@daemux/store-automator 0.10.72 → 0.10.73

package/.claude-plugin/marketplace.json

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

package/package.json

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

package/templates/scripts/ci/ios-native/set_app_store_whats_new.py

@@ -0,0 +1,167 @@
+#!/usr/bin/env python3
+"""
+Set the App Store "What's New" text (appStoreVersionLocalizations.whatsNew) for
+the draft App Store version slot prepared by manage_marketing_version.py.
+
+Mirrors gowalk-step's `fastlane run set_changelog` behavior against the ASC
+REST API (no fastlane dependency here):
+
+  * Uses the pre-resolved APP_STORE_VERSION_ID env var from the
+    "Resolve App Store version slot" step -- no polling, no lookup by version.
+  * Skips the first release (1.0 / 1.0.0 / 0.0 / 0.0.0) -- there are no prior
+    release notes to announce.
+  * Skips when the slot is not in a state that permits editing whatsNew.
+  * Either PATCHes the existing localization for the requested locale or POSTs
+    a new one pointing at the appStoreVersion.
+
+Non-fatal by design: any failure is reported as a ::warning:: and the action
+continues. The TestFlight upload itself has already succeeded by this point.
+
+Environment:
+  ASC_KEY_ID, ASC_ISSUER_ID, ASC_KEY_PATH  -- App Store Connect API credentials
+  MARKETING_VERSION                        -- e.g. "1.2.3"
+  APP_STORE_VERSION_ID                     -- appStoreVersion id (REUSE or CREATE)
+  APP_STORE_WHATS_NEW                      -- release notes text (empty = skip)
+  APP_STORE_LOCALE                         -- locale code, default "en-US"
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+
+from asc_common import get_json, make_jwt, request
+
+
+# gowalk-step parity: skip whatsNew for the initial release.
+SKIP_VERSIONS = {"1.0", "1.0.0", "0.0", "0.0.0"}
+
+# Apple permits editing appStoreVersionLocalizations.whatsNew only while the
+# version is in an editable state. WAITING_FOR_REVIEW / IN_REVIEW /
+# READY_FOR_SALE etc. are not editable -- skip non-fatally.
+WHATSNEW_EDITABLE_STATES = {
+    "PREPARE_FOR_SUBMISSION",
+    "REJECTED",
+    "METADATA_REJECTED",
+    "DEVELOPER_REJECTED",
+    "INVALID_BINARY",
+}
+
+
+def _require_env(name: str) -> str:
+    value = os.environ.get(name, "").strip()
+    if not value:
+        print(f"::error::{name} env var is required", file=sys.stderr)
+        raise SystemExit(1)
+    return value
+
+
+def _warn(msg: str) -> None:
+    print(f"::warning::{msg}", file=sys.stderr)
+
+
+def _log(msg: str) -> None:
+    print(msg, file=sys.stderr)
+
+
+def _patch_localization(token: str, localization_id: str, whats_new: str) -> None:
+    request(
+        "PATCH",
+        f"/appStoreVersionLocalizations/{localization_id}",
+        token,
+        json_body={
+            "data": {
+                "type": "appStoreVersionLocalizations",
+                "id": localization_id,
+                "attributes": {"whatsNew": whats_new},
+            }
+        },
+    )
+
+
+def _create_localization(
+    token: str, version_id: str, locale: str, whats_new: str
+) -> str:
+    resp = request(
+        "POST",
+        "/appStoreVersionLocalizations",
+        token,
+        json_body={
+            "data": {
+                "type": "appStoreVersionLocalizations",
+                "attributes": {"locale": locale, "whatsNew": whats_new},
+                "relationships": {
+                    "appStoreVersion": {
+                        "data": {"type": "appStoreVersions", "id": version_id}
+                    }
+                },
+            }
+        },
+    )
+    return resp.json()["data"]["id"]
+
+
+def main() -> int:
+    whats_new = os.environ.get("APP_STORE_WHATS_NEW", "")
+    if not whats_new.strip():
+        _log("APP_STORE_WHATS_NEW empty; skipping.")
+        return 0
+
+    version = _require_env("MARKETING_VERSION")
+    version_id = _require_env("APP_STORE_VERSION_ID")
+    locale = os.environ.get("APP_STORE_LOCALE", "").strip() or "en-US"
+
+    if version in SKIP_VERSIONS:
+        _log(f"Skipping whatsNew for first release {version}.")
+        return 0
+
+    token = make_jwt(
+        _require_env("ASC_KEY_ID"),
+        _require_env("ASC_ISSUER_ID"),
+        _require_env("ASC_KEY_PATH"),
+    )
+
+    ver = get_json(f"/appStoreVersions/{version_id}", token)
+    state = (ver.get("data") or {}).get("attributes", {}).get("appStoreState", "")
+    if state not in WHATSNEW_EDITABLE_STATES:
+        _warn(
+            f"appStoreVersion {version} is {state}; whatsNew not editable in "
+            f"this state, skipping."
+        )
+        return 0
+
+    locs = get_json(
+        f"/appStoreVersions/{version_id}/appStoreVersionLocalizations", token
+    )
+    existing = next(
+        (
+            item
+            for item in (locs.get("data") or [])
+            if (item.get("attributes") or {}).get("locale") == locale
+        ),
+        None,
+    )
+
+    if existing:
+        _patch_localization(token, existing["id"], whats_new)
+        _log(
+            f"PATCHed appStoreVersionLocalization {existing['id']} whatsNew "
+            f"for {version} ({locale})"
+        )
+    else:
+        new_id = _create_localization(token, version_id, locale, whats_new)
+        _log(
+            f"CREATEd appStoreVersionLocalization {new_id} whatsNew for "
+            f"{version} ({locale})"
+        )
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main())
+    except SystemExit:
+        raise
+    except Exception as exc:  # non-fatal per gowalk-step's set_changelog parity
+        _warn(f"whatsNew setter failed (non-fatal): {exc!r}")
+        sys.exit(0)

package/templates/scripts/ci/ios-native/set_testflight_whats_new.py

@@ -1,146 +0,0 @@
-#!/usr/bin/env python3
-"""
-Set TestFlight "What to Test" (betaBuildLocalization.whatsNew) for the build
-just uploaded by this workflow.
-
-Runs after the altool upload step. Polls ASC until the build record appears
-(altool upload returns before Apple has fully ingested the build), then either
-PATCHes an existing betaBuildLocalization for the requested locale or POSTs a
-new one.
-
-Environment:
-  ASC_KEY_ID, ASC_ISSUER_ID, ASC_KEY_PATH  -- App Store Connect API credentials
-  APP_STORE_APPLE_ID                       -- numeric ASC app id
-  MARKETING_VERSION                        -- e.g. "1.2.3"
-  BUILD_NUMBER                             -- e.g. "42"
-  TESTFLIGHT_WHATS_NEW                     -- release notes text (empty = skip)
-  TESTFLIGHT_LOCALE                        -- locale code, default "en-US"
-
-Non-fatal by design: if the build can't be found within the polling window we
-emit a ::warning:: and exit 0, since the TestFlight upload itself may still
-have succeeded.
-"""
-
-from __future__ import annotations
-
-import os
-import sys
-import time
-
-from asc_common import get_json, make_jwt, request
-
-
-POLL_ATTEMPTS = 20
-POLL_FIRST_DELAY = 10
-POLL_DELAY = 30
-
-
-def _require_env(name: str) -> str:
-    value = os.environ.get(name, "").strip()
-    if not value:
-        print(f"::error::{name} env var is required", file=sys.stderr)
-        raise SystemExit(1)
-    return value
-
-
-def _find_build(token: str, app_id: str, marketing_version: str, build_number: str) -> str | None:
-    """Return the build id matching (marketing_version, build_number), or None."""
-    params = {
-        "filter[app]": app_id,
-        "filter[preReleaseVersion.version]": marketing_version,
-        "filter[version]": build_number,
-        "limit": "5",
-    }
-    data = get_json("/builds", token, params=params)
-    items = data.get("data") or []
-    return items[0].get("id") if items else None
-
-
-def _poll_for_build(token: str, app_id: str, marketing_version: str, build_number: str) -> str | None:
-    """Poll ASC for the uploaded build. Returns build id or None on timeout."""
-    for attempt in range(POLL_ATTEMPTS):
-        delay = POLL_FIRST_DELAY if attempt == 0 else POLL_DELAY
-        print(
-            f"Waiting {delay}s for build {marketing_version} ({build_number}) to appear "
-            f"(attempt {attempt + 1}/{POLL_ATTEMPTS})",
-            file=sys.stderr,
-        )
-        time.sleep(delay)
-        build_id = _find_build(token, app_id, marketing_version, build_number)
-        if build_id:
-            print(f"Found build id {build_id}", file=sys.stderr)
-            return build_id
-    return None
-
-
-def _existing_localization(token: str, build_id: str, locale: str) -> str | None:
-    """Return the betaBuildLocalization id for `locale` on this build, or None."""
-    data = get_json(f"/builds/{build_id}/betaBuildLocalizations", token)
-    for item in data.get("data") or []:
-        if (item.get("attributes") or {}).get("locale") == locale:
-            return item.get("id")
-    return None
-
-
-def _patch_localization(token: str, localization_id: str, whats_new: str) -> None:
-    body = {
-        "data": {
-            "type": "betaBuildLocalizations",
-            "id": localization_id,
-            "attributes": {"whatsNew": whats_new},
-        }
-    }
-    request("PATCH", f"/betaBuildLocalizations/{localization_id}", token, json_body=body)
-
-
-def _create_localization(token: str, build_id: str, locale: str, whats_new: str) -> None:
-    body = {
-        "data": {
-            "type": "betaBuildLocalizations",
-            "attributes": {"locale": locale, "whatsNew": whats_new},
-            "relationships": {
-                "build": {"data": {"type": "builds", "id": build_id}},
-            },
-        }
-    }
-    request("POST", "/betaBuildLocalizations", token, json_body=body)
-
-
-def main() -> int:
-    whats_new = os.environ.get("TESTFLIGHT_WHATS_NEW", "")
-    if not whats_new.strip():
-        print("empty whatsNew; skipping", file=sys.stderr)
-        return 0
-
-    key_id = _require_env("ASC_KEY_ID")
-    issuer_id = _require_env("ASC_ISSUER_ID")
-    key_path = _require_env("ASC_KEY_PATH")
-    app_id = _require_env("APP_STORE_APPLE_ID")
-    marketing_version = _require_env("MARKETING_VERSION")
-    build_number = _require_env("BUILD_NUMBER")
-    locale = os.environ.get("TESTFLIGHT_LOCALE", "").strip() or "en-US"
-
-    token = make_jwt(key_id, issuer_id, key_path)
-
-    build_id = _poll_for_build(token, app_id, marketing_version, build_number)
-    if not build_id:
-        print(
-            f"::warning::build {marketing_version} ({build_number}) not found in ASC "
-            f"after {POLL_ATTEMPTS} polls; skipping whatsNew update",
-            file=sys.stderr,
-        )
-        return 0
-
-    existing = _existing_localization(token, build_id, locale)
-    if existing:
-        _patch_localization(token, existing, whats_new)
-        action = "updated"
-    else:
-        _create_localization(token, build_id, locale, whats_new)
-        action = "created"
-    print(f"Set betaBuildLocalization whatsNew for build {build_id} locale {locale} ({action})")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())