claude-remote-cli 3.9.5 → 3.11.0

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/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);
+});

package/dist/test/integration-github.test.js

@@ -0,0 +1,203 @@
+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 { createIntegrationGitHubRouter } from '../server/integration-github.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';
+/**
+ * Builds a minimal GhIssueItem for use in mock stdout payloads.
+ */
+function makeIssueItem(overrides) {
+    const { number = 1, title = 'Test Issue', url = `https://github.com/fake/repo/issues/${overrides.number ?? 1}`, updatedAt = '2026-03-21T00:00:00Z', createdAt = '2026-03-20T00:00:00Z', } = overrides;
+    return {
+        number,
+        title,
+        url,
+        state: 'OPEN',
+        labels: [],
+        assignees: [],
+        createdAt,
+        updatedAt,
+    };
+}
+/**
+ * Creates a mock execAsync that routes calls based on the command and cwd.
+ * - `gh issue list` in a given cwd → returns configured issues list or throws
+ */
+function makeMockExec(opts) {
+    return async (cmd, args, options) => {
+        const command = cmd;
+        const argv = args;
+        const cwd = options.cwd ?? '';
+        if (command === 'gh' && argv[0] === 'issue' && argv[1] === 'list') {
+            if (opts.globalError)
+                throw opts.globalError;
+            if (opts.errorByPath?.[cwd])
+                throw opts.errorByPath[cwd];
+            const items = opts.issuesByPath?.[cwd] ?? [];
+            return { stdout: JSON.stringify(items), stderr: '' };
+        }
+        throw new Error(`Unexpected exec call: ${command} ${argv.join(' ')}`);
+    };
+}
+function startServer(execAsyncFn) {
+    return new Promise((resolve) => {
+        const app = express();
+        app.use(express.json());
+        const deps = { configPath, execAsync: execAsyncFn };
+        app.use('/integration-github', createIntegrationGitHubRouter(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 getIssues() {
+    const res = await fetch(`${baseUrl}/integration-github/issues`);
+    return res.json();
+}
+before(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'integration-github-test-'));
+    configPath = path.join(tmpDir, 'config.json');
+});
+after(async () => {
+    await stopServer();
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+test('returns issues from all workspace repos merged and sorted', async () => {
+    await stopServer();
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        workspaces: [WORKSPACE_PATH_A, WORKSPACE_PATH_B],
+    });
+    const exec = makeMockExec({
+        issuesByPath: {
+            [WORKSPACE_PATH_A]: [
+                makeIssueItem({ number: 10, title: 'Issue A', updatedAt: '2026-03-21T10:00:00Z' }),
+                makeIssueItem({ number: 11, title: 'Issue A2', updatedAt: '2026-03-19T10:00:00Z' }),
+            ],
+            [WORKSPACE_PATH_B]: [
+                makeIssueItem({ number: 20, title: 'Issue B', updatedAt: '2026-03-20T10:00:00Z' }),
+            ],
+        },
+    });
+    await startServer(exec);
+    const data = await getIssues();
+    assert.equal(data.error, undefined, `Unexpected error: ${data.error}`);
+    assert.equal(data.issues.length, 3, 'Should return all 3 issues from both repos');
+    // Verify sorted descending by updatedAt
+    const updatedAts = data.issues.map((i) => i.updatedAt);
+    assert.deepEqual(updatedAts, [
+        '2026-03-21T10:00:00Z',
+        '2026-03-20T10:00:00Z',
+        '2026-03-19T10:00:00Z',
+    ]);
+    // Verify repoPath and repoName are attached
+    const issue10 = data.issues.find((i) => i.number === 10);
+    assert.equal(issue10?.repoPath, WORKSPACE_PATH_A);
+    assert.equal(issue10?.repoName, 'repo-a');
+    const issue20 = data.issues.find((i) => i.number === 20);
+    assert.equal(issue20?.repoPath, WORKSPACE_PATH_B);
+    assert.equal(issue20?.repoName, 'repo-b');
+});
+test('returns no_workspaces error when empty', async () => {
+    await stopServer();
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        workspaces: [],
+    });
+    // execAsync should never be called — pass a mock that always throws to verify early-return
+    const exec = makeMockExec({});
+    await startServer(exec);
+    const data = await getIssues();
+    assert.equal(data.error, 'no_workspaces');
+    assert.equal(data.issues.length, 0);
+});
+test('returns gh_not_in_path when gh not found', async () => {
+    await stopServer();
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        workspaces: [WORKSPACE_PATH_A],
+    });
+    const err = new Error('spawn gh ENOENT');
+    err.code = 'ENOENT';
+    const exec = makeMockExec({ globalError: err });
+    await startServer(exec);
+    const data = await getIssues();
+    assert.equal(data.error, 'gh_not_in_path');
+    assert.equal(data.issues.length, 0);
+});
+test('caches per-repo within TTL — gh called once per repo for two requests', async () => {
+    await stopServer();
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        workspaces: [WORKSPACE_PATH_A, WORKSPACE_PATH_B],
+    });
+    let ghCallCount = 0;
+    const baseExec = makeMockExec({
+        issuesByPath: {
+            [WORKSPACE_PATH_A]: [makeIssueItem({ number: 1 })],
+            [WORKSPACE_PATH_B]: [makeIssueItem({ number: 2 })],
+        },
+    });
+    const countingExec = async (...args) => {
+        const [cmd, argv] = args;
+        if (cmd === 'gh' && argv[0] === 'issue') {
+            ghCallCount++;
+        }
+        return baseExec(...args);
+    };
+    await startServer(countingExec);
+    // First request — populates cache for both repos
+    const first = await getIssues();
+    assert.equal(first.error, undefined);
+    assert.equal(first.issues.length, 2);
+    assert.equal(ghCallCount, 2, 'gh should be called once per repo on first request');
+    // Second request — should be served from per-repo cache, no additional calls
+    const second = await getIssues();
+    assert.equal(second.error, undefined);
+    assert.equal(second.issues.length, 2);
+    assert.equal(ghCallCount, 2, 'gh should not be called again within TTL (cache hit)');
+});
+test('partial failure: repo that throws still returns others', async () => {
+    await stopServer();
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        workspaces: [WORKSPACE_PATH_A, WORKSPACE_PATH_B],
+    });
+    // repo-b will throw a generic error (not ENOENT, so non-fatal)
+    const exec = makeMockExec({
+        issuesByPath: {
+            [WORKSPACE_PATH_A]: [makeIssueItem({ number: 99, title: 'Surviving issue' })],
+        },
+        errorByPath: {
+            [WORKSPACE_PATH_B]: new Error('git command failed'),
+        },
+    });
+    await startServer(exec);
+    const data = await getIssues();
+    // No top-level error — partial failures are silent
+    assert.equal(data.error, undefined, `Unexpected error: ${data.error}`);
+    assert.equal(data.issues.length, 1, 'Should return the one issue from the succeeding repo');
+    assert.equal(data.issues[0]?.number, 99);
+    assert.equal(data.issues[0]?.repoPath, WORKSPACE_PATH_A);
+});