mindwire 0.1.25 → 0.1.27

package/dist/client.d.ts

@@ -7,7 +7,7 @@ import { ExecutionApi } from "./execution.js";
 import { ComputerApi } from "./computer.js";
 import { type Target } from "./target/index.js";
 import type { EnsureEvent } from "./target/host.js";
-import type { AgentInfo, AuthMethod, AuthState, AuthStatus, Catalog, ChatSummary, CustomProvider, DeleteResult, DoctorReport, Health, MCPServer, MemoryDoc, MemoryScope, Message, ModelInfo, Notification, NotifyChannel, NotifyChannelInput, NotifyChannelTestResult, NotifyConfigInput, NotifyConfigStatus, NotifyRule, NotifyRuleInput, ProcessFrame, PromptTemplate, ResolveOptions, SetupStatus, HarnessSoftware, Stats, Subagent, TurnOptions } from "./types.js";
+import type { AgentInfo, AuthMethod, AuthState, AuthStatus, Catalog, ChatSummary, CustomProvider, DeleteResult, DoctorReport, Health, MCPServer, MemoryDoc, MemoryScope, Message, MessagePage, ModelInfo, Notification, NotifyChannel, NotifyChannelInput, NotifyChannelTestResult, NotifyConfigInput, NotifyConfigStatus, NotifyRule, NotifyRuleInput, ProcessFrame, PromptTemplate, ResolveOptions, SetupStatus, HarnessSoftware, Stats, Subagent, TurnOptions } from "./types.js";
 export interface MindwireOptions {
     /**
      * Default agent type for agent-scoped calls (e.g. `"claude-code"`). When omitted, the daemon
@@ -148,8 +148,15 @@ export declare class Mindwire {
     getConfig(scoped?: AgentScoped): Promise<Record<string, string>>;
     /** `PUT /config` — merge recognized (non-secret) setting keys. Unknown keys are ignored server-side. */
     setConfig(values: Record<string, string>, scoped?: AgentScoped): Promise<void>;
-    /** `GET /chats` — recorded chats (newest first), shared across agents. */
-    chats(): Promise<ChatSummary[]>;
+    /** Native project conversations and drafts, newest first, shared across agents.
+     * `cwd` matches an exact directory; `projectId` selects saved membership.
+     * `refresh` bypasses the daemon's short native metadata cache.
+     */
+    chats(options?: {
+        cwd?: string;
+        projectId?: string;
+        refresh?: boolean;
+    }): Promise<ChatSummary[]>;
     /**
      * `PUT /chats/{id}` — rename a chat. The user title wins over the agent's native auto-title in
      * every listing; an empty title clears the rename (reverting to the native/derived title).
@@ -181,6 +188,16 @@ export declare class Mindwire {
         limit?: number;
         before?: string;
     }): Promise<Message[]>;
+    /**
+     * Byte-budgeted history (default 1 MiB). Whole messages are retained, including
+     * up to two newest messages even when oversized. Older services return their
+     * bounded array, normalized here without a probe or duplicate request.
+     */
+    messagePage(chatId: string, opts?: AgentScoped & {
+        limit?: number;
+        before?: string;
+        maxBytes?: number;
+    }): Promise<MessagePage>;
     /** `GET /chats/{id}/run` — the latest run for a chat (reattach anchor), or `null` if none yet. */
     latestRun(chatId: string): Promise<Run | null>;
     /**
@@ -193,6 +210,8 @@ export declare class Mindwire {
      * clearer entry point for that. The returned {@link Run} is then the parent of the run tree.
      */
     turn(input: {
+        /** Keep this ID when retrying an unacknowledged turn. Requires turnRequestVersion >= 1. */
+        requestId?: string;
         chatId: string;
         message: string;
         cwd?: string;
@@ -214,6 +233,7 @@ export declare class Mindwire {
      * {@link ApiError} (409) if a turn is already running for the chat.
      */
     resolve(input: {
+        requestId?: string;
         chatId: string;
         message: string;
         cwd?: string;

package/dist/computer/connection-flow.d.ts

@@ -0,0 +1,22 @@
+import type { ComputerReconnectCode, ComputerDevice, ComputerInfo } from "../computer.js";
+export type ConnectionAction = "resume" | "reconnect" | "pair";
+export declare function connectionAction(value: string | undefined): ConnectionAction | undefined;
+/** Noninteractive runs never unexpectedly create a new invitation for a paired computer. */
+export declare function chooseConnectionAction(options: {
+    requested?: ConnectionAction;
+    devices: ComputerDevice[];
+    question?: (prompt: string) => Promise<string>;
+}): Promise<ConnectionAction>;
+/** Ask once; preserve existing opt-outs. Scripts must opt in with --startup. */
+export declare function chooseStartupAction(options: {
+    state: {
+        enabled: boolean;
+        running?: boolean;
+        kind?: string;
+    };
+    startup?: boolean;
+    noStartup?: boolean;
+    question?: (prompt: string) => Promise<string>;
+}): Promise<boolean | undefined>;
+export declare function reconnectCode(info: ComputerInfo, name: string, now?: Date): ComputerReconnectCode;
+export declare function deviceSummary(devices: ComputerDevice[]): string;

package/dist/computer/controller.d.ts

@@ -0,0 +1,3 @@
+export declare function recoveryDelay(failures: number): number;
+/** Own process lifecycle separately from any mobile view or pairing command. */
+export declare function superviseComputer(directory: string): Promise<void>;

package/dist/computer/lifecycle.d.ts

@@ -1,6 +1,7 @@
 import { Mindwire } from "../client.js";
 import type { ComputerRoute } from "../computer.js";
-import { type RelayOptions } from "./relay.js";
+import type { RelayOptions } from "./relay.js";
+import { type ProcessState } from "./process.js";
 export interface ComputerConfig {
     daemonBin?: string;
     version?: string;
@@ -11,6 +12,13 @@ export interface ComputerConfig {
     websocketPort: number;
     relay: RelayOptions;
 }
+export interface ControllerState extends ProcessState {
+    ready: boolean;
+    phase?: string;
+    error?: string;
+    recovering?: boolean;
+    routes?: ComputerRoute[];
+}
 export declare const defaultStateDirectory: () => string;
 export declare const defaultComputerConfig: () => ComputerConfig;
 export declare function readJSON<T>(file: string): Promise<T | undefined>;
@@ -18,7 +26,9 @@ export declare function writeJSON(file: string, value: unknown): Promise<void>;
 export declare function computerClient(directory: string): Promise<Mindwire>;
 export declare function directRoutes(config: ComputerConfig, port: number): ComputerRoute[];
 /** Launch once; the daemon additionally owns an OS file lock over its identity/state. */
-export declare function ensureComputer(directory: string, cliPath: string, patch?: Partial<ComputerConfig>, onProgress?: (message: string) => void): Promise<Mindwire>;
-/** The only owner of daemon/relay processes. Closing the pairing command leaves this running. */
+export declare function ensureComputer(directory: string, cliPath: string, patch?: Partial<ComputerConfig>, onProgress?: (message: string) => void, options?: {
+    resume?: boolean;
+    signal?: AbortSignal;
+}): Promise<Mindwire>;
 export declare function superviseComputer(directory: string): Promise<void>;
 export declare function stopComputer(directory: string, force?: boolean): Promise<void>;

package/dist/computer/lock.d.ts

@@ -0,0 +1,11 @@
+export interface ProcessLock {
+    close(): Promise<void>;
+}
+/** Serialize lock-file acquisition and stale recovery with a bakery queue. Each
+ * waiter owns a unique, atomically published ticket; it never removes another
+ * live waiter's ticket. That prevents two stale-lock cleaners deleting a newly
+ * acquired lock. Process birth also makes abandoned tickets safe after reboot. */
+export declare function acquireProcessLock(file: string, options?: {
+    signal?: AbortSignal;
+    onWait?: () => Promise<boolean>;
+}): Promise<ProcessLock | undefined>;

package/dist/computer/pairing-display.d.ts

@@ -0,0 +1,23 @@
+import { type ComputerConnectionCode } from "../computer.js";
+export type PairingQRMode = "auto" | "terminal" | "browser" | "none";
+type Output = Pick<NodeJS.WriteStream, "isTTY" | "columns" | "rows" | "write" | "on" | "off">;
+interface DisplayOptions {
+    mode?: PairingQRMode;
+    output?: Output;
+    environment?: NodeJS.ProcessEnv;
+    openBrowser?: (url: string) => Promise<boolean>;
+}
+export interface PairingDisplay {
+    close(): void;
+}
+/** qrcode's small terminal renderer ignores margin/width. Render its matrix with
+ * a four-module quiet zone, two square QR modules per terminal character. */
+export declare function createPairingQR(invitation: ComputerConnectionCode): Promise<{
+    lines: string[];
+    columns: number;
+    rows: number;
+    svg: string;
+}>;
+/** Display one existing invitation. Resizing never starts another service or pairing. */
+export declare function showPairingInvitation(invitation: ComputerConnectionCode, options?: DisplayOptions): Promise<PairingDisplay>;
+export {};

package/dist/computer/process.d.ts

@@ -0,0 +1,26 @@
+import { type ChildProcess } from "node:child_process";
+export interface ProcessIdentity {
+    pid: number;
+    start: string;
+}
+export interface ProcessState {
+    pid: number;
+    start?: string;
+}
+export interface OwnedProcess {
+    readonly pid: number;
+    readonly identity?: ProcessIdentity;
+    alive(): boolean;
+    close(): Promise<void>;
+}
+export declare function processAlive(pid: number | undefined): boolean;
+/** Include process birth, not just its reusable PID, when adopting an orphan. */
+export declare function processIdentity(pid: number): Promise<ProcessIdentity | undefined>;
+export declare function currentProcessIdentity(): Promise<ProcessIdentity>;
+/** Old CLI records contain only a PID. New records also survive PID reuse after
+ * reboot, so an unrelated process cannot block recovery or receive Stop. */
+export declare function processStateAlive(state: ProcessState | undefined): Promise<boolean>;
+/** Launch/startup locks used plain numeric PIDs before process identities. */
+export declare function readProcessState(file: string): Promise<ProcessState | undefined>;
+export declare function ownChild(child: ChildProcess): Promise<OwnedProcess>;
+export declare function adoptProcess(identity: ProcessIdentity): Promise<OwnedProcess | undefined>;

package/dist/computer/relay.d.ts

@@ -1,5 +1,6 @@
 import { type ChildProcess } from "node:child_process";
 import type { ComputerRoute } from "../computer.js";
+import { type OwnedProcess } from "./process.js";
 export interface RelayOptions {
     kind: "none" | "cloudflare" | "ngrok" | "custom";
     /** A stable, already configured hostname; custom relays must forward WebSocket upgrades. */
@@ -9,11 +10,14 @@ export interface RelayOptions {
 export interface RelayHandle {
     route?: ComputerRoute;
     process?: ChildProcess;
-    close(): void;
+    owner?: OwnedProcess;
+    close(): void | Promise<void>;
 }
 export declare function websocketURL(value: string): string;
 /** Both providers forward encrypted SSH bytes to one loopback WebSocket bridge. */
 export declare function startRelay(options: RelayOptions, port: number, runtime?: {
     cacheDir?: string;
     onProgress?: (message: string) => void | Promise<void>;
+    signal?: AbortSignal;
+    onSpawn?: (owner: OwnedProcess) => Promise<void>;
 }): Promise<RelayHandle>;

package/dist/computer/startup.d.ts

@@ -0,0 +1,38 @@
+type Command = [string, ...string[]];
+export interface StartupPlan {
+    kind: "launchd" | "systemd" | "task-scheduler";
+    name: string;
+    file: string;
+    content: string;
+    query: Command;
+    enable: Command[];
+    disable: Command[];
+}
+export interface StartupState {
+    enabled: boolean;
+    running?: boolean;
+    kind?: StartupPlan["kind"];
+    name?: string;
+    file?: string;
+}
+/** Per-user startup, with no root service, password, or copied pairing secret. */
+export declare function startupPlan(options: {
+    directory: string;
+    cliPath: string;
+    executable?: string;
+    platform?: NodeJS.Platform;
+    home?: string;
+    uid?: number;
+    user?: string;
+    environmentPath?: string;
+}): StartupPlan;
+export declare function startupStatus(directory: string): Promise<StartupState>;
+export declare function configureStartup(directory: string, cliPath: string, enabled: boolean, runtime?: {
+    plan?: StartupPlan;
+    run?: (command: Command) => Promise<void>;
+    verify?: () => Promise<void>;
+}): Promise<StartupState>;
+/** Native startup managers supervise this small guardian. It adopts an existing
+ * controller and honours an explicit stop; it never owns or kills user work. */
+export declare function watchComputer(directory: string, cliPath: string): Promise<void>;
+export {};

package/dist/computer.d.ts

@@ -17,12 +17,26 @@ export interface ComputerInvitation {
     secret: string;
     expiresAt: string;
 }
+/** Address refresh for an already paired phone. Contains no credential and grants no access;
+ * the phone must authenticate with its saved key and verify its saved host fingerprint. */
+export interface ComputerReconnectCode {
+    version: 1;
+    mode: "reconnect";
+    computerId: string;
+    registryId: string;
+    name: string;
+    fingerprint: string;
+    routes: ComputerRoute[];
+    expiresAt: string;
+}
+export type ComputerConnectionCode = ComputerInvitation | ComputerReconnectCode;
 export interface ComputerDevice {
     id: string;
     name: string;
     publicKey: string;
     createdAt: string;
     revoked: boolean;
+    connected?: boolean;
 }
 export interface ComputerPairRequest {
     id: string;
@@ -41,6 +55,8 @@ export interface ComputerUpdate {
     version: string;
     updatedAt: string;
     error?: string;
+    /** Explicit owner restart; automatic requests omit this and wait for idle. */
+    force?: boolean;
     status: "idle" | "queued" | "downloading" | "waiting" | "restarting" | "complete" | "failed";
 }
 export interface ComputerInfo {
@@ -70,7 +86,11 @@ export declare class ComputerApi {
     info(): Promise<ComputerInfo>;
     setRoutes(routes: ComputerRoute[]): Promise<ComputerInfo>;
     updateStatus(): Promise<ComputerUpdate>;
-    requestUpdate(version: string): Promise<ComputerUpdate>;
+    /** Automatic requests wait for idle. With serviceUpdateVersion >= 2, force
+     * promotes the same active request to an explicit restart without re-downloading. */
+    requestUpdate(version: string, options?: {
+        force?: boolean;
+    }): Promise<ComputerUpdate>;
     invite(routes: ComputerRoute[]): Promise<ComputerInvitation>;
     pairing(id: string): Promise<ComputerPairing>;
     completePairing(id: string, requestId: string): Promise<{
@@ -92,5 +112,9 @@ export declare class ComputerApi {
         ok: boolean;
     }>;
 }
+/** The mobile scanner accepts raw JSON. Avoid base64 overhead in QR codes without
+ * dropping routes, shortening the host pin or changing the pairing protocol.
+ * This includes a short-lived secret; never log it to shared service logs. */
+export declare function computerPairingQRData(invitation: ComputerConnectionCode): string;
 /** A URI carries an invitation, not permanent credentials. Never log it to shared service logs. */
-export declare function computerPairingURI(invitation: ComputerInvitation): string;
+export declare function computerPairingURI(invitation: ComputerConnectionCode): string;