appduct 0.10.0 → 0.11.1

package/dist/commands/tools.js

@@ -1,52 +0,0 @@
-/**
- * `appduct tools` (ARCHITECTURE.md §10): `tools [selector] [--full]` lists tools for a session;
- * `tools [selector] <name>` shows one tool's full schema/annotations.
- *
- * The command table gives both forms a leading optional `[selector]`, which makes a single
- * positional argument inherently ambiguous (is it the selector, or the tool name in `tools <name>`
- * with the selector omitted?). This resolves it the same way a human reading the table would:
- * first try the arg as a tool name in the implicit-selector session's registry; if no such tool
- * exists there (or the implicit selector doesn't resolve, e.g. `ambiguous_session`), fall back to
- * treating it as a selector and list that session's tools instead.
- */
-import { RPC_METHODS } from "@appduct/shared";
-import { usageError } from "../errors.js";
-import { callDaemon, DaemonRpcError } from "../rpc/client.js";
-const listTools = (selector, context) => {
-    return callDaemon(RPC_METHODS.toolsList, { selector }, { stateDir: context.stateDir, spawn: context.spawn });
-};
-const findTool = (tools, name) => {
-    return tools.find((tool) => tool.name === name);
-};
-export const handleToolsCommand = async (options, context) => {
-    if (options.selector !== undefined && options.name !== undefined) {
-        const tools = await listTools(options.selector, context);
-        const tool = findTool(tools, options.name);
-        if (!tool) {
-            throw usageError(`Tool "${options.name}" is not registered on session "${options.selector}".`, { available: tools.map((entry) => entry.name) });
-        }
-        return { ok: true, data: tool };
-    }
-    if (options.selector !== undefined) {
-        // A single positional arg: try it as the implicit session's tool name first.
-        let implicitTools;
-        try {
-            implicitTools = await listTools(undefined, context);
-        }
-        catch (error) {
-            if (!(error instanceof DaemonRpcError)) {
-                throw error;
-            }
-        }
-        if (implicitTools) {
-            const tool = findTool(implicitTools, options.selector);
-            if (tool) {
-                return { ok: true, data: tool };
-            }
-        }
-        // Not a tool name on the implicit session (or there is no implicit session): treat the arg as
-        // a selector and list that session's tools instead.
-        return { ok: true, data: await listTools(options.selector, context) };
-    }
-    return { ok: true, data: await listTools(undefined, context) };
-};

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

@@ -1 +0,0 @@
-{"version":3,"file":"address.d.ts","sourceRoot":"","sources":["../../src/daemon/address.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,EAIL,KAAK,aAAa,EACnB,MAAM,iBAAiB,CAAC;AAEzB,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,aAAa,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,qFAAqF;AACrF,eAAO,MAAM,4BAA4B,GAAI,SAAS,MAAM,KAAG,OAE9D,CAAC;AAEF,0EAA0E;AAC1E,eAAO,MAAM,kBAAkB,GAAI,SAAS,MAAM,KAAG,OAWpD,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,SAAS,MAAM,KAAG,OAEvD,CAAC;AAEF,MAAM,MAAM,8BAA8B,GAAG;IAC3C,yFAAyF;IACzF,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,GAClC,UAAS,8BAAmC,KAC3C,iBA+CF,CAAC"}

package/dist/daemon/address.js

@@ -1,71 +0,0 @@
-/**
- * Advertised-address detection (ARCHITECTURE.md §2, §8 bootstrap endpoint). Prefers a
- * non-internal private IPv4 address, falling back to IPv6, then loopback. Fixes v1's
- * `detectHostIp`, which happily returned a Docker bridge address (`172.17.x.x`, inside the RFC
- * 1918 172.16/12 block v1 treated as "private") — that address is unreachable from a physical
- * device and made the printed deep link useless. Also excludes the IPv4 CGNAT range
- * (`100.64.0.0/10`), which is routable-looking but not device-reachable in the common case.
- */
-import { networkInterfaces } from "node:os";
-import { isLinkLocalIpv6Address, isPrivateIpv4Address, isUniqueLocalIpv6Address, } from "@appduct/shared";
-/** Docker's default bridge network (`docker0`), the exact defect v1 shipped with. */
-export const isDockerDefaultBridgeAddress = (address) => {
-    return address.startsWith("172.17.");
-};
-/** Carrier-grade NAT shared address space (RFC 6598): `100.64.0.0/10`. */
-export const isCgnatIpv4Address = (address) => {
-    const parts = address.split(".");
-    if (parts.length !== 4) {
-        return false;
-    }
-    const first = Number(parts[0]);
-    const second = Number(parts[1]);
-    return first === 100 && Number.isInteger(second) && second >= 64 && second <= 127;
-};
-export const isExcludedIpv4Address = (address) => {
-    return isDockerDefaultBridgeAddress(address) || isCgnatIpv4Address(address);
-};
-/**
- * Enumerates non-internal interface addresses and picks the best advertisable candidate: a
- * private (RFC 1918) IPv4 address first (excluding Docker/CGNAT), then any other non-internal
- * IPv4, then a unique-local (`fd00::/8`) IPv6 address, then any other non-internal, non-link-local
- * IPv6 address, finally falling back to loopback if nothing else is available.
- */
-export const detectAdvertisedAddress = (options = {}) => {
-    if (options.override) {
-        return {
-            family: options.override.includes(":") ? 6 : 4,
-            address: options.override,
-        };
-    }
-    const ipv4Candidates = [];
-    const ipv6Candidates = [];
-    for (const entries of Object.values(networkInterfaces())) {
-        for (const entry of entries ?? []) {
-            if (entry.internal) {
-                continue;
-            }
-            if (entry.family === "IPv4") {
-                if (isExcludedIpv4Address(entry.address)) {
-                    continue;
-                }
-                ipv4Candidates.push(entry.address);
-            }
-            else if (entry.family === "IPv6") {
-                if (isLinkLocalIpv6Address(entry.address)) {
-                    continue;
-                }
-                ipv6Candidates.push(entry.address);
-            }
-        }
-    }
-    const preferredIpv4 = ipv4Candidates.find((address) => isPrivateIpv4Address(address)) ?? ipv4Candidates[0];
-    if (preferredIpv4) {
-        return { family: 4, address: preferredIpv4 };
-    }
-    const preferredIpv6 = ipv6Candidates.find((address) => isUniqueLocalIpv6Address(address)) ?? ipv6Candidates[0];
-    if (preferredIpv6) {
-        return { family: 6, address: preferredIpv6 };
-    }
-    return { family: 4, address: "127.0.0.1" };
-};

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

@@ -1 +0,0 @@
-{"version":3,"file":"audit.d.ts","sourceRoot":"","sources":["../../src/daemon/audit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAMH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAG7C,MAAM,MAAM,YAAY,GAAG,IAAI,GAAG,OAAO,GAAG,QAAQ,GAAG,WAAW,CAAC;AACnE,MAAM,MAAM,WAAW,GAAG,KAAK,GAAG,KAAK,GAAG,QAAQ,CAAC;AAEnD,MAAM,MAAM,WAAW,GAAG;IACxB,gBAAgB;IAChB,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,yFAAyF;IACzF,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,YAAY,CAAC;IACtB,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,QAAQ,GAAG,oBAAoB,CAAC;IAC/C,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,WAAW,CAAC;IACpB;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,EAAE,QAAQ,GAAG,aAAa,CAAC;CACpC,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,kEAAkE;IAClE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,sCAAsC;IACtC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,qCAAqC;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,sGAAsG;IACtG,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB;uFACmF;IACnF,MAAM,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,KAAK,IAAI,CAAC;IACjD,2EAA2E;IAC3E,YAAY,EAAE,MAAM,MAAM,CAAC;IAC3B,2EAA2E;IAC3E,YAAY,EAAE,MAAM,MAAM,CAAC;IAC3B;;;;OAIG;IACH,KAAK,EAAE,MAAM,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACvC;sCACkC;IAClC,KAAK,EAAE,MAAM,OAAO,CAAC,UAAU,CAAC,CAAC;IACjC,uFAAuF;IACvF,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,KAAK,CAAC;IACd;+CAC2C;IAC3C,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,8FAA8F;IAC9F,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CAClC,CAAC;AAiBF,eAAO,MAAM,iBAAiB,GAAI,MAAM,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,MAEjE,CAAC;AAEF,eAAO,MAAM,UAAU,GAAI,MAAM,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,MAE1D,CAAC;AA8DF,eAAO,MAAM,iBAAiB,GAAI,SAAS,kBAAkB,KAAG,WA4K/D,CAAC"}

package/dist/daemon/audit.js

@@ -1,237 +0,0 @@
-/**
- * Append-only per-day audit log (ARCHITECTURE.md §3, §12): one JSONL line per `tools.call`
- * attempt (CLI and MCP alike), regardless of outcome. Raw args are **never** written — only a hex
- * sha256 digest of their canonical JSON, so an operator can correlate repeated/identical calls
- * without the log becoming a second copy of whatever secrets a tool's arguments carried.
- *
- * Writes are serialized through an internal promise queue so a slow disk never blocks the
- * `tools.call` response path: {@link AuditLogger.record} enqueues and returns immediately. A write
- * failure never throws back into the call path — it is logged to stderr and counted in
- * {@link AuditLogger.failedWrites} (surfaced via `daemon.status`, ARCHITECTURE.md §12 item 4).
- * {@link AuditLogger.flush} lets the daemon's shutdown teardown wait for the queue to drain.
- *
- * Retention (ARCHITECTURE.md §3): day files older than `config.auditRetentionDays` are deleted by
- * {@link AuditLogger.prune}, which the daemon runs at startup and once a day thereafter. Pruning
- * runs on the same queue as the writes, so it can never race an in-flight append, and its failures
- * are counted in {@link AuditLogger.failedPrunes} and warned rather than thrown — exactly like a
- * failed write.
- */
-import { createHash } from "node:crypto";
-import { chmod, mkdir, open, readdir, rm, stat } from "node:fs/promises";
-import { join } from "node:path";
-import { DEFAULT_AUDIT_RETENTION_DAYS } from "./config.js";
-/** Recursively sorts object keys so semantically-identical args always hash identically,
- * regardless of the property insertion order the caller happened to use. */
-const canonicalize = (value) => {
-    if (Array.isArray(value)) {
-        return value.map(canonicalize);
-    }
-    if (value !== null && typeof value === "object") {
-        const record = value;
-        return Object.fromEntries(Object.keys(record).sort().map((key) => [key, canonicalize(record[key])]));
-    }
-    return value;
-};
-export const canonicalArgsJson = (args) => {
-    return JSON.stringify(canonicalize(args));
-};
-export const argsSha256 = (args) => {
-    return createHash("sha256").update(canonicalArgsJson(args)).digest("hex");
-};
-/** The UTC day stamp a record written at `date` lands in. UTC (not local time) because that is
- * exactly what the file names have always been derived from — see {@link auditFilePathForDate}. */
-const dayStamp = (date) => {
-    return date.toISOString().slice(0, 10); // YYYY-MM-DD
-};
-/** Matches only the day files this module writes. Anything else in `audit/` — an operator's
- * notes, a partial copy, a subdirectory — is never a pruning candidate. */
-const AUDIT_DAY_FILE = /^(\d{4}-\d{2}-\d{2})\.jsonl$/u;
-/** The captured day stamp when `name` is one of our day files *and* the stamp is a real calendar
- * date (so a plausible-looking `2026-13-45.jsonl` is left alone rather than compared as a string). */
-const dayStampOfAuditFile = (name) => {
-    const match = AUDIT_DAY_FILE.exec(name);
-    if (!match) {
-        return undefined;
-    }
-    const stamp = match[1];
-    const parsed = new Date(`${stamp}T00:00:00.000Z`);
-    return Number.isNaN(parsed.getTime()) || dayStamp(parsed) !== stamp ? undefined : stamp;
-};
-const MS_PER_DAY = 24 * 60 * 60 * 1000;
-/**
- * The oldest day stamp retention keeps: `retentionDays` UTC days before the day containing `now`.
- * A day file is pruned when its stamp sorts strictly before this (ISO stamps are zero-padded, so
- * lexicographic order is chronological order), i.e. once it is *more* than `retentionDays` days
- * behind today. Today's file therefore can never be a candidate for any `retentionDays >= 1`.
- */
-const oldestRetainedStamp = (now, retentionDays) => {
-    const todayUtcMidnight = Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate());
-    const cutoff = new Date(todayUtcMidnight - retentionDays * MS_PER_DAY);
-    // `auditRetentionDays` is validated as a positive integer, not a *small* one: a window wide
-    // enough to run off the end of the `Date` range would make `toISOString` throw. That config
-    // means "keep everything", so answer with a stamp no real day file can sort before.
-    return Number.isNaN(cutoff.getTime()) ? "0000-00-00" : dayStamp(cutoff);
-};
-const auditFilePathForDate = (auditDir, date) => {
-    return join(auditDir, `${dayStamp(date)}.jsonl`);
-};
-const appendLine = async (filePath, line) => {
-    const handle = await open(filePath, "a", 0o600);
-    try {
-        await handle.appendFile(line);
-        // `open`'s mode only applies at creation and is further subject to umask; chmod explicitly so
-        // an existing (or umask-widened) file always ends up at the ARCHITECTURE.md §3 mode.
-        await chmod(filePath, 0o600);
-    }
-    finally {
-        await handle.close();
-    }
-};
-export const createAuditLogger = (options) => {
-    const clock = options.clock ?? { now: () => new Date() };
-    const warn = options.warn ??
-        ((message) => {
-            process.stderr.write(`${message}\n`);
-        });
-    const retentionDays = options.retentionDays ?? DEFAULT_AUDIT_RETENTION_DAYS;
-    let failedWrites = 0;
-    let failedPrunes = 0;
-    let queue = Promise.resolve();
-    /**
-     * Lists the day files in the audit directory. A *missing* directory is genuinely empty — the
-     * daemon creates it lazily — and reports `failed: false`. Any other error (EACCES on a
-     * tightened-up directory, ENOTDIR where a file now sits, EIO on a failing disk) is a refusal to
-     * answer, not an answer of zero, and is reported as such: callers must not turn "we could not
-     * look" into "there is nothing there".
-     */
-    const listDayFiles = async () => {
-        let entries;
-        try {
-            entries = await readdir(options.auditDir, { withFileTypes: true });
-        }
-        catch (error) {
-            if (error.code === "ENOENT") {
-                return { files: [], failed: false };
-            }
-            return { files: [], failed: true, error: error };
-        }
-        const files = [];
-        for (const entry of entries) {
-            if (!entry.isFile()) {
-                continue;
-            }
-            const stamp = dayStampOfAuditFile(entry.name);
-            if (stamp !== undefined) {
-                files.push({ name: entry.name, stamp });
-            }
-        }
-        return { files, failed: false };
-    };
-    const pruneOnce = async () => {
-        const today = dayStamp(clock.now());
-        const cutoff = oldestRetainedStamp(clock.now(), retentionDays);
-        let deleted = 0;
-        let failed = 0;
-        const listing = await listDayFiles();
-        if (listing.failed) {
-            // A sweep that could not read the directory did not prune anything and cannot know whether
-            // it needed to — counted and warned like any other prune failure, so a permanently
-            // unreadable `audit/` shows up in `daemon.status` instead of looking like a tidy one.
-            failedPrunes += 1;
-            warn(`appduct daemon: failed to read the audit directory to prune it: ${listing.error?.message}`);
-            return { deleted: 0, failed: 1 };
-        }
-        for (const file of listing.files) {
-            // Belt and braces: `cutoff` is already strictly behind `today` for every valid
-            // `retentionDays`, but today's file is the one file that must never disappear from under an
-            // open append, so it is excluded explicitly (issue #32).
-            if (file.stamp === today || file.stamp >= cutoff) {
-                continue;
-            }
-            try {
-                await rm(join(options.auditDir, file.name), { force: true });
-                deleted += 1;
-            }
-            catch (error) {
-                failed += 1;
-                failedPrunes += 1;
-                warn(`appduct daemon: failed to prune the audit record "${file.name}": ${error.message}`);
-            }
-        }
-        return { deleted, failed };
-    };
-    const record = (entry) => {
-        const now = clock.now();
-        const full = { ts: now.toISOString(), ...entry };
-        const line = `${JSON.stringify(full)}\n`;
-        const filePath = auditFilePathForDate(options.auditDir, now);
-        // Chained onto the existing queue tail so writes for the same (or different) day never race
-        // each other; a failure is swallowed here (never rejects the chain) so one bad write can't
-        // poison every audit record after it.
-        queue = queue.then(async () => {
-            try {
-                await mkdir(options.auditDir, { recursive: true });
-                await appendLine(filePath, line);
-            }
-            catch (error) {
-                failedWrites += 1;
-                warn(`appduct daemon: failed to write an audit record: ${error.message}`);
-            }
-        });
-    };
-    /**
-     * Chained onto the write queue for the same reason the writes are chained onto each other: a
-     * prune must never interleave with the append it would otherwise delete out from under. The
-     * returned promise resolves with this prune's own result while the queue itself stays a
-     * never-rejecting `Promise<void>` that `flush` can keep awaiting.
-     */
-    const prune = () => {
-        let settle;
-        const result = new Promise((resolve) => {
-            settle = resolve;
-        });
-        queue = queue.then(async () => {
-            try {
-                settle(await pruneOnce());
-            }
-            catch (error) {
-                // `pruneOnce` handles per-file failures itself; this only catches a failure of the listing
-                // step, which must still never reject the queue.
-                failedPrunes += 1;
-                warn(`appduct daemon: failed to prune the audit log: ${error.message}`);
-                settle({ deleted: 0, failed: 1 });
-            }
-        });
-        return result;
-    };
-    const stats = async () => {
-        const listing = await listDayFiles();
-        if (listing.failed) {
-            // Reported as "not measured", never as an empty directory: `daemon.status` would otherwise
-            // tell an operator that `audit/` holds nothing at exactly the moment it has become
-            // unreadable — the moment they most need to know otherwise.
-            return {};
-        }
-        let files = 0;
-        let bytes = 0;
-        for (const file of listing.files) {
-            try {
-                bytes += (await stat(join(options.auditDir, file.name))).size;
-                files += 1;
-            }
-            catch {
-                // Raced with a prune (ours or an operator's `rm`); an audit record that is gone by the
-                // time it is measured simply does not count toward the reported footprint.
-            }
-        }
-        return { files, bytes };
-    };
-    return {
-        record,
-        failedWrites: () => failedWrites,
-        failedPrunes: () => failedPrunes,
-        prune,
-        stats,
-        flush: () => queue,
-    };
-};

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

@@ -1 +0,0 @@
-{"version":3,"file":"calls.d.ts","sourceRoot":"","sources":["../../src/daemon/calls.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH,OAAO,EAKL,KAAK,eAAe,EACpB,KAAK,uBAAuB,EAC5B,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACvB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C,OAAO,EAAgB,KAAK,QAAQ,EAAoB,MAAM,aAAa,CAAC;AAE5E;kFACkF;AAClF,eAAO,MAAM,uBAAuB,QAA0B,CAAC;AAC/D,eAAO,MAAM,mBAAmB,OAAsB,CAAC;AACvD,eAAO,MAAM,mBAAmB,SAAsB,CAAC;AAEvD;iFACiF;AACjF,MAAM,MAAM,WAAW,GAAG;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF;;oGAEoG;AACpG,MAAM,MAAM,YAAY,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,KAAK,OAAO,CAAC;AAEpF,4FAA4F;AAC5F,MAAM,MAAM,cAAc,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,KAAK,OAAO,CAAC;AAExF,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,EAAE,YAAY,CAAC;IACnB,UAAU,EAAE,cAAc,CAAC;IAC3B,QAAQ,EAAE,QAAQ,CAAC;IACnB,MAAM,CAAC,EAAE,QAAQ,CAAC;CACnB,CAAC;AAEF;;wEAEwE;AACxE,MAAM,MAAM,WAAW,GAAG;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB;;;;uCAImC;IACnC,IAAI,EAAE,CAAC,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,SAAS,CAAC,EAAE,MAAM,KAAK,WAAW,CAAC;IAC7G,mFAAmF;IACnF,gBAAgB,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,IAAI,CAAC;IACvD,kFAAkF;IAClF,eAAe,EAAE,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACrD;wCACoC;IACpC,sBAAsB,EAAE,CAAC,OAAO,EAAE,uBAAuB,KAAK,IAAI,CAAC;IACnE;;;;sEAIkE;IAClE,MAAM,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC;IACvE,gGAAgG;IAChG,aAAa,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,mBAAmB,GAAG,iBAAiB,KAAK,IAAI,CAAC;IAC/F,oFAAoF;IACpF,UAAU,EAAE,MAAM,IAAI,CAAC;CACxB,CAAC;AAWF;;4EAE4E;AAC5E,eAAO,MAAM,+BAA+B,OAAQ,CAAC;AAErD,8FAA8F;AAC9F,eAAO,MAAM,YAAY,GAAI,WAAW,MAAM,GAAG,SAAS,KAAG,MAM5D,CAAC;AAEF;;kFAEkF;AAClF,eAAO,MAAM,4BAA4B,GAAI,WAAW,MAAM,GAAG,SAAS,KAAG,MAE5E,CAAC;AAYF,eAAO,MAAM,kBAAkB,GAAI,SAAS,mBAAmB,KAAG,YAoJjE,CAAC"}

package/dist/daemon/calls.js

@@ -1,158 +0,0 @@
-/**
- * Per-session tool-invocation manager (ARCHITECTURE.md §5 `tools.call`, §7 `tool_call` /
- * `tool_result` / `tool_error` / `tool_call_progress`). This is the v2 replacement for v1's
- * `pendingCalls` map: the correlation pattern (`call_<random>` ids, resolve on `tool_result`,
- * reject on `tool_error`) was sound and is kept. v1's defect was error flattening — the app's
- * `error.type` got re-wrapped twice and ended up buried two `details` levels deep. Here the type is
- * preserved verbatim: {@link RpcApplicationError.type} is set directly from the app's
- * `tool_error.error.type`, never a generic wrapper.
- *
- * This module knows nothing about sockets or the session state machine — `sessions.ts` (via the
- * composition root in `daemon.ts`) supplies a `send` function and routes incoming
- * `tool_result`/`tool_error`/`tool_call_progress` frames and suspend/revoke/expiry transitions back
- * in. That keeps a single seam (`call`) that a policy layer can wrap.
- */
-import { randomBytes } from "node:crypto";
-import { clampToolTimeoutMs, DEFAULT_TOOL_TIMEOUT_MS, MAX_TOOL_TIMEOUT_MS, MIN_TOOL_TIMEOUT_MS, } from "@appduct/shared";
-import { RpcApplicationError } from "./rpc-server.js";
-import { systemTimers } from "./timers.js";
-/** Re-exported under this module's historical names; the values live in `@appduct/shared` so the
- * RN SDK's app-side abort timer and this timer cannot drift apart (issue #25). */
-export const DEFAULT_CALL_TIMEOUT_MS = DEFAULT_TOOL_TIMEOUT_MS;
-export const MIN_CALL_TIMEOUT_MS = MIN_TOOL_TIMEOUT_MS;
-export const MAX_CALL_TIMEOUT_MS = MAX_TOOL_TIMEOUT_MS;
-const generateCallId = () => `call_${randomBytes(16).toString("base64url")}`;
-/** Extra headroom added on top of the daemon-side deadline so a caller's transport timeout never
- * beats the daemon's own `tool_timeout` — mirrored (deliberately duplicated) in
- * `client/app-client.ts`, which must not import daemon-internal modules. */
-export const CALL_TRANSPORT_TIMEOUT_SLACK_MS = 5_000;
-/** The deadline the daemon will actually enforce for a `tools.call` with this `timeoutMs`. */
-export const clampTimeout = (timeoutMs) => {
-    if (timeoutMs === undefined || !Number.isFinite(timeoutMs)) {
-        return DEFAULT_CALL_TIMEOUT_MS;
-    }
-    return clampToolTimeoutMs(timeoutMs);
-};
-/** Transport timeout a caller should use for a `tools.call` that will be given `timeoutMs`
- * daemon-side. Always clamps first: adding slack to an unclamped value could overflow Node's
- * 32-bit timer range (~24.8 days), which silently fires the timer immediately. */
-export const deriveCallTransportTimeoutMs = (timeoutMs) => {
-    return clampTimeout(timeoutMs) + CALL_TRANSPORT_TIMEOUT_SLACK_MS;
-};
-/** Event kinds that terminate every pending call for a session (ARCHITECTURE.md §6/§5: "On
- * suspend/revoke/expiry, every pending call rejects immediately with session_suspended (or
- * unknown_session on revoke)"). Expiry only ever follows suspend (pending calls are already gone
- * by then), but it is handled defensively with the same `unknown_session` type as revoke. */
-const TERMINATING_KIND_ERROR_TYPES = {
-    session_suspended: "session_suspended",
-    session_revoked: "unknown_session",
-    session_expired: "unknown_session",
-};
-export const createCallsManager = (options) => {
-    const timers = options.timers ?? systemTimers;
-    // sessionId -> callId -> PendingCall. Concurrent calls to the same session get independent
-    // entries here, keyed by their own call id, so out-of-order tool_result/tool_error frames still
-    // resolve the right caller.
-    const pendingBySession = new Map();
-    const takePending = (sessionId, callId) => {
-        const sessionMap = pendingBySession.get(sessionId);
-        const pending = sessionMap?.get(callId);
-        if (!sessionMap || !pending) {
-            return undefined;
-        }
-        sessionMap.delete(callId);
-        if (sessionMap.size === 0) {
-            pendingBySession.delete(sessionId);
-        }
-        timers.clearTimeout(pending.timer);
-        return pending;
-    };
-    const call = (session, name, args, timeoutMs) => {
-        const callId = generateCallId();
-        const result = new Promise((resolve, reject) => {
-            const effectiveTimeoutMs = clampTimeout(timeoutMs);
-            const timer = timers.setTimeout(() => {
-                const pending = takePending(session.sessionId, callId);
-                pending?.reject(new RpcApplicationError("tool_timeout", `Tool call "${name}" timed out after ${effectiveTimeoutMs}ms.`));
-            }, effectiveTimeoutMs);
-            let sessionMap = pendingBySession.get(session.sessionId);
-            if (!sessionMap) {
-                sessionMap = new Map();
-                pendingBySession.set(session.sessionId, sessionMap);
-            }
-            sessionMap.set(callId, { alias: session.alias, resolve, reject, timer });
-            const message = {
-                type: "tool_call",
-                session_id: session.sessionId,
-                id: callId,
-                name,
-                args,
-            };
-            const sent = options.send(session.sessionId, message);
-            if (!sent) {
-                const pending = takePending(session.sessionId, callId);
-                pending?.reject(new RpcApplicationError("session_not_active", "Session has no active socket."));
-            }
-        });
-        return { callId, result };
-    };
-    const handleToolResult = (message) => {
-        const pending = takePending(message.session_id, message.id);
-        pending?.resolve(message.result);
-    };
-    const handleToolError = (message) => {
-        const pending = takePending(message.session_id, message.id);
-        // Verbatim: `error.type` comes straight from the app's frame, never re-wrapped (v1's defect).
-        pending?.reject(new RpcApplicationError(message.error.type, message.error.message, -32000, message.error.details));
-    };
-    const handleToolCallProgress = (message) => {
-        const sessionMap = pendingBySession.get(message.session_id);
-        const pending = sessionMap?.get(message.id);
-        if (!pending) {
-            // Unknown correlation id: dropped (ARCHITECTURE.md task notes say "log at debug level"; a
-            // full logging seam doesn't exist yet in the daemon, so this is a silent, intentional no-op).
-            return;
-        }
-        options.eventBus.emit({
-            // Its own EventKind (ARCHITECTURE.md §5), distinct from `tool_call_started`/
-            // `tool_call_finished` — subscribers correlate all three by `callId` in `data` without
-            // needing to sniff which kind carries a `progress`/`message` field.
-            kind: "tool_call_progress",
-            sessionId: message.session_id,
-            alias: pending.alias,
-            data: { callId: message.id, progress: message.progress, message: message.message },
-        });
-    };
-    const cancel = (sessionId, callId, reason) => {
-        const pending = pendingBySession.get(sessionId)?.get(callId);
-        if (!pending) {
-            return false;
-        }
-        const message = { type: "tool_cancel", session_id: sessionId, id: callId, reason };
-        return options.sendCancel(sessionId, message);
-    };
-    const rejectSession = (sessionId, errorType) => {
-        const sessionMap = pendingBySession.get(sessionId);
-        if (!sessionMap) {
-            return;
-        }
-        pendingBySession.delete(sessionId);
-        for (const pending of sessionMap.values()) {
-            timers.clearTimeout(pending.timer);
-            pending.reject(new RpcApplicationError(errorType, `Session transitioned while the call was pending.`));
-        }
-    };
-    const unsubscribeFromEventBus = options.eventBus.subscribe((event) => {
-        const errorType = TERMINATING_KIND_ERROR_TYPES[event.kind];
-        if (errorType && event.sessionId) {
-            rejectSession(event.sessionId, errorType);
-        }
-    });
-    const disposeAll = () => {
-        unsubscribeFromEventBus();
-        for (const sessionId of Array.from(pendingBySession.keys())) {
-            rejectSession(sessionId, "unknown_session");
-        }
-    };
-    return { call, handleToolResult, handleToolError, handleToolCallProgress, cancel, rejectSession, disposeAll };
-};

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

@@ -1 +0,0 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/daemon/config.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAEpD,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAC;AAEzD;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,OAAO,EAAE,cAAc,CAAC;IACxB,WAAW,EAAE,cAAc,CAAC;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;CACxC,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,wBAAwB,EAAE,MAAM,CAAC;IACjC;yCACqC;IACrC,eAAe,EAAE,MAAM,CAAC;IACxB;kFAC8E;IAC9E,kBAAkB,EAAE,MAAM,CAAC;IAC3B;kDAC8C;IAC9C,iBAAiB,EAAE,MAAM,CAAC;IAC1B,MAAM,EAAE,mBAAmB,CAAC;IAC5B;;;;;OAKG;IACH,8BAA8B,EAAE,OAAO,CAAC;IACxC,uGAAuG;IACvG,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAsBF,eAAO,MAAM,4BAA4B,KAAK,CAAC;AAC/C,eAAO,MAAM,4BAA4B,QAAmB,CAAC;AAE7D,qBAAa,kBAAmB,SAAQ,KAAK;IAEzC,QAAQ,CAAC,GAAG,EAAE,MAAM;gBAAX,GAAG,EAAE,MAAM,EACpB,OAAO,EAAE,MAAM;CAKlB;AAsCD,eAAO,MAAM,aAAa,GAAI,OAAO,aAAa,KAAG,aAgBpD,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;AAErD,kGAAkG;AAClG,eAAO,MAAM,UAAU,GACrB,OAAO,aAAa,EACpB,UAAS;IAAE,IAAI,CAAC,EAAE,YAAY,CAAA;CAAO,KACpC,OAAO,CAAC,aAAa,CA4HvB,CAAC"}