@cardinali-studio/adminkit 1.0.0

package/dist/functions/api/publish.js

@@ -0,0 +1,134 @@
+/* GET·POST /admin/api/publish — mandare online ciò che è stato salvato.
+ *
+ * Salvare e pubblicare erano lo stesso gesto: ogni «Salva e pubblica» era un commit su `main`,
+ * cioè una build di Cloudflare e il sito che cambia. Tre conseguenze, e nessuna era voluta:
+ * il cliente non poteva mettere il lavoro al sicuro senza mandarlo online, ogni salvataggio
+ * costava una build (ed è la build il contatore che ha un tetto), e non esisteva un momento in
+ * cui guardare l'insieme prima di pubblicarlo.
+ *
+ * Ora l'admin scrive sul branch di bozza — nessuna build, il sito fermo — e questo endpoint fa
+ * avanzare il branch pubblicato fino a lì. È l'unico posto in cui `main` viene toccato.
+ *
+ * Dietro Cloudflare Access come tutto ciò che sta sotto /admin/.
+ */
+import { gh, repoBranch, prodBranch, GitHubConflictError } from "../_shared/github.js";
+import { finalizePendingMedia } from "../_shared/pending-media.js";
+
+function json(data, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status, headers: { "Content-Type": "application/json" },
+  });
+}
+
+async function headSha(env, repo, branch) {
+  const r = await gh(env, `/repos/${repo}/git/ref/heads/${encodeURIComponent(branch)}`);
+  if (r.status === 404) return null;
+  if (!r.ok) throw new Error(`ref ${branch} ${r.status}: ${await r.text()}`);
+  return (await r.json()).object.sha;
+}
+
+/* GET — quanto c'è di non pubblicato.
+ *
+ * `compare` in UNA chiamata dà il conteggio e i messaggi: `ahead_by` è quanto la bozza è avanti,
+ * `behind_by` quanto è indietro (cioè: qualcuno ha committato su `main` a mano, e allora un
+ * fast-forward non è possibile).
+ *
+ * I messaggi servono a rispondere alla domanda che uno si fa davvero prima di pubblicare —
+ * «cosa sto mandando online?» — senza dover aprire GitHub.
+ */
+export async function onRequestGet({ env }) {
+  if (!env.GITHUB_TOKEN || !env.GITHUB_REPO) {
+    return json({ ok: false, error: "Backend non configurato." }, 500);
+  }
+  const { repo, branch } = repoBranch(env);
+  const prod = prodBranch(env);
+
+  try {
+    /* Il branch di bozza può non esistere ancora: è un passo manuale della configurazione
+     * (vedi CONFIGURAZIONE.md). Meglio dirlo che rispondere «niente da pubblicare», che sarebbe
+     * vero e insieme profondamente fuorviante. */
+    if ((await headSha(env, repo, branch)) === null) {
+      return json({
+        ok: true, configured: false, ahead: 0, behind: 0, commits: [],
+        error: `Il branch "${branch}" non esiste ancora: va creato da "${prod}".`,
+      });
+    }
+
+    const r = await gh(env, `/repos/${repo}/compare/${encodeURIComponent(prod)}...${encodeURIComponent(branch)}`);
+    if (!r.ok) throw new Error(`compare ${r.status}: ${await r.text()}`);
+    const d = await r.json();
+
+    return json({
+      ok: true,
+      configured: true,
+      ahead: d.ahead_by ?? 0,
+      behind: d.behind_by ?? 0,
+      commits: (d.commits || []).slice(-20).reverse().map((c) => ({
+        message: String(c.commit?.message || "").split("\n")[0],
+        date: c.commit?.author?.date || null,
+      })),
+    });
+  } catch (err) {
+    return json({ ok: false, error: String((err && err.message) || err) }, 502);
+  }
+}
+
+/* POST — pubblica.
+ *
+ * `PATCH /git/refs` senza `force` è fast-forward-only, ed è esattamente la garanzia che serve:
+ * pubblicare non può riscrivere la storia di `main` né cancellare un commit fatto altrove. Se
+ * non è possibile, il 422 diventa un messaggio che dice cosa è successo davvero.
+ */
+export async function onRequestPost({ env, data }) {
+  if (!env.GITHUB_TOKEN || !env.GITHUB_REPO) {
+    return json({ ok: false, error: "Backend non configurato." }, 500);
+  }
+  const { repo, branch } = repoBranch(env);
+  const prod = prodBranch(env);
+  const editor = data?.cloudflareAccess?.JWT?.payload?.email || "admin";
+
+  try {
+    const sha = await headSha(env, repo, branch);
+    if (!sha) return json({ ok: false, error: `Il branch "${branch}" non esiste.` }, 400);
+
+    const prodSha = await headSha(env, repo, prod);
+    if (prodSha === sha) {
+      const media = await finalizePendingMedia(env).catch((error) => ({
+        finalized: 0,
+        pending: null,
+        warning: error?.message || String(error),
+      }));
+      // Non è un errore: è che non c'era niente da fare. Un 200 che lo dice evita di far
+      // partire una build per nulla, e di mostrare un rosso a chi ha solo premuto due volte.
+      return json({ ok: true, published: false, message: "Non c'è niente di nuovo da pubblicare.", media });
+    }
+
+    const r = await gh(env, `/repos/${repo}/git/refs/heads/${encodeURIComponent(prod)}`, {
+      method: "PATCH",
+      body: JSON.stringify({ sha }),
+    });
+
+    if (r.status === 422) {
+      /* `main` è andato avanti per conto suo — un commit fatto a mano, o da un'altra sessione.
+       * Non si forza: sovrascriverlo cancellerebbe quel lavoro. Va riportato nella bozza, e
+       * quello è un gesto da riga di comando, non da pannello. */
+      throw new GitHubConflictError(
+        `Non posso pubblicare: "${prod}" contiene modifiche che non sono nella bozza. ` +
+        `Vanno prima riportate nella bozza (merge), altrimenti pubblicando andrebbero perse.`
+      );
+    }
+    if (!r.ok) throw new Error(`ref ${r.status}: ${await r.text()}`);
+
+    const media = await finalizePendingMedia(env).catch((error) => ({
+      finalized: 0,
+      pending: null,
+      warning: error?.message || String(error),
+    }));
+    return json({ ok: true, published: true, commit: sha, by: editor, media });
+  } catch (err) {
+    if (err instanceof GitHubConflictError) {
+      return json({ ok: false, code: "diverged", error: err.message }, 409);
+    }
+    return json({ ok: false, error: String((err && err.message) || err) }, 502);
+  }
+}

package/dist/functions/api/requests.js

@@ -0,0 +1,57 @@
+/* /admin/api/requests — le richieste arrivate dal form della home.
+ *
+ * Sta sotto /admin/, quindi è già dietro Cloudflare Access E dietro la verifica del JWT in
+ * functions/admin/_middleware.js: qui non serve nessun controllo d'identità, e aggiungerne uno
+ * darebbe la falsa impressione che serva.
+ *
+ *   GET     ?limit=200        elenco, dalla più recente
+ *   PATCH   { id, handled }   segna gestita / da gestire
+ *   DELETE  { id }            elimina
+ *
+ * Non c'è cestino, a differenza dei media: una richiesta è un testo di poche righe, e chi la
+ * elimina lo sta facendo dopo averla letta. Il cestino dei media esiste perché lì si cancellano
+ * file per sbaglio trascinandoli.
+ */
+const MAX = 500;
+
+export async function onRequestGet({ request, env }) {
+  if (!env.DB) return json({ ok: false, error: "Archivio non configurato" }, 500);
+  const url = new URL(request.url);
+  const limit = Math.min(MAX, Math.max(1, Number(url.searchParams.get("limit")) || 200));
+
+  const { results } = await env.DB
+    .prepare("SELECT id, name, email, message, created_at, handled_at FROM requests ORDER BY created_at DESC LIMIT ?")
+    .bind(limit)
+    .all();
+
+  return json({ ok: true, requests: results ?? [] });
+}
+
+export async function onRequestPatch({ request, env }) {
+  if (!env.DB) return json({ ok: false, error: "Archivio non configurato" }, 500);
+  const { id, handled } = await request.json().catch(() => ({}));
+  if (!Number.isInteger(id)) return json({ ok: false, error: "id mancante" }, 400);
+
+  await env.DB
+    .prepare("UPDATE requests SET handled_at = ? WHERE id = ?")
+    .bind(handled ? new Date().toISOString() : null, id)
+    .run();
+
+  return json({ ok: true });
+}
+
+export async function onRequestDelete({ request, env }) {
+  if (!env.DB) return json({ ok: false, error: "Archivio non configurato" }, 500);
+  const { id } = await request.json().catch(() => ({}));
+  if (!Number.isInteger(id)) return json({ ok: false, error: "id mancante" }, 400);
+
+  await env.DB.prepare("DELETE FROM requests WHERE id = ?").bind(id).run();
+  return json({ ok: true });
+}
+
+function json(data, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json", "Cache-Control": "no-store" },
+  });
+}

package/dist/functions/api/settings.js

@@ -0,0 +1,236 @@
+/* GET/POST /admin/api/settings — impostazioni globali del sito.
+ *
+ * I valori pubblici vivono in data/site.json e vengono letti da Hugo durante la build.
+ * Nello stesso file teniamo la sola verifica crittografica della password: mai la password
+ * originale. Hugo non emette automaticamente i file di data/ e i template non serializzano
+ * il blocco `access`, quindi l'hash non finisce nel sito statico.
+ *
+ * Il POST è un unico commit: interfaccia, metadati e protezione del sito entrano in vigore con
+ * la stessa build, senza una finestra in cui il pannello dica una cosa e il sito ne faccia
+ * un'altra.
+ */
+import { json } from "../_shared/assets.js";
+import { site } from "../site.js";
+import {
+  getText, commitUpserts, getRepoSnapshot, gitBlobSha, GitHubConflictError,
+} from "../_shared/github.js";
+
+const PATH = "data/site.json";
+const enc = new TextEncoder();
+
+const defaults = {
+  siteTitle: "",   // il ripiego vero lo dà il sito: vedi `site().name` in publicSettings
+  shortDescription: "",
+  ownerName: "",
+  siteDescription: "",
+  favicon: "",
+  seoWebsiteTitle: "",
+  searchEngineIndexing: true,
+  blockAiTraining: false,
+  analyticsTag: "",
+  /* Le funzioni aggiuntive: attive o no. NON si scrivono dal pannello — `stored` le ricopia
+   * sempre da `previous`, esattamente come `booking`. È deliberato: sono funzioni che il
+   * cliente attiva mettendosi d'accordo con chi gli ha fatto il sito, non premendo un
+   * interruttore. Il pannello le mostra e basta, con l'interruttore disattivato.
+   *
+   * `booking` viene da prima e resta dov'è: è già l'interruttore degli appuntamenti e lo
+   * leggono cinque template Hugo. Duplicarlo in un secondo campo vorrebbe dire due verità
+   * sulla stessa cosa, cioè una delle due prima o poi sbagliata. */
+  analytics: { enabled: false },
+  delivery: { enabled: false },
+  booking: { enabled: false },
+  access: { enabled: false, salt: "", hash: "" },
+};
+
+function cleanText(value, max) {
+  return typeof value === "string" ? value.trim().slice(0, max) : "";
+}
+
+function publicSettings(value) {
+  const v = value && typeof value === "object" ? value : {};
+  return {
+    siteTitle: cleanText(v.siteTitle, 140) || site().name,
+    shortDescription: cleanText(v.shortDescription, 255),
+    ownerName: cleanText(v.ownerName, 120),
+    siteDescription: cleanText(v.siteDescription, 1200),
+    favicon: cleanText(v.favicon, 500),
+    seoWebsiteTitle: cleanText(v.seoWebsiteTitle, 140),
+    searchEngineIndexing: v.searchEngineIndexing !== false,
+    blockAiTraining: v.blockAiTraining === true,
+    /* Codice ARBITRARIO che finisce in ogni pagina del sito. Non si prova a ripulirlo: uno
+     * snippet di analytics È uno `<script>`, quindi qualunque filtro o lo rompe o non
+     * protegge da niente. Quello che lo rende accettabile è chi può scriverlo — solo da
+     * dietro Cloudflare Access, cioè chi potrebbe comunque modificare i template. Il tetto
+     * di caratteri non è sicurezza: impedisce che un incolla sbagliato gonfi ogni pagina. */
+    analyticsTag: cleanText(v.analyticsTag, 4000),
+    /* Una forma SOLA per il pannello, anche se sul disco i due interruttori stanno in posti
+     * diversi (`analytics.enabled` è nuovo, `booking.enabled` c'era già e lo leggono i
+     * template). L'interfaccia non deve conoscere quella differenza: le due voci della
+     * sezione «Funzioni aggiuntive» si disegnano nello stesso modo. */
+    features: {
+      analytics: v.analytics?.enabled === true,
+      delivery: v.delivery?.enabled === true,
+      booking: v.booking?.enabled === true,
+    },
+    passwordEnabled: v.access?.enabled === true && !!v.access?.salt && !!v.access?.hash,
+  };
+}
+
+function fromHex(hex) {
+  if (!/^[a-f0-9]+$/i.test(hex) || hex.length % 2) return new Uint8Array();
+  return Uint8Array.from(hex.match(/../g) || [], (byte) => parseInt(byte, 16));
+}
+
+function toHex(bytes) {
+  return [...new Uint8Array(bytes)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+
+/* 100.000 e non di più, e NON è una scelta di sicurezza: è il tetto della piattaforma. Il
+ * runtime dei Workers risponde `NotSupportedError: Pbkdf2 failed: iteration counts above 100000
+ * are not supported` (la richiesta di alzarlo è cloudflare/workerd#1346, aperta da ottobre 2023
+ * e ancora aperta). OWASP ne chiederebbe 600.000 per SHA-256: non si possono avere.
+ *
+ * ⚠️ Una delle due copie da cui nasce questo pacchetto era passata a 210.000 — un valore che in
+ * produzione solleva l'eccezione al primo utilizzo. Non se n'era accorto nessuno perché su quel
+ * sito la protezione con password non è mai stata accesa. E non lo mostra nemmeno la prova
+ * locale: `wrangler pages dev` accetta 210.000 e persino 600.000 senza fiatare — il tetto esiste
+ * solo nel runtime distribuito. Un limite che non si riproduce in sviluppo è il tipo peggiore,
+ * quindi resta scritto qui.
+ *
+ * ⚠️ Deve restare IDENTICO al conteggio con cui il sito verifica la password (il middleware di
+ * radice del sito, fuori da questo pacchetto): cambiarlo qui senza cambiarlo là rompe l'accesso
+ * senza nessun errore visibile. */
+const PBKDF2_ITERATIONS = 100_000;
+
+async function passwordRecord(password) {
+  const salt = crypto.getRandomValues(new Uint8Array(16));
+  const key = await crypto.subtle.importKey("raw", enc.encode(password), "PBKDF2", false, ["deriveBits"]);
+  const hash = await crypto.subtle.deriveBits(
+    { name: "PBKDF2", hash: "SHA-256", salt, iterations: PBKDF2_ITERATIONS },
+    key,
+    256,
+  );
+  return { enabled: true, salt: toHex(salt), hash: toHex(hash) };
+}
+
+async function readSettings(env, ref) {
+  const raw = await getText(env, PATH, ref);
+  if (raw == null) return { ...defaults, access: { ...defaults.access } };
+  try {
+    const parsed = JSON.parse(raw);
+    return {
+      ...defaults,
+      ...parsed,
+      access: { ...defaults.access, ...(parsed.access || {}) },
+      analytics: { ...defaults.analytics, ...(parsed.analytics || {}) },
+      delivery: { ...defaults.delivery, ...(parsed.delivery || {}) },
+      booking: { ...defaults.booking, ...(parsed.booking || {}) },
+    };
+  } catch {
+    throw new Error(`${PATH} non contiene JSON valido`);
+  }
+}
+
+export async function onRequestGet({ env }) {
+  if (!env.GITHUB_TOKEN || !env.GITHUB_REPO) {
+    return json({ ok: false, error: "backend GitHub non configurato" }, 500);
+  }
+  try {
+    const snapshot = await getRepoSnapshot(env);
+    const file = snapshot.tree.find((entry) => entry.type === "blob" && entry.path === PATH);
+    if (!file) return json({ ok: false, error: `${PATH} non trovato` }, 404);
+    return json({
+      ok: true,
+      settings: publicSettings(await readSettings(env, snapshot.commitSha)),
+      sha: file.sha,
+    });
+  } catch (error) {
+    return json({ ok: false, error: error.message || String(error) }, 500);
+  }
+}
+
+export async function onRequestPost({ request, env, data: ctx }) {
+  if (!env.GITHUB_TOKEN || !env.GITHUB_REPO) {
+    return json({ ok: false, error: "backend GitHub non configurato" }, 500);
+  }
+
+  let body;
+  try { body = await request.json(); }
+  catch { return json({ ok: false, error: "JSON non valido" }, 400); }
+
+  try {
+    const snapshot = await getRepoSnapshot(env);
+    const file = snapshot.tree.find((entry) => entry.type === "blob" && entry.path === PATH);
+    if (!file || typeof body._sha !== "string" || body._sha !== file.sha) {
+      return json({
+        ok: false,
+        code: "stale",
+        error: "Le impostazioni sono state modificate altrove. Non ho salvato nulla: ricarica e riprova.",
+      }, 409);
+    }
+    const previous = await readSettings(env, snapshot.commitSha);
+    if (!cleanText(body.siteTitle, 140)) {
+      return json({ ok: false, code: "invalid", error: "Il titolo del sito è obbligatorio." }, 400);
+    }
+    const nextPublic = publicSettings(body);
+
+    let access = { ...previous.access };
+    if (body.passwordEnabled === false) {
+      access = { enabled: false, salt: "", hash: "" };
+    } else if (body.passwordEnabled === true) {
+      const password = typeof body.password === "string" ? body.password : "";
+      if (password) {
+        if (password.length < 8 || password.length > 200) {
+          return json({
+            ok: false, code: "invalid",
+            error: "La password deve contenere almeno 8 caratteri.",
+          }, 400);
+        }
+        access = await passwordRecord(password);
+      } else if (!(previous.access?.enabled && previous.access?.salt && previous.access?.hash)) {
+        return json({
+          ok: false, code: "invalid",
+          error: "Inserisci una password prima di attivare la protezione.",
+        }, 400);
+      } else {
+        access.enabled = true;
+      }
+    }
+
+    const stored = {
+      siteTitle: nextPublic.siteTitle,
+      shortDescription: nextPublic.shortDescription,
+      ownerName: nextPublic.ownerName,
+      siteDescription: nextPublic.siteDescription,
+      favicon: nextPublic.favicon,
+      seoWebsiteTitle: nextPublic.seoWebsiteTitle,
+      searchEngineIndexing: nextPublic.searchEngineIndexing,
+      blockAiTraining: nextPublic.blockAiTraining,
+      analyticsTag: nextPublic.analyticsTag,
+      /* Ricopiati da `previous`, MAI da `body`: un salvataggio delle impostazioni non può
+       * accendere una funzione a pagamento, nemmeno con una richiesta costruita a mano. */
+      analytics: { ...defaults.analytics, ...(previous.analytics || {}) },
+      delivery: { ...defaults.delivery, ...(previous.delivery || {}) },
+      booking: { ...defaults.booking, ...(previous.booking || {}) },
+      access,
+    };
+    const editor = ctx?.cloudflareAccess?.JWT?.payload?.email || "admin";
+    const content = JSON.stringify(stored, null, 2) + "\n";
+    const sha = await commitUpserts(env, `admin: aggiorna impostazioni sito (${editor})`, [
+      { path: PATH, content },
+    ], { base: snapshot });
+    if (!sha) return json({ ok: false, error: "commit non riuscito" }, 502);
+
+    return json({
+      ok: true, commit: sha, settings: publicSettings(stored), sha: await gitBlobSha(content),
+    });
+  } catch (error) {
+    if (error instanceof GitHubConflictError) {
+      return json({
+        ok: false, code: "conflict",
+        error: "Le impostazioni sono cambiate mentre salvavi. Non ho sovrascritto nulla: ricarica e riprova.",
+      }, 409);
+    }
+    return json({ ok: false, error: error.message || String(error) }, 500);
+  }
+}

package/dist/functions/api/singleton.js

@@ -0,0 +1,105 @@
+/* GET/POST /admin/api/singleton?name=home — i contenuti della home.
+ *
+ * Endpoint SEPARATO da /admin/api/pages, e non è pigrizia architetturale. Il contratto di
+ * quello è "ecco l'elenco completo delle pagine, cancella tutto il resto": un singleton non ha
+ * niente da fare vicino a una spazzata di cancellazione. Qui si usa `commitUpserts`, che sa
+ * solo scrivere — che è esattamente ciò che serve a una cosa che non si elimina mai.
+ *
+ * Vale la stessa invariante delle pagine: il salvataggio è un MERGE. I campi dichiarati nello
+ * schema vengono rigenerati, tutto il resto del front matter — commenti compresi — si ricopia,
+ * e prima di sovrascrivere si verifica di saper riprodurre il file (guardia di fedeltà).
+ */
+import { json } from "../_shared/assets.js";
+import {
+  getText, commitUpserts, getRepoSnapshot, gitBlobSha, GitHubConflictError,
+} from "../_shared/github.js";
+import { serializeItem, deserializeItem, checkFidelity } from "../../index.js";
+import { site } from "../site.js";
+
+// Un solo singleton per ora. È un elenco esplicito e non un percorso arbitrario preso dalla
+// query: l'endpoint sta dietro Access, ma un parametro che diventa un path è comunque il modo
+// in cui si finisce a leggere e scrivere file che non c'entrano.
+const SINGLETONS = {
+  home: () => ({ path: site().homePath, shape: site().home, object: site().homeObject }),
+};
+
+export async function onRequestGet({ request, env }) {
+  if (!env.GITHUB_TOKEN || !env.GITHUB_REPO) {
+    return json({ ok: false, error: "backend GitHub non configurato" }, 500);
+  }
+  const make = SINGLETONS[new URL(request.url).searchParams.get("name") || ""];
+  const s = make?.();
+  if (!s) return json({ ok: false, error: "singleton sconosciuto" }, 404);
+
+  const snapshot = await getRepoSnapshot(env);
+  const file = snapshot.tree.find((entry) => entry.type === "blob" && entry.path === s.path);
+  if (!file) return json({ ok: false, error: "file non trovato" }, 404);
+  const text = await getText(env, s.path, snapshot.commitSha);
+  if (text == null) return json({ ok: false, error: "file non trovato" }, 404);
+
+  return json({ ok: true, data: deserializeItem(text, s.shape), sha: file.sha });
+}
+
+export async function onRequestPost({ request, env, data: ctx }) {
+  if (!env.GITHUB_TOKEN || !env.GITHUB_REPO) {
+    return json({ ok: false, error: "backend GitHub non configurato" }, 500);
+  }
+
+  let body;
+  try { body = await request.json(); } catch { return json({ ok: false, error: "JSON non valido" }, 400); }
+  const make = SINGLETONS[body.name || ""];
+  const s = make?.();
+  if (!s) return json({ ok: false, error: "singleton sconosciuto" }, 404);
+
+  const parsed = s.object.safeParse(body.data);
+  if (!parsed.success) {
+    return json({
+      ok: false, code: "invalid",
+      error: "Contenuti non validi: " +
+        parsed.error.issues.map((i) => `${i.path.join(".") || "?"} ${i.message}`).join("; "),
+    }, 400);
+  }
+
+  const snapshot = await getRepoSnapshot(env);
+  const file = snapshot.tree.find((entry) => entry.type === "blob" && entry.path === s.path);
+  if (!file || typeof body._sha !== "string" || body._sha !== file.sha) {
+    return json({
+      ok: false,
+      code: "stale",
+      error: "La home è stata modificata altrove. Non ho salvato nulla: ricarica e riprova.",
+    }, 409);
+  }
+  const oldMd = await getText(env, s.path, snapshot.commitSha);
+  if (oldMd == null) return json({ ok: false, error: "file non trovato" }, 404);
+
+  // Se non sappiamo riprodurre il file che stiamo per sovrascrivere, non lo sovrascriviamo.
+  const f = checkFidelity(oldMd, s.shape);
+  if (!f.ok) {
+    return json({
+      ok: false, code: "unreadable",
+      error: `Non riesco a riprodurre fedelmente ${s.path}: contiene qualcosa che il lettore del ` +
+             `front matter non gestisce. Per non rischiare di corromperlo non ho salvato nulla.`,
+    }, 409);
+  }
+
+  const editor = ctx?.cloudflareAccess?.JWT?.payload?.email || "admin";
+  // Si valida con Zod, ma si serializza l'oggetto originale: eventuali sotto-campi non ancora
+  // esposti dallo schema non vengono scartati dal parse di z.object.
+  const content = serializeItem(body.data, { shape: s.shape, oldMd });
+
+  try {
+    const sha = await commitUpserts(env, `admin: aggiorna la home (${editor})`, [
+      { path: s.path, content },
+    ], { base: snapshot });
+    if (!sha) return json({ ok: false, error: "commit non riuscito" }, 502);
+    return json({ ok: true, commit: sha, sha: await gitBlobSha(content) });
+  } catch (error) {
+    if (error instanceof GitHubConflictError) {
+      return json({
+        ok: false, code: "conflict",
+        error: "La home è cambiata mentre salvavi. Non ho sovrascritto nulla: ricarica e riprova.",
+      }, 409);
+    }
+    throw error;
+  }
+}

package/dist/functions/api/storage.js

@@ -0,0 +1,125 @@
+/* GET /admin/api/storage — quanto spazio occupano le due librerie.
+ *
+ * Sta sotto /admin/, quindi Access e la verifica del JWT sono già passate dal middleware.
+ *
+ * Due sorgenti, e sono diverse per natura:
+ *
+ *   R2 (i media del sito)  si CONTA, elencando il bucket. Non esiste un'API che dica "quanto
+ *                          pesa questo bucket": il totale è la somma degli oggetti, mille per
+ *                          chiamata. Per questo la risposta passa dalla cache dell'edge.
+ *   B2 (le consegne)       si LEGGE da D1. Gli oggetti su B2 li abbiamo scritti noi e ne
+ *                          conosciamo la dimensione: interrogare il bucket vorrebbe dire
+ *                          firmare una ListObjectsV2 per pagina per sapere una cosa che è già
+ *                          scritta accanto al pacchetto che la usa. E soprattutto: quello che
+ *                          conta è lo spazio ATTRIBUITO a un transfer vivo, non i byte fisici,
+ *                          che restano indietro di qualche giorno per via del lifecycle
+ *                          (tombstone, versioni nascoste e multipart orfani).
+ *
+ * Da qui la parola scelta nel pannello: «in uso», non «fatturato».
+ */
+import { cachedJson } from "../_shared/edge-cache.js";
+import { moduleEnabled } from "../site.js";
+
+/* Cinque minuti: caricare l'elenco di un bucket da qualche migliaio di foto non è gratis, e
+ * nessuno guarda questo numero due volte nello stesso minuto aspettandolo diverso. */
+const TTL = 300;
+/* Ventimila oggetti. Non è una stima dell'archivio di oggi (qualche centinaio): è il punto in
+ * cui smettere per non far scadere la Function. Oltre, il numero si dichiara PARZIALE nel
+ * pannello invece di mostrarne uno sbagliato con l'aria di essere giusto. */
+const MAX_PAGES = 20;
+
+export async function onRequestGet({ request, env, waitUntil }) {
+  const [r2, b2] = await Promise.all([
+    cachedJson(request, waitUntil, "r2-usage", TTL, () => r2Usage(env))
+      .then((out) => ({ ...out.data, cached: out.cached }))
+      .catch((e) => ({ ok: false, error: message(e) })),
+    moduleEnabled("delivery")
+      ? b2Usage(env).catch((e) => ({ ok: false, error: message(e) }))
+      : Promise.resolve({
+          ok: true, bytes: 0, sourceBytes: 0, files: 0, packages: 0,
+          heroes: 0, pendingBytes: 0, configured: false,
+        }),
+  ]);
+  return json({ ok: true, r2, b2 });
+}
+
+async function r2Usage(env) {
+  if (!env.MEDIA) return { ok: false, error: "Binding MEDIA non configurato" };
+
+  let cursor;
+  let objects = 0, bytes = 0, trashObjects = 0, trashBytes = 0, pages = 0, partial = false;
+  do {
+    const page = await env.MEDIA.list({ limit: 1000, cursor });
+    for (const o of page.objects || []) {
+      // I `.keep` sono i segnaposto che tengono in piedi una cartella vuota: zero byte, ma
+      // contarli gonfierebbe il numero delle foto con oggetti che nessuno ha caricato.
+      if (o.key.endsWith("/.keep")) continue;
+      if (o.key.startsWith("_pending-media/")) continue;
+      if (o.key.startsWith("_trash/")) { trashObjects++; trashBytes += o.size; continue; }
+      objects++; bytes += o.size;
+    }
+    cursor = page.truncated ? page.cursor : undefined;
+    if (++pages >= MAX_PAGES && cursor) { partial = true; cursor = undefined; }
+  } while (cursor);
+
+  /* Il cestino è spazio occupato a tutti gli effetti — R2 non ha versioning, `_trash/` è
+   * l'unica rete — ma è anche l'unica parte che si può liberare senza perdere niente del
+   * sito. Va tenuto separato proprio per questo: è l'unica azione possibile davanti al
+   * numero totale. */
+  return { ok: true, objects, bytes, trashObjects, trashBytes, partial };
+}
+
+async function b2Usage(env) {
+  if (!env.DB) return { ok: false, error: "Archivio non configurato" };
+
+  /* `state='ready'` e non semplicemente "non cancellato": un pacchetto in caricamento ha
+   * `stored_bytes` a zero finché non viene finalizzato, quindi includerlo mostrerebbe un
+   * transfer in corso come se non occupasse niente. Lo spazio di chi sta caricando si vede
+   * dentro il transfer, dove c'è la barra di avanzamento che lo spiega. */
+  const packages = await env.DB.prepare(`
+    SELECT COALESCE(SUM(p.stored_bytes),0) bytes,
+           COALESCE(SUM(p.source_bytes),0) source_bytes,
+           COALESCE(SUM(p.file_count),0) files,
+           COUNT(*) packages
+    FROM delivery_packages p
+    JOIN deliveries d ON d.id = p.delivery_id
+    WHERE p.state='ready' AND p.deleted_at IS NULL AND d.status != 'deleted'
+  `).first();
+
+  // Le hero dedicate sono derivate piccole ma sono oggetti B2 come gli altri, e stanno in una
+  // tabella loro: senza questa riga il totale sarebbe più basso del vero.
+  const heroes = await env.DB.prepare(`
+    SELECT COALESCE(SUM(h.bytes),0) bytes, COUNT(*) n
+    FROM delivery_hero_objects h
+    JOIN deliveries d ON d.id = h.delivery_id
+    WHERE h.state='ready' AND d.status != 'deleted'
+  `).first();
+
+  // In attesa di sparire: revocati o scaduti, ancora su B2 finché non passa l'housekeeping.
+  // È spazio che si libera da solo, e dirlo evita la domanda «perché non cala?».
+  const pending = await env.DB.prepare(`
+    SELECT COALESCE(SUM(p.stored_bytes),0) bytes
+    FROM delivery_packages p
+    WHERE p.state='ready' AND p.deleted_at IS NOT NULL
+  `).first();
+
+  return {
+    ok: true,
+    bytes: Number(packages?.bytes || 0) + Number(heroes?.bytes || 0),
+    sourceBytes: Number(packages?.source_bytes || 0),
+    files: Number(packages?.files || 0),
+    packages: Number(packages?.packages || 0),
+    heroes: Number(heroes?.n || 0),
+    pendingBytes: Number(pending?.bytes || 0),
+    configured: !!(env.B2_BUCKET && env.B2_ENDPOINT),
+  };
+}
+
+function message(e) { return e instanceof Error ? e.message : String(e); }
+
+function json(data, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "Content-Type": "application/json", "Cache-Control": "no-store" },
+  });
+}