@prontosite/mcp 0.13.2 → 0.13.4

package/CHANGELOG.md

@@ -3,6 +3,29 @@
 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.13.4 – 2026-10-19
+
+Enthält 0.13.3 (nie einzeln veröffentlicht).
+- Neu: `site_undo {site, steps?, baseRev?}` / `site_redo` – derselbe Rückgängig-Verlauf wie im Dashboard; Antwort je Schritt mit
+  Op-Typ, Seite(n), Akteur (`vonAnderem:true`, wenn die Änderung von jemand anderem stammte). Instructions: „Bei ‚rückgängig‘ site_undo,
+  nie Dateien manuell zurückbauen.“
+- Neu: `site_media_delete {site, mediaId, force?}` → Papierkorb (30 Tage, nie endgültig); noch verwendet (Entwurf oder
+  veröffentlicht) → `inUse` mit Fundstellen, keine Löschung ohne `force` (nur Uploads; Import-Bilder nur unbenutzt).
+  `site_media_restore {trashId}` holt zurück; `site_media_list` zeigt den Papierkorb (`trash`).
+- `site_image_set` erhält das responsive Bild: srcset aus den Server-Varianten, vorhandenes `sizes`, `<picture>`-Quellen umgeschrieben.
+- `site_preview_screenshot`: Einblend-/Scroll-Animationen (ohne JS sonst unsichtbar) werden sichtbar dargestellt.
+
+## 0.13.3 – 2026-10-19
+
+- Neu (nur lokales Paket): `media_upload_file {site, path, purpose?}` – lokale Datei in einem Schritt hochladen
+  (Upload-Link + PUT + Übernahme) → `mediaId`. Hilfreich, wenn die Sandbox des Assistenten (z. B. Claude Desktop/Cowork)
+  app.prontosite.io nicht erreicht, der lokale Server aber schon.
+- Prüfung VOR jedem Netzaufruf: nur unterhalb des Home-Ordners, kein `..`, kein Symlink in der Kette (Datei oder Ordner),
+  keine versteckten Ordner (`~/.ssh` …), nur reguläre Datei, Größe vor dem Lesen (max. 15 MB), Magic-Bytes + passende Endung
+  (JPG/PNG/WebP/SVG/PDF). Abgelehnte Dateien verlassen den Rechner nicht.
+- `media_upload_begin` nimmt kein `path` mehr an (bisher ungeprüfter Lese-Weg) – lokale Dateien nur noch über `media_upload_file`.
+- Server-Instructions lokal: „Wenn du einen lokalen Dateipfad hast, nutze media_upload_file; sonst Upload-Link.“
+
 ## 0.13.2 – 2026-10-19
 
 - Upload-Beschreibung: Bilder und PDF; PDFs mit Skripten, automatischen Aktionen, Formular-Versand oder Anhängen werden abgelehnt;

package/api.mjs

@@ -415,20 +415,85 @@ export async function apiPageCopy(cfg, { site, from, to, baseRev = null } = {},
     method: "POST", headers: { ...authHeaders(token, cfg), "content-type": "application/json" }, body: JSON.stringify({ from, to, ...(Number.isInteger(baseRev) ? { baseRev } : {}) }) }));
 }
 
-/** POST /api/media-upload/<site> – Upload-Link (15 Min., einmalig) für ein neues Bild; lokal optional gleich hochladen (path). */
-export async function apiMediaUploadBegin(cfg, { site, purpose = null, filename = null, path: localPath = null } = {}, fetchImpl = fetch) {
+/** POST /api/media-upload/<site> – Upload-Link (15 Min., einmalig) für ein neues Bild/Dokument. Lokale Datei: apiMediaUploadFile. */
+export async function apiMediaUploadBegin(cfg, { site, purpose = null, filename = null } = {}, fetchImpl = fetch) {
   const { token, slug } = resolveTarget(cfg, site);
-  const name = filename || (localPath ? path.basename(localPath) : null);
-  const out = await asJson(await fetchImpl(`${baseUrl(cfg)}/media-upload/${encodeURIComponent(slug)}`, {
-    method: "POST", headers: { ...authHeaders(token, cfg), "content-type": "application/json" }, body: JSON.stringify({ purpose, filename: name }) }));
-  if (localPath) {   // lokales Paket mit Dateizugriff: Originaldatei selbst per PUT hochladen (keine Varianten, kein ZIP)
-    if (!fs.existsSync(localPath)) throw new Error(`Datei nicht gefunden: ${localPath}`);
-    const up = await fetchImpl(out.uploadUrl, { method: "PUT", headers: { "x-filename": encodeURIComponent(name || "bild") }, body: fs.readFileSync(localPath) });
-    const r = await up.json().catch(() => ({}));
-    if (!up.ok) throw new Error(r.error || `Upload fehlgeschlagen (HTTP ${up.status}).`);
-    return { ...out, uploaded: true, bytes: r.bytes, next: "Hochgeladen – jetzt media_upload_commit {uploadId}." };
+  return asJson(await fetchImpl(`${baseUrl(cfg)}/media-upload/${encodeURIComponent(slug)}`, {
+    method: "POST", headers: { ...authHeaders(token, cfg), "content-type": "application/json" }, body: JSON.stringify({ purpose, filename }) }));
+}
+
+// Lokaler Datei-Upload (nur stdio-Paket): dieselben Grenzen wie der Server (MEDIA_MAX_FILE_MB, Typen aus sniffImageMime +
+// doc-check), aber VOR jedem Netzaufruf – eine abgelehnte Datei verlässt den Rechner nie.
+export const LOCAL_UPLOAD_MAX_BYTES = 15 * 1024 * 1024;
+const LOCAL_UPLOAD_TYPES = { png: ["png"], jpeg: ["jpg", "jpeg"], webp: ["webp"], svg: ["svg"], pdf: ["pdf"] };
+function sniffLocalType(b) {
+  if (b.length >= 8 && b[0] === 0x89 && b[1] === 0x50 && b[2] === 0x4e && b[3] === 0x47) return "png";
+  if (b.length >= 3 && b[0] === 0xff && b[1] === 0xd8 && b[2] === 0xff) return "jpeg";
+  if (b.length >= 12 && b.toString("ascii", 0, 4) === "RIFF" && b.toString("ascii", 8, 12) === "WEBP") return "webp";
+  if (b.length >= 5 && b.toString("ascii", 0, 5) === "%PDF-") return "pdf";
+  const head = b.subarray(0, 256).toString("utf8").replace(/^/, "").trimStart().toLowerCase();
+  if (head.startsWith("<svg") || (head.startsWith("<?xml") && /<svg[\s>]/.test(b.subarray(0, 4096).toString("utf8").toLowerCase()))) return "svg";
+  return null;
+}
+
+/**
+ * Lokale Datei sicher lesen: nur unterhalb des Nutzer-Home, kein Symlink in der Kette (auch nicht als Verzeichnis),
+ * keine versteckten Ordner/Dateien (~/.ssh, ~/.aws …), nur reguläre Datei, Größe VOR dem Lesen, Magic-Bytes + passende
+ * Endung (JPG/PNG/WebP/SVG/PDF). Wirft mit deutscher Meldung; liest erst, wenn alle Pfad-Prüfungen bestanden sind.
+ * @returns {{ buf: Buffer, name: string, type: string, bytes: number, path: string }}
+ */
+export function readLocalUploadFile(p, { home = os.homedir(), maxBytes = LOCAL_UPLOAD_MAX_BYTES } = {}) {
+  if (typeof p !== "string" || !p.trim() || p.includes("\0")) throw new Error("path fehlt – absoluten Dateipfad angeben (z. B. ~/Bilder/team.jpg).");
+  let raw = p.trim();
+  if (raw.split(/[\\/]+/).includes("..")) throw new Error("Pfad mit „..“ ist nicht erlaubt.");
+  if (raw === "~" || raw.startsWith("~/")) raw = path.join(home, raw.slice(1));
+  if (!path.isAbsolute(raw)) throw new Error("Bitte einen absoluten Dateipfad angeben (z. B. ~/Bilder/team.jpg).");
+  const abs = path.resolve(raw);
+  const homeLex = path.resolve(home);
+  let homeReal; try { homeReal = fs.realpathSync(homeLex); } catch { throw new Error("Nutzer-Home nicht lesbar."); }
+  const prefix = [homeLex, homeReal].find(h => abs.startsWith(h + path.sep));
+  if (!prefix) throw new Error("Nur Dateien unterhalb deines Benutzerordners (Home) sind erlaubt.");
+  const parts = abs.slice(prefix.length + 1).split(path.sep).filter(Boolean);
+  if (parts.some(x => x.startsWith("."))) throw new Error("Versteckte Dateien/Ordner (z. B. ~/.ssh) sind nicht erlaubt.");
+  let cur = homeReal;
+  for (const part of parts) {                  // jedes Glied einzeln: kein Symlink, auch nicht als Zwischenordner
+    cur = path.join(cur, part);
+    let st; try { st = fs.lstatSync(cur); } catch { throw new Error(`Datei nicht gefunden: ${p}`); }
+    if (st.isSymbolicLink()) throw new Error("Symlinks sind nicht erlaubt – bitte den echten Dateipfad angeben.");
   }
-  return out;
+  if (fs.realpathSync(cur) !== cur) throw new Error("Pfad nicht eindeutig (Link in der Kette) – bitte den echten Dateipfad angeben.");
+  let fd;
+  try { fd = fs.openSync(cur, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW || 0)); }
+  catch { throw new Error(`Datei nicht lesbar: ${p}`); }
+  try {
+    const st = fs.fstatSync(fd);                 // am offenen Handle prüfen: kein Austausch zwischen Prüfen und Lesen
+    if (!st.isFile()) throw new Error("Nur reguläre Dateien sind erlaubt (kein Ordner, kein Gerät).");
+    if (!st.size) throw new Error("Leere Datei.");
+    if (st.size > maxBytes) throw new Error(`Datei zu groß (${(st.size / 1048576).toFixed(1)} MB, max. ${Math.round(maxBytes / 1048576)} MB).`);
+    const buf = Buffer.alloc(st.size);
+    let off = 0;
+    while (off < st.size) { const n = fs.readSync(fd, buf, off, st.size - off, off); if (!n) break; off += n; }
+    if (off !== st.size) throw new Error("Datei hat sich beim Lesen verändert – bitte erneut versuchen.");
+    const type = sniffLocalType(buf);
+    if (!type) throw new Error("Kein unterstützter Dateityp – erlaubt sind JPG, PNG, WebP, SVG und PDF.");
+    const name = path.basename(cur);
+    const ext = (path.extname(name).slice(1) || "").toLowerCase();
+    if (!LOCAL_UPLOAD_TYPES[type].includes(ext)) throw new Error(`Dateiendung „.${ext}“ passt nicht zum Inhalt (${type.toUpperCase()}).`);
+    return { buf, name, type, bytes: st.size, path: cur };
+  } finally { fs.closeSync(fd); }
+}
+
+/** Lokale Datei in EINEM Schritt hochladen: prüfen (ohne Netz) → media-upload → PUT → media-commit → mediaId. */
+export async function apiMediaUploadFile(cfg, { site, path: localPath, purpose = null } = {}, fetchImpl = fetch, opts = {}) {
+  const f = readLocalUploadFile(localPath, opts);
+  const out = await apiMediaUploadBegin(cfg, { site, purpose, filename: f.name }, fetchImpl);
+  if (Number.isFinite(out.maxBytes) && f.bytes > out.maxBytes) throw new Error(`Datei zu groß (max. ${Math.round(out.maxBytes / 1048576)} MB).`);
+  const up = await fetchImpl(out.uploadUrl, { method: "PUT", headers: { "x-filename": encodeURIComponent(f.name) }, body: f.buf });
+  const r = await up.json().catch(() => ({}));
+  if (!up.ok) throw new Error(r.error || `Upload fehlgeschlagen (HTTP ${up.status}).`);
+  const m = await apiMediaCommit(cfg, { site, uploadId: out.uploadId }, fetchImpl);
+  if (m.pending) throw new Error(m.hinweis || "Upload nicht angekommen – bitte erneut versuchen.");
+  return { ...m, datei: f.name, bytes: f.bytes };
 }
 /** POST /api/media-commit/<site> – hochgeladene Datei prüfen und als Medium ablegen → mediaId. */
 export async function apiMediaCommit(cfg, { site, uploadId } = {}, fetchImpl = fetch) {
@@ -450,6 +515,25 @@ export async function apiImageSet(cfg, { site, page, nodeId = null, marker = nul
     method: "POST", headers: { ...authHeaders(token, cfg), "content-type": "application/json" },
     body: JSON.stringify({ page, mediaId, ...(nodeId ? { nodeId } : {}), ...(marker ? { marker } : {}), ...(alt != null ? { alt } : {}), ...(Number.isInteger(baseRev) ? { baseRev } : {}) }) }));
 }
+/** POST /api/undo|redo/<site> – letzte Änderung(en) des Entwurfs zurücknehmen bzw. wiederherstellen (derselbe Stack wie das Dashboard). */
+export async function apiUndo(cfg, { site, steps = 1, baseRev = null, redo = false } = {}, fetchImpl = fetch) {
+  const { token, slug } = resolveTarget(cfg, site);
+  return asJsonOr409(await fetchImpl(`${baseUrl(cfg)}/${redo ? "redo" : "undo"}/${encodeURIComponent(slug)}`, {
+    method: "POST", headers: { ...authHeaders(token, cfg), "content-type": "application/json" },
+    body: JSON.stringify({ ...(Number.isInteger(steps) ? { steps } : {}), ...(Number.isInteger(baseRev) ? { baseRev } : {}) }) }));
+}
+/** POST /api/media-delete/<site> – Medium in den Papierkorb (30 Tage); noch verwendet → 409-Objekt mit usage (force nur für Uploads). */
+export async function apiMediaDelete(cfg, { site, mediaId, force = false } = {}, fetchImpl = fetch) {
+  const { token, slug } = resolveTarget(cfg, site);
+  return asJsonOr409(await fetchImpl(`${baseUrl(cfg)}/media-delete/${encodeURIComponent(slug)}`, {
+    method: "POST", headers: { ...authHeaders(token, cfg), "content-type": "application/json" }, body: JSON.stringify({ mediaId, ...(force === true ? { force: true } : {}) }) }));
+}
+/** POST /api/media-restore/<site> – Medium aus dem Papierkorb zurückholen. */
+export async function apiMediaRestore(cfg, { site, trashId } = {}, fetchImpl = fetch) {
+  const { token, slug } = resolveTarget(cfg, site);
+  return asJson(await fetchImpl(`${baseUrl(cfg)}/media-restore/${encodeURIComponent(slug)}`, {
+    method: "POST", headers: { ...authHeaders(token, cfg), "content-type": "application/json" }, body: JSON.stringify({ trashId }) }));
+}
 /** GET /api/preview-screenshot/<site>?page=&width= – PNG des Entwurfs (Base64 + Maße). */
 export async function apiPreviewScreenshot(cfg, { site, page = "index.html", width = 1280 } = {}, fetchImpl = fetch) {
   const { token, slug } = resolveTarget(cfg, site);

package/index.mjs

@@ -14,14 +14,14 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 import { loadConfig } from "./api.mjs";
-import { registerTools, SERVER_INSTRUCTIONS } from "./tools.mjs";
+import { registerTools, instructionsFor } from "./tools.mjs";
 
 const cfg = loadConfig();
 // 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");
 // instructions: Arbeitsweise (Weg B = Standard) – gleicher Text wie am Remote-Endpunkt.
-const server = new McpServer({ name: "prontosite", version: "0.13.2" }, { instructions: SERVER_INSTRUCTIONS });
+const server = new McpServer({ name: "prontosite", version: "0.13.4" }, { instructions: instructionsFor("local") });
 // Tool-Definitionen: gemeinsame Quelle mit dem Remote-Endpunkt (tools.mjs, Konzept KI-Anbindung §4.2).
 registerTools(server, { z, cfg, mode: "local" });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prontosite/mcp",
-  "version": "0.13.2",
+  "version": "0.13.4",
   "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": {

package/tools.mjs

@@ -9,13 +9,13 @@
  *                site_domain_connect nur mit Betreuer-Token (Entscheidung 9a).
  * `z` wird vom Aufrufer übergeben (dieselbe zod-Instanz wie sein MCP-SDK).
  */
-import { apiEditText, apiPageTexts, apiPageTextsSet, apiPageCopy, apiMediaUploadBegin, apiMediaCommit, apiMediaList, apiImageSet, apiPreviewScreenshot, apiStatus, apiExport, apiExportFetch, apiDeploy, apiPublish, sitesList, apiAccountCreate, apiCompanyGet, apiCompanySet, apiLegalOptions, apiDomainStatus, apiDomainConnect, apiEmbeds, apiEmbedConsent, apiWidgets, apiWidgetSet, apiFiles, apiFileGet, apiFilePut, apiFileDelete, apiFileRename, apiLock } from "./api.mjs";
+import { apiEditText, apiPageTexts, apiPageTextsSet, apiPageCopy, apiMediaUploadBegin, apiMediaUploadFile, apiMediaCommit, apiMediaList, apiImageSet, apiUndo, apiMediaDelete, apiMediaRestore, apiPreviewScreenshot, apiStatus, apiExport, apiExportFetch, apiDeploy, apiPublish, sitesList, apiAccountCreate, apiCompanyGet, apiCompanySet, apiLegalOptions, apiDomainStatus, apiDomainConnect, apiEmbeds, apiEmbedConsent, apiWidgets, apiWidgetSet, apiFiles, apiFileGet, apiFilePut, apiFileDelete, apiFileRename, apiLock } from "./api.mjs";
 
 /**
  * Arbeitsweise (MCP-`instructions` beim Initialize – lokal UND /mcp): Weg B ist der Standard (Nick 19.10.).
  * Direkt am Server-Entwurf arbeiten; Export + Deploy nur auf ausdrücklichen Wunsch bzw. für Komplett-Umbauten.
  */
-export const SERVER_INSTRUCTIONS = [
+const instructionLines = mode => [
   "ProntoSite – so arbeitest du mit einer Website:",
   "1. STANDARD: direkt am Server-Entwurf arbeiten. Ablauf: site_status (Stand, draftRev, wer zuletzt geändert hat) → Änderung mit "
     + "site_edit_text (Text suchen und ersetzen über alle Seiten) bzw. site_file_get/site_file_put (HTML/CSS) → site_status (Kontrolle). "
@@ -32,12 +32,19 @@ export const SERVER_INSTRUCTIONS = [
   "4. Konflikt (409, conflict:true): nicht erzwingen. Erst site_status aufrufen (zeigt, wer was geändert hat), Inhalt neu holen, Änderung "
     + "neu anwenden und mit der neuen draftRev erneut senden.",
   "5a. Bilder: Für neue Bilder media_upload_begin → Upload-Link. Wenn du Dateien lesen kannst, lade die ORIGINALDATEI selbst per HTTP PUT "
-    + "hoch (lokales Paket: path angeben); sonst gib den Link (uploadPage) an den Nutzer weiter – er lädt am Handy/PC hoch. Danach "
+    + "hoch; sonst gib den Link (uploadPage) an den Nutzer weiter – er lädt am Handy/PC hoch. Danach "
     + "media_upload_commit und mit site_image_set einsetzen. Nie Varianten selbst bauen, nie ZIP für Medien.",
+  ...(mode === "local" ? ["5a-lokal. Wenn du einen lokalen Dateipfad hast, nutze media_upload_file; sonst Upload-Link (media_upload_begin). "
+    + "media_upload_file prüft, lädt hoch und übernimmt in einem Schritt und liefert die mediaId."] : []),
   "5b. Design = CSS-Datei ändern (site_file_get/site_file_put), nicht HTML umschreiben. Nach Design- oder Bild-Änderungen "
     + "site_preview_screenshot (1280 bzw. 390) prüfen, BEVOR du dem Nutzer antwortest.",
+  "5c. Bei „rückgängig“ site_undo (bzw. „doch wieder“ site_redo), nie Dateien manuell zurückbauen. Medien löschen nur mit site_media_delete "
+    + "(Papierkorb, 30 Tage; zurückholen mit site_media_restore).",
   "5. Jede Änderung lässt sich rückgängig machen; Rechtstexte (Impressum/Datenschutz) nicht umformulieren – sie kommen aus den Firmendaten.",
-].join("\n");
+];
+/** Server-Instructions je Modus ("local" = stdio-Paket mit Dateizugriff, "remote" = /mcp). */
+export const instructionsFor = mode => instructionLines(mode).join("\n");
+export const SERVER_INSTRUCTIONS = instructionsFor("remote");
 
 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)) }] });
@@ -176,14 +183,24 @@ export function registerTools(server, { z, cfg, mode = "local", remote = null })
     "SCHREIBEND (Schritt 1 von 2) – neues Bild oder Dokument hochladen: liefert einen UPLOAD-LINK (15 Minuten, einmalig, Größe nach "
       + "Tarif-Kontingent; Bilder JPG/PNG/WebP/SVG und PDF – PDFs mit Skripten, Öffnen-/Ereignis-Aktionen, Formular-Versand oder "
       + "Anhängen werden abgelehnt; Office-Dokumente folgen mit dem Virenscanner, bitte als PDF exportieren). Zwei Wege über DENSELBEN Link: (a) Du kannst Dateien lesen → Originaldatei per HTTP PUT an uploadUrl senden "
-      + (mode === "local" ? "(hier einfach path angeben, das Paket lädt selbst hoch) " : "(z. B. curl -T bild.jpg '<uploadUrl>') ")
+      + (mode === "local" ? "(hier stattdessen media_upload_file mit dem Dateipfad nutzen) " : "(z. B. curl -T bild.jpg '<uploadUrl>') ")
       + "– keine Varianten bauen, kein ZIP. (b) Sonst den Link (uploadPage) dem Nutzer geben: er öffnet ihn am Handy/PC, fotografiert oder "
       + "wählt eine Datei. Danach media_upload_commit.",
     { site: z.string().optional().describe(SITE_DESC),
       purpose: z.string().optional().describe("Wofür das Bild ist (z. B. 'Titelbild Startseite') – erscheint auf der Upload-Seite nicht, hilft im Verlauf."),
-      filename: z.string().optional().describe("Gewünschter Dateiname (z. B. 'team-foto.jpg')."),
-      ...(mode === "local" ? { path: z.string().optional().describe("Lokaler Dateipfad – das Paket lädt die Datei direkt hoch.") } : {}) },
-    async ({ site, purpose, filename, path }) => { try { return asText(await apiMediaUploadBegin(cfg, { site, purpose, filename, path: mode === "local" ? path : null })); } catch (e) { return asError(e); } }
+      filename: z.string().optional().describe("Gewünschter Dateiname (z. B. 'team-foto.jpg').") },
+    async ({ site, purpose, filename }) => { try { return asText(await apiMediaUploadBegin(cfg, { site, purpose, filename })); } catch (e) { return asError(e); } }
+  );
+  if (mode === "local") server.tool(
+    "media_upload_file",
+    "SCHREIBEND – lokale Datei in EINEM Schritt hochladen (Upload-Link + Datei senden + übernehmen) und die mediaId zurückgeben. "
+      + "Nur Dateien unterhalb des Benutzerordners (Home), keine Symlinks, keine versteckten Ordner; JPG/PNG/WebP/SVG oder PDF, max. 15 MB "
+      + "(Prüfung VOR dem Senden – abgelehnte Dateien verlassen den Rechner nicht). Danach Bilder mit site_image_set einsetzen, "
+      + "Dokumente als Download verlinken (href = mediaId). Ohne lokalen Pfad: media_upload_begin (Upload-Link für den Nutzer).",
+    { site: z.string().optional().describe(SITE_DESC),
+      path: z.string().describe("Absoluter Dateipfad unterhalb des Home-Ordners (z. B. ~/Bilder/team.jpg)."),
+      purpose: z.string().optional().describe("Wofür die Datei ist (z. B. 'Titelbild Startseite') – hilft im Verlauf.") },
+    async ({ site, path, purpose }) => { try { return asText(await apiMediaUploadFile(cfg, { site, path, purpose })); } catch (e) { return asError(e); } }
   );
   server.tool(
     "media_upload_commit",
@@ -195,7 +212,7 @@ export function registerTools(server, { z, cfg, mode = "local", remote = null })
   );
   server.tool(
     "site_media_list",
-    "LESEND: Medien der Website (mediaId, Name, Typ, Größe, Maße; Uploads und Bilder der importierten Website) und das Medien-Kontingent.",
+    "LESEND: Medien der Website (mediaId, Name, Typ, Größe, Maße; Uploads und Bilder der importierten Website) und das Medien-Kontingent; trash = Papierkorb (trashId für site_media_restore).",
     { site: z.string().optional().describe(SITE_DESC) },
     async ({ site }) => { try { return asText(await apiMediaList(cfg, { site })); } catch (e) { return asError(e); } }
   );
@@ -209,10 +226,42 @@ export function registerTools(server, { z, cfg, mode = "local", remote = null })
       baseRev: z.number().int().optional().describe("Optional: draftRev (Konfliktschutz).") },
     async (a) => { try { return asText(await apiImageSet(cfg, a)); } catch (e) { return asError(e); } }
   );
+  server.tool(
+    "site_undo",
+    "SCHREIBEND (Entwurf): macht die letzte(n) Änderung(en) rückgängig – derselbe Verlauf wie der Rückgängig-Knopf im Dashboard (auch "
+      + "Datei-Änderungen, Bildtausch, Texte). Bei „rückgängig“ IMMER dieses Tool, nie Dateien von Hand zurückbauen. Antwort nennt je Schritt "
+      + "Op-Typ, Seite(n) und Akteur (vonAnderem:true = Änderung stammte von jemand anderem → dem Nutzer sagen). Nicht live bis site_publish.",
+    { site: z.string().optional().describe(SITE_DESC), steps: z.number().int().min(1).max(10).default(1).describe("Anzahl Schritte (1–10)."),
+      baseRev: z.number().int().optional().describe("Optional: draftRev aus site_status (409, falls inzwischen jemand anderes geändert hat).") },
+    async ({ site, steps, baseRev }) => { try { return asText(await apiUndo(cfg, { site, steps, baseRev })); } catch (e) { return asError(e); } }
+  );
+  server.tool(
+    "site_redo",
+    "SCHREIBEND (Entwurf): stellt zuletzt rückgängig gemachte Änderung(en) wieder her (Gegenstück zu site_undo; nur bis zur nächsten neuen Änderung möglich).",
+    { site: z.string().optional().describe(SITE_DESC), steps: z.number().int().min(1).max(10).default(1).describe("Anzahl Schritte (1–10)."),
+      baseRev: z.number().int().optional().describe("Optional: draftRev (Konfliktschutz).") },
+    async ({ site, steps, baseRev }) => { try { return asText(await apiUndo(cfg, { site, steps, baseRev, redo: true })); } catch (e) { return asError(e); } }
+  );
+  server.tool(
+    "site_media_delete",
+    "SCHREIBEND: verschiebt ein Medium (mediaId aus site_media_list) in den PAPIERKORB – 30 Tage wiederherstellbar (site_media_restore), "
+      + "nie endgültig. Wird es noch verwendet (Entwurf ODER veröffentlichter Stand), kommt inUse:true mit den Fundstellen und es wird NICHT "
+      + "gelöscht – erst ersetzen; force:true nur auf ausdrücklichen Wunsch des Nutzers (nur eigene Uploads; Import-Bilder nur, wenn unbenutzt).",
+    { site: z.string().optional().describe(SITE_DESC), mediaId: z.string().describe("mediaId aus site_media_list (z. B. media/team.webp)."),
+      force: z.boolean().optional().describe("Trotz Verwendung in den Papierkorb (nur nach Rückfrage beim Nutzer).") },
+    async ({ site, mediaId, force }) => { try { return asText(await apiMediaDelete(cfg, { site, mediaId, force })); } catch (e) { return asError(e); } }
+  );
+  server.tool(
+    "site_media_restore",
+    "SCHREIBEND: holt ein Medium aus dem Papierkorb zurück (trashId aus site_media_delete bzw. site_media_list → trash). Ist der Name "
+      + "inzwischen vergeben, kommt es als „…-wiederhergestellt“ zurück.",
+    { site: z.string().optional().describe(SITE_DESC), trashId: z.string().describe("trashId aus site_media_delete bzw. site_media_list.") },
+    async ({ site, trashId }) => { try { return asText(await apiMediaRestore(cfg, { site, trashId })); } catch (e) { return asError(e); } }
+  );
   server.tool(
     "site_preview_screenshot",
     "LESEND: Bildschirmfoto des ENTWURFS einer Seite als Bild (Desktop width=1280, Smartphone width=390; max. 4000 px hoch, ohne "
-      + "JavaScript-Effekte). Nach Design- oder Bild-Änderungen prüfen, bevor du antwortest. Begrenzt (30 je Stunde, ein Lauf gleichzeitig).",
+      + "JavaScript; Einblend-Animationen werden sichtbar dargestellt). Nach Design- oder Bild-Änderungen prüfen, bevor du antwortest. Begrenzt (30 je Stunde, ein Lauf gleichzeitig).",
     { site: z.string().optional().describe(SITE_DESC), page: z.string().default("index.html").describe("Seite (ID, Datei oder Slug)."),
       width: z.union([z.literal(1280), z.literal(390)]).default(1280) },
     async ({ site, page, width }) => {