shell-mirror 1.5.65 → 1.5.67

package/mac-agent/agent.js

@@ -419,7 +419,9 @@ async function sendHeartbeat() {
     const heartbeatData = JSON.stringify({
       agentId: AGENT_ID,
       timestamp: Date.now(),
-      activeSessions: Object.keys(sessions).length
+      activeSessions: Object.keys(sessionManager.sessions).length,
+      localPort: process.env.LOCAL_PORT || 8080,
+      capabilities: ['webrtc', 'direct_websocket']
     });
 
     const options = {
@@ -945,6 +947,7 @@ process.on('SIGINT', () => {
   console.log('\n[AGENT] Shutting down gracefully...');
   cleanup();
   if (ws) ws.close();
+  if (localServer) localServer.close();
   process.exit(0);
 });
 
@@ -952,10 +955,122 @@ process.on('SIGTERM', () => {
   console.log('\n[AGENT] Received SIGTERM, shutting down...');
   cleanup();
   if (ws) ws.close();
+  if (localServer) localServer.close();
   process.exit(0);
 });
 
+// --- Local WebSocket Server for Direct Connections ---
+function startLocalServer() {
+  const localPort = process.env.LOCAL_PORT || 8080;
+  const localServer = require('ws').Server;
+  const wss = new localServer({ port: localPort });
+
+  logToFile(`🏠 Starting local WebSocket server on port ${localPort}`);
+
+  wss.on('connection', (localWs, request) => {
+    const clientIp = request.socket.remoteAddress;
+    logToFile(`🔗 Direct connection from ${clientIp}`);
+
+    // Handle direct browser connections
+    localWs.on('message', (data) => {
+      try {
+        const message = JSON.parse(data);
+        logToFile(`[LOCAL] Received direct message: ${message.type}`);
+
+        switch (message.type) {
+          case 'ping':
+            localWs.send(JSON.stringify({ type: 'pong', timestamp: Date.now() }));
+            break;
+            
+          case 'authenticate':
+            // For direct connections, we can implement simpler auth
+            localWs.send(JSON.stringify({ 
+              type: 'authenticated', 
+              agentId: AGENT_ID,
+              timestamp: Date.now()
+            }));
+            break;
+
+          case 'create_session':
+            // Create new terminal session for direct connection
+            const sessionId = uuidv4();
+            const ptyProcess = pty.spawn(shell, [], {
+              name: 'xterm-color',
+              cols: message.cols || 120,
+              rows: message.rows || 30,
+              cwd: process.env.HOME,
+              env: process.env
+            });
+
+            // Store session
+            sessions[sessionId] = {
+              pty: ptyProcess,
+              buffer: new CircularBuffer(),
+              lastActivity: Date.now()
+            };
+
+            // Send session output to direct connection
+            ptyProcess.onData((data) => {
+              if (localWs.readyState === WebSocket.OPEN) {
+                localWs.send(JSON.stringify({
+                  type: 'output',
+                  sessionId,
+                  data
+                }));
+              }
+            });
+
+            localWs.send(JSON.stringify({
+              type: 'session_created',
+              sessionId,
+              cols: message.cols || 120,
+              rows: message.rows || 30
+            }));
+
+            logToFile(`[LOCAL] Created direct session: ${sessionId}`);
+            break;
+
+          case 'input':
+            // Handle terminal input for direct connection
+            if (sessions[message.sessionId]) {
+              sessions[message.sessionId].pty.write(message.data);
+              sessions[message.sessionId].lastActivity = Date.now();
+            }
+            break;
+
+          case 'resize':
+            // Handle terminal resize for direct connection
+            if (sessions[message.sessionId]) {
+              sessions[message.sessionId].pty.resize(message.cols, message.rows);
+            }
+            break;
+
+          default:
+            logToFile(`[LOCAL] Unknown message type: ${message.type}`);
+        }
+      } catch (err) {
+        logToFile(`[LOCAL] Error parsing message: ${err.message}`);
+      }
+    });
+
+    localWs.on('close', () => {
+      logToFile(`[LOCAL] Direct connection from ${clientIp} closed`);
+    });
+
+    localWs.on('error', (error) => {
+      logToFile(`[LOCAL] Direct connection error: ${error.message}`);
+    });
+  });
+
+  logToFile(`✅ Local WebSocket server started on port ${localPort}`);
+  return wss;
+}
+
 // --- Start the agent ---
 console.log(`[AGENT] Starting Mac Agent with ID: ${AGENT_ID}`);
+
+// Start local server for direct connections
+const localServer = startLocalServer();
+
 console.log(`[AGENT] Connecting to signaling server at: ${SIGNALING_SERVER_URL}`);
 connectToSignalingServer();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shell-mirror",
-  "version": "1.5.65",
+  "version": "1.5.67",
   "description": "Access your Mac shell from any device securely. Perfect for mobile coding with Claude Code CLI, Gemini CLI, and any shell tool.",
   "main": "server.js",
   "bin": {

package/public/app/dashboard.js

@@ -46,7 +46,7 @@ class ShellMirrorDashboard {
                 this.user = authStatus.user;
                 await this.loadDashboardData();
                 this.renderAuthenticatedDashboard();
-                this.setupWebSocket(); // Setup real-time connection
+                this.enableHttpOnlyMode(); // Use HTTP-only mode (no persistent WebSocket)
                 this.startAutoRefresh(); // Start auto-refresh for authenticated users
             } else {
                 this.renderUnauthenticatedDashboard();
@@ -65,12 +65,12 @@ class ShellMirrorDashboard {
             clearInterval(this.refreshInterval);
         }
         
-        // Refresh agent data every 10 seconds (reduced from 30s)
+        // Refresh agent data every 30 seconds (HTTP polling only)
         this.refreshInterval = setInterval(async () => {
             if (this.isAuthenticated && !this.isRefreshing) {
                 await this.refreshDashboardData();
             }
-        }, 10000);
+        }, 30000);
     }
 
     async refreshDashboardData() {
@@ -170,7 +170,10 @@ class ShellMirrorDashboard {
                 console.log(`[DASHBOARD] 🔌 WebSocket closed: ${event.code} (${reason})`, event.reason);
                 
                 if (event.code === 1008) {
-                    console.error('[DASHBOARD] ❌ Authentication required - WebSocket rejected connection');
+                    console.error('[DASHBOARD] ❌ Authentication/Policy violation - switching to HTTP-only mode');
+                    this.updateConnectionStatus('failed');
+                    this.enableHttpOnlyMode();
+                    return;
                 } else if (event.code === 1006) {
                     console.error('[DASHBOARD] ❌ Abnormal closure - WebSocket endpoint may not exist');
                 }

package/public/app/terminal.js

@@ -268,23 +268,215 @@ function startConnection() {
 
 
 async function initialize() {
-    console.log('[CLIENT] 🚀 Initializing WebRTC connection to agent:', AGENT_ID);
+    console.log('[CLIENT] 🚀 Initializing connection to agent:', AGENT_ID);
     console.log('[CLIENT] 📋 Selected agent data:', SELECTED_AGENT);
     
-    // Use Heroku WebSocket server for all connections
+    // First try direct connection to agent
+    const directConnectionSuccess = await tryDirectConnection();
+    
+    if (directConnectionSuccess) {
+        console.log('[CLIENT] ✅ Direct connection established - no server needed!');
+        return;
+    }
+    
+    console.log('[CLIENT] ⚠️ Direct connection failed, falling back to WebRTC signaling...');
+    await initializeWebRTCSignaling();
+}
+
+async function tryDirectConnection() {
+    console.log('[CLIENT] 🔗 Attempting direct connection to agent...');
+    updateConnectionStatus('connecting');
+    
+    // Get agent data from API to find local connection details
+    try {
+        const response = await fetch('/php-backend/api/agents-list.php', {
+            credentials: 'include'
+        });
+        
+        const data = await response.json();
+        if (!data.success || !data.data.agents) {
+            console.log('[CLIENT] ❌ Could not get agent list for direct connection');
+            return false;
+        }
+        
+        const agent = data.data.agents.find(a => a.agentId === AGENT_ID);
+        if (!agent || !agent.localPort) {
+            console.log('[CLIENT] ❌ Agent not found or no local port information');
+            return false;
+        }
+        
+        // Try common local IPs for the agent
+        // Start with localhost/loopback, then try common private network ranges
+        const possibleIPs = [
+            'localhost',
+            '127.0.0.1',
+            // Common private network ranges
+            ...generatePrivateIPCandidates()
+        ];
+        
+        for (const ip of possibleIPs) {
+            const success = await tryDirectConnectionToIP(ip, agent.localPort);
+            if (success) {
+                return true;
+            }
+        }
+        
+        console.log('[CLIENT] ❌ Direct connection failed to all IP candidates');
+        updateConnectionStatus('disconnected');
+        return false;
+        
+    } catch (error) {
+        console.log('[CLIENT] ❌ Error during direct connection attempt:', error);
+        return false;
+    }
+}
+
+async function tryDirectConnectionToIP(ip, port) {
+    return new Promise((resolve) => {
+        console.log(`[CLIENT] 🔍 Trying direct connection to ${ip}:${port}`);
+        
+        const directWs = new WebSocket(`ws://${ip}:${port}`);
+        const timeout = setTimeout(() => {
+            console.log(`[CLIENT] ⏰ Connection timeout to ${ip}:${port}`);
+            directWs.close();
+            resolve(false);
+        }, 3000); // 3 second timeout
+        
+        directWs.onopen = () => {
+            clearTimeout(timeout);
+            console.log(`[CLIENT] ✅ Direct connection established to ${ip}:${port}`);
+            
+            // Set up the direct connection handlers
+            setupDirectConnection(directWs);
+            resolve(true);
+        };
+        
+        directWs.onerror = () => {
+            clearTimeout(timeout);
+            console.log(`[CLIENT] ❌ Connection failed to ${ip}:${port}`);
+            resolve(false);
+        };
+        
+        directWs.onclose = () => {
+            clearTimeout(timeout);
+            resolve(false);
+        };
+    });
+}
+
+function setupDirectConnection(directWs) {
+    console.log('[CLIENT] 🔧 Setting up direct connection handlers');
+    
+    // Store the WebSocket for global access
+    ws = directWs;
+    
+    // Set up message handlers
+    directWs.onmessage = (event) => {
+        const data = JSON.parse(event.data);
+        console.log(`[CLIENT] 📨 Direct message: ${data.type}`);
+        
+        switch (data.type) {
+            case 'pong':
+                console.log('[CLIENT] 🏓 Received pong from direct connection');
+                break;
+                
+            case 'authenticated':
+                console.log('[CLIENT] ✅ Direct authentication successful');
+                // Request session creation
+                directWs.send(JSON.stringify({
+                    type: 'create_session',
+                    sessionId: requestedSessionId,
+                    cols: term.cols,
+                    rows: term.rows
+                }));
+                break;
+                
+            case 'session_created':
+                console.log('[CLIENT] ✅ Direct session created:', data.sessionId);
+                currentSession = { id: data.sessionId };
+                updateSessionDisplay();
+                break;
+                
+            case 'output':
+                // Handle terminal output
+                if (data.sessionId === currentSession?.id) {
+                    term.write(data.data);
+                }
+                break;
+                
+            default:
+                console.log('[CLIENT] ❓ Unknown direct message type:', data.type);
+        }
+    };
+    
+    directWs.onclose = () => {
+        console.log('[CLIENT] ❌ Direct connection closed');
+        updateConnectionStatus('disconnected');
+    };
+    
+    directWs.onerror = (error) => {
+        console.error('[CLIENT] ❌ Direct connection error:', error);
+    };
+    
+    // Set up terminal input handler for direct connection
+    term.onData((data) => {
+        if (currentSession && directWs.readyState === WebSocket.OPEN) {
+            directWs.send(JSON.stringify({
+                type: 'input',
+                sessionId: currentSession.id,
+                data: data
+            }));
+        }
+    });
+    
+    // Send authentication
+    directWs.send(JSON.stringify({
+        type: 'authenticate',
+        agentId: AGENT_ID
+    }));
+    
+    updateConnectionStatus('connected');
+}
+
+function generatePrivateIPCandidates() {
+    // Generate most common private network IP candidates
+    const candidates = [];
+    
+    // Most common home router ranges (limit to most popular subnets)
+    const commonSubnets = [0, 1, 2, 10, 100];
+    for (const subnet of commonSubnets) {
+        // Common host IPs: router (1), common DHCP assignments
+        const hosts = [1, 2, 10, 100, 101, 150];
+        for (const host of hosts) {
+            candidates.push(`192.168.${subnet}.${host}`);
+        }
+    }
+    
+    // Common corporate/enterprise ranges (just the most common ones)
+    candidates.push(
+        '10.0.0.1', '10.0.0.2', '10.0.0.100',
+        '10.0.1.1', '10.0.1.100',
+        '172.16.0.1', '172.16.0.100'
+    );
+    
+    return candidates;
+}
+
+async function initializeWebRTCSignaling() {
+    console.log('[CLIENT] 🚀 Initializing WebRTC signaling connection to agent:', AGENT_ID);
+    
+    // Use Heroku WebSocket server for WebRTC signaling only
     const signalingUrl = 'wss://shell-mirror-30aa5479ceaf.herokuapp.com';
-    console.log('[CLIENT] 🌐 Using Heroku WebSocket server:', signalingUrl);
+    console.log('[CLIENT] 🌐 Using Heroku WebSocket server for signaling:', signalingUrl);
     
     ws = new WebSocket(`${signalingUrl}?role=client`);
-
+    
     ws.onopen = () => {
         console.log('[CLIENT] ✅ WebSocket connection to signaling server opened.');
     };
-
     ws.onmessage = async (message) => {
         const data = JSON.parse(message.data);
         console.log(`[CLIENT] Received message of type: ${data.type}`);
-
         switch (data.type) {
             case 'server-hello':
                 CLIENT_ID = data.id;