@daemux/store-automator 0.10.83 → 0.10.85

package/.claude-plugin/marketplace.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daemux/store-automator",
-  "version": "0.10.83",
+  "version": "0.10.85",
   "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.83",
+  "version": "0.10.85",
   "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,22 +2,33 @@
 """
 Resolve the App Store Connect version slot for this run.
 
-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.
+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 (improvement over gowalk-step's "latest by createdDate"):
+  1. Fetch all appStoreVersions for the app.
+  2. Partition by state:
+       editable  (PREPARE_FOR_SUBMISSION, REJECTED, METADATA_REJECTED,
+                  DEVELOPER_REJECTED, INVALID_BINARY, WAITING_FOR_REVIEW,
+                  IN_REVIEW)
+       blocking  (PENDING_DEVELOPER_RELEASE)
+       terminal  (READY_FOR_SALE, PROCESSING_FOR_APP_STORE,
+                  PENDING_APPLE_RELEASE, REPLACED_WITH_NEW_VERSION,
+                  REMOVED_FROM_SALE, NOT_APPLICABLE)
+  3. If editable: REUSE the HIGHEST SEMVER among editable. Picking the
+     highest semver (not the latest createdDate) matches how Apple's UI
+     presents the "next" version and avoids the "later version closed"
+     error Apple returns on uploads to a lower editable version when a
+     higher one already exists.
+  4. Elif blocking: fail with a clear error -- a human must release the
+     pending version manually before CI can proceed.
+  5. Elif terminal: pick the highest-semver terminal version.
+       - READY_FOR_SALE -> CREATE the next version via rollover bump.
+       - anything else  -> fail (manual intervention required; state is
+         neither editable nor live).
+  6. No versions at all -> first release, CREATE "1.0.0".
+  7. 409 on CREATE (race) -> re-fetch, match by versionString, REUSE.
 
 Env: ASC_KEY_ID, ASC_ISSUER_ID, ASC_KEY_PATH, APP_STORE_APPLE_ID.
 Stdout: {"decision":"REUSE|CREATE","versionString":"...","appStoreVersionId":"..."}
@@ -31,7 +42,14 @@ import os
 import re
 import sys
 
-from asc_common import get_json, make_jwt, request
+from asc_common import (
+    BLOCKING_STATES,
+    EDITABLE_STATES,
+    TERMINAL_STATES,
+    get_json,
+    make_jwt,
+    request,
+)
 
 
 SEM_RE = re.compile(r"^(\d+)\.(\d+)(?:\.(\d+))?$")
@@ -57,14 +75,23 @@ def env(name: str) -> str:
     return val
 
 
+def semver_tuple(version_string: str) -> tuple[int, int, int]:
+    """Parse 'M.m[.p]' -> (M, m, p). Non-semver returns (-1,-1,-1) so it
+    sorts below any real version."""
+    m = SEM_RE.match(version_string or "")
+    if not m:
+        return (-1, -1, -1)
+    return (int(m.group(1)), int(m.group(2)), int(m.group(3) or "0"))
+
+
 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"."""
+    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:
         raise SystemExit(
-            f"::error::Latest App Store versionString {current_version!r} is "
-            f"not a valid semantic version (expected MAJOR.MINOR[.PATCH])."
+            f"::error::App Store versionString {current_version!r} is not a "
+            f"valid semantic version (expected MAJOR.MINOR[.PATCH])."
         )
     major = int(m.group(1))
     minor = int(m.group(2))
@@ -86,8 +113,7 @@ def calculate_next_version(current_version: str) -> str:
 
 
 def fetch_versions(app_id: str, token: str) -> list[dict]:
-    """All appStoreVersions for the app. Mirrors gowalk-step: no sort, no
-    limit, no platform filter -- we do client-side selection."""
+    """All appStoreVersions for the app (no sort/limit/filter)."""
     data = get_json(f"/apps/{app_id}/appStoreVersions", token)
     out: list[dict] = []
     for item in data.get("data", []):
@@ -122,13 +148,11 @@ def create_version(app_id: str, version: str, token: str):
 
 
 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."""
+    """POST a new version; on 409 race, re-fetch and return existing 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"POST /appStoreVersions returned 409 for {version}; "
         "re-fetching to locate the existing slot.",
@@ -143,53 +167,93 @@ def create_or_reuse(app_id: str, version: str, token: str) -> str:
     )
 
 
-def main() -> None:
-    key_id = env("ASC_KEY_ID")
-    issuer_id = env("ASC_ISSUER_ID")
-    key_path = env("ASC_KEY_PATH")
-    app_id = env("APP_STORE_APPLE_ID")
+def _summarize(versions: list[dict]) -> str:
+    return ", ".join(
+        f"{v['versionString']}({v['state']})" for v in versions
+    ) or "<none>"
 
-    token = make_jwt(key_id, issuer_id, key_path)
-    versions = fetch_versions(app_id, token)
 
-    # 1. First ever release.
+def _pick_highest_semver(versions: list[dict]) -> dict:
+    """Tiebreak by createdDate (newer wins) when semvers collide."""
+    return max(
+        versions,
+        key=lambda v: (semver_tuple(v["versionString"]), v.get("createdDate", "")),
+    )
+
+
+def decide(versions: list[dict], app_id: str, token: str) -> dict:
     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
+        return _result("CREATE", new_version, new_id)
+
+    editable = [v for v in versions if v["state"] in EDITABLE_STATES]
+    blocking = [v for v in versions if v["state"] in BLOCKING_STATES]
+    terminal = [v for v in versions if v["state"] in TERMINAL_STATES]
+    _log(
+        f"editable=[{_summarize(editable)}] "
+        f"blocking=[{_summarize(blocking)}] "
+        f"terminal=[{_summarize(terminal)}]"
+    )
 
-    # 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"]
+    if editable:
+        target = _pick_highest_semver(editable)
+        _log(
+            f"REUSE {target['versionString']} (highest-semver editable, "
+            f"state={target['state']}, id={target['id']})"
+        )
+        return _result("REUSE", target["versionString"], target["id"])
 
-    # 3. Blocking: pending developer release.
-    if state == "PENDING_DEVELOPER_RELEASE":
+    if blocking:
+        target = _pick_highest_semver(blocking)
         print(
-            f"::error::Latest App Store version {version_string} is "
-            f"PENDING_DEVELOPER_RELEASE. Release it in App Store Connect, "
-            f"then retry.",
+            f"::error::App Store version {target['versionString']} is "
+            f"{target['state']}. Release it in App Store Connect, 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)
+    if terminal:
+        target = _pick_highest_semver(terminal)
+        if target["state"] != "READY_FOR_SALE":
+            print(
+                f"::error::Highest App Store version {target['versionString']} "
+                f"is {target['state']}; neither editable nor live. Manual "
+                f"intervention required in App Store Connect.",
+                file=sys.stderr,
+            )
+            raise SystemExit(1)
+        new_version = calculate_next_version(target["versionString"])
         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}"
+            f"CREATE {new_version} (previous={target['versionString']}, "
+            f"previous_state={target['state']}) -> appStoreVersion id={new_id}"
         )
-        print(json.dumps(_result("CREATE", new_version, new_id)))
-        return
+        return _result("CREATE", new_version, new_id)
+
+    # Unknown state (not editable, not blocking, not terminal) -- refuse to
+    # guess. Lists both states in the error so ops can update the classifier.
+    unknown = ", ".join(f"{v['versionString']}({v['state']})" for v in versions)
+    print(
+        f"::error::No editable/blocking/terminal App Store versions found; "
+        f"all versions have unrecognized states: {unknown}. Update "
+        f"asc_common.EDITABLE_STATES / TERMINAL_STATES / BLOCKING_STATES.",
+        file=sys.stderr,
+    )
+    raise SystemExit(1)
+
+
+def main() -> None:
+    key_id = env("ASC_KEY_ID")
+    issuer_id = env("ASC_ISSUER_ID")
+    key_path = env("ASC_KEY_PATH")
+    app_id = env("APP_STORE_APPLE_ID")
 
-    # 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)))
+    token = make_jwt(key_id, issuer_id, key_path)
+    versions = fetch_versions(app_id, token)
+    result = decide(versions, app_id, token)
+    print(json.dumps(result))
 
 
 if __name__ == "__main__":

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

@@ -38,8 +38,14 @@ Writes to $GITHUB_ENV:
     ASC_KEY_ID, ASC_ISSUER_ID, ASC_KEY_P8_PATH, ASC_KEY_P8,
     CFG_PROJECT, CFG_WORKSPACE, CFG_SCHEME, CFG_CONFIGURATION,
     CFG_BUNDLE_ID, CFG_TEAM_ID, CFG_APP_STORE_APPLE_ID, CFG_PROFILE_NAME,
-    CFG_USES_NON_EXEMPT, CFG_WHATS_NEW, CFG_LOCALE,
+    CFG_USES_NON_EXEMPT, CFG_WHATS_NEW, CFG_WHATS_NEW_FILE, CFG_LOCALE,
     CFG_RUN_TESTS, CFG_TEST_COMMAND, CFG_TEST_DESTINATION
+
+CFG_WHATS_NEW_FILE points at a file under $RUNNER_TEMP holding the raw
+multi-line release notes. Downstream steps MUST prefer the file over the
+env-var copy: GitHub Actions YAML's `${{ }}` substitution serializes
+multi-line strings in ways that can mangle embedded newlines, while a file
+path is a single-line string that survives interpolation untouched.
 """
 
 from __future__ import annotations
@@ -284,6 +290,22 @@ def main() -> None:
         shown = value if name != "CFG_WHATS_NEW" else value.replace("\n", " / ")
         log(f"{name}={shown!r} (source: {src})")
 
+    # Persist whatsNew to a file under $RUNNER_TEMP so downstream steps can
+    # read raw multi-line content without any GitHub Actions ${{ }} YAML
+    # interpolation mangling embedded newlines. CFG_WHATS_NEW still carries
+    # the same content for backward compatibility; the file is the source
+    # of truth.
+    whats_new_value = tf["whats_new"][0]
+    runner_temp = os.environ.get("RUNNER_TEMP") or str(workspace)
+    whats_new_path = Path(runner_temp) / "whats_new.txt"
+    whats_new_path.write_text(whats_new_value)
+    emit(env_file, "CFG_WHATS_NEW_FILE", str(whats_new_path))
+    log(
+        f"CFG_WHATS_NEW_FILE={whats_new_path} "
+        f"(length={len(whats_new_value)}, "
+        f"newlines={whats_new_value.count(chr(10))})"
+    )
+
 
 if __name__ == "__main__":
     main()

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

@@ -11,8 +11,12 @@ REST API (no fastlane dependency here):
   * 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.
+  * PATCHes whatsNew on EVERY appStoreVersionLocalization entry with the
+    same text. gowalk-step's set_changelog iterates every localization
+    (not just the default one) so users in every language see the release
+    notes rather than an empty "What's New" section when their locale
+    isn't en-US. If no localizations exist yet (brand-new version slot),
+    POST a single one for APP_STORE_LOCALE (default en-US) as a seed.
 
 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.
@@ -21,14 +25,24 @@ 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"
+  APP_STORE_WHATS_NEW_FILE                 -- path to file holding release notes
+                                              (preferred; sidesteps any YAML env
+                                              interpolation that may mangle
+                                              multi-line content)
+  APP_STORE_WHATS_NEW                      -- release notes text (fallback when
+                                              _FILE is unset / unreadable)
+  APP_STORE_LOCALE                         -- locale to seed when no
+                                              localizations exist; default
+                                              "en-US". Ignored when
+                                              localizations already exist --
+                                              every existing locale is updated.
 """
 
 from __future__ import annotations
 
 import os
 import sys
+from pathlib import Path
 
 from asc_common import get_json, make_jwt, request
 
@@ -101,15 +115,74 @@ def _create_localization(
     return resp.json()["data"]["id"]
 
 
+def _read_whats_new() -> tuple[str, str]:
+    """Return (content, source). Prefer a file path (no env interpolation
+    risk). Fall back to APP_STORE_WHATS_NEW env var. Returns ("", "<empty>")
+    when neither is populated."""
+    path = os.environ.get("APP_STORE_WHATS_NEW_FILE", "").strip()
+    if path:
+        try:
+            content = Path(path).read_text()
+            return content, f"file:{path}"
+        except OSError as exc:
+            _warn(
+                f"APP_STORE_WHATS_NEW_FILE={path} unreadable ({exc!r}); "
+                f"falling back to APP_STORE_WHATS_NEW env var."
+            )
+    content = os.environ.get("APP_STORE_WHATS_NEW", "")
+    if content:
+        return content, "env:APP_STORE_WHATS_NEW"
+    return "", "<empty>"
+
+
+def _update_all_localizations(
+    token: str, version_id: str, version: str, whats_new: str, seed_locale: str
+) -> int:
+    """PATCH whatsNew on every existing localization. If none exist, POST a
+    single seed localization in `seed_locale`. Returns the count of
+    localizations written."""
+    locs = get_json(
+        f"/appStoreVersions/{version_id}/appStoreVersionLocalizations", token
+    )
+    entries = locs.get("data") or []
+
+    if not entries:
+        new_id = _create_localization(token, version_id, seed_locale, whats_new)
+        _log(
+            f"CREATEd appStoreVersionLocalization {new_id} whatsNew for "
+            f"{version} ({seed_locale}) -- no prior localizations"
+        )
+        return 1
+
+    count = 0
+    for item in entries:
+        loc_id = item.get("id") or ""
+        loc = (item.get("attributes") or {}).get("locale") or "?"
+        if not loc_id:
+            _warn(f"skipping localization without id: {item!r}")
+            continue
+        _patch_localization(token, loc_id, whats_new)
+        _log(
+            f"PATCHed appStoreVersionLocalization {loc_id} whatsNew "
+            f"for {version} ({loc})"
+        )
+        count += 1
+    return count
+
+
 def main() -> int:
-    whats_new = os.environ.get("APP_STORE_WHATS_NEW", "")
+    whats_new, source = _read_whats_new()
+    _log(
+        f"whatsNew source={source} length={len(whats_new)} "
+        f"newlines={whats_new.count(chr(10))}"
+    )
     if not whats_new.strip():
-        _log("APP_STORE_WHATS_NEW empty; skipping.")
+        _log("whatsNew 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"
+    seed_locale = os.environ.get("APP_STORE_LOCALE", "").strip() or "en-US"
 
     if version in SKIP_VERSIONS:
         _log(f"Skipping whatsNew for first release {version}.")
@@ -130,30 +203,10 @@ def main() -> int:
         )
         return 0
 
-    locs = get_json(
-        f"/appStoreVersions/{version_id}/appStoreVersionLocalizations", token
+    count = _update_all_localizations(
+        token, version_id, version, whats_new, seed_locale
     )
-    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})"
-        )
+    _log(f"whatsNew set for {count} localizations on {version}")
     return 0