claude-remote-cli 3.9.4 → 3.9.5

package/dist/server/index.js

@@ -13,7 +13,7 @@ import * as auth from './auth.js';
 import * as sessions from './sessions.js';
 import { AGENT_CONTINUE_ARGS, AGENT_YOLO_ARGS, serializeAll, restoreFromDisk, activeTmuxSessionNames, populateMetaCache } from './sessions.js';
 import { setupWebSocket } from './ws.js';
-import { WorktreeWatcher, WORKTREE_DIRS, isValidWorktreePath, parseWorktreeListPorcelain, parseAllWorktrees } from './watcher.js';
+import { WorktreeWatcher, BranchWatcher, WORKTREE_DIRS, isValidWorktreePath, parseWorktreeListPorcelain, parseAllWorktrees } from './watcher.js';
 import { isInstalled as serviceIsInstalled } from './service.js';
 import { extensionForMime, setClipboardImage } from './clipboard.js';
 import { listBranches, isBranchStale } from './git.js';
@@ -235,6 +235,26 @@ async function main() {
     watcher.rebuild(config.workspaces || []);
     const server = http.createServer(app);
     const { broadcastEvent } = setupWebSocket(server, authenticatedTokens, watcher, CONFIG_PATH);
+    // Watch .git/HEAD files for branch changes and update active sessions
+    const branchWatcher = new BranchWatcher((cwdPath, newBranch) => {
+        for (const session of sessions.list()) {
+            if (session.repoPath === cwdPath || session.cwd === cwdPath) {
+                const raw = sessions.get(session.id);
+                if (raw) {
+                    raw.branchName = newBranch;
+                    broadcastEvent('session-renamed', {
+                        sessionId: session.id,
+                        branchName: newBranch,
+                        displayName: raw.displayName,
+                    });
+                }
+            }
+        }
+    });
+    branchWatcher.rebuild(config.workspaces || []);
+    watcher.on('worktrees-changed', () => {
+        branchWatcher.rebuild(config.workspaces || []);
+    });
     // Configure session defaults for hooks injection
     sessions.configure({ port: config.port, forceOutputParser: config.forceOutputParser ?? false });
     // Mount hooks router BEFORE auth middleware — hook callbacks come from localhost Claude Code
@@ -301,9 +321,43 @@ async function main() {
         });
         res.json({ ok: true });
     });
-    // GET /sessions
-    app.get('/sessions', requireAuth, (_req, res) => {
-        res.json(sessions.list());
+    // GET /sessions — enrich with live branch from git (rate-limited to avoid spawning git on every poll)
+    const branchRefreshCache = new Map(); // sessionId -> last refresh timestamp
+    const BRANCH_REFRESH_INTERVAL_MS = 10_000;
+    app.get('/sessions', requireAuth, async (_req, res) => {
+        const allSessions = sessions.list();
+        const now = Date.now();
+        // Prune cache entries for sessions that no longer exist
+        const activeIds = new Set(allSessions.map((s) => s.id));
+        for (const sessionId of branchRefreshCache.keys()) {
+            if (!activeIds.has(sessionId))
+                branchRefreshCache.delete(sessionId);
+        }
+        await Promise.all(allSessions.map(async (s) => {
+            if (s.type !== 'repo' && s.type !== 'worktree')
+                return;
+            if (!s.repoPath)
+                return;
+            const lastRefresh = branchRefreshCache.get(s.id) ?? 0;
+            if (now - lastRefresh < BRANCH_REFRESH_INTERVAL_MS)
+                return;
+            const cwd = s.type === 'repo' ? s.repoPath : s.cwd;
+            if (!cwd)
+                return;
+            branchRefreshCache.set(s.id, now);
+            try {
+                const { stdout } = await execFileAsync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd });
+                const liveBranch = stdout.trim();
+                if (liveBranch && liveBranch !== s.branchName) {
+                    s.branchName = liveBranch;
+                    const raw = sessions.get(s.id);
+                    if (raw)
+                        raw.branchName = liveBranch;
+                }
+            }
+            catch { /* non-fatal */ }
+        }));
+        res.json(allSessions);
     });
     // GET /repos — scan root dirs for repos
     app.get('/repos', requireAuth, async (_req, res) => {
@@ -947,6 +1001,7 @@ async function main() {
     }
     function gracefulShutdown() {
         closeAnalytics();
+        branchWatcher.close();
         server.close();
         // Serialize sessions to disk BEFORE killing them
         const configDir = path.dirname(CONFIG_PATH);

package/dist/server/watcher.js

@@ -1,6 +1,9 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
 import { EventEmitter } from 'node:events';
+const execFileAsync = promisify(execFile);
 export const WORKTREE_DIRS = ['.worktrees', '.claude/worktrees'];
 export function isValidWorktreePath(worktreePath) {
     const resolved = path.resolve(worktreePath);
@@ -137,3 +140,124 @@ export class WorktreeWatcher extends EventEmitter {
         this._closeAll();
     }
 }
+export class BranchWatcher {
+    _watchers = [];
+    _debounceTimers = new Map();
+    _lastBranch = new Map();
+    _callback;
+    constructor(callback) {
+        this._callback = callback;
+    }
+    rebuild(rootDirs) {
+        this._closeAll();
+        for (const rootDir of rootDirs) {
+            let entries;
+            try {
+                entries = fs.readdirSync(rootDir, { withFileTypes: true });
+            }
+            catch (_) {
+                continue;
+            }
+            for (const entry of entries) {
+                if (!entry.isDirectory() || entry.name.startsWith('.'))
+                    continue;
+                const repoPath = path.join(rootDir, entry.name);
+                if (!fs.existsSync(path.join(repoPath, '.git')))
+                    continue;
+                this._watchRepoHeads(repoPath);
+            }
+        }
+    }
+    _watchRepoHeads(repoPath) {
+        // Watch main repo HEAD
+        const mainHead = path.join(repoPath, '.git', 'HEAD');
+        this._watchHeadFile(mainHead, repoPath);
+        // Watch worktree HEADs: <repoPath>/.git/worktrees/*/HEAD
+        const worktreesGitDir = path.join(repoPath, '.git', 'worktrees');
+        let wtEntries;
+        try {
+            wtEntries = fs.readdirSync(worktreesGitDir, { withFileTypes: true });
+        }
+        catch (_) {
+            return; // No worktrees
+        }
+        for (const entry of wtEntries) {
+            if (!entry.isDirectory())
+                continue;
+            const wtGitDir = path.join(worktreesGitDir, entry.name);
+            const headFile = path.join(wtGitDir, 'HEAD');
+            if (!fs.existsSync(headFile))
+                continue;
+            // Map worktree git dir back to checkout path via gitdir file
+            const gitdirFile = path.join(wtGitDir, 'gitdir');
+            let checkoutPath;
+            try {
+                const gitdirContent = fs.readFileSync(gitdirFile, 'utf-8').trim();
+                // gitdir contains <checkoutPath>/.git — strip the /.git suffix
+                checkoutPath = gitdirContent.replace(/\/\.git\/?$/, '');
+            }
+            catch (_) {
+                continue;
+            }
+            this._watchHeadFile(headFile, checkoutPath);
+        }
+    }
+    _watchHeadFile(headPath, cwdPath) {
+        // Seed initial branch to avoid false-positive on first change detection
+        try {
+            const content = fs.readFileSync(headPath, 'utf-8').trim();
+            const match = content.match(/^ref: refs\/heads\/(.+)$/);
+            if (match)
+                this._lastBranch.set(cwdPath, match[1]);
+        }
+        catch (_) { }
+        try {
+            const watcher = fs.watch(headPath, { persistent: false }, () => {
+                this._debouncedCheck(cwdPath);
+            });
+            watcher.on('error', () => { });
+            this._watchers.push(watcher);
+        }
+        catch (_) { }
+    }
+    _debouncedCheck(cwdPath) {
+        const existing = this._debounceTimers.get(cwdPath);
+        if (existing)
+            clearTimeout(existing);
+        this._debounceTimers.set(cwdPath, setTimeout(() => {
+            this._debounceTimers.delete(cwdPath);
+            this._readAndEmit(cwdPath);
+        }, 300));
+    }
+    async _readAndEmit(cwdPath) {
+        try {
+            const { stdout } = await execFileAsync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: cwdPath });
+            const newBranch = stdout.trim();
+            const lastBranch = this._lastBranch.get(cwdPath);
+            if (newBranch && newBranch !== lastBranch) {
+                this._lastBranch.set(cwdPath, newBranch);
+                this._callback(cwdPath, newBranch);
+            }
+        }
+        catch (_) {
+            // Non-fatal — repo may be in detached HEAD or mid-rebase
+        }
+    }
+    _closeAll() {
+        for (const w of this._watchers) {
+            try {
+                w.close();
+            }
+            catch (_) { }
+        }
+        this._watchers = [];
+        for (const timer of this._debounceTimers.values()) {
+            clearTimeout(timer);
+        }
+        this._debounceTimers.clear();
+        this._lastBranch.clear();
+    }
+    close() {
+        this._closeAll();
+    }
+}

package/dist/test/branch-watcher.test.js

@@ -0,0 +1,73 @@
+import { describe, it, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { execFileSync } from 'node:child_process';
+import { BranchWatcher } from '../server/watcher.js';
+function makeTempGitRepo() {
+    // Resolve symlinks (macOS /var → /private/var) so paths match git output
+    const dir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'branch-watcher-test-')));
+    execFileSync('git', ['init', '-b', 'main'], { cwd: dir });
+    execFileSync('git', ['-c', 'user.name=Test', '-c', 'user.email=test@test.com', 'commit', '--allow-empty', '-m', 'init'], { cwd: dir });
+    return dir;
+}
+describe('BranchWatcher', () => {
+    const cleanups = [];
+    afterEach(() => {
+        for (const fn of cleanups) {
+            try {
+                fn();
+            }
+            catch { /* ignore */ }
+        }
+        cleanups.length = 0;
+    });
+    it('detects branch change via HEAD file write', async () => {
+        const repoDir = makeTempGitRepo();
+        const parentDir = path.dirname(repoDir);
+        cleanups.push(() => fs.rmSync(repoDir, { recursive: true, force: true }));
+        const events = [];
+        const watcher = new BranchWatcher((cwdPath, newBranch) => {
+            events.push({ cwdPath, newBranch });
+        });
+        cleanups.push(() => watcher.close());
+        watcher.rebuild([parentDir]);
+        // Let fs.watch initialize
+        await new Promise(resolve => setTimeout(resolve, 200));
+        // Create the branch first, then simulate checkout by writing HEAD directly
+        // (more deterministic than git checkout which uses lock+rename)
+        execFileSync('git', ['branch', 'feature-test'], { cwd: repoDir });
+        const headPath = path.join(repoDir, '.git', 'HEAD');
+        fs.writeFileSync(headPath, 'ref: refs/heads/feature-test\n');
+        // Wait for debounce (300ms) + processing
+        await new Promise(resolve => setTimeout(resolve, 800));
+        assert.ok(events.length > 0, 'Expected at least one branch change event');
+        const lastEvent = events[events.length - 1];
+        assert.equal(lastEvent.cwdPath, repoDir);
+        assert.equal(lastEvent.newBranch, 'feature-test');
+    });
+    it('does not fire callback if branch did not change', async () => {
+        const repoDir = makeTempGitRepo();
+        const parentDir = path.dirname(repoDir);
+        cleanups.push(() => fs.rmSync(repoDir, { recursive: true, force: true }));
+        const events = [];
+        const watcher = new BranchWatcher((cwdPath, newBranch) => {
+            events.push({ cwdPath, newBranch });
+        });
+        cleanups.push(() => watcher.close());
+        watcher.rebuild([parentDir]);
+        await new Promise(resolve => setTimeout(resolve, 200));
+        // Touch the HEAD file without changing the branch content
+        const headPath = path.join(repoDir, '.git', 'HEAD');
+        const content = fs.readFileSync(headPath, 'utf-8');
+        fs.writeFileSync(headPath, content);
+        await new Promise(resolve => setTimeout(resolve, 800));
+        assert.equal(events.length, 0, 'Should not fire callback when branch is unchanged');
+    });
+    it('closes cleanly', () => {
+        const watcher = new BranchWatcher(() => { });
+        watcher.close();
+        // No error means success
+    });
+});

package/package.json

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