pi-vault-mind 0.7.4 → 0.8.0

package/dist/test/rest-wiki.test.js

@@ -0,0 +1,161 @@
+import { strict as assert } from "node:assert";
+import * as fs from "node:fs";
+import * as http from "node:http";
+import * as path from "node:path";
+import { after, before, describe, it } from "node:test";
+import { _resetAuthCache } from "../src/auth.js";
+import { createServerState, startServer, stopServer } from "../src/server.js";
+import { createWatcherState } from "../src/watcher.js";
+const envVar = "PVM_API_TOKEN";
+const tmpVault = () => {
+    const p = path.join(process.cwd(), `.tmp-rest-wiki-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    if (fs.existsSync(p))
+        fs.rmSync(p, { recursive: true });
+    fs.mkdirSync(p, { recursive: true });
+    return p;
+};
+const fetchJson = (port, method, path, body, token) => new Promise((resolve, reject) => {
+    const opts = {
+        hostname: "127.0.0.1",
+        port,
+        path,
+        method,
+        headers: {
+            "Content-Type": "application/json",
+            ...(token ? { Authorization: `Bearer ${token}` } : {}),
+        },
+    };
+    const req = http.request(opts, (res) => {
+        let raw = "";
+        res.on("data", (chunk) => {
+            raw += chunk.toString();
+        });
+        res.on("end", () => {
+            try {
+                resolve({ status: res.statusCode ?? 0, data: JSON.parse(raw) });
+            }
+            catch {
+                resolve({ status: res.statusCode ?? 0, data: raw });
+            }
+        });
+    });
+    req.on("error", reject);
+    if (body !== undefined)
+        req.write(JSON.stringify(body));
+    req.end();
+});
+describe("REST wiki routes", () => {
+    let vaultPath;
+    let port;
+    let serverState;
+    let watcherState;
+    let savedEnv;
+    let savedHome;
+    const fakePi = {
+        sendUserMessage: () => { },
+        events: { emit: () => { } },
+    };
+    before(async () => {
+        savedEnv = process.env[envVar];
+        savedHome = process.env.HOME;
+        process.env[envVar] = "test-token";
+        vaultPath = tmpVault();
+        process.env.HOME = vaultPath;
+        // Create a minimal vault config so loadConfig works
+        fs.writeFileSync(path.join(vaultPath, "pi-vault-mind.config.json"), JSON.stringify({
+            version: 2,
+            collections: {
+                main: {
+                    path: "collections/main.jsonl",
+                    schema: ["id", "domain", "source", "fact", "tag", "artifact"],
+                    dedupField: "fact",
+                },
+            },
+            wiki: { dataDir: ".lancedb", embedding: { provider: "transformers" }, ftsEnabled: true },
+        }), "utf-8");
+        // Create the collection file
+        fs.mkdirSync(path.join(vaultPath, "collections"), { recursive: true });
+        fs.writeFileSync(path.join(vaultPath, "collections", "main.jsonl"), "", "utf-8");
+        // Create a global config pointing to this vault
+        fs.mkdirSync(path.join(vaultPath, ".pi", "agent"), { recursive: true });
+        fs.writeFileSync(path.join(vaultPath, ".pi", "agent", "vault-mind.config.json"), JSON.stringify({ wiki: { vaults: { default: { path: vaultPath } } } }), "utf-8");
+        serverState = createServerState(0);
+        watcherState = createWatcherState();
+        startServer(fakePi, serverState, watcherState);
+        // Wait for the server to be ready (port 0 means OS assigns a random port)
+        await new Promise((resolve) => {
+            const check = () => {
+                if (serverState.server?.listening)
+                    resolve();
+                else
+                    setTimeout(check, 10);
+            };
+            check();
+        });
+        port = serverState.port;
+    });
+    after(() => {
+        stopServer(serverState);
+        if (savedEnv === undefined)
+            delete process.env[envVar];
+        else
+            process.env[envVar] = savedEnv;
+        if (savedHome === undefined)
+            process.env.HOME = undefined;
+        else
+            process.env.HOME = savedHome;
+        if (fs.existsSync(vaultPath))
+            fs.rmSync(vaultPath, { recursive: true });
+        _resetAuthCache();
+    });
+    it("POST /wiki/search returns 401 without token", async () => {
+        const { status } = await fetchJson(port, "POST", "/wiki/search", { query: "test" });
+        assert.equal(status, 401);
+    });
+    it("POST /wiki/search returns 200 or 500 with valid token (index may not be built)", async () => {
+        const { status, data } = await fetchJson(port, "POST", "/wiki/search", { query: "test" }, "test-token");
+        // 200 if index exists, 500 if LanceDB table not initialized — both are valid responses
+        assert.ok(status === 200 || status === 500, `expected 200 or 500, got ${status}`);
+        if (status === 200) {
+            const d = data;
+            assert.ok(Array.isArray(d.hits));
+        }
+    });
+    it("POST /wiki/search returns 400 when query is missing", async () => {
+        const { status } = await fetchJson(port, "POST", "/wiki/search", {}, "test-token");
+        assert.equal(status, 400);
+    });
+    it("POST /wiki/search respects collection and limit params", async () => {
+        const { status } = await fetchJson(port, "POST", "/wiki/search", { collection: "main", query: "test", limit: 3 }, "test-token");
+        assert.ok(status === 200 || status === 500, `expected 200 or 500, got ${status}`);
+    });
+    it("POST /wiki/append returns 401 without token", async () => {
+        const { status } = await fetchJson(port, "POST", "/wiki/append", {
+            collection: "main",
+            entry: { id: "1", fact: "hello" },
+        });
+        assert.equal(status, 401);
+    });
+    it("POST /wiki/append returns 200 or 500 with valid token (index may not be built)", async () => {
+        const { status } = await fetchJson(port, "POST", "/wiki/append", {
+            collection: "main",
+            mode: "autopilot",
+            entry: { id: "test-1", domain: "test", source: "test", fact: "hello world", tag: "test" },
+        }, "test-token");
+        assert.ok(status === 200 || status === 500, `expected 200 or 500, got ${status}`);
+    });
+    it("POST /wiki/append returns 400 for unknown collection", async () => {
+        const { status } = await fetchJson(port, "POST", "/wiki/append", { collection: "nonexistent", entry: { id: "1", fact: "x" } }, "test-token");
+        assert.equal(status, 400);
+    });
+    it("POST /wiki/append returns 400 when entry is missing", async () => {
+        const { status } = await fetchJson(port, "POST", "/wiki/append", { collection: "main" }, "test-token");
+        assert.equal(status, 400);
+    });
+    it("POST /wiki/search and /wiki/append both require POST method", async () => {
+        const s1 = await fetchJson(port, "GET", "/wiki/search", undefined, "test-token");
+        const s2 = await fetchJson(port, "GET", "/wiki/append", undefined, "test-token");
+        assert.equal(s1.status, 405);
+        assert.equal(s2.status, 405);
+    });
+});

package/dist/test/server-ws.test.js

@@ -0,0 +1,219 @@
+import { strict as assert } from "node:assert";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import { WebSocket } from "ws";
+import { createJob, markJobDone, markJobRunning } from "../src/agent-queue.js";
+import { _resetAuthCache } from "../src/auth.js";
+import { createServerState, startServer, stopServer } from "../src/server.js";
+import { createWatcherState } from "../src/watcher.js";
+const envVar = "PVM_API_TOKEN";
+const tmpVault = () => {
+    const p = path.join(process.cwd(), `.tmp-ws-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    if (fs.existsSync(p))
+        fs.rmSync(p, { recursive: true });
+    fs.mkdirSync(p, { recursive: true });
+    return p;
+};
+const waitForOpen = (ws, timeoutMs = 5000) => new Promise((resolve, reject) => {
+    if (ws.readyState === ws.OPEN)
+        return resolve();
+    const timer = setTimeout(() => reject(new Error("ws open timeout")), timeoutMs);
+    ws.on("open", () => {
+        clearTimeout(timer);
+        resolve();
+    });
+    ws.on("error", () => {
+        clearTimeout(timer);
+        reject(new Error("ws open error"));
+    });
+});
+const waitForClose = (ws, timeoutMs = 5000) => new Promise((resolve, reject) => {
+    if (ws.readyState === ws.CLOSED)
+        return resolve(0);
+    const timer = setTimeout(() => reject(new Error("ws close timeout")), timeoutMs);
+    ws.on("close", (code) => {
+        clearTimeout(timer);
+        resolve(code);
+    });
+    ws.on("error", () => {
+        clearTimeout(timer);
+        reject(new Error("ws close error"));
+    });
+});
+const collectEvents = (ws, count, timeoutMs = 5000) => new Promise((resolve, reject) => {
+    const events = [];
+    const timer = setTimeout(() => {
+        if (events.length >= count)
+            resolve(events);
+        else
+            reject(new Error(`expected ${count} events, got ${events.length}: ${JSON.stringify(events)}`));
+    }, timeoutMs);
+    ws.on("message", (data) => {
+        try {
+            events.push(JSON.parse(data.toString()));
+        }
+        catch {
+            events.push(data.toString());
+        }
+        if (events.length >= count) {
+            clearTimeout(timer);
+            resolve(events);
+        }
+    });
+});
+const connect = (port, token) => {
+    return new WebSocket(`ws://127.0.0.1:${port}/agent/stream`, {
+        headers: token ? { Authorization: `Bearer ${token}` } : undefined,
+    });
+};
+describe("WebSocket /agent/stream", () => {
+    let vaultPath;
+    let serverState;
+    let watcherState;
+    let port;
+    let savedEnv;
+    let savedHome;
+    beforeEach(async () => {
+        savedEnv = process.env[envVar];
+        savedHome = process.env.HOME;
+        vaultPath = tmpVault();
+        process.env.HOME = vaultPath;
+        process.env[envVar] = "ws-test-token";
+        _resetAuthCache();
+        fs.mkdirSync(path.join(vaultPath, ".pi", "agent"), { recursive: true });
+        fs.writeFileSync(path.join(vaultPath, ".pi", "agent", "vault-mind.config.json"), JSON.stringify({
+            wiki: {
+                vaults: { default: { path: vaultPath } },
+                embedding: { modal: { apiToken: "ws-test-token" } },
+            },
+        }), "utf-8");
+        watcherState = createWatcherState();
+        serverState = createServerState(0);
+        startServer({}, serverState, watcherState);
+        await new Promise((resolve, reject) => {
+            const srv = serverState.server;
+            if (!srv)
+                return reject(new Error("server not created"));
+            if (srv.listening) {
+                const addr = srv.address();
+                port = typeof addr === "object" && addr ? addr.port : 0;
+                return resolve();
+            }
+            srv.once("listening", () => {
+                const addr = srv.address();
+                port = typeof addr === "object" && addr ? addr.port : 0;
+                resolve();
+            });
+            srv.once("error", reject);
+        });
+    });
+    afterEach(async () => {
+        stopServer(serverState);
+        if (savedEnv === undefined)
+            process.env[envVar] = undefined;
+        else
+            process.env[envVar] = savedEnv;
+        if (savedHome === undefined)
+            process.env.HOME = undefined;
+        else
+            process.env.HOME = savedHome;
+        if (fs.existsSync(vaultPath))
+            fs.rmSync(vaultPath, { recursive: true });
+        _resetAuthCache();
+        // allow sockets to close cleanly between tests
+        await new Promise((r) => setTimeout(r, 50));
+    });
+    it("rejects connection with 4401 when no token is sent", async () => {
+        const ws = connect(port);
+        await waitForOpen(ws);
+        const code = await waitForClose(ws);
+        assert.equal(code, 4401);
+    });
+    it("receives queue/snapshot on connect", async () => {
+        createJob(vaultPath, {
+            id: "j1",
+            vaultPath,
+            filePath: path.join(vaultPath, "test.md"),
+            role: "miner",
+            agentName: "vault-mind-miner",
+            instruction: "test",
+            markerCount: 1,
+        });
+        const ws = connect(port, "ws-test-token");
+        const eventsPromise = collectEvents(ws, 1);
+        await waitForOpen(ws);
+        const events = await eventsPromise;
+        ws.close();
+        assert.equal(events.length, 1);
+        const snap = events[0];
+        assert.equal(snap.type, "queue/snapshot");
+        assert.equal(snap.jobs.length, 1);
+        assert.equal(snap.jobs[0].id, "j1");
+    });
+    it("receives job-created event after creating a job", async () => {
+        const ws = connect(port, "ws-test-token");
+        const eventsPromise = collectEvents(ws, 1);
+        await waitForOpen(ws);
+        await eventsPromise; // drain snapshot
+        createJob(vaultPath, {
+            id: "j2",
+            vaultPath,
+            filePath: path.join(vaultPath, "test.md"),
+            role: "miner",
+            agentName: "vault-mind-miner",
+            instruction: "test",
+            markerCount: 1,
+        });
+        const events = await collectEvents(ws, 1);
+        ws.close();
+        assert.equal(events.length, 1);
+        const ev = events[0];
+        assert.equal(ev.type, "job-created");
+        assert.equal(ev.job.id, "j2");
+    });
+    it("receives job-updated and job-completed events", async () => {
+        createJob(vaultPath, {
+            id: "j3",
+            vaultPath,
+            filePath: path.join(vaultPath, "test.md"),
+            role: "miner",
+            agentName: "vault-mind-miner",
+            instruction: "test",
+            markerCount: 1,
+        });
+        const ws = connect(port, "ws-test-token");
+        const eventsPromise = collectEvents(ws, 1);
+        await waitForOpen(ws);
+        await eventsPromise; // drain snapshot
+        markJobRunning(vaultPath, "j3");
+        markJobDone(vaultPath, "j3");
+        const events = await collectEvents(ws, 2);
+        ws.close();
+        const types = events.map((e) => e.type);
+        assert.deepEqual(types, ["job-updated", "job-completed"]);
+    });
+    it("unsubscribes on close and does not receive further events", async () => {
+        const ws = connect(port, "ws-test-token");
+        const eventsPromise = collectEvents(ws, 1);
+        await waitForOpen(ws);
+        await eventsPromise; // drain snapshot
+        ws.close();
+        await waitForClose(ws);
+        createJob(vaultPath, {
+            id: "j4",
+            vaultPath,
+            filePath: path.join(vaultPath, "test.md"),
+            role: "miner",
+            agentName: "vault-mind-miner",
+            instruction: "test",
+            markerCount: 1,
+        });
+        let leaked = false;
+        ws.on("message", () => {
+            leaked = true;
+        });
+        await new Promise((r) => setTimeout(r, 500));
+        assert.equal(leaked, false);
+    });
+});

package/dist/test/tombstone.test.js

@@ -0,0 +1,233 @@
+import { strict as assert } from "node:assert";
+import { randomUUID } from "node:crypto";
+import * as fs from "node:fs";
+import { tmpdir } from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, it } from "node:test";
+const setupConfig = (dir) => {
+    fs.writeFileSync(path.join(dir, "pi-vault-mind.config.json"), JSON.stringify({
+        version: 2,
+        collections: {
+            main: {
+                path: "collections/main.jsonl",
+                schema: ["id", "domain", "source", "fact", "tag", "artifact"],
+                dedupField: "fact",
+            },
+        },
+        injectors: [],
+        wiki: {
+            dataDir: ".lancedb",
+            embedding: { provider: "transformers" },
+            ftsEnabled: false,
+            graph: { enabled: false },
+        },
+    }), "utf-8");
+    fs.mkdirSync(path.join(dir, "collections"), { recursive: true });
+};
+describe("tombstone_entry", () => {
+    let testDir;
+    let collectionPath;
+    let savedHome;
+    beforeEach(() => {
+        testDir = path.join(tmpdir(), `pi-vault-mind-tombstone-test-${randomUUID()}`);
+        fs.mkdirSync(testDir, { recursive: true });
+        setupConfig(testDir);
+        collectionPath = path.join(testDir, "collections", "main.jsonl");
+        savedHome = process.env.HOME;
+        process.env.HOME = testDir;
+        process.env.USERPROFILE = testDir;
+    });
+    afterEach(() => {
+        if (savedHome !== undefined)
+            process.env.HOME = savedHome;
+        else
+            process.env.HOME = undefined;
+        if (fs.existsSync(testDir))
+            fs.rmSync(testDir, { recursive: true });
+    });
+    it("replaces an entry with a tombstone at the same line position", async () => {
+        const { tombstoneEntryById } = await import("../src/tombstone.js");
+        fs.writeFileSync(collectionPath, `${[
+            JSON.stringify({
+                id: "a",
+                domain: "auth",
+                source: "x",
+                fact: "first",
+                tag: "test",
+                artifact: "",
+            }),
+            JSON.stringify({
+                id: "b",
+                domain: "api",
+                source: "y",
+                fact: "second",
+                tag: "test",
+                artifact: "",
+            }),
+            JSON.stringify({
+                id: "c",
+                domain: "ui",
+                source: "z",
+                fact: "third",
+                tag: "test",
+                artifact: "",
+            }),
+            "",
+        ].join("\n")}\n`, "utf-8");
+        const result = tombstoneEntryById(collectionPath, "b");
+        assert.equal(result.success, true);
+        assert.equal(result.lineIndex, 1);
+        const lines = fs.readFileSync(collectionPath, "utf-8").trimEnd().split("\n");
+        assert.equal(lines.length, 3);
+        assert.deepEqual(JSON.parse(lines[0]), {
+            id: "a",
+            domain: "auth",
+            source: "x",
+            fact: "first",
+            tag: "test",
+            artifact: "",
+        });
+        const tombstone = JSON.parse(lines[1]);
+        assert.equal(tombstone.id, "b");
+        assert.equal(tombstone.domain, "tombstone");
+        assert.equal(tombstone.source, "redaction");
+        assert.equal(tombstone.fact, "");
+        assert.equal(tombstone.tag, "tombstone");
+        assert.equal(tombstone.artifact, "");
+        assert.equal(tombstone.original_domain, "api");
+        assert.ok(typeof tombstone.tombstoned_at === "string");
+        assert.deepEqual(JSON.parse(lines[2]), {
+            id: "c",
+            domain: "ui",
+            source: "z",
+            fact: "third",
+            tag: "test",
+            artifact: "",
+        });
+    });
+    it("returns an error when the entry is not found", async () => {
+        const { tombstoneEntryById } = await import("../src/tombstone.js");
+        fs.writeFileSync(collectionPath, `${JSON.stringify({
+            id: "a",
+            domain: "auth",
+            source: "x",
+            fact: "first",
+            tag: "test",
+            artifact: "",
+        })}\n`, "utf-8");
+        const result = tombstoneEntryById(collectionPath, "missing");
+        assert.equal(result.success, false);
+        assert.ok(result.message.includes('"missing" not found'));
+        const lines = fs.readFileSync(collectionPath, "utf-8").trimEnd().split("\n");
+        assert.equal(lines.length, 1);
+        assert.equal(JSON.parse(lines[0]).id, "a");
+    });
+    it("returns an error when the collection file is missing", async () => {
+        const { tombstoneEntryById } = await import("../src/tombstone.js");
+        const missingPath = path.join(testDir, "collections", "missing.jsonl");
+        const result = tombstoneEntryById(missingPath, "a");
+        assert.equal(result.success, false);
+        assert.ok(result.message.includes("not found"));
+    });
+    it("preserves malformed and blank lines", async () => {
+        const { tombstoneEntryById } = await import("../src/tombstone.js");
+        fs.writeFileSync(collectionPath, `${[
+            JSON.stringify({
+                id: "a",
+                domain: "auth",
+                source: "x",
+                fact: "first",
+                tag: "test",
+                artifact: "",
+            }),
+            "not valid json",
+            "",
+            JSON.stringify({
+                id: "b",
+                domain: "api",
+                source: "y",
+                fact: "second",
+                tag: "test",
+                artifact: "",
+            }),
+        ].join("\n")}\n`, "utf-8");
+        const result = tombstoneEntryById(collectionPath, "b");
+        assert.equal(result.success, true);
+        assert.equal(result.lineIndex, 3);
+        const lines = fs.readFileSync(collectionPath, "utf-8").split("\n");
+        assert.equal(lines[0], JSON.stringify({
+            id: "a",
+            domain: "auth",
+            source: "x",
+            fact: "first",
+            tag: "test",
+            artifact: "",
+        }));
+        assert.equal(lines[1], "not valid json");
+        assert.equal(lines[2], "");
+        const tombstone = JSON.parse(lines[3]);
+        assert.equal(tombstone.id, "b");
+        assert.equal(tombstone.domain, "tombstone");
+        assert.equal(tombstone.original_domain, "api");
+    });
+    it("handles an entry without a domain field", async () => {
+        const { tombstoneEntryById } = await import("../src/tombstone.js");
+        fs.writeFileSync(collectionPath, `${JSON.stringify({ id: "a", source: "x", fact: "first", tag: "test", artifact: "" })}\n`, "utf-8");
+        const result = tombstoneEntryById(collectionPath, "a");
+        assert.equal(result.success, true);
+        const lines = fs.readFileSync(collectionPath, "utf-8").trimEnd().split("\n");
+        const tombstone = JSON.parse(lines[0]);
+        assert.equal(tombstone.original_domain, "");
+    });
+    it("registerTombstoneTool registers the pi tool", async () => {
+        const { registerTombstoneTool } = await import("../src/tombstone.js");
+        const registered = [];
+        const fakePi = {
+            registerTool: (tool) => registered.push({ name: tool.name, parameters: tool.parameters }),
+        };
+        registerTombstoneTool(fakePi);
+        assert.equal(registered.length, 1);
+        assert.equal(registered[0].name, "tombstone_entry");
+        assert.ok(registered[0].parameters);
+    });
+    it("tool execute tombstones an entry via collection config", async () => {
+        const { registerTombstoneTool } = await import("../src/tombstone.js");
+        let capturedTool;
+        const fakePi = {
+            registerTool: (tool) => {
+                capturedTool = tool;
+            },
+        };
+        registerTombstoneTool(fakePi);
+        fs.writeFileSync(collectionPath, `${JSON.stringify({
+            id: "target",
+            domain: "api",
+            source: "y",
+            fact: "second",
+            tag: "test",
+            artifact: "",
+        })}\n`, "utf-8");
+        const result = await capturedTool.execute("tool-id", { collection: "main", entryId: "target" }, undefined, undefined, { cwd: testDir });
+        assert.ok(result.content[0].text.includes('Tombstoned entry "target"'));
+        assert.equal(result.details.success, true);
+        assert.equal(result.details.lineIndex, 0);
+        assert.ok(result.details.tombstonedAt);
+        const lines = fs.readFileSync(collectionPath, "utf-8").trimEnd().split("\n");
+        const tombstone = JSON.parse(lines[0]);
+        assert.equal(tombstone.id, "target");
+        assert.equal(tombstone.domain, "tombstone");
+    });
+    it("tool execute returns an error for an unknown collection", async () => {
+        const { registerTombstoneTool } = await import("../src/tombstone.js");
+        let capturedTool;
+        const fakePi = {
+            registerTool: (tool) => {
+                capturedTool = tool;
+            },
+        };
+        registerTombstoneTool(fakePi);
+        const result = await capturedTool.execute("tool-id", { collection: "unknown", entryId: "target" }, undefined, undefined, { cwd: testDir });
+        assert.ok(result.content[0].text.includes('Unknown collection "unknown"'));
+        assert.deepEqual(result.details, {});
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-vault-mind",
-  "version": "0.7.4",
+  "version": "0.8.0",
   "description": "Passive Obsidian vault extension for pi. Watches @agent markers, dispatches forked subagents (Miner, Broadcaster, Heavy-Lifter), stores in LanceDB with vector + FTS + graph. Multi-agent 'Drop & Forget' workflow for the pi agent ecosystem.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -8,6 +8,7 @@
   "files": [
     "dist",
     "skills",
+    "scripts",
     "CHANGELOG.md",
     "README.md",
     "LICENSE"
@@ -60,7 +61,8 @@
   "dependencies": {
     "@lancedb/lancedb": "latest",
     "@xenova/transformers": "latest",
-    "apache-arrow": "^21.1.0"
+    "apache-arrow": "^21.1.0",
+    "ws": "^8.21.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": ">=0.75.0 <1.0.0"
@@ -70,6 +72,7 @@
     "@earendil-works/pi-coding-agent": "^0.79.0",
     "@earendil-works/pi-tui": "^0.79.0",
     "@types/node": "^20.0.0",
+    "@types/ws": "^8.18.1",
     "husky": "^9.1.6",
     "typebox": "^1.1.0",
     "typescript": "^5.0.0"
@@ -79,6 +82,7 @@
     "build": "tsc && tsc -p tsconfig.test.json",
     "dev": "tsc --watch",
     "test": "node --test dist/test/*.test.js",
+    "e2e:ws": "node scripts/e2e-ws.mjs",
     "e2e:modal": "node scripts/modal-e2e-smoke.mjs"
   }
 }