mindwire 0.1.19 → 0.1.22

package/dist/client.d.ts

@@ -3,6 +3,8 @@ import { Run } from "./run.js";
 import { WorkspaceApi, type ProjectAuth } from "./workspace.js";
 import { SurfacesApi } from "./surfaces.js";
 import { ServiceApi } from "./service.js";
+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";
@@ -74,6 +76,8 @@ export declare class Mindwire {
     readonly workspace: WorkspaceApi;
     readonly surfaces: SurfacesApi;
     readonly service: ServiceApi;
+    readonly execution: ExecutionApi;
+    readonly computer: ComputerApi;
     readonly http: Http;
     /** The default agent type applied to agent-scoped calls, if set. */
     readonly defaultAgent: string | undefined;

package/dist/computer/cloudflare-binary.d.ts

@@ -0,0 +1,9 @@
+export declare const CLOUDFLARED_VERSION = "2026.9.3";
+export declare function ensureCloudflareBinary(options?: {
+    cacheDir?: string;
+    platform?: string;
+    arch?: string;
+    fetch?: typeof fetch;
+    onProgress?: (message: string) => void | Promise<void>;
+}): Promise<string>;
+export declare function cloudflareCommand(options: Parameters<typeof ensureCloudflareBinary>[0]): Promise<string>;

package/dist/computer/lifecycle.d.ts

@@ -0,0 +1,24 @@
+import { Mindwire } from "../client.js";
+import type { ComputerRoute } from "../computer.js";
+import { type RelayOptions } from "./relay.js";
+export interface ComputerConfig {
+    daemonBin?: string;
+    version?: string;
+    directory: string;
+    host?: string;
+    bind: string;
+    sshPort: number;
+    websocketPort: number;
+    relay: RelayOptions;
+}
+export declare const defaultStateDirectory: () => string;
+export declare const defaultComputerConfig: () => ComputerConfig;
+export declare function readJSON<T>(file: string): Promise<T | undefined>;
+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 superviseComputer(directory: string): Promise<void>;
+export declare function stopComputer(directory: string, force?: boolean): Promise<void>;

package/dist/computer/relay.d.ts

@@ -0,0 +1,19 @@
+import { type ChildProcess } from "node:child_process";
+import type { ComputerRoute } from "../computer.js";
+export interface RelayOptions {
+    kind: "none" | "cloudflare" | "ngrok" | "custom";
+    /** A stable, already configured hostname; custom relays must forward WebSocket upgrades. */
+    url?: string;
+    cloudflareTokenFile?: string;
+}
+export interface RelayHandle {
+    route?: ComputerRoute;
+    process?: ChildProcess;
+    close(): 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>;
+}): Promise<RelayHandle>;

package/dist/computer.d.ts

@@ -0,0 +1,80 @@
+import type { Mindwire } from "./client.js";
+export type ComputerRoute = {
+    kind: "ssh";
+    host: string;
+    port: number;
+} | {
+    kind: "websocket";
+    url: string;
+};
+export interface ComputerInvitation {
+    version: 1;
+    computerId: string;
+    name: string;
+    fingerprint: string;
+    routes: ComputerRoute[];
+    pairingId: string;
+    secret: string;
+    expiresAt: string;
+}
+export interface ComputerDevice {
+    id: string;
+    name: string;
+    publicKey: string;
+    createdAt: string;
+    revoked: boolean;
+}
+export interface ComputerPairRequest {
+    id: string;
+    name: string;
+    publicKey: string;
+}
+export interface ComputerPairing {
+    id: string;
+    expiresAt: string;
+    status: "waiting" | "pending" | "approved" | "rejected";
+    request?: ComputerPairRequest;
+    completed?: boolean;
+}
+export interface ComputerUpdate {
+    id: string;
+    version: string;
+    updatedAt: string;
+    error?: string;
+    status: "idle" | "queued" | "downloading" | "waiting" | "restarting" | "complete" | "failed";
+}
+export interface ComputerInfo {
+    version: number;
+    computerId: string;
+    registryId: string;
+    fingerprint: string;
+    routes: ComputerRoute[];
+    pid: number;
+    apiAddress: string;
+    sshPort: number;
+    websocketPort: number;
+}
+/** Available only in computer mode. All calls use the existing authenticated transport. */
+export declare class ComputerApi {
+    private readonly client;
+    constructor(client: Mindwire);
+    info(): Promise<ComputerInfo>;
+    setRoutes(routes: ComputerRoute[]): Promise<ComputerInfo>;
+    updateStatus(): Promise<ComputerUpdate>;
+    requestUpdate(version: string): Promise<ComputerUpdate>;
+    invite(routes: ComputerRoute[]): Promise<ComputerInvitation>;
+    pairing(id: string): Promise<ComputerPairing>;
+    completePairing(id: string, requestId: string): Promise<{
+        ok: boolean;
+    }>;
+    decide(id: string, requestId: string, approve: boolean): Promise<{
+        ok: boolean;
+        device: ComputerDevice;
+    }>;
+    devices(): Promise<ComputerDevice[]>;
+    revoke(id: string): Promise<{
+        ok: boolean;
+    }>;
+}
+/** A URI carries an invitation, not permanent credentials. Never log it to shared service logs. */
+export declare function computerPairingURI(invitation: ComputerInvitation): string;

package/dist/execution.d.ts

@@ -0,0 +1,111 @@
+import type { Mindwire } from "./client.js";
+/** Native workspace execution; the same contract on macOS, Linux and Windows. */
+export interface WorkspaceHost {
+    hostname: string;
+    os: "darwin" | "linux" | "windows" | string;
+    arch: string;
+    home: string;
+    directory: string;
+    pid: number;
+}
+export interface HostResources {
+    cpus: number;
+    memoryMb: number;
+    diskMb: number;
+}
+export interface WorkspaceFile {
+    name: string;
+    path: string;
+    type: "file" | "dir";
+    size: number;
+    modifiedAt: string;
+    isIgnored: boolean;
+}
+export interface WorkspaceFileContent {
+    path: string;
+    content: string;
+    size: number;
+}
+export interface WorkspaceExecRequest {
+    argv: string[];
+    directory?: string;
+    input?: string;
+    timeoutMs?: number;
+}
+export interface WorkspaceExecResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    truncated?: boolean;
+}
+export type WorkspaceExecEvent = {
+    kind: "output";
+    channel: "stdout" | "stderr";
+    data: string;
+} | {
+    kind: "exit";
+    exitCode: number;
+} | {
+    kind: "error";
+    error: string;
+};
+export interface TerminalRequest {
+    id: string;
+    directory?: string;
+    columns: number;
+    rows: number;
+}
+export interface TerminalState extends TerminalRequest {
+    title: string;
+    running: boolean;
+    exitCode?: number;
+    createdAt: string;
+}
+export interface TerminalEvent {
+    sequence: number;
+    kind: "output" | "reset" | "exit";
+    data?: string;
+    state?: TerminalState;
+}
+/** Retry the exact same writer/sequence/data after a lost acknowledgement, never a new sequence. */
+export interface TerminalInput {
+    writer: string;
+    sequence: number;
+    data: string;
+}
+export declare class ExecutionApi {
+    private readonly client;
+    readonly terminals: TerminalsApi;
+    constructor(client: Mindwire);
+    host(): Promise<WorkspaceHost>;
+    resources(): Promise<HostResources>;
+    files(path?: string, query?: string): Promise<WorkspaceFile[]>;
+    read(path: string): Promise<WorkspaceFileContent>;
+    write(path: string, content: string): Promise<{
+        ok: boolean;
+    }>;
+    remove(path: string): Promise<{
+        ok: boolean;
+    }>;
+    exec(command: WorkspaceExecRequest, signal?: AbortSignal): Promise<WorkspaceExecResult>;
+    /** Output data is base64, preserving partial UTF-8 chunks. Cancelling stops this command. */
+    stream(command: WorkspaceExecRequest, signal?: AbortSignal): AsyncGenerator<WorkspaceExecEvent>;
+}
+export declare class TerminalsApi {
+    private readonly client;
+    constructor(client: Mindwire);
+    list(directory?: string): Promise<TerminalState[]>;
+    open(request: TerminalRequest): Promise<TerminalState>;
+    get(id: string): Promise<TerminalState>;
+    close(id: string): Promise<{
+        ok: boolean;
+    }>;
+    input(id: string, input: TerminalInput): Promise<{
+        ok: boolean;
+        sequence: number;
+    }>;
+    resize(id: string, columns: number, rows: number): Promise<TerminalState>;
+    /** Detaching only closes the subscription. Resume from the last sequence; reset replaces the screen. */
+    events(id: string, after?: number, signal?: AbortSignal): AsyncGenerator<TerminalEvent>;
+    private path;
+}