peachsim 0.1.627 → 0.1.629

package/cli/commands/setup.ts

@@ -54,6 +54,7 @@ interface SetupOptions {
 
 interface SetupRunOptions {
   launchConnectRN?: boolean
+  port?: number
 }
 
 export interface SetupResult {
@@ -120,6 +121,7 @@ export async function runSetup(
           channel: 'stable',
           setActive: true,
           protectVersions: activeRuntime ? [activeRuntime] : [],
+          quiet: !options.json,
         })
       const result = options.json
         ? await install()
@@ -130,10 +132,16 @@ export async function runSetup(
     let serviceInstalled = serviceStatus.installed
     if (service && !serviceStatus.installed && !options.dryRun) {
       if (options.json) {
-        await daemonInstall({ port: DEFAULT_SOOTSIM_BRIDGE_PORT, force: false })
+        await daemonInstall({
+          port: runOptions.port ?? DEFAULT_SOOTSIM_BRIDGE_PORT,
+          force: false,
+        })
       } else {
         console.log(`\n  ${accent('◆')} ${bold('Enabling the background service')}`)
-        await daemonInstall({ port: DEFAULT_SOOTSIM_BRIDGE_PORT, force: false })
+        await daemonInstall({
+          port: runOptions.port ?? DEFAULT_SOOTSIM_BRIDGE_PORT,
+          force: false,
+        })
       }
       serviceInstalled = true
     }
@@ -144,13 +152,10 @@ export async function runSetup(
 
     if (launchConnectRN) {
       console.log(`\n  ${accent('◆')} Opening ConnectRN`)
-      await runOpenCommand([
-        'ConnectRN',
-        '--driver',
-        simulatorDriver,
-        '--no-describe',
-        '--quiet',
-      ])
+      await runOpenCommand(
+        ['ConnectRN', '--driver', simulatorDriver, '--no-describe', '--quiet'],
+        { port: runOptions.port },
+      )
     }
 
     const productAnalytics = await decidePrivacy(options, privacy)
@@ -324,7 +329,7 @@ async function decideSimulatorDriver(
     desktopDescription,
     'The Desktop app opens in a dedicated native window.',
   ])
-  const choice = await select('Where should peach open??', [
+  const choice = await select('Where should peach open?', [
     'Browser (recommended)  No additional download',
     desktopChoice,
   ])
@@ -343,7 +348,7 @@ async function decidePrivacy(
     'Reports can contain package compatibility or an error class.',
     'They never contain your code or app data.',
   ])
-  return confirm('Share bounded diagnostics to improve peach??', false)
+  return confirm('Share bounded diagnostics to improve peach?', false)
 }
 
 async function decideRepository(

package/cli/commands/show-touches-mode.ts

@@ -0,0 +1,33 @@
+// peach mode show-touches — toggle OS touch indicators (Show Single Touches / Show taps)
+// in the running peach sim.
+
+import { rnxExit } from '../run-rnx'
+import { runShellBooleanMode, type ShellBooleanModeOptions } from './shell-boolean-mode'
+
+export async function runShowTouchesMode(args: string[], opts: ShellBooleanModeOptions) {
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(`
+peach mode show-touches — toggle touch indicator overlays
+
+usage:
+  peach mode show-touches [on|off|toggle]
+
+arguments:
+  on        enable touch indicators
+  off       disable touch indicators
+  toggle    flip the current state (default)
+
+examples:
+  peach mode show-touches
+  peach mode show-touches on
+  peach mode show-touches off
+`)
+    rnxExit(0)
+  }
+
+  await runShellBooleanMode(args, opts, {
+    modeKey: 'showTouches',
+    displayName: 'show-touches',
+    actionId: 'toggle-touches',
+  })
+}

package/cli/commands/skills.ts

@@ -9,10 +9,26 @@ import * as fs from 'fs'
 import * as os from 'os'
 import * as path from 'path'
 import { fileURLToPath } from 'url'
+import { getCliVersion } from '../../src/cli-version'
+import { rnxHomeDir } from '../../src/home-paths'
 import { rnxPublicBrand } from '../../src/public-brand'
 import { rnxExit } from '../run-rnx'
 
+declare const __PEACH_BUNDLED_SKILLS__: Record<string, string>
+
 function getSkillsDir(): string {
+  // the standalone binary carries its skills instead of a package directory;
+  // write them once per cli version so installs can link to real files.
+  if (typeof __PEACH_BUNDLED_SKILLS__ !== 'undefined') {
+    const dir = path.join(rnxHomeDir(), 'skills', getCliVersion())
+    for (const [file, body] of Object.entries(__PEACH_BUNDLED_SKILLS__)) {
+      const target = path.join(dir, file)
+      if (fs.existsSync(target)) continue
+      fs.mkdirSync(path.dirname(target), { recursive: true })
+      fs.writeFileSync(target, body)
+    }
+    return dir
+  }
   try {
     const pkgPath = fileURLToPath(
       import.meta.resolve(`${rnxPublicBrand.packageName}/package.json`),

package/cli/commands/test.ts

@@ -984,7 +984,14 @@ export async function runTest(
     return runCloudTest(args, opts)
   }
 
-  const selected = resolveTestCommand(args)
+  // a missing or unknown target is the caller's mistake: one line, no stack.
+  let selected: ReturnType<typeof resolveTestCommand>
+  try {
+    selected = resolveTestCommand(args)
+  } catch (error) {
+    console.error(`  error: ${error instanceof Error ? error.message : String(error)}`)
+    return 1
+  }
   const app = appFromArgs(args)
   const appTarget = app
     ? await resolveTestAppTarget(app)

package/cli/commands/welcome.ts

@@ -4,14 +4,14 @@ import { printBrand } from '../ui'
 import { runOpenCommand } from './control'
 import { runSetup } from './setup'
 
-export async function runWelcome(): Promise<number> {
+export async function runWelcome(port: number | undefined): Promise<number> {
   if (!isOnboardingComplete() && canPromptForPrivacyChoice()) {
-    await runSetup([], { launchConnectRN: true })
+    await runSetup([], { launchConnectRN: true, port })
     return 0
   }
 
   printBrand('Run any React Native app in a local simulator.')
   console.log(`\n  Opening ConnectRN`)
-  await runOpenCommand(['ConnectRN', '--no-describe', '--quiet'])
+  await runOpenCommand(['ConnectRN', '--no-describe', '--quiet'], { port })
   return 0
 }

package/cli/drivers/playwright-sim-host.ts

@@ -446,16 +446,17 @@ const cleanupProfile = () => {
     const request = readBrowserCompositeCaptureRequest(value);
     const session = await source.page.context().newCDPSession(source.page);
     try {
+      const { clip, originX, originY } = resolveBrowserCompositeCdpClip(
+        request,
+        await session.send('Page.getLayoutMetrics'),
+      );
       const result = await session.send('Page.captureScreenshot', {
         format: 'png',
         fromSurface: true,
         captureBeyondViewport: true,
-        clip: resolveBrowserCompositeCdpClip(
-          request,
-          await session.send('Page.getLayoutMetrics'),
-        ),
+        clip,
       });
-      return 'data:image/png;base64,' + result.data;
+      return { dataUrl: 'data:image/png;base64,' + result.data, originX, originY };
     } finally {
       await session.detach();
     }

package/cli/help-core.ts

@@ -96,8 +96,13 @@ Run \`peach <command> --help\` for leaf availability and usage.`
 export function renderRnxHelp(options: RnxHelpOptions): string {
   const command = options.command ?? null
   const commandArgs = options.commandArgs ?? []
+  // the preview selectors and backend lists describe the factory's browser
+  // backend; the public cli runs the node backend and never sees them.
+  const factory = options.backend === 'browser'
   if (!command) {
-    return `${renderCliIndexHelp(HELP_CONTEXT, formatFlagHelp()).trimEnd()}
+    const index = renderCliIndexHelp(HELP_CONTEXT, formatFlagHelp()).trimEnd()
+    if (!factory) return index
+    return `${index}
 
 browser preview selectors:
   peach web                     select the existing Factory web preview
@@ -108,7 +113,7 @@ ${renderRootAvailability(options.backend)}`
   }
 
   let body: string | null
-  if (command === 'web' || command === 'ios' || command === 'android') {
+  if (factory && (command === 'web' || command === 'ios' || command === 'android')) {
     body = renderPreviewHelp(command)
   } else if (options.group === command && !options.prefer) {
     body = renderCliGroupHelp(command, HELP_CONTEXT, formatFlagHelp())
@@ -130,11 +135,11 @@ ${renderRootAvailability(options.backend)}`
   const registration = getRnxCommandRegistration(command)
   if (!registration) return body
   const current = getRnxCommandAvailability(command, commandArgs, options.backend)
+  if (!factory && current.available) return body
   const currentLine = current.available
     ? `${options.backend} backend: available`
     : `${options.backend} backend: ${current.reason}`
-  const factoryLeaves =
-    options.backend === 'browser' ? renderFactoryBrowserLeaves(command) : null
+  const factoryLeaves = factory ? renderFactoryBrowserLeaves(command) : null
   return `${body.trimEnd()}
 
 ${factoryLeaves ? `${factoryLeaves}\n\n` : ''}${backendLabel(command, commandArgs)}

package/cli/internal-child.ts

@@ -18,6 +18,12 @@ import * as vm from 'node:vm'
 
 export const RNX_INTERNAL_COMMAND = '__internal'
 
+// playwright's installer forks its downloader script with process.execPath,
+// which here is this binary. the installer child sets this for its whole
+// process tree, and bin.ts then runs a forked `.js` argument as a script
+// instead of reading it as a peach command.
+export const RNX_FORKED_SCRIPT_ENV = 'PEACH_RUNS_FORKED_SCRIPTS'
+
 export const RNX_INTERNAL_CHILDREN = {
   playwrightProbe: 'playwright-probe',
   playwrightInstall: 'playwright-install',
@@ -113,8 +119,14 @@ function playwrightInstall(args: string[]): void {
   if (!cliPath) {
     throw new Error('internal playwright-install needs the package CLI path')
   }
-  process.argv = [process.argv[0], cliPath, ...cliArgs]
-  requireFromCwd()(cliPath)
+  process.env[RNX_FORKED_SCRIPT_ENV] = '1'
+  runScript(cliPath, cliArgs)
+}
+
+/** run a javascript file as node would, with argv shaped for its own parser. */
+export function runScript(scriptPath: string, args: string[]): void {
+  process.argv = [process.argv[0], scriptPath, ...args]
+  createRequire(scriptPath)(scriptPath)
 }
 
 /** the detached browser host. its source is CJS that resolves playwright from

package/cli/levenshtein.ts

@@ -0,0 +1,27 @@
+export function levenshtein(a: string, b: string): number {
+  if (a === b) return 0
+  if (!a.length) return b.length
+  if (!b.length) return a.length
+  // standard two-row dp: prev[] is the previous row, cur[] is the row being
+  // computed; swap pointers per outer iteration. the earlier in-place rolling
+  // version overwrote prev[j-1] twice per cell and never set prev[0]=i, so
+  // distance(`kitten`,`sitting`) returned 8 instead of 3 and the fuzzy-suggest
+  // ranking was effectively random.
+  let prev = new Array<number>(b.length + 1)
+  let cur = new Array<number>(b.length + 1)
+  for (let j = 0; j <= b.length; j++) prev[j] = j
+  for (let i = 1; i <= a.length; i++) {
+    cur[0] = i
+    for (let j = 1; j <= b.length; j++) {
+      cur[j] = Math.min(
+        prev[j] + 1,
+        cur[j - 1] + 1,
+        prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1),
+      )
+    }
+    const tmp = prev
+    prev = cur
+    cur = tmp
+  }
+  return prev[b.length]
+}

package/cli/main.ts

@@ -3,7 +3,8 @@
 // when none of its hidden entry points claimed the process.
 
 import { rnxPublicBrand } from '../src/public-brand'
-import { parseArgs, TOP_LEVEL_RUNTIME_COMMANDS } from './parse-args'
+import { levenshtein } from './levenshtein'
+import { COMMANDS, parseArgs, TOP_LEVEL_RUNTIME_COMMANDS } from './parse-args'
 import { RnxExit } from './run-rnx'
 import { rnxSelfInvocation } from './self-invocation'
 import { IS_STANDALONE } from './standalone'
@@ -37,18 +38,29 @@ function handleTopLevelError(err: unknown): never {
     msg.startsWith('peach bridge exited before becoming ready') ||
     msg.startsWith(`${rnxPublicBrand.commandName} open: requested bridge port`) ||
     msg.startsWith('background daemon setup is unavailable') ||
-    msg.startsWith('peach bridge did not start within')
+    msg.startsWith('peach bridge did not start within') ||
+    msg.startsWith('could not resolve a native bundle for ')
   if (isKnownCliFailure && !process.env.SOOTSIM_VERBOSE) {
     process.stderr.write(`  ${msg}\n`)
     process.exit(1)
   }
-  if (err instanceof Error && err.stack) {
-    process.stderr.write(`${err.stack}\n`)
-  } else {
-    process.stderr.write(`${msg}\n`)
-  }
+  // bun can render an async-thrown error's stack with a bare `Error` header, so
+  // the message always goes first.
+  process.stderr.write(`  ${msg}\n`)
+  if (err instanceof Error && err.stack) process.stderr.write(`${err.stack}\n`)
   process.exit(1)
 }
+function printUnknownCommand(attempted: string) {
+  const closest = [...COMMANDS]
+    .map((name) => ({ name, distance: levenshtein(attempted, name) }))
+    .sort((a, b) => a.distance - b.distance)[0]
+  console.error(`  unknown command: ${attempted}`)
+  if (closest && closest.distance <= 2) {
+    console.error(`  did you mean \`${rnxPublicBrand.commandName} ${closest.name}\`?`)
+  }
+  console.error(`  run \`${rnxPublicBrand.commandName} --help\` to see the full surface.`)
+}
+
 process.on('unhandledRejection', handleTopLevelError)
 process.on('uncaughtException', handleTopLevelError)
 
@@ -73,7 +85,11 @@ const isCliUpdateWorker =
   parsed.commandArgs[0] === '--check-worker'
 const isBareWelcome = !parsed.command && parsed.commandArgs.length === 0
 const isReadOnlyInvocation =
-  parsed.version || parsed.help || parsed.commandArgs.includes('--dry-run')
+  parsed.version ||
+  parsed.help ||
+  parsed.commandArgs.includes('--help') ||
+  parsed.commandArgs.includes('-h') ||
+  parsed.commandArgs.includes('--dry-run')
 
 if (isCliUpdateWorker) {
   if (IS_STANDALONE) {
@@ -264,7 +280,7 @@ if (device || theme) {
 // returning runs open ConnectRN directly; app discovery belongs inside it.
 if (!parsed.command && parsed.commandArgs.length === 0) {
   const { runWelcome } = await import('./commands/welcome')
-  await exitWithFlush(await runWelcome())
+  await exitWithFlush(await runWelcome(port))
 }
 
 // route to command. an empty command at this point only happens if the
@@ -280,10 +296,7 @@ if (!command) {
   if (parsed.commandArgs.length > 0) {
     const attempted =
       parsed.commandArgs.find((a) => !a.startsWith('-')) ?? parsed.commandArgs[0]
-    console.error(`  unknown command: ${attempted}`)
-    console.error(
-      `  run \`${rnxPublicBrand.commandName} --help\` to see the full surface.`,
-    )
+    printUnknownCommand(attempted)
     await exitWithFlush(1)
   }
   const { printHelp } = await import('./help')
@@ -608,7 +621,7 @@ try {
 
       case 'setup': {
         const { runSetup } = await import('./commands/setup')
-        await runSetup(parsed.commandArgs)
+        await runSetup(parsed.commandArgs, { port })
         break
       }
 
@@ -685,10 +698,7 @@ try {
       }
 
       default: {
-        console.error(`  unknown command: ${command}`)
-        console.error(
-          `  run \`${rnxPublicBrand.commandName} --help\` to see the full surface.`,
-        )
+        printUnknownCommand(command)
         await exitWithFlush(1)
       }
     }

package/cli/ws-bridge.ts

@@ -145,9 +145,10 @@ function resolveDefaultDevBridgeLockfile(): DevBridgeLockfile | null {
     }
   }
 
+  // another checkout's bridge on its own offset belongs to that checkout's
+  // world; only the canonical bridge is shared, and past it the daemon serves.
   return (
-    lockfiles.find((lockfile) => lockfile.bridgePort === DEFAULT_SOOTSIM_BRIDGE_PORT) ??
-    lockfiles[0]
+    lockfiles.find((lockfile) => lockfile.bridgePort === DEFAULT_SOOTSIM_BRIDGE_PORT) ?? null
   )
 }