appduct 0.10.0 → 0.11.0

package/dist/daemon/registry.js

@@ -1,31 +0,0 @@
-/**
- * Per-session tool registry (ARCHITECTURE.md §7). Callers (sessions.ts/listener.ts) must validate
- * incoming `tool_registry_snapshot`/`tool_registry_delta` wire messages with the shared guards
- * *before* calling into this module — v1 crashed by indexing into an unvalidated `tools: [null]`
- * snapshot; this module only ever stores already-validated {@link ToolDescriptor}s.
- */
-/** `onChange` fires after every mutation (snapshot/upsert/remove) — used to emit `tools_changed`. */
-export const createToolRegistry = (onChange) => {
-    let tools = new Map();
-    const notify = () => {
-        onChange?.();
-    };
-    return {
-        snapshot: (incoming) => {
-            tools = new Map(incoming.map((tool) => [tool.name, tool]));
-            notify();
-        },
-        upsert: (tool) => {
-            tools.set(tool.name, tool);
-            notify();
-        },
-        remove: (name) => {
-            if (tools.delete(name)) {
-                notify();
-            }
-        },
-        list: () => Array.from(tools.values()),
-        get: (name) => tools.get(name),
-        count: () => tools.size,
-    };
-};

package/dist/daemon/rpc-server.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rpc-server.d.ts","sourceRoot":"","sources":["../../src/daemon/rpc-server.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAgB,KAAK,MAAM,EAAE,KAAK,MAAM,EAAE,MAAM,UAAU,CAAC;AAGlE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD,uGAAuG;AACvG,eAAO,MAAM,cAAc,QAAc,CAAC;AAE1C;iGACiG;AACjG,eAAO,MAAM,yBAAyB,QAAkB,CAAC;AAEzD,qBAAa,mBAAoB,SAAQ,KAAK;IAE1C,QAAQ,CAAC,IAAI,EAAE,SAAS;IAExB,wEAAwE;IACxE,QAAQ,CAAC,IAAI;IACb,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO;gBAJjB,IAAI,EAAE,SAAS,EACxB,OAAO,EAAE,MAAM;IACf,wEAAwE;IAC/D,IAAI,SAAS,EACb,OAAO,CAAC,EAAE,OAAO,YAAA;CAK7B;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,2EAA2E;IAC3E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACzC,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,UAAU,EAAE,aAAa,CAAC;IAC1B,8FAA8F;IAC9F,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC;IAC1C;;;;2FAIuF;IACvF,OAAO,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CAAC;CAC/C,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,iBAAiB,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;AAErG,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;AA2C1D,MAAM,MAAM,gBAAgB,GAAG;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,uFAAuF;IACvF,MAAM,EAAE,CAAC,UAAU,EAAE,aAAa,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IAC9D,WAAW,EAAE,MAAM,aAAa,EAAE,CAAC;IACnC,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5B,CAAC;AAsEF,eAAO,MAAM,cAAc,GAAU,SAAS,gBAAgB,KAAG,OAAO,CAAC,SAAS,CAiIjF,CAAC"}

package/dist/daemon/rpc-server.js

@@ -1,203 +0,0 @@
-/**
- * The control-plane UDS JSON-RPC server (ARCHITECTURE.md §5). Framing: one JSON-RPC 2.0 message
- * per line (`\n`-delimited). Server→client notifications use method `"event"` and are pushed via
- * {@link notify} on a targeted connection — this module only exposes the primitive.
- */
-import { createServer } from "node:net";
-import { chmod, rm } from "node:fs/promises";
-/** 1 MiB — lines beyond this are dropped by destroying the connection (ARCHITECTURE.md task notes). */
-export const MAX_LINE_BYTES = 1024 * 1024;
-/** 4 MiB — a subscriber connection (`events.subscribe`) whose outbound buffer grows past this
- * (slow/dead reader) is dropped outright rather than left to back up the daemon indefinitely. */
-export const MAX_NOTIFY_BUFFERED_BYTES = 4 * 1024 * 1024;
-export class RpcApplicationError extends Error {
-    type;
-    code;
-    details;
-    constructor(type, message, 
-    /** JSON-RPC error code; defaults to the shared "server error" range. */
-    code = -32000, details) {
-        super(message);
-        this.type = type;
-        this.code = code;
-        this.details = details;
-        this.name = "RpcApplicationError";
-    }
-}
-const isPlainObject = (value) => {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-};
-const hasRequestId = (value) => {
-    return "id" in value;
-};
-const writeErrorLine = (socket, id, code, message, data) => {
-    writeLine(socket, {
-        jsonrpc: "2.0",
-        id,
-        error: { code, message, ...(data ? { data } : {}) },
-    });
-};
-const writeLine = (socket, payload, onFlushed) => {
-    if (socket.destroyed) {
-        return;
-    }
-    socket.write(`${JSON.stringify(payload)}\n`, (error) => {
-        if (!error) {
-            onFlushed?.();
-        }
-    });
-};
-const handleLine = async (line, connection, dispatch, registerOnClose) => {
-    const { socket } = connection;
-    let request;
-    try {
-        const parsed = JSON.parse(line);
-        if (!isPlainObject(parsed)) {
-            writeErrorLine(socket, null, -32600, "Invalid Request: expected a JSON object.");
-            return;
-        }
-        request = parsed;
-    }
-    catch {
-        writeErrorLine(socket, null, -32700, "Parse error: invalid JSON.");
-        return;
-    }
-    const id = hasRequestId(request) ? request.id : null;
-    if (typeof request.method !== "string" || request.method.length === 0) {
-        writeErrorLine(socket, id, -32600, 'Invalid Request: "method" must be a non-empty string.');
-        return;
-    }
-    const handler = dispatch[request.method];
-    if (!handler) {
-        writeErrorLine(socket, id, -32601, `Method not found: "${request.method}".`);
-        return;
-    }
-    const afterSendCallbacks = [];
-    const context = {
-        connection,
-        afterSend: (callback) => {
-            afterSendCallbacks.push(callback);
-        },
-        onClose: registerOnClose,
-    };
-    try {
-        const result = await handler(request.params, context);
-        writeLine(socket, { jsonrpc: "2.0", id, result: result ?? null }, () => {
-            for (const callback of afterSendCallbacks) {
-                callback();
-            }
-        });
-    }
-    catch (error) {
-        if (error instanceof RpcApplicationError) {
-            writeErrorLine(socket, id, error.code, error.message, {
-                type: error.type,
-                ...(error.details !== undefined ? { details: error.details } : {}),
-            });
-            return;
-        }
-        const message = error instanceof Error ? error.message : "Internal error.";
-        writeErrorLine(socket, id, -32603, message, { type: "invalid_request" });
-    }
-};
-export const startRpcServer = async (options) => {
-    const maxLineBytes = options.maxLineBytes ?? MAX_LINE_BYTES;
-    const connections = new Map();
-    let nextConnectionId = 1;
-    await rm(options.socketPath, { force: true });
-    const server = createServer((socket) => {
-        socket.on("error", () => {
-            // A dropped/reset client connection must never crash the daemon.
-        });
-        const id = nextConnectionId;
-        nextConnectionId += 1;
-        const connection = { id, socket, state: {} };
-        connections.set(id, connection);
-        const closeCallbacks = new Set();
-        const registerOnClose = (callback) => {
-            closeCallbacks.add(callback);
-            return () => {
-                closeCallbacks.delete(callback);
-            };
-        };
-        let buffer = "";
-        socket.on("data", (chunk) => {
-            buffer += chunk.toString("utf8");
-            if (Buffer.byteLength(buffer, "utf8") > maxLineBytes && !buffer.includes("\n")) {
-                socket.destroy();
-                return;
-            }
-            let newlineIndex = buffer.indexOf("\n");
-            while (newlineIndex !== -1) {
-                const line = buffer.slice(0, newlineIndex).replace(/\r$/u, "");
-                buffer = buffer.slice(newlineIndex + 1);
-                if (line.length > 0) {
-                    if (Buffer.byteLength(line, "utf8") > maxLineBytes) {
-                        // ARCHITECTURE.md task notes: cap line length at 1 MiB, dropping the connection beyond.
-                        writeErrorLine(socket, null, -32600, `Invalid Request: line exceeds the ${maxLineBytes}-byte limit.`);
-                        socket.destroy();
-                        return;
-                    }
-                    void handleLine(line, connection, options.dispatch, registerOnClose);
-                }
-                newlineIndex = buffer.indexOf("\n");
-            }
-        });
-        socket.on("close", () => {
-            connections.delete(id);
-            const callbacks = Array.from(closeCallbacks);
-            closeCallbacks.clear();
-            for (const callback of callbacks) {
-                try {
-                    callback();
-                }
-                catch {
-                    // A close callback must never crash the daemon.
-                }
-            }
-        });
-    });
-    server.on("error", () => {
-        // Never let a listener-level error (e.g. EMFILE after startup) crash the process. Startup
-        // failures are additionally surfaced via the one-shot listener below, which rejects `listen()`.
-        // Surfacing post-startup errors would require a caller-supplied sink; the daemon composition
-        // root owns observability wiring in a later task.
-    });
-    await new Promise((resolve, reject) => {
-        const onError = (error) => {
-            server.off("listening", onListening);
-            reject(error);
-        };
-        const onListening = () => {
-            server.off("error", onError);
-            resolve();
-        };
-        server.once("error", onError);
-        server.once("listening", onListening);
-        server.listen(options.socketPath);
-    });
-    await chmod(options.socketPath, 0o600);
-    return {
-        server,
-        notify: (connection, payload) => {
-            if (connection.socket.destroyed) {
-                return;
-            }
-            // Backpressure guard: a slow/dead subscriber must never block the daemon or other
-            // connections. `writableLength` reflects bytes already queued but not yet flushed to the
-            // kernel; once it crosses the cap the connection is beyond saving and gets dropped.
-            if (connection.socket.writableLength > MAX_NOTIFY_BUFFERED_BYTES) {
-                connection.socket.destroy();
-                return;
-            }
-            writeLine(connection.socket, { jsonrpc: "2.0", method: "event", params: payload });
-        },
-        connections: () => Array.from(connections.values()),
-        close: () => new Promise((resolve) => {
-            for (const connection of connections.values()) {
-                connection.socket.destroy();
-            }
-            server.close(() => resolve());
-        }),
-    };
-};

package/dist/daemon/sessions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sessions.d.ts","sourceRoot":"","sources":["../../src/daemon/sessions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,EASL,KAAK,YAAY,EAEjB,KAAK,mBAAmB,EAExB,KAAK,oBAAoB,EACzB,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,uBAAuB,EAC5B,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACvB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,IAAI,CAAC;AAEpC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAA6B,KAAK,WAAW,EAA4B,MAAM,YAAY,CAAC;AAEnG,OAAO,EAAsB,KAAK,YAAY,EAAE,MAAM,eAAe,CAAC;AACtE,OAAO,EAAgB,KAAK,QAAQ,EAAoB,MAAM,aAAa,CAAC;AAI5E,kGAAkG;AAClG,eAAO,MAAM,wBAAwB,aAOnC,CAAC;AAEH,eAAO,MAAM,sBAAsB,GAAI,MAAM,OAAO,KAAG,IAAI,IAAI,MAE9D,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,QAAQ,MAAM,KAAG,MAWnD,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,MAAM,MAAM,EAAE,iBAAiB,WAAW,CAAC,MAAM,CAAC,KAAG,MAYhF,CAAC;AAiDF,MAAM,MAAM,qBAAqB,GAAG;IAClC,YAAY,EAAE,MAAM,CAAC;IACrB,wBAAwB,EAAE,MAAM,CAAC;IACjC,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,WAAW,CAAC,UAAU,CAAC,CAAC;IAC3C,QAAQ,EAAE,QAAQ,CAAC;IACnB,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,MAAM,CAAC,EAAE,QAAQ,CAAC;IAClB;gFAC4E;IAC5E,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE,iBAAiB,GAAG,gBAAgB,GAAG,uBAAuB,KAAK,IAAI,CAAC;IAChG;8CAC0C;IAC1C,UAAU,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,KAAK,IAAI,CAAC;CAChF,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,QAAQ,EAAE,WAAW,CAAC,UAAU,CAAC,CAAC;IAClC,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B;;;4FAGwF;IACxF,UAAU,EAAE,CAAC,UAAU,CAAC,EAAE,MAAM,EAAE,eAAe,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC,gBAAgB,EAAE,KAAK,CAAC,CAAC;IAC7F,0GAA0G;IAC1G,WAAW,EAAE,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,mBAAmB,KAAK,MAAM,GAAG,IAAI,CAAC;IAChF,2GAA2G;IAC3G,YAAY,EAAE,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,oBAAoB,KAAK,MAAM,GAAG,IAAI,CAAC;IAClF,mGAAmG;IACnG,sBAAsB,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IACzG,IAAI,EAAE,MAAM,cAAc,EAAE,CAAC;IAC7B;;gCAE4B;IAC5B,gBAAgB,EAAE,MAAM,MAAM,CAAC;IAC/B,QAAQ,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,cAAc,CAAC;IAChD,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACpC;;oFAEgF;IAChF,eAAe,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK;QACtC,SAAS,EAAE,MAAM,CAAC;QAClB,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,QAAQ,GAAG,WAAW,CAAC;QAC9B,QAAQ,EAAE,YAAY,CAAC;KACxB,CAAC;IACF;;8FAE0F;IAC1F,YAAY,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,KAAK,OAAO,CAAC;IACvE;;0FAEsF;IACtF,cAAc,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,KAAK,OAAO,CAAC;IAC3E,4FAA4F;IAC5F,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CACpD,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAI,SAAS,qBAAqB,KAAG,cA2brE,CAAC"}

package/dist/daemon/sessions.js

@@ -1,429 +0,0 @@
-/**
- * The session state machine (ARCHITECTURE.md §6, exactly): PENDING (owned by links.ts) →
- * ACTIVE ⇄ SUSPENDED → EXPIRED, with REVOKED reachable from any live state. This module owns the
- * live-session map, claim/resume handling (including the pre-auth hardening in the task's
- * rejection matrix), alias assignment, keepalive-driven suspend, and grace-timer expiry.
- *
- * Pending links never enter `sessions` — they live in links.ts's `PendingLinkRegistry` and are
- * only ever resolved during claim. `sessions` therefore only ever holds live (active/suspended)
- * sessions; terminal transitions (revoked/expired) remove the entry immediately (ARCHITECTURE.md
- * §6: "terminal states free the alias" — there is no persisted history, matching §3/§13's "no
- * per-session files, all state in-daemon-memory").
- */
-import { randomBytes, timingSafeEqual } from "node:crypto";
-import { isEventMessage, isToolCallProgressMessage, isToolErrorMessage, isToolRegistryDeltaMessage, isToolRegistrySnapshotMessage, isToolResultMessage, parseSessionClaimDeviceFields, } from "@appduct/shared";
-import { createPendingLinkRegistry } from "./links.js";
-import { RpcApplicationError } from "./rpc-server.js";
-import { createToolRegistry } from "./registry.js";
-import { systemTimers } from "./timers.js";
-const RESUME_TOKEN_BYTES = 32;
-/** Wire message types allowed *after* claim (session_claim/session_resume are pre-claim only). */
-export const POST_CLAIM_MESSAGE_TYPES = new Set([
-    "tool_registry_snapshot",
-    "tool_registry_delta",
-    "tool_result",
-    "tool_error",
-    "tool_call_progress",
-    "event",
-]);
-export const isPostClaimMessageType = (type) => {
-    return typeof type === "string" && POST_CLAIM_MESSAGE_TYPES.has(type);
-};
-export const slugifyDeviceModel = (model) => {
-    if (!model) {
-        return "device";
-    }
-    const slug = model
-        .toLowerCase()
-        .replaceAll(/[^a-z0-9]+/gu, "-")
-        .replaceAll(/^-+|-+$/gu, "");
-    return slug.length > 0 ? slug : "device";
-};
-export const dedupeAlias = (base, existingAliases) => {
-    if (!existingAliases.has(base)) {
-        return base;
-    }
-    let suffix = 2;
-    while (existingAliases.has(`${base}-${suffix}`)) {
-        suffix += 1;
-    }
-    return `${base}-${suffix}`;
-};
-const decodeFixedLengthToken = (base64url, expectedLength) => {
-    let decoded;
-    try {
-        decoded = Buffer.from(base64url, "base64url");
-    }
-    catch {
-        return null;
-    }
-    return decoded.length === expectedLength ? decoded : null;
-};
-/** Constant-time-safe comparison: never calls `timingSafeEqual` on mismatched lengths (it throws). */
-const tokensMatch = (candidate, expected) => {
-    if (!candidate || candidate.length !== expected.length) {
-        return false;
-    }
-    return timingSafeEqual(candidate, expected);
-};
-const MAX_FAILED_CLAIM_ATTEMPTS = 5;
-const closeSocket = (socket, code, reason) => {
-    try {
-        socket.close(code, reason);
-    }
-    catch {
-        // The socket may already be closing/closed; never let a double-close crash the daemon.
-        socket.terminate();
-    }
-};
-export const createSessionManager = (options) => {
-    const clock = options.clock ?? { now: () => new Date() };
-    const timers = options.timers ?? systemTimers;
-    const sessions = new Map();
-    const pendingLinks = createPendingLinkRegistry({
-        getEndpoint: options.getEndpoint,
-        clock,
-        timers,
-        eventBus: options.eventBus,
-    });
-    const emit = (kind, sessionId, alias, data) => {
-        options.eventBus.emit({ kind, sessionId, alias, data });
-    };
-    const toSummary = (session) => {
-        return {
-            sessionId: session.sessionId,
-            alias: session.alias,
-            state: session.state,
-            device: session.device,
-            createdAt: session.createdAt.toISOString(),
-            claimedAt: session.claimedAt.toISOString(),
-            ...(session.suspendedAt ? { suspendedAt: session.suspendedAt.toISOString() } : {}),
-            toolCount: session.registry.count(),
-        };
-    };
-    const resolveSession = (selector) => {
-        const live = Array.from(sessions.values());
-        if (selector !== undefined) {
-            const match = live.find((session) => session.sessionId === selector || session.alias === selector);
-            if (!match) {
-                throw new RpcApplicationError("unknown_session", `No session matches "${selector}".`);
-            }
-            return match;
-        }
-        if (live.length === 0) {
-            throw new RpcApplicationError("no_session", "No active or suspended session, and none was specified.");
-        }
-        if (live.length > 1) {
-            throw new RpcApplicationError("ambiguous_session", `Multiple sessions are live (${live.map((session) => session.alias).join(", ")}); specify a selector.`);
-        }
-        return live[0];
-    };
-    const assignAlias = (model) => {
-        const base = slugifyDeviceModel(model);
-        const existing = new Set(Array.from(sessions.values(), (session) => session.alias));
-        return dedupeAlias(base, existing);
-    };
-    const sendAck = (socket, session) => {
-        const ack = {
-            type: "session_ack",
-            session_id: session.sessionId,
-            status: "ok",
-            alias: session.alias,
-            resume_token: session.resumeToken.toString("base64url"),
-            keepalive_interval_s: options.keepaliveIntervalSeconds,
-            grace_s: options.graceSeconds,
-        };
-        socket.send(JSON.stringify(ack), (error) => {
-            if (error) {
-                // The 'close'/'error' listeners (attached below) own recovery; a failed send must never
-                // throw into the socket library's event loop turn (v1's exact defect).
-                closeSocket(socket, 1011, "send_failed");
-            }
-        });
-    };
-    const suspend = (sessionId) => {
-        const session = sessions.get(sessionId);
-        if (!session || session.state !== "active") {
-            return;
-        }
-        session.state = "suspended";
-        session.suspendedAt = clock.now();
-        session.socket = undefined;
-        session.missedPongs = 0;
-        session.graceTimer = timers.setTimeout(() => expire(sessionId), options.graceSeconds * 1000);
-        emit("session_suspended", session.sessionId, session.alias, {});
-    };
-    const expire = (sessionId) => {
-        const session = sessions.get(sessionId);
-        if (!session || session.state !== "suspended") {
-            return;
-        }
-        sessions.delete(sessionId);
-        emit("session_expired", session.sessionId, session.alias, {});
-    };
-    const attachSocketHandlers = (session) => {
-        const socket = session.socket;
-        socket.on("error", () => {
-            // Never let an unhandled 'error' crash the daemon (v1's fatal defect) — 'close' still fires
-            // after 'error' and drives the suspend transition.
-        });
-        socket.on("pong", () => {
-            session.missedPongs = 0;
-        });
-        socket.on("close", () => {
-            if (session.socket === socket) {
-                suspend(session.sessionId);
-            }
-        });
-    };
-    // Server-side keepalive (ARCHITECTURE.md §7): ping every `keepaliveIntervalSeconds`; two missed
-    // pongs in a row is treated as socket loss and suspends the session (never crashes the daemon).
-    const keepaliveInterval = timers.setInterval(() => {
-        for (const session of sessions.values()) {
-            if (session.state !== "active" || !session.socket) {
-                continue;
-            }
-            if (session.missedPongs >= 2) {
-                const staleSocket = session.socket;
-                session.socket = undefined;
-                suspend(session.sessionId);
-                staleSocket.terminate();
-                continue;
-            }
-            session.missedPongs += 1;
-            try {
-                session.socket.ping();
-            }
-            catch {
-                // A ping failure is surfaced via the socket's own 'error'/'close' handlers.
-            }
-        }
-    }, options.keepaliveIntervalSeconds * 1000);
-    const createLink = (ttlSeconds, addressOverride) => {
-        const { link, deepLinkPayload, endpoint } = pendingLinks.create(ttlSeconds ?? options.linkTtlSeconds, addressOverride);
-        return {
-            sessionId: link.sessionId,
-            deepLinkPayload,
-            endpoint,
-            expiresAt: Math.floor(link.expiresAt.getTime() / 1000),
-        };
-    };
-    const handleClaim = (socket, message) => {
-        const pending = pendingLinks.get(message.session_id);
-        if (!pending) {
-            if (sessions.has(message.session_id)) {
-                closeSocket(socket, 1008, "already_claimed");
-            }
-            else {
-                closeSocket(socket, 1008, "unknown_session");
-            }
-            return null;
-        }
-        const nowMs = clock.now().getTime();
-        if (pending.expiresAt.getTime() <= nowMs) {
-            pendingLinks.discard(pending.sessionId);
-            closeSocket(socket, 1008, "link_expired");
-            return null;
-        }
-        const candidateToken = decodeFixedLengthToken(message.token, pending.token.length);
-        if (!tokensMatch(candidateToken, pending.token)) {
-            // ARCHITECTURE.md §6: the token is invalidated "after 5 failed claim attempts" — the 5th
-            // failure itself invalidates the link (a correct token on a would-be 6th attempt must not
-            // still claim).
-            const attempts = pendingLinks.recordFailedAttempt(pending.sessionId);
-            if (attempts >= MAX_FAILED_CLAIM_ATTEMPTS) {
-                pendingLinks.discard(pending.sessionId);
-                closeSocket(socket, 1008, "claim_attempts_exceeded");
-            }
-            else {
-                closeSocket(socket, 1008, "invalid_token");
-            }
-            return null;
-        }
-        pendingLinks.consume(pending.sessionId);
-        const deviceFields = parseSessionClaimDeviceFields(message);
-        const device = deviceFields && deviceFields !== "invalid" ? deviceFields : {};
-        const alias = assignAlias(device.model);
-        const sessionId = pending.sessionId;
-        const session = {
-            sessionId,
-            alias,
-            state: "active",
-            device,
-            createdAt: pending.createdAt,
-            claimedAt: clock.now(),
-            resumeToken: randomBytes(RESUME_TOKEN_BYTES),
-            socket,
-            missedPongs: 0,
-            registry: createToolRegistry(() => {
-                emit("tools_changed", sessionId, alias, { toolCount: session.registry.count() });
-            }),
-        };
-        sessions.set(sessionId, session);
-        attachSocketHandlers(session);
-        sendAck(socket, session);
-        emit("session_claimed", sessionId, alias, { device });
-        return sessionId;
-    };
-    const handleResume = (socket, message) => {
-        const session = sessions.get(message.session_id);
-        if (!session) {
-            closeSocket(socket, 1008, "unknown_session");
-            return null;
-        }
-        const candidateToken = decodeFixedLengthToken(message.resume_token, session.resumeToken.length);
-        if (!tokensMatch(candidateToken, session.resumeToken)) {
-            closeSocket(socket, 1008, "invalid_resume_token");
-            return null;
-        }
-        // Resuming an ACTIVE session is a socket replacement (e.g. app reconnected before the old
-        // socket's close event was observed) rather than an error: adopt the new socket, drop the old.
-        if (session.state === "active" && session.socket && session.socket !== socket) {
-            const staleSocket = session.socket;
-            session.socket = undefined; // prevents the stale socket's 'close' handler from suspending us
-            closeSocket(staleSocket, 1000, "session_replaced");
-        }
-        if (session.graceTimer) {
-            timers.clearTimeout(session.graceTimer);
-            session.graceTimer = undefined;
-        }
-        session.resumeToken = randomBytes(RESUME_TOKEN_BYTES);
-        session.state = "active";
-        session.suspendedAt = undefined;
-        session.socket = socket;
-        session.missedPongs = 0;
-        attachSocketHandlers(session);
-        sendAck(socket, session);
-        emit("session_resumed", session.sessionId, session.alias, {});
-        return session.sessionId;
-    };
-    const handlePostClaimMessage = (sessionId, socket, message) => {
-        const session = sessions.get(sessionId);
-        if (!session) {
-            closeSocket(socket, 1008, "unknown_session");
-            return;
-        }
-        switch (message.type) {
-            case "tool_registry_snapshot": {
-                if (!isToolRegistrySnapshotMessage(message)) {
-                    closeSocket(socket, 1008, "invalid_registry");
-                    return;
-                }
-                session.registry.snapshot(message.tools);
-                return;
-            }
-            case "tool_registry_delta": {
-                if (!isToolRegistryDeltaMessage(message)) {
-                    closeSocket(socket, 1008, "invalid_registry");
-                    return;
-                }
-                if (message.operation === "upsert") {
-                    session.registry.upsert(message.tool);
-                }
-                else {
-                    session.registry.remove(message.name);
-                }
-                return;
-            }
-            case "tool_result": {
-                if (!isToolResultMessage(message)) {
-                    closeSocket(socket, 1008, "invalid_message");
-                    return;
-                }
-                options.onToolFrame?.(message);
-                return;
-            }
-            case "tool_error": {
-                if (!isToolErrorMessage(message)) {
-                    closeSocket(socket, 1008, "invalid_message");
-                    return;
-                }
-                options.onToolFrame?.(message);
-                return;
-            }
-            case "tool_call_progress": {
-                if (!isToolCallProgressMessage(message)) {
-                    closeSocket(socket, 1008, "invalid_message");
-                    return;
-                }
-                options.onToolFrame?.(message);
-                return;
-            }
-            case "event": {
-                if (!isEventMessage(message)) {
-                    closeSocket(socket, 1008, "invalid_message");
-                    return;
-                }
-                options.onAppEvent?.(sessionId, session.alias, message);
-                return;
-            }
-            default:
-                closeSocket(socket, 1008, "unknown_message_type");
-        }
-    };
-    const revoke = (selector) => {
-        // sessions.revoke is reachable from any state (ARCHITECTURE.md §6), including an unclaimed
-        // pending link — but only when explicitly selected by sessionId (pending links have no alias
-        // and are never eligible for the "exactly one live session" implicit-selector default).
-        if (selector !== undefined && !sessions.has(selector) && pendingLinks.get(selector)) {
-            pendingLinks.discard(selector);
-            emit("session_revoked", selector, undefined, {});
-            return;
-        }
-        const session = resolveSession(selector);
-        if (session.graceTimer) {
-            timers.clearTimeout(session.graceTimer);
-        }
-        if (session.socket) {
-            closeSocket(session.socket, 1000, "revoked");
-        }
-        sessions.delete(session.sessionId);
-        emit("session_revoked", session.sessionId, session.alias, {});
-    };
-    const disposeAll = (code, reason) => {
-        timers.clearInterval(keepaliveInterval);
-        pendingLinks.disposeAll();
-        for (const session of sessions.values()) {
-            if (session.graceTimer) {
-                timers.clearTimeout(session.graceTimer);
-            }
-            if (session.socket) {
-                closeSocket(session.socket, code, reason);
-            }
-        }
-        sessions.clear();
-    };
-    const resolveForTools = (selector) => {
-        const session = resolveSession(selector);
-        return { sessionId: session.sessionId, alias: session.alias, state: session.state, registry: session.registry };
-    };
-    const sendToApp = (sessionId, message) => {
-        const session = sessions.get(sessionId);
-        if (!session || session.state !== "active" || !session.socket) {
-            return false;
-        }
-        const socket = session.socket;
-        socket.send(JSON.stringify(message), (error) => {
-            if (error) {
-                // A failed send must never throw into the socket library's event loop turn (v1's exact
-                // defect); the resulting 'close'/'error' drives suspend, which rejects the pending call.
-                closeSocket(socket, 1011, "send_failed");
-            }
-        });
-        return true;
-    };
-    return {
-        createLink,
-        handleClaim,
-        handleResume,
-        handlePostClaimMessage,
-        list: () => Array.from(sessions.values(), toSummary),
-        pendingLinkCount: () => pendingLinks.claimableCount(),
-        describe: (selector) => toSummary(resolveSession(selector)),
-        revoke,
-        resolveForTools,
-        sendToolCall: sendToApp,
-        sendToolCancel: sendToApp,
-        disposeAll,
-    };
-};

package/dist/daemon/socket-probe.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"socket-probe.d.ts","sourceRoot":"","sources":["../../src/daemon/socket-probe.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAAI,YAAY,MAAM,KAAG,OAAO,CAAC,OAAO,CAcvE,CAAC"}