@kya-os/mcp-i 0.1.0 → 1.2.0

package/dist/cache/__tests__/memory-nonce-cache.test.js

@@ -0,0 +1,132 @@
+"use strict";
+/**
+ * Tests for Memory Nonce Cache
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const memory_nonce_cache_js_1 = require("../memory-nonce-cache.js");
+(0, vitest_1.describe)("MemoryNonceCache", () => {
+    let cache;
+    (0, vitest_1.beforeEach)(() => {
+        cache = new memory_nonce_cache_js_1.MemoryNonceCache(100); // Short cleanup interval for testing
+    });
+    (0, vitest_1.afterEach)(() => {
+        cache.destroy();
+    });
+    (0, vitest_1.describe)("Basic Operations", () => {
+        (0, vitest_1.it)("should add and check nonce existence", async () => {
+            const nonce = "test-nonce-123";
+            // Initially should not exist
+            (0, vitest_1.expect)(await cache.has(nonce)).toBe(false);
+            // Add nonce
+            await cache.add(nonce, 60); // 60 seconds TTL
+            // Should now exist
+            (0, vitest_1.expect)(await cache.has(nonce)).toBe(true);
+        });
+        (0, vitest_1.it)("should prevent duplicate nonce addition", async () => {
+            const nonce = "duplicate-nonce";
+            // Add nonce first time
+            await cache.add(nonce, 60);
+            // Adding same nonce should throw
+            await (0, vitest_1.expect)(cache.add(nonce, 60)).rejects.toThrow("Nonce duplicate-nonce already exists");
+        });
+        (0, vitest_1.it)("should handle TTL expiration", async () => {
+            const nonce = "expiring-nonce";
+            // Add nonce with very short TTL
+            await cache.add(nonce, 0.1); // 0.1 seconds
+            // Should exist initially
+            (0, vitest_1.expect)(await cache.has(nonce)).toBe(true);
+            // Wait for expiration
+            await new Promise((resolve) => setTimeout(resolve, 200));
+            // Should be expired
+            (0, vitest_1.expect)(await cache.has(nonce)).toBe(false);
+        });
+    });
+    (0, vitest_1.describe)("Cleanup", () => {
+        (0, vitest_1.it)("should clean up expired entries", async () => {
+            const nonce1 = "nonce-1";
+            const nonce2 = "nonce-2";
+            // Add nonces with different TTLs
+            await cache.add(nonce1, 0.1); // Short TTL
+            await cache.add(nonce2, 60); // Long TTL
+            // Both should exist initially
+            (0, vitest_1.expect)(await cache.has(nonce1)).toBe(true);
+            (0, vitest_1.expect)(await cache.has(nonce2)).toBe(true);
+            // Wait for first nonce to expire
+            await new Promise((resolve) => setTimeout(resolve, 200));
+            // Manual cleanup
+            await cache.cleanup();
+            // First should be gone, second should remain
+            (0, vitest_1.expect)(await cache.has(nonce1)).toBe(false);
+            (0, vitest_1.expect)(await cache.has(nonce2)).toBe(true);
+        });
+        (0, vitest_1.it)("should provide accurate statistics", async () => {
+            const nonce1 = "stats-nonce-1";
+            const nonce2 = "stats-nonce-2";
+            // Add nonces
+            await cache.add(nonce1, 60);
+            await cache.add(nonce2, 0.1); // This will expire quickly
+            // Wait for one to expire
+            await new Promise((resolve) => setTimeout(resolve, 200));
+            const stats = cache.getStats();
+            (0, vitest_1.expect)(stats.size).toBeGreaterThanOrEqual(1); // At least one still in cache
+            (0, vitest_1.expect)(stats.expired).toBeGreaterThanOrEqual(0); // Some may be expired
+        });
+    });
+    (0, vitest_1.describe)("Atomic Operations", () => {
+        (0, vitest_1.it)("should prevent duplicate nonce addition", async () => {
+            const nonce = "atomic-test-nonce";
+            // Add nonce first time
+            await cache.add(nonce, 60);
+            // Second attempt should fail
+            await (0, vitest_1.expect)(cache.add(nonce, 60)).rejects.toThrow("Nonce atomic-test-nonce already exists");
+            // Nonce should still exist
+            (0, vitest_1.expect)(await cache.has(nonce)).toBe(true);
+        });
+    });
+    (0, vitest_1.describe)("Memory Management", () => {
+        (0, vitest_1.it)("should clear all entries", async () => {
+            // Add multiple nonces
+            await cache.add("nonce-1", 60);
+            await cache.add("nonce-2", 60);
+            await cache.add("nonce-3", 60);
+            // All should exist
+            (0, vitest_1.expect)(await cache.has("nonce-1")).toBe(true);
+            (0, vitest_1.expect)(await cache.has("nonce-2")).toBe(true);
+            (0, vitest_1.expect)(await cache.has("nonce-3")).toBe(true);
+            // Clear cache
+            cache.clear();
+            // None should exist
+            (0, vitest_1.expect)(await cache.has("nonce-1")).toBe(false);
+            (0, vitest_1.expect)(await cache.has("nonce-2")).toBe(false);
+            (0, vitest_1.expect)(await cache.has("nonce-3")).toBe(false);
+        });
+        (0, vitest_1.it)("should properly destroy cache and stop cleanup", async () => {
+            const cache2 = new memory_nonce_cache_js_1.MemoryNonceCache(50);
+            await cache2.add("test-nonce", 60);
+            (0, vitest_1.expect)(await cache2.has("test-nonce")).toBe(true);
+            // Destroy should clear cache and stop intervals
+            cache2.destroy();
+            (0, vitest_1.expect)(await cache2.has("test-nonce")).toBe(false);
+        });
+    });
+    (0, vitest_1.describe)("Edge Cases", () => {
+        (0, vitest_1.it)("should handle empty nonce strings", async () => {
+            await (0, vitest_1.expect)(cache.add("", 60)).resolves.not.toThrow();
+            (0, vitest_1.expect)(await cache.has("")).toBe(true);
+        });
+        (0, vitest_1.it)("should handle zero TTL", async () => {
+            const nonce = "zero-ttl-nonce";
+            await cache.add(nonce, 0);
+            // Zero TTL means it should be expired immediately
+            // The implementation stores it but it should be considered expired
+            (0, vitest_1.expect)(await cache.has(nonce)).toBe(false);
+        });
+        (0, vitest_1.it)("should handle negative TTL", async () => {
+            const nonce = "negative-ttl-nonce";
+            await cache.add(nonce, -1);
+            // Should be immediately expired
+            (0, vitest_1.expect)(await cache.has(nonce)).toBe(false);
+        });
+    });
+});

package/dist/cache/__tests__/nonce-cache-factory-simple.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Simplified tests for Nonce Cache Factory
+ */
+export {};

package/dist/cache/__tests__/nonce-cache-factory-simple.test.js

@@ -0,0 +1,133 @@
+"use strict";
+/**
+ * Simplified tests for Nonce Cache Factory
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const nonce_cache_factory_js_1 = require("../nonce-cache-factory.js");
+const memory_nonce_cache_js_1 = require("../memory-nonce-cache.js");
+// Mock environment variables
+const originalEnv = process.env;
+(0, vitest_1.describe)("Nonce Cache Factory (Simplified)", () => {
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.clearAllMocks();
+        // Reset environment
+        process.env = { ...originalEnv };
+    });
+    (0, vitest_1.afterEach)(() => {
+        process.env = originalEnv;
+    });
+    (0, vitest_1.describe)("detectCacheType", () => {
+        (0, vitest_1.it)("should detect explicit cache type from environment", () => {
+            process.env.mcpi_NONCE_CACHE_TYPE = "redis";
+            (0, vitest_1.expect)((0, nonce_cache_factory_js_1.detectCacheType)()).toBe("redis");
+            process.env.mcpi_NONCE_CACHE_TYPE = "dynamodb";
+            (0, vitest_1.expect)((0, nonce_cache_factory_js_1.detectCacheType)()).toBe("dynamodb");
+            process.env.mcpi_NONCE_CACHE_TYPE = "cloudflare-kv";
+            (0, vitest_1.expect)((0, nonce_cache_factory_js_1.detectCacheType)()).toBe("cloudflare-kv");
+            process.env.mcpi_NONCE_CACHE_TYPE = "memory";
+            (0, vitest_1.expect)((0, nonce_cache_factory_js_1.detectCacheType)()).toBe("memory");
+        });
+        (0, vitest_1.it)("should ignore invalid explicit cache types", () => {
+            process.env.mcpi_NONCE_CACHE_TYPE = "invalid-type";
+            (0, vitest_1.expect)((0, nonce_cache_factory_js_1.detectCacheType)()).toBe("memory");
+        });
+        (0, vitest_1.it)("should detect Redis from environment variables", () => {
+            process.env.REDIS_URL = "redis://localhost:6379";
+            (0, vitest_1.expect)((0, nonce_cache_factory_js_1.detectCacheType)()).toBe("redis");
+            delete process.env.REDIS_URL;
+            process.env.mcpi_REDIS_URL = "redis://localhost:6379";
+            (0, vitest_1.expect)((0, nonce_cache_factory_js_1.detectCacheType)()).toBe("redis");
+        });
+        (0, vitest_1.it)("should detect DynamoDB from environment variables", () => {
+            process.env.AWS_REGION = "us-east-1";
+            process.env.mcpi_DYNAMODB_TABLE = "nonce-cache";
+            (0, vitest_1.expect)((0, nonce_cache_factory_js_1.detectCacheType)()).toBe("dynamodb");
+            delete process.env.AWS_REGION;
+            process.env.AWS_DEFAULT_REGION = "us-west-2";
+            (0, vitest_1.expect)((0, nonce_cache_factory_js_1.detectCacheType)()).toBe("dynamodb");
+        });
+        (0, vitest_1.it)("should default to memory cache", () => {
+            (0, vitest_1.expect)((0, nonce_cache_factory_js_1.detectCacheType)()).toBe("memory");
+        });
+        (0, vitest_1.it)("should warn about memory cache in production", () => {
+            const consoleSpy = vitest_1.vi.spyOn(console, "warn").mockImplementation(() => { });
+            process.env.NODE_ENV = "production";
+            (0, nonce_cache_factory_js_1.detectCacheType)();
+            (0, vitest_1.expect)(consoleSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining("Using memory cache in production"));
+            consoleSpy.mockRestore();
+        });
+    });
+    (0, vitest_1.describe)("createNonceCache", () => {
+        (0, vitest_1.it)("should create memory cache by default", async () => {
+            const cache = await (0, nonce_cache_factory_js_1.createNonceCache)();
+            (0, vitest_1.expect)(cache).toBeInstanceOf(memory_nonce_cache_js_1.MemoryNonceCache);
+            // Cleanup
+            if (cache instanceof memory_nonce_cache_js_1.MemoryNonceCache) {
+                cache.destroy();
+            }
+        });
+        (0, vitest_1.it)("should create memory cache when explicitly configured", async () => {
+            const cache = await (0, nonce_cache_factory_js_1.createNonceCache)({ type: "memory" });
+            (0, vitest_1.expect)(cache).toBeInstanceOf(memory_nonce_cache_js_1.MemoryNonceCache);
+            // Cleanup
+            if (cache instanceof memory_nonce_cache_js_1.MemoryNonceCache) {
+                cache.destroy();
+            }
+        });
+        (0, vitest_1.it)("should fall back to memory cache when Redis URL is missing", async () => {
+            const consoleSpy = vitest_1.vi.spyOn(console, "warn").mockImplementation(() => { });
+            const cache = await (0, nonce_cache_factory_js_1.createNonceCache)({ type: "redis" });
+            (0, vitest_1.expect)(cache).toBeInstanceOf(memory_nonce_cache_js_1.MemoryNonceCache);
+            (0, vitest_1.expect)(consoleSpy).toHaveBeenCalledWith("Redis URL not found, falling back to memory cache");
+            consoleSpy.mockRestore();
+            if (cache instanceof memory_nonce_cache_js_1.MemoryNonceCache) {
+                cache.destroy();
+            }
+        });
+        (0, vitest_1.it)("should fall back to memory cache when DynamoDB table is missing", async () => {
+            const consoleSpy = vitest_1.vi.spyOn(console, "warn").mockImplementation(() => { });
+            const cache = await (0, nonce_cache_factory_js_1.createNonceCache)({ type: "dynamodb" });
+            (0, vitest_1.expect)(cache).toBeInstanceOf(memory_nonce_cache_js_1.MemoryNonceCache);
+            (0, vitest_1.expect)(consoleSpy).toHaveBeenCalledWith("DynamoDB table name not found, falling back to memory cache");
+            consoleSpy.mockRestore();
+            if (cache instanceof memory_nonce_cache_js_1.MemoryNonceCache) {
+                cache.destroy();
+            }
+        });
+        (0, vitest_1.it)("should fall back to memory cache when KV namespace is missing", async () => {
+            const consoleSpy = vitest_1.vi.spyOn(console, "warn").mockImplementation(() => { });
+            const cache = await (0, nonce_cache_factory_js_1.createNonceCache)({ type: "cloudflare-kv" });
+            (0, vitest_1.expect)(cache).toBeInstanceOf(memory_nonce_cache_js_1.MemoryNonceCache);
+            (0, vitest_1.expect)(consoleSpy).toHaveBeenCalledWith("Cloudflare KV namespace not found, falling back to memory cache");
+            consoleSpy.mockRestore();
+            if (cache instanceof memory_nonce_cache_js_1.MemoryNonceCache) {
+                cache.destroy();
+            }
+        });
+    });
+    (0, vitest_1.describe)("createNonceCacheWithConfig", () => {
+        (0, vitest_1.it)("should create cache with default options", async () => {
+            const cache = await (0, nonce_cache_factory_js_1.createNonceCacheWithConfig)();
+            (0, vitest_1.expect)(cache).toBeInstanceOf(memory_nonce_cache_js_1.MemoryNonceCache);
+            if (cache instanceof memory_nonce_cache_js_1.MemoryNonceCache) {
+                cache.destroy();
+            }
+        });
+        (0, vitest_1.it)("should fall back to memory cache on errors by default", async () => {
+            const consoleSpy = vitest_1.vi.spyOn(console, "warn").mockImplementation(() => { });
+            const cache = await (0, nonce_cache_factory_js_1.createNonceCacheWithConfig)({
+                config: {
+                    type: "redis",
+                    // No URL provided, should cause fallback
+                },
+            });
+            (0, vitest_1.expect)(cache).toBeInstanceOf(memory_nonce_cache_js_1.MemoryNonceCache);
+            (0, vitest_1.expect)(consoleSpy).toHaveBeenCalled();
+            consoleSpy.mockRestore();
+            if (cache instanceof memory_nonce_cache_js_1.MemoryNonceCache) {
+                cache.destroy();
+            }
+        });
+    });
+});

package/dist/cache/__tests__/nonce-cache-factory.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for Nonce Cache Factory
+ */
+export {};

package/dist/cache/__tests__/nonce-cache-factory.test.js

@@ -0,0 +1,252 @@
+"use strict";
+/**
+ * Tests for Nonce Cache Factory
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const nonce_cache_factory_js_1 = require("../nonce-cache-factory.js");
+const memory_nonce_cache_js_1 = require("../memory-nonce-cache.js");
+// Mock environment variables
+const originalEnv = process.env;
+(0, vitest_1.describe)("Nonce Cache Factory", () => {
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.clearAllMocks();
+        // Reset environment
+        process.env = { ...originalEnv };
+    });
+    (0, vitest_1.afterEach)(() => {
+        process.env = originalEnv;
+    });
+    (0, vitest_1.describe)("detectCacheType", () => {
+        (0, vitest_1.it)("should detect explicit cache type from environment", () => {
+            process.env.mcpi_NONCE_CACHE_TYPE = "redis";
+            (0, vitest_1.expect)((0, nonce_cache_factory_js_1.detectCacheType)()).toBe("redis");
+            process.env.mcpi_NONCE_CACHE_TYPE = "dynamodb";
+            (0, vitest_1.expect)((0, nonce_cache_factory_js_1.detectCacheType)()).toBe("dynamodb");
+            process.env.mcpi_NONCE_CACHE_TYPE = "cloudflare-kv";
+            (0, vitest_1.expect)((0, nonce_cache_factory_js_1.detectCacheType)()).toBe("cloudflare-kv");
+            process.env.mcpi_NONCE_CACHE_TYPE = "memory";
+            (0, vitest_1.expect)((0, nonce_cache_factory_js_1.detectCacheType)()).toBe("memory");
+        });
+        (0, vitest_1.it)("should ignore invalid explicit cache types", () => {
+            process.env.mcpi_NONCE_CACHE_TYPE = "invalid-type";
+            (0, vitest_1.expect)((0, nonce_cache_factory_js_1.detectCacheType)()).toBe("memory");
+        });
+        (0, vitest_1.it)("should detect Redis from environment variables", () => {
+            process.env.REDIS_URL = "redis://localhost:6379";
+            (0, vitest_1.expect)((0, nonce_cache_factory_js_1.detectCacheType)()).toBe("redis");
+            delete process.env.REDIS_URL;
+            process.env.mcpi_REDIS_URL = "redis://localhost:6379";
+            (0, vitest_1.expect)((0, nonce_cache_factory_js_1.detectCacheType)()).toBe("redis");
+        });
+        (0, vitest_1.it)("should detect DynamoDB from environment variables", () => {
+            process.env.AWS_REGION = "us-east-1";
+            process.env.mcpi_DYNAMODB_TABLE = "nonce-cache";
+            (0, vitest_1.expect)((0, nonce_cache_factory_js_1.detectCacheType)()).toBe("dynamodb");
+            delete process.env.AWS_REGION;
+            process.env.AWS_DEFAULT_REGION = "us-west-2";
+            (0, vitest_1.expect)((0, nonce_cache_factory_js_1.detectCacheType)()).toBe("dynamodb");
+        });
+        (0, vitest_1.it)("should detect Cloudflare Workers environment", () => {
+            // Mock Cloudflare Workers globals
+            const originalGlobalThis = globalThis;
+            Object.defineProperty(globalThis, "caches", {
+                value: {},
+                configurable: true,
+            });
+            Object.defineProperty(globalThis, "fetch", {
+                value: () => { },
+                configurable: true,
+            });
+            Object.defineProperty(globalThis, "addEventListener", {
+                value: () => { },
+                configurable: true,
+            });
+            (0, vitest_1.expect)((0, nonce_cache_factory_js_1.detectCacheType)()).toBe("cloudflare-kv");
+            // Cleanup
+            delete globalThis.caches;
+            delete globalThis.addEventListener;
+        });
+        (0, vitest_1.it)("should default to memory cache", () => {
+            (0, vitest_1.expect)((0, nonce_cache_factory_js_1.detectCacheType)()).toBe("memory");
+        });
+        (0, vitest_1.it)("should warn about memory cache in production", () => {
+            const consoleSpy = vitest_1.vi.spyOn(console, "warn").mockImplementation(() => { });
+            process.env.NODE_ENV = "production";
+            (0, nonce_cache_factory_js_1.detectCacheType)();
+            (0, vitest_1.expect)(consoleSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining("Using memory cache in production"));
+            consoleSpy.mockRestore();
+        });
+    });
+    (0, vitest_1.describe)("createNonceCache", () => {
+        (0, vitest_1.it)("should create memory cache by default", async () => {
+            const cache = await (0, nonce_cache_factory_js_1.createNonceCache)();
+            (0, vitest_1.expect)(cache).toBeInstanceOf(memory_nonce_cache_js_1.MemoryNonceCache);
+            // Cleanup
+            if (cache instanceof memory_nonce_cache_js_1.MemoryNonceCache) {
+                cache.destroy();
+            }
+        });
+        (0, vitest_1.it)("should create memory cache when explicitly configured", async () => {
+            const cache = await (0, nonce_cache_factory_js_1.createNonceCache)({ type: "memory" });
+            (0, vitest_1.expect)(cache).toBeInstanceOf(memory_nonce_cache_js_1.MemoryNonceCache);
+            // Cleanup
+            if (cache instanceof memory_nonce_cache_js_1.MemoryNonceCache) {
+                cache.destroy();
+            }
+        });
+        (0, vitest_1.it)("should fall back to memory cache when Redis URL is missing", async () => {
+            const consoleSpy = vitest_1.vi.spyOn(console, "warn").mockImplementation(() => { });
+            const cache = await (0, nonce_cache_factory_js_1.createNonceCache)({ type: "redis" });
+            (0, vitest_1.expect)(cache).toBeInstanceOf(memory_nonce_cache_js_1.MemoryNonceCache);
+            (0, vitest_1.expect)(consoleSpy).toHaveBeenCalledWith("Redis URL not found, falling back to memory cache");
+            consoleSpy.mockRestore();
+            if (cache instanceof memory_nonce_cache_js_1.MemoryNonceCache) {
+                cache.destroy();
+            }
+        });
+        (0, vitest_1.it)("should fall back to memory cache when DynamoDB table is missing", async () => {
+            const consoleSpy = vitest_1.vi.spyOn(console, "warn").mockImplementation(() => { });
+            const cache = await (0, nonce_cache_factory_js_1.createNonceCache)({ type: "dynamodb" });
+            (0, vitest_1.expect)(cache).toBeInstanceOf(memory_nonce_cache_js_1.MemoryNonceCache);
+            (0, vitest_1.expect)(consoleSpy).toHaveBeenCalledWith("DynamoDB table name not found, falling back to memory cache");
+            consoleSpy.mockRestore();
+            if (cache instanceof memory_nonce_cache_js_1.MemoryNonceCache) {
+                cache.destroy();
+            }
+        });
+        (0, vitest_1.it)("should fall back to memory cache when KV namespace is missing", async () => {
+            const consoleSpy = vitest_1.vi.spyOn(console, "warn").mockImplementation(() => { });
+            const cache = await (0, nonce_cache_factory_js_1.createNonceCache)({ type: "cloudflare-kv" });
+            (0, vitest_1.expect)(cache).toBeInstanceOf(memory_nonce_cache_js_1.MemoryNonceCache);
+            (0, vitest_1.expect)(consoleSpy).toHaveBeenCalledWith("Cloudflare KV namespace not found, falling back to memory cache");
+            consoleSpy.mockRestore();
+            if (cache instanceof memory_nonce_cache_js_1.MemoryNonceCache) {
+                cache.destroy();
+            }
+        });
+        (0, vitest_1.it)("should handle Redis connection failures gracefully", async () => {
+            const consoleSpy = vitest_1.vi.spyOn(console, "warn").mockImplementation(() => { });
+            // Mock Redis import to throw error
+            vitest_1.vi.doMock("redis", () => {
+                throw new Error("Redis not available");
+            });
+            const cache = await (0, nonce_cache_factory_js_1.createNonceCache)({
+                type: "redis",
+                redis: { url: "redis://localhost:6379", keyPrefix: "test:" },
+            });
+            (0, vitest_1.expect)(cache).toBeInstanceOf(memory_nonce_cache_js_1.MemoryNonceCache);
+            (0, vitest_1.expect)(consoleSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining("Failed to connect to Redis"), vitest_1.expect.any(Error));
+            consoleSpy.mockRestore();
+            if (cache instanceof memory_nonce_cache_js_1.MemoryNonceCache) {
+                cache.destroy();
+            }
+        });
+        (0, vitest_1.it)("should handle DynamoDB initialization failures gracefully", async () => {
+            const consoleSpy = vitest_1.vi.spyOn(console, "warn").mockImplementation(() => { });
+            // Mock AWS SDK import to throw error
+            vitest_1.vi.doMock("@aws-sdk/client-dynamodb", () => {
+                throw new Error("AWS SDK not available");
+            });
+            const cache = await (0, nonce_cache_factory_js_1.createNonceCache)({
+                type: "dynamodb",
+                dynamodb: {
+                    tableName: "test-table",
+                    keyAttribute: "nonce",
+                    ttlAttribute: "ttl",
+                },
+            });
+            (0, vitest_1.expect)(cache).toBeInstanceOf(memory_nonce_cache_js_1.MemoryNonceCache);
+            (0, vitest_1.expect)(consoleSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining("Failed to initialize DynamoDB"), vitest_1.expect.any(Error));
+            consoleSpy.mockRestore();
+            if (cache instanceof memory_nonce_cache_js_1.MemoryNonceCache) {
+                cache.destroy();
+            }
+        });
+        (0, vitest_1.it)("should handle Cloudflare KV namespace not found", async () => {
+            const consoleSpy = vitest_1.vi.spyOn(console, "warn").mockImplementation(() => { });
+            const cache = await (0, nonce_cache_factory_js_1.createNonceCache)({
+                type: "cloudflare-kv",
+                cloudflareKv: {
+                    namespace: "NONEXISTENT_KV",
+                    keyPrefix: "test:",
+                },
+            });
+            (0, vitest_1.expect)(cache).toBeInstanceOf(memory_nonce_cache_js_1.MemoryNonceCache);
+            (0, vitest_1.expect)(consoleSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining("Failed to initialize Cloudflare KV"), vitest_1.expect.any(Error));
+            consoleSpy.mockRestore();
+            if (cache instanceof memory_nonce_cache_js_1.MemoryNonceCache) {
+                cache.destroy();
+            }
+        });
+    });
+    (0, vitest_1.describe)("createNonceCacheWithConfig", () => {
+        (0, vitest_1.it)("should create cache with default options", async () => {
+            const cache = await (0, nonce_cache_factory_js_1.createNonceCacheWithConfig)();
+            (0, vitest_1.expect)(cache).toBeInstanceOf(memory_nonce_cache_js_1.MemoryNonceCache);
+            if (cache instanceof memory_nonce_cache_js_1.MemoryNonceCache) {
+                cache.destroy();
+            }
+        });
+        (0, vitest_1.it)("should fall back to memory cache on errors by default", async () => {
+            const consoleSpy = vitest_1.vi.spyOn(console, "warn").mockImplementation(() => { });
+            // Mock to throw error
+            vitest_1.vi.doMock("redis", () => {
+                throw new Error("Connection failed");
+            });
+            const cache = await (0, nonce_cache_factory_js_1.createNonceCacheWithConfig)({
+                config: {
+                    type: "redis",
+                    redis: { url: "redis://localhost:6379", keyPrefix: "test:" },
+                },
+            });
+            (0, vitest_1.expect)(cache).toBeInstanceOf(memory_nonce_cache_js_1.MemoryNonceCache);
+            (0, vitest_1.expect)(consoleSpy).toHaveBeenCalled();
+            consoleSpy.mockRestore();
+            if (cache instanceof memory_nonce_cache_js_1.MemoryNonceCache) {
+                cache.destroy();
+            }
+        });
+        (0, vitest_1.it)("should throw error when fallbackToMemory is false", async () => {
+            // Mock to throw error
+            vitest_1.vi.doMock("redis", () => {
+                throw new Error("Connection failed");
+            });
+            await (0, vitest_1.expect)((0, nonce_cache_factory_js_1.createNonceCacheWithConfig)({
+                config: {
+                    type: "redis",
+                    redis: { url: "redis://localhost:6379", keyPrefix: "test:" },
+                },
+                fallbackToMemory: false,
+            })).rejects.toThrow();
+        });
+    });
+    (0, vitest_1.describe)("Environment Variable Priority", () => {
+        (0, vitest_1.it)("should prioritize config over environment variables", async () => {
+            process.env.REDIS_URL = "redis://env-redis:6379";
+            const consoleSpy = vitest_1.vi.spyOn(console, "warn").mockImplementation(() => { });
+            const cache = await (0, nonce_cache_factory_js_1.createNonceCache)({
+                type: "redis",
+                redis: { url: "redis://config-redis:6379", keyPrefix: "test:" },
+            });
+            (0, vitest_1.expect)(cache).toBeInstanceOf(memory_nonce_cache_js_1.MemoryNonceCache);
+            // Should have tried to use config URL, not env URL
+            (0, vitest_1.expect)(consoleSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining("Failed to connect to Redis"), vitest_1.expect.any(Error));
+            consoleSpy.mockRestore();
+            if (cache instanceof memory_nonce_cache_js_1.MemoryNonceCache) {
+                cache.destroy();
+            }
+        });
+        (0, vitest_1.it)("should use environment variables when config is not provided", async () => {
+            process.env.mcpi_REDIS_URL = "redis://env-redis:6379";
+            const consoleSpy = vitest_1.vi.spyOn(console, "warn").mockImplementation(() => { });
+            const cache = await (0, nonce_cache_factory_js_1.createNonceCache)({ type: "redis" });
+            (0, vitest_1.expect)(cache).toBeInstanceOf(memory_nonce_cache_js_1.MemoryNonceCache);
+            (0, vitest_1.expect)(consoleSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining("Failed to connect to Redis"), vitest_1.expect.any(Error));
+            consoleSpy.mockRestore();
+            if (cache instanceof memory_nonce_cache_js_1.MemoryNonceCache) {
+                cache.destroy();
+            }
+        });
+    });
+});

package/dist/cache/__tests__/redis-nonce-cache.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for Redis Nonce Cache
+ */
+export {};

package/dist/cache/__tests__/redis-nonce-cache.test.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * Tests for Redis Nonce Cache
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const redis_nonce_cache_js_1 = require("../redis-nonce-cache.js");
+// Mock Redis client
+const mockRedis = {
+    exists: vitest_1.vi.fn(),
+    set: vitest_1.vi.fn(),
+};
+(0, vitest_1.describe)("RedisNonceCache", () => {
+    let cache;
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.clearAllMocks();
+        cache = new redis_nonce_cache_js_1.RedisNonceCache(mockRedis, "test:nonce:");
+    });
+    (0, vitest_1.describe)("Basic Operations", () => {
+        (0, vitest_1.it)("should add and check nonce existence", async () => {
+            const nonce = "test-nonce-123";
+            // Mock Redis responses
+            mockRedis.exists.mockResolvedValue(0); // doesn't exist
+            mockRedis.set.mockResolvedValue("OK"); // successful set
+            // Initially should not exist
+            (0, vitest_1.expect)(await cache.has(nonce)).toBe(false);
+            (0, vitest_1.expect)(mockRedis.exists).toHaveBeenCalledWith("test:nonce:test-nonce-123");
+            // Add nonce
+            await cache.add(nonce, 60);
+            (0, vitest_1.expect)(mockRedis.set).toHaveBeenCalledWith("test:nonce:test-nonce-123", "1", "EX", 60, "NX");
+            // Mock that it now exists
+            mockRedis.exists.mockResolvedValue(1);
+            (0, vitest_1.expect)(await cache.has(nonce)).toBe(true);
+        });
+        (0, vitest_1.it)("should prevent duplicate nonce addition", async () => {
+            const nonce = "duplicate-nonce";
+            // Mock Redis SET NX returning null (key already exists)
+            mockRedis.set.mockResolvedValue(null);
+            // Adding duplicate nonce should throw
+            await (0, vitest_1.expect)(cache.add(nonce, 60)).rejects.toThrow("Nonce duplicate-nonce already exists - potential replay attack");
+        });
+        (0, vitest_1.it)("should handle Redis connection errors gracefully", async () => {
+            const nonce = "error-nonce";
+            // Mock Redis throwing connection error
+            mockRedis.exists.mockRejectedValue(new Error("Connection failed"));
+            mockRedis.set.mockRejectedValue(new Error("Connection failed"));
+            // Should propagate errors with context
+            await (0, vitest_1.expect)(cache.has(nonce)).rejects.toThrow("Failed to check nonce existence");
+            await (0, vitest_1.expect)(cache.add(nonce, 60)).rejects.toThrow("Failed to add nonce to cache");
+        });
+    });
+    (0, vitest_1.describe)("Atomic Operations", () => {
+        (0, vitest_1.it)("should use atomic SET NX EX command", async () => {
+            const nonce = "atomic-test-nonce";
+            const ttl = 300;
+            mockRedis.set.mockResolvedValue("OK");
+            await cache.add(nonce, ttl);
+            // Verify atomic command was used
+            (0, vitest_1.expect)(mockRedis.set).toHaveBeenCalledWith("test:nonce:atomic-test-nonce", "1", "EX", ttl, "NX");
+        });
+        (0, vitest_1.it)("should handle concurrent add attempts", async () => {
+            const nonce = "concurrent-nonce";
+            // First call succeeds
+            mockRedis.set.mockResolvedValueOnce("OK");
+            // Second call fails (key exists)
+            mockRedis.set.mockResolvedValueOnce(null);
+            // First add should succeed
+            await (0, vitest_1.expect)(cache.add(nonce, 60)).resolves.not.toThrow();
+            // Second add should fail
+            await (0, vitest_1.expect)(cache.add(nonce, 60)).rejects.toThrow("potential replay attack");
+        });
+    });
+    (0, vitest_1.describe)("Cleanup", () => {
+        (0, vitest_1.it)("should be a no-op since Redis handles expiry", async () => {
+            // cleanup() should not call any Redis methods
+            await cache.cleanup();
+            (0, vitest_1.expect)(mockRedis.exists).not.toHaveBeenCalled();
+            (0, vitest_1.expect)(mockRedis.set).not.toHaveBeenCalled();
+        });
+    });
+    (0, vitest_1.describe)("Key Prefix", () => {
+        (0, vitest_1.it)("should use custom key prefix", () => {
+            const customCache = new redis_nonce_cache_js_1.RedisNonceCache(mockRedis, "custom:prefix:");
+            mockRedis.exists.mockResolvedValue(0);
+            customCache.has("test-nonce");
+            (0, vitest_1.expect)(mockRedis.exists).toHaveBeenCalledWith("custom:prefix:test-nonce");
+        });
+        (0, vitest_1.it)("should use default key prefix", () => {
+            const defaultCache = new redis_nonce_cache_js_1.RedisNonceCache(mockRedis);
+            mockRedis.exists.mockResolvedValue(0);
+            defaultCache.has("test-nonce");
+            (0, vitest_1.expect)(mockRedis.exists).toHaveBeenCalledWith("mcpi:nonce:test-nonce");
+        });
+    });
+});

package/dist/cache/cloudflare-kv-nonce-cache.d.ts

@@ -0,0 +1,14 @@
+import { NonceCache } from "@kya-os/contracts/handshake";
+/**
+ * Cloudflare KV-based nonce cache implementation
+ * Suitable for Cloudflare Workers deployments
+ */
+export declare class CloudflareKVNonceCache implements NonceCache {
+    private kv;
+    private keyPrefix;
+    constructor(kv: any, keyPrefix?: string);
+    private getKey;
+    has(nonce: string): Promise<boolean>;
+    add(nonce: string, ttl: number): Promise<void>;
+    cleanup(): Promise<void>;
+}