feat: add rollout to segment and users

Author: Swiftwork

packages/cli/commands/companies.ts

@@ -4,12 +4,8 @@ import { Argument, Command } from "commander";
 import ora, { Ora } from "ora";
 
 import { getApp } from "../services/bootstrap.js";
-import {
-  CompanyFeatureAccess,
-  companyFeatureAccess,
-  listCompanies,
-} from "../services/companies.js";
-import { listFeatures } from "../services/features.js";
+import { listCompanies } from "../services/companies.js";
+import { listFeatures, updateFeatureAccess } from "../services/features.js";
 import { configStore } from "../stores/config.js";
 import {
   handleError,
@@ -19,9 +15,11 @@ import {
 import {
   appIdOption,
   companyFilterOption,
-  companyIdArgument,
+  companyIdsOption,
   disableFeatureOption,
   enableFeatureOption,
+  segmentIdsOption,
+  userIdsOption,
 } from "../utils/options.js";
 import { baseUrlSuffix } from "../utils/path.js";
 
@@ -69,36 +67,53 @@ export const listCompaniesAction = async (options: { filter?: string }) => {
   }
 };
 
-export const companyFeatureAccessAction = async (
-  companyId: string,
+export const featureAccessAction = async (
   featureKey: string | undefined,
-  options: { enable: boolean; disable: boolean },
+  options: {
+    enable: boolean;
+    disable: boolean;
+    companies?: string[];
+    segments?: string[];
+    users?: string[];
+  },
 ) => {
   const { baseUrl, appId } = configStore.getConfig();
   let spinner: Ora | undefined;
 
   if (!appId) {
-    return handleError(new MissingAppIdError(), "Company Feature Access");
+    return handleError(new MissingAppIdError(), "Feature Access");
   }
 
   const app = getApp(appId);
   const production = app.environments.find((e) => e.isProduction);
   if (!production) {
-    return handleError(new MissingEnvIdError(), "Company Feature Access");
+    return handleError(new MissingEnvIdError(), "Feature Access");
   }
 
   // Validate conflicting options
   if (options.enable && options.disable) {
     return handleError(
       "Cannot both enable and disable a feature.",
-      "Company Feature Access",
+      "Feature Access",
     );
   }
 
   if (!options.enable && !options.disable) {
     return handleError(
       "Must specify either --enable or --disable.",
-      "Company Feature Access",
+      "Feature Access",
+    );
+  }
+
+  // Validate at least one target is specified
+  if (
+    !options.companies?.length &&
+    !options.segments?.length &&
+    !options.users?.length
+  ) {
+    return handleError(
+      "Must specify at least one target using --companies, --segments, or --users.",
+      "Feature Access",
     );
   }
 
@@ -116,10 +131,7 @@ export const companyFeatureAccessAction = async (
       });
 
       if (featuresResponse.data.length === 0) {
-        return handleError(
-          "No features found for this app.",
-          "Company Feature Access",
-        );
+        return handleError("No features found for this app.", "Feature Access");
       }
 
       spinner.succeed(
@@ -135,33 +147,38 @@ export const companyFeatureAccessAction = async (
       });
     } catch (error) {
       spinner?.fail("Loading features failed.");
-      return handleError(error, "Company Feature Access");
+      return handleError(error, "Feature Access");
     }
   }
 
   // Determine if enabling or disabling
   const isEnabled = options.enable;
 
   try {
+    const targetTypes = [];
+    if (options.companies?.length) targetTypes.push("companies");
+    if (options.segments?.length) targetTypes.push("segments");
+    if (options.users?.length) targetTypes.push("users");
+
     spinner = ora(
-      `${isEnabled ? "Enabling" : "Disabling"} feature ${chalk.cyan(featureKey)} for company ${chalk.cyan(companyId)}...`,
+      `${isEnabled ? "Enabling" : "Disabling"} feature ${chalk.cyan(featureKey)} for ${targetTypes.join(", ")}...`,
     ).start();
 
-    const request: CompanyFeatureAccess = {
+    await updateFeatureAccess(appId, {
       envId: production.id,
-      companyId,
       featureKey,
       isEnabled,
-    };
-
-    await companyFeatureAccess(appId, request);
+      companyIds: options.companies,
+      segmentIds: options.segments,
+      userIds: options.users,
+    });
 
     spinner.succeed(
-      `${isEnabled ? "Enabled" : "Disabled"} feature ${chalk.cyan(featureKey)} for company ${chalk.cyan(companyId)}.`,
+      `${isEnabled ? "Enabled" : "Disabled"} feature ${chalk.cyan(featureKey)} for ${targetTypes.join(", ")}.`,
     );
   } catch (error) {
     spinner?.fail(`Feature access update failed.`);
-    void handleError(error, "Company Feature Access");
+    void handleError(error, "Feature Access");
   }
 };
 
@@ -170,8 +187,8 @@ export function registerCompanyCommands(cli: Command) {
     "Manage companies.",
   );
 
-  const companyFeaturesCommand = new Command("features").description(
-    "Manage company features.",
+  const featuresCommand = new Command("features").description(
+    "Manage feature access.",
   );
 
   companiesCommand
@@ -182,11 +199,12 @@ export function registerCompanyCommands(cli: Command) {
     .action(listCompaniesAction);
 
   // Feature access command
-  companyFeaturesCommand
+  featuresCommand
     .command("access")
-    .description("Grant or revoke feature access for a specific company.")
+    .description(
+      "Grant or revoke feature access for companies, segments, and users.",
+    )
     .addOption(appIdOption)
-    .addArgument(companyIdArgument)
     .addArgument(
       new Argument(
         "[featureKey]",
@@ -195,9 +213,12 @@ export function registerCompanyCommands(cli: Command) {
     )
     .addOption(enableFeatureOption)
     .addOption(disableFeatureOption)
-    .action(companyFeatureAccessAction);
+    .addOption(companyIdsOption)
+    .addOption(segmentIdsOption)
+    .addOption(userIdsOption)
+    .action(featureAccessAction);
 
-  companiesCommand.addCommand(companyFeaturesCommand);
+  companiesCommand.addCommand(featuresCommand);
 
   // Update the config with the cli override values
   companiesCommand.hook("preAction", (_, command) => {

packages/cli/index.ts

@@ -10,7 +10,7 @@ import { registerFeatureCommands } from "./commands/features.js";
 import { registerInitCommand } from "./commands/init.js";
 import { registerMcpCommand } from "./commands/mcp.js";
 import { registerNewCommand } from "./commands/new.js";
-import { bootstrap, getUser } from "./services/bootstrap.js";
+import { bootstrap, getBucketUser } from "./services/bootstrap.js";
 import { authStore } from "./stores/auth.js";
 import { configStore } from "./stores/config.js";
 import { handleError } from "./utils/errors.js";
@@ -60,7 +60,7 @@ async function main() {
 
     if (debug) {
       console.debug(chalk.cyan("\nDebug mode enabled."));
-      const user = getUser();
+      const user = getBucketUser();
       console.debug(`Logged in as ${chalk.cyan(user.name ?? user.email)}.`);
       console.debug(
         "Reading config from:",

packages/cli/mcp/responses.ts

@@ -1,3 +1,4 @@
+import { FlagVersion } from "../services/features.js";
 import { JSONPrimitive } from "../utils/json.js";
 
 export function textResponse(message: string, data?: JSONPrimitive) {
@@ -70,6 +71,10 @@ export function companiesResponse(data: JSONPrimitive) {
   return textResponse("List of companies.", data);
 }
 
+export function usersResponse(data: JSONPrimitive) {
+  return textResponse("List of users.", data);
+}
+
 export function companyFeatureAccessResponse(
   isEnabled: boolean,
   featureKey: string,
@@ -83,3 +88,7 @@ export function companyFeatureAccessResponse(
 export function updateFeatureStageResponse(featureKey: string) {
   return textResponse(`Updated flag targeting for feature '${featureKey}'.`);
 }
+
+export function updateFeatureAccessResponse(flagVersions: FlagVersion[]) {
+  return textResponse(flagVersions.map((v) => v.changeDescription).join("\n"));
+}

packages/cli/mcp/tools.ts

@@ -1,24 +1,23 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import ora from "ora";
 import { z } from "zod";
 
-import { getApp, getOrg } from "../services/bootstrap.js";
-import {
-  CompaniesQuerySchema,
-  companyFeatureAccess,
-  CompanyFeatureAccessSchema,
-  listCompanies,
-} from "../services/companies.js";
+import { getApp, getOrg, listSegments } from "../services/bootstrap.js";
+import { CompaniesQuerySchema, listCompanies } from "../services/companies.js";
 import {
   createFeature,
+  FeatureAccessSchema,
   FeatureCreateSchema,
   listFeatureNames,
+  updateFeatureAccess,
 } from "../services/features.js";
 import { FeedbackQuerySchema, listFeedback } from "../services/feedback.js";
 import {
   listStages,
   updateFeatureStage,
   UpdateFeatureStageSchema,
 } from "../services/stages.js";
+import { listUsers, UsersQuerySchema } from "../services/users.js";
 import { configStore } from "../stores/config.js";
 import {
   handleMcpError,
@@ -31,11 +30,12 @@ import { withDefaults, withDescriptions } from "../utils/schemas.js";
 
 import {
   companiesResponse,
-  companyFeatureAccessResponse,
   featureCreateResponse,
   featuresResponse,
   feedbackResponse,
+  updateFeatureAccessResponse,
   updateFeatureStageResponse,
+  usersResponse,
 } from "./responses.js";
 
 export async function registerMcpTools(
@@ -50,12 +50,16 @@ export async function registerMcpTools(
   }
   const org = getOrg();
   const app = getApp(appId);
+  const segments = listSegments(appId);
   const production = app.environments.find((e) => e.isProduction);
   if (!production) {
     throw new MissingEnvIdError();
   }
 
+  // Extend bootstrap spinner for loading stages
+  const spinner = ora("Bootstrapping...").start();
   const stages = await listStages(appId);
+  spinner.stop();
 
   // Add features tool
   mcp.tool(
@@ -128,27 +132,61 @@ export async function registerMcpTools(
     },
   );
 
-  // Add company feature access tool
+  // Add users tool
   mcp.tool(
-    "companyFeatureAccess",
-    "Grant or revoke feature access for a specific company of the Bucket feature management service.",
-    withDefaults(CompanyFeatureAccessSchema, {
+    "users",
+    "List of users of the Bucket feature management service.",
+    withDefaults(UsersQuerySchema, {
       envId: production.id,
     }).shape,
     async (args) => {
       try {
-        await companyFeatureAccess(appId, args);
-        return companyFeatureAccessResponse(
-          args.isEnabled,
-          args.featureKey,
-          args.companyId,
-        );
+        const data = await listUsers(appId, args);
+        return usersResponse(data);
+      } catch (error) {
+        return await handleMcpError(error);
+      }
+    },
+  );
+
+  // Add company feature access tool
+  const segmentNames = segments.map((s) => s.name);
+  mcp.tool(
+    "featureAccess",
+    "Grant or revoke feature access to a specific user, company, or segment of the Bucket feature management service.",
+    withDefaults(
+      FeatureAccessSchema.omit({ segmentIds: true }).extend({
+        segmentNames: z
+          .array(z.enum(segmentNames as [string, ...string[]]))
+          .optional()
+          .describe(
+            `Segment names to target. Must be one of the following: ${segmentNames.join(", ")}`,
+          ),
+      }),
+      {
+        envId: production.id,
+      },
+    ).shape,
+    async (args) => {
+      try {
+        const { segmentNames: selectedSegmentNames, ...rest } = args;
+        const segmentIds =
+          selectedSegmentNames
+            ?.map((name) => segments.find((s) => s.name === name)?.id)
+            .filter((id) => id !== undefined) ?? [];
+        const { flagVersions } = await updateFeatureAccess(appId, {
+          ...rest,
+          segmentIds,
+        });
+        return updateFeatureAccessResponse(flagVersions);
       } catch (error) {
         return await handleMcpError(error);
       }
     },
   );
 
+  // Add update feature stage tool
+  const stageNames = stages.map((s) => s.name);
   mcp.tool(
     "updateFeatureStage",
     "Update the stage of a feature of the Bucket feature management service.",
@@ -157,9 +195,9 @@ export async function registerMcpTools(
         stageId: true,
       }).extend({
         stageName: z
-          .enum(stages.map((s) => s.name) as [string, ...string[]])
+          .enum(stageNames as [string, ...string[]])
           .describe(
-            `The name of the stage. Must be one of the following: ${stages.map((s) => s.name).join(", ")}`,
+            `The name of the stage. Must be one of the following: ${stageNames.join(", ")}`,
           ),
       }),
       {