@cloudnux/local-cloud-provider 0.11.0 → 0.14.0

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

@@ -1,15 +1,6 @@
-// src/dev-console-plugin/plugin.ts
-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";
-
-// src/queue-plugin/core.ts
-import chalk2 from "chalk";
-import logSymbols 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;
@@ -457,8 +448,8 @@ ListCache.prototype.set = listCacheSet_default;
 var ListCache_default = ListCache;
 
 // ../../../node_modules/lodash-es/_Map.js
-var Map = getNative_default(root_default, "Map");
-var Map_default = Map;
+var Map2 = getNative_default(root_default, "Map");
+var Map_default = Map2;
 
 // ../../../node_modules/lodash-es/_mapCacheClear.js
 function mapCacheClear() {
@@ -833,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";
@@ -856,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)}]`;
     }
@@ -870,62 +882,136 @@ var errorToString = (error) => {
   return String(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 ")} - ${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)}` : ""
-      );
-    }
-  }
+// ../../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 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/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/dev-console-plugin/plugin.ts
+import path3 from "path";
+import fastifyStatic from "@fastify/static";
+import fsPlugin4 from "fastify-plugin";
+import { createRequire } from "module";
+
+// src/queue-plugin/plugin.ts
+import fsPlugin from "fastify-plugin";
 
 // src/queue-plugin/core.ts
 var DEFAULT_CONFIG = {
@@ -951,14 +1037,14 @@ var mergeConfig = (defaultConfig, userConfig) => ({
     ...userConfig?.persistence || {}
   }
 });
-var createQueueService = (handler, module2) => ({
+var createQueueService = (handler, module) => ({
   handler,
   incoming: [],
   processing: [],
   dlq: [],
   timeoutId: null,
   processingBatch: false,
-  module: module2
+  module
 });
 var createQueueMessage = (body, headers) => {
   const id = Date.now().toString() + Math.random().toString(36).substring(2, 7);
@@ -1039,32 +1125,36 @@ var purgeDLQ = (queueService) => {
   return dlqCount;
 };
 var logSuccess = (message, messageId, queueName) => {
-  logger.debug(`${logSymbols.success} ${chalk2.green(message)} ${chalk2.yellow(messageId)} in queue ${chalk2.magenta(queueName)}`);
+  logger.debug(`Success: ${message} ${messageId} in queue ${queueName}`);
 };
 var logError = (message, messageId, queueName, error) => {
-  logger.error(`${logSymbols.error} ${chalk2.red(message)} ${chalk2.yellow(messageId)} in queue ${chalk2.magenta(queueName)}: ${error}`);
+  logger.error(`Error: ${message} ${messageId} in queue ${queueName}: ${error}`);
 };
 var logRetryScheduled = (messageId, delayMs) => {
-  logger.debug(`${chalk2.blue("\u23F1\uFE0F Scheduling retry")} for message ${chalk2.yellow(messageId)} in ${chalk2.cyan(delayMs)}ms`);
+  logger.debug(`Scheduling retry for message ${messageId} in ${delayMs}ms`);
 };
 var logDLQOperation = (operation, count, queueName) => {
-  logger.warn(`${logSymbols.warning} ${chalk2.yellow(operation)} ${chalk2.red(count)} messages from DLQ for ${chalk2.green(queueName)}`);
+  logger.warn(`${operation} ${count} messages from DLQ for ${queueName}`);
 };
 
 // src/queue-plugin/processing.ts
 var createProcessMessageHandler = (config) => async (queueName, message, queueService) => {
   try {
-    await queueService.handler(message);
-    removeFromProcessing(queueService, message.id);
-    logSuccess("Successfully processed message", message.id, queueName);
-  } catch (error) {
-    await handleProcessingError(queueName, message, queueService, error, config);
+    const result = await queueService.handler(message);
+    if (result?.failureId) {
+      await handleProcessingError(queueName, message, queueService, config);
+    } else {
+      removeFromProcessing(queueService, message.id);
+      logSuccess("Successfully processed message", message.id, queueName);
+    }
+  } catch {
+    await handleProcessingError(queueName, message, queueService, config);
   }
 };
-var handleProcessingError = async (queueName, message, queueService, error, config) => {
-  logError("Error processing message", message.id, queueName, error.message);
+var handleProcessingError = async (queueName, message, queueService, config) => {
+  logError("Error processing message", message.id, queueName, "handler returned failure");
   if (message.attempts >= config.maxRetries) {
-    moveToDLQ(queueService, message, error.message);
+    moveToDLQ(queueService, message, "max retries exceeded");
     return;
   }
   const updatedMessage = incrementAttempts(queueService, message.id);
@@ -1124,8 +1214,6 @@ var handleImmediateProcessing = (queueService, config, processBatch, queueName)
 // src/queue-plugin/persistence.ts
 import * as fs from "fs/promises";
 import * as path from "path";
-import chalk3 from "chalk";
-import logSymbols2 from "log-symbols";
 var createQueueData = (queueService) => ({
   incoming: queueService.incoming,
   processing: queueService.processing,
@@ -1160,10 +1248,9 @@ var createPersistenceInitializer = (config, loadAllQueueStates, saveDirtyQueueSt
       process.on("SIGINT", shutdownHandler);
       process.on("SIGTERM", shutdownHandler);
     }
-    logger.debug(`${logSymbols2.success} ${chalk3.green("Queue persistence initialized:")} ${chalk3.yellow(config.persistence.directory)}`);
+    logger.debug(`Queue persistence initialized: ${config.persistence.directory}`);
   } catch (error) {
-    console.log("[logger]", logger);
-    logger.error(`${logSymbols2.error} ${chalk3.red("Failed to initialize queue persistence:")} ${chalk3.yellow(error?.message)}`);
+    logger.error(`Failed to initialize queue persistence: ${error?.message}`);
   }
 };
 var createQueueStateSaver = (config) => async (queueName, queueService) => {
@@ -1175,7 +1262,7 @@ var createQueueStateSaver = (config) => async (queueName, queueService) => {
     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.debug(`${logSymbols2.info} ${chalk3.blue("Queue state saved:")} ${chalk3.green(queueName)}`);
+    logger.debug(`Queue state saved: ${queueName}`);
   } catch (error) {
     logger.error(`Failed to save queue state for ${queueName}:`, error?.message);
   }
@@ -1185,9 +1272,9 @@ var createAllQueuesStateSaver = (config, saveQueueState) => (queues) => async ()
     for (const [queueName, queueService] of Object.entries(queues)) {
       await saveQueueState(queueName, queueService);
     }
-    logger.debug(`${logSymbols2.success} ${chalk3.green("All queue states saved to")} ${chalk3.yellow(config.persistence.directory)}`);
+    logger.debug(`All queue states saved to ${config.persistence.directory}`);
   } catch (error) {
-    logger.error(`${logSymbols2.error} ${chalk3.red("Failed to save all queue states:")} ${chalk3.yellow(error?.message)}`);
+    logger.error(`Failed to save all queue states: ${error?.message}`);
   }
 };
 var createDirtyQueuesStateSaver = (saveQueueState, dirtyQueues) => (queues) => async () => {
@@ -1201,7 +1288,7 @@ var createDirtyQueuesStateSaver = (saveQueueState, dirtyQueues) => (queues) => a
       }
     }
   } catch (error) {
-    logger.error(`${logSymbols2.error} ${chalk3.red("Failed to save dirty queue states:")} ${chalk3.yellow(error?.message)}`);
+    logger.error(`Failed to save dirty queue states: ${error?.message}`);
   }
 };
 var createQueueStateLoader = (config, scheduleProcessing, processMessage) => (queues) => async (queueName) => {
@@ -1313,8 +1400,6 @@ var registerQueueRoutes = (app, prefix = "") => {
 };
 
 // src/queue-plugin/decorator.ts
-import chalk4 from "chalk";
-import logSymbols3 from "log-symbols";
 var isValidQueueName = (queueName) => {
   return typeof queueName === "string" && queueName.length > 0 && /^[a-zA-Z0-9_-]+$/.test(queueName);
 };
@@ -1340,21 +1425,21 @@ var createQueueManager = ({
       throw new Error("Handler must be a function");
     }
   };
-  const addQueue = async (queueName, handler, module2) => {
+  const addQueue = async (queueName, handler, module) => {
     try {
       validateQueueName(queueName);
       validateHandler(handler);
       if (queues[queueName]) {
-        logger.warn(`${logSymbols3.warning} ${chalk4.yellow("Queue already exists:")} ${chalk4.magenta(queueName)}.`);
+        logger.warn(`Queue already exists: ${queueName}.`);
         return;
       }
-      queues[queueName] = createQueueService(handler, module2);
+      queues[queueName] = createQueueService(handler, module);
       if (config.persistence.enabled && loadQueueState) {
         await loadQueueState(queueName);
       }
-      logger.info(`${logSymbols3.success} ${chalk4.green("Queue added:")} ${chalk4.magenta(queueName)}`);
+      logger.info(`Queue added: ${queueName}`);
     } catch (error) {
-      logger.error(`${logSymbols3.error} ${chalk4.red("Failed to add queue")} ${chalk4.magenta(queueName)}: ${error.message}`);
+      logger.error(`Failed to add queue ${queueName}: ${error.message}`);
       throw error;
     }
   };
@@ -1367,7 +1452,7 @@ var createQueueManager = ({
       const queueService = queues[queueName];
       const totalMessages = queueService.incoming.length + queueService.processing.length;
       if (totalMessages > 0) {
-        logger.warn(`${logSymbols3.warning} ${chalk4.yellow("Removing queue with")} ${chalk4.red(totalMessages)} ${chalk4.yellow("pending messages:")} ${chalk4.magenta(queueName)}`);
+        logger.warn(`Removing queue with ${totalMessages} pending messages: ${queueName}`);
       }
       if (queueService.timeoutId) {
         clearTimeout(queueService.timeoutId);
@@ -1376,9 +1461,9 @@ var createQueueManager = ({
         await saveQueueState(queueName, queueService);
       }
       delete queues[queueName];
-      logger.info(`${logSymbols3.success} ${chalk4.green("Queue removed:")} ${chalk4.magenta(queueName)}`);
+      logger.info(`Queue removed: ${queueName}`);
     } catch (error) {
-      logger.error(`${logSymbols3.error} ${chalk4.red("Failed to remove queue")} ${chalk4.magenta(queueName)}: ${error.message}`);
+      logger.error(`Failed to remove queue ${queueName}: ${error.message}`);
       throw error;
     }
   };
@@ -1390,10 +1475,10 @@ var createQueueManager = ({
       return false;
     }
   };
-  const listQueues = (module2) => {
+  const listQueues = (module) => {
     return Object.keys(queues).filter((queueName) => {
       const queueService = queues[queueName];
-      return !module2 || queueService.module === module2;
+      return !module || queueService.module === module;
     }).sort();
   };
   const getQueueStats = (queueName) => {
@@ -1555,15 +1640,8 @@ import fsPlugin2 from "fastify-plugin";
 
 // src/schedule-plugin/core.ts
 import * as fs3 from "fs/promises";
-import chalk9 from "chalk";
-import logSymbols7 from "log-symbols";
-
-// src/schedule-plugin/execution.ts
-import chalk6 from "chalk";
-import logSymbols4 from "log-symbols";
 
 // src/schedule-plugin/cron-utils.ts
-import chalk5 from "chalk";
 import { parseExpression } from "cron-parser";
 function parseCronExpression(cronExpression, lastRun, options = {}) {
   const {
@@ -1595,7 +1673,7 @@ function parseCronExpression(cronExpression, lastRun, options = {}) {
       description: describeCronExpression(normalizedCron)
     };
   } catch (error) {
-    logger.error(`${chalk5.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);
@@ -1624,7 +1702,7 @@ function getNextExecutions(cronExpression, count = 5, options = {}) {
     }
     return executions;
   } catch (error) {
-    logger.error(`${chalk5.red("Error getting next executions:")} ${error.message}`);
+    logger.error(`Error getting next executions: ${error.message}`);
     return [];
   }
 }
@@ -1939,7 +2017,7 @@ var scheduleJob = (scheduler, state, executeJobFn) => {
     updatedScheduler.timerId = setTimeout(() => {
       executeJobFn(updatedScheduler);
     }, timeUntilNextRun);
-    logger.debug(`${chalk6.blue("\u{1F4C5} Scheduled job")} ${chalk6.green(scheduler.job.name)} to run in ${chalk6.cyan(Math.round(timeUntilNextRun / 1e3))}s`);
+    logger.debug(`Scheduled job ${scheduler.job.name} to run in ${Math.round(timeUntilNextRun / 1e3)}s`);
   }
   return updatedScheduler;
 };
@@ -1968,20 +2046,18 @@ var updateJobAfterExecution = (job, execution, config) => {
   return updatedJob;
 };
 var handleExecutionError = (execution, error) => {
-  logger.error(`${logSymbols4.error} ${chalk6.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(`${logSymbols4.success} ${chalk6.green("Job completed")} in ${duration}ms`);
+  logger.debug(`Job completed in ${duration}ms`);
   return completeExecution(execution, result);
 };
 
 // src/schedule-plugin/persistence.ts
 import * as fs2 from "fs/promises";
 import * as path2 from "path";
-import chalk7 from "chalk";
-import logSymbols5 from "log-symbols";
 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) => ({
@@ -1997,7 +2073,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.debug(`${logSymbols5.info} ${chalk7.blue("Enhanced scheduler state saved")}`);
+    logger.debug("Enhanced scheduler state saved");
   } catch (error) {
     logger.error("Failed to save scheduler state:", error);
   }
@@ -2009,7 +2085,7 @@ var loadSchedulerStateData = async (directory) => {
     return JSON.parse(data);
   } catch (error) {
     if (error.code === "ENOENT") {
-      logger.debug(`${chalk7.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);
     }
@@ -2022,20 +2098,20 @@ var validateAndAdjustNextRun = (job, savedNextRun, lastRestartTime, config) => {
     return calculateNextRunFromLastRun(job, job.lastRun, config);
   }
   if (savedNextRun <= now) {
-    logger.debug(`${chalk7.yellow("\u23F0 Saved next run is in the past for")} ${chalk7.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(`${chalk7.blue("\u26A1 Rapid restart detected for")} ${chalk7.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(`${chalk7.yellow("\u{1F527} Adjusting timing for")} ${chalk7.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;
     }
   }
@@ -2049,7 +2125,7 @@ var restoreJobFromSavedData = (scheduler, savedJob, config, lastRestartTime) =>
     lastRun: savedJob.lastRun ? new Date(savedJob.lastRun) : void 0
   };
   if (definitionChanged) {
-    logger.debug(`${chalk7.yellow("\u{1F504} Job definition changed:")} ${chalk7.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;
@@ -2059,7 +2135,7 @@ var restoreJobFromSavedData = (scheduler, savedJob, config, lastRestartTime) =>
     const result = parseCronExpression(updatedJob.cronExpression, updatedJob.lastRun, {
       timezone: updatedJob.timezone
     });
-    logger.debug(`${chalk7.blue("\u{1F4C5} Job restored:")} ${chalk7.green(savedJob.name)} - ${result.description} - next: ${chalk7.cyan(updatedJob.nextRun.toLocaleString())}`);
+    logger.debug(`Job restored: ${savedJob.name} - ${result.description} - next: ${updatedJob.nextRun.toLocaleString()}`);
   }
   return { ...scheduler, job: updatedJob };
 };
@@ -2089,20 +2165,18 @@ var loadSchedulerState = async (schedulers, config, lastRestartTime) => {
     }
   }
   const executionHistory = stateData.executions ? restoreExecutionHistory(stateData.executions) : [];
-  logger.debug(`${logSymbols5.success} ${chalk7.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 chalk8 from "chalk";
-import logSymbols6 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(`${chalk8.blue("\u{1F9F9} Cleaned up")} ${removed.length} old execution records`);
+    logger.debug(`Cleaned up ${removed.length} old execution records`);
     return removed;
   }
   return [];
@@ -2169,11 +2243,11 @@ var createSchedulerFunctions = (state) => {
     const { canExecute, reason } = canExecuteJob(scheduler, state);
     if (!canExecute) {
       if (reason === "Maximum concurrent executions reached") {
-        logger.warn(`${chalk9.yellow("\u26A0\uFE0F  Delaying job")} ${chalk9.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(`${chalk9.yellow("\u23F9\uFE0F  Job")} ${chalk9.green(scheduler.job.name)} reached max runs (${scheduler.job.maxRuns})`);
+        logger.info(`Job ${scheduler.job.name} reached max runs (${scheduler.job.maxRuns})`);
       }
       return;
     }
@@ -2182,7 +2256,7 @@ var createSchedulerFunctions = (state) => {
     state.executionHistory.push(execution);
     scheduler.isRunning = true;
     state.runningExecutions++;
-    logger.info(`${chalk9.blue("\u{1F680} Executing job")} ${chalk9.green(scheduler.job.name)} (${execution.id})`);
+    logger.info(`Executing job ${scheduler.job.name} (${execution.id})`);
     try {
       const result = await executeJobWithTimeout(
         scheduler.handler,
@@ -2242,20 +2316,18 @@ var initializeScheduler = async (state, scheduleJobFn) => {
         scheduleJobFn(scheduler);
       }
     }
-    logger.debug(`${logSymbols7.success} ${chalk9.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(`${logSymbols7.error} ${chalk9.red("Failed to initialize scheduler:")} ${error.message}`);
+    logger.error(`Failed to initialize scheduler: ${error.message}`);
     throw error;
   }
 };
 
 // src/schedule-plugin/jobs.ts
-import chalk10 from "chalk";
-import logSymbols8 from "log-symbols";
 var validateJobDefinition = (jobDef) => {
   const expressionType = detectExpressionType(jobDef.cronExpression);
   if (expressionType === "unknown") {
-    logger.error(`${logSymbols8.error} ${chalk10.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}`);
   }
 };
@@ -2267,11 +2339,11 @@ var createJobFromDefinition = (jobDef, config) => {
     const result = parseCronExpression(cronExpression, void 0, {
       timezone: jobDef.timezone ?? config.cron.defaultTimezone
     });
-    logger.debug(`${chalk10.blue("\u{1F4C5} Job")} ${chalk10.green(jobDef.name)}: ${result.description} - Next: ${chalk10.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(`${chalk10.blue("   Upcoming:")} ${upcoming.map((d) => d.toLocaleTimeString()).join(", ")}`);
+    logger.debug(`Upcoming: ${upcoming.map((d) => d.toLocaleTimeString()).join(", ")}`);
   }
   const job = {
     id: generateJobId(),
@@ -2391,8 +2463,6 @@ var registerAllRoutes = (app, state, executeJobFn, scheduleJobFn) => {
 };
 
 // src/schedule-plugin/decorator.ts
-import chalk11 from "chalk";
-import logSymbols9 from "log-symbols";
 var isValidJobName = (jobName) => {
   return typeof jobName === "string" && jobName.length > 0 && /^[a-zA-Z0-9_-]+$/.test(jobName);
 };
@@ -2422,7 +2492,7 @@ var createSchedulerManager = ({
       validateJobDefinition(jobDefinition);
       const existingJob = Object.values(state.schedulers).find((s) => s.job.name === jobDefinition.name);
       if (existingJob) {
-        logger.warn(`${logSymbols9.warning} ${chalk11.yellow("Job already exists:")} ${chalk11.magenta(jobDefinition.name)}.`);
+        logger.warn(`Job already exists: ${jobDefinition.name}.`);
         return existingJob.job.id;
       }
       const job = createJobFromDefinition(jobDefinition, config);
@@ -2431,10 +2501,10 @@ var createSchedulerManager = ({
       if (job.enabled) {
         scheduleJobFn(scheduler);
       }
-      logger.info(`${logSymbols9.success} ${chalk11.green("Job added:")} ${chalk11.magenta(jobDefinition.name)} (${job.id})`);
+      logger.info(`Job added: ${jobDefinition.name} (${job.id})`);
       return job.id;
     } catch (error) {
-      logger.error(`${logSymbols9.error} ${chalk11.red("Failed to add job")} ${chalk11.magenta(jobDefinition.name)}: ${error.message}`);
+      logger.error(`Failed to add job ${jobDefinition.name}: ${error.message}`);
       throw error;
     }
   };
@@ -2446,15 +2516,15 @@ var createSchedulerManager = ({
         throw new Error(`Job '${jobName}' does not exist`);
       }
       if (scheduler.isRunning) {
-        logger.warn(`${logSymbols9.warning} ${chalk11.yellow("Removing job that is currently running:")} ${chalk11.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(`${logSymbols9.success} ${chalk11.green("Job removed:")} ${chalk11.magenta(jobName)}`);
+      logger.info(`Job removed: ${jobName}`);
     } catch (error) {
-      logger.error(`${logSymbols9.error} ${chalk11.red("Failed to remove job")} ${chalk11.magenta(jobName)}: ${error.message}`);
+      logger.error(`Failed to remove job ${jobName}: ${error.message}`);
       throw error;
     }
   };
@@ -2466,8 +2536,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 {
@@ -2486,14 +2556,14 @@ var createSchedulerManager = ({
         throw new Error(`Job '${jobName}' does not exist`);
       }
       if (scheduler.job.enabled) {
-        logger.debug(`${logSymbols9.info} ${chalk11.blue("Job is already enabled:")} ${chalk11.magenta(jobName)}`);
+        logger.debug(`Job is already enabled: ${jobName}`);
         return;
       }
       scheduler.job.enabled = true;
       scheduleJobFn(scheduler);
-      logger.info(`${logSymbols9.success} ${chalk11.green("Job enabled:")} ${chalk11.magenta(jobName)}`);
+      logger.info(`Job enabled: ${jobName}`);
     } catch (error) {
-      logger.error(`${logSymbols9.error} ${chalk11.red("Failed to enable job")} ${chalk11.magenta(jobName)}: ${error.message}`);
+      logger.error(`Failed to enable job ${jobName}: ${error.message}`);
       throw error;
     }
   };
@@ -2505,7 +2575,7 @@ var createSchedulerManager = ({
         throw new Error(`Job '${jobName}' does not exist`);
       }
       if (!scheduler.job.enabled) {
-        logger.debug(`${logSymbols9.info} ${chalk11.blue("Job is already disabled:")} ${chalk11.magenta(jobName)}`);
+        logger.debug(`Job is already disabled: ${jobName}`);
         return;
       }
       scheduler.job.enabled = false;
@@ -2513,9 +2583,9 @@ var createSchedulerManager = ({
         clearTimeout(scheduler.timerId);
         scheduler.timerId = void 0;
       }
-      logger.info(`${logSymbols9.success} ${chalk11.green("Job disabled:")} ${chalk11.magenta(jobName)}`);
+      logger.info(`Job disabled: ${jobName}`);
     } catch (error) {
-      logger.error(`${logSymbols9.error} ${chalk11.red("Failed to disable job")} ${chalk11.magenta(jobName)}: ${error.message}`);
+      logger.error(`Failed to disable job ${jobName}: ${error.message}`);
       throw error;
     }
   };
@@ -2530,9 +2600,9 @@ var createSchedulerManager = ({
         throw new Error(`Job '${jobName}' is already running`);
       }
       setImmediate(() => executeJob(scheduler));
-      logger.info(`${logSymbols9.success} ${chalk11.green("Job triggered:")} ${chalk11.magenta(jobName)}`);
+      logger.info(`Job triggered: ${jobName}`);
     } catch (error) {
-      logger.error(`${logSymbols9.error} ${chalk11.red("Failed to trigger job")} ${chalk11.magenta(jobName)}: ${error.message}`);
+      logger.error(`Failed to trigger job ${jobName}: ${error.message}`);
       throw error;
     }
   };
@@ -2572,10 +2642,141 @@ var schedulerPlugin = fsPlugin2(async (app, options) => {
   registerAllRoutes(app, state, executeJob, scheduleJobFn);
 });
 
+// src/websocket-plugin/plugin.ts
+import crypto from "crypto";
+import fsPlugin3 from "fastify-plugin";
+import websocketPlugin from "@fastify/websocket";
+var DEFAULT_CONFIG3 = {
+  routeKeyField: "action"
+};
+function mergeConfig3(defaults, overrides) {
+  return { ...defaults, ...overrides };
+}
+var websocketsPlugin = fsPlugin3(async (app, options) => {
+  const config = mergeConfig3(DEFAULT_CONFIG3, options.config);
+  const connections = /* @__PURE__ */ new Map();
+  const handlers = [];
+  const registeredPaths = /* @__PURE__ */ new Set();
+  const pathModuleMap = /* @__PURE__ */ new Map();
+  await app.register(websocketPlugin);
+  function ensureRouteForPath(path4) {
+    if (registeredPaths.has(path4)) return;
+    registeredPaths.add(path4);
+    app.get(path4, {
+      websocket: true,
+      preHandler: async (request, reply) => {
+        const connectionId = crypto.randomUUID();
+        request._wsConnectionId = connectionId;
+        const connectHandlers = handlers.filter((h) => h.path === path4 && h.event === "connect");
+        for (const h of connectHandlers) {
+          await h.handler(connectionId, "connect", null, request, reply);
+        }
+        if (reply.statusCode !== 200)
+          return reply;
+      }
+    }, (socket, request) => {
+      const connectionId = request._wsConnectionId ?? crypto.randomUUID();
+      const connection = {
+        connectionId,
+        socket,
+        path: path4,
+        connectedAt: /* @__PURE__ */ new Date()
+      };
+      connections.set(connectionId, connection);
+      const pathHandlers = () => handlers.filter((h) => h.path === path4);
+      socket.on("message", (raw) => {
+        const data = raw.toString();
+        const currentHandlers = pathHandlers();
+        let routeKey;
+        try {
+          const parsed = JSON.parse(data);
+          routeKey = parsed?.[config.routeKeyField];
+        } catch {
+        }
+        let matched = false;
+        if (routeKey) {
+          const routeHandlers = currentHandlers.filter(
+            (h) => h.event === "message" && h.route === routeKey
+          );
+          for (const h of routeHandlers) {
+            matched = true;
+            h.handler(connectionId, "message", data, request).catch((e) => {
+              logger.error(e);
+            });
+          }
+        }
+        if (!matched) {
+          const defaultHandlers = currentHandlers.filter(
+            (h) => h.event === "message" && !h.route
+          );
+          for (const h of defaultHandlers) {
+            h.handler(connectionId, "message", data, request).catch((e) => {
+              logger.error(e);
+            });
+          }
+        }
+      });
+      socket.on("close", () => {
+        const disconnectHandlers = pathHandlers().filter((h) => h.event === "disconnect");
+        for (const h of disconnectHandlers) {
+          h.handler(connectionId, "disconnect", null, request).catch((e) => {
+            logger.error(e);
+          });
+        }
+        connections.delete(connectionId);
+      });
+    });
+  }
+  const manager = {
+    registerHandler(handler) {
+      handlers.push(handler);
+      if (!pathModuleMap.has(handler.path)) {
+        pathModuleMap.set(handler.path, handler.module);
+      }
+      ensureRouteForPath(handler.path);
+    },
+    getConnections(path4) {
+      const allConnections = Array.from(connections.values());
+      if (path4) {
+        return allConnections.filter((c) => c.path === path4);
+      }
+      return allConnections;
+    },
+    getRegisteredPaths(module) {
+      const all = Array.from(pathModuleMap.entries()).map(([path4, mod]) => ({ path: path4, module: mod }));
+      if (module) {
+        return all.filter((p) => p.module === module);
+      }
+      return all;
+    },
+    async sendToClient(connectionId, data) {
+      const connection = connections.get(connectionId);
+      if (!connection) {
+        throw new Error(`WebSocket connection ${connectionId} not found`);
+      }
+      const payload = typeof data === "string" ? data : JSON.stringify(data);
+      connection.socket.send(payload);
+    },
+    async disconnect(connectionId) {
+      const connection = connections.get(connectionId);
+      if (!connection) {
+        throw new Error(`WebSocket connection ${connectionId} not found`);
+      }
+      connection.socket.close();
+    }
+  };
+  app.decorate("websockets", manager);
+});
+
 // src/dev-console-plugin/route-registry.ts
-var RouteRegistry = class {
+var RouteRegistry = class _RouteRegistry {
   routes = [];
+  static IGNORED_METHODS = /* @__PURE__ */ new Set(["OPTIONS", "HEAD"]);
   register(routeOptions) {
+    const methods = Array.isArray(routeOptions.method) ? routeOptions.method : [routeOptions.method];
+    if (methods.every((m) => _RouteRegistry.IGNORED_METHODS.has(m.toUpperCase()))) {
+      return;
+    }
     const routeInfo = {
       method: routeOptions.method,
       url: routeOptions.url,
@@ -2621,17 +2822,6 @@ var LogStore = class {
   getLogs(limit = 100) {
     return this.logs.slice(0, limit);
   }
-  getLogsByLevel(level, limit = 100) {
-    return this.logs.filter((log) => log.level === level).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(
-      (log) => log.triggerType === triggerType && log.trigger === triggerName
-    ).slice(0, limit);
-  }
   clear() {
     this.logs = [];
   }
@@ -2643,59 +2833,26 @@ var LogStore = class {
   }
 };
 var logStore = new LogStore();
-var originalConsole = {
-  log: console.log,
-  error: console.error,
-  warn: console.warn,
-  info: console.info,
-  debug: console.debug
-};
-var captureConsoleLog = (level, originalMethod) => {
-  return (...args) => {
-    originalMethod.apply(console, args);
-    const message = args.join(" ");
-    let source = "unknown";
-    let module2;
-    let trigger;
-    let triggerType;
-    if (message.includes("Queue") || message.includes("queue")) {
-      source = "queue";
-      triggerType = "queue";
-      const queueMatch = message.match(/queue[:\s]+([a-zA-Z0-9_-]+)/i);
-      if (queueMatch) trigger = queueMatch[1];
-    } else if (message.includes("Schedule") || message.includes("job")) {
-      source = "schedule";
-      triggerType = "schedule";
-      const jobMatch = message.match(/(?:job|schedule)[:\s]+([a-zA-Z0-9_-]+)/i);
-      if (jobMatch) trigger = jobMatch[1];
-    } else if (message.includes("HTTP") || message.includes("api") || message.includes("/api/")) {
-      source = "http";
-      triggerType = "http";
-      const routeMatch = message.match(/\/api\/[^\s]+/);
-      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) module2 = moduleMatch[1];
-    logStore.addLog({
-      id: Date.now().toString() + Math.random().toString(36).substr(2, 9),
-      timestamp: /* @__PURE__ */ new Date(),
-      level,
-      message: message.replace(/\x1b\[[0-9;]*m/g, ""),
-      // Remove ANSI colors
-      source,
-      module: module2,
-      trigger,
-      triggerType
-    });
-  };
-};
-console.error = captureConsoleLog("error", originalConsole.error);
-console.warn = captureConsoleLog("warn", originalConsole.warn);
-console.info = captureConsoleLog("info", originalConsole.info);
-console.log = captureConsoleLog("info", originalConsole.log);
-console.debug = captureConsoleLog("debug", originalConsole.debug);
 async function devConsolePluginFunction(fastify, options = {}) {
   const { prefix = "console", enableUI = true } = options;
+  const upstream = getWriter();
+  setWriter((entry) => {
+    logStore.addLog({
+      id: Date.now().toString() + Math.random().toString(36).slice(2, 9),
+      timestamp: new Date(entry.time),
+      levelName: entry.levelName,
+      message: entry.msg,
+      meta: entry.meta,
+      module: entry.module,
+      reqId: entry.reqId
+    });
+    upstream(entry);
+  });
+  fastify.addHook("onClose", (_instance, done) => {
+    setWriter(upstream);
+    logStore.clear();
+    done();
+  });
   fastify.addHook("onRoute", (routeOptions) => {
     if (routeOptions.prefix === "/api") {
       routeRegistry.register(routeOptions);
@@ -2717,7 +2874,8 @@ async function devConsolePluginFunction(fastify, options = {}) {
   fastify.get(`/${prefix}/modules`, async (_, reply) => {
     const queueManager = fastify.queues;
     const schedulerManager = fastify.scheduler;
-    if (!queueManager || !schedulerManager) {
+    const wsManager = fastify.websockets;
+    if (!queueManager || !schedulerManager || !wsManager) {
       return reply.status(503).send({ error: "Services not available" });
     }
     const allRoutes = routeRegistry.getAll();
@@ -2736,6 +2894,9 @@ async function devConsolePluginFunction(fastify, options = {}) {
       const jobStats = schedulerManager.getJobStats(jobName);
       if (jobStats?.job.module) moduleSet.add(jobStats.job.module);
     });
+    wsManager.getRegisteredPaths().forEach((p) => {
+      if (p.module) moduleSet.add(p.module);
+    });
     const modules = Array.from(moduleSet).map((moduleName) => {
       const moduleRoutes = httpRoutes.filter((route) => route.module === moduleName);
       const moduleQueueNames = queueManager.listQueues(moduleName);
@@ -2761,11 +2922,16 @@ async function devConsolePluginFunction(fastify, options = {}) {
           timezone: jobStats?.job.timezone
         };
       });
+      const moduleWebSockets = wsManager ? wsManager.getRegisteredPaths(moduleName).map((p) => ({
+        path: p.path,
+        connectionCount: wsManager.getConnections(p.path).length
+      })) : [];
       return {
         name: moduleName,
         routes: moduleRoutes,
         queues: moduleQueues,
-        schedules: moduleSchedules
+        schedules: moduleSchedules,
+        websockets: moduleWebSockets
       };
     });
     return { modules };
@@ -2883,7 +3049,7 @@ async function devConsolePluginFunction(fastify, options = {}) {
     }
   });
   fastify.post(`/${prefix}/queues`, async (request, reply) => {
-    const { queueName, module: module2 } = request.body;
+    const { queueName, module } = request.body;
     const queueManager = fastify.queues;
     if (!queueManager) {
       return reply.status(503).send({ error: "Queue service not available" });
@@ -2894,8 +3060,9 @@ async function devConsolePluginFunction(fastify, options = {}) {
     try {
       const handler = async (message) => {
         console.log(`Processing message in ${queueName}:`, message);
+        return void 0;
       };
-      await queueManager.addQueue(queueName, handler, module2);
+      await queueManager.addQueue(queueName, handler, module);
       return reply.status(201).send({
         status: "success",
         message: `Queue ${queueName} created successfully`,
@@ -2995,27 +3162,18 @@ async function devConsolePluginFunction(fastify, options = {}) {
     const {
       limit = 100,
       level,
-      source,
-      module: module2,
-      trigger,
-      triggerType
+      module,
+      reqId
     } = request.query;
     let logs = logStore.getLogs(Number(limit));
     if (level) {
-      logs = logs.filter((log) => log.level === level);
+      logs = logs.filter((log) => log.levelName === level);
     }
-    if (source) {
-      logs = logs.filter((log) => log.source === source);
+    if (module) {
+      logs = logs.filter((log) => log.module === module);
     }
-    if (module2) {
-      logs = logs.filter(
-        (log) => log.module === module2 || log.message.toLowerCase().includes(module2.toLowerCase())
-      );
-    }
-    if (trigger && triggerType) {
-      logs = logs.filter(
-        (log) => log.trigger === trigger && log.triggerType === triggerType || log.message.toLowerCase().includes(trigger.toLowerCase())
-      );
+    if (reqId) {
+      logs = logs.filter((log) => log.reqId === reqId);
     }
     return { logs };
   });
@@ -3023,6 +3181,50 @@ async function devConsolePluginFunction(fastify, options = {}) {
     logStore.clear();
     return { status: "success", message: "Logs cleared" };
   });
+  fastify.get(`/${prefix}/websockets`, async (_, reply) => {
+    const wsManager = fastify.websockets;
+    if (!wsManager) {
+      return reply.status(503).send({ error: "WebSocket service not available" });
+    }
+    const connections = wsManager.getConnections();
+    const pathSet = new Set(connections.map((c) => c.path));
+    const paths = Array.from(pathSet).map((p) => ({
+      path: p,
+      connections: wsManager.getConnections(p).map((c) => ({
+        connectionId: c.connectionId,
+        path: c.path,
+        connectedAt: c.connectedAt
+      }))
+    }));
+    return { paths };
+  });
+  fastify.get(`/${prefix}/websockets/:path`, async (request, reply) => {
+    const wsManager = fastify.websockets;
+    if (!wsManager) {
+      return reply.status(503).send({ error: "WebSocket service not available" });
+    }
+    const { path: wsPath } = request.params;
+    const decodedPath = "/" + wsPath;
+    const connections = wsManager.getConnections(decodedPath).map((c) => ({
+      connectionId: c.connectionId,
+      path: c.path,
+      connectedAt: c.connectedAt
+    }));
+    return { path: decodedPath, connections };
+  });
+  fastify.post(`/${prefix}/websockets/:connectionId/send`, async (request, reply) => {
+    const wsManager = fastify.websockets;
+    if (!wsManager) {
+      return reply.status(503).send({ error: "WebSocket service not available" });
+    }
+    const { connectionId } = request.params;
+    try {
+      await wsManager.sendToClient(connectionId, request.body);
+      return reply.status(200).send({ status: "success", message: `Message sent to ${connectionId}` });
+    } catch (error) {
+      return reply.status(404).send({ error: error.message });
+    }
+  });
   fastify.get(`/${prefix}/logs/stream`, async (request, reply) => {
     reply.type("text/event-stream");
     reply.header("Cache-Control", "no-cache");
@@ -3047,14 +3249,15 @@ async function devConsolePluginFunction(fastify, options = {}) {
     );
     await fastify.register(fastifyStatic, {
       root: devConsolePath,
-      decorateReply: true
+      decorateReply: true,
+      prefix: `/${prefix}/`
     });
     fastify.get(`/${prefix}`, async (_, reply) => {
       return reply.sendFile("index.html");
     });
   }
 }
-var devConsolePlugin = fsPlugin3(devConsolePluginFunction, {
+var devConsolePlugin = fsPlugin4(devConsolePluginFunction, {
   name: "dev-console-plugin"
 });
 export {