claude-code-remote-pilot 0.5.5 → 0.5.8

package/CHANGELOG.md

@@ -1,11 +1,19 @@
 # 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
 - **Respawn loading no longer appears stuck**: web respawn now has a request timeout and surfaces a clear timeout error when the API call hangs, so the button always returns to clickable state.
 - **Terminal output now feels realtime**: session detail terminal polling runs at a faster cadence and triggers immediate output refresh after sending input/keys, improving perceived connect speed and responsiveness.
 - **"Connecting…" no longer gets stuck**: terminal detail view now clears connecting state on poll failures, shows a retrying error hint, and fixes session state initialization order for stable render behavior.
+- **Respawn/End web actions stabilized**: removed false-positive client respawn timeout and added explicit inline error handling for End action responses, so both controls fail visibly instead of appearing stuck.
 
 ## 0.5.4 — 2026-05-06
 

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,49 @@ ${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}`);
+        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 +523,55 @@ ${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}`);
+                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}`);
+              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,8 @@ class WebServer {
     this.server = null;
     this._clients = new Set();
     this._broadcastInterval = null;
+    this._tunnelProcess = null;
+    this._tunnelUrl = null;
   }
 
   _buildAllSessions() {
@@ -219,7 +221,43 @@ class WebServer {
     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);
     for (const res of this._clients) { try { res.end(); } catch {} }
     this._clients.clear();

package/lib/ui.html

@@ -580,6 +580,7 @@ function SessionDetailScreen({ session, onBack, onKilled, onRespawned }) {
   const [msg, setMsg] = useState('');
   const [sending, setSending] = useState(false);
   const [killing, setKilling] = useState(false);
+  const [killError, setKillError] = useState('');
   const [respawning, setRespawning] = useState(false);
   const [respawnError, setRespawnError] = useState('');
   const [copyOk, setCopyOk] = useState(false);
@@ -688,10 +689,18 @@ function SessionDetailScreen({ session, onBack, onKilled, onRespawned }) {
   const handleKill = async () => {
     if (!confirm(`End session "${session.name}"?`)) return;
     setKilling(true);
+    setKillError('');
     try {
-      await apiFetch(`/api/sessions/${encodeURIComponent(session.name)}`, { method: 'DELETE' });
+      const res = await apiFetch(`/api/sessions/${encodeURIComponent(session.name)}`, { method: 'DELETE' });
+      if (!res.ok) {
+        const d = await res.json().catch(() => ({}));
+        setKillError(d.error || 'Failed to end session');
+        setKilling(false);
+        return;
+      }
       onKilled();
-    } catch {
+    } catch (e) {
+      if (e && e.message !== 'Unauthorized') setKillError('Network error');
       setKilling(false);
     }
   };
@@ -700,13 +709,8 @@ function SessionDetailScreen({ session, onBack, onKilled, onRespawned }) {
     if (respawning) return;
     setRespawning(true);
     setRespawnError('');
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 12000);
     try {
-      const res = await apiFetch(`/api/sessions/${encodeURIComponent(session.name)}/respawn`, {
-        method: 'POST',
-        signal: controller.signal,
-      });
+      const res = await apiFetch(`/api/sessions/${encodeURIComponent(session.name)}/respawn`, { method: 'POST' });
       const data = await res.json();
       if (!res.ok) {
         setRespawnError(data.error || 'Failed to respawn');
@@ -714,13 +718,8 @@ function SessionDetailScreen({ session, onBack, onKilled, onRespawned }) {
       }
       onRespawned(data);
     } catch (e) {
-      if (e && e.name === 'AbortError') {
-        setRespawnError('Respawn timeout. Please try again.');
-        return;
-      }
       if (e.message !== 'Unauthorized') setRespawnError('Network error');
     } finally {
-      clearTimeout(timeoutId);
       setRespawning(false);
     }
   };
@@ -774,6 +773,11 @@ function SessionDetailScreen({ session, onBack, onKilled, onRespawned }) {
               {Icons.trash} {killing ? 'Ending…' : 'End'}
             </button>
           )}
+          {!isOffline && killError && (
+            <span style={{ color: 'var(--error)', fontSize: 12, alignSelf: 'center' }}>
+              {killError}
+            </span>
+          )}
         </div>
       </div>
 

package/package.json

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