claude-remote-cli 3.9.5 → 3.10.0

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

package/dist/test/review-poller.test.js

@@ -0,0 +1,344 @@
+import { test, before, after, afterEach } 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 { startPolling, stopPolling, isPolling } from '../server/review-poller.js';
+import { saveConfig, DEFAULTS } from '../server/config.js';
+// ─── Shared fixtures ──────────────────────────────────────────────────────────
+let tmpDir;
+let configPath;
+const WORKSPACE_PATH = '/fake/workspace/my-repo';
+before(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'review-poller-test-'));
+    configPath = path.join(tmpDir, 'config.json');
+});
+after(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+afterEach(async () => {
+    // Guarantee no timer leaks between tests
+    await stopPolling();
+});
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+/** Builds a minimal GhNotification JSON string suitable for mock exec stdout. */
+function makeNotificationLine(overrides) {
+    const { id = 'notif-1', reason = 'review_requested', prNumber = 42, ownerRepo = 'owner/my-repo', updatedAt = new Date().toISOString(), title = 'Test PR', } = overrides;
+    return JSON.stringify({
+        id,
+        reason,
+        subject: {
+            title,
+            url: `https://api.github.com/repos/${ownerRepo}/pulls/${prNumber}`,
+            type: 'PullRequest',
+        },
+        repository: { full_name: ownerRepo },
+        updated_at: updatedAt,
+    });
+}
+/**
+ * Creates a mock execAsync. Routes by command:
+ * - `gh api /notifications` → returns notification lines joined by newline
+ * - `git remote get-url origin` → returns the configured remote URL
+ * - `git fetch ...` → resolves with empty output
+ * - `git worktree add ...` → resolves with empty output (unless worktreeError is set)
+ */
+function makeMockExec(opts) {
+    return async (cmd, args) => {
+        const command = cmd;
+        const argv = args;
+        opts.onExec?.(command, argv);
+        if (command === 'gh' && argv[0] === 'api') {
+            if (opts.ghError)
+                throw opts.ghError;
+            const lines = opts.notificationLines ?? [];
+            return { stdout: lines.join('\n'), stderr: '' };
+        }
+        if (command === 'git' && argv[0] === 'remote') {
+            if (opts.gitRemoteError)
+                throw opts.gitRemoteError;
+            const url = opts.remoteUrl ?? 'https://github.com/owner/my-repo.git';
+            return { stdout: url + '\n', stderr: '' };
+        }
+        if (command === 'git' && argv[0] === 'fetch') {
+            return { stdout: '', stderr: '' };
+        }
+        if (command === 'git' && argv[0] === 'worktree') {
+            if (opts.worktreeError)
+                throw opts.worktreeError;
+            return { stdout: '', stderr: '' };
+        }
+        throw new Error(`Unexpected exec call: ${command} ${argv.join(' ')}`);
+    };
+}
+/** Returns a deps object with sensible defaults. Override individual fields as needed. */
+function makeDeps(overrides = {}) {
+    return {
+        configPath,
+        getWorkspacePaths: () => [WORKSPACE_PATH],
+        getWorkspaceSettings: () => undefined,
+        createSession: async () => { },
+        broadcastEvent: () => { },
+        execAsync: makeMockExec({}),
+        ...overrides,
+    };
+}
+/** Waits for at least one poll cycle to complete given the interval. */
+function waitForCycles(intervalMs, cycles = 1) {
+    return new Promise((resolve) => setTimeout(resolve, intervalMs * cycles + 20));
+}
+// ─── Tests ────────────────────────────────────────────────────────────────────
+test('isPolling() returns false initially', () => {
+    assert.equal(isPolling(), false);
+});
+test('startPolling() sets isPolling() to true', () => {
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        automations: { pollIntervalMs: 60_000 },
+    });
+    startPolling(makeDeps());
+    assert.equal(isPolling(), true);
+});
+test('stopPolling() sets isPolling() to false', async () => {
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        automations: { pollIntervalMs: 60_000 },
+    });
+    startPolling(makeDeps());
+    assert.equal(isPolling(), true);
+    await stopPolling();
+    assert.equal(isPolling(), false);
+});
+test('startPolling() is idempotent — calling twice does not create two timers', async () => {
+    const INTERVAL = 50;
+    let callCount = 0;
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        automations: {
+            autoCheckoutReviewRequests: true,
+            pollIntervalMs: INTERVAL,
+            lastPollTimestamp: new Date().toISOString(),
+        },
+    });
+    const exec = makeMockExec({
+        onExec: (cmd, argv) => {
+            if (cmd === 'gh' && argv[0] === 'api')
+                callCount++;
+        },
+    });
+    const deps = makeDeps({ execAsync: exec });
+    startPolling(deps);
+    startPolling(deps); // second call must be a no-op
+    await waitForCycles(INTERVAL, 2);
+    // Two timer cycles elapsed. If only one timer exists, gh was called ~2 times.
+    // If startPolling were NOT idempotent (two timers), we would see ~4 calls.
+    assert.ok(callCount <= 3, `Expected at most 3 gh calls (got ${callCount}) — suggests only one timer running`);
+});
+test('first-run guard — when lastPollTimestamp is absent, no notifications are processed', async () => {
+    const INTERVAL = 50;
+    // Config without lastPollTimestamp — first-run scenario
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        automations: {
+            autoCheckoutReviewRequests: true,
+            pollIntervalMs: INTERVAL,
+            // No lastPollTimestamp — module will default to "now"
+        },
+    });
+    const broadcastedEvents = [];
+    let fetchCallCount = 0;
+    const exec = makeMockExec({
+        // Notification is old (well before "now"), so it should NOT be processed
+        notificationLines: [
+            makeNotificationLine({
+                updatedAt: new Date(Date.now() - 60_000).toISOString(), // 1 minute ago
+                ownerRepo: 'owner/my-repo',
+            }),
+        ],
+        remoteUrl: 'https://github.com/owner/my-repo.git',
+        onExec: (cmd, argv) => {
+            if (cmd === 'git' && argv[0] === 'fetch')
+                fetchCallCount++;
+        },
+    });
+    const deps = makeDeps({
+        execAsync: exec,
+        broadcastEvent: (event, data) => broadcastedEvents.push({ event, data }),
+    });
+    startPolling(deps);
+    await waitForCycles(INTERVAL);
+    // The notification predates the first-run "now" baseline, so no checkout should occur
+    assert.equal(fetchCallCount, 0, 'git fetch should not be called for historical notifications');
+    assert.equal(broadcastedEvents.length, 0, 'No review-checkout events should be broadcast');
+});
+test('JSON parse safety — non-JSON lines in gh output do not crash', async () => {
+    const INTERVAL = 50;
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        automations: {
+            autoCheckoutReviewRequests: true,
+            pollIntervalMs: INTERVAL,
+            lastPollTimestamp: new Date(Date.now() - 120_000).toISOString(), // 2 min ago
+        },
+    });
+    // Mix valid JSON with non-JSON warning lines that gh sometimes emits
+    const validNotification = makeNotificationLine({
+        updatedAt: new Date().toISOString(),
+        ownerRepo: 'owner/my-repo',
+        prNumber: 7,
+    });
+    const exec = makeMockExec({
+        notificationLines: [
+            'Warning: some gh warning message',
+            validNotification,
+            'another non-JSON line',
+        ],
+        remoteUrl: 'https://github.com/owner/my-repo.git',
+    });
+    // Just verify it doesn't throw — if parsing crashes, startPolling's setInterval
+    // would log an unhandled rejection. We capture broadcastEvent to confirm the
+    // valid notification was still processed.
+    const broadcastedEvents = [];
+    const deps = makeDeps({
+        execAsync: exec,
+        broadcastEvent: (event, data) => broadcastedEvents.push({ event, data }),
+    });
+    // Should not throw
+    startPolling(deps);
+    await waitForCycles(INTERVAL);
+    // The valid notification was newer than lastPollTimestamp — should be processed
+    const checkoutEvents = broadcastedEvents.filter((e) => e.event === 'review-checkout');
+    assert.equal(checkoutEvents.length, 1, 'Valid notification should still be processed despite surrounding non-JSON lines');
+});
+test('poll skips processing when autoCheckoutReviewRequests is disabled', async () => {
+    const INTERVAL = 50;
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        automations: {
+            autoCheckoutReviewRequests: false,
+            pollIntervalMs: INTERVAL,
+            lastPollTimestamp: new Date(Date.now() - 120_000).toISOString(),
+        },
+    });
+    let ghCallCount = 0;
+    const exec = makeMockExec({
+        notificationLines: [makeNotificationLine({ updatedAt: new Date().toISOString() })],
+        onExec: (cmd, argv) => {
+            if (cmd === 'gh' && argv[0] === 'api')
+                ghCallCount++;
+        },
+    });
+    startPolling(makeDeps({ execAsync: exec }));
+    await waitForCycles(INTERVAL);
+    // pollOnce returns early when the flag is off — gh should not even be called
+    assert.equal(ghCallCount, 0, 'gh should not be called when autoCheckoutReviewRequests is false');
+});
+test('stopPolling() awaits the in-flight poll before resolving', async () => {
+    const DELAY_MS = 100;
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        automations: {
+            autoCheckoutReviewRequests: true,
+            pollIntervalMs: 60_000,
+            lastPollTimestamp: new Date(Date.now() - 120_000).toISOString(),
+        },
+    });
+    const broadcastedEvents = [];
+    // Wrap the normal exec with a deliberate delay so the poll stays in-flight
+    const normalExec = makeMockExec({
+        notificationLines: [
+            makeNotificationLine({ updatedAt: new Date().toISOString(), ownerRepo: 'owner/my-repo' }),
+        ],
+        remoteUrl: 'https://github.com/owner/my-repo.git',
+    });
+    const delayedExec = async (...args) => {
+        await new Promise((r) => setTimeout(r, DELAY_MS));
+        return normalExec(...args);
+    };
+    const deps = makeDeps({
+        execAsync: delayedExec,
+        broadcastEvent: (event, data) => broadcastedEvents.push({ event, data }),
+    });
+    startPolling(deps);
+    // Give the initial poll just enough time to start (but not finish — it takes ~100ms per call)
+    await new Promise((r) => setTimeout(r, 10));
+    // stopPolling() must await the in-flight poll
+    await stopPolling();
+    // The poll ran to completion — broadcastEvent must have been called
+    const checkoutEvents = broadcastedEvents.filter((e) => e.event === 'review-checkout');
+    assert.ok(checkoutEvents.length >= 1, 'broadcastEvent should have been called before stopPolling() returned');
+});
+test('poll-start watermark: lastPollTimestamp saved is the time before the fetch, not after', async () => {
+    const INTERVAL = 60_000;
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        automations: {
+            autoCheckoutReviewRequests: true,
+            pollIntervalMs: INTERVAL,
+            lastPollTimestamp: new Date(Date.now() - 120_000).toISOString(),
+        },
+    });
+    const EXEC_DELAY_MS = 50;
+    const normalExec = makeMockExec({
+        notificationLines: [],
+        remoteUrl: 'https://github.com/owner/my-repo.git',
+    });
+    const delayedExec = async (...args) => {
+        await new Promise((r) => setTimeout(r, EXEC_DELAY_MS));
+        return normalExec(...args);
+    };
+    const deps = makeDeps({ execAsync: delayedExec });
+    // Bracket the poll with timestamps
+    const beforePoll = Date.now();
+    startPolling(deps);
+    await stopPolling(); // waits for the initial poll to complete
+    const afterPoll = Date.now();
+    // Read the config that was written by the poll
+    const savedConfig = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    const savedTs = savedConfig.automations?.lastPollTimestamp;
+    assert.ok(savedTs !== undefined, 'lastPollTimestamp should have been saved');
+    const savedMs = new Date(savedTs).getTime();
+    assert.ok(savedMs >= beforePoll, `saved timestamp (${savedTs}) should be >= poll start (${new Date(beforePoll).toISOString()})`);
+    assert.ok(savedMs <= afterPoll, `saved timestamp (${savedTs}) should be <= poll end (${new Date(afterPoll).toISOString()})`);
+    // The key invariant: the saved timestamp is the poll-START watermark, not poll-end.
+    // We verify this by confirming it precedes the time after stopPolling returned.
+    // Because exec has a deliberate delay, a poll-END timestamp would be noticeably later.
+    // We simply confirm the saved value is a valid ISO string within the expected window.
+    assert.ok(!isNaN(savedMs), 'saved lastPollTimestamp should be a valid date');
+});
+test('pollInFlight guard prevents overlapping poll cycles', async () => {
+    const INTERVAL_MS = 10;
+    const EXEC_DELAY_MS = 100; // each poll takes ~100ms — far longer than the interval
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        automations: {
+            autoCheckoutReviewRequests: true,
+            pollIntervalMs: INTERVAL_MS,
+            lastPollTimestamp: new Date(Date.now() - 120_000).toISOString(),
+        },
+    });
+    let ghCallCount = 0;
+    const normalExec = makeMockExec({
+        notificationLines: [],
+        remoteUrl: 'https://github.com/owner/my-repo.git',
+        onExec: (cmd, argv) => {
+            if (cmd === 'gh' && argv[0] === 'api')
+                ghCallCount++;
+        },
+    });
+    const delayedExec = async (...args) => {
+        await new Promise((r) => setTimeout(r, EXEC_DELAY_MS));
+        return normalExec(...args);
+    };
+    const deps = makeDeps({ execAsync: delayedExec });
+    startPolling(deps);
+    // Wait long enough for several timer ticks to fire (10ms interval × ~15 ticks = 150ms)
+    // but each poll takes 100ms, so without the guard we would expect many concurrent calls.
+    await new Promise((r) => setTimeout(r, 150));
+    await stopPolling();
+    // Without the pollInFlight guard, 150ms / 10ms = ~15 timer fires would each spawn a poll,
+    // meaning gh could be called ~15 times. With the guard, at most 2 polls can complete
+    // in 150ms (one starting at t=0 finishing at ~100ms, one starting at ~100ms finishing at ~200ms).
+    assert.ok(ghCallCount <= 3, `Expected at most 3 gh calls due to pollInFlight guard (got ${ghCallCount})`);
+    assert.ok(ghCallCount >= 1, `Expected at least 1 gh call to confirm polling ran (got ${ghCallCount})`);
+});