minivibe 0.1.3 → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-2025 MiniVibe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -11,6 +11,7 @@ CLI wrapper for Claude Code with mobile remote control via MiniVibe iOS app.
 - Token usage tracking
 - Headless authentication for servers (EC2, etc.)
 - Skip permissions mode for automation
+- **End-to-end encryption** - Optional E2E encryption so bridge server cannot read message content
 
 ## Quick Start
 
@@ -23,15 +24,13 @@ vibe --login              # Desktop (opens browser)
 vibe --login --headless   # Server/EC2 (device code)
 
 # Option 1: Direct bridge connection
-vibe --bridge wss://ws.neng.ai
+vibe --bridge wss://ws.minivibeapp.com
 
 # Option 2: Agent mode (recommended for servers)
-vibe-agent --bridge wss://ws.neng.ai &   # Start agent
+vibe-agent --bridge wss://ws.minivibeapp.com &   # Start agent
 vibe --agent                              # Create sessions
 ```
 
-See [GETTING_STARTED.md](GETTING_STARTED.md) for detailed setup instructions.
-
 ## Installation
 
 ### From npm (Recommended)
@@ -47,8 +46,8 @@ This installs two commands:
 ### From Source
 
 ```bash
-git clone https://github.com/python3isfun/neng.git
-cd neng/vibe-cli
+git clone https://github.com/minivibeapp/minivibe.git
+cd minivibe
 npm install
 npm link
 ```
@@ -86,8 +85,8 @@ Get token from MiniVibe iOS app: Settings > Copy Token for CLI.
 Connect directly to the bridge server:
 
 ```bash
-vibe --bridge wss://ws.neng.ai
-vibe --bridge wss://ws.neng.ai "Fix the bug in main.js"
+vibe --bridge wss://ws.minivibeapp.com
+vibe --bridge wss://ws.minivibeapp.com "Fix the bug in main.js"
 ```
 
 ### Agent Mode (Recommended for Servers)
@@ -96,7 +95,7 @@ Use a local agent to manage sessions:
 
 ```bash
 # Terminal 1: Start the agent (runs continuously)
-vibe-agent --bridge wss://ws.neng.ai
+vibe-agent --bridge wss://ws.minivibeapp.com
 
 # Terminal 2+: Create sessions via agent
 vibe --agent
@@ -128,12 +127,16 @@ vibe "Explain this code"      # With prompt
 | `--bridge <url>` | Connect to bridge server |
 | `--agent [url]` | Connect via local vibe-agent (default: auto-discover) |
 | `--name <name>` | Name this session (shown in mobile app) |
-| `--resume <id>` | Resume a previous session |
+| `--resume <id>` | Resume a previous session (auto-detects directory) |
+| `--attach <id>` | Attach to running session via local agent |
+| `--remote <id>` | Remote control session via bridge (no local Claude needed) |
+| `--list` | List running sessions on local agent |
 | `--login` | Sign in with Google |
 | `--headless` | Use device code flow for headless environments |
 | `--token <token>` | Set Firebase auth token manually |
 | `--logout` | Remove stored auth token |
 | `--dangerously-skip-permissions` | Auto-approve all tool executions |
+| `--e2e` | Enable end-to-end encryption (auto key exchange with iOS) |
 | `--node-pty` | Use Node.js PTY wrapper (required for Windows) |
 | `--help, -h` | Show help message |
 
@@ -142,29 +145,59 @@ vibe "Explain this code"      # With prompt
 | Option | Description |
 |--------|-------------|
 | `--bridge <url>` | Bridge server URL (required) |
-| `--port <port>` | Local WebSocket port (default: 9999) |
+| `--login` | Start device code login flow |
+| `--token <token>` | Use specific Firebase token |
+| `--name <name>` | Set host display name |
+| `--status` | Show current status and exit |
 | `--help, -h` | Show help message |
 
-## In-Session Commands
-
-| Command | Description |
-|---------|-------------|
-| `/name <name>` | Rename the current session |
-| `/path` + Enter | If not a vibe command, forwards to Claude |
-| `Escape` | Cancel command mode, forward to Claude |
-| `Ctrl+C` | Cancel command mode, forward to Claude |
-
 ## Skip Permissions Mode
 
 For automated/headless environments where you trust the execution context:
 
 ```bash
-vibe --dangerously-skip-permissions --bridge wss://ws.neng.ai
+vibe --dangerously-skip-permissions --bridge wss://ws.minivibeapp.com
 vibe --dangerously-skip-permissions --agent
 ```
 
 **Warning:** This mode auto-approves ALL tool executions (commands, file writes, etc.) without prompting. Only use in trusted/sandboxed environments.
 
+## End-to-End Encryption
+
+Enable E2E encryption to ensure the bridge server cannot read your message content:
+
+```bash
+# Start with E2E encryption enabled
+vibe --e2e --bridge wss://ws.minivibeapp.com
+```
+
+Key exchange happens automatically when both CLI and iOS connect to the bridge:
+
+1. Enable E2E in MiniVibe iOS app: **Settings > Security > E2E Encryption**
+2. Start CLI with `--e2e` flag
+3. Both sides exchange public keys automatically on connect
+4. Encryption is established - no QR scanning needed!
+
+### How It Works
+
+- Uses **X25519** key exchange (same as Signal, WhatsApp)
+- Messages encrypted with **AES-256-GCM**
+- Keys derived using **HKDF-SHA256**
+- Bridge server sees message routing info but cannot read content
+
+### Key Storage
+
+| Location | Description |
+|----------|-------------|
+| `~/.vibe/e2e-keys.json` | CLI keypair and peer info |
+| iOS Keychain | iOS keypair and peer info |
+
+### Security Notes
+
+- E2E is optional and backward compatible
+- Once paired, encryption persists across sessions
+- To re-pair: delete `~/.vibe/e2e-keys.json` and reset in iOS Settings
+
 ## Architecture
 
 ```
@@ -206,6 +239,7 @@ May also need Visual Studio Build Tools and Python for native compilation.
 |------|-------------|
 | `~/.vibe/auth.json` | Stored authentication (token + refresh token) |
 | `~/.vibe/token` | Legacy token file |
+| `~/.vibe/e2e-keys.json` | E2E encryption keypair and peer info |
 | `~/.vibe-agent/port` | Agent port file for auto-discovery |
 
 ## License

package/agent/agent.js

@@ -9,8 +9,8 @@
  * - Stop running sessions
  *
  * Usage:
- *   vibe-agent --bridge wss://ws.neng.ai --token <firebase-token>
- *   vibe-agent --login --bridge wss://ws.neng.ai
+ *   vibe-agent --bridge wss://ws.minivibeapp.com --token <firebase-token>
+ *   vibe-agent --login --bridge wss://ws.minivibeapp.com
  */
 
 const { spawn, execSync } = require('child_process');
@@ -28,11 +28,13 @@ const os = require('os');
 const CONFIG_DIR = path.join(os.homedir(), '.vibe-agent');
 const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
 const AUTH_FILE = path.join(CONFIG_DIR, 'auth.json');
+const SESSION_HISTORY_FILE = path.join(CONFIG_DIR, 'session-history.json');
 
 const RECONNECT_DELAY_MS = 5000;
 const HEARTBEAT_INTERVAL_MS = 30000;
 const LOCAL_SERVER_PORT = 9999;
 const PORT_FILE = path.join(os.homedir(), '.vibe-agent', 'port');
+const MAX_SESSION_HISTORY_AGE_DAYS = 30;
 
 // Colors for terminal output
 const colors = {
@@ -166,9 +168,53 @@ let heartbeatTimer = null;
 // Track running sessions: sessionId -> { process, path, name, localWs }
 const runningSessions = new Map();
 
+// Track session history for resume: sessionId -> { path, name, endedAt }
+// Kept even after session ends so we can resume with correct path
+// Persisted to disk so it survives agent restarts
+const MAX_SESSION_HISTORY = 100;
+const sessionHistory = loadSessionHistoryFromDisk();
+
 // Track sessions being intentionally stopped (to distinguish from unexpected disconnects)
 const stoppingSessions = new Set();
 
+// Load session history from disk on startup
+function loadSessionHistoryFromDisk() {
+  try {
+    if (fs.existsSync(SESSION_HISTORY_FILE)) {
+      const data = JSON.parse(fs.readFileSync(SESSION_HISTORY_FILE, 'utf8'));
+      const map = new Map();
+      const cutoffTime = Date.now() - (MAX_SESSION_HISTORY_AGE_DAYS * 24 * 60 * 60 * 1000);
+
+      // Filter out entries older than MAX_SESSION_HISTORY_AGE_DAYS
+      for (const [sessionId, info] of Object.entries(data)) {
+        if (new Date(info.endedAt).getTime() >= cutoffTime) {
+          map.set(sessionId, info);
+        }
+      }
+
+      console.log(`[vibe-agent] Loaded ${map.size} sessions from history`);
+      return map;
+    }
+  } catch (err) {
+    console.log(`[vibe-agent] Failed to load session history: ${err.message}`);
+  }
+  return new Map();
+}
+
+// Save session history to disk
+function saveSessionHistoryToDisk() {
+  try {
+    // Ensure config directory exists
+    if (!fs.existsSync(CONFIG_DIR)) {
+      fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    const data = Object.fromEntries(sessionHistory);
+    fs.writeFileSync(SESSION_HISTORY_FILE, JSON.stringify(data, null, 2));
+  } catch (err) {
+    console.log(`[vibe-agent] Failed to save session history: ${err.message}`);
+  }
+}
+
 // Local server for vibe-cli connections
 let localServer = null;
 // Track local CLI connections: ws -> { sessionId, authenticated }
@@ -310,18 +356,48 @@ function startLocalServer() {
         const clientInfo = localClients.get(clientWs);
         if (clientInfo?.sessionId) {
           const sessionId = clientInfo.sessionId;
-          const wasIntentionalStop = stoppingSessions.has(sessionId);
-          stoppingSessions.delete(sessionId);  // Clean up
-
-          log(`Local session ${sessionId.slice(0, 8)} ${wasIntentionalStop ? 'stopped' : 'disconnected'}`, colors.dim);
-          runningSessions.delete(sessionId);
-          // Notify bridge
-          send({
-            type: 'agent_session_ended',
-            sessionId: sessionId,
-            exitCode: 0,
-            reason: wasIntentionalStop ? 'stopped_by_user' : 'disconnected'
-          });
+
+          // Check if this is an attached client (not the session owner)
+          if (clientInfo.isAttached) {
+            const session = runningSessions.get(sessionId);
+            if (session?.attachedClients) {
+              session.attachedClients.delete(clientWs);
+              log(`Attached client disconnected from session ${sessionId.slice(0, 8)}`, colors.dim);
+            }
+          } else {
+            // This is the session owner - end the session
+            const wasIntentionalStop = stoppingSessions.has(sessionId);
+            stoppingSessions.delete(sessionId);  // Clean up
+
+            log(`Local session ${sessionId.slice(0, 8)} ${wasIntentionalStop ? 'stopped' : 'disconnected'}`, colors.dim);
+            // Save to history before deleting for resume capability
+            const session = runningSessions.get(sessionId);
+            if (session) {
+              saveSessionHistory(sessionId, session.path, session.name);
+              // Notify attached clients that session ended
+              if (session.attachedClients) {
+                for (const attachedWs of session.attachedClients) {
+                  try {
+                    attachedWs.send(JSON.stringify({
+                      type: 'session_ended',
+                      sessionId,
+                      reason: wasIntentionalStop ? 'stopped_by_user' : 'disconnected'
+                    }));
+                  } catch (err) {
+                    // Ignore
+                  }
+                }
+              }
+            }
+            runningSessions.delete(sessionId);
+            // Notify bridge
+            send({
+              type: 'agent_session_ended',
+              sessionId: sessionId,
+              exitCode: 0,
+              reason: wasIntentionalStop ? 'stopped_by_user' : 'disconnected'
+            });
+          }
         }
         localClients.delete(clientWs);
       });
@@ -385,7 +461,8 @@ function handleLocalMessage(clientWs, msg) {
         path: msg.path || process.cwd(),
         name: msg.name || path.basename(msg.path || process.cwd()),
         startedAt: new Date().toISOString(),
-        managed: true  // Indicates connected via local server, not spawned
+        managed: true,  // Indicates connected via local server, not spawned
+        attachedClients: new Set()  // Track attached terminal clients
       });
 
       log(`Local session registered: ${sessionId.slice(0, 8)} (${msg.name || msg.path})`, colors.green);
@@ -411,13 +488,135 @@ function handleLocalMessage(clientWs, msg) {
       }
       break;
 
-    // All other messages: relay to bridge
+    // Attach to existing session (terminal mirroring)
+    case 'attach_session':
+      const attachSessionId = msg.sessionId;
+
+      // Validate sessionId
+      if (!attachSessionId) {
+        clientWs.send(JSON.stringify({
+          type: 'attach_error',
+          error: 'sessionId is required'
+        }));
+        break;
+      }
+
+      // Check if session is stopping
+      if (stoppingSessions.has(attachSessionId)) {
+        log(`Attach failed: session ${attachSessionId.slice(0, 8)} is stopping`, colors.yellow);
+        clientWs.send(JSON.stringify({
+          type: 'attach_error',
+          sessionId: attachSessionId,
+          error: 'Session is currently stopping. Cannot attach.'
+        }));
+        break;
+      }
+
+      const session = runningSessions.get(attachSessionId);
+
+      if (!session) {
+        log(`Attach failed: session ${attachSessionId.slice(0, 8)} not found`, colors.red);
+        clientWs.send(JSON.stringify({
+          type: 'attach_error',
+          sessionId: attachSessionId,
+          error: 'Session not found. It may have ended or is running on a different agent.'
+        }));
+        break;
+      }
+
+      // Mark this client as attached to the session
+      clientInfo.sessionId = attachSessionId;
+      clientInfo.isAttached = true;
+
+      // Add to session's attached clients
+      if (!session.attachedClients) {
+        session.attachedClients = new Set();
+      }
+      session.attachedClients.add(clientWs);
+
+      log(`Client attached to session ${attachSessionId.slice(0, 8)} (${session.attachedClients.size} attached)`, colors.cyan);
+
+      clientWs.send(JSON.stringify({
+        type: 'attach_success',
+        sessionId: attachSessionId,
+        name: session.name,
+        path: session.path
+      }));
+      break;
+
+    // List running sessions
+    case 'list_sessions':
+      const sessionsList = [];
+      for (const [sessionId, session] of runningSessions) {
+        // Determine source: spawned sessions have 'process', managed have 'localWs'
+        // Sessions started from iOS come via bridge with spawn, sessions from CLI use --agent
+        const source = session.process ? 'ios' : 'cli';
+        sessionsList.push({
+          sessionId,
+          name: session.name,
+          path: session.path,
+          startedAt: session.startedAt,
+          source
+        });
+      }
+      clientWs.send(JSON.stringify({
+        type: 'sessions_list',
+        sessions: sessionsList
+      }));
+      log(`Listed ${sessionsList.length} running sessions`, colors.dim);
+      break;
+
+    // Terminal input from attached client - forward to session provider
+    case 'terminal_input':
+      const targetSession = runningSessions.get(clientInfo.sessionId);
+      if (targetSession && targetSession.localWs && clientInfo.isAttached) {
+        // Forward input to the session's provider (the original vibe-cli)
+        try {
+          targetSession.localWs.send(JSON.stringify({
+            type: 'terminal_input',
+            data: msg.data
+          }));
+        } catch (err) {
+          log(`Failed to forward terminal input: ${err.message}`, colors.red);
+        }
+      }
+      break;
+
+    // Terminal output from session provider - relay to attached clients
+    case 'terminal_output':
+      const outputSession = runningSessions.get(clientInfo.sessionId);
+      if (outputSession?.attachedClients) {
+        for (const attachedWs of outputSession.attachedClients) {
+          try {
+            attachedWs.send(JSON.stringify(msg));
+          } catch (err) {
+            // Ignore send errors
+          }
+        }
+      }
+      break;
+
+    // All other messages: relay to bridge and also to attached clients
     default:
       // Add sessionId if not present
       if (!msg.sessionId && clientInfo.sessionId) {
         msg.sessionId = clientInfo.sessionId;
       }
 
+      // Relay certain message types to attached clients for terminal mirroring
+      if (['claude_message', 'permission_request', 'session_status'].includes(msg.type)) {
+        const msgSession = runningSessions.get(clientInfo.sessionId);
+        if (msgSession?.attachedClients) {
+          for (const attachedWs of msgSession.attachedClients) {
+            try {
+              attachedWs.send(JSON.stringify(msg));
+            } catch (err) {
+              // Ignore send errors
+            }
+          }
+        }
+      }
+
       if (send(msg)) {
         // Message relayed successfully
       } else {
@@ -613,6 +812,32 @@ function findVibeCli() {
   }
 }
 
+// Save session info to history for resume capability
+function saveSessionHistory(sessionId, sessionPath, sessionName) {
+  // Limit history size
+  if (sessionHistory.size >= MAX_SESSION_HISTORY) {
+    // Delete oldest entry
+    const oldest = sessionHistory.keys().next().value;
+    sessionHistory.delete(oldest);
+  }
+
+  sessionHistory.set(sessionId, {
+    path: sessionPath,
+    name: sessionName,
+    endedAt: new Date().toISOString()
+  });
+
+  // Persist to disk
+  saveSessionHistoryToDisk();
+
+  log(`Saved session ${sessionId.slice(0, 8)} to history (path: ${sessionPath})`, colors.dim);
+}
+
+// Get session info from history
+function getSessionFromHistory(sessionId) {
+  return sessionHistory.get(sessionId);
+}
+
 function handleStartSession(msg) {
   const { sessionId, path: projectPath, name, prompt, requestId } = msg;
 
@@ -675,7 +900,8 @@ function handleStartSession(msg) {
       process: proc,
       path: cwd,
       name: name || path.basename(cwd),
-      startedAt: new Date().toISOString()
+      startedAt: new Date().toISOString(),
+      attachedClients: new Set()  // Support terminal attachment
     });
 
     proc.stdout.on('data', (data) => {
@@ -695,6 +921,11 @@ function handleStartSession(msg) {
 
     proc.on('exit', (code) => {
       log(`Session ${newSessionId.slice(0, 8)} exited with code ${code}`, colors.dim);
+      // Save to history before deleting for resume capability
+      const session = runningSessions.get(newSessionId);
+      if (session) {
+        saveSessionHistory(newSessionId, session.path, session.name);
+      }
       runningSessions.delete(newSessionId);
 
       send({
@@ -706,6 +937,11 @@ function handleStartSession(msg) {
 
     proc.on('error', (err) => {
       log(`Session error: ${err.message}`, colors.red);
+      // Save to history before deleting for resume capability
+      const session = runningSessions.get(newSessionId);
+      if (session) {
+        saveSessionHistory(newSessionId, session.path, session.name);
+      }
       runningSessions.delete(newSessionId);
 
       send({
@@ -741,6 +977,17 @@ function handleStartSession(msg) {
 function handleResumeSession(msg) {
   const { sessionId, path: projectPath, name, requestId } = msg;
 
+  // Validate sessionId is present
+  if (!sessionId) {
+    log('Resume session called without sessionId', colors.red);
+    send({
+      type: 'agent_session_error',
+      requestId,
+      error: 'sessionId is required to resume a session'
+    });
+    return;
+  }
+
   log(`Resuming session: ${sessionId.slice(0, 8)}`, colors.cyan);
 
   // Check if already running
@@ -755,6 +1002,18 @@ function handleResumeSession(msg) {
     return;
   }
 
+  // Check if session is currently being stopped
+  if (stoppingSessions.has(sessionId)) {
+    log('Session is currently stopping', colors.yellow);
+    send({
+      type: 'agent_session_error',
+      requestId,
+      sessionId,
+      error: 'Session is currently stopping. Please wait a moment and try again.'
+    });
+    return;
+  }
+
   const vibeCli = findVibeCli();
   if (!vibeCli) {
     log('vibe-cli not found!', colors.red);
@@ -770,12 +1029,37 @@ function handleResumeSession(msg) {
   // Build args with --resume - use --agent to connect via local server
   const args = ['--agent', `ws://localhost:${LOCAL_SERVER_PORT}`, '--resume', sessionId];
 
-  if (name) {
-    args.push('--name', name);
+  // Try to get session info from history if path not provided
+  let effectivePath = projectPath;
+  let effectiveName = name;
+
+  if (!effectivePath) {
+    const historyEntry = getSessionFromHistory(sessionId);
+    if (historyEntry) {
+      effectivePath = historyEntry.path;
+      effectiveName = effectiveName || historyEntry.name;
+      log(`Using path from session history: ${effectivePath}`, colors.dim);
+    }
+  }
+
+  // Don't silently fall back to home directory - require a valid path
+  if (!effectivePath) {
+    log(`Cannot resume session ${sessionId.slice(0, 8)}: path unknown`, colors.red);
+    send({
+      type: 'agent_session_error',
+      requestId,
+      sessionId,
+      error: 'Cannot resume session: working directory path unknown. The session may have been created before path tracking was enabled, or the agent was restarted.'
+    });
+    return;
+  }
+
+  if (effectiveName) {
+    args.push('--name', effectiveName);
   }
 
   // Spawn vibe-cli with resume - expand ~ to home directory
-  let cwd = projectPath || os.homedir();
+  let cwd = effectivePath;
   if (cwd.startsWith('~')) {
     cwd = cwd.replace(/^~/, os.homedir());
   }
@@ -804,8 +1088,9 @@ function handleResumeSession(msg) {
     runningSessions.set(sessionId, {
       process: proc,
       path: cwd,
-      name: name || path.basename(cwd),
-      startedAt: new Date().toISOString()
+      name: effectiveName || path.basename(cwd),
+      startedAt: new Date().toISOString(),
+      attachedClients: new Set()  // Support terminal attachment
     });
 
     proc.stdout.on('data', (data) => {
@@ -824,6 +1109,11 @@ function handleResumeSession(msg) {
 
     proc.on('exit', (code) => {
       log(`Session ${sessionId.slice(0, 8)} exited with code ${code}`, colors.dim);
+      // Save to history before deleting for resume capability
+      const session = runningSessions.get(sessionId);
+      if (session) {
+        saveSessionHistory(sessionId, session.path, session.name);
+      }
       runningSessions.delete(sessionId);
 
       send({
@@ -835,6 +1125,11 @@ function handleResumeSession(msg) {
 
     proc.on('error', (err) => {
       log(`Session error: ${err.message}`, colors.red);
+      // Save to history before deleting for resume capability
+      const session = runningSessions.get(sessionId);
+      if (session) {
+        saveSessionHistory(sessionId, session.path, session.name);
+      }
       runningSessions.delete(sessionId);
 
       send({
@@ -851,7 +1146,7 @@ function handleResumeSession(msg) {
       requestId,
       sessionId,
       path: cwd,
-      name: name || path.basename(cwd)
+      name: effectiveName || path.basename(cwd)
     });
 
     log(`Session resumed: ${sessionId.slice(0, 8)}`, colors.green);
@@ -920,6 +1215,10 @@ function handleStopSession(msg) {
         } catch (err) {
           // Already closed
         }
+        // Cleanup stoppingSessions as backup in case websocket close event doesn't fire
+        setTimeout(() => {
+          stoppingSessions.delete(sessionId);
+        }, 5000);
       }, 100);
       runningSessions.delete(sessionId);
     }
@@ -1025,7 +1324,7 @@ ${colors.bold}Usage:${colors.reset}
   vibe-agent --status                    Show agent status
 
 ${colors.bold}Options:${colors.reset}
-  --bridge <url>    Bridge server URL (wss://ws.neng.ai)
+  --bridge <url>    Bridge server URL (wss://ws.minivibeapp.com)
   --login           Start device code login flow
   --token <token>   Use specific Firebase token
   --name <name>     Set host display name
@@ -1034,13 +1333,13 @@ ${colors.bold}Options:${colors.reset}
 
 ${colors.bold}Examples:${colors.reset}
   # Login (first time)
-  vibe-agent --login --bridge wss://ws.neng.ai
+  vibe-agent --login --bridge wss://ws.minivibeapp.com
 
   # Start agent daemon
-  vibe-agent --bridge wss://ws.neng.ai
+  vibe-agent --bridge wss://ws.minivibeapp.com
 
   # Start with custom host name
-  vibe-agent --bridge wss://ws.neng.ai --name "AWS Dev Server"
+  vibe-agent --bridge wss://ws.minivibeapp.com --name "AWS Dev Server"
 `);
 }
 
@@ -1141,7 +1440,7 @@ async function main() {
 
   // Validate requirements
   if (!bridgeUrl) {
-    log('No bridge URL. Run: vibe-agent --bridge wss://ws.neng.ai', colors.red);
+    log('No bridge URL. Run: vibe-agent --bridge wss://ws.minivibeapp.com', colors.red);
     process.exit(1);
   }