claude-remote-cli 2.0.0 → 2.1.0

package/dist/bin/claude-remote-cli.js

@@ -1,13 +1,17 @@
 #!/usr/bin/env node
 import path from 'node:path';
 import fs from 'node:fs';
-import { execFile } from 'node:child_process';
+import { execFile, spawn } from 'node:child_process';
 import { promisify } from 'node:util';
 import { fileURLToPath } from 'node:url';
 import * as service from '../server/service.js';
 import { DEFAULTS } from '../server/config.js';
 const execFileAsync = promisify(execFile);
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
+function execErrorMessage(err, fallback) {
+    const e = err;
+    return (e.stderr || e.message || fallback).trimEnd();
+}
 // Parse CLI flags
 const args = process.argv.slice(2);
 if (args.includes('--help') || args.includes('-h')) {
@@ -19,12 +23,17 @@ Commands:
   install            Install as a background service (survives reboot)
   uninstall          Stop and remove the background service
   status             Show whether the service is running
+  worktree           Manage git worktrees (wraps git worktree)
+    add [path] [-b branch] [--yolo]   Create worktree and launch Claude
+    remove <path>                      Forward to git worktree remove
+    list                               Forward to git worktree list
 
 Options:
   --bg               Shortcut: install and start as background service
   --port <port>      Override server port (default: 3456)
   --host <host>      Override bind address (default: 0.0.0.0)
   --config <path>    Path to config.json (default: ~/.config/claude-remote-cli/config.json)
+  --yolo             With 'worktree add': pass --dangerously-skip-permissions to Claude
   --version, -v      Show version
   --help, -h         Show this help`);
     process.exit(0);
@@ -87,6 +96,76 @@ if (command === 'update') {
     }
     process.exit(0);
 }
+if (command === 'worktree') {
+    const wtArgs = args.slice(1);
+    const subCommand = wtArgs[0];
+    if (!subCommand) {
+        console.error('Usage: claude-remote-cli worktree <add|remove|list> [options]');
+        process.exit(1);
+    }
+    if (subCommand !== 'add') {
+        try {
+            const result = await execFileAsync('git', ['worktree', ...wtArgs]);
+            if (result.stdout)
+                console.log(result.stdout.trimEnd());
+        }
+        catch (err) {
+            console.error(execErrorMessage(err, 'git worktree failed'));
+            process.exit(1);
+        }
+        process.exit(0);
+    }
+    // Handle 'add' -- strip --yolo, determine path, forward to git, then launch claude
+    const hasYolo = wtArgs.includes('--yolo');
+    const gitWtArgs = wtArgs.filter(function (a) { return a !== '--yolo'; });
+    const addSubArgs = gitWtArgs.slice(1);
+    let targetDir;
+    const bIdx = gitWtArgs.indexOf('-b');
+    const branchForDefault = bIdx !== -1 && bIdx + 1 < gitWtArgs.length ? gitWtArgs[bIdx + 1] : undefined;
+    if (addSubArgs.length === 0 || addSubArgs[0].startsWith('-')) {
+        let repoRoot;
+        try {
+            const result = await execFileAsync('git', ['rev-parse', '--show-toplevel']);
+            repoRoot = result.stdout.trim();
+        }
+        catch {
+            console.error('Not inside a git repository.');
+            process.exit(1);
+        }
+        const dirName = branchForDefault
+            ? branchForDefault.replace(/\//g, '-')
+            : 'worktree-' + Date.now().toString(36);
+        targetDir = path.join(repoRoot, '.worktrees', dirName);
+        gitWtArgs.splice(1, 0, targetDir);
+    }
+    else {
+        targetDir = path.resolve(addSubArgs[0]);
+    }
+    try {
+        const result = await execFileAsync('git', ['worktree', ...gitWtArgs]);
+        if (result.stdout)
+            console.log(result.stdout.trimEnd());
+    }
+    catch (err) {
+        console.error(execErrorMessage(err, 'git worktree add failed'));
+        process.exit(1);
+    }
+    console.log(`Worktree created at ${targetDir}`);
+    const claudeArgs = [];
+    if (hasYolo)
+        claudeArgs.push('--dangerously-skip-permissions');
+    console.log(`Launching claude${hasYolo ? ' (yolo mode)' : ''} in ${targetDir}...`);
+    const child = spawn('claude', claudeArgs, {
+        cwd: targetDir,
+        stdio: 'inherit',
+        env: { ...process.env, CLAUDECODE: undefined },
+    });
+    child.on('exit', (code) => {
+        process.exit(code ?? 0);
+    });
+    // Block until child exits via the handler above
+    await new Promise(() => { });
+}
 if (command === 'install' || command === 'uninstall' || command === 'status' || args.includes('--bg')) {
     if (command === 'uninstall') {
         runServiceCommand(() => { service.uninstall(); });

package/dist/server/index.js

@@ -12,7 +12,7 @@ import { loadConfig, saveConfig, DEFAULTS, readMeta, writeMeta, ensureMetaDir }
 import * as auth from './auth.js';
 import * as sessions from './sessions.js';
 import { setupWebSocket } from './ws.js';
-import { WorktreeWatcher } from './watcher.js';
+import { WorktreeWatcher, WORKTREE_DIRS, isValidWorktreePath } from './watcher.js';
 import { isInstalled as serviceIsInstalled } from './service.js';
 import { extensionForMime, setClipboardImage } from './clipboard.js';
 const __filename = fileURLToPath(import.meta.url);
@@ -59,6 +59,10 @@ async function getLatestVersion() {
         return null;
     }
 }
+function execErrorMessage(err, fallback) {
+    const e = err;
+    return (e.stderr || e.message || fallback).trim();
+}
 function parseTTL(ttl) {
     if (typeof ttl !== 'string')
         return 24 * 60 * 60 * 1000;
@@ -246,28 +250,30 @@ async function main() {
             reposToScan = scanAllRepos(roots);
         }
         for (const repo of reposToScan) {
-            const worktreeDir = path.join(repo.path, '.worktrees');
-            let entries;
-            try {
-                entries = fs.readdirSync(worktreeDir, { withFileTypes: true });
-            }
-            catch (_) {
-                continue;
-            }
-            for (const entry of entries) {
-                if (!entry.isDirectory())
+            for (const dir of WORKTREE_DIRS) {
+                const worktreeDir = path.join(repo.path, dir);
+                let entries;
+                try {
+                    entries = fs.readdirSync(worktreeDir, { withFileTypes: true });
+                }
+                catch (_) {
                     continue;
-                const wtPath = path.join(worktreeDir, entry.name);
-                const meta = readMeta(CONFIG_PATH, wtPath);
-                worktrees.push({
-                    name: entry.name,
-                    path: wtPath,
-                    repoName: repo.name,
-                    repoPath: repo.path,
-                    root: repo.root,
-                    displayName: meta ? meta.displayName : '',
-                    lastActivity: meta ? meta.lastActivity : '',
-                });
+                }
+                for (const entry of entries) {
+                    if (!entry.isDirectory())
+                        continue;
+                    const wtPath = path.join(worktreeDir, entry.name);
+                    const meta = readMeta(CONFIG_PATH, wtPath);
+                    worktrees.push({
+                        name: entry.name,
+                        path: wtPath,
+                        repoName: repo.name,
+                        repoPath: repo.path,
+                        root: repo.root,
+                        displayName: meta ? meta.displayName : '',
+                        lastActivity: meta ? meta.lastActivity : '',
+                    });
+                }
             }
         }
         res.json(worktrees);
@@ -315,9 +321,8 @@ async function main() {
             res.status(400).json({ error: 'worktreePath and repoPath are required' });
             return;
         }
-        // Validate the path is inside a .worktrees/ directory
-        if (!worktreePath.includes(path.sep + '.worktrees' + path.sep)) {
-            res.status(400).json({ error: 'Path is not inside a .worktrees/ directory' });
+        if (!isValidWorktreePath(worktreePath)) {
+            res.status(400).json({ error: 'Path is not inside a worktree directory' });
             return;
         }
         // Check no active session is using this worktree
@@ -335,9 +340,7 @@ async function main() {
             await execFileAsync('git', ['worktree', 'remove', worktreePath], { cwd: repoPath });
         }
         catch (err) {
-            const execErr = err;
-            const message = (execErr.stderr || execErr.message || 'Failed to remove worktree').trim();
-            res.status(500).json({ error: message });
+            res.status(500).json({ error: execErrorMessage(err, 'Failed to remove worktree') });
             return;
         }
         try {
@@ -427,9 +430,7 @@ async function main() {
                 }
             }
             catch (err) {
-                const execErr = err;
-                const message = (execErr.stderr || execErr.message || 'Failed to create worktree').trim();
-                res.status(500).json({ error: message });
+                res.status(500).json({ error: execErrorMessage(err, 'Failed to create worktree') });
                 return;
             }
             worktreeName = dirName;

package/dist/server/watcher.js

@@ -1,6 +1,13 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { EventEmitter } from 'node:events';
+export const WORKTREE_DIRS = ['.worktrees', '.claude/worktrees'];
+export function isValidWorktreePath(worktreePath) {
+    const resolved = path.resolve(worktreePath);
+    return WORKTREE_DIRS.some(function (dir) {
+        return resolved.includes(path.sep + dir + path.sep);
+    });
+}
 export class WorktreeWatcher extends EventEmitter {
     _watchers;
     _debounceTimer;
@@ -30,12 +37,16 @@ export class WorktreeWatcher extends EventEmitter {
         }
     }
     _watchRepo(repoPath) {
-        const worktreeDir = path.join(repoPath, '.worktrees');
-        if (fs.existsSync(worktreeDir)) {
-            this._addWatch(worktreeDir);
+        let anyWatched = false;
+        for (const dir of WORKTREE_DIRS) {
+            const worktreeDir = path.join(repoPath, dir);
+            if (fs.existsSync(worktreeDir)) {
+                this._addWatch(worktreeDir);
+                anyWatched = true;
+            }
         }
-        else {
-            // Watch the repo root so we detect when .worktrees/ is first created
+        if (!anyWatched) {
+            // Watch repo root so we detect when either dir is first created
             this._addWatch(repoPath);
         }
     }

package/package.json

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