@frontmcp/utils 1.8.5 → 1.8.7

package/env/runtime-context.d.ts

@@ -16,7 +16,7 @@
  */
 /**
  * Snapshot of the current runtime environment. Detected once and cached
- * for the lifetime of the process.
+ * for the lifetime of the process (`env` is read live from `NODE_ENV`).
  */
 export interface RuntimeContext {
     /** OS platform: 'darwin', 'linux', 'win32', etc. (issue #417: renamed from platform) */
@@ -134,7 +134,11 @@ export declare function checkEntryAvailability(availability: EntryAvailability |
 export declare function detectRuntimeContext(): RuntimeContext;
 /**
  * Get the current runtime context (lazy singleton).
- * The context is detected on first call and cached for the process lifetime.
+ * The context is detected on first call and cached for the process lifetime,
+ * except `env`, which always reflects the live `NODE_ENV`. A Cloudflare Worker's
+ * `[vars]` reach `process.env` on the first request, after module evaluation has
+ * already read this context, so a frozen `env` would report `development` in a
+ * production deployment.
  */
 export declare function getRuntimeContext(): RuntimeContext;
 /**

package/esm/async-context/browser-async-context.mjs

@@ -1,5 +1,6 @@
-import { createRequire as __frontmcpCreateRequire } from 'module';
-const require = __frontmcpCreateRequire(import.meta.url || 'file:///');
+const __frontmcpModule = typeof process !== "undefined" && typeof process.getBuiltinModule === "function" ? process.getBuiltinModule("module") : undefined;
+const require = __frontmcpModule ? __frontmcpModule.createRequire(import.meta.url || 'file:///') : undefined;
+// __frontmcpCreateRequire
 // libs/utils/src/async-context/overlap-error.ts
 var AsyncContextOverlapError = class extends Error {
   constructor(message) {

package/esm/async-context/node-async-context.mjs

@@ -1,5 +1,6 @@
-import { createRequire as __frontmcpCreateRequire } from 'module';
-const require = __frontmcpCreateRequire(import.meta.url || 'file:///');
+const __frontmcpModule = typeof process !== "undefined" && typeof process.getBuiltinModule === "function" ? process.getBuiltinModule("module") : undefined;
+const require = __frontmcpModule ? __frontmcpModule.createRequire(import.meta.url || 'file:///') : undefined;
+// __frontmcpCreateRequire
 // libs/utils/src/async-context/node-async-context.ts
 import { AsyncLocalStorage } from "node:async_hooks";
 

package/esm/crypto/browser.mjs

@@ -1,5 +1,6 @@
-import { createRequire as __frontmcpCreateRequire } from 'module';
-const require = __frontmcpCreateRequire(import.meta.url || 'file:///');
+const __frontmcpModule = typeof process !== "undefined" && typeof process.getBuiltinModule === "function" ? process.getBuiltinModule("module") : undefined;
+const require = __frontmcpModule ? __frontmcpModule.createRequire(import.meta.url || 'file:///') : undefined;
+// __frontmcpCreateRequire
 // libs/utils/src/crypto/browser.ts
 import { sha256 as sha256Hash } from "@noble/hashes/sha2.js";
 import { hmac } from "@noble/hashes/hmac.js";

package/esm/crypto/node.mjs

@@ -1,5 +1,6 @@
-import { createRequire as __frontmcpCreateRequire } from 'module';
-const require = __frontmcpCreateRequire(import.meta.url || 'file:///');
+const __frontmcpModule = typeof process !== "undefined" && typeof process.getBuiltinModule === "function" ? process.getBuiltinModule("module") : undefined;
+const require = __frontmcpModule ? __frontmcpModule.createRequire(import.meta.url || 'file:///') : undefined;
+// __frontmcpCreateRequire
 // libs/utils/src/crypto/node.ts
 import crypto from "node:crypto";
 

package/esm/env/browser-env.mjs

@@ -1,5 +1,6 @@
-import { createRequire as __frontmcpCreateRequire } from 'module';
-const require = __frontmcpCreateRequire(import.meta.url || 'file:///');
+const __frontmcpModule = typeof process !== "undefined" && typeof process.getBuiltinModule === "function" ? process.getBuiltinModule("module") : undefined;
+const require = __frontmcpModule ? __frontmcpModule.createRequire(import.meta.url || 'file:///') : undefined;
+// __frontmcpCreateRequire
 // libs/utils/src/env/edge-scope.ts
 function hasEdgeGlobalScope() {
   if (typeof globalThis === "undefined") return false;

package/esm/env/node-env.mjs

@@ -1,5 +1,6 @@
-import { createRequire as __frontmcpCreateRequire } from 'module';
-const require = __frontmcpCreateRequire(import.meta.url || 'file:///');
+const __frontmcpModule = typeof process !== "undefined" && typeof process.getBuiltinModule === "function" ? process.getBuiltinModule("module") : undefined;
+const require = __frontmcpModule ? __frontmcpModule.createRequire(import.meta.url || 'file:///') : undefined;
+// __frontmcpCreateRequire
 // libs/utils/src/env/edge-scope.ts
 function hasEdgeGlobalScope() {
   if (typeof globalThis === "undefined") return false;

package/esm/event-emitter/browser-event-emitter.mjs

@@ -1,5 +1,6 @@
-import { createRequire as __frontmcpCreateRequire } from 'module';
-const require = __frontmcpCreateRequire(import.meta.url || 'file:///');
+const __frontmcpModule = typeof process !== "undefined" && typeof process.getBuiltinModule === "function" ? process.getBuiltinModule("module") : undefined;
+const require = __frontmcpModule ? __frontmcpModule.createRequire(import.meta.url || 'file:///') : undefined;
+// __frontmcpCreateRequire
 // libs/utils/src/event-emitter/browser-event-emitter.ts
 var EventEmitter = class {
   events = /* @__PURE__ */ new Map();

package/esm/event-emitter/node-event-emitter.mjs

@@ -1,5 +1,6 @@
-import { createRequire as __frontmcpCreateRequire } from 'module';
-const require = __frontmcpCreateRequire(import.meta.url || 'file:///');
+const __frontmcpModule = typeof process !== "undefined" && typeof process.getBuiltinModule === "function" ? process.getBuiltinModule("module") : undefined;
+const require = __frontmcpModule ? __frontmcpModule.createRequire(import.meta.url || 'file:///') : undefined;
+// __frontmcpCreateRequire
 // libs/utils/src/event-emitter/node-event-emitter.ts
 import { EventEmitter } from "events";
 export {

package/esm/index.mjs

@@ -1,5 +1,6 @@
-import { createRequire as __frontmcpCreateRequire } from 'module';
-const require = __frontmcpCreateRequire(import.meta.url || 'file:///');
+const __frontmcpModule = typeof process !== "undefined" && typeof process.getBuiltinModule === "function" ? process.getBuiltinModule("module") : undefined;
+const require = __frontmcpModule ? __frontmcpModule.createRequire(import.meta.url || 'file:///') : undefined;
+// __frontmcpCreateRequire
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -2962,6 +2963,41 @@ var init_crypto = __esm({
   }
 });
 
+// libs/utils/src/storage/redis-error-listener.ts
+function attachRedisErrorListener(client, options = {}) {
+  const label = options.label ?? "redis";
+  const intervalMs = options.intervalMs ?? DEFAULT_REDIS_ERROR_LOG_INTERVAL_MS;
+  let lastLoggedAt = 0;
+  let suppressed = 0;
+  const listener = (error) => {
+    const now = Date.now();
+    if (lastLoggedAt !== 0 && now - lastLoggedAt < intervalMs) {
+      suppressed++;
+      return;
+    }
+    const extra = suppressed > 0 ? ` (${suppressed} similar error(s) suppressed)` : "";
+    suppressed = 0;
+    lastLoggedAt = now;
+    const message = `[${label}] Redis connection error: ${error?.message ?? String(error)}${extra}`;
+    if (options.logger) {
+      options.logger.warn(message);
+    } else {
+      console.warn(message);
+    }
+  };
+  client.on("error", listener);
+  return () => {
+    client.removeListener("error", listener);
+  };
+}
+var DEFAULT_REDIS_ERROR_LOG_INTERVAL_MS;
+var init_redis_error_listener = __esm({
+  "libs/utils/src/storage/redis-error-listener.ts"() {
+    "use strict";
+    DEFAULT_REDIS_ERROR_LOG_INTERVAL_MS = 3e4;
+  }
+});
+
 // libs/utils/src/storage/utils/index.ts
 var init_utils = __esm({
   "libs/utils/src/storage/utils/index.ts"() {
@@ -2973,7 +3009,8 @@ var init_utils = __esm({
 // libs/utils/src/storage/adapters/redis.ts
 var redis_exports = {};
 __export(redis_exports, {
-  RedisStorageAdapter: () => RedisStorageAdapter
+  RedisStorageAdapter: () => RedisStorageAdapter,
+  createRedisClient: () => createRedisClient
 });
 function getRedisClass() {
   try {
@@ -2982,25 +3019,45 @@ function getRedisClass() {
     const msg = error instanceof Error ? error.message : String(error);
     if (msg.includes("Dynamic require") || msg.includes("require is not defined")) {
       throw new Error(
-        `Failed to load ioredis: ${msg}. This typically happens with ESM bundlers (esbuild, Vite). Ensure your bundler externalizes ioredis or use CJS mode.`
+        `Failed to load ioredis: ${msg}. This typically happens with ESM bundlers (esbuild, Vite). Ensure your bundler externalizes ioredis or use CJS mode.`,
+        { cause: error }
       );
     }
-    throw new Error("ioredis is required for Redis storage adapter. Install it with: npm install ioredis");
+    throw new Error("ioredis is required for Redis storage adapter. Install it with: npm install ioredis", {
+      cause: error
+    });
   }
 }
+function createRedisClient(options) {
+  const RedisClass = getRedisClass();
+  const baseOptions = { lazyConnect: false, maxRetriesPerRequest: 3 };
+  const client = options.url ? new RedisClass(options.url, baseOptions) : new RedisClass({
+    ...baseOptions,
+    host: options.host ?? "localhost",
+    port: options.port ?? 6379,
+    password: options.password,
+    db: options.db ?? 0,
+    tls: options.tls ? {} : void 0
+  });
+  attachRedisErrorListener(client, { label: options.label ?? "redis", logger: options.logger });
+  return client;
+}
 var RedisStorageAdapter;
 var init_redis = __esm({
   "libs/utils/src/storage/adapters/redis.ts"() {
     "use strict";
-    init_base();
     init_errors();
+    init_redis_error_listener();
     init_utils();
+    init_base();
     RedisStorageAdapter = class extends BaseStorageAdapter {
       backendName = "redis";
       client;
       subscriber;
       options;
       ownsClient;
+      detachErrorListener;
+      connecting;
       keyPrefix;
       subscriptionHandlers = /* @__PURE__ */ new Map();
       constructor(options = {}) {
@@ -3030,21 +3087,45 @@ var init_redis = __esm({
       // ============================================
       async connect() {
         if (this.connected) return;
+        this.connecting ??= this.openConnection().finally(() => {
+          this.connecting = void 0;
+        });
+        return this.connecting;
+      }
+      async openConnection() {
+        let socketError;
+        const recordSocketError = (error) => {
+          socketError = error;
+        };
+        let client;
         try {
           if (this.options.client) {
-            this.client = this.options.client;
+            client = this.options.client;
           } else {
             const RedisClass = getRedisClass();
             if (this.options.url) {
-              this.client = new RedisClass(this.options.url, this.buildRedisOptions());
+              client = new RedisClass(this.options.url, this.buildRedisOptions());
             } else {
-              this.client = new RedisClass(this.buildRedisOptions());
+              client = new RedisClass(this.buildRedisOptions());
             }
+            client.on("error", recordSocketError);
           }
-          await this.client.ping();
+          await client.ping();
+          this.client = client;
           this.connected = true;
+          if (this.ownsClient) {
+            client.removeListener("error", recordSocketError);
+            this.detachErrorListener = attachRedisErrorListener(client, { label: "RedisStorage" });
+          }
         } catch (e) {
-          throw new StorageConnectionError("Failed to connect to Redis", e instanceof Error ? e : void 0, "redis");
+          if (this.ownsClient && client) {
+            try {
+              client.disconnect();
+            } catch {
+            }
+          }
+          const cause = socketError ?? (e instanceof Error ? e : void 0);
+          throw new StorageConnectionError("Failed to connect to Redis", cause, "redis");
         }
       }
       async disconnect() {
@@ -3056,6 +3137,8 @@ var init_redis = __esm({
         if (this.ownsClient && this.client) {
           await this.client.quit();
         }
+        this.detachErrorListener?.();
+        this.detachErrorListener = void 0;
         this.client = void 0;
         this.connected = false;
         this.subscriptionHandlers.clear();
@@ -3283,6 +3366,7 @@ var init_redis = __esm({
         } else {
           throw new StorageConfigError("redis", "Cannot create subscriber without url, config, or client");
         }
+        attachRedisErrorListener(subscriber, { label: "RedisStorage:subscriber" });
         subscriber.on("message", (channel, message) => {
           const handlers = this.subscriptionHandlers.get(channel);
           if (handlers) {
@@ -4952,7 +5036,13 @@ function detectRuntimeContext() {
 var cached3;
 function getRuntimeContext() {
   if (!cached3) {
-    cached3 = detectRuntimeContext();
+    const detected = detectRuntimeContext();
+    Object.defineProperty(detected, "env", {
+      get: () => process.env["NODE_ENV"] || "development",
+      enumerable: true,
+      configurable: true
+    });
+    cached3 = detected;
   }
   return cached3;
 }
@@ -5223,6 +5313,7 @@ function getDetectedStorageType() {
 }
 
 // libs/utils/src/storage/index.ts
+init_redis_error_listener();
 init_errors();
 
 // libs/utils/src/storage/typed-storage.ts
@@ -5877,6 +5968,7 @@ export {
   BaseStorageAdapter,
   DEFAULT_CODE_VERIFIER_LENGTH,
   DEFAULT_MAX_INPUT_LENGTH,
+  DEFAULT_REDIS_ERROR_LOG_INTERVAL_MS,
   EncryptedBlobError,
   EncryptedStorageError,
   EncryptedTypedStorage,
@@ -5909,6 +6001,7 @@ export {
   assertNode,
   asymmetricAlgSchema,
   asymmetricKeyDataSchema,
+  attachRedisErrorListener,
   awaitOutsideRequest,
   base64Decode,
   base64Encode,
@@ -5929,6 +6022,7 @@ export {
   createKeyPersistenceWithStorage,
   createMemoryStorage,
   createNamespacedStorage,
+  createRedisClient,
   createRootStorage,
   createSafeRegExp,
   createSecretData,

package/index.d.ts

@@ -26,8 +26,8 @@ export { EventEmitter } from './event-emitter';
 export { getEnv, getCwd, isProduction, isDevelopment, getEnvFlag, isDebug, setEnv, isEdgeRuntime, isServerless, supportsAnsi, getRuntimeContext, resetRuntimeContext, detectRuntimeContext, isEntryAvailable, checkEntryAvailability, entryAvailabilitySchema, } from './env';
 export type { RuntimeContext, EntryAvailability } from './env';
 export { analyzePattern, isPatternSafe, createSafeRegExp, safeTest, safeMatch, safeReplace, safeExec, isInputLengthSafe, DEFAULT_MAX_INPUT_LENGTH, REDOS_THRESHOLDS, trimLeading, trimTrailing, trimBoth, trimChars, extractBracedParams, expandTemplate, hasTemplatePlaceholders, collapseChar, collapseWhitespace, type SafeRegexOptions, type PatternAnalysisResult, } from './regex';
-export { createStorage, createMemoryStorage, getDetectedStorageType, NamespacedStorageImpl, createRootStorage, createNamespacedStorage, buildPrefix, NAMESPACE_SEPARATOR, StorageError, StorageConnectionError, StorageOperationError, StorageNotSupportedError, StorageConfigError, StorageTTLError, StoragePatternError, StorageNotConnectedError, EncryptedStorageError, BaseStorageAdapter, MemoryStorageAdapter, RedisStorageAdapter, VercelKvStorageAdapter, UpstashStorageAdapter, FileSystemStorageAdapter, type FileSystemAdapterOptions, TypedStorage, type TypedStorageOptions, type TypedSetOptions, type TypedSetEntry, EncryptedTypedStorage, type EncryptedTypedStorageOptions, type EncryptedSetOptions, type EncryptedSetEntry, type EncryptionKey, type StoredEncryptedBlob, type ClientKeyBinding, globToRegex, matchesPattern, validatePattern, escapeGlob, MAX_TTL_SECONDS, validateTTL, validateOptionalTTL, ttlToExpiresAt, expiresAtToTTL, isExpired, normalizeTTL, } from './storage';
-export type { StorageAdapter, NamespacedStorage, RootStorage, SetOptions, SetEntry, MessageHandler, Unsubscribe, MemoryAdapterOptions, RedisAdapterOptions, VercelKvAdapterOptions, UpstashAdapterOptions, StorageType, StorageConfig, } from './storage';
+export { createStorage, createMemoryStorage, getDetectedStorageType, NamespacedStorageImpl, createRootStorage, createNamespacedStorage, buildPrefix, NAMESPACE_SEPARATOR, StorageError, StorageConnectionError, StorageOperationError, StorageNotSupportedError, StorageConfigError, StorageTTLError, StoragePatternError, StorageNotConnectedError, EncryptedStorageError, BaseStorageAdapter, MemoryStorageAdapter, RedisStorageAdapter, createRedisClient, VercelKvStorageAdapter, UpstashStorageAdapter, FileSystemStorageAdapter, type FileSystemAdapterOptions, TypedStorage, type TypedStorageOptions, type TypedSetOptions, type TypedSetEntry, EncryptedTypedStorage, type EncryptedTypedStorageOptions, type EncryptedSetOptions, type EncryptedSetEntry, type EncryptionKey, type StoredEncryptedBlob, type ClientKeyBinding, globToRegex, matchesPattern, validatePattern, escapeGlob, MAX_TTL_SECONDS, validateTTL, validateOptionalTTL, ttlToExpiresAt, expiresAtToTTL, isExpired, normalizeTTL, attachRedisErrorListener, DEFAULT_REDIS_ERROR_LOG_INTERVAL_MS, } from './storage';
+export type { StorageAdapter, NamespacedStorage, RootStorage, SetOptions, SetEntry, MessageHandler, Unsubscribe, MemoryAdapterOptions, RedisAdapterOptions, VercelKvAdapterOptions, UpstashAdapterOptions, StorageType, StorageConfig, RedisErrorListenerOptions, CreateRedisClientOptions, ErrorEmitterClient, } from './storage';
 export { processPlatformToolCalls } from './llm';
 export type { CallToolFn, OpenAIToolCallItem, OpenAIToolResponse, ClaudeToolUseBlock, ClaudeToolResultBlock, VercelToolCallInfo, PlatformToolCallsInput, PlatformToolCallsOutput, SupportedPlatform, } from './llm';
 export { getMachineId, setMachineIdOverride } from './machine-id';

package/index.js

@@ -2965,6 +2965,41 @@ var init_crypto = __esm({
   }
 });
 
+// libs/utils/src/storage/redis-error-listener.ts
+function attachRedisErrorListener(client, options = {}) {
+  const label = options.label ?? "redis";
+  const intervalMs = options.intervalMs ?? DEFAULT_REDIS_ERROR_LOG_INTERVAL_MS;
+  let lastLoggedAt = 0;
+  let suppressed = 0;
+  const listener = (error) => {
+    const now = Date.now();
+    if (lastLoggedAt !== 0 && now - lastLoggedAt < intervalMs) {
+      suppressed++;
+      return;
+    }
+    const extra = suppressed > 0 ? ` (${suppressed} similar error(s) suppressed)` : "";
+    suppressed = 0;
+    lastLoggedAt = now;
+    const message = `[${label}] Redis connection error: ${error?.message ?? String(error)}${extra}`;
+    if (options.logger) {
+      options.logger.warn(message);
+    } else {
+      console.warn(message);
+    }
+  };
+  client.on("error", listener);
+  return () => {
+    client.removeListener("error", listener);
+  };
+}
+var DEFAULT_REDIS_ERROR_LOG_INTERVAL_MS;
+var init_redis_error_listener = __esm({
+  "libs/utils/src/storage/redis-error-listener.ts"() {
+    "use strict";
+    DEFAULT_REDIS_ERROR_LOG_INTERVAL_MS = 3e4;
+  }
+});
+
 // libs/utils/src/storage/utils/index.ts
 var init_utils = __esm({
   "libs/utils/src/storage/utils/index.ts"() {
@@ -2976,7 +3011,8 @@ var init_utils = __esm({
 // libs/utils/src/storage/adapters/redis.ts
 var redis_exports = {};
 __export(redis_exports, {
-  RedisStorageAdapter: () => RedisStorageAdapter
+  RedisStorageAdapter: () => RedisStorageAdapter,
+  createRedisClient: () => createRedisClient
 });
 function getRedisClass() {
   try {
@@ -2985,25 +3021,45 @@ function getRedisClass() {
     const msg = error instanceof Error ? error.message : String(error);
     if (msg.includes("Dynamic require") || msg.includes("require is not defined")) {
       throw new Error(
-        `Failed to load ioredis: ${msg}. This typically happens with ESM bundlers (esbuild, Vite). Ensure your bundler externalizes ioredis or use CJS mode.`
+        `Failed to load ioredis: ${msg}. This typically happens with ESM bundlers (esbuild, Vite). Ensure your bundler externalizes ioredis or use CJS mode.`,
+        { cause: error }
       );
     }
-    throw new Error("ioredis is required for Redis storage adapter. Install it with: npm install ioredis");
+    throw new Error("ioredis is required for Redis storage adapter. Install it with: npm install ioredis", {
+      cause: error
+    });
   }
 }
+function createRedisClient(options) {
+  const RedisClass = getRedisClass();
+  const baseOptions = { lazyConnect: false, maxRetriesPerRequest: 3 };
+  const client = options.url ? new RedisClass(options.url, baseOptions) : new RedisClass({
+    ...baseOptions,
+    host: options.host ?? "localhost",
+    port: options.port ?? 6379,
+    password: options.password,
+    db: options.db ?? 0,
+    tls: options.tls ? {} : void 0
+  });
+  attachRedisErrorListener(client, { label: options.label ?? "redis", logger: options.logger });
+  return client;
+}
 var RedisStorageAdapter;
 var init_redis = __esm({
   "libs/utils/src/storage/adapters/redis.ts"() {
     "use strict";
-    init_base();
     init_errors();
+    init_redis_error_listener();
     init_utils();
+    init_base();
     RedisStorageAdapter = class extends BaseStorageAdapter {
       backendName = "redis";
       client;
       subscriber;
       options;
       ownsClient;
+      detachErrorListener;
+      connecting;
       keyPrefix;
       subscriptionHandlers = /* @__PURE__ */ new Map();
       constructor(options = {}) {
@@ -3033,21 +3089,45 @@ var init_redis = __esm({
       // ============================================
       async connect() {
         if (this.connected) return;
+        this.connecting ??= this.openConnection().finally(() => {
+          this.connecting = void 0;
+        });
+        return this.connecting;
+      }
+      async openConnection() {
+        let socketError;
+        const recordSocketError = (error) => {
+          socketError = error;
+        };
+        let client;
         try {
           if (this.options.client) {
-            this.client = this.options.client;
+            client = this.options.client;
           } else {
             const RedisClass = getRedisClass();
             if (this.options.url) {
-              this.client = new RedisClass(this.options.url, this.buildRedisOptions());
+              client = new RedisClass(this.options.url, this.buildRedisOptions());
             } else {
-              this.client = new RedisClass(this.buildRedisOptions());
+              client = new RedisClass(this.buildRedisOptions());
             }
+            client.on("error", recordSocketError);
           }
-          await this.client.ping();
+          await client.ping();
+          this.client = client;
           this.connected = true;
+          if (this.ownsClient) {
+            client.removeListener("error", recordSocketError);
+            this.detachErrorListener = attachRedisErrorListener(client, { label: "RedisStorage" });
+          }
         } catch (e) {
-          throw new StorageConnectionError("Failed to connect to Redis", e instanceof Error ? e : void 0, "redis");
+          if (this.ownsClient && client) {
+            try {
+              client.disconnect();
+            } catch {
+            }
+          }
+          const cause = socketError ?? (e instanceof Error ? e : void 0);
+          throw new StorageConnectionError("Failed to connect to Redis", cause, "redis");
         }
       }
       async disconnect() {
@@ -3059,6 +3139,8 @@ var init_redis = __esm({
         if (this.ownsClient && this.client) {
           await this.client.quit();
         }
+        this.detachErrorListener?.();
+        this.detachErrorListener = void 0;
         this.client = void 0;
         this.connected = false;
         this.subscriptionHandlers.clear();
@@ -3286,6 +3368,7 @@ var init_redis = __esm({
         } else {
           throw new StorageConfigError("redis", "Cannot create subscriber without url, config, or client");
         }
+        attachRedisErrorListener(subscriber, { label: "RedisStorage:subscriber" });
         subscriber.on("message", (channel, message) => {
           const handlers = this.subscriptionHandlers.get(channel);
           if (handlers) {
@@ -3982,6 +4065,7 @@ __export(index_exports, {
   BaseStorageAdapter: () => BaseStorageAdapter,
   DEFAULT_CODE_VERIFIER_LENGTH: () => DEFAULT_CODE_VERIFIER_LENGTH,
   DEFAULT_MAX_INPUT_LENGTH: () => DEFAULT_MAX_INPUT_LENGTH,
+  DEFAULT_REDIS_ERROR_LOG_INTERVAL_MS: () => DEFAULT_REDIS_ERROR_LOG_INTERVAL_MS,
   EncryptedBlobError: () => EncryptedBlobError,
   EncryptedStorageError: () => EncryptedStorageError,
   EncryptedTypedStorage: () => EncryptedTypedStorage,
@@ -4014,6 +4098,7 @@ __export(index_exports, {
   assertNode: () => assertNode,
   asymmetricAlgSchema: () => asymmetricAlgSchema,
   asymmetricKeyDataSchema: () => asymmetricKeyDataSchema,
+  attachRedisErrorListener: () => attachRedisErrorListener,
   awaitOutsideRequest: () => import_async_context.awaitOutsideRequest,
   base64Decode: () => base64Decode,
   base64Encode: () => base64Encode,
@@ -4034,6 +4119,7 @@ __export(index_exports, {
   createKeyPersistenceWithStorage: () => createKeyPersistenceWithStorage,
   createMemoryStorage: () => createMemoryStorage,
   createNamespacedStorage: () => createNamespacedStorage,
+  createRedisClient: () => createRedisClient,
   createRootStorage: () => createRootStorage,
   createSafeRegExp: () => createSafeRegExp,
   createSecretData: () => createSecretData,
@@ -5169,7 +5255,13 @@ function detectRuntimeContext() {
 var cached3;
 function getRuntimeContext() {
   if (!cached3) {
-    cached3 = detectRuntimeContext();
+    const detected = detectRuntimeContext();
+    Object.defineProperty(detected, "env", {
+      get: () => process.env["NODE_ENV"] || "development",
+      enumerable: true,
+      configurable: true
+    });
+    cached3 = detected;
   }
   return cached3;
 }
@@ -5440,6 +5532,7 @@ function getDetectedStorageType() {
 }
 
 // libs/utils/src/storage/index.ts
+init_redis_error_listener();
 init_errors();
 
 // libs/utils/src/storage/typed-storage.ts
@@ -6095,6 +6188,7 @@ function setMachineIdOverride(id) {
   BaseStorageAdapter,
   DEFAULT_CODE_VERIFIER_LENGTH,
   DEFAULT_MAX_INPUT_LENGTH,
+  DEFAULT_REDIS_ERROR_LOG_INTERVAL_MS,
   EncryptedBlobError,
   EncryptedStorageError,
   EncryptedTypedStorage,
@@ -6127,6 +6221,7 @@ function setMachineIdOverride(id) {
   assertNode,
   asymmetricAlgSchema,
   asymmetricKeyDataSchema,
+  attachRedisErrorListener,
   awaitOutsideRequest,
   base64Decode,
   base64Encode,
@@ -6147,6 +6242,7 @@ function setMachineIdOverride(id) {
   createKeyPersistenceWithStorage,
   createMemoryStorage,
   createNamespacedStorage,
+  createRedisClient,
   createRootStorage,
   createSafeRegExp,
   createSecretData,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frontmcp/utils",
-  "version": "1.8.5",
+  "version": "1.8.7",
   "description": "Shared utility functions for FrontMCP - string manipulation, URI handling, path utilities, and more",
   "author": "AgentFront <info@agentfront.dev>",
   "license": "Apache-2.0",
@@ -32,7 +32,7 @@
     "@noble/hashes": "^2.0.1"
   },
   "peerDependencies": {
-    "@frontmcp/lazy-zod": "1.8.5",
+    "@frontmcp/lazy-zod": "1.8.7",
     "@vercel/kv": "^2.0.0 || ^3.0.0",
     "ioredis": "^5.0.0"
   },

package/storage/adapters/index.d.ts

@@ -5,7 +5,8 @@
  */
 export { BaseStorageAdapter } from './base';
 export { MemoryStorageAdapter } from './memory';
-export { RedisStorageAdapter } from './redis';
+export { RedisStorageAdapter, createRedisClient } from './redis';
+export type { CreateRedisClientOptions } from './redis';
 export { VercelKvStorageAdapter } from './vercel-kv';
 export { UpstashStorageAdapter } from './upstash';
 export { CloudflareKvStorageAdapter } from './cloudflare-kv';

package/storage/adapters/redis.d.ts

@@ -4,8 +4,9 @@
  * Redis-based storage implementation for production use.
  * Uses ioredis with dynamic import for browser compatibility.
  */
+import { type RedisErrorListenerOptions } from '../redis-error-listener';
+import type { MessageHandler, RedisAdapterOptions, SetOptions, Unsubscribe } from '../types';
 import { BaseStorageAdapter } from './base';
-import type { RedisAdapterOptions, SetOptions, MessageHandler, Unsubscribe } from '../types';
 type Redis = import('ioredis').Redis;
 /**
  * Redis storage adapter.
@@ -34,10 +35,13 @@ export declare class RedisStorageAdapter extends BaseStorageAdapter {
     private subscriber?;
     private readonly options;
     private readonly ownsClient;
+    private detachErrorListener?;
+    private connecting?;
     private readonly keyPrefix;
     private readonly subscriptionHandlers;
     constructor(options?: RedisAdapterOptions);
     connect(): Promise<void>;
+    private openConnection;
     disconnect(): Promise<void>;
     ping(): Promise<boolean>;
     /**
@@ -85,4 +89,20 @@ export declare class RedisStorageAdapter extends BaseStorageAdapter {
      */
     getClient(): Redis | undefined;
 }
+export interface CreateRedisClientOptions {
+    url?: string;
+    host?: string;
+    port?: number;
+    password?: string;
+    db?: number;
+    tls?: boolean;
+    /** Prefix for the rate-limited connection-error log line. */
+    label?: string;
+    logger?: RedisErrorListenerOptions['logger'];
+}
+/**
+ * Create a plain ioredis client that reconnects on its own and never emits an unhandled
+ * 'error' event. The caller owns the client and must `quit()`/`disconnect()` it.
+ */
+export declare function createRedisClient(options: CreateRedisClientOptions): Redis;
 export {};

package/storage/index.d.ts

@@ -6,13 +6,15 @@
  */
 export type { StorageAdapter, NamespacedStorage, RootStorage, SetOptions, SetEntry, MessageHandler, Unsubscribe, MemoryAdapterOptions, RedisAdapterOptions, VercelKvAdapterOptions, UpstashAdapterOptions, StorageType, StorageConfig, } from './types';
 export { createStorage, createMemoryStorage, getDetectedStorageType } from './factory';
+export { attachRedisErrorListener, DEFAULT_REDIS_ERROR_LOG_INTERVAL_MS } from './redis-error-listener';
+export type { RedisErrorListenerOptions, ErrorEmitterClient } from './redis-error-listener';
 export { NamespacedStorageImpl, createRootStorage, createNamespacedStorage, buildPrefix, NAMESPACE_SEPARATOR, } from './namespace';
 export { StorageError, StorageConnectionError, StorageOperationError, StorageNotSupportedError, StorageConfigError, StorageTTLError, StoragePatternError, StorageNotConnectedError, EncryptedStorageError, } from './errors';
 export { TypedStorage } from './typed-storage';
 export type { TypedStorageOptions, TypedSetOptions, TypedSetEntry } from './typed-storage.types';
 export { EncryptedTypedStorage } from './encrypted-typed-storage';
 export type { EncryptedTypedStorageOptions, EncryptedSetOptions, EncryptedSetEntry, EncryptionKey, StoredEncryptedBlob, ClientKeyBinding, } from './encrypted-typed-storage.types';
-export { BaseStorageAdapter, MemoryStorageAdapter, RedisStorageAdapter, VercelKvStorageAdapter, UpstashStorageAdapter, FileSystemStorageAdapter, LocalStorageAdapter, IndexedDBStorageAdapter, } from './adapters';
-export type { FileSystemAdapterOptions, LocalStorageAdapterOptions, IndexedDBAdapterOptions } from './adapters';
+export { BaseStorageAdapter, MemoryStorageAdapter, RedisStorageAdapter, createRedisClient, VercelKvStorageAdapter, UpstashStorageAdapter, FileSystemStorageAdapter, LocalStorageAdapter, IndexedDBStorageAdapter, } from './adapters';
+export type { CreateRedisClientOptions, FileSystemAdapterOptions, LocalStorageAdapterOptions, IndexedDBAdapterOptions, } from './adapters';
 export { globToRegex, matchesPattern, validatePattern, escapeGlob } from './utils/pattern';
 export { MAX_TTL_SECONDS, validateTTL, validateOptionalTTL, ttlToExpiresAt, expiresAtToTTL, isExpired, normalizeTTL, } from './utils/ttl';

package/storage/redis-error-listener.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Permanent, rate-limited 'error' listener for ioredis clients.
+ *
+ * ioredis emits 'error' for every failed reconnect attempt. With no listener it
+ * prints "[ioredis] Unhandled error event" once per attempt, which floods logs
+ * while Redis is down. This listener swallows the event and logs at most once
+ * per interval, counting the errors it suppressed.
+ */
+export interface RedisErrorListenerOptions {
+    /** Name used in the log line, e.g. 'HA'. */
+    label?: string;
+    /** Logger to write to. Falls back to `console.warn`. */
+    logger?: {
+        warn: (message: string, ...meta: unknown[]) => void;
+    };
+    /** Minimum time between two log lines. Defaults to 30 seconds. */
+    intervalMs?: number;
+}
+export interface ErrorEmitterClient {
+    on(event: 'error', listener: (error: Error) => void): unknown;
+    removeListener(event: 'error', listener: (error: Error) => void): unknown;
+}
+export declare const DEFAULT_REDIS_ERROR_LOG_INTERVAL_MS = 30000;
+/**
+ * Attach the listener and return a function that removes it.
+ */
+export declare function attachRedisErrorListener(client: ErrorEmitterClient, options?: RedisErrorListenerOptions): () => void;