chatccc 0.2.194 → 0.2.196

package/config.sample.json

@@ -28,13 +28,19 @@
       "retentionDays": 7,
       "keepCompleted": false
     },
-    "codex": {
-      "enabled": false,
-      "maxBytesPerTurn": 52428800,
-      "retentionDays": 7,
-      "keepCompleted": false
-    }
-  },
+    "codex": {
+      "enabled": false,
+      "maxBytesPerTurn": 52428800,
+      "retentionDays": 7,
+      "keepCompleted": false
+    },
+    "ccc": {
+      "enabled": false,
+      "maxBytesPerTurn": 52428800,
+      "retentionDays": 7,
+      "keepCompleted": false
+    }
+  },
   "claude": {
     "enabled": false,
     "defaultAgent": true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chatccc",
-  "version": "0.2.194",
+  "version": "0.2.196",
   "description": "Feishu bot bridge for Claude Code",
   "license": "Apache-2.0",
   "type": "module",

package/src/__tests__/builtin-chat-session.test.ts

@@ -4,8 +4,14 @@ import { join } from "node:path";
 
 import { afterEach, describe, expect, it, vi } from "vitest";
 
+import { config } from "../config.ts";
+
 const streamTextMock = vi.fn();
 const generateTextMock = vi.fn();
+const createRawStreamLogMock = vi.fn();
+const rawLogWriteLineMock = vi.fn();
+const rawLogCloseMock = vi.fn();
+const originalRawStreamLogs = structuredClone(config.rawStreamLogs);
 
 vi.mock("@ai-sdk/openai-compatible", () => ({
   createOpenAICompatible: vi.fn(() => (modelId: string) => ({ modelId })),
@@ -14,6 +20,13 @@ vi.mock("@ai-sdk/openai-compatible", () => ({
 vi.mock("ai", () => ({
   streamText: streamTextMock,
   generateText: generateTextMock,
+  stepCountIs: vi.fn((count: number) => ({ count })),
+  jsonSchema: vi.fn((schema: unknown) => schema),
+  tool: vi.fn((definition: unknown) => definition),
+}));
+
+vi.mock("../adapters/raw-stream-log.ts", () => ({
+  createRawStreamLog: createRawStreamLogMock,
 }));
 
 async function collect(iterable: AsyncIterable<unknown>): Promise<unknown[]> {
@@ -26,9 +39,17 @@ async function* textStream(...chunks: string[]): AsyncIterable<string> {
   for (const chunk of chunks) yield chunk;
 }
 
+async function* fullStream(...parts: unknown[]): AsyncIterable<unknown> {
+  for (const part of parts) yield part;
+}
+
 afterEach(() => {
   streamTextMock.mockReset();
   generateTextMock.mockReset();
+  createRawStreamLogMock.mockReset();
+  rawLogWriteLineMock.mockReset();
+  rawLogCloseMock.mockReset();
+  config.rawStreamLogs = structuredClone(originalRawStreamLogs);
 });
 
 describe("ChatSession context management", () => {
@@ -73,4 +94,88 @@ describe("ChatSession context management", () => {
     expect(events).toContainEqual({ type: "compact", compactedMessages: 2 });
     expect(restored.history.map((m) => m.content).join("\n")).toContain("new answer");
   });
+
+  it("streams tool calls and tool results from fullStream", async () => {
+    const { ChatSession } = await import("../builtin/index.ts");
+    const dir = await mkdtemp(join(tmpdir(), "chatccc-session-tools-"));
+    const session = new ChatSession(
+      { apiKey: "sk-test" },
+      {
+        persist: true,
+        contextDir: dir,
+        sessionId: "tools",
+      },
+    );
+
+    streamTextMock.mockReturnValueOnce({
+      fullStream: fullStream(
+        { type: "tool-call", toolCallId: "call-1", toolName: "read_file", input: { path: "package.json" } },
+        { type: "tool-result", toolCallId: "call-1", toolName: "read_file", output: { content: "{}" } },
+        { type: "text-delta", text: "done" },
+      ),
+    });
+
+    const events = await collect(session.chat("read package"));
+
+    expect(events).toContainEqual({
+      type: "tool_use",
+      id: "call-1",
+      name: "read_file",
+      input: { path: "package.json" },
+    });
+    expect(events).toContainEqual({
+      type: "tool_result",
+      tool_use_id: "call-1",
+      name: "read_file",
+      content: { content: "{}" },
+      is_error: false,
+    });
+    expect(events).toContainEqual({ type: "text", text: "done", accumulated: "done" });
+  });
+
+  it("writes raw CCC fullStream parts when raw stream logs are enabled", async () => {
+    const { ChatSession } = await import("../builtin/index.ts");
+    config.rawStreamLogs.ccc = {
+      enabled: true,
+      maxBytesPerTurn: 4096,
+      retentionDays: 3,
+      keepCompleted: true,
+    };
+    createRawStreamLogMock.mockResolvedValueOnce({
+      filePath: "raw.jsonl.gz",
+      writeLine: rawLogWriteLineMock,
+      close: rawLogCloseMock,
+    });
+    const session = new ChatSession(
+      { apiKey: "sk-test" },
+      {
+        sessionId: "raw-log-session",
+      },
+    );
+    const textPart = { type: "text-delta", text: "hello" };
+    const toolPart = {
+      type: "tool-call",
+      toolCallId: "call-1",
+      toolName: "read_file",
+      input: { path: "package.json" },
+    };
+
+    streamTextMock.mockReturnValueOnce({
+      fullStream: fullStream(textPart, toolPart),
+    });
+
+    await collect(session.chat("hi"));
+
+    expect(createRawStreamLogMock).toHaveBeenCalledWith(expect.objectContaining({
+      enabled: true,
+      tool: "ccc",
+      sessionId: "raw-log-session",
+      label: "prompt",
+      maxBytesPerTurn: 4096,
+      retentionDays: 3,
+    }));
+    expect(rawLogWriteLineMock).toHaveBeenNthCalledWith(1, JSON.stringify(textPart));
+    expect(rawLogWriteLineMock).toHaveBeenNthCalledWith(2, JSON.stringify(toolPart));
+    expect(rawLogCloseMock).toHaveBeenCalledWith({ keep: true });
+  });
 });

package/src/__tests__/builtin-file-tools.test.ts

@@ -0,0 +1,196 @@
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import { mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+
+import { afterEach, describe, expect, it } from "vitest";
+
+import {
+  applyPatchForTool,
+  createFileForTool,
+  deleteFileForTool,
+  editFileForTool,
+  listDirForTool,
+  moveFileForTool,
+  readFileForTool,
+  searchCodeForTool,
+} from "../builtin/file-tools.ts";
+
+const execFileAsync = promisify(execFile);
+const tempDirs: string[] = [];
+
+async function makeTempDir(): Promise<string> {
+  const dir = await mkdtemp(join(tmpdir(), "chatccc-builtin-tools-"));
+  tempDirs.push(dir);
+  return dir;
+}
+
+async function hasRg(): Promise<boolean> {
+  try {
+    await execFileAsync("rg", ["--version"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function sha256(text: string): string {
+  return createHash("sha256").update(text).digest("hex");
+}
+
+afterEach(async () => {
+  await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
+});
+
+describe("builtin file tools", () => {
+  it("reads a text file with line ranges", async () => {
+    const dir = await makeTempDir();
+    await writeFile(join(dir, ".secret.txt"), "one\ntwo\nthree\n", "utf8");
+
+    const result = await readFileForTool(dir, { path: ".secret.txt", startLine: 2, endLine: 3 });
+
+    expect(result).toEqual(expect.objectContaining({
+      sha256: sha256("one\ntwo\nthree\n"),
+      isBinary: false,
+      content: "two\nthree",
+      startLine: 2,
+      endLine: 3,
+      totalLines: 4,
+    }));
+    expect(result.path).toContain(".secret.txt");
+  });
+
+  it("lists directory entries including hidden files", async () => {
+    const dir = await makeTempDir();
+    await writeFile(join(dir, ".env"), "TOKEN=x", "utf8");
+
+    const result = await listDirForTool(dir);
+
+    expect(result.entries).toContainEqual(expect.objectContaining({
+      name: ".env",
+      type: "file",
+    }));
+  });
+
+  it("searches code with rg without using a shell", async () => {
+    if (!await hasRg()) return;
+
+    const dir = await makeTempDir();
+    await writeFile(join(dir, "a.ts"), "const marker = 1;\n", "utf8");
+
+    const result = await searchCodeForTool(dir, { query: "marker", glob: "*.ts" });
+
+    expect(result.matches).toEqual([
+      expect.objectContaining({
+        line: 1,
+        text: "const marker = 1;",
+      }),
+    ]);
+  });
+
+  it("edits a file with exact replacements and a SHA-256 precondition", async () => {
+    const dir = await makeTempDir();
+    const file = join(dir, "edit.txt");
+    await writeFile(file, "alpha\nbeta\ngamma\n", "utf8");
+
+    const result = await editFileForTool(dir, {
+      path: "edit.txt",
+      expectedSha256: sha256("alpha\nbeta\ngamma\n"),
+      edits: [{ oldText: "beta", newText: "BETA" }],
+    });
+
+    expect(result).toEqual(expect.objectContaining({
+      changed: true,
+      editsApplied: 1,
+      beforeSha256: sha256("alpha\nbeta\ngamma\n"),
+      afterSha256: sha256("alpha\nBETA\ngamma\n"),
+    }));
+    await expect(readFile(file, "utf8")).resolves.toBe("alpha\nBETA\ngamma\n");
+  });
+
+  it("rejects edits when the SHA-256 precondition does not match", async () => {
+    const dir = await makeTempDir();
+    await writeFile(join(dir, "edit.txt"), "current\n", "utf8");
+
+    await expect(editFileForTool(dir, {
+      path: "edit.txt",
+      expectedSha256: sha256("stale\n"),
+      edits: [{ oldText: "current", newText: "next" }],
+    })).rejects.toThrow("SHA-256 mismatch");
+  });
+
+  it("creates and deletes files", async () => {
+    const dir = await makeTempDir();
+
+    const created = await createFileForTool(dir, {
+      path: "created.txt",
+      content: "created\n",
+    });
+    expect(created).toEqual(expect.objectContaining({
+      changed: true,
+      afterSha256: sha256("created\n"),
+    }));
+    await expect(readFile(join(dir, "created.txt"), "utf8")).resolves.toBe("created\n");
+
+    const deleted = await deleteFileForTool(dir, {
+      path: "created.txt",
+      expectedSha256: sha256("created\n"),
+    });
+    expect(deleted).toEqual(expect.objectContaining({
+      deleted: true,
+      beforeSha256: sha256("created\n"),
+    }));
+    await expect(stat(join(dir, "created.txt"))).rejects.toThrow();
+  });
+
+  it("moves files and creates the destination directory", async () => {
+    const dir = await makeTempDir();
+    await writeFile(join(dir, "old.txt"), "move me\n", "utf8");
+
+    const result = await moveFileForTool(dir, {
+      sourcePath: "old.txt",
+      destinationPath: "nested/new.txt",
+      expectedSourceSha256: sha256("move me\n"),
+    });
+
+    expect(result).toEqual(expect.objectContaining({
+      moved: true,
+      sourceSha256: sha256("move me\n"),
+    }));
+    await expect(stat(join(dir, "old.txt"))).rejects.toThrow();
+    await expect(readFile(join(dir, "nested", "new.txt"), "utf8")).resolves.toBe("move me\n");
+  });
+
+  it("applies a unified diff patch", async () => {
+    const dir = await makeTempDir();
+    await writeFile(join(dir, "patch.txt"), "one\ntwo\nthree\n", "utf8");
+
+    const result = await applyPatchForTool(dir, {
+      patch: [
+        "--- a/patch.txt",
+        "+++ b/patch.txt",
+        "@@ -1,4 +1,4 @@",
+        " one",
+        "-two",
+        "+TWO",
+        " three",
+        " ",
+        "",
+      ].join("\n"),
+      expectedSha256ByPath: {
+        "patch.txt": sha256("one\ntwo\nthree\n"),
+      },
+    });
+
+    expect(result.changedFiles).toEqual([
+      expect.objectContaining({
+        action: "edit",
+        beforeSha256: sha256("one\ntwo\nthree\n"),
+        afterSha256: sha256("one\nTWO\nthree\n"),
+      }),
+    ]);
+    await expect(readFile(join(dir, "patch.txt"), "utf8")).resolves.toBe("one\nTWO\nthree\n");
+  });
+});

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

@@ -14,12 +14,19 @@ vi.mock("@ai-sdk/openai-compatible", () => ({
 vi.mock("ai", () => ({
   streamText: streamTextMock,
   generateText: generateTextMock,
+  stepCountIs: vi.fn((count: number) => ({ count })),
+  jsonSchema: vi.fn((schema: unknown) => schema),
+  tool: vi.fn((definition: unknown) => definition),
 }));
 
 async function* textStream(...chunks: string[]): AsyncIterable<string> {
   for (const chunk of chunks) yield chunk;
 }
 
+async function* fullStream(...parts: unknown[]): AsyncIterable<unknown> {
+  for (const part of parts) yield part;
+}
+
 afterEach(() => {
   streamTextMock.mockReset();
   generateTextMock.mockReset();
@@ -70,4 +77,37 @@ describe("createCccAdapter", () => {
       model: { modelId: "deepseek-v4-flash" },
     }));
   });
+
+  it("maps ChatSession tool events to unified tool blocks", async () => {
+    const { createCccAdapter } = await import("../adapters/ccc-adapter.ts");
+    const contextDir = await mkdtemp(join(tmpdir(), "chatccc-ccc-adapter-tools-"));
+    const adapter = createCccAdapter({
+      apiKey: "sk-test",
+      contextDir,
+      model: "deepseek-v4-flash",
+    });
+    const { sessionId } = await adapter.createSession("F:\\repo");
+    streamTextMock.mockReturnValueOnce({
+      fullStream: fullStream(
+        { type: "tool-call", toolCallId: "call-1", toolName: "read_file", input: { path: "README.md" } },
+        { type: "tool-result", toolCallId: "call-1", toolName: "read_file", output: { content: "hello" } },
+      ),
+    });
+
+    const messages = [];
+    for await (const message of adapter.prompt(sessionId, "read", "F:\\repo")) {
+      messages.push(message);
+    }
+
+    expect(messages).toEqual([
+      {
+        type: "assistant",
+        blocks: [{ type: "tool_use", id: "call-1", name: "read_file", input: { path: "README.md" } }],
+      },
+      {
+        type: "assistant",
+        blocks: [{ type: "tool_result", tool_use_id: "call-1", content: { content: "hello" }, is_error: false }],
+      },
+    ]);
+  });
 });

package/src/__tests__/config-reload.test.ts

@@ -45,11 +45,12 @@ const baseAppConfig: AppConfig = {
   port: 18080,
   gitTimeoutSeconds: 180,
   allowInterrupt: false,
-  rawStreamLogs: {
-    claude: { enabled: false, maxBytesPerTurn: 52_428_800, retentionDays: 7, keepCompleted: false },
-    cursor: { enabled: false, maxBytesPerTurn: 52_428_800, retentionDays: 7, keepCompleted: false },
-    codex: { enabled: false, maxBytesPerTurn: 52_428_800, retentionDays: 7, keepCompleted: false },
-  },
+  rawStreamLogs: {
+    claude: { enabled: false, maxBytesPerTurn: 52_428_800, retentionDays: 7, keepCompleted: false },
+    cursor: { enabled: false, maxBytesPerTurn: 52_428_800, retentionDays: 7, keepCompleted: false },
+    codex: { enabled: false, maxBytesPerTurn: 52_428_800, retentionDays: 7, keepCompleted: false },
+    ccc: { enabled: false, maxBytesPerTurn: 52_428_800, retentionDays: 7, keepCompleted: false },
+  },
   claude: {
     enabled: true,
     defaultAgent: true,

package/src/__tests__/config-sample.test.ts

@@ -72,7 +72,7 @@ describe("config.sample.json", () => {
       }>;
     };
 
-    for (const tool of ["claude", "cursor", "codex"]) {
+    for (const tool of ["claude", "cursor", "codex", "ccc"]) {
       expect(sample.rawStreamLogs?.[tool]?.enabled).toBe(false);
       expect(sample.rawStreamLogs?.[tool]?.maxBytesPerTurn).toBe(52_428_800);
       expect(sample.rawStreamLogs?.[tool]?.retentionDays).toBe(7);

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

@@ -1,9 +1,16 @@
-import { describe, it, expect } from "vitest";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import { normalizeCursorMessage, createCursorAdapter } from "../adapters/cursor-adapter.ts";
-import type { UnifiedStreamMessage } from "../adapters/adapter-interface.ts";
+import { describe, it, expect } from "vitest";
+import { EventEmitter } from "node:events";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { PassThrough } from "node:stream";
+import type { ChildProcess } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import {
+  normalizeCursorMessage,
+  createCursorAdapter,
+  formatCursorAgentEmptyOutputMessage,
+} from "../adapters/cursor-adapter.ts";
+import type { UnifiedStreamMessage } from "../adapters/adapter-interface.ts";
 import type {
   CursorSessionMeta,
   CursorSessionMetaStore,
@@ -37,12 +44,43 @@ function createInMemoryMetaStore(
   };
 }
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-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));
-}
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+type CursorSpawnForTest = NonNullable<
+  NonNullable<Parameters<typeof createCursorAdapter>[0]>["spawn"]
+>;
+
+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));
+}
+
+function createMockCursorProcess(args: {
+  stdout?: string;
+  stderr?: string;
+  exitCode?: number;
+}): 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,
+  });
+
+  setImmediate(() => {
+    if (args.stdout) stdout.write(args.stdout);
+    if (args.stderr) stderr.write(args.stderr);
+    stdout.end();
+    stderr.end();
+    child.emit("close", args.exitCode ?? 0, null);
+  });
+
+  return child;
+}
 
 // ---------------------------------------------------------------------------
 // normalizeCursorMessage — 核心映射逻辑测试（纯函数）
@@ -642,7 +680,7 @@ describe("Cursor stream fixture - 端到端不重复", () => {
     });
   });
 
-  it("mapToolCallKey: maps known keys to readable names", () => {
+  it("mapToolCallKey: maps known keys to readable names", () => {
     const cases: [string, string][] = [
       ["globToolCall", "Glob"],
       ["shellToolCall", "Bash"],
@@ -658,6 +696,65 @@ describe("Cursor stream fixture - 端到端不重复", () => {
         tool_call: { [raw]: { args: {} } },
       } as Parameters<typeof normalizeCursorMessage>[0]);
       expect(r!.blocks[0]).toMatchObject({ type: "tool_use", name: expected });
-    }
-  });
-});
+    }
+  });
+});
+
+describe("Cursor adapter process failures", () => {
+  it("formats empty stdout auth stderr as a cautious visible message", () => {
+    const message = formatCursorAgentEmptyOutputMessage({
+      exitCode: 1,
+      stdoutLength: 0,
+      stderr: "Error: Authentication required. Please run 'agent login' first, or set CURSOR_API_KEY environment variable.\n",
+    });
+
+    expect(message).toContain("检测到认证相关错误");
+    expect(message).toContain("可能需要重新登录 Cursor Agent");
+    expect(message).toContain("CURSOR_API_KEY");
+    expect(message).toContain("agent status");
+    expect(message).toContain("agent login");
+    expect(message).not.toContain("登录态已失效");
+  });
+
+  it("does not format a message when stdout is non-empty", () => {
+    expect(
+      formatCursorAgentEmptyOutputMessage({
+        exitCode: 1,
+        stdoutLength: 10,
+        stderr: "Error: Authentication required",
+      }),
+    ).toBeNull();
+  });
+
+  it("prompt surfaces auth-related empty output before failing the stream", async () => {
+    const store = createInMemoryMetaStore({ sid: { cwd: "F:/repo" } });
+    const spawnImpl = (() =>
+      createMockCursorProcess({
+        exitCode: 1,
+        stderr: "Error: Authentication required. Please run 'agent login' first, or set CURSOR_API_KEY environment variable.\n",
+      })) as CursorSpawnForTest;
+    const adapter = createCursorAdapter({ metaStore: store, spawn: spawnImpl });
+    const iterator = adapter.prompt(
+      "sid",
+      "[User message]\nhello\n[/User message]",
+      "F:/repo",
+    )[Symbol.asyncIterator]();
+
+    const first = await iterator.next();
+    expect(first.done).toBe(false);
+    expect(first.value.blocks).toHaveLength(1);
+    expect(first.value.blocks[0]).toMatchObject({ type: "text_final" });
+    expect(first.value.blocks[0]).toHaveProperty(
+      "text",
+      expect.stringContaining("可能需要重新登录 Cursor Agent"),
+    );
+    expect(first.value.blocks[0]).toHaveProperty(
+      "text",
+      expect.not.stringContaining("登录态已失效"),
+    );
+
+    await expect(iterator.next()).rejects.toThrow(
+      /Cursor Agent exited without stream-json output/,
+    );
+  });
+});

package/src/adapters/ccc-adapter.ts

@@ -74,6 +74,26 @@ export function createCccAdapter(options: CccAdapterOptions = {}): ToolAdapter {
             type: "assistant",
             blocks: [{ type: "text", text: event.text }],
           };
+        } else if (event.type === "tool_use") {
+          yield {
+            type: "assistant",
+            blocks: [{
+              type: "tool_use",
+              id: event.id,
+              name: event.name,
+              input: event.input,
+            }],
+          };
+        } else if (event.type === "tool_result") {
+          yield {
+            type: "assistant",
+            blocks: [{
+              type: "tool_result",
+              tool_use_id: event.tool_use_id,
+              content: event.content,
+              is_error: event.is_error,
+            }],
+          };
         } else if (event.type === "error") {
           throw new Error(event.message);
         }