runwork 0.4.0 → 0.5.0

package/dist/generated/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.4.0";
+export declare const VERSION = "0.5.0";

package/dist/generated/version.js

@@ -1,2 +1,2 @@
 // Auto-generated by scripts/embed-types.ts -- do not edit
-export const VERSION = "0.4.0";
+export const VERSION = "0.5.0";

package/dist/index.js

@@ -10,6 +10,19 @@ import { logoutCommand } from './commands/logout.js';
 import { integrationsCommand } from './commands/integrations.js';
 import { openCommand } from './commands/open.js';
 import { infoCommand } from './commands/info.js';
+import { skillsCommand } from './commands/skills.js';
+import { entitiesCommand } from './commands/entities.js';
+import { workflowsCommand } from './commands/workflows.js';
+import { schedulesCommand } from './commands/schedules.js';
+import { endpointsCommand } from './commands/endpoints.js';
+import { filesCommand } from './commands/files.js';
+import { componentsCommand } from './commands/components.js';
+import { apiKeysCommand } from './commands/api-keys.js';
+import { agentsCommand } from './commands/agents.js';
+import { mcpCommand } from './commands/mcp.js';
+import { setupCommand } from './commands/setup.js';
+import { syncCommand } from './commands/sync.js';
+import { appsCommand } from './commands/apps.js';
 import { handleGitCredentialRequest } from './git/credentials.js';
 import { VERSION } from './generated/version.js';
 const program = new Command();
@@ -30,6 +43,19 @@ program.addCommand(upgradeCommand);
 program.addCommand(logoutCommand);
 program.addCommand(integrationsCommand);
 program.addCommand(openCommand);
+program.addCommand(skillsCommand);
+program.addCommand(entitiesCommand);
+program.addCommand(workflowsCommand);
+program.addCommand(schedulesCommand);
+program.addCommand(endpointsCommand);
+program.addCommand(filesCommand);
+program.addCommand(componentsCommand);
+program.addCommand(apiKeysCommand);
+program.addCommand(agentsCommand);
+program.addCommand(mcpCommand);
+program.addCommand(setupCommand);
+program.addCommand(syncCommand);
+program.addCommand(appsCommand);
 program.addHelpText('after', '\nFor AI agents: run "runwork info --json" to discover app context and available commands.');
 const credentialHelper = program
     .command('git-credential-helper', { hidden: true })

package/dist/logs/tailer.js

@@ -54,6 +54,9 @@ export function startLogTailer(options) {
     let seenEventIds = new Set();
     let stopped = false;
     let timer;
+    let consecutiveEmptyPolls = 0;
+    let paused = false;
+    const PAUSE_THRESHOLD = 60; // ~5 minutes at 5s interval
     function writeLineFiltered(line, tag, jsonData) {
         // Always write to file (stripped of ANSI codes)
         if (toFile) {
@@ -82,6 +85,8 @@ export function startLogTailer(options) {
     async function poll() {
         if (stopped)
             return;
+        const prevStdoutLength = lastStdoutLength;
+        const prevStderrLength = lastStderrLength;
         try {
             // Poll preview logs (stdout/stderr)
             const logs = await client.getPreviewLogs(appId);
@@ -116,6 +121,7 @@ export function startLogTailer(options) {
         catch {
             // Silently ignore - sandbox may not be ready yet
         }
+        let hadNewEvents = false;
         try {
             // Poll app events
             const eventOptions = { limit: 20 };
@@ -147,6 +153,7 @@ export function startLogTailer(options) {
                     writeLineFiltered(`  ${relTime} ${yellow('EVENT  ')}  ${event.type}: ${detail}`, 'EVENT', {
                         event: 'log', type: 'event', eventType: event.type, detail, metadata: event.metadata || {}, timestamp: event.timestamp,
                     });
+                    hadNewEvents = true;
                     seenEventIds.add(event.id);
                 }
                 // Cap the set size to prevent unbounded growth (keep last 200 IDs)
@@ -159,12 +166,39 @@ export function startLogTailer(options) {
         catch {
             // Silently ignore - events endpoint may not be available
         }
-        if (!stopped) {
+        const hadNewLogs = lastStdoutLength > prevStdoutLength ||
+            lastStderrLength > prevStderrLength;
+        if (hadNewLogs || hadNewEvents) {
+            consecutiveEmptyPolls = 0;
+        }
+        else {
+            consecutiveEmptyPolls++;
+        }
+        if (consecutiveEmptyPolls >= PAUSE_THRESHOLD && !paused) {
+            paused = true;
+            if (toTerminal) {
+                console.log(formatLogLine('INFO', dim('No new output for 5 minutes. Polling paused. Press Enter to resume.')));
+            }
+        }
+        if (!stopped && !paused) {
             timer = setTimeout(poll, intervalMs);
         }
     }
     // Initial poll after a short delay to let sandbox start
     timer = setTimeout(poll, 2000);
+    let stdinHandler;
+    if (toTerminal && process.stdin.isTTY) {
+        process.stdin.resume();
+        stdinHandler = () => {
+            if (paused && !stopped) {
+                paused = false;
+                consecutiveEmptyPolls = 0;
+                console.log(formatLogLine('INFO', 'Polling resumed.'));
+                timer = setTimeout(poll, 0);
+            }
+        };
+        process.stdin.on('data', stdinHandler);
+    }
     return {
         stop() {
             stopped = true;
@@ -172,6 +206,12 @@ export function startLogTailer(options) {
                 clearTimeout(timer);
                 timer = undefined;
             }
+            if (toTerminal && process.stdin.isTTY) {
+                if (stdinHandler) {
+                    process.stdin.off('data', stdinHandler);
+                }
+                process.stdin.pause();
+            }
         },
     };
 }

package/dist/types.d.ts

@@ -8,6 +8,8 @@ export interface Credentials {
     apiKey: string;
     email: string;
     baseUrl: string;
+    defaultWorkspaceId?: string;
+    defaultWorkspaceName?: string;
 }
 export interface DevSession {
     sessionId: string;
@@ -84,3 +86,205 @@ export interface WorkspaceAllData {
     components: RegistryComponent[];
     fileStorages: RegistryFileStorage[];
 }
+export interface WorkspaceSkill {
+    id: string;
+    name: string;
+    description?: string;
+    type: 'app' | 'external' | 'mcp';
+    appId?: string;
+    mcpServerId?: string;
+}
+export interface ExternalSkillRegistration {
+    id: string;
+    name: string;
+    description: string;
+    content: string;
+    apiEndpoints?: Array<{
+        url: string;
+        method: string;
+        description: string;
+    }>;
+    importedFrom: string;
+    importedAt: number;
+    importedBy: string;
+}
+export interface McpServerConfig {
+    id: string;
+    name: string;
+    url: string;
+    transport: 'sse' | 'streamable-http';
+    enabled: boolean;
+    addedAt: number;
+    addedBy: string;
+    lastConnectedAt?: number;
+    toolCount?: number;
+}
+export interface SetupState {
+    workspaceId: string;
+    workspaceName: string;
+    configuredAgents: string[];
+    scope: 'project' | 'user' | 'both';
+    lastSyncAt: string;
+    mcpServers: string[];
+    skills: string[];
+}
+export interface WorkflowInfo {
+    name: string;
+    appId: string;
+    appName: string;
+    description?: string;
+    enabled?: boolean;
+    deploymentMode?: 'preview' | 'production';
+}
+export interface TriggerWorkflowResponse {
+    instanceId: string;
+    status: string;
+}
+export interface WorkflowInstance {
+    id: string;
+    workflowName: string;
+    status: string;
+    appId: string;
+    createdAt?: string;
+    completedAt?: string;
+}
+export interface WorkflowInstancesData {
+    instances: WorkflowInstance[];
+}
+export interface WorkflowInstanceDetailData {
+    instance: WorkflowInstance & {
+        steps?: Array<{
+            name: string;
+            status: string;
+            output?: unknown;
+        }>;
+        params?: Record<string, unknown>;
+    };
+}
+export interface ScheduleInfo {
+    name: string;
+    appId: string;
+    appName: string;
+    schedule?: string;
+    description?: string;
+    deploymentMode?: 'preview' | 'production';
+    status?: string;
+    nextRun?: string;
+    lastRun?: string;
+}
+export interface TriggerScheduleResponse {
+    success: boolean;
+    message?: string;
+}
+export interface ScheduleHistoryEntry {
+    scheduleName: string;
+    executedAt: string;
+    status: string;
+    durationMs?: number;
+    error?: string;
+}
+export interface ScheduleHistoryData {
+    history: ScheduleHistoryEntry[];
+}
+export interface FileStorageInfo {
+    id: string;
+    appId: string;
+    appName: string;
+    workspaceId: string;
+    bucketName: string;
+    bucketStatus: string;
+    objectCount?: number;
+    totalSizeBytes?: number;
+    connectedApps?: string[];
+    deploymentMode?: 'preview' | 'production';
+}
+export interface BucketFile {
+    key: string;
+    size?: number;
+    lastModified?: string;
+    etag?: string;
+}
+export interface BucketFolder {
+    prefix: string;
+}
+export interface ListBucketFilesData {
+    files: BucketFile[];
+    folders: BucketFolder[];
+    truncated?: boolean;
+    cursor?: string;
+}
+export interface WorkspaceEndpoint {
+    appId: string;
+    appName?: string;
+    endpointPath: string;
+    method: string;
+    auth?: string;
+    description?: string;
+    tags?: string[];
+    schema?: Record<string, unknown>;
+    deploymentMode?: 'preview' | 'production';
+}
+export interface ComponentInfo {
+    componentName: string;
+    appId: string;
+    appName: string;
+    deploymentMode?: 'preview' | 'production';
+    metadata?: {
+        tag?: string;
+        description?: string;
+        attributes?: Record<string, unknown>;
+    };
+}
+export interface ApiKeyInfo {
+    id: string;
+    name: string;
+    keyPrefix: string;
+    appId?: string;
+    allowedEndpoints?: string[];
+    scopes?: string[];
+    isActive: boolean;
+    requestCount?: number;
+    lastUsedAt?: string;
+    expiresAt?: string;
+    createdAt: string;
+}
+export interface ApiKeyCreateResponse {
+    id: string;
+    name: string;
+    key: string;
+    keyPrefix: string;
+}
+export interface AgentInfo {
+    agentName: string;
+    description: string;
+    type: 'conversational' | 'task';
+    integrations: string[];
+    entities: string[];
+    appId: string;
+    appName: string;
+    deploymentMode?: 'preview' | 'production';
+}
+export interface AgentStatusResponse {
+    agentName: string;
+    status: string;
+    [key: string]: unknown;
+}
+export interface AgentExecutionRecord {
+    executionId: string;
+    sessionId: string;
+    appId: string;
+    agentName: string;
+    prompt: string;
+    status: 'running' | 'completed' | 'partial' | 'error' | 'timeout';
+    responseSummary?: string;
+    outputFileCount?: number;
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+        cost: number;
+    };
+    exitCode?: number;
+    startedAt: string;
+    completedAt?: string;
+    durationMs?: number;
+}

package/dist/ui/banner.js

@@ -64,19 +64,20 @@ export async function runAgentWizard(directory) {
     const agent = SUPPORTED_AGENTS.find(a => a.id === result);
     if (!agent)
         return;
-    const cmd = agent.command.replace(/{dir}/g, directory);
+    const slug = directory.split('/').pop() || directory;
+    const agentCmd = agent.command.replace(/{dir}/g, slug);
     console.log('');
-    console.log(bold(`Open your app in ${agent.name}:`));
-    console.log('');
-    console.log(`  ${cyan(cmd)}`);
+    console.log(bold('Get started:'));
     console.log('');
+    console.log(`  ${dim('1.')} cd ${slug} && runwork dev`);
     if (agent.id === 'claude-desktop') {
+        console.log(`  ${dim('2.')} ${agentCmd}`);
+        console.log('');
         console.log(dim('  Claude Desktop works with project folders. Add your app directory'));
         console.log(dim('  as a project and Claude will have full context of your Runwork app.'));
     }
     else {
-        console.log(dim('  Run this in a separate terminal while `runwork dev` is running.'));
-        console.log(dim('  Your AI agent will have full access to your app code and types.'));
+        console.log(`  ${dim('2.')} ${cyan(agentCmd)}  ${dim('(in a second terminal)')}`);
     }
     console.log('');
 }

package/dist/utils/app-info.d.ts

@@ -0,0 +1,66 @@
+import { ApiClient } from '../api/client.js';
+import type { WorkspaceAllData } from '../types.js';
+export interface AppInfoData {
+    app: {
+        id: string;
+        name: string;
+        slug: string;
+    };
+    workspace: {
+        id: string;
+        name: string;
+    };
+    preview: {
+        url: string | null;
+        active: boolean;
+    };
+    dashboardUrl: string;
+    gitRemoteUrl: string;
+    registries: AppRegistries | null;
+}
+export interface AppRegistries {
+    entities: Array<{
+        name: string;
+        deploymentMode?: string;
+    }>;
+    workflows: Array<{
+        name: string;
+        description?: string;
+        deploymentMode?: string;
+    }>;
+    scheduledJobs: Array<{
+        name: string;
+        schedule?: string;
+        deploymentMode?: string;
+    }>;
+    agents: Array<{
+        name: string;
+        type?: string;
+        description?: string;
+        deploymentMode?: string;
+    }>;
+    publicEndpoints: Array<{
+        path: string;
+        method?: string;
+        description?: string;
+        deploymentMode?: string;
+    }>;
+    components: Array<{
+        name: string;
+        deploymentMode?: string;
+    }>;
+    fileStorage: boolean;
+}
+/**
+ * Fetch app-specific info from the API.
+ * Optionally accepts pre-fetched serverData to avoid duplicate getWorkspaceAll calls.
+ */
+export declare function fetchAppInfo(client: ApiClient, opts: {
+    appId: string;
+    appName: string;
+    appSlug: string;
+    workspaceId: string;
+    workspaceName: string;
+    baseUrl: string;
+}, serverData?: WorkspaceAllData | null): Promise<AppInfoData>;
+export declare function printAppInfo(data: AppInfoData): void;

package/dist/utils/app-info.js

@@ -0,0 +1,150 @@
+import { bold, cyan, dim, green, gray } from '../ui/colors.js';
+/**
+ * Fetch app-specific info from the API.
+ * Optionally accepts pre-fetched serverData to avoid duplicate getWorkspaceAll calls.
+ */
+export async function fetchAppInfo(client, opts, serverData) {
+    let preview = { url: null, active: false };
+    try {
+        const status = await client.getDevStatus(opts.appId);
+        if (status.previewUrl) {
+            preview = { url: status.previewUrl, active: true };
+        }
+    }
+    catch {
+        // No active dev session
+    }
+    let registries = null;
+    const data = serverData !== undefined ? serverData : await fetchServerData(client, opts.workspaceId);
+    if (data) {
+        registries = filterRegistriesToApp(data, opts.appId);
+    }
+    return {
+        app: { id: opts.appId, name: opts.appName, slug: opts.appSlug },
+        workspace: { id: opts.workspaceId, name: opts.workspaceName },
+        preview,
+        dashboardUrl: `${opts.baseUrl}/chat/${opts.appId}`,
+        gitRemoteUrl: client.getGitRemoteUrl(opts.workspaceId, opts.appId),
+        registries,
+    };
+}
+async function fetchServerData(client, workspaceId) {
+    try {
+        return await client.getWorkspaceAll(workspaceId);
+    }
+    catch {
+        return null;
+    }
+}
+function filterRegistriesToApp(data, appId) {
+    return {
+        entities: data.entities.filter(e => e.appId === appId).map(e => ({
+            name: e.entityName, deploymentMode: e.deploymentMode,
+        })),
+        workflows: data.workflows.filter(w => w.appId === appId).map(w => ({
+            name: w.name, description: w.description, deploymentMode: w.deploymentMode,
+        })),
+        scheduledJobs: data.schedules.filter(s => s.appId === appId).map(s => ({
+            name: s.name, schedule: s.schedule, deploymentMode: s.deploymentMode,
+        })),
+        agents: data.agents.filter(a => a.appId === appId).map(a => ({
+            name: a.name, type: a.type, description: a.description, deploymentMode: a.deploymentMode,
+        })),
+        publicEndpoints: data.endpoints.filter(e => e.appId === appId).map(e => ({
+            path: e.path, method: e.method, description: e.description, deploymentMode: e.deploymentMode,
+        })),
+        components: data.components.filter(c => c.appId === appId).map(c => ({
+            name: c.componentName, deploymentMode: c.deploymentMode,
+        })),
+        fileStorage: data.fileStorages.some(f => f.appId === appId),
+    };
+}
+function formatMode(mode) {
+    if (mode === 'production')
+        return green('prod');
+    if (mode === 'preview')
+        return dim('preview');
+    return '';
+}
+export function printAppInfo(data) {
+    const pad = (label) => label.padEnd(14);
+    console.log('');
+    console.log(bold('App'));
+    console.log('');
+    console.log(`  ${dim(pad('Name:'))}${bold(data.app.name)}`);
+    console.log(`  ${dim(pad('ID:'))}${data.app.id}`);
+    console.log(`  ${dim(pad('Workspace:'))}${data.workspace.name || data.workspace.id}`);
+    console.log(`  ${dim(pad('Dashboard:'))}${cyan(data.dashboardUrl)}`);
+    console.log(`  ${dim(pad('Git Remote:'))}${data.gitRemoteUrl}`);
+    if (data.preview.url) {
+        console.log(`  ${dim(pad('Preview:'))}${green(data.preview.url)} ${dim('(running)')}`);
+    }
+    else {
+        console.log(`  ${dim(pad('Preview:'))}${dim('(not running)')}`);
+    }
+    const reg = data.registries;
+    if (!reg) {
+        console.log('');
+        return;
+    }
+    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;
+    if (!hasAny) {
+        console.log('');
+        return;
+    }
+    console.log('');
+    console.log(bold('Registries'));
+    console.log('');
+    if (reg.entities.length > 0) {
+        console.log(`  ${bold('Entities:')}`);
+        for (const e of reg.entities) {
+            console.log(`    ${e.name.padEnd(24)} ${formatMode(e.deploymentMode)}`);
+        }
+        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)} ${formatMode(w.deploymentMode)}${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)} ${formatMode(s.deploymentMode)}${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)} ${formatMode(a.deploymentMode)}${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)} ${formatMode(e.deploymentMode)}`);
+        }
+        console.log('');
+    }
+    if (reg.components.length > 0) {
+        console.log(`  ${bold('Components:')}`);
+        for (const c of reg.components) {
+            console.log(`    ${c.name.padEnd(24)} ${formatMode(c.deploymentMode)}`);
+        }
+        console.log('');
+    }
+    if (reg.fileStorage) {
+        console.log(`  ${bold('File Storage:')}       ${green('enabled')}`);
+        console.log('');
+    }
+}

package/dist/utils/curl-parser.d.ts

@@ -0,0 +1,12 @@
+export interface ParsedRequest {
+    method: string;
+    path: string;
+    query?: string;
+    headers: Record<string, string>;
+    body?: unknown;
+}
+/**
+ * Parse a curl command string into a structured request.
+ * Uses curlconverter for robust parsing of all curl flag combinations.
+ */
+export declare function parseCurlToRequest(curlStr: string): Promise<ParsedRequest>;

package/dist/utils/curl-parser.js

@@ -0,0 +1,44 @@
+import { toJsonString } from 'curlconverter';
+/** Headers that should be stripped — the integration proxy handles auth */
+const STRIPPED_HEADERS = new Set(['host', 'authorization', 'cookie', 'connection', 'user-agent']);
+/**
+ * Parse a curl command string into a structured request.
+ * Uses curlconverter for robust parsing of all curl flag combinations.
+ */
+export async function parseCurlToRequest(curlStr) {
+    const raw = toJsonString(curlStr);
+    const parsed = JSON.parse(raw);
+    if (!parsed.url) {
+        throw new Error('Could not parse curl command -- no URL found.');
+    }
+    const method = (parsed.method || 'GET').toUpperCase();
+    // Extract path and query from full URL
+    const parsedUrl = new URL(parsed.raw_url || parsed.url);
+    const path = parsedUrl.pathname;
+    const query = parsedUrl.search ? parsedUrl.search.slice(1) : undefined;
+    // Copy headers, stripping proxy-managed ones
+    const headers = {};
+    if (parsed.headers) {
+        for (const [key, val] of Object.entries(parsed.headers)) {
+            if (!STRIPPED_HEADERS.has(key.toLowerCase())) {
+                headers[key] = val;
+            }
+        }
+    }
+    // Parse body
+    let body;
+    if (parsed.data) {
+        if (typeof parsed.data === 'string') {
+            try {
+                body = JSON.parse(parsed.data);
+            }
+            catch {
+                body = parsed.data;
+            }
+        }
+        else {
+            body = parsed.data;
+        }
+    }
+    return { method, path, query, headers, body };
+}

package/dist/utils/data-input.d.ts

@@ -0,0 +1 @@
+export declare function parseDataInput(dataFlag?: string): Promise<Record<string, unknown>>;

package/dist/utils/data-input.js

@@ -0,0 +1,38 @@
+import { readFileSync, existsSync } from 'fs';
+export async function parseDataInput(dataFlag) {
+    if (dataFlag) {
+        if (dataFlag.startsWith('@')) {
+            const filePath = dataFlag.slice(1);
+            if (!existsSync(filePath)) {
+                console.error(`File not found: ${filePath}`);
+                process.exit(1);
+            }
+            const content = readFileSync(filePath, 'utf-8');
+            return parseJson(content, filePath);
+        }
+        return parseJson(dataFlag, '--data');
+    }
+    if (!process.stdin.isTTY) {
+        const chunks = [];
+        for await (const chunk of process.stdin) {
+            chunks.push(chunk);
+        }
+        const content = Buffer.concat(chunks).toString('utf-8').trim();
+        if (!content) {
+            console.error('No data provided via stdin.');
+            process.exit(1);
+        }
+        return parseJson(content, 'stdin');
+    }
+    console.error('No data provided. Use --data \'{"key": "value"}\', --data @file.json, or pipe JSON via stdin.');
+    process.exit(1);
+}
+function parseJson(content, source) {
+    try {
+        return JSON.parse(content);
+    }
+    catch {
+        console.error(`Invalid JSON from ${source}: ${content.slice(0, 100)}`);
+        process.exit(1);
+    }
+}