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

package/dist/remoteBridge.d.ts

@@ -1,61 +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 { type McpCallFrame, type TabInfo, type Task, type TaskStatus } from '@harness-fe/protocol';
-import type { IBridge, SendCommandOptions } from './bridge.js';
-import type { IMemoryStore, IStore } from './store/index.js';
-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 declare class RemoteBridge implements IBridge {
-    private ws?;
-    private pending;
-    private closed;
-    private readonly url;
-    private readonly callTimeoutMs;
-    private readonly host;
-    private readonly port;
-    private readonly token;
-    constructor(opts: RemoteBridgeOptions);
-    connect(): Promise<void>;
-    stop(): Promise<void>;
-    sendCommand(command: string, args: unknown, opts?: SendCommandOptions): Promise<unknown>;
-    listTabs(): Promise<TabInfo[]>;
-    listTasks(filter?: {
-        status?: TaskStatus | 'all';
-        limit?: number;
-    }): Promise<Task[]>;
-    claimTask(id: string): Promise<Task | undefined>;
-    resolveTask(id: string, note?: string): 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;
-    getViewerBaseUrl(): string | undefined;
-    getAuthToken(): string | undefined;
-    getTaskAttachmentData(_taskId: string, _attachmentId: string): Promise<string | 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;
-    /** @internal — used by RemoteMemoryStore and RemoteStore */
-    invokeRemote(method: McpCallFrame['method'], args: unknown): Promise<unknown>;
-    private invoke;
-    private attachHandlers;
-    private handleReturn;
-    private handleClose;
-}

package/dist/remoteBridge.js

@@ -1,307 +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 { frameSchema, } from '@harness-fe/protocol';
-const DEFAULT_CALL_TIMEOUT_MS = 30_000;
-export class RemoteBridge {
-    ws;
-    pending = new Map();
-    closed = false;
-    url;
-    callTimeoutMs;
-    host;
-    port;
-    token;
-    constructor(opts) {
-        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() {
-        return new Promise((resolve, reject) => {
-            const headers = {};
-            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) => {
-                ws.off('open', onOpen);
-                reject(err);
-            };
-            ws.once('open', onOpen);
-            ws.once('error', onErr);
-        });
-    }
-    async stop() {
-        this.closed = true;
-        const ws = this.ws;
-        if (!ws)
-            return;
-        try {
-            ws.close();
-        }
-        catch {
-            /* swallow */
-        }
-    }
-    sendCommand(command, args, opts) {
-        return this.invoke('sendCommand', { command, args, opts });
-    }
-    listTabs() {
-        return this.invoke('listTabs', {});
-    }
-    listTasks(filter = {}) {
-        return this.invoke('listTasks', filter);
-    }
-    claimTask(id) {
-        return this.invoke('claimTask', { id });
-    }
-    resolveTask(id, note) {
-        return this.invoke('resolveTask', { id, note });
-    }
-    /**
-     * 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() {
-        return new RemoteMemoryStore(this);
-    }
-    getViewerBaseUrl() {
-        // Followers share the same WS/HTTP port as the leader.
-        return `http://${this.host}:${this.port}`;
-    }
-    getAuthToken() {
-        // 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, _attachmentId) {
-        // 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() {
-        return new RemoteStore(this);
-    }
-    /** @internal — used by RemoteMemoryStore and RemoteStore */
-    invokeRemote(method, args) {
-        return this.invoke(method, args);
-    }
-    invoke(method, args) {
-        const ws = this.ws;
-        if (!ws || ws.readyState !== WebSocket.OPEN) {
-            return Promise.reject(new Error('remote-bridge: not connected'));
-        }
-        const id = randomUUID();
-        const frame = { 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);
-            }
-        });
-    }
-    attachHandlers(ws) {
-        ws.on('message', (raw) => {
-            let parsed;
-            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 */
-        });
-    }
-    handleReturn(frame) {
-        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'));
-        }
-    }
-    handleClose() {
-        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 {
-    bridge;
-    constructor(bridge) {
-        this.bridge = bridge;
-    }
-    get(projectId, key) {
-        // 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, key) {
-        return this.bridge.invokeRemote('memoryGet', { projectId, key });
-    }
-    set(projectId, key, value) {
-        throw new Error('RemoteMemoryStore.set() must be called via setAsync().');
-    }
-    async setAsync(projectId, key, value) {
-        return this.bridge.invokeRemote('memorySet', { projectId, key, value });
-    }
-    delete(projectId, key) {
-        throw new Error('RemoteMemoryStore.delete() must be called via deleteAsync().');
-    }
-    async deleteAsync(projectId, key) {
-        return this.bridge.invokeRemote('memoryDelete', { projectId, key });
-    }
-    list(projectId) {
-        throw new Error('RemoteMemoryStore.list() must be called via listAsync().');
-    }
-    async listAsync(projectId) {
-        return this.bridge.invokeRemote('memoryList', { projectId });
-    }
-}
-// ─── RemoteStore ──────────────────────────────────────────────────────────────
-//
-// Proxies IStore read operations to the leader via mcp.call frames.
-// Write operations throw — followers are read-only for the store.
-class RemoteStore {
-    bridge;
-    constructor(bridge) {
-        this.bridge = bridge;
-    }
-    // ── Read operations (proxied) ──────────────────────────────────────────
-    async listProjectsAsync() {
-        return this.bridge.invokeRemote('storeListProjects', {});
-    }
-    async listSessionsAsync(opts) {
-        return this.bridge.invokeRemote('storeListSessions', opts ?? {});
-    }
-    async summaryAsync(sessionId) {
-        return this.bridge.invokeRemote('storeSummary', { sessionId });
-    }
-    async tailAsync(sessionId, opts) {
-        return this.bridge.invokeRemote('storeTail', { sessionId, opts });
-    }
-    async searchAsync(sessionId, query, opts) {
-        return this.bridge.invokeRemote('storeSearch', { sessionId, query, opts });
-    }
-    async listRecordingsAsync(sessionId) {
-        return this.bridge.invokeRemote('storeRecordingsList', { sessionId });
-    }
-    async sliceRecordingsAsync(sessionId, since, until) {
-        return this.bridge.invokeRemote('storeRecordingsSlice', { sessionId, since, until });
-    }
-    async replayCreateAsync(args) {
-        return this.bridge.invokeRemote('storeReplayCreate', args);
-    }
-    async purgeAsync(policy) {
-        return this.bridge.invokeRemote('storePurge', policy ?? {});
-    }
-    // ── 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, _patch) { throw notSupported('openBuild'); }
-    closeBuild(_b, _c) { throw notSupported('closeBuild'); }
-    // Tab lifecycle
-    upsertTab(_t, _patch) { throw notSupported('upsertTab'); }
-    getTab(_t) { throw notSupported('getTab'); }
-    closeTab(_t, _d) { throw notSupported('closeTab'); }
-    // Session lifecycle
-    upsertSession(_s, _m) { throw notSupported('upsertSession'); }
-    closeSession(_s, _e) { throw notSupported('closeSession'); }
-    getSession(_id) { throw notSupported('getSession'); }
-    listSessions(_opts) { throw notSupported('listSessions'); }
-    // Write
-    appendEvent(_s, _e) { throw notSupported('appendEvent'); }
-    appendEventBatch(_s, _e) { throw notSupported('appendEventBatch'); }
-    appendRecording(_s, _c) { throw notSupported('appendRecording'); }
-    writeNote(_p, _k, _v) { throw notSupported('writeNote'); }
-    // Project metadata
-    listProjects() { throw notSupported('listProjects'); }
-    upsertProject(_p, _patch) { throw notSupported('upsertProject'); }
-    getProject(_p) { throw notSupported('getProject'); }
-    getProjectTree(_r) { throw notSupported('getProjectTree'); }
-    // Build metadata
-    upsertBuild(_p, _b, _patch) { throw notSupported('upsertBuild'); }
-    getBuild(_p, _b) { throw notSupported('getBuild'); }
-    listBuilds(_p, _l) { throw notSupported('listBuilds'); }
-    // Visitor metadata (0.5+) — followers don't proxy yet; leader-only for now.
-    upsertVisitor(_v, _patch) { throw notSupported('upsertVisitor'); }
-    getVisitor(_v) { throw notSupported('getVisitor'); }
-    listVisitors(_opts) { throw notSupported('listVisitors'); }
-    // Read
-    tail(_s, _o) { throw notSupported('tail'); }
-    search(_s, _q, _o) { throw notSupported('search'); }
-    listRecordings(_s) { throw notSupported('listRecordings'); }
-    sliceRecordings(_s, _since, _until) { throw notSupported('sliceRecordings'); }
-    writeExport(_i) { throw notSupported('writeExport'); }
-    getExport(_id) { throw notSupported('getExport'); }
-    readExportEvents(_id) { throw notSupported('readExportEvents'); }
-    listExports(_p, _l) { throw notSupported('listExports'); }
-    summary(_s) { throw notSupported('summary'); }
-    listNotes(_p) { throw notSupported('listNotes'); }
-    // Maintenance
-    purge(_p) { throw notSupported('purge'); }
-    close() { }
-}
-function notSupported(method) {
-    return new Error(`remote-bridge: IStore.${method}() is not available in follower mode`);
-}

package/dist/replayCreate.d.ts

@@ -1,36 +0,0 @@
-/**
- * Shared replay-export logic used by both the leader's MCP tool handler and
- * the leader's mcp.call dispatcher (for follower proxy calls).
- *
- * Takes a time window (or a center timestamp), pulls the overlapping rrweb
- * chunks for a single tab, concatenates the events, persists them as an
- * export, and returns the metadata + viewerUrl.
- */
-import type { IStore } from './store/index.js';
-export interface ReplayCreateArgs {
-    sessionId: string;
-    tabId?: string;
-    ts?: number;
-    windowMs?: number;
-    since?: number;
-    until?: number;
-    label?: string;
-}
-export interface ReplayCreateResult {
-    exportId?: string;
-    viewerUrl?: string;
-    sessionId: string;
-    tabId?: string;
-    since: number;
-    until: number;
-    startTs?: number;
-    endTs?: number;
-    durationMs?: number;
-    eventCount?: number;
-    chunkCount?: number;
-    bytes?: number;
-    createdAt?: number;
-    label?: string;
-    error?: string;
-}
-export declare function createReplayExport(store: IStore, baseUrl: string | undefined, input: ReplayCreateArgs): ReplayCreateResult;

package/dist/replayCreate.js

@@ -1,156 +0,0 @@
-/**
- * Shared replay-export logic used by both the leader's MCP tool handler and
- * the leader's mcp.call dispatcher (for follower proxy calls).
- *
- * Takes a time window (or a center timestamp), pulls the overlapping rrweb
- * chunks for a single tab, concatenates the events, persists them as an
- * export, and returns the metadata + viewerUrl.
- */
-/** rrweb event types: 2 = FullSnapshot baseline. Replay needs at least one. */
-function isFullSnapshotEvent(ev) {
-    return (typeof ev === 'object' &&
-        ev !== null &&
-        ev.type === 2);
-}
-export function createReplayExport(store, baseUrl, input) {
-    const { sessionId, tabId, ts, windowMs, since, until, label } = input;
-    const session = store.getSession(sessionId);
-    if (!session) {
-        return { error: 'session not found', sessionId, since: since ?? 0, until: until ?? 0 };
-    }
-    let resolvedSince;
-    let resolvedUntil;
-    if (typeof since === 'number' && typeof until === 'number') {
-        if (until <= since) {
-            return { error: 'until must be greater than since', sessionId, since, until };
-        }
-        resolvedSince = since;
-        resolvedUntil = until;
-    }
-    else if (typeof ts === 'number') {
-        const radius = windowMs ?? 15_000;
-        resolvedSince = ts - radius;
-        resolvedUntil = ts + radius;
-    }
-    else {
-        return {
-            error: 'must provide either ts (with optional windowMs) or both since and until',
-            sessionId,
-            since: 0,
-            until: 0,
-        };
-    }
-    const chunks = store.sliceRecordings(sessionId, resolvedSince, resolvedUntil);
-    if (chunks.length === 0) {
-        return {
-            error: 'no rrweb chunks found in window',
-            sessionId,
-            tabId,
-            since: resolvedSince,
-            until: resolvedUntil,
-        };
-    }
-    let scopedTabId = tabId;
-    if (!scopedTabId) {
-        const byTab = new Map();
-        for (const c of chunks)
-            byTab.set(c.tabId, (byTab.get(c.tabId) ?? 0) + c.eventCount);
-        let best = '';
-        let bestEvents = -1;
-        for (const [t, count] of byTab) {
-            if (count > bestEvents) {
-                best = t;
-                bestEvents = count;
-            }
-        }
-        scopedTabId = best;
-    }
-    const tabChunks = chunks.filter((c) => c.tabId === scopedTabId);
-    const events = [];
-    let startTs = Infinity;
-    let endTs = -Infinity;
-    for (const c of tabChunks) {
-        for (const ev of c.events)
-            events.push(ev);
-        if (c.startTs < startTs)
-            startTs = c.startTs;
-        if (c.endTs > endTs)
-            endTs = c.endTs;
-    }
-    // rrweb replay requires a baseline pair — type:4 (Meta) + type:2
-    // (FullSnapshot) — before any type:3 (IncrementalSnapshot) is meaningful.
-    // If the window only contains incremental mutations (e.g. user picked a
-    // narrow window long after the page loaded, or the very first chunk was
-    // lost during a daemon restart), look back across earlier chunks for the
-    // most recent baseline and prepend it. Replay will then start from that
-    // earlier DOM state and roll mutations forward into the window.
-    if (!events.some(isFullSnapshotEvent) && resolvedSince > 0) {
-        const priorChunks = store
-            .sliceRecordings(sessionId, 0, resolvedSince - 1)
-            .filter((c) => c.tabId === scopedTabId)
-            .sort((a, b) => a.startTs - b.startTs);
-        // Walk backwards from the chunk closest to window start; the first
-        // chunk that has a FullSnapshot becomes our baseline.
-        for (let i = priorChunks.length - 1; i >= 0; i--) {
-            const baseline = priorChunks[i];
-            if (!baseline)
-                continue;
-            if (baseline.events.some(isFullSnapshotEvent)) {
-                // Prepend baseline events (full chunk — preserves Meta + FS
-                // ordering rrweb emitted them in). startTs widens to baseline.
-                events.unshift(...baseline.events);
-                if (baseline.startTs < startTs)
-                    startTs = baseline.startTs;
-                break;
-            }
-        }
-    }
-    if (events.length < 2) {
-        return {
-            error: 'window contains fewer than 2 rrweb events — not enough to replay',
-            sessionId,
-            tabId: scopedTabId,
-            since: resolvedSince,
-            until: resolvedUntil,
-            eventCount: events.length,
-        };
-    }
-    if (!events.some(isFullSnapshotEvent)) {
-        return {
-            error: 'window contains no rrweb FullSnapshot (type:2) baseline, and no earlier baseline could be found — replay would be blank',
-            sessionId,
-            tabId: scopedTabId,
-            since: resolvedSince,
-            until: resolvedUntil,
-            eventCount: events.length,
-        };
-    }
-    const meta = store.writeExport({
-        sessionId,
-        tabId: scopedTabId,
-        since: resolvedSince,
-        until: resolvedUntil,
-        label,
-        events,
-        startTs,
-        endTs,
-        chunkCount: tabChunks.length,
-    });
-    const viewerUrl = baseUrl ? `${baseUrl}/replay/${meta.exportId}` : undefined;
-    return {
-        exportId: meta.exportId,
-        viewerUrl,
-        sessionId,
-        tabId: scopedTabId,
-        since: resolvedSince,
-        until: resolvedUntil,
-        startTs,
-        endTs,
-        durationMs: endTs - startTs,
-        eventCount: meta.eventCount,
-        chunkCount: meta.chunkCount,
-        bytes: meta.bytes,
-        createdAt: meta.createdAt,
-        label,
-    };
-}

package/dist/replayViewer.d.ts

@@ -1,20 +0,0 @@
-/**
- * Replay viewer — HTTP routes for serving exported rrweb recordings.
- *
- * Routes (all served on the same port as the WS bridge):
- *   GET /replay/:id           HTML viewer page (rrweb-player UI)
- *   GET /replay/:id.json      Raw events array for the player to fetch
- *   GET /replay/static/player.js   Bundled rrweb-player (UMD)
- *   GET /replay/static/player.css  Bundled rrweb-player styles
- *
- * The HTML page loads the static assets relatively and then calls
- * /replay/:id.json to hydrate the player. This keeps the viewer self-contained
- * and offline-capable — no CDN dependencies.
- */
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import type { IStore } from './store/index.js';
-/**
- * Build a handler that dispatches /replay/* requests. Returns undefined for
- * non-replay paths so the caller can chain or 404.
- */
-export declare function createReplayHandler(store: IStore): (req: IncomingMessage, res: ServerResponse) => boolean;