appduct 0.9.0

package/dist/daemon/calls.d.ts

@@ -0,0 +1,84 @@
+/**
+ * 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 { type ToolCallMessage, type ToolCallProgressMessage, type ToolCancelMessage, type ToolErrorMessage, type ToolResultMessage } from "@appduct/shared";
+import type { EventBus } from "./event-bus.js";
+import { type TimerFns } 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 declare const DEFAULT_CALL_TIMEOUT_MS = 10000;
+export declare const MIN_CALL_TIMEOUT_MS = 1000;
+export declare const MAX_CALL_TIMEOUT_MS = 600000;
+/** Identifies the session a call belongs to; carried through so progress/lifecycle events can be
+ * tagged with the alias without this module needing to look sessions back up. */
+export type CallSession = {
+    sessionId: string;
+    alias: string;
+};
+/** Sends a `tool_call` frame to the session's active socket; `false` if there is none (the caller
+ * must already have checked the session is ACTIVE, but the socket can still vanish mid-flight —
+ * the resulting rejection comes from the `session_suspended` transition below, not this return). */
+export type SendToolCall = (sessionId: string, message: ToolCallMessage) => boolean;
+/** Sends a `tool_cancel` frame to the session's active socket; `false` if there is none. */
+export type SendToolCancel = (sessionId: string, message: ToolCancelMessage) => boolean;
+export type CallsManagerOptions = {
+    send: SendToolCall;
+    sendCancel: SendToolCancel;
+    eventBus: EventBus;
+    timers?: TimerFns;
+};
+/** The call id (available synchronously, before the app has answered) plus the eventual result —
+ * lets the caller correlate its own `tools.call` with `tool_call_started`/`tool_call_progress`
+ * events carrying the same `callId` before it has anything to await. */
+export type StartedCall = {
+    callId: string;
+    result: Promise<unknown>;
+};
+export type CallsManager = {
+    /** Sends `tool_call` with a fresh `call_<random>` id, tracks it in a per-session pending map,
+     * resolves on the matching `tool_result`, rejects on `tool_error` (type preserved verbatim) or
+     * after `timeoutMs` (clamped to [{@link MIN_CALL_TIMEOUT_MS}, {@link MAX_CALL_TIMEOUT_MS}],
+     * default {@link DEFAULT_CALL_TIMEOUT_MS}). Returns the `callId` immediately (synchronously)
+     * alongside the result promise. */
+    call: (session: CallSession, name: string, args: Record<string, unknown>, timeoutMs?: number) => StartedCall;
+    /** Routes a validated `tool_result` frame; unknown correlation ids are dropped. */
+    handleToolResult: (message: ToolResultMessage) => void;
+    /** Routes a validated `tool_error` frame; unknown correlation ids are dropped. */
+    handleToolError: (message: ToolErrorMessage) => void;
+    /** Routes a validated `tool_call_progress` frame to the event bus; unknown correlation ids are
+     * dropped (no event is emitted). */
+    handleToolCallProgress: (message: ToolCallProgressMessage) => void;
+    /** Sends `tool_cancel` for a still-pending call. Does not itself resolve/reject the pending
+     * call — the app's eventual `tool_error` (`tool_cancelled`) or a late `tool_result` still wins
+     * normally, and the existing timeout remains a backstop if the app never replies. Returns
+     * `false` (a no-op, not an error) when `callId` is unknown/already finished, or when the
+     * session has no active socket to send the frame on right now. */
+    cancel: (sessionId: string, callId: string, reason: string) => boolean;
+    /** Rejects every pending call for a session immediately (suspend/revoke/expiry transitions). */
+    rejectSession: (sessionId: string, errorType: "session_suspended" | "unknown_session") => void;
+    /** Rejects and clears every pending call across every session (daemon shutdown). */
+    disposeAll: () => void;
+};
+/** 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 declare const CALL_TRANSPORT_TIMEOUT_SLACK_MS = 5000;
+/** The deadline the daemon will actually enforce for a `tools.call` with this `timeoutMs`. */
+export declare const clampTimeout: (timeoutMs: number | undefined) => number;
+/** 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 declare const deriveCallTransportTimeoutMs: (timeoutMs: number | undefined) => number;
+export declare const createCallsManager: (options: CallsManagerOptions) => CallsManager;
+//# sourceMappingURL=calls.d.ts.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,158 @@
+/**
+ * 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

@@ -0,0 +1,79 @@
+/**
+ * `config.json` loading and validation (ARCHITECTURE.md §3). All fields are optional; unknown
+ * top-level keys produce a warning (not an error); invalid values throw a clear error naming the
+ * offending key.
+ */
+import type { StateDirPaths } from "./state-dir.js";
+export type PolicyDecision = "allow" | "deny" | "prompt";
+/**
+ * `config.json`'s `policy` shape (ARCHITECTURE.md §12): `default` applies to tools whose
+ * descriptor has no `annotations.destructiveHint`; `destructive` applies when it is `true`;
+ * `tools["<alias>/<name>"]` overrides both for one specific tool on one specific session alias.
+ * `"prompt"` means "a human gate is required; if one cannot be guaranteed, deny" — today there are
+ * two such gates, both MCP-only (ARCHITECTURE.md §9/§12): an MCP client that declares the
+ * `elicitation` capability at `initialize` (issue #10, preferred whenever available) and an MCP
+ * client that honors `_meta["anthropic/requiresUserInteraction"]` (issue #14, Claude Code ≥
+ * v2.1.199, used only as a fallback for a client that doesn't declare elicitation). Every other
+ * caller (CLI, an MCP client on neither channel) gets `policy_denied` with reason
+ * `no_consent_channel`.
+ */
+export type AppductPolicyConfig = {
+    default: PolicyDecision;
+    destructive: PolicyDecision;
+    tools?: Record<string, PolicyDecision>;
+};
+export type AppductConfig = {
+    wssPort: number;
+    keyPath: string;
+    graceSeconds: number;
+    linkTtlSeconds: number;
+    keepaliveIntervalSeconds: number;
+    /** Max retained `app_event`/etc. events per session (ARCHITECTURE.md §5's `events.since`
+     * retention buffer); default 256. */
+    eventBufferSize: number;
+    /** Days of `audit/<YYYY-MM-DD>.jsonl` history to keep; files older than this are pruned on
+     * daemon start and once a day thereafter (ARCHITECTURE.md §3). Default 30. */
+    auditRetentionDays: number;
+    /** Size at which `daemon.log` is rotated to `daemon.log.1` before a daemon is spawned
+     * (ARCHITECTURE.md §3/§4). Default 10 MiB. */
+    daemonLogMaxBytes: number;
+    policy: AppductPolicyConfig;
+    /**
+     * When the CLI/MCP client finds the running daemon on a different Appduct version, restart it
+     * even if that drops live sessions (issue #30, ARCHITECTURE.md §4's "Version drift"). Default
+     * `false`: with sessions connected the command fails with both versions and the remedy instead.
+     * The `--daemon-restart` flag and `APPDUCT_DAEMON_RESTART=1` force the same thing per run.
+     */
+    restartDaemonOnVersionMismatch: boolean;
+    /** Operator override for advertised-address detection (daemon/address.ts); undefined = auto-detect. */
+    advertisedIp?: string;
+    /**
+     * Deep-link URI scheme used to compose `appduct link`'s output (ARCHITECTURE.md §10: "taken
+     * from the flag, else `config.json`, else the CLI errors with a clear message"). Not part of the
+     * `config.json` shape enumerated in ARCHITECTURE.md §3 (which only covers daemon-side settings),
+     * but `config.json` is explicitly "all fields optional" there and this is the natural home for a
+     * CLI-side setting an operator wants to set once rather than pass with every `link` invocation.
+     */
+    scheme?: string;
+    /**
+     * The app's iOS bundle id, used only by the experimental `--open ios-device` /
+     * `appduct_connect` `target: "ios-device"` delivery path (issue #31): `xcrun devicectl device
+     * process launch` needs to be told which installed app to hand the URL to, and there is nothing
+     * in the deep link itself that says so. Overridable per invocation by `--bundle-id` (CLI) or
+     * `bundleId` (MCP). CLI-side like `scheme`, not a daemon setting.
+     */
+    iosBundleId?: string;
+};
+export declare const DEFAULT_AUDIT_RETENTION_DAYS = 30;
+export declare const DEFAULT_DAEMON_LOG_MAX_BYTES: number;
+export declare class AppductConfigError extends Error {
+    readonly key: string;
+    constructor(key: string, message: string);
+}
+export declare const defaultConfig: (paths: StateDirPaths) => AppductConfig;
+export type ConfigWarnFn = (message: string) => void;
+/** Loads and validates `<state-dir>/config.json`, falling back to defaults when it is missing. */
+export declare const loadConfig: (paths: StateDirPaths, options?: {
+    warn?: ConfigWarnFn;
+}) => Promise<AppductConfig>;
+//# sourceMappingURL=config.d.ts.map

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

@@ -0,0 +1 @@
+{"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"}

package/dist/daemon/config.js

@@ -0,0 +1,170 @@
+/**
+ * `config.json` loading and validation (ARCHITECTURE.md §3). All fields are optional; unknown
+ * top-level keys produce a warning (not an error); invalid values throw a clear error naming the
+ * offending key.
+ */
+import { readFile } from "node:fs/promises";
+const KNOWN_TOP_LEVEL_KEYS = new Set([
+    "wssPort",
+    "keyPath",
+    "graceSeconds",
+    "linkTtlSeconds",
+    "keepaliveIntervalSeconds",
+    "eventBufferSize",
+    "auditRetentionDays",
+    "daemonLogMaxBytes",
+    "policy",
+    "advertisedIp",
+    "scheme",
+    "iosBundleId",
+    "restartDaemonOnVersionMismatch",
+]);
+const KNOWN_POLICY_KEYS = new Set(["default", "destructive", "tools"]);
+const POLICY_DECISIONS = new Set(["allow", "deny", "prompt"]);
+export const DEFAULT_AUDIT_RETENTION_DAYS = 30;
+export const DEFAULT_DAEMON_LOG_MAX_BYTES = 10 * 1024 * 1024;
+export class AppductConfigError extends Error {
+    key;
+    constructor(key, message) {
+        super(message);
+        this.key = key;
+        this.name = "AppductConfigError";
+    }
+}
+const configError = (key, message) => {
+    return new AppductConfigError(key, `Invalid Appduct config value for "${key}": ${message}`);
+};
+const requirePositiveInteger = (value, key) => {
+    if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+        throw configError(key, "must be a positive integer.");
+    }
+    return value;
+};
+const requireNonEmptyString = (value, key) => {
+    if (typeof value !== "string" || value.length === 0) {
+        throw configError(key, "must be a non-empty string.");
+    }
+    return value;
+};
+const requireBoolean = (value, key) => {
+    if (typeof value !== "boolean") {
+        throw configError(key, "must be a boolean.");
+    }
+    return value;
+};
+const requirePolicyDecision = (value, key) => {
+    if (typeof value !== "string" || !POLICY_DECISIONS.has(value)) {
+        throw configError(key, 'must be "allow", "deny", or "prompt".');
+    }
+    return value;
+};
+export const defaultConfig = (paths) => {
+    return {
+        wssPort: 8443,
+        keyPath: paths.keyPath,
+        graceSeconds: 600,
+        linkTtlSeconds: 300,
+        keepaliveIntervalSeconds: 15,
+        eventBufferSize: 256,
+        auditRetentionDays: DEFAULT_AUDIT_RETENTION_DAYS,
+        daemonLogMaxBytes: DEFAULT_DAEMON_LOG_MAX_BYTES,
+        restartDaemonOnVersionMismatch: false,
+        policy: {
+            default: "allow",
+            destructive: "allow",
+        },
+    };
+};
+/** Loads and validates `<state-dir>/config.json`, falling back to defaults when it is missing. */
+export const loadConfig = async (paths, options = {}) => {
+    const warn = options.warn ?? (() => { });
+    const config = defaultConfig(paths);
+    let raw;
+    try {
+        raw = JSON.parse(await readFile(paths.configPath, "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return config;
+        }
+        throw configError("config.json", `could not be read/parsed (${error.message}).`);
+    }
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        throw configError("config.json", "must be a JSON object.");
+    }
+    const parsed = raw;
+    for (const key of Object.keys(parsed)) {
+        if (!KNOWN_TOP_LEVEL_KEYS.has(key)) {
+            warn(`Unknown Appduct config key "${key}" is ignored.`);
+        }
+    }
+    if (parsed.wssPort !== undefined) {
+        config.wssPort = requirePositiveInteger(parsed.wssPort, "wssPort");
+    }
+    if (parsed.keyPath !== undefined) {
+        config.keyPath = requireNonEmptyString(parsed.keyPath, "keyPath");
+    }
+    if (parsed.advertisedIp !== undefined) {
+        config.advertisedIp = requireNonEmptyString(parsed.advertisedIp, "advertisedIp");
+    }
+    if (parsed.scheme !== undefined) {
+        config.scheme = requireNonEmptyString(parsed.scheme, "scheme");
+    }
+    // Only a non-empty string here, like `scheme` — deliberately *not* the bundle-id charset check.
+    // This loader runs on every daemon start, and a typo in a CLI-side convenience key must not stop
+    // the daemon from starting. The charset is enforced where the value is actually used (`mintLink`,
+    // `handleConnectTool`, and `deliverToOpenTarget` itself), which is where it can be reported as a
+    // usage error against the command that needed it.
+    if (parsed.iosBundleId !== undefined) {
+        config.iosBundleId = requireNonEmptyString(parsed.iosBundleId, "iosBundleId");
+    }
+    if (parsed.graceSeconds !== undefined) {
+        config.graceSeconds = requirePositiveInteger(parsed.graceSeconds, "graceSeconds");
+    }
+    if (parsed.linkTtlSeconds !== undefined) {
+        config.linkTtlSeconds = requirePositiveInteger(parsed.linkTtlSeconds, "linkTtlSeconds");
+    }
+    if (parsed.keepaliveIntervalSeconds !== undefined) {
+        config.keepaliveIntervalSeconds = requirePositiveInteger(parsed.keepaliveIntervalSeconds, "keepaliveIntervalSeconds");
+    }
+    if (parsed.eventBufferSize !== undefined) {
+        config.eventBufferSize = requirePositiveInteger(parsed.eventBufferSize, "eventBufferSize");
+    }
+    if (parsed.auditRetentionDays !== undefined) {
+        config.auditRetentionDays = requirePositiveInteger(parsed.auditRetentionDays, "auditRetentionDays");
+    }
+    if (parsed.daemonLogMaxBytes !== undefined) {
+        config.daemonLogMaxBytes = requirePositiveInteger(parsed.daemonLogMaxBytes, "daemonLogMaxBytes");
+    }
+    if (parsed.restartDaemonOnVersionMismatch !== undefined) {
+        config.restartDaemonOnVersionMismatch = requireBoolean(parsed.restartDaemonOnVersionMismatch, "restartDaemonOnVersionMismatch");
+    }
+    if (parsed.policy !== undefined) {
+        if (typeof parsed.policy !== "object" || parsed.policy === null || Array.isArray(parsed.policy)) {
+            throw configError("policy", "must be an object.");
+        }
+        const policy = parsed.policy;
+        for (const key of Object.keys(policy)) {
+            if (!KNOWN_POLICY_KEYS.has(key)) {
+                warn(`Unknown Appduct config key "policy.${key}" is ignored.`);
+            }
+        }
+        if (policy.default !== undefined) {
+            config.policy.default = requirePolicyDecision(policy.default, "policy.default");
+        }
+        if (policy.destructive !== undefined) {
+            config.policy.destructive = requirePolicyDecision(policy.destructive, "policy.destructive");
+        }
+        if (policy.tools !== undefined) {
+            if (typeof policy.tools !== "object" || policy.tools === null || Array.isArray(policy.tools)) {
+                throw configError("policy.tools", "must be an object.");
+            }
+            const tools = {};
+            for (const [toolKey, toolValue] of Object.entries(policy.tools)) {
+                tools[toolKey] = requirePolicyDecision(toolValue, `policy.tools["${toolKey}"]`);
+            }
+            config.policy.tools = tools;
+        }
+    }
+    return config;
+};

package/dist/daemon/daemon.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Daemon composition root (ARCHITECTURE.md §4): state dir → config → pidfile → TLS → session
+ * engine → listener → RPC server. Implements `daemon.status`/`daemon.shutdown`, the session RPC
+ * surface (`link.create`, `sessions.list`, `sessions.describe`, `sessions.revoke`), and the
+ * invocation surface (`tools.list`, `tools.call`, `events.subscribe`), and policy + audit
+ * (ARCHITECTURE.md §12): every `tools.call` attempt is evaluated against `config.policy` and
+ * recorded to the audit log inline in the `tools.call` handler below.
+ */
+import type { Clock } from "../cli/types.js";
+import { detectAdvertisedAddress } from "./address.js";
+import { type AppductConfig, type ConfigWarnFn } from "./config.js";
+import { type EventBus } from "./event-bus.js";
+import { type DaemonListener } from "./listener.js";
+import { type RpcServer } from "./rpc-server.js";
+import { type StateDirPaths } from "./state-dir.js";
+import { type TimerFns } from "./timers.js";
+/** How often audit retention runs after the startup prune (ARCHITECTURE.md §3: "once a day"). */
+export declare const AUDIT_PRUNE_INTERVAL_MS: number;
+export type DaemonOptions = {
+    stateDir: string;
+    clock?: Clock;
+    warn?: ConfigWarnFn;
+    /** Timer seam for the daily audit-retention sweep; defaults to real timers. */
+    timers?: TimerFns;
+    /** Advertised-address detector; defaults to `detectAdvertisedAddress` honoring
+     * `config.advertisedIp`. Overridable so tests can simulate a network change between two
+     * `link.create` calls without mocking `os.networkInterfaces()` process-wide. */
+    detectAddress?: () => ReturnType<typeof detectAdvertisedAddress>;
+};
+export type RunningDaemon = {
+    paths: StateDirPaths;
+    config: AppductConfig;
+    startedAt: Date;
+    server: RpcServer;
+    listener: DaemonListener;
+    eventBus: EventBus;
+    /** Resolves once graceful teardown (sockets closed, RPC/listener closed, pidfile released) completes. */
+    exited: Promise<void>;
+    /** Idempotent graceful teardown. */
+    shutdown: () => Promise<void>;
+};
+export declare const startDaemon: (options: DaemonOptions) => Promise<RunningDaemon>;
+//# sourceMappingURL=daemon.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"daemon.d.ts","sourceRoot":"","sources":["../../src/daemon/daemon.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AA8BH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAE7C,OAAO,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAGvD,OAAO,EAAc,KAAK,aAAa,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAChF,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/D,OAAO,EAAiB,KAAK,cAAc,EAAE,MAAM,eAAe,CAAC;AAGnE,OAAO,EAAuC,KAAK,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEtF,OAAO,EAAmD,KAAK,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACrG,OAAO,EAAqC,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAmB/E,iGAAiG;AACjG,eAAO,MAAM,uBAAuB,QAAsB,CAAC;AAE3D,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,IAAI,CAAC,EAAE,YAAY,CAAC;IACpB,+EAA+E;IAC/E,MAAM,CAAC,EAAE,QAAQ,CAAC;IAClB;;oFAEgF;IAChF,aAAa,CAAC,EAAE,MAAM,UAAU,CAAC,OAAO,uBAAuB,CAAC,CAAC;CAClE,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,EAAE,aAAa,CAAC;IACrB,MAAM,EAAE,aAAa,CAAC;IACtB,SAAS,EAAE,IAAI,CAAC;IAChB,MAAM,EAAE,SAAS,CAAC;IAClB,QAAQ,EAAE,cAAc,CAAC;IACzB,QAAQ,EAAE,QAAQ,CAAC;IACnB,yGAAyG;IACzG,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB,oCAAoC;IACpC,QAAQ,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/B,CAAC;AAkOF,eAAO,MAAM,WAAW,GAAU,SAAS,aAAa,KAAG,OAAO,CAAC,aAAa,CAkb/E,CAAC"}