peachsim 0.1.527

package/cli/browser-backend.ts

@@ -0,0 +1,44 @@
+import type {
+  RnxBrowserOperations,
+  RnxCommandBackend,
+  RnxCommandInvocation,
+  RnxExecutionContext,
+} from './command-contract'
+
+export function createRnxBrowserBackend(
+  operations: RnxBrowserOperations,
+): RnxCommandBackend {
+  return {
+    kind: 'browser',
+    execute(invocation: RnxCommandInvocation, context: RnxExecutionContext) {
+      switch (invocation.family) {
+        case 'preview':
+          return operations.selectPreview(invocation, context)
+        case 'runtime':
+          return operations.readRuntime(invocation, context)
+        case 'tree':
+          return operations.inspectTree(invocation, context)
+        case 'layout':
+          return operations.inspectLayout(invocation, context)
+        case 'find':
+          return operations.find(invocation, context)
+        case 'wait':
+          return operations.wait(invocation, context)
+        case 'action':
+          return operations.act(invocation, context)
+        case 'screenshot':
+          return operations.screenshot(invocation, context)
+        case 'logs':
+          return operations.readLogs(invocation, context)
+        case 'network':
+          return operations.readNetwork(invocation, context)
+        case 'storage':
+          return operations.accessStorage(invocation, context)
+        case 'history':
+          return operations.readHistory(invocation, context)
+        case 'evidence':
+          return operations.collectEvidence(invocation, context)
+      }
+    },
+  }
+}

package/cli/browser-evals.ts

@@ -0,0 +1,96 @@
+// browser-side evaluator snippets for CLI inspect commands.
+//
+// the rnx CLI ships some commands that need to observe the live
+// rnx tree or its rendered pixels. we send these strings over the rnx host's
+// `evaluate` handler.
+//
+// cropping happens once, in the capture module (`bridges.screenshot`),
+// via its `crop` option. these evals intentionally defer to that bridge
+// instead of reimplementing the dpr-aware crop math.
+
+export interface SampleRect {
+  x: number
+  y: number
+  w: number
+  h: number
+}
+
+// resolve a --id/--text matcher into a SampleRect using __sootsimTest.
+// returns null on miss so the caller can report a clear not-found error.
+export function buildResolveRectEval(matcher: { id?: string; text?: string }): string {
+  return `(async () => {
+    const __t = window.__sootsimTest
+    if (!__t) throw new Error('__sootsimTest not available')
+    const __id = ${JSON.stringify(matcher.id || '')}
+    const __text = ${JSON.stringify(matcher.text || '')}
+    let __node = null
+    if (__id) {
+      __node = (__t.findByTestId && await __t.findByTestId(__id)) ||
+               (__t.findById && await __t.findById(__id)) || null
+    } else if (__text) {
+      __node = __t.findByText ? await __t.findByText(__text) : null
+    }
+    if (!__node) return null
+    const __pos = __node.absolutePosition || { x: __node.layout?.x || 0, y: __node.layout?.y || 0 }
+    const __layout = __node.layout || {}
+    return {
+      x: __pos.x,
+      y: __pos.y,
+      w: __layout.width || 1,
+      h: __layout.height || 1,
+    }
+  })()`
+}
+
+// sample-color averages rgba pixels across a logical-coord rect. the eval
+// asks the capture bridge for an already-cropped PNG and then averages the
+// decoded ImageData in one pass.
+export function buildSampleColorEval(rect: SampleRect): string {
+  return `(async () => {
+    const __rect = ${JSON.stringify(rect)}
+    const __screenshot = window.__sootsimScreenshot
+    if (typeof __screenshot !== 'function') {
+      throw new Error('screenshot bridge not installed')
+    }
+    const __dataUrl = await __screenshot({ crop: __rect })
+    const __img = await new Promise((res, rej) => {
+      const img = new Image()
+      img.onload = () => res(img)
+      img.onerror = () => rej(new Error('failed to decode cropped screenshot'))
+      img.src = __dataUrl
+    })
+    const __w = __img.naturalWidth
+    const __h = __img.naturalHeight
+    const __canvas = document.createElement('canvas')
+    __canvas.width = __w
+    __canvas.height = __h
+    const __ctx = __canvas.getContext('2d')
+    if (!__ctx) throw new Error('could not acquire 2d context')
+    __ctx.drawImage(__img, 0, 0)
+    const __data = __ctx.getImageData(0, 0, __w, __h).data
+    const __n = __data.length / 4
+    let __r = 0, __g = 0, __b = 0, __a = 0
+    for (let __i = 0; __i < __data.length; __i += 4) {
+      __r += __data[__i]
+      __g += __data[__i + 1]
+      __b += __data[__i + 2]
+      __a += __data[__i + 3]
+    }
+    const __round = (v) => Math.round(v / __n)
+    const __rr = __round(__r), __gg = __round(__g), __bb = __round(__b), __aa = __round(__a)
+    const __hex =
+      '#' +
+      [__rr, __gg, __bb]
+        .map((v) => v.toString(16).padStart(2, '0'))
+        .join('')
+    const __dpr = window.devicePixelRatio || 1
+    return {
+      r: __rr, g: __gg, b: __bb, a: __aa,
+      hex: __hex,
+      samples: __n,
+      rect: { x: __rect.x, y: __rect.y, w: __rect.w, h: __rect.h },
+      deviceWidth: __w / __dpr,
+      deviceHeight: __h / __dpr,
+    }
+  })()`
+}

package/cli/cli-update.ts

@@ -0,0 +1,261 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { compareSemver } from '@contrast/runtime-delivery'
+import { getCliVersion } from '../src/cli-version'
+import { cliUpdateFilePath } from '../src/home-paths'
+import { isAgentEnv } from './commands/inspect/env'
+
+export const DEFAULT_CLI_RELEASE_ORIGIN = 'https://r2.rnxsim.com/rnx-cli'
+export const CLI_UPDATE_CHECK_INTERVAL_MS = 20 * 60 * 60 * 1000
+export const CLI_UPDATE_NOTIFICATION_COOLDOWN_MS = 7 * 24 * 60 * 60 * 1000
+
+const CLI_UPDATE_STATE_SCHEMA = 1 as const
+const CLI_VERSION_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/
+let stateWriteSequence = 0
+
+interface CliUpdateState {
+  schema: typeof CLI_UPDATE_STATE_SCHEMA
+  latestVersion: string | null
+  checkedAt: number
+  lastAttemptAt: number
+  lastNotifiedVersion: string | null
+  lastNotifiedAt: number
+}
+
+export interface CliUpdateAvailability {
+  currentVersion: string
+  latestVersion: string
+  outdated: boolean
+}
+
+export interface CliUpdateInvocation {
+  command: string | null
+  commandArgs: readonly string[]
+  exitCode: number
+  standalone: boolean
+  stderrIsTTY: boolean
+  stdoutIsTTY: boolean
+  version: boolean
+  env?: Readonly<Record<string, string | undefined>>
+}
+
+function emptyState(): CliUpdateState {
+  return {
+    schema: CLI_UPDATE_STATE_SCHEMA,
+    latestVersion: null,
+    checkedAt: 0,
+    lastAttemptAt: 0,
+    lastNotifiedVersion: null,
+    lastNotifiedAt: 0,
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object'
+}
+
+function isTimestamp(value: unknown): value is number {
+  return typeof value === 'number' && Number.isFinite(value) && value >= 0
+}
+
+function readState(): CliUpdateState {
+  try {
+    const parsed: unknown = JSON.parse(fs.readFileSync(cliUpdateFilePath(), 'utf8'))
+    if (
+      !isRecord(parsed) ||
+      parsed.schema !== CLI_UPDATE_STATE_SCHEMA ||
+      (parsed.latestVersion !== null &&
+        (typeof parsed.latestVersion !== 'string' ||
+          !CLI_VERSION_PATTERN.test(parsed.latestVersion))) ||
+      !isTimestamp(parsed.checkedAt) ||
+      !isTimestamp(parsed.lastAttemptAt) ||
+      (parsed.lastNotifiedVersion !== null &&
+        (typeof parsed.lastNotifiedVersion !== 'string' ||
+          !CLI_VERSION_PATTERN.test(parsed.lastNotifiedVersion))) ||
+      !isTimestamp(parsed.lastNotifiedAt)
+    ) {
+      return emptyState()
+    }
+    return {
+      schema: CLI_UPDATE_STATE_SCHEMA,
+      latestVersion: parsed.latestVersion,
+      checkedAt: parsed.checkedAt,
+      lastAttemptAt: parsed.lastAttemptAt,
+      lastNotifiedVersion: parsed.lastNotifiedVersion,
+      lastNotifiedAt: parsed.lastNotifiedAt,
+    }
+  } catch {
+    return emptyState()
+  }
+}
+
+function writeState(state: CliUpdateState): boolean {
+  const file = cliUpdateFilePath()
+  const temporary = `${file}.tmp-${process.pid}-${stateWriteSequence++}`
+  try {
+    fs.mkdirSync(path.dirname(file), { recursive: true })
+    fs.writeFileSync(temporary, `${JSON.stringify(state)}\n`, 'utf8')
+    fs.renameSync(temporary, file)
+    return true
+  } catch {
+    try {
+      fs.rmSync(temporary, { force: true })
+    } catch {}
+    return false
+  }
+}
+
+function availability(
+  state: CliUpdateState,
+  currentVersion = getCliVersion(),
+): CliUpdateAvailability | null {
+  if (!state.latestVersion) return null
+  return {
+    currentVersion,
+    latestVersion: state.latestVersion,
+    outdated: compareSemver(state.latestVersion, currentVersion) > 0,
+  }
+}
+
+function envFlagIsOff(value: string | undefined): boolean {
+  return (
+    value === '0' || value?.toLowerCase() === 'false' || value?.toLowerCase() === 'off'
+  )
+}
+
+function envFlagIsOn(value: string | undefined): boolean {
+  return Boolean(value) && !envFlagIsOff(value)
+}
+
+export function automaticCliUpdateChecksEnabled(
+  env: Readonly<Record<string, string | undefined>> = process.env,
+): boolean {
+  return !envFlagIsOff(env.RNX_UPDATE_CHECK)
+}
+
+export function shouldUseAutomaticCliUpdateCheck(
+  invocation: CliUpdateInvocation,
+): boolean {
+  const env = invocation.env ?? process.env
+  if (
+    !invocation.standalone ||
+    invocation.exitCode !== 0 ||
+    invocation.version ||
+    !invocation.stdoutIsTTY ||
+    !invocation.stderrIsTTY ||
+    !automaticCliUpdateChecksEnabled(env) ||
+    envFlagIsOn(env.CI) ||
+    envFlagIsOn(env.GITHUB_ACTIONS) ||
+    envFlagIsOn(env.RNX_NO_PROMPT) ||
+    isAgentEnv(env) ||
+    invocation.commandArgs.includes('--json') ||
+    invocation.commandArgs.includes('--ci') ||
+    invocation.commandArgs.includes('--dry-run')
+  ) {
+    return false
+  }
+
+  return !['agent-wrapper', 'cleanup', 'daemon', 'serve', 'upgrade', 'version'].includes(
+    invocation.command ?? '',
+  )
+}
+
+export function claimAutomaticCliUpdateCheck(now = Date.now()): boolean {
+  const state = readState()
+  const lastCheck = Math.max(state.checkedAt, state.lastAttemptAt)
+  if (now >= lastCheck && now - lastCheck < CLI_UPDATE_CHECK_INTERVAL_MS) {
+    return false
+  }
+  return writeState({ ...state, lastAttemptAt: now })
+}
+
+export function readCachedCliUpdate(
+  currentVersion = getCliVersion(),
+): CliUpdateAvailability | null {
+  return availability(readState(), currentVersion)
+}
+
+export function takeCliUpdateNotification(
+  currentVersion = getCliVersion(),
+  now = Date.now(),
+): CliUpdateAvailability | null {
+  const state = readState()
+  const update = availability(state, currentVersion)
+  if (!update?.outdated || state.lastNotifiedVersion === update.latestVersion) return null
+  if (
+    now >= state.lastNotifiedAt &&
+    now - state.lastNotifiedAt < CLI_UPDATE_NOTIFICATION_COOLDOWN_MS
+  ) {
+    return null
+  }
+  if (
+    !writeState({
+      ...state,
+      lastNotifiedVersion: update.latestVersion,
+      lastNotifiedAt: now,
+    })
+  ) {
+    return null
+  }
+  return update
+}
+
+export async function fetchCliReleaseFile(
+  url: string,
+  timeoutMs: number,
+): Promise<Buffer> {
+  let response: Response
+  try {
+    response = await fetch(url, {
+      headers: { accept: 'application/octet-stream' },
+      signal: AbortSignal.timeout(timeoutMs),
+    })
+  } catch (error) {
+    throw new Error(
+      `could not reach the rnx update service: ${
+        error instanceof Error ? error.message : String(error)
+      }`,
+    )
+  }
+  if (!response.ok) {
+    throw new Error(
+      `rnx update download failed: ${response.status} ${response.statusText}`,
+    )
+  }
+  return Buffer.from(await response.arrayBuffer())
+}
+
+export async function refreshCliUpdateCache(
+  options: { releaseOrigin?: string; now?: number; timeoutMs?: number } = {},
+): Promise<CliUpdateAvailability> {
+  const releaseOrigin = (options.releaseOrigin ?? DEFAULT_CLI_RELEASE_ORIGIN).replace(
+    /\/+$/,
+    '',
+  )
+  const latestVersion = (
+    await fetchCliReleaseFile(
+      `${releaseOrigin}/channels/stable`,
+      options.timeoutMs ?? 8_000,
+    )
+  )
+    .toString('utf8')
+    .trim()
+  if (!CLI_VERSION_PATTERN.test(latestVersion)) {
+    throw new Error(
+      `rnx update service returned an invalid version: ${latestVersion || '(empty)'}`,
+    )
+  }
+
+  const now = options.now ?? Date.now()
+  const state = readState()
+  const next: CliUpdateState = {
+    ...state,
+    latestVersion,
+    checkedAt: now,
+    lastAttemptAt: now,
+  }
+  writeState(next)
+  const update = availability(next)
+  if (!update) throw new Error('rnx update cache did not retain the latest version')
+  return update
+}