OpenAdapt Desktop

Lifecycle: Experimental supporting surface. The canonical OpenAdapt workflow engine is openadapt-flow. This repository is not a production desktop application or a supported installer.

OpenAdapt Desktop is the intended authoring and human-teaching companion for OpenAdapt workflows. The checked-out code does not yet deliver that integrated product: it contains a tested Python capture/review CLI plus an unintegrated Tauri shell.

OpenAdapt compiles demonstrated GUI workflows into deterministic, locally executable programs. Healthy runs make no model calls. When an interface drifts, OpenAdapt re-resolves from recorded evidence or proposes a governed repair, and halts when verification fails. Workflow compilation, replay, certification, and repair live in openadapt-flow, not this repository.

Current Status

The Python package and experimental Tauri shell are versioned independently. Those implementation versions do not represent separate supported desktop releases.

Use OpenAdapt Today

Use openadapt-flow for the runnable product loop:

pip install openadapt-flow

openadapt-flow demo-record --out rec
openadapt-flow compile rec --out bundle --name my-task
openadapt-flow lint bundle                                # expected to find demo gaps
openadapt-flow certify bundle --policy permissive        # smoke-policy pass
openadapt-flow certify bundle --policy clinical-write    # expected strict refusal
openadapt-flow replay bundle
openadapt-flow replay bundle --drift theme --save-healed-to healed

The bundled tutorial is runnable but intentionally not certified for clinical writes. A nonzero strict-certification result is the expected refusal boundary, not a setup failure.

Inspect This Repository

The current CLI is useful to contributors evaluating the earlier local capture and review components. It is not the canonical OpenAdapt quickstart and does not compile or replay workflows.

git clone https://github.com/OpenAdaptAI/openadapt-desktop.git
cd openadapt-desktop
uv sync --extra dev

uv run openadapt-desktop doctor
uv run openadapt-desktop list
uv run openadapt-desktop storage

uv run pytest tests -q
uv run ruff check engine tests

Recording requires the operating-system permissions and runtime support used by openadapt-capture:

uv run openadapt-desktop record --task "Inspect capture path"

Do not treat the upload command or optional upload extras as the supported OpenAdapt hosted path. They belong to an earlier capture-data architecture and have not been integrated with current workflow bundles, break reports, or regulated deployment policy.

Intended Architecture

The target boundary is deliberately narrow:

Desktop authoring/teaching UI
        |
        | local authenticated IPC (not implemented here)
        v
openadapt-flow
  record -> compile -> lint/certify -> replay -> halt/repair/teach
        |
        +-> optional hosted control-plane metadata and break reporting

The desktop application should own consent, operating-system permissions, recording controls, inspection, and human teaching. It should not duplicate the workflow compiler or runtime. Those remain in openadapt-flow.

Known Gaps

• The Tauri frontend is not wired to the Python engine.
• The Rust command implementations and sidecar lifecycle are placeholders.
• The Python IPC handler registry is empty.
• No checked-in adapter hands a capture to openadapt-flow for compilation.
• No teaching UI writes a governed repair back to a workflow bundle.
• Native DMG, MSI, and Linux packages are not established release artifacts.
• Apple signing/notarization, Windows Authenticode, updater signing, and rollback are not configured as a supported release channel.
• The separately developed tray client expects a desktop IPC service that this branch does not provide.

Legacy CLI Surface

The Python engine currently exposes these experimental commands:

Raw recordings are local by default. Any egress path still requires careful review of the selected adapter, configuration, logs, and data-classification policy. This repository does not establish a HIPAA-compliant or production-safe deployment by itself.

Development

Prerequisites are Python 3.11+ and uv. Rust, Node.js, and the Tauri CLI are needed only when working on the unfinished shell.

The main implementation areas are:

engine/       Python capture, review, storage, and legacy adapter code
src-tauri/    Experimental Rust/Tauri shell and placeholder sidecar wiring
src/          Experimental WebView frontend
tests/        Python unit and end-to-end tests, largely with mocked boundaries

See DESIGN.md as a historical design reference. Where it conflicts with this status section or with openadapt-flow, this README describes the current public product boundary.

Related Projects

License

MIT. See LICENSE.