Gpc Multi App

gpc-multi-app

Managing multiple Google Play apps with GPC using profiles, scripting, and automation patterns.

When to use

• Managing multiple Android apps (portfolio, white-label, variants)
• Running the same GPC command across several apps
• Setting up per-app configurations and credentials
• Monorepo with multiple Android modules
• Different service accounts for different apps

Inputs required

• Authenticated GPC — gpc auth status must show valid credentials
• Package names — for all apps being managed
• Service account keys — may differ per app or developer account

Procedure

0. Understand app resolution

GPC resolves the target app in this order:

1. --app CLI flag (highest priority) 2. GPC_APP environment variable 3. .gpcrc.json in project directory 4. User config at ~/.config/gpc/config.json 5. Active profile override

1. Quick health check across all apps

Use gpc status --all-apps to check health across all configured apps at once:

gpc status --all-apps

This reports the status of every app defined in your profiles or config, without needing to switch profiles or pass --app for each one.

2. Per-app configuration with profiles

Set up named profiles for each app:

# Configure profiles in ~/.config/gpc/config.json

{
  "app": "com.example.main",
  "profiles": {
    "main": {
      "app": "com.example.main",
      "auth": { "serviceAccount": "/keys/main-sa.json" }
    },
    "lite": {
      "app": "com.example.lite",
      "auth": { "serviceAccount": "/keys/main-sa.json" }
    },
    "enterprise": {
      "app": "com.example.enterprise",
      "auth": { "serviceAccount": "/keys/enterprise-sa.json" }
    }
  }
}

Use profiles per command:

gpc releases list --profile main
gpc releases list --profile lite
gpc releases list --profile enterprise

Or set via environment:

export GPC_PROFILE=enterprise
gpc releases list  # uses enterprise profile

Read: references/profile-patterns.md for advanced profile configurations.

3. Project-level .gpcrc.json

For monorepos, place .gpcrc.json in each app's directory:

monorepo/
├── apps/
│   ├── main/
│   │   ├── .gpcrc.json          # { "app": "com.example.main" }
│   │   └── build.gradle
│   ├── lite/
│   │   ├── .gpcrc.json          # { "app": "com.example.lite" }
│   │   └── build.gradle
│   └── enterprise/
│       ├── .gpcrc.json          # { "app": "com.example.enterprise" }
│       └── build.gradle
└── .gpcrc.json                  # shared defaults

GPC walks up from the current directory to find .gpcrc.json, so running commands from each app's directory automatically uses the right package name.

4. Batch operations with shell scripts

Run the same command across all apps:

#!/bin/bash
# deploy-all.sh — upload to internal track for all apps

APPS=(
  "com.example.main"
  "com.example.lite"
  "com.example.enterprise"
)

for app in "${APPS[@]}"; do
  echo "Uploading $app..."
  gpc releases upload "build/$app/app-release.aab" --track internal --app "$app"
done

5. Batch vitals check

#!/bin/bash
# check-vitals.sh — check crash rate across all apps

APPS=("com.example.main" "com.example.lite" "com.example.enterprise")
THRESHOLD=2.0
FAILED=0

for app in "${APPS[@]}"; do
  echo "Checking $app..."
  if ! gpc vitals crashes --threshold "$THRESHOLD" --app "$app"; then
    echo "FAIL: $app crash rate exceeds ${THRESHOLD}%"
    FAILED=1
  fi
done

exit $FAILED

6. CI/CD for multiple apps

Read: references/ci-multi-app.md for CI platform-specific multi-app workflows.

GitHub Actions matrix strategy

name: Deploy All Apps
on:
  push:
    tags: ['v*']

jobs:
  deploy:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        app:
          - { package: "com.example.main", aab: "main/app-release.aab" }
          - { package: "com.example.lite", aab: "lite/app-release.aab" }
          - { package: "com.example.enterprise", aab: "enterprise/app-release.aab" }
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
      - name: Upload to internal
        env:
          GPC_SERVICE_ACCOUNT: ${{ secrets.PLAY_SA_KEY }}
          GPC_APP: ${{ matrix.app.package }}
        run: npx @gpc-cli/cli releases upload ${{ matrix.app.aab }} --track internal

7. Different service accounts per app

When apps belong to different developer accounts:

# Use different env vars per command
GPC_SERVICE_ACCOUNT=$(cat keys/main.json) gpc releases list --app com.example.main
GPC_SERVICE_ACCOUNT=$(cat keys/client.json) gpc releases list --app com.client.app

Or use profiles (recommended):

{
  "profiles": {
    "main": {
      "app": "com.example.main",
      "auth": { "serviceAccount": "/keys/main-sa.json" }
    },
    "client": {
      "app": "com.client.app",
      "auth": { "serviceAccount": "/keys/client-sa.json" }
    }
  }
}

8. Bulk metadata sync

Sync listings for all apps from a shared metadata structure:

# metadata/
# ├── com.example.main/
# │   └── en-US/
# ├── com.example.lite/
# │   └── en-US/

for dir in metadata/*/; do
  app=$(basename "$dir")
  echo "Syncing $app..."
  gpc listings push --dir "$dir" --app "$app" --dry-run
done

Verification

• gpc config list --profile <name> shows correct app and auth per profile
• Commands with --app or --profile target the right app
• Batch scripts exit 0 when all apps succeed
• CI matrix runs deploy independently per app
• .gpcrc.json in subdirectories correctly overrides the default app

Failure modes / debugging

Related skills

• gpc-setup — initial auth and profiles configuration
• gpc-ci-integration — CI pipeline setup for single apps
• gpc-sdk-usage — programmatic multi-app management with the TypeScript SDK
• gpc-user-management — managing per-app permissions for team members

CI/CD for Multiple Apps

Platform-specific patterns for deploying multiple apps in CI.

GitHub Actions — Matrix strategy

name: Deploy All Apps
on:
  push:
    tags: ['v*']

jobs:
  deploy:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        include:
          - app: com.example.main
            aab: main/app-release.aab
          - app: com.example.lite
            aab: lite/app-release.aab
          - app: com.example.pro
            aab: pro/app-release.aab
      fail-fast: false  # Don't cancel other apps if one fails
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
      - name: Upload to beta
        env:
          GPC_SERVICE_ACCOUNT: ${{ secrets.PLAY_SA_KEY }}
          GPC_APP: ${{ matrix.app }}
        run: npx @gpc-cli/cli releases upload ${{ matrix.aab }} --track beta

GitHub Actions — Different service accounts

jobs:
  deploy:
    strategy:
      matrix:
        include:
          - app: com.ourcompany.app
            secret: PLAY_SA_KEY_MAIN
          - app: com.client.app
            secret: PLAY_SA_KEY_CLIENT
    steps:
      - name: Upload
        env:
          GPC_SERVICE_ACCOUNT: ${{ secrets[matrix.secret] }}
          GPC_APP: ${{ matrix.app }}
        run: npx @gpc-cli/cli releases upload app.aab --track beta

GitLab CI — Parallel jobs

.deploy-template:
  image: node:20
  stage: deploy
  only: [tags]
  script:
    - npx @gpc-cli/cli releases upload ${AAB_PATH} --track beta

deploy-main:
  extends: .deploy-template
  variables:
    GPC_APP: com.example.main
    AAB_PATH: main/app-release.aab

deploy-lite:
  extends: .deploy-template
  variables:
    GPC_APP: com.example.lite
    AAB_PATH: lite/app-release.aab

Batch vitals check in CI

# GitHub Actions
- name: Check vitals for all apps
  env:
    GPC_SERVICE_ACCOUNT: ${{ secrets.PLAY_SA_KEY }}
  run: |
    FAILED=0
    for app in com.example.main com.example.lite com.example.pro; do
      echo "Checking $app..."
      if ! npx @gpc-cli/cli vitals crashes --threshold 2.0 --app "$app"; then
        echo "::warning::$app crash rate exceeds threshold"
        FAILED=1
      fi
    done
    exit $FAILED

Sequential deployment with promotion gates

jobs:
  deploy-internal:
    strategy:
      matrix:
        app: [com.example.main, com.example.lite]
    steps:
      - name: Upload to internal
        env:
          GPC_APP: ${{ matrix.app }}
        run: npx @gpc-cli/cli releases upload app.aab --track internal

  promote-beta:
    needs: deploy-internal
    strategy:
      matrix:
        app: [com.example.main, com.example.lite]
    steps:
      - name: Promote to beta
        env:
          GPC_APP: ${{ matrix.app }}
        run: npx @gpc-cli/cli releases promote --from internal --to beta

Multi-App Profile Patterns

Configuration patterns for managing multiple apps with GPC profiles.

Basic profile setup

~/.config/gpc/config.json:

{
  "app": "com.example.main",
  "profiles": {
    "main": {
      "app": "com.example.main"
    },
    "lite": {
      "app": "com.example.lite"
    }
  }
}

gpc releases list --profile main
gpc releases list --profile lite

Different service accounts per profile

When apps belong to different developer accounts:

{
  "profiles": {
    "our-app": {
      "app": "com.ourcompany.app",
      "auth": { "serviceAccount": "/keys/our-sa.json" }
    },
    "client-a": {
      "app": "com.client-a.app",
      "auth": { "serviceAccount": "/keys/client-a-sa.json" },
      "developerId": "1111111111"
    },
    "client-b": {
      "app": "com.client-b.app",
      "auth": { "serviceAccount": "/keys/client-b-sa.json" },
      "developerId": "2222222222"
    }
  }
}

Environment-based profiles

{
  "profiles": {
    "dev": {
      "app": "com.example.app.dev",
      "auth": { "serviceAccount": "/keys/dev-sa.json" }
    },
    "staging": {
      "app": "com.example.app.staging",
      "auth": { "serviceAccount": "/keys/staging-sa.json" }
    },
    "production": {
      "app": "com.example.app",
      "auth": { "serviceAccount": "/keys/prod-sa.json" }
    }
  }
}

# Deploy to each environment
gpc releases upload app.aab --track internal --profile dev
gpc releases upload app.aab --track beta --profile staging
gpc releases upload app.aab --track production --profile production

White-label apps

{
  "profiles": {
    "brand-a": {
      "app": "com.brand-a.app",
      "auth": { "serviceAccount": "/keys/main-sa.json" }
    },
    "brand-b": {
      "app": "com.brand-b.app",
      "auth": { "serviceAccount": "/keys/main-sa.json" }
    },
    "brand-c": {
      "app": "com.brand-c.app",
      "auth": { "serviceAccount": "/keys/main-sa.json" }
    }
  }
}

Same service account if all apps are under one developer account.

Profile via environment variable

export GPC_PROFILE=production
gpc releases list  # uses production profile

# Override per command
gpc releases list --profile staging

Monorepo pattern

Instead of profiles, use .gpcrc.json per app directory:

monorepo/
├── apps/main/.gpcrc.json       → { "app": "com.example.main" }
├── apps/lite/.gpcrc.json       → { "app": "com.example.lite" }
└── .gpcrc.json                 → shared config (no app set)

cd apps/main && gpc releases list    # uses com.example.main
cd apps/lite && gpc releases list    # uses com.example.lite

Combining profiles with CI

# GitHub Actions — deploy all white-label apps
jobs:
  deploy:
    strategy:
      matrix:
        profile: [brand-a, brand-b, brand-c]
    steps:
      - name: Deploy
        run: npx @gpc-cli/cli releases upload app-${{ matrix.profile }}.aab --track beta --profile ${{ matrix.profile }}