updateFeatureFlag

Instructions

Implementation Reference

• src/tools/update-flag.ts:77-187 (handler)

  The async handler function that executes the tool logic: validates input with Zod schema, prepares UpdateFeatureRequest, calls BucketeerClient.updateFeature API, logs, and returns structured success or error response.

  handler: async (input: unknown) => {
  	try {
  		// Validate input
  		const params = updateFlagSchema.parse(input);
  
  		logger.debug("Updating feature flag", params);
  
  		// Create API client
  		const client = new BucketeerClient(
  			config.bucketeerHost,
  			config.bucketeerApiKey,
  		);
  
  		// Prepare request
  		const request: UpdateFeatureRequest = {
  			id: params.id,
  			comment: params.comment,
  			environmentId: getEnvironmentId(params.environmentId),
  		};
  
  		// Only add fields that are being updated
  		if (params.name !== undefined) {
  			request.name = params.name;
  		}
  		if (params.description !== undefined) {
  			request.description = params.description;
  		}
  		if (params.tags !== undefined) {
  			request.tags = { values: params.tags };
  		}
  		if (params.enabled !== undefined) {
  			request.enabled = params.enabled;
  		}
  		if (params.archived !== undefined) {
  			request.archived = params.archived;
  		}
  
  		// Make API call
  		const response = await client.updateFeature(request);
  
  		logger.info(`Successfully updated feature flag: ${response.feature.id}`);
  
  		return {
  			content: [
  				{
  					type: "text",
  					text: JSON.stringify(
  						{
  							success: true,
  							feature: response.feature,
  							updated: {
  								...(params.name !== undefined && { name: params.name }),
  								...(params.description !== undefined && {
  									description: params.description,
  								}),
  								...(params.tags !== undefined && { tags: params.tags }),
  								...(params.enabled !== undefined && {
  									enabled: params.enabled,
  								}),
  								...(params.archived !== undefined && {
  									archived: params.archived,
  								}),
  							},
  						},
  						null,
  						2,
  					),
  				},
  			],
  		};
  	} catch (error) {
  		logger.error("Failed to update feature flag", error);
  
  		if (error instanceof z.ZodError) {
  			return {
  				content: [
  					{
  						type: "text",
  						text: JSON.stringify(
  							{
  								success: false,
  								error: "Invalid input parameters",
  								details: error.issues,
  							},
  							null,
  							2,
  						),
  					},
  				],
  				isError: true,
  			};
  		}
  
  		return {
  			content: [
  				{
  					type: "text",
  					text: JSON.stringify(
  						{
  							success: false,
  							error: error instanceof Error ? error.message : "Unknown error",
  						},
  						null,
  						2,
  					),
  				},
  			],
  			isError: true,
  		};
  	}
  },

• src/tools/update-flag.ts:7-31 (schema)

  Zod schema defining and validating the input for the updateFeatureFlag tool, requiring id and comment, allowing optional update fields, and refining to ensure at least one updatable field is present.

  // Input schema for the update-flag tool
  export const updateFlagSchema = z
  	.object({
  		id: z.string().min(1, "Feature flag ID is required"),
  		comment: z.string().min(1, "Comment is required for all updates"),
  		environmentId: z.string().optional(),
  		name: z.string().optional(),
  		description: z.string().optional(),
  		tags: z.array(z.string()).optional(),
  		enabled: z.boolean().optional(),
  		archived: z.boolean().optional(),
  	})
  	.refine(
  		(data) => {
  			// At least one update field must be provided
  			return (
  				data.name !== undefined ||
  				data.description !== undefined ||
  				data.tags !== undefined ||
  				data.enabled !== undefined ||
  				data.archived !== undefined
  			);
  		},
  		{ message: "At least one field to update must be provided" },
  	);

• src/tools/index.ts:1-13 (registration)

  Central registration of all feature flag tools, including updateFlagTool, in the exported 'tools' array used by the MCP server.

  import { listFlagsTool } from "./list-flags.js";
  import { createFlagTool } from "./create-flag.js";
  import { getFlagTool } from "./get-flag.js";
  import { updateFlagTool } from "./update-flag.js";
  import { archiveFlagTool } from "./archive-flag.js";
  
  export const tools = [
  	listFlagsTool,
  	createFlagTool,
  	getFlagTool,
  	updateFlagTool,
  	archiveFlagTool,
  ];