aigo 1.0.0

package/bin/vigo.js

@@ -0,0 +1,282 @@
+#!/usr/bin/env node
+
+import { parseArgs } from '../lib/cli.js';
+import { isTmuxInstalled, hasSession, createSession } from '../lib/tmux.js';
+import { isAgentInstalled, checkAgentAuth } from '../lib/cursor.js';
+import { startServer } from '../lib/server.js';
+import { startTunnel, checkNgrokRunning } from '../lib/tunnel.js';
+import { findAvailablePort } from '../lib/port.js';
+import { config } from '../lib/config.js';
+import crypto from 'crypto';
+
+const VERSION = '1.2.0';
+
+function printBanner(info) {
+  const accessUrl = info.tunnelUrl 
+    ? `${info.tunnelUrl}/t/${info.token}`
+    : `${info.localUrl}/t/${info.token}`;
+  
+  const lockStr = info.lockTimeout > 0 ? `${info.lockTimeout}min` : 'off';
+  const exitStr = info.exitTimeout > 0 ? `${info.exitTimeout}min` : 'off';
+  const timeoutStr = `lock:${lockStr} exit:${exitStr}`;
+
+  const toolTitle = info.tool === 'cursor' ? 'Cursor Agent' : 'Claude Code';
+  const header = `vigo - ${toolTitle} Web Terminal`;
+
+  console.log('');
+  console.log('┌────────────────────────────────────────┐');
+  console.log(`│  ${header.padEnd(37)}│`);
+  console.log('├────────────────────────────────────────┤');
+  console.log(`│  Session:  ${info.session.padEnd(27)}│`);
+  console.log(`│  Local:    ${info.localUrl.padEnd(27)}│`);
+  if (info.tunnelUrl) {
+    console.log(`│  Tunnel:   ${info.tunnelUrl.padEnd(27)}│`);
+  }
+  console.log(`│  Password: ${info.password.padEnd(27)}│`);
+  console.log(`│  Timeout:  ${timeoutStr.padEnd(27)}│`);
+  console.log('└────────────────────────────────────────┘');
+  console.log('');
+  console.log('Access URL:');
+  console.log(`  ${accessUrl}`);
+  console.log('');
+  console.log('Press Ctrl+C to stop (tmux session persists)');
+  console.log('');
+}
+
+function printHelp() {
+  console.log(`
+vigo v${VERSION} - Stream Claude Code or Cursor Agent to the web
+
+Usage:
+  vigo [options] claude [claude-args]
+  vigo [options] cursor [cursor-args]
+  vigo [options] agent [agent-args]
+  vigo [options] --attach <session>
+
+Tools:
+  claude                    Use Claude Code CLI
+  cursor, agent             Use Cursor Agent CLI
+
+Options:
+  --port, -p <port>         Web server port (default: ${config.defaultPort}, auto-selects if busy)
+  --session, -s <name>      tmux session name (default: claude-code or cursor-agent)
+  --tunnel, -t <type>       Tunnel: ngrok, cloudflared, none (default: ${config.defaultTunnel})
+  --attach, -a <session>    Attach to existing tmux session (don't start new)
+  --password, -P <pass>     Custom password (default: auto-generated ${config.passwordLength}-char)
+  --timeout, -T <mins>      Lock screen after inactivity (default: disabled)
+  --exit-timeout, -E <mins> Exit session after inactivity (default: disabled)
+  --help, -h                Show this help message
+  --version, -v             Show version
+
+Examples:
+  vigo claude                           Start Claude Code with ngrok tunnel
+  vigo cursor                           Start Cursor Agent with ngrok tunnel
+  vigo --tunnel none claude             Local only (no tunnel)
+  vigo -p 8080 -s myproject cursor      Custom port and session
+  vigo claude --model sonnet            Pass args to Claude
+  vigo cursor --model gpt-5             Pass args to Cursor Agent
+  vigo --attach myproject               Attach to existing session
+  vigo -P mypass123 cursor              Custom password
+`);
+}
+
+async function main() {
+  const { vigoArgs, toolArgs, tool } = parseArgs(process.argv.slice(2));
+  
+  // Handle help and version
+  if (vigoArgs.help) {
+    printHelp();
+    process.exit(0);
+  }
+  
+  if (vigoArgs.version) {
+    console.log(`vigo v${VERSION}`);
+    process.exit(0);
+  }
+  
+  // Check if tmux is installed
+  if (!isTmuxInstalled()) {
+    console.error('Error: tmux is not installed or not in PATH');
+    console.error('');
+    console.error('Install tmux:');
+    console.error('  macOS:  brew install tmux');
+    console.error('  Ubuntu: sudo apt install tmux');
+    console.error('  Arch:   sudo pacman -S tmux');
+    process.exit(1);
+  }
+  
+  // Determine which tool to use (from config default)
+  const activeTool = tool || config.defaultTool;
+  const toolConfig = config.tools[activeTool];
+  
+  // Check if the tool CLI is installed (for non-attach mode)
+  if (!vigoArgs.attach && activeTool === 'cursor') {
+    if (!isAgentInstalled()) {
+      console.error('Error: Cursor Agent CLI is not installed or not in PATH');
+      console.error('');
+      console.error('Install Cursor CLI:');
+      console.error('  curl https://cursor.com/install -fsS | bash');
+      console.error('');
+      console.error('Then authenticate:');
+      console.error('  agent login');
+      process.exit(1);
+    }
+    
+    // Check authentication
+    const authStatus = checkAgentAuth();
+    if (!authStatus.authenticated) {
+      console.error('Warning: Cursor Agent may not be authenticated');
+      console.error(`  ${authStatus.message}`);
+      console.error('');
+      console.error('To authenticate:');
+      console.error('  agent login');
+      console.error('  # or set CURSOR_API_KEY environment variable');
+      console.error('');
+    }
+  }
+  
+  const sessionName = vigoArgs.session || toolConfig.defaultSession;
+  const requestedPort = vigoArgs.port || config.defaultPort;
+  const tunnelType = vigoArgs.tunnel || config.defaultTunnel;
+  
+  // Find available port
+  let port;
+  try {
+    port = await findAvailablePort(requestedPort);
+    if (port !== requestedPort) {
+      console.log(`⚠ Port ${requestedPort} in use, using port ${port} instead`);
+    }
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  }
+  
+  // Generate secure token
+  const token = crypto.randomBytes(config.tokenBytes).toString('hex');
+  
+  // Use custom password or generate password from config
+  let password;
+  if (vigoArgs.password) {
+    password = vigoArgs.password;
+  } else {
+    password = '';
+    const randomBytes = crypto.randomBytes(config.passwordLength);
+    for (let i = 0; i < config.passwordLength; i++) {
+      password += config.passwordChars[randomBytes[i] % config.passwordChars.length];
+    }
+  }
+  
+  // Timeout settings (in minutes) - use config defaults
+  const lockTimeout = vigoArgs.timeout !== null ? vigoArgs.timeout : config.lockTimeout;
+  const exitTimeout = vigoArgs.exitTimeout !== null ? vigoArgs.exitTimeout : config.exitTimeout;
+  
+  // Handle --attach mode
+  if (vigoArgs.attach) {
+    const attachSession = typeof vigoArgs.attach === 'string' ? vigoArgs.attach : sessionName;
+    if (!hasSession(attachSession)) {
+      console.error(`Error: tmux session '${attachSession}' does not exist`);
+      console.error(`Create it first with: tmux new-session -s ${attachSession}`);
+      process.exit(1);
+    }
+    console.log(`✓ Attaching to existing tmux session: ${attachSession}`);
+  } else {
+    // Check if session already exists
+    if (hasSession(sessionName)) {
+      console.log(`✓ Using existing tmux session: ${sessionName}`);
+    } else {
+      // Create new session with the selected tool
+      console.log(`✓ Creating tmux session: ${sessionName} (${toolConfig.name})`);
+      createSession(sessionName, toolConfig.command, toolArgs);
+    }
+  }
+  
+  const actualSession = vigoArgs.attach || sessionName;
+  
+  // Start web server
+  console.log(`✓ Starting web server on port ${port}...`);
+  const server = await startServer({ 
+    port, 
+    token, 
+    password, 
+    session: actualSession,
+    lockTimeout,
+    exitTimeout
+  });
+  
+  // Start tunnel if requested (ngrok is now default)
+  let tunnelUrl = null;
+  let tunnel = null;
+  if (tunnelType !== 'none') {
+    // Check for existing ngrok process before starting
+    if (tunnelType === 'ngrok') {
+      const ngrokStatus = checkNgrokRunning();
+      if (ngrokStatus.running) {
+        console.error('');
+        console.error('Error: An ngrok process is already running.');
+        console.error('Free ngrok accounts only allow 1 simultaneous tunnel.');
+        console.error('');
+        console.error('To kill the existing ngrok process, run:');
+        if (process.platform === 'win32') {
+          console.error(`  taskkill /F /PID ${ngrokStatus.pids.join(' /PID ')}`);
+        } else {
+          console.error(`  kill ${ngrokStatus.pids.join(' ')}`);
+        }
+        console.error('');
+        console.error('Or to run without a tunnel:');
+        console.error('  vigo --tunnel none cursor');
+        console.error('');
+        process.exit(1);
+      }
+    }
+    
+    console.log(`✓ Starting ${tunnelType} tunnel...`);
+    try {
+      tunnel = await startTunnel(tunnelType, port);
+      tunnelUrl = tunnel.url;
+    } catch (err) {
+      console.error(`Warning: Failed to start ${tunnelType} tunnel: ${err.message}`);
+      console.error('Continuing without tunnel...');
+    }
+  }
+  
+  // Print access info
+  printBanner({
+    session: actualSession,
+    localUrl: `http://localhost:${port}`,
+    tunnelUrl,
+    token,
+    password,
+    lockTimeout,
+    exitTimeout,
+    tool: activeTool
+  });
+  
+  // Keep process alive and handle cleanup
+  process.on('SIGINT', () => {
+    console.log('\nShutting down server...');
+    
+    // Kill tunnel if running
+    if (tunnel) {
+      tunnel.kill();
+    }
+    
+    console.log(`tmux session '${actualSession}' is still running.`);
+    console.log(`Re-attach with: vigo --attach ${actualSession}`);
+    console.log(`Or directly: tmux attach -t ${actualSession}`);
+    server.close();
+    process.exit(0);
+  });
+  
+  process.on('SIGTERM', () => {
+    if (tunnel) {
+      tunnel.kill();
+    }
+    server.close();
+    process.exit(0);
+  });
+}
+
+main().catch(err => {
+  console.error('Error:', err.message);
+  process.exit(1);
+});

package/lib/cli.js

@@ -0,0 +1,81 @@
+/**
+ * Parse command line arguments, separating vigo args from tool args
+ * 
+ * Example: vigo --port 8080 --tunnel ngrok claude --model sonnet
+ * Example: vigo --port 8080 cursor --model gpt-5
+ * Returns: 
+ *   vigoArgs: { port: 8080, tunnel: 'ngrok' }
+ *   toolArgs: ['--model', 'sonnet']
+ *   tool: 'claude' | 'cursor' | null
+ */
+export function parseArgs(args) {
+  const vigoArgs = {
+    port: null,
+    session: null,
+    tunnel: null,
+    attach: null,
+    password: null,
+    timeout: null,        // Lock screen timeout in minutes (default: 15)
+    exitTimeout: null,    // Exit after inactivity in minutes (default: 30)
+    help: false,
+    version: false
+  };
+  
+  let toolArgs = [];
+  let tool = null;
+  let i = 0;
+  
+  // Supported tool commands
+  const TOOL_COMMANDS = ['claude', 'cursor', 'agent'];
+  
+  while (i < args.length) {
+    const arg = args[i];
+    
+    // Once we hit a tool command, everything after is tool args
+    if (TOOL_COMMANDS.includes(arg)) {
+      // Normalize 'agent' to 'cursor' for consistency
+      tool = arg === 'agent' ? 'cursor' : arg;
+      toolArgs = args.slice(i + 1);
+      break;
+    }
+    
+    // Parse vigo options
+    if (arg === '--port' || arg === '-p') {
+      vigoArgs.port = parseInt(args[++i], 10);
+    } else if (arg === '--session' || arg === '-s') {
+      vigoArgs.session = args[++i];
+    } else if (arg === '--tunnel' || arg === '-t') {
+      vigoArgs.tunnel = args[++i];
+    } else if (arg === '--attach' || arg === '-a') {
+      const next = args[i + 1];
+      // Check if next arg is a session name (not another flag)
+      if (next && !next.startsWith('-')) {
+        vigoArgs.attach = args[++i];
+      } else {
+        vigoArgs.attach = true; // Use default session name
+      }
+    } else if (arg === '--password' || arg === '-P') {
+      vigoArgs.password = args[++i];
+    } else if (arg === '--timeout' || arg === '-T') {
+      vigoArgs.timeout = parseInt(args[++i], 10);
+    } else if (arg === '--exit-timeout' || arg === '-E') {
+      vigoArgs.exitTimeout = parseInt(args[++i], 10);
+    } else if (arg === '--help' || arg === '-h') {
+      vigoArgs.help = true;
+    } else if (arg === '--version' || arg === '-v') {
+      vigoArgs.version = true;
+    }
+    
+    i++;
+  }
+  
+  // For backward compatibility, also export as claudeArgs/foundClaude
+  return { 
+    vigoArgs, 
+    toolArgs, 
+    tool,
+    // Backward compatibility
+    claudeArgs: toolArgs, 
+    foundClaude: tool === 'claude' 
+  };
+}

package/lib/config.js

@@ -0,0 +1,80 @@
+/**
+ * vigo configuration
+ * 
+ * Edit these values to customize vigo's default behavior.
+ */
+
+export const config = {
+  // ============================================
+  // Server Settings
+  // ============================================
+  
+  /** Default web server port (auto-selects next available if busy) */
+  defaultPort: 3000,
+  
+  /** Default tunnel type: 'ngrok', 'cloudflared', or 'none' */
+  defaultTunnel: 'ngrok',
+  
+  // ============================================
+  // Session Timeouts
+  // ============================================
+  
+  /** 
+   * Lock screen timeout in minutes (0 = disabled)
+   * After this period of inactivity, the session locks and requires password re-entry
+   * Default: 0 (disabled) for persistent sessions
+   */
+  lockTimeout: 0,
+  
+  /** 
+   * Exit timeout in minutes (0 = disabled)
+   * After this period of total inactivity, the session terminates completely
+   * Default: 0 (disabled) for persistent sessions
+   */
+  exitTimeout: 0,
+  
+  // ============================================
+  // Tool Configurations
+  // ============================================
+  
+  tools: {
+    claude: {
+      name: 'Claude Code',
+      command: 'claude',
+      defaultSession: 'claude-code'
+    },
+    cursor: {
+      name: 'Cursor Agent',
+      command: 'agent',
+      defaultSession: 'cursor-agent'
+    }
+  },
+  
+  /** Default tool when none specified */
+  defaultTool: 'claude',
+  
+  // ============================================
+  // Security Settings
+  // ============================================
+  
+  /** Length of auto-generated password */
+  passwordLength: 6,
+  
+  /** Characters used for auto-generated passwords (no ambiguous chars like 0/O, 1/l/I) */
+  passwordChars: 'ABCDEFGHJKLMNPQRSTUVWXYZabcdefghjkmnpqrstuvwxyz23456789',
+  
+  /** Length of URL token (in bytes, will be hex encoded = 2x chars) */
+  tokenBytes: 2,
+  
+  // ============================================
+  // Reconnection Settings
+  // ============================================
+  
+  /** Maximum reconnection attempts before giving up */
+  maxReconnectAttempts: 10,
+  
+  /** Base delay between reconnection attempts (ms) */
+  reconnectDelay: 2000
+};
+
+export default config;

package/lib/cursor.js

@@ -0,0 +1,74 @@
+import { execSync } from 'child_process';
+
+// Cache the agent path
+let agentPath = null;
+
+/**
+ * Get the full path to Cursor agent CLI binary
+ */
+export function getAgentPath() {
+  if (agentPath) return agentPath;
+  
+  try {
+    agentPath = execSync('which agent', { encoding: 'utf-8' }).trim();
+    return agentPath;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if Cursor agent CLI is installed
+ */
+export function isAgentInstalled() {
+  return getAgentPath() !== null;
+}
+
+/**
+ * Check if Cursor CLI is authenticated
+ * Returns: { authenticated: boolean, message: string }
+ */
+export function checkAgentAuth() {
+  const agentBin = getAgentPath();
+  if (!agentBin) {
+    return { 
+      authenticated: false, 
+      message: 'Cursor agent CLI is not installed' 
+    };
+  }
+  
+  try {
+    // Try to check auth status
+    const output = execSync(`${agentBin} status 2>&1`, { 
+      encoding: 'utf-8',
+      timeout: 10000
+    });
+    
+    // Check for common authenticated patterns
+    if (output.includes('logged in') || output.includes('authenticated')) {
+      return { authenticated: true, message: 'Authenticated' };
+    }
+    
+    return { 
+      authenticated: false, 
+      message: 'Not authenticated. Run: agent login' 
+    };
+  } catch (err) {
+    // If CURSOR_API_KEY is set, assume authenticated
+    if (process.env.CURSOR_API_KEY) {
+      return { authenticated: true, message: 'Using CURSOR_API_KEY' };
+    }
+    
+    return { 
+      authenticated: false, 
+      message: 'Unable to verify auth status. Try: agent login' 
+    };
+  }
+}
+
+/**
+ * Get the command to run for Cursor CLI
+ */
+export function getAgentCommand() {
+  return getAgentPath() || 'agent';
+}

package/lib/port.js

@@ -0,0 +1,39 @@
+import { createServer } from 'net';
+
+/**
+ * Check if a port is available
+ */
+export function isPortAvailable(port) {
+  return new Promise((resolve) => {
+    const server = createServer();
+    
+    server.once('error', (err) => {
+      if (err.code === 'EADDRINUSE') {
+        resolve(false);
+      } else {
+        resolve(false);
+      }
+    });
+    
+    server.once('listening', () => {
+      server.close();
+      resolve(true);
+    });
+    
+    server.listen(port, '127.0.0.1');
+  });
+}
+
+/**
+ * Find an available port starting from the given port
+ * Tries up to maxAttempts ports
+ */
+export async function findAvailablePort(startPort, maxAttempts = 100) {
+  for (let i = 0; i < maxAttempts; i++) {
+    const port = startPort + i;
+    if (await isPortAvailable(port)) {
+      return port;
+    }
+  }
+  throw new Error(`Could not find available port after ${maxAttempts} attempts starting from ${startPort}`);
+}