claude-remote-cli 3.9.5 → 3.11.0

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

@@ -0,0 +1,221 @@
+import { test, after } from 'node:test';
+import assert from 'node:assert/strict';
+import express from 'express';
+import { createIntegrationJiraRouter } from '../server/integration-jira.js';
+// ─── Mock stdout constants ────────────────────────────────────────────────────
+const AUTH_STATUS_STDOUT = `✓ Authenticated
+  Site: fake-jira.atlassian.net
+  Email: test@example.com
+  Authentication Type: oauth
+`;
+// ─── Globals ──────────────────────────────────────────────────────────────────
+let server;
+let baseUrl;
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+/**
+ * Builds a minimal AcliWorkItem for use in mock stdout payloads.
+ */
+function makeAcliWorkItem(overrides) {
+    const { key = 'TEST-1', summary = 'Test issue', statusId = '3', statusName = 'In Progress', priorityName = 'Medium', assigneeDisplayName = 'Jane Doe', } = overrides;
+    return {
+        key,
+        fields: {
+            summary,
+            status: { id: statusId, name: statusName },
+            ...(priorityName !== null ? { priority: { name: priorityName } } : { priority: null }),
+            ...(assigneeDisplayName !== null ? { assignee: { displayName: assigneeDisplayName } } : { assignee: null }),
+        },
+    };
+}
+/**
+ * Creates a mock execAsync that routes calls based on the acli subcommand args:
+ * - `acli jira auth status` → returns AUTH_STATUS_STDOUT (or throws)
+ * - `acli jira workitem search` → returns the provided items as JSON stdout (or throws)
+ */
+function makeMockExec(opts) {
+    return async (_cmd, args) => {
+        const argv = args;
+        if (argv.includes('auth') && argv.includes('status')) {
+            if (opts.authError)
+                throw opts.authError;
+            return { stdout: AUTH_STATUS_STDOUT, stderr: '' };
+        }
+        if (argv.includes('workitem') && argv.includes('search')) {
+            if (opts.searchError)
+                throw opts.searchError;
+            return { stdout: JSON.stringify(opts.searchItems ?? []), stderr: '' };
+        }
+        throw new Error(`Unexpected exec call: acli ${argv.join(' ')}`);
+    };
+}
+// ─── Server lifecycle ─────────────────────────────────────────────────────────
+function startServer(execAsyncFn) {
+    return new Promise((resolve) => {
+        const app = express();
+        app.use(express.json());
+        const deps = { configPath: '', execAsync: execAsyncFn };
+        app.use('/integration-jira', createIntegrationJiraRouter(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();
+    });
+}
+// ─── Suite teardown ───────────────────────────────────────────────────────────
+after(async () => {
+    await stopServer();
+});
+// ─── Tests ────────────────────────────────────────────────────────────────────
+test('GET /issues returns mapped JiraIssue[] from mocked acli JSON output', async () => {
+    await stopServer();
+    const searchItems = [
+        makeAcliWorkItem({
+            key: 'PROJ-42',
+            summary: 'Fix the login bug',
+            statusId: '3',
+            statusName: 'In Progress',
+            priorityName: 'High',
+            assigneeDisplayName: 'Alice',
+        }),
+        makeAcliWorkItem({
+            key: 'PROJ-10',
+            summary: 'Update docs',
+            statusId: '1',
+            statusName: 'To Do',
+            priorityName: null,
+            assigneeDisplayName: null,
+        }),
+    ];
+    const exec = makeMockExec({ searchItems });
+    await startServer(exec);
+    const res = await fetch(`${baseUrl}/integration-jira/issues`);
+    assert.equal(res.status, 200);
+    const data = (await res.json());
+    assert.equal(data.error, undefined, `Unexpected error: ${data.error}`);
+    assert.equal(data.issues.length, 2);
+    const issue42 = data.issues.find((i) => i.key === 'PROJ-42');
+    assert.ok(issue42, 'Should contain PROJ-42');
+    assert.equal(issue42.title, 'Fix the login bug');
+    assert.equal(issue42.status, 'In Progress');
+    assert.equal(issue42.priority, 'High');
+    assert.equal(issue42.assignee, 'Alice');
+    assert.equal(issue42.url, 'https://fake-jira.atlassian.net/browse/PROJ-42');
+    assert.equal(issue42.projectKey, 'PROJ');
+    assert.equal(issue42.updatedAt, '');
+    assert.equal(issue42.sprint, null);
+    assert.equal(issue42.storyPoints, null);
+    const issue10 = data.issues.find((i) => i.key === 'PROJ-10');
+    assert.ok(issue10, 'Should contain PROJ-10');
+    assert.equal(issue10.priority, null);
+    assert.equal(issue10.assignee, null);
+    assert.equal(issue10.url, 'https://fake-jira.atlassian.net/browse/PROJ-10');
+    assert.equal(issue10.projectKey, 'PROJ');
+});
+test('GET /issues returns acli_not_in_path when exec throws ENOENT', async () => {
+    await stopServer();
+    const err = new Error('spawn acli ENOENT');
+    err.code = 'ENOENT';
+    const exec = makeMockExec({ authError: err });
+    await startServer(exec);
+    const res = await fetch(`${baseUrl}/integration-jira/issues`);
+    assert.equal(res.status, 200);
+    const data = (await res.json());
+    assert.equal(data.error, 'acli_not_in_path');
+    assert.equal(data.issues.length, 0);
+});
+test('GET /issues returns acli_not_authenticated when exec stderr contains auth message', async () => {
+    await stopServer();
+    const err = Object.assign(new Error('acli auth error'), {
+        stderr: "not logged in, use 'acli jira auth login' to authenticate",
+    });
+    const exec = makeMockExec({ authError: err });
+    await startServer(exec);
+    const res = await fetch(`${baseUrl}/integration-jira/issues`);
+    assert.equal(res.status, 200);
+    const data = (await res.json());
+    assert.equal(data.error, 'acli_not_authenticated');
+    assert.equal(data.issues.length, 0);
+});
+test('GET /issues caches results within TTL — exec called only once for two requests', async () => {
+    await stopServer();
+    let searchCallCount = 0;
+    const baseExec = makeMockExec({
+        searchItems: [makeAcliWorkItem({ key: 'CACHE-1', summary: 'Cached issue' })],
+    });
+    const countingExec = async (...args) => {
+        const argv = args[1];
+        if (argv.includes('workitem') && argv.includes('search')) {
+            searchCallCount++;
+        }
+        return baseExec(...args);
+    };
+    await startServer(countingExec);
+    // First request — populates cache
+    const firstRes = await fetch(`${baseUrl}/integration-jira/issues`);
+    const first = (await firstRes.json());
+    assert.equal(first.error, undefined, `Unexpected error: ${first.error}`);
+    assert.equal(first.issues.length, 1);
+    assert.equal(searchCallCount, 1, 'search should be called once on first request');
+    // Second request — should be served from cache, no additional exec call
+    const secondRes = await fetch(`${baseUrl}/integration-jira/issues`);
+    const second = (await secondRes.json());
+    assert.equal(second.error, undefined, `Unexpected error: ${second.error}`);
+    assert.equal(second.issues.length, 1);
+    assert.equal(searchCallCount, 1, 'search should not be called again within TTL (cache hit)');
+});
+test('GET /statuses?projectKey=TEST returns deduplicated statuses', async () => {
+    await stopServer();
+    // Items with overlapping status IDs — deduplication should collapse to 3 unique statuses
+    const searchItems = [
+        makeAcliWorkItem({ key: 'TEST-1', statusId: '1', statusName: 'To Do' }),
+        makeAcliWorkItem({ key: 'TEST-2', statusId: '2', statusName: 'In Progress' }),
+        makeAcliWorkItem({ key: 'TEST-3', statusId: '2', statusName: 'In Progress' }), // duplicate
+        makeAcliWorkItem({ key: 'TEST-4', statusId: '3', statusName: 'Done' }),
+    ];
+    const exec = makeMockExec({ searchItems });
+    await startServer(exec);
+    const res = await fetch(`${baseUrl}/integration-jira/statuses?projectKey=TEST`);
+    assert.equal(res.status, 200);
+    const data = (await res.json());
+    assert.equal(data.error, undefined, `Unexpected error: ${data.error}`);
+    assert.equal(data.statuses.length, 3, 'Should deduplicate statuses by id');
+    const ids = data.statuses.map((s) => s.id);
+    assert.deepEqual(ids, ['1', '2', '3']);
+    const names = data.statuses.map((s) => s.name);
+    assert.deepEqual(names, ['To Do', 'In Progress', 'Done']);
+});
+test('GET /statuses returns 400 when projectKey query param is missing', async () => {
+    await stopServer();
+    const exec = makeMockExec({ searchItems: [] });
+    await startServer(exec);
+    const res = await fetch(`${baseUrl}/integration-jira/statuses`);
+    assert.equal(res.status, 400);
+    const data = (await res.json());
+    assert.equal(data.error, 'missing_project_key');
+});
+test('GET /statuses returns 400 for invalid projectKey (lowercase or special chars)', async () => {
+    await stopServer();
+    const exec = makeMockExec({ searchItems: [] });
+    await startServer(exec);
+    // Lowercase key
+    const resLower = await fetch(`${baseUrl}/integration-jira/statuses?projectKey=test`);
+    assert.equal(resLower.status, 400);
+    const dataLower = (await resLower.json());
+    assert.equal(dataLower.error, 'invalid_project_key');
+    // Key with special characters
+    const resSpecial = await fetch(`${baseUrl}/integration-jira/statuses?projectKey=TEST%20PROJ`);
+    assert.equal(resSpecial.status, 400);
+    const dataSpecial = (await resSpecial.json());
+    assert.equal(dataSpecial.error, 'invalid_project_key');
+});

package/dist/test/org-dashboard.test.js

@@ -0,0 +1,240 @@
+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 { createOrgDashboardRouter } from '../server/org-dashboard.js';
+import { saveConfig, DEFAULTS } from '../server/config.js';
+let tmpDir;
+let configPath;
+let server;
+let baseUrl;
+// A workspace path we can point git remote mocks at
+const WORKSPACE_PATH_A = '/fake/workspace/repo-a';
+const WORKSPACE_PATH_B = '/fake/workspace/repo-b';
+/**
+ * Creates a mock execAsync that routes calls based on the command.
+ * - `git remote get-url origin` → returns configured remote URL or throws
+ * - `gh api user ...` → returns configured user login or throws
+ * - `gh api search/issues ...` → returns configured search response or throws
+ */
+function makeMockExec(opts) {
+    return async (cmd, args, options) => {
+        const command = cmd;
+        const argv = args;
+        if (command === 'git' && argv[0] === 'remote') {
+            const cwd = options.cwd ?? '';
+            const remote = opts.remotes?.[cwd];
+            if (remote)
+                return { stdout: remote + '\n', stderr: '' };
+            throw Object.assign(new Error('not a git repository'), { code: 128 });
+        }
+        if (command === 'gh' && argv[0] === 'api' && argv[1] === 'user') {
+            if (opts.userError)
+                throw opts.userError;
+            const login = opts.userLogin ?? 'testuser';
+            return { stdout: login + '\n', stderr: '' };
+        }
+        if (command === 'gh' && argv[0] === 'api' && argv[1]?.startsWith('search/issues')) {
+            if (opts.searchError)
+                throw opts.searchError;
+            const items = opts.searchItems ?? [];
+            return { stdout: JSON.stringify({ items }), stderr: '' };
+        }
+        throw new Error(`Unexpected exec call: ${command} ${argv.join(' ')}`);
+    };
+}
+/**
+ * Builds a minimal GH search item for a given owner/repo and user.
+ */
+function makeSearchItem(overrides) {
+    const { ownerRepo, number = 1, title = 'Test PR', author = 'testuser', role = 'author', currentUser = 'testuser', } = overrides;
+    return {
+        number,
+        title,
+        html_url: `https://github.com/${ownerRepo}/pull/${number}`,
+        state: 'open',
+        user: { login: author },
+        pull_request: { head: { ref: 'feat/branch' }, base: { ref: 'main' } },
+        updated_at: '2026-03-21T00:00:00Z',
+        requested_reviewers: role === 'reviewer' ? [{ login: currentUser }] : [],
+        repository_url: `https://api.github.com/repos/${ownerRepo}`,
+    };
+}
+function startServer(execAsyncFn) {
+    return new Promise((resolve) => {
+        const app = express();
+        app.use(express.json());
+        // Cast through unknown: the mock satisfies the runtime contract but the
+        // overloaded promisify types don't align across module instances.
+        const deps = { configPath, execAsync: execAsyncFn };
+        app.use('/org-dashboard', createOrgDashboardRouter(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 getPrs() {
+    const res = await fetch(`${baseUrl}/org-dashboard/prs`);
+    return res.json();
+}
+before(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'org-dashboard-test-'));
+    configPath = path.join(tmpDir, 'config.json');
+});
+after(async () => {
+    await stopServer();
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+// Each test gets a fresh server with its own router (and thus its own cache).
+// We stop/start the server around each test to reset the in-router cache state.
+test('returns prs filtered to workspace repos', async () => {
+    await stopServer();
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        workspaces: [WORKSPACE_PATH_A, WORKSPACE_PATH_B],
+    });
+    const exec = makeMockExec({
+        remotes: {
+            [WORKSPACE_PATH_A]: 'git@github.com:myorg/repo-a.git',
+            [WORKSPACE_PATH_B]: 'git@github.com:myorg/repo-b.git',
+        },
+        userLogin: 'testuser',
+        searchItems: [
+            // Matches WORKSPACE_PATH_A
+            makeSearchItem({ ownerRepo: 'myorg/repo-a', number: 10, author: 'testuser' }),
+            // Matches WORKSPACE_PATH_B
+            makeSearchItem({ ownerRepo: 'myorg/repo-b', number: 20, author: 'testuser' }),
+            // Not in any workspace — should be excluded
+            makeSearchItem({ ownerRepo: 'myorg/other-repo', number: 30, author: 'testuser' }),
+        ],
+    });
+    await startServer(exec);
+    const data = await getPrs();
+    assert.equal(data.error, undefined, `Unexpected error: ${data.error}`);
+    assert.equal(data.prs.length, 2, 'Should return only the 2 workspace-matched PRs');
+    const numbers = data.prs.map((p) => p.number).sort((a, b) => a - b);
+    assert.deepEqual(numbers, [10, 20]);
+    // Verify repoPath is attached
+    const pr10 = data.prs.find((p) => p.number === 10);
+    assert.equal(pr10?.repoPath, WORKSPACE_PATH_A);
+});
+test('returns gh_not_in_path error when gh not found', async () => {
+    await stopServer();
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        workspaces: [WORKSPACE_PATH_A],
+    });
+    const notFoundError = Object.assign(new Error('spawn gh ENOENT'), { code: 'ENOENT' });
+    const exec = makeMockExec({
+        remotes: { [WORKSPACE_PATH_A]: 'git@github.com:myorg/repo-a.git' },
+        userError: notFoundError,
+    });
+    await startServer(exec);
+    const data = await getPrs();
+    assert.equal(data.error, 'gh_not_in_path');
+    assert.equal(data.prs.length, 0);
+});
+test('returns gh_not_authenticated error', async () => {
+    await stopServer();
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        workspaces: [WORKSPACE_PATH_A],
+    });
+    const authError = new Error('You are not logged into any GitHub hosts. Run gh auth login to authenticate.');
+    const exec = makeMockExec({
+        remotes: { [WORKSPACE_PATH_A]: 'git@github.com:myorg/repo-a.git' },
+        userError: authError,
+    });
+    await startServer(exec);
+    const data = await getPrs();
+    assert.equal(data.error, 'gh_not_authenticated');
+    assert.equal(data.prs.length, 0);
+});
+test('returns empty prs with no_workspaces error when workspaces is empty', async () => {
+    await stopServer();
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        workspaces: [],
+    });
+    // execAsync should never be called here — pass a mock that always throws to
+    // verify the early-return path triggers before any exec
+    const exec = makeMockExec({});
+    await startServer(exec);
+    const data = await getPrs();
+    assert.equal(data.error, 'no_workspaces');
+    assert.equal(data.prs.length, 0);
+});
+test('detects reviewer role when current user is in requested_reviewers but not the author', async () => {
+    await stopServer();
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        workspaces: [WORKSPACE_PATH_A],
+    });
+    // PR authored by someone else; testuser is a requested reviewer
+    const reviewerItem = makeSearchItem({
+        ownerRepo: 'myorg/repo-a',
+        number: 42,
+        title: 'Review me',
+        author: 'otheruser',
+        role: 'reviewer',
+        currentUser: 'testuser',
+    });
+    const exec = makeMockExec({
+        remotes: { [WORKSPACE_PATH_A]: 'git@github.com:myorg/repo-a.git' },
+        userLogin: 'testuser',
+        searchItems: [reviewerItem],
+    });
+    await startServer(exec);
+    const data = await getPrs();
+    assert.equal(data.error, undefined, `Unexpected error: ${data.error}`);
+    assert.equal(data.prs.length, 1, 'Should return the reviewer PR');
+    const pr = data.prs[0];
+    assert.equal(pr?.number, 42);
+    assert.equal(pr?.role, 'reviewer', 'Role should be reviewer');
+    assert.equal(pr?.author, 'otheruser', 'Author should be otheruser, not the current user');
+});
+test('caches results within TTL — exec called only once for two requests', async () => {
+    await stopServer();
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        workspaces: [WORKSPACE_PATH_A],
+    });
+    let searchCallCount = 0;
+    // Wrap makeMockExec with a counter on the search path
+    const baseExec = makeMockExec({
+        remotes: { [WORKSPACE_PATH_A]: 'git@github.com:myorg/repo-a.git' },
+        userLogin: 'testuser',
+        searchItems: [makeSearchItem({ ownerRepo: 'myorg/repo-a', number: 1, author: 'testuser' })],
+    });
+    const countingExec = async (...args) => {
+        const [cmd, argv] = args;
+        if (cmd === 'gh' && typeof argv[1] === 'string' && argv[1].startsWith('search/issues')) {
+            searchCallCount++;
+        }
+        return baseExec(...args);
+    };
+    await startServer(countingExec);
+    // First request — populates cache
+    const first = await getPrs();
+    assert.equal(first.error, undefined);
+    assert.equal(first.prs.length, 1);
+    // Second request — should be served from cache, no additional exec call
+    const second = await getPrs();
+    assert.equal(second.error, undefined);
+    assert.equal(second.prs.length, 1);
+    assert.equal(searchCallCount, 1, 'gh search should have been called exactly once (cache hit on second request)');
+});