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);
});
});