@mjasano/devtunnel 1.0.0 → 1.2.0

package/server.js

@@ -4,6 +4,7 @@ const WebSocket = require('ws');
 const pty = require('@homebridge/node-pty-prebuilt-multiarch');
 const path = require('path');
 const os = require('os');
+const fs = require('fs').promises;
 const { spawn } = require('child_process');
 const crypto = require('crypto');
 
@@ -29,6 +30,98 @@ function generateSessionId() {
   return crypto.randomBytes(16).toString('hex');
 }
 
+// Get list of tmux sessions
+async function getTmuxSessions() {
+  return new Promise((resolve) => {
+    const tmux = spawn('tmux', ['list-sessions', '-F', '#{session_name}:#{session_windows}:#{session_attached}']);
+    let output = '';
+
+    tmux.stdout.on('data', (data) => {
+      output += data.toString();
+    });
+
+    tmux.on('close', (code) => {
+      if (code !== 0 || !output.trim()) {
+        resolve([]);
+        return;
+      }
+
+      const sessions = output.trim().split('\n').map(line => {
+        const [name, windows, attached] = line.split(':');
+        return {
+          name,
+          windows: parseInt(windows) || 1,
+          attached: attached === '1'
+        };
+      });
+
+      resolve(sessions);
+    });
+
+    tmux.on('error', () => {
+      resolve([]);
+    });
+  });
+}
+
+// Create session attached to tmux
+function createTmuxSession(tmuxSessionName) {
+  const id = `tmux-${tmuxSessionName}-${Date.now()}`;
+
+  const ptyProcess = pty.spawn('tmux', ['attach-session', '-t', tmuxSessionName], {
+    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,
+    type: 'tmux',
+    tmuxSession: tmuxSessionName
+  };
+
+  ptyProcess.onData((data) => {
+    session.outputBuffer += data;
+    if (session.outputBuffer.length > OUTPUT_BUFFER_SIZE) {
+      session.outputBuffer = session.outputBuffer.slice(-OUTPUT_BUFFER_SIZE);
+    }
+
+    session.clients.forEach(ws => {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify({ type: 'output', data }));
+      }
+    });
+  });
+
+  ptyProcess.onExit(({ exitCode, signal }) => {
+    console.log(`Tmux session ${tmuxSessionName} detached with code ${exitCode}`);
+    session.alive = false;
+
+    session.clients.forEach(ws => {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify({ type: 'exit', exitCode, signal }));
+      }
+    });
+
+    setTimeout(() => {
+      sessions.delete(id);
+      broadcastSessionList();
+    }, 5000);
+  });
+
+  sessions.set(id, session);
+  console.log(`Tmux session attached: ${tmuxSessionName}`);
+  return session;
+}
+
 // Create or get existing session
 function getOrCreateSession(sessionId = null) {
   // If sessionId provided and exists, return it
@@ -119,7 +212,9 @@ function broadcastSessionList() {
     createdAt: s.createdAt,
     lastAccess: s.lastAccess,
     alive: s.alive,
-    clients: s.clients.size
+    clients: s.clients.size,
+    type: s.type || 'shell',
+    tmuxSession: s.tmuxSession
   }));
 
   wss.clients.forEach(client => {
@@ -233,7 +328,7 @@ function stopTunnel(id) {
 }
 
 // WebSocket handling
-wss.on('connection', (ws) => {
+wss.on('connection', async (ws) => {
   console.log('Client connected');
 
   let currentSession = null;
@@ -253,16 +348,38 @@ wss.on('connection', (ws) => {
     createdAt: s.createdAt,
     lastAccess: s.lastAccess,
     alive: s.alive,
-    clients: s.clients.size
+    clients: s.clients.size,
+    type: s.type || 'shell',
+    tmuxSession: s.tmuxSession
   }));
   ws.send(JSON.stringify({ type: 'sessions', data: sessionList }));
 
+  // Send tmux sessions list
+  const tmuxSessions = await getTmuxSessions();
+  ws.send(JSON.stringify({ type: 'tmux-sessions', data: tmuxSessions }));
+
   ws.on('message', (message) => {
     try {
       const msg = JSON.parse(message.toString());
 
       switch (msg.type) {
+        case 'detach':
+          // Detach from current session
+          if (currentSession) {
+            currentSession.clients.delete(ws);
+            currentSession.lastAccess = Date.now();
+            broadcastSessionList();
+            console.log(`Client detached from session ${currentSession.id}`);
+            currentSession = null;
+          }
+          break;
+
         case 'attach':
+          // Detach from current session first if any
+          if (currentSession) {
+            currentSession.clients.delete(ws);
+            currentSession.lastAccess = Date.now();
+          }
           // Attach to existing or new session
           try {
             currentSession = getOrCreateSession(msg.sessionId);
@@ -338,6 +455,43 @@ wss.on('connection', (ws) => {
           }
           break;
 
+        case 'attach-tmux':
+          if (msg.tmuxSession) {
+            try {
+              // Detach from current session if any
+              if (currentSession) {
+                currentSession.clients.delete(ws);
+                currentSession.lastAccess = Date.now();
+                broadcastSessionList();
+              }
+
+              currentSession = createTmuxSession(msg.tmuxSession);
+              currentSession.clients.add(ws);
+
+              ws.send(JSON.stringify({
+                type: 'attached',
+                sessionId: currentSession.id,
+                alive: currentSession.alive,
+                tmuxSession: msg.tmuxSession
+              }));
+
+              broadcastSessionList();
+              console.log(`Client attached to tmux session: ${msg.tmuxSession}`);
+            } catch (err) {
+              ws.send(JSON.stringify({
+                type: 'error',
+                message: err.message
+              }));
+            }
+          }
+          break;
+
+        case 'refresh-tmux':
+          getTmuxSessions().then(tmuxSessions => {
+            ws.send(JSON.stringify({ type: 'tmux-sessions', data: tmuxSessions }));
+          });
+          break;
+
         default:
           console.log('Unknown message type:', msg.type);
       }
@@ -364,6 +518,257 @@ wss.on('connection', (ws) => {
   });
 });
 
+// System Monitoring API
+async function getMemoryInfo() {
+  const totalMem = os.totalmem();
+
+  // macOS: use vm_stat for accurate memory info
+  if (os.platform() === 'darwin') {
+    return new Promise((resolve) => {
+      const vmstat = spawn('vm_stat');
+      let output = '';
+
+      vmstat.stdout.on('data', (data) => {
+        output += data.toString();
+      });
+
+      vmstat.on('close', () => {
+        try {
+          const pageSize = 16384; // macOS default page size (16KB on Apple Silicon)
+          const lines = output.split('\n');
+
+          let free = 0, active = 0, inactive = 0, wired = 0, compressed = 0, purgeable = 0;
+
+          lines.forEach(line => {
+            const match = line.match(/^(.+):\s+(\d+)/);
+            if (match) {
+              const value = parseInt(match[2]) * pageSize;
+              const key = match[1].toLowerCase();
+              if (key.includes('free')) free = value;
+              else if (key.includes('active')) active = value;
+              else if (key.includes('inactive')) inactive = value;
+              else if (key.includes('wired')) wired = value;
+              else if (key.includes('compressed')) compressed = value;
+              else if (key.includes('purgeable')) purgeable = value;
+            }
+          });
+
+          // App Memory = Active + Wired + Compressed (what Activity Monitor shows)
+          const appMemory = active + wired + compressed;
+          const usage = Math.round((appMemory / totalMem) * 100);
+
+          resolve({
+            total: totalMem,
+            used: appMemory,
+            free: totalMem - appMemory,
+            usage
+          });
+        } catch {
+          // Fallback to os.freemem()
+          const freeMem = os.freemem();
+          resolve({
+            total: totalMem,
+            used: totalMem - freeMem,
+            free: freeMem,
+            usage: Math.round(((totalMem - freeMem) / totalMem) * 100)
+          });
+        }
+      });
+
+      vmstat.on('error', () => {
+        const freeMem = os.freemem();
+        resolve({
+          total: totalMem,
+          used: totalMem - freeMem,
+          free: freeMem,
+          usage: Math.round(((totalMem - freeMem) / totalMem) * 100)
+        });
+      });
+    });
+  }
+
+  // Other platforms: use os.freemem()
+  const freeMem = os.freemem();
+  return {
+    total: totalMem,
+    used: totalMem - freeMem,
+    free: freeMem,
+    usage: Math.round(((totalMem - freeMem) / totalMem) * 100)
+  };
+}
+
+async function getSystemInfo() {
+  const cpus = os.cpus();
+  const memory = await getMemoryInfo();
+
+  // Calculate CPU usage
+  let totalIdle = 0;
+  let totalTick = 0;
+  cpus.forEach(cpu => {
+    for (const type in cpu.times) {
+      totalTick += cpu.times[type];
+    }
+    totalIdle += cpu.times.idle;
+  });
+  const cpuUsage = Math.round((1 - totalIdle / totalTick) * 100);
+
+  return {
+    hostname: os.hostname(),
+    platform: os.platform(),
+    arch: os.arch(),
+    uptime: os.uptime(),
+    cpu: {
+      model: cpus[0]?.model || 'Unknown',
+      cores: cpus.length,
+      usage: cpuUsage
+    },
+    memory,
+    loadavg: os.loadavg()
+  };
+}
+
+app.get('/api/system', async (req, res) => {
+  res.json(await getSystemInfo());
+});
+
+// File System API
+const WORKSPACE_ROOT = process.env.WORKSPACE || os.homedir();
+
+// Get file/directory listing
+app.get('/api/files', async (req, res) => {
+  try {
+    const requestedPath = req.query.path || '';
+    const fullPath = path.join(WORKSPACE_ROOT, requestedPath);
+
+    // Security: ensure path is within workspace
+    const normalizedPath = path.normalize(fullPath);
+    if (!normalizedPath.startsWith(WORKSPACE_ROOT)) {
+      return res.status(403).json({ error: 'Access denied' });
+    }
+
+    const stats = await fs.stat(normalizedPath);
+
+    if (stats.isDirectory()) {
+      const entries = await fs.readdir(normalizedPath, { withFileTypes: true });
+      const items = await Promise.all(
+        entries
+          .filter(entry => !entry.name.startsWith('.')) // Hide hidden files
+          .map(async (entry) => {
+            const itemPath = path.join(normalizedPath, entry.name);
+            try {
+              const itemStats = await fs.stat(itemPath);
+              return {
+                name: entry.name,
+                path: path.join(requestedPath, entry.name),
+                isDirectory: entry.isDirectory(),
+                size: itemStats.size,
+                modified: itemStats.mtime
+              };
+            } catch {
+              return null;
+            }
+          })
+      );
+
+      // Sort: directories first, then files
+      const validItems = items.filter(Boolean).sort((a, b) => {
+        if (a.isDirectory !== b.isDirectory) {
+          return a.isDirectory ? -1 : 1;
+        }
+        return a.name.localeCompare(b.name);
+      });
+
+      res.json({
+        path: requestedPath,
+        items: validItems
+      });
+    } else {
+      res.json({
+        path: requestedPath,
+        isFile: true,
+        size: stats.size,
+        modified: stats.mtime
+      });
+    }
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      res.status(404).json({ error: 'Path not found' });
+    } else {
+      res.status(500).json({ error: err.message });
+    }
+  }
+});
+
+// Read file content
+app.get('/api/files/read', async (req, res) => {
+  try {
+    const requestedPath = req.query.path;
+    if (!requestedPath) {
+      return res.status(400).json({ error: 'Path required' });
+    }
+
+    const fullPath = path.join(WORKSPACE_ROOT, requestedPath);
+    const normalizedPath = path.normalize(fullPath);
+
+    if (!normalizedPath.startsWith(WORKSPACE_ROOT)) {
+      return res.status(403).json({ error: 'Access denied' });
+    }
+
+    const stats = await fs.stat(normalizedPath);
+
+    // Limit file size (5MB)
+    if (stats.size > 5 * 1024 * 1024) {
+      return res.status(413).json({ error: 'File too large' });
+    }
+
+    const content = await fs.readFile(normalizedPath, 'utf-8');
+    res.json({
+      path: requestedPath,
+      content,
+      size: stats.size,
+      modified: stats.mtime
+    });
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      res.status(404).json({ error: 'File not found' });
+    } else {
+      res.status(500).json({ error: err.message });
+    }
+  }
+});
+
+// Write file content
+app.post('/api/files/write', async (req, res) => {
+  try {
+    const { path: filePath, content } = req.body;
+
+    if (!filePath) {
+      return res.status(400).json({ error: 'Path required' });
+    }
+
+    const fullPath = path.join(WORKSPACE_ROOT, filePath);
+    const normalizedPath = path.normalize(fullPath);
+
+    if (!normalizedPath.startsWith(WORKSPACE_ROOT)) {
+      return res.status(403).json({ error: 'Access denied' });
+    }
+
+    // Ensure parent directory exists
+    await fs.mkdir(path.dirname(normalizedPath), { recursive: true });
+
+    await fs.writeFile(normalizedPath, content, 'utf-8');
+    const stats = await fs.stat(normalizedPath);
+
+    res.json({
+      path: filePath,
+      size: stats.size,
+      modified: stats.mtime
+    });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
 // REST API
 app.get('/api/sessions', (req, res) => {
   const sessionList = Array.from(sessions.values()).map(s => ({
@@ -430,9 +835,51 @@ app.get('/health', (req, res) => {
   });
 });
 
-const PORT = process.env.PORT || 3000;
-server.listen(PORT, '0.0.0.0', () => {
-  console.log(`DevTunnel server running on http://localhost:${PORT}`);
+const DEFAULT_PORT = process.env.PORT || 3000;
+
+function findAvailablePort(startPort, maxAttempts = 10) {
+  return new Promise((resolve, reject) => {
+    let port = startPort;
+    let attempts = 0;
+
+    const tryPort = () => {
+      if (attempts >= maxAttempts) {
+        reject(new Error(`No available port found after ${maxAttempts} attempts`));
+        return;
+      }
+
+      const testServer = require('net').createServer();
+      testServer.once('error', (err) => {
+        if (err.code === 'EADDRINUSE') {
+          console.log(`Port ${port} is in use, trying ${port + 1}...`);
+          port++;
+          attempts++;
+          tryPort();
+        } else {
+          reject(err);
+        }
+      });
+
+      testServer.once('listening', () => {
+        testServer.close(() => {
+          resolve(port);
+        });
+      });
+
+      testServer.listen(port, '0.0.0.0');
+    };
+
+    tryPort();
+  });
+}
+
+findAvailablePort(DEFAULT_PORT).then((PORT) => {
+  server.listen(PORT, '0.0.0.0', () => {
+    console.log(`DevTunnel server running on http://localhost:${PORT}`);
+  });
+}).catch((err) => {
+  console.error('Failed to start server:', err.message);
+  process.exit(1);
 });
 
 // Graceful shutdown