claude-codex-wechat 0.1.4 → 0.1.6

package/README.md

@@ -189,6 +189,38 @@ claude-codex-wechat start
 - 这是前台进程
 - npm 本身不负责守护
 - 长期常驻建议交给进程管理器
+- 如果默认端口已被本程序的后台服务占用，`start` 会先停掉后台服务，再以前台模式启动
+- 如果端口被别的进程占用，`start` 会直接报出占用 PID 和命令，不会强杀陌生进程
+
+### 安装后后台运行
+
+参考 `happier` 的方式，这个仓库现在提供 `service` 命令，把当前 CLI 注册成操作系统服务，而不是在 Node 进程里自己 daemonize。
+
+常用命令：
+
+```bash
+claude-codex-wechat service install
+claude-codex-wechat service start
+claude-codex-wechat service restart
+claude-codex-wechat service status
+claude-codex-wechat service logs
+claude-codex-wechat service tail
+claude-codex-wechat service stop
+claude-codex-wechat service uninstall
+```
+
+当前支持：
+
+- macOS：`launchd`（`~/Library/LaunchAgents/`）
+- Linux：`systemd --user`（`~/.config/systemd/user/`）
+
+推荐安装后直接这样：
+
+```bash
+claude-codex-wechat init
+claude-codex-wechat service install
+claude-codex-wechat service status
+```
 
 ### pm2
 
@@ -315,6 +347,7 @@ HTTPS_PROXY=http://127.0.0.1:7890 HTTP_PROXY=http://127.0.0.1:7890 ./release.sh
 
 这个脚本会：
 
+- 先检查 `npm whoami`
 - 先执行 `pnpm typecheck`
 - 再执行 `pnpm build`
 - 提交当前改动

package/dist/server/cli.js

@@ -2,8 +2,8 @@
 import { createRequire as __cjsCreateRequire } from 'node:module'; const require = __cjsCreateRequire(import.meta.url);
 
 // src/cli.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "node:fs";
-import { dirname as dirname10, join as join10 } from "node:path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "node:fs";
+import { dirname as dirname11, join as join11 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/daemon/bootstrap.ts
@@ -3989,6 +3989,27 @@ async function resolveProviderCommands(providers) {
   };
 }
 
+// src/daemon/portGuard.ts
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+async function findListeningProcess(port) {
+  if (process.platform === "win32") return null;
+  try {
+    const { stdout } = await execFileAsync("lsof", ["-n", "-P", `-iTCP:${port}`, "-sTCP:LISTEN"]);
+    const lines = stdout.trim().split(/\r?\n/).filter(Boolean);
+    const record = lines.slice(1)[0];
+    if (!record) return null;
+    const parts = record.trim().split(/\s+/);
+    const command = parts[0] ?? "";
+    const pid = Number(parts[1] ?? "");
+    if (!command || !Number.isFinite(pid)) return null;
+    return { pid, command };
+  } catch {
+    return null;
+  }
+}
+
 // src/daemon/staticFrontend.ts
 import { readFileSync as readFileSync6 } from "node:fs";
 import { join as join9 } from "node:path";
@@ -4010,9 +4031,318 @@ function attachStaticFrontend(webRoot2) {
   };
 }
 
+// src/daemon/service.ts
+import { existsSync as existsSync8, statSync } from "node:fs";
+import { mkdir as mkdir4, readFile as readFile6, rm as rm2, writeFile as writeFile5 } from "node:fs/promises";
+import { homedir as homedir7 } from "node:os";
+import { dirname as dirname10, join as join10 } from "node:path";
+import { createReadStream } from "node:fs";
+import { execFile as execFile2, spawn as spawn6 } from "node:child_process";
+import { createInterface } from "node:readline";
+import { promisify as promisify2 } from "node:util";
+var execFileAsync2 = promisify2(execFile2);
+async function installService(context) {
+  if (process.platform === "darwin") {
+    const spec = buildLaunchdSpec(context);
+    await mkdir4(dirname10(spec.plistPath), { recursive: true });
+    await mkdir4(dirname10(spec.stdoutPath), { recursive: true });
+    await writeFile5(spec.plistPath, renderLaunchdPlist(spec), "utf8");
+    await runLaunchctl(["unload", spec.plistPath]).catch(() => void 0);
+    await runLaunchctl(["load", spec.plistPath]);
+    await runLaunchctl(["kickstart", "-k", `gui/${process.getuid?.() ?? 0}/${spec.label}`]);
+    return await readServiceStatus(context);
+  }
+  if (process.platform === "linux") {
+    const spec = buildSystemdUserSpec(context);
+    await mkdir4(dirname10(spec.unitPath), { recursive: true });
+    await mkdir4(dirname10(spec.stdoutPath), { recursive: true });
+    await writeFile5(spec.unitPath, renderSystemdUnit(spec), "utf8");
+    await runSystemctl(["--user", "daemon-reload"]);
+    await runSystemctl(["--user", "enable", "--now", spec.unitName]);
+    return await readServiceStatus(context);
+  }
+  throw new Error("service_install_not_supported_on_this_platform");
+}
+async function startService(context) {
+  if (process.platform === "darwin") {
+    const spec = buildLaunchdSpec(context);
+    await ensureFileExists(spec.plistPath, "service_not_installed");
+    await runLaunchctl(["load", spec.plistPath]).catch(() => void 0);
+    await runLaunchctl(["kickstart", "-k", `gui/${process.getuid?.() ?? 0}/${spec.label}`]);
+    return await readServiceStatus(context);
+  }
+  if (process.platform === "linux") {
+    const spec = buildSystemdUserSpec(context);
+    await ensureFileExists(spec.unitPath, "service_not_installed");
+    await runSystemctl(["--user", "start", spec.unitName]);
+    return await readServiceStatus(context);
+  }
+  throw new Error("service_start_not_supported_on_this_platform");
+}
+async function stopService(context) {
+  if (process.platform === "darwin") {
+    const spec = buildLaunchdSpec(context);
+    if (!existsSync8(spec.plistPath)) return await readServiceStatus(context);
+    await runLaunchctl(["bootout", `gui/${process.getuid?.() ?? 0}`, spec.plistPath]).catch(() => void 0);
+    return await readServiceStatus(context);
+  }
+  if (process.platform === "linux") {
+    const spec = buildSystemdUserSpec(context);
+    if (!existsSync8(spec.unitPath)) return await readServiceStatus(context);
+    await runSystemctl(["--user", "stop", spec.unitName]).catch(() => void 0);
+    return await readServiceStatus(context);
+  }
+  throw new Error("service_stop_not_supported_on_this_platform");
+}
+async function uninstallService(context) {
+  if (process.platform === "darwin") {
+    const spec = buildLaunchdSpec(context);
+    if (existsSync8(spec.plistPath)) {
+      await runLaunchctl(["bootout", `gui/${process.getuid?.() ?? 0}`, spec.plistPath]).catch(() => void 0);
+      await rm2(spec.plistPath, { force: true });
+    }
+    return await readServiceStatus(context);
+  }
+  if (process.platform === "linux") {
+    const spec = buildSystemdUserSpec(context);
+    if (existsSync8(spec.unitPath)) {
+      await runSystemctl(["--user", "disable", "--now", spec.unitName]).catch(() => void 0);
+      await rm2(spec.unitPath, { force: true });
+      await runSystemctl(["--user", "daemon-reload"]).catch(() => void 0);
+    }
+    return await readServiceStatus(context);
+  }
+  throw new Error("service_uninstall_not_supported_on_this_platform");
+}
+async function restartService(context) {
+  if (process.platform === "darwin") {
+    const spec = buildLaunchdSpec(context);
+    await ensureFileExists(spec.plistPath, "service_not_installed");
+    await runLaunchctl(["kickstart", "-k", `gui/${process.getuid?.() ?? 0}/${spec.label}`]);
+    return await readServiceStatus(context);
+  }
+  if (process.platform === "linux") {
+    const spec = buildSystemdUserSpec(context);
+    await ensureFileExists(spec.unitPath, "service_not_installed");
+    await runSystemctl(["--user", "restart", spec.unitName]);
+    return await readServiceStatus(context);
+  }
+  throw new Error("service_restart_not_supported_on_this_platform");
+}
+async function readServiceLogs(context, lines = 120) {
+  const status = await readServiceStatus(context);
+  const stdoutTail = await tailFile(status.stdoutPath, lines);
+  const stderrTail = await tailFile(status.stderrPath, lines);
+  return [
+    `[stdout] ${status.stdoutPath}`,
+    stdoutTail || "(empty)",
+    "",
+    `[stderr] ${status.stderrPath}`,
+    stderrTail || "(empty)"
+  ].join("\n");
+}
+async function tailServiceLogs(context) {
+  const status = await readServiceStatus(context);
+  await tailFiles([status.stdoutPath, status.stderrPath]);
+}
+async function readServiceStatus(context) {
+  if (process.platform === "darwin") {
+    const spec = buildLaunchdSpec(context);
+    const installed = existsSync8(spec.plistPath);
+    const running = installed ? await runLaunchctl(["print", `gui/${process.getuid?.() ?? 0}/${spec.label}`]).then(() => true, () => false) : false;
+    return {
+      manager: "launchd",
+      installed,
+      running,
+      serviceFilePath: spec.plistPath,
+      label: spec.label,
+      stdoutPath: spec.stdoutPath,
+      stderrPath: spec.stderrPath
+    };
+  }
+  if (process.platform === "linux") {
+    const spec = buildSystemdUserSpec(context);
+    const installed = existsSync8(spec.unitPath);
+    const running = installed ? await runSystemctl(["--user", "is-active", "--quiet", spec.unitName]).then(() => true, () => false) : false;
+    return {
+      manager: "systemd-user",
+      installed,
+      running,
+      serviceFilePath: spec.unitPath,
+      label: spec.unitName,
+      stdoutPath: spec.stdoutPath,
+      stderrPath: spec.stderrPath
+    };
+  }
+  throw new Error("service_status_not_supported_on_this_platform");
+}
+function buildLaunchdSpec(context) {
+  const stateDir = join10(homedir7(), ".claude-codex-wechat");
+  return {
+    label: "com.claude-codex-wechat",
+    plistPath: join10(homedir7(), "Library", "LaunchAgents", "com.claude-codex-wechat.plist"),
+    programArgs: [context.nodePath ?? process.execPath, context.cliEntrypointPath, "start"],
+    workingDirectory: homedir7(),
+    stdoutPath: join10(stateDir, "logs", "service.stdout.log"),
+    stderrPath: join10(stateDir, "logs", "service.stderr.log"),
+    environment: buildServiceEnvironment(context)
+  };
+}
+function buildSystemdUserSpec(context) {
+  const stateDir = join10(homedir7(), ".claude-codex-wechat");
+  return {
+    unitName: "claude-codex-wechat.service",
+    unitPath: join10(homedir7(), ".config", "systemd", "user", "claude-codex-wechat.service"),
+    execStart: [context.nodePath ?? process.execPath, context.cliEntrypointPath, "start"],
+    workingDirectory: homedir7(),
+    stdoutPath: join10(stateDir, "logs", "service.stdout.log"),
+    stderrPath: join10(stateDir, "logs", "service.stderr.log"),
+    environment: buildServiceEnvironment(context)
+  };
+}
+function buildServiceEnvironment(context) {
+  const env = {
+    PATH: process.env.PATH ?? "",
+    HOME: process.env.HOME ?? homedir7()
+  };
+  const configPath = context.configPath ?? process.env.BRIDGE_CONFIG;
+  const port = context.port ?? Number(process.env.BRIDGE_PORT ?? 8787);
+  if (configPath) env.BRIDGE_CONFIG = configPath;
+  if (Number.isFinite(port)) env.BRIDGE_PORT = String(port);
+  for (const key of [
+    "BRIDGE_WECHAT_ENABLED",
+    "BRIDGE_WECHAT_BASE_URL",
+    "BRIDGE_WECHAT_TOKEN",
+    "BRIDGE_WECHAT_ACCOUNT_ID",
+    "BRIDGE_CLAUDE_COMMAND",
+    "BRIDGE_CODEX_COMMAND",
+    "HTTP_PROXY",
+    "HTTPS_PROXY",
+    "http_proxy",
+    "https_proxy"
+  ]) {
+    const value = process.env[key];
+    if (value) env[key] = value;
+  }
+  return env;
+}
+function renderLaunchdPlist(spec) {
+  const programArgs = spec.programArgs.map((arg) => `    <string>${escapeXml(arg)}</string>`).join("\n");
+  const envEntries = Object.entries(spec.environment).map(([key, value]) => `    <key>${escapeXml(key)}</key>
+    <string>${escapeXml(value)}</string>`).join("\n");
+  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>${escapeXml(spec.label)}</string>`,
+    "  <key>ProgramArguments</key>",
+    "  <array>",
+    programArgs,
+    "  </array>",
+    "  <key>WorkingDirectory</key>",
+    `  <string>${escapeXml(spec.workingDirectory)}</string>`,
+    "  <key>EnvironmentVariables</key>",
+    "  <dict>",
+    envEntries,
+    "  </dict>",
+    "  <key>RunAtLoad</key>",
+    "  <true/>",
+    "  <key>KeepAlive</key>",
+    "  <true/>",
+    "  <key>StandardOutPath</key>",
+    `  <string>${escapeXml(spec.stdoutPath)}</string>`,
+    "  <key>StandardErrorPath</key>",
+    `  <string>${escapeXml(spec.stderrPath)}</string>`,
+    "</dict>",
+    "</plist>",
+    ""
+  ].join("\n");
+}
+function renderSystemdUnit(spec) {
+  const envEntries = Object.entries(spec.environment).map(([key, value]) => `Environment=${quoteSystemdEnv(`${key}=${value}`)}`).join("\n");
+  return [
+    "[Unit]",
+    "Description=claude-codex-wechat bridge daemon",
+    "After=network.target",
+    "",
+    "[Service]",
+    "Type=simple",
+    `WorkingDirectory=${spec.workingDirectory}`,
+    `ExecStart=${spec.execStart.map(quoteSystemdArg).join(" ")}`,
+    envEntries,
+    `StandardOutput=append:${spec.stdoutPath}`,
+    `StandardError=append:${spec.stderrPath}`,
+    "Restart=on-failure",
+    "RestartSec=5",
+    "",
+    "[Install]",
+    "WantedBy=default.target",
+    ""
+  ].join("\n");
+}
+function escapeXml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+function quoteSystemdArg(value) {
+  return `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+}
+function quoteSystemdEnv(value) {
+  return `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+}
+async function runLaunchctl(args) {
+  await execFileAsync2("launchctl", args);
+}
+async function runSystemctl(args) {
+  await execFileAsync2("systemctl", args);
+}
+async function ensureFileExists(path, errorCode) {
+  if (!existsSync8(path)) throw new Error(errorCode);
+  await readFile6(path, "utf8");
+}
+async function tailFile(path, lines) {
+  if (!existsSync8(path)) return "";
+  const content = await readFile6(path, "utf8");
+  return content.split(/\r?\n/).slice(-lines).join("\n").trim();
+}
+async function tailFiles(paths) {
+  const readers = paths.filter((path) => existsSync8(path)).map((path) => {
+    const rl = createInterface({
+      input: createReadStream(path, { encoding: "utf8", start: Math.max(0, fileSizeHint(path) - 8192) }),
+      crlfDelay: Infinity
+    });
+    rl.on("line", (line) => {
+      process.stdout.write(`[${path}] ${line}
+`);
+    });
+    return rl;
+  });
+  if (process.platform !== "linux" && process.platform !== "darwin") {
+    return;
+  }
+  const child = spawn6("tail", ["-f", ...paths.filter((path) => existsSync8(path))], { stdio: ["ignore", "pipe", "inherit"] });
+  child.stdout.on("data", (chunk) => {
+    process.stdout.write(String(chunk));
+  });
+  await new Promise((resolve, reject) => {
+    child.on("exit", () => resolve());
+    child.on("error", reject);
+  }).finally(() => {
+    for (const reader of readers) reader.close();
+  });
+}
+function fileSizeHint(path) {
+  try {
+    return statSync(path).size;
+  } catch {
+    return 0;
+  }
+}
+
 // src/cli.ts
-var here = dirname10(fileURLToPath(import.meta.url));
-var webRoot = join10(here, "..", "web");
+var here = dirname11(fileURLToPath(import.meta.url));
+var webRoot = join11(here, "..", "web");
 async function main() {
   const command = process.argv[2];
   switch (command) {
@@ -4026,6 +4356,9 @@ async function main() {
     case "doctor":
       await cmdDoctor();
       return;
+    case "service":
+      await cmdService(process.argv.slice(3));
+      return;
     case "print-config":
       cmdPrintConfig();
       return;
@@ -4042,21 +4375,36 @@ async function main() {
   }
 }
 async function cmdStart() {
-  if (!existsSync8(webRoot)) {
+  if (!existsSync9(webRoot)) {
     console.error(`\u627E\u4E0D\u5230\u524D\u7AEF\u6784\u5EFA\u4EA7\u7269: ${webRoot}`);
     console.error("\u8BF7\u5148\u8FD0\u884C\u6784\u5EFA (pnpm build) \u540E\u518D\u542F\u52A8\uFF0C\u6216\u91CD\u65B0\u5B89\u88C5\u5B8C\u6574\u7684 npm \u5305\u3002");
     process.exitCode = 1;
     return;
   }
+  const context = createServiceContext();
+  const port = context.port ?? 8787;
+  const occupiedBy = await findListeningProcess(port);
+  if (occupiedBy) {
+    const serviceStatus = await readServiceStatus(context).catch(() => null);
+    if (serviceStatus?.installed && serviceStatus.running) {
+      console.log(`\u7AEF\u53E3 ${port} \u5DF2\u88AB\u540E\u53F0\u670D\u52A1\u5360\u7528\uFF0C\u5148\u505C\u6B62\u670D\u52A1\u518D\u4EE5\u524D\u53F0\u6A21\u5F0F\u542F\u52A8\u3002`);
+      await stopService(context);
+    } else {
+      console.error(`\u7AEF\u53E3 ${port} \u5DF2\u88AB\u5360\u7528: PID=${occupiedBy.pid} COMMAND=${occupiedBy.command}`);
+      console.error("\u8BF7\u5148\u505C\u6B62\u5360\u7528\u8FDB\u7A0B\uFF0C\u6216\u6539\u7528 `claude-codex-wechat service stop` \u505C\u6389\u540E\u53F0\u670D\u52A1\u3002");
+      process.exitCode = 1;
+      return;
+    }
+  }
   await startDaemon({
     attachFrontend: attachStaticFrontend(webRoot)
   });
 }
 function cmdInit() {
   const configPath = process.env.BRIDGE_CONFIG ?? defaultConfigPath();
-  const dir = dirname10(configPath);
+  const dir = dirname11(configPath);
   mkdirSync6(dir, { recursive: true });
-  if (existsSync8(configPath)) {
+  if (existsSync9(configPath)) {
     console.log(`\u914D\u7F6E\u5DF2\u5B58\u5728\uFF0C\u672A\u8986\u76D6: ${configPath}`);
     return;
   }
@@ -4081,13 +4429,13 @@ function cmdInit() {
 async function cmdDoctor() {
   const configPath = process.env.BRIDGE_CONFIG ?? defaultConfigPath();
   console.log("claude-codex-wechat doctor\n");
-  report("\u914D\u7F6E\u6587\u4EF6", existsSync8(configPath) ? configPath : `\u7F3A\u5931 (${configPath})\uFF0C\u8FD0\u884C init \u521B\u5EFA`);
-  report("\u524D\u7AEF\u4EA7\u7269", existsSync8(webRoot) ? webRoot : `\u7F3A\u5931 (${webRoot})`);
+  report("\u914D\u7F6E\u6587\u4EF6", existsSync9(configPath) ? configPath : `\u7F3A\u5931 (${configPath})\uFF0C\u8FD0\u884C init \u521B\u5EFA`);
+  report("\u524D\u7AEF\u4EA7\u7269", existsSync9(webRoot) ? webRoot : `\u7F3A\u5931 (${webRoot})`);
   const claude = await findExecutable("claude");
   report("claude \u53EF\u6267\u884C", claude ?? "\u672A\u627E\u5230\uFF0C\u9700\u5148\u5B89\u88C5\u5E76\u767B\u5F55 Claude Code");
   const codex = await findExecutable("codex");
   report("codex \u53EF\u6267\u884C", codex ?? "\u672A\u627E\u5230\uFF08\u4EC5\u4F7F\u7528 Claude \u65F6\u53EF\u5FFD\u7565\uFF09");
-  if (existsSync8(configPath)) {
+  if (existsSync9(configPath)) {
     const config = loadBridgeConfig(configPath);
     const wechat = config.wechat;
     report("\u5FAE\u4FE1\u542F\u7528", wechat?.enabled ? "\u662F" : "\u5426");
@@ -4097,16 +4445,84 @@ async function cmdDoctor() {
 }
 function cmdPrintConfig() {
   const configPath = process.env.BRIDGE_CONFIG ?? defaultConfigPath();
-  if (!existsSync8(configPath)) {
+  if (!existsSync9(configPath)) {
     console.error(`\u914D\u7F6E\u4E0D\u5B58\u5728: ${configPath}\uFF08\u8FD0\u884C init \u521B\u5EFA\uFF09`);
     process.exitCode = 1;
     return;
   }
   console.log(readFileSync7(configPath, "utf8"));
 }
+async function cmdService(args) {
+  const action = args[0] ?? "status";
+  const context = createServiceContext();
+  switch (action) {
+    case "install": {
+      const status = await installService(context);
+      printServiceStatus("service installed", status);
+      return;
+    }
+    case "start": {
+      const status = await startService(context);
+      printServiceStatus("service started", status);
+      return;
+    }
+    case "stop": {
+      const status = await stopService(context);
+      printServiceStatus("service stopped", status);
+      return;
+    }
+    case "restart": {
+      const status = await restartService(context);
+      printServiceStatus("service restarted", status);
+      return;
+    }
+    case "logs": {
+      console.log(await readServiceLogs(context));
+      return;
+    }
+    case "tail": {
+      await tailServiceLogs(context);
+      return;
+    }
+    case "uninstall": {
+      const status = await uninstallService(context);
+      printServiceStatus("service uninstalled", status);
+      return;
+    }
+    case "status": {
+      const status = await readServiceStatus(context);
+      printServiceStatus("service status", status);
+      return;
+    }
+    default:
+      console.error(`\u672A\u77E5 service \u5B50\u547D\u4EE4: ${action}
+`);
+      printUsage();
+      process.exitCode = 1;
+  }
+}
+function createServiceContext() {
+  return {
+    cliEntrypointPath: fileURLToPath(import.meta.url),
+    nodePath: process.execPath,
+    configPath: process.env.BRIDGE_CONFIG ?? defaultConfigPath(),
+    port: Number(process.env.BRIDGE_PORT ?? 8787)
+  };
+}
 function report(label, value) {
   console.log(`  ${label.padEnd(14)}: ${value}`);
 }
+function printServiceStatus(title, status) {
+  console.log(`claude-codex-wechat ${title}
+`);
+  report("service manager", status.manager);
+  report("installed", status.installed ? "yes" : "no");
+  report("running", status.running ? "yes" : "no");
+  report("label", status.label);
+  report("service file", status.serviceFilePath);
+  report("stdout log", status.stdoutPath);
+  report("stderr log", status.stderrPath);
+}
 function printUsage() {
   console.log(`claude-codex-wechat \u2014 \u672C\u5730 WeChat \u2194 Claude/Codex bridge daemon
 
@@ -4117,6 +4533,7 @@ function printUsage() {
   start          \u542F\u52A8 daemon\uFF08\u9ED8\u8BA4\u547D\u4EE4\uFF0C\u524D\u53F0\u8FD0\u884C\uFF09
   init           \u5728 ~/.claude-codex-wechat/ \u521B\u5EFA\u9ED8\u8BA4\u914D\u7F6E
   doctor         \u68C0\u67E5\u914D\u7F6E\u3001\u524D\u7AEF\u4EA7\u7269\u4E0E claude/codex \u53EF\u6267\u884C\u6587\u4EF6
+  service        \u7BA1\u7406\u540E\u53F0\u670D\u52A1\uFF08install/start/stop/restart/status/logs/tail/uninstall\uFF09
   print-config   \u6253\u5370\u5F53\u524D\u914D\u7F6E\u6587\u4EF6\u5185\u5BB9
   help           \u663E\u793A\u672C\u5E2E\u52A9
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-codex-wechat",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "private": false,
   "type": "module",
   "bin": {