@wundr.io/cli 1.0.12 → 1.0.14

package/dist/commands/batch.js

@@ -0,0 +1,854 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchCommands = void 0;
+const tslib_1 = require("tslib");
+const path_1 = tslib_1.__importDefault(require("path"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const listr2_1 = require("listr2");
+const yaml_1 = tslib_1.__importDefault(require("yaml"));
+const error_handler_1 = require("../utils/error-handler");
+const logger_1 = require("../utils/logger");
+/**
+ * Batch commands for YAML automation and batch processing
+ */
+class BatchCommands {
+    program;
+    configManager;
+    pluginManager;
+    runningJobs = new Map();
+    constructor(program, configManager, pluginManager) {
+        this.program = program;
+        this.configManager = configManager;
+        this.pluginManager = pluginManager;
+        this.registerCommands();
+    }
+    registerCommands() {
+        const batchCmd = this.program
+            .command('batch')
+            .description('batch processing and automation with YAML');
+        // Run batch job
+        batchCmd
+            .command('run <file>')
+            .description('run batch job from YAML file')
+            .option('--dry-run', 'show what would be executed without running')
+            .option('--parallel', 'run commands in parallel where possible')
+            .option('--continue-on-error', 'continue execution on command failures')
+            .option('--vars <vars>', 'variables to pass to batch job (JSON or key=value)')
+            .option('--timeout <ms>', 'global timeout for batch job')
+            .action(async (file, options) => {
+            await this.runBatchJob(file, options);
+        });
+        // Create batch job
+        batchCmd
+            .command('create <name>')
+            .description('create a new batch job')
+            .option('--template <template>', 'batch job template')
+            .option('--commands <commands>', 'commands to include (comma-separated)')
+            .option('--interactive', 'create job interactively')
+            .action(async (name, options) => {
+            await this.createBatchJob(name, options);
+        });
+        // List batch jobs
+        batchCmd
+            .command('list')
+            .alias('ls')
+            .description('list available batch jobs')
+            .option('--path <path>', 'custom batch jobs directory')
+            .action(async (options) => {
+            await this.listBatchJobs(options);
+        });
+        // Validate batch job
+        batchCmd
+            .command('validate <file>')
+            .description('validate batch job YAML file')
+            .action(async (file) => {
+            await this.validateBatchJob(file);
+        });
+        // Stop running job
+        batchCmd
+            .command('stop <jobId>')
+            .description('stop a running batch job')
+            .action(async (jobId) => {
+            await this.stopBatchJob(jobId);
+        });
+        // Show job status
+        batchCmd
+            .command('status [jobId]')
+            .description('show batch job status')
+            .action(async (jobId) => {
+            await this.showJobStatus(jobId);
+        });
+        // Schedule batch job
+        batchCmd
+            .command('schedule <file>')
+            .description('schedule batch job execution')
+            .option('--cron <expression>', 'cron expression for scheduling')
+            .option('--interval <ms>', 'interval in milliseconds')
+            .option('--once', 'run once after delay')
+            .action(async (file, options) => {
+            await this.scheduleBatchJob(file, options);
+        });
+        // Export batch job
+        batchCmd
+            .command('export <file>')
+            .description('export batch job to different formats')
+            .option('--format <format>', 'export format (json, shell, dockerfile)', 'json')
+            .option('--output <path>', 'output file path')
+            .action(async (file, options) => {
+            await this.exportBatchJob(file, options);
+        });
+        // Import batch job
+        batchCmd
+            .command('import <file>')
+            .description('import batch job from different formats')
+            .option('--format <format>', 'source format (json, shell, package-scripts)')
+            .option('--name <name>', 'batch job name')
+            .action(async (file, options) => {
+            await this.importBatchJob(file, options);
+        });
+        // Template management
+        batchCmd.command('template').description('manage batch job templates');
+        batchCmd
+            .command('template list')
+            .description('list available templates')
+            .action(async () => {
+            await this.listTemplates();
+        });
+        batchCmd
+            .command('template create <name>')
+            .description('create a new template')
+            .option('--from <file>', 'create template from existing batch job')
+            .action(async (name, options) => {
+            await this.createTemplate(name, options);
+        });
+    }
+    /**
+     * Run batch job from YAML file
+     */
+    async runBatchJob(file, options) {
+        try {
+            logger_1.logger.info(`Running batch job: ${chalk_1.default.cyan(file)}`);
+            // Load and validate batch job
+            const job = await this.loadBatchJob(file);
+            await this.validateJobStructure(job);
+            // Process variables
+            const processedJob = await this.processJobVariables(job, options.vars);
+            if (options.dryRun) {
+                await this.showDryRun(processedJob);
+                return;
+            }
+            // Create job ID and track execution
+            const jobId = `job-${Date.now()}`;
+            this.runningJobs.set(jobId, {
+                file,
+                job: processedJob,
+                startTime: Date.now(),
+                status: 'running',
+            });
+            try {
+                await this.executeBatchJob(processedJob, jobId, options);
+                logger_1.logger.success(`Batch job completed: ${file}`);
+            }
+            finally {
+                this.runningJobs.delete(jobId);
+            }
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_BATCH_RUN_FAILED', 'Failed to run batch job', { file, options }, true);
+        }
+    }
+    /**
+     * Create a new batch job
+     */
+    async createBatchJob(name, options) {
+        try {
+            logger_1.logger.info(`Creating batch job: ${chalk_1.default.cyan(name)}`);
+            let job;
+            if (options.interactive) {
+                job = await this.createInteractiveBatchJob(name);
+            }
+            else if (options.template) {
+                job = await this.createJobFromTemplate(name, options.template);
+            }
+            else {
+                job = this.createBasicBatchJob(name, options);
+            }
+            const jobPath = path_1.default.join(process.cwd(), '.wundr', 'batch', `${name}.yaml`);
+            await fs_extra_1.default.ensureDir(path_1.default.dirname(jobPath));
+            await fs_extra_1.default.writeFile(jobPath, yaml_1.default.stringify(job));
+            logger_1.logger.success(`Batch job created: ${jobPath}`);
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_BATCH_CREATE_FAILED', 'Failed to create batch job', { name, options }, true);
+        }
+    }
+    /**
+     * List available batch jobs
+     */
+    async listBatchJobs(options) {
+        try {
+            const batchDir = options.path || path_1.default.join(process.cwd(), '.wundr', 'batch');
+            if (!(await fs_extra_1.default.pathExists(batchDir))) {
+                logger_1.logger.info('No batch jobs directory found');
+                return;
+            }
+            const files = await fs_extra_1.default.readdir(batchDir);
+            const yamlFiles = files.filter(f => f.endsWith('.yaml') || f.endsWith('.yml'));
+            if (yamlFiles.length === 0) {
+                logger_1.logger.info('No batch jobs found');
+                return;
+            }
+            logger_1.logger.info(`Batch jobs (${yamlFiles.length}):`);
+            const jobs = [];
+            for (const file of yamlFiles) {
+                const filePath = path_1.default.join(batchDir, file);
+                try {
+                    const job = await this.loadBatchJob(filePath);
+                    jobs.push({
+                        Name: path_1.default.basename(file, path_1.default.extname(file)),
+                        Description: job.description || 'No description',
+                        Commands: job.commands.length,
+                        Parallel: job.parallel ? '✓' : '✗',
+                    });
+                }
+                catch (error) {
+                    jobs.push({
+                        Name: path_1.default.basename(file, path_1.default.extname(file)),
+                        Description: 'Invalid YAML',
+                        Commands: 'N/A',
+                        Parallel: 'N/A',
+                    });
+                }
+            }
+            console.table(jobs);
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_BATCH_LIST_FAILED', 'Failed to list batch jobs', { options }, true);
+        }
+    }
+    /**
+     * Validate batch job YAML file
+     */
+    async validateBatchJob(file) {
+        try {
+            logger_1.logger.info(`Validating batch job: ${chalk_1.default.cyan(file)}`);
+            const job = await this.loadBatchJob(file);
+            const validation = await this.validateJobStructure(job);
+            if (validation.valid) {
+                logger_1.logger.success('Batch job is valid ✓');
+                // Show job summary
+                console.log(chalk_1.default.blue('\nJob Summary:'));
+                console.log(`Name: ${job.name}`);
+                console.log(`Description: ${job.description || 'None'}`);
+                console.log(`Commands: ${job.commands.length}`);
+                console.log(`Parallel execution: ${job.parallel ? 'Yes' : 'No'}`);
+                console.log(`Continue on error: ${job.continueOnError ? 'Yes' : 'No'}`);
+            }
+            else {
+                logger_1.logger.error('Batch job validation failed:');
+                validation.errors.forEach(error => {
+                    logger_1.logger.error(`  - ${error}`);
+                });
+                process.exit(1);
+            }
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_BATCH_VALIDATE_FAILED', 'Failed to validate batch job', { file }, true);
+        }
+    }
+    /**
+     * Stop a running batch job
+     */
+    async stopBatchJob(jobId) {
+        try {
+            const job = this.runningJobs.get(jobId);
+            if (!job) {
+                logger_1.logger.warn(`Job not found: ${jobId}`);
+                return;
+            }
+            // Stop the job (implementation would depend on how jobs are executed)
+            job.status = 'stopped';
+            this.runningJobs.delete(jobId);
+            logger_1.logger.success(`Batch job stopped: ${jobId}`);
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_BATCH_STOP_FAILED', 'Failed to stop batch job', { jobId }, true);
+        }
+    }
+    /**
+     * Show job status
+     */
+    async showJobStatus(jobId) {
+        try {
+            if (jobId) {
+                const job = this.runningJobs.get(jobId);
+                if (!job) {
+                    logger_1.logger.warn(`Job not found: ${jobId}`);
+                    return;
+                }
+                console.log(chalk_1.default.blue(`\nJob Status: ${jobId}`));
+                console.log(`File: ${job.file}`);
+                console.log(`Status: ${job.status}`);
+                console.log(`Started: ${new Date(job.startTime).toLocaleString()}`);
+                console.log(`Duration: ${Date.now() - job.startTime}ms`);
+            }
+            else {
+                if (this.runningJobs.size === 0) {
+                    logger_1.logger.info('No running batch jobs');
+                    return;
+                }
+                console.log(chalk_1.default.blue(`\nRunning Jobs (${this.runningJobs.size}):`));
+                const jobData = Array.from(this.runningJobs.entries()).map(([id, job]) => ({
+                    ID: id,
+                    File: path_1.default.basename(job.file),
+                    Status: job.status,
+                    Duration: `${Date.now() - job.startTime}ms`,
+                }));
+                console.table(jobData);
+            }
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_BATCH_STATUS_FAILED', 'Failed to show job status', { jobId }, true);
+        }
+    }
+    /**
+     * Schedule batch job execution
+     */
+    async scheduleBatchJob(file, options) {
+        try {
+            logger_1.logger.info(`Scheduling batch job: ${chalk_1.default.cyan(file)}`);
+            // Validate the job first
+            await this.loadBatchJob(file);
+            if (options.cron) {
+                logger_1.logger.info(`Scheduled with cron: ${options.cron}`);
+                // Implementation would use a cron library
+            }
+            else if (options.interval) {
+                logger_1.logger.info(`Scheduled with interval: ${options.interval}ms`);
+                // Implementation would use setInterval
+            }
+            else if (options.once) {
+                logger_1.logger.info('Scheduled to run once');
+                // Implementation would use setTimeout
+            }
+            else {
+                throw new Error('No scheduling option provided');
+            }
+            logger_1.logger.success('Batch job scheduled successfully');
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_BATCH_SCHEDULE_FAILED', 'Failed to schedule batch job', { file, options }, true);
+        }
+    }
+    /**
+     * Export batch job to different formats
+     */
+    async exportBatchJob(file, options) {
+        try {
+            logger_1.logger.info(`Exporting batch job: ${chalk_1.default.cyan(file)}`);
+            const job = await this.loadBatchJob(file);
+            let exportedContent;
+            switch (options.format) {
+                case 'json':
+                    exportedContent = JSON.stringify(job, null, 2);
+                    break;
+                case 'shell':
+                    exportedContent = this.convertToShellScript(job);
+                    break;
+                case 'dockerfile':
+                    exportedContent = this.convertToDockerfile(job);
+                    break;
+                default:
+                    throw new Error(`Unsupported export format: ${options.format}`);
+            }
+            const outputPath = options.output ||
+                `${path_1.default.basename(file, path_1.default.extname(file))}.${options.format}`;
+            await fs_extra_1.default.writeFile(outputPath, exportedContent);
+            logger_1.logger.success(`Batch job exported: ${outputPath}`);
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_BATCH_EXPORT_FAILED', 'Failed to export batch job', { file, options }, true);
+        }
+    }
+    /**
+     * Import batch job from different formats
+     */
+    async importBatchJob(file, options) {
+        try {
+            logger_1.logger.info(`Importing batch job: ${chalk_1.default.cyan(file)}`);
+            let job;
+            switch (options.format) {
+                case 'json':
+                    job = await this.importFromJSON(file, options.name);
+                    break;
+                case 'shell':
+                    job = await this.importFromShell(file, options.name);
+                    break;
+                case 'package-scripts':
+                    job = await this.importFromPackageScripts(file, options.name);
+                    break;
+                default:
+                    throw new Error(`Unsupported import format: ${options.format}`);
+            }
+            const jobName = options.name || path_1.default.basename(file, path_1.default.extname(file));
+            const jobPath = path_1.default.join(process.cwd(), '.wundr', 'batch', `${jobName}.yaml`);
+            await fs_extra_1.default.ensureDir(path_1.default.dirname(jobPath));
+            await fs_extra_1.default.writeFile(jobPath, yaml_1.default.stringify(job));
+            logger_1.logger.success(`Batch job imported: ${jobPath}`);
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_BATCH_IMPORT_FAILED', 'Failed to import batch job', { file, options }, true);
+        }
+    }
+    /**
+     * Helper methods for batch job operations
+     */
+    async loadBatchJob(file) {
+        if (!(await fs_extra_1.default.pathExists(file))) {
+            throw new Error(`Batch job file not found: ${file}`);
+        }
+        const content = await fs_extra_1.default.readFile(file, 'utf8');
+        const ext = path_1.default.extname(file).toLowerCase();
+        if (ext === '.yaml' || ext === '.yml') {
+            return yaml_1.default.parse(content);
+        }
+        else if (ext === '.json') {
+            return JSON.parse(content);
+        }
+        else {
+            throw new Error(`Unsupported file format: ${ext}`);
+        }
+    }
+    async validateJobStructure(job) {
+        const errors = [];
+        if (!job.name) {
+            errors.push('Job name is required');
+        }
+        if (!job.commands || job.commands.length === 0) {
+            errors.push('At least one command is required');
+        }
+        else {
+            job.commands.forEach((cmd, index) => {
+                if (!cmd.command) {
+                    errors.push(`Command ${index + 1} is missing command property`);
+                }
+            });
+        }
+        return { valid: errors.length === 0, errors };
+    }
+    /**
+     * Regex for valid variable names in batch templates.
+     */
+    static VALID_VARIABLE_NAME = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+    async processJobVariables(job, vars) {
+        let variables = {};
+        if (vars) {
+            try {
+                // Try parsing as JSON first
+                variables = JSON.parse(vars);
+            }
+            catch {
+                // Parse as key=value pairs
+                vars.split(',').forEach(pair => {
+                    const eqIndex = pair.indexOf('=');
+                    if (eqIndex > 0) {
+                        const key = pair.slice(0, eqIndex).trim();
+                        const value = pair.slice(eqIndex + 1).trim();
+                        if (key) {
+                            variables[key] = value;
+                        }
+                    }
+                });
+            }
+        }
+        // Validate variable names to prevent regex injection
+        for (const key of Object.keys(variables)) {
+            if (!BatchCommands.VALID_VARIABLE_NAME.test(key)) {
+                throw new Error(`Invalid variable name "${key}": must match [a-zA-Z_][a-zA-Z0-9_]*`);
+            }
+        }
+        // SECURITY: Instead of replacing {{var}} in a JSON-stringified string
+        // (which allows JSON structure breakout via quotes in values), we walk
+        // the job structure and only replace in string leaf values. Values are
+        // JSON-escaped to prevent structure injection.
+        const processedJob = JSON.parse(JSON.stringify(job));
+        const replaceVarsInString = (str) => {
+            let result = str;
+            for (const [key, value] of Object.entries(variables)) {
+                const placeholder = `{{${key}}}`;
+                // Only replace exact placeholder matches, not regex patterns
+                while (result.includes(placeholder)) {
+                    result = result.replace(placeholder, String(value));
+                }
+            }
+            return result;
+        };
+        // Walk commands and replace variables in string fields only
+        processedJob.commands = processedJob.commands.map(cmd => ({
+            ...cmd,
+            command: replaceVarsInString(cmd.command),
+            args: cmd.args?.map(arg => replaceVarsInString(arg)),
+            condition: cmd.condition ? replaceVarsInString(cmd.condition) : undefined,
+        }));
+        if (processedJob.description) {
+            processedJob.description = replaceVarsInString(processedJob.description);
+        }
+        return processedJob;
+    }
+    async showDryRun(job) {
+        console.log(chalk_1.default.blue('\nDry Run - Commands to be executed:'));
+        console.log(chalk_1.default.gray('='.repeat(50)));
+        job.commands.forEach((cmd, index) => {
+            console.log(`${index + 1}. ${chalk_1.default.cyan(cmd.command)}`);
+            if (cmd.args) {
+                console.log(`   Args: ${cmd.args.join(' ')}`);
+            }
+            if (cmd.condition) {
+                console.log(`   Condition: ${cmd.condition}`);
+            }
+            if (cmd.retry) {
+                console.log(`   Retry: ${cmd.retry} times`);
+            }
+            if (cmd.timeout) {
+                console.log(`   Timeout: ${cmd.timeout}ms`);
+            }
+            console.log();
+        });
+        console.log(chalk_1.default.gray('='.repeat(50)));
+        console.log(`Total commands: ${job.commands.length}`);
+        console.log(`Parallel execution: ${job.parallel ? 'Yes' : 'No'}`);
+        console.log(`Continue on error: ${job.continueOnError ? 'Yes' : 'No'}`);
+    }
+    async executeBatchJob(job, _jobId, _options) {
+        const tasks = job.commands.map((cmd, _index) => ({
+            title: cmd.command,
+            task: async () => {
+                await this.executeCommand(cmd, _options);
+            },
+            retry: cmd.retry || 0,
+            timeout: cmd.timeout,
+        }));
+        const listr = new listr2_1.Listr(tasks, {
+            concurrent: job.parallel || _options.parallel,
+            exitOnError: !(job.continueOnError || _options.continueOnError),
+            rendererOptions: {
+                showSubtasks: true,
+            },
+        });
+        await listr.run();
+    }
+    /**
+     * Shell metacharacters that indicate injection attempts.
+     * These characters have special meaning in sh/bash and must not
+     * appear in arguments passed to spawn().
+     */
+    static SHELL_METACHARACTERS = /[;&|`$(){}[\]<>!#~*?\n\r\\]/;
+    /**
+     * Tokenize a command string into [binary, ...args] without shell
+     * interpretation. Supports simple single/double quoting.
+     */
+    tokenizeCommand(command) {
+        const tokens = [];
+        let current = '';
+        let inSingle = false;
+        let inDouble = false;
+        for (let i = 0; i < command.length; i++) {
+            const ch = command[i];
+            if (inSingle) {
+                if (ch === "'") {
+                    inSingle = false;
+                }
+                else {
+                    current += ch;
+                }
+                continue;
+            }
+            if (inDouble) {
+                if (ch === '"') {
+                    inDouble = false;
+                }
+                else {
+                    current += ch;
+                }
+                continue;
+            }
+            if (ch === "'") {
+                inSingle = true;
+                continue;
+            }
+            if (ch === '"') {
+                inDouble = true;
+                continue;
+            }
+            if (ch === ' ' || ch === '\t') {
+                if (current.length > 0) {
+                    tokens.push(current);
+                    current = '';
+                }
+                continue;
+            }
+            current += ch;
+        }
+        if (current.length > 0) {
+            tokens.push(current);
+        }
+        if (inSingle || inDouble) {
+            throw new Error(`Unterminated quote in command: ${command}`);
+        }
+        return tokens;
+    }
+    /**
+     * Validate that no argument contains shell metacharacters.
+     * This is a defense-in-depth measure: since we never use shell: true,
+     * metacharacters would be treated literally, but their presence strongly
+     * suggests a command injection attempt.
+     */
+    validateArgs(args) {
+        for (const arg of args) {
+            if (BatchCommands.SHELL_METACHARACTERS.test(arg)) {
+                throw new Error(`Argument contains shell metacharacters (possible injection): "${arg}"`);
+            }
+        }
+    }
+    async executeCommand(cmd, _options) {
+        // Check condition if specified
+        if (cmd.condition && !(await this.evaluateCondition(cmd.condition))) {
+            logger_1.logger.debug(`Skipping command due to condition: ${cmd.condition}`);
+            return;
+        }
+        const { spawn } = await Promise.resolve().then(() => tslib_1.__importStar(require('child_process')));
+        // Tokenize the command string into binary + args without shell
+        // interpretation. This prevents command injection via shell metacharacters
+        // like ; | & ` $() etc.
+        const tokens = this.tokenizeCommand(cmd.command);
+        if (tokens.length === 0) {
+            throw new Error('Empty command');
+        }
+        const [command, ...parsedArgs] = tokens;
+        const finalArgs = cmd.args ? [...parsedArgs, ...cmd.args] : parsedArgs;
+        // Validate arguments for shell metacharacters as defense-in-depth
+        this.validateArgs(finalArgs);
+        return new Promise((resolve, reject) => {
+            // SECURITY: No shell: true. The command is executed directly via
+            // execvp(), so shell metacharacters in arguments are treated as
+            // literal characters rather than being interpreted by a shell.
+            const child = spawn(command ?? 'echo', finalArgs, {
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            let output = '';
+            let error = '';
+            child.stdout?.on('data', (data) => {
+                output += data.toString();
+            });
+            child.stderr?.on('data', (data) => {
+                error += data.toString();
+            });
+            child.on('exit', (code) => {
+                if (code === 0) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`Command failed with exit code ${code}: ${error}`));
+                }
+            });
+            // Handle timeout
+            if (cmd.timeout) {
+                setTimeout(() => {
+                    child.kill();
+                    reject(new Error(`Command timed out after ${cmd.timeout}ms`));
+                }, cmd.timeout);
+            }
+        });
+    }
+    async evaluateCondition(condition) {
+        // Simple condition evaluation
+        // In a real implementation, this would be more sophisticated
+        switch (condition) {
+            case 'always':
+                return true;
+            case 'never':
+                return false;
+            default:
+                // Could evaluate file existence, environment variables, etc.
+                return true;
+        }
+    }
+    async createInteractiveBatchJob(name) {
+        const inquirer = await Promise.resolve().then(() => tslib_1.__importStar(require('inquirer')));
+        const answers = await inquirer.default.prompt([
+            {
+                type: 'input',
+                name: 'description',
+                message: 'Job description:',
+            },
+            {
+                type: 'confirm',
+                name: 'parallel',
+                message: 'Run commands in parallel?',
+                default: false,
+            },
+            {
+                type: 'confirm',
+                name: 'continueOnError',
+                message: 'Continue on command failure?',
+                default: false,
+            },
+        ]);
+        const commands = [];
+        let addMore = true;
+        while (addMore) {
+            const cmdAnswers = await inquirer.default.prompt([
+                {
+                    type: 'input',
+                    name: 'command',
+                    message: 'Command:',
+                    validate: input => input.length > 0 || 'Command is required',
+                },
+                {
+                    type: 'input',
+                    name: 'condition',
+                    message: 'Condition (optional):',
+                },
+                {
+                    type: 'number',
+                    name: 'retry',
+                    message: 'Retry count:',
+                    default: 0,
+                },
+                {
+                    type: 'confirm',
+                    name: 'addMore',
+                    message: 'Add another command?',
+                    default: true,
+                },
+            ]);
+            commands.push({
+                command: cmdAnswers.command,
+                condition: cmdAnswers.condition || undefined,
+                retry: cmdAnswers.retry || undefined,
+            });
+            addMore = cmdAnswers.addMore;
+        }
+        return {
+            name,
+            description: answers.description,
+            commands,
+            parallel: answers.parallel,
+            continueOnError: answers.continueOnError,
+        };
+    }
+    createBasicBatchJob(name, options) {
+        const commands = options.commands
+            ? options.commands
+                .split(',')
+                .map((cmd) => ({ command: cmd.trim() }))
+            : [];
+        return {
+            name,
+            description: `Batch job: ${name}`,
+            commands,
+            parallel: false,
+            continueOnError: false,
+        };
+    }
+    async createJobFromTemplate(name, template) {
+        // Load template and create job
+        const templatePath = path_1.default.join(__dirname, '../../templates/batch', `${template}.yaml`);
+        if (await fs_extra_1.default.pathExists(templatePath)) {
+            const templateJob = await this.loadBatchJob(templatePath);
+            return { ...templateJob, name };
+        }
+        throw new Error(`Template not found: ${template}`);
+    }
+    // Format conversion methods
+    convertToShellScript(job) {
+        let script = `#!/bin/bash\n# Generated from batch job: ${job.name}\n\n`;
+        if (job.description) {
+            script += `# ${job.description}\n\n`;
+        }
+        script += 'set -e\n\n'; // Exit on error unless continueOnError is true
+        job.commands.forEach(cmd => {
+            script += `echo "Executing: ${cmd.command}"\n`;
+            script += `${cmd.command}\n\n`;
+        });
+        return script;
+    }
+    convertToDockerfile(job) {
+        let dockerfile = `# Generated from batch job: ${job.name}\n`;
+        dockerfile += 'FROM node:18-alpine\n\n';
+        if (job.description) {
+            dockerfile += `# ${job.description}\n`;
+        }
+        dockerfile += 'WORKDIR /app\n';
+        dockerfile += 'COPY . .\n\n';
+        job.commands.forEach(cmd => {
+            dockerfile += `RUN ${cmd.command}\n`;
+        });
+        return dockerfile;
+    }
+    async importFromJSON(file, name) {
+        const content = await fs_extra_1.default.readJson(file);
+        return { ...content, name: name || content.name };
+    }
+    async importFromShell(file, name) {
+        const content = await fs_extra_1.default.readFile(file, 'utf8');
+        const commands = content
+            .split('\n')
+            .filter(line => line.trim() && !line.startsWith('#'))
+            .map(line => ({ command: line.trim() }));
+        return {
+            name: name || path_1.default.basename(file, path_1.default.extname(file)),
+            description: `Imported from shell script: ${file}`,
+            commands,
+        };
+    }
+    async importFromPackageScripts(file, name) {
+        const packageJson = await fs_extra_1.default.readJson(file);
+        const scripts = packageJson.scripts || {};
+        const commands = Object.entries(scripts).map(([script, command]) => ({
+            command: `npm run ${script}`,
+            args: [],
+            condition: undefined,
+        }));
+        return {
+            name: name || 'package-scripts',
+            description: 'Imported from package.json scripts',
+            commands,
+        };
+    }
+    async listTemplates() {
+        const templatesDir = path_1.default.join(__dirname, '../../templates/batch');
+        if (await fs_extra_1.default.pathExists(templatesDir)) {
+            const templates = await fs_extra_1.default.readdir(templatesDir);
+            const yamlTemplates = templates.filter(t => t.endsWith('.yaml') || t.endsWith('.yml'));
+            if (yamlTemplates.length > 0) {
+                logger_1.logger.info('Available templates:');
+                yamlTemplates.forEach(template => {
+                    console.log(`  - ${path_1.default.basename(template, path_1.default.extname(template))}`);
+                });
+            }
+            else {
+                logger_1.logger.info('No templates available');
+            }
+        }
+        else {
+            logger_1.logger.info('No templates directory found');
+        }
+    }
+    async createTemplate(name, options) {
+        logger_1.logger.info(`Creating template: ${name}`);
+        if (options.from) {
+            const job = await this.loadBatchJob(options.from);
+            const templatePath = path_1.default.join(__dirname, '../../templates/batch', `${name}.yaml`);
+            await fs_extra_1.default.ensureDir(path_1.default.dirname(templatePath));
+            await fs_extra_1.default.writeFile(templatePath, yaml_1.default.stringify(job));
+            logger_1.logger.success(`Template created: ${templatePath}`);
+        }
+        else {
+            logger_1.logger.info('Template creation from scratch not yet implemented');
+        }
+    }
+}
+exports.BatchCommands = BatchCommands;
+//# sourceMappingURL=batch.js.map