chatccc 0.2.41 → 0.2.43

package/src/index.ts

@@ -41,6 +41,7 @@ import {
   CLAUDE_EFFORT,
   CLAUDE_MODEL,
   GIT_TIMEOUT_MS,
+  ALLOW_INTERRUPT,
   reloadConfigFromDisk,
   anthropicConfigDisplay,
   LOCAL_RELAY_URL,
@@ -102,6 +103,7 @@ import {
   resetState,
   resumeAndPrompt,
   sessionInfoMap,
+  recordSessionRegistry,
   getAdapterForTool,
 } from "./session.ts";
 
@@ -309,7 +311,8 @@ async function handleSimInjectMessage(req: IncomingMessage, res: ServerResponse)
 
 async function handleCommand(text: string, chatId: string, openId: string, msgTimestamp: number, chatType = "group", traceId?: string): Promise<void> {
   const tid = traceId ?? makeTraceId();
-  if (text === "/restart") {
+  const textLower = text.toLowerCase();
+  if (textLower === "/restart") {
     logTrace(tid, "BRANCH", { cmd: "/restart" });
     const restartToken = await getTenantAccessToken();
     await sendTextReply(restartToken, chatId, "正在重启...").catch(() => {});
@@ -326,7 +329,7 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
     return;
   }
 
-  if (text === "/cd" || text.startsWith("/cd ")) {
+  if (textLower === "/cd" || textLower.startsWith("/cd ")) {
     logTrace(tid, "BRANCH", { cmd: "/cd", arg: text.slice(3).trim() || "(none)" });
     const cdToken = await getTenantAccessToken();
     const currentDir = await getDefaultCwd(chatId);
@@ -415,8 +418,8 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
     return;
   }
 
-  if (text === "/new" || text.startsWith("/new ")) {
-    const toolArg = text.slice(5).trim();
+  if (textLower === "/new" || textLower.startsWith("/new ")) {
+    const toolArg = text.slice(5).trim().toLowerCase();
     const tool = toolArg || "claude";
     logTrace(tid, "BRANCH", { cmd: "/new", tool });
     const validTools = ["claude", "cursor", "codex"];
@@ -483,6 +486,15 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
 
     // 让新群的默认工作目录继承当前会话的 cwd
     await setDefaultCwd(cwd, newChatId);
+    await recordSessionRegistry({
+      chatId: newChatId,
+      sessionId,
+      tool,
+      chatName: initialName,
+      turnCount: 0,
+      startTime: Date.now(),
+      running: false,
+    });
 
     const adapter = getAdapterForTool(tool);
     await sendCardReply(
@@ -530,12 +542,13 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
         try {
           await updateChatInfo(freshToken, chatId, newName, description);
           console.log(`[${ts()}] [RENAME] First message → group renamed to "${newName}"`);
+          await recordSessionRegistry({ chatId, chatName: newName }).catch(() => {});
         } catch (err) {
           console.error(`[${ts()}] [RENAME] Failed: ${(err as Error).message}`);
         }
       }
 
-      if (text === "/stop") {
+      if (textLower === "/stop") {
         logTrace(tid, "BRANCH", { cmd: "/stop" });
         const cEntry = chatSessionMap.get(chatId);
         if (cEntry) {
@@ -556,12 +569,13 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
         return;
       }
 
-      if (text === "/status") {
+      if (textLower === "/status") {
         logTrace(tid, "BRANCH", { cmd: "/status" });
         const status = await getSessionStatus(chatId);
         const running = chatSessionMap.get(chatId);
         const isActive = running && !running.stopped;
         const statusText = [
+          `**群名:** ${status?.chatName || "—"}`,
           `**Session ID:** \`${status?.sessionId ?? sessionId}\``,
           `**工具:** ${toolLabel}`,
           `**状态:** ${isActive ? "🟢 运行中" : "⚪ 空闲"}`,
@@ -590,12 +604,13 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
         return;
       }
 
-      if (text === "/sessions") {
+      if (textLower === "/sessions") {
         logTrace(tid, "BRANCH", { cmd: "/sessions" });
         const allSessions = await getAllSessionsStatus();
         const now = Date.now();
         const cardData = allSessions.map(s => ({
           sessionId: s.sessionId,
+          chatName: s.chatName,
           active: s.active,
           turnCount: s.turnCount,
           elapsedSeconds: s.active ? Math.floor((now - s.startTime) / 1000) : null,
@@ -609,7 +624,7 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
         return;
       }
 
-      if (text === "/forget") {
+      if (textLower === "/forget") {
         logTrace(tid, "BRANCH", { cmd: "/forget" });
         const adapter = getAdapterForTool(descriptionTool);
         let cwd: string;
@@ -643,9 +658,9 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
         }
 
         const descPrefix = sessionPrefixForTool(descriptionTool);
-        const initialName = sessionChatName("新会话", cwd);
-        await updateChatInfo(freshToken, chatId, initialName, `${descPrefix} ${newSessionId}`);
-        console.log(`[${ts()}] [FORGET] Group updated: name="${initialName}" desc="${descPrefix} ${newSessionId}"`);
+        const newName = sessionChatName("新会话", cwd);
+        await updateChatInfo(freshToken, chatId, newName, `${descPrefix} ${newSessionId}`);
+        console.log(`[${ts()}] [FORGET] Group updated: name="${newName}" desc="${descPrefix} ${newSessionId}"`);
 
         sessionInfoMap.set(chatId, {
           sessionId: newSessionId,
@@ -654,6 +669,16 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
           startTime: Date.now(),
           tool: descriptionTool,
         });
+        await recordSessionRegistry({
+          chatId,
+          sessionId: newSessionId,
+          tool: descriptionTool,
+          chatName: newName,
+          turnCount: 0,
+          lastContextTokens: 0,
+          startTime: Date.now(),
+          running: false,
+        });
 
         setChatAvatar(freshToken, chatId, descriptionTool, "new").catch(() => {});
 
@@ -671,10 +696,86 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
         return;
       }
 
+      // /session <number>：切换到 /sessions 列表中的指定会话
+      const sessionMatch = textLower.match(/^\/session\s+(\d+)$/);
+      if (sessionMatch) {
+        const index = parseInt(sessionMatch[1], 10) - 1;
+        logTrace(tid, "BRANCH", { cmd: "/session", index: index + 1 });
+        const allSessions = await getAllSessionsStatus();
+        if (allSessions.length === 0) {
+          await sendCardReply(freshToken, chatId, "/session", "暂无历史会话。", "yellow");
+          logTrace(tid, "DONE", { outcome: "session_no_sessions" });
+          return;
+        }
+        if (index < 0 || index >= allSessions.length) {
+          await sendCardReply(freshToken, chatId, "/session", `序号超出范围，当前共 ${allSessions.length} 个会话。`, "yellow");
+          logTrace(tid, "DONE", { outcome: "session_out_of_range", index: index + 1, total: allSessions.length });
+          return;
+        }
+        const target = allSessions[index];
+
+        const existing2 = chatSessionMap.get(chatId);
+        if (existing2) {
+          existing2.stopped = true;
+          if (existing2.spinnerTimer) { clearInterval(existing2.spinnerTimer); existing2.spinnerTimer = null; }
+          existing2.close();
+          const prevTs2 = lastMsgTimestamps.get(chatId);
+          if (prevTs2 === undefined || existing2.msgTimestamp > prevTs2) {
+            lastMsgTimestamps.set(chatId, existing2.msgTimestamp);
+          }
+          chatSessionMap.delete(chatId);
+        }
+
+        const targetAdapter = getAdapterForTool(target.tool);
+        let cwd2: string;
+        try {
+          const targetInfo = await targetAdapter.getSessionInfo(target.sessionId);
+          cwd2 = targetInfo?.cwd ?? (await getDefaultCwd(chatId));
+        } catch {
+          cwd2 = await getDefaultCwd(chatId);
+        }
+
+        const descPrefix2 = sessionPrefixForTool(target.tool);
+        const newName2 = sessionChatName("新会话", cwd2);
+        await updateChatInfo(freshToken, chatId, newName2, `${descPrefix2} ${target.sessionId}`);
+
+        sessionInfoMap.set(chatId, {
+          sessionId: target.sessionId,
+          turnCount: target.turnCount,
+          lastContextTokens: 0,
+          startTime: Date.now(),
+          tool: target.tool,
+        });
+        await recordSessionRegistry({
+          chatId,
+          sessionId: target.sessionId,
+          tool: target.tool,
+          chatName: newName2,
+          running: false,
+        });
+
+        setChatAvatar(freshToken, chatId, target.tool, "new").catch(() => {});
+
+        const targetToolLabel = toolDisplayName(target.tool);
+        await sendCardReply(
+          freshToken, chatId, `${targetToolLabel} Session Switched`,
+          `已切换到 **${targetToolLabel}** 会话。\n\n` +
+            `**序号:** ${index + 1}\n` +
+            `**Session ID:** ${target.sessionId}\n` +
+            `**工作目录:** \`${cwd2}\`\n\n` +
+            `直接在这里发消息即可继续对话。`,
+          "green"
+        );
+
+        console.log(`[${ts()}] [SESSION] Switched to session ${target.sessionId} (#${index + 1})`);
+        logTrace(tid, "DONE", { outcome: "session_switch", sessionId: target.sessionId, index: index + 1, cwd: cwd2 });
+        return;
+      }
+
       // /git <args>：在「当前会话工作目录」执行 git 命令，把输出回发到群里。
       // 注意 cwd 必须取自 adapter.getSessionInfo（会话真实 cwd），而非
       // getDefaultCwd（下一次 /new 才会使用的默认路径）。
-      if (text.startsWith("/git ") || text === "/git") {
+      if (textLower.startsWith("/git ") || textLower === "/git") {
         const args = text === "/git" ? "" : text.slice(5).trim();
         logTrace(tid, "BRANCH", { cmd: "/git", args: args || "(none)" });
         if (!args) {
@@ -732,6 +833,18 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
           console.log(`[${ts()}] [SKIP] Older message (${msgTimestamp} <= ${existing.msgTimestamp}), ignoring`);
           return;
         }
+
+        if (!ALLOW_INTERRUPT) {
+          logTrace(tid, "BLOCKED", { outcome: "interrupt_disabled", sessionId });
+          console.log(`[${ts()}] [BLOCKED] allowInterrupt=false, ignoring message during generation. Hint sent to user.`);
+          await sendCardReply(
+            freshToken, chatId, "生成中",
+            "AI 正在生成回复中，请先点击卡片上的「停止」按钮停止当前生成后，再发送新消息。",
+            "yellow"
+          );
+          return;
+        }
+
         existing.stopped = true;
         if (existing.spinnerTimer) { clearInterval(existing.spinnerTimer); existing.spinnerTimer = null; }
         existing.close();
@@ -1011,7 +1124,7 @@ async function startBotServiceCore(): Promise<void> {
         const openId = event.sender?.sender_id?.open_id ?? "";
         const chatId = message.chat_id ?? "";
         appendChatLog(chatId, openId, text);
-        if (text === "/new" && openId) {
+        if (text.toLowerCase() === "/new" && openId) {
           console.log(`[MSG] /new from ${openId}, but local relay does not handle /new yet. Use SDK mode.`);
         }
       } catch { /* ignore */ }

package/src/session.ts

@@ -168,6 +168,87 @@ export async function getSessionTool(sessionId: string): Promise<string | null>
   return record?.tool ?? null;
 }
 
+// ---------------------------------------------------------------------------
+// Conversation session registry for /sessions
+// ---------------------------------------------------------------------------
+
+export const SESSION_REGISTRY_FILE = join(USER_DATA_DIR, "state", "session-registry.json");
+let sessionRegistryFile = SESSION_REGISTRY_FILE;
+
+export interface SessionRegistryUpdate {
+  chatId: string;
+  sessionId: string;
+  tool: string;
+  chatName?: string;
+  turnCount?: number;
+  lastContextTokens?: number;
+  startTime?: number;
+  updatedAt?: number;
+  running?: boolean;
+}
+
+interface SessionRegistryRecord {
+  chatId: string;
+  sessionId: string;
+  tool: string;
+  chatName: string;
+  turnCount: number;
+  lastContextTokens: number;
+  startTime: number;
+  updatedAt: number;
+  running: boolean;
+}
+
+type SessionRegistryData = Record<string, SessionRegistryRecord>;
+
+async function loadSessionRegistry(): Promise<SessionRegistryData> {
+  try {
+    const raw = await readFile(sessionRegistryFile, "utf-8");
+    const parsed = JSON.parse(raw) as SessionRegistryData;
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+async function saveSessionRegistry(data: SessionRegistryData): Promise<void> {
+  try {
+    await mkdir(dirname(sessionRegistryFile), { recursive: true });
+    await writeFile(sessionRegistryFile, JSON.stringify(data, null, 2), "utf-8");
+  } catch (err) {
+    console.error(`[${ts()}] Failed to save session-registry.json: ${(err as Error).message}`);
+    fileLog.flush();
+  }
+}
+
+export async function recordSessionRegistry(update: SessionRegistryUpdate): Promise<void> {
+  const data = await loadSessionRegistry();
+  const existing = data[update.chatId];
+  const now = update.updatedAt ?? Date.now();
+
+  data[update.chatId] = {
+    chatId: update.chatId,
+    sessionId: update.sessionId,
+    tool: update.tool,
+    chatName: update.chatName ?? existing?.chatName ?? "",
+    turnCount: update.turnCount ?? existing?.turnCount ?? 0,
+    lastContextTokens: update.lastContextTokens ?? existing?.lastContextTokens ?? 0,
+    startTime: update.startTime ?? existing?.startTime ?? now,
+    updatedAt: now,
+    running: update.running ?? existing?.running ?? false,
+  };
+
+  await saveSessionRegistry(data);
+}
+
+export function _setSessionRegistryFileForTest(filePath: string): void {
+  sessionRegistryFile = filePath;
+}
+
+export function _resetSessionRegistryFileForTest(): void {
+  sessionRegistryFile = SESSION_REGISTRY_FILE;
+}
+
 // ---------------------------------------------------------------------------
 // accumulateBlockContent — 将 UnifiedBlock 累积到渲染状态（纯函数，可测试）
 // ---------------------------------------------------------------------------
@@ -385,13 +466,24 @@ export async function resumeAndPrompt(
 
   const now = Date.now();
   const existingInfo = sessionInfoMap.get(chatId);
+  const nextTurnCount = (existingInfo?.turnCount ?? 0) + 1;
+  const nextContextTokens = existingInfo?.lastContextTokens ?? 0;
   sessionInfoMap.set(chatId, {
     sessionId,
-    turnCount: (existingInfo?.turnCount ?? 0) + 1,
-    lastContextTokens: existingInfo?.lastContextTokens ?? 0,
+    turnCount: nextTurnCount,
+    lastContextTokens: nextContextTokens,
     startTime: now,
     tool,
   });
+  await recordSessionRegistry({
+    chatId,
+    sessionId,
+    tool,
+    turnCount: nextTurnCount,
+    lastContextTokens: nextContextTokens,
+    startTime: now,
+    running: true,
+  });
 
   let cardId: string | null = null;
   cardId = await createCardKitCard(token, buildProgressCard("", { showStop: true, headerTitle: "生成中..." })).catch((err) => {
@@ -512,6 +604,13 @@ export async function resumeAndPrompt(
         if (block.type === "compact_boundary" && block.post_tokens) {
           const info = sessionInfoMap.get(chatId);
           if (info) { info.lastContextTokens = block.post_tokens; }
+          await recordSessionRegistry({
+            chatId,
+            sessionId,
+            tool,
+            lastContextTokens: block.post_tokens,
+            running: true,
+          });
         }
       }
     }
@@ -561,6 +660,16 @@ export async function resumeAndPrompt(
   const finalReply = pickFinalReply(state).trim();
 
   if (wasStopped) {
+    const finalInfo = sessionInfoMap.get(chatId);
+    await recordSessionRegistry({
+      chatId,
+      sessionId,
+      tool,
+      turnCount: finalInfo?.turnCount ?? nextTurnCount,
+      lastContextTokens: finalInfo?.lastContextTokens ?? nextContextTokens,
+      startTime: finalInfo?.startTime ?? now,
+      running: false,
+    });
     if (finalReply) {
       await sendTextReply(token, chatId, finalReply).catch((err) =>
         console.error(`[${ts()}] Failed to send partial text: ${(err as Error).message}`)
@@ -597,6 +706,16 @@ export async function resumeAndPrompt(
   }
 
   console.log(`[${ts()}] Session ${sessionId} stream complete (content chunks: ${state.chunkCount})`);
+  const finalInfo = sessionInfoMap.get(chatId);
+  await recordSessionRegistry({
+    chatId,
+    sessionId,
+    tool,
+    turnCount: finalInfo?.turnCount ?? nextTurnCount,
+    lastContextTokens: finalInfo?.lastContextTokens ?? nextContextTokens,
+    startTime: finalInfo?.startTime ?? now,
+    running: false,
+  });
   if (tid) logTrace(tid, "SESSION_END", { sessionId, chunks: state.chunkCount, finalTextLen: finalReply.length });
 }
 
@@ -620,6 +739,7 @@ export const UNKNOWN_MODEL_PLACEHOLDER = "—";
 
 export interface SessionStatus {
   sessionId: string;
+  chatName: string;
   running: boolean;
   turnCount: number;
   lastContextTokens: number;
@@ -666,8 +786,12 @@ export async function getSessionStatus(chatId: string): Promise<SessionStatus |
   const active = chatSessionMap.get(chatId);
   const { model, effort } = await resolveModelEffort(info.tool, info.sessionId);
 
+  const registry = await loadSessionRegistry();
+  const chatName = registry[chatId]?.chatName ?? "";
+
   return {
     sessionId: info.sessionId,
+    chatName,
     running: active !== undefined && !active.stopped,
     turnCount: info.turnCount,
     lastContextTokens: info.lastContextTokens,
@@ -681,6 +805,7 @@ export async function getSessionStatus(chatId: string): Promise<SessionStatus |
 export interface SessionsListEntry {
   chatId: string;
   sessionId: string;
+  chatName: string;
   active: boolean;
   turnCount: number;
   startTime: number;
@@ -691,16 +816,20 @@ export interface SessionsListEntry {
 }
 
 export async function getAllSessionsStatus(): Promise<SessionsListEntry[]> {
-  const entries = Array.from(sessionInfoMap.entries());
+  const registry = await loadSessionRegistry();
+  const entries = Object.values(registry)
+    .filter((record) => record.chatId && record.sessionId && record.tool)
+    .sort((a, b) => b.updatedAt - a.updatedAt)
+    .slice(0, 20);
   // 并行解析每个 session 的 model/effort（cursor 涉及异步 store IO）
   return Promise.all(
-    entries.map(async ([chatId, info]) => {
-      const active = chatSessionMap.get(chatId);
+    entries.map(async (info) => {
       const { model, effort } = await resolveModelEffort(info.tool, info.sessionId);
       return {
-        chatId,
+        chatId: info.chatId,
         sessionId: info.sessionId,
-        active: active !== undefined && !active.stopped,
+        chatName: info.chatName || "",
+        active: info.running === true,
         turnCount: info.turnCount,
         startTime: info.startTime,
         model,

package/src/shared.ts

@@ -1,17 +1,17 @@
 import { execSync } from "node:child_process";
-import {
-  appendFileSync,
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  unlinkSync,
-  writeFileSync,
-} from "node:fs";
-import { createServer } from "node:http";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { inspect } from "node:util";
-import { WebSocketServer, WebSocket } from "ws";
+import {
+  appendFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { createServer } from "node:http";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { inspect } from "node:util";
+import { WebSocketServer, WebSocket } from "ws";
 
 import { printServiceDidNotStart } from "./exit-banner.ts";
 
@@ -355,56 +355,56 @@ export function installCrashLogging(opts: CrashHandlersOptions = {}): InstallCra
 // 文件日志：同时输出到控制台和日志文件
 // ---------------------------------------------------------------------------
 
-export function setupFileLogging(logDir: string, prefix: string): { logPath: string; flush: () => void } {
-  mkdirSync(logDir, { recursive: true });
-  const ts = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  const logPath = join(logDir, `${prefix}-${ts}.log`);
-  writeFileSync(logPath, "", { flag: "a", encoding: "utf8" });
-  const origConsoleLog = console.log.bind(console);
-  const origConsoleError = console.error.bind(console);
-  const formatArg = (arg: unknown): string => {
-    if (typeof arg === "string") return arg;
-    if (arg instanceof Error) return arg.stack ?? arg.message;
-    return inspect(arg, { depth: 6, breakLength: Infinity, maxArrayLength: 200 });
-  };
-  const writeLine = (level: string, args: unknown[]) => {
-    try {
-      const line = args.map(formatArg).join(" ");
-      appendFileSync(logPath, `[${new Date().toISOString()}] [${level}] ${line}\n`, "utf8");
-    } catch (err) {
-      try {
-        appendStartupTrace("fileLog write failed", { level, error: err instanceof Error ? err.message : String(err) });
-      } catch {
-        // 日志系统自身不能影响主流程
-      }
-    }
-  };
-  console.log = (...args: unknown[]) => {
-    writeLine("LOG", args);
-    try {
-      origConsoleLog(...args);
-    } catch {
-      // 控制台输出失败也不能拖垮服务
-    }
-  };
-  console.error = (...args: unknown[]) => {
-    writeLine("ERR", args);
-    try {
-      origConsoleError(...args);
-    } catch {
-      // 控制台输出失败也不能拖垮服务
-    }
-  };
-  const flush = () => {
-    try {
-      appendFileSync(logPath, "", "utf8");
-    } catch (err) {
-      appendStartupTrace("fileLog flush failed", { error: err instanceof Error ? err.message : String(err) });
-    }
-  };
-  origConsoleLog(`Log file: ${logPath}`);
-  return { logPath, flush };
-}
+export function setupFileLogging(logDir: string, prefix: string): { logPath: string; flush: () => void } {
+  mkdirSync(logDir, { recursive: true });
+  const ts = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  const logPath = join(logDir, `${prefix}-${ts}.log`);
+  writeFileSync(logPath, "", { flag: "a", encoding: "utf8" });
+  const origConsoleLog = console.log.bind(console);
+  const origConsoleError = console.error.bind(console);
+  const formatArg = (arg: unknown): string => {
+    if (typeof arg === "string") return arg;
+    if (arg instanceof Error) return arg.stack ?? arg.message;
+    return inspect(arg, { depth: 6, breakLength: Infinity, maxArrayLength: 200 });
+  };
+  const writeLine = (level: string, args: unknown[]) => {
+    try {
+      const line = args.map(formatArg).join(" ");
+      appendFileSync(logPath, `[${new Date().toISOString()}] [${level}] ${line}\n`, "utf8");
+    } catch (err) {
+      try {
+        appendStartupTrace("fileLog write failed", { level, error: err instanceof Error ? err.message : String(err) });
+      } catch {
+        // 日志系统自身不能影响主流程
+      }
+    }
+  };
+  console.log = (...args: unknown[]) => {
+    writeLine("LOG", args);
+    try {
+      origConsoleLog(...args);
+    } catch {
+      // 控制台输出失败也不能拖垮服务
+    }
+  };
+  console.error = (...args: unknown[]) => {
+    writeLine("ERR", args);
+    try {
+      origConsoleError(...args);
+    } catch {
+      // 控制台输出失败也不能拖垮服务
+    }
+  };
+  const flush = () => {
+    try {
+      appendFileSync(logPath, "", "utf8");
+    } catch (err) {
+      appendStartupTrace("fileLog flush failed", { error: err instanceof Error ? err.message : String(err) });
+    }
+  };
+  origConsoleLog(`Log file: ${logPath}`);
+  return { logPath, flush };
+}
 
 // ---------------------------------------------------------------------------
 // 本地 WebSocket 中继服务器（同一端口、多客户端广播）