@frontmcp/plugins 0.6.2 → 0.7.1

package/esm/cache/index.mjs

@@ -1,395 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
-};
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-
-// libs/plugins/src/cache/cache.plugin.ts
-import {
-  DynamicPlugin,
-  Plugin,
-  ToolHook,
-  FrontMcpConfig,
-  getGlobalStoreConfig,
-  isVercelKvProvider
-} from "@frontmcp/sdk";
-
-// libs/plugins/src/cache/providers/cache-redis.provider.ts
-import Redis from "ioredis";
-import { Provider, ProviderScope } from "@frontmcp/sdk";
-var CacheRedisProvider = class {
-  client;
-  constructor(options) {
-    if (options.type !== "redis" && options.type !== "redis-client") {
-      throw new Error("Invalid cache provider type");
-    }
-    if (options.type === "redis-client") {
-      this.client = options.client;
-      return;
-    }
-    this.client = new Redis({
-      lazyConnect: false,
-      maxRetriesPerRequest: 3,
-      ...options.config
-    });
-    this.client.on("connect", () => console.log("[Redis] Connected"));
-    this.client.on("error", (err) => console.error("[Redis] Error:", err));
-  }
-  /** Set a value (auto-stringifies objects) */
-  async setValue(key, value, ttlSeconds) {
-    const strValue = typeof value === "string" ? value : JSON.stringify(value);
-    if (ttlSeconds && ttlSeconds > 0) {
-      await this.client.set(key, strValue, "EX", ttlSeconds);
-    } else {
-      await this.client.set(key, strValue);
-    }
-  }
-  /** Get a value and automatically parse JSON if possible */
-  async getValue(key, defaultValue) {
-    const raw = await this.client.get(key);
-    if (raw === null) return defaultValue;
-    try {
-      return JSON.parse(raw);
-    } catch {
-      return raw;
-    }
-  }
-  /** Delete a key */
-  async delete(key) {
-    await this.client.del(key);
-  }
-  /** Check if a key exists */
-  async exists(key) {
-    return await this.client.exists(key) === 1;
-  }
-  /** Gracefully close the Redis connection */
-  async close() {
-    await this.client.quit();
-  }
-};
-CacheRedisProvider = __decorateClass([
-  Provider({
-    name: "provider:cache:redis",
-    description: "Redis-based cache provider",
-    scope: ProviderScope.GLOBAL
-  })
-], CacheRedisProvider);
-
-// libs/plugins/src/cache/providers/cache-memory.provider.ts
-import { Provider as Provider2, ProviderScope as ProviderScope2 } from "@frontmcp/sdk";
-var MAX_TIMEOUT_MS = 2 ** 31 - 1;
-var CacheMemoryProvider = class {
-  memory = /* @__PURE__ */ new Map();
-  sweeper;
-  constructor(sweepIntervalTTL = 60) {
-    this.sweeper = setInterval(() => this.sweep(), sweepIntervalTTL * 1e3);
-    this.sweeper.unref?.();
-  }
-  /** Set a value (auto-stringifies objects) */
-  async setValue(key, value, ttlSeconds) {
-    const strValue = typeof value === "string" ? value : JSON.stringify(value);
-    const existing = this.memory.get(key);
-    if (existing?.timeout) clearTimeout(existing.timeout);
-    const entry = { value: strValue };
-    if (ttlSeconds && ttlSeconds > 0) {
-      const ttlMs = ttlSeconds * 1e3;
-      entry.expiresAt = Date.now() + ttlMs;
-      if (ttlMs <= MAX_TIMEOUT_MS) {
-        entry.timeout = setTimeout(() => {
-          const e = this.memory.get(key);
-          if (e && e.expiresAt && e.expiresAt <= Date.now()) {
-            this.memory.delete(key);
-          }
-        }, ttlMs);
-        entry.timeout.unref?.();
-      }
-    }
-    this.memory.set(key, entry);
-  }
-  /** Get a value and automatically parse JSON if possible */
-  async getValue(key, defaultValue) {
-    const entry = this.memory.get(key);
-    if (!entry) return defaultValue;
-    if (this.isExpired(entry)) {
-      await this.delete(key);
-      return defaultValue;
-    }
-    const raw = entry.value;
-    try {
-      return JSON.parse(raw);
-    } catch {
-      return raw;
-    }
-  }
-  /** Delete a key */
-  async delete(key) {
-    const entry = this.memory.get(key);
-    if (entry?.timeout) clearTimeout(entry.timeout);
-    this.memory.delete(key);
-  }
-  /** Check if a key exists (and not expired) */
-  async exists(key) {
-    const entry = this.memory.get(key);
-    if (!entry) return false;
-    if (this.isExpired(entry)) {
-      await this.delete(key);
-      return false;
-    }
-    return true;
-  }
-  /** Gracefully close the provider */
-  async close() {
-    if (this.sweeper) clearInterval(this.sweeper);
-    for (const [, entry] of this.memory) {
-      if (entry.timeout) clearTimeout(entry.timeout);
-    }
-    this.memory.clear();
-  }
-  // ---- internals ----
-  isExpired(entry) {
-    return entry.expiresAt !== void 0 && entry.expiresAt <= Date.now();
-  }
-  /** Periodically remove expired keys to keep memory tidy */
-  sweep() {
-    const now = Date.now();
-    for (const [key, entry] of this.memory) {
-      if (entry.expiresAt !== void 0 && entry.expiresAt <= now) {
-        if (entry.timeout) clearTimeout(entry.timeout);
-        this.memory.delete(key);
-      }
-    }
-  }
-};
-CacheMemoryProvider = __decorateClass([
-  Provider2({
-    name: "provider:cache:memory",
-    description: "Memory-based cache provider",
-    scope: ProviderScope2.GLOBAL
-  })
-], CacheMemoryProvider);
-
-// libs/plugins/src/cache/providers/cache-vercel-kv.provider.ts
-import { Provider as Provider3, ProviderScope as ProviderScope3 } from "@frontmcp/sdk";
-var CacheVercelKvProvider = class {
-  kv;
-  keyPrefix;
-  defaultTTL;
-  constructor(options = {}) {
-    const vercelKv = __require("@vercel/kv");
-    const hasUrl = options.url !== void 0;
-    const hasToken = options.token !== void 0;
-    if (hasUrl !== hasToken) {
-      throw new Error(
-        `CacheVercelKvProvider: Both 'url' and 'token' must be provided together, or neither. Received: url=${hasUrl ? "provided" : "missing"}, token=${hasToken ? "provided" : "missing"}`
-      );
-    }
-    if (options.url && options.token) {
-      this.kv = vercelKv.createClient({
-        url: options.url,
-        token: options.token
-      });
-    } else {
-      this.kv = vercelKv.kv;
-    }
-    this.keyPrefix = options.keyPrefix ?? "cache:";
-    this.defaultTTL = options.defaultTTL ?? 60 * 60 * 24;
-  }
-  prefixKey(key) {
-    return `${this.keyPrefix}${key}`;
-  }
-  /** Set a value (auto-stringifies objects) */
-  async setValue(key, value, ttlSeconds) {
-    const strValue = typeof value === "string" ? value : JSON.stringify(value);
-    const ttl = ttlSeconds ?? this.defaultTTL;
-    if (ttl > 0) {
-      await this.kv.set(this.prefixKey(key), strValue, { ex: ttl });
-    } else {
-      await this.kv.set(this.prefixKey(key), strValue);
-    }
-  }
-  /** Get a value and automatically parse JSON if possible */
-  async getValue(key, defaultValue) {
-    const raw = await this.kv.get(this.prefixKey(key));
-    if (raw === null || raw === void 0) return defaultValue;
-    if (typeof raw === "string") {
-      try {
-        return JSON.parse(raw);
-      } catch {
-        return raw;
-      }
-    }
-    return raw;
-  }
-  /** Delete a key */
-  async delete(key) {
-    await this.kv.del(this.prefixKey(key));
-  }
-  /** Check if a key exists */
-  async exists(key) {
-    return await this.kv.exists(this.prefixKey(key)) === 1;
-  }
-  /** Gracefully close the provider (no-op for Vercel KV - stateless REST API) */
-  async close() {
-  }
-};
-CacheVercelKvProvider = __decorateClass([
-  Provider3({
-    name: "provider:cache:vercel-kv",
-    description: "Vercel KV-based cache provider",
-    scope: ProviderScope3.GLOBAL
-  })
-], CacheVercelKvProvider);
-
-// libs/plugins/src/cache/cache.symbol.ts
-var CacheStoreToken = /* @__PURE__ */ Symbol("plugin:cache:store");
-
-// libs/plugins/src/cache/cache.plugin.ts
-var CachePlugin = class extends DynamicPlugin {
-  options;
-  constructor(options = CachePlugin.defaultOptions) {
-    super();
-    this.options = {
-      defaultTTL: 60 * 60 * 24,
-      ...options
-    };
-  }
-  async willReadCache(flowCtx) {
-    const { tool, toolContext } = flowCtx.state;
-    if (!tool || !toolContext) return;
-    const { cache } = toolContext.metadata;
-    if (!cache || typeof toolContext.input === "undefined") {
-      return;
-    }
-    const cacheStore = this.get(CacheStoreToken);
-    const hash = hashObject({ tool: tool.fullName, input: toolContext.input });
-    const cached = await cacheStore.getValue(hash);
-    if (cached !== void 0 && cached !== null) {
-      if (cache === true || cache.ttl && cache.slideWindow) {
-        const ttl = cache === true ? this.options.defaultTTL : cache.ttl ?? this.options.defaultTTL;
-        await cacheStore.setValue(hash, cached, ttl);
-      }
-      if (!tool.safeParseOutput(cached).success) {
-        await cacheStore.delete(hash);
-        return;
-      }
-      flowCtx.state.rawOutput = cached;
-      toolContext.respond(cached);
-    }
-  }
-  async willWriteCache(flowCtx) {
-    const { tool, toolContext } = flowCtx.state;
-    if (!tool || !toolContext) return;
-    const { cache } = toolContext.metadata;
-    if (!cache || typeof toolContext.input === "undefined") {
-      return;
-    }
-    const cacheStore = this.get(CacheStoreToken);
-    const ttl = cache === true ? this.options.defaultTTL : cache.ttl ?? this.options.defaultTTL;
-    const hash = hashObject({ tool: tool.fullName, input: toolContext.input });
-    await cacheStore.setValue(hash, toolContext.output, ttl);
-  }
-};
-__publicField(CachePlugin, "dynamicProviders", (options) => {
-  const providers = [];
-  switch (options.type) {
-    case "global-store":
-      providers.push({
-        name: "cache:global-store",
-        provide: CacheStoreToken,
-        inject: () => [FrontMcpConfig],
-        useFactory: (config) => {
-          const storeConfig = getGlobalStoreConfig("CachePlugin", config);
-          const globalOptions = options;
-          if (isVercelKvProvider(storeConfig)) {
-            return new CacheVercelKvProvider({
-              url: storeConfig.url,
-              token: storeConfig.token,
-              keyPrefix: storeConfig.keyPrefix,
-              defaultTTL: globalOptions.defaultTTL
-            });
-          }
-          return new CacheRedisProvider({
-            type: "redis",
-            config: {
-              host: storeConfig.host ?? "localhost",
-              port: storeConfig.port ?? 6379,
-              password: storeConfig.password,
-              db: storeConfig.db
-            },
-            defaultTTL: globalOptions.defaultTTL
-          });
-        }
-      });
-      break;
-    case "redis":
-    case "redis-client":
-      providers.push({
-        name: "cache:redis",
-        provide: CacheStoreToken,
-        useValue: new CacheRedisProvider(options)
-      });
-      break;
-    case "memory":
-      providers.push({
-        name: "cache:memory",
-        provide: CacheStoreToken,
-        useValue: new CacheMemoryProvider(options.defaultTTL)
-      });
-      break;
-  }
-  return providers;
-});
-__publicField(CachePlugin, "defaultOptions", {
-  type: "memory"
-});
-__decorateClass([
-  ToolHook.Will("execute", { priority: 1e3 })
-], CachePlugin.prototype, "willReadCache", 1);
-__decorateClass([
-  ToolHook.Did("execute", { priority: 1e3 })
-], CachePlugin.prototype, "willWriteCache", 1);
-CachePlugin = __decorateClass([
-  Plugin({
-    name: "cache",
-    description: "Cache plugin for caching tool results",
-    providers: [
-      /* add providers that always loaded with the plugin or default providers */
-      {
-        // this is a default provider for cache, will be overridden if dynamicProviders based on config
-        name: "cache:memory",
-        provide: CacheStoreToken,
-        useValue: new CacheMemoryProvider(60 * 60 * 24)
-      }
-    ]
-  })
-], CachePlugin);
-function hashObject(obj) {
-  const keys = Object.keys(obj).sort();
-  return keys.reduce((acc, key) => {
-    acc += key + ":";
-    const val = obj[key];
-    if (typeof val === "object" && val !== null) {
-      acc += hashObject(val);
-    } else {
-      acc += String(val);
-    }
-    acc += ";";
-    return acc;
-  }, "");
-}
-export {
-  CachePlugin as default
-};