Documentation

What JARVIS is.

JARVIS is a self-hosted AI agent runtime written in Rust. It runs the whole agent loop on your machine: the model plans, calls tools that read and write files, run shell commands, search the web, drive headless Chrome and query MCP servers, and streams the trace back to the surface you are using โ€” a full-screen terminal UI, a browser UI or an OpenAI-compatible API. Pipelines are defined once in TOML, and every surface shares them. One binary, one config, no control plane in between.

Linux x86_64 and Windows x86_64 archives ยท account required for downloads ยท your keys, sessions and files never leave the host.

jarvis.123beta.net/web
Refactor the deploy script to keep the previous binary and roll back when health fails.
๐Ÿง  Reasoning

Reading the current script first, then I'll split install and health-check into separate steps.

๐Ÿ› ๏ธ read_filescripts/jarvisDeploy.shdone
๐Ÿ› ๏ธ edit_filescripts/jarvisDeploy.shrunning

The previous binary is copied to .deploy/jarvis.prev before the swap, and the unit is restarted only afterโ€ฆ

Message JARVISโ€ฆโ†‘
Web UI โ€” streaming answer with reasoning and tool-call blocks.
7runtime modes
2model protocols + MCP
1static binary to deploy
0hosted dependencies

One agent runtime, every surface.

JARVIS is not a chat wrapper. It owns the loop: it assembles context, picks a model, parses tool calls, executes them under the permissions you configured, feeds the results back and repeats until the turn is finished. The same loop powers the TUI, the browser client, the API, the mail pipe and the scheduler, so a pipeline behaves identically wherever it is invoked.

Everything the agent learns is local state: sessions, tool output, metrics and the model arena live in one SQLite database. Nothing is proxied through a hosted control plane, and only the model request itself leaves the host.

๐Ÿง 

Multi-model routing

Chain providers with provider:model;provider:model. A failed model falls through to the next, with per-key circuit breakers and a cost/quality router catalog.

๐Ÿ› ๏ธ

Real tool execution

Read, write and edit files, run shell commands, search the web, drive a browser, call MCP servers and query language servers for diagnostics and references.

๐Ÿ–ฅ๏ธ

Terminal UI

A 60 FPS Ratatui interface with streaming reasoning, tool-call blocks, session restore, a file explorer, an editor tab and an integrated terminal.

๐ŸŒ

Browser UI

A Yew/WebAssembly client with streaming chat, task and session previews, themes and a mobile layout. It signs in with a cookie issued by the same API key.

๐Ÿ”Œ

API, both dialects

Drop-in /v1/chat/completions for OpenWebUI, LibreChat and friends, plus a native SSE /chat that streams tool calls and reasoning.

๐Ÿ“ฌ

Mail and schedules

Process tasks from a Maildir, run condition-and-action cron jobs, and send Gmail messages or manage Google Tasks with the built-in OAuth tools.

jarvis ยท TUI
โ•ญโ”€ JARVIS โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ•ฎ
โ”‚ model claude-sonnet-4-6  effort high โ”‚
โ•ฐโ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ”€โ•ฏ
โฏ audit the API middleware for SSRF

๐Ÿง  thinkingโ€ฆ checking the browser page guard
๐Ÿ› ๏ธ grep "allow_private_hosts"   โœ“ 4 hits
๐Ÿ› ๏ธ read_file src/core/src/server/web_browser.rs
โœ“ Private ranges are rejected unless the
  operator opts in. One gap: redirects are
  followed after the first host check.
โ–
TUI โ€” the same run with the full tool trace and no browser.
three surfaces, one binary
# terminal
jarvis

# API server
jarvis --serve        # 127.0.0.1:8080

# browser UI
jarvis --serve-web    # 127.0.0.1:8081

# one-shot / CI
jarvis -p "review the diff" --json

# OpenAI-compatible clients
curl http://127.0.0.1:8080/v1/models \
  -H "Authorization: Bearer $JARVIS_KEY"
The TUI, the web UI and the API are modes of the same binary.

Interface previews drawn with the site's own stylesheet. The live web UI ships in every archive and is served under /web/.

Install

Download an archive from the download page, unpack it and run the binary. The archive contains jarvis (or jarvis.exe), the wasm bundle in pkg/, both example configs and a VERSION file. Downloads need a site account: create one or sign in. Forgot-password links are emailed and expire after one hour.

tar xzf jarvis-<version>-linux-x86_64.tar.gz
cd jarvis-<version>-linux-x86_64
cp config/config-api-example.toml config-api.toml
cp config/config-api-example.toml config-web.toml   # web UI; keep api_key in sync
./jarvis --serve --config config-api.toml

The TUI is the same binary: run ./jarvis from the unpacked directory. Building from source needs a Rust toolchain; the web UI additionally needs the wasm32-unknown-unknown target and wasm-bindgen-cli 0.2.100.

cargo build --release --bin jarvis
scripts/jarvisBuild.sh --web      # rebuild pkg/

Verify the download. Every release publishes SHA256SUMS beside the archives; check an unpacked file with sha256sum -c SHA256SUMS. The binary is static for the Linux target, so there is no runtime to install.

Modes

ModeCommandListens on
TUIjarvisโ€”
One-shot / CIjarvis -p "โ€ฆ"โ€”
APIjarvis --serve127.0.0.1:8080
Web UIjarvis --serve-web127.0.0.1:8081
Presentation sitejarvis-site (standalone crate)127.0.0.1:8082
Mail pipejarvis --watch-maildirโ€”
Cronjarvis --cronโ€”

One-shot mode supports --json, --show-thinking and --include-tool-output, so the same agent loop can run from a script or a CI job. The public deployment runs each long-lived mode as its own systemd unit; the presentation site is a separate binary, not a mode of jarvis. A UI change never restarts an in-flight agent turn, and an API restart never takes the site down.

Pane focus. Shift+Tab cycles the focus ring forward through the open file explorer, the active editor-area pane (a file buffer or /terminal shell) and the prompt. The editor area is independent of the explorer: /terminal opens at the top even with /fe closed, and hiding the explorer leaves the editor and terminal visible. A focused file editor keeps Tab for indentation and a focused shell keeps Tab for its own input; use /m for the model picker. F2 zooms a docked terminal and F3 moves it into a resizable right-hand column. The /info sidebar is independent: when it is open, the right terminal sits immediately before it and the sidebar keeps its place.

Configuration

There is no single config.toml. The TUI reads config-tui.toml; the API reads config-api.toml; the standalone web UI reads config-web.toml (override with --config). Keep the same [server] api_key in the API and web files so the signed session cookie is accepted across both. Both examples are complete, commented references: every key carries its default, and both are published at /releases/config-api-example.toml and /releases/config-tui-example.toml after sign-in, and inside every archive. Global settings must appear before the first [section] header. The remote /browser page is served by the API process, so [browser] executable belongs in config-api.toml as well; having it only in config-tui.toml leaves the link with a 503.

# global settings: credentials, context, tools
context_files = ["/srv/rules/*.md"]
skill_files   = ["/srv/skills/*/README.md"]
agent_files   = ["/srv/agents/*.md"]
task_dir      = "/srv/tasks"
mcp           = "/srv/mcp.json"
marketplace_url = "https://jarvis.example.com/marketplace"

[server]
host = "127.0.0.1"
port = 8080          # API
web_port = 8081      # web UI
api_key = ""         # required once the API is public
cors_origins = [""]

[database]
path = "global"      # "global", "local" or a file path
auto_cleanup_days = 30

task_dir powers the /task browser and the /tasks API; each subfolder needs a markdown file with YAML frontmatter declaring name. scripts_dir (with the [Script] marker) powers /scripts. Auto-discovery also finds files tagged [Context], [Skill] and [Agent] in the working tree.

The presentation site you are reading is a separate crate and reads only its own environment: JARVIS_SITE_ADDR, JARVIS_SITE_RELEASES_DIR, JARVIS_SITE_DB and the public URL / mail settings used by password resets. It never reads either config file.

Providers & fallback

A provider is defined once and referenced as provider:modelId. Separate models with ; to build a fallback chain: a 429, 5xx or transport error moves to the next entry. alternate_on_failure controls whether the chain advances on a model error or only on provider trouble.

[[providers]]
name = "OpenRouter"
provider = "openai"
base_url = "https://openrouter.ai/api/v1"
api_key = "sk-โ€ฆ"
# api_keys = ["key-1", "key-2"]  # per-key circuit breakers, tried in order

[[models]]
name = "Premium"
model = "openrouter:deepseek-v4-pro;byteplus:kimi-k2.5"
stream = true
temperature = 0.5
max_tokens = 16384
system_prompt = "You are a precise coding agent."

A provider may rotate several keys with api_keys. Each key is a separate credential with its own circuit breaker; every key is tried before the chain falls back to another provider.

Per-pipeline access keys. [server].api_key is the master key. Give a [[models]] or [[routers]] entry its own access_key and that key can select that pipeline and nothing else. Entries without one are master-only. Issue one key per client with openssl rand -hex 24; a leaked relay key cannot reach pipelines with write_file or execute_command.

Harness providers

JARVIS can put an installed vendor agent CLI under the same TUI, model picker, fallback chain and API server as its HTTP providers. These harnesses need no api_key in the config: install the CLI, authenticate it once, and reference it like any other provider.

ProviderBinaryAuthentication
antigravity-cliagyagy login
cursor-cliagentCursor CLI login, or CURSOR_API_KEY
copilot-clicopilotGitHub Copilot CLI login
[[providers]]
name = "AntigravityCli"
provider = "antigravity-cli"  # binary: agy

[[providers]]
name = "CursorCli"
provider = "cursor-cli"       # binary: agent

[[providers]]
name = "CopilotCli"
provider = "copilot-cli"      # binary: copilot

[[models]]
name = "Antigravity CLI"
model = "AntigravityCli:gemini-3.8-flash-low"

[[models]]
name = "Cursor Agent"
model = "CursorCli:auto"

[[models]]
name = "Copilot"
model = "CopilotCli:auto"

Binary discovery. Keep the CLI on PATH, or override the lookup with ANTIGRAVITY_CLI_PATH, CURSOR_AGENT_PATH or COPILOT_CLI_PATH. Model ids must be ones the CLI exposes: use agy models for Antigravity, agent --list-models for Cursor, and the model list in the Copilot CLI. A turn is streamed into the normal session, so the transcript, model picker and API behave like any other pipeline.

Limitations. The CLI must be installed and logged in. It runs its own tool loop, so JARVIS tools (read_file, write_file, execute_command, spawn_agent, ...) are not passed to it, and allowed_tools/denied_tools do not restrict its tools; use the vendor's permission flags. One turn returns the CLI's final text, not JARVIS tool calls, so completion detection is relaxed. Token usage and cost are usually unreported. The CLI runs with your user's permissions in the current directory; the vendor's model list, quota, rate limits and terms apply, so sandbox or limit it with the vendor's own controls when needed.

Gateway mode. Set base_url to an OpenAI-compatible gateway and the same provider behaves like a normal chat model instead of spawning the CLI. This is useful when the harness should go through a proxy or a shared gateway.

Routing & catalog

[[routers]] turn model choice into a policy. For every turn the router ranks the enabled catalog models by quality, cost, quota and latency, then picks a model and a reasoning effort for the task band. /catalog is where the catalog is curated.

[[routers]]
name = "The Mind Weaver - Auto"
profile = "auto"                 # auto | cheapest | fastest | strongest | free
orchestrator_quality = [55, 80]  # 0โ€“100, the model that answers you
agents_quality = [30, 80]        # 0โ€“100, spawn/swarm/planner workers
cost = [0.1, 1.0]                # USD per 1M output tokens
min_headroom_percent = 18
fallback_models = "OpencodeGo:mimo-v2.6-pro;OpencodeGo:glm-5.3-flash"
denied_tools = ["write_file", "edit_file"]
complexity_trivial = "fastest"
complexity_simple = "cheapest"
complexity_moderate = "balanced"
complexity_complex = "strongest"
complexity_deep = "strongest"
effort_trivial = "none"
effort_simple = "low"
effort_moderate = "medium"
effort_complex = "high"
effort_deep = "high"

Models outside the quality or cost range are never used. A model set to only pins the orchestrator and skips those bounds. If nothing qualifies, fallback_models runs; without it the turn stops and names the range that matched nothing.

In /catalog, Space enables a model, a/A toggles the whole list, Tab switches enabled/disabled, o sorts by a column, and Enter opens one model's stats. You can type missing scores, cycle reasoning_effort, max_tokens and total_token_limit, and set a behaviour: default, disabled, orch, agent, planner, coder, reviewer, QA or only. The router also staffs the side roles: spawn_agent, swarm, smart_edit, planner, vision, follow-up, prompt refiner, context pruner and embeddings.

The optional [classifier] side model ranks a prompt before the router picks a model; without it the keyword rank is used and no LLM call is made.

Arena & health

Every model call is recorded: success or failure, error class, TTFT, wall duration, tokens, cache hits and quota. The TUI shows the table with /arena; HTTP clients read the same aggregation from GET /models/health (and /models includes health data).

The router consumes those measurements as reliability and latency signals, so a model that has been failing stops being picked before its provider is formally down. The arena log lives in the same SQLite database as sessions.

TUI

/arena โ€” sortable per-model stats, last error, uptime and cache rate.

HTTP

GET /models/health โ€” the same rows as JSON for dashboards and monitors.

Skills & agents

Three kinds of injectable knowledge, each with a different lifecycle:

TypeAlways active?Activated byPurpose
Context fileYesAutomaticPersistent project knowledge, rules and specs
SkillNoLLM via /skill runInvokable runbook or helper script
AgentNoUser via /agent, or delegationSwappable persona or specialist worker

Skills live in markdown files with YAML frontmatter (name, description, example). The metadata is parsed into the system prompt as a menu; the model reads the skill's README before running it instead of guessing its commands. Agents are enabled per conversation with /agent <name>, and /agent disabled turns the persona off.

[[agents]] entries are the delegation registry: each one is a worker pipeline that spawn_agent and swarm_plan can hire by name. Chat models in [[models]] are not offered as workers. A name passed to spawn_agent resolves an agent before a chat model.

# global
context_files = ["PROJECT_SPECS.md"]
skill_files   = ["/srv/skills/*/README.md"]
agent_files   = ["/srv/agents/*.md"]

[discovery]
context_tag = "[Context]"
skill_tag   = "[Skill]"
agent_tag   = "[Agent]"
max_depth   = 3

[[agents]]
name = "Elite Builder"
description = "Primary coding agent: multi-file features, refactors and architecture"
model = "openrouter:deepseek-v4-pro;byteplus:kimi-k2.5"
stream = true

TUI commands: /skills list, /skill run <name>, /agents, /agent <name>, /reload to rescan.

Marketplace

The built-in marketplace installs skills and agents from any registry you host. Set marketplace_url at the top level of the config, open /marketplace in the TUI and install what you need: arrow keys move, Space installs or removes, and choices persist across restarts. There is no vendor account and no remote index owned by JARVIS โ€” the registry is a folder you control.

jarvis ยท /marketplace
skill ยท release-checkoutinstalled
skill ยท incident-postmortempress space
agent ยท Elite Builderinstalled
agent ยท Docs Reviewerpress space
Marketplace โ€” skills and agents installed from the registry you host.

The registry is a JSON document with skills and agents arrays, served at <marketplace_url>/registry.json, with the files beside it under skills/ and agents/. This deployment publishes its own at /marketplace/registry.json, so a new skill is one file plus one registry entry.

marketplace_url = "https://jarvis.example.com/marketplace"
# registry:  /marketplace/registry.json
# payloads:  /marketplace/skills/<id>/โ€ฆ, /marketplace/agents/<id>/โ€ฆ

An install copies the payload into the configured skills or agents directory and records it, so the same entry can be removed again from the same screen. Because the payload is a plain markdown file, reviewing what you install is reading one README.

Side models

Cheap, specialised models run around the main turn instead of inside it. Every section takes the same provider:model chain syntax; a failure falls through to the next hop.

SectionRoleTrigger
[follow_up]Three next-step suggestionsAfter each answer
[prompt_refiner]Rewrite a vague promptAlt+P in the TUI
[context_pruner]Summarise old historyToken threshold or context limit
[planner]Architect plan before executionplanner tool
[classifier]Rank a prompt for the routerBefore routing, if enabled
[smart_edit]Natural-language file editingedit_file / smart_edit
[vision_agent]Describe an imageread_image
[embeddings]Vectors for search and retrievalIndexing and /search
[follow_up]
enabled = true
model = "google:gemini-3.7-flash;openrouter:openrouter/free"

[prompt_refiner]
enabled = true
model = "google:gemini-3.7-flash"

[context_pruner]
enabled = true
model = "google:gemini-3.7-flash"
token_threshold_percent = 70
blocking_threshold_percent = 80
preserve_recent_turns = 20

[planner]
enabled = true
models = "google:gemini-3.7-flash"
planning_timeout = 180

[embeddings]
enabled = true
model = "nvidia:nvidia/nemotron-3-embed-1b;google:gemini-embedding-2"
top_k = 16
min_similarity = 0.30
session_search = true
context_retrieval = true

Each entry also accepts alternate_on_failure, reasoning_effort, temperature, max_tokens and a system_prompt, exactly like a main model. Side models do not appear in the routed catalog.

Swarm

Swarm is DAG-based parallel delegation. The leading model submits a plan of worker tasks with dependencies; workers start immediately in the background and results stream back into the conversation. Four tools appear only while the feature is on: swarm_plan, swarm_status, task_result and cancel_task.

[swarm]
enabled = true
max_tasks_per_plan = 16      # hard cap: 32
max_total_tasks = 64         # per session, 0 = unlimited
max_active_tasks = 32
result_inline_limit = 2000
total_timeout_secs = 300
max_consecutive_failures = 3

Workers are regular sub-agents: they share the process-wide max_concurrent_sub_agents cap, cannot call execute_command and cannot spawn recursively. If the model tries to end its turn while workers are running, the turn waits for them without another LLM hop, then the model synthesises the results. A failed-worker latch stops new plans after N consecutive failures; a new user message or /cancel clears it.

spawn_agent remains the lightweight path for one focused task; smart_edit is the bounded single-file editor behind natural-language edits.

MCP tools

Jarvis is an MCP client. Point mcp at a JSON config and every server's tools are registered next to the built-in ones, for every provider. Both stdio commands and HTTP/SSE endpoints are supported; a slow server is skipped after mcp_handshake_timeout_secs without blocking startup or the other servers.

# config-tui.toml / config-api.toml
mcp = "/srv/mcp.json"
mcp_handshake_timeout_secs = 15
// /srv/mcp.json
{
  "mcpServers": {
    "fetch":  { "command": "npx", "args": ["-y", "mcp-fetch-server"] },
    "sqlite": { "command": "uvx", "args": ["mcp-server-sqlite", "--db-path", "app.db"] },
    "remote": { "url": "https://mcp.example.com/sse" }
  }
}

Gemini models get a sanitised copy of each schema: unsupported OpenAPI keywords are stripped, unions are flattened, nullable types normalised and function identifiers made API-safe. That is what keeps third-party MCP servers usable on Google's function-calling endpoint. Servers connect at startup, so editing mcp.json needs a restart.

Built-in tools

Tools are grouped by capability and filtered per pipeline with allowed_tools / denied_tools. File and shell access is confined to the working directory unless --allow-outside-working-dir is set.

Files

read_file, write_file, edit_file, list_files, glob, grep, read_image

Code intelligence

lsp_diagnostics, lsp_goto_definition, lsp_find_references, lsp_hover, lsp_document_symbol โ€” language servers start lazily and are reaped on shutdown.

Execution & web

execute_command, wget, online_search (DuckDuckGo), brave_tavily_search (AI-optimised search), headless Chrome through /browser.

Planning & delegation

think, todo_write, planner, spawn_agent, smart_edit, the swarm tools, ask_user.

Google Workspace

Gmail inbox/read/search/send/labels; Google Tasks CRUD and search; Drive list/read/upload/update/delete/share/permissions/shortcuts; Google Analytics properties and reports.

Media & messaging

generate_image, /media/analyze, optional WhatsApp tools (wa_reply_with_voice, memory, reports) and the sentinel remote bridge.

Memory, tasks & search

Sessions, metrics and the arena log live in SQLite ([database] path = global, local or an explicit file). Sessions are restored from the TUI or the web UI; GET /sessions and GET /sessions/<id> expose the same data over HTTP.

Tasks. task_dir points at a folder of task folders. Each task has a markdown file with YAML frontmatter (name, project, description, priority); activating it injects its files as context. The TUI browses them with /task, the API with GET /tasks, GET /tasks/<name> and the task-session binding routes.

Search. With [embeddings] enabled, context, tasks and sessions are indexed. /search then combines vectors with SQLite full-text search, and context_retrieval adds a per-turn top-k snippet of the best-matching task chunks on top of the whole-folder injection. session_search is purely additive and can be enabled without changing context behaviour.

API

Authentication is Authorization: Bearer <key> on the OpenAI-compatible routes and X-API-Key: <key> on the native routes. The web UI presents the same key as a signed, HttpOnly session cookie.

EndpointMethodPurpose
/v1/chat/completionsPOSTOpenAI-compatible chat (streaming and tools)
/v1/modelsGETOpenAI model list
/v1/images/generationsPOSTOpenAI-compatible image generation
/v1/agents ยท /agentsGETDelegation registry
/chat ยท /chat/resume/<id>POST/GETNative SSE with tool calls, reasoning and fallback events
/ws/liveGETBidirectional live voice/vision stream
/models ยท /models/healthGETPipelines with health/arena data
/sessions ยท /sessions/<id>GET/DELETEList, restore or delete a session
/tasks ยท /tasks/<name>GETTask browser and task context
/tts ยท /media/analyzePOSTSpeech synthesis and media analysis
/upload ยท /browserGETToken-authorised upload and remote-browser pages
/healthGETLiveness, version, model count
curl http://127.0.0.1:8080/v1/chat/completions \
  -H "Authorization: Bearer $JARVIS_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"Coder","messages":[{"role":"user","content":"List the Rust files"}]}'

Open WebUI and LibreChat can use the OpenAI route directly. A Pipe that calls /chat can surface tool calls, reasoning and fallback events in real time. When one integration should not reach everything, give its pipeline an access_key instead of the master key.

Web UI

The browser client is Yew compiled to WebAssembly and served by the API host under /web/. Start it with jarvis --serve-web (or --serve, which serves both). It signs in with the API key, receives a signed HttpOnly cookie, and keeps the agent's telemetry visible while it works: streaming answers, reasoning blocks, tool calls and results, model fallback and session status.

jarvis ยท web workspace

Sessions

Deploy rollback SSRF audit Marketplace registry

Tasks

Release 0.1.3 Docs review
Which sessions touched the deploy script?
๐Ÿ› ๏ธ search_sessionsjarvisDeploy.sh2 hits

Two sessions: the rollback change on this one, and Friday's health-check review.

Message JARVISโ€ฆโ†‘
Web UI โ€” session and task sidebar beside the same streaming chat.

Chat

Streaming SSE, markdown, tool blocks, reasoning toggle, message history, prompt refinement.

Workspace

Session restore and search, task previews, file uploads, themes and a mobile layout.

Remote browser

/browser streams a headless Chrome session into a normal tab, with signed links and private-host refusal.

Static assets

The wasm bundle, manifest and stylesheets are served from the same origin; no CDN and no Node build at runtime.

In the public deployment the app is behind the host's htpasswd gate; the documentation keeps it out of the main navigation on purpose. The archive in /download contains the same bundle, so a self-hosted install serves it without a gate of its own unless you add one.

Mail, cron & Google

Mail pipe. --watch-maildir polls a Maildir every 10 seconds. A new message is parsed, matched against an [[email_pipe]] entry (address, allowed senders, model) and processed by that pipeline. --email-pipe handles a single .eml from stdin for aliases and pipe integrations.

Cron. --cron is a long-running scheduler with a 60-second tick. Each [[cron]] job has an optional natural-language condition (the agent investigates but may not send) and an action that composes and sends the email. With no jobs configured the scheduler stays alive in idle mode rather than exiting.

Google. OAuth is managed with jarvis --google-auth, --google-status and --google-revoke. Credentials in [google] unlock Gmail, Tasks, Drive and Analytics tools, and the cron sender inherits them.

Security

The default posture is local-first: one binary, credentials and sessions on your host, no control plane in between.

Least privilege

File and command tools are confined to the working directory; --allow-outside-working-dir lifts it deliberately. Per-pipeline allowed_tools / denied_tools narrow a client further.

Credential isolation

Per-pipeline access_keys mean a leaked integration key cannot select a pipeline with shell or write access. The master key is never required by clients.

Network guards

Signed /browser and upload links are token-scoped. The browser refuses loopback, private/LAN and cloud-metadata targets unless allow_private_hosts is set.

Edge gates

The web UI and the legacy /downloads folder use htpasswd. Release downloads use self-service site accounts: Argon2 password hashes, opaque HttpOnly sessions and single-use reset links. The API uses key auth.

Secrets

Config files hold API keys. Keep filled-in copies out of version control and restrict their permissions; the examples are safe to share.

Deploy

Each long-lived mode has its own unit, so failures and restarts stay local:

UnitCommandSurface
jarvis-apijarvis --serve127.0.0.1:8080 โ†’ /api
jarvis-webjarvis --serve-web127.0.0.1:8081/web โ†’ /web
jarvis-sitejarvis-site (standalone)127.0.0.1:8082 โ†’ /
jarvis-mailjarvis --watch-maildirMaildir poller
jarvis-cronjarvis --cronScheduler

Apache sends the longest matching prefix to the right process: /api and /ws to the API, /web to the shell, /downloads and /marketplace straight from disk, and everything else to the presentation site. That includes /releases: archives are served by the site so it can enforce the account session. Deploy scripts build the checkout, install the binary, refresh the unit and verify the public URLs.

scripts/jarvisBuild.sh --server --web   # build
scripts/jarvisDeploy.sh                 # API host
scripts/jarvisSiteDeploy.sh             # presentation site only
scripts/jarvisRelease.sh --package-only --windows
                                        # archives + SHA256SUMS into public_html/releases

Download the latest archives from your account, or start with the install steps above.