chatccc 0.2.184 → 0.2.186

package/src/__tests__/orchestrator.test.ts

@@ -9,6 +9,7 @@ import type { SessionInfo, ToolAdapter } from "../adapters/adapter-interface.ts"
 const mockStreamStates = new Map<string, { status: "running" | "done" | "stopped"; finalReply: string }>();
 const mockGetCodexUsageSummary = vi.hoisted(() => vi.fn());
 const mockGetCursorUsageSummary = vi.hoisted(() => vi.fn());
+const mockGetChatGptSubscriptionStatus = vi.hoisted(() => vi.fn());
 
 vi.mock("../im-skills.ts", () => ({
   buildImSkillsPrompt: async () => "",
@@ -64,9 +65,13 @@ vi.mock("../cursor-usage.ts", () => ({
   getCursorUsageSummary: mockGetCursorUsageSummary,
 }));
 
+vi.mock("../chatgpt-subscription.ts", () => ({
+  getChatGptSubscriptionStatus: mockGetChatGptSubscriptionStatus,
+}));
+
 import { handleCommand } from "../orchestrator.ts";
-import {
-  _clearAdapterCacheForTest,
+import {
+  _clearAdapterCacheForTest,
   _resetSessionRegistryFileForTest,
   _resetSessionToolsFileForTest,
   _setAdapterForToolForTest,
@@ -74,10 +79,10 @@ import {
   _setSessionToolsFileForTest,
   loadSessionRegistryForBinding,
   recordSessionRegistry,
-  resetState,
-} from "../session.ts";
-import { activePrompts, resetBindingState } from "../session-chat-binding.ts";
-import { ABD_APPEND_PROMPT } from "../shared-prefix.ts";
+  resetState,
+} from "../session.ts";
+import { activePrompts, resetBindingState } from "../session-chat-binding.ts";
+import { ABD_APPEND_PROMPT } from "../shared-prefix.ts";
 
 function mockPlatform(kind: "wechat" | "feishu" = "wechat"): PlatformAdapter {
   return {
@@ -129,12 +134,13 @@ describe("handleCommand WeChat processing ack", () => {
     mockStreamStates.clear();
     mockGetCodexUsageSummary.mockReset();
     mockGetCursorUsageSummary.mockReset();
-    mockGetCodexUsageSummary.mockResolvedValue({
-      fiveHour: { usedPercent: 0, remainingPercent: 100, resetAtEpochSeconds: null, resetAfterSeconds: null },
-      weekly: { usedPercent: 0, remainingPercent: 100, resetAtEpochSeconds: null, resetAfterSeconds: null },
-      rateLimitResetCreditsAvailable: null,
-      rateLimitResetCredits: null,
-    });
+    mockGetChatGptSubscriptionStatus.mockReset();
+    mockGetCodexUsageSummary.mockResolvedValue({
+      fiveHour: { usedPercent: 0, remainingPercent: 100, resetAtEpochSeconds: null, resetAfterSeconds: null },
+      weekly: { usedPercent: 0, remainingPercent: 100, resetAtEpochSeconds: null, resetAfterSeconds: null },
+      rateLimitResetCreditsAvailable: null,
+      rateLimitResetCredits: null,
+    });
     mockGetCursorUsageSummary.mockResolvedValue({
       billingCycleStart: "1779357999000",
       billingCycleEnd: "1782036399000",
@@ -160,6 +166,12 @@ describe("handleCommand WeChat processing ack", () => {
       displayMessage: "You've hit your usage limit",
       autoBucketModels: ["default"],
     });
+    mockGetChatGptSubscriptionStatus.mockResolvedValue({
+      ok: false,
+      code: "chrome_cdp_disabled",
+      reason: "Chrome CDP guard is disabled in ChatCCC config.",
+      chromeCdp: { enabled: false, port: 15166, status: "skipped" },
+    });
     _setAdapterForToolForTest("claude", mockAdapter());
   });
 
@@ -200,8 +212,8 @@ describe("handleCommand WeChat processing ack", () => {
     expect(platform.sendCard).not.toHaveBeenCalled();
   });
 
-  it("sends the WeChat processing ack after the busy check for normal prompts", async () => {
-    const platform = mockPlatform();
+  it("sends the WeChat processing ack after the busy check for normal prompts", async () => {
+    const platform = mockPlatform();
     await recordSessionRegistry({
       chatId: "wx-chat",
       sessionId: "sid-wechat",
@@ -211,44 +223,44 @@ describe("handleCommand WeChat processing ack", () => {
     });
 
     await handleCommand(platform, "继续说明", "wx-chat", "wx-user", Date.now(), "p2p");
-
-    expect(platform.sendText).toHaveBeenCalledWith("wx-chat", "生成中...");
-  });
-
-  it("treats /abd as a shared prompt prefix in an existing session", async () => {
-    const platform = mockPlatform();
-    const prompt = vi.fn(async function* (_sessionId: string, userText: string) {
-      yield {
-        type: "assistant" as const,
-        blocks: [{ type: "text" as const, text: "done" }],
-      };
-    });
-    _setAdapterForToolForTest("claude", {
-      displayName: "Claude",
-      sessionDescPrefix: "Claude Session:",
-      createSession: vi.fn(async () => ({ sessionId: "sid-wechat" })),
-      prompt,
-      getSessionInfo: async (sessionId: string): Promise<SessionInfo> => ({
-        sessionId,
-        cwd: "F:\\repo",
-      }),
-      closeSession: async () => {},
-    });
-    await recordSessionRegistry({
-      chatId: "wx-chat",
-      sessionId: "sid-wechat",
-      tool: "claude",
-      chatName: "ready-session",
-      running: false,
-    });
-
-    await handleCommand(platform, "/abd帮我分析", "wx-chat", "wx-user", Date.now(), "p2p");
-
-    expect(platform.sendText).toHaveBeenCalledWith("wx-chat", "生成中...");
-    const userText = prompt.mock.calls[0][1];
-    expect(userText).toContain(`[User message]\n帮我分析\n\n---\n${ABD_APPEND_PROMPT}\n[/User message]`);
-    expect(userText).not.toContain("/abd");
-  });
+
+    expect(platform.sendText).toHaveBeenCalledWith("wx-chat", "生成中...");
+  });
+
+  it("treats /abd as a shared prompt prefix in an existing session", async () => {
+    const platform = mockPlatform();
+    const prompt = vi.fn(async function* (_sessionId: string, userText: string) {
+      yield {
+        type: "assistant" as const,
+        blocks: [{ type: "text" as const, text: "done" }],
+      };
+    });
+    _setAdapterForToolForTest("claude", {
+      displayName: "Claude",
+      sessionDescPrefix: "Claude Session:",
+      createSession: vi.fn(async () => ({ sessionId: "sid-wechat" })),
+      prompt,
+      getSessionInfo: async (sessionId: string): Promise<SessionInfo> => ({
+        sessionId,
+        cwd: "F:\\repo",
+      }),
+      closeSession: async () => {},
+    });
+    await recordSessionRegistry({
+      chatId: "wx-chat",
+      sessionId: "sid-wechat",
+      tool: "claude",
+      chatName: "ready-session",
+      running: false,
+    });
+
+    await handleCommand(platform, "/abd帮我分析", "wx-chat", "wx-user", Date.now(), "p2p");
+
+    expect(platform.sendText).toHaveBeenCalledWith("wx-chat", "生成中...");
+    const userText = prompt.mock.calls[0][1];
+    expect(userText).toContain(`[User message]\n帮我分析\n\n---\n${ABD_APPEND_PROMPT}\n[/User message]`);
+    expect(userText).not.toContain("/abd");
+  });
 
   it("does not send the stopped success text until the running prompt really exits", async () => {
     const platform = mockPlatform();
@@ -270,7 +282,7 @@ describe("handleCommand WeChat processing ack", () => {
     expect(platform.sendText).not.toHaveBeenCalledWith("wx-chat", "会话已停止。");
   });
 
-  it("cleans stale Feishu p2p binding, creates a group, and sends the private message as first prompt", async () => {
+  it("cleans stale Feishu p2p binding, creates a group, and sends the private message as first prompt", async () => {
     const platform = mockPlatform("feishu");
     const prompt = vi.fn(async function* (_sessionId: string, userText: string) {
       yield {
@@ -315,40 +327,40 @@ describe("handleCommand WeChat processing ack", () => {
 
     const registry = await loadSessionRegistryForBinding();
     expect(registry["feishu-p2p"]).toBeUndefined();
-    expect(registry["feishu-group"]?.sessionId).toBe("sid-feishu-new");
-  });
-
-  it("auto-creates a Feishu group for /abd private messages and sends the transformed prompt", async () => {
-    const platform = mockPlatform("feishu");
-    const prompt = vi.fn(async function* (_sessionId: string, userText: string) {
-      yield {
-        type: "assistant" as const,
-        blocks: [{ type: "text" as const, text: "done" }],
-      };
-    });
-    _setAdapterForToolForTest("claude", {
-      displayName: "Claude",
-      sessionDescPrefix: "Claude Session:",
-      createSession: vi.fn(async () => ({ sessionId: "sid-feishu-abd" })),
-      prompt,
-      getSessionInfo: async (sessionId: string): Promise<SessionInfo> => ({
-        sessionId,
-        cwd: "F:\\repo",
-      }),
-      closeSession: async () => {},
-    });
-
-    await handleCommand(platform, "/abd帮我看一下日志", "feishu-p2p", "ou-user", Date.now(), "p2p");
-
-    expect(platform.createGroup).toHaveBeenCalledWith(expect.stringContaining("帮我看一下日志"), ["ou-user"]);
-    expect(platform.createGroup).not.toHaveBeenCalledWith(expect.stringContaining("---"), expect.anything());
-    const updateCall = vi.mocked(platform.updateChatInfo).mock.calls[0];
-    expect(updateCall[1]).not.toContain("---");
-    expect(updateCall[1]).not.toContain(ABD_APPEND_PROMPT);
-    const userText = prompt.mock.calls[0][1];
-    expect(userText).toContain(`[User message]\n帮我看一下日志\n\n---\n${ABD_APPEND_PROMPT}\n[/User message]`);
-    expect(userText).not.toContain("/abd");
-  });
+    expect(registry["feishu-group"]?.sessionId).toBe("sid-feishu-new");
+  });
+
+  it("auto-creates a Feishu group for /abd private messages and sends the transformed prompt", async () => {
+    const platform = mockPlatform("feishu");
+    const prompt = vi.fn(async function* (_sessionId: string, userText: string) {
+      yield {
+        type: "assistant" as const,
+        blocks: [{ type: "text" as const, text: "done" }],
+      };
+    });
+    _setAdapterForToolForTest("claude", {
+      displayName: "Claude",
+      sessionDescPrefix: "Claude Session:",
+      createSession: vi.fn(async () => ({ sessionId: "sid-feishu-abd" })),
+      prompt,
+      getSessionInfo: async (sessionId: string): Promise<SessionInfo> => ({
+        sessionId,
+        cwd: "F:\\repo",
+      }),
+      closeSession: async () => {},
+    });
+
+    await handleCommand(platform, "/abd帮我看一下日志", "feishu-p2p", "ou-user", Date.now(), "p2p");
+
+    expect(platform.createGroup).toHaveBeenCalledWith(expect.stringContaining("帮我看一下日志"), ["ou-user"]);
+    expect(platform.createGroup).not.toHaveBeenCalledWith(expect.stringContaining("---"), expect.anything());
+    const updateCall = vi.mocked(platform.updateChatInfo).mock.calls[0];
+    expect(updateCall[1]).not.toContain("---");
+    expect(updateCall[1]).not.toContain(ABD_APPEND_PROMPT);
+    const userText = prompt.mock.calls[0][1];
+    expect(userText).toContain(`[User message]\n帮我看一下日志\n\n---\n${ABD_APPEND_PROMPT}\n[/User message]`);
+    expect(userText).not.toContain("/abd");
+  });
 
   it("cleans stale Feishu p2p binding but keeps valid commands from auto-creating a group", async () => {
     const platform = mockPlatform("feishu");
@@ -370,35 +382,68 @@ describe("handleCommand WeChat processing ack", () => {
 
   it("handles /usage without creating a new Feishu group", async () => {
     const platform = mockPlatform("feishu");
-    mockGetCodexUsageSummary.mockResolvedValue({
-      fiveHour: { usedPercent: 37, remainingPercent: 63, resetAtEpochSeconds: 1781528212, resetAfterSeconds: 10349 },
-      weekly: { usedPercent: 12, remainingPercent: 88, resetAtEpochSeconds: 1781842926, resetAfterSeconds: 325063 },
-      rateLimitResetCreditsAvailable: 2,
-      rateLimitResetCredits: [
-        { grantedAt: "2026-06-12T04:01:47.770016Z", expiresAt: "2026-07-12T04:01:47.770016Z" },
-        { grantedAt: "2026-06-18T00:44:23.904386Z", expiresAt: "2026-07-18T00:44:23.904386Z" },
-      ],
-    });
-
-    await handleCommand(platform, "/usage", "feishu-p2p", "ou-user", Date.now(), "p2p");
-
-    expect(platform.createGroup).not.toHaveBeenCalled();
-    expect(platform.sendCard).not.toHaveBeenCalled();
-    expect(platform.sendRawCard).toHaveBeenCalledTimes(1);
-    const card = JSON.parse(vi.mocked(platform.sendRawCard).mock.calls[0][1]);
-    expect(card.header.title.content).toBe("Codex Usage");
-    expect(card.elements[0].text.content).toContain("2026-07-12");
-    expect(card.elements[0].text.content).toContain("2026-07-18");
-    expect(card.elements[0].text.content).toContain("**主动重置:** 剩余 2 次");
-    expect(card.elements[0].text.content).toContain("**5h:** 已用 37%，剩余 63%，重置:");
-    expect(card.elements[0].text.content).toContain("约 2小时52分钟后");
-    expect(card.elements[0].text.content).toContain("[███████░░░░░░░░░░░░░]");
-    expect(card.elements[0].text.content).toContain("**周:** 已用 12%，剩余 88%，重置:");
-    expect(card.elements[0].text.content).toContain("约 3天18小时17分钟后");
-    expect(card.elements[0].text.content).toContain("[██░░░░░░░░░░░░░░░░░░]");
-    expect(card.elements[2].actions[0].text.content).toBe("发起重置");
-    expect(card.elements[2].actions[0].value).toEqual({ action: "codex_reset_request", availableCount: 2 });
-  });
+    mockGetCodexUsageSummary.mockResolvedValue({
+      fiveHour: { usedPercent: 37, remainingPercent: 63, resetAtEpochSeconds: 1781528212, resetAfterSeconds: 10349 },
+      weekly: { usedPercent: 12, remainingPercent: 88, resetAtEpochSeconds: 1781842926, resetAfterSeconds: 325063 },
+      rateLimitResetCreditsAvailable: 2,
+      rateLimitResetCredits: [
+        { grantedAt: "2026-06-12T04:01:47.770016Z", expiresAt: "2026-07-12T04:01:47.770016Z" },
+        { grantedAt: "2026-06-18T00:44:23.904386Z", expiresAt: "2026-07-18T00:44:23.904386Z" },
+      ],
+    });
+
+    await handleCommand(platform, "/usage", "feishu-p2p", "ou-user", Date.now(), "p2p");
+
+    expect(platform.createGroup).not.toHaveBeenCalled();
+    expect(platform.sendCard).not.toHaveBeenCalled();
+    expect(platform.sendRawCard).toHaveBeenCalledTimes(1);
+    const card = JSON.parse(vi.mocked(platform.sendRawCard).mock.calls[0][1]);
+    expect(card.header.title.content).toBe("Codex Usage");
+    expect(card.elements[0].text.content).toContain("2026-07-12");
+    expect(card.elements[0].text.content).toContain("2026-07-18");
+    expect(card.elements[0].text.content).toContain("**主动重置:** 剩余 2 次");
+    expect(card.elements[0].text.content).not.toContain("ChatGPT 订阅");
+    expect(card.elements[0].text.content).toContain("**5h:** 已用 37%，剩余 63%，重置:");
+    expect(card.elements[0].text.content).toContain("约 2小时52分钟后");
+    expect(card.elements[0].text.content).toContain("[███████░░░░░░░░░░░░░]");
+    expect(card.elements[0].text.content).toContain("**周:** 已用 12%，剩余 88%，重置:");
+    expect(card.elements[0].text.content).toContain("约 3天18小时17分钟后");
+    expect(card.elements[0].text.content).toContain("[██░░░░░░░░░░░░░░░░░░]");
+    expect(card.elements[2].actions[0].text.content).toBe("发起重置");
+    expect(card.elements[2].actions[0].value).toEqual({ action: "codex_reset_request", availableCount: 2 });
+  });
+
+  it("adds ChatGPT subscription expiry to Codex /usage when CDP lookup succeeds", async () => {
+    const platform = mockPlatform("feishu");
+    mockGetCodexUsageSummary.mockResolvedValue({
+      fiveHour: { usedPercent: 37, remainingPercent: 63, resetAtEpochSeconds: 1781528212, resetAfterSeconds: 10349 },
+      weekly: { usedPercent: 12, remainingPercent: 88, resetAtEpochSeconds: 1781842926, resetAfterSeconds: 325063 },
+      rateLimitResetCreditsAvailable: 0,
+      rateLimitResetCredits: [],
+    });
+    mockGetChatGptSubscriptionStatus.mockResolvedValue({
+      ok: true,
+      code: "ok",
+      chromeCdp: { enabled: true, port: 15166, status: "healthy" },
+      chatgpt: { sessionOk: true, maskedEmail: "gg***@gmail.com", sessionExpiresAt: "2026-09-20T09:30:07.340Z" },
+      subscription: {
+        active: true,
+        plan: "chatgptprolite",
+        expiresAt: "2026-07-12T10:20:11+00:00",
+        willRenew: false,
+        purchaseOriginPlatform: "chatgpt_web",
+        remainingDays: 20,
+      },
+    });
+
+    await handleCommand(platform, "/usage", "feishu-p2p", "ou-user", Date.now(), "p2p");
+
+    const card = JSON.parse(vi.mocked(platform.sendRawCard).mock.calls[0][1]);
+    expect(card.elements[0].text.content).toContain("**ChatGPT 订阅:**");
+    expect(card.elements[0].text.content).toContain("- 套餐: chatgptprolite");
+    expect(card.elements[0].text.content).toContain("剩余 20 天");
+    expect(card.elements[0].text.content).toContain("- 自动续费: 否");
+  });
 
   it("handles /usage as Cursor usage in Cursor chats", async () => {
     const platform = mockPlatform("feishu");
@@ -438,7 +483,7 @@ describe("handleCommand WeChat processing ack", () => {
     expect(codexPlatform.sendCard).toHaveBeenCalledWith(
       "feishu-group",
       "Codex Session Ready",
-      expect.stringContaining("发送 **/usage** 查看 Codex 5h/周用量，以及查询/使用主动重置卡。"),
+      expect.stringContaining("发送 **/usage** 查看 Codex 5h/周用量，以及查询/使用主动重置卡。"),
       "green",
     );
 

package/src/__tests__/raw-stream-log.test.ts

@@ -0,0 +1,106 @@
+import { gunzipSync } from "node:zlib";
+import { mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { describe, expect, it } from "vitest";
+
+import {
+  createRawStreamLog,
+  sanitizeLogPathSegment,
+} from "../adapters/raw-stream-log.ts";
+
+describe("raw stream log", () => {
+  it("does nothing when disabled", async () => {
+    const root = await mkdtemp(join(tmpdir(), "chatccc-raw-log-"));
+    try {
+      const log = await createRawStreamLog({
+        enabled: false,
+        rootDir: root,
+        tool: "cursor",
+        sessionId: "sid",
+        label: "turn",
+        maxBytesPerTurn: 1024,
+        retentionDays: 7,
+      });
+      expect(log).toBeNull();
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it("writes gzipped JSONL and can keep the file", async () => {
+    const root = await mkdtemp(join(tmpdir(), "chatccc-raw-log-"));
+    try {
+      const log = await createRawStreamLog({
+        enabled: true,
+        rootDir: root,
+        tool: "cursor",
+        sessionId: "sid/unsafe",
+        label: "turn:1",
+        maxBytesPerTurn: 1024,
+        retentionDays: 7,
+      });
+      expect(log).not.toBeNull();
+      log!.writeLine('{"type":"assistant","text":"hello"}');
+      await log!.close({ keep: true });
+
+      const raw = gunzipSync(await readFile(log!.filePath)).toString("utf-8");
+      expect(raw).toBe('{"type":"assistant","text":"hello"}\n');
+      expect(await stat(log!.filePath)).toBeTruthy();
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it("writes a truncation marker once maxBytesPerTurn is exceeded", async () => {
+    const root = await mkdtemp(join(tmpdir(), "chatccc-raw-log-"));
+    try {
+      const log = await createRawStreamLog({
+        enabled: true,
+        rootDir: root,
+        tool: "cursor",
+        sessionId: "sid",
+        label: "turn",
+        maxBytesPerTurn: 12,
+        retentionDays: 7,
+      });
+      log!.writeLine('{"a":1}');
+      log!.writeLine('{"too":"large"}');
+      log!.writeLine('{"ignored":true}');
+      await log!.close({ keep: true });
+
+      const raw = gunzipSync(await readFile(log!.filePath)).toString("utf-8");
+      expect(raw).toContain('{"a":1}');
+      expect(raw).toContain("chatccc_raw_stream_log_truncated");
+      expect(raw).not.toContain("ignored");
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it("removes the file when keep is false", async () => {
+    const root = await mkdtemp(join(tmpdir(), "chatccc-raw-log-"));
+    try {
+      const log = await createRawStreamLog({
+        enabled: true,
+        rootDir: root,
+        tool: "cursor",
+        sessionId: "sid",
+        label: "turn",
+        maxBytesPerTurn: 1024,
+        retentionDays: 7,
+      });
+      log!.writeLine('{"type":"result"}');
+      await log!.close({ keep: false });
+      await expect(stat(log!.filePath)).rejects.toThrow();
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it("sanitizes path segments", () => {
+    expect(sanitizeLogPathSegment("../sid:1/2")).toBe("sid_1_2");
+    expect(sanitizeLogPathSegment("")).toBe("unknown");
+  });
+});

package/src/__tests__/web-ui.test.ts

@@ -33,6 +33,22 @@ describe("unflattenConfig", () => {
       },
     });
   });
+
+  it("maps Chrome CDP guard fields into chromeDevtools config", () => {
+    expect(
+      unflattenConfig({
+        CHATCCC_CHROME_DEVTOOLS_ENABLED: true,
+        CHATCCC_CHROME_DEVTOOLS_PORT: "15166",
+        CHATCCC_CHROME_DEVTOOLS_PATH: "C:/Program Files/Google/Chrome/Application/chrome.exe",
+      }),
+    ).toEqual({
+      chromeDevtools: {
+        enabled: true,
+        port: 15166,
+        chromePath: "C:/Program Files/Google/Chrome/Application/chrome.exe",
+      },
+    });
+  });
 });
 
 describe("dashboard edit modal", () => {

package/src/adapters/cursor-adapter.ts

@@ -20,12 +20,16 @@ import type {
   SessionInfo,
 } from "./adapter-interface.ts";
 import { parseUserCommand } from "./adapter-interface.ts";
-import { CURSOR_AGENT_COMMAND, CURSOR_AGENT_ARGS } from "../config.ts";
+import { config, CURSOR_AGENT_COMMAND, CURSOR_AGENT_ARGS, RAW_STREAM_LOGS_DIR } from "../config.ts";
 import {
   defaultCursorSessionMetaStore,
   type CursorSessionMetaStore,
 } from "./cursor-session-meta-store.ts";
-import { killProcessTree } from "./proc-tree-kill.ts";
+import { killProcessTree } from "./proc-tree-kill.ts";
+import {
+  createRawStreamLog,
+  type RawStreamLogHandle,
+} from "./raw-stream-log.ts";
 
 // ---------------------------------------------------------------------------
 // 特殊注入提示
@@ -344,11 +348,12 @@ function spawnAgent(
   return proc;
 }
 
-async function* readJsonLines(
-  proc: ChildProcess,
-  signal?: AbortSignal,
-  debugTag?: string,
-): AsyncGenerator<CursorMessageLine> {
+async function* readJsonLines(
+  proc: ChildProcess,
+  signal?: AbortSignal,
+  debugTag?: string,
+  rawLog?: RawStreamLogHandle | null,
+): AsyncGenerator<CursorMessageLine> {
   const tag = debugTag ?? "cursor";
   const rl = createInterface({ input: proc.stdout!, crlfDelay: Infinity });
   // abort 时主动 close readline，避免等待 Windows 管道自然关闭（可能延迟数分钟）
@@ -359,9 +364,10 @@ async function* readJsonLines(
     for await (const line of rl) {
       if (signal?.aborted) break;
       lineCount++;
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-      try {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      rawLog?.writeLine(trimmed);
+      try {
         yield JSON.parse(trimmed) as CursorMessageLine;
       } catch { /* 非 JSON 行静默跳过 */ }
     }
@@ -426,15 +432,32 @@ class CursorAdapter implements ToolAdapter {
       cmd.mode ?? undefined,
     );
     this.activeProcs.add(proc);
-    if (proc.pid !== undefined) options?.onProcessStart?.({ pid: proc.pid });
+    if (proc.pid !== undefined) options?.onProcessStart?.({ pid: proc.pid });
+
+    const rawLogConfig = config.rawStreamLogs.cursor;
+    let rawLog: RawStreamLogHandle | null = null;
+    try {
+      rawLog = await createRawStreamLog({
+        enabled: rawLogConfig.enabled,
+        rootDir: RAW_STREAM_LOGS_DIR,
+        tool: "cursor",
+        sessionId,
+        label: "prompt",
+        maxBytesPerTurn: rawLogConfig.maxBytesPerTurn,
+        retentionDays: rawLogConfig.retentionDays,
+      });
+    } catch (err) {
+      console.error(`[Cursor raw stream log] create failed: ${(err as Error).message}`);
+    }
 
     // 见 codex-adapter.ts 同位置注释：spawn 用了 shell:true，必须杀整棵树，
     // 否则 abort 后真正在跑的孙进程 cursor-agent 还会继续输出 & 占用资源。
-    const onAbort = () => { void killProcessTree(proc.pid); };
-    signal?.addEventListener("abort", onAbort, { once: true });
-
-    try {
-      for await (const raw of readJsonLines(proc, signal, sessionId)) {
+    const onAbort = () => { void killProcessTree(proc.pid); };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    let sawResult = false;
+
+    try {
+      for await (const raw of readJsonLines(proc, signal, sessionId, rawLog)) {
         if (signal?.aborted) break;
         if (
           raw.type === "system" &&
@@ -450,15 +473,17 @@ class CursorAdapter implements ToolAdapter {
         if (normalized) yield normalized;
 
         // result 是流末事件，收到后立即结束进程，防止 CLI 僵死导致 readline 挂起。
-        if (raw.type === "result") {
-          void killProcessTree(proc.pid);
+        if (raw.type === "result") {
+          sawResult = true;
+          void killProcessTree(proc.pid);
           break;
         }
       }
     } finally {
       signal?.removeEventListener("abort", onAbort);
-      await killProcessTree(proc.pid);
-      this.activeProcs.delete(proc);
+      await killProcessTree(proc.pid);
+      await rawLog?.close({ keep: rawLogConfig.keepCompleted || signal?.aborted === true || !sawResult });
+      this.activeProcs.delete(proc);
       if (proc.pid !== undefined) options?.onProcessExit?.({ pid: proc.pid });
       console.log(`[Cursor debug] prompt end: sessionId=${sessionId}, signalAborted=${signal?.aborted ?? false}`);
     }
@@ -494,4 +519,4 @@ export function createCursorAdapter(
   options: CreateCursorAdapterOptions = {},
 ): ToolAdapter {
   return new CursorAdapter(options.metaStore ?? defaultCursorSessionMetaStore, options.model);
-}
+}