nca-ai-cms-astro-plugin 1.0.15 → 1.0.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nca-ai-cms-astro-plugin",
-  "version": "1.0.15",
+  "version": "1.0.17",
   "type": "module",
   "exports": {
     ".": "./src/index.ts",

package/src/api/db/download.ts

@@ -0,0 +1,35 @@
+import type { APIRoute } from 'astro';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { jsonError } from '../_utils';
+
+function getDbPath(): string {
+  const envPath = process.env.ASTRO_DATABASE_FILE;
+  if (envPath) {
+    const resolved = path.resolve(process.cwd(), envPath);
+    if (!resolved.startsWith(process.cwd())) {
+      throw new Error('Invalid database path');
+    }
+    return resolved;
+  }
+  return path.join(process.cwd(), '.astro', 'content.db');
+}
+
+export const GET: APIRoute = async () => {
+  try {
+    const dbPath = getDbPath();
+    const dbBuffer = await fs.readFile(dbPath);
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+
+    return new Response(dbBuffer, {
+      status: 200,
+      headers: {
+        'Content-Type': 'application/x-sqlite3',
+        'Content-Disposition': `attachment; filename="content-${timestamp}.db"`,
+        'Content-Length': String(dbBuffer.length),
+      },
+    });
+  } catch {
+    return jsonError('Database file not found', 404);
+  }
+};

package/src/api/db/upload.ts

@@ -0,0 +1,74 @@
+import type { APIRoute } from 'astro';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { jsonResponse, jsonError } from '../_utils';
+
+const MAX_DB_SIZE = 50 * 1024 * 1024; // 50 MB
+
+function getDbPath(): string {
+  const envPath = process.env.ASTRO_DATABASE_FILE;
+  if (envPath) {
+    const resolved = path.resolve(process.cwd(), envPath);
+    if (!resolved.startsWith(process.cwd())) {
+      throw new Error('Invalid database path');
+    }
+    return resolved;
+  }
+  return path.join(process.cwd(), '.astro', 'content.db');
+}
+
+export const POST: APIRoute = async ({ request }) => {
+  try {
+    const dbPath = getDbPath();
+    const contentType = request.headers.get('content-type') || '';
+
+    let dbBuffer: Buffer;
+
+    if (contentType.includes('multipart/form-data')) {
+      const formData = await request.formData();
+      const file = formData.get('database') as File | null;
+
+      if (!file) {
+        return jsonError('No database file provided. Use field name "database".', 400);
+      }
+
+      if (file.size > MAX_DB_SIZE) {
+        return jsonError('File too large. Maximum 50 MB.', 413);
+      }
+
+      const arrayBuffer = await file.arrayBuffer();
+      dbBuffer = Buffer.from(arrayBuffer);
+    } else if (contentType.includes('application/octet-stream')) {
+      const arrayBuffer = await request.arrayBuffer();
+      dbBuffer = Buffer.from(arrayBuffer);
+
+      if (dbBuffer.length > MAX_DB_SIZE) {
+        return jsonError('File too large. Maximum 50 MB.', 413);
+      }
+    } else {
+      return jsonError('Invalid content type. Use multipart/form-data or application/octet-stream.', 400);
+    }
+
+    // SQLite validation
+    const header = dbBuffer.subarray(0, 16).toString('utf8');
+    if (!header.startsWith('SQLite format 3')) {
+      return jsonError('Invalid file: not a SQLite database.', 400);
+    }
+
+    // Backup current DB before overwriting
+    try {
+      await fs.copyFile(dbPath, `${dbPath}.backup`);
+    } catch {
+      // No existing DB to backup
+    }
+
+    await fs.writeFile(dbPath, dbBuffer);
+
+    return jsonResponse({
+      success: true,
+      size: dbBuffer.length,
+    });
+  } catch {
+    return jsonError('Database upload failed', 500);
+  }
+};

package/src/api/generate-page.ts

@@ -0,0 +1,42 @@
+import type { APIRoute } from 'astro';
+import { z } from 'zod';
+import { ContentGenerator } from '../services/ContentGenerator';
+import { PromptService } from '../services/PromptService';
+import { getEnvVariable } from '../utils/envUtils';
+import { jsonResponse, jsonError } from './_utils';
+
+const GeneratePageSchema = z.object({
+  input: z.string().min(1, 'Input is required'),
+});
+
+export const POST: APIRoute = async ({ request }) => {
+  try {
+    const body = await request.json();
+    const parsed = GeneratePageSchema.safeParse(body);
+    if (!parsed.success) {
+      return jsonError(parsed.error.errors[0]?.message ?? 'Invalid request', 400);
+    }
+    const { input } = parsed.data;
+    const isUrl = /^https?:\/\//.test(input);
+
+    const apiKey = getEnvVariable('GOOGLE_GEMINI_API_KEY');
+    const promptService = new PromptService();
+    const generator = new ContentGenerator({ apiKey, promptService });
+    const page = isUrl
+      ? await generator.generateFromUrl(input)
+      : await generator.generateFromKeywords(input);
+
+    return jsonResponse({
+      title: page.title,
+      description: page.description,
+      content: page.content,
+      filepath: page.filepath,
+      tags: page.tags,
+      date: page.date.toISOString(),
+      ...(generator.warnings.length > 0 ? { warnings: generator.warnings } : {}),
+    });
+  } catch (error) {
+    console.error('Page generation error:', error);
+    return jsonError(error);
+  }
+};

package/src/api/pages/[id]/apply.ts

@@ -0,0 +1,61 @@
+import type { APIRoute } from 'astro';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import matter from 'gray-matter';
+import {
+  ArticleService,
+  ArticleNotFoundError,
+} from '../../../services/ArticleService';
+import { convertToWebP } from '../../../services/ImageConverter';
+import { pagesPath } from 'virtual:nca-ai-cms/config';
+import { jsonResponse, jsonError } from '../../_utils';
+
+interface ApplyRequest {
+  title?: string;
+  description?: string;
+  content?: string;
+  tags?: string[];
+  imageUrl?: string;
+  imageAlt?: string;
+}
+
+export const POST: APIRoute = async ({ params, request }) => {
+  try {
+    const slug = params.id;
+    if (!slug) return jsonError('Page ID required', 400);
+
+    const data: ApplyRequest = await request.json();
+    const service = new ArticleService(pagesPath);
+    const existingPage = await service.read(slug);
+    if (!existingPage) throw new ArticleNotFoundError(slug);
+
+    if (data.imageUrl) {
+      const heroPath = path.join(existingPage.folderPath, 'hero.webp');
+      const base64Data = data.imageUrl.replace(/^data:image\/\w+;base64,/, '');
+      await convertToWebP(base64Data, heroPath);
+
+      if (data.imageAlt) {
+        const indexPath = path.join(existingPage.folderPath, 'index.md');
+        const fileContent = await fs.readFile(indexPath, 'utf-8');
+        const { data: frontmatter, content } = matter(fileContent);
+        frontmatter.imageAlt = data.imageAlt;
+        const updatedContent = matter.stringify(content, frontmatter);
+        await fs.writeFile(indexPath, updatedContent);
+      }
+    }
+
+    if (data.content || data.title || data.description) {
+      await service.updateContent(slug, {
+        ...(data.title && { title: data.title }),
+        ...(data.description && { description: data.description }),
+        ...(data.content && { content: data.content }),
+      });
+    }
+
+    return jsonResponse({ success: true, articleId: existingPage.articleId });
+  } catch (error) {
+    if (error instanceof ArticleNotFoundError) return jsonError(error, 404);
+    console.error('Apply page changes error:', error);
+    return jsonError(error);
+  }
+};

package/src/api/pages/[id]/regenerate-image.ts

@@ -0,0 +1,35 @@
+import type { APIRoute } from 'astro';
+import {
+  ArticleService,
+  ArticleNotFoundError,
+} from '../../../services/ArticleService';
+import { ImageGenerator } from '../../../services/ImageGenerator';
+import { getEnvVariable } from '../../../utils/envUtils';
+import { pagesPath } from 'virtual:nca-ai-cms/config';
+import { jsonResponse, jsonError } from '../../_utils';
+
+export const POST: APIRoute = async ({ params }) => {
+  try {
+    const slug = params.id;
+    if (!slug) return jsonError('Page ID required', 400);
+
+    const service = new ArticleService(pagesPath);
+    const existingPage = await service.read(slug);
+    if (!existingPage) throw new ArticleNotFoundError(slug);
+
+    const apiKey = getEnvVariable('GOOGLE_GEMINI_API_KEY');
+    const generator = new ImageGenerator({ apiKey });
+    const image = await generator.generate(existingPage.title);
+
+    return jsonResponse({
+      url: image.url,
+      alt: image.alt,
+      articleId: existingPage.articleId,
+      articleTitle: existingPage.title,
+    });
+  } catch (error) {
+    if (error instanceof ArticleNotFoundError) return jsonError(error, 404);
+    console.error('Regenerate page image error:', error);
+    return jsonError(error);
+  }
+};

package/src/api/pages/[id]/regenerate-text.ts

@@ -0,0 +1,39 @@
+import type { APIRoute } from 'astro';
+import {
+  ArticleService,
+  ArticleNotFoundError,
+} from '../../../services/ArticleService';
+import { ContentGenerator } from '../../../services/ContentGenerator';
+import { PromptService } from '../../../services/PromptService';
+import { getEnvVariable } from '../../../utils/envUtils';
+import { pagesPath } from 'virtual:nca-ai-cms/config';
+import { jsonResponse, jsonError } from '../../_utils';
+
+export const POST: APIRoute = async ({ params }) => {
+  try {
+    const slug = params.id;
+    if (!slug) return jsonError('Page ID required', 400);
+
+    const service = new ArticleService(pagesPath);
+    const existingPage = await service.read(slug);
+    if (!existingPage) throw new ArticleNotFoundError(slug);
+
+    const apiKey = getEnvVariable('GOOGLE_GEMINI_API_KEY');
+    const promptService = new PromptService();
+    const generator = new ContentGenerator({ apiKey, promptService });
+    const newPage = await generator.generateFromKeywords(existingPage.title);
+
+    return jsonResponse({
+      title: newPage.title,
+      description: newPage.description,
+      content: newPage.content,
+      tags: newPage.tags,
+      originalTitle: existingPage.title,
+      articleId: existingPage.articleId,
+    });
+  } catch (error) {
+    if (error instanceof ArticleNotFoundError) return jsonError(error, 404);
+    console.error('Regenerate page text error:', error);
+    return jsonError(error);
+  }
+};

package/src/api/pages/[id].ts

@@ -0,0 +1,40 @@
+import type { APIRoute } from 'astro';
+import {
+  ArticleService,
+  ArticleNotFoundError,
+} from '../../services/ArticleService';
+import { pagesPath } from 'virtual:nca-ai-cms/config';
+import { jsonResponse, jsonError } from '../_utils';
+
+// GET /api/pages/[id] - Get page details
+export const GET: APIRoute = async ({ params }) => {
+  try {
+    const slug = params.id;
+    if (!slug) return jsonError('Page ID required', 400);
+
+    const service = new ArticleService(pagesPath);
+    const page = await service.read(slug);
+    if (!page) return jsonError('Page not found', 404);
+
+    return jsonResponse(page);
+  } catch (error) {
+    console.error('Read page error:', error);
+    return jsonError(error);
+  }
+};
+
+// DELETE /api/pages/[id] - Delete a page by slug
+export const DELETE: APIRoute = async ({ params }) => {
+  try {
+    const slug = params.id;
+    if (!slug) return jsonError('Page ID required', 400);
+
+    const service = new ArticleService(pagesPath);
+    await service.delete(slug);
+    return jsonResponse({ success: true });
+  } catch (error) {
+    if (error instanceof ArticleNotFoundError) return jsonError(error, 404);
+    console.error('Delete page error:', error);
+    return jsonError(error);
+  }
+};

package/src/api/pages/index.ts

@@ -0,0 +1,16 @@
+import type { APIRoute } from 'astro';
+import { ArticleService } from '../../services/ArticleService';
+import { pagesPath } from 'virtual:nca-ai-cms/config';
+import { jsonResponse, jsonError } from '../_utils';
+
+// GET /api/pages - List all pages
+export const GET: APIRoute = async () => {
+  try {
+    const service = new ArticleService(pagesPath);
+    const pages = await service.list();
+    return jsonResponse(pages);
+  } catch (error) {
+    console.error('List pages error:', error);
+    return jsonError(error);
+  }
+};

package/src/api/save-page.ts

@@ -0,0 +1,50 @@
+import type { APIRoute } from 'astro';
+import { z } from 'zod';
+import { Article } from '../domain/entities/Article';
+import { FileWriter } from '../services/FileWriter';
+import { pagesPath } from 'virtual:nca-ai-cms/config';
+import { jsonResponse, jsonError } from './_utils';
+
+const SavePageSchema = z.object({
+  title: z.string().min(1),
+  description: z.string().min(1),
+  content: z.string().min(1),
+  date: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  imageAlt: z.string().optional(),
+});
+
+export const POST: APIRoute = async ({ request }) => {
+  try {
+    const body = await request.json();
+    const parsed = SavePageSchema.safeParse(body);
+    if (!parsed.success) {
+      return jsonError(parsed.error.errors[0]?.message ?? 'Invalid request', 400);
+    }
+    const data = parsed.data;
+
+    const page = new Article({
+      title: data.title,
+      description: data.description,
+      content: data.content,
+      date: new Date(data.date || Date.now()),
+      tags: data.tags || [],
+      image: './hero.webp',
+      imageAlt: data.imageAlt,
+      contentPath: pagesPath,
+      flatPath: true,
+    });
+
+    const writer = new FileWriter();
+    const result = await writer.write(page);
+
+    return jsonResponse({
+      success: true,
+      filepath: result.filepath,
+      folderPath: page.folderPath,
+    });
+  } catch (error) {
+    console.error('Save page error:', error);
+    return jsonError(error);
+  }
+};

package/src/components/Editor.tsx

@@ -9,10 +9,12 @@ import {
 } from './editor/GenerateTab';
 import { SettingsTab } from './editor/SettingsTab';
 import { PlannerTab } from './editor/PlannerTab';
+import { PagesTab } from './editor/PagesTab';
 
 const TABS: { key: TabType; label: string }[] = [
   { key: 'generate', label: 'Generieren' },
   { key: 'planner', label: 'Planer' },
+  { key: 'pages', label: 'Seiten' },
   { key: 'settings', label: 'Einstellungen' },
 ];
 
@@ -100,6 +102,17 @@ export default function Editor() {
         </div>
       )}
 
+      {activeTab === 'pages' && (
+        <div
+          id="panel-pages"
+          role="tabpanel"
+          aria-labelledby="tab-pages"
+          style={isFullWidth ? styles.panelFullWidth : undefined}
+        >
+          <PagesTab />
+        </div>
+      )}
+
       {activeTab === 'settings' && (
         <div
           id="panel-settings"

package/src/components/editor/PagesTab.tsx

@@ -0,0 +1,231 @@
+import { useState, useEffect, useCallback } from 'react';
+import { styles } from './styles';
+
+interface PageData {
+  articleId: string;
+  title: string;
+  description: string;
+  date: string;
+  tags: string[];
+  image?: string;
+  imageAlt?: string;
+}
+
+export function PagesTab() {
+  const [pages, setPages] = useState<PageData[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+  const [generating, setGenerating] = useState(false);
+  const [newInput, setNewInput] = useState('');
+  const [deleteConfirm, setDeleteConfirm] = useState<string | null>(null);
+
+  const loadPages = useCallback(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const res = await fetch('/api/pages');
+      if (!res.ok) throw new Error('Fehler beim Laden der Seiten');
+      const data = (await res.json()) as PageData[];
+      setPages(data);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Ein Fehler ist aufgetreten');
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    loadPages();
+  }, [loadPages]);
+
+  const handleGenerate = async () => {
+    if (!newInput.trim()) return;
+    setGenerating(true);
+    setError(null);
+    try {
+      // Generate content
+      const contentRes = await fetch('/api/generate-page', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ input: newInput }),
+      });
+      if (!contentRes.ok) throw new Error('Fehler bei der Seitengenerierung');
+      const content = await contentRes.json();
+
+      // Generate image
+      const imageRes = await fetch('/api/generate-image', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ title: content.title }),
+      });
+      const image = imageRes.ok ? await imageRes.json() : null;
+
+      // Save page
+      const saveRes = await fetch('/api/save-page', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          title: content.title,
+          description: content.description,
+          content: content.content,
+          tags: content.tags,
+          date: content.date,
+          imageAlt: image?.alt,
+        }),
+      });
+      if (!saveRes.ok) throw new Error('Fehler beim Speichern der Seite');
+      const saveResult = await saveRes.json();
+
+      // Save image if generated
+      if (image?.url && saveResult.folderPath) {
+        await fetch('/api/save-image', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            imageUrl: image.url,
+            folderPath: saveResult.folderPath,
+          }),
+        });
+      }
+
+      setNewInput('');
+      await loadPages();
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Ein Fehler ist aufgetreten');
+    } finally {
+      setGenerating(false);
+    }
+  };
+
+  const handleDelete = async (slug: string) => {
+    try {
+      const res = await fetch(`/api/pages/${slug}`, {
+        method: 'DELETE',
+        credentials: 'same-origin',
+      });
+      if (!res.ok) throw new Error('Fehler beim Löschen');
+      setDeleteConfirm(null);
+      await loadPages();
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Ein Fehler ist aufgetreten');
+    }
+  };
+
+  if (loading) {
+    return <div style={styles.loadingBox}>Seiten werden geladen...</div>;
+  }
+
+  return (
+    <div style={styles.plannerContent}>
+      {/* Generate new page form */}
+      <div style={styles.plannerForm}>
+        <div style={styles.addFormTitle}>Neue Seite generieren</div>
+        <div style={{ display: 'flex', gap: '0.75rem', alignItems: 'end' }}>
+          <div style={{ flex: 1 }}>
+            <label style={styles.addFormLabel}>Thema, Keywords oder URL</label>
+            <input
+              type="text"
+              value={newInput}
+              onChange={(e) => setNewInput(e.target.value)}
+              placeholder="z.B. Laserreinigung, Gleitschleifen..."
+              style={styles.addFormInput}
+              onKeyDown={(e) => e.key === 'Enter' && handleGenerate()}
+            />
+          </div>
+          <button
+            type="button"
+            style={styles.addButton}
+            onClick={handleGenerate}
+            disabled={generating || !newInput.trim()}
+          >
+            {generating ? 'Generiert...' : 'Seite erstellen'}
+          </button>
+        </div>
+      </div>
+
+      {error && <div style={styles.error}>{error}</div>}
+
+      {/* Page list */}
+      {pages.length === 0 ? (
+        <div style={styles.emptyState}>
+          Noch keine Seiten vorhanden. Erstellen Sie Ihre erste Seite!
+        </div>
+      ) : (
+        <div style={styles.plannerList}>
+          {pages.map((page) => (
+            <div key={page.articleId} style={styles.plannerCard}>
+              <div style={styles.plannerCardHeader}>
+                <div>
+                  <div style={{ fontSize: '0.95rem', fontWeight: 600, color: 'var(--color-text, #faf9f7)' }}>
+                    {page.title}
+                  </div>
+                  <div style={{ fontSize: '0.8rem', color: 'var(--color-text-muted, #b8b5b0)', marginTop: '0.25rem' }}>
+                    {page.description}
+                  </div>
+                </div>
+                <div style={styles.plannerCardActions}>
+                  <a
+                    href={`/services/${page.articleId}`}
+                    style={{
+                      ...styles.editButton,
+                      textDecoration: 'none',
+                      display: 'inline-flex',
+                      alignItems: 'center',
+                    }}
+                  >
+                    Ansehen
+                  </a>
+                  {deleteConfirm === page.articleId ? (
+                    <>
+                      <button
+                        type="button"
+                        style={styles.deleteButton}
+                        onClick={() => handleDelete(page.articleId)}
+                      >
+                        Bestätigen
+                      </button>
+                      <button
+                        type="button"
+                        style={styles.cancelButton}
+                        onClick={() => setDeleteConfirm(null)}
+                      >
+                        Abbrechen
+                      </button>
+                    </>
+                  ) : (
+                    <button
+                      type="button"
+                      style={styles.deleteButton}
+                      onClick={() => setDeleteConfirm(page.articleId)}
+                    >
+                      Löschen
+                    </button>
+                  )}
+                </div>
+              </div>
+              {page.tags && page.tags.length > 0 && (
+                <div style={{ padding: '0.75rem 1.25rem', display: 'flex', gap: '0.5rem', flexWrap: 'wrap' as const }}>
+                  {page.tags.map((tag) => (
+                    <span
+                      key={tag}
+                      style={{
+                        background: 'var(--color-surface-accent, #222226)',
+                        border: '1px solid var(--color-border, #2a2a2e)',
+                        borderRadius: '4px',
+                        padding: '0.15rem 0.5rem',
+                        fontSize: '0.75rem',
+                        color: 'var(--color-text-muted, #b8b5b0)',
+                      }}
+                    >
+                      {tag}
+                    </span>
+                  ))}
+                </div>
+              )}
+            </div>
+          ))}
+        </div>
+      )}
+    </div>
+  );
+}

package/src/components/editor/SettingsTab.tsx

@@ -289,6 +289,50 @@ export function SettingsTab() {
         ))}
       </div>
 
+      {/* Database Management — only on Website tab */}
+      {activeSubTab === 'website' && (
+        <div style={{ ...styles.plannerForm, flexDirection: 'row', alignItems: 'center' }}>
+          <span style={{ ...styles.label, marginRight: 'auto' }}>Datenbank-Verwaltung</span>
+          <a
+            href="/api/db/download"
+            style={{ ...styles.editButton, textDecoration: 'none', display: 'inline-flex', alignItems: 'center', gap: '0.4rem' }}
+          >
+            ↓ DB herunterladen
+          </a>
+          <label style={{ ...styles.editButton, cursor: 'pointer', display: 'inline-flex', alignItems: 'center', gap: '0.4rem', margin: 0 }}>
+            ↑ DB hochladen
+            <input
+              type="file"
+              accept=".db,.sqlite,.sqlite3"
+              style={styles.srOnly}
+              onChange={async (e) => {
+                const file = e.target.files?.[0];
+                if (!file) return;
+                if (!confirm(`Datenbank "${file.name}" hochladen? Die aktuelle DB wird ueberschrieben.`)) {
+                  e.target.value = '';
+                  return;
+                }
+                const formData = new FormData();
+                formData.append('database', file);
+                try {
+                  const res = await fetch('/api/db/upload', { method: 'POST', body: formData });
+                  const data = await res.json();
+                  if (res.ok) {
+                    alert('Datenbank hochgeladen. Seite wird neu geladen.');
+                    window.location.reload();
+                  } else {
+                    alert('Fehler: ' + (data.error || 'Upload fehlgeschlagen'));
+                  }
+                } catch {
+                  alert('Upload fehlgeschlagen');
+                }
+                e.target.value = '';
+              }}
+            />
+          </label>
+        </div>
+      )}
+
       {loading && (
         <div style={styles.loadingBox}>Einstellungen werden geladen...</div>
       )}

package/src/components/editor/types.ts

@@ -1,4 +1,4 @@
-export type TabType = 'generate' | 'planner' | 'settings';
+export type TabType = 'generate' | 'planner' | 'pages' | 'settings';
 
 export type SettingsSubTab =
   | 'homepage'

package/src/config.d.ts

@@ -1,4 +1,5 @@
 declare module 'virtual:nca-ai-cms/config' {
   export const contentPath: string;
+  export const pagesPath: string;
   export const autoPublish: boolean;
 }

package/src/domain/entities/Article.test.ts

@@ -135,4 +135,27 @@ describe('Article', () => {
     expect(markdown).toContain('image: "./hero.webp"');
     expect(markdown).toContain('imageAlt: "Accessibility illustration"');
   });
+
+  it('generates flat folderPath when flatPath is true', () => {
+    const article = new Article({
+      ...defaultProps,
+      contentPath: 'nca-ai-cms-pages',
+      flatPath: true,
+    });
+
+    expect(article.folderPath).toBe(
+      'nca-ai-cms-pages/html-accessibility-grundlagen'
+    );
+  });
+
+  it('generates nested folderPath when flatPath is false', () => {
+    const article = new Article({
+      ...defaultProps,
+      flatPath: false,
+    });
+
+    expect(article.folderPath).toBe(
+      'nca-ai-cms-content/2025/12/html-accessibility-grundlagen'
+    );
+  });
 });

package/src/domain/entities/Article.ts

@@ -10,6 +10,7 @@ export type ArticleProps = {
   image?: string;
   imageAlt?: string;
   contentPath?: string;
+  flatPath?: boolean;
 };
 
 export class Article {
@@ -23,6 +24,7 @@ export class Article {
   readonly image?: string;
   readonly imageAlt?: string;
   readonly contentPath: string;
+  readonly flatPath: boolean;
 
   constructor(props: ArticleProps) {
     this.title = props.title;
@@ -32,6 +34,7 @@ export class Article {
     this.slug = new Slug(props.title);
     this.seoMetadata = new SEOMetadata(props.title, props.description);
     this.contentPath = props.contentPath ?? 'nca-ai-cms-content';
+    this.flatPath = props.flatPath ?? false;
 
     this.content = props.content;
 
@@ -56,6 +59,9 @@ export class Article {
   }
 
   get folderPath(): string {
+    if (this.flatPath) {
+      return `${this.contentPath}/${this.slug.toString()}`;
+    }
     return `${this.contentPath}/${this.year}/${this.month}/${this.slug.toString()}`;
   }
 

package/src/domain/value-objects/ArticleFinder.test.ts

@@ -101,4 +101,37 @@ describe('ArticleFinder', () => {
       expect(result?.articleId).toBe('2026/01/test-slug');
     });
   });
+
+  describe('flat folder support', () => {
+    it('finds article in flat structure (basePath/slug/index.md)', async () => {
+      const flatFolder = path.join(tempDir, 'laserreinigung');
+      await fs.mkdir(flatFolder, { recursive: true });
+      await fs.writeFile(
+        path.join(flatFolder, 'index.md'),
+        '---\ntitle: Laserreinigung\n---\nContent'
+      );
+
+      const result = await finder.findBySlug('laserreinigung');
+
+      expect(result).not.toBeNull();
+      expect(result?.folderPath).toBe(flatFolder);
+      expect(result?.articleId).toBe('laserreinigung');
+    });
+
+    it('flat folder takes priority over year/month match', async () => {
+      // Create both flat and nested
+      const flatFolder = path.join(tempDir, 'my-page');
+      await fs.mkdir(flatFolder, { recursive: true });
+      await fs.writeFile(path.join(flatFolder, 'index.md'), '---\ntitle: Flat\n---');
+
+      const nestedFolder = path.join(tempDir, '2026', '01', 'my-page');
+      await fs.mkdir(nestedFolder, { recursive: true });
+      await fs.writeFile(path.join(nestedFolder, 'index.md'), '---\ntitle: Nested\n---');
+
+      const result = await finder.findBySlug('my-page');
+
+      expect(result?.articleId).toBe('my-page');
+      expect(result?.folderPath).toBe(flatFolder);
+    });
+  });
 });

package/src/domain/value-objects/ArticleFinder.ts

@@ -12,6 +12,18 @@ export class ArticleFinder {
 
   async findBySlug(slug: string): Promise<ArticleLocation | null> {
     try {
+      // 1. Check flat structure: basePath/slug/index.md
+      const flatPath = path.join(this.basePath, slug);
+      const flatIndex = path.join(flatPath, 'index.md');
+      try {
+        await fs.access(flatIndex);
+        const stat = await fs.stat(flatPath);
+        if (stat.isDirectory()) {
+          return { folderPath: flatPath, indexPath: flatIndex, articleId: slug };
+        }
+      } catch {}
+
+      // 2. Fall back to year/month/slug structure
       const years = await this.getDirectories(this.basePath);
 
       for (const year of years) {
@@ -27,7 +39,6 @@ export class ArticleFinder {
               const folderPath = path.join(monthPath, article);
               const indexPath = path.join(folderPath, 'index.md');
 
-              // Verify index.md exists
               try {
                 await fs.access(indexPath);
                 return {
@@ -36,7 +47,6 @@ export class ArticleFinder {
                   articleId: `${year}/${month}/${article}`,
                 };
               } catch {
-                // index.md doesn't exist, skip this folder
                 continue;
               }
             }

package/src/index.ts

@@ -6,6 +6,7 @@ import node from '@astrojs/node';
 
 export interface NcaAiCmsPluginOptions {
   contentPath?: string;
+  pagesPath?: string;
   autoPublish?: boolean;
 }
 
@@ -13,6 +14,7 @@ export default function ncaAiCms(
   options: NcaAiCmsPluginOptions = {}
 ): AstroIntegration {
   const contentPath = options.contentPath ?? 'nca-ai-cms-content';
+  const pagesPath = options.pagesPath ?? 'nca-ai-cms-pages';
   const autoPublish = options.autoPublish ?? import.meta.env.PROD;
 
   return {
@@ -60,7 +62,7 @@ export default function ncaAiCms(
                 },
                 load(id) {
                   if (id === '\0virtual:nca-ai-cms/config') {
-                    return `export const contentPath = ${JSON.stringify(contentPath)};\nexport const autoPublish = ${JSON.stringify(autoPublish)};`;
+                    return `export const contentPath = ${JSON.stringify(contentPath)};\nexport const pagesPath = ${JSON.stringify(pagesPath)};\nexport const autoPublish = ${JSON.stringify(autoPublish)};`;
                   }
                 },
               },
@@ -137,6 +139,60 @@ export default function ncaAiCms(
           prerender: false,
         });
 
+        // Inject page API routes (mirrors article routes with pagesPath)
+        injectRoute({
+          pattern: '/api/pages',
+          entrypoint: 'nca-ai-cms-astro-plugin/api/pages/index.ts',
+          prerender: false,
+        });
+        injectRoute({
+          pattern: '/api/pages/[id]',
+          entrypoint: 'nca-ai-cms-astro-plugin/api/pages/[id].ts',
+          prerender: false,
+        });
+        injectRoute({
+          pattern: '/api/pages/[id]/apply',
+          entrypoint: 'nca-ai-cms-astro-plugin/api/pages/[id]/apply.ts',
+          prerender: false,
+        });
+        injectRoute({
+          pattern: '/api/pages/[id]/regenerate-text',
+          entrypoint: 'nca-ai-cms-astro-plugin/api/pages/[id]/regenerate-text.ts',
+          prerender: false,
+        });
+        injectRoute({
+          pattern: '/api/pages/[id]/regenerate-image',
+          entrypoint: 'nca-ai-cms-astro-plugin/api/pages/[id]/regenerate-image.ts',
+          prerender: false,
+        });
+        injectRoute({
+          pattern: '/api/generate-page',
+          entrypoint: 'nca-ai-cms-astro-plugin/api/generate-page.ts',
+          prerender: false,
+        });
+        injectRoute({
+          pattern: '/api/save-page',
+          entrypoint: 'nca-ai-cms-astro-plugin/api/save-page.ts',
+          prerender: false,
+        });
+        injectRoute({
+          pattern: '/api/page-image/[...path]',
+          entrypoint: 'nca-ai-cms-astro-plugin/pages/api/page-image/[...path].ts',
+          prerender: false,
+        });
+
+        // Inject DB management routes (auth-protected via middleware)
+        injectRoute({
+          pattern: '/api/db/download',
+          entrypoint: 'nca-ai-cms-astro-plugin/api/db/download.ts',
+          prerender: false,
+        });
+        injectRoute({
+          pattern: '/api/db/upload',
+          entrypoint: 'nca-ai-cms-astro-plugin/api/db/upload.ts',
+          prerender: false,
+        });
+
         // Inject auth routes
         injectRoute({
           pattern: '/api/auth/login',

package/src/pages/api/page-image/[...path].ts

@@ -0,0 +1,50 @@
+import type { APIRoute } from 'astro';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { pagesPath } from 'virtual:nca-ai-cms/config';
+
+export const GET: APIRoute = async ({ params }) => {
+  const imagePath = params.path;
+
+  if (!imagePath) {
+    return new Response('Not found', { status: 404 });
+  }
+
+  const allowedExtensions = ['.webp', '.png', '.jpg', '.jpeg'];
+  const ext = path.extname(imagePath).toLowerCase();
+
+  if (!allowedExtensions.includes(ext)) {
+    return new Response('Invalid file type', { status: 400 });
+  }
+
+  const contentDir = path.resolve(process.cwd(), pagesPath);
+  const fullPath = path.resolve(contentDir, imagePath);
+
+  if (!fullPath.startsWith(contentDir + path.sep)) {
+    return new Response('Invalid path', { status: 400 });
+  }
+
+  try {
+    const imageBuffer = await fs.readFile(fullPath);
+    const contentType =
+      ext === '.webp'
+        ? 'image/webp'
+        : ext === '.png'
+          ? 'image/png'
+          : 'image/jpeg';
+
+    const stats = await fs.stat(fullPath);
+    const etag = `"${stats.mtimeMs.toString(36)}"`;
+
+    return new Response(imageBuffer, {
+      status: 200,
+      headers: {
+        'Content-Type': contentType,
+        'Cache-Control': 'public, max-age=0, must-revalidate',
+        ETag: etag,
+      },
+    });
+  } catch {
+    return new Response('Image not found', { status: 404 });
+  }
+};

package/src/services/ArticleService.ts

@@ -43,17 +43,27 @@ export class ArticleService {
     const fullBasePath = path.join(process.cwd(), this.basePath);
 
     try {
-      const years = await fs.readdir(fullBasePath);
+      const entries = await fs.readdir(fullBasePath);
 
-      for (const year of years) {
-        const yearPath = path.join(fullBasePath, year);
-        const yearStat = await fs.stat(yearPath).catch(() => null);
-        if (!yearStat?.isDirectory()) continue;
+      for (const entry of entries) {
+        const entryPath = path.join(fullBasePath, entry);
+        const entryStat = await fs.stat(entryPath).catch(() => null);
+        if (!entryStat?.isDirectory()) continue;
 
-        const months = await fs.readdir(yearPath);
+        // Check if this is a flat article (has index.md directly)
+        const flatIndex = path.join(entryPath, 'index.md');
+        try {
+          await fs.access(flatIndex);
+          const article = await this.read(entry);
+          if (article) articles.push(article);
+          continue;
+        } catch {}
+
+        // Otherwise treat as year directory → scan month/slug
+        const months = await fs.readdir(entryPath);
 
         for (const month of months) {
-          const monthPath = path.join(yearPath, month);
+          const monthPath = path.join(entryPath, month);
           const monthStat = await fs.stat(monthPath).catch(() => null);
           if (!monthStat?.isDirectory()) continue;
 

package/src/utils/authUtils.ts

@@ -1,7 +1,7 @@
 import { validateSession } from '../services/SessionService.js';
 
 const PUBLIC_PATHS = ['/api/auth/login', '/api/auth/logout', '/login'];
-const PUBLIC_PATH_PREFIXES = ['/api/article-image/'];
+const PUBLIC_PATH_PREFIXES = ['/api/article-image/', '/api/page-image/'];
 
 export function isPublicPath(pathname: string): boolean {
   return PUBLIC_PATHS.includes(pathname) || PUBLIC_PATH_PREFIXES.some(prefix => pathname.startsWith(prefix));

package/update.md

@@ -1,3 +1,32 @@
+# v1.0.17
+
+## Feature: Database download/upload via Editor UI
+- New GET `/api/db/download` endpoint — exports SQLite database as file download with timestamp
+- New POST `/api/db/upload` endpoint — imports SQLite database with validation and backup
+- Download/Upload buttons in Editor → Einstellungen → Website tab
+- Path traversal protection: database path validated against project root
+- File size limit: 50 MB max upload
+- SQLite header validation on upload (rejects non-SQLite files)
+- Automatic backup of current DB before overwrite (`content.db.backup`)
+- Both routes auth-protected via existing middleware
+
+---
+
+# v1.0.16
+
+## Feature: Pages content type with flat URL structure
+- New `pagesPath` plugin option (default: `nca-ai-cms-pages`) for managing CMS pages separately from articles
+- Flat folder support in ArticleFinder — pages stored as `basePath/slug/index.md` without date hierarchy
+- SEO-friendly URLs: `/services/laserreinigung` instead of `/services/2024/04/laserreinigung`
+- Flat paths take priority over year/month paths when both exist
+- New `flatPath` option on Article entity for flat folder creation
+- 8 new API routes: `/api/pages/*` (list, CRUD, regenerate text/image, apply, generate, save)
+- `/api/page-image/[...path]` route for serving page images (public, no auth required)
+- New "Seiten" tab in editor UI — list, create, delete pages with AI content generation
+- 4 new tests (211 total, up from 207)
+
+---
+
 # v1.0.15
 
 ## Security: authentication hardening