mindwire 0.1.0 → 0.1.1

package/dist/index.cjs

@@ -0,0 +1,2297 @@
+'use strict';
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+// src/errors.ts
+var MindwireError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "MindwireError";
+  }
+};
+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;
+  }
+};
+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;
+  }
+};
+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;
+  }
+};
+
+// 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, path) {
+    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} ${path} \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, path) {
+    if (!this.timeoutMs || this.timeoutMs <= 0) {
+      return this.fetchOnce(f, url, { ...init, ...userSignal ? { signal: userSignal } : {} }, method, path);
+    }
+    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, path);
+    } catch (e) {
+      if (timedOut) throw new TimeoutError(method, path, 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, path, query) {
+    const u = new URL(baseUrl + (path.startsWith("/") ? path : `/${path}`));
+    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, path, init = {}) {
+    const base = await this.base();
+    const hasBody = init.body !== void 0;
+    const url = this.url(base.baseUrl, path, 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,
+      path
+    );
+    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} ${path} returned a non-JSON body`, { cause: e });
+    }
+  }
+  /** Open a streaming response (SSE). Caller owns the body. */
+  async open(method, path, init = {}) {
+    const base = await this.base();
+    const url = this.url(base.baseUrl, path, 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.signal ? { signal: init.signal } : {}
+      },
+      method,
+      path
+    );
+    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} ${path} 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);
+    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 res = await this.http.open("GET", `/runs/${encodeURIComponent(this.id)}/stream`, {
+      ...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 mid-turn interaction the turn is waiting on — a permission approval, or an
+   * AskUserQuestion / ExitPlanMode reply. 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 permission mode of the live turn (e.g. `default`, `acceptEdits`, `plan`,
+   * `bypassPermissions`). Only meaningful on a persistent (non-bypass) turn; on a one-shot turn it
+   * is a best-effort no-op. Requires the agent's `setPermissionMode` capability.
+   */
+  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;
+  }
+  /**
+   * 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/version.ts
+var SDK_VERSION = "0.1.1" ;
+
+// 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 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 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 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());
+  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;
+}
+
+// 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 } = await import('child_process');
+  const net = await import('net');
+  const proc = serverRuntime().process;
+  const resolved = await resolveBinary(opts.bin);
+  const bin = resolved.bin;
+  const port = await freePort(net);
+  const baseUrl = `http://127.0.0.1:${port}`;
+  const child = spawn(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: ""
+    },
+    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, () => spawnError, resolved);
+  return { baseUrl, stop };
+}
+async function resolveBinary(explicit) {
+  const fs = await import('fs');
+  const path = 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 = path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))));
+    const named = `mindwired-${proc.platform}-${proc.arch}${ext}`;
+    candidates.push(path.join(here, "bin", named), path.join(here, "..", "bin", named));
+  } catch {
+  }
+  for (const c of candidates) {
+    try {
+      if (fs.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 `bun run build:daemon` from the repo root to build it.",
+      `(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, 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`);
+      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 {
+  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.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.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` — public 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 /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` — re-run the toolchain, forcing reinstall of installable steps. */
+  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 -----------------------------------------------------
+  /** `GET /chats` — recorded chats (newest first), shared across agents. */
+  chats() {
+    return this.http.request("GET", "/chats");
+  }
+  /**
+   * `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.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;
+    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 path = "/processes/stream" + (opts.agent ? `?agent=${encodeURIComponent(opts.agent)}` : "");
+    const res = await this.http.open("GET", path, {
+      ...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
+    });
+  }
+  /** `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)
+    });
+  }
+};
+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)}`);
+  }
+};
+
+// src/target/host.ts
+function makeEmit(cfg) {
+  const target = cfg.target ?? "sandbox";
+  return (e) => {
+    if (!cfg.onLog) return;
+    try {
+      cfg.onLog({ target, ...e });
+    } catch {
+    }
+  };
+}
+var DAEMON_DIR = "/root/.mindwire";
+var BIN = `${DAEMON_DIR}/mindwired`;
+var BIN_NEW = `${BIN}.new`;
+var STATE = `${DAEMON_DIR}/agent-state.json`;
+var LOG = `${DAEMON_DIR}/daemon.log`;
+async function ensureDaemon(host, cfg) {
+  const emit2 = makeEmit(cfg);
+  try {
+    await waitHostReady(host);
+    emit2({ phase: "connect", message: "runtime ready" });
+    const desired = cfg.desiredVersion ?? SDK_VERSION;
+    const health = await probeHealth(host, cfg.port);
+    if (health.reachable) {
+      emit2({
+        phase: "probe",
+        message: health.version ? `daemon reachable (v${health.version})` : "daemon reachable (version unknown)",
+        version: health.version
+      });
+      const upToDate = health.version !== void 0 && health.version === desired;
+      if (upToDate || !cfg.autoUpdate) {
+        emit2({
+          phase: "skip",
+          message: upToDate ? `daemon already at v${desired}` : "keeping the running daemon",
+          version: health.version
+        });
+        return;
+      }
+    } else {
+      emit2({ phase: "probe", message: "no daemon reachable; deploying" });
+    }
+    await deploy(host, cfg, emit2);
+  } catch (err) {
+    emit2({ phase: "error", message: "ensure failed", error: err instanceof Error ? err.message : String(err) });
+    throw err;
+  }
+}
+async function deploy(host, cfg, emit2) {
+  const arch = await probeArch(host);
+  const desired = cfg.desiredVersion ?? SDK_VERSION;
+  let acquire = "";
+  if (cfg.daemonBin) {
+    const binPath = await resolveLinuxDaemon(cfg.daemonBin, arch);
+    const bytes = await readBytes(binPath);
+    emit2({ phase: "upload", message: `uploading daemon (${arch}, ${bytes.length} bytes)`, arch, bytes: bytes.length });
+    await host.putFile(BIN_NEW, bytes, { mode: "0755" });
+  } else {
+    if (!/^[0-9]+\.[0-9]+\.[0-9]+(?:-[0-9A-Za-z.-]+)?$/.test(desired)) {
+      throw new MindwireError(`mindwire: cannot download daemon for non-release SDK version ${desired}`);
+    }
+    const asset = `mindwired-v${desired}-linux-${arch === "arm64" ? "arm64" : "amd64"}`;
+    const release = `https://github.com/oblien/mindwire/releases/download/v${desired}`;
+    emit2({ phase: "download", message: `downloading daemon v${desired} on the destination (${arch})`, arch });
+    acquire = [
+      `release=${shellQuote(release)}`,
+      `asset=${shellQuote(asset)}`,
+      "download() {",
+      `  expected=$(curl -fsSL "$release/checksums.txt" | awk -v asset="$asset" '$2 == asset { print $1; exit }') || return 1`,
+      '  [ -n "$expected" ] || return 1',
+      `  curl -fsSL "$release/$asset" -o ${BIN_NEW} || return 1`,
+      `  actual=$(sha256sum ${BIN_NEW} | awk '{print $1}')`,
+      '  [ "$actual" = "$expected" ] || return 2',
+      "}",
+      "if download; then :; else",
+      '  status=$?; [ "$status" -ne 2 ] || { echo "MINDWIRE_FAIL checksum mismatch for $asset"; exit 1; }',
+      `  latest=$(curl -fsSL https://api.github.com/repos/oblien/mindwire/releases/latest | sed -n 's/.*"tag_name"[[:space:]]*:[[:space:]]*"\\([^"]*\\)".*/\\1/p')`,
+      '  case "$latest" in v[0-9]*.[0-9]*.[0-9]*) ;; *) echo "MINDWIRE_FAIL no matching or latest release"; exit 1 ;; esac',
+      '  release="https://github.com/oblien/mindwire/releases/download/$latest"',
+      `  asset="mindwired-$latest-linux-${arch === "arm64" ? "arm64" : "amd64"}"`,
+      '  download || { echo "MINDWIRE_FAIL latest release download failed"; exit 1; }',
+      "fi",
+      `chmod +x ${BIN_NEW}`
+    ].join("\n");
+  }
+  const script = [
+    "set -e",
+    `mkdir -p ${DAEMON_DIR}`,
+    acquire,
+    // Stop a prior daemon by exact process NAME, never `pkill -f <path>`: this whole script (which
+    // contains `${BIN}` several times) is the argv of the `bash -lc` shell running it, so a full-cmdline
+    // match would SIGTERM our own deploying shell before the daemon ever launches. `-x mindwired` matches
+    // only the daemon's comm (`bash`/`pkill` never match), leaving this shell alive.
+    `pkill -x mindwired 2>/dev/null || true`,
+    "sleep 0.3",
+    `mv -f ${BIN_NEW} ${BIN}`,
+    `chmod +x ${BIN}`,
+    // Detach so the daemon survives this exec's shell exiting. ADDR=":<port>" binds 0.0.0.0.
+    `setsid nohup env ADDR=":${cfg.port}" AGENT_TYPE="${cfg.agent}" AGENT_CWD="${cfg.agentCwd}" STATE_PATH="${STATE}" DAEMON_TOKEN="" ${BIN} > ${LOG} 2>&1 < /dev/null &`,
+    // Health-poll from inside the VM (loopback) and emit a marker — exit codes are unreliable here.
+    `for i in $(seq 1 60); do curl -fsS --max-time 2 http://127.0.0.1:${cfg.port}/healthz >/dev/null 2>&1 && { echo MINDWIRE_READY; exit 0; }; sleep 0.25; done`,
+    "echo MINDWIRE_FAIL",
+    `tail -n 40 ${LOG} 2>/dev/null || true`
+  ].join("\n");
+  emit2({ phase: "launch", message: "launching daemon" });
+  const res = await host.exec(["bash", "-lc", script], { timeoutSeconds: 45 });
+  const out = res.stdout ?? "";
+  if (!out.includes("MINDWIRE_READY")) {
+    throw new MindwireError(
+      "mindwire: the in-sandbox daemon did not become healthy after deploy.\n" + (out || res.stderr || res.error || "(no output)").trim()
+    );
+  }
+  emit2({ phase: "ready", message: "daemon deployed and healthy" });
+}
+async function probeHealth(host, port) {
+  const script = `out=$(curl -fsS --max-time 3 http://127.0.0.1:${port}/healthz 2>/dev/null) && printf '<<MW_H>>%s<<MW_H>>' "$out" || printf '<<MW_H>><<MW_H>>'`;
+  const res = await host.exec(["bash", "-lc", script], { timeoutSeconds: 15 });
+  const body = ((res.stdout ?? "").match(/<<MW_H>>([\s\S]*?)<<MW_H>>/)?.[1] ?? "").trim();
+  if (!body) return { reachable: false };
+  try {
+    const j = JSON.parse(body);
+    return { reachable: true, version: typeof j.version === "string" ? j.version : void 0 };
+  } catch {
+    return { reachable: true };
+  }
+}
+async function probeArch(host) {
+  const res = await host.exec(["bash", "-lc", `printf '<<ARCH:%s>>' "$(uname -m)"`], { timeoutSeconds: 15 });
+  const raw = ((res.stdout ?? "").match(/<<ARCH:([^>]*)>>/)?.[1] ?? "").trim();
+  return raw === "aarch64" || raw === "arm64" ? "arm64" : "amd64";
+}
+async function waitHostReady(host, timeoutMs = 6e4) {
+  const deadline = Date.now() + timeoutMs;
+  let lastErr = null;
+  while (Date.now() < deadline) {
+    try {
+      const r = await host.exec(["bash", "-lc", "echo mw_ready"], { timeoutSeconds: 10 });
+      if ((r.stdout ?? "").includes("mw_ready")) return;
+    } catch (e) {
+      lastErr = e;
+    }
+    await sleep(1e3);
+  }
+  throw new MindwireError(
+    "mindwire: the sandbox runtime did not become ready in time.",
+    lastErr ? { cause: lastErr } : void 0
+  );
+}
+async function resolveLinuxDaemon(explicit, arch) {
+  const fs = await import('fs');
+  if (explicit) {
+    if (!fs.existsSync(explicit)) {
+      throw new MindwireError(`mindwire: sandbox daemonBin not found at ${explicit}`);
+    }
+    return explicit;
+  }
+  return ensureDaemonBinary({ platform: "linux", arch: arch === "arm64" ? "arm64" : "x64" });
+}
+async function readBytes(p) {
+  const fs = await import('fs/promises');
+  return fs.readFile(p);
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+
+// src/target/container.ts
+async function provisionContainer(host, cfg, onLog) {
+  const target = cfg.target ?? "container";
+  const emit2 = (e) => {
+    if (!onLog) return;
+    try {
+      onLog({ target, ...e });
+    } catch {
+    }
+  };
+  await ensureDockerReady(host, cfg.install ?? "never", emit2);
+  const { containerId, hostPort, created } = await runContainer(host, cfg, emit2);
+  await ensureDaemon(new ContainerHost(host, containerId), {
+    port: cfg.daemonPort,
+    agent: cfg.agent,
+    agentCwd: cfg.agentCwd,
+    daemonBin: cfg.daemonBin,
+    autoUpdate: cfg.autoUpdate,
+    target,
+    onLog
+  });
+  let stopped = false;
+  const stop = async () => {
+    if (stopped) return;
+    stopped = true;
+    if (!created || !(cfg.stopOnExit ?? true)) return;
+    try {
+      await host.exec(["docker", "rm", "-f", containerId]);
+    } catch {
+    }
+  };
+  return { containerId, hostPort, stop };
+}
+var ContainerHost = class {
+  constructor(base, containerId) {
+    this.base = base;
+    this.containerId = containerId;
+  }
+  base;
+  containerId;
+  exec(argv, opts) {
+    return this.base.exec(["docker", "exec", this.containerId, ...argv], opts);
+  }
+  async putFile(path, data, opts) {
+    const slash = path.lastIndexOf("/");
+    const dir = slash > 0 ? path.slice(0, slash) : "/";
+    const base = path.slice(slash + 1);
+    const mode = opts?.mode ?? "0644";
+    const tmp = `/tmp/.mw-${this.containerId.slice(0, 12)}-${base}`;
+    await this.base.exec(["docker", "exec", this.containerId, "mkdir", "-p", dir]);
+    await this.base.putFile(tmp, data, opts);
+    await this.base.exec(["docker", "cp", tmp, `${this.containerId}:${path}`]);
+    await this.base.exec(["docker", "exec", this.containerId, "chmod", mode, path]);
+    await this.base.exec(["rm", "-f", tmp]);
+  }
+};
+async function ensureDockerReady(host, install, emit2) {
+  let state = await detectDocker(host);
+  if (state.status === "running") {
+    emit2({ phase: "install", message: `docker present (v${state.version ?? "?"})`, version: state.version });
+    return;
+  }
+  if (state.status === "denied") {
+    throw new 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."
+    );
+  }
+  if (state.status === "stopped") {
+    emit2({ phase: "install", message: "docker installed but not running; starting it" });
+    await startDocker(host);
+    state = await detectDocker(host);
+    if (state.status === "running") {
+      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.");
+  }
+  if (install !== "ifMissing") {
+    throw new 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.'
+    );
+  }
+  emit2({ phase: "install", message: "docker not found; installing via get.docker.com" });
+  await installDocker(host);
+  await startDocker(host);
+  state = await detectDocker(host);
+  if (state.status !== "running") {
+    throw new MindwireError(
+      "mindwire: ran the get.docker.com install script, but the Docker daemon did not come up."
+    );
+  }
+  emit2({ phase: "install", message: `docker installed and started (v${state.version ?? "?"})`, version: state.version });
+}
+async function detectDocker(host) {
+  const script = [
+    'if ! command -v docker >/dev/null 2>&1; then echo "MW_DOCKER=absent"; exit 0; fi',
+    'if v=$(docker info --format "{{.ServerVersion}}" 2>/dev/null); then echo "MW_DOCKER=running:$v"; exit 0; fi',
+    "err=$(docker info 2>&1 >/dev/null || true)",
+    'case "$err" in',
+    '  *ermission*denied*) echo "MW_DOCKER=denied" ;;',
+    '  *) echo "MW_DOCKER=stopped" ;;',
+    "esac"
+  ].join("\n");
+  const res = await host.exec(["bash", "-lc", script], { timeoutSeconds: 30 });
+  const m = (res.stdout ?? "").match(/MW_DOCKER=([a-z]+)(?::([^\n]*))?/);
+  const status = m?.[1] ?? "absent";
+  const version = m?.[2]?.trim() || void 0;
+  return { status, version };
+}
+async function installDocker(host) {
+  const res = await host.exec(["bash", "-lc", "curl -fsSL https://get.docker.com | sh"], {
+    timeoutSeconds: 600
+  });
+  if ((res.exitCode ?? 0) !== 0) {
+    throw new MindwireError(
+      "mindwire: the Docker install script (get.docker.com) failed.\n" + (res.stderr || res.stdout || "(no output)").trim()
+    );
+  }
+}
+async function startDocker(host) {
+  await host.exec(
+    ["bash", "-lc", "systemctl enable --now docker 2>/dev/null || service docker start 2>/dev/null || true"],
+    { timeoutSeconds: 60 }
+  );
+}
+async function runContainer(host, cfg, emit2) {
+  const port = cfg.daemonPort;
+  if (cfg.container !== void 0) {
+    await host.exec(["docker", "start", cfg.container]);
+    const hostPort2 = await resolveHostPort(host, cfg.container, port);
+    emit2({
+      phase: "provision",
+      message: `attached to container ${cfg.container}; daemon published on host port ${hostPort2}`
+    });
+    return { containerId: cfg.container, hostPort: hostPort2, created: false };
+  }
+  if (!cfg.image) {
+    throw new 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."
+    );
+  }
+  const runArgs = ["docker", "run", "-d"];
+  if (cfg.name) runArgs.push("--name", cfg.name);
+  runArgs.push("-p", `127.0.0.1:0:${port}`);
+  if (cfg.createArgs?.length) runArgs.push(...cfg.createArgs);
+  runArgs.push(cfg.image, "sleep", "infinity");
+  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(
+      "mindwire: `docker run` did not start a container.\n" + (res.stderr || res.stdout || "(no output)").trim()
+    );
+  }
+  const hostPort = await resolveHostPort(host, containerId, port);
+  emit2({
+    phase: "provision",
+    message: `container ${containerId.slice(0, 12)} up; daemon published on host port ${hostPort}`
+  });
+  return { containerId, hostPort, created: true };
+}
+async function resolveHostPort(host, containerId, port) {
+  const res = await host.exec(["docker", "port", containerId, `${port}/tcp`]);
+  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(
+      `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())}`
+    );
+  }
+  return hostPort;
+}
+function cfgHint(res) {
+  return (res.stdout ?? "").trim() === "" ? "Attach to a container started with that port published (e.g. `-p 127.0.0.1:0:<port>`). " : "";
+}
+
+// src/target/ssh.ts
+function ssh(opts) {
+  return { name: "ssh", connect: (spec) => connectSsh(opts, spec) };
+}
+var DEFAULT_PORT = 8790;
+var DEFAULT_AGENT = "claude-code";
+var DEFAULT_AGENT_CWD = "/root";
+var SshHost = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  exec(argv) {
+    const command = toCommandLine(argv);
+    return new Promise((resolve, reject) => {
+      this.client.exec(command, (err, channel) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        const out = [];
+        const errb = [];
+        let code;
+        channel.on("data", (chunk) => out.push(Buffer.from(chunk)));
+        channel.stderr?.on("data", (chunk) => errb.push(Buffer.from(chunk)));
+        channel.on("close", (c) => {
+          code = typeof c === "number" ? c : void 0;
+          resolve({
+            exitCode: code,
+            stdout: Buffer.concat(out).toString("utf8"),
+            stderr: Buffer.concat(errb).toString("utf8")
+          });
+        });
+        channel.on("error", (e) => reject(e));
+      });
+    });
+  }
+  async putFile(path, data, opts) {
+    const slash = path.lastIndexOf("/");
+    const dir = slash > 0 ? path.slice(0, slash) : "/";
+    await this.exec(["mkdir", "-p", dir]);
+    const sftp = await this.sftp();
+    const mode = parseInt(opts?.mode ?? "0644", 8) || 420;
+    await new Promise((resolve, reject) => {
+      const ws = sftp.createWriteStream(path, { mode });
+      let done = false;
+      const finish = () => {
+        if (!done) {
+          done = true;
+          resolve();
+        }
+      };
+      ws.on("error", (e) => reject(e));
+      ws.on("close", finish);
+      ws.on("finish", finish);
+      ws.end?.(Buffer.from(data));
+    });
+  }
+  sftp() {
+    return new Promise((resolve, reject) => {
+      this.client.sftp((err, sftp) => err ? reject(err) : resolve(sftp));
+    });
+  }
+};
+async function connectSsh(opts, spec) {
+  const mod = await importSsh2();
+  const net = await import('net');
+  const client = await openConnection(mod, opts);
+  const daemonPort = opts.daemonPort ?? DEFAULT_PORT;
+  const makeTunnel = (c, port) => createTunnel(net, c, port);
+  const shared2 = {
+    daemonPort,
+    agent: opts.agentType ?? spec.agent ?? DEFAULT_AGENT,
+    agentCwd: opts.agentCwd ?? DEFAULT_AGENT_CWD,
+    daemonBin: opts.daemonBin,
+    autoUpdate: opts.autoUpdate,
+    stopOnExit: opts.stopOnExit ?? true,
+    onLog: spec.onLog
+  };
+  if (opts.docker) {
+    return provisionSshContainer(client, makeTunnel, {
+      ...shared2,
+      id: `${opts.username}@${opts.host}/docker`,
+      docker: opts.docker
+    });
+  }
+  return provisionSsh(client, makeTunnel, {
+    ...shared2,
+    id: `${opts.username}@${opts.host}:${daemonPort}`
+  });
+}
+async function provisionSsh(client, makeTunnel, cfg) {
+  await ensureDaemon(new SshHost(client), {
+    port: cfg.daemonPort,
+    agent: cfg.agent,
+    agentCwd: cfg.agentCwd,
+    daemonBin: cfg.daemonBin,
+    autoUpdate: cfg.autoUpdate,
+    target: "ssh",
+    onLog: cfg.onLog
+  });
+  const tunnel = await makeTunnel(client, cfg.daemonPort);
+  let stopped = false;
+  const stop = async () => {
+    if (stopped) return;
+    stopped = true;
+    await tunnel.close().catch(() => {
+    });
+    if (cfg.stopOnExit ?? true) {
+      try {
+        client.end();
+      } catch {
+      }
+    }
+  };
+  return { id: cfg.id, baseUrl: tunnel.baseUrl, stop };
+}
+async function provisionSshContainer(client, makeTunnel, cfg) {
+  const container = await provisionContainer(
+    new SshHost(client),
+    {
+      image: cfg.docker.image,
+      container: cfg.docker.container,
+      name: cfg.docker.name,
+      install: cfg.docker.install,
+      createArgs: cfg.docker.createArgs,
+      daemonPort: cfg.daemonPort,
+      agent: cfg.agent,
+      agentCwd: cfg.agentCwd,
+      daemonBin: cfg.daemonBin,
+      autoUpdate: cfg.autoUpdate,
+      stopOnExit: cfg.stopOnExit ?? true,
+      target: "ssh"
+    },
+    cfg.onLog
+  );
+  const tunnel = await makeTunnel(client, container.hostPort);
+  let stopped = false;
+  const stop = async () => {
+    if (stopped) return;
+    stopped = true;
+    await tunnel.close().catch(() => {
+    });
+    await container.stop().catch(() => {
+    });
+    if (cfg.stopOnExit ?? true) {
+      try {
+        client.end();
+      } catch {
+      }
+    }
+  };
+  return { id: cfg.id, baseUrl: tunnel.baseUrl, stop };
+}
+async function openConnection(mod, opts) {
+  const auth = await buildAuth(opts);
+  return new Promise((resolve, reject) => {
+    const client = new mod.Client();
+    let settled = false;
+    client.on("ready", () => {
+      if (settled) return;
+      settled = true;
+      resolve(client);
+    });
+    client.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      reject(
+        new MindwireError(
+          `mindwire: SSH connection to ${opts.username}@${opts.host}:${opts.port ?? 22} failed: ${err.message}`,
+          { cause: err }
+        )
+      );
+    });
+    client.connect({
+      host: opts.host,
+      port: opts.port ?? 22,
+      username: opts.username,
+      readyTimeout: opts.readyTimeoutMs ?? 2e4,
+      ...auth
+    });
+  });
+}
+async function buildAuth(opts) {
+  if (opts.privateKey !== void 0) {
+    return { privateKey: opts.privateKey, ...opts.passphrase ? { passphrase: opts.passphrase } : {} };
+  }
+  if (opts.privateKeyPath !== void 0) {
+    const fs = await import('fs/promises');
+    const key = await fs.readFile(opts.privateKeyPath);
+    return { privateKey: key, ...opts.passphrase ? { passphrase: opts.passphrase } : {} };
+  }
+  if (opts.password !== void 0) {
+    return { password: opts.password };
+  }
+  const sock = opts.agent ?? env("SSH_AUTH_SOCK");
+  return sock ? { agent: sock } : {};
+}
+async function createTunnel(net, client, daemonPort) {
+  await new Promise((resolve, reject) => {
+    client.forwardOut("127.0.0.1", 0, "127.0.0.1", daemonPort, (err, stream) => {
+      if (err) {
+        reject(
+          new 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 }
+          )
+        );
+        return;
+      }
+      try {
+        (stream.destroy ?? stream.end)?.call(stream);
+      } catch {
+      }
+      resolve();
+    });
+  });
+  const sockets = /* @__PURE__ */ new Set();
+  const server = net.createServer((socket) => {
+    sockets.add(socket);
+    socket.on("close", () => sockets.delete(socket));
+    socket.on("error", () => {
+    });
+    client.forwardOut("127.0.0.1", 0, "127.0.0.1", daemonPort, (err, stream) => {
+      if (err) {
+        socket.destroy();
+        return;
+      }
+      stream.on("error", () => socket.destroy());
+      const duplex = stream;
+      socket.pipe(duplex).pipe(socket);
+    });
+  });
+  const localPort = await new Promise((resolve, reject) => {
+    server.on("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      resolve(addr && typeof addr === "object" ? addr.port : 0);
+    });
+  });
+  const close = async () => {
+    for (const s of sockets) {
+      try {
+        s.destroy();
+      } catch {
+      }
+    }
+    sockets.clear();
+    await new Promise((resolve) => server.close(() => resolve()));
+  };
+  return { baseUrl: `http://127.0.0.1:${localPort}`, close };
+}
+function shQuote(s) {
+  return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+function toCommandLine(argv) {
+  return argv.map(shQuote).join(" ");
+}
+async function importSsh2() {
+  const spec = "ssh2";
+  try {
+    const mod = await import(
+      /* @vite-ignore */
+      spec
+    );
+    return mod.default && mod.default.Client ? mod.default : mod;
+  } catch (err) {
+    throw new 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 }
+    );
+  }
+}
+function env(key) {
+  const proc = globalThis.process;
+  return proc?.env?.[key];
+}
+
+// src/target/docker.ts
+function docker(config = {}) {
+  return { name: "docker", connect: (spec) => connectDocker(config, spec) };
+}
+var DEFAULT_PORT2 = 8790;
+var DEFAULT_AGENT2 = "claude-code";
+var DEFAULT_AGENT_CWD2 = "/root";
+var DockerHost = class {
+  constructor(container) {
+    this.container = container;
+  }
+  container;
+  async exec(argv) {
+    const { Writable } = await import('stream');
+    const exec = await this.container.exec({ Cmd: argv, AttachStdout: true, AttachStderr: true });
+    const stream = await exec.start({ hijack: true, stdin: false });
+    const out = [];
+    const err = [];
+    const sink = (arr) => new Writable({
+      write(chunk, _enc, cb) {
+        arr.push(Buffer.from(chunk));
+        cb();
+      }
+    });
+    this.container.modem.demuxStream(stream, sink(out), sink(err));
+    await new Promise((resolve, reject) => {
+      stream.on("end", () => resolve());
+      stream.on("close", () => resolve());
+      stream.on("error", (e) => reject(e instanceof Error ? e : new Error(String(e))));
+    });
+    const info = await exec.inspect();
+    return {
+      exitCode: info.ExitCode,
+      stdout: Buffer.concat(out).toString("utf8"),
+      stderr: Buffer.concat(err).toString("utf8")
+    };
+  }
+  async putFile(path, data, opts) {
+    const slash = path.lastIndexOf("/");
+    const dir = slash > 0 ? path.slice(0, slash) : "/";
+    const base = path.slice(slash + 1);
+    await this.exec(["mkdir", "-p", dir]);
+    const tar = tarSingleFile(base, data, opts?.mode ?? "0644");
+    await this.container.putArchive(tar, { path: dir });
+  }
+};
+async function connectDocker(config, spec) {
+  const Docker = await importDockerode();
+  const instance = config.docker ?? new Docker(config.engine);
+  const merged = { ...config, agent: config.agent ?? spec.agent };
+  return provisionDocker(instance, merged, spec.onLog);
+}
+async function provisionDocker(docker2, config = {}, onLog) {
+  const port = config.port ?? DEFAULT_PORT2;
+  const agent = config.agent ?? DEFAULT_AGENT2;
+  const agentCwd = config.agentCwd ?? DEFAULT_AGENT_CWD2;
+  const created = config.container === void 0;
+  let container;
+  if (config.container !== void 0) {
+    container = docker2.getContainer(config.container);
+  } else {
+    if (!config.image) {
+      throw new MindwireError(
+        "mindwire: the Docker adapter needs an image or a container \u2014 pass docker({ image }) to create one, or docker({ container }) to attach to an existing one."
+      );
+    }
+    const portKey = `${port}/tcp`;
+    container = await docker2.createContainer({
+      Image: config.image,
+      Cmd: ["sleep", "infinity"],
+      Tty: false,
+      ExposedPorts: { [portKey]: {} },
+      HostConfig: { PortBindings: { [portKey]: [{ HostPort: "0" }] } },
+      ...config.createOptions ?? {}
+    });
+  }
+  await container.start().catch(() => {
+  });
+  const info = await container.inspect();
+  const binding = info.NetworkSettings?.Ports?.[`${port}/tcp`];
+  const hostPort = binding?.[0]?.HostPort;
+  if (!hostPort) {
+    throw new 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 + "`).")
+    );
+  }
+  await ensureDaemon(new DockerHost(container), {
+    port,
+    agent,
+    agentCwd,
+    daemonBin: config.daemonBin,
+    autoUpdate: config.autoUpdate,
+    target: "docker",
+    onLog
+  });
+  const stop = async () => {
+    if (!config.stopOnExit) return;
+    if (!created) return;
+    try {
+      await container.stop().catch(() => {
+      });
+      await container.remove({ force: true });
+    } catch {
+    }
+  };
+  return { id: container.id, baseUrl: `http://127.0.0.1:${hostPort}`, stop };
+}
+function tarSingleFile(name, data, mode) {
+  const header = Buffer.alloc(512, 0);
+  header.write(name.slice(0, 100), 0, "utf8");
+  header.write(octal(parseInt(mode, 8) || 420, 8), 100, "utf8");
+  header.write(octal(0, 8), 108, "utf8");
+  header.write(octal(0, 8), 116, "utf8");
+  header.write(octal(data.length, 12), 124, "utf8");
+  header.write(octal(0, 12), 136, "utf8");
+  header.write("        ", 148, "utf8");
+  header.write("0", 156, "utf8");
+  header.write("ustar\0", 257, "latin1");
+  header.write("00", 263, "utf8");
+  let sum = 0;
+  for (const b of header) sum += b;
+  header.write(sum.toString(8).padStart(6, "0") + "\0 ", 148, "latin1");
+  const body = Buffer.from(data);
+  const pad = (512 - body.length % 512) % 512;
+  return Buffer.concat([header, body, Buffer.alloc(pad), Buffer.alloc(1024)]);
+}
+function octal(n, len) {
+  return n.toString(8).padStart(len - 1, "0").slice(-(len - 1)) + "\0";
+}
+async function importDockerode() {
+  const spec = "dockerode";
+  try {
+    const mod = await import(
+      /* @vite-ignore */
+      spec
+    );
+    return mod.default ?? mod;
+  } catch (err) {
+    throw new 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 }
+    );
+  }
+}
+
+// src/target/oblien.ts
+function oblien(config = {}) {
+  return { name: "oblien", connect: (spec) => connectOblien(config, spec) };
+}
+var DEFAULT_PORT3 = 8790;
+var DEFAULT_IMAGE = "node-22";
+var DEFAULT_AGENT3 = "claude-code";
+var DEFAULT_AGENT_CWD3 = "/root";
+var SENTINEL_BASE = "http://mindwire-sandbox.local";
+var OblienHost = class {
+  constructor(rt) {
+    this.rt = rt;
+  }
+  rt;
+  async exec(argv, opts) {
+    const r = await this.rt.exec.run(argv, {
+      execMode: "direct",
+      timeoutSeconds: opts?.timeoutSeconds,
+      keepLogs: true
+    });
+    return { exitCode: r.exit_code, stdout: r.stdout, stderr: r.stderr, error: r.error };
+  }
+  async putFile(path, data, opts) {
+    const b64 = Buffer.from(data).toString("base64");
+    const b64Path = `${path}.b64`;
+    await this.rt.files.write({ fullPath: b64Path, content: b64, createDirs: true });
+    const mode = opts?.mode ?? "0644";
+    await this.rt.exec.run(
+      ["bash", "-lc", `base64 -d ${b64Path} > ${path} && chmod ${mode} ${path} && rm -f ${b64Path}`],
+      { execMode: "direct", timeoutSeconds: 30, keepLogs: true }
+    );
+  }
+};
+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(
+      "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)."
+    );
+  }
+  const mod = await importOblien();
+  const client = new mod.default({
+    clientId,
+    clientSecret,
+    ...config.baseUrl ? { baseUrl: config.baseUrl } : {}
+  });
+  return provisionOblien(client, { ...config, agent: config.agent ?? spec.agent }, spec.onLog);
+}
+async function provisionOblien(client, config = {}, onLog) {
+  const port = config.port ?? DEFAULT_PORT3;
+  const agent = config.agent ?? DEFAULT_AGENT3;
+  const agentCwd = config.agentCwd ?? DEFAULT_AGENT_CWD3;
+  const created = config.workspaceId === void 0;
+  let workspaceId = config.workspaceId;
+  if (workspaceId === void 0) {
+    const params = {
+      image: config.image ?? DEFAULT_IMAGE,
+      mode: config.mode ?? "temporary"
+    };
+    if (config.name !== void 0) params["name"] = config.name;
+    if (config.cpus !== void 0) params["cpus"] = config.cpus;
+    if (config.memoryMb !== void 0) params["memory_mb"] = config.memoryMb;
+    if (config.diskMb !== void 0) params["disk_size_mb"] = config.diskMb;
+    const ws = await client.workspaces.create(params);
+    workspaceId = ws.id;
+  }
+  const handle = client.workspace(workspaceId);
+  await handle.start().catch(() => {
+  });
+  let rt = await handle.runtime();
+  await ensureDaemon(new OblienHost(rt), {
+    port,
+    agent,
+    agentCwd,
+    daemonBin: config.daemonBin,
+    autoUpdate: config.autoUpdate,
+    target: "oblien",
+    onLog
+  });
+  const fetchImpl = async (url, init) => {
+    const { pathname, search } = new URL(url);
+    const path = pathname + search;
+    let res = await rt.proxy(port).fetch(path, init);
+    if (res.status === 401) {
+      rt = await handle.runtime({ force: true });
+      res = await rt.proxy(port).fetch(path, init);
+    }
+    return res;
+  };
+  const stop = async () => {
+    if (!config.stopOnExit) return;
+    try {
+      await (created ? handle.delete() : handle.stop());
+    } catch {
+    }
+  };
+  return { id: workspaceId, workspaceId, baseUrl: SENTINEL_BASE, fetch: fetchImpl, stop };
+}
+async function importOblien() {
+  const spec = "oblien";
+  try {
+    return await import(
+      /* @vite-ignore */
+      spec
+    );
+  } catch (err) {
+    throw new 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 }
+    );
+  }
+}
+function env2(key) {
+  const proc = globalThis.process;
+  return proc?.env?.[key];
+}
+
+// src/catalog/index.ts
+var MODELS_DEV_URL = "https://models.dev/api.json";
+var TTL_MS = 6 * 60 * 60 * 1e3;
+function toCost(c) {
+  if (!c) return void 0;
+  const cost = {};
+  if (typeof c.input === "number") cost.input = c.input;
+  if (typeof c.output === "number") cost.output = c.output;
+  if (typeof c.cache_read === "number") cost.cacheRead = c.cache_read;
+  if (typeof c.cache_write === "number") cost.cacheWrite = c.cache_write;
+  return Object.keys(cost).length ? cost : void 0;
+}
+function toModel(providerId, id, m) {
+  const info = { id: m.id ?? id, label: m.name || (m.id ?? id), provider: providerId };
+  if (m.limit?.context) info.contextWindow = m.limit.context;
+  if (m.limit?.output) info.maxOutput = m.limit.output;
+  if (m.modalities?.input?.length) info.inputModalities = m.modalities.input;
+  if (m.modalities?.output?.length) info.outputModalities = m.modalities.output;
+  if (m.reasoning) info.reasoning = true;
+  if (m.tool_call) info.toolCall = true;
+  if (m.attachment) info.attachment = true;
+  const cost = toCost(m.cost);
+  if (cost) info.cost = cost;
+  return info;
+}
+function project(feed) {
+  const providers = [];
+  for (const [pid, prov] of Object.entries(feed ?? {})) {
+    if (!prov || typeof prov !== "object") continue;
+    const id = prov.id ?? pid;
+    const models = Object.entries(prov.models ?? {}).map(([mid, m]) => toModel(id, mid, m)).sort((a, b) => a.label.localeCompare(b.label) || a.id.localeCompare(b.id));
+    providers.push({
+      id,
+      name: prov.name || id,
+      env: Array.isArray(prov.env) ? prov.env.filter((v) => typeof v === "string" && !!v) : [],
+      ...prov.npm ? { npm: prov.npm } : {},
+      ...prov.api ? { api: prov.api } : {},
+      ...prov.doc ? { doc: prov.doc } : {},
+      models
+    });
+  }
+  return providers.sort((a, b) => a.name.localeCompare(b.name));
+}
+var cache = null;
+var inflight = null;
+async function loadCatalog(opts = {}) {
+  const url = opts.url ?? MODELS_DEV_URL;
+  if (cache && cache.url === url && Date.now() - cache.at < TTL_MS) return cache.data;
+  if (inflight) return inflight;
+  const doFetch = opts.fetch ?? globalThis.fetch;
+  if (typeof doFetch !== "function") {
+    throw new Error("no fetch implementation available \u2014 pass CatalogOptions.fetch");
+  }
+  inflight = (async () => {
+    const res = await doFetch(url, { headers: { accept: "application/json" }, signal: opts.signal });
+    if (!res.ok) throw new Error(`models.dev catalog fetch failed: ${res.status} ${res.statusText}`);
+    const data = project(await res.json());
+    cache = { url, at: Date.now(), data };
+    return data;
+  })();
+  try {
+    return await inflight;
+  } finally {
+    inflight = null;
+  }
+}
+function catalogProviders(opts) {
+  return loadCatalog(opts);
+}
+async function catalogProvider(id, opts) {
+  return (await loadCatalog(opts)).find((p) => p.id === id);
+}
+async function catalogModels(provider, opts) {
+  const providers = await loadCatalog(opts);
+  if (provider) return providers.find((p) => p.id === provider)?.models ?? [];
+  return providers.flatMap((p) => p.models);
+}
+async function lookupModel(provider, id, opts) {
+  return (await catalogProvider(provider, opts))?.models.find((m) => m.id === id);
+}
+function clearCatalogCache() {
+  cache = null;
+  inflight = null;
+}
+
+exports.ApiError = ApiError;
+exports.AuthApi = AuthApi;
+exports.ContainerHost = ContainerHost;
+exports.Http = Http;
+exports.MODELS_DEV_URL = MODELS_DEV_URL;
+exports.McpApi = McpApi;
+exports.Mindwire = Mindwire;
+exports.MindwireError = MindwireError;
+exports.NotifyApi = NotifyApi;
+exports.PromptsApi = PromptsApi;
+exports.ProvidersApi = ProvidersApi;
+exports.Run = Run;
+exports.RunFailedError = RunFailedError;
+exports.SDK_VERSION = SDK_VERSION;
+exports.TimeoutError = TimeoutError;
+exports.catalogModels = catalogModels;
+exports.catalogProvider = catalogProvider;
+exports.catalogProviders = catalogProviders;
+exports.clearCatalogCache = clearCatalogCache;
+exports.docker = docker;
+exports.ensureDaemon = ensureDaemon;
+exports.ensureDaemonBinary = ensureDaemonBinary;
+exports.loadCatalog = loadCatalog;
+exports.local = local;
+exports.lookupModel = lookupModel;
+exports.oblien = oblien;
+exports.provisionContainer = provisionContainer;
+exports.provisionDocker = provisionDocker;
+exports.provisionOblien = provisionOblien;
+exports.provisionSsh = provisionSsh;
+exports.provisionSshContainer = provisionSshContainer;
+exports.remote = remote;
+exports.resolveLinuxDaemon = resolveLinuxDaemon;
+exports.ssh = ssh;
+exports.startEmbedded = startEmbedded;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map