@daemux/store-automator 0.10.71 → 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.71"
+    "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.71",
+      "version": "0.10.73",
       "keywords": [
         "flutter",
         "app-store",

package/package.json

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

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

@@ -2,19 +2,26 @@
 """
 Resolve the App Store Connect version slot for this run.
 
-Apple permits at most ONE editable appStoreVersion per app at a time. If one
-already exists under a different versionString, creating another returns 409
-ENTITY_ERROR.RELATIONSHIP.INVALID. We therefore PATCH the existing editable
-slot to the desired versionString rather than attempt a second CREATE.
-
-Reads PROJECT_MARKETING_VERSION from env (pinned in Xcode) and decides whether
-to REUSE an editable draft (directly or via PATCH) or CREATE a new one. Never
-auto-bumps the version.
-
-Env: ASC_KEY_ID, ASC_ISSUER_ID, ASC_KEY_PATH, APP_STORE_APPLE_ID,
-     PROJECT_MARKETING_VERSION (e.g. "1.2.3" or "1.2").
+Faithful port of gowalk-step/manage_version.py. The CI -- not the Xcode
+project -- decides the marketing version. The archive step overrides the
+pbxproj MARKETING_VERSION at build time via `MARKETING_VERSION=...` on the
+xcodebuild command line.
+
+Algorithm:
+  1. Fetch all appStoreVersions for the app (no sort, no filter).
+  2. No versions at all -> first release: CREATE "1.0.0".
+  3. Pick latest by createdDate.
+     - state == PENDING_DEVELOPER_RELEASE -> fail (must be released first).
+     - state == READY_FOR_SALE             -> auto-bump and CREATE the next
+       version with rollover (patch<10 -> +1; patch>=10 -> reset, minor+1;
+       minor>=10 -> reset, major+1).
+     - anything else (PREPARE_FOR_SUBMISSION, WAITING_FOR_REVIEW, IN_REVIEW,
+       REJECTED, ...) -> REUSE it.
+  4. 409 on CREATE (race) -> re-fetch, match by versionString, REUSE that id.
+
+Env: ASC_KEY_ID, ASC_ISSUER_ID, ASC_KEY_PATH, APP_STORE_APPLE_ID.
 Stdout: {"decision":"REUSE|CREATE","versionString":"...","appStoreVersionId":"..."}
-Stderr: human log + ::error:: lines for GitHub Actions.
+Stderr: [decision] log lines + ::error:: on fatal conditions.
 """
 
 from __future__ import annotations
@@ -24,18 +31,10 @@ import os
 import re
 import sys
 
-from asc_common import (
-    BLOCKING_STATES,
-    EDITABLE_STATES,
-    TERMINAL_STATES,
-    get_json,
-    make_jwt,
-    request,
-)
+from asc_common import get_json, make_jwt, request
 
 
 SEM_RE = re.compile(r"^(\d+)\.(\d+)(?:\.(\d+))?$")
-MAX_RECURSIONS = 2
 
 
 def _log(msg: str) -> None:
@@ -58,136 +57,50 @@ def env(name: str) -> str:
     return val
 
 
-def normalize(v: str) -> str:
-    m = SEM_RE.match(v)
+def calculate_next_version(current_version: str) -> str:
+    """Rollover bump: patch+1; patch>=10 resets to 0 and minor+1;
+    minor>=10 resets both to 0 and major+1. Accepts "M.m" or "M.m.p"."""
+    m = SEM_RE.match(current_version or "")
     if not m:
-        print(
-            f"::error::PROJECT_MARKETING_VERSION ({v!r}) is not a valid "
-            f"semantic version (expected MAJOR.MINOR[.PATCH]).",
-            file=sys.stderr,
+        raise SystemExit(
+            f"::error::Latest App Store versionString {current_version!r} is "
+            f"not a valid semantic version (expected MAJOR.MINOR[.PATCH])."
         )
-        raise SystemExit(1)
-    return f"{m.group(1)}.{m.group(2)}.{m.group(3) or '0'}"
-
+    major = int(m.group(1))
+    minor = int(m.group(2))
+    patch = int(m.group(3) or "0")
 
-def to_tuple(v: str) -> tuple[int, int, int]:
-    m = SEM_RE.match(v or "")
-    if not m:
-        return (0, 0, 0)
-    return int(m.group(1)), int(m.group(2)), int(m.group(3) or "0")
+    new_patch = patch + 1
+    new_minor = minor
+    new_major = major
 
+    if new_patch >= 10:
+        new_patch = 0
+        new_minor = minor + 1
+    if new_minor >= 10:
+        new_minor = 0
+        new_patch = 0
+        new_major = major + 1
 
-def same_version(a: str, b: str) -> bool:
-    """1.2 == 1.2.0 via normalized tuple comparison."""
-    return to_tuple(a) == to_tuple(b)
+    return f"{new_major}.{new_minor}.{new_patch}"
 
 
 def fetch_versions(app_id: str, token: str) -> list[dict]:
-    """Return list of {'versionString','state','id','createdDate'} for IOS."""
-    data = get_json(
-        f"/apps/{app_id}/appStoreVersions",
-        token,
-        params={"limit": 200, "filter[platform]": "IOS"},
-    )
+    """All appStoreVersions for the app. Mirrors gowalk-step: no sort, no
+    limit, no platform filter -- we do client-side selection."""
+    data = get_json(f"/apps/{app_id}/appStoreVersions", token)
     out: list[dict] = []
     for item in data.get("data", []):
         attrs = item.get("attributes") or {}
-        out.append(
-            {
-                "versionString": attrs.get("versionString") or "",
-                "state": attrs.get("appStoreState") or "",
-                "id": item.get("id") or "",
-                "createdDate": attrs.get("createdDate") or "",
-            }
-        )
+        out.append({
+            "versionString": attrs.get("versionString") or "",
+            "state": attrs.get("appStoreState") or "",
+            "id": item.get("id") or "",
+            "createdDate": attrs.get("createdDate") or "",
+        })
     return out
 
 
-def partition(versions: list[dict]) -> tuple[list[dict], list[dict], list[dict]]:
-    """Split versions into (editable, blocking, terminal) buckets."""
-    ed, bl, te = [], [], []
-    for v in versions:
-        st = v["state"]
-        if st in EDITABLE_STATES:
-            ed.append(v)
-        elif st in BLOCKING_STATES:
-            bl.append(v)
-        elif st in TERMINAL_STATES:
-            te.append(v)
-    return ed, bl, te
-
-
-def pick_latest_editable(editable: list[dict]) -> dict:
-    """Latest by createdDate; ties broken by id desc."""
-    return sorted(
-        editable,
-        key=lambda v: (v.get("createdDate", ""), v.get("id", "")),
-        reverse=True,
-    )[0]
-
-
-def highest_terminal_tuple(te: list[dict]) -> tuple[int, int, int] | None:
-    best: tuple[int, int, int] | None = None
-    for v in te:
-        if not SEM_RE.match(v["versionString"] or ""):
-            continue
-        t = to_tuple(v["versionString"])
-        if best is None or t > best:
-            best = t
-    return best
-
-
-def fail_terminal(v: str, state: str) -> None:
-    print(
-        f"::error::Version {v} is already {state} on App Store Connect. "
-        f"Bump MARKETING_VERSION in the Xcode project to publish a new "
-        f"release.",
-        file=sys.stderr,
-    )
-    raise SystemExit(1)
-
-
-def fail_blocking(v: str) -> None:
-    print(
-        f"::error::Version {v} is PENDING_DEVELOPER_RELEASE on App Store "
-        f"Connect. Release it manually (or bump MARKETING_VERSION in the "
-        f"Xcode project), then retry.",
-        file=sys.stderr,
-    )
-    raise SystemExit(1)
-
-
-def fail_not_higher(v: str, published: tuple[int, int, int]) -> None:
-    p = ".".join(str(x) for x in published)
-    print(
-        f"::error::MARKETING_VERSION ({v}) is not higher than the published "
-        f"version ({p}) on App Store Connect. Bump MARKETING_VERSION in the "
-        f"Xcode project.",
-        file=sys.stderr,
-    )
-    raise SystemExit(1)
-
-
-def guard_not_downgrade(v: str, te: list[dict]) -> None:
-    top = highest_terminal_tuple(te)
-    if top is not None and to_tuple(v) <= top:
-        fail_not_higher(v, top)
-
-
-def patch_version_string(slot_id: str, version: str, token: str):
-    body = {
-        "data": {
-            "type": "appStoreVersions",
-            "id": slot_id,
-            "attributes": {"versionString": version},
-        }
-    }
-    return request(
-        "PATCH", f"/appStoreVersions/{slot_id}", token,
-        json_body=body, allow_status={409},
-    )
-
-
 def create_version(app_id: str, version: str, token: str):
     body = {
         "data": {
@@ -208,68 +121,26 @@ def create_version(app_id: str, version: str, token: str):
     )
 
 
-def _reenter_on_409(
-    app_id: str, version: str, token: str, depth: int, label: str,
-) -> dict:
-    if depth >= MAX_RECURSIONS:
-        raise SystemExit(
-            f"{label} returned 409 after {depth} recursion(s); giving up."
-        )
+def create_or_reuse(app_id: str, version: str, token: str) -> str:
+    """POST a new version; on 409 race, re-fetch and return existing id.
+    Returns the appStoreVersion id."""
+    resp = create_version(app_id, version, token)
+    if resp.status_code != 409:
+        return resp.json()["data"]["id"]
+
+    # Race: someone else created it between our GET and POST. Find by name.
     print(
-        f"{label} returned 409; re-fetching and redeciding "
-        f"(depth={depth + 1})",
+        f"POST /appStoreVersions returned 409 for {version}; "
+        "re-fetching to locate the existing slot.",
         file=sys.stderr,
     )
-    return decide(app_id, version, token, depth + 1)
-
-
-def decide(
-    app_id: str, project_version: str, token: str, depth: int = 0,
-) -> dict:
-    """Decision tree; re-enters up to MAX_RECURSIONS on 409 races."""
-    versions = fetch_versions(app_id, token)
-    editable, blocking, terminal = partition(versions)
-
-    # 1. Blocking match on the target versionString (awaiting dev release).
-    for v in blocking:
-        if same_version(v["versionString"], project_version):
-            fail_blocking(project_version)
-
-    # 2. Editable slot exists — reuse (directly or via PATCH rename).
-    if editable:
-        latest = pick_latest_editable(editable)
-        if same_version(latest["versionString"], project_version):
-            _log(f"REUSE {project_version} (state={latest['state']}, "
-                 f"id={latest['id']})")
-            return _result("REUSE", project_version, latest["id"])
-
-        guard_not_downgrade(project_version, terminal)
-        old_v, prior = latest["versionString"], latest["state"]
-        resp = patch_version_string(latest["id"], project_version, token)
-        if resp.status_code == 409:
-            return _reenter_on_409(
-                app_id, project_version, token, depth,
-                f"PATCH /appStoreVersions/{latest['id']}",
-            )
-        new_id = resp.json()["data"]["id"]
-        _log(f"REUSE {project_version} (patched from {old_v}, id={new_id}, "
-             f"prior_state={prior})")
-        return _result("REUSE", project_version, new_id)
-
-    # 3. No editable slots — check terminal collision, then CREATE.
-    for v in terminal:
-        if same_version(v["versionString"], project_version):
-            fail_terminal(project_version, v["state"])
-    guard_not_downgrade(project_version, terminal)
-
-    resp = create_version(app_id, project_version, token)
-    if resp.status_code == 409:
-        return _reenter_on_409(
-            app_id, project_version, token, depth, "POST /appStoreVersions",
-        )
-    new_id = resp.json()["data"]["id"]
-    _log(f"CREATE {project_version} -> appStoreVersion id={new_id}")
-    return _result("CREATE", project_version, new_id)
+    for v in fetch_versions(app_id, token):
+        if v["versionString"] == version:
+            return v["id"]
+    raise SystemExit(
+        f"::error::POST /appStoreVersions returned 409 for {version} but "
+        f"no matching versionString was found on re-fetch."
+    )
 
 
 def main() -> None:
@@ -277,11 +148,48 @@ def main() -> None:
     issuer_id = env("ASC_ISSUER_ID")
     key_path = env("ASC_KEY_PATH")
     app_id = env("APP_STORE_APPLE_ID")
-    project_version = normalize(env("PROJECT_MARKETING_VERSION"))
 
     token = make_jwt(key_id, issuer_id, key_path)
-    result = decide(app_id, project_version, token)
-    print(json.dumps(result))
+    versions = fetch_versions(app_id, token)
+
+    # 1. First ever release.
+    if not versions:
+        new_version = "1.0.0"
+        new_id = create_or_reuse(app_id, new_version, token)
+        _log(f"CREATE {new_version} (first release) -> appStoreVersion id={new_id}")
+        print(json.dumps(_result("CREATE", new_version, new_id)))
+        return
+
+    # 2. Pick the latest by Apple's createdDate.
+    latest = max(versions, key=lambda v: v.get("createdDate", ""))
+    state = latest["state"]
+    version_string = latest["versionString"]
+    version_id = latest["id"]
+
+    # 3. Blocking: pending developer release.
+    if state == "PENDING_DEVELOPER_RELEASE":
+        print(
+            f"::error::Latest App Store version {version_string} is "
+            f"PENDING_DEVELOPER_RELEASE. Release it in App Store Connect, "
+            f"then retry.",
+            file=sys.stderr,
+        )
+        raise SystemExit(1)
+
+    # 4. Live: auto-bump to next version.
+    if state == "READY_FOR_SALE":
+        new_version = calculate_next_version(version_string)
+        new_id = create_or_reuse(app_id, new_version, token)
+        _log(
+            f"CREATE {new_version} (previous={version_string}, "
+            f"previous_state={state}) -> appStoreVersion id={new_id}"
+        )
+        print(json.dumps(_result("CREATE", new_version, new_id)))
+        return
+
+    # 5. Editable/in-review/rejected/etc: reuse as-is.
+    _log(f"REUSE {version_string} (state={state}, id={version_id})")
+    print(json.dumps(_result("REUSE", version_string, version_id)))
 
 
 if __name__ == "__main__":

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())