claude-remote-cli 3.9.4 → 3.10.0

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

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

@@ -0,0 +1,302 @@
+import { test, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import express from 'express';
+import { createIntegrationJiraRouter } from '../server/integration-jira.js';
+// ─── Constants ────────────────────────────────────────────────────────────────
+const FAKE_BASE_URL = 'https://fake-jira.atlassian.net';
+const FAKE_TOKEN = 'test-api-token';
+const FAKE_EMAIL = 'test@example.com';
+// ─── Globals ──────────────────────────────────────────────────────────────────
+let server;
+let baseUrl;
+/**
+ * The real Node.js fetch, saved before any test replaces globalThis.fetch.
+ * All HTTP calls from the test itself to the local Express server must use this.
+ */
+let realFetch;
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+/**
+ * Builds a minimal Jira REST API issue shape for use in mock responses.
+ */
+function makeJiraApiIssue(overrides) {
+    const { key = 'TEST-1', summary = 'Test issue', status = 'In Progress', priority = 'Medium', storyPoints = null, sprint = null, assignee = 'Jane Doe', updated = '2026-03-21T00:00:00.000+0000', } = overrides;
+    return {
+        key,
+        self: `${FAKE_BASE_URL}/rest/api/3/issue/${key}`,
+        fields: {
+            summary,
+            status: { name: status },
+            priority: priority !== null ? { name: priority } : null,
+            customfield_10016: storyPoints,
+            customfield_10020: sprint !== null ? [{ name: sprint }] : null,
+            assignee: assignee !== null ? { displayName: assignee } : null,
+            updated,
+        },
+    };
+}
+/**
+ * Builds a real Response with a given status and JSON body.
+ */
+function makeJsonResponse(body, status = 200) {
+    return new Response(JSON.stringify(body), {
+        status,
+        headers: { 'Content-Type': 'application/json' },
+    });
+}
+// ─── Server lifecycle ─────────────────────────────────────────────────────────
+/**
+ * Starts a fresh Express server with a new Jira router instance (and therefore
+ * a fresh in-memory cache). Call this AFTER setting globalThis.fetch so the
+ * router uses the mock when handling requests.
+ */
+function startServer() {
+    return new Promise((resolve) => {
+        const app = express();
+        app.use(express.json());
+        app.use('/integration-jira', createIntegrationJiraRouter({ configPath: '' }));
+        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();
+    });
+}
+// ─── Env var helpers ──────────────────────────────────────────────────────────
+function setEnvVars() {
+    process.env.JIRA_API_TOKEN = FAKE_TOKEN;
+    process.env.JIRA_EMAIL = FAKE_EMAIL;
+    process.env.JIRA_BASE_URL = FAKE_BASE_URL;
+}
+function clearEnvVars() {
+    delete process.env.JIRA_API_TOKEN;
+    delete process.env.JIRA_EMAIL;
+    delete process.env.JIRA_BASE_URL;
+}
+// ─── Suite setup / teardown ───────────────────────────────────────────────────
+before(() => {
+    realFetch = globalThis.fetch;
+    clearEnvVars();
+});
+after(async () => {
+    globalThis.fetch = realFetch;
+    clearEnvVars();
+    await stopServer();
+});
+// ─── Tests ────────────────────────────────────────────────────────────────────
+test('GET /configured returns true when all env vars are set', async () => {
+    setEnvVars();
+    globalThis.fetch = realFetch;
+    await stopServer();
+    await startServer();
+    const res = await realFetch(`${baseUrl}/integration-jira/configured`);
+    assert.equal(res.status, 200);
+    const body = (await res.json());
+    assert.equal(body.configured, true);
+});
+test('GET /configured returns false when any env var is missing', async () => {
+    clearEnvVars();
+    // Set only two of the three required vars; JIRA_BASE_URL intentionally omitted
+    process.env.JIRA_API_TOKEN = FAKE_TOKEN;
+    process.env.JIRA_EMAIL = FAKE_EMAIL;
+    globalThis.fetch = realFetch;
+    await stopServer();
+    await startServer();
+    const res = await realFetch(`${baseUrl}/integration-jira/configured`);
+    assert.equal(res.status, 200);
+    const body = (await res.json());
+    assert.equal(body.configured, false);
+    clearEnvVars();
+});
+test('GET /issues returns mapped JiraIssue[] from mocked Jira search response', async () => {
+    setEnvVars();
+    const mockSearchPayload = {
+        issues: [
+            makeJiraApiIssue({
+                key: 'PROJ-42',
+                summary: 'Fix the login bug',
+                status: 'In Progress',
+                priority: 'High',
+                storyPoints: 3,
+                sprint: 'Sprint 5',
+                assignee: 'Alice',
+                updated: '2026-03-21T12:00:00.000+0000',
+            }),
+            makeJiraApiIssue({
+                key: 'PROJ-10',
+                summary: 'Update docs',
+                status: 'To Do',
+                priority: null,
+                storyPoints: null,
+                sprint: null,
+                assignee: null,
+                updated: '2026-03-20T08:00:00.000+0000',
+            }),
+        ],
+    };
+    globalThis.fetch = async (input) => {
+        const url = typeof input === 'string' ? input : input.toString();
+        if (url.includes('/rest/api/3/search')) {
+            return makeJsonResponse(mockSearchPayload);
+        }
+        return makeJsonResponse({ error: 'unexpected url' }, 500);
+    };
+    await stopServer();
+    await startServer();
+    const res = await realFetch(`${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.storyPoints, 3);
+    assert.equal(issue42.sprint, 'Sprint 5');
+    assert.equal(issue42.assignee, 'Alice');
+    assert.equal(issue42.url, `${FAKE_BASE_URL}/browse/PROJ-42`);
+    assert.equal(issue42.projectKey, 'PROJ');
+    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.storyPoints, null);
+    assert.equal(issue10.sprint, null);
+    assert.equal(issue10.assignee, null);
+    // Verify sorted descending by updatedAt — PROJ-42 (newer) should come first
+    assert.equal(data.issues[0]?.key, 'PROJ-42');
+    assert.equal(data.issues[1]?.key, 'PROJ-10');
+});
+test('GET /issues caches results within TTL — fetch called only once for two requests', async () => {
+    setEnvVars();
+    let fetchCallCount = 0;
+    const mockPayload = {
+        issues: [makeJiraApiIssue({ key: 'CACHE-1', summary: 'Cached issue' })],
+    };
+    globalThis.fetch = async (input) => {
+        const url = typeof input === 'string' ? input : input.toString();
+        if (url.includes('/rest/api/3/search')) {
+            fetchCallCount++;
+            return makeJsonResponse(mockPayload);
+        }
+        return makeJsonResponse({}, 500);
+    };
+    await stopServer();
+    await startServer();
+    // First request — populates cache
+    const firstRes = await realFetch(`${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(fetchCallCount, 1, 'fetch should be called once on first request');
+    // Second request — should be served from cache, no additional fetch
+    const secondRes = await realFetch(`${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(fetchCallCount, 1, 'fetch should not be called again within TTL (cache hit)');
+});
+test('GET /issues returns jira_not_configured when env vars missing', async () => {
+    clearEnvVars();
+    // fetch should never be called — use a mock that throws to verify early return
+    globalThis.fetch = async () => {
+        throw new Error('fetch should not be called when not configured');
+    };
+    await stopServer();
+    await startServer();
+    const res = await realFetch(`${baseUrl}/integration-jira/issues`);
+    assert.equal(res.status, 200);
+    const data = (await res.json());
+    assert.equal(data.error, 'jira_not_configured');
+    assert.equal(data.issues.length, 0);
+});
+test('GET /statuses?projectKey=TEST returns deduplicated statuses from Jira project API', async () => {
+    setEnvVars();
+    // Jira returns one entry per issue type; statuses may overlap across types
+    const mockProjectStatuses = [
+        {
+            statuses: [
+                { id: '1', name: 'To Do' },
+                { id: '2', name: 'In Progress' },
+            ],
+        },
+        {
+            statuses: [
+                { id: '2', name: 'In Progress' }, // duplicate — should be filtered
+                { id: '3', name: 'Done' },
+            ],
+        },
+    ];
+    globalThis.fetch = async (input) => {
+        const url = typeof input === 'string' ? input : input.toString();
+        if (url.includes('/rest/api/3/project/TEST/statuses')) {
+            return makeJsonResponse(mockProjectStatuses);
+        }
+        return makeJsonResponse({}, 500);
+    };
+    await stopServer();
+    await startServer();
+    const res = await realFetch(`${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 /issues returns jira_auth_failed on 401 from Jira API', async () => {
+    setEnvVars();
+    globalThis.fetch = async (input) => {
+        const url = typeof input === 'string' ? input : input.toString();
+        if (url.includes('/rest/api/3/search')) {
+            return makeJsonResponse({ message: 'Unauthorized' }, 401);
+        }
+        return makeJsonResponse({}, 500);
+    };
+    await stopServer();
+    await startServer();
+    const res = await realFetch(`${baseUrl}/integration-jira/issues`);
+    assert.equal(res.status, 200);
+    const data = (await res.json());
+    assert.equal(data.error, 'jira_auth_failed');
+    assert.equal(data.issues.length, 0);
+});
+test('GET /statuses returns jira_auth_failed on 401 from Jira project API', async () => {
+    setEnvVars();
+    globalThis.fetch = async (input) => {
+        const url = typeof input === 'string' ? input : input.toString();
+        if (url.includes('/rest/api/3/project')) {
+            return makeJsonResponse({ message: 'Unauthorized' }, 401);
+        }
+        return makeJsonResponse({}, 500);
+    };
+    await stopServer();
+    await startServer();
+    const res = await realFetch(`${baseUrl}/integration-jira/statuses?projectKey=TEST`);
+    assert.equal(res.status, 200);
+    const data = (await res.json());
+    assert.equal(data.error, 'jira_auth_failed');
+    assert.equal(data.statuses.length, 0);
+});
+test('GET /statuses returns 400 when projectKey query param is missing', async () => {
+    setEnvVars();
+    globalThis.fetch = realFetch;
+    await stopServer();
+    await startServer();
+    const res = await realFetch(`${baseUrl}/integration-jira/statuses`);
+    assert.equal(res.status, 400);
+    const data = (await res.json());
+    assert.equal(data.error, 'missing_project_key');
+});