@cloudnux/local-cloud-provider 0.12.0 → 0.14.0

package/dist/schedule-plugin/index.js

@@ -1,10 +1,6 @@
-// src/schedule-plugin/plugin.ts
-import fsPlugin from "fastify-plugin";
-
-// src/schedule-plugin/core.ts
-import * as fs2 from "fs/promises";
-import chalk6 from "chalk";
-import logSymbols4 from "log-symbols";
+// src/logging/pretty-writer.ts
+import chalk from "chalk";
+import { EOL as EOL2 } from "os";
 
 // ../../../node_modules/lodash-es/_freeGlobal.js
 var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
@@ -828,20 +824,32 @@ var utils = {
 };
 var env = Object.assign(_env, utils);
 
-// ../../utils/src/logging/index.ts
-import chalk from "chalk";
-import { EOL } from "os";
-
 // ../../utils/src/logging/types.ts
 var logLevels = {
   fatal: -1,
   error: 0,
   warn: 1,
   info: 2,
-  debug: 3
+  debug: 3,
+  trace: 4
 };
 
 // ../../utils/src/logging/error-to-string.ts
+var safeJsonStringify = (value) => {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return JSON.stringify(value, (key, currentValue) => {
+    if (key === "constructor") return void 0;
+    if (typeof currentValue === "object" && currentValue !== null) {
+      if (seen.has(currentValue)) return "[Circular]";
+      seen.add(currentValue);
+    }
+    return currentValue;
+  });
+};
+var hasOwnConstructorProp = (value) => {
+  if (typeof value !== "object" || value === null) return false;
+  return Object.prototype.hasOwnProperty.call(value, "constructor");
+};
 var errorToString = (error) => {
   if (error === null) return "Null error";
   if (error === void 0) return "Undefined error";
@@ -851,13 +859,22 @@ var errorToString = (error) => {
       `Message: ${error.message}`,
       `Stack: ${error.stack || "No stack trace available"}`,
       // Handle additional properties that might exist on custom errors
-      ...Object.entries(error).filter(([key]) => !["name", "message", "stack"].includes(key)).map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
+      ...Object.entries(error).filter(
+        ([key, value]) => !["name", "message", "stack"].includes(key) && !hasOwnConstructorProp(value)
+      ).map(([key, value]) => `${key}: ${safeJsonStringify(value)}`)
     ].join("\n");
   }
   if (typeof error === "string") return error;
   if (typeof error === "object") {
     try {
-      return JSON.stringify(error, null, 2);
+      return JSON.stringify(
+        error,
+        (key, value) => {
+          if (key === "constructor") return void 0;
+          return value;
+        },
+        2
+      );
     } catch {
       return `[Object that cannot be stringified: ${Object.prototype.toString.call(error)}]`;
     }
@@ -865,69 +882,135 @@ var errorToString = (error) => {
   return String(error);
 };
 
+// ../../utils/src/logging/writer.ts
+import { EOL } from "os";
+var jsonWriter = (entry) => {
+  process.stdout.write(JSON.stringify(entry) + EOL);
+};
+var _writer = jsonWriter;
+function setWriter(writer) {
+  _writer = writer;
+}
+function getWriter() {
+  return _writer;
+}
+
 // ../../utils/src/logging/index.ts
-var currentLogLevel = logLevels[env("LOG_LEVEL")?.toLowerCase()] ?? logLevels.info;
-var module = "default";
-var requestId = "";
-var logger = {
-  fatal: (message, meta) => {
-    if (currentLogLevel >= logLevels.fatal) {
-      console.error(
-        `[${(/* @__PURE__ */ new Date()).toTimeString()}]`,
-        `${chalk.bgRed.white(" fatal ")} - ${module || "unknown module"} - ${requestId || "no request ID"} - ${EOL}`,
-        errorToString(message),
-        meta ? `${EOL}${JSON.stringify(meta, null, 2)}` : ""
-      );
-    }
-  },
-  error: (message, meta) => {
-    if (currentLogLevel >= logLevels.error) {
-      console.error(
-        `[${(/* @__PURE__ */ new Date()).toTimeString()}]`,
-        `${chalk.bgRed.white(" error ")} - ${module || "unknown module"} - ${requestId || "no request ID"} - ${EOL}`,
-        errorToString(message),
-        meta ? `${EOL}${JSON.stringify(meta, null, 2)}` : ""
-      );
-    }
-  },
-  warn: (message, meta) => {
-    if (currentLogLevel >= logLevels.warn) {
-      console.warn(
-        `[${(/* @__PURE__ */ new Date()).toTimeString()}]`,
-        `${chalk.bgYellow.black(" warn ")} - ${module || "unknown module"} - ${requestId || "no request ID"} - ${EOL}`,
-        errorToString(message),
-        meta ? `${EOL}${JSON.stringify(meta, null, 2)}` : ""
-      );
-    }
-  },
-  info: (message, meta) => {
-    if (currentLogLevel >= logLevels.info) {
-      console.info(
-        `[${(/* @__PURE__ */ new Date()).toTimeString()}]`,
-        `${chalk.bgBlue.white(" info ")} - ${module || "unknown module"} - ${requestId || "no request ID"} - ${EOL}`,
-        message,
-        meta ? `${EOL}${JSON.stringify(meta, null, 2)}` : ""
-      );
-    }
-  },
-  debug: (message, meta) => {
-    if (currentLogLevel >= logLevels.debug) {
-      console.debug(
-        `[${(/* @__PURE__ */ new Date()).toTimeString()}]`,
-        `${chalk.bgWhite.black(" debug ")} - ${module || "unknown module"} - ${requestId || "no request ID"} - ${EOL}`,
-        message,
-        meta ? `${EOL}${JSON.stringify(meta, null, 2)}` : ""
-      );
-    }
-  }
+var levelValues = {
+  fatal: 70,
+  error: 60,
+  warn: 50,
+  info: 40,
+  debug: 30,
+  trace: 20
 };
+var currentLogLevel = 2;
+var _module = "default";
+var _requestId = "";
+function writeLine(level, mergeObject, msg, bindings) {
+  getWriter()({
+    level: levelValues[level],
+    levelName: level,
+    time: Date.now(),
+    module: bindings.module || _module,
+    reqId: bindings.reqId || _requestId,
+    msg: level === "error" || level === "fatal" ? errorToString(msg) : msg,
+    ...mergeObject ? { meta: mergeObject } : {}
+  });
+}
+function createLogger(bindings = {}) {
+  const currentLogLevelName = env("LOG_LEVEL")?.toLowerCase() ?? "info";
+  currentLogLevel = logLevels[currentLogLevelName] ?? logLevels.info;
+  return {
+    level: currentLogLevelName,
+    fatal: (mergeObject, msg) => {
+      if (currentLogLevel >= logLevels.fatal) {
+        typeof mergeObject === "string" || mergeObject instanceof Error ? writeLine("fatal", null, mergeObject, bindings) : writeLine("fatal", mergeObject, msg ?? "", bindings);
+      }
+    },
+    error: (mergeObject, msg) => {
+      if (currentLogLevel >= logLevels.error) {
+        typeof mergeObject === "string" || mergeObject instanceof Error ? writeLine("error", null, mergeObject, bindings) : writeLine("error", mergeObject, msg ?? "", bindings);
+      }
+    },
+    warn: (mergeObject, msg) => {
+      if (currentLogLevel >= logLevels.warn) {
+        typeof mergeObject === "string" ? writeLine("warn", null, mergeObject, bindings) : writeLine("warn", mergeObject, msg ?? "", bindings);
+      }
+    },
+    info: (mergeObject, msg) => {
+      if (currentLogLevel >= logLevels.info) {
+        typeof mergeObject === "string" ? writeLine("info", null, mergeObject, bindings) : writeLine("info", mergeObject, msg ?? "", bindings);
+      }
+    },
+    debug: (mergeObject, msg) => {
+      if (currentLogLevel >= logLevels.debug) {
+        typeof mergeObject === "string" ? writeLine("debug", null, mergeObject, bindings) : writeLine("debug", mergeObject, msg ?? "", bindings);
+      }
+    },
+    trace: (mergeObject, msg) => {
+      if (currentLogLevel >= logLevels.trace) {
+        typeof mergeObject === "string" ? writeLine("trace", null, mergeObject, bindings) : writeLine("trace", mergeObject, msg ?? "", bindings);
+      }
+    },
+    silent: () => {
+    },
+    child: (childBindings) => createLogger({ ...bindings, ...childBindings })
+  };
+}
+var logger = createLogger();
 
-// src/schedule-plugin/execution.ts
-import chalk3 from "chalk";
-import logSymbols from "log-symbols";
+// src/logging/pretty-writer.ts
+var levelColor = {
+  fatal: chalk.bgRed.white,
+  error: chalk.red,
+  warn: chalk.yellow,
+  info: chalk.cyan,
+  debug: chalk.gray,
+  trace: chalk.white
+};
+function formatTime(ms) {
+  return new Date(ms).toTimeString().slice(0, 8);
+}
+function formatMeta(meta) {
+  const { req, res, ...rest } = meta;
+  const lines = [];
+  if (req) {
+    const reqParts = [`${req.method} ${req.url}`];
+    if (req.remoteAddress) reqParts.push(`from ${req.remoteAddress}:${req.remotePort ?? ""}`);
+    if (req.headers) reqParts.push(`headers=${JSON.stringify(req.headers, null, 2)}`);
+    if (req.body !== void 0) reqParts.push(`body=${typeof req.body === "string" ? req.body : JSON.stringify(req.body, null, 2)}`);
+    lines.push(chalk.dim("  req: " + reqParts.join(" ")));
+  }
+  if (res) {
+    const resParts = [`${res.statusCode}`];
+    if (res.headers) resParts.push(`headers=${JSON.stringify(res.headers, null, 2)}`);
+    if (res.body !== void 0) resParts.push(`body=${typeof res.body === "string" ? res.body : JSON.stringify(res.body, null, 2)}`);
+    lines.push(chalk.dim("  res: " + resParts.join(" ")));
+  }
+  if (Object.keys(rest).length) {
+    lines.push(chalk.dim("  " + JSON.stringify(rest, null, 2)));
+  }
+  return lines.length ? EOL2 + lines.join(EOL2) : "";
+}
+var prettyWriter = (entry) => {
+  const color = levelColor[entry.levelName] ?? chalk.white;
+  const time = chalk.dim(formatTime(entry.time));
+  const level = color(entry.levelName.toUpperCase().padEnd(5));
+  const module = chalk.magenta(entry.module);
+  const reqId = entry.reqId ? chalk.dim(`[${entry.reqId}]`) + " " : "";
+  const meta = entry.meta ? formatMeta(entry.meta) : "";
+  process.stdout.write(`${time} ${level} ${module} ${reqId}- ${entry.msg}${meta}${EOL2}`);
+};
+setWriter(prettyWriter);
+
+// src/schedule-plugin/plugin.ts
+import fsPlugin from "fastify-plugin";
+
+// src/schedule-plugin/core.ts
+import * as fs2 from "fs/promises";
 
 // src/schedule-plugin/cron-utils.ts
-import chalk2 from "chalk";
 import { parseExpression } from "cron-parser";
 function parseCronExpression(cronExpression, lastRun, options = {}) {
   const {
@@ -959,7 +1042,7 @@ function parseCronExpression(cronExpression, lastRun, options = {}) {
       description: describeCronExpression(normalizedCron)
     };
   } catch (error) {
-    logger.error(`${chalk2.red("Invalid cron expression:")} ${cronExpression} - ${error.message}`);
+    logger.error(`Invalid cron expression: ${cronExpression} - ${error.message}`);
     const fallbackTime = /* @__PURE__ */ new Date();
     fallbackTime.setHours(fallbackTime.getHours() + 1);
     fallbackTime.setMinutes(0);
@@ -988,7 +1071,7 @@ function getNextExecutions(cronExpression, count = 5, options = {}) {
     }
     return executions;
   } catch (error) {
-    logger.error(`${chalk2.red("Error getting next executions:")} ${error.message}`);
+    logger.error(`Error getting next executions: ${error.message}`);
     return [];
   }
 }
@@ -1303,7 +1386,7 @@ var scheduleJob = (scheduler, state, executeJobFn) => {
     updatedScheduler.timerId = setTimeout(() => {
       executeJobFn(updatedScheduler);
     }, timeUntilNextRun);
-    logger.debug(`${chalk3.blue("\u{1F4C5} Scheduled job")} ${chalk3.green(scheduler.job.name)} to run in ${chalk3.cyan(Math.round(timeUntilNextRun / 1e3))}s`);
+    logger.debug(`Scheduled job ${scheduler.job.name} to run in ${Math.round(timeUntilNextRun / 1e3)}s`);
   }
   return updatedScheduler;
 };
@@ -1332,20 +1415,18 @@ var updateJobAfterExecution = (job, execution, config) => {
   return updatedJob;
 };
 var handleExecutionError = (execution, error) => {
-  logger.error(`${logSymbols.error} ${chalk3.red("Job failed")} ${execution.jobId}: ${error.message}`);
+  logger.error(`Job failed ${execution.jobId}: ${error.message}`);
   return completeExecution(execution, void 0, error.message);
 };
 var handleExecutionSuccess = (execution, result) => {
   const duration = execution.endTime ? execution.endTime.getTime() - execution.startTime.getTime() : 0;
-  logger.debug(`${logSymbols.success} ${chalk3.green("Job completed")} in ${duration}ms`);
+  logger.debug(`Job completed in ${duration}ms`);
   return completeExecution(execution, result);
 };
 
 // src/schedule-plugin/persistence.ts
 import * as fs from "fs/promises";
 import * as path from "path";
-import chalk4 from "chalk";
-import logSymbols2 from "log-symbols";
 var createStateFilePath = (directory) => path.join(directory, "scheduler-state.json");
 var createTempFilePath = (directory) => path.join(directory, `scheduler-state.${Date.now()}.temp.json`);
 var serializeSchedulerState = (schedulers, executionHistory) => ({
@@ -1361,7 +1442,7 @@ var saveSchedulerState = async (state) => {
     const tempFile = createTempFilePath(state.config.persistence.directory);
     await fs.writeFile(tempFile, JSON.stringify(serializedState, null, 2), "utf8");
     await fs.rename(tempFile, stateFile);
-    logger.debug(`${logSymbols2.info} ${chalk4.blue("Enhanced scheduler state saved")}`);
+    logger.debug("Enhanced scheduler state saved");
   } catch (error) {
     logger.error("Failed to save scheduler state:", error);
   }
@@ -1373,7 +1454,7 @@ var loadSchedulerStateData = async (directory) => {
     return JSON.parse(data);
   } catch (error) {
     if (error.code === "ENOENT") {
-      logger.debug(`${chalk4.blue("No previous scheduler state found - starting fresh")}`);
+      logger.debug("No previous scheduler state found - starting fresh");
     } else {
       logger.error("Failed to load scheduler state:", error);
     }
@@ -1386,20 +1467,20 @@ var validateAndAdjustNextRun = (job, savedNextRun, lastRestartTime, config) => {
     return calculateNextRunFromLastRun(job, job.lastRun, config);
   }
   if (savedNextRun <= now) {
-    logger.debug(`${chalk4.yellow("\u23F0 Saved next run is in the past for")} ${chalk4.green(job.name)} - recalculating`);
+    logger.debug(`Saved next run is in the past for ${job.name} - recalculating`);
     return calculateNextRunFromLastRun(job, job.lastRun, config);
   }
   const timeSinceRestart = now.getTime() - lastRestartTime.getTime();
   const isRapidRestart = timeSinceRestart < config.restartBehavior.rapidRestartThreshold;
   if (isRapidRestart) {
-    logger.debug(`${chalk4.blue("\u26A1 Rapid restart detected for")} ${chalk4.green(job.name)} - preserving saved timing`);
+    logger.debug(`Rapid restart detected for ${job.name} - preserving saved timing`);
     return savedNextRun;
   }
   if (job.cronExpression || job.intervalMs) {
     const expectedNextRun = calculateNextRunFromLastRun(job, job.lastRun, config);
     const timeDiff = Math.abs(savedNextRun.getTime() - expectedNextRun.getTime());
     if (timeDiff > config.restartBehavior.maxTimingDrift) {
-      logger.debug(`${chalk4.yellow("\u{1F527} Adjusting timing for")} ${chalk4.green(job.name)} - drift of ${Math.round(timeDiff / 1e3)}s detected`);
+      logger.debug(`Adjusting timing for ${job.name} - drift of ${Math.round(timeDiff / 1e3)}s detected`);
       return expectedNextRun;
     }
   }
@@ -1413,7 +1494,7 @@ var restoreJobFromSavedData = (scheduler, savedJob, config, lastRestartTime) =>
     lastRun: savedJob.lastRun ? new Date(savedJob.lastRun) : void 0
   };
   if (definitionChanged) {
-    logger.debug(`${chalk4.yellow("\u{1F504} Job definition changed:")} ${chalk4.green(savedJob.name)} - recalculating schedule`);
+    logger.debug(`Job definition changed: ${savedJob.name} - recalculating schedule`);
     updatedJob.nextRun = calculateNextRunFromLastRun(updatedJob, updatedJob.lastRun, config);
   } else {
     const savedNextRun = savedJob.nextRun ? new Date(savedJob.nextRun) : void 0;
@@ -1423,7 +1504,7 @@ var restoreJobFromSavedData = (scheduler, savedJob, config, lastRestartTime) =>
     const result = parseCronExpression(updatedJob.cronExpression, updatedJob.lastRun, {
       timezone: updatedJob.timezone
     });
-    logger.debug(`${chalk4.blue("\u{1F4C5} Job restored:")} ${chalk4.green(savedJob.name)} - ${result.description} - next: ${chalk4.cyan(updatedJob.nextRun.toLocaleString())}`);
+    logger.debug(`Job restored: ${savedJob.name} - ${result.description} - next: ${updatedJob.nextRun.toLocaleString()}`);
   }
   return { ...scheduler, job: updatedJob };
 };
@@ -1453,20 +1534,18 @@ var loadSchedulerState = async (schedulers, config, lastRestartTime) => {
     }
   }
   const executionHistory = stateData.executions ? restoreExecutionHistory(stateData.executions) : [];
-  logger.debug(`${logSymbols2.success} ${chalk4.green("Enhanced scheduler state loaded")} (saved at ${stateData.savedAt})`);
+  logger.debug(`Enhanced scheduler state loaded (saved at ${stateData.savedAt})`);
   return { schedulers: restoredSchedulers, executionHistory };
 };
 
 // src/schedule-plugin/cleanup.ts
-import chalk5 from "chalk";
-import logSymbols3 from "log-symbols";
 var cleanupExecutionHistory = (state) => {
   if (state.executionHistory.length > state.config.cleanup.maxExecutionHistory) {
     const removed = state.executionHistory.splice(
       0,
       state.executionHistory.length - state.config.cleanup.maxExecutionHistory
     );
-    logger.debug(`${chalk5.blue("\u{1F9F9} Cleaned up")} ${removed.length} old execution records`);
+    logger.debug(`Cleaned up ${removed.length} old execution records`);
     return removed;
   }
   return [];
@@ -1533,11 +1612,11 @@ var createSchedulerFunctions = (state) => {
     const { canExecute, reason } = canExecuteJob(scheduler, state);
     if (!canExecute) {
       if (reason === "Maximum concurrent executions reached") {
-        logger.warn(`${chalk6.yellow("\u26A0\uFE0F  Delaying job")} ${chalk6.green(scheduler.job.name)} - ${reason}`);
+        logger.warn(`Delaying job ${scheduler.job.name} - ${reason}`);
         scheduler.job.nextRun = new Date(Date.now() + 3e4);
         scheduleJobFn(scheduler);
       } else if (reason === "Job reached maximum runs") {
-        logger.info(`${chalk6.yellow("\u23F9\uFE0F  Job")} ${chalk6.green(scheduler.job.name)} reached max runs (${scheduler.job.maxRuns})`);
+        logger.info(`Job ${scheduler.job.name} reached max runs (${scheduler.job.maxRuns})`);
       }
       return;
     }
@@ -1546,7 +1625,7 @@ var createSchedulerFunctions = (state) => {
     state.executionHistory.push(execution);
     scheduler.isRunning = true;
     state.runningExecutions++;
-    logger.info(`${chalk6.blue("\u{1F680} Executing job")} ${chalk6.green(scheduler.job.name)} (${execution.id})`);
+    logger.info(`Executing job ${scheduler.job.name} (${execution.id})`);
     try {
       const result = await executeJobWithTimeout(
         scheduler.handler,
@@ -1606,20 +1685,18 @@ var initializeScheduler = async (state, scheduleJobFn) => {
         scheduleJobFn(scheduler);
       }
     }
-    logger.debug(`${logSymbols4.success} ${chalk6.green("Scheduler initialized:")} ${Object.keys(state.schedulers).length} jobs loaded`);
+    logger.debug(`Scheduler initialized: ${Object.keys(state.schedulers).length} jobs loaded`);
   } catch (error) {
-    logger.error(`${logSymbols4.error} ${chalk6.red("Failed to initialize scheduler:")} ${error.message}`);
+    logger.error(`Failed to initialize scheduler: ${error.message}`);
     throw error;
   }
 };
 
 // src/schedule-plugin/jobs.ts
-import chalk7 from "chalk";
-import logSymbols5 from "log-symbols";
 var validateJobDefinition = (jobDef) => {
   const expressionType = detectExpressionType(jobDef.cronExpression);
   if (expressionType === "unknown") {
-    logger.error(`${logSymbols5.error} ${chalk7.red("Invalid cron expression for job:")} ${jobDef.name}`);
+    logger.error(`Invalid cron expression for job: ${jobDef.name}`);
     throw new Error(`Invalid cron expression for job: ${jobDef.name}`);
   }
 };
@@ -1631,11 +1708,11 @@ var createJobFromDefinition = (jobDef, config) => {
     const result = parseCronExpression(cronExpression, void 0, {
       timezone: jobDef.timezone ?? config.cron.defaultTimezone
     });
-    logger.debug(`${chalk7.blue("\u{1F4C5} Job")} ${chalk7.green(jobDef.name)}: ${result.description} - Next: ${chalk7.cyan(result.nextRun.toLocaleString())}`);
+    logger.debug(`Job ${jobDef.name}: ${result.description} - Next: ${result.nextRun.toLocaleString()}`);
     const upcoming = getNextExecutions(cronExpression, 3, {
       timezone: jobDef.timezone ?? config.cron.defaultTimezone
     });
-    logger.debug(`${chalk7.blue("   Upcoming:")} ${upcoming.map((d) => d.toLocaleTimeString()).join(", ")}`);
+    logger.debug(`Upcoming: ${upcoming.map((d) => d.toLocaleTimeString()).join(", ")}`);
   }
   const job = {
     id: generateJobId(),
@@ -1755,8 +1832,6 @@ var registerAllRoutes = (app, state, executeJobFn, scheduleJobFn) => {
 };
 
 // src/schedule-plugin/decorator.ts
-import chalk8 from "chalk";
-import logSymbols6 from "log-symbols";
 var isValidJobName = (jobName) => {
   return typeof jobName === "string" && jobName.length > 0 && /^[a-zA-Z0-9_-]+$/.test(jobName);
 };
@@ -1786,7 +1861,7 @@ var createSchedulerManager = ({
       validateJobDefinition(jobDefinition);
       const existingJob = Object.values(state.schedulers).find((s) => s.job.name === jobDefinition.name);
       if (existingJob) {
-        logger.warn(`${logSymbols6.warning} ${chalk8.yellow("Job already exists:")} ${chalk8.magenta(jobDefinition.name)}.`);
+        logger.warn(`Job already exists: ${jobDefinition.name}.`);
         return existingJob.job.id;
       }
       const job = createJobFromDefinition(jobDefinition, config);
@@ -1795,10 +1870,10 @@ var createSchedulerManager = ({
       if (job.enabled) {
         scheduleJobFn(scheduler);
       }
-      logger.info(`${logSymbols6.success} ${chalk8.green("Job added:")} ${chalk8.magenta(jobDefinition.name)} (${job.id})`);
+      logger.info(`Job added: ${jobDefinition.name} (${job.id})`);
       return job.id;
     } catch (error) {
-      logger.error(`${logSymbols6.error} ${chalk8.red("Failed to add job")} ${chalk8.magenta(jobDefinition.name)}: ${error.message}`);
+      logger.error(`Failed to add job ${jobDefinition.name}: ${error.message}`);
       throw error;
     }
   };
@@ -1810,15 +1885,15 @@ var createSchedulerManager = ({
         throw new Error(`Job '${jobName}' does not exist`);
       }
       if (scheduler.isRunning) {
-        logger.warn(`${logSymbols6.warning} ${chalk8.yellow("Removing job that is currently running:")} ${chalk8.magenta(jobName)}`);
+        logger.warn(`Removing job that is currently running: ${jobName}`);
       }
       if (scheduler.timerId) {
         clearTimeout(scheduler.timerId);
       }
       delete state.schedulers[scheduler.job.id];
-      logger.info(`${logSymbols6.success} ${chalk8.green("Job removed:")} ${chalk8.magenta(jobName)}`);
+      logger.info(`Job removed: ${jobName}`);
     } catch (error) {
-      logger.error(`${logSymbols6.error} ${chalk8.red("Failed to remove job")} ${chalk8.magenta(jobName)}: ${error.message}`);
+      logger.error(`Failed to remove job ${jobName}: ${error.message}`);
       throw error;
     }
   };
@@ -1830,8 +1905,8 @@ var createSchedulerManager = ({
       return false;
     }
   };
-  const listJobs = (module2) => {
-    return Object.values(state.schedulers).filter((s) => !module2 || s.job.module === module2).map((s) => s.job.name).sort();
+  const listJobs = (module) => {
+    return Object.values(state.schedulers).filter((s) => !module || s.job.module === module).map((s) => s.job.name).sort();
   };
   const getJobStats = (jobName) => {
     try {
@@ -1850,14 +1925,14 @@ var createSchedulerManager = ({
         throw new Error(`Job '${jobName}' does not exist`);
       }
       if (scheduler.job.enabled) {
-        logger.debug(`${logSymbols6.info} ${chalk8.blue("Job is already enabled:")} ${chalk8.magenta(jobName)}`);
+        logger.debug(`Job is already enabled: ${jobName}`);
         return;
       }
       scheduler.job.enabled = true;
       scheduleJobFn(scheduler);
-      logger.info(`${logSymbols6.success} ${chalk8.green("Job enabled:")} ${chalk8.magenta(jobName)}`);
+      logger.info(`Job enabled: ${jobName}`);
     } catch (error) {
-      logger.error(`${logSymbols6.error} ${chalk8.red("Failed to enable job")} ${chalk8.magenta(jobName)}: ${error.message}`);
+      logger.error(`Failed to enable job ${jobName}: ${error.message}`);
       throw error;
     }
   };
@@ -1869,7 +1944,7 @@ var createSchedulerManager = ({
         throw new Error(`Job '${jobName}' does not exist`);
       }
       if (!scheduler.job.enabled) {
-        logger.debug(`${logSymbols6.info} ${chalk8.blue("Job is already disabled:")} ${chalk8.magenta(jobName)}`);
+        logger.debug(`Job is already disabled: ${jobName}`);
         return;
       }
       scheduler.job.enabled = false;
@@ -1877,9 +1952,9 @@ var createSchedulerManager = ({
         clearTimeout(scheduler.timerId);
         scheduler.timerId = void 0;
       }
-      logger.info(`${logSymbols6.success} ${chalk8.green("Job disabled:")} ${chalk8.magenta(jobName)}`);
+      logger.info(`Job disabled: ${jobName}`);
     } catch (error) {
-      logger.error(`${logSymbols6.error} ${chalk8.red("Failed to disable job")} ${chalk8.magenta(jobName)}: ${error.message}`);
+      logger.error(`Failed to disable job ${jobName}: ${error.message}`);
       throw error;
     }
   };
@@ -1894,9 +1969,9 @@ var createSchedulerManager = ({
         throw new Error(`Job '${jobName}' is already running`);
       }
       setImmediate(() => executeJob(scheduler));
-      logger.info(`${logSymbols6.success} ${chalk8.green("Job triggered:")} ${chalk8.magenta(jobName)}`);
+      logger.info(`Job triggered: ${jobName}`);
     } catch (error) {
-      logger.error(`${logSymbols6.error} ${chalk8.red("Failed to trigger job")} ${chalk8.magenta(jobName)}: ${error.message}`);
+      logger.error(`Failed to trigger job ${jobName}: ${error.message}`);
       throw error;
     }
   };