@iddp/create-vefk-app 0.7.0

package/README.md

@@ -0,0 +1,151 @@
+# create-vefk-app
+
+Scaffolder der **VEFK-Tools-Suite**: erzeugt aus `vefk-app-template` ein neues,
+sofort startbares Tool — Template klonen, Platzhalter ersetzen (Toolname,
+Markenfarbe, Auth-Profil, 2FA/Mail, erster Mandant, Server-Slug, Port-Paar,
+lokale Dev-Ports), `backend/.env` anlegen, `git init` + Initial-Commit. Das Ergebnis ist für die **Zwei-Server-Welt** (test/prod,
+`deploy`-User, `127.0.0.1`) vorbereitet — `deploy.sh`, `ecosystem.config.cjs` und
+`CLAUDE-DEPLOYMENT.md` sind ausgefüllt.
+
+```bash
+npm create @iddp/vefk-app@latest <ordner>
+npm create @iddp/vefk-app@latest .          # in den aktuellen, leeren Ordner
+# fragt interaktiv: Zielordner (. = aktueller Ordner), Anzeigename, Auth-Profil
+# (Standard both), Login ohne Mandant (E-Mail + Passwort oder Magic-Code), 2FA,
+# Markenfarbe, erster Mandant, Server-Slug, Prod-Port (aus dem Port-Register — dort
+# auch eintragen!), npm install (Standard ja) …
+```
+
+Login-Wege, die das Ergebnis kennt (Kit ≥ 0.6.0): je Mandant E-Mail + Passwort (+ 2FA),
+E-Mail-Code für Nutzer, die `create-user` **ohne Passwort** angelegt hat, und ein
+**Mandanten-Zugang** nur mit Passwort (`npm run zugang`); ohne Mandant E-Mail + Passwort
+(`--login password`) oder Magic-Code mit Selbst-Registrierung (`--login magic`).
+
+**Ordnername = Server-Slug** (`/opt/<slug>`, PM2 `<slug>`, `<slug>.<domain>`, Paketnamen):
+nur `a-z`, `0-9`, `-`, kein Präfix-Zwang — `gbu`, `seminar`, `vefkev-user` sind gute
+Namen. `--slug` übersteuert, wenn der Ordner lokal anders heißen soll. Ein schon
+vorhandener Ordner ist als Ziel erlaubt, solange er leer ist; sonst bricht das CLI ab,
+ohne etwas anzufassen.
+
+Solange das Paket noch nicht auf npm liegt, geht derselbe Aufruf direkt vom Repo:
+
+```bash
+npx github:esgoet/create-vefk-app <ordner>
+```
+
+## Voraussetzungen
+
+- Node ≥ 20.11; die Suite läuft lokal und auf den Servern auf **Node 24** (`.nvmrc`). Vor dem Aufruf
+  dieselbe Version aktiv haben (`fnm use 24` / `nvm use 24`): native Module (better-sqlite3, bcrypt) werden für das aktive Node gebaut;
+  wechselt nvm nach dem `cd` ins Projekt auf eine andere Version, startet das Backend mit
+  `ERR_DLOPEN_FAILED`. Der Scaffolder warnt bei Abweichung und nennt `npm --prefix backend rebuild`.
+- `git` mit Zugriff auf das private Repo `esgoet/vefk-app-template`
+  (dieselben Credentials, die auch `npm install` für die `@iddp`-git-Dependencies braucht)
+
+## Optionen (für Skripte / nicht-interaktiv)
+
+```
+create-vefk-app [<ordner>] [Optionen]
+
+  --dir <pfad>           Zielordner (statt des Positionsarguments; `.` erlaubt)
+  --name <text>          Anzeigename (Header, Mail-Betreff)
+  --auth <profil>        tenant | generic | both (Standard: both)
+  --login <verfahren>    Login ohne Mandant (generic/both): magic (Code per E-Mail,
+                         Nutzer legen sich selbst an; Standard) | password (E-Mail + Passwort,
+                         Nutzer legt der Admin an — der „normale" Login)
+  --brand <#rrggbb>      Markenfarbe (helle Variante wird abgeleitet; --brand-light überschreibt)
+  --two-factor / --no-two-factor   E-Mail-2FA nach dem Passwort für Mandanten-Logins (tenant/both)
+                         bzw. den Passwort-Login (--login password); gilt nicht für Magic-Code
+                         und Mandanten-Zugang; pro Mandant später in /admin umschaltbar
+  --mail / --no-mail     SMTP-Block in .env.example einkommentieren
+  --tenant <slug>        erster Mandant (tenant/both)
+  --anmeldung <art>      erster Mandant: konto (E-Mail + Passwort / E-Mail-Code, Standard) |
+                         zugang (nur gemeinsames Mandanten-Passwort ohne E-Mail; Passwort danach per
+                         npm run zugang oder /admin setzen); später in /admin → Einstellungen umschaltbar
+  --generic-tenant <slug> optional: interner Slug des offenen Bereichs (Standard app, wird nicht gefragt)
+  --owner-email <mail>   optional (--login magic): weitere Adresse, die beim Auto-Anlegen admin wird
+                         (die Adressen aus --admin-email sind es ohnehin; wird nicht gefragt)
+  --admin-email <mail>   Admin-Bereich /admin (Google-Konto oder E-Mail-Code): darf sich anmelden;
+                         mehrfach oder Komma-getrennt (Standard: Betreiber-Adressen aus dem Template)
+  --daten <adapter>      sqlite (Standard: eine Datei backend/data/app.sqlite) | json (Datei je Collection)
+  --slug <slug>          Server-Slug → /opt/<slug>, PM2 <slug>, <slug>.<domain> (Standard: Ordnername)
+  --port <nnnn>          Prod-Port aus dem Port-Register, test = +1. Kein Standardwert:
+                         ohne --port bleiben die @@PORT_*@@-Token stehen und werden gemeldet.
+                         Lokal: Backend = Prod-Port, Vite = 51 + letzte zwei Stellen (3130 → 3130/5130)
+  --dev-port <nnnn>      lokaler Backend-Port, falls der Prod-Port lokal belegt ist (Vite folgt)
+  --template <pfad|url>  andere Template-Quelle (auch lokaler Pfad — gut zum Testen)
+  --install              nach dem Anlegen npm run install:all (Standard, auch mit --yes)
+  --no-install           … überspringen
+  --no-git               kein git init / Initial-Commit
+  --no-local-env         keine backend/.env anlegen (Standard: Kopie von .env.example mit
+                         NODE_ENV=development, VEFK_DEV_LOGIN=true, zufälligem SESSION_SECRET)
+  --yes                  nichts fragen, Standardwerte nehmen
+```
+
+Beispiele:
+
+```bash
+npx @iddp/create-vefk-app protokolle --name "Prüfprotokolle" \
+  --auth tenant --two-factor --brand "#0b5b52" --tenant kunde-a --port 3090 --yes
+
+# mandantenlos mit „normalem" Login (E-Mail + Passwort, kein Magic-Code):
+npx @iddp/create-vefk-app intern --name "Intern" --auth generic --login password --port 3092 --yes
+
+# in einen schon angelegten, leeren Ordner (Slug = Ordnername):
+mkdir vefkev-user && cd vefkev-user
+npx @iddp/create-vefk-app . --name "VEFK e.V. Mitglieder" --auth tenant --port 3130 --install --yes
+```
+
+## Was das CLI ersetzt
+
+| Stelle | Wert |
+|---|---|
+| `app.config.js` | Name, `authMode` (`tenant`/`generic`/`both`), `zweiFaktorDefault`, generic-Slug/`login`/`zweiFaktor`/Owner, Markenfarben |
+| `package.json` × 3 **+ beide `package-lock.json`** | Paketnamen **aus dem Slug** (`npm ci` prüft die Lock-Namen mit) |
+| `frontend/index.html`, `frontend/src/index.css` | `<title>`, `--iddp` / `--iddp-light` |
+| `.env.example` | `APP_NAME`, `SMTP_FROM` (+ SMTP-Block einkommentieren bei `--mail`), `PORT` = lokaler Dev-Port |
+| `frontend/vite.config.js`, `docs/08`, `CLAUDE-DEPLOYMENT.md` (Dev-Block) | lokale Dev-Ports (nur mit `--port`/`--dev-port`; sonst bleibt 3001/5173) |
+| `backend/.env` (neu, gitignored) | Kopie von `.env.example` mit Dev-Flags + zufälligem `SESSION_SECRET` — nie ausgegeben |
+| `deploy.sh`, `ecosystem.config.cjs`, `CLAUDE-DEPLOYMENT.md`, `docs/01`, `docs/07` | `@@APP@@` (Server-Slug), `@@APPNAME@@`, `@@PORT_PROD@@`/`@@PORT_TEST@@`, `@@DATUM@@`; Rest-Scan meldet vergessene Token in Wurzel + `docs/` |
+| `backend/data/tenants/<slug>/` | erster Mandant aus `_muster`, `zweiFaktor` explizit gesetzt |
+| `backend/data/tenants/beispiel/`, `.gitignore`, `frontend/src/App.jsx` | mit erstem Mandanten (oder `generic`): Demo-Mandant `beispiel` entfernt samt `.gitignore`-Whitelist (der erste Mandant ist ein echter Kunde und bleibt ungetrackt), Wurzel-Redirect `/` → `/<slug>` |
+| `README.md` | wird durch ein Projekt-README des neuen Tools ersetzt |
+
+Trifft eine Ersetzung nicht (weil sich das Template weiterentwickelt hat), bricht
+nichts ab — das CLI listet die Stelle am Ende als Warnung zum Nachprüfen.
+
+## Entwurfsentscheidungen
+
+- **`git clone` statt degit:** degit lädt GitHub-Tarballs und scheitert am privaten
+  Template-Repo ohne eigene Token-Konfiguration. `git clone --depth 1` + `.git`
+  entfernen nutzt die ohnehin eingerichteten Git-Credentials und kann zusätzlich
+  lokale Pfade (`--template ../vefk-app-template`).
+- **Zero-Dependency:** nur Node-Bordmittel (`node:util` parseArgs,
+  `node:readline/promises`, `node:test`) — Suite-Linie „nativ statt Extra-Deps".
+
+## Entwickeln & Testen
+
+```bash
+npm test                        # node:test — Unit + End-to-End gegen die Fixture
+node bin/create-vefk-app.js probe --yes --no-install --port 3090 --template ../vefk-app-template
+```
+
+Die Fixture (`test/fixtures/mini-template/`) friert die Template-Stellen ein, die
+das CLI anfasst. Ändert sich das Template an diesen Stellen, Fixture nachziehen.
+
+## Auf npm veröffentlichen
+
+Das Paket heißt `@iddp/create-vefk-app` (npm-Org `iddp`, `publishConfig.access: public`;
+`files`-Whitelist: nur `bin/`, `lib/`, README). Öffentlich sind der Scaffolder und
+`@iddp/vefk-app-kit`; Template und `@iddp/vefk-ui` bleiben private Repos.
+
+```bash
+npm login
+npm publish            # Browser-Verifizierung → läuft nur im eigenen Terminal
+npm view @iddp/create-vefk-app version
+```
+
+Danach funktioniert `npm create @iddp/vefk-app@latest` für alle, die Git-Zugriff auf das
+Template-Repo haben. Der frühere Name `create-vefk-app` (bis 0.6.0) ist per `npm deprecate`
+auf das neue Paket verwiesen. Falle: `npm create` nutzt den npx-Cache (`~/.npm/_npx`) —
+zum Testen immer `@latest` anhängen.

package/bin/create-vefk-app.js

@@ -0,0 +1,305 @@
+#!/usr/bin/env node
+// create-vefk-app — Scaffolder der VEFK-Tools-Suite.
+//
+// Erzeugt ein neues Tool aus vefk-app-template:
+//   1. Fragen stellen (oder Flags lesen)
+//   2. Template klonen (git clone --depth 1, .git entfernen)
+//   3. Platzhalter ersetzen (Name, Marke, Auth-Profil, 2FA/Mail, Mandant,
+//      Server-Slug + Port-Paar für deploy.sh/ecosystem.config.cjs/docs)
+//   4. git init + Initial-Commit (abwählbar), npm install (Standard, --no-install)
+//
+// Aufruf:  npm create @iddp/vefk-app@latest <ordner>
+//    oder: npx @iddp/create-vefk-app <ordner> [Flags]
+//    oder: npx @iddp/create-vefk-app . [Flags]        (in einen leeren Ordner)
+
+import { parseArgs } from "node:util";
+import { readFile } from "node:fs/promises";
+import { resolve, basename, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import process from "node:process";
+
+import { stelleFragen } from "../lib/fragen.js";
+import { kloneTemplate, loeseTemplateQuelle, pruefeZielordner, STANDARD_TEMPLATE } from "../lib/klonen.js";
+import { wendeAntwortenAn } from "../lib/ersetzen.js";
+import { initialisiereRepo } from "../lib/git.js";
+import { legeLokaleEnvAn } from "../lib/lokaleEnv.js";
+import { fuehreAus } from "../lib/prozesse.js";
+import { leiteDevPortsAb } from "../lib/validieren.js";
+
+const HILFE = `create-vefk-app — neues Tool der VEFK-Tools-Suite anlegen
+
+Aufruf:
+  npm create @iddp/vefk-app@latest <ordner>
+  npx @iddp/create-vefk-app <ordner> [Optionen]
+  npx @iddp/create-vefk-app . [Optionen]          # in den aktuellen (leeren) Ordner
+
+Der Ordnername ist zugleich der Server-Slug (/opt/<slug>, PM2, Domain) — nur
+a-z, 0-9, Bindestrich, kein Präfix-Zwang. Ein vorhandener Ordner muss leer sein.
+
+Ohne Optionen fragt das CLI interaktiv (bei der Ordner-Frage ist . der aktuelle
+Ordner). Optionen (für Skripte/CI):
+  --dir <pfad>           Zielordner (statt des Positionsarguments)
+  --name <text>          Anzeigename des Tools (Header, Mail-Betreff)
+  --auth <profil>        tenant | generic | both (Standard: both)
+  --login <verfahren>    Login ohne Mandant (generic/both):
+                         magic (Code per E-Mail, Standard) | password (E-Mail + Passwort)
+  --brand <#rrggbb>      Markenfarbe (Standard: #6667ab)
+  --brand-light <#hex>   helle Markenvariante (Standard: automatisch abgeleitet)
+  --two-factor           E-Mail-2FA nach dem Passwort (Mandanten-Logins bzw. --login password);
+                         nicht für Magic-Code und Mandanten-Zugang; pro Mandant in /admin änderbar
+  --no-two-factor        … explizit aus
+  --mail | --no-mail     SMTP-Block in .env.example einkommentieren
+  --tenant <slug>        erster Mandant (tenant/both)
+  --anmeldung <art>      erster Mandant: konto (E-Mail + Passwort / E-Mail-Code, Standard)
+                         | zugang (nur gemeinsames Mandanten-Passwort, ohne E-Mail)
+  --generic-tenant <slug> optional: interner Slug des offenen Bereichs (Standard: app)
+  --owner-email <mail>   optional (--login magic): weitere Adresse, die beim Auto-Anlegen
+                         admin wird — die Adressen aus --admin-email sind es ohnehin
+  --admin-email <mail>   Admin-Bereich (/admin): darf sich anmelden; mehrfach oder
+                         Komma-getrennt (Standard: die Betreiber-Adressen aus dem Template)
+  --daten <adapter>      sqlite (eine Datei app.sqlite, Standard) | json (Datei je Collection)
+  --slug <slug>          Server-Slug: /opt/<slug>, PM2 <slug>, <slug>.<domain>
+                         (Standard: Ordnername)
+  --port <nnnn>          Prod-Port aus dem Port-Register, test = +1 (kein Standard!)
+                         Lokal: Backend = Prod-Port, Vite = 51 + letzte zwei Stellen
+  --dev-port <nnnn>      lokaler Backend-Port, falls der Prod-Port lokal belegt ist
+  --template <pfad|url>  Template-Quelle (Standard: ${STANDARD_TEMPLATE})
+  --install              nach dem Anlegen npm run install:all ausführen (Standard)
+  --no-install           … nicht ausführen
+  --no-git               kein git init / Initial-Commit
+  --no-local-env         keine backend/.env anlegen (Standard: Kopie von .env.example
+                         mit NODE_ENV=development, VEFK_DEV_LOGIN=true, zufälligem SESSION_SECRET)
+  --yes                  nichts fragen, Standardwerte nehmen
+  --version, --help
+`;
+
+function leseFlags() {
+  const { values, positionals } = parseArgs({
+    allowPositionals: true,
+    options: {
+      dir: { type: "string" },
+      name: { type: "string" },
+      auth: { type: "string" },
+      login: { type: "string" },
+      brand: { type: "string" },
+      "brand-light": { type: "string" },
+      "two-factor": { type: "boolean" },
+      "no-two-factor": { type: "boolean" },
+      mail: { type: "boolean" },
+      "no-mail": { type: "boolean" },
+      tenant: { type: "string" },
+      anmeldung: { type: "string" },
+      "generic-tenant": { type: "string" },
+      "owner-email": { type: "string" },
+      "admin-email": { type: "string", multiple: true },
+      daten: { type: "string" },
+      slug: { type: "string" },
+      port: { type: "string" },
+      "dev-port": { type: "string" },
+      template: { type: "string" },
+      install: { type: "boolean" },
+      "no-install": { type: "boolean" },
+      "no-git": { type: "boolean" },
+      "no-local-env": { type: "boolean" },
+      yes: { type: "boolean" },
+      version: { type: "boolean" },
+      help: { type: "boolean", short: "h" },
+    },
+  });
+  return { values, positionals };
+}
+
+/** Flags → Vorgaben für stelleFragen (undefined = wird ggf. gefragt). */
+function vorgabenAusFlags(values, positionals) {
+  const jaNeinPaar = (ja, nein) => (values[ja] ? true : values[nein] ? false : undefined);
+  if (values.auth && !["tenant", "generic", "both"].includes(values.auth)) {
+    throw new Error(`--auth muss tenant, generic oder both sein (war: ${values.auth})`);
+  }
+  if (values.login && !["magic", "password"].includes(values.login)) {
+    throw new Error(`--login muss magic oder password sein (war: ${values.login})`);
+  }
+  if (values.anmeldung && !["konto", "zugang"].includes(values.anmeldung)) {
+    throw new Error(`--anmeldung muss konto oder zugang sein (war: ${values.anmeldung})`);
+  }
+  if (values.daten && !["sqlite", "json"].includes(values.daten)) {
+    throw new Error(`--daten muss sqlite oder json sein (war: ${values.daten})`);
+  }
+  // Ziel: --dir vor Positionsargument; beides darf ein Pfad sein (auch `.`).
+  // Der Ordnername (Basis für Slug + Anzeigename) kommt aus dem aufgelösten Pfad,
+  // damit `.` den echten Ordnernamen liefert.
+  const zielPfad = values.dir ?? positionals[0];
+  return {
+    ziel: zielPfad ? basename(resolve(zielPfad)) : undefined,
+    zielPfad,
+    name: values.name,
+    authMode: values.auth,
+    genericLogin: values.login,
+    zweiFaktor: jaNeinPaar("two-factor", "no-two-factor"),
+    mail: jaNeinPaar("mail", "no-mail"),
+    marke: values.brand,
+    markeHell: values["brand-light"],
+    tenantSlug: values.tenant,
+    anmeldung: values.anmeldung,
+    genericSlug: values["generic-tenant"],
+    ownerEmail: values["owner-email"],
+    // --admin-email a@x.de --admin-email b@x.de  oder  --admin-email "a@x.de, b@x.de"
+    adminEmails: values["admin-email"]
+      ? values["admin-email"].flatMap((v) => v.split(",")).map((v) => v.trim()).filter(Boolean)
+      : undefined,
+    daten: values.daten,
+    slug: values.slug,
+    port: values.port,
+    devPort: values["dev-port"],
+    gitInit: values["no-git"] ? false : undefined,
+    // Standard: installieren (auch mit --yes); --no-install schaltet ab.
+    install: values["no-install"] ? false : values.install,
+    localEnv: values["no-local-env"] ? false : undefined,
+  };
+}
+
+async function main() {
+  const { values, positionals } = leseFlags();
+
+  if (values.help) {
+    process.stdout.write(HILFE);
+    return;
+  }
+  if (values.version) {
+    const eigenePkg = JSON.parse(
+      await readFile(join(dirname(fileURLToPath(import.meta.url)), "../package.json"), "utf8"),
+    );
+    process.stdout.write(`${eigenePkg.version}\n`);
+    return;
+  }
+
+  const vorgaben = vorgabenAusFlags(values, positionals);
+  const interaktiv = !values.yes && process.stdin.isTTY === true;
+  const antworten = await stelleFragen(vorgaben, interaktiv);
+
+  // Zielpfad: --dir / Positionsargument (kann ein Pfad sein) oder der erfragte
+  // Ordnername. Vorhanden + leer ist ok (wie `npm create vite@latest .`),
+  // nicht leer → Abbruch, bevor irgendetwas geschrieben wird.
+  const zielPfad = resolve(vorgaben.zielPfad ?? antworten.zielPfad ?? antworten.ziel);
+  await pruefeZielordner(zielPfad);
+  const { devPort, vitePort } = leiteDevPortsAb(antworten.port, antworten.devPort);
+
+  if ((antworten.authMode === "generic" || antworten.authMode === "both")
+    && antworten.genericLogin === "magic" && antworten.mail === false) {
+    process.stdout.write(
+      `⚠  ${antworten.authMode}-Profil ohne Mail: der Magic-Code-Login braucht SMTP. ` +
+      "Lokal hilft VEFK_DEV_LOGIN=true, für den Betrieb docs/07 folgen.\n",
+    );
+  }
+
+  // --- 1) Klonen ------------------------------------------------------------
+  const quelle = await loeseTemplateQuelle(values.template ?? STANDARD_TEMPLATE);
+  process.stdout.write(`\nKlone Template (${quelle}) …\n`);
+  await kloneTemplate(quelle, zielPfad);
+
+  // --- 2) Platzhalter ersetzen ----------------------------------------------
+  const warnungen = await wendeAntwortenAn(zielPfad, { ...antworten, devPort, vitePort });
+
+  // --- 2b) lokale backend/.env (Zufalls-SESSION_SECRET, Dev-Flags) ----------
+  let envErgebnis = "uebersprungen";
+  if (antworten.localEnv) {
+    envErgebnis = await legeLokaleEnvAn(zielPfad);
+    if (envErgebnis === "keine-vorlage") warnungen.push(".env.example fehlt — backend/.env nicht angelegt");
+  }
+
+  // --- 3) git init + Initial-Commit -----------------------------------------
+  let gitErgebnis = { commit: false };
+  if (antworten.gitInit) {
+    gitErgebnis = await initialisiereRepo(zielPfad);
+  }
+
+  // --- 4) optional npm install ----------------------------------------------
+  // Native Module (better-sqlite3, bcrypt) werden für die Node-Version gebaut,
+  // die JETZT läuft. Wechselt nvm nach dem cd wegen .nvmrc auf eine andere,
+  // passt das Binary nicht mehr (ERR_DLOPEN_FAILED). Deshalb vorher vergleichen.
+  const nodeHinweis = await pruefeNodeVersion(zielPfad);
+  if (antworten.install) {
+    if (nodeHinweis) process.stdout.write(`\n⚠  ${nodeHinweis}\n`);
+    process.stdout.write("\nInstalliere Dependencies (npm run install:all) …\n");
+    await fuehreAus("npm", ["run", "install:all"], {
+      cwd: zielPfad,
+      shell: process.platform === "win32",
+    });
+  }
+
+  // --- Abschluss -------------------------------------------------------------
+  process.stdout.write(`\n✔ ${antworten.ziel} angelegt (${zielPfad})\n`);
+  process.stdout.write(`  Profil: ${antworten.authMode}`);
+  if (antworten.authMode === "tenant" || antworten.authMode === "both") {
+    process.stdout.write(`, 2FA-Default: ${antworten.zweiFaktor ? "an" : "aus"}`);
+    if (antworten.tenantSlug) process.stdout.write(`, erster Mandant: ${antworten.tenantSlug}`);
+  }
+  if (antworten.authMode === "generic" || antworten.authMode === "both") {
+    process.stdout.write(`, offener Bereich: ${antworten.genericSlug} (${
+      antworten.genericLogin === "password" ? "E-Mail + Passwort" : "Magic-Code"})`);
+    if (antworten.genericLogin === "password" && antworten.authMode === "generic") {
+      process.stdout.write(`, 2FA: ${antworten.zweiFaktor ? "an" : "aus"}`);
+    }
+  }
+  process.stdout.write(`, Marke: ${antworten.marke} / ${antworten.markeHell}\n`);
+  process.stdout.write(`  Server: /opt/${antworten.slug} + /opt/${antworten.slug}-test, Ports ${
+    antworten.port ? `${antworten.port}/${antworten.port + 1}` : "NICHT gesetzt (--port)"}\n`);
+  process.stdout.write(`  Lokal: Backend :${devPort ?? 3001}, Vite :${vitePort ?? 5173}${
+    devPort ? "" : " (Standard — mit --port werden eigene Dev-Ports abgeleitet)"}\n`);
+  if (envErgebnis === "angelegt") {
+    process.stdout.write("  backend/.env: angelegt (NODE_ENV=development, VEFK_DEV_LOGIN=true, zufälliges SESSION_SECRET)\n");
+  }
+  if (antworten.gitInit) {
+    process.stdout.write(gitErgebnis.commit
+      ? "  git: initialisiert + Initial-Commit\n"
+      : `  git: ${gitErgebnis.hinweis ?? "übersprungen"}\n`);
+  }
+
+  if (warnungen.length > 0) {
+    process.stdout.write("\n⚠  Nicht automatisch ersetzt (Template neuer als der Scaffolder?):\n");
+    for (const w of warnungen) process.stdout.write(`   – ${w}\n`);
+    process.stdout.write("   Bitte diese Stellen kurz von Hand prüfen.\n");
+  }
+
+  const cdZeile = zielPfad === process.cwd() ? "" : `  cd ${vorgaben.zielPfad ?? antworten.zielPfad ?? antworten.ziel}\n`;
+  const rebuildZeile = antworten.install && nodeHinweis
+    ? "  npm --prefix backend rebuild      # native Module für die Node-Version aus .nvmrc neu bauen (s. Warnung oben)\n"
+    : "";
+  const envZeile = envErgebnis === "angelegt" ? "" : "  cp .env.example backend/.env   # ausfüllen (SESSION_SECRET!)\n";
+  const zugangZeile = antworten.authMode === "generic"
+    ? ""
+    : antworten.anmeldung === "zugang"
+      ? `  npm run zugang                 # Mandanten-Passwort für „${antworten.tenantSlug}“ setzen — vorher kann sich dort niemand anmelden\n`
+      : "  npm run zugang                 # optional: Mandanten-Zugang (nur Passwort, kein Konto)\n";
+  process.stdout.write(`\nNächste Schritte:
+${cdZeile}${envZeile}${antworten.install ? "" : "  npm run install:all\n"}${rebuildZeile}  npm run create-user            # ersten Nutzer anlegen (ohne Passwort = Login per E-Mail-Code)
+${zugangZeile}  npm run dev                    # Backend + Frontend zusammen, Ctrl-C beendet beide
+
+Vor dem ersten Deploy:
+  Port-Paar ${antworten.port ? `${antworten.port}/${antworten.port + 1} ` : ""}im Port-Register (DEPLOYMENT.md) eintragen,
+  dann CLAUDE-DEPLOYMENT.md lesen — ./deploy.sh test|prod
+`);
+}
+
+/**
+ * Aktives Node gegen die .nvmrc des Projekts vergleichen (nur die Major-Version).
+ * Liefert einen Hinweistext bei Abweichung, sonst "".
+ */
+async function pruefeNodeVersion(dir) {
+  let erwartet;
+  try {
+    erwartet = (await readFile(join(dir, ".nvmrc"), "utf8")).trim().replace(/^v/, "");
+  } catch {
+    return "";
+  }
+  const erwartetMajor = Number.parseInt(erwartet, 10);
+  const aktivMajor = Number.parseInt(process.versions.node, 10);
+  if (!Number.isInteger(erwartetMajor) || erwartetMajor === aktivMajor) return "";
+  return `Node ${process.versions.node} ist aktiv, das Projekt erwartet Node ${erwartet} (.nvmrc). ` +
+    `Native Module (better-sqlite3, bcrypt) werden jetzt für Node ${aktivMajor} gebaut — wechselt nvm beim cd ` +
+    `auf Node ${erwartetMajor}, danach im Projekt „npm --prefix backend rebuild" ausführen (oder vorher „nvm use ${erwartetMajor}").`;
+}
+
+main().catch((fehler) => {
+  process.stderr.write(`\n✗ ${fehler.message}\n`);
+  process.exit(1);
+});