runwork 0.4.0 → 0.5.0

package/dist/commands/sync.js

@@ -0,0 +1,146 @@
+import { Command } from 'commander';
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { requireAuth } from '../auth/store.js';
+import { ApiClient } from '../api/client.js';
+import { getAdapterBySlug } from '../agents/detect.js';
+import { RUNWORK_MCP_PREFIX } from '../agents/types.js';
+function loadSetupState(filePath) {
+    if (!existsSync(filePath))
+        return null;
+    try {
+        return JSON.parse(readFileSync(filePath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+async function syncFromState(state, statePath, credentials, dryRun) {
+    const client = new ApiClient(credentials);
+    console.log(`Syncing workspace: ${state.workspaceName || state.workspaceId}`);
+    // Fetch latest data
+    const [allSkills, mcpServers, externalSkills] = await Promise.all([
+        client.listWorkspaceSkills(state.workspaceId),
+        client.listMcpServers(state.workspaceId),
+        client.listExternalSkills(state.workspaceId),
+    ]);
+    // Build entries
+    const wsPrefix = state.workspaceId.substring(0, 8);
+    const baseUrl = credentials.baseUrl || 'https://runwork.ai';
+    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}` },
+    }));
+    mcpEntries.push({
+        name: `${RUNWORK_MCP_PREFIX}${wsPrefix}-workspace`,
+        url: `${baseUrl}/api/workspaces/${state.workspaceId}/mcp`,
+        transport: 'streamable-http',
+        headers: { Authorization: `Bearer ${credentials.apiKey}` },
+    });
+    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 in parallel
+    const allAppSkillFiles = [];
+    const appSkillEntries = allSkills.filter(s => s.type === 'app' && s.appId);
+    const appSkillResults = await Promise.all(appSkillEntries.map(async (s) => {
+        try {
+            const content = await client.getAppSkillContent(state.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 appSkillResults) {
+        if (r)
+            allAppSkillFiles.push(r);
+    }
+    // Project scope: only current app's skill; User scope: all app skills
+    let projectAppSkillFile = null;
+    if (existsSync('.runwork.json')) {
+        try {
+            const config = JSON.parse(readFileSync('.runwork.json', 'utf-8'));
+            if (config.appName) {
+                const fname = config.appName.toLowerCase().replace(/[^a-z0-9]+/g, '-');
+                projectAppSkillFile = allAppSkillFiles.find(s => s.filename === fname) || null;
+            }
+        }
+        catch { /* ignore */ }
+    }
+    const userSkillFiles = [...baseSkillFiles, ...allAppSkillFiles];
+    const projectSkillFiles = projectAppSkillFile
+        ? [...baseSkillFiles, projectAppSkillFile]
+        : [...baseSkillFiles];
+    if (dryRun) {
+        console.log(`  Would update: ${mcpEntries.length} MCP servers, ${userSkillFiles.length} skills (user), ${projectSkillFiles.length} skills (project)`);
+        console.log(`  Agents: ${state.configuredAgents.join(', ')}`);
+        return;
+    }
+    // Write to configured agents
+    const scopes = state.scope === 'both' ? ['project', 'user'] : [state.scope];
+    for (const slug of state.configuredAgents) {
+        const adapter = getAdapterBySlug(slug);
+        if (!adapter)
+            continue;
+        for (const scope of scopes) {
+            const skillFiles = scope === 'project' ? projectSkillFiles : userSkillFiles;
+            try {
+                if (adapter.supportsMcpScope(scope) && mcpEntries.length > 0) {
+                    await adapter.writeMcpServers(mcpEntries, scope);
+                }
+                if (adapter.supportsSkills() && skillFiles.length > 0) {
+                    await adapter.writeSkills(skillFiles, scope);
+                }
+            }
+            catch (err) {
+                console.warn(`  [${adapter.name}] Failed (${scope}): ${err instanceof Error ? err.message : err}`);
+            }
+        }
+        console.log(`  [${adapter.name}] Updated`);
+    }
+    // Update state
+    state.lastSyncAt = new Date().toISOString();
+    state.mcpServers = mcpEntries.map(e => e.name);
+    state.skills = userSkillFiles.map(s => s.name);
+    writeFileSync(statePath, JSON.stringify(state, null, 2));
+}
+export const syncCommand = new Command('sync')
+    .description('Refresh local agent configs with latest workspace skills and MCP servers')
+    .option('--dry-run', 'Show what would change without writing files')
+    .action(async (opts) => {
+    const credentials = requireAuth();
+    const dryRun = !!opts.dryRun;
+    const projectStatePath = join(process.cwd(), '.runwork', 'setup.json');
+    const userStatePath = join(homedir(), '.runwork', 'setup.json');
+    const projectState = loadSetupState(projectStatePath);
+    const userState = loadSetupState(userStatePath);
+    if (!projectState && !userState) {
+        console.error('No setup state found. Run `runwork setup` first.');
+        process.exit(1);
+    }
+    // Sync both states independently — even if same workspace, they may target different scopes/agents
+    if (projectState) {
+        await syncFromState(projectState, projectStatePath, credentials, dryRun);
+    }
+    if (userState) {
+        await syncFromState(userState, userStatePath, credentials, dryRun);
+    }
+    if (!dryRun) {
+        console.log('\nSync complete.');
+    }
+});

package/dist/commands/workflows.d.ts

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

package/dist/commands/workflows.js

@@ -0,0 +1,187 @@
+import { Command } from 'commander';
+import { requireAuth } from '../auth/store.js';
+import { ApiClient } from '../api/client.js';
+import { resolveWorkspace, resolveApp } from '../workspace/resolve.js';
+import { shouldOutputJson, jsonOut } from '../utils/output.js';
+function truncate(text, max) {
+    if (!text)
+        return '';
+    const first = text.split('\n')[0];
+    if (first.length <= max)
+        return first;
+    return first.slice(0, max - 3) + '...';
+}
+const listCommand = new Command('list')
+    .description('List workflows in a workspace')
+    .option('--workspace <id>', 'Workspace ID')
+    .option('--app <name>', 'Filter by app name or 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 {
+        let workflows = await client.listWorkflows(workspaceId);
+        if (opts.app) {
+            workflows = workflows.filter(w => w.appId === opts.app || w.appName === opts.app);
+        }
+        if (useJson) {
+            jsonOut({ workflows });
+            return;
+        }
+        if (workflows.length === 0) {
+            console.log('No workflows found.');
+            return;
+        }
+        console.log(`\nWorkspace: ${workspaceName || workspaceId}\n`);
+        console.log('  ' +
+            'Name'.padEnd(24) +
+            'App'.padEnd(20) +
+            'Mode'.padEnd(12) +
+            'Enabled'.padEnd(10) +
+            'Description');
+        console.log('  ' + '-'.repeat(80));
+        for (const w of workflows) {
+            const mode = w.deploymentMode ?? '';
+            const enabled = w.enabled === false ? 'no' : 'yes';
+            console.log('  ' +
+                w.name.padEnd(24) +
+                (w.appName || w.appId).slice(0, 18).padEnd(20) +
+                mode.padEnd(12) +
+                enabled.padEnd(10) +
+                truncate(w.description, 40));
+        }
+        console.log('');
+    }
+    catch (err) {
+        console.error('Failed to list workflows:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+const triggerCommand = new Command('trigger')
+    .description('Trigger a workflow by name')
+    .argument('<name>', 'Workflow name')
+    .option('--workspace <id>', 'Workspace ID')
+    .option('--app <name>', 'App name or ID (required if not in a project directory)')
+    .option('--params <json>', 'JSON string of parameters to pass to the workflow')
+    .option('--instance-id <id>', 'Custom instance ID for the workflow run')
+    .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);
+    const { appId, appName } = await resolveApp(client, workspaceId, opts);
+    let params;
+    if (opts.params) {
+        try {
+            params = JSON.parse(opts.params);
+        }
+        catch {
+            console.error('Failed to parse --params: must be valid JSON');
+            process.exit(1);
+        }
+    }
+    try {
+        const result = await client.triggerWorkflow(workspaceId, {
+            workflowName: name,
+            appId,
+            params,
+            instanceId: opts.instanceId,
+        });
+        if (useJson) {
+            jsonOut({ result });
+            return;
+        }
+        console.log(`Triggered workflow "${name}" on app "${appName || appId}".`);
+        console.log(`  Instance ID: ${result.instanceId}`);
+        console.log(`  Status:      ${result.status}`);
+    }
+    catch (err) {
+        console.error('Failed to trigger workflow:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+const instancesCommand = new Command('instances')
+    .description('List workflow instances for an app')
+    .option('--workspace <id>', 'Workspace ID')
+    .option('--app <name>', 'App name or ID (required if not in a project directory)')
+    .option('--workflow <name>', 'Filter by workflow name')
+    .option('--status <status>', 'Filter by instance status')
+    .option('--limit <n>', 'Maximum number of instances to return')
+    .action(async (opts, command) => {
+    const useJson = shouldOutputJson(command.optsWithGlobals().json);
+    const credentials = requireAuth();
+    const client = new ApiClient(credentials);
+    const { workspaceId } = await resolveWorkspace(client, opts);
+    const { appId } = await resolveApp(client, workspaceId, opts);
+    try {
+        const data = await client.listWorkflowInstances(workspaceId, appId, {
+            workflowName: opts.workflow,
+            status: opts.status,
+            limit: opts.limit !== undefined ? Number(opts.limit) : undefined,
+        });
+        if (useJson) {
+            jsonOut({ instances: data.instances });
+            return;
+        }
+        if (data.instances.length === 0) {
+            console.log('No workflow instances found.');
+            return;
+        }
+        console.log('\n  ' +
+            'ID'.padEnd(28) +
+            'Workflow'.padEnd(24) +
+            'Status'.padEnd(14) +
+            'Created At');
+        console.log('  ' + '-'.repeat(80));
+        for (const inst of data.instances) {
+            const created = inst.createdAt
+                ? new Date(inst.createdAt).toLocaleString()
+                : '';
+            console.log('  ' +
+                inst.id.slice(0, 26).padEnd(28) +
+                inst.workflowName.padEnd(24) +
+                inst.status.padEnd(14) +
+                created);
+        }
+        console.log('');
+    }
+    catch (err) {
+        console.error('Failed to list workflow instances:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+const instanceCommand = new Command('instance')
+    .description('Get details for a specific workflow instance')
+    .argument('<id>', 'Workflow instance ID')
+    .option('--workspace <id>', 'Workspace ID')
+    .option('--app <name>', 'App name or ID (optional)')
+    .action(async (id, opts, command) => {
+    const useJson = shouldOutputJson(command.optsWithGlobals().json);
+    const credentials = requireAuth();
+    const client = new ApiClient(credentials);
+    const { workspaceId } = await resolveWorkspace(client, opts);
+    let appId;
+    if (opts.app) {
+        const resolved = await resolveApp(client, workspaceId, opts);
+        appId = resolved.appId;
+    }
+    try {
+        const data = await client.getWorkflowInstance(workspaceId, id, appId);
+        if (useJson) {
+            jsonOut({ instance: data.instance });
+            return;
+        }
+        console.log(JSON.stringify(data.instance, null, 2));
+    }
+    catch (err) {
+        console.error('Failed to get workflow instance:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+export const workflowsCommand = new Command('workflows')
+    .description('Manage workspace workflows')
+    .addCommand(listCommand)
+    .addCommand(triggerCommand)
+    .addCommand(instancesCommand)
+    .addCommand(instanceCommand);