peachsim 0.1.629 → 0.1.631

package/cli/commands/detect.ts

@@ -1,11 +1,21 @@
 // project detection — finds project root, detects framework, scans monorepo workspaces
 
-import { existsSync, readFileSync, readdirSync, statSync } from 'fs'
-import { basename, dirname, join } from 'path'
+import {
+  existsSync,
+  lstatSync,
+  opendirSync,
+  readFileSync,
+  readdirSync,
+  statSync,
+} from 'node:fs'
+import { basename, dirname, join } from 'node:path'
+import JSON5 from 'json5'
+import { parse as parseYaml } from 'yaml'
+import type { DependencyVersion, ProjectManifest } from './projectReportContract'
 
 export type Framework = 'one' | 'expo' | 'bare' | 'unknown'
 export type PackageManager = 'bun' | 'pnpm' | 'npm' | 'yarn'
-export type MonorepoType = 'turbo' | 'pnpm' | 'nx' | 'npm-workspaces' | 'single'
+export type MonorepoType = 'turbo' | 'pnpm' | 'nx' | 'lerna' | 'npm-workspaces' | 'single'
 
 export interface DetectedProject {
   dir: string
@@ -25,7 +35,8 @@ export interface DetectedWorkspace {
 
 const CONFIG_EXTENSIONS = ['ts', 'js', 'cjs', 'mjs', 'mts', 'cts']
 
-export function findProjectRoot(cwd: string): string {
+export function findProjectRoot(cwd: string, includeNativeRepository = false): string {
+  let swiftRoot: string | undefined
   let dir = cwd
   while (true) {
     if (
@@ -37,22 +48,30 @@ export function findProjectRoot(cwd: string): string {
       return dir
     }
 
-    const pkgPath = join(dir, 'package.json')
-    if (existsSync(pkgPath)) {
-      try {
-        const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'))
-        if (pkg.workspaces) return dir
-      } catch {}
-    }
+    if (metadataValue(readProjectJson(join(dir, 'package.json')), 'workspaces'))
+      return dir
 
+    if (includeNativeRepository) {
+      if (existsSync(join(dir, '.git'))) return dir
+      if (!swiftRoot && existsSync(join(dir, 'Package.swift'))) swiftRoot = dir
+    }
     const parent = dirname(dir)
     if (parent === dir) break
     dir = parent
   }
-  return cwd
+  return swiftRoot ?? cwd
 }
 
 export function detectPackageManager(root: string): PackageManager {
+  const manager = metadataValue(
+    readProjectJson(join(root, 'package.json')),
+    'packageManager',
+  )
+  if (typeof manager === 'string') {
+    const name = manager.split('@')[0]
+    if (name === 'bun' || name === 'pnpm' || name === 'npm' || name === 'yarn')
+      return name
+  }
   if (existsSync(join(root, 'bun.lock')) || existsSync(join(root, 'bun.lockb'))) {
     return 'bun'
   }
@@ -66,13 +85,9 @@ export function detectMonorepoType(root: string): MonorepoType {
   if (existsSync(join(root, 'nx.json'))) return 'nx'
   if (existsSync(join(root, 'pnpm-workspace.yaml'))) return 'pnpm'
 
-  const pkgPath = join(root, 'package.json')
-  if (existsSync(pkgPath)) {
-    try {
-      const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'))
-      if (pkg.workspaces) return 'npm-workspaces'
-    } catch {}
-  }
+  if (existsSync(join(root, 'lerna.json'))) return 'lerna'
+  if (metadataValue(readProjectJson(join(root, 'package.json')), 'workspaces'))
+    return 'npm-workspaces'
   return 'single'
 }
 
@@ -87,14 +102,14 @@ export function detectProject(dir: string): DetectedProject | null {
   const pkgPath = join(dir, 'package.json')
   if (!existsSync(pkgPath)) return null
 
-  let pkg: any
-  try {
-    pkg = JSON.parse(readFileSync(pkgPath, 'utf8'))
-  } catch {
-    return null
-  }
+  const pkg = readProjectManifest(dir)
+  if (!pkg) return null
 
   const deps = { ...pkg.dependencies, ...pkg.devDependencies }
+  const devCommand = metadataValue(
+    metadataValue(readProjectJson(pkgPath), 'scripts'),
+    'dev',
+  )
   const framework = detectFramework(deps)
 
   if (framework === 'unknown') return null
@@ -112,7 +127,7 @@ export function detectProject(dir: string): DetectedProject | null {
     hasMetroConfig: CONFIG_EXTENSIONS.some((ext) =>
       existsSync(join(dir, `metro.config.${ext}`)),
     ),
-    devCommand: pkg.scripts?.dev || null,
+    devCommand: typeof devCommand === 'string' ? devCommand : null,
   }
 }
 
@@ -199,3 +214,251 @@ export function scanWorkspace(root: string): DetectedWorkspace {
 
   return { root, type, packageManager, apps }
 }
+
+// reports inspect metadata without evaluating app config or following directory
+// symlinks. this also finds native projects outside package-manager workspaces.
+const REPORT_SKIP_DIRS = new Set([
+  'node_modules',
+  'Pods',
+  'Carthage',
+  'build',
+  'dist',
+  'dist-lib',
+  'DerivedData',
+  'vendor',
+  'coverage',
+  'target',
+  'tmp',
+  'cache',
+  'artifacts',
+  'test-results',
+  'playwright-report',
+])
+
+export function scanRepository(root: string): {
+  directories: string[]
+  truncated: boolean
+  unreadable: number
+} {
+  const directories: string[] = []
+  const pending = [{ dir: root, depth: 0 }]
+  let entries = 0
+  let cursor = 0
+  let truncated = false
+  let unreadable = 0
+  while (cursor < pending.length && entries < 200_000 && directories.length < 10_000) {
+    const next = pending[cursor++]
+    if (!next) break
+    directories.push(next.dir)
+    let handle: ReturnType<typeof opendirSync>
+    try {
+      handle = opendirSync(next.dir)
+    } catch {
+      unreadable++
+      continue
+    }
+    try {
+      let entry
+      while (entries < 200_000 && (entry = handle.readSync())) {
+        entries++
+        if (
+          !entry.isDirectory() ||
+          entry.name.startsWith('.') ||
+          REPORT_SKIP_DIRS.has(entry.name)
+        )
+          continue
+        if (next.depth >= 12) {
+          truncated = true
+          continue
+        }
+        pending.push({ dir: join(next.dir, entry.name), depth: next.depth + 1 })
+      }
+    } finally {
+      handle.closeSync()
+    }
+  }
+  return {
+    directories: directories.sort(),
+    truncated: truncated || cursor < pending.length || entries >= 200_000,
+    unreadable,
+  }
+}
+
+// inspect only regular, bounded metadata files. errors are data, never a reason
+// to execute project code. symlinks may point outside the checkout.
+export function readProjectMetadata(path: string): string | null {
+  try {
+    const info = lstatSync(path)
+    if (!info.isFile() || info.size > 4 * 1024 * 1024) return null
+    return readFileSync(path, 'utf8')
+  } catch {
+    return null
+  }
+}
+
+export function metadataValue(value: unknown, key: string): unknown {
+  if (!value || typeof value !== 'object') return undefined
+  return Object.getOwnPropertyDescriptor(value, key)?.value
+}
+
+export function readProjectJson(path: string): unknown {
+  const text = readProjectMetadata(path)
+  if (text === null) return null
+  try {
+    const value: unknown = JSON.parse(text)
+    return value
+  } catch {
+    return null
+  }
+}
+
+export function readProjectManifest(dir: string): ProjectManifest | null {
+  const parsed = readProjectJson(join(dir, 'package.json'))
+  if (!parsed || typeof parsed !== 'object') return null
+  const record = (value: unknown): Record<string, string> => {
+    if (!value || typeof value !== 'object') return {}
+    return Object.fromEntries(
+      Object.entries(value).filter(
+        (entry): entry is [string, string] =>
+          typeof entry[1] === 'string' &&
+          /^(?:@[a-z0-9._-]+\/)?[a-z0-9._-]+$/i.test(entry[0]) &&
+          entry[0] !== '.' &&
+          entry[0] !== '..',
+      ),
+    )
+  }
+  const name = metadataValue(parsed, 'name')
+  return {
+    ...(typeof name === 'string' ? { name } : {}),
+    dependencies: record(metadataValue(parsed, 'dependencies')),
+    devDependencies: record(metadataValue(parsed, 'devDependencies')),
+  }
+}
+
+// resolve each dependency at its nearest installation/lockfile boundary, so an
+// uninstalled nested project never inherits another app's hoisted version.
+export function resolveManifestVersions(
+  dir: string,
+  manifest: ProjectManifest,
+  locks = new Map<string, Map<string, string>>(),
+): Record<string, DependencyVersion> {
+  const resolveVersion = (name: string, declared: string): DependencyVersion => {
+    if (!/^(?:@[a-z0-9._-]+\/)?[a-z0-9._-]+$/i.test(name))
+      return { version: declared, source: 'declared' }
+    let current = dir
+    while (true) {
+      // installed packages commonly use symlinks; read just this known manifest,
+      // never traverse their dependency trees.
+      try {
+        const file = join(current, 'node_modules', name, 'package.json')
+        if (statSync(file).size <= 256 * 1024) {
+          const value: unknown = JSON.parse(readFileSync(file, 'utf8'))
+          const version = metadataValue(value, 'version')
+          if (typeof version === 'string') return { version, source: 'installed' }
+        }
+      } catch {}
+      let lock = locks.get(current)
+      if (!lock) {
+        lock = readLockedVersions(current)
+        locks.set(current, lock)
+      }
+      const version = lock.get(name)
+      if (version) return { version, source: 'lockfile' }
+      if (
+        [
+          'bun.lock',
+          'bun.lockb',
+          'package-lock.json',
+          'pnpm-lock.yaml',
+          'yarn.lock',
+        ].some((file) => existsSync(join(current, file)))
+      )
+        break
+      const parent = dirname(current)
+      if (parent === current) break
+      current = parent
+    }
+    return { version: declared, source: 'declared' }
+  }
+  return Object.fromEntries(
+    Object.entries({ ...manifest.dependencies, ...manifest.devDependencies }).map(
+      ([name, declared]) => [name, resolveVersion(name, declared)],
+    ),
+  )
+}
+
+function readLockedVersions(dir: string): Map<string, string> {
+  const versions = new Map<string, string>()
+  const put = (name: string, value: unknown) => {
+    if (typeof value !== 'string') return
+    // multiple resolutions without an installed tree are ambiguous; report the
+    // declared range rather than choosing a transitive package's version.
+    const before = versions.get(name)
+    versions.set(name, before === undefined || before === value ? value : '')
+  }
+  const bun = readProjectMetadata(join(dir, 'bun.lock'))
+  if (bun) {
+    try {
+      const rootVersions = new Map<string, string>()
+      const parsed: unknown = JSON5.parse(bun)
+      const packages = metadataValue(parsed, 'packages')
+      if (packages && typeof packages === 'object') {
+        for (const [key, tuple] of Object.entries(packages)) {
+          if (!Array.isArray(tuple) || typeof tuple[0] !== 'string') continue
+          const match = /^((?:@[^/]+\/)?[^@]+)@([\d][\w.+-]*)$/.exec(tuple[0])
+          if (match) put(match[1], match[2])
+          // bun's root resolution wins over nested duplicate package keys.
+          if (match && key === match[1]) rootVersions.set(match[1], match[2])
+        }
+      }
+      for (const [name, version] of rootVersions) versions.set(name, version)
+    } catch {}
+  }
+  const npm = metadataValue(readProjectJson(join(dir, 'package-lock.json')), 'packages')
+  if (npm && typeof npm === 'object') {
+    for (const [key, value] of Object.entries(npm)) {
+      if (key.startsWith('node_modules/') && !key.slice(13).includes('/node_modules/'))
+        put(key.slice(13), metadataValue(value, 'version'))
+    }
+  }
+  const pnpm = readProjectMetadata(join(dir, 'pnpm-lock.yaml'))
+  if (pnpm) {
+    try {
+      const parsed: unknown = parseYaml(pnpm)
+      const packages = metadataValue(parsed, 'packages')
+      if (packages && typeof packages === 'object')
+        for (const key of Object.keys(packages)) {
+          const match = /^\/?((?:@[^/]+\/)?[^@]+)@([\d][\w.+-]*)/.exec(key)
+          if (match) put(match[1], match[2])
+        }
+    } catch {}
+  }
+  const yarn = readProjectMetadata(join(dir, 'yarn.lock'))
+  if (yarn) {
+    let names: string[] = []
+    for (const line of yarn.split('\n')) {
+      if (/^\S.*:\s*$/.test(line))
+        names = [...line.matchAll(/(?:^|[", ]+)((?:@[^/\s]+\/)?[^@" ,]+)@/g)].map(
+          (match) => match[1],
+        )
+      const version = /^\s+version[ :]+["']?([\d][\w.+-]*)/.exec(line)
+      if (version) for (const name of names) put(name, version[1])
+    }
+  }
+  return versions
+}
+
+export function installedManifest(
+  dir: string,
+  manifest: ProjectManifest,
+): ProjectManifest {
+  const versions = resolveManifestVersions(dir, manifest)
+  const mapped = (deps: Record<string, string> | undefined) =>
+    deps &&
+    Object.fromEntries(Object.keys(deps).map((name) => [name, versions[name].version]))
+  return {
+    name: manifest.name,
+    dependencies: mapped(manifest.dependencies),
+    devDependencies: mapped(manifest.devDependencies),
+  }
+}

package/cli/commands/device.ts

@@ -1,11 +1,10 @@
 import {
   devices,
-  DUO_REST_PROGRESS,
   getDevice,
   listSelectableDeviceModels,
   type DeviceModel,
-  type DuoFoldRest,
-} from 'peach-engine/settings'
+} from 'peach-engine/settings/devices'
+import { DUO_REST_PROGRESS, type DuoFoldRest } from 'peach-engine/settings/duo-fold-bus'
 import { SOOTSIM_SHELL_COMMAND_NAME } from '../../src/menu'
 import { rnxExit } from '../run-rnx'
 import {

package/cli/commands/inspect/actions.ts

@@ -332,6 +332,8 @@ function payloadFromResolved(
 interface TextCandidate {
   node: SimSemanticNode
   ancestorTestIDs: string[]
+  actionable: boolean
+  role?: string
 }
 
 // a non-pressable node repeating the text of its nearest labelled ancestor,
@@ -343,16 +345,28 @@ function collectTextCandidates(
   nodes: readonly SimSemanticNode[],
   ancestors: string[] = [],
   pressableOwnerText = '',
+  actionableAncestor = false,
+  actionableRole?: string,
 ): TextCandidate[] {
   const out: TextCandidate[] = []
   for (const node of nodes) {
     const text = nodeText(node)
     const caption = !!text && text === pressableOwnerText && !node.pressable
-    if (!caption) out.push({ node, ancestorTestIDs: ancestors })
+    const actionable = !!node.pressable || actionableAncestor
+    const role = node.role ?? actionableRole
+    if (!caption) out.push({ node, ancestorTestIDs: ancestors, actionable, role })
     if (node.children?.length) {
       const next = node.testID ? [...ancestors, node.testID] : ancestors
       const owner = text ? (node.pressable ? text : '') : pressableOwnerText
-      out.push(...collectTextCandidates(node.children, next, owner))
+      out.push(
+        ...collectTextCandidates(
+          node.children,
+          next,
+          owner,
+          actionable,
+          node.pressable ? node.role : actionableRole,
+        ),
+      )
     }
   }
   return out
@@ -388,93 +402,112 @@ export async function tapByText(
     agent: opts.agent,
     timing: opts.timing,
     textFallback: query,
-    resolve: async () => {
-      const { tree } = await inspectTree(bridge, 50)
-      if (!Array.isArray(tree)) return { matched: 0, total: 0 }
-      const needle = options.exact ? query : query.toLowerCase()
-      let candidates = collectTextCandidates(tree).filter(({ node, ancestorTestIDs }) => {
-        const text = nodeText(node)
-        if (!text) return false
-        if (options.exact ? text !== needle : !text.toLowerCase().includes(needle)) {
-          return false
-        }
-        if (options.role && node.role !== options.role) return false
-        if (options.within && !ancestorTestIDs.includes(options.within)) return false
-        const ax = node.geometry.x
-        const ay = node.geometry.y
-        if (options.minX != null && !(ax >= options.minX)) return false
-        if (options.maxX != null && !(ax <= options.maxX)) return false
-        if (options.minY != null && !(ay >= options.minY)) return false
-        if (options.maxY != null && !(ay <= options.maxY)) return false
-        return true
-      })
+    resolve: () => resolveTextTapTarget(bridge, query, options),
+  })
+}
 
-      if (options.near) {
-        const { x, y } = options.near
-        candidates.sort(
-          (a, b) =>
-            Math.hypot(a.node.geometry.x - x, a.node.geometry.y - y) -
-            Math.hypot(b.node.geometry.x - x, b.node.geometry.y - y),
-        )
-      } else {
-        candidates.sort((a, b) => {
-          if (Math.abs(a.node.geometry.y - b.node.geometry.y) > 2) {
-            return a.node.geometry.y - b.node.geometry.y
-          }
-          return a.node.geometry.x - b.node.geometry.x
-        })
+async function resolveTextTapTarget(
+  bridge: InspectBridge,
+  query: string,
+  options: TapTextOptions = {},
+) {
+  const { tree } = await inspectTree(bridge, 50)
+  if (!Array.isArray(tree)) return { matched: 0, total: 0 }
+  const needle = options.exact ? query : query.toLowerCase()
+  let candidates = collectTextCandidates(tree).filter(
+    ({ node, ancestorTestIDs, role }) => {
+      const text = nodeText(node)
+      if (!text) return false
+      if (options.exact ? text !== needle : !text.toLowerCase().includes(needle)) {
+        return false
       }
+      if (options.role && role !== options.role) return false
+      if (options.within && !ancestorTestIDs.includes(options.within)) return false
+      const ax = node.geometry.x
+      const ay = node.geometry.y
+      if (options.minX != null && !(ax >= options.minX)) return false
+      if (options.maxX != null && !(ax <= options.maxX)) return false
+      if (options.minY != null && !(ay >= options.minY)) return false
+      if (options.maxY != null && !(ay <= options.maxY)) return false
+      return true
+    },
+  )
 
-      const total = candidates.length
-      if (total === 0) return { matched: 0, total: 0 }
+  // default label taps prefer controls to prose mentioning the same word.
+  // explicit position selectors keep their full candidate list and order.
+  if (options.nth == null && !options.first && !options.near) {
+    const actionable = candidates.filter((candidate) => candidate.actionable)
+    if (actionable.length > 0) candidates = actionable
+  }
 
-      let idx = 0
-      if (options.nth != null) {
-        idx = options.nth < 0 ? total + options.nth : options.nth
-        if (idx < 0 || idx >= total) {
-          return { matched: 0, total, nthOutOfRange: true, nth: options.nth }
-        }
-      } else if (total > 1 && !options.first && !options.near) {
-        return {
-          ambiguous: true,
-          total,
-          candidates: candidates.slice(0, 10).map((candidate, index) => ({
-            idx: index,
-            nodeId: candidate.node.nodeId,
-            type: candidate.node.type,
-            testID: candidate.node.testID ?? null,
-            text: nodeText(candidate.node).slice(0, 60),
-            abs: { x: candidate.node.geometry.x, y: candidate.node.geometry.y },
-            layout: {
-              width: Math.round(candidate.node.geometry.width),
-              height: Math.round(candidate.node.geometry.height),
-            },
-            ancestorTestIDs: candidate.ancestorTestIDs.slice(0, 5),
-          })),
-        }
+  if (options.near) {
+    const { x, y } = options.near
+    candidates.sort(
+      (a, b) =>
+        Math.hypot(a.node.geometry.x - x, a.node.geometry.y - y) -
+        Math.hypot(b.node.geometry.x - x, b.node.geometry.y - y),
+    )
+  } else {
+    candidates.sort((a, b) => {
+      if (Math.abs(a.node.geometry.y - b.node.geometry.y) > 2) {
+        return a.node.geometry.y - b.node.geometry.y
       }
+      return a.node.geometry.x - b.node.geometry.x
+    })
+  }
 
-      const picked = candidates[idx]
-      if (!picked) return { matched: 0, total }
-      const node = picked.node
-      let resolved = node.testID
-        ? await resolveTargetCoords(bridge, { mode: 'testid', value: node.testID })
-        : await resolveTargetCoords(bridge, {
-            mode: 'text',
-            value: nodeText(node) || query,
-          })
-      if (!resolved) {
-        resolved = {
-          x: node.geometry.x + node.geometry.width / 2,
-          y: node.geometry.y + node.geometry.height / 2,
-          testID: node.testID ?? null,
-          text: nodeText(node) || query,
-          type: node.type,
-        }
-      }
-      return payloadFromResolved(resolved, node, { total, idx })
-    },
+  const total = candidates.length
+  if (total === 0) return { matched: 0, total: 0 }
+
+  let idx = 0
+  if (options.nth != null) {
+    idx = options.nth < 0 ? total + options.nth : options.nth
+    if (idx < 0 || idx >= total) {
+      return { matched: 0, total, nthOutOfRange: true, nth: options.nth }
+    }
+  } else if (total > 1 && !options.first && !options.near) {
+    return {
+      ambiguous: true,
+      total,
+      candidates: candidates.slice(0, 10).map((candidate, index) => ({
+        idx: index,
+        nodeId: candidate.node.nodeId,
+        type: candidate.node.type,
+        testID: candidate.node.testID ?? null,
+        text: nodeText(candidate.node).slice(0, 60),
+        abs: { x: candidate.node.geometry.x, y: candidate.node.geometry.y },
+        layout: {
+          width: Math.round(candidate.node.geometry.width),
+          height: Math.round(candidate.node.geometry.height),
+        },
+        ancestorTestIDs: candidate.ancestorTestIDs.slice(0, 5),
+      })),
+    }
+  }
+
+  const picked = candidates[idx]
+  if (!picked) return { matched: 0, total }
+  const node = picked.node
+  // keep the selected handle: re-searching its text or testID can pick a
+  // different control, including a covered tenant behind native UI.
+  const tap: unknown = await bridge.send({
+    type: 'call',
+    path: 'SootSim.bridges.test.resolveTapTarget',
+    args: [node.nodeId],
   })
+  if (!isTapTargetInfo(tap)) return { matched: 0, total }
+  return payloadFromResolved(
+    {
+      x: tap.cx,
+      y: tap.cy,
+      nodeId: tap.target.nodeId,
+      testID: tap.target.testID,
+      text: tap.target.text ?? tap.target.accessibilityLabel,
+      type: tap.target.type,
+    },
+    node,
+    { total, idx },
+  )
 }
 
 export type TapQuery =
@@ -570,17 +603,19 @@ export async function tapBest(
           },
         }
       }
-      const byText = await resolveTargetCoords(bridge, { mode: 'text', value: query })
-      if (byText) {
+      const byText = await resolveTextTapTarget(bridge, query)
+      if ('ambiguous' in byText) {
+        return {
+          ambiguous: true,
+          error: `multiple text matches for "${query}"; use tap-text with --nth, --within or --near`,
+        }
+      }
+      if ('cx' in byText && typeof byText.cx === 'number') {
         return {
-          ...payloadFromResolved(byText, byText),
+          ...byText,
           strategy: 'text',
           node: {
-            nodeId: byText.nodeId ?? null,
-            id: byText.testID ?? null,
-            testID: byText.testID ?? null,
-            type: byText.type ?? null,
-            text: byText.text ?? query,
+            ...byText.target,
           },
         }
       }

package/cli/commands/inspect/core.ts

@@ -1287,7 +1287,7 @@ export interface ConsoleEntry {
 // One root error boundary in the tenant worker) can be live and screaming in
 // the driver's console while the agent's `sootsim_errors` reports nothing.
 // Merge both, dedup, so worker + root-error-boundary failures always surface.
-function consoleEntriesEval(level: 'error' | 'warn', limit: number): string {
+export function consoleEntriesEval(level: 'error' | 'warn', limit: number): string {
   const getter = level === 'error' ? 'getErrors' : 'getWarnings'
   return `(() => {
     const out = []