jm2 0.1.0

package/src/cli/commands/add.js

@@ -0,0 +1,206 @@
+/**
+ * JM2 add command
+ * Adds a new job to the scheduler
+ */
+
+import { send } from '../../ipc/client.js';
+import { MessageType } from '../../ipc/protocol.js';
+import { printSuccess, printError, printInfo } from '../utils/output.js';
+import { isDaemonRunning } from '../../daemon/index.js';
+import { parseDateTime, parseRunIn } from '../../utils/datetime.js';
+
+/**
+ * Print common examples of JM2 add command
+ */
+function printExamples() {
+  console.log(`
+Common examples of JM2 add:
+
+  # Run a command once at a specific time
+  jm2 add "backup.sh" --at "today 14:30"
+  jm2 add "backup.sh" --at "tomorrow 09:00"
+  jm2 add "backup.sh" --at "2025-12-25 08:00"
+
+  # Run a command after a delay
+  jm2 add "cleanup.sh" --delay "30m"
+  jm2 add "cleanup.sh" --delay "2h"
+  jm2 add "cleanup.sh" --delay "1d"
+
+  # Run a command on a schedule (cron)
+  jm2 add "daily-report.sh" --cron "0 9 * * *"
+  jm2 add "weekly-backup.sh" --cron "0 0 * * 0"
+  jm2 add "monthly-task.sh" --cron "0 0 1 * *"
+
+  # Add a job with a name
+  jm2 add "backup.sh" --name "daily-backup" --cron "0 2 * * *"
+
+  # Add a job with tags
+  jm2 add "deploy.sh" --tag "production" --tag "deployment" --delay "5m"
+
+  # Add a job with environment variables
+  jm2 add "script.sh" --env "NODE_ENV=production" --env "DEBUG=true" --cron "0 */6 * * *"
+
+  # Add a job with a working directory
+  jm2 add "npm run build" --cwd /path/to/project --at "today 15:00"
+
+  # Add a job with timeout and retry
+  jm2 add "long-running.sh" --timeout "2h" --retry 3 --cron "0 3 * * *"
+`);
+}
+
+/**
+ * Execute the add command
+ * @param {string} command - Command to execute
+ * @param {object} options - Command options
+ * @returns {Promise<number>} Exit code
+ */
+export async function addCommand(command, options = {}) {
+  // Handle --examples flag
+  if (options.examples) {
+    printExamples();
+    return 0;
+  }
+
+  // Check if daemon is running
+  if (!isDaemonRunning()) {
+    printError('Daemon is not running. Start it with: jm2 start');
+    return 1;
+  }
+
+  if (!command || command.trim() === '') {
+    printError('Command is required');
+    return 1;
+  }
+
+  try {
+    // Build job data
+    const jobData = {
+      command: command.trim(),
+    };
+
+    // Handle scheduling options
+    const { cron, at, delay } = options;
+    
+    if (cron && at) {
+      printError('Cannot specify both --cron and --at');
+      return 1;
+    }
+    
+    if (cron && delay) {
+      printError('Cannot specify both --cron and --delay');
+      return 1;
+    }
+    
+    if (at && delay) {
+      printError('Cannot specify both --at and --delay');
+      return 1;
+    }
+
+    // Parse scheduling
+    if (cron) {
+      jobData.cron = cron;
+    } else if (at) {
+      try {
+        const date = parseDateTime(at);
+        jobData.runAt = date.toISOString();
+      } catch (error) {
+        printError(`Invalid datetime: ${error.message}`);
+        return 1;
+      }
+    } else if (delay) {
+      try {
+        const date = parseRunIn(delay);
+        jobData.runAt = date.toISOString();
+      } catch (error) {
+        printError(`Invalid duration: ${error.message}`);
+        return 1;
+      }
+    } else {
+      printError('Scheduling option required: --cron, --at, or --delay');
+      return 1;
+    }
+
+    // Optional fields
+    if (options.name) {
+      // Check if name is a pure number (would conflict with job ID access)
+      if (/^\d+$/.test(options.name)) {
+        printError('Job name cannot be a pure number (conflicts with job ID)');
+        return 1;
+      }
+      jobData.name = options.name;
+    }
+
+    if (options.tag) {
+      // Handle multiple tags
+      const tags = Array.isArray(options.tag) 
+        ? options.tag 
+        : [options.tag];
+      jobData.tags = tags;
+    }
+
+    if (options.cwd) {
+      jobData.cwd = options.cwd;
+    }
+
+    if (options.env) {
+      // Parse env options (format: KEY=value)
+      const envVars = Array.isArray(options.env) 
+        ? options.env 
+        : [options.env];
+      jobData.env = {};
+      for (const envVar of envVars) {
+        const [key, ...valueParts] = envVar.split('=');
+        if (key && valueParts.length > 0) {
+          jobData.env[key] = valueParts.join('=');
+        }
+      }
+    }
+
+    if (options.timeout) {
+      jobData.timeout = options.timeout;
+    }
+
+    if (options.retry !== undefined) {
+      jobData.retry = parseInt(options.retry, 10);
+      if (isNaN(jobData.retry) || jobData.retry < 0) {
+        printError('Retry must be a non-negative integer');
+        return 1;
+      }
+    }
+
+    // Send to daemon
+    printInfo('Adding job...');
+    
+    const response = await send({
+      type: MessageType.JOB_ADD,
+      jobData,
+    });
+
+    if (response.type === MessageType.ERROR) {
+      printError(response.message);
+      return 1;
+    }
+
+    if (response.type === MessageType.JOB_ADDED && response.job) {
+      const job = response.job;
+      printSuccess(`Job added: ${job.name || job.id}`);
+      
+      if (job.cron) {
+        printInfo(`Schedule: ${job.cron}`);
+      } else if (job.runAt) {
+        const runDate = new Date(job.runAt);
+        printInfo(`Scheduled for: ${runDate.toLocaleString()}`);
+      }
+      
+      return 0;
+    }
+
+    printError('Unexpected response from daemon');
+    return 1;
+  } catch (error) {
+    printError(`Failed to add job: ${error.message}`);
+    return 1;
+  }
+}
+
+export default addCommand;

package/src/cli/commands/config.js

@@ -0,0 +1,212 @@
+/**
+ * Config command for JM2
+ * View and modify configuration settings
+ */
+
+import { getConfig, saveConfig, setConfigValue, getConfigValue, validateConfig, DEFAULT_CONFIG } from '../../core/config.js';
+import output from '../utils/output.js';
+
+/**
+ * Parse a value to the appropriate type based on the config key
+ * @param {string} key - Config key
+ * @param {string} value - Value as string
+ * @returns {*} Parsed value
+ */
+function parseConfigValue(key, value) {
+  // Handle numeric values
+  if (key.includes('max') || key.includes('Count') || key.includes('Days') || key.includes('Size')) {
+    const num = parseInt(value, 10);
+    if (isNaN(num)) {
+      throw new Error(`Invalid numeric value: ${value}`);
+    }
+    return num;
+  }
+  
+  // Handle boolean values
+  if (value.toLowerCase() === 'true') return true;
+  if (value.toLowerCase() === 'false') return false;
+  
+  // Return as string
+  return value;
+}
+
+/**
+ * Format a config value for display
+ * @param {*} value - Config value
+ * @returns {string} Formatted value
+ */
+function formatValue(value) {
+  if (value === null) return 'null';
+  if (value === undefined) return 'undefined';
+  if (typeof value === 'boolean') return value ? 'true' : 'false';
+  if (typeof value === 'string') return value;
+  if (typeof value === 'number') {
+    // Format large numbers (bytes) as human readable
+    if (value >= 1024 * 1024) {
+      return `${value} (${(value / 1024 / 1024).toFixed(1)}MB)`;
+    }
+    if (value >= 1024) {
+      return `${value} (${(value / 1024).toFixed(1)}KB)`;
+    }
+    return String(value);
+  }
+  if (Array.isArray(value)) return value.join(', ');
+  if (typeof value === 'object') return JSON.stringify(value);
+  return String(value);
+}
+
+/**
+ * Show all configuration settings
+ * @param {object} config - Config object
+ */
+function showAllConfig(config) {
+  output.section('Daemon Settings');
+  output.keyValue('Max Concurrent', formatValue(config.daemon?.maxConcurrent));
+  output.keyValue('Shell', formatValue(config.daemon?.shell));
+  output.keyValue('Shell Args', formatValue(config.daemon?.shellArgs));
+  
+  output.section('Job Defaults');
+  output.keyValue('Default Timeout', formatValue(config.jobs?.defaultTimeout));
+  output.keyValue('Default Retry', formatValue(config.jobs?.defaultRetry));
+  output.keyValue('Default CWD', formatValue(config.jobs?.defaultCwd));
+  
+  output.section('Logging Settings');
+  output.keyValue('Log Level', formatValue(config.logging?.level));
+  output.keyValue('Max File Size', formatValue(config.logging?.maxFileSize));
+  output.keyValue('Max Files', formatValue(config.logging?.maxFiles));
+  
+  output.section('History Settings');
+  output.keyValue('Max Entries Per Job', formatValue(config.history?.maxEntriesPerJob));
+  output.keyValue('Retention Days', formatValue(config.history?.retentionDays));
+  
+  output.section('Cleanup Settings');
+  output.keyValue('Completed Job Retention (days)', formatValue(config.cleanup?.completedJobRetentionDays));
+  output.keyValue('Log Retention (days)', formatValue(config.cleanup?.logRetentionDays));
+}
+
+/**
+ * Config command implementation
+ * @param {object} options - Command options
+ * @returns {number} Exit code
+ */
+export async function configCommand(options) {
+  try {
+    const config = getConfig();
+    
+    // Show all config if no specific option provided
+    if (options.show || Object.keys(options).length === 0 || 
+        (!options.logMaxSize && !options.logMaxFiles && !options.level && 
+         !options.maxConcurrent && !options.reset)) {
+      showAllConfig(config);
+      return 0;
+    }
+    
+    // Handle reset
+    if (options.reset) {
+      saveConfig({});
+      output.success('Configuration reset to defaults');
+      return 0;
+    }
+    
+    let changes = [];
+    
+    // Handle log-max-size
+    if (options.logMaxSize !== undefined) {
+      const size = parseSizeOption(options.logMaxSize);
+      if (size === null) {
+        output.error(`Invalid size format: ${options.logMaxSize}`);
+        output.info('Use formats like: 10mb, 50MB, 100kb, 1gb');
+        return 1;
+      }
+      setConfigValue('logging.maxFileSize', size);
+      changes.push(`Log max file size: ${formatValue(size)}`);
+    }
+    
+    // Handle log-max-files
+    if (options.logMaxFiles !== undefined) {
+      const count = parseInt(options.logMaxFiles, 10);
+      if (isNaN(count) || count < 1) {
+        output.error(`Invalid file count: ${options.logMaxFiles}`);
+        output.info('Must be a positive number');
+        return 1;
+      }
+      setConfigValue('logging.maxFiles', count);
+      changes.push(`Log max files: ${count}`);
+    }
+    
+    // Handle log level
+    if (options.level !== undefined) {
+      const validLevels = ['DEBUG', 'INFO', 'WARN', 'ERROR'];
+      const level = options.level.toUpperCase();
+      if (!validLevels.includes(level)) {
+        output.error(`Invalid log level: ${options.level}`);
+        output.info(`Valid levels: ${validLevels.join(', ')}`);
+        return 1;
+      }
+      setConfigValue('logging.level', level);
+      changes.push(`Log level: ${level}`);
+    }
+    
+    // Handle max concurrent
+    if (options.maxConcurrent !== undefined) {
+      const count = parseInt(options.maxConcurrent, 10);
+      if (isNaN(count) || count < 1) {
+        output.error(`Invalid concurrent count: ${options.maxConcurrent}`);
+        output.info('Must be a positive number');
+        return 1;
+      }
+      setConfigValue('daemon.maxConcurrent', count);
+      changes.push(`Max concurrent jobs: ${count}`);
+    }
+    
+    // Validate the new config
+    const newConfig = getConfig();
+    const validation = validateConfig(newConfig);
+    if (!validation.valid) {
+      output.error('Configuration validation failed:');
+      for (const error of validation.errors) {
+        output.error(`  - ${error}`);
+      }
+      return 1;
+    }
+    
+    // Show changes
+    if (changes.length > 0) {
+      output.success('Configuration updated:');
+      for (const change of changes) {
+        output.info(`  • ${change}`);
+      }
+    }
+    
+    return 0;
+  } catch (error) {
+    output.error(`Config command failed: ${error.message}`);
+    return 1;
+  }
+}
+
+/**
+ * Parse a size option (e.g., "10mb", "50MB")
+ * @param {string} value - Size string
+ * @returns {number|null} Size in bytes or null if invalid
+ */
+function parseSizeOption(value) {
+  const match = String(value).trim().toLowerCase().match(/^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb)?$/);
+  if (!match) {
+    return null;
+  }
+  
+  const num = parseFloat(match[1]);
+  const unit = match[2] || 'b';
+  
+  const multipliers = {
+    'b': 1,
+    'kb': 1024,
+    'mb': 1024 * 1024,
+    'gb': 1024 * 1024 * 1024,
+  };
+  
+  return Math.floor(num * multipliers[unit]);
+}
+
+export default { configCommand };

package/src/cli/commands/edit.js

@@ -0,0 +1,198 @@
+/**
+ * JM2 edit command
+ * Edit an existing job's properties
+ */
+
+import { send } from '../../ipc/client.js';
+import { MessageType } from '../../ipc/protocol.js';
+import { printSuccess, printError, printInfo } from '../utils/output.js';
+import { isDaemonRunning } from '../../daemon/index.js';
+import { parseDateTime, parseRunIn } from '../../utils/datetime.js';
+
+/**
+ * Execute the edit command
+ * @param {string} jobRef - Job ID or name
+ * @param {object} options - Command options
+ * @returns {Promise<number>} Exit code
+ */
+export async function editCommand(jobRef, options = {}) {
+  // Check if daemon is running
+  if (!isDaemonRunning()) {
+    printError('Daemon is not running. Start it with: jm2 start');
+    return 1;
+  }
+
+  if (!jobRef || jobRef.trim() === '') {
+    printError('Job ID or name is required');
+    return 1;
+  }
+
+  // Build updates object from options
+  const updates = {};
+
+  // Validate that at least one option is provided
+  const hasUpdates =
+    options.command !== undefined ||
+    options.name !== undefined ||
+    options.cron !== undefined ||
+    options.at !== undefined ||
+    options.delay !== undefined ||
+    options.cwd !== undefined ||
+    options.env !== undefined ||
+    options.env !== undefined ||
+    options.timeout !== undefined ||
+    options.retry !== undefined ||
+    options.tag !== undefined;
+
+  if (!hasUpdates) {
+    printError('No changes specified. Use options like --command, --cron, --name, etc.');
+    return 1;
+  }
+
+  // Handle mutually exclusive scheduling options
+  const hasCron = options.cron !== undefined;
+  const hasAt = options.at !== undefined;
+  const hasDelay = options.delay !== undefined;
+
+  if (hasCron && hasAt) {
+    printError('Cannot specify both --cron and --at');
+    return 1;
+  }
+  if (hasCron && hasDelay) {
+    printError('Cannot specify both --cron and --delay');
+    return 1;
+  }
+  if (hasAt && hasDelay) {
+    printError('Cannot specify both --at and --delay');
+    return 1;
+  }
+
+  // Apply updates
+  if (options.command !== undefined) {
+    if (!options.command.trim()) {
+      printError('Command cannot be empty');
+      return 1;
+    }
+    updates.command = options.command.trim();
+  }
+
+  if (options.name !== undefined) {
+    if (!options.name.trim()) {
+      printError('Name cannot be empty');
+      return 1;
+    }
+    updates.name = options.name.trim();
+  }
+
+  // Handle scheduling updates
+  if (hasCron) {
+    updates.cron = options.cron;
+    updates.runAt = null; // Clear runAt when switching to cron
+  } else if (hasAt) {
+    try {
+      const date = parseDateTime(options.at);
+      updates.runAt = date.toISOString();
+      updates.cron = null; // Clear cron when switching to runAt
+    } catch (error) {
+      printError(`Invalid datetime: ${error.message}`);
+      return 1;
+    }
+  } else if (hasDelay) {
+    try {
+      const date = parseRunIn(options.delay);
+      updates.runAt = date.toISOString();
+      updates.cron = null; // Clear cron when switching to runAt
+    } catch (error) {
+      printError(`Invalid duration: ${error.message}`);
+      return 1;
+    }
+  }
+
+  if (options.cwd !== undefined) {
+    updates.cwd = options.cwd || null;
+  }
+
+  if (options.env !== undefined) {
+    // Parse env options (format: KEY=value)
+    const envVars = Array.isArray(options.env)
+      ? options.env
+      : options.env ? [options.env] : [];
+    
+    if (envVars.length > 0) {
+      updates.env = {};
+      for (const envVar of envVars) {
+        const [key, ...valueParts] = envVar.split('=');
+        if (key && valueParts.length > 0) {
+          updates.env[key] = valueParts.join('=');
+        }
+      }
+    }
+  }
+
+  if (options.timeout !== undefined) {
+    updates.timeout = options.timeout || null;
+  }
+
+  if (options.retry !== undefined) {
+    const retry = parseInt(options.retry, 10);
+    if (isNaN(retry) || retry < 0) {
+      printError('Retry must be a non-negative integer');
+      return 1;
+    }
+    updates.retry = retry;
+  }
+
+  if (options.tag !== undefined) {
+    // Handle multiple tags
+    const tags = Array.isArray(options.tag)
+      ? options.tag
+      : options.tag ? [options.tag] : [];
+    if (tags.length > 0) {
+      updates.tags = tags;
+    }
+  }
+
+  try {
+    // Determine if jobRef is an ID (numeric) or name
+    const jobId = parseInt(jobRef, 10);
+    const message = isNaN(jobId)
+      ? { type: MessageType.JOB_UPDATE, jobName: jobRef, updates }
+      : { type: MessageType.JOB_UPDATE, jobId, updates };
+
+    printInfo(`Updating job: ${jobRef}...`);
+
+    const response = await send(message);
+
+    if (response.type === MessageType.ERROR) {
+      printError(response.message);
+      return 1;
+    }
+
+    if (response.type === MessageType.JOB_UPDATED) {
+      const job = response.job;
+
+      if (!job) {
+        printError(`Job not found: ${jobRef}`);
+        return 1;
+      }
+
+      printSuccess(`Job updated: ${job.name || job.id}`);
+
+      // Show what was updated
+      const updatedFields = Object.keys(updates);
+      if (updatedFields.length > 0) {
+        printInfo(`Updated fields: ${updatedFields.join(', ')}`);
+      }
+
+      return 0;
+    }
+
+    printError('Unexpected response from daemon');
+    return 1;
+  } catch (error) {
+    printError(`Failed to update job: ${error.message}`);
+    return 1;
+  }
+}
+
+export default { editCommand };

package/src/cli/commands/export.js

@@ -0,0 +1,61 @@
+/**
+ * JM2 export command
+ * Exports job configurations to a JSON file
+ */
+
+import { writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { getJobs } from '../../core/storage.js';
+import { printSuccess, printError, printInfo } from '../utils/output.js';
+
+/**
+ * Execute the export command
+ * @param {object} options - Command options
+ * @returns {Promise<number>} Exit code
+ */
+export async function exportCommand(options = {}) {
+  try {
+    // Get all jobs from storage
+    const jobs = getJobs();
+
+    if (jobs.length === 0) {
+      printInfo('No jobs to export');
+      return 0;
+    }
+
+    // Prepare export data
+    const exportData = {
+      version: '1.0',
+      exportedAt: new Date().toISOString(),
+      jobs: jobs.map(job => ({
+        // Export all job fields except runtime state
+        // Generate a name for unnamed jobs using job ID
+        name: job.name || `job-${job.id}`,
+        command: job.command,
+        type: job.type,
+        cron: job.cron,
+        runAt: job.runAt,
+        status: job.status,
+        tags: job.tags,
+        env: job.env,
+        cwd: job.cwd,
+        timeout: job.timeout,
+        retry: job.retry,
+        createdAt: job.createdAt,
+        updatedAt: job.updatedAt,
+      })),
+    };
+
+    // Determine output path
+    const outputPath = resolve(options.output || 'jm2-export.json');
+
+    // Write to file
+    writeFileSync(outputPath, JSON.stringify(exportData, null, 2), 'utf8');
+
+    printSuccess(`Exported ${jobs.length} job(s) to ${outputPath}`);
+    return 0;
+  } catch (error) {
+    printError(`Failed to export jobs: ${error.message}`);
+    return 1;
+  }
+}