mindwire 0.1.13 → 0.1.14

package/dist/index.d.ts

@@ -35,3 +35,4 @@ export * from "./types.js";
 export { WorkspaceApi, WorkspaceCollection, ProjectOperationsApi } from "./workspace.js";
 export type { ProjectRequest, ProjectAuth, ProjectOperation, ProjectRemoveRequest } from "./workspace.js";
 export type { WorkspaceRecord, WorkspaceAgent, WorkspaceProject, WorkspaceChat, WorkspaceKind, WorkspaceInput, WorkspaceImport, WorkspaceSnapshot } from "./workspace.js";
+export * from "./surfaces.js";

package/dist/index.js

@@ -580,8 +580,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.14" ;
 
 // src/daemon-binary.ts
 function supported(platform, arch) {
@@ -841,6 +901,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;
@@ -875,6 +936,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);
@@ -896,6 +958,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);
@@ -1474,32 +1537,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",
@@ -1507,20 +1574,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 ? [
@@ -1528,6 +1598,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
@@ -1547,9 +1621,9 @@ 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>&- &`,
+    `"\${mw_detach[@]}" 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>&- &`,
     // 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`,
+    `for ((mw_attempt=0; mw_attempt<60; mw_attempt++)); 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`
   ].join("\n");
@@ -1575,10 +1649,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;
@@ -1598,15 +1677,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');
@@ -2459,6 +2541,6 @@ function clearCatalogCache() {
   inflight = null;
 }
 
-export { ApiError, AuthApi, ContainerHost, Http, MODELS_DEV_URL, McpApi, Mindwire, MindwireError, NotifyApi, ProjectOperationsApi, PromptsApi, ProvidersApi, Run, RunFailedError, SDK_VERSION, TimeoutError, WorkspaceApi, WorkspaceCollection, catalogModels, catalogProvider, catalogProviders, clearCatalogCache, docker, ensureDaemon, ensureDaemonBinary, loadCatalog, local, lookupModel, oblien, provisionContainer, provisionDocker, provisionOblien, provisionSsh, provisionSshContainer, remote, resolveLinuxDaemon, ssh, startEmbedded };
+export { ApiError, AuthApi, ContainerHost, Http, MODELS_DEV_URL, McpApi, Mindwire, MindwireError, NotifyApi, ProjectOperationsApi, PromptsApi, ProvidersApi, Run, RunFailedError, SDK_VERSION, SurfacesApi, TimeoutError, WorkspaceApi, WorkspaceCollection, catalogModels, catalogProvider, catalogProviders, clearCatalogCache, docker, ensureDaemon, ensureDaemonBinary, loadCatalog, local, lookupModel, oblien, provisionContainer, provisionDocker, provisionOblien, provisionSsh, provisionSshContainer, remote, resolveLinuxDaemon, ssh, startEmbedded };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map