claude-remote-cli 2.13.0 → 2.13.1

package/dist/server/sessions.js

@@ -85,6 +85,7 @@ function create({ type, agent = 'claude', repoName, repoPath, cwd, root, worktre
         idle: false,
         useTmux,
         tmuxSessionName,
+        onPtyReplacedCallbacks: [],
     };
     sessions.set(id, session);
     // Load existing metadata to preserve a previously-set displayName
@@ -136,23 +137,42 @@ function create({ type, agent = 'claude', repoName, repoPath, cwd, root, worktre
             // If continue args failed quickly, retry without them
             if (canRetry && (Date.now() - spawnTime) < 3000 && exitCode !== 0) {
                 const retryArgs = args.filter(a => !continueArgs.includes(a));
+                const retryNotice = '\r\n[claude-remote-cli] --continue not available; starting new session...\r\n';
                 scrollback.length = 0;
                 scrollbackBytes = 0;
+                scrollback.push(retryNotice);
+                scrollbackBytes = retryNotice.length;
                 let retryCommand = resolvedCommand;
                 let retrySpawnArgs = retryArgs;
                 if (useTmux && tmuxSessionName) {
-                    const tmux = resolveTmuxSpawn(resolvedCommand, retryArgs, tmuxSessionName);
+                    const retryTmuxName = tmuxSessionName + '-retry';
+                    session.tmuxSessionName = retryTmuxName;
+                    const tmux = resolveTmuxSpawn(resolvedCommand, retryArgs, retryTmuxName);
                     retryCommand = tmux.command;
                     retrySpawnArgs = tmux.args;
                 }
-                const retryPty = pty.spawn(retryCommand, retrySpawnArgs, {
-                    name: 'xterm-256color',
-                    cols,
-                    rows,
-                    cwd: cwd || repoPath,
-                    env,
-                });
+                let retryPty;
+                try {
+                    retryPty = pty.spawn(retryCommand, retrySpawnArgs, {
+                        name: 'xterm-256color',
+                        cols,
+                        rows,
+                        cwd: cwd || repoPath,
+                        env,
+                    });
+                }
+                catch {
+                    // Retry spawn failed — fall through to normal exit cleanup
+                    if (idleTimer)
+                        clearTimeout(idleTimer);
+                    if (metaFlushTimer)
+                        clearTimeout(metaFlushTimer);
+                    sessions.delete(id);
+                    return;
+                }
                 session.pty = retryPty;
+                for (const cb of session.onPtyReplacedCallbacks)
+                    cb(retryPty);
                 attachHandlers(retryPty, false);
                 return;
             }

package/dist/server/ws.js

@@ -71,15 +71,29 @@ function setupWebSocket(server, authenticatedTokens, watcher) {
         const session = sessionMap.get(ws);
         if (!session)
             return;
-        const ptyProcess = session.pty;
-        for (const chunk of session.scrollback) {
-            ws.send(chunk);
-        }
-        const dataHandler = ptyProcess.onData((data) => {
-            if (ws.readyState === ws.OPEN) {
-                ws.send(data);
+        let dataDisposable = null;
+        let exitDisposable = null;
+        function attachToPty(ptyProcess) {
+            // Dispose previous handlers
+            dataDisposable?.dispose();
+            exitDisposable?.dispose();
+            // Replay scrollback
+            for (const chunk of session.scrollback) {
+                if (ws.readyState === ws.OPEN)
+                    ws.send(chunk);
             }
-        });
+            dataDisposable = ptyProcess.onData((data) => {
+                if (ws.readyState === ws.OPEN)
+                    ws.send(data);
+            });
+            exitDisposable = ptyProcess.onExit(() => {
+                if (ws.readyState === ws.OPEN)
+                    ws.close(1000);
+            });
+        }
+        attachToPty(session.pty);
+        const ptyReplacedHandler = (newPty) => attachToPty(newPty);
+        session.onPtyReplacedCallbacks.push(ptyReplacedHandler);
         ws.on('message', (msg) => {
             const str = msg.toString();
             try {
@@ -90,15 +104,15 @@ function setupWebSocket(server, authenticatedTokens, watcher) {
                 }
             }
             catch (_) { }
-            ptyProcess.write(str);
+            // Use session.pty dynamically so writes go to current PTY
+            session.pty.write(str);
         });
         ws.on('close', () => {
-            dataHandler.dispose();
-        });
-        ptyProcess.onExit(() => {
-            if (ws.readyState === ws.OPEN) {
-                ws.close(1000);
-            }
+            dataDisposable?.dispose();
+            exitDisposable?.dispose();
+            const idx = session.onPtyReplacedCallbacks.indexOf(ptyReplacedHandler);
+            if (idx !== -1)
+                session.onPtyReplacedCallbacks.splice(idx, 1);
         });
     });
     sessions.onIdleChange((sessionId, idle) => {

package/dist/test/sessions.test.js

@@ -374,4 +374,36 @@ describe('sessions', () => {
         assert.strictEqual(session.useTmux, false);
         assert.strictEqual(session.tmuxSessionName, '');
     });
+    it('calls onPtyReplaced when continue-arg process fails quickly', (_, done) => {
+        const result = sessions.create({
+            repoName: 'test-repo',
+            repoPath: '/tmp',
+            command: '/bin/false',
+            args: [...sessions.AGENT_CONTINUE_ARGS.claude],
+        });
+        createdIds.push(result.id);
+        const session = sessions.get(result.id);
+        assert.ok(session);
+        session.onPtyReplacedCallbacks.push((newPty) => {
+            assert.ok(newPty, 'should receive new PTY');
+            assert.strictEqual(session.pty, newPty, 'session.pty should be updated to new PTY');
+            done();
+        });
+    });
+    it('session survives after continue-arg retry', (_, done) => {
+        const result = sessions.create({
+            repoName: 'test-repo',
+            repoPath: '/tmp',
+            command: '/bin/false',
+            args: [...sessions.AGENT_CONTINUE_ARGS.claude],
+        });
+        createdIds.push(result.id);
+        const session = sessions.get(result.id);
+        assert.ok(session);
+        session.onPtyReplacedCallbacks.push(() => {
+            const stillExists = sessions.get(result.id);
+            assert.ok(stillExists, 'session should still exist after retry');
+            done();
+        });
+    });
 });

package/package.json

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