runwork 0.2.5 → 0.4.0

package/dist/commands/info.js

@@ -0,0 +1,432 @@
+import { Command } from 'commander';
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { shouldOutputJson, jsonOut } from '../utils/output.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);
+    }
+    return JSON.parse(readFileSync('.runwork.json', 'utf-8'));
+}
+function readBlueprint(cwd) {
+    const blueprintPath = join(cwd, 'blueprint.json');
+    if (!existsSync(blueprintPath))
+        return null;
+    try {
+        return JSON.parse(readFileSync(blueprintPath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function mergeSources(blueprintItems, serverItems, getServerName, appId) {
+    const map = new Map();
+    for (const bp of blueprintItems) {
+        map.set(bp.name, { sources: ['blueprint'], blueprintExtra: bp.extra });
+    }
+    for (const serverItem of serverItems) {
+        if (serverItem.appId !== appId)
+            continue;
+        const name = getServerName(serverItem);
+        const mode = serverItem.deploymentMode;
+        const source = mode === 'production' ? 'production' : 'preview';
+        const existing = map.get(name);
+        if (existing) {
+            existing.sources.push(source);
+            existing.serverItem = serverItem;
+        }
+        else {
+            map.set(name, { sources: [source], serverItem: serverItem });
+        }
+    }
+    return map;
+}
+function buildRegistries(blueprint, serverData, appId) {
+    // Entities
+    const bpEntities = (blueprint?.entities ?? []).map(e => ({
+        name: e.entityName,
+        extra: e.schema ? { schema: e.schema } : {},
+    }));
+    const entityMap = mergeSources(bpEntities, serverData?.entities ?? [], (e) => e.entityName, appId);
+    const entities = Array.from(entityMap.entries()).map(([name, v]) => ({
+        name,
+        sources: v.sources,
+        ...(v.blueprintExtra?.schema ? { schema: v.blueprintExtra.schema } :
+            v.serverItem && 'schema' in v.serverItem && v.serverItem.schema ? { schema: v.serverItem.schema } : {}),
+    }));
+    // Scheduled jobs (blueprint may use either key)
+    const bpSchedules = (blueprint?.scheduledJobs ?? blueprint?.schedules ?? []).map(s => ({
+        name: s.name,
+        extra: { schedule: s.schedule, description: s.description },
+    }));
+    const scheduleMap = mergeSources(bpSchedules, serverData?.schedules ?? [], (s) => s.name, appId);
+    const scheduledJobs = Array.from(scheduleMap.entries()).map(([name, v]) => {
+        const serverItem = v.serverItem;
+        return {
+            name,
+            sources: v.sources,
+            schedule: v.blueprintExtra?.schedule ?? serverItem?.schedule,
+            description: v.blueprintExtra?.description ?? serverItem?.description,
+        };
+    });
+    // Workflows
+    const bpWorkflows = (blueprint?.workflows ?? []).map(w => ({
+        name: w.name,
+        extra: { description: w.description },
+    }));
+    const workflowMap = mergeSources(bpWorkflows, serverData?.workflows ?? [], (w) => w.name, appId);
+    const workflows = Array.from(workflowMap.entries()).map(([name, v]) => {
+        const serverItem = v.serverItem;
+        return {
+            name,
+            sources: v.sources,
+            description: v.blueprintExtra?.description ?? serverItem?.description,
+        };
+    });
+    // Agents
+    const bpAgents = (blueprint?.agents ?? []).map(a => ({
+        name: a.name,
+        extra: { type: a.type, description: a.description },
+    }));
+    const agentMap = mergeSources(bpAgents, serverData?.agents ?? [], (a) => a.name, appId);
+    const agents = Array.from(agentMap.entries()).map(([name, v]) => {
+        const serverItem = v.serverItem;
+        return {
+            name,
+            sources: v.sources,
+            type: v.blueprintExtra?.type ?? serverItem?.type,
+            description: v.blueprintExtra?.description ?? serverItem?.description,
+        };
+    });
+    // Public endpoints (blueprint may use either key)
+    const bpEndpoints = (blueprint?.publicEndpoints ?? blueprint?.endpoints ?? []).map(e => ({
+        name: `${e.method ?? 'ANY'} ${e.path}`,
+        extra: { path: e.path, method: e.method, description: e.description },
+    }));
+    const endpointMap = mergeSources(bpEndpoints, serverData?.endpoints ?? [], (e) => `${e.method ?? 'ANY'} ${e.path}`, appId);
+    const publicEndpoints = Array.from(endpointMap.entries()).map(([, v]) => {
+        const serverItem = v.serverItem;
+        return {
+            path: v.blueprintExtra?.path ?? serverItem?.path ?? '',
+            method: v.blueprintExtra?.method ?? serverItem?.method,
+            sources: v.sources,
+            description: v.blueprintExtra?.description ?? serverItem?.description,
+        };
+    });
+    // Components
+    const bpComponents = (blueprint?.components ?? []).map(c => ({
+        name: c.componentName,
+        extra: {},
+    }));
+    const componentMap = mergeSources(bpComponents, serverData?.components ?? [], (c) => c.componentName, appId);
+    const components = Array.from(componentMap.entries()).map(([name, v]) => ({
+        name,
+        sources: v.sources,
+    }));
+    // File storage
+    const bpHasStorage = blueprint
+        ? typeof blueprint.fileStorage === 'boolean'
+            ? blueprint.fileStorage
+            : typeof blueprint.fileStorage === 'object'
+                ? (blueprint.fileStorage.enabled !== false)
+                : false
+        : false;
+    const serverStorages = (serverData?.fileStorages ?? []).filter(fs => fs.appId === appId);
+    const storageSources = [];
+    if (bpHasStorage)
+        storageSources.push('blueprint');
+    for (const ss of serverStorages) {
+        const mode = ss.deploymentMode;
+        if (mode === 'production')
+            storageSources.push('production');
+        else
+            storageSources.push('preview');
+    }
+    const fileStorage = {
+        enabled: bpHasStorage || serverStorages.length > 0,
+        sources: storageSources,
+    };
+    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) {
+    return sources
+        .map(s => {
+        if (s === 'blueprint')
+            return cyan(s);
+        if (s === 'preview')
+            return yellow(s);
+        if (s === 'production')
+            return green(s);
+        return s;
+    })
+        .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)')}`);
+    }
+    console.log(`  ${dim(pad('Production:'))}${dim('(not available)')}`);
+    console.log('');
+    // Integrations
+    if (data.integrations === null) {
+        console.log(bold('Integrations:'));
+        console.log(`  ${dim('(unavailable -- API error or not authenticated)')}`);
+    }
+    else if (data.integrations.length === 0) {
+        console.log(bold('Integrations:'));
+        console.log(`  ${dim('(none connected)')}`);
+    }
+    else {
+        console.log(bold('Integrations:'));
+        for (const int of data.integrations) {
+            const statusColor = int.status === 'connected' ? green : yellow;
+            console.log(`  ${int.id.padEnd(20)} ${statusColor(int.status)}`);
+        }
+    }
+    console.log('');
+    // Registries
+    if (data.registries === null) {
+        // Skip entirely if unavailable
+    }
+    else {
+        const reg = data.registries;
+        const hasAny = reg.entities.length > 0 || reg.workflows.length > 0 ||
+            reg.scheduledJobs.length > 0 || reg.agents.length > 0 ||
+            reg.publicEndpoints.length > 0 || reg.components.length > 0 ||
+            reg.fileStorage.enabled;
+        if (!hasAny) {
+            // No registries -- skip the section entirely
+        }
+        else {
+            console.log(bold('Registries:'));
+            if (reg.entities.length > 0) {
+                console.log(`  ${bold('Entities:')}`);
+                for (const e of reg.entities) {
+                    console.log(`    ${e.name.padEnd(24)} ${formatSources(e.sources)}`);
+                }
+                console.log('');
+            }
+            if (reg.workflows.length > 0) {
+                console.log(`  ${bold('Workflows:')}`);
+                for (const w of reg.workflows) {
+                    const desc = w.description ? `  ${dim(w.description)}` : '';
+                    console.log(`    ${w.name.padEnd(24)} ${formatSources(w.sources)}${desc}`);
+                }
+                console.log('');
+            }
+            if (reg.scheduledJobs.length > 0) {
+                console.log(`  ${bold('Scheduled Jobs:')}`);
+                for (const s of reg.scheduledJobs) {
+                    const schedule = s.schedule ? `  ${gray(s.schedule)}` : '';
+                    console.log(`    ${s.name.padEnd(24)} ${formatSources(s.sources)}${schedule}`);
+                }
+                console.log('');
+            }
+            if (reg.agents.length > 0) {
+                console.log(`  ${bold('Agents:')}`);
+                for (const a of reg.agents) {
+                    const type = a.type ? `  ${dim(a.type)}` : '';
+                    console.log(`    ${a.name.padEnd(24)} ${formatSources(a.sources)}${type}`);
+                }
+                console.log('');
+            }
+            if (reg.publicEndpoints.length > 0) {
+                console.log(`  ${bold('Public Endpoints:')}`);
+                for (const e of reg.publicEndpoints) {
+                    const label = e.method ? `${e.method} ${e.path}` : e.path;
+                    console.log(`    ${label.padEnd(24)} ${formatSources(e.sources)}`);
+                }
+                console.log('');
+            }
+            if (reg.components.length > 0) {
+                console.log(`  ${bold('Components:')}`);
+                for (const c of reg.components) {
+                    console.log(`    ${c.name.padEnd(24)} ${formatSources(c.sources)}`);
+                }
+                console.log('');
+            }
+            if (reg.fileStorage.enabled) {
+                console.log(`  ${bold('File Storage:')}       ${formatSources(reg.fileStorage.sources)}`);
+                console.log('');
+            }
+        } // end hasAny
+    }
+    // CLI commands
+    console.log(bold('CLI Commands:'));
+    for (const cmd of data.cli.commands) {
+        console.log(`  ${cyan(('runwork ' + cmd.name).padEnd(36))} ${dim(cmd.description)}`);
+    }
+    console.log('');
+    console.log(dim(`  CLI version: ${data.cli.version}`));
+    console.log('');
+}
+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 };
+        }
+    }
+    catch {
+        // No active session -- that's fine
+    }
+    // Integrations
+    let integrations = null;
+    try {
+        const raw = await client.listConnectedIntegrations(config.workspaceId);
+        integrations = raw.map(i => ({
+            id: i.canonicalId ?? i.integrationId,
+            status: i.status ?? 'connected',
+        }));
+    }
+    catch {
+        process.stderr.write('Warning: failed to fetch integrations\n');
+    }
+    // Workspace registries
+    let serverData = null;
+    try {
+        serverData = await client.getWorkspaceAll(config.workspaceId);
+    }
+    catch {
+        process.stderr.write('Warning: failed to fetch workspace registries\n');
+    }
+    const registries = buildRegistries(blueprint, serverData, config.appId);
+    const output = {
+        app: {
+            id: config.appId,
+            name: config.appName,
+            slug: config.appName,
+        },
+        workspace: {
+            id: config.workspaceId,
+            name: config.workspaceName ?? config.workspaceId,
+        },
+        preview,
+        production: { url: null, deployed: false },
+        integrations,
+        registries,
+        cli: {
+            version: VERSION,
+            commands: CLI_COMMANDS,
+        },
+    };
+    if (asJson) {
+        jsonOut(output);
+    }
+    else {
+        printHumanOutput(output);
+    }
+});

package/dist/commands/init.d.ts

@@ -1,2 +1,5 @@
 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>;
 export declare const initCommand: Command;

package/dist/commands/init.js

@@ -1,32 +1,15 @@
 import { Command } from 'commander';
 import { execFileSync } from 'child_process';
 import { writeFileSync, existsSync, mkdirSync } from 'fs';
-import { join } from 'path';
+import { join, resolve } from 'path';
 import { requireAuth } from '../auth/store.js';
 import { ApiClient } from '../api/client.js';
 import { promptSelect, promptInput } from '../utils/prompt.js';
 import { generateManifest, saveManifest } from '../template/manifest.js';
 import { extractZip } from '../utils/zip.js';
 import { removeNestedGitDirs } from '../utils/fs.js';
-export const initCommand = new Command('init')
-    .description('Initialize a new Runwork app')
-    .argument('[name]', 'App name')
-    .action(async (name) => {
-    const creds = requireAuth();
-    const client = new ApiClient(creds);
-    const appName = name || await promptInput('App name');
-    if (!appName) {
-        console.error('App name is required.');
-        process.exit(1);
-    }
-    const workspaces = await client.listWorkspaces();
-    if (workspaces.length === 0) {
-        console.error('No workspaces found. Create one at runwork.ai first.');
-        process.exit(1);
-    }
-    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}"...`);
+import { runAgentWizard } from '../ui/banner.js';
+export async function execInit(client, appName, workspace) {
     const app = await client.initApp(workspace.id, appName);
     const slug = app.slug || appName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
     const dir = slug;
@@ -52,6 +35,7 @@ export const initCommand = new Command('init')
     // Write .runwork.json AFTER template extraction so it doesn't get overwritten
     const config = {
         workspaceId: workspace.id,
+        workspaceName: workspace.name,
         appId: app.id,
         appName: app.name,
     };
@@ -83,5 +67,29 @@ export const initCommand = new Command('init')
     execFileSync('git', ['push', '-u', 'runwork', 'main'], { cwd: dir, stdio: 'inherit' });
     console.log(`\nApp "${app.name}" initialized in ${dir}/`);
     console.log(`Remote: ${remoteUrl}`);
-    console.log(`\nNext: cd ${dir} && runwork dev`);
+    return resolve(dir);
+}
+export const initCommand = new Command('init')
+    .description('Initialize a new Runwork app')
+    .argument('[name]', 'App name')
+    .action(async (name) => {
+    const creds = requireAuth();
+    const client = new ApiClient(creds);
+    const appName = name || await promptInput('App name');
+    if (!appName) {
+        console.error('App name is required.');
+        process.exit(1);
+    }
+    const workspaces = await client.listWorkspaces();
+    if (workspaces.length === 0) {
+        console.error('No workspaces found. Create one at runwork.ai first.');
+        process.exit(1);
+    }
+    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}"...`);
+    const dir = await execInit(client, appName, workspace);
+    const slug = dir.split('/').pop() || dir;
+    await runAgentWizard(dir);
+    console.log(`Next: cd ${slug} && runwork dev`);
 });

package/dist/commands/integrations.js

@@ -2,6 +2,7 @@ import { Command } from 'commander';
 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.');
@@ -13,12 +14,18 @@ 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')
-    .action(async (query, opts) => {
+    .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);
+        if (useJson) {
+            const items = results.map(({ provider: _p, ...rest }) => rest);
+            jsonOut({ results: items });
+            return;
+        }
         if (results.length === 0) {
             console.log(`No integrations found for "${query}".`);
             console.log('Try broader terms (e.g., "calendar" instead of "google calendar").');
@@ -56,12 +63,22 @@ const searchCommand = new Command('search')
 });
 const listCommand = new Command('list')
     .description('List connected workspace integrations')
-    .action(async () => {
+    .action(async (_opts, command) => {
+    const useJson = shouldOutputJson(command.optsWithGlobals().json);
     const credentials = requireAuth();
     const client = new ApiClient(credentials);
     const config = readConfig();
     try {
         const integrations = await client.listConnectedIntegrations(config.workspaceId);
+        if (useJson) {
+            const items = integrations.map(i => ({
+                id: i.canonicalId || i.integrationId,
+                status: i.status || 'connected',
+                createdAt: i.createdAt || null,
+            }));
+            jsonOut({ items });
+            return;
+        }
         if (integrations.length === 0) {
             console.log('No integrations connected in this workspace.');
             console.log('Connect integrations at https://runwork.ai/workspace-settings');

package/dist/commands/login.js

@@ -1,32 +1,17 @@
 import { Command } from 'commander';
-import { ApiClient } from '../api/client.js';
-import { saveCredentials } from '../auth/store.js';
-import { configureGitCredentials } from '../git/credentials.js';
+import { performLogin } from '../auth/login-flow.js';
+import { bold, cyan } from '../ui/colors.js';
 export const loginCommand = new Command('login')
     .description('Authenticate with Runwork platform')
     .option('--base-url <url>', 'Platform URL', 'https://runwork.ai')
     .action(async (options) => {
-    const client = new ApiClient({ apiKey: '', email: '', baseUrl: options.baseUrl });
     console.log('Opening browser for authentication...');
-    const { sessionId, loginUrl } = await client.initiateLogin();
-    // Open browser
-    const open = await import('open');
-    await open.default(loginUrl);
-    console.log(`If browser didn't open, visit: ${loginUrl}`);
-    console.log('Waiting for authentication...');
-    // Poll for up to 5 minutes
-    const maxAttempts = 60;
-    const pollInterval = 5000;
-    for (let i = 0; i < maxAttempts; i++) {
-        await new Promise(resolve => setTimeout(resolve, pollInterval));
-        const result = await client.pollLogin(sessionId);
-        if (result) {
-            saveCredentials(result);
-            await configureGitCredentials(result.baseUrl || options.baseUrl);
-            console.log(`Logged in as ${result.email}`);
-            return;
-        }
-    }
-    console.error('Login timed out. Please try again.');
-    process.exit(1);
+    await performLogin(options.baseUrl);
+    console.log('');
+    console.log(bold('What next?'));
+    console.log('');
+    console.log(`  ${cyan('runwork init')}     Create a new app`);
+    console.log(`  ${cyan('runwork clone')}    Clone an existing app`);
+    console.log(`  ${cyan('runwork dev')}      Start developing (inside an app directory)`);
+    console.log('');
 });