@wirecat/zoom-cli 0.56.0 → 0.58.0

package/dist/bundle/chunk-6CYLVFXM.js

@@ -0,0 +1,9 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+
+// dist/version.js
+var VERSION = "0.58.0";
+
+export {
+  VERSION
+};

package/dist/bundle/chunk-6FL25KC5.js

@@ -0,0 +1,264 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  wirecatDirectory
+} from "./chunk-B32SF7J3.js";
+import {
+  CliError
+} from "./chunk-YIMI6O7R.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.473.0_@wirecat+cli-base@0.65.0_commander@15.0.0_esbuild@0.28.2_type_39633e3162553a2c86dde989a9811fcb/node_modules/@wirecat/cli-core/dist/speech/models.js
+var huggingFace = /* @__PURE__ */ __name((repository, commit) => (name) => `https://huggingface.co/csukuangfj/${repository}/resolve/${commit}/${name}`, "huggingFace");
+var gigaam = huggingFace("sherpa-onnx-nemo-transducer-punct-giga-am-v3-russian-2025-12-16", "a6039be7cee829a9044a69ac0ebaf1c191217c97");
+var gigaamCtc = huggingFace("sherpa-onnx-nemo-ctc-punct-giga-am-v3-russian-2025-12-16", "4fb5407ff028a69fec516cdf4c10fac9ddea7c16");
+var parakeet = huggingFace("sherpa-onnx-nemo-parakeet-tdt-0.6b-v3-int8", "2bda32ec70b097a55adaa07d9a7173915b43cc78");
+var MODELS = [
+  {
+    id: "gigaam-v3",
+    title: "GigaAM v3, with punctuation",
+    languages: "Russian \u2014 the best of the three for Russian",
+    featureDim: 64,
+    files: [
+      {
+        name: "encoder.int8.onnx",
+        url: gigaam("encoder.int8.onnx"),
+        sha256: "369f35a71bf288d3b8e0391fabd8dba5f2314088d440bca474056b7b4b6e66bf",
+        bytes: 224570820
+      },
+      {
+        name: "decoder.onnx",
+        url: gigaam("decoder.onnx"),
+        sha256: "38fc7475443ea2a26f63211ca350f73ac50fff824ab7a3876ee2bd610c53bbc4",
+        bytes: 4600132
+      },
+      {
+        name: "joiner.onnx",
+        url: gigaam("joiner.onnx"),
+        sha256: "602ff7017a93311aad34df1437c8d7f49911353c13d6eae7a6ee7b041339465c",
+        bytes: 2712896
+      },
+      {
+        name: "tokens.txt",
+        url: gigaam("tokens.txt"),
+        sha256: "39abae20e692998290c574e606f11a9edef2902a1995463fcff63d1490cf22b7",
+        bytes: 13354
+      }
+    ],
+    config: /* @__PURE__ */ __name((path) => ({
+      transducer: { encoder: path("encoder.int8.onnx"), decoder: path("decoder.onnx"), joiner: path("joiner.onnx") },
+      tokens: path("tokens.txt"),
+      modelType: "nemo_transducer"
+    }), "config")
+  },
+  {
+    id: "gigaam-v3-ctc",
+    title: "GigaAM v3 CTC, with punctuation \u2014 a little faster",
+    languages: "Russian \u2014 a little faster, rougher with capital letters",
+    featureDim: 64,
+    files: [
+      {
+        name: "model.int8.onnx",
+        url: gigaamCtc("model.int8.onnx"),
+        sha256: "d5fea8df94263c285e54b21e5774b707c707192d3bdbeffd7b1eb07fb6743b35",
+        bytes: 224893661
+      },
+      {
+        name: "tokens.txt",
+        url: gigaamCtc("tokens.txt"),
+        sha256: "142de7570b3de5b3035ce111a89c228e80e6085273731d944093ddf24fa539cd",
+        bytes: 2007
+      }
+    ],
+    config: /* @__PURE__ */ __name((path) => ({ nemoCtc: { model: path("model.int8.onnx") }, tokens: path("tokens.txt") }), "config")
+  },
+  {
+    id: "parakeet-v3",
+    title: "NVIDIA Parakeet TDT 0.6B v3",
+    /** The model card's list: huggingface.co/nvidia/parakeet-tdt-0.6b-v3, read 2026-09-24. */
+    languages: "25: bg cs da de el en es et fi fr hr hu it lt lv mt nl pl pt ro ru sk sl sv uk",
+    featureDim: 80,
+    files: [
+      {
+        name: "encoder.int8.onnx",
+        url: parakeet("encoder.int8.onnx"),
+        sha256: "acfc2b4456377e15d04f0243af540b7fe7c992f8d898d751cf134c3a55fd2247",
+        bytes: 652184281
+      },
+      {
+        name: "decoder.int8.onnx",
+        url: parakeet("decoder.int8.onnx"),
+        sha256: "179e50c43d1a9de79c8a24149a2f9bac6eb5981823f2a2ed88d655b24248db4e",
+        bytes: 11845275
+      },
+      {
+        name: "joiner.int8.onnx",
+        url: parakeet("joiner.int8.onnx"),
+        sha256: "3164c13fc2821009440d20fcb5fdc78bff28b4db2f8d0f0b329101719c0948b3",
+        bytes: 6355277
+      },
+      {
+        name: "tokens.txt",
+        url: parakeet("tokens.txt"),
+        sha256: "d58544679ea4bc6ac563d1f545eb7d474bd6cfa467f0a6e2c1dc1c7d37e3c35d",
+        bytes: 93939
+      }
+    ],
+    config: /* @__PURE__ */ __name((path) => ({
+      transducer: {
+        encoder: path("encoder.int8.onnx"),
+        decoder: path("decoder.int8.onnx"),
+        joiner: path("joiner.int8.onnx")
+      },
+      tokens: path("tokens.txt"),
+      modelType: "nemo_transducer"
+    }), "config")
+  }
+];
+var VAD = {
+  name: "silero_vad.onnx",
+  url: "https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/silero_vad.onnx",
+  sha256: "9e2449e1087496d8d4caba907f23e0bd3f78d91fa552479bb9c23ac09cbb1fd6",
+  bytes: 643854
+};
+var DEFAULT_ORDER = ["parakeet-v3", "gigaam-v3", "gigaam-v3-ctc"];
+var orderedModels = /* @__PURE__ */ __name((order = DEFAULT_ORDER) => [.../* @__PURE__ */ new Set([...order, ...DEFAULT_ORDER])].map(speechModel), "orderedModels");
+var findModel = /* @__PURE__ */ __name((id) => MODELS.find((model) => model.id === id), "findModel");
+var speechModel = /* @__PURE__ */ __name((id) => {
+  const model = findModel(id);
+  if (!model) {
+    throw new CliError("validation_error", `no speech model "${id}" \u2014 one of ${MODELS.map((known) => known.id).join(", ")}`);
+  }
+  return model;
+}, "speechModel");
+
+// node_modules/.pnpm/@wirecat+cli-core@0.473.0_@wirecat+cli-base@0.65.0_commander@15.0.0_esbuild@0.28.2_type_39633e3162553a2c86dde989a9811fcb/node_modules/@wirecat/cli-core/dist/speech/install.js
+import { createHash, randomUUID } from "node:crypto";
+import { createReadStream, createWriteStream, mkdirSync, statSync } from "node:fs";
+import { rename, rm } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { Readable, Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
+var sharedModelsDirectory = /* @__PURE__ */ __name((kind, env = process.env) => join(wirecatDirectory(env), "models", kind), "sharedModelsDirectory");
+var modelsDirectory = /* @__PURE__ */ __name((env = process.env) => sharedModelsDirectory("audio", env), "modelsDirectory");
+var STALL_MS = 6e4;
+var watchdog = /* @__PURE__ */ __name((ms) => {
+  const controller = new AbortController();
+  let timer = setTimeout(() => controller.abort(), ms);
+  return {
+    signal: controller.signal,
+    poke: /* @__PURE__ */ __name(() => {
+      clearTimeout(timer);
+      timer = setTimeout(() => controller.abort(), ms);
+    }, "poke"),
+    stop: /* @__PURE__ */ __name(() => clearTimeout(timer), "stop")
+  };
+}, "watchdog");
+var modelPath = /* @__PURE__ */ __name((directory, model) => (name) => join(directory, model.id, name), "modelPath");
+var vadPath = /* @__PURE__ */ __name((directory) => join(directory, VAD.name), "vadPath");
+var placed = /* @__PURE__ */ __name((model, directory) => [
+  ...model.files.map((file) => [file, modelPath(directory, model)(file.name)]),
+  [VAD, vadPath(directory)]
+], "placed");
+var isInstalled = /* @__PURE__ */ __name((model, directory) => filesPresent(placed(model, directory)), "isInstalled");
+var filesPresent = /* @__PURE__ */ __name((files) => files.every(([file, path]) => sizeOf(path) === file.bytes), "filesPresent");
+var sizeOf = /* @__PURE__ */ __name((path) => {
+  try {
+    return statSync(path).size;
+  } catch {
+    return void 0;
+  }
+}, "sizeOf");
+var installedBytes = /* @__PURE__ */ __name((model) => model.files.reduce((sum, file) => sum + file.bytes, 0), "installedBytes");
+var install = /* @__PURE__ */ __name(async (model, directory, { fetch: get = fetch, progress, verifyExisting } = {}) => {
+  mkdirSync(join(directory, model.id), { recursive: true, mode: 448 });
+  await installFiles(placed(model, directory), { fetch: get, progress, verifyExisting });
+}, "install");
+var installFiles = /* @__PURE__ */ __name(async (files, { fetch: get = fetch, progress, verifyExisting } = {}) => {
+  if (verifyExisting)
+    for (const [file, path] of files) {
+      if (sizeOf(path) !== void 0) {
+        const hash = createHash("sha256");
+        for await (const chunk of createReadStream(path))
+          hash.update(chunk);
+        if (hash.digest("hex") !== file.sha256) {
+          progress?.(`${path}: not the file this version expects, downloading it again`);
+          await rm(path, { force: true });
+        }
+      }
+    }
+  for (const [file, path] of files) {
+    if (sizeOf(path) === file.bytes)
+      continue;
+    mkdirSync(dirname(path), { recursive: true, mode: 448 });
+    progress?.(`downloading ${file.name} (${megabytes(file.bytes)})`);
+    await fetchVerified(file, path, get);
+  }
+}, "installFiles");
+var fetchVerified = /* @__PURE__ */ __name(async (file, path, get) => {
+  const stalled = watchdog(STALL_MS);
+  try {
+    await fetchInto(file, path, get, stalled);
+  } catch (error) {
+    if (stalled.signal.aborted) {
+      throw new CliError("timeout", `${file.name} stopped downloading for ${STALL_MS / 1e3} s \u2014 nothing was installed`);
+    }
+    throw error;
+  } finally {
+    stalled.stop();
+  }
+}, "fetchVerified");
+var fetchInto = /* @__PURE__ */ __name(async (file, path, get, stalled) => {
+  const response = await get(file.url, { signal: stalled.signal });
+  if (!response.ok || !response.body) {
+    await response.body?.cancel();
+    throw new CliError("network_error", `${file.name} could not be downloaded: HTTP ${response.status}`);
+  }
+  const partial = `${path}.${randomUUID()}.part`;
+  const hash = createHash("sha256");
+  let bytes = 0;
+  const hashing = new Transform({
+    transform(chunk, _encoding, done) {
+      stalled.poke();
+      bytes += chunk.length;
+      if (bytes > file.bytes) {
+        done(new CliError("invalid_response", `${file.name} is larger than this version expects \u2014 nothing was installed`));
+        return;
+      }
+      hash.update(chunk);
+      done(null, chunk);
+    }
+  });
+  try {
+    await pipeline(Readable.fromWeb(response.body), hashing, createWriteStream(partial, { flags: "wx", mode: 384 }));
+    const actual = hash.digest("hex");
+    if (actual !== file.sha256) {
+      throw new CliError("invalid_response", `${file.name} is not the file this version expects (sha256 ${actual}) \u2014 nothing was installed`);
+    }
+    await rename(partial, path);
+  } finally {
+    await rm(partial, { force: true });
+  }
+}, "fetchInto");
+var megabytes = /* @__PURE__ */ __name((bytes) => bytes < 1e6 ? "under 1 MB" : `${Math.round(bytes / 1e6)} MB`, "megabytes");
+
+export {
+  MODELS,
+  VAD,
+  DEFAULT_ORDER,
+  orderedModels,
+  findModel,
+  speechModel,
+  sharedModelsDirectory,
+  modelsDirectory,
+  modelPath,
+  vadPath,
+  isInstalled,
+  filesPresent,
+  installedBytes,
+  install,
+  installFiles,
+  megabytes
+};

package/dist/bundle/chunk-7D2CD3E3.js

@@ -0,0 +1,193 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  listen
+} from "./chunk-DDYR6DYL.js";
+import {
+  ownerLogin
+} from "./chunk-UKR7KH3H.js";
+import {
+  activityRecorder,
+  calledTools,
+  httpActivityFile,
+  httpLock
+} from "./chunk-ZHXIXDH5.js";
+import {
+  WebStandardStreamableHTTPServerTransport,
+  createMcpHandler,
+  getOAuthProtectedResourceMetadataUrl,
+  hostHeaderValidationResponse,
+  isLegacyRequest,
+  oauthMetadataResponse,
+  requireBearerAuth
+} from "./chunk-5D4AEUVA.js";
+import {
+  CliError
+} from "./chunk-YIMI6O7R.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.473.0_@wirecat+cli-base@0.65.0_commander@15.0.0_esbuild@0.28.2_type_39633e3162553a2c86dde989a9811fcb/node_modules/@wirecat/cli-core/dist/mcp/http/serve.js
+import { randomUUID } from "node:crypto";
+var MCP_PATH = "/mcp";
+var AS_METADATA = "/.well-known/oauth-authorization-server";
+var LOCAL = ["localhost", "127.0.0.1"];
+var MAX_SESSIONS = 20;
+var MAX_LOGIN_BODY = 64 * 1024;
+var SESSION_IDLE_MS = 60 * 60 * 1e3;
+var sessionMissing = /* @__PURE__ */ __name(() => new Response(JSON.stringify({ jsonrpc: "2.0", error: { code: -32001, message: "Session not found" }, id: null }), {
+  status: 404,
+  headers: { "content-type": "application/json" }
+}), "sessionMissing");
+var legacySessions = /* @__PURE__ */ __name((build, now) => {
+  const sessions = /* @__PURE__ */ new Map();
+  const drop = /* @__PURE__ */ __name(async (id) => {
+    const one = sessions.get(id);
+    sessions.delete(id);
+    await one?.close();
+  }, "drop");
+  const handle = /* @__PURE__ */ __name(async (request, auth) => {
+    for (const [id2, one] of sessions)
+      if (now() - one.seen > SESSION_IDLE_MS)
+        await drop(id2);
+    const id = request.headers.get("mcp-session-id");
+    if (id) {
+      const known = sessions.get(id);
+      if (!known || known.clientId !== auth.clientId)
+        return sessionMissing();
+      known.seen = now();
+      return known.transport.handleRequest(request, { authInfo: auth });
+    }
+    const server = build();
+    const transport = new WebStandardStreamableHTTPServerTransport({
+      sessionIdGenerator: /* @__PURE__ */ __name(() => randomUUID(), "sessionIdGenerator"),
+      onsessionclosed: /* @__PURE__ */ __name((closed) => void sessions.delete(closed), "onsessionclosed")
+    });
+    await server.connect(transport);
+    const response = await transport.handleRequest(request, { authInfo: auth });
+    if (!transport.sessionId) {
+      await server.close();
+      return response;
+    }
+    sessions.set(transport.sessionId, { transport, close: /* @__PURE__ */ __name(() => server.close(), "close"), clientId: auth.clientId, seen: now() });
+    while (sessions.size > MAX_SESSIONS)
+      await drop(sessions.keys().next().value);
+    return response;
+  }, "handle");
+  return {
+    handle,
+    close: /* @__PURE__ */ __name(async () => {
+      for (const id of [...sessions.keys()])
+        await drop(id);
+    }, "close")
+  };
+}, "legacySessions");
+var metadataRequest = /* @__PURE__ */ __name((request, path, base) => {
+  const url = new URL(request.url);
+  const inserted = base && path === `${AS_METADATA}${base}`;
+  if (!inserted && url.pathname === path)
+    return request;
+  url.pathname = inserted ? AS_METADATA : path;
+  return new Request(url, { method: request.method, headers: request.headers });
+}, "metadataRequest");
+var toolsIn = /* @__PURE__ */ __name(async (request) => {
+  if (request.method !== "POST")
+    return [];
+  try {
+    return calledTools(await request.clone().json());
+  } catch {
+    return [];
+  }
+}, "toolsIn");
+var serveOverHttp = /* @__PURE__ */ __name(async (build, options) => {
+  const { publicUrl, port, tokenFile, appName, onCode, onError, now, lockFile, version } = options;
+  const lock = lockFile ? httpLock(lockFile, {
+    pid: process.pid,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    port,
+    publicUrl: publicUrl.href,
+    ...version ? { version } : {}
+  }) : void 0;
+  if (lock?.held)
+    throw new CliError("validation_error", `${appName} already serves MCP over HTTP for this profile on port ${lock.held.port} (PID ${lock.held.pid}, since ${lock.held.startedAt})`);
+  const base = publicUrl.pathname === "/" ? "" : publicUrl.pathname.replace(/\/+$/, "");
+  const issuer = new URL(`${publicUrl.origin}${base}`);
+  const resource = new URL(`${base}${MCP_PATH}`, publicUrl.origin);
+  const mcpPath = resource.pathname;
+  const publicPath = /* @__PURE__ */ __name((path) => base && path !== base && !path.startsWith(`${base}/`) && !path.startsWith("/.well-known/") ? `${base}${path}` : path, "publicPath");
+  const login = ownerLogin({
+    issuer,
+    resource,
+    file: tokenFile,
+    appName,
+    onCode: /* @__PURE__ */ __name((code, expires) => {
+      lock?.update({ loginCode: code, loginCodeExpiresAt: expires.toISOString() });
+      onCode(code, expires);
+    }, "onCode"),
+    ...now ? { now } : {}
+  });
+  const insecure = issuer.protocol === "http:" && LOCAL.includes(issuer.hostname);
+  const mcp = createMcpHandler(build, { legacy: "reject", ...onError ? { onerror: onError } : {} });
+  const legacy = legacySessions(build, now ?? Date.now);
+  const bearer = requireBearerAuth({
+    verifier: login.verifier,
+    resourceMetadataUrl: getOAuthProtectedResourceMetadataUrl(resource)
+  });
+  const activity = activityRecorder(httpActivityFile(tokenFile), now);
+  const allowedHosts = [.../* @__PURE__ */ new Set([publicUrl.hostname, ...LOCAL])];
+  const allowedOrigins = [publicUrl.origin];
+  const listening = await listen(async (request) => {
+    const refused = hostHeaderValidationResponse(request, allowedHosts);
+    if (refused)
+      return refused;
+    const path = publicPath(new URL(request.url).pathname);
+    const discovery = oauthMetadataResponse(metadataRequest(request, path, base), {
+      oauthMetadata: login.metadata,
+      resourceServerUrl: resource,
+      resourceName: appName,
+      ...insecure ? { dangerouslyAllowInsecureIssuerUrl: true } : {}
+    });
+    if (discovery)
+      return discovery;
+    if (Number(request.headers.get("content-length") ?? 0) > MAX_LOGIN_BODY && path !== mcpPath)
+      return new Response("Request too large", { status: 413 });
+    const origin = request.headers.get("origin");
+    if (origin && !allowedOrigins.includes(origin))
+      return new Response("Origin not allowed", { status: 403 });
+    const answered = await login.handle(request, path);
+    if (answered)
+      return answered;
+    if (path !== mcpPath)
+      return new Response("Not found", { status: 404 });
+    const auth = await bearer(request);
+    if (auth instanceof Response)
+      return auth;
+    activity.record(auth.clientId, await toolsIn(request));
+    return await isLegacyRequest(request) ? legacy.handle(request, auth) : mcp.fetch(request, { authInfo: auth });
+  }, { host: "127.0.0.1", port }).catch((error) => {
+    login.close();
+    lock?.release();
+    throw error;
+  });
+  lock?.update({ listeningAt: (/* @__PURE__ */ new Date()).toISOString() });
+  return {
+    url: listening.url,
+    close: /* @__PURE__ */ __name(async () => {
+      login.close();
+      activity.flush();
+      try {
+        await listening.close();
+        await legacy.close();
+        await mcp.close();
+      } finally {
+        lock?.release();
+      }
+    }, "close")
+  };
+}, "serveOverHttp");
+
+export {
+  MCP_PATH,
+  serveOverHttp
+};

package/dist/bundle/chunk-7GVNQOV6.js

@@ -0,0 +1,17 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  resolvePaths
+} from "./chunk-YIMI6O7R.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// dist/folders.js
+var loginService = /* @__PURE__ */ __name((configDir) => `zoom-cli:${configDir}`, "loginService");
+var zmPaths = /* @__PURE__ */ __name((options = {}) => resolvePaths({ appName: "zm", ...options }), "zmPaths");
+
+export {
+  loginService,
+  zmPaths
+};