sailfork / t3code-github / packages/ shared/ src/ mcpApp.test.ts

import * as NodeVM from "node:vm";
import { describe, expect, it } from "vite-plus/test";

import {
  injectMcpAppCsp,
  injectMcpAppThemeBootstrap,
  injectMcpAppCookieBootstrap,
  mcpAppContentSecurityPolicy,
  mcpAppToolCallableByApp,
  mcpAppToolResourceUri,
  readMcpAppCsp,
  readMcpAppReference,
} from "./mcpApp.ts";

describe("mcpAppContentSecurityPolicy", () => {
  it("blocks the network and T3's own origin when the app declares nothing", () => {
    const policy = mcpAppContentSecurityPolicy(undefined);
    expect(policy).toContain("default-src 'none'");
    expect(policy).toContain("connect-src 'none'");
    expect(policy).toContain("frame-src 'none'");
    expect(policy).not.toContain("'self'");
  });

  it("allows exactly the declared origins", () => {
    const policy = mcpAppContentSecurityPolicy({
      connectDomains: ["https://api.weather.test"],
      resourceDomains: ["https://*.cdn.test"],
    });
    expect(policy).toContain("connect-src https://api.weather.test");
    expect(policy).toContain("script-src 'unsafe-inline' https://*.cdn.test");
    expect(policy).toContain("img-src data: blob: https://*.cdn.test");
  });
});

describe("injectMcpAppCsp", () => {
  it("puts the policy after the doctype and ahead of every script", () => {
    const html = "<!DOCTYPE html><html><head><script>x()</script></head></html>";
    const injected = injectMcpAppCsp(html, undefined);
    expect(injected.startsWith('<!DOCTYPE html><meta http-equiv="Content-Security-Policy"')).toBe(
      true,
    );
    expect(injected.indexOf("connect-src 'none'")).toBeLessThan(injected.indexOf("<script>"));
    expect(injectMcpAppCsp("<p>hi</p>", undefined).startsWith("<!doctype html><meta")).toBe(true);
  });
});

describe("injectMcpAppThemeBootstrap", () => {
  it("keeps stored CSP before the bootstrap and vendor scripts after it", () => {
    const snapshot = injectMcpAppCsp(
      "<html><head><script>vendor()</script></head></html>",
      undefined,
    );
    const html = injectMcpAppThemeBootstrap(snapshot);
    expect(html.indexOf("Content-Security-Policy")).toBeLessThan(html.indexOf("<script>"));
    expect(html.indexOf("window.addEventListener")).toBeLessThan(html.indexOf("vendor()"));
    expect(html.endsWith(snapshot.slice(snapshot.indexOf("<html>")))).toBe(true);
  });

  it("applies parent initialize and theme changes while ignoring unrelated or invalid messages", () => {
    const html = injectMcpAppThemeBootstrap(injectMcpAppCsp("<p>app</p>", undefined));
    const script = html.slice(html.indexOf("<script>") + 8, html.indexOf("</script>"));
    const parent = {};
    const style = { colorScheme: "normal" };
    let receive: ((event: { source: object; data: unknown }) => void) | undefined;
    NodeVM.runInNewContext(script, {
      window: {
        parent,
        addEventListener: (_type: string, callback: typeof receive) => {
          receive = callback;
        },
      },
      document: { documentElement: { style } },
    });
    const send = (data: unknown, source = parent) => receive?.({ source, data });
    const initialized = { jsonrpc: "2.0", id: 1, result: { hostContext: { theme: "dark" } } };
    send(initialized, {});
    expect(style.colorScheme).toBe("normal");
    send(initialized);
    expect(style.colorScheme).toBe("dark");
    for (const data of [
      null,
      "bad",
      {},
      { ...initialized, jsonrpc: "1.0" },
      { jsonrpc: "2.0", method: "other", params: { theme: "light" } },
      {
        jsonrpc: "2.0",
        method: "ui/notifications/host-context-changed",
        params: { theme: "normal" },
      },
      { jsonrpc: "2.0", result: { hostContext: { theme: "light" } } },
    ])
      send(data);
    expect(style.colorScheme).toBe("dark");
    send({
      jsonrpc: "2.0",
      method: "ui/notifications/host-context-changed",
      params: { theme: "light" },
    });
    expect(style.colorScheme).toBe("light");
    send(initialized);
    expect(style.colorScheme).toBe("dark");
  });
});

describe("readMcpAppCsp", () => {
  it("drops entries that could widen or break the policy", () => {
    expect(
      readMcpAppCsp({
        connectDomains: [
          "https://ok.test",
          "*",
          "'self'",
          "https://evil.test; script-src *",
          "http://localhost:3000",
          "javascript:alert(1)",
        ],
        resourceDomains: "https://not-an-array.test",
      }),
    ).toEqual({ connectDomains: ["https://ok.test", "http://localhost:3000"] });
    expect(readMcpAppCsp({ connectDomains: ["*"] })).toBeUndefined();
  });
});

describe("readMcpAppReference", () => {
  it("requires a ui:// resource and the owning server and tool", () => {
    const reference = {
      attachmentId: "thread-1-abc-html",
      server: "weather",
      tool: "get_weather",
      resourceUri: "ui://weather/dashboard",
    };
    expect(readMcpAppReference(reference)).toEqual(reference);
    expect(readMcpAppReference({ ...reference, resourceUri: "https://x.test" })).toBeUndefined();
    expect(readMcpAppReference({ ...reference, server: "" })).toBeUndefined();
  });
});

describe("tool metadata", () => {
  it("reads the resource URI from either spelling and honors app visibility", () => {
    const uri = "ui://weather/card.html";
    expect(mcpAppToolResourceUri({ ui: { resourceUri: uri } })).toBe(uri);
    expect(
      mcpAppToolResourceUri({ ui: { visibility: ["model", "app"] }, "ui/resourceUri": uri }),
    ).toBe(uri);
    expect(
      mcpAppToolResourceUri({ ui: { resourceUri: "https://weather/card.html" } }),
    ).toBeUndefined();
    expect(mcpAppToolCallableByApp(undefined)).toBe(true);
    expect(mcpAppToolCallableByApp({ ui: { visibility: ["model"] } })).toBe(false);
    expect(mcpAppToolCallableByApp({ ui: { visibility: ["model", "app"] } })).toBe(true);
  });
});

describe("mcpAppFromToolItem", () => {
  it("reads the app from both the stored output and its compact wire form", async () => {
    const { compactDynamicToolOutput, mcpAppFromToolItem } = await import("./toolOutput.ts");
    const app = {
      attachmentId: "thread-1-abc-html",
      server: "weather",
      tool: "get_weather",
      resourceUri: "ui://weather/dashboard",
    };
    const stored = { t3McpApp: app, result: { content: [] } };
    const toolName = "weather.get_weather";
    expect(mcpAppFromToolItem({ toolName, output: stored })).toEqual(app);
    expect(mcpAppFromToolItem({ toolName, output: compactDynamicToolOutput(stored) })).toEqual(app);
  });

  it("ignores a reference naming a server or tool other than the item's own", async () => {
    const { mcpAppFromToolItem } = await import("./toolOutput.ts");
    const forged = {
      t3McpApp: {
        attachmentId: "thread-1-abc-html",
        server: "bank",
        tool: "transfer",
        resourceUri: "ui://bank/app",
      },
    };
    expect(mcpAppFromToolItem({ toolName: "evil.lookup", output: forged })).toBeUndefined();
    expect(mcpAppFromToolItem({ toolName: "bank.transfer", output: forged })).toBeDefined();
    // Claude Code names the same tool `mcp__<server>__<tool>`.
    expect(mcpAppFromToolItem({ toolName: "mcp__bank__transfer", output: forged })).toBeDefined();
    expect(mcpAppFromToolItem({ toolName: "mcp__evil__transfer", output: forged })).toBeUndefined();
    const connector = { t3McpApp: { ...forged.t3McpApp, server: "claude.ai Asana (Beta)" } };
    expect(
      mcpAppFromToolItem({ toolName: "mcp__claude_ai_Asana_Beta__transfer", output: connector }),
    ).toBeDefined();
  });

  it("keeps an app whose resource URI is longer than a name", async () => {
    const { compactDynamicToolOutput } = await import("./toolOutput.ts");
    const resourceUri = `ui://weather/${"segment/".repeat(60)}dashboard`;
    const output = compactDynamicToolOutput({
      t3McpApp: {
        attachmentId: "thread-1-abc-html",
        server: "weather",
        tool: "get_weather",
        resourceUri,
      },
    });
    expect(output?.t3McpApp?.resourceUri).toBe(resourceUri);
  });

  it("keeps the compact app reference within the wire budget", async () => {
    const { compactDynamicToolOutput } = await import("./toolOutput.ts");
    const domains = Array.from(
      { length: 32 },
      (_, index) => `https://${"a".repeat(200)}${index}.test`,
    );
    const output = compactDynamicToolOutput({
      t3McpApp: {
        attachmentId: "thread-1-abc-html",
        server: "weather",
        tool: "get_weather",
        resourceUri: "ui://weather/dashboard",
        csp: { connectDomains: domains, resourceDomains: domains },
      },
    });
    expect(new TextEncoder().encode(JSON.stringify(output)).byteLength).toBeLessThanOrEqual(8_192);
    expect(output?.t3McpApp?.server).toBe("weather");
  });
});

describe("MCP App cookie bootstrap", () => {
  const vendor = `<script>document.cookie.split(";");document.cookie="analytics=1";document.root="rendered";</script>`;
  const execute = (html: string, document: object) => {
    for (const script of html.matchAll(/<script>([\s\S]*?)<\/script>/g)) {
      NodeVM.runInNewContext(script[1]!, { document });
    }
  };

  it("lets cookie-reading startup code render in an opaque document without granting storage", () => {
    const blocked = new DOMException("Opaque origin", "SecurityError");
    const prototype = Object.defineProperty({}, "cookie", {
      get() {
        throw blocked;
      },
      set() {
        throw blocked;
      },
    });
    const document = Object.assign(
      Object.create(prototype) as { cookie: string; root: string; indexedDB: unknown },
      { root: "" },
    );
    Object.defineProperty(document, "indexedDB", {
      get() {
        throw blocked;
      },
    });
    const saved = injectMcpAppCsp(vendor, { connectDomains: ["https://analytics.example"] });
    const html = injectMcpAppCookieBootstrap(saved);
    expect(html.indexOf("Content-Security-Policy")).toBeLessThan(html.indexOf("<script>"));
    expect(html).toContain("connect-src https://analytics.example");
    execute(html, document);
    expect(document.root).toBe("rendered");
    expect(document.cookie).toBe("");
    document.cookie = "session=secret";
    expect(document.cookie).toBe("");
    expect(() => document.indexedDB).toThrow(blocked);
    expect(() => Reflect.get(prototype, "cookie")).toThrow(blocked);
  });

  it("leaves other cookie failures unchanged", () => {
    const failure = new TypeError("Unexpected cookie failure");
    const document = Object.defineProperty({}, "cookie", {
      get() {
        throw failure;
      },
    });
    expect(() => execute(injectMcpAppCookieBootstrap(vendor), document)).toThrow(failure);
    expect(() => Reflect.get(document, "cookie")).toThrow(failure);
  });
});