chatccc 0.2.252 → 0.2.254

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

@@ -1,331 +0,0 @@
-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,
-  createCodexAdapter,
-  type CreateCodexAdapterOptions,
-} from "../adapters/codex-adapter.ts";
-import type { UnifiedStreamMessage } from "../adapters/adapter-interface.ts";
-import {
-  type CodexSessionMeta,
-  type CodexSessionMetaStore,
-} 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"');
-  });
-});
-
-function readFixture(name: string): unknown[] {
-  const raw = readFileSync(join(__dirname, "fixtures", name), "utf-8");
-  return raw
-    .split(/\r?\n/)
-    .filter(Boolean)
-    .map((line) => JSON.parse(line));
-}
-
-// 进程内内存版 meta store
-function createInMemoryMetaStore(
-  initial: Record<string, CodexSessionMeta> = {},
-): CodexSessionMetaStore & { snapshot(): Record<string, CodexSessionMeta> } {
-  const map = new Map<string, CodexSessionMeta>(Object.entries(initial));
-  return {
-    async get(sid) {
-      return map.get(sid);
-    },
-    async set(sid, partial) {
-      const existing = map.get(sid) ?? { cwd: "" };
-      const merged: CodexSessionMeta = { ...existing, ...partial };
-      if (typeof merged.cwd !== "string" || merged.cwd.length === 0) return;
-      map.set(sid, merged);
-    },
-    async setThreadId(sid, threadId) {
-      const existing = map.get(sid);
-      if (existing) {
-        map.set(sid, { ...existing, threadId });
-      }
-    },
-    snapshot() {
-      return Object.fromEntries(map);
-    },
-  };
-}
-
-// ---------------------------------------------------------------------------
-// normalizeCodexMessage — 核心映射逻辑测试（纯函数）
-// ---------------------------------------------------------------------------
-
-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" },
-    });
-    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({
-      type: "item.started",
-      item: {
-        id: "item_0",
-        type: "command_execution",
-        command: "powershell.exe -Command ls",
-        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" } },
-    ]);
-  });
-
-  it("normalizes command_execution completion as tool_result (success)", () => {
-    const result = normalizeCodexMessage({
-      type: "item.completed",
-      item: {
-        id: "item_0",
-        type: "command_execution",
-        command: "ls",
-        aggregated_output: "file1\nfile2\n",
-        exit_code: 0,
-        status: "completed",
-      },
-    });
-    expect(result).not.toBeNull();
-    expect(result!.blocks).toEqual([
-      {
-        type: "tool_result",
-        tool_use_id: "item_0",
-        content: "file1\nfile2\n",
-        is_error: undefined,
-      },
-    ]);
-  });
-
-  it("normalizes command_execution completion as tool_result (error)", () => {
-    const result = normalizeCodexMessage({
-      type: "item.completed",
-      item: {
-        id: "item_err",
-        type: "command_execution",
-        command: "nonexistent",
-        aggregated_output: "command not found",
-        exit_code: 127,
-        status: "completed",
-      },
-    });
-    expect(result).not.toBeNull();
-    expect(result!.blocks).toEqual([
-      {
-        type: "tool_result",
-        tool_use_id: "item_err",
-        content: "command not found",
-        is_error: true,
-      },
-    ]);
-  });
-
-  it("returns null for thread.started events", () => {
-    expect(
-      normalizeCodexMessage({
-        type: "thread.started",
-        thread_id: "abc-123",
-      }),
-    ).toBeNull();
-  });
-
-  it("returns null for turn.started events", () => {
-    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("returns null for unknown event types", () => {
-    expect(normalizeCodexMessage({ type: "unknown" })).toBeNull();
-    expect(normalizeCodexMessage({} as Parameters<typeof normalizeCodexMessage>[0])).toBeNull();
-  });
-
-  it("returns null for agent_message with empty text", () => {
-    const result = normalizeCodexMessage({
-      type: "item.completed",
-      item: { id: "item_0", type: "agent_message", text: "" },
-    });
-    expect(result).toBeNull();
-  });
-
-  it("returns null for command_execution start without command text", () => {
-    const result = normalizeCodexMessage({
-      type: "item.started",
-      item: { id: "item_0", type: "command_execution", status: "in_progress" },
-    });
-    expect(result).toBeNull();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Fixture 端到端测试
-// ---------------------------------------------------------------------------
-
-describe("Codex stream fixtures", () => {
-  it("simple text: 流结束后 pickFinalReply 返回正确文本", () => {
-    const lines = readFixture("codex_simple_text.jsonl");
-    const state: AccumulatorState = {
-      accumulatedContent: "",
-      finalText: "",
-      finalCompleteText: "",
-      chunkCount: 0,
-    };
-    for (const raw of lines) {
-      const normalized = normalizeCodexMessage(
-        raw as Parameters<typeof normalizeCodexMessage>[0],
-      );
-      if (!normalized) continue;
-      for (const block of normalized.blocks) {
-        accumulateBlockContent(block, state);
-      }
-    }
-
-    expect(pickFinalReply(state)).toBe("hello");
-  });
-
-  it("with tool: 流结束后 pickFinalReply 返回最终文本（不含工具输出在 finalText 中）", () => {
-    const lines = readFixture("codex_with_tool.jsonl");
-    const state: AccumulatorState = {
-      accumulatedContent: "",
-      finalText: "",
-      finalCompleteText: "",
-      chunkCount: 0,
-    };
-    for (const raw of lines) {
-      const normalized = normalizeCodexMessage(
-        raw as Parameters<typeof normalizeCodexMessage>[0],
-      );
-      if (!normalized) continue;
-      for (const block of normalized.blocks) {
-        accumulateBlockContent(block, state);
-      }
-    }
-
-    // finalText 应该只包含最终的 agent_message
-    expect(pickFinalReply(state)).toBe("tool_test");
-    // accumulatedContent 包含工具调用信息
-    expect(state.accumulatedContent).toContain("Bash");
-    expect(state.accumulatedContent).toContain("tool_test");
-  });
-
-  it("with tool: 普通输出不标终态，只有 turn.completed 标记终态", () => {
-    const lines = readFixture("codex_with_tool.jsonl");
-    const messages: UnifiedStreamMessage[] = [];
-    for (const raw of lines) {
-      const normalized = normalizeCodexMessage(
-        raw as Parameters<typeof normalizeCodexMessage>[0],
-      );
-      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,
-    });
-  });
-});
-
-// ---------------------------------------------------------------------------
-// createCodexAdapter — 工厂函数测试
-// ---------------------------------------------------------------------------
-
-describe("createCodexAdapter", () => {
-  it("returns adapter with correct displayName and sessionDescPrefix", () => {
-    const adapter = createCodexAdapter();
-    expect(adapter.displayName).toBe("Codex");
-    expect(adapter.sessionDescPrefix).toBe("Codex Session:");
-  });
-
-  it("closeSession does not throw", async () => {
-    const adapter = createCodexAdapter();
-    await expect(adapter.closeSession("any-id")).resolves.toBeUndefined();
-  });
-
-  it("getSessionInfo: store 中无该 sessionId 时返回 undefined", async () => {
-    const store = createInMemoryMetaStore();
-    const adapter = createCodexAdapter({ metaStore: store });
-    const info = await adapter.getSessionInfo("unknown-sid");
-    expect(info).toBeUndefined();
-  });
-
-  it("getSessionInfo: store 有 cwd 时返回 cwd，无 threadId", async () => {
-    const store = createInMemoryMetaStore({
-      "sid-known": { cwd: "F:/proj/Foo" },
-    });
-    const adapter = createCodexAdapter({ metaStore: store });
-    const info = await adapter.getSessionInfo("sid-known");
-    expect(info).toEqual({ sessionId: "sid-known", cwd: "F:/proj/Foo" });
-  });
-
-  it("getSessionInfo: 有 cwd + threadId 时一并返回", async () => {
-    const store = createInMemoryMetaStore({
-      "sid-known": { cwd: "F:/proj/Foo", threadId: "thread-123" },
-    });
-    const adapter = createCodexAdapter({ metaStore: store });
-    const info = await adapter.getSessionInfo("sid-known");
-    expect(info).toEqual({
-      sessionId: "sid-known",
-      cwd: "F:/proj/Foo",
-    });
-  });
-
-  it("getSessionInfo: 不同 sessionId 互不影响", async () => {
-    const store = createInMemoryMetaStore({
-      "sid-A": { cwd: "/a", threadId: "tA" },
-      "sid-B": { cwd: "/b" },
-    });
-    const adapter = createCodexAdapter({ metaStore: store });
-    expect(await adapter.getSessionInfo("sid-A")).toEqual({
-      sessionId: "sid-A",
-      cwd: "/a",
-    });
-    expect(await adapter.getSessionInfo("sid-B")).toEqual({
-      sessionId: "sid-B",
-      cwd: "/b",
-    });
-    expect(await adapter.getSessionInfo("sid-C")).toBeUndefined();
-  });
-});

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

@@ -1,170 +0,0 @@
-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 +0,0 @@
-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");
-  });
-});