mindwire 0.1.47 → 0.1.50

package/README.md

@@ -185,6 +185,22 @@ new Mindwire({ target: oblien({ clientId: process.env.OBLIEN_CLIENT_ID, clientSe
 
 Any object implementing `Target` can also be passed as `target` (bring-your-own).
 
+For an application-owned local profile, use `local({ cwd, statePath, environment,
+authSource: "host", shared: false })`. `environment` replaces the inherited process
+environment; the optional `authSource` lets the native adapters automatically reuse
+the host's saved connection on the first agent/status read or turn. Existing account
+choices and explicit sign-out are preserved. No client-side `auth.begin()` is needed
+for first setup. Use `authSource: { home, environment, reuse: "manual" }` if a host
+requires explicit selection instead. Methods with `existing` metadata display the
+discovered account/provider and model without exposing credentials;
+`auth.begin(method.id)` remains available to reconnect after sign-out or retry a
+failed import. Native tools, hooks and unrelated host configuration are not imported.
+`await mw.close()` stops the owned daemon. Shared local targets remain alive until
+the host exits or their embedded handle is explicitly stopped.
+`local().profileVersion` advertises this SDK contract before a process starts;
+applications requiring private profiles should reject targets without it. The
+daemon separately reports `health.nativeAuthSource`, which the SDK checks at startup.
+
 ### Provisioning logs & `ensure()`
 
 `ssh` / `docker` / `oblien` prep the box on connect — upload the daemon binary, launch it, health-poll

package/dist/{chunk-7QLYFISG.js → chunk-3LN2KXJK.js}

@@ -88,7 +88,7 @@ function computerPairingURI(invitation) {
 }
 
 // src/version.ts
-var SDK_VERSION = "0.1.47" ;
+var SDK_VERSION = "0.1.50" ;
 function versionAtLeast(actual, desired) {
   if (actual === desired) return true;
   if (!actual || !/^\d+\.\d+\.\d+$/.test(actual) || !/^\d+\.\d+\.\d+$/.test(desired)) return false;
@@ -1694,17 +1694,135 @@ var TerminalsApi = class {
   }
 };
 
+// src/voice.ts
+var VoiceApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  status(scoped) {
+    return this.client.http.request("GET", "/voice", {
+      query: { agent: scoped?.agent ?? this.client.defaultAgent }
+    });
+  }
+  /** Start in an idle chat. Keep requestId/clientId when retrying a lost receipt. */
+  async start(input) {
+    const clientId = input.clientId ?? crypto.randomUUID();
+    const data = await this.client.http.request("POST", "/turns", {
+      query: { agent: input.agent ?? this.client.defaultAgent },
+      body: {
+        chatId: input.chatId,
+        message: "",
+        cwd: input.cwd,
+        gitAuth: input.gitAuth,
+        requestId: input.requestId ?? crypto.randomUUID(),
+        options: { voice: { clientId, voice: input.voice } }
+      }
+    });
+    return new VoiceSession(this.client.http, new Run(this.client.http, data), clientId);
+  }
+};
+var VoiceSession = class {
+  constructor(http, run, clientId) {
+    this.http = http;
+    this.run = run;
+    this.clientId = clientId;
+  }
+  http;
+  run;
+  clientId;
+  sequence = 0;
+  sending = false;
+  ended = false;
+  streaming = false;
+  get path() {
+    return `/runs/${encodeURIComponent(this.run.id)}/voice`;
+  }
+  /** Await each ordered batch. No automatic audio replay after a network failure. */
+  async appendAudio(audio, signal) {
+    if (this.ended || this.sending) throw new Error("Voice ended or the previous audio batch is still being delivered.");
+    this.sending = true;
+    try {
+      await this.http.request("POST", this.path, { signal, body: {
+        clientId: this.clientId,
+        action: "audio",
+        sequence: ++this.sequence,
+        audio
+      } });
+    } catch (error) {
+      await this.stop().catch(() => {
+      });
+      throw error;
+    } finally {
+      this.sending = false;
+    }
+  }
+  /** Subscribe before sending audio; wait for ready. Breaking the loop ends voice. */
+  async *stream(signal) {
+    if (this.streaming || this.ended) throw new Error("This voice stream is already open or ended.");
+    this.streaming = true;
+    const controller = new AbortController();
+    const abort = () => controller.abort(signal?.reason);
+    signal?.addEventListener("abort", abort, { once: true });
+    if (signal?.aborted) abort();
+    let heartbeatPending = false;
+    const heartbeat = setInterval(() => {
+      if (heartbeatPending || controller.signal.aborted) return;
+      heartbeatPending = true;
+      void this.http.request("POST", this.path, {
+        signal: controller.signal,
+        body: { clientId: this.clientId, action: "heartbeat" }
+      }).catch((error) => controller.abort(error)).finally(() => {
+        heartbeatPending = false;
+      });
+    }, 5e3);
+    try {
+      const response = await this.http.open("GET", `${this.path}/stream`, {
+        query: { clientId: this.clientId },
+        signal: controller.signal
+      });
+      for await (const event of readSSE(response.body, controller.signal)) {
+        if (event.type !== "heartbeat") yield event;
+        if (event.type === "closed" || event.type === "error") break;
+      }
+    } finally {
+      clearInterval(heartbeat);
+      signal?.removeEventListener("abort", abort);
+      controller.abort();
+      this.streaming = false;
+      await this.stop().catch(() => {
+      });
+    }
+  }
+  async stop() {
+    if (this.ended) return;
+    this.ended = true;
+    await this.http.request("POST", this.path, { body: { clientId: this.clientId, action: "stop" } });
+  }
+};
+
 // src/embedded.ts
 var shared = /* @__PURE__ */ new Map();
 function configKey(opts) {
-  return JSON.stringify([opts.cwd ?? "", opts.statePath ?? "", opts.bin ?? ""]);
+  const entries = (env) => env && Object.entries(env).sort(([a], [b]) => a.localeCompare(b));
+  return JSON.stringify([
+    opts.cwd ?? "",
+    opts.statePath ?? "",
+    opts.bin ?? "",
+    opts.exactVersion,
+    entries(opts.environment),
+    opts.authSource === "host" ? ["host", entries(serverRuntime().process?.env)] : opts.authSource && [opts.authSource.home, opts.authSource.reuse ?? "automatic", entries(opts.authSource.environment)]
+  ]);
 }
 function startEmbedded(opts = {}) {
+  if (opts.shared === false) return spawnDaemon(opts);
   const key = configKey(opts);
   let daemon = shared.get(key);
   if (!daemon) {
-    daemon = spawnDaemon(opts).catch((err) => {
-      shared.delete(key);
+    daemon = spawnDaemon(opts, () => {
+      if (shared.get(key) === daemon) shared.delete(key);
+    }).catch((err) => {
+      if (shared.get(key) === daemon) shared.delete(key);
       throw err;
     });
     shared.set(key, daemon);
@@ -1718,7 +1836,8 @@ 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) {
+async function spawnDaemon(opts, onStop = () => {
+}) {
   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."
@@ -1728,40 +1847,78 @@ async function spawnDaemon(opts) {
   const net = await import('net');
   const proc = serverRuntime().process;
   const { randomBytes } = await import('crypto');
-  const resolved = await resolveBinary(opts.bin);
+  const resolved = await resolveBinary(opts.bin, opts.exactVersion);
   const bin = resolved.bin;
   const port = await freePort(net);
   const baseUrl = `http://127.0.0.1:${port}`;
   const token = randomBytes(32).toString("hex");
+  const authSource = opts.authSource === "host" ? { home: (await import('os')).homedir(), environment: proc.env } : opts.authSource;
   const child = spawn3(bin, [], {
     env: {
-      ...proc.env,
+      ...opts.environment ?? proc.env,
       ADDR: `127.0.0.1:${port}`,
       AGENT_CWD: opts.cwd ?? proc.cwd(),
       STATE_PATH: opts.statePath ?? ".mindwire-state.json",
-      DAEMON_TOKEN: token
+      DAEMON_TOKEN: token,
+      // The daemon consumes and unsets this before starting any native process.
+      ...authSource ? { MINDWIRE_AUTH_SOURCE: JSON.stringify(authSource) } : {}
     },
+    cwd: opts.cwd ?? proc.cwd(),
     stdio: "ignore"
   });
   let spawnError = null;
-  child.on("error", (e) => {
-    spawnError = e;
-  });
-  const stop = () => {
+  let exited = false;
+  let stopping;
+  const isAlive = () => !exited && !stopping && !spawnError;
+  const killOnExit = () => {
     try {
       child.kill();
     } catch {
     }
   };
-  proc.once?.("exit", stop);
-  proc.once?.("SIGINT", () => {
-    stop();
-    proc.exit?.(130);
+  const cleanup = () => {
+    exited = true;
+    proc.off?.("exit", killOnExit);
+    onStop();
+  };
+  child.once("exit", cleanup);
+  child.on("error", (e) => {
+    spawnError = e;
+    cleanup();
   });
-  await waitHealthy(baseUrl, token, () => spawnError, resolved);
-  return { baseUrl, token, stop };
+  const stop = () => {
+    return stopping ??= new Promise((resolve3) => {
+      if (exited) {
+        resolve3();
+        return;
+      }
+      const timer = setTimeout(() => {
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+      }, 2e3);
+      child.once("exit", () => {
+        clearTimeout(timer);
+        resolve3();
+      });
+      child.once("error", () => {
+        clearTimeout(timer);
+        resolve3();
+      });
+      killOnExit();
+    });
+  };
+  proc.once?.("exit", killOnExit);
+  try {
+    await waitHealthy(baseUrl, token, () => spawnError ?? (exited ? new Error("daemon exited during startup") : null), resolved, 15e3, !!authSource);
+    return { baseUrl, token, isAlive, stop };
+  } catch (error) {
+    await stop();
+    throw error;
+  }
 }
-async function resolveBinary(explicit) {
+async function resolveBinary(explicit, exactVersion) {
   const fs4 = await import('fs');
   const path5 = await import('path');
   const proc = serverRuntime().process;
@@ -1782,7 +1939,7 @@ async function resolveBinary(explicit) {
     } catch {
     }
   }
-  const downloaded = await ensureDaemonBinary({ platform: proc.platform, arch: proc.arch });
+  const downloaded = await ensureDaemonBinary({ platform: proc.platform, arch: proc.arch, exactVersion });
   return { bin: downloaded, found: true, checked: [...candidates, downloaded] };
 }
 function daemonStartError(resolved, cause) {
@@ -1811,7 +1968,7 @@ function freePort(net) {
     });
   });
 }
-async function waitHealthy(baseUrl, token, getError, resolved, timeoutMs = 15e3) {
+async function waitHealthy(baseUrl, token, getError, resolved, timeoutMs = 15e3, authSource = false) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     const err = getError();
@@ -1819,9 +1976,14 @@ async function waitHealthy(baseUrl, token, getError, resolved, timeoutMs = 15e3)
       throw new MindwireError(daemonStartError(resolved, err), { cause: err });
     }
     try {
-      const res = await fetch(`${baseUrl}/healthz`, { headers: { Authorization: `Bearer ${token}` } });
-      if (res.ok) return;
-    } catch {
+      const res = await fetch(`${baseUrl}/healthz`, { headers: { Authorization: `Bearer ${token}` }, signal: AbortSignal.timeout(1e3) });
+      if (res.ok) {
+        if (authSource && (await res.json()).nativeAuthSource !== true)
+          throw new MindwireError("This daemon does not support native auth sources. Update Mindwire or build the matching daemon before using authSource.");
+        return;
+      }
+    } catch (error) {
+      if (error instanceof MindwireError) throw error;
     }
     await new Promise((r) => setTimeout(r, 150));
   }
@@ -1837,17 +1999,27 @@ function emit(spec, e) {
   }
 }
 function local(opts = {}) {
+  let daemon;
+  let pending;
   return {
     name: "local",
+    profileVersion: 1,
     async connect(spec) {
-      const d = await startEmbedded(opts);
+      if (daemon && !daemon.isAlive()) {
+        daemon = void 0;
+        pending = void 0;
+      }
+      const d = await (pending ??= startEmbedded(opts).then((value) => daemon = value).catch((error) => {
+        pending = void 0;
+        throw error;
+      }));
       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 () => {
+        isAlive: d.isAlive,
+        stop: opts.shared === false ? d.stop : async () => {
         }
       };
     }
@@ -1880,6 +2052,7 @@ var Mindwire = class _Mindwire {
   service;
   execution;
   computer;
+  voice;
   http;
   /** The default agent type applied to agent-scoped calls, if set. */
   defaultAgent;
@@ -1918,6 +2091,7 @@ var Mindwire = class _Mindwire {
     this.service = new ServiceApi(this);
     this.execution = new ExecutionApi(this);
     this.computer = new ComputerApi(this);
+    this.voice = new VoiceApi(this);
     this.auth = new AuthApi(this);
     this.prompts = new PromptsApi(this);
     this.mcp = new McpApi(this);
@@ -1943,6 +2117,7 @@ var Mindwire = class _Mindwire {
     clone.service = new ServiceApi(clone);
     clone.execution = new ExecutionApi(clone);
     clone.computer = new ComputerApi(clone);
+    clone.voice = new VoiceApi(clone);
     clone.auth = new AuthApi(clone);
     clone.prompts = new PromptsApi(clone);
     clone.mcp = new McpApi(clone);
@@ -1959,8 +2134,8 @@ var Mindwire = class _Mindwire {
    * 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).
+   * for shared local and remote targets. With `local({ shared: false })`, closes the owned daemon.
+   * Safe to call before the target has connected (nothing to reap yet).
    */
   async close() {
     const handle = handleByTransport.get(this.http);
@@ -2005,6 +2180,12 @@ var Mindwire = class _Mindwire {
   models(scoped) {
     return this.http.request("GET", "/models", { query: this.agentParam(scoped) });
   }
+  /** Discover native commands for a project without starting a model turn. */
+  commands(opts = {}) {
+    return this.http.request("GET", "/commands", {
+      query: { ...this.agentParam(opts), dir: opts.directory, refresh: opts.refresh }
+    });
+  }
   /** `GET /doctor` — daemon-level health plus the selected agent's own checks. */
   doctor(scoped) {
     return this.http.request("GET", "/doctor", { query: this.agentParam(scoped) });
@@ -2142,7 +2323,8 @@ var Mindwire = class _Mindwire {
           limit,
           before: opts.before,
           paged: "true",
-          maxBytes: opts.maxBytes ?? 1048576
+          maxBytes: opts.maxBytes ?? 1048576,
+          ifRevision: opts.before ? void 0 : opts.ifRevision
         }
       }
     );
@@ -2221,7 +2403,7 @@ var Mindwire = class _Mindwire {
       `/chats/${encodeURIComponent(chatId)}/compact`,
       {
         query: this.agentParam(opts),
-        body: opts.instructions ? { instructions: opts.instructions } : {}
+        body: { instructions: opts.instructions, requestId: opts.requestId }
       }
     );
     return new Run(this.http, data);
@@ -2647,7 +2829,7 @@ async function ensureComputer(directory, cliPath, patch = {}, onProgress, option
       if (!compatible(controller2) || !await processStateAlive(controller2)) {
         await ensureComputer(directory, cliPath, {}, onProgress, { ...options, waitForRoutes: false });
       }
-      const { changeComputerConnection } = await import('./connection-change-LCT3UM7M.js');
+      const { changeComputerConnection } = await import('./connection-change-ZYFBOPEE.js');
       await changeComputerConnection(directory, Object.fromEntries(changed.map((key) => [key, patch[key]])), { signal: options.signal, onProgress });
       return computerClient(directory);
     }
@@ -2688,7 +2870,7 @@ async function ensureComputer(directory, cliPath, patch = {}, onProgress, option
     let controller = await readJSON(path4.join(directory, "computer-controller.json"));
     if (existing && controller && !compatible(controller) && await processStateAlive(controller)) {
       onProgress?.("Refreshing the background connection service\u2026");
-      const { handoffController } = await import('./controller-handoff-RPZJDZJR.js');
+      const { handoffController } = await import('./controller-handoff-YB6DMOUW.js');
       await handoffController(directory, controller, config, await existing.computer.info());
       controller = void 0;
     }
@@ -2722,7 +2904,7 @@ async function ensureComputer(directory, cliPath, patch = {}, onProgress, option
   }
 }
 async function superviseComputer(directory) {
-  const controller = await import('./controller-I7A3APTF.js');
+  const controller = await import('./controller-63NGJNKK.js');
   await controller.superviseComputer(directory);
 }
 async function stopComputer(directory, force = false) {
@@ -2747,5 +2929,5 @@ async function stopComputer(directory, force = false) {
 }
 
 export { CONTROLLER_PROTOCOL, ProviderConnectionError, RelayOutput, SDK_VERSION, acquireProcessLock, adoptProcess, adoptRelay, cloudflareCommand, computerClient, computerPairingQRData, computerPairingURI, currentProcessIdentity, defaultComputerConfig, defaultStateDirectory, directRoutes, ensureComputer, ensureDaemonBinary, hasCertificateError, ownChild, processIdentity, processStateAlive, providerFailure, providerNeedsAction, readJSON, startRelay, stopComputer, superviseComputer, versionAtLeast, websocketURL, writeJSON };
-//# sourceMappingURL=chunk-7QLYFISG.js.map
-//# sourceMappingURL=chunk-7QLYFISG.js.map
+//# sourceMappingURL=chunk-3LN2KXJK.js.map
+//# sourceMappingURL=chunk-3LN2KXJK.js.map