relay-ide 0.1.0

package/dist/test/presets.test.js

@@ -0,0 +1,242 @@
+import { test, describe, 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 { DEFAULT_PRESETS, DEFAULTS, loadConfig, saveConfig, } from '../server/config.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+let tmpDir;
+function makeConfigPath() {
+    return path.join(tmpDir, 'config.json');
+}
+/**
+ * Applies the same validation logic used in POST /presets (server/index.ts).
+ * Returns an error string or null if valid.
+ */
+function validatePreset(body) {
+    const { name, sort } = body;
+    if (!name || typeof name !== 'string' || !name.trim()) {
+        return 'name is required';
+    }
+    if (sort && typeof sort === 'object') {
+        const dir = sort.direction;
+        if (dir !== 'asc' && dir !== 'desc') {
+            return 'sort.direction must be "asc" or "desc"';
+        }
+    }
+    return null;
+}
+/**
+ * Applies the same deletion guard used in DELETE /presets/:name (server/index.ts).
+ * Returns an error string or null if deletion is allowed.
+ */
+function validateDeletion(presets, name) {
+    const target = presets.find((p) => p.name === name);
+    if (!target) {
+        return 'Preset not found';
+    }
+    if (target.builtIn) {
+        return 'Cannot delete a built-in preset';
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Setup / teardown
+// ---------------------------------------------------------------------------
+before(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'preset-test-'));
+});
+afterEach(() => {
+    for (const entry of fs.readdirSync(tmpDir, { withFileTypes: true })) {
+        const fullPath = path.join(tmpDir, entry.name);
+        if (entry.isDirectory()) {
+            fs.rmSync(fullPath, { recursive: true });
+        }
+        else {
+            fs.unlinkSync(fullPath);
+        }
+    }
+});
+after(() => {
+    fs.rmdirSync(tmpDir);
+});
+// ---------------------------------------------------------------------------
+// Tests — DEFAULT_PRESETS
+// ---------------------------------------------------------------------------
+describe('DEFAULT_PRESETS', () => {
+    test('contains at least two built-in presets', () => {
+        assert.ok(DEFAULT_PRESETS.length >= 2, 'should have at least 2 default presets');
+    });
+    test('all default presets are marked builtIn', () => {
+        for (const preset of DEFAULT_PRESETS) {
+            assert.equal(preset.builtIn, true, `preset "${preset.name}" should be builtIn`);
+        }
+    });
+    test('all default presets have valid sort direction', () => {
+        for (const preset of DEFAULT_PRESETS) {
+            assert.ok(preset.sort.direction === 'asc' || preset.sort.direction === 'desc', `preset "${preset.name}" has invalid sort.direction: ${preset.sort.direction}`);
+        }
+    });
+});
+// ---------------------------------------------------------------------------
+// Tests — loadConfig sets default presets when absent
+// ---------------------------------------------------------------------------
+describe('loadConfig preset initialisation', () => {
+    test('injects DEFAULT_PRESETS when filterPresets is absent from config file', () => {
+        const configPath = makeConfigPath();
+        fs.writeFileSync(configPath, JSON.stringify({ port: 3456 }), 'utf8');
+        const config = loadConfig(configPath);
+        assert.deepEqual(config.filterPresets, DEFAULT_PRESETS);
+    });
+    test('preserves user-supplied filterPresets from config file', () => {
+        const configPath = makeConfigPath();
+        const userPresets = [
+            {
+                name: 'My Preset',
+                filters: {},
+                sort: { column: 'age', direction: 'asc' },
+            },
+        ];
+        fs.writeFileSync(configPath, JSON.stringify({ port: 3456, filterPresets: userPresets }), 'utf8');
+        const config = loadConfig(configPath);
+        assert.deepEqual(config.filterPresets, userPresets);
+    });
+});
+// ---------------------------------------------------------------------------
+// Tests — POST /presets validation logic
+// ---------------------------------------------------------------------------
+describe('preset creation validation', () => {
+    test('rejects missing name', () => {
+        assert.equal(validatePreset({ sort: { direction: 'asc' } }), 'name is required');
+    });
+    test('rejects empty string name', () => {
+        assert.equal(validatePreset({ name: '' }), 'name is required');
+    });
+    test('rejects whitespace-only name', () => {
+        assert.equal(validatePreset({ name: '   ' }), 'name is required');
+    });
+    test('rejects invalid sort.direction', () => {
+        assert.equal(validatePreset({ name: 'Valid Name', sort: { direction: 'invalid' } }), 'sort.direction must be "asc" or "desc"');
+    });
+    test('accepts valid name with asc direction', () => {
+        assert.equal(validatePreset({ name: 'My Preset', sort: { direction: 'asc' } }), null);
+    });
+    test('accepts valid name with desc direction', () => {
+        assert.equal(validatePreset({ name: 'My Preset', sort: { direction: 'desc' } }), null);
+    });
+    test('accepts valid name with no sort (sort is optional)', () => {
+        assert.equal(validatePreset({ name: 'My Preset' }), null);
+    });
+});
+// ---------------------------------------------------------------------------
+// Tests — preset storage (push + saveConfig round-trip)
+// ---------------------------------------------------------------------------
+describe('preset storage', () => {
+    test('new preset is persisted via saveConfig and reloaded by loadConfig', () => {
+        const configPath = makeConfigPath();
+        saveConfig(configPath, {
+            ...DEFAULTS,
+            filterPresets: [...DEFAULT_PRESETS],
+        });
+        const config = loadConfig(configPath);
+        const newPreset = {
+            name: 'Team Review',
+            filters: { role: ['reviewer'] },
+            sort: { column: 'age', direction: 'desc' },
+        };
+        config.filterPresets.push(newPreset);
+        saveConfig(configPath, config);
+        const reloaded = loadConfig(configPath);
+        const found = reloaded.filterPresets?.find((p) => p.name === 'Team Review');
+        assert.ok(found, 'saved preset should be present after reload');
+        assert.deepEqual(found, newPreset);
+    });
+    test('duplicate name can be pushed (endpoint does not deduplicate — caller responsibility)', () => {
+        // The server endpoint does not currently check for duplicate names,
+        // so both entries will be stored. This test documents that behaviour.
+        const configPath = makeConfigPath();
+        saveConfig(configPath, {
+            ...DEFAULTS,
+            filterPresets: [...DEFAULT_PRESETS],
+        });
+        const config = loadConfig(configPath);
+        const preset = {
+            name: 'Dupe',
+            filters: {},
+            sort: { column: 'role', direction: 'asc' },
+        };
+        config.filterPresets.push(preset);
+        config.filterPresets.push(preset);
+        saveConfig(configPath, config);
+        const reloaded = loadConfig(configPath);
+        const matches = reloaded.filterPresets?.filter((p) => p.name === 'Dupe') ?? [];
+        assert.equal(matches.length, 2, 'both duplicate entries should be stored');
+    });
+});
+// ---------------------------------------------------------------------------
+// Tests — DELETE /presets validation logic
+// ---------------------------------------------------------------------------
+describe('preset deletion validation', () => {
+    test('rejects deletion of a built-in preset', () => {
+        const presets = [
+            {
+                name: 'All PRs',
+                builtIn: true,
+                filters: {},
+                sort: { column: 'age', direction: 'desc' },
+            },
+        ];
+        assert.equal(validateDeletion(presets, 'All PRs'), 'Cannot delete a built-in preset');
+    });
+    test('rejects deletion of a preset that does not exist', () => {
+        const presets = [
+            {
+                name: 'All PRs',
+                builtIn: true,
+                filters: {},
+                sort: { column: 'age', direction: 'desc' },
+            },
+        ];
+        assert.equal(validateDeletion(presets, 'Nonexistent'), 'Preset not found');
+    });
+    test('allows deletion of a user-created preset', () => {
+        const presets = [
+            {
+                name: 'All PRs',
+                builtIn: true,
+                filters: {},
+                sort: { column: 'age', direction: 'desc' },
+            },
+            {
+                name: 'My Custom',
+                filters: {},
+                sort: { column: 'role', direction: 'asc' },
+            },
+        ];
+        assert.equal(validateDeletion(presets, 'My Custom'), null);
+    });
+    test('deletion removes exactly the named preset and leaves others intact', () => {
+        const configPath = makeConfigPath();
+        const initialPresets = [
+            ...DEFAULT_PRESETS,
+            {
+                name: 'To Delete',
+                filters: {},
+                sort: { column: 'role', direction: 'asc' },
+            },
+        ];
+        saveConfig(configPath, { ...DEFAULTS, filterPresets: initialPresets });
+        const config = loadConfig(configPath);
+        config.filterPresets = config.filterPresets.filter((p) => p.name !== 'To Delete');
+        saveConfig(configPath, config);
+        const reloaded = loadConfig(configPath);
+        const remaining = reloaded.filterPresets ?? [];
+        assert.equal(remaining.find((p) => p.name === 'To Delete'), undefined, 'deleted preset should not exist');
+        // Built-in presets survive
+        for (const dp of DEFAULT_PRESETS) {
+            assert.ok(remaining.find((p) => p.name === dp.name), `built-in preset "${dp.name}" should still be present`);
+        }
+    });
+});

package/dist/test/pty-handler-multi-agent.test.js

@@ -0,0 +1,149 @@
+import { afterEach, beforeEach, describe, it } 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 * as sessions from '../server/sessions.js';
+const createdIds = [];
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function waitForScrollbackContains(sessionId, needle, timeoutMs = 4000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const session = sessions.get(sessionId);
+        if (session) {
+            const output = session.scrollback.join('');
+            if (output.includes(needle))
+                return output;
+        }
+        await delay(50);
+    }
+    throw new Error(`Timed out waiting for scrollback to contain: ${needle}`);
+}
+describe('PTY multi-agent hook/plugin wiring', () => {
+    const originalHome = process.env.HOME;
+    let testHome;
+    beforeEach(() => {
+        testHome = fs.mkdtempSync(path.join(os.tmpdir(), 'crc-multi-agent-home-'));
+        process.env.HOME = testHome;
+    });
+    afterEach(() => {
+        for (const id of createdIds) {
+            try {
+                if (sessions.get(id))
+                    sessions.kill(id);
+            }
+            catch { }
+        }
+        createdIds.length = 0;
+        process.env.HOME = originalHome;
+        fs.rmSync(testHome, { recursive: true, force: true });
+    });
+    it('installs OpenCode relay plugin and injects relay env vars', async () => {
+        const port = 4567;
+        const hookToken = 'opencode-hook-token';
+        const result = sessions.create({
+            repoName: 'test-repo',
+            repoPath: '/tmp',
+            worktreePath: null,
+            cwd: '/tmp',
+            agent: 'opencode',
+            command: process.execPath,
+            args: [
+                '-e',
+                [
+                    "const fs=require('node:fs');",
+                    "const os=require('node:os');",
+                    "const path=require('node:path');",
+                    "console.log('CRC_RELAY_URL='+(process.env.CRC_RELAY_URL||''));",
+                    "console.log('CRC_SESSION_ID='+(process.env.CRC_SESSION_ID||''));",
+                    "console.log('CRC_RELAY_TOKEN='+(process.env.CRC_RELAY_TOKEN||''));",
+                    "const pluginPath=path.join(os.homedir(),'.config','opencode','plugins','crc-relay.ts');",
+                    "console.log('PLUGIN_EXISTS='+fs.existsSync(pluginPath));",
+                    'setTimeout(()=>{},10000);',
+                ].join(' '),
+            ],
+            port,
+            hookToken,
+        });
+        createdIds.push(result.id);
+        const output = await waitForScrollbackContains(result.id, 'PLUGIN_EXISTS=true');
+        assert.match(output, new RegExp(`CRC_RELAY_URL=http://127\\.0\\.0\\.1:${port}`));
+        assert.match(output, new RegExp(`CRC_SESSION_ID=${result.id}`));
+        assert.match(output, new RegExp(`CRC_RELAY_TOKEN=${hookToken}`));
+    });
+    it('writes Codex hooks adapter and injects CODEX_CONFIG_DIR', async () => {
+        const result = sessions.create({
+            repoName: 'test-repo',
+            repoPath: '/tmp',
+            worktreePath: null,
+            cwd: '/tmp',
+            agent: 'codex',
+            command: process.execPath,
+            args: [
+                '-e',
+                [
+                    "const fs=require('node:fs');",
+                    "const path=require('node:path');",
+                    "const dir=process.env.CODEX_CONFIG_DIR||'';",
+                    "console.log('CODEX_CONFIG_DIR='+dir);",
+                    "console.log('HAS_HOOKS_JSON='+(dir && fs.existsSync(path.join(dir,'hooks.json'))));",
+                    "console.log('HAS_RELAY_SH='+(dir && fs.existsSync(path.join(dir,'relay.sh'))));",
+                    'setTimeout(()=>{},10000);',
+                ].join(' '),
+            ],
+            port: 7777,
+            hookToken: 'codex-token',
+            configDir: '/tmp',
+        });
+        createdIds.push(result.id);
+        const output = await waitForScrollbackContains(result.id, 'HAS_RELAY_SH=true');
+        assert.match(output, /CODEX_CONFIG_DIR=\/.*codex-hooks-/);
+        assert.match(output, /HAS_HOOKS_JSON=true/);
+    });
+    it('resolves framework from config.frameworks overrides', () => {
+        const result = sessions.create({
+            repoName: 'test-repo',
+            repoPath: '/tmp',
+            worktreePath: null,
+            cwd: '/tmp',
+            agent: 'claude',
+            command: '/bin/cat',
+            args: [],
+            frameworks: {
+                claude: {
+                    eventSource: 'parser',
+                },
+            },
+        });
+        createdIds.push(result.id);
+        const session = sessions.get(result.id);
+        assert.ok(session);
+        assert.equal(session.dataQuality, 'parser');
+    });
+    it('injects framework.yoloEnv for opencode in yolo mode', async () => {
+        const result = sessions.create({
+            repoName: 'test-repo',
+            repoPath: '/tmp',
+            worktreePath: null,
+            cwd: '/tmp',
+            agent: 'opencode',
+            yolo: true,
+            command: process.execPath,
+            args: [
+                '-e',
+                [
+                    "const cfg=process.env.OPENCODE_CONFIG_CONTENT||'';",
+                    "console.log('OPENCODE_CONFIG_CONTENT='+cfg);",
+                    'setTimeout(()=>{},10000);',
+                ].join(' '),
+            ],
+            port: 3456,
+            hookToken: 'tok-opencode',
+        });
+        createdIds.push(result.id);
+        const output = await waitForScrollbackContains(result.id, 'OPENCODE_CONFIG_CONTENT=');
+        assert.match(output, /OPENCODE_CONFIG_CONTENT=.*"permission"/);
+    });
+});

package/dist/test/pty-handler.test.js

@@ -0,0 +1,146 @@
+import { describe, it, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import * as sessions from '../server/sessions.js';
+import { buildStatusLineRelayScript } from '../server/pty-handler.js';
+describe('status-line relay script', () => {
+    it('writes telemetry via a temp file while streaming stdin once', () => {
+        const script = buildStatusLineRelayScript('session-123', '/tmp/claude-remote-config', '/usr/local/bin/status-line');
+        assert.match(script, /mktemp/);
+        assert.match(script, /tee "\$tmp_file"/);
+        assert.match(script, /mv "\$tmp_file"/);
+        assert.doesNotMatch(script, /input=\$\(cat\)/);
+    });
+});
+describe('framework-driven PTY handler', () => {
+    const createdIds = [];
+    afterEach(() => {
+        for (const id of createdIds) {
+            try {
+                const session = sessions.get(id);
+                if (session)
+                    sessions.kill(id);
+            }
+            catch {
+                /* already cleaned up */
+            }
+        }
+        createdIds.length = 0;
+    });
+    it('command is resolved from framework.command when no override specified', () => {
+        // When agent=codex and no custom command, the session agent field should be codex
+        // (the actual pty command is internal — we verify it started by the session being active)
+        const result = sessions.create({
+            repoName: 'test-repo',
+            repoPath: '/tmp',
+            worktreePath: null,
+            cwd: '/tmp',
+            agent: 'codex',
+            command: '/bin/echo', // use custom command to avoid spawning real codex binary
+            args: ['hello'],
+        });
+        createdIds.push(result.id);
+        assert.equal(result.agent, 'codex');
+        const session = sessions.get(result.id);
+        assert.ok(session);
+        // customCommand should be set since we passed command
+        assert.equal(session.customCommand, '/bin/echo');
+    });
+    it('dataQuality is derived from actual hooksActive state (hooks when injection succeeds)', () => {
+        const result = sessions.create({
+            repoName: 'test-repo',
+            repoPath: '/tmp',
+            worktreePath: null,
+            cwd: '/tmp',
+            agent: 'claude',
+            command: '/bin/cat',
+            args: [],
+        });
+        createdIds.push(result.id);
+        const session = sessions.get(result.id);
+        assert.ok(session);
+        // Without a port, hook injection doesn't succeed → hooksActive stays false → dataQuality falls back to 'parser'
+        assert.equal(session.dataQuality, 'parser');
+    });
+    it('dataQuality falls back to parser when plugin injection fails', () => {
+        const result = sessions.create({
+            repoName: 'test-repo',
+            repoPath: '/tmp',
+            worktreePath: null,
+            cwd: '/tmp',
+            agent: 'opencode',
+            command: '/bin/cat',
+            args: [],
+        });
+        createdIds.push(result.id);
+        const session = sessions.get(result.id);
+        assert.ok(session);
+        // Without a port, opencode plugin injection doesn't succeed → hooksActive stays false → dataQuality is 'parser'
+        assert.equal(session.dataQuality, 'parser');
+    });
+    it('sessionArgs is populated on session matching claudeArgs', () => {
+        const result = sessions.create({
+            repoName: 'test-repo',
+            repoPath: '/tmp',
+            worktreePath: null,
+            cwd: '/tmp',
+            agent: 'claude',
+            command: '/bin/cat',
+            args: [],
+            claudeArgs: ['--model', 'opus'],
+        });
+        createdIds.push(result.id);
+        const session = sessions.get(result.id);
+        assert.ok(session);
+        assert.deepEqual(session.sessionArgs, ['--model', 'opus']);
+        // claudeArgs backward compat still set
+        assert.deepEqual(session.claudeArgs, ['--model', 'opus']);
+    });
+    it('sessionArgs defaults to empty array when claudeArgs not provided', () => {
+        const result = sessions.create({
+            repoName: 'test-repo',
+            repoPath: '/tmp',
+            worktreePath: null,
+            cwd: '/tmp',
+            agent: 'claude',
+            command: '/bin/cat',
+            args: [],
+        });
+        createdIds.push(result.id);
+        const session = sessions.get(result.id);
+        assert.ok(session);
+        assert.deepEqual(session.sessionArgs, []);
+    });
+    it('forceOutputParser sets dataQuality to parser regardless of framework', () => {
+        const result = sessions.create({
+            repoName: 'test-repo',
+            repoPath: '/tmp',
+            worktreePath: null,
+            cwd: '/tmp',
+            agent: 'claude',
+            command: '/bin/cat',
+            args: [],
+            forceOutputParser: true,
+        });
+        createdIds.push(result.id);
+        const session = sessions.get(result.id);
+        assert.ok(session);
+        assert.equal(session.dataQuality, 'parser');
+    });
+    it('parser is selected by framework.parserType (opencode uses opencode parser)', () => {
+        const result = sessions.create({
+            repoName: 'test-repo',
+            repoPath: '/tmp',
+            worktreePath: null,
+            cwd: '/tmp',
+            agent: 'opencode',
+            command: '/bin/cat',
+            args: [],
+        });
+        createdIds.push(result.id);
+        const session = sessions.get(result.id);
+        assert.ok(session);
+        // The outputParser should be an instance of the opencode parser
+        // We verify indirectly by checking the session started correctly
+        assert.ok(session.outputParser, 'outputParser should be set');
+    });
+});

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

@@ -0,0 +1,78 @@
+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',
+            isDraft: false,
+            ciStatus: null,
+        };
+        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,
+            isDraft: false,
+            ciStatus: 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,
+                    isDraft: false,
+                    ciStatus: null,
+                },
+            ],
+        };
+        assert.equal(response.prs.length, 1);
+        assert.equal(response.error, undefined);
+    });
+});