Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
8.8 KB
Raw Blame
const assert = require("node:assert/strict");
const { readFileSync } = require("node:fs");
const test = require("node:test");
const { runInNewContext } = require("node:vm");

const { installWebMcpRuntime } = require("./browser-content-preload.cjs");

function createRealm(policy = null) {
  class TestDocument {
    constructor() {
      this.defaultView = null;
    }
  }
  class TestWindow extends EventTarget {
    constructor(origin) {
      super();
      this.location = { origin };
      this.frames = [];
      this.document = new TestDocument();
      this.document.defaultView = this;
    }
  }

  const previous = {
    Document: globalThis.Document,
    document: globalThis.document,
    isSecureContext: globalThis.isSecureContext,
    window: globalThis.window,
  };
  const window = new TestWindow("https://example.test");
  if (policy) window.__omnirushWebMcpPolicyV1 = { check: async (...args) => {
    assert.deepEqual(args, []);
    return policy;
  } };
  globalThis.Document = TestDocument;
  globalThis.document = window.document;
  globalThis.window = window;
  globalThis.isSecureContext = true;
  assert.equal(installWebMcpRuntime(), true);

  return {
    window,
    restore() {
      for (const [key, value] of Object.entries(previous)) {
        if (value === undefined) delete globalThis[key];
        else globalThis[key] = value;
      }
    },
  };
}

test("imperative WebMCP registration, discovery, execution, and abort unregistration", async () => {
  const realm = createRealm();
  try {
    const registration = new AbortController();
    let observedInput = null;
    let toolChanges = 0;
    realm.window.document.modelContext.ontoolchange = () => { toolChanges += 1; };

    await realm.window.document.modelContext.registerTool({
      name: "read_profile",
      title: "Read profile",
      description: "Read the current signed-in profile.",
      inputSchema: {
        type: "object",
        properties: { detail: { type: "string" } },
        additionalProperties: false,
      },
      annotations: { readOnlyHint: true, untrustedContentHint: true },
      async execute(input, { signal }) {
        assert.equal(signal.aborted, false);
        observedInput = input;
        return { user: "Jalil", detail: input.detail };
      },
    }, { signal: registration.signal });

    const [tool] = await realm.window.document.modelContext.getTools();
    assert.equal(tool.name, "read_profile");
    assert.equal(tool.window, realm.window);
    assert.equal(tool.origin, "https://example.test");
    assert.deepEqual(tool.annotations, { readOnlyHint: true, untrustedContentHint: true });
    assert.equal(
      await realm.window.document.modelContext.executeTool(tool, { detail: "full" }),
      JSON.stringify({ user: "Jalil", detail: "full" }),
    );
    assert.deepEqual(observedInput, { detail: "full" });
    assert.ok(toolChanges >= 1);

    registration.abort();
    await new Promise((resolve) => setTimeout(resolve, 5));
    assert.deepEqual(await realm.window.document.modelContext.getTools(), []);
  } finally {
    realm.restore();
  }
});

test("registration rejects duplicate, malformed, and already-aborted tools", async () => {
  const realm = createRealm();
  try {
    const tool = {
      name: "lookup",
      description: "Look up a record.",
      execute: async () => ({}),
    };
    await realm.window.document.modelContext.registerTool(tool);
    await assert.rejects(
      realm.window.document.modelContext.registerTool(tool),
      (error) => error instanceof DOMException && error.name === "InvalidStateError",
    );
    await assert.rejects(
      realm.window.document.modelContext.registerTool({ ...tool, name: "not allowed!" }),
      (error) => error instanceof DOMException && error.name === "InvalidStateError",
    );
    const aborted = new AbortController();
    aborted.abort();
    await assert.rejects(
      realm.window.document.modelContext.registerTool({ ...tool, name: "other" }, { signal: aborted.signal }),
      (error) => error?.name === "AbortError",
    );
  } finally {
    realm.restore();
  }
});

test("executeTool propagates cancellation to the website callback", async () => {
  const realm = createRealm();
  try {
    let callbackSignal;
    await realm.window.document.modelContext.registerTool({
      name: "wait",
      description: "Wait until canceled.",
      async execute(_input, { signal }) {
        callbackSignal = signal;
        await new Promise((resolve) => signal.addEventListener("abort", resolve, { once: true }));
        return { canceled: signal.aborted };
      },
    });
    const [tool] = await realm.window.document.modelContext.getTools();
    const controller = new AbortController();
    const execution = realm.window.document.modelContext.executeTool(tool, {}, { signal: controller.signal });
    await new Promise((resolve) => setTimeout(resolve, 0));
    controller.abort();
    await assert.rejects(execution, (error) => error?.name === "AbortError");
    assert.equal(callbackSignal.aborted, true);
  } finally {
    realm.restore();
  }
});

test("the page API enforces native frame policy before registering tools", async () => {
  const denied = createRealm({ allowed: false, originKeyed: true });
  try {
    await assert.rejects(
      denied.window.document.modelContext.registerTool({
        name: "blocked",
        description: "Must not register.",
        execute: async () => ({}),
      }),
      (error) => error instanceof DOMException && error.name === "NotAllowedError",
    );
  } finally {
    denied.restore();
  }

  const nonOriginKeyed = createRealm({ allowed: true, originKeyed: false });
  try {
    Object.defineProperty(nonOriginKeyed.window, "originAgentCluster", { get: () => assert.fail("Do not read page-controlled OAC.") });
    Object.defineProperty(nonOriginKeyed.window.document, "domain", { get: () => assert.fail("Do not read page-controlled domain.") });
    await assert.rejects(
      nonOriginKeyed.window.document.modelContext.getTools(),
      (error) => error instanceof DOMException && error.name === "SecurityError",
    );
  } finally {
    nonOriginKeyed.restore();
  }
});

test("the isolated preload exposes only a payload-free check, not a policy-reporting capability", async () => {
  const listeners = new Map();
  const sent = [];
  const invoked = [];
  const exposed = {};
  const child = {};
  const isolatedWindow = { originAgentCluster: false, frames: [child], addEventListener() {} };
  const isolatedDocument = {
    domain: "relaxed.example", baseURI: "https://app.example/", readyState: "loading", addEventListener() {},
    querySelectorAll: () => [
      { contentWindow: {}, src: "https://attacker.example/", getAttribute: () => "tools *" },
      { contentWindow: child, src: "https://child.example/", getAttribute: () => "tools 'src'" },
    ],
  };
  runInNewContext(readFileSync(require.resolve("./browser-content-preload.cjs"), "utf8"), {
    require: () => ({
      ipcRenderer: {
        on: (channel, handler) => listeners.set(channel, handler),
        send: (...args) => sent.push(args),
        invoke: async (...args) => { invoked.push(args); return { originKeyed: false }; },
      },
      contextBridge: {
        exposeInMainWorld: (name, api) => { exposed[name] = api; },
        executeInMainWorld() {},
      },
    }),
    window: isolatedWindow, document: isolatedDocument, location: { hostname: "app.example" }, URL,
  });
  const bridge = exposed.__omnirushWebMcpPolicyV1;
  assert.deepEqual(Object.keys(bridge), ["check"]);
  assert.equal((await bridge.check({ originAgentCluster: true, domainMatchesHost: true })).originKeyed, false);
  assert.deepEqual(invoked, [["omnirush:webmcp:frame-policy"]]);
  const readPolicy = listeners.get("omnirush:webmcp:read-policy");
  readPolicy({}, "native-request", 0);
  assert.equal(sent[0][0], "native-request");
  assert.deepEqual(JSON.parse(JSON.stringify(sent[0][1])), {
    originAgentCluster: false, domainMatchesHost: false,
    embedding: { allow: "tools 'src'", sourceOrigin: "https://child.example" },
  });
  isolatedWindow.originAgentCluster = true;
  isolatedDocument.domain = "app.example";
  readPolicy({}, "fresh-native-request", null);
  assert.deepEqual(JSON.parse(JSON.stringify(sent[1][1])), {
    originAgentCluster: true, domainMatchesHost: true, embedding: null,
  });
});

test("aborting while registration is pending rejects and unregisters atomically", async () => {
  const realm = createRealm();
  try {
    const controller = new AbortController();
    const registration = realm.window.document.modelContext.registerTool({
      name: "pending",
      description: "Pending registration.",
      execute: async () => ({}),
    }, { signal: controller.signal });
    await Promise.resolve();
    controller.abort();
    await assert.rejects(registration, (error) => error?.name === "AbortError");
    assert.deepEqual(await realm.window.document.modelContext.getTools(), []);
  } finally {
    realm.restore();
  }
});