runwork 0.2.5 → 0.4.0

package/dist/logs/tailer.d.ts

@@ -6,7 +6,11 @@ interface TailerOptions {
     toTerminal: boolean;
     toFile: boolean;
     intervalMs?: number;
+    getFilter?: () => 'all' | 'events' | 'runtime';
+    useJson?: boolean;
 }
+export declare function formatLogLine(tag: string, line: string): string;
+export declare function formatRelativeTime(eventTimestamp?: string): string;
 export declare function startLogTailer(options: TailerOptions): {
     stop: () => void;
 };

package/dist/logs/tailer.js

@@ -1,5 +1,7 @@
 import { appendFileSync, mkdirSync, writeFileSync } from 'fs';
 import { join, dirname } from 'path';
+import { bold, red, yellow, cyan, gray, dim } from '../ui/colors.js';
+import { stripAnsi } from '../ui/colors.js';
 const LOG_FILE = '.runwork/logs.txt';
 function formatTime() {
     const now = new Date();
@@ -9,8 +11,35 @@ function formatTime() {
         String(now.getSeconds()).padStart(2, '0'),
     ].join(':');
 }
-function formatLogLine(tag, line) {
-    return `[${formatTime()}] [${tag}] ${line}`;
+export function formatLogLine(tag, line) {
+    const time = gray(formatTime());
+    let tagFormatted;
+    switch (tag) {
+        case 'ERROR':
+            tagFormatted = bold(red('ERROR  '));
+            break;
+        case 'EVENT':
+            tagFormatted = yellow('EVENT  ');
+            break;
+        case 'RUNTIME':
+            tagFormatted = cyan('RUNTIME');
+            break;
+        default:
+            tagFormatted = dim(tag.padEnd(7));
+    }
+    return `  ${time} ${tagFormatted}  ${line}`;
+}
+export function formatRelativeTime(eventTimestamp) {
+    if (!eventTimestamp)
+        return formatTime();
+    const diff = Date.now() - new Date(eventTimestamp).getTime();
+    if (diff < 0)
+        return 'now';
+    if (diff < 60_000)
+        return `${Math.floor(diff / 1000)}s ago`;
+    if (diff < 3_600_000)
+        return `${Math.floor(diff / 60_000)}m ago`;
+    return formatTime();
 }
 export function startLogTailer(options) {
     const { appId, client, projectDir, toTerminal, toFile, intervalMs = 5000, } = options;
@@ -25,18 +54,30 @@ export function startLogTailer(options) {
     let seenEventIds = new Set();
     let stopped = false;
     let timer;
-    function writeLine(line) {
-        if (toTerminal) {
-            console.log(line);
-        }
+    function writeLineFiltered(line, tag, jsonData) {
+        // Always write to file (stripped of ANSI codes)
         if (toFile) {
             try {
-                appendFileSync(logFilePath, line + '\n', 'utf-8');
+                appendFileSync(logFilePath, stripAnsi(line) + '\n', 'utf-8');
             }
             catch {
                 // Silently ignore file write errors
             }
         }
+        if (!toTerminal)
+            return;
+        // JSON mode: emit NDJSON line
+        if (options.useJson && jsonData) {
+            process.stdout.write(JSON.stringify(jsonData) + '\n');
+            return;
+        }
+        // Human mode: apply filter and print colored line
+        const filter = options.getFilter?.() || 'all';
+        if (filter === 'events' && tag !== 'EVENT')
+            return;
+        if (filter === 'runtime' && tag !== 'RUNTIME' && tag !== 'ERROR')
+            return;
+        console.log(line);
     }
     async function poll() {
         if (stopped)
@@ -55,7 +96,9 @@ export function startLogTailer(options) {
                 const newContent = logs.stdout.slice(lastStdoutLength);
                 const lines = newContent.split('\n').filter(Boolean);
                 for (const line of lines) {
-                    writeLine(formatLogLine('RUNTIME', line));
+                    writeLineFiltered(formatLogLine('RUNTIME', line), 'RUNTIME', {
+                        event: 'log', type: 'runtime', message: line, timestamp: new Date().toISOString(),
+                    });
                 }
                 lastStdoutLength = logs.stdout.length;
             }
@@ -63,7 +106,9 @@ export function startLogTailer(options) {
                 const newContent = logs.stderr.slice(lastStderrLength);
                 const lines = newContent.split('\n').filter(Boolean);
                 for (const line of lines) {
-                    writeLine(formatLogLine('ERROR', line));
+                    writeLineFiltered(formatLogLine('ERROR', line), 'ERROR', {
+                        event: 'log', type: 'error', message: line, timestamp: new Date().toISOString(),
+                    });
                 }
                 lastStderrLength = logs.stderr.length;
             }
@@ -98,7 +143,10 @@ export function startLogTailer(options) {
                             detail += ` [${meta.path}]`;
                         }
                     }
-                    writeLine(formatLogLine('EVENT', `${event.type}: ${detail}`));
+                    const relTime = gray(formatRelativeTime(event.timestamp));
+                    writeLineFiltered(`  ${relTime} ${yellow('EVENT  ')}  ${event.type}: ${detail}`, 'EVENT', {
+                        event: 'log', type: 'event', eventType: event.type, detail, metadata: event.metadata || {}, timestamp: event.timestamp,
+                    });
                     seenEventIds.add(event.id);
                 }
                 // Cap the set size to prevent unbounded growth (keep last 200 IDs)

package/dist/types.d.ts

@@ -1,5 +1,6 @@
 export interface RunworkConfig {
     workspaceId: string;
+    workspaceName?: string;
     appId: string;
     appName: string;
 }
@@ -25,3 +26,61 @@ export interface WorkspaceInfo {
     id: string;
     name: string;
 }
+export interface RegistryEntity {
+    entityName: string;
+    appId: string;
+    appName: string;
+    schema?: Record<string, unknown>;
+    deploymentMode?: 'preview' | 'production';
+}
+export interface RegistrySchedule {
+    name: string;
+    appId: string;
+    appName: string;
+    schedule?: string;
+    description?: string;
+    deploymentMode?: 'preview' | 'production';
+}
+export interface RegistryWorkflow {
+    name: string;
+    appId: string;
+    appName: string;
+    description?: string;
+    deploymentMode?: 'preview' | 'production';
+}
+export interface RegistryAgent {
+    name: string;
+    appId: string;
+    appName: string;
+    type?: string;
+    description?: string;
+    deploymentMode?: 'preview' | 'production';
+}
+export interface RegistryEndpoint {
+    appId: string;
+    appName: string;
+    path: string;
+    method: string;
+    description?: string;
+    deploymentMode?: 'preview' | 'production';
+}
+export interface RegistryComponent {
+    componentName: string;
+    appId: string;
+    appName: string;
+    deploymentMode?: 'preview' | 'production';
+}
+export interface RegistryFileStorage {
+    appId: string;
+    appName: string;
+    deploymentMode?: 'preview' | 'production';
+}
+export interface WorkspaceAllData {
+    entities: RegistryEntity[];
+    schedules: RegistrySchedule[];
+    workflows: RegistryWorkflow[];
+    agents: RegistryAgent[];
+    endpoints: RegistryEndpoint[];
+    components: RegistryComponent[];
+    fileStorages: RegistryFileStorage[];
+}

package/dist/ui/__tests__/banner.test.d.ts

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

package/dist/ui/__tests__/banner.test.js

@@ -0,0 +1,82 @@
+import { describe, it, expect } from 'vitest';
+import { getAgentCommand, SUPPORTED_AGENTS, getDevBanner, getKeyboardHints, getWelcomeBanner, getInfoPanel } from '../banner.js';
+import { stripAnsi } from '../colors.js';
+describe('getAgentCommand', () => {
+    it('returns claude command for a directory', () => {
+        const cmd = getAgentCommand('claude-code', '/path/to/app');
+        expect(cmd).toContain('claude');
+        expect(cmd).toContain('/path/to/app');
+    });
+    it('returns cursor command', () => {
+        expect(getAgentCommand('cursor', '/path')).toContain('cursor');
+    });
+    it('returns codex command', () => {
+        expect(getAgentCommand('codex', '/path')).toContain('codex');
+    });
+    it('returns null for unknown agent', () => {
+        expect(getAgentCommand('unknown-agent', '/path')).toBe(null);
+    });
+});
+describe('SUPPORTED_AGENTS', () => {
+    it('includes common agents', () => {
+        const ids = SUPPORTED_AGENTS.map(a => a.id);
+        expect(ids).toContain('claude-code');
+        expect(ids).toContain('cursor');
+        expect(ids).toContain('codex');
+    });
+});
+describe('getDevBanner', () => {
+    it('includes preview URL and app name', () => {
+        const banner = getDevBanner({ appName: 'test-app', previewUrl: 'https://test.runwork.dev' });
+        const plain = stripAnsi(banner);
+        expect(plain).toContain('https://test.runwork.dev');
+        expect(plain).toContain('test-app');
+    });
+});
+describe('getKeyboardHints', () => {
+    it('includes shortcut keys', () => {
+        const hints = stripAnsi(getKeyboardHints());
+        expect(hints).toContain('o');
+        expect(hints).toContain('q');
+    });
+});
+describe('getInfoPanel', () => {
+    it('includes app info and agent commands', () => {
+        const panel = getInfoPanel({
+            appName: 'my-app',
+            previewUrl: 'https://test.dev',
+            workspaceName: 'my-ws',
+            directory: '/path/to/app',
+        });
+        const plain = stripAnsi(panel);
+        expect(plain).toContain('my-app');
+        expect(plain).toContain('https://test.dev');
+        expect(plain).toContain('my-ws');
+        expect(plain).toContain('/path/to/app');
+        expect(plain).toContain('Claude Code');
+        expect(plain).toContain('Cursor');
+    });
+    it('omits workspace when not provided', () => {
+        const panel = getInfoPanel({
+            appName: 'my-app',
+            previewUrl: 'https://test.dev',
+            directory: '/path',
+        });
+        const plain = stripAnsi(panel);
+        expect(plain).not.toContain('Workspace');
+    });
+});
+describe('getDevBanner', () => {
+    it('includes workspace name when provided', () => {
+        const banner = getDevBanner({ appName: 'app', previewUrl: 'https://x', workspaceName: 'ws' });
+        const plain = stripAnsi(banner);
+        expect(plain).toContain('ws');
+    });
+});
+describe('getWelcomeBanner', () => {
+    it('includes Runwork name and mentions AI agents', () => {
+        const text = stripAnsi(getWelcomeBanner());
+        expect(text).toContain('Runwork');
+        expect(text).toContain('Claude');
+    });
+});

package/dist/ui/__tests__/colors.test.d.ts

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

package/dist/ui/__tests__/colors.test.js

@@ -0,0 +1,22 @@
+import { describe, it, expect } from 'vitest';
+import { bold, red, green, yellow, cyan, dim, gray, stripAnsi, pc } from '../colors.js';
+describe('colors', () => {
+    it('re-exports picocolors functions that produce strings', () => {
+        // Verify they're callable and return strings (not just that they exist)
+        expect(bold('test')).toEqual(expect.any(String));
+        expect(red('test')).toEqual(expect.any(String));
+        expect(green('test')).toEqual(expect.any(String));
+        expect(yellow('test')).toEqual(expect.any(String));
+        expect(cyan('test')).toEqual(expect.any(String));
+        expect(dim('test')).toEqual(expect.any(String));
+        expect(gray('test')).toEqual(expect.any(String));
+    });
+    it('exports the full picocolors object', () => {
+        expect(typeof pc.bold).toBe('function');
+    });
+    it('strips ANSI codes', () => {
+        expect(stripAnsi('\x1b[1mhello\x1b[22m')).toBe('hello');
+        expect(stripAnsi('no codes')).toBe('no codes');
+        expect(stripAnsi('\x1b[31m\x1b[1mfail\x1b[22m\x1b[39m')).toBe('fail');
+    });
+});

package/dist/ui/__tests__/keyboard.test.d.ts

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

package/dist/ui/__tests__/keyboard.test.js

@@ -0,0 +1,30 @@
+import { describe, it, expect } from 'vitest';
+import { parseKeypress } from '../keyboard.js';
+describe('parseKeypress', () => {
+    it('detects "o" key', () => {
+        expect(parseKeypress(Buffer.from('o'))).toBe('o');
+    });
+    it('detects uppercase "O" as lowercase', () => {
+        expect(parseKeypress(Buffer.from('O'))).toBe('o');
+    });
+    it('detects "p" key', () => {
+        expect(parseKeypress(Buffer.from('p'))).toBe('p');
+    });
+    it('detects Ctrl+C as quit', () => {
+        expect(parseKeypress(Buffer.from([0x03]))).toBe('quit');
+    });
+    it('detects "q" as quit', () => {
+        expect(parseKeypress(Buffer.from('q'))).toBe('quit');
+    });
+    it('returns null for unknown keys', () => {
+        expect(parseKeypress(Buffer.from('x'))).toBe(null);
+    });
+    it('detects log filter keys (a, e, r)', () => {
+        expect(parseKeypress(Buffer.from('a'))).toBe('a');
+        expect(parseKeypress(Buffer.from('e'))).toBe('e');
+        expect(parseKeypress(Buffer.from('r'))).toBe('r');
+    });
+    it('detects "i" for info', () => {
+        expect(parseKeypress(Buffer.from('i'))).toBe('i');
+    });
+});

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

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

package/dist/ui/__tests__/status-line.test.js

@@ -0,0 +1,54 @@
+import { describe, it, expect, vi } from 'vitest';
+import { createStatusLine } from '../status-line.js';
+function createMockStream() {
+    const mockWrite = vi.fn().mockReturnValue(true);
+    return {
+        write: mockWrite,
+        isTTY: true,
+        rows: 24,
+        columns: 80,
+        on: vi.fn(),
+        removeListener: vi.fn(),
+    };
+}
+describe('createStatusLine', () => {
+    it('returns a no-op status line when not a TTY', () => {
+        const stream = createMockStream();
+        stream.isTTY = false;
+        const status = createStatusLine(stream);
+        status.update('test');
+        expect(stream.write).not.toHaveBeenCalled();
+    });
+    it('sets up scroll region on creation for TTY', () => {
+        const stream = createMockStream();
+        createStatusLine(stream);
+        // Should have written scroll region escape sequence
+        const output = stream.write.mock.calls.map((c) => c[0]).join('');
+        // Scroll region: \x1b[1;23r (rows-1 = 23)
+        expect(output).toContain('\x1b[1;23r');
+    });
+    it('writes status text with inverse styling', () => {
+        const stream = createMockStream();
+        const status = createStatusLine(stream);
+        status.update('Watching | 3 files synced');
+        const output = stream.write.mock.calls.map((c) => c[0]).join('');
+        expect(output).toContain('Watching');
+    });
+    it('listens for resize events', () => {
+        const stream = createMockStream();
+        createStatusLine(stream);
+        expect(stream.on).toHaveBeenCalledWith('resize', expect.any(Function));
+    });
+    it('cleans up on destroy', () => {
+        const stream = createMockStream();
+        const status = createStatusLine(stream);
+        status.update('test');
+        stream.write.mockClear();
+        status.destroy();
+        expect(stream.write).toHaveBeenCalled();
+        expect(stream.removeListener).toHaveBeenCalledWith('resize', expect.any(Function));
+        // Should reset scroll region to full terminal
+        const output = stream.write.mock.calls.map((c) => c[0]).join('');
+        expect(output).toContain('\x1b[1;24r');
+    });
+});

package/dist/ui/banner.d.ts

@@ -0,0 +1,29 @@
+export interface AgentInfo {
+    id: string;
+    name: string;
+    /** Shell command to open the agent in a directory. {dir} is replaced with the path. */
+    command: string;
+}
+export declare const SUPPORTED_AGENTS: AgentInfo[];
+export declare function getAgentCommand(agentId: string, directory: string): string | null;
+export declare function getAgentGuidance(directory: string): string;
+export interface DevBannerOptions {
+    appName: string;
+    previewUrl: string;
+    workspaceName?: string;
+}
+export declare function getDevBanner(options: DevBannerOptions): string;
+export declare function getKeyboardHints(): string;
+/**
+ * Interactive wizard that asks which AI agent the user wants to use,
+ * then shows specific instructions for opening this app in that agent.
+ */
+export declare function runAgentWizard(directory: string): Promise<void>;
+/**
+ * Returns full info panel (for 'i' key in dev mode) showing
+ * workspace, app, preview URL, and agent guidance.
+ */
+export declare function getInfoPanel(options: DevBannerOptions & {
+    directory: string;
+}): string;
+export declare function getWelcomeBanner(): string;

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;