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

package/src/visitorTimeline.test.ts

@@ -1,197 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } 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 './store/index.js';
-import { buildVisitorTimeline } from './visitorTimeline.js';
-
-function openSession(
-    store: JsonlStore,
-    projectId: string,
-    tabId: string,
-    sessionId = randomUUID(),
-    startedAt = Date.now(),
-): string {
-    store.upsertTab(tabId, { connectedAt: startedAt });
-    store.upsertSession(sessionId, {
-        tabId,
-        startedAt,
-        participants: [{ projectId, joinedAt: startedAt }],
-    });
-    return sessionId;
-}
-
-describe('buildVisitorTimeline', () => {
-    let dir: string;
-    let store: JsonlStore;
-
-    beforeEach(() => {
-        dir = mkdtempSync(join(tmpdir(), 'visitor-timeline-'));
-        store = new JsonlStore(dir);
-    });
-
-    afterEach(() => {
-        rmSync(dir, { recursive: true, force: true });
-    });
-
-    it('returns error when visitor not found', async () => {
-        await store.flush();
-        const result = buildVisitorTimeline(store, 'no-such-visitor');
-        expect(result).toEqual({ error: 'visitor not found: no-such-visitor' });
-    });
-
-    it('merges events from multiple sessions ascending by ts', async () => {
-        const visitorId = 'visitor-1';
-        const projectId = 'proj-a';
-        const tabA = 'tab-a';
-        const tabB = 'tab-b';
-
-        const sessA = openSession(store, projectId, tabA);
-        const sessB = openSession(store, projectId, tabB);
-        store.upsertVisitor(visitorId, { seenAt: Date.now(), addTabId: tabA, addProjectId: projectId });
-        store.upsertVisitor(visitorId, { addTabId: tabB });
-
-        // Interleave events across the two tabs.
-        store.appendEvent(sessA, { ts: 1000, t: 'req', tab: tabA, visitorId, d: { url: '/a1' } });
-        store.appendEvent(sessB, { ts: 1500, t: 'req', tab: tabB, visitorId, d: { url: '/b1' } });
-        store.appendEvent(sessA, { ts: 2000, t: 'res', tab: tabA, visitorId, d: { status: 200 } });
-        store.appendEvent(sessB, { ts: 2500, t: 'storage', tab: tabB, visitorId, d: { op: 'remove', key: 'token' } });
-
-        await store.flush();
-        const result = buildVisitorTimeline(store, visitorId);
-        if ('error' in result) throw new Error(result.error);
-
-        expect(result.eventCount).toBe(4);
-        expect(result.sessionCount).toBe(2);
-        expect(result.events.map((e) => e.ts)).toEqual([1000, 1500, 2000, 2500]);
-        // tabId distribution proves both tabs contributed.
-        const tabs = new Set(result.events.map((e) => e.tab));
-        expect(tabs).toEqual(new Set([tabA, tabB]));
-    });
-
-    it('drops events from other visitors that landed in the same session', async () => {
-        const visitorId = 'visitor-mine';
-        const otherVisitor = 'visitor-stranger';
-        const projectId = 'proj';
-        const tabId = 'tab-shared';
-
-        const sess = openSession(store, projectId, tabId);
-        store.upsertVisitor(visitorId, { addTabId: tabId, addProjectId: projectId });
-
-        store.appendEvent(sess, { ts: 1000, t: 'req', tab: tabId, visitorId, d: { url: '/mine' } });
-        store.appendEvent(sess, { ts: 1500, t: 'req', tab: tabId, visitorId: otherVisitor, d: { url: '/other' } });
-        store.appendEvent(sess, { ts: 2000, t: 'req', tab: tabId, visitorId, d: { url: '/mine2' } });
-
-        await store.flush();
-        const result = buildVisitorTimeline(store, visitorId);
-        if ('error' in result) throw new Error(result.error);
-
-        expect(result.eventCount).toBe(2);
-        expect(result.events.every((e) => e.visitorId === visitorId)).toBe(true);
-    });
-
-    it('honors tabIds filter at both session-discovery and row level', async () => {
-        const visitorId = 'visitor-1';
-        const projectId = 'proj';
-        const tabA = 'tab-a';
-        const tabB = 'tab-b';
-
-        const sessA = openSession(store, projectId, tabA);
-        const sessB = openSession(store, projectId, tabB);
-        store.upsertVisitor(visitorId, { addTabId: tabA, addProjectId: projectId });
-        store.upsertVisitor(visitorId, { addTabId: tabB });
-
-        store.appendEvent(sessA, { ts: 1000, t: 'req', tab: tabA, visitorId, d: {} });
-        store.appendEvent(sessB, { ts: 2000, t: 'req', tab: tabB, visitorId, d: {} });
-
-        await store.flush();
-        const result = buildVisitorTimeline(store, visitorId, { tabIds: [tabA] });
-        if ('error' in result) throw new Error(result.error);
-
-        expect(result.eventCount).toBe(1);
-        expect(result.events[0].tab).toBe(tabA);
-    });
-
-    it('honors types filter via store.tail', async () => {
-        const visitorId = 'visitor-1';
-        const projectId = 'proj';
-        const tabId = 'tab-1';
-
-        const sess = openSession(store, projectId, tabId);
-        store.upsertVisitor(visitorId, { addTabId: tabId, addProjectId: projectId });
-
-        store.appendEvent(sess, { ts: 1000, t: 'log', tab: tabId, visitorId, d: {} });
-        store.appendEvent(sess, { ts: 2000, t: 'req', tab: tabId, visitorId, d: {} });
-        store.appendEvent(sess, { ts: 3000, t: 'storage', tab: tabId, visitorId, d: {} });
-
-        await store.flush();
-        const result = buildVisitorTimeline(store, visitorId, { types: ['req', 'storage'] });
-        if ('error' in result) throw new Error(result.error);
-
-        expect(result.events.map((e) => e.t)).toEqual(['req', 'storage']);
-    });
-
-    it('limit takes the newest N events and reports truncated=true', async () => {
-        const visitorId = 'visitor-1';
-        const projectId = 'proj';
-        const tabId = 'tab-1';
-
-        const sess = openSession(store, projectId, tabId);
-        store.upsertVisitor(visitorId, { addTabId: tabId, addProjectId: projectId });
-
-        for (let i = 0; i < 10; i++) {
-            store.appendEvent(sess, { ts: 1000 + i, t: 'log', tab: tabId, visitorId, d: { i } });
-        }
-
-        await store.flush();
-        const result = buildVisitorTimeline(store, visitorId, { limit: 3 });
-        if ('error' in result) throw new Error(result.error);
-
-        expect(result.eventCount).toBe(3);
-        expect(result.truncated).toBe(true);
-        expect(result.events.map((e) => e.ts)).toEqual([1007, 1008, 1009]);
-    });
-
-    it('honors explicit sessionIds (skips visitor → session discovery)', async () => {
-        const visitorId = 'visitor-1';
-        const projectId = 'proj';
-        const tabA = 'tab-a';
-        const tabB = 'tab-b';
-
-        const sessA = openSession(store, projectId, tabA);
-        const sessB = openSession(store, projectId, tabB);
-        store.upsertVisitor(visitorId, { addTabId: tabA, addProjectId: projectId });
-        store.upsertVisitor(visitorId, { addTabId: tabB });
-
-        store.appendEvent(sessA, { ts: 1000, t: 'log', tab: tabA, visitorId, d: {} });
-        store.appendEvent(sessB, { ts: 2000, t: 'log', tab: tabB, visitorId, d: {} });
-
-        await store.flush();
-        const result = buildVisitorTimeline(store, visitorId, { sessionIds: [sessA] });
-        if ('error' in result) throw new Error(result.error);
-
-        expect(result.sessionCount).toBe(1);
-        expect(result.eventCount).toBe(1);
-        expect(result.events[0].tab).toBe(tabA);
-    });
-
-    it('honors since/until window', async () => {
-        const visitorId = 'visitor-1';
-        const projectId = 'proj';
-        const tabId = 'tab-1';
-
-        const sess = openSession(store, projectId, tabId);
-        store.upsertVisitor(visitorId, { addTabId: tabId, addProjectId: projectId });
-
-        store.appendEvent(sess, { ts: 1000, t: 'log', tab: tabId, visitorId, d: {} });
-        store.appendEvent(sess, { ts: 2000, t: 'log', tab: tabId, visitorId, d: {} });
-        store.appendEvent(sess, { ts: 3000, t: 'log', tab: tabId, visitorId, d: {} });
-
-        await store.flush();
-        const result = buildVisitorTimeline(store, visitorId, { since: 1500, until: 2500 });
-        if ('error' in result) throw new Error(result.error);
-
-        expect(result.events.map((e) => e.ts)).toEqual([2000]);
-    });
-});

package/src/visitorTimeline.ts

@@ -1,89 +0,0 @@
-/**
- * visitor.timeline — merge event timelines across all sessions belonging to
- * one visitor. Pulled out of mcp.ts so the merge / filter logic is unit
- * testable without spinning up an McpServer.
- */
-
-import type { IStore, StoreEvent } from './store/index.js';
-
-export interface VisitorTimelineOptions {
-    since?: number;
-    until?: number;
-    types?: string | string[];
-    tabIds?: string[];
-    sessionIds?: string[];
-    limit?: number;
-}
-
-export interface VisitorTimelineResult {
-    visitorId: string;
-    sessionCount: number;
-    eventCount: number;
-    truncated: boolean;
-    events: StoreEvent[];
-}
-
-const DEFAULT_LIMIT = 200;
-const SESSION_DISCOVERY_PAGE = 200;
-
-export function buildVisitorTimeline(
-    store: IStore,
-    visitorId: string,
-    opts: VisitorTimelineOptions = {},
-): VisitorTimelineResult | { error: string } {
-    const visitor = store.getVisitor(visitorId);
-    if (!visitor) return { error: `visitor not found: ${visitorId}` };
-
-    const cap = opts.limit ?? DEFAULT_LIMIT;
-    const tabFilter = opts.tabIds && opts.tabIds.length > 0 ? new Set(opts.tabIds) : undefined;
-
-    // 1. Discover candidate sessions (or honor the explicit list).
-    const candidateIds = new Set<string>();
-    if (opts.sessionIds && opts.sessionIds.length > 0) {
-        for (const id of opts.sessionIds) candidateIds.add(id);
-    } else {
-        const visitorTabs = new Set(visitor.tabIds);
-        for (const pid of visitor.projectIds) {
-            for (const sess of store.listSessions({ projectId: pid, limit: SESSION_DISCOVERY_PAGE })) {
-                if (candidateIds.has(sess.id)) continue;
-                if (sess.tabId && !visitorTabs.has(sess.tabId)) continue;
-                if (tabFilter && sess.tabId && !tabFilter.has(sess.tabId)) continue;
-                candidateIds.add(sess.id);
-            }
-        }
-    }
-
-    // 2. Pull tail() from each session and merge. Over-fetch by 1 per session
-    //    so we can detect single-session truncation (tail returns exactly `cap`
-    //    when there are more, indistinguishable from "the session had exactly
-    //    `cap` events" otherwise).
-    const merged: StoreEvent[] = [];
-    let perSessionTruncated = false;
-    for (const sid of candidateIds) {
-        const events = store.tail(sid, {
-            n: cap + 1,
-            type: opts.types,
-            since: opts.since,
-            until: opts.until,
-        });
-        if (events.length > cap) perSessionTruncated = true;
-        for (const ev of events) {
-            if (ev.visitorId && ev.visitorId !== visitorId) continue;
-            if (tabFilter && ev.tab && !tabFilter.has(ev.tab)) continue;
-            merged.push(ev);
-        }
-    }
-
-    // 3. Ascending sort, then trim to the newest `cap` events.
-    merged.sort((a, b) => a.ts - b.ts);
-    const truncated = perSessionTruncated || merged.length > cap;
-    const slice = merged.length > cap ? merged.slice(merged.length - cap) : merged;
-
-    return {
-        visitorId,
-        sessionCount: candidateIds.size,
-        eventCount: slice.length,
-        truncated,
-        events: slice,
-    };
-}