vydanne 0.10.0 → 0.11.0

package/README.md

@@ -235,7 +235,7 @@ already right. `VYDANNE_FLATTEN=1` reads a flat screenshot folder rather than pe
 | `diff` | Shows exactly what's different between your files and what's live. Nothing is changed — a safe preview. |
 | `fill` | Uploads your listing text and screenshots. Handles iPhone, iPad and Mac. Refuses to upload text that names the other mobile platform. |
 | `previews` | Uploads App Preview videos. |
-| `inspect` | Shows the app's current state in the store. Read-only. |
+| `inspect` | Shows the app's current state in the store. Read-only. With `--store google` it also lists every track carrying a release — track, versionCode, version name, status, and the rollout percentage of a staged release. |
 | `locales` | Lists your languages and Apple's code for each — and warns about any language the App Store doesn't offer. |
 | `appinfo` | Sets the App Store **category** and the **content-rights** answer — the two app-level facts that block *Add for Review* and belong to no single release. Declared as `categories` (Apple's ids: `GAMES`, `GAMES_PUZZLE` — never display names) and `contentRights: false` for an app that shows no third-party content. Left undeclared, `contentRights` is not written at all, so an answer already given in App Store Connect is never overwritten by a default nobody chose. |
 | `age-rating` | Sets the age rating. `rating: "4+"` needs nothing else; any higher rating is described feature-by-feature in `ageRating` and Apple computes the band from it. |

package/SKILL.md

@@ -297,6 +297,11 @@ than silent. The versionCode is read out of the `.aab` locally and the changelog
 BEFORE the upload; re-uploading a used code fails loudly instead of silently replacing. DRY by default;
 `--apply` publishes.
 
+`inspect --store google` also reports **which build is on which track** — versionCode, version
+name, status, and a staged rollout's percentage — for every track that carries a release. Tracks
+with no release are omitted. That is the question after any upload, and it could not be answered
+from this tool at all before 0.11.
+
 `--store google` routes `inspect` · `diff` · `preflight` · `fill` · `prerelease` to the Play Developer **Edits** API
 (OAuth2 service account; **scoped to the config's `packageName`** — a shared key can't touch another app).
 The AAB binary and the (YouTube-URL) promo video stay outside vydanne.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vydanne",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "App Store Connect + Google Play submission prep — the companion to zdymak (media). Native Node (no fastlane/Ruby/Python): localized listings, screenshot/preview/icon upload, ratings, review contact, accessibility & privacy labels, IAP, export docs, build upload to TestFlight / a Play closed track, a diff of local-vs-store, and a preflight verifier that encodes the store gotchas. Never submits for review. iOS/macOS via the ASC REST API; Android via the Play Developer Edits API (--store google).",
   "keywords": [
     "app-store-connect",

package/src/play/client.mjs

@@ -86,6 +86,35 @@ export class PlayClient {
 
   getTrack(editId, track) { return this.req("GET", `/edits/${editId}/tracks/${track}`); }
 
+  /**
+   * The track NAMES this app has, from inside an edit.
+   *
+   * Only the names are worth taking from here. The `releases` this returns are the track's DESIRED
+   * state — whatever the last edit wrote — which is not what anyone means by "what is on the track".
+   * Use [trackReleases] for that; see its note.
+   */
+  listTracks(editId) { return this.req("GET", `/edits/${editId}/tracks`); }
+
+  /**
+   * What is ACTUALLY on a track: every non-obsolete release, with its lifecycle state.
+   *
+   * Needs no edit, and it is a different answer from `edits/…/tracks`. That one reports the last
+   * write; this reports reality, and the two disagree exactly when it matters most. Measured on
+   * Niva, 2026-09-05:
+   *
+   *   edits/…/tracks   alpha → [131]                       "the upload worked"
+   *   tracks/alpha/…   alpha → 1.4 (131) IN_REVIEW
+   *                          + 1.0 (102) PUBLISHED         "…and testers still have 1.0"
+   *
+   * A newly uploaded build does not reach testers until review passes, so the previously published
+   * release keeps serving — and the edit-based view cannot see it at all. Reporting only the edit
+   * view meant `inspect` said a release was live when nobody had it yet.
+   *
+   * Shape differs from the edits API too: `releaseName`, `activeArtifacts[].versionCode` and
+   * `releaseLifecycleState`, not `name`/`versionCodes`/`status`.
+   */
+  trackReleases(track) { return this.req("GET", `/tracks/${encodeURIComponent(track)}/releases`); }
+
   /**
    * Point a track at version codes. `releases` is the FULL desired state of that track — Play replaces
    * it wholesale, so send one complete release object rather than appending to what is already there.

package/src/play/commands/inspect.mjs

@@ -1,7 +1,14 @@
 const IMAGE_TYPES = ["phoneScreenshots", "sevenInchScreenshots", "tenInchScreenshots", "wearScreenshots", "tvScreenshots", "featureGraphic", "icon", "promoGraphic"];
 
-// Read-only snapshot of the Play listing — languages, contact details, image counts. Everything reads
-// through one throwaway edit (deleted, never committed), the same as the ASC `inspect`.
+// Read-only snapshot of the Play listing — languages, contact details, image counts, and WHAT IS
+// PUBLISHED WHERE. Everything reads through one throwaway edit (deleted, never committed), the same
+// as the ASC `inspect`.
+//
+// The tracks half was missing until 2026-09-05, and its absence was the difference between "the
+// upload command said it worked" and knowing. `inspect` reported the listing beautifully and could
+// not answer the only question anyone asks after a release — which build is on which track, under
+// what version name — so that had to be worked out by hand against the raw androidpublisher API.
+// A read-only command that cannot show you the state you just changed is half a command.
 export async function run(config, client) {
   const g = config.google;
   const editId = await client.newEdit();
@@ -17,6 +24,68 @@ export async function run(config, client) {
       if (imgs.length) counts.push(`${t}=${imgs.length}`);
     }
     console.log(`  images (${lang}): ${counts.join("  ") || "(none)"}`);
+
+    // What is actually ON each track, which is NOT what the edit says is on it.
+    //
+    // The edit's own `tracks` gives the desired state — the last thing written — so straight after
+    // an upload it happily reports the new build and nothing else. The track's `releases` endpoint
+    // reports reality: the build in review AND the older one still serving testers underneath it,
+    // because a new build does not reach anyone until review passes. Reporting the edit view alone
+    // said a release was live when nobody had it (measured on Niva, 2026-09-05).
+    //
+    // So the edit is used only to enumerate track NAMES; every state below comes from the
+    // non-edit endpoint.
+    const LIFECYCLE = {
+      RELEASE_LIFECYCLE_STATE_PUBLISHED: "published",
+      RELEASE_LIFECYCLE_STATE_IN_REVIEW: "in review",
+      RELEASE_LIFECYCLE_STATE_DRAFT: "draft",
+      RELEASE_LIFECYCLE_STATE_HALTED: "halted",
+      RELEASE_LIFECYCLE_STATE_UNSPECIFIED: "unspecified",
+    };
+    const edited = (await client.listTracks(editId)).json.tracks || [];
+    const rows = [];
+    let degraded = null;
+    for (const t of edited) {
+      const res = await client.trackReleases(t.track);
+      // 404 is information, not a failure: the app has never shipped to this track. "Does not
+      // exist" and "exists but empty" are different facts and neither earns a row.
+      if (res.status === 404) continue;
+      if (res.status !== 200) {
+        // ANYTHING ELSE MUST NOT BE SWALLOWED. `req` returns a status rather than throwing, so an
+        // earlier version of this that caught exceptions caught nothing at all — a 403 produced
+        // zero rows and the command printed "nothing published" about an app with three live
+        // tracks. The endpoint is quota-limited ("Listing releases quota exceeded"), so this is a
+        // state a normal day reaches, not an exotic one. Fall back to the edit's view, which is the
+        // last write rather than what is serving, and label every row so it is never mistaken for
+        // the real thing.
+        degraded = res.json?.error?.message || `HTTP ${res.status}`;
+        for (const rel of t.releases || []) {
+          const codes = (rel.versionCodes || []).join(",") || "-";
+          if (codes === "-") continue;
+          rows.push(`  ~ ${t.track.padEnd(12)} ${codes.padEnd(8)} ${(rel.name || "-").padEnd(12)} ${rel.status || "?"}`);
+        }
+        continue;
+      }
+      for (const rel of res.json.releases || []) {
+        const codes = (rel.activeArtifacts || []).map((a) => a.versionCode).join(",") || "-";
+        const state = LIFECYCLE[rel.releaseLifecycleState] || rel.releaseLifecycleState || "?";
+        const staged = rel.userFraction != null ? `  ${Math.round(rel.userFraction * 100)}% rollout` : "";
+        rows.push(`    ${t.track.padEnd(12)} ${codes.padEnd(8)} ${(rel.releaseName || "-").padEnd(12)} ${state}${staged}`);
+      }
+    }
+    if (rows.length) {
+      console.log(`  tracks (${rows.length} release(s)):`);
+      console.log(`    ${"track".padEnd(12)} ${"code".padEnd(8)} ${"name".padEnd(12)} state`);
+      for (const r of rows) console.log(r);
+    } else if (degraded) {
+      console.log("  tracks: could not be read — " + degraded);
+    } else {
+      console.log("  tracks: (nothing published — no track carries a release)");
+    }
+    if (degraded && rows.length) {
+      console.log(`  ~ rows are the EDIT's view (what was last written), not what is serving.`);
+      console.log(`    Live state unavailable: ${degraded}`);
+    }
   } finally {
     await client.deleteEdit(editId);
   }