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

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

package/dist/frontend/assets/{index-C2nVSRxb.js → index-CUkDx_1l.js} +15 -15
package/dist/frontend/index.html +1 -1
package/dist/server/index.js +73 -4
package/dist/server/watcher.js +26 -0
package/dist/test/worktrees.test.js +86 -1
package/package.json +1 -1

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-C2nVSRxb.js"></script>
+  <script type="module" crossorigin src="/assets/index-CUkDx_1l.js"></script>
   <link rel="stylesheet" crossorigin href="/assets/index-Not5cXLa.css">
 </head>
 <body>

package/dist/server/index.js CHANGED Viewed

@@ -12,7 +12,7 @@ import { loadConfig, saveConfig, DEFAULTS, readMeta, writeMeta, deleteMeta, ensu
 import * as auth from './auth.js';
 import * as sessions 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);
@@ -507,9 +507,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();
@@ -620,6 +633,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',
+                                repoName: name,
+                                repoPath,
+                                cwd: repoPath,
+                                root,
+                                displayName: name,
+                                command: config.claudeCommand,
+                                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 = ['--continue', ...baseArgs];
+                            const displayNameVal = branchName || worktreeName;
+                            const session = sessions.create({
+                                type: 'worktree',
+                                repoName: name,
+                                repoPath: sessionRepoPath,
+                                cwd,
+                                root,
+                                worktreeName,
+                                branchName: branchName || worktreeName,
+                                displayName: displayNameVal,
+                                command: config.claudeCommand,
+                                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) {

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/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.8.0",
   "description": "Remote web interface for Claude Code CLI sessions",
   "type": "module",
   "main": "dist/server/index.js",