appduct 0.9.0 → 0.11.0

package/dist/client/app-client.js

@@ -1,223 +0,0 @@
-/**
- * The typed client handle (issue #8) returned by {@link connect}/{@link waitForSession}: a thin
- * wrapper over the same `tools.list`/`tools.call`/`events.subscribe`/`events.since` RPC the CLI and
- * MCP server use (`rpc/client.ts`'s `DaemonStream`), bound to one resolved session. No new privilege
- * or transport — every call is attributed `caller: "client"` for the audit log (ARCHITECTURE.md
- * §12). {@link AppClient.waitForEvent}'s drain-then-live pattern mirrors the built-in
- * `appduct_wait_for_event` MCP tool (`mcp/events-tool.ts`) — see that module's doc comment for
- * why the notification listener has to be registered before the `events.since` drain call is sent.
- */
-import { clampToolTimeoutMs, MAX_TOOL_TIMEOUT_MS, RPC_METHODS, } from "@appduct/shared";
-import { AppductError, toAppductError } from "./errors.js";
-const DEFAULT_WAIT_FOR_EVENT_TIMEOUT_MS = 30_000;
-/** Extra headroom so the daemon's own `tool_timeout` always wins the race against this client's
- * transport timeout, even accounting for RPC round-trip and event-loop scheduling delay. Kept
- * local because it is a property of this transport, not of the protocol; the *bounds* it is added
- * to come from `@appduct/shared`, so this client and the daemon cannot disagree about the
- * deadline itself. */
-const CALL_TRANSPORT_TIMEOUT_SLACK_MS = 5_000;
-/**
- * Transport timeout for one `tools.call`. With an explicit `timeoutMs` the daemon-side deadline is
- * known exactly, so this is that clamped value plus slack.
- *
- * Without one the daemon defaults to the *tool's own* declared `timeoutMs` (issue #25), which this
- * client does not know at call time and would need an extra `tools.list` round trip (racy against
- * re-registration) to learn — so it falls back to the largest deadline the daemon could possibly
- * enforce. That is deliberately generous: this watchdog only exists for a daemon that accepts the
- * request and then never answers, since a daemon that dies or drops the socket already rejects
- * every pending call immediately (`rpc/client.ts`'s `close` handler). Sizing it off the 10 s
- * default instead would make this client the thing that fails a long tool call, reporting a
- * generic transport error in place of the daemon's real one.
- */
-export const transportTimeoutForToolCall = (timeoutMs) => {
-    const clamped = timeoutMs === undefined || !Number.isFinite(timeoutMs)
-        ? MAX_TOOL_TIMEOUT_MS
-        : clampToolTimeoutMs(timeoutMs);
-    return clamped + CALL_TRANSPORT_TIMEOUT_SLACK_MS;
-};
-export const makeAppClient = (stream, sessionId) => {
-    const client = {
-        sessionId,
-        tools: async () => {
-            try {
-                return await stream.call(RPC_METHODS.toolsList, { selector: sessionId });
-            }
-            catch (error) {
-                throw toAppductError(error);
-            }
-        },
-        call: async (name, args, options) => {
-            try {
-                const result = await stream.call(RPC_METHODS.toolsCall, {
-                    selector: sessionId,
-                    name,
-                    args,
-                    timeoutMs: options?.timeoutMs,
-                    caller: "client",
-                }, transportTimeoutForToolCall(options?.timeoutMs));
-                return result.result;
-            }
-            catch (error) {
-                throw toAppductError(error);
-            }
-        },
-        events: async (options = {}) => {
-            try {
-                const result = await stream.call(RPC_METHODS.eventsSince, {
-                    selector: sessionId,
-                    since: options.since,
-                    limit: options.limit,
-                    kinds: ["app_event"],
-                });
-                return {
-                    events: result.events
-                        .map((event) => appEventFrom(event, sessionId))
-                        .filter((event) => event !== undefined),
-                    cursor: result.cursor,
-                };
-            }
-            catch (error) {
-                throw toAppductError(error);
-            }
-        },
-        waitForEvent: (name, options = {}) => {
-            const timeoutMs = options.timeoutMs ?? DEFAULT_WAIT_FOR_EVENT_TIMEOUT_MS;
-            const toMatch = (event) => {
-                const appEvent = appEventFrom(event, sessionId);
-                if (!appEvent || appEvent.name !== name) {
-                    return undefined;
-                }
-                if (options.match && !options.match(appEvent.payload)) {
-                    return undefined;
-                }
-                return appEvent;
-            };
-            return new Promise((resolve, reject) => {
-                let settled = false;
-                const settle = (fn) => {
-                    if (settled) {
-                        return;
-                    }
-                    settled = true;
-                    clearTimeout(timer);
-                    unsubscribeClose();
-                    liveHandler = null;
-                    fn();
-                };
-                const timer = setTimeout(() => {
-                    settle(() => reject(new AppductError("timeout", `Timed out after ${timeoutMs}ms waiting for event "${name}".`)));
-                }, timeoutMs);
-                // Registered before `events.since` is even sent (not merely before it resolves): the
-                // daemon's response to that call and a `notify()` for a brand-new event can arrive in the
-                // same socket chunk, and a listener added only after awaiting that response could miss a
-                // notification from that same chunk. Buffers into `earlyEvents` until the drain below has
-                // merged its own backlog and switched this to `liveHandler`.
-                let liveHandler = null;
-                const earlyEvents = [];
-                const unsubscribeNotification = stream.onNotification((payload) => {
-                    const event = payload;
-                    if (liveHandler) {
-                        liveHandler(event);
-                    }
-                    else {
-                        earlyEvents.push(event);
-                    }
-                });
-                let unsubscribeClose = () => { };
-                const fail = (error) => {
-                    settle(() => reject(toAppductError(error)));
-                    unsubscribeNotification();
-                };
-                (async () => {
-                    await stream.call(RPC_METHODS.eventsSubscribe, { sessionSelector: sessionId, kinds: ["app_event"] });
-                    const sinceResult = await stream.call(RPC_METHODS.eventsSince, {
-                        selector: sessionId,
-                        since: options.since,
-                        kinds: ["app_event"],
-                    });
-                    // Merge the retained backlog with whatever arrived on the live channel while the two
-                    // calls above were in flight, deduped by `seq` — the same event can legitimately show up
-                    // in both (the daemon buffers before it fans out). Everything from here to `liveHandler =
-                    // …` below is synchronous — no `await` — so nothing can arrive on the socket and be missed
-                    // in the gap.
-                    const seenSeqs = new Set();
-                    const backlog = [];
-                    for (const event of [...sinceResult.events, ...earlyEvents]) {
-                        if (event.sessionId === sessionId && !seenSeqs.has(event.seq)) {
-                            seenSeqs.add(event.seq);
-                            backlog.push(event);
-                        }
-                    }
-                    backlog.sort((a, b) => a.seq - b.seq);
-                    for (const event of backlog) {
-                        try {
-                            const matched = toMatch(event);
-                            if (matched) {
-                                settle(() => resolve(matched));
-                                unsubscribeNotification();
-                                return;
-                            }
-                        }
-                        catch (error) {
-                            fail(error);
-                            return;
-                        }
-                    }
-                    // Nothing matched yet: resume live from the last event actually considered, or — if
-                    // nothing was retained/arrived at all — `events.since`'s own cursor, which already
-                    // reflects the session's true high-water mark even when the `kinds` filter matched
-                    // nothing.
-                    const highestConsideredSeq = backlog.length > 0 ? backlog[backlog.length - 1].seq : sinceResult.cursor;
-                    unsubscribeClose = stream.onClose(() => {
-                        settle(() => reject(new AppductError("connection_error", `The connection to the Appduct daemon closed while waiting for event "${name}".`)));
-                        unsubscribeNotification();
-                    });
-                    // From here on, every notification goes straight to this handler instead of
-                    // `earlyEvents` — assigned synchronously (no `await` since the backlog scan above), so
-                    // nothing is missed.
-                    liveHandler = (event) => {
-                        if (settled) {
-                            return;
-                        }
-                        if (event.sessionId === sessionId && event.seq <= highestConsideredSeq) {
-                            return;
-                        }
-                        try {
-                            const matched = toMatch(event);
-                            if (matched) {
-                                settle(() => resolve(matched));
-                                unsubscribeNotification();
-                            }
-                        }
-                        catch (error) {
-                            fail(error);
-                        }
-                    };
-                })().catch((error) => {
-                    fail(error);
-                });
-            });
-        },
-        close: () => {
-            stream.close();
-        },
-    };
-    return client;
-};
-const appEventFrom = (event, sessionId) => {
-    if (event.kind !== "app_event" || event.sessionId !== sessionId) {
-        return undefined;
-    }
-    const data = event.data;
-    if (typeof data.name !== "string") {
-        return undefined;
-    }
-    return {
-        name: data.name,
-        payload: data.payload,
-        ts: event.ts,
-        sessionId: event.sessionId,
-        alias: event.alias,
-        seq: event.seq,
-    };
-};

package/dist/client/bootstrap.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bootstrap.d.ts","sourceRoot":"","sources":["../../src/client/bootstrap.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAErE,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AAC3D,OAAO,EAAuD,KAAK,OAAO,EAAE,MAAM,kBAAkB,CAAC;AACrG,OAAO,EAAiB,KAAK,SAAS,EAAE,KAAK,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAK9E,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,uEAAuE;IACvE,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;6EACyE;IACzE,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,uFAAuF;IACvF,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;wCACoC;IACpC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,uEAAuE;IACvE,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;iGAC6F;IAC7F,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kEAAkE;IAClE,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;qFACiF;IACjF,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,gFAAgF;IAChF,SAAS,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,cAAc,CAAC;AAExC;2FAC2F;AAC3F,eAAO,MAAM,IAAI,GAAU,UAAS,WAAgB,KAAG,OAAO,CAAC,UAAU,CAoBxE,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,uEAAuE;IACvE,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,wBAAwB;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF;8EAC8E;AAC9E,eAAO,MAAM,cAAc,GAAU,MAAM,GAAG,OAAO,EACnD,WAAW,MAAM,EACjB,UAAS,qBAA0B,KAClC,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,CA0F3B,CAAC"}

package/dist/client/bootstrap.js

@@ -1,108 +0,0 @@
-/**
- * `link()`/`waitForSession()` (issue #8): the bootstrap half of the client, so a test's
- * `globalSetup` can pair a simulator/emulator without shelling out to `appduct link --open`.
- * `link()` delegates to the same `mintLink` core `commands/link.ts` uses (`../link.js`) so the
- * deep-link shape can't drift between the CLI and this package; `waitForSession()` mirrors
- * `mcp/connect-tool.ts`'s `handleWaitForSessionTool`.
- */
-import { RPC_METHODS } from "@appduct/shared";
-import {} from "../cli/open-target.js";
-import { resolveStateDir } from "../daemon/state-dir.js";
-import { mintLink } from "../link.js";
-import { openDaemonStream, DaemonRpcError } from "../rpc/client.js";
-import { makeAppClient } from "./app-client.js";
-import { AppductError, toAppductError } from "./errors.js";
-const DEFAULT_WAIT_FOR_SESSION_TIMEOUT_MS = 120_000;
-/** Mints a session link via `link.create` and composes the deep link. With `target` set, delivers
- * it directly to a booted emulator/simulator instead of leaving delivery to the caller. */
-export const link = async (options = {}) => {
-    try {
-        return await mintLink({
-            stateDir: resolveStateDir(options.stateDir),
-            spawn: options.spawn,
-            autoSpawn: options.autoSpawn,
-            ttlSeconds: options.ttlSeconds,
-            target: options.target,
-            device: options.device,
-            bundleId: options.bundleId,
-            relaunch: options.relaunch,
-            scheme: options.scheme,
-            cwd: options.cwd,
-            exec: options.exec,
-            env: options.env,
-            schemeEnv: options.schemeEnv,
-        });
-    }
-    catch (error) {
-        throw toAppductError(error);
-    }
-};
-/** Waits for `sessionId` (from {@link link}) to be claimed by a device, then returns a connected
- * {@link AppClient} for it — resolves immediately if it's already claimed. */
-export const waitForSession = async (sessionId, options = {}) => {
-    const stateDir = resolveStateDir(options.stateDir);
-    const timeoutMs = options.timeoutMs ?? DEFAULT_WAIT_FOR_SESSION_TIMEOUT_MS;
-    let stream;
-    try {
-        stream = await openDaemonStream({ stateDir, spawn: options.spawn, autoSpawn: options.autoSpawn });
-    }
-    catch (error) {
-        throw toAppductError(error);
-    }
-    try {
-        // The session may already be claimed by the time this runs — resolve immediately rather than
-        // waiting for an event that already happened.
-        try {
-            await stream.call(RPC_METHODS.sessionsDescribe, { selector: sessionId });
-            return makeAppClient(stream, sessionId);
-        }
-        catch (error) {
-            if (!(error instanceof DaemonRpcError) || error.data?.type !== "unknown_session") {
-                throw error;
-            }
-        }
-        await new Promise((resolve, reject) => {
-            let settled = false;
-            const settle = (fn) => {
-                if (settled) {
-                    return;
-                }
-                settled = true;
-                clearTimeout(timer);
-                unsubscribeNotification();
-                unsubscribeClose();
-                fn();
-            };
-            const timer = setTimeout(() => {
-                settle(() => reject(new AppductError("timeout", `Timed out after ${timeoutMs}ms waiting for session "${sessionId}" to be claimed.`)));
-            }, timeoutMs);
-            const unsubscribeClose = stream.onClose(() => {
-                settle(() => reject(new AppductError("connection_error", `The connection to the Appduct daemon closed while waiting for session "${sessionId}" to be claimed.`)));
-            });
-            // Registered *before* `events.subscribe` is sent (not after awaiting it) — a
-            // `session_claimed` notification that arrives in the same TCP chunk as the subscribe
-            // response is dispatched synchronously within that chunk's processing, before an `await`
-            // continuation below would get a chance to run; registering the listener first means it's
-            // always in place in time to see it.
-            const unsubscribeNotification = stream.onNotification((payload) => {
-                if (settled) {
-                    return;
-                }
-                const event = payload;
-                if (event.kind === "session_claimed" && event.sessionId === sessionId) {
-                    settle(resolve);
-                }
-            });
-            stream
-                .call(RPC_METHODS.eventsSubscribe, { sessionSelector: sessionId, kinds: ["session_claimed"] })
-                .catch((error) => {
-                settle(() => reject(toAppductError(error)));
-            });
-        });
-        return makeAppClient(stream, sessionId);
-    }
-    catch (error) {
-        stream.close();
-        throw toAppductError(error);
-    }
-};

package/dist/client/connect.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"connect.d.ts","sourceRoot":"","sources":["../../src/client/connect.ts"],"names":[],"mappings":"AAUA,OAAO,EAAuC,KAAK,OAAO,EAAE,MAAM,kBAAkB,CAAC;AACrF,OAAO,EAAiB,KAAK,SAAS,EAAE,KAAK,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAG9E,MAAM,MAAM,cAAc,GAAG;IAC3B;mGAC+F;IAC/F,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,6FAA6F;IAC7F,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,+EAA+E;IAC/E,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,uEAAuE;IACvE,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF,kGAAkG;AAClG,eAAO,MAAM,OAAO,GAAU,MAAM,GAAG,OAAO,EAC5C,UAAS,cAAmB,KAC3B,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,CA0B3B,CAAC"}

package/dist/client/connect.js

@@ -1,38 +0,0 @@
-/**
- * `connect()` (issue #8): the entry point for a test runner that wants to drive an already-claimed
- * session without shelling out to the CLI. Auto-spawns the daemon (same seam `rpc/client.ts` gives
- * the CLI/MCP server) and resolves `selector` up front via `sessions.describe` so a bad/ambiguous
- * selector fails fast with a typed {@link AppductError} rather than surfacing on the first
- * `call()`.
- */
-import { RPC_METHODS } from "@appduct/shared";
-import { resolveStateDir } from "../daemon/state-dir.js";
-import { openDaemonStream } from "../rpc/client.js";
-import { makeAppClient } from "./app-client.js";
-import { toAppductError } from "./errors.js";
-/** Opens a persistent connection to the daemon and resolves `options.selector` to one session. */
-export const connect = async (options = {}) => {
-    const stateDir = resolveStateDir(options.stateDir);
-    let stream;
-    try {
-        stream = await openDaemonStream({
-            stateDir,
-            spawn: options.spawn,
-            autoSpawn: options.autoSpawn,
-            requestTimeoutMs: options.requestTimeoutMs,
-        });
-    }
-    catch (error) {
-        throw toAppductError(error);
-    }
-    try {
-        const detail = await stream.call(RPC_METHODS.sessionsDescribe, {
-            selector: options.selector,
-        });
-        return makeAppClient(stream, detail.sessionId);
-    }
-    catch (error) {
-        stream.close();
-        throw toAppductError(error);
-    }
-};

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

@@ -1 +0,0 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/client/errors.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAKjD;;;;;uEAKuE;AACvE,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,kBAAkB,GAAG,SAAS,GAAG,cAAc,CAAC;AAE3F,qBAAa,YAAa,SAAQ,KAAK;IACrC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B,mEAAmE;IACnE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;gBAEX,IAAI,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,MAAM;CAOtF;AAED;kFACkF;AAClF,eAAO,MAAM,cAAc,GAAI,OAAO,OAAO,KAAG,YAiC/C,CAAC"}

package/dist/client/errors.js

@@ -1,40 +0,0 @@
-import { isAppductCliError } from "../errors.js";
-import { DaemonRpcError, isDaemonUnreachableError } from "../rpc/client.js";
-export class AppductError extends Error {
-    type;
-    details;
-    /** The JSON-RPC error code, when this wraps a `DaemonRpcError`. */
-    code;
-    constructor(type, message, details, code) {
-        super(message);
-        this.name = "AppductError";
-        this.type = type;
-        this.details = details;
-        this.code = code;
-    }
-}
-/** Converts any error thrown by the RPC layer into a {@link AppductError}, preserving the wire
- * `data.type` verbatim when present. Idempotent on an already-converted error. */
-export const toAppductError = (error) => {
-    if (error instanceof AppductError) {
-        return error;
-    }
-    const withCause = (result) => {
-        result.cause = error;
-        return result;
-    };
-    if (error instanceof DaemonRpcError) {
-        const type = error.data?.type ?? "client_error";
-        return withCause(new AppductError(type, error.message, error.data?.details, error.code));
-    }
-    if (isDaemonUnreachableError(error)) {
-        return withCause(new AppductError("connection_error", error instanceof Error ? error.message : "The Appduct daemon is unreachable."));
-    }
-    if (isAppductCliError(error)) {
-        return withCause(new AppductError("client_error", error.message, error.details));
-    }
-    if (error instanceof Error) {
-        return withCause(new AppductError("client_error", error.message));
-    }
-    return new AppductError("client_error", "An unexpected error occurred.", error);
-};

package/dist/client/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/client/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAC5D,OAAO,EAAE,IAAI,EAAE,cAAc,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,KAAK,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AACrH,OAAO,EAAE,YAAY,EAAE,KAAK,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAClE,YAAY,EACV,SAAS,EACT,QAAQ,EACR,WAAW,EACX,aAAa,EACb,YAAY,EACZ,OAAO,EACP,mBAAmB,GACpB,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,aAAa,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/commands/daemon.d.ts

@@ -1,22 +0,0 @@
-import type { CliResult, DaemonRunCommandData, DaemonStartCommandData, DaemonStatusCommandData, DaemonStopCommandData } from "../cli/result-types.js";
-import type { Clock } from "../cli/types.js";
-import { type SpawnFn } from "../rpc/client.js";
-export type DaemonCommandContext = {
-    stateDir: string;
-    clock?: Clock;
-    spawn?: SpawnFn;
-    warn?: (message: string) => void;
-    /** Test seam: the version `daemon status` compares the daemon against; defaults to this
-     * package's own version. */
-    clientVersion?: string;
-};
-export type DaemonRunHostedResult = {
-    result: CliResult<DaemonRunCommandData>;
-    completion: Promise<void>;
-    stop: () => void;
-};
-export declare const handleDaemonRunCommand: (context: DaemonCommandContext) => Promise<DaemonRunHostedResult>;
-export declare const handleDaemonStartCommand: (context: DaemonCommandContext) => Promise<CliResult<DaemonStartCommandData>>;
-export declare const handleDaemonStopCommand: (context: DaemonCommandContext) => Promise<CliResult<DaemonStopCommandData>>;
-export declare const handleDaemonStatusCommand: (context: DaemonCommandContext) => Promise<CliResult<DaemonStatusCommandData>>;
-//# sourceMappingURL=daemon.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"daemon.d.ts","sourceRoot":"","sources":["../../src/commands/daemon.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,SAAS,EACT,oBAAoB,EACpB,sBAAsB,EACtB,uBAAuB,EACvB,qBAAqB,EACtB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAM7C,OAAO,EAAuD,KAAK,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAErG,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC;gCAC4B;IAC5B,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,MAAM,EAAE,SAAS,CAAC,oBAAoB,CAAC,CAAC;IACxC,UAAU,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,IAAI,EAAE,MAAM,IAAI,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,sBAAsB,GACjC,SAAS,oBAAoB,KAC5B,OAAO,CAAC,qBAAqB,CAiC/B,CAAC;AAEF,eAAO,MAAM,wBAAwB,GACnC,SAAS,oBAAoB,KAC5B,OAAO,CAAC,SAAS,CAAC,sBAAsB,CAAC,CAiB3C,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAClC,SAAS,oBAAoB,KAC5B,OAAO,CAAC,SAAS,CAAC,qBAAqB,CAAC,CAyB1C,CAAC;AAQF,eAAO,MAAM,yBAAyB,GACpC,SAAS,oBAAoB,KAC5B,OAAO,CAAC,SAAS,CAAC,uBAAuB,CAAC,CA2D5C,CAAC"}

package/dist/commands/daemon.js

@@ -1,128 +0,0 @@
-import { RPC_METHODS } from "@appduct/shared";
-import { startDaemon } from "../daemon/daemon.js";
-import { DaemonAlreadyRunningError, readPidFromFile } from "../daemon/pidfile.js";
-import { getStateDirPaths } from "../daemon/state-dir.js";
-import { connectionError } from "../errors.js";
-import { getPackageVersion } from "../package-version.js";
-import { callDaemon, isDaemonUnreachableError, isSameVersion } from "../rpc/client.js";
-export const handleDaemonRunCommand = async (context) => {
-    let daemon;
-    try {
-        daemon = await startDaemon({
-            stateDir: context.stateDir,
-            clock: context.clock,
-            warn: context.warn,
-        });
-    }
-    catch (error) {
-        if (error instanceof DaemonAlreadyRunningError) {
-            throw connectionError(error.message, { pid: error.pid });
-        }
-        throw error;
-    }
-    return {
-        result: {
-            ok: true,
-            data: {
-                daemon: {
-                    pid: process.pid,
-                    state_dir: daemon.paths.root,
-                    socket_path: daemon.paths.socketPath,
-                },
-            },
-        },
-        completion: daemon.exited,
-        stop: () => {
-            void daemon.shutdown();
-        },
-    };
-};
-export const handleDaemonStartCommand = async (context) => {
-    const status = await callDaemon(RPC_METHODS.daemonStatus, {}, { stateDir: context.stateDir, autoSpawn: true, spawn: context.spawn });
-    return {
-        ok: true,
-        data: {
-            daemon: {
-                pid: status.pid,
-                wss_port: status.wssPort,
-                started_at: status.startedAt,
-            },
-        },
-    };
-};
-export const handleDaemonStopCommand = async (context) => {
-    try {
-        await callDaemon(RPC_METHODS.daemonShutdown, {}, { stateDir: context.stateDir, autoSpawn: false });
-        return { ok: true, data: { daemon: { ok: true, method: "rpc" } } };
-    }
-    catch (error) {
-        if (!isDaemonUnreachableError(error)) {
-            throw error;
-        }
-        const paths = getStateDirPaths(context.stateDir);
-        const pid = await readPidFromFile(paths.pidFilePath);
-        if (pid === undefined) {
-            throw connectionError("No Appduct daemon is running.");
-        }
-        process.kill(pid, "SIGTERM");
-        return { ok: true, data: { daemon: { ok: true, method: "sigterm" } } };
-    }
-};
-/** Drops the entries whose value is `undefined`, so spreading the result adds only keys that
- * carry an actual answer. */
-const definedOnly = (fields) => {
-    return Object.fromEntries(Object.entries(fields).filter(([, value]) => value !== undefined));
-};
-export const handleDaemonStatusCommand = async (context) => {
-    const status = await callDaemon(RPC_METHODS.daemonStatus, {}, { stateDir: context.stateDir, autoSpawn: true, spawn: context.spawn });
-    // The wire type declares the retention fields required, as it must for any daemon built from
-    // this tree — but the daemon on the other end of the socket may predate them, and a running
-    // daemon outlives the CLI upgrade that would replace it. Reading them through a partial view
-    // keeps that possibility in the types instead of in a comment, and leaves each one `undefined`
-    // rather than `0` when it was never reported.
-    const retention = status.audit;
-    const clientVersion = context.clientVersion ?? getPackageVersion();
-    // Guarded the same way the version check guards it (`rpc/client.ts`): a `daemon.status` without
-    // `sessions` would otherwise throw from the middle of the command that exists to diagnose a
-    // daemon — the one command that must keep working against a daemon it does not fully understand.
-    const sessionCount = Array.isArray(status.sessions) ? status.sessions.length : 0;
-    const pendingLinkCount = typeof status.pendingLinks === "number" ? status.pendingLinks : 0;
-    // Names the same cost the restart path names (`rpc/client.ts`), so the diagnosis an operator
-    // reads here and the error they hit on the next command tell one consistent story: an unclaimed
-    // link is destroyed by a restart just as surely as a session is.
-    const atStake = `${sessionCount} session(s) and ${pendingLinkCount} unclaimed link(s)`;
-    const warning = isSameVersion(status.version, clientVersion)
-        ? undefined
-        : `Version drift: this daemon is ${status.version} but the CLI is ${clientVersion}. ` +
-            `Newer RPC methods will fail against it — run "appduct daemon stop" (this drops ${atStake}) ` +
-            `and the next command will start a matching daemon, or pass "--daemon-restart" to any command to replace it in place.`;
-    return {
-        ok: true,
-        data: {
-            warning,
-            daemon: {
-                version: status.version,
-                pid: status.pid,
-                started_at: status.startedAt,
-                wss_port: status.wssPort,
-                pinned_keys: status.pinnedKeys,
-                session_count: sessionCount,
-            },
-            policy: status.policy,
-            audit: {
-                path: status.audit.path,
-                failed_writes: status.audit.failedWrites,
-                // Spread so an unreported field is a *missing key*, not a key holding `undefined`. The two
-                // serialize identically, but only the first is honestly shaped: a caller can ask whether
-                // the daemon answered, and `--json` consumers see the same absence in-process as on the
-                // wire.
-                ...definedOnly({
-                    failed_prunes: retention.failedPrunes,
-                    retention_days: retention.retentionDays,
-                    files: retention.files,
-                    bytes: retention.bytes,
-                }),
-            },
-        },
-    };
-};

package/dist/commands/doctor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../src/commands/doctor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAE3E,OAAO,EAAmB,KAAK,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAG5E,MAAM,MAAM,oBAAoB,GAAG;IACjC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,CAAC,EAAE,YAAY,CAAC;CACrB,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAC9B,SAAS,oBAAoB,EAC7B,UAAS,oBAAyB,KACjC,OAAO,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAyCtC,CAAC"}

package/dist/commands/doctor.js

@@ -1,42 +0,0 @@
-/**
- * `appduct doctor <artifact>` (docs/tasks/08-appduct-doctor.md): the release-gate replacement
- * for the runtime `debuggable` check removed elsewhere in opt-in hardening — see
- * `artifact-inspect.ts`'s doc comment for the detection strategy and why it never collapses a
- * missing-tool or unreadable-artifact case into "absent".
- *
- * This handler owns only the CLI-facing concerns: option validation (mutually exclusive
- * `--assert-present`/`--assert-absent`) and turning a failed assertion into a distinct
- * {@link assertionError} exit, separate from `inspectionError`'s "couldn't tell" exit. All artifact
- * inspection itself lives in `artifact-inspect.ts`, unit-testable without going through the CLI.
- */
-import { inspectArtifact } from "../artifact-inspect.js";
-import { assertionError, usageError } from "../errors.js";
-export const handleDoctorCommand = async (options, context = {}) => {
-    if (!options.artifactPath) {
-        throw usageError("Usage: appduct doctor <path-to-artifact> [--assert-present | --assert-absent]");
-    }
-    if (options.assertPresent && options.assertAbsent) {
-        throw usageError("--assert-present and --assert-absent are mutually exclusive.");
-    }
-    const inspection = await inspectArtifact(options.artifactPath, { exec: context.exec });
-    const data = {
-        artifact: options.artifactPath,
-        platform: inspection.platform,
-        format: inspection.format,
-        present: inspection.present,
-        signals: inspection.signals,
-    };
-    if (options.assertPresent && !inspection.present) {
-        throw assertionError(`Expected Appduct to be present in "${options.artifactPath}", but no inclusion signal was found.`, data);
-    }
-    if (options.assertAbsent && inspection.present) {
-        throw assertionError(`Expected Appduct to be absent from "${options.artifactPath}", but found: ${inspection.signals.join(", ")}.`, data);
-    }
-    if (options.assertPresent || options.assertAbsent) {
-        data.assertion = {
-            expected: options.assertPresent ? "present" : "absent",
-            holds: true,
-        };
-    }
-    return { ok: true, data };
-};

package/dist/commands/events.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../src/commands/events.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAe,KAAK,iBAAiB,EAAsD,MAAM,iBAAiB,CAAC;AAE1H,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAoB,KAAK,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAElE,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;0EACsE;IACtE,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAC;IAC5C;;sGAEkG;IAClG,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CACrC,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,SAAS,CAAC,KAAK,CAAC,CAAC;IACzB,UAAU,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,IAAI,EAAE,MAAM,IAAI,CAAC;CAClB,CAAC;AA4BF,eAAO,MAAM,mBAAmB,GAC9B,SAAS,oBAAoB,EAC7B,SAAS,oBAAoB,KAC5B,OAAO,CAAC,kBAAkB,CAkD5B,CAAC"}