claude-remote-cli 3.0.6 → 3.0.9

package/dist/server/sessions.js

@@ -1,260 +1,106 @@
-import pty from 'node-pty';
 import crypto from 'node:crypto';
 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';
+import { AGENT_COMMANDS, AGENT_CONTINUE_ARGS, AGENT_YOLO_ARGS } from './types.js';
+import { createPtySession } from './pty-handler.js';
+import { createSdkSession, killSdkSession, sendMessage as sdkSendMessage, handlePermission as sdkHandlePermission, serializeSdkSession, restoreSdkSession } from './sdk-handler.js';
 const execFileAsync = promisify(execFile);
-const AGENT_COMMANDS = {
-    claude: 'claude',
-    codex: 'codex',
-};
-const AGENT_CONTINUE_ARGS = {
-    claude: ['--continue'],
-    codex: ['resume', '--last'],
-};
-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)}`;
-}
-function resolveTmuxSpawn(command, args, tmuxSessionName) {
-    return {
-        command: 'tmux',
-        args: [
-            '-u', 'new-session', '-s', tmuxSessionName, '--', command, ...args,
-            // ';' tokens are tmux command separators — parsed at the top level before
-            // dispatching to new-session, not passed as argv to `command`.
-            ';', 'set', 'set-clipboard', 'on',
-            ';', 'set', 'allow-passthrough', 'on',
-            ';', 'set', 'mode-keys', 'vi',
-        ],
-    };
-}
+const SDK_IDLE_CHECK_INTERVAL_MS = 60 * 1000; // 60 seconds
+const SDK_MAX_IDLE_MS = 30 * 60 * 1000; // 30 minutes
+const SDK_MAX_IDLE_SESSIONS = 5;
 // In-memory registry: id -> Session
 const sessions = new Map();
-const IDLE_TIMEOUT_MS = 5000;
 let terminalCounter = 0;
 const idleChangeCallbacks = [];
 function onIdleChange(cb) {
     idleChangeCallbacks.push(cb);
 }
+function offIdleChange(cb) {
+    const idx = idleChangeCallbacks.indexOf(cb);
+    if (idx !== -1)
+        idleChangeCallbacks.splice(idx, 1);
+}
 function create({ id: providedId, type, agent = 'claude', repoName, repoPath, cwd, root, worktreeName, branchName, displayName, command, args = [], cols = 80, rows = 24, configPath, useTmux: paramUseTmux, tmuxSessionName: paramTmuxSessionName, initialScrollback, restored: paramRestored, needsBranchRename: paramNeedsBranchRename, branchRenamePrompt: paramBranchRenamePrompt }) {
     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
-    const env = Object.assign({}, process.env);
-    delete env.CLAUDECODE;
-    const useTmux = !command && !!paramUseTmux;
-    let spawnCommand = resolvedCommand;
-    let spawnArgs = args;
-    const tmuxSessionName = paramTmuxSessionName || (useTmux ? generateTmuxSessionName(displayName || repoName || 'session', id) : '');
-    if (useTmux) {
-        const tmux = resolveTmuxSpawn(resolvedCommand, args, tmuxSessionName);
-        spawnCommand = tmux.command;
-        spawnArgs = tmux.args;
+    // Dispatch: if agent is claude, no custom command, try SDK first
+    if (agent === 'claude' && !command) {
+        const sdkResult = createSdkSession({
+            id,
+            type,
+            agent,
+            repoName,
+            repoPath,
+            cwd,
+            root,
+            worktreeName,
+            branchName,
+            displayName,
+        }, sessions, idleChangeCallbacks);
+        if (!('fallback' in sdkResult)) {
+            if (paramNeedsBranchRename) {
+                // createSdkSession initializes needsBranchRename to false; set it now
+                sessions.get(id).needsBranchRename = true;
+            }
+            return { ...sdkResult.result, pid: undefined, needsBranchRename: !!paramNeedsBranchRename };
+        }
+        // SDK init failed — fall through to PTY
     }
-    // Wrap the spawn command to trap SIGPIPE in the child shell.
-    // Without this, piped bash commands (e.g. `cmd | grep | tail`) run by
-    // Claude Code inside the PTY can generate SIGPIPE when the reading end
-    // of the pipe closes, which propagates up and kills the PTY session.
-    // Wrapping with `trap '' PIPE; exec ...` makes the shell ignore SIGPIPE
-    // before exec'ing the agent, so the agent inherits SIG_IGN for PIPE.
-    const wrappedCommand = '/bin/bash';
-    const wrappedArgs = ['-c', `trap '' PIPE; exec ${spawnCommand} ${spawnArgs.map(a => `'${a.replace(/'/g, "'\\''")}'`).join(' ')}`];
-    const ptyProcess = pty.spawn(wrappedCommand, wrappedArgs, {
-        name: 'xterm-256color',
-        cols,
-        rows,
-        cwd: cwd || repoPath,
-        env,
-    });
-    // Scrollback buffer: stores all PTY output so we can replay on WebSocket (re)connect
-    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 = {
+    // PTY path: codex, terminal, custom command, or SDK fallback
+    const ptyParams = {
         id,
-        type: type || 'worktree',
+        type,
         agent,
-        root: root || '',
-        repoName: repoName || '',
+        repoName,
         repoPath,
-        worktreeName: worktreeName || '',
-        branchName: branchName || worktreeName || '',
-        displayName: displayName || worktreeName || repoName || '',
-        pty: ptyProcess,
-        createdAt,
-        lastActivity: createdAt,
-        scrollback,
-        idle: false,
-        cwd: resolvedCwd,
-        customCommand: command || null,
-        useTmux,
-        tmuxSessionName,
-        onPtyReplacedCallbacks: [],
-        status: 'active',
-        restored: paramRestored || false,
-        needsBranchRename: paramNeedsBranchRename || false,
-        branchRenamePrompt: paramBranchRenamePrompt || '',
+        cwd,
+        root,
+        worktreeName,
+        branchName,
+        displayName,
+        command,
+        args,
+        cols,
+        rows,
+        configPath,
+        useTmux: paramUseTmux,
+        tmuxSessionName: paramTmuxSessionName,
+        initialScrollback,
+        restored: paramRestored,
     };
-    sessions.set(id, session);
-    // Load existing metadata to preserve a previously-set displayName
-    if (configPath && worktreeName) {
-        const existing = readMeta(configPath, repoPath);
-        if (existing && existing.displayName) {
-            session.displayName = existing.displayName;
-        }
-        writeMeta(configPath, { worktreePath: repoPath, displayName: session.displayName, lastActivity: createdAt });
-    }
-    let metaFlushTimer = null;
-    let idleTimer = null;
-    function resetIdleTimer() {
-        if (session.idle) {
-            session.idle = false;
-            for (const cb of idleChangeCallbacks)
-                cb(session.id, false);
-        }
-        if (idleTimer)
-            clearTimeout(idleTimer);
-        idleTimer = setTimeout(() => {
-            if (!session.idle) {
-                session.idle = true;
-                for (const cb of idleChangeCallbacks)
-                    cb(session.id, true);
-            }
-        }, IDLE_TIMEOUT_MS);
+    const { result, session: ptySession } = createPtySession(ptyParams, sessions, idleChangeCallbacks);
+    if (paramNeedsBranchRename) {
+        ptySession.needsBranchRename = true;
     }
-    const continueArgs = AGENT_CONTINUE_ARGS[agent];
-    function attachHandlers(proc, canRetry) {
-        const spawnTime = Date.now();
-        // Clear restored flag after 3s of running — means the PTY is healthy
-        const restoredClearTimer = session.restored ? setTimeout(() => { session.restored = false; }, 3000) : null;
-        proc.onData((data) => {
-            session.lastActivity = new Date().toISOString();
-            resetIdleTimer();
-            scrollback.push(data);
-            scrollbackBytes += data.length;
-            // Trim oldest entries if over limit
-            while (scrollbackBytes > MAX_SCROLLBACK && scrollback.length > 1) {
-                scrollbackBytes -= scrollback.shift().length;
-            }
-            if (configPath && worktreeName && !metaFlushTimer) {
-                metaFlushTimer = setTimeout(() => {
-                    metaFlushTimer = null;
-                    writeMeta(configPath, { worktreePath: repoPath, displayName: session.displayName, lastActivity: session.lastActivity });
-                }, 5000);
-            }
-        });
-        proc.onExit(() => {
-            // If continue args failed quickly, retry without them.
-            // Exit code is intentionally not checked: tmux wrapping exits 0 even
-            // when the inner command (e.g. claude --continue) fails, because the
-            // tmux client doesn't propagate inner exit codes. The 3-second window
-            // is the primary heuristic — no user quits a session that fast.
-            if (canRetry && (Date.now() - spawnTime) < 3000) {
-                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 retryTmuxName = tmuxSessionName + '-retry';
-                    session.tmuxSessionName = retryTmuxName;
-                    const tmux = resolveTmuxSpawn(resolvedCommand, retryArgs, retryTmuxName);
-                    retryCommand = tmux.command;
-                    retrySpawnArgs = tmux.args;
-                }
-                let retryPty;
-                try {
-                    // Wrap retry spawn with SIGPIPE trap (same as initial spawn)
-                    const retryWrapped = ['-c', `trap '' PIPE; exec ${retryCommand} ${retrySpawnArgs.map(a => `'${a.replace(/'/g, "'\\''")}'`).join(' ')}`];
-                    retryPty = pty.spawn('/bin/bash', retryWrapped, {
-                        name: 'xterm-256color',
-                        cols,
-                        rows,
-                        cwd: cwd || repoPath,
-                        env,
-                    });
-                }
-                catch {
-                    // Retry spawn failed — fall through to normal exit cleanup
-                    if (restoredClearTimer)
-                        clearTimeout(restoredClearTimer);
-                    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;
-            }
-            if (restoredClearTimer)
-                clearTimeout(restoredClearTimer);
-            // If PTY exited and this is a restored session, mark disconnected rather than delete
-            if (session.restored) {
-                session.status = 'disconnected';
-                session.restored = false; // clear so user-initiated kills can delete normally
-                if (idleTimer)
-                    clearTimeout(idleTimer);
-                if (metaFlushTimer)
-                    clearTimeout(metaFlushTimer);
-                return;
-            }
-            if (idleTimer)
-                clearTimeout(idleTimer);
-            if (metaFlushTimer)
-                clearTimeout(metaFlushTimer);
-            if (configPath && worktreeName) {
-                writeMeta(configPath, { worktreePath: repoPath, displayName: session.displayName, lastActivity: session.lastActivity });
-            }
-            sessions.delete(id);
-            const tmpDir = path.join(os.tmpdir(), 'claude-remote-cli', id);
-            fs.rm(tmpDir, { recursive: true, force: true }, () => { });
-        });
-    }
-    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, cwd: resolvedCwd, customCommand: command || null, useTmux, tmuxSessionName, status: 'active' };
+    return { ...result, needsBranchRename: ptySession.needsBranchRename };
 }
 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, cwd, customCommand, useTmux, tmuxSessionName, status }) => ({
-        id,
-        type,
-        agent,
-        root,
-        repoName,
-        repoPath,
-        worktreeName,
-        branchName,
-        displayName,
-        createdAt,
-        lastActivity,
-        idle,
-        cwd,
-        customCommand,
-        useTmux,
-        tmuxSessionName,
-        status,
+        .map((s) => ({
+        id: s.id,
+        type: s.type,
+        agent: s.agent,
+        mode: s.mode,
+        root: s.root,
+        repoName: s.repoName,
+        repoPath: s.repoPath,
+        worktreeName: s.worktreeName,
+        branchName: s.branchName,
+        displayName: s.displayName,
+        createdAt: s.createdAt,
+        lastActivity: s.lastActivity,
+        idle: s.idle,
+        cwd: s.cwd,
+        customCommand: s.customCommand,
+        useTmux: s.mode === 'pty' ? s.useTmux : false,
+        tmuxSessionName: s.mode === 'pty' ? s.tmuxSessionName : '',
+        status: s.status,
+        needsBranchRename: s.needsBranchRename,
     }))
         .sort((a, b) => b.lastActivity.localeCompare(a.lastActivity));
 }
@@ -270,20 +116,25 @@ function kill(id) {
     if (!session) {
         throw new Error(`Session not found: ${id}`);
     }
-    try {
-        session.pty.kill('SIGTERM');
-    }
-    catch {
-        // PTY may already be dead (e.g. disconnected sessions) — still delete from registry
+    if (session.mode === 'pty') {
+        try {
+            session.pty.kill('SIGTERM');
+        }
+        catch {
+            // PTY may already be dead (e.g. disconnected sessions) — still delete from registry
+        }
+        if (session.tmuxSessionName) {
+            execFile('tmux', ['kill-session', '-t', session.tmuxSessionName], () => { });
+        }
     }
-    if (session.tmuxSessionName) {
-        execFile('tmux', ['kill-session', '-t', session.tmuxSessionName], () => { });
+    else if (session.mode === 'sdk') {
+        killSdkSession(id);
     }
     sessions.delete(id);
 }
 function killAllTmuxSessions() {
     for (const session of sessions.values()) {
-        if (session.tmuxSessionName) {
+        if (session.mode === 'pty' && session.tmuxSessionName) {
             execFile('tmux', ['kill-session', '-t', session.tmuxSessionName], () => { });
         }
     }
@@ -293,14 +144,25 @@ function resize(id, cols, rows) {
     if (!session) {
         throw new Error(`Session not found: ${id}`);
     }
-    session.pty.resize(cols, rows);
+    if (session.mode === 'pty') {
+        session.pty.resize(cols, rows);
+    }
+    // SDK sessions don't support resize (no PTY)
 }
 function write(id, data) {
     const session = sessions.get(id);
     if (!session) {
         throw new Error(`Session not found: ${id}`);
     }
-    session.pty.write(data);
+    if (session.mode === 'pty') {
+        session.pty.write(data);
+    }
+    else if (session.mode === 'sdk') {
+        sdkSendMessage(id, data);
+    }
+}
+function handlePermission(id, requestId, approved) {
+    sdkHandlePermission(id, requestId, approved);
 }
 function findRepoSession(repoPath) {
     return list().find((s) => s.type === 'repo' && s.repoPath === repoPath);
@@ -311,33 +173,40 @@ function nextTerminalName() {
 function serializeAll(configDir) {
     const scrollbackDirPath = path.join(configDir, 'scrollback');
     fs.mkdirSync(scrollbackDirPath, { recursive: true });
-    const serialized = [];
+    const serializedPty = [];
+    const serializedSdk = [];
     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,
-        });
+        if (session.mode === 'pty') {
+            // Write scrollback to disk
+            const scrollbackPath = path.join(scrollbackDirPath, session.id + '.buf');
+            fs.writeFileSync(scrollbackPath, session.scrollback.join(''), 'utf-8');
+            serializedPty.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,
+            });
+        }
+        else if (session.mode === 'sdk') {
+            serializedSdk.push(serializeSdkSession(session));
+        }
     }
     const pending = {
         version: 1,
         timestamp: new Date().toISOString(),
-        sessions: serialized,
+        sessions: serializedPty,
+        sdkSessions: serializedSdk.length > 0 ? serializedSdk : undefined,
     };
     fs.writeFileSync(path.join(configDir, 'pending-sessions.json'), JSON.stringify(pending, null, 2), 'utf-8');
 }
@@ -360,6 +229,7 @@ async function restoreFromDisk(configDir) {
     }
     const scrollbackDirPath = path.join(configDir, 'scrollback');
     let restored = 0;
+    // Restore PTY sessions
     for (const s of pending.sessions) {
         // Load scrollback from disk
         let initialScrollback;
@@ -436,6 +306,18 @@ async function restoreFromDisk(configDir) {
         }
         catch { /* ignore */ }
     }
+    // Restore SDK sessions (as disconnected — they can't resume a live process)
+    if (pending.sdkSessions) {
+        for (const sdkData of pending.sdkSessions) {
+            try {
+                restoreSdkSession(sdkData, sessions);
+                restored++;
+            }
+            catch {
+                console.error(`Failed to restore SDK session ${sdkData.id} (${sdkData.displayName})`);
+            }
+        }
+    }
     // Clean up
     try {
         fs.unlinkSync(pendingPath);
@@ -451,9 +333,55 @@ async function restoreFromDisk(configDir) {
 function activeTmuxSessionNames() {
     const names = new Set();
     for (const session of sessions.values()) {
-        if (session.tmuxSessionName)
+        if (session.mode === 'pty' && 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 };
+// SDK idle sweep: check every 60s, terminate SDK sessions idle > 30min, max 5 idle
+let sdkIdleSweepTimer = null;
+function startSdkIdleSweep() {
+    if (sdkIdleSweepTimer)
+        return;
+    sdkIdleSweepTimer = setInterval(() => {
+        const now = Date.now();
+        const sdkSessions = [];
+        for (const session of sessions.values()) {
+            if (session.mode === 'sdk') {
+                sdkSessions.push(session);
+            }
+        }
+        // Terminate sessions idle > 30 minutes
+        for (const session of sdkSessions) {
+            const lastActivity = new Date(session.lastActivity).getTime();
+            if (session.idle && (now - lastActivity) > SDK_MAX_IDLE_MS) {
+                console.log(`SDK idle sweep: terminating session ${session.id} (${session.displayName}) — idle for ${Math.round((now - lastActivity) / 60000)}min`);
+                try {
+                    kill(session.id);
+                }
+                catch { /* already dead */ }
+            }
+        }
+        // LRU eviction: if more than 5 idle SDK sessions remain, evict oldest
+        const idleSdkSessions = Array.from(sessions.values())
+            .filter((s) => s.mode === 'sdk' && s.idle)
+            .sort((a, b) => a.lastActivity.localeCompare(b.lastActivity));
+        while (idleSdkSessions.length > SDK_MAX_IDLE_SESSIONS) {
+            const oldest = idleSdkSessions.shift();
+            console.log(`SDK idle sweep: evicting session ${oldest.id} (${oldest.displayName}) — LRU`);
+            try {
+                kill(oldest.id);
+            }
+            catch { /* already dead */ }
+        }
+    }, SDK_IDLE_CHECK_INTERVAL_MS);
+}
+function stopSdkIdleSweep() {
+    if (sdkIdleSweepTimer) {
+        clearInterval(sdkIdleSweepTimer);
+        sdkIdleSweepTimer = null;
+    }
+}
+// Re-export pty-handler utilities for backward compatibility
+export { generateTmuxSessionName, resolveTmuxSpawn } from './pty-handler.js';
+export { create, get, list, kill, killAllTmuxSessions, resize, updateDisplayName, write, handlePermission, onIdleChange, offIdleChange, findRepoSession, nextTerminalName, serializeAll, restoreFromDisk, activeTmuxSessionNames, startSdkIdleSweep, stopSdkIdleSweep, AGENT_COMMANDS, AGENT_CONTINUE_ARGS, AGENT_YOLO_ARGS };

package/dist/server/types.js

@@ -1,3 +1,16 @@
+// Agent command records (shared by PTY and SDK handlers)
+export const AGENT_COMMANDS = {
+    claude: 'claude',
+    codex: 'codex',
+};
+export const AGENT_CONTINUE_ARGS = {
+    claude: ['--continue'],
+    codex: ['resume', '--last'],
+};
+export const AGENT_YOLO_ARGS = {
+    claude: ['--dangerously-skip-permissions'],
+    codex: ['--full-auto'],
+};
 export const MOUNTAIN_NAMES = [
     'everest', 'kilimanjaro', 'denali', 'fuji', 'rainier', 'matterhorn',
     'elbrus', 'aconcagua', 'kangchenjunga', 'lhotse', 'makalu', 'cho-oyu',