Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
7.3 KB
Raw Blame
import { describe, expect, test } from "bun:test"
import type { EnterpriseMcpConnectionRequirements } from "@omnirush/enterprise-mcp-client"
import {
  classifyResolveQuery,
  discoveryQualifiesAsMcp,
  matchPresetForQuery,
  normalizeQueryText,
  resolveCandidateUrls,
  suggestConnectionName,
} from "../src/capability-sources/external-mcp-resolve.js"
import { EXTERNAL_MCP_PRESETS } from "../src/capability-sources/external-mcp-presets.js"

describe("classifyResolveQuery", () => {
  test("classifies full URLs", () => {
    expect(classifyResolveQuery("https://mcp.vercel.com/mcp")).toEqual({ kind: "url", url: "https://mcp.vercel.com/mcp" })
    expect(classifyResolveQuery("  http://mcp.internal.example/mcp  ")).toEqual({ kind: "url", url: "http://mcp.internal.example/mcp" })
  })

  test("classifies bare hosts as domains", () => {
    expect(classifyResolveQuery("mcp.vercel.com")).toEqual({ kind: "domain", url: "https://mcp.vercel.com/" })
    expect(classifyResolveQuery("vercel.com/mcp")).toEqual({ kind: "domain", url: "https://vercel.com/mcp" })
  })

  test("classifies product names", () => {
    expect(classifyResolveQuery("vercel")).toEqual({ kind: "name", slug: "vercel" })
    expect(classifyResolveQuery("Google Drive")).toEqual({ kind: "name", slug: "googledrive" })
  })

  test("rejects URLs with credentials or fragments", () => {
    expect(classifyResolveQuery("https://user:[email protected]/mcp").kind).toBe("invalid")
    expect(classifyResolveQuery("https://mcp.example.com/mcp#frag").kind).toBe("invalid")
    expect(classifyResolveQuery("ftp://mcp.example.com").kind).toBe("invalid")
  })

  test("rejects empty, oversized, and unparseable queries", () => {
    expect(classifyResolveQuery("   ").kind).toBe("invalid")
    expect(classifyResolveQuery("a".repeat(201)).kind).toBe("invalid")
    expect(classifyResolveQuery("not a domain. definitely").kind).toBe("invalid")
    expect(classifyResolveQuery("!!!").kind).toBe("invalid")
  })
})

describe("resolveCandidateUrls", () => {
  test("keeps an exact URL first and adds /mcp only for bare roots", () => {
    expect(resolveCandidateUrls({ kind: "url", url: "https://mcp.example.com/custom" }))
      .toEqual(["https://mcp.example.com/custom"])
    expect(resolveCandidateUrls({ kind: "url", url: "https://mcp.example.com/" }))
      .toEqual(["https://mcp.example.com/", "https://mcp.example.com/mcp"])
  })

  test("expands a bare apex domain with the mcp. host convention", () => {
    expect(resolveCandidateUrls({ kind: "domain", url: "https://vercel.com/" })).toEqual([
      "https://vercel.com/",
      "https://vercel.com/mcp",
      "https://mcp.vercel.com/mcp",
    ])
  })

  test("does not re-prefix hosts that already start with mcp.", () => {
    const candidates = resolveCandidateUrls({ kind: "domain", url: "https://mcp.vercel.com/" })
    expect(candidates).toEqual(["https://mcp.vercel.com/", "https://mcp.vercel.com/mcp"])
  })

  test("probes bounded well-known hosts for a bare name, including the .com root", () => {
    expect(resolveCandidateUrls({ kind: "name", slug: "vercel" })).toEqual([
      "https://mcp.vercel.com/mcp",
      "https://mcp.vercel.com/",
      "https://mcp.vercel.dev/mcp",
      "https://mcp.vercel.io/mcp",
      "https://mcp.vercel.ai/mcp",
    ])
  })

  test("never exceeds the candidate limit", () => {
    for (const classification of [
      { kind: "name" as const, slug: "vercel" },
      { kind: "domain" as const, url: "https://vercel.com/" },
      { kind: "url" as const, url: "https://mcp.example.com/" },
    ]) {
      expect(resolveCandidateUrls(classification).length).toBeLessThanOrEqual(5)
    }
  })
})

describe("matchPresetForQuery", () => {
  test("matches by id and display name, case- and punctuation-insensitively", () => {
    expect(matchPresetForQuery("notion", EXTERNAL_MCP_PRESETS)?.presetId).toBe("notion")
    expect(matchPresetForQuery("  Linear ", EXTERNAL_MCP_PRESETS)?.presetId).toBe("linear")
    expect(matchPresetForQuery("CONTEXT7", EXTERNAL_MCP_PRESETS)?.presetId).toBe("context7")
  })

  test("matches by preset URL host for URL and domain queries", () => {
    expect(matchPresetForQuery("https://mcp.notion.com/mcp", EXTERNAL_MCP_PRESETS)?.presetId).toBe("notion")
    expect(matchPresetForQuery("mcp.stripe.com", EXTERNAL_MCP_PRESETS)?.presetId).toBe("stripe")
  })

  test("returns null for unknown names", () => {
    expect(matchPresetForQuery("vercel", EXTERNAL_MCP_PRESETS)).toBeNull()
    expect(matchPresetForQuery("notio", EXTERNAL_MCP_PRESETS)).toBeNull()
  })
})

describe("suggestConnectionName", () => {
  test("strips service prefixes and capitalizes the product label", () => {
    expect(suggestConnectionName("https://mcp.vercel.com/mcp")).toBe("Vercel")
    expect(suggestConnectionName("https://www.example.io/")).toBe("Example")
    expect(suggestConnectionName("https://api.acme.dev/mcp")).toBe("Acme")
    expect(suggestConnectionName("https://granola.ai/mcp")).toBe("Granola")
  })

  test("returns an empty string for unparseable input", () => {
    expect(suggestConnectionName("not a url")).toBe("")
  })
})

describe("normalizeQueryText", () => {
  test("keeps only lowercased letters and digits", () => {
    expect(normalizeQueryText("Google Drive!")).toBe("googledrive")
    expect(normalizeQueryText("Context7")).toBe("context7")
  })
})

function discovery(overrides: {
  initialize: EnterpriseMcpConnectionRequirements["server"]["initialize"]
  authKind: EnterpriseMcpConnectionRequirements["authentication"]["kind"]
  status?: EnterpriseMcpConnectionRequirements["status"]
}): EnterpriseMcpConnectionRequirements {
  return {
    status: overrides.status ?? "ready",
    server: { url: "https://mcp.example.com/mcp", initialize: overrides.initialize },
    authentication: {
      kind: overrides.authKind,
      authorizationServers: [],
      requiredScopes: [],
      recommendedScopes: [],
      refreshSupport: "unknown",
      availableRegistrationMethods: ["pre_registered"],
      recommendedRegistrationMethod: "pre_registered",
    },
    tools: { visibility: "unavailable" },
    manualRequirements: [],
    warnings: [],
  }
}

describe("discoveryQualifiesAsMcp", () => {
  test("accepts open servers and OAuth-protected servers", () => {
    expect(discoveryQualifiesAsMcp(discovery({ initialize: "succeeded", authKind: "none" }), { guessed: true })).toBe(true)
    expect(discoveryQualifiesAsMcp(discovery({ initialize: "authentication_required", authKind: "oauth" }), { guessed: true })).toBe(true)
  })

  test("rejects a bare 401 on guessed hosts but accepts it for explicit URLs", () => {
    const bearer = discovery({ initialize: "authentication_required", authKind: "manual_bearer" })
    expect(discoveryQualifiesAsMcp(bearer, { guessed: true })).toBe(false)
    expect(discoveryQualifiesAsMcp(bearer, { guessed: false })).toBe(true)
  })

  test("accepts a failed initialize when OAuth resource metadata marks it ready (Vercel)", () => {
    expect(discoveryQualifiesAsMcp(discovery({ initialize: "failed", authKind: "oauth", status: "ready" }), { guessed: true })).toBe(true)
  })

  test("rejects failed initializes without OAuth evidence", () => {
    expect(discoveryQualifiesAsMcp(discovery({ initialize: "failed", authKind: "unknown", status: "unreachable" }), { guessed: false })).toBe(false)
    expect(discoveryQualifiesAsMcp(discovery({ initialize: "failed", authKind: "unknown", status: "unsupported" }), { guessed: true })).toBe(false)
  })
})