Skip to main content
Agent and MCP tool setup Level: Intermediate 13 min read

Connecting Cursor to App Store Connect via FlightDeck MCP: Complete Setup

A complete step-by-step setup guide to connecting Cursor to Apple's App Store Connect API using FlightDeck's embedded MCP server. Covers configuration, tool discovery, read-only testing, and human-in-the-loop approval.

Published: 2026-10-31 • Last Updated: 2026-10-31 • Author: Kip Lawrence
Key MCP Tools: apps_listbuilds_listrelease_readiness_check

Overview: Empowering Cursor with App Store Connect

You can connect Cursor directly to Apple's App Store Connect API by configuring Cursor to communicate with FlightDeck's local Model Context Protocol (MCP) server. Once connected, Cursor's AI coding assistant (in Composer or Chat) can query your registered applications, inspect build processing states, audit pre-flight release readiness, manage TestFlight beta groups, and stage storefront metadata updates—all without leaving your code editor or sharing private credentials across external servers.

Cursor connects to external tools using the open Model Context Protocol specification over standard HTTP or command transports. FlightDeck runs an embedded MCP server strictly on your Mac's local loopback (http://127.0.0.1:51122/mcp). It authenticates directly with Apple using App Store Connect API keys stored securely in your macOS Keychain.

Important

Local Governance & Credential Isolation:

  • Zero Cloud Relays: Your App Store Connect API Key (.p8 private key, Key ID, and Issuer ID) resides exclusively in your encrypted macOS Keychain. Neither Cursor nor any third-party cloud service ever receives your raw private key.
  • Local Loopback Only: FlightDeck's MCP server listens strictly on localhost (127.0.0.1). It is never exposed over public networks.
  • Human Approval by Default: All state-changing mutations (such as binary uploads, TestFlight group modifications, and storefront metadata updates) are intercepted by FlightDeck's native Approval Center. Cursor cannot modify your live Apple account without your explicit confirmation in FlightDeck.

Architecture: How Cursor Interacts with FlightDeck

The integration between Cursor, FlightDeck, and Apple follows a secure four-tier architecture:

TEXT
┌─────────────────────────────────────────────────────────────┐
│                      Cursor IDE (Mac)                       │
│  [Composer / Agent Chat] ──> MCP Client Engine             │
└──────────────────────────────┬──────────────────────────────┘
                               │ JSON-RPC 2.0 over Streamable HTTP
                               │ http://127.0.0.1:51122/mcp
┌──────────────────────────────▼──────────────────────────────┐
│                  FlightDeck Desktop (macOS)                 │
│  ├── Local MCP Server (Streamable HTTP Transport)           │
│  ├── macOS Keychain Credential Vault (ASC .p8 Key)          │
│  ├── Approval Center (Staged Human-in-the-Loop Review)      │
│  └── Semantic Domain Engine (80+ App Store Connect Tools)   │
└──────────────────────────────┬──────────────────────────────┘
                               │ Authenticated REST API (HTTPS)
                               │ api.appstoreconnect.apple.com
┌──────────────────────────────▼──────────────────────────────┐
│                  Apple App Store Connect                    │
│  [Apps, Builds, TestFlight, Metadata, Pricing, Review]      │
└─────────────────────────────────────────────────────────────┘

Prerequisites

Before starting configuration, verify you have the following ready:

  1. Mac Running macOS Sonoma (14.0+) or macOS Sequoia (15.0+): Required for modern sandboxing and Keychain integration.
  2. Cursor IDE Installed: Downloaded from cursor.com.
  3. FlightDeck Developer Console: Installed from the Mac App Store.
  4. App Store Connect API Key: Created in the Apple Developer Portal with the Admin or App Manager role. You will need: - Key ID: A 10-character alphanumeric string (e.g., 2X9R4HXF34). - Issuer ID: A UUID string from the Users and Access portal (e.g., 57246542-96fe-1a63-e053-0824d011072a). - Private Key File: A .p8 file downloaded from Apple (downloadable only once).

Step 1: Configure App Store Connect Credentials in FlightDeck

First, connect your Apple API key to FlightDeck:

  1. Launch FlightDeck on your Mac.
  2. If this is your first launch, the Setup Wizard will guide you through adding your profile. Alternatively, navigate to Settings > Apple API Profiles.
  3. Click Add API Profile.
  4. Enter your Key ID, paste your Issuer ID, and select your downloaded AuthKey_<KeyID>.p8 file.
  5. Click Verify and Save. FlightDeck generates a transient cryptographic JWT locally, sends a test ping to Apple, and confirms your credentials are valid.
  6. The private key is securely stored in your macOS Keychain.

Step 2: Enable the FlightDeck MCP Server

Next, ensure FlightDeck's embedded MCP server is running:

  1. In FlightDeck, click MCP Server in the sidebar.
  2. Verify that the Server Status toggle is set to Running.
  3. Note the displayed runtime endpoint: ``text http://127.0.0.1:51122/mcp ``
  4. By default, FlightDeck listens on port 51122 using Streamable HTTP. If another process occupies port 51122, click Change Port to select an alternate port.
  5. Authentication Setting: By default, local loopback requests do not require an authorization header. If you toggle on Require HTTP Bearer Token, FlightDeck generates a secure token that you must include in your client configuration.

Step 3: Configure Cursor to Connect to FlightDeck

You can configure Cursor using either the automated in-app setup prompt, direct JSON editing, or Cursor's visual settings UI.

FlightDeck provides a dynamically generated setup prompt designed specifically for AI coding assistants:

  1. In FlightDeck's MCP Server screen, click the Copy Setup Prompt button.
  2. Switch to Cursor and open Composer (Cmd + I) or the Chat panel (Cmd + L).
  3. Paste the prompt directly into Cursor and press Enter.

Cursor's agent reads the runtime connection details, inspects your existing ~/.cursor/mcp.json file, and safely injects the flightdeck server block without overwriting your other MCP tools.

Warning

Credential Sensitivity with Bearer Auth: If you enabled Require HTTP Bearer Token in FlightDeck, the generated setup prompt will embed your active Bearer token so Cursor can configure the Authorization header automatically. Treat this prompt as sensitive credential material: do not paste it into shared chat channels, publish it in screenshots, or commit token-bearing configuration files to public repositories.

Option B: Manual Configuration via mcp.json

If you prefer to configure Cursor manually, edit Cursor's MCP configuration file directly:

  1. Determine whether you want global or project-specific access: - Global Configuration (All Projects): ~/.cursor/mcp.json - Project-Specific Configuration: .cursor/mcp.json in your project's root folder.
  2. Open or create the file in your editor: ``bash # Open global Cursor MCP configuration in Cursor cursor ~/.cursor/mcp.json ``
  3. Add the flightdeck server definition under the mcpServers object:
JSON
{
  "mcpServers": {
    "flightdeck": {
      "url": "http://127.0.0.1:51122/mcp"
    }
  }
}

If you enabled HTTP Bearer Token Authentication in FlightDeck, include the Authorization header:

JSON
{
  "mcpServers": {
    "flightdeck": {
      "url": "http://127.0.0.1:51122/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_FLIGHTDECK_TOKEN"
      }
    }
  }
}

Save the file.

Tip

Source Control Hygiene: If you configure Bearer token authentication in a project-specific .cursor/mcp.json, ensure .cursor/ is included in your project's .gitignore file to avoid committing credentials to public repositories. Alternatively, prefer the global user configuration at ~/.cursor/mcp.json.

Option C: Visual Setup in Cursor Settings

You can also configure the server through Cursor's graphical settings:

  1. In Cursor, open Settings (Cmd + , or press Cmd + Shift + P and type Cursor Settings).
  2. Navigate to Features > MCP Servers (or Tools > MCP depending on your Cursor version).
  3. Click Add New MCP Server.
  4. Configure the fields: - Name: flightdeck - Type: http - Server URL: http://127.0.0.1:51122/mcp
  5. Click Add.

Step 4: Verify Tool Discovery in Cursor

To verify that Cursor has successfully connected to FlightDeck and indexed its capabilities:

  1. In Cursor, open Settings > Features > MCP Servers.
  2. Look for the flightdeck entry. The status indicator should turn green.
  3. Click on flightdeck to expand the discovered tools list. You should see over 80 semantic App Store Connect tools indexed, including app inspection, build status, TestFlight groups, and localized metadata.
  4. If the indicator does not turn green immediately, reload Cursor's window: - Press Cmd + Shift + P. - Type Developer: Reload Window and press Enter.

Step 5: Test a Safe Read-Only Request

Always verify your connection with a safe, read-only operation before performing any actions that affect remote data:

  1. Open Cursor Composer (Cmd + I) or Chat (Cmd + L).
  2. Ensure Agent Mode is selected.
  3. Submit this verification prompt:
MARKDOWN
Use FlightDeck to show me the apps in my App Store Connect account. Tell me whether the connection is working, and do not make changes.
  1. Expected Result: Cursor invokes apps_list via the local MCP server. FlightDeck executes the query against Apple and returns your application catalog. Because apps_list is read-only, it executes immediately without requiring human confirmation in FlightDeck:
TEXT
Connected to FlightDeck MCP successfully.
Found 1 application registered in App Store Connect:
- FlightDeck Developer Console (com.vibe.flightdeck) — Primary Locale: en-US

The connection is authenticated and operational.

Step 6: Understanding Human Approval for Mutations

FlightDeck enforces strict safety governance for all write operations through its native Approval Center.

When you ask Cursor to perform a state-changing operation (such as modifying storefront metadata, uploading a binary, or attaching a build to TestFlight):

  1. Cursor dispatches the operation to FlightDeck.
  2. FlightDeck halts execution and constructs a staged proposal containing: - The target application. - The exact attribute diff (before and after values). - Character count validations. - The agent's justification explanation (why).
  3. Cursor informs you: > "I have staged a proposal in FlightDeck to update the What's New release notes for version 1.1.0. Please review and approve the proposal in FlightDeck."
  4. Open the FlightDeck desktop app. The proposal is displayed prominently in the Approval Center.
  5. Inspect the diff and click Approve (or Reject).
  6. FlightDeck executes the mutation with Apple's REST API and returns the updated state to Cursor.

This human-in-the-loop mechanism ensures that an autonomous coding assistant cannot accidentally overwrite production storefront data, publish unreviewed release notes, or alter pricing without your explicit oversight.


Practical Cursor AI Agent Prompts

Here are four high-value, outcome-focused prompts to use in Cursor once FlightDeck is connected:

1. Pre-Flight Release Readiness Audit

MARKDOWN
Using FlightDeck, check the release readiness of our app for the upcoming version. Tell me if all required metadata, localized descriptions, support URLs, and screenshots are complete.

2. TestFlight Processing State Check

MARKDOWN
Using FlightDeck, check the latest builds uploaded to TestFlight for our app. Report which build numbers are valid and whether any builds are still processing.

3. Storefront Metadata Inspection

MARKDOWN
Using FlightDeck, inspect our app's current draft version metadata for the en-US locale. Check whether the title, subtitle, and keywords fit within Apple's character limits.

4. Drafting and Staging a Release Notes Update

MARKDOWN
Draft updated What's New release notes for version 1.1.0 highlighting our new iPad multitasking support and performance improvements. Show me the draft, and once I confirm, stage the update in FlightDeck for my approval.

Troubleshooting Cursor MCP Connections

1. Status Indicator Shows Red ("Connection Refused" / ECONNREFUSED)

  • Root Cause: FlightDeck is either not running or the MCP server is toggled off.
  • Fix: Launch FlightDeck, navigate to the MCP Server tab, and verify the status toggle is set to Running. Verify the port in ~/.cursor/mcp.json matches FlightDeck's displayed port (51122).

2. Port Conflict (EADDRINUSE)

  • Root Cause: Another application on your Mac is using port 51122.
  • Fix: In FlightDeck, click Change Port on the MCP Server screen, enter an unused port, and update the URL in ~/.cursor/mcp.json to match the new port.

3. Cursor Fails to Discover Tools

  • Root Cause: Cursor's background MCP client cached an older connection state.
  • Fix: In Cursor, press Cmd + Shift + P, select Developer: Reload Window, and check Settings > Features > MCP Servers again.

4. HTTP 401 Unauthorized Error

  • Root Cause: FlightDeck has Require HTTP Bearer Token enabled, but Cursor is sending unauthenticated requests.
  • Fix: In FlightDeck's MCP Server screen, click Copy Token and add the "headers": { "Authorization": "Bearer <TOKEN>" } block to your ~/.cursor/mcp.json.

Connect Your AI Agent to App Store Connect

FlightDeck runs locally on your Mac, keeping private keys secure in your macOS Keychain and executing mutations only after your explicit approval.

Download FlightDeck on Mac App Store