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

package/src/store/MemoryEventStore.test.ts

@@ -1,119 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import type { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
-import { MemoryEventStore } from './MemoryEventStore.js';
-
-function msg(id: number): JSONRPCMessage {
-    return { jsonrpc: '2.0', id, result: { ok: id } } as JSONRPCMessage;
-}
-
-describe('MemoryEventStore', () => {
-    it('assigns monotonically ordered event ids per stream', async () => {
-        const s = new MemoryEventStore();
-        const a1 = await s.storeEvent('A', msg(1));
-        const a2 = await s.storeEvent('A', msg(2));
-        const b1 = await s.storeEvent('B', msg(1));
-        const a3 = await s.storeEvent('A', msg(3));
-
-        expect(a1 < a2).toBe(true);
-        expect(a2 < a3).toBe(true);
-        expect(b1.startsWith('B::')).toBe(true);
-        expect(a1.startsWith('A::')).toBe(true);
-    });
-
-    it('replays only events strictly after lastEventId, in order', async () => {
-        const s = new MemoryEventStore();
-        const ids: string[] = [];
-        for (let i = 1; i <= 5; i++) ids.push(await s.storeEvent('A', msg(i)));
-
-        const sent: Array<{ eventId: string; message: JSONRPCMessage }> = [];
-        const sid = await s.replayEventsAfter(ids[1]!, {
-            send: async (eventId, message) => {
-                sent.push({ eventId, message });
-            },
-        });
-
-        expect(sid).toBe('A');
-        expect(sent.map((s) => s.eventId)).toEqual([ids[2], ids[3], ids[4]]);
-    });
-
-    it('getStreamIdForEventId recovers stream from event id', async () => {
-        const s = new MemoryEventStore();
-        const id = await s.storeEvent('stream-xyz', msg(1));
-        expect(await s.getStreamIdForEventId(id)).toBe('stream-xyz');
-        expect(await s.getStreamIdForEventId('no-separator')).toBeUndefined();
-    });
-
-    it('replay across unknown stream returns empty without throwing', async () => {
-        const s = new MemoryEventStore();
-        const sent: string[] = [];
-        const sid = await s.replayEventsAfter('ghost::000000000001', {
-            send: async (eventId) => {
-                sent.push(eventId);
-            },
-        });
-        expect(sid).toBe('ghost');
-        expect(sent).toEqual([]);
-    });
-
-    it('evicts oldest per-stream events when maxEventsPerStream is exceeded', async () => {
-        const s = new MemoryEventStore({ maxEventsPerStream: 3 });
-        const ids: string[] = [];
-        for (let i = 1; i <= 5; i++) ids.push(await s.storeEvent('A', msg(i)));
-
-        // After eviction only the last 3 remain. Replaying after the
-        // evicted first id returns just whatever is still buffered.
-        const sent: string[] = [];
-        await s.replayEventsAfter(ids[0]!, {
-            send: async (eventId) => {
-                sent.push(eventId);
-            },
-        });
-        expect(sent).toEqual([ids[2], ids[3], ids[4]]);
-        expect(s.size()).toBe(3);
-    });
-
-    it('evicts events older than maxAgeMs', async () => {
-        let now = 1_000_000;
-        const s = new MemoryEventStore({ maxAgeMs: 1000, now: () => now });
-        const id1 = await s.storeEvent('A', msg(1));
-        now += 500;
-        const id2 = await s.storeEvent('A', msg(2));
-        now += 2000; // both old now from id1's perspective, id2 still within window
-        const id3 = await s.storeEvent('A', msg(3));
-
-        // id1 + id2 are older than 1000ms relative to `now`, so they are evicted.
-        const sent: string[] = [];
-        await s.replayEventsAfter(id1, {
-            send: async (eventId) => {
-                sent.push(eventId);
-            },
-        });
-        expect(sent).toEqual([id3]);
-        expect(id2 < id3).toBe(true); // counters still monotonic
-    });
-
-    it('never reuses an event id after the stream buffer empties', async () => {
-        let now = 1_000;
-        const s = new MemoryEventStore({ maxAgeMs: 100, now: () => now });
-        const id1 = await s.storeEvent('A', msg(1));
-        now += 1000; // evict id1
-        const id2 = await s.storeEvent('A', msg(2));
-
-        expect(id1).not.toBe(id2);
-        // counter monotonic — id2 must compare greater
-        expect(id1 < id2).toBe(true);
-    });
-
-    it('evicts across streams when global byte cap is exceeded', async () => {
-        // Each msg is ~30 bytes JSON; cap so only ~2 events fit globally.
-        const s = new MemoryEventStore({ maxBytesTotal: 60 });
-        await s.storeEvent('A', msg(1));
-        await s.storeEvent('B', msg(2));
-        await s.storeEvent('A', msg(3));
-        await s.storeEvent('B', msg(4));
-
-        // Should have shed oldest until under cap.
-        expect(s.bytes()).toBeLessThanOrEqual(60);
-        expect(s.size()).toBeLessThanOrEqual(3);
-    });
-});

package/src/store/MemoryEventStore.ts

@@ -1,151 +0,0 @@
-/**
- * MemoryEventStore — in-memory bounded buffer of MCP HTTP-streaming events,
- * implements the SDK `EventStore` interface so that
- * `StreamableHTTPServerTransport` can resume a dropped SSE connection from
- * a client-supplied `Last-Event-ID`.
- *
- * Eviction is applied on every store, in this order:
- *   1. drop per-stream events older than `maxAgeMs`
- *   2. drop oldest per-stream events while the stream length exceeds `maxEventsPerStream`
- *   3. drop globally-oldest events across all streams while `totalBytes` exceeds `maxBytesTotal`
- *
- * Event ids are `{streamId}::{padded counter}`. The counter is never reused
- * for a given stream so a reconnect with a stale `Last-Event-ID` can be
- * detected (the id is just absent from the buffer).
- */
-
-import type {
-    EventId,
-    EventStore,
-    StreamId,
-} from '@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js';
-import type { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
-
-export interface MemoryEventStoreOptions {
-    /** Max events retained per stream. Default 1000. */
-    maxEventsPerStream?: number;
-    /** Max age of a retained event, in ms. Default 5 minutes. */
-    maxAgeMs?: number;
-    /** Soft cap on total buffered bytes across all streams. Default 50 MiB. */
-    maxBytesTotal?: number;
-    /** Time source — override for tests. Default `Date.now`. */
-    now?: () => number;
-}
-
-interface StoredEvent {
-    eventId: EventId;
-    message: JSONRPCMessage;
-    ts: number;
-    bytes: number;
-}
-
-const SEPARATOR = '::';
-const COUNTER_PAD = 12;
-
-export class MemoryEventStore implements EventStore {
-    private readonly maxEventsPerStream: number;
-    private readonly maxAgeMs: number;
-    private readonly maxBytesTotal: number;
-    private readonly now: () => number;
-
-    private readonly streams = new Map<StreamId, StoredEvent[]>();
-    private readonly counters = new Map<StreamId, number>();
-    private totalBytes = 0;
-
-    constructor(opts: MemoryEventStoreOptions = {}) {
-        this.maxEventsPerStream = opts.maxEventsPerStream ?? 1000;
-        this.maxAgeMs = opts.maxAgeMs ?? 5 * 60_000;
-        this.maxBytesTotal = opts.maxBytesTotal ?? 50 * 1024 * 1024;
-        this.now = opts.now ?? Date.now;
-    }
-
-    async storeEvent(streamId: StreamId, message: JSONRPCMessage): Promise<EventId> {
-        const counter = (this.counters.get(streamId) ?? 0) + 1;
-        this.counters.set(streamId, counter);
-        const eventId = `${streamId}${SEPARATOR}${counter.toString().padStart(COUNTER_PAD, '0')}`;
-
-        const bytes = Buffer.byteLength(JSON.stringify(message), 'utf8');
-        const stored: StoredEvent = { eventId, message, ts: this.now(), bytes };
-
-        let stream = this.streams.get(streamId);
-        if (!stream) {
-            stream = [];
-            this.streams.set(streamId, stream);
-        }
-        stream.push(stored);
-        this.totalBytes += bytes;
-
-        this.evict();
-        return eventId;
-    }
-
-    async getStreamIdForEventId(eventId: EventId): Promise<StreamId | undefined> {
-        const idx = eventId.lastIndexOf(SEPARATOR);
-        return idx < 0 ? undefined : eventId.slice(0, idx);
-    }
-
-    async replayEventsAfter(
-        lastEventId: EventId,
-        { send }: { send: (eventId: EventId, message: JSONRPCMessage) => Promise<void> },
-    ): Promise<StreamId> {
-        const streamId = await this.getStreamIdForEventId(lastEventId);
-        if (!streamId) return '';
-        const stream = this.streams.get(streamId);
-        if (!stream) return streamId;
-        for (const ev of stream) {
-            if (ev.eventId > lastEventId) {
-                await send(ev.eventId, ev.message);
-            }
-        }
-        return streamId;
-    }
-
-    /** Test helper — total events currently buffered. */
-    size(): number {
-        let n = 0;
-        for (const stream of this.streams.values()) n += stream.length;
-        return n;
-    }
-
-    /** Test helper — current buffered bytes. */
-    bytes(): number {
-        return this.totalBytes;
-    }
-
-    private evict(): void {
-        const now = this.now();
-
-        for (const [sid, stream] of this.streams) {
-            while (
-                stream.length > 0 &&
-                (stream.length > this.maxEventsPerStream || now - stream[0].ts > this.maxAgeMs)
-            ) {
-                const dropped = stream.shift()!;
-                this.totalBytes -= dropped.bytes;
-            }
-            if (stream.length === 0) {
-                this.streams.delete(sid);
-                // Keep the counter — eventIds must never be reused for a stream
-                // even if its buffer is currently empty.
-            }
-        }
-
-        if (this.totalBytes <= this.maxBytesTotal) return;
-
-        while (this.totalBytes > this.maxBytesTotal) {
-            let oldestSid: StreamId | undefined;
-            let oldestTs = Infinity;
-            for (const [sid, stream] of this.streams) {
-                if (stream.length > 0 && stream[0].ts < oldestTs) {
-                    oldestTs = stream[0].ts;
-                    oldestSid = sid;
-                }
-            }
-            if (!oldestSid) break;
-            const stream = this.streams.get(oldestSid)!;
-            const dropped = stream.shift()!;
-            this.totalBytes -= dropped.bytes;
-            if (stream.length === 0) this.streams.delete(oldestSid);
-        }
-    }
-}

package/src/store/WriteQueue.ts

@@ -1,165 +0,0 @@
-/**
- * WriteQueue — async batching queue for JSONL timeline writes.
- *
- * Key behaviors:
- * - `seq` is assigned at enqueue time (not flush time) to preserve arrival order
- * - `setTimeout` on first enqueue after a flush — avoids unnecessary timer overhead when idle
- * - `flush` calls `fs.appendFile` once per file path with all buffered lines joined by `\n`
- * - `drain` awaits the current flush and any in-flight writes before returning
- * - On flush failure: log error, discard batch, continue — seq numbers from failed batch are not reused
- *
- * Requirements: 4.1, 4.2, 4.6, 4.7, 4.8
- */
-
-import { appendFile } from 'node:fs/promises';
-
-/** Maximum delay (ms) before a pending flush is executed. */
-const FLUSH_DELAY_MS = 16;
-
-export class WriteQueue {
-    /** filePath → pending lines to write */
-    private buffers = new Map<string, string[]>();
-
-    /** Pending setTimeout handle; null when idle */
-    private timer: NodeJS.Timeout | null = null;
-
-    /** sessionId → next seq number (assigned at enqueue time) */
-    private seq = new Map<string, number>();
-
-    /** Promise for the currently in-flight flush, if any */
-    private flushPromise: Promise<void> | null = null;
-
-    /**
-     * Enqueue a StoreEvent line for writing.
-     *
-     * The `line` parameter should be a JSON object string WITHOUT a `seq` field.
-     * WriteQueue assigns the seq for the given sessionId, injects it into the line,
-     * and pushes the result to the buffer for `filePath`.
-     *
-     * @param filePath  Absolute path to the JSONL file to append to
-     * @param sessionId Session identifier used to track the per-session seq counter
-     * @param line      Pre-serialized JSON object string (without `seq` field)
-     */
-    enqueue(filePath: string, sessionId: string, line: string): void {
-        // Assign seq at enqueue time to preserve arrival order
-        const seq = this.seq.get(sessionId) ?? 0;
-        this.seq.set(sessionId, seq + 1);
-
-        // Inject seq into the JSON line
-        // The line is a JSON object string like '{"ts":1000,"t":"log",...}'
-        // We insert seq as the first field for readability
-        const lineWithSeq = injectSeq(line, seq);
-
-        // Push to buffer for this file path
-        const buf = this.buffers.get(filePath);
-        if (buf) {
-            buf.push(lineWithSeq);
-        } else {
-            this.buffers.set(filePath, [lineWithSeq]);
-        }
-
-        // Schedule a flush if not already pending
-        if (this.timer === null) {
-            this.timer = setTimeout(() => {
-                this.timer = null;
-                this.flushPromise = this.flush();
-            }, FLUSH_DELAY_MS);
-        }
-    }
-
-    /**
-     * Drain all buffers: one `fs.appendFile` call per file path.
-     * On error: log + discard batch (do not retry).
-     * Seq numbers from failed batches are not reused.
-     */
-    async flush(): Promise<void> {
-        if (this.buffers.size === 0) return;
-
-        // Snapshot and clear the buffers atomically before any async work.
-        // This ensures new enqueues during the flush go into fresh buffers.
-        const snapshot = new Map(this.buffers);
-        this.buffers.clear();
-
-        const writes: Promise<void>[] = [];
-
-        for (const [filePath, lines] of snapshot) {
-            if (lines.length === 0) continue;
-            // Join all lines with newline; append a trailing newline
-            const content = lines.join('\n') + '\n';
-            writes.push(
-                appendFile(filePath, content, 'utf-8').catch((err: unknown) => {
-                    console.error(
-                        `[WriteQueue] flush failed for ${filePath} (${lines.length} events discarded):`,
-                        err,
-                    );
-                    // Discard batch — do not retry, do not reuse seq numbers
-                }),
-            );
-        }
-
-        await Promise.all(writes);
-    }
-
-    /**
-     * Flush any pending timer-scheduled writes immediately, then await
-     * the current in-flight flush (if any). Used on `close()` / SIGINT
-     * to ensure all buffered events reach disk before the process exits.
-     */
-    async drain(): Promise<void> {
-        // Cancel the pending timer so we don't double-flush
-        if (this.timer !== null) {
-            clearTimeout(this.timer);
-            this.timer = null;
-        }
-
-        // Capture any already in-flight flush (timer may have fired just before drain)
-        const inflight = this.flushPromise;
-
-        // Flush whatever is currently buffered (may be empty if inflight already drained it)
-        const newFlush = this.flush();
-        this.flushPromise = newFlush;
-
-        // Await both: the previously in-flight flush and the new one
-        await Promise.all([inflight, newFlush]);
-    }
-
-    /**
-     * Get the current seq counter for a session (for testing / inspection).
-     * Returns 0 if no events have been enqueued for this session yet.
-     */
-    getSeq(sessionId: string): number {
-        return this.seq.get(sessionId) ?? 0;
-    }
-}
-
-// ─── Helpers ──────────────────────────────────────────────────────────────────
-
-/**
- * Inject a `seq` field as the first property of a JSON object string.
- *
- * Input:  '{"ts":1000,"t":"log"}'
- * Output: '{"seq":0,"ts":1000,"t":"log"}'
- *
- * Falls back to appending seq if the line is not a valid JSON object.
- */
-function injectSeq(line: string, seq: number): string {
-    const trimmed = line.trimStart();
-    if (trimmed.startsWith('{')) {
-        // Fast path: insert after the opening brace
-        const openBrace = line.indexOf('{');
-        const rest = line.slice(openBrace + 1).trimStart();
-        if (rest.startsWith('}')) {
-            // Empty object
-            return `{"seq":${seq}}`;
-        }
-        return `${line.slice(0, openBrace + 1)}"seq":${seq},${line.slice(openBrace + 1)}`;
-    }
-    // Fallback: parse and re-serialize (handles edge cases)
-    try {
-        const obj = JSON.parse(line) as Record<string, unknown>;
-        return JSON.stringify({ seq, ...obj });
-    } catch {
-        // If the line is not valid JSON, wrap it
-        return JSON.stringify({ seq, _raw: line });
-    }
-}

package/src/store/identityTagging.test.ts

@@ -1,67 +0,0 @@
-/**
- * Caller-identity tagging (4.0 · P1): `createdBy` is write-once on project /
- * session metadata — the first principal to create the record owns it, and
- * later upserts (which never carry an identity in normal flow) must not
- * silently re-attribute ownership.
- */
-import { afterEach, beforeEach, 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 { JsonlStore } from './JsonlStore.js';
-
-describe('store: createdBy tagging (P1)', () => {
-    let dir: string;
-    let store: JsonlStore;
-
-    beforeEach(() => {
-        dir = mkdtempSync(join(tmpdir(), 'harness-identity-test-'));
-        store = new JsonlStore(dir);
-    });
-    afterEach(() => {
-        store.close();
-        try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
-    });
-
-    it('project: records createdBy on creation', () => {
-        const p = store.upsertProject('proj-a', { createdBy: 'token:abc' });
-        expect(p.createdBy).toBe('token:abc');
-        expect(store.getProject('proj-a')?.createdBy).toBe('token:abc');
-    });
-
-    it('project: createdBy is write-once (later upsert without it is preserved)', () => {
-        store.upsertProject('proj-a', { createdBy: 'local' });
-        const after = store.upsertProject('proj-a', { displayName: 'renamed' });
-        expect(after.createdBy).toBe('local');
-        expect(after.displayName).toBe('renamed');
-    });
-
-    it('project: a later upsert cannot re-attribute ownership', () => {
-        store.upsertProject('proj-a', { createdBy: 'local' });
-        const after = store.upsertProject('proj-a', { createdBy: 'token:evil' });
-        expect(after.createdBy).toBe('local');
-    });
-
-    it('project: createdBy stays undefined when never supplied (back-compat)', () => {
-        const p = store.upsertProject('proj-legacy', { displayName: 'x' });
-        expect(p.createdBy).toBeUndefined();
-    });
-
-    it('session: records and locks createdBy', () => {
-        const sid = randomUUID();
-        store.upsertSession(sid, {
-            tabId: 'tab-1',
-            startedAt: Date.now(),
-            participants: [{ projectId: 'proj-a', joinedAt: Date.now() }],
-            createdBy: 'local',
-        });
-        store.upsertSession(sid, {
-            tabId: 'tab-1',
-            startedAt: Date.now(),
-            participants: [{ projectId: 'proj-a', joinedAt: Date.now() }],
-            createdBy: 'token:other',
-        });
-        expect(store.getSession(sid)?.createdBy).toBe('local');
-    });
-});

package/src/store/index.ts

@@ -1,29 +0,0 @@
-export { JsonlStore, sanitizeId } from './JsonlStore.js';
-export { WriteQueue } from './WriteQueue.js';
-export { JsonTaskStore } from './JsonTaskStore.js';
-export { JsonMemoryStore } from './JsonMemoryStore.js';
-export { MemoryEventStore, type MemoryEventStoreOptions } from './MemoryEventStore.js';
-export type {
-    IStore,
-    ITaskStore,
-    IMemoryStore,
-    MemoryEntry,
-    StoreEvent,
-    EventType,
-    ProjectMeta,
-    ProjectTreeNode,
-    BuildMeta,
-    SessionMeta,
-    TabMeta,
-    SessionSummary,
-    TailOptions,
-    SearchOptions,
-    RecordingChunkSummary,
-    RecordingChunk,
-    ReplayExportMeta,
-    RetentionPolicy,
-    PurgeResult,
-    EventStore,
-    EventId,
-    StreamId,
-} from './types.js';