@daemux/store-automator 0.10.34 → 0.10.35

package/.claude-plugin/marketplace.json

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

package/package.json

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

package/templates/scripts/asc_subscription_setup.py

@@ -66,27 +66,17 @@ def create_subscription_availability(
     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
-    ]
+    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,
-                    },
-                },
-            }
-        },
+        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,
     )
@@ -172,26 +162,16 @@ def create_subscription_price(
     """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,
+        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},
                 },
-                "relationships": {
-                    "subscription": {
-                        "data": {"type": "subscriptions", "id": sub_id},
-                    },
-                    "subscriptionPricePoint": {
-                        "data": {
-                            "type": "subscriptionPricePoints",
-                            "id": price_point_id,
-                        },
-                    },
-                },
-            }
-        },
+            },
+        }},
         headers=headers,
         timeout=TIMEOUT,
     )
@@ -221,72 +201,49 @@ def get_review_screenshot(headers: dict, sub_id: str) -> dict | None:
     return resp.json().get("data")
 
 
-def reserve_review_screenshot(
-    headers: dict, sub_id: str, file_name: str, file_size: int,
+def upload_review_screenshot(
+    headers: dict, sub_id: str,
+    file_name: str, file_data: bytes, md5_checksum: str,
 ) -> dict | None:
-    """Reserve a review screenshot upload slot for a subscription."""
+    """Reserve, upload chunks, and commit a review screenshot in one operation."""
+    resource_type = "subscriptionAppStoreReviewScreenshots"
     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},
-                    },
-                },
-            }
-        },
+        f"{BASE_URL}/{resource_type}",
+        json={"data": {
+            "type": resource_type,
+            "attributes": {"fileName": file_name, "fileSize": len(file_data)},
+            "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]
+    reservation = resp.json().get("data")
+    if not reservation:
+        print(f"ERROR: Empty reservation response for subscription {sub_id}", file=sys.stderr)
+        return None
+    screenshot_id = reservation["id"]
+    for op in reservation["attributes"].get("uploadOperations", []):
+        chunk = file_data[op["offset"] : op["offset"] + op["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:
+        chunk_resp = requests.put(op["url"], headers=op_headers, data=chunk, timeout=TIMEOUT)
+        if not chunk_resp.ok:
             print(
-                f"ERROR (upload chunk at offset {offset}): "
-                f"HTTP {resp.status_code} - {resp.text[:200]}",
+                f"ERROR (upload chunk at offset {op['offset']}): "
+                f"HTTP {chunk_resp.status_code} - {chunk_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."""
+            return None
     resp = requests.patch(
-        f"{BASE_URL}/subscriptionAppStoreReviewScreenshots/{screenshot_id}",
-        json={
-            "data": {
-                "type": "subscriptionAppStoreReviewScreenshots",
-                "id": screenshot_id,
-                "attributes": {
-                    "sourceFileChecksum": md5_checksum,
-                    "uploaded": True,
-                },
-            }
-        },
+        f"{BASE_URL}/{resource_type}/{screenshot_id}",
+        json={"data": {
+            "type": resource_type, "id": screenshot_id,
+            "attributes": {"sourceFileChecksum": md5_checksum, "uploaded": True},
+        }},
         headers=headers,
         timeout=TIMEOUT,
     )

package/templates/scripts/sync_iap_ios.py

@@ -35,7 +35,6 @@ from asc_iap_api import (
     update_localization,
 )
 from asc_subscription_setup import (
-    commit_review_screenshot,
     create_subscription_availability,
     create_subscription_price,
     find_price_point_by_amount,
@@ -44,8 +43,7 @@ from asc_subscription_setup import (
     get_subscription_availability,
     get_subscription_prices,
     list_all_territory_ids,
-    reserve_review_screenshot,
-    upload_screenshot_chunks,
+    upload_review_screenshot,
 )
 
 CURRENCY_TO_TERRITORY = {
@@ -225,27 +223,12 @@ def _sync_review_screenshot(
         return
 
     full_path = os.path.join(project_root, screenshot_path)
-
-    # Fallback: if configured path doesn't exist, pick first iPhone screenshot
     if not os.path.isfile(full_path):
-        fallback = None
-        ios_dir = os.path.join(project_root, "fastlane", "screenshots", "ios", "en-US")
-        if os.path.isdir(ios_dir):
-            for f in sorted(os.listdir(ios_dir)):
-                if f.lower().endswith(".png") and "iphone" in f.lower():
-                    fallback = os.path.join(ios_dir, f)
-                    break
-            if not fallback:
-                for f in sorted(os.listdir(ios_dir)):
-                    if f.lower().endswith(".png"):
-                        fallback = os.path.join(ios_dir, f)
-                        break
-        if fallback:
-            full_path = fallback
-            print(f"      Using fallback screenshot: {os.path.basename(full_path)}")
-        else:
-            print(f"      WARNING: Screenshot not found: {full_path}", file=sys.stderr)
+        full_path = _find_fallback_screenshot(project_root)
+        if not full_path:
+            print(f"      WARNING: Screenshot not found: {screenshot_path}", file=sys.stderr)
             return
+        print(f"      Using fallback screenshot: {os.path.basename(full_path)}")
 
     existing = get_review_screenshot(headers, sub_id)
     if existing:
@@ -257,79 +240,66 @@ def _sync_review_screenshot(
 
     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)
+    result = upload_review_screenshot(headers, sub_id, file_name, file_data, md5_checksum)
     if result:
         print(f"      Review screenshot uploaded: {file_name}")
     else:
-        print("      WARNING: Failed to commit screenshot upload", file=sys.stderr)
+        print("      WARNING: Failed to upload screenshot", file=sys.stderr)
 
 
-def validate_env() -> tuple:
-    """Validate required environment variables. Returns (key_id, issuer_id, private_key, bundle_id, project_root)."""
+def _find_fallback_screenshot(project_root: str) -> str | None:
+    """Find the first iPhone PNG screenshot in fastlane/screenshots/ios/en-US/."""
+    ios_dir = os.path.join(project_root, "fastlane", "screenshots", "ios", "en-US")
+    if not os.path.isdir(ios_dir):
+        return None
+    files = sorted(os.listdir(ios_dir))
+    for f in files:
+        if f.lower().endswith(".png") and "iphone" in f.lower():
+            return os.path.join(ios_dir, f)
+    for f in files:
+        if f.lower().endswith(".png"):
+            return os.path.join(ios_dir, f)
+    return None
+
+
+def main() -> None:
+    if len(sys.argv) < 2:
+        print(f"Usage: {sys.argv[0]} <path/to/iap_config.json>", file=sys.stderr)
+        sys.exit(1)
+
+    # Validate required environment variables
     required_vars = [
-        "APP_STORE_CONNECT_KEY_IDENTIFIER",
-        "APP_STORE_CONNECT_ISSUER_ID",
-        "APP_STORE_CONNECT_PRIVATE_KEY",
-        "BUNDLE_ID",
-        "PROJECT_ROOT",
+        "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]
+    env = {var: os.environ.get(var, "") for var in required_vars}
+    missing = [var for var, val in env.items() if not val]
     if missing:
-        print(f"ERROR: Missing required environment variables: {', '.join(missing)}", file=sys.stderr)
+        print(f"ERROR: Missing env vars: {', '.join(missing)}", file=sys.stderr)
         sys.exit(1)
-    return tuple(values.values())
+    key_id, issuer_id, private_key, bundle_id, project_root = env.values()
 
-
-def load_iap_config(config_path: str) -> dict:
-    """Load and validate the IAP config file."""
+    # Load IAP config
+    config_path = sys.argv[1]
     if not os.path.isfile(config_path):
         print(f"ERROR: IAP config file not found: {config_path}", file=sys.stderr)
         sys.exit(1)
-
     with open(config_path, "r", encoding="utf-8") as f:
         config = json.load(f)
-
     if not config.get("subscription_groups"):
         print("WARNING: No subscription_groups found in config", file=sys.stderr)
 
-    return config
-
-
-def main() -> None:
-    if len(sys.argv) < 2:
-        print(f"Usage: {sys.argv[0]} <path/to/iap_config.json>", file=sys.stderr)
-        sys.exit(1)
-
-    config_path = sys.argv[1]
-    key_id, issuer_id, private_key, bundle_id, project_root = validate_env()
-
     token = get_jwt_token(key_id, issuer_id, private_key)
     headers = {
         "Authorization": f"Bearer {token}",
         "Content-Type": "application/json",
     }
 
-    config = load_iap_config(config_path)
     app_id = get_app_id(headers, bundle_id)
     print(f"App ID: {app_id} (Bundle: {bundle_id})")
 
     existing_groups = list_subscription_groups(headers, app_id)
     results = []
-
     for group_config in config.get("subscription_groups", []):
         result = sync_subscription_group(
             headers, app_id, group_config, existing_groups, project_root,