@daemux/store-automator 0.10.42 → 0.10.44

package/.claude-plugin/marketplace.json

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

package/package.json

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

package/templates/scripts/asc_subscription_setup.py

@@ -93,16 +93,19 @@ def create_subscription_availability(
 
 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", [])
+    url: str | None = f"{BASE_URL}/subscriptions/{sub_id}/prices"
+    params: dict | None = {"include": "subscriptionPricePoint", "limit": 200}
+    all_prices: list = []
+    while url:
+        resp = requests.get(url, headers=headers, params=params, timeout=TIMEOUT)
+        if not resp.ok:
+            print_api_errors(resp, f"get prices for subscription {sub_id}")
+            return all_prices
+        data = resp.json()
+        all_prices.extend(data.get("data", []))
+        url = data.get("links", {}).get("next")
+        params = None
+    return all_prices
 
 
 def get_price_points_for_territory(
@@ -153,13 +156,31 @@ def find_price_point_by_amount(
     return None
 
 
+def get_price_point_equalizations(headers: dict, price_point_id: str) -> list:
+    """Get equalized price points for all territories from a base price point."""
+    url: str | None = f"{BASE_URL}/subscriptionPricePoints/{price_point_id}/equalizations"
+    params: dict | None = {"include": "territory", "limit": 200}
+    all_points: list = []
+    while url:
+        resp = requests.get(url, headers=headers, params=params, timeout=TIMEOUT)
+        if not resp.ok:
+            print_api_errors(resp, "get price point equalizations")
+            return all_points
+        data = resp.json()
+        all_points.extend(data.get("data", []))
+        url = data.get("links", {}).get("next")
+        params = None
+    return all_points
+
+
 def create_subscription_price(
     headers: dict,
     sub_id: str,
     price_point_id: str,
+    territory_id: str,
     start_date: str | None = None,
 ) -> dict | None:
-    """Create a price entry for a subscription using a price point ID."""
+    """Create a price entry for a subscription using a price point ID and territory."""
     resp = requests.post(
         f"{BASE_URL}/subscriptionPrices",
         json={"data": {
@@ -170,6 +191,9 @@ def create_subscription_price(
                 "subscriptionPricePoint": {
                     "data": {"type": "subscriptionPricePoints", "id": price_point_id},
                 },
+                "territory": {
+                    "data": {"type": "territories", "id": territory_id},
+                },
             },
         }},
         headers=headers,
@@ -178,7 +202,6 @@ def create_subscription_price(
     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")
 
 

package/templates/scripts/sync_iap_ios.py

@@ -19,6 +19,7 @@ import hashlib
 import json
 import os
 import sys
+import time
 
 from asc_iap_api import (
     create_group_localization,
@@ -38,6 +39,7 @@ from asc_subscription_setup import (
     create_subscription_availability,
     create_subscription_price,
     find_price_point_by_amount,
+    get_price_point_equalizations,
     get_price_points_for_territory,
     get_review_screenshot,
     get_subscription_availability,
@@ -173,40 +175,99 @@ def _sync_availability(headers: dict, sub_id: str, sub_config: dict) -> None:
 
 
 def _sync_pricing(headers: dict, sub_id: str, sub_config: dict) -> None:
-    """Set subscription prices per territory from config."""
+    """Set subscription prices for all territories using Apple's equalization.
+
+    Finds the base price point (USD/USA), then uses the equalizations
+    endpoint to get Apple-calculated prices for all other territories.
+    """
     prices = sub_config.get("prices", {})
     if not prices:
         print("      WARNING: No prices configured, skipping pricing", file=sys.stderr)
         return
 
+    # Build set of territories that already have prices
     existing_prices = get_subscription_prices(headers, sub_id)
-    if existing_prices:
-        print("      Pricing already configured")
+    priced_territories: set[str] = set()
+    for ep in existing_prices:
+        pp_rel = ep.get("relationships", {}).get("subscriptionPricePoint", {})
+        pp_id = pp_rel.get("data", {}).get("id", "")
+        if "_" in pp_id:
+            priced_territories.add(pp_id.rsplit("_", 1)[-1])
+
+    # Use first configured currency as base (typically USD -> USA)
+    base_currency = next(iter(prices))
+    base_amount = prices[base_currency]
+    base_territory = CURRENCY_TO_TERRITORY.get(base_currency)
+    if not base_territory:
+        print(f"      WARNING: Unknown base currency '{base_currency}'", file=sys.stderr)
+        return
+
+    # Find the base price point
+    price_points = get_price_points_for_territory(headers, sub_id, base_territory)
+    base_point = find_price_point_by_amount(price_points, base_amount)
+    if not base_point:
+        sample = [pp.get("attributes", {}).get("customerPrice", "?") for pp in price_points[:5]]
+        print(
+            f"      WARNING: No price point matching {base_amount} for {base_territory}"
+            f" (API returned {len(price_points)} points, first prices: {sample})",
+            file=sys.stderr,
+        )
         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)
+    created, skipped, failed = _apply_equalized_prices(
+        headers, sub_id, base_point, base_territory, base_amount, base_currency, priced_territories,
+    )
+    print(f"      Pricing: {created} set, {skipped} existed, {failed} failed")
+
+
+def _apply_equalized_prices(
+    headers: dict, sub_id: str, base_point: dict,
+    base_territory: str, base_amount: str, base_currency: str,
+    priced_territories: set[str],
+) -> tuple[int, int, int]:
+    """Set base price then apply Apple-equalized prices for all territories."""
+    created = 0
+    skipped = 0
+    failed = 0
+
+    # Set base territory price if not already set
+    if base_territory not in priced_territories:
+        result = create_subscription_price(headers, sub_id, base_point["id"], base_territory)
+        if result:
+            created += 1
+            print(f"      Set base price {base_amount} {base_currency} for {base_territory}")
+        else:
+            failed += 1
+            print(f"      WARNING: Failed to set base price for {base_territory}", file=sys.stderr)
+            return created, skipped, failed
+    else:
+        skipped += 1
+
+    # Get equalized prices for all other territories
+    equalized = get_price_point_equalizations(headers, base_point["id"])
+    if not equalized:
+        print("      WARNING: No equalizations returned", file=sys.stderr)
+        return created, skipped, failed
+
+    # Set price for each equalized territory
+    for eq_point in equalized:
+        territory_id = eq_point.get("relationships", {}).get(
+            "territory", {}
+        ).get("data", {}).get("id")
+        if not territory_id:
+            failed += 1
             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,
-            )
+        if territory_id in priced_territories:
+            skipped += 1
             continue
-        result = create_subscription_price(headers, sub_id, point["id"])
+        result = create_subscription_price(headers, sub_id, eq_point["id"], territory_id)
         if result:
-            print(f"      Set price {amount} for territory {territory}")
+            created += 1
         else:
-            print(f"      WARNING: Failed to set price for {territory}", file=sys.stderr)
+            failed += 1
+        time.sleep(0.05)
+
+    return created, skipped, failed
 
 
 def _sync_review_screenshot(