What files are needed for signing?

iOS distribution certificate, provisioning profile, and App Store Connect credentials; Android keystore and signing config in gradle.properties.

How do I trigger deployment in CI/CD?

Push a tag matching v* in GitHub Actions workflow that runs deployment jobs for iOS and Android.

What should be included in the pre-deployment checklist?

Tests with high coverage, app icons for all sizes, store screenshots, privacy policy URL, permissions justification, minimum OS support, and release notes.

app-store-deployment

Scanned

npx machina-cli add skill secondsky/claude-skills/app-store-deployment --openclaw

Files (1)

SKILL.md

3.1 KB

App Store Deployment

Publish mobile applications to iOS App Store and Google Play with proper procedures.

iOS Deployment

Build and Archive

# Build archive
xcodebuild -workspace App.xcworkspace \
  -scheme App \
  -sdk iphoneos \
  -configuration Release \
  -archivePath build/App.xcarchive \
  archive

# Export IPA
xcodebuild -exportArchive \
  -archivePath build/App.xcarchive \
  -exportOptionsPlist ExportOptions.plist \
  -exportPath build/

Upload to App Store Connect

xcrun altool --upload-app \
  --type ios \
  --file build/App.ipa \
  --username "$APPLE_ID" \
  --password "$APP_SPECIFIC_PASSWORD"

Android Deployment

Build Release APK/Bundle

# Generate keystore (once)
keytool -genkey -v -keystore release.keystore \
  -alias app -keyalg RSA -keysize 2048 -validity 10000

# Build release bundle
./gradlew bundleRelease

gradle.properties

RELEASE_STORE_FILE=release.keystore
RELEASE_KEY_ALIAS=app
RELEASE_STORE_PASSWORD=****
RELEASE_KEY_PASSWORD=****

Version Management

{
  "version": "1.2.3",
  "ios": { "buildNumber": "45" },
  "android": { "versionCode": 45 }
}

Pre-Deployment Checklist

CI/CD (GitHub Actions)

on:
  push:
    tags: ['v*']

jobs:
  deploy-ios:
    runs-on: macos-latest
    steps:
      - uses: actions/checkout@v4

      - name: Set up environment
        run: |
          # Accept Xcode license if needed
          sudo xcodebuild -license accept || true

      - name: Build archive
        run: |
          xcodebuild -workspace App.xcworkspace \
            -scheme App \
            -sdk iphoneos \
            -configuration Release \
            -archivePath build/App.xcarchive \
            archive

      - name: Export IPA
        run: |
          xcodebuild -exportArchive \
            -archivePath build/App.xcarchive \
            -exportOptionsPlist ExportOptions.plist \
            -exportPath build/

      - name: Upload to App Store Connect
        env:
          APPLE_ID: ${{ secrets.APPLE_ID }}
          APP_SPECIFIC_PASSWORD: ${{ secrets.APP_SPECIFIC_PASSWORD }}
        run: |
          xcrun altool --upload-app \
            --type ios \
            --file build/App.ipa \
            --username "$APPLE_ID" \
            --password "$APP_SPECIFIC_PASSWORD"

  deploy-android:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: ./gradlew bundleRelease
      - uses: r0adkll/upload-google-play@v1

Best Practices

Automate deployment with CI/CD
Test on physical devices
Secure signing materials separately
Monitor crash reports post-launch

Source

git clone https://github.com/secondsky/claude-skills/blob/main/plugins/app-store-deployment/skills/app-store-deployment/SKILL.md

View on GitHub

Overview

App Store Deployment publishes mobile apps to iOS App Store and Google Play with proper signing, versioning, and CI/CD automation. It covers iOS build/archive, IPA export, App Store Connect upload, Android release bundle, and version management, plus a pre-deployment checklist and a GitHub Actions workflow to automate releases.

How This Skill Works

It uses xcodebuild to build and archive the iOS app, exports the IPA, and uploads to App Store Connect via altool. For Android, it builds a release bundle with Gradle, signs it with a keystore, and uses a CI/CD pipeline (e.g., GitHub Actions) to publish to Google Play. Versioning is demonstrated with a version JSON snippet and a repeatable release flow.

When to Use It

Preparing a new app release for iOS and Android.
Configuring signing certificates and keystores.
Setting up automated deployment pipelines (CI/CD).
Updating store listings with icons, screenshots, and release notes.
Bumping version numbers and codes for a publish-worthy build.

Quick Start

Step 1: Configure signing materials (iOS certificates, App Store credentials; Android keystore).
Step 2: Build iOS archive and export IPA; build Android release bundle.
Step 3: Push a release tag (e.g., v1.2.3) to trigger the CI/CD workflow to publish to stores.

Best Practices

Automate deployment with CI/CD.
Test on physical devices before release.
Secure signing materials separately (certificates, keystores, passwords).
Monitor crash reports post-launch.
Keep versioning consistent across platforms (iOS buildNumber and Android versionCode).

Example Use Cases

A GitHub Actions workflow builds IPA, signs it, and uploads to App Store Connect.
Android pipeline signs with release.keystore and uploads the bundle to Google Play via an action.
Version.json keeps version, ios.buildNumber, and android.versionCode in sync across releases.
Pre-deployment checklist ensures icons, screenshots, privacy policy URL, and release notes are ready.
CI/CD pipeline triggers on v* tags to publish releases for both platforms.

Frequently Asked Questions

Add this skill to your agents