mindwire 0.1.11 → 0.1.14

package/dist/run.d.ts

@@ -75,9 +75,9 @@ export declare class Run {
      */
     setModel(model?: string): Promise<void>;
     /**
-     * Switch the permission mode of the live turn (e.g. `default`, `acceptEdits`, `plan`,
-     * `bypassPermissions`). Only meaningful on a persistent (non-bypass) turn; on a one-shot turn it
-     * is a best-effort no-op. Requires the agent's `setPermissionMode` capability.
+     * Switch the live permission mode using a value from the agent's settings schema.
+     * Resolves after the harness acknowledges the change; rejects if it cannot apply it.
+     * Requires `setPermissionMode`. Codex settings apply on the next turn instead.
      */
     setPermissionMode(mode: string): Promise<void>;
     /**

package/dist/surfaces.d.ts

@@ -0,0 +1,177 @@
+import type { Mindwire } from "./client.js";
+export interface SurfaceGeometry {
+    width: number;
+    height: number;
+    revision: number;
+}
+export interface SurfaceProblem {
+    code: string;
+    message: string;
+}
+export interface SurfaceCapabilities {
+    view: boolean;
+    capture: boolean;
+    pointer: boolean;
+    keyboard: boolean;
+    text: boolean;
+    clipboardRead: boolean;
+    clipboardWrite: boolean;
+}
+export interface SurfaceController {
+    sessionId: string;
+    actor: "user" | "agent";
+    name: string;
+    runId?: string;
+    chatId?: string;
+    generation: number;
+    expiresAt: string;
+}
+export interface SurfaceSnapshot {
+    id: string;
+    workspaceId: string;
+    kind: "desktop";
+    provider: "oblien";
+    version: number;
+    revision: number;
+    instanceId: string;
+    state: string;
+    observedAt?: string;
+    supported: boolean;
+    enabled: boolean;
+    available: boolean;
+    credentials: boolean;
+    os?: string;
+    capabilities: SurfaceCapabilities;
+    geometry?: SurfaceGeometry;
+    controller?: SurfaceController;
+    authorizationExpiresAt?: string;
+    error?: SurfaceProblem;
+}
+/** Write-only, desktop-only, expiring provider grant. Never pass a user's session JWT. */
+export interface SurfaceBinding {
+    registryId: string;
+    workspaceId: string;
+    gatewayToken?: string;
+    connection: {
+        expires_at: string;
+        ssh: {
+            host: string;
+            port: number;
+            username: string;
+            password: string;
+            host_key_fingerprint: string;
+        };
+        vnc: {
+            host: string;
+            port: number;
+            authentication: "none";
+        };
+    };
+}
+export interface SurfaceSession {
+    id: string;
+    surfaceId: string;
+    actor: "user" | "agent";
+    name: string;
+    chatId?: string;
+    runId?: string;
+    mode: "view" | "control";
+    createdAt: string;
+    controller?: SurfaceController;
+}
+export interface SurfaceOpenRequest {
+    requestId: string;
+    name?: string;
+    mode: "view" | "control";
+}
+export interface SurfaceControlRequest {
+    action: "acquire" | "takeover" | "release" | "renew";
+    generation?: number;
+}
+export interface SurfaceAction {
+    kind: "pointer" | "click" | "drag" | "scroll" | "key" | "text" | "clipboard_read" | "clipboard_write" | "release";
+    x?: number;
+    y?: number;
+    toX?: number;
+    toY?: number;
+    buttons?: number;
+    button?: "left" | "middle" | "right";
+    count?: number;
+    deltaX?: number;
+    deltaY?: number;
+    keys?: string[];
+    text?: string;
+}
+export interface SurfaceActionRequest {
+    /** Reuse this ID to inspect/recover an uncertain acknowledgement. Do not replay with a new ID. */
+    requestId: string;
+    sessionId: string;
+    controlGeneration: number;
+    frameId?: string;
+    geometryRevision?: number;
+    action: SurfaceAction;
+}
+export interface SurfaceReceipt {
+    id: string;
+    sessionId: string;
+    surfaceId: string;
+    kind: string;
+    status: "dispatching" | "dispatched" | "outcome_unknown";
+    createdAt: string;
+    error?: SurfaceProblem;
+    /** Transient clipboard output, not stored in the receipt. */
+    text?: string;
+}
+export interface SurfaceCapture {
+    id: string;
+    surfaceId: string;
+    artifactId: string;
+    mime: string;
+    geometry: SurfaceGeometry;
+    createdAt: string;
+}
+export interface ArtifactContent {
+    id: string;
+    chatId?: string;
+    mime: string;
+    bytes: number;
+    width: number;
+    height: number;
+    createdAt: string;
+    /** Base64 bytes, compatible with every existing daemon transport. */
+    data: string;
+}
+export interface SurfaceToolAction {
+    surfaceId: string;
+    operation: string;
+    sessionId?: string;
+    receiptId?: string;
+    status?: string;
+    capture?: {
+        id: string;
+        artifactId: string;
+        width: number;
+        height: number;
+    };
+}
+/** Workspace-scoped API. One controller is shared by every harness and app client. */
+export declare class SurfacesApi {
+    private readonly mw;
+    constructor(mw: Mindwire);
+    list(): Promise<SurfaceSnapshot[]>;
+    status(refresh?: boolean): Promise<SurfaceSnapshot>;
+    bind(binding: SurfaceBinding): Promise<SurfaceSnapshot>;
+    open(request: SurfaceOpenRequest): Promise<SurfaceSession>;
+    control(id: string, request: SurfaceControlRequest): Promise<SurfaceSession>;
+    close(id: string): Promise<{
+        closed: boolean;
+    }>;
+    capture(id: string): Promise<SurfaceCapture>;
+    action(request: SurfaceActionRequest): Promise<SurfaceReceipt>;
+    receipt(id: string): Promise<SurfaceReceipt>;
+    artifact(id: string): Promise<ArtifactContent>;
+    /** Every connection starts with the current snapshot, then revisions. Never replays input. */
+    watch(opts?: {
+        signal?: AbortSignal;
+    }): AsyncGenerator<SurfaceSnapshot>;
+}

package/dist/target/host.d.ts

@@ -30,9 +30,9 @@ export interface EnsureDaemonConfig {
     /** `AGENT_CWD` — working directory agents run in, inside the sandbox. */
     agentCwd: string;
     /**
-     * Explicit path to a Linux `mindwired` to deploy (else downloaded from the matching GitHub Release).
-     * `{arch}` is expanded to the destination architecture (`amd64` or `arm64`), allowing a development
-     * launcher to build both artifacts without guessing the sandbox architecture in advance.
+     * Explicit path to a `mindwired` to deploy (else downloaded from the matching GitHub Release).
+     * `{os}` and `{arch}` expand to the destination (`linux`/`darwin` and `amd64`/`arm64`), allowing a
+     * development launcher to build artifacts without guessing the sandbox platform in advance.
      */
     daemonBin?: string;
     /** Redeploy when the running daemon's version differs from `desiredVersion`. Off by default. */
@@ -70,6 +70,8 @@ export interface EnsureEvent {
     version?: string;
     /** Target architecture the daemon was resolved for (on `upload`). */
     arch?: "amd64" | "arm64";
+    /** Destination operating system (on `download` / `upload`). */
+    platform?: "linux" | "darwin";
     /** Size of the uploaded daemon binary in bytes (on `upload`). */
     bytes?: number;
     /** Error message (on `error`). */

package/dist/target/oblien.d.ts

@@ -19,7 +19,7 @@ export interface OblienConfig {
     agentCwd?: string;
     /** Loopback port the in-workspace daemon listens on. */
     port?: number;
-    /** Explicit local Linux `mindwired` to deploy. `{arch}` expands to the workspace architecture. */
+    /** Explicit local `mindwired` to deploy. `{os}`/`{arch}` expand to the workspace platform. */
     daemonBin?: string;
     /** Redeploy the daemon when the running version differs from the SDK's bundled binary. Off by default. */
     autoUpdate?: boolean;

package/dist/target/ssh.d.ts

@@ -26,7 +26,7 @@ export interface SshOptions {
     agentType?: string;
     /** `AGENT_CWD` — working directory agents run in, on the remote. Defaults to `/root`. */
     agentCwd?: string;
-    /** Explicit path to a Linux `mindwired` to deploy (else resolved from the platform package). */
+    /** Explicit local `mindwired` to deploy; `{os}`/`{arch}` expand to the destination platform. Otherwise downloaded from GitHub Releases. */
     daemonBin?: string;
     /** Redeploy when the running daemon's version differs from the SDK's bundled binary. */
     autoUpdate?: boolean;

package/dist/types.d.ts

@@ -28,6 +28,7 @@ export type ToolKind = "file_edit" | "file_read" | "shell" | "search" | "web_sea
  * apply_patch/shell).
  */
 export interface ToolAction {
+    surface?: import("./surfaces.js").SurfaceToolAction;
     kind: ToolKind;
     /** Short human label (e.g. the command or the path). */
     title?: string;
@@ -108,6 +109,8 @@ export interface Usage {
 export interface ResultInfo {
     text?: string;
     isError?: boolean;
+    /** The harness stopped at the user's request; this is not an error. */
+    cancelled?: boolean;
     sessionId?: string;
     costUsd?: number;
     /** Per-turn token accounting, when the agent reports it. */
@@ -193,6 +196,8 @@ export interface ContinuationInfo {
 export interface Action {
     id: string;
     label: string;
+    description?: string;
+    preview?: string;
 }
 export interface TodoItem {
     content: string;
@@ -202,29 +207,49 @@ export interface TodoItem {
  * A structured, self-describing request an agent surfaces mid-turn for the client to render
  * generically — and, when `needsResponse`, for the user to answer.
  */
+export interface Question {
+    id: string;
+    title: string;
+    header?: string;
+    options?: Action[];
+    multiSelect?: boolean;
+    allowOther?: boolean;
+    isSecret?: boolean;
+    optional?: boolean;
+}
+export interface QuestionAnswer {
+    options?: string[];
+    text?: string;
+}
 export interface Interaction {
     id?: string;
-    kind: "todos" | "approval" | "choice" | "select" | "input" | "plan" | (string & {});
+    kind: "todos" | "approval" | "choice" | "select" | "input" | "form" | "plan" | (string & {});
     title?: string;
     detail?: string;
     /** `kind: "todos"` */
     items?: TodoItem[];
     /** `kind: "approval" | "choice" | "select" | "plan"` */
     options?: Action[];
+    questions?: Question[];
+    blocking?: boolean;
+    /** Whether approval feedback is accepted for all actions, or only a rejection. */
+    feedback?: "always" | "rejection";
     needsResponse?: boolean;
     meta?: Record<string, unknown>;
 }
 /**
  * The user's answer to a mid-turn {@link Interaction}, sent via {@link Run.respond}. `interactionId`
- * ties the answer to the interaction the turn paused on; `decision` is the approval verdict
- * (allow/deny) for a permission or plan; `text` is the free-form answer (or deny reason); `options`
- * carries a multi-select answer.
+ * ties the answer to the pending request. `decision` must be an offered action ID. For a form,
+ * `answers` maps every required question ID to its selected option IDs and optional feedback.
+ * Legacy single-question clients may send `options` and `text` at the top level. Incomplete
+ * answers return 400; stale or duplicate submissions return 409.
  */
 export interface RespondInput {
     interactionId?: string;
     decision?: string;
     options?: string[];
     text?: string;
+    answers?: Record<string, QuestionAnswer>;
 }
 /** Whether an agent provides a feature natively, needs the core to emulate it, or lacks it. */
 export type Support = "none" | "native" | "emulated";
@@ -497,6 +522,8 @@ export interface MCPServer {
     bearerTokenEnvVar?: string;
     /** HTTP transport: literal headers sent with each request. */
     httpHeaders?: Record<string, string>;
+    /** Codex's native approval behavior for this MCP server. */
+    defaultToolsApprovalMode?: "auto" | "prompt" | "writes" | "approve";
 }
 /**
  * One registered custom OpenAI-compatible LLM provider — a base URL + model ids an agent loads on every
@@ -799,21 +826,30 @@ export interface SetupStatus {
     started: boolean;
     current?: string;
     steps: StepResult[];
+    /** The shared job's operation, including when another client started it. Older daemons omit it. */
+    operation?: "setup" | "update";
+    /** Current step phase, reported by the daemon rather than inferred from elapsed time. */
+    stage?: "checking" | "waiting" | "installing" | "verifying" | (string & {});
 }
 /** `GET /notify/config` — the token is never returned. */
 export interface NotifyConfigStatus {
     configured: boolean;
     url: string;
     channel: string;
+    /** Absent on older daemons, which always send raw Notification JSON. */
+    format?: NotifyChannelType;
+    hasToken?: boolean;
 }
 /** `PUT /notify/config` body. */
 export interface NotifyConfigInput {
     url: string;
     channel: string;
     token?: string;
+    /** "webhook" (default) sends raw Notification JSON; "push" uses title/body/data. */
+    format?: NotifyChannelType;
 }
 /** Delivery payload shape of a channel (selects only how the outgoing POST is framed). */
-export type NotifyChannelType = "webhook" | "slack" | "discord" | "telegram" | (string & {});
+export type NotifyChannelType = "webhook" | "push" | "slack" | "discord" | "telegram" | (string & {});
 /**
  * `GET /notify/channels` — the masked read view of a channel. Secrets never cross the wire: the URL,
  * token, HMAC secret, and header VALUES are omitted; only their presence (and the URL host, as a
@@ -877,6 +913,11 @@ export interface NotifyChannelTestResult {
 }
 /** `GET /healthz` — the daemon's liveness probe. */
 export interface Health {
+    surfaceProtocolVersion?: number;
+    /** Workspace registry protocol version; absent on daemons predating workspace metadata. */
+    workspaceMetadataVersion?: number;
+    /** Durable project creation/clone operations; absent on older daemons. */
+    projectOperationsVersion?: number;
     ok: boolean;
     agent: string;
     version: string;

package/dist/workspace.d.ts

@@ -0,0 +1,149 @@
+import type { Mindwire } from "./client.js";
+/** Write-only credentials for one clone attempt. Never persisted in operation snapshots. */
+export type ProjectAuth = {
+    kind: "token";
+    token: string;
+    username?: string;
+} | {
+    kind: "ssh";
+    privateKey: string;
+} | {
+    kind: "gh";
+};
+export interface ProjectRequest {
+    /** Stable idempotency key. Keep the same ID if the acknowledgement is lost. */
+    id: string;
+    source: "folder" | "create" | "clone";
+    name: string;
+    /** Absolute directory, or ~/... on the workspace. Clone/create require an absent destination. */
+    path: string;
+    repoUrl?: string;
+    branch?: string;
+    auth?: ProjectAuth;
+}
+export interface ProjectRemoveRequest {
+    /** Stable idempotency key for this confirmed removal. */
+    operationId: string;
+    expectedRevision: number;
+}
+export interface ProjectOperation extends Omit<ProjectRequest, "auth" | "source"> {
+    source: ProjectRequest["source"] | "delete";
+    expectedRevision?: number;
+    authKind?: ProjectAuth["kind"];
+    status: "queued" | "running" | "cancelling" | "succeeded" | "failed" | "cancelled" | "interrupted";
+    phase: string;
+    progress?: number;
+    /** Bounded, redacted output tail. */
+    log?: string;
+    error?: string;
+    projectId?: string;
+    createdAt: string;
+    updatedAt: string;
+    sequence: number;
+    attempt: number;
+}
+export declare class ProjectOperationsApi {
+    private readonly mw;
+    constructor(mw: Mindwire);
+    list(activeOnly?: boolean): Promise<ProjectOperation[]>;
+    get(id: string): Promise<ProjectOperation>;
+    cancel(id: string): Promise<ProjectOperation>;
+    retry(id: string, auth?: ProjectAuth): Promise<ProjectOperation>;
+    /** The first event is the current snapshot, then live changes. Reconnecting never replays old
+     * progress. Breaking the loop/aborting detaches the observer; cancel(id) explicitly stops work.
+     */
+    watch(id: string, opts?: {
+        signal?: AbortSignal;
+    }): AsyncGenerator<ProjectOperation>;
+}
+/** Stable identity and version of a record in one workspace's SQLite registry. */
+export interface WorkspaceRecord {
+    id: string;
+    /** Registry identity, independent of the cloud provider's workspace ID. */
+    workspaceId: string;
+    createdAt: string;
+    revision: number;
+}
+/** A saved agent profile. Profiles using one harness share that workspace's native configuration. */
+export interface WorkspaceAgent extends WorkspaceRecord {
+    name: string;
+    agentType: string;
+    agentTypeName?: string;
+}
+export interface WorkspaceProject extends WorkspaceRecord {
+    name: string;
+    path: string;
+    repoUrl?: string;
+}
+/** Chat membership; transcript content continues to come from /chats/:id/messages. */
+export interface WorkspaceChat extends WorkspaceRecord {
+    agentId: string;
+    projectId: string;
+    title: string;
+    titleIsUserSet?: boolean;
+    sessionId?: string;
+}
+export type WorkspaceKind = "agents" | "projects" | "chats";
+export type WorkspaceInput<T extends WorkspaceRecord> = Omit<T, "id" | "workspaceId" | "revision" | "createdAt"> & {
+    createdAt?: string;
+};
+/** Additive migration. Existing records and deletion tombstones always win over these values. */
+export interface WorkspaceImport {
+    agents?: (WorkspaceInput<WorkspaceAgent> & {
+        id: string;
+    })[];
+    projects?: (WorkspaceInput<WorkspaceProject> & {
+        id: string;
+    })[];
+    chats?: (WorkspaceInput<WorkspaceChat> & {
+        id: string;
+    })[];
+}
+export interface WorkspaceSnapshot {
+    version: number;
+    workspaceId: string;
+    revision: number;
+    /** true replaces the cache for this workspace; false applies changed rows and deletions. */
+    full: boolean;
+    agents: WorkspaceAgent[];
+    projects: WorkspaceProject[];
+    chats: WorkspaceChat[];
+    deleted: {
+        kind: WorkspaceKind;
+        id: string;
+        revision: number;
+    }[];
+}
+export declare class WorkspaceCollection<T extends WorkspaceRecord> {
+    private readonly mw;
+    private readonly kind;
+    constructor(mw: Mindwire, kind: WorkspaceKind);
+    /** Create with a stable client-generated ID. For updates, supply the record's last revision. */
+    put(id: string, record: WorkspaceInput<T>, expectedRevision?: number): Promise<WorkspaceSnapshot>;
+    /** Remove membership and dependent chat links. Files and native transcripts are retained.
+     * Use deleteChat() for an explicit transcript purge. Running chats reject removal with 409.
+     */
+    delete(id: string, revision: number): Promise<WorkspaceSnapshot>;
+}
+/** Workspace metadata is shared by all harnesses; withAgent() never scopes these requests. */
+export declare class WorkspaceApi {
+    private readonly mw;
+    readonly operations: ProjectOperationsApi;
+    readonly agents: WorkspaceCollection<WorkspaceAgent>;
+    readonly projects: WorkspaceCollection<WorkspaceProject>;
+    readonly chats: WorkspaceCollection<WorkspaceChat>;
+    constructor(mw: Mindwire);
+    snapshot(): Promise<WorkspaceSnapshot>;
+    /** Start an operation owned by the daemon. The same ID/payload returns the existing operation. */
+    createProject(request: ProjectRequest): Promise<ProjectOperation>;
+    /** Permanently remove the confirmed project's directory and membership.
+     * projects.delete() retains files. Native harness transcripts are not purged.
+     */
+    removeProjectFiles(id: string, request: ProjectRemoveRequest): Promise<ProjectOperation>;
+    /** Incremental reconciliation. Pass the previous identity to detect a replaced/restored workspace.
+     * A 409 requires fetching snapshot() again; never apply a delta to a different registry.
+     */
+    changes(since: number, workspaceId: string): Promise<WorkspaceSnapshot>;
+    /** Import legacy metadata before replacing a local cache. Safe to repeat after interruption. */
+    import(records: WorkspaceImport): Promise<WorkspaceSnapshot>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindwire",
-  "version": "0.1.11",
+  "version": "0.1.14",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "devDependencies": {