relay-ide 0.1.0

package/dist/test/server/ws.js

@@ -0,0 +1,152 @@
+import { WebSocketServer } from 'ws';
+import * as sessions from './sessions.js';
+import { trackEvent } from './analytics.js';
+function replyPing(ws) {
+    if (ws.readyState === ws.OPEN)
+        ws.send('{"type":"pong"}');
+}
+function parseCookies(cookieHeader) {
+    const cookies = {};
+    if (!cookieHeader)
+        return cookies;
+    cookieHeader.split(';').forEach((part) => {
+        const idx = part.indexOf('=');
+        if (idx < 0)
+            return;
+        const key = part.slice(0, idx).trim();
+        const val = part.slice(idx + 1).trim();
+        cookies[key] = decodeURIComponent(val);
+    });
+    return cookies;
+}
+function setupWebSocket(server, authenticatedTokens, watcher, _configPath) {
+    const wss = new WebSocketServer({ noServer: true });
+    const eventClients = new Set();
+    function broadcastEvent(type, data) {
+        const msg = JSON.stringify({ type, ...data });
+        for (const client of eventClients) {
+            if (client.readyState === client.OPEN) {
+                client.send(msg);
+            }
+        }
+    }
+    if (watcher) {
+        watcher.on('worktrees-changed', function () {
+            broadcastEvent('worktrees-changed');
+        });
+    }
+    server.on('upgrade', (request, socket, head) => {
+        const cookies = parseCookies(request.headers.cookie);
+        if (!authenticatedTokens.has(cookies['token'] ?? '')) {
+            socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
+            socket.destroy();
+            return;
+        }
+        // Event channel: /ws/events
+        if (request.url === '/ws/events') {
+            wss.handleUpgrade(request, socket, head, (ws) => {
+                const cleanup = () => { eventClients.delete(ws); };
+                eventClients.add(ws);
+                ws.on('message', (msg) => {
+                    try {
+                        const parsed = JSON.parse(msg.toString());
+                        if (parsed.type === 'ping')
+                            replyPing(ws);
+                    }
+                    catch { /* ignore */ }
+                });
+                ws.on('close', cleanup);
+                ws.on('error', cleanup);
+            });
+            return;
+        }
+        // PTY channel: /ws/:sessionId
+        const match = request.url && request.url.match(/^\/ws\/([a-f0-9]+)$/);
+        if (!match) {
+            socket.write('HTTP/1.1 404 Not Found\r\n\r\n');
+            socket.destroy();
+            return;
+        }
+        const sessionId = match[1];
+        const session = sessions.get(sessionId);
+        if (!session) {
+            socket.write('HTTP/1.1 404 Not Found\r\n\r\n');
+            socket.destroy();
+            return;
+        }
+        wss.handleUpgrade(request, socket, head, (ws) => {
+            sessionMap.set(ws, session);
+            wss.emit('connection', ws, request);
+        });
+    });
+    const sessionMap = new WeakMap();
+    wss.on('connection', (ws, _request) => {
+        const session = sessionMap.get(ws);
+        if (!session)
+            return;
+        let dataDisposable = null;
+        let exitDisposable = null;
+        const attachToPty = (ptyProcess) => {
+            // Dispose previous handlers
+            dataDisposable?.dispose();
+            exitDisposable?.dispose();
+            // Replay scrollback
+            for (const chunk of session.scrollback) {
+                if (ws.readyState === ws.OPEN)
+                    ws.send(chunk);
+            }
+            dataDisposable = ptyProcess.onData((data) => {
+                if (ws.readyState === ws.OPEN)
+                    ws.send(data);
+            });
+            exitDisposable = ptyProcess.onExit(() => {
+                if (ws.readyState === ws.OPEN)
+                    ws.close(1000);
+            });
+        };
+        attachToPty(session.pty);
+        const ptyReplacedHandler = (newPty) => attachToPty(newPty);
+        session.onPtyReplacedCallbacks.push(ptyReplacedHandler);
+        ws.on('message', (msg) => {
+            const str = msg.toString();
+            try {
+                const parsed = JSON.parse(str);
+                if (parsed.type === 'ping') {
+                    replyPing(ws);
+                    return;
+                }
+                if (parsed.type === 'resize' && parsed.cols && parsed.rows) {
+                    sessions.resize(session.id, parsed.cols, parsed.rows);
+                    return;
+                }
+            }
+            catch (_) { }
+            // Use session.pty dynamically so writes go to current PTY
+            session.pty.write(str);
+        });
+        ws.on('close', () => {
+            dataDisposable?.dispose();
+            exitDisposable?.dispose();
+            const idx = session.onPtyReplacedCallbacks.indexOf(ptyReplacedHandler);
+            if (idx !== -1)
+                session.onPtyReplacedCallbacks.splice(idx, 1);
+        });
+    });
+    sessions.onIdleChange((sessionId, idle) => {
+        broadcastEvent('session-idle-changed', { sessionId, idle });
+        if (idle) {
+            trackEvent({ category: 'agent', action: 'idle', target: sessionId, session_id: sessionId });
+        }
+    });
+    sessions.onStateChange((sessionId, state) => {
+        broadcastEvent('session-state-changed', { sessionId, state });
+        if (state === 'waiting-for-input') {
+            trackEvent({ category: 'agent', action: 'waiting-for-input', target: sessionId, session_id: sessionId });
+        }
+    });
+    sessions.onSessionEnd((sessionId, repoPath, branchName) => {
+        broadcastEvent('session-ended', { sessionId, repoPath, branchName });
+    });
+    return { wss, broadcastEvent };
+}
+export { setupWebSocket };

package/dist/test/server-startup.test.js

@@ -0,0 +1,62 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+test('server starts without PIN in non-TTY mode and serves /auth/status', async () => {
+    // Create a temporary config with no pinHash
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-remote-test-'));
+    const configPath = path.join(tmpDir, 'config.json');
+    fs.writeFileSync(configPath, JSON.stringify({ port: 0, host: '127.0.0.1' }));
+    const serverScript = path.resolve(import.meta.dirname, '..', 'server', 'index.js');
+    // Spawn server as a non-TTY child process (pipe = no TTY)
+    const child = spawn(process.execPath, [serverScript], {
+        env: {
+            ...process.env,
+            CLAUDE_REMOTE_CONFIG: configPath,
+            CLAUDE_REMOTE_PORT: '0',
+            NO_PIN: '1',
+        },
+        stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    try {
+        // Wait for the server to print the listening port
+        const port = await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject(new Error('Server did not start within 10s'));
+            }, 10_000);
+            let stderr = '';
+            child.stdout.on('data', (chunk) => {
+                const text = chunk.toString();
+                const match = text.match(/listening on [\w.]+:(\d+)/);
+                if (match) {
+                    clearTimeout(timeout);
+                    resolve(Number(match[1]));
+                }
+            });
+            child.stderr.on('data', (chunk) => {
+                stderr += chunk.toString();
+            });
+            child.on('exit', (code) => {
+                clearTimeout(timeout);
+                reject(new Error(`Server exited with code ${code}. stderr: ${stderr}`));
+            });
+        });
+        // Hit GET /auth/status — should work without auth
+        const res = await fetch(`http://127.0.0.1:${port}/auth/status`);
+        assert.equal(res.status, 200);
+        const body = (await res.json());
+        assert.equal(body.hasPIN, false, 'Server should report no PIN configured');
+    }
+    finally {
+        child.kill('SIGTERM');
+        // Wait for the child to fully exit before cleaning up temp files.
+        // Without this, SQLite WAL/SHM files may still be open, causing ENOTEMPTY.
+        await new Promise((resolve) => {
+            child.on('exit', () => resolve());
+            setTimeout(resolve, 3000);
+        });
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+});

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

package/dist/test/session-analytics-api.test.js

@@ -0,0 +1,123 @@
+import { test, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import express from 'express';
+import http from 'node:http';
+import { initAnalytics, closeAnalytics, createSessionAnalyticsRouter, recordSessionEvent, flushEventBuffer, upsertSessionRollup, recordRateLimitSnapshot, } from '../server/analytics.js';
+let tmpDir;
+let server;
+let port;
+before(async () => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'session-analytics-api-test-'));
+    initAnalytics(tmpDir);
+    // Seed test data
+    upsertSessionRollup({
+        sessionId: 'sess-1',
+        repoPath: '/repo/a',
+        repoName: 'repo-a',
+        agentType: 'claude',
+        model: 'opus-4',
+        startedAt: new Date().toISOString(),
+        totalInputTokens: 5000,
+        totalOutputTokens: 1200,
+        durationSeconds: 600,
+        rateLimitEncounters: 1,
+        toolUseCounts: { Read: 10, Edit: 3 },
+    });
+    recordSessionEvent({
+        session_id: 'sess-1',
+        repo_path: '/repo/a',
+        event_type: 'session_start',
+        timestamp: new Date().toISOString(),
+    });
+    recordSessionEvent({
+        session_id: 'sess-1',
+        repo_path: '/repo/a',
+        event_type: 'tool_use',
+        event_data: { tool: 'Read' },
+        timestamp: new Date().toISOString(),
+    });
+    recordSessionEvent({
+        session_id: 'sess-1',
+        repo_path: '/repo/a',
+        event_type: 'tool_use',
+        event_data: { tool: 'Edit' },
+        timestamp: new Date().toISOString(),
+    });
+    flushEventBuffer();
+    recordRateLimitSnapshot({
+        fiveHourPercent: 62,
+        fiveHourResetsAt: '2026-04-01T14:32:00Z',
+        sevenDayPercent: 91,
+        sevenDayResetsAt: '2026-04-03T00:00:00Z',
+        timestamp: new Date().toISOString(),
+    });
+    const app = express();
+    app.use(express.json());
+    app.use('/api/analytics', createSessionAnalyticsRouter());
+    server = http.createServer(app);
+    await new Promise((resolve) => server.listen(0, resolve));
+    port = server.address().port;
+});
+after(() => {
+    server.close();
+    closeAnalytics();
+    fs.rmSync(tmpDir, { recursive: true });
+});
+function url(p) {
+    return `http://localhost:${port}/api/analytics${p}`;
+}
+test('GET /api/analytics/overview returns summary', async () => {
+    const res = await fetch(url('/overview'));
+    assert.equal(res.status, 200);
+    const data = (await res.json());
+    assert.equal(typeof data.totalSessions, 'number');
+    assert.ok(data.totalSessions >= 1);
+    assert.equal(typeof data.totalTokensIn, 'number');
+    assert.ok(Array.isArray(data.byRepo));
+});
+test('GET /api/analytics/sessions returns paginated list', async () => {
+    const res = await fetch(url('/sessions?limit=10'));
+    assert.equal(res.status, 200);
+    const data = (await res.json());
+    assert.ok(Array.isArray(data.sessions));
+    assert.equal(typeof data.total, 'number');
+    assert.equal(typeof data.offset, 'number');
+    assert.equal(typeof data.limit, 'number');
+});
+test('GET /api/analytics/sessions/:id returns session detail', async () => {
+    const res = await fetch(url('/sessions/sess-1'));
+    assert.equal(res.status, 200);
+    const data = (await res.json());
+    assert.ok(data.session);
+    assert.ok(data.toolBreakdown);
+    assert.ok(Array.isArray(data.events));
+    assert.ok(data.engagementBreakdown);
+});
+test('GET /api/analytics/sessions/:id returns 404 for unknown', async () => {
+    const res = await fetch(url('/sessions/nonexistent'));
+    assert.equal(res.status, 404);
+});
+test('GET /api/analytics/trends returns daily data', async () => {
+    const res = await fetch(url('/trends?days=7'));
+    assert.equal(res.status, 200);
+    const data = (await res.json());
+    assert.ok(Array.isArray(data.days));
+});
+test('GET /api/analytics/tools returns tool breakdown', async () => {
+    const res = await fetch(url('/tools?days=7'));
+    assert.equal(res.status, 200);
+    const data = (await res.json());
+    assert.ok(Array.isArray(data.tools));
+    // We seeded 2 tool_use events (Read + Edit)
+    assert.ok(data.tools.length >= 1);
+});
+test('GET /api/analytics/rate-limits returns snapshots', async () => {
+    const res = await fetch(url('/rate-limits?hours=24'));
+    assert.equal(res.status, 200);
+    const data = (await res.json());
+    assert.ok(Array.isArray(data.snapshots));
+    assert.ok(data.snapshots.length >= 1);
+});