chatccc 0.2.231 → 0.2.233

package/src/__tests__/builtin-permissions.test.ts

@@ -1,211 +1,211 @@
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-const testHome = vi.hoisted(() => ({ dir: "" }));
-
-const aiMocks = vi.hoisted(() => ({
-  streamText: vi.fn(),
-  generateText: vi.fn(),
-}));
-
-vi.mock("node:os", async () => {
-  const actual = await vi.importActual<typeof import("node:os")>("node:os");
-  const [{ mkdtempSync }, { join }] = await Promise.all([import("node:fs"), import("node:path")]);
-  testHome.dir = mkdtempSync(join(actual.tmpdir(), "chatccc-builtin-perm-"));
-  return { ...actual, homedir: () => testHome.dir };
-});
-
-vi.mock("@ai-sdk/openai-compatible", () => ({
-  createOpenAICompatible: vi.fn(() => (modelId: string) => ({ modelId })),
-}));
-
-vi.mock("ai", () => ({
-  streamText: aiMocks.streamText,
-  generateText: aiMocks.generateText,
-  isLoopFinished: vi.fn(() => ({ loopFinished: true })),
-  stepCountIs: vi.fn((count: number) => ({ count })),
-  jsonSchema: vi.fn((schema: unknown) => schema),
-  tool: vi.fn((definition: unknown) => definition),
-}));
-
-vi.mock("../builtin/raw-stream-log.ts", () => ({
-  createRawStreamLog: vi.fn().mockResolvedValue(null),
-}));
-
-import {
-  PermissionGate,
-  getAllowRules,
-  isDangerousCommand,
-  matchRule,
-  reloadAllowRules,
-} from "../builtin/permissions.ts";
-import { createBuiltinFileTools } from "../builtin/file-tools.ts";
-import { ChatSession } from "../builtin/index.ts";
-
-const streamTextMock = aiMocks.streamText;
-const generateTextMock = aiMocks.generateText;
-
-const ALLOW_FILE = () => join(testHome.dir, ".deepccc", "allow.json");
-
-async function collect(iterable: AsyncIterable<unknown>): Promise<unknown[]> {
-  const events: unknown[] = [];
-  for await (const event of iterable) events.push(event);
-  return events;
-}
-
-async function* textStream(...chunks: string[]): AsyncIterable<string> {
-  for (const chunk of chunks) yield chunk;
-}
-
-function lastRunCommandExecute(): (input: { command: string }, opts?: unknown) => Promise<unknown> {
-  const call = streamTextMock.mock.calls.at(-1)?.[0] as { tools?: Record<string, { execute?: unknown }> };
-  const execute = call?.tools?.run_command?.execute as ((input: { command: string }, opts?: unknown) => Promise<unknown>) | undefined;
-  if (!execute) throw new Error("streamText was not called with tools.run_command.execute");
-  return execute;
-}
-
-afterEach(() => {
-  try {
-    rmSync(ALLOW_FILE(), { force: true });
-  } catch {}
-  reloadAllowRules();
-  streamTextMock.mockReset();
-  generateTextMock.mockReset();
-});
-
-beforeEach(() => {
-  try {
-    rmSync(join(testHome.dir, ".deepccc"), { recursive: true, force: true });
-  } catch {}
-  mkdirSync(join(testHome.dir, ".deepccc"), { recursive: true });
-  reloadAllowRules();
-});
-
-describe("builtin permissions module", () => {
-  it("flags destructive commands and ignores normal ones", () => {
-    expect(isDangerousCommand("rm -rf node_modules")).toBe(true);
-    expect(isDangerousCommand("git push --force origin main")).toBe(true);
-    expect(isDangerousCommand("git status")).toBe(false);
-    expect(isDangerousCommand("npm test")).toBe(false);
-  });
-
-  it("matches allow/deny rules with wildcards and relative paths", () => {
-    expect(matchRule("run_command:git status*", "run_command:git status --short")).toBe(true);
-    expect(matchRule("edit_file:node_modules/**", "edit_file:node_modules/a/b.js")).toBe(true);
-    expect(matchRule("run_command:npm test", "run_command:npm test extra")).toBe(false);
-  });
-
-  it("returns empty rules when allow.json is missing", () => {
-    expect(getAllowRules()).toEqual({ allow: [], deny: [] });
-  });
-
-  it("loads rules from ~/.deepccc/allow.json", () => {
-    writeFileSync(ALLOW_FILE(), JSON.stringify({ deny: ["run_command:npm publish*"] }), "utf-8");
-    reloadAllowRules();
-    expect(getAllowRules().deny).toEqual(["run_command:npm publish*"]);
-  });
-});
-
-describe("builtin PermissionGate", () => {
-  it("bypass mode allows everything", async () => {
-    const gate = new PermissionGate("bypass");
-    expect(await gate.check({ tool: "run_command", action: "rm -rf /", reason: "high-risk", detail: "x" })).toBe("allow");
-  });
-
-  it("ask mode denies high-risk without resolver", async () => {
-    const gate = new PermissionGate("ask");
-    expect(await gate.check({ tool: "run_command", action: "rm -rf x", reason: "high-risk", detail: "x" })).toBe("deny");
-  });
-
-  it("ask mode allows non-high-risk operations without asking", async () => {
-    const resolver = vi.fn();
-    const gate = new PermissionGate("ask", resolver as never);
-    expect(await gate.check({ tool: "run_command", action: "npm test", reason: "rule", detail: "x" })).toBe("allow");
-    expect(await gate.check({ tool: "edit_file", action: "src/a.ts", reason: "rule", detail: "x" })).toBe("allow");
-    expect(resolver).not.toHaveBeenCalled();
-  });
-
-  it("follows resolver answer", async () => {
-    let answer: "allow" | "deny" = "allow";
-    const gate = new PermissionGate("ask", async () => answer);
-    expect(await gate.check({ tool: "run_command", action: "rm -rf x", reason: "high-risk", detail: "x" })).toBe("allow");
-    answer = "deny";
-    expect(await gate.check({ tool: "run_command", action: "rm -rf x", reason: "high-risk", detail: "x" })).toBe("deny");
-  });
-
-  it("deny rule wins over allow rule", async () => {
-    writeFileSync(
-      ALLOW_FILE(),
-      JSON.stringify({ allow: ["run_command:rm -rf /tmp*"], deny: ["run_command:rm -rf /tmp/forbidden*"] }),
-      "utf-8",
-    );
-    reloadAllowRules();
-    const gate = new PermissionGate("ask");
-    expect(await gate.check({ tool: "run_command", action: "rm -rf /tmp/forbidden/x", reason: "high-risk", detail: "x" })).toBe("deny");
-  });
-});
-
-describe("builtin file-tools permission integration", () => {
-  it("run_command high-risk is denied by default gate", async () => {
-    const tools = createBuiltinFileTools(testHome.dir, { permissionGate: new PermissionGate("ask") });
-    const tool = tools.run_command as unknown as {
-      execute: (input: { command: string }, opts?: unknown) => Promise<unknown>;
-    };
-    await expect(tool.execute({ command: "rm -rf node_modules" }, { abortSignal: undefined })).rejects.toThrow(/权限拒绝/);
-  });
-
-  it("no gate keeps original behavior", async () => {
-    const tools = createBuiltinFileTools(testHome.dir);
-    const tool = tools.run_command as unknown as {
-      execute: (input: { command: string }, opts?: unknown) => Promise<{ exitCode: number | null }>;
-    };
-    const result = await tool.execute({ command: "node -e \"console.log('ok')\"" }, { abortSignal: undefined });
-    expect(result.exitCode).toBe(0);
-  });
-});
-
-describe("builtin ChatSession permission integration", () => {
-  it("permissionMode bypass lets high-risk run_command execute", async () => {
-    const session = new ChatSession(
-      { apiKey: "sk-test" },
-      { sessionId: "perm-bypass", permissionMode: "bypass" },
-    );
-    streamTextMock.mockReturnValueOnce({ textStream: textStream("hi") });
-    await collect(session.chat("hi"));
-
-    const result = (await lastRunCommandExecute()({ command: "node -e \"console.log('ok')\"" }, { abortSignal: undefined })) as { exitCode: number };
-    expect(result.exitCode).toBe(0);
-  });
-
-  it("default ask mode without resolver denies high-risk run_command", async () => {
-    const session = new ChatSession(
-      { apiKey: "sk-test" },
-      { sessionId: "perm-ask" },
-    );
-    streamTextMock.mockReturnValueOnce({ textStream: textStream("hi") });
-    await collect(session.chat("hi"));
-
-    await expect(
-      lastRunCommandExecute()({ command: "rm -rf node_modules" }, { abortSignal: undefined }),
-    ).rejects.toThrow(/权限拒绝/);
-  });
-});
-
-describe("ccc-adapter uses bypass mode (aligns with claude/codex)", () => {
-  it("tools created via ccc adapter run high-risk commands without asking", async () => {
-    const { createCccAdapter } = await import("../adapters/ccc-adapter.ts");
-    const adapter = createCccAdapter({ apiKey: "sk-test", contextDir: testHome.dir });
-    const { sessionId } = await adapter.createSession(testHome.dir);
-    streamTextMock.mockReturnValueOnce({ textStream: textStream("hi") });
-
-    for await (const _m of adapter.prompt(sessionId, "hi", testHome.dir)) {
-      // drain
-    }
-
-    const result = (await lastRunCommandExecute()({ command: "node -e \"console.log('bypass')\"" }, { abortSignal: undefined })) as { exitCode: number };
-    expect(result.exitCode).toBe(0);
-  });
-});
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const testHome = vi.hoisted(() => ({ dir: "" }));
+
+const aiMocks = vi.hoisted(() => ({
+  streamText: vi.fn(),
+  generateText: vi.fn(),
+}));
+
+vi.mock("node:os", async () => {
+  const actual = await vi.importActual<typeof import("node:os")>("node:os");
+  const [{ mkdtempSync }, { join }] = await Promise.all([import("node:fs"), import("node:path")]);
+  testHome.dir = mkdtempSync(join(actual.tmpdir(), "chatccc-builtin-perm-"));
+  return { ...actual, homedir: () => testHome.dir };
+});
+
+vi.mock("@ai-sdk/openai-compatible", () => ({
+  createOpenAICompatible: vi.fn(() => (modelId: string) => ({ modelId })),
+}));
+
+vi.mock("ai", () => ({
+  streamText: aiMocks.streamText,
+  generateText: aiMocks.generateText,
+  isLoopFinished: vi.fn(() => ({ loopFinished: true })),
+  stepCountIs: vi.fn((count: number) => ({ count })),
+  jsonSchema: vi.fn((schema: unknown) => schema),
+  tool: vi.fn((definition: unknown) => definition),
+}));
+
+vi.mock("../builtin/raw-stream-log.ts", () => ({
+  createRawStreamLog: vi.fn().mockResolvedValue(null),
+}));
+
+import {
+  PermissionGate,
+  getAllowRules,
+  isDangerousCommand,
+  matchRule,
+  reloadAllowRules,
+} from "../builtin/permissions.ts";
+import { createBuiltinFileTools } from "../builtin/file-tools.ts";
+import { ChatSession } from "../builtin/index.ts";
+
+const streamTextMock = aiMocks.streamText;
+const generateTextMock = aiMocks.generateText;
+
+const ALLOW_FILE = () => join(testHome.dir, ".deepccc", "allow.json");
+
+async function collect(iterable: AsyncIterable<unknown>): Promise<unknown[]> {
+  const events: unknown[] = [];
+  for await (const event of iterable) events.push(event);
+  return events;
+}
+
+async function* textStream(...chunks: string[]): AsyncIterable<string> {
+  for (const chunk of chunks) yield chunk;
+}
+
+function lastRunCommandExecute(): (input: { command: string }, opts?: unknown) => Promise<unknown> {
+  const call = streamTextMock.mock.calls.at(-1)?.[0] as { tools?: Record<string, { execute?: unknown }> };
+  const execute = call?.tools?.run_command?.execute as ((input: { command: string }, opts?: unknown) => Promise<unknown>) | undefined;
+  if (!execute) throw new Error("streamText was not called with tools.run_command.execute");
+  return execute;
+}
+
+afterEach(() => {
+  try {
+    rmSync(ALLOW_FILE(), { force: true });
+  } catch {}
+  reloadAllowRules();
+  streamTextMock.mockReset();
+  generateTextMock.mockReset();
+});
+
+beforeEach(() => {
+  try {
+    rmSync(join(testHome.dir, ".deepccc"), { recursive: true, force: true });
+  } catch {}
+  mkdirSync(join(testHome.dir, ".deepccc"), { recursive: true });
+  reloadAllowRules();
+});
+
+describe("builtin permissions module", () => {
+  it("flags destructive commands and ignores normal ones", () => {
+    expect(isDangerousCommand("rm -rf node_modules")).toBe(true);
+    expect(isDangerousCommand("git push --force origin main")).toBe(true);
+    expect(isDangerousCommand("git status")).toBe(false);
+    expect(isDangerousCommand("npm test")).toBe(false);
+  });
+
+  it("matches allow/deny rules with wildcards and relative paths", () => {
+    expect(matchRule("run_command:git status*", "run_command:git status --short")).toBe(true);
+    expect(matchRule("edit_file:node_modules/**", "edit_file:node_modules/a/b.js")).toBe(true);
+    expect(matchRule("run_command:npm test", "run_command:npm test extra")).toBe(false);
+  });
+
+  it("returns empty rules when allow.json is missing", () => {
+    expect(getAllowRules()).toEqual({ allow: [], deny: [] });
+  });
+
+  it("loads rules from ~/.deepccc/allow.json", () => {
+    writeFileSync(ALLOW_FILE(), JSON.stringify({ deny: ["run_command:npm publish*"] }), "utf-8");
+    reloadAllowRules();
+    expect(getAllowRules().deny).toEqual(["run_command:npm publish*"]);
+  });
+});
+
+describe("builtin PermissionGate", () => {
+  it("bypass mode allows everything", async () => {
+    const gate = new PermissionGate("bypass");
+    expect(await gate.check({ tool: "run_command", action: "rm -rf /", reason: "high-risk", detail: "x" })).toBe("allow");
+  });
+
+  it("ask mode denies high-risk without resolver", async () => {
+    const gate = new PermissionGate("ask");
+    expect(await gate.check({ tool: "run_command", action: "rm -rf x", reason: "high-risk", detail: "x" })).toBe("deny");
+  });
+
+  it("ask mode allows non-high-risk operations without asking", async () => {
+    const resolver = vi.fn();
+    const gate = new PermissionGate("ask", resolver as never);
+    expect(await gate.check({ tool: "run_command", action: "npm test", reason: "rule", detail: "x" })).toBe("allow");
+    expect(await gate.check({ tool: "edit_file", action: "src/a.ts", reason: "rule", detail: "x" })).toBe("allow");
+    expect(resolver).not.toHaveBeenCalled();
+  });
+
+  it("follows resolver answer", async () => {
+    let answer: "allow" | "deny" = "allow";
+    const gate = new PermissionGate("ask", async () => answer);
+    expect(await gate.check({ tool: "run_command", action: "rm -rf x", reason: "high-risk", detail: "x" })).toBe("allow");
+    answer = "deny";
+    expect(await gate.check({ tool: "run_command", action: "rm -rf x", reason: "high-risk", detail: "x" })).toBe("deny");
+  });
+
+  it("deny rule wins over allow rule", async () => {
+    writeFileSync(
+      ALLOW_FILE(),
+      JSON.stringify({ allow: ["run_command:rm -rf /tmp*"], deny: ["run_command:rm -rf /tmp/forbidden*"] }),
+      "utf-8",
+    );
+    reloadAllowRules();
+    const gate = new PermissionGate("ask");
+    expect(await gate.check({ tool: "run_command", action: "rm -rf /tmp/forbidden/x", reason: "high-risk", detail: "x" })).toBe("deny");
+  });
+});
+
+describe("builtin file-tools permission integration", () => {
+  it("run_command high-risk is denied by default gate", async () => {
+    const tools = createBuiltinFileTools(testHome.dir, { permissionGate: new PermissionGate("ask") });
+    const tool = tools.run_command as unknown as {
+      execute: (input: { command: string }, opts?: unknown) => Promise<unknown>;
+    };
+    await expect(tool.execute({ command: "rm -rf node_modules" }, { abortSignal: undefined })).rejects.toThrow(/权限拒绝/);
+  });
+
+  it("no gate keeps original behavior", async () => {
+    const tools = createBuiltinFileTools(testHome.dir);
+    const tool = tools.run_command as unknown as {
+      execute: (input: { command: string }, opts?: unknown) => Promise<{ exitCode: number | null }>;
+    };
+    const result = await tool.execute({ command: "node -e \"console.log('ok')\"" }, { abortSignal: undefined });
+    expect(result.exitCode).toBe(0);
+  });
+});
+
+describe("builtin ChatSession permission integration", () => {
+  it("permissionMode bypass lets high-risk run_command execute", async () => {
+    const session = new ChatSession(
+      { apiKey: "sk-test" },
+      { sessionId: "perm-bypass", permissionMode: "bypass" },
+    );
+    streamTextMock.mockReturnValueOnce({ textStream: textStream("hi") });
+    await collect(session.chat("hi"));
+
+    const result = (await lastRunCommandExecute()({ command: "node -e \"console.log('ok')\"" }, { abortSignal: undefined })) as { exitCode: number };
+    expect(result.exitCode).toBe(0);
+  });
+
+  it("default ask mode without resolver denies high-risk run_command", async () => {
+    const session = new ChatSession(
+      { apiKey: "sk-test" },
+      { sessionId: "perm-ask" },
+    );
+    streamTextMock.mockReturnValueOnce({ textStream: textStream("hi") });
+    await collect(session.chat("hi"));
+
+    await expect(
+      lastRunCommandExecute()({ command: "rm -rf node_modules" }, { abortSignal: undefined }),
+    ).rejects.toThrow(/权限拒绝/);
+  });
+});
+
+describe("ccc-adapter uses bypass mode (aligns with claude/codex)", () => {
+  it("tools created via ccc adapter run high-risk commands without asking", async () => {
+    const { createCccAdapter } = await import("../adapters/ccc-adapter.ts");
+    const adapter = createCccAdapter({ apiKey: "sk-test", contextDir: testHome.dir });
+    const { sessionId } = await adapter.createSession(testHome.dir);
+    streamTextMock.mockReturnValueOnce({ textStream: textStream("hi") });
+
+    for await (const _m of adapter.prompt(sessionId, "hi", testHome.dir)) {
+      // drain
+    }
+
+    const result = (await lastRunCommandExecute()({ command: "node -e \"console.log('bypass')\"" }, { abortSignal: undefined })) as { exitCode: number };
+    expect(result.exitCode).toBe(0);
+  });
+});

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

@@ -0,0 +1,228 @@
+import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { gzipSync } from "node:zlib";
+
+import { describe, expect, it } from "vitest";
+
+import { searchBuiltinSessions } from "../builtin/session-search.ts";
+
+interface TestMessage {
+  role: "user" | "assistant";
+  content: string;
+  toolCalls?: Array<{ name: string; input?: string; output?: string; is_error?: boolean }>;
+}
+
+async function writeContextSession(
+  contextDir: string,
+  sessionId: string,
+  state: { summary?: string; messages?: TestMessage[] },
+): Promise<void> {
+  const dir = join(contextDir, sessionId);
+  await mkdir(dir, { recursive: true });
+  await writeFile(
+    join(dir, "context.json"),
+    JSON.stringify({
+      version: 1,
+      createdAt: 1,
+      updatedAt: 2,
+      sessionId,
+      summary: state.summary ?? "",
+      messages: state.messages ?? [],
+      totalMessages: (state.messages ?? []).length,
+      compactedMessages: 0,
+    }),
+    "utf8",
+  );
+}
+
+describe("searchBuiltinSessions (context.json)", () => {
+  it("finds matching messages and summary across sessions", async () => {
+    const contextDir = await mkdtemp(join(tmpdir(), "deepccc-search-basic-"));
+    await writeContextSession(contextDir, "session-a", {
+      summary: "## 当前任务\n- 修复飞书卡片渲染",
+      messages: [{ role: "user", content: "你好" }],
+    });
+    await writeContextSession(contextDir, "session-b", {
+      messages: [
+        { role: "assistant", content: "我修改了飞书卡片组件并运行了测试" },
+      ],
+    });
+
+    const output = await searchBuiltinSessions("飞书", { contextDir });
+
+    expect(output.terms).toEqual(["飞书"]);
+    expect(output.scannedSessions).toBe(2);
+    expect(output.matches).toHaveLength(2);
+    const sources = output.matches.map((m) => [m.sessionId, m.source]);
+    expect(sources).toContainEqual(["session-a", "summary"]);
+    expect(sources).toContainEqual(["session-b", "context"]);
+    expect(output.matches[1]).toMatchObject({
+      sessionId: "session-b",
+      source: "context",
+      role: "assistant",
+      messageIndex: 0,
+    });
+  });
+
+  it("matches all terms with AND semantics, case-insensitively", async () => {
+    const contextDir = await mkdtemp(join(tmpdir(), "deepccc-search-and-"));
+    await writeContextSession(contextDir, "both", {
+      messages: [{ role: "assistant", content: "DeepCCC deploy 到生产环境成功" }],
+    });
+    await writeContextSession(contextDir, "one-term", {
+      messages: [{ role: "assistant", content: "只提到 deploy" }],
+    });
+
+    const output = await searchBuiltinSessions("deepccc deploy", { contextDir });
+
+    expect(output.matches.map((m) => m.sessionId)).toEqual(["both"]);
+  });
+
+  it("searches structured tool calls and reports tool indexes", async () => {
+    const contextDir = await mkdtemp(join(tmpdir(), "deepccc-search-tools-"));
+    await writeContextSession(contextDir, "tool-session", {
+      messages: [
+        {
+          role: "assistant",
+          content: "回复正文",
+          toolCalls: [
+            { name: "run_command", input: "{\"command\":\"npm test\"}", output: "{\"exitCode\":0}" },
+            { name: "read_file", input: "{\"path\":\"secret-key.txt\"}" },
+          ],
+        },
+      ],
+    });
+
+    const output = await searchBuiltinSessions("secret-key", { contextDir });
+
+    expect(output.matches).toHaveLength(1);
+    expect(output.matches[0]).toMatchObject({
+      sessionId: "tool-session",
+      source: "context",
+      messageIndex: 0,
+      toolCallIndex: 1,
+      toolCallName: "read_file",
+    });
+    expect(output.matches[0].snippet).toContain("secret-key");
+  });
+
+  it("restricts search to an explicit session id", async () => {
+    const contextDir = await mkdtemp(join(tmpdir(), "deepccc-search-restrict-"));
+    await writeContextSession(contextDir, "keep-me", {
+      messages: [{ role: "user", content: "目标关键词 token-xyz" }],
+    });
+    await writeContextSession(contextDir, "skip-me", {
+      messages: [{ role: "user", content: "目标关键词 token-xyz" }],
+    });
+
+    const output = await searchBuiltinSessions("token-xyz", {
+      contextDir,
+      sessionId: "keep-me",
+    });
+
+    expect(output.matches.map((m) => m.sessionId)).toEqual(["keep-me"]);
+    expect(output.scannedSessions).toBe(1);
+  });
+
+  it("caps results and reports truncation", async () => {
+    const contextDir = await mkdtemp(join(tmpdir(), "deepccc-search-cap-"));
+    for (let index = 0; index < 5; index += 1) {
+      await writeContextSession(contextDir, `session-${index}`, {
+        messages: [{ role: "user", content: "共同关键词 shared-term" }],
+      });
+    }
+
+    const output = await searchBuiltinSessions("shared-term", { contextDir, maxResults: 3 });
+
+    expect(output.matches).toHaveLength(3);
+    expect(output.truncated).toBe(true);
+  });
+
+  it("returns an empty result for empty query or missing directory", async () => {
+    const contextDir = await mkdtemp(join(tmpdir(), "deepccc-search-empty-"));
+    await writeContextSession(contextDir, "some", {
+      messages: [{ role: "user", content: "内容" }],
+    });
+
+    const empty = await searchBuiltinSessions("   ", { contextDir });
+    expect(empty.matches).toEqual([]);
+    expect(empty.truncated).toBe(false);
+
+    const missing = await searchBuiltinSessions("内容", {
+      contextDir: join(contextDir, "does-not-exist"),
+    });
+    expect(missing.matches).toEqual([]);
+    expect(missing.scannedSessions).toBe(0);
+  });
+
+  it("skips corrupted context files without failing", async () => {
+    const contextDir = await mkdtemp(join(tmpdir(), "deepccc-search-corrupt-"));
+    await writeContextSession(contextDir, "good", {
+      messages: [{ role: "user", content: "可搜索内容 needle-42" }],
+    });
+    const corruptDir = join(contextDir, "corrupt");
+    await mkdir(corruptDir);
+    await writeFile(join(corruptDir, "context.json"), "not json{{{", "utf8");
+
+    const output = await searchBuiltinSessions("needle-42", { contextDir });
+
+    expect(output.matches.map((m) => m.sessionId)).toEqual(["good"]);
+    expect(output.scannedSessions).toBe(1);
+  });
+});
+
+describe("searchBuiltinSessions (raw stream logs)", () => {
+  it("searches gzipped jsonl logs only when enabled", async () => {
+    const contextDir = await mkdtemp(join(tmpdir(), "deepccc-search-raw-context-"));
+    const rawLogsDir = await mkdtemp(join(tmpdir(), "deepccc-search-raw-logs-"));
+    await writeContextSession(contextDir, "raw-session", {
+      messages: [{ role: "user", content: "无关键词" }],
+    });
+
+    const sessionDir = join(rawLogsDir, "deepccc", "raw-session");
+    await mkdir(sessionDir, { recursive: true });
+    const lines = [
+      JSON.stringify({ type: "text-delta", text: "普通输出" }),
+      JSON.stringify({ type: "tool-call", toolCallId: "c1", toolName: "run_command", input: { command: "git push --force origin" } }),
+      JSON.stringify({ type: "tool-result", toolCallId: "c1", toolName: "run_command", output: { exitCode: 0, stdout: "done" } }),
+    ];
+    await writeFile(join(sessionDir, "2026-08-04T00-00-00-000Z-prompt.jsonl.gz"), gzipSync(lines.join("\n")), "utf8");
+
+    const disabled = await searchBuiltinSessions("git push", {
+      contextDir,
+      rawLogsDir,
+      includeRawLogs: false,
+    });
+    expect(disabled.matches).toHaveLength(0);
+
+    const enabled = await searchBuiltinSessions("git push", {
+      contextDir,
+      rawLogsDir,
+      includeRawLogs: true,
+    });
+    expect(enabled.matches).toHaveLength(1);
+    expect(enabled.matches[0]).toMatchObject({
+      sessionId: "raw-session",
+      source: "raw-log",
+    });
+    expect(enabled.matches[0].snippet).toContain("git push");
+    expect(enabled.scannedRawLogFiles).toBe(1);
+  });
+
+  it("ignores missing raw log roots", async () => {
+    const contextDir = await mkdtemp(join(tmpdir(), "deepccc-search-raw-missing-"));
+    await writeContextSession(contextDir, "s", {
+      messages: [{ role: "user", content: "关键词 kw-77" }],
+    });
+
+    const output = await searchBuiltinSessions("kw-77", {
+      contextDir,
+      rawLogsDir: join(contextDir, "no-raw-logs"),
+      includeRawLogs: true,
+    });
+
+    expect(output.matches.map((m) => m.source)).toEqual(["context"]);
+    expect(output.scannedRawLogFiles).toBe(0);
+  });
+});