chatccc 0.2.231 → 0.2.233

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

package/src/__tests__/codex-reset-actions.test.ts

@@ -1,146 +1,146 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-import {
-  _resetCodexResetRequestsForTest,
-  handleCodexResetCardAction,
-  type CodexResetActionDeps,
-} from "../codex-reset-actions.ts";
-
-function deps(): CodexResetActionDeps & {
-  getTenantAccessToken: ReturnType<typeof vi.fn>;
-  sendRawCard: ReturnType<typeof vi.fn>;
-  sendTextReply: ReturnType<typeof vi.fn>;
-  sendCardReply: ReturnType<typeof vi.fn>;
-  updateCardMessage: ReturnType<typeof vi.fn>;
-  recallMessage: ReturnType<typeof vi.fn>;
-  consumeCodexRateLimitResetCredit: ReturnType<typeof vi.fn>;
-  createRequestId: ReturnType<typeof vi.fn>;
-} {
-  return {
-    getTenantAccessToken: vi.fn(async () => "tenant-token"),
-    sendRawCard: vi.fn(async () => true),
-    sendTextReply: vi.fn(async () => true),
-    sendCardReply: vi.fn(async () => true),
-    updateCardMessage: vi.fn(async () => true),
-    recallMessage: vi.fn(async () => true),
-    consumeCodexRateLimitResetCredit: vi.fn(async () => ({ code: "reset" as const, windowsReset: 2 })),
-    createRequestId: vi.fn(() => "request-1"),
-  };
-}
-
-function event(value: Record<string, unknown>, messageId: string) {
-  return {
-    event: {
-      open_message_id: messageId,
-      open_chat_id: "chat-1",
-      operator: { open_id: "ou-user" },
-      action: { value },
-    },
-  };
-}
-
-describe("Codex reset card actions", () => {
-  beforeEach(() => {
-    _resetCodexResetRequestsForTest();
-  });
-
-  it("sends a confirmation card tied to the clicked usage card", async () => {
-    const d = deps();
-
-    await expect(handleCodexResetCardAction(
-      event({ action: "codex_reset_request" }, "usage-message"),
-      d,
-    )).resolves.toBe(true);
-
-    expect(d.sendRawCard).toHaveBeenCalledTimes(1);
-    expect(d.sendRawCard.mock.calls[0][1]).toBe("chat-1");
-    const confirmCard = JSON.parse(d.sendRawCard.mock.calls[0][2]);
-    const action = confirmCard.elements.find((element: any) => element.tag === "action");
-    expect(action.actions[0].value).toEqual({
-      action: "codex_reset_confirm",
-      decision: "yes",
-      parentMessageId: "usage-message",
-      requestId: "request-1",
-    });
-  });
-
-  it("consumes a reset credit, sends the result, and collapses the confirmation card when user confirms", async () => {
-    const d = deps();
-    await handleCodexResetCardAction(event({ action: "codex_reset_request" }, "usage-message"), d);
-
-    await expect(handleCodexResetCardAction(
-      event({
-        action: "codex_reset_confirm",
-        decision: "yes",
-        parentMessageId: "usage-message",
-        requestId: "request-1",
-      }, "confirm-message"),
-      d,
-    )).resolves.toBe(true);
-
-    expect(d.consumeCodexRateLimitResetCredit).toHaveBeenCalledWith("request-1");
-    expect(d.updateCardMessage).toHaveBeenCalledTimes(1);
-    expect(d.updateCardMessage.mock.calls[0][1]).toBe("confirm-message");
-    expect(JSON.parse(d.updateCardMessage.mock.calls[0][2]).elements).toEqual([
-      { tag: "markdown", content: " " },
-    ]);
-    expect(d.recallMessage).toHaveBeenCalledWith("tenant-token", "confirm-message");
-    expect(d.sendTextReply).toHaveBeenCalledWith(
-      "tenant-token",
-      "chat-1",
-      expect.stringContaining("重置成功"),
-    );
-    expect(d.sendCardReply).not.toHaveBeenCalled();
-  });
-
-  it("does not consume a reset credit and sends a cancellation message when user declines", async () => {
-    const d = deps();
-    await handleCodexResetCardAction(event({ action: "codex_reset_request" }, "usage-message"), d);
-
-    await expect(handleCodexResetCardAction(
-      event({
-        action: "codex_reset_confirm",
-        decision: "no",
-        parentMessageId: "usage-message",
-        requestId: "request-1",
-      }, "confirm-message"),
-      d,
-    )).resolves.toBe(true);
-
-    expect(d.consumeCodexRateLimitResetCredit).not.toHaveBeenCalled();
-    expect(d.updateCardMessage).toHaveBeenCalledTimes(1);
-    expect(d.recallMessage).toHaveBeenCalledWith("tenant-token", "confirm-message");
-    expect(d.sendTextReply).toHaveBeenCalledWith(
-      "tenant-token",
-      "chat-1",
-      "Codex 主动重置：用户取消了重置。",
-    );
-    expect(d.sendCardReply).not.toHaveBeenCalled();
-  });
-
-  it("can collapse a confirmation card using context.message_id fallback", async () => {
-    const d = deps();
-    await handleCodexResetCardAction(event({ action: "codex_reset_request" }, "usage-message"), d);
-
-    await expect(handleCodexResetCardAction({
-      event: {
-        context: {
-          message_id: "confirm-message-from-context",
-          open_chat_id: "chat-1",
-        },
-        action: {
-          value: {
-            action: "codex_reset_confirm",
-            decision: "no",
-            parentMessageId: "usage-message",
-            requestId: "request-1",
-          },
-        },
-      },
-    }, d)).resolves.toBe(true);
-
-    expect(d.updateCardMessage).toHaveBeenCalledTimes(1);
-    expect(d.updateCardMessage.mock.calls[0][1]).toBe("confirm-message-from-context");
-    expect(d.recallMessage).toHaveBeenCalledWith("tenant-token", "confirm-message-from-context");
-  });
-});
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import {
+  _resetCodexResetRequestsForTest,
+  handleCodexResetCardAction,
+  type CodexResetActionDeps,
+} from "../codex-reset-actions.ts";
+
+function deps(): CodexResetActionDeps & {
+  getTenantAccessToken: ReturnType<typeof vi.fn>;
+  sendRawCard: ReturnType<typeof vi.fn>;
+  sendTextReply: ReturnType<typeof vi.fn>;
+  sendCardReply: ReturnType<typeof vi.fn>;
+  updateCardMessage: ReturnType<typeof vi.fn>;
+  recallMessage: ReturnType<typeof vi.fn>;
+  consumeCodexRateLimitResetCredit: ReturnType<typeof vi.fn>;
+  createRequestId: ReturnType<typeof vi.fn>;
+} {
+  return {
+    getTenantAccessToken: vi.fn(async () => "tenant-token"),
+    sendRawCard: vi.fn(async () => true),
+    sendTextReply: vi.fn(async () => true),
+    sendCardReply: vi.fn(async () => true),
+    updateCardMessage: vi.fn(async () => true),
+    recallMessage: vi.fn(async () => true),
+    consumeCodexRateLimitResetCredit: vi.fn(async () => ({ code: "reset" as const, windowsReset: 2 })),
+    createRequestId: vi.fn(() => "request-1"),
+  };
+}
+
+function event(value: Record<string, unknown>, messageId: string) {
+  return {
+    event: {
+      open_message_id: messageId,
+      open_chat_id: "chat-1",
+      operator: { open_id: "ou-user" },
+      action: { value },
+    },
+  };
+}
+
+describe("Codex reset card actions", () => {
+  beforeEach(() => {
+    _resetCodexResetRequestsForTest();
+  });
+
+  it("sends a confirmation card tied to the clicked usage card", async () => {
+    const d = deps();
+
+    await expect(handleCodexResetCardAction(
+      event({ action: "codex_reset_request" }, "usage-message"),
+      d,
+    )).resolves.toBe(true);
+
+    expect(d.sendRawCard).toHaveBeenCalledTimes(1);
+    expect(d.sendRawCard.mock.calls[0][1]).toBe("chat-1");
+    const confirmCard = JSON.parse(d.sendRawCard.mock.calls[0][2]);
+    const action = confirmCard.elements.find((element: any) => element.tag === "action");
+    expect(action.actions[0].value).toEqual({
+      action: "codex_reset_confirm",
+      decision: "yes",
+      parentMessageId: "usage-message",
+      requestId: "request-1",
+    });
+  });
+
+  it("consumes a reset credit, sends the result, and collapses the confirmation card when user confirms", async () => {
+    const d = deps();
+    await handleCodexResetCardAction(event({ action: "codex_reset_request" }, "usage-message"), d);
+
+    await expect(handleCodexResetCardAction(
+      event({
+        action: "codex_reset_confirm",
+        decision: "yes",
+        parentMessageId: "usage-message",
+        requestId: "request-1",
+      }, "confirm-message"),
+      d,
+    )).resolves.toBe(true);
+
+    expect(d.consumeCodexRateLimitResetCredit).toHaveBeenCalledWith("request-1");
+    expect(d.updateCardMessage).toHaveBeenCalledTimes(1);
+    expect(d.updateCardMessage.mock.calls[0][1]).toBe("confirm-message");
+    expect(JSON.parse(d.updateCardMessage.mock.calls[0][2]).elements).toEqual([
+      { tag: "markdown", content: " " },
+    ]);
+    expect(d.recallMessage).toHaveBeenCalledWith("tenant-token", "confirm-message");
+    expect(d.sendTextReply).toHaveBeenCalledWith(
+      "tenant-token",
+      "chat-1",
+      expect.stringContaining("重置成功"),
+    );
+    expect(d.sendCardReply).not.toHaveBeenCalled();
+  });
+
+  it("does not consume a reset credit and sends a cancellation message when user declines", async () => {
+    const d = deps();
+    await handleCodexResetCardAction(event({ action: "codex_reset_request" }, "usage-message"), d);
+
+    await expect(handleCodexResetCardAction(
+      event({
+        action: "codex_reset_confirm",
+        decision: "no",
+        parentMessageId: "usage-message",
+        requestId: "request-1",
+      }, "confirm-message"),
+      d,
+    )).resolves.toBe(true);
+
+    expect(d.consumeCodexRateLimitResetCredit).not.toHaveBeenCalled();
+    expect(d.updateCardMessage).toHaveBeenCalledTimes(1);
+    expect(d.recallMessage).toHaveBeenCalledWith("tenant-token", "confirm-message");
+    expect(d.sendTextReply).toHaveBeenCalledWith(
+      "tenant-token",
+      "chat-1",
+      "Codex 主动重置：用户取消了重置。",
+    );
+    expect(d.sendCardReply).not.toHaveBeenCalled();
+  });
+
+  it("can collapse a confirmation card using context.message_id fallback", async () => {
+    const d = deps();
+    await handleCodexResetCardAction(event({ action: "codex_reset_request" }, "usage-message"), d);
+
+    await expect(handleCodexResetCardAction({
+      event: {
+        context: {
+          message_id: "confirm-message-from-context",
+          open_chat_id: "chat-1",
+        },
+        action: {
+          value: {
+            action: "codex_reset_confirm",
+            decision: "no",
+            parentMessageId: "usage-message",
+            requestId: "request-1",
+          },
+        },
+      },
+    }, d)).resolves.toBe(true);
+
+    expect(d.updateCardMessage).toHaveBeenCalledTimes(1);
+    expect(d.updateCardMessage.mock.calls[0][1]).toBe("confirm-message-from-context");
+    expect(d.recallMessage).toHaveBeenCalledWith("tenant-token", "confirm-message-from-context");
+  });
+});