chatccc 0.2.16 → 0.2.18

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

@@ -1,4 +1,4 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
+import { describe, it, expect, vi, beforeEach, afterAll } from "vitest";
 import { normalizeSdkMessage, createClaudeAdapter } from "../adapters/claude-adapter.ts";
 import type { UnifiedStreamMessage } from "../adapters/adapter-interface.ts";
 
@@ -329,7 +329,7 @@ describe("createClaudeAdapter", () => {
     const adapter = createClaudeAdapter({
       model: "claude-sonnet-4-6",
       effort: "high",
-      isDefault: (v) => v.trim().toLowerCase() === "default",
+      isEmpty: (v) => v.trim() === "",
     });
     expect(adapter.displayName).toBe("Claude Code");
     expect(adapter.sessionDescPrefix).toBe("Claude Code Session:");
@@ -350,7 +350,7 @@ describe("createClaudeAdapter", () => {
     const adapter = createClaudeAdapter({
       model: "claude-sonnet-4-6",
       effort: "high",
-      isDefault: () => false,
+      isEmpty: () => false,
     });
 
     const result = await adapter.createSession("/tmp");
@@ -372,7 +372,7 @@ describe("createClaudeAdapter", () => {
     const adapter = createClaudeAdapter({
       model: "claude-sonnet-4-6",
       effort: "high",
-      isDefault: () => false,
+      isEmpty: () => false,
     });
 
     await expect(adapter.createSession("/tmp")).rejects.toThrow(
@@ -397,7 +397,7 @@ describe("createClaudeAdapter", () => {
     const adapter = createClaudeAdapter({
       model: "claude-sonnet-4-6",
       effort: "high",
-      isDefault: () => false,
+      isEmpty: () => false,
     });
 
     await adapter.createSession("/tmp");
@@ -428,7 +428,7 @@ describe("createClaudeAdapter", () => {
     const adapter = createClaudeAdapter({
       model: "claude-sonnet-4-6",
       effort: "high",
-      isDefault: () => false,
+      isEmpty: () => false,
     });
 
     const messages: UnifiedStreamMessage[] = [];
@@ -468,7 +468,7 @@ describe("createClaudeAdapter", () => {
     const adapter = createClaudeAdapter({
       model: "claude-sonnet-4-6",
       effort: "high",
-      isDefault: () => false,
+      isEmpty: () => false,
     });
 
     const messages: UnifiedStreamMessage[] = [];
@@ -492,7 +492,7 @@ describe("createClaudeAdapter", () => {
     const adapter = createClaudeAdapter({
       model: "claude-sonnet-4-6",
       effort: "high",
-      isDefault: () => false,
+      isEmpty: () => false,
     });
 
     const info = await adapter.getSessionInfo("sid");
@@ -510,7 +510,7 @@ describe("createClaudeAdapter", () => {
     const adapter = createClaudeAdapter({
       model: "claude-sonnet-4-6",
       effort: "high",
-      isDefault: () => false,
+      isEmpty: () => false,
     });
 
     const info = await adapter.getSessionInfo("nonexistent");
@@ -521,9 +521,300 @@ describe("createClaudeAdapter", () => {
     const adapter = createClaudeAdapter({
       model: "claude-sonnet-4-6",
       effort: "high",
-      isDefault: () => false,
+      isEmpty: () => false,
     });
 
     await expect(adapter.closeSession("any-sid")).resolves.toBeUndefined();
   });
+});
+
+// ---------------------------------------------------------------------------
+// createClaudeAdapter — sessionOpts 形状护栏
+// 这一组测试只断言 "调用 SDK 时传了什么"。任何对 buildSessionOptions / env
+// 注入逻辑的改动都应该让这组测试继续通过；如有意修改默认行为，请同步更新断言。
+// ---------------------------------------------------------------------------
+
+describe("createClaudeAdapter — sessionOpts 形状", () => {
+  let sdk: any;
+
+  /** 构造一个完成首次 init 即结束的 mock session，用于让 createSession 走完流程。 */
+  function setupMockCreateSession(): void {
+    const mockSessionObj = mockSession({
+      streamNext: vi
+        .fn()
+        .mockResolvedValueOnce({
+          done: false,
+          value: { session_id: "sid", type: "system", subtype: "init" },
+        })
+        .mockResolvedValueOnce({ done: true, value: undefined }),
+    });
+    sdk.unstable_v2_createSession.mockReturnValue(mockSessionObj);
+  }
+
+  function setupMockResumeSession(): void {
+    const mockSessionObj = mockSession({
+      streamNext: vi
+        .fn()
+        .mockResolvedValueOnce({ done: true, value: undefined }),
+    });
+    sdk.unstable_v2_resumeSession.mockReturnValue(mockSessionObj);
+  }
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    sdk = await import("@anthropic-ai/claude-agent-sdk");
+  });
+
+  it("createSession 把 cwd / 固定权限选项传给 SDK", async () => {
+    setupMockCreateSession();
+    const adapter = createClaudeAdapter({
+      model: "claude-sonnet-4-6",
+      effort: "high",
+      isEmpty: () => false,
+    });
+
+    await adapter.createSession("/work/dir");
+
+    const opts = sdk.unstable_v2_createSession.mock.calls[0][0];
+    expect(opts).toMatchObject({
+      cwd: "/work/dir",
+      permissionMode: "bypassPermissions",
+      allowDangerouslySkipPermissions: true,
+      autoCompactEnabled: true,
+      settingSources: ["project", "local"],
+    });
+  });
+
+  it("model / effort 非空时被传给 SDK", async () => {
+    setupMockCreateSession();
+    const adapter = createClaudeAdapter({
+      model: "claude-sonnet-4-6",
+      effort: "max",
+      isEmpty: (v) => v.trim() === "",
+    });
+
+    await adapter.createSession("/cwd");
+
+    const opts = sdk.unstable_v2_createSession.mock.calls[0][0];
+    expect(opts.model).toBe("claude-sonnet-4-6");
+    expect(opts.effort).toBe("max");
+  });
+
+  it("isEmpty(model) 为 true 时不传 model 字段", async () => {
+    setupMockCreateSession();
+    const adapter = createClaudeAdapter({
+      model: "",
+      effort: "high",
+      isEmpty: (v) => v.trim() === "",
+    });
+
+    await adapter.createSession("/cwd");
+
+    const opts = sdk.unstable_v2_createSession.mock.calls[0][0];
+    expect(opts).not.toHaveProperty("model");
+    expect(opts.effort).toBe("high");
+  });
+
+  it("isEmpty(effort) 为 true 时不传 effort 字段", async () => {
+    setupMockCreateSession();
+    const adapter = createClaudeAdapter({
+      model: "claude-sonnet-4-6",
+      effort: "",
+      isEmpty: (v) => v.trim() === "",
+    });
+
+    await adapter.createSession("/cwd");
+
+    const opts = sdk.unstable_v2_createSession.mock.calls[0][0];
+    expect(opts.model).toBe("claude-sonnet-4-6");
+    expect(opts).not.toHaveProperty("effort");
+  });
+
+  it("prompt() 也按相同规则构造 sessionOpts（resume 路径）", async () => {
+    setupMockResumeSession();
+    const adapter = createClaudeAdapter({
+      model: "claude-sonnet-4-6",
+      effort: "max",
+      isEmpty: (v) => v.trim() === "",
+    });
+
+    const it_ = adapter.prompt("sid", "hi", "/resume/cwd");
+    for await (const _ of it_) { /* drain */ }
+
+    const opts = sdk.unstable_v2_resumeSession.mock.calls[0][1];
+    expect(opts).toMatchObject({
+      cwd: "/resume/cwd",
+      permissionMode: "bypassPermissions",
+      autoCompactEnabled: true,
+      model: "claude-sonnet-4-6",
+      effort: "max",
+    });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// createClaudeAdapter — env 注入（apiKey / baseUrl 通过 SDK env 传递）
+// 行为契约：
+//   - apiKey 或 baseUrl 任一非空（trim 后）→ 传 env，且 env 是 process.env
+//     的副本，并按需覆盖 ANTHROPIC_API_KEY / ANTHROPIC_BASE_URL；
+//     其余 process.env 字段保持不变。
+//   - 两者都为空 → 完全不传 env 字段，让 SDK 走默认行为（即 process.env）。
+//   - 主进程的 process.env 永不被修改（避免污染其他依赖于 env 的代码）。
+// ---------------------------------------------------------------------------
+
+describe("createClaudeAdapter — env 注入", () => {
+  let sdk: any;
+  const ORIGINAL_ENV = { ...process.env };
+
+  function setupMockCreateSession(): void {
+    const mockSessionObj = mockSession({
+      streamNext: vi
+        .fn()
+        .mockResolvedValueOnce({
+          done: false,
+          value: { session_id: "sid", type: "system", subtype: "init" },
+        })
+        .mockResolvedValueOnce({ done: true, value: undefined }),
+    });
+    sdk.unstable_v2_createSession.mockReturnValue(mockSessionObj);
+  }
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    sdk = await import("@anthropic-ai/claude-agent-sdk");
+    // 确保每个用例从干净的 process.env 起步
+    delete process.env.ANTHROPIC_API_KEY;
+    delete process.env.ANTHROPIC_BASE_URL;
+  });
+
+  // 用例之间清掉我们写入的 env，避免互相污染
+  // （afterEach 等价物：vitest 在 beforeEach 里 reset 即可）
+  afterAll(() => {
+    process.env = { ...ORIGINAL_ENV };
+  });
+
+  it("apiKey / baseUrl 都为空时，不向 SDK 传 env 字段", async () => {
+    setupMockCreateSession();
+    const adapter = createClaudeAdapter({
+      model: "claude-sonnet-4-6",
+      effort: "high",
+      isEmpty: (v) => v.trim() === "",
+      apiKey: "",
+      baseUrl: "",
+    });
+
+    await adapter.createSession("/cwd");
+
+    const opts = sdk.unstable_v2_createSession.mock.calls[0][0];
+    expect(opts).not.toHaveProperty("env");
+  });
+
+  it("apiKey / baseUrl 全空白同样视为空", async () => {
+    setupMockCreateSession();
+    const adapter = createClaudeAdapter({
+      model: "claude-sonnet-4-6",
+      effort: "high",
+      isEmpty: (v) => v.trim() === "",
+      apiKey: "   ",
+      baseUrl: "\t\n",
+    });
+
+    await adapter.createSession("/cwd");
+
+    const opts = sdk.unstable_v2_createSession.mock.calls[0][0];
+    expect(opts).not.toHaveProperty("env");
+  });
+
+  it("apiKey 非空 → 传 env 且覆盖 ANTHROPIC_API_KEY", async () => {
+    setupMockCreateSession();
+    process.env.SOME_OTHER = "keep-me";
+    const adapter = createClaudeAdapter({
+      model: "",
+      effort: "",
+      isEmpty: (v) => v.trim() === "",
+      apiKey: "sk-test-key",
+      baseUrl: "",
+    });
+
+    await adapter.createSession("/cwd");
+
+    const opts = sdk.unstable_v2_createSession.mock.calls[0][0];
+    expect(opts.env).toBeDefined();
+    expect(opts.env.ANTHROPIC_API_KEY).toBe("sk-test-key");
+    expect(opts.env.SOME_OTHER).toBe("keep-me");
+
+    delete process.env.SOME_OTHER;
+  });
+
+  it("baseUrl 非空 → 传 env 且覆盖 ANTHROPIC_BASE_URL", async () => {
+    setupMockCreateSession();
+    const adapter = createClaudeAdapter({
+      model: "",
+      effort: "",
+      isEmpty: (v) => v.trim() === "",
+      apiKey: "",
+      baseUrl: "https://api.deepseek.com/anthropic",
+    });
+
+    await adapter.createSession("/cwd");
+
+    const opts = sdk.unstable_v2_createSession.mock.calls[0][0];
+    expect(opts.env).toBeDefined();
+    expect(opts.env.ANTHROPIC_BASE_URL).toBe("https://api.deepseek.com/anthropic");
+  });
+
+  it("apiKey + baseUrl 都设置 → 同时覆盖", async () => {
+    setupMockCreateSession();
+    const adapter = createClaudeAdapter({
+      model: "",
+      effort: "",
+      isEmpty: (v) => v.trim() === "",
+      apiKey: "sk-x",
+      baseUrl: "https://gateway.example/anthropic",
+    });
+
+    await adapter.createSession("/cwd");
+
+    const opts = sdk.unstable_v2_createSession.mock.calls[0][0];
+    expect(opts.env.ANTHROPIC_API_KEY).toBe("sk-x");
+    expect(opts.env.ANTHROPIC_BASE_URL).toBe("https://gateway.example/anthropic");
+  });
+
+  it("不修改主进程 process.env（永不污染）", async () => {
+    setupMockCreateSession();
+    const before = { ...process.env };
+
+    const adapter = createClaudeAdapter({
+      model: "",
+      effort: "",
+      isEmpty: (v) => v.trim() === "",
+      apiKey: "sk-should-not-leak",
+      baseUrl: "https://should-not-leak/anthropic",
+    });
+
+    await adapter.createSession("/cwd");
+
+    // 调用结束后 process.env 与调用前应保持一致
+    expect(process.env.ANTHROPIC_API_KEY).toBe(before.ANTHROPIC_API_KEY);
+    expect(process.env.ANTHROPIC_BASE_URL).toBe(before.ANTHROPIC_BASE_URL);
+  });
+
+  it("apiKey 留空但 process.env 已有 ANTHROPIC_API_KEY → 不覆盖、不抹掉", async () => {
+    setupMockCreateSession();
+    process.env.ANTHROPIC_API_KEY = "from-system-env";
+    const adapter = createClaudeAdapter({
+      model: "",
+      effort: "",
+      isEmpty: (v) => v.trim() === "",
+      apiKey: "",
+      baseUrl: "https://override.example/anthropic",
+    });
+
+    await adapter.createSession("/cwd");
+
+    const opts = sdk.unstable_v2_createSession.mock.calls[0][0];
+    // baseUrl 触发了 env 注入；apiKey 为空 → 沿用系统 env
+    expect(opts.env.ANTHROPIC_API_KEY).toBe("from-system-env");
+    expect(opts.env.ANTHROPIC_BASE_URL).toBe("https://override.example/anthropic");
+  });
 });

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

@@ -0,0 +1,171 @@
+import { describe, it, expect, beforeEach } from "vitest";
+
+// 注意：这个测试文件是少数几个**故意**直接 import `../config.ts` 的地方
+// （会触发 module-level loadConfig 副作用）。其它测试应优先 import
+// config-utils.ts。这里因为要验证 export let 常量在 applyLoadedConfig
+// 调用后能被刷新，没有更轻量的替代路径。
+import {
+  APP_ID,
+  APP_SECRET,
+  CHATCCC_PORT,
+  CLAUDE_API_KEY,
+  CLAUDE_BASE_URL,
+  CLAUDE_EFFORT,
+  CLAUDE_MODEL,
+  CURSOR_AGENT_ARGS,
+  CURSOR_AGENT_COMMAND,
+  GIT_TIMEOUT_MS,
+  GIT_TIMEOUT_SECONDS,
+  applyLoadedConfig,
+  config,
+  type AppConfig,
+} from "../config.ts";
+
+// ---------------------------------------------------------------------------
+// applyLoadedConfig — setup → service「在线切换」时刷新进程内 config 的核心机制
+//
+// 关键护栏：
+//   1. 调用后 export let 的 APP_ID / APP_SECRET 等必须刷新到新值
+//   2. config 这个 export 必须保持**同一个引用**（不能被替换），
+//      否则 codex-adapter 等"直接 import config"的下游会拿不到新值
+//   3. CHATCCC_PORT 不被 reload 改动（setup HTTP server 已经监听原端口，
+//      原地切换复用同一 server，重新读端口只会引入混乱）
+// ---------------------------------------------------------------------------
+
+const baseAppConfig: AppConfig = {
+  feishu: { appId: "INITIAL_APP", appSecret: "INITIAL_SECRET" },
+  port: 18080,
+  gitTimeoutSeconds: 180,
+  claude: {
+    enabled: true,
+    model: "initial-model",
+    effort: "initial-effort",
+    apiKey: "sk-initial",
+    baseUrl: "https://initial.gw/anthropic",
+  },
+  cursor: { enabled: true, path: "/initial/cursor", model: "initial-cursor-model" },
+  codex: { enabled: true, path: "/initial/codex", model: "initial-codex-model", effort: "initial-codex-effort" },
+};
+
+// 把 module 状态抢救快照：每个 it 跑前重置回这个状态，避免污染相邻测试。
+// 不直接用启动时的 config 引用做 snapshot——它可能已经被前一个 it 改写。
+function resetToBaseline(): void {
+  applyLoadedConfig(structuredClone(baseAppConfig));
+}
+
+beforeEach(() => {
+  resetToBaseline();
+});
+
+describe("applyLoadedConfig — 刷新 export let 常量", () => {
+  it("更新 APP_ID / APP_SECRET（飞书凭证）", () => {
+    expect(APP_ID).toBe("INITIAL_APP");
+    expect(APP_SECRET).toBe("INITIAL_SECRET");
+
+    applyLoadedConfig({
+      ...structuredClone(baseAppConfig),
+      feishu: { appId: "NEW_APP_ID", appSecret: "NEW_APP_SECRET" },
+    });
+
+    // ES module live binding：测试模块顶层 import 的 APP_ID 会自动看到新值
+    expect(APP_ID).toBe("NEW_APP_ID");
+    expect(APP_SECRET).toBe("NEW_APP_SECRET");
+  });
+
+  it("更新 Claude 配置（model / effort / apiKey / baseUrl）", () => {
+    applyLoadedConfig({
+      ...structuredClone(baseAppConfig),
+      claude: {
+        enabled: true,
+        model: "deepseek-v4-pro",
+        effort: "high",
+        apiKey: "sk-newkey",
+        baseUrl: "https://gw2.example/anthropic",
+      },
+    });
+
+    expect(CLAUDE_MODEL).toBe("deepseek-v4-pro");
+    expect(CLAUDE_EFFORT).toBe("high");
+    expect(CLAUDE_API_KEY).toBe("sk-newkey");
+    expect(CLAUDE_BASE_URL).toBe("https://gw2.example/anthropic");
+  });
+
+  it("更新 GIT_TIMEOUT_SECONDS 与 GIT_TIMEOUT_MS（毫秒派生值同步刷新）", () => {
+    applyLoadedConfig({
+      ...structuredClone(baseAppConfig),
+      gitTimeoutSeconds: 240,
+    });
+
+    expect(GIT_TIMEOUT_SECONDS).toBe(240);
+    // 派生值必须跟着更新，否则 /git 仍然按旧 timeout 运行
+    expect(GIT_TIMEOUT_MS).toBe(240 * 1000);
+  });
+
+  it("CURSOR_AGENT_ARGS 跟随 cursor.model 重新解析", () => {
+    applyLoadedConfig({
+      ...structuredClone(baseAppConfig),
+      cursor: { enabled: true, path: "/x/cursor", model: "claude-3.7-sonnet" },
+    });
+
+    // CURSOR_AGENT_ARGS 是 ['-p', '--force', ..., '--model', 'claude-3.7-sonnet']
+    expect(CURSOR_AGENT_ARGS).toContain("--model");
+    expect(CURSOR_AGENT_ARGS).toContain("claude-3.7-sonnet");
+  });
+
+  it("cursor.model 留空时 CURSOR_AGENT_ARGS 不含 --model", () => {
+    applyLoadedConfig({
+      ...structuredClone(baseAppConfig),
+      cursor: { enabled: true, path: "/x/cursor", model: "" },
+    });
+
+    expect(CURSOR_AGENT_ARGS).not.toContain("--model");
+  });
+
+  it("CURSOR_AGENT_COMMAND 优先取 config.cursor.path", () => {
+    applyLoadedConfig({
+      ...structuredClone(baseAppConfig),
+      cursor: { enabled: true, path: "C:/custom/cursor.exe", model: "" },
+    });
+
+    expect(CURSOR_AGENT_COMMAND).toBe("C:/custom/cursor.exe");
+  });
+
+  it("不修改 CHATCCC_PORT（端口在 setup 切换时必须保持不变）", () => {
+    const portBefore = CHATCCC_PORT;
+    applyLoadedConfig({
+      ...structuredClone(baseAppConfig),
+      port: 19999,
+    });
+    // 重要：port 字段会刷到 config 对象上（见下个测试），但 CHATCCC_PORT 这个
+    // 顶级 export 始终指向 chatccc 启动那一刻的端口，不允许在线切换中更换。
+    expect(CHATCCC_PORT).toBe(portBefore);
+  });
+});
+
+describe("applyLoadedConfig — config 对象引用契约", () => {
+  it("config 引用保持不变（就地更新），但字段被刷新", () => {
+    const refBefore = config;
+
+    applyLoadedConfig({
+      ...structuredClone(baseAppConfig),
+      feishu: { appId: "REF_TEST_APP", appSecret: "REF_TEST_SECRET" },
+      codex: { enabled: true, path: "/refresh/codex", model: "fresh-model", effort: "low" },
+    });
+
+    // 必须是同一个引用：codex-adapter 等下游模块"直接 import config"，
+    // 替换引用会破坏它们对 config.codex.* 的访问。
+    expect(config).toBe(refBefore);
+    expect(config.feishu.appId).toBe("REF_TEST_APP");
+    expect(config.codex.path).toBe("/refresh/codex");
+  });
+
+  it("空 feishu 凭证也能正确刷入（向导回滚到空的反向场景）", () => {
+    applyLoadedConfig({
+      ...structuredClone(baseAppConfig),
+      feishu: { appId: "", appSecret: "" },
+    });
+    expect(APP_ID).toBe("");
+    expect(APP_SECRET).toBe("");
+    expect(config.feishu.appId).toBe("");
+  });
+});