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

package/src/store/JsonMemoryStore.ts

@@ -1,128 +0,0 @@
-/**
- * JsonMemoryStore — JSON-based persistence for agent memory (key-value store per project).
- *
- * File layout:
- *   {dataDir}/{projectId}/memory.json
- *
- * File format:
- *   {
- *     "key1": { "key": "key1", "value": "...", "updatedAt": 1700000000000 },
- *     "key2": { "key": "key2", "value": "...", "updatedAt": 1700000001000 }
- *   }
- *
- * All mutations use atomic write-then-rename for durability.
- */
-
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import type { IMemoryStore, MemoryEntry } from './types.js';
-import { sanitizeId } from './JsonlStore.js';
-
-export class JsonMemoryStore implements IMemoryStore {
-    constructor(private readonly dataDir: string) {}
-
-    // ── Path helpers ──────────────────────────────────────────────────────
-
-    private memoryPath(projectId: string): string {
-        return join(this.dataDir, sanitizeId(projectId), 'memory.json');
-    }
-
-    // ── Private I/O ───────────────────────────────────────────────────────
-
-    /**
-     * Read and parse memory.json for a project.
-     * Returns a null-prototype object on missing or corrupt file (never throws).
-     * Using Object.create(null) prevents prototype pollution from keys like __proto__.
-     */
-    private load(projectId: string): Record<string, MemoryEntry> {
-        const path = this.memoryPath(projectId);
-        try {
-            const raw = readFileSync(path, 'utf-8');
-            const parsed = JSON.parse(raw) as Record<string, MemoryEntry>;
-            // Copy into a null-prototype object to prevent prototype pollution
-            const safe: Record<string, MemoryEntry> = Object.create(null);
-            for (const key of Object.keys(parsed)) {
-                safe[key] = parsed[key];
-            }
-            return safe;
-        } catch {
-            return Object.create(null);
-        }
-    }
-
-    /**
-     * Atomically write memory data to disk using tmp + rename strategy.
-     * Logs error on failure without throwing.
-     */
-    private save(projectId: string, data: Record<string, MemoryEntry>): void {
-        const path = this.memoryPath(projectId);
-        const tmpPath = `${path}.tmp`;
-
-        // Ensure the project directory exists
-        const dir = join(this.dataDir, sanitizeId(projectId));
-        try {
-            mkdirSync(dir, { recursive: true });
-        } catch (err) {
-            console.error(`[JsonMemoryStore] failed to create directory ${dir}:`, err);
-            return;
-        }
-
-        try {
-            writeFileSync(tmpPath, JSON.stringify(data, null, 2), 'utf-8');
-            renameSync(tmpPath, path);
-        } catch (err) {
-            console.error(`[JsonMemoryStore] failed to write ${path}:`, err);
-        }
-    }
-
-    // ── IMemoryStore implementation ───────────────────────────────────────
-
-    /**
-     * Get a memory entry by key.
-     * Returns undefined if the key does not exist or memory.json is missing.
-     */
-    get(projectId: string, key: string): MemoryEntry | undefined {
-        const data = this.load(projectId);
-        return data[key];
-    }
-
-    /**
-     * Write or update a memory entry.
-     * Sets updatedAt to the current Unix ms timestamp.
-     * Returns the new/updated MemoryEntry.
-     */
-    set(projectId: string, key: string, value: string): MemoryEntry {
-        const data = this.load(projectId);
-        const entry: MemoryEntry = {
-            key,
-            value,
-            updatedAt: Date.now(),
-        };
-        data[key] = entry;
-        this.save(projectId, data);
-        return entry;
-    }
-
-    /**
-     * Delete a memory entry by key.
-     * Returns true if the key existed and was removed, false otherwise.
-     */
-    delete(projectId: string, key: string): boolean {
-        const data = this.load(projectId);
-        if (!(key in data)) {
-            return false;
-        }
-        delete data[key];
-        this.save(projectId, data);
-        return true;
-    }
-
-    /**
-     * List all memory entries for a project, sorted by updatedAt descending.
-     * Returns an empty array if memory.json does not exist.
-     */
-    list(projectId: string): MemoryEntry[] {
-        const data = this.load(projectId);
-        return Object.values(data).sort((a, b) => b.updatedAt - a.updatedAt);
-    }
-}

package/src/store/JsonTaskStore.test.ts

@@ -1,212 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { existsSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { JsonTaskStore } from './JsonTaskStore.js';
-import type { Task } from '@harness-fe/protocol';
-
-function makeTempDir() {
-    return mkdtempSync(join(tmpdir(), 'json-task-store-test-'));
-}
-
-function cleanup(dir: string) {
-    try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
-}
-
-function makeTask(overrides: Partial<Task> = {}): Task {
-    return {
-        id: 'task-1',
-        tabId: 'tab-abc',
-        projectId: 'proj',
-        url: 'http://localhost:5173',
-        status: 'pending',
-        question: 'What does this button do?',
-        selector: { css: '#submit-btn' },
-        element: { outerHTML: '<button id="submit-btn">Submit</button>', rect: { x: 0, y: 0, width: 100, height: 40 } },
-        createdAt: Date.now(),
-        ...overrides,
-    };
-}
-
-describe('JsonTaskStore', () => {
-    let dir: string;
-    let store: JsonTaskStore;
-
-    beforeEach(() => {
-        dir = makeTempDir();
-        store = new JsonTaskStore(dir);
-    });
-
-    afterEach(() => {
-        cleanup(dir);
-    });
-
-    // ── Load from missing file → empty array ─────────────────────────────
-
-    it('returns empty array when tasks.json does not exist', () => {
-        const tasks = store.loadTasks('proj');
-        expect(tasks).toEqual([]);
-    });
-
-    it('returns empty array for a project that has never been saved', () => {
-        const tasks = store.loadTasks('brand-new-project');
-        expect(tasks).toEqual([]);
-    });
-
-    // ── Load from corrupt JSON → empty array ─────────────────────────────
-
-    it('returns empty array when tasks.json contains invalid JSON', () => {
-        // Manually create the project directory and write corrupt JSON
-        const { mkdirSync } = require('node:fs');
-        const projDir = join(dir, 'proj');
-        mkdirSync(projDir, { recursive: true });
-        writeFileSync(join(projDir, 'tasks.json'), '{ this is not valid json !!!', 'utf-8');
-
-        const tasks = store.loadTasks('proj');
-        expect(tasks).toEqual([]);
-    });
-
-    it('returns empty array when tasks.json has valid JSON but wrong shape (no tasks array)', () => {
-        const { mkdirSync } = require('node:fs');
-        const projDir = join(dir, 'proj');
-        mkdirSync(projDir, { recursive: true });
-        writeFileSync(join(projDir, 'tasks.json'), JSON.stringify({ version: 1, data: [] }), 'utf-8');
-
-        const tasks = store.loadTasks('proj');
-        expect(tasks).toEqual([]);
-    });
-
-    it('returns empty array when tasks.json is empty', () => {
-        const { mkdirSync } = require('node:fs');
-        const projDir = join(dir, 'proj');
-        mkdirSync(projDir, { recursive: true });
-        writeFileSync(join(projDir, 'tasks.json'), '', 'utf-8');
-
-        const tasks = store.loadTasks('proj');
-        expect(tasks).toEqual([]);
-    });
-
-    // ── Save tasks → atomic write (tmp + rename) ─────────────────────────
-
-    it('saves tasks and the file exists afterwards', () => {
-        const tasks = [makeTask()];
-        store.saveTasks('proj', tasks);
-
-        const tasksPath = join(dir, 'proj', 'tasks.json');
-        expect(existsSync(tasksPath)).toBe(true);
-    });
-
-    it('saves tasks and no .tmp file remains after save', () => {
-        const tasks = [makeTask()];
-        store.saveTasks('proj', tasks);
-
-        const tmpPath = join(dir, 'proj', 'tasks.json.tmp');
-        expect(existsSync(tmpPath)).toBe(false);
-    });
-
-    it('saved file contains the correct JSON structure', () => {
-        const { readFileSync } = require('node:fs');
-        const tasks = [makeTask({ id: 'task-abc' })];
-        store.saveTasks('proj', tasks);
-
-        const raw = readFileSync(join(dir, 'proj', 'tasks.json'), 'utf-8');
-        const parsed = JSON.parse(raw);
-        expect(parsed.version).toBe(1);
-        expect(Array.isArray(parsed.tasks)).toBe(true);
-        expect(parsed.tasks).toHaveLength(1);
-        expect(parsed.tasks[0].id).toBe('task-abc');
-    });
-
-    it('creates the project directory if it does not exist', () => {
-        const tasks = [makeTask()];
-        store.saveTasks('new-project', tasks);
-
-        const projDir = join(dir, 'new-project');
-        expect(existsSync(projDir)).toBe(true);
-    });
-
-    // ── Round-trip: save then load ────────────────────────────────────────
-
-    it('round-trip: saved tasks can be loaded back and match the original', () => {
-        const tasks: Task[] = [
-            makeTask({ id: 'task-1', status: 'pending' }),
-            makeTask({ id: 'task-2', status: 'claimed', claimedAt: Date.now() }),
-            makeTask({ id: 'task-3', status: 'resolved', resolvedAt: Date.now(), note: 'Done!' }),
-        ];
-
-        store.saveTasks('proj', tasks);
-        const loaded = store.loadTasks('proj');
-
-        expect(loaded).toHaveLength(3);
-        expect(loaded[0].id).toBe('task-1');
-        expect(loaded[1].id).toBe('task-2');
-        expect(loaded[2].id).toBe('task-3');
-        expect(loaded[2].note).toBe('Done!');
-    });
-
-    it('round-trip: saving an empty array and loading returns empty array', () => {
-        store.saveTasks('proj', []);
-        const loaded = store.loadTasks('proj');
-        expect(loaded).toEqual([]);
-    });
-
-    it('round-trip: overwriting tasks replaces the previous data', () => {
-        const initial = [makeTask({ id: 'task-1' }), makeTask({ id: 'task-2' })];
-        store.saveTasks('proj', initial);
-
-        const updated = [makeTask({ id: 'task-3' })];
-        store.saveTasks('proj', updated);
-
-        const loaded = store.loadTasks('proj');
-        expect(loaded).toHaveLength(1);
-        expect(loaded[0].id).toBe('task-3');
-    });
-
-    it('round-trip: multiple saves preserve the last written state', () => {
-        for (let i = 0; i < 5; i++) {
-            store.saveTasks('proj', [makeTask({ id: `task-${i}` })]);
-        }
-
-        const loaded = store.loadTasks('proj');
-        expect(loaded).toHaveLength(1);
-        expect(loaded[0].id).toBe('task-4');
-    });
-
-    // ── Purge does not delete tasks.json ─────────────────────────────────
-    // JsonTaskStore has no purge method — verify that saveTasks/loadTasks
-    // continue to work correctly after multiple saves (simulating what purge
-    // would need to preserve).
-
-    it('tasks.json is preserved across multiple save operations', () => {
-        const tasks = [makeTask({ id: 'task-keep' })];
-        store.saveTasks('proj', tasks);
-
-        // Simulate additional saves (as would happen during normal operation)
-        store.saveTasks('proj', [...tasks, makeTask({ id: 'task-new' })]);
-
-        const tasksPath = join(dir, 'proj', 'tasks.json');
-        expect(existsSync(tasksPath)).toBe(true);
-
-        const loaded = store.loadTasks('proj');
-        expect(loaded).toHaveLength(2);
-        expect(loaded.map((t) => t.id)).toContain('task-keep');
-        expect(loaded.map((t) => t.id)).toContain('task-new');
-    });
-
-    it('tasks.json is not affected by operations on other projects', () => {
-        const projATasks = [makeTask({ id: 'task-a', projectId: 'proj-a' })];
-        const projBTasks = [makeTask({ id: 'task-b', projectId: 'proj-b' })];
-
-        store.saveTasks('proj-a', projATasks);
-        store.saveTasks('proj-b', projBTasks);
-
-        // Loading proj-a should not be affected by proj-b
-        const loadedA = store.loadTasks('proj-a');
-        expect(loadedA).toHaveLength(1);
-        expect(loadedA[0].id).toBe('task-a');
-
-        const loadedB = store.loadTasks('proj-b');
-        expect(loadedB).toHaveLength(1);
-        expect(loadedB[0].id).toBe('task-b');
-    });
-});

package/src/store/JsonTaskStore.ts

@@ -1,59 +0,0 @@
-/**
- * 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 type { Task } from '@harness-fe/protocol';
-import type { ITaskStore } from './types.js';
-import { sanitizeId } from './JsonlStore.js';
-
-interface TasksFile {
-    version: number;
-    tasks: Task[];
-}
-
-export class JsonTaskStore implements ITaskStore {
-    constructor(private readonly dataDir: string) {}
-
-    private tasksPath(projectId: string): string {
-        return join(this.dataDir, sanitizeId(projectId), 'tasks.json');
-    }
-
-    loadTasks(projectId: string): Task[] {
-        const path = this.tasksPath(projectId);
-        if (!existsSync(path)) return [];
-        try {
-            const raw = readFileSync(path, 'utf-8');
-            const parsed = JSON.parse(raw) as TasksFile;
-            if (!Array.isArray(parsed?.tasks)) return [];
-            return parsed.tasks;
-        } catch {
-            return [];
-        }
-    }
-
-    saveTasks(projectId: string, tasks: Task[]): void {
-        const path = this.tasksPath(projectId);
-        const dir = join(this.dataDir, sanitizeId(projectId));
-
-        try {
-            mkdirSync(dir, { recursive: true });
-            const tmp = `${path}.tmp`;
-            const data: TasksFile = { 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);
-        }
-    }
-}