@daemux/store-automator 0.10.71 → 0.10.72

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.72"
   },
   "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.72",
       "keywords": [
         "flutter",
         "app-store",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daemux/store-automator",
-  "version": "0.10.71",
+  "version": "0.10.72",
   "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.72",
   "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__":