jm2 0.1.0

package/src/cli/commands/flush.js

@@ -0,0 +1,132 @@
+/**
+ * JM2 flush command
+ * Cleans up completed one-time jobs, old logs, and old history entries
+ */
+
+import { send } from '../../ipc/client.js';
+import { MessageType } from '../../ipc/protocol.js';
+import { printSuccess, printError, printInfo, printWarning } from '../utils/output.js';
+import { isDaemonRunning } from '../../daemon/index.js';
+import { confirmDestructive } from '../utils/prompts.js';
+import { parseDuration } from '../../utils/duration.js';
+
+/**
+ * Execute the flush command
+ * @param {object} options - Command options
+ * @returns {Promise<number>} Exit code
+ */
+export async function flushCommand(options = {}) {
+  // Check if daemon is running
+  if (!isDaemonRunning()) {
+    printError('Daemon is not running. Start it with: jm2 start');
+    return 1;
+  }
+
+  // Build a summary of what will be flushed
+  const actions = [];
+  if (options.jobs !== false) {
+    actions.push('completed one-time jobs');
+  }
+  if (options.logs) {
+    actions.push(`logs older than ${options.logs}`);
+  }
+  if (options.history) {
+    actions.push(`history entries older than ${options.history}`);
+  }
+  if (options.all) {
+    actions.length = 0;
+    actions.push('completed one-time jobs, all logs, and all history');
+  }
+
+  if (actions.length === 0) {
+    actions.push('completed one-time jobs (default)');
+  }
+
+  // Confirm destructive action unless --force is used
+  const action = `flush ${actions.join(', ')}`;
+  const confirmed = await confirmDestructive(action, options.force);
+  if (!confirmed) {
+    printInfo('Operation cancelled');
+    return 0;
+  }
+
+  try {
+    // Build flush request
+    const flushRequest = {
+      type: MessageType.FLUSH,
+      jobs: options.jobs !== false && !options.all,
+      logs: options.logs || options.all || false,
+      logsAge: options.logs || null,
+      history: options.history || options.all || false,
+      historyAge: options.history || null,
+    };
+
+    // Parse duration options if provided
+    if (flushRequest.logsAge && !options.all) {
+      const duration = parseDuration(flushRequest.logsAge);
+      if (duration === null) {
+        printError(`Invalid duration for --logs: ${options.logs}`);
+        return 1;
+      }
+      flushRequest.logsAgeMs = duration;
+    }
+
+    if (flushRequest.historyAge && !options.all) {
+      const duration = parseDuration(flushRequest.historyAge);
+      if (duration === null) {
+        printError(`Invalid duration for --history: ${options.history}`);
+        return 1;
+      }
+      flushRequest.historyAgeMs = duration;
+    }
+
+    const response = await send(flushRequest);
+
+    if (response.type === MessageType.ERROR) {
+      printError(response.message);
+      return 1;
+    }
+
+    if (response.type === MessageType.FLUSH_RESULT) {
+      // Report results
+      let hasResults = false;
+
+      if (response.jobsRemoved > 0) {
+        printSuccess(`Removed ${response.jobsRemoved} completed one-time job(s)`);
+        hasResults = true;
+      } else if (options.jobs !== false && !options.all) {
+        printInfo('No completed one-time jobs to remove');
+      }
+
+      if (options.logs || options.all) {
+        if (response.logsRemoved > 0) {
+          printSuccess(`Removed ${response.logsRemoved} log file(s)`);
+          hasResults = true;
+        } else {
+          printInfo('No log files to remove');
+        }
+      }
+
+      if (options.history || options.all) {
+        if (response.historyRemoved > 0) {
+          printSuccess(`Removed ${response.historyRemoved} history entries(s)`);
+          hasResults = true;
+        } else {
+          printInfo('No history entries to remove');
+        }
+      }
+
+      if (!hasResults && options.jobs === false) {
+        printInfo('Nothing to flush');
+      }
+
+      return 0;
+    }
+
+    printError('Unexpected response from daemon');
+    return 1;
+  } catch (error) {
+    printError(`Failed to flush: ${error.message}`);
+    return 1;
+  }
+}

package/src/cli/commands/history.js

@@ -0,0 +1,179 @@
+/**
+ * JM2 history command
+ * Show execution history for jobs
+ */
+
+import { send } from '../../ipc/client.js';
+import { MessageType } from '../../ipc/protocol.js';
+import {
+  printSuccess,
+  printError,
+  printInfo,
+  printHeader,
+  formatDate,
+  formatDuration,
+} from '../utils/output.js';
+import { isDaemonRunning } from '../../daemon/index.js';
+import { getHistory } from '../../core/storage.js';
+import chalk from 'chalk';
+import Table from 'cli-table3';
+
+/**
+ * Execute the history command
+ * @param {string} jobRef - Job ID or name (optional)
+ * @param {object} options - Command options
+ * @returns {Promise<number>} Exit code
+ */
+export async function historyCommand(jobRef, options = {}) {
+  // Check if daemon is running
+  if (!isDaemonRunning()) {
+    printError('Daemon is not running. Start it with: jm2 start');
+    return 1;
+  }
+
+  try {
+    let history;
+    let jobName = null;
+
+    if (jobRef) {
+      // Get specific job's history
+      const jobId = parseInt(jobRef, 10);
+      const message = isNaN(jobId)
+        ? { type: MessageType.JOB_GET, jobName: jobRef }
+        : { type: MessageType.JOB_GET, jobId };
+
+      const response = await send(message);
+
+      if (response.type === MessageType.ERROR) {
+        printError(response.message);
+        return 1;
+      }
+
+      if (response.type !== MessageType.JOB_GET_RESULT || !response.job) {
+        printError(`Job not found: ${jobRef}`);
+        return 1;
+      }
+
+      const job = response.job;
+      jobName = job.name || String(job.id);
+
+      // Get history and filter by job ID
+      const allHistory = getHistory();
+      history = allHistory.filter(entry => entry.jobId === job.id);
+    } else {
+      // Get all history
+      history = getHistory();
+    }
+
+    // Apply filters
+    if (options.failed) {
+      history = history.filter(entry => entry.exitCode !== 0 || entry.status === 'failed');
+    }
+
+    if (options.success) {
+      history = history.filter(entry => entry.exitCode === 0 || entry.status === 'success');
+    }
+
+    // Sort by timestamp (newest first)
+    history.sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp));
+
+    // Apply limit
+    const limit = options.limit || 20;
+    if (limit > 0) {
+      history = history.slice(0, limit);
+    }
+
+    // Display results
+    if (history.length === 0) {
+      if (jobName) {
+        printInfo(`No execution history found for job: ${jobName}`);
+      } else {
+        printInfo('No execution history found');
+      }
+      return 0;
+    }
+
+    if (jobName) {
+      printHeader(`Execution History for: ${jobName}`);
+    } else {
+      printHeader('Execution History');
+    }
+
+    printHistoryTable(history, !jobName);
+
+    // Print summary
+    console.log();
+    console.log(`Showing ${chalk.bold(history.length)} entries`);
+
+    return 0;
+  } catch (error) {
+    printError(`Failed to get history: ${error.message}`);
+    return 1;
+  }
+}
+
+/**
+ * Print history as a formatted table
+ * @param {Array} history - Array of history entries
+ * @param {boolean} showJobName - Whether to show job name column
+ */
+function printHistoryTable(history, showJobName = false) {
+  const headers = [
+    chalk.bold('Time'),
+    chalk.bold('Status'),
+    chalk.bold('Duration'),
+    chalk.bold('Exit'),
+  ];
+
+  if (showJobName) {
+    headers.splice(1, 0, chalk.bold('Job'));
+  }
+
+  const colWidths = showJobName 
+    ? [20, 15, 10, 12, 8]
+    : [20, 10, 12, 8];
+
+  const table = new Table({
+    head: headers,
+    colWidths,
+    wordWrap: true,
+  });
+
+  for (const entry of history) {
+    const row = [
+      formatDate(entry.timestamp),
+      formatStatus(entry.status, entry.exitCode),
+      entry.duration ? formatDuration(entry.duration) : '-',
+      entry.exitCode !== undefined ? entry.exitCode : '-',
+    ];
+
+    if (showJobName) {
+      row.splice(1, 0, entry.jobName || `Job ${entry.jobId}`);
+    }
+
+    table.push(row);
+  }
+
+  console.log(table.toString());
+}
+
+/**
+ * Format status with color
+ * @param {string} status - Status string
+ * @param {number} exitCode - Exit code
+ * @returns {string} Colorized status
+ */
+function formatStatus(status, exitCode) {
+  if (status === 'timeout') {
+    return chalk.yellow('timeout');
+  }
+  if (exitCode === 0 || status === 'success') {
+    return chalk.green('success');
+  }
+  if (status === 'failed' || (exitCode !== undefined && exitCode !== 0)) {
+    return chalk.red('failed');
+  }
+  return chalk.gray(status || 'unknown');
+}
+
+export default { historyCommand };

package/src/cli/commands/import.js

@@ -0,0 +1,180 @@
+/**
+ * JM2 import command
+ * Imports job configurations from a JSON file
+ */
+
+import { readFileSync, existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { getJobs, saveJobs, jobNameExists, getNextJobId } from '../../core/storage.js';
+import { validateJob, createJob } from '../../core/job.js';
+import { printSuccess, printError, printInfo, printWarning } from '../utils/output.js';
+import { confirmDestructive } from '../utils/prompts.js';
+import { send } from '../../ipc/client.js';
+import { MessageType } from '../../ipc/protocol.js';
+
+/**
+ * Generate a unique name by appending a number suffix
+ * @param {string} baseName - Base name to start with
+ * @param {Set<string>} existingNames - Set of existing names
+ * @returns {string} Unique name
+ */
+function makeUniqueName(baseName, existingNames) {
+  if (!existingNames.has(baseName)) {
+    return baseName;
+  }
+  let suffix = 2;
+  let newName;
+  do {
+    newName = `${baseName}-${suffix}`;
+    suffix++;
+  } while (existingNames.has(newName));
+  return newName;
+}
+
+/**
+ * Execute the import command
+ * @param {string} file - Path to the import file
+ * @param {object} options - Command options
+ * @returns {Promise<number>} Exit code
+ */
+export async function importCommand(file, options = {}) {
+  try {
+    // Resolve file path
+    const filePath = resolve(file);
+
+    // Check if file exists
+    if (!existsSync(filePath)) {
+      printError(`Import file not found: ${filePath}`);
+      return 1;
+    }
+
+    // Read and parse the import file
+    let importData;
+    try {
+      const content = readFileSync(filePath, 'utf8');
+      importData = JSON.parse(content);
+    } catch (error) {
+      printError(`Failed to parse import file: ${error.message}`);
+      return 1;
+    }
+
+    // Validate import data structure
+    if (!importData.jobs || !Array.isArray(importData.jobs)) {
+      printError('Invalid import file format: missing or invalid "jobs" array');
+      return 1;
+    }
+
+    if (importData.jobs.length === 0) {
+      printInfo('No jobs found in import file');
+      return 0;
+    }
+
+    // Get existing jobs
+    const existingJobs = getJobs();
+    const existingNames = new Set(existingJobs.map(j => j.name).filter(Boolean));
+    
+    // Get starting ID for new jobs (imported jobs get new IDs)
+    let nextId = getNextJobId();
+
+    // Prepare jobs for import - track original name to final name mapping
+    const jobsToImport = [];
+    const nameMapping = []; // { original, final, renamed }
+    const skippedJobs = [];
+    const invalidJobs = [];
+
+    for (const jobData of importData.jobs) {
+      // Validate job structure
+      const validation = validateJob(jobData);
+      if (!validation.valid) {
+        invalidJobs.push({ name: jobData.name || 'unnamed', errors: validation.errors });
+        continue;
+      }
+
+      // Determine the final name
+      const originalName = jobData.name || 'unnamed';
+      let finalName = jobData.name;
+
+      if (existingNames.has(finalName)) {
+        if (options.skip) {
+          skippedJobs.push(finalName);
+          continue;
+        }
+        // Generate a unique name
+        finalName = makeUniqueName(finalName, existingNames);
+      }
+
+      // Create the job object with a new ID
+      const job = createJob({
+        ...jobData,
+        id: nextId++, // Assign a new ID
+        name: finalName,
+        // Reset runtime state
+        status: jobData.status === 'paused' ? 'paused' : 'active',
+        runCount: 0,
+        lastRun: null,
+        lastResult: null,
+        nextRun: null,
+        retryCount: 0,
+      });
+
+      jobsToImport.push(job);
+      existingNames.add(finalName);
+      nameMapping.push({
+        original: originalName,
+        final: finalName,
+        renamed: originalName !== finalName
+      });
+    }
+
+    // Report issues
+    if (invalidJobs.length > 0) {
+      printWarning(`Skipping ${invalidJobs.length} invalid job(s):`);
+      for (const { name, errors } of invalidJobs) {
+        printWarning(`  - ${name}: ${errors.join(', ')}`);
+      }
+    }
+
+    if (skippedJobs.length > 0) {
+      printWarning(`Skipping ${skippedJobs.length} existing job(s): ${skippedJobs.join(', ')}`);
+    }
+
+    if (jobsToImport.length === 0) {
+      printInfo('No jobs to import');
+      return 0;
+    }
+
+    // Confirm import unless --force is used
+    const action = `import ${jobsToImport.length} job(s)`;
+    const confirmed = await confirmDestructive(action, options.force);
+    if (!confirmed) {
+      printInfo('Import cancelled');
+      return 0;
+    }
+
+    // Import the jobs
+    const allJobs = [...existingJobs, ...jobsToImport];
+    saveJobs(allJobs);
+
+    // Notify daemon to reload jobs
+    try {
+      await send({ type: MessageType.RELOAD_JOBS });
+    } catch (error) {
+      printWarning(`Failed to notify daemon to reload jobs: ${error.message}`);
+    }
+
+    // Report results
+    printSuccess(`Successfully imported ${jobsToImport.length} job(s)`);
+    for (const mapping of nameMapping) {
+      if (mapping.renamed) {
+        printInfo(`  - ${mapping.original} → ${mapping.final} (renamed)`);
+      } else {
+        printInfo(`  - ${mapping.final}`);
+      }
+    }
+
+    return 0;
+  } catch (error) {
+    printError(`Failed to import jobs: ${error.message}`);
+    return 1;
+  }
+}

package/src/cli/commands/list.js

@@ -0,0 +1,174 @@
+/**
+ * JM2 list command
+ * Lists all jobs with optional filtering
+ */
+
+import { send } from '../../ipc/client.js';
+import { MessageType } from '../../ipc/protocol.js';
+import { 
+  printSuccess, 
+  printError, 
+  printInfo,
+  printHeader,
+  createJobTable,
+  colorizeStatus,
+  formatDate,
+  formatRelativeTime,
+} from '../utils/output.js';
+import { isDaemonRunning } from '../../daemon/index.js';
+import chalk from 'chalk';
+
+/**
+ * Execute the list command
+ * @param {object} options - Command options
+ * @returns {Promise<number>} Exit code
+ */
+export async function listCommand(options = {}) {
+  // Check if daemon is running
+  if (!isDaemonRunning()) {
+    printError('Daemon is not running. Start it with: jm2 start');
+    return 1;
+  }
+
+  try {
+    // Build filters
+    const filters = {};
+    
+    if (options.tag) {
+      filters.tag = options.tag;
+    }
+    
+    if (options.status) {
+      filters.status = options.status;
+    }
+    
+    if (options.type) {
+      filters.type = options.type;
+    }
+
+    // Request jobs from daemon
+    const response = await send({
+      type: MessageType.JOB_LIST,
+      filters: Object.keys(filters).length > 0 ? filters : undefined,
+    });
+
+    if (response.type === MessageType.ERROR) {
+      printError(response.message);
+      return 1;
+    }
+
+    if (response.type === MessageType.JOB_LIST_RESULT) {
+      const jobs = response.jobs || [];
+      
+      if (jobs.length === 0) {
+        printInfo('No jobs found');
+        return 0;
+      }
+
+      // Print header
+      const filterDesc = [];
+      if (options.tag) filterDesc.push(`tag: ${options.tag}`);
+      if (options.status) filterDesc.push(`status: ${options.status}`);
+      if (options.type) filterDesc.push(`type: ${options.type}`);
+      
+      if (filterDesc.length > 0) {
+        printHeader(`Jobs (${filterDesc.join(', ')})`);
+      } else {
+        printHeader('Jobs');
+      }
+
+      if (options.verbose) {
+        // Verbose output - detailed list
+        for (const job of jobs) {
+          printJobDetails(job);
+        }
+      } else {
+        // Table output
+        const table = createJobTable();
+        
+        for (const job of jobs) {
+          const schedule = job.cron 
+            ? chalk.gray(job.cron) 
+            : job.runAt 
+              ? formatRelativeTime(job.runAt)
+              : chalk.gray('Manual');
+          
+          table.push([
+            job.id,
+            job.name || chalk.gray('-'),
+            colorizeStatus(job.status),
+            schedule,
+            formatRelativeTime(job.nextRun),
+            formatRelativeTime(job.lastRun),
+          ]);
+        }
+        
+        console.log(table.toString());
+      }
+      
+      console.log();
+      printInfo(`${jobs.length} job${jobs.length === 1 ? '' : 's'} found`);
+      
+      return 0;
+    }
+
+    printError('Unexpected response from daemon');
+    return 1;
+  } catch (error) {
+    printError(`Failed to list jobs: ${error.message}`);
+    return 1;
+  }
+}
+
+/**
+ * Print detailed job information
+ * @param {object} job - Job object
+ */
+function printJobDetails(job) {
+  console.log(chalk.bold(`\nJob: ${job.name || job.id}`));
+  console.log(`  ID: ${job.id}`);
+  console.log(`  Status: ${colorizeStatus(job.status)}`);
+  console.log(`  Command: ${chalk.gray(job.command)}`);
+  
+  if (job.cron) {
+    console.log(`  Schedule: ${chalk.gray(job.cron)} (cron)`);
+  } else if (job.runAt) {
+    console.log(`  Schedule: ${formatDate(job.runAt)} (one-time)`);
+  }
+  
+  if (job.nextRun) {
+    console.log(`  Next Run: ${formatRelativeTime(job.nextRun)}`);
+  }
+  
+  if (job.lastRun) {
+    console.log(`  Last Run: ${formatRelativeTime(job.lastRun)}`);
+    if (job.lastResult) {
+      const resultColor = job.lastResult === 'success' ? chalk.green : chalk.red;
+      console.log(`  Last Result: ${resultColor(job.lastResult)}`);
+    }
+  }
+  
+  if (job.tags && job.tags.length > 0) {
+    console.log(`  Tags: ${job.tags.map(t => chalk.cyan(t)).join(', ')}`);
+  }
+  
+  if (job.cwd) {
+    console.log(`  Working Dir: ${chalk.gray(job.cwd)}`);
+  }
+  
+  if (job.timeout) {
+    console.log(`  Timeout: ${chalk.gray(job.timeout)}ms`);
+  }
+  
+  if (job.retry > 0) {
+    console.log(`  Retry: ${chalk.gray(job.retry)} attempts`);
+  }
+  
+  if (job.runCount > 0) {
+    console.log(`  Run Count: ${chalk.gray(job.runCount)}`);
+  }
+  
+  console.log(`  Created: ${formatDate(job.createdAt)}`);
+}
+
+export default listCommand;