Skip to content
Back to search

jarvis

JARVIS — a voice assistant for Claude Code. Talk to your Mac and he brainstorms a project with you, builds it, and tells you out loud when a Claude Code session needs you. macOS, on your Claude subscription, no API key.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/ethanplusai--jarvis/badge.svg)](/listings/ethanplusai--jarvis)

HTML

<a href="/listings/ethanplusai--jarvis"><img src="/api/listings/ethanplusai--jarvis/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

git clone <your fork of this repo> jarvis
cd jarvis

cp .env.example .env

pip install -r requirements.txt
python -m playwright install chromium    # for read_page / look_at_page

cd frontend && npm install && cd ..

**Fill in the `.env`.** `.env.example` documents the lot; the short version is one required key and three optional ones:

FISH_API_KEY=...            # required, no fallback
# JARVIS_BRAIN_MODEL=sonnet # optional: the brain's model
# FISH_VOICE_ID=...         # optional: a different voice
# USER_NAME=Tony            # optional: what he calls you

**Generate the certificates.** These are not optional:

openssl req -x509 -newkey rsa:2048 -keyout key.pem -out cert.pem -days 365 -nodes -subj '/CN=localhost'

`server.py` serves HTTPS whenever `cert.pem` and `key.pem` sit beside it, and `frontend/vite.config.ts` proxies `/api` and `/ws` to `https://localhost:8340`. Without the pair the backend serves plain HTTP, the dev server's proxy cannot reach it, and every API and WebSocket call through the front end fails with a 500 while the page itself still loads — a confusing way to spend an evening. Generate them once and forget about them.

Then, in two terminals:

python server.py --host 127.0.0.1        # terminal 1
cd frontend && npm run dev               # terminal 2

Open **Chrome** at `http://localhost:5173`, click the page once to allow audio, and speak. The dashboard is at `http://localhost:5173/dashboard.html`.

> **Who can reach it.** `--host` defaults to `127.0.0.1` — this machine only. > Everything JARVIS serves acts with your full authority: `POST /api/runs` > spawns `claude --dangerously-skip-permissions`, `/api/sessions` reads every > Claude Code conversation you have. A strict `Origin` check stands in front > of every WebSocket and every state-changing route, so a web page you happen > to be visiting cannot open `/ws/voice` and speak as you. There is nothing > to configure: the page is same-origin, so the browser sends an `Origin` no > page can forge. > > An `Origin` is only unforgeable when a *browser* sets it, though. Anything > speaking raw HTTP can claim to be the dashboard, so a client with no > `Origin` — a script, the brain's own MCP child — must instead present the > token in `<data-dir>/jarvis/tool-token`, and on the network the loopback > bind is the rest of the answer. `--host 0.0.0.0` still works if you mean > it; set `JARVIS_ALLOWED_ORIGINS` to the address you will actually open the > page at, or the browser will be turned away too. > > This is one of five deliberate trust decisions in this design — see > [What this trusts, and why](#what-this-trusts-and-why) before you run it.

One more thing about Chrome: the microphone permission is scoped to the **origin including the port**. If you restart Vite and it lands on 5174, the grant does not follow, and Chrome will not re-prompt — it just stays denied, silently. If the mic stops working after everything else looks right, check that the port has not moved.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 478 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # JARVIS
  2. **Just A Rather Very Intelligent System — a voice for Claude Code.**
  3. JARVIS is a British butler who sits on top of the Claude Code you already pay
  4. for. You talk to him. He brainstorms a project with you out loud, one question
  5. at a time; when you have settled on something he writes the design down as a
  6. file in your project; then he starts a real Claude Code session on it and
  7. drives it through plan → review → execute. While it runs he watches every
  8. Claude Code session on your machine, and when one of them is stuck waiting on
  9. a human he tells you which one, out loud, without you having to look.
  10. > "Will do, sir."
  11. ![Six seconds of the JARVIS orb while he is speaking, looping. Two thousand
  12. particles hold the shape of a hollow blue sphere, wired together by faint lines
  13. between the ones that drift close enough; a bright rim catches its lower edge.
  14. Through each spoken phrase the sphere swells and brightens and leans towards
  15. you, then falls back and contracts through the pause before the next one, three
  16. times over, while the camera drifts a few degrees around
  17. it.](docs/images/orb-speaking.gif)
  18. *What you actually look at while you talk to him: `frontend/src/orb.ts`,
  19. rendered live. The audio driving the pulse is synthetic — a speech-shaped
  20. envelope fitted to a measurement of the real analyser, not a recording of his
  21. voice — but every pixel is that file running. Regenerate with
  22. `scripts/make_orb_loop.py`.*
  23. ![A twenty-three second walkthrough of the JARVIS dashboard, looping. It opens
  24. on Runs: a red "Needs Attention" panel over a failed run and a timed-out one,
  25. then Active and History, every row carrying the project, the prompt, a status
  26. pill, elapsed time and tokens. A run opens to show its prompt, cost, model and
  27. live transcript. The Sessions tab shows every Claude Code conversation on the
  28. machine grouped by project; clicking a blocked one swaps the right-hand column
  29. from a tally into a red band reading "waiting on you for 51m — permission
  30. prompt", with the question the CLI actually asked quoted underneath. Specs
  31. shows a design document with big numbered sections you answer by voice.
  32. Projects drills into one project's conversations, runs and build progress.
  33. Usage ends on the subscription's two gauges — a five-hour window at 62 per
  34. cent and a seven-day one at 84 per cent.](docs/images/dashboard-walkthrough.gif)
  35. *The whole dashboard, clicked through. Fictional sample data throughout — the
  36. projects, prompts, people and figures in every screenshot on this page are
  37. invented.*
  38. ---
  39. ## What it costs
  40. **No AI API usage, and none is possible.** JARVIS's brain is a Claude Code
  41. process running on *your* Claude subscription — the same login you use in the
  42. terminal. There is no Anthropic API key anywhere on the voice path, and there
  43. is no way to accidentally put one there:
  44. ```python
  45. # claude_env.py
  46. SCRUBBED_ENV_PREFIXES = ("CLAUDE_CODE_", "ANTHROPIC_")
  47. SCRUBBED_ENV_KEYS = {"CLAUDECODE"}
  48. ```
  49. Every Claude Code process JARVIS spawns — the brain and every build — is
  50. launched through `claude_env.child_env()`, which strips **every** `ANTHROPIC_*`
  51. variable out of the environment first. This is deliberate and it is not a
  52. nicety: the CLI silently *prefers* an inherited `ANTHROPIC_API_KEY` over your
  53. login, and `claude auth status` goes on reporting `loggedIn: true` while
  54. billing quietly moves onto the key. So JARVIS removes the key rather than
  55. trusting itself not to pass it. Leave one in your `.env` if you like — the
  56. startup check will warn you it is there, and the brain will still never see it.
  57. ![The dashboard's Subscription panel, measured three minutes ago: a 5-hour
  58. session gauge at 62 per cent that resets at 6:00pm, and a 7-day week gauge at 84
  59. per cent that resets Sunday at 8:00am. Underneath, a note headed "what the CLI
  60. reports": two windows, and no separate per-model
  61. limit.](docs/images/dashboard-usage.png)
  62. *So the number that matters is not a dollar figure — it is how much of your
  63. subscription's two windows is gone. Fictional sample data.*
  64. **The one thing you pay for is [Fish Audio](https://fish.audio/)**, which
  65. gives JARVIS his voice. Be aware there is no fallback: `tts.py` returns
  66. nothing without `FISH_API_KEY`, so JARVIS goes silent and his replies appear
  67. as text in the browser instead. If you would rather use a different TTS, that
  68. is a small, well-isolated file to replace — see *Make it yours* below.
  69. ## What he does
  70. - **Brainstorms out loud.** The conversation is the design phase. He asks one
  71. question at a time, offers two or three approaches, and does not start
  72. anything until you have agreed on one.
  73. - **Writes the design down.** What you agreed goes on disk as
  74. `docs/superpowers/specs/YYYY-MM-DD-<topic>-design.md` *inside the project
  75. being built* — before a single process is spawned. You can read it back by
  76. numbered section and approve it by voice, or open it on the dashboard.
  77. - **Drives the build.** A build is a real `claude -p` session handed a brief
  78. that tells it to write a phased plan, review that plan against the spec,
  79. then execute it task by task under test-driven development, ticking the
  80. plan's checkboxes as it goes. "How far has it got" is answered by reading
  81. those checkboxes, not by guessing.
  82. - **Watches every Claude Code session on the machine** — not just his own. Ask
  83. "which of my sessions are waiting on me?" and he checks live. He can post a
  84. message into one, and answer a permission prompt for one running in
  85. Terminal.app by pressing a single key.
  86. - **Interrupts you when it matters.** A session that needs a human gets said
  87. out loud immediately; a session that merely finished gets batched into one
  88. sentence at the next pause. If nobody has the browser tab open, it becomes a
  89. macOS notification instead.
  90. - **Remembers.** Long-term memory is a folder of plain Markdown files, one
  91. fact per file, with an index the brain always sees. You can read and edit it
  92. in any text editor.
  93. - **Records everything.** Every Claude Code process JARVIS starts is a *run*:
  94. a row in SQLite with its prompt, project, status, token usage and the full
  95. event stream. Watch them live at `/dashboard`.
  96. ![The Runs view of the JARVIS dashboard. A red "Needs Attention" panel holds a
  97. failed run and a timed-out one, with the failure's exit code and error printed
  98. under it. Below that, an Active panel with one run in progress and one queued,
  99. then History. Every row shows the project, the prompt the run was given, a
  100. status pill, how long it took, tokens spent, and the
  101. time.](docs/images/dashboard-runs.png)
  102. *The Runs view. Every Claude Code process JARVIS starts is a row here, with
  103. the prompt that started it. Fictional sample data.*
  104. The dashboard has six tabs — Runs, Sessions, Memory, Specs, Projects and
  105. Usage. Usage shows what your subscription's five-hour and seven-day windows
  106. have left, and who spent it.
  107. ![The Sessions view. On the left, a "Needs You" panel with two blocked
  108. sessions, then every Claude Code session on the machine grouped by project and
  109. labelled needs you, working, shell, idle, gone or unknown. On the right, the
  110. selected session: a red band saying it has been waiting on you for 51 minutes
  111. at a permission prompt, that only your keystroke can answer it, and, quoted
  112. underneath, the question the CLI actually
  113. asked.](docs/images/dashboard-sessions.png)
  114. *Sessions, with a blocked one open beside the list. The reason a session is
  115. stuck is the CLI's own words, not a guess. Fictional sample data.*
  116. ## Requirements
  117. - **macOS.** Terminal control, window listing, screenshots and notifications
  118. all go through AppleScript. There is no Linux or Windows path today.
  119. - **Google Chrome.** Not a preference — a constraint. The microphone uses the
  120. Web Speech API (`SpeechRecognition` / `webkitSpeechRecognition`, see
  121. `frontend/src/voice.ts`), which Firefox has never implemented. There is no
  122. server-side transcription to fall back on.
  123. - **Claude Code, installed and logged in.** `npm install -g
  124. @anthropic-ai/claude-code` (2.1.224 or newer), then run `claude` once and
  125. log in. This is what JARVIS runs on.
  126. - **Python 3.11+** and **Node.js 18+**.
  127. - **A Fish Audio API key.** Required; there is no fallback voice.
  128. ## Setup
  129. ```bash
  130. git clone <your fork of this repo> jarvis
  131. cd jarvis
  132. cp .env.example .env
  133. pip install -r requirements.txt
  134. python -m playwright install chromium # for read_page / look_at_page
  135. cd frontend && npm install && cd ..
  136. ```
  137. **Fill in the `.env`.** `.env.example` documents the lot; the short version is
  138. one required key and three optional ones:
  139. ```env
  140. FISH_API_KEY=... # required, no fallback
  141. # JARVIS_BRAIN_MODEL=sonnet # optional: the brain's model
  142. # FISH_VOICE_ID=... # optional: a different voice
  143. # USER_NAME=Tony # optional: what he calls you
  144. ```
  145. **Generate the certificates.** These are not optional:
  146. ```bash
  147. openssl req -x509 -newkey rsa:2048 -keyout key.pem -out cert.pem -days 365 -nodes -subj '/CN=localhost'
  148. ```
  149. `server.py` serves HTTPS whenever `cert.pem` and `key.pem` sit beside it, and
  150. `frontend/vite.config.ts` proxies `/api` and `/ws` to
  151. `https://localhost:8340`. Without the pair the backend serves plain HTTP, the
  152. dev server's proxy cannot reach it, and every API and WebSocket call through
  153. the front end fails with a 500 while the page itself still loads — a confusing
  154. way to spend an evening. Generate them once and forget about them.
  155. Then, in two terminals:
  156. ```bash
  157. python server.py --host 127.0.0.1 # terminal 1
  158. cd frontend && npm run dev # terminal 2
  159. ```
  160. Open **Chrome** at `http://localhost:5173`, click the page once to allow
  161. audio, and speak. The dashboard is at `http://localhost:5173/dashboard.html`.
  162. > **Who can reach it.** `--host` defaults to `127.0.0.1` — this machine only.
  163. > Everything JARVIS serves acts with your full authority: `POST /api/runs`
  164. > spawns `claude --dangerously-skip-permissions`, `/api/sessions` reads every
  165. > Claude Code conversation you have. A strict `Origin` check stands in front
  166. > of every WebSocket and every state-changing route, so a web page you happen
  167. > to be visiting cannot open `/ws/voice` and speak as you. There is nothing
  168. > to configure: the page is same-origin, so the browser sends an `Origin` no
  169. > page can forge.
  170. >
  171. > An `Origin` is only unforgeable when a *browser* sets it, though. Anything
  172. > speaking raw HTTP can claim to be the dashboard, so a client with no
  173. > `Origin` — a script, the brain's own MCP child — must instead present the
  174. > token in `<data-dir>/jarvis/tool-token`, and on the network the loopback
  175. > bind is the rest of the answer. `--host 0.0.0.0` still works if you mean
  176. > it; set `JARVIS_ALLOWED_ORIGINS` to the address you will actually open the
  177. > page at, or the browser will be turned away too.
  178. >
  179. > This is one of five deliberate trust decisions in this design — see
  180. > [What this trusts, and why](#what-this-trusts-and-why) before you run it.
  181. One more thing about Chrome: the microphone permission is scoped to the
  182. **origin including the port**. If you restart Vite and it lands on 5174, the
  183. grant does not follow, and Chrome will not re-prompt — it just stays denied,
  184. silently. If the mic stops working after everything else looks right, check
  185. that the port has not moved.
  186. ## Connections: bring your own
  187. JARVIS ships connected to nothing, because the useful thing is not our guess at
  188. what you use — it is the door. Any MCP server works. Put its `mcpServers` block
  189. into `data/jarvis/connections.json`:
  190. ```json
  191. {
  192. "mcpServers": {
  193. "notion": {
  194. "command": "npx",
  195. "args": ["-y", "@notionhq/notion-mcp-server"],
  196. "env": { "NOTION_TOKEN": "secret_..." }
  197. }
  198. }
  199. }
  200. ```
  201. That is the block from the server's own README, unchanged. Restart JARVIS and
  202. ask him **"what are you connected to?"** — he answers from what actually
  203. started, names anything that would not start and why, and tells you what it
  204. costs him. (About 250 tokens of his context per tool, on every turn — a
  205. measured figure, and counted against the tools that actually loaded rather than
  206. the ones you meant to load. It is not charged against how much of your
  207. conversation he remembers.)
  208. Your other MCP servers are deliberately ignored. JARVIS runs with
  209. `--strict-mcp-config`, so nothing in `~/.claude.json` or Claude Desktop reaches
  210. him unless you put it in that file yourself — connecting something to JARVIS
  211. should be a thing you did, not a thing you inherited.
  212. Whatever a connected server returns is treated the way a web page is: reported,
  213. never obeyed. You vouched for the server's code when you installed it; you did
  214. not write the ticket, the email, or the shared page it hands back.
  215. See `skills/jarvis-setup/SKILL.md` for the longer walkthrough — including what
  216. to do when a server does not start.
  217. Earlier versions of JARVIS came wired to Apple Calendar, Mail and Notes
  218. instead. Those are gone: they cost three AppleScript permission prompts on
  219. first launch, before you had heard him say anything, for an assistant whose job
  220. is building software. A door you choose is worth more than three we picked.
  221. ## How it works
  222. ```
  223. Microphone → Chrome Web Speech API → WebSocket → FastAPI (server.py)
  224. │
  225. ▼
  226. the brain (brain.py) — ONE long-lived
  227. `claude -p` process on your subscription
  228. │
  229. ┌─────────────────────────────────┼──────────────────────────────┐
  230. ▼ ▼ ▼
  231. speech.py → Fish Audio → speaker MCP tools (jarvis_mcp.py session_watch.py
  232. → POST /internal/tool) (every Claude Code
  233. │ session on the machine)
  234. ▼
  235. RunExecutor → run store (SQLite)
  236. │
  237. ▼
  238. /api/runs + /ws/runs → /dashboard
  239. ```
  240. The brain is **one persistent process**, not a request per turn. Your
  241. transcript is written to its stdin; its reply streams back and is split into
  242. sentences as it arrives, so the first words are already being spoken while the
  243. rest is still being written. It reaches JARVIS's own capabilities as MCP tools
  244. over a stdio channel that forwards to `POST /internal/tool`. The exact set
  245. is the allowlist at the top of `brain.py`, which is the list to read rather
  246. than a number to quote here.
  247. What it does *not* get is a way to act on something it has just read off the
  248. web. A turn that used `WebSearch`, `WebFetch`, `read_page` or `look_at_page`
  249. is refused every acting tool for the rest of that turn, and no acting tool
  250. runs at all unless the turn began with you speaking. Text that arrives from a
  251. web page, a screenshot or another session's transcript is untrusted, and is
  252. treated that way.
  253. Anything spawned as real work goes through one recorded pipeline, and two
  254. invariants hold throughout it:
  255. 1. **A run always reaches a terminal state** — `succeeded`, `failed`,
  256. `timed_out` or `cancelled`. Never stuck in `running`.
  257. 2. **Every state transition is a database write before it is a
  258. notification.** The WebSocket is a cache-invalidation hint, never a source
  259. of truth; the dashboard reconciles against `/api/runs`.
  260. | Layer | Technology |
  261. |-------|-----------|
  262. | Backend | FastAPI + Python (`server.py`) |
  263. | Frontend | Vite + TypeScript + Three.js (voice UI), vanilla TS (dashboard) |
  264. | Communication | WebSocket — JSON messages, base64 MP3 audio |
  265. | Brain | One long-lived `claude -p` process, Sonnet by default, on your subscription |
  266. | Voice | Fish Audio, one request per sentence |
  267. | System | AppleScript — Terminal, Chrome, notifications, screenshots |
  268. | Storage | SQLite for runs and usage; plain Markdown for memory |
  269. ### Key files
  270. | File | Purpose |
  271. |------|---------|
  272. | `server.py` | The server: WebSocket handler, HTTP API, every `/internal/tool` handler |
  273. | `brain.py` | The voice brain — spawning, turns, restarts, context rotation |
  274. | `claude_env.py` | The environment every spawned child gets, including the `ANTHROPIC_*` scrub |
  275. | `jarvis_mcp.py` | Stdio MCP server exposing JARVIS's tools to the brain |
  276. | `speech.py` | Sentence splitting, echo rejection, barge-in, and the queue of everything JARVIS says |
  277. | `tts.py` | Fish Audio synthesis — the whole voice, in one small file |
  278. | `builds.py` | Spec, brief and plan: the pipeline behind a real multi-hour build |
  279. | `specs.py` | The review surface — reading a design back by numbered section, and approving it |
  280. | `run_store.py` | SQLite `runs` / `run_events`, and the six-value status enum |
  281. | `run_executor.py` | Spawns runs and drives each to a terminal state |
  282. | `stream_parser.py` | Pure parsing of Claude Code's stream-json output (no I/O) |
  283. | `session_watch.py` | Watches every Claude Code session on the machine |
  284. | `session_steer.py` | Posts a message into a running session's inbox socket |
  285. | `dialog.py` | Presses one key in the Terminal tab that owns a session |
  286. | `jarvis_memory.py` | Memory as a folder of Markdown files, not a database |
  287. | `jarvis_home/CLAUDE.md` | JARVIS's persona and rules — the file to edit to change who he is |
  288. | `preflight.py` | First-run checks: CLI version, login, Accessibility, Fish key |
  289. | `data_paths.py` | The single source of truth for where JARVIS writes |
  290. | `frontend/src/voice.ts` | Web Speech API, audio playback |
  291. | `frontend/src/orb.ts` | The Three.js particle orb |
  292. | `frontend/src/dashboard/` | The dashboard (vanilla TS, no framework) |
  293. ## What this trusts, and why
  294. Five things below are true on purpose. Each is a trade-off JARVIS's design
  295. made deliberately, not a bug waiting for a fix — know them before you run it.
  296. **A directory name can put words in JARVIS's mouth.** To say *which* session
  297. he means — "hammer in Desktop," not "one of them" — JARVIS composes a voice
  298. name out of directory names and a conversation's title, and accepts up to
  299. ~60 characters of letters, digits, spaces and light punctuation (`,.-/+'`)
  300. in it (`_said_name` in `server.py`; `_plain_phrase` accepts the same class
  301. for a session's `waitingFor`). Anyone who can create a directory on this
  302. machine, or write a Claude Code roster file's `waitingFor` field, can put
  303. those words into a sentence JARVIS speaks aloud. There is no separator, no
  304. `<`, `>`, `"` or `=` in the allowed set, so it cannot forge a whole line or
  305. close a wrapper — only words, never a fake instruction with structure. The
  306. alternative is an assistant that cannot name what it is looking at.
  307. **The taint gate stops action, not persuasion.** Anything JARVIS reads from
  308. a web page, a file, another session, a run, the screen or a connected MCP
  309. server is marked untrusted, and every acting tool is refused for the rest
  310. of that turn — for the two tools that write memory, the rest of that
  311. generation (`_untrusted_content_refusal`, `TAINTING_TOOLS`, `MEMORY_WRITERS`
  312. in `server.py`). This does **not** mean text an attacker suggested is never
  313. acted on — nothing tracks where a sentence in the brain's context came from,
  314. so a suggestion planted by something JARVIS read is still sitting there when
  315. you next speak. It means you have to ask again, in your own words, on a turn
  316. that opened clean. That is the strongest guarantee this design can actually
  317. keep, not a claim that the suggestion is gone.
  318. **Every spawned run has full privileges.** `JARVIS_SKIP_PERMISSIONS`
  319. defaults on, so every run passes `--dangerously-skip-permissions`
  320. (`run_executor.py`) — there is no TTY to answer a permission prompt, so
  321. without it a run hangs forever instead of doing its job. A run is therefore
  322. a full-privilege process on your machine, in whatever directory you pointed
  323. it at, scrubbed only of `ANTHROPIC_*`/`CLAUDE_CODE_*` environment variables
  324. (`claude_env.py`), not of filesystem access. It can write anything you could
  325. write by hand, including the Claude Code session roster and transcripts that
  326. JARVIS himself later reads back as another session's words.
  327. **Loopback is trusted.** Anything on this machine that can present an
  328. `Origin` of `http://localhost:5173` through `5180`, or the API port itself
  329. (`DEV_SERVER_PORTS`, `JARVIS_DEFAULT_HOST` in `web_auth.py`), gets the same
  330. access a browser tab gets — including starting a run — because that is the
  331. same window Vite's own dev-server restarts land in. Any other process on
  332. your machine bound to one of those ports gets it too. `--host 0.0.0.0`
  333. widens the same trust to your LAN and prints a warning when you do it. The
  334. other door is the bearer token in `<data-dir>/jarvis/tool-token`, written
  335. `0600` (`data_paths.ensure_tool_token`) so only your user account can read
  336. it.
  337. **A dropped audio ack degrades hearing for up to 45 seconds.** The browser
  338. acks each chunk of speech as it finishes playing; JARVIS uses that to relax
  339. echo rejection for the one- and two-word replies people actually interrupt
  340. with ("now," "yes"). If the tab crashes or the socket drops, no more acks
  341. arrive, that relaxation stays off, and a short reply matching JARVIS's last
  342. sentence can be discarded as an echo of himself — until the `ack_timeout`
  343. watchdog (45 seconds, `speech.py`) gives up on the chunk and settles it.
  344. Reload the tab if a short answer seems to be getting ignored.
  345. ## Make it yours
  346. This is a starting point, not an appliance. The whole idea is that you clone
  347. it and bend it to what you do. The seams are deliberately obvious:
  348. - **His personality** lives in `jarvis_home/CLAUDE.md` — how he speaks, what
  349. he refuses to say, what he does when he is unsure. It is copied into his
  350. data directory on first run; edit that copy and it is never overwritten, or
  351. edit the template and it ships to a fresh install. If you want something
  352. other than a British butler, this is the only file you need to touch.
  353. - **His voice** is `tts.py`: one HTTP call, sixty-odd lines. Swap in a
  354. different provider, or a local model, without touching anything else.
  355. - **His tools** are the `TOOL_HANDLERS` table in `server.py`, exposed to the
  356. brain through `jarvis_mcp.py` and gated by an allowlist in `brain.py`.
  357. Adding one means writing a handler and naming it in those two places.
  358. - **The look** is `frontend/src/dashboard/theme/` — four CSS files, tokens
  359. first. `frontend/dashboard-preview.html` renders every component on one page
  360. against the real stylesheet, so you can redesign without running the
  361. backend. The screenshots above are renders of that page.
  362. - **The orb** is `frontend/src/orb.ts`, self-contained Three.js.
  363. Contributions are welcome, and the most useful ones are the ones this cannot
  364. do yet: non-macOS system integration, alternative TTS engines, and a mobile
  365. client. Please open an issue before a large PR.
  366. ## Development
  367. ```bash
  368. pytest
  369. ```
  370. That runs the whole suite — around 1,640 tests — and touches neither the
  371. network nor your screen. Nine browser tests are deselected by default because
  372. they visit real URLs and `browser.py` launches Chromium with `headless=False`
  373. on purpose, so they open windows on your desk. Run those deliberately:
  374. ```bash
  375. pytest -m browser
  376. ```
  377. No test spawns a real `claude` process, and none should. `tests/conftest.py`
  378. sets `JARVIS_BRAIN_AUTOSTART=0` for the whole suite.
  379. Everything JARVIS writes — the SQLite database, the memory folder, usage
  380. tracking, the internal tool token — lives under `data/`, which is ignored in
  381. full. Point `JARVIS_DATA_DIR` somewhere else to run an instance without
  382. touching your real data:
  383. ```bash
  384. JARVIS_DATA_DIR=/tmp/jarvis-scratch python server.py --host 127.0.0.1
  385. ```
  386. ## License
  387. Free for personal, non-commercial use. Commercial use requires a license —
  388. visit [ethanplus.ai](https://ethanplus.ai) for inquiries. See
  389. [LICENSE](LICENSE) for details.
  390. ## Credits
  391. Built by [Ethan](https://ethanplus.ai). Runs on
  392. [Claude Code](https://claude.com/claude-code) and
  393. [Fish Audio](https://fish.audio).
  394. Inspired by the AI that started it all — Tony Stark's JARVIS.
  395. > **Disclaimer:** This is an independent fan project and is not affiliated
  396. > with, endorsed by, or connected to Marvel Entertainment, The Walt Disney
  397. > Company, or any related entities. The JARVIS name and character are property
  398. > of Marvel Entertainment.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.