peachsim 0.1.630 → 0.1.632

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/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 = []

package/cli/commands/inspect.ts

@@ -20,6 +20,8 @@ import { shouldPrintInspectNotice } from '../inspect-notice-state'
 import { levenshtein } from '../levenshtein'
 import { TOP_LEVEL_RUNTIME_COMMANDS } from '../parse-args'
 import { rethrowIfExit, rnxExit } from '../run-rnx'
+import { collectRuntimeDiagnostics } from '../runtime-diagnostics'
+import { trackCliError } from '../telemetry'
 import {
   type BridgeTransportOption,
   callInBridge,
@@ -4639,6 +4641,7 @@ export async function runInspect(args: string[], opts: InspectOptions) {
     }
   } catch (err: any) {
     rethrowIfExit(err)
+    trackCliError(err)
     const message = err instanceof Error ? err.message : String(err)
     console.error(`  ${subcommand ?? 'peach'} failed: ${message}`)
     const unknownSim = /^no sim connected with id ([^;]+)(?:; connected sims: .+)?$/.exec(
@@ -4704,6 +4707,7 @@ export async function runInspect(args: string[], opts: InspectOptions) {
     }
     rnxExit(1)
   } finally {
+    if (subcommand !== 'list') await collectRuntimeDiagnostics(bridge)
     bridge.close()
   }
 }

package/cli/commands/maestro.ts

@@ -182,7 +182,11 @@ export function applyEnvFlags(args: string[]): string[] {
   const out: string[] = []
   for (let i = 0; i < args.length; i++) {
     const arg = args[i] as string
-    const inline = arg.startsWith('--env=') ? arg.slice('--env='.length) : null
+    const inline = arg.startsWith('--env=')
+      ? arg.slice('--env='.length)
+      : arg.startsWith('-e=')
+        ? arg.slice('-e='.length)
+        : null
     if (arg === '--env' || arg === '-e' || inline !== null) {
       const kv = inline ?? args[i + 1]
       if (!kv || !kv.includes('=')) {
@@ -244,7 +248,9 @@ const MAESTRO_COMPAT_VALUE_FLAGS = new Set([
   '--screen-size',
 ])
 
-function splitTagList(value: string): string[] {
+// shared with the cloud submitter, which resolves tag selection before any
+// hosted job exists the same way a local workspace run does.
+export function splitTagList(value: string): string[] {
   return value
     .split(',')
     .map((tag) => tag.trim())