The Day Generation, Device, and Internal-Test Shipping Became One Step — What I Refused to Hand Over

#!/usr/bin/env python3
"""preflight.py — the irreversible check before internal-test shipping.
Gathers only items with a clear true/false and contracts via exit codes.
  exit 0  pass
  exit 1  a violation the machine should block on (stop shipping)
  exit 2  bad input (failed to read configuration)
"""
import json
import re
import sys
from pathlib import Path
 
EXPECTED_APP_ID = "net.dolice.wallpaper"   # match your own app
LEDGER = Path("release_ledger.jsonl")      # past shipment records
 
def read_gradle_version(gradle: Path):
    text = gradle.read_text(encoding="utf-8")
    code = re.search(r"versionCode\s*[=\s]\s*(\d+)", text)
    name = re.search(r'versionName\s*[=\s]\s*"([^"]+)"', text)
    app  = re.search(r'applicationId\s*[=\s]\s*"([^"]+)"', text)
    if not (code and name and app):
        print("read failed: versionCode / versionName / applicationId")
        sys.exit(2)
    return int(code.group(1)), name.group(1), app.group(1)
 
def last_released_code() -> int:
    if not LEDGER.exists():
        return 0
    codes = [json.loads(l)["versionCode"] for l in LEDGER.read_text().splitlines() if l.strip()]
    return max(codes) if codes else 0
 
def main():
    gradle = Path("app/build.gradle.kts")
    if not gradle.exists():
        print("app/build.gradle.kts not found"); sys.exit(2)
 
    version_code, version_name, app_id = read_gradle_version(gradle)
    failures = []
 
    if app_id != EXPECTED_APP_ID:
        failures.append(f"applicationId mismatch: {app_id} != {EXPECTED_APP_ID}")
    if version_code <= last_released_code():
        failures.append(f"versionCode not monotonic: {version_code} <= {last_released_code()}")
 
    mapping = Path("app/build/outputs/mapping/release/mapping.txt")
    if not mapping.exists():
        failures.append("missing mapping.txt (R8 may not have run)")
 
    bundle = Path("app/build/outputs/bundle/release/app-release.aab")
    if not bundle.exists():
        failures.append("release .aab not found")
 
    if failures:
        print("stopping the shipment:")
        for f in failures:
            print(f"  - {f}")
        sys.exit(1)
 
    print(f"OK: {app_id} versionCode={version_code} ({version_name})")
 
if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""publish_internal.py — hand the .aab to the internal test track.
Reads the service account key from the path in env var PLAY_SA_JSON.
"""
import os
import sys
from google.oauth2 import service_account
from googleapiclient.discovery import build
from googleapiclient.http import MediaFileUpload
 
PACKAGE = "net.dolice.wallpaper"
AAB = "app/build/outputs/bundle/release/app-release.aab"
SCOPES = ["https://www.googleapis.com/auth/androidpublisher"]
 
def service():
    key_path = os.environ["PLAY_SA_JSON"]   # path to the service account key
    creds = service_account.Credentials.from_service_account_file(key_path, scopes=SCOPES)
    return build("androidpublisher", "v3", credentials=creds, cache_discovery=False)
 
def main():
    note = sys.argv[1] if len(sys.argv) > 1 else ""
    if not note:
        print("pass a shipment note as an argument (what is this shipment for)"); sys.exit(2)
 
    svc = service()
    edit = svc.edits().insert(packageName=PACKAGE, body={}).execute()
    edit_id = edit["id"]
 
    uploaded = svc.edits().bundles().upload(
        packageName=PACKAGE, editId=edit_id,
        media_body=MediaFileUpload(AAB, mimetype="application/octet-stream"),
    ).execute()
    version_code = uploaded["versionCode"]
 
    svc.edits().tracks().update(
        packageName=PACKAGE, editId=edit_id, track="internal",
        body={"releases": [{
            "versionCodes": [version_code],
            "status": "completed",
            "releaseNotes": [{"language": "en-US", "text": note}],
        }]},
    ).execute()
 
    svc.edits().commit(packageName=PACKAGE, editId=edit_id).execute()
    print(f"shipped to internal: versionCode={version_code} note={note!r}")
 
if __name__ == "__main__":
    main()

#!/usr/bin/env bash
# ledger.sh — append one line to release_ledger.jsonl on every shipment
set -euo pipefail
 
VERSION_CODE="$1"   # the value printed by publish_internal.py
TRACK="$2"          # internal / closed / production
NOTE="$3"           # in my own words, "what this shipment is for"
 
SHA="$(git rev-parse --short HEAD)"
TS="$(TZ=Asia/Tokyo date '+%Y-%m-%dT%H:%M:%S%z')"
 
printf '{"versionCode":%s,"track":"%s","sha":"%s","ts":"%s","note":%s}\n' \
  "$VERSION_CODE" "$TRACK" "$SHA" "$TS" "$(printf '%s' "$NOTE" | python3 -c 'import json,sys; print(json.dumps(sys.stdin.read()))')" \
  >> release_ledger.jsonl
 
echo "recorded in ledger: code=$VERSION_CODE track=$TRACK sha=$SHA"