vydanne 0.3.0 → 0.4.1

package/README.md

@@ -180,7 +180,7 @@ Run vydanne **from your project folder** — it finds everything relative to whe
 | `compliance` | Generates the US encryption self-classification PDF that Apple asks for. |
 | `version` | Prints the version of vydanne. |
 
-For **Google Play**, add `--store google` to `inspect`, `diff`, `preflight`, or `fill`.
+For **Google Play**, add `--store google` to `inspect`, `diff`, `preflight`, `fill`, or `prerelease`.
 
 <br>
 
@@ -196,6 +196,37 @@ VYDANNE_COMMIT=1 npx vydanne fill --store google   # actually do it
 #   Windows PowerShell:  $env:VYDANNE_COMMIT = "1"; npx vydanne fill --store google
 ```
 
+### `prerelease` — the build, to a testing track
+
+`fill` writes the *listing*; `prerelease` uploads the **binary** to a **closed testing track** with
+release notes, all inside one edit transaction:
+
+```sh
+npx vydanne prerelease --store google                    # dry run
+VYDANNE_COMMIT=1 npx vydanne prerelease --store google   # publish to the track
+```
+
+```js
+google: {
+  packageName: "com.x.app",
+  aab: "./dist",        // a file, or a directory whose NEWEST .aab is taken
+  track: "internal",    // 'internal' (default) | 'alpha' | 'beta'
+}
+```
+
+**It refuses `production`** — that isn't a flag you can pass, it's a refusal. A staged rollout can be
+halted but never un-shipped, so promoting a tested build stays a human decision in Play Console. This is
+the same line the Apple side draws by never submitting.
+
+**Paid app? Use `internal`.** It is the only track where testers install without buying; closed and open
+testers pay like everyone else.
+
+Release notes follow supply's layout, so an existing repo needs no migration —
+`<metadataDir>/<play-locale>/changelogs/<versionCode>.txt`, falling back to `default.txt`, truncated to
+Play's 500-char cap with a warning. The versionCode comes from the bundle's own manifest, so build
+numbering stays with the build and re-uploading a used code fails loudly instead of silently replacing a
+binary. Overrides: `VYDANNE_AAB`, `VYDANNE_TRACK`, `VYDANNE_RELEASE_NAME`.
+
 **Play is dry by default on purpose.** Nothing goes live until you add `VYDANNE_COMMIT=1`, so a
 half-finished folder can never overwrite a good listing. Play also uses its **own** language codes
 (`zh-CN`, `iw-IL`) which are *not* Apple's — `vydanne locales` and the

package/SKILL.md

@@ -164,7 +164,17 @@ live) · `privacy` (prints answers for the UI — the API can't reach Apple's ir
 RGB flatten) · `compliance` (US self-classification PDF) · `diff` (what differs vs live) · `preflight`
 (completeness gate) · `inspect` · `auth` (what credentials resolved, and from where) · `locales` · `version`.
 
-`--store google` routes `inspect` · `diff` · `preflight` · `fill` to the Play Developer **Edits** API
+`prerelease` (**Play only**) uploads an `.aab` to a **closed testing track** with release notes, inside one
+edit transaction. `production` is REFUSED — not flag-gated — so no argument combination ships to the
+public; promoting the tested build stays a human's job, mirroring the Apple side never submitting. Track
+comes from `google.track` / `VYDANNE_TRACK`, default `internal`; the bundle from `google.aab` /
+`VYDANNE_AAB` (a directory takes its newest `.aab`). **For a PAID app use `internal`** — it's the only
+track where testers install without buying. Notes follow supply's layout:
+`<google.metadataDir>/<play-locale>/changelogs/<versionCode>.txt`, falling back to `default.txt`, capped
+at Play's 500 chars. DRY by default like `fill --store google`; `VYDANNE_COMMIT=1` publishes. The
+versionCode comes from the bundle itself, so re-uploading one fails loudly instead of silently replacing.
+
+`--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).
 `fill --store google` is **DRY by default**; `VYDANNE_COMMIT=1` commits. The AAB binary and the
 (YouTube-URL) promo video stay outside vydanne.

package/bin/vydanne.mjs

@@ -87,6 +87,7 @@ usage: vydanne <command> [--config vydanne.config.mjs]
   inspect         read-only ASC state
   diff            show what differs between local (metadata/screenshots/previews) and ASC
   preflight       verify submission-completeness (the gotcha checker)
+  prerelease      --store google: upload the .aab to a closed testing track (refuses production)
   locales         UI -> ASC locale mapping + unsupported
   auth            which credentials resolved, and from where (masked) — run this on a 401
 credentials: env > .env cascade (.env, .env.<mode>, .env.local, .env.<mode>.local) > user config

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vydanne",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "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, a diff of local-vs-store, and a preflight verifier that encodes the store gotchas. iOS/macOS via the ASC REST API; Android via the Play Developer Edits API (--store google).",
   "keywords": [
     "app-store-connect",

package/src/config.mjs

@@ -45,6 +45,9 @@ export async function loadConfig(p) {
           serviceAccountKey: creds.playJsonKeyFile,
           metadataDir: raw.google.metadataDir || "fastlane/metadata/android",
           defaultLocale: raw.google.defaultLocale || raw.primaryLocale,
+          aab: raw.google.aab || null,
+          track: raw.google.track || "internal", // testing only — `prerelease` refuses production
+
         }
       : null,
   };

package/src/play/client.mjs

@@ -65,4 +65,29 @@ export class PlayClient {
     if (res.status >= 300) throw new Error(`image upload ${res.status}: ${JSON.stringify(j).slice(0, 200)}`);
     return j;
   }
+
+  // ── Binaries & tracks ─────────────────────────────────────────────────────────────────────────────
+
+  /** Upload an .aab. The returned versionCode comes from the BUNDLE's manifest — Play assigns it, not us. */
+  async uploadBundle(editId, filePath) {
+    const bytes = fs.readFileSync(filePath);
+    const res = await fetch(`${UPLOAD}/applications/${this.pkg}/edits/${editId}/bundles?uploadType=media`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${this.token}`, "Content-Type": "application/octet-stream" },
+      body: bytes,
+    });
+    const j = await res.json().catch(() => ({}));
+    if (res.status >= 300) throw new Error(`bundle upload ${res.status}: ${JSON.stringify(j).slice(0, 300)}`);
+    return j;
+  }
+
+  getTrack(editId, track) { return this.req("GET", `/edits/${editId}/tracks/${track}`); }
+
+  /**
+   * 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.
+   */
+  putTrack(editId, track, releases) {
+    return this.req("PUT", `/edits/${editId}/tracks/${track}`, { body: { track, releases } });
+  }
 }

package/src/play/commands/prerelease.mjs

@@ -0,0 +1,137 @@
+import fs from "node:fs";
+import path from "node:path";
+import { green, yellow, red } from "../../util.mjs";
+
+/** Tracks this command will write. `production` is deliberately absent — see below. */
+const TESTING_TRACKS = new Set(["internal", "alpha", "beta"]);
+
+/**
+ * Upload an .aab to a CLOSED TESTING track, with release notes.
+ *
+ * Why testing-only: shipping to everyone is a judgement call with no undo — a staged rollout can be
+ * halted but not un-shipped, and the reviewer-facing consequences are the operator's to own. So this
+ * mirrors the Apple side, which never submits: `production` is REFUSED, not gated behind a flag, so
+ * there is no arrangement of arguments that ships to the public by accident.
+ *
+ * For a PAID app, `internal` is usually the only track you want: it is the one where testers install
+ * without buying. Closed/open testers must purchase it like anyone else.
+ *
+ * Play assigns the versionCode from the bundle's own manifest, so build numbering stays with the build,
+ * and re-uploading the same code fails loudly rather than silently replacing a binary.
+ *
+ * Everything happens inside one edit transaction: nothing is live until commit, and any throw leaves the
+ * edit uncommitted — i.e. the track untouched.
+ */
+export async function run(config, client) {
+  const g = config.google;
+  const track = process.env.VYDANNE_TRACK || g.track || "internal";
+
+  if (track === "production") {
+    console.error(red("prerelease: refusing to write the production track — that release is a human's to make."));
+    console.error("  Promote the tested build in Play Console when you're ready.");
+    return false;
+  }
+  if (!TESTING_TRACKS.has(track)) {
+    console.error(red(`prerelease: unknown track "${track}" (expected: ${[...TESTING_TRACKS].join(", ")})`));
+    return false;
+  }
+
+  const aab = resolveAab(g.aab);
+  if (!aab) {
+    console.error(red("prerelease: no .aab found — set `google.aab` in the config, or pass VYDANNE_AAB=<path>."));
+    return false;
+  }
+  console.log(green(`prerelease → track "${track}"`));
+  console.log(`  bundle: ${path.relative(process.cwd(), aab) || aab}  (${(fs.statSync(aab).size / 1e6).toFixed(1)} MB)`);
+
+  const editId = await client.newEdit();
+  try {
+    // Upload, or REUSE. Play rejects a versionCode it already holds, which is the right answer for an
+    // accidental re-upload but wrong for the common case of promoting a build you already pushed to one
+    // testing track onto another. The API names the code in its refusal, so take it and carry on — the
+    // bytes are already up there, and a bundle is immutable, so reusing it can't diverge from the file.
+    let versionCode;
+    try {
+      const bundle = await client.uploadBundle(editId, aab);
+      versionCode = bundle.versionCode;
+      if (!versionCode) throw new Error(`upload returned no versionCode: ${JSON.stringify(bundle).slice(0, 200)}`);
+      console.log(green(`  uploaded versionCode ${versionCode}`));
+    } catch (e) {
+      const used = /Version code (\d+) has already been used/.exec(e.message);
+      if (!used) throw e;
+      versionCode = Number(used[1]);
+      console.log(yellow(`  versionCode ${versionCode} already uploaded — reusing that bundle`));
+    }
+
+    const releaseNotes = readNotes(g.metadataDir, versionCode, g.defaultLocale);
+    if (releaseNotes.length) {
+      console.log(`  release notes: ${releaseNotes.length} locale(s) — ${releaseNotes.map((n) => n.language).join(", ")}`);
+    } else {
+      console.log(yellow(`  no release notes found under ${g.metadataDir}/<locale>/changelogs/{${versionCode},default}.txt`));
+    }
+
+    // One complete release object: Play replaces the track's releases wholesale.
+    const release = { status: "completed", versionCodes: [String(versionCode)] };
+    if (releaseNotes.length) release.releaseNotes = releaseNotes;
+    const name = process.env.VYDANNE_RELEASE_NAME;
+    if (name) release.name = name;
+
+    const put = await client.putTrack(editId, track, [release]);
+    if (put.status >= 300) throw new Error(`tracks.update ${put.status}: ${JSON.stringify(put.json).slice(0, 300)}`);
+
+    if (process.env.VYDANNE_COMMIT !== "1") {
+      await client.deleteEdit(editId);
+      console.log(yellow(`\n  DRY RUN — edit discarded, nothing changed. Re-run with VYDANNE_COMMIT=1 to publish to "${track}".`));
+      return true;
+    }
+    const res = await client.commit(editId);
+    if (res.status >= 300) throw new Error(`edits.commit ${res.status}: ${JSON.stringify(res.json).slice(0, 300)}`);
+    console.log(green(`\n  committed — versionCode ${versionCode} is live on "${track}".`));
+    console.log("  Production stays manual: promote it in Play Console when you're ready.");
+    return true;
+  } catch (e) {
+    // Abandon the edit so a failed run leaves the track exactly as it was.
+    await client.deleteEdit(editId).catch(() => {});
+    console.error(red(`prerelease: ${e.message}`));
+    return false;
+  }
+}
+
+/** `google.aab` may be a file or a directory; a directory takes its newest .aab. */
+function resolveAab(configured) {
+  const p = process.env.VYDANNE_AAB || configured;
+  if (!p) return null;
+  const abs = path.resolve(p);
+  if (!fs.existsSync(abs)) return null;
+  if (!fs.statSync(abs).isDirectory()) return abs;
+  const files = fs.readdirSync(abs).filter((f) => f.endsWith(".aab"))
+    .map((f) => path.join(abs, f))
+    .sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs);
+  return files[0] || null;
+}
+
+/**
+ * Release notes per locale, following fastlane supply's layout so an existing repo needs no migration:
+ * `<metadataDir>/<play-locale>/changelogs/<versionCode>.txt`, falling back to `default.txt`.
+ */
+function readNotes(metadataDir, versionCode, defaultLocale) {
+  const out = [];
+  if (!metadataDir || !fs.existsSync(metadataDir)) return out;
+  for (const language of fs.readdirSync(metadataDir)) {
+    const dir = path.join(metadataDir, language, "changelogs");
+    if (!fs.existsSync(dir)) continue;
+    const file = [path.join(dir, `${versionCode}.txt`), path.join(dir, "default.txt")].find((f) => fs.existsSync(f));
+    if (!file) continue;
+    const text = fs.readFileSync(file, "utf8").trim();
+    if (!text) continue;
+    // Play caps release notes at 500 chars and rejects the whole edit if any locale is over.
+    if (text.length > 500) {
+      console.log(yellow(`  ${language}: release notes ${text.length}/500 chars — truncated`));
+      out.push({ language, text: text.slice(0, 500) });
+    } else {
+      out.push({ language, text });
+    }
+  }
+  // Keep the default locale first purely so the log reads sensibly.
+  return out.sort((a, b) => (a.language === defaultLocale ? -1 : b.language === defaultLocale ? 1 : 0));
+}

package/src/registry.mjs

@@ -23,7 +23,8 @@ export const PLAY_COMMANDS = {
   preflight: { mod: "preflight" },
   diff: { mod: "diff" },
   fill: { mod: "fill" },
+  prerelease: { mod: "prerelease" },
 };
 
 // Full public command surface (the module-dispatched ones above + the three handled inline in bin/).
-export const COMMAND_NAMES = [...Object.keys(COMMANDS), "auth", "locales", "version"];
+export const COMMAND_NAMES = [...Object.keys(COMMANDS), "prerelease", "auth", "locales", "version"];

package/types/index.d.ts

@@ -16,6 +16,8 @@ export type CommandName =
   | 'inspect'
   | 'diff'
   | 'preflight'
+  /** Google Play only: upload an .aab to a closed testing track. Refuses `production`. */
+  | 'prerelease'
   | 'auth'
   | 'locales'
   | 'version';
@@ -58,6 +60,10 @@ export interface GoogleConfig {
   /** Listing-text folders, supply convention. Default 'fastlane/metadata/android'. */
   metadataDir?: string;
   defaultLocale?: string;
+  /** `.aab` for `prerelease` — a file, or a directory whose NEWEST .aab is taken. Override: VYDANNE_AAB. */
+  aab?: string;
+  /** Testing track for `prerelease`: 'internal' (default) | 'alpha' | 'beta'. 'production' is refused. */
+  track?: "internal" | "alpha" | "beta";
 }
 
 export interface ExportConfig {