peachsim 0.1.1625 → 0.1.1635

package/LICENSE

@@ -8,7 +8,7 @@ the Peach Software License Agreement: https://peachsim.com/legal/license
 In summary (the agreement governs): Seed is free for individuals and companies
 under 10 people and under $1M yearly revenue, including commercial desktop and
 local use. A company at or above either limit needs Team while it has under
-100 people and under $10M yearly revenue, or Enterprise at or above either of
+25 people and under $3M yearly revenue, or Enterprise at or above either of
 those limits. Members, agents, API keys and local simulators are unlimited.
 Company size is self-reported and enforced through the license terms only.
 Embedding or redistributing the software requires a separate written agreement

package/README.md

@@ -323,7 +323,16 @@ resolve` re-pins it, and the CLI release publishes any bundle the bucket lacks.
 On Mac, headless launches attach an installed compatible native host. With no
 host, they render in the browser without downloading or placing the app. The
 browser logo menu offers the app; `peach desktop install --native` remains the
-explicit CLI installer. Linux still acquires its standalone host under `~/.peach`.
+explicit CLI installer. Linux x64 headless opens acquire the native standalone
+host under `~/.peach` by default. To choose plain Chromium for an open, use
+`peach open <target> --driver playwright --headless --chromium`.
+Pin the native host for reproducible Linux runs with
+`PEACH_DESKTOP_VERSION=<build>.<attempt> peach open <target> --headless`.
+A cached pin is used directly, even if another build is active; a missing pin
+is downloaded exactly, and an unavailable or incompatible pin fails the open.
+`peach list --drivers` shows installed hosts and each running sim's renderer
+and native executable path. Renderer choices select a matching sim or launch
+one; they never change a running sim's renderer.
 
 Headed launches on Linux use full Chromium, whose extra libraries the bundle
 also carries. Later opens reuse that sim and

package/cli/app-config.ts

@@ -1,3 +1,4 @@
+import { readFileSync } from 'node:fs'
 import path from 'node:path'
 import { createJiti } from 'jiti'
 import * as peachConfigModule from '../src/config'
@@ -80,7 +81,9 @@ async function loadConfigFile(
         [`${rnxPublicBrand.packageName}/config`]: peachConfigModule,
       },
     })
-    const loaded: unknown = await jiti.import(project.configPath, { default: true })
+    const loaded: unknown = project.configPath.endsWith('.json')
+      ? JSON.parse(readFileSync(project.configPath, 'utf8'))
+      : await jiti.import(project.configPath, { default: true })
     if (!isPeachConfig(loaded)) {
       throw new Error('the default export must be a peach config object')
     }

package/cli/app-fonts.ts

@@ -7,7 +7,6 @@ import {
   resolveAppFontsWire,
   expoFontPathsFromPlugins,
   nativeLinkedFontSpecsFromPaths,
-  metroFontSpecsFromPaths,
   appFontAssetUrlsFromWire,
   type ConfigPluginFontSpec,
   type FontPlatform,
@@ -15,8 +14,10 @@ import {
 import { resolveListeningPid, resolveProcessCwd } from '../scripts/dev-server-scanner'
 import { loopbackOriginOf } from '../src/backend-origin'
 import { MANIFEST_PROBE_TIMEOUT_MS } from '../src/dev-bundle-resolution'
+import { parseExpoManifestBody } from '../src/expo-manifest-body'
 import { stageHostFile } from '../src/host/staged-host-files'
 import { parsePlistSource } from '../src/plist.ts'
+import { listXcodeAppTargets, readXcodeAppTarget } from '../src/xcode-project'
 import { resolveAppProject } from './app-project'
 import {
   materialSymbolFontPaths,
@@ -31,24 +32,22 @@ export type DiscoveredAppFontSpec = ConfigPluginFontSpec
 
 type ExpoConfigGetter = (dir: string, opts: Record<string, unknown>) => { exp?: unknown }
 
-// every font file is found on disk, so the asset urls are decided here and
-// never by asking the dev server: metro's asset endpoint resolves a path
-// against its config.projectRoot, which is the root it advertises and the one
-// projectDir names. a reachability request would make the result depend on how
-// busy the dev server is, and a cold build answers late enough to drop fonts.
+// every font file is found on disk, so its bytes are staged as host files and
+// never fetched from the dev server: only metro serves project files at
+// `/assets/<path>`, and a reachability request would make the result depend on
+// how busy the dev server is, so a cold build could answer late and drop fonts.
 export function discoverNativeLinkedAppFonts(opts: {
-  bundleUrl: string
   projectDir: string
   platform?: string
   nativeAssetOrigin: string
 }): DiscoveredAppFontSpec[] {
-  const metroOrigin = loopbackOriginOf(opts.bundleUrl)
-  if (!metroOrigin) return []
   const { paths, materialSymbols } = discoverNativeLinkedAppFontAssets(opts)
-  const specs = metroFontSpecsFromPaths(
+  const realProjectRoot = fs.realpathSync(opts.projectDir)
+  const specs = nativeLinkedFontSpecsFromPaths(
     projectRelativeFontPaths(opts.projectDir, paths),
-    metroOrigin,
     nativeFontPlatform(opts.platform),
+    (fontPath) =>
+      stageHostFile(path.resolve(realProjectRoot, fontPath), opts.nativeAssetOrigin),
   )
   attachMaterialSymbolMetadata(specs, materialSymbols, (asset) =>
     stageHostFile(asset, opts.nativeAssetOrigin),
@@ -286,6 +285,23 @@ function discoverNativeLinkedAppFontAssets(opts: {
             !entry.name.startsWith('.'),
         )
         .slice(0, 64)
+      // a bare filename in UIAppFonts names a file the target copies into
+      // its bundle, wherever the project keeps it: resolve it by the target's
+      // resource build phase before trying paths beside the plist.
+      const bundledByName = new Map<string, string>()
+      for (const entry of fs.readdirSync(iosDir, { withFileTypes: true })) {
+        if (!entry.isDirectory() || !entry.name.endsWith('.xcodeproj')) continue
+        const xcodeproj = path.join(iosDir, entry.name)
+        for (const target of listXcodeAppTargets(xcodeproj, { requireSources: false })) {
+          const members = readXcodeAppTarget(xcodeproj, target, undefined, {
+            requireSources: false,
+          })
+          for (const file of members.resources) {
+            if (!bundledByName.has(path.basename(file)))
+              bundledByName.set(path.basename(file), file)
+          }
+        }
+      }
       const plistPaths = [path.join(iosDir, 'Info.plist')]
       for (const entry of targetDirs) {
         plistPaths.push(path.join(iosDir, entry.name, 'Info.plist'))
@@ -302,15 +318,19 @@ function discoverNativeLinkedAppFontAssets(opts: {
         if (!Array.isArray(declaredFonts)) continue
         for (const declaredFont of declaredFonts) {
           if (typeof declaredFont !== 'string') continue
+          // a file the target copies into its bundle is linked wherever it
+          // lives, including a workspace package's folder outside the app.
+          const bundled = bundledByName.get(declaredFont)
           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
-            return isFile(candidate)
-          })
+          const fontPath =
+            candidates.find((candidate) => {
+              const relative = path.relative(selectedAppDir, candidate)
+              if (relative.startsWith('..') || path.isAbsolute(relative)) return false
+              return isFile(candidate)
+            }) ?? (bundled && isFile(bundled) ? bundled : undefined)
           if (fontPath) fontPaths.push(fontPath)
         }
       }
@@ -383,7 +403,7 @@ export async function resolveMetroProjectRoot(bundleUrl: string): Promise<string
       signal: controller.signal,
     })
     if (res.ok) {
-      const manifest = (await res.json()) as {
+      const manifest = parseExpoManifestBody(await res.text()) as {
         extra?: { expoClient?: { _internal?: { projectRoot?: unknown } } }
       }
       servedManifest = true

package/cli/app-stubs.ts

@@ -3,7 +3,14 @@
 // packages, and a library's own `peach` field, lowered into the engine's
 // nativeModules / nativeViews wire slots.
 
-import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from 'node:fs'
+import {
+  existsSync,
+  lstatSync,
+  readdirSync,
+  readFileSync,
+  realpathSync,
+  statSync,
+} from 'node:fs'
 import { dirname, join, relative, resolve } from 'node:path'
 import { resolveCompatVersionRange } from '@peach/compat/version-range'
 import { parseSync, type Expression } from 'oxc-parser'
@@ -19,7 +26,14 @@ import {
 } from '../src/config'
 import { isRecord } from '../src/is-record'
 import { visitParsedProgram } from '../src/visit-parsed-program'
-import { readProjectManifest, scanRepository } from './commands/detect'
+import {
+  readProjectManifest,
+  scanRepository,
+  metadataValue,
+  readProjectJson,
+} from './commands/detect'
+import type { ProjectManifest } from './commands/projectReportContract'
+import type { ScanResult } from '@peach/compat/web'
 
 // who answers a package, in rising precedence
 export type StubOrigin = 'library' | 'stub-package' | 'config'
@@ -125,7 +139,25 @@ export function resolveAppStubs(
       baseDir: dir,
     })
   }
-  for (const [target, stubs] of Object.entries(config?.packages ?? {})) {
+  const configuredPackages = Object.entries(config?.packages ?? {})
+  const packageNames = new Set<string>()
+  if (typeof manifest?.name === 'string') packageNames.add(manifest.name)
+  for (const [target] of configuredPackages) {
+    const dir = installedPackageDir(appDir, target)
+    if (dir && readPackageJson(dir)?.name === target) packageNames.add(target)
+  }
+  if (manifest && configuredPackages.some(([target]) => !packageNames.has(target))) {
+    for (const root of [appDir, ...workspacePackageDirs(appDir, manifest)])
+      for (const dir of scanRepository(root).directories) {
+        const name = readPackageJson(dir)?.name
+        if (typeof name === 'string') packageNames.add(name)
+      }
+  }
+  for (const [target, stubs] of configuredPackages) {
+    if (manifest && !packageNames.has(target))
+      throw new Error(
+        `packages[${JSON.stringify(target)}]: no installed or local package has this name; use the name from the package's package.json`,
+      )
     sources.push({
       target,
       origin: 'config',
@@ -368,12 +400,17 @@ export function wireSlotMigration(
       if (!owners.has(`${request.kind}:${request.name}`))
         owners.set(`${request.kind}:${request.name}`, name)
   }
-  // the app's own native code answers under its package name
-  if (typeof manifest?.name === 'string')
-    for (const request of packageNativeRequests(appDir))
+  if (manifest)
+    for (const request of scanLocalNative(
+      appDir,
+      manifest,
+      { module: new Set(), view: new Set() },
+      undefined,
+      new Set(),
+      true,
+    ))
       if (!owners.has(`${request.kind}:${request.name}`))
-        owners.set(`${request.kind}:${request.name}`, manifest.name)
-  const unknownOwner = '<package that asks for it>'
+        owners.set(`${request.kind}:${request.name}`, request.package)
   const blocks = new Map<string, { modules: string[]; views: string[] }>()
   const manual: string[] = []
   for (const [kind, entries] of [
@@ -395,7 +432,13 @@ export function wireSlotMigration(
         )
         continue
       }
-      const owner = owners.get(`${kind}:${name}`) ?? unknownOwner
+      const owner = owners.get(`${kind}:${name}`)
+      if (!owner) {
+        manual.push(
+          `${name}: no requesting package was found; find the package that requests this ${kind} before adding its packages entry`,
+        )
+        continue
+      }
       const block = blocks.get(owner) ?? { modules: [], views: [] }
       block[kind === 'module' ? 'modules' : 'views'].push(
         `[${JSON.stringify(name)}]: ${stub}`,
@@ -431,3 +474,175 @@ export function readSmallFile(file: string): string | null {
     return null
   }
 }
+
+export function hasNativeCode(
+  dir: string,
+  platform: ScanResult['scoreSummary']['platform'],
+): boolean {
+  const expoConfig = join(dir, 'expo-module.config.json')
+  const platforms = metadataValue(readProjectJson(expoConfig), 'platforms')
+  if (Array.isArray(platforms))
+    return (
+      platforms.includes(platform) || (platform === 'ios' && platforms.includes('apple'))
+    )
+  if ([platform, 'expo-module.config.json'].some((entry) => existsSync(join(dir, entry))))
+    return true
+  if (listDir(dir).some((name) => name.endsWith('.podspec'))) return true
+  const manifest = readSmallFile(join(dir, 'package.json'))
+  return manifest !== null && manifest.includes('"codegenConfig"')
+}
+
+// an app's own native code, found from the names its JavaScript asks the native
+// side for and from local Expo modules (a directory with expo-module.config.json).
+// each name is a key under its package in peach.config.ts `packages`.
+export interface LocalNative {
+  kind: 'module' | 'view'
+  name: string
+  // the package the name belongs to: the nearest package.json with a name
+  package: string
+  // first place the name appears, relative to the app, as file:line
+  path: string
+  // the local Expo module directory the name belongs to, relative to the app
+  expoModule: string | null
+  swift: boolean
+  // a stub already answers it
+  answered: boolean
+}
+
+const NATIVE_SOURCE_FILE = /\.(?:swift|kt)$/
+export type AnsweredNames = Record<LocalNative['kind'], Set<string>>
+
+export function scanLocalNative(
+  appDir: string,
+  pkg: ProjectManifest,
+  answered: AnsweredNames,
+  platform: ScanResult['scoreSummary']['platform'] | undefined,
+  knownPackages: ReadonlySet<string> = new Set(),
+  includeLegacy = false,
+): LocalNative[] {
+  const expoModuleDirs: string[] = []
+  const excludedModuleDirs: string[] = []
+  const sourceFiles: string[] = []
+  for (const root of [appDir, ...workspacePackageDirs(appDir, pkg)]) {
+    for (const dir of scanRepository(root).directories) {
+      if (
+        excludedModuleDirs.some(
+          (excluded) => dir === excluded || dir.startsWith(`${excluded}/`),
+        )
+      )
+        continue
+      if (existsSync(join(dir, 'expo-module.config.json'))) {
+        if (platform && !hasNativeCode(dir, platform)) {
+          excludedModuleDirs.push(dir)
+          continue
+        }
+        expoModuleDirs.push(dir)
+      }
+      for (const name of listDir(dir)) {
+        if (SOURCE_FILE.test(name) && !name.endsWith('.d.ts'))
+          sourceFiles.push(join(dir, name))
+      }
+    }
+  }
+  const nativeFilesByModule = new Map(
+    expoModuleDirs.map((dir) => [
+      dir,
+      scanRepository(dir).directories.flatMap((sub) =>
+        listDir(sub)
+          .filter((name) => NATIVE_SOURCE_FILE.test(name))
+          .map((name) => join(sub, name)),
+      ),
+    ]),
+  )
+
+  const owners = new Map<string, string>()
+  const owner = (dir: string): string => {
+    const known = owners.get(dir)
+    if (known) return known
+    const name = readPackageJson(dir)?.name
+    const parent = dirname(dir)
+    const result =
+      typeof name === 'string'
+        ? name
+        : parent === dir
+          ? (pkg.name ?? 'app')
+          : owner(parent)
+    owners.set(dir, result)
+    return result
+  }
+  const found = new Map<string, LocalNative>()
+  const add = (kind: LocalNative['kind'], name: string, file: string, line: number) => {
+    const packageName = owner(dirname(file))
+    if (knownPackages.has(packageName)) return
+    const key = `${kind}:${name}`
+    if (found.has(key)) return
+    const moduleDir = expoModuleDirs.find((dir) => file.startsWith(`${dir}/`)) ?? null
+    found.set(key, {
+      kind,
+      name,
+      package: packageName,
+      path: `${relative(appDir, file)}:${line}`,
+      expoModule: moduleDir ? relative(appDir, moduleDir) || '.' : null,
+      swift: moduleDir
+        ? (nativeFilesByModule.get(moduleDir) ?? []).some((path) =>
+            path.endsWith('.swift'),
+          )
+        : false,
+      answered: answered[kind].has(name),
+    })
+  }
+  for (const file of sourceFiles) {
+    const text = readSmallFile(file)
+    if (!text) continue
+    for (const { kind, name, line } of sourceNativeRequests(file, text, includeLegacy))
+      add(kind, name, file, line)
+  }
+  // a local expo module declares its name in its native definition, Name("X"),
+  // whether or not the app's javascript spells it out. swift first, so a
+  // module the report marks Swift points at its swift definition.
+  for (const [, files] of nativeFilesByModule) {
+    const swiftFirst = [...files].sort(
+      (a, b) => Number(b.endsWith('.swift')) - Number(a.endsWith('.swift')),
+    )
+    for (const file of swiftFirst) {
+      const text = readSmallFile(file)
+      if (!text) continue
+      for (const match of text.matchAll(/\bName\(\s*"(\w+)"\s*\)/g)) {
+        if (match[1])
+          add('module', match[1], file, text.slice(0, match.index).split('\n').length)
+      }
+    }
+  }
+  return [...found.values()].sort(
+    (a, b) => a.kind.localeCompare(b.kind) || a.name.localeCompare(b.name),
+  )
+}
+
+// dependencies installed as links to source outside any node_modules are the
+// app's own workspace packages, which hold its native code as often as the app
+// directory does.
+function workspacePackageDirs(appDir: string, pkg: ProjectManifest): string[] {
+  const dirs = new Set<string>()
+  for (const name of Object.keys({ ...pkg.dependencies, ...pkg.devDependencies })) {
+    let current = appDir
+    while (true) {
+      const link = join(current, 'node_modules', name)
+      if (existsSync(link)) {
+        if (lstatSync(link).isSymbolicLink()) {
+          const target = realpathSync(link)
+          if (
+            !target.split('/').includes('node_modules') &&
+            !target.startsWith(`${appDir}/`)
+          ) {
+            dirs.add(target)
+          }
+        }
+        break
+      }
+      const parent = dirname(current)
+      if (parent === current) break
+      current = parent
+    }
+  }
+  return [...dirs]
+}

package/cli/bridge-flow-runner.ts

@@ -2175,48 +2175,58 @@ export class SootSimBridgeFlowRunner {
     await sleep(120)
   }
 
+  // maestro's android driver sends Back. its ios driver never presses a key:
+  // while the keyboard shows it swipes from the screen center up 3%, then
+  // left 3%, and the app's own handling of those touches dismisses it, or
+  // presses whatever sits under the center
   async hideKeyboard() {
-    // CLI flows need "dismiss keyboard" to mean "get the focused TextInput
-    // out of the way before the next tap", not just "ask shell chrome to
-    // animate down eventually". If the TextInput stays focused, the next tap
-    // can still be swallowed by keyboard-dismiss policy on ScrollViews.
-    try {
-      await this.callTest<boolean>('blurFocusedTextInput')
-    } catch {
-      // fall through to the shell-level dismiss below; older bridges may not
-      // expose the text-input helper yet.
+    if (this.js.maestro.platform.toLowerCase() === 'android') {
+      await this.back()
+      await sleep(300)
+      await this.waitForAppToSettle()
+      return
     }
+    if (!(await this.isKeyboardVisible())) return
+    const screen = await this.screenBounds()
+    const center = parsePoint('50%,50%', screen)
+    await this.xctestSwipe(center, parsePoint('50%,47%', screen), 50)
+    if (!(await this.isKeyboardVisible())) return
+    await this.xctestSwipe(center, parsePoint('47%,50%', screen), 50)
+    await this.waitForAppToSettle()
+  }
 
-    await this.bridge.send({
-      type: 'keyboard',
-      simId: this.opts.simId,
-      action: 'dismiss',
-    })
+  // the xctest runner's swipe: press, move to the end over its 100ms tap
+  // duration, rest there for the requested duration, then lift, so the
+  // finger leaves at rest rather than flinging
+  private async xctestSwipe(
+    from: { x: number; y: number },
+    to: { x: number; y: number },
+    durationMs: number,
+  ) {
+    const moves = 6
+    const steps: PerformStep[] = [{ type: 'touchDown', x: from.x, y: from.y }]
+    for (let i = 1; i <= moves; i++) {
+      steps.push({ type: 'wait', ms: 100 / moves })
+      steps.push({
+        type: 'touchMove',
+        x: from.x + ((to.x - from.x) * i) / moves,
+        y: from.y + ((to.y - from.y) * i) / moves,
+      })
+    }
+    steps.push({ type: 'wait', ms: durationMs })
+    steps.push({ type: 'touchUp', x: to.x, y: to.y })
+    const result = await this.perform(steps)
+    if (!result?.ok) throw new Error(`swipe failed: ${result?.error ?? 'swipe missed'}`)
+    await this.waitForAppToSettle()
+  }
 
-    const deadline = Date.now() + 3000
-    do {
-      // the host test bridge proxies the tenant, so isTextInputFocused
-      // resolves a promise; reading it unawaited is always truthy.
-      const state = await this.evaluate<{
-        visible: boolean
-        focused: boolean
-      }>(`(async () => {
-        const keyboard =
-          window.__sootsimKeyboard ??
-          window.SootSim?.bridges?.keyboard ??
-          null
-        const test = window.__sootsimTest
-        return {
-          visible: !!keyboard?.isVisible?.(),
-          focused: !!(await test?.isTextInputFocused?.()),
-        }
-      })()`)
-      if (!state?.visible && !state?.focused) {
-        await sleep(80)
-        return
-      }
-      await sleep(80)
-    } while (Date.now() < deadline)
+  private async isKeyboardVisible(): Promise<boolean> {
+    const visible = await this.evaluate<boolean>(`(() => {
+      const keyboard =
+        window.__sootsimKeyboard ?? window.SootSim?.bridges?.keyboard ?? null
+      return !!keyboard?.isVisible?.()
+    })()`)
+    return visible === true
   }
 
   async eraseText(count: number) {
@@ -2765,8 +2775,15 @@ export class SootSimBridgeFlowRunner {
               : { x: centerX, y: screen.height * 0.1 }
       const element = await this.findElement(target)
       if (element) {
-        const { x, y } = element.absolutePosition
-        const { width, height } = element.layout
+        // maestro computes visibility from integer edges, as it does selection.
+        const { x, y, width, height } = accessibilityBounds({
+          frame: {
+            x: element.absolutePosition.x,
+            y: element.absolutePosition.y,
+            width: element.layout.width,
+            height: element.layout.height,
+          },
+        })
         const shownX = Math.max(0, Math.min(x + width, screen.width) - Math.max(x, 0))
         const shownY = Math.max(0, Math.min(y + height, screen.height) - Math.max(y, 0))
         const share = width * height > 0 ? (shownX * shownY) / (width * height) : 0
@@ -2892,6 +2909,12 @@ export class SootSimBridgeFlowRunner {
     const wantsClear = !!(opts && typeof opts === 'object' && opts.clearState)
     const wantsResetRuntime = readBooleanKey(opts, 'resetRuntime')
     const wantsForeground = isObjectRecord(opts) && opts.stopApp === false
+    // maestro's launchApp clears the keychain, then app state, then sets
+    // permissions and launches
+    if (readBooleanKey(opts, 'clearKeychain')) {
+      if (!this.firstLaunchDone && !this.appStopped) await this.waitForTree(120000)
+      await this.clearKeychain()
+    }
     await this.setLaunchPermissions(isObjectRecord(opts) ? opts.permissions : undefined)
 
     if (!this.firstLaunchDone) {
@@ -2982,9 +3005,7 @@ export class SootSimBridgeFlowRunner {
 
   private async setLaunchPermissions(permissions: unknown) {
     const statuses = maestroLaunchPermissions(permissions)
-    const state = await getShellState(this.bridge)
-    const appId = readStringKey(state, 'activeApp') || readRecentShellAppId(state)
-    if (!appId) throw new Error('launchApp: no simulator app to set permissions for')
+    const appId = await this.callTest<string>('permissionGuestAppId')
     for (const [kind, status] of statuses) {
       await this.callTest('permissionSetAppPermission', appId, kind, {
         status,

package/cli/command-registry.ts

@@ -128,6 +128,7 @@ const VALUE_FLAGS = new Set([
   '--timeout',
   '--device',
   '--posture',
+  '--render-resolution',
   '--os-version',
   '--ios-target',
   '--output',