runwork 0.2.5 → 0.4.0

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__/output.test.d.ts

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

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

@@ -0,0 +1,38 @@
+import { describe, it, expect, vi } from 'vitest';
+import { shouldOutputJson, jsonOut, jsonLine } from '../output.js';
+describe('shouldOutputJson', () => {
+    it('returns true when json flag is true', () => {
+        expect(shouldOutputJson(true)).toBe(true);
+    });
+    it('returns false when json flag is false (--no-json)', () => {
+        expect(shouldOutputJson(false)).toBe(false);
+    });
+    it('returns false when undefined and stdout is TTY', () => {
+        const original = process.stdout.isTTY;
+        Object.defineProperty(process.stdout, 'isTTY', { value: true, writable: true });
+        expect(shouldOutputJson(undefined)).toBe(false);
+        Object.defineProperty(process.stdout, 'isTTY', { value: original, writable: true });
+    });
+    it('returns true when undefined and stdout is not TTY', () => {
+        const original = process.stdout.isTTY;
+        Object.defineProperty(process.stdout, 'isTTY', { value: false, writable: true });
+        expect(shouldOutputJson(undefined)).toBe(true);
+        Object.defineProperty(process.stdout, 'isTTY', { value: original, writable: true });
+    });
+});
+describe('jsonOut', () => {
+    it('writes JSON to stdout with newline', () => {
+        const spy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        jsonOut({ hello: 'world' });
+        expect(spy).toHaveBeenCalledWith('{"hello":"world"}\n');
+        spy.mockRestore();
+    });
+});
+describe('jsonLine', () => {
+    it('writes a single NDJSON line', () => {
+        const spy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        jsonLine({ event: 'test', ts: 123 });
+        expect(spy).toHaveBeenCalledWith('{"event":"test","ts":123}\n');
+        spy.mockRestore();
+    });
+});

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

@@ -0,0 +1,17 @@
+/**
+ * JSON output utilities for agent-friendly CLI.
+ *
+ * When stdout is not a TTY (piped/captured by an agent), output switches
+ * to machine-readable JSON automatically. The --json flag forces it.
+ */
+/**
+ * Determine whether to output JSON based on:
+ * 1. Explicit --json flag (true)
+ * 2. Explicit --no-json flag (false)
+ * 3. Auto-detect: non-TTY stdout means agent/pipe, output JSON
+ */
+export declare function shouldOutputJson(jsonFlag: boolean | undefined): boolean;
+/** Write a single JSON object to stdout (for one-shot commands). */
+export declare function jsonOut(data: unknown): void;
+/** Write one NDJSON line to stdout (for streaming commands). */
+export declare function jsonLine(data: unknown): void;

package/dist/utils/output.js

@@ -0,0 +1,27 @@
+/**
+ * JSON output utilities for agent-friendly CLI.
+ *
+ * When stdout is not a TTY (piped/captured by an agent), output switches
+ * to machine-readable JSON automatically. The --json flag forces it.
+ */
+/**
+ * Determine whether to output JSON based on:
+ * 1. Explicit --json flag (true)
+ * 2. Explicit --no-json flag (false)
+ * 3. Auto-detect: non-TTY stdout means agent/pipe, output JSON
+ */
+export function shouldOutputJson(jsonFlag) {
+    if (jsonFlag === true)
+        return true;
+    if (jsonFlag === false)
+        return false;
+    return !process.stdout.isTTY;
+}
+/** Write a single JSON object to stdout (for one-shot commands). */
+export function jsonOut(data) {
+    process.stdout.write(JSON.stringify(data) + '\n');
+}
+/** Write one NDJSON line to stdout (for streaming commands). */
+export function jsonLine(data) {
+    process.stdout.write(JSON.stringify(data) + '\n');
+}

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.4.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",