chatccc 0.2.228 → 0.2.230

package/src/index.ts

@@ -28,19 +28,20 @@ import { WSClient, EventDispatcher, Domain } from "@larksuiteoapi/node-sdk";
 import WebSocket from "ws";
 
 import { appendStartupTrace, attachRelayWebSocket, ensureSingleInstance, freeRelayListenPort, installCrashLogging, waitForPortFree } from "./shared.ts";
-import { createUiRouter, setExtraApiHandler, setReloadConfigHook, startSetupMode } from "./web-ui.ts";
-import {
-  buildWebUiUrl,
-  createServiceLifecycleGuard,
-  openWebUiInDefaultBrowser,
-  shouldAutoOpenWebUi,
-} from "./startup-lifecycle.ts";
+import { createUiRouter, setExtraApiHandler, setReloadConfigHook, startSetupMode } from "./web-ui.ts";
+import {
+  buildWebUiUrl,
+  createServiceLifecycleGuard,
+  INTERNAL_RESTART_ENV_VAR,
+  openWebUiInDefaultBrowser,
+  shouldAutoOpenWebUi,
+} from "./startup-lifecycle.ts";
 import { buildPlatformStartupPlan } from "./platform-startup.ts";
 import { makeTraceId, logTrace } from "./trace.ts";
 import {
-  CHATCCC_PORT,
-  config,
-  APP_ID,
+  CHATCCC_PORT,
+  config,
+  APP_ID,
   APP_SECRET,
   FEISHU_ENABLED,
   FEISHU_PLATFORM_TYPE,
@@ -96,9 +97,9 @@ import {
   sendCardKitMessage,
   updateCardKitCard,
 } from "./cardkit.ts";
-import {
-  loadSessionRegistryForBinding,
-  rebuildBindingsFromRegistry,
+import {
+  loadSessionRegistryForBinding,
+  rebuildBindingsFromRegistry,
   resetState,
   setSessionPlatform,
   startUnifiedDisplayLoop,
@@ -111,13 +112,13 @@ import {
 import { fixStaleStreamStates } from "./stream-state.ts";
 import { handleCommand, type PlatformAdapter } from "./orchestrator.ts";
 import { createWechatAdapter, startWechatPlatform } from "./wechat-platform.ts";
-import { handleCodexResetCardAction } from "./codex-reset-actions.ts";
-import { resolveFeishuCardActionChatType } from "./card-action-routing.ts";
-import { reloadRuntimeConfig } from "./runtime-reload.ts";
-import {
-  createAckFirstEventHandler,
-  feishuMessageLedger,
-} from "./feishu-message-ingress.ts";
+import { handleCodexResetCardAction } from "./codex-reset-actions.ts";
+import { resolveFeishuCardActionChatType } from "./card-action-routing.ts";
+import { reloadRuntimeConfig } from "./runtime-reload.ts";
+import {
+  createAckFirstEventHandler,
+  feishuMessageLedger,
+} from "./feishu-message-ingress.ts";
 
 // ---------------------------------------------------------------------------
 // Feishu 平台适配器
@@ -199,21 +200,21 @@ function getInnerEvent(data: Evt): InnerEvent {
   return (data.event ?? data) as InnerEvent;
 }
 
-import { formatMessageContent } from "./format-message.ts";
-import {
-  buildUpdateCommandId,
-  extractFeishuEventId,
-} from "./update-command-guard.ts";
+import { formatMessageContent } from "./format-message.ts";
+import {
+  buildUpdateCommandId,
+  extractFeishuEventId,
+} from "./update-command-guard.ts";
 
 // ---------------------------------------------------------------------------
 // Card action helper: parse button click into text command
 // ---------------------------------------------------------------------------
 
-interface CardActionResult {
-  text: string;
-  chatId: string;
-  openId: string;
-  commandId?: string;
+interface CardActionResult {
+  text: string;
+  chatId: string;
+  openId: string;
+  commandId?: string;
 }
 
 function parseCardAction(data: unknown): CardActionResult | null {
@@ -252,130 +253,130 @@ function parseCardAction(data: unknown): CardActionResult | null {
     ((raw as Record<string, unknown>).operator as Record<string, unknown>)?.open_id as string ??
     "";
 
-  return {
-    text,
-    chatId,
-    openId,
-    commandId: buildUpdateCommandId("card", extractFeishuEventId(data)),
-  };
+  return {
+    text,
+    chatId,
+    openId,
+    commandId: buildUpdateCommandId("card", extractFeishuEventId(data)),
+  };
 }
 
 // ---------------------------------------------------------------------------
 // WebSocket relay broadcast
 // ---------------------------------------------------------------------------
 
-let broadcastToRelay: (data: unknown) => void = () => {};
-const wechatSignal = { stopped: false };
-
-async function processFeishuMessageEvent(data: Evt): Promise<void> {
-  const traceId = makeTraceId();
-  try {
-    broadcastToRelay(data);
-
-    const event = getInnerEvent(data);
-    const message = event.message;
-    if (!message) return;
-
-    const messageId = message.message_id;
-    const chatId = message.chat_id ?? "";
-    const chatType = message.chat_type ?? "group";
-    const msgTimestamp = parseInt(message.create_time ?? "0", 10) || Date.now();
-    const disposition = await feishuMessageLedger.accept({
-      messageId,
-      chatId,
-      createTime: msgTimestamp,
-    });
-
-    if (disposition === "duplicate") {
-      console.log(`[MSG] Duplicate message ignored: ${messageId ?? "(missing id)"}`);
-      return;
-    }
-    if (disposition === "stale") {
-      logTrace(traceId, "DONE", {
-        outcome: "skip_stale_feishu_message",
-        messageId,
-        chatId,
-        msgTimestamp,
-      });
-      console.log(
-        `[${ts()}] [SKIP] Stale Feishu message ignored: messageId=${messageId ?? "(missing id)"} chatId=${chatId} createTime=${msgTimestamp}`,
-      );
-      return;
-    }
-
-    const text = await formatMessageContent(message);
-    const openId = event.sender?.sender_id?.open_id ?? "";
-
-    console.log(
-      `[MSG] id=${messageId ?? "(missing)"} sender=${openId} chat=${chatId} type=${chatType} text="${text}"`,
-    );
-    appendChatLog(chatId, openId, text);
-
-    if (messageId) {
-      getTenantAccessToken().then((freshToken) =>
-        addReaction(freshToken, messageId).catch((err) =>
-          console.error(`[${ts()}] Reaction failed: ${(err as Error).message}`)
-        )
-      ).catch((err) =>
-        console.error(`[${ts()}] Reaction token failed: ${(err as Error).message}`)
-      );
-    }
-
-    if (!text) return;
-    logTrace(traceId, "RECV", {
-      messageId,
-      chatId,
-      chatType,
-      text: text.slice(0, 100),
-    });
-
-    const delayNotice = formatDelayNotice(msgTimestamp, text);
-    if (delayNotice) {
-      const delayToken = await getTenantAccessToken();
-      await sendCardReply(delayToken, chatId, "延迟送达", delayNotice, "yellow").catch(() => {});
-      // 延迟送达的旧消息只发提醒、不转发给 agent 执行：
-      // 断线重连或补推时，早已过期的消息不应未经确认就触发新任务。
-      // 用户如需执行可自行重发。
-      logTrace(traceId, "DONE", {
-        outcome: "skip_delayed_feishu_message",
-        chatId,
-        msgTimestamp,
-        delayMinutes: Math.floor((Date.now() - msgTimestamp) / 60000),
-      });
-      console.log(
-        `[${ts()}] [SKIP] Delayed Feishu message not forwarded to agent: messageId=${messageId ?? "(missing id)"} chatId=${chatId} createTime=${msgTimestamp}`,
-      );
-      return;
-    }
-
-    await handleCommand(
-      feishuPlatform,
-      text,
-      chatId,
-      openId,
-      msgTimestamp,
-      chatType,
-      traceId,
-      buildUpdateCommandId("message", messageId),
-    );
-  } catch (err) {
-    logTrace(traceId, "ERROR", { message: (err as Error).message });
-    console.error(
-      `[${ts()}] [FATAL] im.message.receive_v1 worker crashed: ${(err as Error).message}`,
-    );
-  }
-}
-
-const handleFeishuMessageEventAckFirst = createAckFirstEventHandler(
-  processFeishuMessageEvent,
-  (err) => console.error(
-    `[${ts()}] [FATAL] Detached Feishu event worker failed: ${(err as Error).message}`,
-  ),
-);
-
-// ---------------------------------------------------------------------------
-// Simulate mode: inject message via HTTP
-// ---------------------------------------------------------------------------
+let broadcastToRelay: (data: unknown) => void = () => {};
+const wechatSignal = { stopped: false };
+
+async function processFeishuMessageEvent(data: Evt): Promise<void> {
+  const traceId = makeTraceId();
+  try {
+    broadcastToRelay(data);
+
+    const event = getInnerEvent(data);
+    const message = event.message;
+    if (!message) return;
+
+    const messageId = message.message_id;
+    const chatId = message.chat_id ?? "";
+    const chatType = message.chat_type ?? "group";
+    const msgTimestamp = parseInt(message.create_time ?? "0", 10) || Date.now();
+    const disposition = await feishuMessageLedger.accept({
+      messageId,
+      chatId,
+      createTime: msgTimestamp,
+    });
+
+    if (disposition === "duplicate") {
+      console.log(`[MSG] Duplicate message ignored: ${messageId ?? "(missing id)"}`);
+      return;
+    }
+    if (disposition === "stale") {
+      logTrace(traceId, "DONE", {
+        outcome: "skip_stale_feishu_message",
+        messageId,
+        chatId,
+        msgTimestamp,
+      });
+      console.log(
+        `[${ts()}] [SKIP] Stale Feishu message ignored: messageId=${messageId ?? "(missing id)"} chatId=${chatId} createTime=${msgTimestamp}`,
+      );
+      return;
+    }
+
+    const text = await formatMessageContent(message);
+    const openId = event.sender?.sender_id?.open_id ?? "";
+
+    console.log(
+      `[MSG] id=${messageId ?? "(missing)"} sender=${openId} chat=${chatId} type=${chatType} text="${text}"`,
+    );
+    appendChatLog(chatId, openId, text);
+
+    if (messageId) {
+      getTenantAccessToken().then((freshToken) =>
+        addReaction(freshToken, messageId).catch((err) =>
+          console.error(`[${ts()}] Reaction failed: ${(err as Error).message}`)
+        )
+      ).catch((err) =>
+        console.error(`[${ts()}] Reaction token failed: ${(err as Error).message}`)
+      );
+    }
+
+    if (!text) return;
+    logTrace(traceId, "RECV", {
+      messageId,
+      chatId,
+      chatType,
+      text: text.slice(0, 100),
+    });
+
+    const delayNotice = formatDelayNotice(msgTimestamp, text);
+    if (delayNotice) {
+      const delayToken = await getTenantAccessToken();
+      await sendCardReply(delayToken, chatId, "延迟送达", delayNotice, "yellow").catch(() => {});
+      // 延迟送达的旧消息只发提醒、不转发给 agent 执行：
+      // 断线重连或补推时，早已过期的消息不应未经确认就触发新任务。
+      // 用户如需执行可自行重发。
+      logTrace(traceId, "DONE", {
+        outcome: "skip_delayed_feishu_message",
+        chatId,
+        msgTimestamp,
+        delayMinutes: Math.floor((Date.now() - msgTimestamp) / 60000),
+      });
+      console.log(
+        `[${ts()}] [SKIP] Delayed Feishu message not forwarded to agent: messageId=${messageId ?? "(missing id)"} chatId=${chatId} createTime=${msgTimestamp}`,
+      );
+      return;
+    }
+
+    await handleCommand(
+      feishuPlatform,
+      text,
+      chatId,
+      openId,
+      msgTimestamp,
+      chatType,
+      traceId,
+      buildUpdateCommandId("message", messageId),
+    );
+  } catch (err) {
+    logTrace(traceId, "ERROR", { message: (err as Error).message });
+    console.error(
+      `[${ts()}] [FATAL] im.message.receive_v1 worker crashed: ${(err as Error).message}`,
+    );
+  }
+}
+
+const handleFeishuMessageEventAckFirst = createAckFirstEventHandler(
+  processFeishuMessageEvent,
+  (err) => console.error(
+    `[${ts()}] [FATAL] Detached Feishu event worker failed: ${(err as Error).message}`,
+  ),
+);
+
+// ---------------------------------------------------------------------------
+// Simulate mode: inject message via HTTP
+// ---------------------------------------------------------------------------
 
 async function handleSimInjectMessage(req: IncomingMessage, res: ServerResponse): Promise<boolean> {
   const url = new URL(req.url ?? "/", "http://127.0.0.1");
@@ -507,9 +508,9 @@ async function startBotServiceCore(): Promise<void> {
 
   console.log(`[${ts()}] [AUTH] Token obtained`);
 
-  const eventDispatcher = new EventDispatcher({});
-  eventDispatcher.register({
-    "im.message.receive_v1": handleFeishuMessageEventAckFirst,
+  const eventDispatcher = new EventDispatcher({});
+  eventDispatcher.register({
+    "im.message.receive_v1": handleFeishuMessageEventAckFirst,
 
     "card.action.trigger": async (data: Evt) => {
       try {
@@ -552,21 +553,21 @@ async function startBotServiceCore(): Promise<void> {
       });
       if (handledCodexReset) return;
 
-      const result = parseCardAction(data);
-      if (!result) return;
-      const registry = await loadSessionRegistryForBinding();
-      const chatType = resolveFeishuCardActionChatType(result.chatId, registry);
-      console.log(`[BTN] chat=${result.chatId} chatType=${chatType} text="${result.text}"`);
-      handleCommand(
-        feishuPlatform,
-        result.text,
-        result.chatId,
-        result.openId,
-        Date.now(),
-        chatType,
-        undefined,
-        result.commandId,
-      ).catch((err) =>
+      const result = parseCardAction(data);
+      if (!result) return;
+      const registry = await loadSessionRegistryForBinding();
+      const chatType = resolveFeishuCardActionChatType(result.chatId, registry);
+      console.log(`[BTN] chat=${result.chatId} chatType=${chatType} text="${result.text}"`);
+      handleCommand(
+        feishuPlatform,
+        result.text,
+        result.chatId,
+        result.openId,
+        Date.now(),
+        chatType,
+        undefined,
+        result.commandId,
+      ).catch((err) =>
         console.error(`[${ts()}] [BTN] handleCommand failed: ${(err as Error).message}`)
       );
       } catch (err) {
@@ -589,20 +590,20 @@ async function startBotServiceCore(): Promise<void> {
     ws.on("message", async (raw: Buffer) => {
       try {
         const data = JSON.parse(raw.toString()) as Evt;
-        const action = parseCardAction(data);
-        if (action) {
-          const registry = await loadSessionRegistryForBinding();
-          const chatType = resolveFeishuCardActionChatType(action.chatId, registry);
-          handleCommand(
-            feishuPlatform,
-            action.text,
-            action.chatId,
-            action.openId,
-            Date.now(),
-            chatType,
-            undefined,
-            action.commandId,
-          ).catch((err) =>
+        const action = parseCardAction(data);
+        if (action) {
+          const registry = await loadSessionRegistryForBinding();
+          const chatType = resolveFeishuCardActionChatType(action.chatId, registry);
+          handleCommand(
+            feishuPlatform,
+            action.text,
+            action.chatId,
+            action.openId,
+            Date.now(),
+            chatType,
+            undefined,
+            action.commandId,
+          ).catch((err) =>
             console.error(`[${ts()}] [BTN] handleCommand failed: ${(err as Error).message}`)
           );
           return;
@@ -636,8 +637,8 @@ async function startBotServiceCore(): Promise<void> {
   } else {
     // 进程首次启动:此时所有 Map 都是空的,resetState 主要是打个 LOG 标识"开始
     // 干净状态"。修正残留的 running stream-state 并重建 session→chat 映射。
-    resetState();
-    await feishuMessageLedger.load();
+    resetState();
+    await feishuMessageLedger.load();
     startUnifiedDisplayLoop();
     fixStaleStreamStates().then(async () => {
       const registry = await loadSessionRegistryForBinding();
@@ -776,32 +777,32 @@ async function startConfiguredPlatforms(
 // Main
 // ---------------------------------------------------------------------------
 
-async function main(): Promise<void> {
-  // 用户直接运行 chatccc 时打开系统默认浏览器；由 `/restart`、`/update`
-  // 或 Web UI 拉起的替代进程会携带内部标记，不重复打扰用户。
-  const autoOpenWebUi = shouldAutoOpenWebUi({
-    openOnStart: config.webUi.openOnStart,
-  });
-  appendStartupTrace("main: entered", {
-    argv: process.argv.join(" ").slice(0, 400),
-    CHATCCC_PORT,
-    PROJECT_ROOT,
-    autoOpenWebUi,
+async function main(): Promise<void> {
+  // 用户直接运行 chatccc 时打开系统默认浏览器；由 `/restart`、`/update`
+  // 或 Web UI 拉起的替代进程会携带内部标记，不重复打扰用户。
+  const autoOpenWebUi = shouldAutoOpenWebUi({
+    openOnStart: config.webUi.openOnStart,
+  });
+  appendStartupTrace("main: entered", {
+    argv: process.argv.join(" ").slice(0, 400),
+    CHATCCC_PORT,
+    PROJECT_ROOT,
+    autoOpenWebUi,
   });
 
-  // ChatCCC 是常驻服务，不能把“当前刚好有没有 Agent session”当作进程生命周期。
-  // referenced timer 明确锚定服务进程；HTTP Server 接入后还会定期 ref/健康检查。
-  // `/restart`、`/update` 都使用 process.exit()，不会被 timer 阻止。
-  const serviceLifecycle = createServiceLifecycleGuard({ tracer: appendStartupTrace });
-  serviceLifecycle.start();
-
-  // 黑匣子：所有未捕获异常 / 信号 / beforeExit 都同步写入 startup-trace.log（appendFileSync）。
+  // ChatCCC 是常驻服务，不能把“当前刚好有没有 Agent session”当作进程生命周期。
+  // referenced timer 明确锚定服务进程；HTTP Server 接入后还会定期 ref/健康检查。
+  // `/restart`、`/update` 都使用 process.exit()，不会被 timer 阻止。
+  const serviceLifecycle = createServiceLifecycleGuard({ tracer: appendStartupTrace });
+  serviceLifecycle.start();
+
+  // 黑匣子：所有未捕获异常 / 信号 / beforeExit 都同步写入 startup-trace.log（appendFileSync）。
   // 越早装越好——后续任何一行抛错都有兜底；它独立于 SIGINT 清理（见末尾的
   // server.close）——只负责诊断与默认致命退出，不替代清理逻辑。
-  installCrashLogging({
-    flush: () => fileLog.flush(),
-    onBeforeExit: (code) => serviceLifecycle.handleBeforeExit(code),
-  });
+  installCrashLogging({
+    flush: () => fileLog.flush(),
+    onBeforeExit: (code) => serviceLifecycle.handleBeforeExit(code),
+  });
 
   // 模拟模式：独立端口 18079，不与 SDK 实例冲突，不走飞书凭证/权限/WSClient
   if (USE_SIMULATE) {
@@ -841,33 +842,33 @@ async function main(): Promise<void> {
       simServer.once("error", onError);
       simServer.once("listening", onListening);
       simServer.listen(SIM_PORT, "127.0.0.1");
-    }).catch((err: NodeJS.ErrnoException) => {
+    }).catch((err: NodeJS.ErrnoException) => {
       console.error(`\n[启动] 监听失败：端口 ${SIM_PORT}（${err.code ?? "?"} — ${err.message}）`);
-      process.exit(1);
-    });
-    serviceLifecycle.attachServer(
-      simServer,
-      () => recoverHttpServer(simServer, SIM_PORT),
-    );
+      process.exit(1);
+    });
+    serviceLifecycle.attachServer(
+      simServer,
+      () => recoverHttpServer(simServer, SIM_PORT),
+    );
 
     console.log(`\n${"=".repeat(60)}`);
     console.log(`  ChatCCC — 模拟飞书环境模式`);
     console.log(`${"=".repeat(60)}`);
     console.log(`  发送消息: POST http://127.0.0.1:${SIM_PORT}/api/sim/inject-message`);
     console.log(`  消息日志: ~/.chatccc/sim/messages.jsonl`);
-    console.log(`${"=".repeat(60)}\n`);
-
-    if (autoOpenWebUi) {
-      const url = buildWebUiUrl(SIM_PORT);
-      const opened = openWebUiInDefaultBrowser(SIM_PORT);
-      appendStartupTrace(
-        opened ? "web-ui: opening simulate browser" : "web-ui: simulate browser unavailable",
-        { url },
-      );
-    }
-
-    installShutdownHandlers(simServer, serviceLifecycle);
-    return;
+    console.log(`${"=".repeat(60)}\n`);
+
+    if (autoOpenWebUi) {
+      const url = buildWebUiUrl(SIM_PORT);
+      const opened = openWebUiInDefaultBrowser(SIM_PORT);
+      appendStartupTrace(
+        opened ? "web-ui: opening simulate browser" : "web-ui: simulate browser unavailable",
+        { url },
+      );
+    }
+
+    installShutdownHandlers(simServer, serviceLifecycle);
+    return;
   }
 
   if (Number.isNaN(CHATCCC_PORT) || CHATCCC_PORT < 1 || CHATCCC_PORT > 65535) {
@@ -914,32 +915,32 @@ async function main(): Promise<void> {
     if (!APP_ID.trim() || !APP_SECRET.trim()) {
       // 凭证不全：进 setup 向导。注入 onActivate 回调让用户点"保存并启动"
       // 时，原地（同进程）调用 startBotService，复用 setup HTTP server。
-      const setupServer = startSetupMode(CHATCCC_PORT, {
-        openBrowser: autoOpenWebUi,
-        onActivate: async (httpServer: Server) => {
+      const setupServer = startSetupMode(CHATCCC_PORT, {
+        openBrowser: autoOpenWebUi,
+        onActivate: async (httpServer: Server) => {
           reloadRuntimeConfig("setup-activate");
           appendStartupTrace("setup-activate: reloaded config from disk", {
             appIdMaskAfterReload: maskAppId(APP_ID),
           });
           try {
             await startConfiguredPlatforms(httpServer, { failOnFeishuError: true });
-            return { ok: true };
+            return { ok: true };
           } catch (err) {
             appendStartupTrace("setup-activate: startConfiguredPlatforms failed", {
               message: (err as Error).message,
             });
             return { ok: false, error: (err as Error).message };
           }
-        },
-      });
-      setupServer.once("listening", () => {
-        serviceLifecycle.attachServer(
-          setupServer,
-          () => recoverHttpServer(setupServer, CHATCCC_PORT),
-        );
-      });
-      installShutdownHandlers(setupServer, serviceLifecycle);
-      return;
+        },
+      });
+      setupServer.once("listening", () => {
+        serviceLifecycle.attachServer(
+          setupServer,
+          () => recoverHttpServer(setupServer, CHATCCC_PORT),
+        );
+      });
+      installShutdownHandlers(setupServer, serviceLifecycle);
+      return;
     }
     console.log(`  必填项校验通过（App ID 摘要: ${maskAppId(APP_ID)}）。\n`);
     appendStartupTrace("main: feishu credentials ok", { appIdMask: maskAppId(APP_ID) });
@@ -953,64 +954,68 @@ async function main(): Promise<void> {
   // 启动 HTTP server（同时挂 UI router，供 dashboard / setup / agent image/file 使用）
   appendStartupTrace("main: before freeRelayListenPort", { CHATCCC_PORT });
   const killed = freeRelayListenPort(CHATCCC_PORT);
-  appendStartupTrace("main: after freeRelayListenPort", { CHATCCC_PORT, killed });
-  if (killed > 0) {
-    await waitForPortFree(CHATCCC_PORT);
-    appendStartupTrace("main: port free confirmed", { CHATCCC_PORT });
+  const isInternalRestart = process.env[INTERNAL_RESTART_ENV_VAR] === "1";
+  appendStartupTrace("main: after freeRelayListenPort", { CHATCCC_PORT, killed, isInternalRestart });
+  // 内部自重启（/restart、/update）时父进程还占着端口（祖先链 PID 不会被杀）：
+  // 无条件等待端口释放再 listen，避免子进程一上来就 EADDRINUSE 秒退
+  // （Windows 端口释放有额外延迟，重试窗口容易不够）。
+  if (killed > 0 || isInternalRestart) {
+    await waitForPortFree(CHATCCC_PORT, isInternalRestart ? 5000 : undefined);
+    appendStartupTrace("main: port free confirmed", { CHATCCC_PORT, isInternalRestart });
   }
-  const httpServer = createServer(createUiRouter());
-  await listenWithRetry(httpServer, CHATCCC_PORT, "127.0.0.1").catch((err: NodeJS.ErrnoException) => {
+  const httpServer = createServer(createUiRouter());
+  await listenWithRetry(httpServer, CHATCCC_PORT, "127.0.0.1").catch((err: NodeJS.ErrnoException) => {
     console.error(`\n[启动] 本地中继 WebSocket 监听失败：端口 ${CHATCCC_PORT}（${err.code ?? "?"} — ${err.message}）`);
     console.error(
       "  处理建议: 关闭占用该端口的其它程序，或在 config.json 的 port 字段里改成其它未占用端口（如 18081）。"
     );
     printServiceDidNotStart(`本地中继端口 ${CHATCCC_PORT} 无法监听（${err.code ?? "?"} — ${err.message}）`);
-    process.exit(1);
-  });
-  serviceLifecycle.attachServer(
-    httpServer,
-    () => recoverHttpServer(httpServer, CHATCCC_PORT),
-  );
-  // 平台鉴权/长连接启动可能耗时；此时也必须允许 Ctrl+C / SIGTERM 正常退出，
-  // 不能只留下更早安装的信号日志 listener 把默认退出行为吞掉。
-  installShutdownHandlers(httpServer, serviceLifecycle);
-
-  // 必须等 HTTP server 真正监听后再发起打开请求，避免浏览器先到一步看到
-  // ERR_CONNECTION_REFUSED。Chrome CDP 守护仍保持自己原有的独立行为。
-  if (autoOpenWebUi) {
-    const url = buildWebUiUrl(CHATCCC_PORT);
-    const opened = openWebUiInDefaultBrowser(CHATCCC_PORT);
-    if (opened) {
-      console.log(`[WEB-UI] 已请求系统默认浏览器打开: ${url}`);
-      appendStartupTrace("web-ui: opening default browser", { url });
-    } else {
-      appendStartupTrace("web-ui: default browser unavailable", { url });
-    }
-  } else {
-    appendStartupTrace("web-ui: default browser skipped by lifecycle or preference", {
-      url: buildWebUiUrl(CHATCCC_PORT),
-      openOnStart: config.webUi.openOnStart,
-    });
-  }
-
-  await startConfiguredPlatforms(httpServer, { failOnFeishuError: false });
-}
-
-/**
- * 生命周期健康检查发现 HTTP Server 已停止监听时，优先原地恢复同一个 Server。
- * router、WebSocket upgrade listener 都挂在这个对象上，复用它能保留现有服务绑定；
- * 恢复失败会被 lifecycle guard 记录，并在下一轮检查重试。
- */
-async function recoverHttpServer(httpServer: Server, port: number): Promise<void> {
-  if (httpServer.listening) {
-    httpServer.ref();
-    return;
-  }
-  appendStartupTrace("service-lifecycle: HTTP recovery begin", { port });
-  await listenWithRetry(httpServer, port, "127.0.0.1");
-  httpServer.ref();
-  appendStartupTrace("service-lifecycle: HTTP recovery listen succeeded", { port });
-}
+    process.exit(1);
+  });
+  serviceLifecycle.attachServer(
+    httpServer,
+    () => recoverHttpServer(httpServer, CHATCCC_PORT),
+  );
+  // 平台鉴权/长连接启动可能耗时；此时也必须允许 Ctrl+C / SIGTERM 正常退出，
+  // 不能只留下更早安装的信号日志 listener 把默认退出行为吞掉。
+  installShutdownHandlers(httpServer, serviceLifecycle);
+
+  // 必须等 HTTP server 真正监听后再发起打开请求，避免浏览器先到一步看到
+  // ERR_CONNECTION_REFUSED。Chrome CDP 守护仍保持自己原有的独立行为。
+  if (autoOpenWebUi) {
+    const url = buildWebUiUrl(CHATCCC_PORT);
+    const opened = openWebUiInDefaultBrowser(CHATCCC_PORT);
+    if (opened) {
+      console.log(`[WEB-UI] 已请求系统默认浏览器打开: ${url}`);
+      appendStartupTrace("web-ui: opening default browser", { url });
+    } else {
+      appendStartupTrace("web-ui: default browser unavailable", { url });
+    }
+  } else {
+    appendStartupTrace("web-ui: default browser skipped by lifecycle or preference", {
+      url: buildWebUiUrl(CHATCCC_PORT),
+      openOnStart: config.webUi.openOnStart,
+    });
+  }
+
+  await startConfiguredPlatforms(httpServer, { failOnFeishuError: false });
+}
+
+/**
+ * 生命周期健康检查发现 HTTP Server 已停止监听时，优先原地恢复同一个 Server。
+ * router、WebSocket upgrade listener 都挂在这个对象上，复用它能保留现有服务绑定；
+ * 恢复失败会被 lifecycle guard 记录，并在下一轮检查重试。
+ */
+async function recoverHttpServer(httpServer: Server, port: number): Promise<void> {
+  if (httpServer.listening) {
+    httpServer.ref();
+    return;
+  }
+  appendStartupTrace("service-lifecycle: HTTP recovery begin", { port });
+  await listenWithRetry(httpServer, port, "127.0.0.1");
+  httpServer.ref();
+  appendStartupTrace("service-lifecycle: HTTP recovery listen succeeded", { port });
+}
 
 /**
  * 带重试的 server.listen，Windows 端口释放有延迟时自动重试。
@@ -1048,26 +1053,26 @@ async function listenWithRetry(
  * Node EventEmitter 按注册顺序触发，installCrashLogging 装得更早 → 同步 trace
  * 先写盘，再走这里。
  */
-function installShutdownHandlers(
-  httpServer: Server,
-  serviceLifecycle: ReturnType<typeof createServiceLifecycleGuard>,
-): void {
-  process.on("SIGINT", () => {
-    console.log("\nShutting down...");
-    serviceLifecycle.beginShutdown("SIGINT");
-    wechatSignal.stopped = true;
-    stopChromeDevtoolsGuard();
-    httpServer.close();
-    process.exit(0);
-  });
-  process.on("SIGTERM", () => {
-    serviceLifecycle.beginShutdown("SIGTERM");
-    wechatSignal.stopped = true;
-    stopChromeDevtoolsGuard();
-    httpServer.close();
-    process.exit(0);
-  });
-}
+function installShutdownHandlers(
+  httpServer: Server,
+  serviceLifecycle: ReturnType<typeof createServiceLifecycleGuard>,
+): void {
+  process.on("SIGINT", () => {
+    console.log("\nShutting down...");
+    serviceLifecycle.beginShutdown("SIGINT");
+    wechatSignal.stopped = true;
+    stopChromeDevtoolsGuard();
+    httpServer.close();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    serviceLifecycle.beginShutdown("SIGTERM");
+    wechatSignal.stopped = true;
+    stopChromeDevtoolsGuard();
+    httpServer.close();
+    process.exit(0);
+  });
+}
 
 main().catch((err: Error) => {
   appendStartupTrace("main: catch fatal", { message: err.message, stack: err.stack?.slice(0, 800) });