runwork 0.4.0 → 0.5.0

package/dist/commands/schedules.js

@@ -0,0 +1,221 @@
+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 scheduled jobs in the workspace')
+    .option('--workspace <id>', 'Workspace ID')
+    .option('--app <name|id>', '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 schedules = await client.listSchedules(workspaceId);
+        if (opts.app) {
+            const { appId } = await resolveApp(client, workspaceId, opts);
+            schedules = schedules.filter(s => s.appId === appId);
+        }
+        if (useJson) {
+            jsonOut({ schedules });
+            return;
+        }
+        if (schedules.length === 0) {
+            console.log('No scheduled jobs found in this workspace.');
+            return;
+        }
+        console.log(`\nWorkspace: ${workspaceName || workspaceId}\n`);
+        console.log('  ' +
+            'Name'.padEnd(24) +
+            'App'.padEnd(20) +
+            'Schedule'.padEnd(18) +
+            'Status'.padEnd(12) +
+            'Description');
+        console.log('  ' + '-'.repeat(90));
+        for (const s of schedules) {
+            const mode = s.deploymentMode ? ` (${s.deploymentMode})` : '';
+            const status = s.status ? s.status + mode : mode.trim() || '-';
+            console.log('  ' +
+                s.name.padEnd(24) +
+                (s.appName || s.appId).slice(0, 18).padEnd(20) +
+                (s.schedule || '-').padEnd(18) +
+                status.padEnd(12) +
+                truncate(s.description, 40));
+        }
+        console.log('');
+    }
+    catch (err) {
+        console.error('Failed to list schedules:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+const triggerCommand = new Command('trigger')
+    .description('Manually trigger a scheduled job')
+    .argument('<name>', 'Schedule name')
+    .option('--workspace <id>', 'Workspace ID')
+    .option('--app <name|id>', 'App name or ID')
+    .option('--preview', 'Trigger in preview (sandbox) mode instead of production')
+    .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);
+    const deploymentMode = opts.preview ? 'preview' : 'production';
+    try {
+        const result = await client.triggerSchedule(workspaceId, {
+            scheduleName: name,
+            appId,
+            deploymentMode,
+        });
+        if (useJson) {
+            jsonOut({ result, scheduleName: name, appId, appName, deploymentMode });
+            return;
+        }
+        console.log(`Triggered schedule "${name}" on app "${appName}" (${deploymentMode}).`);
+        if (result.message) {
+            console.log(result.message);
+        }
+    }
+    catch (err) {
+        console.error('Failed to trigger schedule:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+const historyCommand = new Command('history')
+    .description('Show execution history for scheduled jobs in an app')
+    .option('--workspace <id>', 'Workspace ID')
+    .option('--app <name|id>', 'App name or ID (required)')
+    .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, appName } = await resolveApp(client, workspaceId, opts);
+    try {
+        const data = await client.getScheduleHistory(workspaceId, appId);
+        if (useJson) {
+            jsonOut({ history: data.history, appId, appName });
+            return;
+        }
+        if (!data.history || data.history.length === 0) {
+            console.log(`No schedule history found for app "${appName}".`);
+            return;
+        }
+        console.log(`\nSchedule history for app: ${appName}\n`);
+        console.log('  ' +
+            'Schedule'.padEnd(24) +
+            'Executed At'.padEnd(26) +
+            'Status'.padEnd(12) +
+            'Duration');
+        console.log('  ' + '-'.repeat(72));
+        for (const entry of data.history) {
+            const duration = entry.durationMs != null ? `${entry.durationMs}ms` : '-';
+            console.log('  ' +
+                entry.scheduleName.padEnd(24) +
+                entry.executedAt.padEnd(26) +
+                entry.status.padEnd(12) +
+                duration);
+            if (entry.error) {
+                console.log(`    Error: ${entry.error}`);
+            }
+        }
+        console.log('');
+    }
+    catch (err) {
+        console.error('Failed to get schedule history:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+const statusCommand = new Command('status')
+    .description('Show runtime status of scheduled jobs for an app')
+    .argument('<name>', 'Schedule name')
+    .option('--workspace <id>', 'Workspace ID')
+    .option('--app <name|id>', 'App name or ID (required)')
+    .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);
+    try {
+        const data = await client.getScheduleStatus(workspaceId, appId);
+        if (useJson) {
+            jsonOut({ status: data, scheduleName: name, appId, appName });
+            return;
+        }
+        console.log(`\nSchedule "${name}" status for app "${appName}":\n`);
+        console.log(JSON.stringify(data, null, 2));
+        console.log('');
+    }
+    catch (err) {
+        console.error('Failed to get schedule status:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+const pauseCommand = new Command('pause')
+    .description('Pause a scheduled job')
+    .argument('<name>', 'Schedule name')
+    .option('--workspace <id>', 'Workspace ID')
+    .option('--app <name|id>', 'App name or ID (required)')
+    .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);
+    try {
+        await client.pauseSchedule(workspaceId, name, appId);
+        if (useJson) {
+            jsonOut({ success: true, scheduleName: name, appId, appName, action: 'paused' });
+            return;
+        }
+        console.log(`Schedule "${name}" paused for app "${appName}".`);
+    }
+    catch (err) {
+        console.error('Failed to pause schedule:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+const resumeCommand = new Command('resume')
+    .description('Resume a paused scheduled job')
+    .argument('<name>', 'Schedule name')
+    .option('--workspace <id>', 'Workspace ID')
+    .option('--app <name|id>', 'App name or ID (required)')
+    .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);
+    try {
+        await client.resumeSchedule(workspaceId, name, appId);
+        if (useJson) {
+            jsonOut({ success: true, scheduleName: name, appId, appName, action: 'resumed' });
+            return;
+        }
+        console.log(`Schedule "${name}" resumed for app "${appName}".`);
+    }
+    catch (err) {
+        console.error('Failed to resume schedule:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+export const schedulesCommand = new Command('schedules')
+    .description('Manage workspace scheduled jobs')
+    .addCommand(listCommand)
+    .addCommand(triggerCommand)
+    .addCommand(historyCommand)
+    .addCommand(statusCommand)
+    .addCommand(pauseCommand)
+    .addCommand(resumeCommand);

package/dist/commands/setup.d.ts

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

package/dist/commands/setup.js

@@ -0,0 +1,199 @@
+import { Command } from 'commander';
+import { readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { requireAuth } from '../auth/store.js';
+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';
+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')
+    .action(async (opts) => {
+    const credentials = requireAuth();
+    const client = new ApiClient(credentials);
+    // 1. Resolve workspace
+    const { workspaceId, workspaceName } = await resolveWorkspace(client, opts);
+    console.log(`\nWorkspace: ${workspaceName || workspaceId}\n`);
+    // 2. Detect agents
+    let agents = await detectAgents();
+    if (agents.length === 0) {
+        printNoAgentsMessage();
+        process.exit(0);
+    }
+    // Filter by --agent flag
+    if (opts.agent) {
+        agents = agents.filter(a => a.slug === opts.agent);
+        if (agents.length === 0) {
+            console.error(`Agent "${opts.agent}" not detected on this machine.`);
+            process.exit(1);
+        }
+    }
+    else {
+        // Show detected agents and confirm
+        console.log('Detected agents:');
+        for (const a of agents) {
+            console.log(`  - ${a.name}`);
+        }
+        console.log('');
+        const configureAll = await promptConfirm(`Configure all ${agents.length} agents?`);
+        if (!configureAll) {
+            const kept = [];
+            for (const a of agents) {
+                const include = await promptConfirm(`  Include ${a.name}?`);
+                if (include)
+                    kept.push(a);
+            }
+            agents = kept;
+            if (agents.length === 0) {
+                console.log('No agents selected.');
+                return;
+            }
+        }
+    }
+    // 3. Determine scope
+    let scope = 'user';
+    if (hasProjectConfig()) {
+        const scopeChoices = [
+            { label: 'This project only', value: 'project' },
+            { label: 'Your user (global)', value: 'user' },
+            { label: 'Both', value: 'both' },
+        ];
+        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 */ }
+    }
+    // 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
+    const state = {
+        workspaceId,
+        workspaceName: workspaceName || '',
+        configuredAgents: agents.map(a => a.slug),
+        scope,
+        lastSyncAt: new Date().toISOString(),
+        mcpServers: mcpEntries.map(e => e.name),
+        skills: userSkillFiles.map(s => s.name),
+    };
+    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');
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(join(dir, 'setup.json'), JSON.stringify(state, null, 2));
+    }
+    console.log('\nSetup complete. Run `runwork sync` anytime to refresh.');
+});

package/dist/commands/skills.d.ts

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

package/dist/commands/skills.js

@@ -0,0 +1,134 @@
+import { Command } from 'commander';
+import { readFileSync, existsSync } from 'fs';
+import { requireAuth } from '../auth/store.js';
+import { ApiClient } from '../api/client.js';
+import { resolveWorkspace } 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 workspace skills (app, external, MCP-generated)')
+    .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 skills = await client.listWorkspaceSkills(workspaceId);
+        if (useJson) {
+            jsonOut({ skills });
+            return;
+        }
+        if (skills.length === 0) {
+            console.log('No skills found in this workspace.');
+            return;
+        }
+        console.log(`\nWorkspace: ${workspaceName || workspaceId}\n`);
+        const appSkills = skills.filter(s => s.type === 'app');
+        const externalSkills = skills.filter(s => s.type === 'external');
+        const mcpSkills = skills.filter(s => s.type === 'mcp');
+        if (appSkills.length > 0) {
+            console.log('  App Skills (auto-generated)');
+            console.log('  ' + '-'.repeat(40));
+            for (const s of appSkills) {
+                console.log(`  ${s.name.padEnd(24)} ${truncate(s.description, 60)}`);
+            }
+            console.log('');
+        }
+        if (externalSkills.length > 0) {
+            console.log('  External Skills');
+            console.log('  ' + '-'.repeat(40));
+            for (const s of externalSkills) {
+                console.log(`  ${s.name.padEnd(24)} ${truncate(s.description, 60)}`);
+            }
+            console.log('');
+        }
+        if (mcpSkills.length > 0) {
+            console.log('  MCP-Generated Skills');
+            console.log('  ' + '-'.repeat(40));
+            for (const s of mcpSkills) {
+                console.log(`  ${s.name.padEnd(24)} ${truncate(s.description, 60)}`);
+            }
+            console.log('');
+        }
+    }
+    catch (err) {
+        console.error('Failed to list skills:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+const pushCommand = new Command('push')
+    .description('Upload a local skill file to workspace (upsert by name)')
+    .argument('<file>', 'Path to skill .md file')
+    .option('--workspace <id>', 'Workspace ID')
+    .action(async (file, opts, command) => {
+    const useJson = shouldOutputJson(command.optsWithGlobals().json);
+    const credentials = requireAuth();
+    const client = new ApiClient(credentials);
+    const { workspaceId } = await resolveWorkspace(client, opts);
+    if (!existsSync(file)) {
+        console.error(`File not found: ${file}`);
+        process.exit(1);
+    }
+    try {
+        const content = readFileSync(file, 'utf-8');
+        // Parse frontmatter
+        const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+        let name = '';
+        let description = '';
+        let body = content;
+        if (frontmatterMatch) {
+            const fm = frontmatterMatch[1];
+            body = frontmatterMatch[2];
+            const nameMatch = fm.match(/^name:\s*(.+)$/m);
+            const descMatch = fm.match(/^description:\s*(.+)$/m);
+            if (nameMatch)
+                name = nameMatch[1].trim();
+            if (descMatch)
+                description = descMatch[1].trim();
+        }
+        if (!name) {
+            console.error('Skill file must have a "name" in YAML frontmatter:\n---\nname: my-skill\ndescription: What it does\n---');
+            process.exit(1);
+        }
+        // Check if skill already exists (upsert by name)
+        const existing = await client.listExternalSkills(workspaceId);
+        const match = existing.find(s => s.name === name);
+        if (match) {
+            const updated = await client.updateExternalSkill(workspaceId, match.id, {
+                name, description, content: body,
+            });
+            if (useJson) {
+                jsonOut({ skill: updated, action: 'updated' });
+                return;
+            }
+            console.log(`Updated skill "${name}" in workspace.`);
+        }
+        else {
+            const created = await client.importExternalSkill(workspaceId, {
+                name, description, content: body, importedFrom: 'cli',
+            });
+            if (useJson) {
+                jsonOut({ skill: created, action: 'created' });
+                return;
+            }
+            console.log(`Created skill "${name}" in workspace.`);
+        }
+        console.log('Run `runwork sync` to update your local agent configs.');
+    }
+    catch (err) {
+        console.error('Failed to push skill:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+export const skillsCommand = new Command('skills')
+    .description('Manage workspace skills')
+    .addCommand(listCommand)
+    .addCommand(pushCommand);

package/dist/commands/sync.d.ts

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