@prontosite/mcp 0.5.0 → 0.8.0

package/CHANGELOG.md

@@ -3,6 +3,37 @@
 Alle nennenswerten Änderungen am MCP-Server für ProntoSite. Der Server ist ein dünner Client um die
 ProntoSite Deploy-API; die eigentliche Logik lebt serverseitig.
 
+## 0.8.0 – 2026-09-23
+
+- **Neu: `site_embeds`** – listet alle externen Einbettungen (Host, Seite(n), Kategorie `gated`/`notwendig`). Lesend.
+- **Neu: `site_embed_consent`** – stuft eine Einbettung als `notwendig` (§ 25 Abs. 2 Nr. 2 TDDDG,
+  Kunden-Eigenverantwortung) oder wieder als `gated` (Zwei-Klick) ein. `notwendig` nur mit `confirmed:true`;
+  ohne Bestätigung antwortet der Server 400 mit dem Verantwortungs-Text, den der Assistent dem Nutzer
+  vorlegen muss. Optional seiten-gebunden (`page`) – so bleibt der Dienst nur dort einwilligungsfrei, wo die
+  Funktion gebraucht wird. Datenschutz-Text + Cookie-Richtlinie werden beim nächsten Publish automatisch
+  angepasst (technisch erforderlicher Dienst statt Einwilligung). Betreuer-Token gilt für betreute Kunden.
+
+## 0.7.0 – 2026-09-23
+
+- **Ambige Config erkannt:** Liegt ein Top-Level-Token (env `PRONTOSITE_TOKEN` bzw. `token`) NEBEN einer
+  `sites`-Map, warnt der Server beim Start deutlich auf stderr und `sites_list` trägt den Hinweis mit:
+  „Beide Konfigurationen gefunden — sites-Map wird genutzt, env-Token ignoriert."
+- **Betreuer-Token hat IMMER Vorrang:** Ist das Top-Level-Token ein Betreuer-Token (scope=manager), nutzt
+  `sites_list` dieses (deckt alle Kunden ab) und meldet die daneben liegende `sites`-Map als
+  Konfigurationsfehler (Map ignoriert). Ein Einzel-Token wird weiterhin von der Map verdrängt.
+- **`liveUrl` = kanonische Kundendomain**, sobald `customDomains` gesetzt ist (sonst die Slug-Subdomain) –
+  in `sites_list` und `site_status`. So wird gedanklich nie „auf die falsche Adresse" deployt; die Slug-URL
+  leitet ohnehin per 301 auf die Kundendomain weiter.
+
+## 0.6.0 – 2026-09-22
+
+- **Neu: `site_domain_status`** – Kundendomain-Status (verbunden/kanonisch/Zertifikat-bis) + offene Jobs;
+  mit `check` nur eine Live-DNS-Prüfung (A @+www → Server-IP, keine AAAA) vor dem Verbinden. LESEND.
+- **Neu: `site_domain_connect`** (SCHREIBEND) – eigene Domain verbinden (nginx-Block + HTTPS-Zertifikat
+  automatisch, kanonisch `www`/`apex`, inkl. Republish) oder trennen (`action:disconnect`). Voraussetzung:
+  DNS zeigt bereits auf den Server (vorher `site_domain_status` mit `check`). Ab Starter-Plan (Betreuer-/
+  Operator-Token ausgenommen); eine Domain nur an EINER Website. Läuft asynchron über die Job-Queue.
+
 ## 0.5.0 – 2026-09-20
 
 - **Neu: `site_legal_options`** – Anzeige-Optionen der Rechtstext-Widgets je Rolle (impressum/datenschutz):

package/README.md

@@ -89,6 +89,10 @@ sichern: `cp ~/.prontosite.json ~/.prontosite.json.bak`).
 | `site_company_get({ site? })` | Firmendaten (Impressum/Footer) lesen. **Lesend.** |
 | `site_company_set({ site?, company, siteOverride? })` | Firmendaten setzen/ergänzen (Teil-Update); füllen Impressum/Datenschutz beim Deploy. **Schreibend.** |
 | `site_legal_options({ site?, impressum?, datenschutz? })` | Anzeige-Optionen der Rechtstexte (showTitle, showDate, draftNotice); ohne Rolle nur lesen. **Schreibend.** |
+| `site_domain_status({ site?, check? })` | Kundendomain-Status (verbunden/kanonisch/Zert-bis) + offene Jobs; mit `check` nur Live-DNS-Prüfung. **Lesend.** |
+| `site_domain_connect({ site?, domain, canonical?, action? })` | Eigene Domain verbinden (nginx + HTTPS automatisch, `www`/`apex`) oder trennen; DNS muss auf den Server zeigen; ab Starter-Plan. **Schreibend.** |
+| `site_embeds({ site? })` | Externe Einbettungen der Website: Host, Seite(n), aktuelle Einwilligungs-Kategorie (`gated` = Zwei-Klick \| `notwendig`). **Lesend.** |
+| `site_embed_consent({ site?, host, page?, category, confirmed })` | Einbettung als `notwendig` (§ 25 Abs. 2 Nr. 2 TDDDG, Eigenverantwortung) oder wieder `gated` einstufen; `notwendig` nur mit `confirmed:true` (sonst 400 mit Verantwortungs-Text). Optional seiten-gebunden. Datenschutz/Cookie-Richtlinie passen sich beim nächsten Publish an. **Schreibend.** |
 
 `site_deploy` und `site_publish` sind **schreibende** Aktionen (verändern die Live-Website). Die
 Tool-Beschreibungen weisen den Assistenten an, vorher rückzufragen. Jeder Aufruf wird serverseitig auditiert.

package/api.mjs

@@ -27,13 +27,19 @@ export function loadConfig(env = process.env, home = os.homedir()) {
   } catch { /* defekte Datei ignorieren – Env kann trotzdem reichen */ }
   const host = (env.PRONTOSITE_HOST || file.host || DEFAULT_HOST).replace(/^https?:\/\//, "").replace(/\/+$/, "");
   const sites = (file.sites && typeof file.sites === "object") ? file.sites : null;
-  return {
-    host,
-    token: env.PRONTOSITE_TOKEN || file.token || "",
-    site: env.PRONTOSITE_SITE || file.site || "active",
-    sites,
-    defaultSite: env.PRONTOSITE_SITE || file.defaultSite || null,
-  };
+  const envToken = env.PRONTOSITE_TOKEN || "";
+  const token = envToken || file.token || "";
+  const tokenSource = envToken ? "env" : (file.token ? "datei" : null);
+  // Ambige Konfiguration: ein Top-Level-Token (Einzel/Betreuer) NEBEN einer sites-Map. Auflösung:
+  // Ein Betreuer-Token (scope=manager) hat IMMER Vorrang (die sites-Map ist dann ein Konfigurationsfehler);
+  // ein Einzel-Token wird von der Map verdrängt. Ob es ein Betreuer-Token ist, weiß nur der Server →
+  // sites_list klärt es per Server-Antdwort; hier nur die generische Startwarnung.
+  const warnings = [];
+  if (sites && token) warnings.push(
+    `Beide Konfigurationen gefunden — sites-Map wird genutzt, ${tokenSource === "env" ? "env-Token" : "Token"} ignoriert. `
+    + `(Ausnahme: ein Betreuer-Token hat Vorrang – eine sites-Map daneben ist ein Konfigurationsfehler; bitte eins entfernen.)`);
+  return { host, token, tokenSource, site: env.PRONTOSITE_SITE || file.site || "active", sites,
+    defaultSite: env.PRONTOSITE_SITE || file.defaultSite || null, warnings };
 }
 
 const needToken = (token, ref) => {
@@ -162,6 +168,46 @@ export async function apiCompanySet(cfg, { site, company, siteOverride = false }
   return asJson(res);
 }
 
+/** GET /api/domain/<site> – Kundendomain-Status (verbunden/kanonisch/Zertifikat-bis) + offene Jobs. Mit
+ *  check=<domain> stattdessen NUR die Live-DNS-Prüfung (A für @ und www → Server-IP, keine AAAA-Leichen). */
+export async function apiDomainStatus(cfg, { site, check } = {}, fetchImpl = fetch) {
+  const { token, slug } = resolveTarget(cfg, site);
+  const qs = check ? `?check=${encodeURIComponent(check)}` : "";
+  const res = await fetchImpl(`${baseUrl(cfg)}/domain/${encodeURIComponent(slug)}${qs}`, { headers: authHeaders(token) });
+  return asJson(res);
+}
+
+/** POST /api/domain/<site> – SCHREIBEND: eigene Domain verbinden (nginx-Block + HTTPS-Zertifikat werden
+ *  automatisch eingerichtet) oder trennen. Voraussetzung: der DNS zeigt bereits auf den Server – vorher
+ *  apiDomainStatus mit `check` nutzen. Läuft asynchron über die Job-Queue; Ergebnis via apiDomainStatus. */
+export async function apiDomainConnect(cfg, { site, domain, canonical = "www", action = "connect" } = {}, fetchImpl = fetch) {
+  if (!domain) throw new Error("domain erwartet.");
+  const { token, slug } = resolveTarget(cfg, site);
+  const res = await fetchImpl(`${baseUrl(cfg)}/domain/${encodeURIComponent(slug)}`, {
+    method: "POST", headers: { ...authHeaders(token), "content-type": "application/json" },
+    body: JSON.stringify({ domain, canonical, action }) });
+  return asJson(res);
+}
+
+/** GET /api/embeds/<site> – erkannte Embeds (Host, Seite(n), aktuelle Kategorie gated|notwendig). LESEND. */
+export async function apiEmbeds(cfg, { site } = {}, fetchImpl = fetch) {
+  const { token, slug } = resolveTarget(cfg, site);
+  const res = await fetchImpl(`${baseUrl(cfg)}/embeds/${encodeURIComponent(slug)}`, { headers: authHeaders(token) });
+  return asJson(res);
+}
+
+/** PUT /api/embeds/<site> – SCHREIBEND: ein Embed als „notwendig" (technisch erforderlich, § 25 Abs. 2 Nr. 2
+ *  TDDDG) oder zurück „gated" einstufen. „notwendig" NUR mit confirmed:true – sonst 400 mit dem
+ *  Verantwortungs-Text. Wirkt beim nächsten Veröffentlichen; Datenschutz-Text passt sich automatisch an. */
+export async function apiEmbedConsent(cfg, { site, host, page, category = "notwendig", confirmed = false } = {}, fetchImpl = fetch) {
+  if (!host) throw new Error("host erwartet.");
+  const { token, slug } = resolveTarget(cfg, site);
+  const res = await fetchImpl(`${baseUrl(cfg)}/embeds/${encodeURIComponent(slug)}`, {
+    method: "PUT", headers: { ...authHeaders(token), "content-type": "application/json" },
+    body: JSON.stringify({ host, page: page || null, category, confirmed: !!confirmed }) });
+  return asJson(res);
+}
+
 /** GET/PUT /api/legal-options/<site> – Anzeige-Optionen der Rechtstext-Widgets. Ohne impressum/datenschutz
  *  nur LESEN; sonst Teil-Update (nur echte Booleans wirken). */
 export async function apiLegalOptions(cfg, { site, impressum, datenschutz } = {}, fetchImpl = fetch) {
@@ -179,24 +225,41 @@ export async function apiLegalOptions(cfg, { site, impressum, datenschutz } = {}
 
 /** Alle erreichbaren Sites auflisten (Slug, Plan, Publish-Bedarf, letzte Änderung). Bei einer sites-Map wird
  *  jeder Eintrag per Status abgefragt; sonst die eine konfigurierte Site. Fehler je Site werden mitgeführt. */
-export async function sitesList(cfg, fetchImpl = fetch) {
-  if (cfg.sites) {
-    // Per-Kunde-Token-Map: jeden Eintrag einzeln abfragen (jeder Token → seine Site).
-    const out = await Promise.all(Object.keys(cfg.sites).map(async label => {
-      try {
-        const s = await apiStatus(cfg, { site: label }, fetchImpl);
-        return { label, slug: s.slug || null, id: s.site || null, name: s.name || null, plan: s.plan,
-          everPublished: s.everPublished, publishNeeded: s.publishNeeded, lastChangeAt: s.lastChangeAt || null, liveUrl: s.liveUrl || null };
-      } catch (e) { return { label, error: e.message }; }
-    }));
-    return { count: out.length, sites: out };
-  }
-  // Einzel-/Betreuer-Token: der Server liefert alle erreichbaren Sites (Betreuer-Token: ALLE betreuten Kunden,
-  // ohne Config-Pflege). GET /api/sites.
-  const { token } = resolveTarget(cfg, cfg.defaultSite || cfg.site || "active");
+// GET /api/sites mit EINEM Token → normalisierte Liste (Betreuer-Token: alle betreuten Kunden).
+async function apiSitesWithToken(cfg, token, fetchImpl) {
   const body = await asJson(await fetchImpl(`${baseUrl(cfg)}/sites`, { headers: authHeaders(token) }));
   const sites = (body.sites || []).map(s => ({ label: s.slug || s.site, slug: s.slug || null, id: s.site || null,
     name: s.name || null, plan: s.plan, everPublished: s.everPublished, publishNeeded: s.publishNeeded,
     lastChangeAt: s.lastChangeAt || null, liveUrl: s.liveUrl || null, customer: s.customer }));
-  return { count: sites.length, manager: !!body.manager, sites };
+  return { count: sites.length, manager: !!body.manager, hint: body.hint || null, sites };
+}
+// sites-Map abfragen: jeden Eintrag einzeln (jeder Token → seine Site).
+async function sitesFromMap(cfg, fetchImpl) {
+  const out = await Promise.all(Object.keys(cfg.sites).map(async label => {
+    try {
+      const s = await apiStatus(cfg, { site: label }, fetchImpl);
+      return { label, slug: s.slug || null, id: s.site || null, name: s.name || null, plan: s.plan,
+        everPublished: s.everPublished, publishNeeded: s.publishNeeded, lastChangeAt: s.lastChangeAt || null, liveUrl: s.liveUrl || null };
+    } catch (e) { return { label, error: e.message }; }
+  }));
+  return { count: out.length, sites: out };
+}
+
+export async function sitesList(cfg, fetchImpl = fetch) {
+  // Ambig (Top-Level-Token NEBEN sites-Map): Betreuer-Token hat IMMER Vorrang. Nur der Server kennt den
+  // Scope → das Top-Level-Token einmal prüfen: manager:true → dieses nutzen (Map ist Konfigurationsfehler);
+  // sonst die Map (Einzel-Token verdrängt).
+  if (cfg.sites && cfg.token) {
+    let probe = null;
+    try { probe = await apiSitesWithToken(cfg, cfg.token, fetchImpl); } catch { /* Token ungültig? → Map-Weg */ }
+    if (probe && probe.manager)
+      return { ...probe, configError: "Konfigurationsfehler: Betreuer-Token UND sites-Map konfiguriert. "
+        + "Der Betreuer-Token deckt bereits ALLE betreuten Kunden ab und hat Vorrang – die sites-Map wird ignoriert. "
+        + "Bitte die sites-Map (oder den Betreuer-Token) aus ~/.prontosite.json entfernen." };
+    return { ...(await sitesFromMap(cfg, fetchImpl)), warning: cfg.warnings[0] || null };
+  }
+  if (cfg.sites) return sitesFromMap(cfg, fetchImpl);
+  // Einzel-/Betreuer-Token ohne Map: der Server liefert alle erreichbaren Sites.
+  const { token } = resolveTarget(cfg, cfg.defaultSite || cfg.site || "active");
+  return apiSitesWithToken(cfg, token, fetchImpl);
 }

package/index.mjs

@@ -11,10 +11,13 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-import { loadConfig, apiStatus, apiExport, apiDeploy, apiPublish, sitesList, apiCompanyGet, apiCompanySet, apiLegalOptions } from "./api.mjs";
+import { loadConfig, apiStatus, apiExport, apiDeploy, apiPublish, sitesList, apiCompanyGet, apiCompanySet, apiLegalOptions, apiDomainStatus, apiDomainConnect, apiEmbeds, apiEmbedConsent } from "./api.mjs";
 
 const cfg = loadConfig();
-const server = new McpServer({ name: "prontosite", version: "0.3.1" });
+// Deutliche Startwarnung bei ambiger Konfiguration (Top-Level-Token NEBEN sites-Map). Nach stderr, damit
+// es im MCP-Log/Terminal auffällt; die endgültige Auflösung (Betreuer-Token-Vorrang vs. Map) klärt sites_list.
+for (const w of (cfg.warnings || [])) process.stderr.write("[prontosite-mcp] ⚠ " + w + "\n");
+const server = new McpServer({ name: "prontosite", version: "0.8.0" });
 const asText = obj => ({ content: [{ type: "text", text: JSON.stringify(obj, null, 2) }] });
 const asError = e => ({ isError: true, content: [{ type: "text", text: "Fehler: " + (e?.message || String(e)) }] });
 const SITE_DESC = "Website-Slug (z. B. 'mas-monti'). Ohne Angabe die Standard-Site der Config. Bei Betreuer-"
@@ -146,5 +149,59 @@ server.tool(
   }
 );
 
+server.tool(
+  "site_domain_status",
+  "LESEND: Kundendomain-Status einer Website – verbundene Domains (kanonisch/Weiterleitung), Zertifikat-"
+    + "Gültigkeit und offene Verbindungs-Jobs. Mit `check` stattdessen NUR eine Live-DNS-Prüfung der angegebenen "
+    + "Domain (A-Record für @ und www muss auf den Server zeigen, kein AAAA) – ideal VOR dem Verbinden.",
+  { site: z.string().optional().describe(SITE_DESC),
+    check: z.string().optional().describe("Domain (z. B. ihre-firma.de) NUR auf DNS-Bereitschaft prüfen, nichts verbinden.") },
+  async ({ site, check }) => { try { return asText(await apiDomainStatus(cfg, { site, check })); } catch (e) { return asError(e); } }
+);
+
+server.tool(
+  "site_domain_connect",
+  "SCHREIBEND: eigene Domain mit der Website verbinden oder trennen. Beim Verbinden werden nginx-Serverblock "
+    + "und HTTPS-Zertifikat (Let's Encrypt) automatisch eingerichtet und die Domain als kanonische Adresse gesetzt "
+    + "(inkl. Republish für Canonical/Sitemap). VORAUSSETZUNG: der DNS zeigt bereits auf den Server – vorher IMMER "
+    + "site_domain_status mit `check` aufrufen und das Ergebnis bestätigen lassen. Nur ab Starter-Plan (Betreuer-/"
+    + "Operator-Token ausgenommen); eine Domain kann nur an EINER Website hängen. Läuft asynchron über eine Job-"
+    + "Queue – danach site_domain_status pollen. action='disconnect' trennt die Domain wieder.",
+  { site: z.string().optional().describe(SITE_DESC),
+    domain: z.string().describe("Die zu verbindende/trennende Domain, z. B. ihre-firma.de (mit oder ohne www)."),
+    canonical: z.enum(["www", "apex"]).default("www").describe("Kanonische Adresse: 'www' (mit www) oder 'apex' (ohne www). Nur beim Verbinden relevant."),
+    action: z.enum(["connect", "disconnect"]).default("connect").describe("connect = verbinden, disconnect = trennen.") },
+  async ({ site, domain, canonical, action }) => {
+    try { return asText(await apiDomainConnect(cfg, { site, domain, canonical, action })); } catch (e) { return asError(e); }
+  }
+);
+
+server.tool(
+  "site_embeds",
+  "LESEND: erkannte eingebettete Inhalte Dritter (iframes) einer Website – je Embed Host, Seite(n) und "
+    + "aktuelle Consent-Kategorie (`gated` = lädt erst nach Einwilligung / Zwei-Klick, `notwendig` = technisch "
+    + "erforderlich, lädt ohne Einwilligung). Basis für site_embed_consent.",
+  { site: z.string().optional().describe(SITE_DESC) },
+  async ({ site }) => { try { return asText(await apiEmbeds(cfg, { site })); } catch (e) { return asError(e); } }
+);
+
+server.tool(
+  "site_embed_consent",
+  "SCHREIBEND: ein Embed als `notwendig` (technisch erforderlich, § 25 Abs. 2 Nr. 2 TDDDG) oder zurück auf "
+    + "`gated` einstufen. Bei `notwendig` erklärt der Kunde/Betreuer, dass der Dienst für die vom Besucher "
+    + "gewünschte Funktion (z. B. Reservierung) UNBEDINGT ERFORDERLICH ist und übernimmt die Verantwortung – "
+    + "das MUSS mit dem Nutzer bestätigt werden (confirmed:true; sonst lehnt der Server mit dem Verantwortungs-"
+    + "Text ab). Dann lädt das Embed OHNE Einwilligung, aber nur auf der angegebenen Seite; der Datenschutz-Text "
+    + "passt sich automatisch an. Greift beim nächsten Veröffentlichen. Betreuer-Token gilt für betreute Kunden.",
+  { site: z.string().optional().describe(SITE_DESC),
+    host: z.string().describe("Embed-Host/Key aus site_embeds (z. B. 'resmio', 'youtube' oder ein Hostname)."),
+    page: z.string().optional().describe("Seiten-Datei, auf die die Einstufung beschränkt ist (z. B. 'reservierung.html'); leer = alle Seiten mit diesem Embed."),
+    category: z.enum(["notwendig", "gated"]).default("notwendig").describe("notwendig = technisch erforderlich (ohne Einwilligung); gated = zurück hinter das Consent-/Zwei-Klick-Gate."),
+    confirmed: z.boolean().default(false).describe("MUSS true sein, um 'notwendig' zu setzen (Verantwortungs-Bestätigung). Vorher den Nutzer explizit fragen.") },
+  async ({ site, host, page, category, confirmed }) => {
+    try { return asText(await apiEmbedConsent(cfg, { site, host, page, category, confirmed })); } catch (e) { return asError(e); }
+  }
+);
+
 const transport = new StdioServerTransport();
 await server.connect(transport);

package/package.json

@@ -1,16 +1,34 @@
 {
   "name": "@prontosite/mcp",
-  "version": "0.5.0",
+  "version": "0.8.0",
   "description": "MCP-Server für ProntoSite – Website-Status, Export, Deploy und Veröffentlichen direkt aus einem KI-Assistenten (Claude Desktop). Dünner Client um die ProntoSite Deploy-API.",
   "type": "module",
-  "bin": { "prontosite-mcp": "index.mjs" },
+  "bin": {
+    "prontosite-mcp": "index.mjs"
+  },
   "main": "index.mjs",
-  "files": ["index.mjs", "api.mjs", "README.md", "CHANGELOG.md"],
-  "engines": { "node": ">=18" },
-  "keywords": ["prontosite", "mcp", "model-context-protocol", "claude", "deploy", "website"],
+  "files": [
+    "index.mjs",
+    "api.mjs",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "prontosite",
+    "mcp",
+    "model-context-protocol",
+    "claude",
+    "deploy",
+    "website"
+  ],
   "license": "UNLICENSED",
   "homepage": "https://prontosite.io/docs/mcp",
-  "publishConfig": { "access": "public" },
+  "publishConfig": {
+    "access": "public"
+  },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
     "zod": "^3.23.0"