@wirecat/zoom-cli 0.56.0 → 0.58.0

package/dist/bundle/chunk-YJRMMZI5.js

@@ -0,0 +1,275 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  envName,
+  readOnlyLockOf
+} from "./chunk-XFCSPOLZ.js";
+import {
+  CAPABILITY_STATEMENTS,
+  storeCapable
+} from "./chunk-SL3SXQZ5.js";
+import {
+  CliError,
+  catchCrashes
+} from "./chunk-YIMI6O7R.js";
+import {
+  importFrom
+} from "./chunk-Y5E2WNWB.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/entry.js
+import { spawn as spawn2 } from "node:child_process";
+
+// 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/sqlite-runtime.js
+import { spawn, spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { dirname } from "node:path";
+var RESTARTED = "CLI_MESSAGING_SQLITE_RESTARTED";
+var USER_LIBRARY_PATH = "CLI_MESSAGING_USER_LD_LIBRARY_PATH";
+var FORWARDED = ["SIGTERM", "SIGHUP", "SIGQUIT"];
+var ensureSqlite = /* @__PURE__ */ __name(async (runtime = nodeRuntime()) => {
+  const { env } = runtime;
+  if (env[RESTARTED]) {
+    if (env[USER_LIBRARY_PATH] === void 0)
+      delete env.LD_LIBRARY_PATH;
+    else
+      env.LD_LIBRARY_PATH = env[USER_LIBRARY_PATH];
+    delete env[USER_LIBRARY_PATH];
+    delete env[RESTARTED];
+    return;
+  }
+  if (runtime.bun || runtime.platform !== "linux")
+    return;
+  const maps = runtime.maps();
+  if (!maps.includes("libsqlite3"))
+    return;
+  if (await runtime.capable())
+    return;
+  const library = await runtime.library(maps.includes("ld-musl"));
+  if (!library)
+    return;
+  const restarted = {
+    ...env,
+    LD_LIBRARY_PATH: [dirname(library.path), env.LD_LIBRARY_PATH].filter(Boolean).join(":"),
+    [RESTARTED]: "1"
+  };
+  if (env.LD_LIBRARY_PATH !== void 0)
+    restarted[USER_LIBRARY_PATH] = env.LD_LIBRARY_PATH;
+  if (!runtime.works(restarted, library.version))
+    return;
+  await runtime.restart(restarted);
+}, "ensureSqlite");
+var trialScript = /* @__PURE__ */ __name((version) => `
+  const { DatabaseSync } = await import("node:sqlite")
+  const database = new DatabaseSync(":memory:")
+  if (database.prepare("SELECT sqlite_version() AS v").get().v !== ${JSON.stringify(version)}) process.exit(1)
+  for (const statement of ${JSON.stringify(CAPABILITY_STATEMENTS)}) database.exec(statement)
+`, "trialScript");
+var nodeRuntime = /* @__PURE__ */ __name(() => ({
+  env: process.env,
+  platform: process.platform,
+  bun: "Bun" in globalThis,
+  maps: /* @__PURE__ */ __name(() => {
+    try {
+      return readFileSync("/proc/self/maps", "utf8");
+    } catch {
+      return "";
+    }
+  }, "maps"),
+  capable: /* @__PURE__ */ __name(() => storeCapable().then(() => true, () => false), "capable"),
+  library: /* @__PURE__ */ __name(async (musl) => {
+    try {
+      const { libraryFor, SQLITE_VERSION } = await importFrom(new URL("sqlite-runtime.js", import.meta.resolve("@wirecat/cli-core")).href, "@wirecat/cli-core-sqlite");
+      const path = libraryFor({ musl });
+      return path === void 0 ? void 0 : { path, version: SQLITE_VERSION };
+    } catch {
+      return void 0;
+    }
+  }, "library"),
+  works: /* @__PURE__ */ __name((env, version) => spawnSync(process.execPath, ["--no-warnings", "--input-type=module", "-e", trialScript(version)], {
+    env,
+    stdio: "ignore",
+    timeout: 1e4
+  }).status === 0, "works"),
+  restart: /* @__PURE__ */ __name((env) => relay(spawn(process.execPath, [...process.execArgv, ...process.argv.slice(1)], { env, stdio: "inherit" })), "restart")
+}), "nodeRuntime");
+var relay = /* @__PURE__ */ __name((child, host = process) => new Promise(() => {
+  for (const signal of FORWARDED)
+    host.on(signal, () => child.kill(signal));
+  host.on("SIGINT", () => {
+  });
+  child.on("error", () => host.exit(1));
+  child.on("exit", (code, signal) => {
+    if (signal) {
+      host.removeAllListeners(signal);
+      host.kill(host.pid, signal);
+    } else
+      host.exit(code ?? 1);
+  });
+}), "relay");
+
+// 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/argv-log.js
+import { appendFileSync } from "node:fs";
+var logParsedArgv = /* @__PURE__ */ __name((file, action) => {
+  const words = [];
+  const options = [];
+  for (let at = action; at; at = at.parent) {
+    if (at.parent)
+      words.unshift(at.name());
+    for (const option of at.options) {
+      const key = option.attributeName();
+      if (at.getOptionValueSource(key) !== "cli" || !option.long)
+        continue;
+      if (option.negate === (at.getOptionValue(key) === false))
+        options.push(option.long);
+    }
+  }
+  appendFileSync(file, `${JSON.stringify({ command: words.join(" "), options })}
+`);
+}, "logParsedArgv");
+var logVersion = /* @__PURE__ */ __name((file) => {
+  appendFileSync(file, `${JSON.stringify({ command: "", options: ["--version"] })}
+`);
+}, "logVersion");
+
+// 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/entry.js
+var processIo = /* @__PURE__ */ __name(() => ({
+  argv: process.argv,
+  env: process.env,
+  platform: process.platform,
+  stdin: process.stdin,
+  stdout: process.stdout,
+  stderr: process.stderr,
+  signals: process,
+  setExitCode: /* @__PURE__ */ __name((code) => {
+    process.exitCode = code;
+  }, "setExitCode"),
+  spawn: spawn2
+}), "processIo");
+var startCli = /* @__PURE__ */ __name(async (entry) => {
+  const io = { ...processIo(), ...entry.io };
+  const args = io.argv.slice(2);
+  if (args.length === 1 && (args[0] === "--version" || args[0] === "-V"))
+    return printVersion(entry.app, io);
+  const tty = io.stdout.isTTY === true;
+  const release = catchCrashes({
+    cli: entry.app.command,
+    interactive: entry.interactive?.(args, tty) ?? tty,
+    ...entry.reasons ? { reasons: entry.reasons } : {},
+    target: io.signals
+  });
+  const controller = new AbortController();
+  let closed = false;
+  let unwritable = false;
+  const interrupted = /* @__PURE__ */ __name((signal) => () => controller.abort(new CliError("cancelled", `command interrupted by ${signal}`, { reason: signal, retryable: false })), "interrupted");
+  const sigint = interrupted("SIGINT");
+  const sigterm = interrupted("SIGTERM");
+  const outputFailed = /* @__PURE__ */ __name((error) => {
+    if (error.code === "EPIPE") {
+      closed = true;
+      controller.abort(new CliError("cancelled", "output pipe closed", { retryable: false }));
+    } else {
+      unwritable = true;
+      controller.abort(new CliError("configuration_error", "could not write command output"));
+    }
+  }, "outputFailed");
+  const headless = /* @__PURE__ */ __name((command) => {
+    const flags = command?.optsWithGlobals() ?? {};
+    return Boolean(flags.json || flags.jsonl || flags.input === false || io.env.CI) || !tty;
+  }, "headless");
+  const context = {
+    args,
+    env: io.env,
+    tty,
+    signal: controller.signal,
+    atStart: /* @__PURE__ */ __name(async (command) => {
+      if (command.optsWithGlobals().dryRun === true)
+        return;
+      const [{ setupAtStart }, { commandPathOf }] = await Promise.all([
+        import("./first-run-LGYDLIUM.js"),
+        import("./command-contract-WHZPF7NA.js")
+      ]);
+      await setupAtStart({
+        command: entry.app.command,
+        env: io.env,
+        contentLanguages: entry.app.contentLanguages,
+        path: commandPathOf(command),
+        headless: headless(command),
+        readOnlyLock: readOnlyLockOf(entry.app, io.env),
+        input: io.stdin
+      });
+    }, "atStart"),
+    ask: /* @__PURE__ */ __name(async (question, command) => {
+      if (headless(command) || io.stdin.isTTY !== true)
+        return false;
+      const { readSecret } = await import("./prompt-LUUMQTMY.js");
+      const answer = await readSecret(`${question} [y/N] `, {
+        input: io.stdin,
+        output: io.stderr,
+        echo: true,
+        signal: controller.signal
+      });
+      return /^(y|yes)$/i.test(answer.trim());
+    }, "ask"),
+    openBrowser: /* @__PURE__ */ __name((url, browser) => openBrowser(io, url, browser), "openBrowser"),
+    outputClosed: /* @__PURE__ */ __name(() => closed, "outputClosed")
+  };
+  let code;
+  try {
+    if (entry.sqlite)
+      await ensureSqlite();
+    io.signals.on("SIGINT", sigint).on("SIGTERM", sigterm);
+    io.stdout.on("error", outputFailed);
+    io.stderr.on("error", outputFailed);
+    const returned = await entry.run(context);
+    if (typeof returned === "number")
+      code = returned;
+  } catch (error) {
+    code = commanderExit(error) ?? entry.fail(error, context);
+  } finally {
+    io.signals.off("SIGINT", sigint).off("SIGTERM", sigterm);
+    release();
+  }
+  if (closed)
+    io.setExitCode(0);
+  else if (unwritable)
+    io.setExitCode(3);
+  else if (code !== void 0)
+    io.setExitCode(code);
+}, "startCli");
+var printVersion = /* @__PURE__ */ __name((app, io) => {
+  const argvLog = io.env[envName(app, "TEST_ARGV_LOG")];
+  if (argvLog)
+    logVersion(argvLog);
+  io.stdout.write(`${app.version}
+`);
+}, "printVersion");
+var commanderExit = /* @__PURE__ */ __name((error) => {
+  if (!(error instanceof Error))
+    return void 0;
+  const { code, exitCode } = error;
+  if (typeof code !== "string" || !code.startsWith("commander.") || typeof exitCode !== "number")
+    return void 0;
+  if (exitCode === 0)
+    return 0;
+  return code === "commander.help" ? 2 : void 0;
+}, "commanderExit");
+var openBrowser = /* @__PURE__ */ __name((io, url, browser) => {
+  const [command, prefix] = browser !== void 0 ? [browser, []] : io.platform === "darwin" ? ["open", []] : io.platform === "win32" ? ["rundll32.exe", ["url.dll,FileProtocolHandler"]] : ["xdg-open", []];
+  return new Promise((resolve, reject) => {
+    const child = io.spawn(command, [...prefix, url], { detached: true, stdio: "ignore", windowsHide: true });
+    child.once("error", () => reject(new CliError("configuration_error", `could not start ${command} \u2014 open the printed URL in a browser`)));
+    child.once("spawn", () => {
+      child.unref();
+      resolve();
+    });
+  });
+}, "openBrowser");
+
+export {
+  logParsedArgv,
+  logVersion,
+  startCli
+};