runwork 0.2.5 → 0.4.0

package/dist/api/client.d.ts

@@ -1,4 +1,4 @@
-import type { Credentials, AppInfo, WorkspaceInfo, DevSession } from '../types.js';
+import type { Credentials, AppInfo, WorkspaceInfo, DevSession, WorkspaceAllData } from '../types.js';
 export declare class ApiClient {
     private baseUrl;
     private apiKey;
@@ -90,5 +90,6 @@ export declare class ApiClient {
      * Both canonical ({baseUrl}/api/git/{workspaceId}/{appId}) and
      * subdomain ({slug}.runwork.ai/api/git/{appId}) formats are supported.
      */
+    getWorkspaceAll(workspaceId: string): Promise<WorkspaceAllData>;
     getGitRemoteUrl(workspaceId: string, appId: string): string;
 }

package/dist/api/client.js

@@ -147,6 +147,10 @@ export class ApiClient {
      * Both canonical ({baseUrl}/api/git/{workspaceId}/{appId}) and
      * subdomain ({slug}.runwork.ai/api/git/{appId}) formats are supported.
      */
+    async getWorkspaceAll(workspaceId) {
+        const res = await this.request(`/api/workspaces/${workspaceId}/all`);
+        return res.data;
+    }
     getGitRemoteUrl(workspaceId, appId) {
         return `${this.baseUrl}/api/git/${workspaceId}/${appId}`;
     }

package/dist/auth/login-flow.d.ts

@@ -0,0 +1,10 @@
+import type { Credentials } from '../types.js';
+/**
+ * Performs the full browser-based login flow:
+ * 1. Initiates login, opens browser
+ * 2. Polls for completion
+ * 3. Saves credentials and configures git
+ *
+ * Returns the credentials on success, exits process on timeout.
+ */
+export declare function performLogin(baseUrl?: string): Promise<Credentials>;

package/dist/auth/login-flow.js

@@ -0,0 +1,37 @@
+import { ApiClient } from '../api/client.js';
+import { saveCredentials } from './store.js';
+import { configureGitCredentials } from '../git/credentials.js';
+const DEFAULT_BASE_URL = 'https://runwork.ai';
+/**
+ * Performs the full browser-based login flow:
+ * 1. Initiates login, opens browser
+ * 2. Polls for completion
+ * 3. Saves credentials and configures git
+ *
+ * Returns the credentials on success, exits process on timeout.
+ */
+export async function performLogin(baseUrl) {
+    const url = baseUrl || DEFAULT_BASE_URL;
+    const client = new ApiClient({ apiKey: '', email: '', baseUrl: url });
+    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('');
+    console.log('Waiting for authentication...');
+    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 || url);
+            console.log(`Logged in as ${result.email}`);
+            return result;
+        }
+    }
+    console.error('Login timed out. Please try again.');
+    process.exit(1);
+}

package/dist/commands/clone.d.ts

@@ -1,2 +1,5 @@
 import { Command } from 'commander';
+import { ApiClient } from '../api/client.js';
+import type { AppInfo } from '../types.js';
+export declare function execClone(client: ApiClient, app: AppInfo, directory?: string): Promise<string>;
 export declare const cloneCommand: Command;

package/dist/commands/clone.js

@@ -1,37 +1,18 @@
 import { Command } from 'commander';
 import { execFileSync } from 'child_process';
 import { writeFileSync, mkdirSync, existsSync } 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 } 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 cloneCommand = new Command('clone')
-    .description('Clone a Runwork app to local development')
-    .argument('[appId]', 'App ID to clone (interactive if omitted)')
-    .argument('[directory]', 'Target directory')
-    .action(async (appId, directory) => {
-    const creds = requireAuth();
-    const client = new ApiClient(creds);
-    let app;
-    if (appId) {
-        app = await client.getApp(appId);
-    }
-    else {
-        const apps = await client.listApps();
-        if (apps.length === 0) {
-            console.error('No apps found.');
-            process.exit(1);
-        }
-        const choice = await promptSelect('Select app to clone:', apps.map(a => ({ label: `${a.name} (${a.workspaceName})`, value: a })));
-        app = choice.value;
-    }
+import { runAgentWizard } from '../ui/banner.js';
+export async function execClone(client, app, directory) {
     const slug = app.slug || app.name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
     const dir = directory || slug;
     const remoteUrl = client.getGitRemoteUrl(app.workspaceId, app.id);
-    console.log(`Cloning "${app.name}"...`);
     // Step 1: Extract skeleton template as the base layer
     console.log('Downloading project template...');
     mkdirSync(dir, { recursive: true });
@@ -70,6 +51,7 @@ export const cloneCommand = new Command('clone')
     // Write .runwork.json config
     const config = {
         workspaceId: app.workspaceId,
+        workspaceName: app.workspaceName,
         appId: app.id,
         appName: app.name,
     };
@@ -85,6 +67,32 @@ export const cloneCommand = new Command('clone')
         // App may be new with no registries yet
     }
     console.log(`\nApp "${app.name}" cloned to ${dir}/`);
-    console.log(`Remote: ${remoteUrl}`);
-    console.log(`\nNext: cd ${dir} && runwork dev`);
+    console.log(`Remote: ${client.getGitRemoteUrl(app.workspaceId, app.id)}`);
+    return resolve(dir);
+}
+export const cloneCommand = new Command('clone')
+    .description('Clone a Runwork app to local development')
+    .argument('[appId]', 'App ID to clone (interactive if omitted)')
+    .argument('[directory]', 'Target directory')
+    .action(async (appId, directory) => {
+    const creds = requireAuth();
+    const client = new ApiClient(creds);
+    let app;
+    if (appId) {
+        app = await client.getApp(appId);
+    }
+    else {
+        const apps = await client.listApps();
+        if (apps.length === 0) {
+            console.error('No apps found.');
+            process.exit(1);
+        }
+        const choice = await promptSelect('Select app to clone:', apps.map(a => ({ label: `${a.name} (${a.workspaceName})`, value: a })));
+        app = choice.value;
+    }
+    console.log(`Cloning "${app.name}"...`);
+    const dir = await execClone(client, app, directory);
+    const slug = dir.split('/').pop() || dir;
+    await runAgentWizard(dir);
+    console.log(`Next: cd ${slug} && runwork dev`);
 });

package/dist/commands/deploy.js

@@ -3,10 +3,16 @@ import { execFileSync } from 'child_process';
 import { readFileSync, existsSync } from 'fs';
 import { requireAuth } from '../auth/store.js';
 import { ApiClient } from '../api/client.js';
+import { shouldOutputJson, jsonOut } from '../utils/output.js';
 export const deployCommand = new Command('deploy')
-    .description('Deploy the current app to Runwork')
-    .action(async () => {
+    .description('Deploy the current app to production')
+    .action(async (_opts, command) => {
+    const useJson = shouldOutputJson(command.optsWithGlobals().json);
     if (!existsSync('.runwork.json')) {
+        if (useJson) {
+            process.stderr.write(JSON.stringify({ error: 'No .runwork.json found. Run `runwork init` first.' }) + '\n');
+            process.exit(1);
+        }
         console.error('No .runwork.json found. Run `runwork init` first.');
         process.exit(1);
     }
@@ -23,21 +29,32 @@ export const deployCommand = new Command('deploy')
         // No commits yet
     }
     if (repoHasCommits) {
-        console.log('Syncing...');
+        if (!useJson)
+            console.log('Syncing...');
         try {
-            execFileSync('git', ['pull', '--rebase', 'runwork', 'main'], { stdio: 'inherit' });
+            execFileSync('git', ['pull', '--rebase', 'runwork', 'main'], { stdio: useJson ? 'pipe' : 'inherit' });
         }
         catch {
-            console.warn('Pull failed. Continuing...');
+            if (!useJson)
+                console.warn('Pull failed. Continuing...');
         }
-        execFileSync('git', ['push', 'runwork', 'main'], { stdio: 'inherit' });
+        execFileSync('git', ['push', 'runwork', 'main'], { stdio: useJson ? 'pipe' : 'inherit' });
     }
     else {
+        if (useJson) {
+            process.stderr.write(JSON.stringify({ error: 'No commits to deploy. Commit your changes first.' }) + '\n');
+            process.exit(1);
+        }
         console.error('No commits to deploy. Commit your changes first.');
         process.exit(1);
     }
     // Trigger deploy
-    console.log('Deploying...');
+    if (!useJson)
+        console.log('Deploying...');
     const result = await client.triggerDeploy(config.appId);
+    if (useJson) {
+        jsonOut({ deployed: true, url: result.deploymentUrl });
+        return;
+    }
     console.log(`Deployed: ${result.deploymentUrl}`);
 });

package/dist/commands/dev.d.ts

@@ -1,2 +1,7 @@
 import { Command } from 'commander';
+export declare function execDev(options?: {
+    logs?: boolean;
+    logsOnlyFile?: boolean;
+    json?: boolean;
+}): Promise<void>;
 export declare const devCommand: Command;

package/dist/commands/dev.js

@@ -11,6 +11,11 @@ import { populateTypes } from '../types-manager.js';
 import { loadManifest, generateManifest, saveManifest, detectUserEdits } from '../template/manifest.js';
 import { extractZip } from '../utils/zip.js';
 import { removeNestedGitDirs } from '../utils/fs.js';
+import { getDevBanner, getKeyboardHints, getInfoPanel } from '../ui/banner.js';
+import { createStatusLine } from '../ui/status-line.js';
+import { createKeyboardListener } from '../ui/keyboard.js';
+import { bold, dim, green, yellow, cyan } from '../ui/colors.js';
+import { shouldOutputJson, jsonLine } from '../utils/output.js';
 async function populateSkill(projectDir, client, appId) {
     try {
         const { skill } = await client.getAppSkill(appId);
@@ -29,23 +34,26 @@ function readConfig() {
     }
     return JSON.parse(readFileSync('.runwork.json', 'utf-8'));
 }
-export const devCommand = new Command('dev')
-    .description('Start local development server with live sync')
-    .option('--no-logs', 'Disable automatic log tailing')
-    .option('--logs-only-file', 'Write logs to file only, not terminal')
-    .action(async (options) => {
+export async function execDev(options) {
+    const useJson = options?.json ?? false;
     const config = readConfig();
     const creds = requireAuth();
     const client = new ApiClient(creds);
     const cwd = process.cwd();
+    const ts = () => new Date().toISOString();
     // Detect user edits made outside of `runwork dev`
     const oldManifest = await loadManifest(cwd);
     if (oldManifest) {
         const userEdits = await detectUserEdits(cwd, oldManifest);
         if (userEdits.length > 0) {
-            console.log(`Detected ${userEdits.length} file(s) edited outside dev session:`);
-            for (const file of userEdits) {
-                console.log(`  ${file}`);
+            if (useJson) {
+                jsonLine({ event: 'startup', phase: 'user_edits_detected', files: userEdits, timestamp: ts() });
+            }
+            else {
+                console.log(`Detected ${userEdits.length} file(s) edited outside dev session:`);
+                for (const file of userEdits) {
+                    console.log(`  ${file}`);
+                }
             }
             try {
                 execFileSync('git', ['add', '--', ...userEdits], { stdio: 'pipe' });
@@ -57,15 +65,18 @@ export const devCommand = new Command('dev')
         }
     }
     // Download fresh template to ensure latest version
-    console.log('Updating template...');
+    if (useJson) {
+        jsonLine({ event: 'startup', phase: 'template_update', timestamp: ts() });
+    }
+    else {
+        console.log(dim('Updating template...'));
+    }
     try {
         const zipData = await client.downloadSkeleton();
         extractZip(zipData, cwd);
         removeNestedGitDirs(cwd);
-        // Generate new manifest from fresh template (before restoring user files)
         const newManifest = await generateManifest(cwd);
         await saveManifest(cwd, newManifest);
-        // Restore user-edited files from git on top of fresh template
         try {
             execFileSync('git', ['checkout', '--', '.'], { cwd, stdio: 'pipe' });
         }
@@ -74,65 +85,160 @@ export const devCommand = new Command('dev')
         }
     }
     catch {
-        console.warn('Template update failed. Continuing with current files.');
+        if (!useJson)
+            console.warn(yellow('Template update failed. Continuing with current files.'));
     }
     // Populate type definitions
     await populateTypes(cwd);
-    // Start dev session first - this triggers DO onStart which may create remote commits
-    console.log('Starting dev session...');
+    if (useJson)
+        jsonLine({ event: 'startup', phase: 'types_populated', timestamp: ts() });
+    // Start dev session
+    if (useJson) {
+        jsonLine({ event: 'startup', phase: 'dev_session', timestamp: ts() });
+    }
+    else {
+        console.log(dim('Starting dev session...'));
+    }
     const session = await client.startDevSession(config.appId);
-    console.log(`Preview: ${session.previewUrl}`);
-    // Fetch SKILL.md (best-effort, after session so DO registries are available)
+    // Fetch SKILL.md (best-effort)
     await populateSkill(cwd, client, config.appId);
-    // Sync AFTER starting session so we pick up any commits the DO created
-    console.log('Syncing with Runwork...');
+    if (useJson)
+        jsonLine({ event: 'startup', phase: 'skill_fetched', timestamp: ts() });
+    // Sync
+    if (!useJson)
+        console.log(dim('Syncing...'));
     const syncResult = syncWithRemote(cwd);
-    switch (syncResult.status) {
-        case 'skipped':
-            console.log('No commits yet. Skipping sync.');
-            break;
-        case 'synced':
-            console.log('Synced with Runwork.');
-            break;
-        case 'merged':
-            console.log('Merged with Runwork (histories diverged).');
-            break;
-        case 'sync-failed':
-            if (syncResult.error === 'stash-conflict') {
-                console.error('Merge conflicts detected after stash pop. Resolve conflicts and restart.');
-                process.exit(1);
-            }
-            console.warn('Pull failed (remote may not have commits yet). Continuing...');
-            break;
+    if (useJson) {
+        jsonLine({ event: 'startup', phase: 'sync', status: syncResult.status, pushed: syncResult.pushed, timestamp: ts() });
     }
-    if (!syncResult.pushed && syncResult.status !== 'skipped' && syncResult.status !== 'sync-failed') {
-        console.warn('Push failed. Continuing with current state...');
+    else {
+        switch (syncResult.status) {
+            case 'skipped':
+                console.log(dim('  No commits yet. Skipping sync.'));
+                break;
+            case 'synced':
+                console.log(green('  Synced with Runwork.'));
+                break;
+            case 'merged':
+                console.log(yellow('  Merged with Runwork (histories diverged).'));
+                break;
+            case 'sync-failed':
+                if (syncResult.error === 'stash-conflict') {
+                    console.error('Merge conflicts detected after stash pop. Resolve conflicts and restart.');
+                    process.exit(1);
+                }
+                console.warn(yellow(`Sync failed. Continuing...`));
+                if (syncResult.error) {
+                    console.warn(dim(`  ${syncResult.error}`));
+                }
+                break;
+        }
+        if (!syncResult.pushed && syncResult.status !== 'skipped' && syncResult.status !== 'sync-failed') {
+            console.warn(yellow('Push failed. Continuing with current state...'));
+        }
     }
-    // Declare logTailer before cleanup so cleanup can reference it
+    // Emit session_started (JSON) or show banner (human)
+    if (useJson) {
+        jsonLine({ event: 'session_started', previewUrl: session.previewUrl, appName: config.appName, timestamp: ts() });
+    }
+    else {
+        console.log(getDevBanner({ appName: config.appName, previewUrl: session.previewUrl, workspaceName: config.workspaceName }));
+        console.log(getKeyboardHints());
+        console.log('');
+        console.log(dim('  ─────────────────────────────────────────────'));
+        console.log('');
+    }
+    // Status line and keyboard only in human mode
+    const statusLine = useJson ? null : createStatusLine(process.stdout);
+    let syncedCount = 0;
+    let logFilter = 'all';
+    function updateStatus() {
+        if (!statusLine)
+            return;
+        const filterLabel = logFilter === 'all' ? 'All' : logFilter === 'events' ? 'Events' : 'Runtime';
+        const sep = '\x1b[90m\u2502\x1b[39m';
+        statusLine.update(`${bold(config.appName)} ${sep} ${green(session.previewUrl)} ${sep} ${cyan(`${syncedCount} synced`)} ${sep} ${filterLabel} ${sep} \x1b[90mo\x1b[39m:open \x1b[90mi\x1b[39m:info \x1b[90ma/e/r\x1b[39m:filter \x1b[90mq\x1b[39m:quit`);
+    }
+    if (statusLine)
+        updateStatus();
     let logTailer;
-    // Register cleanup before starting watcher to avoid race
+    const keyboard = useJson ? null : createKeyboardListener();
     const cleanup = async () => {
-        console.log('\nStopping...');
+        if (!useJson)
+            console.log('\nStopping...');
         logTailer?.stop();
         await stopAutoCommit();
+        statusLine?.destroy();
+        keyboard?.stop();
         process.exit(0);
     };
     process.on('SIGINT', cleanup);
     process.on('SIGTERM', cleanup);
+    if (keyboard) {
+        keyboard.start((action) => {
+            switch (action) {
+                case 'o':
+                case 'p':
+                    import('open').then(m => m.default(session.previewUrl));
+                    break;
+                case 'a':
+                    logFilter = 'all';
+                    console.log(dim('  Showing all logs.'));
+                    updateStatus();
+                    break;
+                case 'e':
+                    logFilter = 'events';
+                    console.log(dim('  Showing events only.'));
+                    updateStatus();
+                    break;
+                case 'r':
+                    logFilter = 'runtime';
+                    console.log(dim('  Showing runtime logs only.'));
+                    updateStatus();
+                    break;
+                case 'i':
+                    console.log(getInfoPanel({
+                        appName: config.appName,
+                        previewUrl: session.previewUrl,
+                        workspaceName: config.workspaceName,
+                        directory: cwd,
+                    }));
+                    break;
+                case 'quit':
+                    cleanup();
+                    break;
+            }
+        });
+    }
     // Start file watcher
-    console.log('Watching for file changes...');
-    await watchAndAutoCommit(process.cwd(), client, config.appId);
+    await watchAndAutoCommit(process.cwd(), client, config.appId, {
+        onFastSync: useJson
+            ? (count) => { jsonLine({ event: 'files_synced', count, target: 'preview', timestamp: ts() }); }
+            : (count) => { syncedCount += count; updateStatus(); },
+        onGitPush: useJson
+            ? (count) => { jsonLine({ event: 'files_pushed', count, target: 'git', timestamp: ts() }); }
+            : (count) => { syncedCount += count; updateStatus(); },
+    });
     // Start log tailing (unless --no-logs)
-    if (options.logs !== false) {
+    if (options?.logs !== false) {
         logTailer = startLogTailer({
             appId: config.appId,
             client,
             projectDir: cwd,
-            toTerminal: !options.logsOnlyFile,
+            toTerminal: !options?.logsOnlyFile,
             toFile: true,
+            getFilter: () => logFilter,
+            useJson,
         });
-        console.log('Log tailing active. Logs written to .runwork/logs.txt');
     }
     // Keep alive
     await new Promise(() => { });
+}
+export const devCommand = new Command('dev')
+    .description('Start local development with live sync, preview sandbox, and file watching')
+    .option('--no-logs', 'Disable automatic log tailing')
+    .option('--logs-only-file', 'Write logs to file only, not terminal')
+    .action(async (options, command) => {
+    const globalJson = shouldOutputJson(command.optsWithGlobals().json);
+    await execDev({ ...options, json: globalJson });
 });

package/dist/commands/info.d.ts

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