@openagt/dashboard 0.0.0-stage → 0.9.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Suleiman Shahbari
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,126 @@
-# Temporary Holding Version
+# @openagt/dashboard
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+**OpenAgent** — autonomous AI programming: humans make the important decisions
+while coding agents run unattended.
+
+You register your repos. From then on, agents work on them: each agent gets a throwaway
+checkout of the repo, does its work, and hands the result off as a pull request. Your own
+checkout is never touched.
+
+```bash
+npm i -g @openagt/dashboard
+
+cd ~/code/my-repo
+openagent          # serves the dashboard at http://127.0.0.1:4200
+```
+
+## The CLI is four options and no verbs
+
+```
+openagent              Serve the dashboard in the foreground. Ctrl+C closes it; the
+                       agents it started go on to their own end.
+
+  --port <n>           Dashboard port (default: 4200).
+  --host <addr>        Bind address (default: 127.0.0.1). A non-loopback address
+                       exposes the dashboard to your network and generates a shared
+                       token; the printed URL carries it, and any request without it
+                       gets 401. Exposing the daemon to the network is a security
+                       decision.
+  -h, --help           Show this help.
+  -v, --version        Print the version.
+```
+
+Everything else is the dashboard. It is the product's user interface, and where an agent's
+prompt, its coding agent and its model are chosen. There is no option that begins an agent:
+the command cannot start one at all.
+
+## How it works
+
+OpenAgent runs no coding agent and makes no model call. Starting an agent is running
+**one shell line the project itself names** — its `start` hook, in the project's own
+`.openagent/hooks.yml`:
+
+```yaml
+start: agent-runner run --detach "$PROMPT" ${DRIVER:+--driver "$DRIVER"} ${MODEL:+--model "$MODEL"} ${THEN:+--then "$THEN"} ${PUBLISH:+--publish "$PUBLISH"} ${BASE:+--base "$BASE"}
+resume: agent-runner run --detach --resume "$RUN_ID" ${TEXT:+"$TEXT"} ${ANSWER:+--answer "$ANSWER"}
+check: agent-runner check ${DRIVER:+--driver "$DRIVER"}
+```
+
+The line is given the prompt and the user's picks in its environment, and answers one JSON
+document whose `id` names the agent it began. From there the agent belongs to whatever that
+line started. Adding a project writes these three lines into the file, so a new project, an
+empty folder included, starts an agent with nothing typed by hand. They are a default: a line
+already there is kept, and any of them can be changed or deleted. A line finds its tools in the
+project's installed packages first, then in the dashboard's built-in ones, which bring `agent-runner`;
+nothing is downloaded to run a line. A project with no `start` line cannot start an agent from
+the dashboard, and the dashboard says so. `npx agent-scheduler init`, run in the project, writes
+the scheduler's `open` and `close` lines (they start it when the dashboard opens and stop it
+when it closes), keeping any line already there. The file's keys are `open`, `close`, `start`, `resume` and `check`; any other key
+is refused and the whole file ignored.
+
+The launcher's **Post-merge cleanup** box, shown where the project has the
+`post-merge-cleanup` command, puts `/post-merge-cleanup` in `THEN`: once the agent ends done
+with a pull request, agent-runner starts a fresh agent on its branch with that command and the
+first agent's id, and holds the pull request's merge until that one is done. Its default is
+Settings → Agent → Post-merge cleanup, which the box writes too.
+
+The launcher's chip above the box says which branch the agent starts from: the project's
+main branch, fetched first, or **My local branch**, the branch the project's folder is on,
+with its commits that are not pushed (edits that are not committed are not carried). The
+local pick puts the branch's name in `BASE`, and is saved per project. The chip is shown only
+when the `start` line mentions `$BASE`: a project whose line was written before the chip
+existed gets it by adding `${BASE:+--base "$BASE"}` to the line.
+
+The `check` line is what the launcher runs before a Start, with the picked coding agent in
+`DRIVER`: it answers one JSON document with `problems` (a coding agent not installed or logged
+out: said in red) and `warnings` (said in amber), each line naming its own fix. A project
+with no `check` line shows nothing there.
+
+A package's own settings are no hook. The scheduler's (how far past the quota boundary it may
+start unattended work, a switch and a publish pick per scheduled command) are the scheduler
+package's own Settings section and Overview card, and the handle on the usage bar is its stop
+line: its part of the dashboard reads them with `agent-scheduler status` and saves them with
+`agent-scheduler offset`, `switch` and `publish`.
+
+The dashboard is a **projection of the agent's own files**. The agent's tool keeps the
+agent's card (`<id>.json`) and diary (`<id>.jsonl`) under `.openagent/` in the agent's
+checkout, and copies both onto the project's `agent-data` branch when the agent ends.
+Everything the dashboard shows — live, and months later — it reads from those two files.
+
+Steering goes back the same way, never over a channel:
+
+- **What you say to a working agent** becomes a line in its `inbox.jsonl`, which the agent's
+  tool reads when a turn ends.
+- **What you say to an agent that has ended** — your words, or your answer to the question it
+  stopped on — runs the project's `resume` hook, which continues that same agent.
+- **Stop** is a signal to the process the agent's card names.
+
+So a working agent and a finished one render identically, and an agent on another machine
+needs only its lines carried home.
+
+- **One daemon per machine.** Running the CLI in any registered repo finds it. It serves
+  the dashboard, runs each project's hooks, and runs the background work — the notifications
+  and the cloud sweeps.
+- **An agent is one task being worked**, in its own checkout on its own branch. You can watch
+  it, answer its questions, and say more to it — or not be there at all.
+- **What you can ask for is your project's own commands**: its skills, read from
+  `.claude/skills/` and `.agents/skills/`, plus free text and the prompts you save.
+  OpenAgent ships no prompt text.
+- **Work leaves as a pull request**, opened by the agent itself. An agent that committed
+  nothing publishes nothing.
+
+## Layout
+
+- `src/` — the CLI, the daemon, the hooks, the reading of a project's agents, and the server
+  side of the dashboard. Node only.
+- `dashboard/` — the browser app: a Vite SPA the daemon serves as static files,
+  talking back over plain HTTP. See [its README](./dashboard/README.md).
+
+A `LOGIC.md` sits beside every source file and directory, describing the business
+logic it implements, in prose written to be read instead of the code.
+[`LOGIC.md`](./LOGIC.md) at the package root is the place to start.
+
+## Status
+
+Pre-release, published from the `0.x` line. There are no users to keep compatible,
+so the code prefers being clean over being backward-compatible.

package/dist/agent-id.d.ts

@@ -0,0 +1,13 @@
+/**
+ * An agent's id, derived from the moment it starts. Pure — no node imports — because the sweep
+ * that mints ids ahead of a claim (#1748) is reachable from the dashboard's browser bundle.
+ */
+/** Filesystem-safe, lexicographically-sortable agent id from an ISO start time. */
+export declare function agentIdFromStartedAt(startedAt: string): string;
+/**
+ * The inverse of {@link agentIdFromStartedAt}, for a caller that has the id but not the meta
+ * (#1251): picking which PR is the agent's needs the start time to tell the agent's own PR from a
+ * predecessor's on the same branch name. Undefined for an id that is not one of ours.
+ */
+export declare function startedAtFromAgentId(id: string): string | undefined;
+//# sourceMappingURL=agent-id.d.ts.map

package/dist/agent-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-id.d.ts","sourceRoot":"","sources":["../src/agent-id.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,mFAAmF;AACnF,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAI9D;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAGnE"}

package/dist/agent-id.js

@@ -0,0 +1,20 @@
+/**
+ * An agent's id, derived from the moment it starts. Pure — no node imports — because the sweep
+ * that mints ids ahead of a claim (#1748) is reachable from the dashboard's browser bundle.
+ */
+/** Filesystem-safe, lexicographically-sortable agent id from an ISO start time. */
+export function agentIdFromStartedAt(startedAt) {
+    // ISO is fixed-width, so replacing the `:`/`.` separators keeps lexical order
+    // in step with chronological order — the history list sorts by id alone.
+    return startedAt.replace(/[:.]/g, '-');
+}
+/**
+ * The inverse of {@link agentIdFromStartedAt}, for a caller that has the id but not the meta
+ * (#1251): picking which PR is the agent's needs the start time to tell the agent's own PR from a
+ * predecessor's on the same branch name. Undefined for an id that is not one of ours.
+ */
+export function startedAtFromAgentId(id) {
+    const match = /^(\d{4}-\d{2}-\d{2}T\d{2})-(\d{2})-(\d{2})-(\d{3})Z$/.exec(id);
+    return match ? `${match[1]}:${match[2]}:${match[3]}.${match[4]}Z` : undefined;
+}
+//# sourceMappingURL=agent-id.js.map

package/dist/agent-id.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-id.js","sourceRoot":"","sources":["../src/agent-id.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,mFAAmF;AACnF,MAAM,UAAU,oBAAoB,CAAC,SAAiB;IACpD,8EAA8E;IAC9E,yEAAyE;IACzE,OAAO,SAAS,CAAC,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC,CAAA;AACxC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,oBAAoB,CAAC,EAAU;IAC7C,MAAM,KAAK,GAAG,sDAAsD,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;IAC7E,OAAO,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,CAAA;AAC/E,CAAC"}

package/dist/agent-locks.d.ts

@@ -0,0 +1,3 @@
+/** Run `fn` once every earlier holder of `checkout`'s lock has settled. */
+export declare function withAgentLock<T>(checkout: string, fn: () => Promise<T>): Promise<T>;
+//# sourceMappingURL=agent-locks.d.ts.map

package/dist/agent-locks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-locks.d.ts","sourceRoot":"","sources":["../src/agent-locks.ts"],"names":[],"mappings":"AAwBA,2EAA2E;AAC3E,wBAAsB,aAAa,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAgBzF"}

package/dist/agent-locks.js

@@ -0,0 +1,40 @@
+import { resolve } from 'node:path';
+/**
+ * Serialize the dashboard's own actions against one run's checkout.
+ *
+ * Two clicks on the same finished run (Open PR, and Remove or Delete of its checkout) each run
+ * their own git in that checkout. Unserialized they raced: the loser reported "could not commit
+ * the work this session left uncommitted", and a removal that lost kept a worktree it should have
+ * taken. Both actions are served inside the daemon's own process (the dashboard's RPCs are), so
+ * an in-process lock is the whole fix between them.
+ *
+ * It does NOT coordinate with the run's own tool (#1774), which is another process and reclaims
+ * the checkout itself when the run ends. What keeps those two apart is that the run has to have
+ * ended before the dashboard offers either action, and that the tool's own reclaim refuses a
+ * checkout it cannot take cleanly.
+ *
+ * Keyed by the checkout path, resolved, so the actions against one run contend on one key;
+ * actions against a run whose checkout is already gone key on the project root, where nothing
+ * contends. A waiter chains on the predecessor's *settlement* — a failed removal must not skip
+ * the action waiting behind it — and each caller still gets its own outcome (or failure) back
+ * untouched.
+ */
+const chains = new Map();
+/** Run `fn` once every earlier holder of `checkout`'s lock has settled. */
+export async function withAgentLock(checkout, fn) {
+    const key = resolve(checkout);
+    const prev = chains.get(key) ?? Promise.resolve();
+    const agent = prev.then(fn, fn);
+    // What the next waiter chains on: settlement, never rejection — one failed holder must not
+    // poison every later acquisition of the same key.
+    const settled = agent.then(() => { }, () => { });
+    chains.set(key, settled);
+    try {
+        return await agent;
+    }
+    finally {
+        if (chains.get(key) === settled)
+            chains.delete(key);
+    }
+}
+//# sourceMappingURL=agent-locks.js.map

package/dist/agent-locks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-locks.js","sourceRoot":"","sources":["../src/agent-locks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAEnC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,GAAG,IAAI,GAAG,EAA4B,CAAA;AAElD,2EAA2E;AAC3E,MAAM,CAAC,KAAK,UAAU,aAAa,CAAI,QAAgB,EAAE,EAAoB;IAC3E,MAAM,GAAG,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAA;IAC7B,MAAM,IAAI,GAAG,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,OAAO,CAAC,OAAO,EAAE,CAAA;IACjD,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC,CAAA;IAC/B,2FAA2F;IAC3F,kDAAkD;IAClD,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,CACxB,GAAG,EAAE,GAAE,CAAC,EACR,GAAG,EAAE,GAAE,CAAC,CACT,CAAA;IACD,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,OAAO,CAAC,CAAA;IACxB,IAAI,CAAC;QACH,OAAO,MAAM,KAAK,CAAA;IACpB,CAAC;YAAS,CAAC;QACT,IAAI,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,OAAO;YAAE,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;IACrD,CAAC;AACH,CAAC"}

package/dist/agent-view.d.ts

@@ -0,0 +1,39 @@
+import type { OpenAgentEvent } from './events.js';
+/** One error of a run: one the agent reported through an `error` block (#1500), or one its tool wrote in the diary. */
+export interface AgentError {
+    /** What is wrong, in one line. */
+    headline: string;
+    /** What it ran and what that said, when the agent wrote any. */
+    detail?: string;
+}
+/**
+ * Every error of the run (#1500), oldest first — the count the dashboard shows on the session, and
+ * the latest headline it shows beside it. Two sources: the `error` lines the run's tool writes in
+ * the diary when the coding agent or its transport fails (the message's first line is the
+ * headline, the rest the detail), and the `error` blocks of runs recorded before the daemon
+ * stopped running agents.
+ *
+ * A fold over the log rather than state of its own: an error is an event that happened, so the
+ * list only ever grows, and reopening a finished agent shows exactly what it showed while it ran.
+ */
+export declare function agentErrors(events: readonly OpenAgentEvent[]): AgentError[];
+/** The wrapped agent session (#431): its id and a deep link, when one is known. */
+export interface SessionInfo {
+    sessionId?: string;
+    sessionLink?: string;
+    /**
+     * The directory the agent ran in (#1195), from the opening `session` event.
+     *
+     * Taken from the event rather than the filesystem on purpose: an agent that finishes cleanly has
+     * its worktree removed (`tearDownWorktree`), so the event is the only surviving record of where
+     * the session lived — and that path is exactly what `claude --resume` needs to find it again.
+     */
+    workspace?: string;
+}
+/**
+ * The session behind the agent (#431): the workspace from the opening `session`
+ * event, then the id and any deep link from the latest `session-update`. Null before the
+ * session opens. The link is what the old dashboard surfaced as "open session".
+ */
+export declare function sessionInfo(events: readonly OpenAgentEvent[]): SessionInfo | null;
+//# sourceMappingURL=agent-view.d.ts.map

package/dist/agent-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-view.d.ts","sourceRoot":"","sources":["../src/agent-view.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAOjD,uHAAuH;AACvH,MAAM,WAAW,UAAU;IACzB,kCAAkC;IAClC,QAAQ,EAAE,MAAM,CAAA;IAChB,gEAAgE;IAChE,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,SAAS,cAAc,EAAE,GAAG,UAAU,EAAE,CAY3E;AAED,mFAAmF;AACnF,MAAM,WAAW,WAAW;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,SAAS,cAAc,EAAE,GAAG,WAAW,GAAG,IAAI,CAajF"}

package/dist/agent-view.js

@@ -0,0 +1,45 @@
+/**
+ * Every error of the run (#1500), oldest first — the count the dashboard shows on the session, and
+ * the latest headline it shows beside it. Two sources: the `error` lines the run's tool writes in
+ * the diary when the coding agent or its transport fails (the message's first line is the
+ * headline, the rest the detail), and the `error` blocks of runs recorded before the daemon
+ * stopped running agents.
+ *
+ * A fold over the log rather than state of its own: an error is an event that happened, so the
+ * list only ever grows, and reopening a finished agent shows exactly what it showed while it ran.
+ */
+export function agentErrors(events) {
+    const errors = [];
+    for (const event of events) {
+        if (event.kind === 'error') {
+            errors.push({ headline: event.headline, ...(event.detail ? { detail: event.detail } : {}) });
+        }
+        else if (event.kind === 'driver' && event.event.type === 'error' && typeof event.event.message === 'string') {
+            const [headline = '', ...rest] = event.event.message.trim().split('\n');
+            const detail = rest.join('\n').trim();
+            errors.push({ headline: headline || 'error', ...(detail ? { detail } : {}) });
+        }
+    }
+    return errors;
+}
+/**
+ * The session behind the agent (#431): the workspace from the opening `session`
+ * event, then the id and any deep link from the latest `session-update`. Null before the
+ * session opens. The link is what the old dashboard surfaced as "open session".
+ */
+export function sessionInfo(events) {
+    let info = null;
+    for (const event of events) {
+        if (event.kind === 'session') {
+            info = {
+                workspace: event.workspace,
+                ...(event.sessionLink ? { sessionLink: event.sessionLink } : {}),
+            };
+        }
+        else if (event.kind === 'session-update') {
+            info = { ...(info ?? {}), sessionId: event.sessionId, ...(event.sessionLink ? { sessionLink: event.sessionLink } : {}) };
+        }
+    }
+    return info;
+}
+//# sourceMappingURL=agent-view.js.map

package/dist/agent-view.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-view.js","sourceRoot":"","sources":["../src/agent-view.ts"],"names":[],"mappings":"AAeA;;;;;;;;;GASG;AACH,MAAM,UAAU,WAAW,CAAC,MAAiC;IAC3D,MAAM,MAAM,GAAiB,EAAE,CAAA;IAC/B,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,IAAI,KAAK,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;YAC3B,MAAM,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAA;QAC9F,CAAC;aAAM,IAAI,KAAK,CAAC,IAAI,KAAK,QAAQ,IAAI,KAAK,CAAC,KAAK,CAAC,IAAI,KAAK,OAAO,IAAI,OAAO,KAAK,CAAC,KAAK,CAAC,OAAO,KAAK,QAAQ,EAAE,CAAC;YAC9G,MAAM,CAAC,QAAQ,GAAG,EAAE,EAAE,GAAG,IAAI,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;YACvE,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAA;YACrC,MAAM,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,QAAQ,IAAI,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAA;QAC/E,CAAC;IACH,CAAC;IACD,OAAO,MAAM,CAAA;AACf,CAAC;AAgBD;;;;GAIG;AACH,MAAM,UAAU,WAAW,CAAC,MAAiC;IAC3D,IAAI,IAAI,GAAuB,IAAI,CAAA;IACnC,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;YAC7B,IAAI,GAAG;gBACL,SAAS,EAAE,KAAK,CAAC,SAAS;gBAC1B,GAAG,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,KAAK,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;aACjE,CAAA;QACH,CAAC;aAAM,IAAI,KAAK,CAAC,IAAI,KAAK,gBAAgB,EAAE,CAAC;YAC3C,IAAI,GAAG,EAAE,GAAG,CAAC,IAAI,IAAI,EAAE,CAAC,EAAE,SAAS,EAAE,KAAK,CAAC,SAAS,EAAE,GAAG,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,KAAK,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAA;QAC1H,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAA;AACb,CAAC"}

package/dist/bin.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=bin.d.ts.map

package/dist/bin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../src/bin.ts"],"names":[],"mappings":""}

package/dist/bin.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import { runCli } from './cli.js';
+runCli(process.argv.slice(2))
+    .then(code => {
+    process.exitCode = code;
+})
+    .catch((err) => {
+    console.error(err);
+    process.exitCode = 1;
+});
+//# sourceMappingURL=bin.js.map

package/dist/bin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin.js","sourceRoot":"","sources":["../src/bin.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAEjC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;KAC1B,IAAI,CAAC,IAAI,CAAC,EAAE;IACX,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAA;AACzB,CAAC,CAAC;KACD,KAAK,CAAC,CAAC,GAAY,EAAE,EAAE;IACtB,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;IAClB,OAAO,CAAC,QAAQ,GAAG,CAAC,CAAA;AACtB,CAAC,CAAC,CAAA"}

package/dist/branch-name.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Whether `value` names a branch the way git lets a branch be named (`git check-ref-format
+ * --branch`), told without running git. The branch a Start names to start from ends up on a
+ * command line, so a word that could be read there as an option (a leading `-`), or that git would
+ * read as something other than one branch (`a..b`, `x@{1}`, `HEAD`), is not a name.
+ */
+export declare function isBranchName(value: unknown): value is string;
+//# sourceMappingURL=branch-name.d.ts.map

package/dist/branch-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"branch-name.d.ts","sourceRoot":"","sources":["../src/branch-name.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAQ5D"}

package/dist/branch-name.js

@@ -0,0 +1,20 @@
+/**
+ * Whether `value` names a branch the way git lets a branch be named (`git check-ref-format
+ * --branch`), told without running git. The branch a Start names to start from ends up on a
+ * command line, so a word that could be read there as an option (a leading `-`), or that git would
+ * read as something other than one branch (`a..b`, `x@{1}`, `HEAD`), is not a name.
+ */
+export function isBranchName(value) {
+    if (typeof value !== 'string' || value === '' || value.length > 255)
+        return false;
+    if (value === 'HEAD' || value === '@' || value.startsWith('-'))
+        return false;
+    // What git refuses anywhere in a ref: a space, a control character, and the characters its
+    // revision syntax uses.
+    if (/[\x00-\x20\x7f~^:?*[\\]/.test(value) || value.includes('..') || value.includes('@{'))
+        return false;
+    if (value.endsWith('.'))
+        return false;
+    return value.split('/').every(part => part !== '' && !part.startsWith('.') && !part.endsWith('.lock'));
+}
+//# sourceMappingURL=branch-name.js.map

package/dist/branch-name.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"branch-name.js","sourceRoot":"","sources":["../src/branch-name.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAAC,KAAc;IACzC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,EAAE,IAAI,KAAK,CAAC,MAAM,GAAG,GAAG;QAAE,OAAO,KAAK,CAAA;IACjF,IAAI,KAAK,KAAK,MAAM,IAAI,KAAK,KAAK,GAAG,IAAI,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC;QAAE,OAAO,KAAK,CAAA;IAC5E,2FAA2F;IAC3F,wBAAwB;IACxB,IAAI,yBAAyB,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC;QAAE,OAAO,KAAK,CAAA;IACvG,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC;QAAE,OAAO,KAAK,CAAA;IACrC,OAAO,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAA;AACxG,CAAC"}

package/dist/bridge-browser.d.ts

@@ -0,0 +1,217 @@
+/**
+ * The bridge browser (#1332): a Chrome for Testing the daemon launches and owns, with the Claude
+ * web bridge extension installed, signed in to claude.ai once by the user and kept minimized.
+ *
+ * The bridge's far end is a browser signed in to claude.ai. Until now that was the user's own
+ * Chrome with the extension loaded, so a web run could only start — and a parked question could
+ * only be noticed — while that Chrome happened to be open. The spike on #1332 settled what a
+ * browser nobody attends has to be: headed, because claude.ai's Cloudflare gate never clears a
+ * headless one; Chrome for Testing, because branded Chrome stopped loading unpacked extensions
+ * from the command line; and installed over CDP with developer mode on, because an extension
+ * loaded any other way is disabled the first time it reloads itself (#1712).
+ *
+ * Nothing here talks to claude.ai. The daemon launches the browser, hands the extension the
+ * bridge token, and from then on the extension's Driver tab does exactly what it does in the
+ * user's own Chrome — the daemon only keeps the window out of the way and brings it up when the
+ * user has to sign in.
+ */
+/** The directory holding the bridge browser's profile and binary, next to the registry file. */
+export declare const BRIDGE_BROWSER_DIR = "openagent-browser";
+/**
+ * Where the bridge browser lives: `$XDG_CONFIG_HOME/openagent-browser` when set, else the
+ * dotted `$HOME/.openagent-browser`. Beside the registry, so the same variable that isolates
+ * a test's registry isolates its browser, and a machine's real one is never touched from a test.
+ * The profile inside it is persistent on purpose: the user signs in once and the sign-in outlives
+ * every daemon restart.
+ */
+export declare function bridgeBrowserDir(env: NodeJS.ProcessEnv): string;
+/**
+ * The launch flags. Headed (no `--headless`): claude.ai's bot gate rejects a headless browser
+ * outright, and a headed one whose window is minimized passes. The unsafe-extension-debugging
+ * flag is what lets `Extensions.loadUnpacked` install the extension over CDP. The keychain flags
+ * keep the cookie-encryption key out of the OS keychain (macOS asks for the login password on
+ * every launch otherwise, and Linux for the wallet) — the same choice Puppeteer makes; the profile
+ * directory's own permissions are what guard the sign-in.
+ */
+export declare function bridgeBrowserLaunchArgs(port: number, profileDir: string): string[];
+/** Where the extension's files are, and whether that is a checkout, where they are edited in place. */
+export interface BridgeExtensionSource {
+    dir: string;
+    checkout: boolean;
+}
+/**
+ * The extension's files (#1720): the checkout's `packages/chrome-extension` next to this package,
+ * so an edit there reaches the browser through the extension's self-reload; else the copy the
+ * build puts in `dist/chrome-extension`, which is what an installed package has. A folder counts
+ * only when its manifest names the bridge extension. Undefined when neither is there.
+ * `moduleUrl` is this file's URL; tests point it elsewhere.
+ */
+export declare function bridgeExtensionSource(moduleUrl?: string): BridgeExtensionSource | undefined;
+/**
+ * The process holding a profile's singleton lock, or undefined when nothing does. Chrome leaves
+ * the lock behind as a symlink whose target is `<host>-<pid>`; a daemon that died without closing
+ * its browser leaves that browser running, and a second Chrome on the same profile would hand its
+ * command line to the first and exit at once.
+ */
+export declare function profileLockOwner(profileDir: string, readLink?: (path: string) => Promise<string>): Promise<number | undefined>;
+/** One page, worker or browser-internal target Chrome lists. */
+export interface CdpTarget {
+    id: string;
+    type: string;
+    url: string;
+    webSocketDebuggerUrl?: string;
+}
+/** A session on one target: the calls go to that page or worker rather than to the browser. */
+export interface CdpTargetSession {
+    send(method: string, params?: Record<string, unknown>): Promise<unknown>;
+    close(): void;
+}
+/** How the daemon talks to its browser. Injectable: the real one speaks WebSocket to Chrome. */
+export interface BridgeBrowserCdp {
+    /** A browser-level call: installing the extension, opening and closing targets, window bounds. */
+    call(method: string, params?: Record<string, unknown>): Promise<unknown>;
+    /** Every target Chrome lists — pages, the extension's worker, browser-internal pages. */
+    targets(): Promise<CdpTarget[]>;
+    /** Attach to one target. */
+    attach(target: CdpTarget): Promise<CdpTargetSession>;
+    /** Drop the browser-level connection. The browser keeps running. */
+    close(): void;
+}
+/** The real connection: the browser socket from `/json/version`, targets from `/json/list`. */
+export declare function connectBridgeBrowser(browserUrl: string): Promise<BridgeBrowserCdp>;
+/** Install the extension from its directory. Chrome answers with the extension's id. */
+export declare function installExtension(cdp: BridgeBrowserCdp, extensionDir: string): Promise<string>;
+/**
+ * The developer-mode switch on Chrome's extensions page, flipped on if it is off. Chrome (137
+ * and later) disables an unpacked extension on reload while the mode is off, and the extension
+ * reloads itself whenever its files change (#1712), so without this the bridge would die on the
+ * first edit or pull. The profile remembers the setting, but writing the preference into the
+ * profile directly does nothing — the switch is the one way that works.
+ */
+export declare const DEVELOPER_MODE_ON = "(() => {\n  const manager = document.querySelector('extensions-manager')?.shadowRoot\n  const toggle = manager?.querySelector('extensions-toolbar')?.shadowRoot?.querySelector('#devMode')\n  if (!toggle) return 'missing'\n  if (!toggle.checked) toggle.click()\n  return 'on'\n})()";
+/** Open Chrome's extensions page in the background, switch developer mode on, close the page. */
+export declare function enableDeveloperMode(cdp: BridgeBrowserCdp, sleep: (ms: number) => Promise<void>): Promise<void>;
+/**
+ * What the extension is told, run inside its own worker: the daemon's address and the bridge
+ * token go into the storage its options page would have written, and the Driver tab is opened
+ * as the one pinned claude.ai/code tab — the shape the extension adopts as its Driver — in place
+ * of the blank page the browser started on. Opened here rather than left to the extension
+ * because the extension opens no Driver tab while the daemon lists no cloud session, and the user
+ * signs in on that tab before any session exists.
+ */
+export declare function seedExpression(daemonUrl: string, token: string): string;
+/** Hand the freshly installed extension its daemon and token, in its service worker. */
+export declare function seedExtension(cdp: BridgeBrowserCdp, extensionId: string, daemonUrl: string, token: string, sleep: (ms: number) => Promise<void>): Promise<void>;
+/** The bridge browser once it runs. */
+export interface BridgeBrowser {
+    extensionId: string;
+    /** The path the claude.ai tab is on (`/login` while signed out), or undefined without such a tab. */
+    page(): Promise<string | undefined>;
+    /** Restore the window and bring the browser to the front, for the user to sign in. */
+    show(): Promise<void>;
+    /** Minimize the window again. */
+    hide(): Promise<void>;
+    /** Called once if Chrome exits on its own — the user quit it, or it crashed. */
+    onExit(listener: (detail: string) => void): void;
+    /** Close the browser. Safe to call twice. */
+    close(): Promise<void>;
+}
+/** The Chrome process, as much of it as this module needs. */
+export interface BridgeBrowserProcess {
+    pid?: number | undefined;
+    kill(signal?: NodeJS.Signals): unknown;
+    on(event: 'exit', listener: (code: number | null, signal: NodeJS.Signals | null) => void): unknown;
+    on(event: 'error', listener: (err: Error) => void): unknown;
+}
+/** Everything the launch touches outside its own logic. Injectable so the sequence is testable without a Chrome. */
+export interface BridgeBrowserDeps {
+    /** The Chrome for Testing binary, downloaded into `cacheDir` if none is there yet. */
+    binary(cacheDir: string, report: (detail: string) => void): Promise<string>;
+    /** The process holding the profile's lock, if any. */
+    lockOwner(profileDir: string): Promise<number | undefined>;
+    alive(pid: number): boolean;
+    kill(pid: number, signal: NodeJS.Signals): void;
+    port(): Promise<number>;
+    spawn(binary: string, args: string[]): BridgeBrowserProcess;
+    ready(browserUrl: string): Promise<boolean>;
+    connect(browserUrl: string): Promise<BridgeBrowserCdp>;
+    /** Bring the browser application to the front (macOS: activate the app bundle). */
+    activate(binary: string): void;
+    sleep(ms: number): Promise<void>;
+}
+/**
+ * The Chrome for Testing binary in `cacheDir`, or the current stable one downloaded there (about
+ * 150 MB, once). Chrome for Testing rather than whatever Chrome the machine has: branded Chrome
+ * ignores an unpacked extension handed to it from outside, and the agent's own browser lookup
+ * would find exactly that.
+ */
+export declare function bridgeBrowserBinary(cacheDir: string, report: (detail: string) => void): Promise<string>;
+/** macOS: the `.app` bundle the binary lives in, which `open` activates. Undefined elsewhere. */
+export declare function appBundle(binary: string): string | undefined;
+/** The real dependencies. */
+export declare function bridgeBrowserDeps(): BridgeBrowserDeps;
+/**
+ * Make sure nothing else holds the profile: a browser a dead daemon left behind is stopped,
+ * gently first. It is OpenAgent's own profile, so whatever holds it is OpenAgent's own
+ * leftover; nothing the user runs shares it.
+ */
+export declare function freeProfile(profileDir: string, deps: BridgeBrowserDeps): Promise<boolean>;
+/** What a launch needs to know. */
+export interface BridgeBrowserOptions {
+    /** Where the daemon listens — what the extension is told to call. */
+    daemonUrl: string;
+    /** The bridge token the extension presents on every call. */
+    token: string;
+    /** The bridge browser's directory: the profile and the binary live under it. */
+    dir: string;
+    /** The extension's files. Default: `bridgeExtensionSource()`. */
+    extension?: BridgeExtensionSource | undefined;
+    /** Progress, one line at a time, for the dashboard to show while the launch runs. */
+    report?: ((detail: string) => void) | undefined;
+}
+/**
+ * Launch the bridge browser and get it ready: binary, profile, extension, developer mode, token,
+ * Driver tab, minimized. Throws with the step that failed; the browser is closed again on a
+ * failure after the spawn, so a half-set-up browser is never left running.
+ */
+export declare function startBridgeBrowser(opts: BridgeBrowserOptions, deps?: BridgeBrowserDeps): Promise<BridgeBrowser>;
+/** Where the bridge browser stands, for the dashboard. */
+export type BridgeBrowserStatus = {
+    state: 'off';
+} | {
+    state: 'starting';
+    detail: string;
+}
+/** `signIn`: the claude.ai tab is on the sign-in page, so a person has to sign in before anything is served. */
+ | {
+    state: 'running';
+    since: string;
+    visible: boolean;
+    signIn: boolean;
+} | {
+    state: 'stopped';
+    detail: string;
+};
+/** What the dashboard can ask of the bridge browser. */
+export type BridgeBrowserAction = 'show' | 'hide' | 'restart';
+/** The daemon's handle on its bridge browser: one at a time, started and stopped from the preference and the dashboard. */
+export interface BridgeBrowserOwner {
+    /** Where the browser stands; a running one is asked which page its claude.ai tab is on. */
+    status(): Promise<BridgeBrowserStatus>;
+    /** Launch it, unless it is running or on its way. Resolves once the launch is over, either way. */
+    start(): Promise<void>;
+    /** Close it, or cancel a launch under way. */
+    stop(): Promise<void>;
+    act(action: BridgeBrowserAction): Promise<void>;
+}
+/** How the owner launches a browser: the daemon's real launch, or a test's fake. */
+export type BridgeBrowserLauncher = (report: (detail: string) => void) => Promise<BridgeBrowser>;
+/**
+ * The one bridge browser a daemon runs. A launch is slow — the first one downloads Chrome — so
+ * the status carries the step it is on, and a stop that lands mid-launch closes the browser the
+ * launch then hands over rather than leaving it running unowned. A browser that exits on its own
+ * (the user quit it) is reported as stopped with the reason, and not relaunched: quitting it was
+ * an act, and the dashboard offers a restart.
+ */
+export declare function bridgeBrowserOwner(launch: BridgeBrowserLauncher, log?: (line: string) => void): BridgeBrowserOwner;
+//# sourceMappingURL=bridge-browser.d.ts.map