claude-remote-cli 3.9.4 → 3.10.0

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

@@ -0,0 +1,293 @@
+import { test, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import express from 'express';
+import { createIntegrationLinearRouter } from '../server/integration-linear.js';
+// ─── State ───────────────────────────────────────────────────────────────────
+let server;
+let baseUrl;
+// Saved before any mock replaces globalThis.fetch so test HTTP calls
+// to the local Express server always reach it even when fetch is mocked.
+let httpFetch;
+let originalApiKey;
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+/** Builds a single Linear issue node as returned by the GraphQL API. */
+function makeIssueNode(overrides = {}) {
+    return {
+        id: overrides.id ?? 'issue-1',
+        identifier: overrides.identifier ?? 'ENG-1',
+        title: overrides.title ?? 'Test Issue',
+        url: overrides.url ?? 'https://linear.app/team/issue/ENG-1',
+        state: overrides.stateName != null ? { name: overrides.stateName } : { name: 'In Progress' },
+        priority: overrides.priority ?? 2,
+        priorityLabel: overrides.priorityLabel ?? 'Medium',
+        cycle: (overrides.cycle !== undefined)
+            ? (overrides.cycle !== null ? { name: overrides.cycle } : null)
+            : null,
+        estimate: overrides.estimate ?? null,
+        assignee: overrides.assigneeName != null ? { name: overrides.assigneeName } : null,
+        updatedAt: overrides.updatedAt ?? '2026-03-21T00:00:00Z',
+        team: overrides.teamId != null ? { id: overrides.teamId } : { id: 'team-abc' },
+    };
+}
+/** Builds a GraphQL issues response envelope. */
+function makeIssuesGqlResponse(nodes) {
+    return {
+        data: {
+            viewer: {
+                assignedIssues: {
+                    nodes,
+                },
+            },
+        },
+    };
+}
+/** Builds a GraphQL workflow states response envelope. */
+function makeStatesGqlResponse(nodes) {
+    return {
+        data: {
+            workflowStates: {
+                nodes,
+            },
+        },
+    };
+}
+/**
+ * Returns a function suitable for replacing globalThis.fetch.
+ * The returned mock always resolves with a minimal Response-shaped object.
+ */
+function makeMockFetch(gqlBody, opts = {}) {
+    const status = opts.status ?? 200;
+    const ok = opts.ok !== undefined ? opts.ok : (status >= 200 && status < 300);
+    return (async () => ({
+        ok,
+        status,
+        json: async () => gqlBody,
+    }));
+}
+function startServer() {
+    return new Promise((resolve) => {
+        const app = express();
+        app.use(express.json());
+        // configPath is unused by the Linear router at runtime; pass a dummy.
+        app.use('/integration-linear', createIntegrationLinearRouter({ configPath: '/dev/null' }));
+        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();
+    });
+}
+// ─── Lifecycle ────────────────────────────────────────────────────────────────
+// Each test gets a fresh server instance so the module-level issuesCache starts
+// at null. This is the only reliable way to clear cache state without exposing
+// internals, since issuesCache lives in the router closure.
+beforeEach(async () => {
+    await startServer();
+    // Capture real fetch AFTER server starts (so baseUrl is set) but BEFORE any
+    // test mock replaces it. Used for all test-to-server HTTP calls.
+    httpFetch = globalThis.fetch;
+    originalApiKey = process.env['LINEAR_API_KEY'];
+});
+afterEach(async () => {
+    await stopServer();
+    globalThis.fetch = httpFetch;
+    if (originalApiKey === undefined) {
+        delete process.env['LINEAR_API_KEY'];
+    }
+    else {
+        process.env['LINEAR_API_KEY'] = originalApiKey;
+    }
+});
+// ─── GET /configured ─────────────────────────────────────────────────────────
+test('GET /configured — returns { configured: true } when LINEAR_API_KEY is set', async () => {
+    process.env['LINEAR_API_KEY'] = 'lin_test_key';
+    const res = await httpFetch(`${baseUrl}/integration-linear/configured`);
+    assert.equal(res.ok, true);
+    const body = await res.json();
+    assert.deepEqual(body, { configured: true });
+});
+test('GET /configured — returns { configured: false } when LINEAR_API_KEY is not set', async () => {
+    delete process.env['LINEAR_API_KEY'];
+    const res = await httpFetch(`${baseUrl}/integration-linear/configured`);
+    assert.equal(res.ok, true);
+    const body = await res.json();
+    assert.deepEqual(body, { configured: false });
+});
+// ─── GET /issues ──────────────────────────────────────────────────────────────
+test('GET /issues — returns linear_not_configured error when API key is missing', async () => {
+    delete process.env['LINEAR_API_KEY'];
+    const res = await httpFetch(`${baseUrl}/integration-linear/issues`);
+    assert.equal(res.ok, true);
+    const body = await res.json();
+    assert.equal(body.error, 'linear_not_configured');
+    assert.deepEqual(body.issues, []);
+});
+test('GET /issues — returns mapped LinearIssue[] from mocked GraphQL response', async () => {
+    process.env['LINEAR_API_KEY'] = 'lin_test_key';
+    const nodes = [
+        makeIssueNode({
+            id: 'issue-abc',
+            identifier: 'ENG-42',
+            title: 'Build something',
+            url: 'https://linear.app/team/issue/ENG-42',
+            stateName: 'In Progress',
+            priority: 1,
+            priorityLabel: 'Urgent',
+            cycle: 'Sprint 5',
+            estimate: 3,
+            assigneeName: 'Alice',
+            updatedAt: '2026-03-21T12:00:00Z',
+            teamId: 'team-xyz',
+        }),
+    ];
+    globalThis.fetch = makeMockFetch(makeIssuesGqlResponse(nodes));
+    const res = await httpFetch(`${baseUrl}/integration-linear/issues`);
+    assert.equal(res.ok, true);
+    const body = await res.json();
+    assert.equal(body.error, undefined, `Unexpected error: ${body.error}`);
+    assert.equal(body.issues.length, 1);
+    const issue = body.issues[0];
+    assert.equal(issue.id, 'issue-abc');
+    assert.equal(issue.identifier, 'ENG-42');
+    assert.equal(issue.title, 'Build something');
+    assert.equal(issue.url, 'https://linear.app/team/issue/ENG-42');
+    assert.equal(issue.state, 'In Progress');
+    assert.equal(issue.priority, 1);
+    assert.equal(issue.priorityLabel, 'Urgent');
+    assert.equal(issue.cycle, 'Sprint 5');
+    assert.equal(issue.estimate, 3);
+    assert.equal(issue.assignee, 'Alice');
+    assert.equal(issue.updatedAt, '2026-03-21T12:00:00Z');
+    assert.equal(issue.teamId, 'team-xyz');
+});
+test('GET /issues — caches results within TTL (fetch called only once for two requests)', async () => {
+    process.env['LINEAR_API_KEY'] = 'lin_test_key';
+    let fetchCallCount = 0;
+    const nodes = [makeIssueNode({ id: 'cached-issue', identifier: 'ENG-99' })];
+    const mockBody = makeIssuesGqlResponse(nodes);
+    globalThis.fetch = (async () => {
+        fetchCallCount++;
+        return { ok: true, status: 200, json: async () => mockBody };
+    });
+    // First request — populates cache
+    const first = await httpFetch(`${baseUrl}/integration-linear/issues`);
+    const firstBody = await first.json();
+    assert.equal(firstBody.error, undefined, `Unexpected error on first request: ${firstBody.error}`);
+    assert.equal(firstBody.issues.length, 1);
+    assert.equal(fetchCallCount, 1, 'fetch should be called once on the first request');
+    // Second request — should be served from cache, no additional fetch calls
+    const second = await httpFetch(`${baseUrl}/integration-linear/issues`);
+    const secondBody = await second.json();
+    assert.equal(secondBody.error, undefined, `Unexpected error on second request: ${secondBody.error}`);
+    assert.equal(secondBody.issues.length, 1);
+    assert.equal(fetchCallCount, 1, 'fetch should not be called again within TTL (cache hit)');
+});
+// ─── GET /states ──────────────────────────────────────────────────────────────
+test('GET /states — returns workflow states from mocked GraphQL response', async () => {
+    process.env['LINEAR_API_KEY'] = 'lin_test_key';
+    const stateNodes = [
+        { id: 'state-1', name: 'Backlog' },
+        { id: 'state-2', name: 'In Progress' },
+        { id: 'state-3', name: 'Done' },
+    ];
+    globalThis.fetch = makeMockFetch(makeStatesGqlResponse(stateNodes));
+    const res = await httpFetch(`${baseUrl}/integration-linear/states?teamId=team-abc`);
+    assert.equal(res.ok, true);
+    const body = await res.json();
+    assert.equal(body.error, undefined, `Unexpected error: ${body.error}`);
+    assert.equal(body.states.length, 3);
+    assert.deepEqual(body.states, stateNodes);
+});
+test('GET /states — returns linear_not_configured error when API key is missing', async () => {
+    delete process.env['LINEAR_API_KEY'];
+    const res = await httpFetch(`${baseUrl}/integration-linear/states?teamId=team-abc`);
+    assert.equal(res.ok, true);
+    const body = await res.json();
+    assert.equal(body.error, 'linear_not_configured');
+    assert.deepEqual(body.states, []);
+});
+test('GET /states — returns 400 missing_team_id when teamId query param is absent', async () => {
+    process.env['LINEAR_API_KEY'] = 'lin_test_key';
+    const res = await httpFetch(`${baseUrl}/integration-linear/states`);
+    assert.equal(res.status, 400);
+    const body = await res.json();
+    assert.equal(body.error, 'missing_team_id');
+});
+// ─── Error handling ───────────────────────────────────────────────────────────
+test('auth failure (HTTP 401) returns linear_auth_failed for /issues', async () => {
+    process.env['LINEAR_API_KEY'] = 'lin_bad_key';
+    globalThis.fetch = makeMockFetch({}, { status: 401, ok: false });
+    const res = await httpFetch(`${baseUrl}/integration-linear/issues`);
+    assert.equal(res.ok, true);
+    const body = await res.json();
+    assert.equal(body.error, 'linear_auth_failed');
+    assert.deepEqual(body.issues, []);
+});
+test('auth failure (HTTP 403) returns linear_auth_failed for /issues', async () => {
+    process.env['LINEAR_API_KEY'] = 'lin_bad_key';
+    globalThis.fetch = makeMockFetch({}, { status: 403, ok: false });
+    const res = await httpFetch(`${baseUrl}/integration-linear/issues`);
+    assert.equal(res.ok, true);
+    const body = await res.json();
+    assert.equal(body.error, 'linear_auth_failed');
+    assert.deepEqual(body.issues, []);
+});
+test('non-ok response (HTTP 500) returns linear_fetch_failed for /issues', async () => {
+    process.env['LINEAR_API_KEY'] = 'lin_test_key';
+    globalThis.fetch = makeMockFetch({}, { status: 500, ok: false });
+    const res = await httpFetch(`${baseUrl}/integration-linear/issues`);
+    assert.equal(res.ok, true);
+    const body = await res.json();
+    assert.equal(body.error, 'linear_fetch_failed');
+    assert.deepEqual(body.issues, []);
+});
+test('GraphQL-level authentication error returns linear_auth_failed', async () => {
+    process.env['LINEAR_API_KEY'] = 'lin_test_key';
+    const gqlAuthError = {
+        errors: [{ extensions: { type: 'authentication' } }],
+        data: null,
+    };
+    globalThis.fetch = makeMockFetch(gqlAuthError);
+    const res = await httpFetch(`${baseUrl}/integration-linear/issues`);
+    assert.equal(res.ok, true);
+    const body = await res.json();
+    assert.equal(body.error, 'linear_auth_failed');
+    assert.deepEqual(body.issues, []);
+});
+test('network error (fetch throws) returns linear_fetch_failed for /issues', async () => {
+    process.env['LINEAR_API_KEY'] = 'lin_test_key';
+    globalThis.fetch = (async () => { throw new Error('Network failure'); });
+    const res = await httpFetch(`${baseUrl}/integration-linear/issues`);
+    assert.equal(res.ok, true);
+    const body = await res.json();
+    assert.equal(body.error, 'linear_fetch_failed');
+    assert.deepEqual(body.issues, []);
+});
+test('auth failure (HTTP 401) returns linear_auth_failed for /states', async () => {
+    process.env['LINEAR_API_KEY'] = 'lin_bad_key';
+    globalThis.fetch = makeMockFetch({}, { status: 401, ok: false });
+    const res = await httpFetch(`${baseUrl}/integration-linear/states?teamId=team-abc`);
+    assert.equal(res.ok, true);
+    const body = await res.json();
+    assert.equal(body.error, 'linear_auth_failed');
+    assert.deepEqual(body.states, []);
+});
+test('non-ok response (HTTP 500) returns linear_fetch_failed for /states', async () => {
+    process.env['LINEAR_API_KEY'] = 'lin_test_key';
+    globalThis.fetch = makeMockFetch({}, { status: 500, ok: false });
+    const res = await httpFetch(`${baseUrl}/integration-linear/states?teamId=team-abc`);
+    assert.equal(res.ok, true);
+    const body = await res.json();
+    assert.equal(body.error, 'linear_fetch_failed');
+    assert.deepEqual(body.states, []);
+});

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