runwork 0.4.0 → 0.5.0

package/dist/commands/info.js

@@ -2,16 +2,21 @@ import { Command } from 'commander';
 import { readFileSync, existsSync } from 'fs';
 import { join } from 'path';
 import { shouldOutputJson, jsonOut } from '../utils/output.js';
+import { fetchAppInfo } from '../utils/app-info.js';
 import { bold, cyan, dim, green, yellow, gray } from '../ui/colors.js';
 import { VERSION } from '../generated/version.js';
 import { requireAuth } from '../auth/store.js';
 import { ApiClient } from '../api/client.js';
-function readConfig() {
-    if (!existsSync('.runwork.json')) {
-        console.error('No .runwork.json found. Run `runwork init` first.');
-        process.exit(1);
+import { resolveWorkspace } from '../workspace/resolve.js';
+function tryReadConfig() {
+    if (!existsSync('.runwork.json'))
+        return null;
+    try {
+        return JSON.parse(readFileSync('.runwork.json', 'utf-8'));
+    }
+    catch {
+        return null;
     }
-    return JSON.parse(readFileSync('.runwork.json', 'utf-8'));
 }
 function readBlueprint(cwd) {
     const blueprintPath = join(cwd, 'blueprint.json');
@@ -153,97 +158,19 @@ function buildRegistries(blueprint, serverData, appId) {
     };
     return { entities, workflows, scheduledJobs, agents, publicEndpoints, components, fileStorage };
 }
-const CLI_COMMANDS = [
-    {
-        name: 'info',
-        description: 'Show app context, registries, integrations, and CLI reference',
-        usage: 'runwork info [--json]',
-        examples: [
-            'runwork info --json',
-            "runwork info --json | jq '.registries.entities'",
-            "runwork info --json | jq '.preview.url'",
-        ],
-    },
-    {
-        name: 'dev',
-        description: 'Start local development with live sync, preview sandbox, and file watching',
-        usage: 'runwork dev [--json] [--no-logs]',
-        examples: ['runwork dev', 'runwork dev --json'],
-    },
-    {
-        name: 'deploy',
-        description: 'Deploy the current app to production',
-        usage: 'runwork deploy [--json]',
-        examples: ['runwork deploy', 'runwork deploy --json'],
-    },
-    {
-        name: 'logs',
-        description: 'View app logs and events from preview or production',
-        usage: 'runwork logs [--json] [--events] [--production] [--follow] [--type <type>] [--search <text>]',
-        examples: [
-            'runwork logs --json',
-            'runwork logs --events --json',
-            'runwork logs --events --type failed --json',
-            'runwork logs --production --json',
-            'runwork logs --follow --json',
-        ],
-    },
-    {
-        name: 'open',
-        description: 'Open preview URL or dashboard in browser. In JSON mode, outputs the URL without opening the browser.',
-        usage: 'runwork open [preview|dashboard] [--json]',
-        examples: ['runwork open', 'runwork open dashboard', 'runwork open --json'],
-    },
-    {
-        name: 'integrations search',
-        description: 'Search available integrations from the platform catalog (3200+ integrations)',
-        usage: 'runwork integrations search <query> [--json] [--limit <n>]',
-        examples: [
-            'runwork integrations search stripe --json',
-            "runwork integrations search 'google drive' --json --limit 5",
-        ],
-    },
-    {
-        name: 'integrations list',
-        description: 'Show integrations connected to the current workspace',
-        usage: 'runwork integrations list [--json]',
-        examples: ['runwork integrations list --json'],
-    },
-    {
-        name: 'login',
-        description: 'Authenticate with Runwork platform (interactive -- requires browser)',
-        usage: 'runwork login [--base-url <url>]',
-        examples: ['runwork login'],
-        note: 'Not available in JSON mode -- requires interactive browser OAuth flow',
-    },
-    {
-        name: 'init',
-        description: 'Initialize a new Runwork app (interactive)',
-        usage: 'runwork init [name]',
-        examples: ['runwork init my-app'],
-        note: 'Requires interactive prompts for workspace selection. Provide app name as argument to reduce prompts.',
-    },
-    {
-        name: 'clone',
-        description: 'Clone an existing Runwork app to a local directory for development',
-        usage: 'runwork clone [appId] [directory]',
-        examples: ['runwork clone abc-123 ./my-app'],
-        note: 'Provide appId argument to skip interactive selection',
-    },
-    {
-        name: 'upgrade',
-        description: 'Upgrade Runwork CLI to the latest version. Use --check to see if an update is available without installing.',
-        usage: 'runwork upgrade [--check]',
-        examples: ['runwork upgrade', 'runwork upgrade --check'],
-    },
-    {
-        name: 'logout',
-        description: 'Remove stored credentials and git credential configuration',
-        usage: 'runwork logout',
-        examples: ['runwork logout'],
-    },
-];
-function formatSources(sources) {
+function getCliCommands(command) {
+    const program = command.parent;
+    if (!program)
+        return [];
+    return program.commands
+        .filter(cmd => !cmd._hidden)
+        .map(cmd => {
+        const aliases = cmd.aliases();
+        const name = aliases.length > 0 ? `${cmd.name()}|${aliases.join('|')}` : cmd.name();
+        return { name, description: cmd.description() };
+    });
+}
+export function formatSources(sources) {
     return sources
         .map(s => {
         if (s === 'blueprint')
@@ -257,19 +184,22 @@ function formatSources(sources) {
         .join(dim(', '));
 }
 function printHumanOutput(data) {
-    console.log('');
-    console.log(bold('Runwork App Info'));
     console.log('');
     const pad = (label) => label.padEnd(12);
-    console.log(`  ${dim(pad('App:'))}${bold(data.app.name)}`);
     console.log(`  ${dim(pad('Workspace:'))}${data.workspace.name || data.workspace.id}`);
-    if (data.preview.url) {
-        console.log(`  ${dim(pad('Preview:'))}${green(data.preview.url)} ${dim('(running)')}`);
-    }
-    else {
-        console.log(`  ${dim(pad('Preview:'))}${dim('(not running)')}`);
+    if (data.app) {
+        console.log('');
+        console.log(bold('App Info'));
+        console.log('');
+        console.log(`  ${dim(pad('App:'))}${bold(data.app.name)}`);
+        if (data.preview.url) {
+            console.log(`  ${dim(pad('Preview:'))}${green(data.preview.url)} ${dim('(running)')}`);
+        }
+        else {
+            console.log(`  ${dim(pad('Preview:'))}${dim('(not running)')}`);
+        }
+        console.log(`  ${dim(pad('Production:'))}${dim('(not available)')}`);
     }
-    console.log(`  ${dim(pad('Production:'))}${dim('(not available)')}`);
     console.log('');
     // Integrations
     if (data.integrations === null) {
@@ -368,25 +298,39 @@ export const infoCommand = new Command('info')
     .description('Show app context, registries, and CLI reference (use --json for agent discovery)')
     .action(async (_opts, command) => {
     const asJson = shouldOutputJson(command.optsWithGlobals().json);
-    const config = readConfig();
-    const blueprint = readBlueprint(process.cwd());
     const creds = requireAuth();
     const client = new ApiClient(creds);
-    // Preview status -- read-only, never starts a session
-    let preview = { url: null, active: false };
-    try {
-        const status = await client.getDevStatus(config.appId);
-        if (status.previewUrl) {
-            preview = { url: status.previewUrl, active: true };
-        }
+    // Try to read project config, but don't require it
+    const config = tryReadConfig();
+    const blueprint = config ? readBlueprint(process.cwd()) : null;
+    // Resolve workspace: project config > --workspace > default > prompt
+    let workspaceId;
+    let workspaceName;
+    if (config) {
+        workspaceId = config.workspaceId;
+        workspaceName = config.workspaceName ?? config.workspaceId;
     }
-    catch {
-        // No active session -- that's fine
+    else {
+        const resolved = await resolveWorkspace(client, {});
+        workspaceId = resolved.workspaceId;
+        workspaceName = resolved.workspaceName || resolved.workspaceId;
     }
+    const appId = config?.appId;
+    const appName = config?.appName;
+    // App-specific info (preview, dashboard, git remote, server registries)
+    const appInfo = appId ? await fetchAppInfo(client, {
+        appId,
+        appName: appName ?? '',
+        appSlug: appName ?? '',
+        workspaceId,
+        workspaceName,
+        baseUrl: creds.baseUrl || 'https://runwork.ai',
+    }) : null;
+    const preview = appInfo?.preview ?? { url: null, active: false };
     // Integrations
     let integrations = null;
     try {
-        const raw = await client.listConnectedIntegrations(config.workspaceId);
+        const raw = await client.listConnectedIntegrations(workspaceId);
         integrations = raw.map(i => ({
             id: i.canonicalId ?? i.integrationId,
             status: i.status ?? 'connected',
@@ -398,21 +342,21 @@ export const infoCommand = new Command('info')
     // Workspace registries
     let serverData = null;
     try {
-        serverData = await client.getWorkspaceAll(config.workspaceId);
+        serverData = await client.getWorkspaceAll(workspaceId);
     }
     catch {
         process.stderr.write('Warning: failed to fetch workspace registries\n');
     }
-    const registries = buildRegistries(blueprint, serverData, config.appId);
+    const registries = buildRegistries(blueprint, serverData, appId ?? '');
     const output = {
-        app: {
-            id: config.appId,
-            name: config.appName,
-            slug: config.appName,
-        },
+        app: appId ? {
+            id: appId,
+            name: appName ?? '',
+            slug: appName ?? '',
+        } : null,
         workspace: {
-            id: config.workspaceId,
-            name: config.workspaceName ?? config.workspaceId,
+            id: workspaceId,
+            name: workspaceName,
         },
         preview,
         production: { url: null, deployed: false },
@@ -420,7 +364,7 @@ export const infoCommand = new Command('info')
         registries,
         cli: {
             version: VERSION,
-            commands: CLI_COMMANDS,
+            commands: getCliCommands(command),
         },
     };
     if (asJson) {

package/dist/commands/init.d.ts

@@ -2,4 +2,6 @@ import { Command } from 'commander';
 import { ApiClient } from '../api/client.js';
 import type { WorkspaceInfo } from '../types.js';
 export declare function execInit(client: ApiClient, appName: string, workspace: WorkspaceInfo): Promise<string>;
+/** Full create flow: prompt for name/workspace, init, and run agent wizard */
+export declare function runCreateFlow(name?: string): Promise<void>;
 export declare const initCommand: Command;

package/dist/commands/init.js

@@ -66,13 +66,10 @@ export async function execInit(client, appName, workspace) {
     }
     execFileSync('git', ['push', '-u', 'runwork', 'main'], { cwd: dir, stdio: 'inherit' });
     console.log(`\nApp "${app.name}" initialized in ${dir}/`);
-    console.log(`Remote: ${remoteUrl}`);
     return resolve(dir);
 }
-export const initCommand = new Command('init')
-    .description('Initialize a new Runwork app')
-    .argument('[name]', 'App name')
-    .action(async (name) => {
+/** Full create flow: prompt for name/workspace, init, and run agent wizard */
+export async function runCreateFlow(name) {
     const creds = requireAuth();
     const client = new ApiClient(creds);
     const appName = name || await promptInput('App name');
@@ -87,9 +84,14 @@ export const initCommand = new Command('init')
     }
     const workspaceChoice = await promptSelect('Select workspace:', workspaces.map(w => ({ label: w.name, value: w })));
     const workspace = workspaceChoice.value;
-    console.log(`Initializing "${appName}" in workspace "${workspace.name}"...`);
+    console.log(`Creating "${appName}" in workspace "${workspace.name}"...`);
     const dir = await execInit(client, appName, workspace);
-    const slug = dir.split('/').pop() || dir;
     await runAgentWizard(dir);
-    console.log(`Next: cd ${slug} && runwork dev`);
+}
+export const initCommand = new Command('init')
+    .alias('create')
+    .description('Create a new Runwork app')
+    .argument('[name]', 'App name')
+    .action(async (name) => {
+    await runCreateFlow(name);
 });

package/dist/commands/integrations.js

@@ -1,15 +1,10 @@
 import { Command } from 'commander';
+import { readFileSync, existsSync } from 'fs';
 import { requireAuth } from '../auth/store.js';
 import { ApiClient } from '../api/client.js';
-import { readFileSync, existsSync } from 'fs';
 import { shouldOutputJson, jsonOut } from '../utils/output.js';
-function readConfig() {
-    if (!existsSync('.runwork.json')) {
-        console.error('No .runwork.json found. Run `runwork init` first.');
-        process.exit(1);
-    }
-    return JSON.parse(readFileSync('.runwork.json', 'utf-8'));
-}
+import { resolveWorkspace } from '../workspace/resolve.js';
+import { parseCurlToRequest } from '../utils/curl-parser.js';
 const searchCommand = new Command('search')
     .description('Search available integrations from the platform catalog')
     .argument('<query>', 'Search query (e.g., "google drive", "hubspot", "slack")')
@@ -63,13 +58,14 @@ const searchCommand = new Command('search')
 });
 const listCommand = new Command('list')
     .description('List connected workspace integrations')
-    .action(async (_opts, command) => {
+    .option('--workspace <id>', 'Workspace ID')
+    .action(async (opts, command) => {
     const useJson = shouldOutputJson(command.optsWithGlobals().json);
     const credentials = requireAuth();
     const client = new ApiClient(credentials);
-    const config = readConfig();
+    const { workspaceId } = await resolveWorkspace(client, opts);
     try {
-        const integrations = await client.listConnectedIntegrations(config.workspaceId);
+        const integrations = await client.listConnectedIntegrations(workspaceId);
         if (useJson) {
             const items = integrations.map(i => ({
                 id: i.canonicalId || i.integrationId,
@@ -97,7 +93,104 @@ const listCommand = new Command('list')
         process.exit(1);
     }
 });
+const callCommand = new Command('call')
+    .description('Make a proxy call to a connected integration')
+    .argument('<integration>', 'Integration name (e.g., hubspot, slack)')
+    .argument('[method]', 'HTTP method (GET, POST, PUT, DELETE)')
+    .argument('[path]', 'API path (e.g., /crm/v3/contacts)')
+    .option('--workspace <id>', 'Workspace ID')
+    .option('--body <json>', 'Request body JSON')
+    .option('--header <header>', 'Request header (repeatable)', (val, prev) => [...prev, val], [])
+    .option('--query <query>', 'Query string (e.g., limit=10&offset=0)')
+    .option('--curl <command>', 'Parse a curl command (paste from Chrome DevTools "Copy as cURL")')
+    .option('--curl-file <file>', 'Read curl command from a file')
+    .action(async (integration, method, path, opts, command) => {
+    const useJson = shouldOutputJson(command.optsWithGlobals().json);
+    const credentials = requireAuth();
+    const client = new ApiClient(credentials);
+    const { workspaceId } = await resolveWorkspace(client, opts);
+    let finalMethod;
+    let finalPath;
+    const headers = {};
+    let body;
+    let query = opts.query;
+    // Mode 1: --curl or --curl-file
+    if (opts.curl || opts.curlFile) {
+        let curlStr = opts.curl;
+        if (opts.curlFile) {
+            const filePath = opts.curlFile;
+            if (!existsSync(filePath)) {
+                console.error(`File not found: ${filePath}`);
+                process.exit(1);
+            }
+            curlStr = readFileSync(filePath, 'utf-8');
+        }
+        try {
+            const result = await parseCurlToRequest(curlStr);
+            finalMethod = result.method;
+            finalPath = result.path;
+            if (result.query)
+                query = query || result.query;
+            Object.assign(headers, result.headers);
+            body = result.body;
+        }
+        catch (err) {
+            console.error('Failed to parse curl command:', err instanceof Error ? err.message : err);
+            process.exit(1);
+        }
+    }
+    // Mode 2: explicit method + path args
+    else if (method && path) {
+        finalMethod = method.toUpperCase();
+        finalPath = path;
+        // Parse headers from repeatable --header flags
+        for (const h of (opts.header || [])) {
+            const [key, ...rest] = h.split(':');
+            headers[key.trim()] = rest.join(':').trim();
+        }
+        // Parse body
+        if (opts.body) {
+            try {
+                body = JSON.parse(opts.body);
+            }
+            catch {
+                console.error('Invalid JSON in --body');
+                process.exit(1);
+            }
+        }
+    }
+    else {
+        console.error('Usage: runwork integrations call <integration> <method> <path>');
+        console.error('   or: runwork integrations call <integration> --curl "curl ..."');
+        process.exit(1);
+    }
+    try {
+        // Find the integration's database row ID from connected integrations
+        const integrations = await client.listConnectedIntegrations(workspaceId);
+        const match = integrations.find(i => (i.canonicalId || i.integrationId) === integration || i.provider === integration);
+        if (!match) {
+            console.error(`Integration "${integration}" not found. Run "runwork integrations list" to see connected integrations.`);
+            process.exit(1);
+        }
+        const result = await client.callIntegrationProxy(match.integrationId, finalMethod, finalPath, { body, headers: Object.keys(headers).length > 0 ? headers : undefined, query });
+        if (useJson) {
+            jsonOut(result);
+            return;
+        }
+        if (typeof result === 'string') {
+            console.log(result);
+        }
+        else {
+            console.log(JSON.stringify(result, null, 2));
+        }
+    }
+    catch (err) {
+        console.error('Failed to call integration:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
 export const integrationsCommand = new Command('integrations')
     .description('Search and manage workspace integrations')
     .addCommand(searchCommand)
-    .addCommand(listCommand);
+    .addCommand(listCommand)
+    .addCommand(callCommand);

package/dist/commands/mcp.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const mcpCommand: Command;

package/dist/commands/mcp.js

@@ -0,0 +1,117 @@
+import { Command } from 'commander';
+import { requireAuth } from '../auth/store.js';
+import { ApiClient } from '../api/client.js';
+import { resolveWorkspace } from '../workspace/resolve.js';
+import { promptConfirm } from '../utils/prompt.js';
+import { shouldOutputJson, jsonOut } from '../utils/output.js';
+const listCommand = new Command('list')
+    .description('List workspace MCP servers')
+    .option('--workspace <id>', 'Workspace ID')
+    .action(async (opts, command) => {
+    const useJson = shouldOutputJson(command.optsWithGlobals().json);
+    const credentials = requireAuth();
+    const client = new ApiClient(credentials);
+    const { workspaceId, workspaceName } = await resolveWorkspace(client, opts);
+    try {
+        const servers = await client.listMcpServers(workspaceId);
+        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>');
+            return;
+        }
+        console.log(`\nWorkspace: ${workspaceName || workspaceId}\n`);
+        console.log(`  ${'Name'.padEnd(20)} ${'URL'.padEnd(45)} Status`);
+        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('');
+    }
+    catch (err) {
+        console.error('Failed to list MCP servers:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+const addCommand = new Command('add')
+    .description('Add an MCP server to workspace')
+    .argument('<name>', 'Server name')
+    .argument('<url>', 'Server URL (Streamable HTTP or SSE endpoint)')
+    .option('--transport <type>', 'Transport type: streamable-http or sse', 'streamable-http')
+    .option('--workspace <id>', 'Workspace ID')
+    .action(async (name, url, opts, command) => {
+    const useJson = shouldOutputJson(command.optsWithGlobals().json);
+    const credentials = requireAuth();
+    const client = new ApiClient(credentials);
+    const { workspaceId } = await resolveWorkspace(client, opts);
+    try {
+        new URL(url);
+    }
+    catch {
+        console.error(`Invalid URL: ${url}`);
+        process.exit(1);
+    }
+    try {
+        const server = await client.addMcpServer(workspaceId, {
+            name,
+            url,
+            transport: opts.transport,
+        });
+        if (useJson) {
+            jsonOut({ server });
+            return;
+        }
+        console.log(`Added MCP server "${name}" (${url})`);
+        console.log('Run `runwork sync` to update your local agent configs.');
+    }
+    catch (err) {
+        console.error('Failed to add MCP server:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+const removeCommand = new Command('remove')
+    .description('Remove an MCP server from workspace')
+    .argument('<name>', 'Server name')
+    .option('--yes', 'Skip confirmation')
+    .option('--workspace <id>', 'Workspace ID')
+    .action(async (name, opts, command) => {
+    const useJson = shouldOutputJson(command.optsWithGlobals().json);
+    const credentials = requireAuth();
+    const client = new ApiClient(credentials);
+    const { workspaceId } = await resolveWorkspace(client, opts);
+    try {
+        const servers = await client.listMcpServers(workspaceId);
+        const match = servers.find(s => s.name === name);
+        if (!match) {
+            console.error(`MCP server "${name}" not found in workspace.`);
+            process.exit(1);
+        }
+        if (!opts.yes && !useJson) {
+            const confirmed = await promptConfirm(`Remove MCP server "${name}" (${match.url})?`);
+            if (!confirmed)
+                return;
+        }
+        await client.removeMcpServer(workspaceId, match.id);
+        if (useJson) {
+            jsonOut({ removed: true, name });
+            return;
+        }
+        console.log(`Removed MCP server "${name}".`);
+        console.log('Run `runwork sync` to update your local agent configs.');
+    }
+    catch (err) {
+        console.error('Failed to remove MCP server:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+export const mcpCommand = new Command('mcp')
+    .description('Manage workspace MCP servers')
+    .addCommand(listCommand)
+    .addCommand(addCommand)
+    .addCommand(removeCommand);

package/dist/commands/schedules.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const schedulesCommand: Command;