npm - claude-remote-cli - Versions diffs - 2.11.0 → 2.12.0 - Mend

claude-remote-cli 2.11.0 → 2.12.0

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 (9) hide show

package/dist/frontend/assets/index-CEJznk5F.js +47 -0
package/dist/frontend/index.html +1 -1
package/dist/server/config.js +3 -0
package/dist/server/index.js +63 -2
package/dist/server/sessions.js +47 -6
package/dist/test/config.test.js +11 -0
package/dist/test/sessions.test.js +71 -0
package/package.json +1 -1
package/dist/frontend/assets/index-DLO1cUOf.js +0 -47

package/dist/frontend/index.html CHANGED Viewed

@@ -11,7 +11,7 @@
   <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-DLO1cUOf.js"></script>
+  <script type="module" crossorigin src="/assets/index-CEJznk5F.js"></script>
   <link rel="stylesheet" crossorigin href="/assets/index-nIPDa7NP.css">
 </head>
 <body>

package/dist/server/config.js CHANGED Viewed

@@ -9,6 +9,9 @@ export const DEFAULTS = {
     claudeCommand: 'claude',
     claudeArgs: [],
     defaultAgent: 'claude',
+    defaultContinue: true,
+    defaultYolo: false,
+    launchInTmux: false,
 };
 export function loadConfig(configPath) {
     if (!fs.existsSync(configPath)) {

package/dist/server/index.js CHANGED Viewed

@@ -193,6 +193,30 @@ async function main() {
         }
         next();
     };
+    function boolConfigEndpoints(name, defaultValue, onEnable) {
+        app.get(`/config/${name}`, requireAuth, (_req, res) => {
+            res.json({ [name]: config[name] ?? defaultValue });
+        });
+        app.patch(`/config/${name}`, requireAuth, async (req, res) => {
+            const value = req.body[name];
+            if (typeof value !== 'boolean') {
+                res.status(400).json({ error: `${name} must be a boolean` });
+                return;
+            }
+            if (value && onEnable) {
+                try {
+                    await onEnable();
+                }
+                catch {
+                    res.status(400).json({ error: `Validation failed for ${name}` });
+                    return;
+                }
+            }
+            config[name] = value;
+            saveConfig(CONFIG_PATH, config);
+            res.json({ [name]: value });
+        });
+    }
     const watcher = new WorktreeWatcher();
     watcher.rebuild(config.rootDirs || []);
     const server = http.createServer(app);
@@ -506,6 +530,11 @@ async function main() {
         saveConfig(CONFIG_PATH, config);
         res.json({ defaultAgent: config.defaultAgent });
     });
+    boolConfigEndpoints('defaultContinue', true);
+    boolConfigEndpoints('defaultYolo', false);
+    boolConfigEndpoints('launchInTmux', false, async () => {
+        await execFileAsync('tmux', ['-V']);
+    });
     // DELETE /worktrees — remove a worktree, prune, and delete its branch
     app.delete('/worktrees', requireAuth, async (req, res) => {
         const { worktreePath, repoPath } = req.body;
@@ -580,7 +609,7 @@ async function main() {
     });
     // POST /sessions
     app.post('/sessions', requireAuth, async (req, res) => {
-        const { repoPath, repoName, worktreePath, branchName, claudeArgs, yolo, agent } = req.body;
+        const { repoPath, repoName, worktreePath, branchName, claudeArgs, yolo, agent, useTmux } = req.body;
         if (!repoPath) {
             res.status(400).json({ error: 'repoPath is required' });
             return;
@@ -666,6 +695,7 @@ async function main() {
                                 root,
                                 displayName: name,
                                 args: baseArgs,
+                                useTmux: useTmux ?? config.launchInTmux,
                             });
                             res.status(201).json(repoSession);
                             return;
@@ -689,6 +719,7 @@ async function main() {
                                 displayName: displayNameVal,
                                 args,
                                 configPath: CONFIG_PATH,
+                                useTmux: useTmux ?? config.launchInTmux,
                             });
                             writeMeta(CONFIG_PATH, {
                                 worktreePath: sessionRepoPath,
@@ -731,6 +762,7 @@ async function main() {
             displayName,
             args,
             configPath: CONFIG_PATH,
+            useTmux: useTmux ?? config.launchInTmux,
         });
         if (!worktreePath) {
             writeMeta(CONFIG_PATH, {
@@ -744,7 +776,7 @@ async function main() {
     });
     // POST /sessions/repo — start a session in the repo root (no worktree)
     app.post('/sessions/repo', requireAuth, (req, res) => {
-        const { repoPath, repoName, continue: continueSession, claudeArgs, yolo, agent } = req.body;
+        const { repoPath, repoName, continue: continueSession, claudeArgs, yolo, agent, useTmux } = req.body;
         if (!repoPath) {
             res.status(400).json({ error: 'repoPath is required' });
             return;
@@ -774,6 +806,7 @@ async function main() {
             root,
             displayName: name,
             args,
+            useTmux: useTmux ?? config.launchInTmux,
         });
         res.status(201).json(session);
     });
@@ -889,6 +922,34 @@ async function main() {
             res.status(500).json({ ok: false, error: message });
         }
     });
+    // Clean up orphaned tmux sessions from previous runs
+    try {
+        const { stdout } = await execFileAsync('tmux', ['list-sessions', '-F', '#{session_name}']);
+        const crcSessions = stdout.trim().split('\n').filter(name => name.startsWith('crc-'));
+        for (const name of crcSessions) {
+            execFileAsync('tmux', ['kill-session', '-t', name]).catch(() => { });
+        }
+        if (crcSessions.length > 0) {
+            console.log(`Cleaned up ${crcSessions.length} orphaned tmux session(s).`);
+        }
+    }
+    catch {
+        // tmux not installed or no sessions — ignore
+    }
+    function gracefulShutdown() {
+        server.close();
+        // Kill all active sessions (PTY + tmux)
+        for (const s of sessions.list()) {
+            try {
+                sessions.kill(s.id);
+            }
+            catch { /* already exiting */ }
+        }
+        // Brief delay to let async tmux kill-session calls fire
+        setTimeout(() => process.exit(0), 200);
+    }
+    process.on('SIGTERM', gracefulShutdown);
+    process.on('SIGINT', gracefulShutdown);
     server.listen(config.port, config.host, () => {
         console.log(`claude-remote-cli listening on ${config.host}:${config.port}`);
     });

package/dist/server/sessions.js CHANGED Viewed

@@ -3,6 +3,7 @@ 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 { readMeta, writeMeta } from './config.js';
 const AGENT_COMMANDS = {
     claude: 'claude',
@@ -16,6 +17,16 @@ const AGENT_YOLO_ARGS = {
     claude: ['--dangerously-skip-permissions'],
     codex: ['--full-auto'],
 };
+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: ['new-session', '-s', tmuxSessionName, '--', command, ...args],
+    };
+}
 // In-memory registry: id -> Session
 const sessions = new Map();
 const IDLE_TIMEOUT_MS = 5000;
@@ -24,14 +35,23 @@ let idleChangeCallback = null;
 function onIdleChange(cb) {
     idleChangeCallback = cb;
 }
-function create({ type, agent = 'claude', repoName, repoPath, cwd, root, worktreeName, branchName, displayName, command, args = [], cols = 80, rows = 24, configPath }) {
+function create({ type, agent = 'claude', repoName, repoPath, cwd, root, worktreeName, branchName, displayName, command, args = [], cols = 80, rows = 24, configPath, useTmux: paramUseTmux }) {
     const id = 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 ptyProcess = pty.spawn(resolvedCommand, args, {
+    const useTmux = !command && !!paramUseTmux;
+    let spawnCommand = resolvedCommand;
+    let spawnArgs = args;
+    const tmuxSessionName = 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,
@@ -57,6 +77,8 @@ function create({ type, agent = 'claude', repoName, repoPath, cwd, root, worktre
         lastActivity: createdAt,
         scrollback,
         idle: false,
+        useTmux,
+        tmuxSessionName,
     };
     sessions.set(id, session);
     // Load existing metadata to preserve a previously-set displayName
@@ -110,7 +132,14 @@ function create({ type, agent = 'claude', repoName, repoPath, cwd, root, worktre
                 const retryArgs = args.filter(a => !continueArgs.includes(a));
                 scrollback.length = 0;
                 scrollbackBytes = 0;
-                const retryPty = pty.spawn(resolvedCommand, retryArgs, {
+                let retryCommand = resolvedCommand;
+                let retrySpawnArgs = retryArgs;
+                if (useTmux && tmuxSessionName) {
+                    const tmux = resolveTmuxSpawn(resolvedCommand, retryArgs, tmuxSessionName);
+                    retryCommand = tmux.command;
+                    retrySpawnArgs = tmux.args;
+                }
+                const retryPty = pty.spawn(retryCommand, retrySpawnArgs, {
                     name: 'xterm-256color',
                     cols,
                     rows,
@@ -134,14 +163,14 @@ function create({ type, agent = 'claude', repoName, repoPath, cwd, root, worktre
         });
     }
     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 };
+    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, useTmux, tmuxSessionName };
 }
 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 }) => ({
+        .map(({ id, type, agent, root, repoName, repoPath, worktreeName, branchName, displayName, createdAt, lastActivity, idle, useTmux, tmuxSessionName }) => ({
         id,
         type,
         agent,
@@ -154,6 +183,8 @@ function list() {
         createdAt,
         lastActivity,
         idle,
+        useTmux,
+        tmuxSessionName,
     }))
         .sort((a, b) => b.lastActivity.localeCompare(a.lastActivity));
 }
@@ -170,8 +201,18 @@ function kill(id) {
         throw new Error(`Session not found: ${id}`);
     }
     session.pty.kill('SIGTERM');
+    if (session.tmuxSessionName) {
+        execFile('tmux', ['kill-session', '-t', session.tmuxSessionName], () => { });
+    }
     sessions.delete(id);
 }
+function killAllTmuxSessions() {
+    for (const session of sessions.values()) {
+        if (session.tmuxSessionName) {
+            execFile('tmux', ['kill-session', '-t', session.tmuxSessionName], () => { });
+        }
+    }
+}
 function resize(id, cols, rows) {
     const session = sessions.get(id);
     if (!session) {
@@ -192,4 +233,4 @@ function findRepoSession(repoPath) {
 function nextTerminalName() {
     return `Terminal ${++terminalCounter}`;
 }
-export { create, get, list, kill, resize, updateDisplayName, write, onIdleChange, findRepoSession, nextTerminalName, AGENT_COMMANDS, AGENT_CONTINUE_ARGS, AGENT_YOLO_ARGS };
+export { create, get, list, kill, killAllTmuxSessions, resize, updateDisplayName, write, onIdleChange, findRepoSession, nextTerminalName, AGENT_COMMANDS, AGENT_CONTINUE_ARGS, AGENT_YOLO_ARGS, resolveTmuxSpawn, generateTmuxSessionName };

package/dist/test/config.test.js CHANGED Viewed

@@ -61,6 +61,17 @@ test('DEFAULTS has expected keys and values', () => {
     assert.equal(DEFAULTS.claudeCommand, 'claude');
     assert.deepEqual(DEFAULTS.claudeArgs, []);
     assert.equal(DEFAULTS.defaultAgent, 'claude');
+    assert.equal(DEFAULTS.defaultContinue, true);
+    assert.equal(DEFAULTS.defaultYolo, false);
+    assert.equal(DEFAULTS.launchInTmux, false);
+});
+test('loadConfig returns correct defaults for defaultContinue, defaultYolo, and launchInTmux', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    fs.writeFileSync(configPath, JSON.stringify({ port: 3456 }), 'utf8');
+    const config = loadConfig(configPath);
+    assert.equal(config.defaultContinue, true);
+    assert.equal(config.defaultYolo, false);
+    assert.equal(config.launchInTmux, false);
 });
 test('ensureMetaDir creates worktree-meta directory', () => {
     const configPath = path.join(tmpDir, 'config.json');

package/dist/test/sessions.test.js CHANGED Viewed

@@ -1,6 +1,7 @@
 import { describe, it, afterEach } from 'node:test';
 import assert from 'node:assert';
 import * as sessions from '../server/sessions.js';
+import { resolveTmuxSpawn, generateTmuxSessionName } from '../server/sessions.js';
 // Track created session IDs so we can clean up after each test
 const createdIds = [];
 afterEach(() => {
@@ -264,6 +265,38 @@ describe('sessions', () => {
         createdIds.push(result.id);
         assert.strictEqual(result.branchName, '');
     });
+    it('resolveTmuxSpawn returns correct tmux command and args', () => {
+        const result = resolveTmuxSpawn('claude', ['--continue'], 'test-session');
+        assert.deepStrictEqual(result, {
+            command: 'tmux',
+            args: ['new-session', '-s', 'test-session', '--', 'claude', '--continue'],
+        });
+    });
+    it('generateTmuxSessionName has crc- prefix', () => {
+        const name = generateTmuxSessionName('my-session', 'abcdef1234567890');
+        assert.ok(name.startsWith('crc-'), `expected crc- prefix, got: ${name}`);
+    });
+    it('generateTmuxSessionName sanitizes special characters', () => {
+        const name = generateTmuxSessionName('feat/auth-flow', 'abcdef1234567890');
+        assert.ok(name.startsWith('crc-feat-auth-flow-'), `expected sanitized name, got: ${name}`);
+    });
+    it('generateTmuxSessionName limits display name to 30 chars', () => {
+        const longName = 'a-very-long-display-name-that-exceeds-thirty-characters';
+        const id = 'abcdef1234567890';
+        const name = generateTmuxSessionName(longName, id);
+        // Format is crc-<sanitized up to 30>-<8 char id>
+        // The sanitized portion should be at most 30 chars
+        const withoutPrefix = name.slice('crc-'.length);
+        const parts = withoutPrefix.split('-');
+        const idPart = parts[parts.length - 1];
+        const displayPart = withoutPrefix.slice(0, withoutPrefix.length - idPart.length - 1);
+        assert.ok(displayPart.length <= 30, `display portion should be <= 30 chars, got: ${displayPart.length}`);
+    });
+    it('generateTmuxSessionName uses 8 chars from the provided id', () => {
+        const id = 'abcdef1234567890';
+        const name = generateTmuxSessionName('my-session', id);
+        assert.ok(name.endsWith(id.slice(0, 8)), `expected name to end with ${id.slice(0, 8)}, got: ${name}`);
+    });
     it('agent defaults to claude when not specified', () => {
         const result = sessions.create({
             repoName: 'test-repo',
@@ -299,4 +332,42 @@ describe('sessions', () => {
         assert.ok(session);
         assert.strictEqual(session.agent, 'codex');
     });
+    it('useTmux defaults to false when not specified', () => {
+        const result = sessions.create({
+            repoName: 'test-repo',
+            repoPath: '/tmp',
+            command: '/bin/echo',
+            args: ['hello'],
+        });
+        createdIds.push(result.id);
+        assert.strictEqual(result.useTmux, false);
+        assert.strictEqual(result.tmuxSessionName, '');
+    });
+    it('useTmux is disabled when custom command is provided even if useTmux is true', () => {
+        const result = sessions.create({
+            repoName: 'test-repo',
+            repoPath: '/tmp',
+            command: '/bin/echo',
+            args: ['hello'],
+            useTmux: true,
+        });
+        createdIds.push(result.id);
+        // Custom command sessions should never use tmux
+        assert.strictEqual(result.useTmux, false);
+        assert.strictEqual(result.tmuxSessionName, '');
+    });
+    it('list includes useTmux and tmuxSessionName fields', () => {
+        const result = sessions.create({
+            repoName: 'test-repo',
+            repoPath: '/tmp',
+            command: '/bin/echo',
+            args: ['hello'],
+        });
+        createdIds.push(result.id);
+        const list = sessions.list();
+        const session = list.find(s => s.id === result.id);
+        assert.ok(session);
+        assert.strictEqual(session.useTmux, false);
+        assert.strictEqual(session.tmuxSessionName, '');
+    });
 });

package/package.json CHANGED Viewed

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