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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daemux/store-automator",
-  "version": "0.10.70",
+  "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.70",
+  "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,18 +2,26 @@
 """
 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.
+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: [decision] log lines + ::error:: on fatal conditions.
 """
 
 from __future__ import annotations
@@ -23,19 +31,24 @@ 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+))?$")
 
 
+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:
     val = os.environ.get(name)
     if not val:
@@ -44,95 +57,51 @@ 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)
-    major, minor, patch = m.group(1), m.group(2), m.group(3) or "0"
-    return f"{major}.{minor}.{patch}"
+    major = int(m.group(1))
+    minor = int(m.group(2))
+    patch = int(m.group(3) or "0")
 
+    new_patch = patch + 1
+    new_minor = minor
+    new_major = major
 
-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])
+    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
+
+    return f"{new_major}.{new_minor}.{new_patch}"
 
 
 def fetch_versions(app_id: str, token: str) -> list[dict]:
-    """Return list of {'versionString','state','id'} for IOS versions."""
-    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 "",
-            }
-        )
+        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 highest_terminal(versions: list[dict]) -> tuple[int, int, int] | None:
-    best: tuple[int, int, int] | None = None
-    for v in versions:
-        if v["state"] not in TERMINAL_STATES:
-            continue
-        parsed = SEM_RE.match(v["versionString"])
-        if not parsed:
-            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 create_version(app_id: str, version: str, token: str) -> str:
+def create_version(app_id: str, version: str, token: str):
     body = {
         "data": {
             "type": "appStoreVersions",
@@ -146,40 +115,32 @@ 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"])
-        raise SystemExit(
-            f"POST /appStoreVersions returned 409 but no matching version "
-            f"{version} was found on re-query:\n{resp.text[:500]}"
-        )
-    new_id = resp.json()["data"]["id"]
+
+
+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"[decision] CREATE {version} -> appStoreVersion id={new_id}",
+        f"POST /appStoreVersions returned 409 for {version}; "
+        "re-fetching to locate the existing slot.",
         file=sys.stderr,
     )
-    return 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:
@@ -187,43 +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)
     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:
+    # 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"[decision] REUSE {project_version} (state={match['state']}, "
-            f"id={match['id']})",
+            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,
         )
-        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,
-        }
+        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
 
-    print(json.dumps(result))
+    # 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__":