peachsim 0.1.637 → 0.1.639

package/cli/commands/inspect/core.ts

@@ -27,6 +27,7 @@ import type {
   SimSemanticSelector,
 } from '../../../src/bridge-contract'
 import type {
+  PeachAccessibilityNode,
   SootSimRouteInfo,
   SootSimRequestEntry,
   SootSimTimelineEvent,
@@ -904,40 +905,108 @@ export interface AccessibilityTreeNode {
   size: { w: number; h: number } | null
 }
 
-// `get a11y` — flat accessibility summary projected from the visible semantic
-// tree, which already excludes hidden and covered content, minus the painted
-// content VoiceOver cannot reach.
+// runtime shape check for the engine's PeachAccessibilityNode projection: the
+// bridge is a JSON boundary, so a node that lost a field must read as "no
+// snapshot" rather than flatten into a half-populated row.
+export function isPeachAccessibilityTree(
+  value: unknown,
+): value is PeachAccessibilityNode[] {
+  if (!Array.isArray(value)) return false
+  return value.every((node) => {
+    if (node === null || typeof node !== 'object') return false
+    if (
+      Reflect.get(node, 'platform') !== 'ios' &&
+      Reflect.get(node, 'platform') !== 'android'
+    )
+      return false
+    if (typeof Reflect.get(node, 'elementId') !== 'string') return false
+    if (!Number.isInteger(Reflect.get(node, 'nodeId'))) return false
+    for (const key of ['type', 'role']) {
+      if (typeof Reflect.get(node, key) !== 'string') return false
+    }
+    for (const key of ['testID', 'label', 'hint', 'value', 'placeholder']) {
+      const field = Reflect.get(node, key)
+      if (field !== null && typeof field !== 'string') return false
+    }
+    for (const key of [
+      'isAccessibilityElement',
+      'enabled',
+      'selected',
+      'checked',
+      'clickable',
+      'isTextInput',
+    ]) {
+      if (typeof Reflect.get(node, key) !== 'boolean') return false
+    }
+    const hasFocus = Reflect.get(node, 'hasFocus')
+    if (hasFocus !== undefined && typeof hasFocus !== 'boolean') return false
+    const state = Reflect.get(node, 'state')
+    if (state !== null) {
+      if (typeof state !== 'object') return false
+      const checked = Reflect.get(state, 'checked')
+      if (typeof checked !== 'boolean' && checked !== 'mixed') return false
+      for (const key of ['disabled', 'selected', 'busy', 'expanded']) {
+        if (typeof Reflect.get(state, key) !== 'boolean') return false
+      }
+    }
+    const value = Reflect.get(node, 'accessibilityValue')
+    if (value !== null) {
+      if (typeof value !== 'object') return false
+      for (const key of ['min', 'max', 'now']) {
+        const field = Reflect.get(value, key)
+        if (field !== undefined && (typeof field !== 'number' || !Number.isFinite(field)))
+          return false
+      }
+      const text = Reflect.get(value, 'text')
+      if (text !== undefined && typeof text !== 'string') return false
+    }
+    if (!isSemanticGeometry(Reflect.get(node, 'frame'))) return false
+    return isPeachAccessibilityTree(Reflect.get(node, 'children'))
+  })
+}
+
+// `get a11y` — flat VoiceOver presentation of the engine's XCTest
+// accessibility projection (SootSimTestBridge.captureAccessibilityTree).
+// VoiceOver reads an accessibility element as one group, so an element's
+// children are hidden from this flat view even though the snapshot keeps them
+// for Maestro's structural selectors (containsChild / containsDescendants).
 export async function inspectAccessibilityTree(
   bridge: InspectBridge,
 ): Promise<AccessibilityTreeNode[]> {
   const result: unknown = await bridge.send({
     type: 'query',
-    query: { kind: 'find', selector: { visible: true } },
+    query: { kind: 'accessibility' },
   })
-  if (!isSemanticQueryResult(result)) return []
-  return result.nodes.flatMap((node) => {
-    if (node.accessibilityHidden) return []
-    if (!node.role && !node.label && !node.text && !node.pressable) return []
-    return [
-      {
-        role:
-          node.role ??
-          (node.pressable ? 'button' : node.type === 'text' ? 'statictext' : 'none'),
-        label: node.label ?? node.text ?? null,
-        hint: null,
-        state: null,
-        testID: node.testID ?? null,
+  const tree =
+    result !== null && typeof result === 'object'
+      ? Reflect.get(result, 'accessibility')
+      : undefined
+  if (!isPeachAccessibilityTree(tree))
+    throw new Error('engine returned an invalid accessibility snapshot')
+  const nodes: AccessibilityTreeNode[] = []
+  const visit = (node: PeachAccessibilityNode): void => {
+    if (node.isAccessibilityElement) {
+      nodes.push({
+        role: node.role,
+        label: node.label,
+        hint: node.hint,
+        state: node.state ? { ...node.state } : null,
+        testID: node.testID,
         position: {
-          x: Math.round(node.geometry.x),
-          y: Math.round(node.geometry.y),
+          x: Math.round(node.frame.x),
+          y: Math.round(node.frame.y),
         },
         size: {
-          w: Math.round(node.geometry.width),
-          h: Math.round(node.geometry.height),
+          w: Math.round(node.frame.width),
+          h: Math.round(node.frame.height),
         },
-      },
-    ]
-  })
+      })
+      if (node.platform === 'ios') return
+    }
+    for (const child of node.children) visit(child)
+  }
+  for (const root of tree) visit(root)
+  return nodes
 }
 
 // ─── find ───

package/cli/commands/maestro.ts

@@ -114,6 +114,7 @@ supported verbs:
   launchApp (including arguments), stopApp, clearState, clearKeychain (warn-only),
   selectors: text, id, index (negative from the end), childOf, below, above,
   leftOf, rightOf, width / height / tolerance, traits, enabled, selected, checked,
+  focused, containsChild, containsDescendants,
   tapOn (including repeat / delay), doubleTapOn, tapAtCoords, longPressOn,
   inputText, pressKey, dispatchKey, hideKeyboard, eraseText,
   setClipboard, pasteText,
@@ -166,8 +167,7 @@ not yet implemented (the step fails with "unsupported flow step"):
   travel, setLocation, setAirplaneMode, killApp, faker, inputRandom*,
   addMedia, startRecording, stopRecording (use --record flag),
   repeat.while (only repeat.times is supported).
-selector keys that fail the step: containsChild, containsDescendants,
-  focused, css.
+selector keys that fail the step: css.
 `)
 }
 

package/cli/commands/serve.ts

@@ -36,11 +36,13 @@ usage:
 
 options:
   --port <n>        bridge port (defaults to ${DEFAULT_SOOTSIM_BRIDGE_PORT})
+  --host <address>  listener address (defaults to 127.0.0.1)
   --quiet           suppress per-connection logging
 
 examples:
   peach serve
   peach serve --port 7668 --quiet
+  peach serve --host 0.0.0.0
 `)
     rnxExit(0)
   }
@@ -54,6 +56,12 @@ examples:
     console.error(`  invalid --port value: ${args[portArgIdx + 1]}`)
     rnxExit(1)
   }
+  const hostArgIdx = args.indexOf('--host')
+  const bindHost = hostArgIdx >= 0 ? args[hostArgIdx + 1] : '127.0.0.1'
+  if (!bindHost || bindHost.startsWith('-')) {
+    console.error('  --host requires a listener address')
+    rnxExit(1)
+  }
   const quiet = args.includes('--quiet') || args.includes('-q')
 
   // only one bridge per peach home. refuse to start a second one
@@ -74,6 +82,7 @@ examples:
   const contrastOrigin = await resolveDefaultUploadOrigin()
   const host = new SootSimBridgeHost({
     port,
+    host: bindHost,
     writeLockfile: true,
     contrastOrigin,
   })
@@ -102,7 +111,10 @@ examples:
     for (const id of currentIds) lastSimIds.add(id)
   }, 500)
 
-  log(`peach bridge listening on ws://localhost:${boundPort} (runtime http on same port)`)
+  const displayHost = bindHost.includes(':') ? `[${bindHost}]` : bindHost
+  log(
+    `peach bridge listening on ws://${displayHost}:${boundPort} (runtime http on same port)`,
+  )
   if (boundPort !== port) {
     log(`  (preferred port ${port} was taken — fell back to ${boundPort})`)
   }

package/cli/commands/swift.ts

@@ -0,0 +1,326 @@
+import fs from 'node:fs'
+import http from 'node:http'
+import path from 'node:path'
+import { WebSocket, WebSocketServer } from 'ws'
+import { isLoopbackHost, resolveContrastBackendOrigin } from '../../src/backend-origin'
+import { swiftGuestBundle } from '../../src/swift-guest'
+import { SWIFT_HMR_PATH, SWIFT_PACKAGE_PATH } from '../../src/swift-submit'
+import { authHeaderValue, resolveCliAuth } from '../auth'
+import { PeachExit } from '../run-rnx'
+import { createBridge } from '../ws-bridge'
+import { runCloseCommand, runOpenCommand, type OpenCommandResources } from './control'
+import type { SwiftEntryModuleArgs } from '../../../sootsim-swift/src/entryModule'
+
+export async function runSwift(
+  args: string[],
+  opts: { port?: number; device?: string; driver?: string; headless?: boolean } = {},
+): Promise<number> {
+  const input = [...args]
+  const openArgs: string[] = []
+  let hostPort = 0
+  let uploadSource = false
+  const valueFlags = new Set([
+    '--device',
+    '--driver',
+    '--profile',
+    '--cdp-port',
+    '--os-version',
+    '--base-url',
+  ])
+  const booleanFlags = new Set([
+    '--headless',
+    '--headed',
+    '--ephemeral',
+    '--quiet',
+    '--proof',
+  ])
+  let packagePath = ''
+  for (let index = 0; index < input.length; index++) {
+    const arg = input[index]
+    if (arg === '--upload-source') uploadSource = true
+    else if (arg === '--host-port' || valueFlags.has(arg)) {
+      const value = input[++index]
+      if (!value || value.startsWith('-')) throw new Error(`${arg} requires a value`)
+      if (arg === '--host-port') {
+        hostPort = Number(value)
+        if (!Number.isInteger(hostPort) || hostPort < 1 || hostPort > 65535) {
+          throw new Error('--host-port must be a port from 1 to 65535')
+        }
+      } else openArgs.push(arg, value)
+    } else if (booleanFlags.has(arg)) openArgs.push(arg)
+    else if (arg.startsWith('-')) throw new Error(`unknown peach swift flag: ${arg}`)
+    else if (packagePath) throw new Error('peach swift expects one SwiftPM directory')
+    else packagePath = path.resolve(arg)
+  }
+  if (!packagePath)
+    throw new Error('usage: peach swift <SwiftPM-directory> --upload-source')
+  if (!uploadSource) {
+    throw new Error(
+      'peach swift uploads the selected package sources and resources to the authenticated Contrast compiler. Pass --upload-source to consent to this directory and its watched edits.',
+    )
+  }
+  const auth = resolveCliAuth()
+  if (!auth || auth.kind === 'github') {
+    throw new Error(
+      'peach swift needs `peach login` or PEACH_API_KEY before reading project sources',
+    )
+  }
+  const compileOrigin = resolveContrastBackendOrigin(
+    auth.kind === 'session' ? auth.origin : null,
+  )
+  packagePath = fs.realpathSync(packagePath)
+  if (
+    !fs.statSync(packagePath).isDirectory() ||
+    !fs.existsSync(path.join(packagePath, 'Package.swift'))
+  ) {
+    throw new Error('peach swift requires a directory containing Package.swift')
+  }
+  const host = await import('../../src/swift-host')
+  // collection preflights every input path before any source bytes are read.
+  host.swiftPackageWatchFiles(packagePath, undefined)
+  const packageName = path.basename(packagePath)
+  const guest = swiftGuestBundle(packageName)
+  const controller = new AbortController()
+  const resources: OpenCommandResources = {}
+  let metadata: (SwiftEntryModuleArgs & { hmrPath: string }) | null = null
+  let compileError = 'Swift compilation is starting'
+  let origin = ''
+  let requested = 0
+  let completed = 0
+  let building: Promise<void> | undefined
+  const sockets = new WebSocketServer({ noServer: true })
+  const send = (message: object) => {
+    const text = JSON.stringify(message)
+    for (const client of sockets.clients)
+      if (client.readyState === WebSocket.OPEN) client.send(text)
+  }
+  const refresh = (): Promise<void> => {
+    requested++
+    if (building) return building
+    building = (async () => {
+      while (!controller.signal.aborted && completed !== requested) {
+        const revision = requested
+        try {
+          const next = await host.swiftPackageMetadata(
+            packagePath,
+            packageName,
+            undefined,
+            origin,
+            {
+              origin: compileOrigin,
+              authorization: authHeaderValue(auth),
+              signal: controller.signal,
+            },
+          )
+          if (controller.signal.aborted) return
+          if (revision === requested) {
+            metadata = { ...next, hmrPath: `${origin}${SWIFT_HMR_PATH}` }
+            compileError = ''
+            send({ type: 'package', packageName, metadata })
+            console.log(`  Swift artifact: ${next.hash}`)
+          }
+        } catch (error) {
+          if (controller.signal.aborted) return
+          if (revision === requested) {
+            compileError = error instanceof Error ? error.message : String(error)
+            console.error(compileError)
+            send({ type: 'error', packageName, message: compileError })
+          }
+        }
+        completed = revision
+      }
+    })().finally(() => {
+      building = undefined
+    })
+    return building
+  }
+  const validRequest = (req: http.IncomingMessage): boolean => {
+    if (req.headers.host !== new URL(origin).host) return false
+    if (!req.headers.origin) return true
+    try {
+      const requestOrigin = new URL(req.headers.origin)
+      return (
+        (requestOrigin.protocol === 'http:' || requestOrigin.protocol === 'https:') &&
+        isLoopbackHost(requestOrigin.hostname)
+      )
+    } catch {
+      return false
+    }
+  }
+  const server = http.createServer((req, res) => {
+    if (!validRequest(req)) {
+      res.statusCode = 403
+      res.end('forbidden Swift host origin')
+      return
+    }
+    res.setHeader('access-control-allow-origin', req.headers.origin ?? '*')
+    res.setHeader('vary', 'origin')
+    res.setHeader('cache-control', 'no-store')
+    if (req.method !== 'GET') {
+      res.statusCode = 405
+      res.end('GET required')
+      return
+    }
+    const pathname = new URL(req.url ?? '/', origin).pathname
+    if (pathname === '/__peach/swift-guest.js') {
+      res.setHeader('content-type', 'application/javascript')
+      res.end(guest)
+    } else if (pathname === `${SWIFT_PACKAGE_PATH}${encodeURIComponent(packageName)}`) {
+      if (!metadata) {
+        res.statusCode = 503
+        res.end(compileError)
+        return
+      }
+      res.setHeader('content-type', 'application/json')
+      res.end(JSON.stringify(metadata))
+    } else if (!host.serveSwiftPackageAsset(pathname, res)) {
+      res.statusCode = 404
+      res.end('unknown Swift host asset')
+    }
+  })
+  server.on('upgrade', (req, socket, head) => {
+    if (
+      !validRequest(req) ||
+      new URL(req.url ?? '/', origin).pathname !== SWIFT_HMR_PATH
+    ) {
+      socket.destroy()
+      return
+    }
+    sockets.handleUpgrade(req, socket, head, (client) => {
+      sockets.emit('connection', client, req)
+      client.send(
+        JSON.stringify(
+          metadata
+            ? { type: 'package', packageName, metadata }
+            : { type: 'error', packageName, message: compileError },
+        ),
+      )
+      if (metadata && compileError)
+        client.send(JSON.stringify({ type: 'error', packageName, message: compileError }))
+    })
+  })
+  const stop = () => controller.abort()
+  process.once('SIGINT', stop)
+  process.once('SIGTERM', stop)
+  let watcher: fs.FSWatcher | undefined
+  let code = 0
+  try {
+    await new Promise<void>((resolve, reject) => {
+      server.once('error', reject)
+      server.listen(hostPort, '127.0.0.1', () => {
+        server.removeListener('error', reject)
+        const address = server.address()
+        if (!address || typeof address === 'string') {
+          reject(new Error('Swift host has no loopback port'))
+          return
+        }
+        origin = `http://127.0.0.1:${address.port}`
+        resolve()
+      })
+    })
+    server.on('error', (error) => {
+      console.error(error.message)
+      code = 1
+      stop()
+    })
+    watcher = fs.watch(packagePath, { recursive: true }, (_event, file) => {
+      if (
+        file &&
+        file
+          .split(/[\\/]/)
+          .some(
+            (segment) =>
+              (segment.startsWith('.') &&
+                segment !== '.one-native-source.json' &&
+                segment !== '.one-native-source.swift.txt') ||
+              ['node_modules', 'ios', 'android', 'build', 'dist', 'types'].includes(
+                segment,
+              ),
+          )
+      )
+        return
+      void refresh()
+    })
+    watcher.on('error', (error) => {
+      console.error(error.message)
+      code = 1
+      stop()
+    })
+    console.log(
+      `  Swift source upload: ${packagePath} → ${compileOrigin}/api/swift-compile`,
+    )
+    console.log(`  Swift preview host: ${origin}`)
+    await refresh()
+    controller.signal.throwIfAborted()
+    if (opts.device) openArgs.push('--device', opts.device)
+    if (opts.driver) openArgs.push('--driver', opts.driver)
+    if (opts.headless) openArgs.push('--headless')
+    await runOpenCommand(
+      [`${origin}/__peach/swift-guest.js`, '--new', '--no-hmr', ...openArgs],
+      {
+        port: opts.port,
+        resources,
+        signal: controller.signal,
+        ownerPid: process.pid,
+      },
+    )
+    await new Promise<void>((resolve) => {
+      if (controller.signal.aborted) resolve()
+      else controller.signal.addEventListener('abort', () => resolve(), { once: true })
+    })
+  } catch (error) {
+    if (!controller.signal.aborted) {
+      console.error(
+        `  peach swift failed: ${error instanceof Error ? error.message : String(error)}`,
+      )
+      code = error instanceof PeachExit ? error.code : 1
+    }
+  } finally {
+    controller.abort()
+    process.removeListener('SIGINT', stop)
+    process.removeListener('SIGTERM', stop)
+    watcher?.close()
+    await building
+    for (const client of sockets.clients) client.terminate()
+    sockets.close()
+    server.closeAllConnections()
+    await new Promise<void>((resolve) => server.close(() => resolve()))
+    if (resources.simId && resources.port) {
+      try {
+        await runCloseCommand(['--sim', resources.simId], { port: resources.port })
+      } catch (error) {
+        console.error(`  Swift preview cleanup failed: ${String(error)}`)
+        code = 1
+      }
+    }
+    if (
+      resources.driver?.driverId === 'playwright' &&
+      resources.driver.launched &&
+      resources.driver.pid
+    ) {
+      try {
+        process.kill(resources.driver.pid, 'SIGTERM')
+      } catch (error) {
+        if (!(error instanceof Error && 'code' in error && error.code === 'ESRCH')) {
+          console.error(String(error))
+          code = 1
+        }
+      }
+    }
+    if (resources.bridge && !resources.bridgeReady) resources.bridge.kill('SIGTERM')
+    if (resources.bridge && resources.bridgeReady && resources.port) {
+      const bridge = createBridge(resources.port)
+      try {
+        if ((await bridge.listSims()).length === 0) resources.bridge.kill('SIGTERM')
+        else console.log('  preserving the bridge adopted by another simulator')
+      } catch (error) {
+        console.error(`  cannot verify owned bridge cleanup: ${String(error)}`)
+        code = 1
+      } finally {
+        bridge.close()
+      }
+    }
+    host.disposeSwiftProject(packagePath)
+  }
+  return code
+}

package/cli/drivers/playwright-provisioning.ts

@@ -48,18 +48,12 @@ export function resolvePlaywright(): ResolvedPlaywright | null {
           const packageJsonPath = requireFromRoot.resolve(`${spec}/package.json`)
           const parsed: unknown = JSON.parse(readFileSync(packageJsonPath, 'utf8'))
           if (!isRecord(parsed) || typeof parsed.version !== 'string') continue
-          const bin = parsed.bin
-          let binPath: string | null = null
-          if (typeof bin === 'string') {
-            binPath = bin
-          } else if (isRecord(bin)) {
-            const named = bin.playwright ?? bin['playwright-core']
-            const first = Object.values(bin).find((value) => typeof value === 'string')
-            binPath =
-              typeof named === 'string' ? named : typeof first === 'string' ? first : null
-          }
-          if (!binPath) continue
-          const cliPath = join(dirname(packageJsonPath), binPath)
+          // resolve the core beside the API entry, never from the caller's
+          // project when running this package's provisioning subcommand.
+          const corePackagePath = createRequire(modulePath).resolve(
+            'playwright-core/package.json',
+          )
+          const cliPath = join(dirname(corePackagePath), 'cli.js')
           if (!existsSync(cliPath)) continue
           return {
             spec,
@@ -166,10 +160,8 @@ export function ensurePlaywrightBrowser(
     return { ok: true, executablePath: before.executablePath, installed: false }
   }
 
-  // the resolved package is the authority for both the required executable
-  // path and the installer. never scan a shared cache or select a neighboring
-  // revision: Playwright's own CLI installs the exact revision its API named.
-  // that CLI is a javascript file, so this CLI runs it as itself.
+  // install only when neither an explicit binary nor an installed cache
+  // revision is available. the absolute core CLI owns its downloader scripts.
   const installer = rnxSelfInvocation()
   const install = spawnSync(
     installer.executable,

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

@@ -26,6 +26,8 @@ import { DISPOSABLE_BROWSER_CACHE_DIR_NAMES } from '../../src/browser-cache'
 
 export const PLAYWRIGHT_SIM_HOST = `
 const modulePath = process.env.SOOTSIM_PW_MODULE;
+const executablePath = process.env.SOOTSIM_PW_EXECUTABLE;
+if (!executablePath) throw new Error('SOOTSIM_PW_EXECUTABLE is not set');
 const url = process.env.SOOTSIM_PW_URL;
 // the WS bridge port the sim page must register with, injected below as
 // window.__sootsimBridgePort so the page skips its shell-port heuristic (which
@@ -332,6 +334,7 @@ const cleanupProfile = () => {
     const opts = channel
       ? { headless, channel, viewport, deviceScaleFactor }
       : { headless, viewport, deviceScaleFactor };
+    opts.executablePath = executablePath;
     // playwright injects --force-color-profile=srgb by default, which reads
     // visibly washed-out next to a normal chrome window on a wide-gamut mac
     // display. strip it so driver-launched sims color-match the user's own

package/cli/drivers/playwright.ts

@@ -132,6 +132,7 @@ async function launch(opts: DriverLaunchOptions): Promise<DriverLaunchResult> {
         env: {
           ...playwrightEnv,
           SOOTSIM_PW_MODULE: resolved.modulePath,
+          SOOTSIM_PW_EXECUTABLE: provisioning.executablePath,
           SOOTSIM_PW_URL: opts.url,
           SOOTSIM_PW_BRIDGE_PORT: opts.bridgePort ? String(opts.bridgePort) : '',
           SOOTSIM_PW_HEADLESS: (opts.headless ?? true) ? '1' : '0',