minivibe 0.1.0

package/vibe.js

@@ -0,0 +1,1621 @@
+#!/usr/bin/env node
+
+/**
+ * vibe-cli - Claude Code wrapper with mobile remote control
+ *
+ * Usage:
+ *   vibe "your prompt here"          Start new session with prompt
+ *   vibe --bridge ws://server:8080   Connect to bridge server (for internet access)
+ *   vibe --resume <id>               Resume existing session
+ *   vibe                             Start interactive session
+ */
+
+const { spawn, execSync, exec } = require('child_process');
+const WebSocket = require('ws');
+const { v4: uuidv4 } = require('uuid');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const http = require('http');
+
+// Find claude executable
+function findClaudePath() {
+  try {
+    // Use 'where' on Windows, 'which' on Unix
+    const cmd = os.platform() === 'win32' ? 'where claude' : 'which claude';
+    const result = execSync(cmd, { encoding: 'utf8' }).trim();
+    // 'where' on Windows can return multiple lines, take the first
+    return result.split('\n')[0].trim();
+  } catch {
+    // Fallback paths
+    if (os.platform() === 'win32') {
+      // Common Windows install locations
+      const userPath = path.join(os.homedir(), 'AppData', 'Local', 'Programs', 'claude', 'claude.exe');
+      if (fs.existsSync(userPath)) return userPath;
+      return 'claude';  // Hope it's in PATH
+    }
+    return '/opt/homebrew/bin/claude';
+  }
+}
+
+// Token storage
+const TOKEN_FILE = path.join(os.homedir(), '.vibe', 'token');
+const AUTH_FILE = path.join(os.homedir(), '.vibe', 'auth.json');
+const LOGIN_HTML = path.join(__dirname, 'login.html');
+
+// Firebase web config (public - safe to embed in client code)
+// Update these values from: Firebase Console → Project Settings → Web App
+const FIREBASE_CONFIG = {
+  apiKey: "AIzaSyAJKYavMidKYxRpfhP2IHUiy8dafc3ISqc",
+  authDomain: "minivibe-adaf4.firebaseapp.com",
+  projectId: "minivibe-adaf4",
+  storageBucket: "minivibe-adaf4.firebasestorage.app",
+  messagingSenderId: "11868121436",
+  appId: "1:11868121436:web:fa1a4941e6b222bc59b999",
+  measurementId: "G-29YEJLRVDS"
+};
+
+// Discover local vibe-agent
+const AGENT_PORT_FILE = path.join(os.homedir(), '.vibe-agent', 'port');
+const DEFAULT_AGENT_URL = 'ws://localhost:9999';
+
+function discoverLocalAgent() {
+  // Try to read port file from vibe-agent
+  try {
+    if (fs.existsSync(AGENT_PORT_FILE)) {
+      const port = fs.readFileSync(AGENT_PORT_FILE, 'utf8').trim();
+      return `ws://localhost:${port}`;
+    }
+  } catch (err) {
+    // Ignore
+  }
+  // Fall back to default
+  return DEFAULT_AGENT_URL;
+}
+
+// Get stored auth data (token + refresh token)
+function getStoredAuth() {
+  try {
+    // Try new JSON format first
+    if (fs.existsSync(AUTH_FILE)) {
+      const data = JSON.parse(fs.readFileSync(AUTH_FILE, 'utf8'));
+      return data;
+    }
+    // Fall back to old token-only format
+    if (fs.existsSync(TOKEN_FILE)) {
+      return { idToken: fs.readFileSync(TOKEN_FILE, 'utf8').trim() };
+    }
+  } catch (err) {
+    // Ignore
+  }
+  return null;
+}
+
+function getStoredToken() {
+  const auth = getStoredAuth();
+  return auth?.idToken || null;
+}
+
+// Store auth data (token + refresh token)
+function storeAuth(idToken, refreshToken = null) {
+  try {
+    const dir = path.dirname(AUTH_FILE);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    const data = { idToken, refreshToken, updatedAt: new Date().toISOString() };
+    fs.writeFileSync(AUTH_FILE, JSON.stringify(data, null, 2), 'utf8');
+    fs.chmodSync(AUTH_FILE, 0o600); // Only user can read
+    // Also write to old token file for backwards compatibility
+    fs.writeFileSync(TOKEN_FILE, idToken, 'utf8');
+    fs.chmodSync(TOKEN_FILE, 0o600);
+    return true;
+  } catch (err) {
+    console.error(`Failed to store auth: ${err.message}`);
+    return false;
+  }
+}
+
+// Legacy function for backwards compatibility
+function storeToken(token) {
+  return storeAuth(token, null);
+}
+
+// Refresh the ID token using Firebase REST API
+async function refreshIdToken() {
+  const auth = getStoredAuth();
+  if (!auth?.refreshToken) {
+    logStatus('No refresh token available');
+    return null;
+  }
+
+  try {
+    logStatus('Refreshing authentication token...');
+    const response = await fetch(
+      `https://securetoken.googleapis.com/v1/token?key=${FIREBASE_CONFIG.apiKey}`,
+      {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        body: `grant_type=refresh_token&refresh_token=${auth.refreshToken}`
+      }
+    );
+
+    if (!response.ok) {
+      const error = await response.json();
+      logStatus(`Token refresh failed: ${error.error?.message || response.status}`);
+      return null;
+    }
+
+    const data = await response.json();
+    // Store new tokens
+    storeAuth(data.id_token, data.refresh_token);
+    log('✅ Token refreshed successfully', colors.green);
+    return data.id_token;
+  } catch (err) {
+    logStatus(`Token refresh error: ${err.message}`);
+    return null;
+  }
+}
+
+// Browser-based login
+function startLoginFlow() {
+  // Check if Firebase config is set up
+  if (FIREBASE_CONFIG.apiKey === "YOUR_API_KEY") {
+    console.log(`
+Firebase not configured.
+
+Edit vibe.js and update FIREBASE_CONFIG with your Firebase web app values:
+
+const FIREBASE_CONFIG = {
+  apiKey: "your-api-key",
+  authDomain: "your-project.firebaseapp.com",
+  projectId: "your-project-id"
+};
+
+Get these values from:
+1. Firebase Console → Project Settings → General
+2. Scroll to "Your apps" → Web app → Config
+`);
+    process.exit(1);
+  }
+
+  const firebaseConfig = FIREBASE_CONFIG;
+
+  if (!fs.existsSync(LOGIN_HTML)) {
+    console.error(`Login page not found: ${LOGIN_HTML}`);
+    console.error('Make sure login.html is in the vibe-cli directory.');
+    process.exit(1);
+  }
+
+  const loginHtml = fs.readFileSync(LOGIN_HTML, 'utf8');
+
+  // Inject Firebase config into HTML
+  const htmlWithConfig = loginHtml.replace(
+    'window.FIREBASE_CONFIG',
+    `window.FIREBASE_CONFIG = ${JSON.stringify(firebaseConfig)}`
+  );
+
+  const PORT = 9876;
+  let server;
+
+  server = http.createServer((req, res) => {
+    if (req.method === 'GET' && req.url === '/') {
+      res.writeHead(200, { 'Content-Type': 'text/html' });
+      res.end(htmlWithConfig);
+    } else if (req.method === 'POST' && req.url === '/callback') {
+      let body = '';
+      req.on('data', chunk => body += chunk);
+      req.on('end', () => {
+        try {
+          const { token, refreshToken, email } = JSON.parse(body);
+          if (token) {
+            storeAuth(token, refreshToken || null);
+            console.log(`\n✅ Logged in as ${email}`);
+            console.log(`   Auth saved to ${AUTH_FILE}`);
+            if (refreshToken) {
+              console.log(`   Token auto-refresh enabled`);
+            }
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ success: true }));
+
+            // Close server after short delay
+            setTimeout(() => {
+              server.close();
+              process.exit(0);
+            }, 500);
+          } else {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'No token provided' }));
+          }
+        } catch (err) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: err.message }));
+        }
+      });
+    } else {
+      res.writeHead(404);
+      res.end('Not found');
+    }
+  });
+
+  server.listen(PORT, () => {
+    const url = `http://localhost:${PORT}`;
+    console.log(`\nOpening browser for login...`);
+    console.log(`If browser doesn't open, visit: ${url}`);
+    console.log(`\nPress Ctrl+C to cancel.\n`);
+
+    // Open browser based on OS
+    // Windows 'start' needs empty title ("") before URL
+    if (process.platform === 'win32') {
+      exec(`start "" "${url}"`);
+    } else {
+      const openCmd = process.platform === 'darwin' ? 'open' : 'xdg-open';
+      exec(`${openCmd} ${url}`);
+    }
+
+    // Timeout after 5 minutes
+    setTimeout(() => {
+      console.log('\nLogin timed out. Please try again.');
+      server.close();
+      process.exit(1);
+    }, 5 * 60 * 1000);
+  });
+
+  server.on('error', (err) => {
+    if (err.code === 'EADDRINUSE') {
+      console.error(`Port ${PORT} is in use. Close other applications and try again.`);
+    } else {
+      console.error('Server error:', err.message);
+    }
+    process.exit(1);
+  });
+}
+
+// Default bridge URL for headless login
+const DEFAULT_BRIDGE_URL = 'wss://ws.neng.ai';
+
+// Headless device code login flow
+async function startHeadlessLogin(bridgeHttpUrl) {
+  console.log(`
+🔐 Headless Login
+══════════════════════════════════════
+`);
+
+  try {
+    // Request a device code from the bridge server
+    console.log('Requesting device code...');
+    const codeRes = await fetch(`${bridgeHttpUrl}/device/code`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' }
+    });
+
+    if (!codeRes.ok) {
+      console.error(`Failed to get device code: ${codeRes.status}`);
+      process.exit(1);
+    }
+
+    const { deviceId, code, expiresIn } = await codeRes.json();
+
+    console.log(`   Visit:  ${bridgeHttpUrl}/device`);
+    console.log(`   Code:   ${code}`);
+    console.log('');
+    console.log(`   Code expires in ${Math.floor(expiresIn / 60)} minutes.`);
+    console.log('   Waiting for authentication...');
+    console.log('');
+    console.log('   Press Ctrl+C to cancel.');
+    console.log('');
+
+    // Poll for token
+    const pollInterval = 3000; // 3 seconds
+    const maxAttempts = Math.ceil((expiresIn * 1000) / pollInterval);
+    let attempts = 0;
+    let consecutiveErrors = 0;
+    const maxConsecutiveErrors = 5;
+
+    while (attempts < maxAttempts) {
+      await new Promise(resolve => setTimeout(resolve, pollInterval));
+      attempts++;
+
+      try {
+        const pollRes = await fetch(`${bridgeHttpUrl}/device/poll/${deviceId}`);
+
+        // Handle non-JSON responses gracefully
+        const contentType = pollRes.headers.get('content-type') || '';
+        if (!contentType.includes('application/json')) {
+          consecutiveErrors++;
+          if (consecutiveErrors >= maxConsecutiveErrors) {
+            console.error(`\nServer error: Invalid response format`);
+            process.exit(1);
+          }
+          process.stdout.write('!');
+          continue;
+        }
+
+        const pollData = await pollRes.json();
+        consecutiveErrors = 0; // Reset on successful response
+
+        if (pollData.status === 'complete') {
+          console.log(''); // New line after dots
+          storeAuth(pollData.token, pollData.refreshToken || null);
+          console.log(`✅ Logged in as ${pollData.email}`);
+          console.log(`   Auth saved to ${AUTH_FILE}`);
+          if (pollData.refreshToken) {
+            console.log(`   Token auto-refresh enabled`);
+          }
+          process.exit(0);
+        } else if (pollRes.status === 404 || pollData.error === 'Device not found or expired') {
+          console.log('\n\nCode expired. Please try again.');
+          process.exit(1);
+        } else if (pollData.error) {
+          console.error(`\nError: ${pollData.error}`);
+          process.exit(1);
+        }
+        // Still pending, continue polling
+        process.stdout.write('.');
+      } catch (err) {
+        consecutiveErrors++;
+        if (consecutiveErrors >= maxConsecutiveErrors) {
+          console.error(`\nNetwork error: ${err.message}`);
+          console.error('Please check your internet connection and try again.');
+          process.exit(1);
+        }
+        // Temporary network error - show warning but continue
+        process.stdout.write('!');
+      }
+    }
+
+    console.log('\n\nLogin timed out. Please try again.');
+    process.exit(1);
+  } catch (err) {
+    console.error(`Failed to start headless login: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+// Parse arguments
+const args = process.argv.slice(2);
+let initialPrompt = null;
+let resumeSessionId = null;
+let bridgeUrl = null;
+let agentUrl = null;  // Connect via local vibe-agent
+let authToken = null;
+let headlessMode = false;
+let sessionName = null;
+let useNodePty = os.platform() === 'win32';  // Auto-detect Windows, can be overridden
+
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === '--help' || args[i] === '-h') {
+    console.log(`
+vibe-cli - Claude Code wrapper with mobile remote control
+
+Usage:
+  vibe "your prompt here"          Start new session with prompt
+  vibe --bridge ws://server:8080   Connect to bridge server
+  vibe --agent                     Connect via local vibe-agent (managed mode)
+  vibe --resume <id>               Resume existing session
+  vibe --login                     Sign in with Google (browser)
+  vibe --login --headless          Sign in on headless server (EC2, etc.)
+  vibe                             Start interactive session
+
+Options:
+  --bridge <url>   Connect to bridge server (enables internet access)
+  --agent [url]    Connect via local vibe-agent (default: ws://localhost:9999)
+  --name <name>    Name this session (shown in mobile app)
+  --resume <id>    Resume a previous session by ID
+  --login          Sign in with Google in browser
+  --headless       Use device code flow for headless environments
+  --token <token>  Set Firebase auth token manually
+  --logout         Remove stored auth token
+  --node-pty       Use Node.js PTY wrapper (required for Windows, optional for Unix)
+  --help, -h       Show this help message
+
+In-Session Commands:
+  /name <name>     Rename the current session
+
+Authentication:
+  Use --login to sign in via browser, or get token from MiniVibe iOS app.
+  Use --login --headless on servers without a browser (EC2, etc.)
+
+Examples:
+  vibe --login                                    Sign in (browser)
+  vibe --login --headless                         Sign in (headless)
+  vibe --bridge wss://ws.neng.ai                  Connect to bridge
+  vibe --agent                                    Connect via local agent
+  vibe --bridge wss://ws.neng.ai "Fix bug"        With initial prompt
+`);
+    process.exit(0);
+  } else if (args[i] === '--headless') {
+    headlessMode = true;
+  } else if (args[i] === '--login') {
+    // Defer login handling until we know if --headless is also present
+    // Will be handled after the loop
+  } else if (args[i] === '--bridge' && args[i + 1]) {
+    bridgeUrl = args[i + 1];
+    i++;
+  } else if (args[i] === '--agent') {
+    // Check if next arg is a URL or another flag
+    if (args[i + 1] && !args[i + 1].startsWith('--')) {
+      agentUrl = args[i + 1];
+      i++;
+    } else {
+      // Auto-discover or use default
+      agentUrl = discoverLocalAgent();
+    }
+  } else if (args[i] === '--name' && args[i + 1]) {
+    sessionName = args[i + 1];
+    i++;
+  } else if (args[i] === '--resume' && args[i + 1]) {
+    resumeSessionId = args[i + 1];
+    i++;
+  } else if (args[i] === '--token' && args[i + 1]) {
+    authToken = args[i + 1];
+    storeToken(authToken);
+    console.log('Token stored successfully');
+    i++;
+  } else if (args[i] === '--logout') {
+    try {
+      if (fs.existsSync(TOKEN_FILE)) {
+        fs.unlinkSync(TOKEN_FILE);
+        console.log('Logged out successfully');
+      } else {
+        console.log('Not logged in');
+      }
+    } catch (err) {
+      console.error('Logout failed:', err.message);
+    }
+    process.exit(0);
+  } else if (args[i] === '--node-pty') {
+    useNodePty = true;
+  } else if (!args[i].startsWith('--')) {
+    initialPrompt = args[i];
+  }
+}
+
+// Handle login after all args are parsed (so we know if --headless was set)
+// Login mode is exclusive - don't start Claude
+let loginMode = false;
+if (args.includes('--login')) {
+  loginMode = true;
+  if (headlessMode) {
+    // Convert WebSocket URL to HTTP(S) URL for API calls
+    let httpUrl = bridgeUrl || DEFAULT_BRIDGE_URL;
+    httpUrl = httpUrl.replace('wss://', 'https://').replace('ws://', 'http://');
+    startHeadlessLogin(httpUrl);
+    // startHeadlessLogin is async and exits on its own
+  } else {
+    startLoginFlow();
+    // startLoginFlow starts a server and exits on callback
+  }
+}
+
+// Load stored token if not provided
+if (!authToken) {
+  authToken = getStoredToken();
+}
+
+// Session state
+const sessionId = resumeSessionId || uuidv4();
+let claudeProcess = null;
+let isRunning = false;
+let isShuttingDown = false;
+let bridgeSocket = null;
+let reconnectTimer = null;
+let sessionFileWatcher = null;
+let lastFileSize = 0;
+let heartbeatTimer = null;
+let isAuthenticated = false;
+let pendingPermission = null;  // Track pending permission request { id, command, timestamp }
+let lastApprovalTime = 0;      // Debounce rapid approvals
+const completedToolIds = new Set();  // Track tool_use IDs that have tool_result (already executed)
+const MAX_COMPLETED_TOOLS = 500;     // Limit Set size to prevent memory issues in long sessions
+let lastCapturedPrompt = null;       // Last permission prompt captured from CLI output
+const mobileMessageHashes = new Set();  // Track messages from mobile to avoid duplicate echo
+const MAX_MOBILE_MESSAGES = 100;     // Limit Set size
+
+// Colors for terminal output
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  dim: '\x1b[2m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+};
+
+function log(msg, color = '') {
+  console.log(`${color}${msg}${colors.reset}`);
+}
+
+function logStatus(msg) {
+  log(`[vibe] ${msg}`, colors.dim);
+}
+
+// Get Claude session file path
+// Claude uses path with '/' replaced by '-' (not base64)
+function getSessionFilePath() {
+  const projectPathHash = process.cwd().replace(/\//g, '-');
+  const claudeDir = path.join(os.homedir(), '.claude', 'projects', projectPathHash);
+  return path.join(claudeDir, `${sessionId}.jsonl`);
+}
+
+// Get local IP
+function getLocalIP() {
+  const interfaces = os.networkInterfaces();
+  for (const name of Object.keys(interfaces)) {
+    for (const iface of interfaces[name]) {
+      if (iface.family === 'IPv4' && !iface.internal) {
+        return iface.address;
+      }
+    }
+  }
+  return 'localhost';
+}
+
+// Safe write to Claude's stdin
+function safeStdinWrite(data) {
+  if (!claudeProcess || !isRunning || isShuttingDown) {
+    return false;
+  }
+  try {
+    if (claudeProcess.stdin && claudeProcess.stdin.writable) {
+      claudeProcess.stdin.write(data);
+      return true;
+    }
+    return false;
+  } catch (err) {
+    logStatus(`Failed to write to Claude: ${err.message}`);
+    return false;
+  }
+}
+
+// Send message to Claude (from bridge)
+function sendToClaude(content, source = 'bridge') {
+  if (!claudeProcess || !isRunning || isShuttingDown) {
+    log('Claude is not running', colors.yellow);
+    return false;
+  }
+
+  logStatus(`Sending message: "${content}"`);
+
+  // Send text first
+  const textBuffer = Buffer.from(content, 'utf8');
+  if (!safeStdinWrite(textBuffer)) {
+    return false;
+  }
+
+  // Send Enter key separately after a short delay
+  // This mimics how a real keyboard sends input
+  setTimeout(() => {
+    if (!claudeProcess || !isRunning || isShuttingDown) return;
+
+    const enterBuffer = Buffer.from('\r', 'utf8');
+    logStatus(`Sending Enter (\\r = 0x0d)`);
+    safeStdinWrite(enterBuffer);
+  }, 100);
+
+  if (source === 'mobile') {
+    log(`📱 [mobile]: ${content}`, colors.cyan);
+  }
+
+  return true;
+}
+
+// ====================
+// Bridge Connection
+// ====================
+
+function connectToBridge() {
+  // Use agentUrl if set, otherwise bridgeUrl
+  const targetUrl = agentUrl || bridgeUrl;
+  if (!targetUrl) return;
+
+  const isAgentMode = !!agentUrl;
+
+  // Check for auth token when bridge is enabled (not needed for agent mode)
+  if (!isAgentMode && !authToken) {
+    log('⚠️  No authentication token found.', colors.yellow);
+    log('   Use --token <token> to set your Firebase token.', colors.dim);
+    log('   Get your token from the MiniVibe mobile app.', colors.dim);
+    log('', '');
+    log('   Continuing without authentication (bridge may reject connection)', colors.dim);
+  }
+
+  if (isAgentMode) {
+    logStatus(`Connecting to local agent: ${targetUrl}`);
+  } else {
+    logStatus(`Connecting to bridge: ${targetUrl}`);
+  }
+  isAuthenticated = false;
+
+  bridgeSocket = new WebSocket(targetUrl);
+
+  bridgeSocket.on('open', () => {
+    logStatus('Connected to bridge server');
+
+    // Authenticate first
+    if (authToken) {
+      logStatus('Sending authentication...');
+      bridgeSocket.send(JSON.stringify({
+        type: 'authenticate',
+        token: authToken
+      }));
+    } else {
+      // No token - send a placeholder (will work if bridge is in dev mode)
+      bridgeSocket.send(JSON.stringify({
+        type: 'authenticate',
+        token: 'dev-mode'
+      }));
+    }
+
+    // Start heartbeat to keep connection alive
+    if (heartbeatTimer) clearInterval(heartbeatTimer);
+    heartbeatTimer = setInterval(() => {
+      if (bridgeSocket && bridgeSocket.readyState === WebSocket.OPEN) {
+        bridgeSocket.ping();
+      }
+    }, 30000); // Ping every 30 seconds
+  });
+
+  bridgeSocket.on('message', (raw) => {
+    try {
+      const msg = JSON.parse(raw.toString());
+      handleBridgeMessage(msg);
+    } catch (err) {
+      logStatus(`Invalid bridge message: ${err.message}`);
+    }
+  });
+
+  bridgeSocket.on('close', () => {
+    logStatus('Disconnected from bridge');
+    bridgeSocket = null;
+
+    // Stop heartbeat
+    if (heartbeatTimer) {
+      clearInterval(heartbeatTimer);
+      heartbeatTimer = null;
+    }
+
+    // Reconnect if not shutting down
+    if (!isShuttingDown) {
+      logStatus('Reconnecting in 3 seconds...');
+      reconnectTimer = setTimeout(connectToBridge, 3000);
+    }
+  });
+
+  bridgeSocket.on('error', (err) => {
+    logStatus(`Bridge connection error: ${err.message}`);
+  });
+}
+
+function handleBridgeMessage(msg) {
+  switch (msg.type) {
+    case 'authenticated':
+      isAuthenticated = true;
+      logStatus(`Authenticated as ${msg.userId} (${msg.email || 'no email'})`);
+      log('✅ Authenticated with bridge server', colors.green);
+
+      // Now register our session
+      bridgeSocket.send(JSON.stringify({
+        type: 'register_session',
+        sessionId,
+        path: process.cwd(),
+        name: sessionName || path.basename(process.cwd())  // Use --name or fallback to directory name
+      }));
+      break;
+
+    case 'auth_error':
+      isAuthenticated = false;
+      log(`⚠️  Authentication failed: ${msg.message}`, colors.yellow);
+
+      // Try to refresh the token
+      (async () => {
+        const newToken = await refreshIdToken();
+        if (newToken) {
+          authToken = newToken;
+          // Re-authenticate with new token
+          if (bridgeSocket && bridgeSocket.readyState === WebSocket.OPEN) {
+            bridgeSocket.send(JSON.stringify({
+              type: 'authenticate',
+              token: newToken
+            }));
+          }
+        } else {
+          log('❌ Token refresh failed. Please re-login:', colors.yellow);
+          log('   vibe --login', colors.dim);
+        }
+      })();
+      break;
+
+    case 'session_registered':
+      logStatus(`Session registered with bridge: ${msg.sessionId.slice(0, 8)}...`);
+      break;
+
+    case 'send_message':
+      // Mobile sent a message - forward to Claude
+      // Track it so we don't echo it back (bridge already echoed to iOS)
+      if (msg.content) {
+        // Store hash of message content to detect it in session file later
+        const hash = msg.content.trim().toLowerCase();
+        if (mobileMessageHashes.size >= MAX_MOBILE_MESSAGES) {
+          // Remove oldest (first) entry
+          const first = mobileMessageHashes.values().next().value;
+          mobileMessageHashes.delete(first);
+        }
+        mobileMessageHashes.add(hash);
+        sendToClaude(msg.content, msg.source || 'mobile');
+      }
+      break;
+
+    case 'approve_permission':
+    case 'approve_permission_always':
+      // Claude Code shows numbered selection: 1=Yes, 2=Yes don't ask again, 3=Custom
+      // approve_permission sends '1', approve_permission_always sends '2'
+      // Can also use msg.option to specify: 1, 2, or 3
+      {
+        const now = Date.now();
+        // Debounce: ignore if less than 500ms since last approval
+        if (now - lastApprovalTime < 500) {
+          log('📱 Permission approval debounced (too fast)', colors.dim);
+          break;
+        }
+        // Check if there's a pending permission
+        if (!pendingPermission) {
+          log('📱 No pending permission to approve', colors.yellow);
+          break;
+        }
+        // Determine which option to send
+        let option = '1';
+        let optionLabel = 'Yes';
+        let customText = null;
+
+        if (msg.type === 'approve_permission_always' || msg.option === 2) {
+          option = '2';
+          optionLabel = "Yes, don't ask again";
+        } else if (msg.option === 3) {
+          // Option 3: custom text
+          if (msg.customText && typeof msg.customText === 'string' && msg.customText.trim()) {
+            option = '3';
+            optionLabel = 'Custom';
+            // Sanitize: remove newlines, limit length
+            customText = msg.customText.replace(/[\r\n]+/g, ' ').trim().slice(0, 500);
+          } else {
+            log('📱 Option 3 requires customText, falling back to option 1', colors.yellow);
+          }
+        } else if (msg.option && msg.option !== 1) {
+          log(`📱 Invalid option ${msg.option}, using option 1`, colors.yellow);
+        }
+
+        // Send the option number first, then Enter separately (like sendToClaude)
+        // Claude's ink UI needs them sent separately to register the selection
+        const optionBuffer = Buffer.from(option, 'utf8');
+        if (safeStdinWrite(optionBuffer)) {
+          log(`📱 Permission approved (${option}: ${optionLabel}): ${pendingPermission.command}`, colors.green);
+          lastApprovalTime = now;
+          const savedCustomText = customText;  // Save for closure
+          pendingPermission = null;
+
+          // Send Enter after a short delay
+          setTimeout(() => {
+            // Guard: check if process is still running
+            if (!claudeProcess || !isRunning || isShuttingDown) return;
+
+            const enterBuffer = Buffer.from('\r', 'utf8');
+            safeStdinWrite(enterBuffer);
+            logStatus('Sent Enter for permission confirmation');
+
+            // For option 3, send custom text after another delay
+            if (option === '3' && savedCustomText) {
+              setTimeout(() => {
+                // Guard: check if process is still running
+                if (!claudeProcess || !isRunning || isShuttingDown) return;
+
+                // Send custom text
+                const textBuffer = Buffer.from(savedCustomText, 'utf8');
+                safeStdinWrite(textBuffer);
+                // Then Enter
+                setTimeout(() => {
+                  // Guard: check if process is still running
+                  if (!claudeProcess || !isRunning || isShuttingDown) return;
+
+                  const enterBuffer2 = Buffer.from('\r', 'utf8');
+                  if (safeStdinWrite(enterBuffer2)) {
+                    log(`📱 Sent custom text: "${savedCustomText.slice(0, 50)}${savedCustomText.length > 50 ? '...' : ''}"`, colors.dim);
+                  }
+                }, 100);
+              }, 150);
+            }
+          }, 100);
+
+          sendToBridge({ type: 'session_status', status: 'active' });
+        }
+      }
+      break;
+
+    case 'deny_permission':
+      // Send Ctrl+C to cancel the permission prompt (more reliable than Escape)
+      {
+        if (!pendingPermission) {
+          log('📱 No pending permission to deny', colors.yellow);
+          break;
+        }
+        // Try Escape first, then Ctrl+C as fallback
+        if (safeStdinWrite('\x1b') || safeStdinWrite('\x03')) {
+          log(`📱 Permission denied: ${pendingPermission.command}`, colors.yellow);
+          pendingPermission = null;
+          sendToBridge({ type: 'session_status', status: 'active' });
+        }
+      }
+      break;
+
+    case 'session_renamed':
+      // Update local session name (could be from our rename or from iOS rename)
+      if (msg.name) {
+        sessionName = msg.name;
+        log(`📝 Session name updated: ${msg.name}`, colors.cyan);
+      }
+      break;
+
+    case 'error':
+      logStatus(`Bridge error: ${msg.message}`);
+      break;
+
+    // Agent-mode messages (when connected via --agent)
+    case 'bridge_disconnected':
+      log('⚠️  Bridge connection lost, agent reconnecting...', colors.yellow);
+      break;
+
+    case 'bridge_reconnected':
+      log('✅ Bridge connection restored', colors.green);
+      break;
+
+    case 'session_stop':
+      // Agent is stopping this session - don't reconnect
+      log('🛑 Session stopped by agent', colors.yellow);
+      isShuttingDown = true;
+      // Let Claude process finish gracefully
+      if (claudeProcess && !claudeProcess.killed) {
+        try { claudeProcess.kill('SIGTERM'); } catch {}
+      }
+      break;
+
+    default:
+      logStatus(`Unknown bridge message: ${msg.type}`);
+  }
+}
+
+function sendToBridge(data) {
+  if (!isAuthenticated) {
+    logStatus(`Cannot send to bridge: not authenticated`);
+    return false;
+  }
+  if (bridgeSocket && bridgeSocket.readyState === WebSocket.OPEN) {
+    try {
+      const json = JSON.stringify(data);
+      bridgeSocket.send(json);
+      logStatus(`SENT to bridge: type=${data.type}, size=${json.length} bytes`);
+      return true;
+    } catch (err) {
+      logStatus(`Failed to send to bridge: ${err.message}`);
+    }
+  } else {
+    logStatus(`Cannot send to bridge: socket ${bridgeSocket ? 'not open' : 'null'}`);
+  }
+  return false;
+}
+
+// ====================
+// Session File Watcher (for Claude output)
+// ====================
+
+function startSessionFileWatcher() {
+  const sessionFile = getSessionFilePath();
+  logStatus(`Watching session file: ${sessionFile}`);
+
+  // Also check what files actually exist in the projects directory
+  const projectsDir = path.join(os.homedir(), '.claude', 'projects');
+  if (fs.existsSync(projectsDir)) {
+    const dirs = fs.readdirSync(projectsDir);
+    logStatus(`Found ${dirs.length} project directories in ${projectsDir}`);
+    // Look for our session in any directory
+    for (const dir of dirs.slice(0, 5)) { // Check first 5
+      const fullDir = path.join(projectsDir, dir);
+      if (fs.statSync(fullDir).isDirectory()) {
+        const files = fs.readdirSync(fullDir);
+        const sessionFiles = files.filter(f => f.includes(sessionId.slice(0, 8)));
+        if (sessionFiles.length > 0) {
+          logStatus(`Found session files in ${dir}: ${sessionFiles.join(', ')}`);
+        }
+      }
+    }
+  }
+
+  let fileCheckCount = 0;
+  const pollInterval = setInterval(() => {
+    if (!isRunning || isShuttingDown) {
+      clearInterval(pollInterval);
+      return;
+    }
+
+    try {
+      if (!fs.existsSync(sessionFile)) {
+        // Log occasionally that file doesn't exist yet
+        if (fileCheckCount++ % 20 === 0) {
+          logStatus(`Session file not found yet: ${sessionFile}`);
+        }
+        return;
+      }
+
+      const stats = fs.statSync(sessionFile);
+      if (stats.size > lastFileSize) {
+        logStatus(`Session file changed: ${lastFileSize} -> ${stats.size} bytes`);
+        const fd = fs.openSync(sessionFile, 'r');
+        const buffer = Buffer.alloc(stats.size - lastFileSize);
+        fs.readSync(fd, buffer, 0, buffer.length, lastFileSize);
+        fs.closeSync(fd);
+        lastFileSize = stats.size;
+
+        const newContent = buffer.toString('utf8');
+        const lines = newContent.split('\n').filter(l => l.trim());
+        logStatus(`Processing ${lines.length} new lines from session file`);
+
+        // First pass: collect all tool_result IDs (auto-approved tools)
+        // This ensures we know which tools are already completed before processing tool_use
+        for (const line of lines) {
+          try {
+            const msg = JSON.parse(line);
+            if (msg.message?.content && Array.isArray(msg.message.content)) {
+              for (const block of msg.message.content) {
+                if (block.type === 'tool_result' && block.tool_use_id) {
+                  // Limit Set size to prevent memory issues
+                  if (completedToolIds.size >= MAX_COMPLETED_TOOLS) {
+                    const firstId = completedToolIds.values().next().value;
+                    completedToolIds.delete(firstId);
+                  }
+                  completedToolIds.add(block.tool_use_id);
+                  logStatus(`Pre-scan: found completed tool ${block.tool_use_id}`);
+                }
+              }
+            }
+          } catch (e) {
+            // Not valid JSON, skip
+          }
+        }
+
+        // Second pass: process all messages
+        for (const line of lines) {
+          try {
+            const msg = JSON.parse(line);
+            processSessionMessage(msg);
+          } catch (e) {
+            // Not valid JSON, skip
+          }
+        }
+      }
+    } catch (err) {
+      logStatus(`Session file error: ${err.message}`);
+    }
+  }, 500);
+
+  return () => clearInterval(pollInterval);
+}
+
+function processSessionMessage(msg) {
+  logStatus(`Processing message: type=${msg.type || 'unknown'}, has_message=${!!msg.message}`);
+
+  // Debug: log content block types
+  if (msg.message?.content && Array.isArray(msg.message.content)) {
+    const blockTypes = msg.message.content.map(b => b.type).join(', ');
+    logStatus(`Content blocks: [${blockTypes}]`);
+  }
+
+  if (!msg.message || !msg.message.role) {
+    logStatus(`Skipping: no message.role (type=${msg.type})`);
+    return;
+  }
+
+  const role = msg.message.role;
+  const content = msg.message.content;
+
+  logStatus(`Message role=${role}, content_type=${typeof content}, is_array=${Array.isArray(content)}`);
+
+  // Build comprehensive message with all content types
+  let parts = [];
+  let toolUses = [];
+  let thinkingContent = '';
+
+  if (typeof content === 'string') {
+    parts.push(content);
+  } else if (Array.isArray(content)) {
+    for (const block of content) {
+      if (block.type === 'text') {
+        parts.push(block.text);
+      } else if (block.type === 'thinking') {
+        // Claude's reasoning/planning
+        thinkingContent = block.thinking || '';
+        logStatus(`Found thinking block: ${thinkingContent.slice(0, 100)}...`);
+      } else if (block.type === 'tool_use') {
+        // Tool use request (permission prompt)
+        const toolInfo = {
+          id: block.id,
+          name: block.name,
+          input: block.input
+        };
+        toolUses.push(toolInfo);
+        logStatus(`Found tool_use: ${block.name} (id: ${block.id})`);
+
+        // Format tool use for display
+        let toolDescription = `**${block.name}**`;
+        if (block.input) {
+          if (block.name === 'Bash' && block.input.command) {
+            toolDescription += `\n\`\`\`\n${block.input.command}\n\`\`\``;
+            if (block.input.description) {
+              toolDescription += `\n${block.input.description}`;
+            }
+          } else if (block.name === 'Read' && block.input.file_path) {
+            toolDescription += `: ${block.input.file_path}`;
+          } else if (block.name === 'Write' && block.input.file_path) {
+            toolDescription += `: ${block.input.file_path}`;
+          } else if (block.name === 'Edit' && block.input.file_path) {
+            toolDescription += `: ${block.input.file_path}`;
+          } else {
+            // Generic tool input display
+            const inputStr = JSON.stringify(block.input, null, 2);
+            if (inputStr.length < 500) {
+              toolDescription += `\n\`\`\`json\n${inputStr}\n\`\`\``;
+            }
+          }
+        }
+        parts.push(toolDescription);
+      } else if (block.type === 'tool_result') {
+        // Tool execution result - permission was processed (auto-approved or user approved)
+        logStatus(`Found tool_result for tool_use_id: ${block.tool_use_id}`);
+        // Mark this tool as completed so we don't send permission_request for it
+        if (completedToolIds.size >= MAX_COMPLETED_TOOLS) {
+          const firstId = completedToolIds.values().next().value;
+          completedToolIds.delete(firstId);
+        }
+        completedToolIds.add(block.tool_use_id);
+        // Clear pending permission since tool was executed
+        if (pendingPermission && pendingPermission.id === block.tool_use_id) {
+          pendingPermission = null;
+        }
+        if (block.content) {
+          const resultText = typeof block.content === 'string'
+            ? block.content
+            : JSON.stringify(block.content);
+          if (resultText.length < 1000) {
+            parts.push(`*Result:*\n${resultText}`);
+          } else {
+            parts.push(`*Result:* (${resultText.length} chars)`);
+          }
+        }
+      }
+    }
+  }
+
+  // Send thinking content if present
+  if (thinkingContent) {
+    log(`💭 Sending thinking to iOS (${thinkingContent.length} chars)`, colors.dim);
+    sendToBridge({
+      type: 'claude_message',
+      message: {
+        id: uuidv4(),
+        sender: 'claude',
+        content: `💭 *Thinking:*\n${thinkingContent}`,
+        timestamp: new Date().toISOString(),
+        messageType: 'thinking'
+      }
+    });
+  }
+
+  // Send tool use as permission request (only for tools not yet executed)
+  const pendingTools = toolUses.filter(t => !completedToolIds.has(t.id));
+  if (pendingTools.length > 0) {
+    log(`🔧 Sending ${pendingTools.length} tool_use to iOS (${toolUses.length - pendingTools.length} already completed)`, colors.dim);
+  }
+
+  // Helper function to send permission request with captured or fallback options
+  function sendPermissionRequest(tool, displayText, capturedPrompt) {
+    let options;
+    let question = 'Permission required';
+
+    if (capturedPrompt && capturedPrompt.options) {
+      // Use actual options captured from CLI terminal output
+      log(`📋 Using captured CLI prompt with ${capturedPrompt.options.length} options`, colors.dim);
+      options = capturedPrompt.options.map(opt => ({
+        id: opt.id,
+        label: opt.label,
+        action: opt.id === 1 ? 'approve' : opt.id === 2 ? 'approve_always' : 'custom',
+        requiresInput: opt.requiresInput || false
+      }));
+      question = capturedPrompt.question || question;
+    } else {
+      // Fallback: build context-aware options
+      log(`⚠️ No captured prompt, using fallback options`, colors.dim);
+      let dontAskAgainLabel = "Yes, and don't ask again";
+      if (tool.name === 'Bash' && tool.input?.command) {
+        const baseCmd = tool.input.command.trim().split(/\s+/)[0];
+        dontAskAgainLabel = `Yes, and don't ask again for ${baseCmd} commands`;
+      } else if (tool.name === 'Read') {
+        dontAskAgainLabel = "Yes, and don't ask again for Read";
+      } else if (tool.name === 'Write') {
+        dontAskAgainLabel = "Yes, and don't ask again for Write";
+      } else if (tool.name === 'Edit') {
+        dontAskAgainLabel = "Yes, and don't ask again for Edit";
+      }
+      options = [
+        { id: 1, label: 'Yes', action: 'approve' },
+        { id: 2, label: dontAskAgainLabel, action: 'approve_always' },
+        { id: 3, label: 'Tell Claude what to do differently', action: 'custom', requiresInput: true }
+      ];
+    }
+
+    sendToBridge({
+      type: 'permission_request',
+      sessionId: sessionId,
+      requestId: tool.id,
+      command: tool.name,
+      question: question,
+      displayText: displayText,
+      fullText: JSON.stringify(tool.input, null, 2),
+      options: options,
+      cancelLabel: 'Cancel'
+    });
+  }
+
+  for (const tool of pendingTools) {
+    // Track the pending permission (only last one if multiple)
+    pendingPermission = {
+      id: tool.id,
+      command: tool.name,
+      timestamp: Date.now()
+    };
+
+    // Build display-friendly description
+    let displayText = `**${tool.name}**`;
+    if (tool.input) {
+      if (tool.name === 'Bash' && tool.input.command) {
+        displayText = `Run command:\n\`\`\`\n${tool.input.command}\n\`\`\``;
+      } else if (tool.name === 'Read' && tool.input.file_path) {
+        displayText = `Read file: ${tool.input.file_path}`;
+      } else if (tool.name === 'Write' && tool.input.file_path) {
+        displayText = `Write file: ${tool.input.file_path}`;
+      } else if (tool.name === 'Edit' && tool.input.file_path) {
+        displayText = `Edit file: ${tool.input.file_path}`;
+      } else {
+        displayText = `${tool.name}: ${JSON.stringify(tool.input, null, 2)}`;
+      }
+    }
+
+    // Check if we already have a captured prompt
+    if (lastCapturedPrompt && lastCapturedPrompt.options) {
+      sendPermissionRequest(tool, displayText, lastCapturedPrompt);
+      lastCapturedPrompt = null;
+    } else {
+      // Wait briefly for prompt to be captured from terminal output
+      // The prompt appears on terminal slightly after tool_use is written to session file
+      const toolCopy = { ...tool };
+      const displayTextCopy = displayText;
+      setTimeout(() => {
+        sendPermissionRequest(toolCopy, displayTextCopy, lastCapturedPrompt);
+        lastCapturedPrompt = null;
+      }, 300);  // 300ms delay to allow prompt capture
+    }
+  }
+
+  // Send text content
+  const textContent = parts.join('\n\n');
+  if (!textContent.trim()) {
+    logStatus(`Skipping: no displayable content extracted`);
+    return;
+  }
+
+  // Only skip user messages that came from mobile (send_message)
+  // Bridge already echoed those, so sending again would cause duplicates
+  // But initial prompts and local terminal input should still be sent
+  if (role === 'user') {
+    const hash = textContent.trim().toLowerCase();
+    if (mobileMessageHashes.has(hash)) {
+      // This message came from mobile - bridge already echoed it
+      mobileMessageHashes.delete(hash);  // Clean up (each message only needs to be skipped once)
+      logStatus(`Skipping mobile message (bridge echoed): "${textContent.slice(0, 30)}..."`);
+      return;
+    }
+    // This is initial prompt or local terminal input - send it
+    logStatus(`Sending user message (initial/local): "${textContent.slice(0, 50)}..."`);
+  } else {
+    logStatus(`Sending ${role} message to bridge: "${textContent.slice(0, 50)}${textContent.length > 50 ? '...' : ''}"`);
+  }
+
+  // Send to bridge
+  sendToBridge({
+    type: 'claude_message',
+    message: {
+      id: msg.uuid || uuidv4(),
+      sender: role === 'user' ? 'user' : 'claude',
+      content: textContent,
+      timestamp: new Date().toISOString()
+    }
+  });
+
+  // Send token usage if available (assistant messages include usage data)
+  if (msg.message?.usage) {
+    const usage = msg.message.usage;
+    sendToBridge({
+      type: 'token_usage',
+      sessionId: sessionId,
+      model: msg.message.model || null,
+      usage: {
+        input_tokens: usage.input_tokens || 0,
+        output_tokens: usage.output_tokens || 0,
+        cache_creation_tokens: usage.cache_creation_input_tokens || 0,
+        cache_read_tokens: usage.cache_read_input_tokens || 0
+      }
+    });
+    logStatus(`Token usage: in=${usage.input_tokens || 0}, out=${usage.output_tokens || 0}, cache_create=${usage.cache_creation_input_tokens || 0}, cache_read=${usage.cache_read_input_tokens || 0}`);
+  }
+}
+
+// ====================
+// Claude Process
+// ====================
+
+function startClaude() {
+  const claudePath = findClaudePath();
+
+  // Claude CLI: --session-id and --resume are mutually exclusive
+  // - For new sessions: use --session-id <id>
+  // - For resume: use --resume <id>
+  let claudeArgs;
+  if (resumeSessionId) {
+    claudeArgs = ['--resume', sessionId];
+    logStatus(`Resuming Claude session: ${sessionId.slice(0, 8)}...`);
+  } else {
+    claudeArgs = ['--session-id', sessionId];
+    logStatus(`Starting new Claude session: ${sessionId.slice(0, 8)}...`);
+  }
+
+  // Choose PTY wrapper based on platform/flag
+  // - Windows: always use node-pty (Python PTY doesn't work)
+  // - Unix: use Python by default, node-pty with --node-pty flag
+  if (useNodePty) {
+    const nodeWrapperPath = path.join(__dirname, 'pty-wrapper-node.js');
+    logStatus('Using Node.js PTY wrapper');
+
+    // Check if wrapper file exists
+    if (!fs.existsSync(nodeWrapperPath)) {
+      log('Error: pty-wrapper-node.js not found.', colors.red);
+      log('Re-install vibe-cli or check installation.', colors.yellow);
+      process.exit(1);
+    }
+
+    // Check if node-pty is available
+    try {
+      require.resolve('node-pty');
+    } catch (err) {
+      log('Error: node-pty is not installed.', colors.red);
+      log('Install it with: npm install node-pty', colors.yellow);
+      if (os.platform() === 'win32') {
+        log('', colors.reset);
+        log('On Windows, you may also need:', colors.yellow);
+        log('  - Python 3.x', colors.dim);
+        log('  - Visual Studio Build Tools', colors.dim);
+        log('  npm install --global windows-build-tools', colors.dim);
+      }
+      process.exit(1);
+    }
+
+    claudeProcess = spawn('node', [nodeWrapperPath, claudePath, ...claudeArgs], {
+      cwd: process.cwd(),
+      env: { ...process.env, TERM: 'xterm-256color' },
+      stdio: ['pipe', 'inherit', 'inherit', 'pipe']  // FD 3 for prompt detection
+    });
+  } else {
+    // Use Python PTY wrapper (Unix only)
+    if (os.platform() === 'win32') {
+      log('Error: Python PTY wrapper does not work on Windows.', colors.red);
+      log('Please install node-pty: npm install node-pty', colors.yellow);
+      process.exit(1);
+    }
+
+    const pythonWrapperPath = path.join(__dirname, 'pty-wrapper.py');
+
+    // Check if wrapper file exists
+    if (!fs.existsSync(pythonWrapperPath)) {
+      log('Error: pty-wrapper.py not found.', colors.red);
+      log('Re-install vibe-cli or check installation.', colors.yellow);
+      process.exit(1);
+    }
+
+    claudeProcess = spawn('python3', [pythonWrapperPath, claudePath, ...claudeArgs], {
+      cwd: process.cwd(),
+      env: { ...process.env, TERM: 'xterm-256color' },
+      stdio: ['pipe', 'inherit', 'inherit', 'pipe']  // FD 3 for prompt detection
+    });
+  }
+
+  isRunning = true;
+
+  // Start watching session file
+  sessionFileWatcher = startSessionFileWatcher();
+
+  // Read permission prompts from FD 3 (captured by PTY wrapper)
+  let promptBuffer = '';
+  if (claudeProcess.stdio[3]) {
+    claudeProcess.stdio[3].on('data', (data) => {
+      promptBuffer += data.toString();
+      // Process complete JSON lines
+      const lines = promptBuffer.split('\n');
+      promptBuffer = lines.pop() || '';  // Keep incomplete line in buffer
+
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const prompt = JSON.parse(line);
+          if (prompt.type === 'permission_prompt') {
+            log(`🔔 Captured permission prompt from CLI`, colors.dim);
+            // Store for use when we see the corresponding tool_use
+            lastCapturedPrompt = prompt;
+          }
+        } catch (e) {
+          // Not valid JSON, skip
+        }
+      }
+    });
+  }
+
+  claudeProcess.on('exit', (code, signal) => {
+    isRunning = false;
+    logStatus(`Claude exited (code: ${code}, signal: ${signal})`);
+
+    if (sessionFileWatcher) {
+      sessionFileWatcher();
+      sessionFileWatcher = null;
+    }
+
+    sendToBridge({
+      type: 'session_ended',
+      exitCode: code,
+      signal
+    });
+
+    process.exit(code || 0);
+  });
+
+  claudeProcess.on('error', (err) => {
+    log(`Failed to start Claude: ${err.message}`, colors.yellow);
+    process.exit(1);
+  });
+}
+
+// ====================
+// Terminal Input
+// ====================
+
+let commandBuffer = '';
+let inCommandMode = false;
+
+function handleVibeCommand(command) {
+  const trimmed = command.trim();
+
+  if (trimmed.startsWith('/name ')) {
+    const newName = trimmed.slice(6).trim();
+    if (!newName) {
+      log('Usage: /name <session name>', colors.yellow);
+      return true;
+    }
+
+    // Update local session name
+    sessionName = newName;
+
+    // Send rename request to bridge
+    if (bridgeSocket && bridgeSocket.readyState === WebSocket.OPEN && isAuthenticated) {
+      bridgeSocket.send(JSON.stringify({
+        type: 'rename_session',
+        sessionId: sessionId,
+        name: newName
+      }));
+      log(`📝 Session renamed to: ${newName}`, colors.green);
+    } else {
+      log(`📝 Session name set to: ${newName} (not connected to bridge)`, colors.yellow);
+    }
+    return true;
+  }
+
+  if (trimmed === '/name') {
+    // Show current session name
+    const currentName = sessionName || path.basename(process.cwd());
+    log(`📝 Current session name: ${currentName}`, colors.cyan);
+    log('   To rename: /name <new name>', colors.dim);
+    return true;
+  }
+
+  // Not a recognized vibe command - forward to Claude
+  // This allows users to type paths like /usr/bin/bash
+  return false;
+}
+
+function setupTerminalInput() {
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+  }
+  process.stdin.resume();
+  process.stdin.on('data', (data) => {
+    // Debug: log what bytes the keyboard sends (only when not in command mode)
+    if (data.length <= 4 && !inCommandMode) {
+      logStatus(`Keyboard input: ${data.length} bytes, hex: ${data.toString('hex')}`);
+    }
+
+    const str = data.toString();
+
+    // Check for command mode
+    for (const char of str) {
+      const code = char.charCodeAt(0);
+
+      // Enter key (CR or LF)
+      if (code === 0x0d || code === 0x0a) {
+        if (inCommandMode) {
+          // Try to handle as vibe command
+          if (handleVibeCommand(commandBuffer)) {
+            // Command was handled, reset and don't forward
+            commandBuffer = '';
+            inCommandMode = false;
+            // Echo a newline to terminal
+            process.stdout.write('\n');
+            continue;
+          }
+          // Not a valid command, forward the buffered content + Enter
+          if (claudeProcess && isRunning && claudeProcess.stdin && claudeProcess.stdin.writable) {
+            claudeProcess.stdin.write(commandBuffer + '\r');
+          }
+          commandBuffer = '';
+          inCommandMode = false;
+          continue;
+        }
+      }
+
+      // Ctrl+C or Escape in command mode - cancel command
+      if ((code === 0x03 || code === 0x1b) && inCommandMode) {
+        // Clear the echoed text
+        for (let i = 0; i < commandBuffer.length; i++) {
+          process.stdout.write('\b \b');
+        }
+        commandBuffer = '';
+        inCommandMode = false;
+        if (code === 0x03) {
+          // Forward Ctrl+C to Claude if not in command mode
+          // (but we just exited, so do nothing)
+        }
+        continue;
+      }
+
+      // Backspace handling in command mode
+      if ((code === 0x7f || code === 0x08) && inCommandMode) {
+        if (commandBuffer.length > 0) {
+          commandBuffer = commandBuffer.slice(0, -1);
+          // Echo backspace to terminal
+          process.stdout.write('\b \b');
+        }
+        if (commandBuffer.length === 0) {
+          inCommandMode = false;
+        }
+        continue;
+      }
+
+      // Start of line and '/' character - enter command mode
+      if (char === '/' && commandBuffer.length === 0 && !inCommandMode) {
+        inCommandMode = true;
+        commandBuffer = '/';
+        // Echo to terminal
+        process.stdout.write('/');
+        continue;
+      }
+
+      // In command mode - buffer the character
+      if (inCommandMode) {
+        commandBuffer += char;
+        // Echo to terminal
+        process.stdout.write(char);
+        continue;
+      }
+
+      // Normal mode - forward to Claude
+      if (claudeProcess && isRunning && claudeProcess.stdin && claudeProcess.stdin.writable) {
+        claudeProcess.stdin.write(char);
+      }
+    }
+  });
+}
+
+// ====================
+// Shutdown
+// ====================
+
+function setupShutdown() {
+  const shutdown = () => {
+    if (isShuttingDown) return;
+    isShuttingDown = true;
+
+    log('\n');
+    logStatus('Shutting down...');
+
+    if (reconnectTimer) {
+      clearTimeout(reconnectTimer);
+    }
+
+    if (heartbeatTimer) {
+      clearInterval(heartbeatTimer);
+    }
+
+    if (bridgeSocket) {
+      try { bridgeSocket.close(); } catch {}
+    }
+
+    if (sessionFileWatcher) {
+      sessionFileWatcher();
+    }
+
+    if (claudeProcess && !claudeProcess.killed) {
+      try { claudeProcess.kill('SIGTERM'); } catch {}
+    }
+
+    setTimeout(() => process.exit(0), 2000);
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+  process.on('uncaughtException', (err) => {
+    logStatus(`Uncaught exception: ${err.message}`);
+    shutdown();
+  });
+}
+
+// ====================
+// Main
+// ====================
+
+function main() {
+  console.log('');
+  log('🎵 vibe-cli', colors.bright + colors.magenta);
+  log('══════════════════════════════════════', colors.dim);
+  log(`   Session:  ${sessionId.slice(0, 8)}...`, colors.dim);
+
+  if (agentUrl) {
+    log(`   Agent:    ${agentUrl}`, colors.dim);
+    log(`   Mode:     Managed (via local agent)`, colors.dim);
+  } else if (bridgeUrl) {
+    log(`   Bridge:   ${bridgeUrl}`, colors.dim);
+    log(`   Mode:     Cloud (via bridge server)`, colors.dim);
+    log(`   Auth:     ${authToken ? 'Token stored' : 'No token (dev mode)'}`, colors.dim);
+  } else {
+    log(`   Mode:     Local (no bridge - terminal only)`, colors.dim);
+  }
+
+  log(`   Terminal: ${process.cwd()}`, colors.dim);
+  log('══════════════════════════════════════', colors.dim);
+  console.log('');
+
+  setupShutdown();
+
+  if (agentUrl || bridgeUrl) {
+    connectToBridge();
+  }
+
+  startClaude();
+  setupTerminalInput();
+
+  // Send initial prompt after a short delay (let Claude start up)
+  if (initialPrompt) {
+    setTimeout(() => {
+      logStatus(`Sending initial prompt: ${initialPrompt}`);
+      sendToClaude(initialPrompt, 'initial');
+    }, 2000);
+  }
+}
+
+// Only start Claude if not in login mode
+if (!loginMode) {
+  main();
+}