@cloudnux/local-cloud-provider 0.7.0 → 0.11.0

package/dist/dev-console-plugin/index.js

@@ -1,14 +1,8 @@
-// ../../../node_modules/tsup/assets/esm_shims.js
-import path from "path";
-import { fileURLToPath } from "url";
-var getFilename = () => fileURLToPath(import.meta.url);
-var getDirname = () => path.dirname(getFilename());
-var __dirname = /* @__PURE__ */ getDirname();
-
 // src/dev-console-plugin/plugin.ts
-import path4 from "path";
+import path3 from "path";
 import fastifyStatic from "@fastify/static";
 import fsPlugin3 from "fastify-plugin";
+import { createRequire } from "module";
 
 // src/queue-plugin/plugin.ts
 import fsPlugin from "fastify-plugin";
@@ -693,11 +687,11 @@ function stringToArray(string) {
 var stringToArray_default = stringToArray;
 
 // ../../../node_modules/lodash-es/_hasPath.js
-function hasPath(object, path5, hasFunc) {
-  path5 = castPath_default(path5, object);
-  var index = -1, length = path5.length, result = false;
+function hasPath(object, path4, hasFunc) {
+  path4 = castPath_default(path4, object);
+  var index = -1, length = path4.length, result = false;
   while (++index < length) {
-    var key = toKey_default(path5[index]);
+    var key = toKey_default(path4[index]);
     if (!(result = object != null && hasFunc(object, key))) {
       break;
     }
@@ -720,8 +714,8 @@ function baseHas(object, key) {
 var baseHas_default = baseHas;
 
 // ../../../node_modules/lodash-es/has.js
-function has(object, path5) {
-  return object != null && hasPath_default(object, path5, baseHas_default);
+function has(object, path4) {
+  return object != null && hasPath_default(object, path4, baseHas_default);
 }
 var has_default = has;
 
@@ -878,12 +872,14 @@ var errorToString = (error) => {
 
 // ../../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 ")}${EOL}`,
+        `${chalk.bgRed.white(" fatal ")} - ${module || "unknown module"} - ${requestId || "no request ID"} - ${EOL}`,
         errorToString(message),
         meta ? `${EOL}${JSON.stringify(meta, null, 2)}` : ""
       );
@@ -893,7 +889,7 @@ var logger = {
     if (currentLogLevel >= logLevels.error) {
       console.error(
         `[${(/* @__PURE__ */ new Date()).toTimeString()}]`,
-        `${chalk.bgRed.white(" error ")}${EOL}`,
+        `${chalk.bgRed.white(" error ")} - ${module || "unknown module"} - ${requestId || "no request ID"} - ${EOL}`,
         errorToString(message),
         meta ? `${EOL}${JSON.stringify(meta, null, 2)}` : ""
       );
@@ -903,7 +899,7 @@ var logger = {
     if (currentLogLevel >= logLevels.warn) {
       console.warn(
         `[${(/* @__PURE__ */ new Date()).toTimeString()}]`,
-        `${chalk.bgYellow.black(" warn ")}${EOL}`,
+        `${chalk.bgYellow.black(" warn ")} - ${module || "unknown module"} - ${requestId || "no request ID"} - ${EOL}`,
         errorToString(message),
         meta ? `${EOL}${JSON.stringify(meta, null, 2)}` : ""
       );
@@ -913,7 +909,7 @@ var logger = {
     if (currentLogLevel >= logLevels.info) {
       console.info(
         `[${(/* @__PURE__ */ new Date()).toTimeString()}]`,
-        `${chalk.bgBlue.white(" info ")}${EOL}`,
+        `${chalk.bgBlue.white(" info ")} - ${module || "unknown module"} - ${requestId || "no request ID"} - ${EOL}`,
         message,
         meta ? `${EOL}${JSON.stringify(meta, null, 2)}` : ""
       );
@@ -923,7 +919,7 @@ var logger = {
     if (currentLogLevel >= logLevels.debug) {
       console.debug(
         `[${(/* @__PURE__ */ new Date()).toTimeString()}]`,
-        `${chalk.bgWhite.black(" debug ")}${EOL}`,
+        `${chalk.bgWhite.black(" debug ")} - ${module || "unknown module"} - ${requestId || "no request ID"} - ${EOL}`,
         message,
         meta ? `${EOL}${JSON.stringify(meta, null, 2)}` : ""
       );
@@ -955,15 +951,14 @@ var mergeConfig = (defaultConfig, userConfig) => ({
     ...userConfig?.persistence || {}
   }
 });
-var createQueueService = (handler, module) => ({
+var createQueueService = (handler, module2) => ({
   handler,
   incoming: [],
   processing: [],
   dlq: [],
   timeoutId: null,
   processingBatch: false,
-  activeProcessing: 0,
-  module
+  module: module2
 });
 var createQueueMessage = (body, headers) => {
   const id = Date.now().toString() + Math.random().toString(36).substring(2, 7);
@@ -1009,7 +1004,6 @@ var createQueueSummary = (queueService, config) => ({
   processing: queueService.processing.length,
   dlq: queueService.dlq.length,
   isProcessing: queueService.processingBatch,
-  activeProcessing: queueService.activeProcessing,
   configuration: {
     batchSize: config.batchSize,
     batchWindowMs: config.batchWindowMs,
@@ -1051,7 +1045,7 @@ var logError = (message, messageId, queueName, error) => {
   logger.error(`${logSymbols.error} ${chalk2.red(message)} ${chalk2.yellow(messageId)} in queue ${chalk2.magenta(queueName)}: ${error}`);
 };
 var logRetryScheduled = (messageId, delayMs) => {
-  logger.info(`${chalk2.blue("\u23F1\uFE0F Scheduling retry")} for message ${chalk2.yellow(messageId)} in ${chalk2.cyan(delayMs)}ms`);
+  logger.debug(`${chalk2.blue("\u23F1\uFE0F Scheduling retry")} for message ${chalk2.yellow(messageId)} in ${chalk2.cyan(delayMs)}ms`);
 };
 var logDLQOperation = (operation, count, queueName) => {
   logger.warn(`${logSymbols.warning} ${chalk2.yellow(operation)} ${chalk2.red(count)} messages from DLQ for ${chalk2.green(queueName)}`);
@@ -1084,7 +1078,7 @@ var handleProcessingError = async (queueName, message, queueService, error, conf
     }, delayMs);
   }
 };
-var createBatchProcessor = (processMessage, config, saveQueueState) => async (queueName, queueService) => {
+var createBatchProcessor = (processMessage, config, dirtyQueues) => async (queueName, queueService) => {
   if (queueService.timeoutId) {
     clearTimeout(queueService.timeoutId);
     queueService.timeoutId = null;
@@ -1102,8 +1096,8 @@ var createBatchProcessor = (processMessage, config, saveQueueState) => async (qu
     await Promise.all(messagesToProcess.map((message) => {
       return processMessage(queueName, message, queueService);
     }));
-    if (config.persistence.enabled && saveQueueState) {
-      await saveQueueState(queueName);
+    if (config.persistence.enabled && dirtyQueues) {
+      dirtyQueues.add(queueName);
     }
   } finally {
     queueService.processingBatch = false;
@@ -1129,7 +1123,7 @@ var handleImmediateProcessing = (queueService, config, processBatch, queueName)
 
 // src/queue-plugin/persistence.ts
 import * as fs from "fs/promises";
-import * as path2 from "path";
+import * as path from "path";
 import chalk3 from "chalk";
 import logSymbols2 from "log-symbols";
 var createQueueData = (queueService) => ({
@@ -1145,18 +1139,21 @@ var restoreDates = (messages) => {
     if (msg.failedAt) msg.failedAt = new Date(msg.failedAt);
   });
 };
-var createPersistenceInitializer = (config, loadAllQueueStates, saveAllQueueStates) => async () => {
+var createPersistenceInitializer = (config, loadAllQueueStates, saveDirtyQueueStates, saveAllQueueStates, intervalIdHolder) => async () => {
   try {
     await fs.mkdir(config.persistence.directory, { recursive: true });
     if (config.persistence.loadOnStartup) {
       await loadAllQueueStates();
     }
     if (config.persistence.saveInterval > 0) {
-      setInterval(saveAllQueueStates, config.persistence.saveInterval);
+      intervalIdHolder.id = setInterval(saveDirtyQueueStates, config.persistence.saveInterval);
     }
     if (config.persistence.saveOnShutdown) {
       const shutdownHandler = async () => {
         logger.debug("Saving queue state before shutdown...");
+        if (intervalIdHolder.id) {
+          clearInterval(intervalIdHolder.id);
+        }
         await saveAllQueueStates();
         process.exit(0);
       };
@@ -1165,7 +1162,8 @@ var createPersistenceInitializer = (config, loadAllQueueStates, saveAllQueueStat
     }
     logger.debug(`${logSymbols2.success} ${chalk3.green("Queue persistence initialized:")} ${chalk3.yellow(config.persistence.directory)}`);
   } catch (error) {
-    logger.error(`${logSymbols2.error} ${chalk3.red("Failed to initialize queue persistence:")} ${chalk3.yellow(error.message)}`);
+    console.log("[logger]", logger);
+    logger.error(`${logSymbols2.error} ${chalk3.red("Failed to initialize queue persistence:")} ${chalk3.yellow(error?.message)}`);
   }
 };
 var createQueueStateSaver = (config) => async (queueName, queueService) => {
@@ -1173,13 +1171,13 @@ var createQueueStateSaver = (config) => async (queueName, queueService) => {
     if (!queueService) return;
     const queueData = createQueueData(queueService);
     const now = Date.now();
-    const queueFilePath = path2.join(config.persistence.directory, `${queueName}.json`);
-    const tempFilePath = path2.join(config.persistence.directory, `${queueName}.${now}temp.json`);
+    const queueFilePath = path.join(config.persistence.directory, `${queueName}.json`);
+    const tempFilePath = path.join(config.persistence.directory, `${queueName}.${now}temp.json`);
     await fs.writeFile(tempFilePath, JSON.stringify(queueData, null, 2), "utf8");
     await fs.rename(tempFilePath, queueFilePath);
-    logger.info(`${logSymbols2.info} ${chalk3.blue("Queue state saved:")} ${chalk3.green(queueName)}`);
+    logger.debug(`${logSymbols2.info} ${chalk3.blue("Queue state saved:")} ${chalk3.green(queueName)}`);
   } catch (error) {
-    logger.error(`Failed to save queue state for ${queueName}:`, error);
+    logger.error(`Failed to save queue state for ${queueName}:`, error?.message);
   }
 };
 var createAllQueuesStateSaver = (config, saveQueueState) => (queues) => async () => {
@@ -1189,7 +1187,21 @@ var createAllQueuesStateSaver = (config, saveQueueState) => (queues) => async ()
     }
     logger.debug(`${logSymbols2.success} ${chalk3.green("All queue states saved to")} ${chalk3.yellow(config.persistence.directory)}`);
   } catch (error) {
-    logger.error(`${logSymbols2.error} ${chalk3.red("Failed to save all queue states:")} ${chalk3.yellow(error.message)}`);
+    logger.error(`${logSymbols2.error} ${chalk3.red("Failed to save all queue states:")} ${chalk3.yellow(error?.message)}`);
+  }
+};
+var createDirtyQueuesStateSaver = (saveQueueState, dirtyQueues) => (queues) => async () => {
+  if (dirtyQueues.size === 0) return;
+  try {
+    const queueNames = [...dirtyQueues];
+    dirtyQueues.clear();
+    for (const queueName of queueNames) {
+      if (queues[queueName]) {
+        await saveQueueState(queueName, queues[queueName]);
+      }
+    }
+  } catch (error) {
+    logger.error(`${logSymbols2.error} ${chalk3.red("Failed to save dirty queue states:")} ${chalk3.yellow(error?.message)}`);
   }
 };
 var createQueueStateLoader = (config, scheduleProcessing, processMessage) => (queues) => async (queueName) => {
@@ -1198,7 +1210,7 @@ var createQueueStateLoader = (config, scheduleProcessing, processMessage) => (qu
       logger.warn(`Skipping load for non-existent queue: ${queueName}`);
       return;
     }
-    const queueFilePath = path2.join(config.persistence.directory, `${queueName}.json`);
+    const queueFilePath = path.join(config.persistence.directory, `${queueName}.json`);
     try {
       const data = await fs.readFile(queueFilePath, "utf8");
       const queueData = JSON.parse(data);
@@ -1228,7 +1240,7 @@ var createQueueStateLoader = (config, scheduleProcessing, processMessage) => (qu
       }
     }
   } catch (error) {
-    logger.error(`Failed to load queue state for ${queueName}:`, error);
+    logger.error(`Failed to load queue state for ${queueName}:`, error?.message);
   }
 };
 var createAllQueuesStateLoader = (config, loadQueueState) => async () => {
@@ -1236,12 +1248,12 @@ var createAllQueuesStateLoader = (config, loadQueueState) => async () => {
     const files = await fs.readdir(config.persistence.directory);
     const queueFiles = files.filter((file) => file.endsWith(".json") && !file.includes(".temp."));
     for (const file of queueFiles) {
-      const queueName = path2.basename(file, ".json");
+      const queueName = path.basename(file, ".json");
       await loadQueueState(queueName);
     }
     logger.debug("All queue states loaded");
   } catch (error) {
-    logger.error("Failed to load queue states:", error);
+    logger.error("Failed to load queue states:", error?.message);
   }
 };
 
@@ -1309,6 +1321,7 @@ var isValidQueueName = (queueName) => {
 var createQueueManager = ({
   config,
   queues,
+  dirtyQueues,
   saveQueueState,
   loadQueueState,
   scheduleProcessing,
@@ -1327,7 +1340,7 @@ var createQueueManager = ({
       throw new Error("Handler must be a function");
     }
   };
-  const addQueue = async (queueName, handler, module) => {
+  const addQueue = async (queueName, handler, module2) => {
     try {
       validateQueueName(queueName);
       validateHandler(handler);
@@ -1335,7 +1348,7 @@ var createQueueManager = ({
         logger.warn(`${logSymbols3.warning} ${chalk4.yellow("Queue already exists:")} ${chalk4.magenta(queueName)}.`);
         return;
       }
-      queues[queueName] = createQueueService(handler, module);
+      queues[queueName] = createQueueService(handler, module2);
       if (config.persistence.enabled && loadQueueState) {
         await loadQueueState(queueName);
       }
@@ -1377,10 +1390,10 @@ var createQueueManager = ({
       return false;
     }
   };
-  const listQueues = (module) => {
+  const listQueues = (module2) => {
     return Object.keys(queues).filter((queueName) => {
       const queueService = queues[queueName];
-      return !module || queueService.module === module;
+      return !module2 || queueService.module === module2;
     }).sort();
   };
   const getQueueStats = (queueName) => {
@@ -1419,8 +1432,8 @@ var createQueueManager = ({
     queues[queueName].incoming.push(message);
     scheduleProcessing(queueName, queues[queueName]);
     handleImmediateProcessing(queues[queueName], config, processBatch, queueName);
-    if (config.persistence.enabled && saveQueueState) {
-      await saveQueueState(queueName, queues[queueName]);
+    if (config.persistence.enabled) {
+      dirtyQueues.add(queueName);
     }
     return {
       id: message.id,
@@ -1441,8 +1454,8 @@ var createQueueManager = ({
     }
     logDLQOperation("Moving", processedCount, queueName);
     scheduleProcessing(queueName, queues[queueName]);
-    if (saveQueueState) {
-      await saveQueueState(queueName, queues[queueName]);
+    if (config.persistence.enabled) {
+      dirtyQueues.add(queueName);
     }
     return {
       status: "success",
@@ -1463,8 +1476,8 @@ var createQueueManager = ({
       };
     }
     logDLQOperation("Purging", purgedCount, queueName);
-    if (saveQueueState) {
-      await saveQueueState(queueName, queues[queueName]);
+    if (config.persistence.enabled) {
+      dirtyQueues.add(queueName);
     }
     return {
       status: "success",
@@ -1495,14 +1508,18 @@ var createQueueDecorator = (queueManager) => (app) => {
 var queuesPlugin = fsPlugin(async (app, options) => {
   const config = mergeConfig(DEFAULT_CONFIG, options.config);
   const queues = {};
+  const dirtyQueues = /* @__PURE__ */ new Set();
+  const intervalIdHolder = {};
   const processMessage = createProcessMessageHandler(config);
   const saveQueueState = config.persistence.enabled ? createQueueStateSaver(config) : void 0;
   const saveAllQueueStates = config.persistence.enabled && saveQueueState ? createAllQueuesStateSaver(config, saveQueueState)(queues) : async () => {
   };
+  const saveDirtyQueueStates = config.persistence.enabled && saveQueueState ? createDirtyQueuesStateSaver(saveQueueState, dirtyQueues)(queues) : async () => {
+  };
   const processBatch = createBatchProcessor(
     processMessage,
     config,
-    saveQueueState ? (queueName) => saveQueueState(queueName, queues[queueName]) : void 0
+    config.persistence.enabled ? dirtyQueues : void 0
   );
   const scheduleProcessing = createProcessingScheduler(processBatch, config);
   const loadQueueState = config.persistence.enabled ? createQueueStateLoader(
@@ -1513,11 +1530,12 @@ var queuesPlugin = fsPlugin(async (app, options) => {
   };
   const loadAllQueueStates = config.persistence.enabled ? createAllQueuesStateLoader(config, loadQueueState) : async () => {
   };
-  const initializePersistence = config.persistence.enabled ? createPersistenceInitializer(config, loadAllQueueStates, saveAllQueueStates) : async () => {
+  const initializePersistence = config.persistence.enabled ? createPersistenceInitializer(config, loadAllQueueStates, saveDirtyQueueStates, saveAllQueueStates, intervalIdHolder) : async () => {
   };
   const queueManager = createQueueManager({
     config,
     queues,
+    dirtyQueues,
     saveQueueState: saveQueueState ? (queueName) => saveQueueState(queueName, queues[queueName]) : void 0,
     loadQueueState,
     scheduleProcessing,
@@ -1921,17 +1939,22 @@ var scheduleJob = (scheduler, state, executeJobFn) => {
     updatedScheduler.timerId = setTimeout(() => {
       executeJobFn(updatedScheduler);
     }, timeUntilNextRun);
-    logger.info(`${chalk6.blue("\u{1F4C5} Scheduled job")} ${chalk6.green(scheduler.job.name)} to run in ${chalk6.cyan(Math.round(timeUntilNextRun / 1e3))}s`);
+    logger.debug(`${chalk6.blue("\u{1F4C5} Scheduled job")} ${chalk6.green(scheduler.job.name)} to run in ${chalk6.cyan(Math.round(timeUntilNextRun / 1e3))}s`);
   }
   return updatedScheduler;
 };
 var executeJobWithTimeout = async (handler, job, execution, timeoutMs) => {
-  return Promise.race([
-    handler(job, execution),
-    new Promise(
-      (_, reject) => setTimeout(() => reject(new Error("Job execution timeout")), timeoutMs)
-    )
-  ]);
+  let timerId;
+  try {
+    return await Promise.race([
+      handler(job, execution),
+      new Promise((_, reject) => {
+        timerId = setTimeout(() => reject(new Error("Job execution timeout")), timeoutMs);
+      })
+    ]);
+  } finally {
+    clearTimeout(timerId);
+  }
 };
 var updateJobAfterExecution = (job, execution, config) => {
   const updatedJob = {
@@ -1956,11 +1979,11 @@ var handleExecutionSuccess = (execution, result) => {
 
 // src/schedule-plugin/persistence.ts
 import * as fs2 from "fs/promises";
-import * as path3 from "path";
+import * as path2 from "path";
 import chalk7 from "chalk";
 import logSymbols5 from "log-symbols";
-var createStateFilePath = (directory) => path3.join(directory, "scheduler-state.json");
-var createTempFilePath = (directory) => path3.join(directory, `scheduler-state.${Date.now()}.temp.json`);
+var createStateFilePath = (directory) => path2.join(directory, "scheduler-state.json");
+var createTempFilePath = (directory) => path2.join(directory, `scheduler-state.${Date.now()}.temp.json`);
 var serializeSchedulerState = (schedulers, executionHistory) => ({
   jobs: Object.values(schedulers).map((s) => s.job),
   executions: executionHistory.slice(-100),
@@ -1974,7 +1997,7 @@ var saveSchedulerState = async (state) => {
     const tempFile = createTempFilePath(state.config.persistence.directory);
     await fs2.writeFile(tempFile, JSON.stringify(serializedState, null, 2), "utf8");
     await fs2.rename(tempFile, stateFile);
-    logger.info(`${logSymbols5.info} ${chalk7.blue("Enhanced scheduler state saved")}`);
+    logger.debug(`${logSymbols5.info} ${chalk7.blue("Enhanced scheduler state saved")}`);
   } catch (error) {
     logger.error("Failed to save scheduler state:", error);
   }
@@ -1986,7 +2009,7 @@ var loadSchedulerStateData = async (directory) => {
     return JSON.parse(data);
   } catch (error) {
     if (error.code === "ENOENT") {
-      logger.info(`${chalk7.blue("No previous scheduler state found - starting fresh")}`);
+      logger.debug(`${chalk7.blue("No previous scheduler state found - starting fresh")}`);
     } else {
       logger.error("Failed to load scheduler state:", error);
     }
@@ -1999,20 +2022,20 @@ var validateAndAdjustNextRun = (job, savedNextRun, lastRestartTime, config) => {
     return calculateNextRunFromLastRun(job, job.lastRun, config);
   }
   if (savedNextRun <= now) {
-    logger.info(`${chalk7.yellow("\u23F0 Saved next run is in the past for")} ${chalk7.green(job.name)} - recalculating`);
+    logger.debug(`${chalk7.yellow("\u23F0 Saved next run is in the past for")} ${chalk7.green(job.name)} - recalculating`);
     return calculateNextRunFromLastRun(job, job.lastRun, config);
   }
   const timeSinceRestart = now.getTime() - lastRestartTime.getTime();
   const isRapidRestart = timeSinceRestart < config.restartBehavior.rapidRestartThreshold;
   if (isRapidRestart) {
-    logger.info(`${chalk7.blue("\u26A1 Rapid restart detected for")} ${chalk7.green(job.name)} - preserving saved timing`);
+    logger.debug(`${chalk7.blue("\u26A1 Rapid restart detected for")} ${chalk7.green(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.info(`${chalk7.yellow("\u{1F527} Adjusting timing for")} ${chalk7.green(job.name)} - drift of ${Math.round(timeDiff / 1e3)}s detected`);
+      logger.debug(`${chalk7.yellow("\u{1F527} Adjusting timing for")} ${chalk7.green(job.name)} - drift of ${Math.round(timeDiff / 1e3)}s detected`);
       return expectedNextRun;
     }
   }
@@ -2026,7 +2049,7 @@ var restoreJobFromSavedData = (scheduler, savedJob, config, lastRestartTime) =>
     lastRun: savedJob.lastRun ? new Date(savedJob.lastRun) : void 0
   };
   if (definitionChanged) {
-    logger.info(`${chalk7.yellow("\u{1F504} Job definition changed:")} ${chalk7.green(savedJob.name)} - recalculating schedule`);
+    logger.debug(`${chalk7.yellow("\u{1F504} Job definition changed:")} ${chalk7.green(savedJob.name)} - recalculating schedule`);
     updatedJob.nextRun = calculateNextRunFromLastRun(updatedJob, updatedJob.lastRun, config);
   } else {
     const savedNextRun = savedJob.nextRun ? new Date(savedJob.nextRun) : void 0;
@@ -2036,7 +2059,7 @@ var restoreJobFromSavedData = (scheduler, savedJob, config, lastRestartTime) =>
     const result = parseCronExpression(updatedJob.cronExpression, updatedJob.lastRun, {
       timezone: updatedJob.timezone
     });
-    logger.info(`${chalk7.blue("\u{1F4C5} Job restored:")} ${chalk7.green(savedJob.name)} - ${result.description} - next: ${chalk7.cyan(updatedJob.nextRun.toLocaleString())}`);
+    logger.debug(`${chalk7.blue("\u{1F4C5} Job restored:")} ${chalk7.green(savedJob.name)} - ${result.description} - next: ${chalk7.cyan(updatedJob.nextRun.toLocaleString())}`);
   }
   return { ...scheduler, job: updatedJob };
 };
@@ -2079,16 +2102,11 @@ var cleanupExecutionHistory = (state) => {
       0,
       state.executionHistory.length - state.config.cleanup.maxExecutionHistory
     );
-    logger.info(`${chalk8.blue("\u{1F9F9} Cleaned up")} ${removed.length} old execution records`);
+    logger.debug(`${chalk8.blue("\u{1F9F9} Cleaned up")} ${removed.length} old execution records`);
     return removed;
   }
   return [];
 };
-var startCleanupInterval = (state) => {
-  return setInterval(() => {
-    cleanupExecutionHistory(state);
-  }, state.config.cleanup.cleanupInterval);
-};
 
 // src/schedule-plugin/core.ts
 var DEFAULT_CONFIG2 = {
@@ -2140,6 +2158,8 @@ var createInitialState = (config) => {
     executionHistory: [],
     isShuttingDown: false,
     runningExecutions: 0,
+    isDirty: false,
+    lastCleanupTime: Date.now(),
     lastRestartTime: /* @__PURE__ */ new Date(),
     config
   };
@@ -2172,18 +2192,18 @@ var createSchedulerFunctions = (state) => {
       );
       const completedExecution = handleExecutionSuccess(execution, result);
       state.executions[execution.id] = completedExecution;
-      scheduler.job = updateJobAfterExecution(scheduler.job, execution, state.config);
     } catch (error) {
       const failedExecution = handleExecutionError(execution, error);
       state.executions[execution.id] = failedExecution;
     } finally {
       scheduler.isRunning = false;
       state.runningExecutions--;
+      scheduler.job = updateJobAfterExecution(scheduler.job, execution, state.config);
       if (scheduler.job.enabled && !state.isShuttingDown) {
         scheduleJobFn(scheduler);
       }
       if (state.config.persistence.enabled) {
-        await saveSchedulerState(state);
+        state.isDirty = true;
       }
     }
   };
@@ -2205,11 +2225,18 @@ var initializeScheduler = async (state, scheduleJobFn) => {
       );
       state.schedulers = schedulers;
       state.executionHistory = executionHistory;
-      if (state.config.persistence.saveInterval > 0) {
-        setInterval(() => saveSchedulerState(state), state.config.persistence.saveInterval);
-      }
     }
-    state.cleanupInterval = startCleanupInterval(state);
+    const tickInterval = state.config.persistence.saveInterval > 0 ? state.config.persistence.saveInterval : state.config.cleanup.cleanupInterval;
+    state.tickInterval = setInterval(async () => {
+      if (state.isDirty && state.config.persistence.enabled) {
+        state.isDirty = false;
+        await saveSchedulerState(state);
+      }
+      if (Date.now() - state.lastCleanupTime >= state.config.cleanup.cleanupInterval) {
+        state.lastCleanupTime = Date.now();
+        cleanupExecutionHistory(state);
+      }
+    }, tickInterval);
     for (const scheduler of Object.values(state.schedulers)) {
       if (scheduler.job.enabled) {
         scheduleJobFn(scheduler);
@@ -2240,11 +2267,11 @@ var createJobFromDefinition = (jobDef, config) => {
     const result = parseCronExpression(cronExpression, void 0, {
       timezone: jobDef.timezone ?? config.cron.defaultTimezone
     });
-    logger.info(`${chalk10.blue("\u{1F4C5} Job")} ${chalk10.green(jobDef.name)}: ${result.description} - Next: ${chalk10.cyan(result.nextRun.toLocaleString())}`);
+    logger.debug(`${chalk10.blue("\u{1F4C5} Job")} ${chalk10.green(jobDef.name)}: ${result.description} - Next: ${chalk10.cyan(result.nextRun.toLocaleString())}`);
     const upcoming = getNextExecutions(cronExpression, 3, {
       timezone: jobDef.timezone ?? config.cron.defaultTimezone
     });
-    logger.info(`${chalk10.blue("   Upcoming:")} ${upcoming.map((d) => d.toLocaleTimeString()).join(", ")}`);
+    logger.debug(`${chalk10.blue("   Upcoming:")} ${upcoming.map((d) => d.toLocaleTimeString()).join(", ")}`);
   }
   const job = {
     id: generateJobId(),
@@ -2308,19 +2335,19 @@ var createExecutionsData = (state) => ({
   running: Object.values(state.executions).filter((e) => e.status === "running")
 });
 var registerDashboardRoute = (app, state) => {
-  app.get("/dashboard", async function(_, reply) {
+  app.get("/schedule/dashboard", async function(_, reply) {
     const dashboardData = createDashboardData(state);
     return reply.status(200).send(dashboardData);
   });
 };
 var registerExecutionsRoute = (app, state) => {
-  app.get("/executions", async function(_, reply) {
+  app.get("/schedule/executions", async function(_, reply) {
     const executionsData = createExecutionsData(state);
     return reply.status(200).send(executionsData);
   });
 };
 var registerTriggerJobRoute = (app, state, executeJobFn) => {
-  app.post("/jobs/:jobId/trigger", async function(request, reply) {
+  app.post("/schedule/jobs/:jobId/trigger", async function(request, reply) {
     const scheduler = state.schedulers[request.params.jobId];
     if (!scheduler) {
       return reply.status(404).send({ error: "Job not found" });
@@ -2333,7 +2360,7 @@ var registerTriggerJobRoute = (app, state, executeJobFn) => {
   });
 };
 var registerEnableJobRoute = (app, state, scheduleJobFn) => {
-  app.put("/jobs/:jobId/enable", async function(request, reply) {
+  app.put("/schedule/jobs/:jobId/enable", async function(request, reply) {
     const scheduler = state.schedulers[request.params.jobId];
     if (!scheduler) {
       return reply.status(404).send({ error: "Job not found" });
@@ -2345,7 +2372,7 @@ var registerEnableJobRoute = (app, state, scheduleJobFn) => {
   });
 };
 var registerDisableJobRoute = (app, state) => {
-  app.put("/jobs/:jobId/disable", async function(request, reply) {
+  app.put("/schedule/jobs/:jobId/disable", async function(request, reply) {
     const scheduler = state.schedulers[request.params.jobId];
     if (!scheduler) {
       return reply.status(404).send({ error: "Job not found" });
@@ -2439,8 +2466,8 @@ var createSchedulerManager = ({
       return false;
     }
   };
-  const listJobs = (module) => {
-    return Object.values(state.schedulers).filter((s) => !module || s.job.module === module).map((s) => s.job.name).sort();
+  const listJobs = (module2) => {
+    return Object.values(state.schedulers).filter((s) => !module2 || s.job.module === module2).map((s) => s.job.name).sort();
   };
   const getJobStats = (jobName) => {
     try {
@@ -2459,7 +2486,7 @@ var createSchedulerManager = ({
         throw new Error(`Job '${jobName}' does not exist`);
       }
       if (scheduler.job.enabled) {
-        logger.info(`${logSymbols9.info} ${chalk11.blue("Job is already enabled:")} ${chalk11.magenta(jobName)}`);
+        logger.debug(`${logSymbols9.info} ${chalk11.blue("Job is already enabled:")} ${chalk11.magenta(jobName)}`);
         return;
       }
       scheduler.job.enabled = true;
@@ -2478,7 +2505,7 @@ var createSchedulerManager = ({
         throw new Error(`Job '${jobName}' does not exist`);
       }
       if (!scheduler.job.enabled) {
-        logger.info(`${logSymbols9.info} ${chalk11.blue("Job is already disabled:")} ${chalk11.magenta(jobName)}`);
+        logger.debug(`${logSymbols9.info} ${chalk11.blue("Job is already disabled:")} ${chalk11.magenta(jobName)}`);
         return;
       }
       scheduler.job.enabled = false;
@@ -2579,6 +2606,7 @@ var RouteRegistry = class {
 var routeRegistry = new RouteRegistry();
 
 // src/dev-console-plugin/plugin.ts
+var require2 = createRequire(import.meta.url);
 var LogStore = class {
   logs = [];
   maxLogs = 1e3;
@@ -2596,8 +2624,8 @@ var LogStore = class {
   getLogsByLevel(level, limit = 100) {
     return this.logs.filter((log) => log.level === level).slice(0, limit);
   }
-  getLogsByModule(module, limit = 100) {
-    return this.logs.filter((log) => log.module === module).slice(0, limit);
+  getLogsByModule(module2, limit = 100) {
+    return this.logs.filter((log) => log.module === module2).slice(0, limit);
   }
   getLogsByTrigger(triggerType, triggerName, limit = 100) {
     return this.logs.filter(
@@ -2627,7 +2655,7 @@ var captureConsoleLog = (level, originalMethod) => {
     originalMethod.apply(console, args);
     const message = args.join(" ");
     let source = "unknown";
-    let module;
+    let module2;
     let trigger;
     let triggerType;
     if (message.includes("Queue") || message.includes("queue")) {
@@ -2647,7 +2675,7 @@ var captureConsoleLog = (level, originalMethod) => {
       if (routeMatch) trigger = routeMatch[0];
     }
     const moduleMatch = message.match(/module[:\s]+([a-zA-Z0-9_-]+)/i) || message.match(/\[([a-zA-Z0-9_-]+)\]/) || message.match(/in\s+([a-zA-Z0-9_-]+)\s+module/i);
-    if (moduleMatch) module = moduleMatch[1];
+    if (moduleMatch) module2 = moduleMatch[1];
     logStore.addLog({
       id: Date.now().toString() + Math.random().toString(36).substr(2, 9),
       timestamp: /* @__PURE__ */ new Date(),
@@ -2655,7 +2683,7 @@ var captureConsoleLog = (level, originalMethod) => {
       message: message.replace(/\x1b\[[0-9;]*m/g, ""),
       // Remove ANSI colors
       source,
-      module,
+      module: module2,
       trigger,
       triggerType
     });
@@ -2855,7 +2883,7 @@ async function devConsolePluginFunction(fastify, options = {}) {
     }
   });
   fastify.post(`/${prefix}/queues`, async (request, reply) => {
-    const { queueName, module } = request.body;
+    const { queueName, module: module2 } = request.body;
     const queueManager = fastify.queues;
     if (!queueManager) {
       return reply.status(503).send({ error: "Queue service not available" });
@@ -2867,7 +2895,7 @@ async function devConsolePluginFunction(fastify, options = {}) {
       const handler = async (message) => {
         console.log(`Processing message in ${queueName}:`, message);
       };
-      await queueManager.addQueue(queueName, handler, module);
+      await queueManager.addQueue(queueName, handler, module2);
       return reply.status(201).send({
         status: "success",
         message: `Queue ${queueName} created successfully`,
@@ -2968,7 +2996,7 @@ async function devConsolePluginFunction(fastify, options = {}) {
       limit = 100,
       level,
       source,
-      module,
+      module: module2,
       trigger,
       triggerType
     } = request.query;
@@ -2979,9 +3007,9 @@ async function devConsolePluginFunction(fastify, options = {}) {
     if (source) {
       logs = logs.filter((log) => log.source === source);
     }
-    if (module) {
+    if (module2) {
       logs = logs.filter(
-        (log) => log.module === module || log.message.toLowerCase().includes(module.toLowerCase())
+        (log) => log.module === module2 || log.message.toLowerCase().includes(module2.toLowerCase())
       );
     }
     if (trigger && triggerType) {
@@ -3014,7 +3042,9 @@ async function devConsolePluginFunction(fastify, options = {}) {
     });
   });
   if (enableUI) {
-    const devConsolePath = path4.resolve(__dirname, "../../../packages/dev-console/dist");
+    const devConsolePath = path3.dirname(
+      require2.resolve("@cloudnux/dev-console/dist/index.html")
+    );
     await fastify.register(fastifyStatic, {
       root: devConsolePath,
       decorateReply: true