peachsim 0.1.527

package/cli/inspect-notice-state.ts

@@ -0,0 +1,114 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'fs'
+import { tmpdir } from 'os'
+import { dirname, join, resolve } from 'path'
+
+const INSPECT_NOTICE_STATE_VERSION = 1 as const
+const INSPECT_NOTICE_PATH_ENV = 'SOOTSIM_INSPECT_NOTICE_PATH'
+const INSPECT_NOTICE_ENTRY_TTL_MS = 5 * 60 * 1000
+
+export const INSPECT_NOTICE_COOLDOWN_MS = 15_000
+
+type InspectNoticeKind = 'console' | 'requests'
+
+interface InspectNoticeEntry {
+  signature: string
+  updatedAt: number
+}
+
+interface InspectNoticeState {
+  version: 1
+  entries: Record<string, InspectNoticeEntry>
+}
+
+export function getInspectNoticeStatePath() {
+  return resolve(
+    process.env[INSPECT_NOTICE_PATH_ENV] ||
+      join(tmpdir(), 'rnx-inspect-notice-state.json'),
+  )
+}
+
+function pruneEntries(
+  entries: Record<string, InspectNoticeEntry>,
+  nowMs: number,
+): Record<string, InspectNoticeEntry> {
+  return Object.fromEntries(
+    Object.entries(entries).filter(([, entry]) => {
+      return (
+        typeof entry?.signature === 'string' &&
+        Number.isFinite(entry?.updatedAt) &&
+        nowMs - entry.updatedAt <= INSPECT_NOTICE_ENTRY_TTL_MS
+      )
+    }),
+  )
+}
+
+function readInspectNoticeState(nowMs: number): InspectNoticeState {
+  const filepath = getInspectNoticeStatePath()
+  if (!existsSync(filepath)) {
+    return { version: INSPECT_NOTICE_STATE_VERSION, entries: {} }
+  }
+
+  try {
+    const parsed = JSON.parse(
+      readFileSync(filepath, 'utf8'),
+    ) as Partial<InspectNoticeState>
+    if (
+      parsed.version !== INSPECT_NOTICE_STATE_VERSION ||
+      !parsed.entries ||
+      typeof parsed.entries !== 'object'
+    ) {
+      rmSync(filepath, { force: true })
+      return { version: INSPECT_NOTICE_STATE_VERSION, entries: {} }
+    }
+    return {
+      version: INSPECT_NOTICE_STATE_VERSION,
+      entries: pruneEntries(parsed.entries as Record<string, InspectNoticeEntry>, nowMs),
+    }
+  } catch {
+    rmSync(filepath, { force: true })
+    return { version: INSPECT_NOTICE_STATE_VERSION, entries: {} }
+  }
+}
+
+function writeInspectNoticeState(state: InspectNoticeState) {
+  const filepath = getInspectNoticeStatePath()
+  mkdirSync(dirname(filepath), { recursive: true })
+  writeFileSync(filepath, JSON.stringify(state, null, 2) + '\n')
+}
+
+function getInspectNoticeKey(kind: InspectNoticeKind, scope: string) {
+  const normalizedScope = scope.trim() || 'default'
+  return `${kind}:${normalizedScope}`
+}
+
+export function shouldPrintInspectNotice(
+  kind: InspectNoticeKind,
+  scope: string,
+  signature: string,
+  opts: { nowMs?: number; cooldownMs?: number } = {},
+) {
+  const nowMs = opts.nowMs ?? Date.now()
+  const cooldownMs = opts.cooldownMs ?? INSPECT_NOTICE_COOLDOWN_MS
+  const state = readInspectNoticeState(nowMs)
+  const key = getInspectNoticeKey(kind, scope)
+  const previous = state.entries[key]
+
+  if (
+    previous &&
+    previous.signature === signature &&
+    nowMs - previous.updatedAt < cooldownMs
+  ) {
+    return false
+  }
+
+  state.entries[key] = {
+    signature,
+    updatedAt: nowMs,
+  }
+  writeInspectNoticeState(state)
+  return true
+}
+
+export function clearInspectNoticeState() {
+  rmSync(getInspectNoticeStatePath(), { force: true })
+}

package/cli/internal-child.ts

@@ -0,0 +1,176 @@
+// hidden child-process entry points.
+//
+// the CLI needs separate JS processes for a few jobs: a detached browser host
+// that outlives `rnx open`, playwright's own installer, and a blocking fetch
+// worker for maestro's synchronous `http` API. each used to run as
+// `process.execPath -e '<source>'`, which cannot work once the CLI ships as a
+// compiled binary: there process.execPath is rnx, and rnx has no -e. a
+// shell-installed user has no node and no bun either, so there is nothing else
+// to reach for. the binary is the JS runtime, and it runs these itself.
+//
+// spawn them through rnxSelfInvocation() so the npm and standalone shapes take
+// the same path. bin.ts dispatches here straight from argv, before any CLI
+// startup work, which keeps a per-request worker (sync-http) cheap.
+
+import { existsSync, writeFileSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import * as vm from 'node:vm'
+
+export const RNX_INTERNAL_COMMAND = '__internal'
+
+export const RNX_INTERNAL_CHILDREN = {
+  playwrightProbe: 'playwright-probe',
+  playwrightInstall: 'playwright-install',
+  playwrightHost: 'playwright-host',
+  syncHttp: 'sync-http',
+} as const
+
+/** require() rooted at the working directory, which is where a user's
+ *  node_modules lives. the compiled binary carries none of its own. */
+function requireFromCwd(): NodeJS.Require {
+  return createRequire(`${process.cwd()}/`)
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null
+}
+
+/** what a one-shot child hands back to the caller that is blocked reading it. */
+interface ChildReply {
+  stdout: string
+  code: number
+}
+
+export async function runInternalChild(args: string[]): Promise<void> {
+  const [name, ...rest] = args
+  let reply: ChildReply | undefined
+  try {
+    switch (name) {
+      case RNX_INTERNAL_CHILDREN.playwrightProbe:
+        reply = playwrightProbe()
+        break
+      case RNX_INTERNAL_CHILDREN.playwrightInstall:
+        playwrightInstall(rest)
+        break
+      case RNX_INTERNAL_CHILDREN.playwrightHost:
+        await playwrightHost()
+        break
+      case RNX_INTERNAL_CHILDREN.syncHttp:
+        reply = await syncHttp()
+        break
+      default:
+        throw new Error(`unknown internal child: ${name ?? '(none)'}`)
+    }
+  } catch (error) {
+    writeFileSync(2, `${error instanceof Error ? error.stack : String(error)}\n`)
+    process.exit(1)
+  }
+
+  // the two one-shot children answer a caller that is blocked in spawnSync
+  // until this process ends, so end it on the reply rather than whenever the
+  // runtime decides nothing is left open. that is only safe because the write
+  // goes through the file descriptor: through process.stdout a pipe write
+  // completes asynchronously on macos, and exiting would truncate the json
+  // being parsed on the other side.
+  if (reply) {
+    writeFileSync(1, reply.stdout)
+    process.exit(reply.code)
+  }
+
+  // playwright's installer and the browser host are both still working when
+  // they return here. they own the process from now on, and it ends when their
+  // own work does.
+}
+
+/** report where the resolved playwright package expects its chromium and
+ *  whether that file is there. a separate process so the caller's environment
+ *  snapshot — PLAYWRIGHT_BROWSERS_PATH above all — is the only browser cache
+ *  this ever sees. */
+function playwrightProbe(): ChildReply {
+  const modulePath = process.env.SOOTSIM_PW_MODULE
+  if (!modulePath) throw new Error('SOOTSIM_PW_MODULE is not set')
+  const playwright: unknown = requireFromCwd()(modulePath)
+  const chromium = isRecord(playwright) ? playwright.chromium : null
+  if (!isRecord(chromium) || typeof chromium.executablePath !== 'function') {
+    throw new Error('resolved package does not expose browser "chromium"')
+  }
+  const executablePath: unknown = chromium.executablePath()
+  if (typeof executablePath !== 'string') {
+    throw new Error('browser "chromium" reported no executable path')
+  }
+  return {
+    stdout: JSON.stringify({ executablePath, exists: existsSync(executablePath) }),
+    code: 0,
+  }
+}
+
+/** run playwright's own CLI entry, the only thing allowed to install the
+ *  browser revision its API named. argv is shaped the way that CLI's argument
+ *  parser expects to receive it from node. it owns this process from here:
+ *  it sets the exit code and may exit outright. */
+function playwrightInstall(args: string[]): void {
+  const [cliPath, ...cliArgs] = args
+  if (!cliPath) {
+    throw new Error('internal playwright-install needs the package CLI path')
+  }
+  process.argv = [process.argv[0], cliPath, ...cliArgs]
+  requireFromCwd()(cliPath)
+}
+
+/** the detached browser host. its source is CJS that resolves playwright from
+ *  an absolute path the driver hands it in the environment, launches chrome,
+ *  and keeps this process alive until the browser goes away. */
+async function playwrightHost(): Promise<void> {
+  const { PLAYWRIGHT_SIM_HOST } = await import('./drivers/playwright-sim-host')
+  const run: unknown = vm.runInThisContext(
+    `(function(require){${PLAYWRIGHT_SIM_HOST}\n})`,
+    { filename: 'rnx-playwright-host.js' },
+  )
+  if (typeof run !== 'function') throw new Error('browser host source is not runnable')
+  run(requireFromCwd())
+}
+
+/** one blocking fetch. maestro's flow `http` API is synchronous and node has
+ *  no synchronous fetch, so the caller round-trips each request through a
+ *  spawnSync of this: JSON request on stdin, JSON response on stdout. a failed
+ *  request is still a reply — the flow engine reads the error out of the same
+ *  json — so only the exit code separates the two. */
+async function syncHttp(): Promise<ChildReply> {
+  const chunks: Buffer[] = []
+  for await (const chunk of process.stdin) chunks.push(Buffer.from(chunk))
+  try {
+    const request: unknown = JSON.parse(Buffer.concat(chunks).toString('utf8'))
+    if (!isRecord(request) || typeof request.url !== 'string') {
+      throw new Error('sync-http needs a JSON request with a url')
+    }
+    const response = await fetch(request.url, {
+      method: typeof request.method === 'string' ? request.method : undefined,
+      headers: isRecord(request.headers) ? readStringMap(request.headers) : undefined,
+      body: typeof request.body === 'string' ? request.body : undefined,
+    })
+    const body = await response.text()
+    const headers: Record<string, string> = {}
+    for (const [key, value] of response.headers.entries()) {
+      headers[key] = headers[key] ? `${headers[key]},${value}` : value
+    }
+    return {
+      stdout: JSON.stringify({ ok: response.ok, status: response.status, body, headers }),
+      code: 0,
+    }
+  } catch (error) {
+    return {
+      stdout: JSON.stringify({
+        __error: error instanceof Error ? error.message : String(error),
+      }),
+      code: 1,
+    }
+  }
+}
+
+function readStringMap(value: Record<string, unknown>): Record<string, string> {
+  const result: Record<string, string> = {}
+  for (const [key, entry] of Object.entries(value)) {
+    if (typeof entry === 'string') result[key] = entry
+  }
+  return result
+}

package/cli/maestro-js.ts

@@ -0,0 +1,323 @@
+// maestro-compatible flow JS engine — mirrors maestro's GraalJsEngine
+// (maestro-client/src/main/java/maestro/js/GraalJsEngine.kt) on top of
+// node's vm module. one context per flow run, shared by the whole flow
+// including runFlow sub-flows, exactly like upstream:
+//
+//   globals: http, output (persistent map), maestro ({copiedText, platform}),
+//   json(), relativePoint(), env vars as bare globals (scope-stacked per
+//   sub-flow), console.log routed to the flow log. undeclared identifiers
+//   evaluate to undefined for `${MY_VAR || 'default'}` patterns (upstream uses
+//   a has-trapping Proxy as globalThis's prototype; node/V8 forbids that, so we
+//   get the same semantics from a with-scope proxy — see the constructor).
+//
+//   `${expr}` string templates are full JS evaluation at command-execution
+//   time (maestro-orchestra-models util/Env.kt): regex (?<!\\)\$\{([^$]*)},
+//   result stringified, `\${...}` escapes to a literal, blank exprs become ''.
+//
+// divergences (deliberate, rnx-side ergonomics — keep this list short):
+//   1. envBinding is seeded from the full process.env, not just MAESTRO_*.
+//      rnx flows historically resolve `${SOOTSIM_*}` credentials from the
+//      shell environment and `rnx maestro --env K=V` writes process.env.
+//   2. a *bare identifier* template (`${NAME}`) that evaluates to undefined
+//      throws a loud "missing variable" error instead of interpolating the
+//      literal text "undefined" into a tap target or login form. complex
+//      expressions keep upstream semantics (undefined -> "undefined").
+//   3. `faker` is not implemented — flows using it fail loudly rather than
+//      getting a half-faithful reimplementation of datafaker.
+
+import { spawnSync } from 'child_process'
+import * as vm from 'vm'
+import { RNX_INTERNAL_CHILDREN, RNX_INTERNAL_COMMAND } from './internal-child'
+import { rnxSelfInvocation } from './self-invocation'
+
+const HTTP_TIMEOUT_MS = 300_000 // upstream: okhttp read/write/call timeout 5min
+
+interface HttpParams {
+  body?: string
+  headers?: Record<string, string>
+  method?: string
+  multipartForm?: unknown
+}
+
+function executeSyncHttp(
+  url: string,
+  method: string,
+  params?: HttpParams,
+): { ok: boolean; status: number; body: string; headers: Record<string, string> } {
+  if (params?.multipartForm) {
+    throw new Error('http: multipartForm is not supported by rnx yet')
+  }
+  // maestro's `http` API is synchronous (flows do `var res = http.post(...)`)
+  // and there is no synchronous fetch, so each request round-trips through a
+  // blocking spawn of this CLI's own fetch worker: JSON in on stdin, JSON out
+  // on stdout.
+  //
+  // the child must be hermetic: when the runner runs under `bun` (or any
+  // process with a debug inspector), the inherited BUN_INSPECT*/NODE_OPTIONS
+  // env makes the child attach to the parent's inspector/IPC socket and exit 1
+  // with no output instead of running our fetch. scrub those so the child is a
+  // clean fetch worker regardless of how the parent was launched.
+  const childEnv = { ...process.env }
+  for (const key of Object.keys(childEnv)) {
+    if (key.startsWith('BUN_INSPECT') || key === 'NODE_OPTIONS') {
+      delete childEnv[key]
+    }
+  }
+  const self = rnxSelfInvocation()
+  const child = spawnSync(
+    self.executable,
+    [...self.prefixArgs, RNX_INTERNAL_COMMAND, RNX_INTERNAL_CHILDREN.syncHttp],
+    {
+      input: JSON.stringify({
+        url,
+        method,
+        headers: params?.headers,
+        body: params?.body,
+      }),
+      encoding: 'utf8',
+      timeout: HTTP_TIMEOUT_MS,
+      maxBuffer: 64 * 1024 * 1024,
+      env: childEnv,
+    },
+  )
+  if (child.error) {
+    throw new Error(`http ${method} ${url} failed: ${child.error.message}`)
+  }
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(child.stdout || '')
+  } catch {
+    throw new Error(
+      `http ${method} ${url} failed: no response (${(child.stderr || '').trim().slice(0, 200)})`,
+    )
+  }
+  const result = parsed as {
+    __error?: string
+    ok: boolean
+    status: number
+    body: string
+    headers: Record<string, string>
+  }
+  if (result.__error) {
+    throw new Error(`http ${method} ${url} failed: ${result.__error}`)
+  }
+  return result
+}
+
+// matches upstream Env.kt: negative-lookbehind for the \ escape, [^$]* body.
+const TEMPLATE_RE = /(?<!\\)\$\{([^$]*)\}/g
+const ESCAPED_TEMPLATE_RE = /\\(\$\{[^$]*\})/g
+const BARE_IDENTIFIER_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/
+
+export class MaestroJsContext {
+  private readonly context: vm.Context
+  private readonly envBinding = new Map<string, string>()
+  private readonly envScopeStack: Array<Map<string, string>> = []
+  // env keys currently materialized as context globals — cleared and re-set
+  // before each evaluation, mirroring upstream syncBindingsToContext.
+  private syncedEnvKeys = new Set<string>()
+  readonly output: Record<string, unknown> = {}
+  readonly maestro: { copiedText: string | null; platform: string }
+
+  constructor(opts: { platform?: string; onLog?: (msg: string) => void } = {}) {
+    this.maestro = { copiedText: null, platform: opts.platform ?? 'ios' }
+    const onLog = opts.onLog ?? ((msg: string) => console.log(`[flow]   js: ${msg}`))
+    const sandbox: Record<string, unknown> = {
+      output: this.output,
+      maestro: this.maestro,
+      http: {
+        get: (url: string, params?: HttpParams) => executeSyncHttp(url, 'GET', params),
+        post: (url: string, params?: HttpParams) => executeSyncHttp(url, 'POST', params),
+        put: (url: string, params?: HttpParams) => executeSyncHttp(url, 'PUT', params),
+        delete: (url: string, params?: HttpParams) =>
+          executeSyncHttp(url, 'DELETE', params),
+        request: (url: string, params?: HttpParams) =>
+          executeSyncHttp(url, (params?.method ?? 'GET').toUpperCase(), params),
+      },
+      console: {
+        log: (...args: unknown[]) =>
+          onLog(args.map((a) => (typeof a === 'string' ? a : stringifyJs(a))).join(' ')),
+      },
+    }
+    this.context = vm.createContext(sandbox)
+    // upstream GraalJsEngine resolves undeclared identifiers to undefined via
+    // a has-trapping Proxy installed as globalThis's prototype, enabling the
+    // `${VAR || 'default'}` idiom. node/V8's vm forbids a Proxy in the global
+    // prototype chain ("Proxy is not allowed in the global prototype chain"),
+    // so we get the identical semantics with a `with`-scope proxy instead:
+    // evalRaw wraps every script in `with(__maestroScope){…}`, and the proxy's
+    // has→true makes any bare identifier resolve through the scope (returning
+    // the real global, or undefined for a name that isn't defined) rather than
+    // throwing ReferenceError. plus the json/relativePoint helpers.
+    vm.runInContext(
+      `
+      globalThis.__maestroScope = new Proxy(globalThis, {
+        has() { return true },
+        get(target, key) { return target[key] },
+      })
+      function json(text) { return JSON.parse(text) }
+      function relativePoint(x, y) {
+        var xPercent = Math.ceil(x * 100) + '%'
+        var yPercent = Math.ceil(y * 100) + '%'
+        return xPercent + ',' + yPercent
+      }
+      `,
+      this.context,
+    )
+    // divergence #1: seed env from the shell so `${SOOTSIM_*}` keeps working.
+    for (const [key, value] of Object.entries(process.env)) {
+      if (value !== undefined) this.envBinding.set(key, value)
+    }
+  }
+
+  putEnv(key: string, value: string) {
+    this.envBinding.set(key, value)
+  }
+
+  setCopiedText(text: string | null) {
+    this.maestro.copiedText = text
+  }
+
+  enterEnvScope() {
+    this.envScopeStack.push(new Map(this.envBinding))
+  }
+
+  leaveEnvScope() {
+    const previous = this.envScopeStack.pop()
+    if (previous) {
+      this.envBinding.clear()
+      for (const [k, v] of previous) this.envBinding.set(k, v)
+    }
+  }
+
+  // evaluate a JS snippet in the shared context. mirrors upstream
+  // evalWithIIFE: the script is embedded in a template literal and run
+  // through eval inside an IIFE so var/let/const stay scoped to this
+  // evaluation while the last expression's value is returned.
+  evaluate(script: string, opts: { env?: Record<string, string> } = {}): unknown {
+    const env = opts.env
+    if (env && Object.keys(env).length > 0) {
+      this.enterEnvScope()
+      try {
+        for (const [k, v] of Object.entries(env)) this.envBinding.set(k, v)
+        return this.evalRaw(script)
+      } finally {
+        this.leaveEnvScope()
+      }
+    }
+    return this.evalRaw(script)
+  }
+
+  private evalRaw(script: string): unknown {
+    this.syncEnvToContext()
+    const escaped = script
+      .replace(/\\/g, '\\\\')
+      .replace(/`/g, '\\`')
+      .replace(/\$\{/g, '\\${')
+    // `with(__maestroScope)` gives undeclared identifiers the upstream
+    // undefined semantics (see constructor); the IIFE + direct eval keep
+    // var/let/const scoped to this evaluation while returning the last value.
+    return vm.runInContext(
+      `(function(){ with(__maestroScope){ return eval(\`${escaped}\`) } })()`,
+      this.context,
+    )
+  }
+
+  private syncEnvToContext() {
+    const globals = vm.runInContext('globalThis', this.context) as Record<string, unknown>
+    for (const key of this.syncedEnvKeys) {
+      if (!this.envBinding.has(key)) delete globals[key]
+    }
+    this.syncedEnvKeys = new Set()
+    for (const [key, value] of this.envBinding) {
+      try {
+        globals[key] = value
+        this.syncedEnvKeys.add(key)
+      } catch {
+        // non-writable global (e.g. a frozen builtin name in env) — skip
+      }
+    }
+  }
+
+  // upstream Env.kt String.evaluateScripts: replace every unescaped `${expr}`
+  // with the stringified evaluation result, then unescape `\${...}`.
+  evaluateStringTemplate(value: string): string {
+    const replaced = value.replace(TEMPLATE_RE, (_match, expr: string) => {
+      if (expr.trim().length === 0) return ''
+      const result = this.evaluate(expr)
+      // divergence #2: a bare `${NAME}` that comes back undefined is a flow
+      // bug 100% of the time — fail loudly instead of typing "undefined".
+      if (result === undefined && BARE_IDENTIFIER_RE.test(expr.trim())) {
+        throw new Error(`missing variable for flow placeholder: ${expr.trim()}`)
+      }
+      return stringifyJs(result)
+    })
+    return replaced.replace(ESCAPED_TEMPLATE_RE, (_match, inner: string) => inner)
+  }
+
+  // walk a parsed step and evaluate every string template. nested command
+  // lists are skipped — each nested command evaluates its own strings when
+  // it executes (matching upstream per-command evaluateScripts timing, and
+  // required for values that change between iterations, e.g. copyTextFrom
+  // inside repeat).
+  interpolateStep<T>(step: T): T {
+    return this.interpolateValue(step, null) as T
+  }
+
+  private interpolateValue(value: unknown, parentKey: string | null): unknown {
+    if (typeof value === 'string') {
+      // evalScript IS the evaluation — the runner template-evaluates it in
+      // its handler. interpolating here too would run the script twice.
+      if (parentKey === 'evalScript') return value
+      return this.evaluateStringTemplate(value)
+    }
+    if (Array.isArray(value)) {
+      if (
+        parentKey === 'commands' ||
+        parentKey === 'onFlowStart' ||
+        parentKey === 'onFlowComplete'
+      ) {
+        return value
+      }
+      return value.map((entry) => this.interpolateValue(entry, parentKey))
+    }
+    if (value && typeof value === 'object') {
+      return Object.fromEntries(
+        Object.entries(value).map(([key, entry]) => [
+          key,
+          this.interpolateValue(entry, key),
+        ]),
+      )
+    }
+    return value
+  }
+}
+
+function stringifyJs(value: unknown): string {
+  if (value === undefined) return 'undefined'
+  if (value === null) return 'null'
+  if (typeof value === 'object') {
+    try {
+      return JSON.stringify(value)
+    } catch {
+      return String(value)
+    }
+  }
+  return String(value)
+}
+
+// upstream Orchestra.evaluateCondition scriptCondition semantics: the value
+// arrives already template-evaluated; false when blank / "false" (any case) /
+// "undefined" / "null" / numerically zero. yaml may also hand us a real
+// boolean or number before stringification — normalize first.
+export function scriptConditionIsTruthy(value: unknown): boolean {
+  if (value === undefined || value === null) return false
+  if (typeof value === 'boolean') return value
+  const text = String(value)
+  if (text.trim().length === 0) return false
+  if (text.toLowerCase() === 'false') return false
+  if (text === 'undefined' || text === 'null') return false
+  const num = Number(text)
+  if (!Number.isNaN(num) && num === 0) return false
+  return true
+}