claude-remote-cli 2.15.16 → 3.0.3

package/dist/test/sessions.test.js

@@ -60,6 +60,7 @@ describe('sessions', () => {
         assert.ok(session, 'should return the session');
         assert.strictEqual(session.id, result.id);
         assert.strictEqual(session.repoName, 'test-repo');
+        assert.strictEqual(session.mode, 'pty');
         assert.ok(session.pty, 'get should include the pty object');
     });
     it('get returns undefined for nonexistent id', () => {
@@ -100,8 +101,10 @@ describe('sessions', () => {
         createdIds.push(result.id);
         const session = sessions.get(result.id);
         assert.ok(session);
+        assert.strictEqual(session.mode, 'pty');
+        const ptySession = session;
         let output = '';
-        session.pty.onData((data) => {
+        ptySession.pty.onData((data) => {
             output += data;
             if (output.includes('hello')) {
                 done();
@@ -388,9 +391,11 @@ describe('sessions', () => {
         createdIds.push(result.id);
         const session = sessions.get(result.id);
         assert.ok(session);
-        session.onPtyReplacedCallbacks.push((newPty) => {
+        assert.strictEqual(session.mode, 'pty');
+        const ptySession = session;
+        ptySession.onPtyReplacedCallbacks.push((newPty) => {
             assert.ok(newPty, 'should receive new PTY');
-            assert.strictEqual(session.pty, newPty, 'session.pty should be updated to new PTY');
+            assert.strictEqual(ptySession.pty, newPty, 'session.pty should be updated to new PTY');
             done();
         });
     });
@@ -404,7 +409,9 @@ describe('sessions', () => {
         createdIds.push(result.id);
         const session = sessions.get(result.id);
         assert.ok(session);
-        session.onPtyReplacedCallbacks.push(() => {
+        assert.strictEqual(session.mode, 'pty');
+        const ptySession = session;
+        ptySession.onPtyReplacedCallbacks.push(() => {
             const stillExists = sessions.get(result.id);
             assert.ok(stillExists, 'session should still exist after retry');
             done();
@@ -420,9 +427,11 @@ describe('sessions', () => {
         createdIds.push(result.id);
         const session = sessions.get(result.id);
         assert.ok(session);
-        session.onPtyReplacedCallbacks.push((newPty) => {
+        assert.strictEqual(session.mode, 'pty');
+        const ptySession = session;
+        ptySession.onPtyReplacedCallbacks.push((newPty) => {
             assert.ok(newPty, 'should receive new PTY even with exit code 0');
-            assert.strictEqual(session.pty, newPty, 'session.pty should be updated');
+            assert.strictEqual(ptySession.pty, newPty, 'session.pty should be updated');
             const stillExists = sessions.get(result.id);
             assert.ok(stillExists, 'session should still exist after retry');
             done();
@@ -452,6 +461,7 @@ describe('sessions', () => {
         createdIds.push(result.id);
         const session = sessions.get(result.id);
         assert.ok(session);
+        assert.strictEqual(session.mode, 'pty');
         assert.ok(session.scrollback.length >= 1);
         assert.strictEqual(session.scrollback[0], 'prior output\r\n');
     });
@@ -489,6 +499,7 @@ describe('session persistence', () => {
         // Manually push some scrollback
         const session = sessions.get(s.id);
         assert.ok(session);
+        assert.strictEqual(session.mode, 'pty');
         session.scrollback.push('hello world');
         serializeAll(configDir);
         // Check pending-sessions.json
@@ -519,6 +530,7 @@ describe('session persistence', () => {
         const originalId = s.id;
         const session = sessions.get(originalId);
         assert.ok(session);
+        assert.strictEqual(session.mode, 'pty');
         session.scrollback.push('saved output');
         serializeAll(configDir);
         // Kill the original session
@@ -533,6 +545,7 @@ describe('session persistence', () => {
         assert.strictEqual(restoredSession.repoPath, '/tmp');
         assert.strictEqual(restoredSession.displayName, 'my-session');
         // Scrollback should be restored
+        assert.strictEqual(restoredSession.mode, 'pty');
         assert.ok(restoredSession.scrollback.length >= 1);
         assert.strictEqual(restoredSession.scrollback[0], 'saved output');
         // pending-sessions.json should be cleaned up
@@ -577,4 +590,160 @@ describe('session persistence', () => {
         const restored = await restoreFromDisk(configDir);
         assert.strictEqual(restored, 0);
     });
+    it('restoreFromDisk preserves tmuxSessionName for tmux sessions', async () => {
+        const configDir = createTmpDir();
+        // Write a pending file with a tmux session
+        const pending = {
+            version: 1,
+            timestamp: new Date().toISOString(),
+            sessions: [{
+                    id: 'tmux-test-id',
+                    type: 'worktree',
+                    agent: 'claude',
+                    root: '',
+                    repoName: 'test-repo',
+                    repoPath: '/tmp',
+                    worktreeName: 'my-wt',
+                    branchName: 'my-branch',
+                    displayName: 'my-session',
+                    createdAt: new Date().toISOString(),
+                    lastActivity: new Date().toISOString(),
+                    useTmux: true,
+                    tmuxSessionName: 'crc-my-session-tmux-tes',
+                    customCommand: '/bin/cat', // Use /bin/cat to avoid spawning real claude binary in test
+                    cwd: '/tmp',
+                }],
+        };
+        fs.writeFileSync(path.join(configDir, 'pending-sessions.json'), JSON.stringify(pending));
+        const restored = await restoreFromDisk(configDir);
+        assert.strictEqual(restored, 1);
+        const session = sessions.get('tmux-test-id');
+        assert.ok(session, 'restored session should exist');
+        assert.strictEqual(session.mode, 'pty');
+        assert.strictEqual(session.tmuxSessionName, 'crc-my-session-tmux-tes', 'tmuxSessionName should be preserved from serialized data');
+    });
+    it('restored session remains in list after PTY exits (disconnected status)', async () => {
+        const configDir = createTmpDir();
+        const pending = {
+            version: 1,
+            timestamp: new Date().toISOString(),
+            sessions: [{
+                    id: 'restore-exit-test',
+                    type: 'worktree',
+                    agent: 'claude',
+                    root: '',
+                    repoName: 'test-repo',
+                    repoPath: '/tmp',
+                    worktreeName: 'my-wt',
+                    branchName: 'my-branch',
+                    displayName: 'restored-session',
+                    createdAt: new Date().toISOString(),
+                    lastActivity: new Date().toISOString(),
+                    useTmux: false,
+                    tmuxSessionName: '',
+                    customCommand: '/bin/false',
+                    cwd: '/tmp',
+                }],
+        };
+        fs.writeFileSync(path.join(configDir, 'pending-sessions.json'), JSON.stringify(pending));
+        await restoreFromDisk(configDir);
+        // Wait for PTY to exit
+        await new Promise(resolve => setTimeout(resolve, 500));
+        // Session should still be in the list with disconnected status
+        const list = sessions.list();
+        const found = list.find(s => s.id === 'restore-exit-test');
+        assert.ok(found, 'restored session should remain in list after PTY exit');
+        assert.strictEqual(found.status, 'disconnected');
+    });
+    it('full serialize-restore round trip preserves all session fields including tmuxSessionName', async () => {
+        const configDir = createTmpDir();
+        // Create sessions of different types
+        const repo = sessions.create({
+            type: 'repo',
+            repoName: 'my-repo',
+            repoPath: '/tmp/repo',
+            command: '/bin/cat',
+            args: [],
+            displayName: 'My Repo',
+        });
+        const terminal = sessions.create({
+            type: 'terminal',
+            repoPath: '/tmp',
+            command: '/bin/sh',
+            args: [],
+            displayName: 'Terminal 1',
+        });
+        // Serialize all
+        serializeAll(configDir);
+        // Kill originals
+        sessions.kill(repo.id);
+        sessions.kill(terminal.id);
+        assert.strictEqual(sessions.list().length, 0);
+        // Also inject a tmux-style session into the pending file to test tmuxSessionName round-trip.
+        // Use customCommand so restore spawns that instead of claude --continue (which would exit instantly).
+        const pendingPath = path.join(configDir, 'pending-sessions.json');
+        const pending = JSON.parse(fs.readFileSync(pendingPath, 'utf-8'));
+        pending.sessions.push({
+            id: 'tmux-roundtrip-id',
+            type: 'worktree',
+            agent: 'claude',
+            root: '',
+            repoName: 'tmux-repo',
+            repoPath: '/tmp',
+            worktreeName: 'tmux-wt',
+            branchName: 'feat/tmux',
+            displayName: 'Tmux Session',
+            createdAt: new Date().toISOString(),
+            lastActivity: new Date().toISOString(),
+            useTmux: true,
+            tmuxSessionName: 'crc-tmux-session-tmux-rou',
+            customCommand: '/bin/cat',
+            cwd: '/tmp',
+        });
+        fs.writeFileSync(pendingPath, JSON.stringify(pending));
+        // Restore
+        const restored = await restoreFromDisk(configDir);
+        assert.strictEqual(restored, 3);
+        // Verify all sessions exist
+        const list = sessions.list();
+        assert.strictEqual(list.length, 3);
+        const restoredRepo = list.find(s => s.id === repo.id);
+        assert.ok(restoredRepo);
+        assert.strictEqual(restoredRepo.type, 'repo');
+        assert.strictEqual(restoredRepo.displayName, 'My Repo');
+        assert.strictEqual(restoredRepo.status, 'active');
+        const restoredTerminal = list.find(s => s.id === terminal.id);
+        assert.ok(restoredTerminal);
+        assert.strictEqual(restoredTerminal.type, 'terminal');
+        assert.strictEqual(restoredTerminal.displayName, 'Terminal 1');
+        // Verify tmux session name survived the round trip
+        const restoredTmux = sessions.get('tmux-roundtrip-id');
+        assert.ok(restoredTmux);
+        assert.strictEqual(restoredTmux.mode, 'pty');
+        assert.strictEqual(restoredTmux.tmuxSessionName, 'crc-tmux-session-tmux-rou');
+        assert.strictEqual(restoredTmux.displayName, 'Tmux Session');
+    });
+    it('serializeAll captures session state before kill', () => {
+        const configDir = createTmpDir();
+        const s = sessions.create({
+            repoName: 'test-repo',
+            repoPath: '/tmp',
+            command: '/bin/cat',
+            args: [],
+            displayName: 'before-kill',
+        });
+        const session = sessions.get(s.id);
+        assert.ok(session);
+        assert.strictEqual(session.mode, 'pty');
+        session.scrollback.push('important output');
+        serializeAll(configDir);
+        // Kill after serialize (mimics gracefulShutdown sequence)
+        sessions.kill(s.id);
+        // Verify data is on disk
+        const pendingPath = path.join(configDir, 'pending-sessions.json');
+        assert.ok(fs.existsSync(pendingPath));
+        const pending = JSON.parse(fs.readFileSync(pendingPath, 'utf-8'));
+        assert.strictEqual(pending.sessions.length, 1);
+        assert.strictEqual(pending.sessions[0].displayName, 'before-kill');
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-remote-cli",
-  "version": "2.15.16",
+  "version": "3.0.3",
   "description": "Remote web interface for Claude Code CLI sessions",
   "type": "module",
   "main": "dist/server/index.js",
@@ -18,7 +18,7 @@
     "build:frontend": "svelte-check --workspace frontend && vite build --config frontend/vite.config.ts",
     "dev": "vite --config frontend/vite.config.ts",
     "start": "tsc && svelte-check --workspace frontend && vite build --config frontend/vite.config.ts && node dist/server/index.js",
-    "test": "svelte-check --workspace frontend && tsc -p tsconfig.test.json && node --test dist/test/*.test.js",
+    "test": "svelte-check --workspace frontend && tsc -p tsconfig.test.json && node --test --test-force-exit dist/test/*.test.js",
     "prepublishOnly": "npm run build",
     "postinstall": "chmod +x node_modules/node-pty/prebuilds/darwin-arm64/spawn-helper 2>/dev/null || true"
   },
@@ -42,6 +42,7 @@
   "license": "MIT",
   "author": "Donovan Yohan",
   "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.77",
     "@tanstack/svelte-query": "^6.0.18",
     "@xterm/addon-fit": "^0.11.0",
     "@xterm/xterm": "^6.0.0",