@jini-ai/daemon 0.1.0

package/dist/frontend-session-registry.d.ts

@@ -0,0 +1,127 @@
+/** A surface that has attached itself and can execute capabilities on a bound run's behalf. */
+export interface FrontendSessionDescriptor {
+    /** Identifies this surface. Minted by the host at attach time; opaque here. */
+    readonly sessionId: string;
+    /**
+     * Capability ids this surface claims it can execute. A call for anything this surface does not
+     * claim fails closed rather than hanging.
+     */
+    readonly capabilities: readonly string[];
+}
+/** One capability call pushed to a surface, awaiting exactly one answer. */
+export interface FrontendInvocation {
+    /** Correlates the answer with this call. Minted here, never supplied by the surface. */
+    readonly invocationId: string;
+    readonly capabilityId: string;
+    readonly input: Record<string, unknown>;
+}
+/** A surface's answer. A refusal is an outcome, not a transport failure. */
+export type FrontendOutcome = {
+    readonly ok: true;
+    readonly output: unknown;
+} | {
+    readonly ok: false;
+    readonly message: string;
+};
+export interface FrontendSessionHandle {
+    readonly sessionId: string;
+    /**
+     * Secret that proves a caller is the surface this handle belongs to, and the only thing that
+     * may cross a wire to bind a run (see {@link FrontendSessionRegistry.bindRunByToken}).
+     *
+     * Separate from `sessionId` on purpose. The session id is *addressing*, not authority: it
+     * appears in a URL path (`/api/frontend-sessions/:sessionId/responses`), and URLs leak by
+     * default — into access logs, proxies, browser history, `Referer` headers, and crash reports.
+     * Binding a run is the act that hands an agent control of a real user's screen, so it must not
+     * be authorized by a value the system is already scattering across places designed to be read.
+     */
+    readonly bindToken: string;
+    /**
+     * Detaches the surface. Every invocation still awaiting it is rejected rather than left pending,
+     * so a closed tab surfaces as a failed tool call instead of a run that never finishes.
+     */
+    detach(): void;
+}
+export interface FrontendSessionRegistry {
+    /**
+     * Registers a surface and the function that pushes invocations to it (an SSE write, a WebSocket
+     * send, an in-process call for a browser-resident caller that needs no relay at all).
+     *
+     * @throws If `sessionId` is already attached.
+     */
+    attach(descriptor: FrontendSessionDescriptor, deliver: (invocation: FrontendInvocation) => void): FrontendSessionHandle;
+    /**
+     * Associates a started run with the surface that originated it, so capability calls made by that
+     * run's agent reach that surface. Re-binding the same run to the same session is a no-op; binding
+     * it to a different one replaces the association, which is what a host should do when a run is
+     * genuinely taken over.
+     *
+     * @returns A function that removes this association — call it when the run reaches a terminal
+     * state so a long-lived surface does not accumulate bindings for runs that ended.
+     * @throws If `sessionId` is not attached. Binding a run to a surface that is already gone would
+     * produce calls that hang until their tool timeout instead of failing immediately.
+     */
+    bindRun(runId: string, sessionId: string): () => void;
+    /**
+     * Binds a run to whichever surface holds `bindToken` — the wire-safe form of {@link bindRun}.
+     *
+     * **Use this for anything a caller supplied.** `bindRun` trusts its `sessionId` argument
+     * completely, which is correct for a composition root choosing among surfaces it already knows
+     * about, and unsafe the moment the id came from outside: session ids travel in URLs, so a caller
+     * that observed one in a log could bind *its* run to *someone else's* tab and drive that screen.
+     * A bind token is minted per surface, delivered once over that surface's own stream, and never
+     * appears in a URL.
+     *
+     * @returns The same unbind function `bindRun` returns.
+     * @throws If no attached surface holds this token. The message deliberately does not
+     * distinguish "never existed" from "detached" — telling a caller which one it guessed is how a
+     * probe learns whether a token is worth retrying.
+     */
+    bindRunByToken(runId: string, bindToken: string): () => void;
+    /**
+     * Routes one capability call to the surface bound to `runId` and resolves with its output.
+     *
+     * @throws If no surface is bound to `runId`, if the bound surface does not claim `capabilityId`,
+     * if delivery fails, if the surface answers with a refusal, or if `signal` aborts first.
+     */
+    invoke(runId: string, capabilityId: string, input: Record<string, unknown>, signal?: AbortSignal): Promise<unknown>;
+    /**
+     * Settles a pending invocation with the surface's answer.
+     *
+     * @returns `true` if this call settled it; `false` if it was already settled, unknown, or belongs
+     * to a different session — the duplicate-answer case, which is a no-op by design.
+     */
+    settle(sessionId: string, invocationId: string, outcome: FrontendOutcome): boolean;
+    /**
+     * Capability ids reachable for `runId` right now — empty when nothing is bound. A caller uses
+     * this to advertise only what can actually be served, so an agent is never offered a capability
+     * that would fail the moment it tried.
+     */
+    capabilitiesFor(runId: string): readonly string[];
+    /** The surface bound to `runId`, or `undefined` when there is none. */
+    sessionFor(runId: string): FrontendSessionDescriptor | undefined;
+}
+export interface CreateFrontendSessionRegistryOptions {
+    /** Injectable id source for invocation ids — defaults to `randomUUID`. Test-only hook. */
+    readonly newInvocationId?: () => string;
+    /**
+     * Injectable source for bind tokens — defaults to `randomUUID`. Test-only hook.
+     *
+     * A production override must be unguessable: this value is the sole authority for binding a run
+     * to a surface, so a predictable sequence would reintroduce exactly the hazard
+     * {@link FrontendSessionRegistry.bindRunByToken} exists to close.
+     */
+    readonly newBindToken?: () => string;
+}
+/**
+ * Creates an in-memory registry of attached surfaces.
+ *
+ * State is per-process and intentionally not persisted: an attached surface is a live connection,
+ * so it cannot outlive the process that holds it, and a restart correctly presents as "nothing
+ * attached" rather than as a stale route to a tab that is long gone.
+ *
+ * @complexity Every operation is O(1) except `detach`, which is O(p + b) in that surface\'s pending
+ * invocations and bound runs.
+ */
+export declare function createFrontendSessionRegistry(options?: CreateFrontendSessionRegistryOptions): FrontendSessionRegistry;
+//# sourceMappingURL=frontend-session-registry.d.ts.map

package/dist/frontend-session-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frontend-session-registry.d.ts","sourceRoot":"","sources":["../src/frontend-session-registry.ts"],"names":[],"mappings":"AAiDA,+FAA+F;AAC/F,MAAM,WAAW,yBAAyB;IACxC,+EAA+E;IAC/E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;;;OAGG;IACH,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1C;AAED,4EAA4E;AAC5E,MAAM,WAAW,kBAAkB;IACjC,wFAAwF;IACxF,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACzC;AAED,4EAA4E;AAC5E,MAAM,MAAM,eAAe,GACvB;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;CAAE,GAC/C;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAErD,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;;;;;;;;;OASG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;;;OAGG;IACH,MAAM,IAAI,IAAI,CAAC;CAChB;AAED,MAAM,WAAW,uBAAuB;IACtC;;;;;OAKG;IACH,MAAM,CACJ,UAAU,EAAE,yBAAyB,EACrC,OAAO,EAAE,CAAC,UAAU,EAAE,kBAAkB,KAAK,IAAI,GAChD,qBAAqB,CAAC;IACzB;;;;;;;;;;OAUG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,IAAI,CAAC;IACtD;;;;;;;;;;;;;;OAcG;IACH,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,IAAI,CAAC;IAC7D;;;;;OAKG;IACH,MAAM,CACJ,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,OAAO,CAAC,CAAC;IACpB;;;;;OAKG;IACH,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC;IACnF;;;;OAIG;IACH,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAAC;IAClD,uEAAuE;IACvE,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,yBAAyB,GAAG,SAAS,CAAC;CAClE;AAED,MAAM,WAAW,oCAAoC;IACnD,0FAA0F;IAC1F,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,MAAM,CAAC;IACxC;;;;;;OAMG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,MAAM,CAAC;CACtC;AAeD;;;;;;;;;GASG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,GAAE,oCAAyC,GACjD,uBAAuB,CA0IzB"}

package/dist/frontend-session-registry.js

@@ -0,0 +1,180 @@
+/**
+ * `FrontendSessionRegistry` — the addressing layer between a run and an attached surface.
+ *
+ * Everything else on the delegated-tool path already exists: a CLI agent calls the injected MCP
+ * server, which posts `{runId, toolUseId, toolId, input}` back over loopback, which reaches
+ * `DelegatedToolBridge` and then `ToolExecutor`. What was missing is one concept — **a run has an
+ * id, a browser tab has nothing**, so a tool call arrives with no addressee. This registry is that
+ * addressee: a surface attaches itself against a run, and a tool handler can then reach *that*
+ * surface, execute a capability there, and get an answer back.
+ *
+ * Deliberately generic. This module knows nothing about `page.*`, the DOM, or chat — it routes an
+ * opaque `capabilityId` plus an opaque input to whichever surface claimed that capability. The
+ * vocabulary of what can be executed is the host's to define (see `@jini-ai/agentic`), which is what
+ * keeps a browser concept out of a server package.
+ *
+ * It also introduces **no second execution path**. The registry is only reachable from inside a
+ * `ToolHandler`, so every call through it has already passed `ToolExecutor`'s authorization,
+ * confirmation, timeout, cancellation, truncation, and audit trail. A route that called `invoke`
+ * directly would be strictly weaker, which is exactly the failure this design exists to avoid.
+ *
+ * That statement is about *this* path, and is worth stating precisely, because one ungated path
+ * does exist elsewhere: a frontend may register the same capabilities with the browser's in-page
+ * WebMCP surface, where a caller has no run and no principal and therefore never reaches
+ * `ToolExecutor` at all. Nothing in this package can gate that — it happens entirely in the page —
+ * so it is off unless a host opts in (`@jini-ai/chat-react`'s `agentControl.webmcp`). A reader who
+ * takes "no second execution path" as a whole-system guarantee would be wrong; it is a guarantee
+ * about everything that arrives here.
+ *
+ * **Attaching and binding are separate on purpose.** A surface attaches once, when it opens — a
+ * chat pane mounts long before the user sends anything, and runs are created per message, so a
+ * surface cannot know a run id at attach time. A run is *bound* to the surface that originated it
+ * when it starts. Beyond matching reality, this dissolves the worst routing hazard by construction:
+ * a run has exactly one originating surface, so a capability call can never be ambiguous between
+ * two open tabs, and no tie-break heuristic is needed that could act on a window nobody is
+ * watching.
+ *
+ * Three failure modes are handled explicitly rather than left to chance:
+ *
+ * 1. **A capability nothing can serve** — no surface bound to the run, or one that does not claim
+ *    the capability. Both fail closed with a message naming what was missing, never hang.
+ * 2. **A duplicate answer** (stream reconnect, retried POST, a surface that answers twice).
+ *    {@link FrontendSessionRegistry.settle} is idempotent and reports whether it was the one that
+ *    settled the invocation; the pending map *is* the idempotency store.
+ * 3. **A surface that never answers** (backgrounded tab, closed laptop). `invoke` rejects on its
+ *    caller's `AbortSignal`, which inside a handler is `ToolExecutor`'s own timeout/cancel signal —
+ *    so the existing `timeoutMs` on a tool descriptor covers this for free.
+ */
+import { randomUUID } from 'node:crypto';
+/**
+ * Creates an in-memory registry of attached surfaces.
+ *
+ * State is per-process and intentionally not persisted: an attached surface is a live connection,
+ * so it cannot outlive the process that holds it, and a restart correctly presents as "nothing
+ * attached" rather than as a stale route to a tab that is long gone.
+ *
+ * @complexity Every operation is O(1) except `detach`, which is O(p + b) in that surface\'s pending
+ * invocations and bound runs.
+ */
+export function createFrontendSessionRegistry(options = {}) {
+    const newInvocationId = options.newInvocationId ?? randomUUID;
+    const newBindToken = options.newBindToken ?? randomUUID;
+    const sessions = new Map();
+    const runBindings = new Map();
+    /** bind token → session id. Cleared on detach, so a token dies with the surface it proves. */
+    const bindTokens = new Map();
+    /** Resolves the surface that may serve this call, or explains precisely what is missing. */
+    function resolveTarget(runId, capabilityId) {
+        const sessionId = runBindings.get(runId);
+        const session = sessionId === undefined ? undefined : sessions.get(sessionId);
+        if (session === undefined) {
+            throw new Error(`no frontend is bound to run "${runId}", so "${capabilityId}" cannot be executed`);
+        }
+        if (!session.descriptor.capabilities.includes(capabilityId)) {
+            throw new Error(`the frontend bound to run "${runId}" does not offer "${capabilityId}" `
+                + `(it offers: ${session.descriptor.capabilities.join(', ') || 'nothing'})`);
+        }
+        return session;
+    }
+    function attach(descriptor, deliver) {
+        if (sessions.has(descriptor.sessionId)) {
+            throw new Error(`FrontendSessionRegistry: session "${descriptor.sessionId}" is already attached`);
+        }
+        const session = { descriptor, deliver, pending: new Map() };
+        sessions.set(descriptor.sessionId, session);
+        const bindToken = newBindToken();
+        bindTokens.set(bindToken, descriptor.sessionId);
+        return {
+            sessionId: descriptor.sessionId,
+            bindToken,
+            detach() {
+                sessions.delete(descriptor.sessionId);
+                bindTokens.delete(bindToken);
+                for (const [runId, boundTo] of runBindings) {
+                    if (boundTo === descriptor.sessionId)
+                        runBindings.delete(runId);
+                }
+                for (const [, entry] of session.pending) {
+                    entry.dispose();
+                    entry.reject(new Error(`frontend session "${descriptor.sessionId}" detached before answering`));
+                }
+                session.pending.clear();
+            },
+        };
+    }
+    function bindRun(runId, sessionId) {
+        if (!sessions.has(sessionId)) {
+            throw new Error(`FrontendSessionRegistry: cannot bind run "${runId}" to unattached session "${sessionId}"`);
+        }
+        runBindings.set(runId, sessionId);
+        return () => {
+            // Only release a binding this call still owns: a run taken over by another surface must not
+            // have its newer binding torn down by the older one\'s cleanup.
+            if (runBindings.get(runId) === sessionId)
+                runBindings.delete(runId);
+        };
+    }
+    function bindRunByToken(runId, bindToken) {
+        const sessionId = bindTokens.get(bindToken);
+        // One message for both "no such token" and "the surface holding it detached". Distinguishing
+        // them tells a caller whether a guess was close, which is the feedback a probe needs and the
+        // only feedback it needs.
+        if (sessionId === undefined) {
+            throw new Error(`FrontendSessionRegistry: cannot bind run "${runId}" — unknown or expired bind token`);
+        }
+        return bindRun(runId, sessionId);
+    }
+    // `async` so that a routing refusal from `resolveTarget` surfaces as a rejected promise like
+    // every other failure here. Throwing synchronously out of a Promise-returning function would
+    // make `invoke(...).catch(...)` an uncaught exception for exactly the fail-closed cases this
+    // registry exists to report.
+    async function invoke(runId, capabilityId, input, signal) {
+        const target = resolveTarget(runId, capabilityId);
+        const invocationId = newInvocationId();
+        return new Promise((resolve, reject) => {
+            const cancelled = () => new Error(`"${capabilityId}" was cancelled before the frontend answered`);
+            const onAbort = () => {
+                target.pending.delete(invocationId);
+                reject(cancelled());
+            };
+            const dispose = () => signal?.removeEventListener('abort', onAbort);
+            if (signal?.aborted) {
+                reject(cancelled());
+                return;
+            }
+            signal?.addEventListener('abort', onAbort, { once: true });
+            target.pending.set(invocationId, { resolve, reject, dispose });
+            try {
+                target.deliver({ invocationId, capabilityId, input });
+            }
+            catch (error) {
+                // A dead channel must fail the call rather than leave it pending until the tool times out.
+                target.pending.delete(invocationId);
+                dispose();
+                reject(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+    }
+    function settle(sessionId, invocationId, outcome) {
+        const session = sessions.get(sessionId);
+        const entry = session?.pending.get(invocationId);
+        if (session === undefined || entry === undefined)
+            return false;
+        session.pending.delete(invocationId);
+        entry.dispose();
+        if (outcome.ok)
+            entry.resolve(outcome.output);
+        else
+            entry.reject(new Error(outcome.message));
+        return true;
+    }
+    function sessionFor(runId) {
+        const sessionId = runBindings.get(runId);
+        return sessionId === undefined ? undefined : sessions.get(sessionId)?.descriptor;
+    }
+    function capabilitiesFor(runId) {
+        return sessionFor(runId)?.capabilities ?? [];
+    }
+    return { attach, bindRun, bindRunByToken, invoke, settle, capabilitiesFor, sessionFor };
+}
+//# sourceMappingURL=frontend-session-registry.js.map

package/dist/frontend-session-registry.js.map

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

package/dist/index.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @module @jini-ai/daemon
+ *
+ * `RunLifecycle` + the durable `EventLog` kernel port (extraction-plan §8
+ * task 5), plus the `ToolExecutor` tool-execution boundary (extraction-plan
+ * §2.5 / §8 task 6), and `AgentExecutor` — the driver that wires
+ * `@jini-ai/agent-runtime` into `RunLifecycle` (extraction-plan §2.1 / §3).
+ * See `source-map.md` for full provenance and scope-decision notes.
+ *
+ * The generic `ArtifactStore` kernel port used to live here too — moved to its own
+ * `@jini-ai/artifacts` package on 2026-07-19 (see `tokens.ts`'s doc comment).
+ *
+ * `routines/` (2026-07-21) adds the `RoutineService` scheduler (DST-safe wall-clock schedule
+ * math, race-safe scheduled-slot persistence) and the `RoutineStore` CRUD + run-history port,
+ * mirroring `EventLog`'s kernel-owned, storage-injected precedent. See its own module doc and
+ * `source-map.md`'s dated section for provenance.
+ *
+ * `terminal-session.ts` (2026-07-21) adds the interactive-terminal session manager: a
+ * `node-pty`-backed `PtySpawn` wired into `@jini-ai/platform`'s generic `TerminalService`, plus
+ * session-ownership gating and the kill/write/resize lock `@jini-ai/http`'s `terminals.ts` route
+ * pack calls into. This is this workspace's first native-compiled-addon dependency — see this
+ * package's `package.json` and `source-map.md`'s dated section.
+ */
+export * from './event-log.js';
+export * from './close-status.js';
+export * from './run-lifecycle.js';
+export * from './tool-executor.js';
+export * from './delegated-tool-bridge.js';
+export * from './frontend-session-registry.js';
+export * from './frontend-capability-tools.js';
+export * from './agent-executor.js';
+export * from './terminal-session.js';
+export * from './tokens.js';
+export * from './legacy-data-migration.js';
+export * from './run/index.js';
+export * from './continuation/index.js';
+export * from './routines/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC;AAC5B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,gBAAgB,CAAC;AAC/B,cAAc,yBAAyB,CAAC;AACxC,cAAc,qBAAqB,CAAC"}

package/dist/index.js

@@ -0,0 +1,38 @@
+/**
+ * @module @jini-ai/daemon
+ *
+ * `RunLifecycle` + the durable `EventLog` kernel port (extraction-plan §8
+ * task 5), plus the `ToolExecutor` tool-execution boundary (extraction-plan
+ * §2.5 / §8 task 6), and `AgentExecutor` — the driver that wires
+ * `@jini-ai/agent-runtime` into `RunLifecycle` (extraction-plan §2.1 / §3).
+ * See `source-map.md` for full provenance and scope-decision notes.
+ *
+ * The generic `ArtifactStore` kernel port used to live here too — moved to its own
+ * `@jini-ai/artifacts` package on 2026-07-19 (see `tokens.ts`'s doc comment).
+ *
+ * `routines/` (2026-07-21) adds the `RoutineService` scheduler (DST-safe wall-clock schedule
+ * math, race-safe scheduled-slot persistence) and the `RoutineStore` CRUD + run-history port,
+ * mirroring `EventLog`'s kernel-owned, storage-injected precedent. See its own module doc and
+ * `source-map.md`'s dated section for provenance.
+ *
+ * `terminal-session.ts` (2026-07-21) adds the interactive-terminal session manager: a
+ * `node-pty`-backed `PtySpawn` wired into `@jini-ai/platform`'s generic `TerminalService`, plus
+ * session-ownership gating and the kill/write/resize lock `@jini-ai/http`'s `terminals.ts` route
+ * pack calls into. This is this workspace's first native-compiled-addon dependency — see this
+ * package's `package.json` and `source-map.md`'s dated section.
+ */
+export * from './event-log.js';
+export * from './close-status.js';
+export * from './run-lifecycle.js';
+export * from './tool-executor.js';
+export * from './delegated-tool-bridge.js';
+export * from './frontend-session-registry.js';
+export * from './frontend-capability-tools.js';
+export * from './agent-executor.js';
+export * from './terminal-session.js';
+export * from './tokens.js';
+export * from './legacy-data-migration.js';
+export * from './run/index.js';
+export * from './continuation/index.js';
+export * from './routines/index.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC;AAC5B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,gBAAgB,CAAC;AAC/B,cAAc,yBAAyB,CAAC;AACxC,cAAc,qBAAqB,CAAC"}

package/dist/legacy-data-migration.d.ts

@@ -0,0 +1,104 @@
+/** Which files/dirs constitute a data root's migratable payload, host-supplied. */
+export interface LegacyDataMigrationConfig {
+    /** Every file/dir under a data root that is part of the migratable payload. */
+    payloadEntries: readonly string[];
+    /**
+     * The one entry (must be a member of `payloadEntries`) whose presence as a
+     * *file* proves a directory holds real, populated data rather than an
+     * empty scaffold a packaged installer pre-creates. For a sqlite-backed
+     * daemon this is the database file.
+     */
+    proofEntry: string;
+    /** Marker file name recording a completed migration. Defaults to `.migrated-from`. */
+    markerFile?: string;
+}
+export interface MigrateLegacyDataDirOptions extends LegacyDataMigrationConfig {
+    /** Path to the legacy data directory (typically from a host-defined env var). */
+    legacyDir: string | undefined;
+    /** Resolved current data root. */
+    dataDir: string;
+    /** Optional logger. Defaults to console.log. */
+    logger?: {
+        info(message: string): void;
+    };
+    /**
+     * Test seam. The default writes the JSON marker with fs.writeFileSync;
+     * tests inject a function that throws so the rollback path (which removes
+     * already-promoted payload entries) can be exercised without contriving
+     * real ENOSPC / read-only conditions. Production callers should never
+     * pass this.
+     * @internal
+     */
+    writeMarker?: (dataDir: string, legacyDir: string, markerFile: string) => void;
+}
+export type MigrateStatus = 'noop' | 'migrated' | 'skipped';
+export interface MigrateLegacyDataDirResult {
+    status: MigrateStatus;
+    reason: string;
+    copied?: readonly string[];
+}
+/**
+ * Thrown when `legacyDir` is explicitly set but is not a usable legacy data
+ * dir, or the new `dataDir` is already populated and would be merged into.
+ * Failing loud here is the point: a silent skip trains an operator to
+ * assume a migration ran when it didn't.
+ */
+export declare class LegacyMigrationError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+/**
+ * Returns true when `dataDir` looks like a fresh / never-used data root:
+ * either the directory does not exist, or it exists but does not contain
+ * the configured `proofEntry` as a file. Deliberately not just "the
+ * directory is empty" — a packaged install commonly pre-creates an empty
+ * `dataDir` before the daemon ever boots, so emptiness alone is not proof
+ * of "no prior data."
+ *
+ * @param dataDir - The data root to check.
+ * @param config - The host's payload/proof-entry configuration.
+ */
+export declare function dataDirIsEmptyOrFresh(dataDir: string, config: LegacyDataMigrationConfig): boolean;
+/**
+ * Returns true when `legacyDir` contains a payload worth migrating: it
+ * exists and its configured `proofEntry` exists as a file.
+ *
+ * @param legacyDir - The candidate legacy data directory.
+ * @param config - The host's payload/proof-entry configuration.
+ */
+export declare function legacyDirHasPayload(legacyDir: string, config: LegacyDataMigrationConfig): boolean;
+/**
+ * Returns the list of configured payload entries that already exist under
+ * `dataDir`. Migration refuses to merge on top of any of them — a database
+ * file/WAL pair or a project tree cannot be safely interleaved with a
+ * foreign counterpart, and a partial overlay is worse than no migration.
+ *
+ * @param dataDir - The data root to check.
+ * @param config - The host's payload/proof-entry configuration.
+ */
+export declare function dataDirHasExistingPayload(dataDir: string, config: LegacyDataMigrationConfig): string[];
+/**
+ * Move staged payload entries into the final `dataDir`. Each entry is moved
+ * with `renameSync` (atomic on the same filesystem); a cross-device rename
+ * falls back to copy + remove. Rollback-safe in two layers: the copy
+ * fallback removes a partial destination on its own failure, and the outer
+ * loop removes every entry it already promoted before rethrowing.
+ *
+ * @param stagingDir - The sibling staging directory holding the copied payload.
+ * @param dataDir - The destination data root.
+ * @param entries - The payload entries to promote.
+ * @returns The entries that were placed into `dataDir` before any failure.
+ */
+export declare function promoteStaged(stagingDir: string, dataDir: string, entries: readonly string[]): readonly string[];
+/**
+ * One-shot, idempotent legacy data migrator. Synchronous so it can run at
+ * module import time before a database connection opens. Throws
+ * {@link LegacyMigrationError} on operator-actionable failures (env set but
+ * path invalid; `dataDir` already populated; symlink in payload).
+ *
+ * @param options - Legacy/current dir paths plus the host's payload config.
+ * @returns The migration outcome (`noop` when unconfigured, `skipped` when
+ *   already migrated, `migrated` with the copied entry list otherwise).
+ */
+export declare function migrateLegacyDataDirSync(options: MigrateLegacyDataDirOptions): MigrateLegacyDataDirResult;
+//# sourceMappingURL=legacy-data-migration.d.ts.map

package/dist/legacy-data-migration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"legacy-data-migration.d.ts","sourceRoot":"","sources":["../src/legacy-data-migration.ts"],"names":[],"mappings":"AAoBA,mFAAmF;AACnF,MAAM,WAAW,yBAAyB;IACxC,+EAA+E;IAC/E,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC;;;;;OAKG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB,sFAAsF;IACtF,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,2BAA4B,SAAQ,yBAAyB;IAC5E,iFAAiF;IACjF,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,kCAAkC;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,gDAAgD;IAChD,MAAM,CAAC,EAAE;QACP,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;KAC7B,CAAC;IACF;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC;CAChF;AAED,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,UAAU,GAAG,SAAS,CAAC;AAE5D,MAAM,WAAW,0BAA0B;IACzC,MAAM,EAAE,aAAa,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC5B;AAID;;;;;GAKG;AACH,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBACV,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAK1C;AAkBD;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,yBAAyB,GAAG,OAAO,CAGjG;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,yBAAyB,GAAG,OAAO,CAGjG;AAED;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,yBAAyB,GAAG,MAAM,EAAE,CAGtG;AAiCD;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,MAAM,EAAE,CAyBhH;AAqBD;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,2BAA2B,GAAG,0BAA0B,CA2DzG"}