runwork 0.2.5 → 0.3.0

package/dist/ui/banner.js

@@ -0,0 +1,118 @@
+import { bold, cyan, dim, green } from './colors.js';
+export const SUPPORTED_AGENTS = [
+    { id: 'claude-code', name: 'Claude Code', command: 'cd {dir} && claude' },
+    { id: 'cursor', name: 'Cursor', command: 'cursor {dir}' },
+    { id: 'codex', name: 'OpenAI Codex', command: 'cd {dir} && codex' },
+    { id: 'claude-desktop', name: 'Claude Desktop', command: 'Open Claude Desktop and add {dir} as a project folder' },
+    { id: 'antigravity', name: 'Antigravity', command: 'cd {dir} && antigravity' },
+];
+export function getAgentCommand(agentId, directory) {
+    const agent = SUPPORTED_AGENTS.find(a => a.id === agentId);
+    if (!agent)
+        return null;
+    return agent.command.replace(/{dir}/g, directory);
+}
+export function getAgentGuidance(directory) {
+    const lines = [
+        '',
+        bold('Open in your AI agent:'),
+        '',
+    ];
+    for (const agent of SUPPORTED_AGENTS) {
+        const cmd = agent.command.replace(/{dir}/g, directory);
+        lines.push(`  ${agent.name.padEnd(18)} ${cyan(cmd)}`);
+    }
+    return lines.join('\n');
+}
+export function getDevBanner(options) {
+    const lines = [
+        '',
+        bold('Runwork Dev'),
+        '',
+    ];
+    if (options.workspaceName) {
+        lines.push(`  Workspace: ${dim(options.workspaceName)}`);
+    }
+    lines.push(`  App:       ${cyan(options.appName)}`, `  Preview:   ${green(options.previewUrl)}`, '', dim('  Changes sync automatically. Logs appear below.'), '');
+    return lines.join('\n');
+}
+export function getKeyboardHints() {
+    return dim('  Press: ') +
+        dim('[') + 'o' + dim(']pen preview  ') +
+        dim('[') + 'a' + dim(']ll logs  ') +
+        dim('[') + 'e' + dim(']vents  ') +
+        dim('[') + 'r' + dim(']untime  ') +
+        dim('[') + 'q' + dim(']uit');
+}
+/**
+ * Interactive wizard that asks which AI agent the user wants to use,
+ * then shows specific instructions for opening this app in that agent.
+ */
+export async function runAgentWizard(directory) {
+    const { select, isCancel } = await import('@clack/prompts');
+    console.log('');
+    const result = await select({
+        message: 'Which AI agent do you use?',
+        options: SUPPORTED_AGENTS.map(a => ({
+            value: a.id,
+            label: a.name,
+        })),
+    });
+    if (isCancel(result)) {
+        return;
+    }
+    const agent = SUPPORTED_AGENTS.find(a => a.id === result);
+    if (!agent)
+        return;
+    const cmd = agent.command.replace(/{dir}/g, directory);
+    console.log('');
+    console.log(bold(`Open your app in ${agent.name}:`));
+    console.log('');
+    console.log(`  ${cyan(cmd)}`);
+    console.log('');
+    if (agent.id === 'claude-desktop') {
+        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('');
+}
+/**
+ * Returns full info panel (for 'i' key in dev mode) showing
+ * workspace, app, preview URL, and agent guidance.
+ */
+export function getInfoPanel(options) {
+    const lines = [
+        '',
+        bold('App Info'),
+        '',
+    ];
+    if (options.workspaceName) {
+        lines.push(`  Workspace: ${dim(options.workspaceName)}`);
+    }
+    lines.push(`  App:       ${cyan(options.appName)}`, `  Preview:   ${green(options.previewUrl)}`, `  Directory: ${dim(options.directory)}`);
+    lines.push('', bold('Open in your AI agent:'), '');
+    for (const agent of SUPPORTED_AGENTS) {
+        const cmd = agent.command.replace(/{dir}/g, options.directory);
+        lines.push(`  ${agent.name.padEnd(18)} ${cyan(cmd)}`);
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+export function getWelcomeBanner() {
+    return [
+        '',
+        bold('Welcome to Runwork!'),
+        '',
+        '  Runwork lets you build full-stack apps with AI agents like',
+        '  Claude Code, Cursor, Codex, and more -- running on your machine,',
+        '  deployed to the edge.',
+        '',
+        '  To get started, you need a Runwork account.',
+        '  We will open your browser to sign up or log in.',
+        '',
+    ].join('\n');
+}

package/dist/ui/colors.d.ts

@@ -0,0 +1,4 @@
+import pc from 'picocolors';
+export declare const bold: import("picocolors/types").Formatter, dim: import("picocolors/types").Formatter, red: import("picocolors/types").Formatter, green: import("picocolors/types").Formatter, yellow: import("picocolors/types").Formatter, cyan: import("picocolors/types").Formatter, gray: import("picocolors/types").Formatter, italic: import("picocolors/types").Formatter, underline: import("picocolors/types").Formatter, inverse: import("picocolors/types").Formatter;
+export { pc };
+export declare function stripAnsi(text: string): string;

package/dist/ui/colors.js

@@ -0,0 +1,7 @@
+import pc from 'picocolors';
+export const { bold, dim, red, green, yellow, cyan, gray, italic, underline, inverse } = pc;
+export { pc };
+// eslint-disable-next-line no-control-regex
+export function stripAnsi(text) {
+    return text.replace(/\x1b\[[0-9;]*m/g, '');
+}

package/dist/ui/keyboard.d.ts

@@ -0,0 +1,12 @@
+export type KeyAction = 'o' | 'p' | 'a' | 'e' | 'r' | 'i' | 'quit' | null;
+/** Parse a raw stdin buffer into a named action. */
+export declare function parseKeypress(data: Buffer): KeyAction;
+export interface KeyboardListener {
+    start(handler: (action: KeyAction) => void): void;
+    stop(): void;
+}
+/**
+ * Listens for raw keypresses on stdin.
+ * Only works when stdin is a TTY. Returns a no-op listener otherwise.
+ */
+export declare function createKeyboardListener(): KeyboardListener;

package/dist/ui/keyboard.js

@@ -0,0 +1,57 @@
+/** Parse a raw stdin buffer into a named action. */
+export function parseKeypress(data) {
+    if (data.length === 1) {
+        const byte = data[0];
+        if (byte === 0x03)
+            return 'quit'; // Ctrl+C
+        const char = String.fromCharCode(byte).toLowerCase();
+        switch (char) {
+            case 'o': return 'o';
+            case 'p': return 'p';
+            case 'a': return 'a';
+            case 'e': return 'e';
+            case 'r': return 'r';
+            case 'i': return 'i';
+            case 'q': return 'quit';
+            default: return null;
+        }
+    }
+    return null;
+}
+/**
+ * Listens for raw keypresses on stdin.
+ * Only works when stdin is a TTY. Returns a no-op listener otherwise.
+ */
+export function createKeyboardListener() {
+    if (!process.stdin.isTTY) {
+        return { start() { }, stop() { } };
+    }
+    let dataHandler = null;
+    return {
+        start(handler) {
+            process.stdin.setRawMode(true);
+            process.stdin.resume();
+            dataHandler = (data) => {
+                const action = parseKeypress(data);
+                if (action)
+                    handler(action);
+            };
+            process.stdin.on('data', dataHandler);
+        },
+        stop() {
+            if (dataHandler) {
+                process.stdin.removeListener('data', dataHandler);
+                dataHandler = null;
+            }
+            try {
+                if (process.stdin.isTTY) {
+                    process.stdin.setRawMode(false);
+                    process.stdin.pause();
+                }
+            }
+            catch {
+                // stdin may already be closed during shutdown
+            }
+        },
+    };
+}

package/dist/ui/status-line.d.ts

@@ -0,0 +1,6 @@
+export interface StatusLine {
+    /** Update with pre-styled text. ANSI colors are preserved in the bar. */
+    update(text: string): void;
+    destroy(): void;
+}
+export declare function createStatusLine(stream: NodeJS.WriteStream): StatusLine;

package/dist/ui/status-line.js

@@ -0,0 +1,53 @@
+import { stripAnsi } from './colors.js';
+// ANSI escape helpers for direct use in the bar (not through picocolors,
+// since we need to layer colors on top of the background)
+const BG_DARK = '\x1b[48;5;236m'; // dark gray background
+const RESET = '\x1b[0m';
+export function createStatusLine(stream) {
+    if (!stream.isTTY) {
+        return { update() { }, destroy() { } };
+    }
+    let lastStyled = '';
+    let lastPlainLen = 0;
+    let rows = stream.rows || 24;
+    let cols = stream.columns || 80;
+    const originalWrite = stream.write.bind(stream);
+    function setupScrollRegion() {
+        originalWrite(`\x1b[1;${rows - 1}r`);
+        originalWrite(`\x1b[${rows - 1};1H`);
+    }
+    function renderBar() {
+        if (!lastStyled)
+            return;
+        // Pad with spaces to fill the bar width (using plain length for calculation)
+        const padding = lastPlainLen < cols
+            ? ' '.repeat(cols - lastPlainLen)
+            : '';
+        // Render: dark background + styled content + padding + reset
+        originalWrite(`\x1b7\x1b[${rows};1H\x1b[2K${BG_DARK}${lastStyled}${padding}${RESET}\x1b8`);
+    }
+    // Handle terminal resize
+    function onResize() {
+        rows = stream.rows || 24;
+        cols = stream.columns || 80;
+        setupScrollRegion();
+        renderBar();
+    }
+    // Activate
+    setupScrollRegion();
+    stream.on('resize', onResize);
+    return {
+        update(text) {
+            lastStyled = ` ${text} `;
+            lastPlainLen = stripAnsi(lastStyled).length;
+            renderBar();
+        },
+        destroy() {
+            stream.removeListener('resize', onResize);
+            // Clear status bar and reset scroll region to full terminal
+            originalWrite(`\x1b7\x1b[${rows};1H\x1b[2K\x1b8`);
+            originalWrite(`\x1b[1;${rows}r`);
+            lastStyled = '';
+        },
+    };
+}

package/dist/utils/__tests__/prompt.test.js

@@ -1,103 +1,27 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-const mockQuestion = vi.fn();
-const mockClose = vi.fn();
-vi.mock('readline', () => ({
-    createInterface: () => ({
-        question: mockQuestion,
-        close: mockClose,
-    }),
-}));
-const { promptSelect, promptInput } = await import('../prompt.js');
-describe('utils/prompt', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
+import { describe, it, expect, vi } from 'vitest';
+import { promptSelect } from '../prompt.js';
+describe('promptSelect', () => {
+    it('throws when no choices available', async () => {
+        await expect(promptSelect('Pick:', [])).rejects.toThrow('No choices available');
     });
-    describe('promptSelect()', () => {
-        it('throws on empty choices array', async () => {
-            await expect(promptSelect('Pick one', [])).rejects.toThrow('No choices available');
-        });
-        it('auto-selects when only one choice', async () => {
-            const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
-            const result = await promptSelect('Pick one', [
-                { label: 'Only Option', value: 42 },
-            ]);
-            expect(result).toEqual({ label: 'Only Option', value: 42 });
-            expect(logSpy).toHaveBeenCalledWith('Pick one: Only Option');
-            logSpy.mockRestore();
-        });
-        it('auto-selects preserves all properties on the choice object', async () => {
-            const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
-            const choice = { label: 'Test', id: 'abc', extra: true };
-            const result = await promptSelect('Select', [choice]);
-            expect(result).toBe(choice);
-            logSpy.mockRestore();
-        });
-        it('returns correct choice by index when multiple choices', async () => {
-            const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
-            // promptSelect calls promptInput internally, which uses readline
-            // Mock the question callback to simulate user selecting "2"
-            mockQuestion.mockImplementation((_prompt, cb) => {
-                cb('2');
-            });
-            const choices = [
-                { label: 'First', id: 1 },
-                { label: 'Second', id: 2 },
-                { label: 'Third', id: 3 },
-            ];
-            const result = await promptSelect('Choose', choices);
-            expect(result).toEqual({ label: 'Second', id: 2 });
-            logSpy.mockRestore();
-        });
-        it('exits process on invalid selection', async () => {
-            const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
-            const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
-            const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {
-                throw new Error('process.exit');
-            }));
-            mockQuestion.mockImplementation((_prompt, cb) => {
-                cb('99');
-            });
-            const choices = [
-                { label: 'First', id: 1 },
-                { label: 'Second', id: 2 },
-            ];
-            await expect(promptSelect('Choose', choices)).rejects.toThrow('process.exit');
-            expect(exitSpy).toHaveBeenCalledWith(1);
-            logSpy.mockRestore();
-            errorSpy.mockRestore();
-            exitSpy.mockRestore();
-        });
+    it('returns single choice without prompting', async () => {
+        const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        const choice = { label: 'Only option', value: 'only' };
+        const result = await promptSelect('Pick:', [choice]);
+        expect(result).toBe(choice);
+        consoleSpy.mockRestore();
     });
-    describe('promptInput()', () => {
-        it('returns user input trimmed', async () => {
-            mockQuestion.mockImplementation((_prompt, cb) => {
-                cb('  user input  ');
-            });
-            const result = await promptInput('Enter value');
-            expect(result).toBe('user input');
-            expect(mockClose).toHaveBeenCalled();
-        });
-        it('returns default value when input is empty', async () => {
-            mockQuestion.mockImplementation((_prompt, cb) => {
-                cb('');
-            });
-            const result = await promptInput('Enter value', 'default-val');
-            expect(result).toBe('default-val');
-        });
-        it('includes default value hint in prompt', async () => {
-            mockQuestion.mockImplementation((_prompt, cb) => {
-                cb('answer');
-            });
-            await promptInput('Name', 'default');
-            const promptText = mockQuestion.mock.calls[0][0];
-            expect(promptText).toContain('[default]');
-        });
-        it('returns empty string when no input and no default', async () => {
-            mockQuestion.mockImplementation((_prompt, cb) => {
-                cb('  ');
-            });
-            const result = await promptInput('Enter');
-            expect(result).toBe('');
-        });
+    it('auto-selects preserves all properties on single choice', async () => {
+        const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        const choice = { label: 'Test', id: 'abc', extra: true };
+        const result = await promptSelect('Select', [choice]);
+        expect(result).toBe(choice);
+        consoleSpy.mockRestore();
+    });
+    it('logs message and choice label when single choice', async () => {
+        const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        await promptSelect('Pick one', [{ label: 'Only Option', value: 42 }]);
+        expect(consoleSpy).toHaveBeenCalledWith('Pick one: Only Option');
+        consoleSpy.mockRestore();
     });
 });

package/dist/utils/prompt.d.ts

@@ -2,3 +2,4 @@ export declare function promptSelect<T extends {
     label: string;
 }>(message: string, choices: T[]): Promise<T>;
 export declare function promptInput(message: string, defaultValue?: string): Promise<string>;
+export declare function promptConfirm(message: string): Promise<boolean>;

package/dist/utils/prompt.js

@@ -1,4 +1,4 @@
-import { createInterface } from 'readline';
+import { select, text, confirm, isCancel } from '@clack/prompts';
 export async function promptSelect(message, choices) {
     if (choices.length === 0) {
         throw new Error('No choices available');
@@ -7,28 +7,36 @@ export async function promptSelect(message, choices) {
         console.log(`${message}: ${choices[0].label}`);
         return choices[0];
     }
-    console.log(message);
-    for (let i = 0; i < choices.length; i++) {
-        console.log(`  ${i + 1}. ${choices[i].label}`);
-    }
-    const answer = await promptInput(`Select (1-${choices.length})`, '1');
-    const index = parseInt(answer, 10) - 1;
-    if (isNaN(index) || index < 0 || index >= choices.length) {
-        console.error('Invalid selection.');
-        process.exit(1);
+    const result = await select({
+        message,
+        options: choices.map((c, i) => ({
+            value: i,
+            label: c.label,
+        })),
+    });
+    if (isCancel(result)) {
+        console.log('Cancelled.');
+        process.exit(0);
     }
-    return choices[index];
+    return choices[result];
 }
 export async function promptInput(message, defaultValue) {
-    const rl = createInterface({
-        input: process.stdin,
-        output: process.stdout,
-    });
-    const suffix = defaultValue ? ` [${defaultValue}]` : '';
-    return new Promise((resolve) => {
-        rl.question(`${message}${suffix}: `, (answer) => {
-            rl.close();
-            resolve(answer.trim() || defaultValue || '');
-        });
+    const result = await text({
+        message,
+        defaultValue,
+        placeholder: defaultValue,
     });
+    if (isCancel(result)) {
+        console.log('Cancelled.');
+        process.exit(0);
+    }
+    return result.trim() || defaultValue || '';
+}
+export async function promptConfirm(message) {
+    const result = await confirm({ message });
+    if (isCancel(result)) {
+        console.log('Cancelled.');
+        process.exit(0);
+    }
+    return result;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runwork",
-  "version": "0.2.5",
+  "version": "0.3.0",
   "description": "CLI for Runwork: develop, preview, and deploy Runwork apps from your local machine.",
   "license": "UNLICENSED",
   "author": "Runwork <info@runwork.ai> (https://www.runwork.ai)",
@@ -41,10 +41,12 @@
     "release:full": "bun run release && bun run scripts/release-binaries.ts"
   },
   "dependencies": {
+    "@clack/prompts": "^1.1.0",
     "chokidar": "^4.0.0",
     "commander": "^13.0.0",
     "fflate": "^0.8.2",
-    "open": "^10.0.0"
+    "open": "^10.0.0",
+    "picocolors": "^1.1.1"
   },
   "devDependencies": {
     "typescript": "^5.7.0",