nca-ai-cms-astro-plugin 1.0.14 → 1.0.16

package/package.json

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

package/src/api/auth/login.ts

@@ -1,14 +1,35 @@
 import type { APIRoute } from 'astro';
 import { z } from 'zod';
 import { jsonResponse, jsonError } from '../_utils.js';
-import { getEnvVariable } from '../../utils/envUtils.js';
+import { verifyCredentials } from '../../utils/credentialUtils.js';
+import { createSession, purgeExpiredSessions } from '../../services/SessionService.js';
+import { loginRateLimiter } from '../../utils/loginRateLimiter.js';
 
 const loginSchema = z.object({
   username: z.string().min(1),
   password: z.string().min(1),
 });
 
-export const POST: APIRoute = async ({ request, cookies }) => {
+export const POST: APIRoute = async ({ request, cookies, clientAddress }) => {
+  const ip =
+    clientAddress ??
+    request.headers.get('x-forwarded-for')?.split(',')[0]?.trim() ??
+    'unknown';
+
+  const { limited, retryAfter } = loginRateLimiter.check(ip);
+  if (limited) {
+    return new Response(
+      JSON.stringify({ error: 'Too many login attempts. Try again later.' }),
+      {
+        status: 429,
+        headers: {
+          'Content-Type': 'application/json',
+          'Retry-After': String(retryAfter),
+        },
+      },
+    );
+  }
+
   let body: unknown;
   try {
     body = await request.json();
@@ -22,14 +43,18 @@ export const POST: APIRoute = async ({ request, cookies }) => {
   }
 
   const { username, password } = result.data;
-  const expectedUsername = getEnvVariable('EDITOR_ADMIN');
-  const expectedPassword = getEnvVariable('EDITOR_PASSWORD');
 
-  if (username !== expectedUsername || password !== expectedPassword) {
+  if (!verifyCredentials(username, password)) {
+    loginRateLimiter.record(ip);
+    console.warn(
+      `[nca-ai-cms] Failed login attempt from ${ip} at ${new Date().toISOString()}`,
+    );
     return jsonError('Invalid credentials', 401);
   }
 
-  const token = btoa(`${username}:${password}`);
+  loginRateLimiter.clear(ip);
+  await purgeExpiredSessions();
+  const token = await createSession();
 
   cookies.set('editor-auth', token, {
     httpOnly: true,

package/src/api/auth/logout.ts

@@ -1,6 +1,10 @@
 import type { APIRoute } from 'astro';
+import { deleteSession } from '../../services/SessionService.js';
 
 export const POST: APIRoute = async ({ cookies, redirect }) => {
+  const token = cookies.get('editor-auth')?.value;
+  if (token) await deleteSession(token);
+
   cookies.delete('editor-auth', { path: '/' });
   return redirect('/login', 302);
 };

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/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/db/config.ts

@@ -1,6 +1,6 @@
 import { defineDb } from 'astro:db';
-import { SiteSettings, Prompts, ScheduledPosts } from './tables.js';
+import { SiteSettings, Prompts, ScheduledPosts, Sessions } from './tables.js';
 
 export default defineDb({
-  tables: { SiteSettings, Prompts, ScheduledPosts },
+  tables: { SiteSettings, Prompts, ScheduledPosts, Sessions },
 });

package/src/db/tables.ts

@@ -37,4 +37,12 @@ const Prompts = defineTable({
   },
 });
 
-export { SiteSettings, Prompts, ScheduledPosts };
+const Sessions = defineTable({
+  columns: {
+    token: column.text({ primaryKey: true }),
+    createdAt: column.date({ default: new Date() }),
+    expiresAt: column.date(),
+  },
+});
+
+export { SiteSettings, Prompts, ScheduledPosts, Sessions };