chatccc 0.2.185 → 0.2.186

package/agent-prompts/cursor_specific.md

@@ -1,3 +1,14 @@
 ## 计划/问答模式权限规则
 
-如果用户消息以 `/plan` 或 `/ask` 开头，说明当前处于只读模式。**遇到任何需要用户同意的权限请求时，不要向用户申请权限，立即调用 stop-stuck-loop 接口提前结束本轮会话。**
+如果用户消息以 `/plan` 或 `/ask` 开头，说明当前处于只读模式。**遇到任何需要用户同意的权限请求时，不要向用户申请权限，立即调用 stop-stuck-loop 接口提前结束本轮会话。**
+
+## 用户问题澄清规则
+
+当需要在开始实现前向用户确认问题、让用户做选择，或用户要求“从第一性原理出发挖掘真实需求 / 判断需求是否合理 / 开始实现前有什么问题要问我”时，**不要调用 `AskQuestion`、多选表单或任何结构化选择工具**。
+
+必须直接用普通文本回复用户：
+
+- 先简要说明你理解到的真实需求和你对合理性的判断。
+- 再列出需要用户确认的问题；如果有推荐选项，就用文本说明“我建议 X，原因是 Y”。
+- 问题数量尽量少，只问会影响实现边界、风险或不可逆决策的问题。
+- 不要把这些问题放进工具调用参数里，也不要只在卡片/工具结果中呈现。

package/config.sample.json

@@ -12,10 +12,30 @@
     "port": 15166,
     "chromePath": ""
   },
-  "port": 18080,
-  "gitTimeoutSeconds": 180,
-  "allowInterrupt": false,
-  "claude": {
+  "port": 18080,
+  "gitTimeoutSeconds": 180,
+  "allowInterrupt": false,
+  "rawStreamLogs": {
+    "claude": {
+      "enabled": false,
+      "maxBytesPerTurn": 52428800,
+      "retentionDays": 7,
+      "keepCompleted": false
+    },
+    "cursor": {
+      "enabled": false,
+      "maxBytesPerTurn": 52428800,
+      "retentionDays": 7,
+      "keepCompleted": false
+    },
+    "codex": {
+      "enabled": false,
+      "maxBytesPerTurn": 52428800,
+      "retentionDays": 7,
+      "keepCompleted": false
+    }
+  },
+  "claude": {
     "enabled": false,
     "defaultAgent": true,
     "model": "",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chatccc",
-  "version": "0.2.185",
+  "version": "0.2.186",
   "description": "Feishu bot bridge for Claude Code",
   "license": "Apache-2.0",
   "type": "module",

package/src/__tests__/config-reload.test.ts

@@ -41,10 +41,15 @@ const baseAppConfig: AppConfig = {
   feishu: { appId: "INITIAL_APP", appSecret: "INITIAL_SECRET" },
   platforms: { feishu: { enabled: true }, ilink: { enabled: true } },
   chromeDevtools: { enabled: false, port: 15166, chromePath: "" },
-  port: 18080,
-  gitTimeoutSeconds: 180,
-  allowInterrupt: false,
-  claude: {
+  port: 18080,
+  gitTimeoutSeconds: 180,
+  allowInterrupt: false,
+  rawStreamLogs: {
+    claude: { enabled: false, maxBytesPerTurn: 52_428_800, retentionDays: 7, keepCompleted: false },
+    cursor: { enabled: false, maxBytesPerTurn: 52_428_800, retentionDays: 7, keepCompleted: false },
+    codex: { enabled: false, maxBytesPerTurn: 52_428_800, retentionDays: 7, keepCompleted: false },
+  },
+  claude: {
     enabled: true,
     defaultAgent: true,
     model: "initial-model",

package/src/__tests__/config-sample.test.ts

@@ -28,7 +28,7 @@ describe("config.sample.json", () => {
     expect(sample.claude?.subagentModel).toBe("");
   });
 
-  it("keeps Chrome CDP guard disabled by default with port 15166", () => {
+  it("keeps Chrome CDP guard disabled by default with port 15166", () => {
     const configSamplePath = join(process.cwd(), "config.sample.json");
     const sample = JSON.parse(readFileSync(configSamplePath, "utf8")) as {
       chromeDevtools?: { enabled?: unknown; port?: unknown; chromePath?: unknown };
@@ -36,6 +36,25 @@ describe("config.sample.json", () => {
 
     expect(sample.chromeDevtools?.enabled).toBe(false);
     expect(sample.chromeDevtools?.port).toBe(15166);
-    expect(sample.chromeDevtools?.chromePath).toBe("");
-  });
-});
+    expect(sample.chromeDevtools?.chromePath).toBe("");
+  });
+
+  it("keeps raw stream logs disabled by default for every agent", () => {
+    const configSamplePath = join(process.cwd(), "config.sample.json");
+    const sample = JSON.parse(readFileSync(configSamplePath, "utf8")) as {
+      rawStreamLogs?: Record<string, {
+        enabled?: unknown;
+        maxBytesPerTurn?: unknown;
+        retentionDays?: unknown;
+        keepCompleted?: unknown;
+      }>;
+    };
+
+    for (const tool of ["claude", "cursor", "codex"]) {
+      expect(sample.rawStreamLogs?.[tool]?.enabled).toBe(false);
+      expect(sample.rawStreamLogs?.[tool]?.maxBytesPerTurn).toBe(52_428_800);
+      expect(sample.rawStreamLogs?.[tool]?.retentionDays).toBe(7);
+      expect(sample.rawStreamLogs?.[tool]?.keepCompleted).toBe(false);
+    }
+  });
+});

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/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);
-}
+}

package/src/adapters/raw-stream-log.ts

@@ -0,0 +1,124 @@
+import { createWriteStream, type Dirent } from "node:fs";
+import { mkdir, readdir, rm, stat, unlink } from "node:fs/promises";
+import { once } from "node:events";
+import { join } from "node:path";
+import { createGzip } from "node:zlib";
+
+export interface RawStreamLogOptions {
+  enabled: boolean;
+  rootDir: string;
+  tool: string;
+  sessionId: string;
+  label: string;
+  maxBytesPerTurn: number;
+  retentionDays: number;
+}
+
+export interface RawStreamLogHandle {
+  filePath: string;
+  writeLine(line: string): void;
+  close(options: { keep: boolean }): Promise<void>;
+}
+
+export function sanitizeLogPathSegment(value: string): string {
+  const safe = value.replace(/[^a-zA-Z0-9._-]+/g, "_").replace(/^[._]+|_+$/g, "");
+  return safe || "unknown";
+}
+
+async function cleanupOldRawStreamLogs(rootDir: string, retentionDays: number): Promise<void> {
+  if (!Number.isFinite(retentionDays) || retentionDays <= 0) return;
+  const cutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1000;
+
+  const visit = async (dir: string): Promise<void> => {
+    let entries: Dirent[];
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+
+    await Promise.all(entries.map(async (entry) => {
+      const path = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await visit(path);
+        try {
+          await rm(path, { recursive: false });
+        } catch {
+          // Directory is not empty or already gone.
+        }
+        return;
+      }
+
+      if (!entry.isFile()) return;
+      try {
+        const info = await stat(path);
+        if (info.mtimeMs < cutoff) await rm(path, { force: true });
+      } catch {
+        // Best-effort cleanup only.
+      }
+    }));
+  };
+
+  await visit(rootDir);
+}
+
+export async function createRawStreamLog(options: RawStreamLogOptions): Promise<RawStreamLogHandle | null> {
+  if (!options.enabled) return null;
+
+  const maxBytes = Math.max(0, Math.floor(options.maxBytesPerTurn));
+  const tool = sanitizeLogPathSegment(options.tool);
+  const session = sanitizeLogPathSegment(options.sessionId);
+  const label = sanitizeLogPathSegment(options.label);
+  const dir = join(options.rootDir, tool, session);
+  await mkdir(dir, { recursive: true });
+  void cleanupOldRawStreamLogs(join(options.rootDir, tool), options.retentionDays);
+
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const filePath = join(dir, `${timestamp}-${label}.jsonl.gz`);
+  const output = createWriteStream(filePath);
+  const gzip = createGzip();
+  gzip.pipe(output);
+
+  let bytes = 0;
+  let truncated = false;
+  let ended = false;
+
+  const writeLine = (line: string): void => {
+    if (ended || truncated) return;
+    const payload = `${line}\n`;
+    const payloadBytes = Buffer.byteLength(payload, "utf-8");
+    if (maxBytes > 0 && bytes + payloadBytes > maxBytes) {
+      const marker = JSON.stringify({
+        type: "chatccc_raw_stream_log_truncated",
+        reason: "max_bytes_per_turn_exceeded",
+        maxBytesPerTurn: maxBytes,
+        writtenBytes: bytes,
+      });
+      gzip.write(`${marker}\n`);
+      truncated = true;
+      return;
+    }
+    bytes += payloadBytes;
+    gzip.write(payload);
+  };
+
+  const close = async ({ keep }: { keep: boolean }): Promise<void> => {
+    if (ended) return;
+    ended = true;
+    gzip.end();
+    try {
+      await once(output, "finish");
+    } catch {
+      // Ignore close errors; caller cannot recover from debug log failures.
+    }
+    if (!keep) {
+      try {
+        await unlink(filePath);
+      } catch {
+        // Best-effort cleanup only.
+      }
+    }
+  };
+
+  return { filePath, writeLine, close };
+}

package/src/config.ts

@@ -39,9 +39,10 @@ export const USER_DATA_DIR = join(homedir(), ".chatccc");
 export const PID_FILE = join(USER_DATA_DIR, "state", "runtime.pid");
 
 export const LOG_DIR = join(USER_DATA_DIR, "logs");
-export const fileLog = setupFileLogging(LOG_DIR, "index");
-
-export const CHAT_LOGS_DIR = join(USER_DATA_DIR, "state", "chat_logs");
+export const fileLog = setupFileLogging(LOG_DIR, "index");
+
+export const CHAT_LOGS_DIR = join(USER_DATA_DIR, "state", "chat_logs");
+export const RAW_STREAM_LOGS_DIR = join(LOG_DIR, "raw-streams");
 
 export async function appendChatLog(chatId: string, sender: string, text: string): Promise<void> {
   try {
@@ -113,27 +114,41 @@ export interface PlatformsConfig {
   ilink: PlatformConfig;
 }
 
-export interface ChromeDevtoolsConfig {
+export interface ChromeDevtoolsConfig {
   /** 是否由 ChatCCC 守护一个常驻 Chrome CDP 实例 */
   enabled: boolean;
   /** Chrome remote debugging 端口，默认 15166 */
   port: number;
   /** Chrome 可执行文件路径；留空时按常见安装位置自动探测 */
-  chromePath: string;
-}
-
-export interface AppConfig {
+  chromePath: string;
+}
+
+export interface RawStreamAgentLogConfig {
+  enabled: boolean;
+  maxBytesPerTurn: number;
+  retentionDays: number;
+  keepCompleted: boolean;
+}
+
+export interface RawStreamLogsConfig {
+  claude: RawStreamAgentLogConfig;
+  cursor: RawStreamAgentLogConfig;
+  codex: RawStreamAgentLogConfig;
+}
+
+export interface AppConfig {
   feishu: FeishuConfig;
   platforms: PlatformsConfig;
   chromeDevtools: ChromeDevtoolsConfig;
   port: number;
-  gitTimeoutSeconds: number;
-  /** 若为 false，AI 生成过程中用户发送消息不会打断，须先点「停止」再发送新消息 */
-  allowInterrupt: boolean;
-  claude: ClaudeConfig;
-  cursor: CursorConfig;
-  codex: CodexConfig;
-}
+  gitTimeoutSeconds: number;
+  /** 若为 false，AI 生成过程中用户发送消息不会打断，须先点「停止」再发送新消息 */
+  allowInterrupt: boolean;
+  rawStreamLogs: RawStreamLogsConfig;
+  claude: ClaudeConfig;
+  cursor: CursorConfig;
+  codex: CodexConfig;
+}
 
 export type AgentTool = "claude" | "cursor" | "codex";
 export const AGENT_TOOLS: AgentTool[] = ["claude", "cursor", "codex"];
@@ -343,20 +358,42 @@ function normalizeCursorAvatarBatteryMode(raw: unknown): CursorAvatarBatteryMode
   return raw === "onDemandUse" ? "onDemandUse" : "apiPercent";
 }
 
-function normalizeCursorOnDemandMonthlyBudget(raw: unknown): number {
-  const value = typeof raw === "string" ? Number(raw.trim()) : Number(raw);
-  return Number.isFinite(value) && value > 0 ? value : 1000;
-}
-
-function loadConfig(): AppConfig {
-  const defaults: AppConfig = {
-    feishu: { appId: "", appSecret: "" },
-    platforms: { feishu: { enabled: true }, ilink: { enabled: true } },
-    chromeDevtools: { enabled: false, port: 15166, chromePath: "" },
-    port: 18080,
-    gitTimeoutSeconds: 180,
-    allowInterrupt: false,
-    claude: { enabled: false, defaultAgent: true, model: "", subagentModel: "", effort: "", apiKey: "", baseUrl: "", maxTurn: 0 },
+function normalizeCursorOnDemandMonthlyBudget(raw: unknown): number {
+  const value = typeof raw === "string" ? Number(raw.trim()) : Number(raw);
+  return Number.isFinite(value) && value > 0 ? value : 1000;
+}
+
+function normalizePositiveInteger(raw: unknown, fallback: number): number {
+  const value = typeof raw === "string" ? Number(raw.trim()) : Number(raw);
+  return Number.isInteger(value) && value > 0 ? value : fallback;
+}
+
+function normalizeRawStreamAgentLogConfig(raw: unknown): RawStreamAgentLogConfig {
+  const obj = typeof raw === "object" && raw !== null
+    ? raw as Record<string, unknown>
+    : {};
+  return {
+    enabled: typeof obj.enabled === "boolean" ? obj.enabled : false,
+    maxBytesPerTurn: normalizePositiveInteger(obj.maxBytesPerTurn, 50 * 1024 * 1024),
+    retentionDays: normalizePositiveInteger(obj.retentionDays, 7),
+    keepCompleted: typeof obj.keepCompleted === "boolean" ? obj.keepCompleted : false,
+  };
+}
+
+function loadConfig(): AppConfig {
+  const defaults: AppConfig = {
+    feishu: { appId: "", appSecret: "" },
+    platforms: { feishu: { enabled: true }, ilink: { enabled: true } },
+    chromeDevtools: { enabled: false, port: 15166, chromePath: "" },
+    port: 18080,
+    gitTimeoutSeconds: 180,
+    allowInterrupt: false,
+    rawStreamLogs: {
+      claude: { enabled: false, maxBytesPerTurn: 50 * 1024 * 1024, retentionDays: 7, keepCompleted: false },
+      cursor: { enabled: false, maxBytesPerTurn: 50 * 1024 * 1024, retentionDays: 7, keepCompleted: false },
+      codex: { enabled: false, maxBytesPerTurn: 50 * 1024 * 1024, retentionDays: 7, keepCompleted: false },
+    },
+    claude: { enabled: false, defaultAgent: true, model: "", subagentModel: "", effort: "", apiKey: "", baseUrl: "", maxTurn: 0 },
     cursor: {
       enabled: false,
       defaultAgent: false,
@@ -416,9 +453,10 @@ function loadConfig(): AppConfig {
       avatarBatteryMode?: unknown;
       onDemandMonthlyBudget?: unknown;
     };
-    codex?: { enabled?: unknown; defaultAgent?: unknown; path?: unknown; command?: unknown; model?: unknown; effort?: unknown };
-    chromeDevtools?: { enabled?: unknown; port?: unknown; chromePath?: unknown };
-  };
+    codex?: { enabled?: unknown; defaultAgent?: unknown; path?: unknown; command?: unknown; model?: unknown; effort?: unknown };
+    chromeDevtools?: { enabled?: unknown; port?: unknown; chromePath?: unknown };
+    rawStreamLogs?: unknown;
+  };
   try {
     parsed = JSON.parse(raw);
   } catch (err) {
@@ -428,9 +466,12 @@ function loadConfig(): AppConfig {
 
   const feishu = parsed.feishu ?? { appId: "", appSecret: "" };
   const claude = parsed.claude ?? {} as Partial<ClaudeConfig>;
-  const cursorRaw = (parsed.cursor ?? {}) as NonNullable<typeof parsed.cursor>;
-  const codexRaw = (parsed.codex ?? {}) as NonNullable<typeof parsed.codex>;
-  const chromeDevtoolsRaw = (parsed.chromeDevtools ?? {}) as NonNullable<typeof parsed.chromeDevtools>;
+  const cursorRaw = (parsed.cursor ?? {}) as NonNullable<typeof parsed.cursor>;
+  const codexRaw = (parsed.codex ?? {}) as NonNullable<typeof parsed.codex>;
+  const chromeDevtoolsRaw = (parsed.chromeDevtools ?? {}) as NonNullable<typeof parsed.chromeDevtools>;
+  const rawStreamLogsRaw = typeof parsed.rawStreamLogs === "object" && parsed.rawStreamLogs !== null
+    ? parsed.rawStreamLogs as unknown as Record<string, unknown>
+    : {};
 
   // 兼容旧字段 `command`：命中时打印一次性 warning 提示用户改名
   const onLegacyField = (label: string, value: string): void => {
@@ -519,10 +560,15 @@ function loadConfig(): AppConfig {
         : 15166,
       chromePath: normalizeOptionalConfigField(chromeDevtoolsRaw.chromePath, { label: "chromeDevtools.chromePath" }),
     },
-    port: typeof parsed.port === "number" ? parsed.port : 18080,
-    gitTimeoutSeconds: typeof parsed.gitTimeoutSeconds === "number" ? parsed.gitTimeoutSeconds : 180,
-    allowInterrupt: typeof parsed.allowInterrupt === "boolean" ? parsed.allowInterrupt : false,
-    claude: {
+    port: typeof parsed.port === "number" ? parsed.port : 18080,
+    gitTimeoutSeconds: typeof parsed.gitTimeoutSeconds === "number" ? parsed.gitTimeoutSeconds : 180,
+    allowInterrupt: typeof parsed.allowInterrupt === "boolean" ? parsed.allowInterrupt : false,
+    rawStreamLogs: {
+      claude: normalizeRawStreamAgentLogConfig(rawStreamLogsRaw.claude),
+      cursor: normalizeRawStreamAgentLogConfig(rawStreamLogsRaw.cursor),
+      codex: normalizeRawStreamAgentLogConfig(rawStreamLogsRaw.codex),
+    },
+    claude: {
       enabled: claudeEnabled,
       defaultAgent: defaultTool === "claude",
       model: normalizeOptionalConfigField(claude.model, { label: "claude.model" }),