create-authenik8-app 2.0.6 → 2.0.8

package/dist/bin/index.js

@@ -5,39 +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";
-function step(name, fn) {
-    return { name, fn };
+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();
 }
-let state = {};
-let answers = {};
-const stateFile = (project) => path.join(process.cwd(), project, ".authenik8-state.json");
-function saveState(project, state) {
-    fs.ensureDirSync(path.join(process.cwd(), project));
-    fs.writeJsonSync(stateFile(project), state, { spaces: 2 });
+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;
 }
-function loadState(project) {
-    const file = stateFile(project);
-    if (!fs.existsSync(file))
-        return null;
-    return fs.readJsonSync(file);
+//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;
+    }
 }
-function clearState(project) {
-    const file = stateFile(project);
-    if (fs.existsSync(file))
-        fs.removeSync(file);
+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 isResume = process.argv.includes("--resume");
+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
@@ -49,17 +96,6 @@ function getBestHashLib() {
     // but still fallback later if needed
     return "bcryptjs";
 }
-function createSaver(projectName, ctx) {
-    return (step, extra) => {
-        saveState(projectName, {
-            step,
-            projectName,
-            ...ctx.state,
-            ...ctx.answers,
-            ...extra,
-        });
-    };
-}
 function generateHashModule(hashLib) {
     if (hashLib === "argon2") {
         return `
@@ -88,122 +124,181 @@ 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 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 exists = fs.existsSync(targetDir);
-if (isResume) {
+const stepOrder = [
+    "start",
+    "prompts",
+    "project-created",
+    "auth-installed",
+    "prisma-configured",
+    "deps-installed",
+    "prisma-generated",
+    "production-configured",
+    "git-initialized",
+    "done",
+];
+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);
 }
-if (exists && !isResume) {
-    const { action } = await inquirer.prompt([
-        {
-            type: "select",
-            name: "action",
-            message: `Folder "${projectName}" already exists. What do you want to do?`,
-            choices: [
-                { name: "Resume setup", value: "resume" },
-                { name: "Overwrite", value: "overwrite" },
-                { name: "Cancel", value: "cancel" },
-            ],
-        },
-    ]);
-    if (action === "resume") {
-        // trigger resume logic
+//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))
+        return null;
+    return fs.readJsonSync(stateFile);
+}
+function clearState() {
+    if (fs.existsSync(stateFile)) {
+        fs.removeSync(stateFile);
     }
-    if (action === "overwrite") {
-        await fs.remove(targetDir);
+}
+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}`));
+        }
     }
-    if (action === "cancel") {
-        process.exit(0);
+    console.log("");
+}
+function isInterruptedError(err) {
+    return (typeof err === "object" &&
+        err !== null &&
+        "signal" in err &&
+        (err.signal === "SIGINT" ||
+            err.signal === "SIGTERM"));
+}
+async function exitForInterrupt(err) {
+    if (isInterruptedError(err)) {
+        throw err;
+    }
+}
+async function cleanupIncompleteProject() {
+    if (projectCreated && fs.existsSync(targetDir)) {
+        await fs.remove(targetDir);
+        console.log("🧹 Cleaned up incomplete project.");
     }
 }
 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));
@@ -212,14 +307,21 @@ 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");
 }
-//const isResume = process.argv.includes("--resume");
 async function main() {
+    process.on("SIGINT", async () => {
+        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 {
         await showBootLogo();
         if (process.argv.includes("--help")) {
@@ -272,227 +374,320 @@ Features:
 • Prisma ORM (optional)
 • Git initialization (optional)
 • OAuth + Auth
+
+
+`));
+        const savedState = loadState();
+        let currentStep = "start";
+        if (!isResume && fs.existsSync(targetDir)) {
+            if (savedState) {
+                console.log(chalk.red(`❌ "${projectName}" already contains an incomplete Authenik8 setup. Run again with --resume.`));
+            }
+            else {
+                console.log(chalk.red(`❌ Directory "${projectName}" already exists.`));
+            }
+            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
 `));
-        answers = await inquirer.prompt([
-            {
-                type: "list",
-                name: "framework",
-                message: "Choose framework:",
-                choices: ["Express", "Fastify (coming soon)"],
-                default: state.framework ?? "Express",
-            },
-            {
-                type: "confirm",
-                name: "usePrisma",
-                message: "Use Prisma?",
-                default: state.usePrisma ?? true,
-            },
-            {
-                type: "list",
-                name: "database",
-                message: "Choose database:",
-                choices: [
-                    { name: "PostgreSQL", value: "postgresql" },
-                    { name: "SQLite ", value: "sqlite" }
-                ],
-                when: (answers) => answers.usePrisma,
-                default: state.database ?? "sqlite",
-            },
-            {
-                type: "confirm",
-                name: "useGit",
-                message: "Initialize git?",
-                default: state.useGit ?? true,
-            }, {
-                type: "list",
-                name: "authMode",
-                message: "Choose authentication setup:",
-                choices: [
-                    { name: "JWT only", value: "base" },
-                    { name: "Email + Password Auth", value: "auth" },
-                    { name: "Full Auth (Password + OAuth)", value: "auth-oauth" },
-                ],
-                default: state.authMode ?? "base"
+        }
+        if (isResume) {
+            if (!savedState) {
+                console.log(chalk.red(`❌ No saved setup state found for "${projectName}".`));
+                process.exit(1);
             }
-        ]);
+            state = savedState;
+            currentStep = state.step;
+            console.log(chalk.yellow(`\n↻ Resuming setup for ${projectName} from "${currentStep}"...\n`));
+        }
+        else {
+            const promptAnswers = await inquirer.prompt([
+                {
+                    type: "list",
+                    name: "framework",
+                    message: "Choose framework:",
+                    choices: ["Express", "Fastify (coming soon)"],
+                    default: "Express",
+                },
+                {
+                    type: "confirm",
+                    name: "usePrisma",
+                    message: "Use Prisma?",
+                    default: true,
+                },
+                {
+                    type: "list",
+                    name: "database",
+                    message: "Choose database:",
+                    choices: [
+                        { name: "PostgreSQL", value: "postgresql" },
+                        { name: "SQLite ", value: "sqlite" }
+                    ],
+                    when: (answers) => answers.usePrisma,
+                    default: "sqlite",
+                },
+                {
+                    type: "confirm",
+                    name: "useGit",
+                    message: "Initialize git?",
+                    default: true,
+                }, {
+                    type: "list",
+                    name: "authMode",
+                    message: "Choose authentication setup:",
+                    choices: [
+                        { name: "JWT only", value: "base" },
+                        { name: "Email + Password Auth", value: "auth" },
+                        { name: "Full Auth (Password + OAuth)", value: "auth-oauth" },
+                    ],
+                    default: "base"
+                }
+            ]);
+            //saveState({
+            //...promptAnswers,
+            //step:"prompts"});
+            state = {
+                ...state,
+                ...promptAnswers,
+                step: "prompts"
+            };
+            saveState({
+                ...state
+            });
+            currentStep = "prompts";
+        }
         function assertRequired(value, name) {
             if (value === undefined || value === null || value === "") {
                 console.log(`❌ Missing required input: ${name}`);
                 process.exit(1);
             }
         }
-        const finalConfig = {
-            ...state,
-            ...answers,
-        };
-        assertRequired(finalConfig.framework, "framework");
-        assertRequired(finalConfig.authMode, "authMode");
-        if (finalConfig.usePrisma && !finalConfig.database) {
-            finalConfig.database = "sqlite";
-        }
-        if (finalConfig.usePrisma) {
-            assertRequired(finalConfig.database, "database");
-        }
-        if (finalConfig.usePrisma && !answers.database && !state.database) {
-            console.log(chalk.gray("ℹ️ Defaulting to SQLite (quick start)"));
-        }
-        if (!answers.authMode || !answers.framework) {
-            console.log("❌ Invalid setup state. Restart CLI.");
-            process.exit(1);
+        assertRequired(state.framework, "framework");
+        assertRequired(state.authMode, "authMode");
+        if (state.usePrisma) {
+            if (!state.database) {
+                state.database = "sqlite";
+            }
+            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)
-        const createSpinner = ora("Creating project structure...").start();
-        try {
-            await fs.copy(templatePath, targetDir);
-            projectCreated = true;
-            createSpinner.succeed("Project files created");
-        }
-        catch (err) {
-            createSpinner.fail("Failed to create project");
-            console.error(err);
-            process.exit(1);
-        }
-        let selectedHash = "bcryptjs"; // default safe fallback
-        if (answers.authMode !== "base") {
-            const authSpinner = ora("Installing password auth...").start();
-            selectedHash = getBestHashLib();
+        if (!hasReachedStep(currentStep, "project-created")) {
+            renderStep("project-created");
             try {
-                spawnSync("npm", ["install", selectedHash], {
-                    cwd: targetDir,
-                    stdio: "ignore"
-                });
-                authSpinner.succeed(`Password auth ready ${selectedHash}`);
+                await fs.copy(templatePath, targetDir);
+                projectCreated = true;
+                saveState({ step: "project-created" });
+                currentStep = "project-created";
+                renderStep(currentStep);
             }
             catch (err) {
-                if (selectedHash !== "bcryptjs") {
-                    authSpinner.warn(`${selectedHash} failed, falling back to bcryptjs`);
-                    spawnSync("npm", ["install", "bcryptjs"], {
+                console.error(err);
+                process.exit(1);
+            }
+        }
+        else {
+            console.log(chalk.gray("↷ Skipping project creation (already completed)"));
+        }
+        let selectedHash = "bcryptjs"; // default safe fallback
+        if (!hasReachedStep(currentStep, "auth-installed")) {
+            if (state.authMode !== "base") {
+                spinner.start("Installing password auth...");
+                selectedHash = getBestHashLib();
+                try {
+                    const installResult = await run(getCommand("npm"), ["install", selectedHash], {
                         cwd: targetDir,
-                        stdio: "ignore",
+                        stdio: "ignore"
                     });
-                    selectedHash = "bcryptjs";
-                    authSpinner.succeed("Password auth ready (bcryptjs fallback)");
                 }
-                else {
-                    authSpinner.fail("Failed to install password auth");
-                    process.exit(1);
+                catch {
+                    if (selectedHash !== "bcryptjs") {
+                        spinner.warn(`${selectedHash} failed, falling back to bcryptjs`);
+                        const fallbackResult = await run(getCommand("npm"), ["install", "bcryptjs"], {
+                            cwd: targetDir,
+                            stdio: "ignore",
+                        });
+                        spinner.stop();
+                        selectedHash = "bcryptjs";
+                        renderStep("auth-installed");
+                    }
+                    else {
+                        spinner.fail("Failed to install password auth");
+                        process.exit(1);
+                        spinner.fail("Failed to install password auth");
+                        process.exit(1);
+                    }
                 }
             }
+            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));
+            }
+            saveState({ step: "auth-installed", ...(state.authMode !== "base" && { hashLib: selectedHash })
+            });
+            currentStep = "auth-installed";
+            renderStep(currentStep);
         }
-        if (answers.authMode !== "base") {
-            const hashLib = getBestHashLib(); // or CLI decision
-            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",
-                });
+        else {
+            selectedHash = savedState?.hashLib ?? selectedHash;
+            console.log(chalk.gray("↷ Skipping auth setup (already completed)"));
+        }
+        if (!hasReachedStep(currentStep, "prisma-configured")) {
+            const pkgPath = path.join(targetDir, "package.json");
+            const pkg = await fs.readJson(pkgPath);
+            pkg.dependencies = {
+                ...pkg.dependencies,
+                ioredis: "^5.8.1",
+            };
+            if (state.usePrisma) {
+                spinner.start("Adding Prisma setup...");
+                try {
+                    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"));
+                    // Copy env  
+                    await fs.copy(path.join(prismaTemplatePath, ".env"), path.join(targetDir, ".env"));
+                    // Inject dependencies
+                    pkg.dependencies = {
+                        ...pkg.dependencies,
+                        "@prisma/client": "5.22.0",
+                    };
+                    pkg.devDependencies = {
+                        ...pkg.devDependencies,
+                        prisma: "5.22.0",
+                    };
+                    // Add scripts  
+                    pkg.scripts = {
+                        ...pkg.scripts,
+                        "prisma:generate": "prisma generate",
+                        "prisma:migrate": "prisma migrate dev",
+                    };
+                    await fs.writeJson(pkgPath, pkg, { spaces: 2 });
+                    spinner.succeed(`Prisma (${dbType}) configured`);
+                }
+                catch (err) {
+                    spinner.fail("Failed to setup Prisma");
+                    exitForInterrupt(err);
+                }
             }
-            ;
+            await fs.writeJson(pkgPath, pkg, { spaces: 2 });
+            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)"));
         }
-        if (answers.usePrisma) {
-            const prismaSpinner = ora("Adding Prisma setup...").start();
+        if (!hasReachedStep(currentStep, "deps-installed")) {
+            renderStep("deps-installed");
+            spinner.start("Installing dependencies...(this may take a few minutes)");
             try {
-                const dbType = answers.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"));
-                // Copy env  
-                await fs.copy(path.join(prismaTemplatePath, ".env"), path.join(targetDir, ".env"));
-                const pkgPath = path.join(targetDir, "package.json");
-                const pkg = await fs.readJson(pkgPath);
-                await fs.writeJson(pkgPath, pkg, { spaces: 2 });
-                // Inject dependencies
-                pkg.dependencies = {
-                    ...pkg.dependencies,
-                    "@prisma/client": "5.22.0",
-                };
-                pkg.devDependencies = {
-                    ...pkg.devDependencies,
-                    prisma: "5.22.0",
-                };
-                // Add scripts  
-                pkg.scripts = {
-                    ...pkg.scripts,
-                    "prisma:generate": "prisma generate",
-                    "prisma:migrate": "prisma migrate dev",
-                };
-                prismaSpinner.succeed(`Prisma (${dbType}) configured`);
+                await run(getCommand("npm"), ["install"], {
+                    cwd: targetDir,
+                    stdio: "ignore",
+                });
+                spinner.stop();
             }
             catch (err) {
-                prismaSpinner.fail("Failed to setup Prisma");
-                console.error(err);
+                spinner.fail("Failed to install dependencies");
+                exitForInterrupt(err);
             }
-            if (answers.usePrisma) {
-                const prismaGenSpinner = ora("Generating Prisma client...").start();
+            saveState({ step: "deps-installed", ...(state.authMode !== "base" && { hashLib: selectedHash })
+            });
+            currentStep = "deps-installed";
+            renderStep(currentStep);
+        }
+        else {
+            await run(getCommand("npm"), ["install"], {
+                cwd: targetDir,
+                stdio: "ignore",
+            });
+        }
+        if (!hasReachedStep(currentStep, "prisma-generated")) {
+            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");
-                    console.error(err);
+                    spinner.fail("Failed to generate Prisma client");
+                    exitForInterrupt(err);
                 }
             }
-            const installSpinner = ora("Installing dependencies...(this may take a few minutes)").start();
+            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")) {
+            spinner.start("Setting up production mode (PM2)...");
             try {
-                execSync("npm install", {
+                await run(getCommand("npm"), ["install pm2"], {
                     cwd: targetDir,
                     stdio: "ignore",
                 });
-                installSpinner.succeed("Dependencies installed");
+                spinner.stop();
             }
             catch (err) {
-                installSpinner.fail("Failed to install dependencies");
-                console.error(err);
-                process.exit(1);
+                spinner.fail("Failed to install PM2");
+                exitForInterrupt(err);
             }
-            if (isProduction) {
-                const pm2Spinner = ora("Setting up production mode (PM2)...").start();
+            saveState({ step: "production-configured", ...(state.authMode !== "base" && { hashLib: selectedHash })
+            });
+            currentStep = "production-configured";
+            renderStep(currentStep);
+        }
+        if (!hasReachedStep(currentStep, "git-initialized")) {
+            if (state.useGit) {
+                renderStep("git-initialized");
                 try {
-                    execSync("npm install pm2", {
+                    await run(getCommand("git"), ["init"], {
                         cwd: targetDir,
                         stdio: "ignore",
                     });
-                    pm2Spinner.succeed("PM2 installed (production-ready)");
+                    spinner.stop();
                 }
                 catch (err) {
-                    pm2Spinner.fail("Failed to install PM2");
+                    spinner.fail("Git init failed");
                 }
             }
+            saveState({ step: "git-initialized", ...(state.authMode !== "base" && { hashLib: selectedHash }),
+            });
+            currentStep = "git-initialized";
+            renderStep("done");
         }
-        if (answers.useGit) {
-            const gitSpinner = ora("Initializing git...").start();
-            try {
-                execSync("git init", {
-                    cwd: targetDir,
-                    stdio: "ignore",
-                });
-                gitSpinner.succeed("Git initialized");
-            }
-            catch (err) {
-                gitSpinner.fail("Git init failed");
-            }
+        else {
+            console.log(chalk.gray("↷ Skipping git init (already completed)"));
         }
         console.log(chalk.green.bold("\n🎉 Authenik8 app created successfully!\n"));
         if (isProduction) {
@@ -524,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.includes("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
@@ -573,26 +768,29 @@ Run:
 npm run pm2:start
 `);
         }
+        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);
+        }
     }
 }
-process.on("SIGINT", () => {
-    console.log("\n👋 Cancelled.");
-    process.exit(0);
-});
 main().catch(async (err) => {
     if (err instanceof ExitPromptError) {
-        console.log("\n👋 Authenik8 setup cancelled.");
-        if (projectCreated && fs.existsSync(targetDir)) {
-            await fs.remove(targetDir);
-            console.log("🧹 Cleaned up incomplete project.");
-        }
+        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);
     }
-    console.error("❌ Unexpected error:", err);
+    console.error(chalk.red("\n❌ Unexpected error:"), err);
+    await cleanupIncompleteProject();
     process.exit(1);
 });
 //# sourceMappingURL=index.js.map