@every-env/compound-plugin 0.12.0 → 2.34.2

package/src/sync/registry.ts

@@ -0,0 +1,141 @@
+import os from "os"
+import path from "path"
+import type { ClaudeHomeConfig } from "../parsers/claude-home"
+import { syncToCodex } from "./codex"
+import { syncToCopilot } from "./copilot"
+import { syncToDroid } from "./droid"
+import { syncToGemini } from "./gemini"
+import { syncToKiro } from "./kiro"
+import { syncToOpenClaw } from "./openclaw"
+import { syncToOpenCode } from "./opencode"
+import { syncToPi } from "./pi"
+import { syncToQwen } from "./qwen"
+import { syncToWindsurf } from "./windsurf"
+
+function getCopilotHomeRoot(home: string): string {
+  return path.join(home, ".copilot")
+}
+
+function getGeminiHomeRoot(home: string): string {
+  return path.join(home, ".gemini")
+}
+
+export type SyncTargetName =
+  | "opencode"
+  | "codex"
+  | "pi"
+  | "droid"
+  | "copilot"
+  | "gemini"
+  | "windsurf"
+  | "kiro"
+  | "qwen"
+  | "openclaw"
+
+export type SyncTargetDefinition = {
+  name: SyncTargetName
+  detectPaths: (home: string, cwd: string) => string[]
+  resolveOutputRoot: (home: string, cwd: string) => string
+  sync: (config: ClaudeHomeConfig, outputRoot: string) => Promise<void>
+}
+
+export const syncTargets: SyncTargetDefinition[] = [
+  {
+    name: "opencode",
+    detectPaths: (home, cwd) => [
+      path.join(home, ".config", "opencode"),
+      path.join(cwd, ".opencode"),
+    ],
+    resolveOutputRoot: (home) => path.join(home, ".config", "opencode"),
+    sync: syncToOpenCode,
+  },
+  {
+    name: "codex",
+    detectPaths: (home) => [path.join(home, ".codex")],
+    resolveOutputRoot: (home) => path.join(home, ".codex"),
+    sync: syncToCodex,
+  },
+  {
+    name: "pi",
+    detectPaths: (home) => [path.join(home, ".pi")],
+    resolveOutputRoot: (home) => path.join(home, ".pi", "agent"),
+    sync: syncToPi,
+  },
+  {
+    name: "droid",
+    detectPaths: (home) => [path.join(home, ".factory")],
+    resolveOutputRoot: (home) => path.join(home, ".factory"),
+    sync: syncToDroid,
+  },
+  {
+    name: "copilot",
+    detectPaths: (home, cwd) => [
+      getCopilotHomeRoot(home),
+      path.join(cwd, ".github", "skills"),
+      path.join(cwd, ".github", "agents"),
+      path.join(cwd, ".github", "copilot-instructions.md"),
+    ],
+    resolveOutputRoot: (home) => getCopilotHomeRoot(home),
+    sync: syncToCopilot,
+  },
+  {
+    name: "gemini",
+    detectPaths: (home, cwd) => [
+      path.join(cwd, ".gemini"),
+      getGeminiHomeRoot(home),
+    ],
+    resolveOutputRoot: (home) => getGeminiHomeRoot(home),
+    sync: syncToGemini,
+  },
+  {
+    name: "windsurf",
+    detectPaths: (home, cwd) => [
+      path.join(home, ".codeium", "windsurf"),
+      path.join(cwd, ".windsurf"),
+    ],
+    resolveOutputRoot: (home) => path.join(home, ".codeium", "windsurf"),
+    sync: syncToWindsurf,
+  },
+  {
+    name: "kiro",
+    detectPaths: (home, cwd) => [
+      path.join(home, ".kiro"),
+      path.join(cwd, ".kiro"),
+    ],
+    resolveOutputRoot: (home) => path.join(home, ".kiro"),
+    sync: syncToKiro,
+  },
+  {
+    name: "qwen",
+    detectPaths: (home, cwd) => [
+      path.join(home, ".qwen"),
+      path.join(cwd, ".qwen"),
+    ],
+    resolveOutputRoot: (home) => path.join(home, ".qwen"),
+    sync: syncToQwen,
+  },
+  {
+    name: "openclaw",
+    detectPaths: (home) => [path.join(home, ".openclaw")],
+    resolveOutputRoot: (home) => path.join(home, ".openclaw"),
+    sync: syncToOpenClaw,
+  },
+]
+
+export const syncTargetNames = syncTargets.map((target) => target.name)
+
+export function isSyncTargetName(value: string): value is SyncTargetName {
+  return syncTargetNames.includes(value as SyncTargetName)
+}
+
+export function getSyncTarget(name: SyncTargetName): SyncTargetDefinition {
+  const target = syncTargets.find((entry) => entry.name === name)
+  if (!target) {
+    throw new Error(`Unknown sync target: ${name}`)
+  }
+  return target
+}
+
+export function getDefaultSyncRegistryContext(): { home: string; cwd: string } {
+  return { home: os.homedir(), cwd: process.cwd() }
+}

package/src/sync/skills.ts

@@ -0,0 +1,21 @@
+import path from "path"
+import type { ClaudeSkill } from "../types/claude"
+import { ensureDir } from "../utils/files"
+import { forceSymlink, isValidSkillName } from "../utils/symlink"
+
+export async function syncSkills(
+  skills: ClaudeSkill[],
+  skillsDir: string,
+): Promise<void> {
+  await ensureDir(skillsDir)
+
+  for (const skill of skills) {
+    if (!isValidSkillName(skill.name)) {
+      console.warn(`Skipping skill with invalid name: ${skill.name}`)
+      continue
+    }
+
+    const target = path.join(skillsDir, skill.name)
+    await forceSymlink(skill.sourceDir, target)
+  }
+}

package/src/sync/windsurf.ts

@@ -0,0 +1,59 @@
+import path from "path"
+import type { ClaudeHomeConfig } from "../parsers/claude-home"
+import type { ClaudeMcpServer } from "../types/claude"
+import type { WindsurfMcpServerEntry } from "../types/windsurf"
+import { syncWindsurfCommands } from "./commands"
+import { mergeJsonConfigAtKey } from "./json-config"
+import { hasExplicitSseTransport } from "./mcp-transports"
+import { syncSkills } from "./skills"
+
+export async function syncToWindsurf(
+  config: ClaudeHomeConfig,
+  outputRoot: string,
+): Promise<void> {
+  await syncSkills(config.skills, path.join(outputRoot, "skills"))
+  await syncWindsurfCommands(config, outputRoot, "global")
+
+  if (Object.keys(config.mcpServers).length > 0) {
+    await mergeJsonConfigAtKey({
+      configPath: path.join(outputRoot, "mcp_config.json"),
+      key: "mcpServers",
+      incoming: convertMcpForWindsurf(config.mcpServers),
+    })
+  }
+}
+
+function convertMcpForWindsurf(
+  servers: Record<string, ClaudeMcpServer>,
+): Record<string, WindsurfMcpServerEntry> {
+  const result: Record<string, WindsurfMcpServerEntry> = {}
+
+  for (const [name, server] of Object.entries(servers)) {
+    if (server.command) {
+      result[name] = {
+        command: server.command,
+        args: server.args,
+        env: server.env,
+      }
+      continue
+    }
+
+    if (!server.url) {
+      continue
+    }
+
+    const entry: WindsurfMcpServerEntry = {
+      headers: server.headers,
+    }
+
+    if (hasExplicitSseTransport(server)) {
+      entry.url = server.url
+    } else {
+      entry.serverUrl = server.url
+    }
+
+    result[name] = entry
+  }
+
+  return result
+}

package/src/types/kiro.ts

@@ -30,9 +30,11 @@ export type KiroSteeringFile = {
 }
 
 export type KiroMcpServer = {
-  command: string
+  command?: string
   args?: string[]
   env?: Record<string, string>
+  url?: string
+  headers?: Record<string, string>
 }
 
 export type KiroBundle = {

package/src/types/qwen.ts

@@ -14,6 +14,9 @@ export type QwenMcpServer = {
   args?: string[]
   env?: Record<string, string>
   cwd?: string
+  httpUrl?: string
+  url?: string
+  headers?: Record<string, string>
 }
 
 export type QwenSetting = {

package/src/types/windsurf.ts

@@ -19,6 +19,7 @@ export type WindsurfMcpServerEntry = {
   args?: string[]
   env?: Record<string, string>
   serverUrl?: string
+  url?: string
   headers?: Record<string, string>
 }
 

package/src/utils/codex-agents.ts

@@ -18,7 +18,7 @@ Tool mapping:
 - Glob: use rg --files or find
 - LS: use ls via shell_command
 - WebFetch/WebSearch: use curl or Context7 for library docs
-- AskUserQuestion/Question: ask the user in chat
+- AskUserQuestion/Question: present choices as a numbered list in chat and wait for a reply number. For multi-select (multiSelect: true), accept comma-separated numbers. Never skip or auto-configure — always wait for the user's response before proceeding.
 - Task/Subagent/Parallel: run sequentially in main thread; use multi_tool_use.parallel for tool calls
 - TodoWrite/TodoRead: use file-based todos in todos/ with file-todos skill
 - Skill: open the referenced SKILL.md and follow it

package/src/utils/detect-tools.ts

@@ -1,6 +1,6 @@
 import os from "os"
-import path from "path"
 import { pathExists } from "./files"
+import { syncTargets } from "../sync/registry"
 
 export type DetectedTool = {
   name: string
@@ -12,27 +12,18 @@ export async function detectInstalledTools(
   home: string = os.homedir(),
   cwd: string = process.cwd(),
 ): Promise<DetectedTool[]> {
-  const checks: Array<{ name: string; paths: string[] }> = [
-    { name: "opencode", paths: [path.join(home, ".config", "opencode"), path.join(cwd, ".opencode")] },
-    { name: "codex", paths: [path.join(home, ".codex")] },
-    { name: "droid", paths: [path.join(home, ".factory")] },
-    { name: "cursor", paths: [path.join(cwd, ".cursor"), path.join(home, ".cursor")] },
-    { name: "pi", paths: [path.join(home, ".pi")] },
-    { name: "gemini", paths: [path.join(cwd, ".gemini"), path.join(home, ".gemini")] },
-  ]
-
   const results: DetectedTool[] = []
-  for (const check of checks) {
+  for (const target of syncTargets) {
     let detected = false
     let reason = "not found"
-    for (const p of check.paths) {
+    for (const p of target.detectPaths(home, cwd)) {
       if (await pathExists(p)) {
         detected = true
         reason = `found ${p}`
         break
       }
     }
-    results.push({ name: check.name, detected, reason })
+    results.push({ name: target.name, detected, reason })
   }
   return results
 }

package/src/utils/files.ts

@@ -41,6 +41,12 @@ export async function writeText(filePath: string, content: string): Promise<void
   await fs.writeFile(filePath, content, "utf8")
 }
 
+export async function writeTextSecure(filePath: string, content: string): Promise<void> {
+  await ensureDir(path.dirname(filePath))
+  await fs.writeFile(filePath, content, { encoding: "utf8", mode: 0o600 })
+  await fs.chmod(filePath, 0o600)
+}
+
 export async function writeJson(filePath: string, data: unknown): Promise<void> {
   const content = JSON.stringify(data, null, 2)
   await writeText(filePath, content + "\n")
@@ -51,6 +57,7 @@ export async function writeJsonSecure(filePath: string, data: unknown): Promise<
   const content = JSON.stringify(data, null, 2)
   await ensureDir(path.dirname(filePath))
   await fs.writeFile(filePath, content + "\n", { encoding: "utf8", mode: 0o600 })
+  await fs.chmod(filePath, 0o600)
 }
 
 export async function walkFiles(root: string): Promise<string[]> {

package/src/utils/symlink.ts

@@ -2,7 +2,7 @@ import fs from "fs/promises"
 
 /**
  * Create a symlink, safely replacing any existing symlink at target.
- * Only removes existing symlinks - refuses to delete real directories.
+ * Only removes existing symlinks - skips real directories with a warning.
  */
 export async function forceSymlink(source: string, target: string): Promise<void> {
   try {
@@ -11,11 +11,9 @@ export async function forceSymlink(source: string, target: string): Promise<void
       // Safe to remove existing symlink
       await fs.unlink(target)
     } else if (stat.isDirectory()) {
-      // Refuse to delete real directories
-      throw new Error(
-        `Cannot create symlink at ${target}: a real directory exists there. ` +
-        `Remove it manually if you want to replace it with a symlink.`
-      )
+      // Skip real directories rather than deleting them
+      console.warn(`Skipping ${target}: a real directory exists there (remove it manually to replace with a symlink).`)
+      return
     } else {
       // Regular file - remove it
       await fs.unlink(target)

package/tests/claude-home.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, test } from "bun:test"
+import { promises as fs } from "fs"
+import os from "os"
+import path from "path"
+import { loadClaudeHome } from "../src/parsers/claude-home"
+
+describe("loadClaudeHome", () => {
+  test("loads personal skills, commands, and MCP servers", async () => {
+    const tempHome = await fs.mkdtemp(path.join(os.tmpdir(), "claude-home-"))
+    const skillDir = path.join(tempHome, "skills", "reviewer")
+    const commandsDir = path.join(tempHome, "commands")
+
+    await fs.mkdir(skillDir, { recursive: true })
+    await fs.writeFile(path.join(skillDir, "SKILL.md"), "---\nname: reviewer\n---\nReview things.\n")
+
+    await fs.mkdir(path.join(commandsDir, "workflows"), { recursive: true })
+    await fs.writeFile(
+      path.join(commandsDir, "workflows", "plan.md"),
+      "---\ndescription: Planning command\nargument-hint: \"[feature]\"\n---\nPlan the work.\n",
+    )
+    await fs.writeFile(
+      path.join(commandsDir, "custom.md"),
+      "---\nname: custom-command\ndescription: Custom command\nallowed-tools: Bash, Read\n---\nDo custom work.\n",
+    )
+
+    await fs.writeFile(
+      path.join(tempHome, "settings.json"),
+      JSON.stringify({
+        mcpServers: {
+          context7: { url: "https://mcp.context7.com/mcp" },
+        },
+      }),
+    )
+
+    const config = await loadClaudeHome(tempHome)
+
+    expect(config.skills.map((skill) => skill.name)).toEqual(["reviewer"])
+    expect(config.commands?.map((command) => command.name)).toEqual([
+      "custom-command",
+      "workflows:plan",
+    ])
+    expect(config.commands?.find((command) => command.name === "workflows:plan")?.argumentHint).toBe("[feature]")
+    expect(config.commands?.find((command) => command.name === "custom-command")?.allowedTools).toEqual(["Bash", "Read"])
+    expect(config.mcpServers.context7?.url).toBe("https://mcp.context7.com/mcp")
+  })
+})

package/tests/cli.test.ts

@@ -504,4 +504,106 @@ describe("CLI", () => {
     expect(json).toHaveProperty("permission")
     expect(json.permission).not.toBeNull()
   })
+
+  test("sync --target all detects new sync targets and ignores stale cursor directories", async () => {
+    const tempHome = await fs.mkdtemp(path.join(os.tmpdir(), "cli-sync-home-"))
+    const tempCwd = await fs.mkdtemp(path.join(os.tmpdir(), "cli-sync-cwd-"))
+    const repoRoot = path.join(import.meta.dir, "..")
+    const fixtureSkillDir = path.join(import.meta.dir, "fixtures", "sample-plugin", "skills", "skill-one")
+    const claudeSkillsDir = path.join(tempHome, ".claude", "skills", "skill-one")
+    const claudeCommandsDir = path.join(tempHome, ".claude", "commands", "workflows")
+
+    await fs.mkdir(path.dirname(claudeSkillsDir), { recursive: true })
+    await fs.cp(fixtureSkillDir, claudeSkillsDir, { recursive: true })
+    await fs.mkdir(claudeCommandsDir, { recursive: true })
+    await fs.writeFile(
+      path.join(claudeCommandsDir, "plan.md"),
+      [
+        "---",
+        "name: workflows:plan",
+        "description: Plan work",
+        "argument-hint: \"[goal]\"",
+        "---",
+        "",
+        "Plan the work.",
+      ].join("\n"),
+    )
+    await fs.writeFile(
+      path.join(tempHome, ".claude", "settings.json"),
+      JSON.stringify({
+        mcpServers: {
+          local: { command: "echo", args: ["hello"] },
+          remote: { url: "https://example.com/mcp" },
+          legacy: { type: "sse", url: "https://example.com/sse" },
+        },
+      }, null, 2),
+    )
+
+    await fs.mkdir(path.join(tempHome, ".config", "opencode"), { recursive: true })
+    await fs.mkdir(path.join(tempHome, ".codex"), { recursive: true })
+    await fs.mkdir(path.join(tempHome, ".pi"), { recursive: true })
+    await fs.mkdir(path.join(tempHome, ".factory"), { recursive: true })
+    await fs.mkdir(path.join(tempHome, ".copilot"), { recursive: true })
+    await fs.mkdir(path.join(tempHome, ".gemini"), { recursive: true })
+    await fs.mkdir(path.join(tempHome, ".codeium", "windsurf"), { recursive: true })
+    await fs.mkdir(path.join(tempHome, ".kiro"), { recursive: true })
+    await fs.mkdir(path.join(tempHome, ".qwen"), { recursive: true })
+    await fs.mkdir(path.join(tempHome, ".openclaw"), { recursive: true })
+    await fs.mkdir(path.join(tempCwd, ".cursor"), { recursive: true })
+
+    const proc = Bun.spawn([
+      "bun",
+      "run",
+      path.join(repoRoot, "src", "index.ts"),
+      "sync",
+      "--target",
+      "all",
+    ], {
+      cwd: tempCwd,
+      stdout: "pipe",
+      stderr: "pipe",
+      env: {
+        ...process.env,
+        HOME: tempHome,
+      },
+    })
+
+    const exitCode = await proc.exited
+    const stdout = await new Response(proc.stdout).text()
+    const stderr = await new Response(proc.stderr).text()
+
+    if (exitCode !== 0) {
+      throw new Error(`CLI failed (exit ${exitCode}).\nstdout: ${stdout}\nstderr: ${stderr}`)
+    }
+
+    expect(stdout).toContain("Synced to codex")
+    expect(stdout).toContain("Synced to opencode")
+    expect(stdout).toContain("Synced to pi")
+    expect(stdout).toContain("Synced to droid")
+    expect(stdout).toContain("Synced to windsurf")
+    expect(stdout).toContain("Synced to kiro")
+    expect(stdout).toContain("Synced to qwen")
+    expect(stdout).toContain("Synced to openclaw")
+    expect(stdout).toContain("Synced to copilot")
+    expect(stdout).toContain("Synced to gemini")
+    expect(stdout).not.toContain("cursor")
+
+    expect(await exists(path.join(tempHome, ".config", "opencode", "commands", "workflows:plan.md"))).toBe(true)
+    expect(await exists(path.join(tempHome, ".codex", "config.toml"))).toBe(true)
+    expect(await exists(path.join(tempHome, ".codex", "prompts", "workflows-plan.md"))).toBe(true)
+    expect(await exists(path.join(tempHome, ".codex", "skills", "workflows-plan", "SKILL.md"))).toBe(true)
+    expect(await exists(path.join(tempHome, ".pi", "agent", "prompts", "workflows-plan.md"))).toBe(true)
+    expect(await exists(path.join(tempHome, ".factory", "commands", "plan.md"))).toBe(true)
+    expect(await exists(path.join(tempHome, ".codeium", "windsurf", "mcp_config.json"))).toBe(true)
+    expect(await exists(path.join(tempHome, ".codeium", "windsurf", "global_workflows", "workflows-plan.md"))).toBe(true)
+    expect(await exists(path.join(tempHome, ".kiro", "settings", "mcp.json"))).toBe(true)
+    expect(await exists(path.join(tempHome, ".kiro", "skills", "workflows-plan", "SKILL.md"))).toBe(true)
+    expect(await exists(path.join(tempHome, ".qwen", "settings.json"))).toBe(true)
+    expect(await exists(path.join(tempHome, ".qwen", "commands", "workflows", "plan.md"))).toBe(true)
+    expect(await exists(path.join(tempHome, ".copilot", "mcp-config.json"))).toBe(true)
+    expect(await exists(path.join(tempHome, ".copilot", "skills", "workflows-plan", "SKILL.md"))).toBe(true)
+    expect(await exists(path.join(tempHome, ".gemini", "settings.json"))).toBe(true)
+    expect(await exists(path.join(tempHome, ".gemini", "commands", "workflows", "plan.toml"))).toBe(true)
+    expect(await exists(path.join(tempHome, ".openclaw", "skills", "skill-one"))).toBe(true)
+  })
 })

package/tests/detect-tools.test.ts

@@ -11,8 +11,9 @@ describe("detectInstalledTools", () => {
 
     // Create directories for some tools
     await fs.mkdir(path.join(tempHome, ".codex"), { recursive: true })
-    await fs.mkdir(path.join(tempCwd, ".cursor"), { recursive: true })
-    await fs.mkdir(path.join(tempCwd, ".gemini"), { recursive: true })
+    await fs.mkdir(path.join(tempHome, ".codeium", "windsurf"), { recursive: true })
+    await fs.mkdir(path.join(tempHome, ".gemini"), { recursive: true })
+    await fs.mkdir(path.join(tempHome, ".copilot"), { recursive: true })
 
     const results = await detectInstalledTools(tempHome, tempCwd)
 
@@ -20,14 +21,18 @@ describe("detectInstalledTools", () => {
     expect(codex?.detected).toBe(true)
     expect(codex?.reason).toContain(".codex")
 
-    const cursor = results.find((t) => t.name === "cursor")
-    expect(cursor?.detected).toBe(true)
-    expect(cursor?.reason).toContain(".cursor")
+    const windsurf = results.find((t) => t.name === "windsurf")
+    expect(windsurf?.detected).toBe(true)
+    expect(windsurf?.reason).toContain(".codeium/windsurf")
 
     const gemini = results.find((t) => t.name === "gemini")
     expect(gemini?.detected).toBe(true)
     expect(gemini?.reason).toContain(".gemini")
 
+    const copilot = results.find((t) => t.name === "copilot")
+    expect(copilot?.detected).toBe(true)
+    expect(copilot?.reason).toContain(".copilot")
+
     // Tools without directories should not be detected
     const opencode = results.find((t) => t.name === "opencode")
     expect(opencode?.detected).toBe(false)
@@ -45,7 +50,7 @@ describe("detectInstalledTools", () => {
 
     const results = await detectInstalledTools(tempHome, tempCwd)
 
-    expect(results.length).toBe(6)
+    expect(results.length).toBe(10)
     for (const tool of results) {
       expect(tool.detected).toBe(false)
       expect(tool.reason).toBe("not found")
@@ -59,12 +64,30 @@ describe("detectInstalledTools", () => {
     await fs.mkdir(path.join(tempHome, ".config", "opencode"), { recursive: true })
     await fs.mkdir(path.join(tempHome, ".factory"), { recursive: true })
     await fs.mkdir(path.join(tempHome, ".pi"), { recursive: true })
+    await fs.mkdir(path.join(tempHome, ".openclaw"), { recursive: true })
 
     const results = await detectInstalledTools(tempHome, tempCwd)
 
     expect(results.find((t) => t.name === "opencode")?.detected).toBe(true)
     expect(results.find((t) => t.name === "droid")?.detected).toBe(true)
     expect(results.find((t) => t.name === "pi")?.detected).toBe(true)
+    expect(results.find((t) => t.name === "openclaw")?.detected).toBe(true)
+  })
+
+  test("detects copilot from project-specific skills without generic .github false positives", async () => {
+    const tempHome = await fs.mkdtemp(path.join(os.tmpdir(), "detect-copilot-home-"))
+    const tempCwd = await fs.mkdtemp(path.join(os.tmpdir(), "detect-copilot-cwd-"))
+
+    await fs.mkdir(path.join(tempCwd, ".github"), { recursive: true })
+
+    let results = await detectInstalledTools(tempHome, tempCwd)
+    expect(results.find((t) => t.name === "copilot")?.detected).toBe(false)
+
+    await fs.mkdir(path.join(tempCwd, ".github", "skills"), { recursive: true })
+
+    results = await detectInstalledTools(tempHome, tempCwd)
+    expect(results.find((t) => t.name === "copilot")?.detected).toBe(true)
+    expect(results.find((t) => t.name === "copilot")?.reason).toContain(".github/skills")
   })
 })
 
@@ -74,7 +97,7 @@ describe("getDetectedTargetNames", () => {
     const tempCwd = await fs.mkdtemp(path.join(os.tmpdir(), "detect-names-cwd-"))
 
     await fs.mkdir(path.join(tempHome, ".codex"), { recursive: true })
-    await fs.mkdir(path.join(tempCwd, ".gemini"), { recursive: true })
+    await fs.mkdir(path.join(tempHome, ".gemini"), { recursive: true })
 
     const names = await getDetectedTargetNames(tempHome, tempCwd)
 

package/tests/sync-codex.test.ts

@@ -0,0 +1,64 @@
+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 { syncToCodex } from "../src/sync/codex"
+
+describe("syncToCodex", () => {
+  test("writes stdio and remote MCP servers into a managed block without clobbering user config", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "sync-codex-"))
+    const fixtureSkillDir = path.join(import.meta.dir, "fixtures", "sample-plugin", "skills", "skill-one")
+    const configPath = path.join(tempRoot, "config.toml")
+
+    await fs.writeFile(
+      configPath,
+      [
+        "[custom]",
+        "enabled = true",
+        "",
+        "# BEGIN compound-plugin Claude Code MCP",
+        "[mcp_servers.old]",
+        "command = \"old\"",
+        "# END compound-plugin Claude Code MCP",
+        "",
+        "[post]",
+        "value = 2",
+        "",
+      ].join("\n"),
+    )
+
+    const config: ClaudeHomeConfig = {
+      skills: [
+        {
+          name: "skill-one",
+          sourceDir: fixtureSkillDir,
+          skillPath: path.join(fixtureSkillDir, "SKILL.md"),
+        },
+      ],
+      mcpServers: {
+        local: { command: "echo", args: ["hello"], env: { KEY: "VALUE" } },
+        remote: { url: "https://example.com/mcp", headers: { Authorization: "Bearer token" } },
+      },
+    }
+
+    await syncToCodex(config, tempRoot)
+
+    const skillPath = path.join(tempRoot, "skills", "skill-one")
+    expect((await fs.lstat(skillPath)).isSymbolicLink()).toBe(true)
+
+    const content = await fs.readFile(configPath, "utf8")
+    expect(content).toContain("[custom]")
+    expect(content).toContain("[post]")
+    expect(content).not.toContain("[mcp_servers.old]")
+    expect(content).toContain("[mcp_servers.local]")
+    expect(content).toContain("command = \"echo\"")
+    expect(content).toContain("[mcp_servers.remote]")
+    expect(content).toContain("url = \"https://example.com/mcp\"")
+    expect(content).toContain("http_headers")
+    expect(content.match(/# BEGIN compound-plugin Claude Code MCP/g)?.length).toBe(1)
+
+    const perms = (await fs.stat(configPath)).mode & 0o777
+    expect(perms).toBe(0o600)
+  })
+})