aigo 1.0.0

package/lib/server.js

@@ -0,0 +1,284 @@
+import express from 'express';
+import { createServer } from 'http';
+import { WebSocketServer } from 'ws';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import pty from 'node-pty';
+import { getTmuxPath, killSession } from './tmux.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Start the web server with WebSocket support
+ */
+export function startServer({ port, token, password, session, lockTimeout, exitTimeout }) {
+  return new Promise((resolve, reject) => {
+    const app = express();
+    const server = createServer(app);
+    
+    // Track last activity for exit timeout
+    let lastActivityTime = Date.now();
+    let exitTimer = null;
+    let hasActiveConnection = false;
+    
+    // Update activity timestamp
+    const updateActivity = () => {
+      lastActivityTime = Date.now();
+    };
+    
+    // Start exit timeout checker
+    const startExitTimer = () => {
+      if (exitTimeout <= 0 || exitTimer) return;
+      
+      exitTimer = setInterval(() => {
+        const inactiveMinutes = (Date.now() - lastActivityTime) / 1000 / 60;
+        
+        if (inactiveMinutes >= exitTimeout) {
+          console.log(`\nSession inactive for ${exitTimeout} minutes. Exiting...`);
+          
+          // Kill tmux session
+          killSession(session);
+          console.log(`Killed tmux session: ${session}`);
+          
+          // Notify all connected clients
+          wss.clients.forEach(client => {
+            if (client.readyState === client.OPEN) {
+              client.send(JSON.stringify({ type: 'session_expired' }));
+              client.close(1000, 'Session expired due to inactivity');
+            }
+          });
+          
+          // Stop timer and exit
+          clearInterval(exitTimer);
+          server.close();
+          process.exit(0);
+        }
+      }, 60000); // Check every minute
+    };
+    
+    // Serve static files from public directory
+    const publicPath = path.join(__dirname, '..', 'public');
+    app.use('/static', express.static(publicPath));
+    
+    // Token validation middleware
+    const validateToken = (req, res, next) => {
+      const urlToken = req.params.token;
+      if (urlToken !== token) {
+        return res.status(403).send('Forbidden: Invalid token');
+      }
+      next();
+    };
+    
+    // Serve terminal page at /t/:token
+    app.get('/t/:token', validateToken, (req, res) => {
+      res.sendFile(path.join(publicPath, 'index.html'));
+    });
+    
+    // Health check endpoint
+    app.get('/health', (req, res) => {
+      res.json({ status: 'ok' });
+    });
+    
+    // WebSocket server
+    const wss = new WebSocketServer({ server, path: `/ws/${token}` });
+    
+    wss.on('connection', (ws) => {
+      console.log('WebSocket client connected');
+      hasActiveConnection = true;
+      updateActivity();
+      
+      // Start exit timer on first connection
+      startExitTimer();
+      
+      let ptyProcess = null;
+      let authenticated = false;
+      
+      // Send auth request
+      ws.send(JSON.stringify({ type: 'auth_required' }));
+      
+      // Handle incoming WebSocket messages
+      ws.on('message', (data) => {
+        const message = data.toString();
+        
+        // Handle authentication
+        if (!authenticated) {
+          try {
+            const parsed = JSON.parse(message);
+            if (parsed.type === 'auth' && parsed.password) {
+              if (parsed.password === password) {
+                authenticated = true;
+                updateActivity();
+                console.log('Client authenticated successfully');
+                
+                // Send auth success with config
+                ws.send(JSON.stringify({ 
+                  type: 'auth_success',
+                  config: {
+                    lockTimeout: lockTimeout,   // minutes
+                    exitTimeout: exitTimeout    // minutes
+                  }
+                }));
+                
+                // Now spawn the PTY
+                try {
+                  const tmuxBin = getTmuxPath() || 'tmux';
+                  console.log(`Spawning PTY: ${tmuxBin} attach-session -t ${session}`);
+                  
+                  ptyProcess = pty.spawn(tmuxBin, ['attach-session', '-t', session], {
+                    name: 'xterm-256color',
+                    cols: parsed.cols || 80,
+                    rows: parsed.rows || 24,
+                    cwd: process.env.HOME,
+                    env: {
+                      ...process.env,
+                      TERM: 'xterm-256color'
+                    }
+                  });
+                  
+                  // Pipe PTY output to WebSocket
+                  ptyProcess.onData((ptyData) => {
+                    try {
+                      if (ws.readyState === ws.OPEN) {
+                        ws.send(ptyData);
+                      }
+                    } catch (err) {
+                      console.error('Error sending to WebSocket:', err);
+                    }
+                  });
+                  
+                  ptyProcess.onExit(({ exitCode, signal }) => {
+                    console.log(`PTY exited with code ${exitCode}, signal ${signal}`);
+                    if (ws.readyState === ws.OPEN) {
+                      ws.close();
+                    }
+                  });
+                } catch (err) {
+                  console.error('Failed to spawn PTY:', err.message);
+                  ws.send(`\r\n\x1b[31mError: Failed to attach to tmux session '${session}'\x1b[0m\r\n`);
+                  ws.close(1011, 'PTY spawn failed');
+                }
+              } else {
+                console.log('Client authentication failed');
+                ws.send(JSON.stringify({ type: 'auth_failed' }));
+              }
+              return;
+            }
+          } catch {
+            // Not JSON or not auth message
+          }
+          return; // Ignore all messages until authenticated
+        }
+        
+        // Already authenticated - handle messages
+        try {
+          const parsed = JSON.parse(message);
+          
+          // Handle activity ping (resets server-side timer)
+          if (parsed.type === 'activity') {
+            updateActivity();
+            return;
+          }
+          
+          // Handle resize command
+          if (parsed.type === 'resize' && parsed.cols && parsed.rows) {
+            updateActivity();
+            if (ptyProcess) {
+              ptyProcess.resize(parsed.cols, parsed.rows);
+            }
+            return;
+          }
+          
+          // Handle re-auth (after lock screen)
+          if (parsed.type === 're-auth' && parsed.password) {
+            if (parsed.password === password) {
+              updateActivity();
+              ws.send(JSON.stringify({ type: 'auth_success' }));
+            } else {
+              ws.send(JSON.stringify({ type: 'auth_failed' }));
+            }
+            return;
+          }
+          
+          // Handle full cleanup request
+          if (parsed.type === 'cleanup') {
+            console.log('\nFull cleanup requested from web client...');
+            
+            // Kill PTY first
+            if (ptyProcess) {
+              ptyProcess.kill();
+            }
+            
+            // Kill tmux session
+            killSession(session);
+            console.log(`Killed tmux session: ${session}`);
+            
+            // Notify client
+            ws.send(JSON.stringify({ type: 'cleanup_complete' }));
+            
+            // Close all WebSocket connections
+            wss.clients.forEach(client => {
+              if (client.readyState === client.OPEN) {
+                client.close(1000, 'Cleanup requested');
+              }
+            });
+            
+            // Stop exit timer
+            if (exitTimer) clearInterval(exitTimer);
+            
+            // Give time for cleanup message to send, then exit
+            setTimeout(() => {
+              console.log('Server shutting down...');
+              server.close();
+              process.exit(0);
+            }, 500);
+            return;
+          }
+        } catch {
+          // Not JSON - treat as terminal input
+        }
+        
+        // Terminal input
+        if (ptyProcess) {
+          updateActivity();
+          ptyProcess.write(message);
+        }
+      });
+      
+      ws.on('close', () => {
+        console.log('WebSocket client disconnected');
+        if (ptyProcess) {
+          ptyProcess.kill();
+        }
+        
+        // Check if any connections remain
+        hasActiveConnection = wss.clients.size > 0;
+      });
+      
+      ws.on('error', (err) => {
+        console.error('WebSocket error:', err);
+        if (ptyProcess) {
+          ptyProcess.kill();
+        }
+      });
+    });
+    
+    // Handle upgrade requests - only allow valid token
+    server.on('upgrade', (request, socket, head) => {
+      const expectedPath = `/ws/${token}`;
+      if (request.url !== expectedPath) {
+        socket.write('HTTP/1.1 403 Forbidden\r\n\r\n');
+        socket.destroy();
+        return;
+      }
+    });
+    
+    server.listen(port, () => {
+      resolve(server);
+    });
+    
+    server.on('error', (err) => {
+      reject(err);
+    });
+  });
+}

package/lib/tmux.js

@@ -0,0 +1,86 @@
+import { execSync, spawn } from 'child_process';
+
+// Cache the tmux path
+let tmuxPath = null;
+
+/**
+ * Get the full path to tmux binary
+ */
+export function getTmuxPath() {
+  if (tmuxPath) return tmuxPath;
+  
+  try {
+    tmuxPath = execSync('which tmux', { encoding: 'utf-8' }).trim();
+    return tmuxPath;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if tmux is installed
+ */
+export function isTmuxInstalled() {
+  return getTmuxPath() !== null;
+}
+
+/**
+ * Check if a tmux session exists
+ */
+export function hasSession(name) {
+  const tmuxBin = getTmuxPath() || 'tmux';
+  try {
+    execSync(`${tmuxBin} has-session -t ${name} 2>/dev/null`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Create a new tmux session running a command with the given args
+ * @param {string} name - tmux session name
+ * @param {string} command - command to run (e.g., 'claude', 'agent')
+ * @param {string[]} args - arguments to pass to the command
+ */
+export function createSession(name, command, args = []) {
+  const tmuxBin = getTmuxPath() || 'tmux';
+  const cmd = [command, ...args].join(' ');
+  
+  try {
+    // Create detached tmux session running the command
+    execSync(`${tmuxBin} new-session -d -s ${name} '${cmd}'`, {
+      stdio: 'inherit'
+    });
+  } catch (err) {
+    throw new Error(`Failed to create tmux session: ${err.message}`);
+  }
+}
+
+/**
+ * Kill a tmux session
+ */
+export function killSession(name) {
+  const tmuxBin = getTmuxPath() || 'tmux';
+  try {
+    execSync(`${tmuxBin} kill-session -t ${name} 2>/dev/null`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * List all tmux sessions
+ */
+export function listSessions() {
+  const tmuxBin = getTmuxPath() || 'tmux';
+  try {
+    const output = execSync(`${tmuxBin} list-sessions -F "#{session_name}"`, {
+      encoding: 'utf-8'
+    });
+    return output.trim().split('\n').filter(Boolean);
+  } catch {
+    return [];
+  }
+}

package/lib/tunnel.js

@@ -0,0 +1,150 @@
+import { spawn, execSync } from 'child_process';
+
+/**
+ * Check if ngrok is already running
+ * Returns { running: boolean, pids: number[] }
+ */
+export function checkNgrokRunning() {
+  try {
+    let output;
+    if (process.platform === 'win32') {
+      output = execSync('tasklist /FI "IMAGENAME eq ngrok.exe" /FO CSV /NH 2>nul', { encoding: 'utf8' });
+      const lines = output.trim().split('\n').filter(l => l.includes('ngrok.exe'));
+      if (lines.length > 0) {
+        // Extract PIDs from CSV format: "ngrok.exe","1234",...
+        const pids = lines.map(l => {
+          const match = l.match(/"ngrok\.exe","(\d+)"/);
+          return match ? parseInt(match[1], 10) : null;
+        }).filter(Boolean);
+        return { running: true, pids };
+      }
+    } else {
+      output = execSync('pgrep -f "ngrok http" 2>/dev/null || true', { encoding: 'utf8' });
+      const pids = output.trim().split('\n').filter(Boolean).map(p => parseInt(p, 10));
+      if (pids.length > 0) {
+        return { running: true, pids };
+      }
+    }
+  } catch (e) {
+    // pgrep returns non-zero if no process found, which is fine
+  }
+  return { running: false, pids: [] };
+}
+
+/**
+ * Start a tunnel (ngrok or cloudflared) and return the public URL
+ */
+export async function startTunnel(type, port) {
+  if (type === 'ngrok') {
+    return startNgrok(port);
+  } else if (type === 'cloudflared') {
+    return startCloudflared(port);
+  } else {
+    throw new Error(`Unknown tunnel type: ${type}. Use 'ngrok' or 'cloudflared'`);
+  }
+}
+
+/**
+ * Start ngrok and extract the public URL
+ */
+function startNgrok(port) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn('ngrok', ['http', port.toString(), '--log', 'stdout'], {
+      stdio: ['ignore', 'pipe', 'pipe']
+    });
+    
+    let output = '';
+    let resolved = false;
+    
+    proc.stdout.on('data', (data) => {
+      output += data.toString();
+      
+      // Look for the URL in ngrok output
+      // Format: url=https://xxxx.ngrok.io or url=https://xxxx.ngrok-free.app
+      const urlMatch = output.match(/url=(https:\/\/[^\s]+)/);
+      if (urlMatch && !resolved) {
+        resolved = true;
+        resolve({
+          url: urlMatch[1],
+          kill: () => proc.kill()
+        });
+      }
+    });
+    
+    proc.stderr.on('data', (data) => {
+      output += data.toString();
+    });
+    
+    proc.on('error', (err) => {
+      if (!resolved) {
+        reject(new Error(`Failed to start ngrok: ${err.message}. Is ngrok installed?`));
+      }
+    });
+    
+    proc.on('exit', (code) => {
+      if (!resolved) {
+        reject(new Error(`ngrok exited with code ${code}. Output: ${output}`));
+      }
+    });
+    
+    // Timeout after 30 seconds
+    setTimeout(() => {
+      if (!resolved) {
+        proc.kill();
+        reject(new Error('Timeout waiting for ngrok URL'));
+      }
+    }, 30000);
+  });
+}
+
+/**
+ * Start cloudflared and extract the public URL
+ */
+function startCloudflared(port) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn('cloudflared', ['tunnel', '--url', `http://localhost:${port}`], {
+      stdio: ['ignore', 'pipe', 'pipe']
+    });
+    
+    let output = '';
+    let resolved = false;
+    
+    const handleOutput = (data) => {
+      output += data.toString();
+      
+      // Look for the URL in cloudflared output
+      // Format: https://xxxx.trycloudflare.com
+      const urlMatch = output.match(/(https:\/\/[^\s]+\.trycloudflare\.com)/);
+      if (urlMatch && !resolved) {
+        resolved = true;
+        resolve({
+          url: urlMatch[1],
+          kill: () => proc.kill()
+        });
+      }
+    };
+    
+    proc.stdout.on('data', handleOutput);
+    proc.stderr.on('data', handleOutput); // cloudflared outputs to stderr
+    
+    proc.on('error', (err) => {
+      if (!resolved) {
+        reject(new Error(`Failed to start cloudflared: ${err.message}. Is cloudflared installed?`));
+      }
+    });
+    
+    proc.on('exit', (code) => {
+      if (!resolved) {
+        reject(new Error(`cloudflared exited with code ${code}. Output: ${output}`));
+      }
+    });
+    
+    // Timeout after 30 seconds
+    setTimeout(() => {
+      if (!resolved) {
+        proc.kill();
+        reject(new Error('Timeout waiting for cloudflared URL'));
+      }
+    }, 30000);
+  });
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "aigo",
+  "version": "1.0.0",
+  "description": "Stream Claude Code to the web - run Claude remotely from any device",
+  "type": "module",
+  "bin": {
+    "aigo": "./bin/vigo.js"
+  },
+  "scripts": {
+    "start": "node bin/vigo.js",
+    "postinstall": "chmod +x node_modules/node-pty/prebuilds/darwin-*/spawn-helper 2>/dev/null || true"
+  },
+  "keywords": [
+    "claude",
+    "terminal",
+    "web",
+    "tmux",
+    "remote"
+  ],
+  "author": "wakandan221",
+  "license": "MIT",
+  "dependencies": {
+    "express": "^4.21.0",
+    "ws": "^8.18.0",
+    "node-pty": "^1.0.0"
+  }
+}