claude-code-remote-pilot 0.2.7 → 0.2.9

package/bin/claude-pilot.js

@@ -6,6 +6,7 @@ const path = require('path');
 const fs = require('fs');
 const readline = require('readline');
 const SessionManager = require('../lib/SessionManager');
+const config = require('../lib/config');
 
 // ─── dependency checks ────────────────────────────────────────────────────────
 
@@ -60,12 +61,18 @@ async function setupTelegram(rl) {
   if (process.env.TELEGRAM_BOT_TOKEN && process.env.TELEGRAM_CHAT_ID) {
     return { token: process.env.TELEGRAM_BOT_TOKEN, chatId: process.env.TELEGRAM_CHAT_ID };
   }
+  const saved = config.load().telegram;
+  if (saved && saved.token && saved.chatId) {
+    console.log('  Telegram: using saved config.\n');
+    return saved;
+  }
   console.log('\nTelegram notifications (optional).');
   const answer = await question(rl, 'Set up Telegram now? (y/n) ');
   if (answer !== 'y' && answer !== 'yes') { console.log('Skipping.\n'); return {}; }
   const token = await questionRaw(rl, 'Bot token: ');
   const chatId = await questionRaw(rl, 'Chat ID: ');
-  console.log('Telegram configured.\n');
+  config.saveTelegram(token, chatId);
+  console.log('  Telegram configured and saved.\n');
   return { token, chatId };
 }
 
@@ -151,14 +158,17 @@ function startWatch(manager, rl) {
 async function handleExit(manager, rl) {
   const sessions = manager.list();
   if (!sessions.length) {
+    config.clearSessions();
     console.log('');
     process.exit(0);
   }
   const answer = await questionRaw(rl, `\n  Kill all ${sessions.length} session(s) before exiting? (y/n) `);
   if (answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes') {
     manager.killAll();
+    config.clearSessions();
     console.log('  All sessions killed.\n');
   } else {
+    config.saveSessions(sessions);
     console.log('  Sessions keep running. Use tmux to attach.\n');
   }
   process.exit(0);
@@ -172,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)
 `;
@@ -230,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;
@@ -277,7 +299,27 @@ ${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 = (cfg.sessions || []).filter(s => {
+    try { execSync(`tmux has-session -t "${s.name}"`, { stdio: 'ignore' }); return true; }
+    catch { return false; }
+  });
+
+  if (savedSessions.length) {
+    console.log(`\n  Found ${savedSessions.length} session(s) still running from last time:`);
+    savedSessions.forEach(s => console.log(`    ${s.name.padEnd(22)} ${s.path}`));
+    const recover = await question(setupRl, '  Re-adopt and watch them? (y/n) ');
+    if (recover === 'y' || recover === 'yes') {
+      savedSessions.forEach(s => {
+        try { manager.adopt(s.name, s.path); console.log(`  ✓ Re-adopted "${s.name}"`); }
+        catch (e) { console.log(`  ✗ Could not adopt "${s.name}": ${e.message}`); }
+      });
+      console.log('');
+    }
+  }
 
   const cwd = process.cwd();
   const defaultName = path.basename(cwd);

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,17 +41,25 @@ 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;
   }
 
+  adopt(name, dirPath) {
+    try { execSync(`tmux has-session -t "${name}"`, { stdio: 'ignore' }); }
+    catch { throw new Error(`tmux session "${name}" not found.`); }
+
+    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 = 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.`);

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

@@ -0,0 +1,37 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CONFIG_PATH = path.join(os.homedir(), '.claude-remote-pilot.json');
+
+function load() {
+  try {
+    return JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function save(data) {
+  const current = load();
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify({ ...current, ...data }, null, 2));
+}
+
+function saveTelegram(token, chatId) {
+  save({ telegram: { token, chatId } });
+}
+
+function saveSessions(sessions) {
+  save({ sessions: sessions.map(s => ({ name: s.name, path: s.path })) });
+}
+
+function clearSessions() {
+  save({ sessions: [] });
+}
+
+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.7",
+  "version": "0.2.9",
   "description": "Interactive Claude Code supervisor — spawn and monitor multiple Claude sessions from a single terminal.",
   "type": "commonjs",
   "bin": {