# App Publisher Mcp

> MCP server from seungmanchoi/app-publisher-mcp.

- **Type:** MCP server
- **Install:** `agentstack add mcp-seungmanchoi-app-publisher-mcp`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [seungmanchoi](https://agentstack.voostack.com/s/seungmanchoi)
- **Installs:** 0
- **Category:** [AI & ML](https://agentstack.voostack.com/c/ai-and-ml)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [seungmanchoi](https://github.com/seungmanchoi)
- **Source:** https://github.com/seungmanchoi/app-publisher-mcp

## Install

```sh
agentstack add mcp-seungmanchoi-app-publisher-mcp
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# App Publisher MCP

An MCP (Model Context Protocol) server built for **vibe coders** - generate app icons with AI, auto-resize for iOS/Android, and publish to app stores, all from your AI coding assistant.

Stop wasting time on Figma for app icons or manually resizing images for every screen density. Just describe what you want, and let AI handle the rest.

## What It Does

| Tool | Description |
|------|-------------|
| `generate_icon` | Generate app icons using Google Gemini AI |
| `resize_icons` | Auto-resize to all iOS & Android required sizes |
| `generate_splash` | Generate splash screen designs with AI |
| `generate_screenshot` | Generate app store screenshot mockups |
| `setup_fastlane` | Generate fastlane config with copyright, review info, and precheck settings |
| `populate_metadata` | Write store listing content directly to fastlane metadata files |
| `validate_metadata` | Validate metadata against App Store requirements (length limits, required fields) |
| `publish_ios` | Publish to App Store via fastlane |
| `publish_android` | Publish to Google Play via fastlane |
| `generate_store_listing` | Auto-generate store metadata + iOS age rating guide + App Privacy guide (4 languages) |
| `get_publishing_guide` | Step-by-step publishing guide (iOS 12 steps / Android 7 steps) |
| `configure_api_key` | Set your Gemini API key |
| `configure_model` | Choose AI model (speed vs quality) |
| `get_status` | Check current configuration |

### Maestro UI Testing & Store Screenshots

| Tool | Description |
|------|-------------|
| `setup_maestro` | Install and configure Maestro CLI for mobile UI testing |
| `maestro_screenshot` | Capture screenshot from running iOS Simulator / Android Emulator |
| `maestro_run_flow` | Run UI test flows with natural language steps |
| `maestro_run_yaml` | Run Maestro flows from raw YAML |
| `maestro_store_screenshot` | Create professional store screenshots with AI-generated headlines + device frames |
| `maestro_status` | Check Maestro installation and running devices |

### Google Play Store

| Tool | Description |
|------|-------------|
| `configure_playstore` | Configure Google Play API with service account JSON key (file path or inline data) |
| `playstore_status` | Check Play Store API configuration and service account status |
| `playstore_setup_key` | Full Android publishing setup: copy key, create Appfile/Fastfile, metadata structure |
| `playstore_verify_access` | Verify service account has API access to a specific app |
| `playstore_get_app_info` | Get comprehensive app info: all listings + all release tracks |
| `playstore_get_listing` | Get store listing(s) - all languages or a specific language |
| `playstore_update_listing` | Update title, short description, full description for a language |
| `playstore_get_tracks` | List release tracks with version codes, status, release notes |
| `playstore_list_images` | List uploaded screenshots/images for a language and type |
| `playstore_upload_image` | Upload screenshot, icon, or feature graphic (PNG/JPEG/WebP) |
| `playstore_delete_images` | Delete all images of a specific type for a language |

### AdMob Integration

| Tool | Description |
|------|-------------|
| `configure_admob` | Set up Google AdMob OAuth credentials and get authorization URL |
| `admob_auth` | Complete OAuth flow by exchanging authorization code for tokens |
| `admob_list_apps` | List all apps registered in your AdMob account |
| `admob_create_app` | Create a new app in AdMob (link to store or manual) * |
| `admob_list_ad_units` | List existing ad units (optionally filter by app) |
| `admob_create_ad_unit` | Create a new ad unit (Banner, Interstitial, Rewarded, App Open, Native) * |
| `admob_integrate` | Generate React Native ad components and configuration for your project |
| `admob_status` | Check AdMob OAuth configuration and authentication status |

> **\* Limited Access**: `admob_create_app` and `admob_create_ad_unit` use the AdMob API v1beta create methods, which have **restricted access by Google**. Most accounts will receive a 403 Permission Denied error. To use these, you must request access from your Google account manager. As an alternative, create apps and ad units directly in the [AdMob console](https://admob.google.com), then use `admob_list_apps`, `admob_list_ad_units`, and `admob_integrate` to generate integration code for your project.

## Quick Start

### 1. Install in Claude Code

```bash
claude mcp add app-publisher -- npx @seungmanchoi/app-publisher-mcp
```

Or with environment variables:

```bash
claude mcp add app-publisher \
  -e GEMINI_API_KEY=your_api_key_here \
  -e GEMINI_MODEL=gemini-2.5-flash-image \
  -- npx @seungmanchoi/app-publisher-mcp
```

### 2. Manual Configuration

Add to your Claude Code MCP config (`~/.claude.json`):

```json
{
  "mcpServers": {
    "app-publisher": {
      "command": "npx",
      "args": ["@seungmanchoi/app-publisher-mcp"],
      "env": {
        "GEMINI_API_KEY": "your_api_key_here",
        "GEMINI_MODEL": "gemini-2.5-flash-image"
      }
    }
  }
}
```

### 3. Restart Claude Code

After adding the MCP server, restart Claude Code to connect.

## Getting Your API Keys

### Google Gemini API Key (Required)

The Gemini API key is needed for AI image generation (icons, splash screens, screenshots).

#### Step-by-Step

1. Go to [Google AI Studio](https://aistudio.google.com/apikey)
2. Sign in with your Google account
3. Click **"Create API key"**
4. Select a Google Cloud project (or create a new one)
5. Copy the generated API key (starts with `AIza...`)

#### Set the API Key

**Option A: Environment variable (recommended)**
```bash
claude mcp add app-publisher \
  -e GEMINI_API_KEY=AIzaSy... \
  -- npx @seungmanchoi/app-publisher-mcp
```

**Option B: Runtime configuration**
Once the MCP is connected, use the `configure_api_key` tool:
> "Set my Gemini API key to AIzaSy..."

**Option C: Config file**
The key is stored in `~/.app-publisher/config.json` and persists across sessions.

#### Pricing

| Model | Price per Image | Speed | Quality |
|-------|----------------|-------|---------|
| `gemini-2.5-flash-image` | ~$0.039 | 3-5 sec | Standard |
| `gemini-3-pro-image-preview` | ~$0.035 (4K: ~$0.24) | 10-15 sec | Best |

Google provides a free tier with generous limits for development. Check [Google AI pricing](https://ai.google.dev/pricing) for current rates.

### Google AdMob OAuth Credentials (For Ad Management)

Required for creating and managing ad units via the AdMob API.

#### Step-by-Step

1. Go to [Google Cloud Console](https://console.cloud.google.com/)
2. Create a new project or select an existing one
3. Enable the **AdMob API**:
   - Go to **APIs & Services** > **Library**
   - Search for "AdMob API"
   - Click **Enable**
4. Create OAuth 2.0 credentials:
   - Go to **APIs & Services** > **Credentials**
   - Click **"Create Credentials"** > **"OAuth client ID"**
   - Application type: **Desktop app**
   - Name it (e.g., "app-publisher-mcp")
   - Click **Create**
5. Copy the **Client ID** and **Client Secret**

> **Note**: If prompted, configure the OAuth consent screen first (External type is fine for personal use). Add the scopes `admob.monetization` and `admob.readonly`.

#### Set Up AdMob in MCP

```
1. "Configure AdMob with client ID xxx and secret yyy"
   → Stores credentials and returns an authorization URL

2. Open the URL in your browser and sign in with your Google account
   → Grant access and copy the authorization code

3. "Authenticate AdMob with code xxxx"
   → Exchanges code for tokens (stored in ~/.app-publisher/config.json)

4. "List my AdMob apps"
   → Verify connection works
```

#### Where to Get AdMob Account

1. Go to [Google AdMob](https://admob.google.com/home/)
2. Sign in with your Google account
3. Accept the terms of service
4. Create your first app or link an existing one

> **Important**: AdMob credentials are stored locally in `~/.app-publisher/config.json`. The refresh token is used to automatically renew access tokens.

### Apple App Store Connect (For iOS Publishing)

Required only if you want to publish to the App Store.

#### Step-by-Step

1. Go to [App Store Connect](https://appstoreconnect.apple.com/)
2. Sign in with your Apple Developer account ($99/year membership required)
3. Go to **Users and Access** > **Integrations** > **App Store Connect API**
4. Click **"Generate API Key"**
5. Give it a name (e.g., "app-publisher-mcp")
6. Select **"Admin"** role
7. Download the `.p8` private key file (you can only download it once!)
8. Note down:
   - **Key ID** (e.g., `ABC1234567`)
   - **Issuer ID** (shown at the top of the page)

#### Using API Key in Fastlane

Place the `.p8` file in your project (e.g., `fastlane/keys/`) and add the API key block to your `Fastfile`:

```ruby
api_key = app_store_connect_api_key(
  key_id: "ABC1234567",
  issuer_id: "your-issuer-id-here",
  key_filepath: File.join(Dir.pwd, "keys", "AuthKey_ABC1234567.p8"),
  in_house: false
)

platform :ios do
  lane :release do
    deliver(
      api_key: api_key,
      # ... other options
    )
  end
end
```

> **Tip**: Add `fastlane/keys/*.p8` to `.gitignore` to avoid committing the private key. The `.p8` file can be deleted from Downloads after copying to your project.

#### Where to Get Apple Developer Account

1. Go to [Apple Developer Program](https://developer.apple.com/programs/)
2. Click **"Enroll"**
3. Sign in with your Apple ID
4. Pay $99/year membership fee
5. Wait for approval (usually 24-48 hours)

### Google Play Console (For Android Publishing)

Required only if you want to publish to Google Play.

#### Step 1: Create a Google Cloud Service Account

1. Go to [Google Cloud Console](https://console.cloud.google.com/)
2. Create a new project or select an existing one
3. Enable the **Google Play Android Developer API**:
   - Go to **APIs & Services** > **Library**
   - Search for "Google Play Android Developer API"
   - Click **Enable**
4. Create a Service Account:
   - Go to **IAM & Admin** > **Service Accounts**
   - Click **"Create Service Account"**
   - Name: `Play Store Deploy` (or any name)
   - ID: `play-store-deploy`
   - Description: `Service account for Google Play Store publishing via fastlane`
   - Skip role assignment (not needed, permissions are set in Play Console)
5. Create a JSON key:
   - Click the service account > **Keys** tab > **Add Key** > **Create new key** > **JSON**
   - Download the JSON key file
   - Note the **service account email** (e.g., `play-store-deploy@project-id.iam.gserviceaccount.com`)

#### Step 2: Grant Access in Google Play Console

> **Important**: The "API access" menu may not be visible in some accounts. Use the "Users and permissions" method instead.

**Method A: Via API Access (if available)**
1. Go to [Google Play Console](https://play.google.com/console/) > **Settings** > **API access**
2. Link your Google Cloud project
3. Grant access to the service account

**Method B: Via Users and Permissions (recommended)**
1. Go to [Google Play Console](https://play.google.com/console/) > **Users and permissions**
2. Click **"Invite new users"**
3. Enter the **service account email** from Step 1
4. Set permissions:
   - **Release management** (manage production, testing tracks)
   - **Edit store listing** (update metadata, screenshots)
5. Click **"Invite user"**

> **Note**: It may take up to 24 hours for permissions to fully propagate.

#### Step 3: Configure in MCP

**Option A: File path (key file stays on disk)**
```
"Configure Play Store with JSON key at ~/Downloads/my-service-account.json for project ~/works/my-app"
```
This validates the key, copies it to `fastlane/keys/`, updates Appfile, and adds to .gitignore.

**Option B: Inline JSON (store in config, delete original file)**
```
"Configure Play Store with inline JSON key data: { ... }"
```
The JSON content is stored in `~/.app-publisher/config.json`. You can safely delete the original key file after configuration. When deploying to a project, the key is written from config to `fastlane/keys/`.

**Option C: Using playstore_setup_key tool**
```
"Set up Play Store publishing for ~/works/my-app with JSON key ~/Downloads/my-key.json and package name com.example.myapp"
```
This creates the full fastlane Android setup including metadata directory structure.

**Option C: Manual setup**

Place the JSON key file in your project (e.g., `fastlane/keys/`) and reference it in `Appfile`:

```ruby
# fastlane/Appfile
json_key_file("fastlane/keys/play-store-service-account.json")
package_name("com.example.myapp")
```

Then use fastlane supply to upload:

```bash
# Upload to production
fastlane android release aab:"path/to/app.aab"

# Upload to internal testing
fastlane android internal aab:"path/to/app.aab"

# Upload metadata only
fastlane android metadata
```

> **Tip**: Add `fastlane/keys/*.json` to `.gitignore` to avoid committing the service account key.

#### Where to Get Google Play Developer Account

1. Go to [Google Play Console signup](https://play.google.com/console/signup)
2. Sign in with your Google account
3. Pay $25 one-time registration fee
4. Complete developer profile
5. Verify identity (may take a few days)

### Fastlane (For Store Publishing)

**Required** for `setup_fastlane`, `publish_ios`, `publish_android`, `populate_metadata`, and `validate_metadata` tools.

```bash
# macOS (recommended)
brew install fastlane

# or via Ruby
gem install fastlane
```

> **Note**: Age ratings and App Privacy settings must be configured directly in [App Store Connect](https://appstoreconnect.apple.com/) — fastlane does not support uploading these. Use the `generate_store_listing` tool to get a step-by-step guide for these settings.

## Usage Examples

### Generate an App Icon

> "Generate an app icon for a meditation app - a lotus flower with calm blue and purple gradient"

The AI will create a professional app icon and save it to `~/app-publisher-assets/`.

### Resize for All Platforms

> "Resize the icon at ~/app-publisher-assets/icon_xxx.png for both iOS and Android"

This generates:
- **iOS**: 15 sizes (20px ~ 1024px) + Xcode `Contents.json`
- **Android**: 6 sizes (mdpi ~ xxxhdpi) + Play Store 512x512

### Generate Store Screenshots

> "Generate a screenshot mockup for a fitness app showing a workout dashboard with progress charts"

### Set Up Fastlane

> "Set up fastlane for my project at ~/myapp with bundle ID com.example.myapp"

You can also provide review contact info and copyright:

> "Set up fastlane for ~/myapp with bundle ID com.example.myapp, app name 'My App', copyright '2026 John Doe', review contact email john@example.com"

This creates:
- `fastlane/Fastfile` - Build and deploy lanes with:
  - Auto-set copyright with current year
  - `app_review_information` block (prevents `No data` crash on new apps)
  - `precheck_include_in_app_purchases: false` (for API key auth)
  - `skip_app_version_update: true` for metadata-only uploads
- `fastlane/Appfile` - App configuration
- `fastlane/metadata/` - Store listing metadata structure (10 files per locale)

### Populate Metadata

After generating store listing content, write it directly to fastlane metadata files:

> "Populate fastlane metadata for ~/myapp with en-US name 'My App', description 'A great app...', and ko name '내 앱'"

This writes content to `fastlane/metadata/{locale}/{field}.txt` files. Supported fields: `name`, `subtitle`, `description`, `keywords`, `promotional_text`, `release_notes`, `privacy_url`, `support_url`, `marketing_url`, `copyright`.

### Validate Metadata

Check your metadata against App Store requirements before uploading:

> "Validate fastlane metadata for ~/myapp"

Checks:
- **Subtitle**: max 30 characters
- **Keywords**: max 100 characters
- **Required files**: `name.txt`, `description.txt`, `privacy_url.txt`, `support_url.txt`
- **Copyright**: must include current year

### Generate Store Listing Metadata

> "Generate store listing metadata for my project at ~/myapp"

Analyzes your projec

…

## Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [seungmanchoi](https://github.com/seungmanchoi)
- **Source:** [seungmanchoi/app-publisher-mcp](https://github.com/seungmanchoi/app-publisher-mcp)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/mcp-seungmanchoi-app-publisher-mcp
- Seller: https://agentstack.voostack.com/s/seungmanchoi
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.