@setzkasten-cms/astro-admin 1.1.0 → 1.4.0

package/src/api-routes/history-rollback.ts

@@ -0,0 +1,144 @@
+import type { APIRoute } from 'astro'
+import { resolveStorageConfigForRequest } from './_storage-config'
+import { resolveGitHubTokenForRequest } from './_github-token'
+import { parseSession, requireAdmin } from './_auth-guard'
+import { withTrailers } from './_commit-trailers'
+import { invalidateCache } from './_github-cache'
+
+interface RollbackBody {
+  path?: string
+  sha?: string
+  /** Optional ETag-style guard: client sends the SHA they think is HEAD;
+   *  if HEAD has moved, we 409 to prevent stomping live edits. */
+  expectedHeadSha?: string
+}
+
+/**
+ * POST /api/setzkasten/history/rollback
+ *
+ * Body: { path, sha, expectedHeadSha? }
+ *
+ * Restores `path` to the contents from `sha` by writing a new commit
+ * (no `git revert` — JSON content is set wholesale). The original SHA
+ * stays in history so users can roll forward again.
+ *
+ * Conflict semantics: the client passes the SHA they currently render in
+ * the file picker. If the file's HEAD has moved between page-load and the
+ * rollback click, we return 409 with `code: 'head-moved'` so the UI can
+ * tell the user to refresh.
+ *
+ * Admin-only — editors can edit, but rollback is destructive enough to
+ * warrant the audit-log control.
+ */
+export const POST: APIRoute = async ({ request, cookies }) => {
+  const denied = requireAdmin(cookies.get('setzkasten_session')?.value)
+  if (denied) return denied
+
+  const session = parseSession(cookies.get('setzkasten_session')?.value)
+  if (!session) return new Response('Unauthorized', { status: 401 })
+
+  let body: RollbackBody
+  try {
+    body = (await request.json()) as RollbackBody
+  } catch {
+    return Response.json({ error: 'Invalid JSON body' }, { status: 400 })
+  }
+  const { path, sha, expectedHeadSha } = body
+  if (!path || !sha) {
+    return Response.json({ error: 'path and sha are required' }, { status: 400 })
+  }
+
+  const tokenResult = await resolveGitHubTokenForRequest(request)
+  if (!tokenResult.ok) return new Response(tokenResult.error.message, { status: 500 })
+
+  const storage = await resolveStorageConfigForRequest(request)
+  if (!storage) {
+    return Response.json({ error: 'Could not resolve owner/repo' }, { status: 400 })
+  }
+  const { owner, repo, branch } = storage
+
+  const headers = {
+    Authorization: `Bearer ${tokenResult.value}`,
+    Accept: 'application/vnd.github+json',
+    'X-GitHub-Api-Version': '2022-11-28',
+    'Content-Type': 'application/json',
+  }
+
+  // 1. Fetch contents of the file at the target sha
+  const versionRes = await fetch(
+    `https://api.github.com/repos/${owner}/${repo}/contents/${path}?ref=${sha}`,
+    { headers },
+  )
+  if (versionRes.status === 404) {
+    return Response.json(
+      { error: 'File did not exist at the requested sha', code: 'version-not-found' },
+      { status: 404 },
+    )
+  }
+  if (!versionRes.ok) {
+    return Response.json(
+      { error: `Failed to read version: ${versionRes.status}` },
+      { status: 502 },
+    )
+  }
+  const versionData = (await versionRes.json()) as {
+    content: string
+    encoding: string
+  }
+  const targetContent =
+    versionData.encoding === 'base64'
+      ? Buffer.from(versionData.content, 'base64').toString('utf-8')
+      : versionData.content
+
+  // 2. Fetch current HEAD SHA of the file (for conflict detection + PUT sha param)
+  const headRes = await fetch(
+    `https://api.github.com/repos/${owner}/${repo}/contents/${path}?ref=${branch}`,
+    { headers },
+  )
+  let currentSha: string | null = null
+  if (headRes.ok) {
+    const data = (await headRes.json()) as { sha: string }
+    currentSha = data.sha
+  }
+
+  if (expectedHeadSha && currentSha && expectedHeadSha !== currentSha) {
+    return Response.json(
+      {
+        error: 'Datei wurde inzwischen geändert. Bitte den Verlauf neu laden.',
+        code: 'head-moved',
+      },
+      { status: 409 },
+    )
+  }
+
+  // 3. Write new commit with the historical content
+  const shortSha = sha.slice(0, 7)
+  const fileName = path.split('/').pop() ?? path
+  const message = withTrailers(
+    `revert(${fileName}): rollback to ${shortSha}`,
+    session.user.email,
+  )
+
+  const putBody: Record<string, unknown> = {
+    message,
+    content: Buffer.from(targetContent).toString('base64'),
+    branch,
+  }
+  if (currentSha) putBody.sha = currentSha
+
+  const putRes = await fetch(
+    `https://api.github.com/repos/${owner}/${repo}/contents/${path}`,
+    { method: 'PUT', headers, body: JSON.stringify(putBody) },
+  )
+
+  if (!putRes.ok) {
+    const text = await putRes.text()
+    return Response.json({ error: `Rollback write failed: ${text}` }, { status: 502 })
+  }
+
+  // Invalidate history cache for this path — fresh commit shows up in lists.
+  invalidateCache(`history:${owner}/${repo}:${branch}:${path}:head`)
+
+  const putData = (await putRes.json()) as { commit: { sha: string } }
+  return Response.json({ ok: true, commitSha: putData.commit.sha })
+}

package/src/api-routes/history-version.ts

@@ -0,0 +1,57 @@
+import type { APIRoute } from 'astro'
+import { resolveStorageConfigForRequest } from './_storage-config'
+import { resolveGitHubTokenForRequest } from './_github-token'
+import { requireAdmin } from './_auth-guard'
+import { cachedFetch } from './_github-cache'
+
+/**
+ * GET /api/setzkasten/history/version?path=<file>&sha=<commit-sha>
+ *
+ * Returns the file content at a specific commit (for diff rendering).
+ * Cached per (path, sha) for 5 minutes — historical content is immutable.
+ */
+export const GET: APIRoute = async ({ request, url, cookies }) => {
+  const denied = requireAdmin(cookies.get('setzkasten_session')?.value)
+  if (denied) return denied
+
+  const path = url.searchParams.get('path')
+  const sha = url.searchParams.get('sha')
+  if (!path || !sha) {
+    return Response.json({ error: 'Missing required `path` or `sha`.' }, { status: 400 })
+  }
+
+  const tokenResult = await resolveGitHubTokenForRequest(request)
+  if (!tokenResult.ok) return new Response(tokenResult.error.message, { status: 500 })
+
+  const storage = await resolveStorageConfigForRequest(request)
+  if (!storage) {
+    return Response.json({ error: 'Could not resolve owner/repo' }, { status: 400 })
+  }
+  const { owner, repo } = storage
+
+  const cacheKey = `history-version:${owner}/${repo}:${path}:${sha}`
+  const result = await cachedFetch(cacheKey, 5 * 60_000, async () => {
+    const u = new URL(
+      `https://api.github.com/repos/${owner}/${repo}/contents/${path}`,
+    )
+    u.searchParams.set('ref', sha)
+    const res = await fetch(u, {
+      headers: {
+        Authorization: `Bearer ${tokenResult.value}`,
+        Accept: 'application/vnd.github+json',
+        'X-GitHub-Api-Version': '2022-11-28',
+      },
+    })
+    if (res.status === 404) return { ok: false as const, status: 404, error: 'File not found at given sha' }
+    if (!res.ok) return { ok: false as const, status: 502, error: `GitHub returned ${res.status}` }
+    const data = (await res.json()) as { content: string; encoding: string; sha: string }
+    const raw =
+      data.encoding === 'base64'
+        ? Buffer.from(data.content, 'base64').toString('utf-8')
+        : data.content
+    return { ok: true as const, value: { content: raw, sha: data.sha } }
+  })
+
+  if (!result.ok) return Response.json({ error: result.error }, { status: result.status })
+  return Response.json(result.value)
+}

package/src/api-routes/history.ts

@@ -0,0 +1,119 @@
+import type { APIRoute } from 'astro'
+import { resolveStorageConfigForRequest } from './_storage-config'
+import { resolveGitHubTokenForRequest } from './_github-token'
+import { requireAdmin } from './_auth-guard'
+import { parseCoAuthorTrailers, type CommitInfo } from '@setzkasten-cms/core'
+import { cachedFetch } from './_github-cache'
+
+/**
+ * GET /api/setzkasten/history?path=<contentPath>&before=<sha>
+ *
+ * Returns up to 5 most recent commits affecting the given file. Pagination
+ * via `before=<sha>` returns 10 more older commits — clients call this on
+ * "Mehr laden". Admin-only — editors can read content but not the audit
+ * trail (and certainly not roll back).
+ */
+export const GET: APIRoute = async ({ request, url, cookies }) => {
+  const denied = requireAdmin(cookies.get('setzkasten_session')?.value)
+  if (denied) return denied
+
+  const path = url.searchParams.get('path')
+  const before = url.searchParams.get('before')
+  if (!path) {
+    return Response.json({ error: 'Missing required `path` parameter.' }, { status: 400 })
+  }
+
+  const tokenResult = await resolveGitHubTokenForRequest(request)
+  if (!tokenResult.ok) return new Response(tokenResult.error.message, { status: 500 })
+
+  const storage = await resolveStorageConfigForRequest(request)
+  if (!storage) {
+    return Response.json({ error: 'Could not resolve owner/repo' }, { status: 400 })
+  }
+  const { owner, repo, branch } = storage
+  const perPage = before ? 10 : 5
+
+  // Cache history per (path, before) for 60s — invalidated by rollback.
+  const cacheKey = `history:${owner}/${repo}:${branch}:${path}:${before ?? 'head'}`
+  const commits = await cachedFetch(cacheKey, 60_000, () =>
+    fetchCommits(owner, repo, branch, path, perPage, before, tokenResult.value),
+  )
+
+  if (!commits.ok) {
+    return Response.json({ error: commits.error }, { status: commits.status })
+  }
+  return Response.json({ commits: commits.value })
+}
+
+interface CommitsListSuccess {
+  ok: true
+  value: readonly CommitInfo[]
+}
+interface CommitsListFailure {
+  ok: false
+  status: number
+  error: string
+}
+type CommitsResult = CommitsListSuccess | CommitsListFailure
+
+async function fetchCommits(
+  owner: string,
+  repo: string,
+  branch: string,
+  path: string,
+  perPage: number,
+  before: string | null,
+  token: string,
+): Promise<CommitsResult> {
+  // GitHub paginates by `?sha=<commit>` — passing `before` as `sha` gets
+  // commits older than (and including) that SHA. We start one before
+  // requested SHA so the same commit doesn't appear twice. The simplest
+  // way: pass sha=<before>, request perPage+1, and skip the first.
+  const sha = before ?? branch
+  const u = new URL(`https://api.github.com/repos/${owner}/${repo}/commits`)
+  u.searchParams.set('path', path)
+  u.searchParams.set('sha', sha)
+  u.searchParams.set('per_page', String(before ? perPage + 1 : perPage))
+
+  const res = await fetch(u, {
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: 'application/vnd.github+json',
+      'X-GitHub-Api-Version': '2022-11-28',
+    },
+  })
+
+  if (res.status === 404) return { ok: true, value: [] }
+  if (!res.ok) {
+    return { ok: false, status: 502, error: `GitHub returned ${res.status}` }
+  }
+
+  const data = (await res.json()) as Array<{
+    sha: string
+    commit: {
+      author: { name: string; email: string; date: string }
+      message: string
+    }
+    author: { avatar_url?: string } | null
+  }>
+
+  // Skip first if we paginated (the `before` SHA itself).
+  const start = before ? 1 : 0
+  const slice = data.slice(start, start + perPage)
+  const commits: CommitInfo[] = slice.map((c) => {
+    const [firstLine, ...rest] = c.commit.message.split('\n')
+    const body = rest.join('\n')
+    return {
+      sha: c.sha,
+      shortSha: c.sha.slice(0, 7),
+      authoredAt: c.commit.author.date,
+      authorName: c.commit.author.name,
+      authorEmail: c.commit.author.email,
+      authorAvatarUrl: c.author?.avatar_url,
+      coAuthors: parseCoAuthorTrailers(body),
+      message: firstLine ?? '',
+      body,
+    }
+  })
+  return { ok: true, value: commits }
+}

package/src/api-routes/icons-local.ts

@@ -0,0 +1,169 @@
+import type { APIRoute } from 'astro'
+import {
+  LOCAL_ICONS_DISCOVERY_PATHS,
+  resolveLocalIconsPaths,
+  sanitizeSvg,
+} from '@setzkasten-cms/core'
+import { resolveStorageConfigForRequest, prefixPath } from './_storage-config'
+import { resolveGitHubTokenForRequest } from './_github-token'
+
+/**
+ * GET /api/setzkasten/icons/local
+ *
+ * Lists `.svg` files from the website's local icons folder(s) so the admin
+ * picker can render them as a "Lokal" tab.
+ *
+ * Path resolution:
+ *  1. If `icons.localPath` is set in the website config, scan exactly the
+ *     listed folders (string or string[]). Whatever the user wrote wins.
+ *  2. Otherwise, scan `LOCAL_ICONS_DISCOVERY_PATHS` until a folder yields
+ *     at least one SVG. Lets projects with `public/icons/` or
+ *     `src/assets/svg/` work without touching their config — and surfaces
+ *     the discovered path so the admin can copy it into setzkasten.config.ts.
+ *
+ * Response:
+ *   {
+ *     icons: Array<{ name, svg, source }>,
+ *     paths: string[],            // paths that contributed icons
+ *     discovered: boolean,        // true when discovery fallback ran
+ *   }
+ *
+ * Each `svg` value is server-side sanitized.
+ */
+export const GET: APIRoute = async ({ request, cookies }) => {
+  if (!cookies.get('setzkasten_session')?.value) {
+    return new Response('Unauthorized', { status: 401 })
+  }
+
+  const tokenResult = await resolveGitHubTokenForRequest(request)
+  if (!tokenResult.ok) {
+    return new Response(tokenResult.error.message, { status: 500 })
+  }
+  const token = tokenResult.value
+
+  const storage = await resolveStorageConfigForRequest(request)
+  if (!storage) {
+    return Response.json({ error: 'Could not resolve owner/repo' }, { status: 400 })
+  }
+  const { owner, repo, branch, projectPrefix } = storage
+
+  const fullConfig = (globalThis as any).__SETZKASTEN_FULL_CONFIG__ as
+    | { icons?: { localPath?: string | readonly string[] } }
+    | undefined
+  const configured = resolveLocalIconsPaths(fullConfig?.icons ?? null)
+  const discovered = configured === null
+  const candidatePaths = configured ?? LOCAL_ICONS_DISCOVERY_PATHS
+
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    Accept: 'application/vnd.github+json',
+    'X-GitHub-Api-Version': '2022-11-28',
+  }
+
+  // Scan paths in order. In configured mode, every path contributes —
+  // brand icons + product icons can happily coexist. In discovery mode,
+  // we stop after the first hit so we don't show e.g. raster assets in
+  // `public/icons` next to the real icons in `src/icons`.
+  const MAX_ICONS = 200
+  const yieldedPaths: string[] = []
+  type DirEntry = { name: string; type: 'file' | 'dir'; download_url?: string | null }
+  const allEntries: Array<{ path: string; entry: DirEntry }> = []
+
+  for (const relativePath of candidatePaths) {
+    if (allEntries.length >= MAX_ICONS) break
+    const path = prefixPath(relativePath, projectPrefix)
+    const listRes = await fetch(
+      `https://api.github.com/repos/${owner}/${repo}/contents/${path}?ref=${branch}`,
+      { headers },
+    )
+    if (listRes.status === 404) continue
+    if (!listRes.ok) continue
+    const json = await listRes.json().catch(() => null)
+    if (!Array.isArray(json)) continue
+
+    const svgs = (json as DirEntry[]).filter(
+      (e) => e.type === 'file' && e.name.toLowerCase().endsWith('.svg'),
+    )
+    if (svgs.length === 0) continue
+
+    yieldedPaths.push(relativePath)
+    const remaining = MAX_ICONS - allEntries.length
+    for (const entry of svgs.slice(0, remaining)) {
+      allEntries.push({ path: relativePath, entry })
+    }
+
+    if (discovered) break
+  }
+
+  // Bounded parallel fetch. Without this cap, hundreds of simultaneous
+  // requests against raw.githubusercontent.com carrying the user's token
+  // would burn rate limits on the first picker open.
+  const PARALLELISM = 8
+  type Entry = { path: string; entry: DirEntry }
+  type Result = { id: string; name: string; svg: string; source: string }
+  const results: Array<Result | null> = new Array(allEntries.length).fill(null)
+  let cursor = 0
+
+  async function worker() {
+    while (true) {
+      const idx = cursor++
+      if (idx >= allEntries.length) return
+      const { path, entry } = allEntries[idx]!
+      results[idx] = await fetchAndSanitize(path, entry, token)
+    }
+  }
+
+  await Promise.all(Array.from({ length: Math.min(PARALLELISM, allEntries.length) }, worker))
+
+  // De-dupe by stable id ("path/basename") so colliding basenames across
+  // folders don't corrupt React keys or storage. Stored value uses the
+  // namespaced id; the bare basename is kept as a label for the picker.
+  const seen = new Set<string>()
+  const icons: Result[] = []
+  for (const r of results) {
+    if (!r) continue
+    if (seen.has(r.id)) continue
+    seen.add(r.id)
+    icons.push(r)
+  }
+
+  return Response.json({
+    icons,
+    paths: yieldedPaths,
+    discovered,
+  })
+}
+
+async function fetchAndSanitize(
+  path: string,
+  entry: { name: string; download_url?: string | null },
+  token: string,
+): Promise<{ id: string; name: string; svg: string; source: string } | null> {
+  const baseName = entry.name.replace(/\.svg$/i, '')
+  const url = entry.download_url
+  if (!url) return null
+
+  // Token only goes to GitHub-controlled hosts. The Contents API can in
+  // principle return any download_url; refusing other hosts means a
+  // future API change can't quietly leak the token to third parties.
+  let parsed: URL
+  try {
+    parsed = new URL(url)
+  } catch {
+    return null
+  }
+  const host = parsed.hostname
+  const githubHost = host === 'raw.githubusercontent.com' || host.endsWith('.githubusercontent.com')
+  if (!githubHost) return null
+
+  try {
+    const res = await fetch(url, { headers: { Authorization: `Bearer ${token}` } })
+    if (!res.ok) return null
+    const raw = await res.text()
+    const svg = sanitizeSvg(raw)
+    if (!svg) return null
+    return { id: `${path}/${baseName}`, name: baseName, svg, source: path }
+  } catch {
+    return null
+  }
+}

package/src/api-routes/section-commit-pending.ts

@@ -1,10 +1,13 @@
 import type { APIRoute } from 'astro'
 import { writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
-import { resolveStorageConfigForRequest } from './_storage-config'
+import { resolveStorageConfigForRequest, prefixPath } from './_storage-config'
 import { parseSession, guardPageAccess } from './_auth-guard'
 import { withTrailers } from './_commit-trailers'
 import { resolveGitHubTokenForRequest } from './_github-token'
+import { convertToSetHtml } from '../init/template-patcher-v2'
+import { readPagesMeta } from './_pages-meta-store'
+import { setPageLastModified } from '@setzkasten-cms/core'
 
 /**
  * POST /api/setzkasten/sections/commit-pending
@@ -80,6 +83,45 @@ export const POST: APIRoute = async ({ request, cookies }) => {
       })),
     ]
 
+    // Auto-upgrade plain-text fields to set:html when the user introduces
+    // formatting via the inline RTE. Without this, Astro's `{value}` escapes
+    // tags and the published page shows literal `<strong>…</strong>`. We
+    // detect HTML in any committed string value, fetch the section template,
+    // run convertToSetHtml (idempotent — no-op if already converted), and
+    // include the patched template in the same batch commit.
+    const sectionsWithHtml = [...sections, ...edits]
+      .filter(s => containsHtmlValue(s.content))
+      .map(s => s.key)
+    const projectPrefix = (storage as { projectPrefix?: string }).projectPrefix
+    for (const sectionKey of sectionsWithHtml) {
+      const componentPath = prefixPath(
+        `src/components/sections/${pascalCase(sectionKey)}Section.astro`,
+        projectPrefix ?? '',
+      )
+      if (files.some(f => f.path === componentPath)) continue
+      const original = await fetchFileContent(owner, repo, branch, componentPath, githubToken)
+      if (!original) continue
+      const patched = convertToSetHtml(original)
+      if (patched !== original) {
+        files.push({ path: componentPath, content: patched })
+      }
+    }
+
+    // Fold the recency-meta update into this same batch commit. Previously
+    // we issued a follow-up PUT via recordPageEdit, which produced a second
+    // commit ("chore(meta): update _pages-meta.json") and a second deploy
+    // for every save — visible noise in history and wasted CI minutes.
+    const metaContentPath: string = serverConfig?.storage?.contentPath ?? 'content'
+    const metaTarget = { owner, repo, branch, contentPath: metaContentPath, token: githubToken }
+    const metaSnapshot = await readPagesMeta(metaTarget)
+    if (metaSnapshot.ok) {
+      const nextMeta = setPageLastModified(metaSnapshot.value.meta, pageKey, Date.now())
+      files.push({
+        path: `${metaContentPath}/_pages-meta.json`,
+        content: JSON.stringify(nextMeta, null, 2),
+      })
+    }
+
     const parts: string[] = []
     if (sections.length > 0) {
       const keys = sections.map(s => s.key).join(', ')
@@ -110,14 +152,25 @@ export const POST: APIRoute = async ({ request, cookies }) => {
       )
     }
 
-    // Best-effort recency tracking. Metadata write must not derail the
-    // primary save — surface failures via the trailing return only.
-    const { recordPageEdit } = await import('./_pages-meta-store.js')
-    const metaContentPath: string = serverConfig?.storage?.contentPath ?? 'content'
-    await recordPageEdit(
-      { owner, repo, branch, contentPath: metaContentPath, token: tokenResult.value },
-      pageKey,
-    ).catch(() => {})
+    // Fire content.save webhooks. Best-effort, fire-and-forget — does
+    // not block the response.
+    const { fireWebhooks } = await import('./_webhook-dispatcher.js')
+    const parsedSession = parseSession(cookies.get('setzkasten_session')?.value)
+    void fireWebhooks(
+      'content.save',
+      {
+        website: { id: owner, repo: `${owner}/${repo}`, branch },
+        user: {
+          email: parsedSession?.user?.email ?? 'unknown',
+          name: parsedSession?.user?.name,
+        },
+        commit: { sha: commitResult.sha, message: `Commit on ${pageKey}` },
+        files: sections.map((s: { key: string }) => ({
+          path: `${metaContentPath}/_sections/${s.key}.json`,
+        })),
+      },
+      request,
+    )
 
     return Response.json({ success: true, commitSha: commitResult.sha })
   } catch (error) {
@@ -129,6 +182,52 @@ export const POST: APIRoute = async ({ request, cookies }) => {
   }
 }
 
+/** Recursively scan a section content tree for any string value containing
+ *  inline HTML markup (a `<` followed by an ASCII letter or `/`). Used to
+ *  decide whether the section template needs upgrading to set:html. */
+function containsHtmlValue(value: unknown): boolean {
+  if (typeof value === 'string') return /<\/?[a-z]/i.test(value)
+  if (Array.isArray(value)) return value.some(containsHtmlValue)
+  if (value && typeof value === 'object') return Object.values(value).some(containsHtmlValue)
+  return false
+}
+
+function pascalCase(input: string): string {
+  return input
+    .split(/[-_\s]+/)
+    .filter(Boolean)
+    .map(s => s.charAt(0).toUpperCase() + s.slice(1))
+    .join('')
+}
+
+async function fetchFileContent(
+  owner: string,
+  repo: string,
+  branch: string,
+  path: string,
+  token: string,
+): Promise<string | null> {
+  try {
+    const res = await fetch(
+      `https://api.github.com/repos/${owner}/${repo}/contents/${path}?ref=${branch}`,
+      {
+        headers: {
+          Authorization: `Bearer ${token}`,
+          Accept: 'application/vnd.github+json',
+          'X-GitHub-Api-Version': '2022-11-28',
+        },
+      },
+    )
+    if (!res.ok) return null
+    const data = await res.json() as { content: string; encoding: string }
+    return data.encoding === 'base64'
+      ? Buffer.from(data.content, 'base64').toString('utf-8')
+      : data.content
+  } catch {
+    return null
+  }
+}
+
 async function batchCommit(
   owner: string, repo: string, branch: string,
   files: Array<{ path: string; content: string }>,

package/src/api-routes/section-delete.ts

@@ -90,6 +90,20 @@ export const DELETE: APIRoute = async ({ request, cookies }) => {
       pageKey,
     ).catch(() => {})
 
+    // Fire content.delete webhooks (fire-and-forget).
+    const { fireWebhooks } = await import('./_webhook-dispatcher.js')
+    const session = parseSession(cookies.get('setzkasten_session')?.value)
+    void fireWebhooks(
+      'content.delete',
+      {
+        website: { id: owner, repo: `${owner}/${repo}`, branch },
+        user: { email: session?.user?.email ?? 'unknown', name: session?.user?.name },
+        commit: { sha: commitResult.sha, message: `Delete ${sectionKey} from ${pageKey}` },
+        files: [{ path: sectionJsonPath }],
+      },
+      request,
+    )
+
     return Response.json({ success: true, commitSha: commitResult.sha })
   } catch (error) {
     console.error('[setzkasten] section-delete error:', error)