relay-ide 0.1.0

package/dist/test/test/pr-state.test.js

@@ -0,0 +1,220 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { derivePrAction, getActionPrompt, getStatusCssVar, shouldUseDarkText } from '../frontend/src/lib/pr-state.js';
+describe('derivePrAction', () => {
+    it('returns none when no commits ahead and no PR', () => {
+        const input = {
+            commitsAhead: 0,
+            prState: null,
+            ciPassing: 0, ciFailing: 0, ciPending: 0, ciTotal: 0,
+            mergeable: null, unresolvedCommentCount: 0,
+        };
+        const action = derivePrAction(input);
+        assert.equal(action.type, 'none');
+        assert.equal(action.color, 'none');
+        assert.equal(action.label, '');
+    });
+    it('returns create-pr when commits ahead but no PR', () => {
+        const input = {
+            commitsAhead: 3,
+            prState: null,
+            ciPassing: 0, ciFailing: 0, ciPending: 0, ciTotal: 0,
+            mergeable: null, unresolvedCommentCount: 0,
+        };
+        const action = derivePrAction(input);
+        assert.equal(action.type, 'create-pr');
+        assert.equal(action.color, 'accent');
+        assert.equal(action.label, 'Create PR');
+    });
+    it('returns ready-for-review for draft PR', () => {
+        const input = {
+            commitsAhead: 5,
+            prState: 'DRAFT',
+            ciPassing: 0, ciFailing: 0, ciPending: 0, ciTotal: 0,
+            mergeable: null, unresolvedCommentCount: 0,
+        };
+        const action = derivePrAction(input);
+        assert.equal(action.type, 'ready-for-review');
+        assert.equal(action.color, 'muted');
+        assert.equal(action.label, 'Ready for Review');
+    });
+    it('returns review-pr for open PR with all CI passing', () => {
+        const input = {
+            commitsAhead: 2,
+            prState: 'OPEN',
+            ciPassing: 5, ciFailing: 0, ciPending: 0, ciTotal: 5,
+            mergeable: 'MERGEABLE', unresolvedCommentCount: 0,
+        };
+        const action = derivePrAction(input);
+        assert.equal(action.type, 'review-pr');
+        assert.equal(action.color, 'success');
+        assert.equal(action.label, 'Review PR');
+    });
+    it('returns review-pr for open PR with no CI checks', () => {
+        const input = {
+            commitsAhead: 1,
+            prState: 'OPEN',
+            ciPassing: 0, ciFailing: 0, ciPending: 0, ciTotal: 0,
+            mergeable: 'MERGEABLE', unresolvedCommentCount: 0,
+        };
+        const action = derivePrAction(input);
+        assert.equal(action.type, 'review-pr');
+        assert.equal(action.color, 'success');
+    });
+    it('returns fix-errors for open PR with failing CI', () => {
+        const input = {
+            commitsAhead: 2,
+            prState: 'OPEN',
+            ciPassing: 6, ciFailing: 2, ciPending: 0, ciTotal: 8,
+            mergeable: 'MERGEABLE', unresolvedCommentCount: 0,
+        };
+        const action = derivePrAction(input);
+        assert.equal(action.type, 'fix-errors');
+        assert.equal(action.color, 'error');
+        assert.equal(action.label, 'Fix Errors 2/8');
+    });
+    it('returns checks-running for open PR with pending CI', () => {
+        const input = {
+            commitsAhead: 1,
+            prState: 'OPEN',
+            ciPassing: 3, ciFailing: 0, ciPending: 2, ciTotal: 5,
+            mergeable: 'MERGEABLE', unresolvedCommentCount: 0,
+        };
+        const action = derivePrAction(input);
+        assert.equal(action.type, 'checks-running');
+        assert.equal(action.color, 'warning');
+        assert.equal(action.label, 'Checks Running...');
+    });
+    it('prioritizes failing over pending CI', () => {
+        const input = {
+            commitsAhead: 1,
+            prState: 'OPEN',
+            ciPassing: 3, ciFailing: 1, ciPending: 1, ciTotal: 5,
+            mergeable: 'MERGEABLE', unresolvedCommentCount: 0,
+        };
+        const action = derivePrAction(input);
+        assert.equal(action.type, 'fix-errors');
+        assert.equal(action.label, 'Fix Errors 1/5');
+    });
+    it('returns archive-merged for merged PR', () => {
+        const input = {
+            commitsAhead: 0,
+            prState: 'MERGED',
+            ciPassing: 5, ciFailing: 0, ciPending: 0, ciTotal: 5,
+            mergeable: null, unresolvedCommentCount: 0,
+        };
+        const action = derivePrAction(input);
+        assert.equal(action.type, 'archive-merged');
+        assert.equal(action.color, 'merged');
+        assert.equal(action.label, 'Archive');
+    });
+    it('returns archive-closed for closed PR', () => {
+        const input = {
+            commitsAhead: 0,
+            prState: 'CLOSED',
+            ciPassing: 0, ciFailing: 0, ciPending: 0, ciTotal: 0,
+            mergeable: null, unresolvedCommentCount: 0,
+        };
+        const action = derivePrAction(input);
+        assert.equal(action.type, 'archive-closed');
+        assert.equal(action.color, 'muted');
+        assert.equal(action.label, 'Archive');
+    });
+    it('returns fix-conflicts for open PR with CONFLICTING mergeable', () => {
+        const input = {
+            commitsAhead: 2,
+            prState: 'OPEN',
+            ciPassing: 0, ciFailing: 0, ciPending: 0, ciTotal: 0,
+            mergeable: 'CONFLICTING', unresolvedCommentCount: 0,
+        };
+        const action = derivePrAction(input);
+        assert.equal(action.type, 'fix-conflicts');
+        assert.equal(action.color, 'error');
+        assert.equal(action.label, 'Fix Conflicts');
+    });
+    it('prioritizes fix-conflicts over fix-errors', () => {
+        const input = {
+            commitsAhead: 2,
+            prState: 'OPEN',
+            ciPassing: 0, ciFailing: 3, ciPending: 0, ciTotal: 3,
+            mergeable: 'CONFLICTING', unresolvedCommentCount: 0,
+        };
+        const action = derivePrAction(input);
+        assert.equal(action.type, 'fix-conflicts');
+    });
+    it('returns resolve-comments when unresolved comments > 0 and CI passing', () => {
+        const input = {
+            commitsAhead: 1,
+            prState: 'OPEN',
+            ciPassing: 5, ciFailing: 0, ciPending: 0, ciTotal: 5,
+            mergeable: 'MERGEABLE', unresolvedCommentCount: 3,
+        };
+        const action = derivePrAction(input);
+        assert.equal(action.type, 'resolve-comments');
+        assert.equal(action.color, 'accent');
+        assert.equal(action.label, 'Resolve Comments (3)');
+    });
+});
+describe('getActionPrompt', () => {
+    it('returns prompt for create-pr', () => {
+        const prompt = getActionPrompt({ type: 'create-pr', color: 'accent', label: 'Create PR' }, { branchName: 'feat/my-feature' });
+        assert.ok(prompt);
+        assert.ok(prompt.includes('feat/my-feature'));
+        assert.ok(prompt.includes('pull request'));
+    });
+    it('returns prompt for fix-errors', () => {
+        const prompt = getActionPrompt({ type: 'fix-errors', color: 'error', label: 'Fix Errors 2/8' }, { branchName: 'bugfix/auth' });
+        assert.ok(prompt);
+        assert.ok(prompt.includes('bugfix/auth'));
+        assert.ok(prompt.includes('failing'));
+    });
+    it('returns prompt for review-pr', () => {
+        const prompt = getActionPrompt({ type: 'review-pr', color: 'success', label: 'Review PR' }, { branchName: 'main', prNumber: 42 });
+        assert.ok(prompt);
+        assert.ok(prompt.includes('Review'));
+    });
+    it('returns prompt for fix-conflicts', () => {
+        const prompt = getActionPrompt({ type: 'fix-conflicts', color: 'error', label: 'Fix Conflicts' }, { branchName: 'feat/foo', baseBranch: 'main' });
+        assert.ok(prompt);
+        assert.ok(prompt.includes('main'));
+        assert.ok(prompt.includes('conflict'));
+    });
+    it('returns prompt for resolve-comments', () => {
+        const prompt = getActionPrompt({ type: 'resolve-comments', color: 'accent', label: 'Resolve Comments (3)' }, { branchName: 'feat/foo', prNumber: 7, unresolvedCommentCount: 3 });
+        assert.ok(prompt);
+        assert.ok(prompt.includes('3'));
+        assert.ok(prompt.includes('#7'));
+    });
+    it('returns null for archive actions', () => {
+        assert.equal(getActionPrompt({ type: 'archive-merged', color: 'merged', label: 'Archive' }, { branchName: 'main' }), null);
+        assert.equal(getActionPrompt({ type: 'archive-closed', color: 'muted', label: 'Archive' }, { branchName: 'main' }), null);
+    });
+    it('returns null for none and checks-running', () => {
+        assert.equal(getActionPrompt({ type: 'none', color: 'none', label: '' }, { branchName: 'main' }), null);
+        assert.equal(getActionPrompt({ type: 'checks-running', color: 'warning', label: 'Checks Running...' }, { branchName: 'main' }), null);
+    });
+});
+describe('getStatusCssVar', () => {
+    it('maps all colors correctly', () => {
+        assert.equal(getStatusCssVar('accent'), 'var(--accent)');
+        assert.equal(getStatusCssVar('success'), 'var(--status-success)');
+        assert.equal(getStatusCssVar('error'), 'var(--status-error)');
+        assert.equal(getStatusCssVar('warning'), 'var(--status-warning)');
+        assert.equal(getStatusCssVar('merged'), 'var(--status-merged)');
+        assert.equal(getStatusCssVar('muted'), 'var(--border)');
+        assert.equal(getStatusCssVar('none'), 'transparent');
+    });
+});
+describe('shouldUseDarkText', () => {
+    it('returns true for success and warning (light backgrounds)', () => {
+        assert.equal(shouldUseDarkText('success'), true);
+        assert.equal(shouldUseDarkText('warning'), true);
+    });
+    it('returns false for dark backgrounds', () => {
+        assert.equal(shouldUseDarkText('accent'), false);
+        assert.equal(shouldUseDarkText('error'), false);
+        assert.equal(shouldUseDarkText('merged'), false);
+        assert.equal(shouldUseDarkText('muted'), false);
+        assert.equal(shouldUseDarkText('none'), false);
+    });
+});

package/dist/test/test/pull-requests.test.js

@@ -0,0 +1,67 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+describe('PullRequest types', () => {
+    it('constructs a valid author PR', () => {
+        const pr = {
+            number: 42,
+            title: 'Fix bug',
+            url: 'https://github.com/owner/repo/pull/42',
+            headRefName: 'fix/bug',
+            baseRefName: 'main',
+            state: 'OPEN',
+            author: 'testuser',
+            role: 'author',
+            updatedAt: '2026-02-24T00:00:00Z',
+            additions: 10,
+            deletions: 5,
+            reviewDecision: 'APPROVED', mergeable: 'MERGEABLE',
+        };
+        assert.equal(pr.role, 'author');
+        assert.equal(pr.state, 'OPEN');
+    });
+    it('constructs a valid reviewer PR', () => {
+        const pr = {
+            number: 43,
+            title: 'Add feature',
+            url: 'https://github.com/owner/repo/pull/43',
+            headRefName: 'feat/new',
+            baseRefName: 'main',
+            state: 'OPEN',
+            author: 'otheruser',
+            role: 'reviewer',
+            updatedAt: '2026-02-24T00:00:00Z',
+            additions: 50,
+            deletions: 20,
+            reviewDecision: null, mergeable: null,
+        };
+        assert.equal(pr.role, 'reviewer');
+    });
+    it('constructs a valid response with error', () => {
+        const response = {
+            prs: [],
+            error: 'gh_not_authenticated',
+        };
+        assert.equal(response.prs.length, 0);
+        assert.equal(response.error, 'gh_not_authenticated');
+    });
+    it('constructs a valid response without error', () => {
+        const response = {
+            prs: [{
+                    number: 1,
+                    title: 'Test',
+                    url: 'https://github.com/o/r/pull/1',
+                    headRefName: 'test',
+                    baseRefName: 'main',
+                    state: 'OPEN',
+                    author: 'user',
+                    role: 'author',
+                    updatedAt: '2026-02-24T00:00:00Z',
+                    additions: 0,
+                    deletions: 0,
+                    reviewDecision: null, mergeable: null,
+                }],
+        };
+        assert.equal(response.prs.length, 1);
+        assert.equal(response.error, undefined);
+    });
+});

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

@@ -0,0 +1,235 @@
+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(() => {
+    // Guarantee no timer leaks between tests
+    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', () => {
+    saveConfig(configPath, {
+        ...DEFAULTS,
+        automations: { pollIntervalMs: 60_000 },
+    });
+    startPolling(makeDeps());
+    assert.equal(isPolling(), true);
+    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');
+});

package/dist/test/test/service.test.js

@@ -0,0 +1,43 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import * as service from '../server/service.js';
+test('getPlatform returns macos or linux', () => {
+    const platform = service.getPlatform();
+    assert.ok(platform === 'macos' || platform === 'linux', 'Expected macos or linux, got ' + platform);
+});
+test('getServicePaths returns expected keys', () => {
+    const paths = service.getServicePaths();
+    assert.ok(paths.servicePath, 'missing servicePath');
+    assert.equal(typeof paths.label, 'string', 'label should be a string');
+    assert.ok('logDir' in paths, 'missing logDir key');
+});
+test('generateServiceFile for macos contains plist XML', () => {
+    const content = service.generateServiceFile('macos', {
+        nodePath: '/usr/local/bin/node',
+        scriptPath: '/usr/local/lib/node_modules/claude-remote-cli/bin/claude-remote-cli.js',
+        configPath: '/Users/test/.config/claude-remote-cli/config.json',
+        port: '3456',
+        host: '0.0.0.0',
+        logDir: '/Users/test/.config/claude-remote-cli/logs',
+    });
+    assert.match(content, /<!DOCTYPE plist/, 'should be plist XML');
+    assert.match(content, /com\.claude-remote-cli/, 'should have label');
+    assert.match(content, /RunAtLoad/, 'should have RunAtLoad');
+    assert.match(content, /KeepAlive/, 'should have KeepAlive');
+    assert.match(content, /3456/, 'should include port');
+});
+test('generateServiceFile for linux contains systemd unit', () => {
+    const content = service.generateServiceFile('linux', {
+        nodePath: '/usr/bin/node',
+        scriptPath: '/usr/lib/node_modules/claude-remote-cli/bin/claude-remote-cli.js',
+        configPath: '/home/test/.config/claude-remote-cli/config.json',
+        port: '3456',
+        host: '0.0.0.0',
+        logDir: null,
+    });
+    assert.match(content, /\[Unit\]/, 'should have Unit section');
+    assert.match(content, /\[Service\]/, 'should have Service section');
+    assert.match(content, /\[Install\]/, 'should have Install section');
+    assert.match(content, /Restart=on-failure/, 'should restart on failure');
+    assert.match(content, /3456/, 'should include port');
+});