@quatrain/cli 1.1.8

package/dist/commands/deploy.js

@@ -0,0 +1,696 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployCommand = deployCommand;
+const inquirer_1 = __importDefault(require("inquirer"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+function discoverCoreDeployPath() {
+    const cwd = process.cwd();
+    if (node_fs_1.default.existsSync(node_path_1.default.join(cwd, 'k8s/templates/namespace.yaml'))) {
+        return cwd;
+    }
+    const siblingCandidates = [
+        node_path_1.default.resolve(cwd, '../CoreDeploy'),
+        node_path_1.default.resolve(cwd, '../../CoreDeploy'),
+        node_path_1.default.resolve(cwd, 'CoreDeploy'),
+        '/Users/crapougnax/CODE/QUATRAIN/CoreDeploy'
+    ];
+    for (const candidate of siblingCandidates) {
+        if (node_fs_1.default.existsSync(node_path_1.default.join(candidate, 'k8s/templates/namespace.yaml'))) {
+            return candidate;
+        }
+    }
+    return '';
+}
+function generateSecurePassword() {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#%^*()-_=+[]{}';
+    let pass = '';
+    for (let i = 0; i < 24; i++) {
+        const idx = Math.floor(Math.random() * chars.length);
+        pass += chars[idx];
+    }
+    return pass;
+}
+function detectLatestStableTag(coreDeployPath) {
+    const fallback = '1.1.49';
+    try {
+        const packageJsonPath = node_path_1.default.resolve(coreDeployPath, '../CoreApps/containers/studio-image/package.json');
+        if (node_fs_1.default.existsSync(packageJsonPath)) {
+            const content = JSON.parse(node_fs_1.default.readFileSync(packageJsonPath, 'utf8'));
+            if (content && content.version) {
+                return content.version;
+            }
+        }
+    }
+    catch {
+    }
+    return fallback;
+}
+function parseMetadataFromYaml(appDir, namespaceName) {
+    try {
+        const nsPath = node_path_1.default.join(appDir, 'namespace.yaml');
+        const ingPath = node_path_1.default.join(appDir, 'ingressroute.yaml');
+        const depPath = node_path_1.default.join(appDir, 'deployment.yaml');
+        const secPath = node_path_1.default.join(appDir, 'secret.yaml');
+        const pvcPath = node_path_1.default.join(appDir, 'pvc.yaml');
+        if (!node_fs_1.default.existsSync(nsPath) || !node_fs_1.default.existsSync(ingPath) || !node_fs_1.default.existsSync(depPath) || !node_fs_1.default.existsSync(secPath)) {
+            return null;
+        }
+        const nsContent = node_fs_1.default.readFileSync(nsPath, 'utf8');
+        const ingContent = node_fs_1.default.readFileSync(ingPath, 'utf8');
+        const depContent = node_fs_1.default.readFileSync(depPath, 'utf8');
+        const secContent = node_fs_1.default.readFileSync(secPath, 'utf8');
+        const env = namespaceName.endsWith('-dev') ? 'dev' : 'prod';
+        let appName = namespaceName.replace(/-[a-z0-9]{5}(-dev)?$/, '');
+        const instanceMatch = nsContent.match(/app\.kubernetes\.io\/instance:\s*([^\s\n]+)/);
+        if (instanceMatch) {
+            appName = instanceMatch[1];
+        }
+        let domain = '';
+        const hostMatch = ingContent.match(/Host\(`([^`]+)`\)/);
+        if (hostMatch) {
+            domain = hostMatch[1];
+        }
+        let imageRef = '';
+        const imageMatch = depContent.match(/image:\s*(ghcr\.io\/quatrain\/studio-image:[^\s\n]+)/);
+        if (imageMatch) {
+            imageRef = imageMatch[1];
+        }
+        else {
+            const generalImageMatch = depContent.match(/image:\s*([^\s\n]+)/);
+            if (generalImageMatch) {
+                imageRef = generalImageMatch[1];
+            }
+        }
+        let authUser = 'admin';
+        let authPass = '';
+        const userMatch = secContent.match(/STUDIO_AUTH_USER:\s*([^\s\n]+)/);
+        const passMatch = secContent.match(/STUDIO_AUTH_PASS:\s*([^\s\n]+)/);
+        if (userMatch) {
+            authUser = Buffer.from(userMatch[1].trim(), 'base64').toString('utf8');
+        }
+        if (passMatch) {
+            authPass = Buffer.from(passMatch[1].trim(), 'base64').toString('utf8');
+        }
+        let cpuRequests = '100m';
+        let cpuLimits = '500m';
+        let memRequests = '256Mi';
+        let memLimits = '512Mi';
+        const containerSplit = depContent.split('containers:');
+        if (containerSplit.length > 1) {
+            const resourcesPart = containerSplit[1];
+            const reqCpuMatch = resourcesPart.match(/requests:[\s\S]*?cpu:\s*"?([^\s\n"]+)"?/);
+            const reqMemMatch = resourcesPart.match(/requests:[\s\S]*?memory:\s*"?([^\s\n"]+)"?/);
+            const limCpuMatch = resourcesPart.match(/limits:[\s\S]*?cpu:\s*"?([^\s\n"]+)"?/);
+            const limMemMatch = resourcesPart.match(/limits:[\s\S]*?memory:\s*"?([^\s\n"]+)"?/);
+            if (reqCpuMatch)
+                cpuRequests = reqCpuMatch[1];
+            if (reqMemMatch)
+                memRequests = reqMemMatch[1];
+            if (limCpuMatch)
+                cpuLimits = limCpuMatch[1];
+            if (limMemMatch)
+                memLimits = limMemMatch[1];
+        }
+        let dataPvcSize = '1Gi';
+        let storagePvcSize = '10Gi';
+        if (node_fs_1.default.existsSync(pvcPath)) {
+            const pvcContent = node_fs_1.default.readFileSync(pvcPath, 'utf8');
+            const docs = pvcContent.split('---');
+            docs.forEach(doc => {
+                const nameMatch = doc.match(/name:\s*([^\s\n]+)/);
+                const storageMatch = doc.match(/storage:\s*([^\s\n]+)/);
+                if (nameMatch && storageMatch) {
+                    if (nameMatch[1].includes('data-pvc')) {
+                        dataPvcSize = storageMatch[1];
+                    }
+                    else if (nameMatch[1].includes('storage-pvc')) {
+                        storagePvcSize = storageMatch[1];
+                    }
+                }
+            });
+        }
+        const meta = {
+            appName,
+            namespace: namespaceName,
+            env,
+            domain,
+            imageRef,
+            authUser,
+            authPass,
+            resources: {
+                cpuRequests,
+                cpuLimits,
+                memRequests,
+                memLimits,
+                dataPvcSize,
+                storagePvcSize
+            },
+            createdAt: new Date().toISOString()
+        };
+        node_fs_1.default.writeFileSync(node_path_1.default.join(appDir, 'metadata.json'), JSON.stringify(meta, null, 3), 'utf8');
+        return meta;
+    }
+    catch (err) {
+        console.error(`Failed to parse YAML configuration for ${namespaceName}:`, err);
+        return null;
+    }
+}
+function loadAllDeployments(coreDeployPath) {
+    const appsDir = node_path_1.default.join(coreDeployPath, 'k8s/apps');
+    if (!node_fs_1.default.existsSync(appsDir)) {
+        return [];
+    }
+    const directories = node_fs_1.default.readdirSync(appsDir).filter(name => {
+        return node_fs_1.default.statSync(node_path_1.default.join(appsDir, name)).isDirectory();
+    });
+    const deployments = [];
+    for (const dir of directories) {
+        const appDir = node_path_1.default.join(appsDir, dir);
+        const metaPath = node_path_1.default.join(appDir, 'metadata.json');
+        if (node_fs_1.default.existsSync(metaPath)) {
+            try {
+                const data = JSON.parse(node_fs_1.default.readFileSync(metaPath, 'utf8'));
+                deployments.push(data);
+            }
+            catch {
+                const meta = parseMetadataFromYaml(appDir, dir);
+                if (meta)
+                    deployments.push(meta);
+            }
+        }
+        else {
+            const meta = parseMetadataFromYaml(appDir, dir);
+            if (meta)
+                deployments.push(meta);
+        }
+    }
+    return deployments;
+}
+function scaffoldManifests(coreDeployPath, meta) {
+    const templatesDir = node_path_1.default.join(coreDeployPath, 'k8s/templates');
+    const targetDir = node_path_1.default.join(coreDeployPath, 'k8s/apps', meta.namespace);
+    if (!node_fs_1.default.existsSync(targetDir)) {
+        node_fs_1.default.mkdirSync(targetDir, { recursive: true });
+    }
+    const templates = [
+        'namespace.yaml',
+        'pvc.yaml',
+        'configmap.yaml',
+        'secret.yaml',
+        'deployment.yaml',
+        'service.yaml',
+        'ingressroute.yaml'
+    ];
+    const authUserB64 = Buffer.from(meta.authUser).toString('base64');
+    const authPassB64 = Buffer.from(meta.authPass).toString('base64');
+    for (const file of templates) {
+        const srcFile = node_path_1.default.join(templatesDir, file);
+        const destFile = node_path_1.default.join(targetDir, file);
+        if (!node_fs_1.default.existsSync(srcFile)) {
+            throw new Error(`Template missing: ${srcFile}`);
+        }
+        let content = node_fs_1.default.readFileSync(srcFile, 'utf8');
+        content = content.replace(/{{NAMESPACE}}/g, meta.namespace);
+        content = content.replace(/{{APP_NAME}}/g, meta.appName);
+        content = content.replace(/{{IMAGE_REF}}/g, meta.imageRef);
+        content = content.replace(/{{AUTH_USER_B64}}/g, authUserB64);
+        content = content.replace(/{{AUTH_PASS_B64}}/g, authPassB64);
+        content = content.replace(/{{DOMAIN}}/g, meta.domain);
+        content = content.replace(/{{CPU_REQUESTS}}/g, meta.resources.cpuRequests);
+        content = content.replace(/{{CPU_LIMITS}}/g, meta.resources.cpuLimits);
+        content = content.replace(/{{MEM_REQUESTS}}/g, meta.resources.memRequests);
+        content = content.replace(/{{MEM_LIMITS}}/g, meta.resources.memLimits);
+        content = content.replace(/{{DATA_PVC_SIZE}}/g, meta.resources.dataPvcSize);
+        content = content.replace(/{{STORAGE_PVC_SIZE}}/g, meta.resources.storagePvcSize);
+        node_fs_1.default.writeFileSync(destFile, content, 'utf8');
+    }
+    node_fs_1.default.writeFileSync(node_path_1.default.join(targetDir, 'metadata.json'), JSON.stringify(meta, null, 3), 'utf8');
+}
+function applyManifests(coreDeployPath, namespace) {
+    const targetDir = node_path_1.default.join(coreDeployPath, 'k8s/apps', namespace);
+    const manifestFiles = [
+        'namespace.yaml',
+        'pvc.yaml',
+        'configmap.yaml',
+        'secret.yaml',
+        'deployment.yaml',
+        'service.yaml',
+        'ingressroute.yaml'
+    ];
+    const filesArgs = manifestFiles
+        .map(f => `-f "${node_path_1.default.join(targetDir, f)}"`)
+        .join(' ');
+    const cmd = `kubectl apply ${filesArgs}`;
+    console.log(`Executing: ${cmd}`);
+    return (0, node_child_process_1.execSync)(cmd, { encoding: 'utf8' });
+}
+async function deployCommand() {
+    console.log('\n==============================================');
+    console.log('   Quatrain Core Studio - Deployment Manager  ');
+    console.log('==============================================\n');
+    let coreDeployPath = discoverCoreDeployPath();
+    if (coreDeployPath) {
+        console.log(`📡 Auto-detected CoreDeploy at: \x1b[33m${coreDeployPath}\x1b[0m`);
+    }
+    else {
+        console.log('⚠️ Could not auto-detect the CoreDeploy repository directory.');
+        const pathAnswer = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'path',
+                message: 'Please provide the absolute path to CoreDeploy:',
+                validate: (input) => {
+                    if (!input || !node_fs_1.default.existsSync(node_path_1.default.join(input, 'k8s/templates/namespace.yaml'))) {
+                        return 'Invalid directory. Ensure it is the root of CoreDeploy containing k8s/templates/namespace.yaml.';
+                    }
+                    return true;
+                }
+            }
+        ]);
+        coreDeployPath = node_path_1.default.resolve(pathAnswer.path);
+    }
+    let exitCli = false;
+    while (!exitCli) {
+        const { action } = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'action',
+                message: 'What deployment action would you like to perform?',
+                choices: [
+                    { name: '📋 List deployments', value: 'list' },
+                    { name: '✨ Create new deployment', value: 'create' },
+                    { name: '⚙️  Modify existing deployment', value: 'modify' },
+                    { name: '🚀 Promote deployment (Dev -> Prod)', value: 'promote' },
+                    { name: '❌ Delete deployment', value: 'delete' },
+                    { name: '🚪 Exit', value: 'exit' }
+                ]
+            }
+        ]);
+        try {
+            switch (action) {
+                case 'list': {
+                    const deployments = loadAllDeployments(coreDeployPath);
+                    if (deployments.length === 0) {
+                        console.log('\nℹ️  No deployments found.\n');
+                        break;
+                    }
+                    console.log('\nActive Studio Deployments:');
+                    console.log('------------------------------------------------------------------------------------------------------------------------');
+                    console.log(`${'App Name'.padEnd(15)} | ${'Namespace'.padEnd(23)} | ${'Env'.padEnd(4)} | ${'FQDN Access Domain'.padEnd(35)} | ${'Image Reference'.padEnd(35)}`);
+                    console.log('------------------------------------------------------------------------------------------------------------------------');
+                    deployments.forEach(d => {
+                        console.log(`${d.appName.padEnd(15)} | ${d.namespace.padEnd(23)} | ${d.env.padEnd(4)} | ${d.domain.padEnd(35)} | ${d.imageRef.padEnd(35)}`);
+                    });
+                    console.log('------------------------------------------------------------------------------------------------------------------------\n');
+                    break;
+                }
+                case 'create': {
+                    const answers = await inquirer_1.default.prompt([
+                        {
+                            type: 'input',
+                            name: 'appName',
+                            message: 'Nom de l\'application (alphanumeric/dashes only):',
+                            validate: (input) => {
+                                if (!input || !/^[a-zA-Z0-9\-]+$/.test(input)) {
+                                    return 'Application name is required and can only contain letters, numbers, and dashes.';
+                                }
+                                return true;
+                            }
+                        },
+                        {
+                            type: 'list',
+                            name: 'env',
+                            message: 'Environnement (dev / prod) :',
+                            choices: [
+                                { name: 'Development (suffixed with -dev)', value: 'dev' },
+                                { name: 'Production', value: 'prod' }
+                            ]
+                        }
+                    ]);
+                    const appNameClean = answers.appName.toLowerCase();
+                    const suffix = Math.random().toString(36).substring(2, 7);
+                    let defaultNamespace = `${appNameClean}-${suffix}`;
+                    let defaultDomain = `${appNameClean}-${suffix}.quatrain.app`;
+                    if (answers.env === 'dev') {
+                        defaultNamespace += '-dev';
+                        defaultDomain = `${appNameClean}-${suffix}.quatrain.dev`;
+                    }
+                    const flowAnswers = await inquirer_1.default.prompt([
+                        {
+                            type: 'input',
+                            name: 'domain',
+                            message: `Subdomain Access FQDN (Par défaut: ${defaultDomain}) :`,
+                            default: defaultDomain
+                        },
+                        {
+                            type: 'input',
+                            name: 'imageRef',
+                            message: `Référence de l'image (Par défaut: studio-image:${detectLatestStableTag(coreDeployPath)}) :`,
+                            default: `ghcr.io/quatrain/studio-image:${detectLatestStableTag(coreDeployPath)}`
+                        },
+                        {
+                            type: 'input',
+                            name: 'authUser',
+                            message: 'Auth Username (Par défaut: admin) :',
+                            default: 'admin'
+                        },
+                        {
+                            type: 'input',
+                            name: 'authPass',
+                            message: `Auth Password (Par défaut (généré sécurisé) :`,
+                            default: () => generateSecurePassword()
+                        },
+                        {
+                            type: 'list',
+                            name: 'resourceChoice',
+                            message: 'Configure Resources / Physical Storage:',
+                            choices: [
+                                { name: 'Use Default Limits (CPU req: 100m, limit: 500m | Mem req: 256Mi, limit: 512Mi | Data: 1Gi, Storage: 10Gi)', value: 'default' },
+                                { name: 'Customize Resources & Storage', value: 'custom' }
+                            ]
+                        }
+                    ]);
+                    let resources = {
+                        cpuRequests: '100m',
+                        cpuLimits: '500m',
+                        memRequests: '256Mi',
+                        memLimits: '512Mi',
+                        dataPvcSize: '1Gi',
+                        storagePvcSize: '10Gi'
+                    };
+                    if (flowAnswers.resourceChoice === 'custom') {
+                        const customRes = await inquirer_1.default.prompt([
+                            {
+                                type: 'input',
+                                name: 'cpuRequests',
+                                message: 'CPU Requests (e.g. 100m, 50m) :',
+                                default: '100m'
+                            },
+                            {
+                                type: 'input',
+                                name: 'cpuLimits',
+                                message: 'CPU Limits (e.g. 500m, 200m) :',
+                                default: '500m'
+                            },
+                            {
+                                type: 'input',
+                                name: 'memRequests',
+                                message: 'Memory Requests (e.g. 256Mi, 128Mi) :',
+                                default: '256Mi'
+                            },
+                            {
+                                type: 'input',
+                                name: 'memLimits',
+                                message: 'Memory Limits (e.g. 512Mi, 256Mi) :',
+                                default: '512Mi'
+                            },
+                            {
+                                type: 'input',
+                                name: 'dataPvcSize',
+                                message: 'Data PVC Storage Capacity (e.g. 1Gi, 2Gi) :',
+                                default: '1Gi'
+                            },
+                            {
+                                type: 'input',
+                                name: 'storagePvcSize',
+                                message: 'Storage PVC Storage Capacity (e.g. 10Gi, 5Gi) :',
+                                default: '10Gi'
+                            }
+                        ]);
+                        resources = customRes;
+                    }
+                    const meta = {
+                        appName: appNameClean,
+                        namespace: defaultNamespace,
+                        env: answers.env,
+                        domain: flowAnswers.domain,
+                        imageRef: flowAnswers.imageRef,
+                        authUser: flowAnswers.authUser,
+                        authPass: flowAnswers.authPass,
+                        resources,
+                        createdAt: new Date().toISOString()
+                    };
+                    scaffoldManifests(coreDeployPath, meta);
+                    console.log(`\n✅ Manifests and metadata successfully scaffolded under: k8s/apps/${meta.namespace}/`);
+                    console.log(`🌐 FQDN access URL: https://${meta.domain}`);
+                    console.log(`🔑 Credentials   : ${meta.authUser} / ${meta.authPass}\n`);
+                    const { applyNow } = await inquirer_1.default.prompt([
+                        {
+                            type: 'confirm',
+                            name: 'applyNow',
+                            message: `Do you want to deploy ${meta.namespace} immediately to the Kubernetes cluster?`,
+                            default: true
+                        }
+                    ]);
+                    if (applyNow) {
+                        const output = applyManifests(coreDeployPath, meta.namespace);
+                        console.log(`\x1b[32m${output}\x1b[0m`);
+                    }
+                    break;
+                }
+                case 'modify': {
+                    const deployments = loadAllDeployments(coreDeployPath);
+                    if (deployments.length === 0) {
+                        console.log('\nℹ️  No deployments found to modify.\n');
+                        break;
+                    }
+                    const { targetNs } = await inquirer_1.default.prompt([
+                        {
+                            type: 'list',
+                            name: 'targetNs',
+                            message: 'Select the deployment to modify:',
+                            choices: deployments.map(d => ({
+                                name: `${d.namespace} (domain: ${d.domain})`,
+                                value: d.namespace
+                            }))
+                        }
+                    ]);
+                    const targetMeta = deployments.find(d => d.namespace === targetNs);
+                    const updates = await inquirer_1.default.prompt([
+                        {
+                            type: 'input',
+                            name: 'domain',
+                            message: 'Subdomain Access FQDN:',
+                            default: targetMeta.domain
+                        },
+                        {
+                            type: 'input',
+                            name: 'imageRef',
+                            message: 'Image Reference:',
+                            default: targetMeta.imageRef
+                        },
+                        {
+                            type: 'input',
+                            name: 'authUser',
+                            message: 'Auth Username:',
+                            default: targetMeta.authUser
+                        },
+                        {
+                            type: 'input',
+                            name: 'authPass',
+                            message: 'Auth Password:',
+                            default: targetMeta.authPass
+                        },
+                        {
+                            type: 'input',
+                            name: 'cpuRequests',
+                            message: 'CPU Requests:',
+                            default: targetMeta.resources?.cpuRequests || '100m'
+                        },
+                        {
+                            type: 'input',
+                            name: 'cpuLimits',
+                            message: 'CPU Limits:',
+                            default: targetMeta.resources?.cpuLimits || '500m'
+                        },
+                        {
+                            type: 'input',
+                            name: 'memRequests',
+                            message: 'Memory Requests:',
+                            default: targetMeta.resources?.memRequests || '256Mi'
+                        },
+                        {
+                            type: 'input',
+                            name: 'memLimits',
+                            message: 'Memory Limits:',
+                            default: targetMeta.resources?.memLimits || '512Mi'
+                        },
+                        {
+                            type: 'input',
+                            name: 'dataPvcSize',
+                            message: 'Data PVC storage size:',
+                            default: targetMeta.resources?.dataPvcSize || '1Gi'
+                        },
+                        {
+                            type: 'input',
+                            name: 'storagePvcSize',
+                            message: 'Storage PVC storage size:',
+                            default: targetMeta.resources?.storagePvcSize || '10Gi'
+                        }
+                    ]);
+                    const updatedMeta = {
+                        ...targetMeta,
+                        domain: updates.domain,
+                        imageRef: updates.imageRef,
+                        authUser: updates.authUser,
+                        authPass: updates.authPass,
+                        resources: {
+                            cpuRequests: updates.cpuRequests,
+                            cpuLimits: updates.cpuLimits,
+                            memRequests: updates.memRequests,
+                            memLimits: updates.memLimits,
+                            dataPvcSize: updates.dataPvcSize,
+                            storagePvcSize: updates.storagePvcSize
+                        },
+                        updatedAt: new Date().toISOString()
+                    };
+                    scaffoldManifests(coreDeployPath, updatedMeta);
+                    console.log(`\n✅ Manifests and metadata updated for namespace ${targetNs}.`);
+                    const { applyNow } = await inquirer_1.default.prompt([
+                        {
+                            type: 'confirm',
+                            name: 'applyNow',
+                            message: 'Do you want to apply these updates to the cluster now?',
+                            default: true
+                        }
+                    ]);
+                    if (applyNow) {
+                        const output = applyManifests(coreDeployPath, targetNs);
+                        console.log(`\x1b[32m${output}\x1b[0m`);
+                    }
+                    break;
+                }
+                case 'promote': {
+                    const deployments = loadAllDeployments(coreDeployPath);
+                    const devDeployments = deployments.filter(d => d.env === 'dev' || d.namespace.endsWith('-dev'));
+                    if (devDeployments.length === 0) {
+                        console.log('\nℹ️  No development deployments found to promote.\n');
+                        break;
+                    }
+                    const { targetNs } = await inquirer_1.default.prompt([
+                        {
+                            type: 'list',
+                            name: 'targetNs',
+                            message: 'Select the development app to promote to production:',
+                            choices: devDeployments.map(d => ({
+                                name: `${d.namespace} (domain: ${d.domain})`,
+                                value: d.namespace
+                            }))
+                        }
+                    ]);
+                    const devMeta = devDeployments.find(d => d.namespace === targetNs);
+                    const prodNamespace = devMeta.namespace.replace(/-dev$/, '');
+                    const prodDomain = devMeta.domain.replace(/\.dev$/, '.app');
+                    console.log(`\nPromoting installation to production:`);
+                    console.log(`  Dev Namespace  : ${devMeta.namespace} -> Prod Namespace : \x1b[32m${prodNamespace}\x1b[0m`);
+                    console.log(`  Dev Domain     : ${devMeta.domain} -> Prod Domain    : \x1b[32m${prodDomain}\x1b[0m\n`);
+                    const confirmPromote = await inquirer_1.default.prompt([
+                        {
+                            type: 'confirm',
+                            name: 'confirm',
+                            message: 'Do you want to proceed with this promotion?',
+                            default: true
+                        }
+                    ]);
+                    if (!confirmPromote.confirm) {
+                        console.log('Promotion cancelled.\n');
+                        break;
+                    }
+                    const prodMeta = {
+                        appName: devMeta.appName,
+                        namespace: prodNamespace,
+                        env: 'prod',
+                        domain: prodDomain,
+                        imageRef: devMeta.imageRef,
+                        authUser: devMeta.authUser,
+                        authPass: devMeta.authPass,
+                        resources: { ...devMeta.resources },
+                        createdAt: new Date().toISOString()
+                    };
+                    scaffoldManifests(coreDeployPath, prodMeta);
+                    console.log(`\n✅ Production manifests scaffolded under: k8s/apps/${prodNamespace}/`);
+                    const { applyNow } = await inquirer_1.default.prompt([
+                        {
+                            type: 'confirm',
+                            name: 'applyNow',
+                            message: `Do you want to deploy ${prodNamespace} immediately to production?`,
+                            default: true
+                        }
+                    ]);
+                    if (applyNow) {
+                        const output = applyManifests(coreDeployPath, prodNamespace);
+                        console.log(`\x1b[32m${output}\x1b[0m`);
+                    }
+                    break;
+                }
+                case 'delete': {
+                    const deployments = loadAllDeployments(coreDeployPath);
+                    if (deployments.length === 0) {
+                        console.log('\nℹ️  No deployments found to delete.\n');
+                        break;
+                    }
+                    const { targetNs } = await inquirer_1.default.prompt([
+                        {
+                            type: 'list',
+                            name: 'targetNs',
+                            message: 'Select the deployment to delete:',
+                            choices: deployments.map(d => ({
+                                name: `${d.namespace} (domain: ${d.domain})`,
+                                value: d.namespace
+                            }))
+                        }
+                    ]);
+                    const { confirmDelete } = await inquirer_1.default.prompt([
+                        {
+                            type: 'confirm',
+                            name: 'confirmDelete',
+                            message: `Are you sure you want to delete local manifests & config for ${targetNs}? (This action is irreversible!)`,
+                            default: false
+                        }
+                    ]);
+                    if (!confirmDelete) {
+                        console.log('Deletion cancelled.\n');
+                        break;
+                    }
+                    const { deleteK8s } = await inquirer_1.default.prompt([
+                        {
+                            type: 'confirm',
+                            name: 'deleteK8s',
+                            message: `Do you also want to delete the namespace "${targetNs}" from the active Kubernetes cluster?`,
+                            default: true
+                        }
+                    ]);
+                    if (deleteK8s) {
+                        console.log(`Executing: kubectl delete namespace ${targetNs}`);
+                        try {
+                            const output = (0, node_child_process_1.execSync)(`kubectl delete namespace "${targetNs}"`, { encoding: 'utf8' });
+                            console.log(`\x1b[32m${output}\x1b[0m`);
+                        }
+                        catch (err) {
+                            console.error(`Failed to delete namespace ${targetNs} on the cluster:`, err.message);
+                        }
+                    }
+                    const appDir = node_path_1.default.join(coreDeployPath, 'k8s/apps', targetNs);
+                    if (node_fs_1.default.existsSync(appDir)) {
+                        node_fs_1.default.rmSync(appDir, { recursive: true, force: true });
+                        console.log(`✅ Deleted local directory: k8s/apps/${targetNs}\n`);
+                    }
+                    break;
+                }
+                case 'exit':
+                    exitCli = true;
+                    break;
+            }
+        }
+        catch (err) {
+            console.error(`\n❌ Error performing action: ${err.message}\n`);
+        }
+    }
+    console.log('🚪 Exiting Deployment Manager.');
+}
+//# sourceMappingURL=deploy.js.map