appduct 0.10.0 → 0.11.0

package/dist/commands/events.js

@@ -1,76 +0,0 @@
-/**
- * `appduct events` (ARCHITECTURE.md §10): subscribes to `events.subscribe` over a persistent
- * connection and streams notifications until interrupted (Ctrl-C) or the connection drops. This is
- * the one command whose output isn't a single rendered `CliResult` — each event is written as it
- * arrives (NDJSON under `--json`, a human line otherwise) — so it plugs into `executeHostedCommand`
- * with a live reporter that suppresses the default one-shot bootstrap render (`cli/runner.ts`).
- *
- * `--since <cursor>` (issue #6) switches to a one-shot mode: a single `events.since` pull instead
- * of a live subscription. It falls out of the same `EventsHostedResult` shape (each retained event
- * is written through `onEvent` exactly like a live one) so the CLI plumbing needs no forking — the
- * "hosted command" here just completes immediately instead of running until interrupted.
- */
-import { RPC_METHODS } from "@appduct/shared";
-import { openDaemonStream } from "../rpc/client.js";
-const NEVER_RESULT = { ok: true, data: undefined };
-const handleEventsSinceCommand = async (options, context) => {
-    const stream = await openDaemonStream({ stateDir: context.stateDir, spawn: context.spawn });
-    try {
-        const since = await stream.call(RPC_METHODS.eventsSince, {
-            selector: options.selector,
-            since: options.since,
-        });
-        for (const event of since.events) {
-            context.onEvent(event);
-        }
-        context.onCursor?.(since.cursor);
-    }
-    finally {
-        stream.close();
-    }
-    return { result: NEVER_RESULT, completion: Promise.resolve(), stop: () => { } };
-};
-export const handleEventsCommand = async (options, context) => {
-    if (options.since !== undefined) {
-        return handleEventsSinceCommand(options, context);
-    }
-    const stream = await openDaemonStream({ stateDir: context.stateDir, spawn: context.spawn });
-    try {
-        await stream.call(RPC_METHODS.eventsSubscribe, {
-            sessionSelector: options.selector,
-        });
-    }
-    catch (error) {
-        stream.close();
-        throw error;
-    }
-    let resolveCompletion;
-    const completion = new Promise((resolve) => {
-        resolveCompletion = resolve;
-    });
-    const unsubscribeNotifications = stream.onNotification((payload) => {
-        context.onEvent(payload);
-    });
-    let unsubscribeClose = () => { };
-    let stopped = false;
-    const stop = () => {
-        if (stopped) {
-            return;
-        }
-        stopped = true;
-        unsubscribeNotifications();
-        unsubscribeClose();
-        stream.close();
-        resolveCompletion();
-    };
-    // The daemon going away mid-stream (shutdown, crash) must end the command gracefully rather than
-    // hang forever waiting for a Ctrl-C that will never resolve anything.
-    unsubscribeClose = stream.onClose(stop);
-    return {
-        // Never rendered: the reporter passed to `executeHostedCommand` suppresses the bootstrap
-        // render for this command (see the doc comment above).
-        result: NEVER_RESULT,
-        completion,
-        stop,
-    };
-};

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

@@ -1 +0,0 @@
-{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/commands/init.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAKH,OAAO,KAAK,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAYzE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,+DAA+D;IAC/D,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,4FAA4F;IAC5F,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,sFAAsF;IACtF,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAyFF,eAAO,MAAM,iBAAiB,GAC5B,SAAS,kBAAkB,EAC3B,UAAS,kBAAuB,KAC/B,OAAO,CAAC,SAAS,CAAC,eAAe,CAAC,CAsKpC,CAAC"}

package/dist/commands/init.js

@@ -1,231 +0,0 @@
-/**
- * `appduct init` (issue #29): the one command that takes an app root from "package installed"
- * to "an agent can connect".
- *
- * It writes a *project-level* `.appduct/config.json` holding the deep-link scheme, and returns
- * the two things that are not discoverable from the filesystem: the MCP server entry to paste into
- * an agent's config, and the `import "@appduct/react-native/auto"` reminder the app needs.
- *
- * What it deliberately does **not** do:
- *
- * - It never generates or touches key material. The daemon auto-generates a host key at startup
- *   (`daemon/tls.ts`), so making `init` a key-generating step would re-introduce exactly the
- *   "run keygen, paste a pin" ceremony this command exists to remove. `appduct keygen` remains
- *   for explicit rotation/provisioning.
- * - It never writes daemon-side settings (`wssPort`, `keyPath`, `policy`, ...), and the project
- *   file is never *read* for them either (`scheme.ts`). A project config that could redirect
- *   `keyPath` would mean a file checked into a repo could move another developer's private key.
- * - It never starts, stops or contacts the daemon.
- *
- * Idempotency (issue #29's acceptance criterion): re-running with the same scheme is a no-op that
- * still prints the snippet, a *different* scheme is refused unless `--force`, and `--force` merges
- * into the existing JSON rather than truncating it, so a key a future version adds is not silently
- * dropped by an old binary.
- *
- * **`init` is not the resolver.** It considers exactly two *kinds* of source — `--scheme`, and
- * whatever {@link discoverStaticProjectScheme} finds on disk (`<cwd>/app.json`, then the native
- * Android/iOS probes from `native-scheme.ts`) — plus whatever this very file already records. It
- * deliberately does *not* consult `APPDUCT_SCHEME` or walk up for a parent
- * `.appduct/config.json`, because its job is to decide what to *write here*, and inheriting
- * either would bake an ambient value into a committed file: a shell variable that happened to be
- * exported, or a parent project's scheme silently copied into a sub-package. `scheme.ts`'s full
- * precedence chain is what *reads* the result. Discovery is shared with that chain's own final
- * step via {@link discoverStaticProjectScheme} specifically so the two can never disagree about
- * what "discovery" means. `InitCommandData.source` names every origin this command itself can
- * produce.
- */
-import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
-import { usageError } from "../errors.js";
-import { discoverStaticProjectScheme, globalConfigDirs, isValidScheme, PROJECT_CONFIG_DIR, PROJECT_CONFIG_FILENAME, PROJECT_CONFIG_RELATIVE_PATH, SCHEME_ENV_VAR, } from "../scheme.js";
-const readExistingConfig = async (path) => {
-    let text;
-    try {
-        text = await readFile(path, "utf8");
-    }
-    catch (error) {
-        const code = error.code;
-        if (code === "ENOENT") {
-            return undefined;
-        }
-        // `.appduct` is a regular file (ENOTDIR), or `config.json` is a directory (EISDIR). Both
-        // are things a person did to their own project, so they get a usage error naming the path —
-        // not a raw errno from `readFile` rendered as an internal failure.
-        if (code === "ENOTDIR") {
-            throw usageError(`Cannot write ${path}: a file already exists where the "${PROJECT_CONFIG_DIR}" directory ` +
-                "needs to go. Remove or rename it, then re-run `appduct init`.");
-        }
-        if (code === "EISDIR") {
-            throw usageError(`Cannot write ${path}: it is a directory, not a file. Remove it, then re-run \`appduct init\`.`);
-        }
-        throw error;
-    }
-    let raw;
-    try {
-        raw = JSON.parse(text);
-    }
-    catch (error) {
-        throw usageError(`Could not parse the existing ${path}: ${error.message}. Fix or delete it, then re-run \`appduct init\`.`);
-    }
-    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
-        throw usageError(`The existing ${path} is not a JSON object. Fix or delete it, then re-run \`appduct init\`.`);
-    }
-    return raw;
-};
-/**
- * The `scheme` already recorded in the project config.
- *
- * A hand-edited `"scheme": "myapp://"` must not be adopted and echoed back into `mcpServerEntry`
- * as though it were usable — every consumer of that entry would compose an unopenable link, and
- * `appduct link` would reject the very value `init` just blessed.
- *
- * But it is only fatal when the run would go on to *keep* that value: `replaceable` says a
- * `--scheme` or `--force` is about to overwrite it anyway, and refusing then would make the
- * error's own suggested remedy reproduce the error.
- */
-const readExistingScheme = (existing, path, replaceable) => {
-    const scheme = existing?.scheme;
-    if (scheme === undefined) {
-        return undefined;
-    }
-    if (typeof scheme !== "string" || !isValidScheme(scheme)) {
-        if (replaceable) {
-            return undefined;
-        }
-        throw usageError(`${path} records an invalid deep-link scheme ${JSON.stringify(scheme)}: a scheme must start ` +
-            'with a letter and contain only letters, digits, "+", "-" or "." (for example "myapp") — ' +
-            'do not include "://". Fix it, or re-run with `--scheme <scheme> --force` to replace it.');
-    }
-    return scheme;
-};
-export const handleInitCommand = async (options, context = {}) => {
-    const root = resolve(context.cwd ?? process.cwd());
-    const projectDir = join(root, PROJECT_CONFIG_DIR);
-    const configPath = join(projectDir, PROJECT_CONFIG_FILENAME);
-    // Run from `$HOME` (or from the parent of a `APPDUCT_STATE_DIR`), `<cwd>/.appduct` *is*
-    // the daemon's state directory. Writing there would drop a config beside `key.pem` and the
-    // audit log and then tell the user it is safe to commit. The same exclusion the walk-up uses
-    // decides this, so "which directory is global state" has exactly one answer in the codebase.
-    if (globalConfigDirs({ stateDirRoot: context.stateDir, homeDir: context.homeDir }).has(projectDir)) {
-        throw usageError(`Refusing to write ${configPath}: that is Appduct's own state directory (it holds the ` +
-            "daemon's private key and audit log), not a project config. Run `appduct init` from " +
-            "your app's root directory instead.");
-    }
-    if (options.scheme !== undefined && !isValidScheme(options.scheme)) {
-        throw usageError(`Invalid deep-link scheme ${JSON.stringify(options.scheme)} from --scheme: a scheme must ` +
-            'start with a letter and contain only letters, digits, "+", "-" or "." (for example ' +
-            '"myapp") — do not include "://".');
-    }
-    const existing = await readExistingConfig(configPath);
-    // A `--scheme` or a `--force` is about to overwrite whatever is recorded, so a garbage value
-    // there is not worth failing over — and failing would make this error's own remedy unusable.
-    const existingScheme = readExistingScheme(existing, configPath, options.force === true || options.scheme !== undefined);
-    // Same discovery `resolveScheme`'s own last step runs (app.json, then the native Android/iOS
-    // probes) — never APPDUCT_SCHEME, never a walk-up, per this file's doc comment. `discovered`
-    // throws on its own for a malformed value or two native probes disagreeing, exactly as it would
-    // for `resolveScheme`.
-    const discovered = await discoverStaticProjectScheme(root);
-    const discoveredScheme = discovered.scheme;
-    const discoveredSourceLabel = discovered.source === undefined
-        ? undefined
-        : discovered.source === "app-json"
-            ? "app.json"
-            : discovered.source;
-    /*
-     * Which scheme wins, and when that is an error, is the whole idempotency contract:
-     *
-     * - `--scheme` always wins, but replacing a *different* recorded scheme needs `--force`, since
-     *   that is a person asking for one thing while the file already says another.
-     * - A plain re-run keeps whatever is already recorded, even when discovery has since changed.
-     *   Erroring there would mean `appduct init` — documented as safe to re-run — starts failing
-     *   because somebody renamed a scheme in `app.json` or a native project file. The divergence is
-     *   reported as a `note` instead: visible, but not fatal.
-     * - `--force` on its own is the escape hatch that re-adopts discovery, replacing the recorded
-     *   scheme with whatever it currently finds.
-     * - With nothing recorded, discovery decides.
-     */
-    const [scheme, source, origin] = (() => {
-        if (options.scheme !== undefined) {
-            return [options.scheme, "--scheme", undefined];
-        }
-        if (options.force && discoveredScheme !== undefined) {
-            return [discoveredScheme, discoveredSourceLabel ?? "app.json", discovered.origin];
-        }
-        return existingScheme === undefined
-            ? [discoveredScheme, discoveredSourceLabel ?? "app.json", discovered.origin]
-            : [existingScheme, "already-recorded", undefined];
-    })();
-    if (scheme === undefined) {
-        throw usageError(`No deep-link scheme found for ${root}, and none was given. Looked in, in order:\n${discovered.tried
-            .map((location, index) => `  ${index + 1}. ${location}`)
-            .join("\n")}\nRun \`appduct init --scheme <scheme>\` with the scheme your app ` +
-            'registers for deep links (e.g. "myapp"), or declare it in one of the locations above.');
-    }
-    if (options.scheme !== undefined &&
-        existingScheme !== undefined &&
-        existingScheme !== options.scheme &&
-        !options.force) {
-        throw usageError(`${configPath} already records the scheme "${existingScheme}", but --scheme asked for ` +
-            `"${options.scheme}". Re-run with --force to replace it (every other key in the file is ` +
-            "preserved), or drop --scheme to keep what is recorded.");
-    }
-    // Only when the recorded scheme is the one being *kept by default* and discovery disagrees. An
-    // explicit `--scheme` (even one that matches what is recorded) is the user stating the answer,
-    // so there is nothing to bring to their attention; `--force` has already resolved it.
-    const note = options.scheme === undefined &&
-        scheme === existingScheme &&
-        discoveredScheme !== undefined &&
-        discoveredScheme !== scheme
-        ? `${discovered.origin} declares "${discoveredScheme}", but ${configPath} records ` +
-            `"${existingScheme}", which is what Appduct uses. Run \`appduct init --force\` to ` +
-            "adopt that value instead."
-        : undefined;
-    const alreadyCorrect = existingScheme === scheme;
-    if (!alreadyCorrect) {
-        // Merge rather than replace: `--force` changes the scheme, it does not reset the file.
-        const next = { ...(existing ?? {}), scheme };
-        await mkdir(dirname(configPath), { recursive: true, mode: 0o700 });
-        await writeFile(configPath, `${JSON.stringify(next, null, 2)}\n`, {
-            encoding: "utf8",
-            mode: 0o600,
-        });
-    }
-    // `mkdir`'s and `writeFile`'s `mode` only apply when they *create*, and both are subject to the
-    // process umask, so tighten explicitly — exactly as `ensureStateDir` does (ARCHITECTURE.md §3).
-    // Unconditional, not just on write: an idempotent re-run is the natural way to repair a
-    // directory that an earlier version, a umask, or a `git checkout` left world-readable. Safe in
-    // both branches — `alreadyCorrect` implies the file already exists.
-    await chmod(dirname(configPath), 0o700);
-    await chmod(configPath, 0o600);
-    // `origin` (set only in the two discovery branches above — see the tuple returned there) names
-    // the exact file/key `scheme` was read from, so the human-readable hint can say more than just
-    // "source: android-manifest".
-    return {
-        ok: true,
-        data: {
-            path: configPath,
-            scheme,
-            source,
-            ...(origin === undefined ? {} : { origin }),
-            created: existing === undefined,
-            changed: !alreadyCorrect,
-            ...(note === undefined ? {} : { note }),
-            mcpServerEntry: {
-                command: "appduct",
-                args: ["mcp", "--scheme", scheme],
-            },
-            nextSteps: [
-                'Add `import "@appduct/react-native/auto";` to your app entry (index.js / App.tsx) — it ' +
-                    "is what starts the in-app agent endpoint.",
-                `Add the Appduct MCP server entry to your agent's MCP config. "--scheme ${scheme}" keeps ` +
-                    `that entry self-contained; ${SCHEME_ENV_VAR} and this ${PROJECT_CONFIG_RELATIVE_PATH} ` +
-                    "work too.",
-                "With the app running, pair a device: `appduct link --open ios-sim` (or `--open android`).",
-                ...(origin === undefined ? [] : [`Scheme "${scheme}" was read from ${origin}.`]),
-                `This file is safe to commit — it holds only "scheme". Do not point --state-dir at this ` +
-                    "directory: the state dir holds the daemon's private key and audit log, which must " +
-                    "never be committed.",
-            ],
-        },
-    };
-};

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

@@ -1 +0,0 @@
-{"version":3,"file":"invoke.d.ts","sourceRoot":"","sources":["../../src/commands/invoke.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAE3E,OAAO,EAAoC,KAAK,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAElF,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAC9B,SAAS,oBAAoB,EAC7B,SAAS,oBAAoB;AAC7B;oFACoF;AACpF,SAAS,WAAW,KACnB,OAAO,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAmDtC,CAAC"}

package/dist/commands/invoke.js

@@ -1,54 +0,0 @@
-/**
- * `appduct invoke` (ARCHITECTURE.md §10): `tools.call` round trip. Failures propagate as-is
- * (`DaemonRpcError`, preserving `error.data.type` verbatim) — `errors.ts`'s `toCliError` is what
- * renders `error.type` as the app's wire error type end-to-end, not this module's job.
- */
-import { RPC_METHODS } from "@appduct/shared";
-import { deriveCallTransportTimeoutMs, MAX_CALL_TIMEOUT_MS } from "../daemon/calls.js";
-import { DaemonRpcError, openDaemonStream } from "../rpc/client.js";
-export const handleInvokeCommand = async (options, context, 
-/** Aborted on SIGINT (issue #9): closes the RPC connection that issued `tools.call`, which the
- * daemon treats as a mid-flight cancel and forwards to the app as `tool_cancel`. */
-signal) => {
-    const stream = await openDaemonStream({ stateDir: context.stateDir, spawn: context.spawn });
-    try {
-        const callPromise = stream.call(RPC_METHODS.toolsCall, {
-            selector: options.selector,
-            name: options.tool,
-            args: options.args,
-            timeoutMs: options.timeoutMs,
-        }, 
-        // Without this the socket watchdog defaults to 10 s and `--timeout 60000` still dies at 10 s
-        // with a generic transport error instead of the daemon's own `tool_timeout` (issue #25).
-        // With no `--timeout` the daemon falls back to the *tool's* declared deadline, which this
-        // command does not know without an extra `tools.list` round trip, so the watchdog is sized
-        // for the largest deadline the daemon could enforce. It is only ever a backstop for a daemon
-        // that answers nothing: one that dies or drops the socket rejects pending calls at once.
-        deriveCallTransportTimeoutMs(options.timeoutMs ?? MAX_CALL_TIMEOUT_MS));
-        if (!signal) {
-            const result = await callPromise;
-            return { ok: true, data: result.result };
-        }
-        const result = await new Promise((resolve, reject) => {
-            // Attached unconditionally, before the aborted check below — otherwise an already-aborted
-            // signal cancels without ever wiring a handler onto `callPromise`, and the rejection that
-            // follows from closing the stream below becomes an unhandled rejection.
-            callPromise.then(resolve, reject).finally(() => signal.removeEventListener("abort", cancel));
-            function cancel() {
-                reject(new DaemonRpcError(-32000, `Tool "${options.tool}" was cancelled.`, { type: "tool_cancelled" }));
-                // Dropping the connection is what actually cancels the call daemon-side (calls.ts's
-                // per-connection onClose hook) — this promise settling doesn't wait for that to finish.
-                stream.close();
-            }
-            if (signal.aborted) {
-                cancel();
-                return;
-            }
-            signal.addEventListener("abort", cancel, { once: true });
-        });
-        return { ok: true, data: result.result };
-    }
-    finally {
-        stream.close();
-    }
-};

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

@@ -1 +0,0 @@
-{"version":3,"file":"keygen.d.ts","sourceRoot":"","sources":["../../src/commands/keygen.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAO3E,MAAM,MAAM,oBAAoB,GAAG;IACjC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAC9B,SAAS,oBAAoB,EAC7B,SAAS,oBAAoB,KAC5B,OAAO,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAiCtC,CAAC"}

package/dist/commands/keygen.js

@@ -1,46 +0,0 @@
-/**
- * `appduct keygen` (ARCHITECTURE.md §10): fully non-interactive — v1's TTY-only prompt flow made
- * it unusable in CI/agent contexts, and neither ARCHITECTURE.md nor the v2 command table describe
- * any interactive mode, so it is not carried forward. Default output is `<state-dir>/key.pem`,
- * the same path the daemon's TLS listener loads by default (ARCHITECTURE.md §3).
- *
- * Since opt-in hardening, this is no longer the *only* way to get a key: the daemon now
- * auto-generates one at this same default path if it's missing at startup (dev-mode zero-config
- * bootstrap — `daemon/tls.ts`). `keygen` remains for explicit key management (rotation via
- * `--force`, a non-default `--out`, or CI/scripted provisioning ahead of a release build).
- * Key generation/file-hygiene itself is shared with the daemon's auto-generate path via
- * `key-material.ts` so both produce byte-identical material.
- */
-import { stat } from "node:fs/promises";
-import { getStateDirPaths } from "../daemon/state-dir.js";
-import { usageError } from "../errors.js";
-import { generatePrivateKeyPem, writePrivateKeyAtomically } from "../key-material.js";
-import { getSpkiPinFromPrivateKeyPem } from "../spki-pin.js";
-export const handleKeygenCommand = async (options, context) => {
-    const outputPath = options.out ?? getStateDirPaths(context.stateDir).keyPath;
-    if (!options.force) {
-        let exists = true;
-        try {
-            await stat(outputPath);
-        }
-        catch (error) {
-            if (error.code !== "ENOENT") {
-                throw error;
-            }
-            exists = false;
-        }
-        if (exists) {
-            throw usageError(`Refusing to overwrite an existing key at "${outputPath}" without --force.`);
-        }
-    }
-    const keyPem = generatePrivateKeyPem();
-    const pin = getSpkiPinFromPrivateKeyPem(keyPem);
-    await writePrivateKeyAtomically(outputPath, keyPem);
-    return {
-        ok: true,
-        data: {
-            path: outputPath,
-            pin,
-        },
-    };
-};

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

@@ -1 +0,0 @@
-{"version":3,"file":"link.d.ts","sourceRoot":"","sources":["../../src/commands/link.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzE,OAAO,EAA8B,KAAK,MAAM,EAAmB,MAAM,uBAAuB,CAAC;AAGjG,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAEhD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;+FAC2F;IAC3F,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,kFAAkF;IAClF,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,gFAAgF;IAChF,SAAS,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CAC/B,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAC5B,SAAS,kBAAkB,EAC3B,SAAS,kBAAkB,KAC1B,OAAO,CAAC,SAAS,CAAC,eAAe,CAAC,CA6CpC,CAAC"}

package/dist/commands/link.js

@@ -1,43 +0,0 @@
-/**
- * `appduct link` (ARCHITECTURE.md §10, §8): CLI-flag validation (`--open`/`--device`'s
- * CLI-specific error wording) around the shared `mintLink` core (`../link.ts`), which both this
- * command and `appduct/client`'s `link()` use so the deep-link shape can't drift between them.
- */
-import { isOpenTarget, OPEN_TARGETS } from "../cli/open-target.js";
-import { mintLink } from "../link.js";
-import { usageError } from "../errors.js";
-export const handleLinkCommand = async (options, context) => {
-    let openTarget;
-    if (options.open !== undefined) {
-        if (!isOpenTarget(options.open)) {
-            throw usageError(`"--open" must be one of ${OPEN_TARGETS.map((target) => `"${target}"`).join(", ")} (got "${options.open}").`);
-        }
-        openTarget = options.open;
-    }
-    if (options.device !== undefined && openTarget === undefined) {
-        throw usageError('"--device" only applies with "--open".');
-    }
-    // A bundle id is only ever consumed by the `devicectl` launch; accepting it silently elsewhere
-    // would let `--open ios-sim --bundle-id ...` look like it did something it did not.
-    if (options.bundleId !== undefined && openTarget !== "ios-device") {
-        throw usageError('"--bundle-id" only applies with "--open ios-device".');
-    }
-    if (options.relaunch !== undefined && openTarget !== "ios-device") {
-        throw usageError('"--relaunch" only applies with "--open ios-device".');
-    }
-    const result = await mintLink({
-        stateDir: context.stateDir,
-        spawn: context.spawn,
-        ttlSeconds: options.ttlSeconds,
-        scheme: options.scheme,
-        cwd: context.cwd,
-        target: openTarget,
-        device: options.device,
-        bundleId: options.bundleId,
-        relaunch: options.relaunch,
-        exec: context.exec,
-        env: context.env,
-        schemeEnv: context.schemeEnv,
-    });
-    return { ok: true, data: result };
-};

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

@@ -1 +0,0 @@
-{"version":3,"file":"ls.d.ts","sourceRoot":"","sources":["../../src/commands/ls.ts"],"names":[],"mappings":"AAAA,uEAAuE;AAIvE,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvE,OAAO,EAAc,KAAK,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAE5D,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF,eAAO,MAAM,eAAe,GAAU,SAAS,gBAAgB,KAAG,OAAO,CAAC,SAAS,CAAC,aAAa,CAAC,CAQjG,CAAC"}

package/dist/commands/ls.js

@@ -1,7 +0,0 @@
-/** `appduct ls` (ARCHITECTURE.md §10): `sessions.list` passthrough. */
-import { RPC_METHODS } from "@appduct/shared";
-import { callDaemon } from "../rpc/client.js";
-export const handleLsCommand = async (context) => {
-    const sessions = await callDaemon(RPC_METHODS.sessionsList, {}, { stateDir: context.stateDir, spawn: context.spawn });
-    return { ok: true, data: sessions };
-};

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

@@ -1 +0,0 @@
-{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../src/commands/mcp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAItD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAGxD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAmB,KAAK,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACzE,OAAO,KAAK,EAAE,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAGrE,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,uFAAuF;IACvF,YAAY,CAAC,EAAE,mBAAmB,CAAC;IACnC,wEAAwE;IACxE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kEAAkE;IAClE,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,kFAAkF;IAClF,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,kFAAkF;IAClF,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,gFAAgF;IAChF,SAAS,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IAC9B,4DAA4D;IAC5D,KAAK,CAAC,EAAE,QAAQ,CAAC;IACjB,MAAM,CAAC,EAAE,QAAQ,CAAC;IAClB;8BAC0B;IAC1B,MAAM,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;CAC5C,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,MAAM,EAAE,SAAS,CAAC,KAAK,CAAC,CAAC;IACzB,UAAU,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,wFAAwF;IACxF,MAAM,EAAE,eAAe,CAAC;CACzB,CAAC;AA2CF,eAAO,MAAM,gBAAgB,GAAU,SAAS,iBAAiB,KAAG,OAAO,CAAC,eAAe,CAqD1F,CAAC"}

package/dist/commands/mcp.js

@@ -1,98 +0,0 @@
-/**
- * `appduct mcp` (ARCHITECTURE.md §9, §10): starts a stdio MCP server that proxies the daemon RPC
- * (auto-spawn applies, same as every other command). This is a hosted command like `daemon run`/
- * `events` — it runs until the transport closes (client disconnected) or the process is
- * interrupted — and its stdout is reserved entirely for MCP protocol frames, so unlike every other
- * command it must never let `executeHostedCommand`'s default bootstrap render reach stdout (the
- * dispatcher wires an `"interactive"` reporter for exactly this reason, same as `events`).
- *
- * The deep-link scheme (`--scheme`, `APPDUCT_SCHEME`, project/state config, `app.json` — see
- * `scheme.ts`) is resolved once here at startup, and *not* finding one is not an error: see
- * {@link resolveSchemeForServer}.
- */
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { loadConfig } from "../daemon/config.js";
-import { getStateDirPaths } from "../daemon/state-dir.js";
-import { createMcpServer } from "../mcp/server.js";
-import { resolveScheme } from "../scheme.js";
-/**
- * Resolves the deep-link scheme for the server, *never* throwing.
- *
- * Unlike `appduct link`, an unresolved (or unresolvable) scheme must not stop `appduct mcp`
- * from starting: the server is still fully useful for proxying an app's tools to a session that was
- * paired some other way (a QR scan, `appduct link` in another terminal), and an MCP client that
- * cannot start its server gets a much worse failure than one whose `appduct_connect` call
- * returns a clear `invalid_request`. So a scheme problem here is downgraded to an extra entry in
- * the `tried` list, which `appduct_connect` renders if and when it is actually called.
- *
- * It is *also* reported on stderr at startup, because an explicitly wrong `--scheme myapp://` or
- * `APPDUCT_SCHEME` is a typo the operator wants to hear about immediately, not only if and when
- * some agent happens to call `appduct_connect`. Stderr, never stdout: stdout carries MCP
- * protocol frames exclusively, and MCP clients surface a server's stderr in their logs.
- */
-const resolveSchemeForServer = async (context, configScheme, paths) => {
-    try {
-        return await resolveScheme({
-            flagScheme: context.scheme,
-            env: context.schemeEnv,
-            cwd: context.cwd,
-            configScheme,
-            stateConfigPath: paths.configPath,
-            stateDirRoot: paths.root,
-        });
-    }
-    catch (error) {
-        const message = error.message;
-        (context.stderr ?? process.stderr).write(`appduct mcp: could not resolve a deep-link scheme: ${message}\n` +
-            "The server is starting anyway; appduct_connect will fail until this is fixed.\n");
-        return { tried: [`(scheme resolution failed: ${message})`] };
-    }
-};
-export const handleMcpCommand = async (context) => {
-    const paths = getStateDirPaths(context.stateDir);
-    const config = await loadConfig(paths);
-    const { scheme, tried } = await resolveSchemeForServer(context, config.scheme, paths);
-    const handle = await createMcpServer({
-        stateDir: context.stateDir,
-        spawn: context.spawn,
-        checkVersion: context.checkVersion,
-        scheme,
-        schemeTried: tried,
-        iosBundleId: context.iosBundleId ?? config.iosBundleId,
-        exec: context.exec,
-        env: context.env,
-    });
-    let resolveCompletion;
-    const completion = new Promise((resolve) => {
-        resolveCompletion = resolve;
-    });
-    let stopped = false;
-    const stop = () => {
-        if (stopped) {
-            return;
-        }
-        stopped = true;
-        void handle.close().finally(resolveCompletion);
-    };
-    // The client disconnecting (stdin closed) ends the transport, which must end the command
-    // gracefully rather than hang forever waiting for a Ctrl-C that will never come.
-    handle.server.onclose = stop;
-    handle.server.onerror = (error) => {
-        console.error("appduct mcp: transport error:", error);
-    };
-    try {
-        await handle.connect(new StdioServerTransport(context.stdin, context.stdout));
-    }
-    catch (error) {
-        await handle.close();
-        throw error;
-    }
-    return {
-        // Never rendered: the dispatcher suppresses the bootstrap render for this command (see the
-        // doc comment above) so stdout carries only MCP protocol frames.
-        result: { ok: true, data: undefined },
-        completion,
-        stop,
-        handle,
-    };
-};

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

@@ -1 +0,0 @@
-{"version":3,"file":"revoke.d.ts","sourceRoot":"","sources":["../../src/commands/revoke.ts"],"names":[],"mappings":"AAAA,yFAAyF;AAIzF,OAAO,KAAK,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3E,OAAO,EAAc,KAAK,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAE5D,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAC9B,SAAS,oBAAoB,EAC7B,SAAS,oBAAoB,KAC5B,OAAO,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAQtC,CAAC"}

package/dist/commands/revoke.js

@@ -1,7 +0,0 @@
-/** `appduct revoke` (ARCHITECTURE.md §10): revokes a session, optionally by selector. */
-import { RPC_METHODS } from "@appduct/shared";
-import { callDaemon } from "../rpc/client.js";
-export const handleRevokeCommand = async (options, context) => {
-    await callDaemon(RPC_METHODS.sessionsRevoke, { selector: options.selector }, { stateDir: context.stateDir, spawn: context.spawn });
-    return { ok: true, data: { ok: true } };
-};

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

@@ -1 +0,0 @@
-{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../src/commands/tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE1E,OAAO,EAA8B,KAAK,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAE5E,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC;AAiBF,eAAO,MAAM,kBAAkB,GAC7B,SAAS,mBAAmB,EAC5B,SAAS,mBAAmB,KAC3B,OAAO,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAyCrC,CAAC"}