@iddp/create-vefk-app 0.7.0

package/lib/fragen.js

@@ -0,0 +1,265 @@
+// lib/fragen.js
+//
+// Interaktive Fragen (node:readline/promises — bewusst ohne Prompt-Library,
+// Suite-Linie „nativ statt Extra-Deps"). Alles, was schon per Flag beantwortet
+// wurde, wird nicht mehr gefragt; mit --yes (oder ohne TTY) gelten die
+// Standardwerte (Profil both, Dependencies installieren, git init, backend/.env).
+
+import { createInterface } from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+import { istSlug, istEmail, istPort, schlageOrdnerVor, schlageSlugVor, loeseZiel, RESERVIERTE_SLUGS } from "./validieren.js";
+import { istHexFarbe, normalisiereHex, helleVariante } from "./farben.js";
+
+/**
+ * Anzeigename-Vorschlag aus dem Projektordner: "pruef-protokolle" → "Pruef Protokolle".
+ * Ein `vefk-`-Präfix fällt nur HIER weg (Anzeigename), nicht im Slug.
+ */
+export function schlageNamenVor(ziel) {
+  const rumpf = ziel.replace(/^vefk-/, "");
+  return rumpf
+    .split("-")
+    .map((teil) => teil.charAt(0).toUpperCase() + teil.slice(1))
+    .join(" ");
+}
+
+export async function stelleFragen(vorgaben, interaktiv) {
+  const rl = interaktiv ? createInterface({ input: stdin, output: stdout }) : null;
+
+  async function frage(text, standard, pruefen, fehlertext) {
+    if (!rl) return standard;
+    for (;;) {
+      const hinweis = standard !== undefined && standard !== "" ? ` [${standard}]` : "";
+      const eingabe = (await rl.question(`${text}${hinweis}: `)).trim();
+      const wert = eingabe === "" ? standard : eingabe;
+      if (!pruefen || pruefen(wert)) return wert;
+      stdout.write(`  ✗ ${fehlertext}\n`);
+    }
+  }
+
+  async function jaNein(text, standard) {
+    if (!rl) return standard;
+    const wert = await frage(`${text} (j/n)`, standard ? "j" : "n",
+      (w) => /^(j|ja|n|nein)$/i.test(w), "bitte j oder n");
+    return /^j/i.test(wert);
+  }
+
+  try {
+    // --- Zielordner (Ordnername = Server-Slug) ------------------------------
+    // Kein Präfix-Zwang: der Ordner heißt, wie das Tool auf dem Server heißt.
+    // Ein vorhandener Ordner (auch `.`) ist als Ziel erlaubt, wenn er leer ist —
+    // das prüft bin/ vor dem Klonen.
+    let ziel = vorgaben.ziel;
+    let zielPfad = vorgaben.zielPfad;
+    if (!ziel) {
+      const eingabe = await frage(
+        "In welchen Ordner soll installiert werden? (. = aktueller Ordner; Ordnername = Server-Slug)",
+        vorgaben.name ? schlageOrdnerVor(vorgaben.name) : undefined,
+        (w) => w === "." || istSlug(w),
+        "nur a-z, 0-9, Bindestrich (nicht am Anfang oder Ende) oder . für den aktuellen Ordner",
+      );
+      ({ zielPfad, ziel } = loeseZiel(eingabe));
+    }
+    // Ordnername, der kein Slug ist (z. B. `.` in „Mein Tool"): interaktiv wird
+    // der Server-Slug unten ohne Vorschlag erfragt, non-interaktiv braucht es --slug.
+    const zielIstSlug = istSlug(ziel);
+    if (!zielIstSlug && !vorgaben.slug && !rl) {
+      throw new Error(
+        `Ordnername „${ziel}" taugt nicht als Server-Slug (nur a-z, 0-9, -) — ` +
+        "bitte anderen Ordner wählen oder --slug angeben.",
+      );
+    }
+
+    // --- Anzeigename --------------------------------------------------------
+    const name = vorgaben.name
+      ?? await frage("Anzeigename des Tools (Header, Mail-Betreff)", schlageNamenVor(ziel),
+        (w) => typeof w === "string" && w.trim().length > 0, "darf nicht leer sein");
+
+    // --- Auth-Profil --------------------------------------------------------
+    // Standard „both": Mandanten-Bereiche PLUS ein Bereich ohne Mandant.
+    let authMode = vorgaben.authMode;
+    if (!authMode) {
+      const antwort = await frage(
+        "Auth-Profil — tenant (Bereiche je Mandant unter /<mandant>) " +
+        "generic oder both (beides)",
+        "both",
+        (w) => ["tenant", "generic", "both"].includes(w),
+        "bitte tenant, generic oder both",
+      );
+      authMode = antwort ?? "both";
+    }
+    const mitMandanten = authMode === "tenant" || authMode === "both";
+    const mitOffen = authMode === "generic" || authMode === "both";
+
+    // --- Login-Verfahren des offenen Bereichs (generic/both) -----------------
+    // magic = Code per E-Mail, Nutzer legen sich selbst an (offen für alle);
+    // password = „normaler" Login mit E-Mail + Passwort, Nutzer legt der Admin an.
+    let genericLogin = "magic";
+    if (mitOffen) {
+      genericLogin = vorgaben.genericLogin ?? await frage(
+        "Login ohne Mandant — password (E-Mail + Passwort, Admin legt Nutzer an) " +
+        "oder magic (Code per E-Mail, Nutzer legt sich selbst an)",
+        "magic",
+        (w) => ["magic", "password"].includes(w),
+        "bitte magic oder password",
+      );
+    }
+    const mitMagic = mitOffen && genericLogin === "magic";
+
+    // --- Profil-Details -----------------------------------------------------
+    let zweiFaktor = false;
+    let tenantSlug = ""; // erster Mandant (tenant/both)
+    let anmeldung = "konto"; // Anmeldeart des ersten Mandanten: konto | zugang
+    // Interner Slug des offenen Bereichs (Nutzer + Daten): bewusst NICHT erfragt —
+    // reiner Ordner-/Tabellenname, "app" passt immer; --generic-tenant für Sonderfälle.
+    const genericSlug = mitOffen ? (vorgaben.genericSlug ?? "app") : "";
+    // Owner-E-Mail: NICHT erfragt — die Adressen aus admin.emails werden im
+    // Magic-Code-Bereich ohnehin admin; --owner-email nur für eine weitere Adresse.
+    const ownerEmail = vorgaben.ownerEmail ?? "";
+
+    const istFreierMandant = (w) =>
+      istSlug(w) && !["_muster", "beispiel", ...RESERVIERTE_SLUGS].includes(w);
+
+    if (mitMandanten) {
+      tenantSlug = vorgaben.tenantSlug ?? await frage(
+        "Slug des ersten Mandanten (leer lassen = nur der beispiel-Mandant)",
+        "",
+        (w) => w === "" || istFreierMandant(w),
+        `nur a-z, 0-9, - (nicht _muster/beispiel/${RESERVIERTE_SLUGS.join("/")})`,
+      );
+      if (tenantSlug) {
+        // Anmeldeart des ersten Mandanten — steht in dessen dashboard-config.json
+        // (anmeldung) und ist später in /admin → Einstellungen umschaltbar.
+        anmeldung = vorgaben.anmeldung ?? await frage(
+          `Anmeldung der Nutzer von „${tenantSlug}“ — konto (E-Mail + Passwort oder E-Mail-Code) ` +
+          "oder zugang (nur ein gemeinsames Mandanten-Passwort, ohne E-Mail)",
+          "konto",
+          (w) => ["konto", "zugang"].includes(w),
+          "bitte konto oder zugang",
+        );
+      }
+    }
+    if (!["konto", "zugang"].includes(anmeldung)) {
+      throw new Error(`--anmeldung muss konto oder zugang sein (war: ${anmeldung}).`);
+    }
+
+    // 2FA gibt es nur nach einem Passwort-Login mit Konto: Mandanten mit Nutzerkonten
+    // oder der Passwort-Login des offenen Bereichs. Nicht bei Magic-Code (der Code ist
+    // der Faktor) und nicht beim Mandanten-Passwort ohne E-Mail.
+    const mitPasswort = (mitMandanten && anmeldung !== "zugang") || (mitOffen && genericLogin === "password");
+    if (mitPasswort) {
+      zweiFaktor = vorgaben.zweiFaktor ?? await jaNein(
+        mitMandanten && anmeldung !== "zugang"
+          ? "E-Mail-2FA für Mandanten-Logins mit Passwort als Standard aktivieren?"
+          : "E-Mail-2FA nach dem Passwort aktivieren?",
+        false,
+      );
+    }
+
+    // --- Werte prüfen, egal ob erfragt oder per Flag geliefert ---------------
+    // (die Prompt-Validierung greift nur bei interaktiver Eingabe)
+    if (tenantSlug && !istFreierMandant(tenantSlug)) {
+      throw new Error(
+        `Mandanten-Slug „${tenantSlug}" ist ungültig oder reserviert ` +
+        `(_muster, beispiel, ${RESERVIERTE_SLUGS.join(", ")}).`,
+      );
+    }
+    if (mitOffen && (!istSlug(genericSlug) || RESERVIERTE_SLUGS.includes(genericSlug) || genericSlug === tenantSlug)) {
+      throw new Error(
+        `Interner Slug „${genericSlug}" ist ungültig, reserviert oder kollidiert mit dem Mandanten-Slug.`,
+      );
+    }
+    if (ownerEmail && !istEmail(ownerEmail)) {
+      throw new Error(`Owner-E-Mail „${ownerEmail}" ist keine gültige E-Mail-Adresse.`);
+    }
+
+    // --- Admin-Bereich (/admin) + Datenspeicher ------------------------------
+    // Admin-Adressen: Betreiber, nicht Kunden — stehen versioniert in app.config.js.
+    // Leer lassen = die Standard-Adressen aus dem Template bleiben (undefined).
+    let adminEmails = vorgaben.adminEmails;
+    if (adminEmails === undefined) {
+      const eingabe = await frage(
+        "Admin-E-Mails für /admin (Komma-getrennt) [dr.dirk.peters@gmail.com, eva@iddp-vefk.de]",
+        "",
+        (w) => w === "" || w.split(",").map((x) => x.trim()).filter(Boolean).every(istEmail),
+        "eine oder mehrere gültige E-Mail-Adressen, Komma-getrennt",
+      );
+      adminEmails = eingabe ? eingabe.split(",").map((x) => x.trim()).filter(Boolean) : undefined;
+    }
+    if (adminEmails !== undefined) {
+      const kaputt = adminEmails.filter((e) => !istEmail(e));
+      if (!adminEmails.length || kaputt.length) {
+        throw new Error(`--admin-email: keine gültige(n) Adresse(n) (${kaputt.join(", ") || "leer"}).`);
+      }
+    }
+    // Datenspeicher: SQLite ist Standard für neue Tools; JSON nur per --daten json.
+    const daten = vorgaben.daten ?? "sqlite";
+    if (!["sqlite", "json"].includes(daten)) {
+      throw new Error(`--daten muss sqlite oder json sein (war: ${daten}).`);
+    }
+
+    // --- Marke --------------------------------------------------------------
+    const markeRoh = vorgaben.marke ?? await frage(
+      "Markenfarbe (Hex; Standard = IDDP-Violett)",
+      "#6667ab",
+      istHexFarbe,
+      "bitte als #rrggbb angeben",
+    );
+    if (!istHexFarbe(markeRoh) || (vorgaben.markeHell && !istHexFarbe(vorgaben.markeHell))) {
+      throw new Error(`Markenfarbe bitte als #rrggbb angeben (war: ${markeRoh} / ${vorgaben.markeHell ?? "—"}).`);
+    }
+    const marke = normalisiereHex(markeRoh);
+    const markeHell = vorgaben.markeHell
+      ? normalisiereHex(vorgaben.markeHell)
+      : helleVariante(marke);
+
+    // --- Server: Slug + Port-Paar -------------------------------------------
+    // Slug → /opt/<slug>, PM2 <slug>/<slug>-test, <slug>.<domain>. Port: prod,
+    // test = prod+1. Ohne Port bleiben die @@PORT_*@@-Token stehen (Warnung).
+    const slug = vorgaben.slug ?? await frage(
+      "Server-Slug (Ordner /opt/<slug>, PM2-Name, Domain)",
+      zielIstSlug ? schlageSlugVor(ziel) : undefined,
+      istSlug,
+      "nur a-z, 0-9, Bindestrich",
+    );
+    if (!istSlug(slug)) {
+      throw new Error(`Server-Slug „${slug}" ist ungültig (nur a-z, 0-9, Bindestrich).`);
+    }
+    const portRoh = vorgaben.port ?? await frage(
+      "Prod-Port aus dem Port-Register (test = +1; freies Paar wählen UND dort eintragen)",
+      undefined,
+      istPort,
+      "vierstellige Portnummer, z. B. 3090",
+    );
+    if (portRoh !== undefined && !istPort(portRoh)) {
+      throw new Error(`--port muss eine Portnummer zwischen 1024 und 65534 sein (war: ${portRoh}).`);
+    }
+    const port = portRoh === undefined ? undefined : Number(portRoh);
+    // Lokale Dev-Ports: nicht erfragt, nur per --dev-port übersteuerbar.
+    if (vorgaben.devPort !== undefined && !istPort(vorgaben.devPort)) {
+      throw new Error(`--dev-port muss eine Portnummer zwischen 1024 und 65534 sein (war: ${vorgaben.devPort}).`);
+    }
+    const devPort = vorgaben.devPort === undefined ? undefined : Number(vorgaben.devPort);
+
+    // --- Mail / SMTP --------------------------------------------------------
+    // Magic-Code braucht SMTP zwingend, Passwort-Logins nur mit 2FA.
+    const mailStandard = mitMagic || zweiFaktor;
+    const mail = vorgaben.mail ?? (mailStandard
+      ? mailStandard // zwingend/sinnvoll → nicht extra fragen
+      : await jaNein("Mail-Versand (SMTP) direkt vorkonfigurieren?", false));
+
+    // --- Abschluss-Aktionen -------------------------------------------------
+    const gitInit = vorgaben.gitInit ?? true;
+    const localEnv = vorgaben.localEnv ?? true; // backend/.env anlegen (--no-local-env)
+    const install = vorgaben.install ?? await jaNein(
+      "npm-Dependencies direkt installieren? (zieht die @iddp-Pakete von GitHub; --no-install überspringt)",
+      true,
+    );
+
+    return {
+      ziel, zielPfad, name, authMode, genericLogin, zweiFaktor, mail, marke, markeHell,
+      tenantSlug, anmeldung, genericSlug, ownerEmail, adminEmails, daten, slug, port, devPort, gitInit, install, localEnv,
+    };
+  } finally {
+    rl?.close();
+  }
+}

package/lib/git.js

@@ -0,0 +1,33 @@
+// lib/git.js
+//
+// Frisches Repo im neuen Tool: git init + Initial-Commit.
+// Schlägt der Commit fehl (z. B. keine user.name/user.email konfiguriert),
+// bricht der Scaffolder nicht ab — das Projekt ist trotzdem fertig, nur
+// der Commit fehlt; der Hinweis dazu kommt in der Abschluss-Ausgabe.
+
+import { fuehreAus } from "./prozesse.js";
+
+export async function initialisiereRepo(dir) {
+  const optionen = { cwd: dir, stdio: ["ignore", "ignore", "inherit"] };
+  try {
+    await fuehreAus("git", ["init", "-b", "main"], optionen);
+  } catch {
+    await fuehreAus("git", ["init"], optionen); // ältere git-Version ohne -b
+  }
+  await fuehreAus("git", ["add", "-A"], optionen);
+  try {
+    await fuehreAus(
+      "git",
+      ["commit", "-m", "Init aus vefk-app-template (create-vefk-app)"],
+      optionen,
+    );
+    return { commit: true };
+  } catch {
+    return {
+      commit: false,
+      hinweis:
+        "git init ok, aber der Initial-Commit schlug fehl (git user.name/user.email gesetzt?). " +
+        "Bitte manuell committen: git add -A && git commit -m \"Init aus vefk-app-template\"",
+    };
+  }
+}

package/lib/klonen.js

@@ -0,0 +1,80 @@
+// lib/klonen.js
+//
+// Template holen: `git clone --depth 1` + `.git` entfernen.
+//
+// Bewusst git statt degit: degit lädt GitHub-Tarballs über die API und
+// scheitert am privaten Template-Repo, solange kein degit-eigener Token
+// konfiguriert ist. `git clone` nutzt die Git-Credentials, die auf dem
+// Rechner ohnehin eingerichtet sind (gleiche Voraussetzung wie das
+// `npm install` der git-Dependencies) — und funktioniert zusätzlich mit
+// lokalen Pfaden (`--template ../vefk-app-template`), was Tests und
+// Offline-Arbeit erlaubt.
+
+import { mkdir, mkdtemp, readdir, rename, rm, stat } from "node:fs/promises";
+import { resolve, join } from "node:path";
+import { fuehreAus } from "./prozesse.js";
+
+export const STANDARD_TEMPLATE = "https://github.com/esgoet/vefk-app-template.git";
+
+/** Dateien, die ein Ordner haben darf und trotzdem als „leer" gilt. */
+const IGNORIERT_BEI_LEER = new Set([".DS_Store"]);
+
+/** Lokalen Pfad zu absolutem Pfad auflösen; URLs unangetastet lassen. */
+export async function loeseTemplateQuelle(quelle) {
+  if (/^[a-z+]+:\/\//i.test(quelle) || quelle.startsWith("git@")) return quelle;
+  const pfad = resolve(quelle);
+  await stat(pfad); // wirft, wenn der lokale Pfad nicht existiert
+  return pfad;
+}
+
+/**
+ * Zielordner prüfen (wie `npm create vite@latest .`): darf fehlen oder leer
+ * sein — auch `.` oder ein schon angelegter Ordner. Ist er nicht leer, wird
+ * abgebrochen, bevor irgendetwas geschrieben wird.
+ *
+ * @returns {Promise<"neu"|"leer">}
+ */
+export async function pruefeZielordner(zielDir) {
+  const info = await stat(zielDir).catch(() => null);
+  if (!info) return "neu";
+  if (!info.isDirectory()) {
+    throw new Error(`Ziel ${zielDir} existiert, ist aber kein Ordner.`);
+  }
+  const eintraege = (await readdir(zielDir)).filter((e) => !IGNORIERT_BEI_LEER.has(e));
+  if (eintraege.length > 0) {
+    throw new Error(
+      `Zielordner ${zielDir} ist nicht leer (${eintraege.slice(0, 3).join(", ")}${
+        eintraege.length > 3 ? ", …" : ""}) — es wird nichts überschrieben. ` +
+      "Bitte leeren Ordner oder anderen Namen wählen.",
+    );
+  }
+  return "leer";
+}
+
+/**
+ * Klont das Template (ohne Historie) nach zielDir und entfernt `.git`,
+ * damit das neue Tool mit einer frischen Historie startet.
+ *
+ * Geklont wird in einen temporären Unterordner des Ziels, dessen Inhalt dann
+ * eine Ebene hochgezogen wird: so funktioniert es auch für `.` und für
+ * vorhandene Ordner (mit `.DS_Store`), an denen `git clone` sonst scheitert —
+ * und die Verschiebung bleibt im selben Dateisystem (`rename`).
+ */
+export async function kloneTemplate(quelle, zielDir) {
+  // Bei lokalen Pfaden kein --depth (git ignoriert es dort mit Warnung);
+  // die Historie fliegt gleich darauf ohnehin mit `.git` raus.
+  const flach = /^[a-z+]+:\/\//i.test(quelle) || quelle.startsWith("git@")
+    ? ["--depth", "1", "--single-branch"]
+    : [];
+  await mkdir(zielDir, { recursive: true });
+  const tmp = await mkdtemp(join(zielDir, ".create-vefk-app-"));
+  try {
+    await fuehreAus("git", ["clone", ...flach, quelle, tmp]);
+    await rm(join(tmp, ".git"), { recursive: true, force: true });
+    for (const eintrag of await readdir(tmp)) {
+      await rename(join(tmp, eintrag), join(zielDir, eintrag));
+    }
+  } finally {
+    await rm(tmp, { recursive: true, force: true });
+  }
+}

package/lib/lokaleEnv.js

@@ -0,0 +1,34 @@
+// lib/lokaleEnv.js
+//
+// Lokale backend/.env direkt mit anlegen, damit `npm run dev:backend` sofort
+// läuft: Kopie von .env.example, NODE_ENV=development + VEFK_DEV_LOGIN=true
+// einkommentiert, SESSION_SECRET durch einen Zufallswert ersetzt. Der Wert
+// wird nirgends ausgegeben. .env steht im .gitignore des Templates.
+
+import { randomBytes } from "node:crypto";
+import { readFile, writeFile, access } from "node:fs/promises";
+import { join } from "node:path";
+
+/**
+ * @returns {Promise<"angelegt"|"vorhanden"|"keine-vorlage">}
+ */
+export async function legeLokaleEnvAn(dir) {
+  const ziel = join(dir, "backend", ".env");
+  if (await access(ziel).then(() => true, () => false)) return "vorhanden"; // nie überschreiben
+
+  let vorlage;
+  try {
+    vorlage = await readFile(join(dir, ".env.example"), "utf8");
+  } catch {
+    return "keine-vorlage";
+  }
+
+  const secret = randomBytes(48).toString("base64url");
+  const inhalt = vorlage
+    .replace(/^SESSION_SECRET=.*$/m, `SESSION_SECRET=${secret}`)
+    .replace(/^# (NODE_ENV=development)/m, "$1")
+    .replace(/^# (VEFK_DEV_LOGIN=true)/m, "$1");
+
+  await writeFile(ziel, inhalt, { mode: 0o600 });
+  return "angelegt";
+}

package/lib/prozesse.js

@@ -0,0 +1,21 @@
+// lib/prozesse.js
+//
+// Dünner Wrapper um child_process für git/npm-Aufrufe.
+// stdio wird durchgereicht, damit z. B. der Git-Credential-Prompt beim
+// Klonen des privaten Template-Repos sichtbar bleibt.
+
+import { spawn } from "node:child_process";
+
+export function fuehreAus(befehl, argumente, optionen = {}) {
+  return new Promise((aufloesen, ablehnen) => {
+    const kind = spawn(befehl, argumente, {
+      stdio: "inherit",
+      ...optionen,
+    });
+    kind.on("error", ablehnen);
+    kind.on("close", (code) => {
+      if (code === 0) aufloesen();
+      else ablehnen(new Error(`${befehl} ${argumente.join(" ")} → Exit-Code ${code}`));
+    });
+  });
+}

package/lib/validieren.js

@@ -0,0 +1,85 @@
+// lib/validieren.js
+//
+// Eingabe-Validierung des Scaffolders. Die Slug-Regel ist dieselbe wie im
+// vefk-app-kit (Tenant-Slug-Validierung, Path-Traversal-Schutz — docs/03, docs/05):
+// nur Kleinbuchstaben, Ziffern, Bindestriche.
+//
+// Ordnername = Server-Slug (Konvention: /opt/<slug>, PM2 <slug>, <slug>.<domain>).
+// Ein `vefk-`-Präfix wird NICHT erzwungen — kaum ein Tool heißt so (gbu, beirat,
+// seminar, vefkev-user …); `--slug` übersteuert bei Bedarf.
+
+import { basename } from "node:path";
+import process from "node:process";
+
+/** Tenant-/Ordner-/Server-Slug: ^[a-z0-9-]+$, beginnt und endet alphanumerisch. */
+export function istSlug(wert) {
+  return typeof wert === "string" && /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/.test(wert);
+}
+
+/**
+ * Von den App-Routen belegte Namen — als Tenant-Slug verboten, sonst
+ * verschatten sie im both-Modus die offenen Routen (/api/data, /login,
+ * /uebersicht). → Template docs/03 (both-Abschnitt).
+ */
+// Deckungsgleich mit RESERVIERTE_SLUGS in @iddp/vefk-app-kit/server (Admin-Bereich prüft dasselbe).
+export const RESERVIERTE_SLUGS = ["data", "login", "uebersicht", "api", "admin", "impressum", "datenschutz"];
+
+/**
+ * Server-Slug-Vorschlag aus dem Projektordner: der Ordnername selbst.
+ * Daraus werden /opt/<slug>, PM2-Name und Domains.
+ */
+export function schlageSlugVor(ziel) {
+  return String(ziel);
+}
+
+/**
+ * Prod-Port des Tools; test ist prod+1. Vierstellig wie das Port-Register
+ * (30x0/30x1). Es gibt bewusst KEINEN Standardwert — ein Beispiel-Port
+ * kollidiert früher oder später mit einer echten App.
+ */
+export function istPort(wert) {
+  const n = Number(wert);
+  return Number.isInteger(n) && n >= 1024 && n <= 65534 && String(wert) === String(n);
+}
+
+/**
+ * Lokale Dev-Ports aus dem Prod-Port: Backend lokal = Prod-Port (oder
+ * --dev-port), Vite = "51" + die letzten zwei Stellen davon. So laufen
+ * mehrere Tools parallel, ohne sich die Standard-Ports 3001/5173 zu teilen.
+ * Ohne Port bleiben beide undefined — das Template behält dann 3001/5173.
+ */
+export function leiteDevPortsAb(port, devPort) {
+  const basis = devPort ?? port;
+  if (basis === undefined) return { devPort: undefined, vitePort: undefined };
+  const n = Number(basis);
+  return { devPort: n, vitePort: Number(`51${String(n).padStart(2, "0").slice(-2)}`) };
+}
+
+/** Grobe E-Mail-Prüfung — echte Prüfung macht der Mail-Versand selbst. */
+export function istEmail(wert) {
+  return typeof wert === "string" && /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(wert);
+}
+
+/** Anzeigename → Vorschlag für den Projektordner (= Slug). */
+export function schlageOrdnerVor(name) {
+  return String(name)
+    .toLowerCase()
+    .replace(/ä/g, "ae")
+    .replace(/ö/g, "oe")
+    .replace(/ü/g, "ue")
+    .replace(/ß/g, "ss")
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
+/**
+ * Eingabe der Ordner-Frage auflösen: `.` = aktueller Ordner (Slug = dessen
+ * Name), sonst ein Ordnername relativ zum Arbeitsverzeichnis.
+ * @returns {{ zielPfad: string, ziel: string }}
+ */
+export function loeseZiel(eingabe, cwd = process.cwd()) {
+  const wert = String(eingabe).trim();
+  if (wert === ".") return { zielPfad: ".", ziel: basename(cwd) };
+  return { zielPfad: wert, ziel: wert };
+}
+

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@iddp/create-vefk-app",
+  "version": "0.7.0",
+  "description": "Scaffolder der VEFK-Tools-Suite — erzeugt ein neues Tool aus vefk-app-template und ersetzt die Platzhalter (Toolname, Marke, Auth-Profil, 2FA/Mail).",
+  "type": "module",
+  "bin": {
+    "create-vefk-app": "bin/create-vefk-app.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20.11.0"
+  },
+  "scripts": {
+    "test": "node --test test/*.test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/esgoet/create-vefk-app.git"
+  },
+  "keywords": [
+    "create",
+    "scaffolder",
+    "vefk"
+  ],
+  "author": "Eva Goetzke",
+  "license": "MIT"
+}