@wirecat/zoom-cli 0.56.0 → 0.57.0

package/dist/bundle/embed-7QYA2ZZE.js

@@ -0,0 +1,35 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  WARM_IDLE_MS,
+  defaultThreads,
+  isTextModelInstalled,
+  loadModel,
+  meanOf,
+  openEmbedder,
+  placedText,
+  runEmbedders,
+  textModelsDirectory,
+  truncated,
+  unit,
+  warmEmbedders
+} from "./chunk-CLMXBW53.js";
+import "./chunk-NW3X3G5X.js";
+import "./chunk-CB5UTASG.js";
+import "./chunk-AE4BOXH7.js";
+import "./chunk-Y5E2WNWB.js";
+import "./chunk-ZVVMGPBJ.js";
+export {
+  WARM_IDLE_MS,
+  defaultThreads,
+  isTextModelInstalled,
+  loadModel,
+  meanOf,
+  openEmbedder,
+  placedText,
+  runEmbedders,
+  textModelsDirectory,
+  truncated,
+  unit,
+  warmEmbedders
+};

package/dist/bundle/embedder-YNN6PCHG.js

@@ -0,0 +1,108 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  openSession,
+  truncated,
+  unit
+} from "./chunk-CLMXBW53.js";
+import "./chunk-NW3X3G5X.js";
+import "./chunk-CB5UTASG.js";
+import {
+  CliError
+} from "./chunk-AE4BOXH7.js";
+import {
+  importFrom
+} from "./chunk-Y5E2WNWB.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/images/picture/embedder.js
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+// 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/images/picture/preprocess.js
+var SIZE = 224;
+var MEAN = [0.48145466, 0.4578275, 0.40821073];
+var STD = [0.26862954, 0.26130258, 0.27577711];
+var importCanvas = /* @__PURE__ */ __name(async () => {
+  try {
+    return await importFrom(new URL("images/picture/preprocess.js", import.meta.resolve("@wirecat/cli-core")).href, "@napi-rs/canvas");
+  } catch {
+    throw new CliError("validation_error", "searching pictures needs the optional package @napi-rs/canvas to read an image \u2014 install it next to this tool");
+  }
+}, "importCanvas");
+var preprocess = /* @__PURE__ */ __name(async (bytes, load = importCanvas) => {
+  const { createCanvas, loadImage } = await load();
+  let image;
+  try {
+    image = await loadImage(bytes);
+  } catch {
+    throw new CliError("invalid_response", "the file is not an image this tool can read");
+  }
+  const scale = SIZE / Math.min(image.width, image.height);
+  const width = Math.max(SIZE, Math.round(image.width * scale));
+  const height = Math.max(SIZE, Math.round(image.height * scale));
+  const surface = createCanvas(SIZE, SIZE);
+  const context = surface.getContext("2d");
+  context.fillStyle = "#ffffff";
+  context.fillRect(0, 0, SIZE, SIZE);
+  context.imageSmoothingQuality = "high";
+  context.drawImage(image, 0, 0, image.width, image.height, Math.round((SIZE - width) / 2), Math.round((SIZE - height) / 2), width, height);
+  const { data } = context.getImageData(0, 0, SIZE, SIZE);
+  const plane = SIZE * SIZE;
+  const pixels = new Float32Array(3 * plane);
+  for (let at = 0; at < plane; at++) {
+    for (let channel = 0; channel < 3; channel++) {
+      pixels[channel * plane + at] = (data[at * 4 + channel] / 255 - MEAN[channel]) / STD[channel];
+    }
+  }
+  return pixels;
+}, "preprocess");
+
+// 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/images/picture/embedder.js
+var openPictureEmbedder = /* @__PURE__ */ __name(async (model, directory, { threads = 4, canvas } = {}) => {
+  const { Tokenizer } = await importFrom(new URL("images/picture/embedder.js", import.meta.resolve("@wirecat/cli-core")).href, "@huggingface/tokenizers");
+  const path = /* @__PURE__ */ __name((name) => join(directory, model.id, name), "path");
+  const tokenizer = new Tokenizer(JSON.parse(readFileSync(path("tokenizer.json"), "utf8")), JSON.parse(readFileSync(path("tokenizer_config.json"), "utf8")));
+  const sessions = [];
+  const lazy = /* @__PURE__ */ __name((name) => {
+    let opened;
+    return () => {
+      opened ??= openSession(readFileSync(path(name)), threads).then((created) => {
+        sessions.push(created.session);
+        return created;
+      });
+      return opened;
+    };
+  }, "lazy");
+  const vision = lazy(model.vision);
+  const text = lazy(model.text);
+  return {
+    model,
+    embedImage: /* @__PURE__ */ __name(async (bytes) => {
+      const pixels = await preprocess(bytes, canvas);
+      const { ort, session } = await vision();
+      const output = await session.run({ pixel_values: new ort.Tensor("float32", pixels, [1, 3, SIZE, SIZE]) });
+      return unit(Float32Array.from(output.image_embeds?.data));
+    }, "embedImage"),
+    embedQuery: /* @__PURE__ */ __name(async (query) => {
+      const ids = truncated(tokenizer.encode(query.toLowerCase()).ids, model.maxTokens);
+      const shape = [1, ids.length];
+      const { ort, session } = await text();
+      const feeds = {
+        input_ids: new ort.Tensor("int64", BigInt64Array.from(ids, BigInt), shape)
+      };
+      if (session.inputNames.includes("attention_mask"))
+        feeds.attention_mask = new ort.Tensor("int64", new BigInt64Array(ids.length).fill(1n), shape);
+      const output = await session.run(feeds);
+      return unit(Float32Array.from(output.text_embeds?.data));
+    }, "embedQuery"),
+    close: /* @__PURE__ */ __name(async () => {
+      await Promise.all(sessions.map((session) => session.release()));
+    }, "close")
+  };
+}, "openPictureEmbedder");
+export {
+  openPictureEmbedder
+};

package/dist/bundle/first-run-EVSRQKZJ.js

@@ -0,0 +1,23 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  askSetupQuestions,
+  asksAtStart,
+  setupAtStart,
+  systemLanguage
+} from "./chunk-BAYNCCNM.js";
+import "./chunk-OIHDCGV4.js";
+import "./chunk-LW2G4U6W.js";
+import "./chunk-S4S7E54J.js";
+import "./chunk-QUJPQMHJ.js";
+import "./chunk-7GUG6UZS.js";
+import "./chunk-CB5UTASG.js";
+import "./chunk-AE4BOXH7.js";
+import "./chunk-Y5E2WNWB.js";
+import "./chunk-ZVVMGPBJ.js";
+export {
+  askSetupQuestions,
+  asksAtStart,
+  setupAtStart,
+  systemLanguage
+};

package/dist/bundle/first-screen-RG4GUKW7.js

@@ -0,0 +1,36 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  WIRECAT_TOOLS,
+  firstScreen,
+  installHelp
+} from "./chunk-7JZJMHQY.js";
+import "./chunk-BW2WPOXP.js";
+import "./chunk-G4R4ZIGD.js";
+import "./chunk-MAEFLDHG.js";
+import "./chunk-OCGPZHXW.js";
+import "./chunk-PIN5RZ3D.js";
+import "./chunk-2WOGZDZG.js";
+import "./chunk-EOQFWJJD.js";
+import "./chunk-NO7CJEYV.js";
+import "./chunk-YB4DMKYX.js";
+import "./chunk-S4S7E54J.js";
+import "./chunk-HTQTIKWP.js";
+import "./chunk-LQ3T2ZIX.js";
+import "./chunk-TKCHUT2H.js";
+import "./chunk-NW3X3G5X.js";
+import "./chunk-6M6FJV5D.js";
+import "./chunk-7GUG6UZS.js";
+import "./chunk-4YLS4YLS.js";
+import "./chunk-CB5UTASG.js";
+import "./chunk-LXB6ONWC.js";
+import "./chunk-LSVI3A5X.js";
+import "./chunk-IVQ6342B.js";
+import "./chunk-AE4BOXH7.js";
+import "./chunk-Y5E2WNWB.js";
+import "./chunk-ZVVMGPBJ.js";
+export {
+  WIRECAT_TOOLS,
+  firstScreen,
+  installHelp
+};

package/dist/bundle/folders-JEPOMYM4.js

@@ -0,0 +1,13 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  loginService,
+  zmPaths
+} from "./chunk-6MX5T6AQ.js";
+import "./chunk-AE4BOXH7.js";
+import "./chunk-Y5E2WNWB.js";
+import "./chunk-ZVVMGPBJ.js";
+export {
+  loginService,
+  zmPaths
+};

package/dist/bundle/instructions-FHNL7CMW.js

@@ -0,0 +1,9 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  instructions
+} from "./chunk-DCTXOMOR.js";
+import "./chunk-ZVVMGPBJ.js";
+export {
+  instructions
+};

package/dist/bundle/main-NYGJXPH7.js

@@ -0,0 +1,130 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  ZM
+} from "./chunk-LHRCJYFC.js";
+import {
+  VERSION
+} from "./chunk-2IKY7VBH.js";
+import {
+  startCli
+} from "./chunk-UI5UTMSZ.js";
+import "./chunk-OCGPZHXW.js";
+import "./chunk-TZ2MKETI.js";
+import {
+  CliError,
+  errorObjectOf,
+  exitCodeOfError,
+  isCliError,
+  readBatchInput,
+  renderError,
+  systemKeyring
+} from "./chunk-AE4BOXH7.js";
+import "./chunk-Y5E2WNWB.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// dist/bin/main.js
+import { createReadStream } from "node:fs";
+import { join } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { addAbortSignal } from "node:stream";
+import { fileURLToPath } from "node:url";
+var answerPolicy;
+await startCli({
+  app: ZM,
+  run: /* @__PURE__ */ __name(async (entry) => {
+    answerPolicy = await import("./answer-policy-KH2IFXPN.js");
+    const [{ runsDirFor }, { readConfig }, { loginService, zmPaths }, { writeExportFile }, { run }, { lazyRunLog }, { createStoreConnector }, { writeStream }, { TOKEN_LOG_ALLOW, TokenManager }] = await Promise.all([
+      import("./cli-72EQATJF.js"),
+      import("./config-GFIJK6G2.js"),
+      import("./folders-JEPOMYM4.js"),
+      import("./output-file-RYQZ3RTE.js"),
+      import("./program-IBRQBQ6W.js"),
+      import("./run-log-RE2EI3UU.js"),
+      import("./store-connection-EG6Z5ITP.js"),
+      import("./streaming-UGFFNOXL.js"),
+      import("./tokens-AF5CPY2F.js")
+    ]);
+    const paths = zmPaths();
+    const configPath = join(paths.config, "config.json");
+    const tokenRun = lazyRunLog({
+      runsDir: runsDirFor(ZM, entry.env),
+      command: "oauth token",
+      version: VERSION,
+      allow: TOKEN_LOG_ALLOW
+    });
+    let failed = true;
+    try {
+      const tokens = new TokenManager({
+        get clientId() {
+          return readConfig(configPath).clientId ?? "";
+        },
+        keyring: systemKeyring,
+        service: loginService(paths.config),
+        fetch,
+        log: tokenRun.log
+      });
+      const code = await run(entry.args, {
+        configPath,
+        recordingScheduleTarget: { runtime: process.execPath, cliPath: fileURLToPath(new URL("../bin/main.js", import.meta.url).href) },
+        tokens,
+        connectStore: createStoreConnector({ env: entry.env }),
+        fetch,
+        outputIsTTY: entry.tty,
+        env: entry.env,
+        signal: entry.signal,
+        writeFile: writeExportFile,
+        readBatchInput: /* @__PURE__ */ __name(async (path, signal) => {
+          signal?.throwIfAborted();
+          const input = path === "-" ? process.stdin : createReadStream(path, { signal });
+          if (signal && path === "-")
+            addAbortSignal(signal, input);
+          try {
+            return await readBatchInput(input, { signal });
+          } catch (error) {
+            signal?.throwIfAborted();
+            if (isCliError(error))
+              throw error;
+            throw new CliError("configuration_error", "could not read the batch input file or stdin");
+          }
+        }, "readBatchInput"),
+        streamData: /* @__PURE__ */ __name((text, signal) => writeStream(process.stdout, text, signal), "streamData"),
+        data: /* @__PURE__ */ __name((text) => process.stdout.write(text), "data"),
+        diagnostic: /* @__PURE__ */ __name((text) => {
+          if (!entry.outputClosed())
+            process.stderr.write(text);
+        }, "diagnostic"),
+        openBrowser: entry.openBrowser,
+        // entry.ask answers no without asking when stdout is not a terminal; leaving confirm out then says to add --yes.
+        confirm: entry.tty && process.stdin.isTTY && process.stderr.isTTY ? (question) => entry.ask(question) : void 0,
+        atStart: entry.atStart,
+        readPaste: process.stdin.isTTY ? async (signal) => {
+          const input = createInterface({ input: process.stdin, output: process.stderr });
+          try {
+            return await input.question("If the callback does not complete, paste code=\u2026&state=\u2026 here: ", {
+              signal
+            });
+          } finally {
+            input.close();
+          }
+        } : void 0
+      });
+      failed = code !== 0;
+      return code;
+    } finally {
+      await tokenRun.finish(failed ? "failed" : "success").catch(() => {
+      });
+    }
+  }, "run"),
+  fail: /* @__PURE__ */ __name((error, entry) => {
+    const diagnostic = /* @__PURE__ */ __name((text) => process.stderr.write(text), "diagnostic");
+    if (answerPolicy)
+      return answerPolicy.reportFailure(error, entry.args, { diagnostic, outputIsTTY: entry.tty });
+    const object = errorObjectOf(error);
+    diagnostic(`${renderError(object, { cli: ZM.command, interactive: entry.tty })}
+`);
+    return exitCodeOfError(object);
+  }, "fail")
+});

package/dist/bundle/mcp-IXFC2VVR.js

@@ -0,0 +1,165 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  executableEnvironment,
+  executableOnPath,
+  require_cross_spawn
+} from "./chunk-LW2G4U6W.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/mcp/index.js
+var import_cross_spawn = __toESM(require_cross_spawn(), 1);
+var realRun = /* @__PURE__ */ __name((file, args) => {
+  const result = import_cross_spawn.default.sync(executableOnPath(file, process.env), args, {
+    encoding: "utf8",
+    timeout: 1e4,
+    maxBuffer: 256e3,
+    env: executableEnvironment(process.env)
+  });
+  return { status: result.status, error: result.error, stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
+}, "realRun");
+var executable = /* @__PURE__ */ __name((client) => client === "codex" ? "codex" : "claude", "executable");
+var presentIn = /* @__PURE__ */ __name((client, name, run) => {
+  const state = lookUp(client, name, run);
+  if (state === "unavailable")
+    throw new Error(`${executable(client)} is not installed or could not be started`);
+  return state === "registered";
+}, "presentIn");
+var setupArguments = /* @__PURE__ */ __name((client, name, entry) => {
+  const variables = Object.entries(entry.env ?? {}).flatMap(([key, value]) => ["--env", `${key}=${value}`]);
+  if (client === "codex")
+    return ["mcp", "add", name, ...variables, "--", entry.command, ...entry.args];
+  return ["mcp", "add", "--scope", "user", name, ...variables, "--", entry.command, ...entry.args];
+}, "setupArguments");
+var checkName = /* @__PURE__ */ __name((name) => {
+  if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(name))
+    throw new Error("the MCP name must be letters, digits, _ or -");
+}, "checkName");
+var lookUp = /* @__PURE__ */ __name((client, name, run) => {
+  const file = executable(client);
+  const existing = run(file, ["mcp", "get", name, ...client === "codex" ? ["--json"] : []]);
+  if (existing.error)
+    return "unavailable";
+  if (existing.status === 0)
+    return "registered";
+  if (!/No MCP server named/i.test(existing.stdout + existing.stderr)) {
+    throw new Error(`${file} could not check its MCP configuration`);
+  }
+  return "missing";
+}, "lookUp");
+var stdioEntryStatus = /* @__PURE__ */ __name((client, name, { run = realRun } = {}) => {
+  checkName(name);
+  return { client, name, state: lookUp(client, name, run) };
+}, "stdioEntryStatus");
+var removeArguments = /* @__PURE__ */ __name((client, name) => (
+  // Claude Code without a scope removes from whichever scope holds the name, which may be a project's own entry.
+  client === "codex" ? ["mcp", "remove", name] : ["mcp", "remove", "--scope", "user", name]
+), "removeArguments");
+var removeStdioEntry = /* @__PURE__ */ __name((client, name, { run = realRun } = {}) => {
+  checkName(name);
+  if (!presentIn(client, name, run))
+    return { client, name, removed: false };
+  const file = executable(client);
+  const removed = run(file, removeArguments(client, name));
+  if (removed.status !== 0 || removed.error)
+    throw new Error(`${file} could not remove ${name}`);
+  return { client, name, removed: true };
+}, "removeStdioEntry");
+var installStdioEntry = /* @__PURE__ */ __name((client, name, entry, { run = realRun } = {}) => {
+  checkName(name);
+  if (!entry.command || entry.args.some((arg) => arg.includes("\0")))
+    throw new Error("invalid MCP command");
+  const file = executable(client);
+  if (presentIn(client, name, run))
+    throw new Error(`${name} is already configured in ${file}; remove it there first`);
+  const args = setupArguments(client, name, entry);
+  const added = run(file, args);
+  if (added.status !== 0 || added.error)
+    throw new Error(`${file} could not add ${name}`);
+  return { client, name, command: [entry.command, ...entry.args] };
+}, "installStdioEntry");
+var probeStdio = /* @__PURE__ */ __name(async (entry, { timeoutMs = 1e4, start = /* @__PURE__ */ __name((file, args, env) => (0, import_cross_spawn.default)(executableOnPath(file, env), args, {
+  env: executableEnvironment(env),
+  stdio: "pipe"
+}), "start") } = {}) => {
+  const child = start(entry.command, entry.args, { ...process.env, ...entry.env });
+  let buffer = "";
+  let timer;
+  const pending = /* @__PURE__ */ new Map();
+  const request = /* @__PURE__ */ __name((id, method, params) => new Promise((resolve, reject) => {
+    pending.set(id, { resolve, reject });
+    child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}
+`);
+  }), "request");
+  const fail = /* @__PURE__ */ __name((error) => {
+    for (const waiter of pending.values())
+      waiter.reject(error);
+    pending.clear();
+  }, "fail");
+  child.on("error", () => fail(new Error("the MCP server could not be started")));
+  child.on("exit", () => fail(new Error("the MCP server exited before answering")));
+  child.stdin.on("error", () => fail(new Error("the MCP server closed its input")));
+  child.stdout.setEncoding("utf8");
+  child.stdout.on("data", (chunk) => {
+    buffer += chunk;
+    if (buffer.length > 1e6)
+      return fail(new Error("the MCP server sent too much output"));
+    for (let newline = buffer.indexOf("\n"); newline !== -1; newline = buffer.indexOf("\n")) {
+      const line = buffer.slice(0, newline);
+      buffer = buffer.slice(newline + 1);
+      try {
+        const value = JSON.parse(line);
+        if (typeof value.id !== "number")
+          continue;
+        const waiter = pending.get(value.id);
+        if (!waiter)
+          continue;
+        pending.delete(value.id);
+        if (value.error)
+          waiter.reject(new Error("the MCP server rejected the handshake"));
+        else
+          waiter.resolve(value.result ?? {});
+      } catch {
+        fail(new Error("the MCP server sent invalid JSON"));
+      }
+    }
+  });
+  try {
+    timer = setTimeout(() => fail(new Error("the MCP server did not answer in time")), timeoutMs);
+    await request(1, "initialize", {
+      protocolVersion: "2025-11-25",
+      capabilities: {},
+      clientInfo: { name: "cli-base-mcp-doctor", version: "1" }
+    });
+    child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" })}
+`);
+    const result = await request(2, "tools/list", {});
+    const tools = result.tools;
+    if (!Array.isArray(tools))
+      throw new Error("the MCP server returned no tool list");
+    const named = tools.filter((item) => item !== null && typeof item === "object" && "name" in item && typeof item.name === "string");
+    if (named.length !== tools.length)
+      throw new Error("the MCP server returned an invalid tool list");
+    return {
+      tools: named.map((item) => item.name),
+      potentialWrites: named.filter((item) => item.annotations?.readOnlyHint !== true).map((item) => item.name)
+    };
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+    pending.clear();
+    child.stdin.end();
+    child.kill();
+  }
+}, "probeStdio");
+export {
+  installStdioEntry,
+  probeStdio,
+  removeArguments,
+  removeStdioEntry,
+  setupArguments,
+  stdioEntryStatus
+};