claude-remote-cli 3.9.4 → 3.10.0

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-linker.test.js

@@ -0,0 +1,231 @@
+import { test, before, after } 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 express from 'express';
+import { createBranchLinkerRouter, invalidateBranchLinkerCache, } from '../server/branch-linker.js';
+import { saveConfig, DEFAULTS } from '../server/config.js';
+let tmpDir;
+let configPath;
+let server;
+let baseUrl;
+const WORKSPACE_PATH_A = '/fake/workspace/repo-a';
+const WORKSPACE_PATH_B = '/fake/workspace/repo-b';
+/**
+ * Creates a mock execAsync that returns configured branch lists per cwd.
+ * - `git branch -a` → returns newline-joined branch names or throws
+ */
+function makeMockExec(opts) {
+    return async (cmd, args, options) => {
+        const command = cmd;
+        const argv = args;
+        const cwd = options.cwd ?? '';
+        if (command === 'git' && argv[0] === 'branch') {
+            if (opts.errorByPath?.[cwd])
+                throw opts.errorByPath[cwd];
+            const branches = opts.branchesByPath?.[cwd] ?? [];
+            return { stdout: branches.join('\n') + '\n', stderr: '' };
+        }
+        throw new Error(`Unexpected exec call: ${command} ${argv.join(' ')}`);
+    };
+}
+function startServer(execAsyncFn, getActiveBranchNames) {
+    return new Promise((resolve) => {
+        const app = express();
+        app.use(express.json());
+        const deps = {
+            configPath,
+            execAsync: execAsyncFn,
+            ...(getActiveBranchNames ? { getActiveBranchNames } : {}),
+        };
+        app.use('/branch-linker', createBranchLinkerRouter(deps));
+        server = app.listen(0, '127.0.0.1', () => {
+            const addr = server.address();
+            if (typeof addr === 'object' && addr) {
+                baseUrl = `http://127.0.0.1:${addr.port}`;
+            }
+            resolve();
+        });
+    });
+}
+function stopServer() {
+    return new Promise((resolve) => {
+        if (server)
+            server.close(() => resolve());
+        else
+            resolve();
+    });
+}
+async function getLinks() {
+    const res = await fetch(`${baseUrl}/branch-linker/links`);
+    return res.json();
+}
+before(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'branch-linker-test-'));
+    configPath = path.join(tmpDir, 'config.json');
+    // Clear any module-level cache before test suite runs
+    invalidateBranchLinkerCache();
+});
+after(async () => {
+    await stopServer();
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+test('extracts Jira ticket IDs from branch names', async () => {
+    await stopServer();
+    invalidateBranchLinkerCache();
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        workspaces: [WORKSPACE_PATH_A],
+    });
+    const exec = makeMockExec({
+        branchesByPath: {
+            [WORKSPACE_PATH_A]: ['dy/fix/ACME-123-auth', 'main'],
+        },
+    });
+    await startServer(exec);
+    const data = await getLinks();
+    assert.ok('ACME-123' in data, 'Should extract ACME-123 from branch name');
+    const links = data['ACME-123'];
+    assert.equal(links.length, 1);
+    assert.equal(links[0].branchName, 'dy/fix/ACME-123-auth');
+    assert.equal(links[0].repoPath, WORKSPACE_PATH_A);
+    assert.equal(links[0].repoName, 'repo-a');
+});
+test('extracts GH issue IDs from gh-N branches', async () => {
+    await stopServer();
+    invalidateBranchLinkerCache();
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        workspaces: [WORKSPACE_PATH_A],
+    });
+    const exec = makeMockExec({
+        branchesByPath: {
+            // Use a branch that only the GH regex matches (no embedded uppercase-only letters)
+            // to get a single clean GH-42 link. The Jira regex (/[A-Z]{2,}-\d+/gi) would also
+            // match 'gh-42' since the flag is case-insensitive, so we use a prefix that isolates
+            // the GH regex match by starting with 'gh-' at the very start of the branch name.
+            [WORKSPACE_PATH_A]: ['gh-42-login-fix'],
+        },
+    });
+    await startServer(exec);
+    const data = await getLinks();
+    assert.ok('GH-42' in data, 'Should extract GH-42 from branch name');
+    const links = data['GH-42'];
+    // Only the GH regex matches this branch — the Jira regex explicitly excludes 'GH'
+    // to avoid double-matching. Verify all links point to the correct branch and repo.
+    assert.ok(links.length >= 1, 'Should have at least one GH-42 link');
+    assert.ok(links.every((l) => l.branchName === 'gh-42-login-fix'), 'All links should reference the correct branch');
+    assert.ok(links.every((l) => l.repoPath === WORKSPACE_PATH_A), 'All links should reference the correct repo');
+});
+test('same ticket in two repos yields array of 2 BranchLinks', async () => {
+    await stopServer();
+    invalidateBranchLinkerCache();
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        workspaces: [WORKSPACE_PATH_A, WORKSPACE_PATH_B],
+    });
+    const exec = makeMockExec({
+        branchesByPath: {
+            [WORKSPACE_PATH_A]: ['feature/PROJ-99-payment'],
+            [WORKSPACE_PATH_B]: ['bugfix/PROJ-99-payment-fix'],
+        },
+    });
+    await startServer(exec);
+    const data = await getLinks();
+    assert.ok('PROJ-99' in data, 'Should have PROJ-99 key');
+    const links = data['PROJ-99'];
+    assert.equal(links.length, 2, 'Should have 2 BranchLinks for the same ticket across 2 repos');
+    const repoPaths = links.map((l) => l.repoPath).sort();
+    assert.deepEqual(repoPaths, [WORKSPACE_PATH_A, WORKSPACE_PATH_B].sort());
+});
+test('ignores branches without ticket IDs', async () => {
+    await stopServer();
+    invalidateBranchLinkerCache();
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        workspaces: [WORKSPACE_PATH_A],
+    });
+    const exec = makeMockExec({
+        branchesByPath: {
+            [WORKSPACE_PATH_A]: ['main', 'develop', 'chore/cleanup', 'feature/new-ui'],
+        },
+    });
+    await startServer(exec);
+    const data = await getLinks();
+    assert.equal(Object.keys(data).length, 0, 'Plain branches should produce no ticket links');
+});
+test('hasActiveSession true when branch is in active set', async () => {
+    await stopServer();
+    invalidateBranchLinkerCache();
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        workspaces: [WORKSPACE_PATH_A],
+    });
+    const activeBranch = 'feature/ACTIVE-1-work';
+    const exec = makeMockExec({
+        branchesByPath: {
+            [WORKSPACE_PATH_A]: [activeBranch, 'feature/INACTIVE-2-other'],
+        },
+    });
+    const getActiveBranchNames = () => {
+        return new Map([[WORKSPACE_PATH_A, new Set([activeBranch])]]);
+    };
+    await startServer(exec, getActiveBranchNames);
+    const data = await getLinks();
+    const activeLinks = data['ACTIVE-1'];
+    assert.ok(activeLinks, 'Should have ACTIVE-1 ticket');
+    assert.equal(activeLinks.length, 1);
+    assert.equal(activeLinks[0].hasActiveSession, true, 'Active branch should have hasActiveSession true');
+    const inactiveLinks = data['INACTIVE-2'];
+    assert.ok(inactiveLinks, 'Should have INACTIVE-2 ticket');
+    assert.equal(inactiveLinks[0].hasActiveSession, false, 'Inactive branch should have hasActiveSession false');
+});
+test('invalidateBranchLinkerCache forces fresh scan', async () => {
+    await stopServer();
+    invalidateBranchLinkerCache();
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        workspaces: [WORKSPACE_PATH_A],
+    });
+    let gitCallCount = 0;
+    const baseExec = makeMockExec({
+        branchesByPath: {
+            [WORKSPACE_PATH_A]: ['feature/SCAN-1-fresh'],
+        },
+    });
+    const countingExec = async (...args) => {
+        const [cmd] = args;
+        if (cmd === 'git')
+            gitCallCount++;
+        return baseExec(...args);
+    };
+    await startServer(countingExec);
+    // First request — populates module-level cache
+    const first = await getLinks();
+    assert.ok('SCAN-1' in first, 'Should have SCAN-1 after first request');
+    assert.equal(gitCallCount, 1, 'git should be called once on first request');
+    // Second request — served from cache
+    const second = await getLinks();
+    assert.ok('SCAN-1' in second);
+    assert.equal(gitCallCount, 1, 'git should not be called again within TTL');
+    // Invalidate cache
+    invalidateBranchLinkerCache();
+    // Third request — cache is cleared, should fetch fresh
+    const third = await getLinks();
+    assert.ok('SCAN-1' in third);
+    assert.equal(gitCallCount, 2, 'git should be called again after cache invalidation');
+});
+test('returns empty object when no workspaces', async () => {
+    await stopServer();
+    invalidateBranchLinkerCache();
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        workspaces: [],
+    });
+    // execAsync should never be called here
+    const exec = makeMockExec({});
+    await startServer(exec);
+    const data = await getLinks();
+    assert.equal(Object.keys(data).length, 0, 'Should return empty object when no workspaces configured');
+});

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/dist/test/config.test.js

@@ -223,3 +223,59 @@ test('deleteWorkspaceSettingKeys is no-op for nonexistent workspace', () => {
     fs.writeFileSync(configPath, JSON.stringify(config), 'utf8');
     assert.doesNotThrow(() => deleteWorkspaceSettingKeys(configPath, config, '/no/such/repo', ['defaultYolo']));
 });
+test('workspaceGroups with valid paths loads cleanly', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    fs.writeFileSync(configPath, JSON.stringify({
+        workspaces: ['/a/repo', '/b/repo'],
+        workspaceGroups: {
+            'Group A': ['/a/repo'],
+            'Group B': ['/b/repo'],
+        },
+    }), 'utf8');
+    const config = loadConfig(configPath);
+    assert.deepEqual(config.workspaceGroups['Group A'], ['/a/repo']);
+    assert.deepEqual(config.workspaceGroups['Group B'], ['/b/repo']);
+});
+test('workspaceGroups with invalid path filters it out', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    fs.writeFileSync(configPath, JSON.stringify({
+        workspaces: ['/valid/repo'],
+        workspaceGroups: {
+            'My Group': ['/valid/repo', '/not/in/workspaces'],
+        },
+    }), 'utf8');
+    const config = loadConfig(configPath);
+    assert.deepEqual(config.workspaceGroups['My Group'], ['/valid/repo']);
+});
+test('workspaceGroups with duplicate path keeps first-group winner', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    fs.writeFileSync(configPath, JSON.stringify({
+        workspaces: ['/shared/repo'],
+        workspaceGroups: {
+            'First': ['/shared/repo'],
+            'Second': ['/shared/repo'],
+        },
+    }), 'utf8');
+    const config = loadConfig(configPath);
+    assert.deepEqual(config.workspaceGroups['First'], ['/shared/repo']);
+    assert.equal(config.workspaceGroups['Second'], undefined);
+});
+test('workspaceGroups undefined produces no errors', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    fs.writeFileSync(configPath, JSON.stringify({
+        workspaces: ['/some/repo'],
+    }), 'utf8');
+    const config = loadConfig(configPath);
+    assert.equal(config.workspaceGroups, undefined);
+});
+test('workspaceGroups with all-invalid paths removes empty group', () => {
+    const configPath = path.join(tmpDir, 'config.json');
+    fs.writeFileSync(configPath, JSON.stringify({
+        workspaces: ['/valid/repo'],
+        workspaceGroups: {
+            'Ghost Group': ['/not/here', '/also/not/here'],
+        },
+    }), 'utf8');
+    const config = loadConfig(configPath);
+    assert.equal(config.workspaceGroups['Ghost Group'], undefined);
+});