Skip to content

Dodaios is an open-source agent OS for your desktop: it runs your coding agents, browser and apps by voice or chat, on your own machine. Formerly Personal Jarvis.

11.3 KB
Raw Blame

install/ — Quick-install bootstrap

This directory ships the one-liner installer for Dodaios. Users never read these files; they just paste the URL into their shell.

End-user one-liner

# Windows (PowerShell)
irm https://raw.githubusercontent.com/Dodaios/Dodaios/main/install/install.ps1 | iex
# macOS / Linux
curl -fsSL https://raw.githubusercontent.com/Dodaios/Dodaios/main/install/install.sh | bash

When Python 3.11+ and Git are already present, the installer is fully non-interactive. If either is missing, Stage 1 lists both missing items and asks once before using the host's native package manager. It waits, refreshes the current process environment, re-checks both commands, and continues the same install run; no second one-liner is needed. All other setup questions remain in the app's one-time first-launch onboarding.

The installer installs the full profile (design 2026-07-07): everything in the repository — desktop app, telephony, chat channels, local voice models — skipping only what the OS cannot run. It explains each step and launches the app as its last action. Re-running the one-liner updates in place and never re-runs setup. --headless keeps the minimal torch-free base (the tiny-VPS / advanced path).

GUI installs also register Dodaios with the current desktop shell: Windows Search and Installed Apps, Spotlight via a per-user macOS app bundle, or the Linux application menu. The in-app updater and first desktop launch repair these artifacts, and uninstall removes them again. Developer checkouts and headless Linux hosts are deliberately not registered.

On macOS, every launch path enters through the same app bundle so privacy grants stay attached to one identity. The source installer compiles a small native launcher (dodaios/setup/macos_stub_launcher.c) into Dodaios.app (a bundle from before the rename, Personal Jarvis.app, is renamed once), signs it with a per-user code-signing certificate it creates on the first run (macOS asks for the login password once to trust it; grants then survive every rebuild and update), verifies the identity from inside a LaunchServices process, and preserves the bundle unchanged across ordinary updates. Without that certificate the launcher is ad-hoc signed and a rebuild costs one round of re-granting. A separately distributed binary still requires the release pipeline's Developer-ID signing and notarization. The installer stops instead of claiming success if the full profile or app-bundle registration fails.

Apple does not permit an installer to silently grant Microphone, Screen Recording, Accessibility, Input Monitoring or input-control access, so the installer asks for none of them and neither does the first launch. Dodaios asks at the moment a feature you start needs a permission: the first dictation asks for the microphone, the first screen capture asks for Screen Recording, and so on, each through Apple's own dialog or System Settings pane. If you decline, only that one feature is unavailable, with one click to the right System Settings pane (one short toast offers it), and everything else (typed chat included) keeps working. dodaios permissions reset <permission> makes macOS ask again. This is how the app is built to behave; it has not been exercised on a real Mac yet (unverified).

Current cryptography on every architecture

The installer uses cryptography 50.0.2 or newer and AsyncSSH 2.24.0 or newer on every supported architecture. Intel macOS 13+ and Windows ARM64 receive hash-pinned native wheels from the project's supplemental package index; Apple Silicon, Windows x64 and Linux use upstream PyPI wheels. Users do not need Rust or OpenSSL development tools. The full profile and frozen browser helper use the same reviewed builds.

For a manual source checkout, use python scripts/pip_install.py -e '.[full]' to select the supplemental index automatically. A raw pip or pipx install on Intel macOS or Windows ARM64 needs --find-links https://dodaios.github.io/Dodaios/native-crypto/50.0.2-1/simple/cryptography/ (pass it through pipx --pip-args when using pipx).

Maintainers build both native wheels with the Native cryptography wheels workflow, which validates source hashes, native architecture, linked system libraries and security/compatibility contracts. Record the successful artifacts' SHA256 values in packaging/native-crypto.json. Generate the static index with python scripts/native_crypto_index.py --artifacts <downloaded-wheels> --output <pages-checkout> and push it to the native-crypto-index branch, whose Pages workflow verifies the artifact hashes again before deployment. Wait for deployment before regenerating the application locks. Preserve older version directories; never replace a published wheel. A rebuilt wheel needs a new build_revision, even when the upstream version is unchanged. Keep the explicit uv index URL and pipx example in sync, then run the portable matrix and native runtime CI jobs before merging.

Compile from project metadata so uv applies the explicit cryptography source. The output uses a flat --find-links page for pip; a generic extra index would query Pages for every unrelated dependency. The browser sidecar project mirrors its requirements.in, enforced by check_requirements_sync.py.

uv pip compile --universal --generate-hashes --emit-find-links \
  --python-version 3.11 --output-file=requirements.txt pyproject.toml \
  --find-links https://dodaios.github.io/Dodaios/native-crypto/50.0.2-1/simple/cryptography/ \
  --config-file packaging/native-crypto-uv.toml \
  --default-index https://pypi.org/simple --keyring-provider disabled --no-progress --color never
uv pip compile dodaios/assets/browser/pyproject.toml --universal --generate-hashes --emit-find-links \
  --python-version 3.12 --no-header --output-file=dodaios/assets/browser/requirements.lock \
  --config-file packaging/native-crypto-uv.toml \
  --find-links https://dodaios.github.io/Dodaios/native-crypto/50.0.2-1/simple/cryptography/ \
  --default-index https://pypi.org/simple --keyring-provider disabled
uv lock --config-file packaging/native-crypto-uv.toml --default-index https://pypi.org/simple

File layout

File Stage Responsibility
install.ps1 1 Windows bootstrap: Python+Git detect/install/re-check, clone, venv, install rich, exec installer.py.
install.sh 1 macOS/Linux bootstrap: same flow through native package managers, POSIX bash.
installer.py 2 Python orchestrator: full-profile install, model prefetch, worker CLI, desktop registration, launch (last).
README.md docs This file.

Why two stages?

Stage 1 is shell-native because it must work before Python or Git exists. Its prerequisite state machine stays explicitly marked and is exercised directly by unit tests, while Stage 2 remains in testable Python.

Everything that needs branching logic (platform detection, optional extras, error recovery, rich progress UI) lives in installer.py, where we get unit tests, exceptions with tracebacks, and a real argument parser. The trade-off: an extra python install/installer.py step at the end of stage 1.

End-user flags

All flags are forwarded from stage 1 to installer.py:

irm https://.../install.ps1 | iex                  # full profile + launch (setup runs in-app)
irm https://.../install.ps1 | iex -- --no-launch   # install only, no app start
irm https://.../install.ps1 | iex -- --headless    # minimal server mode (torch-free base, no launch)
irm https://.../install.ps1 | iex -- --dry-run     # print plan, do nothing

(--no-wizard and --with-voice-local are still accepted as deprecated no-ops — the installer never runs a terminal wizard anymore, and the full profile already includes the local voice extras.)

The shell syntax for forwarding (-- vs. no separator) depends on the shell and PowerShell version. The safest pattern for ad-hoc testing is to clone manually and call installer.py directly:

git clone https://github.com/Dodaios/Dodaios ~/.personal-jarvis
cd ~/.personal-jarvis && python -m venv .venv
. .venv/bin/activate           # Windows: .\.venv\Scripts\Activate.ps1
pip install rich packaging
python install/installer.py --dry-run

Uninstalling

The normal path is the uninstaller the installer put on disk. It removes the install folder, the autostart entry, and the keychain entries. --dry-run previews, --yes skips the confirmation:

# Windows (PowerShell)
& "$env:USERPROFILE\.personal-jarvis\install\uninstall.ps1"
# macOS / Linux
bash ~/.personal-jarvis/install/uninstall.sh

If that script is missing or refuses to start, the app uninstalls itself. This is the same job without the bootstrap wrapper, and it is the path to use on installs from 1.1.0 and 1.1.1, which shipped an uninstaller that could not run on macOS at all:

# macOS / Linux
~/.personal-jarvis/.venv/bin/python -m dodaios --uninstall
# Windows (PowerShell)
& "$env:USERPROFILE\.personal-jarvis\.venv\Scripts\python.exe" -m dodaios --uninstall

Environment overrides

Variable Effect
JARVIS_INSTALL_REPO Clone from a fork instead of the upstream repo.
JARVIS_INSTALL_REF Install this branch/tag instead of the newest published release (falls back to main when no release can be looked up).
JARVIS_INSTALL_DIR Install to a directory other than ~/.personal-jarvis.
JARVIS_INSTALL_PREREQS ask (default), auto (explicit unattended consent), or never.
JARVIS_PYTHON Use one explicit Python interpreter; the pin is authoritative.
JARVIS_INSTALL_NO_PIP Skip the pip steps (re-run only prefetch / launch).

Each variable in this table also answers to its DODAIOS_ spelling (DODAIOS_INSTALL_DIR, DODAIOS_INSTALL_REF, DODAIOS_PYTHON, ...). When both spellings are set to different values, the DODAIOS_ one is used and the installer names the option.

Local development of the installer

# Syntax-check both shells
bash -n install/install.sh
pwsh -NoProfile -Command "Get-Content install/install.ps1 | Out-Null"

# Lint the Python orchestrator
ruff check install/installer.py
python -m py_compile install/installer.py

# Dry-run end-to-end (no pip, no launch)
python install/installer.py --dry-run --no-launch

Pre-public-release checklist

The one-liner URLs become live the moment the repo flips to public. Before that flip:

  1. Secret scan: git log --all --full-history -p | grep -iE "api[_-]?key|secret|token|bearer" returns no hits in commit content (commit messages are OK if they're abstract).
  2. Strip Maintainer-only paths: data/_final_verdict_runtime/, data/workspace/, data/sessions.db removed from history (consider git filter-repo).
  3. Confirm .env is in .gitignore and never committed.
  4. Smoke-test the one-liner on a clean VM (Win11 fresh box, Ubuntu 22.04 server, macOS).
  5. Flip visibility: gh repo edit Dodaios/Dodaios --visibility public --accept-visibility-change-consequences.

Future work (not in this PR)

  • CI smoke workflow .github/workflows/install-test.yml — fresh runner per platform, fakes API keys, asserts exit code 0.
  • dodaios update console script.
  • A short install URL that redirects to raw.githubusercontent.com.