@openagt/dashboard 0.0.0-stage → 0.9.0

package/dist/install.d.ts

@@ -0,0 +1,31 @@
+import { type GitRunner } from '@openagt/agent-data';
+import { type StoreFs } from './store/index.js';
+/**
+ * Install/activate a repo for OpenAgent (#391): create the `.openagent/` marker and its
+ * ignore file. Nothing is committed on a branch that has a commit. Pure core over the same
+ * {@link GitRunner} + {@link StoreFs} seams as project.ts.
+ */
+/** The message of the empty commit an install gives a repository that has none. */
+export declare const FIRST_COMMIT_MESSAGE = "[OpenAgent] first commit";
+/** The outcome of {@link installProject}. Failures are values, never throws. */
+export type InstallResult = {
+    ok: true;
+    alreadyActivated?: boolean;
+    initialized?: boolean;
+} | {
+    ok: false;
+    error: string;
+};
+/** Injectable seams for {@link installProject}. */
+export interface InstallDeps {
+    git?: GitRunner;
+    fs?: StoreFs;
+}
+/**
+ * Activate the repo at `cwd`: create `.openagent/` with its ignore file, which hides the whole
+ * directory from git, itself included, so the person's repository shows no change. A repo whose
+ * ignore file is already there is a no-op (`alreadyActivated`) — the ignore file is the
+ * activation marker. Forgiving: any git/fs failure surfaces as `{ ok: false, error }`.
+ */
+export declare function installProject(cwd: string, deps?: InstallDeps): Promise<InstallResult>;
+//# sourceMappingURL=install.d.ts.map

package/dist/install.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"install.d.ts","sourceRoot":"","sources":["../src/install.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,KAAK,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAGnE,OAAO,EAAe,KAAK,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAG5D;;;;GAIG;AAEH,mFAAmF;AACnF,eAAO,MAAM,oBAAoB,6BAA6B,CAAA;AAK9D,gFAAgF;AAChF,MAAM,MAAM,aAAa,GACrB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAAC,WAAW,CAAC,EAAE,OAAO,CAAA;CAAE,GAC/D;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAEhC,mDAAmD;AACnD,MAAM,WAAW,WAAW;IAC1B,GAAG,CAAC,EAAE,SAAS,CAAA;IACf,EAAE,CAAC,EAAE,OAAO,CAAA;CACb;AAED;;;;;GAKG;AACH,wBAAsB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,GAAE,WAAgB,GAAG,OAAO,CAAC,aAAa,CAAC,CAgChG"}

package/dist/install.js

@@ -0,0 +1,54 @@
+import { join } from 'node:path';
+import { nodeGitRunner } from '@openagt/agent-data';
+import { OPENAGENT_DIR } from './openagent-dir.js';
+import { openagentGitignore, gitignorePath } from './openagent-gitignore.js';
+import { nodeStoreFs } from './store/index.js';
+import { errorMessage } from './error-message.js';
+/**
+ * Install/activate a repo for OpenAgent (#391): create the `.openagent/` marker and its
+ * ignore file. Nothing is committed on a branch that has a commit. Pure core over the same
+ * {@link GitRunner} + {@link StoreFs} seams as project.ts.
+ */
+/** The message of the empty commit an install gives a repository that has none. */
+export const FIRST_COMMIT_MESSAGE = '[OpenAgent] first commit';
+/** Git's tree with no file in it. */
+const EMPTY_TREE = '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
+/**
+ * Activate the repo at `cwd`: create `.openagent/` with its ignore file, which hides the whole
+ * directory from git, itself included, so the person's repository shows no change. A repo whose
+ * ignore file is already there is a no-op (`alreadyActivated`) — the ignore file is the
+ * activation marker. Forgiving: any git/fs failure surfaces as `{ ok: false, error }`.
+ */
+export async function installProject(cwd, deps = {}) {
+    const git = deps.git ?? nodeGitRunner();
+    const fs = deps.fs ?? nodeStoreFs();
+    if (await fs.exists(gitignorePath(cwd)))
+        return { ok: true, alreadyActivated: true };
+    try {
+        // Auto-initialize a repo when the folder isn't one yet: OpenAgent treats
+        // git as the source of truth, so `git init` it for the user rather than erroring.
+        const insideRepo = await git(['rev-parse', '--is-inside-work-tree'], cwd)
+            .then(out => out.trim() === 'true')
+            .catch(() => false);
+        if (!insideRepo)
+            await git(['init'], cwd);
+        // A repository with no commit cannot give an agent's branch a start. Its first commit is
+        // made empty, straight from the empty tree: the index is not read, so a file the person has
+        // staged stays staged and none of theirs is committed. Before the marker below, so a commit
+        // that fails leaves a folder the next add tries again.
+        const hasCommit = await git(['rev-parse', '--verify', '--quiet', 'HEAD'], cwd).then(() => true, () => false);
+        if (!hasCommit) {
+            const first = (await git(['commit-tree', EMPTY_TREE, '-m', FIRST_COMMIT_MESSAGE], cwd)).trim();
+            await git(['update-ref', 'HEAD', first], cwd);
+        }
+        await fs.mkdir(join(cwd, OPENAGENT_DIR));
+        // Keep what lives under `.openagent/` (a run's live files, the hooks file) out of git
+        // (#313). The early return above established the file is absent.
+        await fs.write(gitignorePath(cwd), openagentGitignore());
+        return insideRepo ? { ok: true } : { ok: true, initialized: true };
+    }
+    catch (err) {
+        return { ok: false, error: errorMessage(err) };
+    }
+}
+//# sourceMappingURL=install.js.map

package/dist/install.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"install.js","sourceRoot":"","sources":["../src/install.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAChC,OAAO,EAAE,aAAa,EAAkB,MAAM,qBAAqB,CAAA;AACnE,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAClD,OAAO,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AAC5E,OAAO,EAAE,WAAW,EAAgB,MAAM,kBAAkB,CAAA;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAEjD;;;;GAIG;AAEH,mFAAmF;AACnF,MAAM,CAAC,MAAM,oBAAoB,GAAG,0BAA0B,CAAA;AAE9D,qCAAqC;AACrC,MAAM,UAAU,GAAG,0CAA0C,CAAA;AAa7D;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAAC,GAAW,EAAE,IAAI,GAAgB,EAAE;IACtE,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,IAAI,aAAa,EAAE,CAAA;IACvC,MAAM,EAAE,GAAG,IAAI,CAAC,EAAE,IAAI,WAAW,EAAE,CAAA;IAEnC,IAAI,MAAM,EAAE,CAAC,MAAM,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;QAAE,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,gBAAgB,EAAE,IAAI,EAAE,CAAA;IAEpF,IAAI,CAAC;QACH,yEAAyE;QACzE,kFAAkF;QAClF,MAAM,UAAU,GAAG,MAAM,GAAG,CAAC,CAAC,WAAW,EAAE,uBAAuB,CAAC,EAAE,GAAG,CAAC;aACtE,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,MAAM,CAAC;aAClC,KAAK,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAA;QACrB,IAAI,CAAC,UAAU;YAAE,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,GAAG,CAAC,CAAA;QAEzC,yFAAyF;QACzF,4FAA4F;QAC5F,4FAA4F;QAC5F,uDAAuD;QACvD,MAAM,SAAS,GAAG,MAAM,GAAG,CAAC,CAAC,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,CAAA;QAC5G,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,MAAM,KAAK,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,aAAa,EAAE,UAAU,EAAE,IAAI,EAAE,oBAAoB,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,CAAA;YAC9F,MAAM,GAAG,CAAC,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,GAAG,CAAC,CAAA;QAC/C,CAAC;QAED,MAAM,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,aAAa,CAAC,CAAC,CAAA;QACxC,sFAAsF;QACtF,iEAAiE;QACjE,MAAM,EAAE,CAAC,KAAK,CAAC,aAAa,CAAC,GAAG,CAAC,EAAE,kBAAkB,EAAE,CAAC,CAAA;QACxD,OAAO,UAAU,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,CAAA;IACpE,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,YAAY,CAAC,GAAG,CAAC,EAAE,CAAA;IAChD,CAAC;AACH,CAAC"}

package/dist/jsonl-tail.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Tails an append-only JSONL log, calling `onLine` for each complete line as it
+ * is written. Reads only the bytes appended since the last {@link pull},
+ * buffering a torn trailing line until its newline arrives. A file that shrinks
+ * (a fresh agent truncated the log) resets to the start so the new content is
+ * picked up. The generic base behind the daemon's event tail and the agent's
+ * control tail (#344) — one tailer, two directions.
+ */
+export declare class JsonlTailer<T> {
+    private path;
+    private readonly onLine;
+    /** Told when the log is found rewritten, before its lines are read again from the top. */
+    private readonly onReset?;
+    private offset;
+    private partial;
+    private lastMtimeMs;
+    private adoptMtime;
+    constructor(path: string, onLine: (value: T) => void, 
+    /** Told when the log is found rewritten, before its lines are read again from the top. */
+    onReset?: (() => void) | undefined);
+    /**
+     * Point the tailer at the log's new home, keeping the read offset. For a log that is
+     * *relocated with its content intact* — a run's diary is copied verbatim onto the data branch
+     * when the run ends and its checkout is reclaimed — the bytes already consumed are a prefix of
+     * the new file, so the next {@link pull} delivers exactly the lines the move would otherwise
+     * have swallowed, without replaying what was already delivered.
+     *
+     * The first pull after a retarget adopts the new home's mtime instead of running the
+     * same-length-rewrite check: the copy is younger than the original by construction, and a
+     * fully-consumed log would otherwise read as "rewritten to the same length" and replay
+     * every line it already delivered.
+     */
+    retarget(path: string): void;
+    /** Read and dispatch any lines appended since the previous call. */
+    pull(): Promise<void>;
+}
+/** Options for {@link followFile}. */
+export interface FollowFileOptions {
+    /** How often the backstop poll runs. */
+    pollMs: number;
+    /**
+     * Let the process exit with the tail still running (steering must never hold it open).
+     * Covers both handles this opens — the poll timer *and* the `fs.watch` — since either one
+     * on its own is enough to keep the event loop alive.
+     */
+    unref?: boolean;
+}
+/**
+ * Drive a {@link JsonlTailer} as the file grows: an `fs.watch` on `dir` for latency, plus a
+ * poll backstop because `fs.watch` is unreliable across platforms. Pulls are serialized (a
+ * pull already in flight swallows the next trigger) and stop for good once the returned
+ * function is called. Shared by the agent's control tail and the dashboard's event tail, which
+ * hand-rolled this separately and drifted apart.
+ *
+ * Nothing here may throw at the process: a failed pull and a watcher error are both survivable,
+ * and the poll alone is a complete tail (#996).
+ */
+export declare function followFile(dir: string, pull: () => Promise<void>, opts: FollowFileOptions): () => void;
+//# sourceMappingURL=jsonl-tail.d.ts.map

package/dist/jsonl-tail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonl-tail.d.ts","sourceRoot":"","sources":["../src/jsonl-tail.ts"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,qBAAa,WAAW,CAAC,CAAC;IAOtB,OAAO,CAAC,IAAI;IACZ,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,0FAA0F;IAC1F,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC;IAT3B,OAAO,CAAC,MAAM,CAAI;IAClB,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,WAAW,CAAI;IACvB,OAAO,CAAC,UAAU,CAAQ;IAE1B,YACU,IAAI,EAAE,MAAM,EACH,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI;IAC3C,0FAA0F;IACzE,OAAO,CAAC,GAAE,MAAM,IAAI,aAAA,EACnC;IAEJ;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAG3B;IAED,oEAAoE;IAC9D,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAwC1B;CACF;AAED,sCAAsC;AACtC,MAAM,WAAW,iBAAiB;IAChC,wCAAwC;IACxC,MAAM,EAAE,MAAM,CAAA;IACd;;;;OAIG;IACH,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,iBAAiB,GAAG,MAAM,IAAI,CA+CtG"}

package/dist/jsonl-tail.js

@@ -0,0 +1,152 @@
+import { watch } from 'node:fs';
+import { open } from 'node:fs/promises';
+/**
+ * Tails an append-only JSONL log, calling `onLine` for each complete line as it
+ * is written. Reads only the bytes appended since the last {@link pull},
+ * buffering a torn trailing line until its newline arrives. A file that shrinks
+ * (a fresh agent truncated the log) resets to the start so the new content is
+ * picked up. The generic base behind the daemon's event tail and the agent's
+ * control tail (#344) — one tailer, two directions.
+ */
+export class JsonlTailer {
+    path;
+    onLine;
+    onReset;
+    offset = 0;
+    partial = '';
+    lastMtimeMs = 0;
+    adoptMtime = false;
+    constructor(path, onLine, 
+    /** Told when the log is found rewritten, before its lines are read again from the top. */
+    onReset) {
+        this.path = path;
+        this.onLine = onLine;
+        this.onReset = onReset;
+    }
+    /**
+     * Point the tailer at the log's new home, keeping the read offset. For a log that is
+     * *relocated with its content intact* — a run's diary is copied verbatim onto the data branch
+     * when the run ends and its checkout is reclaimed — the bytes already consumed are a prefix of
+     * the new file, so the next {@link pull} delivers exactly the lines the move would otherwise
+     * have swallowed, without replaying what was already delivered.
+     *
+     * The first pull after a retarget adopts the new home's mtime instead of running the
+     * same-length-rewrite check: the copy is younger than the original by construction, and a
+     * fully-consumed log would otherwise read as "rewritten to the same length" and replay
+     * every line it already delivered.
+     */
+    retarget(path) {
+        this.path = path;
+        this.adoptMtime = true;
+    }
+    /** Read and dispatch any lines appended since the previous call. */
+    async pull() {
+        let fd;
+        try {
+            fd = await open(this.path, 'r');
+        }
+        catch {
+            return; // not created yet (nothing has written)
+        }
+        try {
+            const { size, mtimeMs } = await fd.stat();
+            // A fresh agent truncates the log in place (same inode). Detect it two ways: the
+            // file shrank below what we consumed, or it was rewritten to the same length
+            // (size unchanged but mtime advanced). Either way, re-read from the top.
+            // Suspended for the first read after a retarget, whose newer mtime is the copy's, not a rewrite's.
+            const rewritten = !this.adoptMtime && size === this.offset && this.offset > 0 && mtimeMs > this.lastMtimeMs;
+            if (size < this.offset || rewritten) {
+                this.offset = 0;
+                this.partial = '';
+                this.onReset?.();
+            }
+            this.lastMtimeMs = mtimeMs;
+            this.adoptMtime = false;
+            if (size === this.offset)
+                return;
+            const buf = Buffer.alloc(size - this.offset);
+            await fd.read(buf, 0, buf.length, this.offset);
+            this.offset = size;
+            this.partial += buf.toString('utf8');
+            const lines = this.partial.split('\n');
+            this.partial = lines.pop() ?? ''; // trailing fragment with no newline yet
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                try {
+                    this.onLine(JSON.parse(trimmed));
+                }
+                catch {
+                    // a torn/half-written line — skip it; the log never rewrites history
+                }
+            }
+        }
+        finally {
+            await fd.close();
+        }
+    }
+}
+/**
+ * Drive a {@link JsonlTailer} as the file grows: an `fs.watch` on `dir` for latency, plus a
+ * poll backstop because `fs.watch` is unreliable across platforms. Pulls are serialized (a
+ * pull already in flight swallows the next trigger) and stop for good once the returned
+ * function is called. Shared by the agent's control tail and the dashboard's event tail, which
+ * hand-rolled this separately and drifted apart.
+ *
+ * Nothing here may throw at the process: a failed pull and a watcher error are both survivable,
+ * and the poll alone is a complete tail (#996).
+ */
+export function followFile(dir, pull, opts) {
+    let pulling = false;
+    let stopped = false;
+    const pump = async () => {
+        if (pulling || stopped)
+            return;
+        pulling = true;
+        try {
+            await pull();
+        }
+        catch {
+            // #996: every caller discards this promise, so a rejected read (EIO on a network mount,
+            // EISDIR, a log grown past kMaxLength) would be an unhandled rejection and kill the
+            // process. Swallowed rather than logged: the next tick retries, and a fault that persists
+            // would otherwise print once per poll forever.
+        }
+        finally {
+            pulling = false;
+        }
+    };
+    let watcher;
+    try {
+        watcher = watch(dir, () => void pump());
+        // #996: an 'error' with no listener throws out of the emitter, which is the same process
+        // death. The watcher is spent once it errors (node closes the handle first), so drop it and
+        // let the poll below carry the tail on its own.
+        watcher.on('error', () => {
+            watcher?.close();
+            watcher = undefined;
+        });
+        // Unref the watcher, not just the poll below: an `fs.watch` handle refs the event loop on
+        // its own, so unrefing only the timer left `unref: true` a half-measure that still pinned the
+        // process open. That is what wedged an agent whose config check failed before its watcher had an
+        // owner to close it — the CLI returned, and the process then sat there forever with the agent
+        // recorded as `running`.
+        if (opts.unref)
+            watcher?.unref();
+    }
+    catch {
+        // dir may not be watchable everywhere; the poll backstop still covers it
+    }
+    const poll = setInterval(() => void pump(), opts.pollMs);
+    if (opts.unref)
+        poll.unref();
+    void pump(); // seed with whatever is already written
+    return () => {
+        stopped = true;
+        clearInterval(poll);
+        watcher?.close();
+        watcher = undefined;
+    };
+}
+//# sourceMappingURL=jsonl-tail.js.map

package/dist/jsonl-tail.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonl-tail.js","sourceRoot":"","sources":["../src/jsonl-tail.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAkB,MAAM,SAAS,CAAA;AAC/C,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AAEvC;;;;;;;GAOG;AACH,MAAM,OAAO,WAAW;IAOZ,IAAI;IACK,MAAM;IAEN,OAAO;IATlB,MAAM,GAAG,CAAC,CAAA;IACV,OAAO,GAAG,EAAE,CAAA;IACZ,WAAW,GAAG,CAAC,CAAA;IACf,UAAU,GAAG,KAAK,CAAA;IAE1B,YACU,IAAY,EACH,MAA0B;IAC3C,0FAA0F;IACzE,OAAoB;oBAH7B,IAAI;sBACK,MAAM;uBAEN,OAAO;IACvB,CAAC;IAEJ;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,IAAY;QACnB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;QAChB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAA;IACxB,CAAC;IAED,oEAAoE;IACpE,KAAK,CAAC,IAAI;QACR,IAAI,EAAE,CAAA;QACN,IAAI,CAAC;YACH,EAAE,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,CAAA;QACjC,CAAC;QAAC,MAAM,CAAC;YACP,OAAM,CAAC,wCAAwC;QACjD,CAAC;QACD,IAAI,CAAC;YACH,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,MAAM,EAAE,CAAC,IAAI,EAAE,CAAA;YACzC,iFAAiF;YACjF,6EAA6E;YAC7E,yEAAyE;YACzE,mGAAmG;YACnG,MAAM,SAAS,GAAG,CAAC,IAAI,CAAC,UAAU,IAAI,IAAI,KAAK,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,IAAI,OAAO,GAAG,IAAI,CAAC,WAAW,CAAA;YAC3G,IAAI,IAAI,GAAG,IAAI,CAAC,MAAM,IAAI,SAAS,EAAE,CAAC;gBACpC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAA;gBACf,IAAI,CAAC,OAAO,GAAG,EAAE,CAAA;gBACjB,IAAI,CAAC,OAAO,EAAE,EAAE,CAAA;YAClB,CAAC;YACD,IAAI,CAAC,WAAW,GAAG,OAAO,CAAA;YAC1B,IAAI,CAAC,UAAU,GAAG,KAAK,CAAA;YACvB,IAAI,IAAI,KAAK,IAAI,CAAC,MAAM;gBAAE,OAAM;YAChC,MAAM,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,CAAA;YAC5C,MAAM,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,CAAA;YAC9C,IAAI,CAAC,MAAM,GAAG,IAAI,CAAA;YAClB,IAAI,CAAC,OAAO,IAAI,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAA;YACpC,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;YACtC,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC,GAAG,EAAE,IAAI,EAAE,CAAA,CAAC,wCAAwC;YACzE,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;gBACzB,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,EAAE,CAAA;gBAC3B,IAAI,CAAC,OAAO;oBAAE,SAAQ;gBACtB,IAAI,CAAC;oBACH,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAM,CAAC,CAAA;gBACvC,CAAC;gBAAC,MAAM,CAAC;oBACP,qEAAqE;gBACvE,CAAC;YACH,CAAC;QACH,CAAC;gBAAS,CAAC;YACT,MAAM,EAAE,CAAC,KAAK,EAAE,CAAA;QAClB,CAAC;IACH,CAAC;CACF;AAcD;;;;;;;;;GASG;AACH,MAAM,UAAU,UAAU,CAAC,GAAW,EAAE,IAAyB,EAAE,IAAuB;IACxF,IAAI,OAAO,GAAG,KAAK,CAAA;IACnB,IAAI,OAAO,GAAG,KAAK,CAAA;IACnB,MAAM,IAAI,GAAG,KAAK,IAAmB,EAAE;QACrC,IAAI,OAAO,IAAI,OAAO;YAAE,OAAM;QAC9B,OAAO,GAAG,IAAI,CAAA;QACd,IAAI,CAAC;YACH,MAAM,IAAI,EAAE,CAAA;QACd,CAAC;QAAC,MAAM,CAAC;YACP,wFAAwF;YACxF,oFAAoF;YACpF,0FAA0F;YAC1F,+CAA+C;QACjD,CAAC;gBAAS,CAAC;YACT,OAAO,GAAG,KAAK,CAAA;QACjB,CAAC;IACH,CAAC,CAAA;IAED,IAAI,OAA8B,CAAA;IAClC,IAAI,CAAC;QACH,OAAO,GAAG,KAAK,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,KAAK,IAAI,EAAE,CAAC,CAAA;QACvC,yFAAyF;QACzF,4FAA4F;QAC5F,gDAAgD;QAChD,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE;YACvB,OAAO,EAAE,KAAK,EAAE,CAAA;YAChB,OAAO,GAAG,SAAS,CAAA;QACrB,CAAC,CAAC,CAAA;QACF,0FAA0F;QAC1F,8FAA8F;QAC9F,iGAAiG;QACjG,8FAA8F;QAC9F,yBAAyB;QACzB,IAAI,IAAI,CAAC,KAAK;YAAE,OAAO,EAAE,KAAK,EAAE,CAAA;IAClC,CAAC;IAAC,MAAM,CAAC;QACP,yEAAyE;IAC3E,CAAC;IACD,MAAM,IAAI,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC,KAAK,IAAI,EAAE,EAAE,IAAI,CAAC,MAAM,CAAC,CAAA;IACxD,IAAI,IAAI,CAAC,KAAK;QAAE,IAAI,CAAC,KAAK,EAAE,CAAA;IAC5B,KAAK,IAAI,EAAE,CAAA,CAAC,wCAAwC;IAEpD,OAAO,GAAG,EAAE;QACV,OAAO,GAAG,IAAI,CAAA;QACd,aAAa,CAAC,IAAI,CAAC,CAAA;QACnB,OAAO,EAAE,KAAK,EAAE,CAAA;QAChB,OAAO,GAAG,SAAS,CAAA;IACrB,CAAC,CAAA;AACH,CAAC"}

package/dist/loopback-host.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Loopback-address helpers, shared by the daemon (deciding whether a bind gates behind the
+ * token, #1051) and the RPC mount (rejecting a rebound `Host`). A leaf module on purpose:
+ * `daemon.ts` imports the dashboard, so the mount cannot import these back out of it.
+ */
+/**
+ * True when `host` is a loopback address the browser reaches without leaving the machine (#1051).
+ * A bind-all (`0.0.0.0`, `::`) or a routable address is not, and gates behind the shared token.
+ *
+ * The IPv4 check matches the whole `127.0.0.0/8` range but only as an address: a bare
+ * `startsWith('127.')` also accepts a *registrable name* like `127.evil.com`, which is exactly the
+ * rebound `Host` the DNS-rebinding guard exists to reject (it can resolve to `127.0.0.1`).
+ */
+export declare function isLoopbackHost(host: string): boolean;
+/**
+ * The hostname a `Host` header names, with the port dropped. Keeps the bracketed IPv6 form
+ * (`[::1]:4200` → `[::1]`), which splitting on the first colon would mangle.
+ */
+export declare function hostnameFromHostHeader(header: string): string;
+//# sourceMappingURL=loopback-host.d.ts.map

package/dist/loopback-host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loopback-host.d.ts","sourceRoot":"","sources":["../src/loopback-host.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAO7D"}

package/dist/loopback-host.js

@@ -0,0 +1,31 @@
+/**
+ * Loopback-address helpers, shared by the daemon (deciding whether a bind gates behind the
+ * token, #1051) and the RPC mount (rejecting a rebound `Host`). A leaf module on purpose:
+ * `daemon.ts` imports the dashboard, so the mount cannot import these back out of it.
+ */
+/** The `127.0.0.0/8` loopback range, in dotted-quad form. */
+const LOOPBACK_V4 = /^127(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}$/;
+/**
+ * True when `host` is a loopback address the browser reaches without leaving the machine (#1051).
+ * A bind-all (`0.0.0.0`, `::`) or a routable address is not, and gates behind the shared token.
+ *
+ * The IPv4 check matches the whole `127.0.0.0/8` range but only as an address: a bare
+ * `startsWith('127.')` also accepts a *registrable name* like `127.evil.com`, which is exactly the
+ * rebound `Host` the DNS-rebinding guard exists to reject (it can resolve to `127.0.0.1`).
+ */
+export function isLoopbackHost(host) {
+    return host === 'localhost' || host === '::1' || host === '[::1]' || LOOPBACK_V4.test(host);
+}
+/**
+ * The hostname a `Host` header names, with the port dropped. Keeps the bracketed IPv6 form
+ * (`[::1]:4200` → `[::1]`), which splitting on the first colon would mangle.
+ */
+export function hostnameFromHostHeader(header) {
+    if (header.startsWith('[')) {
+        const close = header.indexOf(']');
+        return close === -1 ? header : header.slice(0, close + 1);
+    }
+    const colon = header.indexOf(':');
+    return colon === -1 ? header : header.slice(0, colon);
+}
+//# sourceMappingURL=loopback-host.js.map

package/dist/loopback-host.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loopback-host.js","sourceRoot":"","sources":["../src/loopback-host.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,6DAA6D;AAC7D,MAAM,WAAW,GAAG,mDAAmD,CAAA;AAEvE;;;;;;;GAOG;AACH,MAAM,UAAU,cAAc,CAAC,IAAY;IACzC,OAAO,IAAI,KAAK,WAAW,IAAI,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,OAAO,IAAI,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;AAC7F,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,sBAAsB,CAAC,MAAc;IACnD,IAAI,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;QAC3B,MAAM,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;QACjC,OAAO,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,GAAG,CAAC,CAAC,CAAA;IAC3D,CAAC;IACD,MAAM,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;IACjC,OAAO,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAA;AACvD,CAAC"}

package/dist/module-server.d.ts

@@ -0,0 +1,56 @@
+// `@openagt/dashboard/module-server`: what the daemon offers a module's server part.
+//
+// A module's server part is the file its package exports as `./server`. The daemon imports it once,
+// in its own process, and calls one of its reads when the module's browser part asks for it
+// (`host.read(name, input)` there). The server part imports nothing from OpenAgent at run time:
+// these are types only, and its default export is a plain object that satisfies `ModuleServer`.
+
+/** What the core knows about one run: facts, never a verdict about what the run's files are. */
+export interface RunFacts {
+  /** The run's own checkout while it has one: an absolute path. */
+  checkout?: string
+  /** The run's record, when the project keeps one for it. */
+  record?: {
+    status?: string
+    /** The machine the run ran on. */
+    host?: string
+    /** The branch the run left its work on, by its last recorded name. */
+    branch?: string
+    pr?: { number: number }
+    /** The branch the run was told to start from, by its name; absent on a run that started from origin's default branch. */
+    base?: string
+    /** The commit the run's own work begins at, for a run that made its own branch: what its changes are measured from when the default branch cannot tell them. */
+    baseCommit?: string
+    /** The last commit of the run's work, once its main agent landed it: its branch is gone, and its work is read here. */
+    landed?: string
+  }
+  /** The run ended on this machine without a pull request and was not landed, so a branch it no longer has held nothing. */
+  changedNothing: boolean
+}
+
+/** Where a pull request stands on the git host: still being asked, or answered (with its merge commit when merged, and the last commit of the branch it merged, when the git host says it). */
+export type MergeLookup = { pending: true } | { pending: false; commit?: string; head?: string }
+
+/** What a read is given: the project it reads, and what the core knows about the project's runs. */
+export interface ModuleServerHost {
+  /** The project's folder: an absolute path. */
+  root: string
+  /** The facts about one run of the project, or undefined when the id names no run. */
+  run(agentId: string): Promise<RunFacts | undefined>
+  /** The commit pull request `number` of `branch` merged as, as the project's git host says. */
+  mergeCommit(branch: string, number: number): Promise<MergeLookup>
+}
+
+/**
+ * What a module's browser part sent with a read: JSON, bounded in size. `agentId`, when present,
+ * names the run the read is about; a run relayed to a connected device is read over there.
+ */
+export type ModuleReadInput = { agentId?: string } & Record<string, unknown>
+
+/** One read of a module's server part: its answer must be JSON. */
+export type ModuleRead = (host: ModuleServerHost, input: ModuleReadInput) => Promise<unknown>
+
+/** What a module's `./server` file default-exports. */
+export interface ModuleServer {
+  reads: Record<string, ModuleRead>
+}

package/dist/module-types/dashboard/components/DiffStat.d.ts

@@ -0,0 +1,6 @@
+/** Added/removed counts as the `+12 −3` pair. */
+export declare function DiffStat({ added, removed, className }: {
+    added: number;
+    removed: number;
+    className?: string;
+}): import("react").JSX.Element;

package/dist/module-types/dashboard/components/DriverModelMenu.d.ts

@@ -0,0 +1,23 @@
+import type { ReactNode } from 'react';
+export interface ModelOption {
+    value: string;
+    label: string;
+}
+export interface DriverOption {
+    value: string;
+    label: string;
+    /** The driver's logo, shown on the trigger and beside its name (#656). */
+    icon?: ReactNode;
+    /** The models this driver offers. Every entry is a real model id — none of them means "unset". */
+    models: ModelOption[];
+    /** Why {@link models} is empty, said in its place: the agent is still being asked, or could not say. */
+    modelsNote?: string;
+}
+export declare function DriverModelMenu({ drivers, driver, model, onChange, busy, }: {
+    drivers: DriverOption[];
+    driver: string;
+    model: string;
+    /** Set the driver and model together (a model is always picked within its driver). */
+    onChange: (driver: string, model: string) => void;
+    busy: boolean;
+}): import("react").JSX.Element;

package/dist/module-types/dashboard/components/LinkActions.d.ts

@@ -0,0 +1,26 @@
+import { type ReactNode } from 'react';
+import { type ModuleLink } from '../module/index.js';
+import { type MountedLinkAction } from '../lib/use-modules.js';
+import { type ButtonProps } from './ui/button.js';
+/** The links one project's worth of a click acts on. */
+export interface ProjectLinks {
+    projectId: string;
+    links: ModuleLink[];
+}
+/** The links a click acts on: known up front, or resolved at click time (a page that first reads what is already there). */
+export type LinkTargets = ProjectLinks[] | (() => Promise<ProjectLinks[]>);
+export declare function LinkActions({ projects, targets, resetKey, label, tooltip, disabled, size, variant, }: {
+    /** The projects the links belong to: an action shows when its package is in at least one of them. */
+    projects: readonly string[];
+    /** What a click acts on, grouped by project. */
+    targets: LinkTargets;
+    /** A done button rests until this changes: the identity of the set it acted on. Defaults to the projects. */
+    resetKey?: string;
+    /** The button's text for an action; the action's own label otherwise. */
+    label?: (action: MountedLinkAction) => string;
+    /** Shown on hover, the same for every action. */
+    tooltip?: ReactNode;
+    disabled?: boolean;
+    size?: ButtonProps['size'];
+    variant?: ButtonProps['variant'];
+}): import("react").JSX.Element | null;

package/dist/module-types/dashboard/components/Markdown.d.ts

@@ -0,0 +1,4 @@
+export declare function Markdown({ text, compact }: {
+    text: string;
+    compact?: boolean;
+}): import("react").JSX.Element;

package/dist/module-types/dashboard/components/SettingsRows.d.ts

@@ -0,0 +1,37 @@
+import type { ReactNode } from 'react';
+/** One section of the Settings page: a titled card of rows. */
+export declare function SettingsSection({ title, description, children }: {
+    title: string;
+    description?: string;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** One setting: what it is and what it does on the left, its control on the right. */
+export declare function SettingsRow({ label, description, control, dimmed, }: {
+    label: string;
+    description: string;
+    control: ReactNode;
+    /** A row the rules turned off: greyed, but still shown with its reason. */
+    dimmed?: boolean;
+}): import("react").JSX.Element;
+export interface SettingsOption {
+    value: string;
+    label: string;
+    /** A line in the list that says something rather than being a choice. */
+    disabled?: boolean;
+}
+/**
+ * One setting picked from a list.
+ *
+ * A row with nothing to pick renders nothing at all (#1172). An empty `<select>` is a control that
+ * cannot be operated — it reads as broken rather than as "no choices here", which is exactly the
+ * paper cut this guard exists for. Every list on this page has a fixed first entry today ("Auto-detect",
+ * the agent's own default), so nothing hits it; it is here because the next list will be added
+ * without thinking about the empty case.
+ */
+export declare function SettingsSelectRow({ label, description, value, options, onChange, }: {
+    label: string;
+    description: string;
+    value: string;
+    options: SettingsOption[];
+    onChange: (next: string) => void;
+}): import("react").JSX.Element | null;

package/dist/module-types/dashboard/components/StartAgentButton.d.ts

@@ -0,0 +1,39 @@
+import type { ReactNode } from 'react';
+export declare function StartAgentButton({ icon, label, busyLabel, ariaLabel, menuAriaLabel, tooltip, tooltipClassName, prompt, configureDescription, onStart, onConfigure, busy, starting, disabled, variant, size, className, }: {
+    /** The primary half's icon; swapped for a spinner while this button's own start is in flight. */
+    icon: ReactNode;
+    /** The primary half's text. Omitted on the dense rows, which are icon-only — pass `ariaLabel` there. */
+    label?: string | undefined;
+    /** What the primary half reads while this button's own start is in flight. */
+    busyLabel?: string | undefined;
+    /** The primary half's accessible name. Required where there is no `label` to serve as one. */
+    ariaLabel?: string | undefined;
+    /** The chevron's accessible name — it has no text of its own, and "menu" would not say whose. */
+    menuAriaLabel: string;
+    /** What the primary half promises on hover: what it does, and what it is about to spend. */
+    tooltip: ReactNode;
+    tooltipClassName?: string | undefined;
+    /**
+     * The prompt "Configure first, then run" hands the launcher. For a click that starts several
+     * agents, the one the launcher can actually send — `configureDescription` then says so.
+     */
+    prompt: string;
+    /** The menu entry's second line: what this particular launcher trip is for. */
+    configureDescription: string;
+    onStart: () => void;
+    /**
+     * Open the launcher the prompt was stashed for — the project's own, since a draft is only
+     * rehydrated by the launcher of the project the reader lands on.
+     */
+    onConfigure: () => void;
+    /** A start is in flight somewhere on this surface: the primary half is out until it settles. */
+    busy?: boolean | undefined;
+    /** *This* button's start is the one in flight, so only it reads as busy. */
+    starting?: boolean | undefined;
+    /** There is nothing to act on at all (no project picked): both halves are out. */
+    disabled?: boolean | undefined;
+    variant?: 'default' | 'outline' | 'ghost' | undefined;
+    size?: 'xs' | 'sm' | 'icon-sm' | undefined;
+    /** Styling the two halves share, so the pair reads as one control rather than two buttons. */
+    className?: string | undefined;
+}): import("react").JSX.Element;

package/dist/module-types/dashboard/components/ui/badge.d.ts

@@ -0,0 +1,2 @@
+import type { HTMLAttributes } from 'react';
+export declare function Badge({ className, ...props }: HTMLAttributes<HTMLSpanElement>): import("react").JSX.Element;

package/dist/module-types/dashboard/components/ui/button.d.ts

@@ -0,0 +1,10 @@
+import { type VariantProps } from 'class-variance-authority';
+import type { ButtonHTMLAttributes } from 'react';
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "destructive" | "ghost" | "outline" | null | undefined;
+    size?: "default" | "icon" | "icon-sm" | "sm" | "xs" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+}
+export declare function Button({ className, variant, size, ...props }: ButtonProps): import("react").JSX.Element;
+export { buttonVariants };

package/dist/module-types/dashboard/components/ui/card.d.ts

@@ -0,0 +1,5 @@
+import type { HTMLAttributes } from 'react';
+export declare function Card({ className, ...props }: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;
+export declare function CardHeader({ className, ...props }: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;
+export declare function CardTitle({ className, ...props }: HTMLAttributes<HTMLHeadingElement>): import("react").JSX.Element;
+export declare function CardContent({ className, ...props }: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;

package/dist/module-types/dashboard/components/ui/checkbox.d.ts

@@ -0,0 +1,7 @@
+import type { ComponentProps } from 'react';
+import { Checkbox as CheckboxPrimitive } from '@base-ui-components/react/checkbox';
+type CheckboxProps = Omit<ComponentProps<typeof CheckboxPrimitive.Root>, 'disabled'> & {
+    disabled?: boolean | undefined;
+};
+export declare function Checkbox({ className, disabled, ...props }: CheckboxProps): import("react").JSX.Element;
+export {};

package/dist/module-types/dashboard/components/ui/dropdown-menu.d.ts

@@ -0,0 +1,16 @@
+import { Menu } from '@base-ui-components/react/menu';
+import type { ComponentProps } from 'react';
+export declare const DropdownMenu: typeof Menu.Root;
+export declare const DropdownMenuGroup: import("react").ForwardRefExoticComponent<import("@base-ui-components/react/menu").MenuGroupProps & import("react").RefAttributes<Element>>;
+export declare const DropdownMenuSub: typeof Menu.SubmenuRoot;
+export declare function DropdownMenuTrigger({ className, ...props }: ComponentProps<typeof Menu.Trigger>): import("react").JSX.Element;
+export declare function DropdownMenuContent({ className, sideOffset, align, children, ...props }: ComponentProps<typeof Menu.Popup> & {
+    sideOffset?: number;
+    align?: 'start' | 'center' | 'end';
+}): import("react").JSX.Element;
+export declare function DropdownMenuItem({ className, ...props }: ComponentProps<typeof Menu.Item>): import("react").JSX.Element;
+export declare function DropdownMenuCheckboxItem({ className, children, closeOnClick, ...props }: ComponentProps<typeof Menu.CheckboxItem>): import("react").JSX.Element;
+export declare function DropdownMenuSubTrigger({ className, children, ...props }: ComponentProps<typeof Menu.SubmenuTrigger>): import("react").JSX.Element;
+export declare function DropdownMenuSubContent({ className, children, ...props }: ComponentProps<typeof Menu.Popup>): import("react").JSX.Element;
+export declare function DropdownMenuSeparator({ className, ...props }: ComponentProps<typeof Menu.Separator>): import("react").JSX.Element;
+export declare function DropdownMenuLabel({ className, ...props }: ComponentProps<typeof Menu.GroupLabel>): import("react").JSX.Element;

package/dist/module-types/dashboard/components/ui/input.d.ts

@@ -0,0 +1,2 @@
+import type { ComponentProps } from 'react';
+export declare function Input({ className, type, ...props }: ComponentProps<'input'>): import("react").JSX.Element;