@harness-fe/mcp-server 3.0.1

package/dist/store/JsonTaskStore.js

@@ -0,0 +1,53 @@
+/**
+ * JsonTaskStore — JSON-based persistence for annotation tasks.
+ *
+ * File format: {dataDir}/{sanitizeId(projectId)}/tasks.json
+ * ```json
+ * { "version": 1, "tasks": Task[] }
+ * ```
+ *
+ * Writes are atomic: write to a .tmp file then rename to the final path.
+ * On read failure (missing or corrupt file), returns an empty array.
+ * On write failure, logs the error without throwing.
+ */
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { sanitizeId } from './JsonlStore.js';
+export class JsonTaskStore {
+    dataDir;
+    constructor(dataDir) {
+        this.dataDir = dataDir;
+    }
+    tasksPath(projectId) {
+        return join(this.dataDir, sanitizeId(projectId), 'tasks.json');
+    }
+    loadTasks(projectId) {
+        const path = this.tasksPath(projectId);
+        if (!existsSync(path))
+            return [];
+        try {
+            const raw = readFileSync(path, 'utf-8');
+            const parsed = JSON.parse(raw);
+            if (!Array.isArray(parsed?.tasks))
+                return [];
+            return parsed.tasks;
+        }
+        catch {
+            return [];
+        }
+    }
+    saveTasks(projectId, tasks) {
+        const path = this.tasksPath(projectId);
+        const dir = join(this.dataDir, sanitizeId(projectId));
+        try {
+            mkdirSync(dir, { recursive: true });
+            const tmp = `${path}.tmp`;
+            const data = { version: 1, tasks };
+            writeFileSync(tmp, JSON.stringify(data, null, 2), 'utf-8');
+            renameSync(tmp, path);
+        }
+        catch (err) {
+            console.error(`[JsonTaskStore] saveTasks failed for project "${projectId}":`, err);
+        }
+    }
+}

package/dist/store/JsonlStore.d.ts

@@ -0,0 +1,128 @@
+/**
+ * JsonlStore — JSONL-based persistence layer (v0.4.0 layout).
+ *
+ * New layout (v0.4.0):
+ *   {dataDir}/projects/{projectId}/meta.json
+ *   {dataDir}/projects/{projectId}/notes.jsonl
+ *   {dataDir}/projects/{projectId}/builds/{buildId}/meta.json
+ *   {dataDir}/tabs/{tabId}/meta.json
+ *   {dataDir}/sessions/{sessionId}/meta.json
+ *   {dataDir}/sessions/{sessionId}/timeline.jsonl
+ *   {dataDir}/sessions/{sessionId}/recording.jsonl
+ *   {dataDir}/exports/index.jsonl
+ *   {dataDir}/exports/{exportId}.rrweb.json
+ *
+ * Legacy layout (v0.3.x, read-only fallback):
+ *   {dataDir}/{projectId}/sessions/{buildId}/tabs/{tabId}/...
+ *   On startup, if legacy dirs are detected a warning is emitted pointing
+ *   users to `rm -rf ~/.harness/data`.
+ */
+import type { BuildMeta, IStore, ProjectMeta, ProjectTreeNode, PurgeResult, RecordingChunk, RecordingChunkSummary, ReplayExportMeta, RetentionPolicy, SearchOptions, SessionMeta, SessionSummary, StoreEvent, TabMeta, TailOptions, VisitorMeta } from './types.js';
+import type { VisitorEnv } from '@harness-fe/protocol';
+export declare class JsonlStore implements IStore {
+    private readonly dataDir;
+    private readonly writeQueue;
+    /**
+     * In-memory index: sessionId → SessionMeta (rebuilt on startup, kept in sync).
+     * Enables O(1) session lookup without disk reads.
+     */
+    private sessionIndex;
+    /**
+     * In-memory index: buildId → projectId (from openBuild / upsertBuild).
+     * Enables resolving project from buildId for legacy bridge compat.
+     */
+    private buildIndex;
+    constructor(dataDir?: string);
+    /** Scan disk to rebuild in-memory indexes. Mark orphaned sessions (no endedAt). */
+    private _rebuildIndexes;
+    private projectsDir;
+    private projectDir;
+    private buildDir;
+    private visitorsDir;
+    private visitorDir;
+    private tabsDir;
+    private tabDir;
+    private sessionsDir;
+    private sessionDir;
+    private sessionTimeline;
+    private sessionRecording;
+    private exportsDir;
+    private exportIndex;
+    private exportEventsPath;
+    openBuild(projectId: string, patch?: Partial<Omit<BuildMeta, 'id' | 'projectId' | 'builtAt'>>): string;
+    closeBuild(buildId: string, closedAt?: number): void;
+    upsertTab(tabId: string, patch: Partial<Omit<TabMeta, 'id'>>): TabMeta;
+    getTab(tabId: string): TabMeta | undefined;
+    closeTab(tabId: string, disconnectedAt?: number): void;
+    upsertSession(sessionId: string, meta: Partial<Omit<SessionMeta, 'id'>> & {
+        tabId: string;
+        startedAt: number;
+    }): SessionMeta;
+    closeSession(sessionId: string, endedAt?: number): void;
+    getSession(sessionId: string): SessionMeta | undefined;
+    listSessions(opts?: {
+        tabId?: string;
+        projectId?: string;
+        buildId?: string;
+        limit?: number;
+    }): SessionMeta[];
+    appendEvent(sessionId: string, event: StoreEvent): void;
+    appendEventBatch(sessionId: string, events: StoreEvent[]): void;
+    appendRecording(sessionId: string, chunk: unknown): void;
+    writeNote(projectId: string, key: string, value: string): void;
+    upsertProject(projectId: string, patch: Partial<Omit<ProjectMeta, 'id' | 'createdAt'>>): ProjectMeta;
+    getProject(projectId: string): ProjectMeta | undefined;
+    listProjects(): ProjectMeta[];
+    upsertVisitor(visitorId: string, patch: {
+        userId?: string;
+        seenAt?: number;
+        incrementSession?: boolean;
+        addTabId?: string;
+        addProjectId?: string;
+        lastEnv?: VisitorEnv;
+    }): VisitorMeta;
+    getVisitor(visitorId: string): VisitorMeta | undefined;
+    listVisitors(opts?: {
+        projectId?: string;
+        limit?: number;
+    }): VisitorMeta[];
+    upsertBuild(projectId: string, buildId: string, patch: Partial<Omit<BuildMeta, 'id' | 'projectId'>>): BuildMeta;
+    getBuild(projectId: string, buildId: string): BuildMeta | undefined;
+    listBuilds(projectId: string, limit?: number): BuildMeta[];
+    getProjectTree(rootId?: string): ProjectTreeNode[];
+    tail(sessionId: string, opts?: TailOptions): StoreEvent[];
+    search(sessionId: string, query: string, opts?: SearchOptions): StoreEvent[];
+    listRecordings(sessionId: string): RecordingChunkSummary[];
+    sliceRecordings(sessionId: string, since: number, until: number): RecordingChunk[];
+    writeExport(input: {
+        sessionId: string;
+        tabId?: string;
+        since: number;
+        until: number;
+        label?: string;
+        events: unknown[];
+        startTs: number;
+        endTs: number;
+        chunkCount: number;
+    }): ReplayExportMeta;
+    getExport(exportId: string): ReplayExportMeta | undefined;
+    readExportEvents(exportId: string): unknown[] | undefined;
+    listExports(projectId: string, limit?: number): ReplayExportMeta[];
+    summary(sessionId: string): SessionSummary;
+    listNotes(projectId: string): Array<{
+        key: string;
+        value: string;
+        ts: number;
+    }>;
+    purge(policy?: RetentionPolicy): PurgeResult;
+    private pruneExports;
+    /**
+     * Flush all pending WriteQueue entries to disk. Used in tests.
+     */
+    flush(): Promise<void>;
+    close(): Promise<void>;
+    private pruneRecordingFile;
+    private readMarkerTimestamps;
+}
+/** Sanitize a string for use as a directory name. */
+export declare function sanitizeId(id: string): string;