Imps is a Rust runtime for small, personal AI assistants (“Imps”). The desktop application is an adapter to that runtime and its application boundary, not the product boundary.
The workspace contains eleven Rust library/CLI packages plus the desktop Tauri package. Core Phase 3 MVP is complete. The imp CLI validates portable definitions; imports, lists, exports, and deletes durable definitions; runs a file or stored definition with a configured OpenAI-compatible chat-completions endpoint; and manages native credentials. The desktop creates, imports, lists, views, explicitly replaces, deletes, and runs text Imps from its app-data SQLite database; it also manages its provider settings and native credentials.
Portable definitions are durable. The desktop's single non-secret provider profile is app-data configuration, not a portable definition or a durable provider domain. There is no workflow engine, visual graph, non-text input, additional provider adapter, streaming or cancellation, execution history or memory, daemon IPC, dynamic/WASM plugin loading, marketplace, cloud sync, or packaged Windows/Linux validation.
imp-application::ExecutionService is shared by CLI and desktop. It owns request, artifact, and correlation UUID construction and runtime invocation; adapters explicitly register the provider, grants, configuration, and credential resolver. DefinitionCatalog provides adapter-independent definition-catalog use cases over an injected repository. Tauri v2 + React/TypeScript is isolated in apps/desktop; it does not add a Tauri dependency to application, runtime, or domain crates.
See the architecture overview.
| Crate | Responsibility |
|---|---|
imp-domain |
Domain types and invariants |
imp-storage |
Engine-independent definition repository contract |
imp-application |
Adapter-independent definition catalog and shared execution service |
imp-storage-sqlite |
SQLx/SQLite definition repository adapter and migrations |
imp-plugin |
Versioned plugin manifest, traits, and DTO contracts |
imp-secrets |
Owned OS-native credential-store adapter |
imp-events |
Event contracts |
imp-runtime |
Lifecycle and execution orchestration |
imp-config |
Configuration parsing and validation |
imp-provider-openai-compatible |
OpenAI-compatible provider adapter |
imp-cli |
Command-line adapter |
| Application | Responsibility |
|---|---|
imp (imp-cli) |
Validation, catalog management, native credential management, and execution |
apps/desktop |
Tauri v2 desktop MVP: text catalog, settings, credentials, and execution |
Run these commands from the repository root:
cargo fmt --all --check
cargo check --workspace --all-targets
cargo clippy --workspace --all-targets -- -D warnings
cargo test --workspaceDesktop development requires Node.js and npm in addition to the Rust toolchain. From apps/desktop:
npm install
npm run check
npm run build
npm run tauri -- dev
npm run tauri -- build --debug --no-bundleNever put API keys or other secrets in Imp definitions or profile files. The desktop provider profile is non-secret app-data configuration. A text Imp's credential reference is optional: no reference sends no Authorization header, for credential-less loopback endpoints; a reference resolves a Bearer credential from the OS-native store under service imps. CLI profiles also support strict none for credential-less definitions, alongside environment and native. Native credential management supports set, existence checks, and deletion only; it has no reveal, list, or export command. Credential input is read twice from the controlling TTY with echo disabled. Wrapped credential values are zeroized on drop where supported; this is not a claim of perfect memory secrecy.
Linux native credentials require a working desktop Secret Service and session bus; headless environments can report the store as unavailable. There is no plaintext fallback. Database paths are explicit: the CLI has no default database path and does not create parent directories.
The desktop database is private app-data state (definitions.sqlite); its non-secret provider-profile.json is written atomically there. Desktop import accepts only canonical regular, non-symlink JSON or TOML files selected with the native open dialog. The main window receives only dialog:allow-open; tray, shortcut, and window actions stay in Rust. Its CSP permits self content and IPC only, with no remote assets or content.
From apps/desktop, run npm install once, then npm run tauri -- dev. On first launch, open Settings, enter a permitted provider endpoint, request options JSON, and timeout; create a text Imp and run it with Ctrl/Cmd+Enter. Use an optional credential reference plus the native credential controls for an authenticated remote endpoint; leave it blank only for a loopback endpoint that intentionally needs no authentication. See the desktop MVP guide for the complete setup and troubleshooting flow.
Use explicit paths and placeholders; do not put secret values in commands or files.
imp validate <definition-file>
imp definitions import <definition-file> --database <database-file>
imp definitions list --database <database-file>
imp definitions export <definition-id> --database <database-file>
imp definitions delete <definition-id> --database <database-file>
imp credentials set <credential-reference>
imp credentials exists <credential-reference>
imp credentials delete <credential-reference>
imp run <definition-file> --profile <profile-file> --text <input-text>
imp run --stored <definition-id> --database <database-file> --profile <profile-file> --text <input-text>