@curdx/flow 3.0.0 → 3.2.0

package/dist/index.mjs

@@ -0,0 +1,1165 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import * as p8 from "@clack/prompts";
+import { defineCommand, runMain } from "citty";
+
+// src/ui/language.ts
+import * as p from "@clack/prompts";
+
+// src/i18n/zh.ts
+var messages = {
+  "app.intro": "@curdx/flow \u2014 Claude Code \u63D2\u4EF6 / MCP \u4E00\u952E\u5B89\u88C5",
+  "app.outro": "\u5B8C\u6210\u3002",
+  "app.cancelled": "\u5DF2\u53D6\u6D88\u3002",
+  "lang.prompt": "\u8BF7\u9009\u62E9\u754C\u9762\u8BED\u8A00 / Please choose your language",
+  "lang.zh": "\u4E2D\u6587",
+  "lang.en": "English",
+  "menu.title": "\u60F3\u505A\u4EC0\u4E48\uFF1F",
+  "menu.install": "\u5B89\u88C5 / \u91CD\u88C5\u63D2\u4EF6\u548C MCP",
+  "menu.update": "\u66F4\u65B0\u5DF2\u5B89\u88C5\u7684\u63D2\u4EF6",
+  "menu.uninstall": "\u5378\u8F7D\u5DF2\u5B89\u88C5\u7684\u63D2\u4EF6\u548C MCP",
+  "menu.status": "\u67E5\u770B\u5F53\u524D\u5B89\u88C5\u72B6\u6001",
+  "menu.exit": "\u9000\u51FA",
+  "pkg.installed": "\u5DF2\u5B89\u88C5",
+  "pkg.notInstalled": "\u672A\u5B89\u88C5",
+  "pkg.unknown": "\u672A\u77E5",
+  "pkg.upToDateWithVersion": "\u5DF2\u5B89\u88C5 v{version}",
+  "pkg.updateAvailable": "\u5DF2\u5B89\u88C5 v{current} \u2192 v{latest} \u53EF\u7528",
+  "marketplace.refreshing": "\u5237\u65B0 marketplace \u7F13\u5B58\u2026",
+  "marketplace.refreshed": "\u5DF2\u5237\u65B0 {count} \u4E2A marketplace",
+  "marketplace.refreshSkipped": "marketplace \u7F13\u5B58\u4ECD\u662F\u65B0\u9C9C\u7684\uFF0C\u8DF3\u8FC7\u5237\u65B0",
+  "install.updating": '\u66F4\u65B0 "{name}" \u5230 v{version}',
+  "install.selectPrompt": "\u52FE\u9009\u8981\u5B89\u88C5 / \u91CD\u88C5\u7684\u6761\u76EE\uFF08\u9ED8\u8BA4\u52FE\u9009\u672A\u5B89\u88C5\u7684\uFF09",
+  "install.nothingSelected": "\u6CA1\u6709\u9009\u62E9\u4EFB\u4F55\u6761\u76EE\uFF0C\u5DF2\u9000\u51FA\u3002",
+  "install.confirmReinstall": '"{name}" \u5DF2\u5B89\u88C5\uFF0C\u662F\u5426\u91CD\u65B0\u5B89\u88C5\uFF08\u5148\u5378\u8F7D\u518D\u5B89\u88C5\uFF09\uFF1F',
+  "install.skippedReinstall": '\u5DF2\u8DF3\u8FC7 "{name}"\uFF08\u5DF2\u5B89\u88C5\uFF09\u3002',
+  "install.prereqFail": '"{name}" \u524D\u7F6E\u68C0\u67E5\u672A\u901A\u8FC7\uFF1A{reason}',
+  "install.starting": '\u5F00\u59CB\u5B89\u88C5 "{name}"',
+  "install.success": '"{name}" \u5B89\u88C5\u6210\u529F',
+  "install.failed": '"{name}" \u5B89\u88C5\u5931\u8D25',
+  "install.summaryTitle": "\u5B89\u88C5\u7ED3\u679C",
+  "install.summaryOk": "\u6210\u529F {count}",
+  "install.summaryFail": "\u5931\u8D25 {count}",
+  "install.summarySkip": "\u8DF3\u8FC7 {count}",
+  "uninstall.selectPrompt": "\u52FE\u9009\u8981\u5378\u8F7D\u7684\u6761\u76EE\uFF08\u4EC5\u663E\u793A\u5F53\u524D\u5DF2\u5B89\u88C5\u7684\uFF09",
+  "uninstall.noneInstalled": "\u5F53\u524D\u6CA1\u6709\u7531\u672C\u5DE5\u5177\u7BA1\u7406\u7684\u6761\u76EE\u5904\u4E8E\u5DF2\u5B89\u88C5\u72B6\u6001\u3002",
+  "uninstall.confirm": "\u5C06\u5378\u8F7D {count} \u9879\uFF0C\u786E\u5B9A\u5417\uFF1F",
+  "uninstall.starting": '\u5F00\u59CB\u5378\u8F7D "{name}"',
+  "uninstall.success": '"{name}" \u5378\u8F7D\u6210\u529F',
+  "uninstall.failed": '"{name}" \u5378\u8F7D\u5931\u8D25',
+  "update.selectPrompt": "\u52FE\u9009\u8981\u66F4\u65B0\u7684\u6761\u76EE",
+  "update.noneInstalled": "\u5F53\u524D\u6CA1\u6709\u53EF\u66F4\u65B0\u7684\u5DF2\u5B89\u88C5\u6761\u76EE\u3002",
+  "update.starting": '\u5F00\u59CB\u66F4\u65B0 "{name}"',
+  "update.success": '"{name}" \u66F4\u65B0\u6210\u529F',
+  "update.failed": '"{name}" \u66F4\u65B0\u5931\u8D25',
+  "update.mcpAutoNote": '"{name}" \u901A\u8FC7 npx -y \u542F\u52A8\uFF0C\u6BCF\u6B21\u8FD0\u884C\u81EA\u52A8\u62C9\u53D6\u6700\u65B0\u7248\u672C\uFF0C\u65E0\u9700\u624B\u52A8\u66F4\u65B0\u3002',
+  "update.context7Note": "context7 \u662F\u8FDC\u7AEF HTTP \u670D\u52A1\uFF0C\u7531\u670D\u52A1\u7AEF\u81EA\u52A8\u66F4\u65B0\uFF0C\u672C\u5730\u65E0\u9700\u64CD\u4F5C\u3002",
+  "status.title": "\u5F53\u524D\u72B6\u6001",
+  "status.headerName": "\u540D\u79F0",
+  "status.headerType": "\u7C7B\u578B",
+  "status.headerState": "\u72B6\u6001",
+  "context7.askKey": "\u662F\u5426\u586B\u5199 context7 API Key\uFF1F(\u56DE\u8F66\u8DF3\u8FC7\u5373\u7528\u514D\u8D39\u5C42)",
+  "context7.keyPlaceholder": "\u7C98\u8D34 API Key\uFF0C\u7559\u7A7A\u8DF3\u8FC7",
+  "context7.keyWarning": "\u6CE8\u610F\uFF1AAPI Key \u4F1A\u4EE5\u660E\u6587\u5199\u5165 ~/.claude.json\uFF0C\u8BF7\u59A5\u5584\u7BA1\u7406\u3002",
+  "context7.dashboardHint": "\u53EF\u5728 https://context7.com/dashboard \u521B\u5EFA API Key",
+  "chrome.prereqNode": "\u9700\u8981 Node.js >= 20.19\uFF0C\u5F53\u524D\u7248\u672C {current}",
+  "chrome.prereqChrome": "\u9700\u8981\u672C\u673A\u5DF2\u5B89\u88C5 Chrome\uFF08chrome-devtools-mcp \u4F1A\u8C03\u7528\u672C\u5730\u6D4F\u89C8\u5668\uFF09",
+  "reinstall.uninstalling": "\u5148\u5378\u8F7D\u65E7\u7248\u672C\u2026",
+  "reinstall.installing": "\u5B89\u88C5\u65B0\u7248\u672C\u2026"
+};
+var zh_default = messages;
+
+// src/i18n/en.ts
+var messages2 = {
+  "app.intro": "@curdx/flow \u2014 Claude Code plugin & MCP installer",
+  "app.outro": "Done.",
+  "app.cancelled": "Cancelled.",
+  "lang.prompt": "Please choose your language / \u8BF7\u9009\u62E9\u754C\u9762\u8BED\u8A00",
+  "lang.zh": "\u4E2D\u6587",
+  "lang.en": "English",
+  "menu.title": "What would you like to do?",
+  "menu.install": "Install / reinstall plugins & MCP servers",
+  "menu.update": "Update installed plugins",
+  "menu.uninstall": "Uninstall installed plugins & MCP servers",
+  "menu.status": "Show current install status",
+  "menu.exit": "Exit",
+  "pkg.installed": "installed",
+  "pkg.notInstalled": "not installed",
+  "pkg.unknown": "unknown",
+  "pkg.upToDateWithVersion": "installed v{version}",
+  "pkg.updateAvailable": "v{current} \u2192 v{latest} available",
+  "marketplace.refreshing": "Refreshing marketplace caches\u2026",
+  "marketplace.refreshed": "Refreshed {count} marketplace(s)",
+  "marketplace.refreshSkipped": "Marketplace caches are fresh, skipping refresh",
+  "install.updating": 'Updating "{name}" to v{version}',
+  "install.selectPrompt": "Select items to install / reinstall (not-installed are pre-selected)",
+  "install.nothingSelected": "Nothing selected. Exiting.",
+  "install.confirmReinstall": '"{name}" is already installed. Reinstall (uninstall then install)?',
+  "install.skippedReinstall": 'Skipped "{name}" (already installed).',
+  "install.prereqFail": 'Prerequisite failed for "{name}": {reason}',
+  "install.starting": 'Installing "{name}"',
+  "install.success": '"{name}" installed',
+  "install.failed": '"{name}" failed',
+  "install.summaryTitle": "Install summary",
+  "install.summaryOk": "{count} succeeded",
+  "install.summaryFail": "{count} failed",
+  "install.summarySkip": "{count} skipped",
+  "uninstall.selectPrompt": "Select items to uninstall (only currently installed shown)",
+  "uninstall.noneInstalled": "None of the managed items are currently installed.",
+  "uninstall.confirm": "About to uninstall {count} item(s). Proceed?",
+  "uninstall.starting": 'Uninstalling "{name}"',
+  "uninstall.success": '"{name}" uninstalled',
+  "uninstall.failed": '"{name}" failed to uninstall',
+  "update.selectPrompt": "Select items to update",
+  "update.noneInstalled": "No installed items available to update.",
+  "update.starting": 'Updating "{name}"',
+  "update.success": '"{name}" updated',
+  "update.failed": '"{name}" failed to update',
+  "update.mcpAutoNote": '"{name}" runs via npx -y and auto-pulls latest on every launch. No manual update needed.',
+  "update.context7Note": "context7 is a remote HTTP service, updated server-side. No local action needed.",
+  "status.title": "Current status",
+  "status.headerName": "Name",
+  "status.headerType": "Type",
+  "status.headerState": "State",
+  "context7.askKey": "Provide a context7 API key? (Enter to skip and use the free tier)",
+  "context7.keyPlaceholder": "Paste API key, or leave blank to skip",
+  "context7.keyWarning": "Note: the API key is written to ~/.claude.json in plaintext.",
+  "context7.dashboardHint": "Get a key at https://context7.com/dashboard",
+  "chrome.prereqNode": "Requires Node.js >= 20.19 (current: {current})",
+  "chrome.prereqChrome": "Requires Chrome installed locally (chrome-devtools-mcp drives the local browser)",
+  "reinstall.uninstalling": "Uninstalling old version\u2026",
+  "reinstall.installing": "Installing new version\u2026"
+};
+var en_default = messages2;
+
+// src/i18n/index.ts
+var tables = { zh: zh_default, en: en_default };
+var currentLang = "zh";
+function setLang(lang) {
+  currentLang = lang;
+}
+function t(key, vars) {
+  const raw = tables[currentLang][key] ?? tables.en[key] ?? key;
+  if (!vars) return raw;
+  return raw.replace(/\{(\w+)\}/g, (_, name) => {
+    const v = vars[name];
+    return v === void 0 ? `{${name}}` : String(v);
+  });
+}
+
+// src/ui/language.ts
+function detectLang() {
+  const env = process.env["LANG"] ?? process.env["LC_ALL"] ?? process.env["LC_MESSAGES"] ?? "";
+  return /^zh/i.test(env) ? "zh" : "en";
+}
+async function initLanguage(override) {
+  if (override) {
+    setLang(override);
+    return;
+  }
+  if (!process.stdin.isTTY) {
+    setLang(detectLang());
+    return;
+  }
+  const picked = await p.select({
+    message: t("lang.prompt"),
+    options: [
+      { value: "zh", label: "\u4E2D\u6587" },
+      { value: "en", label: "English" }
+    ],
+    initialValue: detectLang()
+  });
+  if (p.isCancel(picked)) {
+    setLang(detectLang());
+    process.exit(0);
+  }
+  setLang(picked);
+}
+
+// src/ui/menu.ts
+import * as p7 from "@clack/prompts";
+
+// src/flows/install.ts
+import * as p3 from "@clack/prompts";
+import pc from "picocolors";
+
+// src/runner/state.ts
+import { promises as fs } from "fs";
+import path from "path";
+import os from "os";
+
+// src/runner/exec.ts
+import { x } from "tinyexec";
+async function run(cmd, args) {
+  const proc = x(cmd, args, { throwOnError: false });
+  const result = await proc;
+  return {
+    exitCode: result.exitCode ?? 0,
+    stdout: result.stdout,
+    stderr: result.stderr
+  };
+}
+async function runStreaming(cmd, args, log4) {
+  log4.message(`$ ${cmd} ${args.join(" ")}`);
+  const proc = x(cmd, args, { throwOnError: false });
+  let stdout = "";
+  for await (const line of proc) {
+    const trimmed = line.replace(/\r?\n$/, "");
+    if (trimmed.length > 0) {
+      stdout += trimmed + "\n";
+      log4.message(trimmed);
+    }
+  }
+  const finished = await proc;
+  return {
+    exitCode: finished.exitCode ?? 0,
+    stdout,
+    stderr: finished.stderr
+  };
+}
+var CmdError = class extends Error {
+  constructor(message, result) {
+    super(message);
+    this.result = result;
+  }
+  result;
+};
+function ensureOk(result, label) {
+  if (result.exitCode !== 0) {
+    const detail = (result.stderr || result.stdout || "").trim().slice(0, 500);
+    throw new CmdError(`${label} (exit ${result.exitCode})${detail ? `
+${detail}` : ""}`, result);
+  }
+}
+
+// src/runner/state.ts
+var pluginCache = null;
+var marketplaceCache = null;
+var mcpCache = null;
+function clearStateCache() {
+  pluginCache = null;
+  marketplaceCache = null;
+  mcpCache = null;
+}
+async function listPlugins(force = false) {
+  if (!force && pluginCache) return pluginCache;
+  const res = await run("claude", ["plugin", "list", "--json"]);
+  if (res.exitCode !== 0) {
+    pluginCache = [];
+    return pluginCache;
+  }
+  try {
+    const arr = JSON.parse(res.stdout);
+    pluginCache = arr.map((p9) => {
+      const [name = p9.id, marketplace = ""] = p9.id.split("@");
+      return {
+        id: p9.id,
+        name,
+        marketplace,
+        version: p9.version,
+        scope: p9.scope,
+        enabled: p9.enabled
+      };
+    });
+  } catch {
+    pluginCache = [];
+  }
+  return pluginCache;
+}
+async function listMarketplaces(force = false) {
+  if (!force && marketplaceCache) return marketplaceCache;
+  const res = await run("claude", ["plugin", "marketplace", "list", "--json"]);
+  if (res.exitCode !== 0) {
+    marketplaceCache = [];
+    return marketplaceCache;
+  }
+  try {
+    marketplaceCache = JSON.parse(res.stdout);
+  } catch {
+    marketplaceCache = [];
+  }
+  return marketplaceCache;
+}
+async function listMcp(force = false) {
+  if (!force && mcpCache) return mcpCache;
+  const res = await run("claude", ["mcp", "list"]);
+  if (res.exitCode !== 0) {
+    mcpCache = [];
+    return mcpCache;
+  }
+  const entries = [];
+  for (const rawLine of res.stdout.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    if (line.startsWith("Checking ")) continue;
+    if (!line.includes(":")) continue;
+    if (line.startsWith("plugin:")) continue;
+    const colonIdx = line.indexOf(":");
+    const name = line.slice(0, colonIdx).trim();
+    if (!name || name.includes(" ")) continue;
+    entries.push({ name, raw: line });
+  }
+  mcpCache = entries;
+  return mcpCache;
+}
+async function isPluginInstalled(id) {
+  const list = await listPlugins();
+  return list.some((p9) => p9.id === id);
+}
+async function isMarketplaceAdded(name) {
+  const list = await listMarketplaces();
+  return list.some((m) => m.name === name);
+}
+async function isMcpInstalled(name) {
+  const list = await listMcp();
+  return list.some((m) => m.name === name);
+}
+async function findPlugin(id) {
+  const list = await listPlugins();
+  return list.find((p9) => p9.id === id);
+}
+var marketplaceJsonCache = /* @__PURE__ */ new Map();
+function marketplaceDir(name) {
+  return path.join(os.homedir(), ".claude", "plugins", "marketplaces", name);
+}
+async function readMarketplaceJson(name) {
+  if (marketplaceJsonCache.has(name)) return marketplaceJsonCache.get(name) ?? null;
+  const file = path.join(marketplaceDir(name), ".claude-plugin", "marketplace.json");
+  try {
+    const raw = await fs.readFile(file, "utf8");
+    const parsed = JSON.parse(raw);
+    marketplaceJsonCache.set(name, parsed);
+    return parsed;
+  } catch {
+    marketplaceJsonCache.set(name, null);
+    return null;
+  }
+}
+async function getMarketplacePluginVersion(marketplaceName, pluginName) {
+  const m = await readMarketplaceJson(marketplaceName);
+  if (!m?.plugins) return null;
+  const entry = m.plugins.find((p9) => p9.name === pluginName);
+  return entry?.version ?? null;
+}
+var REFRESH_TTL_MS = 60 * 60 * 1e3;
+async function shouldSkipRefresh(name) {
+  try {
+    const stat = await fs.stat(marketplaceDir(name));
+    return Date.now() - stat.mtimeMs < REFRESH_TTL_MS;
+  } catch {
+    return false;
+  }
+}
+async function refreshMarketplaces(names) {
+  const unique = [...new Set(names)];
+  const toRefresh = [];
+  for (const name of unique) {
+    if (!await shouldSkipRefresh(name)) toRefresh.push(name);
+  }
+  if (toRefresh.length === 0) return [];
+  await Promise.all(
+    toRefresh.map((name) => run("claude", ["plugin", "marketplace", "update", name]))
+  );
+  for (const name of toRefresh) marketplaceJsonCache.delete(name);
+  return toRefresh;
+}
+
+// src/registry/plugins/_helpers.ts
+async function ensureMarketplace(marketplaceName, marketplaceSource, ctx) {
+  if (await isMarketplaceAdded(marketplaceName)) return;
+  const r = await runStreaming("claude", ["plugin", "marketplace", "add", marketplaceSource], ctx.log);
+  ensureOk(r, `marketplace add ${marketplaceSource}`);
+  clearStateCache();
+}
+async function installPluginById(pluginId, ctx) {
+  const r = await runStreaming("claude", ["plugin", "install", pluginId], ctx.log);
+  ensureOk(r, `plugin install ${pluginId}`);
+  clearStateCache();
+}
+async function uninstallPluginById(pluginId, ctx) {
+  if (!await isPluginInstalled(pluginId)) return;
+  const r = await runStreaming("claude", ["plugin", "uninstall", pluginId], ctx.log);
+  ensureOk(r, `plugin uninstall ${pluginId}`);
+  clearStateCache();
+}
+async function updatePluginById(pluginId, ctx) {
+  const r = await runStreaming("claude", ["plugin", "update", pluginId], ctx.log);
+  ensureOk(r, `plugin update ${pluginId}`);
+  clearStateCache();
+}
+
+// src/registry/plugins/pua.ts
+var PLUGIN_ID = "pua@pua-skills";
+var PLUGIN_NAME = "pua";
+var MARKETPLACE_NAME = "pua-skills";
+var MARKETPLACE_SOURCE = "tanweai/pua";
+var pua = {
+  id: "pua",
+  name: "pua",
+  description: "tanweai/pua \u2014 Chinese Claude Code skills bundle",
+  type: "plugin",
+  marketplaces: () => [MARKETPLACE_NAME],
+  isInstalled: () => isPluginInstalled(PLUGIN_ID),
+  installedVersion: async () => {
+    const p9 = await findPlugin(PLUGIN_ID);
+    const v = p9?.version;
+    return v && v !== "unknown" ? v : null;
+  },
+  latestVersion: () => getMarketplacePluginVersion(MARKETPLACE_NAME, PLUGIN_NAME),
+  install: async (ctx) => {
+    await ensureMarketplace(MARKETPLACE_NAME, MARKETPLACE_SOURCE, ctx);
+    await installPluginById(PLUGIN_ID, ctx);
+  },
+  uninstall: (ctx) => uninstallPluginById(PLUGIN_ID, ctx),
+  update: (ctx) => updatePluginById(PLUGIN_ID, ctx)
+};
+var pua_default = pua;
+
+// src/registry/plugins/claude-mem.ts
+var PLUGIN_ID2 = "claude-mem@thedotmack";
+var PLUGIN_NAME2 = "claude-mem";
+var MARKETPLACE_NAME2 = "thedotmack";
+var MARKETPLACE_SOURCE2 = "thedotmack/claude-mem";
+var claudeMem = {
+  id: "claude-mem",
+  name: "claude-mem",
+  description: "thedotmack/claude-mem \u2014 persistent cross-session memory for Claude Code",
+  type: "plugin",
+  marketplaces: () => [MARKETPLACE_NAME2],
+  isInstalled: () => isPluginInstalled(PLUGIN_ID2),
+  installedVersion: async () => {
+    const p9 = await findPlugin(PLUGIN_ID2);
+    const v = p9?.version;
+    return v && v !== "unknown" ? v : null;
+  },
+  latestVersion: () => getMarketplacePluginVersion(MARKETPLACE_NAME2, PLUGIN_NAME2),
+  install: async (ctx) => {
+    await ensureMarketplace(MARKETPLACE_NAME2, MARKETPLACE_SOURCE2, ctx);
+    await installPluginById(PLUGIN_ID2, ctx);
+  },
+  uninstall: (ctx) => uninstallPluginById(PLUGIN_ID2, ctx),
+  update: (ctx) => updatePluginById(PLUGIN_ID2, ctx)
+};
+var claude_mem_default = claudeMem;
+
+// src/registry/plugins/chrome-devtools-mcp.ts
+var PLUGIN_ID3 = "chrome-devtools-mcp@chrome-devtools-plugins";
+var MARKETPLACE_NAME3 = "chrome-devtools-plugins";
+var MARKETPLACE_SOURCE3 = "ChromeDevTools/chrome-devtools-mcp";
+async function checkChrome() {
+  const macPath = "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome";
+  const [stat, viaPath, viaPathChromium] = await Promise.all([
+    run("test", ["-x", macPath]),
+    run("which", ["google-chrome"]),
+    run("which", ["chromium"])
+  ]);
+  return stat.exitCode === 0 || viaPath.exitCode === 0 || viaPathChromium.exitCode === 0;
+}
+var chromeDevtoolsMcp = {
+  id: "chrome-devtools-mcp",
+  name: "chrome-devtools-mcp",
+  description: "ChromeDevTools/chrome-devtools-mcp \u2014 drive a real Chrome from Claude Code",
+  type: "plugin",
+  prereqCheck: async (t2) => {
+    const major = Number(process.versions.node.split(".")[0] ?? "0");
+    const minor = Number(process.versions.node.split(".")[1] ?? "0");
+    if (major < 20 || major === 20 && minor < 19) {
+      return { ok: false, reason: t2("chrome.prereqNode", { current: process.versions.node }) };
+    }
+    if (!await checkChrome()) {
+      return { ok: false, reason: t2("chrome.prereqChrome") };
+    }
+    return { ok: true };
+  },
+  isInstalled: () => isPluginInstalled(PLUGIN_ID3),
+  install: async (ctx) => {
+    await ensureMarketplace(MARKETPLACE_NAME3, MARKETPLACE_SOURCE3, ctx);
+    await installPluginById(PLUGIN_ID3, ctx);
+  },
+  uninstall: (ctx) => uninstallPluginById(PLUGIN_ID3, ctx),
+  update: (ctx) => updatePluginById(PLUGIN_ID3, ctx)
+};
+var chrome_devtools_mcp_default = chromeDevtoolsMcp;
+
+// src/registry/plugins/frontend-design.ts
+var PLUGIN_ID4 = "frontend-design@claude-plugins-official";
+var frontendDesign = {
+  id: "frontend-design",
+  name: "frontend-design",
+  description: "Anthropic official \u2014 UI/frontend design helpers",
+  type: "plugin",
+  isInstalled: () => isPluginInstalled(PLUGIN_ID4),
+  install: (ctx) => installPluginById(PLUGIN_ID4, ctx),
+  uninstall: (ctx) => uninstallPluginById(PLUGIN_ID4, ctx),
+  update: (ctx) => updatePluginById(PLUGIN_ID4, ctx)
+};
+var frontend_design_default = frontendDesign;
+
+// src/registry/mcps/sequential-thinking.ts
+var MCP_NAME = "sequential-thinking";
+var sequentialThinking = {
+  id: "sequential-thinking",
+  name: "sequential-thinking",
+  description: "modelcontextprotocol/server-sequential-thinking \u2014 structured reasoning helper",
+  type: "mcp",
+  isInstalled: () => isMcpInstalled(MCP_NAME),
+  install: async (ctx) => {
+    const r = await runStreaming(
+      "claude",
+      [
+        "mcp",
+        "add",
+        "--scope",
+        "user",
+        MCP_NAME,
+        "--",
+        "npx",
+        "-y",
+        "@modelcontextprotocol/server-sequential-thinking"
+      ],
+      ctx.log
+    );
+    ensureOk(r, `mcp add ${MCP_NAME}`);
+    clearStateCache();
+  },
+  uninstall: async (ctx) => {
+    if (!await isMcpInstalled(MCP_NAME)) return;
+    const r = await runStreaming("claude", ["mcp", "remove", MCP_NAME], ctx.log);
+    ensureOk(r, `mcp remove ${MCP_NAME}`);
+    clearStateCache();
+  }
+  // For npx-based MCPs the latest version is fetched at every launch — nothing to do.
+  // Flow layer detects update?===noop and shows the i18n note instead.
+};
+var sequential_thinking_default = sequentialThinking;
+
+// src/registry/mcps/context7.ts
+import * as p2 from "@clack/prompts";
+var MCP_NAME2 = "context7";
+var URL = "https://mcp.context7.com/mcp";
+var context7 = {
+  id: "context7",
+  name: "context7",
+  description: "upstash/context7 \u2014 up-to-date docs from any library (HTTP MCP, optional API key)",
+  type: "mcp",
+  isInstalled: () => isMcpInstalled(MCP_NAME2),
+  configPrompts: async ({ t: t2 }) => {
+    p2.note(`${t2("context7.dashboardHint")}
+${t2("context7.keyWarning")}`, "context7");
+    const key = await p2.text({
+      message: t2("context7.askKey"),
+      placeholder: t2("context7.keyPlaceholder"),
+      defaultValue: ""
+    });
+    if (p2.isCancel(key)) return null;
+    const trimmed = String(key ?? "").trim();
+    const out = {};
+    if (trimmed) out["CONTEXT7_API_KEY"] = trimmed;
+    return out;
+  },
+  install: async (ctx) => {
+    const args = [
+      "mcp",
+      "add",
+      "--scope",
+      "user",
+      "--transport",
+      "http"
+    ];
+    const apiKey = ctx.config["CONTEXT7_API_KEY"];
+    if (apiKey) {
+      args.push("--header", `CONTEXT7_API_KEY: ${apiKey}`);
+    }
+    args.push(MCP_NAME2, URL);
+    const r = await runStreaming("claude", args, ctx.log);
+    ensureOk(r, `mcp add ${MCP_NAME2}`);
+    clearStateCache();
+  },
+  uninstall: async (ctx) => {
+    if (!await isMcpInstalled(MCP_NAME2)) return;
+    const r = await runStreaming("claude", ["mcp", "remove", MCP_NAME2], ctx.log);
+    ensureOk(r, `mcp remove ${MCP_NAME2}`);
+    clearStateCache();
+  }
+};
+var context7_default = context7;
+
+// src/registry/index.ts
+var PKGS = [
+  pua_default,
+  claude_mem_default,
+  chrome_devtools_mcp_default,
+  frontend_design_default,
+  sequential_thinking_default,
+  context7_default
+];
+function findPkg(id) {
+  return PKGS.find((p9) => p9.id === id);
+}
+
+// src/flows/install.ts
+async function deriveState(pkg) {
+  if (!await pkg.isInstalled()) return { kind: "not_installed" };
+  const [installed, latest] = await Promise.all([
+    pkg.installedVersion?.() ?? Promise.resolve(null),
+    pkg.latestVersion?.() ?? Promise.resolve(null)
+  ]);
+  if (installed && latest && installed !== latest) {
+    return { kind: "update_available", current: installed, latest };
+  }
+  return { kind: "up_to_date", version: installed };
+}
+function stateLabel(pkg, s) {
+  const head = `${pkg.name} ${pc.dim(`(${pkg.type})`)}`;
+  switch (s.kind) {
+    case "not_installed":
+      return `${head}  ${pc.yellow(`\u2717 ${t("pkg.notInstalled")}`)}`;
+    case "up_to_date":
+      return `${head}  ${pc.green(
+        s.version ? `\u2713 ${t("pkg.upToDateWithVersion", { version: s.version })}` : `\u2713 ${t("pkg.installed")}`
+      )}`;
+    case "update_available":
+      return `${head}  ${pc.cyan(
+        `\u2191 ${t("pkg.updateAvailable", { current: s.current, latest: s.latest })}`
+      )}`;
+  }
+}
+async function selectInteractive(states) {
+  const options = PKGS.map((pkg) => {
+    const s = states.get(pkg.id);
+    return { value: pkg.id, label: stateLabel(pkg, s), hint: pkg.description };
+  });
+  const initialValues = PKGS.filter((pkg) => {
+    const s = states.get(pkg.id);
+    return s.kind === "not_installed" || s.kind === "update_available";
+  }).map((pkg) => pkg.id);
+  const picked = await p3.multiselect({
+    message: t("install.selectPrompt"),
+    options,
+    initialValues,
+    required: false
+  });
+  if (p3.isCancel(picked)) return null;
+  return picked.map((id) => findPkg(id)).filter((x2) => Boolean(x2));
+}
+function selectFromIds(opts) {
+  if (opts.all) return [...PKGS];
+  if (!opts.ids || opts.ids.length === 0) return [];
+  const found = [];
+  for (const id of opts.ids) {
+    const pkg = findPkg(id);
+    if (pkg) found.push(pkg);
+    else p3.log.warn(`Unknown id: ${id}`);
+  }
+  return found;
+}
+async function runOne(pkg, state, opts) {
+  let mode;
+  if (state.kind === "not_installed") {
+    mode = "install";
+  } else if (state.kind === "update_available") {
+    mode = "update";
+  } else {
+    if (!opts.yes) {
+      const ans = await p3.confirm({
+        message: t("install.confirmReinstall", { name: pkg.name }),
+        initialValue: false
+      });
+      if (p3.isCancel(ans) || ans === false) {
+        return { id: pkg.id, status: "skip", message: t("install.skippedReinstall", { name: pkg.name }) };
+      }
+    }
+    mode = "reinstall";
+  }
+  if (pkg.prereqCheck) {
+    const r = await pkg.prereqCheck(t);
+    if (!r.ok) {
+      p3.log.warn(t("install.prereqFail", { name: pkg.name, reason: r.reason }));
+      return { id: pkg.id, status: "skip", message: r.reason };
+    }
+  }
+  let config = {};
+  if (pkg.configPrompts && mode !== "update") {
+    const cfg = await pkg.configPrompts({ t });
+    if (cfg === null) return { id: pkg.id, status: "skip", message: t("app.cancelled") };
+    config = cfg;
+  }
+  const titleKey = mode === "update" ? "install.updating" : "install.starting";
+  const titleVars = { name: pkg.name };
+  if (mode === "update" && state.kind === "update_available") {
+    titleVars["version"] = state.latest;
+  }
+  const log4 = p3.taskLog({ title: t(titleKey, titleVars) });
+  try {
+    if (mode === "reinstall") {
+      log4.message(t("reinstall.uninstalling"));
+      await pkg.uninstall({ log: log4, config, t });
+      log4.message(t("reinstall.installing"));
+      await pkg.install({ log: log4, config, t });
+    } else if (mode === "update") {
+      if (pkg.update) {
+        await pkg.update({ log: log4, config, t });
+      } else {
+        log4.message(t("reinstall.uninstalling"));
+        await pkg.uninstall({ log: log4, config, t });
+        log4.message(t("reinstall.installing"));
+        await pkg.install({ log: log4, config, t });
+      }
+    } else {
+      await pkg.install({ log: log4, config, t });
+    }
+    log4.success(t("install.success", { name: pkg.name }));
+    return { id: pkg.id, status: "ok" };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    log4.error(`${t("install.failed", { name: pkg.name })}
+${msg}`);
+    return { id: pkg.id, status: "fail", message: msg };
+  }
+}
+function summarize(results) {
+  const ok = results.filter((r) => r.status === "ok");
+  const fail = results.filter((r) => r.status === "fail");
+  const skip = results.filter((r) => r.status === "skip");
+  const lines = [
+    pc.green(t("install.summaryOk", { count: ok.length })),
+    pc.red(t("install.summaryFail", { count: fail.length })),
+    pc.yellow(t("install.summarySkip", { count: skip.length })),
+    "",
+    ...ok.map((r) => `  ${pc.green("\u2713")} ${r.id}`),
+    ...skip.map((r) => `  ${pc.yellow("-")} ${r.id}${r.message ? pc.dim(` (${r.message})`) : ""}`),
+    ...fail.map((r) => `  ${pc.red("\u2717")} ${r.id}${r.message ? pc.dim(` (${r.message.split("\n")[0]})`) : ""}`)
+  ];
+  p3.note(lines.join("\n"), t("install.summaryTitle"));
+}
+async function maybeRefreshMarketplaces(opts) {
+  if (opts.noRefresh) return;
+  const names = /* @__PURE__ */ new Set();
+  for (const pkg of PKGS) {
+    if (pkg.marketplaces) for (const n of pkg.marketplaces()) names.add(n);
+  }
+  if (names.size === 0) return;
+  const sp = p3.spinner();
+  sp.start(t("marketplace.refreshing"));
+  const refreshed = await refreshMarketplaces([...names]);
+  sp.stop(
+    refreshed.length > 0 ? t("marketplace.refreshed", { count: refreshed.length }) : t("marketplace.refreshSkipped")
+  );
+}
+async function installFlow(opts = {}) {
+  await maybeRefreshMarketplaces(opts);
+  const explicit = opts.all || opts.ids && opts.ids.length > 0;
+  const candidates = explicit ? selectFromIds(opts) : [...PKGS];
+  if (candidates.length === 0) {
+    p3.log.info(t("install.nothingSelected"));
+    return;
+  }
+  const stateMap = /* @__PURE__ */ new Map();
+  await Promise.all(
+    candidates.map(async (pkg) => {
+      stateMap.set(pkg.id, await deriveState(pkg));
+    })
+  );
+  let targets;
+  if (explicit) {
+    targets = candidates;
+  } else {
+    const picked = await selectInteractive(stateMap);
+    if (picked === null) {
+      p3.cancel(t("app.cancelled"));
+      return;
+    }
+    targets = picked;
+  }
+  if (targets.length === 0) {
+    p3.log.info(t("install.nothingSelected"));
+    return;
+  }
+  const results = [];
+  for (const pkg of targets) {
+    const state = stateMap.get(pkg.id) ?? { kind: "not_installed" };
+    results.push(await runOne(pkg, state, opts));
+  }
+  summarize(results);
+}
+
+// src/flows/uninstall.ts
+import * as p4 from "@clack/prompts";
+import pc2 from "picocolors";
+async function getInstalled() {
+  const states = await Promise.all(PKGS.map(async (pkg) => ({ pkg, installed: await pkg.isInstalled() })));
+  return states.filter((s) => s.installed).map((s) => s.pkg);
+}
+async function uninstallFlow(opts = {}) {
+  const installed = await getInstalled();
+  let targets;
+  if (opts.ids && opts.ids.length > 0) {
+    targets = [];
+    for (const id of opts.ids) {
+      const pkg = findPkg(id);
+      if (!pkg) {
+        p4.log.warn(`Unknown id: ${id}`);
+        continue;
+      }
+      if (!installed.some((x2) => x2.id === pkg.id)) {
+        p4.log.warn(`${pkg.name}: ${t("pkg.notInstalled")}`);
+        continue;
+      }
+      targets.push(pkg);
+    }
+  } else {
+    if (installed.length === 0) {
+      p4.log.info(t("uninstall.noneInstalled"));
+      return;
+    }
+    const picked = await p4.multiselect({
+      message: t("uninstall.selectPrompt"),
+      options: installed.map((pkg) => ({
+        value: pkg.id,
+        label: `${pkg.name} ${pc2.dim(`(${pkg.type})`)}`,
+        hint: pkg.description
+      })),
+      required: false
+    });
+    if (p4.isCancel(picked)) {
+      p4.cancel(t("app.cancelled"));
+      return;
+    }
+    targets = picked.map((id) => findPkg(id)).filter((x2) => Boolean(x2));
+  }
+  if (targets.length === 0) {
+    p4.log.info(t("install.nothingSelected"));
+    return;
+  }
+  if (!opts.yes) {
+    const ok2 = await p4.confirm({
+      message: t("uninstall.confirm", { count: targets.length }),
+      initialValue: false
+    });
+    if (p4.isCancel(ok2) || ok2 === false) {
+      p4.cancel(t("app.cancelled"));
+      return;
+    }
+  }
+  const results = [];
+  for (const pkg of targets) {
+    const log4 = p4.taskLog({ title: t("uninstall.starting", { name: pkg.name }) });
+    try {
+      await pkg.uninstall({ log: log4, config: {}, t });
+      log4.success(t("uninstall.success", { name: pkg.name }));
+      results.push({ id: pkg.id, status: "ok" });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      log4.error(`${t("uninstall.failed", { name: pkg.name })}
+${msg}`);
+      results.push({ id: pkg.id, status: "fail", message: msg });
+    }
+  }
+  const ok = results.filter((r) => r.status === "ok").length;
+  const fail = results.filter((r) => r.status === "fail").length;
+  p4.note(
+    [
+      pc2.green(t("install.summaryOk", { count: ok })),
+      pc2.red(t("install.summaryFail", { count: fail }))
+    ].join("\n"),
+    t("install.summaryTitle")
+  );
+}
+
+// src/flows/update.ts
+import * as p5 from "@clack/prompts";
+import pc3 from "picocolors";
+async function getInstalled2() {
+  const states = await Promise.all(PKGS.map(async (pkg) => ({ pkg, installed: await pkg.isInstalled() })));
+  return states.filter((s) => s.installed).map((s) => s.pkg);
+}
+async function updateFlow(opts = {}) {
+  const installed = await getInstalled2();
+  if (installed.length === 0) {
+    p5.log.info(t("update.noneInstalled"));
+    return;
+  }
+  let targets;
+  if (opts.all) {
+    targets = installed;
+  } else if (opts.ids && opts.ids.length > 0) {
+    targets = [];
+    for (const id of opts.ids) {
+      const pkg = findPkg(id);
+      if (!pkg) {
+        p5.log.warn(`Unknown id: ${id}`);
+        continue;
+      }
+      if (!installed.some((x2) => x2.id === pkg.id)) {
+        p5.log.warn(`${pkg.name}: ${t("pkg.notInstalled")}`);
+        continue;
+      }
+      targets.push(pkg);
+    }
+  } else {
+    const picked = await p5.multiselect({
+      message: t("update.selectPrompt"),
+      options: installed.map((pkg) => ({
+        value: pkg.id,
+        label: `${pkg.name} ${pc3.dim(`(${pkg.type})`)}`,
+        hint: pkg.description
+      })),
+      required: false
+    });
+    if (p5.isCancel(picked)) {
+      p5.cancel(t("app.cancelled"));
+      return;
+    }
+    targets = picked.map((id) => findPkg(id)).filter((x2) => Boolean(x2));
+  }
+  if (targets.length === 0) {
+    p5.log.info(t("install.nothingSelected"));
+    return;
+  }
+  const results = [];
+  for (const pkg of targets) {
+    if (pkg.id === "sequential-thinking") {
+      p5.log.info(t("update.mcpAutoNote", { name: pkg.name }));
+      results.push({ id: pkg.id, status: "noop" });
+      continue;
+    }
+    if (pkg.id === "context7") {
+      p5.log.info(t("update.context7Note"));
+      results.push({ id: pkg.id, status: "noop" });
+      continue;
+    }
+    const log4 = p5.taskLog({ title: t("update.starting", { name: pkg.name }) });
+    try {
+      if (pkg.update) {
+        await pkg.update({ log: log4, config: {}, t });
+      } else {
+        await pkg.uninstall({ log: log4, config: {}, t });
+        await pkg.install({ log: log4, config: {}, t });
+      }
+      log4.success(t("update.success", { name: pkg.name }));
+      results.push({ id: pkg.id, status: "ok" });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      log4.error(`${t("update.failed", { name: pkg.name })}
+${msg}`);
+      results.push({ id: pkg.id, status: "fail", message: msg });
+    }
+  }
+  const ok = results.filter((r) => r.status === "ok").length;
+  const fail = results.filter((r) => r.status === "fail").length;
+  const noop = results.filter((r) => r.status === "noop").length;
+  p5.note(
+    [
+      pc3.green(t("install.summaryOk", { count: ok })),
+      pc3.red(t("install.summaryFail", { count: fail })),
+      pc3.dim(`noop: ${noop}`)
+    ].join("\n"),
+    t("install.summaryTitle")
+  );
+}
+
+// src/flows/status.ts
+import * as p6 from "@clack/prompts";
+import pc4 from "picocolors";
+async function statusFlow(opts = {}) {
+  const states = await Promise.all(
+    PKGS.map(async (pkg) => {
+      const installed = await pkg.isInstalled();
+      const installedVersion = installed && pkg.installedVersion ? await pkg.installedVersion() : null;
+      const latestVersion = pkg.latestVersion ? await pkg.latestVersion() : null;
+      const updateAvailable = Boolean(
+        installed && installedVersion && latestVersion && installedVersion !== latestVersion
+      );
+      return {
+        id: pkg.id,
+        name: pkg.name,
+        type: pkg.type,
+        installed,
+        installedVersion,
+        latestVersion,
+        updateAvailable
+      };
+    })
+  );
+  if (opts.json) {
+    process.stdout.write(JSON.stringify(states, null, 2) + "\n");
+    return;
+  }
+  const nameW = Math.max(t("status.headerName").length, ...states.map((s) => s.name.length));
+  const typeW = Math.max(t("status.headerType").length, ...states.map((s) => s.type.length));
+  const header = `${t("status.headerName").padEnd(nameW)}  ${t("status.headerType").padEnd(typeW)}  ${t("status.headerState")}`;
+  const sep = `${"-".repeat(nameW)}  ${"-".repeat(typeW)}  ${"-".repeat(15)}`;
+  const rows = states.map(
+    (s) => `${s.name.padEnd(nameW)}  ${s.type.padEnd(typeW)}  ${s.installed ? pc4.green(`\u2713 ${t("pkg.installed")}`) : pc4.yellow(`\u2717 ${t("pkg.notInstalled")}`)}`
+  );
+  p6.note([header, sep, ...rows].join("\n"), t("status.title"));
+}
+
+// src/ui/menu.ts
+async function mainMenu() {
+  const action = await p7.select({
+    message: t("menu.title"),
+    options: [
+      { value: "install", label: t("menu.install") },
+      { value: "update", label: t("menu.update") },
+      { value: "uninstall", label: t("menu.uninstall") },
+      { value: "status", label: t("menu.status") },
+      { value: "exit", label: t("menu.exit") }
+    ]
+  });
+  if (p7.isCancel(action) || action === "exit") {
+    p7.cancel(t("app.cancelled"));
+    return;
+  }
+  switch (action) {
+    case "install":
+      await installFlow();
+      break;
+    case "update":
+      await updateFlow();
+      break;
+    case "uninstall":
+      await uninstallFlow();
+      break;
+    case "status":
+      await statusFlow();
+      break;
+  }
+}
+
+// src/index.ts
+function parseLang(v) {
+  return v === "zh" || v === "en" ? v : void 0;
+}
+var sharedArgs = {
+  lang: { type: "string", description: "Override language: zh or en" }
+};
+var installCmd = defineCommand({
+  meta: { name: "install", description: "Install, reinstall, or update plugins / MCP servers" },
+  args: {
+    ...sharedArgs,
+    all: { type: "boolean", description: "Install all known items" },
+    yes: { type: "boolean", description: "Skip reinstall confirmation (assume yes)" },
+    "no-refresh": { type: "boolean", description: "Skip refreshing marketplace caches" },
+    ids: { type: "positional", required: false, description: "Item ids", default: "" }
+  },
+  async run({ args }) {
+    await initLanguage(parseLang(args.lang));
+    p8.intro(t("app.intro"));
+    const ids = collectPositional(args);
+    await installFlow({
+      ids,
+      all: Boolean(args.all),
+      yes: Boolean(args.yes),
+      noRefresh: Boolean(args["no-refresh"])
+    });
+    p8.outro(t("app.outro"));
+  }
+});
+var uninstallCmd = defineCommand({
+  meta: { name: "uninstall", description: "Uninstall installed plugins / MCP servers" },
+  args: {
+    ...sharedArgs,
+    yes: { type: "boolean", description: "Skip confirmation" },
+    ids: { type: "positional", required: false, description: "Item ids", default: "" }
+  },
+  async run({ args }) {
+    await initLanguage(parseLang(args.lang));
+    p8.intro(t("app.intro"));
+    const ids = collectPositional(args);
+    await uninstallFlow({ ids, yes: Boolean(args.yes) });
+    p8.outro(t("app.outro"));
+  }
+});
+var updateCmd = defineCommand({
+  meta: { name: "update", description: "Update installed plugins" },
+  args: {
+    ...sharedArgs,
+    all: { type: "boolean", description: "Update all installed" },
+    ids: { type: "positional", required: false, description: "Item ids", default: "" }
+  },
+  async run({ args }) {
+    await initLanguage(parseLang(args.lang));
+    p8.intro(t("app.intro"));
+    const ids = collectPositional(args);
+    await updateFlow({ ids, all: Boolean(args.all) });
+    p8.outro(t("app.outro"));
+  }
+});
+var statusCmd = defineCommand({
+  meta: { name: "status", description: "Show install status" },
+  args: {
+    ...sharedArgs,
+    json: { type: "boolean", description: "Output JSON (machine-readable)" }
+  },
+  async run({ args }) {
+    await initLanguage(parseLang(args.lang));
+    if (!args.json) p8.intro(t("app.intro"));
+    await statusFlow({ json: Boolean(args.json) });
+    if (!args.json) p8.outro(t("app.outro"));
+  }
+});
+var SUBCOMMANDS = /* @__PURE__ */ new Set(["install", "uninstall", "update", "status"]);
+var root = defineCommand({
+  meta: {
+    name: "@curdx/flow",
+    version: "3.2.0",
+    description: "Interactive installer for Claude Code plugins and MCP servers"
+  },
+  args: sharedArgs,
+  subCommands: {
+    install: installCmd,
+    uninstall: uninstallCmd,
+    update: updateCmd,
+    status: statusCmd
+  }
+  // No root run() — citty 0.1.6 calls parent.run AFTER a matching subcommand,
+  // which would render the menu after a subcommand finishes. We dispatch the
+  // interactive menu ourselves below for the no-subcommand case.
+});
+function collectPositional(args) {
+  const ids = [];
+  const rest = args._;
+  if (Array.isArray(rest)) ids.push(...rest);
+  const single = args["ids"];
+  if (typeof single === "string" && single.length > 0) ids.unshift(single);
+  return ids;
+}
+function firstNonFlag(argv2) {
+  for (const a of argv2) {
+    if (!a.startsWith("-")) return a;
+  }
+  return void 0;
+}
+async function runInteractive(argv2) {
+  let lang;
+  for (let i = 0; i < argv2.length; i++) {
+    if (argv2[i] === "--lang" && argv2[i + 1]) lang = parseLang(argv2[i + 1]);
+    else if (argv2[i]?.startsWith("--lang=")) lang = parseLang(argv2[i].slice("--lang=".length));
+  }
+  await initLanguage(lang);
+  p8.intro(t("app.intro"));
+  await mainMenu();
+  p8.outro(t("app.outro"));
+}
+var argv = process.argv.slice(2);
+var first = firstNonFlag(argv);
+if (first === void 0 || first !== void 0 && !SUBCOMMANDS.has(first) && first !== "--help" && first !== "-h") {
+  if (first === void 0) {
+    runInteractive(argv).catch((err) => {
+      console.error(err);
+      process.exit(1);
+    });
+  } else {
+    runMain(root).catch((err) => {
+      console.error(err);
+      process.exit(1);
+    });
+  }
+} else {
+  runMain(root).catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
+}