runwork 0.15.0 → 0.15.2

package/dist/commands/doctor.d.ts

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

package/dist/commands/doctor.js

@@ -1,230 +0,0 @@
-import { Command } from 'commander';
-import { shouldOutputJson, jsonOut } from '../utils/output.js';
-import { bold, dim, green, yellow, cyan, red } from '../ui/colors.js';
-import { runAllChecks, ALL_CHECK_NAMES } from '../health/runner.js';
-import { buildContext } from '../health/checks.js';
-import { applyDoctorFixes } from '../health/fix.js';
-import { detectCurrentAgent } from '../agents/runtime-detection.js';
-/**
- * Env vars worth surfacing in --verbose for AI agents debugging their own
- * environment. Filtered to known-safe runtime signals; never includes
- * credentials, tokens, or anything matching common secret patterns.
- */
-const VERBOSE_ENV_ALLOWLIST = [
-    // Claude Code
-    'CLAUDECODE',
-    'CLAUDE_CODE_ENTRYPOINT',
-    'CLAUDE_CODE_SESSION_ID',
-    'CLAUDE_CODE_EXECPATH',
-    'CLAUDE_EFFORT',
-    // Codex
-    'CODEX_CI',
-    'CODEX_THREAD_ID',
-    'CODEX_SANDBOX',
-    'CODEX_SANDBOX_NETWORK_DISABLED',
-    // Generic shell context
-    'PWD',
-    'SHELL',
-    'TERM',
-    'LANG',
-    // CI markers
-    'CI',
-    'GITHUB_ACTIONS',
-];
-function collectVerboseInfo() {
-    const env = {};
-    for (const key of VERBOSE_ENV_ALLOWLIST) {
-        if (process.env[key] !== undefined) {
-            env[key] = process.env[key];
-        }
-    }
-    const detected = detectCurrentAgent();
-    return {
-        hostAgent: detected ?? null,
-        env,
-        runtime: {
-            platform: process.platform,
-            arch: process.arch,
-            nodeVersion: process.version,
-            cwd: process.cwd(),
-            pid: process.pid,
-        },
-    };
-}
-function printVerboseBlock(info) {
-    console.log('');
-    console.log(bold('Verbose runtime info'));
-    console.log('');
-    const detected = info.hostAgent;
-    if (detected) {
-        console.log(`  ${green('[detected]')} Host agent: ${detected.slug}`);
-        if (detected.sessionId)
-            console.log(`             sessionId:       ${detected.sessionId}`);
-        if (detected.sessionFilePath)
-            console.log(`             sessionFilePath: ${detected.sessionFilePath}`);
-        console.log(`             source:          ${detected.source}`);
-    }
-    else {
-        console.log(`  ${dim('[none]')} No host agent detected (not running inside a known AI agent)`);
-    }
-    console.log('');
-    console.log(bold('Env vars (allowlisted)'));
-    const envEntries = Object.entries(info.env);
-    if (envEntries.length === 0) {
-        console.log(`  ${dim('(none set)')}`);
-    }
-    else {
-        for (const [k, v] of envEntries) {
-            console.log(`  ${k.padEnd(38)} ${v}`);
-        }
-    }
-    console.log('');
-    console.log(bold('Runtime'));
-    const r = info.runtime;
-    for (const [k, v] of Object.entries(r)) {
-        console.log(`  ${k.padEnd(38)} ${v}`);
-    }
-    console.log('');
-}
-const STATUS_LABELS = {
-    pass: green('[pass]'),
-    warn: yellow('[warn]'),
-    fail: bold('[FAIL]'),
-    skip: dim('[skip]'),
-};
-const CHECK_LABELS = {
-    'system-deps': 'System dependencies',
-    'cli-version': 'CLI version',
-    'auth': 'Authentication',
-    'network': 'Network',
-    'project-config': 'Project config',
-    'app-exists': 'App exists',
-    'git-remote': 'Git remote',
-    'deploy-freshness': 'Deploy freshness',
-    'agent-setup': 'Agent setup',
-};
-function printHumanReport(report) {
-    console.log('');
-    console.log(bold('runwork doctor'));
-    console.log('');
-    for (const check of report.checks) {
-        const status = STATUS_LABELS[check.status] || check.status;
-        const label = (CHECK_LABELS[check.name] || check.name).padEnd(22);
-        console.log(`  ${status} ${label} ${dim(check.message)}`);
-        if (check.details && check.details.length > 1) {
-            for (const detail of check.details) {
-                console.log(`         ${dim('- ' + detail)}`);
-            }
-        }
-    }
-    // Summary
-    const failures = report.checks.filter(c => c.status === 'fail');
-    const warnings = report.checks.filter(c => c.status === 'warn');
-    console.log('');
-    if (failures.length > 0) {
-        console.log(`  ${failures.length} issue${failures.length !== 1 ? 's' : ''} found:`);
-        for (const f of failures) {
-            const label = CHECK_LABELS[f.name] || f.name;
-            if (f.fix) {
-                console.log(`    - ${label}: ${cyan(f.fix)}`);
-            }
-            else {
-                console.log(`    - ${label}: ${f.message}`);
-            }
-        }
-    }
-    if (warnings.length > 0 && failures.length === 0) {
-        console.log(`  ${warnings.length} warning${warnings.length !== 1 ? 's' : ''}:`);
-        for (const w of warnings) {
-            const label = CHECK_LABELS[w.name] || w.name;
-            if (w.fix) {
-                console.log(`    - ${label}: ${cyan(w.fix)}`);
-            }
-            else {
-                console.log(`    - ${label}: ${w.message}`);
-            }
-        }
-    }
-    if (failures.length === 0 && warnings.length === 0) {
-        console.log(`  ${green('All checks passed.')}`);
-    }
-    console.log('');
-}
-function printFixOutcomes(outcomes) {
-    console.log('');
-    console.log(bold('Applying fixes'));
-    if (outcomes.length === 0) {
-        console.log(`  ${dim('Nothing to fix (no auto-remediable failures).')}`);
-        return;
-    }
-    for (const o of outcomes) {
-        const marker = o.applied ? green('[fixed]') : yellow('[skip]');
-        console.log(`  ${marker} ${o.name}: ${dim(o.message)}`);
-    }
-}
-/** Parse and validate `--check a,b,c` against the known check names. */
-function parseCheckNames(raw) {
-    const requested = raw.split(',').map(s => s.trim()).filter(Boolean);
-    const known = new Set(ALL_CHECK_NAMES);
-    const only = requested.filter(n => known.has(n));
-    const unknown = requested.filter(n => !known.has(n));
-    return { only, unknown };
-}
-export const doctorCommand = new Command('doctor')
-    .description('Check system health: auth, network, project config, agent setup')
-    .option('-v, --verbose', 'Include host-agent detection results, runtime info, and allowlisted env vars (useful for AI agents debugging their own environment)')
-    .option('--check <names>', `Run only the named checks (comma-separated). Available: ${ALL_CHECK_NAMES.join(', ')}`)
-    .option('--fix', 'Auto-remediate fixable failures (git credential helper, runwork remote), then re-check')
-    .action(async (opts, command) => {
-    const asJson = shouldOutputJson(command.optsWithGlobals().json);
-    // Resolve `--check` scope (if any) up front so both fix and report honor it.
-    let only;
-    if (opts.check) {
-        const parsed = parseCheckNames(opts.check);
-        if (parsed.unknown.length > 0) {
-            const msg = `Unknown check(s): ${parsed.unknown.join(', ')}. Available: ${ALL_CHECK_NAMES.join(', ')}`;
-            if (asJson) {
-                jsonOut({ success: false, command: 'doctor', error: msg });
-            }
-            else {
-                console.error(red(msg));
-            }
-            process.exit(1);
-        }
-        only = parsed.only;
-    }
-    // --- Fix flow: report, remediate fixable failures, re-check ---
-    if (opts.fix) {
-        const before = await runAllChecks({ only });
-        const failingNames = before.checks.filter(c => c.status === 'fail').map(c => c.name);
-        const ctx = buildContext();
-        const outcomes = await applyDoctorFixes(ctx, failingNames);
-        const after = await runAllChecks({ only });
-        if (asJson) {
-            jsonOut({ success: after.status !== 'fail', command: 'doctor', fixes: outcomes, report: after });
-        }
-        else {
-            printFixOutcomes(outcomes);
-            printHumanReport(after);
-        }
-        if (after.checks.some(c => c.status === 'fail')) {
-            process.exit(1);
-        }
-        return;
-    }
-    // --- Normal (optionally scoped) report ---
-    const report = await runAllChecks({ only });
-    const verboseInfo = opts.verbose ? collectVerboseInfo() : null;
-    if (asJson) {
-        jsonOut(verboseInfo ? { ...report, verbose: verboseInfo } : report);
-    }
-    else {
-        printHumanReport(report);
-        if (verboseInfo) {
-            printVerboseBlock(verboseInfo);
-        }
-    }
-    if (report.checks.some(c => c.status === 'fail')) {
-        process.exit(1);
-    }
-});

package/dist/commands/endpoints.d.ts

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

package/dist/commands/endpoints.js

@@ -1,189 +0,0 @@
-import { Command } from 'commander';
-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';
-import { httpFetch } from '../utils/http.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 public endpoints')
-    .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 endpoints = await client.listEndpoints(workspaceId);
-        if (opts.app) {
-            endpoints = endpoints.filter(e => e.appId === opts.app || e.appName === opts.app);
-        }
-        if (useJson) {
-            jsonOut({ endpoints });
-            return;
-        }
-        if (endpoints.length === 0) {
-            console.log('No endpoints found in this workspace.');
-            return;
-        }
-        console.log(`\nWorkspace: ${workspaceName || workspaceId}\n`);
-        console.log(`  ${'METHOD'.padEnd(8)} ${'PATH'.padEnd(36)} ${'APP'.padEnd(20)} ${'AUTH'.padEnd(10)} DESCRIPTION`);
-        console.log('  ' + '-'.repeat(90));
-        for (const e of endpoints) {
-            const method = e.method.toUpperCase().padEnd(8);
-            const path = e.endpointPath.padEnd(36);
-            const app = (e.appName || e.appId).padEnd(20);
-            const auth = (e.auth || '').padEnd(10);
-            const desc = truncate(e.description, 40);
-            const mode = e.deploymentMode ? ` [${e.deploymentMode}]` : '';
-            console.log(`  ${method} ${path} ${app} ${auth} ${desc}${mode}`);
-        }
-        console.log('');
-    }
-    catch (err) {
-        console.error('Failed to list endpoints:', err instanceof Error ? err.message : err);
-        process.exit(1);
-    }
-});
-const callCommand = new Command('call')
-    .description('Call a workspace endpoint directly')
-    .argument('<method>', 'HTTP method (GET, POST, PUT, DELETE, etc.)')
-    .argument('<path>', 'Endpoint path (e.g. /my-endpoint)')
-    .option('--workspace <id>', 'Workspace ID')
-    .option('--app <name>', 'App name or ID (narrows endpoint lookup)')
-    .option('--body <json>', 'Request body as JSON string')
-    .option('--header <header>', 'Request header (format: "Key: Value", repeatable)', (val, prev) => [...prev, val], [])
-    .option('--query <string>', 'Query string to append to the URL (e.g. "foo=bar&baz=1")')
-    .option('--api-key <key>', 'API key for Authorization: Bearer header')
-    .action(async (method, path, 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 endpoints = await client.listEndpoints(workspaceId);
-        if (opts.app) {
-            endpoints = endpoints.filter(e => e.appId === opts.app || e.appName === opts.app);
-        }
-        const targetMethod = method.toUpperCase();
-        const endpoint = endpoints.find(e => e.method.toUpperCase() === targetMethod && e.endpointPath === path);
-        if (!endpoint) {
-            console.error(`Endpoint not found: ${targetMethod} ${path}`);
-            if (endpoints.length > 0) {
-                console.error('\nAvailable endpoints:');
-                for (const e of endpoints) {
-                    console.error(`  ${e.method.toUpperCase().padEnd(8)} ${e.endpointPath}  (${e.appName || e.appId})`);
-                }
-            }
-            else {
-                console.error('No endpoints registered in this workspace.');
-            }
-            process.exit(1);
-        }
-        const appInfo = await client.getApp(endpoint.appId);
-        const appSlug = appInfo.slug;
-        // Build URL: https://{workspaceName}.runwork.ai/{appSlug}/endpoints{path}
-        if (!workspaceName) {
-            console.error('Could not determine workspace name. Provide --workspace with a named workspace.');
-            process.exit(1);
-        }
-        const baseUrl = `https://${workspaceName}.runwork.ai`;
-        let url = `${baseUrl}/${appSlug}/endpoints${path}`;
-        if (opts.query) {
-            url = `${url}?${opts.query}`;
-        }
-        // Build headers
-        const headers = {};
-        if (opts.apiKey) {
-            headers['Authorization'] = `Bearer ${opts.apiKey}`;
-        }
-        for (const h of opts.header) {
-            const colonIndex = h.indexOf(':');
-            if (colonIndex === -1) {
-                console.error(`Invalid header format "${h}" — expected "Key: Value"`);
-                process.exit(1);
-            }
-            const key = h.slice(0, colonIndex).trim();
-            const value = h.slice(colonIndex + 1).trim();
-            headers[key] = value;
-        }
-        // Parse body
-        let body;
-        if (opts.body) {
-            try {
-                // Validate it's valid JSON then re-serialize for consistency
-                const parsed = JSON.parse(opts.body);
-                body = JSON.stringify(parsed);
-                if (!headers['Content-Type']) {
-                    headers['Content-Type'] = 'application/json';
-                }
-            }
-            catch {
-                console.error('Failed to parse --body as JSON. Provide a valid JSON string.');
-                process.exit(1);
-            }
-        }
-        if (useJson) {
-            // Let the caller know what we're calling before making the request
-            process.stderr.write(JSON.stringify({ calling: { method: targetMethod, url } }) + '\n');
-        }
-        else {
-            console.log(`\n${targetMethod} ${url}\n`);
-        }
-        const response = await httpFetch(url, {
-            method: targetMethod,
-            headers,
-            body,
-        });
-        const contentType = response.headers.get('content-type') || '';
-        const responseText = await response.text();
-        if (useJson) {
-            let responseBody = responseText;
-            if (contentType.includes('application/json')) {
-                try {
-                    responseBody = JSON.parse(responseText);
-                }
-                catch {
-                    // leave as string
-                }
-            }
-            jsonOut({
-                status: response.status,
-                statusText: response.statusText,
-                headers: Object.fromEntries(response.headers.entries()),
-                body: responseBody,
-            });
-            return;
-        }
-        console.log(`Status: ${response.status} ${response.statusText}\n`);
-        if (contentType.includes('application/json')) {
-            try {
-                const parsed = JSON.parse(responseText);
-                console.log(JSON.stringify(parsed, null, 2));
-            }
-            catch {
-                console.log(responseText);
-            }
-        }
-        else {
-            console.log(responseText);
-        }
-    }
-    catch (err) {
-        console.error('Failed to call endpoint:', err instanceof Error ? err.message : err);
-        process.exit(1);
-    }
-});
-export const endpointsCommand = new Command('endpoints')
-    .alias('routes')
-    .description('Manage and call workspace endpoints')
-    .addCommand(listCommand)
-    .addCommand(callCommand);

package/dist/commands/entities.d.ts

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

package/dist/commands/entities.js

@@ -1,198 +0,0 @@
-import { Command } from 'commander';
-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';
-import { promptConfirm } from '../utils/prompt.js';
-import { parseDataInput } from '../utils/data-input.js';
-const listCommand = new Command('list')
-    .description('List entities registered in the workspace')
-    .option('--workspace <id>', 'Workspace ID')
-    .option('--app <id>', 'Filter by app name or ID')
-    .option('--preview', 'Show preview-mode entities only')
-    .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 entities = await client.listEntities(workspaceId);
-        if (opts.app) {
-            entities = entities.filter(e => e.appId === opts.app || e.appName === opts.app);
-        }
-        if (opts.preview) {
-            entities = entities.filter(e => e.deploymentMode === 'preview');
-        }
-        if (useJson) {
-            jsonOut({ entities });
-            return;
-        }
-        if (entities.length === 0) {
-            console.log('No entities found in this workspace.');
-            return;
-        }
-        console.log(`\nWorkspace: ${workspaceName || workspaceId}\n`);
-        console.log(`  ${'Entity'.padEnd(28)} ${'App'.padEnd(24)} ${'Mode'.padEnd(12)}`);
-        console.log('  ' + '-'.repeat(66));
-        for (const e of entities) {
-            console.log(`  ${e.entityName.padEnd(28)} ${e.appName.padEnd(24)} ${(e.deploymentMode ?? '').padEnd(12)}`);
-        }
-        console.log('');
-    }
-    catch (err) {
-        console.error('Failed to list entities:', err instanceof Error ? err.message : err);
-        process.exit(1);
-    }
-});
-const recordsCommand = new Command('records')
-    .description('List records for an entity')
-    .argument('<entity>', 'Entity name')
-    .option('--workspace <id>', 'Workspace ID')
-    .option('--limit <n>', 'Number of records to return', '20')
-    .option('--cursor <cursor>', 'Pagination cursor')
-    .option('--preview', 'Query preview-mode data')
-    .action(async (entity, opts, command) => {
-    const useJson = shouldOutputJson(command.optsWithGlobals().json);
-    const credentials = requireAuth();
-    const client = new ApiClient(credentials);
-    const { workspaceId } = await resolveWorkspace(client, opts);
-    try {
-        const result = await client.listEntityRecords(workspaceId, entity, {
-            limit: parseInt(opts.limit, 10),
-            cursor: opts.cursor,
-            deploymentMode: opts.preview ? 'preview' : undefined,
-        });
-        if (useJson) {
-            jsonOut(result);
-            return;
-        }
-        if (result.items.length === 0) {
-            console.log(`No records found for entity "${entity}".`);
-            return;
-        }
-        console.log(`\nEntity: ${entity}  (${result.items.length} record(s))\n`);
-        console.log(JSON.stringify(result.items, null, 2));
-        if (result.next) {
-            console.log(`\nNext cursor: ${result.next}`);
-        }
-    }
-    catch (err) {
-        console.error('Failed to list entity records:', err instanceof Error ? err.message : err);
-        process.exit(1);
-    }
-});
-const getCommand = new Command('get')
-    .description('Get a single entity record by ID')
-    .argument('<entity>', 'Entity name')
-    .argument('<id>', 'Record ID')
-    .option('--workspace <id>', 'Workspace ID')
-    .action(async (entity, id, opts, command) => {
-    const useJson = shouldOutputJson(command.optsWithGlobals().json);
-    const credentials = requireAuth();
-    const client = new ApiClient(credentials);
-    const { workspaceId } = await resolveWorkspace(client, opts);
-    try {
-        const result = await client.getEntityRecord(workspaceId, entity, id);
-        if (useJson) {
-            jsonOut(result);
-            return;
-        }
-        console.log(JSON.stringify(result.item, null, 2));
-    }
-    catch (err) {
-        console.error('Failed to get entity record:', err instanceof Error ? err.message : err);
-        process.exit(1);
-    }
-});
-const createCommand = new Command('create')
-    .description('Create a new entity record')
-    .argument('<entity>', 'Entity name')
-    .option('--workspace <id>', 'Workspace ID')
-    .option('--data <json>', 'Record data as JSON string, @file.json, or pipe via stdin')
-    .option('--preview', 'Create in preview-mode data store')
-    .action(async (entity, opts, command) => {
-    const useJson = shouldOutputJson(command.optsWithGlobals().json);
-    const credentials = requireAuth();
-    const client = new ApiClient(credentials);
-    const { workspaceId } = await resolveWorkspace(client, opts);
-    try {
-        const data = await parseDataInput(opts.data);
-        const result = await client.createEntityRecord(workspaceId, entity, data);
-        if (useJson) {
-            jsonOut(result);
-            return;
-        }
-        console.log('Record created:');
-        console.log(JSON.stringify(result.item, null, 2));
-    }
-    catch (err) {
-        console.error('Failed to create entity record:', err instanceof Error ? err.message : err);
-        process.exit(1);
-    }
-});
-const updateCommand = new Command('update')
-    .description('Update an existing entity record')
-    .argument('<entity>', 'Entity name')
-    .argument('<id>', 'Record ID')
-    .option('--workspace <id>', 'Workspace ID')
-    .option('--data <json>', 'Record data as JSON string, @file.json, or pipe via stdin')
-    .action(async (entity, id, opts, command) => {
-    const useJson = shouldOutputJson(command.optsWithGlobals().json);
-    const credentials = requireAuth();
-    const client = new ApiClient(credentials);
-    const { workspaceId } = await resolveWorkspace(client, opts);
-    try {
-        const data = await parseDataInput(opts.data);
-        const result = await client.updateEntityRecord(workspaceId, entity, id, data);
-        if (useJson) {
-            jsonOut(result);
-            return;
-        }
-        console.log('Record updated:');
-        console.log(JSON.stringify(result.item, null, 2));
-    }
-    catch (err) {
-        console.error('Failed to update entity record:', err instanceof Error ? err.message : err);
-        process.exit(1);
-    }
-});
-const deleteCommand = new Command('delete')
-    .description('Delete an entity record')
-    .argument('<entity>', 'Entity name')
-    .argument('<id>', 'Record ID')
-    .option('--workspace <id>', 'Workspace ID')
-    .option('--yes', 'Skip confirmation prompt')
-    .action(async (entity, id, opts, command) => {
-    const useJson = shouldOutputJson(command.optsWithGlobals().json);
-    const credentials = requireAuth();
-    const client = new ApiClient(credentials);
-    const { workspaceId } = await resolveWorkspace(client, opts);
-    try {
-        if (!opts.yes) {
-            const confirmed = await promptConfirm(`Delete record "${id}" from entity "${entity}"? This cannot be undone.`);
-            if (!confirmed) {
-                console.log('Cancelled.');
-                return;
-            }
-        }
-        const result = await client.deleteEntityRecord(workspaceId, entity, id);
-        if (useJson) {
-            jsonOut(result);
-            return;
-        }
-        console.log(`Record "${id}" deleted from entity "${entity}".`);
-    }
-    catch (err) {
-        console.error('Failed to delete entity record:', err instanceof Error ? err.message : err);
-        process.exit(1);
-    }
-});
-export const entitiesCommand = new Command('entities')
-    .alias('data')
-    .description('Manage workspace entity data')
-    .addCommand(listCommand)
-    .addCommand(recordsCommand)
-    .addCommand(getCommand)
-    .addCommand(createCommand)
-    .addCommand(updateCommand)
-    .addCommand(deleteCommand);

package/dist/commands/files.d.ts

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