mindwire 0.1.13 → 0.1.15

package/dist/client.d.ts

@@ -1,6 +1,7 @@
 import { Http, type FetchLike } from "./http.js";
 import { Run } from "./run.js";
 import { WorkspaceApi } from "./workspace.js";
+import { SurfacesApi } from "./surfaces.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, Stats, Subagent, TurnOptions } from "./types.js";
@@ -70,6 +71,7 @@ export interface AgentScoped {
 export declare class Mindwire {
     /** Workspace registry: saved agent profiles, projects and chat relationships. */
     readonly workspace: WorkspaceApi;
+    readonly surfaces: SurfacesApi;
     readonly http: Http;
     /** The default agent type applied to agent-scoped calls, if set. */
     readonly defaultAgent: string | undefined;

package/dist/index.cjs

@@ -383,8 +383,9 @@ var Run = class _Run {
     await this.http.request("POST", `/runs/${encodeURIComponent(this.id)}/cancel`);
   }
   /**
-   * Answer a mid-turn interaction the turn is waiting on — a permission approval, or an
-   * AskUserQuestion / ExitPlanMode reply. Requires the agent's `respond` capability.
+   * Answer a pending permission, question or plan. Message-mode questions remain answerable
+   * after completion; the daemon steers or resumes the conversation. Read the chat's latest
+   * run after replying to a completed run. Requires the agent's `respond` capability.
    */
   async respond(input = {}) {
     await this.http.request("POST", `/runs/${encodeURIComponent(this.id)}/respond`, { body: input });
@@ -583,8 +584,68 @@ var WorkspaceApi = class {
   }
 };
 
+// src/surfaces.ts
+var SurfacesApi = class {
+  constructor(mw) {
+    this.mw = mw;
+  }
+  mw;
+  list() {
+    return this.mw.http.request("GET", "/surfaces");
+  }
+  status(refresh = false) {
+    return this.mw.http.request("GET", "/surfaces/desktop", { query: { refresh } });
+  }
+  bind(binding) {
+    return this.mw.http.request("PUT", "/surfaces/desktop/binding", { body: binding });
+  }
+  open(request) {
+    return this.mw.http.request("POST", "/surfaces/desktop/sessions", { body: request });
+  }
+  control(id, request) {
+    return this.mw.http.request("POST", `/surfaces/desktop/sessions/${encodeURIComponent(id)}/control`, { body: request });
+  }
+  close(id) {
+    return this.mw.http.request("DELETE", `/surfaces/desktop/sessions/${encodeURIComponent(id)}`);
+  }
+  capture(id) {
+    return this.mw.http.request("POST", `/surfaces/desktop/sessions/${encodeURIComponent(id)}/captures`);
+  }
+  action(request) {
+    return this.mw.http.request("POST", "/surfaces/desktop/actions", { body: request });
+  }
+  receipt(id) {
+    return this.mw.http.request("GET", `/surfaces/desktop/actions/${encodeURIComponent(id)}`);
+  }
+  artifact(id) {
+    return this.mw.http.request("GET", `/artifacts/${encodeURIComponent(id)}`);
+  }
+  /** Every connection starts with the current snapshot, then revisions. Never replays input. */
+  async *watch(opts = {}) {
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    opts.signal?.addEventListener("abort", abort, { once: true });
+    if (opts.signal?.aborted) controller.abort();
+    try {
+      const response = await this.mw.http.open("GET", "/surfaces/desktop/events", { signal: controller.signal });
+      let instance;
+      let revision = -1;
+      for await (const snapshot of readSSE(response.body, controller.signal)) {
+        if (instance !== snapshot.instanceId || snapshot.revision > revision) {
+          instance = snapshot.instanceId;
+          revision = snapshot.revision;
+          yield snapshot;
+        }
+      }
+    } finally {
+      controller.abort();
+      opts.signal?.removeEventListener("abort", abort);
+    }
+  }
+};
+
 // src/version.ts
-var SDK_VERSION = "0.1.13" ;
+var SDK_VERSION = "0.1.15" ;
 
 // src/daemon-binary.ts
 function supported(platform, arch) {
@@ -844,6 +905,7 @@ var handleByTransport = /* @__PURE__ */ new WeakMap();
 var Mindwire = class _Mindwire {
   /** Workspace registry: saved agent profiles, projects and chat relationships. */
   workspace;
+  surfaces;
   http;
   /** The default agent type applied to agent-scoped calls, if set. */
   defaultAgent;
@@ -878,6 +940,7 @@ var Mindwire = class _Mindwire {
     });
     this.defaultAgent = opts.agent;
     this.workspace = new WorkspaceApi(this);
+    this.surfaces = new SurfacesApi(this);
     this.auth = new AuthApi(this);
     this.prompts = new PromptsApi(this);
     this.mcp = new McpApi(this);
@@ -899,6 +962,7 @@ var Mindwire = class _Mindwire {
     clone.http = this.http;
     clone.defaultAgent = agent;
     clone.workspace = new WorkspaceApi(clone);
+    clone.surfaces = new SurfacesApi(clone);
     clone.auth = new AuthApi(clone);
     clone.prompts = new PromptsApi(clone);
     clone.mcp = new McpApi(clone);
@@ -1477,32 +1541,36 @@ async function deploy(host, cfg, emit2, token, directory) {
   const BIN = shellQuote(directory + "/mindwired"), BIN_NEW = shellQuote(newPath);
   const STATE = shellQuote(directory + "/agent-state.json"), LOG = shellQuote(directory + "/daemon.log");
   const TOKEN = shellQuote(directory + "/daemon.token");
-  const arch = await probeArch(host);
+  const { platform, arch } = await probePlatform(host);
   const desired = cfg.desiredVersion ?? SDK_VERSION;
   let acquire = "";
   let stagedUpload;
   if (cfg.daemonBin) {
-    const binPath = await resolveLinuxDaemon(cfg.daemonBin, arch);
+    const binPath = await resolveHostDaemon(cfg.daemonBin, platform, arch);
     const bytes = await readBytes(binPath);
-    emit2({ phase: "upload", message: `uploading daemon (${arch}, ${formatMiB(bytes.length)})`, arch, bytes: bytes.length });
+    emit2({ phase: "upload", message: `uploading daemon (${platform}-${arch}, ${formatMiB(bytes.length)})`, platform, arch, bytes: bytes.length });
     stagedUpload = `${newPath}-${(await import('crypto')).randomUUID()}`;
+    await host.exec(["sh", "-lc", `mkdir -p ${shellQuote(directory)}`], { timeoutSeconds: 15 });
     await host.putFile(stagedUpload, bytes, { mode: "0755" });
     acquire = `mv -f ${shellQuote(stagedUpload)} ${BIN_NEW}`;
   } else {
     if (!/^[0-9]+\.[0-9]+\.[0-9]+(?:-[0-9A-Za-z.-]+)?$/.test(desired)) {
       throw new MindwireError(`mindwire: cannot download daemon for non-release SDK version ${desired}`);
     }
-    const asset = `mindwired-v${desired}-linux-${arch === "arm64" ? "arm64" : "amd64"}`;
+    const asset = `mindwired-v${desired}-${platform}-${arch}`;
     const release = `https://github.com/oblien/mindwire/releases/download/v${desired}`;
-    emit2({ phase: "download", message: `downloading daemon v${desired} on the destination (${arch})`, arch });
+    emit2({ phase: "download", message: `downloading daemon v${desired} on the destination (${platform}-${arch})`, platform, arch });
     acquire = [
       `release=${shellQuote(release)}`,
       `asset=${shellQuote(asset)}`,
+      "if command -v sha256sum >/dev/null 2>&1; then mw_sha256=(sha256sum);",
+      "elif command -v shasum >/dev/null 2>&1; then mw_sha256=(shasum -a 256);",
+      'else echo "MINDWIRE_FAIL SHA-256 verification requires sha256sum or shasum"; exit 1; fi',
       "download() {",
       `  expected=$(curl -fsSL "$release/checksums.txt" | awk -v asset="$asset" '$2 == asset { print $1; exit }') || return 1`,
       '  [ -n "$expected" ] || return 1',
       `  curl -fsSL "$release/$asset" -o ${BIN_NEW} || return 1`,
-      `  actual=$(sha256sum ${BIN_NEW} | awk '{print $1}')`,
+      `  actual=$("\${mw_sha256[@]}" ${BIN_NEW} | awk '{print $1}') || return 1`,
       '  [ "$actual" = "$expected" ] || return 2',
       "}",
       "if download; then :; else",
@@ -1510,20 +1578,23 @@ async function deploy(host, cfg, emit2, token, directory) {
       `  latest=$(curl -fsSL https://api.github.com/repos/oblien/mindwire/releases/latest | sed -n 's/.*"tag_name"[[:space:]]*:[[:space:]]*"\\([^"]*\\)".*/\\1/p')`,
       '  case "$latest" in v[0-9]*.[0-9]*.[0-9]*) ;; *) echo "MINDWIRE_FAIL no matching or latest release"; exit 1 ;; esac',
       '  release="https://github.com/oblien/mindwire/releases/download/$latest"',
-      `  asset="mindwired-$latest-linux-${arch === "arm64" ? "arm64" : "amd64"}"`,
+      `  asset="mindwired-$latest-${platform}-${arch}"`,
       '  download || { echo "MINDWIRE_FAIL latest release download failed"; exit 1; }',
       "fi",
       `chmod +x ${BIN_NEW}`
     ].join("\n");
   }
   const script = [
-    "set -e",
+    "set -eo pipefail",
     `mkdir -p ${shellQuote(directory)}`,
     // iOS takes this same workspace lock. Unique staging also protects concurrent local uploads.
     stagedUpload ? `trap ${shellQuote(`rm -f ${shellQuote(stagedUpload)}`)} EXIT` : "",
-    'command -v flock >/dev/null 2>&1 || { echo "MINDWIRE_FAIL flock is required to lock daemon updates"; exit 1; }',
     `exec 9>${shellQuote(directory + "/daemon-install.lock")}`,
-    'flock -w 360 9 || { echo "MINDWIRE_FAIL another daemon update is still running"; exit 1; }',
+    "if command -v flock >/dev/null 2>&1; then",
+    '  flock -w 360 9 || { echo "MINDWIRE_FAIL another daemon update is still running"; exit 1; }',
+    "elif command -v lockf >/dev/null 2>&1; then",
+    '  lockf -s -t 360 9 || { echo "MINDWIRE_FAIL another daemon update is still running"; exit 1; }',
+    'else echo "MINDWIRE_FAIL No supported update lock is available (flock on Linux, lockf on macOS)."; exit 1; fi',
     `mw_token=${shellQuote(token)}`,
     !cfg.token ? `if [ -s ${TOKEN} ]; then mw_token=$(cat ${TOKEN}); fi` : "",
     !cfg.forceDeploy ? [
@@ -1531,6 +1602,10 @@ async function deploy(host, cfg, emit2, token, directory) {
       `mw_version=$(printf '%s' "$mw_health" | sed -n 's/.*"version"[[:space:]]*:[[:space:]]*"\\([^" ]*\\)".*/\\1/p')`,
       `if [ -n "$mw_health" ] && ${cfg.autoUpdate ? `[ "$mw_version" = ${shellQuote(desired)} ]` : "true"}; then echo MINDWIRE_READY; exit 0; fi`
     ].join("\n") : "",
+    // macOS ships POSIX setsid in Perl, but does not include Linux's setsid executable.
+    "if command -v setsid >/dev/null 2>&1; then mw_detach=(setsid);",
+    `elif command -v perl >/dev/null 2>&1; then mw_detach=(perl -MPOSIX -e 'defined(my $sid = POSIX::setsid()) && $sid >= 0 or die "setsid: $!"; exec @ARGV; die "exec: $!";');`,
+    'else echo "MINDWIRE_FAIL Cannot start the Mindwire service: setsid or Perl is required."; exit 1; fi',
     acquire,
     // Stop a prior daemon by exact process NAME, never `pkill -f <path>`: this whole script (which
     // contains `${BIN}` several times) is the argv of the `bash -lc` shell running it, so a full-cmdline
@@ -1550,11 +1625,21 @@ async function deploy(host, cfg, emit2, token, directory) {
     `mv -f ${BIN_NEW} ${BIN}`,
     `chmod +x ${BIN}`,
     // Detach so the daemon survives this exec's shell exiting. ADDR=":<port>" binds 0.0.0.0.
-    `setsid nohup env ADDR=":${cfg.port}" AGENT_TYPE=${shellQuote(cfg.agent)} AGENT_CWD=${shellQuote(cfg.agentCwd)} STATE_PATH=${STATE} DAEMON_TOKEN="$mw_token" ${BIN} > ${LOG} 2>&1 < /dev/null 9>&- &`,
+    // Ignore HUP directly: macOS nohup can fail after setsid in a headless workspace.
+    `"\${mw_detach[@]}" /bin/sh -c 'trap "" HUP; exec "$@"' mindwire-service env ADDR=":${cfg.port}" AGENT_TYPE=${shellQuote(cfg.agent)} AGENT_CWD=${shellQuote(cfg.agentCwd)} STATE_PATH=${STATE} DAEMON_TOKEN="$mw_token" ${BIN} > ${LOG} 2>&1 < /dev/null 9>&- &`,
     // Health-poll from inside the VM (loopback) and emit a marker — exit codes are unreliable here.
-    `for i in $(seq 1 60); do curl -fsS --max-time 2 -H "Authorization: Bearer $mw_token" http://127.0.0.1:${cfg.port}/healthz >/dev/null 2>&1 && { echo MINDWIRE_READY; exit 0; }; sleep 0.25; done`,
-    "echo MINDWIRE_FAIL",
-    `tail -n 40 ${LOG} 2>/dev/null || true`
+    'mw_pid=$!; mw_exit=""; mw_deadline=$((SECONDS + 30))',
+    `while (( SECONDS < mw_deadline )); do curl -fsS --connect-timeout 2 --max-time 3 -H "Authorization: Bearer $mw_token" http://127.0.0.1:${cfg.port}/healthz >/dev/null 2>&1 && { echo MINDWIRE_READY; exit 0; };`,
+    '  if [ -z "$mw_exit" ] && ! kill -0 "$mw_pid" 2>/dev/null; then',
+    '    mw_exit=0; wait "$mw_pid" || mw_exit=$?; [ "$mw_exit" = 0 ] || break',
+    "  fi",
+    "  sleep 0.25",
+    "done",
+    `mw_tail=$(tail -n 40 ${LOG} 2>/dev/null || true)`,
+    'if [ -n "$mw_exit" ] && [ "$mw_exit" != 0 ]; then mw_reason="Mindwire exited during startup (status $mw_exit).";',
+    'else mw_reason="The Mindwire service did not become ready."; fi',
+    '[ -z "$mw_tail" ] || mw_reason="$mw_reason $mw_tail"',
+    'printf "MINDWIRE_FAIL %s\\n" "$mw_reason"'
   ].join("\n");
   emit2({ phase: "launch", message: "launching daemon" });
   const res = await host.exec(["bash", "-lc", script], { timeoutSeconds: 420 });
@@ -1578,10 +1663,15 @@ async function probeHealth(host, port, token) {
     return { reachable: true };
   }
 }
-async function probeArch(host) {
-  const res = await host.exec(["bash", "-lc", `printf '<<ARCH:%s>>' "$(uname -m)"`], { timeoutSeconds: 15 });
-  const raw = ((res.stdout ?? "").match(/<<ARCH:([^>]*)>>/)?.[1] ?? "").trim();
-  return raw === "aarch64" || raw === "arm64" ? "arm64" : "amd64";
+async function probePlatform(host) {
+  const res = await host.exec(["bash", "-lc", `printf '<<OS:%s>><<ARCH:%s>>' "$(uname -s)" "$(uname -m)"`], { timeoutSeconds: 15 });
+  const os = ((res.stdout ?? "").match(/<<OS:([^>]*)>>/)?.[1] ?? "").trim().toLowerCase();
+  const rawArch = ((res.stdout ?? "").match(/<<ARCH:([^>]*)>>/)?.[1] ?? "").trim();
+  const arch = rawArch === "aarch64" || rawArch === "arm64" ? "arm64" : rawArch === "x86_64" || rawArch === "amd64" ? "amd64" : void 0;
+  if (os !== "linux" && os !== "darwin" || !arch) {
+    throw new MindwireError(`mindwire: unsupported workspace platform ${os || "unknown"}/${rawArch || "unknown"}; expected Linux or macOS on amd64 or arm64`);
+  }
+  return { platform: os, arch };
 }
 async function waitHostReady(host, timeoutMs = 6e4) {
   const deadline = Date.now() + timeoutMs;
@@ -1601,15 +1691,18 @@ async function waitHostReady(host, timeoutMs = 6e4) {
   );
 }
 async function resolveLinuxDaemon(explicit, arch) {
+  return resolveHostDaemon(explicit, "linux", arch);
+}
+async function resolveHostDaemon(explicit, platform, arch) {
   const fs = await import('fs');
   if (explicit) {
-    const resolved = explicit.replaceAll("{arch}", arch);
+    const resolved = explicit.replaceAll("{os}", platform).replaceAll("{arch}", arch);
     if (!fs.existsSync(resolved)) {
       throw new MindwireError(`mindwire: sandbox daemonBin not found at ${resolved}`);
     }
     return resolved;
   }
-  return ensureDaemonBinary({ platform: "linux", arch: arch === "arm64" ? "arm64" : "x64" });
+  return ensureDaemonBinary({ platform, arch: arch === "arm64" ? "arm64" : "x64" });
 }
 async function readBytes(p) {
   const fs = await import('fs/promises');
@@ -2477,6 +2570,7 @@ exports.ProvidersApi = ProvidersApi;
 exports.Run = Run;
 exports.RunFailedError = RunFailedError;
 exports.SDK_VERSION = SDK_VERSION;
+exports.SurfacesApi = SurfacesApi;
 exports.TimeoutError = TimeoutError;
 exports.WorkspaceApi = WorkspaceApi;
 exports.WorkspaceCollection = WorkspaceCollection;