chatccc 0.2.197 → 0.2.198

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chatccc",
-  "version": "0.2.197",
+  "version": "0.2.198",
   "description": "Feishu bot bridge for Claude Code",
   "license": "Apache-2.0",
   "type": "module",
@@ -36,6 +36,7 @@
     "demo:permission-check": "tsx demo/permission_check.ts",
     "demo:claude-hi": "tsx demo/claude_say_hi.ts",
     "demo:codex-hi": "tsx demo/codex_say_hi.ts",
+    "demo:codex-app-server-approval": "tsx demo/codex-app-server-approval/approval_demo.ts",
     "demo:ilink-echo": "tsx demo/ilink_echo_probe.ts",
     "claude-proxy": "tsx src/litellm-proxy.ts",
     "test": "vitest run",

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

@@ -23,6 +23,7 @@ vi.mock("../adapters/proc-tree-kill.ts", () => ({
 
 import { config } from "../config.ts";
 import { createCodexAdapter } from "../adapters/codex-adapter.ts";
+import { BadJsonIdleTimeoutError } from "../adapters/jsonl-stream.ts";
 import type { CodexSessionMetaStore } from "../adapters/codex-session-meta-store.ts";
 
 const originalRawStreamLogs = structuredClone(config.rawStreamLogs);
@@ -52,6 +53,28 @@ function createProc(lines: string[]): EventEmitter & {
   return proc;
 }
 
+function createHangingProc(lines: string[]): EventEmitter & {
+  stdout: PassThrough;
+  stderr: PassThrough;
+  stdin: PassThrough;
+  pid: number;
+} {
+  const proc = new EventEmitter() as EventEmitter & {
+    stdout: PassThrough;
+    stderr: PassThrough;
+    stdin: PassThrough;
+    pid: number;
+  };
+  proc.stdout = new PassThrough();
+  proc.stderr = new PassThrough();
+  proc.stdin = new PassThrough();
+  proc.pid = 4242;
+  queueMicrotask(() => {
+    for (const line of lines) proc.stdout.write(`${line}\n`);
+  });
+  return proc;
+}
+
 async function collect(iterable: AsyncIterable<unknown>): Promise<unknown[]> {
   const events: unknown[] = [];
   for await (const event of iterable) events.push(event);
@@ -69,6 +92,7 @@ function metaStore(): CodexSessionMetaStore {
 }
 
 afterEach(() => {
+  vi.useRealTimers();
   spawnMock.mockReset();
   createRawStreamLogMock.mockReset();
   rawLogWriteLineMock.mockReset();
@@ -117,4 +141,23 @@ describe("Codex raw stream logs", () => {
       blocks: [{ type: "text", text: "hello" }],
     });
   });
+
+  it("fails the turn and kills the process tree when bad JSON is followed by idle stdout", async () => {
+    vi.useFakeTimers();
+    spawnMock.mockReturnValueOnce(createHangingProc([
+      "{\"type\":\"item.started\",\"item\":{\"type\":\"command_execution\"",
+    ]));
+    createRawStreamLogMock.mockResolvedValueOnce(null);
+
+    const adapter = createCodexAdapter({ metaStore: metaStore() });
+    const pending = collect(adapter.prompt("sid-raw", "hi", "F:/project"))
+      .catch((error: unknown) => error);
+
+    await Promise.resolve();
+    await vi.advanceTimersByTimeAsync(120_000);
+
+    const error = await pending;
+    expect(error).toBeInstanceOf(BadJsonIdleTimeoutError);
+    expect(killProcessTreeMock).toHaveBeenCalledWith(4242);
+  });
 });

package/src/__tests__/cursor-adapter.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect } from "vitest";
+import { afterEach, describe, it, expect, vi } from "vitest";
 import { EventEmitter } from "node:events";
 import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
@@ -10,6 +10,7 @@ import {
   createCursorAdapter,
   formatCursorAgentEmptyOutputMessage,
 } from "../adapters/cursor-adapter.ts";
+import { BadJsonIdleTimeoutError } from "../adapters/jsonl-stream.ts";
 import type { UnifiedStreamMessage } from "../adapters/adapter-interface.ts";
 import type {
   CursorSessionMeta,
@@ -82,6 +83,33 @@ function createMockCursorProcess(args: {
   return child;
 }
 
+function createHangingMockCursorProcess(args: {
+  stdout?: string;
+  stderr?: string;
+}): ChildProcess {
+  const child = new EventEmitter() as ChildProcess;
+  const stdout = new PassThrough();
+  const stderr = new PassThrough();
+  const stdin = new PassThrough();
+  Object.assign(child, {
+    stdout,
+    stderr,
+    stdin,
+    pid: undefined,
+  });
+
+  setTimeout(() => {
+    if (args.stdout) stdout.write(args.stdout);
+    if (args.stderr) stderr.write(args.stderr);
+  }, 0);
+
+  return child;
+}
+
+afterEach(() => {
+  vi.useRealTimers();
+});
+
 // ---------------------------------------------------------------------------
 // normalizeCursorMessage — 核心映射逻辑测试（纯函数）
 // ---------------------------------------------------------------------------
@@ -757,4 +785,30 @@ describe("Cursor adapter process failures", () => {
       /Cursor Agent exited without stream-json output/,
     );
   });
+
+  it("prompt fails when Cursor emits bad JSON and then leaves stdout idle", async () => {
+    vi.useFakeTimers();
+    const store = createInMemoryMetaStore({ sid: { cwd: "F:/repo" } });
+    const spawnImpl = (() =>
+      createHangingMockCursorProcess({
+        stdout: "{\"type\":\"tool_call\",\"subtype\":\"started\"\n",
+      })) as CursorSpawnForTest;
+    const adapter = createCursorAdapter({ metaStore: store, spawn: spawnImpl });
+
+    const pending = (async () => {
+      for await (const _event of adapter.prompt(
+        "sid",
+        "[User message]\nhello\n[/User message]",
+        "F:/repo",
+      )) {
+        // No normalized events are expected before the watchdog fires.
+      }
+    })().catch((error: unknown) => error);
+
+    await vi.advanceTimersByTimeAsync(0);
+    await vi.advanceTimersByTimeAsync(120_000);
+
+    const error = await pending;
+    expect(error).toBeInstanceOf(BadJsonIdleTimeoutError);
+  });
 });

package/src/__tests__/jsonl-stream.test.ts

@@ -0,0 +1,79 @@
+import { PassThrough } from "node:stream";
+
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import {
+  BadJsonIdleTimeoutError,
+  readJsonLinesWithBadJsonIdleWatchdog,
+} from "../adapters/jsonl-stream.ts";
+
+function createReader(input: PassThrough, idleTimeoutMs = 100): AsyncIterator<unknown> {
+  return readJsonLinesWithBadJsonIdleWatchdog({
+    input,
+    tool: "test-agent",
+    tag: "sid-test",
+    idleTimeoutMs,
+    parse: (line) => JSON.parse(line) as unknown,
+  })[Symbol.asyncIterator]();
+}
+
+afterEach(() => {
+  vi.useRealTimers();
+});
+
+describe("readJsonLinesWithBadJsonIdleWatchdog", () => {
+  it("throws when a JSON-like bad line remains the last stdout past the idle timeout", async () => {
+    vi.useFakeTimers();
+    const input = new PassThrough();
+    const iterator = createReader(input);
+
+    const pending = iterator.next().catch((error: unknown) => error);
+    input.write("{\"type\":\"tool_call\",\"subtype\":\"started\"\n");
+
+    await vi.advanceTimersByTimeAsync(100);
+
+    const error = await pending;
+    expect(error).toBeInstanceOf(BadJsonIdleTimeoutError);
+    expect(error).toMatchObject({
+      code: "BAD_JSON_IDLE_TIMEOUT",
+      tool: "test-agent",
+      tag: "sid-test",
+    });
+  });
+
+  it("does not throw when a valid JSON line arrives after the bad line before timeout", async () => {
+    vi.useFakeTimers();
+    const input = new PassThrough();
+    const iterator = createReader(input);
+
+    const pending = iterator.next();
+    input.write("{\"type\":\"tool_call\"\n");
+    await vi.advanceTimersByTimeAsync(50);
+    input.write("{\"type\":\"ok\"}\n");
+
+    await expect(pending).resolves.toEqual({
+      done: false,
+      value: { type: "ok" },
+    });
+
+    const done = iterator.next();
+    input.end();
+    await expect(done).resolves.toEqual({ done: true, value: undefined });
+  });
+
+  it("ignores non-JSON banner lines for the bad JSON idle watchdog", async () => {
+    vi.useFakeTimers();
+    const input = new PassThrough();
+    const iterator = createReader(input);
+
+    const pending = iterator.next();
+    input.write("Reading prompt from stdin...\n");
+    await vi.advanceTimersByTimeAsync(200);
+    input.write("{\"type\":\"ok\"}\n");
+
+    await expect(pending).resolves.toEqual({
+      done: false,
+      value: { type: "ok" },
+    });
+  });
+});

package/src/adapters/codex-adapter.ts

@@ -10,7 +10,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 { randomUUID } from "node:crypto";
 import { fileURLToPath } from "node:url";
 
@@ -33,6 +32,7 @@ import {
   createRawStreamLog,
   type RawStreamLogHandle,
 } from "./raw-stream-log.ts";
+import { readJsonLinesWithBadJsonIdleWatchdog } from "./jsonl-stream.ts";
 
 // ---------------------------------------------------------------------------
 // 特殊注入提示
@@ -237,26 +237,14 @@ async function* readJsonLines(
   signal?: AbortSignal,
   rawLog?: RawStreamLogHandle | null,
 ): AsyncGenerator<CodexEvent> {
-  const rl = createInterface({ input: proc.stdout!, crlfDelay: Infinity });
-  // abort 时主动 close readline，避免等待 Windows 管道自然关闭（可能延迟数分钟）
-  const onAbort = () => { rl.close(); };
-  signal?.addEventListener("abort", onAbort, { once: true });
-  try {
-    for await (const line of rl) {
-      if (signal?.aborted) break;
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-      rawLog?.writeLine(trimmed);
-      try {
-        yield JSON.parse(trimmed) as CodexEvent;
-      } catch {
-        // 非 JSON 行静默跳过（如 "Reading prompt from stdin..."）
-      }
-    }
-  } finally {
-    signal?.removeEventListener("abort", onAbort);
-    rl.close();
-  }
+  yield* readJsonLinesWithBadJsonIdleWatchdog<CodexEvent>({
+    input: proc.stdout!,
+    tool: "codex",
+    tag: "codex",
+    signal,
+    rawLog,
+    parse: (line) => JSON.parse(line) as CodexEvent,
+  });
 }
 
 // ---------------------------------------------------------------------------

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";
 
 // ---------------------------------------------------------------------------
 // 特殊注入提示
@@ -439,33 +439,26 @@ async function* readJsonLines(
   stats?: CursorStreamStats,
 ): 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,
+    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}`);
+    },
+  });
 }
 
 // ---------------------------------------------------------------------------

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