muonroi-cli 1.8.0 → 1.8.3

package/dist/src/mcp/__tests__/harness-driver-security.spec.js

@@ -1,61 +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);
-    });
-});
-//# sourceMappingURL=harness-driver-security.spec.js.map

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

@@ -1 +0,0 @@
-export {};

package/dist/src/mcp/__tests__/harness-driver.spec.js

@@ -1,20 +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");
-    });
-});
-//# sourceMappingURL=harness-driver.spec.js.map

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

@@ -1 +0,0 @@
-export {};

package/dist/src/mcp/__tests__/lazy-schema.spec.js

@@ -1,152 +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 (opts) {
-        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) {
-    const properties = {};
-    // 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 = {};
-    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) => ({ 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) {
-    const schema = tool?.inputSchema?.jsonSchema;
-    if (!schema)
-        return 0;
-    return Buffer.byteLength(JSON.stringify(schema), "utf8");
-}
-function totalSchemaBytes(tools) {
-    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.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.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);
-        const bundle = await buildMcpToolSet([
-            {
-                id: "fake",
-                label: "Fake MCP",
-                enabled: true,
-                transport: "stdio",
-                command: "npx",
-                args: ["-y", "fake"],
-            },
-        ]);
-        const lazyBytes = totalSchemaBytes(bundle.tools);
-        // 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];
-        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 } });
-    });
-});
-//# sourceMappingURL=lazy-schema.spec.js.map

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

@@ -1 +0,0 @@
-export {};

package/dist/src/mcp/__tests__/lsp-tools.test.js

@@ -1,56 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { registerLspTools } from "../lsp-tools.js";
-function collectTools(register) {
-    const handlers = {};
-    const fake = {
-        registerTool(name, _def, handler) {
-            handlers[name] = handler;
-        },
-    };
-    register(fake);
-    return handlers;
-}
-function parse(result) {
-    const r = result;
-    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 = { 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");
-    });
-});
-//# sourceMappingURL=lsp-tools.test.js.map

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

@@ -1 +0,0 @@
-export {};

package/dist/src/mcp/__tests__/mcp-keychain.test.js

@@ -1,40 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-vi.mock("keytar", () => {
-    const store = new Map();
-    return {
-        getPassword: vi.fn(async (service, account) => store.get(`${service}:${account}`) ?? null),
-        setPassword: vi.fn(async (service, account, password) => {
-            store.set(`${service}:${account}`, password);
-        }),
-        deletePassword: vi.fn(async (service, account) => {
-            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;
-    });
-});
-//# sourceMappingURL=mcp-keychain.test.js.map

package/dist/src/mcp/__tests__/parallel-build.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/mcp/__tests__/parallel-build.spec.js

@@ -1,67 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-// Phase 1c regression: buildMcpToolSet must connect servers in PARALLEL and
-// return PARTIAL results at its deadline, so a slow server (e.g. an npx stdio
-// spawn) never starves a fast one. The OLD sequential build under an outer race
-// dropped the WHOLE bundle on timeout — the agent then saw NO MCP tools even
-// when a fast HTTP server was reachable (session f6f7881a5fae).
-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 (opts) {
-        Object.assign(this, opts);
-    }),
-    getDefaultEnvironment: () => ({}),
-}));
-vi.mock("../validate.js", () => ({
-    validateMcpServerConfig: () => ({ ok: true }),
-}));
-const fastClient = {
-    tools: async () => ({ ping: { description: "ping", execute: async () => ({ ok: true }) } }),
-    close: async () => { },
-};
-vi.mock("@ai-sdk/mcp", () => ({
-    // A server whose name contains "slow" never finishes connecting (simulates a
-    // slow npx spawn). Everything else connects instantly.
-    createMCPClient: vi.fn(async ({ name }) => {
-        if (name.includes("slow"))
-            return new Promise(() => { }); // never resolves
-        return fastClient;
-    }),
-}));
-describe("buildMcpToolSet — parallel build, partial results at deadline (Phase 1c)", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        delete process.env.MUONROI_MCP_BUILD_DEADLINE_MS;
-    });
-    it("returns the fast server's tools and reports the slow one — slow does NOT starve fast", async () => {
-        process.env.MUONROI_MCP_BUILD_DEADLINE_MS = "500";
-        const { buildMcpToolSet } = await import("../runtime.js");
-        const start = Date.now();
-        const bundle = await buildMcpToolSet([
-            { id: "slow-server", label: "slow-server", enabled: true, transport: "stdio", command: "node", args: [] },
-            { id: "fast-server", label: "fast-server", enabled: true, transport: "stdio", command: "node", args: [] },
-        ]);
-        const elapsed = Date.now() - start;
-        // Resolved at ~the deadline, NOT blocked behind the slow (never-ending) connect.
-        expect(elapsed).toBeLessThan(2000);
-        // The fast server's tool is available even though a slower server is pending.
-        expect(Object.keys(bundle.tools)).toContain("mcp_fast-server__ping");
-        // The slow server is surfaced as an error, never silently dropped.
-        expect(bundle.errors.some((e) => e.includes("slow-server") && /not ready within/.test(e))).toBe(true);
-        await bundle.close();
-    });
-    it("orders are independent — the fast server loads regardless of position", async () => {
-        process.env.MUONROI_MCP_BUILD_DEADLINE_MS = "500";
-        const { buildMcpToolSet } = await import("../runtime.js");
-        const bundle = await buildMcpToolSet([
-            { id: "fast-server", label: "fast-server", enabled: true, transport: "stdio", command: "node", args: [] },
-            { id: "slow-server", label: "slow-server", enabled: true, transport: "stdio", command: "node", args: [] },
-        ]);
-        expect(Object.keys(bundle.tools)).toContain("mcp_fast-server__ping");
-        await bundle.close();
-    });
-});
-//# sourceMappingURL=parallel-build.spec.js.map

package/dist/src/mcp/__tests__/research-onboarding.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/mcp/__tests__/research-onboarding.test.js

@@ -1,148 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-vi.mock("../mcp-keychain.js", () => ({
-    setMcpKey: vi.fn(async () => true),
-    getMcpKey: vi.fn(async () => null),
-    deleteMcpKey: vi.fn(async () => true),
-}));
-const settingsStore = {};
-const mcpServers = [];
-vi.mock("../../utils/settings.js", () => ({
-    loadUserSettings: vi.fn(() => ({ ...settingsStore })),
-    saveUserSettings: vi.fn((p) => Object.assign(settingsStore, p)),
-    loadMcpServers: vi.fn(() => [...mcpServers]),
-    saveMcpServers: vi.fn((s) => {
-        mcpServers.length = 0;
-        mcpServers.push(...s);
-    }),
-}));
-global.fetch = vi.fn(async () => new Response(JSON.stringify({ results: [] }), { status: 200 }));
-import { runResearchMigrationPrompt, runResearchOnboarding, validateTavilyKey } from "../research-onboarding.js";
-describe("validateTavilyKey", () => {
-    it("returns true on HTTP 200", async () => {
-        global.fetch.mockResolvedValueOnce(new Response("{}", { status: 200 }));
-        const ok = await validateTavilyKey("tvly-1234567890abcdefghij");
-        expect(ok).toBe(true);
-    });
-    it("returns false on HTTP 401", async () => {
-        global.fetch.mockResolvedValueOnce(new Response("Unauthorized", { status: 401 }));
-        const ok = await validateTavilyKey("tvly-bad-keykeykeykey");
-        expect(ok).toBe(false);
-    });
-    it("returns false on network error", async () => {
-        global.fetch.mockRejectedValueOnce(new Error("ECONNREFUSED"));
-        const ok = await validateTavilyKey("tvly-1234567890abcdefghij");
-        expect(ok).toBe(false);
-    });
-});
-describe("runResearchOnboarding", () => {
-    beforeEach(() => {
-        settingsStore.webResearchPrompted = undefined;
-        mcpServers.length = 0;
-        // Pre-populate a tavily entry as Task 3's auto-setup would have done.
-        mcpServers.push({
-            id: "tavily",
-            label: "Tavily Web Search",
-            enabled: false,
-            transport: "stdio",
-            command: "npx",
-            args: ["-y", "tavily-mcp"],
-            env: { TAVILY_API_KEY: "" },
-        });
-        vi.clearAllMocks();
-    });
-    it("Y + valid key: stores key, enables tavily, sets flag", async () => {
-        global.fetch.mockResolvedValueOnce(new Response("{}", { status: 200 }));
-        const result = await runResearchOnboarding({
-            askYesNo: async () => "y",
-            askText: async () => "tvly-1234567890abcdefghij",
-            log: () => { },
-        });
-        expect(result.tavilyEnabled).toBe(true);
-        expect(settingsStore.webResearchPrompted).toBe(true);
-        // Critical: tavily entry must end up enabled in mcpServers, not just in
-        // the result object. The first-run wizard runs before any other path
-        // touches mcpServers, so this is the production bug we're guarding.
-        const tavily = mcpServers.find((s) => s.id === "tavily");
-        expect(tavily?.enabled).toBe(true);
-    });
-    it("Y + blank key: skips tavily, still sets flag", async () => {
-        const result = await runResearchOnboarding({
-            askYesNo: async () => "y",
-            askText: async () => "",
-            log: () => { },
-        });
-        expect(result.tavilyEnabled).toBe(false);
-        expect(settingsStore.webResearchPrompted).toBe(true);
-    });
-    it("n: skips entirely, sets flag", async () => {
-        const result = await runResearchOnboarding({
-            askYesNo: async () => "n",
-            askText: async () => "should not be asked",
-            log: () => { },
-        });
-        expect(result.tavilyEnabled).toBe(false);
-        expect(settingsStore.webResearchPrompted).toBe(true);
-    });
-    it("invalid key retries up to 3 times then skips", async () => {
-        global.fetch
-            .mockResolvedValueOnce(new Response("", { status: 401 }))
-            .mockResolvedValueOnce(new Response("", { status: 401 }))
-            .mockResolvedValueOnce(new Response("", { status: 401 }));
-        let calls = 0;
-        const result = await runResearchOnboarding({
-            askYesNo: async () => "y",
-            askText: async () => {
-                calls++;
-                return "tvly-bad-keykeykeykey";
-            },
-            log: () => { },
-        });
-        expect(calls).toBe(3);
-        expect(result.tavilyEnabled).toBe(false);
-        expect(settingsStore.webResearchPrompted).toBe(true);
-    });
-});
-describe("runResearchMigrationPrompt", () => {
-    beforeEach(() => {
-        settingsStore.webResearchPrompted = undefined;
-        mcpServers.length = 0;
-        mcpServers.push({
-            id: "tavily",
-            label: "Tavily Web Search",
-            enabled: false,
-            transport: "stdio",
-            command: "npx",
-            args: ["-y", "tavily-mcp"],
-            env: { TAVILY_API_KEY: "" },
-        });
-        vi.clearAllMocks();
-    });
-    it("does nothing if flag already true", async () => {
-        settingsStore.webResearchPrompted = true;
-        const result = await runResearchMigrationPrompt({
-            askChoice: async () => "y",
-            askText: async () => "tvly-1234567890abcdefghij",
-            log: () => { },
-        });
-        expect(result.shown).toBe(false);
-    });
-    it("'never' sets flag and never asks again", async () => {
-        const result = await runResearchMigrationPrompt({
-            askChoice: async () => "never",
-            askText: async () => "",
-            log: () => { },
-        });
-        expect(result.shown).toBe(true);
-        expect(settingsStore.webResearchPrompted).toBe(true);
-    });
-    it("'n' shows but does NOT set flag (re-ask next start)", async () => {
-        const result = await runResearchMigrationPrompt({
-            askChoice: async () => "n",
-            askText: async () => "",
-            log: () => { },
-        });
-        expect(result.shown).toBe(true);
-        expect(settingsStore.webResearchPrompted).toBeUndefined();
-    });
-});
-//# sourceMappingURL=research-onboarding.test.js.map

package/dist/src/mcp/__tests__/runtime-hydration.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/mcp/__tests__/runtime-hydration.test.js

@@ -1,78 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-// Mock the keychain so getMcpKey returns a deterministic value.
-vi.mock("../mcp-keychain.js", () => ({
-    getMcpKey: vi.fn(async (id) => (id === "tavily" ? "tvly-test-key-1234567890" : null)),
-    setMcpKey: vi.fn(async () => true),
-    deleteMcpKey: vi.fn(async () => true),
-}));
-// Capture the env that StdioClientTransport would receive without actually
-// spawning a process.
-const capturedTransports = [];
-vi.mock("@modelcontextprotocol/sdk/client/stdio.js", () => ({
-    StdioClientTransport: vi.fn(function (opts) {
-        capturedTransports.push(opts);
-        Object.assign(this, opts);
-    }),
-    getDefaultEnvironment: () => ({}),
-}));
-// Bypass the real MCP client lifecycle.
-vi.mock("@ai-sdk/mcp", () => ({
-    createMCPClient: vi.fn(async () => ({
-        tools: async () => ({}),
-        close: async () => { },
-    })),
-}));
-vi.mock("../validate.js", () => ({
-    validateMcpServerConfig: () => ({ ok: true }),
-}));
-import { buildMcpToolSet } from "../runtime.js";
-describe("buildMcpToolSet — env hydration from keychain", () => {
-    beforeEach(() => {
-        capturedTransports.length = 0;
-        vi.clearAllMocks();
-    });
-    it("injects TAVILY_API_KEY from keychain when env is empty string", async () => {
-        await buildMcpToolSet([
-            {
-                id: "tavily",
-                label: "Tavily Web Search",
-                enabled: true,
-                transport: "stdio",
-                command: "npx",
-                args: ["-y", "tavily-mcp"],
-                env: { TAVILY_API_KEY: "" },
-            },
-        ]);
-        expect(capturedTransports).toHaveLength(1);
-        expect(capturedTransports[0].env.TAVILY_API_KEY).toBe("tvly-test-key-1234567890");
-    });
-    it("does NOT overwrite a non-empty env value already configured by user", async () => {
-        await buildMcpToolSet([
-            {
-                id: "tavily",
-                label: "Tavily Web Search",
-                enabled: true,
-                transport: "stdio",
-                command: "npx",
-                args: ["-y", "tavily-mcp"],
-                env: { TAVILY_API_KEY: "user-supplied-explicit-key-1234" },
-            },
-        ]);
-        expect(capturedTransports[0].env.TAVILY_API_KEY).toBe("user-supplied-explicit-key-1234");
-    });
-    it("does not hydrate non-tavily servers", async () => {
-        await buildMcpToolSet([
-            {
-                id: "filesystem",
-                label: "Filesystem",
-                enabled: true,
-                transport: "stdio",
-                command: "npx",
-                args: ["-y", "@modelcontextprotocol/server-filesystem", "."],
-            },
-        ]);
-        // No env injected for unknown server ids.
-        expect(capturedTransports[0].env).toBeUndefined();
-    });
-});
-//# sourceMappingURL=runtime-hydration.test.js.map

package/dist/src/mcp/__tests__/runtime-output-cap.test.d.ts

@@ -1 +0,0 @@
-export {};