jm2 0.1.4 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jm2",
-  "version": "0.1.4",
+  "version": "0.1.7",
   "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/edit.js

@@ -42,7 +42,19 @@ export async function editCommand(jobRef, options = {}) {
     options.env !== undefined ||
     options.timeout !== undefined ||
     options.retry !== undefined ||
-    options.tag !== undefined;
+    options.tag !== undefined ||
+    options.tagAppend !== undefined ||
+    options.tagRemove !== undefined;
+
+  // Check for mutually exclusive tag options
+  const hasTagSet = options.tag !== undefined;
+  const hasTagAppend = options.tagAppend !== undefined;
+  const hasTagRemove = options.tagRemove !== undefined;
+
+  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.');
+    return 1;
+  }
 
   if (!hasUpdates) {
     printError('No changes specified. Use options like --command, --cron, --name, etc.');
@@ -143,12 +155,30 @@ export async function editCommand(jobRef, options = {}) {
   }
 
   if (options.tag !== undefined) {
-    // Handle multiple tags
+    // Handle multiple tags (replace mode)
     const tags = Array.isArray(options.tag)
       ? options.tag
       : options.tag ? [options.tag] : [];
-    if (tags.length > 0) {
-      updates.tags = tags;
+    updates.tags = tags;
+  }
+
+  if (options.tagAppend !== undefined) {
+    // Handle tags to append
+    const tagsToAppend = Array.isArray(options.tagAppend)
+      ? options.tagAppend
+      : options.tagAppend ? [options.tagAppend] : [];
+    if (tagsToAppend.length > 0) {
+      updates.tagsAppend = tagsToAppend;
+    }
+  }
+
+  if (options.tagRemove !== undefined) {
+    // Handle tags to remove
+    const tagsToRemove = Array.isArray(options.tagRemove)
+      ? options.tagRemove
+      : options.tagRemove ? [options.tagRemove] : [];
+    if (tagsToRemove.length > 0) {
+      updates.tagsRemove = tagsToRemove;
     }
   }
 

package/src/cli/commands/tags.js

@@ -0,0 +1,399 @@
+/**
+ * JM2 tags command
+ * Manage job tags - list, add, remove, rename, and more
+ */
+
+import { send } from '../../ipc/client.js';
+import { MessageType } from '../../ipc/protocol.js';
+import { 
+  printSuccess, 
+  printError, 
+  printInfo,
+  printHeader,
+  createJobTable,
+  colorizeStatus,
+  formatRelativeTime,
+} from '../utils/output.js';
+import { isDaemonRunning } from '../../daemon/index.js';
+import chalk from 'chalk';
+
+/**
+ * Execute the tags command
+ * @param {string} subcommand - Subcommand to run (list, add, rm, clear, rename, jobs)
+ * @param {string[]} args - Arguments for the subcommand
+ * @param {object} options - Command options
+ * @returns {Promise<number>} Exit code
+ */
+export async function tagsCommand(subcommand, args, options = {}) {
+  // Check if daemon is running
+  if (!isDaemonRunning()) {
+    printError('Daemon is not running. Start it with: jm2 start');
+    return 1;
+  }
+
+  switch (subcommand) {
+    case 'list':
+      return await listTags(options);
+    case 'add':
+      return await addTags(args, options);
+    case 'rm':
+    case 'remove':
+      return await removeTags(args, options);
+    case 'clear':
+      return await clearTags(args, options);
+    case 'rename':
+      return await renameTag(args, options);
+    case 'jobs':
+      return await listJobsByTag(args, options);
+    default:
+      printError(`Unknown subcommand: ${subcommand}`);
+      printInfo('Available subcommands: list, add, rm, clear, rename, jobs');
+      return 1;
+  }
+}
+
+/**
+ * List all tags with job counts
+ * @param {object} options - Command options
+ * @returns {Promise<number>} Exit code
+ */
+async function listTags(options) {
+  try {
+    const response = await send({
+      type: MessageType.TAG_LIST,
+    });
+
+    if (response.type === MessageType.ERROR) {
+      printError(response.message);
+      return 1;
+    }
+
+    if (response.type === MessageType.TAG_LIST_RESULT) {
+      const tags = response.tags || {};
+      const tagNames = Object.keys(tags).sort();
+
+      if (tagNames.length === 0) {
+        printInfo('No tags found');
+        return 0;
+      }
+
+      printHeader('Tags');
+
+      // Group by tag
+      for (const tagName of tagNames) {
+        const tagData = tags[tagName];
+        const jobCount = tagData.jobs?.length || 0;
+        console.log(`  ${chalk.cyan(tagName)} ${chalk.gray(`(${jobCount} job${jobCount === 1 ? '' : 's'})`)}`);
+        
+        if (options.verbose && tagData.jobs) {
+          for (const job of tagData.jobs) {
+            console.log(`    - ${job.name || job.id} ${chalk.gray(`[${job.id}]`)}`);
+          }
+        }
+      }
+
+      console.log();
+      printInfo(`${tagNames.length} tag${tagNames.length === 1 ? '' : 's'} found`);
+      
+      return 0;
+    }
+
+    printError('Unexpected response from daemon');
+    return 1;
+  } catch (error) {
+    printError(`Failed to list tags: ${error.message}`);
+    return 1;
+  }
+}
+
+/**
+ * Add tags to jobs
+ * @param {string[]} args - [tagName, ...jobIds]
+ * @param {object} options - Command options
+ * @returns {Promise<number>} Exit code
+ */
+async function addTags(args, options) {
+  if (args.length < 2) {
+    printError('Usage: jm2 tags add <tag> <job-id-or-name> [...job-ids-or-names]');
+    return 1;
+  }
+
+  const tagName = args[0];
+  const jobRefs = args.slice(1);
+
+  try {
+    const response = await send({
+      type: MessageType.TAG_ADD,
+      tag: tagName,
+      jobRefs,
+    });
+
+    if (response.type === MessageType.ERROR) {
+      printError(response.message);
+      return 1;
+    }
+
+    if (response.type === MessageType.TAG_ADD_RESULT) {
+      printSuccess(`Tag "${tagName}" added to ${response.count} job${response.count === 1 ? '' : 's'}`);
+      
+      if (response.count > 0 && options.verbose) {
+        printInfo(`Updated job IDs: ${response.jobIds.join(', ')}`);
+      }
+      
+      return 0;
+    }
+
+    printError('Unexpected response from daemon');
+    return 1;
+  } catch (error) {
+    printError(`Failed to add tag: ${error.message}`);
+    return 1;
+  }
+}
+
+/**
+ * Remove tags from jobs
+ * @param {string[]} args - [tagName, ...jobIds] or just [tagName] to remove from all
+ * @param {object} options - Command options
+ * @returns {Promise<number>} Exit code
+ */
+async function removeTags(args, options) {
+  if (args.length < 1) {
+    printError('Usage: jm2 tags rm <tag> [job-id-or-name ...]');
+    printInfo('Or: jm2 tags rm <tag> --all  (to remove tag from all jobs)');
+    return 1;
+  }
+
+  const tagName = args[0];
+  const jobRefs = args.length > 1 ? args.slice(1) : [];
+
+  // If --all flag is set or no specific jobs, remove from all
+  const removeFromAll = options.all || jobRefs.length === 0;
+
+  try {
+    const response = await send({
+      type: MessageType.TAG_REMOVE,
+      tag: tagName,
+      jobRefs: removeFromAll ? null : jobRefs,
+      all: removeFromAll,
+    });
+
+    if (response.type === MessageType.ERROR) {
+      printError(response.message);
+      return 1;
+    }
+
+    if (response.type === MessageType.TAG_REMOVE_RESULT) {
+      printSuccess(`Tag "${tagName}" removed from ${response.count} job${response.count === 1 ? '' : 's'}`);
+      
+      if (response.count > 0 && options.verbose) {
+        printInfo(`Updated job IDs: ${response.jobIds.join(', ')}`);
+      }
+      
+      return 0;
+    }
+
+    printError('Unexpected response from daemon');
+    return 1;
+  } catch (error) {
+    printError(`Failed to remove tag: ${error.message}`);
+    return 1;
+  }
+}
+
+/**
+ * Clear all tags from jobs
+ * @param {string[]} args - [...jobIds] or empty for all jobs
+ * @param {object} options - Command options
+ * @returns {Promise<number>} Exit code
+ */
+async function clearTags(args, options) {
+  const jobRefs = args.length > 0 ? args : null;
+  const clearAll = options.all || !jobRefs;
+
+  if (clearAll && !options.force) {
+    printError('This will clear all tags from all jobs. Use --force to confirm.');
+    return 1;
+  }
+
+  try {
+    const response = await send({
+      type: MessageType.TAG_CLEAR,
+      jobRefs,
+      all: clearAll,
+    });
+
+    if (response.type === MessageType.ERROR) {
+      printError(response.message);
+      return 1;
+    }
+
+    if (response.type === MessageType.TAG_CLEAR_RESULT) {
+      printSuccess(`Tags cleared from ${response.count} job${response.count === 1 ? '' : 's'}`);
+      
+      if (response.count > 0 && options.verbose) {
+        printInfo(`Updated job IDs: ${response.jobIds.join(', ')}`);
+      }
+      
+      return 0;
+    }
+
+    printError('Unexpected response from daemon');
+    return 1;
+  } catch (error) {
+    printError(`Failed to clear tags: ${error.message}`);
+    return 1;
+  }
+}
+
+/**
+ * Rename a tag across all jobs
+ * @param {string[]} args - [oldTagName, newTagName]
+ * @param {object} options - Command options
+ * @returns {Promise<number>} Exit code
+ */
+async function renameTag(args, options) {
+  if (args.length !== 2) {
+    printError('Usage: jm2 tags rename <old-tag> <new-tag>');
+    return 1;
+  }
+
+  const [oldTag, newTag] = args;
+
+  try {
+    const response = await send({
+      type: MessageType.TAG_RENAME,
+      oldTag,
+      newTag,
+    });
+
+    if (response.type === MessageType.ERROR) {
+      printError(response.message);
+      return 1;
+    }
+
+    if (response.type === MessageType.TAG_RENAME_RESULT) {
+      printSuccess(`Tag "${oldTag}" renamed to "${newTag}" in ${response.count} job${response.count === 1 ? '' : 's'}`);
+      return 0;
+    }
+
+    printError('Unexpected response from daemon');
+    return 1;
+  } catch (error) {
+    printError(`Failed to rename tag: ${error.message}`);
+    return 1;
+  }
+}
+
+/**
+ * List jobs grouped by tag (including jobs with no tags)
+ * @param {string[]} args - Optional tag name to filter
+ * @param {object} options - Command options
+ * @returns {Promise<number>} Exit code
+ */
+async function listJobsByTag(args, options) {
+  const filterTag = args[0];
+
+  try {
+    const response = await send({
+      type: MessageType.TAG_LIST,
+    });
+
+    if (response.type === MessageType.ERROR) {
+      printError(response.message);
+      return 1;
+    }
+
+    if (response.type === MessageType.TAG_LIST_RESULT) {
+      const tags = response.tags || {};
+
+      // If filtering by specific tag
+      if (filterTag) {
+        const tagData = tags[filterTag];
+        if (!tagData || !tagData.jobs || tagData.jobs.length === 0) {
+          printInfo(`No jobs found with tag "${filterTag}"`);
+          return 0;
+        }
+
+        printHeader(`Jobs with tag "${filterTag}"`);
+        printJobsTable(tagData.jobs);
+        console.log();
+        printInfo(`${tagData.jobs.length} job${tagData.jobs.length === 1 ? '' : 's'} found`);
+        return 0;
+      }
+
+      // Show all jobs grouped by tag
+      printHeader('Jobs by Tag');
+
+      const tagNames = Object.keys(tags).sort();
+      const noTagJobs = tags['(no tag)']?.jobs || [];
+
+      // First show tagged jobs
+      for (const tagName of tagNames) {
+        if (tagName === '(no tag)') continue;
+        
+        const tagData = tags[tagName];
+        if (!tagData.jobs || tagData.jobs.length === 0) continue;
+
+        console.log(`\n${chalk.bold.cyan(tagName)} ${chalk.gray(`(${tagData.jobs.length} job${tagData.jobs.length === 1 ? '' : 's'})`)}`);
+        printJobsTable(tagData.jobs, true);
+      }
+
+      // Then show jobs with no tags
+      if (noTagJobs.length > 0) {
+        console.log(`\n${chalk.bold.gray('(no tag)')} ${chalk.gray(`(${noTagJobs.length} job${noTagJobs.length === 1 ? '' : 's'})`)}`);
+        printJobsTable(noTagJobs, true);
+      }
+
+      console.log();
+      const totalJobs = Object.values(tags).reduce((sum, t) => sum + (t.jobs?.length || 0), 0);
+      const uniqueJobs = new Set();
+      Object.values(tags).forEach(t => t.jobs?.forEach(j => uniqueJobs.add(j.id)));
+      printInfo(`${uniqueJobs.size} job${uniqueJobs.size === 1 ? '' : 's'} found (${tagNames.length - (noTagJobs.length > 0 ? 1 : 0)} tag${tagNames.length === 1 ? '' : 's'})`);
+      
+      return 0;
+    }
+
+    printError('Unexpected response from daemon');
+    return 1;
+  } catch (error) {
+    printError(`Failed to list jobs by tag: ${error.message}`);
+    return 1;
+  }
+}
+
+/**
+ * Print jobs in a compact table format
+ * @param {Array} jobs - Array of job objects
+ * @param {boolean} compact - Whether to use compact format
+ */
+function printJobsTable(jobs, compact = false) {
+  const table = createJobTable();
+  
+  for (const job of jobs) {
+    const schedule = job.cron 
+      ? chalk.gray(job.cron) 
+      : job.runAt 
+        ? formatRelativeTime(job.runAt)
+        : chalk.gray('Manual');
+    
+    if (compact) {
+      console.log(`  ${job.id}  ${job.name || chalk.gray('-')}  ${colorizeStatus(job.status)}  ${schedule}`);
+    } else {
+      table.push([
+        job.id,
+        job.name || chalk.gray('-'),
+        colorizeStatus(job.status),
+        schedule,
+        formatRelativeTime(job.nextRun),
+        formatRelativeTime(job.lastRun),
+      ]);
+    }
+  }
+  
+  if (!compact && jobs.length > 0) {
+    console.log(table.toString());
+  }
+}
+
+export default { tagsCommand };

package/src/cli/index.js

@@ -28,6 +28,7 @@ import { exportCommand } from './commands/export.js';
 import { importCommand } from './commands/import.js';
 import { installCommand } from './commands/install.js';
 import { uninstallCommand } from './commands/uninstall.js';
+import { tagsCommand } from './commands/tags.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -191,6 +192,8 @@ export async function runCli() {
     .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, [])
+    .option('--tag-append <tag>', 'Append tags to existing tags (can be used multiple times)', collect, [])
+    .option('--tag-remove <tag>', 'Remove tags from existing tags (can be used multiple times)', collect, [])
     .action(async (job, options) => {
       const exitCode = await editCommand(job, options);
       process.exit(exitCode);
@@ -296,6 +299,31 @@ export async function runCli() {
       process.exit(exitCode);
     });
 
+  // Tags command
+  program
+    .command('tags <subcommand> [args...]')
+    .description('Manage job tags')
+    .option('-v, --verbose', 'Show verbose output', false)
+    .option('-a, --all', 'Apply to all jobs', false)
+    .option('-f, --force', 'Skip confirmation for destructive operations', false)
+    .addHelpText('after', `
+Examples:
+  jm2 tags list                    List all tags with job counts
+  jm2 tags list -v                 List tags with associated jobs
+  jm2 tags add production 1 2 3    Add "production" tag to jobs 1, 2, 3
+  jm2 tags rm staging 1 2          Remove "staging" tag from jobs 1, 2
+  jm2 tags rm old-tag --all        Remove "old-tag" from all jobs
+  jm2 tags clear 1 2               Clear all tags from jobs 1, 2
+  jm2 tags clear --all --force     Clear all tags from all jobs
+  jm2 tags rename old new          Rename tag "old" to "new"
+  jm2 tags jobs                    Show all jobs grouped by tag
+  jm2 tags jobs production         Show jobs with "production" tag
+    `)
+    .action(async (subcommand, args, options) => {
+      const exitCode = await tagsCommand(subcommand, args || [], options);
+      process.exit(exitCode);
+    });
+
   // Parse command line arguments
   await program.parseAsync();
 }

package/src/daemon/index.js

@@ -26,6 +26,11 @@ import {
   createJobResumedResponse,
   createJobRunResponse,
   createFlushResultResponse,
+  createTagListResponse,
+  createTagAddResponse,
+  createTagRemoveResponse,
+  createTagClearResponse,
+  createTagRenameResponse,
 } from '../ipc/protocol.js';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -332,6 +337,21 @@ async function handleIpcMessage(message) {
     case MessageType.RELOAD_JOBS:
       return handleReloadJobs(message);
 
+    case MessageType.TAG_LIST:
+      return handleTagList(message);
+
+    case MessageType.TAG_ADD:
+      return handleTagAdd(message);
+
+    case MessageType.TAG_REMOVE:
+      return handleTagRemove(message);
+
+    case MessageType.TAG_CLEAR:
+      return handleTagClear(message);
+
+    case MessageType.TAG_RENAME:
+      return handleTagRename(message);
+
     default:
       return {
         type: 'error',
@@ -763,6 +783,8 @@ function handleFlush(message) {
       result.jobsRemoved = initialCount - filteredJobs.length;
       if (result.jobsRemoved > 0) {
         saveJobs(filteredJobs);
+        // Reload jobs into scheduler to sync in-memory state with storage
+        scheduler.loadJobs();
         logger?.info(`Flushed ${result.jobsRemoved} completed one-time jobs`);
       }
     }
@@ -828,6 +850,231 @@ function handleFlush(message) {
   }
 }
 
+/**
+ * Handle tag list message
+ * Returns all tags grouped with their jobs
+ * @returns {object} Response
+ */
+function handleTagList() {
+  try {
+    const jobs = scheduler.getAllJobs();
+    const tags = {};
+
+    // Group jobs by tag
+    for (const job of jobs) {
+      const jobTags = job.tags || [];
+      
+      if (jobTags.length === 0) {
+        // Jobs with no tags
+        if (!tags['(no tag)']) {
+          tags['(no tag)'] = { jobs: [] };
+        }
+        tags['(no tag)'].jobs.push(job);
+      } else {
+        // Jobs with tags (can be in multiple groups)
+        for (const tag of jobTags) {
+          if (!tags[tag]) {
+            tags[tag] = { jobs: [] };
+          }
+          tags[tag].jobs.push(job);
+        }
+      }
+    }
+
+    return createTagListResponse(tags);
+  } catch (error) {
+    logger?.error(`Failed to list tags: ${error.message}`);
+    return {
+      type: MessageType.ERROR,
+      message: `Failed to list tags: ${error.message}`,
+    };
+  }
+}
+
+/**
+ * Handle tag add message
+ * Adds a tag to specified jobs
+ * @param {object} message - Message with tag and jobRefs
+ * @returns {object} Response
+ */
+function handleTagAdd(message) {
+  try {
+    const { tag, jobRefs } = message;
+    const normalizedTag = tag.trim().toLowerCase();
+    
+    const jobs = scheduler.getAllJobs();
+    const updatedJobIds = [];
+
+    for (const jobRef of jobRefs) {
+      // Find job by ID or name
+      let job = null;
+      const jobId = parseInt(jobRef, 10);
+      
+      if (!isNaN(jobId)) {
+        job = jobs.find(j => j.id === jobId);
+      }
+      if (!job) {
+        job = jobs.find(j => j.name === jobRef);
+      }
+
+      if (job) {
+        const currentTags = job.tags || [];
+        if (!currentTags.includes(normalizedTag)) {
+          const newTags = [...currentTags, normalizedTag];
+          scheduler.updateJob(job.id, { tags: newTags });
+          updatedJobIds.push(job.id);
+        }
+      }
+    }
+
+    if (updatedJobIds.length > 0) {
+      logger?.info(`Added tag "${normalizedTag}" to ${updatedJobIds.length} jobs`);
+    }
+
+    return createTagAddResponse(updatedJobIds.length, updatedJobIds);
+  } catch (error) {
+    logger?.error(`Failed to add tag: ${error.message}`);
+    return {
+      type: MessageType.ERROR,
+      message: `Failed to add tag: ${error.message}`,
+    };
+  }
+}
+
+/**
+ * Handle tag remove message
+ * Removes a tag from specified jobs or all jobs
+ * @param {object} message - Message with tag, jobRefs, and all flag
+ * @returns {object} Response
+ */
+function handleTagRemove(message) {
+  try {
+    const { tag, jobRefs, all } = message;
+    const normalizedTag = tag.trim().toLowerCase();
+    
+    const jobs = scheduler.getAllJobs();
+    const updatedJobIds = [];
+
+    // Determine which jobs to process
+    const jobsToProcess = all
+      ? jobs
+      : jobRefs.map(ref => {
+          const jobId = parseInt(ref, 10);
+          if (!isNaN(jobId)) {
+            return jobs.find(j => j.id === jobId) || jobs.find(j => j.name === ref);
+          }
+          return jobs.find(j => j.name === ref);
+        }).filter(Boolean);
+
+    for (const job of jobsToProcess) {
+      const currentTags = job.tags || [];
+      if (currentTags.includes(normalizedTag)) {
+        const newTags = currentTags.filter(t => t !== normalizedTag);
+        scheduler.updateJob(job.id, { tags: newTags });
+        updatedJobIds.push(job.id);
+      }
+    }
+
+    if (updatedJobIds.length > 0) {
+      logger?.info(`Removed tag "${normalizedTag}" from ${updatedJobIds.length} jobs`);
+    }
+
+    return createTagRemoveResponse(updatedJobIds.length, updatedJobIds);
+  } catch (error) {
+    logger?.error(`Failed to remove tag: ${error.message}`);
+    return {
+      type: MessageType.ERROR,
+      message: `Failed to remove tag: ${error.message}`,
+    };
+  }
+}
+
+/**
+ * Handle tag clear message
+ * Clears all tags from specified jobs or all jobs
+ * @param {object} message - Message with jobRefs and all flag
+ * @returns {object} Response
+ */
+function handleTagClear(message) {
+  try {
+    const { jobRefs, all } = message;
+    
+    const jobs = scheduler.getAllJobs();
+    const updatedJobIds = [];
+
+    // Determine which jobs to process
+    const jobsToProcess = all
+      ? jobs
+      : (jobRefs || []).map(ref => {
+          const jobId = parseInt(ref, 10);
+          if (!isNaN(jobId)) {
+            return jobs.find(j => j.id === jobId) || jobs.find(j => j.name === ref);
+          }
+          return jobs.find(j => j.name === ref);
+        }).filter(Boolean);
+
+    for (const job of jobsToProcess) {
+      const currentTags = job.tags || [];
+      if (currentTags.length > 0) {
+        scheduler.updateJob(job.id, { tags: [] });
+        updatedJobIds.push(job.id);
+      }
+    }
+
+    if (updatedJobIds.length > 0) {
+      logger?.info(`Cleared all tags from ${updatedJobIds.length} jobs`);
+    }
+
+    return createTagClearResponse(updatedJobIds.length, updatedJobIds);
+  } catch (error) {
+    logger?.error(`Failed to clear tags: ${error.message}`);
+    return {
+      type: MessageType.ERROR,
+      message: `Failed to clear tags: ${error.message}`,
+    };
+  }
+}
+
+/**
+ * Handle tag rename message
+ * Renames a tag across all jobs
+ * @param {object} message - Message with oldTag and newTag
+ * @returns {object} Response
+ */
+function handleTagRename(message) {
+  try {
+    const { oldTag, newTag } = message;
+    const normalizedOldTag = oldTag.trim().toLowerCase();
+    const normalizedNewTag = newTag.trim().toLowerCase();
+    
+    const jobs = scheduler.getAllJobs();
+    let updatedCount = 0;
+
+    for (const job of jobs) {
+      const currentTags = job.tags || [];
+      if (currentTags.includes(normalizedOldTag)) {
+        const newTags = currentTags.map(t => t === normalizedOldTag ? normalizedNewTag : t);
+        // Remove duplicates that might result from rename
+        const uniqueTags = [...new Set(newTags)];
+        scheduler.updateJob(job.id, { tags: uniqueTags });
+        updatedCount++;
+      }
+    }
+
+    if (updatedCount > 0) {
+      logger?.info(`Renamed tag "${normalizedOldTag}" to "${normalizedNewTag}" in ${updatedCount} jobs`);
+    }
+
+    return createTagRenameResponse(updatedCount);
+  } catch (error) {
+    logger?.error(`Failed to rename tag: ${error.message}`);
+    return {
+      type: MessageType.ERROR,
+      message: `Failed to rename tag: ${error.message}`,
+    };
+  }
+}
+
 /**
  * Handle reload jobs message
  * Reloads jobs from storage into scheduler

package/src/daemon/scheduler.js

@@ -335,9 +335,34 @@ export class Scheduler {
       return null;
     }
 
+    // Handle tag append/remove operations
+    let finalTags = job.tags || [];
+    
+    if (updates.tagsAppend && updates.tagsAppend.length > 0) {
+      // Normalize and append new tags
+      const tagsToAppend = updates.tagsAppend.map(t => t.trim().toLowerCase());
+      finalTags = [...new Set([...finalTags, ...tagsToAppend])];
+    }
+    
+    if (updates.tagsRemove && updates.tagsRemove.length > 0) {
+      // Normalize and remove tags
+      const tagsToRemove = updates.tagsRemove.map(t => t.trim().toLowerCase());
+      finalTags = finalTags.filter(t => !tagsToRemove.includes(t));
+    }
+
+    // Create a clean updates object without the append/remove markers
+    const cleanUpdates = { ...updates };
+    delete cleanUpdates.tagsAppend;
+    delete cleanUpdates.tagsRemove;
+    
+    // If we modified tags via append/remove, update the tags field
+    if (updates.tagsAppend || updates.tagsRemove) {
+      cleanUpdates.tags = finalTags;
+    }
+
     const updatedJob = {
       ...job,
-      ...updates,
+      ...cleanUpdates,
       id: jobId, // Don't allow changing ID
       updatedAt: new Date().toISOString(),
     };

package/src/ipc/protocol.js

@@ -26,6 +26,18 @@ export const MessageType = {
   JOB_RUN: 'job:run',
   JOB_RUN_RESULT: 'job:run:result',
 
+  // Tag management
+  TAG_LIST: 'tag:list',
+  TAG_LIST_RESULT: 'tag:list:result',
+  TAG_ADD: 'tag:add',
+  TAG_ADD_RESULT: 'tag:add:result',
+  TAG_REMOVE: 'tag:remove',
+  TAG_REMOVE_RESULT: 'tag:remove:result',
+  TAG_CLEAR: 'tag:clear',
+  TAG_CLEAR_RESULT: 'tag:clear:result',
+  TAG_RENAME: 'tag:rename',
+  TAG_RENAME_RESULT: 'tag:rename:result',
+
   // Flush/cleanup
   FLUSH: 'flush',
   FLUSH_RESULT: 'flush:result',
@@ -145,6 +157,72 @@ export function createFlushResultResponse(result) {
   };
 }
 
+/**
+ * Create a tag list response
+ * @param {object} tags - Tags grouped by name with job counts
+ * @returns {{ type: string, tags: object }}
+ */
+export function createTagListResponse(tags) {
+  return {
+    type: MessageType.TAG_LIST_RESULT,
+    tags,
+  };
+}
+
+/**
+ * Create a tag add response
+ * @param {number} count - Number of jobs updated
+ * @param {string[]} jobIds - IDs of jobs that were updated
+ * @returns {{ type: string, count: number, jobIds: string[] }}
+ */
+export function createTagAddResponse(count, jobIds) {
+  return {
+    type: MessageType.TAG_ADD_RESULT,
+    count,
+    jobIds,
+  };
+}
+
+/**
+ * Create a tag remove response
+ * @param {number} count - Number of jobs updated
+ * @param {string[]} jobIds - IDs of jobs that were updated
+ * @returns {{ type: string, count: number, jobIds: string[] }}
+ */
+export function createTagRemoveResponse(count, jobIds) {
+  return {
+    type: MessageType.TAG_REMOVE_RESULT,
+    count,
+    jobIds,
+  };
+}
+
+/**
+ * Create a tag clear response
+ * @param {number} count - Number of jobs updated
+ * @param {string[]} jobIds - IDs of jobs that were updated
+ * @returns {{ type: string, count: number, jobIds: string[] }}
+ */
+export function createTagClearResponse(count, jobIds) {
+  return {
+    type: MessageType.TAG_CLEAR_RESULT,
+    count,
+    jobIds,
+  };
+}
+
+/**
+ * Create a tag rename response
+ * @param {number} count - Number of jobs updated
+ * @returns {{ type: string, count: number }}
+ */
+export function createTagRenameResponse(count) {
+  return {
+    type: MessageType.TAG_RENAME_RESULT,
+    count,
+  };
+}
+
 /**
  * Create a standard error response
  * @param {string} message - Error message
@@ -180,4 +258,9 @@ export default {
   createJobResumedResponse,
   createJobRunResponse,
   createFlushResultResponse,
+  createTagListResponse,
+  createTagAddResponse,
+  createTagRemoveResponse,
+  createTagClearResponse,
+  createTagRenameResponse,
 };

package/src/ipc/server.js

@@ -17,13 +17,19 @@ export function startIpcServer(options = {}) {
   const { onMessage } = options;
   const socketPath = getSocketPath();
 
-  if (process.platform !== 'win32' && existsSync(socketPath)) {
-    unlinkSync(socketPath);
-  }
-
+  // Ensure directories exist first
   ensureDataDir();
   ensureRuntimeDir();
 
+  // Clean up stale socket file
+  if (process.platform !== 'win32' && existsSync(socketPath)) {
+    try {
+      unlinkSync(socketPath);
+    } catch (error) {
+      throw new Error(`Failed to remove stale socket file: ${error.message}`);
+    }
+  }
+
   const server = createServer(socket => {
     let buffer = '';
 
@@ -72,7 +78,21 @@ export function startIpcServer(options = {}) {
     });
   });
 
+  // Add error handler for the server
+  server.on('error', (error) => {
+    throw new Error(`IPC server error: ${error.message}`);
+  });
+
   server.listen(socketPath);
+  
+  // Verify socket was created
+  server.on('listening', () => {
+    if (process.platform !== 'win32' && !existsSync(socketPath)) {
+      server.close();
+      throw new Error(`Socket file was not created at ${socketPath}`);
+    }
+  });
+
   return server;
 }
 
@@ -85,6 +105,18 @@ export function stopIpcServer(server) {
     return;
   }
   server.close();
+  
+  // Clean up socket file on Unix systems
+  if (process.platform !== 'win32') {
+    const socketPath = getSocketPath();
+    try {
+      if (existsSync(socketPath)) {
+        unlinkSync(socketPath);
+      }
+    } catch (error) {
+      // Ignore errors during cleanup
+    }
+  }
 }
 
 export default {

package/src/utils/paths.js

@@ -16,7 +16,7 @@ const DATA_DIR_NAME = '.jm2';
  * Get the runtime directory for sockets
  * Uses platform-specific standard locations:
  * - Linux: /run/user/<uid>/jm2/ (XDG standard)
- * - macOS: ~/Library/Caches/jm2/
+ * - macOS: ~/.jm2/ (Caches directory gets cleaned up by system)
  * - Others: ~/.jm2/
  * @returns {string} The runtime directory path
  */
@@ -33,12 +33,8 @@ function getRuntimeDir() {
     return join(xdgRuntimeDir, 'jm2');
   }
 
-  if (process.platform === 'darwin') {
-    // macOS standard - use Library/Caches for runtime files
-    return join(homedir(), 'Library', 'Caches', 'jm2');
-  }
-
-  // Fallback to data directory for other platforms
+  // For macOS and other platforms, use data directory
+  // Note: Library/Caches gets cleaned up by macOS, causing socket files to disappear
   return getDataDir();
 }