@terreno/agent-plugin 0.0.0-stage → 58.0.0-beta.2

package/skills/store-assets/scripts/devices.ts

@@ -0,0 +1,286 @@
+// Simulator, emulator, and dev-client launch helpers shared by devClient.ts and screenshots.ts.
+
+import {join} from "node:path";
+import {type ExpoInfo, fail, getAndroidHome, run, runOrFail, warn} from "./config";
+
+// Booting a cold emulator can take several minutes on a loaded host.
+const BOOT_POLL_ATTEMPTS = 150;
+const BOOT_POLL_INTERVAL_MS = 2_000;
+const DEV_MENU_PREFS = "expo.modules.devmenu.sharedpreferences";
+
+export interface SimDevice {
+  name: string;
+  udid: string;
+  state: string;
+}
+
+export interface RunningEmulator {
+  avd: string;
+  serial: string;
+}
+
+// "skipIntro" only marks the dev menu intro as seen. "hideAll" also hides the floating gear
+// button and the auto-open sheet, for clean screenshots.
+export type DevMenuMode = "skipIntro" | "hideAll";
+
+export const listIosSimulators = async ({
+  filter,
+  tag,
+}: {
+  filter: "booted" | "available";
+  tag: string;
+}): Promise<SimDevice[]> => {
+  const output = await runOrFail({
+    cmd: ["xcrun", "simctl", "list", "devices", filter, "-j"],
+    isQuiet: true,
+    tag,
+  });
+  // Newest runtime first, so a fresh simulator lands on the latest iOS.
+  return Object.entries(JSON.parse(output).devices as Record<string, SimDevice[]>)
+    .filter(([runtime]) => runtime.includes("iOS"))
+    .sort(([a], [b]) => b.localeCompare(a, undefined, {numeric: true}))
+    .flatMap(([, devices]) => devices);
+};
+
+export const listIosRuntimes = async ({tag}: {tag: string}): Promise<string[]> => {
+  const output = await runOrFail({
+    cmd: ["xcrun", "simctl", "list", "devices", "available", "-j"],
+    isQuiet: true,
+    tag,
+  });
+  return Object.keys(JSON.parse(output).devices as Record<string, SimDevice[]>)
+    .filter((runtime) => runtime.includes("iOS"))
+    .sort((a, b) => b.localeCompare(a, undefined, {numeric: true}));
+};
+
+// Best-effort: the simulator keeps running headless when Simulator.app isn't installed.
+const openSimulatorApp = async ({tag}: {tag: string}): Promise<void> => {
+  const proc = Bun.spawn(["open", "-a", "Simulator"], {stderr: "ignore", stdout: "ignore"});
+  if ((await proc.exited) !== 0) {
+    warn({
+      message:
+        "Simulator.app not found; simulator is running headless. Install it from Xcode > Settings > Components.",
+      tag,
+    });
+  }
+};
+
+export const bootIosSimulator = async ({udid, tag}: {udid: string; tag: string}): Promise<void> => {
+  const booted = await listIosSimulators({filter: "booted", tag});
+  if (!booted.some((sim) => sim.udid === udid)) {
+    await run({cmd: ["xcrun", "simctl", "boot", udid], isQuiet: true});
+    await runOrFail({cmd: ["xcrun", "simctl", "bootstatus", udid, "-b"], isQuiet: true, tag});
+  }
+  await openSimulatorApp({tag});
+};
+
+export const listRunningEmulators = async ({tag}: {tag: string}): Promise<RunningEmulator[]> => {
+  const output = await runOrFail({cmd: ["adb", "devices"], isQuiet: true, tag});
+  const serials = output
+    .split("\n")
+    .map((line) => line.split("\t"))
+    .filter(([serial, state]) => serial?.startsWith("emulator-") && state === "device")
+    .map(([serial]) => serial as string);
+  return Promise.all(
+    serials.map(async (serial) => {
+      const {stdout} = await run({cmd: ["adb", "-s", serial, "emu", "avd", "name"], isQuiet: true});
+      return {avd: stdout.split("\n")[0]?.trim() ?? "", serial};
+    })
+  );
+};
+
+export const findEmulatorSerial = async ({
+  avd,
+  tag,
+}: {
+  avd?: string;
+  tag: string;
+}): Promise<string | undefined> => {
+  const emulators = await listRunningEmulators({tag});
+  return (avd ? emulators.find((emulator) => emulator.avd === avd) : emulators[0])?.serial;
+};
+
+export const listAvds = async ({tag}: {tag: string}): Promise<string[]> => {
+  const emulatorBin = join(getAndroidHome({tag}), "emulator", "emulator");
+  const output = await runOrFail({cmd: [emulatorBin, "-list-avds"], isQuiet: true, tag});
+  return output.split("\n").filter(Boolean);
+};
+
+// Starts the AVD (if needed) and returns its adb serial once Android reports boot complete.
+export const bootEmulator = async ({avd, tag}: {avd: string; tag: string}): Promise<string> => {
+  const running = await findEmulatorSerial({avd, tag});
+  if (running) {
+    return running;
+  }
+  const emulatorBin = join(getAndroidHome({tag}), "emulator", "emulator");
+  // nohup without a shell, so the emulator outlives this script and no value is shell-parsed.
+  Bun.spawn(["nohup", emulatorBin, "-avd", avd], {
+    stderr: "ignore",
+    stdin: "ignore",
+    stdout: "ignore",
+  }).unref();
+  for (let attempt = 0; attempt < BOOT_POLL_ATTEMPTS; attempt++) {
+    const serial = await findEmulatorSerial({avd, tag});
+    if (serial) {
+      const {stdout} = await run({
+        cmd: ["adb", "-s", serial, "shell", "getprop", "sys.boot_completed"],
+        isQuiet: true,
+      });
+      if (stdout.trim() === "1") {
+        return serial;
+      }
+    }
+    await Bun.sleep(BOOT_POLL_INTERVAL_MS);
+  }
+  return fail({message: `Emulator ${avd} did not finish booting`, tag});
+};
+
+// The emulator reaches the host's API and Metro over localhost via adb reverse.
+export const reversePorts = async ({
+  serial,
+  ports,
+  tag,
+}: {
+  serial: string;
+  ports: number[];
+  tag: string;
+}): Promise<void> => {
+  for (const port of ports) {
+    await runOrFail({
+      cmd: ["adb", "-s", serial, "reverse", `tcp:${port}`, `tcp:${port}`],
+      isQuiet: true,
+      tag,
+    });
+  }
+};
+
+const writeAndroidDevMenuPrefs = async ({
+  serial,
+  androidPackage,
+  devMenu,
+  tag,
+}: {
+  serial: string;
+  androidPackage: string;
+  devMenu: DevMenuMode;
+  tag: string;
+}): Promise<void> => {
+  const prefs =
+    devMenu === "hideAll"
+      ? {isOnboardingFinished: true, showFab: false, showsAtLaunch: false}
+      : {isOnboardingFinished: true};
+  const xml = [
+    "<?xml version='1.0' encoding='utf-8' standalone='yes' ?>",
+    "<map>",
+    ...Object.entries(prefs).map(([name, value]) => `<boolean name="${name}" value="${value}" />`),
+    "</map>",
+  ].join("");
+  // Dev client builds are debuggable, so run-as can write the app's private prefs. Base64
+  // avoids shell-quoting the XML; androidPackage is validated by getExpoInfo.
+  const encoded = Buffer.from(xml).toString("base64");
+  await runOrFail({
+    cmd: [
+      "adb",
+      "-s",
+      serial,
+      "shell",
+      `run-as ${androidPackage} sh -c 'mkdir -p shared_prefs && echo ${encoded} | base64 -d > shared_prefs/${DEV_MENU_PREFS}.xml'`,
+    ],
+    isQuiet: true,
+    tag,
+  });
+};
+
+// Launches the dev client straight into a Metro server. iOS passes the launcher's
+// --initialUrl argument because opening an exp+ URL shows an "Open in ...?" system prompt
+// that automation cannot dismiss.
+export const launchDevClientIntoMetro = async ({
+  platform,
+  deviceId,
+  expo,
+  metroPort,
+  devMenu,
+  tag,
+}: {
+  platform: "ios" | "android";
+  deviceId: string;
+  expo: ExpoInfo;
+  metroPort: number;
+  devMenu: DevMenuMode;
+  tag: string;
+}): Promise<void> => {
+  const metroUrl = `http://localhost:${metroPort}`;
+  if (platform === "ios") {
+    const prefs: [string, string][] =
+      devMenu === "hideAll"
+        ? [
+            ["EXDevMenuIsOnboardingFinished", "YES"],
+            ["EXDevMenuShowFloatingActionButton", "NO"],
+            ["EXDevMenuShowsAtLaunch", "NO"],
+          ]
+        : [["EXDevMenuIsOnboardingFinished", "YES"]];
+    for (const [key, value] of prefs) {
+      await runOrFail({
+        cmd: [
+          "xcrun",
+          "simctl",
+          "spawn",
+          deviceId,
+          "defaults",
+          "write",
+          expo.bundleId,
+          key,
+          "-bool",
+          value,
+        ],
+        isQuiet: true,
+        tag,
+      });
+    }
+    await runOrFail({
+      cmd: [
+        "xcrun",
+        "simctl",
+        "launch",
+        "--terminate-running-process",
+        deviceId,
+        expo.bundleId,
+        "--initialUrl",
+        metroUrl,
+      ],
+      isQuiet: true,
+      tag,
+    });
+    return;
+  }
+
+  // The app caches its prefs in memory, so stop it before rewriting them.
+  await runOrFail({
+    cmd: ["adb", "-s", deviceId, "shell", "am", "force-stop", expo.androidPackage],
+    isQuiet: true,
+    tag,
+  });
+  await writeAndroidDevMenuPrefs({
+    androidPackage: expo.androidPackage,
+    devMenu,
+    serial: deviceId,
+    tag,
+  });
+  const url = `exp+${expo.slug}://expo-development-client/?url=${encodeURIComponent(metroUrl)}`;
+  await runOrFail({
+    cmd: [
+      "adb",
+      "-s",
+      deviceId,
+      "shell",
+      "am",
+      "start",
+      "-a",
+      "android.intent.action.VIEW",
+      "-d",
+      `'${url}'`,
+    ],
+    isQuiet: true,
+    tag,
+  });
+};

package/skills/store-assets/scripts/icon.ts

@@ -0,0 +1,81 @@
+#!/usr/bin/env bun
+//
+// Render the Google Play high-res store icon (512x512, full-bleed square): the brand mark in
+// `onSurface` on the brand `surface`. Play applies its own corner mask and shadow, so the image
+// has square corners and no shadow.
+//
+// Usage:
+//   bun run store:icon <app>
+//
+// Needs `brand.iconSvg` in storeAssets.config.json.
+// Output: <appDir>/storeScreenshots/playIcon.png
+
+import {existsSync, mkdirSync} from "node:fs";
+import {join, resolve} from "node:path";
+import {chromium} from "@playwright/test";
+import {fail as failTagged, getApp, loadConfig, REPO_ROOT, say as sayTagged} from "./config";
+
+const TAG = "store:icon";
+const SIZE = 512;
+// Keeps the mark inside Play's masked safe area.
+const MARK_SIZE = 320;
+const DEFAULT_MARK_VIEWBOX = "0 0 64 64";
+
+const say = (message: string): void => sayTagged({message, tag: TAG});
+const fail = (message: string): never => failTagged({message, tag: TAG});
+
+const main = async (): Promise<void> => {
+  const config = await loadConfig({tag: TAG});
+  const app = getApp({appKey: process.argv[2], config, tag: TAG});
+  const brand = config.brand;
+  if (!brand) {
+    fail("storeAssets.config.json has no `brand` section");
+    return;
+  }
+  const svgPath = resolve(REPO_ROOT, brand.iconSvg);
+  if (!existsSync(svgPath)) {
+    fail(`Missing ${svgPath}`);
+    return;
+  }
+
+  let svg = await Bun.file(svgPath).text();
+  // A logo SVG can supply the mark: its first N <path>s, re-wrapped in the mark's viewBox.
+  // Root fill="none" matters because stroke-only paths would otherwise fill black.
+  if (brand.iconPathCount) {
+    // Matches both self-closing <path .../> and <path ...></path> elements.
+    const paths = (svg.match(/<path\b[^>]*?(?:\/>|>[\s\S]*?<\/path>)/g) ?? []).slice(
+      0,
+      brand.iconPathCount
+    );
+    if (paths.length !== brand.iconPathCount) {
+      fail(`Expected ${brand.iconPathCount} <path> elements in ${brand.iconSvg}`);
+    }
+    const viewBox = brand.iconViewBox ?? DEFAULT_MARK_VIEWBOX;
+    svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="${viewBox}" fill="none">${paths.join("")}</svg>`;
+  }
+  for (const color of brand.iconRecolor ?? []) {
+    svg = svg.replaceAll(`"${color}"`, `"${brand.onSurface}"`);
+  }
+  const mark = Buffer.from(svg).toString("base64");
+
+  const outDir = join(REPO_ROOT, app.appDir, "storeScreenshots");
+  mkdirSync(outDir, {recursive: true});
+  const outPath = join(outDir, "playIcon.png");
+  const browser = await chromium.launch();
+  try {
+    const page = await browser.newPage({
+      deviceScaleFactor: 1,
+      viewport: {height: SIZE, width: SIZE},
+    });
+    await page.setContent(`<!doctype html>
+<body style="margin:0;width:${SIZE}px;height:${SIZE}px;background:${brand.surface};display:flex;align-items:center;justify-content:center">
+  <img style="width:${MARK_SIZE}px;height:${MARK_SIZE}px" src="data:image/svg+xml;base64,${mark}" alt="">
+</body>`);
+    await page.screenshot({path: outPath});
+  } finally {
+    await browser.close();
+  }
+  say(`Saved ${outPath} (${SIZE}x${SIZE})`);
+};
+
+await main();

package/skills/store-assets/scripts/maestro/goHome.yaml

@@ -0,0 +1,21 @@
+appId: ${APP_ID}
+---
+# Returns to the home screen from a stack screen opened off home.
+# Android: system back. iOS has no system back, so restart the app; the dev client reloads the
+# last Metro bundle and the session persists. (A cold relaunch on Android leaves the dev client
+# on a blank screen.)
+- runFlow:
+    when:
+      platform: Android
+    commands:
+      - back
+- runFlow:
+    when:
+      platform: iOS
+    commands:
+      - stopApp
+      - launchApp
+- extendedWaitUntil:
+    visible:
+      id: ${HOME_SCREEN_ID}
+    timeout: 60000

package/skills/store-assets/scripts/maestro/login.yaml

@@ -0,0 +1,27 @@
+appId: ${APP_ID}
+---
+# Uses the @terreno/ui LoginScreen testIDs (login-screen-email-input, -password-input,
+# -submit-button). Give a custom login form the same testIDs.
+- tapOn:
+    id: "login-screen-email-input"
+- inputText: ${EMAIL}
+- tapOn:
+    id: "login-screen-password-input"
+- inputText: ${PASSWORD}
+- hideKeyboard
+- tapOn:
+    id: "login-screen-submit-button"
+- extendedWaitUntil:
+    visible:
+      id: ${HOME_SCREEN_ID}
+    timeout: 30000
+# iOS offers to save the password a moment after login; give it time to appear.
+- extendedWaitUntil:
+    visible: "Not Now"
+    timeout: 5000
+    optional: true
+- runFlow:
+    when:
+      visible: "Not Now"
+    commands:
+      - tapOn: "Not Now"

package/skills/store-assets/scripts/maestro/openApp.yaml

@@ -0,0 +1,26 @@
+appId: ${APP_ID}
+---
+# Waits for the app and signs in if needed. scripts/screenshots.ts has already launched the
+# dev client into the screenshot Metro server with the dev menu overlays disabled, and supplies
+# APP_ID, EMAIL, PASSWORD, and HOME_SCREEN_ID.
+# The first production bundle can take a minute to build.
+- extendedWaitUntil:
+    visible:
+      id: "login-screen|${HOME_SCREEN_ID}"
+    timeout: 180000
+# The app can re-render while it boots; let it settle before branching on login.
+- waitForAnimationToEnd:
+    timeout: 5000
+- extendedWaitUntil:
+    visible:
+      id: "login-screen-email-input|${HOME_SCREEN_ID}"
+    timeout: 30000
+- runFlow:
+    when:
+      visible:
+        id: "login-screen-email-input"
+    file: login.yaml
+- extendedWaitUntil:
+    visible:
+      id: ${HOME_SCREEN_ID}
+    timeout: 30000