relay-ide 0.1.0

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

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

package/dist/test/mobile-input.test.js

@@ -0,0 +1,235 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync, readdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { processIntent } from '../server/mobile-input-pipeline.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const FIXTURES_DIR = join(__dirname, '..', '..', 'test', 'fixtures', 'mobile-input');
+function loadFixture(filename) {
+    const raw = readFileSync(join(FIXTURES_DIR, filename), 'utf-8');
+    return JSON.parse(raw);
+}
+function replayFixture(fixture) {
+    let totalPayload = '';
+    for (const step of fixture.events) {
+        const intent = {
+            type: step.inputType,
+            data: step.data,
+            rangeStart: step.rangeStart,
+            rangeEnd: step.rangeEnd,
+            valueBefore: step.valueBefore,
+            cursorBefore: step.cursorBefore,
+        };
+        const result = processIntent(intent, step.valueAfter);
+        totalPayload += result.payload;
+    }
+    return totalPayload;
+}
+function assertReplacementNotLost(payload, expectedReplacement, fixtureName) {
+    assert.ok(payload.includes(expectedReplacement), `[${fixtureName}] Payload contains only backspaces — replacement text "${expectedReplacement}" was lost. Got: ${JSON.stringify(payload)}`);
+}
+// ── Fixture replay tests ─────────────────────────────────────────────
+describe('mobile-input-pipeline: fixture replay', () => {
+    const fixtureFiles = readdirSync(FIXTURES_DIR).filter((f) => f.endsWith('.json'));
+    for (const file of fixtureFiles) {
+        const fixture = loadFixture(file);
+        it(`${fixture.name}: ${fixture.description}`, () => {
+            const actualPayload = replayFixture(fixture);
+            assert.strictEqual(actualPayload, fixture.expectedPayload, `Payload mismatch for fixture "${fixture.name}". ` +
+                `Expected: ${JSON.stringify(fixture.expectedPayload)}, ` +
+                `Got: ${JSON.stringify(actualPayload)}`);
+        });
+    }
+});
+// ── Autocorrect invariant tests ──────────────────────────────────────
+describe('mobile-input-pipeline: autocorrect always includes replacement text', () => {
+    it('Gboard range replacement includes replacement text', () => {
+        const fixture = loadFixture('gboard-autocorrect-range.json');
+        const payload = replayFixture(fixture);
+        assertReplacementNotLost(payload, 'the', fixture.name);
+    });
+    it('Gboard cursor-0 recovery includes replacement text', () => {
+        const fixture = loadFixture('gboard-autocorrect-cursor0.json');
+        const payload = replayFixture(fixture);
+        assertReplacementNotLost(payload, 'the', fixture.name);
+    });
+    it('iOS insertReplacementText includes replacement text', () => {
+        const fixture = loadFixture('ios-replacement-text.json');
+        const payload = replayFixture(fixture);
+        assertReplacementNotLost(payload, 'the', fixture.name);
+    });
+    it('multi-word buffer: only target word deleted, replacement inserted', () => {
+        const fixture = loadFixture('gboard-autocorrect-multi-word.json');
+        const payload = replayFixture(fixture);
+        assertReplacementNotLost(payload, 'the', fixture.name);
+        const backspaceCount = (payload.match(/\x7f/g) ?? []).length;
+        assert.strictEqual(backspaceCount, 3, `Expected 3 backspaces (for "teh") but got ${backspaceCount} — ` +
+            `pipeline is deleting more than the target word`);
+    });
+});
+// ── processIntent unit tests ─────────────────────────────────────────
+describe('mobile-input-pipeline: processIntent', () => {
+    it('normal character insertion sends data directly', () => {
+        const result = processIntent({
+            type: 'insertText',
+            data: 'a',
+            rangeStart: 5,
+            rangeEnd: 5,
+            valueBefore: 'hello',
+            cursorBefore: 5,
+        }, 'helloa');
+        assert.strictEqual(result.payload, 'a');
+        assert.strictEqual(result.newInputValue, undefined);
+    });
+    it('autocorrect with range sends backspaces + replacement', () => {
+        const result = processIntent({
+            type: 'insertText',
+            data: 'the',
+            rangeStart: 0,
+            rangeEnd: 3,
+            valueBefore: 'teh',
+            cursorBefore: 3,
+        }, 'the');
+        assert.strictEqual(result.payload, '\x7f\x7f\x7fthe');
+    });
+    it('cursor-0 recovery: single word buffer', () => {
+        const result = processIntent({
+            type: 'insertText',
+            data: 'the',
+            rangeStart: null,
+            rangeEnd: null,
+            valueBefore: 'teh',
+            cursorBefore: 0,
+        }, 'theteh');
+        assert.strictEqual(result.payload, '\x7f\x7f\x7fthe');
+        assert.strictEqual(result.newInputValue, 'the');
+    });
+    it('cursor-0 recovery: multi-word buffer only deletes last word', () => {
+        const result = processIntent({
+            type: 'insertText',
+            data: 'mobile ',
+            rangeStart: null,
+            rangeEnd: null,
+            valueBefore: 'and mkbijf',
+            cursorBefore: 0,
+        }, 'mobile and mkbijf');
+        assert.strictEqual(result.payload, '\x7f\x7f\x7f\x7f\x7f\x7fmobile ');
+        assert.strictEqual(result.newInputValue, 'and mobile ');
+    });
+    it('cursor-0 recovery: suffix-only data (data[0] !== firstChar)', () => {
+        // Gboard sends suffix "esting " instead of full word "testing "
+        // because firstChar "t" was kept and data starts with "e"
+        const result = processIntent({
+            type: 'insertText',
+            data: 'esting ',
+            rangeStart: null,
+            rangeEnd: null,
+            valueBefore: 'tsestin',
+            cursorBefore: 0,
+        }, 'esting tsestin');
+        // data[0]='e' !== firstChar='t' → suffix mode: "t" + "esting " = "testing "
+        assert.strictEqual(result.payload, '\x7f\x7f\x7f\x7f\x7f\x7f\x7ftesting ');
+        assert.strictEqual(result.newInputValue, 'testing ');
+    });
+    it('cursor-0 recovery: trailing space means nothing to autocorrect', () => {
+        const result = processIntent({
+            type: 'insertText',
+            data: 'the ',
+            rangeStart: null,
+            rangeEnd: null,
+            valueBefore: 'hello ',
+            cursorBefore: 0,
+        }, 'the hello ');
+        assert.strictEqual(result.payload, '');
+        assert.strictEqual(result.newInputValue, 'hello ');
+    });
+    it('deleteContentBackward with range', () => {
+        const result = processIntent({
+            type: 'deleteContentBackward',
+            data: null,
+            rangeStart: 4,
+            rangeEnd: 5,
+            valueBefore: 'hello',
+            cursorBefore: 5,
+        }, 'hell');
+        assert.strictEqual(result.payload, '\x7f');
+    });
+    it('deleteWordBackward with range sends correct backspace count', () => {
+        const result = processIntent({
+            type: 'deleteWordBackward',
+            data: null,
+            rangeStart: 6,
+            rangeEnd: 11,
+            valueBefore: 'hello world',
+            cursorBefore: 11,
+        }, 'hello ');
+        assert.strictEqual(result.payload, '\x7f\x7f\x7f\x7f\x7f');
+    });
+    it('deleteContentBackward without range falls back to diff', () => {
+        const result = processIntent({
+            type: 'deleteContentBackward',
+            data: null,
+            rangeStart: null,
+            rangeEnd: null,
+            valueBefore: 'hello',
+            cursorBefore: 5,
+        }, 'hell');
+        assert.strictEqual(result.payload, '\x7f');
+    });
+    it('insertReplacementText sends backspaces + replacement', () => {
+        const result = processIntent({
+            type: 'insertReplacementText',
+            data: 'the',
+            rangeStart: 0,
+            rangeEnd: 3,
+            valueBefore: 'teh',
+            cursorBefore: 3,
+        }, 'the');
+        assert.strictEqual(result.payload, '\x7f\x7f\x7fthe');
+    });
+    it('insertFromPaste uses diff to extract pasted text', () => {
+        const result = processIntent({
+            type: 'insertFromPaste',
+            data: null,
+            rangeStart: null,
+            rangeEnd: null,
+            valueBefore: 'hello',
+            cursorBefore: 5,
+        }, 'hello world');
+        assert.strictEqual(result.payload, ' world');
+    });
+    it('unknown inputType falls back to diff', () => {
+        const result = processIntent({
+            type: 'insertFromYank',
+            data: null,
+            rangeStart: null,
+            rangeEnd: null,
+            valueBefore: 'hllo',
+            cursorBefore: 1,
+        }, 'hello');
+        assert.strictEqual(result.payload, '\x7f\x7f\x7fello');
+    });
+    it('empty payload for no-op diff', () => {
+        const result = processIntent({
+            type: 'insertText',
+            data: null,
+            rangeStart: null,
+            rangeEnd: null,
+            valueBefore: 'hello',
+            cursorBefore: 5,
+        }, 'hello');
+        assert.strictEqual(result.payload, '');
+    });
+    it('handles emoji codepoints correctly in autocorrect range', () => {
+        const result = processIntent({
+            type: 'insertText',
+            data: 'smile',
+            rangeStart: 0,
+            rangeEnd: 2,
+            valueBefore: '😊',
+            cursorBefore: 2,
+        }, 'smile');
+        assert.strictEqual(result.payload, '\x7fsmile');
+    });
+});

package/dist/test/opencode-relay.test.js

@@ -0,0 +1,107 @@
+import { describe, it, 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 { installOpencodeRelayPlugin, RELAY_PLUGIN_SOURCE, } from '../server/opencode-relay.js';
+let tmpDir;
+before(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'crc-opencode-relay-test-'));
+});
+after(() => {
+    fs.rmSync(tmpDir, { recursive: true });
+});
+describe('RELAY_PLUGIN_SOURCE', () => {
+    it('contains expected opencode hook event names', () => {
+        assert.ok(RELAY_PLUGIN_SOURCE.includes('session.created'), 'should include session.created');
+        assert.ok(RELAY_PLUGIN_SOURCE.includes('session.idle'), 'should include session.idle');
+        assert.ok(RELAY_PLUGIN_SOURCE.includes('session.status'), 'should include session.status');
+        assert.ok(RELAY_PLUGIN_SOURCE.includes('session.error'), 'should include session.error');
+        assert.ok(RELAY_PLUGIN_SOURCE.includes('permission.asked'), 'should include permission.asked');
+        assert.ok(RELAY_PLUGIN_SOURCE.includes('permission.replied'), 'should include permission.replied');
+        assert.ok(RELAY_PLUGIN_SOURCE.includes('tool.execute.before'), 'should include tool.execute.before');
+        assert.ok(RELAY_PLUGIN_SOURCE.includes('tool.execute.after'), 'should include tool.execute.after');
+        assert.ok(RELAY_PLUGIN_SOURCE.includes('message.updated'), 'should include message.updated');
+    });
+    it('reads CRC_RELAY_URL from env', () => {
+        assert.ok(RELAY_PLUGIN_SOURCE.includes('CRC_RELAY_URL'), 'should read CRC_RELAY_URL from env');
+        assert.ok(RELAY_PLUGIN_SOURCE.includes('process.env.CRC_RELAY_URL'), 'should use process.env.CRC_RELAY_URL');
+    });
+    it('reads CRC_SESSION_ID from env', () => {
+        assert.ok(RELAY_PLUGIN_SOURCE.includes('CRC_SESSION_ID'), 'should read CRC_SESSION_ID from env');
+        assert.ok(RELAY_PLUGIN_SOURCE.includes('process.env.CRC_SESSION_ID'), 'should use process.env.CRC_SESSION_ID');
+    });
+    it('reads CRC_RELAY_TOKEN from env', () => {
+        assert.ok(RELAY_PLUGIN_SOURCE.includes('CRC_RELAY_TOKEN'), 'should read CRC_RELAY_TOKEN from env');
+        assert.ok(RELAY_PLUGIN_SOURCE.includes('process.env.CRC_RELAY_TOKEN'), 'should use process.env.CRC_RELAY_TOKEN');
+    });
+    it('relays to /hooks/agent-event endpoint', () => {
+        assert.ok(RELAY_PLUGIN_SOURCE.includes('/hooks/agent-event'), 'should POST to /hooks/agent-event');
+    });
+    it('uses POST method for relay', () => {
+        assert.ok(RELAY_PLUGIN_SOURCE.includes("method: 'POST'"), 'should use POST method');
+    });
+    it('returns early when env vars are missing', () => {
+        assert.ok(RELAY_PLUGIN_SOURCE.includes('if (!relayUrl || !sessionId || !token) return {};'), 'should return empty object when env vars are missing');
+    });
+    it('includes sessionId and token in request body', () => {
+        assert.ok(RELAY_PLUGIN_SOURCE.includes('sessionId'), 'should include sessionId in body');
+        assert.ok(RELAY_PLUGIN_SOURCE.includes('token'), 'should include token in body');
+    });
+    it('includes eventType and timestamp in request body', () => {
+        assert.ok(RELAY_PLUGIN_SOURCE.includes('eventType'), 'should include eventType in body');
+        assert.ok(RELAY_PLUGIN_SOURCE.includes('timestamp'), 'should include timestamp in body');
+    });
+    it('is a non-empty string', () => {
+        assert.ok(typeof RELAY_PLUGIN_SOURCE === 'string', 'should be a string');
+        assert.ok(RELAY_PLUGIN_SOURCE.length > 0, 'should not be empty');
+    });
+    it('exports a default async function', () => {
+        assert.ok(RELAY_PLUGIN_SOURCE.includes('export default async'), 'should export a default async function');
+    });
+});
+describe('installOpencodeRelayPlugin', () => {
+    it('writes the plugin file to the specified directory', () => {
+        const pluginDir = path.join(tmpDir, 'write-test');
+        const pluginPath = installOpencodeRelayPlugin(pluginDir);
+        assert.ok(fs.existsSync(pluginPath), 'plugin file should exist');
+        assert.strictEqual(path.basename(pluginPath), 'crc-relay.ts', 'file should be named crc-relay.ts');
+    });
+    it('returns the path to the written plugin file', () => {
+        const pluginDir = path.join(tmpDir, 'return-path-test');
+        const pluginPath = installOpencodeRelayPlugin(pluginDir);
+        const expectedPath = path.join(pluginDir, 'crc-relay.ts');
+        assert.strictEqual(pluginPath, expectedPath, 'should return path to crc-relay.ts in pluginDir');
+    });
+    it('creates the directory if it does not exist', () => {
+        const pluginDir = path.join(tmpDir, 'nested', 'dirs', 'plugins');
+        assert.ok(!fs.existsSync(pluginDir), 'directory should not exist yet');
+        installOpencodeRelayPlugin(pluginDir);
+        assert.ok(fs.existsSync(pluginDir), 'directory should be created');
+    });
+    it('writes exactly RELAY_PLUGIN_SOURCE as the file content', () => {
+        const pluginDir = path.join(tmpDir, 'content-test');
+        const pluginPath = installOpencodeRelayPlugin(pluginDir);
+        const content = fs.readFileSync(pluginPath, 'utf-8');
+        assert.strictEqual(content, RELAY_PLUGIN_SOURCE, 'file content should match RELAY_PLUGIN_SOURCE');
+    });
+    it('is idempotent — write twice, file still has valid content', () => {
+        const pluginDir = path.join(tmpDir, 'idempotent-test');
+        installOpencodeRelayPlugin(pluginDir);
+        installOpencodeRelayPlugin(pluginDir);
+        const pluginPath = path.join(pluginDir, 'crc-relay.ts');
+        const content = fs.readFileSync(pluginPath, 'utf-8');
+        assert.strictEqual(content, RELAY_PLUGIN_SOURCE, 'file should still have valid content after second write');
+    });
+    it('default path includes opencode/plugins in home dir when no arg given', () => {
+        // We test the default path logic by inspecting the function signature behavior.
+        // We cannot call with no arg since it would write to the real ~/.config/opencode/plugins,
+        // so instead we verify that pluginDir parameter defaults correctly by checking the source.
+        // The actual installOpencodeRelayPlugin(pluginDir) overload is tested above.
+        // Just verify the function is callable and returns a string path.
+        const pluginDir = path.join(tmpDir, 'default-path-test');
+        const result = installOpencodeRelayPlugin(pluginDir);
+        assert.ok(typeof result === 'string', 'should return a string path');
+        assert.ok(result.endsWith('crc-relay.ts'), 'returned path should end with crc-relay.ts');
+    });
+});