jm2 0.1.8 → 0.1.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jm2",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Job Manager 2 - A simple yet powerful job scheduler combining cron and at functionality",
   "type": "module",
   "main": "src/cli/index.js",

package/src/cli/commands/add.js

@@ -31,6 +31,10 @@ Common examples of JM2 add:
   jm2 add "weekly-backup.sh" --cron "0 0 * * 0"
   jm2 add "monthly-task.sh" --cron "0 0 1 * *"
 
+  # Advanced cron patterns (multiple ranges, steps)
+  jm2 add "check.sh" --cron "0 */5 9-18 * * *"    # Every 5 min, 9AM-6PM
+  jm2 add "offpeak.sh" --cron "*/30 0-8,18-23 * * *"  # Every 30 min, off-peak hours
+
   # Add a job with a name
   jm2 add "backup.sh" --name "daily-backup" --cron "0 2 * * *"
 
@@ -138,9 +142,8 @@ export async function addCommand(command, options = {}) {
       jobData.tags = tags;
     }
 
-    if (options.cwd) {
-      jobData.cwd = options.cwd;
-    }
+    // Set working directory - use explicit cwd or default to current directory
+    jobData.cwd = options.cwd || process.cwd();
 
     if (options.env) {
       // Parse env options (format: KEY=value)

package/src/cli/commands/backup.js

@@ -0,0 +1,130 @@
+/**
+ * JM2 backup command
+ * Creates a backup of all JM2 data including jobs, history, and logs
+ */
+
+import { createWriteStream, existsSync, mkdirSync, readdirSync, statSync, readFileSync } from 'node:fs';
+import { createGzip } from 'node:zlib';
+import { pipeline } from 'node:stream/promises';
+import { join, basename } from 'node:path';
+import { getDataDir, getJobsFile, getConfigFile, getHistoryDbFile, getLogsDir } from '../../utils/paths.js';
+import { printSuccess, printError, printInfo, printWarning } from '../utils/output.js';
+import dayjs from 'dayjs';
+
+/**
+ * Execute the backup command
+ * @param {string} outputPath - Output file path (optional)
+ * @param {object} options - Command options
+ * @returns {Promise<number>} Exit code
+ */
+export async function backupCommand(outputPath, options = {}) {
+  try {
+    const dataDir = getDataDir();
+    
+    if (!existsSync(dataDir)) {
+      printError('JM2 data directory not found. Nothing to backup.');
+      return 1;
+    }
+
+    // Generate default filename if not provided
+    if (!outputPath) {
+      const timestamp = dayjs().format('YYYYMMDD_HHmmss');
+      outputPath = `jm2-backup-${timestamp}.json.gz`;
+    }
+
+    // Ensure .json.gz extension
+    if (!outputPath.endsWith('.json.gz') && !outputPath.endsWith('.json')) {
+      outputPath += '.json.gz';
+    }
+
+    // Resolve full path
+    const backupPath = outputPath.startsWith('/') 
+      ? outputPath 
+      : join(process.cwd(), outputPath);
+
+    printInfo(`Creating backup: ${basename(backupPath)}`);
+
+    // Gather backup data
+    const backupData = {
+      version: '1.0.0',
+      createdAt: new Date().toISOString(),
+      platform: process.platform,
+      jobs: null,
+      config: null,
+      history: null,
+      logs: {},
+    };
+
+    // Backup jobs
+    if (existsSync(getJobsFile())) {
+      const jobsContent = readFileSync(getJobsFile(), 'utf8');
+      backupData.jobs = JSON.parse(jobsContent);
+      printInfo(`Included: ${backupData.jobs.length || 1} job(s)`);
+    }
+
+    // Backup config
+    if (existsSync(getConfigFile())) {
+      const configContent = readFileSync(getConfigFile(), 'utf8');
+      backupData.config = JSON.parse(configContent);
+      printInfo('Included: config.json');
+    }
+
+    // Backup history database (as base64)
+    if (existsSync(getHistoryDbFile())) {
+      const historyBuffer = readFileSync(getHistoryDbFile());
+      backupData.history = historyBuffer.toString('base64');
+      printInfo('Included: history.db');
+    }
+
+    // Backup logs
+    const logsDir = getLogsDir();
+    if (existsSync(logsDir)) {
+      const logFiles = readdirSync(logsDir).filter(f => f.endsWith('.log'));
+      for (const logFile of logFiles) {
+        const logPath = join(logsDir, logFile);
+        const logContent = readFileSync(logPath, 'utf8');
+        backupData.logs[logFile] = logContent;
+      }
+      if (logFiles.length > 0) {
+        printInfo(`Included: ${logFiles.length} log file(s)`);
+      }
+    }
+
+    // Convert to JSON
+    const jsonData = JSON.stringify(backupData, null, 2);
+
+    // Write compressed file
+    if (backupPath.endsWith('.gz')) {
+      const source = new ReadableStream({
+        start(controller) {
+          controller.enqueue(Buffer.from(jsonData));
+          controller.close();
+        }
+      });
+      
+      const gzip = createGzip();
+      const output = createWriteStream(backupPath);
+      
+      await pipeline(source, gzip, output);
+    } else {
+      // Write uncompressed
+      const { writeFileSync } = await import('node:fs');
+      writeFileSync(backupPath, jsonData);
+    }
+
+    // Get file size
+    const stats = statSync(backupPath);
+    const sizeKB = (stats.size / 1024).toFixed(2);
+
+    printSuccess(`Backup created successfully: ${basename(backupPath)}`);
+    printInfo(`Size: ${sizeKB} KB`);
+    printInfo(`Location: ${backupPath}`);
+
+    return 0;
+  } catch (error) {
+    printError(`Failed to create backup: ${error.message}`);
+    return 1;
+  }
+}
+
+export default backupCommand;

package/src/cli/commands/restore.js

@@ -0,0 +1,156 @@
+/**
+ * JM2 restore command
+ * Restores JM2 data from a backup file
+ */
+
+import { existsSync, mkdirSync, writeFileSync, readdirSync } from 'node:fs';
+import { createReadStream } from 'node:fs';
+import { createGunzip } from 'node:zlib';
+import { pipeline } from 'node:stream/promises';
+import { join, basename } from 'node:path';
+import { getDataDir, getJobsFile, getConfigFile, getHistoryDbFile, getLogsDir, ensureDataDir, ensureLogsDir } from '../../utils/paths.js';
+import { printSuccess, printError, printInfo, printWarning } from '../utils/output.js';
+import { isDaemonRunning } from '../../daemon/index.js';
+
+/**
+ * Execute the restore command
+ * @param {string} backupPath - Path to backup file
+ * @param {object} options - Command options
+ * @returns {Promise<number>} Exit code
+ */
+export async function restoreCommand(backupPath, options = {}) {
+  if (!backupPath) {
+    printError('Backup file path is required');
+    printInfo('Usage: jm2 restore <backup-file>');
+    return 1;
+  }
+
+  // Resolve full path
+  const fullPath = backupPath.startsWith('/') 
+    ? backupPath 
+    : join(process.cwd(), backupPath);
+
+  if (!existsSync(fullPath)) {
+    printError(`Backup file not found: ${backupPath}`);
+    return 1;
+  }
+
+  try {
+    printInfo(`Reading backup: ${basename(fullPath)}`);
+
+    // Read backup data
+    let jsonData;
+    
+    if (fullPath.endsWith('.gz')) {
+      // Decompress gzip file
+      const chunks = [];
+      const source = createReadStream(fullPath);
+      const gunzip = createGunzip();
+      
+      for await (const chunk of source.pipe(gunzip)) {
+        chunks.push(chunk);
+      }
+      
+      jsonData = Buffer.concat(chunks).toString('utf8');
+    } else {
+      // Read uncompressed
+      const { readFileSync } = await import('node:fs');
+      jsonData = readFileSync(fullPath, 'utf8');
+    }
+
+    // Parse backup data
+    const backupData = JSON.parse(jsonData);
+
+    // Validate backup format
+    if (!backupData.version) {
+      printError('Invalid backup file format');
+      return 1;
+    }
+
+    printInfo(`Backup created: ${backupData.createdAt || 'unknown date'}`);
+    printInfo(`Platform: ${backupData.platform || 'unknown'}`);
+
+    // Warn if daemon is running
+    if (isDaemonRunning() && !options.force) {
+      printWarning('Daemon is currently running. Stop it first or use --force');
+      printInfo('Tip: jm2 stop && jm2 restore <backup-file> && jm2 start');
+      return 1;
+    }
+
+    // Confirm restore unless --yes flag
+    if (!options.yes) {
+      printWarning('This will overwrite existing JM2 data');
+      printInfo('Use --yes to skip this confirmation');
+      
+      // For now, require --yes flag (interactive prompts would need additional deps)
+      printError('Use --yes flag to confirm restore');
+      return 1;
+    }
+
+    // Ensure data directory exists
+    ensureDataDir();
+    ensureLogsDir();
+
+    let restoredCount = 0;
+
+    // Restore jobs
+    if (backupData.jobs) {
+      writeFileSync(getJobsFile(), JSON.stringify(backupData.jobs, null, 2));
+      const jobCount = Array.isArray(backupData.jobs) ? backupData.jobs.length : 1;
+      printInfo(`Restored: ${jobCount} job(s)`);
+      restoredCount++;
+    }
+
+    // Restore config
+    if (backupData.config) {
+      writeFileSync(getConfigFile(), JSON.stringify(backupData.config, null, 2));
+      printInfo('Restored: config.json');
+      restoredCount++;
+    }
+
+    // Restore history
+    if (backupData.history) {
+      const historyBuffer = Buffer.from(backupData.history, 'base64');
+      writeFileSync(getHistoryDbFile(), historyBuffer);
+      printInfo('Restored: history.db');
+      restoredCount++;
+    }
+
+    // Restore logs
+    if (backupData.logs && typeof backupData.logs === 'object') {
+      const logsDir = getLogsDir();
+      let logCount = 0;
+      
+      for (const [filename, content] of Object.entries(backupData.logs)) {
+        const logPath = join(logsDir, filename);
+        writeFileSync(logPath, content);
+        logCount++;
+      }
+      
+      if (logCount > 0) {
+        printInfo(`Restored: ${logCount} log file(s)`);
+        restoredCount++;
+      }
+    }
+
+    if (restoredCount === 0) {
+      printWarning('No data found in backup file');
+      return 0;
+    }
+
+    printSuccess(`Restore completed successfully`);
+    printInfo(`Restored ${restoredCount} data type(s)`);
+    
+    if (isDaemonRunning()) {
+      printInfo('Note: You may need to restart the daemon to load restored jobs');
+      printInfo('Run: jm2 restart');
+    }
+
+    return 0;
+  } catch (error) {
+    printError(`Failed to restore backup: ${error.message}`);
+    return 1;
+  }
+}
+
+export default restoreCommand;

package/src/cli/commands/run.js

@@ -3,7 +3,7 @@
  * Manually execute a job immediately
  */
 
-import { send } from '../../ipc/client.js';
+import { send, sendWithStream } from '../../ipc/client.js';
 import { MessageType } from '../../ipc/protocol.js';
 import { printSuccess, printError, printInfo } from '../utils/output.js';
 import { isDaemonRunning } from '../../daemon/index.js';
@@ -35,33 +35,35 @@ export async function runCommand(jobRef, options = {}) {
 
     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 (options.wait) {
+      // Use streaming for real-time output
+      const response = await sendWithStream(message, {
+        timeoutMs: null,
+        onStream: (chunk) => {
+          if (chunk.stream === 'stdout') {
+            process.stdout.write(chunk.data);
+          } else if (chunk.stream === 'stderr') {
+            process.stderr.write(chunk.data);
+          }
+        },
+      });
 
-      if (result.error) {
-        printError(`Job execution failed: ${result.error}`);
+      if (response.type === MessageType.ERROR) {
+        printError(response.message);
         return 1;
       }
 
-      if (options.wait) {
-        // Display execution results
+      if (response.type === MessageType.JOB_RUN_RESULT) {
+        const result = response.result;
+
+        if (result.error) {
+          printError(`Job execution failed: ${result.error}`);
+          return 1;
+        }
+
+        // Display final 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') {
@@ -69,22 +71,26 @@ export async function runCommand(jobRef, options = {}) {
           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 {
+
+        return 0;
+      }
+    } else {
+      // Non-waiting mode - just queue the job
+      const response = await send(message, { timeoutMs: 5000 });
+
+      if (response.type === MessageType.ERROR) {
+        printError(response.message);
+        return 1;
+      }
+
+      if (response.type === MessageType.JOB_RUN_RESULT) {
+        const result = response.result;
         printSuccess(`Job queued for execution (ID: ${result.jobId || jobRef})`);
         printInfo('Use --wait to wait for completion and see output');
+        return 0;
       }
-
-      return 0;
     }
 
     printError('Unexpected response from daemon');

package/src/cli/commands/show.js

@@ -59,7 +59,11 @@ export async function showCommand(jobRef, options = {}) {
         return 1;
       }
 
-      printJobDetails(job);
+      if (options.recreateCommandOnly) {
+        console.log(generateRecreateCommand(job));
+      } else {
+        printJobDetails(job);
+      }
       return 0;
     }
 
@@ -137,6 +141,11 @@ function printJobDetails(job) {
   console.log(`${chalk.bold('Created:')}      ${formatDate(job.createdAt)}`);
   console.log(`${chalk.bold('Updated:')}      ${formatDate(job.updatedAt)}`);
 
+  // Recreate command
+  console.log();
+  console.log(`${chalk.bold('Recreate Command:')}`);
+  console.log(`  ${generateRecreateCommand(job)}`);
+
   // Log file path
   console.log();
   const logFile = getJobLogFile(job.name || `job-${job.id}`);
@@ -156,4 +165,63 @@ function printJobDetails(job) {
   console.log();
 }
 
+/**
+ * Generate the jm2 add command to recreate this job
+ * @param {object} job - Job object
+ * @returns {string} Command string
+ */
+function generateRecreateCommand(job) {
+  const parts = ['jm2 add'];
+  
+  // Add the command itself (quoted if it contains spaces)
+  const command = job.command.includes(' ') ? `"${job.command}"` : job.command;
+  parts.push(command);
+  
+  // Add name
+  if (job.name) {
+    parts.push(`--name ${job.name}`);
+  }
+  
+  // Add scheduling option
+  if (job.cron) {
+    parts.push(`--cron "${job.cron}"`);
+  } else if (job.runAt) {
+    // For runAt, we need to format it nicely
+    const runDate = new Date(job.runAt);
+    const dateStr = runDate.toISOString().slice(0, 16).replace('T', ' ');
+    parts.push(`--at "${dateStr}"`);
+  }
+  
+  // Add working directory
+  if (job.cwd) {
+    parts.push(`--cwd "${job.cwd}"`);
+  }
+  
+  // Add tags
+  if (job.tags && job.tags.length > 0) {
+    for (const tag of job.tags) {
+      parts.push(`--tag ${tag}`);
+    }
+  }
+  
+  // Add environment variables
+  if (job.env && Object.keys(job.env).length > 0) {
+    for (const [key, value] of Object.entries(job.env)) {
+      parts.push(`--env "${key}=${value}"`);
+    }
+  }
+  
+  // Add timeout
+  if (job.timeout) {
+    parts.push(`--timeout ${job.timeout}`);
+  }
+  
+  // Add retry
+  if (job.retry > 0) {
+    parts.push(`--retry ${job.retry}`);
+  }
+  
+  return parts.join(' ');
+}
+
 export default { showCommand };

package/src/cli/index.js

@@ -29,6 +29,8 @@ import { importCommand } from './commands/import.js';
 import { installCommand } from './commands/install.js';
 import { uninstallCommand } from './commands/uninstall.js';
 import { tagsCommand } from './commands/tags.js';
+import { backupCommand } from './commands/backup.js';
+import { restoreCommand } from './commands/restore.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -140,8 +142,9 @@ export async function runCli() {
   program
     .command('show <job>')
     .description('Show detailed information about a job')
-    .action(async (job) => {
-      const exitCode = await showCommand(job);
+    .option('--recreate-command-only', 'Show only the recreate command', false)
+    .action(async (job, options) => {
+      const exitCode = await showCommand(job, options);
       process.exit(exitCode);
     });
 
@@ -299,6 +302,28 @@ export async function runCli() {
       process.exit(exitCode);
     });
 
+  // Backup command
+  program
+    .command('backup [file]')
+    .description('Create a backup of all JM2 data (jobs, config, history, logs)')
+    .option('-o, --output <file>', 'Output file path (default: jm2-backup-<timestamp>.json.gz)')
+    .action(async (file, options) => {
+      const outputPath = file || options.output;
+      const exitCode = await backupCommand(outputPath, options);
+      process.exit(exitCode);
+    });
+
+  // Restore command
+  program
+    .command('restore <file>')
+    .description('Restore JM2 data from a backup file')
+    .option('-y, --yes', 'Skip confirmation prompt', false)
+    .option('-f, --force', 'Force restore even if daemon is running', false)
+    .action(async (file, options) => {
+      const exitCode = await restoreCommand(file, options);
+      process.exit(exitCode);
+    });
+
   // Tags command
   program
     .command('tags <subcommand> [args...]')

package/src/core/logger.js

@@ -62,12 +62,25 @@ function shouldLog(level) {
 }
 
 /**
- * Format a timestamp for logging
+ * Format a timestamp for logging in local timezone
  * @param {Date} date - Date to format
  * @returns {string} Formatted timestamp
  */
 function formatTimestamp(date = new Date()) {
-  return date.toISOString();
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, '0');
+  const day = String(date.getDate()).padStart(2, '0');
+  const hours = String(date.getHours()).padStart(2, '0');
+  const minutes = String(date.getMinutes()).padStart(2, '0');
+  const seconds = String(date.getSeconds()).padStart(2, '0');
+  const milliseconds = String(date.getMilliseconds()).padStart(3, '0');
+
+  const tzOffset = -date.getTimezoneOffset();
+  const tzHours = String(Math.floor(Math.abs(tzOffset) / 60)).padStart(2, '0');
+  const tzMinutes = String(Math.abs(tzOffset) % 60).padStart(2, '0');
+  const tzSign = tzOffset >= 0 ? '+' : '-';
+
+  return `${year}-${month}-${day}T${hours}:${minutes}:${seconds}.${milliseconds}${tzSign}${tzHours}:${tzMinutes}`;
 }
 
 /**

package/src/core/service.js

@@ -188,6 +188,8 @@ class DarwinService extends PlatformService {
     <dict>
         <key>JM2_DATA_DIR</key>
         <string>${dataDir}</string>
+        <key>PATH</key>
+        <string>${process.env.PATH}</string>
     </dict>
 </dict>
 </plist>`;

package/src/daemon/executor.js

@@ -143,6 +143,9 @@ export function executeJob(job, options = {}) {
         const chunk = data.toString();
         stdout += chunk;
         jobLogger.info(`[stdout] ${chunk.trim()}`);
+        if (execOptions.onStream) {
+          execOptions.onStream('stdout', chunk);
+        }
       });
     }
 
@@ -152,6 +155,9 @@ export function executeJob(job, options = {}) {
         const chunk = data.toString();
         stderr += chunk;
         jobLogger.warn(`[stderr] ${chunk.trim()}`);
+        if (execOptions.onStream) {
+          execOptions.onStream('stderr', chunk);
+        }
       });
     }
 

package/src/daemon/index.js

@@ -25,6 +25,7 @@ import {
   createJobPausedResponse,
   createJobResumedResponse,
   createJobRunResponse,
+  createJobStreamOutput,
   createFlushResultResponse,
   createTagListResponse,
   createTagAddResponse,
@@ -285,9 +286,10 @@ async function runDaemon(options = {}) {
 /**
  * Handle IPC messages
  * @param {object} message - Incoming message
+ * @param {import('node:net').Socket} socket - Socket for streaming responses
  * @returns {Promise<object|null>} Response message
  */
-async function handleIpcMessage(message) {
+async function handleIpcMessage(message, socket) {
   logger?.debug(`Received message: ${JSON.stringify(message)}`);
 
   switch (message.type) {
@@ -329,7 +331,7 @@ async function handleIpcMessage(message) {
       return handleJobResume(message);
 
     case MessageType.JOB_RUN:
-      return handleJobRun(message);
+      return handleJobRun(message, socket);
 
     case MessageType.FLUSH:
       return handleFlush(message);
@@ -647,9 +649,10 @@ function handleJobResume(message) {
 /**
  * Handle job run message (manual execution)
  * @param {object} message - Message with jobId
+ * @param {import('node:net').Socket} socket - Socket for streaming output
  * @returns {object} Response
  */
-async function handleJobRun(message) {
+async function handleJobRun(message, socket) {
   try {
     let jobId = message.jobId;
 
@@ -681,8 +684,19 @@ async function handleJobRun(message) {
 
     // Execute the job
     if (message.wait) {
-      // Wait for execution and return results
-      const result = await executeJobAndReturnResult(job);
+      // Stream function to send output chunks
+      const streamOutput = (stream, data) => {
+        if (socket && !socket.destroyed) {
+          try {
+            socket.write(JSON.stringify(createJobStreamOutput(stream, data)) + '\n');
+          } catch (err) {
+            // Ignore socket write errors
+          }
+        }
+      };
+
+      // Wait for execution with streaming and return results
+      const result = await executeJobAndReturnResult(job, streamOutput);
       return createJobRunResponse({
         jobId,
         status: result.status,
@@ -713,9 +727,10 @@ async function handleJobRun(message) {
 /**
  * Execute a job and return the result
  * @param {object} job - Job to execute
+ * @param {Function} onStream - Callback for streaming output (stream, data) => void
  * @returns {Promise<object>} Execution result
  */
-async function executeJobAndReturnResult(job) {
+async function executeJobAndReturnResult(job, onStream) {
   if (!scheduler.executor) {
     return {
       status: 'failed',
@@ -724,7 +739,7 @@ async function executeJobAndReturnResult(job) {
   }
 
   try {
-    const result = await scheduler.executor.executeJobWithRetry(job);
+    const result = await scheduler.executor.executeJobWithRetry(job, { onStream });
 
     // Update job stats
     const updatedJob = scheduler.getJob(job.id);

package/src/daemon/scheduler.js

@@ -31,6 +31,7 @@ export class Scheduler {
     }
 
     this.running = true;
+    this.lastTickTime = Date.now();
     this.logger.info('Scheduler starting...');
 
     // Load jobs from storage
@@ -132,7 +133,7 @@ export class Scheduler {
     // Calculate next run time for active jobs
     let nextRun = null;
     if (job.status === JobStatus.ACTIVE) {
-      nextRun = this.calculateNextRun(job);
+      nextRun = this.calculateNextRun(job, new Date());
     }
 
     this.jobs.set(job.id, {
@@ -147,15 +148,16 @@ export class Scheduler {
   /**
    * Calculate the next run time for a job
    * @param {object} job - Job object
+   * @param {Date} fromDate - Date to calculate from
    * @returns {Date|null} Next run time or null
    */
-  calculateNextRun(job) {
+  calculateNextRun(job, fromDate) {
     if (job.status !== JobStatus.ACTIVE) {
       return null;
     }
 
     if (job.type === JobType.CRON && job.cron) {
-      return getNextRunTime(job.cron);
+      return getNextRunTime(job.cron, fromDate);
     }
 
     if (job.type === JobType.ONCE && job.runAt) {
@@ -167,6 +169,57 @@ export class Scheduler {
     return null;
   }
 
+  /**
+   * Calculate the next run time for a cron job, accounting for missed runs
+   * This ensures that after sleep/wake, we find the very next occurrence
+   * @param {object} job - Job object
+   * @param {Date} originalRunTime - The time the job was originally scheduled to run
+   * @returns {Date|null} Next run time or null
+   */
+  calculateNextRunAfterExecution(job, originalRunTime) {
+    if (job.status !== JobStatus.ACTIVE || job.type !== JobType.CRON || !job.cron) {
+      return this.calculateNextRun(job, new Date());
+    }
+
+    const now = new Date();
+    let nextRun = this.calculateNextRun(job, originalRunTime);
+
+    // Keep calculating until we find a time in the future
+    // This handles the case where the system woke from sleep and we missed multiple runs
+    while (nextRun && nextRun <= now) {
+      nextRun = this.calculateNextRun(job, nextRun);
+    }
+
+    return nextRun;
+  }
+
+  /**
+   * Recalculate next run times for periodic jobs that have drifted into the past
+   * This handles system sleep/wake scenarios where nextRun becomes stale
+   * @param {Date} now - Current time
+   */
+  recalculateStalePeriodicJobs(now) {
+    for (const [id, job] of this.jobs) {
+      if (
+        job.status === JobStatus.ACTIVE &&
+        job.type === JobType.CRON &&
+        job.cron &&
+        job.nextRun &&
+        job.nextRun < now
+      ) {
+        // Job's next run is in the past - recalculate from now to find next future occurrence
+        const newNextRun = this.calculateNextRun(job, now);
+        if (newNextRun && newNextRun !== job.nextRun) {
+          this.logger.debug(
+            `Recalculating next run for job ${id} (${job.name || 'unnamed'}): ` +
+            `${job.nextRun.toISOString()} → ${newNextRun.toISOString()}`
+          );
+          this.updateJobNextRun(id, newNextRun);
+        }
+      }
+    }
+  }
+
   /**
    * Get jobs that are due to run
    * @returns {Array} Array of jobs that should run now
@@ -249,11 +302,32 @@ export class Scheduler {
       return [];
     }
 
+    // Detect sleep/wake events by checking if too much time has passed since last tick
+    const now = Date.now();
+    const timeSinceLastTick = this.lastTickTime ? now - this.lastTickTime : 0;
+    const sleepThreshold = this.checkIntervalMs * 5; // If more than 5 intervals passed, likely woke from sleep
+
+    if (timeSinceLastTick > sleepThreshold) {
+      const secondsAsleep = Math.round(timeSinceLastTick / 1000);
+      this.logger.info(`System wake detected - was asleep for ${secondsAsleep}s, catching up on due jobs`);
+    }
+
+    this.lastTickTime = now;
+
+    const nowDate = new Date();
+
+    // Recalculate next run for periodic jobs that have drifted into the past
+    // This handles system sleep/wake scenarios
+    this.recalculateStalePeriodicJobs(nowDate);
+
     const dueJobs = this.getDueJobs();
 
     for (const job of dueJobs) {
       this.logger.debug(`Job ${job.id} (${job.name || 'unnamed'}) is due`);
 
+      // Store the original scheduled time before execution
+      const originalNextRun = job.nextRun ? new Date(job.nextRun) : new Date();
+
       // Execute the job
       this.executeJob(job);
 
@@ -261,8 +335,12 @@ export class Scheduler {
       if (job.type === JobType.ONCE) {
         this.updateJobStatus(job.id, JobStatus.COMPLETED);
       } else {
-        // For cron jobs, recalculate next run time
-        const nextRun = this.calculateNextRun({ ...job, status: JobStatus.ACTIVE });
+        // For cron jobs, recalculate next run time from the original scheduled time
+        // This ensures we don't miss runs after system wake from sleep
+        const nextRun = this.calculateNextRunAfterExecution(
+          { ...job, status: JobStatus.ACTIVE },
+          originalNextRun
+        );
         this.updateJobNextRun(job.id, nextRun);
       }
     }
@@ -291,7 +369,7 @@ export class Scheduler {
     }
 
     // Calculate initial next run
-    const nextRun = this.calculateNextRun(jobData);
+    const nextRun = this.calculateNextRun(jobData, new Date());
     const job = { ...jobData, nextRun };
 
     // Add to memory
@@ -368,7 +446,7 @@ export class Scheduler {
     };
 
     // Recalculate next run if needed
-    updatedJob.nextRun = this.calculateNextRun(updatedJob);
+    updatedJob.nextRun = this.calculateNextRun(updatedJob, new Date());
 
     this.jobs.set(jobId, updatedJob);
     this.persistJobs();
@@ -390,7 +468,7 @@ export class Scheduler {
       // Recalculate next run when activating
       const job = this.jobs.get(jobId);
       if (job) {
-        updates.nextRun = this.calculateNextRun({ ...job, status });
+        updates.nextRun = this.calculateNextRun({ ...job, status }, new Date());
       }
     } else {
       updates.nextRun = null;

package/src/ipc/client.js

@@ -44,20 +44,102 @@ export function send(message, options = {}) {
     let buffer = '';
     let finished = false;
 
-    const timeout = setTimeout(() => {
+    const timeout = timeoutMs !== null && timeoutMs !== undefined
+      ? setTimeout(() => {
+          if (!finished) {
+            finished = true;
+            client.destroy();
+            reject(new DaemonError('IPC request timed out', 'ETIMEOUT'));
+          }
+        }, timeoutMs)
+      : null;
+
+    client.on('error', err => {
       if (!finished) {
         finished = true;
-        client.destroy();
-        reject(new DaemonError('IPC request timed out', 'ETIMEOUT'));
+        clearTimeout(timeout);
+        
+        // Provide user-friendly error for daemon not running
+        if (isConnectionRefusedError(err)) {
+          reject(new DaemonError(
+            'Daemon is not running. Start it with: jm2 start',
+            'EDAEMON_NOT_RUNNING'
+          ));
+        } else {
+          reject(new DaemonError(
+            `IPC communication failed: ${err.message}`,
+            err.code || 'EIPC_ERROR'
+          ));
+        }
       }
-    }, timeoutMs);
+    });
+
+    client.on('data', data => {
+      buffer += data.toString();
+      let index;
+      while ((index = buffer.indexOf('\n')) !== -1) {
+        const line = buffer.slice(0, index).trim();
+        buffer = buffer.slice(index + 1);
+        if (!line) {
+          continue;
+        }
+        try {
+          const response = JSON.parse(line);
+          if (!finished) {
+            finished = true;
+            clearTimeout(timeout);
+            client.end();
+            resolve(response);
+          }
+        } catch (error) {
+          if (!finished) {
+            finished = true;
+            clearTimeout(timeout);
+            client.end();
+            reject(new DaemonError('Invalid JSON response from daemon', 'EINVALID_JSON'));
+          }
+        }
+      }
+    });
+
+    client.on('connect', () => {
+      client.write(`${JSON.stringify(message)}\n`);
+    });
+  });
+}
+
+/**
+ * Send a message to the daemon with streaming support
+ * @param {object} message - Message to send
+ * @param {object} options - Client options
+ * @param {number|null} options.timeoutMs - Timeout in milliseconds (null for no timeout)
+ * @param {Function} options.onStream - Callback for stream messages (chunk) => void
+ * @returns {Promise<object>} Final response message
+ */
+export function sendWithStream(message, options = {}) {
+  const { timeoutMs = null, onStream } = options;
+  const socketPath = getSocketPath();
+
+  return new Promise((resolve, reject) => {
+    const client = createConnection(socketPath);
+    let buffer = '';
+    let finished = false;
+
+    const timeout = timeoutMs !== null && timeoutMs !== undefined
+      ? setTimeout(() => {
+          if (!finished) {
+            finished = true;
+            client.destroy();
+            reject(new DaemonError('IPC request timed out', 'ETIMEOUT'));
+          }
+        }, timeoutMs)
+      : null;
 
     client.on('error', err => {
       if (!finished) {
         finished = true;
         clearTimeout(timeout);
         
-        // Provide user-friendly error for daemon not running
         if (isConnectionRefusedError(err)) {
           reject(new DaemonError(
             'Daemon is not running. Start it with: jm2 start',
@@ -83,6 +165,14 @@ export function send(message, options = {}) {
         }
         try {
           const response = JSON.parse(line);
+          
+          // Handle streaming output
+          if (response.type === 'job:stream:output' && onStream) {
+            onStream(response);
+            continue;
+          }
+          
+          // Final result
           if (!finished) {
             finished = true;
             clearTimeout(timeout);
@@ -108,5 +198,6 @@ export function send(message, options = {}) {
 
 export default {
   send,
+  sendWithStream,
   DaemonError,
 };

package/src/ipc/protocol.js

@@ -25,6 +25,7 @@ export const MessageType = {
   JOB_RESUMED: 'job:resumed',
   JOB_RUN: 'job:run',
   JOB_RUN_RESULT: 'job:run:result',
+  JOB_STREAM_OUTPUT: 'job:stream:output',
 
   // Tag management
   TAG_LIST: 'tag:list',
@@ -143,6 +144,20 @@ export function createJobRunResponse(result) {
   };
 }
 
+/**
+ * Create a job stream output message
+ * @param {string} stream - 'stdout' or 'stderr'
+ * @param {string} data - Output data
+ * @returns {{ type: string, stream: string, data: string }}
+ */
+export function createJobStreamOutput(stream, data) {
+  return {
+    type: MessageType.JOB_STREAM_OUTPUT,
+    stream,
+    data,
+  };
+}
+
 /**
  * Create a flush result response
  * @param {object} result - Flush result with jobsRemoved, logsRemoved, historyRemoved
@@ -257,6 +272,7 @@ export default {
   createJobPausedResponse,
   createJobResumedResponse,
   createJobRunResponse,
+  createJobStreamOutput,
   createFlushResultResponse,
   createTagListResponse,
   createTagAddResponse,

package/src/ipc/server.js

@@ -62,7 +62,7 @@ export function startIpcServer(options = {}) {
         }
 
         if (onMessage) {
-          Promise.resolve(onMessage(message))
+          Promise.resolve(onMessage(message, socket))
             .then(response => {
               if (response) {
                 socket.write(JSON.stringify(response) + '\n');