@spinabot/brigade 0.1.2 → 1.0.1

package/dist/identity/device.js

@@ -0,0 +1,88 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { generateKeyPairSync, randomUUID } from "node:crypto";
+import { ensureDir, resolveIdentityDir } from "../config/paths.js";
+// Ed25519 device identity for the host running brigade. The public key is
+// the stable identifier the future gateway and any paired native client
+// will use to recognise this machine; the private key signs connection
+// payloads. Generated once on first onboard, persisted at mode 0600,
+// re-read thereafter.
+//
+// The format is intentionally simple — three fields per file, JSON, no
+// PEM wrappers — because brigade's only consumers are brigade itself and
+// future brigade-aware clients. If interop with external tooling becomes
+// a requirement we can add a PEM emitter at that point.
+const DEVICE_FILE = "device.json";
+const DEVICE_AUTH_FILE = "device-auth.json";
+const SCHEMA_VERSION = 1;
+// Generate the keypair on first call; on subsequent calls return the
+// existing identity. Idempotent across re-onboard runs.
+export async function ensureDeviceIdentity() {
+    const dir = resolveIdentityDir();
+    ensureDir(dir);
+    const identityPath = path.join(dir, DEVICE_FILE);
+    const authPath = path.join(dir, DEVICE_AUTH_FILE);
+    const existing = await tryReadIdentity(identityPath);
+    if (existing)
+        return { identity: existing, created: false };
+    const { publicKey, privateKey } = generateKeyPairSync("ed25519");
+    const deviceId = randomUUID();
+    const label = safeHostName();
+    const createdAt = new Date().toISOString();
+    const identity = {
+        version: SCHEMA_VERSION,
+        deviceId,
+        label,
+        publicKey: publicKey.export({ type: "spki", format: "der" }).toString("base64"),
+        createdAt,
+    };
+    const auth = {
+        version: SCHEMA_VERSION,
+        deviceId,
+        privateKey: privateKey
+            .export({ type: "pkcs8", format: "der" })
+            .toString("base64"),
+        createdAt,
+    };
+    await writeJsonAtomic(identityPath, identity, 0o644);
+    await writeJsonAtomic(authPath, auth, 0o600);
+    return { identity, created: true };
+}
+async function tryReadIdentity(p) {
+    try {
+        const raw = await fs.readFile(p, "utf8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed?.deviceId !== "string")
+            return undefined;
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function writeJsonAtomic(filePath, data, mode) {
+    const tmp = `${filePath}.tmp-${process.pid}-${Date.now().toString(36)}`;
+    await fs.writeFile(tmp, `${JSON.stringify(data, null, 2)}\n`, {
+        encoding: "utf8",
+        mode,
+    });
+    if (process.platform !== "win32") {
+        try {
+            await fs.chmod(tmp, mode);
+        }
+        catch {
+            // Some FSs (FAT32, network mounts) reject chmod — best effort.
+        }
+    }
+    await fs.rename(tmp, filePath);
+}
+function safeHostName() {
+    try {
+        return os.hostname();
+    }
+    catch {
+        return "brigade-host";
+    }
+}
+//# sourceMappingURL=device.js.map

package/dist/identity/device.js.map

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

package/dist/infra/backoff.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Backoff + cooldown primitives shared by the channel manager's restart
+ * loop, the heartbeat-runner's wake-cooldown layer, and any other "try
+ * again after N ms" pattern in the runtime.
+ *
+ * Two flavours of policy declared as readonly tuples:
+ *   - `CHANNEL_RESTART_POLICY` — `[1s, 5s, 15s, 60s, 5min]` schedule applied
+ *     by the channel-manager when a per-account `startAccount()` exits with
+ *     a non-zero crash. After the 5th crash inside the cap window the
+ *     account is parked and operator intervention is required.
+ *
+ * `computeBackoff(attemptIndex, schedule)` returns the next delay in ms.
+ * `attemptIndex` is 0-based — first crash uses `schedule[0]`. Indexes past
+ * the schedule end clamp to the final entry (so retry stays bounded at the
+ * tail, not infinite).
+ *
+ * `sleepWithAbort(ms, signal)` is a plain abortable timer — resolves at
+ * the deadline OR rejects with the signal's reason if the signal aborts
+ * first. No try/catch boilerplate at call sites.
+ */
+export declare const CHANNEL_RESTART_POLICY: readonly [1000, 5000, 15000, 60000, number];
+export declare function computeBackoff(attemptIndex: number, schedule: readonly number[]): number;
+export declare function sleepWithAbort(ms: number, signal?: AbortSignal): Promise<void>;
+//# sourceMappingURL=backoff.d.ts.map

package/dist/infra/backoff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backoff.d.ts","sourceRoot":"","sources":["../../src/infra/backoff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,eAAO,MAAM,sBAAsB,6CAAsD,CAAC;AAE1F,wBAAgB,cAAc,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAMxF;AAED,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAgB9E"}

package/dist/infra/backoff.js

@@ -0,0 +1,48 @@
+/**
+ * Backoff + cooldown primitives shared by the channel manager's restart
+ * loop, the heartbeat-runner's wake-cooldown layer, and any other "try
+ * again after N ms" pattern in the runtime.
+ *
+ * Two flavours of policy declared as readonly tuples:
+ *   - `CHANNEL_RESTART_POLICY` — `[1s, 5s, 15s, 60s, 5min]` schedule applied
+ *     by the channel-manager when a per-account `startAccount()` exits with
+ *     a non-zero crash. After the 5th crash inside the cap window the
+ *     account is parked and operator intervention is required.
+ *
+ * `computeBackoff(attemptIndex, schedule)` returns the next delay in ms.
+ * `attemptIndex` is 0-based — first crash uses `schedule[0]`. Indexes past
+ * the schedule end clamp to the final entry (so retry stays bounded at the
+ * tail, not infinite).
+ *
+ * `sleepWithAbort(ms, signal)` is a plain abortable timer — resolves at
+ * the deadline OR rejects with the signal's reason if the signal aborts
+ * first. No try/catch boilerplate at call sites.
+ */
+export const CHANNEL_RESTART_POLICY = [1_000, 5_000, 15_000, 60_000, 5 * 60_000];
+export function computeBackoff(attemptIndex, schedule) {
+    if (schedule.length === 0)
+        return 0;
+    if (attemptIndex < 0)
+        return schedule[0];
+    const last = schedule.length - 1;
+    const i = Math.min(attemptIndex, last);
+    return schedule[i];
+}
+export function sleepWithAbort(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(signal.reason ?? new Error("aborted"));
+            return;
+        }
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, Math.max(0, ms));
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(signal.reason ?? new Error("aborted"));
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}
+//# sourceMappingURL=backoff.js.map

package/dist/infra/backoff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"backoff.js","sourceRoot":"","sources":["../../src/infra/backoff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,MAAM,CAAU,CAAC;AAE1F,MAAM,UAAU,cAAc,CAAC,YAAoB,EAAE,QAA2B;IAC/E,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,CAAC,CAAC;IACpC,IAAI,YAAY,GAAG,CAAC;QAAE,OAAO,QAAQ,CAAC,CAAC,CAAE,CAAC;IAC1C,MAAM,IAAI,GAAG,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC;IACjC,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,IAAI,CAAC,CAAC;IACvC,OAAO,QAAQ,CAAC,CAAC,CAAE,CAAC;AACrB,CAAC;AAED,MAAM,UAAU,cAAc,CAAC,EAAU,EAAE,MAAoB;IAC9D,OAAO,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QAC5C,IAAI,MAAM,EAAE,OAAO,EAAE,CAAC;YACrB,MAAM,CAAC,MAAM,CAAC,MAAM,IAAI,IAAI,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC;YAC9C,OAAO;QACR,CAAC;QACD,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE;YAC7B,MAAM,EAAE,mBAAmB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;YAC9C,OAAO,EAAE,CAAC;QACX,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;QACpB,MAAM,OAAO,GAAG,GAAS,EAAE;YAC1B,YAAY,CAAC,KAAK,CAAC,CAAC;YACpB,MAAM,CAAC,MAAO,CAAC,MAAM,IAAI,IAAI,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC;QAChD,CAAC,CAAC;QACF,MAAM,EAAE,gBAAgB,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;IAC5D,CAAC,CAAC,CAAC;AACJ,CAAC"}

package/dist/infra/errors.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Shared error utilities used across the gateway, lane engine, and tools.
+ *
+ * Two named errors carry semantic weight beyond their message:
+ *
+ *   - `CommandLaneClearedError` — thrown by the lane engine when a queued
+ *     work item is dropped because `clearCommandLane(lane)` (or
+ *     `resetAllLanes()`) ran while it was waiting. Callers that see this
+ *     should NOT retry — the lane was reset on purpose (gateway shutdown,
+ *     test cleanup).
+ *
+ *   - `GatewayDrainingError` — thrown when the gateway is shutting down
+ *     and refuses to accept new work. Callers should treat this as a
+ *     normal stop signal, not a runtime failure.
+ *
+ * Both inherit from `Error` and set a stable `.name` so handlers can
+ * `err.name === "CommandLaneClearedError"` match without instanceof
+ * (instanceof breaks across module-cache boundaries in some test setups).
+ */
+export declare class CommandLaneClearedError extends Error {
+    readonly name = "CommandLaneClearedError";
+    constructor(message?: string);
+}
+export declare class GatewayDrainingError extends Error {
+    readonly name = "GatewayDrainingError";
+    constructor(message?: string);
+}
+/**
+ * Format any thrown value (Error, string, plain object, undefined) into a
+ * short single-line operator-facing string. Strips stack traces — callers
+ * who want a stack should log `err` separately. Used everywhere we need to
+ * surface a tool error / gateway error to the model or the TUI.
+ */
+export declare function formatErrorMessage(err: unknown): string;
+//# sourceMappingURL=errors.d.ts.map

package/dist/infra/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/infra/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,qBAAa,uBAAwB,SAAQ,KAAK;IACjD,SAAkB,IAAI,6BAA6B;gBACvC,OAAO,SAAyB;CAG5C;AAED,qBAAa,oBAAqB,SAAQ,KAAK;IAC9C,SAAkB,IAAI,0BAA0B;gBACpC,OAAO,SAA2C;CAG9D;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAYvD"}

package/dist/infra/errors.js

@@ -0,0 +1,54 @@
+/**
+ * Shared error utilities used across the gateway, lane engine, and tools.
+ *
+ * Two named errors carry semantic weight beyond their message:
+ *
+ *   - `CommandLaneClearedError` — thrown by the lane engine when a queued
+ *     work item is dropped because `clearCommandLane(lane)` (or
+ *     `resetAllLanes()`) ran while it was waiting. Callers that see this
+ *     should NOT retry — the lane was reset on purpose (gateway shutdown,
+ *     test cleanup).
+ *
+ *   - `GatewayDrainingError` — thrown when the gateway is shutting down
+ *     and refuses to accept new work. Callers should treat this as a
+ *     normal stop signal, not a runtime failure.
+ *
+ * Both inherit from `Error` and set a stable `.name` so handlers can
+ * `err.name === "CommandLaneClearedError"` match without instanceof
+ * (instanceof breaks across module-cache boundaries in some test setups).
+ */
+export class CommandLaneClearedError extends Error {
+    name = "CommandLaneClearedError";
+    constructor(message = "command lane cleared") {
+        super(message);
+    }
+}
+export class GatewayDrainingError extends Error {
+    name = "GatewayDrainingError";
+    constructor(message = "gateway is draining; refusing new work") {
+        super(message);
+    }
+}
+/**
+ * Format any thrown value (Error, string, plain object, undefined) into a
+ * short single-line operator-facing string. Strips stack traces — callers
+ * who want a stack should log `err` separately. Used everywhere we need to
+ * surface a tool error / gateway error to the model or the TUI.
+ */
+export function formatErrorMessage(err) {
+    if (err === null || err === undefined)
+        return "(no error)";
+    if (err instanceof Error) {
+        const msg = err.message.trim();
+        return msg.length > 0 ? msg : err.name;
+    }
+    if (typeof err === "string")
+        return err.trim() || "(empty error)";
+    try {
+        return JSON.stringify(err);
+    }
+    catch {
+        return String(err);
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/infra/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/infra/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,MAAM,OAAO,uBAAwB,SAAQ,KAAK;IAC/B,IAAI,GAAG,yBAAyB,CAAC;IACnD,YAAY,OAAO,GAAG,sBAAsB;QAC3C,KAAK,CAAC,OAAO,CAAC,CAAC;IAChB,CAAC;CACD;AAED,MAAM,OAAO,oBAAqB,SAAQ,KAAK;IAC5B,IAAI,GAAG,sBAAsB,CAAC;IAChD,YAAY,OAAO,GAAG,wCAAwC;QAC7D,KAAK,CAAC,OAAO,CAAC,CAAC;IAChB,CAAC;CACD;AAED;;;;;GAKG;AACH,MAAM,UAAU,kBAAkB,CAAC,GAAY;IAC9C,IAAI,GAAG,KAAK,IAAI,IAAI,GAAG,KAAK,SAAS;QAAE,OAAO,YAAY,CAAC;IAC3D,IAAI,GAAG,YAAY,KAAK,EAAE,CAAC;QAC1B,MAAM,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;QAC/B,OAAO,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC;IACxC,CAAC;IACD,IAAI,OAAO,GAAG,KAAK,QAAQ;QAAE,OAAO,GAAG,CAAC,IAAI,EAAE,IAAI,eAAe,CAAC;IAClE,IAAI,CAAC;QACJ,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;IAC5B,CAAC;IAAC,MAAM,CAAC;QACR,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC;IACpB,CAAC;AACF,CAAC"}

package/dist/infra/fs/atomic-rename.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Shared atomic-rename helpers with bounded retry on transient Windows
+ * filesystem errors (EPERM / EBUSY / EACCES). Used by every component that
+ * needs tmp+rename durability — the cron store, the run-log pruner, and
+ * any future on-disk JSONL writer.
+ *
+ * Why a helper rather than bare `fs.renameSync`:
+ *   On Windows, antivirus / search-indexer / Defender briefly holds an open
+ *   handle on the destination file as a freshly-written tmp lands. The
+ *   resulting rename fails with EPERM/EBUSY even though the file is
+ *   absolutely fine — a short retry with backoff resolves it. Linux/macOS
+ *   never see this; the helper is a no-op there (single attempt).
+ */
+export interface RenameWithRetryOptions {
+    /** Total attempts (including the first). Default 5. */
+    attempts?: number;
+    /** Sleep between attempts in ms. Default 50. */
+    delayMs?: number;
+}
+/**
+ * Synchronous rename with bounded retry on transient Windows errors. The
+ * sync variant exists for the cron-store hot path which needs blocking
+ * semantics so the timer loop sees the new file before the next tick.
+ */
+export declare function renameWithRetry(src: string, dst: string, opts?: RenameWithRetryOptions): void;
+/**
+ * Async variant for `fs/promises` callers. Same retry semantics, but uses
+ * `setTimeout` for the inter-attempt gap so the event loop is not blocked.
+ */
+export declare function renameWithRetryAsync(src: string, dst: string, opts?: RenameWithRetryOptions): Promise<void>;
+//# sourceMappingURL=atomic-rename.d.ts.map

package/dist/infra/fs/atomic-rename.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"atomic-rename.d.ts","sourceRoot":"","sources":["../../../src/infra/fs/atomic-rename.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAOH,MAAM,WAAW,sBAAsB;IACtC,uDAAuD;IACvD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gDAAgD;IAChD,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAC9B,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,IAAI,CAAC,EAAE,sBAAsB,GAC3B,IAAI,CAuBN;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CACzC,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,IAAI,CAAC,EAAE,sBAAsB,GAC3B,OAAO,CAAC,IAAI,CAAC,CAkBf"}

package/dist/infra/fs/atomic-rename.js

@@ -0,0 +1,75 @@
+/**
+ * Shared atomic-rename helpers with bounded retry on transient Windows
+ * filesystem errors (EPERM / EBUSY / EACCES). Used by every component that
+ * needs tmp+rename durability — the cron store, the run-log pruner, and
+ * any future on-disk JSONL writer.
+ *
+ * Why a helper rather than bare `fs.renameSync`:
+ *   On Windows, antivirus / search-indexer / Defender briefly holds an open
+ *   handle on the destination file as a freshly-written tmp lands. The
+ *   resulting rename fails with EPERM/EBUSY even though the file is
+ *   absolutely fine — a short retry with backoff resolves it. Linux/macOS
+ *   never see this; the helper is a no-op there (single attempt).
+ */
+import fs from "node:fs";
+/** Codes that warrant a retry. Anything else is an immediate hard error. */
+const RETRYABLE_RENAME_CODES = new Set(["EPERM", "EBUSY", "EACCES"]);
+/**
+ * Synchronous rename with bounded retry on transient Windows errors. The
+ * sync variant exists for the cron-store hot path which needs blocking
+ * semantics so the timer loop sees the new file before the next tick.
+ */
+export function renameWithRetry(src, dst, opts) {
+    const attempts = Math.max(1, opts?.attempts ?? 5);
+    const delayMs = Math.max(0, opts?.delayMs ?? 50);
+    let lastErr;
+    for (let i = 0; i < attempts; i++) {
+        try {
+            fs.renameSync(src, dst);
+            return;
+        }
+        catch (err) {
+            lastErr = err;
+            const code = err?.code;
+            if (!code || !RETRYABLE_RENAME_CODES.has(code))
+                throw err;
+            if (i === attempts - 1)
+                break;
+            // Tiny busy-wait — we're in a sync hot path, can't await. The
+            // retryable cases are 1-2 attempts in practice, so total stall is
+            // well under 250ms even at the cap.
+            const deadline = Date.now() + delayMs;
+            while (Date.now() < deadline) {
+                // no-op
+            }
+        }
+    }
+    throw lastErr instanceof Error ? lastErr : new Error(String(lastErr));
+}
+/**
+ * Async variant for `fs/promises` callers. Same retry semantics, but uses
+ * `setTimeout` for the inter-attempt gap so the event loop is not blocked.
+ */
+export async function renameWithRetryAsync(src, dst, opts) {
+    const { promises: pfs } = await import("node:fs");
+    const attempts = Math.max(1, opts?.attempts ?? 5);
+    const delayMs = Math.max(0, opts?.delayMs ?? 50);
+    let lastErr;
+    for (let i = 0; i < attempts; i++) {
+        try {
+            await pfs.rename(src, dst);
+            return;
+        }
+        catch (err) {
+            lastErr = err;
+            const code = err?.code;
+            if (!code || !RETRYABLE_RENAME_CODES.has(code))
+                throw err;
+            if (i === attempts - 1)
+                break;
+            await new Promise((r) => setTimeout(r, delayMs));
+        }
+    }
+    throw lastErr instanceof Error ? lastErr : new Error(String(lastErr));
+}
+//# sourceMappingURL=atomic-rename.js.map

package/dist/infra/fs/atomic-rename.js.map

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

package/dist/infra/json-file.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Atomic JSON file loader + saver.
+ *
+ * Both are sync (fs.* sync APIs) to keep the per-storePath FIFO lock queue
+ * in `session-store-lock.ts` simple — the queue serialises operations at
+ * the API boundary, so the file I/O does not need to be async-aware.
+ *
+ * Save semantics (`tmp + rename`):
+ *   1. Write the new content to `<path>.tmp` with `0o600` perms.
+ *   2. `fs.renameSync(<path>.tmp, <path>)` — atomic on every supported
+ *      filesystem (POSIX rename, NTFS MoveFileTransacted under the hood).
+ *
+ * A crash between step 1 and step 2 leaves the `.tmp` file behind but
+ * the existing `<path>` is untouched. A crash after step 2 has nothing
+ * to recover — the rename was atomic.
+ *
+ * Load semantics:
+ *   - Missing file → returns `null`.
+ *   - Empty file → returns `null` (treated as "no state yet").
+ *   - Malformed JSON → throws. The caller (session-store) catches and
+ *     decides whether to back up + reset or propagate.
+ */
+export declare function loadJsonFile<T>(filePath: string): T | null;
+export declare function saveJsonFile(filePath: string, value: unknown): void;
+//# sourceMappingURL=json-file.d.ts.map

package/dist/infra/json-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-file.d.ts","sourceRoot":"","sources":["../../src/infra/json-file.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAKH,wBAAgB,YAAY,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,GAAG,CAAC,GAAG,IAAI,CAK1D;AAED,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAcnE"}

package/dist/infra/json-file.js

@@ -0,0 +1,49 @@
+/**
+ * Atomic JSON file loader + saver.
+ *
+ * Both are sync (fs.* sync APIs) to keep the per-storePath FIFO lock queue
+ * in `session-store-lock.ts` simple — the queue serialises operations at
+ * the API boundary, so the file I/O does not need to be async-aware.
+ *
+ * Save semantics (`tmp + rename`):
+ *   1. Write the new content to `<path>.tmp` with `0o600` perms.
+ *   2. `fs.renameSync(<path>.tmp, <path>)` — atomic on every supported
+ *      filesystem (POSIX rename, NTFS MoveFileTransacted under the hood).
+ *
+ * A crash between step 1 and step 2 leaves the `.tmp` file behind but
+ * the existing `<path>` is untouched. A crash after step 2 has nothing
+ * to recover — the rename was atomic.
+ *
+ * Load semantics:
+ *   - Missing file → returns `null`.
+ *   - Empty file → returns `null` (treated as "no state yet").
+ *   - Malformed JSON → throws. The caller (session-store) catches and
+ *     decides whether to back up + reset or propagate.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+export function loadJsonFile(filePath) {
+    if (!fs.existsSync(filePath))
+        return null;
+    const raw = fs.readFileSync(filePath, "utf8");
+    if (!raw.trim())
+        return null;
+    return JSON.parse(raw);
+}
+export function saveJsonFile(filePath, value) {
+    const dir = path.dirname(filePath);
+    fs.mkdirSync(dir, { recursive: true });
+    const tmp = `${filePath}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(value, null, 2), {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+    try {
+        fs.chmodSync(tmp, 0o600);
+    }
+    catch {
+        /* best-effort on platforms without chmod */
+    }
+    fs.renameSync(tmp, filePath);
+}
+//# sourceMappingURL=json-file.js.map

package/dist/infra/json-file.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-file.js","sourceRoot":"","sources":["../../src/infra/json-file.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,MAAM,SAAS,CAAC;AAC9B,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAElC,MAAM,UAAU,YAAY,CAAI,QAAgB;IAC/C,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC;QAAE,OAAO,IAAI,CAAC;IAC1C,MAAM,GAAG,GAAG,EAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IAC9C,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE;QAAE,OAAO,IAAI,CAAC;IAC7B,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAM,CAAC;AAC7B,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,QAAgB,EAAE,KAAc;IAC5D,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IACnC,EAAE,CAAC,SAAS,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IACvC,MAAM,GAAG,GAAG,GAAG,QAAQ,MAAM,CAAC;IAC9B,EAAE,CAAC,aAAa,CAAC,GAAG,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE;QACrD,QAAQ,EAAE,MAAM;QAChB,IAAI,EAAE,KAAK;KACX,CAAC,CAAC;IACH,IAAI,CAAC;QACJ,EAAE,CAAC,SAAS,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IAC1B,CAAC;IAAC,MAAM,CAAC;QACR,4CAA4C;IAC7C,CAAC;IACD,EAAE,CAAC,UAAU,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;AAC9B,CAAC"}

package/dist/infra/json-utf8-bytes.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Compute the byte length of a value when serialised as UTF-8 JSON.
+ *
+ * Used by `sessions_history` to cap response size at 80 KiB even when the
+ * transcript chunk's character count is well under the cap — a chunk full
+ * of 4-byte emoji can blow past a byte budget computed via `.length` on
+ * the string.
+ *
+ * Implementation: encode via TextEncoder (zero allocations beyond the
+ * intermediate buffer, fast in modern V8) and return the buffer's byte
+ * length. The result is exact, not estimated.
+ */
+export declare function jsonUtf8Bytes(value: unknown): number;
+//# sourceMappingURL=json-utf8-bytes.d.ts.map

package/dist/infra/json-utf8-bytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-utf8-bytes.d.ts","sourceRoot":"","sources":["../../src/infra/json-utf8-bytes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAIpD"}

package/dist/infra/json-utf8-bytes.js

@@ -0,0 +1,20 @@
+/**
+ * Compute the byte length of a value when serialised as UTF-8 JSON.
+ *
+ * Used by `sessions_history` to cap response size at 80 KiB even when the
+ * transcript chunk's character count is well under the cap — a chunk full
+ * of 4-byte emoji can blow past a byte budget computed via `.length` on
+ * the string.
+ *
+ * Implementation: encode via TextEncoder (zero allocations beyond the
+ * intermediate buffer, fast in modern V8) and return the buffer's byte
+ * length. The result is exact, not estimated.
+ */
+const ENCODER = new TextEncoder();
+export function jsonUtf8Bytes(value) {
+    const serialised = JSON.stringify(value);
+    if (serialised === undefined)
+        return 0;
+    return ENCODER.encode(serialised).byteLength;
+}
+//# sourceMappingURL=json-utf8-bytes.js.map

package/dist/infra/json-utf8-bytes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-utf8-bytes.js","sourceRoot":"","sources":["../../src/infra/json-utf8-bytes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,MAAM,OAAO,GAAG,IAAI,WAAW,EAAE,CAAC;AAElC,MAAM,UAAU,aAAa,CAAC,KAAc;IAC3C,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IACzC,IAAI,UAAU,KAAK,SAAS;QAAE,OAAO,CAAC,CAAC;IACvC,OAAO,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,UAAU,CAAC;AAC9C,CAAC"}

package/dist/infra/net/dns-pinning.d.ts

@@ -0,0 +1,66 @@
+/**
+ * DNS-pinned dispatcher for SSRF-guarded fetch.
+ *
+ * The basic SSRF guard resolves a hostname's IP, checks it against the
+ * refuse list, and then hands the request off to `fetch`. There's a
+ * window between those two events: a hostile DNS server can return a
+ * public IP to the guard, then a private IP to the socket. This is the
+ * classic DNS-rebinding TOCTOU attack.
+ *
+ * To close it, we pre-resolve the hostname ourselves, pick the answers
+ * that PASS the SSRF check, and force the actual TCP connect to use one
+ * of THOSE EXACT IPs via undici's `Agent.connect.lookup` hook. The Host
+ * header still reads as the original hostname so TLS SNI + cert
+ * validation keep working.
+ *
+ * The `lookup` callback must match `dns.lookup`'s contract — when
+ * `opts.all === true`, we return an array of `{address, family}`
+ * objects; otherwise we return a single triple. Earlier revisions
+ * returned only the single-triple shape; undici 7+ calls with
+ * `opts.all: true` and that mismatch surfaces as
+ * `Invalid IP address: undefined`.
+ */
+import { type LookupAddress } from "node:dns";
+import type { Agent as UndiciAgent } from "undici";
+/**
+ * Resolve the hostname → list of A/AAAA records. Throws on resolution failure.
+ */
+export declare function resolveAll(hostname: string): Promise<LookupAddress[]>;
+interface PinnedAddress {
+    address: string;
+    family: 4 | 6;
+}
+/**
+ * Build a per-call undici Agent that locks the TCP connect to one of the
+ * pre-resolved + SSRF-vetted IPs, regardless of what the system resolver
+ * says at connect time.
+ */
+export declare function createPinnedDispatcher(args: {
+    hostname: string;
+    pinned: ReadonlyArray<PinnedAddress>;
+}): Promise<UndiciAgent>;
+/**
+ * One-shot helper: resolve, classify, keep every record that passes the
+ * SSRF check, and return a pinned dispatcher. Returns `null` when no
+ * resolved address passes (caller refuses the fetch).
+ */
+export declare function buildPinnedDispatcherForHostname(args: {
+    hostname: string;
+    classifyAddress: (addr: string, family: 4 | 6) => string | null;
+}): Promise<{
+    dispatcher: UndiciAgent;
+    addresses: PinnedAddress[];
+} | null>;
+/**
+ * Lazy-load undici's `fetch` — kept separate from the dispatcher so
+ * callers can do `fetch(url, { dispatcher })` using the SAME undici
+ * version the dispatcher was built from. Mixing Node's bundled
+ * `globalThis.fetch` with an externally-imported undici Agent
+ * triggers "invalid onRequestStart method" because the interceptor
+ * protocol drifts across versions.
+ */
+export declare function undiciFetch(input: string, init: RequestInit & {
+    dispatcher?: unknown;
+}): Promise<Response>;
+export {};
+//# sourceMappingURL=dns-pinning.d.ts.map

package/dist/infra/net/dns-pinning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dns-pinning.d.ts","sourceRoot":"","sources":["../../../src/infra/net/dns-pinning.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAA2B,KAAK,aAAa,EAAE,MAAM,UAAU,CAAC;AAEvE,OAAO,KAAK,EAAE,KAAK,IAAI,WAAW,EAAE,MAAM,QAAQ,CAAC;AAcnD;;GAEG;AACH,wBAAsB,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CAE3E;AAED,UAAU,aAAa;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC;CACd;AAED;;;;GAIG;AACH,wBAAsB,sBAAsB,CAAC,IAAI,EAAE;IAClD,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,aAAa,CAAC,aAAa,CAAC,CAAC;CACrC,GAAG,OAAO,CAAC,WAAW,CAAC,CA6DvB;AAED;;;;GAIG;AACH,wBAAsB,gCAAgC,CAAC,IAAI,EAAE;IAC5D,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,KAAK,MAAM,GAAG,IAAI,CAAC;CAChE,GAAG,OAAO,CAAC;IAAE,UAAU,EAAE,WAAW,CAAC;IAAC,SAAS,EAAE,aAAa,EAAE,CAAA;CAAE,GAAG,IAAI,CAAC,CAe1E;AAED;;;;;;;GAOG;AACH,wBAAsB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG;IAAE,UAAU,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAAC,QAAQ,CAAC,CAGhH"}