@daemux/store-automator 0.10.27 → 0.10.29

package/.claude-plugin/marketplace.json

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

package/package.json

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

package/templates/scripts/asc_iap_api.py

@@ -204,6 +204,72 @@ def update_localization(headers: dict, loc_id: str, loc_data: dict) -> None:
     print(f"      Updated localization (ID: {loc_id})")
 
 
+def get_group_localizations(headers: dict, group_id: str) -> list:
+    """Fetch existing localizations for a subscription group."""
+    resp = requests.get(
+        f"{BASE_URL}/subscriptionGroups/{group_id}/subscriptionGroupLocalizations",
+        headers=headers,
+        timeout=TIMEOUT,
+    )
+    resp.raise_for_status()
+    return resp.json().get("data", [])
+
+
+def create_group_localization(
+    headers: dict, group_id: str, locale: str, name: str, custom_app_name: str = None,
+) -> None:
+    """Create a new localization for a subscription group."""
+    resp = requests.post(
+        f"{BASE_URL}/subscriptionGroupLocalizations",
+        json={
+            "data": {
+                "type": "subscriptionGroupLocalizations",
+                "attributes": {
+                    "name": name,
+                    "customAppName": custom_app_name,
+                    "locale": locale,
+                },
+                "relationships": {
+                    "subscriptionGroup": {
+                        "data": {"type": "subscriptionGroups", "id": group_id}
+                    }
+                },
+            }
+        },
+        headers=headers,
+        timeout=TIMEOUT,
+    )
+    if not resp.ok:
+        print_api_errors(resp, f"create group localization '{locale}' for group {group_id}")
+        return
+    print(f"    Created group localization '{locale}'")
+
+
+def update_group_localization(
+    headers: dict, loc_id: str, name: str, custom_app_name: str = None,
+) -> None:
+    """Update an existing subscription group localization."""
+    resp = requests.patch(
+        f"{BASE_URL}/subscriptionGroupLocalizations/{loc_id}",
+        json={
+            "data": {
+                "type": "subscriptionGroupLocalizations",
+                "id": loc_id,
+                "attributes": {
+                    "name": name,
+                    "customAppName": custom_app_name,
+                },
+            }
+        },
+        headers=headers,
+        timeout=TIMEOUT,
+    )
+    if not resp.ok:
+        print_api_errors(resp, f"update group localization {loc_id}")
+        return
+    print(f"    Updated group localization (ID: {loc_id})")
+
+
 def print_api_errors(resp, action: str) -> None:
     """Print human-readable API error messages."""
     try:

package/templates/scripts/asc_subscription_setup.py

@@ -26,12 +26,12 @@ from asc_iap_api import BASE_URL, TIMEOUT, print_api_errors
 def get_subscription_availability(headers: dict, sub_id: str) -> dict | None:
     """Fetch current availability settings for a subscription.
 
-    Includes availableTerritories relationship so callers can check territory count.
+    Returns the availability resource or None if not yet configured.
+    Does not include territory details to avoid ASC API limit errors.
     """
     resp = requests.get(
         f"{BASE_URL}/subscriptions/{sub_id}/subscriptionAvailability",
         headers=headers,
-        params={"include": "availableTerritories", "limit[availableTerritories]": 200},
         timeout=TIMEOUT,
     )
     if not resp.ok:
@@ -39,11 +39,7 @@ def get_subscription_availability(headers: dict, sub_id: str) -> dict | None:
             return None
         print_api_errors(resp, f"get availability for subscription {sub_id}")
         return None
-    body = resp.json()
-    result = body.get("data")
-    if result:
-        result["_included_territories"] = body.get("included", [])
-    return result
+    return resp.json().get("data")
 
 
 def list_all_territory_ids(headers: dict) -> list[str]:

package/templates/scripts/sync_iap_ios.py

@@ -21,14 +21,17 @@ import os
 import sys
 
 from asc_iap_api import (
+    create_group_localization,
     create_localization,
     create_subscription,
     create_subscription_group,
     get_app_id,
+    get_group_localizations,
     get_jwt_token,
     get_subscription_localizations,
     list_subscription_groups,
     list_subscriptions_in_group,
+    update_group_localization,
     update_localization,
 )
 from asc_subscription_setup import (
@@ -104,6 +107,27 @@ def sync_subscription_group(
     print(f"\nProcessing subscription group: {ref_name}")
     group_id = find_or_create_group(headers, app_id, ref_name, existing_groups)
 
+    # Sync group localizations
+    group_localizations = group_config.get("localizations", {})
+    if group_localizations:
+        existing_locs = get_group_localizations(headers, group_id)
+        existing_map = {loc["attributes"]["locale"]: loc for loc in existing_locs}
+
+        for locale, loc_data in group_localizations.items():
+            name = loc_data.get("name", "")
+            custom_name = loc_data.get("custom_name")
+
+            if locale in existing_map:
+                update_group_localization(
+                    headers, existing_map[locale]["id"], name, custom_name
+                )
+                print(f"    Updated group localization: {locale}")
+            else:
+                create_group_localization(
+                    headers, group_id, locale, name, custom_name
+                )
+                print(f"    Created group localization: {locale}")
+
     existing_subs = list_subscriptions_in_group(headers, group_id)
     sub_results = []
 
@@ -122,10 +146,14 @@ def sync_subscription_group(
 def _sync_availability(headers: dict, sub_id: str, sub_config: dict) -> None:
     """Ensure subscription territory availability is configured with all territories.
 
-    If no territories are specified in config, fetches all App Store territories
-    so the subscription is available everywhere (empty list = removed from sale).
-    Also re-creates availability if existing territory count is suspiciously low.
+    If availability already exists, it is left as-is (idempotent skip).
+    Otherwise fetches all App Store territories and creates availability.
     """
+    existing = get_subscription_availability(headers, sub_id)
+    if existing:
+        print("      Availability already configured")
+        return
+
     avail_config = sub_config.get("availability", {})
     available_in_new = avail_config.get("available_in_new_territories", True)
     territory_ids = avail_config.get("territories", [])
@@ -137,14 +165,6 @@ def _sync_availability(headers: dict, sub_id: str, sub_config: dict) -> None:
             print("      WARNING: Could not fetch territories", file=sys.stderr)
             return
 
-    existing = get_subscription_availability(headers, sub_id)
-    if existing:
-        included = existing.get("_included_territories", [])
-        if len(included) >= 100:
-            print(f"      Availability OK ({len(included)} territories)")
-            return
-        print(f"      Availability has only {len(included)} territories, recreating with {len(territory_ids)}")
-
     result = create_subscription_availability(
         headers, sub_id, territory_ids, available_in_new=available_in_new,
     )