runwork 0.5.0 → 0.6.0

package/dist/commands/integrations.js

@@ -9,13 +9,23 @@ const searchCommand = new Command('search')
     .description('Search available integrations from the platform catalog')
     .argument('<query>', 'Search query (e.g., "google drive", "hubspot", "slack")')
     .option('--limit <n>', 'Maximum results to show', '20')
+    .option('--workspace <id>', 'Workspace ID (enables team usage info)')
     .action(async (query, opts, command) => {
     const useJson = shouldOutputJson(command.optsWithGlobals().json);
     const credentials = requireAuth();
     const client = new ApiClient(credentials);
     const limit = parseInt(opts.limit, 10);
     try {
-        const { results } = await client.searchIntegrations(query, limit);
+        // Resolve workspace for enriched search results (connectedByUser, usedByTeammates)
+        let workspaceId;
+        try {
+            const resolved = await resolveWorkspace(client, opts);
+            workspaceId = resolved.workspaceId;
+        }
+        catch {
+            // Workspace not available, search without enrichment
+        }
+        const { results } = await client.searchIntegrations(query, limit, workspaceId);
         if (useJson) {
             const items = results.map(({ provider: _p, ...rest }) => rest);
             jsonOut({ results: items });
@@ -28,7 +38,13 @@ const searchCommand = new Command('search')
         }
         console.log(`Found ${results.length} integration(s) for "${query}":\n`);
         for (const r of results) {
-            console.log(`  ${r.id} - ${r.name} (${r.provider})`);
+            const tags = [];
+            if (r.connectedByUser)
+                tags.push('[connected]');
+            else if (r.usedByTeammates)
+                tags.push('[used by teammates]');
+            const tagStr = tags.length > 0 ? ` ${tags.join(' ')}` : '';
+            console.log(`  ${r.id} - ${r.name} (${r.provider})${tagStr}`);
             if (r.docs) {
                 console.log(`    Base URL: ${r.docs.baseUrl}`);
                 console.log(`    Path format: ${r.docs.pathFormat}`);
@@ -66,26 +82,47 @@ const listCommand = new Command('list')
     const { workspaceId } = await resolveWorkspace(client, opts);
     try {
         const integrations = await client.listConnectedIntegrations(workspaceId);
+        const teamUsage = await client.getTeamIntegrationUsage(workspaceId);
         if (useJson) {
             const items = integrations.map(i => ({
                 id: i.canonicalId || i.integrationId,
                 status: i.status || 'connected',
                 createdAt: i.createdAt || null,
             }));
-            jsonOut({ items });
+            const teamItems = teamUsage
+                .filter(t => !t.connectedByMe && t.userCount > 0)
+                .map(t => ({
+                canonicalId: t.canonicalId,
+                userCount: t.userCount,
+                users: t.users.map(u => u.name),
+            }));
+            jsonOut({ items, teamUsage: teamItems });
             return;
         }
         if (integrations.length === 0) {
             console.log('No integrations connected in this workspace.');
             console.log('Connect integrations at https://runwork.ai/workspace-settings');
-            return;
         }
-        console.log(`Connected integrations (${integrations.length}):\n`);
-        for (const i of integrations) {
-            const id = i.canonicalId || i.integrationId;
-            const status = i.status || 'connected';
-            const date = i.createdAt ? ` (since ${new Date(i.createdAt).toLocaleDateString()})` : '';
-            console.log(`  ${id} - ${i.provider}${date} [${status}]`);
+        else {
+            console.log(`Connected integrations (${integrations.length}):\n`);
+            for (const i of integrations) {
+                const id = i.canonicalId || i.integrationId;
+                const status = i.status || 'connected';
+                const date = i.createdAt ? ` (since ${new Date(i.createdAt).toLocaleDateString()})` : '';
+                console.log(`  ${id} - ${i.provider}${date} [${status}]`);
+            }
+        }
+        const teamOnly = teamUsage.filter(t => !t.connectedByMe && t.userCount > 0);
+        if (teamOnly.length > 0) {
+            console.log(`\nUsed by your team (${teamOnly.length} more):\n`);
+            for (const t of teamOnly) {
+                const names = t.users.map(u => u.name);
+                const display = names.length <= 3
+                    ? names.join(', ')
+                    : `${names.slice(0, 2).join(', ')}, and ${names.length - 2} other${names.length - 2 !== 1 ? 's' : ''}`;
+                console.log(`  ${t.canonicalId} - Used by ${display}`);
+            }
+            console.log(`\n  Connect at https://runwork.ai/workspace-settings?section=integrations`);
         }
     }
     catch (err) {

package/dist/commands/login.js

@@ -1,12 +1,39 @@
 import { Command } from 'commander';
-import { performLogin } from '../auth/login-flow.js';
+import { performLogin, performLoginNoOpen, performLoginFromUrl, performLoginWithApiKey, } from '../auth/login-flow.js';
 import { bold, cyan } from '../ui/colors.js';
 export const loginCommand = new Command('login')
     .description('Authenticate with Runwork platform')
+    .argument('[url]', 'Login URL from a previous --no-open session')
     .option('--base-url <url>', 'Platform URL', 'https://runwork.ai')
-    .action(async (options) => {
-    console.log('Opening browser for authentication...');
+    .option('--no-open', 'Print login URL without opening browser (polls for completion)')
+    .option('--print-only', 'With --no-open: print URL and exit without polling')
+    .option('--api-key <key>', 'Authenticate directly with an API key (for CI)')
+    .action(async (url, options) => {
+    if (!options)
+        return;
+    // Mode 1: Direct API key auth
+    if (options.apiKey) {
+        await performLoginWithApiKey(options.apiKey, options.baseUrl);
+        return;
+    }
+    // Mode 2: Resume from a previously printed URL
+    if (url) {
+        await performLoginFromUrl(url);
+        printNextSteps();
+        return;
+    }
+    // Mode 3: No-open (print URL, optionally poll)
+    if (!options.open) {
+        const result = await performLoginNoOpen(options.baseUrl, options.printOnly);
+        if (result)
+            printNextSteps();
+        return;
+    }
+    // Mode 4: Default browser flow
     await performLogin(options.baseUrl);
+    printNextSteps();
+});
+function printNextSteps() {
     console.log('');
     console.log(bold('What next?'));
     console.log('');
@@ -14,4 +41,4 @@ export const loginCommand = new Command('login')
     console.log(`  ${cyan('runwork clone')}    Clone an existing app`);
     console.log(`  ${cyan('runwork dev')}      Start developing (inside an app directory)`);
     console.log('');
-});
+}

package/dist/commands/mcp.js

@@ -13,26 +13,57 @@ const listCommand = new Command('list')
     const client = new ApiClient(credentials);
     const { workspaceId, workspaceName } = await resolveWorkspace(client, opts);
     try {
-        const servers = await client.listMcpServers(workspaceId);
+        const baseUrl = credentials.baseUrl || 'https://runwork.ai';
+        const [servers, apps] = await Promise.all([
+            client.listMcpServers(workspaceId),
+            client.listApps(workspaceId).catch(() => []),
+        ]);
+        // Build the workspace MCP entry
+        const workspaceMcpUrl = `${baseUrl}/api/workspaces/${workspaceId}/mcp`;
+        // Build per-app MCP entries
+        const appMcpEntries = apps.map(app => ({
+            name: app.name,
+            url: `${baseUrl}/api/workspaces/${workspaceId}/apps/${app.id}/mcp`,
+        }));
         if (useJson) {
-            jsonOut({ servers });
-            return;
-        }
-        if (servers.length === 0) {
-            console.log('No MCP servers configured in this workspace.');
-            console.log('Add one with: runwork mcp add <name> <url>');
+            jsonOut({
+                workspace: { name: 'Workspace', url: workspaceMcpUrl },
+                apps: appMcpEntries,
+                external: servers,
+            });
             return;
         }
         console.log(`\nWorkspace: ${workspaceName || workspaceId}\n`);
-        console.log(`  ${'Name'.padEnd(20)} ${'URL'.padEnd(45)} Status`);
+        // Workspace MCP
+        console.log('  Workspace MCP (all tools across apps)');
         console.log('  ' + '-'.repeat(75));
-        for (const s of servers) {
-            const status = s.enabled
-                ? (s.toolCount ? `connected (${s.toolCount} tools)` : 'enabled')
-                : 'disabled';
-            console.log(`  ${s.name.padEnd(20)} ${s.url.padEnd(45)} ${status}`);
-        }
+        console.log(`  ${workspaceMcpUrl}`);
         console.log('');
+        // App MCPs
+        if (appMcpEntries.length > 0) {
+            console.log('  App MCP Servers (per-app scope)');
+            console.log('  ' + '-'.repeat(75));
+            for (const app of appMcpEntries) {
+                console.log(`  ${app.name.padEnd(20)} ${app.url}`);
+            }
+            console.log('');
+        }
+        // External MCPs
+        if (servers.length > 0) {
+            console.log('  External MCP Servers');
+            console.log('  ' + '-'.repeat(75));
+            for (const s of servers) {
+                const status = s.enabled
+                    ? (s.toolCount ? `connected (${s.toolCount} tools)` : 'enabled')
+                    : 'disabled';
+                console.log(`  ${s.name.padEnd(20)} ${s.url.padEnd(45)} ${status}`);
+            }
+            console.log('');
+        }
+        else {
+            console.log('  No external MCP servers. Add one with: runwork mcp add <name> <url>');
+            console.log('');
+        }
     }
     catch (err) {
         console.error('Failed to list MCP servers:', err instanceof Error ? err.message : err);
@@ -110,8 +141,105 @@ const removeCommand = new Command('remove')
         process.exit(1);
     }
 });
+const searchCommand = new Command('search')
+    .description('Search community MCP servers from the MCP Registry')
+    .argument('<query>', 'Search query')
+    .option('--limit <n>', 'Max results (1-50)', '10')
+    .action(async (query, opts, command) => {
+    const useJson = shouldOutputJson(command.optsWithGlobals().json);
+    const credentials = requireAuth();
+    const client = new ApiClient(credentials);
+    try {
+        const results = await client.searchCommunityMcpServers(query, Number(opts.limit));
+        if (useJson) {
+            jsonOut(results);
+            return;
+        }
+        if (results.servers.length === 0) {
+            console.log(`No remote-capable MCP servers found for "${query}".`);
+            return;
+        }
+        console.log(`\n  ${results.count} remote-capable server${results.count !== 1 ? 's' : ''} for "${query}"\n`);
+        console.log(`  ${'Name'.padEnd(35)} ${'Type'.padEnd(18)} URL`);
+        console.log('  ' + '-'.repeat(90));
+        for (const s of results.servers) {
+            const name = s.title || s.name.split('/').pop() || s.name;
+            const remote = s.remotes[0];
+            const transport = remote ? remote.type : 'N/A';
+            const url = remote ? truncateUrl(remote.url, 40) : 'N/A';
+            console.log(`  ${name.padEnd(35)} ${transport.padEnd(18)} ${url}`);
+        }
+        console.log(`\n  Connect with: runwork mcp install <name>`);
+        console.log('');
+    }
+    catch (err) {
+        console.error('Search failed:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+const installCommand = new Command('install')
+    .description('Install a community MCP server from the MCP Registry into your workspace')
+    .argument('<query>', 'Server name or search query')
+    .option('--workspace <id>', 'Workspace ID')
+    .action(async (query, opts, command) => {
+    const useJson = shouldOutputJson(command.optsWithGlobals().json);
+    const credentials = requireAuth();
+    const client = new ApiClient(credentials);
+    const { workspaceId } = await resolveWorkspace(client, opts);
+    try {
+        const results = await client.searchCommunityMcpServers(query, 5);
+        if (results.servers.length === 0) {
+            console.error(`No remote-capable MCP servers found for "${query}".`);
+            process.exit(1);
+        }
+        // Pick best match (first result)
+        const server = results.servers[0];
+        const remote = server.remotes[0];
+        if (!remote) {
+            console.error(`Server "${server.name}" has no remote endpoint.`);
+            process.exit(1);
+        }
+        if (remote.url.includes('{') && remote.url.includes('}')) {
+            console.error(`Server "${server.name}" requires configuration variables in its URL.`);
+            console.error(`URL template: ${remote.url}`);
+            console.error('Use `runwork mcp add <name> <url>` to add it manually with the correct URL.');
+            process.exit(1);
+        }
+        const displayName = server.title || server.name.split('/').pop() || server.name;
+        if (!opts.yes && !useJson) {
+            console.log(`\n  Found: ${displayName}`);
+            console.log(`  URL:   ${remote.url}`);
+            console.log(`  Type:  ${remote.type}\n`);
+            const confirmed = await promptConfirm(`Connect "${displayName}" to your workspace?`);
+            if (!confirmed)
+                return;
+        }
+        const added = await client.addMcpServer(workspaceId, {
+            name: displayName,
+            url: remote.url,
+            transport: remote.type,
+        });
+        if (useJson) {
+            jsonOut({ server: added, source: server.name });
+            return;
+        }
+        console.log(`Connected "${displayName}" (${remote.url})`);
+        console.log('Run `runwork sync` to update your local agent configs.');
+    }
+    catch (err) {
+        console.error('Install failed:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+function truncateUrl(url, max) {
+    if (url.length <= max)
+        return url;
+    return url.slice(0, max - 3) + '...';
+}
 export const mcpCommand = new Command('mcp')
     .description('Manage workspace MCP servers')
     .addCommand(listCommand)
     .addCommand(addCommand)
-    .addCommand(removeCommand);
+    .addCommand(removeCommand)
+    .addCommand(searchCommand)
+    .addCommand(installCommand);

package/dist/commands/setup.js

@@ -1,5 +1,5 @@
 import { Command } from 'commander';
-import { readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { writeFileSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
 import { requireAuth } from '../auth/store.js';
@@ -7,12 +7,13 @@ import { ApiClient } from '../api/client.js';
 import { resolveWorkspace, hasProjectConfig } from '../workspace/resolve.js';
 import { promptSelect, promptConfirm } from '../utils/prompt.js';
 import { detectAgents, printNoAgentsMessage } from '../agents/detect.js';
-import { RUNWORK_MCP_PREFIX } from '../agents/types.js';
+import { syncFromState } from './sync.js';
 export const setupCommand = new Command('setup')
     .description('Configure local AI agents with workspace skills and MCP servers')
     .option('--workspace <id>', 'Workspace ID')
     .option('--agent <slug>', 'Only configure a specific agent (e.g. claude-code, cursor)')
     .option('--dry-run', 'Show what would be configured without writing files')
+    .option('-y, --yes', 'Skip all prompts, configure all detected agents with user scope')
     .action(async (opts) => {
     const credentials = requireAuth();
     const client = new ApiClient(credentials);
@@ -33,6 +34,14 @@ export const setupCommand = new Command('setup')
             process.exit(1);
         }
     }
+    else if (opts.yes) {
+        // Non-interactive: configure all detected agents
+        console.log('Detected agents:');
+        for (const a of agents) {
+            console.log(`  - ${a.name}`);
+        }
+        console.log('\nConfiguring all agents (--yes).\n');
+    }
     else {
         // Show detected agents and confirm
         console.log('Detected agents:');
@@ -57,7 +66,7 @@ export const setupCommand = new Command('setup')
     }
     // 3. Determine scope
     let scope = 'user';
-    if (hasProjectConfig()) {
+    if (hasProjectConfig() && !opts.yes) {
         const scopeChoices = [
             { label: 'This project only', value: 'project' },
             { label: 'Your user (global)', value: 'user' },
@@ -66,134 +75,50 @@ export const setupCommand = new Command('setup')
         const chosen = await promptSelect('Configure for:', scopeChoices);
         scope = chosen.value;
     }
-    // 4. Fetch workspace data
-    console.log('\nFetching workspace skills and MCP servers...');
-    const [allSkills, mcpServers, externalSkills] = await Promise.all([
-        client.listWorkspaceSkills(workspaceId),
-        client.listMcpServers(workspaceId),
-        client.listExternalSkills(workspaceId),
-    ]);
-    // 5. Build MCP server entries
-    const wsPrefix = workspaceId.substring(0, 8);
-    const mcpEntries = mcpServers
-        .filter(s => s.enabled)
-        .map(s => ({
-        name: `${RUNWORK_MCP_PREFIX}${wsPrefix}-${s.name}`,
-        url: s.url,
-        transport: s.transport,
-        headers: { Authorization: `Bearer ${credentials.apiKey}` },
-    }));
-    // Also add the workspace MCP endpoint itself
-    const baseUrl = credentials.baseUrl || 'https://runwork.ai';
-    mcpEntries.push({
-        name: `${RUNWORK_MCP_PREFIX}${wsPrefix}-workspace`,
-        url: `${baseUrl}/api/workspaces/${workspaceId}/mcp`,
-        transport: 'streamable-http',
-        headers: { Authorization: `Bearer ${credentials.apiKey}` },
-    });
-    // 6. Build skill files — external skills go to all scopes
-    const baseSkillFiles = externalSkills.map(s => ({
-        name: s.name,
-        filename: s.name.toLowerCase().replace(/[^a-z0-9]+/g, '-'),
-        content: s.content,
-        description: s.description,
-    }));
-    // Fetch all app skills for user scope
-    const allAppSkillFiles = [];
-    const appSkillEntries = allSkills.filter(s => s.type === 'app' && s.appId);
-    if (appSkillEntries.length > 0) {
-        console.log(`Fetching skills for ${appSkillEntries.length} app(s)...`);
-        const results = await Promise.all(appSkillEntries.map(async (s) => {
-            try {
-                const content = await client.getAppSkillContent(workspaceId, s.appId);
-                if (content && content.trim()) {
-                    return {
-                        name: s.name,
-                        filename: s.name.toLowerCase().replace(/[^a-z0-9]+/g, '-'),
-                        content,
-                        description: s.description || `App skill for ${s.name}`,
-                    };
-                }
-            }
-            catch { /* skip */ }
-            return null;
-        }));
-        for (const r of results) {
-            if (r)
-                allAppSkillFiles.push(r);
-        }
-    }
-    // For project scope: only the current app's skill
-    let projectAppSkillFile = null;
-    if (hasProjectConfig()) {
-        try {
-            const config = JSON.parse(readFileSync('.runwork.json', 'utf-8'));
-            if (config.appId) {
-                projectAppSkillFile = allAppSkillFiles.find(s => s.filename === (config.appName || '').toLowerCase().replace(/[^a-z0-9]+/g, '-')) || null;
-            }
-        }
-        catch { /* ignore */ }
+    // 4. Get workspace slug
+    let workspaceSlug;
+    try {
+        const workspaces = await client.listWorkspaces();
+        workspaceSlug = workspaces.find(w => w.id === workspaceId)?.slug;
     }
-    // Build scope-specific skill lists
-    const userSkillFiles = [...baseSkillFiles, ...allAppSkillFiles];
-    const projectSkillFiles = projectAppSkillFile
-        ? [...baseSkillFiles, projectAppSkillFile]
-        : [...baseSkillFiles];
-    if (opts.dryRun) {
-        console.log('\n[Dry run] Would configure:\n');
-        console.log(`  MCP servers: ${mcpEntries.length}`);
-        for (const e of mcpEntries)
-            console.log(`    - ${e.name}: ${e.url}`);
-        console.log(`  Skills (user): ${userSkillFiles.length}`);
-        for (const s of userSkillFiles)
-            console.log(`    - ${s.name}`);
-        if (scope === 'project' || scope === 'both') {
-            console.log(`  Skills (project): ${projectSkillFiles.length}`);
-            for (const s of projectSkillFiles)
-                console.log(`    - ${s.name}`);
-        }
-        console.log(`\n  Agents: ${agents.map(a => a.name).join(', ')}`);
-        console.log(`  Scope: ${scope}`);
-        return;
-    }
-    // 7. Write configs
-    const scopes = scope === 'both' ? ['project', 'user'] : [scope];
-    for (const agent of agents) {
-        for (const s of scopes) {
-            const skillFiles = s === 'project' ? projectSkillFiles : userSkillFiles;
-            try {
-                if (agent.supportsMcpScope(s) && mcpEntries.length > 0) {
-                    await agent.writeMcpServers(mcpEntries, s);
-                    console.log(`  [${agent.name}] MCP servers configured (${s})`);
-                }
-                if (agent.supportsSkills() && skillFiles.length > 0) {
-                    await agent.writeSkills(skillFiles, s);
-                    console.log(`  [${agent.name}] Skills written (${s})`);
-                }
-            }
-            catch (err) {
-                console.warn(`  [${agent.name}] Failed (${s}): ${err instanceof Error ? err.message : err}`);
-            }
-        }
-    }
-    // 8. Save setup state
+    catch { /* best-effort */ }
+    // 5. Save setup state (minimal, sync populates the rest)
     const state = {
         workspaceId,
         workspaceName: workspaceName || '',
+        workspaceSlug: workspaceSlug || undefined,
         configuredAgents: agents.map(a => a.slug),
         scope,
-        lastSyncAt: new Date().toISOString(),
-        mcpServers: mcpEntries.map(e => e.name),
-        skills: userSkillFiles.map(s => s.name),
+        lastSyncAt: '',
+        mcpServers: [],
+        skills: [],
+        skillHashes: {},
     };
-    if (scope === 'project' || scope === 'both') {
-        mkdirSync('.runwork', { recursive: true });
-        writeFileSync('.runwork/setup.json', JSON.stringify(state, null, 2));
-    }
-    if (scope === 'user' || scope === 'both') {
-        const dir = join(homedir(), '.runwork');
+    const scopes = scope === 'both' ? ['project', 'user'] : [scope];
+    for (const s of scopes) {
+        const dir = s === 'project' ? '.runwork' : join(homedir(), '.runwork');
         mkdirSync(dir, { recursive: true });
         writeFileSync(join(dir, 'setup.json'), JSON.stringify(state, null, 2));
     }
+    if (opts.dryRun) {
+        console.log('\n[Dry run] Saved setup state. Would sync:\n');
+        console.log(`  Agents: ${agents.map(a => a.name).join(', ')}`);
+        console.log(`  Scope: ${scope}`);
+        console.log('\nRe-run without --dry-run to sync workspace data.');
+        return;
+    }
+    // 6. Delegate all write operations to sync
+    console.log('\nSyncing workspace data...\n');
+    for (const s of scopes) {
+        const statePath = s === 'project'
+            ? join(process.cwd(), '.runwork', 'setup.json')
+            : join(homedir(), '.runwork', 'setup.json');
+        await syncFromState(state, statePath, credentials, {
+            dryRun: false,
+            pullOnly: true,
+            yes: true,
+            prefer: 'remote',
+        });
+    }
     console.log('\nSetup complete. Run `runwork sync` anytime to refresh.');
 });