@daemux/store-automator 0.10.23 → 0.10.25

package/.claude-plugin/marketplace.json

@@ -5,14 +5,14 @@
   },
   "metadata": {
     "description": "App Store & Google Play automation for Flutter apps",
-    "version": "0.10.23"
+    "version": "0.10.25"
   },
   "plugins": [
     {
       "name": "store-automator",
       "source": "./plugins/store-automator",
       "description": "3 agents for app store publishing: reviewer, meta-creator, media-designer",
-      "version": "0.10.23",
+      "version": "0.10.25",
       "keywords": [
         "flutter",
         "app-store",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daemux/store-automator",
-  "version": "0.10.23",
+  "version": "0.10.25",
   "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,6 +1,6 @@
 {
   "name": "store-automator",
-  "version": "0.10.23",
+  "version": "0.10.25",
   "description": "App Store & Google Play automation agents for Flutter app publishing",
   "author": {
     "name": "Daemux"

package/templates/fastlane/iap_config.json.template

@@ -20,6 +20,10 @@
           "prices": {
             "USD": "9.99"
           },
+          "availability": {
+            "available_in_new_territories": true
+          },
+          "review_screenshot": "fastlane/screenshots/review/subscription_review.png",
           "introductory_offer": {
             "type": "FREE",
             "duration": "ONE_WEEK",
@@ -40,6 +44,10 @@
           "prices": {
             "USD": "69.99"
           },
+          "availability": {
+            "available_in_new_territories": true
+          },
+          "review_screenshot": "fastlane/screenshots/review/subscription_review.png",
           "introductory_offer": {
             "type": "FREE",
             "duration": "ONE_MONTH",

package/templates/scripts/asc_subscription_setup.py

@@ -0,0 +1,268 @@
+"""
+App Store Connect Subscription Setup API layer.
+
+Functions for managing subscription availability (territories),
+pricing (price points), and review screenshot uploads.
+"""
+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
+
+
+# ---------------------------------------------------------------------------
+# Availability
+# ---------------------------------------------------------------------------
+
+def get_subscription_availability(headers: dict, sub_id: str) -> dict | None:
+    """Fetch current availability settings for a subscription."""
+    resp = requests.get(
+        f"{BASE_URL}/subscriptions/{sub_id}/subscriptionAvailability",
+        headers=headers,
+        timeout=TIMEOUT,
+    )
+    if not resp.ok:
+        if resp.status_code == 404:
+            return None
+        print_api_errors(resp, f"get availability for subscription {sub_id}")
+        return None
+    return resp.json().get("data")
+
+
+def create_subscription_availability(
+    headers: dict,
+    sub_id: str,
+    territory_ids: list[str],
+    available_in_new: bool = True,
+) -> dict | None:
+    """Create availability with specified territories for a subscription."""
+    territory_data = [
+        {"type": "territories", "id": tid} for tid in territory_ids
+    ]
+    resp = requests.post(
+        f"{BASE_URL}/subscriptionAvailabilities",
+        json={
+            "data": {
+                "type": "subscriptionAvailabilities",
+                "attributes": {
+                    "availableInNewTerritories": available_in_new,
+                },
+                "relationships": {
+                    "subscription": {
+                        "data": {"type": "subscriptions", "id": sub_id},
+                    },
+                    "availableTerritories": {
+                        "data": territory_data,
+                    },
+                },
+            }
+        },
+        headers=headers,
+        timeout=TIMEOUT,
+    )
+    if not resp.ok:
+        print_api_errors(resp, f"create availability for subscription {sub_id}")
+        return None
+    print(f"    Set availability for subscription {sub_id} ({len(territory_ids)} territories)")
+    return resp.json().get("data")
+
+
+# ---------------------------------------------------------------------------
+# Pricing
+# ---------------------------------------------------------------------------
+
+def get_subscription_prices(headers: dict, sub_id: str) -> list:
+    """List existing prices for a subscription."""
+    resp = requests.get(
+        f"{BASE_URL}/subscriptions/{sub_id}/prices",
+        params={"include": "subscriptionPricePoint"},
+        headers=headers,
+        timeout=TIMEOUT,
+    )
+    if not resp.ok:
+        print_api_errors(resp, f"get prices for subscription {sub_id}")
+        return []
+    return resp.json().get("data", [])
+
+
+def get_price_points_for_territory(
+    headers: dict, sub_id: str, territory: str,
+) -> list:
+    """Get available price points for a subscription in a given territory."""
+    resp = requests.get(
+        f"{BASE_URL}/subscriptions/{sub_id}/pricePoints",
+        params={
+            "filter[territory]": territory,
+            "include": "territory",
+        },
+        headers=headers,
+        timeout=TIMEOUT,
+    )
+    if not resp.ok:
+        print_api_errors(resp, f"get price points for {territory}")
+        return []
+    return resp.json().get("data", [])
+
+
+def find_price_point_by_amount(
+    price_points: list, amount_str: str,
+) -> dict | None:
+    """Find a price point matching the given customer price (numeric comparison).
+
+    Apple's API may return prices with trailing zeros (e.g. "9.990" instead
+    of "9.99"), so we compare as floats with a small tolerance rather than
+    doing an exact string match.
+    """
+    for pp in price_points:
+        customer_price = pp.get("attributes", {}).get("customerPrice", "")
+        try:
+            api_price = float(customer_price)
+            target_price = float(amount_str)
+            if abs(api_price - target_price) < 0.01:
+                return pp
+        except (ValueError, TypeError):
+            continue
+    return None
+
+
+def create_subscription_price(
+    headers: dict,
+    sub_id: str,
+    price_point_id: str,
+    start_date: str | None = None,
+) -> dict | None:
+    """Create a price entry for a subscription using a price point ID."""
+    resp = requests.post(
+        f"{BASE_URL}/subscriptionPrices",
+        json={
+            "data": {
+                "type": "subscriptionPrices",
+                "attributes": {
+                    "startDate": start_date,
+                    "preserveCurrentPrice": False,
+                },
+                "relationships": {
+                    "subscription": {
+                        "data": {"type": "subscriptions", "id": sub_id},
+                    },
+                    "subscriptionPricePoint": {
+                        "data": {
+                            "type": "subscriptionPricePoints",
+                            "id": price_point_id,
+                        },
+                    },
+                },
+            }
+        },
+        headers=headers,
+        timeout=TIMEOUT,
+    )
+    if not resp.ok:
+        print_api_errors(resp, f"create price for subscription {sub_id}")
+        return None
+    print(f"    Set price for subscription {sub_id} (price point: {price_point_id})")
+    return resp.json().get("data")
+
+
+# ---------------------------------------------------------------------------
+# Review Screenshot
+# ---------------------------------------------------------------------------
+
+def get_review_screenshot(headers: dict, sub_id: str) -> dict | None:
+    """Fetch the current review screenshot for a subscription."""
+    resp = requests.get(
+        f"{BASE_URL}/subscriptions/{sub_id}/appStoreReviewScreenshot",
+        headers=headers,
+        timeout=TIMEOUT,
+    )
+    if not resp.ok:
+        if resp.status_code == 404:
+            return None
+        print_api_errors(resp, f"get review screenshot for subscription {sub_id}")
+        return None
+    return resp.json().get("data")
+
+
+def reserve_review_screenshot(
+    headers: dict, sub_id: str, file_name: str, file_size: int,
+) -> dict | None:
+    """Reserve a review screenshot upload slot for a subscription."""
+    resp = requests.post(
+        f"{BASE_URL}/subscriptionAppStoreReviewScreenshots",
+        json={
+            "data": {
+                "type": "subscriptionAppStoreReviewScreenshots",
+                "attributes": {
+                    "fileName": file_name,
+                    "fileSize": file_size,
+                },
+                "relationships": {
+                    "subscription": {
+                        "data": {"type": "subscriptions", "id": sub_id},
+                    },
+                },
+            }
+        },
+        headers=headers,
+        timeout=TIMEOUT,
+    )
+    if not resp.ok:
+        print_api_errors(resp, f"reserve screenshot for subscription {sub_id}")
+        return None
+    return resp.json().get("data")
+
+
+def upload_screenshot_chunks(
+    upload_operations: list, file_data: bytes,
+) -> bool:
+    """Upload binary chunks to pre-signed URLs (no Authorization header)."""
+    for op in upload_operations:
+        url = op["url"]
+        offset = op["offset"]
+        length = op["length"]
+        chunk = file_data[offset : offset + length]
+        op_headers = {h["name"]: h["value"] for h in op.get("requestHeaders", [])}
+        resp = requests.put(url, headers=op_headers, data=chunk, timeout=TIMEOUT)
+        if not resp.ok:
+            print(
+                f"ERROR (upload chunk at offset {offset}): "
+                f"HTTP {resp.status_code} - {resp.text[:200]}",
+                file=sys.stderr,
+            )
+            return False
+    return True
+
+
+def commit_review_screenshot(
+    headers: dict, screenshot_id: str, md5_checksum: str,
+) -> dict | None:
+    """Commit an uploaded review screenshot by confirming its checksum."""
+    resp = requests.patch(
+        f"{BASE_URL}/subscriptionAppStoreReviewScreenshots/{screenshot_id}",
+        json={
+            "data": {
+                "type": "subscriptionAppStoreReviewScreenshots",
+                "id": screenshot_id,
+                "attributes": {
+                    "sourceFileChecksum": md5_checksum,
+                    "uploaded": True,
+                },
+            }
+        },
+        headers=headers,
+        timeout=TIMEOUT,
+    )
+    if not resp.ok:
+        print_api_errors(resp, f"commit screenshot {screenshot_id}")
+        return None
+    print(f"    Committed review screenshot (ID: {screenshot_id})")
+    return resp.json().get("data")

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

@@ -44,6 +44,7 @@ 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 PROJECT_ROOT="$PROJECT_ROOT"
 
 echo "ASC API key configured (Key ID: $APPLE_KEY_ID)"
 

package/templates/scripts/sync_iap_ios.py

@@ -10,10 +10,12 @@ Required env vars:
   APP_STORE_CONNECT_ISSUER_ID       - Issuer ID from App Store Connect
   APP_STORE_CONNECT_PRIVATE_KEY     - Contents of the P8 key file
   BUNDLE_ID                         - App bundle identifier
+  PROJECT_ROOT                      - Absolute path to the project root
 
 Usage:
   python3 sync_iap_ios.py <path/to/iap_config.json>
 """
+import hashlib
 import json
 import os
 import sys
@@ -29,6 +31,32 @@ from asc_iap_api import (
     list_subscriptions_in_group,
     update_localization,
 )
+from asc_subscription_setup import (
+    commit_review_screenshot,
+    create_subscription_availability,
+    create_subscription_price,
+    find_price_point_by_amount,
+    get_price_points_for_territory,
+    get_review_screenshot,
+    get_subscription_availability,
+    get_subscription_prices,
+    reserve_review_screenshot,
+    upload_screenshot_chunks,
+)
+
+CURRENCY_TO_TERRITORY = {
+    "USD": "USA", "EUR": "FRA", "GBP": "GBR", "JPY": "JPN",
+    "AUD": "AUS", "CAD": "CAN", "CHF": "CHE", "CNY": "CHN",
+    "KRW": "KOR", "SEK": "SWE", "NOK": "NOR", "DKK": "DNK",
+    "INR": "IND", "BRL": "BRA", "MXN": "MEX", "RUB": "RUS",
+    "TRY": "TUR", "SAR": "SAU", "AED": "ARE", "HKD": "HKG",
+    "SGD": "SGP", "NZD": "NZL", "TWD": "TWN", "THB": "THA",
+    "MYR": "MYS", "PHP": "PHL", "IDR": "IDN", "ILS": "ISR",
+    "ZAR": "ZAF", "PLN": "POL", "CZK": "CZE", "HUF": "HUN",
+    "RON": "ROU", "BGN": "BGR", "HRK": "HRV", "COP": "COL",
+    "CLP": "CHL", "PEN": "PER", "EGP": "EGY", "NGN": "NGA",
+    "PKR": "PAK", "KZT": "KAZ", "QAR": "QAT", "KWD": "KWT",
+}
 
 
 def find_or_create_group(headers: dict, app_id: str, reference_name: str, existing_groups: list) -> str:
@@ -62,7 +90,10 @@ def set_subscription_localization(headers: dict, sub_id: str, locale: str, loc_d
     create_localization(headers, sub_id, locale, loc_data)
 
 
-def sync_subscription_group(headers: dict, app_id: str, group_config: dict, existing_groups: list) -> dict:
+def sync_subscription_group(
+    headers: dict, app_id: str, group_config: dict,
+    existing_groups: list, project_root: str,
+) -> dict:
     """Sync a single subscription group and its subscriptions. Returns sync result."""
     ref_name = group_config.get("reference_name", group_config.get("group_name", ""))
     if not ref_name:
@@ -77,43 +108,132 @@ def sync_subscription_group(headers: dict, app_id: str, group_config: dict, exis
 
     for sub_config in group_config.get("subscriptions", []):
         sub_id = find_or_create_subscription(headers, group_id, sub_config, existing_subs)
-        _sync_subscription_localizations(headers, sub_id, sub_config)
+        for locale, loc_data in sub_config.get("localizations", {}).items():
+            set_subscription_localization(headers, sub_id, locale, loc_data)
+        _sync_availability(headers, sub_id, sub_config)
+        _sync_pricing(headers, sub_id, sub_config)
+        _sync_review_screenshot(headers, sub_id, sub_config, project_root)
         sub_results.append({"product_id": sub_config["product_id"], "id": sub_id})
 
     return {"group": ref_name, "group_id": group_id, "subscriptions": sub_results}
 
 
-def _sync_subscription_localizations(headers: dict, sub_id: str, sub_config: dict) -> None:
-    """Sync localizations for a subscription from its config."""
-    localizations = sub_config.get("localizations", {})
-    if not localizations:
+def _sync_availability(headers: dict, sub_id: str, sub_config: dict) -> None:
+    """Ensure subscription territory availability is configured."""
+    avail_config = sub_config.get("availability", {})
+    available_in_new = avail_config.get("available_in_new_territories", True)
+    territory_ids = avail_config.get("territories", [])
+
+    existing = get_subscription_availability(headers, sub_id)
+    if existing:
+        print("      Subscription availability already configured")
         return
-    for locale, loc_data in localizations.items():
-        set_subscription_localization(headers, sub_id, locale, loc_data)
 
+    result = create_subscription_availability(
+        headers, sub_id, territory_ids, available_in_new=available_in_new,
+    )
+    if result:
+        print("      Subscription availability configured successfully")
+    else:
+        print("      WARNING: Failed to configure availability", file=sys.stderr)
 
-def validate_env() -> tuple:
-    """Validate required environment variables. Returns (key_id, issuer_id, private_key, bundle_id)."""
-    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", "")
-
-    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")
 
+def _sync_pricing(headers: dict, sub_id: str, sub_config: dict) -> None:
+    """Set subscription prices per territory from config."""
+    prices = sub_config.get("prices", {})
+    if not prices:
+        print("      WARNING: No prices configured, skipping pricing", file=sys.stderr)
+        return
+
+    existing_prices = get_subscription_prices(headers, sub_id)
+    if existing_prices:
+        print("      Pricing already configured")
+        return
+
+    for currency, amount in prices.items():
+        territory = CURRENCY_TO_TERRITORY.get(currency)
+        if not territory:
+            print(f"      WARNING: Unknown currency '{currency}', skipping", file=sys.stderr)
+            continue
+        price_points = get_price_points_for_territory(headers, sub_id, territory)
+        point = find_price_point_by_amount(price_points, amount)
+        if not point:
+            sample = [
+                pp.get("attributes", {}).get("customerPrice", "?")
+                for pp in price_points[:5]
+            ]
+            print(
+                f"      WARNING: No price point matching {amount} for {territory}"
+                f" (API returned {len(price_points)} points, first prices: {sample})",
+                file=sys.stderr,
+            )
+            continue
+        result = create_subscription_price(headers, sub_id, point["id"])
+        if result:
+            print(f"      Set price {amount} for territory {territory}")
+        else:
+            print(f"      WARNING: Failed to set price for {territory}", file=sys.stderr)
+
+
+def _sync_review_screenshot(
+    headers: dict, sub_id: str, sub_config: dict, project_root: str,
+) -> None:
+    """Upload a review screenshot for the subscription if configured."""
+    screenshot_path = sub_config.get("review_screenshot")
+    if not screenshot_path:
+        print("      WARNING: No review_screenshot configured, skipping", file=sys.stderr)
+        return
+
+    full_path = os.path.join(project_root, screenshot_path)
+    if not os.path.isfile(full_path):
+        print(f"      WARNING: Screenshot not found: {full_path}", file=sys.stderr)
+        return
+
+    existing = get_review_screenshot(headers, sub_id)
+    if existing:
+        print("      Review screenshot already uploaded")
+        return
+
+    with open(full_path, "rb") as f:
+        file_data = f.read()
+
+    file_name = os.path.basename(full_path)
+    md5_checksum = hashlib.md5(file_data).hexdigest()
+
+    reservation = reserve_review_screenshot(headers, sub_id, file_name, len(file_data))
+    if not reservation:
+        print("      WARNING: Failed to reserve screenshot upload", file=sys.stderr)
+        return
+
+    screenshot_id = reservation["id"]
+    upload_ops = reservation["attributes"].get("uploadOperations", [])
+
+    success = upload_screenshot_chunks(upload_ops, file_data)
+    if not success:
+        print("      WARNING: Screenshot chunk upload failed, skipping commit", file=sys.stderr)
+        return
+    result = commit_review_screenshot(headers, screenshot_id, md5_checksum)
+    if result:
+        print(f"      Review screenshot uploaded: {file_name}")
+    else:
+        print("      WARNING: Failed to commit screenshot upload", file=sys.stderr)
+
+
+def validate_env() -> tuple:
+    """Validate required environment variables. Returns (key_id, issuer_id, private_key, bundle_id, project_root)."""
+    required_vars = [
+        "APP_STORE_CONNECT_KEY_IDENTIFIER",
+        "APP_STORE_CONNECT_ISSUER_ID",
+        "APP_STORE_CONNECT_PRIVATE_KEY",
+        "BUNDLE_ID",
+        "PROJECT_ROOT",
+    ]
+    values = {var: os.environ.get(var, "") for var in required_vars}
+    missing = [var for var, val in values.items() if not val]
     if missing:
         print(f"ERROR: Missing required environment variables: {', '.join(missing)}", file=sys.stderr)
         sys.exit(1)
-
-    return key_id, issuer_id, private_key, bundle_id
+    return tuple(values.values())
 
 
 def load_iap_config(config_path: str) -> dict:
@@ -137,7 +257,7 @@ def main() -> None:
         sys.exit(1)
 
     config_path = sys.argv[1]
-    key_id, issuer_id, private_key, bundle_id = validate_env()
+    key_id, issuer_id, private_key, bundle_id, project_root = validate_env()
 
     token = get_jwt_token(key_id, issuer_id, private_key)
     headers = {
@@ -153,7 +273,9 @@ def main() -> None:
     results = []
 
     for group_config in config.get("subscription_groups", []):
-        result = sync_subscription_group(headers, app_id, group_config, existing_groups)
+        result = sync_subscription_group(
+            headers, app_id, group_config, existing_groups, project_root,
+        )
         results.append(result)
 
     print(f"\n{json.dumps({'synced_groups': results}, indent=2)}")