@every-env/compound-plugin 0.9.0 → 2.34.2

package/src/targets/windsurf.ts

@@ -0,0 +1,104 @@
+import path from "path"
+import { backupFile, copyDir, ensureDir, pathExists, readJson, writeJsonSecure, writeText } from "../utils/files"
+import { formatFrontmatter } from "../utils/frontmatter"
+import type { WindsurfBundle } from "../types/windsurf"
+import type { TargetScope } from "./index"
+
+/**
+ * Write a WindsurfBundle directly into outputRoot.
+ *
+ * Unlike other target writers, this writer expects outputRoot to be the final
+ * resolved directory — the CLI handles scope-based nesting (global vs workspace).
+ */
+export async function writeWindsurfBundle(outputRoot: string, bundle: WindsurfBundle, scope?: TargetScope): Promise<void> {
+  await ensureDir(outputRoot)
+
+  // Write agent skills (before pass-through copies so pass-through takes precedence on collision)
+  if (bundle.agentSkills.length > 0) {
+    const skillsDir = path.join(outputRoot, "skills")
+    await ensureDir(skillsDir)
+    for (const skill of bundle.agentSkills) {
+      validatePathSafe(skill.name, "agent skill")
+      const destDir = path.join(skillsDir, skill.name)
+
+      const resolvedDest = path.resolve(destDir)
+      if (!resolvedDest.startsWith(path.resolve(skillsDir))) {
+        console.warn(`Warning: Agent skill name "${skill.name}" escapes skills/. Skipping.`)
+        continue
+      }
+
+      await ensureDir(destDir)
+      await writeText(path.join(destDir, "SKILL.md"), skill.content)
+    }
+  }
+
+  // Write command workflows (flat in global_workflows/ for global scope, workflows/ for workspace)
+  if (bundle.commandWorkflows.length > 0) {
+    const workflowsDirName = scope === "global" ? "global_workflows" : "workflows"
+    const workflowsDir = path.join(outputRoot, workflowsDirName)
+    await ensureDir(workflowsDir)
+    for (const workflow of bundle.commandWorkflows) {
+      validatePathSafe(workflow.name, "command workflow")
+      const content = formatWorkflowContent(workflow.name, workflow.description, workflow.body)
+      await writeText(path.join(workflowsDir, `${workflow.name}.md`), content)
+    }
+  }
+
+  // Copy pass-through skill directories (after generated skills so copies overwrite on collision)
+  if (bundle.skillDirs.length > 0) {
+    const skillsDir = path.join(outputRoot, "skills")
+    await ensureDir(skillsDir)
+    for (const skill of bundle.skillDirs) {
+      validatePathSafe(skill.name, "skill directory")
+      const destDir = path.join(skillsDir, skill.name)
+
+      const resolvedDest = path.resolve(destDir)
+      if (!resolvedDest.startsWith(path.resolve(skillsDir))) {
+        console.warn(`Warning: Skill name "${skill.name}" escapes skills/. Skipping.`)
+        continue
+      }
+
+      await copyDir(skill.sourceDir, destDir)
+    }
+  }
+
+  // Merge MCP config
+  if (bundle.mcpConfig) {
+    const mcpPath = path.join(outputRoot, "mcp_config.json")
+    const backupPath = await backupFile(mcpPath)
+    if (backupPath) {
+      console.log(`Backed up existing mcp_config.json to ${backupPath}`)
+    }
+
+    let existingConfig: Record<string, unknown> = {}
+    if (await pathExists(mcpPath)) {
+      try {
+        const parsed = await readJson<unknown>(mcpPath)
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+          existingConfig = parsed as Record<string, unknown>
+        }
+      } catch {
+        console.warn("Warning: existing mcp_config.json could not be parsed and will be replaced.")
+      }
+    }
+
+    const existingServers =
+      existingConfig.mcpServers &&
+      typeof existingConfig.mcpServers === "object" &&
+      !Array.isArray(existingConfig.mcpServers)
+        ? (existingConfig.mcpServers as Record<string, unknown>)
+        : {}
+    const merged = { ...existingConfig, mcpServers: { ...existingServers, ...bundle.mcpConfig.mcpServers } }
+    await writeJsonSecure(mcpPath, merged)
+  }
+}
+
+function validatePathSafe(name: string, label: string): void {
+  if (name.includes("..") || name.includes("/") || name.includes("\\")) {
+    throw new Error(`${label} name contains unsafe path characters: ${name}`)
+  }
+}
+
+function formatWorkflowContent(name: string, description: string, body: string): string {
+  return formatFrontmatter({ description }, `# ${name}\n\n${body}`) + "\n"
+}

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/openclaw.ts

@@ -0,0 +1,52 @@
+export type OpenClawPluginManifest = {
+  id: string
+  name: string
+  kind: "tool"
+  configSchema?: {
+    type: "object"
+    additionalProperties: boolean
+    properties: Record<string, OpenClawConfigProperty>
+    required?: string[]
+  }
+  uiHints?: Record<string, OpenClawUiHint>
+  skills?: string[]
+}
+
+export type OpenClawConfigProperty = {
+  type: string
+  description?: string
+  default?: unknown
+}
+
+export type OpenClawUiHint = {
+  label: string
+  sensitive?: boolean
+  placeholder?: string
+}
+
+export type OpenClawSkillFile = {
+  name: string
+  content: string
+  /** Subdirectory path inside skills/ (e.g. "agent-native-reviewer") */
+  dir: string
+}
+
+export type OpenClawCommandRegistration = {
+  name: string
+  description: string
+  acceptsArgs: boolean
+  /** The prompt body that becomes the command handler response */
+  body: string
+}
+
+export type OpenClawBundle = {
+  manifest: OpenClawPluginManifest
+  packageJson: Record<string, unknown>
+  entryPoint: string
+  skills: OpenClawSkillFile[]
+  /** Skill directories to copy verbatim (original Claude skills with references/) */
+  skillDirCopies: { sourceDir: string; name: string }[]
+  commands: OpenClawCommandRegistration[]
+  /** openclaw.json fragment for MCP servers */
+  openclawConfig?: Record<string, unknown>
+}

package/src/types/opencode.ts

@@ -7,7 +7,6 @@ export type OpenCodeConfig = {
   tools?: Record<string, boolean>
   permission?: Record<string, OpenCodePermission | Record<string, OpenCodePermission>>
   agent?: Record<string, OpenCodeAgentConfig>
-  command?: Record<string, OpenCodeCommandConfig>
   mcp?: Record<string, OpenCodeMcpServer>
 }
 
@@ -20,13 +19,6 @@ export type OpenCodeAgentConfig = {
   permission?: Record<string, OpenCodePermission>
 }
 
-export type OpenCodeCommandConfig = {
-  description?: string
-  model?: string
-  agent?: string
-  template: string
-}
-
 export type OpenCodeMcpServer = {
   type: "local" | "remote"
   command?: string[]
@@ -46,9 +38,16 @@ export type OpenCodePluginFile = {
   content: string
 }
 
+export type OpenCodeCommandFile = {
+  name: string
+  content: string
+}
+
 export type OpenCodeBundle = {
   config: OpenCodeConfig
   agents: OpenCodeAgentFile[]
+  // Commands are written as individual .md files, not in opencode.json. See ADR-001.
+  commandFiles: OpenCodeCommandFile[]
   plugins: OpenCodePluginFile[]
   skillDirs: { sourceDir: string; name: string }[]
 }

package/src/types/qwen.ts

@@ -0,0 +1,51 @@
+export type QwenExtensionConfig = {
+  name: string
+  version: string
+  mcpServers?: Record<string, QwenMcpServer>
+  contextFileName?: string
+  commands?: string
+  skills?: string
+  agents?: string
+  settings?: QwenSetting[]
+}
+
+export type QwenMcpServer = {
+  command?: string
+  args?: string[]
+  env?: Record<string, string>
+  cwd?: string
+  httpUrl?: string
+  url?: string
+  headers?: Record<string, string>
+}
+
+export type QwenSetting = {
+  name: string
+  description: string
+  envVar: string
+  sensitive?: boolean
+}
+
+export type QwenAgentFile = {
+  name: string
+  content: string
+  format: "yaml" | "markdown"
+}
+
+export type QwenSkillDir = {
+  sourceDir: string
+  name: string
+}
+
+export type QwenCommandFile = {
+  name: string
+  content: string
+}
+
+export type QwenBundle = {
+  config: QwenExtensionConfig
+  agents: QwenAgentFile[]
+  commandFiles: QwenCommandFile[]
+  skillDirs: QwenSkillDir[]
+  contextFile?: string
+}

package/src/types/windsurf.ts

@@ -0,0 +1,35 @@
+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
+  url?: 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/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

@@ -0,0 +1,37 @@
+import os from "os"
+import { pathExists } from "./files"
+import { syncTargets } from "../sync/registry"
+
+export type DetectedTool = {
+  name: string
+  detected: boolean
+  reason: string
+}
+
+export async function detectInstalledTools(
+  home: string = os.homedir(),
+  cwd: string = process.cwd(),
+): Promise<DetectedTool[]> {
+  const results: DetectedTool[] = []
+  for (const target of syncTargets) {
+    let detected = false
+    let reason = "not found"
+    for (const p of target.detectPaths(home, cwd)) {
+      if (await pathExists(p)) {
+        detected = true
+        reason = `found ${p}`
+        break
+      }
+    }
+    results.push({ name: target.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

@@ -41,11 +41,25 @@ 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")
 }
 
+/** 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 })
+  await fs.chmod(filePath, 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/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")
+  })
+})