runwork 0.9.0 → 0.9.1

package/dist/agents/registry-data.js

@@ -0,0 +1,436 @@
+/**
+ * Unified agent registry (types + data + browser-safe lookups).
+ *
+ * This file is the SINGLE SOURCE OF TRUTH for every agent Runwork knows about:
+ * CLI adapters read from here (via `./registry.js`), and the desktop app
+ * re-exports from here (via the `@cli-agent-registry` path alias).
+ *
+ * Keep this file browser-safe: no `os`, `path`, `fs`, or other Node-only
+ * imports. Node-only path resolvers live next to this file in `./registry.ts`.
+ */
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// Registry
+// ---------------------------------------------------------------------------
+const AGENT_REGISTRY = [
+    // === First-class agents (full Runwork support) ===
+    {
+        slug: 'claude-code',
+        name: 'Claude Code',
+        description: "Anthropic's AI coding agent for the terminal",
+        category: 'cli',
+        detection: { method: 'binary', target: 'claude' },
+        launch: { cli: 'claude', cliAcceptsPrompt: true },
+        logo: 'claude',
+        downloadUrl: 'https://docs.anthropic.com/en/docs/claude-code',
+        autoInstallable: true,
+        skillsPaths: { global: '.claude/skills', project: '.claude/skills' },
+        mcpConfigPath: '.claude/settings.json',
+        instructionFile: { global: '.claude/CLAUDE.md', project: '.claude/CLAUDE.md' },
+        mcpConfigKey: 'mcpServers',
+        firstClass: true,
+        quickStart: {
+            launchHint: 'Open your terminal and type `claude`',
+            skillCommand: '/skills',
+            examplePrompts: [
+                'Use /skills to see what your workspace can do',
+                'What integrations does my team have?',
+            ],
+        },
+    },
+    {
+        slug: 'claude-desktop',
+        name: 'Claude Desktop',
+        aliases: ['Claude Desktop (Cowork)', 'Cowork'],
+        description: 'Claude as a desktop application',
+        category: 'desktop',
+        detection: {
+            method: 'any',
+            target: [
+                { method: 'path', target: { macos: '/Applications/Claude.app' } },
+                { method: 'windows-start-app', target: 'Claude' },
+            ],
+        },
+        launch: { app: { macos: 'Claude', windows: 'Claude' } },
+        logo: 'claude',
+        downloadUrl: 'https://claude.ai/download',
+        skillsPaths: { global: '.claude/skills', project: '.claude/skills' },
+        mcpConfigPath: {
+            macos: 'Library/Application Support/Claude/claude_desktop_config.json',
+            windows: 'AppData/Roaming/Claude/claude_desktop_config.json',
+            linux: '.config/Claude/claude_desktop_config.json',
+        },
+        mcpConfigKey: 'mcpServers',
+        firstClass: true,
+        quickStart: {
+            launchHint: 'Open Claude Desktop',
+            examplePrompts: [
+                "What can my team's Runwork workspace do?",
+                "Check my team's recent activity",
+            ],
+        },
+        manualSetup: {
+            // Must run after the `connecting` scene: Scene7Connecting is what
+            // calls `runwork setup`, which writes the setup state that
+            // `runwork build-plugin` reads. Putting this earlier breaks the
+            // Download plugin button for first-time users.
+            title: 'Install Runwork plugin',
+            showAfter: 'connecting',
+            downloadArtifact: {
+                label: 'Download plugin',
+                filename: 'runwork-plugin.zip',
+                command: 'build-plugin',
+            },
+            steps: [
+                { id: 'download', label: 'Click Download plugin above to save runwork-plugin.zip' },
+                { id: 'open', label: "Open Claude Desktop and sign in if you haven't already" },
+                { id: 'cowork', label: 'Go to the Cowork tab (top of the window)' },
+                { id: 'customize', label: 'Click Customize in the sidebar' },
+                { id: 'create-plugin', label: 'Click + next to Personal plugins, then Create plugin, then Upload plugin' },
+                { id: 'pick-file', label: 'Select runwork-plugin.zip' },
+                { id: 'add', label: 'Click Add to confirm' },
+                { id: 'allow-network-go', label: 'Now go back and click your name at the bottom left, click Settings, go to Capabilities' },
+                { id: 'allow-network', label: 'Scroll down and in Domain Allowlist panel, enable "Allow network egress", and then add "runwork.ai" and "*.runwork.ai" under "Additional allowed domains" so Cowork sessions can reach Runwork' },
+            ],
+        },
+    },
+    {
+        slug: 'microsoft-copilot',
+        name: 'Microsoft Copilot',
+        description: 'AI assistant by Microsoft for everyday tasks',
+        category: 'desktop',
+        detection: {
+            method: 'any',
+            target: [
+                { method: 'path', target: { macos: '/Applications/Microsoft Copilot.app' } },
+                { method: 'windows-appx', target: 'Microsoft.Copilot' },
+            ],
+        },
+        launch: { app: { macos: 'Microsoft Copilot', windows: 'Microsoft Copilot' } },
+        logo: 'microsoft-copilot',
+        downloadUrl: 'https://www.microsoft.com/en-us/microsoft-copilot/for-individuals/get-copilot',
+        firstClass: true,
+        quickStart: {
+            launchHint: 'Open Microsoft Copilot',
+            examplePrompts: [
+                'Help me brainstorm ideas for a project',
+                'Summarize this document for me',
+            ],
+        },
+    },
+    {
+        slug: 'microsoft-365-copilot',
+        name: 'Microsoft 365 Copilot',
+        aliases: ['M365 Copilot'],
+        description: 'AI assistant integrated with Microsoft 365 apps',
+        category: 'desktop',
+        detection: {
+            method: 'any',
+            target: [
+                { method: 'path', target: { macos: '/Applications/Microsoft 365 Copilot.app' } },
+                { method: 'windows-appx', target: 'Microsoft.M365Copilot' },
+            ],
+        },
+        launch: { app: { macos: 'Microsoft 365 Copilot', windows: 'Microsoft 365 Copilot' } },
+        logo: 'microsoft-copilot',
+        downloadUrl: 'https://www.microsoft.com/en-us/microsoft-365-copilot/download-copilot-app',
+        firstClass: true,
+        quickStart: {
+            launchHint: 'Open Microsoft 365 Copilot',
+            examplePrompts: [
+                'Help me draft a project status update',
+                'Summarize the latest team emails',
+            ],
+        },
+    },
+    {
+        slug: 'cursor',
+        name: 'Cursor',
+        description: 'Write and edit code with AI built into every keystroke, great for building features faster',
+        category: 'ide',
+        detection: {
+            method: 'any',
+            target: [
+                { method: 'path', target: { macos: '/Applications/Cursor.app' } },
+                { method: 'windows-start-app', target: 'Cursor' },
+            ],
+        },
+        launch: { app: { macos: 'Cursor', windows: 'Cursor' }, cli: 'cursor' },
+        logo: 'cursor',
+        downloadUrl: 'https://cursor.com',
+        skillsPaths: { global: '.cursor/skills', project: '.cursor/skills' },
+        mcpConfigPath: '.cursor/mcp.json',
+        instructionFile: { project: '.cursor/rules/runwork.mdc' },
+        mcpConfigKey: 'mcpServers',
+        skillFormat: 'mdc',
+        firstClass: true,
+        quickStart: {
+            panelHint: 'Press Cmd+L for chat, or click the AI tab in the sidebar',
+            skillCommand: 'Check .cursor/rules/ for workspace skills',
+            examplePrompts: [
+                'Use Runwork tools to check team integrations',
+                'What workspace skills are available?',
+            ],
+        },
+    },
+    {
+        // Codex desktop reads from ~/.codex (same directory as Codex CLI), so
+        // CLI-side sync can install skills and MCP servers for the desktop app
+        // even when the `codex` binary isn't on the user's PATH. Keep the
+        // skillsPaths / instructionFile in lockstep with the `codex` entry.
+        slug: 'codex-app',
+        name: 'Codex',
+        description: 'OpenAI desktop app for coding and agent workflows',
+        category: 'desktop',
+        detection: {
+            method: 'any',
+            target: [
+                { method: 'path', target: { macos: '/Applications/Codex.app' } },
+                { method: 'windows-appx', target: 'OpenAI.Codex' },
+            ],
+        },
+        launch: { app: { macos: 'Codex', windows: 'Codex' } },
+        logo: 'openai',
+        downloadUrl: 'https://openai.com/codex/',
+        skillsPaths: { global: '.codex/skills', project: '.agents/skills' },
+        instructionFile: { global: '.codex/instructions.md', project: 'AGENTS.md' },
+        firstClass: true,
+        quickStart: {
+            launchHint: 'Open Codex',
+            examplePrompts: [
+                'Use my workspace skills and integrations',
+                'Check what tools my team has connected',
+            ],
+        },
+    },
+    {
+        slug: 'codex',
+        name: 'Codex CLI',
+        description: "AI in your terminal by OpenAI, great for coding, debugging, and automating dev tasks",
+        category: 'cli',
+        detection: { method: 'binary', target: 'codex' },
+        launch: { cli: 'codex', cliAcceptsPrompt: true },
+        logo: 'openai',
+        downloadUrl: 'https://github.com/openai/codex',
+        skillsPaths: { global: '.codex/skills', project: '.agents/skills' },
+        instructionFile: { global: '.codex/instructions.md', project: 'AGENTS.md' },
+        firstClass: true,
+        quickStart: {
+            launchHint: 'Open your terminal and type `codex`',
+            skillCommand: 'Check AGENTS.md for workspace skills',
+            examplePrompts: [
+                'Use your skills to check workspace activity',
+                'What integrations does my team use?',
+            ],
+        },
+    },
+    {
+        slug: 'windsurf',
+        name: 'Windsurf',
+        description: 'Write and ship code with AI that understands your full project, built for fast iteration',
+        category: 'ide',
+        detection: {
+            method: 'any',
+            target: [
+                { method: 'binary', target: 'windsurf' },
+                { method: 'path', target: { windows: 'AppData/Local/Programs/Windsurf' } },
+                { method: 'path', target: { windows: 'C:\\Program Files\\Windsurf' } },
+            ],
+        },
+        launch: { app: { macos: 'Windsurf', windows: 'Windsurf' } },
+        logo: 'windsurf',
+        downloadUrl: 'https://windsurf.com',
+        skillsPaths: { global: '.codeium/windsurf/skills', project: '.windsurf/skills' },
+        mcpConfigPath: '.codeium/windsurf/mcp_config.json',
+        instructionFile: { global: '.codeium/windsurf/rules/runwork.md', project: '.windsurf/rules/runwork.md' },
+        mcpConfigKey: 'mcpServers',
+        skillFormat: 'windsurf-md',
+        firstClass: true,
+        quickStart: {
+            panelHint: 'Press Cmd+L to open Cascade',
+            skillCommand: 'Check .windsurf/rules/ for workspace skills',
+            examplePrompts: [
+                'Use Runwork tools to check team data',
+                'What workspace skills do I have?',
+            ],
+        },
+    },
+    {
+        slug: 'gemini',
+        name: 'Gemini CLI',
+        description: 'AI in your terminal by Google, great for coding, research, and working across large codebases',
+        category: 'cli',
+        detection: { method: 'binary', target: 'gemini' },
+        launch: { cli: 'gemini', cliAcceptsPrompt: true },
+        logo: 'gemini',
+        downloadUrl: 'https://github.com/google-gemini/gemini-cli',
+        skillsPaths: { global: '.gemini/skills', project: '.gemini/skills' },
+        mcpConfigPath: '.gemini/settings.json',
+        instructionFile: { global: '.gemini/GEMINI.md', project: 'GEMINI.md' },
+        mcpConfigKey: 'mcpServers',
+        firstClass: true,
+        quickStart: {
+            launchHint: 'Open your terminal and type `gemini`',
+            skillCommand: 'Check GEMINI.md or .gemini/skills/',
+            examplePrompts: [
+                'Use your tools to check workspace activity',
+                'What can my workspace do?',
+            ],
+        },
+    },
+    // === Additional agents with some custom handling ===
+    {
+        slug: 'copilot-vscode',
+        name: 'GitHub Copilot (VS Code)',
+        description: "GitHub's AI pair programmer in VS Code",
+        category: 'extension',
+        detection: { method: 'binary', target: 'code' },
+        launch: { app: { macos: 'Visual Studio Code', windows: 'Code' }, cli: 'code' },
+        logo: 'vscode',
+        downloadUrl: 'https://marketplace.visualstudio.com/items?itemName=GitHub.copilot',
+        skillsPaths: { global: '.copilot/skills', project: '.github/skills' },
+        mcpConfigPath: '.vscode/mcp.json',
+        mcpConfigKey: 'servers',
+    },
+    {
+        slug: 'cline',
+        name: 'Cline',
+        description: 'Autonomous AI coding agent for VS Code',
+        category: 'extension',
+        detection: { method: 'binary', target: 'cline' },
+        launch: { cli: 'cline', cliAcceptsPrompt: true },
+        logo: 'cline',
+        skillsPaths: { global: '.agents/skills', project: '.agents/skills' },
+    },
+    {
+        slug: 'copilot-cli',
+        name: 'GitHub Copilot CLI',
+        description: 'GitHub Copilot in the terminal',
+        category: 'cli',
+        detection: { method: 'binary', target: 'gh' },
+        logo: 'vscode',
+        skillsPaths: { global: '.copilot/skills', project: '.github/skills' },
+        mcpConfigPath: '.copilot/mcp-config.json',
+        mcpConfigKey: 'mcpServers',
+    },
+    // === Community agents (from skillshare targets.yaml) ===
+    { slug: 'antigravity', name: 'Antigravity', aliases: ['Antigravity (Google)'], description: "Google's Antigravity AI agent", category: 'cli', detection: { method: 'binary', target: 'antigravity' }, logo: 'antigravity', skillsPaths: { global: '.gemini/antigravity/skills', project: '.agent/skills' } },
+    { slug: 'amp', name: 'Amp', description: 'AI coding agent by Sourcegraph', category: 'cli', detection: { method: 'binary', target: 'amp' }, skillsPaths: { global: '.config/agents/skills', project: '.agents/skills' } },
+    { slug: 'adal', name: 'AdaL', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'adal' }, skillsPaths: { global: '.adal/skills', project: '.adal/skills' } },
+    { slug: 'astrbot', name: 'AstrBot', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'astrbot' }, skillsPaths: { global: '.astrbot/data/skills', project: 'data/skills' } },
+    { slug: 'augment', name: 'Augment', description: 'AI coding assistant', category: 'ide', detection: { method: 'binary', target: 'augment' }, skillsPaths: { global: '.augment/skills', project: '.augment/skills' } },
+    { slug: 'bob', name: 'Bob', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'bob' }, skillsPaths: { global: '.bob/skills', project: '.bob/skills' } },
+    { slug: 'codebuddy', name: 'CodeBuddy', description: 'AI coding assistant', category: 'cli', detection: { method: 'binary', target: 'codebuddy' }, skillsPaths: { global: '.codebuddy/skills', project: '.codebuddy/skills' } },
+    { slug: 'comate', name: 'Comate', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'comate' }, skillsPaths: { global: '.comate/skills', project: '.comate/skills' } },
+    { slug: 'commandcode', name: 'Command Code', aliases: ['command-code'], description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'commandcode' }, skillsPaths: { global: '.commandcode/skills', project: '.commandcode/skills' } },
+    { slug: 'continue', name: 'Continue', description: 'Open-source AI code assistant', category: 'extension', detection: { method: 'binary', target: 'continue' }, skillsPaths: { global: '.continue/skills', project: '.continue/skills' } },
+    { slug: 'cortex', name: 'Cortex', aliases: ['Cortex (Snowflake)'], description: "Snowflake's AI coding agent", category: 'cli', detection: { method: 'binary', target: 'cortex' }, skillsPaths: { global: '.snowflake/cortex/skills', project: '.cortex/skills' } },
+    { slug: 'crush', name: 'Crush', aliases: ['Crush (Charm)'], description: 'AI agent by Charm', category: 'cli', detection: { method: 'binary', target: 'crush' }, skillsPaths: { global: '.config/crush/skills', project: '.crush/skills' } },
+    { slug: 'deepagents', name: 'Deep Agents', aliases: ['deep-agents'], description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'deepagents' }, skillsPaths: { global: '.deepagents/agent/skills', project: '.deepagents/skills' } },
+    { slug: 'droid', name: 'Droid', aliases: ['Droid (Factory AI)'], description: "Factory AI's coding agent", category: 'cli', detection: { method: 'binary', target: 'droid' }, skillsPaths: { global: '.factory/skills', project: '.factory/skills' } },
+    { slug: 'firebender', name: 'Firebender', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'firebender' }, skillsPaths: { global: '.firebender/skills', project: '.firebender/skills' } },
+    { slug: 'goose', name: 'Goose', description: 'AI coding agent by Block', category: 'cli', detection: { method: 'binary', target: 'goose' }, skillsPaths: { global: '.config/goose/skills', project: '.goose/skills' } },
+    { slug: 'hermes', name: 'Hermes', aliases: ['hermes-agent'], description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'hermes' }, skillsPaths: { global: '.hermes/skills', project: '.hermes/skills' } },
+    { slug: 'iflow', name: 'iFlow CLI', aliases: ['iflow-cli'], description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'iflow' }, skillsPaths: { global: '.iflow/skills', project: '.iflow/skills' } },
+    { slug: 'junie', name: 'Junie', description: 'JetBrains AI coding agent', category: 'ide', detection: { method: 'binary', target: 'junie' }, skillsPaths: { global: '.junie/skills', project: '.junie/skills' } },
+    { slug: 'kilocode', name: 'Kilo Code', aliases: ['kilo'], description: 'AI coding agent', category: 'extension', detection: { method: 'binary', target: 'kilocode' }, skillsPaths: { global: '.kilocode/skills', project: '.kilocode/skills' } },
+    { slug: 'kimi', name: 'Kimi Code CLI', aliases: ['kimi-cli'], description: "Moonshot AI's coding agent", category: 'cli', detection: { method: 'binary', target: 'kimi' }, skillsPaths: { global: '.config/agents/skills', project: '.agents/skills' } },
+    { slug: 'kiro', name: 'Kiro', aliases: ['Kiro CLI', 'kiro-cli'], description: "AWS's AI coding agent", category: 'ide', detection: { method: 'binary', target: 'kiro' }, skillsPaths: { global: '.kiro/skills', project: '.kiro/skills' } },
+    { slug: 'kode', name: 'Kode', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'kode' }, skillsPaths: { global: '.kode/skills', project: '.kode/skills' } },
+    { slug: 'letta', name: 'Letta', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'letta' }, skillsPaths: { global: '.letta/skills', project: '.skills' } },
+    { slug: 'lingma', name: 'Lingma', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'lingma' }, skillsPaths: { global: '.lingma/skills', project: '.lingma/skills' } },
+    { slug: 'mcpjam', name: 'MCPJam', description: 'MCP-based AI agent', category: 'cli', detection: { method: 'binary', target: 'mcpjam' }, skillsPaths: { global: '.mcpjam/skills', project: '.mcpjam/skills' } },
+    { slug: 'mux', name: 'Mux', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'mux' }, skillsPaths: { global: '.mux/skills', project: '.mux/skills' } },
+    { slug: 'neovate', name: 'Neovate', description: 'AI coding agent for Neovim', category: 'extension', detection: { method: 'binary', target: 'neovate' }, skillsPaths: { global: '.neovate/skills', project: '.neovate/skills' } },
+    { slug: 'omp', name: 'Oh My Pi', aliases: ['oh-my-pi'], description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'omp' }, skillsPaths: { global: '.omp/agent/skills', project: '.omp/skills' } },
+    { slug: 'openclaw', name: 'OpenClaw', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'openclaw' }, skillsPaths: { global: '.openclaw/skills', project: 'skills' } },
+    { slug: 'opencode', name: 'OpenCode', description: 'Open-source AI coding agent', category: 'cli', detection: { method: 'binary', target: 'opencode' }, skillsPaths: { global: '.config/opencode/skills', project: '.opencode/skills' } },
+    { slug: 'openhands', name: 'OpenHands', description: 'Open-source AI coding agent', category: 'cli', detection: { method: 'binary', target: 'openhands' }, skillsPaths: { global: '.openhands/skills', project: '.openhands/skills' } },
+    { slug: 'pi', name: 'Pi', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'pi' }, skillsPaths: { global: '.pi/agent/skills', project: '.pi/skills' } },
+    { slug: 'pochi', name: 'Pochi', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'pochi' }, skillsPaths: { global: '.pochi/skills', project: '.pochi/skills' } },
+    { slug: 'purecode', name: 'PureCode AI', aliases: ['purecode-ai'], description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'purecode' }, skillsPaths: { global: '.purecode/skills', project: '.agents/skills' } },
+    { slug: 'qoder', name: 'Qoder', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'qoder' }, skillsPaths: { global: '.qoder/skills', project: '.qoder/skills' } },
+    { slug: 'qwen', name: 'Qwen Code', aliases: ['qwen-code'], description: "Alibaba's AI coding agent", category: 'cli', detection: { method: 'binary', target: 'qwen' }, skillsPaths: { global: '.qwen/skills', project: '.qwen/skills' } },
+    { slug: 'roo', name: 'Roo Code', description: 'AI coding agent', category: 'extension', detection: { method: 'binary', target: 'roo' }, skillsPaths: { global: '.roo/skills', project: '.roo/skills' } },
+    { slug: 'trae', name: 'Trae', description: 'ByteDance AI coding IDE', category: 'ide', detection: { method: 'binary', target: 'trae' }, skillsPaths: { global: '.trae/skills', project: '.trae/skills' } },
+    { slug: 'trae-cn', name: 'Trae CN', description: 'ByteDance AI coding IDE (China)', category: 'ide', detection: { method: 'binary', target: 'trae-cn' }, skillsPaths: { global: '.trae-cn/skills', project: '.trae/skills' } },
+    { slug: 'mistral-vibe', name: 'Mistral Vibe', aliases: ['vibe'], description: "Mistral's AI coding agent", category: 'cli', detection: { method: 'binary', target: 'vibe' }, skillsPaths: { global: '.vibe/skills', project: '.vibe/skills' } },
+    { slug: 'verdent', name: 'Verdent', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'verdent' }, skillsPaths: { global: '.verdent/skills', project: '.verdent/skills' } },
+    { slug: 'warp', name: 'Warp AI', description: 'AI-powered terminal', category: 'cli', detection: { method: 'path', target: { macos: '/Applications/Warp.app', linux: '/usr/bin/warp-terminal' } }, skillsPaths: { global: '.agents/skills', project: '.agents/skills' } },
+    { slug: 'witsy', name: 'Witsy', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'witsy' }, skillsPaths: { global: '.agents/skills', project: '.agents/skills' } },
+    { slug: 'xcode-claude', name: 'Xcode Claude', description: 'Claude integration for Xcode', category: 'extension', detection: { method: 'path', target: { macos: 'Library/Developer/Xcode/CodingAssistant/ClaudeAgentConfig' } }, logo: 'claude', skillsPaths: { global: 'Library/Developer/Xcode/CodingAssistant/ClaudeAgentConfig/skills', project: '.claude/skills' } },
+    { slug: 'xcode-codex', name: 'Xcode Codex', description: 'Codex integration for Xcode', category: 'extension', detection: { method: 'path', target: { macos: 'Library/Developer/Xcode/CodingAssistant/codex' } }, logo: 'openai', skillsPaths: { global: 'Library/Developer/Xcode/CodingAssistant/codex/skills', project: '.codex/skills' } },
+    { slug: 'zencoder', name: 'Zencoder', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'zencoder' }, skillsPaths: { global: '.zencoder/skills', project: '.zencoder/skills' } },
+    { slug: 'replit', name: 'Replit', description: 'AI-powered coding platform', category: 'ide', detection: { method: 'binary', target: 'replit' }, skillsPaths: { global: '.config/agents/skills', project: '.agents/skills' } },
+];
+// ---------------------------------------------------------------------------
+// Indexes
+// ---------------------------------------------------------------------------
+const slugIndex = new Map();
+const nameIndex = new Map();
+for (const agent of AGENT_REGISTRY) {
+    slugIndex.set(agent.slug, agent);
+    nameIndex.set(agent.name, agent);
+    if (agent.aliases) {
+        for (const alias of agent.aliases) {
+            nameIndex.set(alias, agent);
+        }
+    }
+}
+// Custom adapters live in CLI source tree. This list stays manual so the CLI
+// knows which agents to skip when falling back to the generic adapter.
+const CUSTOM_ADAPTER_SLUGS = new Set([
+    'claude-code',
+    'claude-desktop',
+    'cursor',
+    'windsurf',
+    'codex',
+    'codex-app',
+    'cline',
+    'gemini',
+]);
+// ---------------------------------------------------------------------------
+// Public API (browser-safe)
+// ---------------------------------------------------------------------------
+export function getAgent(slug) {
+    return slugIndex.get(slug);
+}
+export function getAgentByName(name) {
+    return nameIndex.get(name);
+}
+export function getAgents() {
+    return AGENT_REGISTRY;
+}
+export function getDetectableAgents() {
+    return AGENT_REGISTRY.filter((a) => a.detection);
+}
+export function getLaunchableAgents() {
+    return AGENT_REGISTRY.filter((a) => a.launch);
+}
+export function getFirstClassAgents() {
+    return AGENT_REGISTRY.filter((a) => a.firstClass);
+}
+export function getAgentsByCategory(category) {
+    return AGENT_REGISTRY.filter((a) => a.category === category);
+}
+export function isCLIAgent(slug) {
+    return getAgent(slug)?.category === 'cli';
+}
+export function isIDEAgent(slug) {
+    return getAgent(slug)?.category === 'ide';
+}
+export function isDesktopAgent(slug) {
+    return getAgent(slug)?.category === 'desktop';
+}
+/** Alias of {@link getAgent} kept for backward compatibility with CLI callers. */
+export const getRegistryAgent = getAgent;
+/** Alias of {@link getAgents} kept for backward compatibility with CLI callers. */
+export const getRegistryAgents = getAgents;
+export function getFirstClassSlugs() {
+    return AGENT_REGISTRY.filter((a) => a.firstClass).map((a) => a.slug);
+}
+export function getCustomAdapterSlugs() {
+    return CUSTOM_ADAPTER_SLUGS;
+}

package/dist/agents/registry.d.ts

@@ -1,53 +1,13 @@
 /**
- * Shared agent registry data.
+ * CLI-side agent registry entry point.
  *
- * Source of truth: packages/runwork-desktop/src/lib/agent-registry.ts
- * When adding new agents, update both files.
- *
- * This is a data-only file -- no platform-specific helpers.
- * The CLI uses Node's process.platform for detection.
+ * The data and browser-safe types / lookups live in `./registry-data.ts` so
+ * that the desktop package can import them without pulling in Node-only
+ * modules. This file keeps the existing public surface for CLI callers by
+ * re-exporting everything from the data module and adding the Node-only path
+ * resolvers used by the generic adapter and `sync` command.
  */
-export type AgentCategory = 'cli' | 'ide' | 'desktop' | 'extension';
-/** Platform-specific string. Plain string = same on all platforms. */
-export type PlatformString = string | {
-    default?: string;
-    macos?: string;
-    windows?: string;
-    linux?: string;
-};
-export interface AgentDetection {
-    method: 'binary' | 'path';
-    target: PlatformString;
-}
-export interface AgentDefinition {
-    slug: string;
-    name: string;
-    aliases?: string[];
-    description: string;
-    category: AgentCategory;
-    detection: AgentDetection;
-    /** Skill file directories relative to $HOME (global) or project root (project) */
-    skillsPaths?: {
-        global?: PlatformString;
-        project?: PlatformString;
-    };
-    /** MCP config file path relative to $HOME */
-    mcpConfigPath?: PlatformString;
-    /** First-class agent = full Runwork support (custom adapter) */
-    firstClass?: boolean;
-    /** Instruction file path relative to $HOME (global) or project root (project) */
-    instructionFile?: {
-        global?: PlatformString;
-        project?: PlatformString;
-    };
-    /** MCP config JSON key where servers are stored (default: 'mcpServers') */
-    mcpConfigKey?: string;
-    /** Skill file format */
-    skillFormat?: 'skill-md' | 'mdc' | 'windsurf-md' | 'gemini-flat';
-}
+export * from './registry-data.js';
+import type { PlatformString } from './registry-data.js';
 export declare function resolvePlatformString(ps: PlatformString): string | undefined;
 export declare function resolveToAbsolute(ps: PlatformString, scope: 'global' | 'project'): string | undefined;
-export declare function getRegistryAgent(slug: string): AgentDefinition | undefined;
-export declare function getRegistryAgents(): AgentDefinition[];
-export declare function getFirstClassSlugs(): string[];
-export declare function getCustomAdapterSlugs(): Set<string>;