sailfork / t3code-github / .github/ scripts/ mirror-play-apk.cjs

// Play signs generated APKs with the app signing key, matching Play Store installs.
const { execFileSync } = require("node:child_process");
const crypto = require("node:crypto");
const fs = require("node:fs");
const os = require("node:os");
const path = require("node:path");
const { Readable } = require("node:stream");
const { pipeline } = require("node:stream/promises");

const PLAY_API = "https://androidpublisher.googleapis.com/androidpublisher/v3/applications";

function requireEnv(name) {
  const value = process.env[name];
  if (!value) throw new Error(`${name} is required.`);
  return value;
}

async function playAccessToken(key) {
  const now = Math.floor(Date.now() / 1000);
  const encode = (value) => Buffer.from(JSON.stringify(value)).toString("base64url");
  const unsigned = `${encode({ alg: "RS256", typ: "JWT" })}.${encode({
    iss: key.client_email,
    scope: "https://www.googleapis.com/auth/androidpublisher",
    aud: key.token_uri,
    iat: now,
    exp: now + 600,
  })}`;
  const signature = crypto.sign("RSA-SHA256", Buffer.from(unsigned), key.private_key);
  const response = await fetch(key.token_uri, {
    method: "POST",
    body: new URLSearchParams({
      grant_type: "urn:ietf:params:oauth:grant-type:jwt-bearer",
      assertion: `${unsigned}.${signature.toString("base64url")}`,
    }),
  });
  if (!response.ok) {
    throw new Error(`Google token exchange failed: ${response.status} ${await response.text()}`);
  }
  return (await response.json()).access_token;
}

async function play(token, method, url) {
  const response = await fetch(url, { method, headers: { authorization: `Bearer ${token}` } });
  if (!response.ok) {
    throw new Error(`${method} ${url} failed: ${response.status} ${await response.text()}`);
  }
  return response;
}

// Opening an edit would invalidate any EAS Submit edit using the same service account.
async function newestTrackBuild(token, appUrl, trackName) {
  const { releases = [] } = await (
    await play(token, "GET", `${appUrl}/tracks/${trackName}/releases`)
  ).json();
  let newest;
  for (const release of releases) {
    if (release.releaseLifecycleState !== "RELEASE_LIFECYCLE_STATE_PUBLISHED") continue;
    for (const { versionCode } of release.activeArtifacts ?? []) {
      if (!newest || versionCode > newest.versionCode) {
        newest = { versionCode, versionName: release.releaseName || String(versionCode) };
      }
    }
  }
  return newest;
}

function gh(...args) {
  return execFileSync("gh", args, { encoding: "utf8", stdio: ["ignore", "pipe", "inherit"] });
}

function readRelease(tag) {
  try {
    return JSON.parse(gh("release", "view", tag, "--json", "assets,body,isDraft"));
  } catch {
    return undefined;
  }
}

// Stage downloads so failed requests cannot leave partial release assets.
async function downloadApk({ token, appUrl, build, apkName }) {
  const generated = await (
    await play(token, "GET", `${appUrl}/generatedApks/${build.versionCode}`)
  ).json();
  const universal = (generated.generatedApks ?? []).filter((entry) => entry.generatedUniversalApk);
  if (universal.length === 0) return undefined;
  if (universal.length > 1) {
    throw new Error(`Play returned ${universal.length} universal APKs, one per signing key.`);
  }
  const { downloadId } = universal[0].generatedUniversalApk;
  const directory = fs.mkdtempSync(path.join(os.tmpdir(), "apk-"));
  const apkPath = path.join(directory, apkName);
  try {
    const download = await play(
      token,
      "GET",
      `${appUrl}/generatedApks/${build.versionCode}/downloads/${encodeURIComponent(downloadId)}:download?alt=media`,
    );
    await pipeline(Readable.fromWeb(download.body), fs.createWriteStream(apkPath));
    return apkPath;
  } catch (error) {
    fs.rmSync(directory, { recursive: true, force: true });
    throw error;
  }
}

function publishBeta(tag, apkPath, notes, title) {
  const release = readRelease(tag);
  if (
    release &&
    !release.isDraft &&
    release.assets.some(
      (asset) =>
        asset.name === path.basename(apkPath) && asset.state === "uploaded" && asset.size > 0,
    )
  )
    return;
  if (!release) {
    gh(
      "release",
      "create",
      tag,
      "--draft",
      "--prerelease",
      "--latest=false",
      "--title",
      title,
      "--notes",
      notes,
    );
  }
  gh("release", "upload", tag, apkPath, "--clobber");
  gh(
    "release",
    "edit",
    tag,
    "--draft=false",
    "--prerelease",
    "--latest=false",
    "--title",
    title,
    "--notes",
    notes,
  );
}

async function main() {
  const packageName = requireEnv("PACKAGE_NAME");
  const outputDirectory = process.env.APK_OUTPUT_DIR;
  const channel = outputDirectory ? "internal" : "beta";
  const track = outputDirectory ? "internal" : "alpha";
  const token = await playAccessToken(JSON.parse(requireEnv("GOOGLE_PLAY_SERVICE_ACCOUNT_JSON")));
  const appUrl = `${PLAY_API}/${packageName}`;
  const build = await newestTrackBuild(token, appUrl, track);
  if (!build) {
    console.log(`The ${track} track has no live release.`);
    return;
  }
  const safeName = build.versionName.replace(/[^0-9A-Za-z.]+/g, "-").replace(/^-|-$/g, "");
  const apkName = `t3code-android-${channel}-${safeName}-${build.versionCode}.apk`;
  const tag = `android-beta-${build.versionCode}`;
  const release = outputDirectory ? undefined : readRelease(tag);
  if (
    release &&
    !release.isDraft &&
    release.assets.some(
      (asset) => asset.name === apkName && asset.state === "uploaded" && asset.size > 0,
    )
  ) {
    console.log(`${apkName} is already published.`);
    return;
  }
  const apkPath = await downloadApk({ token, appUrl, build, apkName });
  if (!apkPath) {
    console.log(`Play is still processing the ${track} APK for ${build.versionCode}.`);
    return;
  }
  try {
    if (outputDirectory) {
      fs.mkdirSync(outputDirectory, { recursive: true });
      const destination = path.join(outputDirectory, apkName);
      const temporary = `${destination}.tmp`;
      try {
        fs.copyFileSync(apkPath, temporary);
        fs.renameSync(temporary, destination);
      } finally {
        fs.rmSync(temporary, { force: true });
      }
      return;
    }
    const notes = [
      `T3 Code for Android beta, mirrored from Google Play closed testing. Build: ${build.versionName} (${build.versionCode}).`,
      "",
      "These builds have been promoted for wider testing, but may still contain bugs. The beta is optional; the store app also works with Nightly servers.",
    ].join("\n");
    // The build number makes retries and unchanged hourly checks idempotent.
    publishBeta(tag, apkPath, notes, `Android beta ${build.versionName} (${build.versionCode})`);
  } finally {
    fs.rmSync(path.dirname(apkPath), { recursive: true, force: true });
  }
}

main().catch((error) => {
  console.error(error);
  process.exit(1);
});