@cookiemunch/mcp 0.0.0-stage → 0.1.0

package/dist/bin.cjs

@@ -0,0 +1,1394 @@
+#!/usr/bin/env node
+"use strict";
+
+// src/bin.ts
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+
+// src/index.ts
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_sdk = require("@cookiemunch/sdk");
+
+// src/tools.ts
+var import_zod3 = require("zod");
+
+// src/tools-config.ts
+var import_zod = require("zod");
+function registerConfigTools(tool, client) {
+  const blockingModeEnum = import_zod.z.enum(["auto", "manual"]);
+  const bannerModeEnum = import_zod.z.enum(["opt-in", "opt-out", "off"]);
+  const bannerTypeEnum = import_zod.z.enum(["multilevel", "inline", "accept-decline", "accept-only", "do-not-sell"]);
+  const bannerLayoutEnum = import_zod.z.enum(["top", "bottom", "push-down", "popup", "overlay"]);
+  const consentModeModeEnum = import_zod.z.enum(["basic", "advanced"]);
+  const geoRuleSchema = import_zod.z.object({
+    match: import_zod.z.object({
+      countries: import_zod.z.array(import_zod.z.string()).optional(),
+      regions: import_zod.z.array(import_zod.z.string()).optional()
+    }),
+    mode: bannerModeEnum
+  });
+  const setBlockingSchema = import_zod.z.object({
+    cbid: import_zod.z.string().describe("Site identifier (cbid)."),
+    mode: blockingModeEnum.describe("Blocking mode. auto = block non-consented scripts; manual = never block."),
+    ignoreSelectors: import_zod.z.array(import_zod.z.string()).optional().describe("CSS selectors for elements that should never be blocked.")
+  });
+  tool(
+    "set_blocking",
+    "Configure the script-blocking mode for a site. Fetches the current config, patches only the blocking domain, and PUTs.",
+    setBlockingSchema.shape,
+    async (a) => {
+      const { cbid: siteId, mode, ignoreSelectors } = setBlockingSchema.parse(a);
+      const cfg = await client.sites.getConfig(siteId);
+      const existingBlocking = cfg["blocking"] ?? {};
+      const blocking = {
+        ...existingBlocking,
+        mode,
+        ...ignoreSelectors !== void 0 ? { ignoreSelectors } : {}
+      };
+      return client.sites.putConfig(siteId, { ...cfg, blocking });
+    }
+  );
+  const setGeoRulesSchema = import_zod.z.object({
+    cbid: import_zod.z.string().describe("Site identifier (cbid)."),
+    geoRules: import_zod.z.array(geoRuleSchema).describe("Ordered list of geo rules. First match wins."),
+    defaultMode: bannerModeEnum.optional().describe("Banner mode when no geo rule matches. Default: opt-in.")
+  });
+  tool(
+    "set_geo_rules",
+    "Set geo-targeting rules for a site (which banner mode to show per country/region). Fetches the current config, patches only geoRules + defaultMode, and PUTs.",
+    setGeoRulesSchema.shape,
+    async (a) => {
+      const { cbid: siteId, geoRules, defaultMode } = setGeoRulesSchema.parse(a);
+      const cfg = await client.sites.getConfig(siteId);
+      return client.sites.putConfig(siteId, {
+        ...cfg,
+        geoRules,
+        ...defaultMode !== void 0 ? { defaultMode } : {}
+      });
+    }
+  );
+  tool(
+    "list_supported_languages",
+    "The languages the banner already has copy for, with their English name, their name in themselves, whether they read right to left, and whether they ship in the base embed or in the renderer. Check this before writing translations with set_languages \u2014 the ones listed here need none. Read-only.",
+    {},
+    () => client.languages()
+  );
+  const identitySourceSchema = import_zod.z.object({
+    name: import_zod.z.string().describe('What you call the identifier, e.g. "customerId" or "email".'),
+    from: import_zod.z.enum(["dataLayer", "window", "cookie", "localStorage", "query", "meta"]).describe("Where the page keeps it."),
+    key: import_zod.z.string().describe("Dotted path for dataLayer/window; cookie, storage key, query parameter or meta name otherwise."),
+    hash: import_zod.z.boolean().optional().describe("Default true: SHA-256 the trimmed, lowercased value in the browser. false for an opaque id.")
+  });
+  const setIdentitySourcesSchema = import_zod.z.object({
+    cbid: import_zod.z.string().describe("Site identifier (cbid)."),
+    sources: import_zod.z.array(identitySourceSchema).describe("In priority order; the first with a value becomes the consent record's subjectId. Empty array removes them.")
+  });
+  tool(
+    "set_identity_sources",
+    "Tell the web embed where a site keeps its signed-in customer (data layer, window object, cookie, local storage, query parameter or meta tag), so consent records carry that customer's subjectId and can be read with GET /v1/subjects/:id/consent. Values are hashed in the browser unless a source sets hash:false. Fetches the current config, patches only identity, and PUTs.",
+    setIdentitySourcesSchema.shape,
+    async (a) => {
+      const { cbid: siteId, sources } = setIdentitySourcesSchema.parse(a);
+      const cfg = await client.sites.getConfig(siteId);
+      const { identity: _old, ...rest } = cfg;
+      return client.sites.putConfig(siteId, sources.length > 0 ? { ...rest, identity: { sources } } : rest);
+    }
+  );
+  const setLanguagesSchema = import_zod.z.object({
+    cbid: import_zod.z.string().describe("Site identifier (cbid)."),
+    defaultCulture: import_zod.z.string().optional().describe('Default locale/culture code, e.g. "en", "fr". Stored in i18n.defaultCulture.'),
+    autoDetect: import_zod.z.boolean().optional().describe("Auto-detect visitor language from browser locale. Stored in i18n.autoDetect."),
+    translations: import_zod.z.record(import_zod.z.record(import_zod.z.unknown())).optional().describe("Per-locale banner copy overrides. Merged onto banner.i18n (locale keys preserved)."),
+    overrides: import_zod.z.record(import_zod.z.object({ banner: import_zod.z.record(import_zod.z.string()).optional(), categories: import_zod.z.record(import_zod.z.object({ label: import_zod.z.string().optional(), description: import_zod.z.string().optional() })).optional() })).optional().describe("The site's own copy per language, keyed by tag (de, pt-BR): { banner: { title, body, \u2026 }, categories: { <id>: { label, description } } }. Each language given replaces its entry in i18n.overrides; other languages are kept. Strings the site wrote are shown as written in any language without an override \u2014 stock translations never replace them.")
+  });
+  tool(
+    "set_languages",
+    "Configure language/i18n settings for a site: default culture, auto-detect, and the site's own copy per language (overrides). Fetches the current config, patches only i18n + banner.i18n, and PUTs.",
+    setLanguagesSchema.shape,
+    async (a) => {
+      const { cbid: siteId, defaultCulture, autoDetect, translations, overrides } = setLanguagesSchema.parse(a);
+      const cfg = await client.sites.getConfig(siteId);
+      const existingI18n = cfg["i18n"] ?? {};
+      const existingBanner = cfg["banner"] ?? {};
+      const existingBannerI18n = existingBanner["i18n"] ?? {};
+      const i18n = {
+        ...existingI18n,
+        ...defaultCulture !== void 0 ? { defaultCulture } : {},
+        ...autoDetect !== void 0 ? { autoDetect } : {},
+        ...overrides !== void 0 ? { overrides: { ...existingI18n["overrides"] ?? {}, ...overrides } } : {}
+      };
+      const banner = {
+        ...existingBanner,
+        ...translations !== void 0 ? { i18n: { ...existingBannerI18n, ...translations } } : {}
+      };
+      return client.sites.putConfig(siteId, { ...cfg, i18n, banner });
+    }
+  );
+  const setConsentModeSchema = import_zod.z.object({
+    cbid: import_zod.z.string().describe("Site identifier (cbid)."),
+    enabled: import_zod.z.boolean().describe("Whether Google Consent Mode signals are emitted."),
+    mode: consentModeModeEnum.describe("basic = gtag consent commands only; advanced = also passes redacted pings before consent."),
+    waitForUpdate: import_zod.z.number().optional().describe("Milliseconds to wait for consent before gtag proceeds. Default 500.")
+  });
+  tool(
+    "set_consent_mode",
+    "Configure Google Consent Mode for a site (enabled, basic/advanced, waitForUpdate). Fetches the current config, patches only consentMode, and PUTs.",
+    setConsentModeSchema.shape,
+    async (a) => {
+      const { cbid: siteId, enabled, mode, waitForUpdate } = setConsentModeSchema.parse(a);
+      const cfg = await client.sites.getConfig(siteId);
+      const existingCm = cfg["consentMode"] ?? {};
+      const consentMode = {
+        ...existingCm,
+        enabled,
+        mode,
+        ...waitForUpdate !== void 0 ? { waitForUpdate } : {}
+      };
+      return client.sites.putConfig(siteId, { ...cfg, consentMode });
+    }
+  );
+  const setAbExperimentSchema = import_zod.z.object({
+    cbid: import_zod.z.string().describe("Site identifier (cbid)."),
+    enabled: import_zod.z.boolean().describe("Whether the A/B experiment is active."),
+    splitB: import_zod.z.number().min(0).max(100).describe("Percentage of visitors (0\u2013100) who see variant B."),
+    variantB: import_zod.z.record(import_zod.z.unknown()).optional().describe("Partial BannerConfig override for variant B visitors. Deep-merged over the base banner.")
+  });
+  tool(
+    "set_ab_experiment",
+    "Configure the A/B banner experiment for a site (enabled, split percentage, variant B overrides). Fetches the current config, patches only experiment, and PUTs.",
+    setAbExperimentSchema.shape,
+    async (a) => {
+      const { cbid: siteId, enabled, splitB, variantB } = setAbExperimentSchema.parse(a);
+      const cfg = await client.sites.getConfig(siteId);
+      const existingExperiment = cfg["experiment"] ?? {};
+      const experiment = {
+        ...existingExperiment,
+        enabled,
+        splitB,
+        ...variantB !== void 0 ? { variantB } : {}
+      };
+      return client.sites.putConfig(siteId, { ...cfg, experiment });
+    }
+  );
+  const setConsentPolicySchema = import_zod.z.object({
+    cbid: import_zod.z.string().describe("Site identifier (cbid)."),
+    expiryDays: import_zod.z.number().optional().describe("Re-prompt visitors after this many days. Omit to disable time-based expiry."),
+    version: import_zod.z.number().optional().describe("Bump this integer to force a re-prompt (e.g. when your cookie usage changes).")
+  });
+  tool(
+    "set_consent_policy",
+    "Configure consent persistence policy for a site (expiry days, version bump). Fetches the current config, patches only consent, and PUTs.",
+    setConsentPolicySchema.shape,
+    async (a) => {
+      const { cbid: siteId, expiryDays, version } = setConsentPolicySchema.parse(a);
+      const cfg = await client.sites.getConfig(siteId);
+      const existingConsent = cfg["consent"] ?? {};
+      const consent = {
+        ...existingConsent,
+        ...expiryDays !== void 0 ? { expiryDays } : {},
+        ...version !== void 0 ? { version } : {}
+      };
+      return client.sites.putConfig(siteId, { ...cfg, consent });
+    }
+  );
+  const setBannerBasicsSchema = import_zod.z.object({
+    cbid: import_zod.z.string().describe("Site identifier (cbid)."),
+    type: bannerTypeEnum.optional().describe("Banner type. multilevel | inline | accept-decline | accept-only | do-not-sell."),
+    layout: bannerLayoutEnum.optional().describe("Banner layout. top | bottom | push-down | popup | overlay."),
+    preset: import_zod.z.enum(["bar", "box", "full"]).optional().describe("Named shape that sets type/secondLayer (and layout for box): bar = slim one-row bar + categories in a modal; box = centred card + modal; full = every category in the first layer."),
+    secondLayer: import_zod.z.enum(["expand", "popup", "modal"]).optional().describe("Where the categories open from an inline banner."),
+    density: import_zod.z.enum(["comfortable", "compact"]).optional().describe("compact = one-row bar from 760px wide."),
+    theme: import_zod.z.record(import_zod.z.unknown()).optional().describe("Partial ThemeTokens \u2014 deep-merged onto the existing banner theme."),
+    content: import_zod.z.record(import_zod.z.unknown()).optional().describe("Partial BannerContent \u2014 banner copy overrides (title, body, button labels, policyUrl, etc.).")
+  });
+  tool(
+    "set_banner_basics",
+    "Configure v1 banner appearance for a site: preset, type, layout, second layer, density, theme tokens, and copy (content.preferencesTitle titles the preferences dialog). Fetches the current config, patches only those banner fields, and PUTs. Setting type or secondLayer (or layout under the box preset) without a preset removes the stored preset, which would otherwise re-derive them.",
+    setBannerBasicsSchema.shape,
+    async (a) => {
+      const { cbid: siteId, type, layout, preset, secondLayer, density, theme, content } = setBannerBasicsSchema.parse(a);
+      const cfg = await client.sites.getConfig(siteId);
+      const existingBanner = cfg["banner"] ?? {};
+      const existingTheme = existingBanner["theme"] ?? {};
+      const existingContent = existingBanner["content"] ?? {};
+      const banner = {
+        ...existingBanner,
+        ...type !== void 0 ? { type } : {},
+        ...layout !== void 0 ? { layout } : {},
+        ...secondLayer !== void 0 ? { secondLayer } : {},
+        ...density !== void 0 ? { density } : {},
+        ...preset !== void 0 ? { preset } : {},
+        ...theme !== void 0 ? { theme: { ...existingTheme, ...theme } } : {},
+        ...content !== void 0 ? { content: { ...existingContent, ...content } } : {}
+      };
+      const owned = type !== void 0 || secondLayer !== void 0 || layout !== void 0 && banner["preset"] === "box";
+      if (preset === void 0 && owned) delete banner["preset"];
+      return client.sites.putConfig(siteId, { ...cfg, banner });
+    }
+  );
+  const getInstallSnippetSchema = import_zod.z.object({
+    cbid: import_zod.z.string().describe("Site identifier (cbid). Must belong to your org."),
+    blockingMode: import_zod.z.enum(["auto", "manual"]).optional().describe(
+      '"auto" (default) blocks third-party scripts until consent is given; "manual" never blocks. These are the only two modes the runtime embed honors \u2014 any other value is rejected rather than silently downgraded.'
+    ),
+    culture: import_zod.z.string().optional().describe('Language culture override, e.g. "en", "fr", "de".')
+  });
+  tool(
+    "get_install_snippet",
+    "Get the exact <script> tag to install Cookie Munch on a site. Copy and paste this into the <head> of every page on the site.",
+    getInstallSnippetSchema.shape,
+    (a) => {
+      const { cbid: siteId, blockingMode, culture } = getInstallSnippetSchema.parse(a);
+      return client.sites.snippet(siteId, { blockingMode, culture });
+    }
+  );
+  const previewBannerSchema = import_zod.z.object({
+    cbid: import_zod.z.string().describe("Site identifier (cbid). Must belong to your org."),
+    region: import_zod.z.string().optional().describe('Region to show the banner for: a country or subdivision code ("de", "us-ca") or "eu".'),
+    lang: import_zod.z.string().optional().describe('Language to show it in, e.g. "de", "pt-BR".'),
+    url: import_zod.z.string().optional().describe("The page to open. Default: the site's registered domain."),
+    ttlSeconds: import_zod.z.number().int().min(1).max(3600).optional().describe("How long the link works, in seconds (default 900, max 3600).")
+  });
+  tool(
+    "preview_banner",
+    "Get a short-lived link that shows the site\u2019s banner exactly as a visitor in a given region and language sees it \u2014 it works from a headless browser too (bot suppression is bypassed), and nothing done on it is recorded as consent or counted in statistics.",
+    previewBannerSchema.shape,
+    (a) => {
+      const { cbid: siteId, ...opts } = previewBannerSchema.parse(a);
+      return client.sites.previewToken(siteId, opts);
+    }
+  );
+}
+
+// src/tools-platform.ts
+var import_zod2 = require("zod");
+var identifierSchema = import_zod2.z.array(import_zod2.z.object({ space: import_zod2.z.string(), value: import_zod2.z.string() })).describe("A person's identifiers, e.g. [{space:'email_sha256', value:'<sha256 of the lowercased email>'}].");
+var ids = (a) => a.identifiers;
+function registerPlatformTools(tool, client) {
+  tool(
+    "resolve_identity",
+    "Resolve identifiers to the canonical subject id for one person, or null if unknown. Read-only.",
+    { identifiers: identifierSchema },
+    (a) => client.identity.resolve(ids(a))
+  );
+  tool(
+    "get_identity_cluster",
+    "Every identifier currently stitched to one subject \u2014 what resolve_identity and link_identity have merged. Read-only.",
+    { subjectId: import_zod2.z.string() },
+    (a) => client.identity.cluster(a.subjectId)
+  );
+  tool(
+    "link_identity",
+    "Stitch identifiers together as ONE person and return the canonical subject id. This is a durable merge: if the identifiers already belong to different subjects, those subjects are combined and their consent and profile data are carried onto the survivor. Use resolve_identity if you only need to look someone up.",
+    { identifiers: identifierSchema },
+    (a) => client.identity.link(ids(a))
+  );
+  tool(
+    "record_consent_decision",
+    "Record consent decisions against the resolved person in the Permission Vault. The latest decision per purpose wins, so this is how a withdrawal is registered too (allowed:false).",
+    {
+      identifiers: identifierSchema,
+      decisions: import_zod2.z.array(import_zod2.z.object({
+        purpose: import_zod2.z.string(),
+        allowed: import_zod2.z.boolean(),
+        legalBasis: import_zod2.z.string().optional(),
+        jurisdiction: import_zod2.z.string().optional(),
+        provenance: import_zod2.z.string().optional().describe("Where the decision came from, e.g. banner_accept_all, gpc, preference_center."),
+        collectedAt: import_zod2.z.number().optional().describe("Unix ms; latest per purpose wins.")
+      })).describe("One entry per purpose.")
+    },
+    (a) => client.vault.record(ids(a), a.decisions)
+  );
+  tool(
+    "get_consent_state",
+    "A person's current allow/deny per purpose, resolved across ALL their identifiers. Read-only.",
+    { identifiers: identifierSchema },
+    (a) => client.vault.current(ids(a))
+  );
+  tool(
+    "list_permits",
+    "A person's consent decisions in full: per purpose, allowed or not, with the legal basis, jurisdiction, where it was collected and when. The audit-grade view behind get_consent_state. Read-only.",
+    { identifiers: identifierSchema },
+    (a) => client.vault.permits(ids(a))
+  );
+  tool(
+    "get_profile",
+    "The unified profile for a person: their identifiers, current permits and first-party attributes. Read-only.",
+    { identifiers: identifierSchema },
+    (a) => client.profile.get(ids(a))
+  );
+  tool(
+    "set_profile_attributes",
+    "Set first-party profile attributes for a person. A newer collectedAt wins over an older value.",
+    {
+      identifiers: identifierSchema,
+      attributes: import_zod2.z.record(import_zod2.z.object({ value: import_zod2.z.string(), purpose: import_zod2.z.string().optional(), collectedAt: import_zod2.z.number().optional() })).describe('Attribute name to value, e.g. { plan: { value: "pro" } }.')
+    },
+    (a) => client.profile.setAttributes(ids(a), a.attributes)
+  );
+  tool(
+    "activate_profile",
+    "Get the attribute values usable for a purpose. CONSENT-GATED: returns {} when the person has not consented to that purpose, so it is safe to call before sending data to a marketing or AI destination.",
+    { identifiers: identifierSchema, purpose: import_zod2.z.string().describe("The activation purpose, e.g. marketing.") },
+    (a) => client.profile.activate(ids(a), a.purpose)
+  );
+  tool(
+    "get_subscriptions",
+    "A subject's marketing subscription state (topics x channels). Read-only.",
+    { subjectId: import_zod2.z.string() },
+    (a) => client.subscriptions.get(a.subjectId)
+  );
+  tool(
+    "set_subscription",
+    "Opt a subject in or out of one topic on one channel.",
+    {
+      subjectId: import_zod2.z.string(),
+      topic: import_zod2.z.string(),
+      channel: import_zod2.z.string().describe("email | sms | push | mail | phone, or a custom channel."),
+      optedIn: import_zod2.z.boolean()
+    },
+    (a) => client.subscriptions.set(a.subjectId, a.topic, a.channel, a.optedIn)
+  );
+  tool(
+    "global_unsubscribe",
+    "Suppress every topic and channel for a subject WITHOUT erasing their per-topic choices, so a later resubscribe restores them.",
+    { subjectId: import_zod2.z.string() },
+    (a) => client.subscriptions.unsubscribeAll(a.subjectId)
+  );
+  tool(
+    "resubscribe",
+    "Lift a global unsubscribe. Restores the per-topic choices the subject had before it \u2014 it does not opt them in to anything they had not chosen.",
+    { subjectId: import_zod2.z.string() },
+    (a) => client.subscriptions.resubscribe(a.subjectId)
+  );
+  tool(
+    "get_subscription_activation",
+    "What to send downstream for a subject: per topic and channel, whether they are subscribed and which mapped downstream group (e.g. an ESP list id) that is. Honours a global unsubscribe. Read-only.",
+    {
+      subjectId: import_zod2.z.string(),
+      topics: import_zod2.z.array(
+        import_zod2.z.object({
+          code: import_zod2.z.string(),
+          name: import_zod2.z.string().optional(),
+          channels: import_zod2.z.array(import_zod2.z.string()),
+          downstream: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.string()).optional()
+        })
+      ).describe("The topics to resolve, usually the catalog from get_subscription_topics.")
+    },
+    (a) => client.subscriptions.activation(a.subjectId, a.topics)
+  );
+  tool(
+    "list_assessment_templates",
+    "The assessment templates available (DPIA, PIA, LIA, TIA, AI impact, vendor) and the questions each asks.",
+    {},
+    () => client.assessments.templates()
+  );
+  tool(
+    "list_assessments",
+    "Every assessment in the org with its status: draft, in_review, approved or rejected. Read-only.",
+    {},
+    () => client.assessments.list()
+  );
+  tool(
+    "autopopulate_assessment",
+    "Prefill an assessment from evidence you supply. Never overwrites a human answer, and stamps every filled answer with `source` so a reviewer can see where it came from. The assessment still needs a human to submit and approve it.",
+    { id: import_zod2.z.string(), evidence: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()).describe("questionId \u2192 answer."), source: import_zod2.z.string().optional() },
+    (a) => client.assessments.autoPopulate(a.id, a.evidence, a.source)
+  );
+  tool(
+    "start_assessment",
+    "Start an assessment from a template against a subject (a processing activity, system or vendor).",
+    {
+      template: import_zod2.z.string().describe("dpia | pia | lia | tia | ai_impact | vendor"),
+      subject: import_zod2.z.string().describe("What is being assessed.")
+    },
+    (a) => client.assessments.start(a.template, a.subject)
+  );
+  tool(
+    "get_assessment",
+    "An assessment with its derived risk score, completeness (what is still missing) and which SME owns each outstanding question.",
+    { id: import_zod2.z.string() },
+    (a) => client.assessments.get(a.id)
+  );
+  tool(
+    "answer_assessment_question",
+    "Record one answer on an assessment. Note: answering an APPROVED assessment reopens it to draft, because changing the facts invalidates the sign-off.",
+    { id: import_zod2.z.string(), questionId: import_zod2.z.string(), value: import_zod2.z.union([import_zod2.z.string(), import_zod2.z.number(), import_zod2.z.boolean()]) },
+    (a) => client.assessments.answer(a.id, a.questionId, a.value)
+  );
+  tool(
+    "autopopulate_assessment_from_data_map",
+    "Fill an assessment from the organisation\u2019s latest data-map scan. Only facts the scan can establish are applied, a human\u2019s existing answer is never overwritten, and machine answers are stamped with provenance so a reviewer can tell them apart.",
+    { id: import_zod2.z.string() },
+    (a) => client.assessments.autoPopulateFromMap(a.id)
+  );
+  tool(
+    "submit_assessment",
+    "Submit an assessment for review. Refused while any required question is unanswered.",
+    { id: import_zod2.z.string() },
+    (a) => client.assessments.submit(a.id)
+  );
+  tool(
+    "get_data_map",
+    "The latest data map: which systems hold personal data, and which categories. Read-only.",
+    {},
+    () => client.discovery.getMap()
+  );
+  tool(
+    "get_data_drift",
+    "What changed in the estate since the previous scan, and where the documented RoPA disagrees with what is actually there (undocumented systems, undeclared data categories, stale records).",
+    {},
+    () => client.discovery.drift()
+  );
+  tool(
+    "get_ropa_drafts",
+    "Draft processing-activity records generated from the latest data map. These are DRAFTS: the factual fields come from the scan, the legal ones still need a human.",
+    {},
+    () => client.discovery.ropaDrafts()
+  );
+  tool(
+    "get_discovery_evidence",
+    "The assessment answers the latest data map can actually support \u2014 only questions a scan can genuinely answer, never guesses. What autopopulate_assessment_from_data_map would apply. Read-only.",
+    {},
+    () => client.discovery.evidence()
+  );
+  tool(
+    "plan_warehouse_enforcement",
+    "Plan warehouse-native policy (Snowflake masking / row access, Postgres RLS) from the latest data map. Returns a PLAN and its revert \u2014 nothing is applied to the warehouse by calling this. Also reports what it declined to do and why, so gaps are visible rather than silently missing.",
+    {
+      dialect: import_zod2.z.enum(["postgres", "mysql", "snowflake"]),
+      rules: import_zod2.z.array(
+        import_zod2.z.object({
+          id: import_zod2.z.string(),
+          action: import_zod2.z.enum(["mask", "restrict"]),
+          minSensitivity: import_zod2.z.enum(["personal", "sensitive"]).optional(),
+          categories: import_zod2.z.array(import_zod2.z.string()).optional(),
+          allowRoles: import_zod2.z.array(import_zod2.z.string()).optional(),
+          purpose: import_zod2.z.string().optional(),
+          subjectColumn: import_zod2.z.string().optional()
+        })
+      ).describe("A rule with neither minSensitivity nor categories matches nothing, by design."),
+      permitsTable: import_zod2.z.string().optional(),
+      policyPrefix: import_zod2.z.string().optional()
+    },
+    (a) => client.discovery.planEnforcement(
+      a.dialect,
+      a.rules,
+      {
+        ...typeof a.permitsTable === "string" ? { permitsTable: a.permitsTable } : {},
+        ...typeof a.policyPrefix === "string" ? { policyPrefix: a.policyPrefix } : {}
+      }
+    )
+  );
+  tool(
+    "get_subscription_topics",
+    "The org's marketing topic catalog \u2014 what a subject can subscribe to, and on which channels. Read-only.",
+    {},
+    () => client.subscriptions.topics()
+  );
+  tool(
+    "set_subscription_topics",
+    "Replace the subscription topic catalog. The list is authored whole, so anything omitted is removed.",
+    {
+      topics: import_zod2.z.array(
+        import_zod2.z.object({
+          code: import_zod2.z.string(),
+          name: import_zod2.z.string().optional(),
+          channels: import_zod2.z.array(import_zod2.z.string()),
+          downstream: import_zod2.z.record(import_zod2.z.string()).optional()
+        })
+      )
+    },
+    (a) => client.subscriptions.setTopics(a.topics)
+  );
+  tool(
+    "get_regulatory_feed",
+    "The curated privacy-law dataset, optionally narrowed to the jurisdictions you operate in. Carries reviewedAt: this ships with the product and is only as current as its last review. Not legal advice.",
+    {
+      jurisdictions: import_zod2.z.array(import_zod2.z.string()).optional().describe("ISO codes, e.g. ['US-CA','BR']. A subdivision also matches its country; an EEA country matches the EU-wide regulations.")
+    },
+    (a) => client.regulatory.feed(a.jurisdictions)
+  );
+  tool(
+    "get_upcoming_regulations",
+    "Privacy laws taking effect within a horizon (default 180 days), soonest first. Same caveat as the feed: a shipped dataset with a review date, not live legal research.",
+    { days: import_zod2.z.number().int().positive().optional() },
+    (a) => client.regulatory.upcoming(a.days)
+  );
+  tool(
+    "get_dsr_sla",
+    "The rights queue at a glance: how many requests are overdue, due today, due soon or on track, plus the overdue ids.",
+    {},
+    () => client.fulfillment.sla()
+  );
+  tool(
+    "plan_dsr_fulfillment",
+    "Break a data-subject request into one fulfillment task per system. The tasks are then executed by the in-VPC agent inside the customer network \u2014 this call only queues the work.",
+    {
+      requestId: import_zod2.z.string(),
+      systems: import_zod2.z.array(import_zod2.z.object({ system: import_zod2.z.string(), operation: import_zod2.z.enum(["locate", "export", "erase", "optOut"]) })).describe("One entry per system to act on."),
+      includeHistorical: import_zod2.z.boolean().optional().describe("Also reprocess already-collected records, not just future ones.")
+    },
+    (a) => client.fulfillment.plan(
+      a.requestId,
+      a.systems,
+      a.includeHistorical
+    )
+  );
+  tool(
+    "list_dsar_executors",
+    "Systems connected to run part of a rights request themselves \u2014 an identity platform, a CRM, anything with a rights API. The in-VPC agent covers systems we cannot reach; these are the ones we can. Each carries the profile that describes its API. Never returns credentials. Read-only.",
+    {},
+    () => client.fulfillment.executors()
+  );
+  tool(
+    "connect_dsar_executor",
+    "Connect a system that runs part of a rights request \u2014 an identity platform, a CRM, anything with a rights API. Cookie Munch is not specific to any platform: the `profile` describes that system's API (paths, the words it uses for export/erase, its status vocabulary, how it signs webhooks), so connecting a new one needs no code. The secret key is stored encrypted and never returned; the response carries the webhook URL to configure in that system. Sub-tasks open automatically once a request reaches fulfilment (after identity verification), and completions are picked up by webhook or by polling.",
+    {
+      system: import_zod2.z.string().describe("The name this connection answers to in a plan, e.g. identity or crm."),
+      baseUrl: import_zod2.z.string().describe("The system's public https origin."),
+      secretKey: import_zod2.z.string().describe("Its API key, with whatever scope that system needs to export and erase a user."),
+      webhookSecret: import_zod2.z.string().optional().describe("Signing secret of its webhook endpoint. Optional: polling closes tasks without it."),
+      auto: import_zod2.z.boolean().optional().describe("Open a sub-task automatically when a request reaches fulfilment. Default true."),
+      profile: import_zod2.z.record(import_zod2.z.unknown()).describe("How to drive that system: { open, poll, statuses } required, plus optional subjectLookup, auth, idempotencyHeader and webhook. See the connected-systems docs for the shape.")
+    },
+    (a) => client.fulfillment.connectExecutor(a)
+  );
+  tool(
+    "disconnect_dsar_executor",
+    "Disconnect a system. Its open sub-tasks stop being driven, and the stored credentials are deleted.",
+    { id: import_zod2.z.string() },
+    async (a) => {
+      await client.fulfillment.disconnectExecutor(a.id);
+      return { disconnected: a.id };
+    }
+  );
+  tool(
+    "get_dsar_task",
+    "One fulfilment task in detail: its status history, what it means for the person (exported, no record, done without an export\u2026), every request Cookie Munch made to the connected system on its behalf with the answer it got (credentials removed, kept 30 days), and whether that system was redeployed mid-request. Read-only. Use it to explain why a system answered the way it did.",
+    { requestId: import_zod2.z.string(), taskId: import_zod2.z.string() },
+    (a) => client.fulfillment.task(a.requestId, a.taskId)
+  );
+  tool(
+    "test_dsar_executor",
+    "Try a connected system against one email WITHOUT filing a rights request. Runs its subject lookup and returns the raw upstream answers (credentials removed) and a one-line verdict. The open step is rendered but not sent, unless open is true on an export, which opens and polls a real export once. An erasure is never sent by a test.",
+    {
+      id: import_zod2.z.string().describe("The connection id."),
+      email: import_zod2.z.string().describe("The address to look up."),
+      operation: import_zod2.z.enum(["locate", "export", "erase"]).optional().describe("Default locate."),
+      open: import_zod2.z.boolean().optional().describe("For export only: open a real export and poll it once.")
+    },
+    (a) => client.fulfillment.testExecutor(a.id, {
+      email: a.email,
+      ...a.operation ? { operation: a.operation } : {},
+      ...typeof a.open === "boolean" ? { open: a.open } : {}
+    })
+  );
+  tool(
+    "get_dsar_task_export",
+    "The export bundle a connected system produced for one sub-task, fetched from that system on demand. The platform keeps no copy.",
+    { requestId: import_zod2.z.string(), taskId: import_zod2.z.string() },
+    (a) => client.fulfillment.taskExport(a.requestId, a.taskId)
+  );
+  tool(
+    "get_dsr_fulfillment_status",
+    'Per-system fulfillment status for one request ("n of m systems done"), including which systems failed and why.',
+    { requestId: import_zod2.z.string() },
+    (a) => client.fulfillment.status(a.requestId)
+  );
+  tool(
+    "inspect_ai_prompt",
+    "Run a prompt or model response through the AI governance gateway BEFORE it reaches the model or the user. Returns action allow | redact | block plus the text to actually forward (redacted, or empty when blocked). Pass `consent` when the call concerns an identified person: data for a purpose they have not consented to is blocked outright.",
+    {
+      prompt: import_zod2.z.string(),
+      purpose: import_zod2.z.string().describe("What the AI call is for, e.g. support or marketing."),
+      model: import_zod2.z.string().optional(),
+      actor: import_zod2.z.string().optional(),
+      direction: import_zod2.z.enum(["prompt", "response"]).optional(),
+      consent: import_zod2.z.record(import_zod2.z.boolean()).optional().describe("The person's current permits, e.g. { marketing: false }.")
+    },
+    (a) => client.ai.inspect(a)
+  );
+  tool(
+    "get_ai_policy",
+    "The AI gateway policy: its rules, and what happens when no rule matches. `configured` is false while the built-in default applies. Read-only.",
+    {},
+    () => client.ai.getPolicy()
+  );
+  tool(
+    "set_ai_policy",
+    "REPLACE the AI gateway policy. Takes effect on the next inspected prompt: a rule with action `block` stops matching calls, `redact` strips the matched data. `default` decides every call no rule matches \u2014 `block` fails closed.",
+    {
+      rules: import_zod2.z.array(
+        import_zod2.z.object({
+          id: import_zod2.z.string(),
+          purposes: import_zod2.z.array(import_zod2.z.string()).optional(),
+          categories: import_zod2.z.array(import_zod2.z.string()).optional(),
+          minSensitivity: import_zod2.z.string().optional(),
+          action: import_zod2.z.enum(["allow", "redact", "block"]),
+          reason: import_zod2.z.string().describe("Recorded on every audit entry this rule decides.")
+        })
+      ).describe("Evaluated in order; the first match decides."),
+      default: import_zod2.z.enum(["allow", "redact", "block"])
+    },
+    (a) => client.ai.setPolicy({ rules: a.rules, default: a.default })
+  );
+  tool(
+    "register_ai_system",
+    "Declare an AI system so it appears in the inventory as registered rather than shadow. Idempotent on `id`.",
+    { id: import_zod2.z.string(), name: import_zod2.z.string(), provider: import_zod2.z.string().optional(), purpose: import_zod2.z.string().optional() },
+    (a) => client.ai.registerSystem({
+      id: a.id,
+      name: a.name,
+      ...a.provider ? { provider: a.provider } : {},
+      ...a.purpose ? { purpose: a.purpose } : {}
+    })
+  );
+  tool("list_ai_systems", "The AI systems declared with register_ai_system. Read-only.", {}, () => client.ai.systems());
+  tool(
+    "get_ai_audit_log",
+    "Recent AI gateway decisions \u2014 what was allowed, redacted or blocked, and which rule decided. Read-only.",
+    { limit: import_zod2.z.number().int().positive().max(500).optional() },
+    (a) => client.ai.audit(a.limit)
+  );
+  tool(
+    "get_ai_inventory",
+    "Every AI system seen or declared, highest risk first, plus the SHADOW subset \u2014 models observed handling data that were never registered.",
+    {},
+    () => client.ai.inventory()
+  );
+  tool(
+    "get_ai_lineage",
+    'Which data categories reach which model. Answers "does anything send SSNs to a vendor model?".',
+    {},
+    () => client.ai.lineage()
+  );
+}
+
+// src/tools.ts
+function text(value) {
+  const body = typeof value === "string" ? value : JSON.stringify(value, null, 2);
+  return { content: [{ type: "text", text: body }] };
+}
+function fail(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return { content: [{ type: "text", text: `Error: ${message}` }], isError: true };
+}
+function registerTools(server, client) {
+  const tool = (name, description, inputSchema, run) => {
+    server.registerTool(name, { description, inputSchema }, async (args) => {
+      try {
+        return text(await run(args));
+      } catch (err) {
+        return fail(err);
+      }
+    });
+  };
+  const cbid = { cbid: import_zod3.z.string().describe("Site identifier (cbid). Must belong to your org.") };
+  const range = {
+    from: import_zod3.z.number().optional().describe("Epoch-ms lower bound."),
+    to: import_zod3.z.number().optional().describe("Epoch-ms upper bound.")
+  };
+  tool(
+    "whoami",
+    "Return the identity tied to the API key: orgId and name, the effective plan with planSource (org = its own subscription, account = covered by a higher plan another org on the same account pays for) and the features it unlocks, and the key\u2019s scopes.",
+    {},
+    () => client.me()
+  );
+  tool(
+    "list_account_orgs",
+    "The organisations on this key\u2019s account, each with its effective plan and planSource, plus the per-account org cap (max/used) and the upgrade URL. Read-only; needs an unscoped key.",
+    {},
+    () => client.orgs.list()
+  );
+  tool("list_sites", "List all sites (cbids) in your organization.", {}, () => client.sites.list());
+  tool(
+    "get_site",
+    "One site: its domain, cbid and verification status. Read-only.",
+    { cbid: import_zod3.z.string() },
+    (a) => client.sites.get(a.cbid)
+  );
+  tool(
+    "get_site_banner",
+    "Which banner design a site uses, or bannerId null when none is assigned. Read-only.",
+    { cbid: import_zod3.z.string() },
+    (a) => client.sites.banner(a.cbid)
+  );
+  tool(
+    "get_privacy_policy",
+    "Generate the site's privacy and cookie policy as Markdown, naming the org's data controller. Needs a contact email: the one given, else the org controller's, else the owner's. Read-only \u2014 nothing is published.",
+    { cbid: import_zod3.z.string(), contactEmail: import_zod3.z.string().optional(), effectiveDate: import_zod3.z.string().optional().describe("YYYY-MM-DD; defaults to today."), jurisdictions: import_zod3.z.array(import_zod3.z.string()).optional() },
+    (a) => client.sites.policy(a.cbid, {
+      ...a.contactEmail ? { contactEmail: a.contactEmail } : {},
+      ...a.effectiveDate ? { effectiveDate: a.effectiveDate } : {},
+      ...a.jurisdictions ? { jurisdictions: a.jurisdictions } : {}
+    })
+  );
+  tool(
+    "set_ad_personalization",
+    "Add or remove the separate 'personalised ads' choice on the site's live banner. With it on, accepting marketing no longer implies personalised ads unless `default` is true.",
+    { cbid: import_zod3.z.string(), enabled: import_zod3.z.boolean(), default: import_zod3.z.boolean().optional(), label: import_zod3.z.string().optional() },
+    (a) => client.sites.setAdPersonalization(a.cbid, {
+      enabled: a.enabled,
+      ...a.default !== void 0 ? { default: a.default } : {},
+      ...a.label ? { label: a.label } : {}
+    })
+  );
+  tool(
+    "analyze_session",
+    "Analyse a captured browsing session against the consent it ran under: which trackers fired after the visitor opted out, and what personal data left the page. Read-only.",
+    {
+      cbid: import_zod3.z.string(),
+      har: import_zod3.z.unknown().optional().describe("A HAR export of the session."),
+      requests: import_zod3.z.array(import_zod3.z.unknown()).optional().describe("Or the requests directly."),
+      consent: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.boolean()).optional(),
+      gpc: import_zod3.z.boolean().optional()
+    },
+    (a) => client.sites.analyzeSession(a.cbid, {
+      ...a.har !== void 0 ? { har: a.har } : {},
+      ...a.requests ? { requests: a.requests } : {},
+      ...a.consent ? { consent: a.consent } : {},
+      ...a.gpc !== void 0 ? { gpc: a.gpc } : {}
+    })
+  );
+  tool(
+    "create_site",
+    "Create a new site. The cbid is auto-generated if you omit it.",
+    { domain: import_zod3.z.string().describe("The site domain, e.g. example.com."), cbid: import_zod3.z.string().optional().describe("Optional explicit cbid.") },
+    (a) => client.sites.create({ domain: a.domain, ...typeof a.cbid === "string" ? { cbid: a.cbid } : {} })
+  );
+  tool(
+    "create_sites_bulk",
+    "Create up to 100 sites in one call. Partial success: each item reports ok or its own error, and a bad or duplicate item fails only itself.",
+    {
+      sites: import_zod3.z.array(import_zod3.z.object({ domain: import_zod3.z.string(), cbid: import_zod3.z.string().optional(), platform: import_zod3.z.string().optional() })).min(1).max(100)
+    },
+    (a) => client.sites.createBulk(a.sites)
+  );
+  tool("get_site_config", "Get the banner/consent configuration for a site.", { ...cbid }, (a) => client.sites.getConfig(a.cbid));
+  tool(
+    "update_site_config",
+    "Replace (overwrite) the banner/consent configuration for a site via PUT. This is destructive, not a merge: any top-level SiteConfig field you omit from `config` reverts to its default rather than keeping its current value. To change one setting, use patch_site_config instead \u2014 it merges server-side. Prefer the narrower set_* tools (set_blocking, set_banner_basics, etc.) when they cover your change.",
+    { ...cbid, config: import_zod3.z.record(import_zod3.z.unknown()).describe("The full SiteConfig to write, not a patch. Omitted top-level fields are NOT preserved from the current config \u2014 fetch get_site_config first and merge client-side.") },
+    (a) => client.sites.putConfig(a.cbid, a.config)
+  );
+  tool(
+    "patch_site_config",
+    "Change part of a site's banner/consent configuration. The patch is deep-merged over the stored config server-side, so any field you omit keeps its current value \u2014 this is the safe way to flip one setting, and it needs no read-modify-write. Use update_site_config only when you genuinely mean to replace the whole document.",
+    { ...cbid, config: import_zod3.z.record(import_zod3.z.unknown()).describe('The subset of SiteConfig to change, e.g. { "banner": { "showRightsLink": true } }. Everything else is preserved.') },
+    (a) => client.sites.patchConfig(a.cbid, a.config)
+  );
+  tool(
+    "preview_site_config",
+    'Preview a config change WITHOUT saving it: returns the config as it would be saved, a diff of every field that would change, and any warnings (plan-gated or unrecognised fields). mode "patch" (default) previews patch_site_config; mode "put" previews update_site_config, and its diff lists everything a replace would revert to its default. Use it before any write you are not sure of.',
+    {
+      ...cbid,
+      config: import_zod3.z.record(import_zod3.z.unknown()).describe('The patch (or, with mode "put", the full config) to preview.'),
+      mode: import_zod3.z.enum(["patch", "put"]).optional().describe("patch (default) merges; put replaces.")
+    },
+    (a) => client.sites.dryRunConfig(a.cbid, a.config, { mode: a.mode ?? "patch" })
+  );
+  tool(
+    "verify_consent_log",
+    "Verify a site's consent log has not been tampered with. Each record carries the hash of the one before it, so an edited, reordered or deleted record breaks the chain and this returns valid: false. This is the evidence behind a consent log \u2014 what you check when someone asks whether the record can be trusted, not just what it says.",
+    { ...cbid },
+    (a) => client.consent.verify(a.cbid)
+  );
+  tool(
+    "get_consent_stats",
+    "Get aggregated per-day consent statistics for a site.",
+    { ...cbid, ...range },
+    (a) => client.consent.stats(a.cbid, { from: a.from, to: a.to })
+  );
+  tool(
+    "get_consent_log",
+    "Get recent anonymised consent records for a site.",
+    { ...cbid, ...range, limit: import_zod3.z.number().optional().describe("Max records to return (default 200).") },
+    (a) => client.consent.log(a.cbid, {
+      from: a.from,
+      to: a.to,
+      limit: a.limit
+    })
+  );
+  tool(
+    "get_subject_consent",
+    "One person's consent records across every site in the org \u2014 web, mobile and desktop \u2014 by the subjectId your apps attach. Consent data: needs the consent:read scope. Read-only.",
+    { subjectId: import_zod3.z.string() },
+    (a) => client.subjects.consent(a.subjectId)
+  );
+  tool("list_dsar", "List all Data Subject Access Requests for your organization.", {}, () => client.dsar.list());
+  tool(
+    "update_dsar_executor",
+    "Change a connected system in place \u2014 its profile, address, credential or auto flag. Only what you pass changes; the stored credential is kept unless you give a new one.",
+    { id: import_zod3.z.string(), patch: import_zod3.z.record(import_zod3.z.unknown()) },
+    (a) => client.fulfillment.updateExecutor(a.id, a.patch)
+  );
+  tool(
+    "get_dsar",
+    "One rights request by id, including its status and the deadline it must be answered by.",
+    { id: import_zod3.z.string() },
+    (a) => client.dsar.get(a.id)
+  );
+  tool(
+    "erase_dsar_subject",
+    "For a deletion request that is past identity verification: erase the person\u2019s consent records on one site, identified by their consent stamp. Irreversible. The erasure is noted on the request. If the response carries a warning, nothing was cryptographically erased \u2014 tell the user.",
+    { id: import_zod3.z.string(), cbid: import_zod3.z.string(), stamp: import_zod3.z.string() },
+    (a) => client.dsar.erase(a.id, a.cbid, a.stamp)
+  );
+  tool(
+    "export_dsar_subject",
+    "For an access or portability request that is past identity verification: the person\u2019s consent records on one site, identified by their consent stamp. The export is noted on the request.",
+    { id: import_zod3.z.string(), cbid: import_zod3.z.string(), stamp: import_zod3.z.string() },
+    (a) => client.dsar.export(a.id, a.cbid, a.stamp)
+  );
+  tool(
+    "get_dsar_response_notice",
+    "The subject-facing response notice for a request, as plain text \u2014 what to send the person. Read-only; nothing is sent.",
+    { id: import_zod3.z.string() },
+    (a) => client.dsar.response(a.id)
+  );
+  tool(
+    "create_dsar",
+    "Open a new Data Subject Access Request.",
+    {
+      type: import_zod3.z.enum(["access", "deletion", "rectification", "portability", "opt-out"]).describe("DSAR right being exercised."),
+      subjectEmail: import_zod3.z.string().describe("The data subject\u2019s email."),
+      regulation: import_zod3.z.enum(["gdpr", "ccpa"]).describe("Governing regulation."),
+      note: import_zod3.z.string().optional().describe("Optional free-text note."),
+      test: import_zod3.z.boolean().optional().describe("Mark it as a test request: kept off the SLA board and deletable afterwards with delete_test_dsar.")
+    },
+    (a) => client.dsar.create({
+      type: a.type,
+      subjectEmail: a.subjectEmail,
+      regulation: a.regulation,
+      ...typeof a.note === "string" ? { note: a.note } : {},
+      ...a.test === true ? { test: true } : {}
+    })
+  );
+  tool(
+    "delete_test_dsar",
+    "Delete a TEST rights request (one created with test: true), with its tasks and their upstream log. Real requests cannot be deleted and are refused. The deletion is recorded in the audit log.",
+    { id: import_zod3.z.string().describe("The test request id.") },
+    async (a) => {
+      await client.dsar.delete(a.id);
+      return { deleted: a.id };
+    }
+  );
+  tool(
+    "advance_dsar",
+    "Advance a DSAR to a new status (received \u2192 verifying \u2192 in_progress \u2192 completed, or rejected).",
+    {
+      id: import_zod3.z.string().describe("The DSAR id."),
+      toStatus: import_zod3.z.enum(["received", "verifying", "in_progress", "completed", "rejected"]).describe("Target status.")
+    },
+    (a) => client.dsar.advance(a.id, a.toStatus)
+  );
+  tool(
+    "export_consent",
+    "Export a site\u2019s consent log as raw CSV text.",
+    { ...cbid, ...range },
+    (a) => client.consent.export(a.cbid, { from: a.from, to: a.to })
+  );
+  tool(
+    "get_receipt",
+    "Fetch the signed consent receipt for a single consent record (by stamp).",
+    { ...cbid, stamp: import_zod3.z.string().describe("The consent record stamp/id.") },
+    (a) => client.consent.receipt(a.cbid, a.stamp)
+  );
+  tool("delete_site", "Delete a site (cbid) and its configuration from your org.", { ...cbid }, async (a) => {
+    await client.sites.delete(a.cbid);
+    return { ok: true };
+  });
+  tool("list_vendors", "List vendors (processors) with their computed risk scores.", {}, () => client.vendors.list());
+  tool(
+    "create_vendor",
+    "Register a vendor (processor) and compute its risk score.",
+    {
+      name: import_zod3.z.string().describe("Vendor name."),
+      category: import_zod3.z.string().describe("Vendor category, e.g. analytics."),
+      dataShared: import_zod3.z.array(import_zod3.z.string()).describe("Categories of data shared with the vendor."),
+      dpaSigned: import_zod3.z.boolean().describe("Whether a Data Processing Agreement is signed."),
+      subprocessors: import_zod3.z.number().describe("Number of subprocessors."),
+      certifications: import_zod3.z.array(import_zod3.z.string()).describe("Compliance certifications, e.g. ISO27001."),
+      region: import_zod3.z.string().describe("Primary processing region, e.g. EU.")
+    },
+    (a) => client.vendors.create({
+      name: a.name,
+      category: a.category,
+      dataShared: a.dataShared,
+      dpaSigned: a.dpaSigned,
+      subprocessors: a.subprocessors,
+      certifications: a.certifications,
+      region: a.region
+    })
+  );
+  tool("list_ropa", "List Records of Processing Activities (RoPA) for your organization.", {}, () => client.ropa.list());
+  tool("export_ropa_csv", "The org\u2019s RoPA (GDPR Art. 30) as CSV. Read-only.", {}, () => client.ropa.exportCsv());
+  tool(
+    "create_ropa",
+    "Create a Record of Processing Activity (RoPA) entry.",
+    {
+      name: import_zod3.z.string().describe("Activity name."),
+      purpose: import_zod3.z.string().describe("Purpose of processing."),
+      legalBasis: import_zod3.z.enum(["consent", "contract", "legal-obligation", "vital-interests", "public-task", "legitimate-interests"]).describe("GDPR legal basis."),
+      dataCategories: import_zod3.z.array(import_zod3.z.string()).describe("Categories of personal data."),
+      recipients: import_zod3.z.array(import_zod3.z.string()).describe("Recipients of the data."),
+      retentionDays: import_zod3.z.number().describe("Retention period in days."),
+      crossBorderTransfer: import_zod3.z.boolean().describe("Whether data is transferred across borders.")
+    },
+    (a) => client.ropa.create({
+      name: a.name,
+      purpose: a.purpose,
+      legalBasis: a.legalBasis,
+      dataCategories: a.dataCategories,
+      recipients: a.recipients,
+      retentionDays: a.retentionDays,
+      crossBorderTransfer: a.crossBorderTransfer
+    })
+  );
+  tool(
+    "get_site_cookies",
+    "List the cookies discovered on a site, with their consent categories.",
+    { ...cbid },
+    (a) => client.sites.cookies(a.cbid)
+  );
+  tool(
+    "scan_site",
+    "Trigger a cookie scan for a site. Returns the scan job state.",
+    { ...cbid },
+    (a) => client.sites.scan(a.cbid)
+  );
+  tool(
+    "get_scan_status",
+    "Get the status/result of a site\u2019s most recent cookie scan.",
+    { ...cbid },
+    (a) => client.sites.scanStatus(a.cbid)
+  );
+  tool(
+    "get_ab_results",
+    "Get A/B banner experiment results (per variant) for a site.",
+    { ...cbid },
+    (a) => client.sites.ab(a.cbid)
+  );
+  tool("list_brand_kits", "List reusable brand kits (colors/logo/typography) for your org.", {}, () => client.brandKits.list());
+  tool("list_preferences", "List configurable consent preferences/purposes for your org.", {}, () => client.preferences.list());
+  tool("list_members", "List the members of your organization.", {}, () => client.members.list());
+  tool("list_api_keys", "List the API keys for your organization (secrets are not returned).", {}, () => client.keys.list());
+  tool("get_usage", "Get the current usage/quota summary for your organization.", {}, () => client.usage());
+  tool("list_webhooks", "List webhook subscriptions for your organization.", {}, () => client.webhooks.list());
+  tool(
+    "create_webhook",
+    "Create a webhook subscription. The response includes the signing secret (shown once).",
+    {
+      url: import_zod3.z.string().describe("HTTPS endpoint to deliver events to."),
+      events: import_zod3.z.array(import_zod3.z.string()).describe("Event names to subscribe to, e.g. consent.created."),
+      cbid: import_zod3.z.string().optional().describe("Optional site cbid to scope the subscription to.")
+    },
+    (a) => client.webhooks.create({
+      url: a.url,
+      events: a.events,
+      ...typeof a.cbid === "string" ? { cbid: a.cbid } : {}
+    })
+  );
+  tool(
+    "roll_webhook_secret",
+    "Rotate a webhook subscription\u2019s signing secret. The new secret is returned once; the receiving endpoint must be updated to verify with it.",
+    { id: import_zod3.z.string() },
+    (a) => client.webhooks.rollSecret(a.id)
+  );
+  tool(
+    "test_webhook",
+    "Send a signed test event to a webhook subscription now, and report what the endpoint answered.",
+    { id: import_zod3.z.string() },
+    (a) => client.webhooks.test(a.id)
+  );
+  tool(
+    "list_webhook_dead_letters",
+    "Webhook deliveries that failed every retry, newest first, with the last status or error. Read-only.",
+    {},
+    () => client.webhooks.deadLetters()
+  );
+  tool(
+    "replay_webhook_dead_letter",
+    "Deliver a dead-lettered webhook event again, to the subscription as it is now.",
+    { id: import_zod3.z.string() },
+    (a) => client.webhooks.replayDeadLetter(a.id)
+  );
+  tool(
+    "update_webhook",
+    "Change a webhook subscription, or pause it with active:false (delivery stops; the subscription is kept). Only the fields given change. cbid: null widens it to every property in the org.",
+    {
+      id: import_zod3.z.string(),
+      url: import_zod3.z.string().optional(),
+      events: import_zod3.z.array(import_zod3.z.string()).optional(),
+      cbid: import_zod3.z.string().nullable().optional(),
+      active: import_zod3.z.boolean().optional()
+    },
+    (a) => client.webhooks.update(a.id, {
+      ...a.url !== void 0 ? { url: a.url } : {},
+      ...a.events !== void 0 ? { events: a.events } : {},
+      ...a.cbid !== void 0 ? { cbid: a.cbid } : {},
+      ...a.active !== void 0 ? { active: a.active } : {}
+    })
+  );
+  tool("delete_webhook", "Delete a webhook subscription by id.", { id: import_zod3.z.string().describe("The webhook subscription id.") }, async (a) => {
+    await client.webhooks.delete(a.id);
+    return { ok: true };
+  });
+  tool(
+    "verify_site",
+    "Verify that your organization controls a domain by one of three challenge methods (dns / meta / file). Required to unlock consent export and signed receipts.",
+    { ...cbid, method: import_zod3.z.enum(["dns", "meta", "file"]).describe("Challenge method: dns (TXT record), meta (HTML tag), or file (/.well-known/cookiemunch-verify.txt).") },
+    (a) => client.sites.verify(a.cbid, a.method)
+  );
+  tool(
+    "get_verification_challenge",
+    "Exactly what to publish to prove control of a site\u2019s domain: the DNS TXT record, the meta tag, the file, or installing the embed. Read-only \u2014 publish one, then call verify_site.",
+    { cbid: import_zod3.z.string() },
+    (a) => client.sites.verifyChallenge(a.cbid)
+  );
+  tool(
+    "match_site_brand",
+    "Extract theme colors and typography from a site's homepage to suggest a matching brand theme for the consent banner.",
+    { ...cbid },
+    (a) => client.sites.brand(a.cbid)
+  );
+  tool(
+    "get_flow",
+    "Get the v2 banner flow config for a site, including current views, categories, and any lint issues.",
+    { cbid: import_zod3.z.string().describe("Site identifier (cbid).") },
+    (a) => client.sites.getFlow(a.cbid)
+  );
+  tool(
+    "edit_flow",
+    "Apply a batch of structured edit operations to a site's v2 banner flow. All ops are validated server-side and the final config must be lint-clean before it is saved.",
+    {
+      cbid: import_zod3.z.string().describe("Site identifier (cbid)."),
+      operations: import_zod3.z.array(import_zod3.z.record(import_zod3.z.unknown())).describe(
+        'Ordered list of ops. Each must have an "op" field: addView | removeView | addElement | setButtonTransition | addCustomCategory.'
+      )
+    },
+    (a) => client.sites.editFlow(a.cbid, a.operations)
+  );
+  tool(
+    "set_flow",
+    "Wholesale replace a site's v2 banner flow with a complete config (e.g. from a template). Validated server-side before it is saved.",
+    {
+      cbid: import_zod3.z.string().describe("Site identifier (cbid)."),
+      config: import_zod3.z.record(import_zod3.z.unknown()).describe("A full v2 FlowConfig object ({ v:2, flow, categories, ... }).")
+    },
+    (a) => client.sites.setFlow(a.cbid, a.config)
+  );
+  registerConfigTools(tool, client);
+  registerPlatformTools(tool, client);
+  tool(
+    "invite_member",
+    "Invite a person to your organization by email. role must be admin, member, or viewer. The org is derived from the API key \u2014 you cannot invite into a different org.",
+    {
+      email: import_zod3.z.string().describe("Email address of the person to invite."),
+      role: import_zod3.z.enum(["admin", "member", "viewer"]).describe("Role to assign: admin, member, or viewer. owner is not assignable via API key.")
+    },
+    (a) => client.members.invite(a.email, a.role)
+  );
+  tool(
+    "set_member_role",
+    "Change the role of a member in your organization. The org owner's role cannot be changed.",
+    {
+      userId: import_zod3.z.string().describe("The userId of the member whose role to change."),
+      role: import_zod3.z.enum(["admin", "member", "viewer"]).describe("New role: admin, member, or viewer.")
+    },
+    (a) => client.members.setRole(a.userId, a.role)
+  );
+  tool(
+    "remove_member",
+    "Remove a member from your organization. The org owner cannot be removed.",
+    {
+      userId: import_zod3.z.string().describe("The userId of the member to remove.")
+    },
+    async (a) => {
+      await client.members.remove(a.userId);
+      return { ok: true };
+    }
+  );
+  tool(
+    "create_brand_kit",
+    "Create a reusable brand kit (colors, logo, typography) for your organization's consent banners.",
+    {
+      name: import_zod3.z.string().describe("Display name for the brand kit."),
+      theme: import_zod3.z.record(import_zod3.z.unknown()).describe("Theme tokens (colors, fonts, etc.) as a JSON object."),
+      content: import_zod3.z.record(import_zod3.z.unknown()).optional().describe("Optional banner copy overrides."),
+      logoUrl: import_zod3.z.string().optional().describe("Optional URL for your org logo."),
+      customCss: import_zod3.z.string().optional().describe("Optional custom CSS string to inject into the banner.")
+    },
+    (a) => client.brandKits.create({
+      name: a.name,
+      theme: a.theme,
+      ...a.content !== void 0 ? { content: a.content } : {},
+      ...typeof a.logoUrl === "string" ? { logoUrl: a.logoUrl } : {},
+      ...typeof a.customCss === "string" ? { customCss: a.customCss } : {}
+    })
+  );
+  tool(
+    "delete_brand_kit",
+    "Delete a brand kit by id. The kit must belong to your organization (cross-org deletes are rejected).",
+    {
+      id: import_zod3.z.string().describe("The brand kit id to delete.")
+    },
+    async (a) => {
+      await client.brandKits.delete(a.id);
+      return { ok: true };
+    }
+  );
+  tool(
+    "save_preference",
+    "Save or update the consent preferences for an end-user (by subjectId) within your organization. purposes is a map of purpose-name \u2192 boolean.",
+    {
+      subjectId: import_zod3.z.string().describe("The end-user identifier (e.g. email or internal user id)."),
+      purposes: import_zod3.z.record(import_zod3.z.boolean()).describe('Map of purpose names to consent values, e.g. { "newsletter": true, "analytics": false }.')
+    },
+    (a) => client.preferences.save(a.subjectId, a.purposes)
+  );
+  tool(
+    "get_preference",
+    "One end-user\u2019s saved preferences, by subjectId. Read-only.",
+    { subjectId: import_zod3.z.string() },
+    (a) => client.preferences.get(a.subjectId)
+  );
+  tool(
+    "issue_api_key",
+    "Issue a new API key. The secret is returned once and never again. Prefer the least privilege the job needs: `scopes` limits what it can do, `cbids` locks it to specific sites (it then cannot reach anything org-wide), `expiresInDays` retires it. Omitting all three mints a full-access, org-wide, non-expiring key.",
+    {
+      name: import_zod3.z.string().optional(),
+      scopes: import_zod3.z.array(import_zod3.z.string()).optional(),
+      cbids: import_zod3.z.array(import_zod3.z.string()).min(1).optional(),
+      expiresInDays: import_zod3.z.number().int().min(1).max(3650).optional()
+    },
+    (a) => client.keys.issue({
+      ...a.name ? { name: a.name } : {},
+      ...a.scopes ? { scopes: a.scopes } : {},
+      ...a.cbids ? { cbids: a.cbids } : {},
+      ...a.expiresInDays !== void 0 ? { expiresInDays: a.expiresInDays } : {}
+    })
+  );
+  tool("revoke_api_key", "Revoke an API key by its prefix. Takes effect immediately; anything using that key stops working.", { prefix: import_zod3.z.string() }, async (a) => {
+    await client.keys.revoke(a.prefix);
+    return { revoked: a.prefix };
+  });
+  tool(
+    "import_cookie_declaration",
+    "Read a cookie declaration exported from another CMP (OneTrust, Cookiebot, CookieYes, or any CSV/JSON with the same columns) and translate its categories into ours. Nothing is applied \u2014 it comes back for review, with the rows whose category could not be placed listed separately.",
+    { cbid: import_zod3.z.string(), data: import_zod3.z.string().describe("The exported file, as text (CSV or JSON).") },
+    (a) => client.sites.importDeclaration(a.cbid, a.data)
+  );
+  tool(
+    "get_blocked_pages",
+    "Pages where the embed could not load its banner renderer \u2014 the page\u2019s Content Security Policy or Trusted Types policy refused it, so nobody there can be asked for consent. An empty list is healthy. Read-only.",
+    { cbid: import_zod3.z.string() },
+    (a) => client.sites.blocked(a.cbid)
+  );
+  tool(
+    "roll_api_key",
+    "Rotate an API key: returns a new secret once, with the same name, scopes, property lock and expiry. The old secret stops working immediately \u2014 if it is the key this server runs with, this server stops working too until it is reconfigured.",
+    { prefix: import_zod3.z.string() },
+    (a) => client.keys.roll(a.prefix)
+  );
+  tool(
+    "update_api_key",
+    "Rename an API key, or replace its scopes or the properties it is locked to. Only the fields given change; the secret does not.",
+    {
+      prefix: import_zod3.z.string(),
+      name: import_zod3.z.string().optional(),
+      scopes: import_zod3.z.array(import_zod3.z.string()).optional(),
+      cbids: import_zod3.z.array(import_zod3.z.string()).min(1).optional()
+    },
+    (a) => client.keys.update(a.prefix, {
+      ...a.name !== void 0 ? { name: a.name } : {},
+      ...a.scopes ? { scopes: a.scopes } : {},
+      ...a.cbids ? { cbids: a.cbids } : {}
+    })
+  );
+  tool("get_org", "Your organisation: id, name, plan and logo URL. Read-only.", {}, () => client.org.get());
+  tool(
+    "update_org",
+    "Rename your organisation or set its logo. logoUrl: null removes the logo; upload an image with upload_asset to get a URL. Deleting the organisation is not possible here.",
+    { name: import_zod3.z.string().min(1).optional(), logoUrl: import_zod3.z.string().nullable().optional() },
+    (a) => client.org.update({
+      ...a.name !== void 0 ? { name: a.name } : {},
+      ...a.logoUrl !== void 0 ? { logoUrl: a.logoUrl } : {}
+    })
+  );
+  tool(
+    "get_audit_log",
+    "The organisation\u2019s audit log, newest first: administrative changes made in the dashboard or through the API, and who made them. Read-only.",
+    { limit: import_zod3.z.number().int().min(1).max(500).optional() },
+    (a) => client.audit(a.limit)
+  );
+  tool(
+    "upload_asset",
+    "Upload an image \u2014 a banner logo \u2014 and get its public URL. data is base64 (a data: URL also works); PNG, JPEG, WebP, GIF or SVG, up to 1,000,000 bytes.",
+    {
+      data: import_zod3.z.string(),
+      contentType: import_zod3.z.enum(["image/png", "image/jpeg", "image/webp", "image/gif", "image/svg+xml"])
+    },
+    (a) => client.assets.upload({ data: a.data, contentType: a.contentType })
+  );
+  tool(
+    "delete_asset",
+    "Delete a stored image by its URL (or file name). Only your own organisation\u2019s images can be named.",
+    { url: import_zod3.z.string().describe("The URL upload_asset returned, or just its file name.") },
+    async (a) => {
+      await client.assets.delete(a.url);
+      return { deleted: a.url };
+    }
+  );
+  tool(
+    "list_customers",
+    "The child orgs this reseller has provisioned, with pooled usage against the reseller plan\u2019s cap. Read-only.",
+    {},
+    () => client.reseller.list()
+  );
+  tool(
+    "get_customer",
+    "One child org: its controller details and usage. Read-only.",
+    { id: import_zod3.z.string() },
+    (a) => client.reseller.get(a.id)
+  );
+  tool(
+    "provision_customer",
+    "Create a new child org under this reseller. With `mintKey`, its first API key is returned once. Counts toward the reseller plan\u2019s pooled limits.",
+    {
+      name: import_zod3.z.string(),
+      ownerEmail: import_zod3.z.string().optional(),
+      delegatedAccess: import_zod3.z.boolean().optional().describe("Whether this reseller may act inside the child."),
+      mintKey: import_zod3.z.boolean().optional(),
+      keyScopes: import_zod3.z.array(import_zod3.z.string()).optional()
+    },
+    (a) => client.reseller.create({
+      name: a.name,
+      ...a.ownerEmail ? { ownerEmail: a.ownerEmail } : {},
+      ...a.delegatedAccess !== void 0 ? { delegatedAccess: a.delegatedAccess } : {},
+      ...a.mintKey !== void 0 ? { mintKey: a.mintKey } : {},
+      ...a.keyScopes ? { keyScopes: a.keyScopes } : {}
+    })
+  );
+  tool(
+    "update_customer",
+    "Change a child org\u2019s status, delegated access or DSAR routing. `dsarRouting: null` clears the override.",
+    {
+      id: import_zod3.z.string(),
+      status: import_zod3.z.enum(["active", "suspended"]).optional(),
+      delegatedAccess: import_zod3.z.boolean().optional(),
+      dsarRouting: import_zod3.z.enum(["reseller", "child"]).nullable().optional()
+    },
+    (a) => client.reseller.update(a.id, {
+      ...a.status ? { status: a.status } : {},
+      ...a.delegatedAccess !== void 0 ? { delegatedAccess: a.delegatedAccess } : {},
+      ...a.dsarRouting !== void 0 ? { dsarRouting: a.dsarRouting } : {}
+    })
+  );
+  tool(
+    "suspend_customer",
+    "Suspend a child org: it stops ingesting consent and its keys stop working, and it can be reactivated with update_customer. Its data is kept. (Permanent deletion is deliberately not available here.)",
+    { id: import_zod3.z.string() },
+    async (a) => {
+      await client.reseller.deprovision(a.id);
+      return { suspended: a.id };
+    }
+  );
+  tool(
+    "list_customer_keys",
+    "A child org's API key prefixes. Never the secrets. Read-only.",
+    { id: import_zod3.z.string() },
+    (a) => client.reseller.listKeys(a.id)
+  );
+  tool(
+    "issue_customer_key",
+    "Mint an API key for a child org. The secret is returned once. Prefer scopes and a property lock over a full-access key.",
+    { id: import_zod3.z.string(), name: import_zod3.z.string().optional(), scopes: import_zod3.z.array(import_zod3.z.string()).optional(), cbids: import_zod3.z.array(import_zod3.z.string()).min(1).optional() },
+    (a) => client.reseller.mintKey(a.id, {
+      ...a.name ? { name: a.name } : {},
+      ...a.scopes ? { scopes: a.scopes } : {},
+      ...a.cbids ? { cbids: a.cbids } : {}
+    })
+  );
+  tool("revoke_customer_key", "Revoke a child org's API key by prefix. Takes effect immediately.", { id: import_zod3.z.string(), prefix: import_zod3.z.string() }, async (a) => {
+    await client.reseller.revokeKey(a.id, a.prefix);
+    return { revoked: a.prefix };
+  });
+  tool(
+    "erase_subject_data",
+    "IRREVERSIBLY crypto-erase a data subject's consent records by their consent-receipt stamp (GDPR/CCPA deletion). Destroys the encryption key; the tamper-evident chain stays intact.",
+    { cbid: import_zod3.z.string(), stamp: import_zod3.z.string() },
+    (a) => client.consent.eraseSubject(a.cbid, a.stamp)
+  );
+  tool(
+    "export_subject_data",
+    "Export a data subject's consent records (GDPR access/portability).",
+    { cbid: import_zod3.z.string(), stamp: import_zod3.z.string() },
+    (a) => client.consent.exportSubject(a.cbid, a.stamp)
+  );
+  tool("list_banners", "List reusable banner designs in your org.", {}, () => client.banners.list());
+  tool(
+    "create_banner",
+    "Create a reusable banner design.",
+    { name: import_zod3.z.string(), json: import_zod3.z.record(import_zod3.z.unknown()).describe("A v2 BannerConfig.") },
+    (a) => client.banners.create({ name: a.name, json: a.json })
+  );
+  tool("get_banner", "Get a banner design by id.", { id: import_zod3.z.string() }, (a) => client.banners.get(a.id));
+  tool(
+    "update_banner",
+    "Update a banner design (name and/or config).",
+    { id: import_zod3.z.string(), name: import_zod3.z.string().optional(), json: import_zod3.z.record(import_zod3.z.unknown()).optional() },
+    (a) => client.banners.update(a.id, {
+      ...a.name !== void 0 ? { name: a.name } : {},
+      ...a.json !== void 0 ? { json: a.json } : {}
+    })
+  );
+  tool("delete_banner", "Delete a banner design (fails if assigned to sites).", { id: import_zod3.z.string() }, async (a) => {
+    await client.banners.delete(a.id);
+    return { ok: true };
+  });
+  tool(
+    "get_banner_assignments",
+    "The sites (cbids) a banner design is currently assigned to. Read-only.",
+    { id: import_zod3.z.string() },
+    (a) => client.banners.assignments(a.id)
+  );
+  tool(
+    "assign_banner",
+    "Set which sites (cbids) use a banner design.",
+    { id: import_zod3.z.string(), cbids: import_zod3.z.array(import_zod3.z.string()) },
+    (a) => client.banners.setAssignments(a.id, a.cbids)
+  );
+  tool(
+    "publish_banner",
+    "Publish a design live to all its assigned sites.",
+    { id: import_zod3.z.string() },
+    (a) => client.banners.publish(a.id)
+  );
+}
+
+// src/index.ts
+function createCookieMunchMcp(opts) {
+  const client = opts.client ?? (0, import_sdk.createCookieMunch)({ apiKey: opts.apiKey, baseUrl: opts.baseUrl });
+  const server = new import_mcp.McpServer({ name: "cookiemunch", version: "1.0.0" });
+  registerTools(server, client);
+  return server;
+}
+
+// src/bin.ts
+async function main() {
+  const apiKey = process.env.COOKIEMUNCH_API_KEY;
+  if (!apiKey) {
+    console.error("COOKIEMUNCH_API_KEY is required.");
+    process.exit(1);
+  }
+  const baseUrl = process.env.COOKIEMUNCH_BASE_URL ?? "http://localhost:8787";
+  const server = createCookieMunchMcp({ apiKey, baseUrl });
+  const transport = new import_stdio.StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch((err) => {
+  console.error("cookiemunch-mcp failed to start:", err);
+  process.exit(1);
+});
+//# sourceMappingURL=bin.cjs.map