peachsim 0.1.527

package/cli/app-config.ts

@@ -0,0 +1,82 @@
+import { createRequire } from 'node:module'
+import path from 'node:path'
+import { isValidRuntimeVersion } from '@contrast/runtime-delivery'
+import { createJiti } from 'jiti'
+import { rnxPublicBrand } from '../src/public-brand'
+import { resolveAppProject, type ResolvedAppProject } from './app-project'
+import type { RNXConfig } from '../src/config'
+
+const require = createRequire(import.meta.url)
+
+function isOptionalRecord(value: unknown): boolean {
+  return (
+    value === undefined ||
+    (value !== null && typeof value === 'object' && !Array.isArray(value))
+  )
+}
+
+function isRNXConfig(value: unknown): value is RNXConfig {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false
+  const runtimeVersion = Reflect.get(value, 'runtimeVersion')
+  const network = Reflect.get(value, 'network')
+  return (
+    (runtimeVersion === undefined ||
+      (typeof runtimeVersion === 'string' &&
+        runtimeVersion === runtimeVersion.trim() &&
+        isValidRuntimeVersion(runtimeVersion))) &&
+    isOptionalRecord(Reflect.get(value, 'modules')) &&
+    isOptionalRecord(Reflect.get(value, 'turboModules')) &&
+    isOptionalRecord(Reflect.get(value, 'nativeModules')) &&
+    isOptionalRecord(Reflect.get(value, 'env')) &&
+    isOptionalRecord(network) &&
+    isOptionalRecord(Reflect.get(value, 'settings')) &&
+    isOptionalRecord(Reflect.get(value, 'initialState'))
+  )
+}
+
+function resolveConfigReplacementFiles(config: RNXConfig, configPath: string): RNXConfig {
+  if (!config.modules) return config
+  const configDir = path.dirname(configPath)
+  return {
+    ...config,
+    modules: Object.fromEntries(
+      Object.entries(config.modules).map(([name, resolution]) => [
+        name,
+        resolution && typeof resolution === 'object' && 'file' in resolution
+          ? { ...resolution, file: path.resolve(configDir, resolution.file) }
+          : resolution,
+      ]),
+    ),
+  }
+}
+
+export async function loadRNXAppConfig(
+  project: ResolvedAppProject | null,
+): Promise<RNXConfig | undefined> {
+  if (!project?.configPath) return undefined
+  try {
+    const jiti = createJiti(import.meta.url, {
+      interopDefault: true,
+      alias: {
+        [`${rnxPublicBrand.packageName}/config`]: require.resolve(
+          `${rnxPublicBrand.packageName}/config`,
+        ),
+      },
+    })
+    const loaded: unknown = await jiti.import(project.configPath, { default: true })
+    if (!isRNXConfig(loaded)) {
+      throw new Error('the default export must be an rnx config object')
+    }
+    return resolveConfigReplacementFiles(loaded, project.configPath)
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    throw new Error(`could not load ${project.configPath}: ${message}`)
+  }
+}
+
+export async function resolveRNXAppConfig(
+  startDir: string = process.cwd(),
+): Promise<{ project: ResolvedAppProject | null; config: RNXConfig | undefined }> {
+  const project = resolveAppProject(startDir)
+  return { project, config: await loadRNXAppConfig(project) }
+}

package/cli/app-fonts.ts

@@ -0,0 +1,388 @@
+import { createHash } from 'node:crypto'
+import fs from 'node:fs'
+import { createRequire } from 'node:module'
+import path from 'node:path'
+import {
+  expoFontPathsFromPlugins,
+  metroFontSpecsFromPaths,
+  type ConfigPluginFontSpec,
+} from 'sootsim-engine/engine/config-plugin-fonts'
+import { resolveListeningPid, resolveProcessCwd } from '../scripts/dev-server-scanner'
+import { parsePlistSource } from '../src/plist.ts'
+import { resolveAppProject } from './app-project'
+
+const require = createRequire(import.meta.url)
+
+// the filesystem scan and the engine's metro-manifest scan share the same spec
+// shape and the same path → spec logic (config-plugin-fonts.ts).
+export type DiscoveredAppFontSpec = ConfigPluginFontSpec
+
+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
+}
+
+export function discoverNativeLinkedAppFonts(opts: {
+  bundleUrl: string
+  projectDir: string
+  platform?: string
+}): DiscoveredAppFontSpec[] {
+  const metroOrigin = localOriginOf(opts.bundleUrl)
+  if (!metroOrigin) return []
+
+  const project = resolveAppProject(opts.projectDir)
+  const selectedAppDir = project?.appDir ?? null
+  if (!selectedAppDir) return []
+
+  const platform = (opts.platform || process.env.CONTRAST_PLATFORM || 'ios').toLowerCase()
+
+  let getConfig: ExpoConfigGetter | null = null
+  // resolve from the exact app root advertised by the development server.
+  if (project) {
+    try {
+      const modulePath = require.resolve('@expo/config', {
+        paths: [selectedAppDir],
+      })
+      const mod = require(modulePath) as { getConfig?: unknown }
+      if (typeof mod.getConfig === 'function') {
+        getConfig = mod.getConfig as ExpoConfigGetter
+      }
+    } catch {}
+  }
+  let plugins: unknown = []
+  if (getConfig) {
+    try {
+      const result = getConfig(selectedAppDir, { skipSDKVersionRequirement: true })
+      if (result?.exp && typeof result.exp === 'object') {
+        const resolvedPlugins = (result.exp as Record<string, unknown>).plugins
+        if (Array.isArray(resolvedPlugins)) {
+          plugins = resolvedPlugins
+        }
+      }
+    } catch {}
+  }
+
+  const fontPaths = expoFontPathsFromPlugins(
+    plugins,
+    platform === 'android' ? 'android' : 'ios',
+  ).slice(0, 256)
+  // the walk is bounded by WORK, not by a clock: at most 64 readdirs, at most 64
+  // queued dirs, 4 levels deep, 256 paths. those ceilings are what keep a stray
+  // node_modules from being crawled, and no machine can blow through them. a
+  // wall-clock budget on top of that only makes the RESULT depend on how busy
+  // the box is, and silently — a user on a loaded machine would get fewer fonts
+  // and no error at all.
+  let scannedFontDirectories = 0
+
+  const collectFontFiles = (root: string, metroPathPrefix: string): void => {
+    const pending: Array<{ dir: string; depth: number }> = [{ dir: root, depth: 0 }]
+    let nextIndex = 0
+    while (
+      nextIndex < pending.length &&
+      scannedFontDirectories < 64 &&
+      fontPaths.length < 256
+    ) {
+      const current = pending[nextIndex++]
+      if (!current) continue
+      scannedFontDirectories++
+      let entries: fs.Dirent[]
+      try {
+        entries = fs.readdirSync(current.dir, { withFileTypes: true })
+      } catch {
+        continue
+      }
+      for (const entry of entries) {
+        if (entry.isSymbolicLink()) continue
+        const fullPath = path.join(current.dir, entry.name)
+        if (entry.isDirectory()) {
+          if (current.depth < 4 && pending.length < 64 && !entry.name.startsWith('.')) {
+            pending.push({ dir: fullPath, depth: current.depth + 1 })
+          }
+          continue
+        }
+        if (!entry.isFile() || !/\.(ttf|otf|woff|woff2)$/i.test(entry.name)) continue
+        const relative = path.relative(root, fullPath).split(path.sep).join('/')
+        fontPaths.push(path.posix.join(metroPathPrefix, relative))
+        if (fontPaths.length >= 256) break
+      }
+    }
+  }
+
+  // @react-native-vector-icons links fonts from its configured local font
+  // directory and each installed icon package into the native app. those files
+  // never enter the metro module graph, so rnx must stage them through the
+  // same native-linked font wire as expo-font config-plugin assets. Font Awesome
+  // Pro installs its licensed faces under the local directory rather than
+  // publishing them in the npm package.
+  try {
+    const packageJson: object = JSON.parse(
+      fs.readFileSync(path.join(selectedAppDir, 'package.json'), 'utf8'),
+    )
+    const dependencyNames = new Set<string>()
+    for (const field of ['dependencies', 'devDependencies', 'optionalDependencies']) {
+      const dependencies = Reflect.get(packageJson, field)
+      if (!dependencies || typeof dependencies !== 'object') continue
+      for (const name of Object.keys(dependencies)) dependencyNames.add(name)
+    }
+    const vectorIconDependencies = [...dependencyNames].filter(
+      (name) =>
+        name === 'react-native-vector-icons' ||
+        name.startsWith('@react-native-vector-icons/'),
+    )
+    if (vectorIconDependencies.length > 0) {
+      const config = Reflect.get(packageJson, 'reactNativeVectorIcons')
+      const configuredFontDir =
+        config && typeof config === 'object' ? Reflect.get(config, 'fontDir') : null
+      const configuredDir =
+        typeof configuredFontDir === 'string' ? configuredFontDir : 'rnvi-fonts'
+      const root = path.resolve(selectedAppDir, configuredDir)
+      const relativeRoot = path.relative(selectedAppDir, root)
+      if (!relativeRoot.startsWith('..') && !path.isAbsolute(relativeRoot)) {
+        collectFontFiles(root, relativeRoot.split(path.sep).join('/'))
+      }
+
+      const vectorIconRequire = createRequire(path.join(selectedAppDir, 'package.json'))
+      for (const dependencyName of vectorIconDependencies) {
+        try {
+          const entryPath = vectorIconRequire.resolve(dependencyName)
+          const dependencyPath = dependencyName.split('/').join(path.sep)
+          const marker = `${path.sep}node_modules${path.sep}${dependencyPath}${path.sep}`
+          const markerIndex = entryPath.lastIndexOf(marker)
+          if (markerIndex === -1) continue
+          const packageRoot = entryPath.slice(0, markerIndex + marker.length - 1)
+          const fontsDir =
+            dependencyName === 'react-native-vector-icons' ? 'Fonts' : 'fonts'
+          collectFontFiles(
+            path.join(packageRoot, fontsDir),
+            path.posix.join('node_modules', dependencyName, fontsDir),
+          )
+        } catch {}
+      }
+    }
+  } catch {}
+
+  // react-native.config.js `assets` is the RN CLI's native asset-linking
+  // source: `npx react-native-asset` copies every font in those directories
+  // into the app bundle and Info.plist UIAppFonts, and the JS never requires
+  // the files, so they enter no module graph. apps like mattermost register
+  // icon sets (createIconSetFromFontello) purely by family name against a
+  // font linked this way.
+  try {
+    const configPath = path.join(selectedAppDir, 'react-native.config.js')
+    if (fs.statSync(configPath).isFile()) {
+      const appConfigRequire = createRequire(path.join(selectedAppDir, 'package.json'))
+      const rnConfig: unknown = appConfigRequire(configPath)
+      const assets =
+        rnConfig && typeof rnConfig === 'object' ? Reflect.get(rnConfig, 'assets') : null
+      if (Array.isArray(assets)) {
+        for (const assetDir of assets) {
+          if (typeof assetDir !== 'string') continue
+          const root = path.resolve(selectedAppDir, assetDir)
+          const relativeRoot = path.relative(selectedAppDir, root)
+          if (relativeRoot.startsWith('..') || path.isAbsolute(relativeRoot)) continue
+          collectFontFiles(root, relativeRoot.split(path.sep).join('/'))
+        }
+      }
+    }
+  } catch {}
+
+  // bare iOS projects can embed fonts directly in an Xcode target without a
+  // react-native.config.js assets declaration. UIAppFonts is the native
+  // contract, so stage those referenced files through Metro's asset endpoint.
+  if (platform === 'ios') {
+    const iosDir = path.join(selectedAppDir, 'ios')
+    try {
+      const targetDirs = fs
+        .readdirSync(iosDir, { withFileTypes: true })
+        .filter(
+          (entry) =>
+            entry.isDirectory() &&
+            !entry.isSymbolicLink() &&
+            entry.name !== 'Pods' &&
+            entry.name !== 'build' &&
+            !entry.name.startsWith('.'),
+        )
+        .slice(0, 64)
+      const plistPaths = [path.join(iosDir, 'Info.plist')]
+      for (const entry of targetDirs) {
+        plistPaths.push(path.join(iosDir, entry.name, 'Info.plist'))
+      }
+      for (const plistPath of plistPaths) {
+        let parsed: unknown
+        try {
+          parsed = parsePlistSource(fs.readFileSync(plistPath, 'utf8'))
+        } catch {
+          continue
+        }
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) continue
+        const declaredFonts = Reflect.get(parsed, 'UIAppFonts')
+        if (!Array.isArray(declaredFonts)) continue
+        for (const declaredFont of declaredFonts) {
+          if (typeof declaredFont !== 'string') continue
+          const candidates = [
+            path.resolve(path.dirname(plistPath), declaredFont),
+            path.resolve(iosDir, declaredFont),
+          ]
+          const fontPath = candidates.find((candidate) => {
+            const relative = path.relative(selectedAppDir, candidate)
+            if (relative.startsWith('..') || path.isAbsolute(relative)) return false
+            try {
+              return fs.statSync(candidate).isFile()
+            } catch {
+              return false
+            }
+          })
+          if (!fontPath) continue
+          fontPaths.push(
+            path.relative(selectedAppDir, fontPath).split(path.sep).join('/'),
+          )
+        }
+      }
+    } catch {}
+  }
+
+  return metroFontSpecsFromPaths(fontPaths, metroOrigin)
+}
+
+// resolve a metro dev server's project root. expo serves a manifest at the
+// server origin carrying `extra.expoClient._internal.projectRoot` — the absolute
+// dir of the app being served. the local `rnx open <port>` path runs from the
+// CLI's cwd, which almost never owns the bundle being opened (e.g.
+// `rnx open 8081` run from ~/soot against a 3pc metro), so scanning cwd for
+// font declarations finds nothing.
+//
+// a bare react-native packager serves no such manifest, so the same resolver
+// asks the OS for the listening process's cwd. that is still the development
+// server's project identity; the invoking CLI's cwd is never consulted.
+export async function resolveMetroProjectRoot(
+  bundleUrl: string,
+  opts?: { timeoutMs?: number },
+): Promise<string | null> {
+  const origin = localOriginOf(bundleUrl)
+  if (!origin) return null
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), opts?.timeoutMs ?? 1500)
+  let servedManifest = false
+  try {
+    const res = await fetch(`${origin}/`, {
+      headers: { 'expo-platform': 'ios', Accept: 'application/json' },
+      signal: controller.signal,
+    })
+    if (res.ok) {
+      const manifest = (await res.json()) as {
+        extra?: { expoClient?: { _internal?: { projectRoot?: unknown } } }
+      }
+      servedManifest = true
+      const root = manifest?.extra?.expoClient?._internal?.projectRoot
+      if (typeof root === 'string' && root.length > 0) return root
+    }
+  } catch {
+  } finally {
+    clearTimeout(timer)
+  }
+
+  // a server that answered with a manifest has already told us everything it
+  // knows. if it did not name a project root there is none to learn, and asking
+  // the OS about the listening process would answer with whatever directory
+  // that process happens to sit in — which is the CLI's own cwd trap this
+  // function exists to avoid. only a server that served no manifest at all gets
+  // the process lookup.
+  if (servedManifest) return null
+
+  const port = Number(new URL(origin).port)
+  if (!Number.isFinite(port) || port <= 0) return null
+  const pid = await resolveListeningPid(port)
+  return pid === null ? null : resolveProcessCwd(pid)
+}
+
+export function encodeAppFontsWire(specs: DiscoveredAppFontSpec[]): string {
+  return specs
+    .map((spec) => `${encodeURIComponent(spec.url)}::${encodeURIComponent(spec.family)}`)
+    .join(',')
+}
+
+export function parseAppFontUrls(wire: string): string[] {
+  const urls: string[] = []
+  for (const entry of wire.split(',')) {
+    const trimmed = entry.trim()
+    if (!trimmed) continue
+    const sep = trimmed.indexOf('::')
+    const urlPart = sep === -1 ? trimmed : trimmed.slice(0, sep)
+    try {
+      urls.push(decodeURIComponent(urlPart))
+    } catch {
+      urls.push(urlPart)
+    }
+  }
+  return urls.filter(Boolean)
+}
+
+// content type for a config-plugin font url, by extension. config fonts only
+// ever ship as ttf/otf/woff(2); fall back to octet-stream for anything else
+// so R2 still serves bytes the engine can register.
+export function fontContentType(url: string): string {
+  const ext = (url.split('?')[0].split('.').pop() || '').toLowerCase()
+  if (ext === 'ttf') return 'font/ttf'
+  if (ext === 'otf') return 'font/otf'
+  if (ext === 'woff') return 'font/woff'
+  if (ext === 'woff2') return 'font/woff2'
+  return 'application/octet-stream'
+}
+
+export type FetchedAppFont = {
+  url: string
+  // sha256(url) — the share-store key both the build and preview upload paths
+  // use, and what /api/preview/share/fetch?url=<fontUrl> resolves against.
+  urlhash: string
+  contentType: string
+  bytes: Uint8Array
+}
+
+// fetch every config-plugin font declared on an engine `?appFonts=` wire.
+// these typefaces live in the native binary, never in the metro bundle's
+// __packager_asset graph, so neither asset capture nor recorded fetches see
+// them — both the preview (`rnx record upload`) and build (`rnx app-fonts
+// stage`) paths backfill by re-fetching the declared urls off the still-live
+// metro. one implementation so both pipelines store identical bytes + keys.
+export async function fetchAppFontFiles(
+  wire: string,
+  hooks?: {
+    onStaged?: (info: { url: string; byteLength: number }) => void
+    onError?: (url: string, err: unknown) => void
+  },
+): Promise<FetchedAppFont[]> {
+  const out: FetchedAppFont[] = []
+  const seen = new Set<string>()
+  for (const url of parseAppFontUrls(wire)) {
+    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: fontContentType(url), bytes })
+      hooks?.onStaged?.({ url, byteLength: bytes.byteLength })
+    } catch (err) {
+      hooks?.onError?.(url, err)
+    }
+  }
+  return out
+}

package/cli/app-project.ts

@@ -0,0 +1,59 @@
+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 RNX_APP_CONFIG_NAMES = [
+  'rnx.config.ts',
+  'rnx.config.js',
+  'rnx.config.mjs',
+  'rnx.config.cjs',
+] as const
+
+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 findRNXAppConfig(dir: string): string | null {
+  return firstNamedFile(dir, RNX_APP_CONFIG_NAMES)
+}
+
+export function resolveAppProject(projectRoot: string): ResolvedAppProject | null {
+  const appDir = path.resolve(projectRoot)
+  try {
+    if (!fs.statSync(appDir).isDirectory()) return null
+  } catch {
+    return null
+  }
+
+  const configPath = findRNXAppConfig(appDir)
+  if (
+    !configPath &&
+    !findExpoAppConfig(appDir) &&
+    !fs.existsSync(path.join(appDir, 'package.json'))
+  ) {
+    return null
+  }
+  return { appDir, configPath }
+}