codevf 1.0.0 → 1.0.2

package/dist/ui/LiveSession.js

@@ -1,4 +1,4 @@
-import React, { useState, useEffect } from 'react';
+import React, { useState, useEffect, useCallback } from 'react';
 import { Box, Text, useInput, useApp } from 'ink';
 import * as fs from 'fs';
 import { exec } from 'child_process';
@@ -6,44 +6,189 @@ import { promisify } from 'util';
 import { useRef } from 'react';
 const execAsync = promisify(exec);
 const COMMANDS = [
-    { cmd: '/end', description: 'End the session' },
-    { cmd: '/help', description: 'Show available commands' },
-    { cmd: '/?', description: 'Show available commands' },
+    { cmd: '/hybrid', description: 'Hybrid mode (AI → Human) (active)' },
+    { cmd: '/ai', description: 'Use AI mode only' },
+    { cmd: '/human', description: 'Request human engineer' },
     { cmd: '/shell', description: 'Switch to local shell (not shared)' },
+    { cmd: '/tunnel <port>', description: 'Share a local port over the internet' },
+    { cmd: '/close-tunnel', description: 'Close the active tunnel' },
     { cmd: '/resume', description: 'Return from shell to session' },
+    { cmd: '/?', description: 'Show all commands' },
+    { cmd: '/help', description: 'Show all commands' },
+    { cmd: '/end', description: 'End the session' },
 ];
-export const LiveSession = ({ taskId, wsClient, apiClient, permissionManager, }) => {
+export const LiveSession = ({ taskId, wsClient, apiClient, permissionManager, tunnelManager, }) => {
     const [messages, setMessages] = useState([]);
     const [engineerName, setEngineerName] = useState(null);
     const [engineerTitle, setEngineerTitle] = useState('');
     const [creditsUsed, setCreditsUsed] = useState(0);
-    const [sessionDuration, setSessionDuration] = useState(0);
+    const [_sessionDuration, setSessionDuration] = useState(0);
     const [inputBuffer, setInputBuffer] = useState('');
     const [isProcessingRequest, setIsProcessingRequest] = useState(false);
     const { exit } = useApp();
     const endingRef = useRef(false);
     const [mode, setMode] = useState('session');
+    const [isPasteMode, setIsPasteMode] = useState(false);
+    const [activeTunnel, setActiveTunnel] = useState(null);
+    const lastInputTimeRef = useRef(0);
+    const blockReturnsUntilRef = useRef(0);
+    const shareTunnel = useCallback(async (port, subdomain, reason, requestedByEngineer = false) => {
+        if (requestedByEngineer) {
+            const approved = await permissionManager.requestTunnelPermission(port, reason);
+            if (!approved) {
+                setMessages((prev) => [
+                    ...prev,
+                    {
+                        timestamp: new Date().toISOString(),
+                        sender: 'system',
+                        content: `✗ Tunnel request denied for port ${port}`,
+                    },
+                ]);
+                try {
+                    wsClient.send({
+                        type: 'tunnel_error',
+                        timestamp: new Date().toISOString(),
+                        payload: { port, message: 'Denied by customer' },
+                    });
+                }
+                catch (error) {
+                    // best-effort
+                }
+                return null;
+            }
+        }
+        setIsProcessingRequest(true);
+        try {
+            const tunnel = await tunnelManager.createTunnel({ port, subdomain, taskId });
+            setActiveTunnel(tunnel);
+            const tunnelMessage = `🔗 Tunnel shared: ${tunnel.url} (port ${tunnel.port})`;
+            setMessages((prev) => [
+                ...prev,
+                {
+                    timestamp: new Date().toISOString(),
+                    sender: 'system',
+                    content: tunnelMessage,
+                },
+            ]);
+            try {
+                wsClient.send({
+                    type: 'tunnel_shared',
+                    timestamp: new Date().toISOString(),
+                    payload: { port: tunnel.port, url: tunnel.url },
+                });
+            }
+            catch (error) {
+                // best-effort to notify engineer
+            }
+            try {
+                await apiClient.sendMessage(taskId, tunnelMessage);
+            }
+            catch (error) {
+                // sending message is best-effort; continue
+            }
+            return tunnel;
+        }
+        catch (error) {
+            const message = error?.message || 'Failed to create tunnel';
+            setMessages((prev) => [
+                ...prev,
+                {
+                    timestamp: new Date().toISOString(),
+                    sender: 'system',
+                    content: `✗ ${message}`,
+                },
+            ]);
+            try {
+                wsClient.send({
+                    type: 'tunnel_error',
+                    timestamp: new Date().toISOString(),
+                    payload: { port, message },
+                });
+            }
+            catch (sendError) {
+                // ignore
+            }
+            return null;
+        }
+        finally {
+            setIsProcessingRequest(false);
+        }
+    }, [apiClient, permissionManager, taskId, tunnelManager, wsClient]);
+    const closeActiveTunnel = useCallback(async () => {
+        if (!activeTunnel) {
+            setMessages((prev) => [
+                ...prev,
+                {
+                    timestamp: new Date().toISOString(),
+                    sender: 'system',
+                    content: 'No active tunnel to close.',
+                },
+            ]);
+            return;
+        }
+        setIsProcessingRequest(true);
+        try {
+            await tunnelManager.closeTunnel();
+            setActiveTunnel(null);
+            setMessages((prev) => [
+                ...prev,
+                {
+                    timestamp: new Date().toISOString(),
+                    sender: 'system',
+                    content: `Tunnel closed for port ${activeTunnel.port}`,
+                },
+            ]);
+        }
+        finally {
+            setIsProcessingRequest(false);
+        }
+    }, [activeTunnel, tunnelManager]);
+    useEffect(() => {
+        // Enable bracketed paste mode
+        process.stdout.write('\x1b[?2004h');
+        return () => {
+            // Disable bracketed paste mode on unmount
+            process.stdout.write('\x1b[?2004l');
+        };
+    }, []);
     useEffect(() => {
-        // Add initial message
+        // Add initial message with status and commands
+        const initMessage = `[initialized] • 🤖 [Hybrid+Vibe: 240 credits max]
+
+AI=OpenCode (free w/ limits), Vibe=2-3 credits, Human=2 credits/min • /? for info
+
+Quick commands:
+/hybrid - Hybrid mode (AI → Human) (active)
+/ai     - Use AI mode only
+/human  - Request human engineer
+/shell  - Local shell (not shared)
+/tunnel <port> - Share a local port via secure tunnel
+/?      - Show all commands
+/end    - End session
+
+🔗 Connecting to engineer...`;
         setMessages([
             {
                 timestamp: new Date().toISOString(),
                 sender: 'system',
-                content: 'Connecting to engineer... (type /? for commands, /shell for local shell, /end to close)',
+                content: initMessage,
             },
         ]);
         // WebSocket event handlers
         wsClient.on('engineer_connected', (data) => {
             setEngineerName(data.payload.engineerName);
             setEngineerTitle(data.payload.engineerTitle);
-            setMessages((prev) => [
-                ...prev,
-                {
-                    timestamp: new Date().toISOString(),
-                    sender: 'system',
-                    content: `Engineer connected: ${data.payload.engineerName} (${data.payload.engineerTitle})`,
-                },
-            ]);
+            // Only add message if not already connected (prevent duplicates)
+            if (!engineerName) {
+                setMessages((prev) => [
+                    ...prev,
+                    {
+                        timestamp: new Date().toISOString(),
+                        sender: 'system',
+                        content: 'Engineer connected',
+                    },
+                ]);
+            }
         });
         wsClient.on('engineer_message', (data) => {
             setMessages((prev) => [
@@ -162,6 +307,10 @@ export const LiveSession = ({ taskId, wsClient, apiClient, permissionManager, })
             }
             setIsProcessingRequest(false);
         });
+        wsClient.on('request_tunnel', async (data) => {
+            const { port, reason, subdomain } = data.payload;
+            await shareTunnel(port, subdomain, reason, true);
+        });
         wsClient.on('screenshare_request', (data) => {
             setMessages((prev) => [
                 ...prev,
@@ -183,14 +332,18 @@ export const LiveSession = ({ taskId, wsClient, apiClient, permissionManager, })
             ]);
         });
         wsClient.on('session_end', async (data) => {
+            const endedBy = data?.payload?.endedBy || 'engineer';
+            const endMessage = endedBy === 'customer' ? 'Session ended by User' : 'Session ended by engineer';
             setMessages((prev) => [
                 ...prev,
                 {
                     timestamp: new Date().toISOString(),
                     sender: 'system',
-                    content: 'Session ended by engineer',
+                    content: endMessage,
                 },
             ]);
+            // Ensure tunnels are closed when session ends
+            void tunnelManager.closeTunnel().then(() => setActiveTunnel(null));
             // Show summary and exit after a delay
             setTimeout(() => exit(), 2000);
         });
@@ -214,193 +367,317 @@ export const LiveSession = ({ taskId, wsClient, apiClient, permissionManager, })
                 },
             ]);
         });
+        wsClient.on('disconnected', () => {
+            setMessages((prev) => [
+                ...prev,
+                {
+                    timestamp: new Date().toISOString(),
+                    sender: 'system',
+                    content: 'Connection lost. Any active tunnels will be closed.',
+                },
+            ]);
+            // Close tunnel best-effort
+            void tunnelManager.closeTunnel().then(() => setActiveTunnel(null));
+        });
         return () => {
             wsClient.removeAllListeners();
         };
-    }, [wsClient, taskId, apiClient, permissionManager, exit]);
-    const endSession = async (reason = 'Customer ended session') => {
-        if (endingRef.current)
+    }, [wsClient, taskId, apiClient, permissionManager, exit, tunnelManager, shareTunnel]);
+    const processReturnKey = () => {
+        if (!inputBuffer.trim()) {
             return;
-        endingRef.current = true;
-        setMessages((prev) => [
-            ...prev,
-            {
-                timestamp: new Date().toISOString(),
-                sender: 'system',
-                content: 'Ending session...',
-            },
-        ]);
-        try {
-            wsClient.send({
-                type: 'end_session',
-                timestamp: new Date().toISOString(),
-                payload: { reason, endedBy: 'customer' },
-            });
         }
-        catch (error) {
-            // ignore send errors on shutdown
-        }
-        try {
-            await apiClient.endSession(taskId);
-        }
-        catch (error) {
-            // best-effort; still proceed to exit
-        }
-        try {
-            wsClient.disconnect();
-        }
-        catch (error) {
-            // ignore
-        }
-        setTimeout(() => exit(), 200);
-    };
-    useInput((input, key) => {
-        if (key.return && inputBuffer.trim()) {
-            const message = inputBuffer.trim();
-            // Shell mode handling (local only)
-            if (mode === 'shell') {
-                if (message === '/resume' || message === '/session') {
-                    setMode('session');
-                    setMessages((prev) => [
-                        ...prev,
-                        {
-                            timestamp: new Date().toISOString(),
-                            sender: 'system',
-                            content: 'Back to session (messages will be shared with engineer).',
-                        },
-                    ]);
-                    setInputBuffer('');
-                    return;
-                }
-                if (message === '/end') {
-                    endSession();
-                    setInputBuffer('');
-                    return;
-                }
-                if (message === '/shell') {
-                    setMessages((prev) => [
-                        ...prev,
-                        {
-                            timestamp: new Date().toISOString(),
-                            sender: 'system',
-                            content: 'Already in shell mode. Type /resume to return to session.',
-                        },
-                    ]);
-                    setInputBuffer('');
-                    return;
-                }
-                if (message === '/help' || message === '/?') {
-                    setMessages((prev) => [
-                        ...prev,
-                        ...COMMANDS.map((c) => ({
-                            timestamp: new Date().toISOString(),
-                            sender: 'system',
-                            content: `${c.cmd} — ${c.description}`,
-                        })),
-                        {
-                            timestamp: new Date().toISOString(),
-                            sender: 'system',
-                            content: '/resume — return to session mode',
-                        },
-                    ]);
-                    setInputBuffer('');
-                    return;
-                }
-                if (message.startsWith('/')) {
-                    setMessages((prev) => [
-                        ...prev,
-                        {
-                            timestamp: new Date().toISOString(),
-                            sender: 'system',
-                            content: `Unknown command in shell: ${message}`,
-                        },
-                    ]);
-                    setInputBuffer('');
-                    return;
-                }
-                // Execute local command
-                (async () => {
-                    try {
-                        const { stdout, stderr } = await execAsync(message, { cwd: process.cwd() });
-                        setMessages((prev) => [
-                            ...prev,
-                            {
-                                timestamp: new Date().toISOString(),
-                                sender: 'system',
-                                content: `$ ${message}\n${stdout || ''}${stderr ? `\n${stderr}` : ''}`.trim(),
-                            },
-                        ]);
-                    }
-                    catch (error) {
-                        setMessages((prev) => [
-                            ...prev,
-                            {
-                                timestamp: new Date().toISOString(),
-                                sender: 'system',
-                                content: `$ ${message}\n${error.stdout || ''}${error.stderr || error.message || 'Command failed'}`,
-                            },
-                        ]);
-                    }
-                })();
+        const message = inputBuffer.trim();
+        // Shell mode handling
+        if (mode === 'shell') {
+            if (message === '/resume' || message === '/session') {
+                setMode('session');
+                setMessages((prev) => [
+                    ...prev,
+                    {
+                        timestamp: new Date().toISOString(),
+                        sender: 'system',
+                        content: 'Back to session (messages will be shared with engineer).',
+                    },
+                ]);
                 setInputBuffer('');
                 return;
             }
-            // Session mode handling
             if (message === '/end') {
                 endSession();
                 setInputBuffer('');
                 return;
             }
-            if (message === '/help' || message === '/?') {
+            if (message === '/shell') {
                 setMessages((prev) => [
                     ...prev,
-                    ...COMMANDS.map((c) => ({
+                    {
                         timestamp: new Date().toISOString(),
                         sender: 'system',
-                        content: `${c.cmd} — ${c.description}`,
-                    })),
+                        content: 'Already in shell mode. Type /resume to return to session.',
+                    },
+                ]);
+                setInputBuffer('');
+                return;
+            }
+            if (message === '/help' || message === '/?') {
+                setMessages((prev) => [
+                    ...prev,
                     {
                         timestamp: new Date().toISOString(),
                         sender: 'system',
-                        content: '/shell — switch to local shell (not shared)',
+                        content: 'Available commands:',
                     },
+                    ...COMMANDS.map((c) => ({
+                        timestamp: new Date().toISOString(),
+                        sender: 'system',
+                        content: `${c.cmd} — ${c.description}`,
+                    })),
                 ]);
                 setInputBuffer('');
                 return;
             }
-            if (message === '/shell') {
-                setMode('shell');
+            if (message.startsWith('/')) {
                 setMessages((prev) => [
                     ...prev,
                     {
                         timestamp: new Date().toISOString(),
                         sender: 'system',
-                        content: 'Switched to local shell mode (commands are NOT shared with engineer). Type /resume to return.',
+                        content: `Unknown command in shell: ${message}`,
                     },
                 ]);
                 setInputBuffer('');
                 return;
             }
-            wsClient.send({
-                type: 'customer_message',
-                timestamp: new Date().toISOString(),
-                payload: { message },
-            });
+            // Execute local command
+            (async () => {
+                try {
+                    const { stdout, stderr } = await execAsync(message, { cwd: process.cwd() });
+                    setMessages((prev) => [
+                        ...prev,
+                        {
+                            timestamp: new Date().toISOString(),
+                            sender: 'system',
+                            content: `$ ${message}\n${stdout || ''}${stderr ? `\n${stderr}` : ''}`.trim(),
+                        },
+                    ]);
+                }
+                catch (error) {
+                    setMessages((prev) => [
+                        ...prev,
+                        {
+                            timestamp: new Date().toISOString(),
+                            sender: 'system',
+                            content: `$ ${message}\n${error.stdout || ''}${error.stderr || error.message || 'Command failed'}`,
+                        },
+                    ]);
+                }
+            })();
+            setInputBuffer('');
+            return;
+        }
+        // Session mode handling
+        if (message === '/end') {
+            endSession();
+            setInputBuffer('');
+            return;
+        }
+        if (message === '/hybrid') {
             setMessages((prev) => [
                 ...prev,
                 {
                     timestamp: new Date().toISOString(),
-                    sender: 'customer',
-                    content: message,
+                    sender: 'system',
+                    content: 'Switched to Hybrid mode (AI → Human fallback). This is the default mode.',
                 },
             ]);
             setInputBuffer('');
+            return;
         }
-        else if (key.backspace || key.delete) {
-            setInputBuffer((prev) => prev.slice(0, -1));
+        if (message === '/ai') {
+            setMessages((prev) => [
+                ...prev,
+                {
+                    timestamp: new Date().toISOString(),
+                    sender: 'system',
+                    content: 'Switched to AI-only mode. Only AI assistance will be used.',
+                },
+            ]);
+            setInputBuffer('');
+            return;
+        }
+        if (message === '/human') {
+            setMessages((prev) => [
+                ...prev,
+                {
+                    timestamp: new Date().toISOString(),
+                    sender: 'system',
+                    content: 'Requesting human engineer... (2 credits/min)',
+                },
+            ]);
+            setInputBuffer('');
+            return;
+        }
+        if (message === '/help' || message === '/?') {
+            setMessages((prev) => [
+                ...prev,
+                {
+                    timestamp: new Date().toISOString(),
+                    sender: 'system',
+                    content: 'Available commands:',
+                },
+                ...COMMANDS.map((c) => ({
+                    timestamp: new Date().toISOString(),
+                    sender: 'system',
+                    content: `${c.cmd} — ${c.description}`,
+                })),
+            ]);
+            setInputBuffer('');
+            return;
         }
-        else if (!key.ctrl && !key.meta && input) {
-            setInputBuffer((prev) => prev + input);
+        if (message === '/shell') {
+            setMode('shell');
+            setMessages((prev) => [
+                ...prev,
+                {
+                    timestamp: new Date().toISOString(),
+                    sender: 'system',
+                    content: 'Switched to local shell mode (commands are NOT shared with engineer). Type /resume to return.',
+                },
+            ]);
+            setInputBuffer('');
+            return;
+        }
+        if (message.startsWith('/tunnel')) {
+            const parts = message.split(' ').filter(Boolean);
+            const port = Number(parts[1]);
+            if (!port || Number.isNaN(port)) {
+                setMessages((prev) => [
+                    ...prev,
+                    {
+                        timestamp: new Date().toISOString(),
+                        sender: 'system',
+                        content: 'Usage: /tunnel <port>',
+                    },
+                ]);
+                setInputBuffer('');
+                return;
+            }
+            void shareTunnel(port);
+            setInputBuffer('');
+            return;
+        }
+        if (message === '/close-tunnel') {
+            void closeActiveTunnel();
+            setInputBuffer('');
+            return;
+        }
+        wsClient.send({
+            type: 'customer_message',
+            timestamp: new Date().toISOString(),
+            payload: { message },
+        });
+        setMessages((prev) => [
+            ...prev,
+            {
+                timestamp: new Date().toISOString(),
+                sender: 'customer',
+                content: message,
+            },
+        ]);
+        setInputBuffer('');
+    };
+    const endSession = async (reason = 'Customer ended session') => {
+        if (endingRef.current)
+            return;
+        endingRef.current = true;
+        try {
+            wsClient.send({
+                type: 'end_session',
+                timestamp: new Date().toISOString(),
+                payload: { reason, endedBy: 'customer' },
+            });
+        }
+        catch (error) {
+            // ignore send errors on shutdown
+        }
+        try {
+            await apiClient.endSession(taskId);
+        }
+        catch (error) {
+            // best-effort; still proceed to exit
+        }
+        try {
+            await tunnelManager.closeTunnel();
+            setActiveTunnel(null);
+        }
+        catch (error) {
+            // ignore cleanup errors
+        }
+        try {
+            wsClient.disconnect();
+        }
+        catch (error) {
+            // ignore
+        }
+        setTimeout(() => exit(), 200);
+    };
+    useInput((input, key) => {
+        const now = Date.now();
+        // DEBUG: Log all inputs (remove after testing)
+        if (process.env.CODEVF_DEBUG) {
+            console.error(`[DEBUG] input="${input}" length=${input?.length} key.return=${key.return} key.sequence="${key.sequence}" isPasteMode=${isPasteMode}`);
+        }
+        // Handle bracketed paste mode sequences
+        if (key.sequence === '\x1b[200~') {
+            setIsPasteMode(true);
+            blockReturnsUntilRef.current = now + 500;
+            return;
+        }
+        if (key.sequence === '\x1b[201~') {
+            setIsPasteMode(false);
+            // Allow returns again after 100ms
+            blockReturnsUntilRef.current = now + 100;
+            return;
+        }
+        // If we receive ANY text input (not a control key), block returns for 100ms
+        // This catches paste operations even without bracketed paste mode
+        if (input && input.length > 0 && !key.return && !key.backspace && !key.delete) {
+            lastInputTimeRef.current = now;
+            blockReturnsUntilRef.current = now + 100;
+            // If multi-character input, definitely a paste
+            if (input.length > 1) {
+                setIsPasteMode(true);
+                blockReturnsUntilRef.current = now + 300;
+            }
+            // Strip newlines from input and add to buffer
+            const sanitized = input.replace(/[\r\n]+/g, ' ');
+            if (sanitized) {
+                setInputBuffer((prev) => prev + sanitized);
+            }
+            return;
+        }
+        // Handle return key
+        if (key.return) {
+            // If returns are blocked (recent text input), ignore this return
+            if (now < blockReturnsUntilRef.current) {
+                if (process.env.CODEVF_DEBUG) {
+                    console.error(`[DEBUG] Return blocked for ${blockReturnsUntilRef.current - now}ms`);
+                }
+                setIsPasteMode(true);
+                // Extend block period
+                blockReturnsUntilRef.current = now + 100;
+                return;
+            }
+            // Returns are not blocked - this is a real Enter key press
+            setIsPasteMode(false);
+            processReturnKey();
+            return;
+        }
+        // Handle backspace/delete
+        if (key.backspace || key.delete) {
+            setInputBuffer((prev) => prev.slice(0, -1));
+            return;
         }
     }, { isActive: !isProcessingRequest });
     const formatTime = (timestamp) => {
@@ -408,19 +685,19 @@ export const LiveSession = ({ taskId, wsClient, apiClient, permissionManager, })
         return date.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
     };
     return (React.createElement(Box, { flexDirection: "column", height: "100%" },
-        React.createElement(Box, { borderStyle: "round", borderColor: "cyan", paddingX: 1, marginBottom: 1 },
+        React.createElement(Box, { borderStyle: "round", borderColor: "magenta", paddingX: 1, marginBottom: 1 },
             React.createElement(Box, { flexDirection: "column" },
-                React.createElement(Text, { bold: true, color: "cyan" }, "CodeVF Live Session"),
-                engineerName && (React.createElement(Text, { color: "white" },
+                React.createElement(Text, { bold: true, color: "magenta", backgroundColor: "black" }, "CodeVF Engineer Session"),
+                engineerName && (React.createElement(Text, { color: "cyan" },
                     "Engineer: ",
                     engineerName,
-                    " ",
-                    engineerTitle && React.createElement(Text, { dimColor: true },
+                    ' ',
+                    engineerTitle && React.createElement(Text, { color: "gray" },
                         "(",
                         engineerTitle,
                         ")"))),
-                React.createElement(Text, { dimColor: true },
-                    "Billing: ",
+                React.createElement(Text, { color: "yellow" },
+                    "\uD83D\uDCB0 Credits: ",
                     creditsUsed,
                     " credit",
                     creditsUsed !== 1 ? 's' : '',
@@ -431,21 +708,25 @@ export const LiveSession = ({ taskId, wsClient, apiClient, permissionManager, })
                 formatTime(msg.timestamp),
                 "]"),
             React.createElement(Text, null, " "),
-            msg.sender === 'engineer' && React.createElement(Text, { color: "green" },
-                engineerName || 'Engineer',
-                ":"),
-            msg.sender === 'customer' && React.createElement(Text, { color: "blue" }, "You:"),
-            msg.sender === 'system' && React.createElement(Text, { color: "yellow" }, "System:"),
-            React.createElement(Text, null,
-                " ",
-                msg.content))))),
-        React.createElement(Box, { borderStyle: "round", borderColor: "blue", paddingX: 1 },
-            React.createElement(Text, { color: "blue" }, mode === 'shell' ? 'Local> ' : 'You: '),
+            msg.sender === 'engineer' && (React.createElement(React.Fragment, null,
+                React.createElement(Text, { color: "magenta", bold: true, backgroundColor: "black" }, "Engineer:"),
+                React.createElement(Text, null, " "))),
+            msg.sender === 'customer' && (React.createElement(React.Fragment, null,
+                React.createElement(Text, { color: "green", bold: true, backgroundColor: "black" }, "\uD83D\uDC64 You:"),
+                React.createElement(Text, null, " "))),
+            msg.sender === 'system' && (React.createElement(React.Fragment, null,
+                React.createElement(Text, { color: "yellow", bold: true, backgroundColor: "blue" }, "\u2139\uFE0F System:"),
+                React.createElement(Text, null, " "))),
+            msg.sender === 'engineer' ? (React.createElement(Text, { color: "cyan", backgroundColor: "black" }, msg.content)) : (React.createElement(Text, null, msg.content)))))),
+        React.createElement(Box, { borderStyle: "round", borderColor: mode === 'shell' ? 'yellow' : 'magenta', paddingX: 1 },
+            React.createElement(Text, { color: mode === 'shell' ? 'yellow' : 'magenta', bold: true }, mode === 'shell' ? '🐚 Local> ' : '💬 Chat: '),
             React.createElement(Text, null, inputBuffer),
             React.createElement(Text, { color: "gray" }, "\u258C")),
         React.createElement(Box, { marginTop: 1 },
-            React.createElement(Text, { dimColor: true }, mode === 'shell'
-                ? 'Shell mode (not shared). /resume to return, /? for commands.'
-                : 'Type `/?` to see available commands (e.g., /end, /shell)'))));
+            React.createElement(Text, { color: isPasteMode ? 'yellow' : 'cyan' }, isPasteMode
+                ? '📋 Paste mode active - Press Enter when done pasting'
+                : mode === 'shell'
+                    ? '🔒 Shell mode (not shared). /resume to return, /? for commands.'
+                    : '💡 Quick: /auto /ai /human /shell /tunnel /? /end'))));
 };
 //# sourceMappingURL=LiveSession.js.map