@cardinali-studio/adminkit 1.0.0

package/dist/functions/_shared/refs.js

@@ -0,0 +1,155 @@
+/* Riferimenti alle immagini dentro le pagine (front matter `images:` e corpo). */
+
+// URL pubblico di una chiave R2, come viene salvato nelle pagine.
+export function mediaUrl(key) {
+  return "/media/" + key.split("/").map(encodeURIComponent).join("/");
+}
+
+// Titolo della pagina dal front matter (o null).
+export function parseTitle(text) {
+  const m = text.match(/^title:[ \t]*(.*?)[ \t]*$/m);
+  if (!m) return null;
+  const value = m[1].trim();
+  const quoted = value.match(/^(["'])([\s\S]*)\1$/);
+  return (quoted ? quoted[2] : value) || null;
+}
+
+// Vero se l'URL è presente nel testo come riferimento a sé stante
+// (boundary: evita che /media/a/b.png matchi dentro /media/a/b.png2).
+export function urlPresent(text, url) {
+  const esc = url.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(esc + "(?![A-Za-z0-9._%/-])").test(text);
+}
+
+/* Rimuove i riferimenti alle url indicate: voci di lista YAML, valori scalari, immagini
+ * markdown `![](url)` e tag `<img src="url">`. Ritorna { text, changed }.
+ *
+ * È una passata TESTUALE e non un giro dallo schema, per la stessa ragione per cui
+ * `frontmatter.ts` non usa una libreria YAML: qui non si sa — e non si deve sapere — in quali
+ * campi possa comparire un'immagine. Oggi sono le foto della gallery, la copertina e le card di
+ * un lavoro, la locandina di un workshop, il ritratto, l'immagine di una sezione, la cover Open
+ * Graph; domani ne basta uno nuovo per far dimenticare un posto. Una regola sulla FORMA li copre
+ * tutti, compresi quelli non ancora dichiarati.
+ *
+ * La distinzione che conta è fra una voce che È un'immagine e una voce che ne CONTIENE una:
+ *
+ *   - src: "/media/food/uno.webp"    la voce È la foto -> via INTERA, righe figlie comprese
+ *     w: 1708                        (`w`/`h`/`hidden` lasciate orfane sarebbero front matter
+ *     h: 2560                         rotto scritto sul repo)
+ *
+ *   - "/media/develop/uno.webp"      idem: una lista di percorsi nudi
+ *
+ *   - image: "/media/workshop/x.webp"  la voce è un'EDIZIONE, che ha una locandina -> si svuota
+ *     title: "Roma 2022"               il solo valore. Portare via la voce vorrebbe dire
+ *     blocks: …                        cancellare titolo e testi insieme alla foto.
+ *
+ *   cover: "/media/books/uno.webp"   valore SCALARE -> si SVUOTA, non si cancella la riga:
+ *                                    togliere la chiave romperebbe la voce di lista che
+ *                                    comincia con essa, e per un campo obbligatorio sarebbe un
+ *                                    file senza un campo che deve esserci. `cover: ""` dice la
+ *                                    cosa giusta — quell'immagine non c'è più.
+ *
+ * A separarli è il NOME della chiave, ed è una convenzione di questo progetto, non una regola di
+ * YAML: `src` si usa dove la voce è la fotografia e basta; `image`/`cover` dove l'immagine
+ * appartiene a qualcosa che ha una vita propria — un lavoro, un'edizione, una card. Chi
+ * aggiungesse una lista di immagini con un'altra chiave deve aggiungerla anche qui.
+ *
+ * Reggeva solo `- "url"`, cioè una lista di stringhe nude. Da quando le foto di una gallery sono
+ * OGGETTI (`w`/`h` servono alla griglia per riservare l'ingombro di ogni cella) quella riga non
+ * combaciava più con niente: si eliminava una foto dai media, l'admin dichiarava di aver pulito
+ * i riferimenti, e nella griglia restava un buco della dimensione esatta della foto sparita. */
+export function removeImageRefs(text, urls) {
+  const norm = (s) => s.trim().replace(/^["']|["']$/g, "");
+  const indentOf = (l) => l.match(/^[ \t]*/)[0].length;
+  const KEY = /^([ \t]*)([A-Za-z_][\w-]*)\s*:\s*(.*)$/;
+  const set = new Set(urls);
+  /** Le chiavi con cui una voce di lista È l'immagine, e quindi va via tutta. */
+  const VOCE_E_IMMAGINE = new Set(["src"]);
+  let changed = false;
+
+  const lines = text.split("\n");
+  const out = [];
+  /* Le chiavi da cui abbiamo tolto delle voci: se restano senza, vanno chiuse con `[]` o il file
+     avrebbe una chiave senza valore. Si segna DOVE sono in `out`, non il loro nome: due campi
+     diversi possono chiamarsi uguale a profondità diverse. */
+  const svuotate = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const item = line.match(/^([ \t]*)-\s+(.*)$/);
+    if (item) {
+      const kv = item[2].match(KEY);
+      // La prima chiave di una voce sta sulla riga del trattino (è la forma che emette
+      // `toYamlLines`): `- src: "…"`. Senza chiave, la voce è una stringa nuda.
+      const laVoceEUnImmagine = !kv || VOCE_E_IMMAGINE.has(kv[2]);
+      if (laVoceEUnImmagine && set.has(norm(kv ? kv[3] : item[2]))) {
+        const base = item[1].length;
+        while (i + 1 < lines.length && lines[i + 1].trim() !== "" && indentOf(lines[i + 1]) > base) i++;
+        for (let j = out.length - 1; j >= 0; j--) {
+          const k = out[j].match(KEY);
+          if (k && indentOf(out[j]) < base) { if (k[3] === "") svuotate.push(j); break; }
+        }
+        changed = true;
+        continue;
+      }
+      // La voce resta: se è lei a portare l'immagine (`- image: "…"`), si svuota il valore.
+      if (kv && kv[3] !== "" && set.has(norm(kv[3]))) {
+        out.push(`${item[1]}- ${kv[2]}: ""`);
+        changed = true;
+        continue;
+      }
+    } else {
+      const kv = line.match(KEY);
+      if (kv && kv[3] !== "" && set.has(norm(kv[3]))) {
+        out.push(`${kv[1]}${kv[2]}: ""`);
+        changed = true;
+        continue;
+      }
+    }
+    out.push(line);
+  }
+
+  for (const j of svuotate) {
+    const base = indentOf(out[j]);
+    // È rimasta almeno una voce sotto questa chiave? Si guarda fin dove arriva il suo blocco.
+    let restano = false;
+    for (let k = j + 1; k < out.length; k++) {
+      if (out[k].trim() === "") continue;
+      if (indentOf(out[k]) <= base) break;
+      if (/^[ \t]*-\s/.test(out[k])) { restano = true; break; }
+    }
+    if (!restano) out[j] = out[j].replace(/:\s*$/, ": []");
+  }
+  let t = out.join("\n");
+
+  for (const u of urls) {
+    const esc = u.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const before = t;
+    // Markdown: supporta anche <url>, spazi e il titolo facoltativo dopo l'indirizzo.
+    t = t.replace(new RegExp(
+      "!\\[[^\\]]*\\]\\(\\s*<?" + esc +
+      ">?(?:\\s+(?:[\"'][^\"']*[\"']|\\([^)]*\\)))?\\s*\\)",
+      "g",
+    ), "");
+    t = t.replace(new RegExp(
+      "<img\\b[^>]*\\bsrc\\s*=\\s*[\"']" + esc + "[\"'][^>]*>",
+      "gi",
+    ), "");
+    if (t !== before) changed = true;
+  }
+
+  return { text: t, changed };
+}
+
+// Sostituisce gli URL immagine (map oldUrl -> newUrl), es. dopo uno spostamento.
+export function replaceImageRefs(text, map) {
+  let t = text, changed = false;
+  for (const [oldUrl, newUrl] of Object.entries(map)) {
+    const esc = oldUrl.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const re = new RegExp(esc + "(?![A-Za-z0-9._%/-])", "g");
+    const before = t;
+    t = t.replace(re, newUrl);
+    if (t !== before) changed = true;
+  }
+  return { text: t, changed };
+}

package/dist/functions/api/analytics.js

@@ -0,0 +1,106 @@
+/* GET /admin/api/analytics?range=7d — le visite del sito, da Umami o da Google Analytics.
+ *
+ * Sta sotto /admin/: Access e la verifica del JWT sono già passate dal middleware.
+ *
+ * È un endpoint SEPARATO da /admin/api/storage, e non è pignoleria: è l'unico pezzo della
+ * Panoramica che dipende da un servizio di qualcun altro. Messo insieme agli altri, un servizio
+ * lento o giù terrebbe ferma una schermata che per il resto legge solo roba nostra — e la
+ * schermata è quella da cui si entra nel pannello.
+ *
+ * ── I due servizi ──────────────────────────────────────────────────────────────────────────
+ * Questo file non sa niente di nessuno dei due: sceglie un driver e gli chiede i numeri di una
+ * finestra temporale. I driver stanno in `_shared/analytics-umami.js` e
+ * `_shared/analytics-ga4.js`, espongono le stesse quattro cose (`id`, `label`, `missing`, `collect`) e
+ * restituiscono la stessa forma. Aggiungerne un terzo significa scrivere un file e metterlo
+ * nell'elenco qui sotto: né questo endpoint né il pannello cambiano.
+ *
+ * Quale dei due: `ANALYTICS_PROVIDER` se dichiarato, altrimenti il primo che risulta
+ * configurato. L'ordine dell'elenco è quindi anche la precedenza.
+ *
+ * ── La chiave non attraversa mai il browser ────────────────────────────────────────────────
+ * Vale per entrambi, con motivi diversi: una chiave di Umami Cloud vale per TUTTI i siti
+ * dell'account, e la chiave privata di un service account Google firma richieste per conto di
+ * quell'identità. Restano secret delle Functions, e fuori esce solo il risultato.
+ *
+ * ── Il tag sul sito è un'altra cosa ────────────────────────────────────────────────────────
+ * Questo endpoint LEGGE le statistiche. A produrle è il tag che si incolla in
+ * Impostazioni → Sito, che vive in `data/site.json` e lo emette `layouts/partials/head.html`.
+ * Sono indipendenti apposta: si può avere il tag senza il pannello collegato (i dati esistono,
+ * si guardano sul servizio) e viceversa (il pannello legge un sito tracciato altrove — è così
+ * che è stato collaudato).
+ */
+import { cachedJson } from "../_shared/edge-cache.js";
+import * as umami from "../_shared/analytics-umami.js";
+import * as ga4 from "../_shared/analytics-ga4.js";
+
+const DRIVERS = [umami, ga4];
+
+/* Un minuto. Umami Cloud ha un tetto di chiamate e ogni caricamento della Panoramica ne fa
+ * quattro (GA4 pure): senza, basta rimbalzare fra le sezioni per consumarlo. Un minuto di
+ * ritardo su un grafico di giorni non lo nota nessuno. */
+const TTL = 60;
+
+const RANGES = {
+  "24h": { hours: 24, unit: "hour" },
+  "7d": { hours: 24 * 7, unit: "day" },
+  "30d": { hours: 24 * 30, unit: "day" },
+};
+
+export async function onRequestGet({ request, env, waitUntil }) {
+  const driver = pickDriver(env);
+  if (!driver) {
+    /* NON è un errore: è una funzione che non è stata ancora accesa, e il pannello lo dice
+     * invece di mostrare un guasto. Si manda cosa manca PER OGNI servizio, così la schermata
+     * può proporre la scelta invece di raccontarne uno solo. */
+    return json({
+      ok: true,
+      configured: false,
+      providers: DRIVERS.map((d) => ({ id: d.id, label: d.label, missing: d.missing(env) })),
+    });
+  }
+
+  const asked = new URL(request.url).searchParams.get("range") || "7d";
+  const range = RANGES[asked] ? asked : "7d";
+  const { hours, unit } = RANGES[range];
+  const endAt = Date.now();
+  const startAt = endAt - hours * 3_600_000;
+
+  try {
+    // La chiave della cache contiene il provider: cambiandolo non si eredita il grafico dell'altro.
+    const { data, cached } = await cachedJson(
+      request, waitUntil, `analytics-${driver.id}-${range}`, TTL,
+      () => driver.collect(env, { startAt, endAt, unit }),
+    );
+    return json({
+      ok: true, configured: true, provider: driver.id, providerLabel: driver.label,
+      range, unit, startAt, endAt, cached, ...data,
+    });
+  } catch (e) {
+    console.error(`analytics ${driver.id}:`, e);
+    return json({
+      ok: false, configured: true, provider: driver.id, providerLabel: driver.label,
+      error: message(e),
+    }, 502);
+  }
+}
+
+function pickDriver(env) {
+  const wanted = String(env.ANALYTICS_PROVIDER || "").trim().toLowerCase();
+  if (wanted) {
+    /* Dichiarato ma incompleto NON deve ricadere sull'altro: si è chiesto quel servizio, e un
+     * silenzioso passaggio al secondo mostrerebbe i numeri di un sito diverso da quello che si
+     * pensa di stare guardando. Meglio «non collegato», che dice cosa manca. */
+    const chosen = DRIVERS.find((d) => d.id === wanted);
+    return chosen && chosen.missing(env).length === 0 ? chosen : null;
+  }
+  return DRIVERS.find((d) => d.missing(env).length === 0) || null;
+}
+
+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" },
+  });
+}

package/dist/functions/api/assets/delete.js

@@ -0,0 +1,241 @@
+/* POST /admin/api/assets/delete — SOFT delete: pulisce i riferimenti nelle
+ * pagine (commit) e sposta i file nel cestino (_trash/, auto-purge 30gg).
+ * Body: { keys?: [...], prefixes?: [...] } (compat: { key }, { prefix }).
+ * Supporta più file/cartelle insieme.
+ *
+ * DUE INTERRUTTORI, e servono a spezzare una cancellazione grande in più richieste senza
+ * moltiplicare i commit:
+ *   refsOnly  pulisce i riferimenti di TUTTE le chiavi e non tocca il bucket
+ *   skipRefs  sposta i file nel cestino e non tocca il repo
+ *
+ * Perché non basta chiamare l'endpoint più volte: la pulizia dei riferimenti costa un commit —
+ * cioè una build — e farne uno per ogni gruppo di file significherebbe otto deploy per una
+ * cancellazione sola. Il client fa una passata `refsOnly` con l'elenco intero (un commit) e poi
+ * manda i file a gruppi con `skipRefs`.
+ *
+ * Perché il client deve spezzare: `moveToTrash` è get + put + delete per file, e ottanta foto da
+ * qualche MB in una richiesta sola non ci stanno — la richiesta muore a metà e i file restano
+ * spostati per una parte e no per il resto. Il valore `trashed` nella risposta è quello vero,
+ * quindi chi chiama sa sempre quanti ne sono passati davvero.
+ */
+import { json, isKey, isPrefix, listKeysUnder } from "../../_shared/assets.js";
+import { mediaUrl } from "../../_shared/refs.js";
+import { rewriteMediaReferences } from "../../_shared/media-content.js";
+import { getBase, DRAFT } from "../../_shared/github.js";
+import { finalizePendingMedia, recordPendingMedia } from "../../_shared/pending-media.js";
+
+const enc = new TextEncoder();
+
+function b64url(bytes) {
+  let raw = "";
+  for (const byte of new Uint8Array(bytes)) raw += String.fromCharCode(byte);
+  return btoa(raw).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+
+function fromB64url(value) {
+  const base64 = value.replace(/-/g, "+").replace(/_/g, "/");
+  const raw = atob(base64 + "=".repeat((4 - base64.length % 4) % 4));
+  return Uint8Array.from(raw, (c) => c.charCodeAt(0));
+}
+
+async function hmacKey(env) {
+  return crypto.subtle.importKey(
+    "raw",
+    enc.encode(env.GITHUB_TOKEN),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign", "verify"],
+  );
+}
+
+/** Prova che queste chiavi hanno superato il preflight. Vive un'ora: abbastanza per i gruppi
+ *  grandi, troppo poco per diventare un'autorizzazione riutilizzabile in futuro. */
+export async function signRefsPreflight(env, keys, commitSha) {
+  const payload = b64url(enc.encode(JSON.stringify({
+    keys: [...new Set(keys)].sort(),
+    repo: env.GITHUB_REPO,
+    branch: env.GITHUB_BRANCH || DRAFT,
+    commit: commitSha,
+    exp: Date.now() + 60 * 60 * 1000,
+  })));
+  const signature = await crypto.subtle.sign("HMAC", await hmacKey(env), enc.encode(payload));
+  return `${payload}.${b64url(signature)}`;
+}
+
+export async function verifyRefsPreflight(env, token, keys, currentCommit) {
+  if (typeof token !== "string") return false;
+  const [payload, signature, extra] = token.split(".");
+  if (!payload || !signature || extra) return false;
+  let data;
+  try {
+    const valid = await crypto.subtle.verify(
+      "HMAC",
+      await hmacKey(env),
+      fromB64url(signature),
+      enc.encode(payload),
+    );
+    if (!valid) return false;
+    data = JSON.parse(new TextDecoder().decode(fromB64url(payload)));
+  } catch {
+    return false;
+  }
+  if (
+    !data || !Array.isArray(data.keys) || data.exp < Date.now()
+    || data.repo !== env.GITHUB_REPO
+    || data.branch !== (env.GITHUB_BRANCH || DRAFT)
+    || !data.commit
+    || data.commit !== currentCommit
+  ) return false;
+  const allowed = new Set(data.keys);
+  return keys.every((key) => allowed.has(key));
+}
+
+export async function onRequestPost({ request, env }) {
+  if (!env.MEDIA) return json({ ok: false, error: "Binding MEDIA non configurato" }, 500);
+  let body;
+  try { body = await request.json(); } catch { return json({ ok: false, error: "JSON non valido" }, 400); }
+  if (!body || typeof body !== "object" || Array.isArray(body)) {
+    return json({ ok: false, error: "Corpo richiesta non valido" }, 400);
+  }
+
+  const keys = new Set();
+  for (const k of (Array.isArray(body.keys) ? body.keys : [])) if (isKey(k)) keys.add(k);
+  if (body.key && isKey(body.key)) keys.add(body.key);
+
+  const prefixes = [
+    ...(Array.isArray(body.prefixes) ? body.prefixes : []),
+    ...(body.prefix ? [body.prefix] : []),
+  ].filter((p) => p && isPrefix(p));
+  const keepKeys = [];
+  for (const pre of prefixes) {
+    for (const k of await listKeysUnder(env.MEDIA, pre)) {
+      if (k.endsWith("/.keep")) keepKeys.push(k); else keys.add(k);
+    }
+  }
+  const keyList = [...keys].filter((k) => !k.startsWith("_trash/"));
+  if (!keyList.length && !keepKeys.length) return json({ ok: true, trashed: 0, pagesUpdated: [] });
+
+  const refsOnly = body.refsOnly === true;
+  const skipRefs = body.skipRefs === true;
+  if (keyList.length && (!env.GITHUB_TOKEN || !env.GITHUB_REPO)) {
+    return json({
+      ok: false,
+      code: "github_unavailable",
+      error: "Non posso eliminare media senza verificare e aggiornare i riferimenti nel sito.",
+    }, 503);
+  }
+  if (skipRefs && keyList.length) {
+    let valid = false;
+    try {
+      const current = await getBase(env);
+      valid = await verifyRefsPreflight(env, body.refsToken, keyList, current.commitSha);
+    } catch (error) {
+      return json({
+        ok: false,
+        code: "github_read_failed",
+        error: `Non riesco a confermare la verifica riferimenti: ${error.message || String(error)}`,
+      }, 502);
+    }
+    if (!valid) {
+      return json({
+        ok: false,
+        code: "media_preflight_required",
+        error: "Il sito è cambiato dopo la verifica dei riferimenti. Ripeti l'operazione.",
+      }, 409);
+    }
+    return json({
+      ok: true,
+      trashed: keyList.length,
+      deferred: true,
+      pagesUpdated: [],
+      warning: "I file resteranno disponibili al sito online fino alla prossima pubblicazione.",
+    });
+  }
+
+  // 1) pulizia riferimenti in tutte le sorgenti (un solo commit). Qualunque file non
+  // riproducibile o non valido blocca TUTTA l'operazione: nessun riferimento viene saltato.
+  const pagesUpdated = [];
+  let verifiedCommit = null;
+  if (!skipRefs && keyList.length) {
+    const urls = keyList.map(mediaUrl);
+    try {
+      const result = await rewriteMediaReferences(
+        env,
+        { removeUrls: urls },
+        "admin: rimuovi riferimenti a immagini eliminate",
+      );
+      pagesUpdated.push(...result.labels);
+      verifiedCommit = result.verifiedCommit;
+    } catch (error) {
+      const blocked = Array.isArray(error.blockers) ? error.blockers : undefined;
+      return json({
+        ok: false,
+        code: error.code || "media_refs_failed",
+        error: error.message || String(error),
+        ...(blocked ? { blockers: blocked } : {}),
+      }, error.code === "media_refs_blocked" || error.code === "conflict" ? 409 : 502);
+    }
+  }
+
+  if (refsOnly) {
+    if (keyList.length) {
+      await recordPendingMedia(
+        env.MEDIA,
+        "trash",
+        keyList.map((oldKey) => ({ oldKey })),
+        verifiedCommit,
+      );
+      await finalizePendingMedia(env).catch(() => null);
+    }
+    for (const keepKey of keepKeys) await env.MEDIA.delete(keepKey);
+    return json({
+      ok: true,
+      trashed: 0,
+      refsOnly: true,
+      refsToken: await signRefsPreflight(env, keyList, verifiedCommit),
+      pagesUpdated: [...new Set(pagesUpdated)],
+    });
+  }
+
+  // Chiamata non spezzata: anche nella breve finestra fra commit e R2 il branch non deve
+  // cambiare, perché una modifica concorrente potrebbe aver reintrodotto uno dei riferimenti.
+  if (!skipRefs && keyList.length) {
+    try {
+      const current = await getBase(env);
+      if (current.commitSha !== verifiedCommit) {
+        return json({
+          ok: false,
+          code: "conflict",
+          error: "Il sito è cambiato dopo la pulizia dei riferimenti. Nessun file è stato cestinato.",
+        }, 409);
+      }
+    } catch (error) {
+      return json({
+        ok: false,
+        code: "github_read_failed",
+        error: `Non riesco a confermare il commit dei riferimenti: ${error.message || String(error)}`,
+      }, 502);
+    }
+  }
+
+  // 2) la rimozione fisica è differita: `main` può ancora contenere i vecchi riferimenti.
+  if (keyList.length) {
+    await recordPendingMedia(
+      env.MEDIA,
+      "trash",
+      keyList.map((oldKey) => ({ oldKey })),
+      verifiedCommit,
+    );
+    await finalizePendingMedia(env).catch(() => null);
+  }
+  for (const kk of keepKeys) {
+    await env.MEDIA.delete(kk);
+  }
+  return json({
+    ok: true,
+    trashed: keyList.length,
+    deferred: true,
+    pagesUpdated: [...new Set(pagesUpdated)],
+    warning: "I file resteranno disponibili al sito online fino alla prossima pubblicazione.",
+  });
+}

package/dist/functions/api/assets/folder.js

@@ -0,0 +1,43 @@
+/* POST /admin/api/assets/folder — crea una cartella (prefisso) nel bucket.
+ * Le cartelle in R2 sono solo prefissi di chiave: creiamo un placeholder
+ * "<prefix>.keep" così la cartella (anche vuota) compare nella lista.
+ * Body: { prefix: "food/" } oppure { parent: "food/", name: "2024" }.
+ * Dietro Access.
+ *
+ * IL NOME SCELTO SI CONSERVA. La chiave dev'essere uno slug — finisce dentro gli URL delle
+ * immagini, che sono pubblici e già indicizzati — ma «Hospitality & Interiors» non deve
+ * diventare «hospitality-interiors» sotto gli occhi di chi l'ha scritto. Il nome per esteso vive
+ * nei customMetadata del `.keep`, cioè accanto alla cosa che nomina: niente elenco di etichette
+ * da tenere allineato altrove, e una cartella senza `.keep` (create prima, o nate caricando in
+ * un prefisso) semplicemente mostra il suo slug.
+ */
+import { isPrefix, json } from "../../_shared/assets.js";
+
+export async function onRequestPost({ request, env }) {
+  if (!env.MEDIA) return json({ ok: false, error: "Binding MEDIA non configurato" }, 500);
+  let body;
+  try { body = await request.json(); } catch { return json({ ok: false, error: "JSON non valido" }, 400); }
+
+  let prefix = String(body.prefix || "").trim().toLowerCase();
+  if (!prefix && body.name) {
+    const parent = String(body.parent || "").trim().toLowerCase();
+    const name = String(body.name).trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+    if (!name) return json({ ok: false, error: "nome cartella non valido" }, 400);
+    prefix = `${parent}${name}/`;
+  }
+  if (!prefix.endsWith("/")) prefix += "/";
+  if (!isPrefix(prefix)) return json({ ok: false, error: `prefisso non valido: ${prefix}` }, 400);
+
+  // L'etichetta è il nome per esteso. Se non arriva, si prende il nome grezzo del body: chi
+  // chiama non deve ricordarsi di mandare due volte la stessa cosa.
+  const label = String(body.label ?? body.name ?? "").trim().slice(0, 120);
+
+  const existing = await env.MEDIA.head(prefix + ".keep");
+  if (existing && !body.relabel) return json({ ok: true, prefix, exists: true, label: existing.customMetadata?.label || "" });
+
+  await env.MEDIA.put(prefix + ".keep", new Uint8Array(0), {
+    httpMetadata: { contentType: "application/x-empty" },
+    customMetadata: label ? { label } : undefined,
+  });
+  return json({ ok: true, prefix, label });
+}

package/dist/functions/api/assets/folders.js

@@ -0,0 +1,32 @@
+/* GET /admin/api/assets/folders — elenco delle cartelle di primo livello con
+ * il numero di file contenuti (ricorsivo). Usato dalla 2ª colonna dell'admin.
+ * Dietro Access.
+ */
+import { json, TRASH, listKeysUnder } from "../../_shared/assets.js";
+import { pendingSourceKeys } from "../../_shared/pending-media.js";
+
+export async function onRequestGet({ env }) {
+  if (!env.MEDIA) return json({ ok: false, error: "Binding MEDIA non configurato" }, 500);
+  const keys = await listKeysUnder(env.MEDIA, "");
+  const pending = await pendingSourceKeys(env.MEDIA);
+  const counts = {};
+  for (const k of keys) {
+    if (k.startsWith(TRASH) || k.startsWith("_pending-media/") || pending.has(k)) continue;
+    const slash = k.indexOf("/");
+    if (slash < 0) continue; // file in root: non appartiene a una cartella
+    const top = k.slice(0, slash);
+    if (!(top in counts)) counts[top] = 0;
+    if (!k.endsWith("/.keep")) counts[top] += 1; // il placeholder non conta
+  }
+  /* L'etichetta (il nome per esteso scelto da chi ha creato la cartella) sta nei metadati del
+   * `.keep`. Una `head` per cartella: sono una manciata, e il conto lo si fa una volta per
+   * caricamento del pannello. Chi non ce l'ha mostra il suo slug, che è il comportamento di
+   * prima — nessuna cartella esistente cambia aspetto. */
+  const names = Object.keys(counts);
+  const folders = await Promise.all(names.map(async (name) => {
+    const keep = await env.MEDIA.head(name + "/.keep");
+    return { name, prefix: name + "/", count: counts[name], label: keep?.customMetadata?.label || "" };
+  }));
+  folders.sort((a, b) => b.count - a.count || a.name.localeCompare(b.name));
+  return json({ ok: true, folders });
+}