runwork 0.2.5 → 0.4.0

package/dist/commands/logs.js

@@ -2,6 +2,7 @@ import { Command } from 'commander';
 import { readFileSync, existsSync } from 'fs';
 import { requireAuth } from '../auth/store.js';
 import { ApiClient } from '../api/client.js';
+import { shouldOutputJson, jsonLine } from '../utils/output.js';
 function readConfig() {
     if (!existsSync('.runwork.json')) {
         console.error('No .runwork.json found. Run `runwork init` first.');
@@ -25,7 +26,8 @@ export const logsCommand = new Command('logs')
     .option('--level <level>', 'Filter by log level (production only)')
     .option('--search <text>', 'Search log content (production only)')
     .option('--type <type>', 'Filter by event type (events only)')
-    .action(async (opts) => {
+    .action(async (opts, command) => {
+    const useJson = shouldOutputJson(command.optsWithGlobals().json);
     const config = readConfig();
     const creds = requireAuth();
     const client = new ApiClient(creds);
@@ -50,15 +52,22 @@ export const logsCommand = new Command('logs')
                         level: opts.level,
                         search: opts.search,
                     });
-                    if (logs.length === 0) {
-                        console.log('No production logs found.');
+                    if (useJson) {
+                        for (const entry of logs) {
+                            jsonLine(entry);
+                        }
                     }
                     else {
-                        for (const entry of logs) {
-                            console.log(JSON.stringify(entry));
+                        if (logs.length === 0) {
+                            console.log('No production logs found.');
                         }
-                        if (pagination?.hasMore) {
-                            console.log(`... ${pagination.total ? `${pagination.total} total entries` : 'more entries available'}`);
+                        else {
+                            for (const entry of logs) {
+                                console.log(JSON.stringify(entry));
+                            }
+                            if (pagination?.hasMore) {
+                                console.log(`... ${pagination.total ? `${pagination.total} total entries` : 'more entries available'}`);
+                            }
                         }
                     }
                 }
@@ -81,25 +90,61 @@ export const logsCommand = new Command('logs')
                         }
                         if (stdout && stdout.length > lastStdoutLength) {
                             const newContent = stdout.slice(lastStdoutLength);
-                            process.stdout.write(newContent);
+                            if (useJson) {
+                                for (const line of newContent.split('\n')) {
+                                    if (line) {
+                                        jsonLine({ type: 'runtime', message: line, timestamp: new Date().toISOString() });
+                                    }
+                                }
+                            }
+                            else {
+                                process.stdout.write(newContent);
+                            }
                         }
                         if (stderr && stderr.length > lastStderrLength) {
                             const newContent = stderr.slice(lastStderrLength);
-                            process.stderr.write(newContent);
+                            if (useJson) {
+                                for (const line of newContent.split('\n')) {
+                                    if (line) {
+                                        jsonLine({ type: 'error', message: line, timestamp: new Date().toISOString() });
+                                    }
+                                }
+                            }
+                            else {
+                                process.stderr.write(newContent);
+                            }
                         }
                         lastStdoutLength = stdout ? stdout.length : 0;
                         lastStderrLength = stderr ? stderr.length : 0;
                     }
                     else {
                         // First poll or non-follow: print everything
-                        if (stdout) {
-                            console.log(stdout);
+                        if (useJson) {
+                            if (stdout) {
+                                for (const line of stdout.split('\n')) {
+                                    if (line) {
+                                        jsonLine({ type: 'runtime', message: line, timestamp: new Date().toISOString() });
+                                    }
+                                }
+                            }
+                            if (stderr) {
+                                for (const line of stderr.split('\n')) {
+                                    if (line) {
+                                        jsonLine({ type: 'error', message: line, timestamp: new Date().toISOString() });
+                                    }
+                                }
+                            }
                         }
-                        if (stderr) {
-                            console.error(stderr);
-                        }
-                        if (!stdout && !stderr) {
-                            console.log('No preview logs available.');
+                        else {
+                            if (stdout) {
+                                console.log(stdout);
+                            }
+                            if (stderr) {
+                                console.error(stderr);
+                            }
+                            if (!stdout && !stderr) {
+                                console.log('No preview logs available.');
+                            }
                         }
                         // Initialize cursors for subsequent follow polls
                         lastStdoutLength = stdout ? stdout.length : 0;
@@ -112,7 +157,7 @@ export const logsCommand = new Command('logs')
             }
         }
         if (showEvents) {
-            if (showRuntime && isFirstPoll) {
+            if (!useJson && showRuntime && isFirstPoll) {
                 console.log('\n--- Events ---\n');
             }
             try {
@@ -120,15 +165,29 @@ export const logsCommand = new Command('logs')
                     limit,
                     type: opts.type,
                 });
-                if (events.length === 0 && isFirstPoll) {
-                    console.log('No events found.');
+                if (useJson) {
+                    for (const event of events) {
+                        jsonLine({
+                            type: 'event',
+                            eventType: event.type,
+                            source: event.source,
+                            detail: event.summary || event.content,
+                            metadata: event.metadata || {},
+                            timestamp: event.timestamp,
+                        });
+                    }
                 }
                 else {
-                    for (const event of events) {
-                        console.log(formatEvent(event));
+                    if (events.length === 0 && isFirstPoll) {
+                        console.log('No events found.');
                     }
-                    if (hasMore && isFirstPoll) {
-                        console.log(`... ${totalCount} total events`);
+                    else {
+                        for (const event of events) {
+                            console.log(formatEvent(event));
+                        }
+                        if (hasMore && isFirstPoll) {
+                            console.log(`... ${totalCount} total events`);
+                        }
                     }
                 }
             }

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,53 @@
+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';
+import { shouldOutputJson, jsonOut } from '../utils/output.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, _opts, command) => {
+    const useJson = shouldOutputJson(command.optsWithGlobals().json);
+    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;
+            }
+            if (useJson) {
+                jsonOut({ target: 'preview', url: previewUrl });
+                return;
+            }
+            console.log(`Opening preview: ${cyan(previewUrl)}`);
+            await open.default(previewUrl);
+            break;
+        }
+        case 'dashboard': {
+            const url = `${creds.baseUrl}/apps/${config.appId}`;
+            if (useJson) {
+                jsonOut({ target: 'dashboard', url });
+                return;
+            }
+            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>;

package/dist/commands/welcome.js

@@ -0,0 +1,83 @@
+import { getCredentials } from '../auth/store.js';
+import { performLogin } from '../auth/login-flow.js';
+import { ApiClient } from '../api/client.js';
+import { promptSelect, promptInput, promptConfirm } from '../utils/prompt.js';
+import { getWelcomeBanner, runAgentWizard } from '../ui/banner.js';
+import { cyan, dim, green } from '../ui/colors.js';
+export async function runWelcomeWizard() {
+    // Step 1: Welcome
+    console.log(getWelcomeBanner());
+    // Step 2: Login
+    let creds = getCredentials();
+    if (creds) {
+        console.log(green(`  Already logged in as ${creds.email}.`));
+    }
+    else {
+        console.log('Opening your browser to log in...');
+        console.log('');
+        creds = await performLogin();
+    }
+    // Step 3: Init or Clone
+    console.log('');
+    const action = await promptSelect('What would you like to do?', [
+        { label: 'Create a new app', value: 'init' },
+        { label: 'Clone an existing app', value: 'clone' },
+    ]);
+    const client = new ApiClient(creds);
+    let appDir;
+    if (action.value === 'init') {
+        const appName = 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);
+        }
+        let workspace;
+        if (workspaces.length === 1) {
+            workspace = workspaces[0];
+            console.log(dim(`  Using workspace: ${workspace.name}`));
+        }
+        else {
+            console.log('');
+            console.log('A workspace is where your apps live. Pick one:');
+            const choice = await promptSelect('Select workspace:', workspaces.map(w => ({ label: w.name, value: w })));
+            workspace = choice.value;
+        }
+        console.log('');
+        console.log(`Creating ${cyan(appName)} in workspace ${cyan(workspace.name)}...`);
+        const { execInit } = await import('./init.js');
+        appDir = await execInit(client, appName, workspace);
+    }
+    else {
+        const apps = await client.listApps();
+        if (apps.length === 0) {
+            console.error('No apps found. Choose "Create a new app" instead.');
+            process.exit(1);
+        }
+        const choice = await promptSelect('Select app to clone:', apps.map(a => ({ label: `${a.name} (${a.workspaceName})`, value: a })));
+        const { execClone } = await import('./clone.js');
+        appDir = await execClone(client, choice.value);
+    }
+    // Step 4: Agent guidance
+    await runAgentWizard(appDir);
+    // Step 5: Offer to start dev
+    console.log('');
+    const startDev = await promptConfirm('Start developing now?');
+    if (startDev) {
+        console.log('');
+        console.log(dim(`  Tip: Open another terminal and launch your AI agent in ${cyan(appDir)}`));
+        console.log('');
+        process.chdir(appDir);
+        const { execDev } = await import('./dev.js');
+        await execDev();
+    }
+    else {
+        const slug = appDir.split('/').pop() || appDir;
+        console.log('');
+        console.log(`Next: ${cyan(`cd ${slug} && runwork dev`)}`);
+    }
+}

package/dist/generated/version.d.ts

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

package/dist/generated/version.js

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

package/dist/git/__tests__/sync.test.js

@@ -165,7 +165,7 @@ describe('syncWithRemote()', () => {
         expect(existsSync(join(local, 'local-file.txt'))).toBe(true);
         expect(existsSync(join(local, 'remote-only.txt'))).toBe(true);
     });
-    it('reports sync-failed when both rebase and merge have conflicts', () => {
+    it('auto-resolves conflicting unrelated histories by accepting remote', () => {
         const { local, remote } = createTestRepo();
         // Local modifies a file
         commitFile(local, 'shared.txt', 'local-line-1\nlocal-line-2\n', 'local init');
@@ -178,8 +178,10 @@ describe('syncWithRemote()', () => {
         execFileSync('git', ['remote', 'add', 'origin', remote], { cwd: other });
         execFileSync('git', ['push', 'origin', 'main'], { cwd: other, stdio: 'pipe' });
         const result = syncWithRemote(local);
-        // Both rebase and merge will fail on conflicting unrelated histories
-        expect(result.status).toBe('sync-failed');
+        // Conflicts auto-resolved with -X theirs (remote wins for first sync)
+        expect(result.status).toBe('merged');
+        // Remote version should win
+        expect(readFileSync(join(local, 'shared.txt'), 'utf-8')).toBe('remote-line-1\nremote-line-2\n');
     });
     it('stashes and restores dirty working tree during sync', () => {
         const { local, remote } = createTestRepo();
@@ -316,7 +318,7 @@ describe('syncWithRemote() edge cases', () => {
         // But local repo should be intact
         expect(readFileSync(join(local, 'a.txt'), 'utf-8')).toBe('hello');
     });
-    it('leaves repo clean (not in rebase/merge state) after sync-failed', () => {
+    it('leaves repo clean after auto-resolving conflicting unrelated histories', () => {
         const { local, remote } = createTestRepo();
         commitFile(local, 'shared.txt', 'local version\n', 'local init');
         // Create conflicting remote history
@@ -328,14 +330,14 @@ describe('syncWithRemote() edge cases', () => {
         execFileSync('git', ['remote', 'add', 'origin', remote], { cwd: other });
         execFileSync('git', ['push', 'origin', 'main'], { cwd: other, stdio: 'pipe' });
         const result = syncWithRemote(local);
-        expect(result.status).toBe('sync-failed');
+        // Auto-resolved with -X theirs
+        expect(result.status).toBe('merged');
         // Repo should NOT be in a rebase or merge state
         expect(existsSync(join(local, '.git', 'MERGE_HEAD'))).toBe(false);
         expect(existsSync(join(local, '.git', 'rebase-merge'))).toBe(false);
         expect(existsSync(join(local, '.git', 'rebase-apply'))).toBe(false);
-        // Working tree should be clean (original file intact)
-        const fileContent = readFileSync(join(local, 'shared.txt'), 'utf-8');
-        expect(fileContent).toBe('local version\n');
+        // Remote version wins
+        expect(readFileSync(join(local, 'shared.txt'), 'utf-8')).toBe('remote version\n');
     });
     it('handles merge conflict during rebase on related histories (same file edited both sides)', () => {
         const { local, remote } = createTestRepo();

package/dist/git/auto-commit.d.ts

@@ -1,4 +1,8 @@
 import type { ApiClient } from '../api/client.js';
 export declare function isIgnored(filePath: string): boolean;
-export declare function watchAndAutoCommit(directory: string, client: ApiClient, appId: string): Promise<void>;
+export declare function watchAndAutoCommit(directory: string, client: ApiClient, appId: string, callbacks?: {
+    onFileChange?: (relPath: string, pendingCount: number) => void;
+    onFastSync?: (count: number) => void;
+    onGitPush?: (count: number) => void;
+}): Promise<void>;
 export declare function stopAutoCommit(): Promise<void>;

package/dist/git/auto-commit.js

@@ -2,11 +2,13 @@ import { execFileSync } from 'child_process';
 import { readFileSync } from 'fs';
 import { watch } from 'chokidar';
 import { basename, join, relative } from 'path';
+import { dim, cyan, yellow } from '../ui/colors.js';
 let watcher = null;
 let fastSyncTimer = null;
 let gitTimer = null;
 let gitPushing = false;
 let gitPendingAfterPush = false;
+let activeCallbacks;
 // Files awaiting fast sync: path -> 'changed' | 'deleted'
 const pendingFastSync = new Map();
 // Track files the user actually touched during this session (for git)
@@ -33,7 +35,8 @@ export function isIgnored(filePath) {
         return true;
     return false;
 }
-export async function watchAndAutoCommit(directory, client, appId) {
+export async function watchAndAutoCommit(directory, client, appId, callbacks) {
+    activeCallbacks = callbacks;
     watcher = watch(directory, {
         ignored: isIgnored,
         persistent: true,
@@ -46,19 +49,20 @@ export async function watchAndAutoCommit(directory, client, appId) {
     const onFileChange = (filePath) => {
         const rel = relative(directory, filePath);
         if (changedFiles.size === 0) {
-            console.log(`Changed: ${rel}`);
+            console.log(`  ${dim('Changed:')} ${cyan(rel)}`);
         }
         else {
-            console.log(`Changed: ${rel} (+${changedFiles.size} pending)`);
+            console.log(`  ${dim('Changed:')} ${cyan(rel)} ${dim(`(+${changedFiles.size} pending)`)}`);
         }
         changedFiles.add(rel);
         pendingFastSync.set(rel, 'changed');
+        activeCallbacks?.onFileChange?.(rel, changedFiles.size);
         scheduleFastSync(directory, client, appId);
         scheduleGitCommit();
     };
     const onFileUnlink = (filePath) => {
         const rel = relative(directory, filePath);
-        console.log(`Deleted: ${rel}`);
+        console.log(`  ${dim('Deleted:')} ${cyan(rel)}`);
         changedFiles.add(rel);
         pendingFastSync.set(rel, 'deleted');
         scheduleFastSync(directory, client, appId);
@@ -109,11 +113,12 @@ async function executeFastSync(directory, client, appId) {
     const total = files.length + deletedFiles.length;
     try {
         await client.syncFiles(appId, files, deletedFiles.length > 0 ? deletedFiles : undefined);
-        console.log(`  Synced ${total} file(s) to preview.`);
+        console.log(dim(`  Synced ${total} file(s) to preview.`));
+        activeCallbacks?.onFastSync?.(total);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        console.warn(`  Fast sync failed (git will handle it): ${message}`);
+        console.warn(yellow(`  Fast sync failed (git will handle it): ${message}`));
     }
 }
 // ========================================
@@ -178,7 +183,7 @@ function commitAndPush() {
                     execFileSync('git', ['merge', '--abort'], { stdio: 'pipe' });
                 }
                 catch { /* no merge in progress */ }
-                console.warn('Auto-sync: merge failed, skipping push. Run `git pull --rebase runwork main` manually.');
+                console.warn(yellow('Auto-sync: merge failed, skipping push. Run `git pull --rebase runwork main` manually.'));
                 return;
             }
         }
@@ -189,11 +194,12 @@ function commitAndPush() {
         catch {
             execFileSync('git', ['push', '-u', 'runwork', 'main'], { stdio: 'pipe' });
         }
-        console.log(`  Pushed ${stagedFiles.length} file(s) to git.`);
+        console.log(dim(`  Pushed ${stagedFiles.length} file(s) to git.`));
+        activeCallbacks?.onGitPush?.(stagedFiles.length);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        console.warn(`Auto-sync failed: ${message}`);
+        console.warn(yellow(`Auto-sync failed: ${message}`));
     }
     finally {
         gitPushing = false;

package/dist/git/sync.js

@@ -49,6 +49,31 @@ function removeConflictingUntrackedFiles(cwd) {
         // best effort
     }
 }
+function extractGitError(err) {
+    if (err && typeof err === 'object') {
+        const obj = err;
+        // execFileSync errors have stderr and stdout as Buffer or string
+        const stderr = bufToStr(obj.stderr);
+        const stdout = bufToStr(obj.stdout);
+        // Prefer stderr (git's error output), fall back to stdout (merge conflict details)
+        if (stderr)
+            return stderr;
+        if (stdout)
+            return stdout;
+    }
+    if (err instanceof Error)
+        return err.message;
+    return String(err);
+}
+function bufToStr(val) {
+    if (!val)
+        return '';
+    if (typeof val === 'string')
+        return val.trim();
+    if (Buffer.isBuffer(val))
+        return val.toString('utf-8').trim();
+    return '';
+}
 /**
  * Sync local repository with the runwork remote.
  *
@@ -65,13 +90,14 @@ export function syncWithRemote(cwd) {
         execFileSync('git', ['stash', 'push', '-m', 'runwork-dev-sync'], { cwd, stdio: 'pipe' });
     }
     let status = 'synced';
+    let syncError;
     try {
         execFileSync('git', ['fetch', 'runwork', 'main'], { cwd, stdio: 'pipe' });
         removeConflictingUntrackedFiles(cwd);
         try {
             execFileSync('git', ['rebase', 'runwork/main'], { cwd, stdio: 'pipe' });
         }
-        catch {
+        catch (rebaseErr) {
             try {
                 execFileSync('git', ['rebase', '--abort'], { cwd, stdio: 'pipe' });
             }
@@ -81,17 +107,32 @@ export function syncWithRemote(cwd) {
                 status = 'merged';
             }
             catch {
+                // Merge conflicts (common with unrelated histories / first sync).
+                // Abort and retry accepting the remote's version for all conflicts.
+                // This is safe because: user edits were committed before sync,
+                // and local template files are ephemeral (re-downloaded each session).
                 try {
                     execFileSync('git', ['merge', '--abort'], { cwd, stdio: 'pipe' });
                 }
                 catch { /* no merge in progress */ }
-                status = 'sync-failed';
+                try {
+                    execFileSync('git', ['merge', 'runwork/main', '--allow-unrelated-histories', '--no-edit', '-X', 'theirs'], { cwd, stdio: 'pipe' });
+                    status = 'merged';
+                }
+                catch (mergeErr) {
+                    try {
+                        execFileSync('git', ['merge', '--abort'], { cwd, stdio: 'pipe' });
+                    }
+                    catch { /* no merge in progress */ }
+                    status = 'sync-failed';
+                    syncError = extractGitError(mergeErr);
+                }
             }
         }
     }
-    catch {
-        // fetch failed — remote may be unreachable or have no commits
+    catch (fetchErr) {
         status = 'sync-failed';
+        syncError = extractGitError(fetchErr);
     }
     if (dirty) {
         try {
@@ -102,7 +143,7 @@ export function syncWithRemote(cwd) {
         }
     }
     if (status === 'sync-failed') {
-        return { status, pushed: false, error: 'Pull failed (remote may not have commits yet)' };
+        return { status, pushed: false, error: syncError };
     }
     let pushed = false;
     try {

package/dist/index.js

@@ -8,13 +8,18 @@ import { logsCommand } from './commands/logs.js';
 import { upgradeCommand } from './commands/upgrade.js';
 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 { handleGitCredentialRequest } from './git/credentials.js';
 import { VERSION } from './generated/version.js';
 const program = new Command();
 program
     .name('runwork')
     .description('Runwork CLI - local development for Runwork apps')
-    .version(VERSION);
+    .version(VERSION)
+    .option('--json', 'Output as JSON (auto-enabled when stdout is not a TTY)');
+// Info first -- it's the agent discovery entry point
+program.addCommand(infoCommand);
 program.addCommand(loginCommand);
 program.addCommand(initCommand);
 program.addCommand(cloneCommand);
@@ -24,6 +29,8 @@ program.addCommand(logsCommand);
 program.addCommand(upgradeCommand);
 program.addCommand(logoutCommand);
 program.addCommand(integrationsCommand);
+program.addCommand(openCommand);
+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 })
     .argument('<action>', 'Credential action (get/store/erase)')
@@ -32,4 +39,18 @@ const credentialHelper = program
     await handleGitCredentialRequest(action);
 });
 credentialHelper.helpOption(false);
+// First-run detection: bare `runwork` with no command and no credentials -> welcome wizard
+const args = process.argv.slice(2);
+const isHelpOrVersion = args.includes('--help') || args.includes('-h') ||
+    args.includes('--version') || args.includes('-v') || args.includes('-V');
+const knownCommands = program.commands.map(c => c.name());
+const hasCommand = args.some(arg => !arg.startsWith('-') && knownCommands.includes(arg));
+if (!hasCommand && !isHelpOrVersion && args.length === 0) {
+    const { getCredentials } = await import('./auth/store.js');
+    if (!getCredentials()) {
+        const { runWelcomeWizard } = await import('./commands/welcome.js');
+        await runWelcomeWizard();
+        process.exit(0);
+    }
+}
 program.parse();

package/dist/logs/__tests__/tailer-format.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/logs/__tests__/tailer-format.test.js

@@ -0,0 +1,43 @@
+import { describe, it, expect } from 'vitest';
+import { formatLogLine, formatRelativeTime } from '../tailer.js';
+import { stripAnsi } from '../../ui/colors.js';
+describe('formatLogLine', () => {
+    it('formats RUNTIME lines with timestamp and tag', () => {
+        const line = formatLogLine('RUNTIME', 'Server started on port 8787');
+        const plain = stripAnsi(line);
+        expect(plain).toMatch(/\d{2}:\d{2}:\d{2}/);
+        expect(plain).toContain('RUNTIME');
+        expect(plain).toContain('Server started on port 8787');
+    });
+    it('formats ERROR lines', () => {
+        const line = formatLogLine('ERROR', 'Something broke');
+        const plain = stripAnsi(line);
+        expect(plain).toContain('ERROR');
+    });
+    it('formats EVENT lines', () => {
+        const line = formatLogLine('EVENT', 'workflow_completed: done');
+        const plain = stripAnsi(line);
+        expect(plain).toContain('EVENT');
+    });
+    it('indents log lines with 2 spaces', () => {
+        const line = formatLogLine('RUNTIME', 'test');
+        expect(line.startsWith('  ')).toBe(true);
+    });
+});
+describe('formatRelativeTime', () => {
+    it('returns "now" for future timestamps', () => {
+        const future = new Date(Date.now() + 10000).toISOString();
+        expect(formatRelativeTime(future)).toBe('now');
+    });
+    it('returns seconds for recent events', () => {
+        const recent = new Date(Date.now() - 5000).toISOString();
+        expect(formatRelativeTime(recent)).toMatch(/\ds ago/);
+    });
+    it('returns minutes for older events', () => {
+        const older = new Date(Date.now() - 120000).toISOString();
+        expect(formatRelativeTime(older)).toMatch(/\dm ago/);
+    });
+    it('returns absolute time when no timestamp given', () => {
+        expect(formatRelativeTime()).toMatch(/\d{2}:\d{2}:\d{2}/);
+    });
+});