minivibe 0.1.0 → 0.1.1

package/README.md

@@ -0,0 +1,180 @@
+# vibe-cli
+
+CLI wrapper for Claude Code with mobile remote control via MiniVibe.
+
+## Features
+
+- Remote control Claude Code from your iOS device
+- Session management with resume capability
+- Permission handling from mobile
+- Token usage tracking
+- Headless authentication for servers (EC2, etc.)
+
+## Installation
+
+```bash
+# Clone the repository
+git clone <repo-url>
+cd vibe-cli
+
+# Install dependencies
+npm install
+
+# Link globally (optional)
+npm link
+```
+
+### Global Installation (EC2/Servers)
+
+```bash
+# Install to /opt for all users
+sudo git clone <repo-url> /opt/neng
+cd /opt/neng/vibe-cli
+sudo npm install
+sudo npm link
+
+# Or add to PATH
+echo 'export PATH="/opt/neng/vibe-cli:$PATH"' | sudo tee /etc/profile.d/vibe.sh
+```
+
+## Authentication
+
+### Browser Login (Desktop)
+
+```bash
+vibe --login
+```
+
+Opens browser for Google sign-in. Token is saved to `~/.vibe/auth.json`.
+
+### Headless Login (Servers/EC2)
+
+```bash
+vibe --login --headless
+```
+
+Displays a device code. Visit the URL on any device to authenticate.
+
+### Manual Token
+
+```bash
+vibe --token <firebase-token>
+```
+
+Get token from MiniVibe iOS app Settings > Copy Token for CLI.
+
+## Usage
+
+### Basic Usage
+
+```bash
+# Interactive session
+vibe
+
+# With initial prompt
+vibe "Fix the bug in main.js"
+
+# Connect to bridge server
+vibe --bridge wss://ws.neng.ai
+
+# With prompt and bridge
+vibe --bridge wss://ws.neng.ai "Deploy the application"
+```
+
+### Session Management
+
+```bash
+# Name your session (visible in iOS app)
+vibe --name "Backend Refactor" --bridge wss://ws.neng.ai
+
+# Resume a previous session
+vibe --resume <session-id> --bridge wss://ws.neng.ai
+```
+
+### Skip Permissions Mode
+
+For automated/headless environments where you trust the execution context:
+
+```bash
+vibe --dangerously-skip-permissions --bridge wss://ws.neng.ai
+```
+
+**Warning:** This mode auto-approves ALL tool executions (commands, file writes, etc.) without prompting. Only use in trusted/sandboxed environments.
+
+### Local Agent Mode
+
+Connect via a local vibe-agent for managed sessions:
+
+```bash
+# Auto-discover agent
+vibe --agent
+
+# Specify agent URL
+vibe --agent ws://localhost:9999
+```
+
+## Options
+
+| Option | Description |
+|--------|-------------|
+| `--bridge <url>` | Connect to bridge server (e.g., `wss://ws.neng.ai`) |
+| `--agent [url]` | Connect via local vibe-agent |
+| `--name <name>` | Name this session (shown in mobile app) |
+| `--resume <id>` | Resume a previous session |
+| `--login` | Sign in with Google (browser) |
+| `--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 |
+| `--node-pty` | Use Node.js PTY wrapper (required for Windows) |
+| `--help, -h` | Show help message |
+
+## In-Session Commands
+
+| Command | Description |
+|---------|-------------|
+| `/name <name>` | Rename the current session |
+
+## Requirements
+
+- Node.js >= 18.0.0
+- Claude Code CLI installed and in PATH
+- Python 3 (for Unix PTY wrapper) or node-pty (for Windows)
+
+## Platform Notes
+
+### macOS/Linux
+
+Uses Python PTY wrapper by default. Requires `python3`.
+
+### Windows
+
+Requires `node-pty`:
+
+```bash
+npm install node-pty
+```
+
+May also need Visual Studio Build Tools and Python for native compilation.
+
+## Files
+
+- `~/.vibe/auth.json` - Stored authentication (token + refresh token)
+- `~/.vibe/token` - Legacy token file (backwards compatibility)
+
+## Architecture
+
+```
+┌─────────────┐     ┌─────────────┐     ┌─────────────┐
+│  MiniVibe   │────▶│   Bridge    │◀────│  vibe-cli   │
+│  iOS App    │     │   Server    │     │  + Claude   │
+└─────────────┘     └─────────────┘     └─────────────┘
+```
+
+1. **vibe-cli** wraps Claude Code and connects to the bridge server
+2. **Bridge server** relays messages between mobile and CLI
+3. **MiniVibe iOS** provides remote control, permission approval, and session monitoring
+
+## License
+
+MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minivibe",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "CLI wrapper for Claude Code with mobile remote control",
   "author": "neng.ai",
   "homepage": "https://github.com/python3isfun/neng",

package/vibe.js

@@ -382,6 +382,7 @@ let authToken = null;
 let headlessMode = false;
 let sessionName = null;
 let useNodePty = os.platform() === 'win32';  // Auto-detect Windows, can be overridden
+let skipPermissions = false;  // --dangerously-skip-permissions mode
 
 for (let i = 0; i < args.length; i++) {
   if (args[i] === '--help' || args[i] === '-h') {
@@ -407,6 +408,7 @@ Options:
   --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)
+  --dangerously-skip-permissions   Run Claude without permission prompts (use with caution!)
   --help, -h       Show this help message
 
 In-Session Commands:
@@ -466,6 +468,8 @@ Examples:
     process.exit(0);
   } else if (args[i] === '--node-pty') {
     useNodePty = true;
+  } else if (args[i] === '--dangerously-skip-permissions') {
+    skipPermissions = true;
   } else if (!args[i].startsWith('--')) {
     initialPrompt = args[i];
   }
@@ -534,12 +538,50 @@ function logStatus(msg) {
 
 // Get Claude session file path
 // Claude uses path with '/' replaced by '-' (not base64)
+// But the exact format may vary - we try multiple strategies
 function getSessionFilePath() {
-  const projectPathHash = process.cwd().replace(/\//g, '-');
-  const claudeDir = path.join(os.homedir(), '.claude', 'projects', projectPathHash);
-  return path.join(claudeDir, `${sessionId}.jsonl`);
+  const cwd = process.cwd();
+  const projectsDir = path.join(os.homedir(), '.claude', 'projects');
+
+  // Strategy 1: Direct replacement (e.g., /home/ubuntu -> -home-ubuntu)
+  const directHash = cwd.replace(/\//g, '-');
+
+  // Strategy 2: Without leading dash (e.g., home-ubuntu)
+  const noLeadingDash = directHash.replace(/^-/, '');
+
+  // Strategy 3: URL-safe encoding variations
+  const candidates = [directHash, noLeadingDash];
+
+  // Try to find existing directory that matches
+  if (fs.existsSync(projectsDir)) {
+    for (const candidate of candidates) {
+      const candidateDir = path.join(projectsDir, candidate);
+      if (fs.existsSync(candidateDir)) {
+        return path.join(candidateDir, `${sessionId}.jsonl`);
+      }
+    }
+
+    // Scan for session file in any project directory
+    try {
+      const dirs = fs.readdirSync(projectsDir);
+      for (const dir of dirs) {
+        const sessionFile = path.join(projectsDir, dir, `${sessionId}.jsonl`);
+        if (fs.existsSync(sessionFile)) {
+          return sessionFile;
+        }
+      }
+    } catch (err) {
+      // Ignore scan errors
+    }
+  }
+
+  // Fall back to direct hash (will be created by Claude)
+  return path.join(projectsDir, directHash, `${sessionId}.jsonl`);
 }
 
+// Cache for discovered session file path
+let discoveredSessionFile = null;
+
 // Get local IP
 function getLocalIP() {
   const interfaces = os.networkInterfaces();
@@ -910,28 +952,41 @@ function sendToBridge(data) {
 // ====================
 
 function startSessionFileWatcher() {
-  const sessionFile = getSessionFilePath();
-  logStatus(`Watching session file: ${sessionFile}`);
+  let sessionFile = getSessionFilePath();
+  logStatus(`Watching for 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;
+  let lastNotFoundLog = 0;
+  let fileFound = false;
+
+  // Function to scan for session file in all project directories
+  function scanForSessionFile() {
+    if (!fs.existsSync(projectsDir)) return null;
+
+    try {
+      const dirs = fs.readdirSync(projectsDir);
+      // Limit scan to 50 directories to avoid slowdown
+      const dirsToScan = dirs.slice(0, 50);
+      for (const dir of dirsToScan) {
+        const fullDir = path.join(projectsDir, dir);
+        try {
+          if (fs.statSync(fullDir).isDirectory()) {
+            const candidateFile = path.join(fullDir, `${sessionId}.jsonl`);
+            if (fs.existsSync(candidateFile)) {
+              return candidateFile;
+            }
+          }
+        } catch (e) {
+          // Skip inaccessible directories
         }
       }
+    } catch (err) {
+      // Ignore scan errors
     }
+    return null;
   }
 
-  let fileCheckCount = 0;
   const pollInterval = setInterval(() => {
     if (!isRunning || isShuttingDown) {
       clearInterval(pollInterval);
@@ -939,15 +994,46 @@ function startSessionFileWatcher() {
     }
 
     try {
-      if (!fs.existsSync(sessionFile)) {
-        // Log occasionally that file doesn't exist yet
-        if (fileCheckCount++ % 20 === 0) {
-          logStatus(`Session file not found yet: ${sessionFile}`);
+      // If file not found yet, try to discover it
+      if (!fileFound) {
+        if (!fs.existsSync(sessionFile)) {
+          // Try scanning for it every 5 seconds
+          fileCheckCount++;
+          if (fileCheckCount % 10 === 0) {
+            const discovered = scanForSessionFile();
+            if (discovered) {
+              sessionFile = discovered;
+              fileFound = true;
+              lastFileSize = 0;  // Reset to read from beginning
+              log(`📁 Found session file: ${sessionFile}`, colors.dim);
+            } else {
+              // Only log "not found" every 30 seconds to reduce spam
+              const now = Date.now();
+              if (now - lastNotFoundLog > 30000) {
+                logStatus(`Waiting for session file... (${Math.floor(fileCheckCount / 2)}s)`);
+                lastNotFoundLog = now;
+              }
+            }
+          }
+          return;
         }
+        fileFound = true;
+        lastFileSize = 0;  // Reset to read from beginning
+        log(`📁 Session file ready: ${sessionFile}`, colors.dim);
+      }
+
+      if (!fs.existsSync(sessionFile)) {
         return;
       }
 
       const stats = fs.statSync(sessionFile);
+
+      // Handle file being recreated (size shrunk)
+      if (stats.size < lastFileSize) {
+        logStatus(`Session file was recreated, re-reading from start`);
+        lastFileSize = 0;
+      }
+
       if (stats.size > lastFileSize) {
         logStatus(`Session file changed: ${lastFileSize} -> ${stats.size} bytes`);
         const fd = fs.openSync(sessionFile, 'r');
@@ -1277,6 +1363,12 @@ function startClaude() {
     logStatus(`Starting new Claude session: ${sessionId.slice(0, 8)}...`);
   }
 
+  // Add --dangerously-skip-permissions if requested
+  if (skipPermissions) {
+    claudeArgs.push('--dangerously-skip-permissions');
+    log('⚠️  Running in skip-permissions mode (no prompts)', colors.yellow);
+  }
+
   // 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
@@ -1593,6 +1685,10 @@ function main() {
     log(`   Mode:     Local (no bridge - terminal only)`, colors.dim);
   }
 
+  if (skipPermissions) {
+    log(`   Perms:    SKIPPED (dangerously-skip-permissions)`, colors.yellow);
+  }
+
   log(`   Terminal: ${process.cwd()}`, colors.dim);
   log('══════════════════════════════════════', colors.dim);
   console.log('');