Skip to content

armgit / eve

Public Imported from GitHub
0

The Open Framework for Building Agents

10.5 KB
Raw Blame
import { readFileSync } from "node:fs";

import { describe, expect, it, vi } from "vitest";

import {
  buildConnectionInstall,
  buildConnectionSetup,
  renderConnectionVariants,
} from "./connection-setup";
import { getIntegration } from "./data";
import { integrationMarkdown } from "./discovery";
import sentConnection from "../../registry/connections/sent";

// Connect's runtime pulls in channel auth; these tests exercise only the authored approval policy.
vi.mock("@vercel/connect/eve", () => ({
  connect: () => ({ getToken: async () => ({ token: "" }) }),
}));

describe("Browser Use connection setup", () => {
  it("generates server-side header authentication without Connect", () => {
    const integration = getIntegration("browser-use")!;
    const setup = buildConnectionSetup(integration);
    const quickStart = setup.variants["mcp:apiKey"];

    expect(quickStart).toContain('"x-browser-use-api-key": process.env.BROWSER_USE_API_KEY!');
    expect(quickStart).not.toContain("@vercel/connect");
    expect(buildConnectionInstall(integration)).toContain("eve add connection/browser-use");
    expect(renderConnectionVariants(setup, setup.configureVariants)).toContain(
      "BROWSER_USE_API_KEY=your_api_key",
    );
  });

  it("keeps Connect setup for OAuth connections", () => {
    const integration = getIntegration("linear")!;
    const quickStart = buildConnectionSetup(integration).variants["mcp:user"];

    expect(quickStart).toContain("@vercel/connect/eve");
    expect(buildConnectionInstall(integration)).toContain("eve add connection/linear");
  });
});

describe("Firecrawl connection setup", () => {
  it("renders bearer authentication for cost-sensitive tools", () => {
    const integration = getIntegration("firecrawl")!;

    expect(integration.quickStart).toContain(
      "Authorization: `Bearer ${process.env.FIRECRAWL_API_KEY!}`",
    );
    expect(buildConnectionInstall(integration)).toContain("eve add connection/firecrawl");
  });

  it("shows the installed connection file in the gallery", () => {
    const source = readFileSync(
      new URL("../../registry/connections/firecrawl.ts", import.meta.url),
      "utf8",
    );

    expect(getIntegration("firecrawl")!.quickStart).toContain(source.trim());
  });
});

describe("Agentcard connection setup", () => {
  it("uses the standard connector name for the native Vercel Connect service", () => {
    const integration = getIntegration("agentcard")!;
    const setup = buildConnectionSetup(integration);
    const quickStart = setup.variants["mcp:user"];

    expect(quickStart).toContain("Agentcard: the agent's wallet.");
    expect(quickStart).toContain('auth: connect("agentcard")');
    expect(quickStart).not.toContain("AGENTCARD_CONNECTOR");
    expect(setup.configureVariants["mcp:user"]).toContain("vercel connect create agentcard");
    expect(setup.configureVariants["mcp:user"]).not.toContain("--name");
  });
});

describe("Context connection setup", () => {
  it("keeps the connector UID separate from its creation arguments", () => {
    const integration = getIntegration("context")!;
    const setup = buildConnectionSetup(integration);

    expect(setup.variants["mcp:user"]).toContain('auth: connect("context")');
    expect(setup.configureVariants["mcp:user"]).toContain(
      "vercel connect create mcp.context.dev --name context",
    );
  });
});

describe("FLORA connection setup", () => {
  it("uses the published MCP URL, Connect connector name, and approval gate", () => {
    const integration = getIntegration("flora")!;
    const setup = buildConnectionSetup(integration);

    expect(setup.variants["mcp:user"]).toContain('url: "https://agents.flora.ai/mcp"');
    expect(setup.variants["mcp:user"]).toContain('auth: connect("agents.flora.ai/flora")');
    expect(setup.configureVariants["mcp:user"]).toContain(
      "vercel connect create agents.flora.ai/mcp --name flora",
    );
    expect(integrationMarkdown(integration)).toContain("approval: always()");
  });

  it("shows the installed connection file in the gallery", () => {
    const source = readFileSync(
      new URL("../../registry/connections/flora.ts", import.meta.url),
      "utf8",
    );

    expect(getIntegration("flora")!.quickStart).toContain(source.trim());
  });
});

describe("Sent connection setup", () => {
  it("preserves the installed tool boundary in the gallery setup", () => {
    const integration = getIntegration("sent")!;
    const setup = buildConnectionSetup(integration);
    const quickStart = integration.quickStart!;

    expect(setup.authModes).toEqual(["user"]);
    expect(setup.variants["mcp:user"]).toContain('url: "https://mcp.sent.dm/mcp"');
    expect(setup.variants["mcp:user"]).toContain('auth: connect("sent")');
    expect(setup.configureVariants["mcp:user"]).toContain(
      "vercel connect create mcp.sent.dm --name sent",
    );
    expect(buildConnectionInstall(integration)).toContain("eve add connection/sent");
    expect(quickStart).toContain("approval: ({ toolName }) =>");
    expect(quickStart).toContain('? "user-approval"');
    expect(quickStart).toContain(': "not-applicable"');

    const { tools } = sentConnection;
    if (!tools || !("allow" in tools)) {
      throw new Error("Sent requires a tool allowlist.");
    }
    for (const toolName of tools.allow) {
      expect(quickStart).toContain(`"${toolName}"`);
    }

    expect(integrationMarkdown(integration)).toContain(quickStart);
  });
});

describe("Neon connection setup", () => {
  it("generates the registry install and Vercel Connect configuration", () => {
    const integration = getIntegration("neon")!;
    const setup = buildConnectionSetup(integration);
    const quickStart = setup.variants["mcp:app"];

    expect(buildConnectionInstall(integration)).toContain("eve add connection/neon");
    expect(quickStart).toContain('url: "https://mcp.neon.tech/mcp"');
    expect(quickStart).toContain('auth: connect({ connector: "neon/neon", principalType: "app" })');
    expect(setup.configureVariants["mcp:app"]).toContain("vercel connect create neon");
    expect(setup.configureVariants["mcp:app"]).not.toContain("--name");
  });
});

describe("Sanity connection setup", () => {
  it("documents automatic MCP registration and user OAuth for Sanity", () => {
    const integration = getIntegration("sanity")!;
    const setup = buildConnectionSetup(integration);

    expect(buildConnectionInstall(integration)).toContain("eve add connection/sanity");
    expect(setup.variants["mcp:user"]).toContain('url: "https://mcp.sanity.io"');
    expect(setup.variants["mcp:user"]).toContain('auth: connect("sanity/sanity")');
    expect(integrationMarkdown(integration)).toContain(
      "vercel connect create sanity --name sanity --connection-method mcp",
    );
  });
});

describe("Shopify connection setup", () => {
  it("uses hand-authored sections without generating authentication variants", () => {
    const integration = getIntegration("shopify")!;
    const setup = buildConnectionSetup(integration);

    expect(setup.protocols).toEqual(["mcp"]);
    expect(setup.authModes).toEqual([]);
    expect(setup.variants).toEqual({});
    expect(setup.configureVariants).toEqual({});
    expect(integration.quickStart).toContain("defineMcpClientConnection");
    expect(integration.quickStart).toContain('process.env.EVE_DEV === "1"');
    expect(integration.quickStart).not.toContain("process.env.NODE_ENV");
    expect(integration.configure).toContain("SHOPIFY_STORE_DOMAIN");
    expect(integration.configure).not.toContain("UCP_AGENT_PROFILE_URL");
  });
});

describe("Kernel extension setup", () => {
  it("uses Kernel's eve extension with Vercel Connect", () => {
    const integration = getIntegration("kernel")!;

    expect(integration.type).toBe("extension");
    expect(integration.install).toContain("eve add extension/kernel");
    expect(integration.quickStart).toContain('kernel({ connect: "kernel/kernel-mcp" })');
    expect(integration.configure).toContain("KERNEL_API_KEY");
    expect(integration.relatedResources?.map((resource) => resource.href)).toEqual([
      "https://vercel.com/kb/guide/build-a-browser-agent",
      "https://vercel.com/kb/guide/software-factory-browser",
    ]);
  });
});

describe("Nimble extension setup", () => {
  it("documents the API-key mount and approval-gated billable-run boundary", () => {
    const integration = getIntegration("nimble")!;

    expect(integration.type).toBe("extension");
    expect(integration.install).toContain("eve add extension/nimble");
    expect(integration.quickStart).toContain("NIMBLE_API_KEY");
    expect(integration.quickStart).toContain('import nimble from "@nimble-way/eve"');
    expect(integration.quickStart).toContain("agent/extensions/nimble/extension.ts");
    expect(integration.quickStart).toContain("require approval for every Agent API run");
    expect(integration.configure).toContain("untrusted third-party content");
    expect(integration.configure).toContain("billable, non-idempotent");
    expect(integration.configure).toContain("requires approval for every call");
  });
});

describe("Vercel MCP connection setup", () => {
  it("offers user OAuth and shared app credential setup", () => {
    const integration = getIntegration("vercel")!;
    const setup = buildConnectionSetup(integration);
    const userQuickStart = setup.variants["mcp:user"];
    const appQuickStart = setup.variants["mcp:app"];

    expect(setup.authModes).toEqual(["user", "app"]);
    expect(userQuickStart).toContain('url: "https://mcp.vercel.com"');
    expect(userQuickStart).toContain('auth: connect("vercel")');
    expect(appQuickStart).toContain(
      'auth: connect({ connector: "vercel/your-connector", principalType: "app" })',
    );
    const userConfigure = setup.configureVariants["mcp:user"];
    const appConfigure = setup.configureVariants["mcp:app"];

    expect(userConfigure).toContain("vercel connect create vercel --name vercel");
    expect(userConfigure).toContain("Select None");
    expect(userConfigure).not.toContain("create api-key");
    expect(appConfigure).toContain("vercel connect create api-key --name vercel");
    expect(appConfigure).not.toContain("Select None");
    expect(appConfigure).toContain(
      "[Vercel token](https://vercel.com/kb/guide/how-do-i-use-a-vercel-api-access-token)",
    );
    expect(appConfigure).toContain("copy the returned connector UID into the App example");
    expect(appConfigure).toContain("token still belongs to the user who created it");

    const configure = renderConnectionVariants(setup, setup.configureVariants);
    expect(configure).toContain("### MCP · User");
    expect(configure).toContain("### MCP · App");
    expect(configure).not.toContain("vercel connect attach");
  });
});