runwork 0.2.4 → 0.3.0

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/dev.d.ts

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

package/dist/commands/dev.js

@@ -1,15 +1,20 @@
 import { Command } from 'commander';
 import { execFileSync } from 'child_process';
-import { readFileSync, writeFileSync, existsSync, unlinkSync } from 'fs';
+import { readFileSync, writeFileSync, existsSync } from 'fs';
 import { join } from 'path';
 import { requireAuth } from '../auth/store.js';
 import { ApiClient } from '../api/client.js';
 import { watchAndAutoCommit, stopAutoCommit } from '../git/auto-commit.js';
+import { syncWithRemote } from '../git/sync.js';
 import { startLogTailer } from '../logs/tailer.js';
 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';
 async function populateSkill(projectDir, client, appId) {
     try {
         const { skill } = await client.getAppSkill(appId);
@@ -28,30 +33,7 @@ function readConfig() {
     }
     return JSON.parse(readFileSync('.runwork.json', 'utf-8'));
 }
-function hasCommits() {
-    try {
-        execFileSync('git', ['rev-parse', 'HEAD'], { stdio: 'pipe' });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function hasTrackedChanges() {
-    try {
-        // Only check tracked files (modified/deleted/staged) - not untracked (??) files
-        const output = execFileSync('git', ['status', '--porcelain'], { encoding: 'utf-8' });
-        return output.trim().split('\n').some(line => line.length > 0 && !line.startsWith('??'));
-    }
-    catch {
-        return false;
-    }
-}
-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 config = readConfig();
     const creds = requireAuth();
     const client = new ApiClient(creds);
@@ -75,7 +57,7 @@ export const devCommand = new Command('dev')
         }
     }
     // Download fresh template to ensure latest version
-    console.log('Updating template...');
+    console.log(dim('Updating template...'));
     try {
         const zipData = await client.downloadSkeleton();
         extractZip(zipData, cwd);
@@ -92,97 +74,133 @@ export const devCommand = new Command('dev')
         }
     }
     catch {
-        console.warn('Template update failed. Continuing with current files.');
+        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...');
+    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)
     await populateSkill(cwd, client, config.appId);
     // Sync AFTER starting session so we pick up any commits the DO created
-    if (hasCommits()) {
-        console.log('Syncing with Runwork...');
-        const dirty = hasTrackedChanges();
-        if (dirty) {
-            execFileSync('git', ['stash', 'push', '-m', 'runwork-dev-sync'], { stdio: 'inherit' });
-        }
-        try {
-            // Fetch first, then remove untracked skeleton files that conflict
-            // with the remote before rebasing. Skeleton files are ephemeral
-            // (re-downloaded each session) so the server's versions take precedence.
-            // User-edited files are already tracked/committed at this point.
-            execFileSync('git', ['fetch', 'runwork', 'main'], { stdio: 'inherit' });
-            try {
-                const remoteFiles = execFileSync('git', ['ls-tree', '-r', '--name-only', 'runwork/main'], { encoding: 'utf-8' }).trim().split('\n');
-                const untrackedOutput = execFileSync('git', ['ls-files', '--others', '--exclude-standard'], { encoding: 'utf-8' }).trim();
-                const untracked = new Set(untrackedOutput.split('\n').filter(Boolean));
-                for (const file of remoteFiles) {
-                    if (untracked.has(file)) {
-                        try {
-                            unlinkSync(join(cwd, file));
-                        }
-                        catch { /* already gone */ }
-                    }
-                }
-            }
-            catch { /* best effort */ }
-            execFileSync('git', ['rebase', 'runwork/main'], { stdio: 'inherit' });
-        }
-        catch {
-            try {
-                execFileSync('git', ['rebase', '--abort'], { stdio: 'pipe' });
-            }
-            catch { /* no rebase in progress */ }
-            console.warn('Pull failed (remote may not have commits yet). Continuing...');
-        }
-        if (dirty) {
-            try {
-                execFileSync('git', ['stash', 'pop'], { stdio: 'inherit' });
-            }
-            catch {
+    console.log(dim('Syncing...'));
+    const syncResult = syncWithRemote(cwd);
+    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);
             }
-        }
-        // Push local changes
-        try {
-            execFileSync('git', ['push', 'runwork', 'main'], { stdio: 'inherit' });
-        }
-        catch {
-            console.warn('Push failed. Continuing with current state...');
-        }
+            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...'));
     }
-    else {
-        console.log('No commits yet. Skipping sync.');
+    // Show banner
+    console.log(getDevBanner({ appName: config.appName, previewUrl: session.previewUrl, workspaceName: config.workspaceName }));
+    console.log(getKeyboardHints());
+    console.log('');
+    console.log(dim('  ─────────────────────────────────────────────'));
+    console.log('');
+    // Status line tracks sync activity
+    const statusLine = createStatusLine(process.stdout);
+    let syncedCount = 0;
+    let logFilter = 'all';
+    function updateStatus() {
+        const filterLabel = logFilter === 'all' ? 'All' : logFilter === 'events' ? 'Events' : 'Runtime';
+        const sep = '\x1b[90m\u2502\x1b[39m'; // dim │
+        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`);
     }
+    updateStatus();
     // Declare logTailer before cleanup so cleanup can reference it
     let logTailer;
+    const keyboard = createKeyboardListener();
     // Register cleanup before starting watcher to avoid race
     const cleanup = async () => {
         console.log('\nStopping...');
         logTailer?.stop();
         await stopAutoCommit();
+        statusLine.destroy();
+        keyboard.stop(); // Last - stopping stdin can affect process exit
         process.exit(0);
     };
     process.on('SIGINT', cleanup);
     process.on('SIGTERM', cleanup);
+    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(count) {
+            syncedCount += count;
+            updateStatus();
+        },
+        onGitPush(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,
         });
-        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 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) => execDev(options));

package/dist/commands/init.d.ts

@@ -1,2 +1,5 @@
 import { Command } from 'commander';
+import { ApiClient } from '../api/client.js';
+import type { WorkspaceInfo } from '../types.js';
+export declare function execInit(client: ApiClient, appName: string, workspace: WorkspaceInfo): Promise<string>;
 export declare const initCommand: Command;

package/dist/commands/init.js

@@ -1,32 +1,15 @@
 import { Command } from 'commander';
 import { execFileSync } from 'child_process';
 import { writeFileSync, existsSync, mkdirSync } 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, promptInput } 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 initCommand = new Command('init')
-    .description('Initialize a new Runwork app')
-    .argument('[name]', 'App name')
-    .action(async (name) => {
-    const creds = requireAuth();
-    const client = new ApiClient(creds);
-    const appName = name || await promptInput('App name');
-    if (!appName) {
-        console.error('App name is required.');
-        process.exit(1);
-    }
-    const workspaces = await client.listWorkspaces();
-    if (workspaces.length === 0) {
-        console.error('No workspaces found. Create one at runwork.ai first.');
-        process.exit(1);
-    }
-    const workspaceChoice = await promptSelect('Select workspace:', workspaces.map(w => ({ label: w.name, value: w })));
-    const workspace = workspaceChoice.value;
-    console.log(`Initializing "${appName}" in workspace "${workspace.name}"...`);
+import { runAgentWizard } from '../ui/banner.js';
+export async function execInit(client, appName, workspace) {
     const app = await client.initApp(workspace.id, appName);
     const slug = app.slug || appName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
     const dir = slug;
@@ -52,6 +35,7 @@ export const initCommand = new Command('init')
     // Write .runwork.json AFTER template extraction so it doesn't get overwritten
     const config = {
         workspaceId: workspace.id,
+        workspaceName: workspace.name,
         appId: app.id,
         appName: app.name,
     };
@@ -83,5 +67,29 @@ export const initCommand = new Command('init')
     execFileSync('git', ['push', '-u', 'runwork', 'main'], { cwd: dir, stdio: 'inherit' });
     console.log(`\nApp "${app.name}" initialized in ${dir}/`);
     console.log(`Remote: ${remoteUrl}`);
-    console.log(`\nNext: cd ${dir} && runwork dev`);
+    return resolve(dir);
+}
+export const initCommand = new Command('init')
+    .description('Initialize a new Runwork app')
+    .argument('[name]', 'App name')
+    .action(async (name) => {
+    const creds = requireAuth();
+    const client = new ApiClient(creds);
+    const appName = name || await promptInput('App name');
+    if (!appName) {
+        console.error('App name is required.');
+        process.exit(1);
+    }
+    const workspaces = await client.listWorkspaces();
+    if (workspaces.length === 0) {
+        console.error('No workspaces found. Create one at runwork.ai first.');
+        process.exit(1);
+    }
+    const workspaceChoice = await promptSelect('Select workspace:', workspaces.map(w => ({ label: w.name, value: w })));
+    const workspace = workspaceChoice.value;
+    console.log(`Initializing "${appName}" in workspace "${workspace.name}"...`);
+    const dir = await execInit(client, appName, workspace);
+    const slug = dir.split('/').pop() || dir;
+    await runAgentWizard(dir);
+    console.log(`Next: cd ${slug} && runwork dev`);
 });

package/dist/commands/login.js

@@ -1,32 +1,17 @@
 import { Command } from 'commander';
-import { ApiClient } from '../api/client.js';
-import { saveCredentials } from '../auth/store.js';
-import { configureGitCredentials } from '../git/credentials.js';
+import { performLogin } from '../auth/login-flow.js';
+import { bold, cyan } from '../ui/colors.js';
 export const loginCommand = new Command('login')
     .description('Authenticate with Runwork platform')
     .option('--base-url <url>', 'Platform URL', 'https://runwork.ai')
     .action(async (options) => {
-    const client = new ApiClient({ apiKey: '', email: '', baseUrl: options.baseUrl });
     console.log('Opening browser for authentication...');
-    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('Waiting for authentication...');
-    // Poll for up to 5 minutes
-    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 || options.baseUrl);
-            console.log(`Logged in as ${result.email}`);
-            return;
-        }
-    }
-    console.error('Login timed out. Please try again.');
-    process.exit(1);
+    await performLogin(options.baseUrl);
+    console.log('');
+    console.log(bold('What next?'));
+    console.log('');
+    console.log(`  ${cyan('runwork init')}     Create a new app`);
+    console.log(`  ${cyan('runwork clone')}    Clone an existing app`);
+    console.log(`  ${cyan('runwork dev')}      Start developing (inside an app directory)`);
+    console.log('');
 });

package/dist/commands/open.d.ts

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

package/dist/commands/open.js

@@ -0,0 +1,43 @@
+import { Command } from 'commander';
+import { readFileSync, existsSync } from 'fs';
+import { requireAuth } from '../auth/store.js';
+import { ApiClient } from '../api/client.js';
+import { cyan } from '../ui/colors.js';
+export const openCommand = new Command('open')
+    .description('Open app preview or dashboard in browser')
+    .argument('[target]', 'What to open: preview (default), dashboard', 'preview')
+    .action(async (target) => {
+    if (!existsSync('.runwork.json')) {
+        console.error('No .runwork.json found. Run `runwork init` first.');
+        process.exit(1);
+    }
+    const config = JSON.parse(readFileSync('.runwork.json', 'utf-8'));
+    const creds = requireAuth();
+    const client = new ApiClient(creds);
+    const open = await import('open');
+    switch (target) {
+        case 'preview': {
+            let previewUrl;
+            try {
+                const status = await client.getDevStatus(config.appId);
+                previewUrl = status.previewUrl;
+            }
+            catch {
+                const session = await client.startDevSession(config.appId);
+                previewUrl = session.previewUrl;
+            }
+            console.log(`Opening preview: ${cyan(previewUrl)}`);
+            await open.default(previewUrl);
+            break;
+        }
+        case 'dashboard': {
+            const url = `${creds.baseUrl}/apps/${config.appId}`;
+            console.log(`Opening dashboard: ${cyan(url)}`);
+            await open.default(url);
+            break;
+        }
+        default:
+            console.error(`Unknown target: ${target}. Use "preview" or "dashboard".`);
+            process.exit(1);
+    }
+});

package/dist/commands/welcome.d.ts

@@ -0,0 +1 @@
+export declare function runWelcomeWizard(): Promise<void>;