@featureflip/mcp 0.1.0

package/dist/org-yZkTaCl5.js

@@ -0,0 +1,719 @@
+import { McpServer as e } from "@modelcontextprotocol/server";
+import * as t from "zod/v4";
+//#endregion
+//#region src/version.ts
+var n = {
+	name: "@featureflip/mcp",
+	version: "0.1.0",
+	description: "MCP server for managing Featureflip feature flags from AI agents and editors",
+	license: "Apache-2.0",
+	repository: {
+		type: "git",
+		url: "https://github.com/canopy-labs/featureflip-mcp.git"
+	},
+	homepage: "https://featureflip.io/docs/integrations/mcp/",
+	type: "module",
+	bin: { "featureflip-mcp": "bin/featureflip-mcp.mjs" },
+	exports: { ".": {
+		types: "./dist/index.d.ts",
+		import: "./dist/index.mjs"
+	} },
+	types: "./dist/index.d.ts",
+	files: ["dist", "bin"],
+	publishConfig: { access: "public" },
+	scripts: {
+		build: "vite build",
+		typecheck: "tsc --noEmit -p tsconfig.json",
+		"generate:api": "npx --yes openapi-typescript@7.13.0 ../../apps/management-api/public-v1-openapi.json -o src/generated/api-types.ts",
+		test: "vitest run",
+		"test:watch": "vitest"
+	},
+	dependencies: {
+		"@modelcontextprotocol/server": "2.0.0-beta.3",
+		zod: "^4.0.0"
+	},
+	devDependencies: {
+		"@modelcontextprotocol/client": "2.0.0-beta.3",
+		"@types/node": "^26.0.0",
+		typescript: "^7.0.2",
+		vite: "^8.0.16",
+		"vite-plugin-dts": "^5.0.0",
+		vitest: "^4.1.2"
+	},
+	engines: { node: ">=20.19.0" }
+}.version, r = class extends Error {
+	status;
+	envelope;
+	constructor(e, t) {
+		super(t.message), this.status = e, this.envelope = t, this.name = "ApiError";
+	}
+};
+function i(e) {
+	return encodeURIComponent(e);
+}
+var a = class {
+	opts;
+	fetchImpl;
+	constructor(e) {
+		this.opts = e, this.fetchImpl = e.fetchImpl ?? fetch;
+	}
+	async request(e, t, n = {}) {
+		let i = new URL(this.opts.baseUrl + t);
+		for (let [e, t] of Object.entries(n.query ?? {})) t !== void 0 && i.searchParams.set(e, String(t));
+		let a = {
+			Authorization: `Bearer ${this.opts.token}`,
+			Accept: "application/json"
+		}, o;
+		n.body !== void 0 && (a["Content-Type"] = "application/json", o = JSON.stringify(n.body)), n.idempotencyKey && (a["Idempotency-Key"] = n.idempotencyKey);
+		let s = await this.fetchImpl(i.toString(), {
+			method: e,
+			headers: a,
+			body: o
+		});
+		if (s.status !== 204) {
+			if (!s.ok) {
+				let e;
+				try {
+					if (e = await s.json(), typeof e?.error != "string") throw Error("not an envelope");
+				} catch {
+					e = {
+						error: `http_${s.status}`,
+						message: `HTTP ${s.status} from ${i.pathname}`
+					};
+				}
+				throw new r(s.status, e);
+			}
+			return await s.json();
+		}
+	}
+};
+//#endregion
+//#region src/errors.ts
+function o(e) {
+	return { content: [{
+		type: "text",
+		text: JSON.stringify(e, null, 2)
+	}] };
+}
+function s(e) {
+	if (e instanceof r) {
+		let t = e.envelope, n = [`Featureflip API error ${e.status} (${t.error}): ${t.message}`];
+		return t.fields && n.push(`Field errors: ${JSON.stringify(t.fields)}`), t.did_you_mean?.length && n.push(`Did you mean: ${t.did_you_mean.join(", ")}`), t.next_actions?.length && n.push(`Next actions: ${t.next_actions.map((e) => `${e.method} ${e.path}`).join("; ")}`), t.retry_after != null && n.push(`Rate limited — retry after ${t.retry_after}s.`), e.status === 404 && n.push("Note: 404 can also mean the public Management API is not enabled for this organization yet, or a service token does not include this project."), t.docs_url && n.push(`Docs: ${t.docs_url}`), {
+			content: [{
+				type: "text",
+				text: n.join("\n")
+			}],
+			isError: !0
+		};
+	}
+	return {
+		content: [{
+			type: "text",
+			text: `Error: ${e instanceof Error ? e.message : String(e)}`
+		}],
+		isError: !0
+	};
+}
+async function c(e) {
+	try {
+		return await e();
+	} catch (e) {
+		return s(e);
+	}
+}
+//#endregion
+//#region src/tools/projects.ts
+var l = {
+	limit: t.number().int().min(1).max(100).optional().describe("Page size (default 20)"),
+	cursor: t.string().optional().describe("next_cursor from a previous response")
+};
+function u(e, n) {
+	e.registerTool("list_projects", {
+		title: "List projects",
+		description: "List projects in the Featureflip organization. Paginated: pass cursor from next_cursor to continue.",
+		inputSchema: t.object({ ...l }),
+		annotations: { readOnlyHint: !0 }
+	}, async ({ limit: e, cursor: t }) => c(async () => o(await n.api.request("GET", `/api/v1/orgs/${i(n.org)}/projects`, { query: {
+		limit: e,
+		cursor: t
+	} }))));
+}
+//#endregion
+//#region src/tools/environments.ts
+function d(e, n) {
+	e.registerTool("list_environments", {
+		title: "List environments",
+		description: "List the environments of a project (e.g. development, staging, production).",
+		inputSchema: t.object({
+			project: t.string().describe("Project key"),
+			limit: t.number().int().min(1).max(100).optional(),
+			cursor: t.string().optional()
+		}),
+		annotations: { readOnlyHint: !0 }
+	}, async ({ project: e, limit: t, cursor: r }) => c(async () => o(await n.api.request("GET", `/api/v1/orgs/${i(n.org)}/projects/${i(e)}/environments`, { query: {
+		limit: t,
+		cursor: r
+	} }))));
+}
+//#endregion
+//#region src/tools/segments.ts
+function f(e, n) {
+	e.registerTool("list_segments", {
+		title: "List user segments",
+		description: "List reusable user segments in a project. Segments are referenced from targeting rules via userSegmentId.",
+		inputSchema: t.object({
+			project: t.string().describe("Project key"),
+			limit: t.number().int().min(1).max(100).optional(),
+			cursor: t.string().optional()
+		}),
+		annotations: { readOnlyHint: !0 }
+	}, async ({ project: e, limit: t, cursor: r }) => c(async () => o(await n.api.request("GET", `/api/v1/orgs/${i(n.org)}/projects/${i(e)}/segments`, { query: {
+		limit: t,
+		cursor: r
+	} })))), e.registerTool("get_segment", {
+		title: "Get user segment",
+		description: "Get one user segment (its conditions, id, and metadata) by key or id.",
+		inputSchema: t.object({
+			project: t.string().describe("Project key"),
+			segment: t.string().describe("Segment key or id")
+		}),
+		annotations: { readOnlyHint: !0 }
+	}, async ({ project: e, segment: t }) => c(async () => o(await n.api.request("GET", `/api/v1/orgs/${i(n.org)}/projects/${i(e)}/segments/${i(t)}`))));
+}
+//#endregion
+//#region src/tools/flags.ts
+var p = t.enum([
+	"Boolean",
+	"String",
+	"Number",
+	"Json"
+]);
+function m(e, n) {
+	let r = (e) => `/api/v1/orgs/${i(n.org)}/projects/${i(e)}/flags`;
+	e.registerTool("list_flags", {
+		title: "List feature flags",
+		description: "List feature flags in a project. Filter with search (key/name substring), tag, type, archived. Paginated via cursor.",
+		inputSchema: t.object({
+			project: t.string().describe("Project key"),
+			search: t.string().optional(),
+			tag: t.string().optional(),
+			type: p.optional(),
+			archived: t.boolean().optional().describe("true = only archived, false = only active"),
+			limit: t.number().int().min(1).max(100).optional(),
+			cursor: t.string().optional()
+		}),
+		annotations: { readOnlyHint: !0 }
+	}, async ({ project: e, ...t }) => c(async () => o(await n.api.request("GET", r(e), { query: t })))), e.registerTool("get_flag", {
+		title: "Get feature flag",
+		description: "Get one feature flag with its variations and metadata. Address by flag key or id.",
+		inputSchema: t.object({
+			project: t.string().describe("Project key"),
+			flag: t.string().describe("Flag key or id")
+		}),
+		annotations: { readOnlyHint: !0 }
+	}, async ({ project: e, flag: t }) => c(async () => o(await n.api.request("GET", `${r(e)}/${i(t)}`)))), e.registerTool("create_flag", {
+		title: "Create feature flag",
+		description: "Create a feature flag. type is one of Boolean|String|Number|Json. Boolean flags get true/false variations automatically; for other types pass initialVariations. The flag is created in every environment of the project (disabled).",
+		inputSchema: t.object({
+			project: t.string().describe("Project key"),
+			key: t.string().describe("Unique flag key, e.g. checkout-v2"),
+			name: t.string(),
+			type: p,
+			description: t.string().optional(),
+			tags: t.array(t.string()).optional(),
+			clientSideVisible: t.boolean().optional().describe("Expose to client-side SDKs (browser/mobile)"),
+			initialVariations: t.array(t.object({
+				key: t.string(),
+				name: t.string().optional(),
+				value: t.string().describe("Variation value serialized as a string"),
+				description: t.string().optional()
+			})).optional(),
+			idempotency_key: t.string().optional().describe("Idempotency-Key header for safe retries")
+		}),
+		annotations: {}
+	}, async ({ project: e, idempotency_key: t, ...i }) => c(async () => o(await n.api.request("POST", r(e), {
+		body: i,
+		idempotencyKey: t
+	})))), e.registerTool("update_flag", {
+		title: "Update feature flag metadata",
+		description: "Update flag name/description/tags/clientSideVisible. Key and type are immutable. Use toggle_flag / update_targeting for behavior changes.",
+		inputSchema: t.object({
+			project: t.string(),
+			flag: t.string().describe("Flag key or id"),
+			name: t.string().optional(),
+			description: t.string().optional(),
+			tags: t.array(t.string()).optional(),
+			clientSideVisible: t.boolean().optional()
+		}),
+		annotations: {}
+	}, async ({ project: e, flag: t, ...a }) => c(async () => (await n.api.request("PUT", `${r(e)}/${i(t)}`, { body: a }), o({
+		project: e,
+		flag: t,
+		updated: !0
+	})))), e.registerTool("delete_flag", {
+		title: "Delete feature flag",
+		description: "PERMANENTLY delete a flag across all environments. Fails with FLAG_HAS_DEPENDENTS if other flags use it as a prerequisite. Prefer archive_flag unless the flag must be fully removed.",
+		inputSchema: t.object({
+			project: t.string(),
+			flag: t.string().describe("Flag key or id")
+		}),
+		annotations: { destructiveHint: !0 }
+	}, async ({ project: e, flag: t }) => c(async () => (await n.api.request("DELETE", `${r(e)}/${i(t)}`), o({ deleted: t })))), e.registerTool("archive_flag", {
+		title: "Archive feature flag",
+		description: "Archive a flag (soft-hide, evaluation stops serving it). Reversible with restore_flag.",
+		inputSchema: t.object({
+			project: t.string(),
+			flag: t.string()
+		}),
+		annotations: { destructiveHint: !0 }
+	}, async ({ project: e, flag: t }) => c(async () => (await n.api.request("POST", `${r(e)}/${i(t)}/archive`), o({
+		flag: t,
+		archived: !0
+	})))), e.registerTool("restore_flag", {
+		title: "Restore archived flag",
+		description: "Restore a previously archived flag.",
+		inputSchema: t.object({
+			project: t.string(),
+			flag: t.string()
+		}),
+		annotations: {}
+	}, async ({ project: e, flag: t }) => c(async () => (await n.api.request("POST", `${r(e)}/${i(t)}/restore`), o({
+		flag: t,
+		archived: !1
+	}))));
+}
+//#endregion
+//#region src/tools/flag-environments.ts
+var h = t.enum([
+	"SingleVariation",
+	"PercentageRollout",
+	"TargetedRollout"
+]);
+function g(e, n) {
+	let r = (e, t) => `/api/v1/orgs/${i(n.org)}/projects/${i(e)}/flags/${i(t)}`;
+	e.registerTool("toggle_flag", {
+		title: "Toggle flag in environment",
+		description: "Enable or disable a flag in ONE environment. Affects live evaluation immediately — double-check the environment.",
+		inputSchema: t.object({
+			project: t.string(),
+			flag: t.string().describe("Flag key or id"),
+			environment: t.string().describe("Environment key, e.g. production"),
+			enabled: t.boolean()
+		}),
+		annotations: { destructiveHint: !0 }
+	}, async ({ project: e, flag: t, environment: a, enabled: s }) => c(async () => (await n.api.request("POST", `${r(e, t)}/environments/${i(a)}/toggle`, { body: { enabled: s } }), o({
+		project: e,
+		flag: t,
+		environment: a,
+		enabled: s
+	})))), e.registerTool("update_flag_environment_config", {
+		title: "Update flag environment config",
+		description: "Update a flag's per-environment serving config: defaultVariationId (served on fallthrough, required), strategy (SingleVariation | PercentageRollout | TargetedRollout — only SingleVariation is currently supported at the environment level), and prerequisites. Percentage rollouts are configured on targeting rules via update_targeting.",
+		inputSchema: t.object({
+			project: t.string(),
+			flag: t.string(),
+			environment: t.string(),
+			defaultVariationId: t.string().describe("Variation id to serve on fallthrough — required by the API"),
+			strategy: h.optional(),
+			prerequisites: t.array(t.object({
+				prerequisiteFlagKey: t.string(),
+				expectedVariationKey: t.string()
+			})).optional().describe("Flags that must evaluate to the expected variation before this flag serves. Omit to leave existing prerequisites untouched; pass a list (possibly empty) to replace them wholesale.")
+		}),
+		annotations: { destructiveHint: !0 }
+	}, async ({ project: e, flag: t, environment: a, ...s }) => c(async () => (await n.api.request("PUT", `${r(e, t)}/environments/${i(a)}`, { body: s }), o({
+		project: e,
+		flag: t,
+		environment: a,
+		...s
+	})))), e.registerTool("flag_status", {
+		title: "Flag status across environments",
+		description: "Compact cross-environment view of one flag: enabled state, strategy, default variation, and prerequisites per environment.",
+		inputSchema: t.object({
+			project: t.string(),
+			flag: t.string()
+		}),
+		annotations: { readOnlyHint: !0 }
+	}, async ({ project: e, flag: t }) => c(async () => {
+		let [i, a] = await Promise.all([n.api.request("GET", r(e, t)), n.api.request("GET", `${r(e, t)}/environments`)]), s = (e) => (i.variations ?? []).find((t) => t.id === e)?.key ?? e ?? null;
+		return o({
+			key: i.key ?? null,
+			name: i.name ?? null,
+			type: i.type ?? null,
+			archived: i.isArchived ?? !1,
+			updatedAt: i.updatedAt ?? null,
+			environments: a.map((e) => ({
+				environment: e.environmentKey ?? null,
+				enabled: e.isEnabled ?? !1,
+				strategy: e.strategy ?? null,
+				defaultVariation: s(e.defaultVariationId),
+				prerequisites: e.prerequisites ?? []
+			}))
+		});
+	}));
+}
+//#endregion
+//#region src/tools/targeting.ts
+var _ = t.object({
+	attribute: t.string().describe("Context attribute name, e.g. plan, country, user_id"),
+	operator: t.string().describe("OperatorType member name, case-sensitive — e.g. Equals, NotEquals, Contains, In, GreaterThan"),
+	values: t.array(t.string()),
+	negate: t.boolean().optional().default(!1)
+}), v = t.object({
+	description: t.string().optional(),
+	variationId: t.string().optional().describe("Variation served when the rule matches"),
+	rolloutPercentage: t.number().int().min(0).max(100).optional().describe("Percentage rollout for this rule"),
+	userSegmentId: t.string().optional().describe("Match users in this segment (see list_segments)"),
+	conditionGroups: t.array(t.object({
+		operator: t.enum(["And", "Or"]).describe("How conditions inside this group combine"),
+		conditions: t.array(_)
+	})).optional().describe("Groups are ANDed together; conditions inside a group use the group operator")
+});
+function y(e, n) {
+	let r = (e, t, r) => `/api/v1/orgs/${i(n.org)}/projects/${i(e)}/flags/${i(t)}/environments/${i(r)}/targeting`;
+	e.registerTool("get_targeting", {
+		title: "Get targeting rules",
+		description: "Get a flag's current targeting configuration (enabled flag + ordered rules) in one environment.",
+		inputSchema: t.object({
+			project: t.string(),
+			flag: t.string(),
+			environment: t.string()
+		}),
+		annotations: { readOnlyHint: !0 }
+	}, async ({ project: e, flag: t, environment: i }) => c(async () => o(await n.api.request("GET", r(e, t, i))))), e.registerTool("update_targeting", {
+		title: "Replace targeting rules",
+		description: "REPLACE all targeting rules of a flag in one environment (full PUT — rules not included are removed). Rules are evaluated in order. Get the current rules first with get_targeting.",
+		inputSchema: t.object({
+			project: t.string(),
+			flag: t.string(),
+			environment: t.string(),
+			rules: t.array(v)
+		}),
+		annotations: { destructiveHint: !0 }
+	}, async ({ project: e, flag: t, environment: i, rules: a }) => c(async () => (await n.api.request("PUT", r(e, t, i), { body: { rules: a } }), o({
+		project: e,
+		flag: t,
+		environment: i,
+		rulesReplaced: a.length
+	}))));
+}
+//#endregion
+//#region src/tools/variations.ts
+function b(e, n) {
+	e.registerTool("manage_variation", {
+		title: "Add, update, or remove a variation",
+		description: "Manage a flag's variations. action=add requires key + value; action=update/remove require variationId (get ids via get_flag). Removing a variation fails with VARIATION_HAS_DEPENDENTS if other flags depend on it.",
+		inputSchema: t.object({
+			project: t.string(),
+			flag: t.string(),
+			action: t.enum([
+				"add",
+				"update",
+				"remove"
+			]),
+			variationId: t.string().optional().describe("Required for update/remove"),
+			key: t.string().optional().describe("Required for add; immutable afterwards"),
+			name: t.string().optional(),
+			value: t.string().optional().describe("Variation value serialized as a string; required for add"),
+			description: t.string().optional()
+		}),
+		annotations: { destructiveHint: !0 }
+	}, async ({ project: e, flag: t, action: r, variationId: a, key: l, name: u, value: d, description: f }) => c(async () => {
+		let c = `/api/v1/orgs/${i(n.org)}/projects/${i(e)}/flags/${i(t)}/variations`;
+		return r === "add" ? !l || d === void 0 ? s(/* @__PURE__ */ Error("action=add requires key and value")) : o(await n.api.request("POST", c, { body: {
+			key: l,
+			name: u,
+			value: d,
+			description: f
+		} })) : a ? r === "update" ? (await n.api.request("PUT", `${c}/${i(a)}`, { body: {
+			name: u,
+			value: d,
+			description: f
+		} }), o({ updated: a })) : (await n.api.request("DELETE", `${c}/${i(a)}`), o({ removed: a })) : s(/* @__PURE__ */ Error(`action=${r} requires variationId (see get_flag for ids)`));
+	}));
+}
+//#endregion
+//#region src/tools/workflows/stale-flags.ts
+var x = 50;
+function S(e, n) {
+	e.registerTool("find_stale_flags", {
+		title: "Find stale flags",
+		description: `Find flags that look ready for code cleanup: not updated in N days AND either enabled in every environment (verify rollout is complete before removing — per-rule percentage ramps are not inspected) or disabled in every environment (dead — remove flag and code path). Checks at most ${x} candidates per call.`,
+		inputSchema: t.object({
+			project: t.string(),
+			days: t.number().int().min(1).optional().default(30).describe("Minimum age in days since last update")
+		}),
+		annotations: { readOnlyHint: !0 }
+	}, async ({ project: e, days: t }) => c(async () => {
+		let r = `/api/v1/orgs/${i(n.org)}/projects/${i(e)}/flags`, a = Date.now() - t * 24 * 60 * 60 * 1e3, s = [], c;
+		do {
+			let e = await n.api.request("GET", r, { query: {
+				archived: !1,
+				limit: 100,
+				cursor: c
+			} });
+			s.push(...(e.items ?? []).filter((e) => !!e.key && !!e.name && !!e.updatedAt && new Date(e.updatedAt).getTime() < a)), c = e.next_cursor ?? void 0;
+		} while (c);
+		let l = s.length > x, u = s.slice(0, x), d = [];
+		for (let e of u) {
+			let t = await n.api.request("GET", `${r}/${i(e.key)}/environments`);
+			if (t.length === 0) continue;
+			let a = t.every((e) => e.isEnabled), o = t.every((e) => !e.isEnabled);
+			!a && !o || d.push({
+				key: e.key,
+				name: e.name,
+				updatedAt: e.updatedAt,
+				reason: a ? "enabled-everywhere" : "disabled-everywhere",
+				environments: t.length
+			});
+		}
+		return o({
+			project: e,
+			olderThanDays: t,
+			checked: u.length,
+			truncated: l,
+			...l ? { note: `Only the first ${x} of ${s.length} candidates were checked.` } : {},
+			stale: d
+		});
+	}));
+}
+//#endregion
+//#region src/tools/workflows/snippets.ts
+var C = [
+	"js",
+	"node",
+	"browser",
+	"react",
+	"python",
+	"csharp",
+	"java",
+	"go",
+	"php",
+	"ruby",
+	"swift"
+], w = "Uses a SERVER-side SDK key (Featureflip dashboard → environment → SDK keys).", T = "Uses a CLIENT-side SDK key (safe to ship to browsers/apps).";
+function E(e, t) {
+	switch (e) {
+		case "js": return {
+			install: "npm install @featureflip/js",
+			code: `import { FeatureflipClient, createNodePlatform } from '@featureflip/js';
+
+const client = FeatureflipClient.get(
+  { sdkKey: process.env.FEATUREFLIP_SDK_KEY!, baseUrl: 'https://eval.featureflip.io' },
+  createNodePlatform(),
+);
+await client.waitForInitialization();
+const enabled = client.boolVariation('${t}', { user_id: userId }, false);
+if (enabled) {
+  // new code path
+}`,
+			notes: w
+		};
+		case "node": return {
+			install: "npm install @featureflip/node",
+			code: `import { FeatureflipClient } from '@featureflip/node';
+
+const client = await FeatureflipClient.create({ sdkKey: process.env.FEATUREFLIP_SDK_KEY! });
+const enabled = client.boolVariation('${t}', { user_id: userId }, false);
+if (enabled) {
+  // new code path
+}`,
+			notes: w
+		};
+		case "browser": return {
+			install: "npm install @featureflip/browser",
+			code: `import { FeatureflipClient } from '@featureflip/browser';
+
+const client = FeatureflipClient.get({ clientKey: 'YOUR_CLIENT_SDK_KEY' });
+await client.initialize();
+const enabled = client.boolVariation('${t}', false);
+if (enabled) {
+  // new code path
+}`,
+			notes: T
+		};
+		case "react": return {
+			install: "npm install @featureflip/react @featureflip/browser",
+			code: `import { FeatureflipProvider, useFeatureFlag } from '@featureflip/react';
+
+// In your app root:
+// <FeatureflipProvider clientKey="YOUR_CLIENT_SDK_KEY">...</FeatureflipProvider>
+
+function MyComponent() {
+  const enabled = useFeatureFlag('${t}', false);
+  return enabled ? <NewExperience /> : <CurrentExperience />;
+}`,
+			notes: T
+		};
+		case "python": return {
+			install: "pip install featureflip",
+			code: `from featureflip import FeatureflipClient
+
+client = FeatureflipClient(sdk_key=os.environ["FEATUREFLIP_SDK_KEY"])
+enabled = client.variation("${t}", {"user_id": user_id}, default=False)
+if enabled:
+    # new code path
+    ...`,
+			notes: w
+		};
+		case "csharp": return {
+			install: "dotnet add package Featureflip.Client",
+			code: `using Featureflip.Client;
+
+var client = FeatureflipClient.Get(Environment.GetEnvironmentVariable("FEATUREFLIP_SDK_KEY")!);
+var enabled = client.BoolVariation("${t}",
+    new EvaluationContext { UserId = userId }, false);
+if (enabled)
+{
+    // new code path
+}`,
+			notes: w
+		};
+		case "java": return {
+			install: "implementation 'io.featureflip:featureflip-java:2.0.0'",
+			code: `import io.featureflip.client.FeatureflipClient;
+import io.featureflip.client.EvaluationContext;
+
+FeatureflipClient client = FeatureflipClient.get(System.getenv("FEATUREFLIP_SDK_KEY"));
+client.waitForInitialization();
+boolean enabled = client.boolVariation("${t}",
+    EvaluationContext.of(userId), false);
+if (enabled) {
+    // new code path
+}`,
+			notes: w
+		};
+		case "go": return {
+			install: "go get github.com/canopy-labs/featureflip-go",
+			code: `import featureflip "github.com/canopy-labs/featureflip-go"
+
+client, err := featureflip.Get(os.Getenv("FEATUREFLIP_SDK_KEY"))
+if err != nil {
+    log.Fatal(err)
+}
+defer client.Close()
+
+ctx := featureflip.EvaluationContext{UserID: userID}
+if client.BoolVariation("${t}", ctx, false) {
+    // new code path
+}`,
+			notes: w
+		};
+		case "php": return {
+			install: "composer require featureflip/featureflip-php",
+			code: `use Featureflip\\FeatureflipClient;
+use Featureflip\\Config;
+
+$client = FeatureflipClient::get(getenv('FEATUREFLIP_SDK_KEY'), new Config(
+    cache: $psrCache, httpClient: $psrHttpClient,
+    requestFactory: $psrRequestFactory, streamFactory: $psrStreamFactory,
+));
+$enabled = $client->boolVariation('${t}', ['user_id' => $userId], false);
+if ($enabled) {
+    // new code path
+}`,
+			notes: "Uses a SERVER-side SDK key (Featureflip dashboard → environment → SDK keys). Requires PSR-16 cache and PSR-18 HTTP implementations."
+		};
+		case "ruby": return {
+			install: "gem \"featureflip\"",
+			code: `require "featureflip"
+
+client = Featureflip::Client.get(ENV.fetch("FEATUREFLIP_SDK_KEY"))
+enabled = client.bool_variation("${t}", { "user_id" => user_id }, false)
+if enabled
+  # new code path
+end`,
+			notes: w
+		};
+		case "swift": return {
+			install: ".package(url: \"https://github.com/canopy-labs/featureflip-swift\", from: \"2.0.0\")",
+			code: `import Featureflip
+
+let config = FeatureflipConfig(clientKey: "YOUR_CLIENT_SDK_KEY")
+let client = FeatureflipClient(config: config)
+await client.initialize()
+let enabled = client.boolVariation("${t}", default: false)
+if enabled {
+    // new code path
+}`,
+			notes: T
+		};
+	}
+}
+//#endregion
+//#region src/tools/workflows/wrap-feature.ts
+function D(e, n) {
+	e.registerTool("wrap_feature", {
+		title: "Wrap a feature in a new flag",
+		description: "Create a Boolean feature flag and get back the SDK code snippet to guard the new code path with it. Returns the snippet only — apply the edit yourself. The flag starts DISABLED in every environment; enable it with toggle_flag when ready.",
+		inputSchema: t.object({
+			project: t.string().describe("Project key"),
+			key: t.string().describe("Flag key, e.g. new-checkout"),
+			name: t.string().optional().describe("Display name; defaults to the key"),
+			description: t.string().optional().describe("What this flag guards"),
+			tags: t.array(t.string()).optional(),
+			language: t.enum(C).describe("SDK language of the codebase being edited"),
+			idempotency_key: t.string().optional()
+		}),
+		annotations: {}
+	}, async ({ project: e, key: t, name: r, description: a, tags: s, language: l, idempotency_key: u }) => c(async () => {
+		let c = await n.api.request("POST", `/api/v1/orgs/${i(n.org)}/projects/${i(e)}/flags`, {
+			body: {
+				key: t,
+				name: r ?? t,
+				type: "Boolean",
+				description: a,
+				tags: s
+			},
+			idempotencyKey: u
+		}), d = E(l, t);
+		return o({
+			flag: c,
+			integration: {
+				language: l,
+				install: d.install,
+				code: d.code,
+				notes: d.notes
+			},
+			next_steps: [
+				"Apply the snippet around the new code path.",
+				`Enable in a non-production environment first: toggle_flag { project: "${e}", flag: "${t}", environment: "<env>", enabled: true }.`,
+				"Ramp with update_targeting (rolloutPercentage) when ready."
+			]
+		});
+	}));
+}
+//#endregion
+//#region src/server.ts
+function O(t) {
+	let r = new e({
+		name: "featureflip",
+		version: n
+	});
+	return u(r, t), d(r, t), f(r, t), m(r, t), g(r, t), y(r, t), b(r, t), S(r, t), D(r, t), r;
+}
+//#endregion
+//#region src/config.ts
+function k(e = process.env) {
+	let t = e.FEATUREFLIP_TOKEN?.trim();
+	if (!t) throw Error("FEATUREFLIP_TOKEN is required. Create one in the Featureflip dashboard — Settings → API Tokens (personal token, ffp_...) or Organization Settings → Service Tokens (ffs_...) — and set it in your MCP client config.");
+	return {
+		token: t,
+		baseUrl: (e.FEATUREFLIP_API_URL?.trim() || "https://api.featureflip.io").replace(/\/+$/, ""),
+		org: e.FEATUREFLIP_ORG?.trim() || void 0
+	};
+}
+//#endregion
+//#region src/org.ts
+async function A(e, t) {
+	if (t) return t;
+	let n = (await e.request("GET", "/api/v1/orgs", { query: { limit: 100 } })).items ?? [];
+	if (n.length === 1) {
+		let e = n[0].slug;
+		if (!e) throw Error("The token can see one organization, but it has no slug set.");
+		return e;
+	}
+	throw n.length === 0 ? Error("The token can see no organizations. Check the token in the Featureflip dashboard.") : Error(`The token can see ${n.length} organizations — set FEATUREFLIP_ORG to one of: ` + n.map((e) => e.slug ?? "?").join(", "));
+}
+//#endregion
+export { a, r as i, k as n, n as o, O as r, A as t };