create-authenik8-app 2.0.7 → 2.0.9

package/dist/bin/index.js

@@ -5,18 +5,86 @@ import chalk from "chalk";
 import inquirer from "inquirer";
 import { ExitPromptError } from "@inquirer/core";
 import ora from "ora";
-import { execSync } from "child_process";
+import { execSync, ChildProcess } from "child_process";
 import { fileURLToPath } from "url";
-import { spawnSync } from "child_process";
+import { spawnSync, spawn } from "child_process";
 import os from "os";
-let answers = {};
+const spinner = ora().start();
+const activeProcesses = new Set();
+export function run(cmd, args, options) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(cmd, args, {
+            cwd: options.cwd,
+            stdio: "ignore",
+        });
+        activeProcesses.add(child);
+        child.on("exit", (code) => {
+            activeProcesses.delete(child);
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`${cmd} exited with code ${code}`));
+            }
+        });
+        child.on("error", (err) => {
+            activeProcesses.delete(child);
+            reject(err);
+        });
+    });
+}
+function killAllProcesses() {
+    for (const proc of activeProcesses) {
+        try {
+            proc.kill("SIGINT");
+        }
+        catch { }
+    }
+    activeProcesses.clear();
+}
+function getCommand(cmd) {
+    const isWin = process.platform === "win32";
+    if (cmd === "npm")
+        return isWin ? "npm.cmd" : "npm";
+    if (cmd === "npx")
+        return isWin ? "npx.cmd" : "npx";
+    if (cmd === "git")
+        return isWin ? "git.exe" : "git";
+    return cmd;
+}
+//make sure steps are completed
+function stepActuallyCompleted(step) {
+    switch (step) {
+        case "deps-installed":
+            return fs.existsSync(path.join(targetDir, "node_modules"));
+        case "prisma-generated":
+            return fs.existsSync(path.join(targetDir, "node_modules/.prisma/client"));
+        case "git-initialized":
+            return fs.existsSync(path.join(targetDir, ".git"));
+        default:
+            return true;
+    }
+}
+const args = process.argv.slice(2);
+const projectNameArg = args.find(arg => !arg.startsWith("--"));
+//const projectNameArg = process.argv[2];
+if (!projectNameArg) {
+    console.log(chalk.red("❌ Please provide a project name"));
+    process.exit(1);
+}
+const projectName = projectNameArg;
+//let answers:any = {};
+let state = {
+    step: "start",
+    projectName,
+};
 const platform = os.platform();
 // 'linux' | 'darwin' | 'win32'
 const isTermux = process.env.PREFIX?.includes("com.termux") ||
     process.env.TERMUX === "true";
 function getBestHashLib() {
     if (isTermux)
-        return "bcryptjs"; // argon2 breaks here
+        return "bcryptjs";
     if (platform === "win32")
         return "bcryptjs";
     // avoids build tools issues for most users
@@ -56,14 +124,9 @@ return bcrypt.compare(password, hash);
 }
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-const projectName = process.argv[2];
-if (!projectName) {
-    console.log(chalk.red("❌ Please provide a project name"));
-    process.exit(1);
-}
-const isProduction = process.argv.includes("--production-ready");
-const isResume = process.argv.includes("--resume");
-const targetDir = path.join(process.cwd(), projectName);
+const isProduction = args.includes("--production-ready");
+const isResume = args.includes("--resume");
+const targetDir = path.resolve(process.cwd(), projectName);
 let projectCreated = false;
 const stepOrder = [
     "start",
@@ -77,18 +140,28 @@ const stepOrder = [
     "git-initialized",
     "done",
 ];
-const stateFile = path.join(targetDir, ".authenik8-state.json");
+const stepLabels = {
+    start: "Starting",
+    prompts: "Collecting inputs",
+    "project-created": "Project scaffold",
+    "auth-installed": "Auth setup",
+    "prisma-configured": "Prisma setup",
+    "deps-installed": "Dependencies install",
+    "prisma-generated": "Prisma generate",
+    "production-configured": "Production setup",
+    "git-initialized": "Git init",
+    done: "Completed",
+};
+const globalStateDir = path.join(process.cwd(), ".authenik8");
+const stateFile = path.join(globalStateDir, `${projectName}.json`);
 function hasReachedStep(currentStep, targetStep) {
     return stepOrder.indexOf(currentStep) >= stepOrder.indexOf(targetStep);
 }
-function saveState(step, extra = {}) {
-    fs.ensureDirSync(targetDir);
-    fs.writeJsonSync(stateFile, {
-        step,
-        projectName,
-        ...answers,
-        ...extra,
-    }, { spaces: 2 });
+//function saveState(step: StepName, extra: Partial<CliState> = {}) {
+function saveState(update) {
+    state = { ...state, ...update };
+    fs.ensureDirSync(path.dirname(stateFile));
+    fs.writeJsonSync(stateFile, state, { spaces: 2 });
 }
 function loadState() {
     if (!fs.existsSync(stateFile))
@@ -100,6 +173,27 @@ function clearState() {
         fs.removeSync(stateFile);
     }
 }
+function renderStep(current) {
+    console.clear();
+    renderHeader();
+    for (const step of stepOrder) {
+        const label = stepLabels[step];
+        if (step === "production-configured" && !isProduction) {
+            continue;
+        }
+        if (step === current) {
+            console.log(chalk.yellow(`⏳ ${label}...`));
+            break;
+        }
+        if (hasReachedStep(current, step)) {
+            console.log(chalk.green(`✔ ${label}`));
+        }
+        else {
+            console.log(chalk.gray(`○ ${label}`));
+        }
+    }
+    console.log("");
+}
 function isInterruptedError(err) {
     return (typeof err === "object" &&
         err !== null &&
@@ -107,12 +201,10 @@ function isInterruptedError(err) {
         (err.signal === "SIGINT" ||
             err.signal === "SIGTERM"));
 }
-function exitForInterrupt(err) {
+async function exitForInterrupt(err) {
     if (isInterruptedError(err)) {
         throw err;
     }
-    console.error(err);
-    process.exit(1);
 }
 async function cleanupIncompleteProject() {
     if (projectCreated && fs.existsSync(targetDir)) {
@@ -121,87 +213,92 @@ async function cleanupIncompleteProject() {
     }
 }
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-const cleanLogo = `
-
-█████╗      █████╗
-██╔══██╗    ██╔══██╗
-███████║    ╚█████╔╝
-██╔══██║    ██╔══██╗
-██║  ██║    ╚█████╔╝
-╚═╝  ╚═╝     ╚════╝
-
-A8
-
-Authenik8 CLI
-Build  Faster
-More , Secure
+const cleanLogo = `  
+  
+█████╗      █████╗  
+██╔══██╗    ██╔══██╗  
+███████║    ╚█████╔╝  
+██╔══██║    ██╔══██╗  
+██║  ██║    ╚█████╔╝  
+╚═╝  ╚═╝     ╚════╝  
+  
+A8  
+  
+Authenik8 CLI  
+Build  Faster  
+More , Secure  
 `;
 const glitchFrames = [
     `  
-█████╗      █████╗
-██╔══██╗    ██▒▒▒▒██
-███████║    ╚█████╔╝
-██╔══██║    ██▒▒▒▒██
-██║  ██║    ╚█████╔╝
-╚═╝  ╚═╝     ╚════╝
-
+█████╗      █████╗  
+██╔══██╗    ██▒▒▒▒██  
+███████║    ╚█████╔╝  
+██╔══██║    ██▒▒▒▒██  
+██║  ██║    ╚█████╔╝  
+╚═╝  ╚═╝     ╚════╝  
+  
 A8  
   Authenik8 CLI  
-
-  More
+  
+  More  
 `,
-    `
-██▓▓██╗    ██▓▓██╗
-██▒▒██╔╝    ██▒▒██╔╝
-██▒▒▒▒██    ╚█████╔╝
-██▓▓██╔╝    ██▒▒██╗
-██▒▒██║     ╚█████╔╝
-╚═════╝      ╚════╝
-
+    `  
+██▓▓██╗    ██▓▓██╗  
+██▒▒██╔╝    ██▒▒██╔╝  
+██▒▒▒▒██    ╚█████╔╝  
+██▓▓██╔╝    ██▒▒██╗  
+██▒▒██║     ╚█████╔╝  
+╚═════╝      ╚════╝  
+  
 A8  
   Authenik8 CLI  
-         Faster
+         Faster  
 `,
-    `
-██▒▒██╗    ██▒▒██╗
-██▓▓██╔╝    ██▓▓██╔╝
-██▒▒▒▒██    ╚█████╔╝
-██▓▓██╔╝    ██▓▓██╗
-██▒▒██║     ╚█████╔╝
-╚═════╝      ╚════╝
-
+    `  
+██▒▒██╗    ██▒▒██╗  
+██▓▓██╔╝    ██▓▓██╔╝  
+██▒▒▒▒██    ╚█████╔╝  
+██▓▓██╔╝    ██▓▓██╗  
+██▒▒██║     ╚█████╔╝  
+╚═════╝      ╚════╝  
+  
 A8  
   Authenik8 CLI  
-  Build
+  Build  
 `,
-    `
-██▓▓██╗    ██▓▓██╗
-██▒▒██╔╝    ██▒▒██╔╝
-██▒▒▒▒██    ╚█████╔╝
-██▓▓██╔╝    ██▒▒██╗
-██▒▒██║     ╚█████╔╝
-╚═════╝      ╚════╝
-
+    `  
+██▓▓██╗    ██▓▓██╗  
+██▒▒██╔╝    ██▒▒██╔╝  
+██▒▒▒▒██    ╚█████╔╝  
+██▓▓██╔╝    ██▒▒██╗  
+██▒▒██║     ╚█████╔╝  
+╚═════╝      ╚════╝  
+  
 A8  
-  Authenik8 CLI
-
+  Authenik8 CLI  
+  
 `
 ];
+function renderHeader() {
+    console.log(chalk.cyan.bold("Happy building \nAuthenik8 CLI"));
+    console.log(chalk.gray("────────────────────"));
+    console.log("");
+}
 async function showBootLogo() {
     console.clear();
-    const boot = ora("Initializing Authenik8 engine...").start();
-    // Phase 1: clean → unstable
+    spinner.text = "Initializing Authenik8 engine...";
+    // Phase 1: clean → unstable  
     console.clear();
     console.log(chalk.cyan(cleanLogo));
     await sleep(200);
-    // Phase 2: glitch burst (irregular feel)
+    // Phase 2: glitch burst (irregular feel)  
     for (let i = 0; i < 5; i++) {
         console.clear();
         const frame = glitchFrames[Math.floor(Math.random() * glitchFrames.length)];
         console.log(chalk.cyan(frame));
         await sleep(120 + Math.random() * 120);
     }
-    // Phase 3: stabilization flicker
+    // Phase 3: stabilization flicker  
     for (let i = 0; i < 2; i++) {
         console.clear();
         console.log(chalk.cyan(cleanLogo));
@@ -210,16 +307,19 @@ async function showBootLogo() {
         console.log(chalk.gray(cleanLogo));
         await sleep(120);
     }
-    // Final render
+    // Final render  
     console.clear();
     console.log(chalk.cyan.bold(cleanLogo));
     await sleep(800);
-    boot.succeed("Engine ready");
+    spinner.succeed("Engine ready");
 }
 async function main() {
     process.on("SIGINT", async () => {
-        console.log("\n👋 Authenik8 setup cancelled.");
-        await cleanupIncompleteProject();
+        console.log("\n");
+        spinner.stop();
+        killAllProcesses();
+        console.log(chalk.yellow("⏸ Setup interrupted."));
+        console.log(chalk.gray(`↻ Resume with: create-authenik8-app ${projectName} --resume`));
         process.exit(0);
     });
     try {
@@ -274,6 +374,8 @@ Features:
 • Prisma ORM (optional)
 • Git initialization (optional)
 • OAuth + Auth
+
+
 `));
         const savedState = loadState();
         let currentStep = "start";
@@ -286,23 +388,28 @@ Features:
             }
             process.exit(1);
         }
+        if (isResume || fs.existsSync(stateFile)) {
+            console.log(chalk.gray(`
+Resumable steps:
+✔ project scaffold
+✔ auth install
+✔ prisma setup
+✔ deps install
+✔ prisma generate
+✔ git init
+`));
+        }
         if (isResume) {
             if (!savedState) {
                 console.log(chalk.red(`❌ No saved setup state found for "${projectName}".`));
                 process.exit(1);
             }
-            answers = {
-                framework: savedState.framework,
-                usePrisma: savedState.usePrisma,
-                database: savedState.database,
-                useGit: savedState.useGit,
-                authMode: savedState.authMode,
-            };
-            currentStep = savedState.step;
+            state = savedState;
+            currentStep = state.step;
             console.log(chalk.yellow(`\n↻ Resuming setup for ${projectName} from "${currentStep}"...\n`));
         }
         else {
-            answers = await inquirer.prompt([
+            const promptAnswers = await inquirer.prompt([
                 {
                     type: "list",
                     name: "framework",
@@ -344,7 +451,17 @@ Features:
                     default: "base"
                 }
             ]);
-            saveState("prompts");
+            //saveState({
+            //...promptAnswers,
+            //step:"prompts"});
+            state = {
+                ...state,
+                ...promptAnswers,
+                step: "prompts"
+            };
+            saveState({
+                ...state
+            });
             currentStep = "prompts";
         }
         function assertRequired(value, name) {
@@ -353,36 +470,35 @@ Features:
                 process.exit(1);
             }
         }
-        assertRequired(answers.framework, "framework");
-        assertRequired(answers.authMode, "authMode");
-        if (answers.usePrisma) {
-            if (!answers.database) {
-                answers.database = "sqlite";
+        assertRequired(state.framework, "framework");
+        assertRequired(state.authMode, "authMode");
+        if (state.usePrisma) {
+            if (!state.database) {
+                state.database = "sqlite";
             }
-            assertRequired(answers.database, "database");
+            assertRequired(state.database, "database");
         }
-        console.log(chalk.cyan("\n⚙️ Setting things up...\n"));
+        console.log(chalk.cyan("\nSetting up your project\n"));
         const templateRoot = path.resolve(__dirname, "../../templates");
         let templateName = "express-base";
-        if (answers.authMode === "auth") {
+        if (state.authMode === "auth") {
             templateName = "express-auth";
         }
-        if (answers.authMode === "auth-oauth") {
+        if (state.authMode === "auth-oauth") {
             templateName = "express-auth+";
         }
         const templatePath = path.join(templateRoot, templateName);
         // 📁 Create project (SPINNER)
         if (!hasReachedStep(currentStep, "project-created")) {
-            const createSpinner = ora("Creating project structure...").start();
+            renderStep("project-created");
             try {
                 await fs.copy(templatePath, targetDir);
                 projectCreated = true;
-                createSpinner.succeed("Project files created");
-                saveState("project-created");
+                saveState({ step: "project-created" });
                 currentStep = "project-created";
+                renderStep(currentStep);
             }
             catch (err) {
-                createSpinner.fail("Failed to create project");
                 console.error(err);
                 process.exit(1);
             }
@@ -392,53 +508,44 @@ Features:
         }
         let selectedHash = "bcryptjs"; // default safe fallback
         if (!hasReachedStep(currentStep, "auth-installed")) {
-            if (answers.authMode !== "base") {
-                const authSpinner = ora("Installing password auth...").start();
+            if (state.authMode !== "base") {
+                spinner.start("Installing password auth...");
                 selectedHash = getBestHashLib();
-                const installResult = spawnSync("npm", ["install", selectedHash], {
-                    cwd: targetDir,
-                    stdio: "ignore"
-                });
-                if (!installResult.error && installResult.status === 0) {
-                    authSpinner.succeed(`Password auth ready ${selectedHash}`);
+                try {
+                    const installResult = await run(getCommand("npm"), ["install", selectedHash], {
+                        cwd: targetDir,
+                        stdio: "ignore"
+                    });
                 }
-                else {
+                catch {
                     if (selectedHash !== "bcryptjs") {
-                        authSpinner.warn(`${selectedHash} failed, falling back to bcryptjs`);
-                        const fallbackResult = spawnSync("npm", ["install", "bcryptjs"], {
+                        spinner.warn(`${selectedHash} failed, falling back to bcryptjs`);
+                        const fallbackResult = await run(getCommand("npm"), ["install", "bcryptjs"], {
                             cwd: targetDir,
                             stdio: "ignore",
                         });
-                        if (!fallbackResult.error && fallbackResult.status === 0) {
-                            selectedHash = "bcryptjs";
-                            authSpinner.succeed("Password auth ready (bcryptjs fallback)");
-                        }
-                        else {
-                            authSpinner.fail("Failed to install password auth");
-                            process.exit(1);
-                        }
+                        spinner.stop();
+                        selectedHash = "bcryptjs";
+                        renderStep("auth-installed");
                     }
                     else {
-                        authSpinner.fail("Failed to install password auth");
+                        spinner.fail("Failed to install password auth");
+                        process.exit(1);
+                        spinner.fail("Failed to install password auth");
                         process.exit(1);
                     }
                 }
             }
-            if (answers.authMode !== "base") {
+            renderStep("auth-installed");
+            if (state.authMode !== "base") {
+                spinner.start("Installing password auth...");
                 const hashLib = selectedHash;
                 await fs.writeFile(path.join(targetDir, "src/utils/hash.ts"), generateHashModule(hashLib));
-                //const deps = [];
-                //if (hashLib === "argon2") deps.push("argon2");
-                //if (hashLib === "bcryptjs") deps.push("bcryptjs");
-                //if (deps.length) {
-                //execSync(`npm install ${deps.join(" ")}`, {
-                //cwd: targetDir,
-                //stdio: "ignore",
-                //});
-                //};
             }
-            saveState("auth-installed", answers.authMode !== "base" ? { hashLib: selectedHash } : {});
+            saveState({ step: "auth-installed", ...(state.authMode !== "base" && { hashLib: selectedHash })
+            });
             currentStep = "auth-installed";
+            renderStep(currentStep);
         }
         else {
             selectedHash = savedState?.hashLib ?? selectedHash;
@@ -451,12 +558,12 @@ Features:
                 ...pkg.dependencies,
                 ioredis: "^5.8.1",
             };
-            if (answers.usePrisma) {
-                const prismaSpinner = ora("Adding Prisma setup...").start();
+            if (state.usePrisma) {
+                spinner.start("Adding Prisma setup...");
                 try {
-                    const dbType = answers.database ===
-                        "postgresql" ? "postgresql"
-                        : "sqlite";
+                    const dbType = state.database ===
+                        "postgresql" ? "postgresql" :
+                        "sqlite";
                     const prismaTemplatePath = path.join(templateRoot, `prisma/${dbType}`);
                     // Copy prisma schema  
                     await fs.copy(path.join(prismaTemplatePath, "schema.prisma"), path.join(targetDir, "prisma/schema.prisma"));
@@ -478,92 +585,106 @@ Features:
                         "prisma:migrate": "prisma migrate dev",
                     };
                     await fs.writeJson(pkgPath, pkg, { spaces: 2 });
-                    prismaSpinner.succeed(`Prisma (${dbType}) configured`);
+                    spinner.succeed(`Prisma (${dbType}) configured`);
                 }
                 catch (err) {
-                    prismaSpinner.fail("Failed to setup Prisma");
+                    spinner.fail("Failed to setup Prisma");
                     exitForInterrupt(err);
                 }
             }
             await fs.writeJson(pkgPath, pkg, { spaces: 2 });
-            saveState("prisma-configured", answers.authMode !== "base" ? { hashLib: selectedHash } : {});
+            saveState({ step: "prisma-configured", ...(state.authMode !== "base" && { hashLib: selectedHash })
+            });
             currentStep = "prisma-configured";
+            renderStep(currentStep);
         }
         else {
-            console.log(chalk.gray("↷ Skipping Prisma/package setup (already completed)"));
+            console.log(chalk.gray(" Skipping Prisma/package setup (already completed)"));
         }
         if (!hasReachedStep(currentStep, "deps-installed")) {
-            const installSpinner = ora("Installing dependencies...(this may take a few minutes)").start();
+            renderStep("deps-installed");
+            spinner.start("Installing dependencies...(this may take a few minutes)");
             try {
-                execSync("npm install", {
+                await run(getCommand("npm"), ["install"], {
                     cwd: targetDir,
                     stdio: "ignore",
                 });
-                installSpinner.succeed("Dependencies installed");
+                spinner.stop();
             }
             catch (err) {
-                installSpinner.fail("Failed to install dependencies");
+                spinner.fail("Failed to install dependencies");
                 exitForInterrupt(err);
             }
-            saveState("deps-installed", answers.authMode !== "base" ? { hashLib: selectedHash } : {});
+            saveState({ step: "deps-installed", ...(state.authMode !== "base" && { hashLib: selectedHash })
+            });
             currentStep = "deps-installed";
+            renderStep(currentStep);
         }
         else {
-            console.log(chalk.gray("↷ Skipping dependency install (already completed)"));
+            await run(getCommand("npm"), ["install"], {
+                cwd: targetDir,
+                stdio: "ignore",
+            });
         }
         if (!hasReachedStep(currentStep, "prisma-generated")) {
-            if (answers.usePrisma) {
-                const prismaGenSpinner = ora("Generating Prisma client...").start();
+            if (state.usePrisma) {
+                spinner.start("Generating Prisma client...");
                 try {
-                    execSync("npx prisma@5.22.0 generate", {
+                    await run(getCommand("npx"), ["prisma@5.22.0", "generate"], {
                         cwd: targetDir,
                         stdio: "ignore"
                     });
-                    prismaGenSpinner.succeed("Prisma client generated");
+                    spinner.stop();
                 }
                 catch (err) {
-                    prismaGenSpinner.fail("Failed to generate Prisma client");
+                    spinner.fail("Failed to generate Prisma client");
                     exitForInterrupt(err);
                 }
             }
-            saveState("prisma-generated", answers.authMode !== "base" ? { hashLib: selectedHash } : {});
+            saveState({ step: "prisma-generated", ...(state.authMode !== "base" && { hashLib: selectedHash })
+            });
             currentStep = "prisma-generated";
+            renderStep(currentStep);
         }
         else {
             console.log(chalk.gray("↷ Skipping Prisma client generation (already completed)"));
         }
         if (isProduction && !hasReachedStep(currentStep, "production-configured")) {
-            const pm2Spinner = ora("Setting up production mode (PM2)...").start();
+            spinner.start("Setting up production mode (PM2)...");
             try {
-                execSync("npm install pm2", {
+                await run(getCommand("npm"), ["install pm2"], {
                     cwd: targetDir,
                     stdio: "ignore",
                 });
-                pm2Spinner.succeed("PM2 installed (production-ready)");
+                spinner.stop();
             }
             catch (err) {
-                pm2Spinner.fail("Failed to install PM2");
+                spinner.fail("Failed to install PM2");
                 exitForInterrupt(err);
             }
-            saveState("production-configured", answers.authMode !== "base" ? { hashLib: selectedHash } : {});
+            saveState({ step: "production-configured", ...(state.authMode !== "base" && { hashLib: selectedHash })
+            });
             currentStep = "production-configured";
+            renderStep(currentStep);
         }
         if (!hasReachedStep(currentStep, "git-initialized")) {
-            if (answers.useGit) {
-                const gitSpinner = ora("Initializing git...").start();
+            if (state.useGit) {
+                renderStep("git-initialized");
                 try {
-                    execSync("git init", {
+                    await run(getCommand("git"), ["init"], {
                         cwd: targetDir,
                         stdio: "ignore",
                     });
-                    gitSpinner.succeed("Git initialized");
+                    spinner.stop();
                 }
                 catch (err) {
-                    gitSpinner.fail("Git init failed");
+                    spinner.fail("Git init failed");
                 }
             }
-            saveState("git-initialized", answers.authMode !== "base" ? { hashLib: selectedHash } : {});
+            saveState({ step: "git-initialized", ...(state.authMode !== "base" && { hashLib: selectedHash }),
+            });
             currentStep = "git-initialized";
+            renderStep("done");
         }
         else {
             console.log(chalk.gray("↷ Skipping git init (already completed)"));
@@ -598,28 +719,28 @@ redis-server --daemonize yes
 npm run dev
 
 Auth Features:
-${answers.authMode === "base"
+${state.authMode === "base"
             ? "✓ JWT only"
-            : answers.authMode === "auth"
+            : state.authMode === "auth"
                 ? "✓ Email + Password"
                 : "✓ Password + OAuth (Google/GitHub)"}
 
 🛠 Stack:
 ✔ Express
-✔ ${answers.usePrisma ? (answers.database === "postgresql" ? "PostgreSQL" : "SQLite") : "No database"}
-✔ ${answers.usePrisma ? "Prisma ORM" : "No ORM"}
+✔ ${state.usePrisma ? (state.database === "postgresql" ? "PostgreSQL" : "SQLite") : "No database"}
+✔ ${state.usePrisma ? "Prisma ORM" : "No ORM"}
 
 📡 API Routes:
-${answers.authMode === "base"
+${state.authMode === "base"
             ? `
   GET    /public
   GET    /guest
   GET    /protected
   POST   /refresh
 `
-            : answers.authMode === "auth"
+            : state.authMode === "auth"
                 ? `
-  POST   /auth/register
+  POST   /auth/register	
   POST   /auth/login
   POST   /auth/refresh
   GET    /protected
@@ -647,17 +768,24 @@ Run:
 npm run pm2:start
 `);
         }
-        saveState("done", answers.authMode !== "base" ? { hashLib: selectedHash } : {});
+        saveState({ step: "done", ...(state.authMode !== "base" && { hashLib: selectedHash }),
+        });
         clearState();
     }
     catch (err) {
-        console.error("Fatal error", err);
-        process.exit(1);
+        if (err instanceof ExitPromptError) {
+            throw err;
+            console.error("Fatal error", err);
+            process.exit(1);
+        }
     }
 }
 main().catch(async (err) => {
     if (err instanceof ExitPromptError) {
-        console.log("\n👋 Authenik8 setup cancelled.");
+        console.log("\n👋 Authenik8 setup cancelled.You can --resume later");
+        killAllProcesses();
+        await new Promise((r) => setTimeout(r, 300));
+        console.log(chalk.bgYellow.black(" SETUP CANCELLED "));
         await cleanupIncompleteProject();
         process.exit(0);
     }