chatccc 0.2.226 → 0.2.228

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

@@ -2,9 +2,9 @@ import { describe, it, expect } from "vitest";
 import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
-import {
-  buildCodexInvocationArgs,
-  normalizeCodexMessage,
+import {
+  buildCodexInvocationArgs,
+  normalizeCodexMessage,
   createCodexAdapter,
   type CreateCodexAdapterOptions,
 } from "../adapters/codex-adapter.ts";
@@ -15,21 +15,21 @@ import {
 } from "../adapters/codex-session-meta-store.ts";
 import { accumulateBlockContent, pickFinalReply, type AccumulatorState } from "../session.ts";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-describe("buildCodexInvocationArgs", () => {
-  it("forces the priority service tier when Fast mode is on", () => {
-    expect(buildCodexInvocationArgs(["exec", "--json"], "", "", true)).toContain(
-      'service_tier="fast"',
-    );
-  });
-
-  it("forces the standard service tier when Fast mode is off", () => {
-    const args = buildCodexInvocationArgs(["exec", "--json"], "", "", false);
-    expect(args).toContain('service_tier="default"');
-    expect(args).not.toContain('service_tier="fast"');
-  });
-});
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+describe("buildCodexInvocationArgs", () => {
+  it("forces the priority service tier when Fast mode is on", () => {
+    expect(buildCodexInvocationArgs(["exec", "--json"], "", "", true)).toContain(
+      'service_tier="fast"',
+    );
+  });
+
+  it("forces the standard service tier when Fast mode is off", () => {
+    const args = buildCodexInvocationArgs(["exec", "--json"], "", "", false);
+    expect(args).toContain('service_tier="default"');
+    expect(args).not.toContain('service_tier="fast"');
+  });
+});
 
 function readFixture(name: string): unknown[] {
   const raw = readFileSync(join(__dirname, "fixtures", name), "utf-8");
@@ -71,16 +71,16 @@ function createInMemoryMetaStore(
 // ---------------------------------------------------------------------------
 
 describe("normalizeCodexMessage", () => {
-  it("normalizes agent_message into assistant text block", () => {
-    const result = normalizeCodexMessage({
-      type: "item.completed",
-      item: { id: "item_0", type: "agent_message", text: "hello" },
+  it("normalizes agent_message into assistant text block", () => {
+    const result = normalizeCodexMessage({
+      type: "item.completed",
+      item: { id: "item_0", type: "agent_message", text: "hello" },
     });
-    expect(result).not.toBeNull();
-    expect(result!.type).toBe("assistant");
-    expect(result!.blocks).toEqual([{ type: "text", text: "hello" }]);
-    expect(result!.isFinalResponse).toBeUndefined();
-  });
+    expect(result).not.toBeNull();
+    expect(result!.type).toBe("assistant");
+    expect(result!.blocks).toEqual([{ type: "text", text: "hello" }]);
+    expect(result!.isFinalResponse).toBeUndefined();
+  });
 
   it("normalizes command_execution start into tool_use block", () => {
     const result = normalizeCodexMessage({
@@ -92,12 +92,12 @@ describe("normalizeCodexMessage", () => {
         status: "in_progress",
       },
     });
-    expect(result).not.toBeNull();
-    expect(result!.type).toBe("assistant");
-    expect(result!.blocks).toEqual([
-      { type: "tool_use", id: "item_0", name: "Bash", input: { command: "powershell.exe -Command ls" } },
-    ]);
-  });
+    expect(result).not.toBeNull();
+    expect(result!.type).toBe("assistant");
+    expect(result!.blocks).toEqual([
+      { type: "tool_use", id: "item_0", name: "Bash", input: { command: "powershell.exe -Command ls" } },
+    ]);
+  });
 
   it("normalizes command_execution completion as tool_result (success)", () => {
     const result = normalizeCodexMessage({
@@ -158,17 +158,17 @@ describe("normalizeCodexMessage", () => {
     expect(normalizeCodexMessage({ type: "turn.started" })).toBeNull();
   });
 
-  it("marks turn.completed as the authoritative final response", () => {
-    expect(
-      normalizeCodexMessage({
-        type: "turn.completed",
-        usage: { input_tokens: 100, output_tokens: 50 },
-      }),
-    ).toEqual({
-      type: "assistant",
-      blocks: [],
-      isFinalResponse: true,
-    });
+  it("marks turn.completed as the authoritative final response", () => {
+    expect(
+      normalizeCodexMessage({
+        type: "turn.completed",
+        usage: { input_tokens: 100, output_tokens: 50 },
+      }),
+    ).toEqual({
+      type: "assistant",
+      blocks: [],
+      isFinalResponse: true,
+    });
   });
 
   it("returns null for unknown event types", () => {
@@ -244,7 +244,7 @@ describe("Codex stream fixtures", () => {
     expect(state.accumulatedContent).toContain("tool_test");
   });
 
-  it("with tool: 普通输出不标终态，只有 turn.completed 标记终态", () => {
+  it("with tool: 普通输出不标终态，只有 turn.completed 标记终态", () => {
     const lines = readFixture("codex_with_tool.jsonl");
     const messages: UnifiedStreamMessage[] = [];
     for (const raw of lines) {
@@ -254,18 +254,18 @@ describe("Codex stream fixtures", () => {
       if (normalized) messages.push(normalized);
     }
 
-    // 应有: tool_use + tool_result + text + turn.completed = 4 条消息
-    expect(messages.length).toBe(4);
-    expect(messages[0].blocks[0].type).toBe("tool_use");
-    expect(messages[1].blocks[0].type).toBe("tool_result");
-    expect(messages[2].blocks[0].type).toBe("text");
-    expect(messages[2].isFinalResponse).toBeUndefined();
-    expect(messages[3]).toEqual({
-      type: "assistant",
-      blocks: [],
-      isFinalResponse: true,
-    });
-  });
+    // 应有: tool_use + tool_result + text + turn.completed = 4 条消息
+    expect(messages.length).toBe(4);
+    expect(messages[0].blocks[0].type).toBe("tool_use");
+    expect(messages[1].blocks[0].type).toBe("tool_result");
+    expect(messages[2].blocks[0].type).toBe("text");
+    expect(messages[2].isFinalResponse).toBeUndefined();
+    expect(messages[3]).toEqual({
+      type: "assistant",
+      blocks: [],
+      isFinalResponse: true,
+    });
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -328,4 +328,4 @@ describe("createCodexAdapter", () => {
     });
     expect(await adapter.getSessionInfo("sid-C")).toBeUndefined();
   });
-});
+});

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

@@ -1,170 +1,170 @@
-import { EventEmitter } from "node:events";
-import { PassThrough } from "node:stream";
-
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-const spawnMock = vi.hoisted(() => vi.fn());
-const createRawStreamLogMock = vi.hoisted(() => vi.fn());
-const rawLogWriteLineMock = vi.hoisted(() => vi.fn());
-const rawLogCloseMock = vi.hoisted(() => vi.fn());
-const killProcessTreeMock = vi.hoisted(() => vi.fn(async () => {}));
-
-vi.mock("node:child_process", () => ({
-  spawn: spawnMock,
-}));
-
-vi.mock("../adapters/raw-stream-log.ts", () => ({
-  createRawStreamLog: createRawStreamLogMock,
-}));
-
-vi.mock("../adapters/proc-tree-kill.ts", () => ({
-  killProcessTree: killProcessTreeMock,
-}));
-
-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);
-
-function createProc(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`);
-    proc.stdout.end();
-    proc.stderr.end();
-    proc.emit("close", 0);
-  });
-  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);
-  return events;
-}
-
-function metaStore(): CodexSessionMetaStore {
-  return {
-    async get(sessionId) {
-      return sessionId === "sid-raw" ? { cwd: "F:/project" } : undefined;
-    },
-    async set() {},
-    async setThreadId() {},
-  };
-}
-
-afterEach(() => {
-  vi.useRealTimers();
-  spawnMock.mockReset();
-  createRawStreamLogMock.mockReset();
-  rawLogWriteLineMock.mockReset();
-  rawLogCloseMock.mockReset();
-  killProcessTreeMock.mockClear();
-  config.rawStreamLogs = structuredClone(originalRawStreamLogs);
-});
-
-describe("Codex raw stream logs", () => {
-  it("writes raw Codex JSONL stdout lines when enabled", async () => {
-    const lines = [
-      JSON.stringify({ type: "thread.started", thread_id: "thread-1" }),
-      JSON.stringify({ type: "item.completed", item: { id: "item-1", type: "agent_message", text: "hello" } }),
-      JSON.stringify({ type: "turn.completed" }),
-    ];
-    spawnMock.mockReturnValueOnce(createProc(lines));
-    createRawStreamLogMock.mockResolvedValueOnce({
-      filePath: "codex.jsonl.gz",
-      writeLine: rawLogWriteLineMock,
-      close: rawLogCloseMock,
-    });
-    config.rawStreamLogs.codex = {
-      enabled: true,
-      maxBytesPerTurn: 2048,
-      retentionDays: 2,
-      keepCompleted: false,
-    };
-
-    const adapter = createCodexAdapter({ metaStore: metaStore() });
-    const events = await collect(adapter.prompt("sid-raw", "hi", "F:/project"));
-
-    expect(createRawStreamLogMock).toHaveBeenCalledWith(expect.objectContaining({
-      enabled: true,
-      tool: "codex",
-      sessionId: "sid-raw",
-      label: "prompt",
-      maxBytesPerTurn: 2048,
-      retentionDays: 2,
-    }));
-    expect(rawLogWriteLineMock).toHaveBeenNthCalledWith(1, lines[0]);
-    expect(rawLogWriteLineMock).toHaveBeenNthCalledWith(2, lines[1]);
-    expect(rawLogWriteLineMock).toHaveBeenNthCalledWith(3, lines[2]);
-    expect(rawLogCloseMock).toHaveBeenCalledWith({ keep: false });
-    expect(events).toEqual([
-      {
-        type: "assistant",
-        blocks: [{ type: "text", text: "hello" }],
-      },
-      {
-        type: "assistant",
-        blocks: [],
-        isFinalResponse: true,
-      },
-    ]);
-  });
-
-  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);
-  });
-});
+import { EventEmitter } from "node:events";
+import { PassThrough } from "node:stream";
+
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const spawnMock = vi.hoisted(() => vi.fn());
+const createRawStreamLogMock = vi.hoisted(() => vi.fn());
+const rawLogWriteLineMock = vi.hoisted(() => vi.fn());
+const rawLogCloseMock = vi.hoisted(() => vi.fn());
+const killProcessTreeMock = vi.hoisted(() => vi.fn(async () => {}));
+
+vi.mock("node:child_process", () => ({
+  spawn: spawnMock,
+}));
+
+vi.mock("../adapters/raw-stream-log.ts", () => ({
+  createRawStreamLog: createRawStreamLogMock,
+}));
+
+vi.mock("../adapters/proc-tree-kill.ts", () => ({
+  killProcessTree: killProcessTreeMock,
+}));
+
+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);
+
+function createProc(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`);
+    proc.stdout.end();
+    proc.stderr.end();
+    proc.emit("close", 0);
+  });
+  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);
+  return events;
+}
+
+function metaStore(): CodexSessionMetaStore {
+  return {
+    async get(sessionId) {
+      return sessionId === "sid-raw" ? { cwd: "F:/project" } : undefined;
+    },
+    async set() {},
+    async setThreadId() {},
+  };
+}
+
+afterEach(() => {
+  vi.useRealTimers();
+  spawnMock.mockReset();
+  createRawStreamLogMock.mockReset();
+  rawLogWriteLineMock.mockReset();
+  rawLogCloseMock.mockReset();
+  killProcessTreeMock.mockClear();
+  config.rawStreamLogs = structuredClone(originalRawStreamLogs);
+});
+
+describe("Codex raw stream logs", () => {
+  it("writes raw Codex JSONL stdout lines when enabled", async () => {
+    const lines = [
+      JSON.stringify({ type: "thread.started", thread_id: "thread-1" }),
+      JSON.stringify({ type: "item.completed", item: { id: "item-1", type: "agent_message", text: "hello" } }),
+      JSON.stringify({ type: "turn.completed" }),
+    ];
+    spawnMock.mockReturnValueOnce(createProc(lines));
+    createRawStreamLogMock.mockResolvedValueOnce({
+      filePath: "codex.jsonl.gz",
+      writeLine: rawLogWriteLineMock,
+      close: rawLogCloseMock,
+    });
+    config.rawStreamLogs.codex = {
+      enabled: true,
+      maxBytesPerTurn: 2048,
+      retentionDays: 2,
+      keepCompleted: false,
+    };
+
+    const adapter = createCodexAdapter({ metaStore: metaStore() });
+    const events = await collect(adapter.prompt("sid-raw", "hi", "F:/project"));
+
+    expect(createRawStreamLogMock).toHaveBeenCalledWith(expect.objectContaining({
+      enabled: true,
+      tool: "codex",
+      sessionId: "sid-raw",
+      label: "prompt",
+      maxBytesPerTurn: 2048,
+      retentionDays: 2,
+    }));
+    expect(rawLogWriteLineMock).toHaveBeenNthCalledWith(1, lines[0]);
+    expect(rawLogWriteLineMock).toHaveBeenNthCalledWith(2, lines[1]);
+    expect(rawLogWriteLineMock).toHaveBeenNthCalledWith(3, lines[2]);
+    expect(rawLogCloseMock).toHaveBeenCalledWith({ keep: false });
+    expect(events).toEqual([
+      {
+        type: "assistant",
+        blocks: [{ type: "text", text: "hello" }],
+      },
+      {
+        type: "assistant",
+        blocks: [],
+        isFinalResponse: true,
+      },
+    ]);
+  });
+
+  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);
+  });
+});