lokalise_remove_members_from_group

Instructions

Implementation Reference

• src/domains/usergroups/usergroups.tool.ts:360-365 (registration)

  Registration of the 'lokalise_remove_members_from_group' tool with server.tool(), binding RemoveMembersToolArgs.shape schema and handleRemoveMembers handler.

  server.tool(
  	"lokalise_remove_members_from_group",
  	"Removes users from a user group, revoking group-based permissions and project access. Required: teamId, groupId, userIds array. Use for role changes, offboarding, or permission cleanup. Returns: Operation confirmation. Warning: Immediate effect - users lose group permissions and project access.",
  	RemoveMembersToolArgs.shape,
  	handleRemoveMembers,
  );

• src/domains/usergroups/usergroups.tool.ts:221-247 (handler)

  Handler function 'handleRemoveMembers' that calls usergroupsController.removeMembers() and returns the result in MCP content format.

  async function handleRemoveMembers(args: RemoveMembersToolArgsType) {
  	const methodLogger = Logger.forContext(
  		"usergroups.tool.ts",
  		"handleRemoveMembers",
  	);
  	methodLogger.debug("Removing members from user group...", args);
  
  	try {
  		const result = await usergroupsController.removeMembers(args);
  		methodLogger.debug("Got the response from the controller", result);
  
  		return {
  			content: [
  				{
  					type: "text" as const,
  					text: result.content,
  				},
  			],
  		};
  	} catch (error) {
  		methodLogger.error("Tool failed", {
  			error: (error as Error).message,
  			args,
  		});
  		return formatErrorForMcpTool(error);
  	}
  }

• src/domains/usergroups/usergroups.types.ts:190-204 (schema)

  Zod schema 'RemoveMembersToolArgs' defining the tool's input arguments: teamId (string), groupId (string|number), userIds (array of string|number, min 1). Also the inferred type.

  /**
   * Zod schema for remove members from group tool arguments.
   */
  export const RemoveMembersToolArgs = z
  	.object({
  		teamId: z.string().describe("Team ID containing the user group"),
  		groupId: z.union([z.string(), z.number()]).describe("User group ID"),
  		userIds: z
  			.array(z.union([z.string(), z.number()]))
  			.min(1)
  			.describe("User IDs to remove from the group"),
  	})
  	.strict();
  
  export type RemoveMembersToolArgsType = z.infer<typeof RemoveMembersToolArgs>;

• src/domains/usergroups/usergroups.controller.ts:339-394 (helper)

  Controller function 'removeMembers' that validates inputs, calls service layer, and formats response via formatRemoveMembersResult formatter.

  /**
   * Remove members from a user group
   */
  async function removeMembers(
  	args: RemoveMembersToolArgsType,
  ): Promise<ControllerResponse> {
  	const methodLogger = Logger.forContext(
  		"usergroups.controller.ts",
  		"removeMembers",
  	);
  	methodLogger.debug("Removing members from user group...", args);
  
  	try {
  		// Validate inputs
  		if (!args.teamId) {
  			throw new McpError("Team ID is required.", ErrorType.API_ERROR);
  		}
  
  		if (!args.groupId) {
  			throw new McpError("Group ID is required.", ErrorType.API_ERROR);
  		}
  
  		if (!args.userIds || args.userIds.length === 0) {
  			throw new McpError(
  				"At least one user ID is required.",
  				ErrorType.API_ERROR,
  			);
  		}
  
  		// Call service layer
  		const result = await usergroupsService.removeMembers(args);
  
  		// Format response
  		const formattedContent = formatRemoveMembersResult(
  			result,
  			args.userIds.length,
  		);
  
  		methodLogger.debug("Members removed successfully", {
  			teamId: args.teamId,
  			groupId: args.groupId,
  			userCount: args.userIds.length,
  		});
  
  		return {
  			content: formattedContent,
  		};
  	} catch (error: unknown) {
  		throw handleControllerError(error, {
  			source: "UsergroupsController.removeMembers",
  			entityType: "UserGroup",
  			entityId: String(args.groupId),
  			operation: "removing members",
  		});
  	}
  }

• src/domains/usergroups/usergroups.service.ts:309-344 (helper)

  Service function 'removeMembers' that calls the Lokalise API userGroups().remove_members_from_group() to actually perform the removal.

  async removeMembers(args: RemoveMembersToolArgsType): Promise<UserGroup> {
  	const methodLogger = logger.forMethod("removeMembers");
  	methodLogger.info("Removing members from user group", {
  		teamId: args.teamId,
  		groupId: args.groupId,
  		userCount: args.userIds.length,
  	});
  
  	try {
  		const api = getLokaliseApi();
  		// Convert user IDs to proper array type for SDK
  		const userIds = args.userIds.map((id) =>
  			typeof id === "string" ? id : id.toString(),
  		);
  		const result = await api
  			.userGroups()
  			.remove_members_from_group(args.teamId, args.groupId, userIds);
  
  		methodLogger.info("Removed members from user group successfully", {
  			teamId: args.teamId,
  			groupId: args.groupId,
  			removedCount: args.userIds.length,
  		});
  
  		return result;
  	} catch (error) {
  		methodLogger.error("Failed to remove members from user group", {
  			error,
  			args,
  		});
  		throw createUnexpectedError(
  			`Failed to remove members from user group ${args.groupId}`,
  			error,
  		);
  	}
  },