@greenflags/mcp 0.2.0

package/dist/tools/setFlagValue.d.ts

@@ -0,0 +1,61 @@
+import { type McpToolResult } from "../result.js";
+export declare const toolDefinition: {
+    name: string;
+    description: string;
+    annotations: {
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+    };
+    inputSchema: {
+        type: "object";
+        properties: {
+            project: {
+                type: string;
+                description: string;
+            };
+            project_id: {
+                type: string;
+                description: string;
+            };
+            flag: {
+                type: string;
+                description: string;
+            };
+            flag_id: {
+                type: string;
+                description: string;
+            };
+            environment: {
+                type: string;
+                description: string;
+            };
+            environment_id: {
+                type: string;
+                description: string;
+            };
+            type: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            value_boolean: {
+                type: string;
+            };
+            value_string: {
+                type: string;
+            };
+            value_number: {
+                type: string;
+            };
+            value_json: {
+                type: string;
+            };
+            confirm: {
+                type: string;
+                description: string;
+            };
+        };
+        required: never[];
+    };
+};
+export declare function handler(args: Record<string, unknown>): Promise<McpToolResult>;

package/dist/tools/setFlagValue.js

@@ -0,0 +1,123 @@
+import { callApi } from "../api.js";
+import { requireProjectId } from "../config.js";
+import { ApiError, SensitiveConfirmRequiredError } from "../errors.js";
+import { okResult } from "../result.js";
+import { invalidateFlagCache, resolveEnvironment, resolveFlag, } from "../resolvers.js";
+export const toolDefinition = {
+    name: "set_flag_value",
+    description: "Set a flag's value in one environment. Supports boolean/string/number/json (replaces the old toggle_flag_value).\n" +
+        "Use when: enabling/disabling a flag or setting its typed value in an env.\n" +
+        "Prerequisites: a project, an existing flag, and an environment. Call list_environments first to see which envs are sensitive.\n" +
+        "Side effects: DESTRUCTIVE (can change production behavior). Writes to sensitive envs REQUIRE confirm:true or the call is refused. Idempotent — same value yields changed:false.\n" +
+        'Example: set_flag_value(flag: "checkout-v2", environment: "staging", value_boolean: true).',
+    annotations: {
+        destructiveHint: true,
+        idempotentHint: true,
+    },
+    inputSchema: {
+        type: "object",
+        properties: {
+            project: {
+                type: "string",
+                description: "Project id or slug. Optional if GREENFLAGS_PROJECT_ID is set.",
+            },
+            project_id: { type: "string", description: "Legacy alias for `project`." },
+            flag: {
+                type: "string",
+                description: "Flag key (preferred) or flag id.",
+            },
+            flag_id: { type: "string", description: "Legacy alias for `flag`." },
+            environment: {
+                type: "string",
+                description: "Environment slug (preferred) or environment id.",
+            },
+            environment_id: {
+                type: "string",
+                description: "Legacy alias for `environment`.",
+            },
+            type: {
+                type: "string",
+                enum: ["boolean", "string", "number", "json"],
+                description: "Override flag value type. Defaults to the flag's declared type.",
+            },
+            value_boolean: { type: "boolean" },
+            value_string: { type: "string" },
+            value_number: { type: "number" },
+            value_json: { type: "object" },
+            confirm: {
+                type: "boolean",
+                description: "Required when the target environment is sensitive (e.g. prod). Set true to acknowledge the write.",
+            },
+        },
+        required: [],
+    },
+};
+function pickTypedValue(type, args) {
+    switch (type) {
+        case "boolean":
+            if (typeof args["value_boolean"] !== "boolean") {
+                throw new ApiError("VALIDATION_FAILED", "Flag type is boolean — pass `value_boolean: true|false`.", 422);
+            }
+            return { key: "valueBoolean", value: args["value_boolean"] };
+        case "string":
+            if (typeof args["value_string"] !== "string") {
+                throw new ApiError("VALIDATION_FAILED", "Flag type is string — pass `value_string`.", 422);
+            }
+            return { key: "valueString", value: args["value_string"] };
+        case "number":
+            if (typeof args["value_number"] !== "number") {
+                throw new ApiError("VALIDATION_FAILED", "Flag type is number — pass `value_number`.", 422);
+            }
+            return { key: "valueNumber", value: args["value_number"] };
+        case "json":
+            if (typeof args["value_json"] !== "object" ||
+                args["value_json"] === null ||
+                Array.isArray(args["value_json"])) {
+                throw new ApiError("VALIDATION_FAILED", "Flag type is json — pass `value_json` as an object.", 422);
+            }
+            return { key: "valueJson", value: args["value_json"] };
+        default:
+            throw new ApiError("VALIDATION_FAILED", `Unknown flag type '${type}'.`, 422);
+    }
+}
+export async function handler(args) {
+    const projectId = requireProjectId(args["project"] ?? args["project_id"]);
+    const flagArg = (args["flag"] ?? args["flag_id"]);
+    if (typeof flagArg !== "string" || flagArg.trim() === "") {
+        throw new Error("`flag` (key or id) is required.");
+    }
+    const envArg = (args["environment"] ?? args["environment_id"]);
+    if (typeof envArg !== "string" || envArg.trim() === "") {
+        throw new Error("`environment` (slug or id) is required.");
+    }
+    const confirm = args["confirm"] === true;
+    const flag = await resolveFlag(projectId, flagArg.trim());
+    const env = await resolveEnvironment(projectId, envArg.trim());
+    if (env.is_sensitive && !confirm) {
+        throw new SensitiveConfirmRequiredError(env.slug);
+    }
+    const effectiveType = typeof args["type"] === "string" ? args["type"] : flag.type;
+    const { key: valueKey, value } = pickTypedValue(effectiveType, args);
+    const valuesBefore = await callApi(`/admin/projects/${encodeURIComponent(projectId)}/flags/${encodeURIComponent(flag.id)}/values`);
+    const beforeRow = valuesBefore.values.find((v) => v.environmentId === env.id);
+    const body = {
+        type: effectiveType,
+        [valueKey]: value,
+    };
+    if (confirm)
+        body["confirmed"] = true;
+    const result = await callApi(`/admin/projects/${encodeURIComponent(projectId)}/flags/${encodeURIComponent(flag.id)}/values/${encodeURIComponent(env.id)}`, "PUT", body);
+    const after = result.value;
+    const before = beforeRow
+        ? { type: beforeRow.type, value: beforeRow.value }
+        : null;
+    const changed = JSON.stringify(before?.value) !== JSON.stringify(after.value);
+    invalidateFlagCache(projectId);
+    return okResult({
+        value: after,
+        before,
+        after: { type: after.type, value: after.value },
+        changed,
+        environment: { id: env.id, slug: env.slug, is_sensitive: Boolean(env.is_sensitive) },
+    }, `${flag.key} in ${env.slug} = ${JSON.stringify(after.value)}${changed ? "" : " (no change)"}${env.is_sensitive ? " [sensitive]" : ""}`);
+}

package/dist/tools/updateFlag.d.ts

@@ -0,0 +1,40 @@
+import { type McpToolResult } from "../result.js";
+export declare const toolDefinition: {
+    name: string;
+    description: string;
+    annotations: {
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+    };
+    inputSchema: {
+        type: "object";
+        properties: {
+            project: {
+                type: string;
+                description: string;
+            };
+            project_id: {
+                type: string;
+                description: string;
+            };
+            flag: {
+                type: string;
+                description: string;
+            };
+            flag_id: {
+                type: string;
+                description: string;
+            };
+            name: {
+                type: string;
+                description: string;
+            };
+            description: {
+                type: string;
+                description: string;
+            };
+        };
+        required: never[];
+    };
+};
+export declare function handler(args: Record<string, unknown>): Promise<McpToolResult>;

package/dist/tools/updateFlag.js

@@ -0,0 +1,60 @@
+import { callApi } from "../api.js";
+import { requireProjectId } from "../config.js";
+import { okResult } from "../result.js";
+import { invalidateFlagCache, resolveFlag } from "../resolvers.js";
+export const toolDefinition = {
+    name: "update_flag",
+    description: "Update a flag's name and/or description. `key` and `type` are immutable and cannot be changed here.\n" +
+        "Use when: renaming a flag or editing its description. To change its on/off value use set_flag_value.\n" +
+        "Prerequisites: a project + an existing flag (key or id). Provide at least one of name/description.\n" +
+        "Side effects: mutates flag metadata. Idempotent — same body yields changed:false.\n" +
+        'Example: update_flag(flag: "dark-mode", name: "Dark Theme").',
+    annotations: {
+        destructiveHint: false,
+        idempotentHint: true,
+    },
+    inputSchema: {
+        type: "object",
+        properties: {
+            project: {
+                type: "string",
+                description: "Project id or slug. Optional if GREENFLAGS_PROJECT_ID is set.",
+            },
+            project_id: { type: "string", description: "Legacy alias for `project`." },
+            flag: {
+                type: "string",
+                description: "Flag key (preferred) or flag id.",
+            },
+            flag_id: { type: "string", description: "Legacy alias for `flag`." },
+            name: { type: "string", description: "New name (optional)." },
+            description: {
+                type: "string",
+                description: "New description (optional, pass null to clear).",
+            },
+        },
+        required: [],
+    },
+};
+export async function handler(args) {
+    const projectId = requireProjectId(args["project"] ?? args["project_id"]);
+    const flagArg = (args["flag"] ?? args["flag_id"]);
+    if (typeof flagArg !== "string" || flagArg.trim() === "") {
+        throw new Error("`flag` (key or id) is required.");
+    }
+    const name = args["name"];
+    const descriptionRaw = args["description"];
+    if (name === undefined && descriptionRaw === undefined) {
+        throw new Error("At least one of `name` or `description` is required.");
+    }
+    const current = await resolveFlag(projectId, flagArg.trim());
+    const body = {
+        name: typeof name === "string" ? name : current.name,
+        description: descriptionRaw === undefined ? current.description ?? null : descriptionRaw,
+    };
+    const data = await callApi(`/admin/projects/${encodeURIComponent(projectId)}/flags/${encodeURIComponent(current.id)}`, "PATCH", body);
+    invalidateFlagCache(projectId);
+    const before = { name: current.name, description: current.description ?? null };
+    const after = data.flag;
+    const changed = before.name !== after.name || before.description !== (after.description ?? null);
+    return okResult({ flag: after, before, changed }, `Flag ${after.key} updated${changed ? "" : " (no changes)"}.`);
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@greenflags/mcp",
+  "version": "0.2.0",
+  "description": "MCP server for GreenFlags feature flag management",
+  "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
+  "bin": {
+    "greenflags-mcp": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "feature-flags",
+    "greenflags",
+    "mcp",
+    "model-context-protocol"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "prepublishOnly": "npm run typecheck && npm run build && npm test"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "axios": "^1.9.0",
+    "open": "^10.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.8.0",
+    "vitest": "^2.0.0"
+  }
+}