Skip to main content
Building, signing, and binary uploads Level: Intermediate 11 min read

Pre-Upload Binary Inspection: How FlightDeck Validates .ipa Files

Understand the local pre-upload checks FlightDeck performs on iOS .ipa packages to prevent failed uploads, Transporter errors, and processing rejections.

Published: 2026-10-31 • Last Updated: 2026-11-01 • Author: Kip Lawrence
Key MCP Tools: build_upload_preview

Few experiences in mobile release engineering are as frustrating as waiting 20 minutes for a 200 MB iOS application archive (.ipa) to upload to App Store Connect, only to encounter an immediate rejection error from Apple's Transporter service or receive an automated email minutes later informing you that your build is INVALID.

Many common issues—such as an unincremented build number, a mismatched bundle identifier, a malformed property list, or packaging an unarchived folder—can be caught on your local machine before a single byte leaves your computer.

FlightDeck includes an offline package inspection engine (build_upload_preview) designed to inspect and validate compiled .ipa packages before initiating an upload. Through conversational prompts with your AI coding assistant, FlightDeck audits archive structure and metadata in seconds, preventing unnecessary network transfers.

This guide explores the anatomy of an .ipa package, breaks down exactly what FlightDeck validates locally, explains which checks must be performed using macOS command-line tools or Apple's ingestion servers, and shows how to run pre-upload checks with your AI assistant.


The Anatomy of an iOS Application Archive (.ipa)

An .ipa file is not a proprietary opaque binary format. It is a standard ZIP archive structured according to Apple's bundle specifications:

TEXT
MyApp.ipa (ZIP Container)
└── Payload/
    └── MyApp.app/
        ├── MyApp                          (Mach-O compiled binary executable)
        ├── Info.plist                     (Application configuration & metadata)
        ├── embedded.mobileprovision       (Cryptographic provisioning profile)
        ├── Assets.car                     (Compiled asset catalog & icon sets)
        ├── Frameworks/                    (Embedded dynamic frameworks & dylibs)
        └── _CodeSignature/
            └── CodeResources              (XML signature manifest of all resources)

When you instruct an upload tool to deliver an .ipa to App Store Connect, Apple's ingestion system unpacks this archive and performs rigorous analysis on its contents. If any required component is missing or misconfigured, Apple rejects the package.


What FlightDeck Validates Offline

When you prompt your AI assistant to preview an upload, FlightDeck uses its in-process ArtifactInspector engine to evaluate package structure and metadata offline.

TEXT
                  ┌────────────────────────────────────────┐
                  │    FlightDeck Local Package Inspection │
                  └───────────────────┬────────────────────┘
                                      │
         ┌────────────────────────────┼────────────────────────────┐
         ▼                            ▼                            ▼
┌──────────────────┐         ┌──────────────────┐         ┌──────────────────┐
│ Container Check  │         │  Security Bounds │         │  Metadata Match  │
├──────────────────┤         ├──────────────────┤         ├──────────────────┤
│ • Valid ZIP file │         │ • Entry count lim│         │ • CFBundleId match│
│ • Payload/ dir   │         │ • No traversal ..│         │ • Semantic version│
│ • Single .app    │         │ • Size limits    │         │ • Numeric build  │
│ • Rejects dirs   │         │ • No symlink plist│        │ • Target platform│
└──────────────────┘         └──────────────────┘         └──────────────────┘

FlightDeck performs the following concrete checks directly on your local workstation:

  1. File Container Verification: Confirms the target path is an existing, non-empty packaged file (.ipa, .pkg, or .zip). If a developer accidentally passes an unpackaged .app directory or raw .xcarchive, FlightDeck halts immediately with an UnsupportedArtifactException, reminding you that App Store Connect requires an archive package.
  2. ZIP Decompression Bounds: Decodes the archive in memory using pure Dart decoders, enforcing safe bounds (up to 10,000 entries) to defend against zip-bomb denial-of-service vulnerabilities.
  3. Directory Traversal Defense: Scans entry paths to ensure no entry contains .., leading slashes, backslashes, null bytes, or traversal tokens, and verifies that Info.plist is not a symbolic link.
  4. Bounded Extraction: Enforces a 10 MB limit on the decompressed Info.plist to prevent memory exhaustion from corrupt archives.
  5. In-Process Property List Parsing: Natively parses binary property lists (bplist00) and XML property lists to extract metadata without invoking external shell scripts.
  6. Bundle Identifier Matching: Compares the extracted CFBundleIdentifier against your registered App Store Connect app record (app.bundleId) to prevent uploading a staging build to a production container.
  7. Marketing Version Verification: Extracts CFBundleShortVersionString and validates it against expected semantic version formats.
  8. Build Number Integrity: Extracts CFBundleVersion and confirms it contains valid numeric components.
  9. Target Platform Inference: Determines whether the application targets IOS or MAC_OS based on bundle structure and property list contents.
  10. Streaming Digest Computation: Generates SHA-256 and MD5 cryptographic checksums of the entire archive for upload part verification without buffering the full file into memory.

Technical Inspection Boundaries: FlightDeck vs. Local CLI vs. Apple

To avoid false expectations, developers must understand what FlightDeck validates versus what requires local macOS developer tools or Apple's server-side ingestion:

Validation Capability Checked by FlightDeck (build_upload_preview) Checked via Local macOS Tools (codesign, lipo) Checked by Apple During Ingestion / Processing
ZIP archive & entry bounds Yes Yes (unzip -t) Yes
*Payload/.app bundle presence** Yes Yes Yes
Info.plist bundle ID match Yes Yes (plutil) Yes
Version & build number format Yes Yes (plutil) Yes
Streaming SHA-256 / MD5 digest Yes Yes (shasum) Yes
Mach-O CPU architecture slices (arm64) No Yes (lipo -info) Yes
Mach-O header structure No Yes (otool -h) Yes
Cryptographic code signatures No Yes (codesign -dv) Yes
Provisioning profile trust & get-task-allow No Yes (security cms) Yes
Nested framework signatures No Yes (codesign --verify) Yes
Apple certificate revocation (OCSP) No No Yes
Private Apple API symbol usage No No Yes
App Review Guideline compliance No No Yes (Human Review)
Important

No Acceptance Guarantee: FlightDeck's build_upload_preview verifies local package integrity and bundle metadata alignment. It does not parse Mach-O headers, check CPU architecture slices, verify cryptographic signature trust, or scan for private API symbols. Running build_upload_preview cannot guarantee that Apple's backend processing will accept the binary.


Running Local Binary Checks with macOS Developer Tools

If you need to verify executable architectures or code signatures before uploading, your AI coding assistant can run native macOS command-line tools in your local terminal. These tools are part of Apple's Xcode Command Line Tools, not FlightDeck.

1. Verifying ARM64 Architecture Slices (lipo)

To confirm that your executable contains the required 64-bit ARM device slice rather than an x86_64 simulator binary:

BASH
# Unpack archive into a temporary folder
mkdir -p /tmp/inspect_ipa
unzip -q /path/to/MyApp.ipa -d /tmp/inspect_ipa

# Inspect Mach-O binary architecture slices
lipo -info /tmp/inspect_ipa/Payload/*.app/MyApp

Expected output for a physical iOS device build:

TEXT
Non-fat file: /tmp/inspect_ipa/Payload/MyApp.app/MyApp is architecture: arm64

2. Verifying Code Signatures and Entitlements (codesign)

To verify that the application is signed with an Apple Distribution identity and has production entitlements:

BASH
# Check signing authority
codesign -dv --verbose=4 /tmp/inspect_ipa/Payload/*.app

# Verify signature validity on disk
codesign --verify --deep --strict --verbose=2 /tmp/inspect_ipa/Payload/*.app

# Inspect embedded profile get-task-allow (must be 0 for production)
security cms -D -i /tmp/inspect_ipa/Payload/*.app/embedded.mobileprovision | grep -A 1 get-task-allow

Inspecting Your Binary Using Natural Language AI Prompts

Through FlightDeck, you can ask your AI coding assistant to inspect your .ipa archive using conversational English. FlightDeck handles the offline package inspection and validates metadata against App Store Connect.

Because inspecting local archives is an offline, read-only analysis (Tier 2), FlightDeck executes the inspection immediately without requiring manual approval.

Pre-Upload Inspection Prompt

Copy and paste this prompt into your connected AI coding assistant:

TEXT
Inspect the local iOS archive at [path/to/MyApp.ipa] using FlightDeck. Verify its package structure, Info.plist metadata, bundle identifier, and version numbers against App Store Connect for [Your App Name], and confirm whether it is ready to be staged for upload.

Your assistant connects to FlightDeck, unpacks the archive in memory, and reports:

  • The package structure and whether a valid Payload/*.app bundle exists.
  • The extracted bundle ID (CFBundleIdentifier) and whether it matches your registered App Store Connect app record.
  • The marketing version (CFBundleShortVersionString) and build number (CFBundleVersion).
  • The inferred target platform (IOS or MAC_OS).
  • The computed file size and SHA-256 digest.

Staging the Upload in the FlightDeck Approval Center

Once local inspection confirms that your archive is structurally sound and matches your App Store Connect app record, prompt your AI assistant to stage the upload:

TEXT
The pre-upload validation passed. Stage an upload of [path/to/MyApp.ipa] to App Store Connect for [Your App Name] and show me the approval summary before delivering.

Because delivering a new binary creates resources on Apple's servers, FlightDeck intercepts the mutating network request and stages it for your review. FlightDeck Desktop displays the Approval Center sheet:

Illustrative representation of the FlightDeck Approval Center sheet:

TEXT
┌──────────────────────────────────────────────────────────────┐
│ FlightDeck Desktop — Operation Approval Request             │
├──────────────────────────────────────────────────────────────┤
│ Operation:   Deliver iOS Binary (.ipa)                      │
│ Target App:  [Your App Name] (App ID: 6812899314)           │
│ Binary Path: /path/to/MyApp.ipa                             │
│ Version:     1.0.0 (Build 12)                               │
│ Platform:    iOS                                            │
│ Action:      Upload binary parts to Apple Ingestion Storage │
│ Impact:      Stages build for Apple server processing.      │
├──────────────────────────────────────────────────────────────┤
│ [Reject Proposal]                        [Approve & Execute] │
└──────────────────────────────────────────────────────────────┘

Review the parameters in FlightDeck Desktop and click Approve & Execute. FlightDeck streams the binary in chunked parts directly to Apple's ingestion storage.


Inspection Step What Is Checked Tool Used
Package Structure Valid ZIP container, Payload/*.app/Info.plist FlightDeck build_upload_preview
App Alignment Bundle ID matches App Store Connect app record FlightDeck build_upload_preview
Version & Build Valid semantic version and numeric build counter FlightDeck build_upload_preview
Architecture Mach-O executable contains arm64 device slice Local macOS CLI (lipo -info)
Code Signing Apple Distribution identity, get-task-allow = 0 Local macOS CLI (codesign, security cms)
Delivery Staging Human review of target app, version, and file path FlightDeck Desktop Approval Center

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