Autoconsent MCP

Instructions

Implementation Reference

• src/tools/test-rule.ts:35-108 (handler)

  The core handler function for the 'test_rule' tool. It sets up the page, injects the autoconsent script, navigates to the URL, handles messages from the content script, and returns test results including errors, CMP detection, popup findings, and opt-out results.

  export async function testRule(
    page: Page,
    url: string,
    rule: AutoConsentCMPRule,
    { viewportWidth = 1280, viewportHeight = 720 }: TestRuleSettings = {},
  ): Promise<TestRuleResults> {
    // Set viewport
    await page.setViewport({ width: viewportWidth, height: viewportHeight });
  
    // Reset browser data - clear cookies, cache, and storage
    await resetBrowserData(page);
  
    const messages: ContentScriptMessage[] = [];
  
    async function messageCallback(message: ContentScriptMessage) {
      messages.push(message);
  
      switch (message.type) {
        case "init": {
          await page.evaluate(
            `autoconsentReceiveMessage(${JSON.stringify({
              type: "initResp",
              rules: {
                autoconsent: [rule],
              },
              config: {
                enabled: true,
                autoAction: "optOut",
                disabledCmps: [],
                enablePrehide: true,
                detectRetries: 20,
                enableCosmeticRules: true,
              },
            })})`,
          );
          break;
        }
        case "eval": {
          const result = await page.evaluate(message.code);
          await page.evaluate(
            `autoconsentReceiveMessage(${JSON.stringify({
              id: message.id,
              type: "evalResp",
              result: result,
            })})`,
          );
          break;
        }
      }
    }
  
    await page.exposeFunction("autoconsentSendMessage", messageCallback);
  
    await page.goto(url, {
      waitUntil: "domcontentloaded",
    });
  
    await injectAutoconsent(page);
    page.frames().forEach(injectAutoconsent);
    // page.on("framenavigated", injectAutoconsent);
  
    await new Promise((resolve) => setTimeout(resolve, 5000));
  
    const results = {
      errors: messages.filter((msg) => msg.type === "autoconsentError"),
      cmpDetectedMessage: messages.find((msg) => msg.type === "cmpDetected"),
      popupFoundMessage: messages.find((msg) => msg.type === "popupFound"),
      optOutResultMessage: messages.find((msg) => msg.type === "optOutResult"),
    };
  
    await page.removeExposedFunction("autoconsentSendMessage");
  
    return results;
  }

• src/tools/test-rule.ts:14-24 (schema)

  TypeScript type definitions for the input settings (TestRuleSettings) and output results (TestRuleResults) used by the testRule handler.

  type TestRuleSettings = {
    viewportWidth?: number;
    viewportHeight?: number;
  };
  
  type TestRuleResults = {
    errors: ErrorMessage[];
    cmpDetectedMessage?: DetectedMessage;
    popupFoundMessage?: FoundMessage;
    optOutResultMessage?: OptOutResultMessage;
  };

• src/index.ts:128-142 (registration)

  Registration of the 'test_rule' tool in the TOOLS array, defining its name, description, and input schema for MCP tool listing.

  {
    name: "test_rule",
    description: "Tests the given Autoconsent rule on the given URL",
    inputSchema: {
      type: "object",
      properties: {
        url: { type: "string", description: "URL to navigate to" },
        rule: {
          type: "object",
          description: "Autoconsent rule (AutoConsentCMPRule)",
        },
      },
      required: ["url", "rule"],
    },
  },

• src/index.ts:430-472 (handler)

  MCP tool dispatcher case for 'test_rule' that calls the testRule function and formats the results into text output for the MCP response.

  case "test_rule":
    try {
      const rule = args.rule as AutoConsentCMPRule;
      const results = await testRule(page, args.url, rule);
  
      let output = `Test results for rule "${rule.name}" on ${args.url}:\n\n`;
  
      if (results.errors.length > 0) {
        output += `Errors:\n${results.errors.map((err) => JSON.stringify(err, null, 2)).join("\n")}\n\n`;
      }
  
      if (results.cmpDetectedMessage) {
        output += `CMP Detected: ${JSON.stringify(results.cmpDetectedMessage, null, 2)}\n\n`;
      }
  
      if (results.popupFoundMessage) {
        output += `Popup Found: ${JSON.stringify(results.popupFoundMessage, null, 2)}\n\n`;
      }
  
      if (results.optOutResultMessage) {
        output += `Opt-out Result: ${JSON.stringify(results.optOutResultMessage, null, 2)}\n\n`;
      }
  
      return {
        content: [
          {
            type: "text",
            text: output,
          },
        ],
        isError: false,
      };
    } catch (error) {
      return {
        content: [
          {
            type: "text",
            text: `Failed to test rule: ${(error as Error).message}`,
          },
        ],
        isError: true,
      };
    }

• src/tools/test-rule.ts:26-33 (helper)

  Helper function to inject the autoconsent Playwright script into the page or frame.

  async function injectAutoconsent(page: Page | Frame) {
    const autoconsentPath = path.resolve(
      __dirname,
      "../../node_modules/@duckduckgo/autoconsent/dist/autoconsent.playwright.js",
    );
    const autoconsentScript = fs.readFileSync(autoconsentPath, "utf8");
    await page.evaluate(autoconsentScript);
  }