@wirecat/zoom-cli 0.55.0 → 0.57.0

package/dist/bundle/chunk-TLQUKHEM.js

@@ -0,0 +1,193 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  listen
+} from "./chunk-UC44ZMQV.js";
+import {
+  ownerLogin
+} from "./chunk-Z4TZ6TAF.js";
+import {
+  activityRecorder,
+  calledTools,
+  httpActivityFile,
+  httpLock
+} from "./chunk-G4VZDINN.js";
+import {
+  WebStandardStreamableHTTPServerTransport,
+  createMcpHandler,
+  getOAuthProtectedResourceMetadataUrl,
+  hostHeaderValidationResponse,
+  isLegacyRequest,
+  oauthMetadataResponse,
+  requireBearerAuth
+} from "./chunk-5D4AEUVA.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/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-TZ2MKETI.js

@@ -0,0 +1,100 @@
+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/store/driver.js
+var PRAGMAS = `
+  PRAGMA busy_timeout = 5000;
+  PRAGMA journal_mode = WAL;
+  PRAGMA foreign_keys = ON;
+`;
+
+// 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/store/sqlite-warning.js
+var SQLITE_WARNING = "SQLite is an experimental feature";
+var quieted = /* @__PURE__ */ new WeakSet();
+var quietSqliteWarning = /* @__PURE__ */ __name((host = process) => {
+  if (quieted.has(host))
+    return;
+  quieted.add(host);
+  const emit = host.emitWarning;
+  host.emitWarning = function(warning, ...rest) {
+    if (isSqliteWarning(warning, rest[0]))
+      return;
+    return Reflect.apply(emit, this, [warning, ...rest]);
+  };
+}, "quietSqliteWarning");
+var isSqliteWarning = /* @__PURE__ */ __name((warning, options) => {
+  const type = typeof options === "string" ? options : options?.type;
+  const name = typeof warning === "string" ? type : warning.name;
+  const message = typeof warning === "string" ? warning : warning.message;
+  return name === "ExperimentalWarning" && message.startsWith(SQLITE_WARNING);
+}, "isSqliteWarning");
+
+// 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/store/open.js
+var openCache = /* @__PURE__ */ __name(async (path) => {
+  const database = await openFile(path);
+  try {
+    database.exec(PRAGMAS);
+  } catch (error) {
+    database.close();
+    throw error;
+  }
+  return database;
+}, "openCache");
+var openFile = /* @__PURE__ */ __name((path) => "Bun" in globalThis ? openUnderBun(path) : openUnderNode(path), "openFile");
+var openUnderBun = /* @__PURE__ */ __name(async (path) => {
+  const { openWithBunSqlite } = await import("./bun-sqlite-2SDA3YOT.js");
+  return await openWithBunSqlite(path);
+}, "openUnderBun");
+var openUnderNode = /* @__PURE__ */ __name(async (path) => {
+  quietSqliteWarning();
+  const { openWithNodeSqlite } = await import("./node-sqlite-ZNGOBA5Q.js");
+  return openWithNodeSqlite(path);
+}, "openUnderNode");
+var runtime = /* @__PURE__ */ __name(() => {
+  const bun = globalThis.Bun;
+  return bun ? `Bun ${bun.version}` : `Node ${process.versions.node}`;
+}, "runtime");
+var CAPABILITY_STATEMENTS = [
+  `CREATE VIRTUAL TABLE temp.capability_words USING fts5(a, content = '', contentless_delete = 1,
+     tokenize = 'unicode61 remove_diacritics 2')`,
+  "CREATE VIRTUAL TABLE temp.capability_text USING fts5(a, tokenize = 'trigram')",
+  "DROP TABLE temp.capability_words",
+  "DROP TABLE temp.capability_text"
+];
+var assertStoreCapable = /* @__PURE__ */ __name((database, on = runtime()) => {
+  try {
+    for (const statement of CAPABILITY_STATEMENTS)
+      database.exec(statement);
+  } catch (error) {
+    const version = String(database.prepare("SELECT sqlite_version() AS version").get()?.version);
+    const remedy = on.startsWith("Bun") ? "Run it under Node 22.16 or newer instead" : "Update Node to 22.16 or newer, or run it under Bun";
+    throw new CliError("configuration_error", `the message store needs full-text search that this SQLite (${version}, ${on}) does not have. ${remedy}.`, { sqlite: version, runtime: on, cause: error instanceof Error ? error.message : String(error) });
+  }
+}, "assertStoreCapable");
+var capable;
+var storeCapable = /* @__PURE__ */ __name(() => {
+  capable ??= openCache(":memory:").then((database) => {
+    try {
+      assertStoreCapable(database);
+    } finally {
+      database.close();
+    }
+  });
+  return capable;
+}, "storeCapable");
+
+export {
+  PRAGMAS,
+  quietSqliteWarning,
+  openCache,
+  openFile,
+  CAPABILITY_STATEMENTS,
+  assertStoreCapable,
+  storeCapable
+};

package/dist/bundle/chunk-UC44ZMQV.js

@@ -0,0 +1,78 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+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/listen.js
+import { createServer } from "node:http";
+import { Readable } from "node:stream";
+var MAX_BODY = 4 * 1024 * 1024;
+var TooLarge = class extends Error {
+  static {
+    __name(this, "TooLarge");
+  }
+};
+var readBody = /* @__PURE__ */ __name((incoming, limit) => new Promise((resolve, reject) => {
+  if (Number(incoming.headers["content-length"] ?? 0) > limit)
+    return reject(new TooLarge());
+  const chunks = [];
+  let size = 0;
+  incoming.on("data", (chunk) => {
+    size += chunk.length;
+    if (size > limit) {
+      incoming.destroy();
+      reject(new TooLarge());
+    } else
+      chunks.push(chunk);
+  });
+  incoming.once("end", () => resolve(Buffer.concat(chunks)));
+  incoming.once("error", reject);
+}), "readBody");
+var toRequest = /* @__PURE__ */ __name(async (incoming, origin, maxBody) => {
+  const headers = new Headers();
+  for (const [name, value] of Object.entries(incoming.headers)) {
+    if (Array.isArray(value))
+      for (const one of value)
+        headers.append(name, one);
+    else if (value !== void 0)
+      headers.set(name, value);
+  }
+  const method = incoming.method ?? "GET";
+  const body = method === "GET" || method === "HEAD" ? void 0 : await readBody(incoming, maxBody);
+  if (body)
+    headers.set("content-length", String(body.length));
+  return new Request(new URL(incoming.url ?? "/", origin), { method, headers, ...body ? { body } : {} });
+}, "toRequest");
+var send = /* @__PURE__ */ __name(async (response, outgoing) => {
+  outgoing.writeHead(response.status, Object.fromEntries(response.headers));
+  if (!response.body)
+    return void outgoing.end();
+  const body = Readable.fromWeb(response.body);
+  outgoing.once("close", () => body.destroy());
+  body.pipe(outgoing);
+}, "send");
+var listen = /* @__PURE__ */ __name((handle, { host, port, maxBody = MAX_BODY }) => new Promise((resolve, reject) => {
+  const server = createServer((incoming, outgoing) => {
+    toRequest(incoming, `http://${host}`, maxBody).then(handle).then((response) => send(response, outgoing)).catch((error) => {
+      if (!outgoing.headersSent)
+        outgoing.writeHead(error instanceof TooLarge ? 413 : 500, { connection: "close" });
+      outgoing.end();
+    });
+  });
+  server.once("error", reject);
+  server.listen(port, host, () => {
+    const { port: bound } = server.address();
+    resolve({
+      url: new URL(`http://${host}:${bound}`),
+      close: /* @__PURE__ */ __name(() => new Promise((done) => {
+        server.close(() => done());
+        server.closeAllConnections();
+      }), "close")
+    });
+  });
+}), "listen");
+
+export {
+  listen
+};

package/dist/bundle/chunk-UI5UTMSZ.js

@@ -0,0 +1,275 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  envName,
+  readOnlyLockOf
+} from "./chunk-OCGPZHXW.js";
+import {
+  CAPABILITY_STATEMENTS,
+  storeCapable
+} from "./chunk-TZ2MKETI.js";
+import {
+  CliError,
+  catchCrashes
+} 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/cli/entry.js
+import { spawn as spawn2 } from "node:child_process";
+
+// 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/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.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/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.469.0_@wirecat+cli-base@0.65.0_commander@15.0.0_typescript@7.0.2_vi_80b586dbc8b099637a6e461856c2ee6b/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-EVSRQKZJ.js"),
+        import("./command-contract-4MHSZUN3.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-RT7GUUXH.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
+};