4runr-os 2.1.2 → 2.1.5

package/dist/ui/v4/index.js

@@ -1,993 +0,0 @@
-#!/usr/bin/env node
-/**
- * 4Runr Terminal UI V4 - Main Entry
- *
- * ⚠️ FROZEN STATUS ⚠️
- *
- * This version is FROZEN due to display issues.
- * Development has moved to V5.
- *
- * DO NOT MODIFY THIS CODE.
- *
- * Phase 2: Bulletproof Layout + Resize System
- *
- * Boot with: TUI_V4=1 (NOT RECOMMENDED)
- *
- * See FROZEN.md for details.
- */
-import blessed from 'neo-blessed';
-import { eventBus } from '../../core/eventBus.js';
-import { commandRegistry } from '../../core/commandRegistry.js';
-import { executeCommandLine } from '../../core/commandExecutor.js';
-import { handleSizeCommandWithScreen } from '../../core/commands/size.js';
-import { computeLayout, validateLayoutInvariant } from './layout/layoutEngine.js';
-import { initResizeController, destroyResizeController, getResizeStats, getTerminalSize } from './engine/resizeController.js';
-import { getSafeViewport } from './engine/safeViewport.js';
-import { renderFrame } from './engine/renderFrame.js';
-import { getTerminalProfile } from './engine/terminalProfile.js';
-import { attachTuiRuntime } from './runtime/keepAlive.js';
-import { tuiDebug, tuiError } from './runtime/logger.js';
-/**
- * Contract C: Stdout is owned by the TUI (no logs)
- *
- * Rule: once the screen is created:
- * - no console.log
- * - no raw process.stdout.write
- * - all debug goes to stderr or a file
- * - all user output goes through Operations feed only
- *
- * Code-level guard: monkey-patch console.log to redirect to stderr
- */
-let screenCreated = false;
-const originalConsoleLog = console.log;
-const originalStdoutWrite = process.stdout.write.bind(process.stdout);
-// Contract C: Guard console.log once screen is created
-function guardStdout() {
-    if (!screenCreated)
-        return;
-    // Redirect console.log to stderr (safe)
-    console.log = (...args) => {
-        const msg = args.map(a => String(a)).join(' ');
-        tuiError('BLOCKED console.log:', msg);
-        // Also write to stderr safely
-        try {
-            process.stderr.write(`[V4 BLOCKED console.log] ${msg}\n`);
-        }
-        catch {
-            // Ignore
-        }
-    };
-    // Guard process.stdout.write (already wrapped, but ensure it stays wrapped)
-}
-// Contract C: Guard process.stdout.write
-function setupStdoutGuard(screen) {
-    screenCreated = true;
-    // Wrap stdout.write to detect/prevent long lines
-    process.stdout.write = function (chunk, encoding, callback) {
-        // Get current safeCols (dynamic, handles resize)
-        const viewport = getSafeViewport(screen);
-        const safeCols = viewport.cols;
-        const str = typeof chunk === 'string' ? chunk : chunk.toString();
-        const lines = str.split('\n');
-        // Check for lines longer than safeCols
-        for (const line of lines) {
-            if (line.length > safeCols - 5) { // -5 for safety margin
-                // Log warning to eventBus instead of printing (prevents overflow)
-                eventBus.emit({
-                    id: `stdout-overflow-${Date.now()}`,
-                    tag: 'WARN',
-                    level: 'WARN',
-                    msg: `⚠️ stdout line truncated (${line.length} > ${safeCols - 5}): ${line.substring(0, 50)}...`,
-                    ts: Date.now(),
-                });
-                const truncated = line.substring(0, safeCols - 5);
-                return originalStdoutWrite(truncated + '\n', encoding, callback);
-            }
-        }
-        return originalStdoutWrite(chunk, encoding, callback);
-    };
-    // Enable console.log guard
-    guardStdout();
-}
-/**
- * Contract C: Debug helper - uses tuiDebug (stderr/file, gated by TUI_DEBUG=1)
- * UI owns stdout. Logs go to stderr or file. No exceptions.
- */
-const dbg = tuiDebug; // Use the centralized logger
-const tuiLog = tuiDebug; // Backward compatibility
-/**
- * V4 TUI State
- */
-class V4TUI {
-    screen;
-    widgets = null; // Public for eventBus subscription
-    currentLayout = null;
-    commandInputValue = '';
-    layoutOverlayEnabled = false;
-    overlayBox = null;
-    terminalProfile = null;
-    constructor(screen) {
-        this.screen = screen;
-    }
-    /**
-     * Set terminal profile (called during initialization)
-     */
-    setTerminalProfile(profile) {
-        this.terminalProfile = profile;
-    }
-    /**
-     * Get terminal profile
-     */
-    getTerminalProfile() {
-        return this.terminalProfile;
-    }
-    /**
-     * Initialize V4 TUI
-     */
-    async init() {
-        // Rule 1: Get safe viewport (always cols - 1)
-        const viewport = getSafeViewport(this.screen);
-        // Compute initial layout using safe viewport
-        this.currentLayout = computeLayout(viewport);
-        // A) Log to stderr only (never stdout)
-        const { mode, columns } = this.currentLayout;
-        const leftRight = columns.left.left + columns.left.width + 2;
-        const centerRight = columns.center.left + columns.center.width + 2;
-        const rightRight = columns.right.left + columns.right.width + 1;
-        dbg('Layout:', `mode=${mode}, safeCols=${viewport.cols}`);
-        dbg('Right edges:', `left=${leftRight}, center=${centerRight}, right=${rightRight}, safeCols=${viewport.cols}`);
-        if (leftRight > viewport.cols || centerRight > viewport.cols || rightRight > viewport.cols) {
-            dbg('ERROR: Some panel exceeds safeCols!');
-        }
-        // Initial render (includes watermark as part of widgets)
-        // A) Render Guard: catch errors on boot
-        // Use ASCII borders if in safe mode to prevent symbol corruption
-        const useAsciiBorders = this.terminalProfile?.isSafeMode || false;
-        try {
-            this.widgets = renderFrame(this.screen, this.currentLayout, null, this.commandInputValue, true, useAsciiBorders);
-        }
-        catch (error) {
-            // Step 1: Render failed on boot - use tuiError (always goes to stderr)
-            const errorMsg = error instanceof Error ? error.message : String(error);
-            tuiError('BOOT ERROR:', errorMsg);
-            tuiError('Viewport:', `${viewport.cols}x${viewport.rows}`);
-            tuiError('Press Ctrl+C to exit');
-            // Also try to show on screen if possible
-            const program = this.screen.program;
-            if (program && typeof program.write === 'function') {
-                try {
-                    program.write('\r\n\x1b[31m[V4 BOOT ERROR]\x1b[0m\r\n');
-                    program.write(`Error: ${errorMsg}\r\n`);
-                    program.write(`Viewport: ${viewport.cols}x${viewport.rows}\r\n`);
-                    program.write(`Press Ctrl+C to exit\r\n`);
-                    program.flush();
-                }
-                catch {
-                    // Ignore if screen write fails
-                }
-            }
-            throw error;
-        }
-        // Setup resize controller
-        initResizeController(this.screen, async (newSize) => {
-            await this.handleResize(newSize);
-        });
-        // Setup input handling
-        this.setupInputHandling();
-        // Setup overlay toggle command
-        this.setupCommands();
-        // CRITICAL: Ensure screen is rendered after all setup
-        // Force a full render cycle to make widgets visible
-        // Don't render multiple times - it can cause black screens in CloudShell
-        this.screen.render();
-    }
-    /**
-     * Contract E: Handle resize (atomic, no mutation storms)
-     *
-     * Rule: on resize commit:
-     * 1. debounce (handled by resizeController)
-     * 2. destroy widgets
-     * 3. recompute layout from safe viewport
-     * 4. rebuild
-     * 5. render
-     * 6. refocus command input
-     *
-     * No partial mutation. No duplicate panels.
-     */
-    async handleResize(size) {
-        // Contract A: Get safe viewport (strict bounds)
-        const viewport = getSafeViewport(this.screen);
-        // Contract E: Compute new layout using safe viewport (no mutation)
-        const newLayout = computeLayout(viewport);
-        // Contract E: Preserve command input (atomic - get before destroy)
-        if (this.widgets?.commandLine) {
-            try {
-                this.commandInputValue = this.widgets.commandLine.getValue();
-            }
-            catch (error) {
-                // Ignore if commandLine is being destroyed
-                this.commandInputValue = '';
-            }
-        }
-        // Contract E: Atomic teardown + rebuild (destroy widgets, then rebuild)
-        // D) Use ASCII borders if in safe mode to prevent symbol corruption
-        const useAsciiBorders = this.terminalProfile?.isSafeMode || false;
-        this.widgets = renderFrame(this.screen, newLayout, this.widgets, this.commandInputValue, false, useAsciiBorders);
-        // Contract E: Re-attach input handlers (widgets were recreated - no mutation of old widgets)
-        this.attachCommandLineHandlers();
-        // Contract E: Update current layout (atomic - one assignment)
-        this.currentLayout = newLayout;
-        // Contract E: Update overlay if enabled (watermark is handled by renderFrame)
-        if (this.layoutOverlayEnabled) {
-            this.updateOverlay();
-        }
-    }
-    /**
-     * Setup input handling
-     */
-    setupInputHandling() {
-        // Ensure stdin is active (blessed handles this, but ensure it's set)
-        if (process.stdin.isTTY) {
-            process.stdin.setRawMode(true);
-            process.stdin.setEncoding('utf8');
-            process.stdin.resume();
-        }
-        // Re-setup after each resize (widgets may be recreated)
-        this.attachCommandLineHandlers();
-    }
-    /**
-     * Attach command line handlers (called after resize)
-     *
-     * CRITICAL: Manual input handling for broken terminals
-     * Textbox widget doesn't work in browser terminals (CloudShell/EC2 Instance Connect)
-     * Handle input manually via screen.key() events
-     */
-    attachCommandLineHandlers() {
-        if (!this.widgets?.commandLine) {
-            return;
-        }
-        const cmdBox = this.widgets.commandLine;
-        const PROMPT = cmdBox.__prompt || '4runr> ';
-        // Track if we've already attached handlers to prevent duplicates
-        if (this.screen.__commandLineHandlersAttached) {
-            return; // Already attached
-        }
-        this.screen.__commandLineHandlersAttached = true;
-        // Focus command line box
-        cmdBox.focus();
-        this.screen.focused = cmdBox;
-        // Manual input handling via screen.key()
-        this.screen.key(['C-c'], () => {
-            process.exit(0);
-        });
-        // Handle all keypress events manually
-        this.screen.on('keypress', async (ch, key) => {
-            // Only handle if command line is focused
-            if (this.screen.focused !== cmdBox) {
-                return;
-            }
-            let currentValue = cmdBox.__value || '';
-            // Handle Enter key (submit)
-            if (key.name === 'enter' || key.name === 'return') {
-                if (currentValue.trim()) {
-                    // Execute command
-                    await executeCommandLine(currentValue.trim(), {}, true);
-                    // Clear command line
-                    currentValue = '';
-                    cmdBox.__value = '';
-                    cmdBox.setContent(PROMPT);
-                    this.commandInputValue = '';
-                    // Render
-                    this.screen.render();
-                }
-                return;
-            }
-            // Handle Backspace
-            if (key.name === 'backspace' || key.name === 'delete') {
-                currentValue = currentValue.slice(0, -1);
-                cmdBox.__value = currentValue;
-                cmdBox.setContent(PROMPT + currentValue);
-                this.commandInputValue = currentValue;
-                this.screen.render();
-                return;
-            }
-            // Handle printable characters (ASCII only to avoid symbol corruption)
-            if (ch && typeof ch === 'string' && /[\x20-\x7E]/.test(ch)) {
-                currentValue += ch;
-                cmdBox.__value = currentValue;
-                cmdBox.setContent(PROMPT + currentValue);
-                this.commandInputValue = currentValue;
-                this.screen.render();
-            }
-        });
-    }
-    /**
-     * Setup debug commands
-     */
-    setupCommands() {
-        // dbg:size command
-        commandRegistry.register({
-            name: 'dbg:size',
-            help: 'dbg:size - Show terminal sizing and environment info',
-            handler: (ctx, args) => {
-                return handleSizeCommandWithScreen(ctx, args, {
-                    width: this.screen.width,
-                    height: this.screen.height,
-                    cols: this.screen.cols || getTerminalSize(this.screen).cols,
-                    rows: this.screen.rows || getTerminalSize(this.screen).rows,
-                });
-            },
-        });
-        // dbg:layout toggle command
-        commandRegistry.register({
-            name: 'dbg:layout',
-            help: 'dbg:layout - Toggle layout debug overlay (on/off)',
-            handler: (ctx, args) => {
-                const arg = args[0]?.toLowerCase();
-                const enabled = arg === 'on' || (arg !== 'off' && !this.layoutOverlayEnabled);
-                this.layoutOverlayEnabled = enabled;
-                if (this.layoutOverlayEnabled) {
-                    this.createOverlay();
-                    this.updateOverlay();
-                }
-                else {
-                    this.removeOverlay();
-                }
-                return {
-                    events: [{
-                            id: `overlay-${Date.now()}`,
-                            tag: 'SYS',
-                            level: 'INFO',
-                            msg: `Layout overlay ${this.layoutOverlayEnabled ? 'enabled' : 'disabled'}`,
-                            ts: Date.now(),
-                        }],
-                    actions: [],
-                };
-            },
-        });
-        // dbg:probe command - Step 5: Visual proof probe (draws marker at safeCols-1)
-        commandRegistry.register({
-            name: 'dbg:probe',
-            help: 'dbg:probe - Draw visual proof marker at right edge (x = safeCols - 1)',
-            handler: (ctx, args) => {
-                const events = [];
-                if (!this.widgets?.viewport) {
-                    events.push({
-                        id: `probe-${Date.now()}`,
-                        tag: 'ERR',
-                        level: 'ERROR',
-                        msg: 'No viewport container found',
-                        ts: Date.now(),
-                    });
-                    return { events, actions: [] };
-                }
-                const viewport = getSafeViewport(this.screen);
-                const viewportBox = this.widgets.viewport;
-                // Get current content
-                const currentContent = viewportBox.content || '';
-                // Draw vertical line at x = safeCols - 1 on every row
-                let probeContent = '';
-                for (let row = 0; row < Math.min(viewport.rows, 20); row++) {
-                    const line = ' '.repeat(Math.max(0, viewport.cols - 2)) + '|'; // Vertical line at safeCols - 1
-                    probeContent += line + '\n';
-                }
-                // Add probe text at top-right
-                const probeText = `safeCols=${viewport.cols}`;
-                const topLine = ' '.repeat(Math.max(0, viewport.cols - probeText.length - 2)) + probeText + '|';
-                probeContent = topLine + '\n' + probeContent.substring(topLine.length + 1);
-                // Set content (temporarily)
-                viewportBox.setContent(probeContent);
-                this.screen.render();
-                events.push({
-                    id: `probe-${Date.now()}`,
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `Visual probe drawn: vertical line at x=${viewport.cols - 1}, text="${probeText}"`,
-                    ts: Date.now(),
-                });
-                events.push({
-                    id: `probe-${Date.now()}-2`,
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `If marker is visible and scrollbar still appears, overflow is NOT from layout (rogue stdout or DOM issue)`,
-                    ts: Date.now(),
-                });
-                // Restore after 3 seconds
-                setTimeout(() => {
-                    if (this.widgets?.operations) {
-                        const opsBox = this.widgets.operations;
-                        opsBox.setContent(opsBox.content || '');
-                    }
-                    this.screen.render();
-                }, 3000);
-                return { events, actions: [] };
-            },
-        });
-        // dbg:viewport command - Rule 5: Proof command for CloudShell
-        commandRegistry.register({
-            name: 'dbg:viewport',
-            help: 'dbg:viewport - Show safe viewport and panel boundaries (proves no scrollbar)',
-            handler: (ctx, args) => {
-                const events = [];
-                if (!this.currentLayout) {
-                    events.push({
-                        id: `viewport-${Date.now()}`,
-                        tag: 'ERR',
-                        level: 'ERROR',
-                        msg: 'No layout computed yet',
-                        ts: Date.now(),
-                    });
-                    return { events, actions: [] };
-                }
-                const viewport = getSafeViewport(this.screen);
-                const { mode, columns, raw } = this.currentLayout;
-                events.push({
-                    id: `viewport-${Date.now()}-1`,
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `=== Safe Viewport Check (Hard Invariant: x >= safeCols is forbidden) ===`,
-                    ts: Date.now(),
-                });
-                // Environment info
-                events.push({
-                    id: `viewport-${Date.now()}-env`,
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `Platform: ${viewport.platform} | TERM: ${viewport.term} | Browser: ${viewport.isBrowserTerminal ? 'YES' : 'NO'}`,
-                    ts: Date.now(),
-                });
-                events.push({
-                    id: `viewport-${Date.now()}-2`,
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `Sources: screen.cols=${viewport.screenCols} stdout=${viewport.stdoutCols || 'N/A'} env=${viewport.envCols || 'N/A'}`,
-                    ts: Date.now(),
-                });
-                events.push({
-                    id: `viewport-${Date.now()}-3`,
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `Effective: rawCols=${viewport.rawCols} rawRows=${viewport.rawRows}`,
-                    ts: Date.now(),
-                });
-                events.push({
-                    id: `viewport-${Date.now()}-4`,
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `Safe: safeCols=${viewport.cols} safeRows=${viewport.rows} (margins: right=${viewport.rightMargin}, bottom=${viewport.bottomMargin})`,
-                    ts: Date.now(),
-                });
-                events.push({
-                    id: `viewport-${Date.now()}-5`,
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `Layout mode: ${mode}`,
-                    ts: Date.now(),
-                });
-                // Validate invariant
-                const violations = validateLayoutInvariant(this.currentLayout, viewport.cols, viewport.rows);
-                if (violations.length > 0) {
-                    events.push({
-                        id: `viewport-${Date.now()}-violations`,
-                        tag: 'ERR',
-                        level: 'ERROR',
-                        msg: `❌ INVARIANT VIOLATIONS (${violations.length}):`,
-                        ts: Date.now(),
-                    });
-                    for (const violation of violations) {
-                        events.push({
-                            id: `viewport-${Date.now()}-viol-${violation.panel}`,
-                            tag: 'ERR',
-                            level: 'ERROR',
-                            msg: `  ${violation.panel}: ${violation.violation}`,
-                            ts: Date.now(),
-                        });
-                    }
-                }
-                else {
-                    events.push({
-                        id: `viewport-${Date.now()}-invariant`,
-                        tag: 'DBG',
-                        level: 'INFO',
-                        msg: `✓ Invariant check: All panels satisfy x + w + borderPad <= safeCols`,
-                        ts: Date.now(),
-                    });
-                }
-                // Calculate column widths and right edges
-                const leftW = columns.left.width;
-                const centerW = columns.center.width;
-                const rightW = columns.right.width;
-                events.push({
-                    id: `viewport-${Date.now()}-widths`,
-                    tag: 'DBG',
-                    level: 'INFO',
-                    msg: `Panel widths: left=${leftW} center=${centerW} right=${rightW} (sum=${leftW + centerW + rightW})`,
-                    ts: Date.now(),
-                });
-                // Show right edges with border accounting
-                const LEFT_BORDER_PAD = 1;
-                const RIGHT_BORDER_PAD = 1;
-                if (columns.left.width > 0) {
-                    const leftRightEdge = columns.left.left + columns.left.width + LEFT_BORDER_PAD + RIGHT_BORDER_PAD;
-                    const safe = leftRightEdge <= viewport.cols;
-                    events.push({
-                        id: `viewport-${Date.now()}-left`,
-                        tag: safe ? 'DBG' : 'ERR',
-                        level: safe ? 'INFO' : 'ERROR',
-                        msg: `LEFT: x=${columns.left.left} w=${columns.left.width} rightEdge=${leftRightEdge} (borders:+2) ${safe ? '✓' : '❌'} <= safeCols=${viewport.cols}`,
-                        ts: Date.now(),
-                    });
-                }
-                if (columns.center.width > 0) {
-                    const centerRightEdge = columns.center.left + columns.center.width + LEFT_BORDER_PAD + RIGHT_BORDER_PAD;
-                    const safe = centerRightEdge <= viewport.cols;
-                    events.push({
-                        id: `viewport-${Date.now()}-center`,
-                        tag: safe ? 'DBG' : 'ERR',
-                        level: safe ? 'INFO' : 'ERROR',
-                        msg: `CENTER: x=${columns.center.left} w=${columns.center.width} rightEdge=${centerRightEdge} (borders:+2) ${safe ? '✓' : '❌'} <= safeCols=${viewport.cols}`,
-                        ts: Date.now(),
-                    });
-                }
-                if (columns.right.width > 0) {
-                    const rightRightEdge = columns.right.left + columns.right.width + LEFT_BORDER_PAD; // No right border
-                    const safe = rightRightEdge <= viewport.cols;
-                    events.push({
-                        id: `viewport-${Date.now()}-right`,
-                        tag: safe ? 'DBG' : 'ERR',
-                        level: safe ? 'INFO' : 'ERROR',
-                        msg: `RIGHT: x=${columns.right.left} w=${columns.right.width} rightEdge=${rightRightEdge} (border:+1, no right) ${safe ? '✓' : '❌'} <= safeCols=${viewport.cols}`,
-                        ts: Date.now(),
-                    });
-                }
-                // Command line
-                const cmdRightEdge = viewport.cols - 1; // Command line uses safeCols - 1 width, left=0, no right border
-                const cmdSafe = cmdRightEdge < viewport.cols;
-                events.push({
-                    id: `viewport-${Date.now()}-cmd`,
-                    tag: cmdSafe ? 'DBG' : 'ERR',
-                    level: cmdSafe ? 'INFO' : 'ERROR',
-                    msg: `CMD: x=0 w=${viewport.cols - 1} rightEdge=${cmdRightEdge} ${cmdSafe ? '✓' : '❌'} < safeCols=${viewport.cols}`,
-                    ts: Date.now(),
-                });
-                // Final summary
-                const allSafe = violations.length === 0;
-                events.push({
-                    id: `viewport-${Date.now()}-summary`,
-                    tag: allSafe ? 'DBG' : 'ERR',
-                    level: allSafe ? 'INFO' : 'ERROR',
-                    msg: allSafe
-                        ? `✓ SAFE: All panels satisfy hard invariant (x >= safeCols forbidden) - No scrollbar possible`
-                        : `❌ UNSAFE: ${violations.length} invariant violation(s) - Horizontal scrollbar will appear!`,
-                    ts: Date.now(),
-                });
-                return { events, actions: [] };
-            },
-        });
-    }
-    /**
-     * Create overlay box
-     */
-    createOverlay() {
-        if (this.overlayBox) {
-            return;
-        }
-        const blessedLib = blessed;
-        this.overlayBox = blessedLib.box({
-            top: 0,
-            left: 0,
-            width: '100%',
-            height: 1,
-            content: '',
-            style: {
-                fg: 'yellow',
-            },
-            tags: true,
-            focusable: false,
-        });
-        // Bring to front
-        this.screen.append(this.overlayBox);
-    }
-    /**
-     * Update overlay content
-     */
-    updateOverlay() {
-        if (!this.overlayBox || !this.currentLayout) {
-            return;
-        }
-        const stats = getResizeStats();
-        const size = getTerminalSize(this.screen);
-        const { mode, columns, raw } = this.currentLayout;
-        // Build overlay line
-        const parts = [];
-        parts.push(`cols=${raw.cols} rows=${raw.rows}`);
-        parts.push(`mode=${mode}`);
-        parts.push(`left=${columns.left.width} center=${columns.center.width} right=${columns.right.width}`);
-        if (stats.lastCommittedSize) {
-            parts.push(`commits=${stats.commitCount} bursts=${stats.eventCount - stats.commitCount}`);
-        }
-        const overlayText = parts.join(' | ');
-        this.overlayBox.setContent(overlayText);
-        this.screen.render();
-    }
-    /**
-     * Remove overlay
-     */
-    removeOverlay() {
-        if (this.overlayBox) {
-            try {
-                if (this.overlayBox.detach) {
-                    this.overlayBox.detach();
-                }
-                if (this.overlayBox.destroy) {
-                    this.overlayBox.destroy();
-                }
-            }
-            catch (error) {
-                // Ignore
-            }
-            this.overlayBox = null;
-            this.screen.render();
-        }
-    }
-    /**
-     * Destroy V4 TUI
-     */
-    destroy() {
-        // Reset singleton guard
-        globalThis.__FOURRUNR_V4_TUI_RUNNING__ = false;
-        // Clear keep-alive interval (Deliverable 1)
-        const interval = this.screen.__keepAliveInterval;
-        if (interval) {
-            clearInterval(interval);
-        }
-        this.removeOverlay();
-        // Clear heartbeat intervals from widgets (Deliverable 3)
-        if (this.widgets) {
-            for (const widget of Object.values(this.widgets)) {
-                if (widget) {
-                    const heartbeatInterval = widget.__heartbeatInterval;
-                    if (heartbeatInterval) {
-                        clearInterval(heartbeatInterval);
-                    }
-                }
-            }
-        }
-        // Watermark is handled by renderFrame teardown
-        destroyResizeController();
-        if (this.widgets) {
-            try {
-                if (this.widgets.commandLine.detach) {
-                    this.widgets.commandLine.detach();
-                }
-                if (this.widgets.commandLine.destroy) {
-                    this.widgets.commandLine.destroy();
-                }
-            }
-            catch (error) {
-                // Ignore
-            }
-            this.widgets = null;
-        }
-        // Deliverable 4: Terminal recovery on exit
-        try {
-            this.screen.program?.showCursor();
-        }
-        catch {
-            // Ignore
-        }
-        try {
-            this.screen.destroy();
-        }
-        catch (error) {
-            // Ignore
-        }
-    }
-}
-/**
- * Start V4 TUI
- *
- * ⚠️ FROZEN: This version has display issues.
- * Development moved to V5. Use at your own risk.
- */
-export async function startV4Shell() {
-    // FROZEN: Warn if V4 is being used
-    if (!process.env.SUPPRESS_V4_WARNING) {
-        process.stderr.write('\n⚠️  WARNING: V4 TUI is FROZEN (display issues). Development moved to V5.\n' +
-            '   This version is preserved for reference only.\n' +
-            '   Set SUPPRESS_V4_WARNING=1 to suppress this message.\n\n');
-    }
-    // Singleton guard - prevent multiple instances
-    if (globalThis.__FOURRUNR_V4_TUI_RUNNING__) {
-        // Already running - do nothing
-        return;
-    }
-    // Mark as running BEFORE any UI code executes
-    globalThis.__FOURRUNR_V4_TUI_RUNNING__ = true;
-    // D) Never print anything to stdout before screen init
-    // All boot logs go to stderr only
-    // B) Force a sane TERM on the server session
-    // If TERM is broken (like "locale"), set it to something safe
-    const currentTerm = process.env.TERM || '';
-    if (!currentTerm || currentTerm === 'locale' || /dumb|unknown/i.test(currentTerm)) {
-        dbg('TERM is broken:', currentTerm, '- forcing xterm-256color');
-        process.env.TERM = 'xterm-256color';
-        if (!process.env.COLORTERM) {
-            process.env.COLORTERM = 'truecolor';
-        }
-    }
-    // Create initial screen to detect terminal profile (use screen dimensions from process)
-    // We'll detect profile after creating the real screen
-    const terminalProfile = getTerminalProfile({
-        cols: process.stdout.columns || 80,
-        rows: process.stdout.rows || 24
-    });
-    dbg('Terminal profile:', {
-        isSafeMode: terminalProfile.isSafeMode,
-        safeCols: terminalProfile.safeCols,
-        safeRows: terminalProfile.safeRows,
-        supportsUnicode: terminalProfile.supportsUnicode,
-        term: terminalProfile.term,
-    });
-    // C) Create screen with safe mode config if needed
-    const screen = blessed.screen({
-        smartCSR: true, // Better for broken terminals
-        fastCSR: false,
-        title: '4Runr OS - V4 Shell (Phase 2)',
-        fullUnicode: !terminalProfile.isSafeMode, // false in safe mode
-        unicode: !terminalProfile.isSafeMode, // neo-blessed supports this
-        autoPadding: false,
-        terminal: terminalProfile.isSafeMode ? undefined : 'xterm-256color',
-        // CRITICAL: Ensure output is properly configured
-        output: process.stdout,
-        input: process.stdin,
-        // Force cursor to be hidden initially (command line will show it when focused)
-        cursor: {
-            artificial: false,
-            shape: 'block',
-            blink: false,
-            color: null,
-        },
-    }); // Cast to any to allow options
-    // Update terminal profile with actual screen dimensions
-    const actualProfile = getTerminalProfile(screen);
-    // CRITICAL: Force safe mode for CloudShell/weak terminals to prevent symbol corruption
-    // If terminal doesn't support Unicode properly, force ASCII-only mode
-    if (actualProfile.isSafeMode || !actualProfile.supportsUnicode) {
-        // Ensure blessed uses ASCII borders only
-        // We'll pass useAsciiBorders=true to renderFrame, but also ensure screen config is correct
-        screen.fullUnicode = false;
-        screen.unicode = false;
-    }
-    // Hide cursor (command line handles its own)
-    if (screen.program?.hideCursor) {
-        screen.program.hideCursor();
-    }
-    // Step 3: Guard against rogue stdout writes (common hidden cause of scrollbar)
-    // Dynamic safeCols (refresh on each write to handle resize)
-    // Store original write functions
-    const originalStdoutWrite = process.stdout.write.bind(process.stdout);
-    const originalStderrWrite = process.stderr.write.bind(process.stderr);
-    // Wrap stdout.write to detect/prevent long lines
-    process.stdout.write = function (chunk, encoding, callback) {
-        // Get current safeCols (dynamic, handles resize)
-        const viewport = getSafeViewport(screen);
-        const safeCols = viewport.cols;
-        const str = typeof chunk === 'string' ? chunk : chunk.toString();
-        const lines = str.split('\n');
-        // Check for lines longer than safeCols
-        for (const line of lines) {
-            if (line.length > safeCols - 5) { // -5 for safety margin
-                // Log warning to eventBus instead of printing (prevents overflow)
-                eventBus.emit({
-                    id: `stdout-overflow-${Date.now()}`,
-                    tag: 'WARN',
-                    level: 'WARN',
-                    msg: `⚠️ stdout line truncated (${line.length} > ${safeCols - 5}): ${line.substring(0, 50)}...`,
-                    ts: Date.now(),
-                });
-                // Truncate line to safeCols - 5
-                const truncated = line.substring(0, safeCols - 5);
-                return originalStdoutWrite(truncated + '\n', encoding, callback);
-            }
-        }
-        // Normal write
-        return originalStdoutWrite(chunk, encoding, callback);
-    };
-    // Wrap stderr.write similarly
-    process.stderr.write = function (chunk, encoding, callback) {
-        // Get current safeCols (dynamic, handles resize)
-        const viewport = getSafeViewport(screen);
-        const safeCols = viewport.cols;
-        const str = typeof chunk === 'string' ? chunk : chunk.toString();
-        const lines = str.split('\n');
-        for (const line of lines) {
-            if (line.length > safeCols - 5) {
-                eventBus.emit({
-                    id: `stderr-overflow-${Date.now()}`,
-                    tag: 'WARN',
-                    level: 'WARN',
-                    msg: `⚠️ stderr line truncated (${line.length} > ${safeCols - 5}): ${line.substring(0, 50)}...`,
-                    ts: Date.now(),
-                });
-                const truncated = line.substring(0, safeCols - 5);
-                return originalStderrWrite(truncated + '\n', encoding, callback);
-            }
-        }
-        return originalStderrWrite(chunk, encoding, callback);
-    };
-    // Deliverable 1: Attach TUI runtime keep-alive BEFORE creating TUI
-    // This ensures stdin is active and process stays alive
-    attachTuiRuntime(screen);
-    // Create V4 TUI instance
-    const tui = new V4TUI(screen);
-    // Subscribe to eventBus (for operations panel updates)
-    // Must be AFTER tui is created so we can reference it in the closure
-    const unsubscribe = eventBus.subscribe((event) => {
-        // Update operations panel if it exists
-        if (tui.widgets?.operations) {
-            const time = new Date(event.ts).toLocaleTimeString();
-            // Get existing content (use content property or getContent if available)
-            const opsBox = tui.widgets.operations;
-            const existingContent = opsBox.content || opsBox.getContent?.() || '';
-            const newLine = `[${time}] [${event.tag}] ${event.msg}`;
-            const lines = existingContent.split('\n');
-            lines.push(newLine);
-            // Limit to last 100 lines (prevent memory bloat)
-            const displayLines = lines.slice(-100);
-            opsBox.setContent(displayLines.join('\n'));
-            // Only render if not currently resizing (to avoid conflicts)
-            const stats = getResizeStats();
-            if (!stats.isCommitting) {
-                screen.render();
-            }
-        }
-    });
-    // Initialize with error handling
-    try {
-        await tui.init();
-        // CRITICAL: Render the screen to make it visible
-        // Only render once - multiple renders can cause black screens in CloudShell
-        screen.render();
-        // CRITICAL: Force output flush (blessed sometimes needs explicit flush)
-        try {
-            const program = screen.program;
-            if (program && typeof program.flush === 'function') {
-                program.flush();
-            }
-        }
-        catch {
-            // Ignore flush errors
-        }
-        // A) Log to stderr only (never stdout) - delayed
-        dbg('Init complete. Screen children:', screen.children.length);
-        dbg('Screen will stay alive - press Ctrl+C to exit');
-        // CRITICAL: Force widgets to be visible - ensure they render
-        if (tui.widgets) {
-            // Force all widgets to show their content
-            for (const [name, widget] of Object.entries(tui.widgets)) {
-                if (widget && name !== 'viewport') {
-                    try {
-                        // Force widget to be displayed
-                        if (typeof widget.setContent === 'function') {
-                            const currentContent = widget.content || '';
-                            if (!currentContent || currentContent.trim() === '') {
-                                // Set minimal content to ensure widget is visible
-                                if (name.includes('posture') || name.includes('resources') || name.includes('assets')) {
-                                    widget.setContent(`\n ${name.toUpperCase()} \n`);
-                                }
-                                else if (name === 'operations') {
-                                    widget.setContent(`\n OPERATIONS \n`);
-                                }
-                                else if (name === 'network' || name === 'capabilities') {
-                                    widget.setContent(`\n ${name.toUpperCase()} \n`);
-                                }
-                                else {
-                                    widget.setContent(' '); // At least one space
-                                }
-                            }
-                        }
-                    }
-                    catch (err) {
-                        dbg(`Error setting content for ${name}:`, err);
-                    }
-                }
-            }
-            // Force another render after setting content
-            screen.render();
-        }
-        // CRITICAL: Ensure process stays alive
-        // In browser terminals, blessed might not keep the event loop alive
-        // The keep-alive interval should handle this, but verify stdin is active
-        if (!process.stdin.isPaused()) {
-            dbg('stdin is active and not paused');
-        }
-        else {
-            dbg('WARNING: stdin is paused - resuming');
-            process.stdin.resume();
-        }
-        // Verify event loop has active handles
-        const hasListeners = process.stdin.listenerCount('data') > 0 ||
-            process.stdin.listenerCount('readable') > 0;
-        dbg('stdin listeners:', process.stdin.listenerCount('data'), 'readable listeners:', process.stdin.listenerCount('readable'));
-        if (!hasListeners) {
-            dbg('WARNING: No stdin listeners detected - adding fallback');
-            // Fallback: add a dummy listener to keep stdin active
-            process.stdin.on('data', () => {
-                // Blessed handles actual input, we just keep stdin open
-            });
-        }
-    }
-    catch (error) {
-        // A) Init failed - show error immediately (not delayed)
-        const errorMsg = error instanceof Error ? error.message : String(error);
-        const errorStack = error instanceof Error ? error.stack : '';
-        // Try to show error on screen first (most visible)
-        const program = screen.program;
-        if (program && typeof program.write === 'function') {
-            try {
-                program.write(`\r\n\x1b[31m[V4 INIT ERROR]\x1b[0m\r\n`);
-                program.write(`Error: ${errorMsg}\r\n`);
-                if (errorStack) {
-                    // Only show first few lines of stack
-                    const stackLines = errorStack.split('\n').slice(0, 5).join('\n');
-                    program.write(`Stack:\n${stackLines}\n`);
-                }
-                program.write(`Press any key to exit...\r\n`);
-                program.flush();
-                // Wait for keypress before exiting
-                screen.once('keypress', () => {
-                    process.exit(1);
-                });
-                return; // Don't exit immediately, wait for keypress
-            }
-            catch {
-                // Fallback to stderr if screen write fails
-                process.stderr.write(`[V4 INIT ERROR] ${errorMsg}\n`);
-                if (errorStack) {
-                    process.stderr.write(`[V4 INIT ERROR] Stack: ${errorStack.split('\n').slice(0, 5).join('\n')}\n`);
-                }
-            }
-        }
-        else {
-            // No screen available - write to stderr immediately
-            process.stderr.write(`[V4 INIT ERROR] ${errorMsg}\n`);
-            if (errorStack) {
-                process.stderr.write(`[V4 INIT ERROR] Stack: ${errorStack.split('\n').slice(0, 5).join('\n')}\n`);
-            }
-        }
-        process.exit(1);
-    }
-    // Cleanup on exit (attachTuiRuntime already handles SIGINT/SIGTERM, but we need local cleanup too)
-    const cleanup = () => {
-        // Reset singleton guard
-        globalThis.__FOURRUNR_V4_TUI_RUNNING__ = false;
-        // Clear keep-alive interval
-        const interval = screen.__keepAliveInterval;
-        if (interval) {
-            clearInterval(interval);
-        }
-        // Deliverable 4: Terminal recovery on exit
-        try {
-            screen.program?.showCursor();
-        }
-        catch {
-            // Ignore
-        }
-        // Restore original stdout/stderr writes
-        process.stdout.write = originalStdoutWrite;
-        process.stderr.write = originalStderrWrite;
-        unsubscribe();
-        tui.destroy();
-        try {
-            screen.destroy();
-        }
-        catch {
-            // Ignore
-        }
-        process.exit(0);
-    };
-    // Note: attachTuiRuntime already handles SIGINT/SIGTERM, but we keep this as backup
-    // The runtime handler will call cleanup via screen.destroy()
-}
-//# sourceMappingURL=index.js.map