@daemux/store-automator 0.10.70 → 0.10.71

package/.claude-plugin/marketplace.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daemux/store-automator",
-  "version": "0.10.70",
+  "version": "0.10.71",
   "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.70",
+  "version": "0.10.71",
   "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,18 +2,19 @@
 """
 Resolve the App Store Connect version slot for this run.
 
-Reads MARKETING_VERSION from the Xcode project (via env) and decides whether
-to REUSE an existing editable draft on ASC or CREATE a new one. Never
-auto-bumps the version — the developer pins intent in Xcode, CI honours it.
-
-Environment:
-  ASC_KEY_ID, ASC_ISSUER_ID, ASC_KEY_PATH, APP_STORE_APPLE_ID
-  PROJECT_MARKETING_VERSION  — e.g. "1.2.3" or "1.2" (normalized to 3-part)
-
-Stdout: single-line JSON
-  {"decision":"REUSE|CREATE","versionString":"...","appStoreVersionId":"..."}
-
-Stderr: human-readable log + ::error:: lines for GitHub Actions.
+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").
+Stdout: {"decision":"REUSE|CREATE","versionString":"...","appStoreVersionId":"..."}
+Stderr: human log + ::error:: lines for GitHub Actions.
 """
 
 from __future__ import annotations
@@ -34,6 +35,19 @@ from asc_common import (
 
 
 SEM_RE = re.compile(r"^(\d+)\.(\d+)(?:\.(\d+))?$")
+MAX_RECURSIONS = 2
+
+
+def _log(msg: str) -> None:
+    print(f"[decision] {msg}", file=sys.stderr)
+
+
+def _result(decision: str, version: str, vid: str) -> dict:
+    return {
+        "decision": decision,
+        "versionString": version,
+        "appStoreVersionId": vid,
+    }
 
 
 def env(name: str) -> str:
@@ -53,26 +67,27 @@ def normalize(v: str) -> str:
             file=sys.stderr,
         )
         raise SystemExit(1)
-    major, minor, patch = m.group(1), m.group(2), m.group(3) or "0"
-    return f"{major}.{minor}.{patch}"
+    return f"{m.group(1)}.{m.group(2)}.{m.group(3) or '0'}"
 
 
 def to_tuple(v: str) -> tuple[int, int, int]:
-    parts = v.split(".")
-    while len(parts) < 3:
-        parts.append("0")
-    return int(parts[0]), int(parts[1]), int(parts[2])
+    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")
+
+
+def same_version(a: str, b: str) -> bool:
+    """1.2 == 1.2.0 via normalized tuple comparison."""
+    return to_tuple(a) == to_tuple(b)
 
 
 def fetch_versions(app_id: str, token: str) -> list[dict]:
-    """Return list of {'versionString','state','id'} for IOS versions."""
+    """Return list of {'versionString','state','id','createdDate'} for IOS."""
     data = get_json(
         f"/apps/{app_id}/appStoreVersions",
         token,
-        params={
-            "limit": 200,
-            "filter[platform]": "IOS",
-        },
+        params={"limit": 200, "filter[platform]": "IOS"},
     )
     out: list[dict] = []
     for item in data.get("data", []):
@@ -82,18 +97,39 @@ def fetch_versions(app_id: str, token: str) -> list[dict]:
                 "versionString": attrs.get("versionString") or "",
                 "state": attrs.get("appStoreState") or "",
                 "id": item.get("id") or "",
+                "createdDate": attrs.get("createdDate") or "",
             }
         )
     return out
 
 
-def highest_terminal(versions: list[dict]) -> tuple[int, int, int] | None:
-    best: tuple[int, int, int] | None = None
+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:
-        if v["state"] not in TERMINAL_STATES:
-            continue
-        parsed = SEM_RE.match(v["versionString"])
-        if not parsed:
+        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:
@@ -132,7 +168,27 @@ def fail_not_higher(v: str, published: tuple[int, int, int]) -> None:
     raise SystemExit(1)
 
 
-def create_version(app_id: str, version: str, token: str) -> str:
+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": {
             "type": "appStoreVersions",
@@ -146,40 +202,74 @@ def create_version(app_id: str, version: str, token: str) -> str:
             },
         }
     }
-    resp = request(
-        "POST",
-        "/appStoreVersions",
-        token,
-        json_body=body,
-        allow_status={409},
+    return request(
+        "POST", "/appStoreVersions", token,
+        json_body=body, allow_status={409},
     )
-    if resp.status_code == 409:
-        # Race / eventual consistency: re-query and treat as REUSE if editable.
-        versions = fetch_versions(app_id, token)
-        match = next(
-            (v for v in versions if v["versionString"] == version), None
-        )
-        if match and match["state"] in EDITABLE_STATES:
-            print(
-                f"[decision] REUSE {version} (state={match['state']}, "
-                f"id={match['id']}) — recovered from 409 on create",
-                file=sys.stderr,
-            )
-            return match["id"]
-        if match and match["state"] in BLOCKING_STATES:
-            fail_blocking(version)
-        if match:
-            fail_terminal(version, match["state"])
+
+
+def _reenter_on_409(
+    app_id: str, version: str, token: str, depth: int, label: str,
+) -> dict:
+    if depth >= MAX_RECURSIONS:
         raise SystemExit(
-            f"POST /appStoreVersions returned 409 but no matching version "
-            f"{version} was found on re-query:\n{resp.text[:500]}"
+            f"{label} returned 409 after {depth} recursion(s); giving up."
         )
-    new_id = resp.json()["data"]["id"]
     print(
-        f"[decision] CREATE {version} -> appStoreVersion id={new_id}",
+        f"{label} returned 409; re-fetching and redeciding "
+        f"(depth={depth + 1})",
         file=sys.stderr,
     )
-    return new_id
+    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)
 
 
 def main() -> None:
@@ -190,39 +280,7 @@ def main() -> None:
     project_version = normalize(env("PROJECT_MARKETING_VERSION"))
 
     token = make_jwt(key_id, issuer_id, key_path)
-    versions = fetch_versions(app_id, token)
-    match = next(
-        (v for v in versions if v["versionString"] == project_version), None
-    )
-
-    if match and match["state"] in EDITABLE_STATES:
-        print(
-            f"[decision] REUSE {project_version} (state={match['state']}, "
-            f"id={match['id']})",
-            file=sys.stderr,
-        )
-        result = {
-            "decision": "REUSE",
-            "versionString": project_version,
-            "appStoreVersionId": match["id"],
-        }
-    elif match and match["state"] in BLOCKING_STATES:
-        fail_blocking(project_version)
-        return  # unreachable
-    elif match and match["state"] in TERMINAL_STATES:
-        fail_terminal(project_version, match["state"])
-        return  # unreachable
-    else:
-        top = highest_terminal(versions)
-        if top is not None and to_tuple(project_version) <= top:
-            fail_not_higher(project_version, top)
-        new_id = create_version(app_id, project_version, token)
-        result = {
-            "decision": "CREATE",
-            "versionString": project_version,
-            "appStoreVersionId": new_id,
-        }
-
+    result = decide(app_id, project_version, token)
     print(json.dumps(result))