runwork 0.8.4 → 0.9.1

package/dist/agents/registry.js

@@ -1,14 +1,17 @@
 /**
- * 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.
  */
 import { platform, homedir } from 'os';
 import { join } from 'path';
+// Re-export types, data, and browser-safe lookups so every existing CLI
+// caller keeps working unchanged (`import { getRegistryAgent, ... } from './registry.js'`).
+export * from './registry-data.js';
 function getNodePlatform() {
     const p = platform();
     if (p === 'darwin')
@@ -31,189 +34,3 @@ export function resolveToAbsolute(ps, scope) {
         ? join(homedir(), resolved)
         : join(process.cwd(), resolved);
 }
-// ---------------------------------------------------------------------------
-// Registry
-// ---------------------------------------------------------------------------
-const AGENT_REGISTRY = [
-    // === First-class agents (have custom adapters in CLI) ===
-    {
-        slug: 'claude-code',
-        name: 'Claude Code',
-        description: "Anthropic's AI coding agent for the terminal",
-        category: 'cli',
-        detection: { method: 'binary', target: 'claude' },
-        skillsPaths: { global: '.claude/skills', project: '.claude/skills' },
-        mcpConfigPath: '.claude/settings.json',
-        instructionFile: { global: '.claude/CLAUDE.md', project: '.claude/CLAUDE.md' },
-        mcpConfigKey: 'mcpServers',
-        firstClass: true,
-    },
-    {
-        slug: 'claude-desktop',
-        name: 'Claude Desktop',
-        aliases: ['Claude Desktop (Cowork)', 'Cowork'],
-        description: 'Claude as a desktop application',
-        category: 'desktop',
-        detection: {
-            method: 'path',
-            target: {
-                macos: 'Library/Application Support/Claude/claude_desktop_config.json',
-                windows: 'AppData/Roaming/Claude/claude_desktop_config.json',
-                linux: '.config/Claude/claude_desktop_config.json',
-            },
-        },
-        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,
-    },
-    {
-        slug: 'cursor',
-        name: 'Cursor',
-        description: 'AI-powered code editor',
-        category: 'ide',
-        detection: { method: 'binary', target: 'cursor' },
-        skillsPaths: { global: '.cursor/skills', project: '.cursor/skills' },
-        mcpConfigPath: '.cursor/mcp.json',
-        instructionFile: { project: '.cursor/rules/runwork.mdc' },
-        mcpConfigKey: 'mcpServers',
-        skillFormat: 'mdc',
-        firstClass: true,
-    },
-    {
-        slug: 'codex',
-        name: 'Codex CLI',
-        description: "OpenAI's AI coding agent for the terminal",
-        category: 'cli',
-        detection: { method: 'binary', target: 'codex' },
-        skillsPaths: { global: '.codex/skills', project: '.agents/skills' },
-        instructionFile: { global: '.codex/instructions.md', project: 'AGENTS.md' },
-        firstClass: true,
-    },
-    {
-        slug: 'windsurf',
-        name: 'Windsurf',
-        description: 'AI-powered code editor by Codeium',
-        category: 'ide',
-        detection: { method: 'binary', target: 'windsurf' },
-        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,
-    },
-    {
-        slug: 'gemini',
-        name: 'Gemini CLI',
-        description: "Google's AI coding agent for the terminal",
-        category: 'cli',
-        detection: { method: 'binary', target: 'gemini' },
-        skillsPaths: { global: '.gemini/skills', project: '.gemini/skills' },
-        mcpConfigPath: '.gemini/settings.json',
-        instructionFile: { global: '.gemini/GEMINI.md', project: 'GEMINI.md' },
-        mcpConfigKey: 'mcpServers',
-        firstClass: true,
-    },
-    // === 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' },
-        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' },
-        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' },
-        skillsPaths: { global: '.copilot/skills', project: '.github/skills' },
-        mcpConfigPath: '.copilot/mcp-config.json',
-        mcpConfigKey: 'mcpServers',
-    },
-    // === Community agents (from skillshare targets.yaml) ===
-    { slug: 'antigravity', name: 'Antigravity', description: "Google's Antigravity AI agent", category: 'cli', detection: { method: 'binary', target: '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', 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', 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', 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', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'deepagents' }, skillsPaths: { global: '.deepagents/agent/skills', project: '.deepagents/skills' } },
-    { slug: 'droid', name: 'Droid', 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', description: 'AI coding agent', category: 'cli', detection: { method: 'binary', target: 'hermes' }, skillsPaths: { global: '.hermes/skills', project: '.hermes/skills' } },
-    { slug: 'iflow', name: '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', description: 'AI coding agent', category: 'extension', detection: { method: 'binary', target: 'kilocode' }, skillsPaths: { global: '.kilocode/skills', project: '.kilocode/skills' } },
-    { slug: 'kimi', name: 'Kimi Code 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', 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', 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', 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', 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: 'mistral-vibe', name: 'Mistral 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: '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' } },
-];
-// ---------------------------------------------------------------------------
-// Index (built once)
-// ---------------------------------------------------------------------------
-const slugIndex = new Map();
-for (const agent of AGENT_REGISTRY) {
-    slugIndex.set(agent.slug, agent);
-}
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-export function getRegistryAgent(slug) {
-    return slugIndex.get(slug);
-}
-export function getRegistryAgents() {
-    return AGENT_REGISTRY;
-}
-export function getFirstClassSlugs() {
-    return AGENT_REGISTRY.filter(a => a.firstClass).map(a => a.slug);
-}
-export function getCustomAdapterSlugs() {
-    return new Set(['claude-code', 'claude-desktop', 'cursor', 'windsurf', 'codex', 'cline', 'gemini']);
-}

package/dist/agents/types.d.ts

@@ -75,6 +75,18 @@ export interface AgentConfigOverride {
     };
     /** Domains to allowlist in the agent's sandbox/network config (e.g. for Cursor CLI sandbox) */
     networkAllowlist?: string[];
+    /**
+     * Minimum permission levels required for Runwork tools to function.
+     * Adapters should only UPGRADE restrictive settings, never downgrade
+     * more permissive ones. Keys are agent-specific config field names,
+     * values are ordered arrays from most restrictive to least, plus
+     * the minimum required value.
+     */
+    minimumPermissions?: Array<{
+        field: string;
+        order: string[];
+        minimum: string;
+    }>;
 }
 export interface AgentUsageStats {
     hasNewActivity: boolean;

package/dist/auth/store.js

@@ -44,7 +44,18 @@ export function clearCredentials() {
 export function requireAuth() {
     const creds = getCredentials();
     if (!creds) {
-        console.error('Not logged in. Run `runwork login` first.');
+        const isTTY = process.stdin.isTTY;
+        if (isTTY) {
+            console.error('Not logged in. Run `runwork login` first.');
+        }
+        else {
+            // Headless / sandbox / AI agent environment: provide actionable guidance
+            console.error('Not logged in. In a sandbox or headless environment, authenticate using one of:\n' +
+                '  1. Call the get_cli_setup MCP tool, then write the returned credentials to ~/.runwork/.credentials\n' +
+                '  2. Set the RUNWORK_API_KEY environment variable\n' +
+                '  3. Run: runwork login --api-key <your-api-key>\n' +
+                '  4. Run: runwork login --no-open --print-only  (prints a URL for browser auth)');
+        }
         process.exit(1);
     }
     return creds;

package/dist/commands/init.js

@@ -107,6 +107,10 @@ export async function runCreateFlow(name, workspaceFlag, options = {}) {
     if (workspaceFlag) {
         workspace = await resolveWorkspace(client, workspaceFlag);
     }
+    else if (creds.defaultWorkspaceId) {
+        // Auto-select default workspace from credentials (set during login/onboarding)
+        workspace = { id: creds.defaultWorkspaceId, name: creds.defaultWorkspaceName || creds.defaultWorkspaceId };
+    }
     else {
         const workspaces = await client.listWorkspaces();
         if (workspaces.length === 0) {

package/dist/commands/sync.js

@@ -5,6 +5,7 @@ import { homedir } from 'os';
 import { requireAuth } from '../auth/store.js';
 import { ApiClient } from '../api/client.js';
 import { getAdapterBySlug } from '../agents/detect.js';
+import { CodexAdapter } from '../agents/codex.js';
 import { RUNWORK_MCP_PREFIX, RUNWORK_WORKSPACE_MCP_NAME } from '../agents/types.js';
 import { collectTelemetryEvents, printTelemetryVerbose, summarizeTelemetryForDryRun, } from './sync-telemetry.js';
 import { generateIntroSkill, generateInstructionHint, buildAppSkillDescription } from '../agents/intro-skill.js';
@@ -360,12 +361,31 @@ export async function syncFromState(state, statePath, credentials, opts) {
         if (!adapter.writeAgentConfig)
             continue;
         try {
-            await adapter.writeAgentConfig({ networkAllowlist: networkDomains }, 'user');
+            await adapter.writeAgentConfig({
+                networkAllowlist: networkDomains,
+                minimumPermissions: [
+                    { field: 'approval_policy', order: ['always', 'untrusted', 'on-request', 'never'], minimum: 'on-request' },
+                    { field: 'sandbox_mode', order: ['full', 'read-only', 'workspace-write', 'off'], minimum: 'workspace-write' },
+                ],
+            }, 'user');
         }
         catch {
             // Best-effort
         }
     }
+    // Register ~/.runwork as a project in the Codex desktop app (best-effort).
+    // Only attempts when Codex adapter is configured and the desktop app is closed.
+    for (const adapter of adapters) {
+        if (adapter instanceof CodexAdapter) {
+            const runworkDir = join(homedir(), '.runwork');
+            const result = adapter.registerDesktopWorkspace(runworkDir, 'Runwork');
+            if (result === 'written') {
+                console.log(`  [${adapter.name}] Registered workspace in Codex desktop app`);
+            }
+            // 'app_running' and 'already_registered' are silently skipped
+            break;
+        }
+    }
     // Update state
     state.lastSyncAt = new Date().toISOString();
     state.mcpServers = mcpEntries.map(e => e.name);

package/dist/generated/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.8.4";
+export declare const VERSION = "0.9.1";

package/dist/generated/version.js

@@ -1,2 +1,2 @@
 // Auto-generated by scripts/embed-types.ts -- do not edit
-export const VERSION = "0.8.4";
+export const VERSION = "0.9.1";

package/dist/utils/which.d.ts

@@ -4,3 +4,11 @@
  * Returns the resolved path on success, null if not found.
  */
 export declare function whichBinary(name: string): string | null;
+/**
+ * Check if a desktop app is currently running by process name.
+ * On macOS: checks for the .app bundle process via pgrep.
+ * On Windows: uses tasklist to find the .exe.
+ * On Linux: uses pgrep for the binary name.
+ * Returns true if the process is found, false otherwise.
+ */
+export declare function isAppRunning(appName: string): boolean;

package/dist/utils/which.js

@@ -16,3 +16,32 @@ export function whichBinary(name) {
         return null;
     }
 }
+/**
+ * Check if a desktop app is currently running by process name.
+ * On macOS: checks for the .app bundle process via pgrep.
+ * On Windows: uses tasklist to find the .exe.
+ * On Linux: uses pgrep for the binary name.
+ * Returns true if the process is found, false otherwise.
+ */
+export function isAppRunning(appName) {
+    try {
+        const os = platform();
+        if (os === 'darwin') {
+            // pgrep -f matches against the full command line, catching Electron apps
+            execFileSync('pgrep', ['-f', `${appName}.app`], { stdio: 'pipe' });
+            return true;
+        }
+        else if (os === 'win32') {
+            const result = execFileSync('tasklist', ['/FI', `IMAGENAME eq ${appName}.exe`, '/NH'], { stdio: 'pipe' }).toString();
+            return result.includes(`${appName}.exe`);
+        }
+        else {
+            execFileSync('pgrep', ['-x', appName.toLowerCase()], { stdio: 'pipe' });
+            return true;
+        }
+    }
+    catch {
+        // pgrep exits non-zero when no processes match
+        return false;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runwork",
-  "version": "0.8.4",
+  "version": "0.9.1",
   "description": "CLI for Runwork: develop, preview, and deploy Runwork apps from your local machine.",
   "license": "UNLICENSED",
   "author": "Runwork <info@runwork.ai> (https://www.runwork.ai)",