mindwire 0.1.25 → 0.1.26

package/dist/chunk-L3USUTZZ.js

@@ -0,0 +1,2021 @@
+import { MindwireError, TimeoutError, ApiError, RunFailedError } from './chunk-T6TD76UA.js';
+import { execFile, spawn } from 'child_process';
+import * as fs from 'fs/promises';
+import { readFile } from 'fs/promises';
+import { promisify } from 'util';
+import { setTimeout as setTimeout$1 } from 'timers/promises';
+import { randomUUID } from 'crypto';
+import { homedir, networkInterfaces } from 'os';
+import * as path from 'path';
+
+// 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)}`);
+  }
+  forwards() {
+    return this.client.http.request("GET", "/computer/forwards");
+  }
+  /** Authorize a loopback port for this paired device. Renew the same ID every 30s;
+   * grants expire after two minutes. Carry traffic using SSH direct-tcpip. */
+  forward(request) {
+    return this.client.http.request("POST", "/computer/forwards", { body: request });
+  }
+  closeForward(id) {
+    return this.client.http.request("DELETE", `/computer/forwards/${encodeURIComponent(id)}`);
+  }
+};
+function computerPairingQRData(invitation) {
+  return JSON.stringify(invitation);
+}
+function computerPairingURI(invitation) {
+  const bytes = new TextEncoder().encode(computerPairingQRData(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/version.ts
+var SDK_VERSION = "0.1.26" ;
+
+// 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}`);
+  }
+}
+function assetName(version, platform, arch) {
+  const releasePlatform = platform === "win32" ? "windows" : platform;
+  const releaseArch = arch === "x64" ? "amd64" : arch;
+  return `mindwired-v${version}-${releasePlatform}-${releaseArch}${platform === "win32" ? ".exe" : ""}`;
+}
+function checksumFor(text, asset) {
+  const line = text.split("\n").find((l) => l.trim().endsWith(` ${asset}`) || l.trim().endsWith(`  ${asset}`));
+  const hash = line?.trim().split(/\s+/)[0];
+  return hash && /^[a-f0-9]{64}$/i.test(hash) ? hash.toLowerCase() : void 0;
+}
+async function ensureDaemonBinary(opts = {}) {
+  const proc = globalThis;
+  const platform = opts.platform ?? proc.process?.platform;
+  const arch = opts.arch ?? proc.process?.arch;
+  supported(platform ?? "unknown", arch ?? "unknown");
+  const daemonPlatform = platform;
+  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}`);
+  }
+  const path2 = await import('path');
+  const { binaryCacheDirectory, cachedExecutable, cacheExecutable } = await import('./binary-cache-VM7VHCEU.js');
+  const dir = path2.join(opts.cacheDir ?? await binaryCacheDirectory(daemonPlatform), version, `${daemonPlatform}-${daemonArch}`);
+  const asset = assetName(version, daemonPlatform, daemonArch);
+  const bin = path2.join(dir, asset);
+  const cached = await cachedExecutable(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");
+  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) {
+      const latest = await request("https://api.github.com/repos/oblien/mindwire/releases/latest");
+      if (latest.ok) {
+        const tag = (await latest.json()).tag_name;
+        const fallback = typeof tag === "string" ? tag.replace(/^v/, "") : "";
+        if (/^[0-9]+\.[0-9]+\.[0-9]+(?:-[0-9A-Za-z.-]+)?$/.test(fallback) && fallback !== version) {
+          return ensureDaemonBinary({ ...opts, version: fallback });
+        }
+      }
+    }
+    throw new 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}`);
+  const bytes = new Uint8Array(await binary.arrayBuffer());
+  return cacheExecutable(bin, bytes, expected);
+}
+var execute = promisify(execFile);
+function processAlive(pid) {
+  if (!pid || !Number.isSafeInteger(pid) || pid < 1) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function processIdentity(pid) {
+  if (!processAlive(pid)) return void 0;
+  try {
+    let start;
+    if (process.platform === "linux") {
+      const stat2 = await readFile(`/proc/${pid}/stat`, "utf8");
+      const fields = stat2.slice(stat2.lastIndexOf(")") + 2).split(" ");
+      const boot = (await readFile("/proc/sys/kernel/random/boot_id", "utf8")).trim();
+      start = `${boot}:${fields[19]}`;
+    } else if (process.platform === "win32") {
+      const result = await execute("powershell.exe", [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        `(Get-Process -Id ${pid} -ErrorAction Stop).StartTime.ToUniversalTime().Ticks`
+      ], { timeout: 5e3, windowsHide: true });
+      start = result.stdout.trim();
+    } else {
+      const result = await execute("/bin/ps", ["-p", String(pid), "-o", "lstart=", "-o", "comm="], {
+        timeout: 3e3,
+        env: { ...process.env, LC_ALL: "C", TZ: "UTC" }
+      });
+      start = result.stdout.trim();
+    }
+    return start ? { pid, start } : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function currentProcessIdentity() {
+  const identity = await processIdentity(process.pid);
+  if (!identity) throw new Error("Couldn't verify the Mindwire process identity. Retry the command.");
+  return identity;
+}
+async function processStateAlive(state) {
+  if (!state || !processAlive(state.pid)) return false;
+  if (state.start === void 0) return true;
+  const current = await processIdentity(state.pid);
+  if (!current && processAlive(state.pid)) throw new Error("Couldn't verify the running Mindwire process. Retry the command.");
+  return !!state.start && current?.start === state.start;
+}
+async function readProcessState(file) {
+  try {
+    const state = JSON.parse(await readFile(file, "utf8"));
+    if (typeof state === "number") return { pid: state };
+    return state && typeof state.pid === "number" ? state : void 0;
+  } catch (error) {
+    if (error instanceof SyntaxError || error.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+async function ownChild(child) {
+  if (!child.pid) throw new Error("The background process could not start.");
+  const pid = child.pid;
+  const identity = await processIdentity(pid);
+  const alive = () => child.exitCode === null && child.signalCode === null;
+  return { pid, identity, alive, async close() {
+    if (!alive()) return;
+    const exited = new Promise((resolve) => child.once("exit", () => resolve()));
+    child.kill("SIGTERM");
+    const timer = setTimeout(() => {
+      if (alive()) child.kill("SIGKILL");
+    }, 15e3);
+    try {
+      await exited;
+    } finally {
+      clearTimeout(timer);
+    }
+  } };
+}
+async function adoptProcess(identity) {
+  const matches = async () => (await processIdentity(identity.pid))?.start === identity.start;
+  if (!await matches()) return void 0;
+  return { pid: identity.pid, identity, alive: () => processAlive(identity.pid), async close() {
+    if (!await matches()) return;
+    process.kill(identity.pid, "SIGTERM");
+    for (let attempt = 0; attempt < 60; attempt++) {
+      if (!processAlive(identity.pid)) return;
+      await setTimeout$1(250);
+    }
+    if (await matches()) process.kill(identity.pid, "SIGKILL");
+  } };
+}
+
+// src/http.ts
+var DEFAULT_TIMEOUT_MS = 12e4;
+function isAbortError(e) {
+  return typeof e === "object" && e !== null && e.name === "AbortError";
+}
+var Http = class {
+  fetchImpl;
+  baseHeaders;
+  resolver;
+  timeoutMs;
+  cached = null;
+  pending = null;
+  constructor(opts) {
+    const f = opts.fetch ?? globalThis.fetch;
+    if (!f) {
+      throw new MindwireError(
+        "mindwire: no global fetch found \u2014 pass a `fetch` implementation in the client options"
+      );
+    }
+    this.fetchImpl = f;
+    this.baseHeaders = { ...opts.headers };
+    this.timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    if (opts.baseUrl) {
+      const base = { baseUrl: opts.baseUrl.replace(/\/+$/, ""), token: opts.token };
+      this.resolver = async () => base;
+    } else if (opts.resolveBase) {
+      const rb = opts.resolveBase;
+      this.resolver = async () => {
+        const r = await rb();
+        return {
+          baseUrl: r.baseUrl.replace(/\/+$/, ""),
+          token: r.token ?? opts.token,
+          getToken: r.getToken,
+          headers: r.headers,
+          fetch: r.fetch
+        };
+      };
+    } else {
+      throw new MindwireError("mindwire: Http requires a baseUrl or a resolveBase");
+    }
+  }
+  /**
+   * One fetch, with raw network failures wrapped as {@link MindwireError} so callers see a typed
+   * SDK error instead of a bare `TypeError: fetch failed`. An abort (the request's own signal, or
+   * our timeout controller) is re-thrown untouched — `fetchWithTimeout` classifies it.
+   */
+  async fetchOnce(f, url, init, method, path2) {
+    try {
+      return await f(url, init);
+    } catch (e) {
+      const aborted = init.signal?.aborted ?? false;
+      if (aborted || isAbortError(e)) throw e;
+      throw new MindwireError(`mindwire: ${method} ${path2} \u2014 network request failed`, { cause: e });
+    }
+  }
+  /**
+   * `fetchOnce` plus a timeout that composes with the caller's `signal`. A hand-rolled controller
+   * (not `AbortSignal.timeout`/`AbortSignal.any`, which need Node 20.3+/18.17+) fires after
+   * `timeoutMs`; whichever aborts first wins. Timeout → {@link TimeoutError}; the caller's own abort
+   * propagates as-is (its `reason`). `timeoutMs<=0` disables the deadline entirely.
+   */
+  async fetchWithTimeout(f, url, init, userSignal, method, path2) {
+    if (!this.timeoutMs || this.timeoutMs <= 0) {
+      return this.fetchOnce(f, url, { ...init, ...userSignal ? { signal: userSignal } : {} }, method, path2);
+    }
+    const ctrl = new AbortController();
+    const onAbort = () => ctrl.abort(userSignal?.reason);
+    if (userSignal) {
+      if (userSignal.aborted) ctrl.abort(userSignal.reason);
+      else userSignal.addEventListener("abort", onAbort, { once: true });
+    }
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      ctrl.abort();
+    }, this.timeoutMs);
+    try {
+      return await this.fetchOnce(f, url, { ...init, signal: ctrl.signal }, method, path2);
+    } catch (e) {
+      if (timedOut) throw new TimeoutError(method, path2, this.timeoutMs);
+      if (userSignal?.aborted) throw userSignal.reason ?? e;
+      throw e;
+    } finally {
+      clearTimeout(timer);
+      if (userSignal) userSignal.removeEventListener("abort", onAbort);
+    }
+  }
+  /**
+   * The bearer token for the next request. Prefers the transport's dynamic `getToken` (which
+   * caches and mints on demand); falls back to the static token resolved at base time. `force`
+   * asks the getter to re-mint — used once on a 401 before retrying.
+   */
+  async authToken(base, force) {
+    if (base.getToken) {
+      const t = await base.getToken(force ? { force: true } : void 0);
+      return t ?? base.token;
+    }
+    return base.token;
+  }
+  base() {
+    if (this.cached) return Promise.resolve(this.cached);
+    if (!this.pending) {
+      this.pending = this.resolver().then((b) => this.cached = b).catch((err) => {
+        this.pending = null;
+        throw err;
+      });
+    }
+    return this.pending;
+  }
+  /**
+   * Resolve the base eagerly and memoize it — provisions the transport (spawns the embedded daemon,
+   * connects the sandbox/SSH/Docker target, …) now instead of on the first request. Idempotent: this
+   * awaits the *same* memoized promise the first `request()`/`open()` awaits, so the target's
+   * `connect()` fires exactly once. Backs {@link import("./client.js").Mindwire.ensure}.
+   */
+  async ready() {
+    await this.base();
+  }
+  url(baseUrl, path2, query) {
+    const u = new URL(baseUrl + (path2.startsWith("/") ? path2 : `/${path2}`));
+    if (query) {
+      for (const [k, v] of Object.entries(query)) {
+        if (v !== void 0) u.searchParams.set(k, String(v));
+      }
+    }
+    return u.toString();
+  }
+  headers(token, extra, hasBody = false) {
+    const h = { Accept: "application/json", ...this.baseHeaders, ...extra };
+    if (token) h["Authorization"] = `Bearer ${token}`;
+    if (hasBody) h["Content-Type"] = "application/json";
+    return h;
+  }
+  async request(method, path2, init = {}) {
+    const base = await this.base();
+    const hasBody = init.body !== void 0;
+    const url = this.url(base.baseUrl, path2, init.query);
+    const extra = { ...base.headers, ...init.headers };
+    const f = base.fetch ?? this.fetchImpl;
+    const send = async (force) => this.fetchWithTimeout(
+      f,
+      url,
+      {
+        method,
+        headers: this.headers(await this.authToken(base, force), extra, hasBody),
+        body: hasBody ? JSON.stringify(init.body) : void 0
+      },
+      init.signal,
+      method,
+      path2
+    );
+    let res = await send(false);
+    if (res.status === 401 && base.getToken) res = await send(true);
+    if (!res.ok) throw await this.toApiError(method, res);
+    if (res.status === 204) return void 0;
+    const text = await res.text();
+    if (text === "") return void 0;
+    try {
+      return JSON.parse(text);
+    } catch (e) {
+      throw new MindwireError(`mindwire: ${method} ${path2} returned a non-JSON body`, { cause: e });
+    }
+  }
+  /** Open a streaming response (SSE). Caller owns the body. */
+  async open(method, path2, init = {}) {
+    const base = await this.base();
+    const url = this.url(base.baseUrl, path2, init.query);
+    const extra = { Accept: "text/event-stream", ...base.headers, ...init.headers };
+    const f = base.fetch ?? this.fetchImpl;
+    const send = async (force) => this.fetchOnce(
+      f,
+      url,
+      {
+        method,
+        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,
+      path2
+    );
+    let res = await send(false);
+    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} ${path2} returned no response body to stream`);
+    return res;
+  }
+  async toApiError(method, res) {
+    let body = "";
+    try {
+      const text = await res.text();
+      try {
+        body = text ? JSON.parse(text) : "";
+      } catch {
+        body = text;
+      }
+    } catch {
+    }
+    return new ApiError({ status: res.status, url: res.url, method, body });
+  }
+};
+
+// src/sse.ts
+async function* readSSE(body, signal) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  const onAbort = () => void reader.cancel().catch(() => {
+  });
+  if (signal) {
+    if (signal.aborted) {
+      await reader.cancel().catch(() => {
+      });
+      return;
+    }
+    signal.addEventListener("abort", onAbort, { once: true });
+  }
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let sep;
+      while ((sep = indexOfBlankLine(buffer)) !== -1) {
+        const rawEvent = buffer.slice(0, sep);
+        buffer = buffer.slice(sepEnd(buffer, sep));
+        const payload2 = parseEvent(rawEvent);
+        if (payload2 !== void 0) yield JSON.parse(payload2);
+      }
+    }
+    const payload = parseEvent(buffer);
+    if (payload !== void 0) yield JSON.parse(payload);
+  } finally {
+    if (signal) signal.removeEventListener("abort", onAbort);
+    await reader.cancel().catch(() => {
+    });
+    reader.releaseLock();
+  }
+}
+function indexOfBlankLine(s) {
+  const a = s.indexOf("\n\n");
+  const b = s.indexOf("\r\n\r\n");
+  if (a === -1) return b;
+  if (b === -1) return a;
+  return Math.min(a, b);
+}
+function sepEnd(s, idx) {
+  return s.startsWith("\r\n\r\n", idx) ? idx + 4 : idx + 2;
+}
+function parseEvent(block) {
+  const lines = block.split(/\r\n|\n/);
+  const data = [];
+  for (const line of lines) {
+    if (line === "" || line.startsWith(":")) continue;
+    const colon = line.indexOf(":");
+    const field = colon === -1 ? line : line.slice(0, colon);
+    if (field !== "data") continue;
+    let value = colon === -1 ? "" : line.slice(colon + 1);
+    if (value.startsWith(" ")) value = value.slice(1);
+    data.push(value);
+  }
+  if (data.length === 0) return void 0;
+  return data.join("\n");
+}
+
+// src/run.ts
+var TERMINAL = /* @__PURE__ */ new Set(["done", "error", "cancelled"]);
+var Run = class _Run {
+  data;
+  http;
+  constructor(http, data) {
+    this.http = http;
+    this.data = data;
+  }
+  get id() {
+    return this.data.id;
+  }
+  get chatId() {
+    return this.data.chatId;
+  }
+  get agent() {
+    return this.data.agent;
+  }
+  get status() {
+    return this.data.status;
+  }
+  /** `"resolve"` on the parent of a global-resolve run; `undefined` for an ordinary turn. */
+  get kind() {
+    return this.data.kind;
+  }
+  /** On a child iteration of a resolve run, the id of its parent resolve run; else `undefined`. */
+  get parentId() {
+    return this.data.parentId;
+  }
+  /** Parent of a resolve run only: why the loop ended (`"done"` | `"capped"` | `"error"` | …). */
+  get stopReason() {
+    return this.data.stopReason;
+  }
+  /** Parent of a resolve run only: how many child turns the loop ran. */
+  get iterations() {
+    return this.data.iterations;
+  }
+  /** The latest known run record. */
+  get value() {
+    return this.data;
+  }
+  /** Unified SSE event stream: replay buffer, then live events, then close. */
+  async *stream(opts = {}) {
+    const cursor = opts.after === void 0 ? "" : `?after=${encodeURIComponent(opts.after)}`;
+    const res = await this.http.open("GET", `/runs/${encodeURIComponent(this.id)}/stream${cursor}`, {
+      ...opts.signal ? { signal: opts.signal } : {}
+    });
+    for await (const ev of readSSE(res.body, opts.signal)) {
+      if (!opts.includeOpenSentinel && ev.type === "status" && ev.meta?.["stream"] === "open") {
+        continue;
+      }
+      yield ev;
+    }
+  }
+  /** `for await (const ev of run)` — sugar for `run.stream()`. */
+  [Symbol.asyncIterator]() {
+    return this.stream();
+  }
+  /** Cancel the in-flight turn (kills the underlying agent process). */
+  async cancel() {
+    await this.http.request("POST", `/runs/${encodeURIComponent(this.id)}/cancel`);
+  }
+  /**
+   * 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 });
+  }
+  /**
+   * Steer a follow-up message into the running turn without cancelling it. Requires the agent's
+   * `input` capability.
+   */
+  async sendInput(text) {
+    await this.http.request("POST", `/runs/${encodeURIComponent(this.id)}/input`, { body: { text } });
+  }
+  /**
+   * Soft-stop the running turn (ask the agent to halt current work) without the hard process kill
+   * {@link Run.cancel} does — the turn stays open for a follow-up via {@link Run.sendInput}.
+   * Requires the agent's `interrupt` capability.
+   */
+  async interrupt() {
+    await this.http.request("POST", `/runs/${encodeURIComponent(this.id)}/interrupt`);
+  }
+  /**
+   * Switch the model of the live turn. An empty/omitted `model` resets the turn to the agent/CLI
+   * default. Only meaningful on a persistent (non-bypass) turn; on a one-shot turn it is a
+   * best-effort no-op. Requires the agent's `setModel` capability.
+   */
+  async setModel(model) {
+    await this.http.request("POST", `/runs/${encodeURIComponent(this.id)}/set-model`, {
+      body: { model: model ?? "" }
+    });
+  }
+  /**
+   * 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.
+   */
+  async setPermissionMode(mode) {
+    await this.http.request("POST", `/runs/${encodeURIComponent(this.id)}/set-permission-mode`, {
+      body: { mode }
+    });
+  }
+  /**
+   * `GET /runs/{id}/children` — the child iterations of a global-resolve run, oldest→newest, each as
+   * its own {@link Run} handle. An ordinary turn (or a resolve that ran a single iteration) returns an
+   * empty array. Use it to inspect the run tree a {@link Mindwire.resolve} produced.
+   */
+  async children() {
+    const data = await this.http.request(
+      "GET",
+      `/runs/${encodeURIComponent(this.id)}/children`
+    );
+    return data.map((d) => new _Run(this.http, d));
+  }
+  /** Re-fetch the run record from the daemon and update this handle. */
+  async refresh() {
+    this.data = await this.http.request("GET", `/runs/${encodeURIComponent(this.id)}`);
+    return this.data;
+  }
+  /** Restore current output once, then follow with `stream({ after: snapshot.sequence })`. */
+  async snapshot() {
+    const snapshot = await this.http.request("GET", `/runs/${encodeURIComponent(this.id)}/snapshot`);
+    this.data = snapshot.run;
+    return snapshot;
+  }
+  /**
+   * 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
+   * unless `throwOnError` is set to `false`.
+   */
+  async wait(opts = {}) {
+    let result;
+    let streamError;
+    for await (const ev of this.stream(opts)) {
+      if (ev.type === "result") result = ev.result;
+      else if (ev.type === "error") streamError = ev.error;
+    }
+    const run = await this.refresh();
+    if (opts.throwOnError !== false) {
+      if (TERMINAL.has(run.status)) {
+        if (run.status !== "done") {
+          throw new RunFailedError(run.id, run.status, run.error ?? streamError);
+        }
+      } else {
+        throw new RunFailedError(
+          run.id,
+          run.status,
+          streamError ?? "event stream ended before the run reached a terminal state"
+        );
+      }
+    }
+    return result !== void 0 ? { run, result } : { run };
+  }
+};
+
+// src/workspace.ts
+var ProjectOperationsApi = class {
+  constructor(mw) {
+    this.mw = mw;
+  }
+  mw;
+  async list(activeOnly = false) {
+    const response = await this.mw.http.request("GET", "/workspace/operations", {
+      query: { active: activeOnly }
+    });
+    return response.operations;
+  }
+  get(id) {
+    return this.mw.http.request("GET", `/workspace/operations/${encodeURIComponent(id)}`);
+  }
+  cancel(id) {
+    return this.mw.http.request("POST", `/workspace/operations/${encodeURIComponent(id)}/cancel`);
+  }
+  retry(id, auth) {
+    return this.mw.http.request("POST", `/workspace/operations/${encodeURIComponent(id)}/retry`, { body: { auth } });
+  }
+  /** 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.
+   */
+  async *watch(id, 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", `/workspace/operations/${encodeURIComponent(id)}/stream`, {
+        signal: controller.signal
+      });
+      let sequence = -1;
+      for await (const operation of readSSE(response.body, controller.signal)) {
+        if (operation.sequence > sequence) {
+          sequence = operation.sequence;
+          yield operation;
+        }
+      }
+    } finally {
+      controller.abort();
+      opts.signal?.removeEventListener("abort", abort);
+    }
+  }
+};
+var WorkspaceCollection = class {
+  constructor(mw, kind) {
+    this.mw = mw;
+    this.kind = kind;
+  }
+  mw;
+  kind;
+  /** Create with a stable client-generated ID. For updates, supply the record's last revision. */
+  put(id, record, expectedRevision) {
+    return this.mw.http.request("PUT", `/workspace/${this.kind}/${encodeURIComponent(id)}`, {
+      body: { record, expectedRevision }
+    });
+  }
+  /** 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, revision) {
+    return this.mw.http.request("DELETE", `/workspace/${this.kind}/${encodeURIComponent(id)}`, {
+      query: { revision }
+    });
+  }
+};
+var WorkspaceApi = class {
+  constructor(mw) {
+    this.mw = mw;
+    this.git = new GitAccessApi(mw);
+    this.operations = new ProjectOperationsApi(mw);
+    this.agents = new WorkspaceCollection(mw, "agents");
+    this.projects = new WorkspaceCollection(mw, "projects");
+    this.chats = new WorkspaceCollection(mw, "chats");
+  }
+  mw;
+  git;
+  operations;
+  agents;
+  projects;
+  chats;
+  snapshot(options = {}) {
+    return this.mw.http.request("GET", "/workspace", { query: options });
+  }
+  /** Start an operation owned by the daemon. The same ID/payload returns the existing operation. */
+  createProject(request) {
+    return this.mw.http.request("POST", "/workspace/projects", { body: request });
+  }
+  /** Permanently remove the confirmed project's directory and membership.
+   * projects.delete() retains files. Native harness transcripts are not purged.
+   */
+  removeProjectFiles(id, request) {
+    return this.mw.http.request("POST", `/workspace/projects/${encodeURIComponent(id)}/remove`, { body: request });
+  }
+  /** 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, workspaceId, options = {}) {
+    return this.mw.http.request("GET", "/workspace/changes", { query: { since, workspaceId, ...options } });
+  }
+  /** Import legacy metadata before replacing a local cache. Safe to repeat after interruption. */
+  import(records) {
+    return this.mw.http.request("POST", "/workspace/import", { body: records });
+  }
+};
+var GitAccessApi = class {
+  constructor(mw) {
+    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");
+  }
+  setDefault(connection, auth) {
+    return this.mw.http.request("PUT", "/workspace/git", { body: { connection, auth } });
+  }
+  forget(connectionId) {
+    return this.mw.http.request("DELETE", `/workspace/git/connections/${encodeURIComponent(connectionId)}`);
+  }
+  project(projectId) {
+    return this.mw.http.request("GET", `/workspace/projects/${encodeURIComponent(projectId)}/git`);
+  }
+  setProject(projectId, connection, expectedRevision, auth) {
+    return this.mw.http.request("PUT", `/workspace/projects/${encodeURIComponent(projectId)}/git`, {
+      body: { connection, expectedRevision, auth }
+    });
+  }
+  /** Compatibility call. Prefer start() and operation()/watch() for reconnectable writes. */
+  run(projectId, operation, auth) {
+    return this.mw.http.request("POST", `/workspace/projects/${encodeURIComponent(projectId)}/git/${operation}`, { body: { auth } });
+  }
+  /** Requires health.gitOperationsVersion >= 1 (>= 2 for branches, >= 4 for restore_commit). Acceptance persists before Git runs;
+   * disconnecting only detaches the client. The same ID/intent never runs twice.
+   */
+  start(projectId, request) {
+    return this.mw.http.request("POST", `/workspace/projects/${encodeURIComponent(projectId)}/git/operations`, { body: request });
+  }
+  async operations(projectId, activeOnly = false) {
+    const result = await this.mw.http.request(
+      "GET",
+      `/workspace/projects/${encodeURIComponent(projectId)}/git/operations`,
+      { query: { active: activeOnly, actionsVersion: 4 } }
+    );
+    return result.operations;
+  }
+  operation(id) {
+    return this.mw.http.request("GET", `/workspace/git/operations/${encodeURIComponent(id)}`);
+  }
+  cancel(id) {
+    return this.mw.http.request("POST", `/workspace/git/operations/${encodeURIComponent(id)}/cancel`);
+  }
+  /** Current snapshot followed by state changes. Aborting observation never cancels the operation. */
+  async *watch(id, 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", `/workspace/git/operations/${encodeURIComponent(id)}/stream`, {
+        signal: controller.signal
+      });
+      let sequence = -1;
+      for await (const operation of readSSE(response.body, controller.signal)) {
+        if (operation.sequence > sequence) {
+          sequence = operation.sequence;
+          yield operation;
+        }
+      }
+    } finally {
+      controller.abort();
+      opts.signal?.removeEventListener("abort", abort);
+    }
+  }
+};
+
+// 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/service.ts
+var ServiceApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  updateStatus() {
+    return this.client.http.request("GET", "/service/update");
+  }
+  /** Download first. Acquire immediately before replacement; busy work returns 409.
+   * Admission stays closed until release, process exit, or the one-minute expiry. */
+  acquireUpdate() {
+    return this.client.http.request("POST", "/service/update");
+  }
+  releaseUpdate(id) {
+    return this.client.http.request("DELETE", `/service/update/${encodeURIComponent(id)}`);
+  }
+};
+
+// 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(path2 = "", query) {
+    return this.client.http.request("GET", "/workspace/files", { query: { path: path2, query } });
+  }
+  read(path2) {
+    return this.client.http.request("GET", "/workspace/file", { query: { path: path2 } });
+  }
+  write(path2, content) {
+    return this.client.http.request("PUT", "/workspace/file", { body: { path: path2, content } });
+  }
+  remove(path2) {
+    return this.client.http.request("DELETE", "/workspace/file", { query: { path: path2 } });
+  }
+  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/embedded.ts
+var shared = /* @__PURE__ */ new Map();
+function configKey(opts) {
+  return JSON.stringify([opts.cwd ?? "", opts.statePath ?? "", opts.bin ?? ""]);
+}
+function startEmbedded(opts = {}) {
+  const key = configKey(opts);
+  let daemon = shared.get(key);
+  if (!daemon) {
+    daemon = spawnDaemon(opts).catch((err) => {
+      shared.delete(key);
+      throw err;
+    });
+    shared.set(key, daemon);
+  }
+  return daemon;
+}
+function serverRuntime() {
+  return globalThis;
+}
+function isServerRuntime() {
+  const g = serverRuntime();
+  return typeof g.process !== "undefined" && !!g.process.versions?.node || typeof g.Bun !== "undefined" || typeof g.Deno !== "undefined";
+}
+async function spawnDaemon(opts) {
+  if (!isServerRuntime()) {
+    throw new 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."
+    );
+  }
+  const { spawn: spawn2 } = await import('child_process');
+  const net = await import('net');
+  const proc = serverRuntime().process;
+  const { randomBytes } = await import('crypto');
+  const resolved = await resolveBinary(opts.bin);
+  const bin = resolved.bin;
+  const port = await freePort(net);
+  const baseUrl = `http://127.0.0.1:${port}`;
+  const token = randomBytes(32).toString("hex");
+  const child = spawn2(bin, [], {
+    env: {
+      ...proc.env,
+      ADDR: `127.0.0.1:${port}`,
+      AGENT_CWD: opts.cwd ?? proc.cwd(),
+      STATE_PATH: opts.statePath ?? ".mindwire-state.json",
+      DAEMON_TOKEN: token
+    },
+    stdio: "ignore"
+  });
+  let spawnError = null;
+  child.on("error", (e) => {
+    spawnError = e;
+  });
+  const stop = () => {
+    try {
+      child.kill();
+    } catch {
+    }
+  };
+  proc.once?.("exit", stop);
+  proc.once?.("SIGINT", () => {
+    stop();
+    proc.exit?.(130);
+  });
+  await waitHealthy(baseUrl, token, () => spawnError, resolved);
+  return { baseUrl, token, stop };
+}
+async function resolveBinary(explicit) {
+  const fs3 = await import('fs');
+  const path2 = await import('path');
+  const proc = serverRuntime().process;
+  const ext = proc.platform === "win32" ? ".exe" : "";
+  const candidates = [];
+  if (explicit) candidates.push(explicit);
+  if (proc.env?.MINDWIRE_DAEMON) candidates.push(proc.env.MINDWIRE_DAEMON);
+  try {
+    const url = await import('url');
+    const here = path2.dirname(url.fileURLToPath(import.meta.url));
+    const named = `mindwired-${proc.platform}-${proc.arch}${ext}`;
+    candidates.push(path2.join(here, "bin", named), path2.join(here, "..", "bin", named));
+  } catch {
+  }
+  for (const c of candidates) {
+    try {
+      if (fs3.existsSync(c)) return { bin: c, found: true, checked: candidates };
+    } catch {
+    }
+  }
+  const downloaded = await ensureDaemonBinary({ platform: proc.platform, arch: proc.arch });
+  return { bin: downloaded, found: true, checked: [...candidates, downloaded] };
+}
+function daemonStartError(resolved, cause) {
+  if (!resolved.found) {
+    return [
+      "Couldn't start the mindwire daemon: the `mindwired` binary was not found.",
+      `Looked in: ${resolved.checked.join(", ")}.`,
+      "Fixes:",
+      "  \u2022 check GitHub Release access so the SDK can download its matching daemon binary; or",
+      "  \u2022 set MINDWIRE_DAEMON to a `mindwired` binary; or",
+      "  \u2022 pass { baseUrl } to connect to a daemon you run yourself.",
+      "  \u2022 Working inside the mindwire monorepo? Run `go build -o /tmp/mindwired ./daemon/cmd/daemon` and set MINDWIRE_DAEMON.",
+      `(underlying error: ${cause.message})`
+    ].join("\n");
+  }
+  return `Couldn't start the mindwire daemon (${resolved.bin}): ${cause.message}. Set MINDWIRE_DAEMON to the binary path, or pass { baseUrl } to use a running daemon.`;
+}
+function freePort(net) {
+  return new Promise((resolve, reject) => {
+    const srv = net.createServer();
+    srv.on("error", reject);
+    srv.listen(0, "127.0.0.1", () => {
+      const addr = srv.address();
+      const port = addr && typeof addr === "object" ? addr.port : 0;
+      srv.close(() => resolve(port));
+    });
+  });
+}
+async function waitHealthy(baseUrl, token, getError, resolved, timeoutMs = 15e3) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const err = getError();
+    if (err) {
+      throw new MindwireError(daemonStartError(resolved, err), { cause: err });
+    }
+    try {
+      const res = await fetch(`${baseUrl}/healthz`, { headers: { Authorization: `Bearer ${token}` } });
+      if (res.ok) return;
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, 150));
+  }
+  throw new MindwireError("mindwire embedded daemon did not become healthy in time.");
+}
+
+// src/target/index.ts
+function emit(spec, e) {
+  if (!spec.onLog) return;
+  try {
+    spec.onLog(e);
+  } catch {
+  }
+}
+function local(opts = {}) {
+  return {
+    name: "local",
+    async connect(spec) {
+      const d = await startEmbedded(opts);
+      emit(spec, { target: "local", phase: "ready", message: `embedded daemon on ${d.baseUrl}` });
+      return {
+        id: d.baseUrl,
+        baseUrl: d.baseUrl,
+        ...d.token !== void 0 ? { token: d.token } : {},
+        // No-op: the embedded daemon is shared (keyed memoization) and reaped on process exit.
+        stop: async () => {
+        }
+      };
+    }
+  };
+}
+function remote(baseUrl, opts = {}) {
+  return {
+    name: "remote",
+    async connect(spec) {
+      emit(spec, { target: "remote", phase: "skip", message: `using remote daemon at ${baseUrl}` });
+      return {
+        id: baseUrl,
+        baseUrl,
+        ...opts.token !== void 0 ? { token: opts.token } : {},
+        ...opts.headers !== void 0 ? { headers: opts.headers } : {},
+        ...opts.fetch !== void 0 ? { fetch: opts.fetch } : {},
+        stop: async () => {
+        }
+      };
+    }
+  };
+}
+
+// src/client.ts
+var handleByTransport = /* @__PURE__ */ new WeakMap();
+var Mindwire = class _Mindwire {
+  /** Workspace registry: saved agent profiles, projects and chat relationships. */
+  workspace;
+  surfaces;
+  service;
+  execution;
+  computer;
+  http;
+  /** The default agent type applied to agent-scoped calls, if set. */
+  defaultAgent;
+  /** Step-flow auth, scoped to this client's default agent (override per call). */
+  auth;
+  /** Persistent memory files + saved prompt templates, scoped to this client's default agent. */
+  prompts;
+  /** Persistent MCP-server config (the config an agent loads every run), scoped to this client's default agent. */
+  mcp;
+  /** Custom LLM-provider registration (opencode/Codex native config), scoped to this client's default agent. */
+  providers;
+  /** Daemon-driven notification channels + routing rules (webhook/slack/discord/telegram; per-agent/session/global). */
+  notify;
+  constructor(opts = {}) {
+    const target = opts.target ?? local();
+    const spec = { agent: opts.agent, onLog: opts.logger };
+    this.http = new Http({
+      fetch: opts.fetch,
+      headers: opts.headers,
+      timeoutMs: opts.requestTimeoutMs,
+      resolveBase: () => {
+        const h = target.connect(spec);
+        handleByTransport.set(this.http, h);
+        return h.then((x) => ({
+          baseUrl: x.baseUrl,
+          token: x.token,
+          getToken: x.getToken,
+          headers: x.headers,
+          fetch: x.fetch
+        }));
+      }
+    });
+    this.defaultAgent = opts.agent;
+    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);
+    this.providers = new ProvidersApi(this);
+    this.notify = new NotifyApi(this);
+  }
+  /**
+   * Provision the destination and await readiness **now**, rather than lazily on the first request —
+   * useful to front-load a fresh SSH/Docker/Oblien box (and to stream its {@link EnsureEvent}s to the
+   * `logger`) before the first `turn()`. Idempotent and memoized: repeated `ensure()` calls, and the
+   * first real request, all await the same provisioning, so the target connects exactly once.
+   */
+  async ensure() {
+    await this.http.ready();
+  }
+  /** Return a new client bound to a different default agent (shares the same transport config). */
+  withAgent(agent) {
+    const clone = Object.create(_Mindwire.prototype);
+    clone.http = this.http;
+    clone.defaultAgent = agent;
+    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);
+    clone.providers = new ProvidersApi(clone);
+    clone.notify = new NotifyApi(clone);
+    return clone;
+  }
+  /** The `?agent=` value to send for a scoped call: explicit override → client default → none. */
+  agentParam(scoped) {
+    const a = scoped?.agent ?? this.defaultAgent;
+    return a ? { agent: a } : void 0;
+  }
+  /**
+   * Release target-owned resources by calling the {@link TargetHandle}'s `stop()` — once, even across
+   * {@link withAgent} clones that share the transport. For an `ssh`/`docker`/`oblien` target this reaps
+   * the box (tear down the tunnel, stop or delete the container/workspace, per `stopOnExit`); a no-op
+   * for `local`/`remote` (embedded self-cleans on process exit; remote is not ours to stop). Safe to
+   * call before the target has connected (nothing to reap yet).
+   */
+  async close() {
+    const handle = handleByTransport.get(this.http);
+    if (!handle) return;
+    handleByTransport.delete(this.http);
+    const h = await handle.catch(() => null);
+    if (h) await h.stop();
+  }
+  // ---- health & catalog ----------------------------------------------------
+  /** `GET /healthz` — authenticated liveness check. Resolves with the daemon's health payload when it is up. */
+  health() {
+    return this.http.request("GET", "/healthz");
+  }
+  /**
+   * `GET /stats` — the daemon **process's** resource snapshot (heap in use, memory reserved from the
+   * OS, goroutines, GC cycles, cores, platform, uptime). Cheap enough to call on demand — the daemon
+   * reads its own Go runtime, not the machine — so a UI can fetch it when a user opens a daemon's page
+   * without any background polling. See {@link Stats} for what each field means and doesn't.
+   */
+  stats() {
+    return this.http.request("GET", "/stats");
+  }
+  /** `GET /catalog` — every agent this daemon binary supports. */
+  catalog() {
+    return this.http.request("GET", "/catalog");
+  }
+  /** `GET /agent` — capabilities + settings schema + auth methods/status for the selected agent. */
+  agent(scoped) {
+    return this.http.request("GET", "/agent", { query: this.agentParam(scoped) });
+  }
+  /** `GET /agent/software` — installed version, compatibility and approved update target. */
+  software(opts = {}) {
+    return this.http.request("GET", "/agent/software", {
+      query: { ...this.agentParam(opts), ...opts.refresh ? { refresh: "true" } : {} }
+    });
+  }
+  /**
+   * `GET /models` — the models the selected agent can run for the configured account. An empty array
+   * is valid (no credentials yet / offline). Throws a 400 {@link ApiError} for an agent whose model is
+   * free text (check `capabilities.models` first).
+   */
+  models(scoped) {
+    return this.http.request("GET", "/models", { query: this.agentParam(scoped) });
+  }
+  /** `GET /doctor` — daemon-level health plus the selected agent's own checks. */
+  doctor(scoped) {
+    return this.http.request("GET", "/doctor", { query: this.agentParam(scoped) });
+  }
+  // ---- toolchain setup -----------------------------------------------------
+  /** `POST /setup` — start the agent's install toolchain (background; poll {@link setupStatus}). */
+  setup(scoped) {
+    return this.http.request("POST", "/setup", { query: this.agentParam(scoped) });
+  }
+  /** `POST /update` — install the catalog's newest tested version compatible with this daemon. */
+  update(scoped) {
+    return this.http.request("POST", "/update", { query: this.agentParam(scoped) });
+  }
+  /** `GET /setup` — current toolchain install progress. */
+  setupStatus(scoped) {
+    return this.http.request("GET", "/setup", { query: this.agentParam(scoped) });
+  }
+  // ---- config --------------------------------------------------------------
+  /** `GET /config` — the declared, non-secret settings for the agent. */
+  getConfig(scoped) {
+    return this.http.request("GET", "/config", {
+      query: this.agentParam(scoped)
+    });
+  }
+  /** `PUT /config` — merge recognized (non-secret) setting keys. Unknown keys are ignored server-side. */
+  async setConfig(values, scoped) {
+    await this.http.request("PUT", "/config", {
+      query: this.agentParam(scoped),
+      body: values
+    });
+  }
+  // ---- chats & history -----------------------------------------------------
+  /** Native project conversations and drafts, newest first, shared across agents.
+   * `cwd` matches an exact directory; `projectId` selects saved membership.
+   * `refresh` bypasses the daemon's short native metadata cache.
+   */
+  chats(options = {}) {
+    return this.http.request("GET", "/chats", { query: options });
+  }
+  /**
+   * `PUT /chats/{id}` — rename a chat. The user title wins over the agent's native auto-title in
+   * every listing; an empty title clears the rename (reverting to the native/derived title).
+   * Returns the updated summary.
+   */
+  renameChat(chatId, title) {
+    return this.http.request("PUT", `/chats/${encodeURIComponent(chatId)}`, {
+      body: { title }
+    });
+  }
+  /**
+   * `DELETE /chats/{id}` — a true, irreversible delete: purges ALL of the chat's mindwire
+   * bookkeeping and, for every session the chat mapped to, removes that agent's native transcript
+   * (the source of truth). Rejects with a 409 error if a turn is live. Native deletion is
+   * best-effort per agent; the result reports what was purged vs. failed.
+   */
+  deleteChat(chatId) {
+    return this.http.request("DELETE", `/chats/${encodeURIComponent(chatId)}`);
+  }
+  /**
+   * `POST /chats/{id}/fork` — clone a chat into a new id (generated when `newChatId` is omitted).
+   * The fork shares the source's native session until its first turn, which branches it (natively
+   * on Claude via `--fork-session`; a fresh session on agents without native fork). Rejects with a
+   * 409 if the source has a live turn, 404 if the source is unknown, 400 if the target id is in
+   * use. Returns the new chat's summary.
+   */
+  forkChat(chatId, opts = {}) {
+    return this.http.request("POST", `/chats/${encodeURIComponent(chatId)}/fork`, {
+      body: opts.newChatId ? { newChatId: opts.newChatId } : {}
+    });
+  }
+  /**
+   * `GET /chats/{id}/messages` — a chat's transcript (native when the agent supports it, else
+   * the recorded fallback). `limit` caps to the newest N; `before` pages older history.
+   */
+  messages(chatId, opts = {}) {
+    const query = { ...this.agentParam(opts) };
+    if (opts.limit !== void 0) query["limit"] = opts.limit;
+    if (opts.before !== void 0) query["before"] = opts.before;
+    return this.http.request("GET", `/chats/${encodeURIComponent(chatId)}/messages`, {
+      query
+    });
+  }
+  /** `GET /chats/{id}/run` — the latest run for a chat (reattach anchor), or `null` if none yet. */
+  async latestRun(chatId) {
+    const data = await this.http.request(
+      "GET",
+      `/chats/${encodeURIComponent(chatId)}/run`
+    );
+    return data ? new Run(this.http, data) : null;
+  }
+  // ---- turns & runs --------------------------------------------------------
+  /**
+   * `POST /turns` — start a turn. Returns a {@link Run} handle you can stream, cancel, or await.
+   * Rejects with an {@link ApiError} (409) if a turn is already running for the chat.
+   *
+   * `mode` defaults to `"turn"` — one agent turn that ends when the CLI settles. Pass
+   * `mode: "resolve"` (with optional {@link ResolveOptions} `resolve` caps) for a global-resolve run
+   * that auto-continues the agent's multi-step work until it's done; {@link Mindwire.resolve} is the
+   * clearer entry point for that. The returned {@link Run} is then the parent of the run tree.
+   */
+  async turn(input) {
+    const body = {
+      chatId: input.chatId,
+      message: input.message
+    };
+    if (input.requestId !== void 0) body.requestId = input.requestId;
+    if (input.cwd !== void 0) body.cwd = input.cwd;
+    if (input.options !== void 0) body.options = input.options;
+    if (input.mode !== void 0) body.mode = input.mode;
+    if (input.resolve !== void 0) body.resolve = input.resolve;
+    if (input.gitAuth !== void 0) body.gitAuth = input.gitAuth;
+    const data = await this.http.request("POST", "/turns", {
+      query: this.agentParam(input),
+      body
+    });
+    return new Run(this.http, data);
+  }
+  /**
+   * `POST /turns {mode:"resolve"}` — start a **global-resolve** run: instead of returning after one
+   * turn, the daemon holds the task open and auto-continues the agent (resuming on continuable stops
+   * and probing for completion) until the work is globally resolved, then aggregates one final result.
+   *
+   * The returned {@link Run} is the **parent** of a run tree: each auto-continued iteration is a child
+   * turn ({@link Run.children}) whose events stream onto the parent's topic, delimited by `continuation`
+   * boundary events. `run.wait()` resolves once with the aggregated result; `run.stopReason` /
+   * `run.iterations` report how the loop ended. Resolve turns run unattended (no mid-turn approvals)
+   * and are bounded by {@link ResolveOptions} caps — see the resolve guide. Rejects with an
+   * {@link ApiError} (409) if a turn is already running for the chat.
+   */
+  async resolve(input) {
+    return this.turn({ ...input, mode: "resolve" });
+  }
+  /** `GET /runs/{id}` — fetch an existing run as a {@link Run} handle. */
+  async run(id) {
+    const data = await this.http.request("GET", `/runs/${encodeURIComponent(id)}`);
+    return new Run(this.http, data);
+  }
+  /**
+   * `POST /chats/{id}/compact` — run an on-demand conversation compaction as a first-class {@link Run}
+   * you can stream or await. The agent folds prior context into a summary it carries forward, emitting
+   * a `compaction` event on the stream and recording the boundary in history exactly like an
+   * auto-compaction. Optional `instructions` focus the continuation summary (Claude's
+   * `/compact <instructions>`; agents that don't honor focus still compact). Rejects with an
+   * {@link ApiError}: 400 if the agent doesn't support compaction (`capabilities.compactNow`) or the
+   * chat has no conversation yet, 409 if a turn is already running for the chat.
+   */
+  async compact(chatId, opts = {}) {
+    const data = await this.http.request(
+      "POST",
+      `/chats/${encodeURIComponent(chatId)}/compact`,
+      {
+        query: this.agentParam(opts),
+        body: opts.instructions ? { instructions: opts.instructions } : {}
+      }
+    );
+    return new Run(this.http, data);
+  }
+  // ---- notifications -------------------------------------------------------
+  /** `GET /notify/config` — whether a notification channel is wired (token never returned). */
+  getNotifyConfig() {
+    return this.http.request("GET", "/notify/config");
+  }
+  /** `PUT /notify/config` — store the provisioned notification channel (daemon-wide). */
+  async setNotifyConfig(input) {
+    await this.http.request("PUT", "/notify/config", { body: input });
+  }
+  /** `GET /notify/stream` — SSE feed of the daemon's notifications (replay, then live). */
+  async *notifications(opts = {}) {
+    const res = await this.http.open("GET", "/notify/stream", {
+      ...opts.signal ? { signal: opts.signal } : {}
+    });
+    yield* readSSE(res.body, opts.signal);
+  }
+  // ---- live resources ------------------------------------------------------
+  /**
+   * `GET /processes/stream` — SSE feed of live per-turn CPU/memory, one {@link ProcessFrame} per tick.
+   * Sampling is **on demand**: the daemon starts measuring only while a client is connected and stops
+   * the instant the last one disconnects, so aborting the `signal` (or ending the loop) tells the
+   * daemon to stop — no background work, no leak. Pass `agent` to filter each frame's samples to one
+   * agent type. Frames are live snapshots (no replay); an empty `samples` array is a valid keep-alive.
+   */
+  async *processes(opts = {}) {
+    const path2 = "/processes/stream" + (opts.agent ? `?agent=${encodeURIComponent(opts.agent)}` : "");
+    const res = await this.http.open("GET", path2, {
+      ...opts.signal ? { signal: opts.signal } : {}
+    });
+    yield* readSSE(res.body, opts.signal);
+  }
+};
+var AuthApi = class {
+  constructor(mw) {
+    this.mw = mw;
+  }
+  mw;
+  /** `GET /auth/methods` — the options list to present. */
+  methods(scoped) {
+    return this.mw.http.request("GET", "/auth/methods", {
+      query: this.mw.agentParam(scoped)
+    });
+  }
+  /** `POST /auth/begin` — start one method (may return `{ url, code, fields, pending }`). */
+  begin(method, scoped) {
+    return this.mw.http.request("POST", "/auth/begin", {
+      query: this.mw.agentParam(scoped),
+      body: { method }
+    });
+  }
+  /** `POST /auth/step` — submit fields, or poll an interactive login to completion. */
+  step(input, scoped) {
+    return this.mw.http.request("POST", "/auth/step", {
+      query: this.mw.agentParam(scoped),
+      body: input
+    });
+  }
+  /** Read one interactive attempt, scoped by the returned AuthState.flowId. */
+  poll(flowId, scoped) {
+    return this.step({ _flowId: flowId }, scoped);
+  }
+  /** Cancel this native login without affecting a newer sign-in attempt. */
+  cancel(flowId, scoped) {
+    return this.step({ _flowId: flowId, _action: "cancel" }, scoped);
+  }
+  /** `GET /auth/status` — is the agent authenticated, and via which method. */
+  status(scoped) {
+    return this.mw.http.request("GET", "/auth/status", {
+      query: this.mw.agentParam(scoped)
+    });
+  }
+  /** `POST /auth/logout` — disconnect this harness once its running chats finish. */
+  logout(scoped) {
+    return this.mw.http.request("POST", "/auth/logout", {
+      query: this.mw.agentParam(scoped)
+    });
+  }
+};
+var PromptsApi = class {
+  constructor(mw) {
+    this.mw = mw;
+  }
+  mw;
+  query(scoped, extra) {
+    return { ...this.mw.agentParam(scoped), ...extra };
+  }
+  /**
+   * `GET /memory` — the agent's memory file at every supported scope (project + user for both
+   * Claude and Codex). Each entry carries the resolved `path` and `exists`; `content` is `""` for
+   * an absent file.
+   */
+  memory(opts = {}) {
+    return this.mw.http.request("GET", "/memory", {
+      query: this.query(opts, { dir: opts.dir })
+    });
+  }
+  /** `PUT /memory` — write the memory file at `scope`. Returns the resulting {@link MemoryDoc}. */
+  setMemory(input, opts = {}) {
+    return this.mw.http.request("PUT", "/memory", {
+      query: this.query(opts, { dir: opts.dir }),
+      body: input
+    });
+  }
+  /**
+   * `DELETE /memory` — remove the memory file at `scope` (defaults to `user`). Returns the resulting
+   * {@link MemoryDoc} (`exists: false` at the resolved path). Idempotent: deleting an absent file still
+   * succeeds.
+   */
+  deleteMemory(opts = {}) {
+    return this.mw.http.request("DELETE", "/memory", {
+      query: this.query(opts, { scope: opts.scope, dir: opts.dir })
+    });
+  }
+  /**
+   * `GET /prompts` — saved prompt templates across every supported scope (Claude: project + user;
+   * Codex: user only). `content` is omitted here; fetch it with {@link get}. A missing project
+   * directory yields an empty list for that scope rather than an error.
+   */
+  list(opts = {}) {
+    return this.mw.http.request("GET", "/prompts", {
+      query: this.query(opts, { dir: opts.dir })
+    });
+  }
+  /** `GET /prompts/{name}` — one template's full body. Rejects with a 404 `ApiError` if absent. */
+  get(name, opts = {}) {
+    return this.mw.http.request("GET", `/prompts/${encodeURIComponent(name)}`, {
+      query: this.query(opts, { scope: opts.scope, dir: opts.dir })
+    });
+  }
+  /** `PUT /prompts/{name}` — create or overwrite a template. Returns the resulting {@link PromptTemplate}. */
+  set(name, content, opts = {}) {
+    return this.mw.http.request("PUT", `/prompts/${encodeURIComponent(name)}`, {
+      query: this.query(opts, { scope: opts.scope, dir: opts.dir }),
+      body: { content }
+    });
+  }
+  /**
+   * `DELETE /prompts/{name}` — remove one template at `scope` (defaults to `user`). Idempotent:
+   * deleting an absent template still succeeds. A traversal name rejects with a 400 `ApiError`.
+   */
+  async delete(name, opts = {}) {
+    await this.mw.http.request("DELETE", `/prompts/${encodeURIComponent(name)}`, {
+      query: this.query(opts, { scope: opts.scope, dir: opts.dir })
+    });
+  }
+  /**
+   * `GET /subagents` — persistent subagent definitions (Claude `.claude/agents/*.md`) across every
+   * supported scope. `content` is omitted here (fetch it with {@link subagent}); `meta` is the parsed
+   * frontmatter view. Rejects with a 400 `ApiError` on an agent without the subagent-definition module.
+   * Distinct from a turn's per-turn `subagents` passthrough — this is the on-disk definition store.
+   */
+  subagents(opts = {}) {
+    return this.mw.http.request("GET", "/subagents", {
+      query: this.query(opts, { dir: opts.dir })
+    });
+  }
+  /** `GET /subagents/{name}` — one definition's raw body + parsed meta. 404 `ApiError` if absent. */
+  subagent(name, opts = {}) {
+    return this.mw.http.request("GET", `/subagents/${encodeURIComponent(name)}`, {
+      query: this.query(opts, { scope: opts.scope, dir: opts.dir })
+    });
+  }
+  /** `PUT /subagents/{name}` — create or overwrite a definition (raw content is canonical). Returns it. */
+  setSubagent(name, content, opts = {}) {
+    return this.mw.http.request("PUT", `/subagents/${encodeURIComponent(name)}`, {
+      query: this.query(opts, { scope: opts.scope, dir: opts.dir }),
+      body: { content }
+    });
+  }
+  /**
+   * `DELETE /subagents/{name}` — remove one definition at `scope` (defaults to `user`). Idempotent:
+   * deleting an absent definition still succeeds. A traversal name rejects with a 400 `ApiError`.
+   */
+  async deleteSubagent(name, opts = {}) {
+    await this.mw.http.request("DELETE", `/subagents/${encodeURIComponent(name)}`, {
+      query: this.query(opts, { scope: opts.scope, dir: opts.dir })
+    });
+  }
+};
+var McpApi = class {
+  constructor(mw) {
+    this.mw = mw;
+  }
+  mw;
+  query(scoped, extra) {
+    return { ...this.mw.agentParam(scoped), ...extra };
+  }
+  /**
+   * `GET /mcp` — every persistent MCP server across the agent's supported scopes, keyed
+   * `scope → name → server` (Claude: project + user; Codex: user only). A missing config file yields
+   * an empty object for that scope rather than an error.
+   */
+  list(opts = {}) {
+    return this.mw.http.request("GET", "/mcp", {
+      query: this.query(opts, { dir: opts.dir })
+    });
+  }
+  /** `GET /mcp/{name}` — one server's definition. Rejects with a 404 `ApiError` if it isn't configured. */
+  get(name, opts = {}) {
+    return this.mw.http.request("GET", `/mcp/${encodeURIComponent(name)}`, {
+      query: this.query(opts, { scope: opts.scope, dir: opts.dir })
+    });
+  }
+  /** `PUT /mcp/{name}` — create or overwrite one server. Returns the stored definition. */
+  set(name, server, opts = {}) {
+    return this.mw.http.request("PUT", `/mcp/${encodeURIComponent(name)}`, {
+      query: this.query(opts, { scope: opts.scope, dir: opts.dir }),
+      body: server
+    });
+  }
+  /** `DELETE /mcp/{name}` — remove one server. Idempotent: deleting an absent server still succeeds. */
+  async delete(name, opts = {}) {
+    await this.mw.http.request("DELETE", `/mcp/${encodeURIComponent(name)}`, {
+      query: this.query(opts, { scope: opts.scope, dir: opts.dir })
+    });
+  }
+};
+var ProvidersApi = class {
+  constructor(mw) {
+    this.mw = mw;
+  }
+  mw;
+  query(scoped, extra) {
+    return { ...this.mw.agentParam(scoped), ...extra };
+  }
+  /**
+   * `GET /providers` — every registered custom provider across the agent's supported scopes, keyed
+   * `scope → id → provider` (opencode/Codex: user only). A missing config file yields an empty object for
+   * that scope rather than an error. `hasKey` reports whether a secret is stored; the key is never returned.
+   */
+  list(opts = {}) {
+    return this.mw.http.request("GET", "/providers", {
+      query: this.query(opts, { dir: opts.dir })
+    });
+  }
+  /** `GET /providers/{id}` — one provider's definition. Rejects with a 404 `ApiError` if it isn't configured. */
+  get(id, opts = {}) {
+    return this.mw.http.request("GET", `/providers/${encodeURIComponent(id)}`, {
+      query: this.query(opts, { scope: opts.scope, dir: opts.dir })
+    });
+  }
+  /**
+   * `PUT /providers/{id}` — create or overwrite one provider, returning the stored definition (with
+   * `hasKey` and the stored `envVars`). Two write-only secret channels, both optional: `opts.apiKey` is a
+   * single key (custom endpoints, single-key catalog brands); `opts.secrets` is a NAME→VALUE map for a
+   * catalog provider whose entry declares MULTIPLE env vars (e.g. AWS Bedrock). Omitting both leaves any
+   * previously stored secret intact. The path `id` wins over any `id` on the provider value.
+   */
+  set(id, provider, opts = {}) {
+    return this.mw.http.request("PUT", `/providers/${encodeURIComponent(id)}`, {
+      query: this.query(opts, { scope: opts.scope, dir: opts.dir }),
+      body: { ...provider, id, apiKey: opts.apiKey, secrets: opts.secrets }
+    });
+  }
+  /** `DELETE /providers/{id}` — remove one provider and clear its stored key. Idempotent. */
+  async delete(id, opts = {}) {
+    await this.mw.http.request("DELETE", `/providers/${encodeURIComponent(id)}`, {
+      query: this.query(opts, { scope: opts.scope, dir: opts.dir })
+    });
+  }
+};
+var NotifyApi = class {
+  constructor(mw) {
+    this.mw = mw;
+  }
+  mw;
+  /** `GET /notify/channels` — every channel, masked (no secrets). */
+  channels() {
+    return this.mw.http.request("GET", "/notify/channels");
+  }
+  /** `POST /notify/channels` — create a channel (server-assigns the id). Returns it masked. */
+  createChannel(input) {
+    return this.mw.http.request("POST", "/notify/channels", { body: input });
+  }
+  /**
+   * `PUT /notify/channels/{id}` — update a channel, merge-preserving any omitted secret
+   * (`url`/`token`/`secret`). Returns the updated masked channel. 404 `ApiError` if unknown.
+   */
+  setChannel(id, input) {
+    return this.mw.http.request("PUT", `/notify/channels/${encodeURIComponent(id)}`, {
+      body: input
+    });
+  }
+  /** `DELETE /notify/channels/{id}` — remove a channel. Idempotent. */
+  async deleteChannel(id) {
+    await this.mw.http.request("DELETE", `/notify/channels/${encodeURIComponent(id)}`);
+  }
+  /**
+   * `POST /notify/channels/{id}/test` — deliver a synthetic notification to a channel. A failed
+   * delivery is DATA (`{ ok: false, error }`), not a thrown error; only an unknown id rejects (404).
+   */
+  testChannel(id) {
+    return this.mw.http.request(
+      "POST",
+      `/notify/channels/${encodeURIComponent(id)}/test`
+    );
+  }
+  /** `GET /notify/rules` — every routing rule. */
+  rules() {
+    return this.mw.http.request("GET", "/notify/rules");
+  }
+  /** `POST /notify/rules` — create a rule (server-assigns the id). Returns it. */
+  createRule(input) {
+    return this.mw.http.request("POST", "/notify/rules", { body: input });
+  }
+  /** `PUT /notify/rules/{id}` — replace a rule. Returns it. 404 `ApiError` if unknown. */
+  setRule(id, input) {
+    return this.mw.http.request("PUT", `/notify/rules/${encodeURIComponent(id)}`, {
+      body: input
+    });
+  }
+  /** `DELETE /notify/rules/{id}` — remove a rule. Idempotent. */
+  async deleteRule(id) {
+    await this.mw.http.request("DELETE", `/notify/rules/${encodeURIComponent(id)}`);
+  }
+};
+async function acquireProcessLock(file, options = {}) {
+  const owner = await currentProcessIdentity();
+  const queue = file + ".queue", id = randomUUID() + ".json", claimPath = queue + "/" + id;
+  await fs.mkdir(queue, { recursive: true, mode: 448 });
+  let lock;
+  const release = async () => {
+    try {
+      if (lock) {
+        const held = lock;
+        lock = void 0;
+        const owned = await held.stat();
+        await held.close();
+        const current = await fs.stat(file).catch(() => void 0);
+        if (current?.ino === owned.ino && current.dev === owned.dev) await fs.rm(file, { force: true });
+      }
+    } finally {
+      await fs.rm(claimPath, { force: true });
+    }
+  };
+  const publish = async (claim) => {
+    const temporary = claimPath + ".tmp";
+    try {
+      await fs.writeFile(temporary, JSON.stringify(claim), { mode: 384 });
+      await fs.rename(temporary, claimPath);
+    } finally {
+      await fs.rm(temporary, { force: true });
+    }
+  };
+  const claims = async () => {
+    const entries = [];
+    for (const candidate of await fs.readdir(queue)) {
+      if (!candidate.endsWith(".json")) continue;
+      const content = await fs.readFile(queue + "/" + candidate, "utf8").catch((error) => {
+        if (error.code === "ENOENT") return void 0;
+        throw error;
+      });
+      if (content === void 0) continue;
+      const claim = JSON.parse(content);
+      if (!claim.owner || claim.ticket !== null && (!Number.isSafeInteger(claim.ticket) || claim.ticket < 1)) {
+        throw new Error("Invalid Mindwire lock ticket.");
+      }
+      if (await processStateAlive(claim.owner)) entries.push({ id: candidate, claim });
+      else await fs.rm(queue + "/" + candidate, { force: true });
+    }
+    return entries;
+  };
+  try {
+    options.signal?.throwIfAborted();
+    await publish({ owner, ticket: null });
+    const ticket = Math.max(0, ...(await claims()).map((entry) => entry.claim.ticket ?? 0)) + 1;
+    if (!Number.isSafeInteger(ticket)) throw new Error("Mindwire's connection queue is full. Retry shortly.");
+    await publish({ owner, ticket });
+    const deadline = Date.now() + 3e4;
+    while (Date.now() < deadline) {
+      options.signal?.throwIfAborted();
+      if (await options.onWait?.()) {
+        await release();
+        return void 0;
+      }
+      const ahead = (await claims()).some((entry) => entry.id !== id && (entry.claim.ticket === null || entry.claim.ticket < ticket || entry.claim.ticket === ticket && entry.id < id));
+      if (!ahead) {
+        try {
+          lock = await fs.open(file, "wx", 384);
+          await lock.writeFile(JSON.stringify(owner));
+          return { close: release };
+        } catch (error) {
+          if (error.code !== "EEXIST") throw error;
+          const holder = await readProcessState(file);
+          const age = Date.now() - (await fs.stat(file).catch(() => ({ mtimeMs: Date.now() }))).mtimeMs;
+          if (age > 5e3 && !await processStateAlive(holder)) {
+            await fs.rm(file, { force: true });
+            continue;
+          }
+        }
+      }
+      await setTimeout$1(250, void 0, { signal: options.signal });
+    }
+    throw new Error("Another Mindwire operation is in progress. Try again shortly.");
+  } catch (error) {
+    await release();
+    throw error;
+  }
+}
+
+// src/computer/lifecycle.ts
+var defaultStateDirectory = () => path.join(homedir(), ".mindwire", "computer");
+var defaultComputerConfig = () => ({ directory: homedir(), bind: "0.0.0.0", sshPort: 8791, websocketPort: 8792, relay: { kind: "cloudflare" } });
+async function readJSON(file) {
+  try {
+    return JSON.parse(await fs.readFile(file, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+async function writeJSON(file, value) {
+  const temp = `${file}.${randomUUID()}.tmp`;
+  try {
+    await fs.writeFile(temp, JSON.stringify(value) + "\n", { mode: 384 });
+    await fs.rename(temp, file);
+  } finally {
+    await fs.rm(temp, { force: true });
+  }
+}
+async function computerClient(directory) {
+  const runtime = await readJSON(path.join(directory, "computer-runtime.json"));
+  if (!runtime) throw new Error("Mindwire is not running. Run mindwire connect on the computer.");
+  const url = new URL(`http://${runtime.apiAddress}`);
+  if (!["127.0.0.1", "[::1]"].includes(url.hostname) || url.username || url.password) throw new Error("Invalid local Mindwire address.");
+  const token = (await fs.readFile(path.join(directory, "daemon.token"), "utf8")).trim();
+  const client = new Mindwire({ target: remote(url.origin, { token }), requestTimeoutMs: 3e3 });
+  const info = await client.computer.info();
+  if (info.computerId !== runtime.computerId || info.pid !== runtime.pid) throw new Error("The local Mindwire process changed. Retry the command.");
+  return client;
+}
+function directRoutes(config, port) {
+  if (config.host) return [{ kind: "ssh", host: config.host, port }];
+  if (!["0.0.0.0", "::"].includes(config.bind)) return [{ kind: "ssh", host: config.bind, port }];
+  const addresses = /* @__PURE__ */ new Set();
+  for (const entries of Object.values(networkInterfaces())) {
+    for (const address of entries ?? []) if (address.family === "IPv4" && !address.internal) addresses.add(address.address);
+  }
+  return [...addresses].slice(0, 6).map((host) => ({ kind: "ssh", host, port }));
+}
+async function ensureComputer(directory, cliPath, patch = {}, onProgress, options = {}) {
+  const resume = options.resume !== false;
+  options.signal?.throwIfAborted();
+  await fs.mkdir(directory, { recursive: true, mode: 448 });
+  const stoppedPath = path.join(directory, "computer-stopped.json");
+  if (resume) await fs.rm(stoppedPath, { force: true });
+  else if ((await readJSON(stoppedPath))?.stopped) throw new Error("Mindwire was stopped by its owner.");
+  let current;
+  try {
+    current = await computerClient(directory);
+  } catch {
+  }
+  const configPath = path.join(directory, "computer-config.json");
+  const previous = await readJSON(configPath);
+  const config = { ...defaultComputerConfig(), ...previous, ...patch };
+  let launchedPID;
+  let launchFailure;
+  const waitUntilReady = async () => {
+    let phase;
+    for (let attempt = 0; attempt < 1200; attempt++) {
+      options.signal?.throwIfAborted();
+      const controller = await readJSON(path.join(directory, "computer-controller.json"));
+      if (launchFailure) throw launchFailure;
+      if (launchedPID && controller?.pid !== launchedPID) {
+        await setTimeout$1(250);
+        continue;
+      }
+      if (controller?.error && !controller.recovering) throw new Error(controller.error);
+      if (controller?.ready && await processStateAlive(controller)) return computerClient(directory);
+      if (controller?.phase && controller.phase !== phase) {
+        phase = controller.phase;
+        onProgress?.(phase);
+      }
+      await setTimeout$1(250);
+    }
+    throw new Error(`Mindwire did not finish starting. Inspect ${path.join(directory, "computer.log")}.`);
+  };
+  if (current) {
+    if (Object.keys(patch).some((key) => JSON.stringify(config[key]) !== JSON.stringify(previous?.[key]))) {
+      throw new Error("Mindwire is running with different connection settings. Run mindwire stop when idle, then retry with the new settings.");
+    }
+    const controller = await readJSON(path.join(directory, "computer-controller.json"));
+    if (await processStateAlive(controller)) return waitUntilReady();
+  }
+  const lockPath = path.join(directory, "launch.lock");
+  const lock = await acquireProcessLock(lockPath, {
+    signal: options.signal,
+    onWait: async () => {
+      const controller = await readJSON(path.join(directory, "computer-controller.json"));
+      if (await processStateAlive(controller)) {
+        const saved = await readJSON(configPath);
+        if (Object.keys(patch).some((key) => JSON.stringify(patch[key]) !== JSON.stringify(saved?.[key]))) {
+          throw new Error("Another start used different connection settings. Stop Mindwire when idle before changing them.");
+        }
+        return true;
+      }
+      return false;
+    }
+  });
+  if (!lock) return waitUntilReady();
+  try {
+    if (!resume && (await readJSON(stoppedPath))?.stopped) throw new Error("Mindwire was stopped by its owner.");
+    let existing;
+    try {
+      existing = await computerClient(directory);
+    } catch {
+    }
+    if (existing) {
+      const saved = await readJSON(configPath);
+      if (Object.keys(patch).some((key) => JSON.stringify(patch[key]) !== JSON.stringify(saved?.[key]))) {
+        throw new Error("Another start used different connection settings. Stop Mindwire when idle before changing them.");
+      }
+      const controller2 = await readJSON(path.join(directory, "computer-controller.json"));
+      if (await processStateAlive(controller2)) return waitUntilReady();
+    }
+    const controller = await readJSON(path.join(directory, "computer-controller.json"));
+    if (await processStateAlive(controller)) {
+      if (controller?.error && !controller.recovering) throw new Error(controller.error);
+    } else {
+      await writeJSON(configPath, config);
+      const log = await fs.open(path.join(directory, "computer.log"), "a", 384);
+      try {
+        const child = spawn(process.execPath, [cliPath, "_serve", "--state-dir", directory], {
+          detached: true,
+          stdio: ["ignore", log.fd, log.fd],
+          windowsHide: true
+        });
+        await new Promise((resolve, reject) => {
+          child.once("spawn", resolve);
+          child.once("error", reject);
+        });
+        launchedPID = child.pid;
+        child.on("exit", () => {
+          launchFailure = new Error(`The computer controller stopped. Inspect ${path.join(directory, "computer.log")}.`);
+        });
+        child.unref();
+      } finally {
+        await log.close();
+      }
+    }
+    return await waitUntilReady();
+  } finally {
+    await lock.close();
+  }
+}
+async function superviseComputer(directory) {
+  const controller = await import('./controller-CGSJZZZD.js');
+  await controller.superviseComputer(directory);
+}
+async function stopComputer(directory, force = false) {
+  const client = await computerClient(directory);
+  const controller = await readJSON(path.join(directory, "computer-controller.json"));
+  if (!await processStateAlive(controller)) throw new Error("The Mindwire controller is not running.");
+  const lease = force ? void 0 : await client.service.acquireUpdate();
+  try {
+    await writeJSON(path.join(directory, "computer-stopped.json"), { stopped: true });
+    if (!await processStateAlive(controller)) throw new Error("The Mindwire controller changed. Retry the command.");
+    process.kill(controller.pid, "SIGTERM");
+  } catch (error) {
+    await fs.rm(path.join(directory, "computer-stopped.json"), { force: true });
+    if (lease) await client.service.releaseUpdate(lease.id);
+    throw error;
+  }
+  for (let attempt = 0; attempt < 80; attempt++) {
+    if (!await processStateAlive(controller)) return;
+    await setTimeout$1(250);
+  }
+  throw new Error("Mindwire is still stopping. Check computer.log.");
+}
+
+export { SDK_VERSION, acquireProcessLock, adoptProcess, computerClient, computerPairingQRData, computerPairingURI, currentProcessIdentity, defaultStateDirectory, directRoutes, ensureComputer, ensureDaemonBinary, ownChild, processIdentity, processStateAlive, readJSON, stopComputer, superviseComputer, writeJSON };
+//# sourceMappingURL=chunk-L3USUTZZ.js.map
+//# sourceMappingURL=chunk-L3USUTZZ.js.map