@leverageaiapps/locus-beta 2.0.4-beta.0

package/dist/vortex-tunnel.js

@@ -0,0 +1,993 @@
+"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.startTunnel = startTunnel;
+exports.stopTunnel = stopTunnel;
+exports.getTunnelUrl = getTunnelUrl;
+exports.isTunnelRunning = isTunnelRunning;
+const axios_1 = __importDefault(require("axios"));
+const ws_1 = __importDefault(require("ws"));
+const http = __importStar(require("http"));
+let tunnelWs = null;
+let tunnelUrl = null;
+let sessionId = null;
+let gatewayUrl = null;
+let localPort = null;
+let heartbeatInterval = null;
+let isReconnecting = false;
+let reconnectAttempts = 0;
+// Heartbeat configuration
+const HEARTBEAT_INTERVAL_MS = 20 * 1000; // Send heartbeat every 20 seconds
+const MAX_RECONNECT_ATTEMPTS = 100; // Max reconnect attempts (essentially unlimited for home use)
+const MAX_RECONNECT_DELAY_MS = 60 * 1000; // Max 60 seconds between reconnect attempts
+const MAX_PAYLOAD_SIZE = 64 * 1024 * 1024; // 64MB max message size for large file transfer
+// Map to store pending HTTP requests
+const pendingRequests = new Map();
+// Current running task
+let currentTask = null;
+// Pending task exec responses (for command execution within tasks)
+const pendingTaskExecs = new Map();
+// Single shared WebSocket connection to local server
+let sharedLocalWs = null;
+let sharedLocalWsReady = false;
+/**
+ * Start Vortex tunnel
+ * Creates a session with the gateway and establishes WebSocket connection
+ */
+function startTunnel(port = 4020, gateway) {
+    return new Promise(async (resolve, reject) => {
+        try {
+            localPort = port;
+            gatewayUrl = gateway || process.env.VORTEX_GATEWAY || 'https://vortex.futuretech.social';
+            console.log(`  [Vortex] Connecting to gateway: ${gatewayUrl}`);
+            // Step 1: Create session on gateway (v2 API)
+            const response = await axios_1.default.post(`${gatewayUrl}/api/session`, {
+                mode: 'http_proxy',
+                client_type: `LeverageAI-Agent/${process.platform}`
+            });
+            const { session_id, url, tunnel_url: sessionUrl, ws_url, expires_in } = response.data;
+            sessionId = session_id;
+            tunnelUrl = url;
+            console.log(`  [Vortex] Session created: ${session_id.substring(0, 8)}...`);
+            console.log(`  [Vortex] Session expires in: ${expires_in}s`);
+            // Step 2: Register tunnel with gateway
+            await axios_1.default.post(`${gatewayUrl}/api/tunnel/register`, {
+                session_id: session_id,
+            });
+            // Step 3: Connect WebSocket to gateway
+            const wsUrl = gatewayUrl.replace('https://', 'wss://').replace('http://', 'ws://') + `/tunnel/${session_id}`;
+            console.log(`  [Vortex] Establishing WebSocket tunnel...`);
+            tunnelWs = new ws_1.default(wsUrl, {
+                maxPayload: MAX_PAYLOAD_SIZE
+            });
+            tunnelWs.on('open', () => {
+                console.log(`  [Vortex] Tunnel connected`);
+                startHeartbeat();
+                // Create shared local WebSocket connection
+                createSharedLocalConnection();
+                resolve(tunnelUrl);
+            });
+            tunnelWs.on('message', (data) => {
+                try {
+                    const msg = JSON.parse(data.toString());
+                    handleGatewayMessage(msg);
+                }
+                catch (e) {
+                    // Not JSON, might be binary data
+                    console.error('[Vortex] Invalid message from gateway:', e);
+                }
+            });
+            tunnelWs.on('close', () => {
+                console.log('  [Vortex] Tunnel disconnected');
+                stopHeartbeat();
+                tunnelWs = null;
+                // Auto reconnect instead of cleanup
+                if (!isReconnecting && sessionId && gatewayUrl) {
+                    attemptTunnelReconnect();
+                }
+            });
+            tunnelWs.on('error', (err) => {
+                console.error('  [Vortex] Tunnel error:', err.message);
+                reject(err);
+            });
+        }
+        catch (error) {
+            console.error('  [Vortex] Failed to start tunnel:', error.message);
+            if (error.response) {
+                console.error('  [Vortex] Response:', error.response.data);
+            }
+            reject(error);
+        }
+    });
+}
+/**
+ * Create shared WebSocket connection to local server
+ * This connection is reused for all browser clients
+ */
+function createSharedLocalConnection() {
+    if (!localPort)
+        return;
+    if (sharedLocalWs && sharedLocalWs.readyState === ws_1.default.OPEN) {
+        return; // Already connected
+    }
+    console.log(`  [Vortex] Creating shared local WebSocket connection to port ${localPort}...`);
+    sharedLocalWs = new ws_1.default(`ws://localhost:${localPort}/ws`, {
+        maxPayload: MAX_PAYLOAD_SIZE
+    });
+    sharedLocalWs.on('open', () => {
+        console.log(`  [Vortex] Shared local WebSocket connected`);
+        sharedLocalWsReady = true;
+    });
+    sharedLocalWs.on('message', (data) => {
+        const dataStr = Buffer.isBuffer(data) ? data.toString() : data.toString();
+        // Check if this is task-related output (contains markers)
+        if (pendingTaskExecs.size > 0 && dataStr.includes('<<TASK_EXEC_')) {
+            processTaskOutput(dataStr);
+            // Don't forward task execution output to browsers
+            return;
+        }
+        // Check if this is raw terminal output that might be part of task execution
+        try {
+            const msg = JSON.parse(dataStr);
+            if (msg.type === 'output' && pendingTaskExecs.size > 0) {
+                // Could be task output - check for markers
+                if (msg.data && (msg.data.includes('<<TASK_EXEC_') || currentTask)) {
+                    processTaskOutput(msg.data);
+                    return;
+                }
+            }
+            // Handle AI chat task responses from local server
+            if (msg.type === 'ai_chat_response' && currentTask && currentTask.type === 'ai_chat') {
+                sendToGateway({
+                    type: 'task_output',
+                    task_id: currentTask.id,
+                    chunk: msg.content || ''
+                });
+                return;
+            }
+            if (msg.type === 'ai_chat_complete' && currentTask && currentTask.type === 'ai_chat') {
+                sendToGateway({
+                    type: 'task_complete',
+                    task_id: currentTask.id,
+                    success: true,
+                    output: msg.full_response || currentTask.accumulatedOutput
+                });
+                currentTask = null;
+                return;
+            }
+            if (msg.type === 'ai_chat_error' && currentTask && currentTask.type === 'ai_chat') {
+                sendToGateway({
+                    type: 'task_error',
+                    task_id: currentTask.id,
+                    error: msg.error || 'AI chat failed'
+                });
+                currentTask = null;
+                return;
+            }
+        }
+        catch {
+            // Not JSON, might be raw output
+            if (pendingTaskExecs.size > 0 && dataStr.includes('<<TASK_EXEC_')) {
+                processTaskOutput(dataStr);
+                return;
+            }
+        }
+        // Forward data from local server to all browsers through gateway (legacy mode)
+        if (tunnelWs && tunnelWs.readyState === ws_1.default.OPEN) {
+            tunnelWs.send(dataStr);
+        }
+    });
+    sharedLocalWs.on('close', () => {
+        console.log(`  [Vortex] Shared local WebSocket closed`);
+        sharedLocalWsReady = false;
+        sharedLocalWs = null;
+        // Exponential backoff reconnect
+        let retryCount = 0;
+        const maxRetries = 10;
+        const attemptReconnect = () => {
+            if (retryCount >= maxRetries) {
+                console.log(`  [Vortex] Max local reconnect attempts reached`);
+                return;
+            }
+            retryCount++;
+            const delay = Math.min(Math.pow(2, retryCount) * 1000, 30000);
+            console.log(`  [Vortex] Local reconnect attempt ${retryCount}/${maxRetries} in ${delay / 1000}s...`);
+            setTimeout(() => {
+                if (tunnelWs && tunnelWs.readyState === ws_1.default.OPEN) {
+                    createSharedLocalConnection();
+                    // Check if reconnect succeeded after a short delay
+                    setTimeout(() => {
+                        if (!sharedLocalWsReady && retryCount < maxRetries) {
+                            attemptReconnect();
+                        }
+                    }, 2000);
+                }
+            }, delay);
+        };
+        attemptReconnect();
+    });
+    sharedLocalWs.on('error', (err) => {
+        console.error(`  [Vortex] Shared local WebSocket error:`, err.message);
+        sharedLocalWsReady = false;
+    });
+}
+// Map of WebSocket connections (for backward compatibility)
+const websocketConnections = new Map();
+/**
+ * Handle messages from the gateway
+ */
+function handleGatewayMessage(msg) {
+    switch (msg.type) {
+        case 'http_request':
+            // Gateway forwarded an HTTP request from browser
+            handleHttpRequest(msg);
+            break;
+        case 'websocket_connect':
+            // New WebSocket connection from browser (legacy protocol)
+            handleWebSocketConnect(msg.conn_id);
+            break;
+        case 'websocket_message':
+            // WebSocket message from browser (legacy protocol)
+            handleWebSocketMessage(msg.conn_id, msg.data);
+            break;
+        case 'websocket_binary':
+            // WebSocket binary data from browser (legacy protocol)
+            handleWebSocketBinary(msg.conn_id, msg.data);
+            break;
+        case 'websocket_disconnect':
+            // WebSocket disconnection from browser (legacy protocol)
+            handleWebSocketDisconnect(msg.conn_id);
+            break;
+        case 'client_connected':
+            // New browser client connected (v2 protocol)
+            console.log(`  [Vortex] Client connected`);
+            // Ensure shared local connection is ready
+            if (!sharedLocalWsReady) {
+                createSharedLocalConnection();
+            }
+            else {
+                // Send Ctrl+C to reset shell state in case previous session left it in a bad state
+                // (e.g., stuck in heredoc mode, waiting for input, etc.)
+                if (sharedLocalWs && sharedLocalWs.readyState === ws_1.default.OPEN) {
+                    console.log(`  [Vortex] Sending Ctrl+C to reset shell state`);
+                    sharedLocalWs.send(JSON.stringify({ type: 'input', data: '\x03' }));
+                }
+            }
+            break;
+        case 'client_disconnected':
+            console.log(`  [Vortex] Client disconnected`);
+            break;
+        case 'pong':
+            // Heartbeat response received, connection is alive
+            break;
+        // ============== Task Queue Protocol (v3) ==============
+        case 'task_execute':
+            // Gateway asking us to execute a task
+            handleTaskExecute(msg);
+            break;
+        case 'task_cancel':
+            // Gateway asking us to cancel a task
+            handleTaskCancel(msg.task_id);
+            break;
+        default:
+            // Forward any other message to local server (v2 protocol - direct relay)
+            // This handles input, resize, ping, etc. from browser
+            if (sharedLocalWs && sharedLocalWs.readyState === ws_1.default.OPEN) {
+                sharedLocalWs.send(JSON.stringify(msg));
+            }
+            break;
+    }
+}
+// ============================================================================
+// Task Execution (v3 Protocol)
+// ============================================================================
+/**
+ * Handle task execution request from Gateway
+ */
+async function handleTaskExecute(msg) {
+    const { task_id, task_type, payload } = msg;
+    if (currentTask && !currentTask.cancelled) {
+        // Already executing a task, shouldn't happen if gateway queues properly
+        console.error(`  [Task] Error: Already executing task ${currentTask.id}`);
+        sendToGateway({
+            type: 'task_error',
+            task_id,
+            error: 'Already executing another task'
+        });
+        return;
+    }
+    console.log(`  [Task] Executing task ${task_id} (${task_type})`);
+    currentTask = {
+        id: task_id,
+        type: task_type,
+        payload,
+        startTime: Date.now(),
+        accumulatedOutput: '',
+        cancelled: false
+    };
+    try {
+        switch (task_type) {
+            case 'exec':
+                await executeExecTask(task_id, payload);
+                break;
+            case 'ai_chat':
+                await executeAiChatTask(task_id, payload);
+                break;
+            case 'file_read':
+                await executeFileReadTask(task_id, payload);
+                break;
+            case 'file_write':
+                await executeFileWriteTask(task_id, payload);
+                break;
+            default:
+                throw new Error(`Unknown task type: ${task_type}`);
+        }
+    }
+    catch (error) {
+        console.error(`  [Task] Error executing task ${task_id}:`, error.message);
+        if (!currentTask?.cancelled) {
+            sendToGateway({
+                type: 'task_error',
+                task_id,
+                error: error.message
+            });
+        }
+    }
+    finally {
+        currentTask = null;
+    }
+}
+/**
+ * Handle task cancellation request
+ */
+function handleTaskCancel(taskId) {
+    if (currentTask && currentTask.id === taskId) {
+        console.log(`  [Task] Cancelling task ${taskId}`);
+        currentTask.cancelled = true;
+        // Cancel any pending exec for this task
+        for (const [execId, pending] of pendingTaskExecs.entries()) {
+            if (pending.taskId === taskId) {
+                pending.reject(new Error('Task cancelled'));
+                pendingTaskExecs.delete(execId);
+            }
+        }
+        // Send Ctrl+C to interrupt any running command
+        if (sharedLocalWs && sharedLocalWs.readyState === ws_1.default.OPEN) {
+            sharedLocalWs.send(JSON.stringify({ type: 'input', data: '\x03' }));
+        }
+    }
+}
+/**
+ * Execute a shell command task
+ */
+async function executeExecTask(taskId, payload) {
+    const { command } = payload;
+    if (!command) {
+        throw new Error('No command specified');
+    }
+    if (!sharedLocalWs || sharedLocalWs.readyState !== ws_1.default.OPEN) {
+        throw new Error('Local WebSocket not connected');
+    }
+    console.log(`  [Task] Executing command: ${command.substring(0, 50)}...`);
+    const result = await executeCommandWithOutput(taskId, command);
+    console.log(`  [Task] executeCommandWithOutput returned for ${taskId}, exitCode=${result.exitCode}`);
+    if (currentTask?.cancelled) {
+        console.log(`  [Task] Task ${taskId} was cancelled, not sending complete`);
+        return;
+    }
+    console.log(`  [Task] Sending task_complete for ${taskId}`);
+    sendToGateway({
+        type: 'task_complete',
+        task_id: taskId,
+        success: result.exitCode === 0,
+        output: result.output,
+        exit_code: result.exitCode
+    });
+    console.log(`  [Task] task_complete sent for ${taskId}`);
+}
+/**
+ * Execute command and collect output with streaming
+ */
+function executeCommandWithOutput(taskId, command) {
+    return new Promise((resolve, reject) => {
+        const execId = `exec_${taskId}_${Date.now()}`;
+        const startMarker = `<<TASK_EXEC_START_${execId}>>`;
+        const endMarkerPrefix = `<<TASK_EXEC_END_${execId}>>_`;
+        pendingTaskExecs.set(execId, {
+            taskId,
+            resolve,
+            reject,
+            output: ''
+        });
+        // Set timeout
+        const timeout = setTimeout(() => {
+            const pending = pendingTaskExecs.get(execId);
+            if (pending) {
+                pendingTaskExecs.delete(execId);
+                reject(new Error('Command timed out'));
+            }
+        }, 300000); // 5 minute timeout
+        // Store timeout for cleanup
+        pendingTaskExecs.get(execId).timeout = timeout;
+        // Send wrapped command
+        const wrappedCommand = `echo '${startMarker}'; ${command}; echo '${endMarkerPrefix}'$?\n`;
+        if (sharedLocalWs && sharedLocalWs.readyState === ws_1.default.OPEN) {
+            sharedLocalWs.send(JSON.stringify({ type: 'input', data: wrappedCommand }));
+        }
+        else {
+            pendingTaskExecs.delete(execId);
+            clearTimeout(timeout);
+            reject(new Error('WebSocket not connected'));
+        }
+    });
+}
+/**
+ * Execute AI chat task (forward to local server for AI processing)
+ */
+async function executeAiChatTask(taskId, payload) {
+    // AI chat tasks are forwarded to the local web server which handles Claude API
+    // The local server will send streaming responses back
+    if (!sharedLocalWs || sharedLocalWs.readyState !== ws_1.default.OPEN) {
+        throw new Error('Local WebSocket not connected');
+    }
+    // Send AI chat request to local server
+    sharedLocalWs.send(JSON.stringify({
+        type: 'ai_chat_task',
+        task_id: taskId,
+        message: payload.message,
+        context: payload.context
+    }));
+    // The response will come through the normal WebSocket message handler
+    // which will detect ai_chat_response and forward appropriately
+}
+/**
+ * Execute file read task
+ * Supports both text files (utf-8) and binary files (base64)
+ */
+async function executeFileReadTask(taskId, payload) {
+    const { file_path } = payload;
+    if (!file_path) {
+        throw new Error('No file path specified');
+    }
+    const fs = require('fs').promises;
+    const path = require('path');
+    try {
+        // Check if file exists and get stats
+        const stats = await fs.stat(file_path);
+        const fileName = path.basename(file_path);
+        const ext = path.extname(file_path).toLowerCase();
+        // Binary file extensions
+        const binaryExtensions = ['.png', '.jpg', '.jpeg', '.gif', '.bmp', '.ico', '.webp',
+            '.pdf', '.zip', '.tar', '.gz', '.rar', '.7z',
+            '.mp3', '.mp4', '.wav', '.avi', '.mov', '.mkv',
+            '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx',
+            '.exe', '.dll', '.so', '.dylib', '.bin'];
+        const isBinary = binaryExtensions.includes(ext);
+        if (isBinary) {
+            // Read as binary and encode to base64
+            const buffer = await fs.readFile(file_path);
+            const base64Content = buffer.toString('base64');
+            // Determine MIME type
+            const mimeTypes = {
+                '.png': 'image/png',
+                '.jpg': 'image/jpeg',
+                '.jpeg': 'image/jpeg',
+                '.gif': 'image/gif',
+                '.bmp': 'image/bmp',
+                '.webp': 'image/webp',
+                '.pdf': 'application/pdf',
+                '.zip': 'application/zip',
+                '.mp3': 'audio/mpeg',
+                '.mp4': 'video/mp4',
+            };
+            const mimeType = mimeTypes[ext] || 'application/octet-stream';
+            sendToGateway({
+                type: 'task_complete',
+                task_id: taskId,
+                success: true,
+                file_name: fileName,
+                file_path: file_path,
+                file_size: stats.size,
+                file_type: mimeType,
+                content_base64: base64Content,
+                is_binary: true
+            });
+        }
+        else {
+            // Read as text
+            const content = await fs.readFile(file_path, 'utf-8');
+            sendToGateway({
+                type: 'task_complete',
+                task_id: taskId,
+                success: true,
+                file_name: fileName,
+                file_path: file_path,
+                file_size: stats.size,
+                file_content: content,
+                is_binary: false
+            });
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to read file: ${error.message}`);
+    }
+}
+/**
+ * Execute file write task
+ */
+async function executeFileWriteTask(taskId, payload) {
+    const { file_path, file_content } = payload;
+    if (!file_path || file_content === undefined) {
+        throw new Error('File path and content required');
+    }
+    const fs = require('fs').promises;
+    try {
+        await fs.writeFile(file_path, file_content, 'utf-8');
+        sendToGateway({
+            type: 'task_complete',
+            task_id: taskId,
+            success: true,
+            output: `File written: ${file_path}`
+        });
+    }
+    catch (error) {
+        throw new Error(`Failed to write file: ${error.message}`);
+    }
+}
+/**
+ * Process output from local WebSocket for task execution
+ * Called when we receive output that might contain task markers
+ */
+function processTaskOutput(data) {
+    console.log(`  [Task] processTaskOutput called, data length: ${data.length}, pendingCount: ${pendingTaskExecs.size}`);
+    console.log(`  [Task] Data preview: ${data.substring(0, 200).replace(/\n/g, '\\n')}`);
+    // Check for task exec markers
+    for (const [execId, pending] of pendingTaskExecs.entries()) {
+        console.log(`  [Task] Checking execId: ${execId}`);
+        const startMarker = `<<TASK_EXEC_START_${execId}>>`;
+        const endMarkerPrefix = `<<TASK_EXEC_END_${execId}>>_`;
+        // Track if we've seen start marker
+        const hasSeenStart = pending.hasSeenStart || false;
+        // Check if this data contains start marker
+        if (!hasSeenStart && data.includes(startMarker)) {
+            // Extract content after start marker
+            const startIdx = data.indexOf(startMarker);
+            data = data.substring(startIdx + startMarker.length);
+            // Skip leading newlines
+            while (data.startsWith('\n') || data.startsWith('\r')) {
+                data = data.substring(1);
+            }
+            pending.hasSeenStart = true;
+        }
+        else if (!hasSeenStart) {
+            // Haven't seen start marker yet, ignore this chunk (it's command echo)
+            continue;
+        }
+        // Check for end marker first (might be in same chunk as start)
+        const endIdx = data.indexOf(endMarkerPrefix);
+        if (endIdx !== -1) {
+            console.log(`  [Task] Found end marker for ${execId}, endIdx=${endIdx}`);
+            // Only take content before end marker
+            const cleanOutput = data.substring(0, endIdx);
+            pending.output += cleanOutput;
+            const afterEnd = data.substring(endIdx + endMarkerPrefix.length);
+            const exitCodeMatch = afterEnd.match(/^(\d+)/);
+            const exitCode = exitCodeMatch ? parseInt(exitCodeMatch[1], 10) : 0;
+            console.log(`  [Task] Exit code: ${exitCode}, output length: ${pending.output.length}`);
+            // Clear timeout
+            if (pending.timeout) {
+                clearTimeout(pending.timeout);
+            }
+            // Send final clean output to gateway
+            const finalOutput = pending.output.trim();
+            if (currentTask && !currentTask.cancelled) {
+                console.log(`  [Task] Sending final output to gateway`);
+                sendToGateway({
+                    type: 'task_output',
+                    task_id: pending.taskId,
+                    chunk: finalOutput,
+                    is_final: true
+                });
+            }
+            // Resolve promise
+            console.log(`  [Task] Resolving promise for ${execId}`);
+            pending.resolve({
+                output: finalOutput,
+                exitCode
+            });
+            pendingTaskExecs.delete(execId);
+            return;
+        }
+        // No end marker yet, append clean data (for streaming)
+        if (currentTask && !currentTask.cancelled && data.length > 0) {
+            pending.output += data;
+            // Send streaming chunk to gateway (only clean output)
+            sendToGateway({
+                type: 'task_output',
+                task_id: pending.taskId,
+                chunk: data
+            });
+        }
+    }
+}
+/**
+ * Handle HTTP request forwarded from gateway
+ * Forward it to the local server and send response back
+ */
+async function handleHttpRequest(msg) {
+    const { request_id, method, path, headers, body } = msg;
+    if (!localPort) {
+        sendToGateway({
+            type: 'http_response',
+            request_id,
+            status: 503,
+            headers: { 'Content-Type': 'text/plain' },
+            body: 'Local server not configured'
+        });
+        return;
+    }
+    try {
+        // Remove host header to avoid conflicts
+        const requestHeaders = { ...headers };
+        delete requestHeaders.host;
+        delete requestHeaders.Host;
+        // Make request to local server
+        const options = {
+            hostname: 'localhost',
+            port: localPort,
+            path: path,
+            method: method,
+            headers: requestHeaders
+        };
+        const localReq = http.request(options, (localRes) => {
+            const chunks = [];
+            localRes.on('data', (chunk) => {
+                chunks.push(chunk);
+            });
+            localRes.on('end', () => {
+                const responseBody = Buffer.concat(chunks);
+                // Send response back to gateway
+                sendToGateway({
+                    type: 'http_response',
+                    request_id,
+                    status: localRes.statusCode || 200,
+                    headers: localRes.headers,
+                    body: responseBody.toString('base64'),
+                    encoding: 'base64'
+                });
+            });
+        });
+        localReq.on('error', (err) => {
+            console.error('[Vortex] Local request error:', err.message);
+            sendToGateway({
+                type: 'http_response',
+                request_id,
+                status: 502,
+                headers: { 'Content-Type': 'text/plain' },
+                body: `Failed to connect to local server: ${err.message}`
+            });
+        });
+        // Send request body if present
+        if (body) {
+            // Decode base64 body if encoded
+            const bodyBuffer = msg.encoding === 'base64' ? Buffer.from(body, 'base64') : body;
+            localReq.write(bodyBuffer);
+        }
+        localReq.end();
+    }
+    catch (error) {
+        sendToGateway({
+            type: 'http_response',
+            request_id,
+            status: 500,
+            headers: { 'Content-Type': 'text/plain' },
+            body: `Internal error: ${error.message}`
+        });
+    }
+}
+/**
+ * Handle new WebSocket connection (legacy protocol)
+ */
+function handleWebSocketConnect(connId) {
+    if (!localPort) {
+        sendToGateway({
+            type: 'websocket_close',
+            conn_id: connId
+        });
+        return;
+    }
+    // Create WebSocket connection to local server
+    const localWs = new ws_1.default(`ws://localhost:${localPort}/ws`, {
+        maxPayload: MAX_PAYLOAD_SIZE
+    });
+    localWs.on('open', () => {
+        console.log(`[Vortex] Local WebSocket connected for ${connId.substring(0, 8)}...`);
+        websocketConnections.set(connId, localWs);
+    });
+    localWs.on('message', (data) => {
+        // Forward data from local server to browser through gateway
+        // Local server sends JSON text, we need to preserve it
+        if (Buffer.isBuffer(data)) {
+            sendToGateway({
+                type: 'websocket_data',
+                conn_id: connId,
+                data: data.toString('base64'),
+                binary: true
+            });
+        }
+        else {
+            // data is already a string (JSON), send it as-is
+            sendToGateway({
+                type: 'websocket_data',
+                conn_id: connId,
+                data: data.toString(),
+                binary: false
+            });
+        }
+    });
+    localWs.on('close', () => {
+        console.log(`[Vortex] Local WebSocket closed for ${connId.substring(0, 8)}...`);
+        websocketConnections.delete(connId);
+        sendToGateway({
+            type: 'websocket_close',
+            conn_id: connId
+        });
+    });
+    localWs.on('error', (err) => {
+        console.error(`[Vortex] Local WebSocket error for ${connId.substring(0, 8)}...`, err.message);
+        websocketConnections.delete(connId);
+        sendToGateway({
+            type: 'websocket_close',
+            conn_id: connId
+        });
+    });
+}
+/**
+ * Handle WebSocket message from browser (legacy protocol)
+ */
+function handleWebSocketMessage(connId, data) {
+    const localWs = websocketConnections.get(connId);
+    if (localWs && localWs.readyState === ws_1.default.OPEN) {
+        localWs.send(data);
+    }
+}
+/**
+ * Handle WebSocket binary data from browser (legacy protocol)
+ */
+function handleWebSocketBinary(connId, data) {
+    const localWs = websocketConnections.get(connId);
+    if (localWs && localWs.readyState === ws_1.default.OPEN) {
+        // Decode base64 and send as binary
+        const buffer = Buffer.from(data, 'base64');
+        localWs.send(buffer);
+    }
+}
+/**
+ * Handle WebSocket disconnection from browser (legacy protocol)
+ */
+function handleWebSocketDisconnect(connId) {
+    const localWs = websocketConnections.get(connId);
+    if (localWs) {
+        localWs.close();
+        websocketConnections.delete(connId);
+        console.log(`[Vortex] WebSocket disconnected for ${connId.substring(0, 8)}...`);
+    }
+}
+/**
+ * Send message to gateway
+ */
+function sendToGateway(msg) {
+    if (tunnelWs && tunnelWs.readyState === ws_1.default.OPEN) {
+        tunnelWs.send(JSON.stringify(msg));
+    }
+}
+/**
+ * Start heartbeat to keep connection alive
+ * Sends ping every 30 seconds to prevent 5-minute timeout
+ */
+function startHeartbeat() {
+    stopHeartbeat(); // Clear any existing heartbeat
+    heartbeatInterval = setInterval(() => {
+        if (tunnelWs && tunnelWs.readyState === ws_1.default.OPEN) {
+            sendToGateway({ type: 'ping', timestamp: Date.now() });
+        }
+    }, HEARTBEAT_INTERVAL_MS);
+    console.log(`  [Vortex] Heartbeat started (interval: ${HEARTBEAT_INTERVAL_MS / 1000}s)`);
+}
+/**
+ * Stop heartbeat timer
+ */
+function stopHeartbeat() {
+    if (heartbeatInterval) {
+        clearInterval(heartbeatInterval);
+        heartbeatInterval = null;
+    }
+}
+/**
+ * Attempt to reconnect tunnel with exponential backoff
+ * Keeps the same session ID so iOS doesn't need to re-scan QR code
+ */
+async function attemptTunnelReconnect() {
+    if (isReconnecting) {
+        return;
+    }
+    isReconnecting = true;
+    while (reconnectAttempts < MAX_RECONNECT_ATTEMPTS) {
+        reconnectAttempts++;
+        const delay = Math.min(Math.pow(2, reconnectAttempts) * 1000, MAX_RECONNECT_DELAY_MS);
+        console.log(`  [Vortex] Tunnel reconnect attempt ${reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS} in ${delay / 1000}s...`);
+        await new Promise(resolve => setTimeout(resolve, delay));
+        try {
+            await reconnectTunnel();
+            console.log(`  [Vortex] Tunnel reconnected successfully!`);
+            reconnectAttempts = 0;
+            isReconnecting = false;
+            return;
+        }
+        catch (error) {
+            console.error(`  [Vortex] Reconnect failed: ${error.message}`);
+        }
+    }
+    console.log(`  [Vortex] Max reconnect attempts reached, giving up`);
+    isReconnecting = false;
+    cleanup();
+}
+/**
+ * Reconnect tunnel using existing session ID
+ */
+async function reconnectTunnel() {
+    if (!sessionId || !gatewayUrl || !localPort) {
+        throw new Error('Missing session info for reconnect');
+    }
+    // Re-register tunnel with gateway (session should still exist)
+    try {
+        await axios_1.default.post(`${gatewayUrl}/api/tunnel/register`, {
+            session_id: sessionId,
+        });
+    }
+    catch (e) {
+        // If session expired, we need to create a new one
+        if (e.response?.status === 404) {
+            console.log(`  [Vortex] Session expired, creating new session...`);
+            // Create new session
+            const response = await axios_1.default.post(`${gatewayUrl}/api/session`, {
+                mode: 'http_proxy',
+                client_type: `LeverageAI-Agent/${process.platform}`
+            });
+            const { session_id, url } = response.data;
+            sessionId = session_id;
+            tunnelUrl = url;
+            console.log(`  [Vortex] New session created: ${session_id.substring(0, 8)}...`);
+            console.log(`  [Vortex] ⚠️  New URL - need to re-scan QR code: ${url}`);
+            // Register new tunnel
+            await axios_1.default.post(`${gatewayUrl}/api/tunnel/register`, {
+                session_id: session_id,
+            });
+        }
+        else {
+            throw e;
+        }
+    }
+    // Connect WebSocket to gateway
+    const wsUrl = gatewayUrl.replace('https://', 'wss://').replace('http://', 'ws://') + `/tunnel/${sessionId}`;
+    return new Promise((resolve, reject) => {
+        tunnelWs = new ws_1.default(wsUrl, {
+            maxPayload: MAX_PAYLOAD_SIZE
+        });
+        tunnelWs.on('open', () => {
+            console.log(`  [Vortex] Tunnel reconnected`);
+            startHeartbeat();
+            // Recreate shared local connection
+            createSharedLocalConnection();
+            resolve();
+        });
+        tunnelWs.on('message', (data) => {
+            try {
+                const msg = JSON.parse(data.toString());
+                handleGatewayMessage(msg);
+            }
+            catch (e) {
+                console.error('[Vortex] Invalid message from gateway:', e);
+            }
+        });
+        tunnelWs.on('close', () => {
+            console.log('  [Vortex] Tunnel disconnected');
+            stopHeartbeat();
+            tunnelWs = null;
+            // Auto reconnect again
+            if (!isReconnecting && sessionId && gatewayUrl) {
+                attemptTunnelReconnect();
+            }
+        });
+        tunnelWs.on('error', (err) => {
+            console.error('  [Vortex] Tunnel error:', err.message);
+            reject(err);
+        });
+        // Timeout for connection
+        setTimeout(() => {
+            if (tunnelWs && tunnelWs.readyState !== ws_1.default.OPEN) {
+                tunnelWs.close();
+                reject(new Error('Connection timeout'));
+            }
+        }, 10000);
+    });
+}
+/**
+ * Clean up resources
+ */
+function cleanup() {
+    // Clear any pending requests
+    pendingRequests.forEach(({ reject, timeout }) => {
+        clearTimeout(timeout);
+        reject(new Error('Tunnel closed'));
+    });
+    pendingRequests.clear();
+    // Close shared local WebSocket
+    if (sharedLocalWs) {
+        sharedLocalWs.close();
+        sharedLocalWs = null;
+        sharedLocalWsReady = false;
+    }
+    // Close all WebSocket connections (legacy)
+    websocketConnections.forEach(ws => {
+        ws.close();
+    });
+    websocketConnections.clear();
+}
+function stopTunnel() {
+    // Set reconnecting to true to prevent auto-reconnect on manual stop
+    isReconnecting = true;
+    stopHeartbeat();
+    if (tunnelWs) {
+        tunnelWs.close();
+        tunnelWs = null;
+    }
+    cleanup();
+    tunnelUrl = null;
+    sessionId = null;
+    gatewayUrl = null;
+    isReconnecting = false;
+    reconnectAttempts = 0;
+}
+function getTunnelUrl() {
+    return tunnelUrl;
+}
+function isTunnelRunning() {
+    return tunnelWs !== null && tunnelWs.readyState === ws_1.default.OPEN;
+}
+//# sourceMappingURL=vortex-tunnel.js.map