katax-cli 1.1.3 → 1.2.0

package/dist/commands/deploy.js

@@ -1,96 +1,96 @@
-import chalk from 'chalk';
-import inquirer from 'inquirer';
-import ora from 'ora';
-import path from 'path';
-import { execa } from 'execa';
-import { success, error, warning, title, info, gray } from '../utils/logger.js';
-import { directoryExists, writeFile } from '../utils/file-utils.js';
+import chalk from "chalk";
+import inquirer from "inquirer";
+import ora from "ora";
+import path from "path";
+import { execa } from "execa";
+import { success, error, warning, title, info, gray } from "../utils/logger.js";
+import { directoryExists, writeFile, fileExists } from "../utils/file-utils.js";
 export async function deployInitCommand() {
-    title('🚀 Katax Deploy - Initial Setup');
+    title("🚀 Katax Deploy - Initial Setup");
     const pm2Installed = await checkPM2Installation();
     if (!pm2Installed) {
-        error('PM2 is not installed globally!');
-        info('Install with: npm install -g pm2');
+        error("PM2 is not installed globally!");
+        info("Install with: npm install -g pm2");
         process.exit(1);
     }
     const answers = await inquirer.prompt([
         {
-            type: 'input',
-            name: 'appName',
-            message: 'Application name for PM2:',
-            default: 'my-api',
+            type: "input",
+            name: "appName",
+            message: "Application name for PM2:",
+            default: "my-api",
             validate: (input) => {
                 if (!/^[a-z0-9-_]+$/i.test(input)) {
-                    return 'App name can only contain letters, numbers, hyphens, and underscores';
+                    return "App name can only contain letters, numbers, hyphens, and underscores";
                 }
                 return true;
-            }
+            },
         },
         {
-            type: 'list',
-            name: 'repoType',
-            message: 'Repository connection type:',
+            type: "list",
+            name: "repoType",
+            message: "Repository connection type:",
             choices: [
-                { name: 'HTTPS (username/password or token)', value: 'https' },
-                { name: 'SSH (requires SSH key setup)', value: 'ssh' }
+                { name: "HTTPS (username/password or token)", value: "https" },
+                { name: "SSH (requires SSH key setup)", value: "ssh" },
             ],
-            default: 'https'
+            default: "https",
         },
         {
-            type: 'input',
-            name: 'repoUrl',
-            message: 'Git repository URL:',
+            type: "input",
+            name: "repoUrl",
+            message: "Git repository URL:",
             validate: (input) => {
                 if (!input)
-                    return 'Repository URL is required';
-                if (!input.includes('git') && !input.includes('.git')) {
-                    return 'Please provide a valid Git repository URL';
+                    return "Repository URL is required";
+                if (!input.includes("git") && !input.includes(".git")) {
+                    return "Please provide a valid Git repository URL";
                 }
                 return true;
-            }
+            },
         },
         {
-            type: 'input',
-            name: 'branch',
-            message: 'Branch to deploy:',
-            default: 'main'
+            type: "input",
+            name: "branch",
+            message: "Branch to deploy:",
+            default: "main",
         },
         {
-            type: 'input',
-            name: 'installPath',
-            message: 'Installation path (absolute):',
-            default: `/home/${process.env.USER || 'ubuntu'}/apps`,
+            type: "input",
+            name: "installPath",
+            message: "Installation path (absolute):",
+            default: `/home/${process.env.USER || "ubuntu"}/apps`,
             validate: (input) => {
                 if (!path.isAbsolute(input)) {
-                    return 'Please provide an absolute path';
+                    return "Please provide an absolute path";
                 }
                 return true;
-            }
+            },
         },
         {
-            type: 'list',
-            name: 'instances',
-            message: 'PM2 instances (cluster mode):',
+            type: "list",
+            name: "instances",
+            message: "PM2 instances (cluster mode):",
             choices: [
-                { name: 'Max (use all CPU cores)', value: 'max' },
-                { name: '1 instance', value: 1 },
-                { name: '2 instances', value: 2 },
-                { name: '4 instances', value: 4 }
+                { name: "Max (use all CPU cores)", value: "max" },
+                { name: "1 instance", value: 1 },
+                { name: "2 instances", value: 2 },
+                { name: "4 instances", value: 4 },
             ],
-            default: 'max'
+            default: "max",
         },
         {
-            type: 'input',
-            name: 'maxMemory',
-            message: 'Max memory per instance (e.g., 512M, 1G):',
-            default: '512M'
+            type: "input",
+            name: "maxMemory",
+            message: "Max memory per instance (e.g., 512M, 1G):",
+            default: "512M",
         },
         {
-            type: 'confirm',
-            name: 'addEnvVars',
-            message: 'Add environment variables?',
-            default: true
-        }
+            type: "confirm",
+            name: "addEnvVars",
+            message: "Add environment variables?",
+            default: true,
+        },
     ]);
     let envVars = {};
     if (answers.addEnvVars) {
@@ -104,108 +104,180 @@ export async function deployInitCommand() {
         pm2Config: {
             instances: answers.instances,
             maxMemory: answers.maxMemory,
-            env: envVars
-        }
+            env: envVars,
+        },
     };
     await executeInitialDeploy(deployConfig);
 }
 export async function deployUpdateCommand(options) {
-    title('🔄 Katax Deploy - Update Application');
+    title("🔄 Katax Deploy - Update Application");
     const isGitRepo = await checkGitRepository();
     if (!isGitRepo) {
-        error('Not a git repository! Run this command from your project directory.');
-        info('Or use: katax deploy init');
+        error("Not a git repository! Run this command from your project directory.");
+        info("Or use: katax deploy init");
         process.exit(1);
     }
     const pm2Installed = await checkPM2Installation();
     if (!pm2Installed) {
-        error('PM2 is not installed globally!');
-        info('Install with: npm install -g pm2');
+        error("PM2 is not installed globally!");
+        info("Install with: npm install -g pm2");
         process.exit(1);
     }
     const currentDir = process.cwd();
-    const appName = path.basename(currentDir);
+    let appName = options.appName;
+    let wasAutoDiscovered = false;
+    if (!appName) {
+        const discovered = await discoverPM2AppName(currentDir);
+        if (discovered) {
+            appName = discovered;
+            wasAutoDiscovered = true;
+            info(`🔍 Discovered PM2 app: ${chalk.cyan(appName)}`);
+        }
+    }
+    if (!appName) {
+        const configPath = path.join(currentDir, ".katax-deploy.json");
+        if (fileExists(configPath)) {
+            try {
+                const fs = await import("fs");
+                const configContent = fs.readFileSync(configPath, "utf-8");
+                const config = JSON.parse(configContent);
+                appName = config.appName;
+                info(`📝 Using app name from config: ${chalk.cyan(appName)}`);
+            }
+            catch (err) {
+            }
+        }
+    }
+    if (!appName) {
+        appName = path.basename(currentDir);
+        warning(`⚠️  Using directory name as fallback: ${chalk.yellow(appName)}`);
+        info(`💡 Tip: Run ${chalk.cyan("pm2 list")} to verify the app name`);
+    }
     let targetBranch = options.branch;
     if (!targetBranch) {
-        const branchResult = await execa('git', ['branch', '--show-current']);
+        const branchResult = await execa("git", ["branch", "--show-current"]);
         targetBranch = branchResult.stdout.trim();
     }
+    if (wasAutoDiscovered && appName) {
+        await saveAppNameToConfig(currentDir, appName, targetBranch);
+    }
     info(`📦 Application: ${chalk.cyan(appName)}`);
     info(`🌿 Branch: ${chalk.cyan(targetBranch)}`);
     if (options.hard) {
-        warning('⚠️  Hard reset enabled - all local changes will be lost!');
+        warning("⚠️  Hard reset enabled - all local changes will be lost!");
     }
     const { confirm } = await inquirer.prompt([
         {
-            type: 'confirm',
-            name: 'confirm',
-            message: 'Proceed with update?',
-            default: true
-        }
+            type: "confirm",
+            name: "confirm",
+            message: "Proceed with update?",
+            default: true,
+        },
     ]);
     if (!confirm) {
-        warning('Update cancelled');
+        warning("Update cancelled");
         return;
     }
     await executeUpdate(appName, targetBranch, options.hard || false);
+    if (!wasAutoDiscovered) {
+        await saveAppNameToConfig(currentDir, appName, targetBranch, true);
+    }
 }
 export async function deployRollbackCommand(options) {
-    title('⏮️  Katax Deploy - Rollback');
+    title("⏮️  Katax Deploy - Rollback");
     const isGitRepo = await checkGitRepository();
     if (!isGitRepo) {
-        error('Not a git repository!');
+        error("Not a git repository!");
         process.exit(1);
     }
     const commits = options.commits || 1;
     const currentDir = process.cwd();
-    const appName = path.basename(currentDir);
+    let appName = options.appName;
+    if (!appName) {
+        appName = (await discoverPM2AppName(currentDir)) || undefined;
+    }
+    if (!appName) {
+        const configPath = path.join(currentDir, ".katax-deploy.json");
+        if (fileExists(configPath)) {
+            try {
+                const fs = await import("fs");
+                const configContent = fs.readFileSync(configPath, "utf-8");
+                const config = JSON.parse(configContent);
+                appName = config.appName;
+            }
+            catch (err) {
+            }
+        }
+    }
+    if (!appName) {
+        appName = path.basename(currentDir);
+    }
     warning(`Rolling back ${commits} commit(s) for ${appName}`);
     const { confirm } = await inquirer.prompt([
         {
-            type: 'confirm',
-            name: 'confirm',
-            message: 'This will reset your code. Continue?',
-            default: false
-        }
+            type: "confirm",
+            name: "confirm",
+            message: "This will reset your code. Continue?",
+            default: false,
+        },
     ]);
     if (!confirm) {
-        warning('Rollback cancelled');
+        warning("Rollback cancelled");
         return;
     }
     await executeRollback(appName, commits);
 }
 export async function deployLogsCommand(options) {
     const currentDir = process.cwd();
-    const appName = path.basename(currentDir);
+    let appName = options.appName;
+    if (!appName) {
+        appName = (await discoverPM2AppName(currentDir)) || undefined;
+    }
+    if (!appName) {
+        const configPath = path.join(currentDir, ".katax-deploy.json");
+        if (fileExists(configPath)) {
+            try {
+                const fs = await import("fs");
+                const configContent = fs.readFileSync(configPath, "utf-8");
+                const config = JSON.parse(configContent);
+                appName = config.appName;
+            }
+            catch (err) {
+            }
+        }
+    }
+    if (!appName) {
+        appName = path.basename(currentDir);
+    }
     title(`📋 PM2 Logs - ${appName}`);
-    const args = ['logs', appName];
+    const args = ["logs", appName];
     if (options.lines) {
-        args.push('--lines', options.lines.toString());
+        args.push("--lines", options.lines.toString());
     }
     if (!options.follow) {
-        args.push('--nostream');
+        args.push("--nostream");
     }
     try {
-        await execa('pm2', args, { stdio: 'inherit' });
+        await execa("pm2", args, { stdio: "inherit" });
     }
     catch (err) {
-        error('Failed to fetch logs');
+        error("Failed to fetch logs");
         console.error(err);
     }
 }
 export async function deployStatusCommand() {
-    title('📊 PM2 Status');
+    title("📊 PM2 Status");
     try {
-        await execa('pm2', ['list'], { stdio: 'inherit' });
+        await execa("pm2", ["list"], { stdio: "inherit" });
     }
     catch (err) {
-        error('Failed to get PM2 status');
+        error("Failed to get PM2 status");
         console.error(err);
     }
 }
 async function checkPM2Installation() {
     try {
-        await execa('pm2', ['--version']);
+        await execa("pm2", ["--version"]);
         return true;
     }
     catch {
@@ -214,32 +286,80 @@ async function checkPM2Installation() {
 }
 async function checkGitRepository() {
     try {
-        await execa('git', ['rev-parse', '--git-dir']);
+        await execa("git", ["rev-parse", "--git-dir"]);
         return true;
     }
     catch {
         return false;
     }
 }
+async function saveAppNameToConfig(projectDir, appName, branch, silent = false) {
+    try {
+        const configPath = path.join(projectDir, ".katax-deploy.json");
+        if (fileExists(configPath)) {
+            return;
+        }
+        const config = {
+            appName: appName,
+            createdAt: new Date().toISOString(),
+            branch: branch,
+            autoDiscovered: true,
+        };
+        await writeFile(configPath, JSON.stringify(config, null, 2));
+        if (!silent) {
+            success(`💾 Saved app name to .katax-deploy.json for future deployments`);
+        }
+    }
+    catch (err) {
+    }
+}
+async function discoverPM2AppName(targetDir) {
+    try {
+        const { stdout } = await execa("pm2", ["jlist"]);
+        const processes = JSON.parse(stdout);
+        const normalizedTargetDir = path.resolve(targetDir).toLowerCase();
+        for (const proc of processes) {
+            if (proc.pm2_env && proc.pm2_env.pm_cwd) {
+                const procDir = path.resolve(proc.pm2_env.pm_cwd).toLowerCase();
+                if (procDir === normalizedTargetDir) {
+                    return proc.name;
+                }
+            }
+            if (proc.pm2_env && proc.pm2_env.pm_exec_path) {
+                const execDir = path
+                    .resolve(path.dirname(proc.pm2_env.pm_exec_path))
+                    .toLowerCase();
+                if (execDir === normalizedTargetDir ||
+                    execDir.startsWith(normalizedTargetDir)) {
+                    return proc.name;
+                }
+            }
+        }
+        return null;
+    }
+    catch (err) {
+        return null;
+    }
+}
 async function collectEnvVars() {
     const envVars = {};
-    info('\n📝 Add environment variables (leave empty to finish):\n');
+    info("\n📝 Add environment variables (leave empty to finish):\n");
     while (true) {
         const { key } = await inquirer.prompt([
             {
-                type: 'input',
-                name: 'key',
-                message: 'Variable name:',
-            }
+                type: "input",
+                name: "key",
+                message: "Variable name:",
+            },
         ]);
         if (!key)
             break;
         const { value } = await inquirer.prompt([
             {
-                type: 'input',
-                name: 'value',
+                type: "input",
+                name: "value",
                 message: `Value for ${key}:`,
-            }
+            },
         ]);
         envVars[key] = value;
         success(`✓ ${key} added`);
@@ -252,124 +372,138 @@ async function executeInitialDeploy(config) {
         error(`Directory ${fullPath} already exists!`);
         process.exit(1);
     }
-    const cloneSpinner = ora('Cloning repository...').start();
+    const deployConfigFile = {
+        appName: config.appName,
+        createdAt: new Date().toISOString(),
+        branch: config.branch,
+    };
+    await writeFile(path.join(fullPath, ".katax-deploy.json"), JSON.stringify(deployConfigFile, null, 2));
+    const cloneSpinner = ora("Cloning repository...").start();
     try {
-        await execa('git', ['clone', '--branch', config.branch, config.repoUrl, fullPath]);
-        cloneSpinner.succeed('Repository cloned');
+        await execa("git", [
+            "clone",
+            "--branch",
+            config.branch,
+            config.repoUrl,
+            fullPath,
+        ]);
+        cloneSpinner.succeed("Repository cloned");
     }
     catch (err) {
-        cloneSpinner.fail('Failed to clone repository');
+        cloneSpinner.fail("Failed to clone repository");
         console.error(err);
         process.exit(1);
     }
-    const installSpinner = ora('Installing dependencies...').start();
+    const installSpinner = ora("Installing dependencies...").start();
     try {
-        await execa('npm', ['install'], { cwd: fullPath });
-        installSpinner.succeed('Dependencies installed');
+        await execa("npm", ["install"], { cwd: fullPath });
+        installSpinner.succeed("Dependencies installed");
     }
     catch (err) {
-        installSpinner.fail('Failed to install dependencies');
+        installSpinner.fail("Failed to install dependencies");
         console.error(err);
         process.exit(1);
     }
-    const buildSpinner = ora('Building project...').start();
+    const buildSpinner = ora("Building project...").start();
     try {
-        await execa('npm', ['run', 'build'], { cwd: fullPath });
-        buildSpinner.succeed('Project built');
+        await execa("npm", ["run", "build"], { cwd: fullPath });
+        buildSpinner.succeed("Project built");
     }
     catch (err) {
-        buildSpinner.fail('Failed to build project');
+        buildSpinner.fail("Failed to build project");
         console.error(err);
         process.exit(1);
     }
     await generatePM2Config(fullPath, config);
-    const pm2Spinner = ora('Starting with PM2...').start();
+    const pm2Spinner = ora("Starting with PM2...").start();
     try {
-        await execa('pm2', ['start', 'ecosystem.config.cjs', '--env', 'production'], { cwd: fullPath });
-        await execa('pm2', ['save']);
-        pm2Spinner.succeed('Application started with PM2');
+        await execa("pm2", ["start", "ecosystem.config.cjs", "--env", "production"], { cwd: fullPath });
+        await execa("pm2", ["save"]);
+        pm2Spinner.succeed("Application started with PM2");
     }
     catch (err) {
-        pm2Spinner.fail('Failed to start with PM2');
+        pm2Spinner.fail("Failed to start with PM2");
         console.error(err);
         process.exit(1);
     }
     success(`\n✅ Deployment completed successfully!`);
     info(`\n📍 Location: ${fullPath}`);
     info(`🔧 PM2 App Name: ${config.appName}`);
+    info(`📝 Config saved: .katax-deploy.json`);
     info(`\nUseful commands:`);
     gray(`  pm2 logs ${config.appName}       # View logs`);
     gray(`  pm2 restart ${config.appName}    # Restart app`);
     gray(`  pm2 stop ${config.appName}       # Stop app`);
-    gray(`  katax deploy update           # Update deployment\n`);
+    gray(`  katax deploy update           # Update deployment`);
+    gray(`  katax deploy update --app-name ${config.appName}  # Specify app name\n`);
 }
 async function executeUpdate(appName, branch, hard) {
     const currentDir = process.cwd();
-    const gitSpinner = ora('Updating code from git...').start();
+    const gitSpinner = ora("Updating code from git...").start();
     try {
-        await execa('git', ['fetch', 'origin', branch]);
+        await execa("git", ["fetch", "origin", branch]);
         if (hard) {
-            await execa('git', ['reset', '--hard', `origin/${branch}`]);
+            await execa("git", ["reset", "--hard", `origin/${branch}`]);
         }
         else {
-            await execa('git', ['pull', 'origin', branch]);
+            await execa("git", ["pull", "origin", branch]);
         }
-        gitSpinner.succeed('Code updated');
+        gitSpinner.succeed("Code updated");
     }
     catch (err) {
-        gitSpinner.fail('Git update failed');
+        gitSpinner.fail("Git update failed");
         error(err.message);
         process.exit(1);
     }
-    const installSpinner = ora('Installing dependencies...').start();
+    const installSpinner = ora("Installing dependencies...").start();
     try {
-        await execa('npm', ['install'], { cwd: currentDir });
-        installSpinner.succeed('Dependencies updated');
+        await execa("npm", ["install"], { cwd: currentDir });
+        installSpinner.succeed("Dependencies updated");
     }
     catch (err) {
-        installSpinner.fail('Failed to install dependencies');
+        installSpinner.fail("Failed to install dependencies");
         console.error(err);
         process.exit(1);
     }
-    const buildSpinner = ora('Building project...').start();
+    const buildSpinner = ora("Building project...").start();
     try {
-        await execa('npm', ['run', 'build'], { cwd: currentDir });
-        buildSpinner.succeed('Project rebuilt');
+        await execa("npm", ["run", "build"], { cwd: currentDir });
+        buildSpinner.succeed("Project rebuilt");
     }
     catch (err) {
-        buildSpinner.fail('Build failed');
+        buildSpinner.fail("Build failed");
         console.error(err);
         process.exit(1);
     }
-    const pm2Spinner = ora('Restarting PM2...').start();
+    const pm2Spinner = ora("Restarting PM2...").start();
     try {
-        await execa('pm2', ['restart', appName]);
-        pm2Spinner.succeed('Application restarted');
+        await execa("pm2", ["restart", appName]);
+        pm2Spinner.succeed("Application restarted");
     }
     catch (err) {
-        pm2Spinner.fail('PM2 restart failed');
+        pm2Spinner.fail("PM2 restart failed");
         console.error(err);
         process.exit(1);
     }
-    success('\n✅ Update completed successfully!');
+    success("\n✅ Update completed successfully!");
     info(`\nView logs with: pm2 logs ${appName}\n`);
 }
 async function executeRollback(appName, commits) {
     const rollbackSpinner = ora(`Rolling back ${commits} commit(s)...`).start();
     try {
-        await execa('git', ['reset', '--hard', `HEAD~${commits}`]);
-        rollbackSpinner.succeed('Code rolled back');
-        const buildSpinner = ora('Rebuilding...').start();
-        await execa('npm', ['install']);
-        await execa('npm', ['run', 'build']);
-        buildSpinner.succeed('Project rebuilt');
-        const pm2Spinner = ora('Restarting PM2...').start();
-        await execa('pm2', ['restart', appName]);
-        pm2Spinner.succeed('Application restarted');
-        success('\n✅ Rollback completed successfully!');
+        await execa("git", ["reset", "--hard", `HEAD~${commits}`]);
+        rollbackSpinner.succeed("Code rolled back");
+        const buildSpinner = ora("Rebuilding...").start();
+        await execa("npm", ["install"]);
+        await execa("npm", ["run", "build"]);
+        buildSpinner.succeed("Project rebuilt");
+        const pm2Spinner = ora("Restarting PM2...").start();
+        await execa("pm2", ["restart", appName]);
+        pm2Spinner.succeed("Application restarted");
+        success("\n✅ Rollback completed successfully!");
     }
     catch (err) {
-        rollbackSpinner.fail('Rollback failed');
+        rollbackSpinner.fail("Rollback failed");
         console.error(err);
         process.exit(1);
     }
@@ -384,7 +518,7 @@ module.exports = {
     script: './dist/index.js',
     
     // Cluster mode
-    instances: ${typeof config.pm2Config.instances === 'number' ? config.pm2Config.instances : `'${config.pm2Config.instances}'`},
+    instances: ${typeof config.pm2Config.instances === "number" ? config.pm2Config.instances : `'${config.pm2Config.instances}'`},
     exec_mode: 'cluster',
     
     // Resource limits
@@ -404,13 +538,13 @@ module.exports = {
     
     // Environment variables
     env_production: ${JSON.stringify({
-        NODE_ENV: 'production',
-        ...config.pm2Config.env
+        NODE_ENV: "production",
+        ...config.pm2Config.env,
     }, null, 6)}
   }]
 };
 `;
-    await writeFile(path.join(projectPath, 'ecosystem.config.cjs'), ecosystem);
-    success('✓ PM2 ecosystem.config.cjs generated');
+    await writeFile(path.join(projectPath, "ecosystem.config.cjs"), ecosystem);
+    success("✓ PM2 ecosystem.config.cjs generated");
 }
 //# sourceMappingURL=deploy.js.map