native-sim 0.1.0

package/src/lib/gh.js

@@ -0,0 +1,170 @@
+import { sh, shx } from './proc.js';
+
+export function requireAuth() {
+  if (!sh('which', ['gh']).ok) {
+    throw new Error('GitHub CLI not found. Install it: brew install gh');
+  }
+  if (!sh('gh', ['auth', 'status']).ok) {
+    throw new Error('Not logged in to GitHub. Run: gh auth login');
+  }
+}
+
+/** `gh api <path>` returning parsed JSON. Returns null on failure. */
+export function api(path, extra = []) {
+  const r = sh('gh', ['api', path, ...extra]);
+  if (!r.ok) return null;
+  try {
+    return JSON.parse(r.out);
+  } catch {
+    return null;
+  }
+}
+
+/** owner/repo for the repo in `cwd`, or null when there is no remote yet. */
+export function nameWithOwner(cwd) {
+  const r = sh('gh', ['repo', 'view', '--json', 'nameWithOwner', '-q', '.nameWithOwner'], { cwd });
+  return r.ok ? r.out : null;
+}
+
+export function createRepo(cwd, name, { isPublic, branch }) {
+  const args = [
+    'repo', 'create', name,
+    isPublic ? '--public' : '--private',
+    '--source=.', '--remote=origin', '--push',
+  ];
+  shx('gh', args, { cwd });
+  // `--push` pushes the current branch; make sure upstream is set.
+  sh('git', ['branch', '--set-upstream-to', `origin/${branch}`, branch], { cwd });
+  return nameWithOwner(cwd);
+}
+
+export function repoExists(cwd) {
+  return nameWithOwner(cwd) !== null;
+}
+
+export function isPublicRepo(cwd) {
+  const r = sh('gh', ['repo', 'view', '--json', 'visibility', '-q', '.visibility'], { cwd });
+  return r.ok && r.out.toUpperCase() === 'PUBLIC';
+}
+
+/**
+ * GitHub indexes a newly pushed workflow asynchronously, so the very first
+ * dispatch after `gh repo create` routinely 404s for a few seconds.
+ */
+export async function dispatch(cwd, workflow, ref, inputs, { attempts = 12 } = {}) {
+  const args = ['workflow', 'run', workflow, '--ref', ref];
+  for (const [k, v] of Object.entries(inputs)) args.push('-f', `${k}=${v}`);
+
+  let last;
+  for (let i = 0; i < attempts; i++) {
+    const r = sh('gh', args, { cwd });
+    if (r.ok) return;
+    last = r.err || r.out;
+    if (!/could not find|not found|404|does not exist/i.test(last)) break;
+    await new Promise((resolve) => setTimeout(resolve, 5000));
+  }
+  throw new Error(`Could not dispatch ${workflow} on ${ref}:\n${last}`);
+}
+
+/**
+ * The first push to a brand-new empty repo is not scanned for workflows, so a
+ * freshly created repo can hold a valid workflow that Actions has never seen.
+ * Poll until GitHub has actually registered it.
+ */
+export async function waitForWorkflowRegistration(cwd, repo, path, { timeoutMs = 180000 } = {}) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const list = api(`repos/${repo}/actions/workflows`);
+    if (list?.workflows?.some((w) => w.path === path)) return true;
+    await new Promise((resolve) => setTimeout(resolve, 4000));
+  }
+  return false;
+}
+
+/** Find the run whose display title carries our session id. */
+export function findRun(cwd, workflow, session) {
+  const r = sh('gh', [
+    'run', 'list', '--workflow', workflow, '--limit', '25',
+    '--json', 'databaseId,displayTitle,status,conclusion,url,createdAt',
+  ], { cwd });
+  if (!r.ok) return null;
+  let runs;
+  try {
+    runs = JSON.parse(r.out);
+  } catch {
+    return null;
+  }
+  return runs.find((run) => run.displayTitle?.includes(session)) ?? null;
+}
+
+export function getRun(cwd, id) {
+  const r = sh('gh', [
+    'run', 'view', String(id),
+    '--json', 'databaseId,status,conclusion,url,displayTitle,jobs',
+  ], { cwd });
+  if (!r.ok) return null;
+  try {
+    return JSON.parse(r.out);
+  } catch {
+    return null;
+  }
+}
+
+/** Every run of `workflow` that is still queued or executing. */
+export function inFlightRuns(cwd, workflow) {
+  const r = sh('gh', [
+    'run', 'list', '--workflow', workflow, '--limit', '50',
+    '--json', 'databaseId,status,displayTitle,url',
+  ], { cwd });
+  if (!r.ok) return [];
+  try {
+    return JSON.parse(r.out).filter((run) => run.status !== 'completed');
+  } catch {
+    return [];
+  }
+}
+
+/** Artifacts are queryable as soon as their upload step finishes, mid-job. */
+export async function waitForArtifact(cwd, repo, runId, name, { timeoutMs = 45 * 60 * 1000 } = {}) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const list = api(`repos/${repo}/actions/runs/${runId}/artifacts`);
+    const hit = list?.artifacts?.find((a) => a.name === name && !a.expired);
+    if (hit) return hit;
+    const run = getRun(cwd, runId);
+    if (run?.status === 'completed' && run.conclusion !== 'success') {
+      throw new Error(`run finished (${run.conclusion}) without producing ${name}`);
+    }
+    await new Promise((resolve) => setTimeout(resolve, 10000));
+  }
+  throw new Error(`timed out waiting for artifact ${name}`);
+}
+
+export function downloadArtifact(cwd, runId, name, dir) {
+  shx('gh', ['run', 'download', String(runId), '-n', name, '-D', dir], { cwd });
+}
+
+/** Sets a repo secret. The value goes over stdin so it never lands in argv or shell history. */
+export function setSecret(cwd, name, value) {
+  const r = sh('gh', ['secret', 'set', name], { cwd, input: value });
+  if (!r.ok) throw new Error(`could not set ${name}: ${r.err || r.out}`);
+}
+
+export function listSecrets(cwd) {
+  const r = sh('gh', ['secret', 'list', '--json', 'name', '-q', '.[].name'], { cwd });
+  return r.ok ? r.out.split('\n').filter(Boolean) : [];
+}
+
+export function cancelRun(cwd, id) {
+  return sh('gh', ['run', 'cancel', String(id)], { cwd }).ok;
+}
+
+/**
+ * The runner publishes the tunnel URL as a commit status, which is readable
+ * live over the API (unlike logs or artifacts, which only land when the job ends).
+ */
+export function readStatus(cwd, repo, sha, context) {
+  const list = api(`repos/${repo}/commits/${sha}/statuses`, ['--jq', '.']);
+  if (!Array.isArray(list)) return null;
+  return list.find((s) => s.context === context) ?? null;
+}

package/src/lib/ghrelease.js

@@ -0,0 +1,50 @@
+import { basename } from 'node:path';
+import { statSync } from 'node:fs';
+import { sh, shx } from './proc.js';
+import { ensureArchive } from './r2.js';
+
+/**
+ * Host simulator builds as release assets on the repo the workflow runs in.
+ *
+ * The runner already has `GH_TOKEN: ${{ github.token }}`, and that token is
+ * scoped to exactly this repo — so an asset here is fetchable with no PAT, no
+ * third-party account, and no presigned URL to expire mid-session. A private
+ * repo's assets are private for free, which is the thing R2 was buying.
+ *
+ * One stable tag is reused and the asset clobbered, rather than a release per
+ * session, so the repo's release list does not fill with build noise.
+ */
+export const TAG = 'native-sim-build';
+
+/** Draft releases are not listed publicly, so a public repo does not publish your binary. */
+export function ensureRelease(cwd, repo, { draft = true } = {}) {
+  const existing = sh('gh', ['release', 'view', TAG, '--repo', repo, '--json', 'tagName'], { cwd });
+  if (existing.ok) return { created: false };
+
+  shx('gh', [
+    'release', 'create', TAG,
+    '--repo', repo,
+    '--title', 'native-sim builds',
+    '--notes', 'Simulator builds uploaded by `native-sim`. Managed automatically; safe to delete.',
+    ...(draft ? ['--draft'] : []),
+  ], { cwd });
+  return { created: true };
+}
+
+/** Uploads (or replaces) one archive. Returns what the workflow needs to fetch it. */
+export function upload(cwd, repo, filePath, { draft = true } = {}) {
+  const archive = ensureArchive(filePath);
+  const asset = basename(archive);
+  ensureRelease(cwd, repo, { draft });
+  // --clobber so re-running with the same build name replaces rather than fails.
+  shx('gh', ['release', 'upload', TAG, archive, '--repo', repo, '--clobber'], { cwd });
+  return { repo, tag: TAG, asset, bytes: statSync(archive).size };
+}
+
+/** True when the repo would expose this asset to anyone (published release on a public repo). */
+export function isPubliclyReadable(cwd, repo) {
+  const vis = sh('gh', ['repo', 'view', repo, '--json', 'visibility', '-q', '.visibility'], { cwd });
+  if (!vis.ok || vis.out.trim() !== 'PUBLIC') return false;
+  const rel = sh('gh', ['release', 'view', TAG, '--repo', repo, '--json', 'isDraft', '-q', '.isDraft'], { cwd });
+  return rel.ok && rel.out.trim() === 'false';
+}

package/src/lib/git.js

@@ -0,0 +1,68 @@
+import { realpathSync } from 'node:fs';
+import { sh, shx } from './proc.js';
+
+/**
+ * True only when `cwd` is itself a repo root. `--is-inside-work-tree` is true for
+ * any subdirectory of a repo, which would make native-sim skip `git init` inside a
+ * monorepo and then fail in `gh repo create`, which requires a repo root.
+ */
+export function isRepo(cwd) {
+  const r = sh('git', ['rev-parse', '--show-toplevel'], { cwd });
+  if (!r.ok) return false;
+  try {
+    return realpathSync(r.out) === realpathSync(cwd);
+  } catch {
+    return false;
+  }
+}
+
+export function init(cwd) {
+  shx('git', ['init', '-b', 'main'], { cwd });
+}
+
+export function currentBranch(cwd) {
+  const r = sh('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd });
+  return r.ok && r.out !== 'HEAD' ? r.out : 'main';
+}
+
+export function headSha(cwd) {
+  return shx('git', ['rev-parse', 'HEAD'], { cwd });
+}
+
+export function isDirty(cwd) {
+  return sh('git', ['status', '--porcelain'], { cwd }).out.length > 0;
+}
+
+export function hasCommits(cwd) {
+  return sh('git', ['rev-parse', '--verify', 'HEAD'], { cwd }).ok;
+}
+
+export function commitAll(cwd, message) {
+  shx('git', ['add', '-A'], { cwd });
+  // `git commit` exits non-zero when there is nothing staged; treat that as fine.
+  const r = sh('git', ['commit', '-m', message], { cwd });
+  if (!r.ok && !/nothing to commit/i.test(r.out + r.err)) {
+    throw new Error(`git commit failed\n${r.err || r.out}`);
+  }
+}
+
+export function remoteUrl(cwd, name = 'origin') {
+  const r = sh('git', ['remote', 'get-url', name], { cwd });
+  return r.ok ? r.out : null;
+}
+
+export function push(cwd, branch) {
+  shx('git', ['push', '-u', 'origin', branch], { cwd });
+}
+
+/** Ensure a .gitignore exists that covers the usual Expo build noise. */
+export const GITIGNORE = `node_modules/
+.expo/
+dist/
+web-build/
+ios/
+android/
+*.log
+.DS_Store
+.env*.local
+`;

package/src/lib/proc.js

@@ -0,0 +1,37 @@
+import { spawnSync, spawn } from 'node:child_process';
+
+/** Run a command, capture output. Never throws. */
+export function sh(cmd, args = [], opts = {}) {
+  const r = spawnSync(cmd, args, { encoding: 'utf8', ...opts });
+  return {
+    ok: r.status === 0,
+    code: r.status,
+    out: (r.stdout ?? '').trim(),
+    err: (r.stderr ?? '').trim(),
+  };
+}
+
+/** Run a command, capture output, throw on non-zero. */
+export function shx(cmd, args = [], opts = {}) {
+  const r = sh(cmd, args, opts);
+  if (!r.ok) {
+    throw new Error(`${cmd} ${args.join(' ')} failed (${r.code})\n${r.err || r.out}`);
+  }
+  return r.out;
+}
+
+/** Run a command with inherited stdio (user sees live output). */
+export function run(cmd, args = [], opts = {}) {
+  const r = spawnSync(cmd, args, { stdio: 'inherit', ...opts });
+  if (r.status !== 0) throw new Error(`${cmd} ${args.join(' ')} exited ${r.status}`);
+}
+
+export function has(cmd) {
+  return sh('which', [cmd]).ok;
+}
+
+export function open(url) {
+  spawn('open', [url], { detached: true, stdio: 'ignore' }).unref();
+}
+
+export const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

package/src/lib/project.js

@@ -0,0 +1,35 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { join, basename } from 'node:path';
+
+/** Throws unless `cwd` looks like an Expo app. */
+export function assertExpoProject(cwd) {
+  const pkgPath = join(cwd, 'package.json');
+  if (!existsSync(pkgPath)) {
+    throw new Error(`No package.json in ${cwd} — run native-sim from an Expo project root.`);
+  }
+  const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  if (!deps.expo) {
+    throw new Error(`${pkg.name ?? basename(cwd)} has no "expo" dependency — native-sim targets Expo apps.`);
+  }
+  return pkg;
+}
+
+/** Best-effort read of app.json / app.config.json. Config plugins in JS are ignored. */
+export function readAppConfig(cwd) {
+  for (const file of ['app.json', 'app.config.json']) {
+    const path = join(cwd, file);
+    if (!existsSync(path)) continue;
+    try {
+      return JSON.parse(readFileSync(path, 'utf8')).expo ?? {};
+    } catch {
+      return {};
+    }
+  }
+  return {};
+}
+
+
+export function defaultRepoName(cwd) {
+  return basename(cwd).replace(/[^A-Za-z0-9._-]+/g, '-').replace(/^-+|-+$/g, '') || 'expo-app';
+}

package/src/lib/r2.js

@@ -0,0 +1,94 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, statSync } from 'node:fs';
+import { join, basename } from 'node:path';
+import { homedir, tmpdir } from 'node:os';
+import { randomBytes } from 'node:crypto';
+import { sh, shx, has } from './proc.js';
+
+const CONFIG_DIR = join(homedir(), '.native-sim');
+const CONFIG_PATH = join(CONFIG_DIR, 'r2.json');
+
+/** Env wins over the config file, so CI can override without a file. */
+export function loadConfig() {
+  const file = existsSync(CONFIG_PATH) ? JSON.parse(readFileSync(CONFIG_PATH, 'utf8')) : {};
+  return {
+    accountId: process.env.R2_ACCOUNT_ID ?? file.accountId,
+    bucket: process.env.R2_BUCKET ?? file.bucket,
+    accessKeyId: process.env.R2_ACCESS_KEY_ID ?? file.accessKeyId,
+    secretAccessKey: process.env.R2_SECRET_ACCESS_KEY ?? file.secretAccessKey,
+  };
+}
+
+export function saveConfig(config) {
+  mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
+  return CONFIG_PATH;
+}
+
+export const configPath = () => CONFIG_PATH;
+
+export function assertConfigured(config) {
+  if (!has('aws')) {
+    throw new Error('aws CLI not found — R2 uses the S3 API. Install: brew install awscli');
+  }
+  const missing = ['accountId', 'bucket', 'accessKeyId', 'secretAccessKey'].filter((k) => !config[k]);
+  if (missing.length) {
+    throw new Error(
+      `R2 is not configured (missing: ${missing.join(', ')}).\n` +
+        `Run: native-sim r2 setup\n` +
+        `Or set R2_ACCOUNT_ID, R2_BUCKET, R2_ACCESS_KEY_ID, R2_SECRET_ACCESS_KEY.`,
+    );
+  }
+}
+
+const endpoint = (config) => `https://${config.accountId}.r2.cloudflarestorage.com`;
+
+function awsEnv(config) {
+  return {
+    ...process.env,
+    AWS_ACCESS_KEY_ID: config.accessKeyId,
+    AWS_SECRET_ACCESS_KEY: config.secretAccessKey,
+    AWS_DEFAULT_REGION: 'auto',
+    // R2 is not EC2; without this the SDK stalls probing instance metadata.
+    AWS_EC2_METADATA_DISABLED: 'true',
+  };
+}
+
+const awsArgs = (config) => ['--endpoint-url', endpoint(config), '--region', 'auto'];
+
+export function bucketExists(config) {
+  return sh('aws', ['s3api', 'head-bucket', '--bucket', config.bucket, ...awsArgs(config)],
+    { env: awsEnv(config) }).ok;
+}
+
+export function createBucket(config) {
+  shx('aws', ['s3api', 'create-bucket', '--bucket', config.bucket, ...awsArgs(config)],
+    { env: awsEnv(config) });
+}
+
+/**
+ * simctl installs a .app directory, so archive one if that is what we were given.
+ * Returns a path to a .tar.gz.
+ */
+export function ensureArchive(path) {
+  if (!existsSync(path)) throw new Error(`No such file: ${path}`);
+  if (!statSync(path).isDirectory()) return path;
+  if (!path.endsWith('.app')) throw new Error(`${path} is a directory but not a .app bundle`);
+
+  const out = join(tmpdir(), `${basename(path, '.app')}-${Date.now()}.tar.gz`);
+  shx('tar', ['-C', join(path, '..'), '-czf', out, basename(path)]);
+  return out;
+}
+
+/** Uploads and returns a presigned URL valid for `expiresIn` seconds. */
+export function upload(config, filePath, { expiresIn = 3600, prefix = 'native-sim' } = {}) {
+  assertConfigured(config);
+  const archive = ensureArchive(filePath);
+  const key = `${prefix}/${Date.now()}-${randomBytes(6).toString('hex')}-${basename(archive)}`;
+  const target = `s3://${config.bucket}/${key}`;
+
+  shx('aws', ['s3', 'cp', archive, target, ...awsArgs(config)], { env: awsEnv(config) });
+  const url = shx('aws', ['s3', 'presign', target, '--expires-in', String(expiresIn), ...awsArgs(config)],
+    { env: awsEnv(config) });
+
+  return { url, key, bytes: statSync(archive).size, expiresIn };
+}

package/src/lib/session.js

@@ -0,0 +1,24 @@
+import { writeFileSync, readFileSync, existsSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+
+/** Inside .git so it is never committed and dies with the clone. */
+const file = (cwd) => join(cwd, '.git', 'native-sim-session.json');
+
+export function saveSession(cwd, data) {
+  if (!existsSync(join(cwd, '.git'))) return;
+  writeFileSync(file(cwd), JSON.stringify({ ...data, startedAt: Date.now() }, null, 2));
+}
+
+export function loadSession(cwd) {
+  const path = file(cwd);
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+export function clearSession(cwd) {
+  rmSync(file(cwd), { force: true });
+}

package/src/lib/ui.js

@@ -0,0 +1,44 @@
+const tty = process.stdout.isTTY && !process.env.NO_COLOR;
+const c = (code) => (s) => (tty ? `\x1b[${code}m${s}\x1b[0m` : String(s));
+
+export const dim = c('2');
+export const bold = c('1');
+export const red = c('31');
+export const green = c('32');
+export const yellow = c('33');
+export const cyan = c('36');
+
+export const info = (msg) => console.log(`${cyan('›')} ${msg}`);
+export const ok = (msg) => console.log(`${green('✓')} ${msg}`);
+export const warn = (msg) => console.log(`${yellow('!')} ${msg}`);
+export const step = (msg) => console.log(`\n${bold(msg)}`);
+
+const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+
+/** Minimal spinner that degrades to plain lines when not a TTY. */
+export function spinner(text) {
+  let i = 0;
+  let label = text;
+  let timer = null;
+  if (tty) {
+    timer = setInterval(() => {
+      process.stdout.write(`\r${cyan(FRAMES[i++ % FRAMES.length])} ${label}\x1b[K`);
+    }, 80);
+  } else {
+    console.log(`… ${label}`);
+  }
+  return {
+    update(next) {
+      if (next === label) return;
+      label = next;
+      if (!tty) console.log(`… ${label}`);
+    },
+    stop(finalLine) {
+      if (timer) {
+        clearInterval(timer);
+        process.stdout.write('\r\x1b[K');
+      }
+      if (finalLine) console.log(finalLine);
+    },
+  };
+}