claude-code-remote-pilot 0.2.8 → 0.2.10

package/bin/claude-pilot.js

@@ -111,14 +111,21 @@ function trunc(str, len) {
   return str.length <= len ? str.padEnd(len) : str.slice(0, len - 1) + '…';
 }
 
+function uptime(startedAt) {
+  const s = Math.floor((Date.now() - new Date(startedAt)) / 1000);
+  if (s < 60) return `${s}s`;
+  if (s < 3600) return `${Math.floor(s / 60)}m`;
+  return `${Math.floor(s / 3600)}h ${Math.floor((s % 3600) / 60)}m`;
+}
+
 function renderTable(sessions) {
-  const NW = 20, SW = 14;
-  const bar = '  ' + '─'.repeat(NW + SW + 42);
-  const header = `  ${'SESSION'.padEnd(NW)}  ${'STATUS'.padEnd(SW)}  DIRECTORY`;
+  const NW = 18, SW = 14, UW = 8;
+  const bar = '  ' + '─'.repeat(NW + SW + UW + 34);
+  const header = `  ${'SESSION'.padEnd(NW)}  ${'STATUS'.padEnd(SW)}  ${'UP'.padEnd(UW)}  DIRECTORY`;
   const rows = sessions.map(s => {
     const { plain, colored } = formatStatus(s);
     const pad = ' '.repeat(Math.max(0, SW - plain.length));
-    return `  ${trunc(s.name, NW)}  ${colored}${pad}  ${trunc(s.path, 40)}`;
+    return `  ${trunc(s.name, NW)}  ${colored}${pad}  ${uptime(s.startedAt).padEnd(UW)}  ${trunc(s.path, 32)}`;
   });
   const footer = `  ${sessions.length} session${sessions.length !== 1 ? 's' : ''}   ${new Date().toLocaleTimeString()}   q to exit`;
   return ['\n', '  Claude Code Remote Pilot', bar, header, bar, ...rows, bar, footer, ''].join('\n');
@@ -182,6 +189,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 +248,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 +306,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,10 +20,17 @@ 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;
     this._busy = false;
+    this._prevOutputHash = '';
+    this._outputUnchangedCount = 0;
+  }
+
+  _stripAnsi(text) {
+    return text.replace(/\x1b\[[0-9;]*[mGKHFABCDJsuhl]/g, '').replace(/\x1b[()][AB012]/g, '');
   }
 
   start() {
@@ -72,23 +79,36 @@ class Watcher {
         return;
       }
 
-      const text = this._capture();
-      const lastLine = text.split('\n').filter(l => l.trim()).pop() || '';
+      const raw = this._capture();
+      const text = this._stripAnsi(raw);
+      const nonEmptyLines = text.split('\n').filter(l => l.trim());
+      const lastLine = nonEmptyLines[nonEmptyLines.length - 1] || '';
+      const recentLines = nonEmptyLines.slice(-5).join('\n');
+
+      // Track whether output is changing between checks
+      const outputHash = this._hash(recentLines);
+      if (outputHash === this._prevOutputHash) {
+        this._outputUnchangedCount++;
+      } else {
+        this._prevOutputHash = outputHash;
+        this._outputUnchangedCount = 0;
+      }
+      const outputIsStable = this._outputUnchangedCount >= 2;
 
       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;
         }
-      } else if (IDLE_RE.test(lastLine)) {
+      } else if (IDLE_RE.test(lastLine) || outputIsStable) {
         if (this.session.status !== 'idle') {
           this.session.status = 'idle';
           this.session.resumeAt = null;
@@ -108,6 +128,7 @@ class Watcher {
     if ((Date.now() / 1000) - this.lastResumeAt < this.cooldown) return;
 
     this.lastHash = hash;
+    this._outputUnchangedCount = 0; // reset — we're intentionally waiting
     const wait = this._parseWait(text);
     this.session.status = 'limit';
     this.session.resumeAt = Date.now() + wait * 1000;
@@ -117,7 +138,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.10",
   "description": "Interactive Claude Code supervisor — spawn and monitor multiple Claude sessions from a single terminal.",
   "type": "commonjs",
   "bin": {