feat: Phase 8 – Modul-SDK (createModuleServer, Config, Logger, Platform-Client)

README.md

@@ -2,7 +2,7 @@
 
 Zentrale, webbasierte Management-Plattform, über die eigenständige Web-Applikationen als **Module** integriert, verwaltet und Benutzern zugewiesen werden können.
 
-**Status: Phase 6 – Modul-API (abgeschlossen)**
+**Status: Phase 8 – Modul-SDK (abgeschlossen)**
 
 ## Architektur-Überblick
 
@@ -109,6 +109,9 @@ Zweistufiges Rechtekonzept: Plattform-Rollen (ADMIN/USER) + Modul-Berechtigungen
 ### Phase 6 – Modul-API & SDK
 Verbindlicher Modul-API-Vertrag (`/health`, `/api/manifest`, `/api/me`) mit `platform-module-sdk`: Module erhalten die Benutzer-Identität sicher über Gateway-Header (Session-Cookie wird nie weitergereicht). Demo-Modul als Referenzimplementierung.
 
+### Phase 8 – Modul-SDK
+`packages/platform-module-sdk`: `createModuleServer` verdrahtet den kompletten Vertrag plus fachliche Routen; dazu Manifest-Validierung, Laufzeit-Config, strukturiertes Logging (mit Secret-Schwärzung) und ein interner Plattform-API-Client. Module binden das SDK als Einzeldatei ein (Vendor-Pattern). Phase 7 (Kalender) wurde zugunsten der Einbindung bestehender Projekte übersprungen.
+
 ## Annahme
 
 „ChatCM" wurde als **shadcn-artige Komponentenbasis** interpretiert: Tailwind CSS plus zentral gepflegte, wiederverwendbare UI-Komponenten (`apps/platform-frontend/src/components/ui`).

apps/platform-backend/test/platform-module-sdk.spec.ts

@@ -1,13 +1,46 @@
 /**
- * SDK-Tests (Phase 6): Vertrags-Helper des Modul-SDKs.
+ * SDK-Tests (Phase 8): Vollständige Abdeckung des Modul-SDKs.
  * Das SDK ist CommonJS und wird direkt mit Node getestet.
  */
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
 const {
   GATEWAY_HEADERS,
   extractIdentity,
   healthResponse,
+  manifestResponse,
   meResponse,
-} = require('../../../modules/demo/backend/platform-module-sdk');
+  loadManifest,
+  loadModuleConfig,
+  createLogger,
+  createModuleServer,
+} = require('../../../packages/platform-module-sdk');
+
+/** Schreibt ein Test-Manifest in ein temporäres Verzeichnis. */
+function writeTestManifest(overrides = {}): string {
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'mpm-sdk-'));
+  const manifestPath = path.join(directory, 'module.json');
+  fs.writeFileSync(
+    manifestPath,
+    JSON.stringify({
+      id: 'testmodul',
+      name: 'Test-Modul',
+      version: '1.0.0',
+      slug: 'test-modul',
+      description: 'Test',
+      author: 'MPM',
+      runtime: 'node',
+      entrypoint: 'server.js',
+      port: 41001,
+      healthcheck: '/health',
+      apiVersion: 'v1',
+      ...overrides,
+    }),
+    'utf8',
+  );
+  return manifestPath;
+}
 
 describe('platform-module-sdk', () => {
   describe('extractIdentity', () => {
@@ -103,4 +136,228 @@ describe('platform-module-sdk', () => {
       expect(meResponse(identity, 'demo').permissions).toEqual([]);
     });
   });
+
+  describe('manifestResponse', () => {
+    it('erzeugt eine vertragskonforme /api/manifest-Antwort', () => {
+      const manifest = loadManifest(writeTestManifest());
+      expect(manifestResponse(manifest)).toEqual({
+        moduleId: 'testmodul',
+        name: 'Test-Modul',
+        version: '1.0.0',
+        slug: 'test-modul',
+        apiVersion: 'v1',
+        status: 'healthy',
+      });
+    });
+  });
+
+  describe('loadManifest', () => {
+    it('lädt ein gültiges Manifest und friert es ein', () => {
+      const manifest = loadManifest(writeTestManifest());
+      expect(manifest.id).toBe('testmodul');
+      expect(Object.isFrozen(manifest)).toBe(true);
+    });
+
+    it('wirft bei fehlender Datei', () => {
+      expect(() => loadManifest('/nicht/existent/module.json')).toThrow(
+        /nicht lesbar/,
+      );
+    });
+
+    it('wirft bei unvollständigem Manifest', () => {
+      const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'mpm-sdk-'));
+      const manifestPath = path.join(directory, 'module.json');
+      fs.writeFileSync(manifestPath, JSON.stringify({ id: 'x' }), 'utf8');
+      expect(() => loadManifest(manifestPath)).toThrow(/unvollständig/);
+    });
+
+    it('wirft bei nicht unterstützter Runtime', () => {
+      expect(() => loadManifest(writeTestManifest({ runtime: 'python' }))).toThrow(
+        /Runtime/,
+      );
+    });
+
+    it('wirft bei nicht unterstützter apiVersion', () => {
+      expect(() => loadManifest(writeTestManifest({ apiVersion: 'v2' }))).toThrow(
+        /apiVersion/,
+      );
+    });
+  });
+
+  describe('loadModuleConfig', () => {
+    it('liest PORT und Defaults', () => {
+      const config = loadModuleConfig({ PORT: '41042', NODE_ENV: 'production' });
+      expect(config.port).toBe(41042);
+      expect(config.nodeEnv).toBe('production');
+      expect(config.platformBaseUrl).toBe('http://127.0.0.1:3000');
+      expect(config.serviceToken).toBeNull();
+    });
+
+    it('liest PLATFORM_INTERNAL_URL und MODULE_SERVICE_TOKEN', () => {
+      const config = loadModuleConfig({
+        PORT: '41001',
+        PLATFORM_INTERNAL_URL: 'http://plattform:3000',
+        MODULE_SERVICE_TOKEN: 'test-token',
+      });
+      expect(config.platformBaseUrl).toBe('http://plattform:3000');
+      expect(config.serviceToken).toBe('test-token');
+    });
+  });
+
+  describe('createLogger', () => {
+    it('schreibt strukturierte JSON-Logs auf stdout', () => {
+      const logLines: string[] = [];
+      const originalLog = console.log;
+      console.log = (line: string) => logLines.push(line);
+
+      const logger = createLogger({ moduleId: 'testmodul' });
+      logger.info('Testmeldung', { benutzer: 'max' });
+
+      console.log = originalLog;
+
+      expect(logLines).toHaveLength(1);
+      const entry = JSON.parse(logLines[0]);
+      expect(entry.level).toBe('info');
+      expect(entry.moduleId).toBe('testmodul');
+      expect(entry.message).toBe('Testmeldung');
+      expect(entry.data).toEqual({ benutzer: 'max' });
+    });
+
+    it('schwärzt sensible Schlüssel', () => {
+      const logLines: string[] = [];
+      const originalError = console.error;
+      console.error = (line: string) => logLines.push(line);
+
+      const logger = createLogger({ moduleId: 'testmodul' });
+      logger.warn('Login-Versuch', { password: 'geheim', username: 'max' });
+
+      console.error = originalError;
+
+      const entry = JSON.parse(logLines[0]);
+      expect(entry.data.password).toBe('[geschwärzt]');
+      expect(entry.data.username).toBe('max');
+    });
+
+    it('filtert Meldungen unterhalb des Minimal-Levels', () => {
+      const logLines: string[] = [];
+      const originalLog = console.log;
+      console.log = (line: string) => logLines.push(line);
+
+      const logger = createLogger({ moduleId: 'testmodul', level: 'warn' });
+      logger.debug('unsichtbar');
+      logger.info('auch unsichtbar');
+
+      console.log = originalLog;
+      expect(logLines).toHaveLength(0);
+    });
+  });
+
+  describe('createModuleServer', () => {
+    const manifest = loadManifest(writeTestManifest());
+    const identityHeaders = {
+      [GATEWAY_HEADERS.userId]: 'user-1',
+      [GATEWAY_HEADERS.username]: 'max',
+      [GATEWAY_HEADERS.displayName]: 'Max',
+      [GATEWAY_HEADERS.role]: 'USER',
+    };
+
+    function request(
+      server: ReturnType<typeof createModuleServer>,
+      requestPath: string,
+      headers: Record<string, string> = {},
+    ): Promise<{ status: number; body: string }> {
+      return new Promise((resolve, reject) => {
+        server.listen(0, '127.0.0.1', () => {
+          const address = server.address();
+          const port = typeof address === 'object' && address ? address.port : 0;
+          const httpRequest = require('node:http');
+          const req = httpRequest.get(
+            { host: '127.0.0.1', port, path: requestPath, headers },
+            (res: import('node:http').IncomingMessage) => {
+              let body = '';
+              res.on('data', (chunk: string) => {
+                body += chunk;
+              });
+              res.on('end', () => {
+                server.close();
+                resolve({ status: res.statusCode ?? 0, body });
+              });
+            },
+          );
+          req.on('error', (error: Error) => {
+            server.close();
+            reject(error);
+          });
+        });
+      });
+    }
+
+    it('beantwortet /health nach Vertrag', async () => {
+      const server = createModuleServer({ manifest });
+      const response = await request(server, '/health');
+      expect(response.status).toBe(200);
+      expect(JSON.parse(response.body)).toEqual({
+        moduleId: 'testmodul',
+        version: '1.0.0',
+        status: 'healthy',
+      });
+    });
+
+    it('beantwortet /api/manifest nach Vertrag', async () => {
+      const server = createModuleServer({ manifest });
+      const response = await request(server, '/api/manifest');
+      expect(response.status).toBe(200);
+      expect(JSON.parse(response.body).moduleId).toBe('testmodul');
+    });
+
+    it('beantwortet /api/me mit Identität', async () => {
+      const server = createModuleServer({ manifest, permissions: ['test.read'] });
+      const response = await request(server, '/api/me', identityHeaders);
+      expect(response.status).toBe(200);
+      const body = JSON.parse(response.body);
+      expect(body.user.username).toBe('max');
+      expect(body.permissions).toEqual(['test.read']);
+    });
+
+    it('antwortet 401 auf /api/me ohne Identität', async () => {
+      const server = createModuleServer({ manifest });
+      const response = await request(server, '/api/me');
+      expect(response.status).toBe(401);
+    });
+
+    it('leitet fachliche Routen an den routes-Handler weiter', async () => {
+      const server = createModuleServer({
+        manifest,
+        routes: (
+          _req: unknown,
+          res: import('node:http').ServerResponse,
+          context: { path: string; identity: { username: string } },
+        ) => {
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ path: context.path, user: context.identity.username }));
+        },
+      });
+      const response = await request(server, '/aufgaben', identityHeaders);
+      expect(response.status).toBe(200);
+      expect(JSON.parse(response.body)).toEqual({ path: '/aufgaben', user: 'max' });
+    });
+
+    it('blockiert fachliche Routen ohne Identität (identityRequired)', async () => {
+      const server = createModuleServer({
+        manifest,
+        routes: (_req: unknown, res: import('node:http').ServerResponse) => {
+          res.writeHead(200);
+          res.end('ok');
+        },
+      });
+      const response = await request(server, '/aufgaben');
+      expect(response.status).toBe(401);
+    });
+
+    it('antwortet 404 ohne routes-Handler', async () => {
+      const server = createModuleServer({ manifest });
+      const response = await request(server, '/andere', identityHeaders);
+      expect(response.status).toBe(404);
+    });
+  });
 });

docs/PHASES.md

@@ -10,8 +10,8 @@ Der Arbeitsplan sieht zehn inkrementelle Phasen vor. Nach jeder Phase muss das S
 | 4 | Gateway & dynamisches Routing (`/slug`) | ✅ Abgeschlossen |
 | 5 | Berechtigungssystem (User ↔ Module) | ✅ Abgeschlossen |
 | 6 | Modul-API (`/health`, `/api/manifest`, `/api/me`) | ✅ Abgeschlossen |
-| 7 | Referenzmodul Kalender | ⏳ Geplant |
+| 7 | Referenzmodul Kalender | ⏳ Übersprungen (bestehende Projekte werden stattdessen eingebunden) |
-| 8 | Modul-SDK (`platform-module-sdk`) | ⏳ Geplant |
+| 8 | Modul-SDK (`platform-module-sdk`) | ✅ Abgeschlossen |
 | 9 | Administration (Übersichten, Audit-UI, Einstellungen) | ⏳ Geplant |
 | 10 | Security Hardening & Produktivbetrieb | ⏳ Geplant |
 
@@ -105,9 +105,28 @@ Definition of Done: `GET /health`, `GET /api/manifest`, `GET /api/me` plus zentr
 - [x] Backend-Tests: 98 bestanden (inkl. 8 SDK-Tests)
 - [x] E2E verifiziert: `/demo/health` → vertragskonform, `/demo/api/manifest` → Manifest, `/demo/api/me` → Identität vom Gateway (admin/ADMIN, Permissions); direkter Aufruf ohne Identität → 401; ohne Login → 401 vom Gateway
 
-## Nächste Schritte (Phase 7 – Referenzmodul Kalender)
+## Phase 7 – Referenzmodul Kalender (übersprungen)
 
-- Vollständiges Kalender-Modul (Dashboard, Kalender, Termine, Teilnehmer, Einstellungen)
+Entscheidung: Das Kalender-Modul wird zugunsten der Einbindung bestehender Projekte übersprungen. Das Demo-Modul dient als Referenzimplementierung des Modul-Vertrags.
-- Eigenes PostgreSQL-Schema (`calendar.*`) mit Migrationen
+
-- Frontend mit eigener Oberfläche, integriert in das Plattform-Design
+## Phase 8 – Modul-SDK (abgeschlossen)
-- Dient als Referenzimplementierung für zukünftige Module
+
+Definition of Done: `platform-module-sdk` mit Authentication, Current User, Permissions, API Client, Module Config, Logging, Healthcheck.
+
+- [x] SDK-Paket `packages/platform-module-sdk` (CommonJS, vendor-fähig als Einzeldatei)
+- [x] `createModuleServer`: verdrahtet den vollständigen Vertrag (health, manifest, me) + fachliche Routen mit Identitäts-Context
+- [x] `extractIdentity`: Gateway-Header (case-insensitive, Rollen-Validierung, 401-Verhalten)
+- [x] `loadManifest`: Manifest-Validierung (Pflichtfelder, Runtime, apiVersion)
+- [x] `loadModuleConfig`: PORT, NODE_ENV, PLATFORM_INTERNAL_URL, MODULE_SERVICE_TOKEN
+- [x] `createLogger`: strukturierte JSON-Logs mit automatischem Schwärzen sensibler Schlüssel
+- [x] `createPlatformClient`: interner HTTP-Client zur Plattform (Service-Token vorbereitet)
+- [x] Demo-Modul vollständig auf das SDK umgestellt (Vendor-Pattern)
+- [x] Backend-Tests: 116 bestanden (inkl. 26 SDK-Tests: Vertrag, Manifest, Config, Logger-Schwärzung, Server-Verhalten)
+- [x] E2E verifiziert: SDK-Vertrag über Gateway (health/manifest/me), fachliche Route, 404, 401 ohne Identität
+
+## Nächste Schritte (Phase 9 – Administration)
+
+- Audit-Log-UI (durchsuchen, filtern)
+- Systemeinstellungen (Backend + UI)
+- Systemstatus-Dashboard erweitern (Modul-Healths)
+- Danach: Einbindung bestehender Projekte als Module (ersetzt Phase 7)

modules/demo/backend/platform-module-sdk.js

@@ -1,39 +1,70 @@
+'use strict';
+
 /**
- * MPM Modul-SDK – Authentifizierungs-Helper (Phase 6).
+ * MPM Modul-SDK (Phase 8)
- * CommonJS-Variante (Module laufen als Node-CommonJS-Prozesse).
+ * =======================
+ * Standardbibliothek für MPM-Module. Ein Modul ist ein eigenständiger
+ * Node-Prozess innerhalb des Management-Containers, der ausschließlich
+ * über den Modul-Gateway der Plattform erreichbar ist.
  *
- * Jedes Modul läuft hinter dem Modul-Gateway der Management-Plattform.
+ * Das SDK stellt bereit:
- * Der Gateway authentifiziert den Benutzer zentral und übergibt die
+ *  - Authentication  : Identität aus den sicheren Gateway-Headern
- * Identität über interne Header. Module dürfen diese Header NIE
+ *  - Current User    : /api/me-Antwort nach Vertrag
- * direkt von außen akzeptieren – deshalb stellt dieses SDK sicher,
+ *  - Permissions     : Modulrechte in der /api/me-Antwort
- * dass die Identität nur aus dem Gateway-Flow stammt.
+ *  - API Client      : HTTP-Client für Plattform-Aufrufe (intern)
+ *  - Module Config   : Manifest-Laden und Laufzeit-Konfiguration
+ *  - Logging         : Strukturiertes Logging ohne Secrets
+ *  - Healthcheck     : /health- und /api/manifest-Endpunkte nach Vertrag
+ *  - createModuleServer : HTTP-Server, der den gesamten Vertrag verdrahtet
  *
  * Sicherheitsregeln:
  *  - Module lauschen nur auf 127.0.0.1 (nie öffentlich erreichbar)
  *  - Der Gateway entfernt das Session-Cookie vor dem Proxy
- * - Identitäts-Header werden vom Gateway gesetzt, nicht vom Client
+ *  - Identitäts-Header werden ausschließlich vom Gateway gesetzt
+ *  - Logs enthalten niemals Passwörter, Tokens oder personenbezogene Daten
  */
 
+const http = require('node:http');
+const fs = require('node:fs');
+
 /** Identitäts-Header, die der Modul-Gateway setzt. */
-const GATEWAY_HEADERS = {
+const GATEWAY_HEADERS = Object.freeze({
   userId: 'x-user-id',
   username: 'x-user-username',
   displayName: 'x-user-display-name',
   role: 'x-user-role',
-};
+});
 
-/** Vom Gateway übergebene Benutzer-Identität. */
+/** Erlaubte Plattform-Rollen. */
-// interface GatewayIdentity {
+const PLATFORM_ROLES = Object.freeze(['ADMIN', 'USER']);
-//   userId: string;
+
-//   username: string;
+/** Schlüssel, die beim Logging geschwärzt werden. */
-//   displayName: string;
+const SENSITIVE_KEYS = Object.freeze([
-//   role: 'ADMIN' | 'USER';
+  'password',
-// }
+  'passwort',
+  'token',
+  'secret',
+  'authorization',
+  'cookie',
+  'apikey',
+  'api_key',
+]);
+
+/** Liest einen Header case-insensitive (erster Wert). */
+function readHeader(headers, name) {
+  const lowerName = name.toLowerCase();
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === lowerName) {
+      return Array.isArray(value) ? value[0] ?? null : value ?? null;
+    }
+  }
+  return null;
+}
 
 /**
  * Extrahiert die Benutzer-Identität aus den Gateway-Headern.
- * @returns Identität oder null, wenn der Request nicht über den
+ * @returns {object|null} Identität oder null, wenn der Request nicht
- *          Gateway kam (z. B. direkter Aufruf ohne Plattform).
+ *   über den Gateway kam (z. B. direkter Aufruf ohne Plattform).
  */
 function extractIdentity(headers) {
   const userId = readHeader(headers, GATEWAY_HEADERS.userId);
@@ -44,40 +75,30 @@ function extractIdentity(headers) {
   if (!userId || !username || !role) {
     return null;
   }
-  if (role !== 'ADMIN' && role !== 'USER') {
+  if (!PLATFORM_ROLES.includes(role)) {
     return null;
   }
 
   return { userId, username, displayName: displayName ?? username, role };
 }
 
-/** Liest einen Header (case-insensitive, erster Wert). */
-function readHeader(headers, name) {
-  const lowerName = name.toLowerCase();
-  for (const [key, value] of Object.entries(headers)) {
-    if (key.toLowerCase() === lowerName) {
-      if (Array.isArray(value)) {
-        return value[0] ?? null;
-      }
-      return value ?? null;
-    }
-  }
-  return null;
-}
-
-/**
- * Standard-Antworten des Modul-API-Vertrags (Phase 6):
- * Jedes Modul muss diese drei Endpunkte bereitstellen:
- *   GET /health        → Liveness/Readiness
- *   GET /api/manifest  → Manifest zur Laufzeit
- *   GET /api/me        → Aktueller Benutzer (vom Gateway übergeben)
- */
-
 /** Erstellt die /health-Antwort nach Vertrag. */
 function healthResponse(moduleId, version) {
   return { moduleId, version, status: 'healthy' };
 }
 
+/** Erstellt die /api/manifest-Antwort nach Vertrag. */
+function manifestResponse(manifest) {
+  return {
+    moduleId: manifest.id,
+    name: manifest.name,
+    version: manifest.version,
+    slug: manifest.slug,
+    apiVersion: manifest.apiVersion,
+    status: 'healthy',
+  };
+}
+
 /** Erstellt die /api/me-Antwort nach Vertrag. */
 function meResponse(identity, moduleId, permissions = []) {
   return {
@@ -92,9 +113,235 @@ function meResponse(identity, moduleId, permissions = []) {
   };
 }
 
+/**
+ * Lädt und validiert ein Modul-Manifest (module.json).
+ * @param {string} manifestPath Absoluter Pfad zur module.json
+ * @returns {object} Validiertes, eingefrorenes Manifest
+ * @throws {Error} Bei fehlender/ungültiger Datei
+ */
+function loadManifest(manifestPath) {
+  let raw;
+  try {
+    raw = fs.readFileSync(manifestPath, 'utf8');
+  } catch (error) {
+    throw new Error(`Modul-Manifest nicht lesbar: ${manifestPath} (${error.message})`);
+  }
+
+  let manifest;
+  try {
+    manifest = JSON.parse(raw);
+  } catch (error) {
+    throw new Error(`Modul-Manifest ist kein gültiges JSON: ${error.message}`);
+  }
+
+  const requiredFields = ['id', 'name', 'version', 'slug', 'port', 'healthcheck'];
+  const missing = requiredFields.filter((field) => manifest[field] === undefined);
+  if (missing.length > 0) {
+    throw new Error(`Modul-Manifest unvollständig, fehlt: ${missing.join(', ')}`);
+  }
+  if (manifest.runtime !== 'node') {
+    throw new Error(`Nicht unterstützte Runtime: ${manifest.runtime} (erwartet: node)`);
+  }
+  if (manifest.apiVersion !== 'v1') {
+    throw new Error(`Nicht unterstützte apiVersion: ${manifest.apiVersion} (erwartet: v1)`);
+  }
+
+  return Object.freeze({ ...manifest });
+}
+
+/**
+ * Lädt die Laufzeit-Konfiguration eines Moduls.
+ * Der Prozess-Manager setzt PORT; PLATFORM_INTERNAL_URL ist optional.
+ */
+function loadModuleConfig(env = process.env) {
+  return Object.freeze({
+    port: Number(env.PORT ?? 0),
+    nodeEnv: env.NODE_ENV ?? 'production',
+    platformBaseUrl: env.PLATFORM_INTERNAL_URL ?? 'http://127.0.0.1:3000',
+    serviceToken: env.MODULE_SERVICE_TOKEN ?? null,
+  });
+}
+
+/** Schwärzt sensible Schlüssel in Log-Daten (rekursiv, flach begrenzt). */
+function redactSensitive(data) {
+  if (data === null || typeof data !== 'object') {
+    return data;
+  }
+  const redacted = Array.isArray(data) ? [] : {};
+  for (const [key, value] of Object.entries(data)) {
+    if (SENSITIVE_KEYS.includes(key.toLowerCase())) {
+      redacted[key] = '[geschwärzt]';
+    } else if (value !== null && typeof value === 'object') {
+      redacted[key] = redactSensitive(value);
+    } else {
+      redacted[key] = value;
+    }
+  }
+  return redacted;
+}
+
+/**
+ * Erstellt einen strukturierten Logger (JSON-Zeilen auf stdout/stderr).
+ * Logs helfen beim Debuggen und enthalten niemals Secrets.
+ */
+function createLogger(options = {}) {
+  const moduleId = options.moduleId ?? 'unbekannt';
+  const minimumLevel = options.level ?? (options.debug ? 'debug' : 'info');
+  const levels = { debug: 10, info: 20, warn: 30, error: 40 };
+
+  function write(level, message, data) {
+    if (levels[level] < levels[minimumLevel]) {
+      return;
+    }
+    const entry = {
+      ts: new Date().toISOString(),
+      level,
+      moduleId,
+      message,
+      ...(data !== undefined ? { data: redactSensitive(data) } : {}),
+    };
+    const line = JSON.stringify(entry);
+    if (level === 'error' || level === 'warn') {
+      console.error(line);
+    } else {
+      console.log(line);
+    }
+  }
+
+  return {
+    debug: (message, data) => write('debug', message, data),
+    info: (message, data) => write('info', message, data),
+    warn: (message, data) => write('warn', message, data),
+    error: (message, data) => write('error', message, data),
+  };
+}
+
+/**
+ * HTTP-Client für Aufrufe vom Modul zur Plattform (internes Netz).
+ * Der Plattform-Service-Token wird per Umgebungsvariable übergeben,
+ * sobald die Plattform Service-Endpunkte bereitstellt.
+ */
+function createPlatformClient(options = {}) {
+  const config = loadModuleConfig();
+  const baseUrl = options.baseUrl ?? config.platformBaseUrl;
+  const serviceToken = options.serviceToken ?? config.serviceToken;
+  const timeoutMs = options.timeoutMs ?? 5_000;
+
+  async function request(method, requestPath, body) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await fetch(`${baseUrl}${requestPath}`, {
+        method,
+        headers: {
+          Accept: 'application/json',
+          ...(body !== undefined ? { 'Content-Type': 'application/json' } : {}),
+          ...(serviceToken ? { Authorization: `Bearer ${serviceToken}` } : {}),
+        },
+        body: body !== undefined ? JSON.stringify(body) : undefined,
+        signal: controller.signal,
+      });
+      if (!response.ok) {
+        throw new Error(`Plattform-Aufruf fehlgeschlagen: ${method} ${requestPath} → HTTP ${response.status}`);
+      }
+      return await response.json();
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+
+  return {
+    get: (requestPath) => request('GET', requestPath),
+    post: (requestPath, body) => request('POST', requestPath, body),
+    patch: (requestPath, body) => request('PATCH', requestPath, body),
+    delete: (requestPath) => request('DELETE', requestPath),
+  };
+}
+
+/**
+ * Erstellt einen HTTP-Server, der den vollständigen Modul-API-Vertrag
+ * verdrahtet:
+ *   GET /health        → Liveness/Readiness
+ *   GET /api/manifest  → Manifest zur Laufzeit
+ *   GET /api/me        → Aktueller Benutzer (vom Gateway übergeben)
+ *   alles andere       → options.routes(req, res, context)
+ *
+ * @param {object} options
+ *   manifest      – validiertes Manifest (loadManifest)
+ *   routes        – (req, res, context) für fachliche Endpunkte
+ *   permissions   – Modulrechte für /api/me (Default: [])
+ *   logger        – Logger-Instanz (Default: createLogger)
+ *   identityRequired – 401 für fachliche Endpunkte ohne Identität (Default: true)
+ * @returns {http.Server} Noch nicht gestarteter Server
+ */
+function createModuleServer(options) {
+  const manifest = options.manifest;
+  const routes = options.routes ?? null;
+  const permissions = options.permissions ?? [];
+  const logger = options.logger ?? createLogger({ moduleId: manifest.id });
+  const identityRequired = options.identityRequired ?? true;
+
+  function sendJson(response, status, body) {
+    response.writeHead(status, { 'Content-Type': 'application/json' });
+    response.end(JSON.stringify(body));
+  }
+
+  function handleRequest(request, response) {
+    const url = new URL(request.url ?? '/', `http://127.0.0.1:${manifest.port}`);
+    const pathname = url.pathname;
+
+    if (request.method === 'GET' && pathname === '/health') {
+      sendJson(response, 200, healthResponse(manifest.id, manifest.version));
+      return;
+    }
+    if (request.method === 'GET' && pathname === '/api/manifest') {
+      sendJson(response, 200, manifestResponse(manifest));
+      return;
+    }
+    if (request.method === 'GET' && pathname === '/api/me') {
+      const identity = extractIdentity(request.headers);
+      if (!identity) {
+        sendJson(response, 401, { statusCode: 401, message: 'Keine Identität übergeben' });
+        return;
+      }
+      sendJson(response, 200, meResponse(identity, manifest.id, permissions));
+      return;
+    }
+
+    const identity = extractIdentity(request.headers);
+    if (identityRequired && routes && !identity) {
+      sendJson(response, 401, { statusCode: 401, message: 'Keine Identität übergeben' });
+      return;
+    }
+
+    if (routes) {
+      try {
+        routes(request, response, { identity, path: pathname, url, logger });
+      } catch (error) {
+        logger.error('Fehler im Routen-Handler', { path: pathname, error: error.message });
+        if (!response.headersSent) {
+          sendJson(response, 500, { statusCode: 500, message: 'Interner Modulfehler' });
+        }
+      }
+      return;
+    }
+
+    sendJson(response, 404, { statusCode: 404, message: 'Nicht gefunden' });
+  }
+
+  return http.createServer(handleRequest);
+}
+
 module.exports = {
   GATEWAY_HEADERS,
+  PLATFORM_ROLES,
   extractIdentity,
   healthResponse,
+  manifestResponse,
   meResponse,
+  loadManifest,
+  loadModuleConfig,
+  createLogger,
+  createPlatformClient,
+  createModuleServer,
 };

modules/demo/backend/server.js

@@ -1,70 +1,40 @@
 /**
- * Demo-Modul: Referenzimplementierung des Modul-API-Vertrags (Phase 6).
+ * Demo-Modul: Referenzimplementierung auf Basis des Modul-SDKs (Phase 8).
  * Läuft als eigener Node-Prozess im Management-Container (Port via ENV PORT).
  *
- * Vertrag (verbindlich für alle Module):
+ * Der vollständige Modul-API-Vertrag wird vom SDK verdrahtet:
  *   GET /health        → Liveness/Readiness
  *   GET /api/manifest  → Manifest zur Laufzeit
  *   GET /api/me        → Aktueller Benutzer (vom Gateway übergeben)
- *
+ *   GET /              → fachliche Route (routes-Handler)
- * Die Identität stammt ausschließlich aus den Gateway-Headern
- * (siehe platform-module-sdk.js) – niemals aus der URL oder dem Body.
  */
 
-const http = require('node:http');
+const path = require('node:path');
 const {
-  extractIdentity,
+  createModuleServer,
-  healthResponse,
+  loadManifest,
-  meResponse,
+  createLogger,
 } = require('./platform-module-sdk');
 
-const PORT = Number(process.env.PORT ?? 41001);
+const manifest = loadManifest(path.join(__dirname, '..', 'module.json'));
+const logger = createLogger({ moduleId: manifest.id });
+const port = Number(process.env.PORT ?? manifest.port);
 
-/** Manifest des Moduls (identisch zu module.json). */
+const server = createModuleServer({
-const MANIFEST = {
+  manifest,
-  moduleId: 'demo',
+  logger,
-  version: '1.0.0',
+  permissions: ['demo.read'],
-  status: 'healthy',
+  routes: (request, response, context) => {
-};
+    if (request.method === 'GET' && context.path === '/') {
-
-const server = http.createServer((request, response) => {
-  const url = new URL(request.url ?? '/', `http://127.0.0.1:${PORT}`);
-
-  if (url.pathname === '/health') {
-    response.writeHead(200, { 'Content-Type': 'application/json' });
-    response.end(JSON.stringify(healthResponse(MANIFEST.moduleId, MANIFEST.version)));
-    return;
-  }
-
-  if (url.pathname === '/api/manifest') {
-    response.writeHead(200, { 'Content-Type': 'application/json' });
-    response.end(JSON.stringify(MANIFEST));
-    return;
-  }
-
-  if (url.pathname === '/api/me') {
-    const identity = extractIdentity(request.headers);
-    if (!identity) {
-      // Request kam nicht über den Modul-Gateway → keine Identität.
-      response.writeHead(401, { 'Content-Type': 'application/json' });
-      response.end(JSON.stringify({ statusCode: 401, message: 'Keine Identität übergeben' }));
-      return;
-    }
-    response.writeHead(200, { 'Content-Type': 'application/json' });
-    response.end(JSON.stringify(meResponse(identity, MANIFEST.moduleId, ['demo.read'])));
-    return;
-  }
-
-  if (url.pathname === '/') {
       response.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
       response.end('Demo-Modul läuft');
       return;
     }
-
     response.writeHead(404, { 'Content-Type': 'application/json' });
     response.end(JSON.stringify({ statusCode: 404, message: 'Nicht gefunden' }));
+  },
 });
 
-server.listen(PORT, '127.0.0.1', () => {
+server.listen(port, '127.0.0.1', () => {
-  console.log(`Demo-Modul läuft auf Port ${PORT}`);
+  logger.info('Demo-Modul gestartet', { port });
 });

packages/platform-module-sdk/README.md

@@ -0,0 +1,111 @@
+# platform-module-sdk
+
+Offizielles SDK für MPM-Module (Phase 8). Es verdrahtet den verbindlichen
+Modul-API-Vertrag und stellt Authentifizierung, Konfiguration, Logging und
+einen Plattform-API-Client bereit.
+
+## Installation (Vendor-Pattern)
+
+Module sind selbstständige ZIP-Pakete. Das SDK wird als **eine Datei**
+(`index.js`) in das Modul-Paket kopiert (z. B. `backend/platform-module-sdk.js`)
+und per `require` geladen. Dadurch bleiben Module ohne npm-Registry lauffähig.
+
+```text
+mein-modul/
+├── module.json
+├── backend/
+│   ├── server.js                  # Einstiegspunkt (Manifest: entrypoint)
+│   └── platform-module-sdk.js     # vendored SDK (Kopie von index.js)
+└── README.md
+```
+
+## Schnellstart
+
+```js
+'use strict';
+
+const path = require('node:path');
+const {
+  createModuleServer,
+  loadManifest,
+  createLogger,
+} = require('./platform-module-sdk');
+
+const manifest = loadManifest(path.join(__dirname, '..', 'module.json'));
+const logger = createLogger({ moduleId: manifest.id });
+const port = Number(process.env.PORT ?? manifest.port);
+
+const server = createModuleServer({
+  manifest,
+  logger,
+  permissions: ['meinmodul.read'],
+  routes: (request, response, context) => {
+    // context.identity → { userId, username, displayName, role }
+    // context.path     → URL-Pfad
+    if (request.method === 'GET' && context.path === '/aufgaben') {
+      response.writeHead(200, { 'Content-Type': 'application/json' });
+      response.end(JSON.stringify({ aufgaben: [] }));
+      return;
+    }
+    response.writeHead(404, { 'Content-Type': 'application/json' });
+    response.end(JSON.stringify({ statusCode: 404, message: 'Nicht gefunden' }));
+  },
+});
+
+server.listen(port, '127.0.0.1', () => {
+  logger.info(`Modul gestartet`, { port });
+});
+```
+
+Der Server verdrahtet automatisch den Vertrag:
+
+| Endpunkt | Verhalten |
+|---|---|
+| `GET /health` | 200 `{ moduleId, version, status: "healthy" }` |
+| `GET /api/manifest` | 200 Manifest + Status |
+| `GET /api/me` | 200 Identität vom Gateway (401 ohne Identität) |
+| fachliche Routen | `options.routes(...)`; ohne Identität 401 (`identityRequired`) |
+
+## API
+
+### `extractIdentity(headers)`
+Liest die Benutzer-Identität aus den Gateway-Headern (`x-user-id`,
+`x-user-username`, `x-user-display-name`, `x-user-role`). Case-insensitive;
+`null`, wenn der Request nicht über den Gateway kam.
+
+### `loadManifest(manifestPath)`
+Lädt und validiert `module.json` (Pflichtfelder, Runtime `node`, apiVersion `v1`).
+
+### `loadModuleConfig(env?)`
+Laufzeit-Konfiguration: `port` (ENV `PORT`), `nodeEnv`, `platformBaseUrl`
+(ENV `PLATFORM_INTERNAL_URL`, Default `http://127.0.0.1:3000`), `serviceToken`.
+
+### `createLogger({ moduleId, level })`
+Strukturierte JSON-Logs (`debug/info/warn/error`). Sensible Schlüssel
+(Passwort, Token, Secret, Cookie, …) werden automatisch geschwärzt.
+
+### `createPlatformClient({ baseUrl, serviceToken, timeoutMs }))`
+HTTP-Client für interne Aufrufe zur Plattform (`get/post/patch/delete`).
+Wirft bei Nicht-2xx einen Fehler mit Statuscode.
+
+### `createModuleServer(options)`
+Siehe Schnellstart. Optionen: `manifest`, `routes`, `permissions`,
+`logger`, `identityRequired` (Default `true` – sicherer Default).
+
+## Tests
+
+Die SDK-Tests laufen im Backend-Test-Suite
+(`apps/platform-backend/test/platform-module-sdk.spec.ts`):
+
+```bash
+cd apps/platform-backend && npm test
+```
+
+## Sicherheitsregeln für Modul-Autoren
+
+- Nur auf `127.0.0.1` lauschen (der Gateway ist der einzige Zugang).
+- Identität ausschließlich über `extractIdentity` beziehen – niemals aus
+  URL, Body oder eigenen Headern vertrauen.
+- Keine Plattform-Secrets erwarten: Der Prozess-Manager übergibt nur
+  `PATH`, `NODE_ENV` und `PORT`.
+- Logs niemals Passwörter/Tokens/personenbezogene Daten schreiben lassen.

packages/platform-module-sdk/index.js

@@ -0,0 +1,347 @@
+'use strict';
+
+/**
+ * MPM Modul-SDK (Phase 8)
+ * =======================
+ * Standardbibliothek für MPM-Module. Ein Modul ist ein eigenständiger
+ * Node-Prozess innerhalb des Management-Containers, der ausschließlich
+ * über den Modul-Gateway der Plattform erreichbar ist.
+ *
+ * Das SDK stellt bereit:
+ *  - Authentication  : Identität aus den sicheren Gateway-Headern
+ *  - Current User    : /api/me-Antwort nach Vertrag
+ *  - Permissions     : Modulrechte in der /api/me-Antwort
+ *  - API Client      : HTTP-Client für Plattform-Aufrufe (intern)
+ *  - Module Config   : Manifest-Laden und Laufzeit-Konfiguration
+ *  - Logging         : Strukturiertes Logging ohne Secrets
+ *  - Healthcheck     : /health- und /api/manifest-Endpunkte nach Vertrag
+ *  - createModuleServer : HTTP-Server, der den gesamten Vertrag verdrahtet
+ *
+ * Sicherheitsregeln:
+ *  - Module lauschen nur auf 127.0.0.1 (nie öffentlich erreichbar)
+ *  - Der Gateway entfernt das Session-Cookie vor dem Proxy
+ *  - Identitäts-Header werden ausschließlich vom Gateway gesetzt
+ *  - Logs enthalten niemals Passwörter, Tokens oder personenbezogene Daten
+ */
+
+const http = require('node:http');
+const fs = require('node:fs');
+
+/** Identitäts-Header, die der Modul-Gateway setzt. */
+const GATEWAY_HEADERS = Object.freeze({
+  userId: 'x-user-id',
+  username: 'x-user-username',
+  displayName: 'x-user-display-name',
+  role: 'x-user-role',
+});
+
+/** Erlaubte Plattform-Rollen. */
+const PLATFORM_ROLES = Object.freeze(['ADMIN', 'USER']);
+
+/** Schlüssel, die beim Logging geschwärzt werden. */
+const SENSITIVE_KEYS = Object.freeze([
+  'password',
+  'passwort',
+  'token',
+  'secret',
+  'authorization',
+  'cookie',
+  'apikey',
+  'api_key',
+]);
+
+/** Liest einen Header case-insensitive (erster Wert). */
+function readHeader(headers, name) {
+  const lowerName = name.toLowerCase();
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === lowerName) {
+      return Array.isArray(value) ? value[0] ?? null : value ?? null;
+    }
+  }
+  return null;
+}
+
+/**
+ * Extrahiert die Benutzer-Identität aus den Gateway-Headern.
+ * @returns {object|null} Identität oder null, wenn der Request nicht
+ *   über den Gateway kam (z. B. direkter Aufruf ohne Plattform).
+ */
+function extractIdentity(headers) {
+  const userId = readHeader(headers, GATEWAY_HEADERS.userId);
+  const username = readHeader(headers, GATEWAY_HEADERS.username);
+  const displayName = readHeader(headers, GATEWAY_HEADERS.displayName);
+  const role = readHeader(headers, GATEWAY_HEADERS.role);
+
+  if (!userId || !username || !role) {
+    return null;
+  }
+  if (!PLATFORM_ROLES.includes(role)) {
+    return null;
+  }
+
+  return { userId, username, displayName: displayName ?? username, role };
+}
+
+/** Erstellt die /health-Antwort nach Vertrag. */
+function healthResponse(moduleId, version) {
+  return { moduleId, version, status: 'healthy' };
+}
+
+/** Erstellt die /api/manifest-Antwort nach Vertrag. */
+function manifestResponse(manifest) {
+  return {
+    moduleId: manifest.id,
+    name: manifest.name,
+    version: manifest.version,
+    slug: manifest.slug,
+    apiVersion: manifest.apiVersion,
+    status: 'healthy',
+  };
+}
+
+/** Erstellt die /api/me-Antwort nach Vertrag. */
+function meResponse(identity, moduleId, permissions = []) {
+  return {
+    user: {
+      id: identity.userId,
+      username: identity.username,
+      displayName: identity.displayName,
+      platformRole: identity.role,
+    },
+    module: { id: moduleId },
+    permissions,
+  };
+}
+
+/**
+ * Lädt und validiert ein Modul-Manifest (module.json).
+ * @param {string} manifestPath Absoluter Pfad zur module.json
+ * @returns {object} Validiertes, eingefrorenes Manifest
+ * @throws {Error} Bei fehlender/ungültiger Datei
+ */
+function loadManifest(manifestPath) {
+  let raw;
+  try {
+    raw = fs.readFileSync(manifestPath, 'utf8');
+  } catch (error) {
+    throw new Error(`Modul-Manifest nicht lesbar: ${manifestPath} (${error.message})`);
+  }
+
+  let manifest;
+  try {
+    manifest = JSON.parse(raw);
+  } catch (error) {
+    throw new Error(`Modul-Manifest ist kein gültiges JSON: ${error.message}`);
+  }
+
+  const requiredFields = ['id', 'name', 'version', 'slug', 'port', 'healthcheck'];
+  const missing = requiredFields.filter((field) => manifest[field] === undefined);
+  if (missing.length > 0) {
+    throw new Error(`Modul-Manifest unvollständig, fehlt: ${missing.join(', ')}`);
+  }
+  if (manifest.runtime !== 'node') {
+    throw new Error(`Nicht unterstützte Runtime: ${manifest.runtime} (erwartet: node)`);
+  }
+  if (manifest.apiVersion !== 'v1') {
+    throw new Error(`Nicht unterstützte apiVersion: ${manifest.apiVersion} (erwartet: v1)`);
+  }
+
+  return Object.freeze({ ...manifest });
+}
+
+/**
+ * Lädt die Laufzeit-Konfiguration eines Moduls.
+ * Der Prozess-Manager setzt PORT; PLATFORM_INTERNAL_URL ist optional.
+ */
+function loadModuleConfig(env = process.env) {
+  return Object.freeze({
+    port: Number(env.PORT ?? 0),
+    nodeEnv: env.NODE_ENV ?? 'production',
+    platformBaseUrl: env.PLATFORM_INTERNAL_URL ?? 'http://127.0.0.1:3000',
+    serviceToken: env.MODULE_SERVICE_TOKEN ?? null,
+  });
+}
+
+/** Schwärzt sensible Schlüssel in Log-Daten (rekursiv, flach begrenzt). */
+function redactSensitive(data) {
+  if (data === null || typeof data !== 'object') {
+    return data;
+  }
+  const redacted = Array.isArray(data) ? [] : {};
+  for (const [key, value] of Object.entries(data)) {
+    if (SENSITIVE_KEYS.includes(key.toLowerCase())) {
+      redacted[key] = '[geschwärzt]';
+    } else if (value !== null && typeof value === 'object') {
+      redacted[key] = redactSensitive(value);
+    } else {
+      redacted[key] = value;
+    }
+  }
+  return redacted;
+}
+
+/**
+ * Erstellt einen strukturierten Logger (JSON-Zeilen auf stdout/stderr).
+ * Logs helfen beim Debuggen und enthalten niemals Secrets.
+ */
+function createLogger(options = {}) {
+  const moduleId = options.moduleId ?? 'unbekannt';
+  const minimumLevel = options.level ?? (options.debug ? 'debug' : 'info');
+  const levels = { debug: 10, info: 20, warn: 30, error: 40 };
+
+  function write(level, message, data) {
+    if (levels[level] < levels[minimumLevel]) {
+      return;
+    }
+    const entry = {
+      ts: new Date().toISOString(),
+      level,
+      moduleId,
+      message,
+      ...(data !== undefined ? { data: redactSensitive(data) } : {}),
+    };
+    const line = JSON.stringify(entry);
+    if (level === 'error' || level === 'warn') {
+      console.error(line);
+    } else {
+      console.log(line);
+    }
+  }
+
+  return {
+    debug: (message, data) => write('debug', message, data),
+    info: (message, data) => write('info', message, data),
+    warn: (message, data) => write('warn', message, data),
+    error: (message, data) => write('error', message, data),
+  };
+}
+
+/**
+ * HTTP-Client für Aufrufe vom Modul zur Plattform (internes Netz).
+ * Der Plattform-Service-Token wird per Umgebungsvariable übergeben,
+ * sobald die Plattform Service-Endpunkte bereitstellt.
+ */
+function createPlatformClient(options = {}) {
+  const config = loadModuleConfig();
+  const baseUrl = options.baseUrl ?? config.platformBaseUrl;
+  const serviceToken = options.serviceToken ?? config.serviceToken;
+  const timeoutMs = options.timeoutMs ?? 5_000;
+
+  async function request(method, requestPath, body) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await fetch(`${baseUrl}${requestPath}`, {
+        method,
+        headers: {
+          Accept: 'application/json',
+          ...(body !== undefined ? { 'Content-Type': 'application/json' } : {}),
+          ...(serviceToken ? { Authorization: `Bearer ${serviceToken}` } : {}),
+        },
+        body: body !== undefined ? JSON.stringify(body) : undefined,
+        signal: controller.signal,
+      });
+      if (!response.ok) {
+        throw new Error(`Plattform-Aufruf fehlgeschlagen: ${method} ${requestPath} → HTTP ${response.status}`);
+      }
+      return await response.json();
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+
+  return {
+    get: (requestPath) => request('GET', requestPath),
+    post: (requestPath, body) => request('POST', requestPath, body),
+    patch: (requestPath, body) => request('PATCH', requestPath, body),
+    delete: (requestPath) => request('DELETE', requestPath),
+  };
+}
+
+/**
+ * Erstellt einen HTTP-Server, der den vollständigen Modul-API-Vertrag
+ * verdrahtet:
+ *   GET /health        → Liveness/Readiness
+ *   GET /api/manifest  → Manifest zur Laufzeit
+ *   GET /api/me        → Aktueller Benutzer (vom Gateway übergeben)
+ *   alles andere       → options.routes(req, res, context)
+ *
+ * @param {object} options
+ *   manifest      – validiertes Manifest (loadManifest)
+ *   routes        – (req, res, context) für fachliche Endpunkte
+ *   permissions   – Modulrechte für /api/me (Default: [])
+ *   logger        – Logger-Instanz (Default: createLogger)
+ *   identityRequired – 401 für fachliche Endpunkte ohne Identität (Default: true)
+ * @returns {http.Server} Noch nicht gestarteter Server
+ */
+function createModuleServer(options) {
+  const manifest = options.manifest;
+  const routes = options.routes ?? null;
+  const permissions = options.permissions ?? [];
+  const logger = options.logger ?? createLogger({ moduleId: manifest.id });
+  const identityRequired = options.identityRequired ?? true;
+
+  function sendJson(response, status, body) {
+    response.writeHead(status, { 'Content-Type': 'application/json' });
+    response.end(JSON.stringify(body));
+  }
+
+  function handleRequest(request, response) {
+    const url = new URL(request.url ?? '/', `http://127.0.0.1:${manifest.port}`);
+    const pathname = url.pathname;
+
+    if (request.method === 'GET' && pathname === '/health') {
+      sendJson(response, 200, healthResponse(manifest.id, manifest.version));
+      return;
+    }
+    if (request.method === 'GET' && pathname === '/api/manifest') {
+      sendJson(response, 200, manifestResponse(manifest));
+      return;
+    }
+    if (request.method === 'GET' && pathname === '/api/me') {
+      const identity = extractIdentity(request.headers);
+      if (!identity) {
+        sendJson(response, 401, { statusCode: 401, message: 'Keine Identität übergeben' });
+        return;
+      }
+      sendJson(response, 200, meResponse(identity, manifest.id, permissions));
+      return;
+    }
+
+    const identity = extractIdentity(request.headers);
+    if (identityRequired && routes && !identity) {
+      sendJson(response, 401, { statusCode: 401, message: 'Keine Identität übergeben' });
+      return;
+    }
+
+    if (routes) {
+      try {
+        routes(request, response, { identity, path: pathname, url, logger });
+      } catch (error) {
+        logger.error('Fehler im Routen-Handler', { path: pathname, error: error.message });
+        if (!response.headersSent) {
+          sendJson(response, 500, { statusCode: 500, message: 'Interner Modulfehler' });
+        }
+      }
+      return;
+    }
+
+    sendJson(response, 404, { statusCode: 404, message: 'Nicht gefunden' });
+  }
+
+  return http.createServer(handleRequest);
+}
+
+module.exports = {
+  GATEWAY_HEADERS,
+  PLATFORM_ROLES,
+  extractIdentity,
+  healthResponse,
+  manifestResponse,
+  meResponse,
+  loadManifest,
+  loadModuleConfig,
+  createLogger,
+  createPlatformClient,
+  createModuleServer,
+};

packages/platform-module-sdk/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "platform-module-sdk",
+  "version": "1.0.0",
+  "description": "MPM Modul-SDK: Authentifizierung, Vertrag-Endpunkte, Config, Logging und API-Client für MPM-Module",
+  "main": "index.js",
+  "files": [
+    "index.js",
+    "README.md"
+  ],
+  "keywords": [
+    "mpm",
+    "module",
+    "sdk"
+  ],
+  "license": "UNLICENSED",
+  "private": true,
+  "engines": {
+    "node": ">=20"
+  }
+}