mindwire 0.1.18 → 0.1.22

package/dist/index.cjs

@@ -1,61 +1,136 @@
 'use strict';
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
 // src/errors.ts
-var MindwireError = class extends Error {
-  constructor(message, options) {
-    super(message, options);
-    this.name = "MindwireError";
+exports.MindwireError = void 0; exports.ApiError = void 0; exports.RunFailedError = void 0; exports.TimeoutError = void 0;
+var init_errors = __esm({
+  "src/errors.ts"() {
+    exports.MindwireError = class extends Error {
+      constructor(message, options) {
+        super(message, options);
+        this.name = "MindwireError";
+      }
+    };
+    exports.ApiError = class _ApiError extends exports.MindwireError {
+      status;
+      url;
+      method;
+      body;
+      constructor(args) {
+        super(_ApiError.messageFor(args));
+        this.name = "ApiError";
+        this.status = args.status;
+        this.url = args.url;
+        this.method = args.method;
+        this.body = args.body;
+      }
+      static messageFor({
+        status,
+        method,
+        url,
+        body
+      }) {
+        const detail = body && typeof body === "object" && "error" in body && typeof body.error === "string" ? body.error : typeof body === "string" && body.trim() !== "" ? body.trim() : "";
+        const base = `${method} ${url} failed with ${status}`;
+        return detail ? `${base}: ${detail}` : base;
+      }
+    };
+    exports.RunFailedError = class extends exports.MindwireError {
+      status;
+      runId;
+      constructor(runId, status, detail) {
+        super(detail ? `run ${runId} ${status}: ${detail}` : `run ${runId} ${status}`);
+        this.name = "RunFailedError";
+        this.runId = runId;
+        this.status = status;
+      }
+    };
+    exports.TimeoutError = class extends exports.MindwireError {
+      method;
+      path;
+      timeoutMs;
+      constructor(method, path, timeoutMs) {
+        super(`mindwire: ${method} ${path} timed out after ${timeoutMs}ms`);
+        this.name = "TimeoutError";
+        this.method = method;
+        this.path = path;
+        this.timeoutMs = timeoutMs;
+      }
+    };
   }
-};
-var ApiError = class _ApiError extends MindwireError {
-  status;
-  url;
-  method;
-  body;
-  constructor(args) {
-    super(_ApiError.messageFor(args));
-    this.name = "ApiError";
-    this.status = args.status;
-    this.url = args.url;
-    this.method = args.method;
-    this.body = args.body;
-  }
-  static messageFor({
-    status,
-    method,
-    url,
-    body
-  }) {
-    const detail = body && typeof body === "object" && "error" in body && typeof body.error === "string" ? body.error : typeof body === "string" && body.trim() !== "" ? body.trim() : "";
-    const base = `${method} ${url} failed with ${status}`;
-    return detail ? `${base}: ${detail}` : base;
+});
+
+// src/binary-cache.ts
+var binary_cache_exports = {};
+__export(binary_cache_exports, {
+  binaryCacheDirectory: () => binaryCacheDirectory,
+  cacheExecutable: () => cacheExecutable,
+  cachedExecutable: () => cachedExecutable,
+  executableChecksum: () => executableChecksum,
+  verifyReleaseBytes: () => verifyReleaseBytes
+});
+async function binaryCacheDirectory(platform = process.platform) {
+  const path = await import('path');
+  const { homedir } = await import('os');
+  const homeDirectory = homedir();
+  return platform === "darwin" ? path.join(homeDirectory, "Library", "Caches", "mindwire") : platform === "win32" ? path.join(process.env.LOCALAPPDATA ?? homeDirectory, "mindwire", "Cache") : path.join(process.env.XDG_CACHE_HOME ?? path.join(homeDirectory, ".cache"), "mindwire");
+}
+async function executableChecksum(bytes) {
+  const { createHash } = await import('crypto');
+  return createHash("sha256").update(bytes).digest("hex");
+}
+async function verifyReleaseBytes(bytes, expected, name) {
+  if (!/^[a-f0-9]{64}$/i.test(expected) || await executableChecksum(bytes) !== expected.toLowerCase()) {
+    throw new exports.MindwireError(`mindwire: checksum verification failed for ${name}`);
   }
-};
-var RunFailedError = class extends MindwireError {
-  status;
-  runId;
-  constructor(runId, status, detail) {
-    super(detail ? `run ${runId} ${status}: ${detail}` : `run ${runId} ${status}`);
-    this.name = "RunFailedError";
-    this.runId = runId;
-    this.status = status;
+}
+async function cachedExecutable(bin) {
+  const fs = await import('fs/promises');
+  try {
+    const [bytes, checksum] = await Promise.all([fs.readFile(bin), fs.readFile(`${bin}.sha256`, "utf8")]);
+    await verifyReleaseBytes(bytes, checksum.trim(), bin);
+    return bin;
+  } catch {
+    return void 0;
   }
-};
-var TimeoutError = class extends MindwireError {
-  method;
-  path;
-  timeoutMs;
-  constructor(method, path, timeoutMs) {
-    super(`mindwire: ${method} ${path} timed out after ${timeoutMs}ms`);
-    this.name = "TimeoutError";
-    this.method = method;
-    this.path = path;
-    this.timeoutMs = timeoutMs;
+}
+async function cacheExecutable(bin, bytes, expected) {
+  await verifyReleaseBytes(bytes, expected, bin);
+  const fs = await import('fs/promises');
+  const { dirname } = await import('path');
+  const { randomUUID } = await import('crypto');
+  await fs.mkdir(dirname(bin), { recursive: true, mode: 448 });
+  const temp = `${bin}.${randomUUID()}.tmp`;
+  try {
+    await fs.writeFile(temp, bytes, { mode: 493, flag: "wx" });
+    await fs.writeFile(`${temp}.sha256`, `${expected.toLowerCase()}
+`, { mode: 384, flag: "wx" });
+    await fs.rename(temp, bin);
+    await fs.rename(`${temp}.sha256`, `${bin}.sha256`);
+    return bin;
+  } finally {
+    await fs.rm(temp, { force: true });
+    await fs.rm(`${temp}.sha256`, { force: true });
   }
-};
+}
+var init_binary_cache = __esm({
+  "src/binary-cache.ts"() {
+    init_errors();
+  }
+});
 
 // src/http.ts
+init_errors();
 var DEFAULT_TIMEOUT_MS = 12e4;
 function isAbortError(e) {
   return typeof e === "object" && e !== null && e.name === "AbortError";
@@ -70,7 +145,7 @@ var Http = class {
   constructor(opts) {
     const f = opts.fetch ?? globalThis.fetch;
     if (!f) {
-      throw new MindwireError(
+      throw new exports.MindwireError(
         "mindwire: no global fetch found \u2014 pass a `fetch` implementation in the client options"
       );
     }
@@ -93,7 +168,7 @@ var Http = class {
         };
       };
     } else {
-      throw new MindwireError("mindwire: Http requires a baseUrl or a resolveBase");
+      throw new exports.MindwireError("mindwire: Http requires a baseUrl or a resolveBase");
     }
   }
   /**
@@ -107,7 +182,7 @@ var Http = class {
     } catch (e) {
       const aborted = init.signal?.aborted ?? false;
       if (aborted || isAbortError(e)) throw e;
-      throw new MindwireError(`mindwire: ${method} ${path} \u2014 network request failed`, { cause: e });
+      throw new exports.MindwireError(`mindwire: ${method} ${path} \u2014 network request failed`, { cause: e });
     }
   }
   /**
@@ -134,7 +209,7 @@ var Http = class {
     try {
       return await this.fetchOnce(f, url, { ...init, signal: ctrl.signal }, method, path);
     } catch (e) {
-      if (timedOut) throw new TimeoutError(method, path, this.timeoutMs);
+      if (timedOut) throw new exports.TimeoutError(method, path, this.timeoutMs);
       if (userSignal?.aborted) throw userSignal.reason ?? e;
       throw e;
     } finally {
@@ -215,7 +290,7 @@ var Http = class {
     try {
       return JSON.parse(text);
     } catch (e) {
-      throw new MindwireError(`mindwire: ${method} ${path} returned a non-JSON body`, { cause: e });
+      throw new exports.MindwireError(`mindwire: ${method} ${path} returned a non-JSON body`, { cause: e });
     }
   }
   /** Open a streaming response (SSE). Caller owns the body. */
@@ -229,7 +304,8 @@ var Http = class {
       url,
       {
         method,
-        headers: this.headers(await this.authToken(base, force), extra),
+        headers: this.headers(await this.authToken(base, force), extra, init.body !== void 0),
+        ...init.body !== void 0 ? { body: JSON.stringify(init.body) } : {},
         ...init.signal ? { signal: init.signal } : {}
       },
       method,
@@ -239,7 +315,7 @@ var Http = class {
     if (res.status === 401 && base.getToken) res = await send(true);
     if (!res.ok) throw await this.toApiError(method, res);
     if (!res.body)
-      throw new MindwireError(`mindwire: ${method} ${path} returned no response body to stream`);
+      throw new exports.MindwireError(`mindwire: ${method} ${path} returned no response body to stream`);
     return res;
   }
   async toApiError(method, res) {
@@ -253,7 +329,7 @@ var Http = class {
       }
     } catch {
     }
-    return new ApiError({ status: res.status, url: res.url, method, body });
+    return new exports.ApiError({ status: res.status, url: res.url, method, body });
   }
 };
 
@@ -321,6 +397,7 @@ function parseEvent(block) {
 }
 
 // src/run.ts
+init_errors();
 var TERMINAL = /* @__PURE__ */ new Set(["done", "error", "cancelled"]);
 var Run = class _Run {
   data;
@@ -464,10 +541,10 @@ var Run = class _Run {
     if (opts.throwOnError !== false) {
       if (TERMINAL.has(run.status)) {
         if (run.status !== "done") {
-          throw new RunFailedError(run.id, run.status, run.error ?? streamError);
+          throw new exports.RunFailedError(run.id, run.status, run.error ?? streamError);
         }
       } else {
-        throw new RunFailedError(
+        throw new exports.RunFailedError(
           run.id,
           run.status,
           streamError ?? "event stream ended before the run reached a terminal state"
@@ -590,6 +667,15 @@ var GitAccessApi = class {
     this.mw = mw;
   }
   mw;
+  /** Reads attribution independently of GitHub authentication. Requires gitIdentityVersion >= 1. */
+  identity(context = {}) {
+    return this.mw.http.request("GET", "/workspace/git/identity", { query: context });
+  }
+  /** Saves settings only; never stages or commits. all_workspaces installs this
+   * workspace's copy of a client-managed default; the client handles fan-out. */
+  setIdentity(update, context = {}) {
+    return this.mw.http.request("PUT", "/workspace/git/identity", { query: context, body: update });
+  }
   state() {
     return this.mw.http.request("GET", "/workspace/git");
   }
@@ -611,7 +697,7 @@ var GitAccessApi = class {
   run(projectId, operation, auth) {
     return this.mw.http.request("POST", `/workspace/projects/${encodeURIComponent(projectId)}/git/${operation}`, { body: { auth } });
   }
-  /** Requires health.gitOperationsVersion >= 1. Acceptance persists before Git runs;
+  /** Requires health.gitOperationsVersion >= 1 (>= 2 for branch changes). Acceptance persists before Git runs;
    * disconnecting only detaches the client. The same ID/intent never runs twice.
    */
   start(projectId, request) {
@@ -621,7 +707,7 @@ var GitAccessApi = class {
     const result = await this.mw.http.request(
       "GET",
       `/workspace/projects/${encodeURIComponent(projectId)}/git/operations`,
-      { query: { active: activeOnly } }
+      { query: { active: activeOnly, actionsVersion: 2 } }
     );
     return result.operations;
   }
@@ -734,13 +820,132 @@ var ServiceApi = class {
   }
 };
 
+// src/execution.ts
+var ExecutionApi = class {
+  constructor(client) {
+    this.client = client;
+    this.terminals = new TerminalsApi(client);
+  }
+  client;
+  terminals;
+  host() {
+    return this.client.http.request("GET", "/workspace/host");
+  }
+  resources() {
+    return this.client.http.request("GET", "/workspace/resources");
+  }
+  files(path = "", query) {
+    return this.client.http.request("GET", "/workspace/files", { query: { path, query } });
+  }
+  read(path) {
+    return this.client.http.request("GET", "/workspace/file", { query: { path } });
+  }
+  write(path, content) {
+    return this.client.http.request("PUT", "/workspace/file", { body: { path, content } });
+  }
+  remove(path) {
+    return this.client.http.request("DELETE", "/workspace/file", { query: { path } });
+  }
+  exec(command, signal) {
+    return this.client.http.request("POST", "/workspace/exec", { body: command, signal });
+  }
+  /** Output data is base64, preserving partial UTF-8 chunks. Cancelling stops this command. */
+  async *stream(command, signal) {
+    const response = await this.client.http.open("POST", "/workspace/exec/stream", { body: command, signal });
+    yield* readSSE(response.body, signal);
+  }
+};
+var TerminalsApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  list(directory) {
+    return this.client.http.request("GET", "/workspace/terminals", { query: { directory } });
+  }
+  open(request) {
+    return this.client.http.request("POST", "/workspace/terminals", { body: request });
+  }
+  get(id) {
+    return this.client.http.request("GET", this.path(id));
+  }
+  close(id) {
+    return this.client.http.request("DELETE", this.path(id));
+  }
+  input(id, input) {
+    return this.client.http.request("POST", `${this.path(id)}/input`, { body: input });
+  }
+  resize(id, columns, rows) {
+    return this.client.http.request("PUT", `${this.path(id)}/size`, { body: { columns, rows } });
+  }
+  /** Detaching only closes the subscription. Resume from the last sequence; reset replaces the screen. */
+  async *events(id, after = 0, signal) {
+    const response = await this.client.http.open("GET", `${this.path(id)}/events`, { query: { after }, signal });
+    yield* readSSE(response.body, signal);
+  }
+  path(id) {
+    return `/workspace/terminals/${encodeURIComponent(id)}`;
+  }
+};
+
+// src/computer.ts
+var ComputerApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  info() {
+    return this.client.http.request("GET", "/computer");
+  }
+  setRoutes(routes) {
+    return this.client.http.request("PUT", "/computer/routes", { body: { routes } });
+  }
+  updateStatus() {
+    return this.client.http.request("GET", "/computer/update");
+  }
+  requestUpdate(version) {
+    return this.client.http.request("POST", "/computer/update", { body: { version } });
+  }
+  invite(routes) {
+    return this.client.http.request("POST", "/computer/pairings", { body: { routes } });
+  }
+  pairing(id) {
+    return this.client.http.request("GET", `/computer/pairings/${encodeURIComponent(id)}`);
+  }
+  completePairing(id, requestId) {
+    return this.client.http.request("POST", `/computer/pairings/${encodeURIComponent(id)}/complete`, { body: { requestId } });
+  }
+  decide(id, requestId, approve) {
+    return this.client.http.request("POST", `/computer/pairings/${encodeURIComponent(id)}/decision`, { body: { requestId, approve } });
+  }
+  devices() {
+    return this.client.http.request("GET", "/computer/devices");
+  }
+  revoke(id) {
+    return this.client.http.request("DELETE", `/computer/devices/${encodeURIComponent(id)}`);
+  }
+};
+function computerPairingURI(invitation) {
+  const bytes = new TextEncoder().encode(JSON.stringify(invitation));
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  const encoded = btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+  return `mindwire://pair?v=1#${encoded}`;
+}
+
+// src/embedded.ts
+init_errors();
+
+// src/daemon-binary.ts
+init_errors();
+
 // src/version.ts
-var SDK_VERSION = "0.1.18" ;
+var SDK_VERSION = "0.1.22" ;
 
 // src/daemon-binary.ts
 function supported(platform, arch) {
   if (!["darwin", "linux", "win32"].includes(platform) || !["x64", "arm64"].includes(arch)) {
-    throw new MindwireError(`mindwire: no daemon release for ${platform}-${arch}`);
+    throw new exports.MindwireError(`mindwire: no daemon release for ${platform}-${arch}`);
   }
 }
 function assetName(version, platform, arch) {
@@ -762,27 +967,19 @@ async function ensureDaemonBinary(opts = {}) {
   const daemonArch = arch;
   const version = opts.version ?? SDK_VERSION;
   if (!/^[0-9]+\.[0-9]+\.[0-9]+(?:-[0-9A-Za-z.-]+)?$/.test(version)) {
-    throw new MindwireError(`mindwire: cannot download daemon for non-release SDK version ${version}`);
+    throw new exports.MindwireError(`mindwire: cannot download daemon for non-release SDK version ${version}`);
   }
-  const fs = await import('fs/promises');
   const path = await import('path');
-  const os = await import('os');
-  const crypto = await import('crypto');
-  const home = os.homedir();
-  const defaultCache = daemonPlatform === "darwin" ? path.join(home, "Library", "Caches", "mindwire") : daemonPlatform === "win32" ? path.join(proc.process?.env?.LOCALAPPDATA ?? home, "mindwire", "Cache") : path.join(proc.process?.env?.XDG_CACHE_HOME ?? path.join(home, ".cache"), "mindwire");
-  const dir = path.join(opts.cacheDir ?? defaultCache, version, `${daemonPlatform}-${daemonArch}`);
+  const { binaryCacheDirectory: binaryCacheDirectory2, cachedExecutable: cachedExecutable2, cacheExecutable: cacheExecutable2 } = await Promise.resolve().then(() => (init_binary_cache(), binary_cache_exports));
+  const dir = path.join(opts.cacheDir ?? await binaryCacheDirectory2(daemonPlatform), version, `${daemonPlatform}-${daemonArch}`);
   const asset = assetName(version, daemonPlatform, daemonArch);
   const bin = path.join(dir, asset);
-  const shaFile = `${bin}.sha256`;
-  try {
-    const [bytes2, expected2] = await Promise.all([fs.readFile(bin), fs.readFile(shaFile, "utf8")]);
-    if (crypto.createHash("sha256").update(bytes2).digest("hex") === expected2.trim()) return bin;
-  } catch {
-  }
+  const cached = await cachedExecutable2(bin);
+  if (cached) return cached;
   const base = (opts.releaseBaseUrl ?? proc.process?.env?.MINDWIRE_RELEASE_BASE_URL ?? "https://github.com/oblien/mindwire/releases/download").replace(/\/$/, "");
   const release = `${base}/v${version}`;
   const request = opts.fetch ?? globalThis.fetch;
-  if (!request) throw new MindwireError("mindwire: fetch is unavailable; set daemonBin or MINDWIRE_DAEMON");
+  if (!request) throw new exports.MindwireError("mindwire: fetch is unavailable; set daemonBin or MINDWIRE_DAEMON");
   const [checksums, binary] = await Promise.all([request(`${release}/checksums.txt`), request(`${release}/${asset}`)]);
   if (!checksums.ok || !binary.ok) {
     if (!opts.releaseBaseUrl && !proc.process?.env?.MINDWIRE_RELEASE_BASE_URL) {
@@ -795,22 +992,12 @@ async function ensureDaemonBinary(opts = {}) {
         }
       }
     }
-    throw new MindwireError(`mindwire: failed to download daemon v${version} for ${daemonPlatform}-${daemonArch}`);
+    throw new exports.MindwireError(`mindwire: failed to download daemon v${version} for ${daemonPlatform}-${daemonArch}`);
   }
   const expected = checksumFor(await checksums.text(), asset);
-  if (!expected) throw new MindwireError(`mindwire: release v${version} has no checksum for ${asset}`);
+  if (!expected) throw new exports.MindwireError(`mindwire: release v${version} has no checksum for ${asset}`);
   const bytes = new Uint8Array(await binary.arrayBuffer());
-  const actual = crypto.createHash("sha256").update(bytes).digest("hex");
-  if (actual !== expected) throw new MindwireError(`mindwire: checksum verification failed for ${asset}`);
-  await fs.mkdir(dir, { recursive: true });
-  const temp = `${bin}.${process.pid}.tmp`;
-  await fs.writeFile(temp, bytes, { mode: 493 });
-  await fs.writeFile(`${shaFile}.${process.pid}.tmp`, `${expected}
-`);
-  await fs.rename(temp, bin);
-  await fs.rename(`${shaFile}.${process.pid}.tmp`, shaFile);
-  if (daemonPlatform !== "win32") await fs.chmod(bin, 493);
-  return bin;
+  return cacheExecutable2(bin, bytes, expected);
 }
 
 // src/embedded.ts
@@ -839,7 +1026,7 @@ function isServerRuntime() {
 }
 async function spawnDaemon(opts) {
   if (!isServerRuntime()) {
-    throw new MindwireError(
+    throw new exports.MindwireError(
       "MindWire embedded mode needs a server runtime (Node/Bun/Deno). In the browser or an edge runtime, pass { baseUrl } to connect to a running daemon."
     );
   }
@@ -935,7 +1122,7 @@ async function waitHealthy(baseUrl, token, getError, resolved, timeoutMs = 15e3)
   while (Date.now() < deadline) {
     const err = getError();
     if (err) {
-      throw new MindwireError(daemonStartError(resolved, err), { cause: err });
+      throw new exports.MindwireError(daemonStartError(resolved, err), { cause: err });
     }
     try {
       const res = await fetch(`${baseUrl}/healthz`, { headers: { Authorization: `Bearer ${token}` } });
@@ -944,7 +1131,7 @@ async function waitHealthy(baseUrl, token, getError, resolved, timeoutMs = 15e3)
     }
     await new Promise((r) => setTimeout(r, 150));
   }
-  throw new MindwireError("mindwire embedded daemon did not become healthy in time.");
+  throw new exports.MindwireError("mindwire embedded daemon did not become healthy in time.");
 }
 
 // src/target/index.ts
@@ -997,6 +1184,8 @@ var Mindwire = class _Mindwire {
   workspace;
   surfaces;
   service;
+  execution;
+  computer;
   http;
   /** The default agent type applied to agent-scoped calls, if set. */
   defaultAgent;
@@ -1033,6 +1222,8 @@ var Mindwire = class _Mindwire {
     this.workspace = new WorkspaceApi(this);
     this.surfaces = new SurfacesApi(this);
     this.service = new ServiceApi(this);
+    this.execution = new ExecutionApi(this);
+    this.computer = new ComputerApi(this);
     this.auth = new AuthApi(this);
     this.prompts = new PromptsApi(this);
     this.mcp = new McpApi(this);
@@ -1056,6 +1247,8 @@ var Mindwire = class _Mindwire {
     clone.workspace = new WorkspaceApi(clone);
     clone.surfaces = new SurfacesApi(clone);
     clone.service = new ServiceApi(clone);
+    clone.execution = new ExecutionApi(clone);
+    clone.computer = new ComputerApi(clone);
     clone.auth = new AuthApi(clone);
     clone.prompts = new PromptsApi(clone);
     clone.mcp = new McpApi(clone);
@@ -1588,7 +1781,11 @@ var NotifyApi = class {
   }
 };
 
+// src/target/ssh.ts
+init_errors();
+
 // src/target/host.ts
+init_errors();
 function versionAtLeast(actual, desired) {
   if (actual === desired) return true;
   if (!actual || !/^\d+\.\d+\.\d+$/.test(actual) || !/^\d+\.\d+\.\d+$/.test(desired)) return false;
@@ -1620,7 +1817,7 @@ async function daemonDirectory(host) {
   const result = await host.exec(["sh", "-lc", 'printf "<<MW_HOME>>%s<<MW_HOME>>" "$HOME"'], { timeoutSeconds: 15 });
   const runtimeHome = result.stdout?.match(/<<MW_HOME>>([\s\S]*?)<<MW_HOME>>/)?.[1];
   if (!runtimeHome?.startsWith("/") || runtimeHome.length > 4096 || /[\x00-\x1f\x7f]/.test(runtimeHome)) {
-    throw new MindwireError("mindwire: cannot resolve the runtime user's home directory");
+    throw new exports.MindwireError("mindwire: cannot resolve the runtime user's home directory");
   }
   return runtimeHome.replace(/\/+$/, "") + "/.mindwire";
 }
@@ -1652,7 +1849,7 @@ async function ensureDaemon(host, cfg) {
         return token;
       }
       if ((health.serviceUpdateVersion ?? 0) < 1) {
-        if (cfg.forceDeploy) throw new MindwireError("This legacy service cannot reserve an idle update. Upgrade it explicitly or stop it after its work finishes before deploying.");
+        if (cfg.forceDeploy) throw new exports.MindwireError("This legacy service cannot reserve an idle update. Upgrade it explicitly or stop it after its work finishes before deploying.");
         emit2({ phase: "skip", message: "automatic update deferred: upgrade this legacy service explicitly to enable idle updates", version: health.version });
         return token;
       }
@@ -1691,7 +1888,7 @@ async function deploy(host, cfg, emit2, token, directory, requireLease) {
     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}`);
+      throw new exports.MindwireError(`mindwire: cannot download daemon for non-release SDK version ${desired}`);
     }
     const asset = `mindwired-v${desired}-${platform}-${arch}`;
     const release = `https://github.com/oblien/mindwire/releases/download/v${desired}`;
@@ -1799,12 +1996,12 @@ async function deploy(host, cfg, emit2, token, directory, requireLease) {
   const res = await host.exec(["bash", "-lc", script], { timeoutSeconds: 420 });
   const out = res.stdout ?? "";
   if (out.includes("MINDWIRE_UPDATE_DEFERRED")) {
-    if (cfg.forceDeploy) throw new MindwireError("The workspace is busy. Wait for its operations to finish before deploying the service.");
+    if (cfg.forceDeploy) throw new exports.MindwireError("The workspace is busy. Wait for its operations to finish before deploying the service.");
     emit2({ phase: "skip", message: "service update deferred while workspace operations are running" });
     return;
   }
   if (!out.includes("MINDWIRE_READY")) {
-    throw new MindwireError(
+    throw new exports.MindwireError(
       "mindwire: the in-sandbox daemon did not become healthy after deploy.\n" + (out || res.stderr || res.error || "(no output)").trim()
     );
   }
@@ -1832,7 +2029,7 @@ async function probePlatform(host) {
   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`);
+    throw new exports.MindwireError(`mindwire: unsupported workspace platform ${os || "unknown"}/${rawArch || "unknown"}; expected Linux or macOS on amd64 or arm64`);
   }
   return { platform: os, arch };
 }
@@ -1848,7 +2045,7 @@ async function waitHostReady(host, timeoutMs = 6e4) {
     }
     await sleep(1e3);
   }
-  throw new MindwireError(
+  throw new exports.MindwireError(
     "mindwire: the sandbox runtime did not become ready in time.",
     lastErr ? { cause: lastErr } : void 0
   );
@@ -1861,7 +2058,7 @@ async function resolveHostDaemon(explicit, platform, arch) {
   if (explicit) {
     const resolved = explicit.replaceAll("{os}", platform).replaceAll("{arch}", arch);
     if (!fs.existsSync(resolved)) {
-      throw new MindwireError(`mindwire: sandbox daemonBin not found at ${resolved}`);
+      throw new exports.MindwireError(`mindwire: sandbox daemonBin not found at ${resolved}`);
     }
     return resolved;
   }
@@ -1882,6 +2079,7 @@ function formatMiB(bytes) {
 }
 
 // src/target/container.ts
+init_errors();
 async function provisionContainer(host, cfg, onLog) {
   const target = cfg.target ?? "container";
   const emit2 = (e) => {
@@ -1944,7 +2142,7 @@ async function ensureDockerReady(host, install, emit2) {
     return;
   }
   if (state.status === "denied") {
-    throw new MindwireError(
+    throw new exports.MindwireError(
       "mindwire: connected to the host, but this user can't reach the Docker daemon socket (permission denied). Connect as root, or add the SSH user to the `docker` group."
     );
   }
@@ -1956,10 +2154,10 @@ async function ensureDockerReady(host, install, emit2) {
       emit2({ phase: "install", message: `docker started (v${state.version ?? "?"})`, version: state.version });
       return;
     }
-    throw new MindwireError("mindwire: Docker is installed on the host but could not be started.");
+    throw new exports.MindwireError("mindwire: Docker is installed on the host but could not be started.");
   }
   if (install !== "ifMissing") {
-    throw new MindwireError(
+    throw new exports.MindwireError(
       'mindwire: Docker is not installed on the remote host, and mindwire won\'t install system packages unless you opt in. Pass docker: { install: "ifMissing" } to have it run the official get.docker.com script (`curl -fsSL https://get.docker.com | sh`) and enable the service \u2014 or install Docker on the host yourself.'
     );
   }
@@ -1968,7 +2166,7 @@ async function ensureDockerReady(host, install, emit2) {
   await startDocker(host);
   state = await detectDocker(host);
   if (state.status !== "running") {
-    throw new MindwireError(
+    throw new exports.MindwireError(
       "mindwire: ran the get.docker.com install script, but the Docker daemon did not come up."
     );
   }
@@ -1995,7 +2193,7 @@ async function installDocker(host) {
     timeoutSeconds: 600
   });
   if ((res.exitCode ?? 0) !== 0) {
-    throw new MindwireError(
+    throw new exports.MindwireError(
       "mindwire: the Docker install script (get.docker.com) failed.\n" + (res.stderr || res.stdout || "(no output)").trim()
     );
   }
@@ -2018,7 +2216,7 @@ async function runContainer(host, cfg, emit2) {
     return { containerId: cfg.container, hostPort: hostPort2, created: false };
   }
   if (!cfg.image) {
-    throw new MindwireError(
+    throw new exports.MindwireError(
       "mindwire: running the daemon in a container needs an image (docker.image) to create one, or an existing container (docker.container) to attach to."
     );
   }
@@ -2030,7 +2228,7 @@ async function runContainer(host, cfg, emit2) {
   const res = await host.exec(runArgs, { timeoutSeconds: 120 });
   const containerId = (res.stdout ?? "").trim().split(/\s+/).pop() ?? "";
   if (!containerId || (res.exitCode ?? 0) !== 0) {
-    throw new MindwireError(
+    throw new exports.MindwireError(
       "mindwire: `docker run` did not start a container.\n" + (res.stderr || res.stdout || "(no output)").trim()
     );
   }
@@ -2046,7 +2244,7 @@ async function resolveHostPort(host, containerId, port) {
   const line = (res.stdout ?? "").split("\n").map((s) => s.trim()).find(Boolean);
   const hostPort = line ? Number.parseInt(line.match(/:(\d+)\s*$/)?.[1] ?? "", 10) : NaN;
   if (!Number.isFinite(hostPort) || hostPort <= 0) {
-    throw new MindwireError(
+    throw new exports.MindwireError(
       `mindwire: could not resolve the published host port for ${port}/tcp on container ${containerId.slice(0, 12)}. ` + cfgHint(res) + `docker port output: ${JSON.stringify((res.stdout ?? "").trim())}`
     );
   }
@@ -2224,7 +2422,7 @@ async function openConnection(mod, opts) {
       if (settled) return;
       settled = true;
       reject(
-        new MindwireError(
+        new exports.MindwireError(
           `mindwire: SSH connection to ${opts.username}@${opts.host}:${opts.port ?? 22} failed: ${err.message}`,
           { cause: err }
         )
@@ -2259,7 +2457,7 @@ async function createTunnel(net, client, daemonPort) {
     client.forwardOut("127.0.0.1", 0, "127.0.0.1", daemonPort, (err, stream) => {
       if (err) {
         reject(
-          new MindwireError(
+          new exports.MindwireError(
             `mindwire: the SSH server refused a port-forward to 127.0.0.1:${daemonPort} (direct-tcpip). Enable \`AllowTcpForwarding yes\` in the remote sshd_config \u2014 mindwire tunnels the daemon's HTTP/SSE over the SSH connection.`,
             { cause: err }
           )
@@ -2323,7 +2521,7 @@ async function importSsh2() {
     );
     return mod.default && mod.default.Client ? mod.default : mod;
   } catch (err) {
-    throw new MindwireError(
+    throw new exports.MindwireError(
       "mindwire: the SSH target needs the optional `ssh2` package. Install it (`npm i ssh2`). It's an optional peer dependency, so the core SDK stays dependency-free.",
       { cause: err }
     );
@@ -2335,6 +2533,7 @@ function env(key) {
 }
 
 // src/target/docker.ts
+init_errors();
 function docker(config = {}) {
   return { name: "docker", connect: (spec) => connectDocker(config, spec) };
 }
@@ -2416,7 +2615,7 @@ async function provisionDocker(docker2, config = {}, onLog) {
   const binding = info.NetworkSettings?.Ports?.[`${port}/tcp`];
   const hostPort = binding?.[0]?.HostPort;
   if (!hostPort) {
-    throw new MindwireError(
+    throw new exports.MindwireError(
       `mindwire: the Docker container does not publish a host port for ${port}/tcp. ` + (created ? "This is unexpected for a container mindwire created." : "Attach to a container started with that port published (e.g. `-p 0:" + port + "`).")
     );
   }
@@ -2468,7 +2667,7 @@ async function ensureImage(docker2, image, policy, onLog) {
   } catch (error) {
     const detail = error instanceof Error ? error.message : String(error);
     emit2(`failed to pull runtime image ${image}`, detail);
-    throw new MindwireError(`mindwire: failed to pull Docker image ${image}: ${detail}`, { cause: error });
+    throw new exports.MindwireError(`mindwire: failed to pull Docker image ${image}: ${detail}`, { cause: error });
   }
 }
 function tarSingleFile(name, data, mode) {
@@ -2502,7 +2701,7 @@ async function importDockerode() {
     );
     return mod.default ?? mod;
   } catch (err) {
-    throw new MindwireError(
+    throw new exports.MindwireError(
       "mindwire: the Docker sandbox adapter needs the optional `dockerode` package. Install it (`npm i dockerode`). It's an optional peer dependency, so the core SDK stays dependency-free.",
       { cause: err }
     );
@@ -2510,6 +2709,7 @@ async function importDockerode() {
 }
 
 // src/target/oblien.ts
+init_errors();
 function oblien(config = {}) {
   return { name: "oblien", connect: (spec) => connectOblien(config, spec) };
 }
@@ -2546,7 +2746,7 @@ async function connectOblien(config, spec) {
   const clientId = config.clientId ?? env2("MINDWIRE_SANDBOX_CLIENT_ID") ?? env2("OBLIEN_CLIENT_ID");
   const clientSecret = config.clientSecret ?? env2("MINDWIRE_SANDBOX_CLIENT_SECRET") ?? env2("OBLIEN_CLIENT_SECRET");
   if (!clientId || !clientSecret) {
-    throw new MindwireError(
+    throw new exports.MindwireError(
       "mindwire: the Oblien target needs credentials \u2014 pass oblien({ clientId, clientSecret }) or set MINDWIRE_SANDBOX_CLIENT_ID / MINDWIRE_SANDBOX_CLIENT_SECRET (OBLIEN_CLIENT_ID / OBLIEN_CLIENT_SECRET are also accepted)."
     );
   }
@@ -2622,7 +2822,7 @@ async function importOblien() {
       spec
     );
   } catch (err) {
-    throw new MindwireError(
+    throw new exports.MindwireError(
       "mindwire: sandbox mode with the default (Oblien) adapter needs the optional `oblien` package. Install it (`npm i oblien`). It's an optional peer dependency, so the core SDK stays dependency-free.",
       { cause: err }
     );
@@ -2718,31 +2918,34 @@ function clearCatalogCache() {
   inflight = null;
 }
 
-exports.ApiError = ApiError;
+// src/index.ts
+init_errors();
+
 exports.AuthApi = AuthApi;
+exports.ComputerApi = ComputerApi;
 exports.ContainerHost = ContainerHost;
+exports.ExecutionApi = ExecutionApi;
 exports.GitAccessApi = GitAccessApi;
 exports.Http = Http;
 exports.MODELS_DEV_URL = MODELS_DEV_URL;
 exports.McpApi = McpApi;
 exports.Mindwire = Mindwire;
-exports.MindwireError = MindwireError;
 exports.NotifyApi = NotifyApi;
 exports.ProjectOperationsApi = ProjectOperationsApi;
 exports.PromptsApi = PromptsApi;
 exports.ProvidersApi = ProvidersApi;
 exports.Run = Run;
-exports.RunFailedError = RunFailedError;
 exports.SDK_VERSION = SDK_VERSION;
 exports.ServiceApi = ServiceApi;
 exports.SurfacesApi = SurfacesApi;
-exports.TimeoutError = TimeoutError;
+exports.TerminalsApi = TerminalsApi;
 exports.WorkspaceApi = WorkspaceApi;
 exports.WorkspaceCollection = WorkspaceCollection;
 exports.catalogModels = catalogModels;
 exports.catalogProvider = catalogProvider;
 exports.catalogProviders = catalogProviders;
 exports.clearCatalogCache = clearCatalogCache;
+exports.computerPairingURI = computerPairingURI;
 exports.docker = docker;
 exports.ensureDaemon = ensureDaemon;
 exports.ensureDaemonBinary = ensureDaemonBinary;