@skylandnpm/octopus-proxy 0.1.0

package/dist/cli.js

@@ -0,0 +1,738 @@
+#!/usr/bin/env node
+import {
+  ConfigError,
+  SERVICE_LABEL,
+  SYSTEMD_UNIT,
+  TOOL_KINDS,
+  atomicJson,
+  daemonEntryPath,
+  defaultStateDirectory,
+  describeTool,
+  expandHome,
+  isMacOS,
+  launchdLogPath,
+  launchdPlistPath,
+  loadConfig,
+  resolveConfigPath,
+  runDaemon,
+  supportedPlatform,
+  systemdUnitPath
+} from "./chunk-TIHWE4WN.js";
+
+// src/cli.ts
+import { spawn } from "node:child_process";
+import { access as access3 } from "node:fs/promises";
+
+// src/doctor.ts
+import { access as access2, chmod, constants, mkdir as mkdir3, stat as stat2 } from "node:fs/promises";
+import { isAbsolute as isAbsolute2, join as join2 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { execFile as execFile4 } from "node:child_process";
+import { promisify as promisify4 } from "node:util";
+
+// src/service.ts
+import { readFile, access } from "node:fs/promises";
+import { dirname as dirname3, isAbsolute, resolve } from "node:path";
+
+// src/node-resolution.ts
+import { realpath, stat } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { join } from "node:path";
+import { homedir, platform } from "node:os";
+var run = promisify(execFile);
+var VERSION_MANAGED_SEGMENTS = /* @__PURE__ */ new Set([".nvm", "nvm", ".volta", "volta", ".fnm", "fnm", ".asdf", "asdf", ".mise", "mise"]);
+var execProbe = async (path) => {
+  try {
+    await run(path, ["--version"], { timeout: 5e3 });
+    return true;
+  } catch {
+    return false;
+  }
+};
+function isVersionManagedPath(path) {
+  return path.split("/").some((segment) => VERSION_MANAGED_SEGMENTS.has(segment));
+}
+function nodeCandidates() {
+  return platform() === "darwin" ? ["/opt/homebrew/bin/node", "/opt/homebrew/opt/node/bin/node", "/usr/local/bin/node", "/usr/bin/node"] : ["/usr/local/bin/node", "/usr/bin/node", "/snap/bin/node"];
+}
+async function resolveNodePath(options = {}) {
+  const probe = options.probe ?? execProbe;
+  if (options.pinned) {
+    if (!await probe(options.pinned)) throw new Error(`--node-path ${options.pinned} is not a working node executable`);
+    return { nodePath: options.pinned, source: "pinned" };
+  }
+  let exec = options.execPath ?? process.execPath;
+  try {
+    exec = await realpath(exec);
+  } catch {
+  }
+  if (!isVersionManagedPath(exec) && await probe(exec)) return { nodePath: exec, source: "exec" };
+  for (const candidate of nodeCandidates()) if (!isVersionManagedPath(candidate) && await probe(candidate)) return { nodePath: candidate, source: "candidate" };
+  if (await probe(exec)) return { nodePath: exec, source: "exec", warning: `only a version-manager node was found (${exec}); install node with the system package manager or pass --node-path, otherwise the service breaks when that node is upgraded` };
+  return { nodePath: null, source: "exec" };
+}
+function toolSearchDirs(kind) {
+  const dirs = [...describeTool(kind).searchDirs, join(homedir(), ".local", "bin"), join(homedir(), ".opencode", "bin"), join(homedir(), ".codex", "bin")];
+  return [...new Set(dirs)];
+}
+async function resolveCommandOnPath(name, extraDirs = []) {
+  const dirs = [...(process.env.PATH ?? "").split(":"), ...extraDirs].filter(Boolean);
+  for (const dir of new Set(dirs)) {
+    const full = join(dir, name);
+    try {
+      const info = await stat(full);
+      if (info.isFile() && info.mode & 73) return full;
+    } catch {
+    }
+  }
+  return null;
+}
+
+// src/launchd.ts
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { execFile as execFile2 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+import { userInfo } from "node:os";
+var run2 = promisify2(execFile2);
+var guiDomain = () => `gui/${userInfo().uid}`;
+function xml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function generatePlist(def) {
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+  <key>Label</key><string>${SERVICE_LABEL}</string>
+  <key>ProgramArguments</key><array><string>${xml(def.nodePath)}</string><string>${xml(def.entryPath)}</string></array>
+  <key>EnvironmentVariables</key><dict><key>OCTOPUS_PROXY_CONFIG</key><string>${xml(def.configPath)}</string><key>PATH</key><string>${xml(def.pathEnv)}</string></dict>
+  <key>AbandonProcessGroup</key><true/>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>StandardOutPath</key><string>${xml(launchdLogPath())}</string>
+  <key>StandardErrorPath</key><string>${xml(launchdLogPath())}</string>
+</dict></plist>
+`;
+}
+async function writePlistFile(xmlText) {
+  const path = launchdPlistPath();
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, xmlText, { mode: 420 });
+  return path;
+}
+async function ignoreMissing(action) {
+  try {
+    await action();
+  } catch {
+  }
+}
+async function launchdLoad() {
+  await ignoreMissing(() => run2("launchctl", ["bootout", `${guiDomain()}/${SERVICE_LABEL}`]));
+  await run2("launchctl", ["bootstrap", guiDomain(), launchdPlistPath()]);
+}
+async function launchdStart() {
+  await ignoreMissing(() => run2("launchctl", ["bootstrap", guiDomain(), launchdPlistPath()]));
+  await run2("launchctl", ["kickstart", `${guiDomain()}/${SERVICE_LABEL}`]);
+}
+async function launchdStop() {
+  await ignoreMissing(() => run2("launchctl", ["bootout", `${guiDomain()}/${SERVICE_LABEL}`]));
+}
+async function launchdRestart() {
+  await launchdLoad();
+}
+async function launchdUninstall() {
+  await launchdStop();
+  await rm(launchdPlistPath(), { force: true });
+}
+async function launchdStatus() {
+  try {
+    const { stdout: stdout2 } = await run2("launchctl", ["print", `${guiDomain()}/${SERVICE_LABEL}`]);
+    const running = /state = running/.test(stdout2);
+    const pid = Number(/pid = (\d+)/.exec(stdout2)?.[1]);
+    return { loaded: true, running, pid: Number.isFinite(pid) && pid > 0 ? pid : void 0 };
+  } catch {
+    return { loaded: false, running: false };
+  }
+}
+
+// src/systemd.ts
+import { mkdir as mkdir2, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname2 } from "node:path";
+import { execFile as execFile3 } from "node:child_process";
+import { promisify as promisify3 } from "node:util";
+var run3 = promisify3(execFile3);
+function quoteSystemdArg(value) {
+  const escaped = value.replaceAll("%", "%%").replaceAll('"', '\\"');
+  return /[\s"\\]/.test(value) ? `"${escaped}"` : escaped;
+}
+function generateUnit(def) {
+  return `[Unit]
+Description=Octopus host proxy
+After=network-online.target
+Wants=network-online.target
+StartLimitBurst=10
+StartLimitIntervalSec=300
+
+[Service]
+Type=simple
+WorkingDirectory=${quoteSystemdArg(dirname2(def.entryPath))}
+Environment=OCTOPUS_PROXY_CONFIG=${quoteSystemdArg(def.configPath)}
+ExecStart=${quoteSystemdArg(def.nodePath)} ${quoteSystemdArg(def.entryPath)}
+KillMode=process
+TimeoutStopSec=10
+Restart=on-failure
+RestartSec=5
+RestartPreventExitStatus=78
+UMask=0077
+NoNewPrivileges=true
+
+[Install]
+WantedBy=default.target
+`;
+}
+async function writeUnitFile(text) {
+  const path = systemdUnitPath();
+  await mkdir2(dirname2(path), { recursive: true });
+  await writeFile2(path, text, { mode: 420 });
+  return path;
+}
+async function systemctl(args) {
+  try {
+    const { stdout: stdout2 } = await run3("systemctl", ["--user", ...args]);
+    return stdout2;
+  } catch (error) {
+    const stderr = error instanceof Error ? error.stderr ?? error.message : String(error);
+    if (/Failed to connect to bus|D-Bus connection/i.test(String(stderr))) {
+      throw new Error(`systemctl --user ${args.join(" ")} failed: user session bus not reachable.
+On a headless host run:
+  export XDG_RUNTIME_DIR=/run/user/$(id -u)
+  sudo loginctl enable-linger $USER`);
+    }
+    throw new Error(`systemctl --user ${args.join(" ")} failed: ${String(stderr).trim()}`);
+  }
+}
+async function ignoreFailure(action) {
+  try {
+    return await action();
+  } catch {
+    return void 0;
+  }
+}
+async function systemdReload() {
+  await systemctl(["daemon-reload"]);
+}
+async function systemdInstall() {
+  await systemdReload();
+  await systemctl(["enable", SYSTEMD_UNIT]);
+  await systemctl(["restart", SYSTEMD_UNIT]);
+}
+async function systemdStart() {
+  await systemctl(["start", SYSTEMD_UNIT]);
+}
+async function systemdStop() {
+  await systemctl(["stop", SYSTEMD_UNIT]);
+}
+async function systemdRestart() {
+  await systemctl(["restart", SYSTEMD_UNIT]);
+}
+async function systemdUninstall() {
+  await ignoreFailure(() => systemctl(["disable", "--now", SYSTEMD_UNIT]));
+  await rm2(systemdUnitPath(), { force: true });
+  await systemdReload();
+}
+async function systemdStatus() {
+  const active = await ignoreFailure(() => systemctl(["is-active", SYSTEMD_UNIT]));
+  const enabled = await ignoreFailure(() => systemctl(["is-enabled", SYSTEMD_UNIT]));
+  return { active: active?.trim() === "active", enabled: enabled?.trim() === "enabled" };
+}
+
+// src/service.ts
+function serviceFilePath() {
+  return isMacOS() ? launchdPlistPath() : systemdUnitPath();
+}
+async function serviceFileExists() {
+  try {
+    await access(serviceFilePath());
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readServiceFile() {
+  return readFile(serviceFilePath(), "utf8").catch(() => null);
+}
+async function buildServiceDefinition(opts) {
+  const config = await loadConfig(opts.configPath);
+  const resolution = await resolveNodePath({ pinned: opts.nodePath });
+  if (!resolution.nodePath) throw new Error("\u672A\u627E\u5230\u53EF\u7528\u7684 node \u53EF\u6267\u884C\u6587\u4EF6\uFF1B\u8BF7\u7528\u7CFB\u7EDF\u5305\u7BA1\u7406\u5668\u5B89\u88C5 node\uFF0C\u6216\u901A\u8FC7 --node-path \u6307\u5B9A\u7EDD\u5BF9\u8DEF\u5F84");
+  const opencodeDir = isAbsolute(config.tool.command) ? [dirname3(config.tool.command)] : [];
+  const pathEnv = [dirname3(resolution.nodePath), ...opencodeDir, "/usr/local/bin", "/usr/bin", "/bin"].filter((dir, index, all) => all.indexOf(dir) === index).join(":");
+  return { def: { nodePath: resolution.nodePath, entryPath: daemonEntryPath(), configPath: resolve(opts.configPath), pathEnv }, warning: resolution.warning };
+}
+async function installService(opts) {
+  const { def, warning } = await buildServiceDefinition(opts);
+  const expected = isMacOS() ? generatePlist(def) : generateUnit(def);
+  const path = serviceFilePath();
+  const existing = await readServiceFile();
+  const changed = existing !== expected || opts.force === true;
+  if (isMacOS()) {
+    if (changed) {
+      await writePlistFile(expected);
+      await launchdLoad();
+    } else await launchdStart();
+  } else {
+    if (changed) {
+      await writeUnitFile(expected);
+      await systemdInstall();
+    } else await systemdStart();
+  }
+  return { serviceFile: path, changed, nodePath: def.nodePath, warning };
+}
+async function uninstallService() {
+  const path = serviceFilePath();
+  if (isMacOS()) await launchdUninstall();
+  else await systemdUninstall();
+  return path;
+}
+async function controlService(action) {
+  if (!await serviceFileExists()) throw new Error("\u670D\u52A1\u5C1A\u672A\u5B89\u88C5\uFF1B\u8BF7\u5148\u8FD0\u884C octopus-proxy install");
+  if (isMacOS()) {
+    if (action === "start") await launchdStart();
+    else if (action === "stop") await launchdStop();
+    else await launchdRestart();
+  } else {
+    if (action === "start") await systemdStart();
+    else if (action === "stop") await systemdStop();
+    else await systemdRestart();
+  }
+}
+async function serviceStatus() {
+  if (!await serviceFileExists()) return { installed: false, active: false };
+  if (isMacOS()) {
+    const state2 = await launchdStatus();
+    return { installed: true, active: state2.running, pid: state2.pid, serviceFile: launchdPlistPath() };
+  }
+  const state = await systemdStatus();
+  return { installed: true, active: state.active, enabled: state.enabled, serviceFile: systemdUnitPath() };
+}
+function logLocationHint() {
+  return isMacOS() ? launchdLogPath() : "journalctl --user -u octopus-proxy";
+}
+
+// src/doctor.ts
+var run4 = promisify4(execFile4);
+async function runDoctor(opts) {
+  const results = [];
+  const record = (name, status, detail) => results.push({ name, status, detail });
+  let config;
+  try {
+    const info = await stat2(opts.configPath).catch((error) => {
+      if (error.code === "ENOENT") throw new Error(`\u914D\u7F6E\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${opts.configPath}\uFF1B\u5148\u8FD0\u884C octopus-proxy onboard`);
+      throw error;
+    });
+    if ((info.mode & 63) !== 0) {
+      if (opts.fix) {
+        await chmod(opts.configPath, 384);
+        record("\u914D\u7F6E\u6743\u9650", "ok", `\u5DF2\u4FEE\u590D\u4E3A 600\uFF08${opts.configPath}\uFF09`);
+      } else record("\u914D\u7F6E\u6743\u9650", "warn", `${opts.configPath} \u6743\u9650\u8D85\u8FC7 600\uFF1B\u8FD0\u884C doctor --fix \u4FEE\u590D`);
+    } else record("\u914D\u7F6E\u6743\u9650", "ok");
+    config = await loadConfig(opts.configPath);
+    record("\u914D\u7F6E\u6821\u9A8C", "ok", opts.configPath);
+  } catch (error) {
+    record("\u914D\u7F6E\u6821\u9A8C", "fail", error instanceof Error ? error.message : String(error));
+  }
+  if (config) {
+    try {
+      await mkdir3(config.stateDirectory, { recursive: true, mode: 448 });
+      await access2(config.stateDirectory, constants.W_OK);
+      record("\u72B6\u6001\u76EE\u5F55", "ok", config.stateDirectory);
+    } catch (error) {
+      record("\u72B6\u6001\u76EE\u5F55", "fail", `\u65E0\u6CD5\u5199\u5165 ${config.stateDirectory}\uFF1A${error instanceof Error ? error.message : String(error)}`);
+    }
+    const descriptor = describeTool(config.tool.kind);
+    const checkName = `${descriptor.label} \u547D\u4EE4`;
+    const command2 = config.tool.command;
+    if (!isAbsolute2(command2)) {
+      record(checkName, "warn", `\u5F53\u524D\u4E3A\u300C${command2}\u300D\uFF0C\u4F9D\u8D56 PATH \u67E5\u627E\uFF1B\u670D\u52A1\u73AF\u5883\u5EFA\u8BAE\u6539\u7528\u7EDD\u5BF9\u8DEF\u5F84\uFF08\u91CD\u65B0\u8FD0\u884C onboard \u6216\u624B\u5DE5\u4FEE\u6539\u914D\u7F6E\uFF09`);
+    } else if (!await access2(command2, constants.X_OK).then(() => true, () => false)) {
+      record(checkName, "fail", `${command2} \u4E0D\u5B58\u5728\u6216\u4E0D\u53EF\u6267\u884C`);
+    } else {
+      try {
+        const { stdout: stdout2 } = await run4(command2, [...descriptor.versionArgs], { timeout: 15e3 });
+        const version = stdout2.trim().split("\n")[0].trim();
+        if (version === descriptor.baseline) record(checkName, "ok", `${command2}\uFF08${version}\uFF09`);
+        else if (descriptor.versionPolicy === "exact") record(checkName, "warn", `${command2} \u7248\u672C\u4E3A ${version}\uFF0C\u5DF2\u9A8C\u8BC1\u57FA\u7EBF\u662F ${descriptor.baseline}\uFF08\u4EE3\u7406\u4F1A\u62D2\u7EDD\u6258\u7BA1\u8BE5\u7248\u672C\uFF09`);
+        else record(checkName, "warn", `${command2} \u7248\u672C\u4E3A ${version}\uFF0C\u5DF2\u9A8C\u8BC1\u57FA\u7EBF\u662F ${descriptor.baseline}\uFF1Bapp-server \u534F\u8BAE\u53EF\u80FD\u6F02\u79FB`);
+      } catch (error) {
+        record(checkName, "warn", `\u6267\u884C ${command2} ${descriptor.versionArgs.join(" ")} \u5931\u8D25\uFF1A${error instanceof Error ? error.message : String(error)}`);
+      }
+      if (config.tool.kind === "codex") {
+        try {
+          await run4(command2, ["login", "status"], { timeout: 15e3 });
+        } catch {
+          record("Codex \u767B\u5F55", "warn", "codex login status \u672A\u901A\u8FC7\uFF1B\u65E0\u5934\u4E3B\u673A\u8BF7\u5148\u5B8C\u6210 codex \u767B\u5F55\uFF08--with-api-key \u6216\u590D\u5236 auth.json\uFF09");
+        }
+      }
+      if (config.tool.kind === "zcode") {
+        const credentials = join2(homedir2(), ".zcode", "v2", "credentials.json");
+        if (!await access2(credentials).then(() => true, () => false)) record("ZCode \u767B\u5F55", "warn", `\u672A\u627E\u5230 ${credentials}\uFF1B\u8BF7\u5148\u5728\u8BE5\u4E3B\u673A\u5B8C\u6210 zcode login`);
+      }
+    }
+  }
+  try {
+    await access2(daemonEntryPath(), constants.R_OK);
+    record("\u4EE3\u7406\u5165\u53E3", "ok", daemonEntryPath());
+  } catch {
+    record("\u4EE3\u7406\u5165\u53E3", "fail", `\u672A\u627E\u5230 ${daemonEntryPath()}\uFF1B\u8BF7\u91CD\u65B0\u5B89\u88C5 @skylandnpm/octopus-proxy\uFF08\u6E90\u7801\u6784\u5EFA\uFF1Apnpm --filter @skylandnpm/octopus-proxy build\uFF09`);
+  }
+  if (config) {
+    try {
+      const { def, warning } = await buildServiceDefinition({ configPath: opts.configPath });
+      if (warning) record("Node \u89E3\u6790", "warn", warning);
+      else record("Node \u89E3\u6790", "ok", def.nodePath);
+      if (isVersionManagedPath(def.nodePath)) record("Node \u8DEF\u5F84", "warn", `${def.nodePath} \u4F4D\u4E8E\u7248\u672C\u7BA1\u7406\u5668\u76EE\u5F55\uFF0C\u5347\u7EA7\u540E\u53EF\u80FD\u5931\u6548\uFF1B\u5EFA\u8BAE --node-path \u56FA\u5B9A\u4E3A\u7CFB\u7EDF node \u540E\u91CD\u65B0 install`);
+      const existing = await readServiceFile();
+      if (existing === null) record("\u670D\u52A1\u5B9A\u4E49", "warn", "\u5C1A\u672A\u5B89\u88C5\u670D\u52A1\uFF1B\u8FD0\u884C octopus-proxy install");
+      else {
+        const expected = isMacOS() ? generatePlist(def) : generateUnit(def);
+        if (existing === expected) record("\u670D\u52A1\u5B9A\u4E49", "ok");
+        else if (opts.fix) {
+          await installService({ ...opts, force: true });
+          record("\u670D\u52A1\u5B9A\u4E49", "ok", "\u5DF2\u6309\u5F53\u524D\u73AF\u5883\u91CD\u5199\u670D\u52A1\u5B9A\u4E49");
+        } else record("\u670D\u52A1\u5B9A\u4E49", "warn", "\u670D\u52A1\u5B9A\u4E49\u4E0E\u5F53\u524D\u73AF\u5883\u4E0D\u4E00\u81F4\uFF08node \u6216\u8DEF\u5F84\u53D8\u5316\uFF09\uFF1B\u8FD0\u884C doctor --fix \u6216 install --force \u66F4\u65B0");
+      }
+    } catch (error) {
+      record("\u670D\u52A1\u5B9A\u4E49", "fail", error instanceof Error ? error.message : String(error));
+    }
+  }
+  const state = await serviceStatus();
+  if (state.active) record("\u670D\u52A1\u72B6\u6001", "ok", `\u8FD0\u884C\u4E2D${state.pid ? `\uFF08pid ${state.pid}\uFF09` : ""}`);
+  else if (!state.installed) record("\u670D\u52A1\u72B6\u6001", "warn", "\u5C1A\u672A\u5B89\u88C5\u670D\u52A1");
+  else if (opts.fix) {
+    try {
+      await controlService("start");
+      record("\u670D\u52A1\u72B6\u6001", "ok", "\u5DF2\u542F\u52A8");
+    } catch (error) {
+      record("\u670D\u52A1\u72B6\u6001", "fail", `\u542F\u52A8\u5931\u8D25\uFF1A${error instanceof Error ? error.message : String(error)}\uFF1B\u53EF\u7528 octopus-proxy logs \u67E5\u770B\u65E5\u5FD7`);
+    }
+  } else record("\u670D\u52A1\u72B6\u6001", "warn", "\u672A\u5728\u8FD0\u884C\uFF1B\u8FD0\u884C octopus-proxy start \u6216 doctor --fix");
+  return results;
+}
+
+// src/onboard.ts
+import { createInterface } from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+import { mkdir as mkdir4, stat as stat3 } from "node:fs/promises";
+import { isAbsolute as isAbsolute3 } from "node:path";
+async function ask(rl, question, options = {}) {
+  for (; ; ) {
+    const suffix = options.default !== void 0 ? `\uFF08\u9ED8\u8BA4 ${options.default}\uFF09` : "";
+    const answer = (await rl.question(`${question}${suffix}: `)).trim();
+    const value = answer || options.default || "";
+    const problem = options.validate?.(value);
+    if (problem) {
+      console.log(`  ${problem}`);
+      continue;
+    }
+    return value;
+  }
+}
+function slug(name) {
+  return name.replaceAll(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
+}
+var validUrl = (value) => {
+  try {
+    const url = new URL(value);
+    return url.protocol === "https:" || url.hostname === "localhost" || url.hostname === "127.0.0.1" ? void 0 : "\u8FDC\u7A0B Hub \u5FC5\u987B\u4F7F\u7528 https";
+  } catch {
+    return "\u8BF7\u8F93\u5165\u5408\u6CD5 URL\uFF0C\u4F8B\u5982 https://hub.example.com";
+  }
+};
+var validId = (value) => /^[a-zA-Z0-9_-]+$/.test(value) ? void 0 : "\u4EC5\u9650\u5B57\u6BCD\u3001\u6570\u5B57\u3001\u4E0B\u5212\u7EBF\u548C\u8FDE\u5B57\u7B26";
+var validBotId = (value) => /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value) ? void 0 : "\u8BF7\u8F93\u5165\u673A\u5668\u4EBA UUID";
+async function runOnboard(opts) {
+  let hubUrl = opts.hubUrl ?? "", botId = opts.botId ?? "", secretKey = opts.secretKey ?? "", stateDirectory = opts.stateDirectory ?? defaultStateDirectory(), toolCommand = opts.toolCommand ?? "", toolKind = opts.toolKind ?? "opencode", mode = "managed";
+  let projects = opts.projects.map((project) => ({ ...project, directory: expandHome(project.directory) }));
+  if (opts.interactive) {
+    const rl = createInterface({ input: stdin, output: stdout });
+    console.log("Octopus Proxy \u521D\u59CB\u5316\u5411\u5BFC");
+    console.log(`\u914D\u7F6E\u5C06\u5199\u5165 ${opts.configPath}\uFF1B\u6587\u4EF6\u5305\u542B\u673A\u5668\u4EBA Secret\uFF0C\u4F1A\u4EE5 0600 \u6743\u9650\u4FDD\u5B58\u3002
+`);
+    hubUrl = await ask(rl, "Hub \u5730\u5740", { default: hubUrl || void 0, validate: validUrl });
+    botId = await ask(rl, "\u673A\u5668\u4EBA ID\uFF08\u5728 Claw \u6216 Taskhub \u4E2D\u521B\u5EFA\u5E76\u590D\u5236\uFF09", { validate: validBotId });
+    secretKey = await ask(rl, "\u673A\u5668\u4EBA Secret\uFF08\u5728 Claw \u6216 Taskhub \u521B\u5EFA\uFF1B\u8F93\u5165\u4F1A\u56DE\u663E\u5728\u7EC8\u7AEF\uFF09", { validate: (value) => value.length >= 20 ? void 0 : "\u8BF7\u8F93\u5165\u5B8C\u6574\u7684\u673A\u5668\u4EBA Secret" });
+    stateDirectory = expandHome(await ask(rl, "\u72B6\u6001\u76EE\u5F55", { default: stateDirectory, validate: (value) => isAbsolute3(expandHome(value)) ? void 0 : "\u5FC5\u987B\u662F\u7EDD\u5BF9\u8DEF\u5F84" }));
+    toolKind = await ask(rl, `\u7F16\u7801\u5DE5\u5177\uFF08${TOOL_KINDS.join("/")}\uFF09`, { default: toolKind, validate: (value) => TOOL_KINDS.includes(value) ? void 0 : `\u8F93\u5165 ${TOOL_KINDS.join(" \u6216 ")}` });
+    const descriptor = describeTool(toolKind);
+    const found = await resolveCommandOnPath(toolKind, toolSearchDirs(toolKind));
+    toolCommand = await ask(rl, found ? `${descriptor.label} \u547D\u4EE4\uFF08\u63A2\u6D4B\u5230 ${found}\uFF09` : `${descriptor.label} \u547D\u4EE4\uFF08\u672A\u5728 PATH \u4E2D\u63A2\u6D4B\u5230\uFF0C\u8BF7\u8F93\u5165\u7EDD\u5BF9\u8DEF\u5F84\uFF09`, { default: found ?? void 0, validate: (value) => isAbsolute3(expandHome(value)) ? void 0 : "\u670D\u52A1\u73AF\u5883\u9700\u8981\u7EDD\u5BF9\u8DEF\u5F84" });
+    if (toolKind === "opencode") mode = await ask(rl, "OpenCode \u6A21\u5F0F\uFF08managed=\u7531\u4EE3\u7406\u6258\u7BA1\u542F\u52A8\uFF0Cexternal=\u4EC5\u8FDE\u63A5\u5DF2\u6709\u670D\u52A1\uFF09", { default: "managed", validate: (value) => value === "managed" || value === "external" ? void 0 : "\u8F93\u5165 managed \u6216 external" });
+    console.log("\n\u5F55\u5165\u6388\u6743\u9879\u76EE\uFF08\u540D\u79F0\u7559\u7A7A\u7ED3\u675F\uFF09\uFF1A");
+    for (; ; ) {
+      const name = (await rl.question("  \u9879\u76EE\u540D\u79F0: ")).trim();
+      if (!name) break;
+      let directory = "";
+      for (; ; ) {
+        directory = expandHome(await ask(rl, `  \u300C${name}\u300D\u76EE\u5F55\uFF08\u7EDD\u5BF9\u8DEF\u5F84\uFF09`));
+        if (!isAbsolute3(directory)) {
+          console.log("  \u5FC5\u987B\u662F\u7EDD\u5BF9\u8DEF\u5F84");
+          continue;
+        }
+        if (!await stat3(directory).then(() => true, () => false)) {
+          console.log("  \u76EE\u5F55\u4E0D\u5B58\u5728");
+          continue;
+        }
+        break;
+      }
+      const id = await ask(rl, "  \u9879\u76EE ID", { default: slug(name), validate: validId });
+      projects.push({ id, name, directory });
+    }
+    rl.close();
+    if (!projects.length) throw new Error("\u81F3\u5C11\u9700\u8981\u5F55\u5165\u4E00\u4E2A\u6388\u6743\u9879\u76EE");
+    console.log("");
+  } else {
+    const missing = [];
+    if (!hubUrl) missing.push("--hub-url");
+    if (!botId) missing.push("--bot-id");
+    if (!secretKey) missing.push("--secret-key");
+    if (!projects.length) missing.push("--project");
+    if (missing.length) throw new Error(`\u975E\u4EA4\u4E92\u6A21\u5F0F\u7F3A\u5C11\u5FC5\u586B\u53C2\u6570\uFF1A${missing.join("\u3001")}`);
+    const urlProblem = validUrl(hubUrl);
+    if (urlProblem) throw new Error(`${urlProblem}\uFF08--hub-url\uFF09`);
+    if (validBotId(botId) || secretKey.length < 20) throw new Error("\u673A\u5668\u4EBA ID \u6216 Secret \u683C\u5F0F\u65E0\u6548");
+    projects = projects.map((project) => ({ ...project, id: project.id ?? slug(project.name) }));
+    const invalid = projects.find((project) => validId(project.id ?? "") !== void 0);
+    if (invalid) throw new Error(`\u9879\u76EE\u300C${invalid.name}\u300D\u65E0\u6CD5\u63A8\u5BFC\u51FA\u5408\u6CD5 ID\uFF08\u4EC5\u9650\u5B57\u6BCD\u3001\u6570\u5B57\u3001\u4E0B\u5212\u7EBF\u548C\u8FDE\u5B57\u7B26\uFF09\uFF0C\u8BF7\u8C03\u6574\u540D\u79F0\u6216\u624B\u5DE5\u6307\u5B9A ID`);
+    if (projects.some((project) => !isAbsolute3(project.directory))) throw new Error("--project \u7684\u76EE\u5F55\u5FC5\u987B\u662F\u7EDD\u5BF9\u8DEF\u5F84");
+    const descriptor = describeTool(toolKind);
+    toolCommand = toolCommand ? expandHome(toolCommand) : await resolveCommandOnPath(toolKind, toolSearchDirs(toolKind)) ?? descriptor.defaultCommand;
+    if (!isAbsolute3(toolCommand)) console.log(`\u63D0\u793A\uFF1A\u672A\u5728 PATH \u4E2D\u63A2\u6D4B\u5230 ${descriptor.label}\uFF0C\u914D\u7F6E\u4FDD\u7559\u547D\u4EE4\u540D\u300C${toolCommand}\u300D\uFF1B\u670D\u52A1\u73AF\u5883\u5EFA\u8BAE\u7EDD\u5BF9\u8DEF\u5F84\uFF08\u53EF\u7528 --tool-command \u6307\u5B9A\uFF09`);
+  }
+  if (await stat3(opts.configPath).then(() => true, () => false)) {
+    if (opts.interactive) {
+      const rl = createInterface({ input: stdin, output: stdout });
+      const answer = (await rl.question(`\u914D\u7F6E ${opts.configPath} \u5DF2\u5B58\u5728\uFF0C\u8986\u76D6\uFF1F(y/N): `)).trim();
+      rl.close();
+      if (!/^y(es)?$/i.test(answer)) {
+        console.log("\u5DF2\u53D6\u6D88\uFF0C\u672A\u5199\u5165\u4EFB\u4F55\u5185\u5BB9\u3002");
+        return;
+      }
+    } else throw new Error(`\u914D\u7F6E\u5DF2\u5B58\u5728\uFF1A${opts.configPath}\uFF1B\u975E\u4EA4\u4E92\u6A21\u5F0F\u62D2\u7EDD\u8986\u76D6\uFF0C\u8BF7\u5148\u79FB\u9664\u6216\u7528 --config \u6307\u5B9A\u65B0\u8DEF\u5F84`);
+  }
+  const loopbackHttp = hubUrl.startsWith("http://");
+  if (loopbackHttp) console.log("\u63D0\u793A\uFF1AHub \u4E3A http \u5730\u5740\uFF0C\u914D\u7F6E\u5C06\u5199\u5165 allowInsecureLocalhost: true\uFF08\u4EC5\u9650\u672C\u673A\u56DE\u73AF\u8054\u8C03\uFF09");
+  await atomicJson(opts.configPath, {
+    hubUrl,
+    botId,
+    secretKey,
+    stateDirectory,
+    ...loopbackHttp ? { allowInsecureLocalhost: true } : {},
+    projects: projects.map((project) => ({ id: project.id, name: project.name, directory: project.directory, specDirectories: ["specs", "docs"] })),
+    tool: { kind: toolKind, command: toolCommand || describeTool(toolKind).defaultCommand, ...toolKind === "opencode" ? { baseUrl: "http://127.0.0.1:4096", mode } : {}, autoStart: true }
+  });
+  await loadConfig(opts.configPath);
+  console.log(`\u5DF2\u5199\u5165\u914D\u7F6E\uFF1A${opts.configPath}\uFF080600\uFF09`);
+  stateDirectory = expandHome(stateDirectory);
+  await mkdir4(stateDirectory, { recursive: true, mode: 448 });
+  try {
+    const response = await fetch(hubUrl, { redirect: "manual", signal: AbortSignal.timeout(5e3) });
+    console.log(`Hub \u8FDE\u901A\u6027\uFF1AHTTP ${response.status}`);
+  } catch {
+    console.log("\u8B66\u544A\uFF1A\u6682\u65F6\u65E0\u6CD5\u8FDE\u63A5 Hub\uFF1B\u7A0D\u540E\u53EF\u7528 octopus-proxy doctor \u68C0\u67E5\u7F51\u7EDC\u4E0E\u8BC1\u4E66");
+  }
+  let install = opts.installServiceWanted ?? true;
+  if (opts.interactive && opts.installServiceWanted === void 0) {
+    const rl = createInterface({ input: stdin, output: stdout });
+    const answer = (await rl.question("\u73B0\u5728\u5B89\u88C5\u5E76\u542F\u52A8\u7CFB\u7EDF\u670D\u52A1\uFF1F(Y/n): ")).trim();
+    rl.close();
+    install = !/^(n|no)$/i.test(answer);
+  }
+  if (install) {
+    const outcome = await installService({ configPath: opts.configPath });
+    console.log(outcome.changed ? `\u5DF2\u5B89\u88C5\u5E76\u542F\u52A8\u7CFB\u7EDF\u670D\u52A1\uFF1A${outcome.serviceFile}` : `\u670D\u52A1\u5B9A\u4E49\u4E0E\u914D\u7F6E\u4E00\u81F4\uFF0C\u5DF2\u786E\u4FDD\u8FD0\u884C\uFF1A${outcome.serviceFile}`);
+    console.log(`node\uFF1A${outcome.nodePath}`);
+    if (outcome.warning) console.log(`\u6CE8\u610F\uFF1A${outcome.warning}`);
+    console.log(`\u65E5\u5FD7\uFF1A${logLocationHint()}\uFF08octopus-proxy logs \u67E5\u770B\uFF09`);
+  } else console.log("\u5DF2\u8DF3\u8FC7\u670D\u52A1\u5B89\u88C5\uFF1B\u4E4B\u540E\u53EF\u8FD0\u884C octopus-proxy install");
+}
+
+// src/cli.ts
+var USAGE = `octopus-proxy \u2014 Octopus \u4E3B\u673A\u4EE3\u7406
+
+\u7528\u6CD5: octopus-proxy <\u547D\u4EE4> [\u9009\u9879]
+
+\u547D\u4EE4:
+  onboard     \u4EA4\u4E92\u5F0F\u521D\u59CB\u5316\u914D\u7F6E\uFF0C\u5E76\u9ED8\u8BA4\u5B89\u88C5\u7CFB\u7EDF\u670D\u52A1
+  install     \u6821\u9A8C\u914D\u7F6E\u540E\u5B89\u88C5/\u66F4\u65B0\u7CFB\u7EDF\u670D\u52A1\uFF08\u5E42\u7B49\uFF0C\u81EA\u52A8\u542F\u52A8\uFF09
+  uninstall   \u505C\u6B62\u5E76\u79FB\u9664\u7CFB\u7EDF\u670D\u52A1\uFF08\u4FDD\u7559\u914D\u7F6E\u4E0E\u72B6\u6001\u6570\u636E\uFF09
+  start       \u542F\u52A8\u670D\u52A1
+  stop        \u505C\u6B62\u670D\u52A1
+  restart     \u91CD\u542F\u670D\u52A1
+  status      \u67E5\u770B\u670D\u52A1\u5B89\u88C5\u4E0E\u8FD0\u884C\u72B6\u6001
+  doctor      \u68C0\u67E5\u914D\u7F6E\u3001OpenCode\u3001node \u4E0E\u670D\u52A1\u5065\u5EB7\uFF08--fix \u81EA\u52A8\u4FEE\u590D\uFF09
+  run         \u524D\u53F0\u8FD0\u884C\u4EE3\u7406\uFF08\u8C03\u8BD5\u7528\uFF0CCtrl+C \u9000\u51FA\uFF09
+  logs        \u67E5\u770B\u670D\u52A1\u65E5\u5FD7\uFF08-f \u6301\u7EED\u8DDF\u968F\uFF09
+  help        \u663E\u793A\u672C\u5E2E\u52A9
+
+\u901A\u7528\u9009\u9879:
+  --config <path>      \u914D\u7F6E\u6587\u4EF6\u8DEF\u5F84\uFF08\u9ED8\u8BA4 $OCTOPUS_PROXY_CONFIG \u6216 ~/.config/octopus/proxy.json\uFF09
+
+onboard \u9009\u9879:
+  --non-interactive        \u975E\u4EA4\u4E92\u6A21\u5F0F\uFF1B\u9700\u63D0\u4F9B Hub \u5730\u5740\u3001\u673A\u5668\u4EBA ID\u3001Secret \u548C\u9879\u76EE
+  --hub-url <url>          Hub \u5730\u5740\uFF08https\uFF09
+  --bot-id <uuid>          Claw \u6216 Taskhub \u4E2D\u521B\u5EFA\u7684\u673A\u5668\u4EBA ID
+  --secret-key <key>       \u673A\u5668\u4EBA Secret\uFF08\u5728 Claw \u6216 Taskhub \u521B\u5EFA\uFF09
+  --state-dir <path>       \u72B6\u6001\u76EE\u5F55\uFF08\u9ED8\u8BA4 ~/.local/state/octopus\uFF09
+  --project <name=path>    \u6388\u6743\u9879\u76EE\uFF0C\u53EF\u91CD\u590D\u591A\u6B21
+  --tool <kind>            \u7F16\u7801\u5DE5\u5177\uFF1Aopencode\uFF08\u9ED8\u8BA4\uFF09\u3001codex\u3001zcode \u6216 pi
+  --tool-command <p>       \u7F16\u7801\u5DE5\u5177\u53EF\u6267\u884C\u6587\u4EF6\u7EDD\u5BF9\u8DEF\u5F84
+  --no-install-service     \u53EA\u5199\u914D\u7F6E\uFF0C\u4E0D\u5B89\u88C5\u670D\u52A1
+
+install \u9009\u9879:
+  --force            \u91CD\u5199\u670D\u52A1\u5B9A\u4E49\u5E76\u91CD\u542F\uFF08\u914D\u7F6E\u6216\u8DEF\u5F84\u53D8\u5316\u540E\u4F7F\u7528\uFF09
+  --node-path <p>    \u56FA\u5B9A\u670D\u52A1\u4F7F\u7528\u7684 node \u7EDD\u5BF9\u8DEF\u5F84
+
+doctor / logs \u9009\u9879:
+  --fix              \u81EA\u52A8\u4FEE\u590D\uFF08\u914D\u7F6E\u6743\u9650\u3001\u670D\u52A1\u5B9A\u4E49\u3001\u542F\u52A8\u670D\u52A1\uFF09
+  -f, --follow       \u6301\u7EED\u8F93\u51FA\u65E5\u5FD7
+
+\u9000\u51FA\u7801: 0 \u6210\u529F\uFF1B1 \u4E00\u822C\u9519\u8BEF\uFF1B78 \u914D\u7F6E\u65E0\u6548\uFF08\u670D\u52A1\u5355\u5143\u5DF2\u914D\u7F6E\u4E0D\u56E0\u6B64\u91CD\u542F\uFF09`;
+var VALUE_FLAGS = /* @__PURE__ */ new Set(["--config", "--node-path", "--hub-url", "--bot-id", "--secret-key", "--state-dir", "--tool", "--tool-command", "--opencode-command", "--project"]);
+function parse(argv) {
+  const flags2 = {}, projectArgs2 = [];
+  let command2;
+  for (let i = 0; i < argv.length; ) {
+    const arg = argv[i++];
+    if (arg === "-h" || arg === "--help") {
+      flags2["--help"] = "true";
+      continue;
+    }
+    if (arg === "-f") {
+      flags2["--follow"] = "true";
+      continue;
+    }
+    if (!arg.startsWith("--")) {
+      if (command2 === void 0) command2 = arg;
+      else throw new Error(`\u65E0\u6CD5\u8BC6\u522B\u7684\u53C2\u6570\uFF1A${arg}`);
+      continue;
+    }
+    const equals = arg.indexOf("=");
+    const name = equals === -1 ? arg : arg.slice(0, equals);
+    let value = equals === -1 ? void 0 : arg.slice(equals + 1);
+    if (value === void 0 && VALUE_FLAGS.has(name) && i < argv.length && !argv[i].startsWith("--")) value = argv[i++];
+    if (VALUE_FLAGS.has(name) && value === void 0) throw new Error(`\u9009\u9879 ${name} \u7F3A\u5C11\u503C`);
+    if (!VALUE_FLAGS.has(name) && value !== void 0) throw new Error(`\u9009\u9879 ${name} \u4E0D\u63A5\u53D7\u503C`);
+    if (name === "--project") {
+      projectArgs2.push(value);
+      continue;
+    }
+    flags2[name] = value ?? "true";
+  }
+  return { command: command2, flags: flags2, projectArgs: projectArgs2 };
+}
+async function showLogs(follow) {
+  const child = isMacOS() ? spawn("tail", ["-n", "200", ...follow ? ["-F"] : [], launchdLogPath()], { stdio: "inherit" }) : spawn("journalctl", ["--user", "-u", SYSTEMD_UNIT, "-n", "200", ...follow ? ["-f"] : ["--no-pager"]], { stdio: "inherit" });
+  if (isMacOS() && !await access3(launchdLogPath()).then(() => true, () => false)) {
+    console.error(`\u65E5\u5FD7\u6587\u4EF6\u5C1A\u672A\u751F\u6210\uFF1A${launchdLogPath()}`);
+    process.exit(1);
+  }
+  child.on("error", (error) => {
+    console.error(`\u65E0\u6CD5\u67E5\u770B\u65E5\u5FD7\uFF1A${error.message}\uFF08${logLocationHint()}\uFF09`);
+    process.exit(1);
+  });
+  for (const signal of ["SIGINT", "SIGTERM"]) process.on(signal, () => child.kill(signal));
+  const code = await new Promise((resolve2) => child.on("exit", (code2) => resolve2(code2 ?? 0)));
+  process.exit(code);
+}
+var { command, flags, projectArgs } = parse(process.argv.slice(2));
+if (!command || command === "help" || flags["--help"]) {
+  console.log(USAGE);
+  process.exit(command || flags["--help"] ? 0 : 1);
+}
+if (!supportedPlatform()) {
+  console.error("octopus-proxy \u4EC5\u652F\u6301 macOS \u4E0E Linux");
+  process.exit(1);
+}
+var configPath = resolveConfigPath(flags["--config"]);
+try {
+  switch (command) {
+    case "onboard": {
+      await runOnboard({
+        interactive: flags["--non-interactive"] !== "true",
+        configPath,
+        hubUrl: flags["--hub-url"],
+        botId: flags["--bot-id"],
+        secretKey: flags["--secret-key"],
+        stateDirectory: flags["--state-dir"],
+        projects: projectArgs.map((entry) => {
+          const equals = entry.indexOf("=");
+          if (equals === -1) throw new Error(`--project \u9700\u8981 name=path \u5F62\u5F0F\uFF1A${entry}`);
+          return { name: entry.slice(0, equals), directory: entry.slice(equals + 1) };
+        }),
+        toolKind: flags["--tool"],
+        toolCommand: flags["--tool-command"] ?? flags["--opencode-command"],
+        installServiceWanted: flags["--no-install-service"] === "true" ? false : void 0
+      });
+      break;
+    }
+    case "install": {
+      const outcome = await installService({ configPath, nodePath: flags["--node-path"], force: flags["--force"] === "true" });
+      console.log(outcome.changed ? `\u5DF2\u5B89\u88C5\u5E76\u542F\u52A8\u670D\u52A1\uFF1A${outcome.serviceFile}` : `\u670D\u52A1\u5B9A\u4E49\u4E0E\u914D\u7F6E\u4E00\u81F4\uFF0C\u5DF2\u786E\u4FDD\u8FD0\u884C\uFF1A${outcome.serviceFile}`);
+      console.log(`node\uFF1A${outcome.nodePath}`);
+      if (outcome.warning) console.log(`\u6CE8\u610F\uFF1A${outcome.warning}`);
+      console.log(`\u65E5\u5FD7\uFF1A${logLocationHint()}\uFF08octopus-proxy logs \u67E5\u770B\uFF09`);
+      break;
+    }
+    case "uninstall": {
+      const path = await uninstallService();
+      console.log(`\u5DF2\u505C\u6B62\u5E76\u79FB\u9664\u7CFB\u7EDF\u670D\u52A1\uFF08${path}\uFF09\uFF1B\u914D\u7F6E\u4E0E\u72B6\u6001\u6570\u636E\u5DF2\u4FDD\u7559`);
+      break;
+    }
+    case "start":
+    case "stop":
+    case "restart": {
+      await controlService(command);
+      console.log(`\u5DF2${command === "start" ? "\u542F\u52A8" : command === "stop" ? "\u505C\u6B62" : "\u91CD\u542F"}\u670D\u52A1`);
+      break;
+    }
+    case "status": {
+      const state = await serviceStatus();
+      if (!state.installed) console.log("\u5C1A\u672A\u5B89\u88C5\u670D\u52A1\uFF1B\u8FD0\u884C octopus-proxy install\uFF08\u6216\u5148 onboard \u751F\u6210\u914D\u7F6E\uFF09");
+      else console.log([
+        `\u670D\u52A1\uFF1A\u5DF2\u5B89\u88C5\uFF08${state.serviceFile}\uFF09`,
+        `\u72B6\u6001\uFF1A${state.active ? `\u8FD0\u884C\u4E2D${state.pid ? `\uFF08pid ${state.pid}\uFF09` : ""}` : "\u672A\u8FD0\u884C"}`,
+        state.enabled === void 0 ? "" : `\u5F00\u673A\u81EA\u542F\uFF1A${state.enabled ? "\u5DF2\u542F\u7528" : "\u672A\u542F\u7528"}`,
+        `\u914D\u7F6E\uFF1A${configPath}`,
+        `\u65E5\u5FD7\uFF1A${logLocationHint()}`
+      ].filter(Boolean).join("\n"));
+      break;
+    }
+    case "doctor": {
+      const results = await runDoctor({ configPath, fix: flags["--fix"] === "true" });
+      for (const result of results) console.log(`${result.status === "ok" ? "[OK]  " : result.status === "warn" ? "[\u8B66\u544A]" : "[\u5931\u8D25]"} ${result.name}${result.detail ? ` \u2014 ${result.detail}` : ""}`);
+      if (results.some((result) => result.status === "fail")) {
+        console.log("\u5B58\u5728\u5931\u8D25\u9879\uFF1B\u6839\u636E\u63D0\u793A\u5904\u7406\u540E\u91CD\u8BD5 octopus-proxy doctor");
+        process.exit(1);
+      }
+      break;
+    }
+    case "run":
+      await runDaemon(configPath);
+      break;
+    case "logs":
+      await showLogs(flags["--follow"] === "true");
+      break;
+    default:
+      console.error(`\u672A\u77E5\u547D\u4EE4\uFF1A${command}`);
+      console.log(USAGE);
+      process.exit(1);
+  }
+} catch (error) {
+  if (error instanceof ConfigError) {
+    console.error(error.message);
+    process.exit(78);
+  }
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+}