profclaw 2.0.0 → 2.3.0

package/dist/cli/interactive/auto-serve.js

@@ -0,0 +1,209 @@
+/**
+ * Auto-Serve
+ *
+ * Automatically starts the profClaw server if it's not running.
+ * Inspired by OpenClaw's pattern where the CLI "just works" -
+ * you type `openclaw` and it handles server lifecycle.
+ *
+ * @package profclaw-interactive (future standalone)
+ */
+import { spawn } from 'node:child_process';
+import { resolve } from 'node:path';
+import { existsSync, readFileSync } from 'node:fs';
+import chalk from 'chalk';
+/**
+ * Simple .env file parser (no external dependency).
+ * Handles KEY=VALUE, KEY="VALUE", comments (#), and empty lines.
+ */
+function loadDotEnv(filePath) {
+    const vars = {};
+    try {
+        if (!existsSync(filePath))
+            return vars;
+        const content = readFileSync(filePath, 'utf-8');
+        for (const line of content.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#'))
+                continue;
+            const eqIdx = trimmed.indexOf('=');
+            if (eqIdx === -1)
+                continue;
+            const key = trimmed.slice(0, eqIdx).trim();
+            let value = trimmed.slice(eqIdx + 1).trim();
+            // Strip surrounding quotes
+            if ((value.startsWith('"') && value.endsWith('"')) ||
+                (value.startsWith("'") && value.endsWith("'"))) {
+                value = value.slice(1, -1);
+            }
+            if (key)
+                vars[key] = value;
+        }
+    }
+    catch { /* ignore */ }
+    return vars;
+}
+/**
+ * Check if the profClaw server is reachable.
+ */
+export async function checkServer(baseUrl) {
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 3000);
+        const response = await fetch(`${baseUrl}/health`, {
+            signal: controller.signal,
+            headers: { 'Accept': 'application/json' },
+        });
+        clearTimeout(timeout);
+        // Verify it's actually profClaw (not some other service on the same port)
+        const text = await response.text();
+        if (text.startsWith('<!DOCTYPE') || text.startsWith('<html')) {
+            // Got HTML - some other service is on this port
+            return false;
+        }
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Find the server entry point.
+ */
+function findServerEntry() {
+    // Try common locations relative to the package root
+    const candidates = [
+        resolve(process.cwd(), 'dist/server.js'),
+        resolve(process.cwd(), 'src/server.ts'),
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+/**
+ * Start the profClaw server as a background child process.
+ * Returns when the server is healthy or times out.
+ */
+export async function autoStartServer(options) {
+    const port = options.port || 3000;
+    // First check if server is already running
+    const alreadyRunning = await checkServer(options.baseUrl);
+    if (alreadyRunning) {
+        return { success: true };
+    }
+    if (!options.silent) {
+        process.stdout.write(chalk.dim('  Starting server...'));
+    }
+    const serverEntry = findServerEntry();
+    if (!serverEntry) {
+        return {
+            success: false,
+            error: 'Cannot find server entry point. Run `pnpm build` first, or start the server manually with `pnpm dev`.',
+        };
+    }
+    // Determine runner based on file extension
+    const isTsFile = serverEntry.endsWith('.ts');
+    const runner = isTsFile ? 'tsx' : 'node';
+    // Load .env file (no dotenv dependency - simple parser)
+    const dotenvVars = loadDotEnv(resolve(process.cwd(), '.env'));
+    const env = {
+        ...process.env,
+        ...dotenvVars,
+        PORT: String(port),
+        NODE_ENV: process.env.NODE_ENV || 'development',
+    };
+    // Spawn server as fully detached child (cwd = project root for data/ access)
+    // Use 'ignore' for all stdio so the child is truly independent
+    // We'll detect readiness via HTTP health checks instead of stdout parsing
+    let serverProcess;
+    try {
+        serverProcess = spawn(runner, [serverEntry], {
+            env,
+            cwd: process.cwd(),
+            stdio: 'ignore',
+            detached: true,
+        });
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to start server: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+    // Track if process exits early
+    let startupError = '';
+    serverProcess.on('error', (err) => {
+        startupError = err.message;
+    });
+    serverProcess.on('exit', (code) => {
+        if (code !== null && code !== 0) {
+            startupError = `Server exited with code ${code}`;
+        }
+    });
+    // Fully detach - CLI can exit and server keeps running
+    serverProcess.unref();
+    // Wait for server to become healthy
+    const maxWaitMs = 15000;
+    const pollIntervalMs = 500;
+    const startTime = Date.now();
+    while (Date.now() - startTime < maxWaitMs) {
+        // Check for early crash
+        if (startupError) {
+            if (startupError.includes('EADDRINUSE')) {
+                return {
+                    success: false,
+                    error: `Port ${port} is already in use. Kill the process or use: PORT=${port + 1} profclaw chat`,
+                };
+            }
+            if (startupError.includes('exited with code')) {
+                return { success: false, error: `Server crashed: ${startupError.slice(0, 300)}` };
+            }
+            // Non-fatal stderr (e.g. warnings) - continue waiting
+        }
+        const healthy = await checkServer(options.baseUrl);
+        if (healthy) {
+            if (!options.silent) {
+                console.log(chalk.green(' ready'));
+            }
+            return { success: true, pid: serverProcess.pid };
+        }
+        await new Promise((r) => setTimeout(r, pollIntervalMs));
+    }
+    return {
+        success: false,
+        error: startupError
+            ? `Server failed: ${startupError.slice(0, 300)}`
+            : `Server did not respond within ${maxWaitMs / 1000}s. Try starting manually: pnpm dev`,
+    };
+}
+/**
+ * Ensure the server is running. Auto-starts if needed.
+ * This is the main entry point for the "just works" pattern.
+ */
+export async function ensureServer(baseUrl, options) {
+    const isRunning = await checkServer(baseUrl);
+    if (isRunning) {
+        return { ok: true };
+    }
+    if (options?.autoStart === false) {
+        return {
+            ok: false,
+            error: `profClaw server is not running at ${baseUrl}. Start it with: pnpm dev`,
+        };
+    }
+    // Extract port from URL
+    const portMatch = baseUrl.match(/:(\d+)/);
+    const port = portMatch ? parseInt(portMatch[1]) : 3000;
+    const result = await autoStartServer({
+        port,
+        baseUrl,
+        silent: options?.silent,
+    });
+    if (!result.success) {
+        return { ok: false, error: result.error };
+    }
+    return { ok: true };
+}
+//# sourceMappingURL=auto-serve.js.map

package/dist/cli/interactive/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * profClaw Interactive CLI
+ *
+ * Claude-like interactive chat with streaming responses, tool display,
+ * markdown rendering, slash commands, and session management.
+ *
+ * Designed as a self-contained module that can be extracted to its own
+ * package in the future (e.g., @profclaw/interactive or profclaw-cli).
+ *
+ * Dependencies (all peer/optional in standalone mode):
+ *   - chalk (terminal colors)
+ *   - ora (spinners)
+ *   - node:readline (input)
+ *   - node:fs (history persistence)
+ *
+ * @package profclaw-interactive
+ */
+export { startInteractiveREPL } from './repl.js';
+export { createRenderer, renderMarkdownLite, formatElapsed, formatTokens, highlightCode } from './renderer.js';
+export { streamChat, createConversation, sendMessage } from './stream-client.js';
+export { ensureServer, checkServer, autoStartServer } from './auto-serve.js';
+export { showPicker } from './picker.js';
+export type { PickerItem, PickerOptions } from './picker.js';
+export type { InteractiveOptions, REPLState, SlashCommand, ServerConfig, Session, ChatMessage, ToolCallInfo, TokenUsage, SSEEvent, SSEEventType, Renderer, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/interactive/index.js

@@ -0,0 +1,23 @@
+/**
+ * profClaw Interactive CLI
+ *
+ * Claude-like interactive chat with streaming responses, tool display,
+ * markdown rendering, slash commands, and session management.
+ *
+ * Designed as a self-contained module that can be extracted to its own
+ * package in the future (e.g., @profclaw/interactive or profclaw-cli).
+ *
+ * Dependencies (all peer/optional in standalone mode):
+ *   - chalk (terminal colors)
+ *   - ora (spinners)
+ *   - node:readline (input)
+ *   - node:fs (history persistence)
+ *
+ * @package profclaw-interactive
+ */
+export { startInteractiveREPL } from './repl.js';
+export { createRenderer, renderMarkdownLite, formatElapsed, formatTokens, highlightCode } from './renderer.js';
+export { streamChat, createConversation, sendMessage } from './stream-client.js';
+export { ensureServer, checkServer, autoStartServer } from './auto-serve.js';
+export { showPicker } from './picker.js';
+//# sourceMappingURL=index.js.map

package/dist/cli/interactive/picker.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Interactive Picker
+ *
+ * Arrow-key navigable selection menu for the terminal.
+ * Used for session picker, model picker, provider picker, etc.
+ *
+ * @package profclaw-interactive (future standalone)
+ */
+export interface PickerItem {
+    id: string;
+    label: string;
+    description?: string;
+    dimLabel?: boolean;
+}
+export interface PickerOptions {
+    title: string;
+    items: PickerItem[];
+    /** Allow filtering by typing */
+    filterable?: boolean;
+    /** Max items to show at once (scrolls) */
+    pageSize?: number;
+}
+/**
+ * Show an interactive picker menu.
+ * Returns the selected item ID, or null if cancelled (Escape/Ctrl+C).
+ */
+export declare function showPicker(options: PickerOptions): Promise<string | null>;
+//# sourceMappingURL=picker.d.ts.map

package/dist/cli/interactive/picker.js

@@ -0,0 +1,153 @@
+/**
+ * Interactive Picker
+ *
+ * Arrow-key navigable selection menu for the terminal.
+ * Used for session picker, model picker, provider picker, etc.
+ *
+ * @package profclaw-interactive (future standalone)
+ */
+import chalk from 'chalk';
+/**
+ * Show an interactive picker menu.
+ * Returns the selected item ID, or null if cancelled (Escape/Ctrl+C).
+ */
+export function showPicker(options) {
+    return new Promise((resolve) => {
+        const { title, items, pageSize = 10 } = options;
+        const filterable = options.filterable !== false;
+        if (items.length === 0) {
+            console.log(chalk.dim('  No items to select.'));
+            resolve(null);
+            return;
+        }
+        let selectedIndex = 0;
+        let filter = '';
+        let filteredItems = [...items];
+        let scrollOffset = 0;
+        const gold = chalk.hex('#F6C453');
+        const dim = chalk.dim;
+        const mint = chalk.hex('#7DD3A5');
+        const border = chalk.hex('#3C414B');
+        const H = '\u2500';
+        const POINTER = '\u25b8'; // ▸
+        const w = Math.min((process.stdout.columns || 80) - 4, 68);
+        function applyFilter() {
+            if (!filter) {
+                filteredItems = [...items];
+            }
+            else {
+                const lower = filter.toLowerCase();
+                filteredItems = items.filter((item) => item.label.toLowerCase().includes(lower) ||
+                    item.id.toLowerCase().includes(lower) ||
+                    (item.description || '').toLowerCase().includes(lower));
+            }
+            selectedIndex = Math.min(selectedIndex, Math.max(0, filteredItems.length - 1));
+            scrollOffset = Math.max(0, Math.min(scrollOffset, filteredItems.length - pageSize));
+        }
+        function render() {
+            // Clear previous render
+            const totalLines = 3 + Math.min(filteredItems.length, pageSize) + (filterable ? 1 : 0) + 2;
+            process.stdout.write(`\x1b[${totalLines}A\x1b[J`);
+            // Header
+            console.log('');
+            console.log(`  ${border(H.repeat(w))}`);
+            console.log(`  ${gold.bold(title)}${filter ? dim(`  filter: ${filter}`) : ''}`);
+            // Items
+            const visibleStart = scrollOffset;
+            const visibleEnd = Math.min(filteredItems.length, scrollOffset + pageSize);
+            if (visibleStart > 0) {
+                console.log(dim(`  ${'  '}... ${visibleStart} more above`));
+            }
+            for (let i = visibleStart; i < visibleEnd; i++) {
+                const item = filteredItems[i];
+                const isSelected = i === selectedIndex;
+                const pointer = isSelected ? gold(POINTER) : ' ';
+                const label = isSelected
+                    ? chalk.bold(item.label)
+                    : item.dimLabel ? dim(item.label) : item.label;
+                const desc = item.description ? dim(` ${item.description}`) : '';
+                const id = dim(` ${item.id.slice(0, 8)}`);
+                console.log(`  ${pointer} ${label}${desc}${id}`);
+            }
+            if (visibleEnd < filteredItems.length) {
+                console.log(dim(`  ${'  '}... ${filteredItems.length - visibleEnd} more below`));
+            }
+            // Footer
+            console.log(`  ${border(H.repeat(w))}`);
+            console.log(dim(`  \u2191\u2193 navigate \u00b7 enter select \u00b7 esc cancel${filterable ? ' \u00b7 type to filter' : ''}`));
+        }
+        // Print initial blank lines to give render() space to overwrite
+        const initialLines = 3 + Math.min(items.length, pageSize) + 2;
+        for (let i = 0; i < initialLines; i++)
+            console.log('');
+        render();
+        // Enter raw mode to capture keystrokes
+        if (!process.stdin.isRaw) {
+            process.stdin.setRawMode(true);
+        }
+        process.stdin.resume();
+        const onKeypress = (chunk) => {
+            const key = chunk.toString();
+            // Escape
+            if (key === '\x1b' || key === '\x03') {
+                cleanup();
+                resolve(null);
+                return;
+            }
+            // Enter
+            if (key === '\r' || key === '\n') {
+                if (filteredItems.length > 0) {
+                    const selected = filteredItems[selectedIndex];
+                    cleanup();
+                    resolve(selected.id);
+                    return;
+                }
+            }
+            // Arrow up
+            if (key === '\x1b[A') {
+                if (selectedIndex > 0) {
+                    selectedIndex--;
+                    if (selectedIndex < scrollOffset)
+                        scrollOffset = selectedIndex;
+                }
+                render();
+                return;
+            }
+            // Arrow down
+            if (key === '\x1b[B') {
+                if (selectedIndex < filteredItems.length - 1) {
+                    selectedIndex++;
+                    if (selectedIndex >= scrollOffset + pageSize)
+                        scrollOffset = selectedIndex - pageSize + 1;
+                }
+                render();
+                return;
+            }
+            // Backspace
+            if (key === '\x7f' || key === '\b') {
+                if (filter.length > 0) {
+                    filter = filter.slice(0, -1);
+                    applyFilter();
+                    render();
+                }
+                return;
+            }
+            // Printable character (filter)
+            if (filterable && key.length === 1 && key >= ' ' && key <= '~') {
+                filter += key;
+                applyFilter();
+                render();
+                return;
+            }
+        };
+        function cleanup() {
+            process.stdin.removeListener('data', onKeypress);
+            process.stdin.setRawMode(false);
+            // Clear the picker display
+            const totalLines = 3 + Math.min(filteredItems.length, pageSize) + 2;
+            process.stdout.write(`\x1b[${totalLines}A\x1b[J`);
+        }
+        process.stdin.on('data', onKeypress);
+    });
+}
+//# sourceMappingURL=picker.js.map

package/dist/cli/interactive/renderer.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Terminal Renderer - Polished CLI Output
+ *
+ * Design inspired by Claude Code, OpenClaw, Charm.sh, and clig.dev:
+ *
+ *   - Response text indented 2 spaces for visual separation from prompt
+ *   - Tool calls framed with thin Unicode box-drawing lines
+ *   - Markdown rendered inline (bold, code, lists, headings, quotes)
+ *   - Streaming markdown: lines formatted as they complete
+ *   - Syntax highlighting for common languages in code blocks
+ *   - Word-wrap respects terminal width
+ *   - Color used intentionally: cyan for links, gold for code, dim for chrome
+ *   - Progress within 100ms (spinner starts immediately)
+ *   - Errors are actionable, not cryptic
+ *   - Respects NO_COLOR env var
+ *   - Cost/time shown only when meaningful
+ *
+ * @package profclaw-interactive (future standalone)
+ */
+import type { Renderer } from './types.js';
+export declare function highlightCode(line: string, lang: string): string;
+export declare function formatElapsed(ms: number): string;
+export declare function formatTokens(count: number): string;
+export declare function renderMarkdownLite(text: string): string;
+export declare function createRenderer(): Renderer;
+//# sourceMappingURL=renderer.d.ts.map