peachsim 0.1.527

package/detox/attempt-events.cjs

@@ -0,0 +1,23 @@
+const fs = require('node:fs')
+const path = require('node:path')
+
+function attemptEventsPath() {
+  const enabled =
+    process.env.CONFORMANCE_PROOF === '1' || Boolean(process.env.CONFORMANCE_PROOF_DIR)
+  if (!enabled) return null
+  const root = path.resolve(
+    process.cwd(),
+    process.env.CONFORMANCE_PROOF_DIR || 'artifacts/conformance-proof/latest',
+  )
+  return path.join(root, 'events.jsonl')
+}
+
+function writeAttemptEvent(event) {
+  const output = attemptEventsPath()
+  if (output === null) return false
+  fs.mkdirSync(path.dirname(output), { recursive: true })
+  fs.appendFileSync(output, `${JSON.stringify(event)}\n`)
+  return true
+}
+
+module.exports = { attemptEventsPath, writeAttemptEvent }

package/detox/colors.ts

@@ -0,0 +1,54 @@
+// re-export color utilities from kitchen-sink for convenience
+// these are the same implementations used in detox tests
+
+import * as fs from 'fs'
+import { PNG } from 'pngjs'
+
+export type RGB = { r: number; g: number; b: number }
+
+export function getDominantColor(screenshotPath: string): RGB {
+  const data = fs.readFileSync(screenshotPath)
+  const png = PNG.sync.read(data)
+
+  const startX = Math.floor(png.width * 0.25)
+  const endX = Math.floor(png.width * 0.75)
+  const startY = Math.floor(png.height * 0.25)
+  const endY = Math.floor(png.height * 0.75)
+
+  let totalR = 0,
+    totalG = 0,
+    totalB = 0,
+    count = 0
+
+  for (let y = startY; y < endY; y++) {
+    for (let x = startX; x < endX; x++) {
+      const idx = (png.width * y + x) * 4
+      totalR += png.data[idx]
+      totalG += png.data[idx + 1]
+      totalB += png.data[idx + 2]
+      count++
+    }
+  }
+
+  return {
+    r: Math.round(totalR / count),
+    g: Math.round(totalG / count),
+    b: Math.round(totalB / count),
+  }
+}
+
+export function isBlueish(color: RGB): boolean {
+  return color.b > 100 && color.b > color.r && color.b > color.g
+}
+
+export function isReddish(color: RGB): boolean {
+  return color.r > 100 && color.r > color.b && color.r > color.g
+}
+
+export function isGreenish(color: RGB): boolean {
+  return color.g > 100 && color.g > color.r && color.g > color.b
+}
+
+export function formatRGB(color: RGB): string {
+  return `RGB(${color.r}, ${color.g}, ${color.b})`
+}

package/detox/config-loader.ts

@@ -0,0 +1,135 @@
+// parse detox configuration from various locations
+// maps detox device config to sootsim settings
+
+import * as fs from 'fs'
+import * as path from 'path'
+
+export interface DetoxConfig {
+  testRunner?: {
+    args?: Record<string, any>
+    jest?: { setupTimeout?: number; teardownTimeout?: number }
+  }
+  apps?: Record<string, { type: string; binaryPath?: string; build?: string }>
+  devices?: Record<string, { type: string; device?: { type?: string } }>
+  configurations?: Record<string, { device?: string; app?: string }>
+  testMatch?: string[]
+  testDir?: string
+}
+
+export interface SootSimDetoxConfig {
+  testFiles: string[]
+  testTimeout: number
+  sootsimUrl: string
+  deviceModel: string
+  maxWorkers: number
+}
+
+// search order: .detoxrc.js, .detoxrc.json, detox.config.js, detox.config.json, package.json#detox
+export function loadDetoxConfig(projectDir: string): DetoxConfig | null {
+  const candidates = [
+    '.detoxrc.js',
+    '.detoxrc.json',
+    'detox.config.js',
+    'detox.config.json',
+  ]
+
+  for (const file of candidates) {
+    const filePath = path.join(projectDir, file)
+    if (fs.existsSync(filePath)) {
+      try {
+        if (file.endsWith('.json')) {
+          return JSON.parse(fs.readFileSync(filePath, 'utf8'))
+        }
+        // for JS files, we can't easily require them without running them
+        // return a basic config indicating file was found
+        return { testDir: 'e2e' }
+      } catch {
+        continue
+      }
+    }
+  }
+
+  // check package.json
+  const pkgPath = path.join(projectDir, 'package.json')
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'))
+      if (pkg.detox) return pkg.detox
+    } catch {}
+  }
+
+  return null
+}
+
+// find test files matching detox patterns
+export function findDetoxTestFiles(
+  projectDir: string,
+  config: DetoxConfig | null,
+): string[] {
+  const testDirs = ['e2e', 'test/e2e', 'detox', '__tests__/e2e']
+  const patterns = [
+    '.test.ts',
+    '.test.js',
+    '.test.tsx',
+    '.test.jsx',
+    '.spec.ts',
+    '.spec.js',
+  ]
+
+  // if config specifies a test dir, prioritize it
+  if (config?.testDir) {
+    testDirs.unshift(config.testDir)
+  }
+
+  const files: string[] = []
+
+  for (const dir of testDirs) {
+    const fullDir = path.join(projectDir, dir)
+    if (!fs.existsSync(fullDir)) continue
+
+    const entries = fs.readdirSync(fullDir, { recursive: true })
+    for (const entry of entries) {
+      const entryStr = String(entry)
+      if (patterns.some((p) => entryStr.endsWith(p))) {
+        files.push(path.join(fullDir, entryStr))
+      }
+    }
+  }
+
+  return files
+}
+
+// map detox device type to sootsim device model
+export function mapDetoxDevice(config: DetoxConfig | null): string {
+  if (!config?.devices) return 'iphone-15-pro'
+
+  const devices = Object.values(config.devices)
+  for (const dev of devices) {
+    const type = dev.device?.type?.toLowerCase() || ''
+    if (type.includes('se')) return 'iphone-se'
+    if (type.includes('16 pro max') || type.includes('16-pro-max'))
+      return 'iphone-16-pro-max'
+    if (type.includes('16 pro') || type.includes('16-pro')) return 'iphone-16-pro'
+    if (type.includes('16')) return 'iphone-16'
+    if (type.includes('15 pro max') || type.includes('15-pro-max'))
+      return 'iphone-15-pro-max'
+    if (type.includes('15 pro') || type.includes('15-pro')) return 'iphone-15-pro'
+    if (type.includes('15')) return 'iphone-15'
+  }
+
+  return 'iphone-15-pro'
+}
+
+// generate a sootsim-compatible config from detox config
+export function toRNXConfig(
+  projectDir: string,
+  config: DetoxConfig | null,
+): SootSimDetoxConfig {
+  return {
+    testFiles: findDetoxTestFiles(projectDir, config),
+    testTimeout: config?.testRunner?.jest?.setupTimeout || 120000,
+    sootsimUrl: process.env.RNX_URL || 'http://localhost:5173',
+    deviceModel: mapDetoxDevice(config),
+    maxWorkers: 1,
+  }
+}

package/detox/element-types.ts

@@ -0,0 +1,48 @@
+import type { Matcher } from './matchers'
+
+// element interaction object returned by element(matcher)
+export interface SootSimElement {
+  // reference to the matcher for lazy evaluation
+  _matcher: Matcher
+
+  tap(point?: { x?: number; y?: number }): Promise<void>
+  multiTap(times: number): Promise<void>
+  longPress(duration?: number): Promise<void>
+  longPressAndDrag(
+    duration: number,
+    normalizedStartX: number,
+    normalizedStartY: number,
+    targetElement: SootSimElement,
+    normalizedEndX: number,
+    normalizedEndY: number,
+    speed?: string,
+    holdDuration?: number,
+  ): Promise<void>
+  typeText(text: string): Promise<void>
+  replaceText(text: string): Promise<void>
+  clearText(): Promise<void>
+  scroll(
+    pixels: number,
+    direction: 'up' | 'down' | 'left' | 'right',
+    startPositionX?: number,
+    startPositionY?: number,
+  ): Promise<void>
+  scrollTo(
+    edge: 'top' | 'bottom' | 'left' | 'right',
+    startPositionX?: number,
+    startPositionY?: number,
+  ): Promise<void>
+  swipe(
+    direction: 'up' | 'down' | 'left' | 'right',
+    speed?: 'fast' | 'slow',
+    percentage?: number,
+    normalizedStartingPointX?: number,
+    normalizedStartingPointY?: number,
+  ): Promise<void>
+  setColumnToValue(column: number, value: string): Promise<void>
+  pinch(scale: number, speed?: 'fast' | 'slow', angle?: number): Promise<void>
+  rotate(radians: number, speed?: 'fast' | 'slow'): Promise<void>
+  takeScreenshot(name: string): Promise<string>
+  getAttributes(): Promise<any>
+  atIndex(index: number): SootSimElement
+}