claude-code-remote-pilot 0.2.13 → 0.3.1

package/CHANGELOG.md

@@ -0,0 +1,34 @@
+# Changelog
+
+## 0.3.1 — 2026-05-06
+
+### Changed
+- Status check interval reduced from 30s → 5s (faster running/idle/limit detection)
+- Watch screen refresh rate reduced from 2s → 1s
+
+---
+
+## 0.3.0 — 2026-05-06
+
+### Added
+- **Session history**: every spawned or adopted session is persisted to `~/.claude-remote-pilot.json`. Sessions you've worked in before are remembered even after they end.
+- **Offline sessions in watch**: the watch screen now shows offline sessions (from history but no longer running in tmux) alongside live sessions, in dim text.
+- **Interactive watch**: press a number key (1–9) to select a session, then:
+  - Active session: `[t]` open terminal (tmux attach), `[k]` kill, `Esc` deselect
+  - Offline session: `[s]` re-spawn Claude at the saved path, `[r]` remove from history, `Esc` deselect
+- **Auto-watch on start**: watch mode opens automatically after startup if there are any sessions (active or historical), so you land in the dashboard instead of a blank prompt.
+
+### Changed
+- Watch exits cleanly with `q` back to the command prompt (no session list required first).
+- Watch command also triggers when there are only offline sessions in history.
+
+---
+
+## 0.2.13 — previous
+
+- Usage limit detection with auto-resume
+- Token usage display in watch (`↑sent ↓received`)
+- Configurable resume message
+- Telegram notification persistence
+- Session recovery after pilot restart
+- Status detection: running / idle / needs-response / limit

package/README.md

@@ -15,29 +15,32 @@ npx claude-code-remote-pilot
   │
   ├── asks: mount current directory as a session?
   ├── asks: set up Telegram? (optional)
-  └── starts interactive prompt
-
-claude-pilot> spawn ~/projects/api-refactor
-claude-pilot> spawn ~/projects/mobile-app
-claude-pilot> watch
+  └── opens watch dashboard automatically
 ```
 
+Watch opens immediately. Press `q` to drop to the command prompt, then `watch` to return.
+
 ```
   Claude Code Remote Pilot
-  ─────────────────────────────────────────────────────────────────
-  SESSION                STATUS          DIRECTORY
-  ─────────────────────────────────────────────────────────────────
-  api-refactor           running         ~/projects/api-refactor
-  mobile-app             limit 42m       ~/projects/mobile-app
-  ─────────────────────────────────────────────────────────────────
-  2 sessions   14:23:05   q to exit
+  ───────────────────────────────────────────────────────────────────
+  #  SESSION             STATUS          UP       USAGE / RESET
+  ───────────────────────────────────────────────────────────────────
+   1 api-refactor        running         12m      ↑1.2k ↓890
+   2 mobile-app          limit 3m        1h 4m    resets 2:00 AM
+   3 old-project         offline         —
+  ───────────────────────────────────────────────────────────────────
+  [1-3]: select session   q: exit watch
 ```
 
-From any other terminal, interact with a session directly:
+Press a number to select a session:
+- **Active**: `[t]` open terminal · `[k]` kill · `Esc` back
+- **Offline**: `[s]` re-spawn · `[r]` remove from history · `Esc` back
+
+From any terminal, attach directly:
 
 ```bash
 tmux attach -t api-refactor
-# Ctrl+B then D to detach back to your terminal
+# Ctrl+B then D to detach
 ```
 
 ---
@@ -100,7 +103,7 @@ sudo apt update && sudo apt install tmux
 |---|---|
 | `spawn <path> [name]` | Start Claude at a path. Name defaults to the directory name. |
 | `list` | One-shot status of all sessions. |
-| `watch` | Live-updating session monitor. Press `q` to exit. |
+| `watch` | Live dashboard with offline session history. Press a number to select, `q` to exit. |
 | `attach <name>` | Open a tmux session in the current terminal. |
 | `kill <name>` | Stop a session. |
 | `help` | Show command reference. |
@@ -171,7 +174,7 @@ Start Claude without `--dangerously-skip-permissions` unless you know what you'r
 - [x] interactive REPL — spawn, watch, attach, kill
 - [x] multi-session support
 - [ ] web dashboard (sessions connect to pilot server)
-- [ ] persistent session state
+- [x] persistent session history with offline session display
 - [ ] pluggable notification providers
 - [ ] safety / policy engine
 

package/bin/claude-pilot.js

@@ -103,6 +103,8 @@ function formatStatus(session) {
       const label = `limit ${Math.ceil(secs / 60)}m`;
       return { plain: label, colored: `${C.yellow}${label}${C.reset}` };
     }
+    case 'offline':
+      return { plain: 'offline', colored: `${C.dim}offline${C.reset}` };
     case 'ended':
       return { plain: 'ended', colored: `${C.dim}ended${C.reset}` };
     default:
@@ -131,46 +133,161 @@ function formatUsage(session) {
   return '';
 }
 
-function renderTable(sessions) {
+// ─── watch mode ───────────────────────────────────────────────────────────────
+
+function buildAllSessions(manager) {
+  const active = manager.list();
+  const activeNames = new Set(active.map(s => s.name));
+  const history = config.getHistory();
+  const offline = history
+    .filter(h => !activeNames.has(h.name))
+    .map(h => ({ name: h.name, path: h.path, status: 'offline', startedAt: h.lastSeen, resumeAt: null }));
+  return [...active, ...offline];
+}
+
+function renderWatchTable(allSessions, selectedIdx) {
   const NW = 18, SW = 14, UW = 7, TW = 16;
   const bar = '  ' + '─'.repeat(NW + SW + UW + TW + 10);
-  const header = `  ${'SESSION'.padEnd(NW)}  ${'STATUS'.padEnd(SW)}  ${'UP'.padEnd(UW)}  ${'USAGE / RESET'.padEnd(TW)}`;
-  const rows = sessions.map(s => {
+  const header = `  ${'#'.padEnd(3)}${'SESSION'.padEnd(NW)}  ${'STATUS'.padEnd(SW)}  ${'UP'.padEnd(UW)}  ${'USAGE / RESET'.padEnd(TW)}`;
+
+  const rows = allSessions.slice(0, 9).map((s, i) => {
+    const num = `${i + 1}`;
     const { plain, colored } = formatStatus(s);
     const pad = ' '.repeat(Math.max(0, SW - plain.length));
-    const usage = formatUsage(s);
-    return `  ${trunc(s.name, NW)}  ${colored}${pad}  ${uptime(s.startedAt).padEnd(UW)}  ${trunc(usage, TW)}`;
+    const usage = s.status === 'offline' ? '' : formatUsage(s);
+    const up = s.status === 'offline' ? '—' : uptime(s.startedAt);
+    const sel = selectedIdx === i ? '▶' : ' ';
+    return `  ${sel}${num.padEnd(2)}${trunc(s.name, NW)}  ${colored}${pad}  ${up.padEnd(UW)}  ${trunc(usage, TW)}`;
   });
-  const footer = `  ${sessions.length} session${sessions.length !== 1 ? 's' : ''}   ${new Date().toLocaleTimeString()}   q to exit`;
+
+  let footer;
+  if (selectedIdx >= 0 && selectedIdx < allSessions.length) {
+    const sel = allSessions[selectedIdx];
+    if (sel.status === 'offline') {
+      footer = `  [s] spawn   [r] remove from history   Esc: back`;
+    } else {
+      footer = `  [t] terminal   [k] kill   Esc: back`;
+    }
+  } else {
+    footer = `  [1-${Math.min(allSessions.length, 9)}]: select session   q: exit watch`;
+  }
+
   return ['\n', '  Claude Code Remote Pilot', bar, header, bar, ...rows, bar, footer, ''].join('\n');
 }
 
-// ─── watch mode ───────────────────────────────────────────────────────────────
-
 function startWatch(manager, rl) {
+  let selectedIdx = -1;
+  let allSessions = buildAllSessions(manager);
+  const timer = { id: null };
+
   function draw() {
+    allSessions = buildAllSessions(manager);
     process.stdout.write('\x1B[2J\x1B[0f');
-    process.stdout.write(renderTable(manager.list()));
+    process.stdout.write(renderWatchTable(allSessions, selectedIdx));
   }
 
-  draw();
-  const interval = setInterval(draw, 2000);
+  function startTimer() {
+    timer.id = setInterval(draw, 1000);
+  }
 
-  function exit() {
+  function stopTimer() {
+    clearInterval(timer.id);
+    timer.id = null;
+  }
+
+  function exitWatch() {
     process.stdin.removeListener('keypress', onKeypress);
-    clearInterval(interval);
+    stopTimer();
     process.stdout.write('\x1B[2J\x1B[0f');
-    // Clear any character readline buffered while we were in watch mode
     rl.write(null, { ctrl: true, name: 'u' });
     rl.prompt();
   }
 
+  function redraw() {
+    process.stdout.write('\x1B[2J\x1B[0f');
+    process.stdout.write(renderWatchTable(allSessions, selectedIdx));
+  }
+
   function onKeypress(str, key) {
-    if (str === 'q' || str === 'Q' || (key && key.ctrl && key.name === 'c')) {
-      exit();
+    if (!key) return;
+
+    if (key.ctrl && key.name === 'c') { exitWatch(); return; }
+
+    if (key.name === 'escape') {
+      selectedIdx = -1;
+      redraw();
+      return;
+    }
+
+    if (selectedIdx < 0) {
+      if (str === 'q' || str === 'Q') { exitWatch(); return; }
+      const n = parseInt(str);
+      if (!isNaN(n) && n >= 1 && n <= Math.min(allSessions.length, 9)) {
+        selectedIdx = n - 1;
+        redraw();
+      }
+      return;
+    }
+
+    const sel = allSessions[selectedIdx];
+
+    if (sel.status === 'offline') {
+      if (str === 's' || str === 'S') {
+        selectedIdx = -1;
+        stopTimer();
+        process.stdin.removeListener('keypress', onKeypress);
+        process.stdout.write('\x1B[2J\x1B[0f');
+        try {
+          const session = manager.spawn(sel.path, sel.name);
+          process.stdout.write(`\n  ✓ "${session.name}" spawned.\n    tmux attach -t ${session.name}\n\n`);
+        } catch (e) {
+          process.stdout.write(`\n  Error: ${e.message}\n\n`);
+        }
+        setTimeout(() => {
+          allSessions = buildAllSessions(manager);
+          draw();
+          startTimer();
+          process.stdin.on('keypress', onKeypress);
+        }, 1500);
+        return;
+      }
+      if (str === 'r' || str === 'R') {
+        config.removeFromHistory(sel.name);
+        selectedIdx = -1;
+        allSessions = buildAllSessions(manager);
+        redraw();
+        return;
+      }
+    } else {
+      if (str === 't' || str === 'T') {
+        stopTimer();
+        process.stdin.removeListener('keypress', onKeypress);
+        rl.pause();
+        process.stdout.write('\x1B[2J\x1B[0f');
+        const child = spawn('tmux', ['attach-session', '-t', sel.name], { stdio: 'inherit' });
+        child.on('exit', () => {
+          process.stdout.write('\n');
+          rl.resume();
+          selectedIdx = -1;
+          allSessions = buildAllSessions(manager);
+          draw();
+          startTimer();
+          process.stdin.on('keypress', onKeypress);
+        });
+        return;
+      }
+      if (str === 'k' || str === 'K') {
+        try { manager.kill(sel.name); } catch {}
+        selectedIdx = -1;
+        allSessions = buildAllSessions(manager);
+        redraw();
+        return;
+      }
     }
   }
 
+  draw();
+  startTimer();
   process.stdin.on('keypress', onKeypress);
 }
 
@@ -208,20 +325,82 @@ const HELP = `
   exit                  Quit pilot  (asks whether to kill sessions)
 `;
 
-function startREPL(manager) {
-  const rl = readline.createInterface({
+// ─── main ─────────────────────────────────────────────────────────────────────
+
+async function main() {
+  if (process.argv.includes('--help') || process.argv.includes('-h')) {
+    console.log(`
+Claude Code Remote Pilot
+
+Usage:
+  claude-remote-pilot
+
+Interactive commands:
+${HELP}`);
+    process.exit(0);
+  }
+
+  const setupRl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+  await ensureDep(setupRl, 'tmux', 'tmux', tmuxInstallCmd());
+  await ensureDep(setupRl, 'claude', 'Claude Code CLI', 'npm install -g @anthropic-ai/claude-code');
+  const telegram = await setupTelegram(setupRl);
+
+  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 (isYes(recover)) {
+      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);
+  const mount = await question(setupRl, `Mount current directory as a session? (${defaultName}) [Y/n] `);
+
+  if (isYes(mount)) {
+    const rawName = await questionRaw(setupRl, `Session name [${defaultName}]: `);
+    const session = manager.spawn(cwd, rawName || defaultName);
+    console.log(`  ✓ "${session.name}" started at ${session.path}`);
+    console.log(`    tmux attach -t ${session.name}\n`);
+  }
+
+  setupRl.close();
+
+  console.log('  Type help for commands.\n');
+  const replRl = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
     prompt: 'claude-pilot> ',
   });
 
-  rl.prompt();
+  // Auto-enter watch if there are sessions to monitor
+  const allAtStart = buildAllSessions(manager);
+  if (allAtStart.length) {
+    startWatch(manager, replRl);
+  } else {
+    replRl.prompt();
+  }
 
-  rl.on('line', async (line) => {
+  replRl.on('line', async (line) => {
     const parts = line.trim().split(/\s+/).filter(Boolean);
     const [cmd, ...args] = parts;
 
-    if (!cmd) { rl.prompt(); return; }
+    if (!cmd) { replRl.prompt(); return; }
 
     try {
       switch (cmd) {
@@ -244,16 +423,16 @@ function startREPL(manager) {
           break;
         }
         case 'watch': {
-          const sessions = manager.list();
-          if (!sessions.length) { console.log('  No sessions.'); break; }
-          startWatch(manager, rl);
+          const all = buildAllSessions(manager);
+          if (!all.length) { console.log('  No sessions.'); break; }
+          startWatch(manager, replRl);
           return;
         }
         case 'attach': {
           if (!args[0]) { console.log('  Usage: attach <name>'); break; }
-          rl.pause();
+          replRl.pause();
           const child = spawn('tmux', ['attach-session', '-t', args[0]], { stdio: 'inherit' });
-          child.on('exit', () => { process.stdout.write('\n'); rl.resume(); rl.prompt(); });
+          child.on('exit', () => { process.stdout.write('\n'); replRl.resume(); replRl.prompt(); });
           return;
         }
         case 'kill': {
@@ -264,10 +443,10 @@ function startREPL(manager) {
         }
         case 'resume': {
           if (args.length) {
-            const cmd = args.join(' ');
-            manager.resumeCommand = cmd;
-            config.saveResumeCommand(cmd);
-            console.log(`  ✓ Resume message saved: "${cmd}"`);
+            const resumeMsg = args.join(' ');
+            manager.resumeCommand = resumeMsg;
+            config.saveResumeCommand(resumeMsg);
+            console.log(`  ✓ Resume message saved: "${resumeMsg}"`);
           } else {
             console.log(`  Current resume message: "${manager.resumeCommand || '(default)'}"`);
           }
@@ -279,7 +458,7 @@ function startREPL(manager) {
         }
         case 'exit':
         case 'quit': {
-          await handleExit(manager, rl);
+          await handleExit(manager, replRl);
           return;
         }
         default:
@@ -289,74 +468,13 @@ function startREPL(manager) {
       console.error(`  Error: ${err.message}`);
     }
 
-    rl.prompt();
+    replRl.prompt();
   });
 
-  rl.on('close', () => {
-    // stdin closed (Ctrl+D) — can't ask interactively, keep sessions running
+  replRl.on('close', () => {
     console.log('\n  Sessions keep running. Use tmux to attach.\n');
     process.exit(0);
   });
 }
 
-// ─── main ─────────────────────────────────────────────────────────────────────
-
-async function main() {
-  if (process.argv.includes('--help') || process.argv.includes('-h')) {
-    console.log(`
-Claude Code Remote Pilot
-
-Usage:
-  claude-remote-pilot
-
-Interactive commands:
-${HELP}`);
-    process.exit(0);
-  }
-
-  const setupRl = readline.createInterface({ input: process.stdin, output: process.stdout });
-
-  await ensureDep(setupRl, 'tmux', 'tmux', tmuxInstallCmd());
-  await ensureDep(setupRl, 'claude', 'Claude Code CLI', 'npm install -g @anthropic-ai/claude-code');
-  const telegram = await setupTelegram(setupRl);
-
-  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 (isYes(recover)) {
-      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);
-  const mount = await question(setupRl, `Mount current directory as a session? (${defaultName}) [Y/n] `);
-
-  if (isYes(mount)) {
-    const rawName = await questionRaw(setupRl, `Session name [${defaultName}]: `);
-    const session = manager.spawn(cwd, rawName || defaultName);
-    console.log(`  ✓ "${session.name}" started at ${session.path}`);
-    console.log(`    tmux attach -t ${session.name}\n`);
-  }
-
-  setupRl.close();
-
-  console.log('  Type help for commands.\n');
-  startREPL(manager);
-}
-
 main().catch(err => { console.error(err.message); process.exit(1); });

package/lib/SessionManager.js

@@ -3,6 +3,7 @@ const { execSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
 const Watcher = require('./Watcher');
+const config = require('./config');
 
 const RESERVED = new Set(['spawn', 'list', 'watch', 'attach', 'kill', 'help', 'exit', 'quit', 'resume']);
 
@@ -44,6 +45,7 @@ class SessionManager {
     const watcher = this._makeWatcher(session);
     watcher.start();
     this.sessions.set(sessionName, { session, watcher });
+    config.addToHistory(sessionName, resolved);
     return session;
   }
 
@@ -57,6 +59,7 @@ class SessionManager {
     const watcher = this._makeWatcher(session);
     watcher.start();
     this.sessions.set(name, { session, watcher });
+    config.addToHistory(name, dirPath);
     return session;
   }
 

package/lib/Watcher.js

@@ -16,7 +16,7 @@ class Watcher {
     this.session = session;
     this.telegram = opts.telegram || {};
     this.onEnded = opts.onEnded || (() => {});
-    this.checkInterval = opts.checkInterval || 30000;
+    this.checkInterval = opts.checkInterval || 5000;
     this.fallbackWait = opts.fallbackWait || 300;
     this.cooldown = opts.cooldown || 180;
     this.captureLines = opts.captureLines || 500;

package/lib/config.js

@@ -34,4 +34,20 @@ function saveResumeCommand(cmd) {
   save({ resumeCommand: cmd });
 }
 
-module.exports = { load, saveTelegram, saveSessions, clearSessions, saveResumeCommand };
+function addToHistory(name, path) {
+  const cfg = load();
+  const history = (cfg.sessionHistory || []).filter(s => s.name !== name);
+  history.unshift({ name, path, lastSeen: new Date().toISOString() });
+  save({ sessionHistory: history.slice(0, 30) }); // cap at 30
+}
+
+function removeFromHistory(name) {
+  const cfg = load();
+  save({ sessionHistory: (cfg.sessionHistory || []).filter(s => s.name !== name) });
+}
+
+function getHistory() {
+  return load().sessionHistory || [];
+}
+
+module.exports = { load, saveTelegram, saveSessions, clearSessions, saveResumeCommand, addToHistory, removeFromHistory, getHistory };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-remote-pilot",
-  "version": "0.2.13",
+  "version": "0.3.1",
   "description": "Interactive Claude Code supervisor — spawn and monitor multiple Claude sessions from a single terminal.",
   "type": "commonjs",
   "bin": {
@@ -10,6 +10,7 @@
     "bin/",
     "lib/",
     "README.md",
+    "CHANGELOG.md",
     "LICENSE"
   ],
   "scripts": {