@expressots/cli 3.0.0 → 4.0.0-preview.2

package/bin/new/form.js

@@ -8,115 +8,259 @@ const chalk_1 = __importDefault(require("chalk"));
 const cli_progress_1 = require("cli-progress");
 const degit_1 = __importDefault(require("degit"));
 const inquirer_1 = __importDefault(require("inquirer"));
-const node_child_process_1 = require("node:child_process");
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const cli_1 = require("../cli");
 const center_text_1 = require("../utils/center-text");
 const change_package_info_1 = require("../utils/change-package-info");
 const cli_ui_1 = require("../utils/cli-ui");
+const input_validation_1 = require("../utils/input-validation");
+const safe_spawn_1 = require("../utils/safe-spawn");
+/**
+ * Install dependencies using the selected package manager
+ */
 async function packageManagerInstall({ packageManager, directory, progressBar, }) {
-    const command = process.platform === "win32" ? `${packageManager}.cmd` : packageManager;
-    const args = ["install", "--silent"];
+    if (!(0, input_validation_1.isValidPackageManager)(packageManager)) {
+        throw new Error(`Invalid package manager: ${packageManager}`);
+    }
+    // npm's `--silent` swallows errors too (loglevel=silent), which
+    // makes failures impossible to diagnose. `--loglevel=error` keeps
+    // the install quiet on the happy path but lets real failures
+    // stream to stderr so we can capture and surface them below.
+    const args = packageManager === "npm"
+        ? ["install", "--loglevel=error"]
+        : ["install", "--silent"];
     if (packageManager === "yarn") {
         args.push("--ignore-engines");
-        args.splice(args.indexOf("--prefer-offline"), 1);
     }
     return new Promise((resolve, reject) => {
-        const installProcess = (0, node_child_process_1.spawn)(command, args, {
+        // `safeSpawn` (cross-spawn) handles the Windows `.cmd` shim
+        // resolution and properly escapes argv even when the shell is
+        // involved on Windows. The `directory` value is only used as
+        // cwd; it is never interpolated into a command string.
+        const installProcess = (0, safe_spawn_1.safeSpawn)(packageManager, args, {
             cwd: directory,
-            shell: true,
             timeout: 600000,
         });
-        // Simulate incremental progress
-        let progress = 0;
+        let progress = 50;
+        let lastProgressUpdate = Date.now();
         const interval = setInterval(() => {
-            if (progress < 90) {
-                progress += 5;
-                progressBar.update(progress);
+            const now = Date.now();
+            if (progress < 88) {
+                const increment = progress < 70 ? 3 : 1;
+                progress = Math.min(progress + increment, 88);
+                progressBar.update(progress, {
+                    doing: "Installing dependencies...",
+                });
+            }
+            else if (now - lastProgressUpdate > 3000) {
+                progressBar.update(progress, {
+                    doing: "Installing dependencies...",
+                });
             }
         }, 1000);
-        // Handle stdout for meaningful output or progress feedback
+        // Keep a rolling tail of stderr/stdout so we can surface a
+        // meaningful diagnostic when the install exits non-zero (npm's
+        // real error is otherwise hidden behind `--silent`).
+        const diagnosticBuffer = [];
+        const MAX_DIAGNOSTIC_LINES = 20;
+        const recordDiagnostic = (chunk) => {
+            for (const line of chunk.split(/\r?\n/)) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                diagnosticBuffer.push(trimmed);
+                if (diagnosticBuffer.length > MAX_DIAGNOSTIC_LINES) {
+                    diagnosticBuffer.shift();
+                }
+            }
+        };
         installProcess.stdout?.on("data", (data) => {
-            const output = data.toString().trim();
-            // Remove all data from || to the end of the line
-            const cleanedOutput = output.replace(/\|\|.*$/g, "");
-            // Match and handle npm-specific progress
+            const output = data.toString();
+            recordDiagnostic(output);
+            const cleanedOutput = output.trim().replace(/\|\|.*$/g, "");
             const npmProgressMatch = cleanedOutput.match(/\[(\d+)\/(\d+)\] (?:npm )?([\w\s]+)\.{3}/);
             if (npmProgressMatch) {
                 const [, current, total, task] = npmProgressMatch;
-                progress = Math.round((parseInt(current) / parseInt(total)) * 100);
+                const npmProgress = (parseInt(current) / parseInt(total)) * 100;
+                progress = Math.round(50 + npmProgress * 0.4);
+                lastProgressUpdate = Date.now();
                 progressBar.update(progress, { doing: task });
             }
-            else {
-                // Update "task" without changing the progress
+            else if (cleanedOutput) {
+                lastProgressUpdate = Date.now();
                 progressBar.update(progress, { doing: cleanedOutput });
             }
         });
-        // Handle errors
+        installProcess.stderr?.on("data", (data) => {
+            const output = data.toString();
+            recordDiagnostic(output);
+            const cleanedOutput = output.trim().replace(/\|\|.*$/g, "");
+            const npmProgressMatch = cleanedOutput.match(/\[(\d+)\/(\d+)\] (?:npm )?([\w\s]+)\.{3}/);
+            if (npmProgressMatch) {
+                const [, current, total, task] = npmProgressMatch;
+                const npmProgress = (parseInt(current) / parseInt(total)) * 100;
+                progress = Math.round(50 + npmProgress * 0.4);
+                lastProgressUpdate = Date.now();
+                progressBar.update(progress, { doing: task });
+            }
+        });
         installProcess.on("error", (error) => {
-            clearInterval(interval); // Stop interval on error
+            clearInterval(interval);
             progressBar.stop();
             reject(new Error(`Failed to start subprocess: ${error.message}`));
         });
-        // Finalize progress on close
         installProcess.on("close", (code) => {
-            clearInterval(interval); // Stop interval when the process ends
+            clearInterval(interval);
             if (code === 0) {
-                progressBar.update(100, { doing: "Complete!" }); // Finalize progress
-                progressBar.stop();
+                progressBar.update(90, { doing: "Dependencies installed" });
                 resolve("Installation Done!");
             }
             else {
                 progressBar.stop();
+                if (diagnosticBuffer.length > 0) {
+                    console.log("\n");
+                    console.log(chalk_1.default.bold.red(`${packageManager} install failed with exit code ${code}:`));
+                    for (const line of diagnosticBuffer) {
+                        console.log(chalk_1.default.gray(`  ${line}`));
+                    }
+                    console.log("");
+                }
                 reject(new Error(`${packageManager} install exited with code ${code}`));
             }
         });
     });
 }
+/**
+ * Check if the package manager is installed
+ */
 async function checkIfPackageManagerExists(packageManager) {
-    try {
-        (0, node_child_process_1.execSync)(`${packageManager} --version`);
-        return true;
+    if (!(0, input_validation_1.isValidPackageManager)(packageManager)) {
+        (0, cli_ui_1.printError)("Package manager not found!", packageManager);
+        process.exit(1);
     }
-    catch (error) {
+    const result = (0, safe_spawn_1.safeSpawnSync)(packageManager, ["--version"], {
+        stdio: "ignore",
+    });
+    if (result.error || result.status !== 0) {
         (0, cli_ui_1.printError)("Package manager not found!", packageManager);
         process.exit(1);
     }
+    return true;
 }
-function renameEnvFile(directory) {
-    try {
-        const envExamplePath = node_path_1.default.join(directory, ".env.example");
-        const envPath = node_path_1.default.join(directory, ".env");
-        if (!node_fs_1.default.existsSync(envExamplePath)) {
-            throw new Error(`File not found: ${envExamplePath}`);
-        }
-        node_fs_1.default.renameSync(envExamplePath, envPath);
+/**
+ * Copy directory recursively (for local template testing)
+ */
+function copyDirectorySync(src, dest) {
+    if (!node_fs_1.default.existsSync(dest)) {
+        node_fs_1.default.mkdirSync(dest, { recursive: true });
     }
-    catch (error) {
-        (0, cli_ui_1.printError)("Error renaming .env.example file", ".env.example to .env");
-        process.exit(1);
+    const entries = node_fs_1.default.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = node_path_1.default.join(src, entry.name);
+        const destPath = node_path_1.default.join(dest, entry.name);
+        // Skip node_modules and dist directories
+        if (entry.name === "node_modules" || entry.name === "dist") {
+            continue;
+        }
+        if (entry.isDirectory()) {
+            copyDirectorySync(srcPath, destPath);
+        }
+        else {
+            node_fs_1.default.copyFileSync(srcPath, destPath);
+        }
     }
 }
+/**
+ * Template definitions for v4.0
+ */
 var Template;
 (function (Template) {
-    Template["nonopinionated"] = "Non-Opinionated :: Start with a clean slate and build your project from scratch.";
-    Template["opinionated"] = "Opinionated :: Automatically scaffolds resources into a preset project structure. (Recommended)";
-    Template["micro"] = "Micro :: A minimalistic template for building micro api's.";
+    Template["application"] = "Application :: Full-featured ExpressoTS application. (Recommended)";
+    Template["micro"] = "Micro :: A minimalistic template for building micro APIs and serverless functions.";
 })(Template || (Template = {}));
+/**
+ * Middleware presets for Application template
+ */
+var MiddlewarePreset;
+(function (MiddlewarePreset) {
+    MiddlewarePreset["api"] = "API :: REST API with security, compression, and auto-logging. (Recommended)";
+    MiddlewarePreset["web"] = "Web :: Full web app with cookies and session support.";
+    MiddlewarePreset["graphql"] = "GraphQL :: Optimized for GraphQL APIs.";
+    MiddlewarePreset["microservice"] = "Microservice :: Minimal setup for microservices.";
+    MiddlewarePreset["minimal"] = "Minimal :: Just request parsing, customize everything yourself.";
+})(MiddlewarePreset || (MiddlewarePreset = {}));
+/**
+ * Template folder mapping
+ */
+const TEMPLATE_FOLDERS = {
+    Application: "application",
+    Micro: "micro",
+};
+/**
+ * Middleware preset mapping to code
+ */
+const PRESET_CODE = {
+    API: `this.Middleware.applyPreset("api");`,
+    Web: `this.Middleware.applyPreset("web");`,
+    GraphQL: `this.Middleware.applyPreset("graphql");`,
+    Microservice: `this.Middleware.applyPreset("microservice");`,
+    Minimal: `this.Middleware.parse();`,
+};
+/**
+ * Apply the selected middleware preset to the generated app.ts
+ */
+function applyMiddlewarePreset(directory, preset) {
+    const appTsPath = node_path_1.default.join(directory, "src", "app.ts");
+    if (!node_fs_1.default.existsSync(appTsPath)) {
+        return;
+    }
+    // Extract preset name from selection (e.g., "API :: ..." -> "API")
+    const presetMatch = preset.match(/^(\w+) ::/);
+    const presetName = presetMatch ? presetMatch[1] : "API";
+    const presetCode = PRESET_CODE[presetName] || PRESET_CODE["API"];
+    let content = node_fs_1.default.readFileSync(appTsPath, "utf-8");
+    // Replace the placeholder with the preset code
+    content = content.replace(/\/\/ __MIDDLEWARE_PRESET_PLACEHOLDER__/, presetCode);
+    node_fs_1.default.writeFileSync(appTsPath, content, "utf-8");
+}
+/**
+ * Enable local template mode for testing.
+ * Opt-in via `EXPRESSOTS_DEV=1` and `EXPRESSOTS_USE_LOCAL_TEMPLATES=1`.
+ * Both must be set so a stray env var alone cannot redirect a user's
+ * `expressots new` to local files.
+ */
+const USE_LOCAL_TEMPLATES = process.env.EXPRESSOTS_DEV === "1" &&
+    process.env.EXPRESSOTS_USE_LOCAL_TEMPLATES === "1";
+/**
+ * Skip the package-manager install step. Useful when iterating on
+ * templates that depend on unpublished package versions. Same dual
+ * env-var guard as `USE_LOCAL_TEMPLATES`.
+ */
+const SKIP_INSTALL_FOR_TESTING = process.env.EXPRESSOTS_DEV === "1" &&
+    process.env.EXPRESSOTS_SKIP_INSTALL === "1";
+/**
+ * Local templates path (relative to CLI installation)
+ * For development: points to the templates folder in the monorepo
+ * For production: this will be replaced with the actual path
+ */
+const LOCAL_TEMPLATES_PATH = node_path_1.default.resolve(__dirname, "../../../templates");
+/**
+ * Main project creation form
+ */
 const projectForm = async (projectName, args) => {
     let answer;
-    const [packageManager, template, directory] = args;
+    const [packageManager, template, directory, preset] = args;
     if (packageManager && template) {
         answer = {
             name: projectName,
             packageManager: packageManager,
             template: Template[template],
+            preset: preset ? MiddlewarePreset[preset] : undefined,
             confirm: true,
         };
     }
     else {
-        answer = await inquirer_1.default.prompt([
+        const baseAnswers = await inquirer_1.default.prompt([
             {
                 type: "input",
                 name: "name",
@@ -130,18 +274,42 @@ const projectForm = async (projectName, args) => {
                 type: "list",
                 name: "packageManager",
                 message: "Package manager",
-                choices: ["npm", "yarn", "pnpm", "bun"],
+                choices: [
+                    "npm",
+                    "yarn",
+                    "pnpm",
+                    ...(process.platform !== "win32" ? ["bun"] : []),
+                ],
             },
             {
                 type: "list",
                 name: "template",
                 message: "Select a template",
                 choices: [
-                    `Opinionated :: Automatically scaffolds resources into a preset project structure. (${chalk_1.default.yellow("Recommended")})`,
-                    "NonOpinionated :: Allows users to choose where to scaffold resources, offering flexible project organization.",
-                    "Micro :: A minimalistic template for building micro api's.",
+                    `Application :: Full-featured ExpressoTS application. (${chalk_1.default.yellow("Recommended")})`,
+                    "Micro :: A minimalistic template for building micro APIs and serverless functions.",
                 ],
             },
+        ]);
+        // Only show preset selection for Application template
+        let presetAnswer = {};
+        if (baseAnswers.template.startsWith("Application")) {
+            presetAnswer = await inquirer_1.default.prompt([
+                {
+                    type: "list",
+                    name: "preset",
+                    message: "Select a middleware preset",
+                    choices: [
+                        `API :: REST API with security, compression, and auto-logging. (${chalk_1.default.yellow("Recommended")})`,
+                        "Web :: Full web app with cookies and session support.",
+                        "GraphQL :: Optimized for GraphQL APIs.",
+                        "Microservice :: Minimal setup for microservices.",
+                        "Minimal :: Just request parsing, customize everything yourself.",
+                    ],
+                },
+            ]);
+        }
+        const confirmAnswer = await inquirer_1.default.prompt([
             {
                 type: "confirm",
                 name: "confirm",
@@ -149,6 +317,11 @@ const projectForm = async (projectName, args) => {
                 default: true,
             },
         ]);
+        answer = {
+            ...baseAnswers,
+            ...presetAnswer,
+            ...confirmAnswer,
+        };
     }
     if (directory) {
         if (!node_fs_1.default.existsSync(node_path_1.default.join(directory, answer.name))) {
@@ -159,12 +332,6 @@ const projectForm = async (projectName, args) => {
             process.exit(1);
         }
     }
-    // Hashmap of templates and their directories
-    const templates = {
-        NonOpinionated: "non_opinionated",
-        Opinionated: "opinionated",
-        Micro: "micro",
-    };
     if (answer.confirm) {
         // Check if package manager is bun and OS is Windows
         if (answer.packageManager === "bun" && process.platform === "win32") {
@@ -180,28 +347,76 @@ const projectForm = async (projectName, args) => {
             hideCursor: true,
         }, cli_progress_1.Presets.rect);
         progressBar.start(100, 0, {
-            doing: "Cloning project",
+            doing: "Creating project",
         });
-        const [_, template] = answer.template.match(/(.*) ::/);
-        const repo = `expressots/templates/${templates[template]}#${cli_1.BUNDLE_VERSION}`;
+        // Extract template name from selection
+        const templateMatch = answer.template.match(/(.*) ::/);
+        if (!templateMatch || !templateMatch[1]) {
+            progressBar.stop();
+            (0, cli_ui_1.printError)(`Could not parse selected template: ${answer.template}`, "new");
+            process.exit(1);
+        }
+        const templateName = templateMatch[1];
+        const templateFolder = TEMPLATE_FOLDERS[templateName];
+        if (!templateFolder) {
+            progressBar.stop();
+            (0, cli_ui_1.printError)(`Unknown template: ${templateName}`, "new");
+            process.exit(1);
+        }
         try {
-            const emitter = (0, degit_1.default)(repo);
-            await emitter.clone(answer.name);
+            if (USE_LOCAL_TEMPLATES) {
+                // LOCAL TEMPLATE MODE (for testing)
+                const localTemplatePath = node_path_1.default.join(LOCAL_TEMPLATES_PATH, templateFolder);
+                if (!node_fs_1.default.existsSync(localTemplatePath)) {
+                    progressBar.stop();
+                    (0, cli_ui_1.printError)(`Local template not found at: ${localTemplatePath}`, "Please check your templates folder");
+                    process.exit(1);
+                }
+                // Create target directory
+                node_fs_1.default.mkdirSync(answer.name, { recursive: true });
+                // Copy template files
+                copyDirectorySync(localTemplatePath, answer.name);
+                progressBar.update(30, { doing: "Template copied" });
+            }
+            else {
+                // GITHUB MODE (production)
+                // Pinned to the v4.0.0 GA tag of the templates repo so a
+                // CLI shipped at v4.0.0 keeps working even if `main` moves.
+                const repo = `expressots/templates/${templateFolder}#v4.0.0-preview.1`;
+                const emitter = (0, degit_1.default)(repo);
+                await emitter.clone(answer.name);
+                progressBar.update(30, { doing: "Template cloned" });
+            }
         }
         catch (err) {
             console.log("\n");
             (0, cli_ui_1.printError)("Project already exists or Folder is not empty", answer.name);
             process.exit(1);
         }
-        progressBar.update(50, {
-            doing: "Installing dependencies",
-        });
-        await packageManagerInstall({
-            packageManager: answer.packageManager,
-            directory: answer.name,
-            progressBar,
-        });
-        progressBar.update(90);
+        if (SKIP_INSTALL_FOR_TESTING) {
+            progressBar.update(90, {
+                doing: "Skipping install (testing mode)",
+            });
+        }
+        else {
+            progressBar.update(50, {
+                doing: "Installing dependencies",
+            });
+            await packageManagerInstall({
+                packageManager: answer.packageManager,
+                directory: answer.name,
+                progressBar,
+            });
+        }
+        // Progress should already be at 90% from packageManagerInstall
+        // Only update if we skipped installation
+        if (!SKIP_INSTALL_FOR_TESTING) {
+            progressBar.update(90, { doing: "Finalizing project" });
+        }
+        // Apply middleware preset for Application template
+        if (answer.preset && templateFolder === "application") {
+            applyMiddlewarePreset(answer.name, answer.preset);
+        }
         (0, change_package_info_1.changePackageName)({
             directory: answer.name,
             name: projectName,

package/bin/profile/analyzers/dockerfile-analyzer.d.ts

@@ -0,0 +1,27 @@
+export interface DockerfileAnalysis {
+    baseImage?: string;
+    nodeVersion?: string;
+    layers: number;
+    hasMultiStage: boolean;
+    hasHealthCheck: boolean;
+    hasNonRootUser: boolean;
+    hasDockerignore: boolean;
+    hasNpmInstallWithoutCi: boolean;
+    hasCurlOrWgetWithoutCleanup: boolean;
+    instructions: DockerInstruction[];
+    stages: string[];
+}
+export interface DockerInstruction {
+    line: number;
+    instruction: string;
+    arguments: string;
+    raw: string;
+}
+/**
+ * Analyze a Dockerfile for issues and metrics
+ */
+export declare function analyzeDockerfile(dockerfilePath: string): Promise<DockerfileAnalysis>;
+/**
+ * Parse a specific Dockerfile instruction
+ */
+export declare function parseInstruction(line: string): DockerInstruction | null;

package/bin/profile/analyzers/dockerfile-analyzer.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseInstruction = exports.analyzeDockerfile = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Analyze a Dockerfile for issues and metrics
+ */
+async function analyzeDockerfile(dockerfilePath) {
+    const content = fs_1.default.readFileSync(dockerfilePath, "utf-8");
+    const lines = content.split("\n");
+    const instructions = [];
+    const stages = [];
+    let hasMultiStage = false;
+    let hasHealthCheck = false;
+    let hasNonRootUser = false;
+    let hasNpmInstallWithoutCi = false;
+    let hasCurlOrWgetWithoutCleanup = false;
+    let baseImage;
+    let nodeVersion;
+    let runLayerCount = 0;
+    // Parse Dockerfile
+    let currentLine = 0;
+    for (const line of lines) {
+        currentLine++;
+        const trimmed = line.trim();
+        // Skip comments and empty lines
+        if (!trimmed || trimmed.startsWith("#")) {
+            continue;
+        }
+        // Parse instruction
+        const match = trimmed.match(/^(\w+)\s*(.*)/);
+        if (!match)
+            continue;
+        const instruction = match[1].toUpperCase();
+        const args = match[2];
+        instructions.push({
+            line: currentLine,
+            instruction,
+            arguments: args,
+            raw: trimmed,
+        });
+        // Analyze instruction
+        switch (instruction) {
+            case "FROM":
+                if (stages.length > 0) {
+                    hasMultiStage = true;
+                }
+                stages.push(args);
+                // Extract base image info
+                if (!baseImage) {
+                    baseImage = args.split(/\s+/)[0];
+                    // Try to extract Node version
+                    const nodeMatch = baseImage.match(/node:(\d+)/);
+                    if (nodeMatch) {
+                        nodeVersion = nodeMatch[1];
+                    }
+                }
+                break;
+            case "HEALTHCHECK":
+                hasHealthCheck = true;
+                break;
+            case "USER":
+                // Check if non-root user
+                if (args && args !== "root" && args !== "0") {
+                    hasNonRootUser = true;
+                }
+                break;
+            case "RUN":
+                runLayerCount++;
+                // Check for npm install vs npm ci
+                if (args.includes("npm install") && !args.includes("npm ci")) {
+                    hasNpmInstallWithoutCi = true;
+                }
+                // Check for curl/wget without cleanup
+                if ((args.includes("curl") || args.includes("wget")) &&
+                    !args.includes("rm ")) {
+                    hasCurlOrWgetWithoutCleanup = true;
+                }
+                break;
+        }
+    }
+    // Check for .dockerignore
+    const dockerignorePath = path_1.default.join(path_1.default.dirname(dockerfilePath), ".dockerignore");
+    const hasDockerignore = fs_1.default.existsSync(dockerignorePath);
+    return {
+        baseImage,
+        nodeVersion,
+        layers: runLayerCount,
+        hasMultiStage,
+        hasHealthCheck,
+        hasNonRootUser,
+        hasDockerignore,
+        hasNpmInstallWithoutCi,
+        hasCurlOrWgetWithoutCleanup,
+        instructions,
+        stages,
+    };
+}
+exports.analyzeDockerfile = analyzeDockerfile;
+/**
+ * Parse a specific Dockerfile instruction
+ */
+function parseInstruction(line) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+        return null;
+    }
+    const match = trimmed.match(/^(\w+)\s*(.*)/);
+    if (!match)
+        return null;
+    return {
+        line: 0,
+        instruction: match[1].toUpperCase(),
+        arguments: match[2],
+        raw: trimmed,
+    };
+}
+exports.parseInstruction = parseInstruction;

package/bin/profile/analyzers/image-analyzer.d.ts

@@ -0,0 +1,19 @@
+export interface ImageAnalysis {
+    size: string;
+    layers: number;
+    created: string;
+    os: string;
+    architecture: string;
+    vulnerabilities: Vulnerability[];
+}
+export interface Vulnerability {
+    id: string;
+    severity: "low" | "medium" | "high" | "critical";
+    description: string;
+    package?: string;
+    fixedVersion?: string;
+}
+/**
+ * Analyze a Docker image for size, layers, and vulnerabilities
+ */
+export declare function analyzeImage(imageName: string): Promise<ImageAnalysis>;