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

package/dist/store/MemoryEventStore.d.ts

@@ -1,47 +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;
-}
-export declare class MemoryEventStore implements EventStore {
-    private readonly maxEventsPerStream;
-    private readonly maxAgeMs;
-    private readonly maxBytesTotal;
-    private readonly now;
-    private readonly streams;
-    private readonly counters;
-    private totalBytes;
-    constructor(opts?: MemoryEventStoreOptions);
-    storeEvent(streamId: StreamId, message: JSONRPCMessage): Promise<EventId>;
-    getStreamIdForEventId(eventId: EventId): Promise<StreamId | undefined>;
-    replayEventsAfter(lastEventId: EventId, { send }: {
-        send: (eventId: EventId, message: JSONRPCMessage) => Promise<void>;
-    }): Promise<StreamId>;
-    /** Test helper — total events currently buffered. */
-    size(): number;
-    /** Test helper — current buffered bytes. */
-    bytes(): number;
-    private evict;
-}

package/dist/store/MemoryEventStore.js

@@ -1,111 +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).
- */
-const SEPARATOR = '::';
-const COUNTER_PAD = 12;
-export class MemoryEventStore {
-    maxEventsPerStream;
-    maxAgeMs;
-    maxBytesTotal;
-    now;
-    streams = new Map();
-    counters = new Map();
-    totalBytes = 0;
-    constructor(opts = {}) {
-        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, message) {
-        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 = { 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) {
-        const idx = eventId.lastIndexOf(SEPARATOR);
-        return idx < 0 ? undefined : eventId.slice(0, idx);
-    }
-    async replayEventsAfter(lastEventId, { send }) {
-        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() {
-        let n = 0;
-        for (const stream of this.streams.values())
-            n += stream.length;
-        return n;
-    }
-    /** Test helper — current buffered bytes. */
-    bytes() {
-        return this.totalBytes;
-    }
-    evict() {
-        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;
-            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/dist/store/WriteQueue.d.ts

@@ -1,51 +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
- */
-export declare class WriteQueue {
-    /** filePath → pending lines to write */
-    private buffers;
-    /** Pending setTimeout handle; null when idle */
-    private timer;
-    /** sessionId → next seq number (assigned at enqueue time) */
-    private seq;
-    /** Promise for the currently in-flight flush, if any */
-    private flushPromise;
-    /**
-     * 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;
-    /**
-     * 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.
-     */
-    flush(): Promise<void>;
-    /**
-     * 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.
-     */
-    drain(): Promise<void>;
-    /**
-     * 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;
-}

package/dist/store/WriteQueue.js

@@ -1,142 +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 */
-    buffers = new Map();
-    /** Pending setTimeout handle; null when idle */
-    timer = null;
-    /** sessionId → next seq number (assigned at enqueue time) */
-    seq = new Map();
-    /** Promise for the currently in-flight flush, if any */
-    flushPromise = 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, sessionId, line) {
-        // 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() {
-        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 = [];
-        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) => {
-                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() {
-        // 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) {
-        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, seq) {
-    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);
-        return JSON.stringify({ seq, ...obj });
-    }
-    catch {
-        // If the line is not valid JSON, wrap it
-        return JSON.stringify({ seq, _raw: line });
-    }
-}

package/dist/store/index.d.ts

@@ -1,6 +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';

package/dist/store/index.js

@@ -1,5 +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 } from './MemoryEventStore.js';