README
¶
Run Claude Code and Codex on your own servers. They keep working with the laptop closed,
you answer them from your phone, and you see what each one is doing and what it costs.
Features · Quick start · Hub · Releases · Compared · Docs · Contributing
curl -fsSL https://raw.githubusercontent.com/ly-solutions/harnessly/main/install.sh | sh
One command for Linux and macOS: the latest signed release, checked, started as a service of your account on http://127.0.0.1:8022. Then open the page and choose your password. Other ways · how it compares.
harnessly is a workspace where people and coding agents work side by side. Claude Code and Codex run as the real CLIs in tmux panes on your machines, next to your repositories and tools, and keep running when nobody has a page open. harnessly knows what each agent is doing and serves it through one HTTP and WebSocket API and a web UI. It is a Go runtime plus a machine agent on the user's machine (small static binaries, no cgo), a web UI compiled into the runtime, and an optional hub for teams: sign-in, spaces, and machines connected through one address.
Features
Agents and chats
- Claude Code, Codex and plain shells in tabs on the runtime's own tmux server. A terminal socket attaches a pty to any of them.
- Live tab states (
busy,needs-input,ready-for-review, ...), derived from the agent's hooks, status line, transcript, screen and process tree and pushed to every client. - Conversations: a timeline over the agents' transcripts (turns, tool runs, plans, questions), subagents, token and cost economics, turn checkpoints as git snapshots. The composer takes slash commands, files, context and dictation.
- Prompt delivery through a per-tab queue; launch and resume of agents after a restart; Claude agents idle for too long are stopped to free memory and resumed by the next prompt.
- Usage statistics and provider limits with a forecast, from the transcripts.
- Agents can start, brief and read other agents in new tabs with the
harnesslycommand line tool (harnessly tab ...,harnessly peers).
Files, changes, terminal and browser pane
The right pane of a conversation holds a terminal, a file editor, changed files and diffs, a browser for the machine's dev servers (a reverse proxy with a DevTools record that agents read through an MCP server), documents and boards (integrations), GitHub and GitLab, subagents and the session's cost. Agents can open a tab of the pane for you.
Sinopia Design
A design space for prototypes, sites and presentations. Every design is a plain folder on your machine, with its page model, history and exports (PDF, PNG, PowerPoint, one offline HTML file for a deck). The board engine is not part of harnessly: you bring your own. Each machine fetches it once with the owner's own Claude account, through the Claude CLI installed and logged in on that machine:
harnessly design engine fetch
harnessly design engine status # what the machine has: engine, browser, ffmpeg
Details: docs/design-engine.md, docs/design-pages.md.
Voice input
A microphone in the message field. The recording is turned into text on the machine by a built-in
whisper.cpp server; nothing is sent to an outside service. The model is
downloaded once, on the first dictation (base or small, by processor count). Needs ffmpeg (included in the Docker
images) and https:// or localhost. Turn it off with RUNTIME_VOICE_ENGINE=off. See docs/voice.md.
Ask a human
An agent can ask a person a question or request an approval, from the shell:
harnessly ask people # who may be tagged, who may approve
harnessly ask --to NAME --option A --option B QUESTION...
harnessly ask approve --to NAME --link URL WHAT...
The question goes to a Telegram chat through a bot you linked, with the person tagged and answer buttons; the person
answers in Telegram or on the page. harnessly ask waits for the answer (exit 4 when it does not come in time; for
approve, exit 0 means approved). Bots, contacts and approvers are set in Settings, Notifications, in the People
section. Agents can also send plain messages with harnessly notify send.
Notifications and the update notice
- Web push when a turn ends or an agent asks for input; Telegram bots as above.
- A standalone runtime built from a release checks the project's GitHub releases at start and every 12 hours and shows
a quiet "new version" notice with a link to the notes. The check sends nothing but the standard request headers;
RUNTIME_UPDATE_CHECK=0turns it off. See Updates.
Hub
For a team, the hub is the one address people sign in at.
- Spaces and invitations (by email or by link);
HUB_SIGNUP=invitelimits sign-up to administrators and invited people. - Sign-in by email code, passkey, GitHub or Yandex ID (and any OIDC provider). A way without its settings is not offered.
- Machines connect outbound with one command, so they need no open port. In subdomain mode (
HUB_RUNTIME_DOMAIN) a machine opens at<id>.<machines domain>, one origin per machine; otherwise at/m/<id>/on the hub.
Quick start
One command
curl -fsSL https://raw.githubusercontent.com/ly-solutions/harnessly/main/install.sh | sh
The installer puts the latest release into ~/.local/bin, checks the archive against the release's checksums.txt
(and its sigstore signature when cosign is installed), installs tmux and git when they are missing, and starts
the runtime as a systemd user service on Linux or a launchd agent on macOS, listening on 127.0.0.1:8022 only. Run it
again to update. Options go after sh -s --: --version X.Y.Z, --port N, --no-service, --uninstall (keeps
your data in ~/.harnessly); --help lists them all. On a remote server it prints the ssh -L command that brings
the page to your computer. Details: docs/deploy.md.
Docker
docker run -d --name harnessly -p 127.0.0.1:8022:8022 -v harnessly-home:/home/agent ghcr.io/ly-solutions/harnessly:latest
docker logs harnessly | grep -i password
Open http://127.0.0.1:8022, enter the Initial password the second command printed, and choose your own. Workspaces,
data and the agents' logins live on the harnessly-home volume. The image has no agent CLIs; use
ghcr.io/ly-solutions/harnessly:with-agents for Claude Code and Codex. Tags: X.Y.Z (pin this in production), X.Y,
latest, and the same with a -with-agents suffix. Images are for linux/amd64 and linux/arm64.
Release binary
Needs tmux and git. Each release has
harnessly_<version>_<os>_<arch>.tar.gz for linux and darwin on amd64 and arm64, with the runtime (the page
is compiled in), the agent and the harnessly command line tool.
VERSION=$(curl -fsSL https://api.github.com/repos/ly-solutions/harnessly/releases/latest | sed -n 's/.*"tag_name": *"v\([^"]*\)".*/\1/p')
OS=linux ARCH=amd64 # OS: linux or darwin; ARCH: amd64 or arm64
BASE=https://github.com/ly-solutions/harnessly/releases/download/v$VERSION
ARCHIVE=harnessly_${VERSION}_${OS}_${ARCH}.tar.gz
curl -fsSLO "$BASE/$ARCHIVE" -O "$BASE/checksums.txt" -O "$BASE/checksums.txt.sigstore.json"
# verify first, see "Releases and verification" below
tar xzf "$ARCHIVE"
RUNTIME_GATE_LISTEN=127.0.0.1:8022 RUNTIME_GATE_UPSTREAM= RUNTIME_APP_BASE_PATH=/ ./runtime
Open http://127.0.0.1:8022 and choose your password. Read the first visit before
you listen on anything other than 127.0.0.1. To keep it running, use
systemd.
From source
git clone https://github.com/ly-solutions/harnessly.git && cd harnessly
make run # builds web/ and the runtime with the page, serves http://127.0.0.1:8022
Needs Go (the version in go.mod), Node.js 22 with pnpm, tmux and git. docker compose up -d --build starts
the whole workspace with boards and artifacts on http://localhost:8022; Helm and Argo CD examples are in
docs/deploy.md. To drive the runtime's HTTP API by hand against a throwaway home, see
Getting started.
Agents need their CLIs installed and logged in where the runtime runs (npm install -g @anthropic-ai/claude-code,
npm install -g @openai/codex); see what the agents need.
Self-hosted hub
git clone https://github.com/ly-solutions/harnessly && cd harnessly
docker compose -f compose.hub.yaml up -d --build # the hub and one machine, http://hub.localhost:8040
Only HUB_PUBLIC_URL is required. The hub image is built locally from this repository. Without a mail server the
sign-in code is in the hub's log, marked DEV. Connect other machines with the installer the hub serves:
curl -fsSL https://hub.example.com/install | sudo sh -s -- --token <code> --profile dir
Profiles are dir, container and full. Caddy with automatic TLS, systemd, Helm and the subdomain mode:
docs/hub/deploy.md; connecting a machine: docs/hub/machine.md.
Releases and verification
A pushed vX.Y.Z tag runs the release workflow:
- GoReleaser builds the archives for linux and darwin (amd64, arm64) and makes a GitHub release with
checksums.txtand its keyless cosign signaturechecksums.txt.sigstore.json. The archives get a build provenance attestation. - A multi-arch image (linux/amd64, linux/arm64) is pushed to
ghcr.io/ly-solutions/harnessly, signed keyless with cosign and attested. - Nothing is signed with a key kept anywhere: signatures and attestations use the run's GitHub OIDC identity.
Verify an archive (needs cosign and, for provenance, the GitHub CLI):
cosign verify-blob checksums.txt --bundle checksums.txt.sigstore.json \
--certificate-identity "https://github.com/ly-solutions/harnessly/.github/workflows/release.yml@refs/tags/v$VERSION" \
--certificate-oidc-issuer https://token.actions.githubusercontent.com
grep " $ARCHIVE\$" checksums.txt | sha256sum -c - # on macOS: shasum -a 256 -c -
gh attestation verify "$ARCHIVE" --repo ly-solutions/harnessly
Verify the image:
cosign verify ghcr.io/ly-solutions/harnessly:latest \
--certificate-identity-regexp '^https://github.com/ly-solutions/harnessly/\.github/workflows/release\.yml@refs/tags/v' \
--certificate-oidc-issuer https://token.actions.githubusercontent.com
gh attestation verify oci://ghcr.io/ly-solutions/harnessly:latest --repo ly-solutions/harnessly
Docs
| Compared | harnessly next to Happy, Paseo, T3 Code, Orca and Claude Code Remote Control |
| Getting started | build, run standalone, open tabs, run agents, connect the machine agent |
| Deploy | quick start, verification, updating, systemd, Docker, compose, Helm, Argo CD |
| Configuration | every RUNTIME_* and AGENT_* variable |
| Voice input | the microphone, the built-in recognition, how to change or turn it off |
| Board engine | fetching the design engine with your own Claude account |
| Design pages | the page model of a design project and the page commands |
| Integrations | boards, artifacts and the agent skills |
| Architecture | the runtime gate, the core, tmux, the machine agent, the repository layout |
| Slices | the slices of routes and switching them per machine |
| The hub | deploy, connecting a machine, architecture, API |
| Changelog | what changed in each version |
| Contributing | development setup, tests, commit convention; Security, Code of Conduct |
harnessly is young: versions are 0.x and a minor version may change the API.
License
Apache License 2.0. Third-party licences: THIRD_PARTY_NOTICES.md.
Directories
¶
| Path | Synopsis |
|---|---|
|
cmd
|
|
|
agent
command
Command agent is the machine agent: it serves one Unix account's transcripts, runtime state and loopback services to the cluster over a single WebSocket link, or, once registered, to a harnessly hub (docs/hub/machine.md).
|
Command agent is the machine agent: it serves one Unix account's transcripts, runtime state and loopback services to the cluster over a single WebSocket link, or, once registered, to a harnessly hub (docs/hub/machine.md). |
|
agentprobe
command
Command agentprobe talks to a machine agent the way the cluster does.
|
Command agentprobe talks to a machine agent the way the cluster does. |
|
harnessly
command
Command harnessly is what an agent in a harnessly tab calls to show things in the person's right pane and to work with the workspace's other tabs.
|
Command harnessly is what an agent in a harnessly tab calls to show things in the person's right pane and to work with the workspace's other tabs. |
|
hub
command
Command hub is the harnessly hub: the server people sign in to, which keeps their spaces and machines and carries a browser to a machine's runtime (docs/hub/architecture.md).
|
Command hub is the harnessly hub: the server people sign in to, which keeps their spaces and machines and carries a browser to a machine's runtime (docs/hub/architecture.md). |
|
runtime
command
Command runtime is the per-person runtime on a machine, being moved here a slice at a time.
|
Command runtime is the per-person runtime on a machine, being moved here a slice at a time. |
|
deploy
|
|
|
container
Package container holds the entrypoint of the machine image: a script that registers the machine with its hub and runs the runtime and the agent side by side (docs/hub/machine.md).
|
Package container holds the entrypoint of the machine image: a script that registers the machine with its hub and runs the runtime and the agent side by side (docs/hub/machine.md). |
|
install
Package install holds the machine installer the hub serves at /install (docs/hub/machine.md).
|
Package install holds the machine installer the hub serves at /install (docs/hub/machine.md). |
|
internal
|
|
|
agentcfg
Package agentcfg reads and writes the settings files of the agent CLIs on this machine for the Settings screen of the new interface: Claude Code's settings.json and Codex's config.toml.
|
Package agentcfg reads and writes the settings files of the agent CLIs on this machine for the Settings screen of the new interface: Claude Code's settings.json and Codex's config.toml. |
|
agentdetect
Package agentdetect tells whether a coding agent (Claude Code, Codex) runs in a tab's terminal, which conversation it is in and whether that conversation can be resumed from its transcript: the check-agent answer, read the way the previous runtime read it, on top of internal/agents/claude and internal/agents/codex.
|
Package agentdetect tells whether a coding agent (Claude Code, Codex) runs in a tab's terminal, which conversation it is in and whether that conversation can be resumed from its transcript: the check-agent answer, read the way the previous runtime read it, on top of internal/agents/claude and internal/agents/codex. |
|
agentlogin
Package agentlogin signs the agent CLIs in on the machine, for the hub's «Войти» buttons.
|
Package agentlogin signs the agent CLIs in on the machine, for the hub's «Войти» buttons. |
|
agentnet
Package agentnet is what the machine agent does with the network and with the agent CLIs' environment: the env files their launches source, the proxy around them (with a local HTTP bridge for SOCKS), and the check that a provider's servers answer.
|
Package agentnet is what the machine agent does with the network and with the agent CLIs' environment: the env files their launches source, the proxy around them (with a local HTTP bridge for SOCKS), and the check that a provider's servers answer. |
|
agents
Package agents holds what the coding agents the runtime drives (Claude Code in internal/agents/claude, Codex in internal/agents/codex) have in common: the session a pane runs, the work-state events their hooks translate to, the snapshot of a transcript's tail, the stats of a finished turn, and the pieces of a launch line.
|
Package agents holds what the coding agents the runtime drives (Claude Code in internal/agents/claude, Codex in internal/agents/codex) have in common: the session a pane runs, the work-state events their hooks translate to, the snapshot of a transcript's tail, the stats of a finished turn, and the pieces of a launch line. |
|
agents/agentstest
Package agentstest is a rig for tests of what the agent does through the login shell: a home folder, a folder of fake agent CLIs that comes first on the PATH, and a stand-in login shell.
|
Package agentstest is a rig for tests of what the agent does through the login shell: a home folder, a folder of fake agent CLIs that comes first on the PATH, and a stand-in login shell. |
|
agents/claude
Package claude is the runtime's side of Claude Code: whether it runs in a pane and which conversation, what its transcript says about the turn, what its hooks mean, and the command line that starts or resumes it.
|
Package claude is the runtime's side of Claude Code: whether it runs in a pane and which conversation, what its transcript says about the turn, what its hooks mean, and the command line that starts or resumes it. |
|
agents/codex
Package codex is the runtime's side of the OpenAI Codex CLI: whether it runs in a pane and which session, what its rollout transcript says about the turn, what its hook payloads mean, and the launcher line and arguments that start or resume it.
|
Package codex is the runtime's side of the OpenAI Codex CLI: whether it runs in a pane and which session, what its rollout transcript says about the turn, what its hook payloads mean, and the launcher line and arguments that start or resume it. |
|
agents/install
Package install puts Claude Code or Codex on the machine as a job of five steps the hub's UI shows live: the system is checked, the provider's servers are reached, the CLI is downloaded, installed, and started once to see it runs.
|
Package install puts Claude Code or Codex on the machine as a job of five steps the hub's UI shows live: the system is checked, the provider's servers are reached, the CLI is downloaded, installed, and started once to see it runs. |
|
agentskills
Package agentskills installs the skills agents use in a harnessly workspace, for both Claude Code and Codex: the workspace skill (the harnessly command), the boards skill when a boards server is configured, and the artifacts skill when an artifacts catalog is.
|
Package agentskills installs the skills agents use in a harnessly workspace, for both Claude Code and Codex: the workspace skill (the harnessly command), the boards skill when a boards server is configured, and the artifacts skill when an artifacts catalog is. |
|
agentstate
Package agentstate is the automaton of a conversation's agent: where it is (wire.AgentState) and what one input — a hook, a transcript entry, a look at the screen, the process under the pane, the launch, a command — makes of it.
|
Package agentstate is the automaton of a conversation's agent: where it is (wire.AgentState) and what one input — a hook, a transcript entry, a look at the screen, the process under the pane, the launch, a command — makes of it. |
|
asks
Package asks is an agent asking a person: a question or an approval sent through one of the Telegram bots the person linked (internal/notifybots), with the person tagged, buttons to answer, and the answer handed back to the agent that waits for it.
|
Package asks is an agent asking a person: a question or an approval sent through one of the Telegram bots the person linked (internal/notifybots), with the person tagged, buttons to answer, and the answer handed back to the agent that waits for it. |
|
attach
Package attach writes the places a message points at (wire.MessageRef: a design, a document, a board, a file of the project, a merge request, a task) into the words the agent gets: one block under the person's text, a line per place, each led by a tag the page reads back into a chip.
|
Package attach writes the places a message points at (wire.MessageRef: a design, a document, a board, a file of the project, a merge request, a task) into the words the agent gets: one block under the person's text, a line per place, each led by a tag the page reads back into a chip. |
|
background
Package background tells which background work an agent conversation still has running — shells, monitors, async agents, dynamic workflows and pending wakeups started from its transcript — reconciled with the agent's own footer, and keeps that list current for every live tab.
|
Package background tells which background work an agent conversation still has running — shells, monitors, async agents, dynamic workflows and pending wakeups started from its transcript — reconciled with the agent's own footer, and keeps that list current for every live tab. |
|
catalog
Package catalog reads, from the machine's files, what a composer offers for an agent CLI (Claude Code or Codex): its slash commands and skills for a folder, and the models and reasoning efforts it can be started with.
|
Package catalog reads, from the machine's files, what a composer offers for an agent CLI (Claude Code or Codex): its slash commands and skills for a folder, and the models and reasoning efforts it can be started with. |
|
chatguard
Package chatguard is what a machine's runtime does about the chat's typing while the machine's local policy keeps the terminal switched off for the hub.
|
Package chatguard is what a machine's runtime does about the chat's typing while the machine's local policy keeps the terminal switched off for the hub. |
|
chatmove
Package chatmove carries a conversation to another machine of the same person: the provider-neutral history leaves the source in an encrypted bundle, the target starts a new native session on it in a worktree of its own, and the source is sealed read-only once the cluster has switched.
|
Package chatmove carries a conversation to another machine of the same person: the provider-neutral history leaves the source in an encrypted bundle, the target starts a new native session on it in a worktree of its own, and the source is sealed read-only once the cluster has switched. |
|
checkpoints
Package checkpoints keeps per-conversation snapshots of a working folder in a shadow git repository (one per tab and folder, under the runtime's data folder) and returns the folder to one of them.
|
Package checkpoints keeps per-conversation snapshots of a working folder in a shadow git repository (one per tab and folder, under the runtime's data folder) and returns the folder to one of them. |
|
checkpoints/scripttest
Package scripttest replays the scripted cases the previous runtime's modules ran (the golden files of the checkpoint store and of the routes over git): the same file and git actions in a temporary folder, and the same dumps of a working folder and a shadow repository, so a Go test compares like with like.
|
Package scripttest replays the scripted cases the previous runtime's modules ran (the golden files of the checkpoint store and of the routes over git): the same file and git actions in a temporary folder, and the same dumps of a working folder and a shadow repository, so a Go test compares like with like. |
|
codemode
Package codemode reads the JavaScript Codex sends to its "exec" tool in code mode and says in plain words what the script does.
|
Package codemode reads the JavaScript Codex sends to its "exec" tool in code mode and says in plain words what the script does. |
|
convo
Package convo owns the conversations of a runtime: one actor per conversation writes its record, agent state, queue, messages, gates, background tasks and seenAt, and every change it makes goes out as a wire event.
|
Package convo owns the conversations of a runtime: one actor per conversation writes its record, agent state, queue, messages, gates, background tasks and seenAt, and every change it makes goes out as a wire event. |
|
coreapi
Package coreapi answers the HTTP routes of the core slice that drive the tab state keeper: the agents' hook reports, a launch typed by the page, the recovery of a tab whose state is unknown, killing and resuming a conversation's agent, and the device visibility the web push sender reads.
|
Package coreapi answers the HTTP routes of the core slice that drive the tab state keeper: the agents' hook reports, a launch typed by the page, the recovery of a tab whose state is unknown, killing and resuming a conversation's agent, and the device visibility the web push sender reads. |
|
coreapi/layoutapi
Package layoutapi answers the core slice's routes over layouts, workspaces, the CLIs' tab commands and the right pane's bridges, the way the previous runtime's API answered them: its route table and precedence, its sign-in check, its body parsing (1 MB, "Invalid JSON", 413), its JSON with ETag and 304, and each handler's statuses and texts.
|
Package layoutapi answers the core slice's routes over layouts, workspaces, the CLIs' tab commands and the right pane's bridges, the way the previous runtime's API answered them: its route table and precedence, its sign-in check, its body parsing (1 MB, "Invalid JSON", 413), its JSON with ETag and 304, and each handler's statuses and texts. |
|
delegation
Package delegation lets an agent hand work to another agent the person sees: a new conversation of the machine — any provider, any model — nested under the one that delegated it.
|
Package delegation lets an agent hand work to another agent the person sees: a new conversation of the machine — any provider, any model — nested under the one that delegated it. |
|
delivery
Package delivery is a file the agent hands to the person on purpose (`harnessly deliver <path>`, the MCP tool deliver_file): what the platform records of it, how the record travels in the tool's result, and how it reads.
|
Package delivery is a file the agent hands to the person on purpose (`harnessly deliver <path>`, the MCP tool deliver_file): what the platform records of it, how the record travels in the tool's result, and how it reads. |
|
design
Package design is the design library of a machine: projects of a design tool kept as plain folders, listed, served to the right panel's browser by a small loopback server, checked in a headless browser, claimed board by board by the agents that edit them and saved to a private history.
|
Package design is the design library of a machine: projects of a design tool kept as plain folders, listed, served to the right panel's browser by a small loopback server, checked in a headless browser, claimed board by board by the agents that edit them and saved to a private history. |
|
designkit
Package designkit keeps UI kits of the design library by version: a kit (stylesheets, scripts, fonts, docs) is installed once as a folder <kits>/<id>/<version>/ and every project loads it from /kit/<id>/<version>/...
|
Package designkit keeps UI kits of the design library by version: a kit (stylesheets, scripts, fonts, docs) is installed once as a folder <kits>/<id>/<version>/ and every project loads it from /kit/<id>/<version>/... |
|
docsecret
Package docsecret finds a secret in a document before it leaves the machine.
|
Package docsecret finds a secret in a document before it leaves the machine. |
|
docshare
Package docshare turns a file of the workspace into a document of the cluster's catalog and keeps the two bound: every save of a linked file, by the person in the editor or by an agent, becomes a new version of the document, no more often than once in Debounce.
|
Package docshare turns a file of the workspace into a document of the cluster's catalog and keeps the two bound: every save of a linked file, by the person in the editor or by an agent, becomes a new version of the document, no more often than once in Debounce. |
|
economics
Package economics is the tokens, time and list-price cost of one agent conversation, read from its transcripts on demand.
|
Package economics is the tokens, time and list-price cost of one agent conversation, read from its transcripts on demand. |
|
feed
Package feed is a conversation's feed on top of the agent's transcript: entries with ids that come from the transcript itself (a re-read and an incremental read agree), cut into turns by the runtime, read in pages by turn, and the signals in it that move the agent's state (a question asked, a gate resolved, a turn ended).
|
Package feed is a conversation's feed on top of the agent's transcript: entries with ids that come from the transcript itself (a re-read and an incremental read agree), cut into turns by the runtime, read in pages by turn, and the signals in it that move the agent's state (a question asked, a gate resolved, a turn ended). |
|
files
Package files answers the runtime's read-only file routes: a file of a tab's project for the editor, both sides of a changed file, a picture or document the agent produced, the «@»-context picker, a memory note the agent cited and an uploaded attachment.
|
Package files answers the runtime's read-only file routes: a file of a tab's project for the editor, both sides of a changed file, a picture or document the agent produced, the «@»-context picker, a memory note the agent cited and an uploaded attachment. |
|
fork
Package fork cuts an agent's transcript at one of the person's messages and writes what comes before it as a new session of the agent, which the agent CLI resumes as its own: the conversation goes on from that point, the old transcript stays as it was.
|
Package fork cuts an agent's transcript at one of the person's messages and writes what comes before it as a new session of the agent, which the agent CLI resumes as its own: the conversation goes on from that point, the old transcript stays as it was. |
|
gate
Package gate is the runtime gate: the process on the runtime's port.
|
Package gate is the runtime gate: the process on the runtime's port. |
|
gitread
Package gitread answers the read-only git questions about a tab's working folder and a repository on this machine: branch, status, the working diff, a commit's diff and the commit log.
|
Package gitread answers the read-only git questions about a tab's working folder and a repository on this machine: branch, status, the working diff, a commit's diff and the commit log. |
|
gitsync
Package gitsync brings a tab's repository in line with its upstream, as the diff panel's sync button asks: fetch with prune, a fast-forward pull when behind, a push when ahead; a failed step is classified for the page.
|
Package gitsync brings a tab's repository in line with its upstream, as the diff panel's sync button asks: fetch with prune, a fast-forward pull when behind, a push when ahead; a failed step is classified for the page. |
|
handoff
Package handoff carries a conversation's context to another one: a fork's own copy of a Claude session cut after a turn, an excerpt of a transcript within a budget, the note an agent writes for the next one, and the blocks these go in as a first message (a handoff) or as a message back into the conversation a fork came from (a merge).
|
Package handoff carries a conversation's context to another one: a fork's own copy of a Claude session cut after a turn, an excerpt of a transcript within a budget, the note an agent writes for the next one, and the blocks these go in as a first message (a handoff) or as a message back into the conversation a fork came from (a merge). |
|
history
Package history keeps what the core remembers about finished turns: session-history.json, the newest 200 turns for the notification list, and session-stats/<id>.json, the last statusline figures of each agent session.
|
Package history keeps what the core remembers about finished turns: session-history.json, the newest 200 turns for the notification list, and session-stats/<id>.json, the last statusline figures of each agent session. |
|
hlcli
Package hlcli is the harnessly command: what an agent running in a harnessly tab calls to show things to the person in the right pane, to look at the workspace's tabs, and to hand work to another agent.
|
Package hlcli is the harnessly command: what an agent running in a harnessly tab calls to show things to the person in the right pane, to look at the workspace's tabs, and to hand work to another agent. |
|
hooksetup
Package hooksetup writes the files the coding agents call the runtime through: the port file, the status hook and status line scripts Claude Code runs, the Codex hook script, the `--settings` file with the hooks, the MCP config, the prompt editor Claude gets as VISUAL, and the Codex launcher.
|
Package hooksetup writes the files the coding agents call the runtime through: the port file, the status hook and status line scripts Claude Code runs, the Codex hook script, the `--settings` file with the hooks, the MCP config, the prompt editor Claude gets as VISUAL, and the Codex launcher. |
|
hub/api
Package api assembles the hub: it builds every service from one configuration and one database, routes the requests among them, and runs the background work (the local machine's code, the sweeping of what expired).
|
Package api assembles the hub: it builds every service from one configuration and one database, routes the requests among them, and runs the background work (the local machine's code, the sweeping of what expired). |
|
hub/auth
Package auth is the hub's accounts: sessions and cookies, the CSRF guard, email codes, passkeys, OAuth sign-in with GitHub, Yandex ID and OpenID Connect, and the rules that decide which sign-in belongs to which account.
|
Package auth is the hub's accounts: sessions and cookies, the CSRF guard, email codes, passkeys, OAuth sign-in with GitHub, Yandex ID and OpenID Connect, and the rules that decide which sign-in belongs to which account. |
|
hub/buildinfo
Package buildinfo holds what the linker puts into the hub binary.
|
Package buildinfo holds what the linker puts into the hub binary. |
|
hub/config
Package config reads the hub's configuration: every HUB_* variable of docs/hub/api.md, each also as <NAME>_FILE.
|
Package config reads the hub's configuration: every HUB_* variable of docs/hub/api.md, each also as <NAME>_FILE. |
|
hub/dist
Package dist serves what a machine downloads to join the hub: the installer script at /install and the binaries under /dl/, with a manifest of their SHA-256 sums.
|
Package dist serves what a machine downloads to join the hub: the installer script at /install and the binaries under /dl/, with a manifest of their SHA-256 sums. |
|
hub/events
Package events is the hub's live channel to the browser: one Server-Sent Events stream per open space.
|
Package events is the hub's live channel to the browser: one Server-Sent Events stream per open space. |
|
hub/httpx
Package httpx is the hub's HTTP plumbing: JSON bodies, the error shape of docs/hub/api.md, client addresses.
|
Package httpx is the hub's HTTP plumbing: JSON bodies, the error shape of docs/hub/api.md, client addresses. |
|
hub/hubtest
Package hubtest is a whole hub in a test: the real services on a real SQLite file behind a real HTTP server, people who sign in by email code, and a fake agent that registers, dials with its key and answers like a machine does.
|
Package hubtest is a whole hub in a test: the real services on a real SQLite file behind a real HTTP server, people who sign in by email code, and a fake agent that registers, dials with its key and answers like a machine does. |
|
hub/link
Package link is the hub's end of the agent link: one WebSocket per machine, dialed by the agent.
|
Package link is the hub's end of the agent link: one WebSocket per machine, dialed by the agent. |
|
hub/machines
Package machines is the hub's registry of machines: registration codes and the registration of an agent, what the hub knows about each machine (hello, preflight, agents, policy, proxy), the views the API sends, and opening a machine's runtime.
|
Package machines is the hub's registry of machines: registration codes and the registration of an agent, what the hub knows about each machine (hello, preflight, agents, policy, proxy), the views the API sends, and opening a machine's runtime. |
|
hub/mail
Package mail sends the hub's two kinds of mail, sign-in codes and invitations, over SMTP, or writes them to the log when no SMTP server is configured (a single-host installation).
|
Package mail sends the hub's two kinds of mail, sign-in codes and invitations, over SMTP, or writes them to the log when no SMTP server is configured (a single-host installation). |
|
hub/proxy
Package proxy carries a person's browser to the runtime of a machine, through the machine's agent link (docs/hub/architecture.md, "Reaching a runtime through the hub").
|
Package proxy carries a person's browser to the runtime of a machine, through the machine's agent link (docs/hub/architecture.md, "Reaching a runtime through the hub"). |
|
hub/ratelimit
Package ratelimit is the hub's in-memory abuse limiter.
|
Package ratelimit is the hub's in-memory abuse limiter. |
|
hub/relay
Package relay is the owner's hands on a machine's agents: install, check, log in, deliver a key or a secret, set a proxy.
|
Package relay is the owner's hands on a machine's agents: install, check, log in, deliver a key or a secret, set a proxy. |
|
hub/spaces
Package spaces is the hub's teams: spaces and their members, and the invitations that bring people in.
|
Package spaces is the hub's teams: spaces and their members, and the invitations that bring people in. |
|
hub/sshinstall
Package sshinstall is the hub's «Свой сервер по SSH» way of connecting a machine.
|
Package sshinstall is the hub's «Свой сервер по SSH» way of connecting a machine. |
|
hub/store
Package store is the hub's database: database/sql over SQLite (pure Go) or Postgres (pgx), one schema, embedded migrations, queries written with ? placeholders and rebound for Postgres.
|
Package store is the hub's database: database/sql over SQLite (pure Go) or Postgres (pgx), one schema, embedded migrations, queries written with ? placeholders and rebound for Postgres. |
|
hub/ticket
Package ticket is the one-minute, single-use pass the hub gives a signed-in person to open a machine's own origin (subdomain mode): the hub UI asks for one, the machine's origin trades it for its host-only cookie.
|
Package ticket is the one-minute, single-use pass the hub gives a signed-in person to open a machine's own origin (subdomain mode): the hub UI asks for one, the machine's origin trades it for its host-only cookie. |
|
hubproto
Package hubproto is what the hub and the machine agent agree on (docs/hub/api.md): the signed dial, the sealed envelope a browser hands the machine through the hub, and the types of the agent link's protocol 2.
|
Package hubproto is what the hub and the machine agent agree on (docs/hub/api.md): the signed dial, the sealed envelope a browser hands the machine through the hub, and the types of the agent link's protocol 2. |
|
integrations
Package integrations connects the runtime to the sibling services people and agents share with it: a boards server (whiteboards) and an artifacts catalog (documents).
|
Package integrations connects the runtime to the sibling services people and agents share with it: a boards server (whiteboards) and an artifacts catalog (documents). |
|
integrations/github
Package github reads issues and pull requests from GitHub (or GitHub Enterprise) for the page: an issue as a task card and tab, an issue or a pull request link as a chip.
|
Package github reads issues and pull requests from GitHub (or GitHub Enterprise) for the page: an issue as a task card and tab, an issue or a pull request link as a chip. |
|
jscompat
Package jscompat reproduces the few JavaScript behaviours the runtime's answers depend on — string trimming and length in UTF-16 units, parseInt, Date parsing and printing, truthiness of JSON values, Node's query strings and path.basename — so a route moved to Go answers byte for byte as the one it replaces.
|
Package jscompat reproduces the few JavaScript behaviours the runtime's answers depend on — string trimming and length in UTF-16 units, parseInt, Date parsing and printing, truthiness of JSON values, Node's query strings and path.basename — so a route moved to Go answers byte for byte as the one it replaces. |
|
jsonlog
Package jsonlog writes the JSON log lines the runtime, the machine agent and the hub share: one line per event, info to stdout, warn and error to stderr.
|
Package jsonlog writes the JSON log lines the runtime, the machine agent and the hub share: one line per event, info to stdout, warn and error to stderr. |
|
jsvalue
Package jsvalue holds JSON the way JavaScript does: objects keep their key order and every key they were given, so a document read, changed and written back carries the fields nobody here models, in the order the previous runtime wrote them, and Stringify writes what JSON.stringify writes.
|
Package jsvalue holds JSON the way JavaScript does: objects keep their key order and every key they were given, so a document read, changed and written back carries the fields nobody here models, in the order the previous runtime wrote them, and Stringify writes what JSON.stringify writes. |
|
launch
Package launch starts and resumes agent conversations the platform's way: a tab in a workspace's first pane, the agent CLI's launch line with its environment and initial prompt typed into it, the tab's metadata, and the keeper told that a launch is under way.
|
Package launch starts and resumes agent conversations the platform's way: a tab in a workspace's first pane, the agent CLI's launch line with its environment and initial prompt typed into it, the tab's metadata, and the keeper told that a launch is under way. |
|
limits
Package limits keeps the machine's subscription limits: rate-limits.json, one entry per provider merged field by field from every source that measures them (the agent's statusline, codexbar, Codex's usage endpoint, the Codex transcript), its watcher, and limits-history.jsonl for the burn-rate forecast.
|
Package limits keeps the machine's subscription limits: rate-limits.json, one entry per provider merged field by field from every source that measures them (the agent's statusline, codexbar, Codex's usage endpoint, the Codex transcript), its watcher, and limits-history.jsonl for the burn-rate forecast. |
|
locale
Package locale picks the language of the texts the runtime shows people — the errors and hints its routes answer with — by RUNTIME_LOCALE: "en" (the default) or "ru", the language the previous runtime answered in.
|
Package locale picks the language of the texts the runtime shows people — the errors and hints its routes answer with — by RUNTIME_LOCALE: "en" (the default) or "ru", the language the previous runtime answered in. |
|
loginflow
Package loginflow signs the machine's agent CLIs in and out for the page.
|
Package loginflow signs the machine's agent CLIs in and out for the page. |
|
machine
Package machine answers what the runtime reads from the machine itself: processes, the Claude Code session files, a tab's working folder.
|
Package machine answers what the runtime reads from the machine itself: processes, the Claude Code session files, a tab's working folder. |
|
machines
Package machines answers what a runtime says about its machine: the machine snapshot (load, provider limits with their forecast, features, release), the machine load panel, the health probe and the app manifest, and the web push subscription routes.
|
Package machines answers what a runtime says about its machine: the machine snapshot (load, provider limits with their forecast, features, release), the machine load panel, the health probe and the app manifest, and the web push subscription routes. |
|
mcpserver
Package mcpserver is the JSON-RPC of the runtime's MCP server for agents: stateless Streamable HTTP, every POST carrying one message (or a batch) and getting its answer as plain JSON, nothing kept between calls.
|
Package mcpserver is the JSON-RPC of the runtime's MCP server for agents: stateless Streamable HTTP, every POST carrying one message (or a batch) and getting its answer as plain JSON, nothing kept between calls. |
|
messagecounts
Package messagecounts counts the messages of a Claude Code or Codex transcript the way the previous runtime's timeline/message-counts route did: user, assistant and tool messages, and the tools by name.
|
Package messagecounts counts the messages of a Claude Code or Codex transcript the way the previous runtime's timeline/message-counts route did: user, assistant and tool messages, and the tools by name. |
|
msgindex
Package msgindex is the full-text index over the messages of conversations: what the person wrote and what the agent answered, not the tool noise.
|
Package msgindex is the full-text index over the messages of conversations: what the person wrote and what the agent answered, not the tool noise. |
|
nodejson
Package nodejson writes JSON byte for byte as the previous runtime did (JavaScript's JSON.stringify) and gives an answer the ETag that runtime's dispatcher put on it, so a page's conditional request keeps working across the switch.
|
Package nodejson writes JSON byte for byte as the previous runtime did (JavaScript's JSON.stringify) and gives an answer the ETag that runtime's dispatcher put on it, so a page's conditional request keeps working across the switch. |
|
notifybots
Package notifybots keeps the Telegram bots the person linked in Settings for notifications: each bot with its token, the chat it writes to and the person's instruction of when an agent should use it.
|
Package notifybots keeps the Telegram bots the person linked in Settings for notifications: each bot with its token, the chat it writes to and the person's instruction of when an agent should use it. |
|
oomguard
Package oomguard keeps the OOM killer's protection of the runtime from passing to the work it starts.
|
Package oomguard keeps the OOM killer's protection of the runtime from passing to the work it starts. |
|
outbox
Package outbox is a conversation's way to its agent: every message — a prompt, a "/model", a "!cmd" — enters the queue, and the head of the queue is typed by the typist when the agent can take it.
|
Package outbox is a conversation's way to its agent: every message — a prompt, a "/model", a "!cmd" — enters the queue, and the head of the queue is typed by the typist when the agent can take it. |
|
paneauto
Package paneauto opens in the right pane what the agent of a conversation works on, without being asked: a design of the machine's library whose files it writes, a document it publishes or a board it draws on the workspace's portal.
|
Package paneauto opens in the right pane what the agent of a conversation works on, without being asked: a design of the machine's library whose files it writes, a document it publishes or a board it draws on the workspace's portal. |
|
paneintents
Package paneintents keeps what an agent asked its right pane to show, with the conversation rather than sent to a page that may not be there: the page that shows the conversation applies it when it does, now or hours later, on any device.
|
Package paneintents keeps what an agent asked its right pane to show, with the conversation rather than sent to a page that may not be there: the page that shows the conversation applies it when it does, now or hours later, on any device. |
|
panel
Package panel is what an agent may ask of the right pane of its own tab and what the pane answers: the command parser, the cleaning of a page's answer, and the bridge that carries a command to the person's page over the sync socket and the answer back to the agent that waits for it.
|
Package panel is what an agent may ask of the right pane of its own tab and what the pane answers: the command parser, the cleaning of a page's answer, and the bridge that carries a command to the person's page over the sync socket and the answer back to the agent that waits for it. |
|
peers
Package peers is how agents of different conversations — on this machine or on another machine of the fleet — write to each other: who may write here (the allow-list), how a message from another agent reaches a conversation (typed into its agent as a <peer-message> envelope, never as the person's own words), the list of chats an agent may write to, and the audit of what went in and out.
|
Package peers is how agents of different conversations — on this machine or on another machine of the fleet — write to each other: who may write here (the allow-list), how a message from another agent reaches a conversation (typed into its agent as a <peer-message> envelope, never as the person's own words), the list of chats an agent may write to, and the audit of what went in and out. |
|
pluginreload
Package pluginreload carries a change of the person's Claude Code plugins and skills into the Claude tabs that run.
|
Package pluginreload carries a change of the person's Claude Code plugins and skills into the Claude tabs that run. |
|
preflight
Package preflight checks the tools the runtime needs on the machine — tmux, git, Claude Code, Codex — the way the person's own login shell finds them.
|
Package preflight checks the tools the runtime needs on the machine — tmux, git, Claude Code, Codex — the way the person's own login shell finds them. |
|
preview
Package preview is the reverse proxy behind the right pane's browser: a slot origin of the gateway shows a local dev server port (with its neighbour ports) or an external site, named by a claim the gateway signs with the pair's secret.
|
Package preview is the reverse proxy behind the right pane's browser: a slot origin of the gateway shows a local dev server port (with its neighbour ports) or an external site, named by a claim the gateway signs with the pair's secret. |
|
preview/devtools
Package devtools is the DevTools record of the preview slots: what a slot's page did on the network and in its console, and the conditions it runs under (throttling, blocked addresses, cache).
|
Package devtools is the DevTools record of the preview slots: what a slot's page did on the network and in its console, and the conditions it runs under (throttling, blocked addresses, cache). |
|
preview/ports
Package ports lists the dev servers a preview can open (the listeners of this machine grouped by the conversation's work folders and the agents' worktrees) and maps a component picked in a preview to its source files.
|
Package ports lists the dev servers a preview can open (the listeners of this machine grouped by the conversation's work folders and the agents' worktrees) and maps a component picked in a preview to its source files. |
|
preview/weburl
Package weburl parses URLs the way browsers and Node's URL class do (the WHATWG URL standard) for the http(s) and ws(s) schemes the preview deals with: lowercase scheme and host, default port dropped, dot segments resolved, the same characters percent-encoded.
|
Package weburl parses URLs the way browsers and Node's URL class do (the WHATWG URL standard) for the http(s) and ws(s) schemes the preview deals with: lowercase scheme and host, default port dropped, dot segments resolved, the same characters percent-encoded. |
|
pricing
Package pricing is the API price of tokens, per model, for Claude and OpenAI models: what a conversation would have cost at list prices.
|
Package pricing is the API price of tokens, per model, for Claude and OpenAI models: what a conversation would have cost at list prices. |
|
proc
Package proc reads the process table of this machine: a process's children and descendants, its command line, environment, working folder and start time, the TCP ports a process tree listens on, and memory pressure.
|
Package proc reads the process table of this machine: a process's children and descendants, its command line, environment, working folder and start time, the TCP ports a process tree listens on, and memory pressure. |
|
prompts
Package prompts types a person's messages and keys into an agent's tmux pane: the per-tab prompt queue and its delivery, steering a message into a running turn, "send now", the composer's text route (through Claude's external editor or a paste, or Codex's watched submit), the slash-command runner with its model and effort confirmation, the menu mirror, AskUserQuestion answers, and the registry that keeps one message from being typed twice.
|
Package prompts types a person's messages and keys into an agent's tmux pane: the per-tab prompt queue and its delivery, steering a message into a running turn, "send now", the composer's text route (through Claude's external editor or a paste, or Codex's watched submit), the slash-command runner with its model and effort confirmation, the menu mirror, AskUserQuestion answers, and the registry that keeps one message from being typed twice. |
|
providers
Package providers holds the backend profiles: another vendor's models (Kimi, GLM, Grok) behind an agent CLI the machine already runs.
|
Package providers holds the backend profiles: another vendor's models (Kimi, GLM, Grok) behind an agent CLI the machine already runs. |
|
push
Package push sends the web push notifications of the runtime: a finished turn or a question of an agent, to the person's subscribed browsers (RFC 8030 delivery, RFC 8291 message encryption, RFC 8292 VAPID).
|
Package push sends the web push notifications of the runtime: a finished turn or a question of an agent, to the person's subscribed browsers (RFC 8030 delivery, RFC 8291 message encryption, RFC 8292 VAPID). |
|
runlock
Package runlock is the single-instance lock of a machine's runtime: a file in the data folder naming the process that holds it and its port.
|
Package runlock is the single-instance lock of a machine's runtime: a file in the data folder naming the process that holds it and its port. |
|
sameorigin
Package sameorigin tells a request of a page of another origin from one of the machine's own pages.
|
Package sameorigin tells a request of a page of another origin from one of the machine's own pages. |
|
screen
Package screen reads what a coding agent's terminal UI (Claude Code, Codex) shows in a captured tmux pane: whether it is working, which menu or permission prompt is open, what the input line holds, whether a queued message waits, and which keys answer an AskUserQuestion dialog.
|
Package screen reads what a coding agent's terminal UI (Claude Code, Codex) shows in a captured tmux pane: whether it is working, which menu or permission prompt is open, what the input line holds, whether a queued message waits, and which keys answer an AskUserQuestion dialog. |
|
secrets
Package secrets is the safe: the tokens and keys the person hands to the agents of this machine, kept encrypted on the machine and handed to a command's environment or a short-lived file, never to a conversation.
|
Package secrets is the safe: the tokens and keys the person hands to the agents of this machine, kept encrypted on the machine and handed to a command's environment or a short-lived file, never to a conversation. |
|
selfupdate
Package selfupdate keeps the programs of a machine connected to a hub the same as the ones the hub serves (<hub>/dl/manifest.json, the file install.sh downloads from).
|
Package selfupdate keeps the programs of a machine connected to a hub the same as the ones the hub serves (<hub>/dl/manifest.json, the file install.sh downloads from). |
|
services
Package services answers the runtime's routes that only call external services with the person's tokens: a session's pushes and merge requests on GitLab, a merge request or commit with its diff, link previews (tracker issues, merge requests, published documents), tracker avatars, project keys and task cards, and site icons.
|
Package services answers the runtime's routes that only call external services with the person's tokens: a session's pushes and merge requests on GitLab, a merge request or commit with its diff, link previews (tracker issues, merge requests, published documents), tracker avatars, project keys and task cards, and site icons. |
|
sessionmeta
Package sessionmeta reads what a Claude Code transcript says about the session itself, beside its messages: the reasoning effort it really runs on, the /goal it works toward, and the recap Claude writes for the person who comes back after being away.
|
Package sessionmeta reads what a Claude Code transcript says about the session itself, beside its messages: the reasoning effort it really runs on, the /goal it works toward, and the recap Claude writes for the person who comes back after being away. |
|
sessions
Package sessions lists the conversations Claude Code and Codex keep on disk for a working folder, as the runtime's conversation lists show them.
|
Package sessions lists the conversations Claude Code and Codex keep on disk for a working folder, as the runtime's conversation lists show them. |
|
settings
Package settings keeps the runtime's settings files as the previous runtime did: the person's preferences in the config file (with the pair's secret and the automation token beside them), keyboard shortcuts, quick prompts, sidebar items and each workspace's sent messages.
|
Package settings keeps the runtime's settings files as the previous runtime did: the person's preferences in the config file (with the pair's secret and the automation token beside them), keyboard shortcuts, quick prompts, sidebar items and each workspace's sent messages. |
|
share
Package share is the owner's conversation snapshots and the read-only links published from them: a redacted draft of a conversation's transcript, its page and Markdown, the links' store and the page a colleague opens through the platform's share route.
|
Package share is the owner's conversation snapshots and the read-only links published from them: a redacted draft of a conversation's transcript, its page and Markdown, the links' store and the page a colleague opens through the platform's share route. |
|
shots
Package shots lists the pictures a Claude Code agent and its subagents looked at: the image files it Read, and the ones a tool such as a browser's screenshot saved.
|
Package shots lists the pictures a Claude Code agent and its subagents looked at: the image files it Read, and the ones a tool such as a browser's screenshot saved. |
|
sidechat
Package sidechat answers a quick question about an agent tab's Claude session from a fork that is never saved: the main conversation does not change and the agent may be busy.
|
Package sidechat answers a quick question about an agent tab's Claude session from a fork that is never saved: the main conversation does not change and the agent may be busy. |
|
sites
Package sites publishes static sites: a site is a name in a space, a deployment is an immutable snapshot of files (a manifest of path → sha256 and blobs addressed by that hash), and the site's "current" alias points at one deployment.
|
Package sites publishes static sites: a site is a name in a space, a deployment is an immutable snapshot of files (a manifest of path → sha256 and blobs addressed by that hash), and the site's "current" alias points at one deployment. |
|
sitesclient
Package sitesclient deploys sites over the API of internal/sites without importing the server.
|
Package sitesclient deploys sites over the API of internal/sites without importing the server. |
|
sleep
Package sleep puts idle agents to sleep: an idle Claude holds a few hundred megabytes with its MCP bridges whatever it does, and a machine that never lets one go runs out of memory.
|
Package sleep puts idle agents to sleep: an idle Claude holds a few hundred megabytes with its MCP bridges whatever it does, and a machine that never lets one go runs out of memory. |
|
sockets
Package sockets serves the runtime's JSON sockets: /api/status (tab states, background work, the prompt queue, pane intents, limits) and /api/sync (layout and workspace changes, toasts and commands to the page).
|
Package sockets serves the runtime's JSON sockets: /api/status (tab states, background work, the prompt queue, pane intents, limits) and /api/sync (layout and workspace changes, toasts and commands to the page). |
|
sources
Package sources is what a whole conversation refers to, read from its transcript the way the previous runtime's conversation sources route did: the links of the agent's answers (documents, merge requests, tracker issues and the rest of the web) and the filesystem paths it worked with.
|
Package sources is what a whole conversation refers to, read from its transcript the way the previous runtime's conversation sources route did: the links of the agent's answers (documents, merge requests, tracker issues and the rest of the web) and the filesystem paths it worked with. |
|
state
Package state keeps the runtime's workspace list (`workspaces.json`) and each workspace's layout (`workspaces/<id>/layout.json`): reads with their normalisation, atomic writes in the bytes the previous runtime wrote, the commit of every change to the cluster when the cluster owns the pair's state, the changes the cluster makes, and the tree and tab operations behind the layout and workspace routes.
|
Package state keeps the runtime's workspace list (`workspaces.json`) and each workspace's layout (`workspaces/<id>/layout.json`): reads with their normalisation, atomic writes in the bytes the previous runtime wrote, the commit of every change to the cluster when the cluster owns the pair's state, the changes the cluster makes, and the tree and tab operations behind the layout and workspace routes. |
|
stats
Package stats answers the usage statistics pages (/api/stats/*) from this machine's Claude Code and Codex files, as the previous runtime's handlers did: the same answers, the same cache files under the data folder, each transcript read again only once it changes.
|
Package stats answers the usage statistics pages (/api/stats/*) from this machine's Claude Code and Codex files, as the previous runtime's handlers did: the same answers, the same cache files under the data folder, each transcript read again only once it changes. |
|
status
Package status keeps the work state of every tab: what its agent is doing (idle, busy, waiting for an answer, done), learnt from the agent's hooks, its transcript, its screen and its process tree, and pushed to every status socket.
|
Package status keeps the work state of every tab: what its agent is doing (idle, busy, waiting for an answer, done), learnt from the agent's hooks, its transcript, its screen and its process tree, and pushed to every status socket. |
|
statusline
Package statusline is the sink of Claude Code's status line: the platform's statusline script posts the JSON Claude gives it on every refresh, the sink keeps the subscription limits and the session's figures from it, and answers the line to show, which is the output of the person's own statusLine command when they have one.
|
Package statusline is the sink of Claude Code's status line: the platform's statusline script posts the JSON Claude gives it on every refresh, the sink keeps the subscription limits and the session's figures from it, and answers the line to show, which is the output of the person's own statusLine command when they have one. |
|
subagents
Package subagents lists the subagents of a Claude Code conversation: the transcripts Claude Code writes next to the conversation's own (<session>/subagents/agent-<id>.jsonl, with an agent-<id>.meta.json), each summed up the way the previous runtime's inspector showed it.
|
Package subagents lists the subagents of a Claude Code conversation: the transcripts Claude Code writes next to the conversation's own (<session>/subagents/agent-<id>.jsonl, with an agent-<id>.meta.json), each summed up the way the previous runtime's inspector showed it. |
|
telemetry
Package telemetry reports a runtime's own events to a PostHog-compatible batch endpoint: queued, sent a minute after the first of them (or at once when a batch is full), never more than a batch per request.
|
Package telemetry reports a runtime's own events to a PostHog-compatible batch endpoint: queued, sent a minute after the first of them (or at once when a batch is full), never more than a batch per request. |
|
terminal
Package terminal serves the terminal socket: a page attaches to a tab's tmux session through a pty and talks a small binary protocol.
|
Package terminal serves the terminal socket: a page attaches to a tab's tmux session through a pty and talks a small binary protocol. |
|
terminalfailure
Package terminalfailure normalizes provider failures that a coding-agent CLI cannot recover from by retrying.
|
Package terminalfailure normalizes provider failures that a coding-agent CLI cannot recover from by retrying. |
|
timeline
Package timeline serves the conversation socket (/api/timeline): which agent session a tab's pane runs, its transcript's first screen and what it gains, switches between sessions, the reply on screen not yet written, session statistics and the resume of a past session.
|
Package timeline serves the conversation socket (/api/timeline): which agent session a tab's pane runs, its transcript's first screen and what it gains, switches between sessions, the reply on screen not yet written, session statistics and the resume of a past session. |
|
tmux
Package tmux runs the tmux commands the runtime needs.
|
Package tmux runs the tmux commands the runtime needs. |
|
transcript
Package transcript reads the coding agents' conversation files (Claude Code and Codex jsonl) into timeline entries, the shape the conversation view draws, as the previous runtime's parsers built them: the same entries, keys in the same order, the same byte offsets; only the ids differ.
|
Package transcript reads the coding agents' conversation files (Claude Code and Codex jsonl) into timeline entries, the shape the conversation view draws, as the previous runtime's parsers built them: the same entries, keys in the same order, the same byte offsets; only the ids differ. |
|
typist
Package typist types into an agent's tmux pane: it reads the screen before any key, decides whether a message may go in now, pastes its pictures and its text, presses Enter and watches the text leave the input box.
|
Package typist types into an agent's tmux pane: it reads the screen before any key, decides whether a message may go in now, pastes its pictures and its text, presses Enter and watches the text leave the input box. |
|
updatecheck
Package updatecheck tells a self-hosted runtime whether a newer release is published: a periodic GET of the project's latest-release address, compared with the running version.
|
Package updatecheck tells a self-hosted runtime whether a newer release is published: a periodic GET of the project's latest-release address, compared with the running version. |
|
usagereport
Package usagereport is a runtime's usage report: what its Claude Code and Codex transcripts say about prompts, sessions, tokens and their API-equivalent cost, per day, project and model.
|
Package usagereport is a runtime's usage report: what its Claude Code and Codex transcripts say about prompts, sessions, tokens and their API-equivalent cost, per day, project and model. |
|
vault
Package vault carries an agent's request that the person's page log in on a site with the password safe: the origin check, the cleaning of the page's answer, the per-tab rate limit and the bridge over the sync socket.
|
Package vault carries an agent's request that the person's page log in on a site with the password safe: the origin check, the cleaning of the page's answer, the per-tab rate limit and the bridge over the sync socket. |
|
voice
Package voice is dictation for the composer's server engine: the page streams whatever its recorder produces over a socket, ffmpeg decodes it to PCM as it arrives, and the machine's recognition service, reached over a Unix socket, answers with partial and final text.
|
Package voice is dictation for the composer's server engine: the page streams whatever its recorder produces over a socket, ffmpeg decodes it to PCM as it arrives, and the machine's recognition service, reached over a Unix socket, answers with partial and final text. |
|
voice/engine
Package engine is the speech recognition the runtime brings with it: a pinned whisper.cpp server run as a child of the runtime, and a Unix socket speaking the protocol internal/voice already knows, so that a machine with nothing set up dictates out of the box.
|
Package engine is the speech recognition the runtime brings with it: a pinned whisper.cpp server run as a child of the runtime, and a Unix socket speaking the protocol internal/voice already knows, so that a machine with nothing set up dictates out of the box. |
|
wire
Package wire is the v2 contract between a runtime and its pages: the data model, the socket frames and events, the commands of POST /api/v2/cmd/<op> and their results.
|
Package wire is the v2 contract between a runtime and its pages: the data model, the socket frames and events, the commands of POST /api/v2/cmd/<op> and their results. |
|
wire/wirefake
Package wirefake is a runtime without agents: a convo.Service and a wire.MachineSource that serve the shared fixtures of internal/wire/testdata and play a scripted agent on them.
|
Package wirefake is a runtime without agents: a convo.Service and a wire.MachineSource that serve the shared fixtures of internal/wire/testdata and play a scripted agent on them. |
|
workflows
Package workflows reads the dynamic workflows of a Claude Code conversation: a script the agent hands to its Workflow tool, which runs in the background and starts many subagents phase by phase.
|
Package workflows reads the dynamic workflows of a Claude Code conversation: a script the agent hands to its Workflow tool, which runs in the background and starts many subagents phase by phase. |
|
Package skills carries the agent skills harnessly installs for Claude Code and Codex: the files of two upstream repositories at the commits pinned in SOURCES, vendored under upstream/ so an install works offline.
|
Package skills carries the agent skills harnessly installs for Claude Code and Codex: the files of two upstream repositories at the commits pinned in SOURCES, vendored under upstream/ so an install works offline. |
|
tools
|
|
|
hub-e2e/seal
command
Command seal seals a value to a machine the way the hub's page does (docs/hub/api.md, "Sealed envelope"), for tools/hub-e2e.sh: the value is read from standard input, the envelope is printed as JSON.
|
Command seal seals a value to a machine the way the hub's page does (docs/hub/api.md, "Sealed envelope"), for tools/hub-e2e.sh: the value is read from standard input, the envelope is printed as JSON. |
|
Package web holds the browser front-end (a Vite project in this folder) and, built with the webui tag, its compiled files for the runtime to serve.
|
Package web holds the browser front-end (a Vite project in this folder) and, built with the webui tag, its compiled files for the runtime to serve. |
Click to show internal directories.
Click to hide internal directories.