skyloom 1.13.6 → 1.13.8

package/tests/bus.test.ts

@@ -1,121 +1,121 @@
-/**
- * Tests for the event bus.
- */
-import { describe, it, expect, vi } from 'vitest';
-import { MessageBus, Event, EventType } from '../src/core/bus';
-
-describe('MessageBus', () => {
-  it('subscribe and publish broadcasts to subscribers', async () => {
-    const bus = new MessageBus();
-    const received: Event[] = [];
-
-    async function handler(event: Event) {
-      received.push(event);
-    }
-
-    bus.subscribe('test_agent', handler);
-    const event = new Event(EventType.SYSTEM_EVENT, 'system', null, { msg: 'hello' });
-    await bus.publish(event);
-
-    expect(received).toHaveLength(1);
-    expect(received[0].type).toBe(EventType.SYSTEM_EVENT);
-    expect(received[0].data).toEqual({ msg: 'hello' });
-  });
-
-  it('direct message goes to target agent only', async () => {
-    const bus = new MessageBus();
-    const received: Event[] = [];
-
-    async function handler(event: Event) {
-      received.push(event);
-    }
-
-    bus.subscribe('target_agent', handler);
-    const event = new Event(EventType.TASK_ASSIGNED, 'snow', 'target_agent', { task: 'test' });
-    await bus.publish(event);
-
-    expect(received).toHaveLength(1);
-  });
-
-  it('unsubscribe removes handler', async () => {
-    const bus = new MessageBus();
-    const received: Event[] = [];
-
-    async function handler(event: Event) {
-      received.push(event);
-    }
-
-    bus.subscribe('agent', handler);
-    bus.unsubscribe('agent');
-    await bus.publish(new Event(EventType.SYSTEM_EVENT, 'system'));
-    expect(received).toHaveLength(0);
-  });
-
-  it('state listener receives state change events', async () => {
-    const bus = new MessageBus();
-    const received: Event[] = [];
-
-    async function listener(event: Event) {
-      received.push(event);
-    }
-
-    bus.onStateChange(listener);
-    await bus.notifyStateChange(
-      new Event(EventType.STATE_CHANGE, 'fog', null, { old_state: 'idle', new_state: 'thinking' })
-    );
-
-    expect(received).toHaveLength(1);
-    expect(received[0].type).toBe(EventType.STATE_CHANGE);
-    expect(received[0].source).toBe('fog');
-  });
-
-  it('state listener ignores non-state events', async () => {
-    const bus = new MessageBus();
-    const received: Event[] = [];
-
-    async function listener(event: Event) {
-      received.push(event);
-    }
-
-    bus.onStateChange(listener);
-    await bus.notifyStateChange(new Event(EventType.TASK_ASSIGNED, 'snow'));
-    expect(received).toHaveLength(0);
-  });
-
-  it('history tracks published events', async () => {
-    const bus = new MessageBus();
-    for (let i = 0; i < 5; i++) {
-      await bus.publish(new Event(EventType.SYSTEM_EVENT, 'system'));
-    }
-    expect(bus.getHistory()).toHaveLength(5);
-    expect(bus.getHistory(undefined, undefined, 2)).toHaveLength(2);
-  });
-
-  it('broadcast skips source agent', async () => {
-    const bus = new MessageBus();
-    const called: string[] = [];
-
-    async function fogHandler(_event: Event) { called.push('fog'); }
-    async function rainHandler(_event: Event) { called.push('rain'); }
-
-    bus.subscribe('fog', fogHandler);
-    bus.subscribe('rain', rainHandler);
-    await bus.publish(new Event(EventType.SYSTEM_EVENT, 'fog'));
-
-    expect(called).not.toContain('fog');
-    expect(called).toContain('rain');
-  });
-
-  it('handler exception does not block other handlers', async () => {
-    const bus = new MessageBus();
-    const good: Event[] = [];
-
-    async function failing(_event: Event) { throw new Error('failed'); }
-    async function ok(event: Event) { good.push(event); }
-
-    bus.subscribe('rain', failing);
-    bus.subscribe('dew', ok);
-    await bus.publish(new Event(EventType.SYSTEM_EVENT, 'fog'));
-    expect(good).toHaveLength(1);
-  });
-});
+/**
+ * Tests for the event bus.
+ */
+import { describe, it, expect, vi } from 'vitest';
+import { MessageBus, Event, EventType } from '../src/core/bus';
+
+describe('MessageBus', () => {
+  it('subscribe and publish broadcasts to subscribers', async () => {
+    const bus = new MessageBus();
+    const received: Event[] = [];
+
+    async function handler(event: Event) {
+      received.push(event);
+    }
+
+    bus.subscribe('test_agent', handler);
+    const event = new Event(EventType.SYSTEM_EVENT, 'system', null, { msg: 'hello' });
+    await bus.publish(event);
+
+    expect(received).toHaveLength(1);
+    expect(received[0].type).toBe(EventType.SYSTEM_EVENT);
+    expect(received[0].data).toEqual({ msg: 'hello' });
+  });
+
+  it('direct message goes to target agent only', async () => {
+    const bus = new MessageBus();
+    const received: Event[] = [];
+
+    async function handler(event: Event) {
+      received.push(event);
+    }
+
+    bus.subscribe('target_agent', handler);
+    const event = new Event(EventType.TASK_ASSIGNED, 'snow', 'target_agent', { task: 'test' });
+    await bus.publish(event);
+
+    expect(received).toHaveLength(1);
+  });
+
+  it('unsubscribe removes handler', async () => {
+    const bus = new MessageBus();
+    const received: Event[] = [];
+
+    async function handler(event: Event) {
+      received.push(event);
+    }
+
+    bus.subscribe('agent', handler);
+    bus.unsubscribe('agent');
+    await bus.publish(new Event(EventType.SYSTEM_EVENT, 'system'));
+    expect(received).toHaveLength(0);
+  });
+
+  it('state listener receives state change events', async () => {
+    const bus = new MessageBus();
+    const received: Event[] = [];
+
+    async function listener(event: Event) {
+      received.push(event);
+    }
+
+    bus.onStateChange(listener);
+    await bus.notifyStateChange(
+      new Event(EventType.STATE_CHANGE, 'fog', null, { old_state: 'idle', new_state: 'thinking' })
+    );
+
+    expect(received).toHaveLength(1);
+    expect(received[0].type).toBe(EventType.STATE_CHANGE);
+    expect(received[0].source).toBe('fog');
+  });
+
+  it('state listener ignores non-state events', async () => {
+    const bus = new MessageBus();
+    const received: Event[] = [];
+
+    async function listener(event: Event) {
+      received.push(event);
+    }
+
+    bus.onStateChange(listener);
+    await bus.notifyStateChange(new Event(EventType.TASK_ASSIGNED, 'snow'));
+    expect(received).toHaveLength(0);
+  });
+
+  it('history tracks published events', async () => {
+    const bus = new MessageBus();
+    for (let i = 0; i < 5; i++) {
+      await bus.publish(new Event(EventType.SYSTEM_EVENT, 'system'));
+    }
+    expect(bus.getHistory()).toHaveLength(5);
+    expect(bus.getHistory(undefined, undefined, 2)).toHaveLength(2);
+  });
+
+  it('broadcast skips source agent', async () => {
+    const bus = new MessageBus();
+    const called: string[] = [];
+
+    async function fogHandler(_event: Event) { called.push('fog'); }
+    async function rainHandler(_event: Event) { called.push('rain'); }
+
+    bus.subscribe('fog', fogHandler);
+    bus.subscribe('rain', rainHandler);
+    await bus.publish(new Event(EventType.SYSTEM_EVENT, 'fog'));
+
+    expect(called).not.toContain('fog');
+    expect(called).toContain('rain');
+  });
+
+  it('handler exception does not block other handlers', async () => {
+    const bus = new MessageBus();
+    const good: Event[] = [];
+
+    async function failing(_event: Event) { throw new Error('failed'); }
+    async function ok(event: Event) { good.push(event); }
+
+    bus.subscribe('rain', failing);
+    bus.subscribe('dew', ok);
+    await bus.publish(new Event(EventType.SYSTEM_EVENT, 'fog'));
+    expect(good).toHaveLength(1);
+  });
+});

package/tests/catalog.test.ts

@@ -1,86 +1,86 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import {
-  loadCatalog,
-  listProviders,
-  modelsFor,
-  allModels,
-  getModelInfo,
-  isKnownModel,
-  providerLabel,
-  validateModel,
-  resetCatalogCache,
-  PROVIDER_META,
-} from "../src/core/catalog";
-
-describe("catalog", () => {
-  beforeEach(() => resetCatalogCache());
-
-  it("loads providers from models.yaml", () => {
-    const providers = listProviders();
-    expect(providers.length).toBeGreaterThan(0);
-    expect(providers).toContain("openai");
-    expect(providers).toContain("deepseek");
-  });
-
-  it("orders providers by wizard order", () => {
-    const providers = listProviders();
-    const orders = providers.map((p) => PROVIDER_META[p]?.order ?? 99);
-    const sorted = [...orders].sort((a, b) => a - b);
-    expect(orders).toEqual(sorted);
-  });
-
-  it("parses real model fields (context + cost)", () => {
-    const gpt4o = getModelInfo("gpt-4o");
-    expect(gpt4o).not.toBeNull();
-    expect(gpt4o!.provider).toBe("openai");
-    expect(gpt4o!.context).toBeGreaterThan(0);
-    expect(gpt4o!.costIn).toBeGreaterThan(0);
-  });
-
-  it("contains all real, API-verified deepseek models", () => {
-    // Verified live against https://api.deepseek.com/v1/models
-    expect(isKnownModel("deepseek-chat")).toBe(true);
-    expect(isKnownModel("deepseek-reasoner")).toBe(true);
-    expect(isKnownModel("deepseek-v4-flash")).toBe(true);
-    expect(isKnownModel("deepseek-v4-pro")).toBe(true);
-  });
-
-  it("still rejects genuinely unknown model ids", () => {
-    expect(isKnownModel("deepseek-v9-ultra")).toBe(false);
-    expect(isKnownModel("gpt-5-imaginary")).toBe(false);
-  });
-
-  it("marks ollama / zero-cost models as local", () => {
-    const local = allModels().filter((m) => m.local);
-    expect(local.every((m) => m.costIn === 0 && m.costOut === 0)).toBe(true);
-  });
-
-  it("tolerates provider/ prefix when resolving", () => {
-    // openrouter lists "openai/gpt-4.1"; bare "gpt-4.1" should also resolve
-    const direct = getModelInfo("gpt-4.1");
-    expect(direct).not.toBeNull();
-  });
-
-  it("validateModel passes for a real model and fails with suggestions otherwise", () => {
-    expect(validateModel("gpt-4o").ok).toBe(true);
-    const bad = validateModel("totally-made-up-model");
-    expect(bad.ok).toBe(false);
-    expect(bad.suggestions.length).toBeGreaterThan(0);
-    expect(bad.suggestions.every((s) => isKnownModel(s))).toBe(true);
-  });
-
-  it("provides display labels", () => {
-    expect(providerLabel("openai")).toBe("OpenAI");
-    expect(providerLabel("unknown-xyz")).toBe("unknown-xyz");
-  });
-
-  it("modelsFor returns empty for unknown provider", () => {
-    expect(modelsFor("nope")).toEqual([]);
-  });
-
-  it("caches the catalog across calls", () => {
-    const a = loadCatalog();
-    const b = loadCatalog();
-    expect(a).toBe(b);
-  });
-});
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  loadCatalog,
+  listProviders,
+  modelsFor,
+  allModels,
+  getModelInfo,
+  isKnownModel,
+  providerLabel,
+  validateModel,
+  resetCatalogCache,
+  PROVIDER_META,
+} from "../src/core/catalog";
+
+describe("catalog", () => {
+  beforeEach(() => resetCatalogCache());
+
+  it("loads providers from models.yaml", () => {
+    const providers = listProviders();
+    expect(providers.length).toBeGreaterThan(0);
+    expect(providers).toContain("openai");
+    expect(providers).toContain("deepseek");
+  });
+
+  it("orders providers by wizard order", () => {
+    const providers = listProviders();
+    const orders = providers.map((p) => PROVIDER_META[p]?.order ?? 99);
+    const sorted = [...orders].sort((a, b) => a - b);
+    expect(orders).toEqual(sorted);
+  });
+
+  it("parses real model fields (context + cost)", () => {
+    const gpt4o = getModelInfo("gpt-4o");
+    expect(gpt4o).not.toBeNull();
+    expect(gpt4o!.provider).toBe("openai");
+    expect(gpt4o!.context).toBeGreaterThan(0);
+    expect(gpt4o!.costIn).toBeGreaterThan(0);
+  });
+
+  it("contains all real, API-verified deepseek models", () => {
+    // Verified live against https://api.deepseek.com/v1/models
+    expect(isKnownModel("deepseek-chat")).toBe(true);
+    expect(isKnownModel("deepseek-reasoner")).toBe(true);
+    expect(isKnownModel("deepseek-v4-flash")).toBe(true);
+    expect(isKnownModel("deepseek-v4-pro")).toBe(true);
+  });
+
+  it("still rejects genuinely unknown model ids", () => {
+    expect(isKnownModel("deepseek-v9-ultra")).toBe(false);
+    expect(isKnownModel("gpt-5-imaginary")).toBe(false);
+  });
+
+  it("marks ollama / zero-cost models as local", () => {
+    const local = allModels().filter((m) => m.local);
+    expect(local.every((m) => m.costIn === 0 && m.costOut === 0)).toBe(true);
+  });
+
+  it("tolerates provider/ prefix when resolving", () => {
+    // openrouter lists "openai/gpt-4.1"; bare "gpt-4.1" should also resolve
+    const direct = getModelInfo("gpt-4.1");
+    expect(direct).not.toBeNull();
+  });
+
+  it("validateModel passes for a real model and fails with suggestions otherwise", () => {
+    expect(validateModel("gpt-4o").ok).toBe(true);
+    const bad = validateModel("totally-made-up-model");
+    expect(bad.ok).toBe(false);
+    expect(bad.suggestions.length).toBeGreaterThan(0);
+    expect(bad.suggestions.every((s) => isKnownModel(s))).toBe(true);
+  });
+
+  it("provides display labels", () => {
+    expect(providerLabel("openai")).toBe("OpenAI");
+    expect(providerLabel("unknown-xyz")).toBe("unknown-xyz");
+  });
+
+  it("modelsFor returns empty for unknown provider", () => {
+    expect(modelsFor("nope")).toEqual([]);
+  });
+
+  it("caches the catalog across calls", () => {
+    const a = loadCatalog();
+    const b = loadCatalog();
+    expect(a).toBe(b);
+  });
+});

package/tests/checkpoint_commands.test.ts

@@ -0,0 +1,124 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { getFileCheckpoints } from "../src/core/file_checkpoint";
+import { loadCustomCommands, substituteArgs, resolveCustomCommand } from "../src/cli/commands_md";
+
+let tmp: string;
+beforeEach(() => {
+  tmp = fs.mkdtempSync(path.join(os.tmpdir(), "skycp-"));
+  getFileCheckpoints().clear();
+});
+afterEach(() => { fs.rmSync(tmp, { recursive: true, force: true }); });
+
+describe("文件级检查点 /rewind", () => {
+  it("snapshots before mutation and restores on rewind", () => {
+    const cp = getFileCheckpoints();
+    const f = path.join(tmp, "a.txt");
+    fs.writeFileSync(f, "原始内容");
+
+    cp.beginTurn("改 a.txt");
+    cp.snapshot(f);
+    fs.writeFileSync(f, "agent 改坏了");
+
+    const r = cp.rewind(1);
+    expect(r.turns).toBe(1);
+    expect(r.restored).toEqual([f]);
+    expect(fs.readFileSync(f, "utf-8")).toBe("原始内容");
+  });
+
+  it("deletes files that did not exist before the turn", () => {
+    const cp = getFileCheckpoints();
+    const f = path.join(tmp, "new.txt");
+
+    cp.beginTurn("新建文件");
+    cp.snapshot(f); // 不存在 → content null
+    fs.writeFileSync(f, "agent 新建的");
+
+    const r = cp.rewind(1);
+    expect(r.deleted).toEqual([f]);
+    expect(fs.existsSync(f)).toBe(false);
+  });
+
+  it("first touch per turn wins; multi-turn rewind restores the oldest state", () => {
+    const cp = getFileCheckpoints();
+    const f = path.join(tmp, "a.txt");
+    fs.writeFileSync(f, "v1");
+
+    cp.beginTurn("第一轮");
+    cp.snapshot(f);
+    fs.writeFileSync(f, "v2");
+    cp.snapshot(f); // 同轮第二次：忽略
+    fs.writeFileSync(f, "v2b");
+
+    cp.beginTurn("第二轮");
+    cp.snapshot(f);
+    fs.writeFileSync(f, "v3");
+
+    const r = cp.rewind(2);
+    expect(r.turns).toBe(2);
+    expect(fs.readFileSync(f, "utf-8")).toBe("v1");
+  });
+
+  it("rewound turns are consumed; empty turns don't stack", () => {
+    const cp = getFileCheckpoints();
+    const f = path.join(tmp, "a.txt");
+    fs.writeFileSync(f, "v1");
+    cp.beginTurn("空轮");      // 无快照
+    cp.beginTurn("有改动");
+    cp.snapshot(f);
+    fs.writeFileSync(f, "v2");
+    expect(cp.list().length).toBe(1);
+    cp.rewind(1);
+    expect(cp.list().length).toBe(0);
+    expect(cp.rewind(1).turns).toBe(0);
+  });
+
+  it("pathToSnapshot only matches mutating file tools", () => {
+    const cp = getFileCheckpoints();
+    expect(cp.pathToSnapshot("write_file", { path: "x.txt" })).toBe("x.txt");
+    expect(cp.pathToSnapshot("edit_file", { path: "x.txt" })).toBe("x.txt");
+    expect(cp.pathToSnapshot("delete_file", { path: "x.txt" })).toBe("x.txt");
+    expect(cp.pathToSnapshot("read_file", { path: "x.txt" })).toBeNull();
+    expect(cp.pathToSnapshot("run_bash", { command: "rm x" })).toBeNull();
+    expect(cp.pathToSnapshot("write_file", {})).toBeNull();
+  });
+});
+
+describe("自定义斜杠命令", () => {
+  function writeCmd(rel: string, content: string) {
+    const f = path.join(tmp, ".sky", "commands", rel);
+    fs.mkdirSync(path.dirname(f), { recursive: true });
+    fs.writeFileSync(f, content);
+  }
+
+  it("loads commands with frontmatter; subdirectories namespace", () => {
+    writeCmd("fix-issue.md", "---\ndescription: 修复 issue\nagent: rain\n---\n修复 issue #$ARGUMENTS");
+    writeCmd("git/commit.md", "规范化提交");
+    const cmds = loadCustomCommands(tmp);
+    const names = cmds.map(c => c.name);
+    expect(names).toContain("fix-issue");
+    expect(names).toContain("git:commit");
+    const fix = cmds.find(c => c.name === "fix-issue")!;
+    expect(fix.description).toBe("修复 issue");
+    expect(fix.agent).toBe("rain");
+    // 无 frontmatter：首行作描述
+    expect(cmds.find(c => c.name === "git:commit")!.description).toBe("规范化提交");
+  });
+
+  it("substitutes $ARGUMENTS and positional $1..$9", () => {
+    expect(substituteArgs("issue #$ARGUMENTS", "123 high")).toBe("issue #123 high");
+    expect(substituteArgs("from $1 to $2 ($3)", "a b")).toBe("from a to b ()");
+  });
+
+  it("resolveCustomCommand matches name and expands args", () => {
+    writeCmd("review.md", "---\ndescription: 审查\n---\n审查 $1 的改动");
+    const cmds = loadCustomCommands(tmp);
+    const hit = resolveCustomCommand("/review src/core", cmds);
+    expect(hit).not.toBeNull();
+    expect(hit!.prompt).toBe("审查 src/core 的改动");
+    expect(resolveCustomCommand("/nonexistent", cmds)).toBeNull();
+    expect(resolveCustomCommand("not-slash", cmds)).toBeNull();
+  });
+});

package/tests/claude_compat.test.ts

@@ -0,0 +1,110 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { SkillRegistry } from "../src/core/skill";
+import { dynamicSkillDirs } from "../src/skills/loader";
+import { loadProjectMcpJson, expandEnvRefs } from "../src/core/mcp";
+
+let tmp: string;
+beforeEach(() => { tmp = fs.mkdtempSync(path.join(os.tmpdir(), "skycompat-")); });
+afterEach(() => {
+  fs.rmSync(tmp, { recursive: true, force: true });
+  delete process.env.SKY_TEST_TOKEN;
+});
+
+/** Write a Claude Code-style skill folder. */
+function writeSkill(root: string, name: string, frontmatter: string, body: string, extras: Record<string, string> = {}) {
+  const dir = path.join(root, name);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, "SKILL.md"), `---\n${frontmatter}\n---\n${body}`);
+  for (const [rel, content] of Object.entries(extras)) {
+    const f = path.join(dir, rel);
+    fs.mkdirSync(path.dirname(f), { recursive: true });
+    fs.writeFileSync(f, content);
+  }
+}
+
+describe("Claude Code skills 零迁移兼容", () => {
+  it("loads folder-style skills (<root>/<name>/SKILL.md), ignoring sibling reference files", () => {
+    writeSkill(tmp, "thesis-chart", "name: thesis-chart\ndescription: 学术图表绘制", "## 工作流程\n按学术配色出图", {
+      "reference.md": "# 详细参考（不是独立技能）",
+      "scripts/plot.py": "print('hi')",
+    });
+    const reg = new SkillRegistry();
+    const loaded = reg.loadSkillFolders(tmp);
+    expect(loaded.map(s => s.name)).toEqual(["thesis-chart"]); // reference.md 没被误注册
+    const skill = reg.get("thesis-chart")!;
+    expect(skill.description).toBe("学术图表绘制");
+    expect(skill.systemPrompt).toContain("学术配色");
+    expect(skill.resourceDir).toBe(path.join(tmp, "thesis-chart")); // 相对资源可解析
+  });
+
+  it("maps Claude Code allowed-tools names to sky tools", () => {
+    writeSkill(tmp, "deploy", "name: deploy\ndescription: 部署\nallowed-tools: Bash, Read, WebFetch", "做部署");
+    const reg = new SkillRegistry();
+    reg.loadSkillFolders(tmp);
+    const skill = reg.get("deploy")!;
+    expect(skill.allowedTools).toContain("run_bash");
+    expect(skill.allowedTools).toContain("read_file");
+  });
+
+  it("re-scan picks up live edits (Claude Code live change detection)", () => {
+    writeSkill(tmp, "x", "name: x\ndescription: v1", "body1");
+    const reg = new SkillRegistry();
+    reg.loadSkillFolders(tmp);
+    expect(reg.get("x")!.description).toBe("v1");
+    writeSkill(tmp, "x", "name: x\ndescription: v2", "body2");
+    reg.loadSkillFolders(tmp); // same call list_skills makes
+    expect(reg.get("x")!.description).toBe("v2");
+  });
+
+  it("dynamic skill dirs include both .claude (compat) and .sky (native) locations", () => {
+    const dirs = dynamicSkillDirs("/proj");
+    expect(dirs).toContain(path.join(os.homedir(), ".claude", "skills"));
+    expect(dirs).toContain(path.join("/proj", ".claude", "skills"));
+    expect(dirs).toContain(path.join("/proj", ".sky", "skills"));
+    // project dirs come after user dirs → later registration wins
+    expect(dirs.indexOf(path.join("/proj", ".sky", "skills"))).toBeGreaterThan(
+      dirs.indexOf(path.join(os.homedir(), ".claude", "skills")));
+  });
+});
+
+describe("Claude Code .mcp.json 兼容", () => {
+  it("parses the standard mcpServers schema (stdio + http)", () => {
+    fs.writeFileSync(path.join(tmp, ".mcp.json"), JSON.stringify({
+      mcpServers: {
+        github: { type: "http", url: "https://api.githubcopilot.com/mcp/" },
+        db: { command: "npx", args: ["-y", "@bytebase/dbhub"], env: { DB_URL: "postgres://x" } },
+      },
+    }));
+    const servers = loadProjectMcpJson(tmp);
+    expect(servers).toHaveLength(2);
+    const gh = servers.find(s => s.name === "github")!;
+    expect(gh.url).toBe("https://api.githubcopilot.com/mcp/");
+    const db = servers.find(s => s.name === "db")!;
+    expect(db.command).toBe("npx");
+    expect(db.args).toEqual(["-y", "@bytebase/dbhub"]);
+    expect(db.env).toEqual({ DB_URL: "postgres://x" });
+  });
+
+  it("expands ${ENV_VAR} references so secrets stay out of the file", () => {
+    process.env.SKY_TEST_TOKEN = "sk-secret";
+    expect(expandEnvRefs("Bearer ${SKY_TEST_TOKEN}")).toBe("Bearer sk-secret");
+    expect(expandEnvRefs("${MISSING_VAR_XYZ}")).toBe("");
+    fs.writeFileSync(path.join(tmp, ".mcp.json"), JSON.stringify({
+      mcpServers: { api: { command: "run", env: { TOKEN: "${SKY_TEST_TOKEN}" } } },
+    }));
+    expect(loadProjectMcpJson(tmp)[0].env).toEqual({ TOKEN: "sk-secret" });
+  });
+
+  it("tolerates missing/invalid files and unsupported entries", () => {
+    expect(loadProjectMcpJson(tmp)).toEqual([]);
+    fs.writeFileSync(path.join(tmp, ".mcp.json"), "not json{");
+    expect(loadProjectMcpJson(tmp)).toEqual([]);
+    fs.writeFileSync(path.join(tmp, ".mcp.json"), JSON.stringify({
+      mcpServers: { weird: { type: "carrier-pigeon" } },
+    }));
+    expect(loadProjectMcpJson(tmp)).toEqual([]); // 无 command/url 的条目跳过
+  });
+});