@every-env/compound-plugin 0.8.0 → 0.12.0

package/src/types/windsurf.ts

@@ -0,0 +1,34 @@
+export type WindsurfWorkflow = {
+  name: string
+  description: string
+  body: string
+}
+
+export type WindsurfGeneratedSkill = {
+  name: string
+  content: string
+}
+
+export type WindsurfSkillDir = {
+  name: string
+  sourceDir: string
+}
+
+export type WindsurfMcpServerEntry = {
+  command?: string
+  args?: string[]
+  env?: Record<string, string>
+  serverUrl?: string
+  headers?: Record<string, string>
+}
+
+export type WindsurfMcpConfig = {
+  mcpServers: Record<string, WindsurfMcpServerEntry>
+}
+
+export type WindsurfBundle = {
+  agentSkills: WindsurfGeneratedSkill[]
+  commandWorkflows: WindsurfWorkflow[]
+  skillDirs: WindsurfSkillDir[]
+  mcpConfig: WindsurfMcpConfig | null
+}

package/src/utils/detect-tools.ts

@@ -0,0 +1,46 @@
+import os from "os"
+import path from "path"
+import { pathExists } from "./files"
+
+export type DetectedTool = {
+  name: string
+  detected: boolean
+  reason: string
+}
+
+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) {
+    let detected = false
+    let reason = "not found"
+    for (const p of check.paths) {
+      if (await pathExists(p)) {
+        detected = true
+        reason = `found ${p}`
+        break
+      }
+    }
+    results.push({ name: check.name, detected, reason })
+  }
+  return results
+}
+
+export async function getDetectedTargetNames(
+  home: string = os.homedir(),
+  cwd: string = process.cwd(),
+): Promise<string[]> {
+  const tools = await detectInstalledTools(home, cwd)
+  return tools.filter((t) => t.detected).map((t) => t.name)
+}

package/src/utils/files.ts

@@ -46,6 +46,13 @@ export async function writeJson(filePath: string, data: unknown): Promise<void>
   await writeText(filePath, content + "\n")
 }
 
+/** Write JSON with restrictive permissions (0o600) for files containing secrets */
+export async function writeJsonSecure(filePath: string, data: unknown): Promise<void> {
+  const content = JSON.stringify(data, null, 2)
+  await ensureDir(path.dirname(filePath))
+  await fs.writeFile(filePath, content + "\n", { encoding: "utf8", mode: 0o600 })
+}
+
 export async function walkFiles(root: string): Promise<string[]> {
   const entries = await fs.readdir(root, { withFileTypes: true })
   const results: string[] = []

package/src/utils/resolve-output.ts

@@ -0,0 +1,50 @@
+import os from "os"
+import path from "path"
+import type { TargetScope } from "../targets"
+
+export function resolveTargetOutputRoot(options: {
+  targetName: string
+  outputRoot: string
+  codexHome: string
+  piHome: string
+  openclawHome?: string
+  qwenHome?: string
+  pluginName?: string
+  hasExplicitOutput: boolean
+  scope?: TargetScope
+}): string {
+  const { targetName, outputRoot, codexHome, piHome, openclawHome, qwenHome, pluginName, hasExplicitOutput, scope } = options
+  if (targetName === "codex") return codexHome
+  if (targetName === "pi") return piHome
+  if (targetName === "droid") return path.join(os.homedir(), ".factory")
+  if (targetName === "cursor") {
+    const base = hasExplicitOutput ? outputRoot : process.cwd()
+    return path.join(base, ".cursor")
+  }
+  if (targetName === "gemini") {
+    const base = hasExplicitOutput ? outputRoot : process.cwd()
+    return path.join(base, ".gemini")
+  }
+  if (targetName === "copilot") {
+    const base = hasExplicitOutput ? outputRoot : process.cwd()
+    return path.join(base, ".github")
+  }
+  if (targetName === "kiro") {
+    const base = hasExplicitOutput ? outputRoot : process.cwd()
+    return path.join(base, ".kiro")
+  }
+  if (targetName === "windsurf") {
+    if (hasExplicitOutput) return outputRoot
+    if (scope === "global") return path.join(os.homedir(), ".codeium", "windsurf")
+    return path.join(process.cwd(), ".windsurf")
+  }
+  if (targetName === "openclaw") {
+    const home = openclawHome ?? path.join(os.homedir(), ".openclaw", "extensions")
+    return path.join(home, pluginName ?? "plugin")
+  }
+  if (targetName === "qwen") {
+    const home = qwenHome ?? path.join(os.homedir(), ".qwen", "extensions")
+    return path.join(home, pluginName ?? "plugin")
+  }
+  return outputRoot
+}

package/src/utils/secrets.ts

@@ -0,0 +1,24 @@
+export const SENSITIVE_PATTERN = /key|token|secret|password|credential|api_key/i
+
+/** Check if any MCP servers have env vars that might contain secrets */
+export function hasPotentialSecrets(
+  servers: Record<string, { env?: Record<string, string> }>,
+): boolean {
+  for (const server of Object.values(servers)) {
+    if (server.env) {
+      for (const key of Object.keys(server.env)) {
+        if (SENSITIVE_PATTERN.test(key)) return true
+      }
+    }
+  }
+  return false
+}
+
+/** Return names of MCP servers whose env vars may contain secrets */
+export function findServersWithPotentialSecrets(
+  servers: Record<string, { env?: Record<string, string> }>,
+): string[] {
+  return Object.entries(servers)
+    .filter(([, s]) => s.env && Object.keys(s.env).some((k) => SENSITIVE_PATTERN.test(k)))
+    .map(([name]) => name)
+}

package/tests/cli.test.ts

@@ -426,4 +426,82 @@ describe("CLI", () => {
     expect(await exists(path.join(piRoot, "prompts", "workflows-review.md"))).toBe(true)
     expect(await exists(path.join(piRoot, "extensions", "compound-engineering-compat.ts"))).toBe(true)
   })
+
+  test("install --to opencode uses permissions:none by default", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "cli-perms-none-"))
+    const fixtureRoot = path.join(import.meta.dir, "fixtures", "sample-plugin")
+
+    const proc = Bun.spawn([
+      "bun",
+      "run",
+      "src/index.ts",
+      "install",
+      fixtureRoot,
+      "--to",
+      "opencode",
+      "--output",
+      tempRoot,
+    ], {
+      cwd: path.join(import.meta.dir, ".."),
+      stdout: "pipe",
+      stderr: "pipe",
+    })
+
+    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("Installed compound-engineering")
+
+    const opencodeJsonPath = path.join(tempRoot, "opencode.json")
+    const content = await fs.readFile(opencodeJsonPath, "utf-8")
+    const json = JSON.parse(content)
+
+    expect(json).not.toHaveProperty("permission")
+    expect(json).not.toHaveProperty("tools")
+  })
+
+  test("install --to opencode --permissions broad writes permission block", async () => {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "cli-perms-broad-"))
+    const fixtureRoot = path.join(import.meta.dir, "fixtures", "sample-plugin")
+
+    const proc = Bun.spawn([
+      "bun",
+      "run",
+      "src/index.ts",
+      "install",
+      fixtureRoot,
+      "--to",
+      "opencode",
+      "--permissions",
+      "broad",
+      "--output",
+      tempRoot,
+    ], {
+      cwd: path.join(import.meta.dir, ".."),
+      stdout: "pipe",
+      stderr: "pipe",
+    })
+
+    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("Installed compound-engineering")
+
+    const opencodeJsonPath = path.join(tempRoot, "opencode.json")
+    const content = await fs.readFile(opencodeJsonPath, "utf-8")
+    const json = JSON.parse(content)
+
+    expect(json).toHaveProperty("permission")
+    expect(json.permission).not.toBeNull()
+  })
 })

package/tests/converter.test.ts

@@ -8,7 +8,7 @@ import type { ClaudePlugin } from "../src/types/claude"
 const fixtureRoot = path.join(import.meta.dir, "fixtures", "sample-plugin")
 
 describe("convertClaudeToOpenCode", () => {
-  test("maps commands, permissions, and agents", async () => {
+  test("from-command mode: map allowedTools to global permission block", async () => {
     const plugin = await loadClaudePlugin(fixtureRoot)
     const bundle = convertClaudeToOpenCode(plugin, {
       agentMode: "subagent",
@@ -16,8 +16,9 @@ describe("convertClaudeToOpenCode", () => {
       permissions: "from-commands",
     })
 
-    expect(bundle.config.command?.["workflows:review"]).toBeDefined()
-    expect(bundle.config.command?.["plan_review"]).toBeDefined()
+    expect(bundle.config.command).toBeUndefined()
+    expect(bundle.commandFiles.find((f) => f.name === "workflows:review")).toBeDefined()
+    expect(bundle.commandFiles.find((f) => f.name === "plan_review")).toBeDefined()
 
     const permission = bundle.config.permission as Record<string, string | Record<string, string>>
     expect(Object.keys(permission).sort()).toEqual([
@@ -71,8 +72,10 @@ describe("convertClaudeToOpenCode", () => {
     expect(parsed.data.model).toBe("anthropic/claude-sonnet-4-20250514")
     expect(parsed.data.temperature).toBe(0.1)
 
-    const modelCommand = bundle.config.command?.["workflows:work"]
-    expect(modelCommand?.model).toBe("openai/gpt-4o")
+    const modelCommand = bundle.commandFiles.find((f) => f.name === "workflows:work")
+    expect(modelCommand).toBeDefined()
+    const commandParsed = parseFrontmatter(modelCommand!.content)
+    expect(commandParsed.data.model).toBe("openai/gpt-4o")
   })
 
   test("resolves bare Claude model aliases to full IDs", () => {
@@ -199,7 +202,7 @@ describe("convertClaudeToOpenCode", () => {
     expect(parsed.data.mode).toBe("primary")
   })
 
-  test("excludes commands with disable-model-invocation from command map", async () => {
+  test("excludes commands with disable-model-invocation from commandFiles", async () => {
     const plugin = await loadClaudePlugin(fixtureRoot)
     const bundle = convertClaudeToOpenCode(plugin, {
       agentMode: "subagent",
@@ -208,10 +211,10 @@ describe("convertClaudeToOpenCode", () => {
     })
 
     // deploy-docs has disable-model-invocation: true, should be excluded
-    expect(bundle.config.command?.["deploy-docs"]).toBeUndefined()
+    expect(bundle.commandFiles.find((f) => f.name === "deploy-docs")).toBeUndefined()
 
     // Normal commands should still be present
-    expect(bundle.config.command?.["workflows:review"]).toBeDefined()
+    expect(bundle.commandFiles.find((f) => f.name === "workflows:review")).toBeDefined()
   })
 
   test("rewrites .claude/ paths to .opencode/ in command bodies", () => {
@@ -240,10 +243,11 @@ Run \`/compound-engineering-setup\` to create a settings file.`,
       permissions: "none",
     })
 
-    const template = bundle.config.command?.["review"]?.template ?? ""
+    const commandFile = bundle.commandFiles.find((f) => f.name === "review")
+    expect(commandFile).toBeDefined()
 
     // Tool-agnostic path in project root — no rewriting needed
-    expect(template).toContain("compound-engineering.local.md")
+    expect(commandFile!.content).toContain("compound-engineering.local.md")
   })
 
   test("rewrites .claude/ paths in agent bodies", () => {
@@ -273,4 +277,33 @@ Run \`/compound-engineering-setup\` to create a settings file.`,
     // Tool-agnostic path in project root — no rewriting needed
     expect(agentFile!.content).toContain("compound-engineering.local.md")
   })
+
+  test("command .md files include description in frontmatter", () => {
+    const plugin: ClaudePlugin = {
+      root: "/tmp/plugin",
+      manifest: { name: "fixture", version: "1.0.0" },
+      agents: [],
+      commands: [
+        {
+          name: "test-cmd",
+          description: "Test description",
+          body: "Do the thing",
+          sourcePath: "/tmp/plugin/commands/test-cmd.md",
+        },
+      ],
+      skills: [],
+    }
+
+    const bundle = convertClaudeToOpenCode(plugin, {
+      agentMode: "subagent",
+      inferTemperature: false,
+      permissions: "none",
+    })
+
+    const commandFile = bundle.commandFiles.find((f) => f.name === "test-cmd")
+    expect(commandFile).toBeDefined()
+    const parsed = parseFrontmatter(commandFile!.content)
+    expect(parsed.data.description).toBe("Test description")
+    expect(parsed.body).toContain("Do the thing")
+  })
 })

package/tests/detect-tools.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, test } from "bun:test"
+import { promises as fs } from "fs"
+import path from "path"
+import os from "os"
+import { detectInstalledTools, getDetectedTargetNames } from "../src/utils/detect-tools"
+
+describe("detectInstalledTools", () => {
+  test("detects tools when config directories exist", async () => {
+    const tempHome = await fs.mkdtemp(path.join(os.tmpdir(), "detect-tools-"))
+    const tempCwd = await fs.mkdtemp(path.join(os.tmpdir(), "detect-tools-cwd-"))
+
+    // 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 })
+
+    const results = await detectInstalledTools(tempHome, tempCwd)
+
+    const codex = results.find((t) => t.name === "codex")
+    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 gemini = results.find((t) => t.name === "gemini")
+    expect(gemini?.detected).toBe(true)
+    expect(gemini?.reason).toContain(".gemini")
+
+    // Tools without directories should not be detected
+    const opencode = results.find((t) => t.name === "opencode")
+    expect(opencode?.detected).toBe(false)
+
+    const droid = results.find((t) => t.name === "droid")
+    expect(droid?.detected).toBe(false)
+
+    const pi = results.find((t) => t.name === "pi")
+    expect(pi?.detected).toBe(false)
+  })
+
+  test("returns all tools with detected=false when no directories exist", async () => {
+    const tempHome = await fs.mkdtemp(path.join(os.tmpdir(), "detect-empty-"))
+    const tempCwd = await fs.mkdtemp(path.join(os.tmpdir(), "detect-empty-cwd-"))
+
+    const results = await detectInstalledTools(tempHome, tempCwd)
+
+    expect(results.length).toBe(6)
+    for (const tool of results) {
+      expect(tool.detected).toBe(false)
+      expect(tool.reason).toBe("not found")
+    }
+  })
+
+  test("detects home-based tools", async () => {
+    const tempHome = await fs.mkdtemp(path.join(os.tmpdir(), "detect-home-"))
+    const tempCwd = await fs.mkdtemp(path.join(os.tmpdir(), "detect-home-cwd-"))
+
+    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 })
+
+    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)
+  })
+})
+
+describe("getDetectedTargetNames", () => {
+  test("returns only names of detected tools", async () => {
+    const tempHome = await fs.mkdtemp(path.join(os.tmpdir(), "detect-names-"))
+    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 })
+
+    const names = await getDetectedTargetNames(tempHome, tempCwd)
+
+    expect(names).toContain("codex")
+    expect(names).toContain("gemini")
+    expect(names).not.toContain("opencode")
+    expect(names).not.toContain("droid")
+    expect(names).not.toContain("pi")
+    expect(names).not.toContain("cursor")
+  })
+
+  test("returns empty array when nothing detected", async () => {
+    const tempHome = await fs.mkdtemp(path.join(os.tmpdir(), "detect-none-"))
+    const tempCwd = await fs.mkdtemp(path.join(os.tmpdir(), "detect-none-cwd-"))
+
+    const names = await getDetectedTargetNames(tempHome, tempCwd)
+    expect(names).toEqual([])
+  })
+})