@setzkasten-cms/astro-admin 1.4.0 → 1.4.2

package/dist/api-routes/icons-local.d.ts

@@ -0,0 +1,28 @@
+import { APIRoute } from 'astro';
+
+/**
+ * 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.
+ */
+declare const GET: APIRoute;
+
+export { GET };

package/dist/api-routes/icons-local.js

@@ -0,0 +1,115 @@
+import {
+  prefixPath,
+  resolveStorageConfigForRequest
+} from "../chunk-6UIKVKED.js";
+import {
+  resolveGitHubTokenForRequest
+} from "../chunk-NKDATSPA.js";
+
+// src/api-routes/icons-local.ts
+import {
+  LOCAL_ICONS_DISCOVERY_PATHS,
+  resolveLocalIconsPaths,
+  sanitizeSvg
+} from "@setzkasten-cms/core";
+var GET = 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.__SETZKASTEN_FULL_CONFIG__;
+  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"
+  };
+  const MAX_ICONS = 200;
+  const yieldedPaths = [];
+  const allEntries = [];
+  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.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;
+  }
+  const PARALLELISM = 8;
+  const results = 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));
+  const seen = /* @__PURE__ */ new Set();
+  const icons = [];
+  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, entry, token) {
+  const baseName = entry.name.replace(/\.svg$/i, "");
+  const url = entry.download_url;
+  if (!url) return null;
+  let parsed;
+  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;
+  }
+}
+export {
+  GET
+};

package/dist/api-routes/init-add-section.d.ts

@@ -0,0 +1,23 @@
+import { APIRoute } from 'astro';
+
+/**
+ * POST /api/setzkasten/init/add-section
+ *
+ * Adds a single section to an already-initialized Setzkasten project.
+ * Updates setzkasten.config.ts, creates the content JSON, and updates the page config.
+ * All changes are committed as a single batch via Git Trees API.
+ *
+ * Body: { owner, repo, branch?, projectRoot, section, pageKey, contentPath? }
+ */
+declare const POST: APIRoute;
+/**
+ * Add import statement and SECTION_COMPONENTS registry entry to a page file.
+ * Returns the patched source, or null if no changes needed.
+ */
+declare function patchPageFile(source: string, sectionKey: string, componentName: string, componentPath: string, pagePath: string): string | null;
+/**
+ * Calculate a relative import path from a page directory to a component file.
+ */
+declare function calculateRelativePath(fromDir: string, toPath: string): string;
+
+export { POST, calculateRelativePath, patchPageFile };

package/dist/api-routes/init-add-section.js

@@ -0,0 +1,396 @@
+import {
+  patchTemplateForFields,
+  stripTemplateFallbacks
+} from "../chunk-RHJONMLK.js";
+import {
+  prefixPath,
+  resolveStorageConfigForRequest
+} from "../chunk-6UIKVKED.js";
+import {
+  resolveGitHubTokenForRequest
+} from "../chunk-NKDATSPA.js";
+import {
+  withTrailers
+} from "../chunk-KH22FJO5.js";
+
+// src/api-routes/init-add-section.ts
+import { addSectionToConfig } from "@setzkasten-cms/core/init";
+var POST = async ({ request, cookies }) => {
+  const session = cookies.get("setzkasten_session")?.value;
+  if (!session) {
+    return new Response("Unauthorized", { status: 401 });
+  }
+  const tokenResult = await resolveGitHubTokenForRequest(request);
+  if (!tokenResult.ok) {
+    return new Response(tokenResult.error.message, { status: 500 });
+  }
+  const githubToken = tokenResult.value;
+  try {
+    const body = await request.json();
+    const storage = await resolveStorageConfigForRequest(request, body);
+    if (!storage) {
+      return Response.json({ error: "Could not resolve owner/repo. Set SETZKASTEN_OWNER and SETZKASTEN_REPO env vars." }, { status: 400 });
+    }
+    const { owner, repo, branch, projectPrefix } = storage;
+    const serverConfig = globalThis.__SETZKASTEN_CONFIG__;
+    const contentPath = body.contentPath || serverConfig?.storage?.contentPath || "content";
+    const { section, pageKey } = body;
+    if (!section || !pageKey) {
+      return Response.json({ error: "section and pageKey are required" }, { status: 400 });
+    }
+    const headers = {
+      Authorization: `Bearer ${githubToken}`,
+      Accept: "application/vnd.github+json",
+      "X-GitHub-Api-Version": "2022-11-28",
+      "Content-Type": "application/json"
+    };
+    const filesToCommit = [];
+    const configPath = prefixPath("setzkasten.config.ts", projectPrefix);
+    const existingConfig = await fetchFileContent(owner, repo, branch, configPath, githubToken);
+    if (existingConfig) {
+      const updatedConfig = addSectionToConfig(existingConfig, section.key, section, section.allFields);
+      if (updatedConfig) {
+        filesToCommit.push({ path: configPath, content: updatedConfig });
+      }
+    }
+    const sectionJsonPath = `${contentPath}/_sections/${section.key}.json`;
+    const existingSectionJson = await fetchFileContent(owner, repo, branch, sectionJsonPath, githubToken);
+    let sectionData = {};
+    if (existingSectionJson) {
+      try {
+        sectionData = JSON.parse(existingSectionJson);
+      } catch {
+      }
+    }
+    for (const field of section.fields) {
+      if (!(field.key in sectionData)) {
+        let value = field.defaultValue ?? getDefaultValue(field.type);
+        if (Array.isArray(value)) value = value.filter((item) => item != null);
+        sectionData[field.key] = value;
+      }
+    }
+    const orderedKeys = (section.allFields ?? section.fields).map((f) => f.key);
+    const orderedData = {};
+    for (const key of orderedKeys) {
+      if (key in sectionData) {
+        orderedData[key] = sectionData[key];
+      }
+    }
+    for (const key of Object.keys(sectionData)) {
+      if (!(key in orderedData)) {
+        orderedData[key] = sectionData[key];
+      }
+    }
+    filesToCommit.push({
+      path: sectionJsonPath,
+      content: JSON.stringify(orderedData, null, 2)
+    });
+    const configKey = "_" + pageKey.replace(/\//g, "_");
+    const pageConfigPath = `${contentPath}/pages/${configKey}.json`;
+    const existingPageConfig = await fetchFileContent(owner, repo, branch, pageConfigPath, githubToken);
+    let pageConfig;
+    if (existingPageConfig) {
+      pageConfig = JSON.parse(existingPageConfig);
+      const normalizeKey = (k) => k.replace(/[-_]/g, "").toLowerCase();
+      const normalizedNewKey = normalizeKey(section.key);
+      if (!pageConfig.sections.some((s) => normalizeKey(s.key) === normalizedNewKey)) {
+        pageConfig.sections.push({ key: section.key, enabled: true });
+      }
+    } else {
+      pageConfig = {
+        sections: [{ key: section.key, enabled: true }]
+      };
+    }
+    filesToCommit.push({
+      path: pageConfigPath,
+      content: JSON.stringify(pageConfig, null, 2)
+    });
+    if (section.isPageLevel && body.pagePath) {
+      let fullPagePath = prefixPath(body.pagePath, projectPrefix);
+      let pageSource = await fetchFileContent(owner, repo, branch, fullPagePath, githubToken);
+      let resolvedPagePath = body.pagePath;
+      if (!pageSource && body.pagePath.endsWith(".astro")) {
+        const indexPath = body.pagePath.replace(/\.astro$/, "/index.astro");
+        fullPagePath = prefixPath(indexPath, projectPrefix);
+        pageSource = await fetchFileContent(owner, repo, branch, fullPagePath, githubToken);
+        if (pageSource) resolvedPagePath = indexPath;
+      }
+      if (pageSource) {
+        const repeatedGroups = section._analyzerResult?.repeatedGroups ?? [];
+        let patchedSource = await patchTemplateForFields(
+          pageSource,
+          section.key,
+          section.allFields ?? section.fields,
+          repeatedGroups,
+          { mode: "page" }
+        );
+        const { source: strippedSource, fallbacks } = stripTemplateFallbacks(patchedSource);
+        if (strippedSource !== patchedSource) {
+          patchedSource = strippedSource;
+          let jsonUpdated = false;
+          for (const [key, value] of Object.entries(fallbacks)) {
+            const existing = sectionData[key];
+            const existingIsPlain = typeof existing === "string" && !/<[a-z]/.test(existing);
+            const newIsHtml = typeof value === "string" && /<[a-z]/.test(value);
+            if (!(key in sectionData) || existing === "" || existing === null || existingIsPlain && newIsHtml) {
+              sectionData[key] = value;
+              jsonUpdated = true;
+            }
+          }
+          if (jsonUpdated) {
+            const jsonIdx = filesToCommit.findIndex((f) => f.path === sectionJsonPath);
+            if (jsonIdx !== -1) {
+              filesToCommit[jsonIdx].content = JSON.stringify(sectionData, null, 2);
+            }
+          }
+        }
+        if (patchedSource !== pageSource) {
+          filesToCommit.push({ path: fullPagePath, content: patchedSource });
+          const previewCopySource = patchedSource.replace(/\bexport\s+const\s+prerender\s*=\s*true\s*;?\s*\n?/, "").replace(/(from\s+')(\.\.\/)/g, "$1../$2").replace(/(from\s+")(\.\.\/)/g, "$1../$2");
+          const relativePage = resolvedPagePath.replace(/^src\/pages\//, "");
+          const previewCopyPath = prefixPath(`src/pages/sk-preview/${relativePage}`, projectPrefix);
+          filesToCommit.push({ path: previewCopyPath, content: previewCopySource });
+        }
+        const fields = section.allFields ?? section.fields;
+        for (const g of repeatedGroups) {
+          const topField = fields.find((f) => f.key === g.fieldKey);
+          if (!topField || !Array.isArray(topField.defaultValue)) continue;
+          sectionData[g.fieldKey] = topField.defaultValue.filter((item) => item != null);
+          const jsonIdx = filesToCommit.findIndex((f) => f.path === sectionJsonPath);
+          if (jsonIdx !== -1) {
+            filesToCommit[jsonIdx].content = JSON.stringify(sectionData, null, 2);
+          }
+        }
+      }
+    } else if (section.componentPath) {
+      const componentSource = await fetchFileContent(owner, repo, branch, section.componentPath, githubToken);
+      if (componentSource) {
+        const repeatedGroups = section._analyzerResult?.repeatedGroups ?? [];
+        const patchedSource = await patchTemplateForFields(componentSource, section.key, section.allFields ?? section.fields, repeatedGroups);
+        if (patchedSource !== componentSource) {
+          filesToCommit.push({ path: section.componentPath, content: patchedSource });
+        }
+        const fields = section.allFields ?? section.fields;
+        for (const g of repeatedGroups) {
+          const topField = fields.find((f) => f.key === g.fieldKey);
+          if (!topField || !Array.isArray(topField.defaultValue)) continue;
+          const items = topField.defaultValue.filter((item) => item != null);
+          sectionData[g.fieldKey] = items;
+          const jsonIdx = filesToCommit.findIndex((f) => f.path === sectionJsonPath);
+          if (jsonIdx !== -1) {
+            filesToCommit[jsonIdx].content = JSON.stringify(sectionData, null, 2);
+          }
+        }
+      }
+      if (body.pagePath && section.componentName) {
+        const fullPagePath = prefixPath(body.pagePath, projectPrefix);
+        const pageSource = await fetchFileContent(owner, repo, branch, fullPagePath, githubToken);
+        if (pageSource) {
+          const patched = patchPageFile(pageSource, section.key, section.componentName, section.componentPath, body.pagePath);
+          if (patched && patched !== pageSource) {
+            filesToCommit.push({ path: fullPagePath, content: patched });
+          }
+        }
+        const pageDir = body.pagePath.replace(/\/[^/]+$/, "");
+        const previewPath = prefixPath(`${pageDir}/sk-preview/[...page].astro`, projectPrefix);
+        const previewSource = await fetchFileContent(owner, repo, branch, previewPath, githubToken);
+        if (previewSource) {
+          const patchedPreview = patchPageFile(previewSource, section.key, section.componentName, section.componentPath, `${pageDir}/sk-preview/[...page].astro`);
+          if (patchedPreview && patchedPreview !== previewSource) {
+            filesToCommit.push({ path: previewPath, content: patchedPreview });
+          }
+        }
+      }
+    }
+    if (filesToCommit.length === 0) {
+      return Response.json({ error: "Nothing to commit" }, { status: 400 });
+    }
+    const commitResult = await batchCommit(
+      owner,
+      repo,
+      branch,
+      filesToCommit,
+      withTrailers(existingSectionJson ? `content: update ${section.key} section \u2014 add new fields` : `content: add ${section.key} section to Setzkasten`),
+      headers
+    );
+    if (!commitResult.ok) {
+      return Response.json({ error: commitResult.error }, { status: 500 });
+    }
+    const { recordPageEdit } = await import("./_pages-meta-store.js");
+    await recordPageEdit(
+      { owner, repo, branch, contentPath, token: tokenResult.value },
+      pageKey
+    ).catch(() => {
+    });
+    return Response.json({
+      success: true,
+      commitSha: commitResult.sha,
+      filesWritten: filesToCommit.map((f) => f.path)
+    });
+  } catch (error) {
+    console.error("[setzkasten] add-section error:", error);
+    return Response.json(
+      { error: error instanceof Error ? error.message : "Add section failed" },
+      { status: 500 }
+    );
+  }
+};
+function getDefaultValue(fieldType) {
+  switch (fieldType) {
+    case "text":
+      return "";
+    case "number":
+      return 0;
+    case "boolean":
+      return false;
+    case "image":
+      return { path: "", alt: "" };
+    case "array":
+      return [];
+    case "color":
+      return "#000000";
+    case "date":
+      return "";
+    case "icon":
+      return "";
+    default:
+      return "";
+  }
+}
+function patchPageFile(source, sectionKey, componentName, componentPath, pagePath) {
+  const normalize = (k) => k.replace(/[-_]/g, "").toLowerCase();
+  if (source.includes(`import ${componentName}`) || source.includes(`'${componentName}'`)) {
+    if (source.includes(normalize(sectionKey))) return null;
+  }
+  const pageDir = pagePath.replace(/\/[^/]+$/, "");
+  const relPath = calculateRelativePath(pageDir, componentPath);
+  let patched = source;
+  const lastImportMatch = patched.match(/import\s+\w+\s+from\s+['"][^'"]*Section\.astro['"];?\s*\n/);
+  if (lastImportMatch) {
+    let lastIdx = 0;
+    const importRegex = /import\s+\w+\s+from\s+['"][^'"]*Section\.astro['"];?\s*\n/g;
+    let m;
+    while ((m = importRegex.exec(patched)) !== null) {
+      lastIdx = m.index + m[0].length;
+    }
+    const importLine = `import ${componentName} from '${relPath}';
+`;
+    if (!patched.includes(`import ${componentName}`)) {
+      patched = patched.slice(0, lastIdx) + importLine + patched.slice(lastIdx);
+    }
+  }
+  const registryPattern = /SECTION_COMPONENTS[^{]*\{([^}]*)\}/s;
+  const registryMatch = patched.match(registryPattern);
+  if (registryMatch) {
+    const registryContent = registryMatch[1];
+    if (!registryContent.includes(normalize(sectionKey))) {
+      const lastEntryMatch = registryContent.match(/.*\w+Section,?\s*$/m);
+      if (lastEntryMatch && lastEntryMatch.index !== void 0) {
+        const insertPos = registryMatch.index + registryMatch[0].indexOf(registryContent) + lastEntryMatch.index + lastEntryMatch[0].length;
+        const newEntry = `
+  [normalize('${sectionKey}')]: ${componentName},`;
+        patched = patched.slice(0, insertPos) + newEntry + patched.slice(insertPos);
+      }
+    }
+  }
+  const hardcodedPattern = new RegExp(`\\s*<${componentName}\\s*/?>\\s*\\n?`, "g");
+  patched = patched.replace(hardcodedPattern, "\n");
+  return patched !== source ? patched : null;
+}
+function calculateRelativePath(fromDir, toPath) {
+  const fromParts = fromDir.split("/");
+  const toParts = toPath.split("/");
+  let common = 0;
+  while (common < fromParts.length && common < toParts.length && fromParts[common] === toParts[common]) {
+    common++;
+  }
+  const ups = fromParts.length - common;
+  const remaining = toParts.slice(common).join("/");
+  if (ups === 0) return "./" + remaining;
+  return "../".repeat(ups) + remaining;
+}
+async function fetchFileContent(owner, repo, branch, path, token) {
+  try {
+    const response = 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 (!response.ok) return null;
+    const data = await response.json();
+    return data.encoding === "base64" ? Buffer.from(data.content, "base64").toString("utf-8") : data.content;
+  } catch {
+    return null;
+  }
+}
+async function batchCommit(owner, repo, branch, files, message, headers) {
+  try {
+    const refRes = await fetch(
+      `https://api.github.com/repos/${owner}/${repo}/git/refs/heads/${branch}`,
+      { headers }
+    );
+    if (!refRes.ok) return { ok: false, error: `Failed to get HEAD: ${refRes.status}` };
+    const refData = await refRes.json();
+    const headSha = refData.object.sha;
+    const commitRes = await fetch(
+      `https://api.github.com/repos/${owner}/${repo}/git/commits/${headSha}`,
+      { headers }
+    );
+    if (!commitRes.ok) return { ok: false, error: `Failed to get commit: ${commitRes.status}` };
+    const commitData = await commitRes.json();
+    const treeRes = await fetch(
+      `https://api.github.com/repos/${owner}/${repo}/git/trees`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          base_tree: commitData.tree.sha,
+          tree: files.map((f) => ({
+            path: f.path,
+            mode: "100644",
+            type: "blob",
+            content: f.content
+          }))
+        })
+      }
+    );
+    if (!treeRes.ok) return { ok: false, error: `Failed to create tree: ${treeRes.status}` };
+    const treeData = await treeRes.json();
+    const newCommitRes = await fetch(
+      `https://api.github.com/repos/${owner}/${repo}/git/commits`,
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          tree: treeData.sha,
+          parents: [headSha],
+          message
+        })
+      }
+    );
+    if (!newCommitRes.ok) return { ok: false, error: `Failed to create commit: ${newCommitRes.status}` };
+    const newCommitData = await newCommitRes.json();
+    const updateRes = await fetch(
+      `https://api.github.com/repos/${owner}/${repo}/git/refs/heads/${branch}`,
+      {
+        method: "PATCH",
+        headers,
+        body: JSON.stringify({ sha: newCommitData.sha })
+      }
+    );
+    if (!updateRes.ok) return { ok: false, error: `Failed to update ref: ${updateRes.status}` };
+    return { ok: true, sha: newCommitData.sha };
+  } catch (error) {
+    return { ok: false, error: error instanceof Error ? error.message : "Commit failed" };
+  }
+}
+export {
+  POST,
+  calculateRelativePath,
+  patchPageFile
+};

package/dist/api-routes/init-apply.d.ts

@@ -0,0 +1,11 @@
+import { APIRoute } from 'astro';
+
+/**
+ * POST /api/setzkasten/init/apply
+ *
+ * Generates config + content files and commits them to the repo.
+ * Body: ApplyRequest
+ */
+declare const POST: APIRoute;
+
+export { POST };