peachsim 0.1.577 → 0.1.579

package/src/attached-projects.ts

@@ -97,9 +97,6 @@ export function setUserDataDir(dir: string | null): void {
   overrideDir = dir
 }
 
-/** back-compat alias retained for existing test imports. */
-export const __setUserDataDirForTests = setUserDataDir
-
 /** resolve the user-data directory where attached-projects.json lives.
  *  precedence:
  *    1. explicit override from setUserDataDir() (tests, CLI bootstrap)
@@ -205,10 +202,6 @@ function newSessionId(): string {
   return `s_${randomBytes(10).toString('hex')}`
 }
 
-function newPreviewId(): string {
-  return `pa_${randomBytes(10).toString('hex')}`
-}
-
 // --- project CRUD ---
 
 /** upsert by canonicalized cwd — cwd is the unique index. `input.id` is
@@ -271,30 +264,6 @@ export function findProjectById(id: string): AttachedProject | null {
   return loadStore().attachedProjects.find((p) => p.id === id) ?? null
 }
 
-export function findProjectByCwd(cwd: string): AttachedProject | null {
-  const resolved = path.resolve(cwd)
-  return loadStore().attachedProjects.find((p) => p.cwd === resolved) ?? null
-}
-
-export function findProjectByBundleUrl(bundleUrl: string): AttachedProject | null {
-  // first exact match, then prefix match. the prefix path handles metro query
-  // param drift (?platform=ios&dev=true) so the same base URL binds.
-  const store = loadStore()
-  const exact = store.attachedProjects.find((p) => p.knownBundleUrls.includes(bundleUrl))
-  if (exact) return exact
-  const base = stripQuery(bundleUrl)
-  return (
-    store.attachedProjects.find((p) =>
-      p.knownBundleUrls.some((u) => stripQuery(u) === base),
-    ) ?? null
-  )
-}
-
-function stripQuery(url: string): string {
-  const q = url.indexOf('?')
-  return q >= 0 ? url.slice(0, q) : url
-}
-
 export function listProjects(): AttachedProject[] {
   return loadStore().attachedProjects
 }
@@ -452,47 +421,6 @@ export function deleteSession(id: string): void {
   })
 }
 
-// --- preview attachment CRUD ---
-
-export function upsertPreviewAttachment(
-  input: Partial<PreviewAttachment> & { bundleUrl: string; simId: string },
-): PreviewAttachment {
-  let result!: PreviewAttachment
-  mutateStore((store) => {
-    const existing = store.previewAttachments.find(
-      (pa) => pa.bundleUrl === input.bundleUrl && pa.simId === input.simId,
-    )
-    if (existing) {
-      const merged: PreviewAttachment = {
-        ...existing,
-        ...input,
-        lastSeenAt: Date.now(),
-      }
-      const idx = store.previewAttachments.indexOf(existing)
-      store.previewAttachments[idx] = merged
-      result = merged
-      return
-    }
-    const created: PreviewAttachment = {
-      id: input.id ?? newPreviewId(),
-      projectId: input.projectId ?? null,
-      bundleUrl: input.bundleUrl,
-      simId: input.simId,
-      deviceModel: input.deviceModel ?? 'unknown',
-      status: input.status ?? 'connecting',
-      lastSeenAt: Date.now(),
-    }
-    store.previewAttachments.push(created)
-    result = created
-  })
-  return result
-}
-
-export function listPreviewAttachments(projectId?: string): PreviewAttachment[] {
-  const all = loadStore().previewAttachments
-  return projectId ? all.filter((pa) => pa.projectId === projectId) : all
-}
-
 export function deletePreviewAttachment(id: string): void {
   mutateStore((store) => {
     store.previewAttachments = store.previewAttachments.filter((pa) => pa.id !== id)

package/src/backend-origin.ts

@@ -29,6 +29,16 @@ export function isLoopbackHost(hostname: string): boolean {
   )
 }
 
+// the origin of a url whose host is loopback, or null for any other or unparsable url
+export function loopbackOriginOf(value: string): string | null {
+  try {
+    const url = new URL(value)
+    return isLoopbackHost(url.hostname) ? url.origin : null
+  } catch {
+    return null
+  }
+}
+
 export function buildBrowserAssetProxyUrl(targetUrl: string): string {
   const proxyPath = isLoopbackHost(new URL(targetUrl).hostname)
     ? '/__bundle-proxy'

package/src/bridge-contract-input.ts

@@ -13,6 +13,7 @@ import type {
 } from './bridge-contract'
 import type { SimPerformStep, SimScreenshotOptions } from './sim-client'
 import type { SootSimReplayTarget } from '@peach/globals'
+import { isRecord } from './is-record'
 
 /** the caller sent a value this bridge argument cannot be read from. */
 export class BridgeInputError extends Error {
@@ -28,12 +29,8 @@ function validationFailure(path: string, expectation: string): never {
   throw new BridgeInputError(`${path} ${expectation}`)
 }
 
-function isRecordValue(value: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === 'object' && !Array.isArray(value)
-}
-
 function recordValue(value: unknown, path: string): Record<string, unknown> {
-  if (!isRecordValue(value)) {
+  if (!isRecord(value)) {
     validationFailure(path, 'must be an object')
   }
   return value

package/src/bridge-contract.ts

@@ -471,6 +471,8 @@ export interface SimSemanticNode {
   role?: string
   label?: string
   pressable?: true
+  /** painted but hidden from the accessibility tree, as VoiceOver sees it */
+  accessibilityHidden?: true
   geometry: SimSemanticGeometry
   children?: SimSemanticNode[]
 }

package/src/capture-contract.ts

@@ -243,13 +243,14 @@ export function rnxRasterFrames(
       width: node.layout.width,
       height: node.layout.height,
     }
-    const liquidGlass = node.style._liquidGlass
-    const capturePadding =
-      liquidGlass &&
-      typeof liquidGlass === 'object' &&
-      typeof Reflect.get(liquidGlass, 'capturePadding') === 'number'
-        ? Reflect.get(liquidGlass, 'capturePadding')
-        : 0
+    // a region is what the node paints, and nothing else: a producer that crops
+    // a composited screenshot copies every pixel inside it, so any margin past
+    // the paint carries neighbours (a header title, a hairline, a list row)
+    // frozen at their own positions over the ones the tree redraws. glass
+    // paints its shape plus the box shadows the material casts (shadow,
+    // tallShadow, contour). its capturePadding is the backdrop the shader
+    // samples for refraction, which it never paints, so it is not an outset.
+    const glassOutset = liquidGlassPaintOutset(node.style._liquidGlass, frame)
     const shadowRadius =
       typeof node.style.shadowRadius === 'number' ? node.style.shadowRadius : 0
     const shadowOffset = node.style.shadowOffset
@@ -267,19 +268,21 @@ export function rnxRasterFrames(
         : 0
     const left = Math.max(
       0,
-      frame.x - Math.max(capturePadding, shadowRadius - shadowOffsetX),
+      frame.x - Math.max(glassOutset.x, shadowRadius - shadowOffsetX, 0),
     )
     const top = Math.max(
       0,
-      frame.y - Math.max(capturePadding, shadowRadius - shadowOffsetY),
+      frame.y - Math.max(glassOutset.top, shadowRadius - shadowOffsetY, 0),
     )
     const right = Math.min(
       tree.width,
-      frame.x + frame.width + Math.max(capturePadding, shadowRadius + shadowOffsetX),
+      frame.x + frame.width + Math.max(glassOutset.x, shadowRadius + shadowOffsetX, 0),
     )
     const bottom = Math.min(
       tree.height,
-      frame.y + frame.height + Math.max(capturePadding, shadowRadius + shadowOffsetY),
+      frame.y +
+        frame.height +
+        Math.max(glassOutset.bottom, shadowRadius + shadowOffsetY, 0),
     )
     if (right > left && bottom > top) {
       frames.set(node.nodeId, {
@@ -293,6 +296,45 @@ export function rnxRasterFrames(
   return frames
 }
 
+// how far a liquid glass material paints past its shape: each box shadow it
+// casts (liquid-glass.ts drawLiquidGlassBoxShadow) is its rrect grown by spread,
+// moved by offsetY, and blurred to about three sigma. the tall shadow only
+// draws once the minor axis passes 62pt.
+function liquidGlassPaintOutset(
+  glass: unknown,
+  frame: RnxCaptureRect,
+): { x: number; top: number; bottom: number } {
+  const outset = { x: 0, top: 0, bottom: 0 }
+  if (!glass || typeof glass !== 'object') return outset
+  const contour = Reflect.get(glass, 'contour')
+  const shadows = [
+    Reflect.get(glass, 'shadow'),
+    Math.min(frame.width, frame.height) > 62 ? Reflect.get(glass, 'tallShadow') : null,
+    ...(Array.isArray(contour) ? contour : []),
+  ]
+  for (const shadow of shadows) {
+    if (!shadow || typeof shadow !== 'object') continue
+    const sigma = Reflect.get(shadow, 'sigma')
+    if (typeof sigma !== 'number') continue
+    const offsetY = Reflect.get(shadow, 'offsetY')
+    const spread = Reflect.get(shadow, 'spread')
+    const [spreadX, spreadY] =
+      typeof spread === 'number'
+        ? [spread, spread]
+        : Array.isArray(spread) &&
+            typeof spread[0] === 'number' &&
+            typeof spread[1] === 'number'
+          ? [spread[0], spread[1]]
+          : [0, 0]
+    const dy = typeof offsetY === 'number' ? offsetY : 0
+    const blur = sigma * 3
+    outset.x = Math.max(outset.x, spreadX + blur)
+    outset.top = Math.max(outset.top, spreadY + blur - dy)
+    outset.bottom = Math.max(outset.bottom, spreadY + blur + dy)
+  }
+  return outset
+}
+
 export function rnxCaptureRasterRegions(
   capture: RnxScreenCapture,
 ): RnxCaptureRegionRequest[] {

package/src/cloud.ts

@@ -25,7 +25,9 @@ import {
   type RnxCloudCreateReceipt,
   type RnxCloudScopedToken,
 } from './cloud-contract'
+import { isRecord } from './is-record'
 import { rnxPublicBrand } from './public-brand'
+import { sleep } from './sleep'
 import type { SimStateOptions } from './bridge-contract'
 
 export {
@@ -121,10 +123,6 @@ interface RemoteSimulatorSession {
   scopes: readonly RnxCloudCommandScope[]
 }
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === 'object' && !Array.isArray(value)
-}
-
 function normalizeCloudOrigin(source: string): string {
   let parsed: URL
   try {
@@ -210,10 +208,6 @@ function readRetryAfterMs(response: Response, text: string): number | null {
   return null
 }
 
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms))
-}
-
 // one fetch with the cloud retry policy: `rate_limited` waits out its
 // `retry-after` and 5xx goes again at once, each at most twice, and nothing
 // else is retried. the body is buffered only on a retryable status, so every
@@ -320,7 +314,8 @@ function readSimulatorCreate(
   claim: RnxCloudClaim
   artifact: RnxCloudBoxCreateReceipt['artifact']
 } {
-  if (!isRecord(value)) throw new Error('Peach Cloud create returned an invalid simulator')
+  if (!isRecord(value))
+    throw new Error('Peach Cloud create returned an invalid simulator')
   const claim = readClaim(value.claim)
   if (
     typeof value.simId !== 'string' ||

package/src/dev-server-open.ts

@@ -1,14 +1,11 @@
 import { spawn, type ChildProcess } from 'node:child_process'
 import { createHash } from 'node:crypto'
 import fs from 'node:fs'
-import http from 'node:http'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 
 export type RnxDesktopOpenOption = boolean | { appName: string }
 
-const scheduledMetroOpens = new Set<string>()
-
 export function resolveRnxDesktopAppName(
   open: RnxDesktopOpenOption | undefined,
   projectRoot: string,
@@ -100,99 +97,3 @@ export function launchRnxDesktop(bundleUrl: string, appName: string): void {
   )
   observeRnxDesktopLaunch(child, appName)
 }
-
-interface MetroDesktopOpenOptions {
-  port: number
-  bundleUrl: string
-  appName: string
-  projectRoot: string
-  serverId: string
-  intervalMs?: number
-  timeoutMs?: number
-  launch?: (bundleUrl: string, appName: string) => void
-}
-
-export function openRnxDesktopWhenMetroIsReady({
-  port,
-  bundleUrl,
-  appName,
-  projectRoot,
-  serverId,
-  intervalMs = 100,
-  timeoutMs = 30_000,
-  launch = launchRnxDesktop,
-}: MetroDesktopOpenOptions): Promise<boolean> {
-  const key = `${projectRoot}\0${port}`
-  if (scheduledMetroOpens.has(key)) return Promise.resolve(false)
-  scheduledMetroOpens.add(key)
-  const deadline = Date.now() + timeoutMs
-
-  return new Promise((resolve) => {
-    let finished = false
-    let retryTimer: ReturnType<typeof setTimeout> | undefined
-    const finish = (opened: boolean) => {
-      if (finished) return
-      finished = true
-      clearTimeout(retryTimer)
-      scheduledMetroOpens.delete(key)
-      resolve(opened)
-    }
-    const retry = () => {
-      if (finished) return
-      if (Date.now() >= deadline) {
-        console.error(
-          `[peach] could not open ${appName}: Metro did not become ready on port ${port}`,
-        )
-        finish(false)
-        return
-      }
-      retryTimer = setTimeout(check, intervalMs)
-    }
-    const check = () => {
-      const request = http.get(
-        `http://127.0.0.1:${port}/__server-scan`,
-        { headers: { Accept: 'application/json' } },
-        (response) => {
-          let body = ''
-          response.setEncoding('utf8')
-          response.on('data', (chunk: string) => {
-            body = `${body}${chunk}`.slice(0, 65_536)
-          })
-          response.once('end', () => {
-            try {
-              const scan: unknown = JSON.parse(body)
-              const matches =
-                response.statusCode === 200 &&
-                Array.isArray(scan) &&
-                scan.some((entry: unknown) => {
-                  if (!entry || typeof entry !== 'object') return false
-                  const scannedPort = Reflect.get(entry, 'port')
-                  const projectName = Reflect.get(entry, 'projectName')
-                  const scannedServerId = Reflect.get(entry, 'rnxServerId')
-                  const scannedBundle = Reflect.get(entry, 'bundleUrl')
-                  if (
-                    scannedPort !== port ||
-                    projectName !== appName ||
-                    scannedServerId !== serverId ||
-                    typeof scannedBundle !== 'string'
-                  ) {
-                    return false
-                  }
-                  return new URL(scannedBundle).searchParams.get('rnxAppName') === appName
-                })
-              if (matches) {
-                launch(bundleUrl, appName)
-                finish(true)
-                return
-              }
-            } catch {}
-            retry()
-          })
-        },
-      )
-      request.setTimeout(Math.min(1_000, timeoutMs), () => request.destroy())
-      request.once('error', retry)
-    }
-    check()
-  })
-}

package/src/home-paths.ts

@@ -432,9 +432,8 @@ export interface DaemonLockfile {
   /** epoch-ms of last heartbeat. daemons update this every ~5s; readers
    *  treat the lockfile as stale if now - heartbeatAt > DAEMON_HEARTBEAT_STALE_MS. */
   heartbeatAt: number
-  /** true while the daemon is still fetching/activating its runtime on first
-   *  boot. clients (electron splash, cli) should wait for this to become
-   *  false before treating the daemon as ready to serve. */
+  /** true while the daemon has no usable runtime and is fetching one on first
+   *  boot. an installed runtime serves while an update downloads. */
   bootstrapping?: boolean
 }
 

package/src/host/agent-host.ts

@@ -13,6 +13,7 @@
 //   { type: 'agent:event',         sessionId, event }
 //   { type: 'agent:session-status', session }
 
+import { randomUUID } from 'node:crypto'
 import fs from 'node:fs'
 import path from 'node:path'
 import {
@@ -43,12 +44,8 @@ import {
   type AgentSession,
   type AttachedProject,
 } from '../attached-projects.ts'
-import {
-  sendPromptToTeamMachineSession,
-  teamMachineSessionIdFromCliIdentity,
-} from '../team-machine-prompt.ts'
 import type { AgentEvent } from '../agent-events.ts'
-import type { AgentPromptEnvelope } from '../agent-prompt.ts'
+import type { AgentInspectMessage, AgentPromptEnvelope } from '../agent-prompt.ts'
 import type { WebSocket } from 'ws'
 
 // ws.readyState constant — avoid importing the module just for this enum.
@@ -70,15 +67,12 @@ export interface AgentHostOptions {
    *  the rest of the repo uses, so `peach serve` standalone does the
    *  right thing. */
   getExcludePorts?: () => number[]
-  /** returns the active CLI lease for a sim. used only for prompt routing to
-   *  an external Team Machine agent that claimed the tab. */
-  resolveCliLease?: (simId: string) => AgentCliLeaseSnapshot | null
 }
 
-export interface AgentCliLeaseSnapshot {
-  kind: 'cli' | 'user-active'
-  cliIdentityKey: string
-  expiresAt: number
+interface InspectListener {
+  socket: WebSocket
+  resolve: (message: AgentInspectMessage) => void
+  reject: (error: Error) => void
 }
 
 /** default excludes keep the dev-server scanner from hitting Contrast's own
@@ -105,6 +99,8 @@ export class AgentHost {
   // pushes so a CLI `peach agent sessions --watch` can react to state
   // changes driven by another client.
   private allSockets = new Set<WebSocket>()
+  private inspectQueues = new Map<string, AgentInspectMessage[]>()
+  private inspectListeners = new Map<string, InspectListener[]>()
   // agent wrappers also emit prompt-received from the FIFO reader, but the
   // shell/daemon already knows the user-facing display text when send-prompt
   // is accepted. emit the friendly prompt immediately and suppress the raw
@@ -139,6 +135,18 @@ export class AgentHost {
       }
       this.sessionsBySocket.delete(ws)
     }
+    for (const [simId, listeners] of this.inspectListeners) {
+      const remaining: InspectListener[] = []
+      for (const listener of listeners) {
+        if (listener.socket === ws) {
+          listener.reject(new AgentSessionError('DISCONNECT', 'listener disconnected'))
+        } else {
+          remaining.push(listener)
+        }
+      }
+      if (remaining.length > 0) this.inspectListeners.set(simId, remaining)
+      else this.inspectListeners.delete(simId)
+    }
     this.allSockets.delete(ws)
   }
 
@@ -188,6 +196,13 @@ export class AgentHost {
     }
     this.subscriptions.clear()
     this.sessionsBySocket.clear()
+    for (const listeners of this.inspectListeners.values()) {
+      for (const listener of listeners) {
+        listener.reject(new AgentSessionError('DISCONNECT', 'daemon closed'))
+      }
+    }
+    this.inspectListeners.clear()
+    this.inspectQueues.clear()
     this.allSockets.clear()
   }
 
@@ -208,8 +223,17 @@ export class AgentHost {
         return listSessions(msg.projectId ? String(msg.projectId) : undefined)
       case 'agent:start-session':
         return this.doStartSession(msg.input ?? {})
-      case 'agent:send-claimed-prompt':
-        return this.sendClaimedPrompt(msg)
+      case 'agent:listen-inspect':
+        return this.listenForInspect(ws, this.requireSimId(msg, type))
+      case 'agent:get-inspect-listener-status': {
+        const simId = this.requireSimId(msg, type)
+        return { simId, listening: (this.inspectListeners.get(simId)?.length ?? 0) > 0 }
+      }
+      case 'agent:send-inspect-message':
+        return this.sendInspectMessage(
+          this.requireSimId(msg, type),
+          this.normalizePromptEnvelope(msg),
+        )
       case 'agent:send-prompt': {
         const sessionId = String(msg.sessionId)
         const session = findSessionById(sessionId)
@@ -243,31 +267,53 @@ export class AgentHost {
 
   // --- operation impls ---
 
-  private async sendClaimedPrompt(msg: any): Promise<{
-    ok: true
-    routed: 'team-machine'
-    sessionId: string
-  }> {
+  private requireSimId(msg: any, type: string): string {
     const simId = typeof msg.simId === 'string' ? msg.simId.trim() : ''
-    if (!simId) {
-      throw new AgentSessionError('NO_SIM', 'agent:send-claimed-prompt requires simId')
-    }
-    const lease = this.opts.resolveCliLease?.(simId) ?? null
-    if (!lease || lease.kind !== 'cli' || lease.expiresAt <= Date.now()) {
-      throw new AgentSessionError('NO_CLAIM', `sim ${simId} has no active CLI claim`)
-    }
-    const sessionId = teamMachineSessionIdFromCliIdentity(lease.cliIdentityKey)
-    if (!sessionId) {
-      throw new AgentSessionError(
-        'UNSUPPORTED_CLAIM',
-        `sim ${simId} is claimed by a CLI identity that is not promptable`,
-      )
+    if (!simId) throw new AgentSessionError('NO_SIM', `${type} requires simId`)
+    return simId
+  }
+
+  private listenForInspect(
+    socket: WebSocket,
+    simId: string,
+  ): Promise<AgentInspectMessage> {
+    const queue = this.inspectQueues.get(simId)
+    const queued = queue?.shift()
+    if (queued && queue) {
+      if (queue.length === 0) this.inspectQueues.delete(simId)
+      return Promise.resolve(queued)
     }
-    await sendPromptToTeamMachineSession({
-      sessionId,
-      prompt: this.normalizePromptEnvelope(msg),
+    return new Promise((resolve, reject) => {
+      const listeners = this.inspectListeners.get(simId) ?? []
+      listeners.push({ socket, resolve, reject })
+      this.inspectListeners.set(simId, listeners)
     })
-    return { ok: true, routed: 'team-machine', sessionId }
+  }
+
+  private sendInspectMessage(
+    simId: string,
+    prompt: AgentPromptEnvelope,
+  ): { ok: true; queued: boolean; messageId: string } {
+    if (!prompt.text.trim()) {
+      throw new AgentSessionError('EMPTY_PROMPT', 'inspect message cannot be empty')
+    }
+    const message: AgentInspectMessage = {
+      id: `inspect-${randomUUID()}`,
+      simId,
+      createdAt: new Date().toISOString(),
+      prompt,
+    }
+    const listeners = this.inspectListeners.get(simId)
+    const listener = listeners?.shift()
+    if (listener && listeners) {
+      if (listeners.length === 0) this.inspectListeners.delete(simId)
+      listener.resolve(message)
+      return { ok: true, queued: false, messageId: message.id }
+    }
+    const queue = this.inspectQueues.get(simId) ?? []
+    queue.push(message)
+    this.inspectQueues.set(simId, queue)
+    return { ok: true, queued: true, messageId: message.id }
   }
 
   private async doStartSession(input: {

package/src/host/bridge-host.ts

@@ -484,17 +484,6 @@ export class SootSimBridgeHost {
     this.openUrlHandler = opts.openUrl
     this.agentHost = new AgentHost({
       getExcludePorts: opts.agentScanExcludes,
-      resolveCliLease: (simId) => {
-        const sim = this.sims.get(simId)
-        const lease = sim ? this.getActiveLease(sim) : null
-        return lease
-          ? {
-              kind: lease.kind,
-              cliIdentityKey: lease.cliIdentityKey,
-              expiresAt: lease.expiresAt,
-            }
-          : null
-      },
     })
     this.contrastOrigin = opts.contrastOrigin?.replace(/\/$/, '') || null
     this.simIdleReapTtlMs =
@@ -535,6 +524,11 @@ export class SootSimBridgeHost {
     // seed active runtime state from disk so the http routes + lockfile
     // reflect reality at boot. we reread this on runtime:use messages.
     this.refreshActiveRuntime()
+    // an installed runtime can serve while the startup update runs. only a
+    // machine without usable assets needs to wait for that download.
+    this.bootstrapping =
+      !this.activeRuntimeDirPath ||
+      !fs.existsSync(path.join(this.activeRuntimeDirPath, 'index.html'))
 
     for (let attempt = 0; attempt < this.portFallbackCount; attempt++) {
       const candidate = this.preferredPort + attempt