@every-env/compound-plugin 0.9.0 → 2.34.2

package/tests/sync-copilot.test.ts

@@ -28,6 +28,34 @@ describe("syncToCopilot", () => {
     expect(linkedStat.isSymbolicLink()).toBe(true)
   })
 
+  test("converts personal commands into Copilot skills", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "sync-copilot-cmd-"))
+
+    const config: ClaudeHomeConfig = {
+      skills: [],
+      commands: [
+        {
+          name: "workflows:plan",
+          description: "Planning command",
+          argumentHint: "[goal]",
+          body: "Plan the work carefully.",
+          sourcePath: "/tmp/workflows/plan.md",
+        },
+      ],
+      mcpServers: {},
+    }
+
+    await syncToCopilot(config, tempRoot)
+
+    const skillContent = await fs.readFile(
+      path.join(tempRoot, "skills", "workflows-plan", "SKILL.md"),
+      "utf8",
+    )
+    expect(skillContent).toContain("name: workflows-plan")
+    expect(skillContent).toContain("Planning command")
+    expect(skillContent).toContain("## Arguments")
+  })
+
   test("skips skills with invalid names", async () => {
     const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "sync-copilot-invalid-"))
 
@@ -51,7 +79,7 @@ describe("syncToCopilot", () => {
 
   test("merges MCP config with existing file", async () => {
     const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "sync-copilot-merge-"))
-    const mcpPath = path.join(tempRoot, "copilot-mcp-config.json")
+    const mcpPath = path.join(tempRoot, "mcp-config.json")
 
     await fs.writeFile(
       mcpPath,
@@ -77,6 +105,7 @@ describe("syncToCopilot", () => {
 
     expect(merged.mcpServers.existing?.command).toBe("node")
     expect(merged.mcpServers.context7?.url).toBe("https://mcp.context7.com/mcp")
+    expect(merged.mcpServers.context7?.type).toBe("http")
   })
 
   test("transforms MCP env var names to COPILOT_MCP_ prefix", async () => {
@@ -95,7 +124,7 @@ describe("syncToCopilot", () => {
 
     await syncToCopilot(config, tempRoot)
 
-    const mcpPath = path.join(tempRoot, "copilot-mcp-config.json")
+    const mcpPath = path.join(tempRoot, "mcp-config.json")
     const mcpConfig = JSON.parse(await fs.readFile(mcpPath, "utf8")) as {
       mcpServers: Record<string, { env?: Record<string, string> }>
     }
@@ -118,7 +147,7 @@ describe("syncToCopilot", () => {
 
     await syncToCopilot(config, tempRoot)
 
-    const mcpPath = path.join(tempRoot, "copilot-mcp-config.json")
+    const mcpPath = path.join(tempRoot, "mcp-config.json")
     const stat = await fs.stat(mcpPath)
     // Check owner read+write permission (0o600 = 33216 in decimal, masked to file perms)
     const perms = stat.mode & 0o777
@@ -142,7 +171,34 @@ describe("syncToCopilot", () => {
 
     await syncToCopilot(config, tempRoot)
 
-    const mcpExists = await fs.access(path.join(tempRoot, "copilot-mcp-config.json")).then(() => true).catch(() => false)
+    const mcpExists = await fs.access(path.join(tempRoot, "mcp-config.json")).then(() => true).catch(() => false)
     expect(mcpExists).toBe(false)
   })
+
+  test("preserves explicit SSE transport for legacy remote servers", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "sync-copilot-sse-"))
+
+    const config: ClaudeHomeConfig = {
+      skills: [],
+      mcpServers: {
+        legacy: {
+          type: "sse",
+          url: "https://example.com/sse",
+        },
+      },
+    }
+
+    await syncToCopilot(config, tempRoot)
+
+    const mcpPath = path.join(tempRoot, "mcp-config.json")
+    const mcpConfig = JSON.parse(await fs.readFile(mcpPath, "utf8")) as {
+      mcpServers: Record<string, { type?: string; url?: string }>
+    }
+
+    expect(mcpConfig.mcpServers.legacy).toEqual({
+      type: "sse",
+      tools: ["*"],
+      url: "https://example.com/sse",
+    })
+  })
 })

package/tests/sync-droid.test.ts

@@ -6,7 +6,7 @@ import { syncToDroid } from "../src/sync/droid"
 import type { ClaudeHomeConfig } from "../src/parsers/claude-home"
 
 describe("syncToDroid", () => {
-  test("symlinks skills to factory skills dir", async () => {
+  test("symlinks skills to factory skills dir and writes mcp.json", async () => {
     const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "sync-droid-"))
     const fixtureSkillDir = path.join(import.meta.dir, "fixtures", "sample-plugin", "skills", "skill-one")
 
@@ -29,9 +29,49 @@ describe("syncToDroid", () => {
     const linkedStat = await fs.lstat(linkedSkillPath)
     expect(linkedStat.isSymbolicLink()).toBe(true)
 
-    // Droid does not write MCP config
-    const mcpExists = await fs.access(path.join(tempRoot, "mcp.json")).then(() => true).catch(() => false)
-    expect(mcpExists).toBe(false)
+    const mcpConfig = JSON.parse(
+      await fs.readFile(path.join(tempRoot, "mcp.json"), "utf8"),
+    ) as {
+      mcpServers: Record<string, { type: string; url?: string; disabled: boolean }>
+    }
+    expect(mcpConfig.mcpServers.context7?.type).toBe("http")
+    expect(mcpConfig.mcpServers.context7?.url).toBe("https://mcp.context7.com/mcp")
+    expect(mcpConfig.mcpServers.context7?.disabled).toBe(false)
+  })
+
+  test("merges existing mcp.json and overwrites same-named servers from Claude", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "sync-droid-merge-"))
+    await fs.writeFile(
+      path.join(tempRoot, "mcp.json"),
+      JSON.stringify({
+        theme: "dark",
+        mcpServers: {
+          shared: { type: "http", url: "https://old.example.com", disabled: true },
+          existing: { type: "stdio", command: "node", disabled: false },
+        },
+      }, null, 2),
+    )
+
+    const config: ClaudeHomeConfig = {
+      skills: [],
+      mcpServers: {
+        shared: { url: "https://new.example.com" },
+      },
+    }
+
+    await syncToDroid(config, tempRoot)
+
+    const mcpConfig = JSON.parse(
+      await fs.readFile(path.join(tempRoot, "mcp.json"), "utf8"),
+    ) as {
+      theme: string
+      mcpServers: Record<string, { type: string; url?: string; command?: string; disabled: boolean }>
+    }
+
+    expect(mcpConfig.theme).toBe("dark")
+    expect(mcpConfig.mcpServers.existing?.command).toBe("node")
+    expect(mcpConfig.mcpServers.shared?.url).toBe("https://new.example.com")
+    expect(mcpConfig.mcpServers.shared?.disabled).toBe(false)
   })
 
   test("skips skills with invalid names", async () => {

package/tests/sync-gemini.test.ts

@@ -0,0 +1,160 @@
+import { describe, expect, test } from "bun:test"
+import { promises as fs } from "fs"
+import path from "path"
+import os from "os"
+import { syncToGemini } from "../src/sync/gemini"
+import type { ClaudeHomeConfig } from "../src/parsers/claude-home"
+
+describe("syncToGemini", () => {
+  test("symlinks skills and writes settings.json", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "sync-gemini-"))
+    const fixtureSkillDir = path.join(import.meta.dir, "fixtures", "sample-plugin", "skills", "skill-one")
+
+    const config: ClaudeHomeConfig = {
+      skills: [
+        {
+          name: "skill-one",
+          sourceDir: fixtureSkillDir,
+          skillPath: path.join(fixtureSkillDir, "SKILL.md"),
+        },
+      ],
+      mcpServers: {
+        context7: { url: "https://mcp.context7.com/mcp" },
+        local: { command: "echo", args: ["hello"], env: { FOO: "bar" } },
+      },
+    }
+
+    await syncToGemini(config, tempRoot)
+
+    // Check skill symlink
+    const linkedSkillPath = path.join(tempRoot, "skills", "skill-one")
+    const linkedStat = await fs.lstat(linkedSkillPath)
+    expect(linkedStat.isSymbolicLink()).toBe(true)
+
+    // Check settings.json
+    const settingsPath = path.join(tempRoot, "settings.json")
+    const settings = JSON.parse(await fs.readFile(settingsPath, "utf8")) as {
+      mcpServers: Record<string, { url?: string; command?: string; args?: string[]; env?: Record<string, string> }>
+    }
+
+    expect(settings.mcpServers.context7?.url).toBe("https://mcp.context7.com/mcp")
+    expect(settings.mcpServers.local?.command).toBe("echo")
+    expect(settings.mcpServers.local?.args).toEqual(["hello"])
+    expect(settings.mcpServers.local?.env).toEqual({ FOO: "bar" })
+  })
+
+  test("merges existing settings.json", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "sync-gemini-merge-"))
+    const settingsPath = path.join(tempRoot, "settings.json")
+
+    await fs.writeFile(
+      settingsPath,
+      JSON.stringify({
+        theme: "dark",
+        mcpServers: { existing: { command: "node", args: ["server.js"] } },
+      }, null, 2),
+    )
+
+    const config: ClaudeHomeConfig = {
+      skills: [],
+      mcpServers: {
+        context7: { url: "https://mcp.context7.com/mcp" },
+      },
+    }
+
+    await syncToGemini(config, tempRoot)
+
+    const merged = JSON.parse(await fs.readFile(settingsPath, "utf8")) as {
+      theme: string
+      mcpServers: Record<string, { command?: string; url?: string }>
+    }
+
+    // Preserves existing settings
+    expect(merged.theme).toBe("dark")
+    // Preserves existing MCP servers
+    expect(merged.mcpServers.existing?.command).toBe("node")
+    // Adds new MCP servers
+    expect(merged.mcpServers.context7?.url).toBe("https://mcp.context7.com/mcp")
+  })
+
+  test("writes personal commands as Gemini TOML prompts", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "sync-gemini-cmd-"))
+
+    const config: ClaudeHomeConfig = {
+      skills: [],
+      commands: [
+        {
+          name: "workflows:plan",
+          description: "Planning command",
+          argumentHint: "[goal]",
+          body: "Plan the work carefully.",
+          sourcePath: "/tmp/workflows/plan.md",
+        },
+      ],
+      mcpServers: {},
+    }
+
+    await syncToGemini(config, tempRoot)
+
+    const content = await fs.readFile(
+      path.join(tempRoot, "commands", "workflows", "plan.toml"),
+      "utf8",
+    )
+    expect(content).toContain("Planning command")
+    expect(content).toContain("User request: {{args}}")
+  })
+
+  test("does not write settings.json when no MCP servers", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "sync-gemini-nomcp-"))
+    const fixtureSkillDir = path.join(import.meta.dir, "fixtures", "sample-plugin", "skills", "skill-one")
+
+    const config: ClaudeHomeConfig = {
+      skills: [
+        {
+          name: "skill-one",
+          sourceDir: fixtureSkillDir,
+          skillPath: path.join(fixtureSkillDir, "SKILL.md"),
+        },
+      ],
+      mcpServers: {},
+    }
+
+    await syncToGemini(config, tempRoot)
+
+    // Skills should still be symlinked
+    const linkedSkillPath = path.join(tempRoot, "skills", "skill-one")
+    const linkedStat = await fs.lstat(linkedSkillPath)
+    expect(linkedStat.isSymbolicLink()).toBe(true)
+
+    // But settings.json should not exist
+    const settingsExists = await fs.access(path.join(tempRoot, "settings.json")).then(() => true).catch(() => false)
+    expect(settingsExists).toBe(false)
+  })
+
+  test("skips mirrored ~/.agents skills when syncing to ~/.gemini and removes stale duplicate symlinks", async () => {
+    const tempHome = await fs.mkdtemp(path.join(os.tmpdir(), "sync-gemini-home-"))
+    const geminiRoot = path.join(tempHome, ".gemini")
+    const agentsSkillDir = path.join(tempHome, ".agents", "skills", "skill-one")
+
+    await fs.mkdir(path.join(agentsSkillDir), { recursive: true })
+    await fs.writeFile(path.join(agentsSkillDir, "SKILL.md"), "# Skill One\n", "utf8")
+    await fs.mkdir(path.join(geminiRoot, "skills"), { recursive: true })
+    await fs.symlink(agentsSkillDir, path.join(geminiRoot, "skills", "skill-one"))
+
+    const config: ClaudeHomeConfig = {
+      skills: [
+        {
+          name: "skill-one",
+          sourceDir: agentsSkillDir,
+          skillPath: path.join(agentsSkillDir, "SKILL.md"),
+        },
+      ],
+      mcpServers: {},
+    }
+
+    await syncToGemini(config, geminiRoot)
+
+    const duplicateExists = await fs.access(path.join(geminiRoot, "skills", "skill-one")).then(() => true).catch(() => false)
+    expect(duplicateExists).toBe(false)
+  })
+})

package/tests/sync-kiro.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, test } from "bun:test"
+import { promises as fs } from "fs"
+import os from "os"
+import path from "path"
+import type { ClaudeHomeConfig } from "../src/parsers/claude-home"
+import { syncToKiro } from "../src/sync/kiro"
+
+describe("syncToKiro", () => {
+  test("writes user-scope settings/mcp.json with local and remote servers", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "sync-kiro-"))
+    const fixtureSkillDir = path.join(import.meta.dir, "fixtures", "sample-plugin", "skills", "skill-one")
+
+    const config: ClaudeHomeConfig = {
+      skills: [
+        {
+          name: "skill-one",
+          sourceDir: fixtureSkillDir,
+          skillPath: path.join(fixtureSkillDir, "SKILL.md"),
+        },
+      ],
+      mcpServers: {
+        local: { command: "echo", args: ["hello"], env: { TOKEN: "secret" } },
+        remote: { url: "https://example.com/mcp", headers: { Authorization: "Bearer token" } },
+      },
+    }
+
+    await syncToKiro(config, tempRoot)
+
+    expect((await fs.lstat(path.join(tempRoot, "skills", "skill-one"))).isSymbolicLink()).toBe(true)
+
+    const content = JSON.parse(
+      await fs.readFile(path.join(tempRoot, "settings", "mcp.json"), "utf8"),
+    ) as {
+      mcpServers: Record<string, {
+        command?: string
+        args?: string[]
+        env?: Record<string, string>
+        url?: string
+        headers?: Record<string, string>
+      }>
+    }
+
+    expect(content.mcpServers.local?.command).toBe("echo")
+    expect(content.mcpServers.local?.args).toEqual(["hello"])
+    expect(content.mcpServers.local?.env).toEqual({ TOKEN: "secret" })
+    expect(content.mcpServers.remote?.url).toBe("https://example.com/mcp")
+    expect(content.mcpServers.remote?.headers).toEqual({ Authorization: "Bearer token" })
+  })
+
+  test("merges existing settings/mcp.json", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "sync-kiro-merge-"))
+    await fs.mkdir(path.join(tempRoot, "settings"), { recursive: true })
+    await fs.writeFile(
+      path.join(tempRoot, "settings", "mcp.json"),
+      JSON.stringify({
+        note: "preserve",
+        mcpServers: {
+          existing: { command: "node" },
+        },
+      }, null, 2),
+    )
+
+    const config: ClaudeHomeConfig = {
+      skills: [],
+      mcpServers: {
+        remote: { url: "https://example.com/mcp" },
+      },
+    }
+
+    await syncToKiro(config, tempRoot)
+
+    const content = JSON.parse(
+      await fs.readFile(path.join(tempRoot, "settings", "mcp.json"), "utf8"),
+    ) as {
+      note: string
+      mcpServers: Record<string, { command?: string; url?: string }>
+    }
+
+    expect(content.note).toBe("preserve")
+    expect(content.mcpServers.existing?.command).toBe("node")
+    expect(content.mcpServers.remote?.url).toBe("https://example.com/mcp")
+  })
+})

package/tests/sync-openclaw.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, test } from "bun:test"
+import { promises as fs } from "fs"
+import os from "os"
+import path from "path"
+import type { ClaudeHomeConfig } from "../src/parsers/claude-home"
+import { syncToOpenClaw } from "../src/sync/openclaw"
+
+describe("syncToOpenClaw", () => {
+  test("symlinks skills and warns instead of writing unvalidated MCP config", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "sync-openclaw-"))
+    const fixtureSkillDir = path.join(import.meta.dir, "fixtures", "sample-plugin", "skills", "skill-one")
+    const warnings: string[] = []
+    const originalWarn = console.warn
+    console.warn = (message?: unknown) => {
+      warnings.push(String(message))
+    }
+
+    try {
+      const config: ClaudeHomeConfig = {
+        skills: [
+          {
+            name: "skill-one",
+            sourceDir: fixtureSkillDir,
+            skillPath: path.join(fixtureSkillDir, "SKILL.md"),
+          },
+        ],
+        commands: [
+          {
+            name: "workflows:plan",
+            description: "Planning command",
+            body: "Plan the work.",
+            sourcePath: "/tmp/workflows/plan.md",
+          },
+        ],
+        mcpServers: {
+          remote: { url: "https://example.com/mcp" },
+        },
+      }
+
+      await syncToOpenClaw(config, tempRoot)
+    } finally {
+      console.warn = originalWarn
+    }
+
+    expect((await fs.lstat(path.join(tempRoot, "skills", "skill-one"))).isSymbolicLink()).toBe(true)
+    const openclawConfigExists = await fs.access(path.join(tempRoot, "openclaw.json")).then(() => true).catch(() => false)
+    expect(openclawConfigExists).toBe(false)
+    expect(warnings.some((warning) => warning.includes("OpenClaw personal command sync is skipped"))).toBe(true)
+    expect(warnings.some((warning) => warning.includes("OpenClaw MCP sync is skipped"))).toBe(true)
+  })
+})

package/tests/sync-qwen.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, test } from "bun:test"
+import { promises as fs } from "fs"
+import os from "os"
+import path from "path"
+import type { ClaudeHomeConfig } from "../src/parsers/claude-home"
+import { syncToQwen } from "../src/sync/qwen"
+
+describe("syncToQwen", () => {
+  test("defaults ambiguous remote URLs to httpUrl and warns", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "sync-qwen-"))
+    const warnings: string[] = []
+    const originalWarn = console.warn
+    console.warn = (message?: unknown) => {
+      warnings.push(String(message))
+    }
+
+    try {
+      const config: ClaudeHomeConfig = {
+        skills: [],
+        mcpServers: {
+          remote: { url: "https://example.com/mcp", headers: { Authorization: "Bearer token" } },
+        },
+      }
+
+      await syncToQwen(config, tempRoot)
+    } finally {
+      console.warn = originalWarn
+    }
+
+    const content = JSON.parse(
+      await fs.readFile(path.join(tempRoot, "settings.json"), "utf8"),
+    ) as {
+      mcpServers: Record<string, { httpUrl?: string; url?: string; headers?: Record<string, string> }>
+    }
+
+    expect(content.mcpServers.remote?.httpUrl).toBe("https://example.com/mcp")
+    expect(content.mcpServers.remote?.url).toBeUndefined()
+    expect(content.mcpServers.remote?.headers).toEqual({ Authorization: "Bearer token" })
+    expect(warnings.some((warning) => warning.includes("ambiguous remote transport"))).toBe(true)
+  })
+
+  test("uses legacy url only for explicit SSE servers and preserves existing settings", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "sync-qwen-sse-"))
+    await fs.writeFile(
+      path.join(tempRoot, "settings.json"),
+      JSON.stringify({
+        theme: "dark",
+        mcpServers: {
+          existing: { command: "node" },
+        },
+      }, null, 2),
+    )
+
+    const config: ClaudeHomeConfig = {
+      skills: [],
+      mcpServers: {
+        legacy: { type: "sse", url: "https://example.com/sse" },
+      },
+    }
+
+    await syncToQwen(config, tempRoot)
+
+    const content = JSON.parse(
+      await fs.readFile(path.join(tempRoot, "settings.json"), "utf8"),
+    ) as {
+      theme: string
+      mcpServers: Record<string, { command?: string; httpUrl?: string; url?: string }>
+    }
+
+    expect(content.theme).toBe("dark")
+    expect(content.mcpServers.existing?.command).toBe("node")
+    expect(content.mcpServers.legacy?.url).toBe("https://example.com/sse")
+    expect(content.mcpServers.legacy?.httpUrl).toBeUndefined()
+  })
+})

package/tests/sync-windsurf.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, test } from "bun:test"
+import { promises as fs } from "fs"
+import os from "os"
+import path from "path"
+import type { ClaudeHomeConfig } from "../src/parsers/claude-home"
+import { syncToWindsurf } from "../src/sync/windsurf"
+
+describe("syncToWindsurf", () => {
+  test("writes stdio, http, and sse MCP servers", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "sync-windsurf-"))
+    const fixtureSkillDir = path.join(import.meta.dir, "fixtures", "sample-plugin", "skills", "skill-one")
+
+    const config: ClaudeHomeConfig = {
+      skills: [
+        {
+          name: "skill-one",
+          sourceDir: fixtureSkillDir,
+          skillPath: path.join(fixtureSkillDir, "SKILL.md"),
+        },
+      ],
+      mcpServers: {
+        local: { command: "npx", args: ["serve"], env: { FOO: "bar" } },
+        remoteHttp: { url: "https://example.com/mcp", headers: { Authorization: "Bearer a" } },
+        remoteSse: { type: "sse", url: "https://example.com/sse" },
+      },
+    }
+
+    await syncToWindsurf(config, tempRoot)
+
+    expect((await fs.lstat(path.join(tempRoot, "skills", "skill-one"))).isSymbolicLink()).toBe(true)
+
+    const content = JSON.parse(
+      await fs.readFile(path.join(tempRoot, "mcp_config.json"), "utf8"),
+    ) as {
+      mcpServers: Record<string, {
+        command?: string
+        args?: string[]
+        env?: Record<string, string>
+        serverUrl?: string
+        url?: string
+      }>
+    }
+
+    expect(content.mcpServers.local).toEqual({
+      command: "npx",
+      args: ["serve"],
+      env: { FOO: "bar" },
+    })
+    expect(content.mcpServers.remoteHttp?.serverUrl).toBe("https://example.com/mcp")
+    expect(content.mcpServers.remoteSse?.url).toBe("https://example.com/sse")
+
+    const perms = (await fs.stat(path.join(tempRoot, "mcp_config.json"))).mode & 0o777
+    expect(perms).toBe(0o600)
+  })
+
+  test("merges existing config and overwrites same-named servers", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "sync-windsurf-merge-"))
+    await fs.writeFile(
+      path.join(tempRoot, "mcp_config.json"),
+      JSON.stringify({
+        theme: "dark",
+        mcpServers: {
+          existing: { command: "node" },
+          shared: { serverUrl: "https://old.example.com" },
+        },
+      }, null, 2),
+    )
+
+    const config: ClaudeHomeConfig = {
+      skills: [],
+      mcpServers: {
+        shared: { url: "https://new.example.com" },
+      },
+    }
+
+    await syncToWindsurf(config, tempRoot)
+
+    const content = JSON.parse(
+      await fs.readFile(path.join(tempRoot, "mcp_config.json"), "utf8"),
+    ) as {
+      theme: string
+      mcpServers: Record<string, { command?: string; serverUrl?: string }>
+    }
+
+    expect(content.theme).toBe("dark")
+    expect(content.mcpServers.existing?.command).toBe("node")
+    expect(content.mcpServers.shared?.serverUrl).toBe("https://new.example.com")
+  })
+})