claude-remote-cli 3.0.6 → 3.0.9

package/dist/server/ws.js

@@ -1,5 +1,17 @@
 import { WebSocketServer } from 'ws';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
 import * as sessions from './sessions.js';
+import { onSdkEvent, sendMessage as sdkSendMessage, handlePermission as sdkHandlePermission } from './sdk-handler.js';
+import { writeMeta } from './config.js';
+const execFileAsync = promisify(execFile);
+const BACKPRESSURE_HIGH = 1024 * 1024; // 1MB
+const BACKPRESSURE_LOW = 512 * 1024; // 512KB
+const RENAME_CORE = `rename the current git branch using \`git branch -m <new-name>\` to a short, descriptive kebab-case name based on the task I'm asking about. Do not include any ticket numbers or prefixes.`;
+// Prepended to the user's first message in SDK mode
+const SDK_BRANCH_RENAME_INSTRUCTION = `Before responding to my message, first ${RENAME_CORE} After renaming, proceed with my request normally.\n\n`;
+// Sent as a standalone first message in PTY mode, before the user types
+const PTY_BRANCH_RENAME_INSTRUCTION = `When I send my next message, before responding to it, first ${RENAME_CORE} After renaming, proceed with my request normally. Reply with only "Ready." and nothing else.`;
 function parseCookies(cookieHeader) {
     const cookies = {};
     if (!cookieHeader)
@@ -14,7 +26,39 @@ function parseCookies(cookieHeader) {
     });
     return cookies;
 }
-function setupWebSocket(server, authenticatedTokens, watcher) {
+const BRANCH_POLL_INTERVAL_MS = 3000;
+const BRANCH_POLL_MAX_ATTEMPTS = 10;
+function startBranchWatcher(session, broadcastEvent, configPath) {
+    const originalBranch = session.branchName;
+    let attempts = 0;
+    const timer = setInterval(async () => {
+        attempts++;
+        if (attempts > BRANCH_POLL_MAX_ATTEMPTS) {
+            clearInterval(timer);
+            return;
+        }
+        try {
+            const { stdout } = await execFileAsync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: session.cwd });
+            const currentBranch = stdout.trim();
+            if (currentBranch && currentBranch !== originalBranch) {
+                clearInterval(timer);
+                session.branchName = currentBranch;
+                session.displayName = currentBranch;
+                broadcastEvent('session-renamed', { sessionId: session.id, branchName: currentBranch, displayName: currentBranch });
+                writeMeta(configPath, {
+                    worktreePath: session.repoPath,
+                    displayName: currentBranch,
+                    lastActivity: new Date().toISOString(),
+                    branchName: currentBranch,
+                });
+            }
+        }
+        catch {
+            // git command failed — session cwd may not exist yet, retry
+        }
+    }, BRANCH_POLL_INTERVAL_MS);
+}
+function setupWebSocket(server, authenticatedTokens, watcher, configPath) {
     const wss = new WebSocketServer({ noServer: true });
     const eventClients = new Set();
     function broadcastEvent(type, data) {
@@ -47,7 +91,7 @@ function setupWebSocket(server, authenticatedTokens, watcher) {
             });
             return;
         }
-        // PTY channel: /ws/:sessionId
+        // PTY/SDK channel: /ws/:sessionId
         const match = request.url && request.url.match(/^\/ws\/([a-f0-9]+)$/);
         if (!match) {
             socket.write('HTTP/1.1 404 Not Found\r\n\r\n');
@@ -71,6 +115,16 @@ function setupWebSocket(server, authenticatedTokens, watcher) {
         const session = sessionMap.get(ws);
         if (!session)
             return;
+        if (session.mode === 'sdk') {
+            handleSdkConnection(ws, session);
+            return;
+        }
+        // PTY mode — existing behavior
+        if (session.mode !== 'pty') {
+            ws.close(1008, 'Session mode does not support PTY streaming');
+            return;
+        }
+        const ptySession = session;
         let dataDisposable = null;
         let exitDisposable = null;
         function attachToPty(ptyProcess) {
@@ -78,7 +132,7 @@ function setupWebSocket(server, authenticatedTokens, watcher) {
             dataDisposable?.dispose();
             exitDisposable?.dispose();
             // Replay scrollback
-            for (const chunk of session.scrollback) {
+            for (const chunk of ptySession.scrollback) {
                 if (ws.readyState === ws.OPEN)
                     ws.send(chunk);
             }
@@ -91,52 +145,125 @@ function setupWebSocket(server, authenticatedTokens, watcher) {
                     ws.close(1000);
             });
         }
-        attachToPty(session.pty);
+        attachToPty(ptySession.pty);
+        // For PTY sessions needing branch rename, send the rename instruction once Claude CLI is ready.
+        // We watch for PTY idle (Claude shows its prompt and waits for input) as the trigger.
+        let pendingIdleHandler = null;
+        if (ptySession.needsBranchRename) {
+            ptySession.needsBranchRename = false;
+            const idleHandler = (sessionId, idle) => {
+                if (idle && sessionId === ptySession.id) {
+                    sessions.offIdleChange(idleHandler);
+                    pendingIdleHandler = null;
+                    ptySession.pty.write(PTY_BRANCH_RENAME_INSTRUCTION + '\r');
+                    startBranchWatcher(ptySession, broadcastEvent, configPath);
+                }
+            };
+            pendingIdleHandler = idleHandler;
+            sessions.onIdleChange(idleHandler);
+        }
         const ptyReplacedHandler = (newPty) => attachToPty(newPty);
-        session.onPtyReplacedCallbacks.push(ptyReplacedHandler);
+        ptySession.onPtyReplacedCallbacks.push(ptyReplacedHandler);
         ws.on('message', (msg) => {
             const str = msg.toString();
             try {
                 const parsed = JSON.parse(str);
                 if (parsed.type === 'resize' && parsed.cols && parsed.rows) {
-                    sessions.resize(session.id, parsed.cols, parsed.rows);
+                    sessions.resize(ptySession.id, parsed.cols, parsed.rows);
                     return;
                 }
             }
             catch (_) { }
-            // Branch rename interception: prepend rename prompt before the user's first message
-            if (session.needsBranchRename) {
-                if (!session._renameBuffer)
-                    session._renameBuffer = '';
-                const enterIndex = str.indexOf('\r');
-                if (enterIndex === -1) {
-                    // No Enter yet — buffer and pass through so the user sees echo
-                    session._renameBuffer += str;
-                    session.pty.write(str);
-                    return;
-                }
-                // Enter detected — inject rename prompt before the user's message
-                const buffered = session._renameBuffer;
-                const beforeEnter = buffered + str.slice(0, enterIndex);
-                const afterEnter = str.slice(enterIndex); // includes the \r
-                const renamePrompt = `Before doing anything else, rename the current git branch using \`git branch -m <new-name>\`. Choose a short, descriptive kebab-case branch name based on the task below.${session.branchRenamePrompt ? ' User preferences: ' + session.branchRenamePrompt : ''} Do not ask for confirmation — just rename and proceed.\n\n`;
-                const clearLine = '\x15'; // Ctrl+U clears the current input line
-                session.pty.write(clearLine + renamePrompt + beforeEnter + afterEnter);
-                session.needsBranchRename = false;
-                delete session._renameBuffer;
-                return;
-            }
-            // Use session.pty dynamically so writes go to current PTY
-            session.pty.write(str);
+            // Use ptySession.pty dynamically so writes go to current PTY
+            ptySession.pty.write(str);
         });
         ws.on('close', () => {
             dataDisposable?.dispose();
             exitDisposable?.dispose();
-            const idx = session.onPtyReplacedCallbacks.indexOf(ptyReplacedHandler);
+            if (pendingIdleHandler)
+                sessions.offIdleChange(pendingIdleHandler);
+            const idx = ptySession.onPtyReplacedCallbacks.indexOf(ptyReplacedHandler);
             if (idx !== -1)
-                session.onPtyReplacedCallbacks.splice(idx, 1);
+                ptySession.onPtyReplacedCallbacks.splice(idx, 1);
         });
     });
+    function handleSdkConnection(ws, session) {
+        // Send session info
+        const sessionInfo = JSON.stringify({
+            type: 'session_info',
+            mode: 'sdk',
+            sessionId: session.id,
+        });
+        if (ws.readyState === ws.OPEN)
+            ws.send(sessionInfo);
+        // Replay stored events (send as-is — client expects raw SdkEvent shape)
+        for (const event of session.events) {
+            if (ws.readyState !== ws.OPEN)
+                break;
+            ws.send(JSON.stringify(event));
+        }
+        // Subscribe to live events with backpressure
+        let paused = false;
+        const unsubscribe = onSdkEvent(session.id, (event) => {
+            if (ws.readyState !== ws.OPEN)
+                return;
+            // Backpressure check
+            if (ws.bufferedAmount > BACKPRESSURE_HIGH) {
+                paused = true;
+                return;
+            }
+            ws.send(JSON.stringify(event));
+        });
+        // Periodically check if we can resume
+        const backpressureInterval = setInterval(() => {
+            if (paused && ws.bufferedAmount < BACKPRESSURE_LOW) {
+                paused = false;
+            }
+        }, 100);
+        // Handle incoming messages
+        ws.on('message', (msg) => {
+            const str = msg.toString();
+            try {
+                const parsed = JSON.parse(str);
+                if (parsed.type === 'message' && typeof parsed.text === 'string') {
+                    if (parsed.text.length > 100_000)
+                        return;
+                    if (session.needsBranchRename) {
+                        session.needsBranchRename = false;
+                        sdkSendMessage(session.id, SDK_BRANCH_RENAME_INSTRUCTION + parsed.text);
+                        startBranchWatcher(session, broadcastEvent, configPath);
+                    }
+                    else {
+                        sdkSendMessage(session.id, parsed.text);
+                    }
+                    return;
+                }
+                if (parsed.type === 'permission' && typeof parsed.requestId === 'string' && typeof parsed.approved === 'boolean') {
+                    sdkHandlePermission(session.id, parsed.requestId, parsed.approved);
+                    return;
+                }
+                if (parsed.type === 'resize' && typeof parsed.cols === 'number' && typeof parsed.rows === 'number') {
+                    // TODO: wire up companion shell — currently open_companion message is unhandled server-side
+                    return;
+                }
+                if (parsed.type === 'open_companion') {
+                    // TODO: spawn companion PTY in session CWD and relay via terminal_data/terminal_exit frames
+                    return;
+                }
+            }
+            catch (_) {
+                // Not JSON — ignore for SDK sessions
+            }
+        });
+        ws.on('close', () => {
+            unsubscribe();
+            clearInterval(backpressureInterval);
+        });
+        ws.on('error', () => {
+            unsubscribe();
+            clearInterval(backpressureInterval);
+        });
+    }
     sessions.onIdleChange((sessionId, idle) => {
         broadcastEvent('session-idle-changed', { sessionId, idle });
     });

package/dist/test/branch-rename.test.js

@@ -0,0 +1,28 @@
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import { MOUNTAIN_NAMES } from '../server/types.js';
+describe('MOUNTAIN_NAMES', () => {
+    test('contains 30 mountain names', () => {
+        assert.equal(MOUNTAIN_NAMES.length, 30);
+    });
+    test('all names are lowercase kebab-case', () => {
+        for (const name of MOUNTAIN_NAMES) {
+            assert.match(name, /^[a-z][a-z0-9-]*$/, `Mountain name "${name}" is not kebab-case`);
+        }
+    });
+    test('no duplicate names', () => {
+        const unique = new Set(MOUNTAIN_NAMES);
+        assert.equal(unique.size, MOUNTAIN_NAMES.length);
+    });
+    test('cycling wraps around at array length', () => {
+        let idx = 28;
+        const name1 = MOUNTAIN_NAMES[idx % MOUNTAIN_NAMES.length];
+        idx++;
+        const name2 = MOUNTAIN_NAMES[idx % MOUNTAIN_NAMES.length];
+        idx++;
+        const name3 = MOUNTAIN_NAMES[idx % MOUNTAIN_NAMES.length];
+        assert.equal(name1, 'whitney');
+        assert.equal(name2, 'hood');
+        assert.equal(name3, 'everest'); // wraps back to start
+    });
+});

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
@@ -597,7 +610,7 @@ describe('session persistence', () => {
                     lastActivity: new Date().toISOString(),
                     useTmux: true,
                     tmuxSessionName: 'crc-my-session-tmux-tes',
-                    customCommand: null,
+                    customCommand: '/bin/cat', // Use /bin/cat to avoid spawning real claude binary in test
                     cwd: '/tmp',
                 }],
         };
@@ -606,6 +619,7 @@ describe('session persistence', () => {
         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 () => {
@@ -705,6 +719,7 @@ describe('session persistence', () => {
         // 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');
     });
@@ -719,6 +734,7 @@ describe('session persistence', () => {
         });
         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)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-remote-cli",
-  "version": "3.0.6",
+  "version": "3.0.9",
   "description": "Remote web interface for Claude Code CLI sessions",
   "type": "module",
   "main": "dist/server/index.js",
@@ -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",