set_simulator_location

Instructions

Implementation Reference

• src/mcp/tools/simulator-management/set_sim_location.ts:73-116 (handler)

  Main handler logic: validates latitude/longitude ranges and executes the xcrun simctl location set command for the given simulator.

  export async function set_sim_locationLogic(
    params: SetSimulatorLocationParams,
    executor: CommandExecutor,
  ): Promise<ToolResponse> {
    const extraValidation = (): ToolResponse | null => {
      if (params.latitude < -90 || params.latitude > 90) {
        return {
          content: [
            {
              type: 'text',
              text: 'Latitude must be between -90 and 90 degrees',
            },
          ],
        };
      }
      if (params.longitude < -180 || params.longitude > 180) {
        return {
          content: [
            {
              type: 'text',
              text: 'Longitude must be between -180 and 180 degrees',
            },
          ],
        };
      }
      return null;
    };
  
    log(
      'info',
      `Setting simulator ${params.simulatorId} location to ${params.latitude},${params.longitude}`,
    );
  
    return executeSimctlCommandAndRespond(
      params,
      ['location', params.simulatorId, 'set', `${params.latitude},${params.longitude}`],
      'Set Simulator Location',
      `Successfully set simulator ${params.simulatorId} location to ${params.latitude},${params.longitude}`,
      'Failed to set simulator location',
      'set simulator location',
      executor,
      extraValidation,
    );
  }

• src/mcp/tools/simulator-management/set_sim_location.ts:8-15 (schema)

  Zod schema for input parameters: simulatorId (UUID), latitude, longitude with descriptions.

  const setSimulatorLocationSchema = z.object({
    simulatorId: z
      .string()
      .uuid()
      .describe('UUID of the simulator to use (obtained from list_simulators)'),
    latitude: z.number().describe('The latitude for the custom location.'),
    longitude: z.number().describe('The longitude for the custom location.'),
  });

• src/mcp/tools/simulator-management/set_sim_location.ts:120-130 (registration)

  Tool registration exporting the tool definition with name, description, schema, and wrapped handler using createSessionAwareTool.

  export default {
    name: 'set_sim_location',
    description: 'Sets a custom GPS location for the simulator.',
    schema: publicSchemaObject.shape, // MCP SDK compatibility
    handler: createSessionAwareTool<SetSimulatorLocationParams>({
      internalSchema: setSimulatorLocationSchema as unknown as z.ZodType<SetSimulatorLocationParams>,
      logicFunction: set_sim_locationLogic,
      getExecutor: getDefaultCommandExecutor,
      requirements: [{ allOf: ['simulatorId'], message: 'simulatorId is required' }],
    }),
  };

• src/mcp/tools/simulator-management/set_sim_location.ts:21-71 (helper)

  Helper function to execute simctl commands via xcrun, with logging, error handling, and optional extra validation.

  async function executeSimctlCommandAndRespond(
    params: SetSimulatorLocationParams,
    simctlSubCommand: string[],
    operationDescriptionForXcodeCommand: string,
    successMessage: string,
    failureMessagePrefix: string,
    operationLogContext: string,
    executor: CommandExecutor = getDefaultCommandExecutor(),
    extraValidation?: () => ToolResponse | null,
  ): Promise<ToolResponse> {
    if (extraValidation) {
      const validationResult = extraValidation();
      if (validationResult) {
        return validationResult;
      }
    }
  
    try {
      const command = ['xcrun', 'simctl', ...simctlSubCommand];
      const result = await executor(command, operationDescriptionForXcodeCommand, true, {});
  
      if (!result.success) {
        const fullFailureMessage = `${failureMessagePrefix}: ${result.error}`;
        log(
          'error',
          `${fullFailureMessage} (operation: ${operationLogContext}, simulator: ${params.simulatorId})`,
        );
        return {
          content: [{ type: 'text', text: fullFailureMessage }],
        };
      }
  
      log(
        'info',
        `${successMessage} (operation: ${operationLogContext}, simulator: ${params.simulatorId})`,
      );
      return {
        content: [{ type: 'text', text: successMessage }],
      };
    } catch (error) {
      const errorMessage = error instanceof Error ? error.message : String(error);
      const fullFailureMessage = `${failureMessagePrefix}: ${errorMessage}`;
      log(
        'error',
        `Error during ${operationLogContext} for simulator ${params.simulatorId}: ${errorMessage}`,
      );
      return {
        content: [{ type: 'text', text: fullFailureMessage }],
      };
    }
  }