import test from "node:test";
import assert from "node:assert/strict";
import {
  McpRegistry,
  createDefaultMcpRegistry,
  createMcpHandlerShell,
} from "../src/mcp/handlers.js";

test("mcp registries are isolated instances", () => {
  const registryA = createDefaultMcpRegistry();
  const registryB = createDefaultMcpRegistry();

  registryA.register(
    createMcpHandlerShell({
      id: "custom-a",
      description: "custom handler",
      matches: () => false,
    }),
  );

  assert.equal(registryA.listHandlers().some((handler) => handler.id === "custom-a"), true);
  assert.equal(registryB.listHandlers().some((handler) => handler.id === "custom-a"), false);
});

test("mcp registry resolves generic fallback by default", () => {
  const registry = createDefaultMcpRegistry();

  const resolved = registry.resolveServerWithHandler({
    serverName: "local-files",
    server: {
      type: "stdio",
      command: "npx",
      args: ["-y", "@modelcontextprotocol/server-filesystem", "."],
    },
    context: {},
    fullConfig: {
      servers: {},
    },
  });

  assert.equal(resolved.handlerId, "generic");
  assert.ok(resolved.codex);
  assert.ok(resolved.claude);
});

test("mcp registry rejects unknown explicit handlers", () => {
  const registry = new McpRegistry();

  assert.throws(
    () =>
      registry.resolveServerWithHandler({
        serverName: "broken",
        server: {
          type: "http",
          url: "http://localhost:3000/mcp",
          handler: "missing-handler",
        },
        context: {},
        fullConfig: {
          servers: {},
        },
      }),
    /Unknown MCP handler/,
  );
});

test("mcp registry enforces tool clearance on resolved codex tool lists", () => {
  const registry = createDefaultMcpRegistry();

  const resolved = registry.resolveServerWithHandler({
    serverName: "sandbox-tools",
    server: {
      type: "stdio",
      command: "node",
      args: ["server.js"],
      enabled_tools: ["read_file", "write_file", "search"],
      disabled_tools: ["legacy_tool"],
    },
    context: {},
    fullConfig: {
      servers: {},
    },
    toolClearance: {
      allowlist: ["read_file", "search"],
      banlist: ["search", "write_file"],
    },
  });

  assert.ok(resolved.codex);
  assert.deepEqual(resolved.codex.enabled_tools, ["read_file"]);
  assert.deepEqual(resolved.codex.disabled_tools, [
    "legacy_tool",
    "search",
    "write_file",
  ]);
});