@evantahler/mcpx 0.15.0

package/.claude/worktrees/elastic-jennings/test/config/loader.test.ts

@@ -0,0 +1,139 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { join } from "path";
+import { loadConfig, saveAuth, saveSearchIndex } from "../../src/config/loader.ts";
+import { tmpdir } from "os";
+import { mkdtemp, rm } from "fs/promises";
+
+const FIXTURES_DIR = join(import.meta.dir, "../fixtures");
+
+describe("loadConfig", () => {
+  test("loads all three config files from a directory", async () => {
+    process.env.TEST_API_KEY = "test-key";
+    process.env.TEST_TOKEN = "test-token";
+
+    const config = await loadConfig({ configFlag: FIXTURES_DIR });
+
+    expect(config.configDir).toBe(FIXTURES_DIR);
+    expect(Object.keys(config.servers.mcpServers)).toEqual(["filesystem", "github", "internal"]);
+    expect(config.auth.github).toBeDefined();
+    expect(config.auth.github!.tokens.access_token).toBe("gho_test123");
+    expect(config.searchIndex.tools).toHaveLength(1);
+    expect(config.searchIndex.tools[0]!.tool).toBe("search_repositories");
+
+    delete process.env.TEST_API_KEY;
+    delete process.env.TEST_TOKEN;
+  });
+
+  test("interpolates env vars in server configs", async () => {
+    process.env.TEST_API_KEY = "my-api-key";
+    process.env.TEST_TOKEN = "my-token";
+
+    const config = await loadConfig({ configFlag: FIXTURES_DIR });
+    const fs = config.servers.mcpServers.filesystem!;
+    expect("env" in fs && fs.env?.API_KEY).toBe("my-api-key");
+
+    const internal = config.servers.mcpServers.internal!;
+    expect("headers" in internal && internal.headers?.Authorization).toBe("Bearer my-token");
+
+    delete process.env.TEST_API_KEY;
+    delete process.env.TEST_TOKEN;
+  });
+
+  test("returns empty defaults when no config files exist", async () => {
+    const tmpDir = await mkdtemp(join(tmpdir(), "mcpcli-test-"));
+    try {
+      const config = await loadConfig({ configFlag: tmpDir });
+      expect(Object.keys(config.servers.mcpServers)).toHaveLength(0);
+      expect(Object.keys(config.auth)).toHaveLength(0);
+      expect(config.searchIndex.tools).toHaveLength(0);
+    } finally {
+      await rm(tmpDir, { recursive: true });
+    }
+  });
+
+  test("uses MCP_CONFIG_PATH env var", async () => {
+    process.env.MCP_CONFIG_PATH = FIXTURES_DIR;
+    process.env.TEST_API_KEY = "x";
+    process.env.TEST_TOKEN = "x";
+
+    const config = await loadConfig();
+    expect(Object.keys(config.servers.mcpServers).length).toBeGreaterThan(0);
+
+    delete process.env.MCP_CONFIG_PATH;
+    delete process.env.TEST_API_KEY;
+    delete process.env.TEST_TOKEN;
+  });
+});
+
+describe("validateServersFile", () => {
+  test("rejects missing mcpServers key", async () => {
+    const tmpDir = await mkdtemp(join(tmpdir(), "mcpcli-test-"));
+    try {
+      await Bun.write(join(tmpDir, "servers.json"), JSON.stringify({ wrong: "shape" }));
+      await expect(loadConfig({ configFlag: tmpDir })).rejects.toThrow("mcpServers");
+    } finally {
+      await rm(tmpDir, { recursive: true });
+    }
+  });
+
+  test("rejects server without command or url", async () => {
+    const tmpDir = await mkdtemp(join(tmpdir(), "mcpcli-test-"));
+    try {
+      await Bun.write(
+        join(tmpDir, "servers.json"),
+        JSON.stringify({ mcpServers: { bad: { name: "nope" } } }),
+      );
+      await expect(loadConfig({ configFlag: tmpDir })).rejects.toThrow(
+        'must have either "command"',
+      );
+    } finally {
+      await rm(tmpDir, { recursive: true });
+    }
+  });
+});
+
+describe("saveAuth / saveSearchIndex", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), "mcpcli-test-"));
+  });
+
+  afterEach(async () => {
+    await rm(tmpDir, { recursive: true });
+  });
+
+  test("saves and reloads auth.json", async () => {
+    await saveAuth(tmpDir, {
+      test: {
+        tokens: { access_token: "abc", token_type: "bearer" },
+        expires_at: "2099-01-01T00:00:00Z",
+      },
+    });
+
+    const raw = await Bun.file(join(tmpDir, "auth.json")).json();
+    expect(raw.test.tokens.access_token).toBe("abc");
+  });
+
+  test("saves and reloads search.json", async () => {
+    await saveSearchIndex(tmpDir, {
+      version: 1,
+      indexed_at: "2026-01-01T00:00:00Z",
+      embedding_model: "claude",
+      tools: [
+        {
+          server: "s",
+          tool: "t",
+          description: "d",
+          scenarios: [],
+          keywords: [],
+          embedding: [],
+        },
+      ],
+    });
+
+    const raw = await Bun.file(join(tmpDir, "search.json")).json();
+    expect(raw.tools).toHaveLength(1);
+    expect(raw.tools[0].server).toBe("s");
+  });
+});

package/.claude/worktrees/elastic-jennings/test/fixtures/auth.json

@@ -0,0 +1,10 @@
+{
+  "github": {
+    "tokens": {
+      "access_token": "gho_test123",
+      "token_type": "bearer",
+      "refresh_token": "ghr_refresh456"
+    },
+    "expires_at": "2099-01-01T00:00:00Z"
+  }
+}

package/.claude/worktrees/elastic-jennings/test/fixtures/mock-config/servers.json

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "mock": {
+      "command": "bun",
+      "args": ["run", "test/fixtures/mock-server.ts"]
+    }
+  }
+}

package/.claude/worktrees/elastic-jennings/test/fixtures/mock-server.ts

@@ -0,0 +1,113 @@
+#!/usr/bin/env bun
+
+/**
+ * Minimal MCP server over stdio for testing.
+ * Implements just enough of the protocol to support initialize, listTools, and callTool.
+ */
+
+import { readFileSync } from "fs";
+
+let buffer = "";
+
+process.stdin.setEncoding("utf-8");
+process.stdin.on("data", (chunk: string) => {
+  buffer += chunk;
+  processBuffer();
+});
+
+function processBuffer() {
+  while (true) {
+    const newlineIndex = buffer.indexOf("\n");
+    if (newlineIndex === -1) break;
+    const line = buffer.slice(0, newlineIndex).trim();
+    buffer = buffer.slice(newlineIndex + 1);
+    if (line) handleMessage(line);
+  }
+}
+
+function handleMessage(line: string) {
+  let msg: { jsonrpc: string; id?: number; method: string; params?: unknown };
+  try {
+    msg = JSON.parse(line);
+  } catch {
+    return;
+  }
+
+  if (msg.method === "initialize") {
+    respond(msg.id, {
+      protocolVersion: "2025-03-26",
+      capabilities: { tools: {} },
+      serverInfo: { name: "mock-server", version: "1.0.0" },
+    });
+  } else if (msg.method === "notifications/initialized") {
+    // No response needed for notifications
+  } else if (msg.method === "tools/list") {
+    respond(msg.id, {
+      tools: [
+        {
+          name: "echo",
+          description: "Echoes back the input",
+          inputSchema: {
+            type: "object",
+            properties: {
+              message: { type: "string", description: "Message to echo" },
+            },
+            required: ["message"],
+          },
+        },
+        {
+          name: "add",
+          description: "Adds two numbers",
+          inputSchema: {
+            type: "object",
+            properties: {
+              a: { type: "number" },
+              b: { type: "number" },
+            },
+            required: ["a", "b"],
+          },
+        },
+        {
+          name: "secret",
+          description: "A secret tool",
+          inputSchema: { type: "object" },
+        },
+        {
+          name: "noop",
+          description: "A tool that takes no arguments",
+          inputSchema: { type: "object", properties: {} },
+        },
+      ],
+    });
+  } else if (msg.method === "tools/call") {
+    const params = msg.params as { name: string; arguments?: Record<string, unknown> };
+    if (params.name === "echo") {
+      respond(msg.id, {
+        content: [{ type: "text", text: String(params.arguments?.message ?? "") }],
+      });
+    } else if (params.name === "add") {
+      const a = Number(params.arguments?.a ?? 0);
+      const b = Number(params.arguments?.b ?? 0);
+      respond(msg.id, {
+        content: [{ type: "text", text: String(a + b) }],
+      });
+    } else if (params.name === "noop") {
+      respond(msg.id, {
+        content: [{ type: "text", text: "ok" }],
+      });
+    } else {
+      respond(msg.id, {
+        content: [{ type: "text", text: `unknown tool: ${params.name}` }],
+        isError: true,
+      });
+    }
+  } else if (msg.method === "ping") {
+    respond(msg.id, {});
+  }
+}
+
+function respond(id: number | undefined, result: unknown) {
+  if (id === undefined) return;
+  const response = JSON.stringify({ jsonrpc: "2.0", id, result });
+  process.stdout.write(response + "\n");
+}

package/.claude/worktrees/elastic-jennings/test/fixtures/search.json

@@ -0,0 +1,15 @@
+{
+  "version": 1,
+  "indexed_at": "2026-03-03T10:00:00Z",
+  "embedding_model": "claude",
+  "tools": [
+    {
+      "server": "github",
+      "tool": "search_repositories",
+      "description": "Search for repositories on GitHub",
+      "scenarios": ["Find open source projects"],
+      "keywords": ["search", "repo", "github"],
+      "embedding": [0.1, 0.2, 0.3]
+    }
+  ]
+}

package/.claude/worktrees/elastic-jennings/test/fixtures/servers.json

@@ -0,0 +1,18 @@
+{
+  "mcpServers": {
+    "filesystem": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-filesystem", "."],
+      "env": { "API_KEY": "${TEST_API_KEY}" }
+    },
+    "github": {
+      "url": "https://mcp.github.com"
+    },
+    "internal": {
+      "url": "https://mcp.internal.example.com",
+      "headers": { "Authorization": "Bearer ${TEST_TOKEN}" },
+      "allowedTools": ["read_*"],
+      "disabledTools": ["read_secret"]
+    }
+  }
+}

package/.claude/worktrees/elastic-jennings/test/integration/stdio-server.test.ts

@@ -0,0 +1,149 @@
+import { describe, test, expect } from "bun:test";
+import { join } from "path";
+
+const CLI = join(import.meta.dir, "../../src/cli.ts");
+const CONFIG = join(import.meta.dir, "../fixtures/mock-config");
+
+/**
+ * Integration tests proving that mcpcli can connect to a local stdio MCP server,
+ * discover its tools, inspect schemas, and execute tools end-to-end.
+ */
+
+function run(...args: string[]) {
+  return Bun.spawn(["bun", "run", CLI, "-c", CONFIG, "--json", ...args], {
+    stdout: "pipe",
+    stderr: "pipe",
+    cwd: join(import.meta.dir, "../.."),
+  });
+}
+
+async function runAndParse<T = unknown>(...args: string[]): Promise<T> {
+  const proc = run(...args);
+  const exitCode = await proc.exited;
+  const stdout = await new Response(proc.stdout).text();
+  if (exitCode !== 0) {
+    const stderr = await new Response(proc.stderr).text();
+    throw new Error(`mcpcli exited with ${exitCode}: ${stderr}\n${stdout}`);
+  }
+  return JSON.parse(stdout) as T;
+}
+
+describe("stdio MCP server integration", () => {
+  test("lists all tools from the mock stdio server", async () => {
+    const tools = await runAndParse<{ server: string; tool: string }[]>();
+    expect(tools).toBeInstanceOf(Array);
+    expect(tools.length).toBe(4);
+
+    const names = tools.map((t) => t.tool);
+    expect(names).toContain("echo");
+    expect(names).toContain("add");
+    expect(names).toContain("secret");
+    expect(names).toContain("noop");
+
+    // Every tool should be from the "mock" server
+    for (const t of tools) {
+      expect(t.server).toBe("mock");
+    }
+  });
+
+  test("lists tools with descriptions", async () => {
+    const tools = await runAndParse<{ server: string; tool: string; description: string }[]>("-d");
+    const echo = tools.find((t) => t.tool === "echo");
+    expect(echo).toBeDefined();
+    expect(echo!.description).toContain("Echoes");
+  });
+
+  test("inspects a specific server to list its tools", async () => {
+    const result = await runAndParse<{ server: string; tools: { name: string }[] }>("info", "mock");
+    expect(result.server).toBe("mock");
+    expect(result.tools.length).toBe(4);
+  });
+
+  test("inspects a specific tool to show its schema", async () => {
+    const result = await runAndParse<{
+      server: string;
+      tool: string;
+      inputSchema: { properties: Record<string, unknown> };
+    }>("info", "mock", "echo");
+    expect(result.server).toBe("mock");
+    expect(result.tool).toBe("echo");
+    expect(result.inputSchema.properties).toHaveProperty("message");
+  });
+
+  test("calls echo tool and gets response", async () => {
+    const result = await runAndParse<{ content: { type: string; text: string }[] }>(
+      "exec",
+      "mock",
+      "echo",
+      '{"message":"hello world"}',
+    );
+    expect(result.content).toBeInstanceOf(Array);
+    expect(result.content[0]!.text).toBe("hello world");
+  });
+
+  test("calls add tool with numeric arguments", async () => {
+    const result = await runAndParse<{ content: { type: string; text: string }[] }>(
+      "exec",
+      "mock",
+      "add",
+      '{"a":10,"b":32}',
+    );
+    expect(result.content[0]!.text).toBe(42);
+  });
+
+  test("validates tool input and rejects missing required fields", async () => {
+    const proc = run("exec", "mock", "echo", "{}");
+    const exitCode = await proc.exited;
+    const stderr = await new Response(proc.stderr).text();
+    expect(exitCode).toBe(1);
+    expect(stderr).toContain("message");
+  });
+
+  test("validates tool input and rejects wrong types", async () => {
+    const proc = run("exec", "mock", "add", '{"a":"not a number","b":1}');
+    const exitCode = await proc.exited;
+    const stderr = await new Response(proc.stderr).text();
+    expect(exitCode).toBe(1);
+    expect(stderr).toContain("a");
+  });
+
+  test("reads tool arguments from stdin", async () => {
+    const proc = Bun.spawn(["bun", "run", CLI, "-c", CONFIG, "--json", "exec", "mock", "echo"], {
+      stdout: "pipe",
+      stderr: "pipe",
+      stdin: "pipe",
+      cwd: join(import.meta.dir, "../.."),
+    });
+    proc.stdin.write('{"message":"from stdin"}');
+    proc.stdin.end();
+    const exitCode = await proc.exited;
+    const stdout = await new Response(proc.stdout).text();
+    expect(exitCode).toBe(0);
+    const result = JSON.parse(stdout) as { content: { text: string }[] };
+    expect(result.content[0]!.text).toBe("from stdin");
+  });
+
+  test("exits with error for unknown server", async () => {
+    const proc = run("exec", "nonexistent", "sometool", "{}");
+    const exitCode = await proc.exited;
+    expect(exitCode).toBe(1);
+  });
+
+  test("MCP_DEBUG=1 enables verbose output on stderr", async () => {
+    const proc = Bun.spawn(
+      ["bun", "run", CLI, "-c", CONFIG, "--json", "exec", "mock", "echo", '{"message":"test"}'],
+      {
+        stdout: "pipe",
+        stderr: "pipe",
+        env: { ...process.env, MCP_DEBUG: "1" },
+        cwd: join(import.meta.dir, "../.."),
+      },
+    );
+    const exitCode = await proc.exited;
+    const stdout = await new Response(proc.stdout).text();
+    expect(exitCode).toBe(0);
+    // Should still produce valid JSON on stdout
+    const result = JSON.parse(stdout);
+    expect(result.content[0]!.text).toBe("test");
+  });
+});

package/.claude/worktrees/elastic-jennings/test/output/formatter.test.ts

@@ -0,0 +1,54 @@
+import { describe, test, expect } from "bun:test";
+import { formatCallResult } from "../../src/output/formatter.ts";
+
+describe("formatCallResult nested JSON parsing", () => {
+  test("parses JSON strings inside text content", () => {
+    const result = {
+      content: [{ type: "text", text: '{"name":"Evan","count":42}' }],
+    };
+    const parsed = JSON.parse(formatCallResult(result, {}));
+    expect(parsed.content[0].text).toEqual({ name: "Evan", count: 42 });
+  });
+
+  test("leaves plain strings as-is", () => {
+    const result = {
+      content: [{ type: "text", text: "hello world" }],
+    };
+    const parsed = JSON.parse(formatCallResult(result, {}));
+    expect(parsed.content[0].text).toBe("hello world");
+  });
+
+  test("parses nested JSON arrays", () => {
+    const result = {
+      content: [{ type: "text", text: "[1, 2, 3]" }],
+    };
+    const parsed = JSON.parse(formatCallResult(result, {}));
+    expect(parsed.content[0].text).toEqual([1, 2, 3]);
+  });
+
+  test("parses numeric strings", () => {
+    const result = {
+      content: [{ type: "text", text: "42" }],
+    };
+    const parsed = JSON.parse(formatCallResult(result, {}));
+    expect(parsed.content[0].text).toBe(42);
+  });
+
+  test("handles deeply nested JSON strings", () => {
+    const inner = JSON.stringify({ nested: true });
+    const result = {
+      content: [{ type: "text", text: inner }],
+    };
+    const parsed = JSON.parse(formatCallResult(result, {}));
+    expect(parsed.content[0].text).toEqual({ nested: true });
+  });
+
+  test("preserves non-string values unchanged", () => {
+    const result = {
+      content: [{ type: "text", text: "plain" }],
+      isError: false,
+    };
+    const parsed = JSON.parse(formatCallResult(result, {}));
+    expect(parsed.isError).toBe(false);
+  });
+});

package/.claude/worktrees/elastic-jennings/test/output/logger.test.ts

@@ -0,0 +1,89 @@
+import { describe, test, expect, beforeEach, afterEach, spyOn, type Mock } from "bun:test";
+import { logger } from "../../src/output/logger.ts";
+
+describe("logger", () => {
+  let stderrSpy: Mock<typeof process.stderr.write>;
+  let origIsTTY: boolean | undefined;
+
+  beforeEach(() => {
+    origIsTTY = process.stderr.isTTY;
+    Object.defineProperty(process.stderr, "isTTY", { value: true, writable: true });
+    stderrSpy = spyOn(process.stderr, "write").mockReturnValue(true);
+    logger.configure({});
+  });
+
+  afterEach(() => {
+    stderrSpy.mockRestore();
+    Object.defineProperty(process.stderr, "isTTY", { value: origIsTTY, writable: true });
+  });
+
+  test("info() writes dim text to stderr", () => {
+    logger.info("hello");
+    expect(stderrSpy).toHaveBeenCalled();
+    const written = stderrSpy.mock.calls.map((c) => String(c[0])).join("");
+    expect(written).toContain("hello");
+  });
+
+  test("warn() writes to stderr", () => {
+    logger.warn("caution");
+    expect(stderrSpy).toHaveBeenCalled();
+    const written = stderrSpy.mock.calls.map((c) => String(c[0])).join("");
+    expect(written).toContain("caution");
+  });
+
+  test("error() writes to stderr", () => {
+    logger.error("failure");
+    expect(stderrSpy).toHaveBeenCalled();
+    const written = stderrSpy.mock.calls.map((c) => String(c[0])).join("");
+    expect(written).toContain("failure");
+  });
+
+  test("info() is suppressed in JSON mode", () => {
+    logger.configure({ json: true });
+    logger.info("hidden");
+    expect(stderrSpy).not.toHaveBeenCalled();
+  });
+
+  test("error() still writes in JSON mode", () => {
+    logger.configure({ json: true });
+    logger.error("visible");
+    expect(stderrSpy).toHaveBeenCalled();
+    const written = stderrSpy.mock.calls.map((c) => String(c[0])).join("");
+    expect(written).toContain("visible");
+  });
+
+  test("info() is suppressed when stderr is not a TTY", () => {
+    Object.defineProperty(process.stderr, "isTTY", { value: false, writable: true });
+    logger.configure({});
+    logger.info("hidden");
+    expect(stderrSpy).not.toHaveBeenCalled();
+  });
+
+  test("debug() only writes when verbose is enabled", () => {
+    logger.configure({});
+    logger.debug("no-show");
+    expect(stderrSpy).not.toHaveBeenCalled();
+
+    logger.configure({ verbose: true });
+    logger.debug("show-me");
+    expect(stderrSpy).toHaveBeenCalled();
+    const written = stderrSpy.mock.calls.map((c) => String(c[0])).join("");
+    expect(written).toContain("show-me");
+  });
+
+  test("writeRaw() writes to stderr without formatting", () => {
+    logger.writeRaw("raw output\n");
+    expect(stderrSpy).toHaveBeenCalled();
+    const written = stderrSpy.mock.calls.map((c) => String(c[0])).join("");
+    expect(written).toBe("raw output\n");
+  });
+
+  test("startSpinner() returns no-op in JSON mode", () => {
+    logger.configure({ json: true });
+    const spinner = logger.startSpinner("test");
+    // Should not throw
+    spinner.update("x");
+    spinner.success("y");
+    expect(stderrSpy).not.toHaveBeenCalled();
+  });
+});

package/.claude/worktrees/elastic-jennings/test/search/indexer.test.ts

@@ -0,0 +1,32 @@
+import { describe, test, expect } from "bun:test";
+import { extractKeywords, generateScenarios } from "../../src/search/indexer.ts";
+
+describe("extractKeywords", () => {
+  test("splits on underscores", () => {
+    expect(extractKeywords("Gmail_SendEmail")).toEqual(["gmail", "send", "email"]);
+  });
+
+  test("splits camelCase", () => {
+    expect(extractKeywords("sendMessage")).toEqual(["send", "message"]);
+  });
+
+  test("splits on hyphens", () => {
+    expect(extractKeywords("create-pull-request")).toEqual(["create", "pull", "request"]);
+  });
+
+  test("filters single-char words", () => {
+    expect(extractKeywords("a_Send_b")).toEqual(["send"]);
+  });
+});
+
+describe("generateScenarios", () => {
+  test("includes description when short", () => {
+    const scenarios = generateScenarios("SendEmail", "Send an email via Gmail");
+    expect(scenarios).toContain("Send an email via Gmail");
+  });
+
+  test("includes keyword phrase from name", () => {
+    const scenarios = generateScenarios("Gmail_SendEmail", "Send an email");
+    expect(scenarios.some((s) => s.includes("gmail"))).toBe(true);
+  });
+});