jm2 0.1.7 → 0.1.9

package/README.md

@@ -296,8 +296,14 @@ jm2 edit nightly-backup --cron "0 3 * * *"
 # Change command
 jm2 edit nightly-backup --command "npm run full-backup"
 
-# Add/remove tags
-jm2 edit nightly-backup --tag important --untag old
+# Replace all tags (removes existing, sets new)
+jm2 edit nightly-backup --tag production --tag critical
+
+# Append tags without removing existing ones
+jm2 edit nightly-backup --tag-append new-tag
+
+# Remove specific tags
+jm2 edit nightly-backup --tag-remove old-tag
 
 # Change working directory
 jm2 edit nightly-backup --cwd /new/path
@@ -308,14 +314,63 @@ Options:
 - `--at, -a <datetime>` - Convert to one-time job at datetime
 - `--command <cmd>` - New command to execute
 - `--name, -n <name>` - Rename the job
-- `--tag, -t <tag>` - Add tag (can be used multiple times)
-- `--untag <tag>` - Remove tag (can be used multiple times)
+- `--tag, -t <tag>` - Set tags (replaces all existing tags, can be used multiple times)
+- `--tag-append <tag>` - Append tags to existing tags (can be used multiple times)
+- `--tag-remove <tag>` - Remove specific tags (can be used multiple times)
 - `--cwd <path>` - New working directory
 - `--env, -e <KEY=value>` - Set/update environment variable
-- `--unenv <KEY>` - Remove environment variable
 - `--timeout <duration>` - New timeout value
 - `--retry <count>` - New retry count
 
+#### `jm2 tags <subcommand>`
+Manage job tags in bulk.
+
+```bash
+# List all tags with job counts
+jm2 tags list
+
+# List tags with associated jobs (verbose)
+jm2 tags list -v
+
+# Add tag to multiple jobs
+jm2 tags add production 1 2 3
+jm2 tags add staging job-name job2-name
+
+# Remove tag from specific jobs
+jm2 tags rm staging 1 2
+
+# Remove tag from all jobs
+jm2 tags rm old-tag --all
+
+# Clear all tags from specific jobs
+jm2 tags clear 1 2
+
+# Clear all tags from all jobs (requires confirmation)
+jm2 tags clear --all --force
+
+# Rename a tag across all jobs
+jm2 tags rename staging production
+
+# Show jobs grouped by tag (includes untagged group)
+jm2 tags jobs
+
+# Show jobs with specific tag
+jm2 tags jobs production
+```
+
+Subcommands:
+- `list` - List all tags with job counts
+- `add <tag> <job-id-or-name>...` - Add tag to specified jobs
+- `rm <tag> [job-id-or-name]...` - Remove tag from jobs (use `--all` for all jobs)
+- `clear [job-id-or-name]...` - Clear all tags from jobs (use `--all --force` for all jobs)
+- `rename <old-tag> <new-tag>` - Rename a tag across all jobs
+- `jobs [tag-name]` - List jobs grouped by tag
+
+Options:
+- `-v, --verbose` - Show verbose output (list associated jobs)
+- `-a, --all` - Apply to all jobs (for rm and clear commands)
+- `-f, --force` - Skip confirmation for destructive operations
+
 ### Logs and History
 
 #### `jm2 logs [id|name]`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jm2",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "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

@@ -138,9 +138,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/edit.js

@@ -47,9 +47,10 @@ export async function editCommand(jobRef, options = {}) {
     options.tagRemove !== undefined;
 
   // Check for mutually exclusive tag options
-  const hasTagSet = options.tag !== undefined;
-  const hasTagAppend = options.tagAppend !== undefined;
-  const hasTagRemove = options.tagRemove !== undefined;
+  // options.tag has a default of [], so check if it's non-empty
+  const hasTagSet = options.tag !== undefined && options.tag.length > 0;
+  const hasTagAppend = options.tagAppend !== undefined && options.tagAppend.length > 0;
+  const hasTagRemove = options.tagRemove !== undefined && options.tagRemove.length > 0;
 
   if (hasTagSet && (hasTagAppend || hasTagRemove)) {
     printError('Cannot use --tag with --tag-append or --tag-remove. Use --tag to replace all tags, or --tag-append/--tag-remove to modify existing tags.');

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/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/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');