@openagt/dashboard 0.0.0-stage → 0.9.0

package/dist/daemon-services.js

@@ -0,0 +1,126 @@
+import { basename } from 'node:path';
+import { listProjects } from './registry.js';
+import { startDaemonTick, DAEMON_TICK_MS } from './daemon-tick.js';
+import { DATA_BRANCH, branchReach, pullFileBranch } from '@openagt/agent-data';
+import { startCloudScratchSweep } from './cloud-scratch-refs.js';
+import { adoptCloudWork, startCloudWorkAdoption } from './cloud-work.js';
+import { providerProblems } from './store/provided.js';
+import { projectGitHost } from './store/git-host.js';
+/**
+ * Everything the daemon runs in the background beside serving the dashboard: the data sync (#1599),
+ * the cloud-scratch sweep (#1547) and the cloud work adoption (#1601). None of them starts a run
+ * (#1774).
+ *
+ * All of it used to sit inline in `runDaemon`, which meant its body was a lifecycle narrative with
+ * ~200 lines of service wiring in the middle of it; the daemon body is left with the sequence it
+ * actually owns.
+ *
+ * They share one clock (E4). Each used to own a `setInterval`, so six intervals ran side by side
+ * with no single place to look when a sweep was not running; now each declares how many ticks it
+ * wants between turns and `daemon-tick.ts` fires them.
+ */
+/** Ticks between cloud work adoption passes: a ten-minute job. */
+const TEN_MINUTES_EVERY = Math.round((10 * 60 * 1000) / DAEMON_TICK_MS);
+/**
+ * Ticks between cloud-scratch sweeps (#1547): hourly. The refs it deletes have to sit for a day
+ * first, so a finer cadence would only spend `ls-remote` round-trips asking the same question.
+ */
+const CLOUD_SCRATCH_EVERY = Math.round((60 * 60 * 1000) / DAEMON_TICK_MS);
+/**
+ * One project's data-sync turn (#1599): converge the `agent-data` branch — the skills' branch,
+ * which carries the tickets, the queue and the `logs` skill's runs — with
+ * origin through the shared branch library, one pull, and set or clear the project's `data-sync`
+ * error by the outcome. The clear is unconditional on success, so the error lives exactly as long
+ * as the condition — the next tick after the user fixes the remote, it is gone. A branch that stays
+ * on this machine (no remote, or the person does not share it) is no error: the project carries why,
+ * for as long as that holds. The daemon knows
+ * nothing of what is on the branch (#1774): a skill's own setup makes its files.
+ */
+export async function syncProjectData(path, errors, log) {
+    const result = await pullFileBranch(path, DATA_BRANCH, { log });
+    if (result.ok) {
+        errors.setReach(path, result.reach);
+        errors.clear(path, 'data-sync');
+    }
+    else {
+        errors.setReach(path, await branchReach(path));
+        log(`[openagent] data sync: ${result.error}`);
+        errors.set(path, 'data-sync', result.error);
+    }
+}
+/**
+ * One project's provider check (#1820), on the data sync's clock: a kind of the project's data
+ * that packages declare but none is settled to provide (several declare it and the project's
+ * package.json names none, or names one that does not declare it) is the project's `provider`
+ * error, every such kind on its own line; every kind settled clears it. OpenAgent never picks
+ * the first declarer silently: the project says, or nothing provides and the banner says why.
+ */
+export async function checkProviders(path, errors) {
+    const problems = await providerProblems(path);
+    if (problems.length === 0)
+        errors.clear(path, 'provider');
+    else
+        errors.set(path, 'provider', problems.join('\n'));
+}
+/** The registered projects as dashboard summaries. */
+async function listSummaries(env) {
+    const records = await listProjects(undefined, env).catch(() => []);
+    return Promise.all(records.map(async (p) => ({ id: p.id, path: p.path, name: basename(p.path), activated: true, gitHost: (await projectGitHost(p.path).catch(() => undefined)) !== undefined })));
+}
+export function startBackgroundServices(deps) {
+    const { env, log } = deps;
+    const projects = () => listSummaries(env);
+    // Delete the scratch refs a web hand-off leaves on origin (#1547): the pre-hand-off `cloud-*`
+    // ref and the run branch, one dead pair per web run. Daemon-side rather than in the driver,
+    // because session creation only signals "created", not "clone finished" — a driver deleting its
+    // own ref races the provisioning and can strand the session. The sweep waits out that race
+    // (~a day) and only deletes refs whose work is provably on the default branch.
+    const cloudScratch = startCloudScratchSweep({ projects, log });
+    // Adopt the branch a cloud session actually worked on (#1601): match each settled web run to
+    // the `claude/*` head descending from its hand-off anchor, record the branch and PR on the
+    // run's archive, and open the armed draft PR the session never did. Daemon-side by necessity:
+    // the branch does not exist yet when the wrapper ends — the cloud VM is still provisioning.
+    const cloudWork = startCloudWorkAdoption({ projects, log, adopt: cwd => adoptCloudWork(cwd) });
+    // One clock for every background job (E4). Each says how many ticks it wants between turns
+    // instead of owning an interval, so there is one place to look when the answer to "why is
+    // nothing happening" is that a sweep is not running — and the ratios are exact rather than six
+    // timers drifting apart.
+    const clock = startDaemonTick({
+        log,
+        jobs: [
+            // The eager data pull (#1582): converge every project's data checkout on what other
+            // machines and cloud sessions pushed, and carry out anything a failed cycle left local.
+            // Its start-up turn is also what creates the checkout on a fresh clone. A project that
+            // cannot converge is recorded as such for the dashboard (#1599).
+            {
+                name: 'data sync',
+                every: 2,
+                run: async () => {
+                    for (const project of await projects().catch(() => [])) {
+                        // Taken off the list since this turn began: a sync would make its records' checkout again,
+                        // right after a person asked for it to go.
+                        if (!(await listProjects(undefined, env).catch(() => [])).some(listed => listed.id === project.id))
+                            continue;
+                        await syncProjectData(project.path, deps.projectErrors, log);
+                        await checkProviders(project.path, deps.projectErrors);
+                    }
+                },
+            },
+            // Hourly. Its start-up turn is what starts a `cloud-*` ref's one-day clock (#1547): the
+            // sweep ages those refs from when it first saw them, so the sooner it looks, the sooner
+            // a leftover can go.
+            { name: 'cloud scratch sweep', every: CLOUD_SCRATCH_EVERY, run: () => cloudScratch.tick() },
+            // Ten minutes: the cloud session it waits on lives minutes-to-hours itself, and the pass
+            // costs an `ls-remote` per project only while a settled web run is actually waiting.
+            { name: 'cloud work adoption', every: TEN_MINUTES_EVERY, run: () => cloudWork.tick() },
+        ],
+    });
+    return {
+        quiesce: async () => {
+            await clock.stop();
+            cloudScratch.stop();
+            cloudWork.stop();
+        },
+    };
+}
+//# sourceMappingURL=daemon-services.js.map

package/dist/daemon-services.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"daemon-services.js","sourceRoot":"","sources":["../src/daemon-services.ts"],"names":[],"mappings":"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"}

package/dist/daemon-tick.d.ts

@@ -0,0 +1,68 @@
+/**
+ * The daemon's one background clock (E4).
+ *
+ * Every sweep used to own a timer: one `setInterval`, one unref call and one overlap guard
+ * each, and no single place to look when the answer to "why is nothing happening" is that a
+ * sweep is not running.
+ *
+ * One interval fires, and each job says how often it wants a turn. A job's cadence stops being a
+ * duration it has to reason about and becomes a small integer: how many ticks between turns.
+ *
+ * The base interval is the finest cadence anything needs. Anything slower is that many ticks —
+ * exact by construction, because the ratios are integers rather than two timers drifting apart.
+ */
+/** One thing the daemon does on a schedule. */
+export interface TickJob {
+    /** For the log line when it throws. */
+    name: string;
+    /**
+     * Ticks between turns. `1` is every tick, `20` is every twentieth. A tick is the interval
+     * coming round, not a turn that ran, so a slow job on the same clock cannot stretch this out.
+     *
+     * Its own turn is *skipped* rather than queued, so a slow job never accumulates a backlog of
+     * missed turns to work through.
+     */
+    every?: number;
+    /** Run one turn. Awaited, so a long job holds the tick rather than overlapping the next one. */
+    run: () => Promise<void>;
+    /**
+     * Run on the very first tick, which fires at start-up rather than one interval later.
+     *
+     * On by default, because the case most of these exist for is a machine that was off while
+     * something happened. A job that only makes sense once the daemon has been up a while says so.
+     */
+    onStart?: boolean;
+}
+/** The running clock. */
+export interface DaemonTick {
+    /** Run one tick now, awaiting it. The tests drive the clock through this. */
+    tick: () => Promise<void>;
+    /**
+     * Stop the clock, and resolve when the turn already in flight has finished. Awaiting it is how
+     * a shutdown knows the sweeps have let go of the repo — clearing the interval only stops the
+     * *next* turn, and these jobs commit and push.
+     */
+    stop: () => Promise<void>;
+}
+/** How often the clock fires. The finest cadence any job asks for; everything else is a multiple. */
+export declare const DAEMON_TICK_MS = 30000;
+/** What {@link startDaemonTick} needs. */
+export interface DaemonTickOptions {
+    jobs: readonly TickJob[];
+    /** Override the base interval (tests). */
+    intervalMs?: number;
+    log: (message: string) => void;
+}
+/**
+ * Start the clock and return the handle that stops it.
+ *
+ * A job that throws costs its own turn and nothing else: the others in the same tick still run,
+ * and the failure is logged once with the job's name, because a sweep failing silently is
+ * indistinguishable from one that is not scheduled at all.
+ *
+ * Overlapping ticks join the one already running rather than being dropped, so awaiting `tick()`
+ * means the tick finished — which is what lets a test drive this deterministically. The timer is
+ * unref'd: background work is never the reason the process stays up.
+ */
+export declare function startDaemonTick(opts: DaemonTickOptions): DaemonTick;
+//# sourceMappingURL=daemon-tick.d.ts.map

package/dist/daemon-tick.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"daemon-tick.d.ts","sourceRoot":"","sources":["../src/daemon-tick.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AAEH,+CAA+C;AAC/C,MAAM,WAAW,OAAO;IACtB,uCAAuC;IACvC,IAAI,EAAE,MAAM,CAAA;IACZ;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,gGAAgG;IAChG,GAAG,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IACxB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,yBAAyB;AACzB,MAAM,WAAW,UAAU;IACzB,6EAA6E;IAC7E,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IACzB;;;;OAIG;IACH,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAC1B;AAED,qGAAqG;AACrG,eAAO,MAAM,cAAc,QAAS,CAAA;AAEpC,0CAA0C;AAC1C,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,SAAS,OAAO,EAAE,CAAA;IACxB,0CAA0C;IAC1C,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,GAAG,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;CAC/B;AAOD;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,iBAAiB,GAAG,UAAU,CA2EnE"}

package/dist/daemon-tick.js

@@ -0,0 +1,97 @@
+import { errorMessage } from './error-message.js';
+/** How often the clock fires. The finest cadence any job asks for; everything else is a multiple. */
+export const DAEMON_TICK_MS = 30_000;
+/** Ticks between a job's turns, defaulted and floored. */
+function cadence(job) {
+    return Math.max(1, job.every ?? 1);
+}
+/**
+ * Start the clock and return the handle that stops it.
+ *
+ * A job that throws costs its own turn and nothing else: the others in the same tick still run,
+ * and the failure is logged once with the job's name, because a sweep failing silently is
+ * indistinguishable from one that is not scheduled at all.
+ *
+ * Overlapping ticks join the one already running rather than being dropped, so awaiting `tick()`
+ * means the tick finished — which is what lets a test drive this deterministically. The timer is
+ * unref'd: background work is never the reason the process stays up.
+ */
+export function startDaemonTick(opts) {
+    let stopped = false;
+    /**
+     * Which tick is running now. Advanced by {@link elapsedWhileBusy} as well as by one, so it
+     * stays a count of how many times the interval has *come round* rather than how many turns
+     * happened to run (#1607).
+     */
+    let tickNow = -1;
+    /**
+     * Interval firings that arrived while a turn was in flight. Time passed for them, so they count
+     * towards every cadence — the turn they would each have had is folded into the next one.
+     */
+    let elapsedWhileBusy = 0;
+    let inflight;
+    /**
+     * The tick each job last took a turn on, seeded so tick 0 is already due for a job that wants
+     * the start-up turn and one whole cadence away for a job that sits it out.
+     */
+    const lastTurn = opts.jobs.map(job => (job.onStart === false ? 0 : -cadence(job)));
+    const runTick = async (n) => {
+        for (const [index, job] of opts.jobs.entries()) {
+            if (stopped)
+                return;
+            // Ticks *since this job's own last turn*, rather than `n % every`: when the clock jumps
+            // over the tick a job's cadence would have landed on, the job is due at the next turn
+            // instead of waiting a whole further cadence for the modulo to come round again.
+            if (n - lastTurn[index] < cadence(job))
+                continue;
+            // Claimed before the run, not after: a missed turn is skipped rather than queued, and a job
+            // that throws has still had its turn.
+            lastTurn[index] = n;
+            try {
+                await job.run();
+            }
+            catch (err) {
+                opts.log(`[openagent] ${job.name} failed this tick: ${errorMessage(err)}`);
+            }
+        }
+    };
+    const tick = () => {
+        if (stopped)
+            return Promise.resolve();
+        // A caller that arrives mid-turn joins it without moving the clock: `tick()` means "run a
+        // turn now" — the daemon's shutdown and the tests drive it, and neither is elapsed time.
+        // Only the interval is, and it says so through `elapsedWhileBusy`.
+        if (inflight)
+            return inflight;
+        tickNow += 1 + elapsedWhileBusy;
+        elapsedWhileBusy = 0;
+        inflight = runTick(tickNow).finally(() => {
+            inflight = undefined;
+        });
+        return inflight;
+    };
+    void tick();
+    const timer = setInterval(() => {
+        // The clock moved whether or not a turn can start. Counting a firing that lands on a busy
+        // daemon is the whole point: without it a long job — a data sync failing slowly against an
+        // unreachable remote — stretched every `every: N` cadence by its own duration, because a
+        // cadence was measured in turns that ran rather than in time that passed (#1607).
+        if (inflight) {
+            elapsedWhileBusy++;
+            return;
+        }
+        void tick();
+    }, opts.intervalMs ?? DAEMON_TICK_MS);
+    timer.unref?.();
+    return {
+        tick,
+        stop: async () => {
+            stopped = true;
+            clearInterval(timer);
+            // The turn in flight stops at the next job boundary, but the job it is inside runs to the
+            // end — so wait it out rather than leaving a sweep mid-commit.
+            await inflight?.catch(() => { });
+        },
+    };
+}
+//# sourceMappingURL=daemon-tick.js.map

package/dist/daemon-tick.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"daemon-tick.js","sourceRoot":"","sources":["../src/daemon-tick.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAmDjD,qGAAqG;AACrG,MAAM,CAAC,MAAM,cAAc,GAAG,MAAM,CAAA;AAUpC,0DAA0D;AAC1D,SAAS,OAAO,CAAC,GAAY;IAC3B,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,KAAK,IAAI,CAAC,CAAC,CAAA;AACpC,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,eAAe,CAAC,IAAuB;IACrD,IAAI,OAAO,GAAG,KAAK,CAAA;IACnB;;;;OAIG;IACH,IAAI,OAAO,GAAG,CAAC,CAAC,CAAA;IAChB;;;OAGG;IACH,IAAI,gBAAgB,GAAG,CAAC,CAAA;IACxB,IAAI,QAAmC,CAAA;IACvC;;;OAGG;IACH,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,OAAO,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAA;IAElF,MAAM,OAAO,GAAG,KAAK,EAAE,CAAS,EAAiB,EAAE;QACjD,KAAK,MAAM,CAAC,KAAK,EAAE,GAAG,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC;YAC/C,IAAI,OAAO;gBAAE,OAAM;YACnB,wFAAwF;YACxF,sFAAsF;YACtF,iFAAiF;YACjF,IAAI,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAE,GAAG,OAAO,CAAC,GAAG,CAAC;gBAAE,SAAQ;YACjD,4FAA4F;YAC5F,sCAAsC;YACtC,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;YACnB,IAAI,CAAC;gBACH,MAAM,GAAG,CAAC,GAAG,EAAE,CAAA;YACjB,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,IAAI,CAAC,GAAG,CAAC,eAAe,GAAG,CAAC,IAAI,sBAAsB,YAAY,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;YAC5E,CAAC;QACH,CAAC;IACH,CAAC,CAAA;IAED,MAAM,IAAI,GAAG,GAAkB,EAAE;QAC/B,IAAI,OAAO;YAAE,OAAO,OAAO,CAAC,OAAO,EAAE,CAAA;QACrC,0FAA0F;QAC1F,yFAAyF;QACzF,mEAAmE;QACnE,IAAI,QAAQ;YAAE,OAAO,QAAQ,CAAA;QAC7B,OAAO,IAAI,CAAC,GAAG,gBAAgB,CAAA;QAC/B,gBAAgB,GAAG,CAAC,CAAA;QACpB,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE;YACvC,QAAQ,GAAG,SAAS,CAAA;QACtB,CAAC,CAAC,CAAA;QACF,OAAO,QAAQ,CAAA;IACjB,CAAC,CAAA;IAED,KAAK,IAAI,EAAE,CAAA;IACX,MAAM,KAAK,GAAG,WAAW,CAAC,GAAG,EAAE;QAC7B,0FAA0F;QAC1F,2FAA2F;QAC3F,yFAAyF;QACzF,kFAAkF;QAClF,IAAI,QAAQ,EAAE,CAAC;YACb,gBAAgB,EAAE,CAAA;YAClB,OAAM;QACR,CAAC;QACD,KAAK,IAAI,EAAE,CAAA;IACb,CAAC,EAAE,IAAI,CAAC,UAAU,IAAI,cAAc,CAAC,CAAA;IACrC,KAAK,CAAC,KAAK,EAAE,EAAE,CAAA;IACf,OAAO;QACL,IAAI;QACJ,IAAI,EAAE,KAAK,IAAI,EAAE;YACf,OAAO,GAAG,IAAI,CAAA;YACd,aAAa,CAAC,KAAK,CAAC,CAAA;YACpB,0FAA0F;YAC1F,+DAA+D;YAC/D,MAAM,QAAQ,EAAE,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAA;QACjC,CAAC;KACF,CAAA;AACH,CAAC"}

package/dist/daemon.d.ts

@@ -0,0 +1,65 @@
+import { isLoopbackHost } from './loopback-host.js';
+import { type BridgeBrowser, type BridgeBrowserOptions } from './bridge-browser.js';
+/**
+ * The dashboard process (#302). It is a pure projection of files: a run's tool keeps the run's
+ * card and diary in the run's checkout, and the dashboard *tails* them, pushing each new line to
+ * connected browsers. No run<->dashboard IPC: the files are the seam. The daemon runs no agent
+ * (#1774): a Start is the project's own `start` hook line, and what a person says to a run goes
+ * into the run's inbox file, or through the `resume` hook line once the run has ended.
+ *
+ * It runs in the foreground and only in the foreground: Ctrl-C closes the dashboard. A run is
+ * not the daemon's process, so it goes on to its end. There is no detached mode, so there is no
+ * liveness record, no machine-global state file, and no second process to find, reuse or stop.
+ *
+ * Its own `cwd` is just the home project it streams by default.
+ */
+/** The default dashboard port the daemon binds. */
+export declare const DEFAULT_DAEMON_PORT = 4200;
+/** The default bind host (#1051): localhost only, so the daemon is unreachable off the machine. */
+export declare const DEFAULT_DAEMON_HOST = "127.0.0.1";
+/**
+ * True when `host` is a loopback address the browser reaches without leaving the machine (#1051).
+ * Defined in its own leaf module so the dashboard's RPC mount can share the one definition without
+ * importing this one back (a cycle); re-exported here for the callers that already had it.
+ */
+export { isLoopbackHost };
+/** Where the dashboard came up, reported to {@link RunDaemonOptions.onListening}. */
+export interface DaemonState {
+    /** The daemon process id. */
+    pid: number;
+    /** The port the dashboard is bound to. */
+    port: number;
+    /** The URL to open. */
+    url: string;
+    /** ISO timestamp the daemon started. */
+    startedAt: string;
+    /** The host the dashboard is bound to (#1051). */
+    host?: string;
+}
+/** True when a process with this id is still running (best-effort, signal 0). The store's
+ * {@link isPidAlive} under the daemon's historical public name -- the two were byte-identical. */
+export { isPidAlive as isProcessAlive } from './store/index.js';
+/** Options for {@link runDaemon}. */
+export interface RunDaemonOptions {
+    /** Port to bind. Default {@link DEFAULT_DAEMON_PORT}; pass `0` for an ephemeral port. */
+    port?: number;
+    /** Host to bind (#1051). Default {@link DEFAULT_DAEMON_HOST}; a non-loopback address generates and
+     * requires the shared token, and every route is then gated behind it. */
+    host?: string;
+    /** Shut the daemon down when this aborts (in addition to SIGINT/SIGTERM). For tests. */
+    signal?: AbortSignal;
+    /** Env the registry is read from. Default `process.env`; injectable for tests. */
+    env?: NodeJS.ProcessEnv;
+    /** Called once the server has bound, before it blocks. The only way a caller learns the port. */
+    onListening?: (state: DaemonState) => void;
+    /** How the bridge browser is launched (#1332); default the real Chrome for Testing. For tests. */
+    bridgeBrowser?: (opts: BridgeBrowserOptions) => Promise<BridgeBrowser>;
+}
+/**
+ * The daemon body, run in the foreground by bare `openagent`. Serves the built dashboard bundle
+ * (#405/#426): the SPA reads each run's files over an event stream, so the daemon just serves
+ * the files and runs the project's hooks. Resolves on SIGINT/SIGTERM after tearing the dashboard
+ * down.
+ */
+export declare function runDaemon(cwd: string, opts?: RunDaemonOptions): Promise<void>;
+//# sourceMappingURL=daemon.d.ts.map

package/dist/daemon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"daemon.d.ts","sourceRoot":"","sources":["../src/daemon.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AAGnD,OAAO,EAA4D,KAAK,aAAa,EAAE,KAAK,oBAAoB,EAAE,MAAM,qBAAqB,CAAA;AAK7I;;;;;;;;;;;;GAYG;AAEH,mDAAmD;AACnD,eAAO,MAAM,mBAAmB,OAAO,CAAA;AAEvC,mGAAmG;AACnG,eAAO,MAAM,mBAAmB,cAAc,CAAA;AAE9C;;;;GAIG;AACH,OAAO,EAAE,cAAc,EAAE,CAAA;AAEzB,qFAAqF;AACrF,MAAM,WAAW,WAAW;IAC1B,6BAA6B;IAC7B,GAAG,EAAE,MAAM,CAAA;IACX,0CAA0C;IAC1C,IAAI,EAAE,MAAM,CAAA;IACZ,uBAAuB;IACvB,GAAG,EAAE,MAAM,CAAA;IACX,wCAAwC;IACxC,SAAS,EAAE,MAAM,CAAA;IACjB,kDAAkD;IAClD,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAOD;kGACkG;AAClG,OAAO,EAAE,UAAU,IAAI,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAE/D,qCAAqC;AACrC,MAAM,WAAW,gBAAgB;IAC/B,yFAAyF;IACzF,IAAI,CAAC,EAAE,MAAM,CAAA;IACb;6EACyE;IACzE,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,wFAAwF;IACxF,MAAM,CAAC,EAAE,WAAW,CAAA;IACpB,kFAAkF;IAClF,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAA;IACvB,iGAAiG;IACjG,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAA;IAC1C,kGAAkG;IAClG,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,oBAAoB,KAAK,OAAO,CAAC,aAAa,CAAC,CAAA;CACvE;AAED;;;;;GAKG;AACH,wBAAsB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,GAAE,gBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CA8HvF"}

package/dist/daemon.js

@@ -0,0 +1,202 @@
+import { mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { OPENAGENT_DIR } from './openagent-dir.js';
+import { startDashboard } from './dashboard/index.js';
+import { createProjectRuntime } from './daemon-runtime.js';
+import { defaultQuotaSource } from './dashboard/quota.js';
+import { defaultModelsSource } from './dashboard/models.js';
+import { startBackgroundServices } from './daemon-services.js';
+import { projectErrorStore } from './project-errors.js';
+import { resolveDashboardBundle } from './dashboard/bundle.js';
+import { ensureDaemonToken, listProjects, nodeRegistryFs, readPreferences, registryPreferencesStore } from './registry.js';
+import { isLoopbackHost } from './loopback-host.js';
+import { bridgeSessionsFrom } from './dashboard/bridge-sessions.js';
+import { bridgeQuestions } from './dashboard/bridge-store.js';
+import { bridgeBrowserDir, bridgeBrowserOwner, startBridgeBrowser } from './bridge-browser.js';
+import { runProjectHooks } from './project-hooks.js';
+import { readAllAgents } from './store/index.js';
+/**
+ * The dashboard process (#302). It is a pure projection of files: a run's tool keeps the run's
+ * card and diary in the run's checkout, and the dashboard *tails* them, pushing each new line to
+ * connected browsers. No run<->dashboard IPC: the files are the seam. The daemon runs no agent
+ * (#1774): a Start is the project's own `start` hook line, and what a person says to a run goes
+ * into the run's inbox file, or through the `resume` hook line once the run has ended.
+ *
+ * It runs in the foreground and only in the foreground: Ctrl-C closes the dashboard. A run is
+ * not the daemon's process, so it goes on to its end. There is no detached mode, so there is no
+ * liveness record, no machine-global state file, and no second process to find, reuse or stop.
+ *
+ * Its own `cwd` is just the home project it streams by default.
+ */
+/** The default dashboard port the daemon binds. */
+export const DEFAULT_DAEMON_PORT = 4200;
+/** The default bind host (#1051): localhost only, so the daemon is unreachable off the machine. */
+export const DEFAULT_DAEMON_HOST = '127.0.0.1';
+/**
+ * True when `host` is a loopback address the browser reaches without leaving the machine (#1051).
+ * Defined in its own leaf module so the dashboard's RPC mount can share the one definition without
+ * importing this one back (a cycle); re-exported here for the callers that already had it.
+ */
+export { isLoopbackHost };
+/** The `.openagent/` directory for a workspace. */
+function daemonDir(cwd) {
+    return join(cwd, OPENAGENT_DIR);
+}
+/** True when a process with this id is still running (best-effort, signal 0). The store's
+ * {@link isPidAlive} under the daemon's historical public name -- the two were byte-identical. */
+export { isPidAlive as isProcessAlive } from './store/index.js';
+/**
+ * The daemon body, run in the foreground by bare `openagent`. Serves the built dashboard bundle
+ * (#405/#426): the SPA reads each run's files over an event stream, so the daemon just serves
+ * the files and runs the project's hooks. Resolves on SIGINT/SIGTERM after tearing the dashboard
+ * down.
+ */
+export async function runDaemon(cwd, opts = {}) {
+    const port = opts.port ?? DEFAULT_DAEMON_PORT;
+    const host = opts.host ?? DEFAULT_DAEMON_HOST;
+    const env = opts.env ?? process.env;
+    // #1051: a non-loopback bind reaches the network, where a daemon that spawns processes is RCE for
+    // anyone who finds the port, so generate + persist the shared token the request guard requires. A
+    // loopback bind needs none, so the local zero-config path stays byte-identical.
+    const token = isLoopbackHost(host) ? undefined : await ensureDaemonToken(undefined, env);
+    // The browser bridge (#1237). Opt-in, because it opens the daemon's one route reachable from
+    // another origin. It reuses the same shared token (#1051) rather than minting a second one: the two
+    // guard the same daemon, so a second secret would be another thing to rotate and leak without
+    // narrowing anything. On a loopback bind that secret may not exist yet, hence ensure, not read.
+    const bridgeOn = (await readPreferences(undefined, env).catch(() => ({}))).bridge === true;
+    const bridgeToken = bridgeOn ? await ensureDaemonToken(undefined, env) : undefined;
+    // The project's own `.openagent/` — where its hooks file sits, and where a run's tool keeps
+    // the run's card and diary inside the run's checkout. Created up front so the daemon works as the
+    // very first command in a fresh workspace, before any run has made the directory.
+    await mkdir(daemonDir(cwd), { recursive: true });
+    // Everything the dashboard drives per project (a run's start, project install, the device
+    // relay) lives in the runtime, so this body stays about the daemon's own lifecycle.
+    const runtime = createProjectRuntime({ cwd, env });
+    // Known only once the dashboard listens; the bridge browser is told it (#1332).
+    let daemonUrl;
+    // The daemon serves the built dashboard bundle (#405/#426): the SPA reads each run's files over
+    // `GET /_rpc/events`, so there is no in-process event stream to feed here. The runtime's RPCs reach the browser through the
+    // dashboard context the mount is wired with. A missing bundle (a broken install) surfaces as a
+    // 503 from the server.
+    const clientBundleDir = await resolveDashboardBundle();
+    // The long-lived meter the usage panel draws (#685), owned here so it stops with the daemon.
+    const quota = defaultQuotaSource();
+    // The per-project error state (#1500): the background services write it, the dashboard reads it.
+    const projectErrors = projectErrorStore();
+    // The bridge browser (#1332): the daemon's own Chrome for Testing with the extension installed,
+    // so a web run no longer needs the user's Chrome open. Created here, launched only once the
+    // dashboard listens (the extension is told the daemon's address) and the preference says so.
+    // It needs the bridge: without the token there is nothing to hand the extension.
+    const bridgeBrowser = bridgeBrowserOwner(async (report) => {
+        if (!bridgeToken || !daemonUrl) {
+            // The token is minted at boot, from the bridge preference as it stood then (above). A bridge
+            // switched on since is a restart away; a bridge that is off wants switching on first.
+            const bridgeOnNow = (await readPreferences(undefined, env).catch(() => ({}))).bridge === true;
+            throw new Error(bridgeOnNow
+                ? 'the browser bridge was switched on after the dashboard started — restart the dashboard, and the browser launches on its own'
+                : 'turn the browser bridge on, then restart the dashboard');
+        }
+        return (opts.bridgeBrowser ?? (o => startBridgeBrowser(o)))({ daemonUrl, token: bridgeToken, dir: bridgeBrowserDir(env), report });
+    }, console.log);
+    const dashboard = await startDashboard({
+        host,
+        port,
+        quota,
+        // Which models each coding agent offers: asked on the menu's first read, then kept.
+        models: defaultModelsSource(),
+        onStart: runtime.onStart,
+        onAddProject: runtime.onAddProject,
+        onRemoveProject: runtime.onRemoveProject,
+        // Relay an agent to/from a connected device (#1067): the events source streams an agent this daemon
+        // is relaying, `remote` lets the read RPCs forward a remote agent's reads/steer/push to its device
+        // (slice 2), and the `/_relay/*` endpoints let another daemon run + read + steer a session here.
+        eventsSource: runtime.remoteEventsSource,
+        remote: runtime.remoteAgents,
+        relay: { tailEvents: runtime.tailRelayEvents, rpc: runtime.onRelayRpc },
+        // The browser bridge (#1237): absent unless the preference is on, which 404s every route.
+        ...(bridgeToken ? { bridgeToken, bridgeSessions: () => listBridgeSessions(env) } : {}),
+        // The bridge browser follows its switch (#1332): on launches it, off closes it, without a restart.
+        preferences: registryPreferencesStore(nodeRegistryFs(), env, written => {
+            if (written.bridgeBrowser === true)
+                void bridgeBrowser.start();
+            if (written.bridgeBrowser === false)
+                void bridgeBrowser.stop();
+        }),
+        projectErrors: projectErrors.read,
+        bridgeBrowser,
+        ...(token ? { token } : {}),
+        ...(clientBundleDir ? { clientBundleDir } : {}),
+    });
+    daemonUrl = dashboard.url;
+    try {
+        const actualPort = Number(new URL(dashboard.url).port) || port;
+        opts.onListening?.({ pid: process.pid, port: actualPort, host, url: dashboard.url, startedAt: new Date().toISOString() });
+    }
+    catch (err) {
+        // Startup failed after the port was bound. Tear the server down, or it keeps the event loop
+        // alive: a zombie process squatting the port.
+        await dashboard.close();
+        throw err;
+    }
+    // The bridge browser comes up in the background (#1332): its first launch downloads Chrome,
+    // and the dashboard must not wait on that. Read here rather than with the bridge preference
+    // above: the launch needs the address the dashboard only has now.
+    if ((await readPreferences(undefined, env).catch(() => ({}))).bridgeBrowser === true)
+        void bridgeBrowser.start();
+    // Each project's open hooks (#1774): the lines its own `.openagent/hooks.yml` names, run in
+    // the project once the dashboard listens, so a slow line never delays the URL. The daemon names
+    // no tool; the file does. Bounded and logged, never a reason the daemon did not come up.
+    for (const record of await listProjects(undefined, env).catch(() => [])) {
+        await runProjectHooks(record.path, 'open', { log: console.log });
+    }
+    // Everything that runs in the background beside serving the dashboard: the data sync and the
+    // cloud sweeps.
+    const services = startBackgroundServices({
+        env,
+        projectErrors,
+        log: console.log,
+    });
+    await waitForShutdown(opts.signal);
+    await services.quiesce();
+    // Each project's close hooks (#1774), the counterpart of the open hooks above. A run in flight
+    // is not the daemon's process: it goes on to its end, and the next dashboard shows it.
+    for (const record of await listProjects(undefined, env).catch(() => [])) {
+        await runProjectHooks(record.path, 'close', { log: console.log });
+    }
+    // Stopped here as well as by the dashboard: a broken install serves 503s without ever taking
+    // ownership of the source we handed in, and that poller would go on reading by itself.
+    quota.stop();
+    // The daemon's browser goes with the daemon (#1332): left running it would keep serving a
+    // daemon that is gone, and the next daemon would find its profile held.
+    await bridgeBrowser.stop();
+    await runtime.dispose();
+    await dashboard.close();
+}
+/** Resolve on SIGINT/SIGTERM, or when the optional abort signal fires. */
+function waitForShutdown(signal) {
+    return new Promise(resolvePromise => {
+        if (signal?.aborted)
+            return resolvePromise();
+        const done = () => {
+            process.off('SIGINT', done);
+            process.off('SIGTERM', done);
+            signal?.removeEventListener('abort', done);
+            resolvePromise();
+        };
+        process.once('SIGINT', done);
+        process.once('SIGTERM', done);
+        signal?.addEventListener('abort', done, { once: true });
+    });
+}
+/**
+ * The cloud sessions the browser bridge's Driver tab should be serving (#1237, #1332).
+ *
+ * Across every registered project, because a cloud agent is not tied to the daemon's home
+ * checkout, and best-effort per project so one unreadable repo cannot empty the list.
+ */
+async function listBridgeSessions(env) {
+    const projects = await listProjects(undefined, env).catch(() => []);
+    const agents = (await Promise.all(projects.map(p => readAllAgents(p.path).catch(() => [])))).flat();
+    return bridgeSessionsFrom(agents, new Date(), bridgeQuestions().pendingAnswerSessions());
+}
+//# sourceMappingURL=daemon.js.map

package/dist/daemon.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"daemon.js","sourceRoot":"","sources":["../src/daemon.ts"],"names":[],"mappings":"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"}

package/dist/dashboard/activity.d.ts

@@ -0,0 +1,41 @@
+import { type AgentMeta, type AgentStatus } from '../store/index.js';
+import type { ProjectSummary, ProjectionRead } from './projects.js';
+export { activityKey } from './keys.js';
+/**
+ * One agent lifecycle event worth a passing mention. Two kinds: an agent `started` (entered
+ * `running`) or `finished` (reached a terminal status). The card is not shown for these — they
+ * only drive notifications — so the fields are just what a notification line needs.
+ */
+export interface Activity {
+    projectId: string;
+    projectName: string;
+    /** The agent this is about. */
+    agentId: string;
+    /** `started` = the agent entered `running`; `finished` = it reached a terminal status. */
+    kind: 'started' | 'finished';
+    /** What the agent is building (its `intent`), for the notification body; may be absent. */
+    title?: string;
+    /** The finished agent's terminal status (`finished` only), so a stop reads differently from a done. */
+    status?: AgentStatus;
+    /** When the agent last changed, ISO, for ordering and the baseline diff. */
+    updatedAt?: string;
+}
+/** Injectable seam so {@link buildActivity} is unit-testable off disk. */
+export interface ActivityDeps {
+    /** A project's runs, live prepended to the archived history, newest-first. Defaults to disk. */
+    readAgents?: (cwd: string) => Promise<AgentMeta[]>;
+}
+/**
+ * Build the cross-project activity feed: for each registered project's most recent agents, one
+ * item per agent reflecting where it is now (`started` while it runs, `finished` once it lands),
+ * newest first. Forgiving — a project whose agents cannot be read simply contributes nothing, and
+ * comes back named as one that was *not* read whole (#1623), since "nothing happened there" and
+ * "I could not look" are the same empty list to everyone but the notification watcher.
+ *
+ * The `started` and `finished` items for one agent carry distinct keys ({@link activityKey}), so a
+ * run that is still going notifies once (started) and again when it lands (finished). An agent that
+ * both starts and finishes between two polls is only ever seen terminal, so it notifies once
+ * (finished) — one quick agent, one line.
+ */
+export declare function buildActivity(projects: ProjectSummary[], deps?: ActivityDeps): Promise<ProjectionRead<Activity>>;
+//# sourceMappingURL=activity.d.ts.map