@cloudnux/local-cloud-provider 0.19.0 → 0.21.0

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

@@ -1,5 +1,5 @@
 // src/dev-console-plugin/plugin.ts
-import path3 from "path";
+import path4 from "path";
 import fastifyStatic from "@fastify/static";
 import fsPlugin4 from "fastify-plugin";
 import { createRequire } from "module";
@@ -20,7 +20,7 @@ var DEFAULT_CONFIG = {
   tickIntervalMs: 50,
   persistence: {
     enabled: true,
-    directory: "./.develop/queue-data",
+    directory: "./.develop/.queue-data",
     saveInterval: 6e4,
     saveOnShutdown: false
   }
@@ -502,6 +502,26 @@ var purgeDlq = async (runtime, queueName) => {
 var getMessageHistory = (runtime, queueName, limit = 50) => {
   return runtime.messageHistory.filter((entry) => entry.queueName === queueName).slice(-limit).reverse();
 };
+var subscribeTopic = (runtime, topicName, queueName) => {
+  const subscribers = runtime.topics[topicName] ?? (runtime.topics[topicName] = []);
+  if (!subscribers.includes(queueName)) {
+    subscribers.push(queueName);
+  }
+  runtime.logging.info({ topicName, queueName }, `Subscribed queue '${queueName}' to topic '${topicName}'`);
+};
+var publishTopic = async (runtime, topicName, body, attributes) => {
+  const subscribers = runtime.topics[topicName];
+  if (!subscribers || subscribers.length === 0) {
+    return null;
+  }
+  const results = await Promise.all(
+    subscribers.map((queueName) => enqueueMessage(runtime, queueName, body, attributes))
+  );
+  return results.filter((result) => result !== null);
+};
+var listTopics = (runtime) => {
+  return Object.fromEntries(Object.entries(runtime.topics).map(([name, queues]) => [name, [...queues]]));
+};
 var createQueueManager = (runtime) => ({
   addQueue: (queueName, handler, module) => addQueue(runtime, queueName, handler, module),
   removeQueue: (queueName) => removeQueue(runtime, queueName),
@@ -515,7 +535,10 @@ var createQueueManager = (runtime) => ({
   enqueueMessage: (queueName, body, attributes) => enqueueMessage(runtime, queueName, body, attributes),
   processDlq: (queueName) => processDlq(runtime, queueName),
   purgeDlq: (queueName) => purgeDlq(runtime, queueName),
-  getMessageHistory: (queueName, limit) => getMessageHistory(runtime, queueName, limit)
+  getMessageHistory: (queueName, limit) => getMessageHistory(runtime, queueName, limit),
+  subscribeTopic: (topicName, queueName) => subscribeTopic(runtime, topicName, queueName),
+  publishTopic: (topicName, body, attributes) => publishTopic(runtime, topicName, body, attributes),
+  listTopics: () => listTopics(runtime)
 });
 
 // src/queue-plugin/routes.ts
@@ -549,6 +572,17 @@ var registerQueueRoutes = (app, prefix = "") => {
       return reply.status(200).send(result);
     }
   );
+  app.post(
+    `/${prefix}/topics/:topic`,
+    async (request, reply) => {
+      const topicName = request.params.topic;
+      const results = await app.queues.publishTopic(topicName, request.body, request.headers);
+      if (results === null) {
+        return reply.status(404).send({ error: "Topic not found" });
+      }
+      return reply.status(200).send({ topicName, results });
+    }
+  );
   app.get(
     `/${prefix}/:queue/process-dlq`,
     async (request, reply) => {
@@ -578,6 +612,7 @@ var queuesPlugin = fsPlugin(async (app, options) => {
   const runtime = {
     config: mergeConfig(DEFAULT_CONFIG, options.config),
     queues: {},
+    topics: {},
     dirtyQueues: /* @__PURE__ */ new Set(),
     lastSavedAt: Date.now(),
     messageHistory: [],
@@ -936,7 +971,7 @@ var DEFAULT_CONFIG2 = {
   tickIntervalMs: 1e3,
   persistence: {
     enabled: true,
-    directory: "./.develop/scheduler-data",
+    directory: "./.develop/.scheduler-data",
     saveInterval: 3e4,
     // 30 seconds
     saveOnShutdown: false
@@ -1573,16 +1608,16 @@ var websocketsPlugin = fsPlugin3(async (app, options) => {
   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, {
+  function ensureRouteForPath(path5) {
+    if (registeredPaths.has(path5)) return;
+    registeredPaths.add(path5);
+    app.get(path5, {
       websocket: true,
       preHandler: async (request, reply) => {
         const connectionId = crypto.randomUUID();
         request._wsConnectionId = connectionId;
         const reqId = `${request.id}:${connectionId}`;
-        const connectHandlers = handlers.filter((h) => h.path === path4 && h.event === "connect");
+        const connectHandlers = handlers.filter((h) => h.path === path5 && h.event === "connect");
         for (const h of connectHandlers) {
           await app.logging.runWithLogContext(
             { module: h.module, reqId },
@@ -1598,11 +1633,11 @@ var websocketsPlugin = fsPlugin3(async (app, options) => {
       const connection = {
         connectionId,
         socket,
-        path: path4,
+        path: path5,
         connectedAt: /* @__PURE__ */ new Date()
       };
       connections.set(connectionId, connection);
-      const pathHandlers = () => handlers.filter((h) => h.path === path4);
+      const pathHandlers = () => handlers.filter((h) => h.path === path5);
       socket.on("message", (raw) => {
         const data = raw.toString();
         const currentHandlers = pathHandlers();
@@ -1657,15 +1692,15 @@ var websocketsPlugin = fsPlugin3(async (app, options) => {
       }
       ensureRouteForPath(handler.path);
     },
-    getConnections(path4) {
+    getConnections(path5) {
       const allConnections = Array.from(connections.values());
-      if (path4) {
-        return allConnections.filter((c) => c.path === path4);
+      if (path5) {
+        return allConnections.filter((c) => c.path === path5);
       }
       return allConnections;
     },
     getRegisteredPaths(module) {
-      const all = Array.from(pathModuleMap.entries()).map(([path4, mod]) => ({ path: path4, module: mod }));
+      const all = Array.from(pathModuleMap.entries()).map(([path5, mod]) => ({ path: path5, module: mod }));
       if (module) {
         return all.filter((p) => p.module === module);
       }
@@ -1728,6 +1763,904 @@ var RouteRegistry = class _RouteRegistry {
 };
 var routeRegistry = new RouteRegistry();
 
+// src/services/email.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+
+// ../../../node_modules/lodash-es/_freeGlobal.js
+var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+var freeGlobal_default = freeGlobal;
+
+// ../../../node_modules/lodash-es/_root.js
+var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+var root = freeGlobal_default || freeSelf || Function("return this")();
+var root_default = root;
+
+// ../../../node_modules/lodash-es/_Symbol.js
+var Symbol = root_default.Symbol;
+var Symbol_default = Symbol;
+
+// ../../../node_modules/lodash-es/_getRawTag.js
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+var nativeObjectToString = objectProto.toString;
+var symToStringTag = Symbol_default ? Symbol_default.toStringTag : void 0;
+function getRawTag(value) {
+  var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+  try {
+    value[symToStringTag] = void 0;
+    var unmasked = true;
+  } catch (e) {
+  }
+  var result = nativeObjectToString.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag] = tag;
+    } else {
+      delete value[symToStringTag];
+    }
+  }
+  return result;
+}
+var getRawTag_default = getRawTag;
+
+// ../../../node_modules/lodash-es/_objectToString.js
+var objectProto2 = Object.prototype;
+var nativeObjectToString2 = objectProto2.toString;
+function objectToString(value) {
+  return nativeObjectToString2.call(value);
+}
+var objectToString_default = objectToString;
+
+// ../../../node_modules/lodash-es/_baseGetTag.js
+var nullTag = "[object Null]";
+var undefinedTag = "[object Undefined]";
+var symToStringTag2 = Symbol_default ? Symbol_default.toStringTag : void 0;
+function baseGetTag(value) {
+  if (value == null) {
+    return value === void 0 ? undefinedTag : nullTag;
+  }
+  return symToStringTag2 && symToStringTag2 in Object(value) ? getRawTag_default(value) : objectToString_default(value);
+}
+var baseGetTag_default = baseGetTag;
+
+// ../../../node_modules/lodash-es/isObjectLike.js
+function isObjectLike(value) {
+  return value != null && typeof value == "object";
+}
+var isObjectLike_default = isObjectLike;
+
+// ../../../node_modules/lodash-es/isSymbol.js
+var symbolTag = "[object Symbol]";
+function isSymbol(value) {
+  return typeof value == "symbol" || isObjectLike_default(value) && baseGetTag_default(value) == symbolTag;
+}
+var isSymbol_default = isSymbol;
+
+// ../../../node_modules/lodash-es/_arrayMap.js
+function arrayMap(array2, iteratee) {
+  var index = -1, length = array2 == null ? 0 : array2.length, result = Array(length);
+  while (++index < length) {
+    result[index] = iteratee(array2[index], index, array2);
+  }
+  return result;
+}
+var arrayMap_default = arrayMap;
+
+// ../../../node_modules/lodash-es/isArray.js
+var isArray = Array.isArray;
+var isArray_default = isArray;
+
+// ../../../node_modules/lodash-es/_baseToString.js
+var INFINITY = 1 / 0;
+var symbolProto = Symbol_default ? Symbol_default.prototype : void 0;
+var symbolToString = symbolProto ? symbolProto.toString : void 0;
+function baseToString(value) {
+  if (typeof value == "string") {
+    return value;
+  }
+  if (isArray_default(value)) {
+    return arrayMap_default(value, baseToString) + "";
+  }
+  if (isSymbol_default(value)) {
+    return symbolToString ? symbolToString.call(value) : "";
+  }
+  var result = value + "";
+  return result == "0" && 1 / value == -INFINITY ? "-0" : result;
+}
+var baseToString_default = baseToString;
+
+// ../../../node_modules/lodash-es/_trimmedEndIndex.js
+var reWhitespace = /\s/;
+function trimmedEndIndex(string) {
+  var index = string.length;
+  while (index-- && reWhitespace.test(string.charAt(index))) {
+  }
+  return index;
+}
+var trimmedEndIndex_default = trimmedEndIndex;
+
+// ../../../node_modules/lodash-es/_baseTrim.js
+var reTrimStart = /^\s+/;
+function baseTrim(string) {
+  return string ? string.slice(0, trimmedEndIndex_default(string) + 1).replace(reTrimStart, "") : string;
+}
+var baseTrim_default = baseTrim;
+
+// ../../../node_modules/lodash-es/isObject.js
+function isObject(value) {
+  var type = typeof value;
+  return value != null && (type == "object" || type == "function");
+}
+var isObject_default = isObject;
+
+// ../../../node_modules/lodash-es/isFunction.js
+var asyncTag = "[object AsyncFunction]";
+var funcTag = "[object Function]";
+var genTag = "[object GeneratorFunction]";
+var proxyTag = "[object Proxy]";
+function isFunction(value) {
+  if (!isObject_default(value)) {
+    return false;
+  }
+  var tag = baseGetTag_default(value);
+  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+}
+var isFunction_default = isFunction;
+
+// ../../../node_modules/lodash-es/_coreJsData.js
+var coreJsData = root_default["__core-js_shared__"];
+var coreJsData_default = coreJsData;
+
+// ../../../node_modules/lodash-es/_isMasked.js
+var maskSrcKey = function() {
+  var uid = /[^.]+$/.exec(coreJsData_default && coreJsData_default.keys && coreJsData_default.keys.IE_PROTO || "");
+  return uid ? "Symbol(src)_1." + uid : "";
+}();
+function isMasked(func) {
+  return !!maskSrcKey && maskSrcKey in func;
+}
+var isMasked_default = isMasked;
+
+// ../../../node_modules/lodash-es/_toSource.js
+var funcProto = Function.prototype;
+var funcToString = funcProto.toString;
+function toSource(func) {
+  if (func != null) {
+    try {
+      return funcToString.call(func);
+    } catch (e) {
+    }
+    try {
+      return func + "";
+    } catch (e) {
+    }
+  }
+  return "";
+}
+var toSource_default = toSource;
+
+// ../../../node_modules/lodash-es/_baseIsNative.js
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+var funcProto2 = Function.prototype;
+var objectProto3 = Object.prototype;
+var funcToString2 = funcProto2.toString;
+var hasOwnProperty2 = objectProto3.hasOwnProperty;
+var reIsNative = RegExp(
+  "^" + funcToString2.call(hasOwnProperty2).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+);
+function baseIsNative(value) {
+  if (!isObject_default(value) || isMasked_default(value)) {
+    return false;
+  }
+  var pattern = isFunction_default(value) ? reIsNative : reIsHostCtor;
+  return pattern.test(toSource_default(value));
+}
+var baseIsNative_default = baseIsNative;
+
+// ../../../node_modules/lodash-es/_getValue.js
+function getValue(object, key) {
+  return object == null ? void 0 : object[key];
+}
+var getValue_default = getValue;
+
+// ../../../node_modules/lodash-es/_getNative.js
+function getNative(object, key) {
+  var value = getValue_default(object, key);
+  return baseIsNative_default(value) ? value : void 0;
+}
+var getNative_default = getNative;
+
+// ../../../node_modules/lodash-es/_baseFindIndex.js
+function baseFindIndex(array2, predicate, fromIndex, fromRight) {
+  var length = array2.length, index = fromIndex + (fromRight ? 1 : -1);
+  while (fromRight ? index-- : ++index < length) {
+    if (predicate(array2[index], index, array2)) {
+      return index;
+    }
+  }
+  return -1;
+}
+var baseFindIndex_default = baseFindIndex;
+
+// ../../../node_modules/lodash-es/_baseIsNaN.js
+function baseIsNaN(value) {
+  return value !== value;
+}
+var baseIsNaN_default = baseIsNaN;
+
+// ../../../node_modules/lodash-es/_strictIndexOf.js
+function strictIndexOf(array2, value, fromIndex) {
+  var index = fromIndex - 1, length = array2.length;
+  while (++index < length) {
+    if (array2[index] === value) {
+      return index;
+    }
+  }
+  return -1;
+}
+var strictIndexOf_default = strictIndexOf;
+
+// ../../../node_modules/lodash-es/_baseIndexOf.js
+function baseIndexOf(array2, value, fromIndex) {
+  return value === value ? strictIndexOf_default(array2, value, fromIndex) : baseFindIndex_default(array2, baseIsNaN_default, fromIndex);
+}
+var baseIndexOf_default = baseIndexOf;
+
+// ../../../node_modules/lodash-es/_isIndex.js
+var MAX_SAFE_INTEGER = 9007199254740991;
+var reIsUint = /^(?:0|[1-9]\d*)$/;
+function isIndex(value, length) {
+  var type = typeof value;
+  length = length == null ? MAX_SAFE_INTEGER : length;
+  return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
+}
+var isIndex_default = isIndex;
+
+// ../../../node_modules/lodash-es/eq.js
+function eq(value, other) {
+  return value === other || value !== value && other !== other;
+}
+var eq_default = eq;
+
+// ../../../node_modules/lodash-es/isLength.js
+var MAX_SAFE_INTEGER2 = 9007199254740991;
+function isLength(value) {
+  return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER2;
+}
+var isLength_default = isLength;
+
+// ../../../node_modules/lodash-es/_baseIsArguments.js
+var argsTag = "[object Arguments]";
+function baseIsArguments(value) {
+  return isObjectLike_default(value) && baseGetTag_default(value) == argsTag;
+}
+var baseIsArguments_default = baseIsArguments;
+
+// ../../../node_modules/lodash-es/isArguments.js
+var objectProto4 = Object.prototype;
+var hasOwnProperty3 = objectProto4.hasOwnProperty;
+var propertyIsEnumerable = objectProto4.propertyIsEnumerable;
+var isArguments = baseIsArguments_default(/* @__PURE__ */ function() {
+  return arguments;
+}()) ? baseIsArguments_default : function(value) {
+  return isObjectLike_default(value) && hasOwnProperty3.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
+};
+var isArguments_default = isArguments;
+
+// ../../../node_modules/lodash-es/_isKey.js
+var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
+var reIsPlainProp = /^\w*$/;
+function isKey(value, object) {
+  if (isArray_default(value)) {
+    return false;
+  }
+  var type = typeof value;
+  if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol_default(value)) {
+    return true;
+  }
+  return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);
+}
+var isKey_default = isKey;
+
+// ../../../node_modules/lodash-es/_nativeCreate.js
+var nativeCreate = getNative_default(Object, "create");
+var nativeCreate_default = nativeCreate;
+
+// ../../../node_modules/lodash-es/_hashClear.js
+function hashClear() {
+  this.__data__ = nativeCreate_default ? nativeCreate_default(null) : {};
+  this.size = 0;
+}
+var hashClear_default = hashClear;
+
+// ../../../node_modules/lodash-es/_hashDelete.js
+function hashDelete(key) {
+  var result = this.has(key) && delete this.__data__[key];
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var hashDelete_default = hashDelete;
+
+// ../../../node_modules/lodash-es/_hashGet.js
+var HASH_UNDEFINED = "__lodash_hash_undefined__";
+var objectProto5 = Object.prototype;
+var hasOwnProperty4 = objectProto5.hasOwnProperty;
+function hashGet(key) {
+  var data = this.__data__;
+  if (nativeCreate_default) {
+    var result = data[key];
+    return result === HASH_UNDEFINED ? void 0 : result;
+  }
+  return hasOwnProperty4.call(data, key) ? data[key] : void 0;
+}
+var hashGet_default = hashGet;
+
+// ../../../node_modules/lodash-es/_hashHas.js
+var objectProto6 = Object.prototype;
+var hasOwnProperty5 = objectProto6.hasOwnProperty;
+function hashHas(key) {
+  var data = this.__data__;
+  return nativeCreate_default ? data[key] !== void 0 : hasOwnProperty5.call(data, key);
+}
+var hashHas_default = hashHas;
+
+// ../../../node_modules/lodash-es/_hashSet.js
+var HASH_UNDEFINED2 = "__lodash_hash_undefined__";
+function hashSet(key, value) {
+  var data = this.__data__;
+  this.size += this.has(key) ? 0 : 1;
+  data[key] = nativeCreate_default && value === void 0 ? HASH_UNDEFINED2 : value;
+  return this;
+}
+var hashSet_default = hashSet;
+
+// ../../../node_modules/lodash-es/_Hash.js
+function Hash(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+Hash.prototype.clear = hashClear_default;
+Hash.prototype["delete"] = hashDelete_default;
+Hash.prototype.get = hashGet_default;
+Hash.prototype.has = hashHas_default;
+Hash.prototype.set = hashSet_default;
+var Hash_default = Hash;
+
+// ../../../node_modules/lodash-es/_listCacheClear.js
+function listCacheClear() {
+  this.__data__ = [];
+  this.size = 0;
+}
+var listCacheClear_default = listCacheClear;
+
+// ../../../node_modules/lodash-es/_assocIndexOf.js
+function assocIndexOf(array2, key) {
+  var length = array2.length;
+  while (length--) {
+    if (eq_default(array2[length][0], key)) {
+      return length;
+    }
+  }
+  return -1;
+}
+var assocIndexOf_default = assocIndexOf;
+
+// ../../../node_modules/lodash-es/_listCacheDelete.js
+var arrayProto = Array.prototype;
+var splice = arrayProto.splice;
+function listCacheDelete(key) {
+  var data = this.__data__, index = assocIndexOf_default(data, key);
+  if (index < 0) {
+    return false;
+  }
+  var lastIndex = data.length - 1;
+  if (index == lastIndex) {
+    data.pop();
+  } else {
+    splice.call(data, index, 1);
+  }
+  --this.size;
+  return true;
+}
+var listCacheDelete_default = listCacheDelete;
+
+// ../../../node_modules/lodash-es/_listCacheGet.js
+function listCacheGet(key) {
+  var data = this.__data__, index = assocIndexOf_default(data, key);
+  return index < 0 ? void 0 : data[index][1];
+}
+var listCacheGet_default = listCacheGet;
+
+// ../../../node_modules/lodash-es/_listCacheHas.js
+function listCacheHas(key) {
+  return assocIndexOf_default(this.__data__, key) > -1;
+}
+var listCacheHas_default = listCacheHas;
+
+// ../../../node_modules/lodash-es/_listCacheSet.js
+function listCacheSet(key, value) {
+  var data = this.__data__, index = assocIndexOf_default(data, key);
+  if (index < 0) {
+    ++this.size;
+    data.push([key, value]);
+  } else {
+    data[index][1] = value;
+  }
+  return this;
+}
+var listCacheSet_default = listCacheSet;
+
+// ../../../node_modules/lodash-es/_ListCache.js
+function ListCache(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+ListCache.prototype.clear = listCacheClear_default;
+ListCache.prototype["delete"] = listCacheDelete_default;
+ListCache.prototype.get = listCacheGet_default;
+ListCache.prototype.has = listCacheHas_default;
+ListCache.prototype.set = listCacheSet_default;
+var ListCache_default = ListCache;
+
+// ../../../node_modules/lodash-es/_Map.js
+var Map2 = getNative_default(root_default, "Map");
+var Map_default = Map2;
+
+// ../../../node_modules/lodash-es/_mapCacheClear.js
+function mapCacheClear() {
+  this.size = 0;
+  this.__data__ = {
+    "hash": new Hash_default(),
+    "map": new (Map_default || ListCache_default)(),
+    "string": new Hash_default()
+  };
+}
+var mapCacheClear_default = mapCacheClear;
+
+// ../../../node_modules/lodash-es/_isKeyable.js
+function isKeyable(value) {
+  var type = typeof value;
+  return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+}
+var isKeyable_default = isKeyable;
+
+// ../../../node_modules/lodash-es/_getMapData.js
+function getMapData(map, key) {
+  var data = map.__data__;
+  return isKeyable_default(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+}
+var getMapData_default = getMapData;
+
+// ../../../node_modules/lodash-es/_mapCacheDelete.js
+function mapCacheDelete(key) {
+  var result = getMapData_default(this, key)["delete"](key);
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var mapCacheDelete_default = mapCacheDelete;
+
+// ../../../node_modules/lodash-es/_mapCacheGet.js
+function mapCacheGet(key) {
+  return getMapData_default(this, key).get(key);
+}
+var mapCacheGet_default = mapCacheGet;
+
+// ../../../node_modules/lodash-es/_mapCacheHas.js
+function mapCacheHas(key) {
+  return getMapData_default(this, key).has(key);
+}
+var mapCacheHas_default = mapCacheHas;
+
+// ../../../node_modules/lodash-es/_mapCacheSet.js
+function mapCacheSet(key, value) {
+  var data = getMapData_default(this, key), size = data.size;
+  data.set(key, value);
+  this.size += data.size == size ? 0 : 1;
+  return this;
+}
+var mapCacheSet_default = mapCacheSet;
+
+// ../../../node_modules/lodash-es/_MapCache.js
+function MapCache(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+MapCache.prototype.clear = mapCacheClear_default;
+MapCache.prototype["delete"] = mapCacheDelete_default;
+MapCache.prototype.get = mapCacheGet_default;
+MapCache.prototype.has = mapCacheHas_default;
+MapCache.prototype.set = mapCacheSet_default;
+var MapCache_default = MapCache;
+
+// ../../../node_modules/lodash-es/memoize.js
+var FUNC_ERROR_TEXT = "Expected a function";
+function memoize(func, resolver) {
+  if (typeof func != "function" || resolver != null && typeof resolver != "function") {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  var memoized = function() {
+    var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    var result = func.apply(this, args);
+    memoized.cache = cache.set(key, result) || cache;
+    return result;
+  };
+  memoized.cache = new (memoize.Cache || MapCache_default)();
+  return memoized;
+}
+memoize.Cache = MapCache_default;
+var memoize_default = memoize;
+
+// ../../../node_modules/lodash-es/_memoizeCapped.js
+var MAX_MEMOIZE_SIZE = 500;
+function memoizeCapped(func) {
+  var result = memoize_default(func, function(key) {
+    if (cache.size === MAX_MEMOIZE_SIZE) {
+      cache.clear();
+    }
+    return key;
+  });
+  var cache = result.cache;
+  return result;
+}
+var memoizeCapped_default = memoizeCapped;
+
+// ../../../node_modules/lodash-es/_stringToPath.js
+var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+var reEscapeChar = /\\(\\)?/g;
+var stringToPath = memoizeCapped_default(function(string) {
+  var result = [];
+  if (string.charCodeAt(0) === 46) {
+    result.push("");
+  }
+  string.replace(rePropName, function(match, number, quote, subString) {
+    result.push(quote ? subString.replace(reEscapeChar, "$1") : number || match);
+  });
+  return result;
+});
+var stringToPath_default = stringToPath;
+
+// ../../../node_modules/lodash-es/toString.js
+function toString(value) {
+  return value == null ? "" : baseToString_default(value);
+}
+var toString_default = toString;
+
+// ../../../node_modules/lodash-es/_castPath.js
+function castPath(value, object) {
+  if (isArray_default(value)) {
+    return value;
+  }
+  return isKey_default(value, object) ? [value] : stringToPath_default(toString_default(value));
+}
+var castPath_default = castPath;
+
+// ../../../node_modules/lodash-es/_toKey.js
+var INFINITY2 = 1 / 0;
+function toKey(value) {
+  if (typeof value == "string" || isSymbol_default(value)) {
+    return value;
+  }
+  var result = value + "";
+  return result == "0" && 1 / value == -INFINITY2 ? "-0" : result;
+}
+var toKey_default = toKey;
+
+// ../../../node_modules/lodash-es/_baseSlice.js
+function baseSlice(array2, start, end) {
+  var index = -1, length = array2.length;
+  if (start < 0) {
+    start = -start > length ? 0 : length + start;
+  }
+  end = end > length ? length : end;
+  if (end < 0) {
+    end += length;
+  }
+  length = start > end ? 0 : end - start >>> 0;
+  start >>>= 0;
+  var result = Array(length);
+  while (++index < length) {
+    result[index] = array2[index + start];
+  }
+  return result;
+}
+var baseSlice_default = baseSlice;
+
+// ../../../node_modules/lodash-es/_castSlice.js
+function castSlice(array2, start, end) {
+  var length = array2.length;
+  end = end === void 0 ? length : end;
+  return !start && end >= length ? array2 : baseSlice_default(array2, start, end);
+}
+var castSlice_default = castSlice;
+
+// ../../../node_modules/lodash-es/_hasUnicode.js
+var rsAstralRange = "\\ud800-\\udfff";
+var rsComboMarksRange = "\\u0300-\\u036f";
+var reComboHalfMarksRange = "\\ufe20-\\ufe2f";
+var rsComboSymbolsRange = "\\u20d0-\\u20ff";
+var rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange;
+var rsVarRange = "\\ufe0e\\ufe0f";
+var rsZWJ = "\\u200d";
+var reHasUnicode = RegExp("[" + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + "]");
+function hasUnicode(string) {
+  return reHasUnicode.test(string);
+}
+var hasUnicode_default = hasUnicode;
+
+// ../../../node_modules/lodash-es/_asciiToArray.js
+function asciiToArray(string) {
+  return string.split("");
+}
+var asciiToArray_default = asciiToArray;
+
+// ../../../node_modules/lodash-es/_unicodeToArray.js
+var rsAstralRange2 = "\\ud800-\\udfff";
+var rsComboMarksRange2 = "\\u0300-\\u036f";
+var reComboHalfMarksRange2 = "\\ufe20-\\ufe2f";
+var rsComboSymbolsRange2 = "\\u20d0-\\u20ff";
+var rsComboRange2 = rsComboMarksRange2 + reComboHalfMarksRange2 + rsComboSymbolsRange2;
+var rsVarRange2 = "\\ufe0e\\ufe0f";
+var rsAstral = "[" + rsAstralRange2 + "]";
+var rsCombo = "[" + rsComboRange2 + "]";
+var rsFitz = "\\ud83c[\\udffb-\\udfff]";
+var rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")";
+var rsNonAstral = "[^" + rsAstralRange2 + "]";
+var rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}";
+var rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]";
+var rsZWJ2 = "\\u200d";
+var reOptMod = rsModifier + "?";
+var rsOptVar = "[" + rsVarRange2 + "]?";
+var rsOptJoin = "(?:" + rsZWJ2 + "(?:" + [rsNonAstral, rsRegional, rsSurrPair].join("|") + ")" + rsOptVar + reOptMod + ")*";
+var rsSeq = rsOptVar + reOptMod + rsOptJoin;
+var rsSymbol = "(?:" + [rsNonAstral + rsCombo + "?", rsCombo, rsRegional, rsSurrPair, rsAstral].join("|") + ")";
+var reUnicode = RegExp(rsFitz + "(?=" + rsFitz + ")|" + rsSymbol + rsSeq, "g");
+function unicodeToArray(string) {
+  return string.match(reUnicode) || [];
+}
+var unicodeToArray_default = unicodeToArray;
+
+// ../../../node_modules/lodash-es/_stringToArray.js
+function stringToArray(string) {
+  return hasUnicode_default(string) ? unicodeToArray_default(string) : asciiToArray_default(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;
+  while (++index < length) {
+    var key = toKey_default(path5[index]);
+    if (!(result = object != null && hasFunc(object, key))) {
+      break;
+    }
+    object = object[key];
+  }
+  if (result || ++index != length) {
+    return result;
+  }
+  length = object == null ? 0 : object.length;
+  return !!length && isLength_default(length) && isIndex_default(key, length) && (isArray_default(object) || isArguments_default(object));
+}
+var hasPath_default = hasPath;
+
+// ../../../node_modules/lodash-es/_baseHas.js
+var objectProto7 = Object.prototype;
+var hasOwnProperty6 = objectProto7.hasOwnProperty;
+function baseHas(object, key) {
+  return object != null && hasOwnProperty6.call(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);
+}
+var has_default = has;
+
+// ../../../node_modules/lodash-es/_charsEndIndex.js
+function charsEndIndex(strSymbols, chrSymbols) {
+  var index = strSymbols.length;
+  while (index-- && baseIndexOf_default(chrSymbols, strSymbols[index], 0) > -1) {
+  }
+  return index;
+}
+var charsEndIndex_default = charsEndIndex;
+
+// ../../../node_modules/lodash-es/_charsStartIndex.js
+function charsStartIndex(strSymbols, chrSymbols) {
+  var index = -1, length = strSymbols.length;
+  while (++index < length && baseIndexOf_default(chrSymbols, strSymbols[index], 0) > -1) {
+  }
+  return index;
+}
+var charsStartIndex_default = charsStartIndex;
+
+// ../../../node_modules/lodash-es/trim.js
+function trim(string, chars, guard) {
+  string = toString_default(string);
+  if (string && (guard || chars === void 0)) {
+    return baseTrim_default(string);
+  }
+  if (!string || !(chars = baseToString_default(chars))) {
+    return string;
+  }
+  var strSymbols = stringToArray_default(string), chrSymbols = stringToArray_default(chars), start = charsStartIndex_default(strSymbols, chrSymbols), end = charsEndIndex_default(strSymbols, chrSymbols) + 1;
+  return castSlice_default(strSymbols, start, end).join("");
+}
+var trim_default = trim;
+
+// ../../utils/src/config/env.ts
+function _env(key, defaultValue) {
+  return has_default(process.env, key) ? process.env[key] ?? "" : defaultValue ?? "";
+}
+function int(key, defaultValue) {
+  if (!has_default(process.env, key)) {
+    return defaultValue ?? 0;
+  }
+  const value = process.env[key] ?? "0";
+  return parseInt(value, 10);
+}
+function float(key, defaultValue) {
+  if (!has_default(process.env, key)) {
+    return defaultValue ?? 0;
+  }
+  const value = process.env[key] ?? "0";
+  return parseFloat(value);
+}
+function bool(key, defaultValue) {
+  if (!has_default(process.env, key)) {
+    return defaultValue ?? false;
+  }
+  const value = process.env[key];
+  return value === "true";
+}
+function json(key, defaultValue) {
+  if (!has_default(process.env, key)) {
+    return defaultValue ?? {};
+  }
+  const value = process.env[key] ?? "{}";
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    throw new Error(`Invalid json environment variable ${key}: ${error.message}`);
+  }
+}
+function array(key, defaultValue) {
+  if (!has_default(process.env, key)) {
+    return defaultValue ?? [];
+  }
+  let value = process.env[key] ?? "";
+  if (value.startsWith("[") && value.endsWith("]")) {
+    value = value.substring(1, value.length - 1);
+  }
+  return value.split(",").map((v) => {
+    return trim_default(trim_default(v, " "), '"');
+  });
+}
+function date(key, defaultValue) {
+  if (!has_default(process.env, key)) {
+    return defaultValue ?? /* @__PURE__ */ new Date();
+  }
+  const value = process.env[key] ?? Date();
+  return new Date(value);
+}
+var utils = {
+  int,
+  float,
+  bool,
+  json,
+  array,
+  date,
+  /**
+   * Gets a value from env that matches oneOf provided values
+   * @param {string} key
+   * @param {string[]} expectedValues
+   * @param {string|undefined} defaultValue
+   * @returns {string|undefined}
+   */
+  oneOf(key, expectedValues, defaultValue) {
+    if (!expectedValues) {
+      throw new Error(`env.oneOf requires expectedValues`);
+    }
+    if (defaultValue && !expectedValues.includes(defaultValue)) {
+      throw new Error(`env.oneOf requires defaultValue to be included in expectedValues`);
+    }
+    const rawValue = env(key, defaultValue);
+    return expectedValues.includes(rawValue) ? rawValue : defaultValue ?? "";
+  }
+};
+var env = Object.assign(_env, utils);
+
+// src/services/email.ts
+import { getService } from "@cloudnux/core-cloud-provider";
+var { mkdir: mkdir3, writeFile: writeFile3, readdir, readFile: readFile3, unlink } = fs3.promises;
+var MAX_HISTORY = 100;
+function resolveBaseDir() {
+  return env("DEV_CLOUD_EMAIL_DIR", path3.join(process.cwd(), ".local-email"));
+}
+async function listEntryIds(baseDir) {
+  if (!fs3.existsSync(baseDir)) return [];
+  const files = await readdir(baseDir);
+  return files.filter((file) => file.endsWith(".json")).map((file) => file.slice(0, -".json".length)).sort().reverse();
+}
+async function listEmailHistory(limit = MAX_HISTORY) {
+  const baseDir = resolveBaseDir();
+  const ids = (await listEntryIds(baseDir)).slice(0, limit);
+  return Promise.all(ids.map(async (id) => {
+    const raw = await readFile3(path3.join(baseDir, `${id}.json`), "utf8");
+    return JSON.parse(raw);
+  }));
+}
+async function getEmailHistoryEntry(id) {
+  try {
+    const raw = await readFile3(path3.join(resolveBaseDir(), `${id}.json`), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+async function getEmailRaw(id) {
+  try {
+    return await readFile3(path3.join(resolveBaseDir(), `${id}.eml`), "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function extractHeader(headerBlock, name) {
+  const match = headerBlock.match(new RegExp(`^${name}:\\s*(.+)$`, "im"));
+  return match?.[1]?.trim();
+}
+function collectParts(part, result) {
+  const boundaryIdx = part.indexOf("\r\n\r\n");
+  const headerBlock = boundaryIdx === -1 ? part : part.slice(0, boundaryIdx);
+  const body = boundaryIdx === -1 ? "" : part.slice(boundaryIdx + 4);
+  const contentType = extractHeader(headerBlock, "Content-Type") ?? "text/plain";
+  const boundaryMatch = contentType.match(/boundary="?([^";]+)"?/i);
+  if (/^multipart\//i.test(contentType) && boundaryMatch) {
+    const boundary = boundaryMatch[1];
+    for (const chunk of body.split(`--${boundary}`)) {
+      const trimmed = chunk.replace(/^\r\n/, "");
+      if (!trimmed || trimmed.startsWith("--")) continue;
+      collectParts(trimmed, result);
+    }
+    return;
+  }
+  if (/^attachment/i.test(extractHeader(headerBlock, "Content-Disposition") ?? "")) return;
+  const encoding = (extractHeader(headerBlock, "Content-Transfer-Encoding") ?? "").toLowerCase();
+  const raw = body.replace(/\r\n$/, "");
+  const decoded = encoding === "base64" ? Buffer.from(raw.replace(/\r?\n/g, ""), "base64").toString("utf8") : raw;
+  if (/^text\/html/i.test(contentType)) {
+    result.html = decoded;
+  } else if (/^text\/plain/i.test(contentType)) {
+    result.text = decoded;
+  }
+}
+async function getEmailBody(id) {
+  const raw = await getEmailRaw(id);
+  if (raw === void 0) return void 0;
+  const result = {};
+  collectParts(raw, result);
+  return result;
+}
+
 // src/dev-console-plugin/plugin.ts
 var require2 = createRequire(import.meta.url);
 var LogStore = class {
@@ -2057,6 +2990,63 @@ async function devConsolePluginFunction(fastify, options = {}) {
       });
     }
   });
+  const summarizeSubscribers = (subscriberQueues) => subscriberQueues.map((queueName) => {
+    const stats = fastify.queues.getQueueStats(queueName);
+    return {
+      queueName,
+      module: stats?.module,
+      stats: stats ? {
+        incoming: stats.incoming.length,
+        processing: stats.processing.length,
+        dlq: stats.dlq.length
+      } : null
+    };
+  });
+  fastify.get(`/${prefix}/topics`, async (_, reply) => {
+    const queueManager = fastify.queues;
+    if (!queueManager) {
+      return reply.status(503).send({ error: "Queue service not available" });
+    }
+    const topics = Object.entries(queueManager.listTopics()).map(([name, subscriberQueues]) => ({
+      name,
+      subscribers: summarizeSubscribers(subscriberQueues)
+    }));
+    return { topics };
+  });
+  fastify.get(`/${prefix}/topics/:topicName`, async (request, reply) => {
+    const { topicName } = request.params;
+    const queueManager = fastify.queues;
+    if (!queueManager) {
+      return reply.status(503).send({ error: "Queue service not available" });
+    }
+    const subscriberQueues = queueManager.listTopics()[topicName];
+    if (!subscriberQueues) {
+      return reply.status(404).send({ error: "Topic not found" });
+    }
+    return {
+      name: topicName,
+      subscribers: summarizeSubscribers(subscriberQueues)
+    };
+  });
+  fastify.post(`/${prefix}/topics/:topicName/publish`, async (request, reply) => {
+    const { topicName } = request.params;
+    const queueManager = fastify.queues;
+    if (!queueManager) {
+      return reply.status(503).send({ error: "Queue service not available" });
+    }
+    try {
+      const results = await queueManager.publishTopic(topicName, request.body, request.headers);
+      if (results === null) {
+        return reply.status(404).send({ error: "Topic not found" });
+      }
+      return reply.status(200).send({ topicName, results });
+    } catch (error) {
+      return reply.status(500).send({
+        message: "Failed to publish to topic",
+        error
+      });
+    }
+  });
   fastify.get(`/${prefix}/schedules`, async (_, reply) => {
     const schedulerManager = fastify.scheduler;
     if (!schedulerManager) {
@@ -2221,6 +3211,35 @@ async function devConsolePluginFunction(fastify, options = {}) {
       return reply.status(404).send({ error: error.message });
     }
   });
+  fastify.get(`/${prefix}/emails`, async (request) => {
+    const { limit } = request.query;
+    return { emails: await listEmailHistory(limit ? Number(limit) : void 0) };
+  });
+  fastify.get(`/${prefix}/emails/:id`, async (request, reply) => {
+    const { id } = request.params;
+    const email = await getEmailHistoryEntry(id);
+    if (!email) {
+      return reply.status(404).send({ error: "Email not found" });
+    }
+    return { email };
+  });
+  fastify.get(`/${prefix}/emails/:id/raw`, async (request, reply) => {
+    const { id } = request.params;
+    const raw = await getEmailRaw(id);
+    if (!raw) {
+      return reply.status(404).send({ error: "Email not found" });
+    }
+    reply.type("message/rfc822");
+    return raw;
+  });
+  fastify.get(`/${prefix}/emails/:id/body`, async (request, reply) => {
+    const { id } = request.params;
+    const body = await getEmailBody(id);
+    if (!body) {
+      return reply.status(404).send({ error: "Email not found" });
+    }
+    return { body };
+  });
   fastify.get(`/${prefix}/logs/stream`, async (request, reply) => {
     const { level, module, reqId } = request.query;
     const matchesFilters = (log) => {
@@ -2249,7 +3268,7 @@ async function devConsolePluginFunction(fastify, options = {}) {
     });
   });
   if (enableUI) {
-    const devConsolePath = path3.dirname(
+    const devConsolePath = path4.dirname(
       require2.resolve("@cloudnux/dev-console/dist/index.html")
     );
     await fastify.register(fastifyStatic, {
@@ -2269,4 +3288,17 @@ export {
   devConsolePlugin,
   routeRegistry
 };
+/*! Bundled license information:
+
+lodash-es/lodash.js:
+  (**
+   * @license
+   * Lodash (Custom Build) <https://lodash.com/>
+   * Build: `lodash modularize exports="es" -o ./`
+   * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
+   * Released under MIT license <https://lodash.com/license>
+   * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+   * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+   *)
+*/
 //# sourceMappingURL=index.js.map