npm - claude-remote-cli - Versions diffs - 2.7.0 → 2.9.0 - Mend

claude-remote-cli 2.7.0 → 2.9.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 (14) hide show

package/README.md +5 -2
package/dist/frontend/assets/index-B3mDW63X.css +32 -0
package/dist/frontend/assets/index-Dkj00kFR.js +47 -0
package/dist/frontend/index.html +2 -2
package/dist/server/config.js +1 -0
package/dist/server/index.js +97 -10
package/dist/server/sessions.js +25 -9
package/dist/server/watcher.js +26 -0
package/dist/test/config.test.js +2 -0
package/dist/test/sessions.test.js +35 -0
package/dist/test/worktrees.test.js +86 -1
package/package.json +1 -1
package/dist/frontend/assets/index-C2nVSRxb.js +0 -47
package/dist/frontend/assets/index-Not5cXLa.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-C2nVSRxb.js"></script>
-  <link rel="stylesheet" crossorigin href="/assets/index-Not5cXLa.css">
+  <script type="module" crossorigin src="/assets/index-Dkj00kFR.js"></script>
+  <link rel="stylesheet" crossorigin href="/assets/index-B3mDW63X.css">
 </head>
 <body>
   <div id="app"></div>

package/dist/server/config.js CHANGED Viewed

@@ -8,6 +8,7 @@ export const DEFAULTS = {
     repos: [],
     claudeCommand: 'claude',
     claudeArgs: [],
+    defaultAgent: 'claude',
 };
 export function loadConfig(configPath) {
     if (!fs.existsSync(configPath)) {

package/dist/server/index.js CHANGED Viewed

@@ -11,8 +11,9 @@ 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 } from './sessions.js';
 import { setupWebSocket } from './ws.js';
-import { WorktreeWatcher, WORKTREE_DIRS, isValidWorktreePath, parseWorktreeListPorcelain } from './watcher.js';
+import { WorktreeWatcher, WORKTREE_DIRS, isValidWorktreePath, parseWorktreeListPorcelain, parseAllWorktrees } from './watcher.js';
 import { isInstalled as serviceIsInstalled } from './service.js';
 import { extensionForMime, setClipboardImage } from './clipboard.js';
 const __filename = fileURLToPath(import.meta.url);
@@ -500,6 +501,21 @@ async function main() {
         broadcastEvent('worktrees-changed');
         res.json(config.rootDirs);
     });
+    // GET /config/defaultAgent — get default coding agent
+    app.get('/config/defaultAgent', requireAuth, (_req, res) => {
+        res.json({ defaultAgent: config.defaultAgent || 'claude' });
+    });
+    // PATCH /config/defaultAgent — set default coding agent
+    app.patch('/config/defaultAgent', requireAuth, (req, res) => {
+        const { defaultAgent } = req.body;
+        if (!defaultAgent || (defaultAgent !== 'claude' && defaultAgent !== 'codex')) {
+            res.status(400).json({ error: 'defaultAgent must be "claude" or "codex"' });
+            return;
+        }
+        config.defaultAgent = defaultAgent;
+        saveConfig(CONFIG_PATH, config);
+        res.json({ defaultAgent: config.defaultAgent });
+    });
     // DELETE /worktrees — remove a worktree, prune, and delete its branch
     app.delete('/worktrees', requireAuth, async (req, res) => {
         const { worktreePath, repoPath } = req.body;
@@ -507,9 +523,22 @@ async function main() {
             res.status(400).json({ error: 'worktreePath and repoPath are required' });
             return;
         }
-        if (!isValidWorktreePath(worktreePath)) {
-            res.status(400).json({ error: 'Path is not inside a worktree directory' });
-            return;
+        // Validate the path is a real git worktree (not the main worktree)
+        try {
+            const { stdout: wtListOut } = await execFileAsync('git', ['worktree', 'list', '--porcelain'], { cwd: repoPath });
+            const allWorktrees = parseAllWorktrees(wtListOut, repoPath);
+            const isKnownWorktree = allWorktrees.some(wt => wt.path === path.resolve(worktreePath) && !wt.isMain);
+            if (!isKnownWorktree) {
+                res.status(400).json({ error: 'Path is not a recognized git worktree' });
+                return;
+            }
+        }
+        catch {
+            // If git worktree list fails, fall back to the directory-name check
+            if (!isValidWorktreePath(worktreePath)) {
+                res.status(400).json({ error: 'Path is not inside a worktree directory' });
+                return;
+            }
         }
         // Check no active session is using this worktree
         const activeSessions = sessions.list();
@@ -561,11 +590,12 @@ async function main() {
     });
     // POST /sessions
     app.post('/sessions', requireAuth, async (req, res) => {
-        const { repoPath, repoName, worktreePath, branchName, claudeArgs } = req.body;
+        const { repoPath, repoName, worktreePath, branchName, claudeArgs, agent } = req.body;
         if (!repoPath) {
             res.status(400).json({ error: 'repoPath is required' });
             return;
         }
+        const resolvedAgent = agent || config.defaultAgent || 'claude';
         const name = repoName || repoPath.split('/').filter(Boolean).pop() || 'session';
         const baseArgs = [...(config.claudeArgs || []), ...(claudeArgs || [])];
         // Compute root by matching repoPath against configured rootDirs
@@ -578,7 +608,7 @@ async function main() {
         let resolvedBranch = '';
         if (worktreePath) {
             // Resume existing worktree
-            args = ['--continue', ...baseArgs];
+            args = [...AGENT_CONTINUE_ARGS[resolvedAgent], ...baseArgs];
             cwd = worktreePath;
             sessionRepoPath = worktreePath;
             worktreeName = worktreePath.split('/').pop() || '';
@@ -620,6 +650,62 @@ async function main() {
                     }
                 }
                 if (branchName && branchExists) {
+                    // Check if branch is already checked out in an existing worktree
+                    const { stdout: wtListOut } = await execFileAsync('git', ['worktree', 'list', '--porcelain'], { cwd: repoPath });
+                    const allWorktrees = parseAllWorktrees(wtListOut, repoPath);
+                    const existingWt = allWorktrees.find(wt => wt.branch === branchName);
+                    if (existingWt) {
+                        // Branch already checked out — redirect to the existing worktree
+                        if (existingWt.isMain) {
+                            // Main worktree → create a repo session
+                            const existingRepoSession = sessions.findRepoSession(repoPath);
+                            if (existingRepoSession) {
+                                res.status(409).json({ error: 'A session already exists for this repo', sessionId: existingRepoSession.id });
+                                return;
+                            }
+                            const repoSession = sessions.create({
+                                type: 'repo',
+                                agent: resolvedAgent,
+                                repoName: name,
+                                repoPath,
+                                cwd: repoPath,
+                                root,
+                                displayName: name,
+                                args: baseArgs,
+                            });
+                            res.status(201).json(repoSession);
+                            return;
+                        }
+                        else {
+                            // Another worktree → create a worktree session with --continue
+                            cwd = existingWt.path;
+                            sessionRepoPath = existingWt.path;
+                            worktreeName = existingWt.path.split('/').pop() || '';
+                            args = [...AGENT_CONTINUE_ARGS[resolvedAgent], ...baseArgs];
+                            const displayNameVal = branchName || worktreeName;
+                            const session = sessions.create({
+                                type: 'worktree',
+                                agent: resolvedAgent,
+                                repoName: name,
+                                repoPath: sessionRepoPath,
+                                cwd,
+                                root,
+                                worktreeName,
+                                branchName: branchName || worktreeName,
+                                displayName: displayNameVal,
+                                args,
+                                configPath: CONFIG_PATH,
+                            });
+                            writeMeta(CONFIG_PATH, {
+                                worktreePath: sessionRepoPath,
+                                displayName: displayNameVal,
+                                lastActivity: new Date().toISOString(),
+                                branchName: branchName || worktreeName,
+                            });
+                            res.status(201).json(session);
+                            return;
+                        }
+                    }
                     await execFileAsync('git', ['worktree', 'add', targetDir, resolvedBranch], { cwd: repoPath });
                 }
                 else if (branchName) {
@@ -641,6 +727,7 @@ async function main() {
         const displayName = branchName || worktreeName;
         const session = sessions.create({
             type: 'worktree',
+            agent: resolvedAgent,
             repoName: name,
             repoPath: sessionRepoPath,
             cwd,
@@ -648,7 +735,6 @@ async function main() {
             worktreeName,
             branchName: branchName || worktreeName,
             displayName,
-            command: config.claudeCommand,
             args,
             configPath: CONFIG_PATH,
         });
@@ -664,11 +750,12 @@ 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 } = req.body;
+        const { repoPath, repoName, continue: continueSession, claudeArgs, agent } = req.body;
         if (!repoPath) {
             res.status(400).json({ error: 'repoPath is required' });
             return;
         }
+        const resolvedAgent = agent || config.defaultAgent || 'claude';
         // One repo session at a time
         const existing = sessions.findRepoSession(repoPath);
         if (existing) {
@@ -677,17 +764,17 @@ async function main() {
         }
         const name = repoName || repoPath.split('/').filter(Boolean).pop() || 'session';
         const baseArgs = [...(config.claudeArgs || []), ...(claudeArgs || [])];
-        const args = continueSession ? ['--continue', ...baseArgs] : [...baseArgs];
+        const args = continueSession ? [...AGENT_CONTINUE_ARGS[resolvedAgent], ...baseArgs] : [...baseArgs];
         const roots = config.rootDirs || [];
         const root = roots.find(function (r) { return repoPath.startsWith(r); }) || '';
         const session = sessions.create({
             type: 'repo',
+            agent: resolvedAgent,
             repoName: name,
             repoPath,
             cwd: repoPath,
             root,
             displayName: name,
-            command: config.claudeCommand,
             args,
         });
         res.status(201).json(session);

package/dist/server/sessions.js CHANGED Viewed

@@ -4,6 +4,18 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { readMeta, writeMeta } from './config.js';
+const AGENT_COMMANDS = {
+    claude: 'claude',
+    codex: 'codex',
+};
+const AGENT_YOLO_ARGS = {
+    claude: ['--dangerously-skip-permissions'],
+    codex: ['--full-auto'],
+};
+const AGENT_CONTINUE_ARGS = {
+    claude: ['--continue'],
+    codex: ['resume', '--last'],
+};
 // In-memory registry: id -> Session
 const sessions = new Map();
 const IDLE_TIMEOUT_MS = 5000;
@@ -11,13 +23,14 @@ let idleChangeCallback = null;
 function onIdleChange(cb) {
     idleChangeCallback = cb;
 }
-function create({ type, 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 }) {
     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(command, args, {
+    const ptyProcess = pty.spawn(resolvedCommand, args, {
         name: 'xterm-256color',
         cols,
         rows,
@@ -31,6 +44,7 @@ function create({ type, repoName, repoPath, cwd, root, worktreeName, branchName,
     const session = {
         id,
         type: type || 'worktree',
+        agent,
         root: root || '',
         repoName: repoName || '',
         repoPath,
@@ -70,6 +84,7 @@ function create({ type, repoName, repoPath, cwd, root, worktreeName, branchName,
             }
         }, IDLE_TIMEOUT_MS);
     }
+    const continueArgs = AGENT_CONTINUE_ARGS[agent];
     function attachHandlers(proc, canRetry) {
         const spawnTime = Date.now();
         proc.onData((data) => {
@@ -89,12 +104,12 @@ function create({ type, repoName, repoPath, cwd, root, worktreeName, branchName,
             }
         });
         proc.onExit(({ exitCode }) => {
-            // If --continue failed quickly, retry without it
+            // If continue args failed quickly, retry without them
             if (canRetry && (Date.now() - spawnTime) < 3000 && exitCode !== 0) {
-                const retryArgs = args.filter(a => a !== '--continue');
+                const retryArgs = args.filter(a => !continueArgs.includes(a));
                 scrollback.length = 0;
                 scrollbackBytes = 0;
-                const retryPty = pty.spawn(command, retryArgs, {
+                const retryPty = pty.spawn(resolvedCommand, retryArgs, {
                     name: 'xterm-256color',
                     cols,
                     rows,
@@ -117,17 +132,18 @@ function create({ type, repoName, repoPath, cwd, root, worktreeName, branchName,
             fs.rm(tmpDir, { recursive: true, force: true }, () => { });
         });
     }
-    attachHandlers(ptyProcess, args.includes('--continue'));
-    return { id, type: session.type, root: session.root, repoName: session.repoName, repoPath, worktreeName: session.worktreeName, branchName: session.branchName, displayName: session.displayName, pid: ptyProcess.pid, createdAt, lastActivity: createdAt, idle: false };
+    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 };
 }
 function get(id) {
     return sessions.get(id);
 }
 function list() {
     return Array.from(sessions.values())
-        .map(({ id, type, root, repoName, repoPath, worktreeName, branchName, displayName, createdAt, lastActivity, idle }) => ({
+        .map(({ id, type, agent, root, repoName, repoPath, worktreeName, branchName, displayName, createdAt, lastActivity, idle }) => ({
         id,
         type,
+        agent,
         root,
         repoName,
         repoPath,
@@ -172,4 +188,4 @@ function write(id, data) {
 function findRepoSession(repoPath) {
     return list().find((s) => s.type === 'repo' && s.repoPath === repoPath);
 }
-export { create, get, list, kill, resize, updateDisplayName, write, onIdleChange, findRepoSession };
+export { create, get, list, kill, resize, updateDisplayName, write, onIdleChange, findRepoSession, AGENT_COMMANDS, AGENT_YOLO_ARGS, AGENT_CONTINUE_ARGS };

package/dist/server/watcher.js CHANGED Viewed

@@ -8,6 +8,32 @@ export function isValidWorktreePath(worktreePath) {
         return resolved.includes(path.sep + dir + path.sep);
     });
 }
+/**
+ * Parse `git worktree list --porcelain` output into ALL entries (including main worktree).
+ * Skips bare entries. Detached HEAD entries get empty branch string.
+ */
+export function parseAllWorktrees(stdout, repoPath) {
+    const results = [];
+    const blocks = stdout.split('\n\n').filter(Boolean);
+    for (const block of blocks) {
+        const lines = block.split('\n');
+        let wtPath = '';
+        let branch = '';
+        let bare = false;
+        for (const line of lines) {
+            if (line.startsWith('worktree '))
+                wtPath = line.slice(9);
+            if (line.startsWith('branch refs/heads/'))
+                branch = line.slice(18);
+            if (line === 'bare')
+                bare = true;
+        }
+        if (!wtPath || bare)
+            continue;
+        results.push({ path: wtPath, branch, isMain: wtPath === repoPath });
+    }
+    return results;
+}
 /**
  * Parse `git worktree list --porcelain` output into structured entries.
  * Skips the main worktree (matching repoPath) and bare/detached entries.

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

@@ -40,6 +40,7 @@ test('loadConfig merges with defaults for missing fields', () => {
     assert.deepEqual(config.repos, DEFAULTS.repos);
     assert.equal(config.claudeCommand, DEFAULTS.claudeCommand);
     assert.deepEqual(config.claudeArgs, DEFAULTS.claudeArgs);
+    assert.equal(config.defaultAgent, DEFAULTS.defaultAgent);
 });
 test('loadConfig throws if config file not found', () => {
     const configPath = path.join(tmpDir, 'nonexistent.json');
@@ -59,6 +60,7 @@ test('DEFAULTS has expected keys and values', () => {
     assert.deepEqual(DEFAULTS.repos, []);
     assert.equal(DEFAULTS.claudeCommand, 'claude');
     assert.deepEqual(DEFAULTS.claudeArgs, []);
+    assert.equal(DEFAULTS.defaultAgent, 'claude');
 });
 test('ensureMetaDir creates worktree-meta directory', () => {
     const configPath = path.join(tmpDir, 'config.json');

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

@@ -264,4 +264,39 @@ describe('sessions', () => {
         createdIds.push(result.id);
         assert.strictEqual(result.branchName, '');
     });
+    it('agent defaults to claude when not specified', () => {
+        const result = sessions.create({
+            repoName: 'test-repo',
+            repoPath: '/tmp',
+            command: '/bin/echo',
+            args: ['hello'],
+        });
+        createdIds.push(result.id);
+        assert.strictEqual(result.agent, 'claude');
+    });
+    it('agent is set when specified', () => {
+        const result = sessions.create({
+            repoName: 'test-repo',
+            repoPath: '/tmp',
+            agent: 'codex',
+            command: '/bin/echo',
+            args: ['hello'],
+        });
+        createdIds.push(result.id);
+        assert.strictEqual(result.agent, 'codex');
+    });
+    it('list includes agent field', () => {
+        const result = sessions.create({
+            repoName: 'test-repo',
+            repoPath: '/tmp',
+            agent: 'codex',
+            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.agent, 'codex');
+    });
 });

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

@@ -1,6 +1,6 @@
 import { describe, it } from 'node:test';
 import assert from 'node:assert/strict';
-import { WORKTREE_DIRS, isValidWorktreePath, parseWorktreeListPorcelain } from '../server/watcher.js';
+import { WORKTREE_DIRS, isValidWorktreePath, parseWorktreeListPorcelain, parseAllWorktrees } from '../server/watcher.js';
 describe('worktree directories constant', () => {
     it('should include both .worktrees and .claude/worktrees', () => {
         assert.deepEqual(WORKTREE_DIRS, ['.worktrees', '.claude/worktrees']);
@@ -146,6 +146,91 @@ describe('parseWorktreeListPorcelain', () => {
         assert.equal(result[0].branch, 'dy/feat/deep/nesting/here');
     });
 });
+describe('parseAllWorktrees', () => {
+    const repoPath = '/Users/me/code/my-repo';
+    it('should include the main worktree with isMain=true', () => {
+        const stdout = [
+            `worktree ${repoPath}`,
+            'HEAD abc123',
+            'branch refs/heads/main',
+            '',
+        ].join('\n');
+        const result = parseAllWorktrees(stdout, repoPath);
+        assert.equal(result.length, 1);
+        assert.equal(result[0].path, repoPath);
+        assert.equal(result[0].branch, 'main');
+        assert.equal(result[0].isMain, true);
+    });
+    it('should mark non-main worktrees with isMain=false', () => {
+        const stdout = [
+            `worktree ${repoPath}`,
+            'HEAD abc123',
+            'branch refs/heads/main',
+            '',
+            'worktree /Users/me/code/my-repo/.worktrees/feat-branch',
+            'HEAD def456',
+            'branch refs/heads/feat/branch',
+            '',
+        ].join('\n');
+        const result = parseAllWorktrees(stdout, repoPath);
+        assert.equal(result.length, 2);
+        assert.equal(result[0].isMain, true);
+        assert.equal(result[1].isMain, false);
+        assert.equal(result[1].path, '/Users/me/code/my-repo/.worktrees/feat-branch');
+        assert.equal(result[1].branch, 'feat/branch');
+    });
+    it('should still skip bare entries', () => {
+        const stdout = [
+            `worktree ${repoPath}`,
+            'HEAD abc123',
+            'branch refs/heads/main',
+            '',
+            'worktree /some/bare/repo',
+            'HEAD def456',
+            'bare',
+            '',
+        ].join('\n');
+        const result = parseAllWorktrees(stdout, repoPath);
+        assert.equal(result.length, 1);
+        assert.equal(result[0].isMain, true);
+    });
+    it('should include detached HEAD entries with empty branch', () => {
+        const stdout = [
+            `worktree ${repoPath}`,
+            'HEAD abc123',
+            'branch refs/heads/main',
+            '',
+            'worktree /Users/me/code/my-repo/.worktrees/detached',
+            'HEAD def456',
+            'detached',
+            '',
+        ].join('\n');
+        const result = parseAllWorktrees(stdout, repoPath);
+        assert.equal(result.length, 2);
+        assert.equal(result[1].branch, '');
+    });
+    it('should handle empty output', () => {
+        const result = parseAllWorktrees('', repoPath);
+        assert.equal(result.length, 0);
+    });
+    it('should find worktree by branch name', () => {
+        const stdout = [
+            `worktree ${repoPath}`,
+            'HEAD abc123',
+            'branch refs/heads/dy/feat/worktree-isolation',
+            '',
+            'worktree /Users/me/code/my-repo/.worktrees/feat-a',
+            'HEAD def456',
+            'branch refs/heads/feat/a',
+            '',
+        ].join('\n');
+        const result = parseAllWorktrees(stdout, repoPath);
+        const match = result.find(wt => wt.branch === 'dy/feat/worktree-isolation');
+        assert.ok(match);
+        assert.equal(match.path, repoPath);
+        assert.equal(match.isMain, true);
+    });
+});
 describe('CLI worktree arg parsing', () => {
     it('should extract --yolo and leave other args intact', () => {
         const args = ['add', './.worktrees/my-feature', '-b', 'my-feature', '--yolo'];

package/package.json CHANGED Viewed

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