mindwire 0.1.46 → 0.1.48

package/dist/index.d.ts

@@ -8,13 +8,14 @@
 export { Mindwire, AuthApi, PromptsApi, McpApi, ProvidersApi, NotifyApi } from "./client.js";
 export type { MindwireOptions, AgentScoped } from "./client.js";
 export { Run } from "./run.js";
+export { VoiceApi, VoiceSession } from "./voice.js";
 export type { StreamOptions, WaitResult } from "./run.js";
 export { Http } from "./http.js";
 export type { HttpOptions, FetchLike, RequestInitLike, BaseResolver, TokenGetter } from "./http.js";
 export { startEmbedded } from "./embedded.js";
-export type { EmbeddedOptions, EmbeddedDaemon } from "./embedded.js";
+export type { EmbeddedOptions, EmbeddedDaemon, NativeAuthSource } from "./embedded.js";
 export { local, remote } from "./target/index.js";
-export type { Target, TargetHandle, ConnectSpec, RemoteOptions } from "./target/index.js";
+export type { Target, LocalTarget, TargetHandle, ConnectSpec, RemoteOptions } from "./target/index.js";
 export { ssh, provisionSsh, provisionSshContainer } from "./target/ssh.js";
 export type { SshOptions, SshProvisionConfig, SshContainerProvisionConfig } from "./target/ssh.js";
 export { docker, provisionDocker } from "./target/docker.js";

package/dist/index.js

@@ -1117,8 +1117,115 @@ function computerPairingURI(invitation) {
   return `mindwire://${action}?v=1#${encoded}`;
 }
 
+// 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/version.ts
-var SDK_VERSION = "0.1.46" ;
+var SDK_VERSION = "0.1.48" ;
 function versionAtLeast(actual, desired) {
   if (actual === desired) return true;
   if (!actual || !/^\d+\.\d+\.\d+$/.test(actual) || !/^\d+\.\d+\.\d+$/.test(desired)) return false;
@@ -1190,14 +1297,25 @@ async function ensureDaemonBinary(opts = {}) {
 // src/embedded.ts
 var shared = /* @__PURE__ */ new Map();
 function configKey(opts) {
-  return JSON.stringify([opts.cwd ?? "", opts.statePath ?? "", opts.bin ?? ""]);
+  const entries = (env3) => env3 && Object.entries(env3).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);
@@ -1211,7 +1329,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."
@@ -1221,40 +1340,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 = spawn(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((resolve) => {
+      if (exited) {
+        resolve();
+        return;
+      }
+      const timer = setTimeout(() => {
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+      }, 2e3);
+      child.once("exit", () => {
+        clearTimeout(timer);
+        resolve();
+      });
+      child.once("error", () => {
+        clearTimeout(timer);
+        resolve();
+      });
+      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 fs = await import('fs');
   const path = await import('path');
   const proc = serverRuntime().process;
@@ -1275,7 +1432,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) {
@@ -1304,7 +1461,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();
@@ -1312,9 +1469,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));
   }
@@ -1330,17 +1492,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 () => {
         }
       };
     }
@@ -1373,6 +1545,7 @@ var Mindwire = class _Mindwire {
   service;
   execution;
   computer;
+  voice;
   http;
   /** The default agent type applied to agent-scoped calls, if set. */
   defaultAgent;
@@ -1411,6 +1584,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);
@@ -1436,6 +1610,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);
@@ -1452,8 +1627,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);
@@ -1498,6 +1673,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) });
@@ -1635,7 +1816,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
         }
       }
     );
@@ -1714,7 +1896,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);
@@ -3157,6 +3339,6 @@ function clearCatalogCache() {
   inflight = null;
 }
 
-export { AuthApi, ComputerApi, ContainerHost, ConversationsApi, ExecutionApi, GitAccessApi, Http, MODELS_DEV_URL, McpApi, Mindwire, NotifyApi, ProjectOperationsApi, ProjectSyncApi, ProjectSyncError, PromptsApi, ProvidersApi, Run, SDK_VERSION, ServiceApi, SurfacesApi, TerminalsApi, WorkspaceApi, WorkspaceCollection, catalogModels, catalogProvider, catalogProviders, clearCatalogCache, computerPairingQRData, computerPairingURI, docker, ensureDaemon, ensureDaemonBinary, loadCatalog, local, lookupModel, oblien, provisionContainer, provisionDocker, provisionOblien, provisionSsh, provisionSshContainer, remote, resolveLinuxDaemon, ssh, startEmbedded };
+export { AuthApi, ComputerApi, ContainerHost, ConversationsApi, ExecutionApi, GitAccessApi, Http, MODELS_DEV_URL, McpApi, Mindwire, NotifyApi, ProjectOperationsApi, ProjectSyncApi, ProjectSyncError, PromptsApi, ProvidersApi, Run, SDK_VERSION, ServiceApi, SurfacesApi, TerminalsApi, VoiceApi, VoiceSession, WorkspaceApi, WorkspaceCollection, catalogModels, catalogProvider, catalogProviders, clearCatalogCache, computerPairingQRData, computerPairingURI, docker, ensureDaemon, ensureDaemonBinary, loadCatalog, local, lookupModel, oblien, provisionContainer, provisionDocker, provisionOblien, provisionSsh, provisionSshContainer, remote, resolveLinuxDaemon, ssh, startEmbedded };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map