feat: add VECTOR_MEMORY_DATA_DIR env var + MCP integration tests

- Add VECTOR_MEMORY_DATA_DIR env var to vector-memory-server.js and index.js
  for overriding the data directory (default: ~/.copilot/)
- Add test-integration.js with 7 end-to-end tests that spawn the full MCP
  STDIO proxy, perform the JSON-RPC handshake, and exercise all tools
- Tests use temp directory via VECTOR_MEMORY_DATA_DIR + random port to
  avoid touching real data or conflicting with running servers
- Add npm run test:integration script

Refs #5

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: BrainSlugs83

index.js

@@ -11,7 +11,7 @@ import { request } from "http";
 import { userInfo } from "os";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const COPILOT_DIR = join(homedir(), ".copilot");
+const COPILOT_DIR = process.env.VECTOR_MEMORY_DATA_DIR || join(homedir(), ".copilot");
 const EXPECTED_USER = userInfo().username;
 const PKG = JSON.parse(readFileSync(join(__dirname, "package.json"), "utf-8"));
 

package.json

@@ -53,7 +53,8 @@
   "scripts": {
     "lint": "eslint index.js vector-memory-server.js embed-worker.js embed-pool.js lib.js",
     "test": "node --test test.js",
-    "test:coverage": "node --test --experimental-test-coverage --test-coverage-lines=100 --test-coverage-branches=100 --test-coverage-functions=100 --test-coverage-exclude=test.js test.js",
+    "test:integration": "node --test test-integration.js",
+    "test:coverage": "node --test --experimental-test-coverage --test-coverage-lines=100 --test-coverage-branches=100 --test-coverage-functions=100 --test-coverage-exclude=test.js --test-coverage-exclude=test-integration.js test.js",
     "check": "npm run lint && npm run test:coverage"
   },
   "dependencies": {

test-integration.js

@@ -0,0 +1,261 @@
+/**
+ * Integration tests for the MCP STDIO proxy + HTTP server pipeline.
+ *
+ * Spawns index.js (the proxy), which spawns vector-memory-server.js (the
+ * HTTP server) on first tool call. All data goes to a temp directory via
+ * VECTOR_MEMORY_DATA_DIR, leaving the real ~/.copilot/ untouched.
+ *
+ * Refs #5
+ */
+
+import { describe, it, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { spawn } from "node:child_process";
+import { mkdtempSync, rmSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { dirname } from "node:path";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const INDEX_JS = join(__dirname, "index.js");
+
+// --- MCP JSON-RPC helpers ---
+
+let msgId = 0;
+
+function jsonrpc(method, params = {}) {
+  return JSON.stringify({ jsonrpc: "2.0", id: ++msgId, method, params });
+}
+
+function notification(method, params = {}) {
+  return JSON.stringify({ jsonrpc: "2.0", method, params });
+}
+
+/**
+ * Spawns the MCP proxy, performs the initialize handshake, and returns
+ * a helper object for sending tool calls and reading responses.
+ */
+function createMcpClient(env = {}) {
+  const child = spawn(process.execPath, [INDEX_JS], {
+    stdio: ["pipe", "pipe", "pipe"],
+    env: { ...process.env, ...env },
+    windowsHide: true,
+  });
+
+  let buffer = "";
+  const pending = new Map();
+
+  child.stdout.on("data", (chunk) => {
+    buffer += chunk.toString();
+    // MCP messages are newline-delimited JSON
+    let nl;
+    while ((nl = buffer.indexOf("\n")) !== -1) {
+      const line = buffer.slice(0, nl).trim();
+      buffer = buffer.slice(nl + 1);
+      if (!line) continue;
+      try {
+        const msg = JSON.parse(line);
+        if (msg.id != null && pending.has(msg.id)) {
+          pending.get(msg.id)(msg);
+          pending.delete(msg.id);
+        }
+      } catch { /* ignore non-JSON lines */ }
+    }
+  });
+
+  function send(text) {
+    child.stdin.write(text + "\n");
+  }
+
+  function request(method, params = {}, timeoutMs = 120_000) {
+    const id = ++msgId;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        pending.delete(id);
+        reject(new Error(`MCP request "${method}" (id=${id}) timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+
+      pending.set(id, (msg) => {
+        clearTimeout(timer);
+        resolve(msg);
+      });
+
+      send(JSON.stringify({ jsonrpc: "2.0", id, method, params }));
+    });
+  }
+
+  async function initialize() {
+    const resp = await request("initialize", {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: { name: "integration-test", version: "0.1" },
+    });
+    // Send initialized notification (required by MCP spec)
+    send(notification("notifications/initialized"));
+    return resp;
+  }
+
+  async function callTool(name, args = {}, timeoutMs = 120_000) {
+    return request("tools/call", { name, arguments: args }, timeoutMs);
+  }
+
+  async function listTools() {
+    return request("tools/list");
+  }
+
+  function kill() {
+    try { child.stdin.end(); } catch {}
+    try { child.kill(); } catch {}
+  }
+
+  return { initialize, callTool, listTools, request, kill, child };
+}
+
+// --- Integration tests ---
+
+describe("MCP Integration (end-to-end)", { timeout: 180_000 }, () => {
+  let tmpDir;
+  let client;
+  let testPort;
+
+  before(async () => {
+    // Create isolated temp data directory
+    tmpDir = mkdtempSync(join(tmpdir(), "vector-memory-test-"));
+
+    // Use a random high port to avoid conflicting with a running server
+    testPort = 40000 + Math.floor(Math.random() * 20000);
+
+    client = createMcpClient({
+      VECTOR_MEMORY_DATA_DIR: tmpDir,
+      VECTOR_MEMORY_PORT: String(testPort),
+      VECTOR_MEMORY_IDLE_TIMEOUT: "0", // disable idle shutdown
+    });
+
+    // Perform MCP handshake
+    const initResp = await client.initialize();
+    assert.ok(initResp.result, "initialize should return a result");
+    assert.ok(initResp.result.protocolVersion, "should include protocol version");
+  });
+
+  after(async () => {
+    if (client) client.kill();
+
+    // Give child processes a moment to exit
+    await new Promise(r => setTimeout(r, 1000));
+
+    // Kill any server on our test port
+    try {
+      const { execSync } = await import("node:child_process");
+      const out = execSync("netstat -ano", { encoding: "utf-8", windowsHide: true });
+      for (const line of out.split("\n")) {
+        if (line.includes(`:${testPort}`) && line.includes("LISTENING")) {
+          const pid = parseInt(line.trim().split(/\s+/).pop());
+          if (!isNaN(pid) && pid > 0) {
+            try { process.kill(pid); } catch {}
+          }
+        }
+      }
+    } catch {}
+
+    // Clean up temp directory
+    if (tmpDir && existsSync(tmpDir)) {
+      rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it("tools/list returns vector_search and vector_reindex", async () => {
+    const resp = await client.listTools();
+    assert.ok(resp.result, "should have result");
+    const tools = resp.result.tools;
+    assert.ok(Array.isArray(tools), "tools should be an array");
+
+    const names = tools.map(t => t.name).sort();
+    assert.deepEqual(names, ["vector_reindex", "vector_search"]);
+
+    // vector_search should have query and limit params
+    const searchTool = tools.find(t => t.name === "vector_search");
+    assert.ok(searchTool.inputSchema.properties.query, "vector_search should have query param");
+    assert.ok(searchTool.inputSchema.properties.limit, "vector_search should have limit param");
+
+    // vector_reindex should have no required params
+    const reindexTool = tools.find(t => t.name === "vector_reindex");
+    assert.ok(reindexTool, "vector_reindex should exist");
+  });
+
+  it("vector_search with valid query returns results (empty DB = no results)", async () => {
+    const resp = await client.callTool("vector_search", { query: "test query", limit: 5 });
+    assert.ok(resp.result, "should have result");
+    assert.ok(Array.isArray(resp.result.content), "should have content array");
+    assert.equal(resp.result.content[0].type, "text");
+    const text = resp.result.content[0].text;
+    // Empty temp DB → "No results found." or worker error (acceptable on first run)
+    assert.ok(
+      text.includes("No results") ||
+      text.includes("score:") ||
+      text.includes("unavailable") ||
+      text.includes("Error"),
+      `Unexpected response: ${text.slice(0, 300)}`
+    );
+  });
+
+  it("vector_search with missing query returns validation error", async () => {
+    const resp = await client.callTool("vector_search", {});
+    // MCP SDK returns validation errors as result with isError: true
+    assert.ok(resp.result || resp.error, "should have result or error");
+    if (resp.result) {
+      assert.ok(resp.result.isError, "should be flagged as error");
+      assert.ok(resp.result.content[0].text.includes("invalid") ||
+                resp.result.content[0].text.includes("Invalid") ||
+                resp.result.content[0].text.includes("required"),
+        `Expected validation error, got: ${resp.result.content[0].text.slice(0, 200)}`);
+    }
+  });
+
+  it("vector_search with invalid limit type returns validation error", async () => {
+    const resp = await client.callTool("vector_search", { query: "test", limit: "not a number" });
+    assert.ok(resp.result || resp.error, "should have result or error");
+    if (resp.result) {
+      assert.ok(resp.result.isError, "should be flagged as error");
+      assert.ok(resp.result.content[0].text.includes("invalid") ||
+                resp.result.content[0].text.includes("Invalid") ||
+                resp.result.content[0].text.includes("number"),
+        `Expected type validation error, got: ${resp.result.content[0].text.slice(0, 200)}`);
+    }
+  });
+
+  it("vector_reindex returns count or session store message", async () => {
+    const resp = await client.callTool("vector_reindex", {});
+    assert.ok(resp.result, "should have result");
+    assert.ok(Array.isArray(resp.result.content), "should have content array");
+    const text = resp.result.content[0].text;
+    assert.ok(
+      text.includes("Reindexed") ||
+      text.includes("Session store") ||
+      text.includes("not found") ||
+      text.includes("unavailable") ||
+      text.includes("Error"),
+      `Expected reindex result or error message, got: ${text.slice(0, 300)}`
+    );
+  });
+
+  it("calling unknown tool returns error", async () => {
+    const resp = await client.callTool("nonexistent_tool", {});
+    // MCP SDK returns unknown tool as either error or result with isError
+    assert.ok(
+      resp.error || (resp.result && resp.result.isError),
+      `Expected error for unknown tool, got: ${JSON.stringify(resp.result || resp.error).slice(0, 200)}`
+    );
+  });
+
+  it("PID file is created in temp data dir", async () => {
+    // The server should have written its PID file to our temp dir
+    const pidFile = join(tmpDir, "vector-memory.pid");
+    // Give the server a moment if it's still starting
+    for (let i = 0; i < 10; i++) {
+      if (existsSync(pidFile)) break;
+      await new Promise(r => setTimeout(r, 500));
+    }
+    assert.ok(existsSync(pidFile), "PID file should exist in temp data dir (not ~/.copilot/)");
+  });
+});

vector-memory-server.js

@@ -14,7 +14,7 @@ import { createEmbedPool } from "./embed-pool.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const PKG = JSON.parse(readFileSync(join(__dirname, "package.json"), "utf-8"));
 const SERVER_USER = userInfo().username;
-const COPILOT_DIR = join(homedir(), ".copilot");
+const COPILOT_DIR = process.env.VECTOR_MEMORY_DATA_DIR || join(homedir(), ".copilot");
 const SESSION_STORE_PATH = join(COPILOT_DIR, "session-store.db");
 const VECTOR_INDEX_PATH = join(COPILOT_DIR, "vector-index.db");
 const INDEX_INTERVAL_MS = 15 * 60 * 1000;