chatccc 0.2.197 → 0.2.199

package/src/adapters/cursor-adapter.ts

@@ -8,7 +8,6 @@
 import { spawn, type ChildProcess } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { createInterface } from "node:readline";
 import { fileURLToPath } from "node:url";
 
 import type {
@@ -30,6 +29,7 @@ import {
   createRawStreamLog,
   type RawStreamLogHandle,
 } from "./raw-stream-log.ts";
+import { readJsonLinesWithBadJsonIdleWatchdog } from "./jsonl-stream.ts";
 
 // ---------------------------------------------------------------------------
 // 特殊注入提示
@@ -156,6 +156,26 @@ function isCursorAuthRelatedError(stderr: string): boolean {
   );
 }
 
+const CURSOR_VISIBLE_STDERR_MAX_CHARS = 1200;
+
+function sanitizeCursorStderr(stderr: string): string {
+  return stderr
+    .replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, "")
+    .replace(/\bBearer\s+[A-Za-z0-9._~+/=-]{12,}\b/gi, "Bearer <redacted>")
+    .replace(/\bsk-[A-Za-z0-9_-]{12,}\b/g, "<redacted-api-key>")
+    .replace(
+      /\b(api[_-]?key|token|authorization|password)\s*[:=]\s*["']?[^\s"']+/gi,
+      "$1=<redacted>",
+    )
+    .trim();
+}
+
+function formatCursorVisibleStderr(stderr: string): string {
+  const sanitized = sanitizeCursorStderr(stderr);
+  if (sanitized.length <= CURSOR_VISIBLE_STDERR_MAX_CHARS) return sanitized;
+  return `${sanitized.slice(0, CURSOR_VISIBLE_STDERR_MAX_CHARS)}\n...(stderr truncated)`;
+}
+
 export function formatCursorAgentEmptyOutputMessage(args: {
   exitCode: number | null;
   stdoutLength: number;
@@ -165,11 +185,12 @@ export function formatCursorAgentEmptyOutputMessage(args: {
   if (args.stdoutLength !== 0) return null;
   if (args.stderr.trim().length === 0) return null;
 
+  const stderrBlock = `[Cursor stderr] exit=${args.exitCode ?? "unknown"}:\n${formatCursorVisibleStderr(args.stderr)}`;
   if (isCursorAuthRelatedError(args.stderr)) {
-    return "Cursor Agent 没有返回内容。检测到认证相关错误，可能需要重新登录 Cursor Agent，或配置 CURSOR_API_KEY。请在本机运行 agent status 检查状态；如未登录，请运行 agent login 后重试。";
+    return `Cursor Agent 没有返回内容。检测到认证相关错误，可能需要重新登录 Cursor Agent，或配置 CURSOR_API_KEY。请在本机运行 agent status 检查状态；如未登录，请运行 agent login 后重试。\n\n${stderrBlock}`;
   }
 
-  return "Cursor Agent 没有返回内容。底层命令异常退出，请检查本机 Cursor Agent 状态后重试。";
+  return `Cursor Agent 没有返回内容。底层命令异常退出，错误信息如下：\n\n${stderrBlock}`;
 }
 
 function createCursorAgentFailureError(info: CursorProcessCloseInfo): Error {
@@ -437,35 +458,30 @@ async function* readJsonLines(
   debugTag?: string,
   rawLog?: RawStreamLogHandle | null,
   stats?: CursorStreamStats,
+  idleTimeoutMs?: number,
 ): AsyncGenerator<CursorMessageLine> {
   const tag = debugTag ?? "cursor";
-  const rl = createInterface({ input: proc.stdout!, crlfDelay: Infinity });
-  // abort 时主动 close readline，避免等待 Windows 管道自然关闭（可能延迟数分钟）
-  const onAbort = () => { rl.close(); };
-  signal?.addEventListener("abort", onAbort, { once: true });
-  let lineCount = 0;
-  try {
-    for await (const line of rl) {
-      if (signal?.aborted) break;
-      lineCount++;
+  yield* readJsonLinesWithBadJsonIdleWatchdog<CursorMessageLine>({
+    input: proc.stdout!,
+    tool: "cursor",
+    tag,
+    signal,
+    rawLog,
+    idleTimeoutMs,
+    parse: (line) => JSON.parse(line) as CursorMessageLine,
+    onRawLine: (line) => {
       if (stats) {
         stats.rawLineCount++;
         stats.stdoutLength += Buffer.byteLength(line, "utf-8") + 1;
       }
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-      rawLog?.writeLine(trimmed);
-      try {
-        const parsed = JSON.parse(trimmed) as CursorMessageLine;
-        if (stats) stats.parsedLineCount++;
-        yield parsed;
-      } catch { /* 非 JSON 行静默跳过 */ }
-    }
-  } finally {
-    signal?.removeEventListener("abort", onAbort);
-    rl.close();
-    console.log(`[Cursor debug] ${tag} readJsonLines done: ${lineCount} raw lines, signalAborted=${signal?.aborted ?? false}`);
-  }
+    },
+    onParsedLine: () => {
+      if (stats) stats.parsedLineCount++;
+    },
+    onDone: (info) => {
+      console.log(`[Cursor debug] ${tag} readJsonLines done: ${info.lineCount} raw lines, signalAborted=${info.signalAborted}`);
+    },
+  });
 }
 
 // ---------------------------------------------------------------------------
@@ -479,11 +495,18 @@ class CursorAdapter implements ToolAdapter {
   private metaStore: CursorSessionMetaStore;
   private modelOverride: string | undefined;
   private spawnImpl: CursorSpawn;
-
-  constructor(metaStore: CursorSessionMetaStore, modelOverride?: string, spawnImpl: CursorSpawn = spawn) {
+  private badJsonIdleTimeoutMs: number | undefined;
+
+  constructor(
+    metaStore: CursorSessionMetaStore,
+    modelOverride?: string,
+    spawnImpl: CursorSpawn = spawn,
+    badJsonIdleTimeoutMs?: number,
+  ) {
     this.metaStore = metaStore;
     this.modelOverride = modelOverride;
     this.spawnImpl = spawnImpl;
+    this.badJsonIdleTimeoutMs = badJsonIdleTimeoutMs;
   }
 
   async createSession(cwd: string): Promise<CreateSessionResult> {
@@ -492,7 +515,7 @@ class CursorAdapter implements ToolAdapter {
     const stats = createCursorStreamStats();
     this.activeProcs.add(proc);
 
-    for await (const msg of readJsonLines(proc, undefined, "createSession", null, stats)) {
+    for await (const msg of readJsonLines(proc, undefined, "createSession", null, stats, this.badJsonIdleTimeoutMs)) {
       if (msg.type === "system" && msg.subtype === "init" && msg.session_id) {
         const sessionId = msg.session_id;
         await this.metaStore
@@ -561,7 +584,7 @@ class CursorAdapter implements ToolAdapter {
     const stats = createCursorStreamStats();
 
     try {
-      for await (const raw of readJsonLines(proc, signal, sessionId, rawLog, stats)) {
+      for await (const raw of readJsonLines(proc, signal, sessionId, rawLog, stats, this.badJsonIdleTimeoutMs)) {
         if (signal?.aborted) break;
         if (
           raw.type === "system" &&
@@ -634,6 +657,8 @@ export interface CreateCursorAdapterOptions {
   model?: string;
   /** 注入自定义 spawn 实现（测试用）。 */
   spawn?: CursorSpawn;
+  /** Test-only override for the bad JSON idle watchdog threshold. */
+  badJsonIdleTimeoutMs?: number;
 }
 
 export function createCursorAdapter(
@@ -643,5 +668,6 @@ export function createCursorAdapter(
     options.metaStore ?? defaultCursorSessionMetaStore,
     options.model,
     options.spawn,
+    options.badJsonIdleTimeoutMs,
   );
 }

package/src/adapters/jsonl-stream.ts

@@ -0,0 +1,157 @@
+import { createInterface } from "node:readline";
+
+interface JsonLineSink {
+  writeLine(line: string): void;
+}
+
+export const DEFAULT_BAD_JSON_IDLE_TIMEOUT_MS = 120_000;
+export const BAD_JSON_IDLE_TIMEOUT_CODE = "BAD_JSON_IDLE_TIMEOUT";
+
+export class BadJsonIdleTimeoutError extends Error {
+  readonly code = BAD_JSON_IDLE_TIMEOUT_CODE;
+  readonly tool: string;
+  readonly tag: string;
+  readonly timeoutMs: number;
+  readonly lineNumber: number;
+  readonly lineExcerpt: string;
+  readonly parseError: string;
+
+  constructor(args: {
+    tool: string;
+    tag: string;
+    timeoutMs: number;
+    lineNumber: number;
+    lineExcerpt: string;
+    parseError: string;
+  }) {
+    super(
+      `${args.tool} stream stopped after invalid JSON for ${args.timeoutMs}ms ` +
+        `(tag=${args.tag}, line=${args.lineNumber}): ${args.lineExcerpt}`,
+    );
+    this.name = "BadJsonIdleTimeoutError";
+    this.tool = args.tool;
+    this.tag = args.tag;
+    this.timeoutMs = args.timeoutMs;
+    this.lineNumber = args.lineNumber;
+    this.lineExcerpt = args.lineExcerpt;
+    this.parseError = args.parseError;
+  }
+}
+
+export interface ReadJsonLinesDoneInfo {
+  lineCount: number;
+  signalAborted: boolean;
+  protocolError: BadJsonIdleTimeoutError | null;
+}
+
+export interface ReadJsonLinesOptions<T> {
+  input: NodeJS.ReadableStream;
+  tool: string;
+  tag?: string;
+  signal?: AbortSignal;
+  rawLog?: JsonLineSink | null;
+  idleTimeoutMs?: number;
+  parse?: (line: string) => T;
+  onRawLine?: (line: string, lineNumber: number) => void;
+  onParsedLine?: (value: T, line: string, lineNumber: number) => void;
+  onDone?: (info: ReadJsonLinesDoneInfo) => void;
+}
+
+function isJsonLike(line: string): boolean {
+  return line.startsWith("{") || line.startsWith("[");
+}
+
+function lineExcerpt(line: string): string {
+  const max = 500;
+  return line.length <= max ? line : `${line.slice(0, max)}...`;
+}
+
+function parseErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export async function* readJsonLinesWithBadJsonIdleWatchdog<T>({
+  input,
+  tool,
+  tag = tool,
+  signal,
+  rawLog,
+  idleTimeoutMs = DEFAULT_BAD_JSON_IDLE_TIMEOUT_MS,
+  parse = (line: string) => JSON.parse(line) as T,
+  onRawLine,
+  onParsedLine,
+  onDone,
+}: ReadJsonLinesOptions<T>): AsyncGenerator<T> {
+  const rl = createInterface({ input, crlfDelay: Infinity });
+  let lineCount = 0;
+  let protocolError: BadJsonIdleTimeoutError | null = null;
+  let badJsonIdleTimer: ReturnType<typeof setTimeout> | null = null;
+
+  const clearBadJsonIdleTimer = () => {
+    if (!badJsonIdleTimer) return;
+    clearTimeout(badJsonIdleTimer);
+    badJsonIdleTimer = null;
+  };
+
+  const armBadJsonIdleTimer = (line: string, lineNumber: number, error: unknown) => {
+    if (idleTimeoutMs <= 0) return;
+    clearBadJsonIdleTimer();
+    badJsonIdleTimer = setTimeout(() => {
+      protocolError = new BadJsonIdleTimeoutError({
+        tool,
+        tag,
+        timeoutMs: idleTimeoutMs,
+        lineNumber,
+        lineExcerpt: lineExcerpt(line),
+        parseError: parseErrorMessage(error),
+      });
+      rl.close();
+    }, idleTimeoutMs);
+    const timerWithUnref = badJsonIdleTimer as ReturnType<typeof setTimeout> & {
+      unref?: () => void;
+    };
+    timerWithUnref.unref?.();
+  };
+
+  const onAbort = () => {
+    clearBadJsonIdleTimer();
+    rl.close();
+  };
+  signal?.addEventListener("abort", onAbort, { once: true });
+
+  try {
+    for await (const line of rl) {
+      if (signal?.aborted) break;
+      lineCount++;
+      onRawLine?.(line, lineCount);
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+
+      clearBadJsonIdleTimer();
+      rawLog?.writeLine(trimmed);
+
+      try {
+        const parsed = parse(trimmed);
+        onParsedLine?.(parsed, trimmed, lineCount);
+        yield parsed;
+      } catch (error) {
+        if (isJsonLike(trimmed)) {
+          armBadJsonIdleTimer(trimmed, lineCount, error);
+        }
+      }
+    }
+
+    if (protocolError && !signal?.aborted) {
+      throw protocolError;
+    }
+  } finally {
+    signal?.removeEventListener("abort", onAbort);
+    clearBadJsonIdleTimer();
+    rl.close();
+    onDone?.({
+      lineCount,
+      signalAborted: signal?.aborted ?? false,
+      protocolError,
+    });
+  }
+}

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

@@ -1,124 +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 };
-}
+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/agent-reload-config-rpc.ts

@@ -1,34 +1,34 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-
-import { reloadRuntimeConfig, type RuntimeReloadResult } from "./runtime-reload.ts";
-
-export const AGENT_RELOAD_CONFIG_PATH = "/api/agent/reload-config";
-
-type ReloadRuntimeConfig = (source: string) => RuntimeReloadResult | Promise<RuntimeReloadResult>;
-
-function jsonReply(res: ServerResponse, status: number, data: unknown): void {
-  res.writeHead(status, { "Content-Type": "application/json; charset=utf-8" });
-  res.end(JSON.stringify(data));
-}
-
-export async function handleAgentReloadConfigRequest(
-  req: IncomingMessage,
-  res: ServerResponse,
-  reload: ReloadRuntimeConfig = reloadRuntimeConfig,
-): Promise<boolean> {
-  const url = new URL(req.url ?? "/", "http://127.0.0.1");
-  if (url.pathname !== AGENT_RELOAD_CONFIG_PATH) return false;
-
-  if (req.method !== "POST") {
-    jsonReply(res, 405, { ok: false, error: "Method not allowed" });
-    return true;
-  }
-
-  try {
-    const result = await reload("agent-reload-api");
-    jsonReply(res, 200, { ok: true, ...result });
-  } catch (err) {
-    jsonReply(res, 500, { ok: false, error: (err as Error).message });
-  }
-  return true;
-}
+import type { IncomingMessage, ServerResponse } from "node:http";
+
+import { reloadRuntimeConfig, type RuntimeReloadResult } from "./runtime-reload.ts";
+
+export const AGENT_RELOAD_CONFIG_PATH = "/api/agent/reload-config";
+
+type ReloadRuntimeConfig = (source: string) => RuntimeReloadResult | Promise<RuntimeReloadResult>;
+
+function jsonReply(res: ServerResponse, status: number, data: unknown): void {
+  res.writeHead(status, { "Content-Type": "application/json; charset=utf-8" });
+  res.end(JSON.stringify(data));
+}
+
+export async function handleAgentReloadConfigRequest(
+  req: IncomingMessage,
+  res: ServerResponse,
+  reload: ReloadRuntimeConfig = reloadRuntimeConfig,
+): Promise<boolean> {
+  const url = new URL(req.url ?? "/", "http://127.0.0.1");
+  if (url.pathname !== AGENT_RELOAD_CONFIG_PATH) return false;
+
+  if (req.method !== "POST") {
+    jsonReply(res, 405, { ok: false, error: "Method not allowed" });
+    return true;
+  }
+
+  try {
+    const result = await reload("agent-reload-api");
+    jsonReply(res, 200, { ok: true, ...result });
+  } catch (err) {
+    jsonReply(res, 500, { ok: false, error: (err as Error).message });
+  }
+  return true;
+}