@daemux/store-automator 0.10.52 → 0.10.54

package/.claude-plugin/marketplace.json

@@ -5,20 +5,15 @@
   },
   "metadata": {
     "description": "App Store & Google Play automation for Flutter apps",
-    "version": "0.10.52"
+    "version": "0.10.37"
   },
   "plugins": [
     {
       "name": "store-automator",
       "source": "./plugins/store-automator",
       "description": "3 agents for app store publishing: reviewer, meta-creator, media-designer",
-      "version": "0.10.52",
-      "keywords": [
-        "flutter",
-        "app-store",
-        "google-play",
-        "fastlane"
-      ]
+      "version": "0.10.37",
+      "keywords": ["flutter", "app-store", "google-play", "fastlane"]
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daemux/store-automator",
-  "version": "0.10.52",
+  "version": "0.10.54",
   "description": "Full App Store & Google Play automation for Flutter apps with Claude Code agents",
   "type": "module",
   "bin": {

package/plugins/store-automator/.claude-plugin/plugin.json

@@ -1,16 +1,9 @@
 {
   "name": "store-automator",
-  "version": "0.10.52",
+  "version": "0.10.54",
   "description": "App Store & Google Play automation agents for Flutter app publishing",
   "author": {
     "name": "Daemux"
   },
-  "keywords": [
-    "flutter",
-    "app-store",
-    "google-play",
-    "fastlane",
-    "screenshots",
-    "metadata"
-  ]
+  "keywords": ["flutter", "app-store", "google-play", "fastlane", "screenshots", "metadata"]
 }

package/templates/github/workflows/ios-release.yml

@@ -47,6 +47,9 @@ jobs:
       - name: Install Python dependencies
         run: pip3 install --break-system-packages requests PyJWT
 
+      - name: Ensure App Exists
+        run: scripts/ci/ios/ensure-app-exists.sh
+
       - name: Upload Metadata & Screenshots
         id: upload-metadata
         run: scripts/ci/ios/upload-metadata.sh

package/templates/scripts/asc_subscription_submit.py

@@ -0,0 +1,74 @@
+"""App Store Connect Subscription Review Submission API layer.
+
+Functions for submitting subscriptions and subscription groups for App Store review.
+"""
+import sys
+
+try:
+    import requests
+except ImportError:
+    import subprocess
+    subprocess.check_call(
+        [sys.executable, "-m", "pip", "install", "--break-system-packages", "requests"],
+        stdout=subprocess.DEVNULL,
+    )
+    import requests
+
+from asc_iap_api import BASE_URL, TIMEOUT, print_api_errors
+
+
+def create_review_submission(
+    headers: dict, sub_id: str, reviewer_notes: str = "",
+) -> dict | None:
+    """Submit a subscription for App Store review.
+
+    Idempotent: silently handles 409 Conflict (already submitted).
+    """
+    resp = requests.post(
+        f"{BASE_URL}/subscriptionAppStoreReviewSubmissions",
+        json={"data": {
+            "type": "subscriptionAppStoreReviewSubmissions",
+            "attributes": {"reviewerNotes": reviewer_notes} if reviewer_notes else {},
+            "relationships": {
+                "subscription": {"data": {"type": "subscriptions", "id": sub_id}},
+            },
+        }},
+        headers=headers,
+        timeout=TIMEOUT,
+    )
+    if resp.status_code == 409:
+        return None
+    if not resp.ok:
+        print_api_errors(resp, f"submit subscription {sub_id} for review")
+        return None
+    print(f"      Submitted subscription {sub_id} for review")
+    return resp.json().get("data")
+
+
+def create_group_submission(
+    headers: dict, group_id: str,
+) -> dict | None:
+    """Submit a subscription group for App Store review.
+
+    Idempotent: silently handles 409 Conflict (already submitted).
+    """
+    resp = requests.post(
+        f"{BASE_URL}/subscriptionGroupSubmissions",
+        json={"data": {
+            "type": "subscriptionGroupSubmissions",
+            "relationships": {
+                "subscriptionGroup": {
+                    "data": {"type": "subscriptionGroups", "id": group_id},
+                },
+            },
+        }},
+        headers=headers,
+        timeout=TIMEOUT,
+    )
+    if resp.status_code == 409:
+        return None
+    if not resp.ok:
+        print_api_errors(resp, f"submit group {group_id} for review")
+        return None
+    print(f"    Submitted subscription group {group_id} for review")
+    return resp.json().get("data")

package/templates/scripts/ci/ios/ensure-app-exists.sh

@@ -0,0 +1,50 @@
+#!/usr/bin/env bash
+# Ensures the app exists in App Store Connect (registers bundle ID, creates
+# app record, sets content rights and pricing). Fully idempotent.
+# Requires read-config.sh to have been sourced (provides PROJECT_ROOT, credentials, etc.).
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/../common/read-config.sh"
+source "$SCRIPT_DIR/../common/ci-notify.sh"
+
+echo "=== Ensure App Exists in App Store Connect ==="
+
+# --- Validate ASC credentials ---
+if [ -z "${APPLE_KEY_ID:-}" ] || [ -z "${APPLE_ISSUER_ID:-}" ]; then
+  ci_skip "ASC credentials not configured"
+fi
+
+if [ -z "${BUNDLE_ID:-}" ] || [ -z "${APP_NAME:-}" ]; then
+  ci_skip "BUNDLE_ID or APP_NAME not set in ci.config.yaml"
+fi
+
+# --- Set up App Store Connect API credentials ---
+P8_FULL_PATH="$PROJECT_ROOT/$P8_KEY_PATH"
+if [ ! -f "$P8_FULL_PATH" ]; then
+  echo "ERROR: P8 key file not found at $P8_FULL_PATH" >&2
+  exit 1
+fi
+
+export APP_STORE_CONNECT_KEY_IDENTIFIER="$APPLE_KEY_ID"
+export APP_STORE_CONNECT_ISSUER_ID="$APPLE_ISSUER_ID"
+export APP_STORE_CONNECT_PRIVATE_KEY="$(cat "$P8_FULL_PATH")"
+export BUNDLE_ID="$BUNDLE_ID"
+export APP_NAME="$APP_NAME"
+export SKU="${SKU:-$BUNDLE_ID}"
+export PLATFORM="${PLATFORM:-IOS}"
+
+echo "ASC API key configured (Key ID: $APPLE_KEY_ID)"
+
+# --- Run ensure-app-exists via Python ---
+CREATE_SCRIPT="$PROJECT_ROOT/scripts/create_app_record.py"
+
+if [ ! -f "$CREATE_SCRIPT" ]; then
+  echo "ERROR: create_app_record.py not found at $CREATE_SCRIPT" >&2
+  exit 1
+fi
+
+echo "Ensuring app exists in App Store Connect..."
+python3 "$CREATE_SCRIPT"
+
+ci_done "App exists and is configured in App Store Connect"

package/templates/scripts/ci/ios/sync-iap.sh

@@ -20,6 +20,7 @@ fi
 CURRENT_HASH=$(cat "$IAP_CONFIG" \
   "$PROJECT_ROOT/scripts/sync_iap_ios.py" \
   "$PROJECT_ROOT/scripts/asc_subscription_setup.py" \
+  "$PROJECT_ROOT/scripts/asc_subscription_submit.py" \
   "$PROJECT_ROOT/scripts/asc_iap_api.py" \
   | shasum -a 256 | cut -d' ' -f1)
 

package/templates/scripts/create_app_record.py

@@ -1,9 +1,12 @@
 #!/usr/bin/env python3
 """
-Create an App Store Connect app record via the direct API.
+Ensure an App Store Connect app exists with correct configuration.
 
-Looks up the Bundle ID resource, then creates a new app record
-with the specified name, SKU, and primary locale.
+Fully idempotent flow:
+  1. Register Bundle ID on the Developer Portal (skip if exists)
+  2. Create App Record in App Store Connect (skip if exists)
+  3. Set content rights declaration (via asc_app_setup)
+  4. Set app pricing schedule (via asc_app_setup)
 
 Required env vars:
   APP_STORE_CONNECT_KEY_IDENTIFIER  - Key ID from App Store Connect
@@ -11,10 +14,15 @@ Required env vars:
   APP_STORE_CONNECT_PRIVATE_KEY     - Contents of the P8 key file
   BUNDLE_ID                         - App bundle identifier (e.g. com.daemux.gigachat)
   APP_NAME                          - Display name for the app
-  SKU                               - Unique SKU string for the app
+  SKU                               - Unique SKU string (defaults to BUNDLE_ID)
+
+Optional env vars:
+  PLATFORM                          - "IOS" or "UNIVERSAL" (default: "IOS")
+  CONTENT_RIGHTS_THIRD_PARTY        - "true" if app uses third-party content (default: "false")
+  PRICE_TIER                        - Price tier integer (default: "0" for free)
 
 Exit codes:
-  0 - App record created successfully
+  0 - App ready (created or already existed)
   1 - Any failure (missing env vars, API error, etc.)
 """
 import json
@@ -35,6 +43,10 @@ except ImportError:
     import jwt
     import requests
 
+# Import content rights and pricing from asc_app_setup (same directory)
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from asc_app_setup import print_api_errors, set_content_rights, set_app_pricing  # noqa: E402
+
 BASE_URL = "https://api.appstoreconnect.apple.com/v1"
 TIMEOUT = (10, 30)
 
@@ -48,13 +60,53 @@ def get_jwt_token(key_id: str, issuer_id: str, private_key: str) -> str:
         "exp": now + 1200,
         "aud": "appstoreconnect-v1",
     }
-    return jwt.encode(
-        payload, private_key, algorithm="ES256", headers={"kid": key_id}
+    return jwt.encode(payload, private_key, algorithm="ES256", headers={"kid": key_id})
+
+
+def ensure_bundle_id(headers: dict, bundle_id: str, app_name: str, platform: str) -> str:
+    """Register a Bundle ID if it does not exist. Returns the resource ID."""
+    resp = requests.get(
+        f"{BASE_URL}/bundleIds",
+        params={"filter[identifier]": bundle_id},
+        headers=headers,
+        timeout=TIMEOUT,
     )
+    resp.raise_for_status()
+    data = resp.json().get("data", [])
+    if data:
+        resource_id = data[0]["id"]
+        print(f"  Bundle ID already registered: {resource_id}")
+        return resource_id
+
+    print(f"  Registering new Bundle ID '{bundle_id}' (platform: {platform})...")
+    post_resp = requests.post(
+        f"{BASE_URL}/bundleIds",
+        json={
+            "data": {
+                "type": "bundleIds",
+                "attributes": {
+                    "identifier": bundle_id,
+                    "name": app_name,
+                    "platform": platform,
+                },
+            }
+        },
+        headers=headers,
+        timeout=TIMEOUT,
+    )
+    if post_resp.status_code == 409:
+        print("  Bundle ID already exists (409 Conflict), re-fetching...")
+        return _refetch_bundle_id(headers, bundle_id)
+    if not post_resp.ok:
+        print_api_errors(post_resp, "register bundle ID")
+        sys.exit(1)
+    resource_id = post_resp.json()["data"]["id"]
+    print(f"  Bundle ID registered: {resource_id}")
+    return resource_id
 
 
-def lookup_bundle_id_resource(headers: dict, bundle_id: str) -> str:
-    """Look up the Bundle ID resource ID for the given identifier."""
+def _refetch_bundle_id(headers: dict, bundle_id: str) -> str:
+    """Re-fetch a bundle ID resource after a 409 conflict."""
     resp = requests.get(
         f"{BASE_URL}/bundleIds",
         params={"filter[identifier]": bundle_id},
@@ -64,15 +116,24 @@ def lookup_bundle_id_resource(headers: dict, bundle_id: str) -> str:
     resp.raise_for_status()
     data = resp.json().get("data", [])
     if not data:
-        print(
-            f"ERROR: No Bundle ID found for identifier '{bundle_id}'. "
-            "Register it in App Store Connect > Certificates, Identifiers & Profiles first.",
-            file=sys.stderr,
-        )
+        print(f"ERROR: Bundle ID '{bundle_id}' not found after 409 conflict.", file=sys.stderr)
         sys.exit(1)
     return data[0]["id"]
 
 
+def _lookup_existing_app(headers: dict, bundle_id: str) -> dict | None:
+    """Look up an existing app by bundle ID. Returns app data dict or None."""
+    resp = requests.get(
+        f"{BASE_URL}/apps",
+        params={"filter[bundleId]": bundle_id},
+        headers=headers,
+        timeout=TIMEOUT,
+    )
+    resp.raise_for_status()
+    data = resp.json().get("data", [])
+    return data[0] if data else None
+
+
 def create_app_record(
     headers: dict,
     bundle_id: str,
@@ -80,7 +141,18 @@ def create_app_record(
     app_name: str,
     sku: str,
 ) -> dict:
-    """Create a new app record in App Store Connect."""
+    """Create or retrieve an existing app record in App Store Connect."""
+    existing = _lookup_existing_app(headers, bundle_id)
+    if existing:
+        app_info = {
+            "app_id": existing["id"],
+            "name": existing["attributes"]["name"],
+            "bundle_id": existing["attributes"]["bundleId"],
+            "sku": existing["attributes"]["sku"],
+        }
+        print(f"  App already exists: {json.dumps(app_info)}")
+        return existing
+
     payload = {
         "data": {
             "type": "apps",
@@ -92,80 +164,87 @@ def create_app_record(
             },
             "relationships": {
                 "bundleId": {
-                    "data": {
-                        "type": "bundleIds",
-                        "id": bundle_id_resource_id,
-                    }
+                    "data": {"type": "bundleIds", "id": bundle_id_resource_id}
                 }
             },
         }
     }
-    resp = requests.post(
-        f"{BASE_URL}/apps",
-        json=payload,
-        headers=headers,
-        timeout=TIMEOUT,
-    )
+    resp = requests.post(f"{BASE_URL}/apps", json=payload, headers=headers, timeout=TIMEOUT)
     if resp.status_code == 409:
-        print(
-            f"ERROR: An app with bundle ID '{bundle_id}' already exists.",
-            file=sys.stderr,
-        )
+        print("  App creation returned 409, fetching existing record...")
+        existing = _lookup_existing_app(headers, bundle_id)
+        if existing:
+            return existing
+        print("ERROR: App creation returned 409 but app not found.", file=sys.stderr)
         sys.exit(1)
     if not resp.ok:
-        errors = resp.json().get("errors", [])
-        for err in errors:
-            print(f"ERROR: {err.get('detail', err.get('title', 'Unknown'))}", file=sys.stderr)
+        print_api_errors(resp, "create app record")
         sys.exit(1)
     return resp.json()["data"]
 
 
-def main() -> None:
+def validate_env_vars() -> dict:
+    """Validate and return all required/optional env vars as a dict."""
     key_id = os.environ.get("APP_STORE_CONNECT_KEY_IDENTIFIER", "")
     issuer_id = os.environ.get("APP_STORE_CONNECT_ISSUER_ID", "")
     private_key = os.environ.get("APP_STORE_CONNECT_PRIVATE_KEY", "")
     bundle_id = os.environ.get("BUNDLE_ID", "")
     app_name = os.environ.get("APP_NAME", "")
-    sku = os.environ.get("SKU", "")
-
-    missing = []
-    if not key_id:
-        missing.append("APP_STORE_CONNECT_KEY_IDENTIFIER")
-    if not issuer_id:
-        missing.append("APP_STORE_CONNECT_ISSUER_ID")
-    if not private_key:
-        missing.append("APP_STORE_CONNECT_PRIVATE_KEY")
-    if not bundle_id:
-        missing.append("BUNDLE_ID")
-    if not app_name:
-        missing.append("APP_NAME")
-    if not sku:
-        missing.append("SKU")
-
+    sku = os.environ.get("SKU", "") or bundle_id
+
+    required = {
+        "APP_STORE_CONNECT_KEY_IDENTIFIER": key_id,
+        "APP_STORE_CONNECT_ISSUER_ID": issuer_id,
+        "APP_STORE_CONNECT_PRIVATE_KEY": private_key,
+        "BUNDLE_ID": bundle_id,
+        "APP_NAME": app_name,
+    }
+    missing = [k for k, v in required.items() if not v]
     if missing:
         print(f"ERROR: Missing required environment variables: {', '.join(missing)}", file=sys.stderr)
         sys.exit(1)
 
-    token = get_jwt_token(key_id, issuer_id, private_key)
-    headers = {
-        "Authorization": f"Bearer {token}",
-        "Content-Type": "application/json",
+    platform = os.environ.get("PLATFORM", "IOS")
+    if platform not in ("IOS", "UNIVERSAL"):
+        print(f"ERROR: PLATFORM must be 'IOS' or 'UNIVERSAL', got '{platform}'", file=sys.stderr)
+        sys.exit(1)
+
+    price_tier_str = os.environ.get("PRICE_TIER", "0")
+    try:
+        price_tier = int(price_tier_str)
+    except ValueError:
+        print(f"ERROR: PRICE_TIER must be an integer, got '{price_tier_str}'", file=sys.stderr)
+        sys.exit(1)
+
+    return {
+        "key_id": key_id, "issuer_id": issuer_id, "private_key": private_key,
+        "bundle_id": bundle_id, "app_name": app_name, "sku": sku,
+        "platform": platform, "price_tier": price_tier,
+        "uses_third_party": os.environ.get("CONTENT_RIGHTS_THIRD_PARTY", "false").lower() == "true",
     }
 
-    print(f"Looking up Bundle ID resource for '{bundle_id}'...")
-    bundle_id_resource_id = lookup_bundle_id_resource(headers, bundle_id)
-    print(f"Found Bundle ID resource: {bundle_id_resource_id}")
 
-    print(f"Creating app record '{app_name}' (SKU: {sku})...")
-    app_data = create_app_record(headers, bundle_id, bundle_id_resource_id, app_name, sku)
+def main() -> None:
+    """Orchestrate the full app creation and configuration flow."""
+    cfg = validate_env_vars()
+    token = get_jwt_token(cfg["key_id"], cfg["issuer_id"], cfg["private_key"])
+    headers = {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
 
-    result = {
-        "app_id": app_data["id"],
-        "name": app_data["attributes"]["name"],
-        "bundle_id": app_data["attributes"]["bundleId"],
-        "sku": app_data["attributes"]["sku"],
-    }
-    print(f"App record created successfully: {json.dumps(result)}")
+    print(f"Step 1: Ensuring Bundle ID '{cfg['bundle_id']}' is registered...")
+    bundle_id_resource_id = ensure_bundle_id(headers, cfg["bundle_id"], cfg["app_name"], cfg["platform"])
+
+    print(f"Step 2: Ensuring app record '{cfg['app_name']}' (SKU: {cfg['sku']}) exists...")
+    app_data = create_app_record(headers, cfg["bundle_id"], bundle_id_resource_id, cfg["app_name"], cfg["sku"])
+    app_id = app_data["id"]
+    print(f"  App ID: {app_id}")
+
+    print("Step 3: Setting content rights declaration...")
+    set_content_rights(headers, app_id, cfg["uses_third_party"])
+
+    print("Step 4: Setting app pricing...")
+    set_app_pricing(headers, app_id, cfg["price_tier"])
+
+    print(f"All done. App '{cfg['app_name']}' ({cfg['bundle_id']}) is ready.")
 
 
 if __name__ == "__main__":

package/templates/scripts/sync_iap_ios.py

@@ -52,6 +52,10 @@ from asc_subscription_setup import (
     list_all_territory_ids,
     upload_review_screenshot,
 )
+from asc_subscription_submit import (
+    create_group_submission,
+    create_review_submission,
+)
 
 CURRENCY_TO_TERRITORY = {
     "USD": "USA", "EUR": "FRA", "GBP": "GBR", "JPY": "JPN",
@@ -155,8 +159,10 @@ def sync_subscription_group(
         )
         if not resp.ok:
             print_api_errors(resp, f"touch subscription {sub_id}")
+        create_review_submission(headers, sub_id)
         sub_results.append({"product_id": sub_config["product_id"], "id": sub_id})
 
+    create_group_submission(headers, group_id)
     return {"group": ref_name, "group_id": group_id, "subscriptions": sub_results}