chatccc 0.2.41 → 0.2.42

package/src/__tests__/crash-logging.test.ts

@@ -1,9 +1,9 @@
-import { mkdtemp, readFile, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { describe, it, expect, vi } from "vitest";
-
-import { buildCrashLoggingHandlers, installCrashLogging, setupFileLogging } from "../shared.ts";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, it, expect, vi } from "vitest";
+
+import { buildCrashLoggingHandlers, installCrashLogging, setupFileLogging } from "../shared.ts";
 
 describe("buildCrashLoggingHandlers", () => {
   it("uncaughtException: 写诊断、刷新日志、调用 onFatal", () => {
@@ -144,7 +144,7 @@ describe("buildCrashLoggingHandlers", () => {
   });
 });
 
-describe("installCrashLogging", () => {
+describe("installCrashLogging", () => {
   it("注册所有相关事件监听器", () => {
     const before = {
       uncaught: process.listenerCount("uncaughtException"),
@@ -209,58 +209,58 @@ describe("installCrashLogging", () => {
     } finally {
       cleanup();
     }
-  });
-});
-
-describe("setupFileLogging", () => {
-  it("flush 后继续写日志不会触发 write after end，且日志已落盘", async () => {
-    const originalLog = console.log;
-    const originalError = console.error;
-    console.log = vi.fn() as never;
-    console.error = vi.fn() as never;
-    const dir = await mkdtemp(join(tmpdir(), "chatccc-log-"));
-
-    try {
-      const fileLog = setupFileLogging(dir, "index");
-
-      console.log("before flush");
-      fileLog.flush();
-
-      expect(() => console.error("after flush")).not.toThrow();
-      fileLog.flush();
-
-      const content = await readFile(fileLog.logPath, "utf8");
-      expect(content).toContain("[LOG] before flush");
-      expect(content).toContain("[ERR] after flush");
-    } finally {
-      console.log = originalLog;
-      console.error = originalError;
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-
-  it("日志参数无法 JSON 序列化时也不会让 console 调用抛错", async () => {
-    const originalLog = console.log;
-    const originalError = console.error;
-    console.log = vi.fn() as never;
-    console.error = vi.fn() as never;
-    const dir = await mkdtemp(join(tmpdir(), "chatccc-log-"));
-
-    try {
-      const fileLog = setupFileLogging(dir, "index");
-      const circular: Record<string, unknown> = { name: "root" };
-      circular.self = circular;
-
-      expect(() => console.log("circular", circular)).not.toThrow();
-      fileLog.flush();
-
-      const content = await readFile(fileLog.logPath, "utf8");
-      expect(content).toContain("[LOG] circular");
-      expect(content).toContain("self");
-    } finally {
-      console.log = originalLog;
-      console.error = originalError;
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-});
+  });
+});
+
+describe("setupFileLogging", () => {
+  it("flush 后继续写日志不会触发 write after end，且日志已落盘", async () => {
+    const originalLog = console.log;
+    const originalError = console.error;
+    console.log = vi.fn() as never;
+    console.error = vi.fn() as never;
+    const dir = await mkdtemp(join(tmpdir(), "chatccc-log-"));
+
+    try {
+      const fileLog = setupFileLogging(dir, "index");
+
+      console.log("before flush");
+      fileLog.flush();
+
+      expect(() => console.error("after flush")).not.toThrow();
+      fileLog.flush();
+
+      const content = await readFile(fileLog.logPath, "utf8");
+      expect(content).toContain("[LOG] before flush");
+      expect(content).toContain("[ERR] after flush");
+    } finally {
+      console.log = originalLog;
+      console.error = originalError;
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("日志参数无法 JSON 序列化时也不会让 console 调用抛错", async () => {
+    const originalLog = console.log;
+    const originalError = console.error;
+    console.log = vi.fn() as never;
+    console.error = vi.fn() as never;
+    const dir = await mkdtemp(join(tmpdir(), "chatccc-log-"));
+
+    try {
+      const fileLog = setupFileLogging(dir, "index");
+      const circular: Record<string, unknown> = { name: "root" };
+      circular.self = circular;
+
+      expect(() => console.log("circular", circular)).not.toThrow();
+      fileLog.flush();
+
+      const content = await readFile(fileLog.logPath, "utf8");
+      expect(content).toContain("[LOG] circular");
+      expect(content).toContain("self");
+    } finally {
+      console.log = originalLog;
+      console.error = originalError;
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+});

package/src/__tests__/session.test.ts

@@ -1,4 +1,7 @@
 import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
 import {
   chatSessionMap,
   sessionInfoMap,
@@ -7,9 +10,12 @@ import {
   resetState,
   getSessionStatus,
   getAllSessionsStatus,
+  recordSessionRegistry,
   accumulateBlockContent,
   pickFinalReply,
   UNKNOWN_MODEL_PLACEHOLDER,
+  _setSessionRegistryFileForTest,
+  _resetSessionRegistryFileForTest,
   _setAdapterForToolForTest,
   _clearAdapterCacheForTest,
 } from "../session.ts";
@@ -196,39 +202,146 @@ describe("getSessionStatus", () => {
 });
 
 describe("getAllSessionsStatus", () => {
-  beforeEach(() => {
+  let registryFile = "";
+
+  beforeEach(async () => {
     chatSessionMap.clear();
     sessionInfoMap.clear();
+    const dir = await mkdtemp(join(tmpdir(), "chatccc-session-registry-"));
+    registryFile = join(dir, "session-registry.json");
+    _setSessionRegistryFileForTest(registryFile);
   });
 
-  afterEach(() => {
+  afterEach(async () => {
     _clearAdapterCacheForTest();
+    _resetSessionRegistryFileForTest();
+    if (registryFile) {
+      await rm(dirname(registryFile), { recursive: true, force: true });
+    }
   });
 
   it("returns empty array when no sessions", async () => {
     await expect(getAllSessionsStatus()).resolves.toEqual([]);
   });
 
-  it("returns statuses for all recorded sessions", async () => {
+  it("does not read memory-only sessions", async () => {
     mockSessionInfo("chat1", { sessionId: "s1" });
     mockSessionInfo("chat2", { sessionId: "s2" });
     mockActiveSession("chat1");
+
+    const result = await getAllSessionsStatus();
+    expect(result).toEqual([]);
+  });
+
+  it("returns statuses from disk registry", async () => {
+    await recordSessionRegistry({
+      chatId: "chat1",
+      sessionId: "s1",
+      tool: "claude",
+      chatName: "test-chat-1",
+      turnCount: 2,
+      startTime: 1000,
+      updatedAt: 2000,
+      running: true,
+    });
+    await recordSessionRegistry({
+      chatId: "chat2",
+      sessionId: "s2",
+      tool: "claude",
+      chatName: "test-chat-2",
+      turnCount: 0,
+      startTime: 900,
+      updatedAt: 1900,
+      running: false,
+    });
+
     const result = await getAllSessionsStatus();
     expect(result).toHaveLength(2);
+    expect(result[0].chatId).toBe("chat1");
+    expect(result[0].active).toBe(true);
+    expect(result[0].turnCount).toBe(2);
+    expect(result[0].chatName).toBe("test-chat-1");
+    expect(result[1].chatId).toBe("chat2");
+    expect(result[1].active).toBe(false);
+    expect(result[1].chatName).toBe("test-chat-2");
+  });
+
+  it("returns recent disk sessions by updatedAt desc, limited to 20", async () => {
+    for (let i = 0; i < 25; i++) {
+      await recordSessionRegistry({
+        chatId: `chat-${i}`,
+        sessionId: `sid-${i}`,
+        tool: "claude",
+        startTime: i,
+        updatedAt: 1000 + i,
+      });
+    }
+
+    const result = await getAllSessionsStatus();
+    expect(result).toHaveLength(20);
+    expect(result[0].chatId).toBe("chat-24");
+    expect(result[19].chatId).toBe("chat-5");
+    expect(result.some((r) => r.chatId === "chat-4")).toBe(false);
+  });
+
+  it("marks disk-running sessions as active without checking chatSessionMap", async () => {
+    await recordSessionRegistry({
+      chatId: "chat1",
+      sessionId: "s1",
+      tool: "claude",
+      running: true,
+      updatedAt: 1000,
+    });
+
+    const result = await getAllSessionsStatus();
     expect(result.find(r => r.chatId === "chat1")!.active).toBe(true);
-    expect(result.find(r => r.chatId === "chat2")!.active).toBe(false);
   });
 
-  it("marks stopped sessions as not active", async () => {
-    mockSessionInfo("chat1");
-    mockActiveSession("chat1", { stopped: true });
+  it("persists chatName across updates and defaults to empty string when not set", async () => {
+    await recordSessionRegistry({
+      chatId: "chat-a",
+      sessionId: "sa",
+      tool: "claude",
+      chatName: "My Chat",
+      updatedAt: 100,
+    });
+    // Update without chatName — should keep existing
+    await recordSessionRegistry({
+      chatId: "chat-a",
+      sessionId: "sa",
+      tool: "claude",
+      updatedAt: 200,
+    });
+    const result = await getAllSessionsStatus();
+    expect(result.find(r => r.chatId === "chat-a")!.chatName).toBe("My Chat");
+  });
+
+  it("chatName defaults to empty string for sessions without it", async () => {
+    await recordSessionRegistry({
+      chatId: "chat-b",
+      sessionId: "sb",
+      tool: "claude",
+      updatedAt: 100,
+    });
     const result = await getAllSessionsStatus();
-    expect(result[0].active).toBe(false);
+    expect(result.find(r => r.chatId === "chat-b")!.chatName).toBe("");
   });
 
   it("混合 claude + cursor 会话：各自取自己来源的 model/effort", async () => {
-    mockSessionInfo("chat-c", { sessionId: "sid-c", tool: "claude" });
-    mockSessionInfo("chat-x", { sessionId: "sid-x", tool: "cursor" });
+    await recordSessionRegistry({
+      chatId: "chat-c",
+      sessionId: "sid-c",
+      tool: "claude",
+      chatName: "claude-chat",
+      updatedAt: 100,
+    });
+    await recordSessionRegistry({
+      chatId: "chat-x",
+      sessionId: "sid-x",
+      tool: "cursor",
+      chatName: "cursor-chat",
+      updatedAt: 200,
+    });
     _setAdapterForToolForTest(
       "cursor",
       mockAdapter((sid) =>
@@ -473,4 +586,4 @@ describe("pickFinalReply", () => {
       }),
     ).toBe("");
   });
-});
+});

package/src/cards.ts

@@ -254,6 +254,7 @@ export function buildCdCard(
 // 所有会话列表卡片（Claude Code 优先，然后 Cursor）
 export function buildSessionsCard(sessions: Array<{
   sessionId: string;
+  chatName: string;
   active: boolean;
   turnCount: number;
   elapsedSeconds: number | null;
@@ -274,7 +275,7 @@ export function buildSessionsCard(sessions: Array<{
       config: { wide_screen_mode: true },
       header: { template: "blue", title: { content: "所有会话", tag: "plain_text" } },
       elements: [
-        { tag: "div", text: { tag: "lark_md", content: `当前没有会话记录。\n\n使用 **/new**（默认 ${defaultToolLabel}）、**/new claude**、**/new cursor** 或 **/new codex** 创建新会话。` } },
+        { tag: "div", text: { tag: "lark_md", content: `当前没有会话记录。\n\n使用 **/new**（默认 ${defaultToolLabel}）、**/new claude**、**/new cursor** 或 **/new codex** 创建新会话。\n创建后可在任意会话群内发送 **/sessions** 查看列表，用 **/session 数字** 切换会话。` } },
         { tag: "hr" },
         { tag: "action", actions: [{ tag: "button", text: { tag: "plain_text", content: "收起" }, type: "default", value: { action: "close" } }] },
       ],
@@ -291,7 +292,8 @@ export function buildSessionsCard(sessions: Array<{
       extra = ` | 本轮: ${mins}分${secs}秒`;
     }
     const toolLabel = s.tool === "cursor" ? "Cursor" : s.tool === "codex" ? "Codex" : "Claude Code";
-    return `**${i + 1}.** \`${shortId}\` ${status} | 工具: ${toolLabel} | 轮数: ${s.turnCount} | ${s.model}${extra}`;
+    const namePart = s.chatName ? `**${s.chatName}** ` : "";
+    return `**${i + 1}.** ${namePart}\`${shortId}\` ${status} | 工具: ${toolLabel} | 轮数: ${s.turnCount} | ${s.model}${extra}`;
   };
 
   const lines: string[] = [`共 **${sessions.length}** 个会话:`, ""];
@@ -326,7 +328,7 @@ export function buildSessionsCard(sessions: Array<{
     elements: [
       { tag: "div", text: { tag: "lark_md", content: lines.join("\n") } },
       { tag: "hr" },
-      { tag: "div", text: { tag: "lark_md", content: "在会话群内发送 **/forget** 可重置当前会话（创建新 Session，保留工作目录和群聊）。" } },
+      { tag: "div", text: { tag: "lark_md", content: "在会话群内发送 **/forget** 可重置当前会话（创建新 Session，保留工作目录和群聊）。\n发送 **/session 数字**（如 `/session 1`）可将当前群聊切换到列表中对应编号的会话。" } },
       { tag: "hr" },
       {
         tag: "action",

package/src/index.ts

@@ -102,6 +102,7 @@ import {
   resetState,
   resumeAndPrompt,
   sessionInfoMap,
+  recordSessionRegistry,
   getAdapterForTool,
 } from "./session.ts";
 
@@ -309,7 +310,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 +328,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 +417,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 +485,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 +541,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,7 +568,7 @@ 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);
@@ -590,12 +602,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 +622,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 +656,11 @@ 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 = isUntitledSessionChatName(chatInfo.name)
+          ? sessionChatName("新会话", cwd)
+          : chatInfo.name;
+        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,88 @@ 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 = isUntitledSessionChatName(chatInfo.name)
+          ? sessionChatName("新会话", cwd2)
+          : chatInfo.name;
+        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) {
@@ -1011,7 +1114,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 */ }