@setzkasten-cms/astro 0.4.2

package/src/api-routes/github-proxy.ts

@@ -0,0 +1,82 @@
+import type { APIRoute } from 'astro'
+
+/**
+ * Server-side proxy for GitHub API calls.
+ * The GitHub App token stays server-side (never exposed to browser).
+ *
+ * Client calls: POST /api/setzkasten/github/repos/{owner}/{repo}/...
+ * Proxy forwards to: https://api.github.com/repos/{owner}/{repo}/...
+ */
+export const ALL: APIRoute = async ({ params, request, cookies }) => {
+  // Verify session
+  const session = cookies.get('setzkasten_session')?.value
+  if (!session) {
+    return new Response('Unauthorized', { status: 401 })
+  }
+
+  const githubPath = params.path
+  if (!githubPath) {
+    return new Response('Missing path', { status: 400 })
+  }
+
+  // GitHub App token from environment (never sent to client)
+  const githubToken = import.meta.env.GITHUB_TOKEN ?? process.env.GITHUB_TOKEN
+
+  if (!githubToken) {
+    return new Response('GitHub token not configured', { status: 500 })
+  }
+
+  const githubUrl = `https://api.github.com/${githubPath}`
+
+  try {
+    // Forward the request to GitHub API
+    const headers: Record<string, string> = {
+      Authorization: `Bearer ${githubToken}`,
+      Accept: 'application/vnd.github+json',
+      'X-GitHub-Api-Version': '2022-11-28',
+    }
+
+    // Forward Content-Type for write operations
+    const contentType = request.headers.get('content-type')
+    if (contentType) {
+      headers['Content-Type'] = contentType
+    }
+
+    const body =
+      request.method !== 'GET' && request.method !== 'HEAD'
+        ? await request.text()
+        : undefined
+
+    const response = await fetch(githubUrl, {
+      method: request.method,
+      headers,
+      body,
+    })
+
+    // Forward response with rate limit headers
+    const responseHeaders = new Headers()
+    responseHeaders.set('Content-Type', response.headers.get('content-type') ?? 'application/json')
+
+    const rateLimitHeaders = [
+      'x-ratelimit-limit',
+      'x-ratelimit-remaining',
+      'x-ratelimit-reset',
+    ]
+    for (const header of rateLimitHeaders) {
+      const value = response.headers.get(header)
+      if (value) responseHeaders.set(header, value)
+    }
+
+    // Forward ETag for caching
+    const etag = response.headers.get('etag')
+    if (etag) responseHeaders.set('etag', etag)
+
+    return new Response(await response.text(), {
+      status: response.status,
+      headers: responseHeaders,
+    })
+  } catch (error) {
+    console.error('[setzkasten] GitHub proxy error:', error)
+    return new Response('GitHub API request failed', { status: 502 })
+  }
+}

package/src/api-routes/pages.ts

@@ -0,0 +1,17 @@
+import type { APIRoute } from 'astro'
+
+/**
+ * Returns the list of pages detected at build time.
+ * The pages are scanned from src/pages/ by the integration hook
+ * and injected into globalThis.__SETZKASTEN_PAGES__.
+ *
+ * GET /api/setzkasten/pages
+ */
+export const GET: APIRoute = async () => {
+  const pages = (globalThis as Record<string, unknown>).__SETZKASTEN_PAGES__ ?? []
+
+  return new Response(JSON.stringify({ pages }), {
+    status: 200,
+    headers: { 'Content-Type': 'application/json' },
+  })
+}

package/src/draft-store.ts

@@ -0,0 +1,61 @@
+// ---------------------------------------------------------------------------
+// In-memory draft store for Live SSR Preview
+// Stores draft section content keyed by session ID.
+// Used by the preview middleware to inject draft data into getSection().
+// ---------------------------------------------------------------------------
+
+interface DraftEntry {
+  values: Record<string, unknown>
+  updatedAt: number
+}
+
+type SessionDrafts = Map<string, DraftEntry>
+
+const store = new Map<string, SessionDrafts>()
+
+// Auto-cleanup stale sessions after 30 minutes
+const MAX_AGE_MS = 30 * 60 * 1000
+
+export function setDraft(
+  sessionId: string,
+  sectionKey: string,
+  values: Record<string, unknown>,
+): void {
+  if (!store.has(sessionId)) store.set(sessionId, new Map())
+  store.get(sessionId)!.set(sectionKey, { values, updatedAt: Date.now() })
+  cleanup()
+}
+
+export function getDrafts(
+  sessionId: string,
+): Record<string, Record<string, unknown>> | null {
+  const drafts = store.get(sessionId)
+  if (!drafts || drafts.size === 0) return null
+  const result: Record<string, Record<string, unknown>> = {}
+  for (const [key, entry] of drafts) {
+    result[key] = entry.values
+  }
+  return result
+}
+
+export function clearDraft(sessionId: string, sectionKey?: string): void {
+  if (sectionKey) {
+    store.get(sessionId)?.delete(sectionKey)
+  } else {
+    store.delete(sessionId)
+  }
+}
+
+/** Remove sessions that haven't been updated in MAX_AGE_MS */
+function cleanup(): void {
+  const now = Date.now()
+  for (const [sessionId, drafts] of store) {
+    let newest = 0
+    for (const entry of drafts.values()) {
+      if (entry.updatedAt > newest) newest = entry.updatedAt
+    }
+    if (now - newest > MAX_AGE_MS) {
+      store.delete(sessionId)
+    }
+  }
+}

package/src/env.d.ts

@@ -0,0 +1,7 @@
+interface ImportMeta {
+  readonly env: Record<string, string | undefined> & {
+    readonly PROD: boolean
+    readonly DEV: boolean
+    readonly MODE: string
+  }
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+/**
+ * @setzkasten-cms/astro – Astro Integration
+ *
+ * Composition root that wires all adapters together:
+ * - Astro integration hook to mount the admin SPA under /admin
+ * - API routes for auth callbacks and GitHub proxy
+ * - Preview middleware for live SSR preview (draft-aware rendering)
+ */
+
+export { setzkasten as default, setzkasten } from './integration'
+export type { SetzKastenIntegrationOptions } from './integration'

package/src/integration.ts

@@ -0,0 +1,378 @@
+import { resolve, dirname, join } from 'node:path'
+import { existsSync, readFileSync, readdirSync } from 'node:fs'
+import type { AstroIntegration } from 'astro'
+import type { SetzKastenConfig } from '@setzkasten-cms/core'
+
+export interface SetzKastenIntegrationOptions {
+  /** Base path for the admin UI (default: '/admin') */
+  adminPath?: string
+  /** Full CMS config (products, sections, collections, theme) */
+  config?: SetzKastenConfig
+  /** GitHub repository for content storage */
+  storage?: {
+    owner: string
+    repo: string
+    branch?: string
+    contentPath?: string
+    /** Path to public/images in the repo (default: 'public/images'). For monorepos e.g. 'apps/website/public/images' */
+    assetsPath?: string
+  }
+  /** GitHub OAuth config */
+  github?: {
+    clientId: string
+    clientSecret: string
+  }
+  /** Google OAuth config */
+  google?: {
+    clientId: string
+    clientSecret: string
+  }
+  /** Allowed email addresses for login */
+  allowedEmails?: string[]
+}
+
+/**
+ * Astro integration that mounts the Setzkasten admin SPA.
+ *
+ * Usage in astro.config.mjs:
+ * ```js
+ * import setzkasten from '@setzkasten-cms/astro'
+ * export default defineConfig({
+ *   integrations: [setzkasten({ adminPath: '/admin' })],
+ * })
+ * ```
+ */
+export function setzkasten(
+  options: SetzKastenIntegrationOptions = {},
+): AstroIntegration {
+  const adminPath = options.adminPath ?? '/admin'
+
+  return {
+    name: 'setzkasten',
+    hooks: {
+      'astro:config:setup': ({ injectRoute, injectScript, updateConfig, config, addMiddleware }) => {
+        const contentPath = options.storage?.contentPath ?? 'content'
+        const projectRoot = config.root?.pathname ?? process.cwd()
+        // Resolve content dir relative to git/monorepo root (not Astro project root)
+        const repoRoot = findRepoRoot(projectRoot)
+        const contentDir = resolve(repoRoot, contentPath)
+
+        // Virtual module: setzkasten:content
+        updateConfig({
+          vite: {
+            plugins: [virtualContentPlugin(contentDir) as any],
+          },
+        })
+        // Mount the admin SPA catch-all route
+        injectRoute({
+          pattern: `${adminPath}/[...path]`,
+          entrypoint: '@setzkasten-cms/astro/admin-page',
+          prerender: false,
+        })
+
+        // Auth routes
+        injectRoute({
+          pattern: '/api/setzkasten/auth/login',
+          entrypoint: '@setzkasten-cms/astro/auth-login',
+          prerender: false,
+        })
+
+        injectRoute({
+          pattern: '/api/setzkasten/auth/callback',
+          entrypoint: '@setzkasten-cms/astro/auth-callback',
+          prerender: false,
+        })
+
+        injectRoute({
+          pattern: '/api/setzkasten/auth/logout',
+          entrypoint: '@setzkasten-cms/astro/auth-logout',
+          prerender: false,
+        })
+
+        injectRoute({
+          pattern: '/api/setzkasten/auth/session',
+          entrypoint: '@setzkasten-cms/astro/auth-session',
+          prerender: false,
+        })
+
+        // GitHub proxy API route
+        injectRoute({
+          pattern: '/api/setzkasten/github/[...path]',
+          entrypoint: '@setzkasten-cms/astro/github-proxy',
+          prerender: false,
+        })
+
+        // Asset proxy (serves images from private GitHub repo)
+        injectRoute({
+          pattern: '/api/setzkasten/asset/[...path]',
+          entrypoint: '@setzkasten-cms/astro/asset-proxy',
+          prerender: false,
+        })
+
+        // Config API route
+        injectRoute({
+          pattern: '/api/setzkasten/config',
+          entrypoint: '@setzkasten-cms/astro/config',
+          prerender: false,
+        })
+
+        // Draft API route (for Live SSR Preview)
+        injectRoute({
+          pattern: '/api/setzkasten/draft',
+          entrypoint: '@setzkasten-cms/astro/draft',
+          prerender: false,
+        })
+
+        // Pages API route (returns detected pages)
+        injectRoute({
+          pattern: '/api/setzkasten/pages',
+          entrypoint: '@setzkasten-cms/astro/pages',
+          prerender: false,
+        })
+
+        // Preview middleware (intercepts ?_sk_preview for draft-aware SSR)
+        addMiddleware({
+          entrypoint: '@setzkasten-cms/astro/preview-middleware',
+          order: 'pre',
+        })
+
+        // Inject minimal config for SSR pages (auth detection + storage)
+        injectScript(
+          'page-ssr',
+          `globalThis.__SETZKASTEN_CONFIG__ = ${JSON.stringify({
+            adminPath,
+            hasGitHub: !!options.github,
+            hasGoogle: !!options.google,
+            storage: options.storage ? {
+              owner: options.storage.owner,
+              repo: options.storage.repo,
+              branch: options.storage.branch ?? 'main',
+              contentPath: options.storage.contentPath ?? 'content',
+              assetsPath: options.storage.assetsPath ?? 'public/images',
+            } : undefined,
+          })}`,
+        )
+
+        // Scan available pages and inject for the pages API
+        const pagesDir = resolve(projectRoot, 'src/pages')
+        const detectedPages = scanPages(pagesDir, contentDir, adminPath)
+        injectScript(
+          'page-ssr',
+          `globalThis.__SETZKASTEN_PAGES__ = ${JSON.stringify(detectedPages)}`,
+        )
+
+        // Inject full CMS config for the config API route
+        if (options.config) {
+          injectScript(
+            'page-ssr',
+            `globalThis.__SETZKASTEN_FULL_CONFIG__ = ${JSON.stringify(options.config)}`,
+          )
+        }
+      },
+
+      'astro:config:done': ({ config }) => {
+        // Verify an adapter is configured (needed for SSR routes)
+        if (!config.adapter) {
+          console.warn(
+            '[setzkasten] Warning: No adapter detected. Setzkasten requires an SSR adapter (e.g. @astrojs/vercel) for API routes.',
+          )
+        }
+      },
+    },
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+interface PageInfo {
+  /** URL path, e.g. '/' or '/docs' or '/docs/architecture' */
+  path: string
+  /** Page key for config file lookup, e.g. 'index' or 'docs' or 'docs/architecture' */
+  pageKey: string
+  /** Human-readable label */
+  label: string
+  /** Whether a page config file exists (content/pages/_<key>.json) */
+  hasConfig: boolean
+}
+
+function scanPages(pagesDir: string, contentDir: string, adminPath: string): PageInfo[] {
+  if (!existsSync(pagesDir)) return []
+
+  const pages: PageInfo[] = []
+
+  function walk(dir: string, prefix: string) {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isDirectory()) {
+        // Skip admin and api directories
+        const dirName = entry.name
+        if (dirName === 'api' || `/${prefix}${dirName}`.startsWith(adminPath)) continue
+        walk(join(dir, dirName), `${prefix}${dirName}/`)
+      } else if (entry.name.endsWith('.astro')) {
+        const name = entry.name.replace(/\.astro$/, '')
+
+        // Skip catch-all routes, preview page
+        if (name.includes('[') || name === 'preview') continue
+
+        // Convert to URL path and page key
+        const isIndex = name === 'index'
+        const urlPath = isIndex
+          ? prefix ? `/${prefix.replace(/\/$/, '')}` : '/'
+          : `/${prefix}${name}`
+        const pageKey = isIndex
+          ? prefix ? prefix.replace(/\/$/, '') : 'index'
+          : `${prefix}${name}`
+
+        // Check if page config exists
+        const configKey = '_' + pageKey.replace(/\//g, '--')
+        const hasConfig = existsSync(join(contentDir, 'pages', `${configKey}.json`))
+
+        pages.push({
+          path: urlPath,
+          pageKey,
+          label: pageKey === 'index' ? 'Startseite' : pageKey,
+          hasConfig,
+        })
+      }
+    }
+  }
+
+  walk(pagesDir, '')
+  // Sort: index first, then alphabetically
+  pages.sort((a, b) => {
+    if (a.pageKey === 'index') return -1
+    if (b.pageKey === 'index') return 1
+    return a.pageKey.localeCompare(b.pageKey)
+  })
+
+  return pages
+}
+
+function findRepoRoot(startDir: string): string {
+  let dir = startDir
+  for (let i = 0; i < 10; i++) {
+    if (existsSync(join(dir, '.git')) || existsSync(join(dir, 'pnpm-workspace.yaml'))) {
+      return dir
+    }
+    const parent = dirname(dir)
+    if (parent === dir) break
+    dir = parent
+  }
+  return startDir // fallback: use project root
+}
+
+// ---------------------------------------------------------------------------
+// Virtual Module: setzkasten:content
+// ---------------------------------------------------------------------------
+
+const VIRTUAL_ID = 'setzkasten:content'
+const RESOLVED_ID = '\0' + VIRTUAL_ID
+
+function virtualContentPlugin(contentDir: string) {
+  // Read all content at build time and embed as static data.
+  // This avoids readFileSync at runtime which fails on Vercel serverless.
+  function readJsonDir(dir: string): Record<string, unknown> {
+    const result: Record<string, unknown> = {}
+    if (!existsSync(dir)) return result
+    for (const f of readdirSync(dir)) {
+      if (!f.endsWith('.json')) continue
+      try {
+        result[f.replace(/\.json$/, '')] = JSON.parse(readFileSync(join(dir, f), 'utf-8'))
+      } catch { /* skip invalid JSON */ }
+    }
+    return result
+  }
+
+  // Scan all collection directories (skip _sections and pages which are handled separately)
+  function readCollections(baseDir: string): Record<string, unknown[]> {
+    const result: Record<string, unknown[]> = {}
+    if (!existsSync(baseDir)) return result
+    for (const entry of readdirSync(baseDir, { withFileTypes: true })) {
+      if (!entry.isDirectory() || entry.name === '_sections' || entry.name === 'pages') continue
+      const items: unknown[] = []
+      const dir = join(baseDir, entry.name)
+      for (const f of readdirSync(dir)) {
+        if (!f.endsWith('.json')) continue
+        try {
+          items.push({
+            slug: f.replace(/\.json$/, ''),
+            ...JSON.parse(readFileSync(join(dir, f), 'utf-8')) as Record<string, unknown>,
+          })
+        } catch { /* skip */ }
+      }
+      result[entry.name] = items
+    }
+    return result
+  }
+
+  return {
+    name: 'setzkasten:content',
+    resolveId(id: string) {
+      if (id === VIRTUAL_ID) return RESOLVED_ID
+    },
+    load(id: string) {
+      if (id !== RESOLVED_ID) return
+
+      // Embed content data at build time
+      const sections = readJsonDir(join(contentDir, '_sections'))
+      const pages = readJsonDir(join(contentDir, 'pages'))
+      const collections = readCollections(contentDir)
+
+      return `
+// Content data embedded at build time from: ${contentDir}
+const SECTIONS = ${JSON.stringify(sections)};
+const PAGES = ${JSON.stringify(pages)};
+const COLLECTIONS = ${JSON.stringify(collections)};
+
+// ---------------------------------------------------------------------------
+// Draft-aware getSection: checks AsyncLocalStorage for preview drafts first.
+// The ALS is populated by the preview middleware for ?_sk_preview requests.
+// ---------------------------------------------------------------------------
+
+function _getDraft(key) {
+  try {
+    var als = globalThis[Symbol.for('setzkasten.preview.als')]
+    var drafts = als?.getStore?.()
+    return drafts?.[key] ?? null
+  } catch {
+    return null
+  }
+}
+
+export function getSection(key) {
+  var draft = _getDraft(key)
+  if (draft) return draft
+  return SECTIONS[key] ? JSON.parse(JSON.stringify(SECTIONS[key])) : null
+}
+
+export function getCollection(key) {
+  return COLLECTIONS[key] ? JSON.parse(JSON.stringify(COLLECTIONS[key])) : []
+}
+
+export function getCollectionEntry(collection, slug) {
+  var items = COLLECTIONS[collection]
+  if (!items) return null
+  var entry = items.find(function(e) { return e.slug === slug })
+  return entry ? JSON.parse(JSON.stringify(entry)) : null
+}
+
+// ---------------------------------------------------------------------------
+// Page configuration: section ordering, enable/disable
+// ---------------------------------------------------------------------------
+
+export function getPage(pageKey, opts) {
+  pageKey = pageKey || 'index'
+  var config = PAGES['_' + pageKey]
+  if (!config) return null
+  config = JSON.parse(JSON.stringify(config))
+  var includeDisabled = opts && opts.includeDisabled
+  var sections = (config.sections || [])
+    .filter(function(s) { return includeDisabled || s.enabled !== false })
+    .map(function(s) { return { key: s.key, data: getSection(s.key), enabled: s.enabled !== false } })
+  return { sections: sections, config: config }
+}
+`
+    },
+  }
+}