appduct 0.9.0 → 0.11.0

package/dist/cli/runner.d.ts

@@ -1,6 +1,6 @@
 import type { CliResult } from "./result-types.js";
 import { type RenderOptions } from "../output.js";
-import { type Clock, type CliIoWriters } from "./types.js";
+import type { CliEnv } from "./types.js";
 /**
  * Long-lived command result shape shared by any CLI command that keeps a process alive
  * until completion/cancellation (e.g. a foreground daemon run). Not tied to any specific
@@ -22,14 +22,6 @@ export type HostedCommandReporter = {
     onEvent: (event: unknown) => void | Promise<void>;
     dispose: () => void;
 };
-export declare const executeCommand: (command: string, handler: () => CliResult<unknown> | Promise<CliResult<unknown>>, options: CliIoWriters & Pick<RenderOptions, "json" | "color"> & Partial<Pick<RenderOptions, "qr" | "full">> & {
-    clock: Clock;
-}) => Promise<number>;
-export declare const executeHostedCommand: (command: string, handler: () => Promise<HostedCommandResult>, options: CliIoWriters & {
-    json: boolean;
-    color: boolean;
-    clock: Clock;
-    reporter?: HostedCommandReporter;
-}) => Promise<number>;
+export declare const executeCommand: (command: string, handler: () => CliResult<unknown> | Promise<CliResult<unknown>>, env: CliEnv, render?: Partial<Pick<RenderOptions, "qr" | "full">>) => Promise<number>;
+export declare const executeHostedCommand: (command: string, handler: () => Promise<HostedCommandResult>, env: CliEnv, reporter?: HostedCommandReporter) => Promise<number>;
 export {};
-//# sourceMappingURL=runner.d.ts.map

package/dist/cli/types.d.ts

@@ -1,20 +1,23 @@
-import type { CommandMeta } from "./result-types.js";
+import type { GlobalFlags } from "./global-flags.js";
 export type Clock = {
     now: () => Date;
 };
 export declare const systemClock: Clock;
-export declare const createCommandMeta: (command: string, startedAt: Date, finishedAt: Date) => CommandMeta;
 export type RunCliOptions = {
     stdout?: Pick<typeof process.stdout, "write" | "isTTY">;
     stderr?: Pick<typeof process.stderr, "write">;
     clock?: Clock;
 };
 export type CliIoWriters = Required<Pick<RunCliOptions, "stdout" | "stderr">>;
-export type CliRenderContext = {
-    json: boolean;
-    color: boolean;
+/**
+ * Everything a route's handler needs about how to behave and where to write, in one object:
+ * the resolved global flags plus the writers and clock. A future global flag is added to
+ * `global-flags.ts`'s table and becomes available as `env.flags.<name>` everywhere this is
+ * threaded, with no other plumbing change.
+ */
+export type CliEnv = {
+    flags: GlobalFlags;
     stdout: CliIoWriters["stdout"];
     stderr: CliIoWriters["stderr"];
     clock: Clock;
 };
-//# sourceMappingURL=types.d.ts.map

package/dist/cli/version-guard.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The daemon version check as a route sees it (ARCHITECTURE.md §4 "Version drift"). Lives on the
+ * route side of the eager/route bundle boundary on purpose: the check throws
+ * `DaemonVersionMismatchError` instances, and they must be created by the same copy of
+ * `rpc/client.ts` that the route's `runner.ts` classifies them with (see `RouteContext`).
+ */
+import type { RouteContext } from "./router.js";
+import { type VersionCheckOptions } from "../rpc/client.js";
+/** The check's options for a route, with the drift notice going to `onWarning` (default: the
+ * context's `warn`). `mcp` passes its own writer: stderr is that server's only log channel. */
+export declare const versionCheckOptions: (context: RouteContext, onWarning?: (message: string) => void) => Promise<VersionCheckOptions>;
+/**
+ * Wraps a command handler so the daemon's version is verified once, before the command's first
+ * RPC. `autoSpawn: false`: with nothing listening there is no drift to find, and any daemon this
+ * process spawns afterwards is its own build. Applied to every command that talks to the daemon
+ * except `daemon run` (it *is* the daemon), `daemon status` (warns instead — see
+ * `commands/daemon/status.ts`) and `daemon stop` (already the remedy); `keygen`/`doctor` never
+ * open a daemon connection at all.
+ */
+export declare const guarded: (context: RouteContext) => <T>(handler: () => T | Promise<T>) => (() => Promise<T>);

package/dist/cli.d.ts

@@ -1,4 +1,3 @@
 export { createCli } from "./cli/create-cli.js";
 export { runCli } from "./cli/dispatch.js";
 export type { RunCliOptions } from "./cli/types.js";
-//# sourceMappingURL=cli.d.ts.map

package/dist/client/app-client.d.ts

@@ -123,4 +123,3 @@ export type AppClient<TTools = ToolMap> = {
 export declare const transportTimeoutForToolCall: (timeoutMs: number | undefined) => number;
 export declare const makeAppClient: <TTools = ToolMap>(stream: DaemonStream, sessionId: string) => AppClient<TTools>;
 export {};
-//# sourceMappingURL=app-client.d.ts.map

package/dist/client/bootstrap.d.ts

@@ -13,9 +13,10 @@ export type LinkOptions = {
     target?: OpenTarget;
     /** `--device` equivalent: an adb serial, a simulator udid, or a paired-device udid. */
     device?: string;
-    /** `--bundle-id` equivalent; only valid with `target: "ios-device"`, where it overrides
-     * `config.json`'s `iosBundleId`. */
-    bundleId?: string;
+    /** `--app-id` equivalent: the installed app's id, required (via this, or the project
+     * `.appduct/config.json`'s `appId.<platform>`) with `target: "android"` or `target:
+     * "ios-device"`. */
+    appId?: string;
     /** `--relaunch` equivalent; only valid with `target: "ios-device"`. */
     relaunch?: boolean;
     /** Highest-precedence scheme source, ahead of `APPDUCT_SCHEME`, a project
@@ -45,4 +46,3 @@ export type WaitForSessionOptions = {
 /** 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 declare const waitForSession: <TTools = ToolMap>(sessionId: string, options?: WaitForSessionOptions) => Promise<AppClient<TTools>>;
-//# sourceMappingURL=bootstrap.d.ts.map

package/dist/client/connect.d.ts

@@ -14,4 +14,3 @@ export type ConnectOptions = {
 };
 /** Opens a persistent connection to the daemon and resolves `options.selector` to one session. */
 export declare const connect: <TTools = ToolMap>(options?: ConnectOptions) => Promise<AppClient<TTools>>;
-//# sourceMappingURL=connect.d.ts.map

package/dist/client/errors.d.ts

@@ -23,4 +23,3 @@ export declare class AppductError extends Error {
 /** 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 declare const toAppductError: (error: unknown) => AppductError;
-//# sourceMappingURL=errors.d.ts.map

package/dist/client/index.d.ts

@@ -16,4 +16,3 @@ export { link, waitForSession, type LinkOptions, type LinkResult, type WaitForSe
 export { AppductError, type AppductErrorType } from "./errors.js";
 export type { AppClient, AppEvent, CallOptions, EventsOptions, EventsResult, ToolMap, WaitForEventOptions, } from "./app-client.js";
 export type { AgentEndpoint, ErrorType, ToolDescriptor } from "@appduct/shared";
-//# sourceMappingURL=index.d.ts.map