claude-remote-cli 3.0.3 → 3.0.4

package/dist/server/sessions.js

@@ -1,93 +1,260 @@
+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 { 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';
+import { readMeta, writeMeta } from './config.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
-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;
+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',
+        ],
+    };
+}
 // 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 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 }) {
+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');
-    // 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)) {
-            return { ...sdkResult.result, pid: undefined };
-        }
-        // SDK init failed — fall through to PTY
+    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;
     }
-    // PTY path: codex, terminal, custom command, or SDK fallback
-    const ptyParams = {
+    // 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 = {
         id,
-        type,
+        type: type || 'worktree',
         agent,
-        repoName,
+        root: root || '',
+        repoName: repoName || '',
         repoPath,
-        cwd,
-        root,
-        worktreeName,
-        branchName,
-        displayName,
-        command,
-        args,
-        cols,
-        rows,
-        configPath,
-        useTmux: paramUseTmux,
-        tmuxSessionName: paramTmuxSessionName,
-        initialScrollback,
-        restored: paramRestored,
+        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 || '',
     };
-    const { result } = createPtySession(ptyParams, sessions, idleChangeCallbacks);
-    return result;
+    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 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' };
 }
 function get(id) {
     return sessions.get(id);
 }
 function list() {
     return Array.from(sessions.values())
-        .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,
+        .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,
     }))
         .sort((a, b) => b.lastActivity.localeCompare(a.lastActivity));
 }
@@ -103,25 +270,20 @@ function kill(id) {
     if (!session) {
         throw new Error(`Session not found: ${id}`);
     }
-    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], () => { });
-        }
+    try {
+        session.pty.kill('SIGTERM');
     }
-    else if (session.mode === 'sdk') {
-        killSdkSession(id);
+    catch {
+        // PTY may already be dead (e.g. disconnected sessions) — still delete from registry
+    }
+    if (session.tmuxSessionName) {
+        execFile('tmux', ['kill-session', '-t', session.tmuxSessionName], () => { });
     }
     sessions.delete(id);
 }
 function killAllTmuxSessions() {
     for (const session of sessions.values()) {
-        if (session.mode === 'pty' && session.tmuxSessionName) {
+        if (session.tmuxSessionName) {
             execFile('tmux', ['kill-session', '-t', session.tmuxSessionName], () => { });
         }
     }
@@ -131,25 +293,14 @@ function resize(id, cols, rows) {
     if (!session) {
         throw new Error(`Session not found: ${id}`);
     }
-    if (session.mode === 'pty') {
-        session.pty.resize(cols, rows);
-    }
-    // SDK sessions don't support resize (no PTY)
+    session.pty.resize(cols, rows);
 }
 function write(id, data) {
     const session = sessions.get(id);
     if (!session) {
         throw new Error(`Session not found: ${id}`);
     }
-    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);
+    session.pty.write(data);
 }
 function findRepoSession(repoPath) {
     return list().find((s) => s.type === 'repo' && s.repoPath === repoPath);
@@ -160,40 +311,33 @@ function nextTerminalName() {
 function serializeAll(configDir) {
     const scrollbackDirPath = path.join(configDir, 'scrollback');
     fs.mkdirSync(scrollbackDirPath, { recursive: true });
-    const serializedPty = [];
-    const serializedSdk = [];
+    const serialized = [];
     for (const session of sessions.values()) {
-        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));
-        }
+        // 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: serializedPty,
-        sdkSessions: serializedSdk.length > 0 ? serializedSdk : undefined,
+        sessions: serialized,
     };
     fs.writeFileSync(path.join(configDir, 'pending-sessions.json'), JSON.stringify(pending, null, 2), 'utf-8');
 }
@@ -216,7 +360,6 @@ 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;
@@ -293,18 +436,6 @@ 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);
@@ -320,55 +451,9 @@ async function restoreFromDisk(configDir) {
 function activeTmuxSessionNames() {
     const names = new Set();
     for (const session of sessions.values()) {
-        if (session.mode === 'pty' && session.tmuxSessionName)
+        if (session.tmuxSessionName)
             names.add(session.tmuxSessionName);
     }
     return names;
 }
-// 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, findRepoSession, nextTerminalName, serializeAll, restoreFromDisk, activeTmuxSessionNames, startSdkIdleSweep, stopSdkIdleSweep, AGENT_COMMANDS, AGENT_CONTINUE_ARGS, AGENT_YOLO_ARGS };
+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/server/types.js

@@ -1,13 +1,7 @@
-// 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',
+    'dhaulagiri', 'manaslu', 'annapurna', 'nanga-parbat', 'olympus',
+    'mont-blanc', 'k2', 'vinson', 'erebus', 'logan', 'puncak-jaya',
+    'wilhelm', 'cook', 'ararat', 'etna', 'shasta', 'whitney', 'hood',
+];