claude-code-remote-pilot 0.2.8 → 0.2.9

package/bin/claude-pilot.js

@@ -182,6 +182,7 @@ const HELP = `
   watch                 Live session monitor  (q to exit)
   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)
 `;
@@ -240,6 +241,17 @@ function startREPL(manager) {
           console.log(`  ✓ "${args[0]}" killed.`);
           break;
         }
+        case 'resume': {
+          if (args.length) {
+            const cmd = args.join(' ');
+            manager.resumeCommand = cmd;
+            config.saveResumeCommand(cmd);
+            console.log(`  ✓ Resume message saved: "${cmd}"`);
+          } else {
+            console.log(`  Current resume message: "${manager.resumeCommand || '(default)'}"`);
+          }
+          break;
+        }
         case 'help': {
           console.log(HELP);
           break;
@@ -287,10 +299,11 @@ ${HELP}`);
   await ensureDep(setupRl, 'claude', 'Claude Code CLI', 'npm install -g @anthropic-ai/claude-code');
   const telegram = await setupTelegram(setupRl);
 
-  const manager = new SessionManager({ telegram });
+  const cfg = config.load();
+  const manager = new SessionManager({ telegram, resumeCommand: cfg.resumeCommand });
 
   // Recover sessions from previous run
-  const savedSessions = (config.load().sessions || []).filter(s => {
+  const savedSessions = (cfg.sessions || []).filter(s => {
     try { execSync(`tmux has-session -t "${s.name}"`, { stdio: 'ignore' }); return true; }
     catch { return false; }
   });

package/lib/SessionManager.js

@@ -4,16 +4,25 @@ const fs = require('fs');
 const path = require('path');
 const Watcher = require('./Watcher');
 
-const RESERVED = new Set(['spawn', 'list', 'watch', 'attach', 'kill', 'help', 'exit', 'quit']);
+const RESERVED = new Set(['spawn', 'list', 'watch', 'attach', 'kill', 'help', 'exit', 'quit', 'resume']);
 
 function sanitizeName(name) {
   return name.replace(/[.:\s]/g, '-');
 }
 
 class SessionManager {
-  constructor({ telegram = {} } = {}) {
+  constructor({ telegram = {}, resumeCommand } = {}) {
     this.sessions = new Map();
     this.telegram = telegram;
+    this.resumeCommand = resumeCommand;
+  }
+
+  _makeWatcher(session) {
+    return new Watcher(session, {
+      telegram: this.telegram,
+      resumeCommand: this.resumeCommand,
+      onEnded: (s) => this.sessions.delete(s.name),
+    });
   }
 
   spawn(dirPath, name) {
@@ -32,25 +41,12 @@ class SessionManager {
     execSync(`tmux new-session -d -s "${sessionName}" -c "${resolved}" "claude"`, { stdio: 'ignore' });
 
     const session = { name: sessionName, path: resolved, status: 'running', startedAt: new Date(), resumeAt: null };
-
-    const watcher = new Watcher(session, {
-      telegram: this.telegram,
-      onEnded: (s) => this.sessions.delete(s.name),
-    });
+    const watcher = this._makeWatcher(session);
     watcher.start();
-
     this.sessions.set(sessionName, { session, watcher });
     return session;
   }
 
-  kill(name) {
-    const entry = this.sessions.get(name);
-    if (!entry) throw new Error(`Session "${name}" not found.`);
-    entry.watcher.stop();
-    try { execSync(`tmux kill-session -t "${name}"`, { stdio: 'ignore' }); } catch {}
-    this.sessions.delete(name);
-  }
-
   adopt(name, dirPath) {
     try { execSync(`tmux has-session -t "${name}"`, { stdio: 'ignore' }); }
     catch { throw new Error(`tmux session "${name}" not found.`); }
@@ -58,15 +54,20 @@ class SessionManager {
     if (this.sessions.has(name)) throw new Error(`Session "${name}" already being watched.`);
 
     const session = { name, path: dirPath, status: 'running', startedAt: new Date(), resumeAt: null };
-    const watcher = new Watcher(session, {
-      telegram: this.telegram,
-      onEnded: (s) => this.sessions.delete(s.name),
-    });
+    const watcher = this._makeWatcher(session);
     watcher.start();
     this.sessions.set(name, { session, watcher });
     return session;
   }
 
+  kill(name) {
+    const entry = this.sessions.get(name);
+    if (!entry) throw new Error(`Session "${name}" not found.`);
+    entry.watcher.stop();
+    try { execSync(`tmux kill-session -t "${name}"`, { stdio: 'ignore' }); } catch {}
+    this.sessions.delete(name);
+  }
+
   killAll() {
     for (const name of [...this.sessions.keys()]) {
       try { this.kill(name); } catch {}

package/lib/Watcher.js

@@ -4,11 +4,11 @@ const crypto = require('crypto');
 const notifier = require('./notifier');
 
 const LIMIT_RE = /hit your limit|usage limit|rate limit|limit reached|try again|resets/i;
-// Claude Code's permission/action prompt UI
+// Checked against full capture — these messages persist on screen
 const RESPONSE_RE = /do you want to proceed|esc to cancel|ctrl\+e to explain|❯\s*\d+\.\s*yes/i;
-// Claude Code shows this footer while actively processing
+// Checked against last 5 lines only — footer disappears when Claude finishes
 const RUNNING_RE = /esc to interrupt/i;
-// Claude Code shows ">" alone on the last line when idle/waiting for next prompt
+// Checked against the single last non-empty line
 const IDLE_RE = /^\s*>\s*$/;
 
 class Watcher {
@@ -20,6 +20,7 @@ class Watcher {
     this.fallbackWait = opts.fallbackWait || 300;
     this.cooldown = opts.cooldown || 180;
     this.captureLines = opts.captureLines || 500;
+    this.resumeCommand = opts.resumeCommand || 'The usage limit has reset. Please continue where you left off.';
     this.lastHash = '';
     this.lastResumeAt = 0;
     this._timer = null;
@@ -73,17 +74,20 @@ class Watcher {
       }
 
       const text = this._capture();
-      const lastLine = text.split('\n').filter(l => l.trim()).pop() || '';
+      const nonEmptyLines = text.split('\n').filter(l => l.trim());
+      const lastLine = nonEmptyLines[nonEmptyLines.length - 1] || '';
+      // Only check recent lines for transient UI elements
+      const recentLines = nonEmptyLines.slice(-5).join('\n');
 
       if (LIMIT_RE.test(text)) {
         await this._handleLimit(text);
-      } else if (RESPONSE_RE.test(text)) {
+      } else if (RESPONSE_RE.test(recentLines)) {
         if (this.session.status !== 'needs-response') {
           this.session.status = 'needs-response';
           notifier.send(this.telegram.token, this.telegram.chatId,
             `Pilot: "${this.session.name}" needs your response.`);
         }
-      } else if (RUNNING_RE.test(text)) {
+      } else if (RUNNING_RE.test(recentLines)) {
         if (this.session.status !== 'running') {
           this.session.status = 'running';
           this.session.resumeAt = null;
@@ -117,7 +121,7 @@ class Watcher {
 
     await new Promise(r => setTimeout(r, wait * 1000));
 
-    try { execSync(`tmux send-keys -t "${this.session.name}" "continue" Enter`, { stdio: 'ignore' }); }
+    try { execSync(`tmux send-keys -t "${this.session.name}" "${this.resumeCommand}" Enter`, { stdio: 'ignore' }); }
     catch {}
 
     this.lastResumeAt = Date.now() / 1000;

package/lib/config.js

@@ -30,4 +30,8 @@ function clearSessions() {
   save({ sessions: [] });
 }
 
-module.exports = { load, saveTelegram, saveSessions, clearSessions };
+function saveResumeCommand(cmd) {
+  save({ resumeCommand: cmd });
+}
+
+module.exports = { load, saveTelegram, saveSessions, clearSessions, saveResumeCommand };

package/package.json

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