Skip to content

armgit / qm

Public Imported from GitHub
0

Multiplayer agent harness for work.

10.1 KB
Raw Blame
import "./support/auto-fake-sprites.ts";
import { test } from "node:test";
import assert from "node:assert/strict";
import { mkdtemp, rm } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { once } from "node:events";
import { createServer } from "node:http";
import type { AddressInfo } from "node:net";
import { createInsecureTestServer } from "../src/api/server.ts";
import { buildApp } from "./support/build-app.ts";
import { testConfig } from "./support/test-config.ts";
import { createMcpServerStore, type McpServer } from "../src/mcp/mcp-server-store.ts";
import { createMemoryMap } from "../src/persistence/durable-map.ts";
import { startMcpTestServer } from "./support/mcp-test-server.ts";

const ADMIN = { "content-type": "application/json", "x-admin-actor": "admin-alice@default-org" };

test("MCP admin validates and preserves credential scope, without returning secrets", async (t) => {
  const dir = await mkdtemp(join(tmpdir(), "mcp-admin-"));
  const built = buildApp(testConfig({ dataDir: dir }));
  const store = createMcpServerStore(createMemoryMap<McpServer>());
  const server = createInsecureTestServer(built.app, {
    admin: built.admin,
    auditLog: built.auditLog,
    mcpServers: store,
  });
  server.listen(0, "127.0.0.1");
  await once(server, "listening");
  t.after(async () => {
    await new Promise<void>((resolve) => server.close(() => resolve()));
    await rm(dir, { recursive: true, force: true });
  });
  const url = `http://127.0.0.1:${(server.address() as AddressInfo).port}/v1/admin/mcp-servers/crm`;
  const put = (body: object, headers = ADMIN) =>
    fetch(url, {
      method: "PUT",
      headers,
      body: JSON.stringify({ url: "https://tools.example.com/mcp", validate: false, ...body }),
    });
  assert.equal((await put({ credentialScope: "other" })).status, 400);
  assert.equal((await put({ credentialScope: "per-user" })).status, 400);
  assert.equal(
    (await put({ credentialScope: "per-user", credentialHost: "accounts.example.com", credentialAccountType: "other" }))
      .status,
    400,
  );
  for (const credentialHost of ["", " accounts.example.com", "accounts.example.com/path", "host@evil", 1]) {
    assert.equal((await put({ credentialScope: "per-user", credentialHost })).status, 400);
  }
  assert.equal(
    (
      await put({
        credentialScope: "per-user",
        credentialHost: "accounts.example.com",
        url: "http://tools.example.com/mcp",
      })
    ).status,
    400,
  );
  assert.equal(
    (
      await put(
        { credentialScope: "per-user", credentialHost: "accounts.example.com" },
        { ...ADMIN, "x-admin-actor": "nobody@default-org" },
      )
    ).status,
    403,
  );
  const saved = await put({
    credentialScope: "per-user",
    credentialHost: "accounts.example.com",
    auth: "bearer",
    bearerToken: "catalog-secret",
    credentialAccountType: "personal",
  });
  assert.equal(saved.status, 200);
  const body = await saved.text();
  assert.doesNotMatch(body, /catalog-secret/);
  assert.equal(JSON.parse(body).server.credentialScope, "per-user");
  assert.equal((await put({ auth: "bearer" })).status, 200);
  assert.equal((await store.get("crm"))?.credentialScope, "per-user");
  assert.equal((await store.get("crm"))?.credentialHost, "accounts.example.com");
  assert.equal((await store.get("crm"))?.credentialAccountType, "personal");
  assert.equal((await store.get("crm"))?.bearerToken, "catalog-secret");
  assert.equal((await put({ credentialScope: "shared" })).status, 200);
  assert.equal((await store.get("crm"))?.credentialScope, "shared");
  assert.equal((await store.get("crm"))?.credentialHost, undefined);
  assert.equal((await store.get("crm"))?.credentialAccountType, undefined);
  assert.equal((await put({ approval: "sometimes" })).status, 400);
  assert.equal((await put({ approval: "all" })).status, 200);
  assert.equal((await store.get("crm"))?.approval, "all");
  assert.equal((await put({})).status, 200);
  assert.equal((await store.get("crm"))?.approval, "all", "an update that omits the policy keeps it");
  assert.equal((await put({ approval: "annotations" })).status, 200);
  assert.equal((await store.get("crm"))?.approval, undefined);
  assert.equal((await put({ attestActor: true })).status, 400);
  assert.equal(
    (await put({ catalog: true, attestActor: true })).status,
    400,
    "an unauthenticated upstream cannot trust the actor",
  );
  assert.equal(
    (
      await put({
        catalog: true,
        attestActor: true,
        auth: "bearer",
        bearerToken: "t",
        credentialScope: "per-user",
        credentialHost: "accounts.example.com",
      })
    ).status,
    400,
    "a per-person token could otherwise assert someone else",
  );
  assert.equal(
    (await put({ catalog: true, attestActor: true, auth: "bearer", bearerToken: "t", credentialScope: "shared" }))
      .status,
    200,
  );
  assert.deepEqual([(await store.get("crm"))?.catalog, (await store.get("crm"))?.attestActor], [true, true]);
});

test("production wiring never uses operator fallback tokens for per-user MCP calls", async (t) => {
  const dir = await mkdtemp(join(tmpdir(), "mcp-wiring-"));
  const previous = process.env.VAULT_TOKEN_ACCOUNTS_EXAMPLE_COM;
  process.env.VAULT_TOKEN_ACCOUNTS_EXAMPLE_COM = "operator-token";
  const built = buildApp(testConfig({ dataDir: dir, egressServiceHosts: ["accounts.example.com"] }));
  const remote = await startMcpTestServer(t, {
    tools: [{ name: "identity", inputSchema: { type: "object" } }],
    call: (_name, _args, authorization) => ({ content: [{ type: "text", text: authorization ?? "" }] }),
  });
  const calls = () => remote.requests.filter((r) => r.rpc === "tools/call").length;
  t.after(async () => {
    built.mcpToolService.close();
    if (previous === undefined) delete process.env.VAULT_TOKEN_ACCOUNTS_EXAMPLE_COM;
    else process.env.VAULT_TOKEN_ACCOUNTS_EXAMPLE_COM = previous;
    await rm(dir, { recursive: true, force: true });
  });
  await built.mcpServers.put({
    id: "crm",
    name: "CRM",
    url: `${remote.url}/mcp`,
    auth: "none",
    credentialScope: "per-user",
    credentialHost: "accounts.example.com",
    readOnly: true,
    enabled: true,
    updatedAt: Date.now(),
    updatedBy: "internal:admin",
  });
  await built.mcpToolService.refresh();
  assert.equal(
    await built.connectorTokens.connectorAccessToken("accounts.example.com", "internal:alice"),
    "operator-token",
  );
  await assert.rejects(built.mcpToolService.call("crm_identity", {}, "internal:alice"), /Connect your account/);
  assert.equal(calls(), 0);
  await built.connectorTokens.setConnectorToken("accounts.example.com", "internal:alice", {
    accessToken: "alice-only",
  });
  assert.equal(await built.mcpToolService.call("crm_identity", {}, "internal:alice"), "Bearer alice-only");
  assert.equal(calls(), 1);
});

test("MCP admin accepts per-user OAuth servers, discovers endpoints from metadata, and never shadows built-in connectors", async (t) => {
  const dir = await mkdtemp(join(tmpdir(), "mcp-admin-oauth-"));
  const built = buildApp(testConfig({ dataDir: dir }));
  const store = createMcpServerStore(createMemoryMap<McpServer>());
  const server = createInsecureTestServer(built.app, {
    admin: built.admin,
    auditLog: built.auditLog,
    mcpServers: store,
  });
  const issuer = createServer((req, res) => {
    const base = `http://127.0.0.1:${(issuer.address() as AddressInfo).port}`;
    const metadata: Record<string, object> = {
      "/.well-known/oauth-authorization-server/id": {
        authorization_endpoint: `${base}/id/authorize`,
        token_endpoint: `${base}/id/token`,
      },
      "/.well-known/oauth-protected-resource/mcp": {
        resource: `${base}/mcp`,
        authorization_servers: [`${base}/id`],
        scopes_supported: ["mcp:write"],
      },
    };
    const meta = metadata[req.url ?? ""];
    if (!meta) return void res.writeHead(404).end();
    res.writeHead(200, { "content-type": "application/json" });
    res.end(JSON.stringify(meta));
  });
  server.listen(0, "127.0.0.1");
  issuer.listen(0, "127.0.0.1");
  await Promise.all([once(server, "listening"), once(issuer, "listening")]);
  t.after(async () => {
    await new Promise<void>((resolve) => server.close(() => resolve()));
    await new Promise<void>((resolve) => issuer.close(() => resolve()));
    await rm(dir, { recursive: true, force: true });
  });
  const issuerUrl = `http://127.0.0.1:${(issuer.address() as AddressInfo).port}`;
  const base = `http://127.0.0.1:${(server.address() as AddressInfo).port}/v1/admin/mcp-servers`;
  const put = (id: string, body: object) =>
    fetch(`${base}/${id}`, {
      method: "PUT",
      headers: ADMIN,
      body: JSON.stringify({ url: `${issuerUrl}/mcp`, auth: "oauth-user", ...body }),
    });

  const undiscoverable = await put("orders", { clientId: "c", url: `${issuerUrl}/elsewhere` });
  assert.equal(undiscoverable.status, 400);
  assert.match(((await undiscoverable.json()) as { message: string }).message, /discovery: .*HTTP 404/);
  assert.equal((await put("github", { clientId: "c" })).status, 400, "built-in connector ids are reserved");
  assert.equal((await put("orders", { clientId: "c", credentialHost: "github.com" })).status, 400);
  assert.equal((await put("orders", { clientId: "c", oauthTokenUrl: "http://id.example.com/token" })).status, 400);

  assert.equal((await put("orders", { clientId: " c " })).status, 200);
  const record = (await store.get("orders"))!;
  assert.equal(record.credentialScope, "per-user");
  assert.equal(record.credentialHost, "127.0.0.1");
  assert.equal(record.clientId, "c");
  assert.equal(record.oauthAuthorizeUrl, `${issuerUrl}/id/authorize`);
  assert.equal(record.oauthTokenUrl, `${issuerUrl}/id/token`);
  assert.deepEqual(record.oauthScopes, ["mcp:write"]);
  assert.equal(record.clientSecret, undefined);

  assert.equal(
    (
      await put("manual", {
        clientId: "c",
        url: "https://tools.example.com/mcp",
        oauthAuthorizeUrl: "https://id.example.com/authorize",
        oauthTokenUrl: "https://id.example.com/token",
        oauthScopes: "a b",
      })
    ).status,
    200,
    "explicit endpoints skip discovery",
  );
  assert.deepEqual((await store.get("manual"))!.oauthScopes, ["a", "b"]);
});