KAppMaker CLI

Full documentation at cli.kappmaker.com

CLI tool that automates the entire mobile app launch process — from project scaffolding to store-ready builds.

A single kappmaker create command can:

  • Clone a template repository and set up a new project
  • Create a Firebase project, register Android + iOS apps, enable authentication, and download SDK configs
  • Generate an AI-powered app logo with automatic background removal
  • Create an App Store Connect listing with metadata, categories, age rating, subscriptions, privacy declarations, and review contact info
  • Configure an existing Google Play Console app — store listings, subscriptions, one-time in-app products, and the data safety declaration — via a built-in wrapper around the Play Publisher API (no external CLI, no extra dependencies)
  • Set up Adapty subscription products, paywalls, and placements for both iOS and Android
  • Refactor Gradle package names and application IDs
  • Set up the build environment (Android SDK)
  • Produce a signed Android release build (AAB) via Fastlane, ready to upload to Google Play

On top of that, standalone commands let you generate marketing screenshots from a text description, translate screenshots to 48+ locales in parallel, generate arbitrary images with AI, remove image backgrounds, enhance image quality, and split grid images — all powered by AI.

By default it uses the KAppMaker boilerplate (Kotlin Multiplatform), but you can bring your own template repository via --template-repo or kappmaker config set templateRepo <your-repo-url>. Boilerplate-specific steps (Gradle refactor, Fastlane build, CocoaPods) are automatically detected and skipped with a warning when using a custom template.

Installation

npm install -g kappmaker

Then use it anywhere:

kappmaker create <AppName>

npm install
npx tsx src/index.ts create <AppName>

Configuration

Run interactive setup to configure API keys and preferences:

kappmaker config init

Or set keys individually:

kappmaker config set falApiKey <your-key>       # For AI features (logo, screenshots) — or prompted on first use
kappmaker config set imgbbApiKey <your-key>      # For screenshot translation/generation — or prompted on first use
kappmaker config set openaiApiKey <your-key>     # For generate-screenshots — or prompted on first use
kappmaker config set templateRepo <your-repo>    # Use your own template (default: KAppMaker)

See all config keys and external services setup for details.

Claude Code Skill

If you use Claude Code, you can install the /kappmaker skill to run any CLI command through natural language — with automatic prerequisite checks, guided setup, and inline error recovery.

Install:

npx skills add KAppMaker/KAppMaker-CLI --skill kappmaker

Or via the Claude Code plugin system:

/plugin marketplace add KAppMaker/KAppMaker-CLI
/plugin install kappmaker@KAppMaker-CLI

Use:

/kappmaker create MyApp
/kappmaker generate screenshots for my fitness app
/kappmaker set up App Store Connect

Claude will check your config, verify API keys are set, and walk you through any missing prerequisites before running the command.

Context-aware: when a command needs inputs you didn't pass (app description, app name, brand color, tagline, keywords, etc.), the skill reads your project's AiGuidelines/ folder first (app-idea.md, prd.md, keywords.md, brand.md), then README.md, then existing ASO metadata, and fills in what it finds — you're only prompted for things that aren't already written down somewhere in the project.

Table of Contents

Commands Overview

Command Description
kappmaker create <app-name> Full end-to-end app setup (Firebase, logo, App Store Connect, Google Play Console, Adapty, release build)
kappmaker clone <app-name> Clone the template into <AppName>-All (step 1 of create as a standalone)
kappmaker git setup-upstream Rename origin to upstream (step 10 of create as a standalone)
kappmaker firebase login firebase login — authenticate the Firebase CLI
kappmaker firebase project Create a Firebase project (idempotent)
kappmaker firebase apps Create Android + iOS apps in a Firebase project (idempotent)
kappmaker firebase auth-anonymous Enable anonymous authentication
kappmaker firebase configs Download google-services.json + GoogleService-Info.plist
kappmaker create-logo Generate an app logo with AI (fal.ai)
kappmaker generate-image Generate an arbitrary image with AI — generic wrapper around fal.ai nano-banana-2
kappmaker create-appstore-app Set up an app on App Store Connect (metadata, subscriptions, privacy)
kappmaker appstore-monetization-push Push subscriptions + IAPs from appstore-config.json to App Store Connect (monetization step of create-appstore-app as a standalone; supports --subscriptions-only, --iap-only, --config)
kappmaker gpc setup Set up an existing app on Google Play Console (listings, subscriptions, IAPs, data safety)
kappmaker gpc listings push Push store listings from the Google Play config file
kappmaker gpc subscriptions list/push List or push subscriptions on Google Play Console
kappmaker gpc iap list/push List or push one-time in-app products on Google Play Console
kappmaker gpc data-safety push Push data safety declaration on Google Play Console
kappmaker gpc app-check --package <pkg> Check if a package exists on Google Play Console
kappmaker gpc monetization push Push subscriptions + IAPs from googleplay-config.json to Google Play Console (monetization steps of gpc setup as a standalone; supports --subscriptions-only, --iap-only)
kappmaker subscription add Quick-add one new subscription to Google Play + App Store Connect (auto-aligned IDs, full PPP fan-out, auto-creates ASC subscription group if missing)
kappmaker iap add Quick-add one new credit-pack IAP to Google Play + App Store Connect + Adapty (auto-aligned IDs, full PPP fan-out)
kappmaker adapty setup Set up Adapty products, paywalls, and placements
kappmaker image-split <image> Split a grid image into individual tiles
kappmaker image-remove-bg <image> Remove background from an image (fal.ai)
kappmaker image-enhance <image> Upscale and enhance image quality (fal.ai)
kappmaker convert-webp <source> Convert images (PNG, JPG, BMP, TIFF, GIF) to WebP
kappmaker translate-screenshots [dir] Translate screenshots to multiple locales (fal.ai)
kappmaker generate-screenshots Generate marketing screenshots with AI (OpenAI + fal.ai)
kappmaker generate-feature-image Generate a Google Play feature graphic (1024×500) with AI (OpenAI + fal.ai)
kappmaker generate-ios-icons Generate all iOS AppIcon.appiconset PNG sizes + Contents.json from one logo (sharp, no AI)
kappmaker generate-android-icons Generate all Android mipmap-* launcher icons (5 densities × 3 files) + adaptive icon XML + colors.xml entry (sharp, no AI)
ASO Keyword Research (skill-driven, no binary) — Find high-value keywords with popularity + difficulty scores via Astro MCP, cluster by sub-niche, write AiGuidelines/keywords.md
ASO Metadata Localization (skill-driven, no binary) — Write localized name/subtitle/keywords/description and title/short/full_description files for App Store + Google Play
kappmaker fastlane configure Set up Fastlane in the mobile app directory
kappmaker publish Build and upload to Google Play and/or App Store via Fastlane
kappmaker generate-keystore Generate an Android signing keystore for Play Store releases
kappmaker android-release-build Build a signed Android release AAB
kappmaker refactor Refactor package names, application ID, bundle ID, and app name
kappmaker update-version Bump Android and iOS version codes and version name
kappmaker config Manage CLI settings, API keys, and global defaults

Features

Works with any project

These commands are standalone and don't depend on any specific boilerplate:

  • AI logo generation — Generate logo variations with fal.ai, pick your favorite, auto-remove background
  • AI screenshot generation — Generate marketing screenshots from a text description (8 style presets)
  • Screenshot translation — Translate app screenshots to 48+ locales in parallel
  • ASO keyword research — Skill-driven workflow that discovers high-value sub-niche keywords for a base topic via the Astro MCP tools (real-time App Store popularity + difficulty scores from competitor analysis and AI suggestions), filters them by configurable thresholds, clusters them by sub-niche, and writes AiGuidelines/keywords.md. Falls back to a manual brainstorm when Astro MCP isn't connected. Output feeds directly into the metadata localization workflow below.
  • ASO metadata localization — Skill-driven workflow that writes per-locale name/subtitle/keywords/description (iOS) and title/short_description/full_description (Android) text files with two strategies: US-indexed keyword expansion (English copy with different keywords per locale to multiply indexed surface) or native per-market localization. Char-limits, keyword-field rules, and no-duplicate-word-across-fields are enforced automatically.
  • App Store Connect setup — Register bundle ID (with Sign in with Apple, In-App Purchases, and Push Notifications capabilities enabled automatically), create app, set metadata, categories, age rating, subscriptions, privacy, and review info — fully automated, no manual App Store Connect steps needed
  • Google Play Console setup — Push store listings, subscriptions (new monetization API), one-time in-app products, and the data safety declaration via a built-in wrapper around the Play Publisher API — no external CLI, no extra dependencies
  • Adapty subscription setup — Create products, paywalls, and placements for iOS and Android
  • Version bumping — Increment Android and iOS version codes and names in one command
  • Image tools — Split grids, remove backgrounds, enhance quality, convert to WebP

KAppMaker boilerplate-specific

The create command runs the full end-to-end setup. Some steps assume the KAppMaker project structure and will be skipped with a warning if you use a custom template:

  • Package refactor — Renames package name, app ID, and display name using the TypeScript refactor service (also available standalone via kappmaker refactor)
  • Firebase SDK config placement — Downloads google-services.json and GoogleService-Info.plist to KAppMaker-specific paths (falls back to Assets/ for custom templates)
  • Build environment — Creates local.properties; iOS dependencies resolve via Swift Package Manager at build time (CocoaPods runs only if a custom template still has a Podfile)
  • Android release build — Generates keystore and builds signed AAB (also available standalone via kappmaker android-release-build)
  • Git remotes — Renames origin to upstream (designed for the "fork from template" workflow)
  • Screenshot translation default path — Defaults to MobileApp/distribution/ios/appstore_metadata/screenshots/en-US (falls back to parent of source directory)

Prerequisites

  • Node.js >= 20
  • Git
  • Firebase CLI — npm install -g firebase-tools
  • Fastlane — via Bundler in the template repo
  • Android SDK — installed at ~/Library/Android/sdk (configurable)
  • asc CLI (optional, for App Store Connect) — brew install asc (requires ≥ 1.4.0 as of KAppMaker 1.7.0 for the bulk CSV subscription-pricing path)
  • Adapty CLI (optional, for Adapty setup) — npm install -g adapty
  • No extra CLI for Google Play Console — kappmaker gpc talks to the Play Publisher API directly via Node's built-in fetch and crypto; all it needs is the service-account JSON path set in googleServiceAccountPath

External Services & API Keys

The CLI integrates with several external services for AI image generation, app store management, and subscription setup. All keys are stored locally at ~/.config/kappmaker/config.json.

fal.ai — AI Image Generation

Used for: Logo generation, background removal, image enhancement, screenshot translation, and screenshot generation.

How to get your key:

  1. Sign up at fal.ai
  2. Go to Dashboard > Keys and create an API key
  3. kappmaker config set falApiKey <your-key> — or skip this and the CLI will prompt you the first time you run a command that needs it

ImgBB — Image Hosting

Used for: Temporarily hosting reference images when generating or translating screenshots (fal.ai needs a public URL to process images).

How to get your key:

  1. Sign up at imgbb.com
  2. Go to api.imgbb.com and get your free API key
  3. kappmaker config set imgbbApiKey <your-key> — or prompted on first use

OpenAI — Prompt Generation

Used for: Generating detailed screenshot specifications from a short app description (uses GPT-4.1). Only needed for the generate-screenshots command.

How to get your key:

  1. Sign up at platform.openai.com
  2. Go to API Keys and create a new key
  3. kappmaker config set openaiApiKey <your-key> — or prompted on first use

App Store Connect CLI (asc) — iOS App Management & Publishing

Used for: Creating apps, setting metadata, categories, subscriptions, privacy declarations, and review info on App Store Connect (create-appstore-app). The same API key credentials are also used by publish --platform ios to build and upload IPAs via Fastlane.

How to set up:

  1. Install: brew install asc
  2. Generate an API key at App Store Connect > Users and Access > Integrations > API (Admin role, download the .p8 file immediately)
  3. Configure: 
    kappmaker config set ascKeyId <your-key-id>
kappmaker config set ascIssuerId <your-issuer-id>
kappmaker config set ascPrivateKeyPath /path/to/AuthKey.p8
kappmaker config set appleId [email protected]
    Or run kappmaker config appstore-defaults --init for interactive setup.

Note: kappmaker publish --platform ios uses ascKeyId, ascIssuerId, and ascPrivateKeyPath to automatically generate the Fastlane-format publisher JSON — no separate credentials needed.

Adapty CLI — Subscription Management

Used for: Setting up in-app subscription products, paywalls, and placements across iOS and Android via Adapty's backend.

How to set up:

  1. Install: npm install -g adapty
  2. Log in: adapty auth login (opens browser for authentication)
  3. Run: kappmaker adapty setup

Firebase CLI — Backend Setup

Used for: Creating Firebase projects, registering Android/iOS apps, downloading SDK config files (google-services.json, GoogleService-Info.plist), and enabling anonymous authentication.

How to set up:

  1. Install: npm install -g firebase-tools
  2. The create command handles login and project creation interactively.

Google Play Publisher — Android Store Uploads + Play Console Management

Used for:

  • Building and uploading Android AABs to Google Play Store via kappmaker publish --platform android (Fastlane)
  • Configuring store listings, subscriptions, in-app products, and the data safety declaration via kappmaker gpc ... (direct Publisher API call, no external CLI)

Both flows share the same service account JSON key — set it once, use it everywhere.

How to set up:

  1. Go to Google Cloud Console and create a new project (or select existing)
  2. Open APIs & Services > Library, search for Google Play Android Developer API, and enable it
  3. Go to IAM & Admin > Service Accounts, create a new service account (skip role assignment)
  4. Open the service account, go to Keys, click Add key > Create new key > JSON, and download it
  5. Open Google Play Console, go to Settings > Users and permissions
  6. Click Invite new user with the service account email ([email protected]) and grant permissions for your app(s)
  7. Save the JSON key file and configure: 
    kappmaker config set googleServiceAccountPath /path/to/google-service-app-publisher.json

Note: Google Play does not allow creating new apps via any public API — you must create the app manually once in Play Console before kappmaker gpc can configure it.

App Store Publisher — iOS Store Uploads

Used for: Building and uploading iOS IPAs to App Store Connect, managing App Store metadata and screenshots via kappmaker publish --platform ios.

The publish command reuses the same App Store Connect API key credentials used by create-appstore-app (ascKeyId, ascIssuerId, ascPrivateKeyPath) and automatically generates the Fastlane-format publisher JSON.

How to set up (if not already configured for create-appstore-app):

  1. Open App Store Connect > Users and Access > Integrations
  2. Create an API key with App Manager access and download the .p8 file
  3. Note the Key ID and Issuer ID
  4. Configure: 
    kappmaker config set ascKeyId <your-key-id>
kappmaker config set ascIssuerId <your-issuer-id>
kappmaker config set ascPrivateKeyPath /path/to/AuthKey.p8

create <app-name>

Full end-to-end app bootstrapping. Creates a new KAppMaker app from the template and optionally sets up everything needed to publish.

kappmaker create Remimi

What it does (13 steps):

Step Action Details
1 Clone template Clones into <AppName>-All/ (prompts to overwrite if exists)
2 Firebase login Opens browser for authentication
3 Create Firebase project <appname>-app (skips if exists)
4 Create Firebase apps Android + iOS apps (reuses existing if found)
5 Enable anonymous auth If brand-new project, prompts user to click "Get started" in Firebase Console, then enables via API
6 Download SDK configs google-services.json + GoogleService-Info.plist (verifies package match, falls back to Assets/)
7 Logo generation Optional — AI logo + automatic background removal
8 Package refactor Renames packages, IDs, app name across all modules (shared, androidApp, desktopApp, webApp, designsystem, libs; also walks legacy composeApp/ for pre-rename projects)
9 Build environment local.properties, generates signing keystore if missing (iOS deps resolve via SwiftPM)
10 Git remotes Renames origin to upstream
Pre-store reminder Prompts user to create Google Play Console app; App Store Connect is created automatically
11 App Store Connect Optional — full app setup (metadata, subs, privacy); app created automatically via asc web apps create
12 Google Play Console Optional — Fastlane builds + uploads AAB to internal track, then runs full gpc setup
13 Adapty setup Optional — products, paywalls, placements (links to ASC + Play products created in 11-12)

Options:

Flag Description Default
--template-repo <url> Template repository URL KAppMaker template
--organization <org> Organization for Fastlane signing App name (configurable)

clone <app-name>

Clones the template repository into <AppName>-All. This is step 1 of create exposed as a standalone command — useful when you only want to scaffold a project and apply your own changes (e.g. clone + refactor without Firebase, ASC, etc.).

kappmaker clone Remimi
kappmaker clone Remimi --template-repo [email protected]:my-org/my-template.git
kappmaker clone Remimi --target-dir ./projects/Remimi

What it does:

  1. Validates the app name (PascalCase)
  2. If no config exists at ~/.config/kappmaker/config.json, runs kappmaker config init first
  3. If the target directory already exists, prompts to delete and start fresh
  4. Runs git clone <templateRepo> <targetDir>

Minimal flow — clone + refactor without anything else:

kappmaker clone MyApp
cd MyApp-All/MobileApp
kappmaker refactor --app-id com.example.myapp --app-name MyApp
Flag Description Default
--template-repo <url> Git URL of the template repository templateRepo from config
--target-dir <path> Target directory for the clone <AppName>-All

git setup-upstream

Renames the origin remote to upstream. Step 10 of create as a standalone command — designed for the "fork from template" workflow where the template repo becomes upstream and you add your own origin later.

kappmaker git setup-upstream                    # Run from inside the cloned repo
kappmaker git setup-upstream ./MyApp-All        # Or pass the path explicitly

Exits non-zero if the path is not a git repository.

Argument Description Default
[path] Path to the repo root Current directory

firebase

Five standalone subcommands matching steps 2–6 of create. Run them individually for partial flows (e.g. set up Firebase for an existing project), or together to replicate what create does.

kappmaker firebase login
kappmaker firebase project --app-name MyApp                # derives project-id = myapp-app, display = MyApp
kappmaker firebase project --project-id myapp-prod --display-name MyApp  # explicit
kappmaker firebase apps --project myapp-app --app-name MyApp --package-name com.example.myapp
kappmaker firebase auth-anonymous --project myapp-app
kappmaker firebase configs --project myapp-app --app-name MyApp --package-name com.example.myapp

firebase login

Runs firebase login (interactive). No args.

firebase project

Creates the Firebase project. Idempotent — if the project already exists it skips creation. Returns success/failure to the orchestrator (controls whether create proceeds with steps 4–6).

Flag Description Required
--project-id <id> Firebase project ID (e.g. myapp-app) Yes, unless --app-name is set
--display-name <name> Project display name Defaults to --project-id or --app-name
--app-name <name> PascalCase app name; derives project-id = <lowercase>-app and display-name = <name> Yes, unless explicit IDs are passed

firebase apps

Creates an Android + iOS app under the project. Idempotent — reuses existing apps that match the display name ${appName} (Android App) / ${appName} (iOS App).

Flag Description Required
--project <id> Firebase project ID Yes
--app-name <name> PascalCase display name (used to label the apps) Yes
--package-name <pkg> Android applicationId and iOS bundle ID (e.g. com.example.myapp) Yes

firebase auth-anonymous

Enables anonymous authentication via the Identity Toolkit Admin API. If Firebase Auth has never been initialized for the project, the command pauses and asks you to click "Get started" in the Firebase Console, then retries automatically.

Flag Description Required
--project <id> Firebase project ID Yes

firebase configs

Downloads google-services.json and GoogleService-Info.plist for the Android + iOS apps and writes them to the right place. Apps are looked up via --app-name (display name match) unless you pass --android-app-id / --ios-app-id directly.

Output auto-detection (when --android-output / --ios-output aren't given): probes MobileApp/androidApp/google-services.json, then MobileApp/composeApp/google-services.json, then falls back to Assets/google-services.json. Same for iOS — MobileApp/iosApp/iosApp/GoogleService-Info.plist if it exists, otherwise Assets/GoogleService-Info.plist.

When --package-name is provided, the downloaded google-services.json is verified against the expected package name and patched in-place if it doesn't match (handles cases where the Firebase app was registered with an older bundleIdPrefix).

Flag Description Required
--project <id> Firebase project ID Yes
--app-name <name> PascalCase display name (used to find the apps if app IDs aren't given) Yes
--package-name <pkg> Verify and fix the Android google-services.json package name No
--android-app-id <id> Skip lookup and use this Firebase App ID directly No
--ios-app-id <id> Skip lookup and use this Firebase App ID directly No
--android-output <path> Output path for google-services.json Auto-detect
--ios-output <path> Output path for GoogleService-Info.plist Auto-detect

create-logo

Generates an app logo using fal.ai's nano-banana-2 model.

kappmaker create-logo
kappmaker create-logo --prompt "A minimalist fitness tracker for runners"
kappmaker create-logo --output ./custom/path/logo.png

Flow:

  1. Reads app idea from --prompt (or prompts interactively if omitted)
  2. Generates a 4x4 grid of 16 logo variations (2K, 1:1)
  3. Opens grid in Preview.app for review
  4. Pick a logo (1-16) or R to regenerate — optional: 5 --zoom 1.1 --gap 3
  5. Extracts chosen logo at 512x512

Output: Assets/app_logo.png + Assets/logo_variations.png

Requires a fal.ai API key (prompted on first use if not set, or set manually: kappmaker config set falApiKey <your-key>)

Flag Description Default
--prompt <text> App idea / concept (skips the interactive prompt) —
--output <path> Custom output path Assets/app_logo.png

generate-image

Generic AI image generator — a thin wrapper around fal.ai's nano-banana-2 (text-to-image) and nano-banana-2/edit (with reference images). Use this any time you need a one-off image without the logo-grid selection flow.

kappmaker generate-image --prompt "A minimalist mountain landscape at sunset"
kappmaker generate-image --prompt "Hero banner for a meditation app" --aspect-ratio 16:9 --resolution 4K
kappmaker generate-image --prompt "Product render" --num-images 4 --output Assets/hero
kappmaker generate-image --prompt "Put this logo on a black t-shirt" --reference Assets/app_logo.png
kappmaker generate-image --prompt "Blend these into a single composition" --reference Assets/moodboard
kappmaker generate-image --prompt "Match this product shot" --reference https://example.com/ref.jpg

Reference images (edit mode): Passing --reference switches the endpoint from nano-banana-2 (text-to-image) to nano-banana-2/edit (reference-guided). Each entry can be a file path, a directory (all png/jpg/jpeg/webp inside are picked up, sorted, non-recursive), or an HTTP(S) URL. Max 10 references total. If imgbbApiKey is configured, local files are uploaded to imgbb for reliable URLs; otherwise they are sent inline as data URIs (fine for small images, can fail on very large ones).

Output path behavior:

  • No --output → Assets/generated.png (single) or Assets/generated_1.png, _2.png… (multi)
  • --output <dir> (no extension) → saves into that directory
  • --output <file.png> → single image uses path verbatim; multi-image appends _1, _2 before extension

Requires a fal.ai API key (prompted on first use if not set).

Flag Description Default
--prompt <text> Text description of the image (required) —
--output <path> Output file or directory Assets/generated.png
--num-images <n> Number of images to generate (1–8) 1
--aspect-ratio <ratio> 1:1, 16:9, 9:16, 4:3, 3:4, 3:2, 2:3, 21:9, 9:21, auto 1:1
--resolution <res> 1K, 2K, 4K 2K
--output-format <fmt> png, jpg, webp png
--reference <paths...> Reference images — file paths, directories, or HTTP URLs (edit mode, max 10) —

create-appstore-app

Creates and fully configures an app on App Store Connect using the asc CLI. Requires asc ≥ 1.4.0.

kappmaker create-appstore-app
kappmaker create-appstore-app --config ./my-config.json

First-time setup

  1. Generate an API key at App Store Connect > Users and Access > Integrations > API — Admin access, download the .p8 file immediately
  2. Run one-time setup: 
    kappmaker config appstore-defaults --init

What it does (13 steps)

  1. Validate asc CLI and authentication
  2. Load config (from file or interactive prompts)
  3. Register Bundle ID + enable capabilities (Sign in with Apple, In-App Purchases, Push Notifications). Name follows Apple convention: XC com measify myapp for com.measify.myapp
  4. Find or create app (fully automated via asc web apps create — no manual App Store Connect step needed)
  5. Set content rights
  6. Create app version (1.0.0)
  7. Set categories
  8. Set age rating
  9. Update localizations
  10. Set pricing, availability, and subscriptions
  11. Set privacy data usages
  12. Set encryption declarations
  13. Set review contact details

Config resolution

Layers are deep-merged (later overrides earlier):

  1. Built-in template — age rating, privacy, encryption, subscriptions
  2. Global defaults (~/.config/kappmaker/appstore-defaults.json) — review contact, copyright
  3. Local config (./Assets/appstore-config.json or --config)
  4. Interactive prompts — only for fields still empty

Default subscriptions

Subscription Period Price Product ID
Weekly Premium ONE_WEEK $6.99 {appname}.premium.weekly.v1.699.v1
Yearly Premium ONE_YEAR $29.99 {appname}.premium.yearly.v1.2999.v1

Auto-generated naming: group {appname}.premium.v1, ref name {AppName} Premium Weekly v1 (6.99).

Per-territory PPP pricing (1.7.0+ — bulk CSV import)

Subscriptions and IAPs are fanned out to every ASC territory (~175) with purchasing-power-parity-adjusted prices in a single API call per product. Requires asc CLI ≥ 1.4.0 (brew upgrade asc).

  • Subscriptions (1.7.0+): asc subscriptions pricing prices import --input <csv>. KAppMaker writes a temp CSV with territory,price,price_point_id rows for all ~175 territories and pipes it in. Replaces the 155-call loop from 1.6.x which hit Apple's rate limits.
  • IAPs: a single asc iap pricing schedules create --prices "PP_ID:DATE,…" call covers all territories (unchanged).

Set "ppp_enabled": false on any subscription or IAP to opt out and keep only your explicitly-listed prices. User-listed territory prices are always preserved (they win the merge).

Tier resolution: Apple's price-point catalog uses globally-stable tier numbers (1..800 — tier N = the same USD-equivalent across every territory). KAppMaker resolves each unique PPP USD target → tier ONCE via USA's catalog (where customerPrice is in USD), then synthesises per-territory price-point IDs locally using Apple's base64 {s, t, p} format. Critical fix vs 1.6.x: the old code compared a USD target against local-currency price-points (e.g. ¥, ₩, ₹) and ended up picking the FREE tier — products silently landed at $0 in JPN/IDR/INR/KRW/etc. The new tier-based resolution avoids that entirely.

Distinct catalogs: subscriptions use subscriptionPricePoints (CLI: asc subscriptions pricing price-points list) while IAPs use appPricePoints (CLI: asc pricing price-points). Their s (catalog identifier) fields differ — mixing IDs across catalogs returns 400 The provided entity is invalid.

Idempotent re-runs: when setup reports "already been used", KAppMaker now logs existing — refreshing pricing and continues into the PPP fan-out so re-runs actually update territory pricing (1.6.x silently skipped).

App Review screenshots (1.7.1+)

Apple requires a review screenshot on every subscription and IAP — without one, products remain in MISSING_METADATA state and per-territory pricing won't "resolve". KAppMaker uploads it automatically when you set review_screenshot in the config:

{
  "review_screenshot": "Assets/appstore/review-screenshot.png",
  "subscriptions": {
    "groups": [{
      "subscriptions": [{
        "ref_name": "Premium Weekly",
        "review_screenshot": "Assets/appstore/weekly-review.png"
      }]
    }]
  },
  "in_app_purchases": [{
    "product_id": "credit_pack_10_499_myapp",
    "review_screenshot": "Assets/appstore/iap-review.png"
  }]
}
  • Global default: review_screenshot at the top level applies to every sub + IAP.
  • Per-product override: each subscription / IAP can specify its own path.
  • Idempotent: re-runs check view / images list first and skip if a screenshot is already attached. Delete via Apple's UI to force a re-upload.
  • Silent skip on missing file: if the path doesn't resolve to an existing file, KAppMaker logs and moves on — no error.

Under the hood: asc subscriptions review screenshots create --file <path> for subs and asc iap images create --file <path> for IAPs.

Required size + auto-resize prompt

Apple's recommended size for App Review screenshots is 1290 × 2796 px (iPhone 6.7" Display, portrait — matches App Store listing screenshot dimensions). Minimum: 640 × 920 px. Format: PNG or JPG.

If the file's dimensions don't match 1290 × 2796, KAppMaker prompts:

WARN Review screenshot wrong-size.png is 1920×1080.
-- Apple's App Store recommended size for review screenshots: 1290×2796 (iPhone 6.7" Display, portrait).
  Resize to 1290×2796 keeping aspect ratio? (Y/n)
  • Y (default) — sharp resizes the file with fit: 'inside' (preserves aspect ratio, may end up smaller than the target on the constraining dimension; e.g. a 1920 × 1080 input becomes 1290 × 726). Writes to a temp file. Uploads the resized copy.
  • N — uploads the file as-is. Apple may still accept it (the rule is just min 640 × 920) but the aspect ratio won't match typical iPhone screenshots.

Files that are already 1290 × 2796 skip the prompt entirely.

Standalone replace commands

Two top-level appstore- prefixed commands replace existing screenshots without running the full create-appstore-app flow:

# Replace the review screenshot on EVERY subscription in the config
kappmaker appstore-update-subscription-review-screenshot --file ./Assets/appstore/new-review.png

# Replace the review image on EVERY IAP
kappmaker appstore-update-iap-review-screenshot --file ./Assets/appstore/iap-review.png

# Without --file, the commands use the per-product `review_screenshot` from the config
kappmaker appstore-update-subscription-review-screenshot
kappmaker appstore-update-iap-review-screenshot

# Target a single product
kappmaker appstore-update-iap-review-screenshot \
    --file ./Assets/appstore/credit-pack-30.png \
    --product-id credit_pack_30_999_myapp
Flag Description
--file <path> Single screenshot applied to all matched products. Overrides per-product review_screenshot from the config.
--config <path> Override default ./Assets/appstore-config.json.
--product-id <id> Target ONE product (matches by product_id or ref_name).

These commands force-replace existing screenshots (delete + create under the hood — empirically asc … update doesn't actually swap the binary). The setup-flow upload in create-appstore-app remains idempotent (skips when one is already attached).

Default in-app purchases (credit packs)

The template also ships three CONSUMABLE in-app purchases shaped as credit packs. Auto-fill triggers on any in_app_purchases[] entry with a credits numeric field.

Pack Credits Price Product ID
Basic Credit Pack 10 $4.99 credit_pack_10_499_{appname}
Pro Credit Pack 30 $9.99 credit_pack_30_999_{appname}
Ultimate Credit Pack 80 $19.99 credit_pack_80_1999_{appname}

Format: credit_pack_{credits}_{priceDigits}_{appname}. The same ID is used on Google Play and Adapty so app code can reference one constant per platform pair.

Created via