@expressots/cli 3.0.0 → 4.0.0-preview.2

package/bin/config/manager.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Global configuration manager for ExpressoTS CLI
+ * Manages user preferences stored in ~/.expressots/config.json
+ */
+export interface TemplateConfig {
+    repository: string;
+    branch: string;
+    cacheTTL: number;
+}
+export interface PricingConfig {
+    sources: ("api" | "remote" | "local")[];
+    cacheTTL: number;
+    customFile: string | null;
+}
+export interface GlobalConfig {
+    templates: TemplateConfig;
+    pricing: PricingConfig;
+    offline: boolean;
+}
+export declare class ConfigManager {
+    private config;
+    private configPath;
+    constructor();
+    /**
+     * Ensure config directory exists
+     */
+    private ensureConfigDir;
+    /**
+     * Load configuration from file
+     */
+    private load;
+    /**
+     * Merge loaded config with defaults
+     */
+    private mergeWithDefaults;
+    /**
+     * Save configuration to file
+     */
+    save(): void;
+    /**
+     * Get full configuration
+     */
+    getConfig(): GlobalConfig;
+    /**
+     * Get template configuration
+     */
+    getTemplateConfig(): TemplateConfig;
+    /**
+     * Get pricing configuration
+     */
+    getPricingConfig(): PricingConfig;
+    /**
+     * Set template repository
+     */
+    setTemplateRepository(repository: string, branch?: string): void;
+    /**
+     * Reset template repository to default
+     */
+    resetTemplateRepository(): void;
+    /**
+     * Set template cache TTL
+     */
+    setTemplateCacheTTL(ttl: number): void;
+    /**
+     * Set pricing sources
+     */
+    setPricingSources(sources: ("api" | "remote" | "local")[]): void;
+    /**
+     * Set custom pricing file
+     */
+    setCustomPricingFile(filePath: string | null): void;
+    /**
+     * Set pricing cache TTL
+     */
+    setPricingCacheTTL(ttl: number): void;
+    /**
+     * Set offline mode
+     */
+    setOfflineMode(offline: boolean): void;
+    /**
+     * Get offline mode
+     */
+    isOffline(): boolean;
+    /**
+     * Reset all configuration to defaults
+     */
+    reset(): void;
+    /**
+     * Get config file path
+     */
+    getConfigPath(): string;
+    /**
+     * Get config directory path
+     */
+    getConfigDir(): string;
+}
+export declare function getConfigManager(): ConfigManager;
+export declare function resetConfigManager(): void;

package/bin/config/manager.js

@@ -0,0 +1,222 @@
+"use strict";
+/**
+ * Global configuration manager for ExpressoTS CLI
+ * Manages user preferences stored in ~/.expressots/config.json
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetConfigManager = exports.getConfigManager = exports.ConfigManager = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const cli_ui_1 = require("../utils/cli-ui");
+const CONFIG_DIR = path_1.default.join(os_1.default.homedir(), ".expressots");
+const CONFIG_FILE = path_1.default.join(CONFIG_DIR, "config.json");
+const DEFAULT_CONFIG = {
+    templates: {
+        repository: "expressots/templates",
+        branch: "main",
+        cacheTTL: 86400, // 24 hours
+    },
+    pricing: {
+        sources: ["api", "remote", "local"],
+        cacheTTL: 21600,
+        customFile: null,
+    },
+    offline: false,
+};
+/**
+ * Returns a deep clone of the default config so callers can mutate
+ * their copy without poisoning the module-level constant. A previous
+ * implementation used `{ ...DEFAULT_CONFIG }` which kept the inner
+ * `templates`/`pricing` objects shared, so `setTemplateRepository`
+ * mutated the defaults and broke `reset()`.
+ */
+function freshDefaults() {
+    return {
+        templates: { ...DEFAULT_CONFIG.templates },
+        pricing: {
+            ...DEFAULT_CONFIG.pricing,
+            sources: [...DEFAULT_CONFIG.pricing.sources],
+        },
+        offline: DEFAULT_CONFIG.offline,
+    };
+}
+class ConfigManager {
+    constructor() {
+        this.configPath = CONFIG_FILE;
+        this.config = this.load();
+    }
+    /**
+     * Ensure config directory exists
+     */
+    ensureConfigDir() {
+        if (!fs_1.default.existsSync(CONFIG_DIR)) {
+            fs_1.default.mkdirSync(CONFIG_DIR, { recursive: true });
+        }
+    }
+    /**
+     * Load configuration from file
+     */
+    load() {
+        if (!fs_1.default.existsSync(this.configPath)) {
+            return freshDefaults();
+        }
+        let content;
+        try {
+            content = fs_1.default.readFileSync(this.configPath, "utf-8");
+        }
+        catch (err) {
+            (0, cli_ui_1.printWarning)(`Could not read ${this.configPath}: ${err.message}. Falling back to defaults.`, "config");
+            return freshDefaults();
+        }
+        try {
+            const loaded = JSON.parse(content);
+            if (loaded === null ||
+                typeof loaded !== "object" ||
+                Array.isArray(loaded)) {
+                (0, cli_ui_1.printWarning)(`${this.configPath} is not a JSON object. Falling back to defaults.`, "config");
+                return freshDefaults();
+            }
+            return this.mergeWithDefaults(loaded);
+        }
+        catch (err) {
+            (0, cli_ui_1.printWarning)(`${this.configPath} is not valid JSON: ${err.message}. Falling back to defaults.`, "config");
+            return freshDefaults();
+        }
+    }
+    /**
+     * Merge loaded config with defaults
+     */
+    mergeWithDefaults(loaded) {
+        return {
+            templates: {
+                ...DEFAULT_CONFIG.templates,
+                ...loaded.templates,
+            },
+            pricing: {
+                ...DEFAULT_CONFIG.pricing,
+                ...loaded.pricing,
+            },
+            offline: loaded.offline ?? DEFAULT_CONFIG.offline,
+        };
+    }
+    /**
+     * Save configuration to file
+     */
+    save() {
+        this.ensureConfigDir();
+        fs_1.default.writeFileSync(this.configPath, JSON.stringify(this.config, null, 2), "utf-8");
+    }
+    /**
+     * Get full configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Get template configuration
+     */
+    getTemplateConfig() {
+        return { ...this.config.templates };
+    }
+    /**
+     * Get pricing configuration
+     */
+    getPricingConfig() {
+        return { ...this.config.pricing };
+    }
+    /**
+     * Set template repository
+     */
+    setTemplateRepository(repository, branch) {
+        this.config.templates.repository = repository;
+        if (branch) {
+            this.config.templates.branch = branch;
+        }
+        this.save();
+    }
+    /**
+     * Reset template repository to default
+     */
+    resetTemplateRepository() {
+        this.config.templates = { ...DEFAULT_CONFIG.templates };
+        this.save();
+    }
+    /**
+     * Set template cache TTL
+     */
+    setTemplateCacheTTL(ttl) {
+        this.config.templates.cacheTTL = ttl;
+        this.save();
+    }
+    /**
+     * Set pricing sources
+     */
+    setPricingSources(sources) {
+        this.config.pricing.sources = sources;
+        this.save();
+    }
+    /**
+     * Set custom pricing file
+     */
+    setCustomPricingFile(filePath) {
+        this.config.pricing.customFile = filePath;
+        this.save();
+    }
+    /**
+     * Set pricing cache TTL
+     */
+    setPricingCacheTTL(ttl) {
+        this.config.pricing.cacheTTL = ttl;
+        this.save();
+    }
+    /**
+     * Set offline mode
+     */
+    setOfflineMode(offline) {
+        this.config.offline = offline;
+        this.save();
+    }
+    /**
+     * Get offline mode
+     */
+    isOffline() {
+        return this.config.offline;
+    }
+    /**
+     * Reset all configuration to defaults
+     */
+    reset() {
+        this.config = freshDefaults();
+        this.save();
+    }
+    /**
+     * Get config file path
+     */
+    getConfigPath() {
+        return this.configPath;
+    }
+    /**
+     * Get config directory path
+     */
+    getConfigDir() {
+        return CONFIG_DIR;
+    }
+}
+exports.ConfigManager = ConfigManager;
+// Singleton instance
+let configInstance = null;
+function getConfigManager() {
+    if (!configInstance) {
+        configInstance = new ConfigManager();
+    }
+    return configInstance;
+}
+exports.getConfigManager = getConfigManager;
+function resetConfigManager() {
+    configInstance = null;
+}
+exports.resetConfigManager = resetConfigManager;

package/bin/containerize/analyzers/bootstrap-analyzer.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Environment file mapping from bootstrap configuration
+ */
+export interface EnvFileMapping {
+    [environment: string]: string;
+}
+/**
+ * Bootstrap configuration detected from main.ts
+ */
+export interface BootstrapConfig {
+    /** Whether envFileConfig is used */
+    hasEnvFileConfig: boolean;
+    /** Whether skipFileLoading is set to true (container-friendly) */
+    skipFileLoading: boolean;
+    /** Whether ciMode is explicitly set */
+    ciMode: boolean | undefined;
+    /** Environment file mappings */
+    envFiles: EnvFileMapping;
+    /** Required environment variables */
+    requiredVariables: string[];
+    /** Whether autoCreateTemplate is enabled */
+    autoCreateTemplate: boolean;
+    /** Current environment if specified */
+    currentEnvironment: string | undefined;
+    /** Detected env files that exist on disk */
+    existingEnvFiles: string[];
+    /** Detected env files that are missing */
+    missingEnvFiles: string[];
+    /** Whether the configuration is container-ready */
+    isContainerReady: boolean;
+    /** Recommendations for container deployment */
+    recommendations: string[];
+}
+/**
+ * Analyze the bootstrap configuration in main.ts
+ * Detects environment file configurations that affect container deployment
+ */
+export declare function analyzeBootstrapConfig(): Promise<BootstrapConfig>;
+/**
+ * Get the env file for a specific environment
+ */
+export declare function getEnvFileForEnvironment(config: BootstrapConfig, environment: string): string;
+/**
+ * Check if env files should be copied to the container
+ */
+export declare function shouldCopyEnvFiles(config: BootstrapConfig): boolean;

package/bin/containerize/analyzers/bootstrap-analyzer.js

@@ -0,0 +1,187 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldCopyEnvFiles = exports.getEnvFileForEnvironment = exports.analyzeBootstrapConfig = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Analyze the bootstrap configuration in main.ts
+ * Detects environment file configurations that affect container deployment
+ */
+async function analyzeBootstrapConfig() {
+    const cwd = process.cwd();
+    const result = {
+        hasEnvFileConfig: false,
+        skipFileLoading: false,
+        ciMode: undefined,
+        envFiles: {},
+        requiredVariables: [],
+        autoCreateTemplate: false,
+        currentEnvironment: undefined,
+        existingEnvFiles: [],
+        missingEnvFiles: [],
+        isContainerReady: true,
+        recommendations: [],
+    };
+    // Find main.ts file
+    const mainTsPath = findMainFile(cwd);
+    if (!mainTsPath) {
+        return result;
+    }
+    const content = fs_1.default.readFileSync(mainTsPath, "utf-8");
+    // Check if bootstrap is imported and used
+    if (!content.includes("bootstrap")) {
+        return result;
+    }
+    // Parse bootstrap configuration
+    parseBootstrapConfig(content, result);
+    // Detect existing env files
+    detectExistingEnvFiles(cwd, result);
+    // Determine if configuration is container-ready
+    evaluateContainerReadiness(result);
+    return result;
+}
+exports.analyzeBootstrapConfig = analyzeBootstrapConfig;
+/**
+ * Find the main.ts file in the project
+ */
+function findMainFile(cwd) {
+    const possiblePaths = [
+        path_1.default.join(cwd, "src", "main.ts"),
+        path_1.default.join(cwd, "src", "index.ts"),
+        path_1.default.join(cwd, "main.ts"),
+        path_1.default.join(cwd, "index.ts"),
+    ];
+    for (const filePath of possiblePaths) {
+        if (fs_1.default.existsSync(filePath)) {
+            return filePath;
+        }
+    }
+    return null;
+}
+/**
+ * Parse bootstrap configuration from file content
+ * Uses regex patterns to extract configuration without full AST parsing
+ */
+function parseBootstrapConfig(content, result) {
+    // Check for envFileConfig usage
+    const envFileConfigMatch = content.match(/envFileConfig\s*[:{]/);
+    if (envFileConfigMatch) {
+        result.hasEnvFileConfig = true;
+    }
+    // Check for skipFileLoading: true
+    if (/skipFileLoading\s*:\s*true/.test(content)) {
+        result.skipFileLoading = true;
+    }
+    // Check for ciMode
+    const ciModeMatch = content.match(/ciMode\s*:\s*(true|false)/);
+    if (ciModeMatch) {
+        result.ciMode = ciModeMatch[1] === "true";
+    }
+    // Check for autoCreateTemplate
+    if (/autoCreateTemplate\s*:\s*true/.test(content)) {
+        result.autoCreateTemplate = true;
+    }
+    // Extract files mapping
+    const filesMatch = content.match(/files\s*:\s*\{([^}]+)\}/s);
+    if (filesMatch) {
+        const filesContent = filesMatch[1];
+        // Match key-value pairs like: development: ".env.dev"
+        const envMappings = filesContent.matchAll(/(\w+)\s*:\s*["'`]([^"'`]+)["'`]/g);
+        for (const match of envMappings) {
+            result.envFiles[match[1]] = match[2];
+        }
+    }
+    // Extract required variables
+    const requiredMatch = content.match(/required\s*:\s*\[([^\]]+)\]/s);
+    if (requiredMatch) {
+        const requiredContent = requiredMatch[1];
+        const variables = requiredContent.matchAll(/["'`]([^"'`]+)["'`]/g);
+        for (const match of variables) {
+            result.requiredVariables.push(match[1]);
+        }
+    }
+    // Extract currentEnvironment
+    const envMatch = content.match(/currentEnvironment\s*:\s*["'`]([^"'`]+)["'`]/);
+    if (envMatch) {
+        result.currentEnvironment = envMatch[1];
+    }
+}
+/**
+ * Detect which env files exist and which are missing
+ */
+function detectExistingEnvFiles(cwd, result) {
+    // If no explicit files mapping, use convention
+    if (Object.keys(result.envFiles).length === 0 && result.hasEnvFileConfig) {
+        // Default convention: .env.{environment}
+        const defaultEnvs = ["development", "production", "staging", "test"];
+        for (const env of defaultEnvs) {
+            result.envFiles[env] = `.env.${env}`;
+        }
+    }
+    // Check each mapped file
+    for (const [env, fileName] of Object.entries(result.envFiles)) {
+        const filePath = path_1.default.join(cwd, fileName);
+        if (fs_1.default.existsSync(filePath)) {
+            result.existingEnvFiles.push(fileName);
+        }
+        else {
+            result.missingEnvFiles.push(fileName);
+        }
+    }
+    // Also check for common env files
+    const commonEnvFiles = [".env", ".env.local", ".env.example"];
+    for (const fileName of commonEnvFiles) {
+        const filePath = path_1.default.join(cwd, fileName);
+        if (fs_1.default.existsSync(filePath) &&
+            !result.existingEnvFiles.includes(fileName)) {
+            result.existingEnvFiles.push(fileName);
+        }
+    }
+}
+/**
+ * Evaluate if the bootstrap configuration is container-ready
+ */
+function evaluateContainerReadiness(result) {
+    result.isContainerReady = true;
+    result.recommendations = [];
+    // If envFileConfig is used but skipFileLoading is not true
+    if (result.hasEnvFileConfig && !result.skipFileLoading && !result.ciMode) {
+        // Check if there are missing env files for development
+        const devEnvFile = result.envFiles["development"] || ".env.development";
+        if (result.missingEnvFiles.includes(devEnvFile)) {
+            result.isContainerReady = false;
+            result.recommendations.push(`Create ${devEnvFile} or set skipFileLoading: true for containers`);
+        }
+        // Recommend container-friendly configuration
+        if (!result.skipFileLoading) {
+            result.recommendations.push("Consider using skipFileLoading: true for Docker deployments");
+            result.recommendations.push("Use docker-compose environment variables instead of .env files");
+        }
+    }
+    // If there are required variables, they need to be provided
+    if (result.requiredVariables.length > 0) {
+        result.recommendations.push(`Ensure these variables are set in docker-compose: ${result.requiredVariables.join(", ")}`);
+    }
+}
+/**
+ * Get the env file for a specific environment
+ */
+function getEnvFileForEnvironment(config, environment) {
+    return config.envFiles[environment] || `.env.${environment}`;
+}
+exports.getEnvFileForEnvironment = getEnvFileForEnvironment;
+/**
+ * Check if env files should be copied to the container
+ */
+function shouldCopyEnvFiles(config) {
+    // Don't copy if skipFileLoading is true or ciMode is true
+    if (config.skipFileLoading || config.ciMode) {
+        return false;
+    }
+    // Copy if envFileConfig is used and there are existing files
+    return config.hasEnvFileConfig && config.existingEnvFiles.length > 0;
+}
+exports.shouldCopyEnvFiles = shouldCopyEnvFiles;

package/bin/containerize/analyzers/project-analyzer.d.ts

@@ -0,0 +1,20 @@
+import { type BootstrapConfig } from "./bootstrap-analyzer";
+export interface ProjectAnalysis {
+    nodeVersion: string;
+    packageManager: "npm" | "pnpm" | "yarn" | "bun";
+    dependencies: string[];
+    devDependencies: string[];
+    controllers: string[];
+    hasDatabase: boolean;
+    hasRedis: boolean;
+    hasCors: boolean;
+    estimatedMemory: string;
+    estimatedCpu: string;
+    healthCheckPaths: string[];
+    port: number;
+    hasLocalDependencies: boolean;
+    localDependencyPaths: string[];
+    /** Bootstrap configuration analysis */
+    bootstrapConfig: BootstrapConfig;
+}
+export declare function analyzeProject(): Promise<ProjectAnalysis>;