claude-remote-cli 2.15.5 → 2.15.6

package/dist/server/index.js

@@ -11,7 +11,7 @@ import cookieParser from 'cookie-parser';
 import { loadConfig, saveConfig, DEFAULTS, readMeta, writeMeta, deleteMeta, ensureMetaDir } from './config.js';
 import * as auth from './auth.js';
 import * as sessions from './sessions.js';
-import { AGENT_CONTINUE_ARGS, AGENT_YOLO_ARGS } from './sessions.js';
+import { AGENT_CONTINUE_ARGS, AGENT_YOLO_ARGS, serializeAll, restoreFromDisk, activeTmuxSessionNames } from './sessions.js';
 import { setupWebSocket } from './ws.js';
 import { WorktreeWatcher, WORKTREE_DIRS, isValidWorktreePath, parseWorktreeListPorcelain, parseAllWorktrees } from './watcher.js';
 import { isInstalled as serviceIsInstalled } from './service.js';
@@ -223,6 +223,12 @@ async function main() {
     watcher.rebuild(config.rootDirs || []);
     const server = http.createServer(app);
     const { broadcastEvent } = setupWebSocket(server, authenticatedTokens, watcher);
+    // Restore sessions from a previous update restart
+    const configDir = path.dirname(CONFIG_PATH);
+    const restoredCount = await restoreFromDisk(configDir);
+    if (restoredCount > 0) {
+        console.log(`Restored ${restoredCount} session(s) from previous update.`);
+    }
     // Push notifications on session idle
     sessions.onIdleChange((sessionId, idle) => {
         if (idle) {
@@ -955,6 +961,11 @@ async function main() {
         try {
             await execFileAsync('npm', ['install', '-g', 'claude-remote-cli@latest']);
             const restarting = serviceIsInstalled();
+            if (restarting) {
+                // Persist sessions so they can be restored after restart
+                const configDir = path.dirname(CONFIG_PATH);
+                serializeAll(configDir);
+            }
             res.json({ ok: true, restarting });
             if (restarting) {
                 setTimeout(() => process.exit(0), 1000);
@@ -965,15 +976,16 @@ async function main() {
             res.status(500).json({ ok: false, error: message });
         }
     });
-    // Clean up orphaned tmux sessions from previous runs
+    // Clean up orphaned tmux sessions from previous runs (skip any adopted by restore)
     try {
+        const adoptedNames = activeTmuxSessionNames();
         const { stdout } = await execFileAsync('tmux', ['list-sessions', '-F', '#{session_name}']);
-        const crcSessions = stdout.trim().split('\n').filter(name => name.startsWith('crc-'));
-        for (const name of crcSessions) {
+        const orphanedSessions = stdout.trim().split('\n').filter(name => name.startsWith('crc-') && !adoptedNames.has(name));
+        for (const name of orphanedSessions) {
             execFileAsync('tmux', ['kill-session', '-t', name]).catch(() => { });
         }
-        if (crcSessions.length > 0) {
-            console.log(`Cleaned up ${crcSessions.length} orphaned tmux session(s).`);
+        if (orphanedSessions.length > 0) {
+            console.log(`Cleaned up ${orphanedSessions.length} orphaned tmux session(s).`);
         }
     }
     catch {

package/dist/server/sessions.js

@@ -4,7 +4,9 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
 import { readMeta, writeMeta } from './config.js';
+const execFileAsync = promisify(execFile);
 const AGENT_COMMANDS = {
     claude: 'claude',
     codex: 'codex',
@@ -17,6 +19,7 @@ const AGENT_YOLO_ARGS = {
     claude: ['--dangerously-skip-permissions'],
     codex: ['--full-auto'],
 };
+const STALE_THRESHOLD_MS = 5 * 60 * 1000; // 5 minutes
 function generateTmuxSessionName(displayName, id) {
     const sanitized = displayName.replace(/[^a-zA-Z0-9-]/g, '-').replace(/-+/g, '-').slice(0, 30);
     return `crc-${sanitized}-${id.slice(0, 8)}`;
@@ -42,8 +45,8 @@ const idleChangeCallbacks = [];
 function onIdleChange(cb) {
     idleChangeCallbacks.push(cb);
 }
-function create({ type, agent = 'claude', repoName, repoPath, cwd, root, worktreeName, branchName, displayName, command, args = [], cols = 80, rows = 24, configPath, useTmux: paramUseTmux }) {
-    const id = crypto.randomBytes(8).toString('hex');
+function create({ id: providedId, type, agent = 'claude', repoName, repoPath, cwd, root, worktreeName, branchName, displayName, command, args = [], cols = 80, rows = 24, configPath, useTmux: paramUseTmux, initialScrollback }) {
+    const id = providedId || crypto.randomBytes(8).toString('hex');
     const createdAt = new Date().toISOString();
     const resolvedCommand = command || AGENT_COMMANDS[agent];
     // Strip CLAUDECODE env var to allow spawning claude inside a claude-managed server
@@ -66,9 +69,10 @@ function create({ type, agent = 'claude', repoName, repoPath, cwd, root, worktre
         env,
     });
     // Scrollback buffer: stores all PTY output so we can replay on WebSocket (re)connect
-    const scrollback = [];
-    let scrollbackBytes = 0;
+    const scrollback = initialScrollback ? [...initialScrollback] : [];
+    let scrollbackBytes = initialScrollback ? initialScrollback.reduce((sum, s) => sum + s.length, 0) : 0;
     const MAX_SCROLLBACK = 256 * 1024; // 256KB max
+    const resolvedCwd = cwd || repoPath;
     const session = {
         id,
         type: type || 'worktree',
@@ -84,6 +88,8 @@ function create({ type, agent = 'claude', repoName, repoPath, cwd, root, worktre
         lastActivity: createdAt,
         scrollback,
         idle: false,
+        cwd: resolvedCwd,
+        customCommand: command || null,
         useTmux,
         tmuxSessionName,
         onPtyReplacedCallbacks: [],
@@ -194,14 +200,14 @@ function create({ type, agent = 'claude', repoName, repoPath, cwd, root, worktre
         });
     }
     attachHandlers(ptyProcess, continueArgs.some(a => args.includes(a)));
-    return { id, type: session.type, agent: session.agent, root: session.root, repoName: session.repoName, repoPath, worktreeName: session.worktreeName, branchName: session.branchName, displayName: session.displayName, pid: ptyProcess.pid, createdAt, lastActivity: createdAt, idle: false, useTmux, tmuxSessionName };
+    return { id, type: session.type, agent: session.agent, root: session.root, repoName: session.repoName, repoPath, worktreeName: session.worktreeName, branchName: session.branchName, displayName: session.displayName, pid: ptyProcess.pid, createdAt, lastActivity: createdAt, idle: false, cwd: resolvedCwd, customCommand: command || null, useTmux, tmuxSessionName };
 }
 function get(id) {
     return sessions.get(id);
 }
 function list() {
     return Array.from(sessions.values())
-        .map(({ id, type, agent, root, repoName, repoPath, worktreeName, branchName, displayName, createdAt, lastActivity, idle, useTmux, tmuxSessionName }) => ({
+        .map(({ id, type, agent, root, repoName, repoPath, worktreeName, branchName, displayName, createdAt, lastActivity, idle, cwd, customCommand, useTmux, tmuxSessionName }) => ({
         id,
         type,
         agent,
@@ -214,6 +220,8 @@ function list() {
         createdAt,
         lastActivity,
         idle,
+        cwd,
+        customCommand,
         useTmux,
         tmuxSessionName,
     }))
@@ -264,4 +272,150 @@ function findRepoSession(repoPath) {
 function nextTerminalName() {
     return `Terminal ${++terminalCounter}`;
 }
-export { create, get, list, kill, killAllTmuxSessions, resize, updateDisplayName, write, onIdleChange, findRepoSession, nextTerminalName, AGENT_COMMANDS, AGENT_CONTINUE_ARGS, AGENT_YOLO_ARGS, resolveTmuxSpawn, generateTmuxSessionName };
+function serializeAll(configDir) {
+    const scrollbackDirPath = path.join(configDir, 'scrollback');
+    fs.mkdirSync(scrollbackDirPath, { recursive: true });
+    const serialized = [];
+    for (const session of sessions.values()) {
+        // Write scrollback to disk
+        const scrollbackPath = path.join(scrollbackDirPath, session.id + '.buf');
+        fs.writeFileSync(scrollbackPath, session.scrollback.join(''), 'utf-8');
+        serialized.push({
+            id: session.id,
+            type: session.type,
+            agent: session.agent,
+            root: session.root,
+            repoName: session.repoName,
+            repoPath: session.repoPath,
+            worktreeName: session.worktreeName,
+            branchName: session.branchName,
+            displayName: session.displayName,
+            createdAt: session.createdAt,
+            lastActivity: session.lastActivity,
+            useTmux: session.useTmux,
+            tmuxSessionName: session.tmuxSessionName,
+            customCommand: session.customCommand,
+            cwd: session.cwd,
+        });
+    }
+    const pending = {
+        version: 1,
+        timestamp: new Date().toISOString(),
+        sessions: serialized,
+    };
+    fs.writeFileSync(path.join(configDir, 'pending-sessions.json'), JSON.stringify(pending, null, 2), 'utf-8');
+}
+async function restoreFromDisk(configDir) {
+    const pendingPath = path.join(configDir, 'pending-sessions.json');
+    if (!fs.existsSync(pendingPath))
+        return 0;
+    let pending;
+    try {
+        pending = JSON.parse(fs.readFileSync(pendingPath, 'utf-8'));
+    }
+    catch {
+        fs.unlinkSync(pendingPath);
+        return 0;
+    }
+    // Ignore stale files (>5 minutes old)
+    if (Date.now() - new Date(pending.timestamp).getTime() > STALE_THRESHOLD_MS) {
+        fs.unlinkSync(pendingPath);
+        return 0;
+    }
+    const scrollbackDirPath = path.join(configDir, 'scrollback');
+    let restored = 0;
+    for (const s of pending.sessions) {
+        // Load scrollback from disk
+        let initialScrollback;
+        const scrollbackPath = path.join(scrollbackDirPath, s.id + '.buf');
+        try {
+            const data = fs.readFileSync(scrollbackPath, 'utf-8');
+            if (data.length > 0)
+                initialScrollback = [data];
+        }
+        catch {
+            // Missing scrollback is non-fatal
+        }
+        // Determine spawn command and args
+        let command;
+        let args = [];
+        if (s.customCommand) {
+            // Terminal session — respawn the shell
+            command = s.customCommand;
+        }
+        else if (s.useTmux && s.tmuxSessionName) {
+            // Tmux session — check if tmux session is still alive
+            let tmuxAlive = false;
+            try {
+                await execFileAsync('tmux', ['has-session', '-t', s.tmuxSessionName]);
+                tmuxAlive = true;
+            }
+            catch {
+                // tmux session is gone
+            }
+            if (tmuxAlive) {
+                // Attach to surviving tmux session
+                command = 'tmux';
+                args = ['attach-session', '-t', s.tmuxSessionName];
+            }
+            else {
+                // Tmux session died — fall back to agent with continue args
+                args = [...AGENT_CONTINUE_ARGS[s.agent]];
+            }
+        }
+        else {
+            // Non-tmux agent session — respawn with continue args
+            args = [...AGENT_CONTINUE_ARGS[s.agent]];
+        }
+        try {
+            const createParams = {
+                id: s.id,
+                type: s.type,
+                agent: s.agent,
+                repoName: s.repoName,
+                repoPath: s.repoPath,
+                cwd: s.cwd,
+                root: s.root,
+                worktreeName: s.worktreeName,
+                branchName: s.branchName,
+                displayName: s.displayName,
+                args,
+                useTmux: false, // Don't re-wrap in tmux — either attaching to existing or using plain agent
+            };
+            if (command)
+                createParams.command = command;
+            if (initialScrollback)
+                createParams.initialScrollback = initialScrollback;
+            create(createParams);
+            restored++;
+        }
+        catch {
+            console.error(`Failed to restore session ${s.id} (${s.displayName})`);
+        }
+        // Clean up scrollback file
+        try {
+            fs.unlinkSync(scrollbackPath);
+        }
+        catch { /* ignore */ }
+    }
+    // Clean up
+    try {
+        fs.unlinkSync(pendingPath);
+    }
+    catch { /* ignore */ }
+    try {
+        fs.rmdirSync(path.join(configDir, 'scrollback'));
+    }
+    catch { /* ignore — may not be empty */ }
+    return restored;
+}
+/** Returns the set of tmux session names currently owned by restored sessions */
+function activeTmuxSessionNames() {
+    const names = new Set();
+    for (const session of sessions.values()) {
+        if (session.tmuxSessionName)
+            names.add(session.tmuxSessionName);
+    }
+    return names;
+}
+export { create, get, list, kill, killAllTmuxSessions, resize, updateDisplayName, write, onIdleChange, findRepoSession, nextTerminalName, serializeAll, restoreFromDisk, activeTmuxSessionNames, AGENT_COMMANDS, AGENT_CONTINUE_ARGS, AGENT_YOLO_ARGS, resolveTmuxSpawn, generateTmuxSessionName };

package/dist/test/sessions.test.js

@@ -1,7 +1,10 @@
 import { describe, it, afterEach } from 'node:test';
 import assert from 'node:assert';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
 import * as sessions from '../server/sessions.js';
-import { resolveTmuxSpawn, generateTmuxSessionName } from '../server/sessions.js';
+import { resolveTmuxSpawn, generateTmuxSessionName, serializeAll, restoreFromDisk } from '../server/sessions.js';
 // Track created session IDs so we can clean up after each test
 const createdIds = [];
 afterEach(() => {
@@ -425,4 +428,153 @@ describe('sessions', () => {
             done();
         });
     });
+    it('create accepts a predetermined id', () => {
+        const result = sessions.create({
+            id: 'custom-id-12345678',
+            repoName: 'test-repo',
+            repoPath: '/tmp',
+            command: '/bin/echo',
+            args: ['hello'],
+        });
+        createdIds.push(result.id);
+        assert.strictEqual(result.id, 'custom-id-12345678');
+        const session = sessions.get('custom-id-12345678');
+        assert.ok(session);
+    });
+    it('create accepts initialScrollback', () => {
+        const result = sessions.create({
+            repoName: 'test-repo',
+            repoPath: '/tmp',
+            command: '/bin/echo',
+            args: ['hello'],
+            initialScrollback: ['prior output\r\n'],
+        });
+        createdIds.push(result.id);
+        const session = sessions.get(result.id);
+        assert.ok(session);
+        assert.ok(session.scrollback.length >= 1);
+        assert.strictEqual(session.scrollback[0], 'prior output\r\n');
+    });
+});
+describe('session persistence', () => {
+    let tmpDir;
+    afterEach(() => {
+        // Clean up any sessions created during tests
+        for (const s of sessions.list()) {
+            try {
+                sessions.kill(s.id);
+            }
+            catch { /* ignore */ }
+        }
+        // Clean up temp directory
+        if (tmpDir) {
+            try {
+                fs.rmSync(tmpDir, { recursive: true, force: true });
+            }
+            catch { /* ignore */ }
+        }
+    });
+    function createTmpDir() {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'crc-test-'));
+        return tmpDir;
+    }
+    it('serializeAll writes pending-sessions.json and scrollback files', () => {
+        const configDir = createTmpDir();
+        const s = sessions.create({
+            repoName: 'test-repo',
+            repoPath: '/tmp',
+            command: '/bin/cat',
+            args: [],
+        });
+        // Manually push some scrollback
+        const session = sessions.get(s.id);
+        assert.ok(session);
+        session.scrollback.push('hello world');
+        serializeAll(configDir);
+        // Check pending-sessions.json
+        const pendingPath = path.join(configDir, 'pending-sessions.json');
+        assert.ok(fs.existsSync(pendingPath), 'pending-sessions.json should exist');
+        const pending = JSON.parse(fs.readFileSync(pendingPath, 'utf-8'));
+        assert.strictEqual(pending.version, 1);
+        assert.ok(pending.timestamp);
+        assert.strictEqual(pending.sessions.length, 1);
+        assert.strictEqual(pending.sessions[0].id, s.id);
+        assert.strictEqual(pending.sessions[0].repoPath, '/tmp');
+        // Check scrollback file
+        const scrollbackPath = path.join(configDir, 'scrollback', s.id + '.buf');
+        assert.ok(fs.existsSync(scrollbackPath), 'scrollback file should exist');
+        const scrollbackData = fs.readFileSync(scrollbackPath, 'utf-8');
+        assert.ok(scrollbackData.includes('hello world'));
+    });
+    it('restoreFromDisk restores sessions with original IDs', async () => {
+        const configDir = createTmpDir();
+        // Create and serialize a session
+        const s = sessions.create({
+            repoName: 'test-repo',
+            repoPath: '/tmp',
+            command: '/bin/cat',
+            args: [],
+            displayName: 'my-session',
+        });
+        const originalId = s.id;
+        const session = sessions.get(originalId);
+        assert.ok(session);
+        session.scrollback.push('saved output');
+        serializeAll(configDir);
+        // Kill the original session
+        sessions.kill(originalId);
+        assert.strictEqual(sessions.get(originalId), undefined);
+        // Restore
+        const restored = await restoreFromDisk(configDir);
+        assert.strictEqual(restored, 1);
+        // Verify session exists with original ID
+        const restoredSession = sessions.get(originalId);
+        assert.ok(restoredSession, 'restored session should exist');
+        assert.strictEqual(restoredSession.repoPath, '/tmp');
+        assert.strictEqual(restoredSession.displayName, 'my-session');
+        // Scrollback should be restored
+        assert.ok(restoredSession.scrollback.length >= 1);
+        assert.strictEqual(restoredSession.scrollback[0], 'saved output');
+        // pending-sessions.json should be cleaned up
+        assert.ok(!fs.existsSync(path.join(configDir, 'pending-sessions.json')));
+    });
+    it('restoreFromDisk ignores stale files (>5 min old)', async () => {
+        const configDir = createTmpDir();
+        // Write a stale pending file
+        const staleTime = new Date(Date.now() - 6 * 60 * 1000).toISOString();
+        const pending = {
+            version: 1,
+            timestamp: staleTime,
+            sessions: [{ id: 'stale-id', type: 'repo', agent: 'claude', root: '', repoName: 'test', repoPath: '/tmp', worktreeName: '', branchName: '', displayName: 'test', createdAt: staleTime, lastActivity: staleTime, useTmux: false, tmuxSessionName: '', customCommand: null, cwd: '/tmp' }],
+        };
+        fs.writeFileSync(path.join(configDir, 'pending-sessions.json'), JSON.stringify(pending));
+        const restored = await restoreFromDisk(configDir);
+        assert.strictEqual(restored, 0, 'should not restore stale sessions');
+        assert.ok(!fs.existsSync(path.join(configDir, 'pending-sessions.json')), 'stale file should be deleted');
+    });
+    it('restoreFromDisk handles missing scrollback gracefully', async () => {
+        const configDir = createTmpDir();
+        // Create a session, serialize, then delete scrollback file
+        const s = sessions.create({
+            repoName: 'test-repo',
+            repoPath: '/tmp',
+            command: '/bin/cat',
+            args: [],
+        });
+        serializeAll(configDir);
+        sessions.kill(s.id);
+        // Delete scrollback file
+        const scrollbackPath = path.join(configDir, 'scrollback', s.id + '.buf');
+        try {
+            fs.unlinkSync(scrollbackPath);
+        }
+        catch { /* ignore */ }
+        const restored = await restoreFromDisk(configDir);
+        assert.strictEqual(restored, 1, 'should still restore without scrollback');
+    });
+    it('restoreFromDisk returns 0 when no pending file exists', async () => {
+        const configDir = createTmpDir();
+        const restored = await restoreFromDisk(configDir);
+        assert.strictEqual(restored, 0);
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-remote-cli",
-  "version": "2.15.5",
+  "version": "2.15.6",
   "description": "Remote web interface for Claude Code CLI sessions",
   "type": "module",
   "main": "dist/server/index.js",