jm2 0.1.0

package/src/cli/commands/resume.js

@@ -0,0 +1,96 @@
+/**
+ * JM2 resume command
+ * Resumes one or more paused jobs
+ */
+
+import { send } from '../../ipc/client.js';
+import { MessageType } from '../../ipc/protocol.js';
+import { printSuccess, printError, printWarning } from '../utils/output.js';
+import { isDaemonRunning } from '../../daemon/index.js';
+
+/**
+ * Execute the resume command
+ * @param {string|string[]} jobRefs - Job ID(s) or name(s)
+ * @param {object} options - Command options
+ * @returns {Promise<number>} Exit code
+ */
+export async function resumeCommand(jobRefs, options = {}) {
+  // Check if daemon is running
+  if (!isDaemonRunning()) {
+    printError('Daemon is not running. Start it with: jm2 start');
+    return 1;
+  }
+
+  // Normalize jobRefs to array
+  const refs = Array.isArray(jobRefs) ? jobRefs : [jobRefs];
+
+  if (refs.length === 0 || (refs.length === 1 && !refs[0])) {
+    printError('Job ID or name is required');
+    return 1;
+  }
+
+  let successCount = 0;
+  let failCount = 0;
+
+  for (const jobRef of refs) {
+    const result = await resumeSingleJob(jobRef);
+    if (result) {
+      successCount++;
+    } else {
+      failCount++;
+    }
+  }
+
+  // Summary
+  if (successCount > 0) {
+    printSuccess(`Resumed ${successCount} job(s)`);
+  }
+
+  if (failCount > 0) {
+    printError(`Failed to resume ${failCount} job(s)`);
+    return 1;
+  }
+
+  return 0;
+}
+
+/**
+ * Resume a single job
+ * @param {string} jobRef - Job ID or name
+ * @returns {Promise<boolean>} True if successful
+ */
+async function resumeSingleJob(jobRef) {
+  try {
+    // Determine if jobRef is an ID (numeric) or name
+    const jobId = parseInt(jobRef, 10);
+    const message = isNaN(jobId)
+      ? { type: MessageType.JOB_RESUME, jobName: jobRef }
+      : { type: MessageType.JOB_RESUME, jobId };
+
+    const response = await send(message);
+
+    if (response.type === MessageType.ERROR) {
+      printError(`${jobRef}: ${response.message}`);
+      return false;
+    }
+
+    if (response.type === MessageType.JOB_RESUMED) {
+      if (response.job) {
+        const name = response.job.name || response.job.id;
+        printSuccess(`Resumed: ${name}`);
+        return true;
+      } else {
+        printWarning(`Job not found: ${jobRef}`);
+        return false;
+      }
+    }
+
+    printError(`${jobRef}: Unexpected response from daemon`);
+    return false;
+  } catch (error) {
+    printError(`${jobRef}: ${error.message}`);
+    return false;
+  }
+}
+
+export default { resumeCommand };

package/src/cli/commands/run.js

@@ -0,0 +1,115 @@
+/**
+ * JM2 run command
+ * Manually execute a job immediately
+ */
+
+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';
+
+/**
+ * Execute the run command
+ * @param {string} jobRef - Job ID or name
+ * @param {object} options - Command options
+ * @returns {Promise<number>} Exit code
+ */
+export async function runCommand(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;
+  }
+
+  try {
+    // Determine if jobRef is an ID (numeric) or name
+    const jobId = parseInt(jobRef, 10);
+    const message = isNaN(jobId)
+      ? { type: MessageType.JOB_RUN, jobName: jobRef, wait: options.wait }
+      : { type: MessageType.JOB_RUN, jobId, wait: options.wait };
+
+    printInfo(`Running job: ${jobRef}...`);
+
+    const response = await send(message);
+
+    if (response.type === MessageType.ERROR) {
+      printError(response.message);
+      return 1;
+    }
+
+    if (response.type === MessageType.JOB_RUN_RESULT) {
+      const result = response.result;
+
+      if (result.error) {
+        printError(`Job execution failed: ${result.error}`);
+        return 1;
+      }
+
+      if (options.wait) {
+        // Display execution results
+        if (result.status === 'success') {
+          printSuccess('Job completed successfully');
+          if (result.stdout) {
+            console.log('\n--- stdout ---');
+            console.log(result.stdout);
+          }
+          if (result.stderr) {
+            console.log('\n--- stderr ---');
+            console.log(result.stderr);
+          }
+          console.log(`\nExit code: ${result.exitCode || 0}`);
+          console.log(`Duration: ${formatDuration(result.duration || 0)}`);
+        } else if (result.status === 'timeout') {
+          printError('Job timed out');
+          return 1;
+        } else {
+          printError(`Job failed with status: ${result.status}`);
+          if (result.stdout) {
+            console.log('\n--- stdout ---');
+            console.log(result.stdout);
+          }
+          if (result.stderr) {
+            console.log('\n--- stderr ---');
+            console.log(result.stderr);
+          }
+          return 1;
+        }
+      } else {
+        printSuccess(`Job queued for execution (ID: ${result.jobId || jobRef})`);
+        printInfo('Use --wait to wait for completion and see output');
+      }
+
+      return 0;
+    }
+
+    printError('Unexpected response from daemon');
+    return 1;
+  } catch (error) {
+    printError(`Failed to run job: ${error.message}`);
+    return 1;
+  }
+}
+
+/**
+ * Format duration in milliseconds to human-readable string
+ * @param {number} ms - Duration in milliseconds
+ * @returns {string} Formatted duration
+ */
+function formatDuration(ms) {
+  if (ms < 1000) {
+    return `${ms}ms`;
+  }
+  if (ms < 60000) {
+    return `${(ms / 1000).toFixed(2)}s`;
+  }
+  const minutes = Math.floor(ms / 60000);
+  const seconds = ((ms % 60000) / 1000).toFixed(1);
+  return `${minutes}m ${seconds}s`;
+}
+
+export default { runCommand };

package/src/cli/commands/show.js

@@ -0,0 +1,159 @@
+/**
+ * JM2 show command
+ * Shows detailed information about a job
+ */
+
+import { send } from '../../ipc/client.js';
+import { MessageType } from '../../ipc/protocol.js';
+import {
+  printSuccess,
+  printError,
+  printInfo,
+  printHeader,
+  colorizeStatus,
+  formatDate,
+  formatRelativeTime,
+  formatJobSchedule,
+} from '../utils/output.js';
+import { isDaemonRunning } from '../../daemon/index.js';
+import { getJobLogFile } from '../../utils/paths.js';
+import chalk from 'chalk';
+
+/**
+ * Execute the show command
+ * @param {string} jobRef - Job ID or name
+ * @param {object} options - Command options
+ * @returns {Promise<number>} Exit code
+ */
+export async function showCommand(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;
+  }
+
+  try {
+    // Determine if jobRef is an ID (numeric) or name
+    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) {
+      const job = response.job;
+
+      if (!job) {
+        printError(`Job not found: ${jobRef}`);
+        return 1;
+      }
+
+      printJobDetails(job);
+      return 0;
+    }
+
+    printError('Unexpected response from daemon');
+    return 1;
+  } catch (error) {
+    printError(`Failed to get job: ${error.message}`);
+    return 1;
+  }
+}
+
+/**
+ * Print detailed job information
+ * @param {object} job - Job object
+ */
+function printJobDetails(job) {
+  printHeader(`Job: ${job.name || job.id}`);
+
+  // Basic info
+  console.log(`${chalk.bold('ID:')}           ${job.id}`);
+  console.log(`${chalk.bold('Name:')}         ${job.name || chalk.gray('-')}`);
+  console.log(`${chalk.bold('Status:')}       ${colorizeStatus(job.status)}`);
+  console.log(`${chalk.bold('Type:')}         ${job.type || 'manual'}`);
+
+  // Schedule
+  console.log(`${chalk.bold('Schedule:')}     ${formatJobSchedule(job)}`);
+
+  if (job.nextRun) {
+    console.log(`${chalk.bold('Next Run:')}     ${formatDate(job.nextRun)} (${formatRelativeTime(job.nextRun)})`);
+  }
+
+  if (job.lastRun) {
+    console.log(`${chalk.bold('Last Run:')}     ${formatDate(job.lastRun)} (${formatRelativeTime(job.lastRun)})`);
+  }
+
+  // Command
+  console.log();
+  console.log(`${chalk.bold('Command:')}`);
+  console.log(`  ${job.command}`);
+
+  // Working directory
+  if (job.cwd) {
+    console.log();
+    console.log(`${chalk.bold('Working Directory:')}`);
+    console.log(`  ${job.cwd}`);
+  }
+
+  // Environment variables
+  if (job.env && Object.keys(job.env).length > 0) {
+    console.log();
+    console.log(`${chalk.bold('Environment Variables:')}`);
+    for (const [key, value] of Object.entries(job.env)) {
+      console.log(`  ${key}=${value}`);
+    }
+  }
+
+  // Tags
+  if (job.tags && job.tags.length > 0) {
+    console.log();
+    console.log(`${chalk.bold('Tags:')}         ${job.tags.join(', ')}`);
+  }
+
+  // Timeout and retry
+  if (job.timeout) {
+    console.log();
+    console.log(`${chalk.bold('Timeout:')}      ${job.timeout}ms`);
+  }
+
+  if (job.retry > 0) {
+    console.log(`${chalk.bold('Retries:')}      ${job.retry}`);
+  }
+
+  // Metadata
+  console.log();
+  console.log(`${chalk.bold('Created:')}      ${formatDate(job.createdAt)}`);
+  console.log(`${chalk.bold('Updated:')}      ${formatDate(job.updatedAt)}`);
+
+  // Log file path
+  console.log();
+  const logFile = getJobLogFile(job.name || `job-${job.id}`);
+  console.log(`${chalk.bold('Log File:')}     ${logFile}`);
+
+  // Execution info
+  if (job.lastExitCode !== undefined && job.lastExitCode !== null) {
+    const exitColor = job.lastExitCode === 0 ? chalk.green : chalk.red;
+    console.log();
+    console.log(`${chalk.bold('Last Exit Code:')} ${exitColor(job.lastExitCode)}`);
+  }
+
+  if (job.retryCount > 0) {
+    console.log(`${chalk.bold('Retry Count:')}  ${job.retryCount}`);
+  }
+
+  console.log();
+}
+
+export default { showCommand };

package/src/cli/commands/start.js

@@ -0,0 +1,46 @@
+/**
+ * JM2 start command
+ * Starts the JM2 daemon process
+ */
+
+import { startDaemon, isDaemonRunning, getDaemonStatus } from '../../daemon/index.js';
+import { printSuccess, printError, printInfo } from '../utils/output.js';
+
+/**
+ * Execute the start command
+ * @param {object} options - Command options
+ * @param {boolean} options.foreground - Run in foreground mode
+ * @returns {Promise<number>} Exit code
+ */
+export async function startCommand(options = {}) {
+  const { foreground = false } = options;
+
+  // Check if daemon is already running
+  if (isDaemonRunning()) {
+    const { pid } = getDaemonStatus();
+    printInfo(`Daemon is already running (PID: ${pid})`);
+    return 0;
+  }
+
+  try {
+    if (foreground) {
+      printInfo('Starting daemon in foreground mode...');
+    } else {
+      printInfo('Starting daemon...');
+    }
+
+    await startDaemon({ foreground });
+
+    if (!foreground) {
+      const { pid } = getDaemonStatus();
+      printSuccess(`Daemon started (PID: ${pid})`);
+    }
+
+    return 0;
+  } catch (error) {
+    printError(`Failed to start daemon: ${error.message}`);
+    return 1;
+  }
+}
+
+export default startCommand;

package/src/cli/commands/status.js

@@ -0,0 +1,47 @@
+/**
+ * JM2 status command
+ * Shows the daemon status and statistics
+ */
+
+import { isDaemonRunning, getDaemonStatus } from '../../daemon/index.js';
+import { getJobs } from '../../core/storage.js';
+import { 
+  colorizeDaemonStatus, 
+  createStatusTable,
+  printHeader,
+} from '../utils/output.js';
+
+/**
+ * Execute the status command
+ * @param {object} _options - Command options (none for status)
+ * @returns {Promise<number>} Exit code
+ */
+export async function statusCommand(_options = {}) {
+  const running = isDaemonRunning();
+  const { pid } = getDaemonStatus();
+  
+  // Count jobs
+  const jobs = getJobs();
+  const totalJobs = jobs.length;
+  const activeJobs = jobs.filter(j => j.status === 'active').length;
+  const pausedJobs = jobs.filter(j => j.status === 'paused').length;
+
+  // Print header
+  printHeader('JM2 Daemon Status');
+
+  // Create status table
+  const table = createStatusTable();
+  
+  table.push(
+    ['Status:', colorizeDaemonStatus(running)],
+    ['PID:', pid ? pid.toString() : '-'],
+    ['Jobs:', `${totalJobs} total (${activeJobs} active, ${pausedJobs} paused)`]
+  );
+
+  console.log(table.toString());
+  console.log();
+
+  return 0;
+}
+
+export default statusCommand;

package/src/cli/commands/stop.js

@@ -0,0 +1,48 @@
+/**
+ * JM2 stop command
+ * Stops the JM2 daemon process
+ */
+
+import { stopDaemon, isDaemonRunning, getDaemonStatus } from '../../daemon/index.js';
+import { printSuccess, printError, printInfo, printWarning } from '../utils/output.js';
+
+/**
+ * Execute the stop command
+ * @param {object} _options - Command options (none for stop)
+ * @returns {Promise<number>} Exit code
+ */
+export async function stopCommand(_options = {}) {
+  // Check if daemon is running
+  if (!isDaemonRunning()) {
+    printError('Daemon is not running');
+    return 3; // Specific exit code for daemon not running
+  }
+
+  const { pid } = getDaemonStatus();
+  printInfo(`Stopping daemon (PID: ${pid})...`);
+
+  try {
+    const stopped = stopDaemon();
+
+    if (stopped) {
+      // Wait a moment to confirm the daemon stopped
+      await new Promise(resolve => setTimeout(resolve, 500));
+
+      if (!isDaemonRunning()) {
+        printSuccess('Daemon stopped');
+        return 0;
+      } else {
+        printWarning('Daemon may not have stopped cleanly');
+        return 1;
+      }
+    } else {
+      printError('Failed to send stop signal to daemon');
+      return 1;
+    }
+  } catch (error) {
+    printError(`Failed to stop daemon: ${error.message}`);
+    return 1;
+  }
+}
+
+export default stopCommand;