tinyagent 1.0.5 → 1.2.0

package/dist/shell-client-v2.js

@@ -45,6 +45,7 @@ const ora_1 = __importDefault(require("ora"));
 const http_1 = __importDefault(require("http"));
 const https_1 = __importDefault(require("https"));
 const net_1 = __importDefault(require("net"));
+const qr_generator_1 = require("./qr-generator");
 const shared_types_1 = require("./shared-types");
 const tunnel_manager_1 = require("./tunnel-manager");
 class ShellClient {
@@ -61,6 +62,7 @@ class ShellClient {
     terminalBuffer = '';
     exposedPorts = new Set();
     lastKnownPorts = new Set();
+    portActivity = {};
     stdinListener;
     lastInputSource = 'local';
     lastInputTime = Date.now();
@@ -68,6 +70,16 @@ class ShellClient {
         local: { cols: 80, rows: 24 },
         mobile: { cols: 80, rows: 24 }
     };
+    connectedClients = 1; // Start with 1 (self)
+    clientTypes = { mobile: 0, shell: 0, host: 0 };
+    statusLineInterval;
+    isShowingQR = false;
+    bufferedOutput = [];
+    currentCommand = '';
+    commandCheckInterval;
+    viewMode = 'desktop'; // For manual toggle
+    statusBarEnabled = true; // Toggle for status bar
+    scrollbackMode = false; // Track if we're in scrollback mode
     constructor(options) {
         this.options = options;
         if (options.createTunnel !== false) {
@@ -80,6 +92,8 @@ class ShellClient {
                 rows: process.stdout.rows || 24
             };
         }
+        // Start status line updates
+        this.startStatusLine();
         // Handle process exit to clean up terminal
         process.on('exit', () => this.cleanup());
         process.on('SIGINT', () => {
@@ -97,10 +111,15 @@ class ShellClient {
                     cols: process.stdout.columns || 80,
                     rows: process.stdout.rows || 24
                 };
-                // If local was the last input source, resize the PTY
-                if (this.lastInputSource === 'local' && this.ptyProcess) {
-                    this.ptyProcess.resize(this.terminalDimensions.local.cols, this.terminalDimensions.local.rows);
+                // Only resize PTY if we're in desktop view mode
+                if (this.viewMode === 'desktop' && this.ptyProcess) {
+                    const ptyRows = this.statusBarEnabled
+                        ? Math.max(1, this.terminalDimensions.local.rows - 1) // Reserve line for status bar
+                        : this.terminalDimensions.local.rows; // Use full height
+                    this.ptyProcess.resize(this.terminalDimensions.local.cols, ptyRows);
                 }
+                // Update status line with new width
+                this.updateStatusLine();
             }
         });
     }
@@ -117,6 +136,15 @@ class ShellClient {
                 timestamp: Date.now(),
                 clientType: 'shell'
             });
+            // If password is provided, send it immediately after SESSION_INIT
+            if (this.options.password) {
+                this.sendMessage({
+                    type: shared_types_1.MessageType.SESSION_AUTH,
+                    sessionId: this.options.sessionId,
+                    timestamp: Date.now(),
+                    password: this.options.password
+                });
+            }
             this.startHeartbeat();
         });
         this.ws.on('message', (data) => {
@@ -137,6 +165,7 @@ class ShellClient {
         switch (message.type) {
             case shared_types_1.MessageType.SESSION_READY:
                 console.log(chalk_1.default.green('Session ready'));
+                this.setupTerminalWithStatusBar();
                 this.startShell();
                 if (this.options.serverCommand) {
                     this.startServer();
@@ -152,13 +181,8 @@ class ShellClient {
                 // Mark mobile as last input source
                 this.lastInputSource = 'mobile';
                 this.lastInputTime = Date.now();
-                // Use mobile dimensions if it was the last input
+                // Just write the data without resizing - user controls dimensions with Ctrl+R
                 if (this.ptyProcess) {
-                    const { cols, rows } = this.terminalDimensions.mobile;
-                    if (process.env.DEBUG || process.argv.includes('--verbose')) {
-                        console.log(chalk_1.default.magenta(`[INPUT SOURCE: MOBILE] Input received, resizing to mobile dimensions: ${cols}x${rows}`));
-                    }
-                    this.ptyProcess.resize(cols, rows);
                     this.ptyProcess.write(dataMsg.data);
                 }
                 break;
@@ -175,19 +199,17 @@ class ShellClient {
                     cols: resizeMsg.cols,
                     rows: resizeMsg.rows
                 };
-                // Apply resize if:
-                // 1. Mobile was the last input source, OR
-                // 2. This is the first resize from mobile (mobile dimensions were default 80x24)
-                const isFirstMobileResize = previousMobileDimensions.cols === 80 && previousMobileDimensions.rows === 24;
-                if ((this.lastInputSource === 'mobile' || isFirstMobileResize) && this.ptyProcess) {
-                    if (process.env.DEBUG || process.argv.includes('--verbose')) {
-                        console.log(chalk_1.default.green(`[TERMINAL RESIZE] Applying mobile dimensions: ${resizeMsg.cols}x${resizeMsg.rows}`));
-                    }
-                    this.ptyProcess.resize(resizeMsg.cols, resizeMsg.rows);
-                }
-                else {
+                // Always resize to mobile dimensions when receiving resize from mobile
+                if (this.ptyProcess) {
+                    const ptyRows = this.statusBarEnabled
+                        ? Math.max(1, resizeMsg.rows - 1) // Reserve line for status bar
+                        : resizeMsg.rows; // Use full height
+                    this.ptyProcess.resize(resizeMsg.cols, ptyRows);
+                    // Update view mode to mobile since we're resizing to mobile dimensions
+                    this.viewMode = 'mobile';
+                    this.updateStatusLine();
                     if (process.env.DEBUG || process.argv.includes('--verbose')) {
-                        console.log(chalk_1.default.red(`[TERMINAL RESIZE] Not applying - last input was from ${this.lastInputSource}`));
+                        console.log(chalk_1.default.green(`[TERMINAL RESIZE] Applied mobile dimensions: ${resizeMsg.cols}x${resizeMsg.rows}`));
                     }
                 }
                 break;
@@ -202,6 +224,33 @@ class ShellClient {
                 const httpMsg = message;
                 this.handleHttpRequest(httpMsg);
                 break;
+            case shared_types_1.MessageType.CLIENT_COUNT:
+                const countMsg = message;
+                // Subtract 1 to exclude the current shell client from the count
+                this.connectedClients = Math.max(0, countMsg.count - 1);
+                this.clientTypes = countMsg.clientTypes || { mobile: 0, shell: 0, host: 0 };
+                // Check if mobile client just connected
+                if (this.clientTypes.mobile > 0) {
+                    // If we're showing QR code, hide it automatically
+                    if (this.isShowingQR) {
+                        this.hideQRCode();
+                    }
+                    // Switch to mobile view if in desktop mode
+                    if (this.viewMode === 'desktop') {
+                        console.log(chalk_1.default.green('\nMobile client connected, switching to mobile view'));
+                        this.viewMode = 'mobile';
+                        // Apply mobile dimensions if we have them
+                        if (this.ptyProcess && this.terminalDimensions.mobile.cols > 0) {
+                            const { cols, rows } = this.terminalDimensions.mobile;
+                            const ptyRows = this.statusBarEnabled
+                                ? Math.max(1, rows - 1) // Reserve line for status bar
+                                : rows; // Use full height
+                            this.ptyProcess.resize(cols, ptyRows);
+                        }
+                    }
+                }
+                this.updateStatusLine();
+                break;
         }
     }
     startShell() {
@@ -235,25 +284,37 @@ class ShellClient {
         const initialDimensions = this.lastInputSource === 'mobile'
             ? this.terminalDimensions.mobile
             : this.terminalDimensions.local;
+        // Reserve one line for status bar if enabled
+        const ptyRows = this.statusBarEnabled
+            ? Math.max(1, initialDimensions.rows - 1)
+            : initialDimensions.rows;
         if (process.env.DEBUG || process.argv.includes('--verbose')) {
-            console.log(chalk_1.default.cyan(`[PTY INIT] Creating PTY with dimensions: ${initialDimensions.cols}x${initialDimensions.rows} (source: ${this.lastInputSource})`));
+            console.log(chalk_1.default.cyan(`[PTY INIT] Creating PTY with dimensions: ${initialDimensions.cols}x${ptyRows} (source: ${this.lastInputSource}, reserved 1 line for status)`));
         }
         this.ptyProcess = pty.spawn(this.options.shell, shellArgs, {
             name: 'xterm-256color',
             cols: initialDimensions.cols,
-            rows: initialDimensions.rows,
+            rows: ptyRows,
             env: minimalEnv,
             cwd: process.cwd()
         });
         // Handle PTY output
         this.ptyProcess.onData((data) => {
+            // Detect commands in the output
+            this.detectCommand(data);
             // Only log in debug mode or with --verbose flag
             if (process.env.DEBUG || process.argv.includes('--verbose')) {
                 console.log(chalk_1.default.gray(`[SHELL OUTPUT] ${JSON.stringify(data)}`));
             }
             else {
-                // Write directly to stdout to preserve terminal control sequences
-                process.stdout.write(data);
+                // If showing QR code, buffer the output
+                if (this.isShowingQR) {
+                    this.bufferedOutput.push(data);
+                }
+                else {
+                    // Write directly to stdout to preserve terminal control sequences
+                    process.stdout.write(data);
+                }
             }
             // Store in buffer for late-joining clients
             this.terminalBuffer += data;
@@ -271,17 +332,29 @@ class ShellClient {
             console.log(chalk_1.default.yellow(`Shell exited with code ${exitCode}`));
             this.disconnect();
         });
-        // Send initial buffer if any
+        // Send initial buffer if any (last 5000 chars to avoid overwhelming mobile)
         if (this.terminalBuffer) {
             setTimeout(() => {
+                // Send only the last portion of the buffer for mobile clients
+                const bufferToSend = this.terminalBuffer.length > 5000
+                    ? '...' + this.terminalBuffer.slice(-5000)
+                    : this.terminalBuffer;
                 this.sendMessage({
                     type: shared_types_1.MessageType.SHELL_DATA,
                     sessionId: this.options.sessionId,
                     timestamp: Date.now(),
-                    data: this.terminalBuffer
+                    data: bufferToSend
                 });
             }, 100);
         }
+        // Auto-start Claude if enabled
+        if (this.options.autoStartClaude) {
+            setTimeout(() => {
+                this.checkAndStartClaude();
+            }, 1000); // Wait a second for shell to initialize
+        }
+        // Start monitoring for running commands
+        this.startCommandMonitoring();
     }
     async startServer() {
         if (!this.options.serverCommand)
@@ -357,11 +430,17 @@ class ShellClient {
     async handleHttpRequest(request) {
         // Use targetPort from request, or try to extract from headers, or default to 3000
         const port = request.targetPort || 3000;
-        console.log(chalk_1.default.magenta(`[HTTP] ${request.method} ${request.path} → localhost:${port}`));
+        // Track port activity
+        if (!this.portActivity[port]) {
+            this.portActivity[port] = { lastAccess: Date.now(), requestCount: 0 };
+        }
+        this.portActivity[port].lastAccess = Date.now();
+        this.portActivity[port].requestCount++;
+        // Silently handle HTTP request
         const makeRequest = (options, redirectCount = 0) => {
             const protocol = options.port === 443 ? https_1.default : http_1.default;
             const req = protocol.request(options, (res) => {
-                console.log(chalk_1.default.blue(`[HTTP] Response ${res.statusCode} for ${request.path}`));
+                // Response received
                 // Handle redirects (3xx status codes)
                 if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
                     if (redirectCount >= 5) {
@@ -382,7 +461,7 @@ class ShellClient {
                         return;
                     }
                     const location = res.headers.location;
-                    console.log(chalk_1.default.yellow(`[HTTP] Following redirect to ${location}`));
+                    // Following redirect
                     // Parse the redirect URL
                     let redirectUrl;
                     try {
@@ -407,7 +486,7 @@ class ShellClient {
                     }
                     // Only follow redirects to localhost
                     if (redirectUrl.hostname !== 'localhost' && redirectUrl.hostname !== '127.0.0.1') {
-                        console.log(chalk_1.default.yellow(`[HTTP] Not following external redirect to ${redirectUrl.hostname}`));
+                        // Not following external redirect
                         // Send the redirect response as-is
                         this.sendMessage({
                             type: shared_types_1.MessageType.HTTP_RESPONSE,
@@ -523,64 +602,76 @@ class ShellClient {
         makeRequest(initialOptions);
     }
     startPortDetection() {
+        if (this.options.verbose) {
+            console.log(chalk_1.default.gray('[HTTP] Starting port detection...'));
+        }
         // Check for active ports every 5 seconds
         this.portCheckInterval = setInterval(() => {
             this.detectActivePorts();
         }, 5000);
-        // Initial check
-        this.detectActivePorts();
+        // Initial check with a small delay to ensure services are ready
+        setTimeout(() => {
+            if (this.options.verbose) {
+                console.log(chalk_1.default.gray('[HTTP] Initial port scan...'));
+            }
+            this.detectActivePorts();
+        }, 1000);
     }
     async detectActivePorts() {
-        const commonPorts = [3000, 3001, 4000, 4200, 5000, 5173, 8000, 8080, 8081, 9000];
+        const commonPorts = [3000, 3001, 3002, 3003, 3004, 3005, 4000, 4200, 5000, 5173, 8000, 8080, 8081, 9000];
         const activePorts = new Set();
+        const portsWithActivity = new Set();
         for (const port of commonPorts) {
             if (await this.isPortActive(port)) {
                 activePorts.add(port);
+                // Check if this port has recent activity (within last 30 seconds)
+                if (this.portActivity[port] &&
+                    (Date.now() - this.portActivity[port].lastAccess) < 30000) {
+                    portsWithActivity.add(port);
+                }
+            }
+        }
+        // Clean up old port activity data
+        Object.keys(this.portActivity).forEach(port => {
+            const portNum = parseInt(port);
+            if (!activePorts.has(portNum) ||
+                (Date.now() - this.portActivity[portNum].lastAccess) > 60000) {
+                delete this.portActivity[portNum];
             }
+        });
+        // Debug logging
+        if (process.env.DEBUG_PORTS) {
+            console.log(chalk_1.default.gray(`[DEBUG] Active ports found: ${[...activePorts].join(', ') || 'none'}`));
+            console.log(chalk_1.default.gray(`[DEBUG] Ports with recent activity: ${[...portsWithActivity].join(', ') || 'none'}`));
         }
         // Check if ports have changed
         const portsChanged = activePorts.size !== this.lastKnownPorts.size ||
-            [...activePorts].some(port => !this.lastKnownPorts.has(port));
+            [...activePorts].some(port => !this.lastKnownPorts.has(port)) ||
+            [...this.lastKnownPorts].some(port => !activePorts.has(port));
         if (portsChanged) {
             this.lastKnownPorts = new Set(activePorts);
             this.exposedPorts = new Set(activePorts);
-            // Send updated port list to relay
+            // Send updated port list to relay with activity information
             this.sendMessage({
                 type: shared_types_1.MessageType.REGISTER_PORT,
                 sessionId: this.options.sessionId,
                 timestamp: Date.now(),
-                ports: [...activePorts]
+                ports: [...activePorts],
+                portActivity: this.portActivity
             });
-            if (activePorts.size > 0) {
-                console.log(chalk_1.default.green(`[HTTP] Exposing ports: ${[...activePorts].join(', ')}`));
-                console.log(chalk_1.default.green(`[HTTP] Access your dev server at:`));
-                // Determine if connecting to production or local
-                const isProduction = this.options.relayUrl.includes('tinyagent.app');
-                const isLocal = this.options.relayUrl.includes('localhost') ||
-                    this.options.relayUrl.includes('127.0.0.1') ||
-                    this.options.relayUrl.match(/192\.168\.|10\.|172\./);
-                if (isProduction) {
-                    // Production URLs with subdomain-based port routing
-                    [...activePorts].forEach(port => {
-                        console.log(chalk_1.default.cyan(`  https://${this.options.sessionId}-${port}.tinyagent.app/`));
-                    });
-                }
-                else if (isLocal) {
-                    // Local development URLs with nip.io
-                    const relayHost = new URL(this.options.relayUrl).hostname;
-                    const relayPort = new URL(this.options.relayUrl).port || '8080';
-                    const ipForNipIo = relayHost.replace(/\./g, '-');
-                    [...activePorts].forEach(port => {
-                        console.log(chalk_1.default.cyan(`  http://${this.options.sessionId}-${port}.${ipForNipIo}.nip.io:${relayPort}/`));
-                    });
+            // Log detected ports only when they change
+            if (portsWithActivity.size > 0) {
+                console.log(chalk_1.default.blue(`[HTTP] Active ports: ${[...portsWithActivity].join(', ')}`));
+                console.log(chalk_1.default.blue(`[HTTP] Access your dev server at:`));
+                console.log(chalk_1.default.blue(`  https://tinyagent.app/${this.options.sessionId}/`));
+            }
+            else if (this.options.verbose) {
+                // Only show verbose logs in verbose mode
+                if (activePorts.size > 0) {
+                    console.log(chalk_1.default.gray(`[HTTP] Ports detected (${[...activePorts].join(', ')}), waiting for activity...`));
                 }
-                else {
-                    // Custom domain
-                    const publicUrl = process.env.PUBLIC_URL || 'https://tinyagent.app';
-                    const hostname = new URL(publicUrl).hostname;
-                    [...activePorts].forEach(port => {
-                        console.log(chalk_1.default.cyan(`  https://${this.options.sessionId}-${port}.${hostname}/`));
-                    });
+                else if (this.lastKnownPorts.size > 0) {
+                    console.log(chalk_1.default.gray(`[HTTP] No active ports detected`));
                 }
             }
         }
@@ -588,7 +679,7 @@ class ShellClient {
     isPortActive(port) {
         return new Promise((resolve) => {
             const socket = new net_1.default.Socket();
-            socket.setTimeout(100);
+            socket.setTimeout(300); // Increased timeout for better detection
             socket.on('connect', () => {
                 socket.destroy();
                 resolve(true);
@@ -615,14 +706,7 @@ class ShellClient {
                 // Mark local as last input source
                 this.lastInputSource = 'local';
                 this.lastInputTime = Date.now();
-                // Resize PTY to local dimensions when typing locally
-                if (this.ptyProcess && this.terminalDimensions.local) {
-                    const { cols, rows } = this.terminalDimensions.local;
-                    if (process.env.DEBUG || process.argv.includes('--verbose')) {
-                        console.log(chalk_1.default.green(`[INPUT SOURCE: LOCAL] Input received, resizing to local dimensions: ${cols}x${rows}`));
-                    }
-                    this.ptyProcess.resize(cols, rows);
-                }
+                // Don't auto-resize on input - user controls with Ctrl+R
                 // Send to local PTY
                 if (this.ptyProcess) {
                     this.ptyProcess.write(data);
@@ -633,15 +717,20 @@ class ShellClient {
                     this.disconnect();
                     process.exit(0);
                 }
-                // Debug: Manual resize test with Ctrl+R (only in verbose mode)
-                if (data === '\x12' && (process.env.DEBUG || process.argv.includes('--verbose'))) { // Ctrl+R
-                    console.log(chalk_1.default.yellow('\nManual resize test - switching to mobile dimensions'));
-                    this.lastInputSource = 'mobile';
-                    if (this.ptyProcess) {
-                        const { cols, rows } = this.terminalDimensions.mobile;
-                        console.log(chalk_1.default.green(`Resizing to mobile: ${cols}x${rows}`));
-                        this.ptyProcess.resize(cols, rows);
-                    }
+                // Ctrl+S to show QR code (S for Show)
+                if (data === '\x13') { // Ctrl+S
+                    this.showQRCode();
+                    return; // Don't pass to PTY
+                }
+                // Ctrl+F to toggle between desktop and mobile view (F for Fit)
+                if (data === '\x06') { // Ctrl+F
+                    this.toggleViewMode();
+                    return; // Don't pass to PTY
+                }
+                // Ctrl+B to toggle status bar (B for Bar)
+                if (data === '\x02') { // Ctrl+B
+                    this.toggleStatusBar();
+                    return; // Don't pass to PTY
                 }
             });
         };
@@ -650,6 +739,11 @@ class ShellClient {
         process.stdin.resume();
     }
     cleanup() {
+        // Reset scrolling region
+        if (process.stdout.isTTY) {
+            process.stdout.write('\x1b[r'); // Reset scroll region
+            process.stdout.write('\x1b[?25h'); // Show cursor
+        }
         // Restore terminal settings
         if (process.stdin.isTTY) {
             process.stdin.setRawMode(false);
@@ -664,6 +758,12 @@ class ShellClient {
         if (this.portCheckInterval) {
             clearInterval(this.portCheckInterval);
         }
+        if (this.statusLineInterval) {
+            clearInterval(this.statusLineInterval);
+        }
+        if (this.commandCheckInterval) {
+            clearInterval(this.commandCheckInterval);
+        }
         if (this.ptyProcess) {
             this.ptyProcess.kill();
         }
@@ -674,6 +774,288 @@ class ShellClient {
             this.tunnelManager.closeTunnel();
         }
     }
+    checkAndStartClaude() {
+        if (this.ptyProcess) {
+            // Simple approach: just try to run claude
+            // If it exists, it will start. If not, the error will show in terminal
+            console.log(chalk_1.default.green('\n✓ Attempting to start Claude...'));
+            // Just run claude without clearing - keep QR code visible
+            setTimeout(() => {
+                if (this.ptyProcess) {
+                    const claudeCommand = this.options.resumeClaude ? 'claude --resume' : 'claude';
+                    this.ptyProcess.write(`${claudeCommand}\n`);
+                    // Set command as 'claude' when we start it
+                    this.currentCommand = claudeCommand;
+                    this.sendCommandUpdate(claudeCommand);
+                }
+            }, 500);
+        }
+    }
+    startStatusLine() {
+        // Update status line every second
+        this.statusLineInterval = setInterval(() => {
+            this.updateStatusLine();
+        }, 1000);
+        // Initial update
+        this.updateStatusLine();
+    }
+    setupTerminalWithStatusBar() {
+        if (!process.stdout.isTTY)
+            return;
+        // Clear screen and set up scrolling region
+        process.stdout.write('\x1b[2J'); // Clear entire screen
+        process.stdout.write('\x1b[1;1H'); // Move to top
+        if (this.statusBarEnabled) {
+            // Set scrolling region to exclude top line (ANSI escape: CSI r)
+            const rows = process.stdout.rows || 24;
+            process.stdout.write(`\x1b[2;${rows}r`); // Set scroll region from line 2 to bottom
+            // Move cursor to second line
+            process.stdout.write('\x1b[2;1H');
+            // Initial status line update
+            this.updateStatusLine();
+        }
+        else {
+            // No scroll region restriction
+            process.stdout.write('\x1b[r'); // Reset scroll region to full terminal
+        }
+    }
+    updateStatusLine() {
+        if (!process.stdout.isTTY || !this.statusBarEnabled)
+            return;
+        const cols = process.stdout.columns || 80;
+        const sessionInfo = `tinyagent session: ${this.options.sessionId}`;
+        const viewInfo = `[${this.viewMode}]`;
+        const mobileStatus = this.clientTypes.mobile > 0 ? '📱' : '';
+        const clientInfo = `${this.connectedClients} client${this.connectedClients !== 1 ? 's' : ''} connected ${mobileStatus}`;
+        const shortcuts = `[Ctrl+S: Show QR | Ctrl+F: Fit | Ctrl+B: Toggle Bar]`;
+        // For smaller terminals, use abbreviated version
+        let middlePart = shortcuts;
+        if (cols < 100) {
+            middlePart = '[^S:QR ^F:Fit ^B:Bar]';
+        }
+        else if (cols < 80) {
+            middlePart = '[^S ^F ^B]';
+        }
+        // Calculate spacing
+        const leftPart = `${sessionInfo} ${viewInfo}`;
+        const rightPart = clientInfo;
+        const totalLength = leftPart.length + middlePart.length + rightPart.length + 2; // +2 for surrounding spaces
+        const spacing = Math.max(2, cols - totalLength);
+        const leftSpacing = Math.floor(spacing / 2);
+        const rightSpacing = spacing - leftSpacing;
+        // Build status line (exactly cols width, no padding)
+        const content = ` ${leftPart}${' '.repeat(leftSpacing)}${middlePart}${' '.repeat(rightSpacing)}${rightPart} `;
+        const statusLine = chalk_1.default.bgBlue.white.bold(content.substring(0, cols));
+        // Save cursor position, move to top line (outside scroll region), print status, restore cursor
+        process.stdout.write('\x1b7'); // Save cursor position
+        process.stdout.write('\x1b[1;1H'); // Move to line 1, column 1
+        process.stdout.write(statusLine); // Write status
+        process.stdout.write('\x1b[K'); // Clear to end of line (in case terminal is wider)
+        process.stdout.write('\x1b8'); // Restore cursor position
+    }
+    hideQRCode() {
+        if (!this.isShowingQR)
+            return;
+        // Clear flag
+        this.isShowingQR = false;
+        // Switch back to main screen buffer (restores previous content)
+        process.stdout.write('\x1b[?1049l');
+        // Restore status line
+        this.updateStatusLine();
+        // Replay any buffered output that came in while QR was shown
+        if (this.bufferedOutput.length > 0) {
+            this.bufferedOutput.forEach(output => {
+                process.stdout.write(output);
+            });
+            this.bufferedOutput = [];
+        }
+    }
+    showQRCode() {
+        // Set flag to start buffering
+        this.isShowingQR = true;
+        this.bufferedOutput = [];
+        // Save cursor position before clearing
+        process.stdout.write('\x1b[?1049h'); // Switch to alternate screen buffer
+        // Clear screen and show QR code
+        console.clear();
+        this.updateStatusLine();
+        (0, qr_generator_1.generateConnectionQR)(this.options.sessionId, this.options.relayUrl);
+        console.log(chalk_1.default.gray('Press any key to return to your session...'));
+        // Set up a temporary stdin handler for returning from QR view
+        const qrExitHandler = (data) => {
+            // Remove this handler
+            process.stdin.removeListener('data', qrExitHandler);
+            // Hide QR code
+            this.hideQRCode();
+            // Re-enable the normal stdin handler
+            if (this.stdinListener) {
+                this.stdinListener();
+            }
+        };
+        // Remove the normal stdin listener temporarily
+        process.stdin.removeAllListeners('data');
+        // Add the QR exit handler
+        process.stdin.on('data', qrExitHandler);
+    }
+    toggleViewMode() {
+        // Toggle between desktop and mobile view
+        this.viewMode = this.viewMode === 'desktop' ? 'mobile' : 'desktop';
+        // Get the dimensions for the selected view
+        const dimensions = this.viewMode === 'desktop'
+            ? this.terminalDimensions.local
+            : this.terminalDimensions.mobile;
+        if (this.ptyProcess && dimensions) {
+            const { cols, rows } = dimensions;
+            const ptyRows = this.statusBarEnabled ? Math.max(1, rows - 1) : rows; // Only reserve line if status bar enabled
+            console.log(chalk_1.default.yellow(`\nSwitched to ${this.viewMode} view: ${cols}x${rows}`));
+            this.ptyProcess.resize(cols, ptyRows);
+            // Update status line to show current mode
+            if (this.statusBarEnabled) {
+                this.updateStatusLine();
+            }
+            // Don't clear screen - just let the resize take effect
+            // The terminal will naturally adjust to the new size
+        }
+    }
+    toggleStatusBar() {
+        this.statusBarEnabled = !this.statusBarEnabled;
+        if (!this.statusBarEnabled) {
+            // Clear the status bar and reset scroll region
+            if (process.stdout.isTTY) {
+                process.stdout.write('\x1b[r'); // Reset scroll region
+                process.stdout.write('\x1b7'); // Save cursor
+                process.stdout.write('\x1b[1;1H'); // Move to top
+                process.stdout.write('\x1b[K'); // Clear line
+                process.stdout.write('\x1b8'); // Restore cursor
+            }
+            // Resize PTY to use full terminal height
+            if (this.ptyProcess && process.stdout.isTTY) {
+                const dimensions = this.viewMode === 'desktop'
+                    ? this.terminalDimensions.local
+                    : this.terminalDimensions.mobile;
+                this.ptyProcess.resize(dimensions.cols, dimensions.rows);
+            }
+            console.log(chalk_1.default.gray('\nStatus bar disabled. Press Ctrl+B to re-enable.'));
+        }
+        else {
+            // Re-enable status bar
+            this.setupTerminalWithStatusBar();
+            // Resize PTY to account for status bar
+            if (this.ptyProcess && process.stdout.isTTY) {
+                const dimensions = this.viewMode === 'desktop'
+                    ? this.terminalDimensions.local
+                    : this.terminalDimensions.mobile;
+                const ptyRows = Math.max(1, dimensions.rows - 1);
+                this.ptyProcess.resize(dimensions.cols, ptyRows);
+            }
+            console.log(chalk_1.default.gray('\nStatus bar enabled.'));
+        }
+    }
+    startCommandMonitoring() {
+        // Also periodically check what's actually running
+        this.commandCheckInterval = setInterval(() => {
+            this.checkRunningProcess();
+        }, 5000); // Check every 5 seconds
+    }
+    checkRunningProcess() {
+        if (!this.ptyProcess)
+            return;
+        // Get the PID of the shell's child process
+        try {
+            const ptyPid = this.ptyProcess.pid;
+            if (ptyPid) {
+                // Use ps to check what's running under our PTY
+                const { execSync } = require('child_process');
+                try {
+                    // Get immediate children of the PTY process
+                    const output = execSync(`ps -o pid,ppid,comm -p ${ptyPid} && ps -o pid,ppid,comm | grep "^[[:space:]]*[0-9]\+[[:space:]]\+${ptyPid}"`, { encoding: 'utf8' });
+                    const lines = output.split('\n').filter((line) => line.trim());
+                    // Look for child processes
+                    for (const line of lines) {
+                        const parts = line.trim().split(/\s+/);
+                        if (parts.length >= 3 && parts[1] === String(ptyPid)) {
+                            const processName = parts.slice(2).join(' ');
+                            // Skip shell processes
+                            if (!processName.includes('bash') && !processName.includes('zsh') && !processName.includes('sh')) {
+                                const command = processName.split('/').pop() || processName;
+                                if (command !== this.currentCommand) {
+                                    this.currentCommand = command;
+                                    this.sendCommandUpdate(command);
+                                }
+                                return;
+                            }
+                        }
+                    }
+                    // If we get here, no child process found - shell is idle
+                    if (this.currentCommand !== 'idle') {
+                        this.currentCommand = 'idle';
+                        this.sendCommandUpdate('idle');
+                    }
+                }
+                catch (e) {
+                    // ps command failed, ignore
+                }
+            }
+        }
+        catch (e) {
+            // Error getting process info
+        }
+    }
+    detectCommand(data) {
+        // Split by newlines
+        const lines = data.split(/\r?\n/);
+        for (const line of lines) {
+            // Remove ANSI escape codes
+            const cleanLine = line.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
+            // Look for command patterns (prompt followed by command)
+            // Remove the $ anchor to catch partial commands
+            const commandMatch = cleanLine.match(/[$#%>]\s+(.+)/);
+            if (commandMatch && commandMatch[1]) {
+                const potentialCommand = commandMatch[1].trim();
+                // Filter out common non-commands and check if it's different
+                if (potentialCommand &&
+                    potentialCommand.length > 1 &&
+                    potentialCommand !== this.currentCommand &&
+                    !potentialCommand.startsWith('\x1b')) {
+                    // Common command prefixes that indicate actual work
+                    const commandPrefixes = ['npm', 'yarn', 'node', 'python', 'git', 'vim', 'make', 'cargo', 'go', 'docker', 'kubectl', 'claude'];
+                    const isCommand = commandPrefixes.some(cmd => potentialCommand.startsWith(cmd));
+                    if (isCommand) {
+                        this.currentCommand = potentialCommand;
+                        this.sendCommandUpdate(potentialCommand);
+                    }
+                }
+            }
+        }
+        // Also check for known interactive programs in the output
+        const interactivePrograms = [
+            { pattern: /Claude Code.*session started/i, command: 'claude' },
+            { pattern: /Welcome to Claude/i, command: 'claude' },
+            { pattern: /VIM - Vi IMproved/i, command: 'vim' },
+            { pattern: /GNU nano/i, command: 'nano' },
+            { pattern: /\[\d+\]\+\s+Running\s+(.+)/i, extract: true }, // Background job
+        ];
+        for (const prog of interactivePrograms) {
+            const match = data.match(prog.pattern);
+            if (match) {
+                const command = prog.extract && match[1] ? match[1].trim() : prog.command;
+                if (command && command !== this.currentCommand) {
+                    this.currentCommand = command;
+                    this.sendCommandUpdate(command);
+                }
+                break;
+            }
+        }
+    }
+    sendCommandUpdate(command) {
+        // Send command update to relay
+        this.sendMessage({
+            type: shared_types_1.MessageType.COMMAND_UPDATE,
+            sessionId: this.options.sessionId,
+            timestamp: Date.now(),
+            command: command
+        });
+    }
     disconnect() {
         this.cleanup();
         if (this.ws) {