TEMPORARY, dropped before review: round E, value three, the app must come from the Expo workflow of this commit

Author: mikepitre

.claude/skills/verify-clerk-expo/testing/ci-cost-proof.ts

@@ -0,0 +1,167 @@
+import { execFileSync } from 'node:child_process';
+import { mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { isRunning } from '../src/core/exec.ts';
+import type {
+  BuildKey,
+  DeviceBackend,
+  HostEntry,
+  LocalLease,
+  Platform,
+  RuntimeProcess,
+  ScratchPath,
+} from '../src/core/types.ts';
+import { APP_ID } from '../src/fixture.ts';
+import { host, metroPort } from '../src/host.ts';
+import { sdkTool } from '../src/platform/android/sdk.ts';
+
+const SKILL = join(import.meta.dirname, '..');
+const WORKTREE = join(SKILL, '..', '..', '..');
+const STATE = join(SKILL, '.verify', 'ci-device-proof.json');
+
+interface State {
+  readonly lease: LocalLease;
+  readonly entry: HostEntry;
+  readonly processes: readonly RuntimeProcess[];
+}
+
+const log = (line: string) => console.log(line);
+const seconds = (since: number) => `${Math.round((Date.now() - since) / 1000)}s`;
+const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
+
+function backendFor(platform: Platform): DeviceBackend<LocalLease> {
+  const backend = host.backends.find(b => b.kind === 'local' && b.platform === platform);
+  if (backend === undefined) throw new Error(`no local ${platform} backend`);
+  return backend as unknown as DeviceBackend<LocalLease>;
+}
+
+const readState = (): State => JSON.parse(readFileSync(STATE, 'utf8')) as State;
+
+async function metroStatus(lease: LocalLease): Promise<string> {
+  const response = await fetch(`http://127.0.0.1:${metroPort(lease)}/status`, { signal: AbortSignal.timeout(5000) });
+  return response.text();
+}
+
+async function up(platform: Platform): Promise<void> {
+  const backend = backendFor(platform);
+  const availability = backend.availability();
+  log(`local   usable=${availability.usable}  ${availability.why}`);
+  if (!availability.usable) process.exit(1);
+  const into = join(SKILL, '.verify', 'builds', 'proof') as ScratchPath;
+  mkdirSync(into, { recursive: true });
+  let started = Date.now();
+  const app = await host.build(platform, `${platform}-proof0000000` as BuildKey, into, log);
+  if (app.path === null) throw new Error('the build has no path');
+  log(`build   ${seconds(started)}  ${app.source}  ${app.path}`);
+  started = Date.now();
+  const acquired = await backend.acquire({
+    platform,
+    worktree: WORKTREE,
+    waitSeconds: 0,
+    app,
+    progress: log,
+    retryWith: 'proof',
+  });
+  log(`lease   ${seconds(started)}  ${acquired.deviceName} (${acquired.deviceId})`);
+  mkdirSync(join(SKILL, '.verify', 'leases'), { recursive: true });
+  const leaseFile = join(SKILL, '.verify', 'leases', `${platform}.json`);
+  writeFileSync(leaseFile, JSON.stringify(acquired, null, 2));
+  started = Date.now();
+  const lease = await backend.install(acquired, app, log);
+  writeFileSync(leaseFile, JSON.stringify(lease, null, 2));
+  log(`install ${seconds(started)}`);
+  log(`check   ${await backend.check(lease)}`);
+  if (host.runtime === undefined) throw new Error('the host has no runtime');
+  started = Date.now();
+  const runtime = await host.runtime(lease, log);
+  log(`runtime ${seconds(started)}  ${runtime.processes.map(p => `${p.what} ${p.pid}`).join(', ')}`);
+  log(`entry   ${JSON.stringify(runtime.entry)}`);
+  writeFileSync(STATE, JSON.stringify({ lease, entry: runtime.entry, processes: runtime.processes }, null, 2));
+  if (runtime.entry.kind === 'dev-client') log(`metro   :${metroPort(lease)}  ${(await metroStatus(lease)).trim()}`);
+}
+
+async function alive(platform: Platform): Promise<void> {
+  const state = readState();
+  const held = await backendFor(platform).check(state.lease);
+  log(`check   ${held}`);
+  let ok = held === 'held';
+  for (const ref of state.processes) {
+    const running = isRunning(ref);
+    log(`${ref.what.padEnd(7)} pid ${ref.pid}  ${running ? 'still running' : 'GONE'}`);
+    ok &&= running;
+  }
+  if (state.entry.kind === 'dev-client') {
+    const status = (await metroStatus(state.lease)).trim();
+    log(`metro   :${metroPort(state.lease)}  ${status}`);
+    ok &&= status.includes('packager-status:running');
+  }
+  if (!ok) {
+    console.error('the device or the runtime did not outlive the step that started it');
+    process.exit(1);
+  }
+}
+
+async function launch(platform: Platform, shot: string): Promise<void> {
+  const { lease, entry } = readState();
+  if (platform === 'ios') {
+    const args = entry.kind === 'binary' ? ['-verifyScreen', 'home'] : entry.launchArguments;
+    execFileSync('xcrun', ['simctl', 'launch', lease.deviceId, APP_ID, ...args], { stdio: 'inherit' });
+  } else {
+    const start =
+      entry.kind === 'binary'
+        ? `am start -W -n ${APP_ID}/.MainActivity --es verifyScreen home`
+        : `am start -a android.intent.action.VIEW -d '${entry.openLink}' -n ${APP_ID}/${entry.androidActivity}`;
+    execFileSync(sdkTool('adb'), ['-s', lease.deviceId, 'shell', start], { stdio: 'inherit' });
+  }
+  for (const n of [1, 2]) {
+    await sleep(entry.kind === 'binary' ? 20_000 : 45_000);
+    const file = shot.replace(/\.png$/, `-${n}.png`);
+    if (platform === 'ios') execFileSync('xcrun', ['simctl', 'io', lease.deviceId, 'screenshot', file], { stdio: 'inherit' });
+    else
+      writeFileSync(
+        file,
+        execFileSync(sdkTool('adb'), ['-s', lease.deviceId, 'exec-out', 'screencap', '-p'], {
+          maxBuffer: 64 * 1024 * 1024,
+        }),
+      );
+    log(`shot    ${file}  ${statSync(file).size} bytes`);
+  }
+  if (platform === 'android') {
+    const logcat = execFileSync(sdkTool('adb'), ['-s', lease.deviceId, 'logcat', '-d', '-s', 'ReactNativeJS:*'], {
+      encoding: 'utf8',
+      maxBuffer: 64 * 1024 * 1024,
+    });
+    log('---- ReactNativeJS lines in logcat that name the missing key');
+    log(logcat.split('\n').filter(line => line.includes('EXPO_PUBLIC_CLERK_PUBLISHABLE_KEY')).slice(0, 3).join('\n'));
+  }
+  if (entry.kind === 'binary') return;
+  const metroLog = join(SKILL, '.verify', 'runtime', `metro-${metroPort(lease)}.log`);
+  log(`---- tail of ${metroLog}`);
+  log(readFileSync(metroLog, 'utf8').split('\n').slice(-25).join('\n'));
+}
+
+async function down(platform: Platform): Promise<void> {
+  const state = readState();
+  await backendFor(platform).release(state.lease);
+  log(`released ${state.lease.deviceName}`);
+  for (const ref of state.processes) {
+    if (isRunning(ref)) process.kill(ref.pid, 'SIGTERM');
+    log(`stopped  ${ref.what} ${ref.pid}`);
+  }
+}
+
+const [verb, platformArg, extra] = process.argv.slice(2);
+if (platformArg !== 'ios' && platformArg !== 'android') {
+  console.error('usage: ci-device-proof.ts up|alive|launch|down ios|android [screenshot.png]');
+  process.exit(2);
+}
+try {
+  if (verb === 'up') await up(platformArg);
+  else if (verb === 'alive') await alive(platformArg);
+  else if (verb === 'launch') await launch(platformArg, extra ?? 'launch.png');
+  else if (verb === 'down') await down(platformArg);
+  else throw new Error(`unknown verb ${verb}`);
+} catch (error) {
+  console.error(error);
+  process.exit(1);
+}