npm - claude-remote-cli - Versions diffs - 2.15.16 → 3.0.3 - Mend

claude-remote-cli 2.15.16 → 3.0.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

package/dist/bin/claude-remote-cli.js +3 -0
package/dist/frontend/assets/index-BgOmCV-k.css +32 -0
package/dist/frontend/assets/index-CKQHbnTN.js +47 -0
package/dist/frontend/index.html +2 -2
package/dist/server/index.js +66 -2
package/dist/server/pty-handler.js +214 -0
package/dist/server/push.js +54 -3
package/dist/server/sdk-handler.js +536 -0
package/dist/server/sessions.js +183 -230
package/dist/server/types.js +13 -1
package/dist/server/ws.js +92 -9
package/dist/test/sessions.test.js +175 -6
package/package.json +3 -2
package/dist/frontend/assets/index-DQ-fMetm.js +0 -47
package/dist/frontend/assets/index-XlU0yxtO.css +0 -32

package/dist/frontend/index.html CHANGED Viewed

@@ -11,8 +11,8 @@
   <meta name="apple-mobile-web-app-capable" content="yes" />
   <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />
   <meta name="theme-color" content="#1a1a1a" />
-  <script type="module" crossorigin src="/assets/index-DQ-fMetm.js"></script>
-  <link rel="stylesheet" crossorigin href="/assets/index-XlU0yxtO.css">
+  <script type="module" crossorigin src="/assets/index-CKQHbnTN.js"></script>
+  <link rel="stylesheet" crossorigin href="/assets/index-BgOmCV-k.css">
 </head>
 <body>
   <div id="app"></div>

package/dist/server/index.js CHANGED Viewed

@@ -11,7 +11,7 @@ import cookieParser from 'cookie-parser';
 import { loadConfig, saveConfig, DEFAULTS, readMeta, writeMeta, deleteMeta, ensureMetaDir } from './config.js';
 import * as auth from './auth.js';
 import * as sessions from './sessions.js';
-import { AGENT_CONTINUE_ARGS, AGENT_YOLO_ARGS, serializeAll, restoreFromDisk, activeTmuxSessionNames } from './sessions.js';
+import { AGENT_CONTINUE_ARGS, AGENT_YOLO_ARGS, serializeAll, restoreFromDisk, activeTmuxSessionNames, startSdkIdleSweep, stopSdkIdleSweep } from './sessions.js';
 import { setupWebSocket } from './ws.js';
 import { WorktreeWatcher, WORKTREE_DIRS, isValidWorktreePath, parseWorktreeListPorcelain, parseAllWorktrees } from './watcher.js';
 import { isInstalled as serviceIsInstalled } from './service.js';
@@ -156,6 +156,12 @@ async function main() {
         config.port = parseInt(process.env.CLAUDE_REMOTE_PORT, 10);
     if (process.env.CLAUDE_REMOTE_HOST)
         config.host = process.env.CLAUDE_REMOTE_HOST;
+    // Enable SDK debug logging if requested
+    if (process.env.CLAUDE_REMOTE_DEBUG_LOG === '1' || config.debugLog) {
+        const { enableDebugLog } = await import('./sdk-handler.js');
+        enableDebugLog(true);
+        console.log('SDK debug logging enabled → ~/.config/claude-remote-cli/debug/');
+    }
     push.ensureVapidKeys(config, CONFIG_PATH, saveConfig);
     if (!config.pinHash) {
         const pin = await promptPin('Set up a PIN for claude-remote-cli:');
@@ -884,6 +890,58 @@ async function main() {
             res.status(404).json({ error: 'Session not found' });
         }
     });
+    // POST /sessions/:id/message — send message to SDK session
+    app.post('/sessions/:id/message', requireAuth, (req, res) => {
+        const id = req.params['id'];
+        const { text } = req.body;
+        if (!text) {
+            res.status(400).json({ error: 'text is required' });
+            return;
+        }
+        const session = sessions.get(id);
+        if (!session) {
+            res.status(404).json({ error: 'Session not found' });
+            return;
+        }
+        if (session.mode !== 'sdk') {
+            res.status(400).json({ error: 'Session is not an SDK session — use WebSocket for PTY sessions' });
+            return;
+        }
+        try {
+            sessions.write(id, text);
+            res.json({ ok: true });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Failed to send message';
+            res.status(500).json({ error: message });
+        }
+    });
+    // POST /sessions/:id/permission — handle permission approval for SDK session
+    app.post('/sessions/:id/permission', requireAuth, (req, res) => {
+        const id = req.params['id'];
+        const { requestId, approved } = req.body;
+        if (!requestId || typeof approved !== 'boolean') {
+            res.status(400).json({ error: 'requestId and approved are required' });
+            return;
+        }
+        const session = sessions.get(id);
+        if (!session) {
+            res.status(404).json({ error: 'Session not found' });
+            return;
+        }
+        if (session.mode !== 'sdk') {
+            res.status(400).json({ error: 'Session is not an SDK session' });
+            return;
+        }
+        try {
+            sessions.handlePermission(id, requestId, approved);
+            res.json({ ok: true });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Failed to handle permission';
+            res.status(500).json({ error: message });
+        }
+    });
     // PATCH /sessions/:id — update displayName and persist to metadata
     app.patch('/sessions/:id', requireAuth, (req, res) => {
         const { displayName } = req.body;
@@ -991,9 +1049,15 @@ async function main() {
     catch {
         // tmux not installed or no sessions — ignore
     }
+    // Start SDK idle sweep
+    startSdkIdleSweep();
     function gracefulShutdown() {
         server.close();
-        // Kill all active sessions (PTY + tmux)
+        stopSdkIdleSweep();
+        // Serialize sessions to disk BEFORE killing them
+        const configDir = path.dirname(CONFIG_PATH);
+        serializeAll(configDir);
+        // Kill all active sessions (PTY + tmux + SDK)
         for (const s of sessions.list()) {
             try {
                 sessions.kill(s.id);

package/dist/server/pty-handler.js ADDED Viewed

@@ -0,0 +1,214 @@
+import pty from 'node-pty';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { AGENT_COMMANDS, AGENT_CONTINUE_ARGS } from './types.js';
+import { readMeta, writeMeta } from './config.js';
+const IDLE_TIMEOUT_MS = 5000;
+const MAX_SCROLLBACK = 256 * 1024; // 256KB max
+export 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)}`;
+}
+export function resolveTmuxSpawn(command, args, tmuxSessionName) {
+    return {
+        command: 'tmux',
+        args: [
+            '-u', 'new-session', '-s', tmuxSessionName, '--', command, ...args,
+            ';', 'set', 'set-clipboard', 'on',
+            ';', 'set', 'allow-passthrough', 'on',
+            ';', 'set', 'mode-keys', 'vi',
+        ],
+    };
+}
+export function createPtySession(params, sessionsMap, idleChangeCallbacks) {
+    const { id, type, agent = 'claude', repoName, repoPath, cwd, root, worktreeName, branchName, displayName, command, args = [], cols = 80, rows = 24, configPath, useTmux: paramUseTmux, tmuxSessionName: paramTmuxSessionName, initialScrollback, restored: paramRestored, } = params;
+    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;
+    }
+    const ptyProcess = pty.spawn(spawnCommand, spawnArgs, {
+        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 resolvedCwd = cwd || repoPath;
+    const session = {
+        id,
+        type: type || 'worktree',
+        agent,
+        mode: 'pty',
+        root: root || '',
+        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,
+    };
+    sessionsMap.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 (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 {
+                    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 (restoredClearTimer)
+                        clearTimeout(restoredClearTimer);
+                    if (idleTimer)
+                        clearTimeout(idleTimer);
+                    if (metaFlushTimer)
+                        clearTimeout(metaFlushTimer);
+                    sessionsMap.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 });
+            }
+            sessionsMap.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)));
+    const result = {
+        id,
+        type: session.type,
+        agent: session.agent,
+        mode: 'pty',
+        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 { session, result };
+}

package/dist/server/push.js CHANGED Viewed

@@ -1,6 +1,7 @@
 import webpush from 'web-push';
 let vapidPublicKey = null;
 const subscriptions = new Map();
+const MAX_PAYLOAD_SIZE = 4 * 1024; // 4KB
 export function ensureVapidKeys(config, configPath, save) {
     if (config.vapidPublicKey && config.vapidPrivateKey) {
         vapidPublicKey = config.vapidPublicKey;
@@ -39,15 +40,65 @@ export function removeSession(sessionId) {
         entry.sessionIds.delete(sessionId);
     }
 }
-export function notifySessionIdle(sessionId, session) {
+export function enrichNotification(event) {
+    try {
+        switch (event.type) {
+            case 'tool_call': {
+                const action = event.toolName || 'use a tool';
+                const target = event.path || (event.toolInput && typeof event.toolInput === 'object'
+                    ? event.toolInput.file_path || event.toolInput.command || ''
+                    : '');
+                const msg = target
+                    ? `Claude wants to ${action} ${target}`
+                    : `Claude wants to ${action}`;
+                return msg.slice(0, 200);
+            }
+            case 'turn_completed':
+                return 'Claude finished';
+            case 'error': {
+                const brief = (event.text || 'unknown error').slice(0, 150);
+                return `Claude hit an error: ${brief}`;
+            }
+            default:
+                return 'Claude is waiting for your input';
+        }
+    }
+    catch {
+        return 'Claude is waiting for your input';
+    }
+}
+function truncatePayload(payload) {
+    if (payload.length <= MAX_PAYLOAD_SIZE)
+        return payload;
+    // Try to parse, truncate text fields, and re-serialize
+    try {
+        const obj = JSON.parse(payload);
+        if (typeof obj.enrichedMessage === 'string' && obj.enrichedMessage.length > 100) {
+            obj.enrichedMessage = obj.enrichedMessage.slice(0, 100) + '...';
+        }
+        const truncated = JSON.stringify(obj);
+        if (truncated.length <= MAX_PAYLOAD_SIZE)
+            return truncated;
+    }
+    catch {
+        // fall through
+    }
+    return payload.slice(0, MAX_PAYLOAD_SIZE);
+}
+export function notifySessionIdle(sessionId, session, sdkEvent) {
     if (!vapidPublicKey)
         return;
-    const payload = JSON.stringify({
+    const enrichedMessage = sdkEvent ? enrichNotification(sdkEvent) : undefined;
+    const payloadObj = {
         type: 'session-attention',
         sessionId,
         displayName: session.displayName,
         sessionType: session.type,
-    });
+    };
+    if (enrichedMessage) {
+        payloadObj.enrichedMessage = enrichedMessage;
+    }
+    const payload = truncatePayload(JSON.stringify(payloadObj));
     for (const [endpoint, entry] of subscriptions) {
         if (!entry.sessionIds.has(sessionId))
             continue;