@wirecat/mail-cli 0.0.0-stage → 0.1.1

package/dist/bundle/dispatch-EUKKT3PD.js

@@ -0,0 +1,411 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  require_cross_spawn
+} from "./chunk-D72URWJE.js";
+import {
+  BUILT_IN_COMMANDS,
+  DESCRIBE_FLAG,
+  FIRST_PARTY_TOOLS,
+  PROGRAM_PREFIX,
+  TOOL_NAME,
+  fileState,
+  parseDescribe,
+  shimFiles,
+  writeShim
+} from "./chunk-TI6VBZKJ.js";
+import "./chunk-Y5E2WNWB.js";
+import {
+  CliError
+} from "./chunk-5BVIWP3S.js";
+import {
+  __name,
+  __toESM
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/wcat/dispatch.js
+var import_cross_spawn2 = __toESM(require_cross_spawn(), 1);
+import { randomUUID } from "node:crypto";
+import { constants } from "node:os";
+
+// node_modules/.pnpm/@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/wcat/path.js
+import { readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+var variable = /* @__PURE__ */ __name((env, name, platform) => platform === "win32" ? Object.entries(env).find(([key]) => key.toUpperCase() === name)?.[1] : env[name], "variable");
+var pathEntries = /* @__PURE__ */ __name(({ env, platform }) => {
+  const raw = variable(env, "PATH", platform) ?? "";
+  const entries = raw.split(platform === "win32" ? ";" : ":").map((entry) => entry.replace(/^"(.*)"$/, "$1"));
+  const seen = /* @__PURE__ */ new Set();
+  return entries.filter((entry) => {
+    const key = platform === "win32" ? entry.toLowerCase().replace(/[\\/]+$/, "") : entry.replace(/\/+$/, "");
+    if (entry === "" || seen.has(key))
+      return false;
+    seen.add(key);
+    return true;
+  });
+}, "pathEntries");
+var programExtensions = /* @__PURE__ */ __name(({ env, platform }) => platform === "win32" ? (variable(env, "PATHEXT", platform) ?? ".COM;.EXE;.BAT;.CMD").split(";").filter((ext) => /^\.[a-z0-9]+$/i.test(ext)).map((ext) => ext.toLowerCase()) : [""], "programExtensions");
+var isProgram = /* @__PURE__ */ __name((path, platform) => {
+  try {
+    const stat = statSync(path);
+    return stat.isFile() && (platform === "win32" || (stat.mode & 73) !== 0);
+  } catch {
+    return false;
+  }
+}, "isProgram");
+var findOnPath = /* @__PURE__ */ __name((command, search) => {
+  const extensions = programExtensions(search);
+  return pathEntries(search).flatMap((dir) => {
+    for (const extension of extensions) {
+      const path = join(dir, command + extension);
+      if (isProgram(path, search.platform))
+        return [path];
+    }
+    return [];
+  });
+}, "findOnPath");
+var findTools = /* @__PURE__ */ __name((search) => {
+  const extensions = programExtensions(search);
+  const tools = /* @__PURE__ */ new Map();
+  for (const dir of pathEntries(search)) {
+    let files;
+    try {
+      files = readdirSync(dir);
+    } catch {
+      continue;
+    }
+    const here = /* @__PURE__ */ new Map();
+    for (const file of files) {
+      if (!(search.platform === "win32" ? file.toLowerCase() : file).startsWith(PROGRAM_PREFIX))
+        continue;
+      const extension = extensions.find((ext) => ext !== "" && file.toLowerCase().endsWith(ext)) ?? "";
+      if (search.platform === "win32" && extension === "")
+        continue;
+      const base = search.platform === "win32" ? file.toLowerCase() : file;
+      const name = base.slice(PROGRAM_PREFIX.length, base.length - extension.length);
+      if (!TOOL_NAME.test(name))
+        continue;
+      const best = here.get(name);
+      const rank = /* @__PURE__ */ __name((path2) => extensions.findIndex((ext) => path2.toLowerCase().endsWith(ext)), "rank");
+      const path = join(dir, file);
+      if (best !== void 0 && rank(best) <= rank(path))
+        continue;
+      if (isProgram(path, search.platform))
+        here.set(name, path);
+    }
+    for (const [name, path] of here)
+      tools.set(name, [...tools.get(name) ?? [], path]);
+  }
+  return new Map([...tools].sort(([a], [b]) => a < b ? -1 : 1));
+}, "findTools");
+var isBuiltIn = /* @__PURE__ */ __name((name) => name === "wcat" || BUILT_IN_COMMANDS.includes(name), "isBuiltIn");
+
+// node_modules/.pnpm/@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/wcat/probe.js
+var import_cross_spawn = __toESM(require_cross_spawn(), 1);
+import { readFileSync } from "node:fs";
+var MAX_ANSWER_BYTES = 64 * 1024;
+var probeDescribe = /* @__PURE__ */ __name((path, { env, timeoutMs }) => new Promise((resolve) => {
+  let child;
+  try {
+    child = (0, import_cross_spawn.default)(path, [DESCRIBE_FLAG], { stdio: ["ignore", "pipe", "ignore"], env, windowsHide: true });
+  } catch {
+    resolve(void 0);
+    return;
+  }
+  const chunks = [];
+  let size = 0;
+  let settled = false;
+  const settle = /* @__PURE__ */ __name((answer) => {
+    if (settled)
+      return;
+    settled = true;
+    clearTimeout(timer);
+    resolve(answer);
+  }, "settle");
+  const giveUp = /* @__PURE__ */ __name(() => {
+    child.kill();
+    child.stdout?.destroy();
+    child.unref();
+    settle(void 0);
+  }, "giveUp");
+  const timer = setTimeout(giveUp, timeoutMs);
+  child.stdout?.on("data", (chunk) => {
+    size += chunk.length;
+    if (size > MAX_ANSWER_BYTES)
+      giveUp();
+    else
+      chunks.push(chunk);
+  });
+  child.once("error", () => settle(void 0));
+  child.once("close", (code) => settle(code === 0 ? parseDescribe(Buffer.concat(chunks).toString("utf8")) : void 0));
+}), "probeDescribe");
+var baseVersion = /* @__PURE__ */ __name(() => {
+  try {
+    const raw = readFileSync(new URL("../../package.json", new URL("wcat/probe.js", import.meta.resolve("@wirecat/cli-base")).href), "utf8");
+    const { name, version } = JSON.parse(raw);
+    return name === "@wirecat/cli-base" && typeof version === "string" ? version : "unknown";
+  } catch {
+    return "unknown";
+  }
+}, "baseVersion");
+
+// node_modules/.pnpm/@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/wcat/shortcuts.js
+import { closeSync, openSync, readSync, realpathSync, rmSync } from "node:fs";
+import { basename, dirname } from "node:path";
+var WIRECAT_PACKAGE = /node_modules[\\/]+@wirecat[\\/]/;
+var isWirecatPackage = /* @__PURE__ */ __name((path) => {
+  try {
+    if (WIRECAT_PACKAGE.test(realpathSync(path)))
+      return true;
+    const buffer = Buffer.alloc(16 * 1024);
+    const fd = openSync(path, "r");
+    try {
+      const read = readSync(fd, buffer, 0, buffer.length, 0);
+      return WIRECAT_PACKAGE.test(buffer.subarray(0, read).toString("latin1"));
+    } finally {
+      closeSync(fd);
+    }
+  } catch {
+    return false;
+  }
+}, "isWirecatPackage");
+var ourShortcut = /* @__PURE__ */ __name((path) => {
+  const state = fileState(path);
+  return state.state === "ours" && state.mark.kind === "shortcut";
+}, "ourShortcut");
+var statusOf = /* @__PURE__ */ __name((name, program, search) => {
+  const files = shimFiles("shortcut", {
+    dir: dirname(program),
+    name,
+    target: basename(program),
+    platform: search.platform
+  });
+  const named = findOnPath(name, search);
+  const made = [...files.map((file) => file.path), ...named].find(ourShortcut);
+  if (made)
+    return { name, status: "made", path: made, program };
+  const first = named[0];
+  if (first === void 0)
+    return { name, status: "free", program };
+  return { name, status: isWirecatPackage(first) ? "package" : "taken", path: first, program };
+}, "statusOf");
+var changeFile = /* @__PURE__ */ __name((path, change) => {
+  try {
+    change();
+  } catch (error) {
+    throw new CliError("permission_error", `could not change ${path}: ${error.code ?? error}`, {
+      reason: "access.denied"
+    });
+  }
+}, "changeFile");
+var installedPrograms = /* @__PURE__ */ __name((search) => new Map([...findTools(search)].filter(([name]) => !isBuiltIn(name))), "installedPrograms");
+var chosen = /* @__PURE__ */ __name((names, search) => {
+  const installed = installedPrograms(search);
+  if (names === void 0 || names.length === 0)
+    return [...installed].map(([name, paths]) => [name, paths[0]]);
+  const missing = names.filter((name) => !installed.has(name));
+  if (missing.length > 0)
+    throw new CliError("not_found", `not installed: ${missing.map((name) => `wcat-${name}`).join(", ")}`, {
+      reason: "tool.not-installed",
+      tool: missing[0],
+      installed: [...installed.keys()]
+    });
+  return [...new Set(names)].map((name) => [name, installed.get(name)[0]]);
+}, "chosen");
+var listShortcuts = /* @__PURE__ */ __name((search, names) => chosen(names, search).map(([name, program]) => statusOf(name, program, search)), "listShortcuts");
+var addShortcuts = /* @__PURE__ */ __name((search, names) => listShortcuts(search, names).map((shortcut) => {
+  if (shortcut.status !== "free")
+    return { ...shortcut, changed: false };
+  const files = shimFiles("shortcut", {
+    dir: dirname(shortcut.program),
+    name: shortcut.name,
+    target: basename(shortcut.program),
+    platform: search.platform
+  });
+  for (const file of files)
+    changeFile(file.path, () => writeShim(file));
+  return { ...shortcut, status: "made", path: files[0]?.path, changed: true };
+}), "addShortcuts");
+var removeShortcuts = /* @__PURE__ */ __name((search, names) => listShortcuts(search, names).map((shortcut) => {
+  if (shortcut.status !== "made")
+    return { ...shortcut, changed: false };
+  const files = shimFiles("shortcut", {
+    dir: dirname(shortcut.path),
+    name: shortcut.name,
+    target: basename(shortcut.program),
+    platform: search.platform
+  });
+  for (const file of files)
+    if (ourShortcut(file.path))
+      changeFile(file.path, () => rmSync(file.path, { force: true }));
+  return { ...statusOf(shortcut.name, shortcut.program, search), changed: true };
+}), "removeShortcuts");
+
+// node_modules/.pnpm/@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_typescript@7.0.2_vitest@5.0.5/node_modules/@wirecat/cli-base/dist/wcat/dispatch.js
+var DEFAULT_DESCRIBE_TIMEOUT_MS = 2e3;
+var listTools = /* @__PURE__ */ __name(async (context) => {
+  const installed = installedPrograms(context);
+  const timeoutMs = context.describeTimeoutMs ?? DEFAULT_DESCRIBE_TIMEOUT_MS;
+  const found = await Promise.all([...installed].map(async ([name, paths]) => {
+    const [path, ...shadowed] = paths;
+    const own = context.self?.command === name ? context.self : void 0;
+    const described = own ?? await probeDescribe(path, { env: context.env, timeoutMs });
+    return {
+      name,
+      installed: true,
+      path,
+      ...described?.version ? { version: described.version } : {},
+      ...described?.description ? { description: described.description } : {},
+      ...described?.docs ? { docs_url: described.docs } : {},
+      ...shadowed.length > 0 ? { shadowed } : {}
+    };
+  }));
+  const missing = FIRST_PARTY_TOOLS.filter((tool) => tool.package && !installed.has(tool.name)).map((tool) => ({
+    name: tool.name,
+    installed: false,
+    package: tool.package,
+    install: `npm install -g ${tool.package}`
+  }));
+  return [...found, ...missing];
+}, "listTools");
+var envelope = /* @__PURE__ */ __name((items, started) => ({
+  items,
+  page: { mode: "page", limit: Math.max(items.length, 1), has_more: false },
+  meta: { run_id: randomUUID(), duration_ms: Math.max(0, Math.round(performance.now() - started)), complete: true }
+}), "envelope");
+var column = /* @__PURE__ */ __name((rows) => {
+  const widths = rows[0]?.map((_, at) => rows.reduce((wide, row) => Math.max(wide, (row[at] ?? "").length), 0)) ?? [];
+  return rows.map((row) => `  ${row.map((cell, at) => cell.padEnd(widths[at] ?? 0)).join("  ")}`.trimEnd());
+}, "column");
+var USAGE = [
+  "wcat <tool> [arguments]                 run a tool: wcat tg --help",
+  "wcat shortcuts [add|remove] [tool...]   short names, such as tg, for installed tools",
+  "wcat --json                             the list below as JSON"
+];
+var listText = /* @__PURE__ */ __name((tools) => {
+  const installed = tools.filter((tool) => tool.installed);
+  const missing = tools.filter((tool) => !tool.installed);
+  return [
+    "wcat runs WireCat tools, and any other wcat-<name> program on PATH.",
+    "",
+    ...USAGE,
+    "",
+    installed.length > 0 ? "Installed:" : "Installed: none",
+    ...column(installed.map((tool) => [tool.name, tool.version ?? "", tool.description ?? "(no description)"])),
+    ...missing.length > 0 ? ["", "Not installed:", ...column(missing.map((tool) => [tool.name, tool.install ?? ""]))] : [],
+    ""
+  ].join("\n");
+}, "listText");
+var shadowWarnings = /* @__PURE__ */ __name((tools) => tools.filter((tool) => tool.shadowed).map((tool) => `wcat: ${(tool.shadowed?.length ?? 0) + 1} programs are named ${PROGRAM_PREFIX}${tool.name}; wcat runs the first:
+${[tool.path, ...tool.shadowed ?? []].map((path) => `  ${path}`).join("\n")}
+`).join(""), "shadowWarnings");
+var shortcutText = /* @__PURE__ */ __name((shortcuts2) => {
+  if (shortcuts2.length === 0)
+    return "No wcat-<name> programs are installed.\n";
+  const said = /* @__PURE__ */ __name((shortcut) => {
+    switch (shortcut.status) {
+      case "made":
+        return `made: ${shortcut.path}`;
+      case "free":
+        return shortcut.changed ? "removed" : "free: wcat shortcuts add makes it";
+      case "package":
+        return `installed by the package: ${shortcut.path}`;
+      case "taken":
+        return `taken by ${shortcut.path}`;
+    }
+  }, "said");
+  return `${column(shortcuts2.map((shortcut) => [shortcut.name, said(shortcut)])).join("\n")}
+`;
+}, "shortcutText");
+var signalNumber = /* @__PURE__ */ __name((signal) => constants.signals[signal] ?? 1, "signalNumber");
+var runTool = /* @__PURE__ */ __name((path, args, context) => new Promise((resolve, reject) => {
+  const signals = context.signals ?? process;
+  const child = (0, import_cross_spawn2.default)(path, [...args], { stdio: "inherit", env: context.env });
+  const pass = /* @__PURE__ */ __name((signal) => () => child.kill(signal), "pass");
+  const term = pass("SIGTERM");
+  const hup = pass("SIGHUP");
+  const ignore = /* @__PURE__ */ __name(() => {
+  }, "ignore");
+  signals.on("SIGTERM", term).on("SIGHUP", hup).on("SIGINT", ignore);
+  const done = /* @__PURE__ */ __name(() => signals.off("SIGTERM", term).off("SIGHUP", hup).off("SIGINT", ignore), "done");
+  child.once("error", (error) => {
+    done();
+    reject(new CliError("configuration_error", `could not start ${path}: ${error.message}`));
+  });
+  child.once("exit", (code, signal) => {
+    done();
+    resolve(code ?? (signal ? 128 + signalNumber(signal) : 1));
+  });
+}), "runTool");
+var fail = /* @__PURE__ */ __name(async (error, json, context) => {
+  const { errorObjectOf, exitCodeOfError, renderError } = await import("./failure-OAIC5VAP.js");
+  const object = errorObjectOf(error);
+  context.stderr.write(`${renderError(object, { cli: "wcat", interactive: !json })}
+`);
+  return exitCodeOfError(object);
+}, "fail");
+var shortcuts = /* @__PURE__ */ __name(async (args, json, context) => {
+  const [action, ...names] = args;
+  const started = performance.now();
+  const result = action === "add" ? addShortcuts(context, names) : action === "remove" ? removeShortcuts(context, names) : action === void 0 || action === "list" ? listShortcuts(context, names) : void 0;
+  if (result === void 0)
+    throw new CliError("validation_error", `wcat shortcuts takes list, add or remove, not "${action}"`, {
+      reason: "input.invalid"
+    });
+  context.stdout.write(json ? `${JSON.stringify(envelope(result, started))}
+` : shortcutText(result));
+  return 0;
+}, "shortcuts");
+var runWcat = /* @__PURE__ */ __name(async (args, context) => {
+  const [first, ...rest] = args;
+  const json = args.includes("--json");
+  const words = args.filter((word) => word !== "--json");
+  const started = performance.now();
+  try {
+    if (first === "--version" || first === "-V" || first === "version") {
+      const tools = await listTools(context);
+      const by = context.self ? `, run by ${PROGRAM_PREFIX}${context.self.command} ${context.self.version}` : "";
+      context.stdout.write(`wcat ${baseVersion()} (@wirecat/cli-base${by})
+
+${listText(tools)}`);
+      return 0;
+    }
+    if (words.length === 0 || first === "--help" || first === "-h" || first === "help") {
+      const tools = await listTools(context);
+      if (json)
+        context.stdout.write(`${JSON.stringify(envelope(tools, started))}
+`);
+      else {
+        context.stderr.write(shadowWarnings(tools));
+        context.stdout.write(listText(tools));
+      }
+      return 0;
+    }
+    if (first === "shortcuts")
+      return await shortcuts(words.slice(1), json, context);
+    if (BUILT_IN_COMMANDS.includes(first))
+      throw new CliError("validation_error", `wcat ${first} is reserved for a later version of wcat`, {
+        reason: "input.invalid"
+      });
+    if (first?.startsWith("-"))
+      throw new CliError("validation_error", `wcat does not take ${first} before a tool's name`, {
+        reason: "input.invalid"
+      });
+    const name = first;
+    const [path, ...shadowed] = TOOL_NAME.test(name) ? findOnPath(`${PROGRAM_PREFIX}${name}`, context) : [];
+    if (path === void 0) {
+      const installed = [...installedPrograms(context).keys()];
+      throw new CliError("not_found", `no ${PROGRAM_PREFIX}${name} on PATH; installed: ${installed.length > 0 ? installed.join(", ") : "none"}`, { reason: "tool.not-installed", tool: name, installed });
+    }
+    if (shadowed.length > 0 && context.stderr.isTTY)
+      context.stderr.write(shadowWarnings([{ name, installed: true, path, shadowed }]));
+    return await runTool(path, rest, context);
+  } catch (error) {
+    return fail(error, json, context);
+  }
+}, "runWcat");
+export {
+  listTools,
+  runTool,
+  runWcat
+};