lokalise_list_team_users

Instructions

Implementation Reference

• src/domains/teamusers/teamusers.tool.ts:181-186 (registration)

  Registration of the 'lokalise_list_team_users' tool with the MCP server, binding the tool name to the ListTeamusersToolArgs schema and the handleListTeamusers handler function.

  server.tool(
  	"lokalise_list_team_users",
  	"Lists all users in a Lokalise team with pagination support. Required: teamId. Optional: limit (100), page. Use to audit team composition, check access levels, or prepare team changes. Returns: Users with roles, permissions, and activity status.",
  	ListTeamusersToolArgs.shape,
  	handleListTeamusers,
  );

• src/domains/teamusers/teamusers.tool.ts:31-60 (handler)

  Handler function that calls teamusersController.listTeamusers() and formats the response for the MCP tool output.

  async function handleListTeamusers(args: ListTeamusersToolArgsType) {
  	const methodLogger = Logger.forContext(
  		"teamusers.tool.ts",
  		"handleListTeamusers",
  	);
  	methodLogger.debug(
  		`Getting Lokalise teamusers list (limit: ${args.limit || "default"}, page: ${args.page || "1"})...`,
  		args,
  	);
  
  	try {
  		const result = await teamusersController.listTeamusers(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/teamusers/teamusers.types.ts:20-39 (schema)

  Zod schema for the list team users tool arguments: teamId (required string), limit (optional 1-100), page (optional positive integer).

  export const ListTeamusersToolArgs = z
  	.object({
  		teamId: z.string().describe("Team ID to list users for"),
  		limit: z
  			.number()
  			.int()
  			.min(1)
  			.max(100)
  			.optional()
  			.describe("Number of users to return (1-100, default: 100)"),
  		page: z
  			.number()
  			.int()
  			.positive()
  			.optional()
  			.describe("Page number for pagination (default: 1)"),
  	})
  	.strict();
  
  export type ListTeamusersToolArgsType = z.infer<typeof ListTeamusersToolArgs>;

• src/domains/teamusers/teamusers.controller.ts:26-81 (helper)

  Controller layer for listTeamusers that validates inputs (teamId, limit, page) and delegates to teamusersService.list() then formats via formatTeamusersList().

  async function listTeamusers(
  	args: ListTeamusersToolArgsType,
  ): Promise<ControllerResponse> {
  	const methodLogger = Logger.forContext(
  		"teamusers.controller.ts",
  		"listTeamusers",
  	);
  	methodLogger.debug("Getting Lokalise team users list...", args);
  
  	try {
  		// Validate team ID
  		if (!args.teamId || typeof args.teamId !== "string") {
  			throw new McpError(
  				"Team ID is required and must be a string.",
  				ErrorType.API_ERROR,
  			);
  		}
  
  		// Validate pagination parameters
  		if (args.limit !== undefined && (args.limit < 1 || args.limit > 100)) {
  			throw new McpError(
  				"Invalid limit parameter. Must be between 1 and 100.",
  				ErrorType.API_ERROR,
  			);
  		}
  
  		if (args.page !== undefined && args.page < 1) {
  			throw new McpError(
  				"Invalid page parameter. Must be 1 or greater.",
  				ErrorType.API_ERROR,
  			);
  		}
  
  		// Call service layer
  		const result = await teamusersService.list(args);
  
  		// Format response using the formatter
  		const formattedContent = formatTeamusersList(result, args.teamId);
  
  		methodLogger.debug("Team users list fetched successfully", {
  			teamId: args.teamId,
  			userCount: result.items?.length || 0,
  		});
  
  		return {
  			content: formattedContent,
  		};
  	} catch (error: unknown) {
  		throw handleControllerError(error, {
  			source: "TeamusersController.listTeamusers",
  			entityType: "TeamUsers",
  			entityId: args.teamId,
  			operation: "listing",
  		});
  	}
  }

• src/domains/teamusers/teamusers.service.ts:37-69 (helper)

  Service layer that calls the Lokalise API teamUsers().list() with team_id, page, and limit parameters to fetch the list of team users.

  async list(
  	args: ListTeamusersToolArgsType,
  ): Promise<PaginatedResult<TeamUser>> {
  	const methodLogger = logger.forMethod("list");
  	methodLogger.info("Listing team users", {
  		teamId: args.teamId,
  		page: args.page,
  		limit: args.limit,
  	});
  
  	try {
  		const api = getLokaliseApi();
  		const result = await api.teamUsers().list({
  			team_id: args.teamId,
  			page: args.page,
  			limit: args.limit,
  		});
  
  		methodLogger.info("Listed team users successfully", {
  			teamId: args.teamId,
  			count: result.items.length,
  			totalResults: result.totalResults,
  		});
  
  		return result;
  	} catch (error) {
  		methodLogger.error("Failed to list team users", { error, args });
  		throw createUnexpectedError(
  			`Failed to list team users for team ${args.teamId}`,
  			error,
  		);
  	}
  },