@daemux/store-automator 0.10.33 → 0.10.34

package/.claude-plugin/marketplace.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daemux/store-automator",
-  "version": "0.10.33",
+  "version": "0.10.34",
   "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,9 +1,16 @@
 {
   "name": "store-automator",
-  "version": "0.10.3",
+  "version": "0.10.34",
   "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/fastlane/ios/Fastfile.template

@@ -57,7 +57,6 @@ def metadata_deliver_options
     sync_screenshots: true,
     primary_category: ENV.fetch("PRIMARY_CATEGORY", "UTILITIES"),
     secondary_category: ENV.fetch("SECONDARY_CATEGORY", "PRODUCTIVITY"),
-    price_tier: ENV.fetch("PRICE_TIER", "0").to_i,
     app_rating_config_path: "#{ROOT_DIR}/fastlane/app_rating_config.json"
   )
 end

package/templates/scripts/asc_subscription_setup.py

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

package/templates/scripts/sync_iap_ios.py

@@ -35,6 +35,7 @@ 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,
@@ -43,7 +44,8 @@ from asc_subscription_setup import (
     get_subscription_availability,
     get_subscription_prices,
     list_all_territory_ids,
-    upload_review_screenshot,
+    reserve_review_screenshot,
+    upload_screenshot_chunks,
 )
 
 CURRENCY_TO_TERRITORY = {
@@ -223,12 +225,27 @@ 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):
-        full_path = _find_fallback_screenshot(project_root)
-        if not full_path:
-            print(f"      WARNING: Screenshot not found: {screenshot_path}", file=sys.stderr)
+        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)
             return
-        print(f"      Using fallback screenshot: {os.path.basename(full_path)}")
 
     existing = get_review_screenshot(headers, sub_id)
     if existing:
@@ -240,66 +257,79 @@ def _sync_review_screenshot(
 
     file_name = os.path.basename(full_path)
     md5_checksum = hashlib.md5(file_data).hexdigest()
-    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 upload screenshot", file=sys.stderr)
 
+    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
 
-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
+    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 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
+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",
+        "APP_STORE_CONNECT_KEY_IDENTIFIER",
+        "APP_STORE_CONNECT_ISSUER_ID",
+        "APP_STORE_CONNECT_PRIVATE_KEY",
+        "BUNDLE_ID",
+        "PROJECT_ROOT",
     ]
-    env = {var: os.environ.get(var, "") for var in required_vars}
-    missing = [var for var, val in env.items() if not val]
+    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 env vars: {', '.join(missing)}", file=sys.stderr)
+        print(f"ERROR: Missing required environment variables: {', '.join(missing)}", file=sys.stderr)
         sys.exit(1)
-    key_id, issuer_id, private_key, bundle_id, project_root = env.values()
+    return tuple(values.values())
 
-    # Load IAP config
-    config_path = sys.argv[1]
+
+def load_iap_config(config_path: str) -> dict:
+    """Load and validate the IAP config file."""
     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,