mindwire 0.1.25 → 0.1.26

package/dist/client.d.ts

@@ -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).
@@ -193,6 +200,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 +223,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/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 ComputerInvitation } 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: ComputerInvitation): 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: ComputerInvitation, 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

@@ -92,5 +92,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: ComputerInvitation): string;
 /** A URI carries an invitation, not permanent credentials. Never log it to shared service logs. */
 export declare function computerPairingURI(invitation: ComputerInvitation): string;