claude-remote-cli 3.9.5 → 3.10.0

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

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