@harness-fe/mcp-server 4.0.0-next.2 → 4.0.0-next.3

package/src/remoteBridge.ts

@@ -1,404 +0,0 @@
-/**
- * RemoteBridge — IBridge implementation backed by a WS connection to an
- * already-running daemon (leader).
- *
- * Used when this process starts as a follower: another cli.js is already
- * listening on :47729, so we attach as a ws client and proxy every MCP tool
- * call through the new `mcp.call` / `mcp.return` control frames.
- */
-
-import { WebSocket } from 'ws';
-import { randomUUID } from 'node:crypto';
-import {
-    type McpCallFrame,
-    type McpReturnFrame,
-    type TabInfo,
-    type Task,
-    type TaskStatus,
-    frameSchema,
-} from '@harness-fe/protocol';
-import type { IBridge, SendCommandOptions } from './bridge.js';
-import type {
-    BuildMeta,
-    IMemoryStore,
-    IStore,
-    MemoryEntry,
-    ProjectMeta,
-    ProjectTreeNode,
-    PurgeResult,
-    RecordingChunk,
-    RecordingChunkSummary,
-    ReplayExportMeta,
-    RetentionPolicy,
-    SearchOptions,
-    SessionMeta,
-    SessionSummary,
-    StoreEvent,
-    TabMeta,
-    TailOptions,
-} from './store/index.js';
-
-const DEFAULT_CALL_TIMEOUT_MS = 30_000;
-
-interface PendingCall {
-    resolve(value: unknown): void;
-    reject(err: Error): void;
-    timer: NodeJS.Timeout;
-}
-
-export interface RemoteBridgeOptions {
-    port: number;
-    host?: string;
-    /** Per-call timeout. Must be ≥ daemon's command timeout to surface upstream errors first. */
-    callTimeoutMs?: number;
-    /** Token used to authenticate against the leader, if it requires one. */
-    token?: string;
-}
-
-export class RemoteBridge implements IBridge {
-    private ws?: WebSocket;
-    private pending = new Map<string, PendingCall>();
-    private closed = false;
-    private readonly url: string;
-    private readonly callTimeoutMs: number;
-    private readonly host: string;
-    private readonly port: number;
-
-    private readonly token: string | undefined;
-
-    constructor(opts: RemoteBridgeOptions) {
-        const host = opts.host ?? '127.0.0.1';
-        this.host = host;
-        this.port = opts.port;
-        this.token = opts.token;
-        const tokenQs = opts.token ? `?token=${encodeURIComponent(opts.token)}` : '';
-        this.url = `ws://${host}:${opts.port}${tokenQs}`;
-        this.callTimeoutMs = opts.callTimeoutMs ?? DEFAULT_CALL_TIMEOUT_MS;
-    }
-
-    async connect(): Promise<void> {
-        return new Promise((resolve, reject) => {
-            const headers: Record<string, string> = {};
-            if (this.token) headers.authorization = `Bearer ${this.token}`;
-            const ws = new WebSocket(this.url, { headers });
-            this.ws = ws;
-            const onOpen = () => {
-                ws.off('error', onErr);
-                this.attachHandlers(ws);
-                resolve();
-            };
-            const onErr = (err: Error) => {
-                ws.off('open', onOpen);
-                reject(err);
-            };
-            ws.once('open', onOpen);
-            ws.once('error', onErr);
-        });
-    }
-
-    async stop(): Promise<void> {
-        this.closed = true;
-        const ws = this.ws;
-        if (!ws) return;
-        try {
-            ws.close();
-        } catch {
-            /* swallow */
-        }
-    }
-
-    sendCommand(command: string, args: unknown, opts?: SendCommandOptions): Promise<unknown> {
-        return this.invoke('sendCommand', { command, args, opts });
-    }
-
-    listTabs(): Promise<TabInfo[]> {
-        return this.invoke('listTabs', {}) as Promise<TabInfo[]>;
-    }
-
-    listTasks(filter: { status?: TaskStatus | 'all'; limit?: number } = {}): Promise<Task[]> {
-        return this.invoke('listTasks', filter) as Promise<Task[]>;
-    }
-
-    claimTask(id: string): Promise<Task | undefined> {
-        return this.invoke('claimTask', { id }) as Promise<Task | undefined>;
-    }
-
-    resolveTask(id: string, note?: string): Promise<Task | undefined> {
-        return this.invoke('resolveTask', { id, note }) as Promise<Task | undefined>;
-    }
-
-    /**
-     * Returns a RemoteMemoryStore that proxies all memory operations to the
-     * leader via the mcp.call channel. This allows follower instances to use
-     * the same project.memory.* tools as the leader.
-     */
-    getMemoryStore(): IMemoryStore {
-        return new RemoteMemoryStore(this);
-    }
-
-    getViewerBaseUrl(): string | undefined {
-        // Followers share the same WS/HTTP port as the leader.
-        return `http://${this.host}:${this.port}`;
-    }
-
-    getAuthToken(): string | undefined {
-        // Followers connect to the leader using their own configured token
-        // (passed in via RemoteBridge constructor). Surface it so dashboard
-        // links the follower hands out are pre-authenticated.
-        return this.token;
-    }
-
-    async getTaskAttachmentData(_taskId: string, _attachmentId: string): Promise<string | null> {
-        // Follower mode: attachment reads are not proxied in v0.6; direct leader access needed.
-        return null;
-    }
-
-    /**
-     * Returns a RemoteStore that proxies all store read/query operations to
-     * the leader via the mcp.call channel. Write operations (openSession,
-     * append, etc.) are not proxied — followers are read-only.
-     */
-    getStore(): IStore {
-        return new RemoteStore(this);
-    }
-
-    /** @internal — used by RemoteMemoryStore and RemoteStore */
-    invokeRemote(method: McpCallFrame['method'], args: unknown): Promise<unknown> {
-        return this.invoke(method, args);
-    }
-
-    private invoke(method: McpCallFrame['method'], args: unknown): Promise<unknown> {
-        const ws = this.ws;
-        if (!ws || ws.readyState !== WebSocket.OPEN) {
-            return Promise.reject(new Error('remote-bridge: not connected'));
-        }
-        const id = randomUUID();
-        const frame: McpCallFrame = { type: 'mcp.call', id, method, args };
-        return new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                this.pending.delete(id);
-                reject(new Error(`remote-bridge: "${method}" timed out after ${this.callTimeoutMs}ms`));
-            }, this.callTimeoutMs);
-            this.pending.set(id, { resolve, reject, timer });
-            try {
-                ws.send(JSON.stringify(frame));
-            } catch (err) {
-                clearTimeout(timer);
-                this.pending.delete(id);
-                reject(err as Error);
-            }
-        });
-    }
-
-    private attachHandlers(ws: WebSocket): void {
-        ws.on('message', (raw) => {
-            let parsed: unknown;
-            try {
-                parsed = JSON.parse(raw.toString());
-            } catch {
-                return;
-            }
-            const frame = frameSchema.safeParse(parsed);
-            if (!frame.success) return;
-            if (frame.data.type !== 'mcp.return') return;
-            this.handleReturn(frame.data);
-        });
-        ws.on('close', () => this.handleClose());
-        ws.on('error', () => {
-            /* close will follow */
-        });
-    }
-
-    private handleReturn(frame: McpReturnFrame): void {
-        const p = this.pending.get(frame.id);
-        if (!p) return;
-        clearTimeout(p.timer);
-        this.pending.delete(frame.id);
-        if (frame.ok) {
-            p.resolve(frame.result);
-        } else {
-            p.reject(new Error(frame.error?.message ?? 'remote-bridge: unknown error'));
-        }
-    }
-
-    private handleClose(): void {
-        const err = new Error(
-            this.closed
-                ? 'remote-bridge: connection closed'
-                : 'remote-bridge: lost connection to daemon',
-        );
-        for (const p of this.pending.values()) {
-            clearTimeout(p.timer);
-            p.reject(err);
-        }
-        this.pending.clear();
-    }
-}
-
-// ─── RemoteMemoryStore ────────────────────────────────────────────────────────
-//
-// Proxies IMemoryStore operations to the leader via mcp.call frames.
-// Used by follower instances so project.memory.* tools work in all windows.
-
-class RemoteMemoryStore implements IMemoryStore {
-    constructor(private readonly bridge: RemoteBridge) {}
-
-    get(projectId: string, key: string): MemoryEntry | undefined {
-        // Synchronous interface — not directly awaitable. The MCP tool layer
-        // wraps calls in async handlers, so we return a thenable-compatible
-        // object. In practice mcp.ts awaits the result via the async handler.
-        // We throw here to signal that callers must use the async path.
-        throw new Error(
-            'RemoteMemoryStore.get() must be called via the async MCP tool handler. ' +
-            'Use remoteMemoryStore.getAsync() instead.',
-        );
-    }
-
-    /** Async variant used by the MCP tool handlers in mcp.ts. */
-    async getAsync(projectId: string, key: string): Promise<MemoryEntry | undefined> {
-        return this.bridge.invokeRemote('memoryGet', { projectId, key }) as Promise<MemoryEntry | undefined>;
-    }
-
-    set(projectId: string, key: string, value: string): MemoryEntry {
-        throw new Error('RemoteMemoryStore.set() must be called via setAsync().');
-    }
-
-    async setAsync(projectId: string, key: string, value: string): Promise<MemoryEntry> {
-        return this.bridge.invokeRemote('memorySet', { projectId, key, value }) as Promise<MemoryEntry>;
-    }
-
-    delete(projectId: string, key: string): boolean {
-        throw new Error('RemoteMemoryStore.delete() must be called via deleteAsync().');
-    }
-
-    async deleteAsync(projectId: string, key: string): Promise<boolean> {
-        return this.bridge.invokeRemote('memoryDelete', { projectId, key }) as Promise<boolean>;
-    }
-
-    list(projectId: string): MemoryEntry[] {
-        throw new Error('RemoteMemoryStore.list() must be called via listAsync().');
-    }
-
-    async listAsync(projectId: string): Promise<MemoryEntry[]> {
-        return this.bridge.invokeRemote('memoryList', { projectId }) as Promise<MemoryEntry[]>;
-    }
-}
-
-// ─── RemoteStore ──────────────────────────────────────────────────────────────
-//
-// Proxies IStore read operations to the leader via mcp.call frames.
-// Write operations throw — followers are read-only for the store.
-
-class RemoteStore implements IStore {
-    constructor(private readonly bridge: RemoteBridge) {}
-
-    // ── Read operations (proxied) ──────────────────────────────────────────
-
-    async listProjectsAsync(): Promise<ProjectMeta[]> {
-        return this.bridge.invokeRemote('storeListProjects', {}) as Promise<ProjectMeta[]>;
-    }
-
-    async listSessionsAsync(opts?: { projectId?: string; tabId?: string; buildId?: string; limit?: number }): Promise<SessionMeta[]> {
-        return this.bridge.invokeRemote('storeListSessions', opts ?? {}) as Promise<SessionMeta[]>;
-    }
-
-    async summaryAsync(sessionId: string): Promise<SessionSummary> {
-        return this.bridge.invokeRemote('storeSummary', { sessionId }) as Promise<SessionSummary>;
-    }
-
-    async tailAsync(sessionId: string, opts?: TailOptions): Promise<StoreEvent[]> {
-        return this.bridge.invokeRemote('storeTail', { sessionId, opts }) as Promise<StoreEvent[]>;
-    }
-
-    async searchAsync(sessionId: string, query: string, opts?: SearchOptions): Promise<StoreEvent[]> {
-        return this.bridge.invokeRemote('storeSearch', { sessionId, query, opts }) as Promise<StoreEvent[]>;
-    }
-
-    async listRecordingsAsync(sessionId: string): Promise<RecordingChunkSummary[]> {
-        return this.bridge.invokeRemote('storeRecordingsList', { sessionId }) as Promise<RecordingChunkSummary[]>;
-    }
-
-    async sliceRecordingsAsync(sessionId: string, since: number, until: number): Promise<RecordingChunk[]> {
-        return this.bridge.invokeRemote(
-            'storeRecordingsSlice',
-            { sessionId, since, until },
-        ) as Promise<RecordingChunk[]>;
-    }
-
-    async replayCreateAsync(args: {
-        sessionId: string;
-        tabId?: string;
-        ts?: number;
-        windowMs?: number;
-        since?: number;
-        until?: number;
-        label?: string;
-    }): Promise<unknown> {
-        return this.bridge.invokeRemote('storeReplayCreate', args);
-    }
-
-    async purgeAsync(policy?: RetentionPolicy): Promise<PurgeResult> {
-        return this.bridge.invokeRemote('storePurge', policy ?? {}) as Promise<PurgeResult>;
-    }
-
-    // ── Synchronous IStore interface stubs (not used by follower) ─────────
-    // These satisfy the interface but throw — the MCP tool handlers in mcp.ts
-    // use the async variants above when running in follower mode.
-
-    // Build lifecycle
-    openBuild(_p: string, _patch?: Partial<Omit<BuildMeta, 'id' | 'projectId' | 'builtAt'>>): string { throw notSupported('openBuild'); }
-    closeBuild(_b: string, _c?: number): void { throw notSupported('closeBuild'); }
-
-    // Tab lifecycle
-    upsertTab(_t: string, _patch: Partial<Omit<TabMeta, 'id'>>): TabMeta { throw notSupported('upsertTab'); }
-    getTab(_t: string): TabMeta | undefined { throw notSupported('getTab'); }
-    closeTab(_t: string, _d?: number): void { throw notSupported('closeTab'); }
-
-    // Session lifecycle
-    upsertSession(_s: string, _m: Partial<Omit<SessionMeta, 'id'>> & { tabId: string; startedAt: number }): SessionMeta { throw notSupported('upsertSession'); }
-    closeSession(_s: string, _e?: number): void { throw notSupported('closeSession'); }
-    getSession(_id: string): SessionMeta | undefined { throw notSupported('getSession'); }
-    listSessions(_opts?: { tabId?: string; projectId?: string; buildId?: string; limit?: number }): SessionMeta[] { throw notSupported('listSessions'); }
-
-    // Write
-    appendEvent(_s: string, _e: StoreEvent): void { throw notSupported('appendEvent'); }
-    appendEventBatch(_s: string, _e: StoreEvent[]): void { throw notSupported('appendEventBatch'); }
-    appendRecording(_s: string, _c: unknown): void { throw notSupported('appendRecording'); }
-    writeNote(_p: string, _k: string, _v: string): void { throw notSupported('writeNote'); }
-
-    // Project metadata
-    listProjects(): ProjectMeta[] { throw notSupported('listProjects'); }
-    upsertProject(_p: string, _patch: Partial<Omit<ProjectMeta, 'id' | 'createdAt'>>): ProjectMeta { throw notSupported('upsertProject'); }
-    getProject(_p: string): ProjectMeta | undefined { throw notSupported('getProject'); }
-    getProjectTree(_r?: string): ProjectTreeNode[] { throw notSupported('getProjectTree'); }
-
-    // Build metadata
-    upsertBuild(_p: string, _b: string, _patch: Partial<Omit<BuildMeta, 'id' | 'projectId'>>): BuildMeta { throw notSupported('upsertBuild'); }
-    getBuild(_p: string, _b: string): BuildMeta | undefined { throw notSupported('getBuild'); }
-    listBuilds(_p: string, _l?: number): BuildMeta[] { throw notSupported('listBuilds'); }
-
-    // Visitor metadata (0.5+) — followers don't proxy yet; leader-only for now.
-    upsertVisitor(_v: string, _patch: Parameters<IStore['upsertVisitor']>[1]): ReturnType<IStore['upsertVisitor']> { throw notSupported('upsertVisitor'); }
-    getVisitor(_v: string): ReturnType<IStore['getVisitor']> { throw notSupported('getVisitor'); }
-    listVisitors(_opts?: Parameters<IStore['listVisitors']>[0]): ReturnType<IStore['listVisitors']> { throw notSupported('listVisitors'); }
-
-    // Read
-    tail(_s: string, _o?: TailOptions): StoreEvent[] { throw notSupported('tail'); }
-    search(_s: string, _q: string, _o?: SearchOptions): StoreEvent[] { throw notSupported('search'); }
-    listRecordings(_s: string): RecordingChunkSummary[] { throw notSupported('listRecordings'); }
-    sliceRecordings(_s: string, _since: number, _until: number): RecordingChunk[] { throw notSupported('sliceRecordings'); }
-    writeExport(_i: Parameters<IStore['writeExport']>[0]): ReplayExportMeta { throw notSupported('writeExport'); }
-    getExport(_id: string): ReplayExportMeta | undefined { throw notSupported('getExport'); }
-    readExportEvents(_id: string): unknown[] | undefined { throw notSupported('readExportEvents'); }
-    listExports(_p: string, _l?: number): ReplayExportMeta[] { throw notSupported('listExports'); }
-    summary(_s: string): SessionSummary { throw notSupported('summary'); }
-    listNotes(_p: string): Array<{ key: string; value: string; ts: number }> { throw notSupported('listNotes'); }
-
-    // Maintenance
-    purge(_p?: RetentionPolicy): PurgeResult { throw notSupported('purge'); }
-    close(): void { /* no-op for remote */ }
-}
-
-function notSupported(method: string): Error {
-    return new Error(`remote-bridge: IStore.${method}() is not available in follower mode`);
-}

package/src/replay.test.ts

@@ -1,271 +0,0 @@
-import { afterEach, describe, expect, it } from 'vitest';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { randomUUID } from 'node:crypto';
-import { Bridge } from './bridge.js';
-import { JsonlStore } from './store/index.js';
-import { createReplayExport } from './replayCreate.js';
-
-const tempDirs: string[] = [];
-function mkTmp(): string {
-    const dir = mkdtempSync(join(tmpdir(), 'harness-replay-test-'));
-    tempDirs.push(dir);
-    return dir;
-}
-
-afterEach(async () => {
-    while (tempDirs.length) {
-        const d = tempDirs.pop()!;
-        try { rmSync(d, { recursive: true, force: true }); } catch { /* ignore */ }
-    }
-});
-
-/**
- * v0.4.0 helper: open a session (one-tab pageload).
- */
-function openSession(store: JsonlStore, projectId: string, tabId: string = `tab-${randomUUID().slice(0, 8)}`): string {
-    const sessionId = randomUUID();
-    store.upsertTab(tabId, { connectedAt: Date.now() });
-    store.upsertSession(sessionId, {
-        tabId,
-        startedAt: Date.now(),
-        participants: [{ projectId, joinedAt: Date.now() }],
-    });
-    return sessionId;
-}
-
-function seedRecording(store: JsonlStore, sessId: string, _tabId: string, opts: {
-    chunkId: string;
-    startTs: number;
-    endTs: number;
-    events: unknown[];
-}) {
-    // v0.4.0: appendRecording takes (sessionId, chunk) — no tabId arg
-    store.appendRecording(sessId, {
-        chunkId: opts.chunkId,
-        startTs: opts.startTs,
-        endTs: opts.endTs,
-        eventCount: opts.events.length,
-        events: opts.events,
-    });
-}
-
-describe('createReplayExport — pure logic', () => {
-    it('rejects when neither ts nor since/until are provided', () => {
-        const dir = mkTmp();
-        const store = new JsonlStore(dir);
-        const sessId = openSession(store, 'proj');
-        const result = createReplayExport(store, undefined, { sessionId: sessId });
-        expect(result.error).toMatch(/must provide either ts/);
-    });
-
-    it('rejects when until <= since', () => {
-        const dir = mkTmp();
-        const store = new JsonlStore(dir);
-        const sessId = openSession(store, 'proj');
-        const result = createReplayExport(store, undefined, { sessionId: sessId, since: 100, until: 100 });
-        expect(result.error).toMatch(/until must be greater/);
-    });
-
-    it('rejects when session unknown', () => {
-        const dir = mkTmp();
-        const store = new JsonlStore(dir);
-        const result = createReplayExport(store, undefined, { sessionId: 'nope', ts: 1000 });
-        expect(result.error).toMatch(/session not found/);
-    });
-
-    it('rejects when no chunks in window', async () => {
-        const dir = mkTmp();
-        const store = new JsonlStore(dir);
-        const sessId = openSession(store, 'proj', 'tab-1');
-        seedRecording(store, sessId, 'tab-1', { chunkId: 'rrc_1', startTs: 1000, endTs: 1500, events: [{}, {}] });
-        await store.flush();
-        const result = createReplayExport(store, undefined, { sessionId: sessId, since: 5000, until: 6000 });
-        expect(result.error).toMatch(/no rrweb chunks/);
-    });
-
-    it('rejects when fewer than 2 events in window', async () => {
-        const dir = mkTmp();
-        const store = new JsonlStore(dir);
-        const sessId = openSession(store, 'proj', 'tab-1');
-        seedRecording(store, sessId, 'tab-1', { chunkId: 'rrc_1', startTs: 1000, endTs: 1500, events: [{ type: 2 }] });
-        await store.flush();
-        const result = createReplayExport(store, undefined, { sessionId: sessId, since: 0, until: 5000 });
-        expect(result.error).toMatch(/fewer than 2 rrweb events/);
-    });
-
-    it('builds an export from chunks in window and persists to disk', async () => {
-        const dir = mkTmp();
-        const store = new JsonlStore(dir);
-        const sessId = openSession(store, 'proj', 'tab-1');
-        seedRecording(store, sessId, 'tab-1', { chunkId: 'a', startTs: 1000, endTs: 1500, events: [{ type: 4 }, { type: 2 }] });
-        seedRecording(store, sessId, 'tab-1', { chunkId: 'b', startTs: 1600, endTs: 2000, events: [{ type: 3 }, { type: 3 }, { type: 3 }] });
-        // outside window — should NOT be in export
-        seedRecording(store, sessId, 'tab-1', { chunkId: 'c', startTs: 9000, endTs: 9500, events: [{ type: 3 }, { type: 3 }] });
-        await store.flush();
-
-        const result = createReplayExport(store, 'http://127.0.0.1:47729', {
-            sessionId: sessId, since: 900, until: 2100, label: 'bug-checkout',
-        });
-        expect(result.error).toBeUndefined();
-        expect(result.exportId).toMatch(/^exp_/);
-        expect(result.viewerUrl).toBe(`http://127.0.0.1:47729/replay/${result.exportId}`);
-        expect(result.eventCount).toBe(5);
-        expect(result.chunkCount).toBe(2);
-        expect(result.durationMs).toBe(1000);
-        expect(result.label).toBe('bug-checkout');
-
-        // Round-trip through the store
-        const events = store.readExportEvents(result.exportId!);
-        expect(events).toHaveLength(5);
-    });
-
-    it('picks the tab with the most events when caller does not pin tabId', async () => {
-        const dir = mkTmp();
-        const store = new JsonlStore(dir);
-        // Two separate sessions, each representing a different tab in the same "logical" session
-        // v0.4.0: each session has exactly one tab; we test multi-session scenario differently.
-        // Instead, we have two recording chunks on the same session with different tabIds in chunk metadata.
-        // Actually in v0.4.0 a session owns one tab, and recording chunks carry the session's tabId.
-        // "Multi-tab" means multiple sessions. The tabId auto-select picks from chunk.tabId values.
-        const sessId = openSession(store, 'proj', 'tab-1');
-        // Seed recordings that have different tabIds via the chunkId; in v0.4.0 tabId comes from sessionMeta.tabId
-        // so all chunks for this session have tabId='tab-1'. Let's just verify the auto-select works per chunk count.
-        seedRecording(store, sessId, 'tab-1', { chunkId: 'a', startTs: 1000, endTs: 1500, events: [{ type: 4 }, { type: 2 }, { type: 3 }] });
-        await store.flush();
-
-        const result = createReplayExport(store, undefined, { sessionId: sessId, since: 500, until: 2500 });
-        expect(result.error).toBeUndefined();
-        expect(result.tabId).toBe('tab-1');
-        expect(result.eventCount).toBe(3);
-    });
-
-    it('respects ts + windowMs as a center window', async () => {
-        const dir = mkTmp();
-        const store = new JsonlStore(dir);
-        const sessId = openSession(store, 'proj', 'tab-1');
-        seedRecording(store, sessId, 'tab-1', { chunkId: 'a', startTs: 1000, endTs: 1500, events: [{ type: 4 }, { type: 2 }] });
-        seedRecording(store, sessId, 'tab-1', { chunkId: 'b', startTs: 9000, endTs: 9500, events: [{ type: 4 }, { type: 2 }] });
-        await store.flush();
-
-        const r1 = createReplayExport(store, undefined, { sessionId: sessId, ts: 1200, windowMs: 500 });
-        expect(r1.chunkCount).toBe(1);
-
-        const r2 = createReplayExport(store, undefined, { sessionId: sessId, ts: 5000, windowMs: 5000 });
-        expect(r2.chunkCount).toBe(2);
-    });
-});
-
-describe('replay HTTP routes', () => {
-    async function startBridge() {
-        const dir = mkTmp();
-        const store = new JsonlStore(dir);
-        const bridge = new Bridge({ port: 0, host: '127.0.0.1', store, taskStore: null, memoryStore: null });
-        await bridge.start();
-        const port = bridge.getBoundPort();
-        if (!port) throw new Error('no port');
-        return { bridge, store, port, dir };
-    }
-
-    it('serves HTML viewer for an existing export', async () => {
-        const { bridge, store, port } = await startBridge();
-        try {
-            const sessId = openSession(store, 'proj', 'tab-1');
-            seedRecording(store, sessId, 'tab-1', { chunkId: 'a', startTs: 1000, endTs: 1500, events: [{ type: 4 }, { type: 2 }, { type: 3 }] });
-            await store.flush();
-            const r = createReplayExport(store, `http://127.0.0.1:${port}`, { sessionId: sessId, since: 0, until: 5000 });
-            expect(r.exportId).toBeTruthy();
-
-            const resp = await fetch(`http://127.0.0.1:${port}/replay/${r.exportId}`);
-            expect(resp.status).toBe(200);
-            const html = await resp.text();
-            expect(html).toContain('new rrwebPlayer');
-            expect(html).toContain(r.exportId!);
-        } finally {
-            await bridge.stop();
-        }
-    });
-
-    it('serves events JSON via /replay/:id.json', async () => {
-        const { bridge, store, port } = await startBridge();
-        try {
-            const sessId = openSession(store, 'proj', 'tab-1');
-            seedRecording(store, sessId, 'tab-1', { chunkId: 'a', startTs: 1000, endTs: 1500, events: [{ type: 4 }, { type: 2 }, { type: 3 }] });
-            await store.flush();
-            const r = createReplayExport(store, undefined, { sessionId: sessId, since: 0, until: 5000 });
-
-            const resp = await fetch(`http://127.0.0.1:${port}/replay/${r.exportId}.json`);
-            expect(resp.status).toBe(200);
-            expect(resp.headers.get('content-type')).toMatch(/application\/json/);
-            const body = await resp.json();
-            expect(Array.isArray(body)).toBe(true);
-            expect(body).toHaveLength(3);
-        } finally {
-            await bridge.stop();
-        }
-    });
-
-    it('serves the bundled rrweb-player JS and CSS', async () => {
-        const { bridge, port } = await startBridge();
-        try {
-            const js = await fetch(`http://127.0.0.1:${port}/replay/static/player.js`);
-            expect(js.status).toBe(200);
-            expect(js.headers.get('content-type')).toMatch(/javascript/);
-            const jsBody = await js.text();
-            expect(jsBody.length).toBeGreaterThan(1000);
-            expect(jsBody).toContain('rrwebPlayer');
-
-            const css = await fetch(`http://127.0.0.1:${port}/replay/static/player.css`);
-            expect(css.status).toBe(200);
-            expect(css.headers.get('content-type')).toMatch(/css/);
-        } finally {
-            await bridge.stop();
-        }
-    });
-
-    it('returns 404 for unknown export', async () => {
-        const { bridge, port } = await startBridge();
-        try {
-            const resp = await fetch(`http://127.0.0.1:${port}/replay/exp_nope`);
-            expect(resp.status).toBe(404);
-        } finally {
-            await bridge.stop();
-        }
-    });
-
-    it('rejects malformed export ids', async () => {
-        const { bridge, port } = await startBridge();
-        try {
-            const resp = await fetch(`http://127.0.0.1:${port}/replay/has%20space`);
-            expect(resp.status).toBe(400);
-        } finally {
-            await bridge.stop();
-        }
-    });
-});
-
-describe('export retention interacts cleanly with replay creation', () => {
-    it('export created after a purge still resolves chunks still on disk', async () => {
-        const dir = mkTmp();
-        const store = new JsonlStore(dir);
-        const sessId = openSession(store, 'proj', 'tab-1');
-        const now = Date.now();
-        seedRecording(store, sessId, 'tab-1', { chunkId: 'a', startTs: now - 3000, endTs: now - 2800, events: [{ type: 4 }, { type: 2 }, { type: 3 }] });
-        // Each surviving chunk carries its own baseline so the post-purge
-        // export still has a FullSnapshot to replay from.
-        seedRecording(store, sessId, 'tab-1', { chunkId: 'b', startTs: now - 2000, endTs: now - 1800, events: [{ type: 2 }, { type: 3 }] });
-        seedRecording(store, sessId, 'tab-1', { chunkId: 'c', startTs: now - 1000, endTs: now - 800, events: [{ type: 3 }, { type: 3 }] });
-        await store.flush();
-
-        // Trim to 2 chunks per session (new key name).
-        const purge = store.purge({ maxRecordingChunksPerSession: 2, preserveMarkedChunks: false });
-        expect(purge.recordingsDeleted).toBeGreaterThanOrEqual(1);
-
-        // Export over the full window — should only include surviving chunks.
-        const r = createReplayExport(store, undefined, { sessionId: sessId, since: now - 10000, until: now + 10000 });
-        expect(r.error).toBeUndefined();
-        expect(r.chunkCount).toBe(2);
-        expect(r.eventCount).toBe(4);
-    });
-});