peachsim 0.1.1644 → 0.1.1653

package/cli/commands/control.ts

@@ -6,21 +6,13 @@ import { createRequire } from 'node:module'
 import net from 'node:net'
 import os from 'node:os'
 import path from 'node:path'
-import { bundleUrlForPlatform } from 'peach-engine/bundle-platform-url'
-import { encodeAppCatalogWire } from 'peach-engine/engine/app-catalog-wire'
-import { encodeAppFontsWire } from 'peach-engine/engine/config-plugin-fonts'
-import {
-  getRuntimePlatform,
-  isDeviceModel,
-  resolveDeviceFitBox,
-  type DeviceModel,
-} from 'peach-engine/settings/devices'
 import { WebSocket } from 'ws'
 import { pinSharedListenerScan, probePort } from '../../scripts/dev-server-scanner'
 import { formatLockOwner } from '../../src/agent-identity'
 import { isAppDeepLinkTarget, openAppUrl } from '../../src/app-url'
 import { isLoopbackHost, loopbackOriginOf } from '../../src/backend-origin'
 import { resolveSootsimShellBaseUrlForBridgePort } from '../../src/bridge-constants'
+import { getCliRuntime } from '../../src/cli-runtime.ts'
 import {
   applyPeachConfigToUrl,
   mergePeachConfig,
@@ -37,6 +29,7 @@ import {
   resolveConnectionInput,
   type ResolvedDevBundle,
 } from '../../src/dev-bundle-resolution'
+import { isDeviceModel, type DeviceModel } from '../../src/device-catalog.ts'
 import { readProjectDotEnv } from '../../src/dot-env'
 import { awaitStampedExpoSwiftReady } from '../../src/expo-swift-ready'
 import { flowTimeoutScale } from '../../src/flow-timeout-scale'
@@ -63,6 +56,7 @@ import {
 import { readInstalledNativePackageVersions } from '../../src/installed-package-versions'
 import { LAUNCH_METADATA_QUERY_PARAM } from '../../src/launchMetadataContract'
 import { detectBundleModeFromText } from '../../src/metro-production-bundle'
+import { resolveMetroProjectRoot } from '../../src/metro-project-root'
 import {
   canExtractNativeAppIdentity,
   createNativeAppIdentityHeader,
@@ -92,7 +86,7 @@ import { sleep } from '../../src/sleep'
 import { stageAppBundleResources } from '../app-bundle-resources'
 import { discoverAppCatalog } from '../app-catalog'
 import { loadRNXAppConfig } from '../app-config'
-import { discoverNativeLinkedAppFonts, resolveMetroProjectRoot } from '../app-fonts'
+import { discoverNativeLinkedAppFonts } from '../app-fonts'
 import {
   findExpoAppConfig,
   resolveAppProject,
@@ -107,7 +101,9 @@ import {
 } from '../app-splash'
 import { printBridgeFailureDiagnostics } from '../bridge-diagnostics'
 import {
+  assertNoPendingOpen,
   clearCurrentSimId,
+  markOpenPending,
   getStableOwnerPid,
   readCurrentSimId,
   saveCurrentSimId,
@@ -116,11 +112,14 @@ import { findDesktopCompanion, nativeDesktopIsDefault } from '../desktop-compani
 import { validateDeviceOption } from '../device-option'
 import { getDriver } from '../drivers/registry'
 import { isTeamMachineSession, openUrl as openUrlInBrowser } from '../open-url'
+import { redactConfigurationForDiagnostics } from '../output-redaction'
+import { GLOBAL_FLAG_TAKES_VALUE } from '../parse-args'
 import { diagnosticsAllowedForCurrentProcess, isCi } from '../privacy'
 import { rethrowIfExit, peachExit } from '../run-rnx'
 import { collectRuntimeDiagnostics } from '../runtime-diagnostics'
 import { rnxSelfInvocation } from '../self-invocation'
 import {
+  BRIDGE_VALUE_FLAGS,
   BridgeSimLockedError,
   createBridge,
   createBridgeFromParsed,
@@ -1042,7 +1041,9 @@ function stampAppFonts(
     })
     if (specs.length === 0) return urlStr
     const catalogUrl = stageHostBytes(
-      new TextEncoder().encode(encodeAppFontsWire(specs)),
+      new TextEncoder().encode(
+        getCliRuntime().engine_config_plugin_fonts.encodeAppFontsWire(specs),
+      ),
       nativeAssetOrigin,
     )
     url.searchParams.set('appFonts', `@${catalogUrl}`)
@@ -1137,7 +1138,10 @@ function stampAppCatalog(urlStr: string, project?: ResolvedAppProject | null): s
     if (!metroOrigin || !project) return urlStr
     const catalog = discoverAppCatalog(project.appDir, metroOrigin)
     if (!catalog) return urlStr
-    url.searchParams.set('appCatalog', encodeAppCatalogWire(catalog))
+    url.searchParams.set(
+      'appCatalog',
+      getCliRuntime().engine_app_catalog_wire.encodeAppCatalogWire(catalog),
+    )
     return url.toString()
   } catch {
     return urlStr
@@ -1365,7 +1369,7 @@ export async function buildShellUrl(
   const bundle = bundleUrlOf(resolved)
   const platform =
     device && isDeviceModel(device)
-      ? getRuntimePlatform(device)
+      ? getCliRuntime().settings_devices.getRuntimePlatform(device)
       : bundle && new URL(bundle).searchParams.get('platform') === 'android'
         ? 'android'
         : 'ios'
@@ -1802,30 +1806,9 @@ export function printOpenedSim(
     | `${string} driver`,
   quiet = false,
 ) {
-  const [printableOpenUrl, printableSimUrl] = [openUrl, sim.url].map((value) => {
-    if (!value) return value
-    try {
-      const parsed = new URL(value)
-      let changed = false
-      if (parsed.searchParams.has(PEACH_CONFIG_QUERY_PARAM)) {
-        parsed.searchParams.set(PEACH_CONFIG_QUERY_PARAM, '[redacted]')
-        changed = true
-      }
-      const bundle = parsed.searchParams.get('bundle')
-      if (bundle) {
-        try {
-          const parsedBundle = new URL(bundle)
-          if (parsedBundle.searchParams.has(PEACH_CONFIG_QUERY_PARAM)) {
-            parsedBundle.searchParams.set(PEACH_CONFIG_QUERY_PARAM, '[redacted]')
-            parsed.searchParams.set('bundle', parsedBundle.toString())
-            changed = true
-          }
-        } catch {}
-      }
-      if (changed) return parsed.toString()
-    } catch {}
-    return value
-  })
+  const [printableOpenUrl, printableSimUrl] = [openUrl, sim.url].map((value) =>
+    value ? redactConfigurationForDiagnostics(value) : value,
+  )
   if (quiet) {
     console.log(`  Opened ConnectRN [${mode}]`)
     return
@@ -1989,9 +1972,7 @@ export async function runOpenCommand(
     ownerPid?: number
   } = {},
 ): Promise<{ simId: string; launched: boolean } | undefined> {
-  const parsed = parseBridgeCliArgs(args, {
-    port: opts.port,
-    commandTimeoutMs: opts.timeoutMs,
+  const openArgOptions = {
     stripBooleanFlags: [
       '--new',
       '--headless',
@@ -2010,6 +1991,7 @@ export async function runOpenCommand(
       '--bundle-origin',
       '--project-root',
       '--replace',
+      '--remap',
       '--driver',
       '--profile',
       '--cdp-port',
@@ -2024,6 +2006,40 @@ export async function runOpenCommand(
       '--theme',
       '-t',
     ],
+  }
+  const booleanFlags = new Set(openArgOptions.stripBooleanFlags)
+  const valueFlags = new Set(openArgOptions.stripValueFlags)
+  const bridgeValueFlags = new Set(BRIDGE_VALUE_FLAGS)
+  // validate tokens, not parsed positionals: option values may start with a
+  // dash, and an explicit separator ends option validation.
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]
+    if (arg === '--') break
+    if (valueFlags.has(arg) || bridgeValueFlags.has(arg)) {
+      i++
+      continue
+    }
+    if (booleanFlags.has(arg)) continue
+    const equals = arg.indexOf('=')
+    if (equals > 0 && bridgeValueFlags.has(arg.slice(0, equals))) continue
+    const globalTakesValue = GLOBAL_FLAG_TAKES_VALUE.get(arg)
+    if (globalTakesValue !== undefined) {
+      if (globalTakesValue) i++
+      continue
+    }
+    if (arg.startsWith('-') && arg !== '-') {
+      console.error(
+        `  peach open: unknown option "${arg}". ${
+          arg.startsWith('--cdp') ? 'Use --cdp-port <port>. ' : ''
+        }Run \`peach open --help\` for supported options.`,
+      )
+      peachExit(1)
+    }
+  }
+  const parsed = parseBridgeCliArgs(args, {
+    ...openArgOptions,
+    port: opts.port,
+    commandTimeoutMs: opts.timeoutMs,
   })
   const requestedProfileId = args.find((_, i) => args[i - 1] === '--profile')
   const quiet = args.includes('--quiet')
@@ -2133,6 +2149,14 @@ export async function runOpenCommand(
     return
   }
 
+  // argument validation and link handling are done; every failure from here on
+  // happens while choosing the sim this open meant to drive. an open that will
+  // not reuse a pinned sim records that intent now, so a failure anywhere
+  // below leaves later implicit commands refused instead of landing on
+  // whichever other tab the bridge holds.
+  const savedSimId = readCurrentSimId()
+  if (parsed.simIdSource !== 'flag' && (openInNewSim || !savedSimId)) markOpenPending()
+
   // a bundle file gets its url once the bridge that serves it is settled
   let resolvedBundle =
     !prebuiltBundle && shouldResolveBundleTargetInCli(target)
@@ -2234,16 +2258,6 @@ export async function runOpenCommand(
     resolvedBundle && project && !findExpoAppConfig(project.appDir)
       ? discoverOneNativeAppSplash(resolvedBundle.bundleUrl)
       : undefined
-  if (resolvedBundle) {
-    // the engine fetches this url for its device's platform
-    const bundleUrl = applyHotMode(resolvedBundle.bundleUrl, hotMode)
-    startDevServerBuild(
-      deviceArg && isDeviceModel(deviceArg)
-        ? bundleUrlForPlatform(bundleUrl, getRuntimePlatform(deviceArg), () => bundleUrl)
-        : bundleUrl,
-    )
-  }
-
   const appConfig = await loadRNXAppConfig(project)
   const configuredRuntimeVersion = appConfig?.runtimeVersion
   const runtimeConfig = mergePeachConfig(
@@ -2301,6 +2315,19 @@ export async function runOpenCommand(
   )
   if (opts.resources) opts.resources.port = parsed.wsPort
   opts.signal?.throwIfAborted()
+  if (resolvedBundle) {
+    // platform selection needs the verified companion after runtime preparation
+    const bundleUrl = applyHotMode(resolvedBundle.bundleUrl, hotMode)
+    startDevServerBuild(
+      deviceArg && isDeviceModel(deviceArg)
+        ? getCliRuntime().bundle_platform_url.bundleUrlForPlatform(
+            bundleUrl,
+            getCliRuntime().settings_devices.getRuntimePlatform(deviceArg),
+            () => bundleUrl,
+          )
+        : bundleUrl,
+    )
+  }
   // the shell opens a bundle file as the url the bridge serves it at
   let shellTarget = target
   if (prebuiltBundle) {
@@ -2351,7 +2378,7 @@ export async function runOpenCommand(
   // a foldable spans both postures, so the device draws at its natural size in
   // the posture it opens in instead of shrinking into a window sized for one.
   const deviceFitBox = deviceArg
-    ? resolveDeviceFitBox(
+    ? getCliRuntime().settings_devices.resolveDeviceFitBox(
         deviceArg as DeviceModel,
         false,
         orientationArg,
@@ -2458,7 +2485,6 @@ export async function runOpenCommand(
       : applyRuntimeGenerationOrigin(selectedShellBaseUrl, configuredRuntimeVersion)
   const hasExplicitBaseUrl = args.includes('--base-url')
   printBridgeWorldNotice(parsed.wsPort, baseUrl)
-  const savedSimId = readCurrentSimId()
   const shouldReuseCurrentSim = !openInNewSim
   // every open stamps its page URL with a one-off token and matches the sim by
   // it. a sim id alone cannot tell the page this open loaded from the page it
@@ -2490,7 +2516,7 @@ export async function runOpenCommand(
                 simUsesDriver(sim, driverId, renderer, pinnedHostExecutable),
             ) ?? null
           if (!targetSim) {
-            clearCurrentSimId()
+            markOpenPending()
           }
         } else if (parsed.simIdSource === 'flag') {
           targetSim = resolveTargetSim(sims, parsed.simId)
@@ -3024,6 +3050,20 @@ export async function runCloseCommand(args: string[], opts: ControlCommandOption
   const closeOthers = args.includes('--others')
   const force = args.includes('--force')
 
+  // close resolves its own sim ids before the bridge sees them, so the
+  // bridge's pending-open check cannot tell a named sim from a chosen one.
+  // refuse here, before any bridge command, when the user named no sim.
+  const namedSim = parsed.positional[0] || parsed.simIdSource === 'flag'
+  if (!namedSim) {
+    try {
+      assertNoPendingOpen()
+    } catch (err) {
+      console.error(`  close failed: ${err instanceof Error ? err.message : String(err)}`)
+      bridge.close()
+      peachExit(1)
+    }
+  }
+
   if (closeAll || closeOthers) {
     try {
       const sims = await bridge.listSims()

package/cli/commands/coverage-parser.ts

@@ -0,0 +1,67 @@
+import { existsSync, readFileSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { dirname, join } from 'node:path'
+import { installVerifiedTarball } from '@contrast/runtime-delivery'
+import { version } from 'typescript'
+import { rnxHomeDir } from '../../src/home-paths'
+
+// the api client and its native server must be the same release.
+const PARSER_VERSION = '7.1.0-beta'
+const INTEGRITIES = new Map([
+  [
+    'darwin-arm64',
+    'q7mxblcyX0E7hXsY4k+Q6KWKK5mGmfVq+BDesdTgRVgjodk27aIxER77Zyj9+TgSTlCje8F7+JM6f6hl2BuNdw==',
+  ],
+  [
+    'darwin-x64',
+    'D5EYqG5Wm/guw9+0j8+Mn1Jbr/gfS/VtFTuoH8PJtFbcqeDaQGMulc7SW8q51QG6Y3wGOGX3nbsTOw6fIKWWAA==',
+  ],
+  [
+    'linux-arm64',
+    'hNqQBgQ5b5oGqN76QqbAU6CwYhJZ6iOcWc2kPTUs2OentgpxZktETziH6KIyRFJPaiBncognwn2ZLu3DNhHiWw==',
+  ],
+  [
+    'linux-x64',
+    'kcD51ihf+pnI5KT4uQQYG04OpwznaZYBlIQhDhl8fflFd27NktxXsUeguxZyvUMyWfum7IF2bBS6Jv7ox0AgFQ==',
+  ],
+  [
+    'win32-x64',
+    'UKcHvbybY2tDTvFW2b1vwiAvDlIRooo69lh8CXWVhOQejcvpM5+IgbiFW9EIwR5Wi5X/v+BdN7gdWbigBuJ3rw==',
+  ],
+])
+
+export async function coverageParserPath(): Promise<string> {
+  if (version !== PARSER_VERSION)
+    throw new Error('coverage parser pins must match the installed TypeScript API client')
+  const platform = `${process.platform}-${process.arch}`
+  const integrity = INTEGRITIES.get(platform)
+  if (!integrity) throw new Error(`coverage source parser is unavailable for ${platform}`)
+  const packageName = `@typescript/typescript-${platform}`
+  const executable = process.platform === 'win32' ? 'tsc.exe' : 'tsc'
+  const require = createRequire(import.meta.url)
+  try {
+    const manifestPath = require.resolve(`${packageName}/package.json`)
+    const manifest: unknown = JSON.parse(readFileSync(manifestPath, 'utf8'))
+    const path = join(dirname(manifestPath), 'lib', executable)
+    if (
+      manifest &&
+      typeof manifest === 'object' &&
+      'version' in manifest &&
+      manifest.version === PARSER_VERSION &&
+      existsSync(path)
+    )
+      return path
+  } catch {}
+  const destDir = join(rnxHomeDir(), 'tools', 'coverage-parser', PARSER_VERSION, platform)
+  const cached = join(destDir, 'lib', executable)
+  if (existsSync(cached)) return cached
+  await installVerifiedTarball({
+    url: `https://registry.npmjs.org/${packageName}/-/typescript-${platform}-${PARSER_VERSION}.tgz`,
+    digest: { algorithm: 'sha512', encoding: 'base64', value: integrity },
+    destDir,
+    installedMarker: `lib/${executable}`,
+    stripComponents: 1,
+    label: `coverage source parser ${PARSER_VERSION}`,
+  })
+  return cached
+}