MCP Server for iOS Simulator

Implementation Reference

• src/mcp/mcp-server.ts:217-254 (registration)

  MCP tool registration for 'terminate-simulator-session', including input schema and handler function that delegates to simulatorManager.terminateSession

  this.server.tool(
    'terminate-simulator-session',
    {
      sessionId: z.string()
    },
    async ({ sessionId }) => {
      fileLogger.info(`Terminating simulator session: ${sessionId}`);
      try {
        const success = await simulatorManager.terminateSession(sessionId);
        
        if (!success) {
          return {
            content: [{
              type: 'text',
              text: `Failed to terminate session: ${sessionId}`
            }],
            isError: true
          };
        }
        
        return {
          content: [{
            type: 'text',
            text: `Session terminated: ${sessionId}`
          }]
        };
      } catch (error) {
        fileLogger.error(`Failed to terminate simulator session: ${sessionId}`, { error });
        return {
          content: [{
            type: 'text',
            text: `Error: ${error instanceof Error ? error.message : String(error)}`
          }],
          isError: true
        };
      }
    }
  );

• src/mcp/mcp-server.ts:222-252 (handler)

  Handler function for the MCP tool that logs, calls simulatorManager.terminateSession, and returns success/error response

  async ({ sessionId }) => {
    fileLogger.info(`Terminating simulator session: ${sessionId}`);
    try {
      const success = await simulatorManager.terminateSession(sessionId);
      
      if (!success) {
        return {
          content: [{
            type: 'text',
            text: `Failed to terminate session: ${sessionId}`
          }],
          isError: true
        };
      }
      
      return {
        content: [{
          type: 'text',
          text: `Session terminated: ${sessionId}`
        }]
      };
    } catch (error) {
      fileLogger.error(`Failed to terminate simulator session: ${sessionId}`, { error });
      return {
        content: [{
          type: 'text',
          text: `Error: ${error instanceof Error ? error.message : String(error)}`
        }],
        isError: true
      };
    }

• src/mcp/mcp-server.ts:220-220 (schema)

  Zod input schema requiring sessionId string

  sessionId: z.string()

• src/simulator/simulator-manager.ts:302-339 (helper)

  Core implementation that checks if simulator is running, shuts it down if needed via shutdownSimulator, removes session from map, and returns success/failure

  async terminateSession(sessionId: string): Promise<boolean> {
    const session = this.sessions.get(sessionId);
    if (!session) {
      fileLogger.warn(`Session not found: ${sessionId}`);
      return false;
    }
  
    try {
      // Try to get the simulator status
      let isRunning = false;
      try {
        const status = await session.simulator.stat();
        isRunning = status.state === 'Booted';
      } catch (statError) {
        // If we can't get status, check the booted simulators list
        fileLogger.warn(`Failed to get simulator status, checking booted simulators`, { statError });
        const bootedSimulators = await this.getBootedSimulators();
        isRunning = bootedSimulators.some(sim => sim.udid === session.udid);
      }
      
      // Shutdown the simulator if running
      if (isRunning) {
        fileLogger.info(`Shutting down simulator for session: ${sessionId}`);
        await this.shutdownSimulator(sessionId);
      } else {
        fileLogger.info(`Simulator already shut down for session: ${sessionId}`);
      }
      
      // Remove from sessions map
      this.sessions.delete(sessionId);
      
      fileLogger.info(`Session terminated: ${sessionId}`);
      return true;
    } catch (error) {
      fileLogger.error(`Failed to terminate session: ${sessionId}`, { error });
      return false;
    }
  }