mindwire 0.1.10 → 0.1.13

package/dist/run.d.ts

@@ -1,7 +1,9 @@
 import type { Http } from "./http.js";
-import type { Event, ResultInfo, RespondInput, Run as RunData } from "./types.js";
+import type { Event, ResultInfo, RespondInput, RunSnapshot, Run as RunData } from "./types.js";
 export interface StreamOptions {
     signal?: AbortSignal;
+    /** Resume after a snapshot/event cursor without replaying earlier output. */
+    after?: number;
     /**
      * Include the daemon's `{ type: "status", meta: { stream: "open" } }` sentinel that is
      * flushed the instant the stream opens (used to detect a live vs. buffered transport).
@@ -73,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>;
     /**
@@ -86,6 +88,8 @@ export declare class Run {
     children(): Promise<Run[]>;
     /** Re-fetch the run record from the daemon and update this handle. */
     refresh(): Promise<RunData>;
+    /** Restore current output once, then follow with `stream({ after: snapshot.sequence })`. */
+    snapshot(): Promise<RunSnapshot>;
     /**
      * Consume the event stream to completion. Returns the final run record and the `result`
      * event's summary (if any). Throws {@link RunFailedError} on an `error`/`cancelled` outcome

package/dist/types.d.ts

@@ -108,6 +108,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. */
@@ -129,6 +131,10 @@ export interface ResultInfo {
 /** The unified stream item. Optional fields are populated per `type`. */
 export interface Event {
     type: EventType;
+    /** Per-run cursor. Subscribe with `stream({ after: sequence })` to receive newer events. */
+    sequence?: number;
+    /** Buffered output from before this stream connection opened. */
+    replay?: boolean;
     /** Text/thinking item identity. A non-delta snapshot replaces this item's earlier text. */
     itemId?: string;
     sessionId?: string;
@@ -189,6 +195,8 @@ export interface ContinuationInfo {
 export interface Action {
     id: string;
     label: string;
+    description?: string;
+    preview?: string;
 }
 export interface TodoItem {
     content: string;
@@ -198,29 +206,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";
@@ -585,6 +613,15 @@ export interface ConditionUX {
 export interface NotificationSpec {
     conditions: ConditionUX[];
 }
+/** Materialized output at an exact stream cursor, shared by all agent harnesses. */
+export interface RunSnapshot {
+    run: Run;
+    sequence: number;
+    parts: Part[];
+    result?: ResultInfo;
+    error?: string;
+    statusMessage?: string;
+}
 /** A paired tool call (use + result) within an assistant turn. */
 export interface ToolPart {
     id?: string;
@@ -786,21 +823,28 @@ 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";
 }
 /** `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
@@ -864,6 +908,10 @@ export interface NotifyChannelTestResult {
 }
 /** `GET /healthz` — the daemon's liveness probe. */
 export interface Health {
+    /** 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.10",
+  "version": "0.1.13",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "devDependencies": {