@frontmcp/plugin-feature-flags 0.0.1

package/index.js

@@ -0,0 +1,638 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+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);
+
+// plugins/plugin-feature-flags/src/adapters/splitio.adapter.ts
+var splitio_adapter_exports = {};
+__export(splitio_adapter_exports, {
+  SplitioFeatureFlagAdapter: () => SplitioFeatureFlagAdapter
+});
+var SplitioFeatureFlagAdapter;
+var init_splitio_adapter = __esm({
+  "plugins/plugin-feature-flags/src/adapters/splitio.adapter.ts"() {
+    "use strict";
+    SplitioFeatureFlagAdapter = class {
+      config;
+      factory;
+      client;
+      constructor(config) {
+        this.config = config;
+      }
+      async initialize() {
+        let SplitFactory;
+        try {
+          ({ SplitFactory } = require("@splitsoftware/splitio"));
+        } catch {
+          throw new Error("Split.io SDK not found. Install it: npm install @splitsoftware/splitio");
+        }
+        this.factory = SplitFactory({
+          core: {
+            authorizationKey: this.config.apiKey
+          }
+        });
+        this.client = this.factory.client();
+        await this.client.ready();
+      }
+      async isEnabled(flagKey, context) {
+        if (!this.client) throw new Error("SplitioFeatureFlagAdapter not initialized");
+        const key = context.userId ?? context.sessionId ?? "anonymous";
+        const treatment = this.client.getTreatment(key, flagKey, context.attributes);
+        return treatment === "on";
+      }
+      async getVariant(flagKey, context) {
+        if (!this.client) throw new Error("SplitioFeatureFlagAdapter not initialized");
+        const key = context.userId ?? context.sessionId ?? "anonymous";
+        const treatment = this.client.getTreatment(key, flagKey, context.attributes);
+        return {
+          name: treatment,
+          value: treatment,
+          enabled: treatment === "on"
+        };
+      }
+      async evaluateFlags(flagKeys, context) {
+        const results = /* @__PURE__ */ new Map();
+        for (const key of flagKeys) {
+          results.set(key, await this.isEnabled(key, context));
+        }
+        return results;
+      }
+      async destroy() {
+        if (this.client) {
+          await this.client.destroy();
+        }
+        this.client = void 0;
+        this.factory = void 0;
+      }
+    };
+  }
+});
+
+// plugins/plugin-feature-flags/src/adapters/launchdarkly.adapter.ts
+var launchdarkly_adapter_exports = {};
+__export(launchdarkly_adapter_exports, {
+  LaunchDarklyFeatureFlagAdapter: () => LaunchDarklyFeatureFlagAdapter
+});
+var LaunchDarklyFeatureFlagAdapter;
+var init_launchdarkly_adapter = __esm({
+  "plugins/plugin-feature-flags/src/adapters/launchdarkly.adapter.ts"() {
+    "use strict";
+    LaunchDarklyFeatureFlagAdapter = class {
+      config;
+      client;
+      constructor(config) {
+        this.config = config;
+      }
+      async initialize() {
+        let init;
+        try {
+          ({ init } = require("@launchdarkly/node-server-sdk"));
+        } catch {
+          throw new Error("LaunchDarkly SDK not found. Install it: npm install @launchdarkly/node-server-sdk");
+        }
+        this.client = init(this.config.sdkKey);
+        await this.client.waitForInitialization();
+      }
+      buildLDContext(context) {
+        return {
+          kind: "user",
+          key: context.userId ?? context.sessionId ?? "anonymous",
+          ...context.attributes ?? {}
+        };
+      }
+      async isEnabled(flagKey, context) {
+        if (!this.client) throw new Error("LaunchDarklyFeatureFlagAdapter not initialized");
+        const ldContext = this.buildLDContext(context);
+        return this.client.variation(flagKey, ldContext, false);
+      }
+      async getVariant(flagKey, context) {
+        if (!this.client) throw new Error("LaunchDarklyFeatureFlagAdapter not initialized");
+        const ldContext = this.buildLDContext(context);
+        const detail = await this.client.variationDetail(flagKey, ldContext, false);
+        const value = detail.value;
+        return {
+          name: String(value),
+          value,
+          enabled: Boolean(value)
+        };
+      }
+      async evaluateFlags(flagKeys, context) {
+        const results = /* @__PURE__ */ new Map();
+        for (const key of flagKeys) {
+          results.set(key, await this.isEnabled(key, context));
+        }
+        return results;
+      }
+      async destroy() {
+        if (this.client) {
+          await this.client.close();
+        }
+        this.client = void 0;
+      }
+    };
+  }
+});
+
+// plugins/plugin-feature-flags/src/adapters/unleash.adapter.ts
+var unleash_adapter_exports = {};
+__export(unleash_adapter_exports, {
+  UnleashFeatureFlagAdapter: () => UnleashFeatureFlagAdapter
+});
+var UnleashFeatureFlagAdapter;
+var init_unleash_adapter = __esm({
+  "plugins/plugin-feature-flags/src/adapters/unleash.adapter.ts"() {
+    "use strict";
+    UnleashFeatureFlagAdapter = class {
+      config;
+      client;
+      constructor(config) {
+        this.config = config;
+      }
+      async initialize() {
+        let Unleash;
+        try {
+          ({ Unleash } = require("unleash-client"));
+        } catch {
+          throw new Error("Unleash SDK not found. Install it: npm install unleash-client");
+        }
+        const options = {
+          url: this.config.url,
+          appName: this.config.appName
+        };
+        if (this.config.apiKey) {
+          options["customHeaders"] = { Authorization: this.config.apiKey };
+        }
+        this.client = new Unleash(options);
+        await this.client.start();
+      }
+      buildUnleashContext(context) {
+        return {
+          userId: context.userId,
+          sessionId: context.sessionId,
+          properties: context.attributes ?? {}
+        };
+      }
+      async isEnabled(flagKey, context) {
+        if (!this.client) throw new Error("UnleashFeatureFlagAdapter not initialized");
+        const unleashCtx = this.buildUnleashContext(context);
+        return this.client.isEnabled(flagKey, unleashCtx);
+      }
+      async getVariant(flagKey, context) {
+        if (!this.client) throw new Error("UnleashFeatureFlagAdapter not initialized");
+        const unleashCtx = this.buildUnleashContext(context);
+        const variant = this.client.getVariant(flagKey, unleashCtx);
+        return {
+          name: variant.name ?? "disabled",
+          value: variant.payload?.value ?? variant.name,
+          enabled: variant.enabled ?? false
+        };
+      }
+      async evaluateFlags(flagKeys, context) {
+        const results = /* @__PURE__ */ new Map();
+        for (const key of flagKeys) {
+          results.set(key, await this.isEnabled(key, context));
+        }
+        return results;
+      }
+      async destroy() {
+        if (this.client) {
+          this.client.destroy();
+        }
+        this.client = void 0;
+      }
+    };
+  }
+});
+
+// plugins/plugin-feature-flags/src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  FeatureFlagAccessor: () => FeatureFlagAccessor,
+  FeatureFlagAccessorToken: () => FeatureFlagAccessorToken,
+  FeatureFlagAdapterToken: () => FeatureFlagAdapterToken,
+  FeatureFlagConfigToken: () => FeatureFlagConfigToken,
+  FeatureFlagPlugin: () => FeatureFlagPlugin,
+  LaunchDarklyFeatureFlagAdapter: () => LaunchDarklyFeatureFlagAdapter,
+  SplitioFeatureFlagAdapter: () => SplitioFeatureFlagAdapter,
+  StaticFeatureFlagAdapter: () => StaticFeatureFlagAdapter,
+  UnleashFeatureFlagAdapter: () => UnleashFeatureFlagAdapter,
+  default: () => FeatureFlagPlugin,
+  getFeatureFlags: () => getFeatureFlags,
+  tryGetFeatureFlags: () => tryGetFeatureFlags
+});
+module.exports = __toCommonJS(index_exports);
+
+// plugins/plugin-feature-flags/src/feature-flag.plugin.ts
+var import_sdk2 = require("@frontmcp/sdk");
+
+// plugins/plugin-feature-flags/src/feature-flag.symbols.ts
+var FeatureFlagAdapterToken = /* @__PURE__ */ Symbol(
+  "plugin:feature-flags:adapter"
+);
+var FeatureFlagConfigToken = /* @__PURE__ */ Symbol(
+  "plugin:feature-flags:config"
+);
+var FeatureFlagAccessorToken = /* @__PURE__ */ Symbol(
+  "plugin:feature-flags:accessor"
+);
+
+// plugins/plugin-feature-flags/src/adapters/static.adapter.ts
+var StaticFeatureFlagAdapter = class {
+  flags;
+  constructor(flags) {
+    this.flags = { ...flags };
+  }
+  async initialize() {
+  }
+  async isEnabled(flagKey, _context) {
+    const flag = this.flags[flagKey];
+    if (flag === void 0) return false;
+    if (typeof flag === "boolean") return flag;
+    return flag.enabled;
+  }
+  async getVariant(flagKey, _context) {
+    const flag = this.flags[flagKey];
+    if (flag === void 0) {
+      return { name: "off", value: void 0, enabled: false };
+    }
+    if (typeof flag === "boolean") {
+      return { name: flag ? "on" : "off", value: flag, enabled: flag };
+    }
+    return { ...flag };
+  }
+  async evaluateFlags(flagKeys, context) {
+    const results = /* @__PURE__ */ new Map();
+    for (const key of flagKeys) {
+      results.set(key, await this.isEnabled(key, context));
+    }
+    return results;
+  }
+  async destroy() {
+  }
+};
+
+// plugins/plugin-feature-flags/src/providers/feature-flag-accessor.provider.ts
+var import_sdk = require("@frontmcp/sdk");
+var FeatureFlagAccessor = class {
+  adapter;
+  ctx;
+  config;
+  cache = /* @__PURE__ */ new Map();
+  constructor(adapter, ctx, config) {
+    this.adapter = adapter;
+    this.ctx = ctx;
+    this.config = config;
+  }
+  /**
+   * Check if a feature flag is enabled.
+   */
+  async isEnabled(flagKey, defaultValue) {
+    const cacheStrategy = this.config.cacheStrategy ?? "none";
+    const cacheTtlMs = this.config.cacheTtlMs ?? 3e4;
+    if (cacheStrategy !== "none") {
+      const cached = this.cache.get(flagKey);
+      if (cached && Date.now() < cached.expiresAt) {
+        return cached.value;
+      }
+    }
+    const context = this.buildContext();
+    let result;
+    try {
+      result = await this.adapter.isEnabled(flagKey, context);
+    } catch {
+      result = defaultValue ?? this.config.defaultValue ?? false;
+    }
+    if (cacheStrategy !== "none") {
+      this.cache.set(flagKey, { value: result, expiresAt: Date.now() + cacheTtlMs });
+    }
+    return result;
+  }
+  /**
+   * Get a feature flag variant (for multi-variate flags).
+   */
+  async getVariant(flagKey) {
+    const context = this.buildContext();
+    return this.adapter.getVariant(flagKey, context);
+  }
+  /**
+   * Batch evaluate multiple flags at once.
+   */
+  async evaluateFlags(flagKeys) {
+    const context = this.buildContext();
+    return this.adapter.evaluateFlags(flagKeys, context);
+  }
+  /**
+   * Resolve a FeatureFlagRef (string or object) to a boolean.
+   */
+  async resolveRef(ref) {
+    if (typeof ref === "string") {
+      return this.isEnabled(ref);
+    }
+    return this.isEnabled(ref.key, ref.defaultValue);
+  }
+  /**
+   * Build the FeatureFlagContext from the current FrontMcpContext.
+   */
+  buildContext() {
+    const userId = this.config.userIdResolver ? this.config.userIdResolver(this.ctx) : this.ctx.authInfo?.extra?.["sub"] ?? this.ctx.authInfo?.extra?.["userId"] ?? this.ctx.authInfo?.clientId;
+    const attributes = this.config.attributesResolver ? this.config.attributesResolver(this.ctx) : {};
+    return {
+      userId: userId ?? void 0,
+      sessionId: this.ctx.sessionId,
+      attributes
+    };
+  }
+};
+FeatureFlagAccessor = __decorateClass([
+  (0, import_sdk.Provider)({
+    name: "provider:feature-flags:accessor",
+    description: "Context-scoped accessor for feature flag evaluation",
+    scope: import_sdk.ProviderScope.CONTEXT
+  })
+], FeatureFlagAccessor);
+function createFeatureFlagAccessor(adapter, ctx, config) {
+  return new FeatureFlagAccessor(adapter, ctx, config);
+}
+
+// plugins/plugin-feature-flags/src/feature-flag.plugin.ts
+var ListPromptsHook = (0, import_sdk2.FlowHooksOf)("prompts:list-prompts");
+var SearchSkillsHook = (0, import_sdk2.FlowHooksOf)("skills:search");
+var FeatureFlagPlugin = class extends import_sdk2.DynamicPlugin {
+  options;
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  async filterListTools(flowCtx) {
+    const { tools } = flowCtx.state;
+    if (!tools || tools.length === 0) return;
+    const flaggedTools = this.collectFlagRefs(tools, (item) => item.tool.metadata?.featureFlag);
+    if (flaggedTools.size === 0) return;
+    const adapter = this.get(FeatureFlagAdapterToken);
+    const flagResults = await this.batchEvaluateRefs(adapter, flaggedTools);
+    const filtered = tools.filter((item) => {
+      const ref = item.tool.metadata?.featureFlag;
+      if (!ref) return true;
+      return this.isRefEnabled(ref, flagResults);
+    });
+    flowCtx.state.set("tools", filtered);
+  }
+  async filterListResources(flowCtx) {
+    const { resources } = flowCtx.state;
+    if (!resources || resources.length === 0) return;
+    const flaggedResources = this.collectFlagRefs(resources, (item) => item.resource.metadata?.featureFlag);
+    if (flaggedResources.size === 0) return;
+    const adapter = this.get(FeatureFlagAdapterToken);
+    const flagResults = await this.batchEvaluateRefs(adapter, flaggedResources);
+    const filtered = resources.filter((item) => {
+      const ref = item.resource.metadata?.featureFlag;
+      if (!ref) return true;
+      return this.isRefEnabled(ref, flagResults);
+    });
+    flowCtx.state.set("resources", filtered);
+  }
+  async filterListPrompts(flowCtx) {
+    const { prompts } = flowCtx.state;
+    if (!prompts || prompts.length === 0) return;
+    const flaggedPrompts = this.collectFlagRefs(prompts, (item) => item.prompt.metadata?.featureFlag);
+    if (flaggedPrompts.size === 0) return;
+    const adapter = this.get(FeatureFlagAdapterToken);
+    const flagResults = await this.batchEvaluateRefs(adapter, flaggedPrompts);
+    const filtered = prompts.filter((item) => {
+      const ref = item.prompt.metadata?.featureFlag;
+      if (!ref) return true;
+      return this.isRefEnabled(ref, flagResults);
+    });
+    flowCtx.state.set("prompts", filtered);
+  }
+  async filterSearchSkills(flowCtx) {
+    const { results } = flowCtx.state;
+    if (!results || results.length === 0) return;
+    const flaggedSkills = this.collectFlagRefs(results, (item) => item.metadata?.featureFlag);
+    if (flaggedSkills.size === 0) return;
+    const adapter = this.get(FeatureFlagAdapterToken);
+    const flagResults = await this.batchEvaluateRefs(adapter, flaggedSkills);
+    const filtered = results.filter((item) => {
+      const ref = item.metadata?.featureFlag;
+      if (!ref) return true;
+      return this.isRefEnabled(ref, flagResults);
+    });
+    flowCtx.state.set("results", filtered);
+  }
+  async gateToolExecution(flowCtx) {
+    const { tool } = flowCtx.state;
+    if (!tool) return;
+    const ref = tool.metadata?.featureFlag;
+    if (!ref) return;
+    const adapter = this.get(FeatureFlagAdapterToken);
+    const key = typeof ref === "string" ? ref : ref.key;
+    const defaultValue = typeof ref === "object" ? ref.defaultValue ?? false : false;
+    let enabled;
+    try {
+      enabled = await adapter.isEnabled(key, {});
+    } catch {
+      enabled = defaultValue;
+    }
+    if (!enabled) {
+      throw new Error(`Tool "${tool.metadata.name}" is disabled by feature flag "${key}"`);
+    }
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Private Helpers
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Collect unique flag keys from items that have a featureFlag metadata.
+   */
+  collectFlagRefs(items, getRef) {
+    const refs = /* @__PURE__ */ new Map();
+    for (const item of items) {
+      const ref = getRef(item);
+      if (ref) {
+        const key = typeof ref === "string" ? ref : ref.key;
+        if (!refs.has(key)) {
+          refs.set(key, ref);
+        }
+      }
+    }
+    return refs;
+  }
+  /**
+   * Batch evaluate all collected flag refs via the adapter.
+   */
+  async batchEvaluateRefs(adapter, refs) {
+    const keys = Array.from(refs.keys());
+    return adapter.evaluateFlags(keys, {});
+  }
+  /**
+   * Determine if a feature flag ref is enabled given adapter results.
+   * For object-style refs, `defaultValue` acts as a fallback when the adapter
+   * returns false (i.e., the flag is unknown to the adapter).
+   */
+  isRefEnabled(ref, flagResults) {
+    const key = typeof ref === "string" ? ref : ref.key;
+    const adapterResult = flagResults.get(key);
+    const defaultValue = typeof ref === "object" ? ref.defaultValue ?? false : false;
+    if (adapterResult === true) return true;
+    return defaultValue;
+  }
+};
+/**
+ * Dynamic providers based on plugin options.
+ */
+__publicField(FeatureFlagPlugin, "dynamicProviders", (options) => {
+  const providers = [];
+  switch (options.adapter) {
+    case "static":
+      providers.push({
+        name: "feature-flags:adapter:static",
+        provide: FeatureFlagAdapterToken,
+        useValue: new StaticFeatureFlagAdapter(options.flags)
+      });
+      break;
+    case "splitio":
+      providers.push({
+        name: "feature-flags:adapter:splitio",
+        provide: FeatureFlagAdapterToken,
+        inject: () => [],
+        useFactory: async () => {
+          const { SplitioFeatureFlagAdapter: SplitioFeatureFlagAdapter2 } = (init_splitio_adapter(), __toCommonJS(splitio_adapter_exports));
+          const adapter = new SplitioFeatureFlagAdapter2(options.config);
+          await adapter.initialize();
+          return adapter;
+        }
+      });
+      break;
+    case "launchdarkly":
+      providers.push({
+        name: "feature-flags:adapter:launchdarkly",
+        provide: FeatureFlagAdapterToken,
+        inject: () => [],
+        useFactory: async () => {
+          const { LaunchDarklyFeatureFlagAdapter: LaunchDarklyFeatureFlagAdapter2 } = (init_launchdarkly_adapter(), __toCommonJS(launchdarkly_adapter_exports));
+          const adapter = new LaunchDarklyFeatureFlagAdapter2(options.config);
+          await adapter.initialize();
+          return adapter;
+        }
+      });
+      break;
+    case "unleash":
+      providers.push({
+        name: "feature-flags:adapter:unleash",
+        provide: FeatureFlagAdapterToken,
+        inject: () => [],
+        useFactory: async () => {
+          const { UnleashFeatureFlagAdapter: UnleashFeatureFlagAdapter2 } = (init_unleash_adapter(), __toCommonJS(unleash_adapter_exports));
+          const adapter = new UnleashFeatureFlagAdapter2(options.config);
+          await adapter.initialize();
+          return adapter;
+        }
+      });
+      break;
+    case "custom":
+      providers.push({
+        name: "feature-flags:adapter:custom",
+        provide: FeatureFlagAdapterToken,
+        useValue: options.adapterInstance
+      });
+      break;
+  }
+  providers.push({
+    name: "feature-flags:config",
+    provide: FeatureFlagConfigToken,
+    useValue: options
+  });
+  providers.push({
+    name: "feature-flags:accessor",
+    provide: FeatureFlagAccessorToken,
+    scope: import_sdk2.ProviderScope.CONTEXT,
+    inject: () => [FeatureFlagAdapterToken, import_sdk2.FRONTMCP_CONTEXT, FeatureFlagConfigToken],
+    useFactory: (adapter, ctx, cfg) => createFeatureFlagAccessor(adapter, ctx, cfg)
+  });
+  return providers;
+});
+__decorateClass([
+  import_sdk2.ListToolsHook.Did("findTools", { priority: 50 })
+], FeatureFlagPlugin.prototype, "filterListTools", 1);
+__decorateClass([
+  import_sdk2.ListResourcesHook.Did("findResources", { priority: 50 })
+], FeatureFlagPlugin.prototype, "filterListResources", 1);
+__decorateClass([
+  ListPromptsHook.Did("findPrompts", { priority: 50 })
+], FeatureFlagPlugin.prototype, "filterListPrompts", 1);
+__decorateClass([
+  SearchSkillsHook.Did("search", { priority: 50 })
+], FeatureFlagPlugin.prototype, "filterSearchSkills", 1);
+__decorateClass([
+  import_sdk2.ToolHook.Will("execute", { priority: 50 })
+], FeatureFlagPlugin.prototype, "gateToolExecution", 1);
+FeatureFlagPlugin = __decorateClass([
+  (0, import_sdk2.Plugin)({
+    name: "feature-flags",
+    description: "Feature flag-based capability filtering for MCP",
+    providers: [],
+    contextExtensions: [
+      {
+        property: "featureFlags",
+        token: FeatureFlagAccessorToken,
+        errorMessage: "FeatureFlagPlugin is not installed. Add FeatureFlagPlugin.init() to your plugins array."
+      }
+    ]
+  })
+], FeatureFlagPlugin);
+
+// plugins/plugin-feature-flags/src/index.ts
+init_splitio_adapter();
+init_launchdarkly_adapter();
+init_unleash_adapter();
+
+// plugins/plugin-feature-flags/src/feature-flag.context-extension.ts
+function getFeatureFlags(ctx) {
+  return ctx.get(FeatureFlagAccessorToken);
+}
+function tryGetFeatureFlags(ctx) {
+  if (typeof ctx.tryGet === "function") {
+    return ctx.tryGet(FeatureFlagAccessorToken);
+  }
+  return void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FeatureFlagAccessor,
+  FeatureFlagAccessorToken,
+  FeatureFlagAdapterToken,
+  FeatureFlagConfigToken,
+  FeatureFlagPlugin,
+  LaunchDarklyFeatureFlagAdapter,
+  SplitioFeatureFlagAdapter,
+  StaticFeatureFlagAdapter,
+  UnleashFeatureFlagAdapter,
+  getFeatureFlags,
+  tryGetFeatureFlags
+});

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@frontmcp/plugin-feature-flags",
+  "version": "0.0.1",
+  "description": "Feature flag plugin for FrontMCP - dynamically gate MCP capabilities behind feature flags",
+  "author": "AgentFront <info@agentfront.dev>",
+  "license": "Apache-2.0",
+  "keywords": [
+    "mcp",
+    "feature-flags",
+    "split",
+    "launchdarkly",
+    "unleash",
+    "plugin",
+    "frontmcp",
+    "agentfront"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/agentfront/frontmcp.git",
+    "directory": "plugins/plugin-feature-flags"
+  },
+  "bugs": {
+    "url": "https://github.com/agentfront/frontmcp/issues"
+  },
+  "homepage": "https://github.com/agentfront/frontmcp/blob/main/plugins/plugin-feature-flags/README.md",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "type": "commonjs",
+  "main": "./index.js",
+  "module": "./esm/index.mjs",
+  "types": "./index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "require": {
+        "types": "./index.d.ts",
+        "default": "./index.js"
+      },
+      "import": {
+        "types": "./index.d.ts",
+        "default": "./esm/index.mjs"
+      }
+    }
+  },
+  "dependencies": {
+    "@frontmcp/sdk": "1.0.0",
+    "@frontmcp/utils": "1.0.0",
+    "zod": "^4.0.0"
+  },
+  "peerDependencies": {
+    "@splitsoftware/splitio": "^10.0.0 || ^11.0.0",
+    "@launchdarkly/node-server-sdk": "^9.0.0 || ^10.0.0",
+    "unleash-client": "^5.0.0 || ^6.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@splitsoftware/splitio": {
+      "optional": true
+    },
+    "@launchdarkly/node-server-sdk": {
+      "optional": true
+    },
+    "unleash-client": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "reflect-metadata": "^0.2.2"
+  }
+}