claude-remote-cli 3.9.5 → 3.11.0

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

package/dist/test/ticket-transitions.test.js

@@ -0,0 +1,265 @@
+import { test, describe, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createTicketTransitionsRouter } from '../server/ticket-transitions.js';
+// Shared temp config for all tests (checkPrTransitions calls loadConfig)
+let sharedTmpDir;
+let sharedConfigPath;
+before(() => {
+    sharedTmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tt-'));
+    sharedConfigPath = path.join(sharedTmpDir, 'config.json');
+    const minimalConfig = {
+        host: '0.0.0.0', port: 3456, cookieTTL: '24h', repos: [],
+        claudeCommand: 'claude', claudeArgs: [], defaultAgent: 'claude',
+        defaultContinue: true, defaultYolo: false, launchInTmux: false,
+        defaultNotifications: true,
+    };
+    fs.writeFileSync(sharedConfigPath, JSON.stringify(minimalConfig, null, 2));
+});
+after(() => {
+    fs.rmSync(sharedTmpDir, { recursive: true, force: true });
+});
+function makeExecMock(opts = {}) {
+    const calls = [];
+    const exec = async (cmd, args, options) => {
+        const command = cmd;
+        const argv = args;
+        const cwd = options?.cwd;
+        calls.push({ cmd: command, args: argv, cwd });
+        if (opts.shouldThrow) {
+            throw new Error('gh CLI error');
+        }
+        return { stdout: '', stderr: '' };
+    };
+    return { exec, calls };
+}
+function makeApp(execMock) {
+    const deps = { configPath: sharedConfigPath, execAsync: execMock };
+    return createTicketTransitionsRouter(deps);
+}
+const REPO_PATH = '/fake/workspace/repo-a';
+function makeTicketContext(overrides = {}) {
+    return {
+        ticketId: 'GH-1',
+        title: 'Test Issue',
+        url: 'https://github.com/fake/repo/issues/1',
+        source: 'github',
+        repoPath: REPO_PATH,
+        repoName: 'repo-a',
+        ...overrides,
+    };
+}
+function makeBranchLinks(ticketId, branchName) {
+    return {
+        [ticketId]: [
+            {
+                repoPath: REPO_PATH,
+                repoName: 'repo-a',
+                branchName,
+                hasActiveSession: true,
+            },
+        ],
+    };
+}
+describe('ticket-transitions', () => {
+    describe('transitionOnSessionCreate', () => {
+        test('adds in-progress label to GitHub issue', async () => {
+            const { exec, calls } = makeExecMock();
+            const { transitionOnSessionCreate } = makeApp(exec);
+            const ctx = makeTicketContext({ ticketId: 'GH-100' });
+            await transitionOnSessionCreate(ctx);
+            const addLabelCall = calls.find((c) => c.cmd === 'gh' && c.args.includes('--add-label') && c.args.includes('in-progress'));
+            assert.ok(addLabelCall, 'Should have called gh issue edit --add-label in-progress');
+            assert.equal(addLabelCall.cwd, REPO_PATH);
+            assert.ok(addLabelCall.args.includes('100'), 'Should pass issue number 100');
+        });
+        test('is idempotent — does not re-fire same transition', async () => {
+            const { exec, calls } = makeExecMock();
+            const { transitionOnSessionCreate } = makeApp(exec);
+            const ctx = makeTicketContext({ ticketId: 'GH-101' });
+            // First call — should fire
+            await transitionOnSessionCreate(ctx);
+            const firstCallCount = calls.length;
+            assert.ok(firstCallCount > 0, 'First call should trigger gh');
+            // Second call — should be a no-op (idempotent)
+            await transitionOnSessionCreate(ctx);
+            assert.equal(calls.length, firstCallCount, 'Second call should not trigger additional gh calls');
+        });
+    });
+    describe('checkPrTransitions', () => {
+        test('adds code-review label when PR is OPEN for a linked ticket', async () => {
+            const { exec, calls } = makeExecMock();
+            const { checkPrTransitions } = makeApp(exec);
+            const ticketId = 'GH-200';
+            const branchName = 'feat/my-feature';
+            const prs = [{ number: 1, headRefName: branchName, state: 'OPEN' }];
+            const branchLinks = makeBranchLinks(ticketId, branchName);
+            await checkPrTransitions(prs, branchLinks);
+            const addCodeReview = calls.find((c) => c.cmd === 'gh' && c.args.includes('--add-label') && c.args.includes('code-review'));
+            assert.ok(addCodeReview, 'Should have called gh issue edit --add-label code-review');
+            assert.equal(addCodeReview.cwd, REPO_PATH);
+            assert.ok(addCodeReview.args.includes('200'), 'Should pass issue number 200');
+            const removeInProgress = calls.find((c) => c.cmd === 'gh' && c.args.includes('--remove-label') && c.args.includes('in-progress'));
+            assert.ok(removeInProgress, 'Should have removed in-progress label');
+        });
+        test('adds ready-for-qa label when PR is MERGED for a linked ticket', async () => {
+            const { exec, calls } = makeExecMock();
+            const { checkPrTransitions } = makeApp(exec);
+            const ticketId = 'GH-300';
+            const branchName = 'feat/merged-feature';
+            const prs = [{ number: 2, headRefName: branchName, state: 'MERGED' }];
+            const branchLinks = makeBranchLinks(ticketId, branchName);
+            await checkPrTransitions(prs, branchLinks);
+            const addReadyForQa = calls.find((c) => c.cmd === 'gh' && c.args.includes('--add-label') && c.args.includes('ready-for-qa'));
+            assert.ok(addReadyForQa, 'Should have called gh issue edit --add-label ready-for-qa');
+            assert.equal(addReadyForQa.cwd, REPO_PATH);
+            assert.ok(addReadyForQa.args.includes('300'), 'Should pass issue number 300');
+            const removeCodeReview = calls.find((c) => c.cmd === 'gh' && c.args.includes('--remove-label') && c.args.includes('code-review'));
+            assert.ok(removeCodeReview, 'Should have removed code-review label');
+        });
+        test('is idempotent for PR transitions', async () => {
+            const { exec, calls } = makeExecMock();
+            const { checkPrTransitions } = makeApp(exec);
+            const ticketId = 'GH-400';
+            const branchName = 'feat/idempotent-pr';
+            const prs = [{ number: 3, headRefName: branchName, state: 'OPEN' }];
+            const branchLinks = makeBranchLinks(ticketId, branchName);
+            // First call — should fire
+            await checkPrTransitions(prs, branchLinks);
+            const firstCallCount = calls.length;
+            assert.ok(firstCallCount > 0, 'First call should trigger gh');
+            // Second call with same PR state — should be a no-op (idempotent)
+            await checkPrTransitions(prs, branchLinks);
+            assert.equal(calls.length, firstCallCount, 'Second call with same state should not trigger additional gh calls');
+        });
+        test('handles gh CLI errors gracefully', async () => {
+            const { exec } = makeExecMock({ shouldThrow: true });
+            const { checkPrTransitions } = makeApp(exec);
+            const ticketId = 'GH-500';
+            const branchName = 'feat/error-branch';
+            const prs = [{ number: 4, headRefName: branchName, state: 'OPEN' }];
+            const branchLinks = makeBranchLinks(ticketId, branchName);
+            // Should not throw even when gh CLI fails
+            await assert.doesNotReject(() => checkPrTransitions(prs, branchLinks), 'checkPrTransitions should not throw when gh CLI errors');
+        });
+    });
+});
+// ─── Jira transition tests ────────────────────────────────────────────────────
+describe('ticket-transitions (Jira)', () => {
+    let tmpDir;
+    let configPath;
+    before(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tt-jira-'));
+        configPath = path.join(tmpDir, 'config.json');
+    });
+    after(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    function writeJiraConfig(statusMappings) {
+        const config = {
+            host: '0.0.0.0',
+            port: 3456,
+            cookieTTL: '24h',
+            repos: [],
+            claudeCommand: 'claude',
+            claudeArgs: [],
+            defaultAgent: 'claude',
+            defaultContinue: true,
+            defaultYolo: false,
+            launchInTmux: false,
+            defaultNotifications: true,
+            integrations: {
+                jira: { projectKey: 'PROJ', statusMappings },
+            },
+        };
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    }
+    function makeJiraApp(execOverride) {
+        const { exec } = makeExecMock();
+        const effectiveExec = execOverride ?? exec;
+        const deps = { configPath, execAsync: effectiveExec };
+        return createTicketTransitionsRouter(deps);
+    }
+    test('transitionOnSessionCreate calls acli jira workitem transition for Jira ticket', async () => {
+        writeJiraConfig({ 'in-progress': 'In Progress' });
+        const acliCalls = [];
+        const trackingExec = async (cmd, args) => {
+            acliCalls.push({ cmd: cmd, args: args });
+            return { stdout: '', stderr: '' };
+        };
+        const { transitionOnSessionCreate } = makeJiraApp(trackingExec);
+        const ctx = {
+            ticketId: 'PROJ-123',
+            title: 'Test',
+            url: 'https://jira.example.com/browse/PROJ-123',
+            source: 'jira',
+            repoPath: '/fake/repo',
+            repoName: 'repo',
+        };
+        await transitionOnSessionCreate(ctx);
+        const transitionCall = acliCalls.find((c) => c.cmd === 'acli' && c.args.includes('transition') && c.args.includes('PROJ-123'));
+        assert.ok(transitionCall, `Expected acli jira workitem transition call, got: ${JSON.stringify(acliCalls)}`);
+        assert.ok(transitionCall.args.includes('In Progress'), 'Should pass the mapped status name');
+    });
+    test('transitionOnSessionCreate skips when no status mapping configured', async () => {
+        writeJiraConfig({}); // Empty mappings — no 'in-progress' key
+        const acliCalls = [];
+        const trackingExec = async (cmd, args) => {
+            acliCalls.push({ cmd: cmd, args: args });
+            return { stdout: '', stderr: '' };
+        };
+        const { transitionOnSessionCreate } = makeJiraApp(trackingExec);
+        const ctx = {
+            ticketId: 'PROJ-456',
+            title: 'Test',
+            url: 'https://jira.example.com/browse/PROJ-456',
+            source: 'jira',
+            repoPath: '/fake/repo',
+            repoName: 'repo',
+        };
+        await transitionOnSessionCreate(ctx);
+        assert.equal(acliCalls.length, 0, 'Should not call acli when no status mapping exists');
+    });
+    test('transitionOnSessionCreate is idempotent — second call blocked after success', async () => {
+        writeJiraConfig({ 'in-progress': 'In Progress' });
+        const acliCalls = [];
+        const trackingExec = async (cmd, args) => {
+            acliCalls.push({ cmd: cmd, args: args });
+            return { stdout: '', stderr: '' };
+        };
+        const { transitionOnSessionCreate } = makeJiraApp(trackingExec);
+        const ctx = {
+            ticketId: 'PROJ-55',
+            title: 'Jira test issue',
+            url: 'https://jira.example.com/browse/PROJ-55',
+            source: 'jira',
+            repoPath: '/fake/repo',
+            repoName: 'repo',
+        };
+        await transitionOnSessionCreate(ctx);
+        const firstCallCount = acliCalls.length;
+        assert.ok(firstCallCount > 0, 'First call should trigger acli');
+        // Second call — should be blocked by idempotency guard
+        await transitionOnSessionCreate(ctx);
+        assert.equal(acliCalls.length, firstCallCount, 'Second call should be blocked by idempotency guard after success');
+    });
+    test('checkPrTransitions calls acli jira workitem transition for OPEN PR with mapped Jira ticket', async () => {
+        writeJiraConfig({ 'code-review': 'Code Review', 'ready-for-qa': 'Ready for QA' });
+        const acliCalls = [];
+        const trackingExec = async (cmd, args) => {
+            acliCalls.push({ cmd: cmd, args: args });
+            return { stdout: '', stderr: '' };
+        };
+        const { checkPrTransitions } = makeJiraApp(trackingExec);
+        const prs = [{ number: 10, headRefName: 'feat/jira-pr', state: 'OPEN' }];
+        const branchLinks = {
+            'PROJ-789': [{ repoPath: '/fake/repo', repoName: 'repo', branchName: 'feat/jira-pr', hasActiveSession: true }],
+        };
+        await checkPrTransitions(prs, branchLinks);
+        const transitionCall = acliCalls.find((c) => c.cmd === 'acli' && c.args.includes('transition') && c.args.includes('PROJ-789'));
+        assert.ok(transitionCall, `Expected acli jira workitem transition call, got: ${JSON.stringify(acliCalls)}`);
+        assert.ok(transitionCall.args.includes('Code Review'), 'Should use code-review status name');
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-remote-cli",
-  "version": "3.9.5",
+  "version": "3.11.0",
   "description": "Remote web interface for Claude Code CLI sessions",
   "type": "module",
   "main": "dist/server/index.js",