@leadcms/sdk 1.2.85-pre

package/dist/scripts/leadcms-helpers.mjs

@@ -0,0 +1,208 @@
+import fs from "fs/promises"
+import path from "path"
+import yaml from "js-yaml"
+import axios from "axios"
+
+import { existsSync, readFileSync } from "fs"
+
+// Simple configuration loader for the scripts
+function loadConfig() {
+  const possiblePaths = [
+    "leadcms.config.json",
+    ".leadcmsrc.json",
+    ".leadcmsrc"
+  ];
+
+  for (const configPath of possiblePaths) {
+    try {
+      if (existsSync(configPath)) {
+        const content = readFileSync(configPath, "utf-8");
+        const config = JSON.parse(content);
+        console.log(`[LeadCMS] Loaded configuration from: ${configPath}`);
+        return config;
+      }
+    } catch (error) {
+      // Continue to next config file
+    }
+  }
+
+  return {};
+}
+
+const config = loadConfig();
+
+// Use configuration with environment variable fallbacks
+export const leadCMSUrl = config.url || process.env.LEADCMS_URL || process.env.NEXT_PUBLIC_LEADCMS_URL
+export const leadCMSApiKey = config.apiKey || process.env.LEADCMS_API_KEY
+export const defaultLanguage = config.defaultLanguage || process.env.LEADCMS_DEFAULT_LANGUAGE || process.env.NEXT_PUBLIC_LEADCMS_DEFAULT_LANGUAGE || "en"
+export const CONTENT_DIR = path.resolve(config.contentDir || ".leadcms/content")
+export const MEDIA_DIR = path.resolve(config.mediaDir || "public/media")
+
+// Fetch content types dynamically from LeadCMS API to build typeMap
+// Content types are automatically detected and don't need to be configured
+export async function fetchContentTypes() {
+  console.log(`[LeadCMS] Fetching content types from API...`)
+  const url = new URL("/api/content-types", leadCMSUrl)
+  url.searchParams.set("filter[limit]", "100")
+  try {
+    const res = await axios.get(url.toString(), {
+      headers: { Authorization: `Bearer ${leadCMSApiKey}` },
+    })
+    const types = res.data
+    const typeMap = {}
+    for (const t of types) {
+      typeMap[t.uid] = t.format
+    }
+    console.log(`[LeadCMS] Detected ${Object.keys(typeMap).length} content types:`, Object.keys(typeMap).join(', '))
+    return typeMap
+  } catch (error) {
+    console.error(`[LeadCMS] Failed to fetch content types:`, error.message)
+    return {}
+  }
+}
+
+export function extractMediaUrlsFromContent(content) {
+  console.log(`[LeadCMS] Extracting media URLs from content: ${content}`)
+  const urls = new Set()
+  const body = content.body || ""
+  const regex = /["'\(](\/api\/media\/[^"'\)\s]+)/g
+  let match
+  while ((match = regex.exec(body))) {
+    urls.add(match[1])
+  }
+  if (content.coverImageUrl && content.coverImageUrl.startsWith("/api/media/")) {
+    urls.add(content.coverImageUrl)
+  }
+
+  return Array.from(urls)
+}
+
+// Direct media download without meta.json dependency
+export async function downloadMediaFileDirect(mediaUrl, destPath, leadCMSUrl, leadCMSApiKey) {
+  await fs.mkdir(path.dirname(destPath), { recursive: true })
+
+  const fullUrl = mediaUrl.startsWith("http") ? mediaUrl : leadCMSUrl.replace(/\/$/, "") + mediaUrl
+  const headers = { Authorization: `Bearer ${leadCMSApiKey}` }
+
+  try {
+    const res = await axios.get(fullUrl, {
+      responseType: "arraybuffer",
+      headers,
+      validateStatus: (status) =>
+        (status >= 200 && status < 300) || status === 404,
+    })
+
+    if (res.status === 404) {
+      // Remove file if not found on server
+      try {
+        await fs.unlink(destPath)
+        console.log(`Deleted missing file: ${destPath}`)
+      } catch {}
+      return false
+    }
+
+    await fs.writeFile(destPath, res.data)
+    return true
+  } catch (err) {
+    console.error(`Failed to download ${mediaUrl}:`, err.message)
+    throw err
+  }
+}
+
+// Old downloadMediaFile function removed - replaced with downloadMediaFileDirect
+// No longer using meta.json for media file caching, using sync API instead
+
+export function buildFrontmatter(content) {
+  const omit = ["body"]
+  const fm = Object.fromEntries(
+    Object.entries(content).filter(([k, v]) => !omit.includes(k) && v !== undefined && v !== null)
+  )
+  return `---\n${yaml.dump(fm)}---`
+}
+
+export function replaceApiMediaPaths(obj) {
+  if (typeof obj === "string") {
+    return obj.replace(/\/api\/media\//g, "/media/")
+  } else if (Array.isArray(obj)) {
+    return obj.map(replaceApiMediaPaths)
+  } else if (typeof obj === "object" && obj !== null) {
+    const out = {}
+    for (const [k, v] of Object.entries(obj)) {
+      out[k] = replaceApiMediaPaths(v)
+    }
+    return out
+  }
+  return obj
+}
+
+export async function saveContentFile({ content, typeMap, contentDir, previewSlug }) {
+  if (!content || typeof content !== "object") {
+    console.warn("[LeadCMS] Skipping undefined or invalid content:", content)
+    return
+  }
+  const slug = previewSlug || content.slug
+  if (!slug) {
+    console.warn("[LeadCMS] Skipping content with missing slug:", content)
+    return
+  }
+  const contentType = typeMap
+    ? typeMap[content.type]
+    : content.format || (content.body ? "MDX" : "JSON")
+  const cleanedContent = replaceApiMediaPaths(content)
+
+  // Inject draft: true when previewSlug is provided (indicates draft content)
+  if (previewSlug) {
+    cleanedContent.draft = true
+  }
+
+  // Determine the target directory based on language
+  let targetContentDir = contentDir
+  const contentLanguage = content.language || defaultLanguage
+
+  if (contentLanguage !== defaultLanguage) {
+    // Save non-default language content in language-specific folder
+    targetContentDir = path.join(contentDir, contentLanguage)
+  }
+
+  if (contentType === "MDX") {
+    const filePath = path.join(targetContentDir, `${slug}.mdx`)
+    let body = cleanedContent.body || ""
+    let bodyFrontmatter = {}
+    let bodyContent = body
+    // Extract frontmatter from body if present
+    const fmMatch = body.match(/^---\n([\s\S]*?)\n---\n?/)
+    if (fmMatch) {
+      try {
+        bodyFrontmatter = yaml.load(fmMatch[1]) || {}
+      } catch (error) {
+        console.warn(`[LeadCMS] Failed to parse frontmatter in body for ${slug}:`, error.message)
+      }
+      bodyContent = body.slice(fmMatch[0].length)
+    }
+
+    // Merge frontmatters, body frontmatter takes precedence over content metadata
+    const mergedFrontmatter = { ...cleanedContent, ...bodyFrontmatter }
+    delete mergedFrontmatter.body
+    const frontmatterStr = buildFrontmatter(mergedFrontmatter)
+    const mdx = `${frontmatterStr}\n\n${bodyContent.replace(/\/api\/media\//g, "/media/").trim()}\n`
+    await fs.mkdir(path.dirname(filePath), { recursive: true })
+    await fs.writeFile(filePath, mdx, "utf8")
+    return filePath
+  } else {
+    let bodyObj = {}
+    try {
+      bodyObj = cleanedContent.body ? JSON.parse(cleanedContent.body) : {}
+    } catch {
+      bodyObj = {}
+    }
+    const merged = { ...bodyObj }
+    for (const [k, v] of Object.entries(cleanedContent)) {
+      if (k !== "body") merged[k] = v
+    }
+    const filePath = path.join(targetContentDir, `${slug}.json`)
+    const jsonStr = JSON.stringify(merged, null, 2)
+    await fs.mkdir(path.dirname(filePath), { recursive: true })
+    await fs.writeFile(filePath, jsonStr, "utf8")
+    return filePath
+  }
+}

package/dist/scripts/sse-watcher.mjs

@@ -0,0 +1,325 @@
+import "dotenv/config"
+import { EventSource } from "eventsource"
+import { exec } from "child_process"
+import {
+  saveContentFile,
+  leadCMSUrl,
+  leadCMSApiKey,
+  defaultLanguage,
+  CONTENT_DIR,
+} from "./leadcms-helpers.mjs"
+import { fetchContentTypes } from "./leadcms-helpers.mjs"
+
+// Log environment configuration for debugging
+console.log(`[SSE ENV] LeadCMS URL: ${leadCMSUrl}`)
+console.log(
+  `[SSE ENV] LeadCMS API Key: ${leadCMSApiKey ? `${leadCMSApiKey.substring(0, 8)}...` : "NOT_SET"}`
+)
+console.log(`[SSE ENV] Default Language: ${defaultLanguage}`)
+console.log(`[SSE ENV] Content Dir: ${CONTENT_DIR}`)
+
+function buildSSEUrl() {
+  console.log(`[SSE URL] Building SSE URL with base: ${leadCMSUrl}`)
+  const url = new URL("/api/sse/stream", leadCMSUrl)
+  url.searchParams.set("entities", "Content")
+  url.searchParams.set("includeContent", "true")
+  url.searchParams.set("includeLiveDrafts", "true")
+  const finalUrl = url.toString()
+  console.log(`[SSE URL] Final SSE URL: ${finalUrl}`)
+  return finalUrl
+}
+
+async function startSSEWatcher() {
+  console.log(`[SSE] Starting SSE watcher...`)
+  const typeMap = await fetchContentTypes()
+  const sseUrl = buildSSEUrl()
+  const eventSourceOptions = {}
+
+  if (leadCMSApiKey) {
+    console.log(`[SSE] Using API key for authentication`)
+    eventSourceOptions.fetch = (input, init) => {
+      console.log(`[SSE FETCH] Making authenticated request to: ${input}`)
+      console.log(
+        `[SSE FETCH] Headers:`,
+        JSON.stringify(
+          {
+            ...init?.headers,
+            Authorization: `Bearer ${leadCMSApiKey.substring(0, 8)}...`,
+          },
+          null,
+          2
+        )
+      )
+
+      return fetch(input, {
+        ...init,
+        headers: {
+          ...init?.headers,
+          Authorization: `Bearer ${leadCMSApiKey}`,
+        },
+      })
+        .then((response) => {
+          console.log(`[SSE FETCH] Response status: ${response.status} ${response.statusText}`)
+          console.log(
+            `[SSE FETCH] Response headers:`,
+            JSON.stringify(Object.fromEntries(response.headers.entries()), null, 2)
+          )
+          if (!response.ok) {
+            console.error(`[SSE FETCH] Failed response: ${response.status} ${response.statusText}`)
+          }
+          return response
+        })
+        .catch((error) => {
+          console.error(`[SSE FETCH] Fetch error:`, error.message)
+          throw error
+        })
+    }
+  } else {
+    console.warn(`[SSE] No API key provided - attempting unauthenticated connection`)
+  }
+
+  console.log(`[SSE] Connecting to: ${sseUrl}`)
+  console.log(`[SSE] Event source options:`, JSON.stringify(eventSourceOptions, null, 2))
+  const es = new EventSource(sseUrl, eventSourceOptions)
+
+  es.onopen = () => {
+    console.log("[SSE] Connection opened successfully")
+  }
+
+  es.onmessage = (event) => {
+    console.log(`[SSE] Received message:`, event.data)
+    try {
+      const data = JSON.parse(event.data)
+      console.log(`[SSE] Parsed message data:`, JSON.stringify(data, null, 2))
+
+      if (data.entityType === "Content") {
+        console.log(`[SSE] Content message - Operation: ${data.operation}`)
+        console.log(`[SSE] Content change detected - triggering full fetch`)
+        exec("npm run fetch:leadcms", (err, stdout, stderr) => {
+          if (err) {
+            console.error("[SSE] fetch:leadcms failed:", err.message)
+            console.error("[SSE] fetch:leadcms stderr:", stderr)
+            return
+          }
+          console.log("[SSE] fetch:leadcms completed successfully")
+          console.log("[SSE] fetch:leadcms output:\n", stdout)
+          if (stderr) console.warn("[SSE] fetch:leadcms stderr:", stderr)
+        })
+      } else {
+        console.log(`[SSE] Non-content message - Entity type: ${data.entityType}`)
+      }
+    } catch (e) {
+      console.warn("[SSE] Failed to parse SSE message:", e.message)
+      console.warn("[SSE] Raw event data:", event.data)
+    }
+  }
+
+  es.addEventListener("connected", (event) => {
+    console.log(`[SSE] Received 'connected' event:`, event.data)
+    try {
+      const data = JSON.parse(event.data)
+      console.log(
+        `[SSE] Connected successfully - Client ID: ${data.clientId}, Starting change log ID: ${data.startingChangeLogId}`
+      )
+    } catch (e) {
+      console.warn("[SSE] Failed to parse connected event:", e.message)
+      console.warn("[SSE] Raw connected event data:", event.data)
+    }
+  })
+
+  es.addEventListener("heartbeat", (event) => {
+    console.log(`[SSE] Received heartbeat:`, event.data)
+    try {
+      const data = JSON.parse(event.data)
+      console.log(`[SSE] Heartbeat at ${data.timestamp}`)
+    } catch (e) {
+      console.warn("[SSE] Failed to parse heartbeat event:", e.message)
+      console.warn("[SSE] Raw heartbeat event data:", event.data)
+    }
+  })
+
+  es.addEventListener("draft-updated", (event) => {
+    console.log(`[SSE] Received 'draft-updated' event:`, event.data)
+    try {
+      const data = JSON.parse(event.data)
+      console.log(`[SSE] Draft updated data:`, JSON.stringify(data, null, 2))
+
+      if (data.createdById && data.data) {
+        console.log(`[SSE] Processing draft update for user: ${data.createdById}`)
+        let contentData
+        try {
+          contentData = typeof data.data === "string" ? JSON.parse(data.data) : data.data
+          console.log(`[SSE] Draft content data:`, JSON.stringify(contentData, null, 2))
+        } catch (e) {
+          console.warn("[SSE] Failed to parse draft content data:", e.message)
+          console.warn("[SSE] Raw data:", data.data)
+          return
+        }
+
+        // Determine content type for draft handling
+        let contentType = undefined
+        if (contentData && contentData.type && typeMap && typeMap[contentData.type]) {
+          contentType = typeMap[contentData.type]
+        }
+
+        console.log(`[SSE] Draft updated - triggering full fetch`)
+        exec("npm run fetch:leadcms", (err, stdout, stderr) => {
+          if (err) {
+            console.error("[SSE] fetch:leadcms failed:", err.message)
+            console.error("[SSE] fetch:leadcms stderr:", stderr)
+            return
+          }
+          console.log("[SSE] fetch:leadcms completed successfully")
+          console.log("[SSE] fetch:leadcms output:\n", stdout)
+          if (stderr) console.warn("[SSE] fetch:leadcms stderr:", stderr)
+        })
+
+        if (contentType === "MDX" || contentType === "JSON") {
+          if (contentData && typeof contentData === "object") {
+            const previewSlug = `${contentData.slug}-${data.createdById}`
+            console.log(`[SSE] Saving draft content file for preview: ${previewSlug}`)
+            ;(async () => {
+              try {
+                await saveContentFile({
+                  content: contentData,
+                  typeMap,
+                  contentDir: CONTENT_DIR,
+                  previewSlug: previewSlug,
+                })
+                console.log(`[SSE] Saved draft preview for ${previewSlug}`)
+              } catch (error) {
+                console.error(`[SSE] Error processing draft update:`, error.message)
+              }
+            })()
+          }
+        } else {
+          console.log(`[SSE] Draft is not MDX or JSON (type: ${contentType}), skipping file save.`)
+        }
+      }
+    } catch (e) {
+      console.warn("[SSE] Failed to parse draft-updated event:", e.message)
+      console.warn("[SSE] Raw draft-updated event data:", event.data)
+    }
+  })
+
+  // Handle legacy DraftModified messages for backward compatibility
+  es.addEventListener("message", (event) => {
+    try {
+      const data = JSON.parse(event.data)
+
+      // Only handle DraftModified operations here for backward compatibility
+      if (data.entityType === "Content" && data.operation === "DraftModified" && data.createdById && data.data) {
+        console.log(`[SSE] Received legacy 'DraftModified' message for user: ${data.createdById}`)
+        let contentData
+        try {
+          contentData = typeof data.data === "string" ? JSON.parse(data.data) : data.data
+          console.log(`[SSE] Legacy draft content data:`, JSON.stringify(contentData, null, 2))
+        } catch (e) {
+          console.warn("[SSE] Failed to parse legacy draft content data:", e.message)
+          console.warn("[SSE] Raw data:", data.data)
+          return
+        }
+
+        // Determine content type for legacy draft handling
+        let contentType = undefined
+        if (contentData && contentData.type && typeMap && typeMap[contentData.type]) {
+          contentType = typeMap[contentData.type]
+        }
+
+        console.log(`[SSE] Legacy draft modified - triggering full fetch`)
+        exec("npm run fetch:leadcms", (err, stdout, stderr) => {
+          if (err) {
+            console.error("[SSE] fetch:leadcms failed:", err.message)
+            console.error("[SSE] fetch:leadcms stderr:", stderr)
+            return
+          }
+          console.log("[SSE] fetch:leadcms completed successfully")
+          console.log("[SSE] fetch:leadcms output:\n", stdout)
+          if (stderr) console.warn("[SSE] fetch:leadcms stderr:", stderr)
+        })
+
+        if (contentType === "MDX" || contentType === "JSON") {
+          if (contentData && typeof contentData === "object") {
+            const previewSlug = `${contentData.slug}-${data.createdById}`
+            console.log(`[SSE] Saving legacy draft content file for preview: ${previewSlug}`)
+            ;(async () => {
+              try {
+                await saveContentFile({
+                  content: contentData,
+                  typeMap,
+                  contentDir: CONTENT_DIR,
+                  previewSlug: previewSlug,
+                })
+                console.log(`[SSE] Saved legacy draft preview for ${previewSlug}`)
+              } catch (error) {
+                console.error(`[SSE] Error processing legacy draft modification:`, error.message)
+              }
+            })()
+          }
+        } else {
+          console.log(`[SSE] Legacy draft is not MDX or JSON (type: ${contentType}), skipping file save.`)
+        }
+      }
+    } catch {
+      // Silently ignore parse errors for non-JSON messages
+    }
+  })
+
+  es.addEventListener("content-updated", (event) => {
+    console.log(`[SSE] Received 'content-updated' event:`, event.data)
+    try {
+      const data = JSON.parse(event.data)
+      console.log(`[SSE] Content updated data:`, JSON.stringify(data, null, 2))
+
+      console.log(`[SSE] Content updated - triggering full fetch`)
+      exec("npm run fetch:leadcms", (err, stdout, stderr) => {
+        if (err) {
+          console.error("[SSE] fetch:leadcms failed:", err.message)
+          console.error("[SSE] fetch:leadcms stderr:", stderr)
+          return
+        }
+        console.log("[SSE] fetch:leadcms completed successfully")
+        console.log("[SSE] fetch:leadcms output:\n", stdout)
+        if (stderr) console.warn("[SSE] fetch:leadcms stderr:", stderr)
+      })
+    } catch (e) {
+      console.warn("[SSE] Failed to parse content-updated event:", e.message)
+      console.warn("[SSE] Raw content-updated event data:", event.data)
+    }
+  })
+
+  es.onerror = (err) => {
+    console.error("[SSE] Connection error occurred:", {
+      type: err.type,
+      message: err.message,
+      code: err.code,
+      timestamp: new Date().toISOString(),
+      readyState: es.readyState,
+      url: es.url,
+    })
+
+    // Log specific error types
+    if (err.code === 401) {
+      console.error("[SSE] Authentication failed (401) - check your LEADCMS_API_KEY")
+      console.error(
+        "[SSE] Current API Key (first 8 chars):",
+        leadCMSApiKey ? leadCMSApiKey.substring(0, 8) : "NOT_SET"
+      )
+    } else if (err.code === 403) {
+      console.error("[SSE] Forbidden (403) - insufficient permissions")
+    } else if (err.code === 404) {
+      console.error("[SSE] Not Found (404) - check your LEADCMS_URL and endpoint path")
+    } else if (err.code >= 500) {
+      console.error("[SSE] Server error (5xx) - LeadCMS server issue")
+    }
+
+    console.log("[SSE] Closing connection and will reconnect in 5s")
+    es.close()
+    setTimeout(() => {
+      console.log("[SSE] Attempting to reconnect...")
+      startSSEWatcher()
+    }, 5000)
+  }
+}
+
+startSSEWatcher()

package/dist/templates/docker/Dockerfile

@@ -0,0 +1,34 @@
+# LeadCMS Static Site Production Dockerfile
+# This Dockerfile serves pre-built static files using nginx
+# Works with any static site generator (Next.js, Astro, Gatsby, Nuxt, etc.)
+#
+# Usage from project root:
+# 1. Build your static site to 'out' or 'dist' directory
+# 2. docker build -t my-leadcms-site .
+# 3. docker run -p 80:80 my-leadcms-site
+
+FROM nginx:alpine
+
+# Copy pre-built static site from local 'out' folder
+# Note: Adjust the source directory based on your static site generator:
+# - Next.js: out/
+# - Astro: dist/
+# - Gatsby: public/
+# - Nuxt: dist/
+COPY out /usr/share/nginx/html
+
+# Copy nginx configuration and runtime environment injection script
+COPY nginx.conf /etc/nginx/conf.d/default.conf
+COPY scripts/inject-runtime-env.sh /app/scripts/inject-runtime-env.sh
+
+# Set appropriate permissions
+RUN chmod -R 755 /usr/share/nginx/html && chmod +x /app/scripts/inject-runtime-env.sh
+
+EXPOSE 80
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD wget --spider -q http://localhost:80 || exit 1
+
+# Start nginx with runtime environment injection
+CMD ["/bin/sh", "-c", "/app/scripts/inject-runtime-env.sh && nginx -g 'daemon off;'"]

package/dist/templates/docker/nginx.conf

@@ -0,0 +1,70 @@
+# LeadCMS Static Site nginx Configuration
+# Optimized for serving static sites with proper caching headers
+# Works with any static site generator
+
+server {
+    listen 80;
+    server_name localhost;
+    root /usr/share/nginx/html;
+    index index.html;
+
+    # Security headers
+    add_header X-Frame-Options "SAMEORIGIN" always;
+    add_header X-Content-Type-Options "nosniff" always;
+    add_header X-XSS-Protection "1; mode=block" always;
+    add_header Referrer-Policy "strict-origin-when-cross-origin" always;
+
+    # HTML files: no cache for content freshness
+    location ~* \.html$ {
+        add_header Cache-Control "public, max-age=0, must-revalidate";
+        try_files $uri $uri/index.html =404;
+    }
+
+    # Runtime environment file: never cache
+    location = /__env.js {
+        add_header Cache-Control "no-store, no-cache, must-revalidate, proxy-revalidate, max-age=0";
+        try_files $uri =404;
+    }
+
+    # Static assets: cache forever with immutable flag
+    location ~* \.(js|css|woff2?|ttf|eot|svg|jpg|jpeg|png|avif|webp|gif|ico|pdf)$ {
+        add_header Cache-Control "public, max-age=31536000, immutable";
+        try_files $uri =404;
+    }
+
+    # JSON files (potentially dynamic content): short cache
+    location ~* \.json$ {
+        add_header Cache-Control "public, max-age=300";  # 5 minutes
+        try_files $uri =404;
+    }
+
+    # Default location: try files with index.html fallback
+    location / {
+        try_files $uri $uri/index.html =404;
+    }
+
+    # Custom error pages
+    error_page 404 /404.html;
+    error_page 500 502 503 504 /50x.html;
+
+    location = /50x.html {
+        root /usr/share/nginx/html;
+    }
+
+    # Gzip compression
+    gzip on;
+    gzip_vary on;
+    gzip_min_length 1024;
+    gzip_proxied any;
+    gzip_comp_level 6;
+    gzip_types
+        text/plain
+        text/css
+        text/xml
+        text/javascript
+        application/json
+        application/javascript
+        application/xml+rss
+        application/atom+xml
+        image/svg+xml;
+}