@wirecat/zoom-cli 0.56.0 → 0.57.0

package/dist/bundle/chunk-NW3X3G5X.js

@@ -0,0 +1,264 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  wirecatDirectory
+} from "./chunk-CB5UTASG.js";
+import {
+  CliError
+} from "./chunk-AE4BOXH7.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/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.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/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-O66V2WHK.js

@@ -0,0 +1,48 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  CliError
+} from "./chunk-AE4BOXH7.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/http/public-url.js
+var EXAMPLE = "--public-url https://<name>.ts.net";
+var publicUrlOf = /* @__PURE__ */ __name((given, { missing, reaches, path = false }) => {
+  if (!given)
+    throw new CliError("configuration_error", `${missing} needs the tunnel's address: ${EXAMPLE}`);
+  let url;
+  try {
+    url = new URL(given);
+  } catch {
+    throw new CliError("validation_error", `--public-url is not an address: ${EXAMPLE}`);
+  }
+  if (url.username || url.password)
+    throw new CliError("validation_error", "--public-url must not contain login credentials");
+  const local = url.protocol === "http:" && ["localhost", "127.0.0.1"].includes(url.hostname);
+  if (url.protocol !== "https:" && !local)
+    throw new CliError("validation_error", `--public-url must be https \u2014 ${reaches} through it`);
+  if (url.search || url.hash || !path && url.pathname !== "/")
+    throw new CliError("validation_error", path ? `--public-url is the tunnel's address, or a path of it, without a query: ${EXAMPLE}/tg` : `--public-url is the tunnel's address only, without a path: ${EXAMPLE}`);
+  if (path && !/^(\/[A-Za-z0-9_-][A-Za-z0-9._-]*)*\/?$/.test(url.pathname))
+    throw new CliError("validation_error", "--public-url's path takes letters, digits, dot, dash and underscore: /tg");
+  if (path)
+    url.pathname = url.pathname.replace(/\/+$/, "") || "/";
+  return url;
+}, "publicUrlOf");
+var portOf = /* @__PURE__ */ __name((given, fallback) => {
+  if (given === void 0)
+    return fallback;
+  const port = Number(given);
+  if (!Number.isInteger(port) || port < 1 || port > 65535)
+    throw new CliError("validation_error", "--port takes 1\u201365535");
+  return port;
+}, "portOf");
+var mcpUrlOf = /* @__PURE__ */ __name((publicUrl) => new URL(`${publicUrl.pathname.replace(/\/+$/, "")}/mcp`, publicUrl.origin), "mcpUrlOf");
+
+export {
+  publicUrlOf,
+  portOf,
+  mcpUrlOf
+};

package/dist/bundle/chunk-OCGPZHXW.js

@@ -0,0 +1,25 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  CliError
+} from "./chunk-AE4BOXH7.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/node_modules/@wirecat/cli-core/dist/ports/app.js
+var envName = /* @__PURE__ */ __name((app, name) => `${app.envPrefix}_${name}`, "envName");
+var readOnlyLockOf = /* @__PURE__ */ __name((app, env) => {
+  const name = envName(app, "READ_ONLY");
+  const value = env[name];
+  return value === void 0 || value.trim() === "" || value === "0" ? void 0 : name;
+}, "readOnlyLockOf");
+var MESSENGER_CHANGE_REFUSAL = "send, react, change chats or change the account";
+var readOnlyRefusal = /* @__PURE__ */ __name((lock, what) => new CliError("permission_error", `this process is read-only (${lock}) \u2014 it cannot ${what}`), "readOnlyRefusal");
+
+export {
+  envName,
+  readOnlyLockOf,
+  MESSENGER_CHANGE_REFUSAL,
+  readOnlyRefusal
+};

package/dist/bundle/chunk-OIHDCGV4.js

@@ -0,0 +1,151 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  executableEnvironment,
+  executableOnPath,
+  require_cross_spawn
+} from "./chunk-LW2G4U6W.js";
+import {
+  loadConfigFile,
+  number,
+  object,
+  optional,
+  saveConfigFile,
+  string
+} from "./chunk-AE4BOXH7.js";
+import {
+  __name,
+  __toESM
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/update/index.js
+var import_cross_spawn = __toESM(require_cross_spawn(), 1);
+import { existsSync } from "node:fs";
+var installerOf = /* @__PURE__ */ __name((scriptPath) => {
+  const path = scriptPath.replaceAll("\\", "/");
+  if (path.includes("/_npx/"))
+    return "npx";
+  if (path.includes("/install/global/node_modules/"))
+    return "bun";
+  if (/\/\.?pnpm\//.test(path))
+    return "pnpm";
+  if (path.includes("/node_modules/"))
+    return "npm";
+  return path.includes("/dist/") ? "checkout" : "unknown";
+}, "installerOf");
+var updateCommand = /* @__PURE__ */ __name((installer, packageName) => {
+  const target = `${packageName}@latest`;
+  switch (installer) {
+    // pnpm 11 installs only versions a day old (minimumReleaseAge 1440); a fix must reach users the day it ships.
+    // Only the package's own scope is exempt — every other dependency keeps the wait.
+    case "pnpm":
+      return ["pnpm", "add", "-g", target, `--config.minimumReleaseAgeExclude=${ownScope(packageName)}`];
+    case "npm":
+      return ["npm", "install", "-g", target];
+    case "bun":
+      return ["bun", "add", "-g", target];
+    default:
+      return void 0;
+  }
+}, "updateCommand");
+var ownScope = /* @__PURE__ */ __name((packageName) => packageName.startsWith("@") ? `${packageName.split("/", 1)[0]}/*` : packageName, "ownScope");
+var isNewer = /* @__PURE__ */ __name((candidate, current) => {
+  const parse = /* @__PURE__ */ __name((version) => /^\d+\.\d+\.\d+$/.test(version) ? version.split(".").map(Number) : void 0, "parse");
+  const a = parse(candidate);
+  const b = parse(current);
+  if (!a || !b)
+    return false;
+  for (let i = 0; i < 3; i++) {
+    if (a[i] !== b[i])
+      return a[i] > b[i];
+  }
+  return false;
+}, "isNewer");
+var latestVersion = /* @__PURE__ */ __name(async (packageName, fetch, { timeoutMs = 1e3 } = {}) => {
+  try {
+    const response = await fetch(`https://registry.npmjs.org/${packageName}/latest`, {
+      signal: AbortSignal.timeout(timeoutMs),
+      headers: { accept: "application/json" }
+    });
+    if (!response.ok)
+      return void 0;
+    const { version } = await response.json();
+    return typeof version === "string" ? version : void 0;
+  } catch {
+    return void 0;
+  }
+}, "latestVersion");
+var CHECK_EVERY_MS = 24 * 60 * 60 * 1e3;
+var mayNotify = /* @__PURE__ */ __name(({ format, stderrIsTTY, quiet, enabled, installer, env, offVariables = [] }) => enabled && format === "pretty" && stderrIsTTY && !quiet && updateCommand(installer, "any") !== void 0 && !env.CI && !env.NO_UPDATE_NOTIFIER && offVariables.every((name) => !env[name]), "mayNotify");
+var updateState = object({
+  checkedAt: number(),
+  latest: optional(string()),
+  /** When the skill hint (`cli-base/skill`) was last shown — the other daily notice kept in this file. */
+  skillHintAt: optional(number())
+});
+var readNoticeState = /* @__PURE__ */ __name((path) => {
+  try {
+    return loadConfigFile(path, updateState, () => ({ checkedAt: 0 }));
+  } catch {
+    return { checkedAt: 0 };
+  }
+}, "readNoticeState");
+var readUpdateState = /* @__PURE__ */ __name((path) => {
+  const state = readNoticeState(path);
+  return state.checkedAt > 0 ? state : void 0;
+}, "readUpdateState");
+var writeUpdateState = /* @__PURE__ */ __name((path, state) => {
+  try {
+    saveConfigFile(path, { ...readNoticeState(path), ...state });
+  } catch {
+  }
+}, "writeUpdateState");
+var checkIsDue = /* @__PURE__ */ __name((state, now) => state === void 0 || now - state.checkedAt >= CHECK_EVERY_MS, "checkIsDue");
+var spawnPlan = /* @__PURE__ */ __name(([command, ...args], platform = process.platform, env = process.env, exists = existsSync) => ({ file: executableOnPath(command, env, platform, exists), args, shell: false }), "spawnPlan");
+var runUpdate = /* @__PURE__ */ __name((argv) => {
+  const { file, args, shell } = spawnPlan(argv);
+  const { status, error } = import_cross_spawn.default.sync(file, args, {
+    stdio: ["inherit", 2, 2],
+    shell,
+    env: executableEnvironment(process.env)
+  });
+  if (error)
+    throw new Error(`could not start ${argv[0]}: ${error.message}`);
+  return status ?? 1;
+}, "runUpdate");
+var updateNotice = /* @__PURE__ */ __name(async ({ argv, packageName, command, upgradeCommand = "upgrade", version, statePath, fetch, now = Date.now, ...context }) => {
+  try {
+    const path = commandWords(argv).slice(0, 2);
+    if (path.includes("complete") || path.includes(upgradeCommand))
+      return void 0;
+    if (!mayNotify(context))
+      return void 0;
+    const at = now();
+    let state = readUpdateState(statePath);
+    if (checkIsDue(state, at)) {
+      const found = await latestVersion(packageName, fetch, { timeoutMs: 1e3 });
+      const seen = found ?? state?.latest;
+      state = seen ? { checkedAt: at, latest: seen } : { checkedAt: at };
+      writeUpdateState(statePath, state);
+    }
+    return state?.latest && isNewer(state.latest, version) ? `${command} ${state.latest} is out \u2014 you have ${version}. \`${command} ${upgradeCommand}\` installs it.` : void 0;
+  } catch {
+    return void 0;
+  }
+}, "updateNotice");
+var commandWords = /* @__PURE__ */ __name((argv) => {
+  const end = argv.indexOf("--");
+  return argv.slice(0, end < 0 ? void 0 : end).filter((word) => !word.startsWith("-"));
+}, "commandWords");
+
+export {
+  installerOf,
+  updateCommand,
+  isNewer,
+  latestVersion,
+  CHECK_EVERY_MS,
+  readNoticeState,
+  writeUpdateState,
+  runUpdate,
+  updateNotice
+};