@mjasano/devtunnel 1.0.0

package/server.js

@@ -0,0 +1,458 @@
+const express = require('express');
+const http = require('http');
+const WebSocket = require('ws');
+const pty = require('@homebridge/node-pty-prebuilt-multiarch');
+const path = require('path');
+const os = require('os');
+const { spawn } = require('child_process');
+const crypto = require('crypto');
+
+const app = express();
+const server = http.createServer(app);
+const wss = new WebSocket.Server({ server });
+
+app.use(express.json());
+app.use(express.static(path.join(__dirname, 'public')));
+
+// Session configuration
+const SESSION_TIMEOUT = 24 * 60 * 60 * 1000; // 24 hours
+const OUTPUT_BUFFER_SIZE = 50000; // Keep last 50KB of output
+
+// Store persistent terminal sessions
+const sessions = new Map();
+
+// Store active tunnels
+const tunnels = new Map();
+
+// Generate session ID
+function generateSessionId() {
+  return crypto.randomBytes(16).toString('hex');
+}
+
+// Create or get existing session
+function getOrCreateSession(sessionId = null) {
+  // If sessionId provided and exists, return it
+  if (sessionId && sessions.has(sessionId)) {
+    const session = sessions.get(sessionId);
+    session.lastAccess = Date.now();
+    return session;
+  }
+
+  // Create new session
+  const id = sessionId || generateSessionId();
+  const shell = os.platform() === 'win32' ? 'powershell.exe' : '/bin/zsh';
+
+  const ptyProcess = pty.spawn(shell, [], {
+    name: 'xterm-256color',
+    cols: 80,
+    rows: 24,
+    cwd: process.env.WORKSPACE || os.homedir(),
+    env: { ...process.env, TERM: 'xterm-256color' }
+  });
+
+  const session = {
+    id,
+    pty: ptyProcess,
+    outputBuffer: '',
+    clients: new Set(),
+    lastAccess: Date.now(),
+    createdAt: Date.now(),
+    alive: true
+  };
+
+  // Buffer output for reconnection
+  ptyProcess.onData((data) => {
+    session.outputBuffer += data;
+    // Trim buffer if too large
+    if (session.outputBuffer.length > OUTPUT_BUFFER_SIZE) {
+      session.outputBuffer = session.outputBuffer.slice(-OUTPUT_BUFFER_SIZE);
+    }
+
+    // Send to all connected clients
+    session.clients.forEach(ws => {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify({ type: 'output', data }));
+      }
+    });
+  });
+
+  ptyProcess.onExit(({ exitCode, signal }) => {
+    console.log(`Session ${id} terminal exited with code ${exitCode}`);
+    session.alive = false;
+
+    session.clients.forEach(ws => {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify({ type: 'exit', exitCode, signal }));
+      }
+    });
+
+    // Remove session after a delay
+    setTimeout(() => {
+      sessions.delete(id);
+      broadcastSessionList();
+    }, 5000);
+  });
+
+  sessions.set(id, session);
+  console.log(`Session created: ${id}`);
+  return session;
+}
+
+// Clean up inactive sessions
+setInterval(() => {
+  const now = Date.now();
+  sessions.forEach((session, id) => {
+    if (session.clients.size === 0 && now - session.lastAccess > SESSION_TIMEOUT) {
+      console.log(`Session ${id} timed out, cleaning up`);
+      if (session.pty) {
+        session.pty.kill();
+      }
+      sessions.delete(id);
+    }
+  });
+}, 60000); // Check every minute
+
+// Broadcast session list to all clients
+function broadcastSessionList() {
+  const sessionList = Array.from(sessions.values()).map(s => ({
+    id: s.id,
+    createdAt: s.createdAt,
+    lastAccess: s.lastAccess,
+    alive: s.alive,
+    clients: s.clients.size
+  }));
+
+  wss.clients.forEach(client => {
+    if (client.readyState === WebSocket.OPEN) {
+      client.send(JSON.stringify({ type: 'sessions', data: sessionList }));
+    }
+  });
+}
+
+// Broadcast tunnel updates to all connected clients
+function broadcastTunnelUpdate() {
+  const tunnelList = Array.from(tunnels.values()).map(t => ({
+    id: t.id,
+    port: t.port,
+    url: t.url,
+    status: t.status
+  }));
+
+  wss.clients.forEach(client => {
+    if (client.readyState === WebSocket.OPEN) {
+      client.send(JSON.stringify({ type: 'tunnels', data: tunnelList }));
+    }
+  });
+}
+
+// Create a new tunnel
+function createTunnel(port) {
+  return new Promise((resolve, reject) => {
+    const id = `tunnel-${port}-${Date.now()}`;
+
+    for (const tunnel of tunnels.values()) {
+      if (tunnel.port === port && tunnel.status === 'active') {
+        reject(new Error(`Tunnel already exists for port ${port}`));
+        return;
+      }
+    }
+
+    const tunnelProcess = spawn('cloudflared', ['tunnel', '--url', `http://localhost:${port}`], {
+      stdio: ['ignore', 'pipe', 'pipe']
+    });
+
+    const tunnel = {
+      id,
+      port,
+      url: null,
+      status: 'connecting',
+      process: tunnelProcess
+    };
+
+    tunnels.set(id, tunnel);
+    broadcastTunnelUpdate();
+
+    let urlFound = false;
+
+    const handleOutput = (data) => {
+      const output = data.toString();
+      console.log(`[Tunnel ${port}] ${output}`);
+
+      const urlMatch = output.match(/https:\/\/[a-zA-Z0-9-]+\.trycloudflare\.com/);
+      if (urlMatch && !urlFound) {
+        urlFound = true;
+        tunnel.url = urlMatch[0];
+        tunnel.status = 'active';
+        broadcastTunnelUpdate();
+        resolve(tunnel);
+      }
+    };
+
+    tunnelProcess.stdout.on('data', handleOutput);
+    tunnelProcess.stderr.on('data', handleOutput);
+
+    tunnelProcess.on('error', (err) => {
+      console.error(`Tunnel process error: ${err.message}`);
+      tunnel.status = 'error';
+      broadcastTunnelUpdate();
+      if (!urlFound) {
+        reject(err);
+      }
+    });
+
+    tunnelProcess.on('exit', (code) => {
+      console.log(`Tunnel for port ${port} exited with code ${code}`);
+      tunnel.status = 'stopped';
+      broadcastTunnelUpdate();
+
+      setTimeout(() => {
+        tunnels.delete(id);
+        broadcastTunnelUpdate();
+      }, 5000);
+    });
+
+    setTimeout(() => {
+      if (!urlFound) {
+        tunnel.status = 'error';
+        broadcastTunnelUpdate();
+        reject(new Error('Timeout waiting for tunnel URL'));
+      }
+    }, 30000);
+  });
+}
+
+function stopTunnel(id) {
+  const tunnel = tunnels.get(id);
+  if (tunnel && tunnel.process) {
+    tunnel.process.kill();
+    tunnel.status = 'stopping';
+    broadcastTunnelUpdate();
+    return true;
+  }
+  return false;
+}
+
+// WebSocket handling
+wss.on('connection', (ws) => {
+  console.log('Client connected');
+
+  let currentSession = null;
+
+  // Send current tunnel list
+  const tunnelList = Array.from(tunnels.values()).map(t => ({
+    id: t.id,
+    port: t.port,
+    url: t.url,
+    status: t.status
+  }));
+  ws.send(JSON.stringify({ type: 'tunnels', data: tunnelList }));
+
+  // Send session list
+  const sessionList = Array.from(sessions.values()).map(s => ({
+    id: s.id,
+    createdAt: s.createdAt,
+    lastAccess: s.lastAccess,
+    alive: s.alive,
+    clients: s.clients.size
+  }));
+  ws.send(JSON.stringify({ type: 'sessions', data: sessionList }));
+
+  ws.on('message', (message) => {
+    try {
+      const msg = JSON.parse(message.toString());
+
+      switch (msg.type) {
+        case 'attach':
+          // Attach to existing or new session
+          try {
+            currentSession = getOrCreateSession(msg.sessionId);
+            currentSession.clients.add(ws);
+
+            // Send session info
+            ws.send(JSON.stringify({
+              type: 'attached',
+              sessionId: currentSession.id,
+              alive: currentSession.alive
+            }));
+
+            // Send buffered output
+            if (currentSession.outputBuffer) {
+              ws.send(JSON.stringify({
+                type: 'output',
+                data: currentSession.outputBuffer
+              }));
+            }
+
+            broadcastSessionList();
+            console.log(`Client attached to session ${currentSession.id}`);
+          } catch (err) {
+            ws.send(JSON.stringify({
+              type: 'error',
+              message: err.message
+            }));
+          }
+          break;
+
+        case 'input':
+          if (currentSession && currentSession.pty && currentSession.alive) {
+            currentSession.pty.write(msg.data);
+          }
+          break;
+
+        case 'resize':
+          if (currentSession && currentSession.pty && msg.cols && msg.rows) {
+            currentSession.pty.resize(msg.cols, msg.rows);
+          }
+          break;
+
+        case 'create-tunnel':
+          if (msg.port) {
+            createTunnel(msg.port)
+              .then(tunnel => {
+                ws.send(JSON.stringify({
+                  type: 'tunnel-created',
+                  data: { id: tunnel.id, port: tunnel.port, url: tunnel.url }
+                }));
+              })
+              .catch(err => {
+                ws.send(JSON.stringify({
+                  type: 'tunnel-error',
+                  error: err.message
+                }));
+              });
+          }
+          break;
+
+        case 'stop-tunnel':
+          if (msg.id) {
+            stopTunnel(msg.id);
+          }
+          break;
+
+        case 'kill-session':
+          if (msg.sessionId) {
+            const session = sessions.get(msg.sessionId);
+            if (session && session.pty) {
+              session.pty.kill();
+            }
+          }
+          break;
+
+        default:
+          console.log('Unknown message type:', msg.type);
+      }
+    } catch (err) {
+      console.error('Error processing message:', err);
+    }
+  });
+
+  ws.on('close', () => {
+    console.log('Client disconnected');
+    if (currentSession) {
+      currentSession.clients.delete(ws);
+      currentSession.lastAccess = Date.now();
+      broadcastSessionList();
+      // Note: We don't kill the session here!
+    }
+  });
+
+  ws.on('error', (err) => {
+    console.error('WebSocket error:', err);
+    if (currentSession) {
+      currentSession.clients.delete(ws);
+    }
+  });
+});
+
+// REST API
+app.get('/api/sessions', (req, res) => {
+  const sessionList = Array.from(sessions.values()).map(s => ({
+    id: s.id,
+    createdAt: s.createdAt,
+    lastAccess: s.lastAccess,
+    alive: s.alive,
+    clients: s.clients.size
+  }));
+  res.json(sessionList);
+});
+
+app.delete('/api/sessions/:id', (req, res) => {
+  const session = sessions.get(req.params.id);
+  if (session) {
+    if (session.pty) {
+      session.pty.kill();
+    }
+    sessions.delete(req.params.id);
+    broadcastSessionList();
+    res.json({ success: true });
+  } else {
+    res.status(404).json({ error: 'Session not found' });
+  }
+});
+
+app.get('/api/tunnels', (req, res) => {
+  const tunnelList = Array.from(tunnels.values()).map(t => ({
+    id: t.id,
+    port: t.port,
+    url: t.url,
+    status: t.status
+  }));
+  res.json(tunnelList);
+});
+
+app.post('/api/tunnels', async (req, res) => {
+  const { port } = req.body;
+  if (!port || typeof port !== 'number') {
+    return res.status(400).json({ error: 'Valid port number required' });
+  }
+
+  try {
+    const tunnel = await createTunnel(port);
+    res.json({ id: tunnel.id, port: tunnel.port, url: tunnel.url });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+app.delete('/api/tunnels/:id', (req, res) => {
+  if (stopTunnel(req.params.id)) {
+    res.json({ success: true });
+  } else {
+    res.status(404).json({ error: 'Tunnel not found' });
+  }
+});
+
+app.get('/health', (req, res) => {
+  res.json({
+    status: 'ok',
+    sessions: sessions.size,
+    tunnels: tunnels.size
+  });
+});
+
+const PORT = process.env.PORT || 3000;
+server.listen(PORT, '0.0.0.0', () => {
+  console.log(`DevTunnel server running on http://localhost:${PORT}`);
+});
+
+// Graceful shutdown
+process.on('SIGINT', () => {
+  console.log('\nShutting down...');
+
+  tunnels.forEach((tunnel) => {
+    if (tunnel.process) {
+      tunnel.process.kill();
+    }
+  });
+
+  sessions.forEach((session) => {
+    if (session.pty) {
+      session.pty.kill();
+    }
+  });
+
+  server.close(() => {
+    console.log('Server closed');
+    process.exit(0);
+  });
+});