@prontosite/mcp 0.2.0

package/README.md

@@ -0,0 +1,117 @@
+# ProntoSite MCP-Server
+
+Deploy, Export und Status deiner ProntoSite-Website **direkt aus einem KI-Assistenten** (z. B. Claude Desktop) –
+ohne Terminal. Der Server ist ein **dünner Client** um die bestehende [ProntoSite Deploy-API](../../docs/deploy-api.md);
+er hat keine eigene Logik und keinen Zustand. Die HTTP-API (curl/Terminal, Skripte) bleibt der primäre Weg –
+dies ist nur ein zusätzlicher Client obendrauf.
+
+## Voraussetzungen
+
+- Node.js ≥ 18
+- Ein ProntoSite **API-Token** (`psk_…`) – im Dashboard unter **Konto → API-Zugang** (oder vom Betreuer erzeugt).
+
+## Einrichtung (empfohlen: npx)
+
+Kein Klonen, kein Node-Projekt nötig – Claude Desktop startet den Server per `npx`:
+
+```jsonc
+// claude_desktop_config.json → "mcpServers"
+{
+  "prontosite": {
+    "command": "npx",
+    "args": ["-y", "@prontosite/mcp"],
+    "env": { "PRONTOSITE_TOKEN": "psk_…", "PRONTOSITE_SITE": "meine-firma" }
+  }
+}
+```
+
+(Repo-Variante ohne npx: `"command": "node", "args": ["/pfad/promptsite/mcp/prontosite/index.mjs"]`. Vorher
+`cd mcp/prontosite && npm install`.)
+
+## Konfiguration (Token nie im Chat)
+
+Umgebungsvariablen **oder** `~/.prontosite.json`. Zwei Formen:
+
+**Wichtig zum Site-Bezeichner:** Nutze die **stabile Site-ID** (`s-…`, steht im Dashboard) oder `"active"` –
+**nicht** den Slug. Der Slug/die Adresse kann sich ändern (eigene Domain, Umbenennung); die Site-ID nie.
+Für ein Konto mit nur einer Website ist `"active"` der robusteste Wert.
+
+**Einzelne Website (ein Kunde):**
+```jsonc
+{ "token": "psk_…", "site": "active", "host": "app.prontosite.io" }
+```
+Env-Äquivalent: `PRONTOSITE_TOKEN`, `PRONTOSITE_SITE`, `PRONTOSITE_HOST`.
+
+**Mehrere Websites (Betreuer/Agentur) – zwei gleichwertige Wege:** Bis ~5 Kunden am einfachsten je Kunde ein
+eigener `mcpServers`-Eintrag (Token in `env`, terminalfrei) – siehe „Einrichtung (empfohlen: npx)" oben, den
+Block je Kunde mit eigenem Server-Namen wiederholen. Ab ~5 wird die folgende `sites`-Map übersichtlicher (ein
+Server, alle Kunden in einer Datei; `sites_list` zeigt alle auf einmal). Die Map – Schlüssel = frei wählbares
+**Label** (das du im Chat sagst), `site` = **stabile Site-ID**, ein Token je Website:
+```jsonc
+{
+  "host": "app.prontosite.io",
+  "defaultSite": "mas-monti",
+  "sites": {
+    "mas-monti":        { "site": "s-mth…", "token": "psk_…" },
+    "wallboxservice24": { "site": "s-msz…", "token": "psk_…" }
+  }
+}
+```
+Jedes Tool nimmt einen optionalen Parameter `site` (Label **oder** Site-ID). Ohne Angabe gilt `defaultSite`
+bzw. die Einzel-Site. So verwaltest du mit **einem** Claude Desktop beliebig viele Kundenseiten – und die
+Zuordnung bricht nicht, wenn ein Kunde seine Domain/Adresse ändert.
+
+- `site` – **Site-ID** (`s-…`, empfohlen) oder `"active"`; ein Slug wird zwar noch akzeptiert, kann aber
+  veralten. Erst-Import: `site:"new"`.
+- `host` – Standard `app.prontosite.io`.
+
+**Datei anlegen/erweitern:** Existiert `~/.prontosite.json` noch nicht, lege sie mit obigem Inhalt an
+(z. B. `cat > ~/.prontosite.json <<'JSON' … JSON` – ⚠ **überschreibt** eine vorhandene Datei!). Ist sie schon
+da, NICHT überschreiben: die Datei öffnen und unter `"sites"` einen weiteren Eintrag ergänzen (vorher
+sichern: `cp ~/.prontosite.json ~/.prontosite.json.bak`).
+
+## Tools
+
+| Tool | Wirkung |
+|------|---------|
+| `sites_list` | Alle erreichbaren Websites (Slug, Plan, letzte Änderung, Publish-Bedarf). **Lesend.** |
+| `site_status({ site? })` | Plan, Slug, Live-URL, Publish-Bedarf. **Lesend.** |
+| `site_export({ site?, which, outDir })` | ZIP (`published`\|`draft`\|`original`) lokal speichern. **Lesend.** |
+| `site_deploy({ site?, zipPath, publish?, resetOverlay?, legal? })` | ZIP importieren, optional live. **Schreibend.** |
+| `site_publish({ site? })` | Aktuellen Stand erneut veröffentlichen. **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.
+
+## Arbeitsweise: ein Chat je Kunde
+
+Für saubere Trennung: pro Kundenwebsite **einen eigenen Claude-Chat**. So bezieht sich der ganze Verlauf auf
+genau diese Website, und Verwechslungen sind ausgeschlossen. `sites_list` zeigt alle Slugs – so kannst du im
+Chat einfach sagen „deploye mas-monti", ohne Slugs auswendig zu kennen. (Alternativ ein Chat für alles und die
+Website je Aufruf über `site` wählen – die getrennten Chats sind aber übersichtlicher.)
+
+## Sicherheit
+
+- Tokens liegen nur lokal (Config/Env), werden nie geloggt und nie in Antworten zurückgegeben.
+- **Behandle Tokens wie Passwörter.** Ein durchgesickertes Token erlaubt Deploy/Publish der betroffenen Website;
+  im Dashboard jederzeit widerrufbar, dann ein neues erzeugen.
+- Es gelten dieselben serverseitigen Grenzen wie bei der HTTP-API (Plan/Operator-Gate, Rate-Limit, Audit-Log,
+  100 MB ZIP, kein Server-Code).
+
+## Betreuer-Token (ein Token für ALLE betreuten Kunden)
+
+Für Agenturen/Partner: **ein** Betreuer-Token deckt alle betreuten Kunden ab – **ohne `sites`-Map**. Erzeugt im
+Admin/Partner-Bereich (Panel „Betreuer-Token"). Config dann einfach:
+
+```jsonc
+{ "token": "psk_…", "host": "app.prontosite.io" }   // KEIN sites, KEIN site
+```
+
+`sites_list` liefert automatisch alle betreuten Kunden-Sites (Neukunde erscheint, sobald er dem Partner
+zugeordnet ist – keine Config-Pflege). Website je Aufruf per Slug **oder stabiler Site-ID** angeben (kein
+`"active"` – es sind mehrere Konten). Erst-Import: `site_deploy({ site: "new", customer: "k-…" })`.
+
+Sicherheit: der Zugriff wird bei JEDEM Aufruf serverseitig geprüft (`assertCanManage` – nur betreute Konten,
+Rollenentzug wirkt sofort); nur Deploy/Status/Export/Veröffentlichen, kein Konto-/Zahlungszugriff; optionaler
+Ablauf (Default 90 Tage) und optionale IP-Bindung; Widerruf sperrt alle betreuten Sites auf einmal.
+Alternative bleibt die `sites`-Map oben (kleinere Angriffsfläche je Token, aber Pflege je Kunde).

package/api.mjs

@@ -0,0 +1,137 @@
+/**
+ * ProntoSite MCP – HTTP-Kern (ohne MCP-SDK, damit testbar). Dünner Client um die bestehende Deploy-API;
+ * KEINE eigene Logik. Token/Site/Host aus lokaler Config (Env > ~/.prontosite.json), nie aus dem Chat.
+ * Tokens werden nie geloggt und nie zurückgegeben.
+ *
+ * Config-Formen:
+ *   Einzel (ein Kunde):  { "token":"psk_…", "site":"active", "host":"app.prontosite.io" }
+ *   Multi (Betreuer):    { "host":"app.prontosite.io", "defaultSite":"mas-monti", "sites": {
+ *                            "mas-monti":        { "site":"s-mth…", "token":"psk_…" },
+ *                            "wallboxservice24": { "site":"s-msz…", "token":"psk_…" } } }
+ * `site` ist die STABILE Site-ID (s-…) oder "active" – NICHT der Slug (der kann sich ändern: Kundendomain,
+ * Umbenennung). Der Map-Schlüssel ist ein frei wählbares Label (das man im Chat sagt). Jedes Tool nimmt
+ * optional `site` (Label ODER Site-ID); ohne Angabe gilt defaultSite bzw. die Einzel-Site (sonst „active").
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const DEFAULT_HOST = "app.prontosite.io";
+
+/** Config laden: Umgebungsvariablen haben Vorrang (Einzel-Werte), plus optionale sites-Map aus der Datei. */
+export function loadConfig(env = process.env, home = os.homedir()) {
+  let file = {};
+  try {
+    const p = path.join(home, ".prontosite.json");
+    if (fs.existsSync(p)) file = JSON.parse(fs.readFileSync(p, "utf8")) || {};
+  } 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 needToken = (token, ref) => {
+  if (!token || !String(token).startsWith("psk_"))
+    throw new Error(`Kein API-Token für „${ref}" konfiguriert. Setze PRONTOSITE_TOKEN oder trage die Site in ~/.prontosite.json (sites) ein.`);
+  return token;
+};
+
+/** Ziel (Token + Site-Bezeichner für die API) bestimmen. Bei einer sites-Map wird der Eintrag per Label-
+ *  Schlüssel ODER per stabiler Site-ID (entry.site) gefunden; die API bekommt die stabile ID (entry.site)
+ *  bzw. den Schlüssel. Sonst der Einzel-Token mit dem übergebenen Bezeichner (ID/„active"). */
+export function resolveTarget(cfg, site) {
+  const want = site || cfg.defaultSite || cfg.site || "active";
+  if (cfg.sites) {
+    const key = cfg.sites[want] ? want : Object.keys(cfg.sites).find(k => cfg.sites[k] && cfg.sites[k].site === want);
+    if (key) { const e = cfg.sites[key]; return { token: needToken(e.token, key), slug: e.site || key }; }
+  }
+  return { token: needToken(cfg.token, want), slug: want };
+}
+
+const baseUrl = cfg => `https://${cfg.host}/api`;
+const authHeaders = token => ({ authorization: `Bearer ${token}` });
+
+/** Antwort als JSON lesen; bei Fehlerstatus eine sprechende Exception (ohne Token). */
+async function asJson(res) {
+  let body = {};
+  try { body = await res.json(); } catch { /* kein JSON */ }
+  if (!res.ok) throw new Error(body.error || `HTTP ${res.status}`);
+  return body;
+}
+
+/** GET /api/status/<site> – Status der Site (Plan, Slug, Live-URL, Publish-Bedarf, letzte Änderung). */
+export async function apiStatus(cfg, { site } = {}, fetchImpl = fetch) {
+  const { token, slug } = resolveTarget(cfg, site);
+  const res = await fetchImpl(`${baseUrl(cfg)}/status/${encodeURIComponent(slug)}`, { headers: authHeaders(token) });
+  return asJson(res);
+}
+
+/** GET /api/export/<site>?which= – ZIP in einen lokalen Ordner speichern. */
+export async function apiExport(cfg, { site, which = "published", outDir = "." } = {}, fetchImpl = fetch) {
+  const { token, slug } = resolveTarget(cfg, site);
+  const res = await fetchImpl(`${baseUrl(cfg)}/export/${encodeURIComponent(slug)}?which=${encodeURIComponent(which)}`, { headers: authHeaders(token) });
+  if (!res.ok) return asJson(res);   // Fehler kommen als JSON
+  const buf = Buffer.from(await res.arrayBuffer());
+  const cd = res.headers.get("content-disposition") || "";
+  const m = /filename="?([^"]+)"?/.exec(cd);
+  const name = (m && m[1]) || `prontosite-${slug}-${which}.zip`;
+  fs.mkdirSync(outDir, { recursive: true });
+  const outPath = path.join(outDir, name.replace(/[^a-zA-Z0-9._-]+/g, "_"));
+  fs.writeFileSync(outPath, buf);
+  return { path: outPath, bytes: buf.length, which, site: slug };
+}
+
+/** POST /api/deploy/<site> – ZIP übergeben (+ optional publish/resetOverlay/legal). site="new" = anlegen. */
+export async function apiDeploy(cfg, { site, customer = null, zipPath, publish = false, resetOverlay = false, legal = null } = {}, fetchImpl = fetch) {
+  if (!zipPath || !fs.existsSync(zipPath)) throw new Error(`ZIP nicht gefunden: ${zipPath}`);
+  const { token, slug } = resolveTarget(cfg, site);
+  const q = new URLSearchParams();
+  if (publish) q.set("publish", "1");
+  if (resetOverlay) q.set("resetOverlay", "1");
+  if (legal === true) q.set("legal", "1");
+  if (legal === false) q.set("legal", "0");
+  if (customer) q.set("customer", customer);   // Betreuer-Token + site="new": Ziel-Konto für den Erst-Import
+  const qs = q.toString() ? `?${q}` : "";
+  const res = await fetchImpl(`${baseUrl(cfg)}/deploy/${encodeURIComponent(slug)}${qs}`, {
+    method: "POST", headers: { ...authHeaders(token), "content-type": "application/zip" }, body: fs.readFileSync(zipPath) });
+  return asJson(res);
+}
+
+/** POST /api/publish/<site> – erneut veröffentlichen (ohne ZIP). force=true = „trotzdem veröffentlichen"
+ *  (auch ohne erkannte Änderung), analog zum Dashboard-Menüpunkt „Erneut veröffentlichen". */
+export async function apiPublish(cfg, { site, force = false } = {}, fetchImpl = fetch) {
+  const { token, slug } = resolveTarget(cfg, site);
+  const qs = force ? "?force=1" : "";
+  const res = await fetchImpl(`${baseUrl(cfg)}/publish/${encodeURIComponent(slug)}${qs}`, { method: "POST", headers: authHeaders(token) });
+  return asJson(res);
+}
+
+/** 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");
+  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 };
+}

package/index.mjs

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+/**
+ * ProntoSite MCP-Server (stdio) für Claude Desktop u. a. KI-Assistenten.
+ * DÜNNER Client um die bestehende ProntoSite-Deploy-API – keine eigene Logik, kein Zustand. Die HTTP-API
+ * (curl/Terminal) bleibt der primäre Weg; dies ist nur ein zusätzlicher Client. Token/Site/Host aus lokaler
+ * Config (Env > ~/.prontosite.json), nie aus dem Chat.
+ *
+ * Multi-Site (Betreuer): trägt die Config eine `sites`-Map, adressiert jedes Tool per `site`-Parameter die
+ * jeweilige Website (eigenes Token je Site). Arbeitsweise: EIN Chat je Kunde. `sites_list` zeigt alle Sites.
+ */
+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 } from "./api.mjs";
+
+const cfg = loadConfig();
+const server = new McpServer({ name: "prontosite", version: "0.2.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-"
+  + "Config (mehrere Sites) hier die gewünschte Website angeben.";
+
+server.tool(
+  "sites_list",
+  "Listet alle erreichbaren ProntoSite-Websites auf (Slug, Plan, letzte Änderung, offener Veröffentlichungs"
+    + "bedarf). Nützlich, um im Chat eine Website beim Namen zu nennen. LESEND.",
+  {},
+  async () => { try { return asText(await sitesList(cfg)); } catch (e) { return asError(e); } }
+);
+
+server.tool(
+  "site_status",
+  "Status einer ProntoSite-Website: Plan, Slug, Live-URL, letzte Änderungen und offener Veröffentlichungs"
+    + "bedarf. LESEND – ändert nichts.",
+  { site: z.string().optional().describe(SITE_DESC) },
+  async ({ site }) => { try { return asText(await apiStatus(cfg, { site })); } catch (e) { return asError(e); } }
+);
+
+server.tool(
+  "site_export",
+  "Exportiert eine Website als ZIP in ein lokales Verzeichnis. which: 'published' (Live-Stand, Standard), "
+    + "'draft' (Entwurf) oder 'original' (flacher Stand ohne ProntoSite-Zutaten). LESEND.",
+  { site: z.string().optional().describe(SITE_DESC),
+    which: z.enum(["published", "draft", "original"]).default("published"),
+    outDir: z.string().default(".").describe("Zielordner für die ZIP-Datei (lokal).") },
+  async ({ site, which, outDir }) => { try { return asText(await apiExport(cfg, { site, which, outDir })); } catch (e) { return asError(e); } }
+);
+
+server.tool(
+  "site_deploy",
+  "SCHREIBEND: Übergibt eine lokale ZIP-Datei an ProntoSite (Import). Mit publish=true wird die Website "
+    + "DIREKT LIVE geschaltet und der bestehende Live-Stand überschrieben. site='new' legt beim Erst-Import "
+    + "(Konto-Token) eine neue Website an. Bitte VOR dem Aufruf bestätigen lassen – und die richtige Website prüfen.",
+  { site: z.string().optional().describe(SITE_DESC + " Oder 'new' zum Anlegen (Erst-Import)."),
+    customer: z.string().optional().describe("Nur mit Betreuer-Token + site='new': Ziel-Konto-ID (k-…) für die neue Website."),
+    zipPath: z.string().describe("Pfad zur ZIP-Datei der Website (lokal)."),
+    publish: z.boolean().default(false).describe("true = nach dem Import direkt veröffentlichen (LIVE)."),
+    resetOverlay: z.boolean().default(false).describe("true = bisherige Dashboard-Änderungen verwerfen."),
+    legal: z.boolean().optional().describe("Rechts-Automatik (Impressum/Datenschutz): true erzwingt, false schaltet ab.") },
+  async ({ site, customer, zipPath, publish, resetOverlay, legal }) => {
+    try { return asText(await apiDeploy(cfg, { site, customer, zipPath, publish, resetOverlay, legal })); } catch (e) { return asError(e); }
+  }
+);
+
+server.tool(
+  "site_publish",
+  "SCHREIBEND: Veröffentlicht den aktuellen Stand einer Website ERNEUT (ohne ZIP) – z. B. um Plattform-"
+    + "Aktualisierungen live zu bringen. Meldet die Antwort nothing:true (keine erkannte Änderung), aber du "
+    + "willst trotzdem neu ausliefern, setze force:true. Bitte VOR dem Aufruf bestätigen lassen – und die richtige Website prüfen.",
+  { site: z.string().optional().describe(SITE_DESC),
+    force: z.boolean().default(false).describe("true = trotzdem veröffentlichen, auch ohne erkannte Änderung (wie der Menüpunkt Erneut veröffentlichen).") },
+  async ({ site, force }) => { try { return asText(await apiPublish(cfg, { site, force })); } catch (e) { return asError(e); } }
+);
+
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@prontosite/mcp",
+  "version": "0.2.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" },
+  "main": "index.mjs",
+  "files": ["index.mjs", "api.mjs", "README.md"],
+  "engines": { "node": ">=18" },
+  "keywords": ["prontosite", "mcp", "model-context-protocol", "claude", "deploy", "website"],
+  "license": "UNLICENSED",
+  "homepage": "https://prontosite.io/mcp-anleitung",
+  "publishConfig": { "access": "public" },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "zod": "^3.23.0"
+  }
+}