muonroi-cli 1.4.0 → 1.5.0

package/src/mcp/__tests__/harness-driver-async-tools.spec.ts

@@ -1,129 +0,0 @@
-import type { Driver } from "@muonroi/agent-harness-core/driver";
-import { registerAsyncTools } from "@muonroi/agent-harness-core/mcp-server";
-import type { LiveEvent } from "@muonroi/agent-harness-core/protocol";
-import { describe, expect, it } from "vitest";
-
-type ToolCb = (input: Record<string, unknown>) => Promise<unknown>;
-
-function makeFakeServer() {
-  const tools = new Map<string, ToolCb>();
-  return {
-    server: {
-      registerTool: (name: string, _config: unknown, cb: ToolCb) => {
-        tools.set(name, cb);
-      },
-    } as any,
-    invoke: async (name: string, input: Record<string, unknown> = {}) => {
-      const cb = tools.get(name);
-      if (!cb) throw new Error(`tool not registered: ${name}`);
-      return cb(input);
-    },
-    names: () => Array.from(tools.keys()),
-  };
-}
-
-type StubOpts = {
-  waitRejects?: boolean;
-  expectResult?: boolean;
-  lastEvent?: LiveEvent | null;
-};
-function makeStubDriver(opts: StubOpts = {}): Driver {
-  return {
-    snapshot: () => null,
-    changes_since: () => null,
-    press: () => {},
-    press_sequence: () => {},
-    type: () => {},
-    focus: () => {},
-    wait_for: async () => {
-      if (opts.waitRejects) throw new Error("wait_for timeout after 30ms");
-    },
-    query: () => null,
-    queryAll: () => [],
-    count: () => 0,
-    expect: () => opts.expectResult ?? true,
-    last_event: (() => opts.lastEvent ?? null) as Driver["last_event"],
-    events: () => ({
-      [Symbol.asyncIterator]: () => ({ next: async () => ({ value: undefined as any, done: true as const }) }),
-    }),
-    render_text: () => "",
-    _ingest: () => {},
-    _closeAllSubscribers: () => {},
-  };
-}
-
-describe("registerAsyncTools", () => {
-  it("registers all 4 async tools", () => {
-    const fake = makeFakeServer();
-    registerAsyncTools(fake.server, () => makeStubDriver(), { onStop: () => {} });
-    expect(fake.names().sort()).toEqual(["tui.expect", "tui.last_event", "tui.stop", "tui.wait_for"]);
-  });
-
-  it("tui.wait_for returns ok on success", async () => {
-    const fake = makeFakeServer();
-    registerAsyncTools(fake.server, () => makeStubDriver(), { onStop: () => {} });
-    const r: any = await fake.invoke("tui.wait_for", { idle: true, timeoutMs: 1000 });
-    expect(r.content[0].text).toBe("ok");
-  });
-
-  it("tui.wait_for returns isError on timeout", async () => {
-    const fake = makeFakeServer();
-    registerAsyncTools(fake.server, () => makeStubDriver({ waitRejects: true }), { onStop: () => {} });
-    const r: any = await fake.invoke("tui.wait_for", { selector: "role=missing", timeoutMs: 30 });
-    expect(r.isError).toBe(true);
-    expect(JSON.parse(r.content[0].text).error).toBe("timeout");
-  });
-
-  it("tui.expect returns 'true' string", async () => {
-    const fake = makeFakeServer();
-    registerAsyncTools(fake.server, () => makeStubDriver({ expectResult: true }), { onStop: () => {} });
-    const r: any = await fake.invoke("tui.expect", { selector: "x", predicate: {} });
-    expect(r.content[0].text).toBe("true");
-  });
-
-  it("tui.expect returns 'false' string", async () => {
-    const fake = makeFakeServer();
-    registerAsyncTools(fake.server, () => makeStubDriver({ expectResult: false }), { onStop: () => {} });
-    const r: any = await fake.invoke("tui.expect", { selector: "x", predicate: {} });
-    expect(r.content[0].text).toBe("false");
-  });
-
-  it("tui.last_event returns event JSON or null", async () => {
-    const evt: LiveEvent = { t: "event", kind: "toast", level: "info", text: "hi" };
-    const fake = makeFakeServer();
-    registerAsyncTools(fake.server, () => makeStubDriver({ lastEvent: evt }), { onStop: () => {} });
-    const r: any = await fake.invoke("tui.last_event", { kind: "toast" });
-    expect(JSON.parse(r.content[0].text).kind).toBe("toast");
-  });
-
-  it("tui.last_event returns null when no event", async () => {
-    const fake = makeFakeServer();
-    registerAsyncTools(fake.server, () => makeStubDriver(), { onStop: () => {} });
-    const r: any = await fake.invoke("tui.last_event", { kind: "stream.delta" });
-    expect(JSON.parse(r.content[0].text)).toBeNull();
-  });
-
-  it("tui.stop invokes onStop", async () => {
-    let stopped = false;
-    const fake = makeFakeServer();
-    registerAsyncTools(fake.server, () => makeStubDriver(), {
-      onStop: () => {
-        stopped = true;
-      },
-    });
-    const r: any = await fake.invoke("tui.stop");
-    expect(stopped).toBe(true);
-    expect(r.content[0].text).toBe("ok");
-  });
-
-  it("returns no_driver error when getDriver returns null (wait_for/expect/last_event)", async () => {
-    const fake = makeFakeServer();
-    registerAsyncTools(fake.server, () => null, { onStop: () => {} });
-    const a: any = await fake.invoke("tui.wait_for", { idle: true });
-    expect(a.isError).toBe(true);
-    const b: any = await fake.invoke("tui.expect", { selector: "x", predicate: {} });
-    expect(b.isError).toBe(true);
-    const c: any = await fake.invoke("tui.last_event", { kind: "toast" });
-    expect(c.isError).toBe(true);
-  });
-});

package/src/mcp/__tests__/harness-driver-read-tools.spec.ts

@@ -1,140 +0,0 @@
-import type { Driver } from "@muonroi/agent-harness-core/driver";
-import { registerReadTools } from "@muonroi/agent-harness-core/mcp-server";
-import type { LiveFrame, UINode } from "@muonroi/agent-harness-core/protocol";
-import { describe, expect, it } from "vitest";
-
-type ToolCb = (input: Record<string, unknown>) => Promise<unknown>;
-
-function makeFakeServer() {
-  const tools = new Map<string, ToolCb>();
-  return {
-    server: {
-      registerTool: (name: string, _config: unknown, cb: ToolCb) => {
-        tools.set(name, cb);
-        return undefined;
-      },
-    } as any,
-    invoke: async (name: string, input: Record<string, unknown> = {}) => {
-      const cb = tools.get(name);
-      if (!cb) throw new Error(`tool not registered: ${name}`);
-      return cb(input);
-    },
-    names: () => Array.from(tools.keys()),
-  };
-}
-
-function makeStubDriver(frame: LiveFrame, nodes: UINode[]): Driver {
-  return {
-    snapshot: () => frame,
-    changes_since: (seq: number) => (frame.seq > seq ? frame : null),
-    press: () => {},
-    press_sequence: () => {},
-    type: () => {},
-    focus: () => {},
-    wait_for: async () => {},
-    query: (sel: string) =>
-      sel === "ambiguous-error"
-        ? (() => {
-            throw new Error("ambiguous: 2 matches");
-          })()
-        : (nodes[0] ?? null),
-    queryAll: () => nodes,
-    count: () => nodes.length,
-    expect: () => true,
-    last_event: () => null,
-    events: () => ({
-      [Symbol.asyncIterator]: () => ({ next: async () => ({ value: undefined as any, done: true as const }) }),
-    }),
-    render_text: () => "[rendered]",
-    _ingest: () => {},
-    _closeAllSubscribers: () => {},
-  };
-}
-
-const sampleFrame: LiveFrame = {
-  mode: "live",
-  version: "0.4.0",
-  seq: 7,
-  ts: 0,
-  nodes: [{ id: "n1", role: "button", name: "Send" }],
-};
-
-describe("registerReadTools", () => {
-  it("registers all 6 read tools", () => {
-    const fake = makeFakeServer();
-    registerReadTools(fake.server, () => makeStubDriver(sampleFrame, sampleFrame.nodes));
-    expect(fake.names().sort()).toEqual([
-      "tui.changes_since",
-      "tui.count",
-      "tui.query",
-      "tui.query_all",
-      "tui.render_text",
-      "tui.snapshot",
-    ]);
-  });
-
-  it("tui.snapshot returns serialized frame", async () => {
-    const fake = makeFakeServer();
-    registerReadTools(fake.server, () => makeStubDriver(sampleFrame, sampleFrame.nodes));
-    const r: any = await fake.invoke("tui.snapshot");
-    expect(JSON.parse(r.content[0].text).seq).toBe(7);
-  });
-
-  it("tui.changes_since returns null when seq is current", async () => {
-    const fake = makeFakeServer();
-    registerReadTools(fake.server, () => makeStubDriver(sampleFrame, sampleFrame.nodes));
-    const r: any = await fake.invoke("tui.changes_since", { seq: 7 });
-    expect(JSON.parse(r.content[0].text)).toBeNull();
-  });
-
-  it("tui.changes_since returns frame when seq < current", async () => {
-    const fake = makeFakeServer();
-    registerReadTools(fake.server, () => makeStubDriver(sampleFrame, sampleFrame.nodes));
-    const r: any = await fake.invoke("tui.changes_since", { seq: 0 });
-    expect(JSON.parse(r.content[0].text).seq).toBe(7);
-  });
-
-  it("tui.query returns the single node", async () => {
-    const fake = makeFakeServer();
-    registerReadTools(fake.server, () => makeStubDriver(sampleFrame, sampleFrame.nodes));
-    const r: any = await fake.invoke("tui.query", { selector: "role=button" });
-    expect(JSON.parse(r.content[0].text).id).toBe("n1");
-  });
-
-  it("tui.query returns isError on ambiguous", async () => {
-    const fake = makeFakeServer();
-    registerReadTools(fake.server, () => makeStubDriver(sampleFrame, sampleFrame.nodes));
-    const r: any = await fake.invoke("tui.query", { selector: "ambiguous-error" });
-    expect(r.isError).toBe(true);
-    expect(JSON.parse(r.content[0].text).error).toBe("ambiguous");
-  });
-
-  it("tui.query_all returns array", async () => {
-    const fake = makeFakeServer();
-    registerReadTools(fake.server, () => makeStubDriver(sampleFrame, sampleFrame.nodes));
-    const r: any = await fake.invoke("tui.query_all", { selector: "*" });
-    expect(JSON.parse(r.content[0].text)).toHaveLength(1);
-  });
-
-  it("tui.count returns numeric string", async () => {
-    const fake = makeFakeServer();
-    registerReadTools(fake.server, () => makeStubDriver(sampleFrame, sampleFrame.nodes));
-    const r: any = await fake.invoke("tui.count", { selector: "*" });
-    expect(r.content[0].text).toBe("1");
-  });
-
-  it("tui.render_text returns string", async () => {
-    const fake = makeFakeServer();
-    registerReadTools(fake.server, () => makeStubDriver(sampleFrame, sampleFrame.nodes));
-    const r: any = await fake.invoke("tui.render_text");
-    expect(r.content[0].text).toBe("[rendered]");
-  });
-
-  it("returns no_driver error when getDriver returns null", async () => {
-    const fake = makeFakeServer();
-    registerReadTools(fake.server, () => null);
-    const r: any = await fake.invoke("tui.snapshot");
-    expect(r.isError).toBe(true);
-    expect(JSON.parse(r.content[0].text).error).toBe("no_driver");
-  });
-});

package/src/mcp/__tests__/harness-driver-security.spec.ts

@@ -1,69 +0,0 @@
-import { homedir } from "node:os";
-import {
-  sanitizeEnv,
-  validateCwd,
-  validateMockLlmPath,
-  validateStartArgs,
-} from "@muonroi/agent-harness-core/mcp-server";
-import { describe, expect, it } from "vitest";
-
-describe("validateStartArgs (argv allowlist)", () => {
-  it("accepts --agent-* flags", () => {
-    expect(validateStartArgs(["--agent-mode", "--agent-cols=80"])).toEqual({ ok: true });
-  });
-  it("accepts --mock-llm", () => {
-    expect(validateStartArgs(["--mock-llm=fix/"])).toEqual({ ok: true });
-  });
-  it("rejects --require", () => {
-    expect(validateStartArgs(["--require", "evil.js"])).toMatchObject({ ok: false });
-  });
-  it("rejects --preload", () => {
-    expect(validateStartArgs(["--preload=evil"])).toMatchObject({ ok: false });
-  });
-  it("rejects --eval", () => {
-    expect(validateStartArgs(["--eval", "x"])).toMatchObject({ ok: false });
-  });
-});
-
-describe("sanitizeEnv", () => {
-  it("strips NODE_OPTIONS / BUN_OPTIONS / LD_PRELOAD", () => {
-    const e = sanitizeEnv({ NODE_OPTIONS: "x", BUN_OPTIONS: "y", LD_PRELOAD: "z", FOO: "ok" });
-    expect(e).toEqual({ FOO: "ok" });
-  });
-  it("strips LD_AUDIT / DYLD_FRAMEWORK_PATH / NODE_PATH (v1.1 expansion)", () => {
-    const e = sanitizeEnv({ LD_AUDIT: "a", DYLD_FRAMEWORK_PATH: "b", NODE_PATH: "c", KEEP: "ok" });
-    expect(e).toEqual({ KEEP: "ok" });
-  });
-  it("rejects keys with bad chars", () => {
-    const e = sanitizeEnv({ "ok=A": "x", "BAD-KEY": "y", GOOD: "z" });
-    expect(e).toEqual({ GOOD: "z" });
-  });
-});
-
-describe("validateCwd", () => {
-  it("accepts home directory", () => {
-    expect(validateCwd(homedir())).toEqual({ ok: true });
-  });
-  it("accepts current repo root", () => {
-    expect(validateCwd(process.cwd())).toEqual({ ok: true });
-  });
-  it("rejects path outside home and repo", () => {
-    // Pick a path guaranteed to be outside home + repo. Use the OS root.
-    const root = process.platform === "win32" ? "C:\\" : "/";
-    const v = validateCwd(root);
-    expect(v.ok).toBe(false);
-  });
-});
-
-describe("validateMockLlmPath", () => {
-  it("accepts a path inside repo root", () => {
-    expect(validateMockLlmPath("tests/harness/fixtures/llm")).toBe(true);
-  });
-  it("rejects path escaping repo root with ..", () => {
-    expect(validateMockLlmPath("../../etc")).toBe(false);
-  });
-  it("rejects absolute path outside repo", () => {
-    const outside = process.platform === "win32" ? "C:\\Windows" : "/etc";
-    expect(validateMockLlmPath(outside)).toBe(false);
-  });
-});

package/src/mcp/__tests__/harness-driver.spec.ts

@@ -1,21 +0,0 @@
-import { buildCapabilitiesPayload } from "@muonroi/agent-harness-core/mcp-server";
-import { PROTOCOL_VERSION } from "@muonroi/agent-harness-core/protocol";
-import { describe, expect, it } from "vitest";
-
-describe("harness-driver capabilities", () => {
-  it("reports current protocol version", () => {
-    expect(buildCapabilitiesPayload().protocol).toBe(PROTOCOL_VERSION);
-  });
-
-  it("advertises core feature set", () => {
-    const { features } = buildCapabilitiesPayload();
-    expect(features).toContain("capabilities");
-    expect(features).toContain("snapshot");
-    expect(features).toContain("press");
-    expect(features).toContain("type");
-    expect(features).toContain("wait_for");
-    expect(features).toContain("query");
-    expect(features).toContain("expect");
-    expect(features).toContain("render_text");
-  });
-});

package/src/mcp/__tests__/lazy-schema.spec.ts

@@ -1,173 +0,0 @@
-import { jsonSchema } from "@ai-sdk/provider-utils";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-// Mock keychain — not relevant here.
-vi.mock("../mcp-keychain.js", () => ({
-  getMcpKey: vi.fn(async () => null),
-  setMcpKey: vi.fn(async () => true),
-  deleteMcpKey: vi.fn(async () => true),
-}));
-
-vi.mock("@modelcontextprotocol/sdk/client/stdio.js", () => ({
-  StdioClientTransport: vi.fn(function (this: any, opts: any) {
-    Object.assign(this, opts);
-  }),
-  getDefaultEnvironment: () => ({}),
-}));
-
-vi.mock("../validate.js", () => ({
-  validateMcpServerConfig: () => ({ ok: true }),
-}));
-
-// Build a synthetic registry of 10 MCP tools, each with a realistic ~1.2 KB
-// JSON schema. The control test ("eager") goes through the AI SDK exactly as
-// our code path does; the lazy test asserts the schema is stripped.
-function makeFatSchema(toolIndex: number): Record<string, unknown> {
-  const properties: Record<string, unknown> = {};
-  // 12 string properties with description/enum/pattern — typical for a real
-  // MCP tool advertising rich args. Pads each tool's schema to ~1 KB+.
-  for (let i = 0; i < 12; i++) {
-    properties[`field_${i}`] = {
-      type: "string",
-      description: `Tool ${toolIndex} field ${i} — accepts a string of moderate length and represents a parameter the MCP server cares about. Longer descriptions are common in real MCP tools.`,
-      enum: ["one", "two", "three", "four", "five", "six"],
-      pattern: "^[a-zA-Z0-9_-]+$",
-    };
-  }
-  return {
-    type: "object",
-    properties,
-    required: ["field_0", "field_1", "field_2"],
-    additionalProperties: false,
-  };
-}
-
-function makeTenFatTools() {
-  const tools: Record<
-    string,
-    { description: string; inputSchema: unknown; execute: (args: unknown) => Promise<unknown> }
-  > = {};
-  for (let i = 0; i < 10; i++) {
-    const name = `tool_${i}`;
-    tools[name] = {
-      description: `Synthetic MCP tool number ${i}`,
-      inputSchema: jsonSchema(makeFatSchema(i)),
-      execute: async (args: unknown) => ({ ok: true, args }),
-    };
-  }
-  return tools;
-}
-
-const fakeMcpClient = {
-  tools: async () => makeTenFatTools(),
-  close: async () => {},
-};
-
-vi.mock("@ai-sdk/mcp", () => ({
-  createMCPClient: vi.fn(async () => fakeMcpClient),
-}));
-
-// Helper: compute the wire-payload-sized byte count of the tool's inputSchema
-// as it would be serialized to the provider. The AI SDK reads
-// `tool.inputSchema.jsonSchema` (via `asSchema(...)`) and that is what gets
-// JSON-serialized into the provider tool definition.
-function schemaPayloadBytes(tool: unknown): number {
-  const schema = (tool as { inputSchema?: { jsonSchema?: unknown } })?.inputSchema?.jsonSchema;
-  if (!schema) return 0;
-  return Buffer.byteLength(JSON.stringify(schema), "utf8");
-}
-
-function totalSchemaBytes(tools: Record<string, unknown>): number {
-  let total = 0;
-  for (const t of Object.values(tools)) total += schemaPayloadBytes(t);
-  return total;
-}
-
-describe("M1 — MCP lazy schema loading", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("strips per-tool inputSchema to a minimal placeholder", async () => {
-    const { buildMcpToolSet } = await import("../runtime.js");
-    const bundle = await buildMcpToolSet([
-      {
-        id: "fake",
-        label: "Fake MCP",
-        enabled: true,
-        transport: "stdio",
-        command: "npx",
-        args: ["-y", "fake"],
-      },
-    ]);
-
-    expect(bundle.errors).toHaveLength(0);
-    expect(Object.keys(bundle.tools)).toHaveLength(10);
-
-    for (const tool of Object.values(bundle.tools)) {
-      const schema = (tool as { inputSchema?: { jsonSchema?: Record<string, unknown> } }).inputSchema?.jsonSchema;
-      expect(schema).toBeDefined();
-      // The lazy schema is `{ type: "object", properties: {}, additionalProperties: true }`.
-      // OpenAI Responses API requires `properties` to be present (even empty);
-      // Anthropic / DeepSeek tolerate omitting it.
-      expect(schema?.type).toBe("object");
-      expect(schema?.additionalProperties).toBe(true);
-      expect(schema?.properties).toEqual({});
-      // Crucially: no `required`, no `enum`/`pattern`/field-level descriptions.
-      expect(schema).not.toHaveProperty("required");
-      // Description is preserved (the model needs it to decide WHEN to call).
-      expect((tool as { description?: string }).description).toMatch(/Synthetic MCP tool number/);
-    }
-  });
-
-  it("lazy payload is <1 KB while eager payload is >10 KB for 10 tools", async () => {
-    const { buildMcpToolSet } = await import("../runtime.js");
-
-    // Eager baseline = the raw fixture tools, unwrapped (what we'd send if we
-    // didn't strip).
-    const eagerTools = makeTenFatTools();
-    const eagerBytes = totalSchemaBytes(eagerTools as unknown as Record<string, unknown>);
-
-    const bundle = await buildMcpToolSet([
-      {
-        id: "fake",
-        label: "Fake MCP",
-        enabled: true,
-        transport: "stdio",
-        command: "npx",
-        args: ["-y", "fake"],
-      },
-    ]);
-    const lazyBytes = totalSchemaBytes(bundle.tools as unknown as Record<string, unknown>);
-
-    // Acceptance bands from the M1 brief.
-    expect(eagerBytes).toBeGreaterThan(10_000);
-    expect(lazyBytes).toBeLessThan(1_000);
-
-    // And a sanity ratio: lazy should be at least ~20x smaller.
-    expect(lazyBytes * 20).toBeLessThan(eagerBytes);
-  });
-
-  it("tool-call still routes to the MCP server execute() — args pass through unchanged", async () => {
-    const { buildMcpToolSet } = await import("../runtime.js");
-    const bundle = await buildMcpToolSet([
-      {
-        id: "fake",
-        label: "Fake MCP",
-        enabled: true,
-        transport: "stdio",
-        command: "npx",
-        args: ["-y", "fake"],
-      },
-    ]);
-
-    const first = Object.values(bundle.tools)[0] as { execute?: (args: unknown, opts?: unknown) => Promise<unknown> };
-    expect(typeof first.execute).toBe("function");
-
-    // Send args that would FAIL the eager full schema (extra fields,
-    // missing-required-fields). Under lazy loading these still pass through to
-    // the MCP server's execute, which is where the real validation happens.
-    const result = await first.execute!({ surprise_field: 42 }, {});
-    expect(result).toEqual({ ok: true, args: { surprise_field: 42 } });
-  });
-});

package/src/mcp/__tests__/lsp-tools.test.ts

@@ -1,72 +0,0 @@
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { describe, expect, it } from "vitest";
-import type { LspToolResponse } from "../../lsp/types.js";
-import { registerLspTools } from "../lsp-tools.js";
-
-function collectTools(register: (s: McpServer) => void) {
-  const handlers: Record<string, (args: unknown) => Promise<unknown>> = {};
-  const fake = {
-    registerTool(name: string, _def: unknown, handler: (args: unknown) => Promise<unknown>) {
-      handlers[name] = handler;
-    },
-  } as unknown as McpServer;
-  register(fake);
-  return handlers;
-}
-function parse(result: unknown) {
-  const r = result as { content: Array<{ text: string }>; isError?: boolean };
-  return { json: JSON.parse(r.content[0]!.text), isError: r.isError };
-}
-
-describe("lsp-tools", () => {
-  it("lsp_query passes through the LspToolResponse when enabled", async () => {
-    const resp: LspToolResponse = { success: true, output: "def at file.ts:10" };
-    const handlers = collectTools((s) => registerLspTools(s, { enabled: () => true, query: async () => resp }));
-    const out = parse(
-      await handlers["lsp_query"]!({ operation: "goToDefinition", filePath: "a.ts", line: 1, character: 2 }),
-    );
-    expect(out.isError).toBeFalsy();
-    expect(out.json).toEqual(resp);
-  });
-
-  it("lsp_query returns lsp_disabled when LSP is off", async () => {
-    const handlers = collectTools((s) =>
-      registerLspTools(s, { enabled: () => false, query: async () => ({ success: true, output: "x" }) }),
-    );
-    const out = parse(await handlers["lsp_query"]!({ operation: "hover", filePath: "a.ts", line: 0, character: 0 }));
-    expect(out.isError).toBe(true);
-    expect(out.json.error).toBe("lsp_disabled");
-  });
-
-  it("lsp_query returns lsp_error when the query throws", async () => {
-    const handlers = collectTools((s) =>
-      registerLspTools(s, {
-        enabled: () => true,
-        query: async () => {
-          throw new Error("server launch failed");
-        },
-      }),
-    );
-    const out = parse(
-      await handlers["lsp_query"]!({ operation: "findReferences", filePath: "a.ts", line: 3, character: 4 }),
-    );
-    expect(out.isError).toBe(true);
-    expect(out.json.error).toBe("lsp_error");
-    expect(out.json.message).toContain("server launch failed");
-  });
-
-  it("lsp_query returns lsp_error when the enabled check throws", async () => {
-    const handlers = collectTools((s) =>
-      registerLspTools(s, {
-        enabled: () => {
-          throw new Error("settings read failed");
-        },
-        query: async () => ({ success: true, output: "x" }),
-      }),
-    );
-    const out = parse(await handlers["lsp_query"]!({ operation: "hover", filePath: "a.ts", line: 0, character: 0 }));
-    expect(out.isError).toBe(true);
-    expect(out.json.error).toBe("lsp_error");
-    expect(out.json.message).toContain("settings read failed");
-  });
-});

package/src/mcp/__tests__/mcp-keychain.test.ts

@@ -1,46 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-vi.mock("keytar", () => {
-  const store = new Map<string, string>();
-  return {
-    getPassword: vi.fn(async (service: string, account: string) => store.get(`${service}:${account}`) ?? null),
-    setPassword: vi.fn(async (service: string, account: string, password: string) => {
-      store.set(`${service}:${account}`, password);
-    }),
-    deletePassword: vi.fn(async (service: string, account: string) => {
-      return store.delete(`${service}:${account}`);
-    }),
-  };
-});
-
-import { deleteMcpKey, getMcpKey, setMcpKey } from "../mcp-keychain.js";
-
-describe("mcp-keychain", () => {
-  beforeEach(async () => {
-    await deleteMcpKey("tavily");
-    delete process.env.TAVILY_API_KEY;
-  });
-
-  it("stores and retrieves a tavily key", async () => {
-    const ok = await setMcpKey("tavily", "tvly-1234567890abcdefghij");
-    expect(ok).toBe(true);
-    const got = await getMcpKey("tavily");
-    expect(got).toBe("tvly-1234567890abcdefghij");
-  });
-
-  it("returns null when no key stored", async () => {
-    const got = await getMcpKey("tavily");
-    expect(got).toBeNull();
-  });
-
-  it("rejects keys shorter than 16 chars", async () => {
-    await expect(setMcpKey("tavily", "short")).rejects.toThrow(/too short/i);
-  });
-
-  it("falls back to env var when keytar empty", async () => {
-    process.env.TAVILY_API_KEY = "tvly-env-1234567890abcdefgh";
-    const got = await getMcpKey("tavily");
-    expect(got).toBe("tvly-env-1234567890abcdefgh");
-    delete process.env.TAVILY_API_KEY;
-  });
-});