shipstores 0.1.0__py3-none-any.whl

shipstores/__init__.py

@@ -0,0 +1,3 @@
+"""MCP server for publishing apps to the App Store and Google Play."""
+
+__version__ = "0.1.0"

shipstores/apple.py

@@ -0,0 +1,222 @@
+"""App Store Connect API client (JWT ES256)."""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import subprocess
+import time
+from typing import Callable, TypeVar
+from pathlib import Path
+from typing import Any
+
+import httpx
+import jwt
+
+from .config import AppleConfig, load_apple
+
+BASE_URL = "https://api.appstoreconnect.apple.com"
+TOKEN_TTL_SECONDS = 900  # Apple's maximum lifetime for API tokens
+
+
+class AppleError(RuntimeError):
+    pass
+
+T = TypeVar("T")
+
+RETRY_TENTATIVAS = 5
+
+
+def with_retry(fn: Callable[[], T], what: str, tentativas: int = RETRY_TENTATIVAS) -> T:
+    """Retry a network call with exponential backoff.
+
+    Screenshot uploads send ~1 MB files to Apple's CDN, and a connection dropped
+    mid-transfer is common. Without this, a single network failure leaves the
+    screenshot set half-uploaded.
+    """
+    for n in range(1, tentativas + 1):
+        try:
+            return fn()
+        except (httpx.TransportError, httpx.HTTPStatusError) as exc:
+            if n == tentativas:
+                raise AppleError(f"{what} failed after {tentativas} attempts: {exc}") from exc
+            time.sleep(2**n)
+    raise AppleError(f"{what}: unreachable")
+
+
+def _token(cfg: AppleConfig) -> str:
+    now = int(time.time())
+    return jwt.encode(
+        {
+            "iss": cfg.issuer_id,
+            "iat": now,
+            "exp": now + TOKEN_TTL_SECONDS,
+            "aud": "appstoreconnect-v1",
+        },
+        cfg.private_key,
+        algorithm="ES256",
+        headers={"kid": cfg.key_id, "typ": "JWT"},
+    )
+
+
+def request(
+    method: str,
+    path: str,
+    *,
+    params: dict[str, Any] | None = None,
+    json: dict[str, Any] | None = None,
+    cfg: AppleConfig | None = None,
+) -> dict[str, Any]:
+    cfg = cfg or load_apple()
+
+    def chamar() -> httpx.Response:
+        resp = httpx.request(
+            method,
+            f"{BASE_URL}{path}",
+            headers={"Authorization": f"Bearer {_token(cfg)}"},
+            params=params,
+            json=json,
+            timeout=120,
+        )
+        # 5xx means instability on Apple's side: worth retrying. 4xx is a usage error.
+        if resp.status_code >= 500:
+            resp.raise_for_status()
+        return resp
+
+    resp = with_retry(chamar, f"ASC {method} {path}")
+    if resp.status_code >= 400:
+        detail = resp.text[:800]
+        raise AppleError(f"ASC {method} {path} -> HTTP {resp.status_code}: {detail}")
+    return resp.json() if resp.content else {}
+
+
+def upload_asset(
+    resource: str,
+    file_path: Path,
+    relationships: dict[str, Any],
+    *,
+    cfg: AppleConfig | None = None,
+) -> str:
+    """Upload a file to App Store Connect and return the id of the created resource.
+
+    App Store Connect uploads happen in three steps: reserve the asset, send the
+    bytes to the URLs it returns, and commit with the checksum. Works for any
+    resource that follows this contract (version screenshots, subscription
+    review screenshots). Every step is retried — ~1 MB files sent to Apple's
+    CDN fail often.
+    """
+    cfg = cfg or load_apple()
+    conteudo = file_path.read_bytes()
+    nome = file_path.name
+
+    def reservar() -> dict[str, Any]:
+        return request(
+            "POST",
+            f"/v1/{resource}",
+            json={
+                "data": {
+                    "type": resource,
+                    "attributes": {"fileName": nome, "fileSize": len(conteudo)},
+                    "relationships": relationships,
+                }
+            },
+            cfg=cfg,
+        )
+
+    reserva = reservar()
+    asset_id = reserva["data"]["id"]
+
+    for operacao in reserva["data"]["attributes"]["uploadOperations"]:
+        trecho = conteudo[operacao["offset"] : operacao["offset"] + operacao["length"]]
+
+        def enviar(op: dict[str, Any] = operacao, bloco: bytes = trecho) -> None:
+            resposta = httpx.request(
+                op["method"],
+                op["url"],
+                headers={h["name"]: h["value"] for h in op.get("requestHeaders", [])},
+                content=bloco,
+                timeout=600,
+            )
+            resposta.raise_for_status()
+
+        with_retry(enviar, f"upload {nome}")
+
+    def confirmar() -> None:
+        try:
+            request(
+                "PATCH",
+                f"/v1/{resource}/{asset_id}",
+                json={
+                    "data": {
+                        "type": resource,
+                        "id": asset_id,
+                        "attributes": {
+                            "uploaded": True,
+                            "sourceFileChecksum": hashlib.md5(conteudo).hexdigest(),
+                        },
+                    }
+                },
+                cfg=cfg,
+            )
+        except AppleError as exc:
+            # This PATCH is not idempotent: if the response was lost and the retry
+            # resent it, ASC answers 409 ("can't be re-committed"). When the
+            # asset is already COMPLETE, the upload succeeded — not an error.
+            if "HTTP 409" not in str(exc):
+                raise
+            estado = request("GET", f"/v1/{resource}/{asset_id}", cfg=cfg)
+            entrega = estado["data"]["attributes"].get("assetDeliveryState") or {}
+            if entrega.get("state") != "COMPLETE":
+                raise
+
+    confirmar()
+    return asset_id
+
+
+def set_order(resource: str, set_id: str, child: str, ids: list[str]) -> None:
+    """Pin the display order of a set (screenshots, previews).
+
+    Without this the order falls back to creation order, which Apple does not guarantee.
+    """
+    cfg = load_apple()
+
+    def chamar() -> httpx.Response:
+        resp = httpx.patch(
+            f"{BASE_URL}/v1/{resource}/{set_id}/relationships/{child}",
+            headers={"Authorization": f"Bearer {_token(cfg)}"},
+            json={"data": [{"type": child, "id": i} for i in ids]},
+            timeout=120,
+        )
+        if resp.status_code >= 500:
+            resp.raise_for_status()
+        return resp
+
+    resp = with_retry(chamar, f"reorder {resource}")
+    if resp.status_code >= 400:
+        raise AppleError(f"reordering failed: HTTP {resp.status_code} {resp.text[:300]}")
+
+
+def upload_binary(ipa_path: Path, platform: str, cfg: AppleConfig) -> str:
+    """Upload an .ipa via `xcrun altool`. Returns the command's combined output.
+
+    altool does not accept a key path as an argument, but it honors
+    API_PRIVATE_KEYS_DIR: point it straight at the .p8's folder, no copying or linking.
+    """
+    env = {**os.environ, "API_PRIVATE_KEYS_DIR": str(cfg.private_key_path.parent)}
+    result = subprocess.run(
+        [
+            "xcrun", "altool", "--upload-app",
+            "-f", str(ipa_path),
+            "-t", platform,
+            "--apiKey", cfg.key_id,
+            "--apiIssuer", cfg.issuer_id,
+        ],
+        capture_output=True,
+        text=True,
+        timeout=3600,
+        env=env,
+    )
+    output = f"{result.stdout}\n{result.stderr}".strip()
+    if result.returncode != 0:
+        raise AppleError(f"altool failed (exit {result.returncode}):\n{output}")
+    return output

shipstores/apple_console.py

@@ -0,0 +1,132 @@
+"""App settings that only exist in the console's internal API (/iris).
+
+Territory availability and "App Privacy" have no usable public endpoint: setting
+availability through the public API answers 409 even with every territory in the
+payload, and privacy does not exist there at all. The web console uses /iris with
+the cookie session, so these operations run as fetch calls inside an App Store
+Connect page in the dedicated Chrome.
+
+Rules Apple does not document (validated against a production app):
+- appAvailabilities requires ALL territories in `included`, each with `available`.
+- appDataUsages: category, purpose and protection go in the SAME record. Separate
+  records (purpose only, protection only) are accepted one by one, but publishing
+  fails with "An app data usage is missing a category/purpose or data protection type".
+"""
+
+from __future__ import annotations
+
+import json
+
+from . import browser
+
+ASC = "https://appstoreconnect.apple.com"
+
+DATA_CATEGORIES = (
+    "PAYMENT_INFORMATION", "CREDIT_AND_FRAUD", "OTHER_FINANCIAL_INFO", "PRECISE_LOCATION",
+    "COARSE_LOCATION", "SENSITIVE_INFO", "PHYSICAL_ADDRESS", "EMAIL_ADDRESS", "NAME",
+    "PHONE_NUMBER", "OTHER_CONTACT_INFO", "CONTACTS", "EMAILS_OR_TEXT_MESSAGES",
+    "PHOTOS_OR_VIDEOS", "AUDIO", "GAMEPLAY_CONTENT", "CUSTOMER_SUPPORT", "OTHER_USER_CONTENT",
+    "BROWSING_HISTORY", "SEARCH_HISTORY", "USER_ID", "DEVICE_ID", "PURCHASE_HISTORY",
+    "PRODUCT_INTERACTION", "ADVERTISING_DATA", "OTHER_USAGE_DATA", "CRASH_DATA",
+    "PERFORMANCE_DATA", "OTHER_DIAGNOSTIC_DATA", "OTHER_DATA", "HEALTH", "FITNESS",
+    "ENVIRONMENTAL_SCANNING", "HANDS", "HEAD_MOVEMENT",
+)
+DATA_PURPOSES = (
+    "THIRD_PARTY_ADVERTISING", "DEVELOPERS_ADVERTISING", "ANALYTICS",
+    "PRODUCT_PERSONALIZATION", "APP_FUNCTIONALITY", "OTHER_PURPOSES",
+)
+
+
+def _run_iris(app_id: str, body_js: str, timeout: int = 300) -> dict:
+    """Run `body_js` (the body of an async function that returns an object) in a console page."""
+    script = f"""
+import time
+new_tab({f"{ASC}/apps/{app_id}/distribution"!r})
+wait_for_load()
+time.sleep(3)
+js(r\"\"\"window.__sp='running';(async()=>{{
+ const H={{'Content-Type':'application/json'}};
+ const req=async (method,path,body)=>{{const r=await fetch(path,{{method,credentials:'include',headers:H,body:body?JSON.stringify(body):undefined}});
+   const t=await r.text(); return {{status:r.status, json:(()=>{{try{{return JSON.parse(t)}}catch(e){{return null}}}})(), text:t.slice(0,600)}}}};
+ const all=async (path)=>{{let out=[],p=path; while(p){{const r=await req('GET',p); if(r.status!==200) throw new Error(path+' -> '+r.status+' '+r.text);
+   out=out.concat(r.json.data); p=r.json.links&&r.json.links.next? r.json.links.next.replace(/^https:\\/\\/[^/]+/,''): null;}} return out}};
+ const result=await (async()=>{{ {body_js} }})();
+ window.__sp=JSON.stringify(result);
+}})().catch(e=>window.__sp=JSON.stringify({{error:String(e)}})); 'ok'\"\"\")
+for _ in range({timeout // 2}):
+    v = js("String(window.__sp)")
+    if v != 'running': break
+    time.sleep(2)
+print('__SP__' + v)
+"""
+    out = browser.run_harness(script, timeout=timeout + 60)
+    payload = out.split("__SP__", 1)[-1].strip()
+    try:
+        result = json.loads(payload)
+    except json.JSONDecodeError as exc:
+        raise browser.BrowserError(f"Unexpected response from the console: {payload[:300]}") from exc
+    if isinstance(result, dict) and result.get("error"):
+        raise browser.BrowserError(result["error"])
+    return result
+
+
+def set_availability(app_id: str, territories: list[str], available_in_new: bool) -> dict:
+    """Make the app available only in the given territories (3-letter ISO codes)."""
+    wanted = json.dumps(sorted(set(t.upper() for t in territories)))
+    body = f"""
+ const want={wanted};
+ const terr=(await all('/iris/v1/territories?limit=200')).map(t=>t.id);
+ const missing=want.filter(t=>!terr.includes(t)); if(missing.length) throw new Error('unknown territory: '+missing.join(','));
+ const rel=terr.map(t=>({{type:'territoryAvailabilities',id:'${{'+t+'}}'}}));
+ const inc=terr.map(t=>({{type:'territoryAvailabilities',id:'${{'+t+'}}',attributes:{{available:want.includes(t)}},relationships:{{territory:{{data:{{type:'territories',id:t}}}}}}}}));
+ const r=await req('POST','/iris/v2/appAvailabilities',{{data:{{type:'appAvailabilities',attributes:{{availableInNewTerritories:{json.dumps(available_in_new)}}},
+   relationships:{{app:{{data:{{type:'apps',id:'{app_id}'}}}},territoryAvailabilities:{{data:rel}}}}}},included:inc}});
+ if(r.status>=300) throw new Error('appAvailabilities -> '+r.status+' '+r.text);
+ const now=(await all('/iris/v2/appAvailabilities/{app_id}/territoryAvailabilities?limit=200&include=territory'))
+   .filter(d=>d.attributes.available).map(d=>(d.relationships.territory.data||{{}}).id);
+ return {{total_territories:terr.length, available:now}};
+"""
+    return _run_iris(app_id, body)
+
+
+def set_privacy(app_id: str, usages: list[dict]) -> dict:
+    """Replace the whole privacy declaration and publish it.
+
+    usages: [{"category": "NAME", "purposes": ["APP_FUNCTIONALITY"], "linked": true,
+    "tracking": false}, ...]. An empty list declares "we do not collect data".
+    """
+    records = []
+    for u in usages:
+        cat = u["category"].upper()
+        if cat not in DATA_CATEGORIES:
+            raise ValueError(f"Invalid category: {cat}. Options: {', '.join(DATA_CATEGORIES)}")
+        purposes = [p.upper() for p in u.get("purposes") or []]
+        bad = [p for p in purposes if p not in DATA_PURPOSES]
+        if not purposes or bad:
+            raise ValueError(f"{cat}: invalid purposes {bad or '(none)'}. Options: {', '.join(DATA_PURPOSES)}")
+        protections = ["DATA_LINKED_TO_YOU" if u.get("linked", True) else "DATA_NOT_LINKED_TO_YOU"]
+        if u.get("tracking"):
+            protections.append("DATA_USED_TO_TRACK_YOU")
+        for purpose in purposes:
+            for protection in protections:
+                records.append({"category": cat, "purpose": purpose, "protection": protection})
+    plan = json.dumps(records)
+    body = f"""
+ const plan={plan};
+ const old=await all('/iris/v1/apps/{app_id}/dataUsages?limit=200');
+ for (const d of old) {{ const r=await req('DELETE','/iris/v1/appDataUsages/'+d.id); if(r.status>=300) throw new Error('DELETE '+d.id+' -> '+r.status); }}
+ const created=[];
+ const recs = plan.length? plan : [{{protection:'DATA_NOT_COLLECTED'}}];
+ for (const x of recs) {{
+   const rel={{app:{{data:{{type:'apps',id:'{app_id}'}}}},dataProtection:{{data:{{type:'appDataUsageDataProtections',id:x.protection}}}}}};
+   if (x.category) rel.category={{data:{{type:'appDataUsageCategories',id:x.category}}}};
+   if (x.purpose) rel.purpose={{data:{{type:'appDataUsagePurposes',id:x.purpose}}}};
+   const r=await req('POST','/iris/v1/appDataUsages',{{data:{{type:'appDataUsages',relationships:rel}}}});
+   if (r.status!==201) throw new Error('appDataUsages '+(x.category||'')+' -> '+r.status+' '+r.text);
+   created.push((x.category||'NOT_COLLECTED')+':'+(x.purpose||'')+':'+x.protection);
+ }}
+ const p=await req('PATCH','/iris/v1/appDataUsagesPublishState/{app_id}',{{data:{{type:'appDataUsagesPublishState',id:'{app_id}',attributes:{{published:true}}}}}});
+ if (p.status>=300) throw new Error('publish -> '+p.status+' '+p.text);
+ return {{removed:old.length, created:created, published:true}};
+"""
+    return _run_iris(app_id, body)

shipstores/apple_review.py

@@ -0,0 +1,149 @@
+"""App Store Resolution Center: read the rejection and reply to App Review.
+
+Apple's public API exposes neither the review messages nor replies to them. The
+web console uses the internal /iris API, which accepts the dedicated Chrome's
+cookie session. Reading is done with fetch inside the page; replying goes through
+the console's own "Reply to App Review" box, because the attachment goes through
+an upload that only the UI knows how to assemble.
+
+Details learned by trial and error:
+- The harness js() gives up after 5s; the fetch calls run in an IIFE that writes
+  to window, and the script polls for the result.
+- The reply textarea only enables the "Reply" button after real typing: setting
+  .value is not enough, so the script types and deletes a space via CDP.
+- Attachments go through DOM.setFileInputFiles and show "Processing..." before
+  appearing in the list; sending before that drops the file.
+- iPhone video is recorded in HEVC and weighs ~100 MB; converted to H.264 at
+  1920px it is ~8 MB and opens in any player.
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+
+from . import browser
+
+ASC = "https://appstoreconnect.apple.com"
+
+# Console UI labels, matched literally against the page text (pt-BR and en-US)
+REPLY_OPEN = ("Responda à equipe de revisão de apps", "Reply to App Review")
+REPLY_SEND = ("Responder", "Reply")
+PROCESSING = ("Processando", "Processing")
+
+
+def read_messages(app_id: str) -> list[dict]:
+    """The app's Resolution Center messages, oldest first."""
+    script = f"""
+import time, json
+new_tab({f"{ASC}/apps/{app_id}/distribution"!r})
+wait_for_load()
+time.sleep(3)
+js(r\"\"\"window.__sp='running';(async()=>{{
+ const g=async p=>{{const r=await fetch(p,{{credentials:'include'}}); return r.ok? r.json(): null}};
+ const th=await g('/iris/v1/apps/{app_id}/resolutionCenterThreads');
+ const out=[];
+ for (const t of ((th&&th.data)||[])) {{
+   const m=await g('/iris/v1/resolutionCenterThreads/'+t.id+'/resolutionCenterMessages?include=rejections&limit=50');
+   const rej=((m&&m.included)||[]).filter(i=>i.type&&i.type.indexOf('ejection')>=0).map(i=>i.attributes.reasons||[]).flat();
+   for (const x of ((m&&m.data)||[])) out.push({{thread:t.id, date:x.attributes.createdDate, sender:x.attributes.fromActor||null,
+     text:(x.attributes.messageBody||'').replace(/<br\\s*\\/?>/g,' ').replace(/<[^>]+>/g,'').trim(), reasons:rej}});
+ }}
+ window.__sp=JSON.stringify(out.sort((a,b)=>a.date<b.date?-1:1));
+}})().catch(e=>window.__sp='ERROR '+e); 'ok'\"\"\")
+for _ in range(40):
+    v = js("String(window.__sp)")
+    if v != 'running': break
+    time.sleep(1.5)
+print('__SP__' + v)
+"""
+    out = browser.run_harness(script, timeout=180)
+    payload = out.split("__SP__", 1)[-1].strip()
+    if payload.startswith("ERROR") or not payload.startswith("["):
+        raise browser.BrowserError(f"Could not read the Resolution Center: {payload[:300]}")
+    return json.loads(payload)
+
+
+def prepare_attachment(path: Path) -> Path:
+    """Convert HEVC video to H.264 at 1920px (smaller and universal); anything else passes through unchanged."""
+    if path.suffix.lower() not in (".mp4", ".mov", ".m4v"):
+        return path
+    if not (shutil.which("ffprobe") and shutil.which("ffmpeg")):
+        return path
+    codec = subprocess.run(
+        ["ffprobe", "-v", "error", "-select_streams", "v:0", "-show_entries", "stream=codec_name",
+         "-of", "csv=p=0", str(path)],
+        capture_output=True, text=True,
+    ).stdout.strip()
+    if codec != "hevc":
+        return path
+    out = Path(tempfile.mkdtemp(prefix="sp-review-")) / f"{path.stem}.mp4"
+    subprocess.run(
+        ["ffmpeg", "-v", "error", "-y", "-i", str(path), "-vf", "scale=-2:1920", "-c:v", "libx264",
+         "-preset", "medium", "-crf", "26", "-pix_fmt", "yuv420p", "-c:a", "aac", "-b:a", "96k",
+         "-movflags", "+faststart", str(out)],
+        check=True,
+    )
+    return out
+
+
+def reply(app_id: str, submission_id: str, text: str, attachments: list[Path]) -> str:
+    """Reply to App Review through the console box and verify the message landed in the thread."""
+    script = f"""
+import time, json
+TEXT = {json.dumps(text)}
+FILES = {json.dumps([str(p) for p in attachments])}
+OPEN = {json.dumps(list(REPLY_OPEN))}
+SEND = {json.dumps(list(REPLY_SEND))}
+BUSY = {json.dumps(list(PROCESSING))}
+new_tab({f"{ASC}/apps/{app_id}/distribution/reviewsubmissions/details/{submission_id}"!r})
+wait_for_load()
+for _ in range(15):
+    time.sleep(2)
+    if js("[...document.querySelectorAll('button')].some(b=>%s.includes(b.innerText.trim()))" % json.dumps(OPEN)): break
+else:
+    raise SystemExit('ERROR: the reply button did not appear (does the submission have an open issue?)')
+js("[...document.querySelectorAll('button')].find(b=>%s.includes(b.innerText.trim())).click()" % json.dumps(OPEN))
+time.sleep(3)
+ok = js(\"\"\"(()=>{{const t=document.querySelector('[role=dialog] textarea'); if(!t) return false;
+ Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype,'value').set.call(t, %s);
+ t.dispatchEvent(new Event('input',{{bubbles:true}})); t.focus(); t.setSelectionRange(t.value.length,t.value.length); return true}})()\"\"\" % json.dumps(TEXT))
+if not ok:
+    raise SystemExit('ERROR: the reply box did not open (the console may not have rendered in headless mode; try SHIPSTORES_HEADLESS=0)')
+cdp("Input.insertText", text=" ")
+cdp("Input.dispatchKeyEvent", type="keyDown", key="Backspace", code="Backspace", windowsVirtualKeyCode=8)
+cdp("Input.dispatchKeyEvent", type="keyUp", key="Backspace", code="Backspace", windowsVirtualKeyCode=8)
+for f in FILES:
+    doc = cdp("DOM.getDocument", depth=-1, pierce=True)
+    ids = cdp("DOM.querySelectorAll", nodeId=doc["root"]["nodeId"], selector="[role=dialog] input[type=file]")["nodeIds"]
+    if not ids:
+        raise SystemExit('ERROR: attachment input not found')
+    cdp("DOM.setFileInputFiles", nodeId=ids[-1], files=[f])
+    name = f.rsplit('/', 1)[-1]
+    for _ in range(90):
+        time.sleep(2)
+        d = js("(document.querySelector('[role=dialog]')||{{}}).innerText||''")
+        if name in d and not any(b in d for b in BUSY): break
+    else:
+        raise SystemExit('ERROR: attachment did not finish processing: ' + name)
+# "Mensagens"/"Messages" is console UI text, matched literally (pt-BR / en-US)
+COUNT = r"(()=>{{const m=document.body.innerText.match(/(?:Mensagens|Messages) \\((\\d+)\\)/); return m? Number(m[1]): -1}})()"
+before = js(COUNT)
+sent = js("(()=>{{const b=[...document.querySelectorAll('[role=dialog] button')].filter(b=>%s.includes(b.innerText.trim())).pop(); if(!b) return 'no button'; if(b.disabled) return 'disabled'; b.click(); return 'sent'}})()" % json.dumps(SEND))
+if sent != 'sent':
+    raise SystemExit('ERROR: not sent (' + sent + ')')
+for _ in range(15):
+    time.sleep(2)
+    if js(COUNT) > before: break
+else:
+    raise SystemExit('ERROR: the message did not appear in the thread after sending')
+print('__SP__ok')
+"""
+    out = browser.run_harness(script, timeout=600)
+    if "__SP__ok" not in out:
+        erro = next((l for l in out.splitlines() if l.startswith("ERROR")), out[-500:])
+        raise browser.BrowserError(erro)
+    return "sent"