claude-code-remote-pilot 0.5.6 → 0.5.9

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.5.7 — 2026-05-06
+
+### Fixed
+- **Running status now takes precedence over stale limit text**: watcher checks recent running markers before limit window matching, preventing false re-entry into `limit` when old limit lines remain in scrollback.
+
+---
+
 ## 0.5.5 — 2026-05-06
 
 ### Fixed

package/bin/claude-pilot.js

@@ -8,6 +8,7 @@ const readline = require('readline');
 const SessionManager = require('../lib/SessionManager');
 const WebServer = require('../lib/WebServer');
 const config = require('../lib/config');
+const notifier = require('../lib/notifier');
 
 // ─── dependency checks ────────────────────────────────────────────────────────
 
@@ -33,6 +34,13 @@ function tmuxInstallCmd() {
   return 'sudo apt-get install -y tmux';
 }
 
+function cloudflaredInstallCmd() {
+  const p = detectPlatform();
+  if (p === 'macos') return 'brew install cloudflare/cloudflare/cloudflared';
+  if (p === 'arch') return 'yay -S cloudflared';
+  return 'curl -L https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64 -o /usr/local/bin/cloudflared && chmod +x /usr/local/bin/cloudflared';
+}
+
 function isYes(answer) { return answer === '' || answer === 'y' || answer === 'yes'; }
 function isNo(answer)  { return answer === '' || answer === 'n' || answer === 'no'; }
 
@@ -328,15 +336,15 @@ async function handleExit(manager, rl) {
 // ─── REPL ─────────────────────────────────────────────────────────────────────
 
 const HELP = `
-  spawn <path> [name]   Start Claude at path (name defaults to dir name)
-  list                  Show all sessions
-  watch                 Live session monitor  (q to exit)
-  web [port] [host] [password]  Start web dashboard  (default: 3742 127.0.0.1)
-  attach <name>         Open tmux session in this terminal
-  kill <name>           Stop a session
-  resume [message]      Show or set the message sent after a limit resets
-  help                  Show this help
-  exit                  Quit pilot  (asks whether to kill sessions)
+  spawn <path> [name]                        Start Claude at path (name defaults to dir name)
+  list                                       Show all sessions
+  watch                                      Live session monitor  (q to exit)
+  web [port] [host] [password] [--tunnel]    Start web dashboard  (default: 3742 127.0.0.1)
+  attach <name>                              Open tmux session in this terminal
+  kill <name>                                Stop a session
+  resume [message]                           Show or set the message sent after a limit resets
+  help                                       Show this help
+  exit                                       Quit pilot  (asks whether to kill sessions)
 `;
 
 // ─── main ─────────────────────────────────────────────────────────────────────
@@ -419,13 +427,50 @@ ${HELP}`);
 
   const openWeb = await question(setupRl, 'Open web dashboard? (Y/n) ');
   if (isYes(openWeb)) {
-    const webServer = new WebServer(manager, 3742, '127.0.0.1');
+    let webPassword = null;
+    let useTunnel = false;
+
+    const tunnelAns = await question(setupRl, 'Expose publicly via cloudflared tunnel? (y/N) ');
+    useTunnel = tunnelAns === 'y' || tunnelAns === 'yes';
+
+    if (useTunnel && !has('cloudflared')) {
+      console.log(`\n  cloudflared not found. Install it:\n    ${cloudflaredInstallCmd()}\n  Continuing without tunnel.\n`);
+      useTunnel = false;
+    }
+
+    if (useTunnel) {
+      console.log('\n  ⚠  Public tunnel exposes your dashboard to the internet.');
+      const pwAns = await questionRaw(setupRl, '  Set a password (strongly recommended, Enter to skip): ');
+      if (pwAns) {
+        webPassword = pwAns;
+        console.log('  Password protection enabled.\n');
+      } else {
+        console.log('  ⚠  No password set — anyone with the URL can control your sessions!\n');
+      }
+    }
+
+    const webServer = new WebServer(manager, 3742, '127.0.0.1', webPassword);
     manager._webServer = webServer;
     webServer.start();
-    const url = 'http://127.0.0.1:3742';
-    console.log(`  ✓ Web dashboard at ${url}`);
+    const localUrl = 'http://127.0.0.1:3742';
+    console.log(`  ✓ Web dashboard at ${localUrl}`);
+
+    if (useTunnel) {
+      console.log('  Starting cloudflared tunnel...');
+      webServer.startTunnel().then(publicUrl => {
+        console.log(`  ✓ Tunnel ready: ${publicUrl}`);
+        console.log('    Note: first visit may show a Cloudflare warning — click "Proceed" to open the dashboard.');
+        if (!webPassword) console.log('  ⚠  Reminder: no password set. Restart with a password for security.');
+        if (telegram.token && telegram.chatId) {
+          notifier.send(telegram.token, telegram.chatId,
+            `Claude Remote Pilot tunnel ready: ${publicUrl}${webPassword ? ' (password protected)' : ' ⚠ no password set'}`);
+          console.log('  ✓ Tunnel URL sent via Telegram.');
+        }
+      }).catch(e => console.log(`  ✗ Tunnel failed: ${e.message}`));
+    }
+
     const opener = process.platform === 'darwin' ? 'open' : 'xdg-open';
-    spawn(opener, [url], { stdio: 'ignore', detached: true }).unref();
+    spawn(opener, [localUrl], { stdio: 'ignore', detached: true }).unref();
     console.log('');
   }
 
@@ -479,22 +524,57 @@ ${HELP}`);
           return;
         }
         case 'web': {
-          const port = parseInt(args[0]) || 3742;
-          const host = args[1] || '127.0.0.1';
-          const password = args[2] || null;
+          const flags = args.filter(a => a.startsWith('--'));
+          const positional = args.filter(a => !a.startsWith('--'));
+          const port = parseInt(positional[0]) || 3742;
+          const host = positional[1] || '127.0.0.1';
+          const password = positional[2] || null;
+          const useTunnel = flags.includes('--tunnel');
           let webServer = manager._webServer;
           if (webServer) {
             console.log(`  Web dashboard already running at http://${webServer.host}:${webServer.port}`);
+            if (useTunnel && !webServer._tunnelProcess) {
+              if (!has('cloudflared')) { console.log(`  cloudflared not found. Install: ${cloudflaredInstallCmd()}`); break; }
+              if (!webServer.password) console.log('  ⚠  No password set — anyone with the URL can control your sessions!');
+              console.log('  Starting cloudflared tunnel...');
+              webServer.startTunnel().then(publicUrl => {
+                console.log(`  ✓ Tunnel ready: ${publicUrl}`);
+                console.log('    Note: first visit may show a Cloudflare warning — click "Proceed" to open the dashboard.');
+                if (telegram.token && telegram.chatId) {
+                  notifier.send(telegram.token, telegram.chatId,
+                    `Claude Remote Pilot tunnel ready: ${publicUrl}${webServer.password ? ' (password protected)' : ' ⚠ no password set'}`);
+                  console.log('  ✓ Tunnel URL sent via Telegram.');
+                }
+              }).catch(e => console.log(`  ✗ Tunnel failed: ${e.message}`));
+            }
+            break;
+          }
+          if (useTunnel && !has('cloudflared')) {
+            console.log(`  cloudflared not found. Install:\n    ${cloudflaredInstallCmd()}`);
             break;
           }
+          if (useTunnel && !password) console.log('  ⚠  No password set — anyone with the URL can control your sessions!');
           webServer = new WebServer(manager, port, host, password);
           manager._webServer = webServer;
           webServer.start();
           const url = `http://${host}:${port}`;
           console.log(`  ✓ Web dashboard started at ${url}`);
-          if (password) console.log(`  Password protected. Enter password in the browser.`);
+          if (password) console.log('  Password protection enabled.');
           const opener = process.platform === 'darwin' ? 'open' : 'xdg-open';
           spawn(opener, [url], { stdio: 'ignore', detached: true }).unref();
+          if (useTunnel) {
+            console.log('  Starting cloudflared tunnel...');
+            webServer.startTunnel().then(publicUrl => {
+              console.log(`  ✓ Tunnel ready: ${publicUrl}`);
+              console.log('    Note: first visit may show a Cloudflare warning — click "Proceed" to open the dashboard.');
+              if (!password) console.log('  ⚠  Reminder: add a password with: web <port> <host> <password> --tunnel');
+              if (telegram.token && telegram.chatId) {
+                notifier.send(telegram.token, telegram.chatId,
+                  `Claude Remote Pilot tunnel ready: ${publicUrl}${password ? ' (password protected)' : ' ⚠ no password set'}`);
+                console.log('  ✓ Tunnel URL sent via Telegram.');
+              }
+            }).catch(e => console.log(`  ✗ Tunnel failed: ${e.message}`));
+          }
           break;
         }
         case 'attach': {

package/lib/Watcher.js

@@ -15,7 +15,7 @@ class Watcher {
   constructor(session, opts = {}) {
     this.session = session;
     this.telegram = opts.telegram || {};
-    this.onEnded = opts.onEnded || (() => {});
+    this.onEnded = opts.onEnded || (() => { });
     this.checkInterval = opts.checkInterval || 5000;
     this.fallbackWait = opts.fallbackWait || 300;
     this.cooldown = opts.cooldown || 180;
@@ -134,7 +134,12 @@ class Watcher {
         this.session.tokens = { sent: tokenMatch[1], received: tokenMatch[2] };
       }
 
-      if (LIMIT_RE.test(limitWindow)) {
+      if (RUNNING_RE.test(recentLines)) {
+        if (this.session.status !== 'running') {
+          this.session.status = 'running';
+          this.session.resumeAt = null;
+        }
+      } else if (LIMIT_RE.test(limitWindow)) {
         await this._handleLimit(limitWindow);
       } else if (RESPONSE_RE.test(recentLines)) {
         if (this.session.status !== 'needs-response') {
@@ -142,11 +147,6 @@ class Watcher {
           notifier.send(this.telegram.token, this.telegram.chatId,
             `Pilot: "${this.session.name}" needs your response.`);
         }
-      } else if (RUNNING_RE.test(recentLines)) {
-        if (this.session.status !== 'running') {
-          this.session.status = 'running';
-          this.session.resumeAt = null;
-        }
       } else {
         // No "esc to interrupt" visible — Claude is not actively processing
         if (this.session.status !== 'idle') {
@@ -181,7 +181,7 @@ class Watcher {
     await new Promise(r => setTimeout(r, effectiveWaitSeconds * 1000));
 
     try { spawnSync('tmux', ['send-keys', '-t', this.session.name, this.resumeCommand, 'Enter'], { stdio: 'ignore' }); }
-    catch {}
+    catch { }
 
     this.lastResumeAt = Date.now() / 1000;
     this.session.status = 'running';

package/lib/WebServer.js

@@ -3,7 +3,7 @@ const http = require('http');
 const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
-const { spawnSync } = require('child_process');
+const { spawnSync, spawn } = require('child_process');
 const config = require('./config');
 
 
@@ -18,6 +18,9 @@ class WebServer {
     this.server = null;
     this._clients = new Set();
     this._broadcastInterval = null;
+    this._heartbeatInterval = null;
+    this._tunnelProcess = null;
+    this._tunnelUrl = null;
   }
 
   _buildAllSessions() {
@@ -199,6 +202,7 @@ class WebServer {
           'Content-Type': 'text/event-stream',
           'Cache-Control': 'no-cache',
           'Connection': 'keep-alive',
+          'X-Accel-Buffering': 'no',  // prevent Cloudflare/nginx from buffering the stream
         });
         this._clients.add(res);
         res.write(`data: ${JSON.stringify(this._buildAllSessions())}\n\n`);
@@ -215,12 +219,55 @@ class WebServer {
     });
 
     this._broadcastInterval = setInterval(() => this._broadcast(), 3000);
+    // Keep SSE connections alive through proxies (Cloudflare timeout is ~100s)
+    this._heartbeatInterval = setInterval(() => {
+      for (const res of this._clients) {
+        try { res.write(': heartbeat\n\n'); } catch { this._clients.delete(res); }
+      }
+    }, 20000);
     this.server.listen(this.port, this.host);
     return this.port;
   }
 
+  startTunnel() {
+    return new Promise((resolve, reject) => {
+      const cf = spawn('cloudflared', ['tunnel', '--url', `http://localhost:${this.port}`], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+      this._tunnelProcess = cf;
+      let resolved = false;
+      const onData = (chunk) => {
+        const text = chunk.toString();
+        const match = text.match(/https:\/\/[a-z0-9-]+\.trycloudflare\.com/);
+        if (match && !resolved) {
+          resolved = true;
+          this._tunnelUrl = match[0];
+          resolve(match[0]);
+        }
+      };
+      cf.stdout.on('data', onData);
+      cf.stderr.on('data', onData);
+      cf.on('exit', (code) => {
+        if (!resolved) reject(new Error(`cloudflared exited (code ${code})`));
+      });
+      setTimeout(() => {
+        if (!resolved) reject(new Error('Timed out waiting for tunnel URL (30s)'));
+      }, 30000);
+    });
+  }
+
+  stopTunnel() {
+    if (this._tunnelProcess) {
+      try { this._tunnelProcess.kill(); } catch {}
+      this._tunnelProcess = null;
+      this._tunnelUrl = null;
+    }
+  }
+
   stop() {
+    this.stopTunnel();
     clearInterval(this._broadcastInterval);
+    clearInterval(this._heartbeatInterval);
     for (const res of this._clients) { try { res.end(); } catch {} }
     this._clients.clear();
     if (this.server) this.server.close();

package/lib/ui.html

@@ -1094,6 +1094,21 @@ function App() {
     return () => { if (esRef.current) esRef.current.close(); };
   }, []);
 
+  // Fallback polling — loads sessions immediately and keeps them fresh when
+  // SSE is blocked (e.g. through a Cloudflare tunnel that buffers streams).
+  useEffect(() => {
+    let mounted = true;
+    const poll = () => {
+      apiFetch('/api/sessions', { cache: 'no-store' })
+        .then(r => r.json())
+        .then(data => { if (mounted) setSessions(data); })
+        .catch(() => {});
+    };
+    poll();
+    const t = setInterval(poll, 5000);
+    return () => { mounted = false; clearInterval(t); };
+  }, []);
+
   const handleLogin = useCallback(() => {
     setNeedsLogin(false);
     apiFetch('/api/status').then(r => r.json()).then(setServerStatus).catch(() => {});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-remote-pilot",
-  "version": "0.5.6",
+  "version": "0.5.9",
   "description": "Interactive Claude Code supervisor — spawn and monitor multiple Claude sessions from a single terminal.",
   "type": "commonjs",
   "repository": {