@wirecat/zoom-cli 0.56.0 → 0.58.0

package/dist/bundle/chunk-ZC5UXEIH.js

@@ -0,0 +1,215 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  installerOf,
+  updateCommand
+} from "./chunk-DP5DX45H.js";
+import {
+  QUESTIONS,
+  readSetupAnswers,
+  unanswered,
+  writeSetupAnswers
+} from "./chunk-4AURKUDZ.js";
+import {
+  DEFAULT_STEMMERS,
+  LANGUAGES
+} from "./chunk-YSHSCBPM.js";
+import {
+  sharedConfigPath
+} from "./chunk-KVHRHBLY.js";
+import {
+  storePath
+} from "./chunk-B32SF7J3.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/cli/first-run.js
+import { spawnSync } from "node:child_process";
+import { accessSync, constants, realpathSync } from "node:fs";
+import { delimiter, join } from "node:path";
+var SKIPPED = /* @__PURE__ */ new Set(["help", "guide", "completion", "mcp", "serve", "server", "update", "store"]);
+var asksAtStart = /* @__PURE__ */ __name((start) => !start.headless && start.terminal && !start.env.AI_AGENT && !start.env.CLAUDECODE && start.readOnlyLock === void 0 && !SKIPPED.has(start.path[0] ?? ""), "asksAtStart");
+var systemLanguage = /* @__PURE__ */ __name((env) => {
+  const named = [env.LC_ALL, env.LC_MESSAGES, env.LANG, ...(env.LANGUAGE ?? "").split(":")].map((value) => value?.trim()).find((value) => value && value !== "C" && value !== "POSIX" && !value.startsWith("C."));
+  return (named ?? Intl.DateTimeFormat().resolvedOptions().locale).slice(0, 2).toLowerCase();
+}, "systemLanguage");
+var stemmersOf = /* @__PURE__ */ __name((languages) => {
+  const latin = LANGUAGES.filter(({ name, script }) => script === "latin" && languages.includes(name));
+  return {
+    cyrillic: languages.includes("russian") ? "russian" : "none",
+    latin: latin.length ? latin.map(({ name }) => name).join(",") : "none"
+  };
+}, "stemmersOf");
+var languagesOf = /* @__PURE__ */ __name((stemmers) => LANGUAGES.filter(({ name }) => stemmers.cyrillic === name || stemmers.latin.split(",").includes(name)).map(({ name }) => name), "languagesOf");
+var choose = /* @__PURE__ */ __name(async (io, prompt, count, chosen) => {
+  for (let attempt = 0; attempt < 3; attempt++) {
+    const answer = (await io.ask(prompt)).trim();
+    if (!answer)
+      return chosen;
+    if (/^(none|-)$/i.test(answer))
+      return [];
+    const numbers = answer.split(/[\s,]+/).filter(Boolean).map(Number);
+    if (numbers.every((number) => Number.isInteger(number) && number >= 1 && number <= count))
+      return [...new Set(numbers)].sort((a, b) => a - b);
+    io.say(`Choose numbers from 1 to ${count}, separated by commas.`);
+  }
+  return chosen;
+}, "choose");
+var yes = /* @__PURE__ */ __name(async (io, prompt) => /^y(es)?$/i.test((await io.ask(prompt)).trim()), "yes");
+var onPath = /* @__PURE__ */ __name((command, env) => {
+  const names = process.platform === "win32" ? [".cmd", ".exe", ""].map((ending) => command + ending) : [command];
+  return (env.PATH ?? env.Path ?? "").split(delimiter).some((folder) => names.some((name) => {
+    try {
+      accessSync(join(folder, name), process.platform === "win32" ? constants.F_OK : constants.X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }));
+}, "onPath");
+var installWith = /* @__PURE__ */ __name((argv) => spawnSync(argv[0], argv.slice(1), { stdio: ["inherit", 2, 2] }).status === 0, "installWith");
+var installerHere = /* @__PURE__ */ __name(() => {
+  try {
+    return installerOf(realpathSync(process.argv[1] ?? ""));
+  } catch {
+    return "unknown";
+  }
+}, "installerHere");
+var suggested = /* @__PURE__ */ __name((env, contentLanguages) => {
+  const own = LANGUAGES.filter(({ code }) => contentLanguages?.includes(code));
+  const system = systemLanguage(env);
+  return (own.length ? own : LANGUAGES.filter(({ code }) => code === "en" || code === system)).map(({ name }) => name);
+}, "suggested");
+var askLanguages = /* @__PURE__ */ __name(async ({ command, env, io, contentLanguages }) => {
+  const { openStore } = await import("./store-LEU3M6IN.js");
+  const store = await openStore({ env });
+  let rebuild = false;
+  try {
+    const saved = await store.searchIndex.stemmers() ?? void 0;
+    const inUse = saved !== void 0 || (await store.accounts.accounts()).length > 0;
+    const ticked = inUse ? languagesOf(saved ?? DEFAULT_STEMMERS) : suggested(env, contentLanguages);
+    const numbers = ticked.map((name) => LANGUAGES.findIndex((one) => one.name === name) + 1);
+    io.say("Languages you write and speak \u2014 search finds every form of their words, and spellings speech mangles:");
+    LANGUAGES.forEach(({ name, label }, at) => {
+      io.say(`  ${at + 1}. ${label}${ticked.includes(name) ? " \u2713" : ""}`);
+    });
+    const chosen = await choose(io, `Numbers (${numbers.join(",")}): `, LANGUAGES.length, numbers);
+    const next = stemmersOf(chosen.map((number) => LANGUAGES[number - 1].name));
+    const before = saved ?? DEFAULT_STEMMERS;
+    if (inUse && before.cyrillic === next.cyrillic && before.latin === next.latin)
+      return;
+    if (inUse && !await yes(io, "Rebuild the word forms of every stored message now? Word search waits for it; a large store takes minutes. [y/N] ")) {
+      io.say(`Languages kept as they were; \`${command} setup\` asks again.`);
+      return;
+    }
+    await store.searchIndex.saveStemmers(next);
+    rebuild = inUse;
+  } finally {
+    await store.close();
+  }
+  if (!rebuild)
+    return;
+  const [{ openCache }, { buildStems }] = await Promise.all([
+    import("./open-J4FCAUAJ.js"),
+    import("./store-maintenance-command-PSCHEHHY.js")
+  ]);
+  const database = await openCache(storePath(env));
+  try {
+    buildStems(database, (note) => io.say(`  ${note}`), { force: true });
+  } finally {
+    database.close();
+  }
+}, "askLanguages");
+var askTools = /* @__PURE__ */ __name(async (run) => {
+  const { command, env, io } = run;
+  const installed = run.installed ?? ((name) => onPath(name, env));
+  const { WIRECAT_TOOLS } = await import("./first-screen-LYQKPNF4.js");
+  const others = WIRECAT_TOOLS.filter((tool) => tool.command !== command);
+  const missing = others.filter((tool) => !installed(tool.command));
+  io.say("Other WireCat tools \u2014 they share this store, so one search finds everything:");
+  for (const tool of others) {
+    const at = missing.indexOf(tool);
+    io.say(`  ${at < 0 ? "\u2713 " : `${at + 1}.`} ${tool.command} \u2014 ${tool.does}`);
+  }
+  if (!missing.length)
+    return;
+  const chosen = await choose(io, "Numbers to install (none): ", missing.length, []);
+  const installer = run.installer ?? installerHere();
+  for (const number of chosen) {
+    const tool = missing[number - 1];
+    const argv = updateCommand(installer, tool.package);
+    if (!argv) {
+      io.say(`Install ${tool.command} with \`npm install -g ${tool.package}\`.`);
+      continue;
+    }
+    io.say(`Installing ${tool.command}: ${argv.join(" ")}`);
+    if (!(run.install ?? installWith)(argv))
+      io.say(`${tool.command} was not installed; run \`${argv.join(" ")}\`.`);
+  }
+}, "askTools");
+var PERMISSION_CHOICES = [
+  { answer: "readonly", text: "read only \u2014 search and read; nothing sends or changes" },
+  { answer: "allow", text: "read and write \u2014 as each profile's permissions allow" }
+];
+var askPermissions = /* @__PURE__ */ __name(async ({ io }, answers) => {
+  const now = answers.permissions ?? "allow";
+  const current = Math.max(1, PERMISSION_CHOICES.findIndex(({ answer }) => answer === now) + 1);
+  io.say("Read only, or read and write? The same for you, scripts and agents over MCP, in every WireCat tool:");
+  PERMISSION_CHOICES.forEach(({ text }, at) => {
+    io.say(`  ${at + 1}. ${text}`);
+  });
+  const [chosen = current] = await choose(io, `Number (${current}): `, PERMISSION_CHOICES.length, [current]);
+  return PERMISSION_CHOICES[chosen - 1].answer;
+}, "askPermissions");
+var answersAt = /* @__PURE__ */ __name((path) => {
+  try {
+    return readSetupAnswers(path);
+  } catch {
+    return {};
+  }
+}, "answersAt");
+var askSetupQuestions = /* @__PURE__ */ __name(async (run) => {
+  const path = sharedConfigPath(storePath(run.env), run.env);
+  const answers = answersAt(path);
+  const asking = run.all ? [...QUESTIONS] : unanswered(answers);
+  for (const question of asking) {
+    run.io.say("");
+    if (question === "languages") {
+      await askLanguages(run);
+      writeSetupAnswers(path, { languages: true });
+    } else if (question === "tools") {
+      await askTools(run);
+      writeSetupAnswers(path, { tools: true });
+    } else
+      writeSetupAnswers(path, { permissions: await askPermissions(run, answers) });
+  }
+  return asking;
+}, "askSetupQuestions");
+var setupAtStart = /* @__PURE__ */ __name(async (start) => {
+  const input = start.input ?? process.stdin;
+  const terminal = start.terminal ?? (input.isTTY === true && process.stderr.isTTY === true);
+  if (!asksAtStart({ ...start, terminal, readOnlyLock: start.readOnlyLock }))
+    return;
+  await askSetupQuestions({
+    command: start.command,
+    env: start.env,
+    contentLanguages: start.contentLanguages,
+    all: start.path[0] === "setup",
+    io: {
+      ask: /* @__PURE__ */ __name(async (prompt) => (await import("./prompt-LUUMQTMY.js")).readSecret(prompt, { input, echo: true }), "ask"),
+      say: /* @__PURE__ */ __name((text) => process.stderr.write(`${text}
+`), "say")
+    }
+  }).catch((error) => {
+    process.stderr.write(`setup questions skipped: ${error instanceof Error ? error.message : String(error)} \u2014 \`${start.command} setup\` asks them again
+`);
+  });
+}, "setupAtStart");
+
+export {
+  asksAtStart,
+  systemLanguage,
+  askSetupQuestions,
+  setupAtStart
+};

package/dist/bundle/chunk-ZHXIXDH5.js

@@ -0,0 +1,161 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  holdLock,
+  readLock,
+  releaseLock,
+  takeLock
+} from "./chunk-UYJUTZTT.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/state.js
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+
+// 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/activity.js
+import { randomBytes } from "node:crypto";
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+var WRITE_EVERY_MS = 2e3;
+var TOOL_NAME = /^[A-Za-z0-9_.-]{1,64}$/;
+var httpActivityFile = /* @__PURE__ */ __name((tokenFile) => `${tokenFile.replace(/\.json$/, "")}.activity.json`, "httpActivityFile");
+var localDay = /* @__PURE__ */ __name((ms) => {
+  const d = new Date(ms);
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}, "localDay");
+var readActivity = /* @__PURE__ */ __name((path) => {
+  if (!existsSync(path))
+    return {};
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}, "readActivity");
+var calledTools = /* @__PURE__ */ __name((body) => (Array.isArray(body) ? body : [body]).flatMap((message) => {
+  if (!message || typeof message !== "object")
+    return [];
+  const { method, params } = message;
+  const name = params?.name;
+  return method === "tools/call" && typeof name === "string" && TOOL_NAME.test(name) ? [name] : [];
+}), "calledTools");
+var activityRecorder = /* @__PURE__ */ __name((path, now = Date.now) => {
+  const activity = readActivity(path);
+  let timer;
+  const write = /* @__PURE__ */ __name(() => {
+    timer = void 0;
+    try {
+      mkdirSync(dirname(path), { recursive: true, mode: 448 });
+      const temporary = `${path}.${randomBytes(8).toString("hex")}.tmp`;
+      writeFileSync(temporary, JSON.stringify(activity), { mode: 384, flag: "wx" });
+      chmodSync(temporary, 384);
+      renameSync(temporary, path);
+    } catch {
+    }
+  }, "write");
+  return {
+    record: /* @__PURE__ */ __name((clientId, tools) => {
+      const at = now();
+      const iso = new Date(at).toISOString();
+      const day = localDay(at);
+      const before = activity[clientId];
+      const counted = before?.day === day ? before.toolCalls : 0;
+      const last = tools.at(-1);
+      activity[clientId] = {
+        lastRequestAt: iso,
+        day,
+        toolCalls: counted + tools.length,
+        ...last ? { lastTool: last, lastToolAt: iso } : before?.lastTool ? { lastTool: before.lastTool, ...before.lastToolAt ? { lastToolAt: before.lastToolAt } : {} } : {}
+      };
+      if (last) {
+        clearTimeout(timer);
+        write();
+      } else if (!timer) {
+        timer = setTimeout(write, WRITE_EVERY_MS);
+        timer.unref();
+      }
+    }, "record"),
+    flush: /* @__PURE__ */ __name(() => {
+      if (!timer)
+        return;
+      clearTimeout(timer);
+      write();
+    }, "flush")
+  };
+}, "activityRecorder");
+
+// 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/state.js
+var ACCESS_SECONDS = 60 * 60;
+var REFRESH_SECONDS = 30 * 24 * 60 * 60;
+var readStored = /* @__PURE__ */ __name((path) => existsSync2(path) ? JSON.parse(readFileSync2(path, "utf8")) : { clients: [], tokens: [] }, "readStored");
+var mcpHttpMarker = /* @__PURE__ */ __name((envPrefix) => `${envPrefix}_MCP_HTTP`, "mcpHttpMarker");
+var httpLogFile = /* @__PURE__ */ __name((tokenFile) => `${tokenFile.replace(/\.json$/, "")}.log`, "httpLogFile");
+var httpLockFile = /* @__PURE__ */ __name((tokenFile) => `${tokenFile.replace(/\.json$/, "")}.lock`, "httpLockFile");
+var httpLaunchFile = /* @__PURE__ */ __name((lockFile) => `${lockFile.replace(/\.lock$/, "")}.launch.json`, "httpLaunchFile");
+var readHttpLaunch = /* @__PURE__ */ __name((path) => {
+  try {
+    const launch = JSON.parse(readFileSync2(path, "utf8"));
+    return typeof launch.invocation === "string" && Array.isArray(launch.argv) && launch.argv.every((word) => typeof word === "string") && typeof launch.env === "object" && launch.env !== null ? launch : void 0;
+  } catch {
+    return void 0;
+  }
+}, "readHttpLaunch");
+var readHttpLock = /* @__PURE__ */ __name((path) => {
+  const lock = readLock(path);
+  return lock && typeof lock.port === "number" && typeof lock.publicUrl === "string" ? lock : void 0;
+}, "readHttpLock");
+var httpLock = /* @__PURE__ */ __name((path, first) => {
+  let current = first;
+  const held = takeLock(path, current);
+  return {
+    held,
+    update: /* @__PURE__ */ __name((change) => {
+      current = { ...current, ...change };
+      holdLock(path, current);
+    }, "update"),
+    release: /* @__PURE__ */ __name(() => releaseLock(path), "release")
+  };
+}, "httpLock");
+var signedInClients = /* @__PURE__ */ __name((tokenFile, now = Date.now()) => {
+  const seconds = Math.floor(now / 1e3);
+  const { clients, tokens } = readStored(tokenFile);
+  const activity = readActivity(httpActivityFile(tokenFile));
+  const today = localDay(now);
+  const last = /* @__PURE__ */ new Map();
+  for (const token of tokens) {
+    if (token.expiresAt <= seconds)
+      continue;
+    const issued = token.expiresAt - (token.kind === "access" ? ACCESS_SECONDS : REFRESH_SECONDS);
+    last.set(token.clientId, Math.max(last.get(token.clientId) ?? 0, issued));
+  }
+  return clients.filter((client) => last.has(client.id)).map((client) => {
+    const did = activity[client.id];
+    return {
+      claimedName: client.name ?? null,
+      lastLoginAt: new Date((last.get(client.id) ?? 0) * 1e3).toISOString(),
+      lastRequestAt: did?.lastRequestAt ?? null,
+      lastTool: did?.lastTool ?? null,
+      lastToolAt: did?.lastToolAt ?? null,
+      toolCallsToday: did?.day === today ? did.toolCalls : 0
+    };
+  }).sort((a, b) => b.lastLoginAt.localeCompare(a.lastLoginAt));
+}, "signedInClients");
+
+export {
+  httpActivityFile,
+  calledTools,
+  activityRecorder,
+  ACCESS_SECONDS,
+  REFRESH_SECONDS,
+  readStored,
+  mcpHttpMarker,
+  httpLogFile,
+  httpLockFile,
+  httpLaunchFile,
+  readHttpLaunch,
+  readHttpLock,
+  httpLock,
+  signedInClients
+};

package/dist/bundle/chunk-ZTOAAYFV.js

@@ -0,0 +1,122 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  unit
+} from "./chunk-NOKFJJPA.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/embeddings/remote.js
+import { setTimeout } from "node:timers/promises";
+var OPENAI_URL = "https://api.openai.com/v1";
+var OPENAI_MODELS = {
+  "text-embedding-3-small": { dims: 1536, perMillion: 0.02 },
+  "text-embedding-3-large": { dims: 3072, perMillion: 0.13 }
+};
+var DEFAULT_OPENAI_MODEL = "text-embedding-3-small";
+var PER_REQUEST = 256;
+var LOCAL = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]", "::1"]);
+var isLocal = /* @__PURE__ */ __name((baseUrl) => LOCAL.has(new URL(baseUrl).hostname), "isLocal");
+var remoteModel = /* @__PURE__ */ __name(({ model = DEFAULT_OPENAI_MODEL, baseUrl, dims }) => {
+  const known = baseUrl === void 0 ? OPENAI_MODELS[model] : void 0;
+  if (baseUrl === void 0 && !known) {
+    throw new CliError("validation_error", `OpenAI has no embedding model ${model} here \u2014 one of: ${Object.keys(OPENAI_MODELS).join(", ")}; another server takes --base-url`);
+  }
+  const size = dims ?? known?.dims;
+  if (size === void 0)
+    throw new CliError("validation_error", "with --base-url, say the vector size with --dims");
+  return {
+    provider: baseUrl === void 0 ? "openai" : `url:${new URL(baseUrl).host}`,
+    model,
+    dims: size,
+    baseUrl: baseUrl ?? OPENAI_URL,
+    shorten: known !== void 0 && size !== known.dims,
+    ...known ? { price: { perMillion: known.perMillion, read: "2026-10-02" } } : {}
+  };
+}, "remoteModel");
+var remoteKey = /* @__PURE__ */ __name(({ provider, model, dims }) => `${provider}:${model}:${dims}`, "remoteKey");
+var openRemote = /* @__PURE__ */ __name((remote, apiKey, { concurrency = 4, fetch: post = fetch, tries = 5 } = {}) => {
+  const request = /* @__PURE__ */ __name(async (input) => {
+    for (let attempt = 1; ; attempt++) {
+      let response;
+      try {
+        response = await post(`${remote.baseUrl.replace(/\/$/, "")}/embeddings`, {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            ...apiKey ? { authorization: `Bearer ${apiKey}` } : {}
+          },
+          body: JSON.stringify({
+            model: remote.model,
+            input,
+            encoding_format: "float",
+            ...remote.shorten ? { dimensions: remote.dims } : {}
+          })
+        });
+      } catch {
+        if (attempt >= tries)
+          throw new CliError("network_error", `${remote.provider} could not be reached`);
+        await setTimeout(1e3 * attempt);
+        continue;
+      }
+      if (response.ok) {
+        const body = await response.json();
+        const data = [...body.data ?? []].sort((a, b) => a.index - b.index);
+        if (data.length !== input.length || data.some(({ embedding }) => embedding.length !== remote.dims)) {
+          throw new CliError("invalid_response", `${remote.provider} answered with vectors of another number or size than ${input.length} \xD7 ${remote.dims}`);
+        }
+        return data.map(({ embedding }) => unit(Float32Array.from(embedding)));
+      }
+      const code = await errorCode(response);
+      if (response.status === 401 || response.status === 403) {
+        throw new CliError("authentication_error", `${remote.provider} refused the key (HTTP ${response.status}${code}) \u2014 set it again with \`models keys set\``);
+      }
+      const again = response.status === 429 || response.status >= 500;
+      if (!again || attempt >= tries) {
+        throw new CliError(response.status === 429 ? "rate_limited" : "provider_error", `${remote.provider} answered HTTP ${response.status}${code}`);
+      }
+      const wait = Number(response.headers.get("retry-after"));
+      await setTimeout(Number.isFinite(wait) && wait > 0 ? wait * 1e3 : 1e3 * 2 ** attempt);
+    }
+  }, "request");
+  return {
+    model: { id: remote.model, dims: remote.dims },
+    embed: /* @__PURE__ */ __name(async (texts) => {
+      const parts = [];
+      for (let start = 0; start < texts.length; start += PER_REQUEST)
+        parts.push(texts.slice(start, start + PER_REQUEST));
+      const results = new Array(parts.length);
+      let next = 0;
+      await Promise.all(Array.from({ length: Math.min(concurrency, parts.length) }, async () => {
+        for (let index = next++; index < parts.length; index = next++)
+          results[index] = await request(parts[index]);
+      }));
+      return results.flat();
+    }, "embed"),
+    close: /* @__PURE__ */ __name(async () => {
+    }, "close")
+  };
+}, "openRemote");
+var errorCode = /* @__PURE__ */ __name(async (response) => {
+  try {
+    const body = await response.json();
+    const code = body.error?.code ?? body.error?.type;
+    return typeof code === "string" && /^[\w.-]{1,64}$/.test(code) ? `, ${code}` : "";
+  } catch {
+    return "";
+  }
+}, "errorCode");
+
+export {
+  OPENAI_URL,
+  OPENAI_MODELS,
+  DEFAULT_OPENAI_MODEL,
+  isLocal,
+  remoteModel,
+  remoteKey,
+  openRemote
+};

package/dist/bundle/chunk-ZVVMGPBJ.js

@@ -0,0 +1,50 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __name,
+  __require,
+  __commonJS,
+  __export,
+  __toESM
+};