jm2 0.1.0

package/src/cli/index.js

@@ -0,0 +1,274 @@
+/**
+ * JM2 CLI
+ * Command-line interface using Commander.js
+ */
+
+import { Command } from 'commander';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+import { startCommand } from './commands/start.js';
+import { stopCommand } from './commands/stop.js';
+import { restartCommand } from './commands/restart.js';
+import { statusCommand } from './commands/status.js';
+import { addCommand } from './commands/add.js';
+import { listCommand } from './commands/list.js';
+import { showCommand } from './commands/show.js';
+import { removeCommand } from './commands/remove.js';
+import { pauseCommand } from './commands/pause.js';
+import { resumeCommand } from './commands/resume.js';
+import { runCommand } from './commands/run.js';
+import { editCommand } from './commands/edit.js';
+import { configCommand } from './commands/config.js';
+import { logsCommand } from './commands/logs.js';
+import { historyCommand } from './commands/history.js';
+import { flushCommand } from './commands/flush.js';
+import { exportCommand } from './commands/export.js';
+import { importCommand } from './commands/import.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Collect multiple option values
+ * @param {string} value - Current value
+ * @param {Array} previous - Previous values
+ * @returns {Array} Combined values
+ */
+function collect(value, previous) {
+  return previous.concat([value]);
+}
+
+/**
+ * Get package version from package.json
+ * @returns {string} Package version
+ */
+function getVersion() {
+  try {
+    const packagePath = join(__dirname, '../../package.json');
+    const packageJson = JSON.parse(readFileSync(packagePath, 'utf8'));
+    return packageJson.version;
+  } catch {
+    return '0.1.0';
+  }
+}
+
+/**
+ * Run the CLI
+ */
+export async function runCli() {
+  const program = new Command();
+
+  program
+    .name('jm2')
+    .description('JM2 (Job Manager 2) - A simple yet powerful job scheduler')
+    .version(getVersion(), '-v, --version', 'Display version number');
+
+  // Daemon management commands
+  program
+    .command('start')
+    .description('Start the JM2 daemon')
+    .option('-f, --foreground', 'Run in foreground (don\'t daemonize)', false)
+    .action(async (options) => {
+      const exitCode = await startCommand(options);
+      process.exit(exitCode);
+    });
+
+  program
+    .command('stop')
+    .description('Stop the JM2 daemon')
+    .action(async () => {
+      const exitCode = await stopCommand();
+      process.exit(exitCode);
+    });
+
+  program
+    .command('restart')
+    .description('Restart the JM2 daemon')
+    .action(async () => {
+      const exitCode = await restartCommand();
+      process.exit(exitCode);
+    });
+
+  program
+    .command('status')
+    .description('Show daemon status and statistics')
+    .action(async () => {
+      const exitCode = await statusCommand();
+      process.exit(exitCode);
+    });
+
+  // Job management commands
+  program
+    .command('add [command]')
+    .description('Add a new job')
+    .option('-n, --name <name>', 'Job name (unique identifier)')
+    .option('-c, --cron <expression>', 'Cron expression for recurring jobs')
+    .option('-a, --at <datetime>', 'Run once at specific datetime (ISO 8601, "today 10:00", "tomorrow 14:30")')
+    .option('-i, --delay <duration>', 'Run once after duration (e.g., "30m", "2h", "1d")')
+    .option('-t, --tag <tag>', 'Add a tag (can be used multiple times)', collect, [])
+    .option('--cwd <path>', 'Working directory for job execution')
+    .option('-e, --env <env>', 'Environment variable (format: KEY=value, can be used multiple times)', collect, [])
+    .option('--timeout <duration>', 'Timeout for job execution (e.g., "30m", "2h")')
+    .option('--retry <count>', 'Number of retry attempts on failure', '0')
+    .option('--examples', 'Show common examples of jm2 add')
+    .action(async (command, options) => {
+      const exitCode = await addCommand(command, options);
+      process.exit(exitCode);
+    });
+
+  program
+    .command('list')
+    .description('List all jobs')
+    .option('-t, --tag <tag>', 'Filter by tag')
+    .option('-s, --status <status>', 'Filter by status (active, paused, completed, failed)')
+    .option('--type <type>', 'Filter by type (cron, once)')
+    .option('-v, --verbose', 'Show detailed information', false)
+    .action(async (options) => {
+      const exitCode = await listCommand(options);
+      process.exit(exitCode);
+    });
+
+  program
+    .command('show <job>')
+    .description('Show detailed information about a job')
+    .action(async (job) => {
+      const exitCode = await showCommand(job);
+      process.exit(exitCode);
+    });
+
+  program
+    .command('remove <jobs...>')
+    .description('Remove one or more jobs')
+    .option('-f, --force', 'Force removal without confirmation', false)
+    .action(async (jobs, options) => {
+      const exitCode = await removeCommand(jobs, options);
+      process.exit(exitCode);
+    });
+
+  program
+    .command('pause <jobs...>')
+    .description('Pause one or more jobs')
+    .action(async (jobs) => {
+      const exitCode = await pauseCommand(jobs);
+      process.exit(exitCode);
+    });
+
+  program
+    .command('resume <jobs...>')
+    .description('Resume one or more paused jobs')
+    .action(async (jobs) => {
+      const exitCode = await resumeCommand(jobs);
+      process.exit(exitCode);
+    });
+
+  program
+    .command('run <job>')
+    .description('Run a job manually')
+    .option('-w, --wait', 'Wait for job to complete and show output', false)
+    .action(async (job, options) => {
+      const exitCode = await runCommand(job, options);
+      process.exit(exitCode);
+    });
+
+  program
+    .command('edit <job>')
+    .description('Edit an existing job')
+    .option('--command <command>', 'New command to execute')
+    .option('-n, --name <name>', 'New job name')
+    .option('-c, --cron <expression>', 'New cron expression')
+    .option('-a, --at <datetime>', 'New datetime to run once (replaces cron)')
+    .option('-i, --delay <duration>', 'New relative time to run once (replaces cron)')
+    .option('--cwd <path>', 'New working directory')
+    .option('-e, --env <env>', 'Set environment variable (format: KEY=value, can be used multiple times)', collect, [])
+    .option('--timeout <duration>', 'New timeout for job execution')
+    .option('--retry <count>', 'New retry count on failure')
+    .option('-t, --tag <tag>', 'Set tags (replaces all existing tags, can be used multiple times)', collect, [])
+    .action(async (job, options) => {
+      const exitCode = await editCommand(job, options);
+      process.exit(exitCode);
+    });
+
+  // Configuration command
+  program
+    .command('config')
+    .description('View or modify configuration settings')
+    .option('-s, --show', 'Show all configuration (default)')
+    .option('--log-max-size <size>', 'Set maximum log file size (e.g., 10mb, 50MB)')
+    .option('--log-max-files <count>', 'Set maximum number of log files to keep')
+    .option('--level <level>', 'Set log level (DEBUG, INFO, WARN, ERROR)')
+    .option('--max-concurrent <count>', 'Set maximum concurrent job executions')
+    .option('--reset', 'Reset configuration to defaults')
+    .action(async (options) => {
+      const exitCode = await configCommand(options);
+      process.exit(exitCode);
+    });
+
+  // Logs command
+  program
+    .command('logs <job>')
+    .description('View job execution logs')
+    .option('-n, --lines <count>', 'Number of lines to show (default: 50)', '50')
+    .option('-f, --follow', 'Follow log output in real-time', false)
+    .option('--since <time>', 'Show logs since time (e.g., "1h", "30m", "2026-01-31")')
+    .option('--until <time>', 'Show logs until time')
+    .option('--timestamps', 'Show timestamps', true)
+    .option('--no-timestamps', 'Hide timestamps')
+    .action(async (job, options) => {
+      const exitCode = await logsCommand(job, options);
+      process.exit(exitCode);
+    });
+
+  // History command
+  program
+    .command('history [job]')
+    .description('Show execution history for a job or all jobs')
+    .option('-f, --failed', 'Show only failed executions', false)
+    .option('-s, --success', 'Show only successful executions', false)
+    .option('-l, --limit <count>', 'Maximum number of entries to show (default: 20)', '20')
+    .action(async (job, options) => {
+      const exitCode = await historyCommand(job, options);
+      process.exit(exitCode);
+    });
+
+  // Flush command
+  program
+    .command('flush')
+    .description('Clean up completed one-time jobs, old logs, and history')
+    .option('--no-jobs', 'Skip removing completed one-time jobs')
+    .option('--logs <duration>', 'Remove logs older than duration (e.g., "7d", "24h")')
+    .option('--history <duration>', 'Remove history older than duration (e.g., "30d")')
+    .option('-a, --all', 'Remove all logs and history (equivalent to --logs --history with no age limit)')
+    .option('--force', 'Skip confirmation prompt', false)
+    .action(async (options) => {
+      const exitCode = await flushCommand(options);
+      process.exit(exitCode);
+    });
+
+  // Export command
+  program
+    .command('export')
+    .description('Export job configurations to a JSON file')
+    .option('-o, --output <file>', 'Output file path (default: jm2-export.json)', 'jm2-export.json')
+    .action(async (options) => {
+      const exitCode = await exportCommand(options);
+      process.exit(exitCode);
+    });
+
+  // Import command
+  program
+    .command('import <file>')
+    .description('Import job configurations from a JSON file')
+    .option('-s, --skip', 'Skip jobs with conflicting names instead of renaming', false)
+    .option('-f, --force', 'Skip confirmation prompt', false)
+    .action(async (file, options) => {
+      const exitCode = await importCommand(file, options);
+      process.exit(exitCode);
+    });
+
+  // Parse command line arguments
+  await program.parseAsync();
+}
+
+export default { runCli };

package/src/cli/utils/output.js

@@ -0,0 +1,267 @@
+/**
+ * Output formatting utilities for JM2 CLI
+ * Provides table formatting, colors, and other output helpers
+ */
+
+import chalk from 'chalk';
+import Table from 'cli-table3';
+
+/**
+ * Format a duration in milliseconds to human-readable string
+ * @param {number} ms - Duration in milliseconds
+ * @returns {string} Formatted duration
+ */
+export function formatDuration(ms) {
+  if (ms < 1000) {
+    return `${ms}ms`;
+  }
+  
+  const seconds = Math.floor(ms / 1000);
+  if (seconds < 60) {
+    return `${seconds}s`;
+  }
+  
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  if (minutes < 60) {
+    return remainingSeconds > 0 
+      ? `${minutes}m ${remainingSeconds}s`
+      : `${minutes}m`;
+  }
+  
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  if (hours < 24) {
+    return remainingMinutes > 0
+      ? `${hours}h ${remainingMinutes}m`
+      : `${hours}h`;
+  }
+  
+  const days = Math.floor(hours / 24);
+  const remainingHours = hours % 24;
+  return remainingHours > 0
+    ? `${days}d ${remainingHours}h`
+    : `${days}d`;
+}
+
+/**
+ * Format uptime from a start date
+ * @param {Date|string} startDate - When the process started
+ * @returns {string} Formatted uptime
+ */
+export function formatUptime(startDate) {
+  const start = new Date(startDate);
+  const now = new Date();
+  const ms = now - start;
+  return formatDuration(ms);
+}
+
+/**
+ * Format a date for display
+ * @param {Date|string} date - Date to format
+ * @returns {string} Formatted date
+ */
+export function formatDate(date) {
+  if (!date) return chalk.gray('Never');
+  const d = new Date(date);
+  return d.toLocaleString();
+}
+
+/**
+ * Format a relative time (e.g., "2 minutes ago", "in 5 minutes")
+ * @param {Date|string} date - Date to format
+ * @returns {string} Relative time string
+ */
+export function formatRelativeTime(date) {
+  if (!date) return chalk.gray('Never');
+  
+  const d = new Date(date);
+  const now = new Date();
+  const diffMs = d - now;
+  const absMs = Math.abs(diffMs);
+  
+  const suffix = diffMs < 0 ? 'ago' : 'in';
+  const duration = formatDuration(absMs);
+  
+  if (diffMs < 0) {
+    return chalk.gray(`${duration} ago`);
+  } else {
+    return chalk.cyan(`in ${duration}`);
+  }
+}
+
+/**
+ * Colorize a job status
+ * @param {string} status - Job status
+ * @returns {string} Colorized status
+ */
+export function colorizeStatus(status) {
+  switch (status) {
+    case 'active':
+      return chalk.green('active');
+    case 'paused':
+      return chalk.yellow('paused');
+    case 'completed':
+      return chalk.blue('completed');
+    case 'failed':
+      return chalk.red('failed');
+    case 'running':
+      return chalk.cyan('running');
+    default:
+      return chalk.gray(status);
+  }
+}
+
+/**
+ * Colorize daemon status
+ * @param {boolean} running - Whether daemon is running
+ * @returns {string} Colorized status
+ */
+export function colorizeDaemonStatus(running) {
+  return running 
+    ? chalk.green('Running')
+    : chalk.red('Stopped');
+}
+
+/**
+ * Create a table for job listing
+ * @returns {Table} CLI table instance
+ */
+export function createJobTable() {
+  return new Table({
+    head: [
+      chalk.bold('ID'),
+      chalk.bold('Name'),
+      chalk.bold('Status'),
+      chalk.bold('Schedule'),
+      chalk.bold('Next Run'),
+      chalk.bold('Last Run'),
+    ],
+    colWidths: [6, 20, 12, 20, 20, 20],
+    wordWrap: true,
+  });
+}
+
+/**
+ * Create a table for daemon status
+ * @returns {Table} CLI table instance
+ */
+export function createStatusTable() {
+  return new Table({
+    colWidths: [20, 40],
+    style: {
+      head: [],
+      border: [],
+    },
+  });
+}
+
+/**
+ * Print a success message
+ * @param {string} message - Message to print
+ */
+export function printSuccess(message) {
+  console.log(chalk.green('✓'), message);
+}
+
+/**
+ * Print an error message
+ * @param {string} message - Message to print
+ */
+export function printError(message) {
+  console.error(chalk.red('✗'), message);
+}
+
+/**
+ * Print a warning message
+ * @param {string} message - Message to print
+ */
+export function printWarning(message) {
+  console.warn(chalk.yellow('⚠'), message);
+}
+
+/**
+ * Print an info message
+ * @param {string} message - Message to print
+ */
+export function printInfo(message) {
+  console.log(chalk.blue('ℹ'), message);
+}
+
+/**
+ * Print a section header
+ * @param {string} title - Section title
+ */
+export function printHeader(title) {
+  console.log();
+  console.log(chalk.bold.underline(title));
+  console.log();
+}
+
+/**
+ * Print a section header (alias for printHeader)
+ * @param {string} title - Section title
+ */
+export function printSection(title) {
+  console.log();
+  console.log(chalk.bold.underline(title));
+  console.log();
+}
+
+/**
+ * Print a key-value pair
+ * @param {string} key - Key label
+ * @param {*} value - Value to display
+ */
+export function printKeyValue(key, value) {
+  console.log(`  ${chalk.cyan(key)}: ${value}`);
+}
+
+/**
+ * Print an empty line
+ */
+export function printEmptyLine() {
+  console.log();
+}
+
+/**
+ * Format job schedule for display
+ * @param {object} job - Job object
+ * @returns {string} Formatted schedule
+ */
+export function formatJobSchedule(job) {
+  if (job.cron) {
+    return chalk.gray(job.cron);
+  } else if (job.runAt) {
+    return chalk.gray(`at ${formatDate(job.runAt)}`);
+  } else {
+    return chalk.gray('Manual only');
+  }
+}
+
+export default {
+  formatDuration,
+  formatUptime,
+  formatDate,
+  formatRelativeTime,
+  colorizeStatus,
+  colorizeDaemonStatus,
+  createJobTable,
+  createStatusTable,
+  printSuccess,
+  printError,
+  printWarning,
+  printInfo,
+  printHeader,
+  printEmptyLine,
+  formatJobSchedule,
+  printSection,
+  printKeyValue,
+  // Aliases for convenience
+  success: printSuccess,
+  error: printError,
+  warning: printWarning,
+  info: printInfo,
+  section: printSection,
+  keyValue: printKeyValue,
+};

package/src/cli/utils/prompts.js

@@ -0,0 +1,56 @@
+/**
+ * Prompt utilities for JM2 CLI
+ * Provides confirmation prompts and user interaction helpers
+ */
+
+import readline from 'node:readline';
+
+/**
+ * Ask for confirmation
+ * @param {string} message - Confirmation message
+ * @param {boolean} [defaultValue=false] - Default value if user just presses enter
+ * @returns {Promise<boolean>} True if confirmed
+ */
+export async function confirm(message, defaultValue = false) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  const defaultPrompt = defaultValue ? 'Y/n' : 'y/N';
+
+  return new Promise((resolve) => {
+    rl.question(`${message} [${defaultPrompt}] `, (answer) => {
+      rl.close();
+
+      const trimmed = answer.trim().toLowerCase();
+
+      if (trimmed === '') {
+        resolve(defaultValue);
+      } else if (trimmed === 'y' || trimmed === 'yes') {
+        resolve(true);
+      } else {
+        resolve(false);
+      }
+    });
+  });
+}
+
+/**
+ * Confirm destructive action
+ * @param {string} action - Description of the action
+ * @param {boolean} [force=false] - Skip confirmation if true
+ * @returns {Promise<boolean>} True if confirmed or forced
+ */
+export async function confirmDestructive(action, force = false) {
+  if (force) {
+    return true;
+  }
+
+  return await confirm(`Are you sure you want to ${action}?`, false);
+}
+
+export default {
+  confirm,
+  confirmDestructive,
+};