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 authoring and human-teaching companion for OpenAdapt workflows. The checked-out code contains a Python engine (capture, review, hosted auth/push, and a bridge to openadapt-flow) wired to a Tauri/React cockpit over a JSON-lines sidecar IPC, plus a loopback socket server for the separately developed tray. It is integrated but Experimental: end-to-end tests mock the capture and flow boundaries, and no supported product release exists.

OpenAdapt compiles demonstrated GUI workflows into deterministic, locally executable programs. Healthy runs make no model calls. When an interface drifts, OpenAdapt re-resolves from retained 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 releases through semantic-release; the experimental Tauri shell's native version is synchronized to each engine release by CI so its desktop-v* prerelease mirrors the engine version it was built from. A native prerelease is packaging evidence, not a separate supported desktop release. The two-lane release policy, supersession rules, and post-signing convergence plan are documented in RELEASES.md.

The current release line gates the updater plugin on configuration presence so packaged installers launch cleanly instead of failing on an empty updater feed. For the authoritative current version, the matching engine wheel, and its native installer prerelease, see the releases page: the newest vX.Y.Z engine release is marked "Latest", and its Experimental native installers ship under the matching desktop-vX.Y.Z prerelease tag.

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 local capture and review components and the hosted-loop verbs. It is not the canonical OpenAdapt quickstart; compile/replay/run/teach delegate to a separately installed openadapt-flow.

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.

Architecture

The boundary is deliberately narrow:

Desktop authoring/teaching UI
        |
        | local IPC (JSON lines over sidecar stdio; token-authenticated
        | loopback socket for the tray)
        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

• openadapt-flow is not bundled with the frozen sidecar. Compile, replay, run, and teach require a separately installed openadapt-flow on PATH and fail with an explicit error without it.
• End-to-end tests mock the capture and flow boundaries. No CI job drives the built UI against a real engine performing a real record -> compile -> replay -> teach loop, so integration is code-complete but not product-validated.
• The frozen openadapt-engine sidecar binary is produced only by CI. A plain dev checkout runs the shell in frontend-only mode and shows the engine as offline.
• Native packages remain Experimental and unsigned; structural install/uninstall success is not evidence of a validated end-to-end workflow.
• Apple Developer ID/notarization and Windows Authenticode are credential-gated and fail closed on partial configuration. Activation (what to buy, which secrets to add, and what each surface may then claim) is documented in docs/CODE_SIGNING.md. The updater and rollback remain disabled pending an independent signing-key lifecycle.
• This repository now serves the tray's loopback IPC contract, but the desktop and the separately developed tray client have not been validated together end to end.

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 shell and frontend.

Native packaging details, verification scope, artifact names, and external signing requirements are documented in Experimental Native Installers; the release-channel policy lives in RELEASES.md.

The main implementation areas are:

engine/       Python capture, review, storage, and legacy adapter code
src-tauri/    Experimental Rust/Tauri shell and sidecar lifecycle 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.