@openagt/dashboard 0.0.0-stage → 0.8.0

package/dist/dashboard-rpc/relay-run.js

@@ -0,0 +1,21 @@
+import { contextRemote } from './context.js';
+import { relayRpc } from '../dashboard/remote-run.js';
+/**
+ * Run a run-scoped RPC locally, or relay it to the device when `runId` names a run this daemon is
+ * relaying to a connected one (#1067 slice 2). For an ordinary local run the remote lookup is empty and
+ * `local()` runs unchanged. For a remote run there is no local checkout, so the call is forwarded to the
+ * device over the token; if the device is unreachable, `unreachable` is returned - the same empty/error
+ * shape `local()` gives on a failed read - so the caller never special-cases a remote run.
+ */
+export async function relayOr(runId, fn, args, local, unreachable) {
+    const target = contextRemote()?.target(runId);
+    if (!target)
+        return local();
+    try {
+        return (await relayRpc(target, fn, args));
+    }
+    catch {
+        return unreachable;
+    }
+}
+//# sourceMappingURL=relay-run.js.map

package/dist/dashboard-rpc/relay-run.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"relay-run.js","sourceRoot":"","sources":["../../src/dashboard-rpc/relay-run.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAC5C,OAAO,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAA;AAErD;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,OAAO,CAC3B,KAAyB,EACzB,EAAU,EACV,IAAe,EACf,KAAuB,EACvB,WAAc;IAEd,MAAM,MAAM,GAAG,aAAa,EAAE,EAAE,MAAM,CAAC,KAAK,CAAC,CAAA;IAC7C,IAAI,CAAC,MAAM;QAAE,OAAO,KAAK,EAAE,CAAA;IAC3B,IAAI,CAAC;QACH,OAAO,CAAC,MAAM,QAAQ,CAAC,MAAM,EAAE,EAAE,EAAE,IAAI,CAAC,CAAM,CAAA;IAChD,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,WAAW,CAAA;IACpB,CAAC;AACH,CAAC"}

package/dist/dashboard-rpc/stream-channel.d.ts

@@ -0,0 +1,23 @@
+import { type ClientChannel } from 'telefunc';
+/**
+ * Wrap a live source in a Telefunc Channel (#405/#426): open the channel, hand `start` a
+ * `send` sink, and let it wire the source and hand back a stop function. When `start`
+ * returns undefined — an unknown project with nothing to stream — the channel closes
+ * immediately, mirroring the read model's empty results rather than throwing at the client;
+ * otherwise the stop runs on `.close()`. This owns the whole Channel lifecycle so the
+ * callers (events.telefunc.ts) read as "stream from this source" with no channel plumbing.
+ */
+export declare function streamChannel<T>(start: (send: (value: T) => void) => (() => void) | undefined): ClientChannel<never, T>;
+/**
+ * Forward an async-iterable of events to a `send` sink until the source is exhausted or
+ * the returned stop function is called (#426). This is the bridge behind the relay's
+ * `onEvents`: the relay's in-memory run is an `AsyncIterable` that replays its buffered
+ * history then follows live (exactly what `serveSSE` consumes), and each value becomes a
+ * `channel.send(event)`. Kept transport-agnostic (a plain `send` callback, not a Channel)
+ * so the pump can be driven and tested on its own; {@link streamChannel} wires the Channel.
+ *
+ * Returns a stop function that halts forwarding and cancels the iterator, releasing the
+ * follower waiting on the next event. Idempotent. An absent source is a no-op.
+ */
+export declare function forwardStream<T>(iterable: AsyncIterable<T> | undefined, send: (value: T) => void): () => void;
+//# sourceMappingURL=stream-channel.d.ts.map

package/dist/dashboard-rpc/stream-channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-channel.d.ts","sourceRoot":"","sources":["../../src/dashboard-rpc/stream-channel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,aAAa,EAAE,MAAM,UAAU,CAAA;AAEtD;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,GAAG,aAAa,CAAC,KAAK,EAAE,CAAC,CAAC,CAQvH;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,SAAS,EAAE,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,GAAG,MAAM,IAAI,CAiB7G"}

package/dist/dashboard-rpc/stream-channel.js

@@ -0,0 +1,52 @@
+import { Channel } from 'telefunc';
+/**
+ * Wrap a live source in a Telefunc Channel (#405/#426): open the channel, hand `start` a
+ * `send` sink, and let it wire the source and hand back a stop function. When `start`
+ * returns undefined — an unknown project with nothing to stream — the channel closes
+ * immediately, mirroring the read model's empty results rather than throwing at the client;
+ * otherwise the stop runs on `.close()`. This owns the whole Channel lifecycle so the
+ * callers (events.telefunc.ts) read as "stream from this source" with no channel plumbing.
+ */
+export function streamChannel(start) {
+    const channel = new Channel();
+    // `as never`: telefunc's ChannelData<T> wrapper doesn't resolve for a free type param
+    // (it does for a concrete event type); the sink is plain `T` for every caller.
+    const stop = start(value => void channel.send(value));
+    if (stop)
+        channel.onClose(stop);
+    else
+        void channel.close();
+    return channel.client;
+}
+/**
+ * Forward an async-iterable of events to a `send` sink until the source is exhausted or
+ * the returned stop function is called (#426). This is the bridge behind the relay's
+ * `onEvents`: the relay's in-memory run is an `AsyncIterable` that replays its buffered
+ * history then follows live (exactly what `serveSSE` consumes), and each value becomes a
+ * `channel.send(event)`. Kept transport-agnostic (a plain `send` callback, not a Channel)
+ * so the pump can be driven and tested on its own; {@link streamChannel} wires the Channel.
+ *
+ * Returns a stop function that halts forwarding and cancels the iterator, releasing the
+ * follower waiting on the next event. Idempotent. An absent source is a no-op.
+ */
+export function forwardStream(iterable, send) {
+    if (!iterable)
+        return () => { };
+    const iterator = iterable[Symbol.asyncIterator]();
+    let stopped = false;
+    void (async () => {
+        try {
+            for (let next = await iterator.next(); !next.done && !stopped; next = await iterator.next()) {
+                send(next.value);
+            }
+        }
+        catch {
+            // the stream closed or the consumer went away
+        }
+    })();
+    return () => {
+        stopped = true;
+        void iterator.return?.();
+    };
+}
+//# sourceMappingURL=stream-channel.js.map

package/dist/dashboard-rpc/stream-channel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-channel.js","sourceRoot":"","sources":["../../src/dashboard-rpc/stream-channel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAsB,MAAM,UAAU,CAAA;AAEtD;;;;;;;GAOG;AACH,MAAM,UAAU,aAAa,CAAI,KAA6D;IAC5F,MAAM,OAAO,GAAG,IAAI,OAAO,EAAY,CAAA;IACvC,sFAAsF;IACtF,+EAA+E;IAC/E,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,KAAc,CAAC,CAAC,CAAA;IAC9D,IAAI,IAAI;QAAE,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;;QAC1B,KAAK,OAAO,CAAC,KAAK,EAAE,CAAA;IACzB,OAAO,OAAO,CAAC,MAAM,CAAA;AACvB,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,aAAa,CAAI,QAAsC,EAAE,IAAwB;IAC/F,IAAI,CAAC,QAAQ;QAAE,OAAO,GAAG,EAAE,GAAE,CAAC,CAAA;IAC9B,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,aAAa,CAAC,EAAE,CAAA;IACjD,IAAI,OAAO,GAAG,KAAK,CAAA;IACnB,KAAK,CAAC,KAAK,IAAI,EAAE;QACf,IAAI,CAAC;YACH,KAAK,IAAI,IAAI,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,OAAO,EAAE,IAAI,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC;gBAC5F,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;YAClB,CAAC;QACH,CAAC;QAAC,MAAM,CAAC;YACP,8CAA8C;QAChD,CAAC;IACH,CAAC,CAAC,EAAE,CAAA;IACJ,OAAO,GAAG,EAAE;QACV,OAAO,GAAG,IAAI,CAAA;QACd,KAAK,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAA;IAC1B,CAAC,CAAA;AACH,CAAC"}

package/dist/dashboard-rpc/stream-forward.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Forward an async-iterable of events to a `send` sink until the source is exhausted or
+ * the returned stop function is called (#426). This is the bridge behind a relayed
+ * run's live feed: the agent is an `AsyncIterable` that replays its buffered history then follows
+ * live, and each value becomes one `send(event)`. Transport-agnostic on purpose — a plain
+ * callback, so the pump is driven and tested on its own, and the mount decides what a value
+ * becomes on the wire.
+ *
+ * `onDone` fires when the source runs out on its own — a relayed agent that finished. Without it a
+ * consumer cannot tell "nothing more is coming" from "nothing has happened yet", so an SSE
+ * response would stay open forever on a stream that was already over.
+ *
+ * Returns a stop function that halts forwarding and cancels the iterator, releasing the
+ * follower waiting on the next event. Idempotent. An absent source is a no-op.
+ */
+export declare function forwardStream<T>(iterable: AsyncIterable<T> | undefined, send: (value: T) => void, onDone?: () => void): () => void;
+//# sourceMappingURL=stream-forward.d.ts.map

package/dist/dashboard-rpc/stream-forward.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-forward.d.ts","sourceRoot":"","sources":["../../src/dashboard-rpc/stream-forward.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAC7B,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,SAAS,EACtC,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,EACxB,MAAM,CAAC,EAAE,MAAM,IAAI,GAClB,MAAM,IAAI,CAkBZ"}

package/dist/dashboard-rpc/stream-forward.js

@@ -0,0 +1,38 @@
+/**
+ * Forward an async-iterable of events to a `send` sink until the source is exhausted or
+ * the returned stop function is called (#426). This is the bridge behind a relayed
+ * run's live feed: the agent is an `AsyncIterable` that replays its buffered history then follows
+ * live, and each value becomes one `send(event)`. Transport-agnostic on purpose — a plain
+ * callback, so the pump is driven and tested on its own, and the mount decides what a value
+ * becomes on the wire.
+ *
+ * `onDone` fires when the source runs out on its own — a relayed agent that finished. Without it a
+ * consumer cannot tell "nothing more is coming" from "nothing has happened yet", so an SSE
+ * response would stay open forever on a stream that was already over.
+ *
+ * Returns a stop function that halts forwarding and cancels the iterator, releasing the
+ * follower waiting on the next event. Idempotent. An absent source is a no-op.
+ */
+export function forwardStream(iterable, send, onDone) {
+    if (!iterable)
+        return () => { };
+    const iterator = iterable[Symbol.asyncIterator]();
+    let stopped = false;
+    void (async () => {
+        try {
+            for (let next = await iterator.next(); !next.done && !stopped; next = await iterator.next()) {
+                send(next.value);
+            }
+        }
+        catch {
+            // the stream closed or the consumer went away
+        }
+        if (!stopped)
+            onDone?.();
+    })();
+    return () => {
+        stopped = true;
+        void iterator.return?.();
+    };
+}
+//# sourceMappingURL=stream-forward.js.map

package/dist/dashboard-rpc/stream-forward.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-forward.js","sourceRoot":"","sources":["../../src/dashboard-rpc/stream-forward.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,aAAa,CAC3B,QAAsC,EACtC,IAAwB,EACxB,MAAmB;IAEnB,IAAI,CAAC,QAAQ;QAAE,OAAO,GAAG,EAAE,GAAE,CAAC,CAAA;IAC9B,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,aAAa,CAAC,EAAE,CAAA;IACjD,IAAI,OAAO,GAAG,KAAK,CAAA;IACnB,KAAK,CAAC,KAAK,IAAI,EAAE;QACf,IAAI,CAAC;YACH,KAAK,IAAI,IAAI,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,OAAO,EAAE,IAAI,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC;gBAC5F,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;YAClB,CAAC;QACH,CAAC;QAAC,MAAM,CAAC;YACP,8CAA8C;QAChD,CAAC;QACD,IAAI,CAAC,OAAO;YAAE,MAAM,EAAE,EAAE,CAAA;IAC1B,CAAC,CAAC,EAAE,CAAA;IACJ,OAAO,GAAG,EAAE;QACV,OAAO,GAAG,IAAI,CAAA;QACd,KAAK,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAA;IAC1B,CAAC,CAAA;AACH,CAAC"}

package/dist/dashboard-rpc/subagents.d.ts

@@ -0,0 +1,12 @@
+import { type SubagentSettingsView } from '../dashboard/subagent-settings.js';
+import type { SubagentSettings } from '../subagent-settings.js';
+/** The settings in force, and how many projects have the line that writes them. */
+export declare function onSubagentSettings(): Promise<SubagentSettingsView>;
+/** Save the settings whole, through every registered project's `subagents` line. */
+export declare function sendSubagentSettings(settings: SubagentSettings): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+}>;
+//# sourceMappingURL=subagents.d.ts.map

package/dist/dashboard-rpc/subagents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subagents.d.ts","sourceRoot":"","sources":["../../src/dashboard-rpc/subagents.ts"],"names":[],"mappings":"AACA,OAAO,EAA6C,KAAK,oBAAoB,EAAE,MAAM,mCAAmC,CAAA;AACxH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAA;AAK/D,mFAAmF;AACnF,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,oBAAoB,CAAC,CAExE;AAED,oFAAoF;AACpF,wBAAsB,oBAAoB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CAE3H"}

package/dist/dashboard-rpc/subagents.js

@@ -0,0 +1,13 @@
+import { contextProjects } from './context.js';
+import { readSubagentSettings, setSubagentSettings } from '../dashboard/subagent-settings.js';
+// Settings → Subagents (#1902): the person's subagent settings, the same on every registered
+// project. The work over the projects is in `dashboard/subagent-settings.ts`.
+/** The settings in force, and how many projects have the line that writes them. */
+export async function onSubagentSettings() {
+    return readSubagentSettings(await contextProjects().list().catch(() => []));
+}
+/** Save the settings whole, through every registered project's `subagents` line. */
+export async function sendSubagentSettings(settings) {
+    return setSubagentSettings(await contextProjects().list().catch(() => []), settings);
+}
+//# sourceMappingURL=subagents.js.map

package/dist/dashboard-rpc/subagents.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subagents.js","sourceRoot":"","sources":["../../src/dashboard-rpc/subagents.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAC9C,OAAO,EAAE,oBAAoB,EAAE,mBAAmB,EAA6B,MAAM,mCAAmC,CAAA;AAGxH,6FAA6F;AAC7F,8EAA8E;AAE9E,mFAAmF;AACnF,MAAM,CAAC,KAAK,UAAU,kBAAkB;IACtC,OAAO,oBAAoB,CAAC,MAAM,eAAe,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;AAC7E,CAAC;AAED,oFAAoF;AACpF,MAAM,CAAC,KAAK,UAAU,oBAAoB,CAAC,QAA0B;IACnE,OAAO,mBAAmB,CAAC,MAAM,eAAe,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAA;AACtF,CAAC"}

package/dist/dashboard-rpc/test-context.d.ts

@@ -0,0 +1,23 @@
+import type { DashboardContext } from '../dashboard/rpc-serve.js';
+import type { DashboardOptions } from '../dashboard/server.js';
+/**
+ * What the dashboard host wires (D3), as a test would have it: every capability present, the two
+ * that start work refusing, and the reads answering empty. There is one host and it wires every
+ * capability, so an RPC reads its context as simply there — a missing field is a wiring bug, and
+ * it throws. That makes this the one place a test says what the host would have wired, with only
+ * the parts it cares about overridden.
+ */
+export declare function testDashboardContext(over?: Partial<DashboardContext>): DashboardContext;
+/**
+ * The same wiring as {@link testDashboardContext}, in the shape {@link startDashboard} takes: a
+ * test asserting one route still stands up the same server the product does.
+ */
+export declare function testDashboardOptions(over?: Partial<DashboardOptions>): DashboardOptions;
+/**
+ * Wire the dashboard's capabilities for a test that calls an RPC directly.
+ *
+ * It sticks until the next call, where Telefunc's request context used to evaporate at the next
+ * macrotask (F3) — so a test no longer has to call this immediately before the RPC under test.
+ */
+export declare function provideTestContext(over?: Partial<DashboardContext>): void;
+//# sourceMappingURL=test-context.d.ts.map

package/dist/dashboard-rpc/test-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-context.d.ts","sourceRoot":"","sources":["../../src/dashboard-rpc/test-context.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAA;AACjE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AAE9D;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,GAAE,OAAO,CAAC,gBAAgB,CAAM,GAAG,gBAAgB,CAa3F;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,GAAE,OAAO,CAAC,gBAAgB,CAAM,GAAG,gBAAgB,CAG3F;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,GAAE,OAAO,CAAC,gBAAgB,CAAM,GAAG,IAAI,CAE7E"}

package/dist/dashboard-rpc/test-context.js

@@ -0,0 +1,42 @@
+import { setDashboardContext } from './context.js';
+import { registryPreferencesStore } from '../registry.js';
+import { defaultQuotaSource } from '../dashboard/quota.js';
+/**
+ * What the dashboard host wires (D3), as a test would have it: every capability present, the two
+ * that start work refusing, and the reads answering empty. There is one host and it wires every
+ * capability, so an RPC reads its context as simply there — a missing field is a wiring bug, and
+ * it throws. That makes this the one place a test says what the host would have wired, with only
+ * the parts it cares about overridden.
+ */
+export function testDashboardContext(over = {}) {
+    return {
+        startAgent: () => ({ ok: false, error: 'not wired in this test' }),
+        addProject: () => ({ ok: false, error: 'not wired in this test' }),
+        eventsSource: () => undefined,
+        remote: { target: () => undefined, list: () => [] },
+        preferences: registryPreferencesStore(),
+        quota: defaultQuotaSource(),
+        models: { read: async () => ({ 'claude-code': { models: [] }, codex: { models: [] } }) },
+        projectErrors: () => ({ errors: [], localOnly: false }),
+        bridgeBrowser: { status: async () => ({ state: 'off' }), start: async () => { }, stop: async () => { }, act: async () => { } },
+        ...over,
+    };
+}
+/**
+ * The same wiring as {@link testDashboardContext}, in the shape {@link startDashboard} takes: a
+ * test asserting one route still stands up the same server the product does.
+ */
+export function testDashboardOptions(over = {}) {
+    const { startAgent, addProject, ...rest } = testDashboardContext();
+    return { port: 0, onStart: startAgent, onAddProject: addProject, ...rest, ...over };
+}
+/**
+ * Wire the dashboard's capabilities for a test that calls an RPC directly.
+ *
+ * It sticks until the next call, where Telefunc's request context used to evaporate at the next
+ * macrotask (F3) — so a test no longer has to call this immediately before the RPC under test.
+ */
+export function provideTestContext(over = {}) {
+    setDashboardContext(testDashboardContext(over));
+}
+//# sourceMappingURL=test-context.js.map

package/dist/dashboard-rpc/test-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-context.js","sourceRoot":"","sources":["../../src/dashboard-rpc/test-context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AAClD,OAAO,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAA;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAA;AAI1D;;;;;;GAMG;AACH,MAAM,UAAU,oBAAoB,CAAC,IAAI,GAA8B,EAAE;IACvE,OAAO;QACL,UAAU,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,wBAAwB,EAAE,CAAC;QAClE,UAAU,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,wBAAwB,EAAE,CAAC;QAClE,YAAY,EAAE,GAAG,EAAE,CAAC,SAAS;QAC7B,MAAM,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,SAAS,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE;QACnD,WAAW,EAAE,wBAAwB,EAAE;QACvC,KAAK,EAAE,kBAAkB,EAAE;QAC3B,MAAM,EAAE,EAAE,IAAI,EAAE,KAAK,IAAI,EAAE,CAAC,CAAC,EAAE,aAAa,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE;QACxF,aAAa,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC;QACvD,aAAa,EAAE,EAAE,MAAM,EAAE,KAAK,IAAI,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,KAAK,IAAI,EAAE,GAAE,CAAC,EAAE,IAAI,EAAE,KAAK,IAAI,EAAE,GAAE,CAAC,EAAE,GAAG,EAAE,KAAK,IAAI,EAAE,GAAE,CAAC,EAAE;QAC3H,GAAG,IAAI;KACR,CAAA;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,oBAAoB,CAAC,IAAI,GAA8B,EAAE;IACvE,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,GAAG,IAAI,EAAE,GAAG,oBAAoB,EAAE,CAAA;IAClE,OAAO,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,EAAE,GAAG,IAAI,EAAE,GAAG,IAAI,EAAE,CAAA;AACrF,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,kBAAkB,CAAC,IAAI,GAA8B,EAAE;IACrE,mBAAmB,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC,CAAA;AACjD,CAAC"}

package/dist/dashboard-rpc/widgets.d.ts

@@ -0,0 +1,33 @@
+import { type WidgetCommandResult } from '../project-widgets.js';
+export type { WidgetCommandResult } from '../project-widgets.js';
+/** One widget as the dashboard loads it: where its module is, and which projects have it. */
+export interface DashboardWidget {
+    /** The package that brings it. */
+    package: string;
+    /** The URL of its browser module, served from the first project that has it. */
+    url: string;
+    /** The registered projects whose packages include it, in the registry's order. */
+    projects: string[];
+}
+/**
+ * Every widget any registered project brings (#1774), one per package: the sidebar and the pages
+ * are cross-project, like the Overview. A package several projects install is loaded once, from
+ * the first of them in the registry's order; its page then reads each project through that
+ * project's own command. A project that cannot be read contributes nothing.
+ */
+export declare function onWidgets(): Promise<DashboardWidget[]>;
+/**
+ * Run one of a widget package's commands in one project and answer its JSON output: how a widget
+ * reads (and changes) its own data. Refused for an unknown project and for a package that is not a
+ * widget of that project, so a page can run only its own package's commands, never an arbitrary
+ * program. Once the command has run, the framework forgets what it had read of that project's
+ * provided data (its queue, its runs): the command may have written it, and the next read sees
+ * that at once instead of a cached copy.
+ *
+ * `acts` says the command is a widget's action on the project (a link action), not a page's read:
+ * the framework then also converges the project's data branch with origin, as its clock does
+ * every minute, before forgetting — a package's command writes as a remote writer, straight to
+ * origin, and this machine's copy would otherwise show the write only at the next sync.
+ */
+export declare function runWidgetCommand(projectId: string, pkg: string, args: string[], command?: string, acts?: boolean): Promise<WidgetCommandResult>;
+//# sourceMappingURL=widgets.d.ts.map

package/dist/dashboard-rpc/widgets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"widgets.d.ts","sourceRoot":"","sources":["../../src/dashboard-rpc/widgets.ts"],"names":[],"mappings":"AACA,OAAO,EAAyE,KAAK,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAKvI,YAAY,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAEhE,6FAA6F;AAC7F,MAAM,WAAW,eAAe;IAC9B,kCAAkC;IAClC,OAAO,EAAE,MAAM,CAAA;IACf,gFAAgF;IAChF,GAAG,EAAE,MAAM,CAAA;IACX,kFAAkF;IAClF,QAAQ,EAAE,MAAM,EAAE,CAAA;CACnB;AAED;;;;;GAKG;AACH,wBAAsB,SAAS,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC,CAW5D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,IAAI,UAAQ,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAUnJ"}

package/dist/dashboard-rpc/widgets.js

@@ -0,0 +1,54 @@
+import { contextProjects, resolveProjectPath } from './context.js';
+import { findProjectWidget, readProjectWidgets, runWidgetCommand as runCommand } from '../project-widgets.js';
+import { widgetUrl } from '../dashboard/widget-serve.js';
+import { providedDataChanged } from '../store/provided.js';
+import { DATA_BRANCH, pullFileBranch } from '@gemstack/agent-data';
+/**
+ * Every widget any registered project brings (#1774), one per package: the sidebar and the pages
+ * are cross-project, like the Overview. A package several projects install is loaded once, from
+ * the first of them in the registry's order; its page then reads each project through that
+ * project's own command. A project that cannot be read contributes nothing.
+ */
+export async function onWidgets() {
+    const byPackage = new Map();
+    for (const project of await contextProjects().list()) {
+        const widgets = await readProjectWidgets(project.path).catch(() => []);
+        for (const widget of widgets) {
+            const known = byPackage.get(widget.package);
+            if (known)
+                known.projects.push(project.id);
+            else
+                byPackage.set(widget.package, { package: widget.package, url: widgetUrl(project.id, widget), projects: [project.id] });
+        }
+    }
+    return [...byPackage.values()];
+}
+/**
+ * Run one of a widget package's commands in one project and answer its JSON output: how a widget
+ * reads (and changes) its own data. Refused for an unknown project and for a package that is not a
+ * widget of that project, so a page can run only its own package's commands, never an arbitrary
+ * program. Once the command has run, the framework forgets what it had read of that project's
+ * provided data (its queue, its runs): the command may have written it, and the next read sees
+ * that at once instead of a cached copy.
+ *
+ * `acts` says the command is a widget's action on the project (a link action), not a page's read:
+ * the framework then also converges the project's data branch with origin, as its clock does
+ * every minute, before forgetting — a package's command writes as a remote writer, straight to
+ * origin, and this machine's copy would otherwise show the write only at the next sync.
+ */
+export async function runWidgetCommand(projectId, pkg, args, command, acts = false) {
+    const root = await resolveProjectPath(projectId);
+    if (!root)
+        return { ok: false, error: 'unknown project' };
+    if (!Array.isArray(args))
+        return { ok: false, error: 'arguments must be a list' };
+    const widget = await findProjectWidget(root, pkg);
+    if (!widget)
+        return { ok: false, error: `${pkg} brings no widget to this project` };
+    const result = await runCommand(root, widget, args, command);
+    if (acts)
+        await pullFileBranch(root, DATA_BRANCH, { log: () => { } }).catch(() => { });
+    providedDataChanged(root);
+    return result;
+}
+//# sourceMappingURL=widgets.js.map

package/dist/dashboard-rpc/widgets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"widgets.js","sourceRoot":"","sources":["../../src/dashboard-rpc/widgets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAA;AAClE,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,gBAAgB,IAAI,UAAU,EAA4B,MAAM,uBAAuB,CAAA;AACvI,OAAO,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAA;AACxD,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAA;AAC1D,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAclE;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,SAAS;IAC7B,MAAM,SAAS,GAAG,IAAI,GAAG,EAA2B,CAAA;IACpD,KAAK,MAAM,OAAO,IAAI,MAAM,eAAe,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC;QACrD,MAAM,OAAO,GAAG,MAAM,kBAAkB,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,CAAA;QACtE,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;YAC7B,MAAM,KAAK,GAAG,SAAS,CAAC,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;YAC3C,IAAI,KAAK;gBAAE,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;;gBACrC,SAAS,CAAC,GAAG,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,GAAG,EAAE,SAAS,CAAC,OAAO,CAAC,EAAE,EAAE,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE,CAAC,CAAA;QAC7H,CAAC;IACH,CAAC;IACD,OAAO,CAAC,GAAG,SAAS,CAAC,MAAM,EAAE,CAAC,CAAA;AAChC,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAAC,SAAiB,EAAE,GAAW,EAAE,IAAc,EAAE,OAAgB,EAAE,IAAI,GAAG,KAAK;IACnH,MAAM,IAAI,GAAG,MAAM,kBAAkB,CAAC,SAAS,CAAC,CAAA;IAChD,IAAI,CAAC,IAAI;QAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,iBAAiB,EAAE,CAAA;IACzD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC;QAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,0BAA0B,EAAE,CAAA;IACjF,MAAM,MAAM,GAAG,MAAM,iBAAiB,CAAC,IAAI,EAAE,GAAG,CAAC,CAAA;IACjD,IAAI,CAAC,MAAM;QAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,GAAG,mCAAmC,EAAE,CAAA;IACnF,MAAM,MAAM,GAAG,MAAM,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,CAAC,CAAA;IAC5D,IAAI,IAAI;QAAE,MAAM,cAAc,CAAC,IAAI,EAAE,WAAW,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,GAAE,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAA;IACpF,mBAAmB,CAAC,IAAI,CAAC,CAAA;IACzB,OAAO,MAAM,CAAA;AACf,CAAC"}

package/dist/data-branch.d.ts

@@ -0,0 +1,120 @@
+import { type GitRunner } from '@gemstack/skill-branches';
+import { DATA_BRANCH } from './framework-dir.js';
+export { DATA_BRANCH };
+/** The data branch's checkout under a project. */
+export declare function dataWorktreePath(cwd: string): string;
+/** Injectable seams; production takes the defaults. */
+export interface DataBranchDeps {
+    git?: GitRunner;
+    /** Write one file, creating parents (default `node:fs/promises`). */
+    write?: (path: string, content: string) => Promise<void>;
+    /** Whether anything (file, dir, or dangling link) sits at `path` (default `fs.lstat`). */
+    lexists?: (path: string) => Promise<boolean>;
+    /** Create a symlink at `path` to `target` (default `node:fs/promises`). */
+    symlink?: (target: string, path: string) => Promise<void>;
+    log?: (message: string) => void;
+}
+/**
+ * Make sure the data branch and its checkout exist, the queue file is seeded, and the root
+ * `tickets` symlink points into the checkout. Idempotent and cheap when everything is in place
+ * (one `git rev-parse` against the checkout); never throws — a project this cannot be set up in
+ * reports why and is left alone.
+ */
+export declare function ensureDataWorktree(cwd: string, deps?: DataBranchDeps): Promise<{
+    ok: boolean;
+    error?: string;
+}>;
+/**
+ * What one funneled write did. `changed: false` is the clean no-op (the op wrote nothing new).
+ * A failure says whether the change still landed as a local commit (`committed` — the push is
+ * what failed, and the next cycle carries it out) or nothing survived at all.
+ */
+export type DataWriteResult = {
+    ok: true;
+    changed: boolean;
+    pushed: boolean;
+} | {
+    ok: false;
+    committed: boolean;
+    error: string;
+};
+/**
+ * Apply one change to the data branch: sync with origin, run `op` against the checkout, commit
+ * whatever it changed, push. The single funnel every local data write goes through (#1582).
+ *
+ * `op` must be re-runnable: when the push loses a race with another machine, the cycle re-syncs
+ * and runs it again against the fresher state rather than force-fitting a stale commit — the op
+ * *is* the intent, the commit is just its serialization. Two attempts; a push that still fails
+ * (the network, most likely) keeps the commit local and reports the error — the next cycle's sync
+ * rebases it onto whatever origin has by then, and the next push carries it.
+ *
+ * Never throws: callers run on background ticks with nothing to catch it.
+ */
+export declare function withDataBranch(cwd: string, message: string | (() => string), op: (dataDir: string) => Promise<void>, deps?: DataBranchDeps): Promise<DataWriteResult>;
+/**
+ * The file seams a *claim* on the data branch needs — the ticket locks (#1420) and the routine
+ * locks (#1659), which read, write, delete and list plain files inside the checkout the funnel
+ * hands them. Injectable so every operation is unit-testable off disk and git; production takes
+ * the defaults.
+ */
+export interface DataFileDeps {
+    /** Read one file (default `fs.readFile`); a rejection reads as "absent". */
+    read?: (path: string) => Promise<string>;
+    /** Write one file, creating parents (default `fs.writeFile`). */
+    write?: (path: string, content: string) => Promise<void>;
+    /** Delete one file (default `fs.rm`). */
+    remove?: (path: string) => Promise<void>;
+    /** The files under a directory, by filename (default `fs.readdir`); a missing directory reads as none. */
+    list?: (dir: string) => Promise<string[]>;
+    /** The data-branch write funnel (default {@link withDataBranch}); a test's fake stands in. */
+    funnel?: typeof withDataBranch;
+    /** Progress line. */
+    log?: (message: string) => void;
+}
+/**
+ * Fill in whatever a caller left out, so an operation reads the same way in tests and out. Parents
+ * are created on write because the directory itself is not a given: retiring the last file removes
+ * it (git keeps no empty dirs), and the branch is born without it.
+ */
+export declare function resolveDataFileDeps(deps: DataFileDeps): Required<DataFileDeps>;
+/** How a sync went: converged with origin, or why it could not. */
+export type DataSyncResult = {
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * The eager pull (#1582): sync the checkout with origin so this machine reads what other machines
+ * and cloud sessions committed, without waiting for the next local write — and push anything a
+ * failed cycle left stranded locally, via the same owed-push rule as the writer. Ensures the
+ * checkout exists, so a fresh clone converges on its first tick. Never throws.
+ *
+ * Reports why it could not converge (#1599): a push origin rejects, or no origin to converge with
+ * at all. The writer treats a remote-less repo as fine — the commit is safe locally — but a sync's
+ * whole job is to meet the other machines, and a repo nothing can reach is an error state the user
+ * has to fix, not a mode the framework supports (#1595). The daemon records the answer as the
+ * project's error state, so it reaches the dashboard rather than only the daemon's stdout.
+ */
+export declare function pullDataBranch(cwd: string, deps?: DataBranchDeps): Promise<DataSyncResult>;
+/**
+ * The project root `cwd` belongs to: the directory holding the repo's real `.git`. From the main
+ * checkout that is `cwd` itself; from an agent's worktree it is the repo the worktree was made
+ * from — where the data checkout lives, and the address every data write funnels to. `undefined`
+ * outside any repo.
+ */
+export declare function dataProjectRoot(cwd: string, git?: GitRunner): Promise<string | undefined>;
+/**
+ * Read one file off the data branch, from anywhere in the repo: the checkout when this `cwd` has
+ * one, else `git show` against the local branch (worktrees share the repo's refs, so an agent's
+ * checkout reads the same data without holding any of it), else against `origin/…` (a fresh
+ * clone that fetched but never branched — the cloud case). `undefined` when the file exists in
+ * none of them. Never throws.
+ *
+ * `fresh: true` fetches first and prefers origin's copy — for a reader about to act on the queue
+ * from a long-lived agent process, where the local ref may trail what other writers pushed.
+ */
+export declare function readDataFile(cwd: string, rel: string, opts?: {
+    fresh?: boolean;
+}, deps?: DataBranchDeps): Promise<string | undefined>;
+//# sourceMappingURL=data-branch.d.ts.map

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

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