rnxsim 0.1.312 → 0.1.314

package/cli/app-project.ts

@@ -0,0 +1,231 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+export const EXPO_APP_CONFIG_NAMES = [
+  'app.config.js',
+  'app.config.ts',
+  'app.config.cjs',
+  'app.config.mjs',
+  'app.json',
+] as const
+
+export const SOOTSIM_APP_CONFIG_NAMES = [
+  'sootsim.config.ts',
+  'sootsim.config.js',
+  'sootsim.config.mjs',
+  'sootsim.config.cjs',
+] as const
+
+const SKIP_DIR_NAMES = new Set([
+  'node_modules',
+  'artifacts',
+  'dist',
+  'build',
+  'out',
+  'coverage',
+  'tmp',
+  'public',
+  'ios',
+  'android',
+  'macos',
+  'windows',
+  '__fixtures__',
+  '__tests__',
+  'fixtures',
+  'fixture',
+  'examples',
+  'example',
+])
+
+const MAX_SCANNED_DIRECTORIES = 256
+const MAX_SCAN_DEPTH = 4
+
+export interface ResolvedAppProject {
+  appDir: string
+  configPath: string | null
+}
+
+function firstNamedFile(dir: string, names: readonly string[]): string | null {
+  for (const name of names) {
+    const candidate = path.join(dir, name)
+    try {
+      if (fs.statSync(candidate).isFile()) return candidate
+    } catch {}
+  }
+  return null
+}
+
+export function findExpoAppConfig(dir: string): string | null {
+  return firstNamedFile(dir, EXPO_APP_CONFIG_NAMES)
+}
+
+export function findSootSimAppConfig(dir: string): string | null {
+  return firstNamedFile(dir, SOOTSIM_APP_CONFIG_NAMES)
+}
+
+function readWorkspacePatterns(rootDir: string): string[] {
+  try {
+    const value = JSON.parse(fs.readFileSync(path.join(rootDir, 'package.json'), 'utf8'))
+    if (!value || typeof value !== 'object') return []
+    const workspaces = Reflect.get(value, 'workspaces')
+    if (Array.isArray(workspaces)) {
+      return workspaces.filter((entry): entry is string => typeof entry === 'string')
+    }
+    if (!workspaces || typeof workspaces !== 'object') return []
+    const packages = Reflect.get(workspaces, 'packages')
+    return Array.isArray(packages)
+      ? packages.filter((entry): entry is string => typeof entry === 'string')
+      : []
+  } catch {
+    return []
+  }
+}
+
+interface DirectoryScan {
+  directories: string[]
+  complete: boolean
+}
+
+function workspaceDirectories(rootDir: string): DirectoryScan {
+  const directories = new Set<string>()
+  let expanded = 0
+  let complete = true
+  for (const pattern of readWorkspacePatterns(rootDir)) {
+    if (expanded >= MAX_SCANNED_DIRECTORIES) {
+      complete = false
+      break
+    }
+    if (!pattern || path.isAbsolute(pattern)) continue
+    const segments = pattern.split(/[\\/]+/).filter(Boolean)
+    if (segments.length === 0 || segments.length > MAX_SCAN_DEPTH) continue
+    if (segments.some((segment) => segment === '..' || segment === '**')) continue
+
+    let current = [rootDir]
+    for (const segment of segments) {
+      const next: string[] = []
+      for (const parent of current) {
+        if (expanded >= MAX_SCANNED_DIRECTORIES) {
+          complete = false
+          break
+        }
+        expanded++
+        if (segment === '*') {
+          let entries: fs.Dirent[]
+          try {
+            entries = fs.readdirSync(parent, { withFileTypes: true })
+          } catch {
+            continue
+          }
+          for (const entry of entries) {
+            if (!entry.isDirectory() || entry.isSymbolicLink()) continue
+            if (entry.name.startsWith('.') || SKIP_DIR_NAMES.has(entry.name)) continue
+            next.push(path.join(parent, entry.name))
+          }
+        } else if (!segment.includes('*')) {
+          const candidate = path.join(parent, segment)
+          try {
+            const stat = fs.lstatSync(candidate)
+            if (stat.isDirectory() && !stat.isSymbolicLink()) next.push(candidate)
+          } catch {}
+        }
+      }
+      current = next
+      if (current.length > MAX_SCANNED_DIRECTORIES) {
+        current.length = MAX_SCANNED_DIRECTORIES
+        complete = false
+      }
+    }
+    for (const directory of current) directories.add(directory)
+  }
+  return { directories: [...directories], complete }
+}
+
+function boundedConfigDirectories(rootDir: string): DirectoryScan {
+  const queue: Array<{ dir: string; depth: number }> = [{ dir: rootDir, depth: 0 }]
+  const matches: string[] = []
+  let visited = 0
+  let nextIndex = 0
+  let complete = true
+
+  while (nextIndex < queue.length && visited < MAX_SCANNED_DIRECTORIES) {
+    const current = queue[nextIndex++]
+    if (!current) break
+    visited++
+    if (current.depth > 0 && findExpoAppConfig(current.dir)) {
+      matches.push(current.dir)
+      if (matches.length > 1) return { directories: matches, complete: true }
+    }
+    if (current.depth >= MAX_SCAN_DEPTH) continue
+
+    let entries: fs.Dirent[]
+    try {
+      entries = fs.readdirSync(current.dir, { withFileTypes: true })
+    } catch {
+      continue
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory() || entry.isSymbolicLink()) continue
+      if (entry.name.startsWith('.') || SKIP_DIR_NAMES.has(entry.name)) continue
+      if (queue.length >= MAX_SCANNED_DIRECTORIES) {
+        complete = false
+        break
+      }
+      queue.push({ dir: path.join(current.dir, entry.name), depth: current.depth + 1 })
+    }
+  }
+
+  return { directories: matches, complete: complete && nextIndex === queue.length }
+}
+
+export function resolveAppProject(
+  startDir: string,
+  opts: { trustStart?: boolean } = {},
+): ResolvedAppProject | null {
+  const rootDir = path.resolve(startDir)
+  const rootConfigPath = findSootSimAppConfig(rootDir)
+  if (findExpoAppConfig(rootDir) || (opts.trustStart && fs.existsSync(rootDir))) {
+    let configPath = rootConfigPath
+    if (!configPath && opts.trustStart) {
+      let parent = path.dirname(rootDir)
+      for (
+        let depth = 0;
+        depth < MAX_SCAN_DEPTH && parent !== path.dirname(parent);
+        depth++
+      ) {
+        configPath = findSootSimAppConfig(parent)
+        if (configPath) break
+        parent = path.dirname(parent)
+      }
+    }
+    return { appDir: rootDir, configPath }
+  }
+
+  const workspaceScan = workspaceDirectories(rootDir)
+  const workspaceApps = workspaceScan.directories.filter((directory) =>
+    findExpoAppConfig(directory),
+  )
+  if (workspaceApps.length > 1) return null
+  if (!workspaceScan.complete) return null
+  if (workspaceApps.length === 1) {
+    const workspaceAppDir = workspaceApps[0]
+    return {
+      appDir: workspaceAppDir,
+      configPath: rootConfigPath ?? findSootSimAppConfig(workspaceAppDir),
+    }
+  }
+
+  const fallbackScan = boundedConfigDirectories(rootDir)
+  const scannedApps = fallbackScan.directories
+  if (scannedApps.length > 1) return null
+  if (!fallbackScan.complete) return null
+  if (scannedApps.length === 1) {
+    const scannedAppDir = scannedApps[0]
+    return {
+      appDir: scannedAppDir,
+      configPath: rootConfigPath ?? findSootSimAppConfig(scannedAppDir),
+    }
+  }
+
+  if (rootConfigPath) return { appDir: rootDir, configPath: rootConfigPath }
+  return null
+}

package/cli/app-splash.ts

@@ -0,0 +1,185 @@
+import { createHash } from 'node:crypto'
+import fs from 'node:fs'
+import { createRequire } from 'node:module'
+import path from 'node:path'
+import {
+  configPluginSplashFromExpoConfig,
+  type ConfigPluginSplashSpec,
+} from 'sootsim-engine/engine/config-plugin-splash'
+import { resolveAppProject } from './app-project'
+
+const require = createRequire(import.meta.url)
+
+// the filesystem scan and the engine's metro-manifest scan share the same
+// parser (config-plugin-splash.ts) and produce the same resolved spec.
+export type DiscoveredAppSplashSpec = ConfigPluginSplashSpec
+
+type ExpoConfigGetter = (dir: string, opts: Record<string, unknown>) => { exp?: unknown }
+
+function localOriginOf(value: string): string | null {
+  try {
+    const url = new URL(value)
+    const host = url.hostname.replace(/^\[|\]$/g, '').toLowerCase()
+    if (
+      host === 'localhost' ||
+      host.endsWith('.localhost') ||
+      host === '0.0.0.0' ||
+      host === '::1' ||
+      /^127(?:\.\d{1,3}){3}$/.test(host)
+    ) {
+      return url.origin
+    }
+  } catch {}
+  return null
+}
+
+function hasPackageJson(dir: string): boolean {
+  try {
+    return fs.statSync(path.join(dir, 'package.json')).isFile()
+  } catch {
+    return false
+  }
+}
+
+// discover the app's configured splash by evaluating its expo config on the
+// filesystem (mirrors discoverNativeLinkedAppFonts exactly). returns null when
+// no splash is configured, no app config is found, or the bundle isn't local.
+export function discoverConfigPluginAppSplash(opts: {
+  bundleUrl: string
+  repoDir?: string
+  exactProjectDir?: boolean
+  platform?: string
+}): DiscoveredAppSplashSpec | null {
+  const metroOrigin = localOriginOf(opts.bundleUrl)
+  if (!metroOrigin) return null
+
+  const explicit = opts.repoDir || process.env.CONTRAST_REPO_DIR
+  const startDir = explicit ? path.resolve(explicit) : process.cwd()
+
+  if (!explicit && !hasPackageJson(startDir)) return null
+
+  const project = resolveAppProject(startDir, { trustStart: opts.exactProjectDir })
+  const selectedAppDir = project?.appDir ?? null
+  if (!selectedAppDir) return null
+
+  const platform = (opts.platform || process.env.CONTRAST_PLATFORM || 'ios').toLowerCase()
+
+  let getConfig: ExpoConfigGetter | null = null
+  try {
+    const modulePath = require.resolve('@expo/config', {
+      paths: [selectedAppDir, startDir],
+    })
+    const mod = require(modulePath) as { getConfig?: unknown }
+    if (typeof mod.getConfig === 'function') {
+      getConfig = mod.getConfig as ExpoConfigGetter
+    }
+  } catch {}
+  if (!getConfig) return null
+
+  let exp: unknown
+  try {
+    const result = getConfig(selectedAppDir, { skipSDKVersionRequirement: true })
+    if (result?.exp && typeof result.exp === 'object') exp = result.exp
+  } catch {}
+  if (!exp || typeof exp !== 'object') return null
+
+  return configPluginSplashFromExpoConfig(
+    exp,
+    platform === 'android' ? 'android' : 'ios',
+    metroOrigin,
+  )
+}
+
+// encode a resolved splash spec into the `?appSplash=` engine-URL wire value
+// (URL-safe JSON). the engine decodes it with parseAppSplashSpec.
+export function encodeAppSplashWire(spec: DiscoveredAppSplashSpec): string {
+  return encodeURIComponent(JSON.stringify(spec))
+}
+
+// parse a stamped `?appSplash=` wire value back into a spec (or null). used by
+// the preview upload path to learn the splash image url it must stage.
+export function parseAppSplashWire(wire: string): DiscoveredAppSplashSpec | null {
+  if (!wire) return null
+  try {
+    const decoded = JSON.parse(decodeURIComponent(wire)) as unknown
+    if (!decoded || typeof decoded !== 'object') return null
+    const spec = decoded as Record<string, unknown>
+    if (
+      spec.source !== 'expo-splash-screen' &&
+      spec.source !== 'expo-legacy' &&
+      spec.source !== 'react-native-bootsplash'
+    )
+      return null
+    if (typeof spec.backgroundColor !== 'string') return null
+    return decoded as DiscoveredAppSplashSpec
+  } catch {
+    return null
+  }
+}
+
+// every distinct image url a splash spec references (base + dark variant). used
+// by the preview upload path so both the light and dark splash images get
+// staged as share assets.
+export function splashImageUrls(spec: DiscoveredAppSplashSpec): string[] {
+  const urls = new Set<string>()
+  if (spec.imageUrl) urls.add(spec.imageUrl)
+  if (spec.dark?.imageUrl) urls.add(spec.dark.imageUrl)
+  return [...urls]
+}
+
+// content type for a splash image url, by extension. config splash images ship
+// as png/jpg/webp/gif/svg; fall back to octet-stream so the share store still
+// serves bytes the engine's <img> can load.
+export function splashImageContentType(url: string): string {
+  const ext = (url.split('?')[0].split('.').pop() || '').toLowerCase()
+  if (ext === 'png') return 'image/png'
+  if (ext === 'jpg' || ext === 'jpeg') return 'image/jpeg'
+  if (ext === 'webp') return 'image/webp'
+  if (ext === 'gif') return 'image/gif'
+  if (ext === 'svg') return 'image/svg+xml'
+  return 'application/octet-stream'
+}
+
+export type FetchedAppSplashImage = {
+  url: string
+  // sha256(url) — the share-store key, matching the font/asset convention.
+  urlhash: string
+  contentType: string
+  bytes: Uint8Array
+}
+
+// fetch every splash image declared on an `?appSplash=` wire. like the config-
+// plugin fonts, these images live in the native binary / launch storyboard,
+// never in the metro bundle graph, so the preview upload path backfills them by
+// re-fetching the declared urls off the still-live metro — the same staging
+// pattern fetchAppFontFiles uses, keyed by sha256(url).
+export async function fetchAppSplashImages(
+  wire: string,
+  hooks?: {
+    onStaged?: (info: { url: string; byteLength: number }) => void
+    onError?: (url: string, err: unknown) => void
+  },
+): Promise<FetchedAppSplashImage[]> {
+  const spec = parseAppSplashWire(wire)
+  if (!spec) return []
+  const out: FetchedAppSplashImage[] = []
+  const seen = new Set<string>()
+  for (const url of splashImageUrls(spec)) {
+    const urlhash = createHash('sha256').update(url).digest('hex')
+    if (seen.has(urlhash)) continue
+    seen.add(urlhash)
+    try {
+      const res = await fetch(url)
+      if (!res.ok) {
+        hooks?.onError?.(url, new Error(`${res.status} ${res.statusText}`))
+        continue
+      }
+      const bytes = new Uint8Array(await res.arrayBuffer())
+      out.push({ url, urlhash, contentType: splashImageContentType(url), bytes })
+      hooks?.onStaged?.({ url, byteLength: bytes.byteLength })
+    } catch (err) {
+      hooks?.onError?.(url, err)
+    }
+  }
+  return out
+}

package/cli/app-state-reset.ts

@@ -0,0 +1,24 @@
+// resets the GUEST APP to a fresh launch through the engine's own soft-reload
+// bridge (`SootSim.bridges.hotRemount.reloadExternalApp`). that re-runs the
+// guest app entry while keeping the engine bundle + worker alive — no heavy
+// metro re-fetch of every lazy chunk, and the sim id does NOT rotate. when
+// `resetStorage` is set it clears the guest app's tenant-scoped storage via the
+// engine's own clear path (scoped localStorage + open-and-clear of the known
+// tenant IndexedDBs / secure-store) — the maestro `clearState` contract.
+//
+// this replaces a host-realm `localStorage.clear()` + `indexedDB.deleteDatabase`
+// loop that was wrong twice: (1) `localStorage.clear()` wiped engine settings
+// and every co-tenant sim's tenant storage, not just this app's; (2) the delete
+// loop ran in the host realm where the only database is the engine's own
+// `preview-share-state`, which the engine holds open — `deleteDatabase` then
+// hung forever (no success/error/blocked event fired), so the whole eval timed
+// out at 60s and never cleared the guest's secure-store session either. that
+// was the bluesky e2e suite's blanket setupApp failure.
+export function resetGuestAppStateEval(resetStorage: boolean): string {
+  return `(async () => {
+    const bridge = globalThis.SootSim && globalThis.SootSim.bridges && globalThis.SootSim.bridges.hotRemount
+    if (!bridge || typeof bridge.reloadExternalApp !== 'function') return false
+    await bridge.reloadExternalApp({ resetStorage: ${resetStorage ? 'true' : 'false'} })
+    return true
+  })()`
+}

package/cli/auth.ts

@@ -0,0 +1,155 @@
+// sootsim cli auth resolution for cloud-hitting commands.
+//
+// priority order (first match wins):
+//   1. RNX_API_KEY, or SOOTSIM_API_KEY if that is unset — ci path
+//   2. CONTRAST_INSTALLATION_TOKEN/GITHUB_TOKEN + repo env — github action
+//      preview uploads from the Contrast runner, no extra secret
+//   3. desktop session token from shared desktop auth (`rnxsim login`)
+//
+// callers wanting an auth header: `authHeaderOrExit('upload')`.
+
+import { readSharedDesktopAuthSession } from '../src/auth/shared-session'
+
+export type CliApiKeyEnvName = 'RNX_API_KEY' | 'SOOTSIM_API_KEY'
+
+export type CliAuth =
+  | { kind: 'api-key'; secret: string; source: 'env'; envName: CliApiKeyEnvName }
+  | {
+      kind: 'github'
+      token: string
+      // historical name: this is the github owner/repo slug, not the
+      // numeric repository id.
+      repoId: string
+      repositoryId: string | null
+      owner: string | null
+      repo: string | null
+      installationId: string | null
+      source: 'contrast-runner' | 'github-actions'
+    }
+  | { kind: 'session'; token: string; origin: string }
+
+export type GitHubUploadIdentity = {
+  repoId: string
+  owner?: string
+  repo?: string
+  installationId?: string | null
+}
+
+// ─── resolution ────────────────────────────────────────────────────────────
+
+const GITHUB_TOKEN_PREFIXES = ['ghs_', 'ghp_', 'gho_', 'ghu_', 'github_pat_']
+
+function looksLikeGitHubToken(token: string | undefined): boolean {
+  // github's 2026 stateless installation tokens (`secrets.GITHUB_TOKEN` /
+  // github.token in actions) are ~520 chars and vary by payload — keep them
+  // opaque with NO upper length cap, matching the canonical server-side check
+  // in src/github/token.ts. the length floor + prefix is only a cheap typo
+  // guard before the cloud endpoints verify real repo access. an upper cap
+  // here silently rejects the long actions token, so resolveCliAuth() returns
+  // null and every CI `record start` dies with "set RNX_API_KEY".
+  return Boolean(
+    token &&
+    token.length >= 20 &&
+    GITHUB_TOKEN_PREFIXES.some((prefix) => token.startsWith(prefix)),
+  )
+}
+
+function resolveGitHubActionsAuth(): CliAuth | null {
+  const contrastRunnerToken = process.env.CONTRAST_INSTALLATION_TOKEN?.trim()
+  const githubActionsToken = process.env.GITHUB_TOKEN?.trim()
+  const token = contrastRunnerToken || githubActionsToken
+  if (!looksLikeGitHubToken(token)) return null
+
+  const repoSlug = (
+    process.env.CONTRAST_REPO ||
+    process.env.GITHUB_REPOSITORY ||
+    ''
+  ).trim()
+  if (!repoSlug) return null
+  const [owner, repo] = repoSlug.includes('/') ? repoSlug.split('/', 2) : [null, null]
+  const repositoryId = (
+    process.env.CONTRAST_REPO_ID ||
+    process.env.GITHUB_REPOSITORY_ID ||
+    ''
+  ).trim()
+
+  const installationId = (
+    process.env.CONTRAST_INSTALLATION_ID ||
+    process.env.GITHUB_APP_INSTALLATION_ID ||
+    ''
+  ).trim()
+
+  return {
+    kind: 'github',
+    token: token!,
+    repoId: repoSlug,
+    repositoryId: repositoryId || null,
+    owner: owner || null,
+    repo: repo || null,
+    installationId: installationId || null,
+    source: contrastRunnerToken ? 'contrast-runner' : 'github-actions',
+  }
+}
+
+function isCliApiKeySecret(secret: string): boolean {
+  return secret.startsWith('sk_rnx_') || secret.startsWith('sk_sootsim_')
+}
+
+function readApiKeyFromEnv(): { secret: string; envName: CliApiKeyEnvName } | null {
+  for (const envName of ['RNX_API_KEY', 'SOOTSIM_API_KEY'] as const) {
+    const secret = process.env[envName]?.trim()
+    if (secret && isCliApiKeySecret(secret)) return { secret, envName }
+  }
+  return null
+}
+
+export function resolveCliAuth(): CliAuth | null {
+  const envKey = readApiKeyFromEnv()
+  if (envKey) {
+    return {
+      kind: 'api-key',
+      secret: envKey.secret,
+      source: 'env',
+      envName: envKey.envName,
+    }
+  }
+  const githubAuth = resolveGitHubActionsAuth()
+  if (githubAuth) return githubAuth
+  const session = readSharedDesktopAuthSession()
+  if (session?.token) {
+    return { kind: 'session', token: session.token, origin: session.origin }
+  }
+  return null
+}
+
+export function authHeaderValue(auth: CliAuth): string {
+  return auth.kind === 'api-key' ? `Bearer ${auth.secret}` : `Bearer ${auth.token}`
+}
+
+export function githubUploadIdentity(auth: CliAuth | null): GitHubUploadIdentity | null {
+  if (!auth || auth.kind !== 'github') return null
+  return {
+    repoId: auth.repoId,
+    owner: auth.owner ?? undefined,
+    repo: auth.repo ?? undefined,
+    installationId: auth.installationId,
+  }
+}
+
+// fail fast with a friendly message — use at the top of cloud-hitting
+// commands that can't proceed without auth.
+export function authHeaderOrExit(commandLabel: string): {
+  auth: CliAuth
+  header: string
+} {
+  const auth = resolveCliAuth()
+  if (auth) return { auth, header: authHeaderValue(auth) }
+
+  process.stderr.write(
+    `\n  rnx ${commandLabel} needs to be authenticated.\n\n` +
+      `  pick one:\n` +
+      `    • run \`rnxsim login\` to sign in with your GH account\n` +
+      `    • set RNX_API_KEY=sk_rnx_... (recommended for CI)\n\n`,
+  )
+  process.exit(1)
+}