@evantahler/mcpx 0.15.0

package/.claude/worktrees/elastic-jennings/test/commands/add-remove.test.ts

@@ -0,0 +1,253 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { join } from "path";
+import { tmpdir } from "os";
+import { mkdtemp, rm } from "fs/promises";
+
+const CLI = join(import.meta.dir, "../../src/cli.ts");
+
+async function run(args: string[], cwd?: string) {
+  const proc = Bun.spawn(["bun", "run", CLI, ...args], {
+    stdout: "pipe",
+    stderr: "pipe",
+    cwd,
+  });
+  const exitCode = await proc.exited;
+  const stdout = await new Response(proc.stdout).text();
+  const stderr = await new Response(proc.stderr).text();
+  return { exitCode, stdout, stderr };
+}
+
+describe("mcpcli add", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), "mcpcli-add-"));
+  });
+
+  afterEach(async () => {
+    await rm(tmpDir, { recursive: true });
+  });
+
+  test("adds a stdio server", async () => {
+    const { exitCode, stdout } = await run([
+      "-c",
+      tmpDir,
+      "add",
+      "test-server",
+      "--command",
+      "echo",
+      "--args",
+      "hello,world",
+      "--no-index",
+    ]);
+    expect(exitCode).toBe(0);
+    expect(stdout).toContain('Added server "test-server"');
+
+    const servers = await Bun.file(join(tmpDir, "servers.json")).json();
+    expect(servers.mcpServers["test-server"]).toEqual({
+      command: "echo",
+      args: ["hello", "world"],
+    });
+  });
+
+  test("adds an http server", async () => {
+    const { exitCode } = await run([
+      "-c",
+      tmpDir,
+      "add",
+      "my-api",
+      "--url",
+      "https://example.com/mcp",
+      "--header",
+      "Authorization:Bearer tok123",
+      "--no-index",
+    ]);
+    expect(exitCode).toBe(0);
+
+    const servers = await Bun.file(join(tmpDir, "servers.json")).json();
+    expect(servers.mcpServers["my-api"]).toEqual({
+      url: "https://example.com/mcp",
+      headers: { Authorization: "Bearer tok123" },
+    });
+  });
+
+  test("adds a stdio server with env and cwd", async () => {
+    const { exitCode } = await run([
+      "-c",
+      tmpDir,
+      "add",
+      "full-server",
+      "--command",
+      "node",
+      "--args",
+      "index.js",
+      "--env",
+      "KEY=val,FOO=bar",
+      "--cwd",
+      "/tmp",
+      "--no-index",
+    ]);
+    expect(exitCode).toBe(0);
+
+    const servers = await Bun.file(join(tmpDir, "servers.json")).json();
+    expect(servers.mcpServers["full-server"]).toEqual({
+      command: "node",
+      args: ["index.js"],
+      env: { KEY: "val", FOO: "bar" },
+      cwd: "/tmp",
+    });
+  });
+
+  test("adds a server with allowed and disabled tools", async () => {
+    const { exitCode } = await run([
+      "-c",
+      tmpDir,
+      "add",
+      "filtered",
+      "--command",
+      "echo",
+      "--allowed-tools",
+      "read,write",
+      "--disabled-tools",
+      "delete",
+      "--no-index",
+    ]);
+    expect(exitCode).toBe(0);
+
+    const servers = await Bun.file(join(tmpDir, "servers.json")).json();
+    expect(servers.mcpServers["filtered"].allowedTools).toEqual(["read", "write"]);
+    expect(servers.mcpServers["filtered"].disabledTools).toEqual(["delete"]);
+  });
+
+  test("errors if server already exists without --force", async () => {
+    await run(["-c", tmpDir, "add", "dupe", "--command", "echo", "--no-index"]);
+    const { exitCode, stderr } = await run([
+      "-c",
+      tmpDir,
+      "add",
+      "dupe",
+      "--command",
+      "cat",
+      "--no-index",
+    ]);
+    expect(exitCode).not.toBe(0);
+    expect(stderr).toContain("already exists");
+  });
+
+  test("overwrites with --force", async () => {
+    await run(["-c", tmpDir, "add", "dupe", "--command", "echo", "--no-index"]);
+    const { exitCode } = await run([
+      "-c",
+      tmpDir,
+      "add",
+      "dupe",
+      "--command",
+      "cat",
+      "--force",
+      "--no-index",
+    ]);
+    expect(exitCode).toBe(0);
+
+    const servers = await Bun.file(join(tmpDir, "servers.json")).json();
+    expect(servers.mcpServers["dupe"].command).toBe("cat");
+  });
+
+  test("errors if neither --command nor --url", async () => {
+    const { exitCode, stderr } = await run(["-c", tmpDir, "add", "bad"]);
+    expect(exitCode).not.toBe(0);
+    expect(stderr).toContain("Must specify --command");
+  });
+
+  test("errors if both --command and --url", async () => {
+    const { exitCode, stderr } = await run([
+      "-c",
+      tmpDir,
+      "add",
+      "bad",
+      "--command",
+      "echo",
+      "--url",
+      "https://example.com",
+      "--no-index",
+    ]);
+    expect(exitCode).not.toBe(0);
+    expect(stderr).toContain("Cannot specify both");
+  });
+});
+
+describe("mcpcli remove", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), "mcpcli-rm-"));
+  });
+
+  afterEach(async () => {
+    await rm(tmpDir, { recursive: true });
+  });
+
+  test("removes a server", async () => {
+    await run(["-c", tmpDir, "add", "to-remove", "--command", "echo", "--no-index"]);
+    const { exitCode, stdout } = await run(["-c", tmpDir, "remove", "to-remove"]);
+    expect(exitCode).toBe(0);
+    expect(stdout).toContain('Removed server "to-remove"');
+
+    const servers = await Bun.file(join(tmpDir, "servers.json")).json();
+    expect(servers.mcpServers["to-remove"]).toBeUndefined();
+  });
+
+  test("errors on unknown server", async () => {
+    const { exitCode, stderr } = await run(["-c", tmpDir, "remove", "nope"]);
+    expect(exitCode).not.toBe(0);
+    expect(stderr).toContain('Unknown server: "nope"');
+  });
+
+  test("dry-run shows what would happen without changing files", async () => {
+    await run(["-c", tmpDir, "add", "keep-me", "--command", "echo", "--no-index"]);
+    const { exitCode, stdout } = await run(["-c", tmpDir, "remove", "keep-me", "--dry-run"]);
+    expect(exitCode).toBe(0);
+    expect(stdout).toContain("Would remove");
+
+    const servers = await Bun.file(join(tmpDir, "servers.json")).json();
+    expect(servers.mcpServers["keep-me"]).toBeDefined();
+  });
+
+  test("removes auth by default", async () => {
+    // Add a server, then manually write auth for it
+    await run(["-c", tmpDir, "add", "authed", "--url", "https://example.com", "--no-index"]);
+    await Bun.write(
+      join(tmpDir, "auth.json"),
+      JSON.stringify({
+        authed: {
+          tokens: { access_token: "tok", token_type: "bearer" },
+        },
+      }),
+    );
+
+    const { exitCode, stdout } = await run(["-c", tmpDir, "remove", "authed"]);
+    expect(exitCode).toBe(0);
+    expect(stdout).toContain("Removed auth");
+
+    const auth = await Bun.file(join(tmpDir, "auth.json")).json();
+    expect(auth.authed).toBeUndefined();
+  });
+
+  test("--keep-auth preserves auth", async () => {
+    await run(["-c", tmpDir, "add", "authed", "--url", "https://example.com", "--no-index"]);
+    await Bun.write(
+      join(tmpDir, "auth.json"),
+      JSON.stringify({
+        authed: {
+          tokens: { access_token: "tok", token_type: "bearer" },
+        },
+      }),
+    );
+
+    const { exitCode, stdout } = await run(["-c", tmpDir, "remove", "authed", "--keep-auth"]);
+    expect(exitCode).toBe(0);
+    expect(stdout).not.toContain("Removed auth");
+
+    const auth = await Bun.file(join(tmpDir, "auth.json")).json();
+    expect(auth.authed).toBeDefined();
+  });
+});

package/.claude/worktrees/elastic-jennings/test/commands/exec.test.ts

@@ -0,0 +1,105 @@
+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");
+
+function run(...args: string[]) {
+  return Bun.spawn(["bun", "run", CLI, "-c", CONFIG, ...args], {
+    stdout: "pipe",
+    stderr: "pipe",
+    cwd: join(import.meta.dir, "../.."),
+  });
+}
+
+function runWithStdin(stdin: string, ...args: string[]) {
+  const proc = Bun.spawn(["bun", "run", CLI, "-c", CONFIG, ...args], {
+    stdout: "pipe",
+    stderr: "pipe",
+    stdin: "pipe",
+    cwd: join(import.meta.dir, "../.."),
+  });
+  proc.stdin.write(stdin);
+  proc.stdin.end();
+  return proc;
+}
+
+describe("mcpcli exec", () => {
+  test("calls a tool with inline JSON args", async () => {
+    const proc = run("exec", "mock", "echo", '{"message": "hello world"}');
+    const exitCode = await proc.exited;
+    const stdout = await new Response(proc.stdout).text();
+    expect(exitCode).toBe(0);
+
+    const result = JSON.parse(stdout);
+    expect(result.content[0].text).toBe("hello world");
+  });
+
+  test("calls add tool", async () => {
+    const proc = run("exec", "mock", "add", '{"a": 10, "b": 20}');
+    const exitCode = await proc.exited;
+    const stdout = await new Response(proc.stdout).text();
+    expect(exitCode).toBe(0);
+
+    const result = JSON.parse(stdout);
+    expect(result.content[0].text).toBe(30);
+  });
+
+  test("reads args from stdin", async () => {
+    const proc = runWithStdin('{"message": "from stdin"}', "exec", "mock", "echo");
+    const exitCode = await proc.exited;
+    const stdout = await new Response(proc.stdout).text();
+    expect(exitCode).toBe(0);
+
+    const result = JSON.parse(stdout);
+    expect(result.content[0].text).toBe("from stdin");
+  });
+
+  test("calls a tool with no args (no {} required)", async () => {
+    const proc = run("exec", "mock", "noop");
+    const exitCode = await proc.exited;
+    const stdout = await new Response(proc.stdout).text();
+    expect(exitCode).toBe(0);
+
+    const result = JSON.parse(stdout);
+    expect(result.content[0].text).toBe("ok");
+  });
+
+  test("errors on invalid JSON", async () => {
+    const proc = run("exec", "mock", "echo", "not json");
+    const exitCode = await proc.exited;
+    const stderr = await new Response(proc.stderr).text();
+    expect(exitCode).toBe(1);
+    expect(stderr).toContain("Invalid JSON");
+  });
+
+  test("errors on unknown server", async () => {
+    const proc = run("exec", "nonexistent", "tool", "{}");
+    const exitCode = await proc.exited;
+    const stderr = await new Response(proc.stderr).text();
+    expect(exitCode).toBe(1);
+    expect(stderr).toContain("Unknown server");
+  });
+
+  test("validates missing required field", 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 wrong type", 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("number");
+  });
+
+  test("passes validation with correct args", async () => {
+    const proc = run("exec", "mock", "echo", '{"message": "valid"}');
+    const exitCode = await proc.exited;
+    expect(exitCode).toBe(0);
+  });
+});

package/.claude/worktrees/elastic-jennings/test/commands/info.test.ts

@@ -0,0 +1,48 @@
+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");
+
+function run(...args: string[]) {
+  return Bun.spawn(["bun", "run", CLI, "-c", CONFIG, "--json", ...args], {
+    stdout: "pipe",
+    stderr: "pipe",
+    cwd: join(import.meta.dir, "../.."),
+  });
+}
+
+describe("mcpcli info", () => {
+  test("info <server> lists tools for that server", async () => {
+    const proc = run("info", "mock");
+    const exitCode = await proc.exited;
+    const stdout = await new Response(proc.stdout).text();
+    expect(exitCode).toBe(0);
+
+    const result = JSON.parse(stdout);
+    expect(result.server).toBe("mock");
+    expect(result.tools.length).toBeGreaterThan(0);
+    expect(result.tools.map((t: { name: string }) => t.name)).toContain("echo");
+  });
+
+  test("info <server> <tool> shows tool schema", async () => {
+    const proc = run("info", "mock", "echo");
+    const exitCode = await proc.exited;
+    const stdout = await new Response(proc.stdout).text();
+    expect(exitCode).toBe(0);
+
+    const result = JSON.parse(stdout);
+    expect(result.server).toBe("mock");
+    expect(result.tool).toBe("echo");
+    expect(result.inputSchema).toBeDefined();
+    expect(result.inputSchema.properties).toHaveProperty("message");
+  });
+
+  test("info <server> <tool> errors on unknown tool", async () => {
+    const proc = run("info", "mock", "nonexistent");
+    const exitCode = await proc.exited;
+    const stderr = await new Response(proc.stderr).text();
+    expect(exitCode).toBe(1);
+    expect(stderr).toContain("not found");
+  });
+});

package/.claude/worktrees/elastic-jennings/test/commands/list.test.ts

@@ -0,0 +1,39 @@
+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");
+
+function run(...args: string[]) {
+  return Bun.spawn(["bun", "run", CLI, "-c", CONFIG, ...args], {
+    stdout: "pipe",
+    stderr: "pipe",
+    cwd: join(import.meta.dir, "../.."),
+  });
+}
+
+describe("mcpcli (list)", () => {
+  test("lists tools from mock server as JSON when piped", async () => {
+    const proc = run("--json");
+    const exitCode = await proc.exited;
+    const stdout = await new Response(proc.stdout).text();
+    expect(exitCode).toBe(0);
+
+    const tools = JSON.parse(stdout);
+    expect(Array.isArray(tools)).toBe(true);
+    const names = tools.map((t: { tool: string }) => t.tool);
+    expect(names).toContain("echo");
+    expect(names).toContain("add");
+  });
+
+  test("lists tools with descriptions", async () => {
+    const proc = run("--json", "-d");
+    const exitCode = await proc.exited;
+    const stdout = await new Response(proc.stdout).text();
+    expect(exitCode).toBe(0);
+
+    const tools = JSON.parse(stdout);
+    const echo = tools.find((t: { tool: string }) => t.tool === "echo");
+    expect(echo.description).toContain("Echoes");
+  });
+});

package/.claude/worktrees/elastic-jennings/test/commands/skill.test.ts

@@ -0,0 +1,98 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { join } from "path";
+import { tmpdir } from "os";
+import { mkdtemp, rm, readFile, mkdir, writeFile } from "fs/promises";
+
+const CLI = join(import.meta.dir, "../../src/cli.ts");
+
+async function run(args: string[], cwd?: string) {
+  const proc = Bun.spawn(["bun", "run", CLI, ...args], {
+    stdout: "pipe",
+    stderr: "pipe",
+    cwd,
+  });
+  const exitCode = await proc.exited;
+  const stdout = await new Response(proc.stdout).text();
+  const stderr = await new Response(proc.stderr).text();
+  return { exitCode, stdout, stderr };
+}
+
+describe("mcpcli skill install", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), "mcpcli-skill-"));
+  });
+
+  afterEach(async () => {
+    await rm(tmpDir, { recursive: true });
+  });
+
+  test("errors without --claude flag", async () => {
+    const { exitCode, stderr } = await run(["skill", "install"], tmpDir);
+    expect(exitCode).not.toBe(0);
+    expect(stderr).toContain("--claude");
+  });
+
+  test("installs to project directory by default", async () => {
+    const { exitCode, stdout } = await run(["skill", "install", "--claude"], tmpDir);
+    expect(exitCode).toBe(0);
+    expect(stdout).toContain("Installed mcpcli skill (project):");
+
+    const dest = join(tmpDir, ".claude", "skills", "mcpcli.md");
+    const content = await readFile(dest, "utf-8");
+    expect(content).toContain("mcpcli");
+    expect(content).toContain("search");
+  });
+
+  test("installs to global directory with --global", async () => {
+    // We can't write to the real ~/.claude, so just verify the --project path works
+    // and test --global + --project together using --project to confirm both targets
+    const { exitCode, stdout } = await run(["skill", "install", "--claude", "--project"], tmpDir);
+    expect(exitCode).toBe(0);
+    expect(stdout).toContain("project");
+
+    const dest = join(tmpDir, ".claude", "skills", "mcpcli.md");
+    const content = await readFile(dest, "utf-8");
+    expect(content).toContain("mcpcli");
+  });
+
+  test("errors if file already exists without --force", async () => {
+    // First install
+    await run(["skill", "install", "--claude"], tmpDir);
+
+    // Second install should fail
+    const { exitCode, stderr } = await run(["skill", "install", "--claude"], tmpDir);
+    expect(exitCode).not.toBe(0);
+    expect(stderr).toContain("already exists");
+    expect(stderr).toContain("--force");
+  });
+
+  test("overwrites with --force", async () => {
+    // First install
+    await run(["skill", "install", "--claude"], tmpDir);
+
+    // Overwrite the file with garbage to verify it gets replaced
+    const dest = join(tmpDir, ".claude", "skills", "mcpcli.md");
+    await writeFile(dest, "old content", "utf-8");
+
+    // Force install
+    const { exitCode, stdout } = await run(["skill", "install", "--claude", "--force"], tmpDir);
+    expect(exitCode).toBe(0);
+    expect(stdout).toContain("Installed mcpcli skill");
+
+    const content = await readFile(dest, "utf-8");
+    expect(content).not.toBe("old content");
+    expect(content).toContain("mcpcli");
+  });
+
+  test("creates intermediate directories", async () => {
+    // The .claude/skills/ dir shouldn't exist yet in a fresh tmpDir
+    const { exitCode } = await run(["skill", "install", "--claude"], tmpDir);
+    expect(exitCode).toBe(0);
+
+    const dest = join(tmpDir, ".claude", "skills", "mcpcli.md");
+    const content = await readFile(dest, "utf-8");
+    expect(content.length).toBeGreaterThan(0);
+  });
+});

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

@@ -0,0 +1,61 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { interpolateEnvString, interpolateEnv } from "../../src/config/env.ts";
+
+describe("interpolateEnvString", () => {
+  beforeEach(() => {
+    process.env.TEST_VAR = "hello";
+    process.env.TEST_VAR2 = "world";
+  });
+
+  afterEach(() => {
+    delete process.env.TEST_VAR;
+    delete process.env.TEST_VAR2;
+    delete process.env.MCP_STRICT_ENV;
+  });
+
+  test("replaces ${VAR} with env value", () => {
+    expect(interpolateEnvString("${TEST_VAR}")).toBe("hello");
+  });
+
+  test("replaces multiple vars in one string", () => {
+    expect(interpolateEnvString("${TEST_VAR} ${TEST_VAR2}")).toBe("hello world");
+  });
+
+  test("leaves strings without vars untouched", () => {
+    expect(interpolateEnvString("no vars here")).toBe("no vars here");
+  });
+
+  test("throws on missing var in strict mode", () => {
+    expect(() => interpolateEnvString("${DOES_NOT_EXIST}")).toThrow("DOES_NOT_EXIST");
+  });
+
+  test("warns and returns empty on missing var in non-strict mode", () => {
+    process.env.MCP_STRICT_ENV = "false";
+    expect(interpolateEnvString("prefix-${DOES_NOT_EXIST}-suffix")).toBe("prefix--suffix");
+  });
+});
+
+describe("interpolateEnv", () => {
+  beforeEach(() => {
+    process.env.TEST_KEY = "val";
+  });
+
+  afterEach(() => {
+    delete process.env.TEST_KEY;
+  });
+
+  test("interpolates strings in objects recursively", () => {
+    const input = { a: "${TEST_KEY}", b: { c: "x-${TEST_KEY}-y" } };
+    expect(interpolateEnv(input)).toEqual({ a: "val", b: { c: "x-val-y" } });
+  });
+
+  test("interpolates strings in arrays", () => {
+    const input = ["${TEST_KEY}", "plain"];
+    expect(interpolateEnv(input)).toEqual(["val", "plain"]);
+  });
+
+  test("passes through non-string values", () => {
+    const input = { a: 42, b: true, c: null };
+    expect(interpolateEnv(input)).toEqual({ a: 42, b: true, c: null });
+  });
+});