tinyagent 1.0.5

package/dist/shell-client-v2.js

@@ -0,0 +1,685 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShellClient = void 0;
+const ws_1 = __importDefault(require("ws"));
+// @ts-ignore - node-pty types not available
+const pty = __importStar(require("node-pty"));
+const chalk_1 = __importDefault(require("chalk"));
+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 shared_types_1 = require("./shared-types");
+const tunnel_manager_1 = require("./tunnel-manager");
+class ShellClient {
+    options;
+    ws;
+    ptyProcess; // node-pty IPty
+    serverProcess; // node-pty IPty
+    tunnelManager;
+    heartbeatInterval;
+    reconnectTimeout;
+    portCheckInterval;
+    isConnected = false;
+    spinner = (0, ora_1.default)();
+    terminalBuffer = '';
+    exposedPorts = new Set();
+    lastKnownPorts = new Set();
+    stdinListener;
+    lastInputSource = 'local';
+    lastInputTime = Date.now();
+    terminalDimensions = {
+        local: { cols: 80, rows: 24 },
+        mobile: { cols: 80, rows: 24 }
+    };
+    constructor(options) {
+        this.options = options;
+        if (options.createTunnel !== false) {
+            this.tunnelManager = new tunnel_manager_1.TunnelManager();
+        }
+        // Get initial terminal dimensions
+        if (process.stdout.isTTY) {
+            this.terminalDimensions.local = {
+                cols: process.stdout.columns || 80,
+                rows: process.stdout.rows || 24
+            };
+        }
+        // Handle process exit to clean up terminal
+        process.on('exit', () => this.cleanup());
+        process.on('SIGINT', () => {
+            this.cleanup();
+            process.exit(0);
+        });
+        process.on('SIGTERM', () => {
+            this.cleanup();
+            process.exit(0);
+        });
+        // Handle terminal resize
+        process.stdout.on('resize', () => {
+            if (process.stdout.isTTY) {
+                this.terminalDimensions.local = {
+                    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);
+                }
+            }
+        });
+    }
+    async connect() {
+        this.spinner.start('Connecting to relay server...');
+        const wsUrl = `${this.options.relayUrl}/ws/${this.options.sessionId}`;
+        this.ws = new ws_1.default(wsUrl);
+        this.ws.on('open', () => {
+            this.spinner.succeed('Connected to relay server');
+            this.isConnected = true;
+            this.sendMessage({
+                type: shared_types_1.MessageType.SESSION_INIT,
+                sessionId: this.options.sessionId,
+                timestamp: Date.now(),
+                clientType: 'shell'
+            });
+            this.startHeartbeat();
+        });
+        this.ws.on('message', (data) => {
+            this.handleMessage(JSON.parse(data.toString()));
+        });
+        this.ws.on('close', () => {
+            this.isConnected = false;
+            console.log(chalk_1.default.yellow('Connection closed'));
+            this.cleanup();
+            this.scheduleReconnect();
+        });
+        this.ws.on('error', (error) => {
+            this.spinner.fail(`WebSocket error: ${error.message}`);
+            this.cleanup();
+        });
+    }
+    handleMessage(message) {
+        switch (message.type) {
+            case shared_types_1.MessageType.SESSION_READY:
+                console.log(chalk_1.default.green('Session ready'));
+                this.startShell();
+                if (this.options.serverCommand) {
+                    this.startServer();
+                }
+                // Always start port detection for HTTP tunneling
+                this.startPortDetection();
+                break;
+            case shared_types_1.MessageType.SHELL_DATA:
+                const dataMsg = message;
+                if (process.env.DEBUG || process.argv.includes('--verbose')) {
+                    console.log(chalk_1.default.cyan(`[RECEIVED FROM MOBILE] ${JSON.stringify(dataMsg.data)}`));
+                }
+                // Mark mobile as last input source
+                this.lastInputSource = 'mobile';
+                this.lastInputTime = Date.now();
+                // Use mobile dimensions if it was the last input
+                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;
+            case shared_types_1.MessageType.SHELL_RESIZE:
+                const resizeMsg = message;
+                if (process.env.DEBUG || process.argv.includes('--verbose')) {
+                    console.log(chalk_1.default.blue(`[TERMINAL RESIZE] Received from mobile: ${resizeMsg.cols}x${resizeMsg.rows}`));
+                    console.log(chalk_1.default.yellow(`[TERMINAL RESIZE] Current dimensions - Local: ${this.terminalDimensions.local.cols}x${this.terminalDimensions.local.rows}, Mobile: ${this.terminalDimensions.mobile.cols}x${this.terminalDimensions.mobile.rows}`));
+                    console.log(chalk_1.default.yellow(`[TERMINAL RESIZE] Last input source: ${this.lastInputSource}`));
+                }
+                // Store mobile dimensions
+                const previousMobileDimensions = { ...this.terminalDimensions.mobile };
+                this.terminalDimensions.mobile = {
+                    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 {
+                    if (process.env.DEBUG || process.argv.includes('--verbose')) {
+                        console.log(chalk_1.default.red(`[TERMINAL RESIZE] Not applying - last input was from ${this.lastInputSource}`));
+                    }
+                }
+                break;
+            case shared_types_1.MessageType.COMMAND:
+                const cmdMsg = message;
+                this.handleCommand(cmdMsg);
+                break;
+            case shared_types_1.MessageType.SESSION_ERROR:
+                console.error(chalk_1.default.red(`Session error: ${message.error}`));
+                break;
+            case shared_types_1.MessageType.HTTP_REQUEST:
+                const httpMsg = message;
+                this.handleHttpRequest(httpMsg);
+                break;
+        }
+    }
+    startShell() {
+        if (this.ptyProcess) {
+            console.log(chalk_1.default.yellow('Shell already started'));
+            return;
+        }
+        if (process.env.DEBUG || process.argv.includes('--verbose')) {
+            console.log(chalk_1.default.blue(`Starting shell: ${this.options.shell}`));
+            console.log(chalk_1.default.blue('[DEBUG] Using shell-client-v2 with node-pty'));
+        }
+        // Set up local terminal input handling
+        this.setupLocalInput();
+        // Parse shell args for login shell
+        const shellArgs = [];
+        if (this.options.shell.includes('bash') || this.options.shell.includes('zsh')) {
+            shellArgs.push('-l'); // login shell
+        }
+        // Create a minimal environment to let the login shell set up its own PATH
+        const minimalEnv = {
+            TERM: 'xterm-256color',
+            USER: process.env.USER,
+            HOME: process.env.HOME,
+            SHELL: process.env.SHELL,
+            LANG: process.env.LANG,
+            LC_ALL: process.env.LC_ALL,
+            // Explicitly set a basic PATH to ensure system commands are available
+            PATH: '/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin'
+        };
+        // Create PTY with initial size based on last input source
+        const initialDimensions = this.lastInputSource === 'mobile'
+            ? this.terminalDimensions.mobile
+            : this.terminalDimensions.local;
+        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})`));
+        }
+        this.ptyProcess = pty.spawn(this.options.shell, shellArgs, {
+            name: 'xterm-256color',
+            cols: initialDimensions.cols,
+            rows: initialDimensions.rows,
+            env: minimalEnv,
+            cwd: process.cwd()
+        });
+        // Handle PTY output
+        this.ptyProcess.onData((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);
+            }
+            // Store in buffer for late-joining clients
+            this.terminalBuffer += data;
+            if (this.terminalBuffer.length > 10000) {
+                this.terminalBuffer = this.terminalBuffer.slice(-10000);
+            }
+            this.sendMessage({
+                type: shared_types_1.MessageType.SHELL_DATA,
+                sessionId: this.options.sessionId,
+                timestamp: Date.now(),
+                data: data
+            });
+        });
+        this.ptyProcess.onExit(({ exitCode }) => {
+            console.log(chalk_1.default.yellow(`Shell exited with code ${exitCode}`));
+            this.disconnect();
+        });
+        // Send initial buffer if any
+        if (this.terminalBuffer) {
+            setTimeout(() => {
+                this.sendMessage({
+                    type: shared_types_1.MessageType.SHELL_DATA,
+                    sessionId: this.options.sessionId,
+                    timestamp: Date.now(),
+                    data: this.terminalBuffer
+                });
+            }, 100);
+        }
+    }
+    async startServer() {
+        if (!this.options.serverCommand)
+            return;
+        console.log(chalk_1.default.blue(`Starting server: ${this.options.serverCommand}`));
+        this.serverProcess = pty.spawn('sh', ['-c', this.options.serverCommand], {
+            name: 'xterm',
+            env: { ...process.env, PORT: this.options.serverPort?.toString() }
+        });
+        this.serverProcess.onData((data) => {
+            console.log(chalk_1.default.gray(`[SERVER] ${data.trim()}`));
+        });
+        if (this.tunnelManager && this.options.serverPort) {
+            setTimeout(async () => {
+                try {
+                    const tunnelUrl = await this.tunnelManager.createTunnel(this.options.serverPort);
+                    console.log(chalk_1.default.green(`Tunnel created: ${tunnelUrl}`));
+                    this.sendMessage({
+                        type: shared_types_1.MessageType.TUNNEL_URL,
+                        sessionId: this.options.sessionId,
+                        timestamp: Date.now(),
+                        url: tunnelUrl,
+                        port: this.options.serverPort
+                    });
+                }
+                catch (error) {
+                    console.error(chalk_1.default.red(`Failed to create tunnel: ${error}`));
+                }
+            }, 3000);
+        }
+    }
+    handleCommand(message) {
+        switch (message.command) {
+            case 'start_server':
+                if (!this.serverProcess) {
+                    this.startServer();
+                }
+                break;
+            case 'stop_server':
+                if (this.serverProcess) {
+                    this.serverProcess.kill();
+                    this.serverProcess = undefined;
+                }
+                break;
+            case 'terminate':
+                this.disconnect();
+                break;
+        }
+    }
+    sendMessage(message) {
+        if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
+            this.ws.send(JSON.stringify(message));
+        }
+    }
+    startHeartbeat() {
+        this.heartbeatInterval = setInterval(() => {
+            this.sendMessage({
+                type: shared_types_1.MessageType.HEARTBEAT,
+                sessionId: this.options.sessionId,
+                timestamp: Date.now()
+            });
+        }, shared_types_1.HEARTBEAT_INTERVAL);
+    }
+    scheduleReconnect() {
+        if (this.reconnectTimeout)
+            return;
+        this.reconnectTimeout = setTimeout(() => {
+            console.log(chalk_1.default.blue('Attempting to reconnect...'));
+            this.reconnectTimeout = undefined;
+            this.connect();
+        }, shared_types_1.RECONNECT_DELAY);
+    }
+    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}`));
+        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}`));
+                // Handle redirects (3xx status codes)
+                if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                    if (redirectCount >= 5) {
+                        // Too many redirects
+                        console.error(chalk_1.default.red(`[HTTP] Too many redirects for ${request.path}`));
+                        this.sendMessage({
+                            type: shared_types_1.MessageType.HTTP_RESPONSE,
+                            sessionId: this.options.sessionId,
+                            timestamp: Date.now(),
+                            streamId: request.streamId,
+                            head: {
+                                status: 310,
+                                headers: { 'content-type': 'text/plain' }
+                            },
+                            data: Buffer.from('Too many redirects').toString('base64'),
+                            end: true
+                        });
+                        return;
+                    }
+                    const location = res.headers.location;
+                    console.log(chalk_1.default.yellow(`[HTTP] Following redirect to ${location}`));
+                    // Parse the redirect URL
+                    let redirectUrl;
+                    try {
+                        if (location.startsWith('http://') || location.startsWith('https://')) {
+                            redirectUrl = new URL(location);
+                        }
+                        else if (location.startsWith('//')) {
+                            redirectUrl = new URL(`http:${location}`);
+                        }
+                        else if (location.startsWith('/')) {
+                            redirectUrl = new URL(location, `http://localhost:${port}`);
+                        }
+                        else {
+                            // Relative URL
+                            const basePath = request.path.substring(0, request.path.lastIndexOf('/') + 1);
+                            redirectUrl = new URL(location, `http://localhost:${port}${basePath}`);
+                        }
+                    }
+                    catch (e) {
+                        console.error(chalk_1.default.red(`[HTTP] Invalid redirect URL: ${location}`));
+                        redirectUrl = new URL(location, `http://localhost:${port}`);
+                    }
+                    // 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}`));
+                        // Send the redirect response as-is
+                        this.sendMessage({
+                            type: shared_types_1.MessageType.HTTP_RESPONSE,
+                            sessionId: this.options.sessionId,
+                            timestamp: Date.now(),
+                            streamId: request.streamId,
+                            head: {
+                                status: res.statusCode,
+                                headers: res.headers
+                            }
+                        });
+                        res.on('data', (chunk) => {
+                            this.sendMessage({
+                                type: shared_types_1.MessageType.HTTP_RESPONSE,
+                                sessionId: this.options.sessionId,
+                                timestamp: Date.now(),
+                                streamId: request.streamId,
+                                data: chunk.toString('base64')
+                            });
+                        });
+                        res.on('end', () => {
+                            this.sendMessage({
+                                type: shared_types_1.MessageType.HTTP_RESPONSE,
+                                sessionId: this.options.sessionId,
+                                timestamp: Date.now(),
+                                streamId: request.streamId,
+                                end: true
+                            });
+                        });
+                        return;
+                    }
+                    // Follow the redirect
+                    const newOptions = {
+                        hostname: 'localhost',
+                        port: parseInt(redirectUrl.port) || port,
+                        path: redirectUrl.pathname + redirectUrl.search,
+                        method: 'GET', // Redirects typically become GET requests
+                        headers: {
+                            ...request.headers,
+                            host: `localhost:${parseInt(redirectUrl.port) || port}`
+                        }
+                    };
+                    makeRequest(newOptions, redirectCount + 1);
+                    return;
+                }
+                // Send response head
+                this.sendMessage({
+                    type: shared_types_1.MessageType.HTTP_RESPONSE,
+                    sessionId: this.options.sessionId,
+                    timestamp: Date.now(),
+                    streamId: request.streamId,
+                    head: {
+                        status: res.statusCode || 200,
+                        headers: res.headers
+                    }
+                });
+                // Stream response body
+                res.on('data', (chunk) => {
+                    this.sendMessage({
+                        type: shared_types_1.MessageType.HTTP_RESPONSE,
+                        sessionId: this.options.sessionId,
+                        timestamp: Date.now(),
+                        streamId: request.streamId,
+                        data: chunk.toString('base64')
+                    });
+                });
+                res.on('end', () => {
+                    this.sendMessage({
+                        type: shared_types_1.MessageType.HTTP_RESPONSE,
+                        sessionId: this.options.sessionId,
+                        timestamp: Date.now(),
+                        streamId: request.streamId,
+                        end: true
+                    });
+                });
+            });
+            req.on('error', (error) => {
+                console.error(chalk_1.default.red(`[HTTP] Request error: ${error.message}`));
+                // Send error response
+                this.sendMessage({
+                    type: shared_types_1.MessageType.HTTP_RESPONSE,
+                    sessionId: this.options.sessionId,
+                    timestamp: Date.now(),
+                    streamId: request.streamId,
+                    head: {
+                        status: 502,
+                        headers: { 'content-type': 'text/plain' }
+                    },
+                    data: Buffer.from(`Gateway Error: ${error.message}`).toString('base64'),
+                    end: true
+                });
+            });
+            // Write request body if present
+            if (request.body && request.method !== 'GET' && request.method !== 'HEAD') {
+                const body = typeof request.body === 'string'
+                    ? Buffer.from(request.body, 'base64')
+                    : request.body;
+                req.write(body);
+            }
+            req.end();
+        };
+        // Start the request
+        const initialOptions = {
+            hostname: 'localhost',
+            port,
+            path: request.path,
+            method: request.method,
+            headers: {
+                ...request.headers,
+                host: `localhost:${port}`
+            }
+        };
+        makeRequest(initialOptions);
+    }
+    startPortDetection() {
+        // Check for active ports every 5 seconds
+        this.portCheckInterval = setInterval(() => {
+            this.detectActivePorts();
+        }, 5000);
+        // Initial check
+        this.detectActivePorts();
+    }
+    async detectActivePorts() {
+        const commonPorts = [3000, 3001, 4000, 4200, 5000, 5173, 8000, 8080, 8081, 9000];
+        const activePorts = new Set();
+        for (const port of commonPorts) {
+            if (await this.isPortActive(port)) {
+                activePorts.add(port);
+            }
+        }
+        // Check if ports have changed
+        const portsChanged = activePorts.size !== this.lastKnownPorts.size ||
+            [...activePorts].some(port => !this.lastKnownPorts.has(port));
+        if (portsChanged) {
+            this.lastKnownPorts = new Set(activePorts);
+            this.exposedPorts = new Set(activePorts);
+            // Send updated port list to relay
+            this.sendMessage({
+                type: shared_types_1.MessageType.REGISTER_PORT,
+                sessionId: this.options.sessionId,
+                timestamp: Date.now(),
+                ports: [...activePorts]
+            });
+            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}/`));
+                    });
+                }
+                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}/`));
+                    });
+                }
+            }
+        }
+    }
+    isPortActive(port) {
+        return new Promise((resolve) => {
+            const socket = new net_1.default.Socket();
+            socket.setTimeout(100);
+            socket.on('connect', () => {
+                socket.destroy();
+                resolve(true);
+            });
+            socket.on('timeout', () => {
+                socket.destroy();
+                resolve(false);
+            });
+            socket.on('error', () => {
+                resolve(false);
+            });
+            socket.connect(port, 'localhost');
+        });
+    }
+    setupLocalInput() {
+        // Set stdin to raw mode to capture all keystrokes
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+        }
+        process.stdin.setEncoding('utf8');
+        // Handle local keyboard input
+        this.stdinListener = () => {
+            process.stdin.on('data', (data) => {
+                // 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);
+                }
+                // Send to local PTY
+                if (this.ptyProcess) {
+                    this.ptyProcess.write(data);
+                }
+                // Special handling for Ctrl+C to exit
+                if (data === '\x03') {
+                    console.log(chalk_1.default.yellow('\nReceived Ctrl+C, disconnecting...'));
+                    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);
+                    }
+                }
+            });
+        };
+        this.stdinListener();
+        // Resume stdin to start receiving data
+        process.stdin.resume();
+    }
+    cleanup() {
+        // Restore terminal settings
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(false);
+        }
+        process.stdin.pause();
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+        }
+        if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout);
+        }
+        if (this.portCheckInterval) {
+            clearInterval(this.portCheckInterval);
+        }
+        if (this.ptyProcess) {
+            this.ptyProcess.kill();
+        }
+        if (this.serverProcess) {
+            this.serverProcess.kill();
+        }
+        if (this.tunnelManager) {
+            this.tunnelManager.closeTunnel();
+        }
+    }
+    disconnect() {
+        this.cleanup();
+        if (this.ws) {
+            this.ws.close();
+        }
+    }
+}
+exports.ShellClient = ShellClient;
+//# sourceMappingURL=shell-client-v2.js.map