rnxsim 0.1.431 → 0.1.433

package/cli/commands/flow.ts

@@ -24,8 +24,15 @@ import {
   keepFlowCandidate,
   startFlowSession,
 } from '../flow-session'
+import { GLOBAL_FLAG_TAKES_VALUE } from '../parse-args'
 import { rnxExit } from '../run-rnx'
-import { createBridge, createBridgeFromParsed, parseBridgeCliArgs } from '../ws-bridge'
+import {
+  BRIDGE_VALUE_FLAGS,
+  createBridge,
+  createBridgeFromParsed,
+  parseBridgeCliArgs,
+  resolveBridgePortForPin,
+} from '../ws-bridge'
 import {
   buildShellUrl,
   closeSimsBulk,
@@ -39,6 +46,110 @@ import type { UploadResult } from './upload'
 
 export { parseFlowFile, validateFlowFile } from '../flow-file'
 
+// the complete flag vocabulary of `runFlowPlayback`. it is both the strip list
+// handed to parseBridgeCliArgs and the vocabulary the unknown-argument check
+// enforces, so a flag added to the runner and left out of here gets rejected
+// rather than silently dropped.
+const FLOW_BOOLEAN_FLAGS = [
+  '--record',
+  '--profile',
+  '--electron',
+  '--new',
+  '--preview',
+  '--preview-open',
+  '--headless',
+  '--headed',
+  '--proof',
+  '--no-shell',
+  '--shell-only',
+]
+
+const FLOW_VALUE_FLAGS = [
+  '--out',
+  '--base-url',
+  '--device',
+  '--theme',
+  '--slow',
+  '--tail-wait',
+  '--url',
+  '--replace',
+  '--remap',
+  '--screenshots',
+  '--screenshot-paths',
+  '--preview-origin',
+  '--preview-public-origin',
+  '--driver',
+  '--billing-kind',
+  '--owner',
+  '--repo',
+]
+
+// the strip lists parseBridgeCliArgs needs to see a flow argv the way the
+// runner does. exported so a command that pre-parses argv before handing it to
+// runFlowPlayback reads the same vocabulary instead of keeping its own copy.
+export const FLOW_BRIDGE_ARG_OPTIONS = {
+  stripBooleanFlags: FLOW_BOOLEAN_FLAGS,
+  stripValueFlags: FLOW_VALUE_FLAGS,
+}
+
+// every flag that swallows the token after it on a flow argv. a caller picking
+// the positional flow path out of raw argv has to skip those tokens, or
+// `maestro test --sim a2 login.yaml` resolves `a2` as the flow file.
+export const FLOW_ARG_VALUE_FLAGS = [...FLOW_VALUE_FLAGS, ...BRIDGE_VALUE_FLAGS]
+
+export interface UnexpectedFlowArg {
+  arg: string
+  message: string
+}
+
+// runFlowPlayback is the end of the line for argv: everything below it is built
+// from named values, never forwarded raw. so an argument it does not read is
+// read by nobody, and dropping one is how a run reports success while doing
+// something other than what was asked — a stale build took --proof, discarded
+// it, and produced non-proof screenshots under a proof-mode label.
+//
+// parseBridgeCliArgs already removes every flag this command understands and
+// every flag the bridge owns, each with its value, so whatever it leaves behind
+// past the flow path at args[0] is an argument nothing here consumes.
+export function findUnexpectedFlowArgs(args: string[]): UnexpectedFlowArg[] {
+  const known = new Set([...FLOW_BOOLEAN_FLAGS, ...FLOW_VALUE_FLAGS])
+  const problems: UnexpectedFlowArg[] = parseBridgeCliArgs(args, FLOW_BRIDGE_ARG_OPTIONS)
+    .positional.slice(1)
+    .map((arg) => {
+      const eq = arg.indexOf('=')
+      const head = eq > 0 ? arg.slice(0, eq) : ''
+      if (known.has(head)) {
+        return {
+          arg,
+          message: `${head} takes its value as a separate argument: ${head} ${arg.slice(eq + 1)}`,
+        }
+      }
+      const globalTakesValue = GLOBAL_FLAG_TAKES_VALUE.get(arg)
+      if (globalTakesValue !== undefined) {
+        return {
+          arg,
+          message: `${arg} is a global rnx flag and goes before the command: rnx ${arg}${
+            globalTakesValue ? ' <value>' : ''
+          } <command>`,
+        }
+      }
+      if (arg.startsWith('-')) return { arg, message: `unknown flag: ${arg}` }
+      return { arg, message: `unexpected argument: ${arg}` }
+    })
+
+  // a value flag left without a value keeps the runner's default instead of
+  // what the caller meant to set, which is the same silent substitution.
+  for (let i = 0; i < args.length; i++) {
+    if (!FLOW_VALUE_FLAGS.includes(args[i])) continue
+    const value = args[i + 1]
+    if (value === undefined || value.startsWith('-')) {
+      problems.push({ arg: args[i], message: `${args[i]} expects a value` })
+    }
+    i++
+  }
+  return problems
+}
+
 let lastPreviewUploadResult: UploadResult | null = null
 
 export function getLastFlowPreviewUploadResult(): UploadResult | null {
@@ -112,11 +223,17 @@ options:
   --profile            capture perf stats while the flow runs
   --out <dir>          output directory (default: /tmp/rnx-recordings)
   --device <model>     override the flow frontmatter device for this run
+  --theme <scheme>     override the flow frontmatter theme (light or dark) for
+                       this run
   --slow <ms>          delay between steps for natural pacing
   --tail-wait <ms>     hold the recording open after the last step so the
                        final UI state is captured (default: smart idle up to
                        6000ms for --preview, fixed 2000ms for --record, 0 otherwise)
   --url <url>          load this target before running the flow
+  --base-url <url>     run the flow against the shell at this URL instead of
+                       the discovered one, and poll that shell's own bridge.
+                       errors when no live rnx world serves it, so a pinned run
+                       can never quietly measure the default shell instead
   --screenshot-paths <mode>
                        screenshot path mode: dir (default) or flow
   --no-shell           capture every screenshot tenant-only (no status bar,
@@ -134,6 +251,14 @@ options:
                        --new; overrides --headless). use when you want to
                        watch the flow run live even if the current sim is
                        headless or stale
+  --proof              deterministic-capture mode: pin the TextInput caret
+                       visible instead of blinking, stop notifications
+                       auto-dismissing, and leave the device corners unclipped
+                       to match a native simctl framebuffer. a screen holding a
+                       focused text field cannot reach three identical idle
+                       frames without this, so its screenshot fails after 12
+                       tries. use it for any run whose screenshots get
+                       compared to anything
   --electron           prefer opening the target in the desktop companion
   --sim <id>           target a specific current sim
   --validate           replay the drafted flow before clearing it
@@ -152,7 +277,7 @@ options:
 
 frontmatter (top of flow.yaml between --- markers):
   app: 8081            load this target before the flow starts
-  device: iphone-14    set the live device model for this flow run
+  device: iphone-16    set the live device model for this flow run
   electron: true       prefer the desktop companion sim for this flow
 
 default runtime:
@@ -180,6 +305,15 @@ flow extension:
     rnxExit(0)
   }
 
+  const unexpected = findUnexpectedFlowArgs(args)
+  if (unexpected.length > 0) {
+    for (const problem of unexpected) {
+      console.error(`  error: ${problem.message}`)
+    }
+    console.error('\n  run `rnx maestro --help` for the flags this command accepts')
+    rnxExit(1)
+  }
+
   const flowPath = args[0]
   if (!fs.existsSync(flowPath)) {
     console.error(`  error: ${flowPath} not found`)
@@ -191,6 +325,10 @@ flow extension:
   // --headed forces a fresh visible window: implies --new and overrides
   // --headless (you asked to watch it run).
   const headed = args.includes('--headed')
+  // deterministic-capture mode. pins everything that would otherwise change
+  // between two frames of an idle screen, so `takeScreenshot` reaches its
+  // three identical frames on the first try instead of hunting for them.
+  const proofMode = args.includes('--proof')
   const openInNewSim = args.includes('--new') || headed
   const outDir = getFlag('--out') || '/tmp/rnx-recordings'
   // when --screenshots isn't explicitly set, default to the --out directory.
@@ -214,6 +352,12 @@ flow extension:
       ? 'shell'
       : undefined
   const deviceOverride = getFlag('--device')?.trim() || ''
+  // --device and --theme are also global flags, but a global sets the settings
+  // store inside THIS process and the sim renders in the shell's browser page,
+  // so `rnx --theme light maestro test` reaches nothing. both have to be read
+  // here and pushed over the bridge, and they are read the same way so a caller
+  // that gets one right cannot get the other silently ignored.
+  const themeOverride = getFlag('--theme')?.trim() || ''
   const slow = args.includes('--slow') ? +(getFlag('--slow') || '500') : 0
   const cliElectron = args.includes('--electron')
   const preview = args.includes('--preview')
@@ -275,7 +419,7 @@ flow extension:
     rnxExit(1)
   }
   const targetDevice = deviceOverride || frontmatter.device || ''
-  const targetTheme = frontmatter.theme || ''
+  const targetTheme = themeOverride || frontmatter.theme || ''
 
   const wantElectron = cliElectron || frontmatter.electron === true
   const rawTargetApp =
@@ -289,37 +433,29 @@ flow extension:
   const targetAppResolution = await resolveAppFrontmatterTarget(rawTargetApp)
   const targetApp = targetAppResolution.target
 
-  const bridgeArgOptions = {
-    stripBooleanFlags: [
-      '--record',
-      '--profile',
-      '--electron',
-      '--new',
-      '--preview',
-      '--preview-open',
-      '--headless',
-      '--headed',
-    ],
-    stripValueFlags: [
-      '--out',
-      '--device',
-      '--slow',
-      '--tail-wait',
-      '--url',
-      '--replace',
-      '--remap',
-      '--screenshots',
-      '--screenshot-paths',
-      '--preview-origin',
-      '--preview-public-origin',
-      '--driver',
-      '--billing-kind',
-      '--owner',
-      '--repo',
-    ],
-  }
-  const parsedBridgeArgs = parseBridgeCliArgs(args, bridgeArgOptions)
+  const parsedBridgeArgs = parseBridgeCliArgs(args, FLOW_BRIDGE_ARG_OPTIONS)
   const url = getFlag('--url') || ''
+
+  // --base-url pins the run to one shell, so a caller can build an engine from
+  // a known tree, serve it, and measure that build instead of whatever the
+  // discovered shell happens to hold. the page and the bridge have to stay in
+  // one world: without this retarget the flow would open the pinned shell and
+  // then poll the default world's bridge, waiting out its timeout with no sign
+  // of which shell it actually ran against.
+  const pinnedShellBaseUrl = getFlag('--base-url') || ''
+  if (pinnedShellBaseUrl) {
+    const pinned = resolveBridgePortForPin({
+      baseUrl: pinnedShellBaseUrl,
+      wsPort: parsedBridgeArgs.wsPort,
+      explicitPort: parsedBridgeArgs.explicitPort,
+    })
+    if (pinned.error !== undefined) {
+      console.error(`  error: ${pinned.error}`)
+      rnxExit(1)
+    } else {
+      parsedBridgeArgs.wsPort = pinned.port
+    }
+  }
   if (wantElectron && !findDesktopCompanion()) {
     console.error(
       '  error: desktop companion not found. install or build it first with `bun run build:electron`',
@@ -338,7 +474,7 @@ flow extension:
   const effectiveOpenInNewSim =
     openInNewSim || (wantElectron && parsedBridgeArgs.simIdSource !== 'flag')
   const driverFlag = getFlag('--driver') || ''
-  let closeManagedDriverSimAfterRun = false
+  let closeFlowOwnedSimAfterRun = false
   const ownedSimIds = new Set<string>()
 
   // if we weren't told exactly where to go, and there's already a primary
@@ -379,16 +515,19 @@ flow extension:
 
   if (openTarget && targetDevice) {
     const shellBaseUrl = applyRNXConfigToUrl(
-      resolveShellBaseUrlForBridgePort(parsedBridgeArgs.wsPort),
+      pinnedShellBaseUrl || resolveShellBaseUrlForBridgePort(parsedBridgeArgs.wsPort),
       targetAppResolution.runtimeConfig,
     )
-    const url = new URL(await buildShellUrl(openTarget, shellBaseUrl))
+    const url = new URL(
+      await buildShellUrl(openTarget, shellBaseUrl, { proof: proofMode }),
+    )
     url.searchParams.set('device', targetDevice)
     openTarget = url.toString()
   }
 
   if (openTarget) {
     const openArgs = [openTarget]
+    if (pinnedShellBaseUrl) openArgs.push('--base-url', pinnedShellBaseUrl)
     openArgs.push(...replaceArgs)
     openArgs.push(...remapArgs)
     if (effectiveOpenInNewSim) {
@@ -400,23 +539,30 @@ flow extension:
     }
     if (driverFlag) {
       openArgs.push('--driver', driverFlag)
-      closeManagedDriverSimAfterRun = true
     }
     if (args.includes('--headless') && !headed) {
       openArgs.push('--headless')
     }
+    if (proofMode) openArgs.push('--proof')
     await runOpenCommand(openArgs, {
       port: parsedBridgeArgs.wsPort,
       timeoutMs: parsedBridgeArgs.commandTimeoutMs,
       runtimeConfig: targetAppResolution.runtimeConfig,
     })
-    if (closeManagedDriverSimAfterRun) {
+    // a flow that opened its own sim owns it, and owning it means closing it.
+    // this used to be claimed only for `--driver` runs, so a `--new` run
+    // stranded its browser: the detached host's watchdog polls the *top*
+    // ancestor (getStableOwnerPid -> findTopAncestor), which is the shell or
+    // agent session, not the run. that pid lives for hours, so the watchdog
+    // stayed happy and every flow left one more Chrome behind.
+    closeFlowOwnedSimAfterRun = effectiveOpenInNewSim || !!driverFlag
+    if (closeFlowOwnedSimAfterRun) {
       const openedSimId = readCurrentSimId()
       if (openedSimId) ownedSimIds.add(openedSimId)
     }
   }
 
-  const resolvedBridgeArgs = parseBridgeCliArgs(args, bridgeArgOptions)
+  const resolvedBridgeArgs = parseBridgeCliArgs(args, FLOW_BRIDGE_ARG_OPTIONS)
   const pinnedSimId =
     resolvedBridgeArgs.simIdSource === 'flag'
       ? resolvedBridgeArgs.simId
@@ -432,7 +578,7 @@ flow extension:
     simIdSource: pinnedSimIdSource,
   })
   let driver: SootSimBridgeFlowRunner
-  const applyFlowFrontmatter = async () => {
+  const applySimSettings = async () => {
     const statusBarTime = frontmatter.env?.RNX_STATUS_BAR_TIME
     if (statusBarTime) {
       if (!/^(?:[1-9]|1[0-2]):[0-5][0-9]$/.test(statusBarTime)) {
@@ -483,7 +629,7 @@ flow extension:
     // recorder lives in-page state and gets wiped by window.location.reload.
     onAfterLaunch: async (simId) => {
       if (simId) saveCurrentSimId(simId)
-      const deviceChanged = await applyFlowFrontmatter()
+      const deviceChanged = await applySimSettings()
       if (deviceChanged) await driver.waitForTree(120000)
       if (!preview) return
       await bridge.send({
@@ -526,7 +672,7 @@ flow extension:
     if (!startsWithLaunchApp) {
       await driver.waitForTree(120000)
     }
-    const deviceChanged = await applyFlowFrontmatter()
+    const deviceChanged = await applySimSettings()
     if (deviceChanged && !startsWithLaunchApp) await driver.waitForTree(120000)
     // preview replay must reproduce the SAME initial conditions the agent
     // explored from. the explore session runs on a fresh ephemeral profile
@@ -783,7 +929,7 @@ flow extension:
 
   bridge.close()
 
-  if (closeManagedDriverSimAfterRun) {
+  if (closeFlowOwnedSimAfterRun) {
     if (driver.simId) ownedSimIds.add(driver.simId)
     await closeFlowOwnedSims(parsedBridgeArgs.wsPort, parsedBridgeArgs.commandTimeoutMs, [
       ...ownedSimIds,

package/cli/commands/inspect/get-layout.ts

@@ -33,7 +33,7 @@ export async function runGetLayoutSubcommand(opts: {
         error.message === 'unsupported RNX Cloud command type: evaluate'
       ) {
         throw new Error(
-          'get layout --styling is unavailable in RNX Cloud; rerun without --styling or use a local sim',
+          'get layout --styling is unavailable on a remote simulator; rerun without --styling or use a local sim',
         )
       }
       throw error

package/cli/commands/inspect.ts

@@ -436,7 +436,9 @@ function printRenderProfile(worker: string, rp: Record<string, any> | undefined)
   const recordCauses = [
     rp.boundaryRecordsInvalidated ? `invalidated ${rp.boundaryRecordsInvalidated}` : '',
     rp.boundaryRecordsOrigin ? `moved ${rp.boundaryRecordsOrigin}` : '',
-    rp.boundaryRecordsScheme ? `first-record ${rp.boundaryRecordsScheme}` : '',
+    rp.boundaryRecordsFirst ? `first-record ${rp.boundaryRecordsFirst}` : '',
+    rp.boundaryRecordsScheme ? `scheme ${rp.boundaryRecordsScheme}` : '',
+    rp.boundaryRecordsFont ? `late-font ${rp.boundaryRecordsFont}` : '',
   ]
     .filter(Boolean)
     .join(' · ')
@@ -472,6 +474,11 @@ function printRenderProfile(worker: string, rp: Record<string, any> | undefined)
       )
     }
   }
+  if (rp.paragraphBuilds || rp.paragraphLayouts) {
+    console.log(
+      `      text shaping: ${rp.paragraphBuilds} shaped ${Number(rp.paragraphBuildMs ?? 0).toFixed(1)}ms · ${rp.paragraphLayouts} re-broken ${Number(rp.paragraphLayoutMs ?? 0).toFixed(1)}ms`,
+    )
+  }
   console.log(`      blur:         ${rp.avgBlurMs}ms`)
   if (rp.glassDownsampleActive || rp.glassBackdropCacheMisses) {
     console.log(

package/cli/commands/login.ts

@@ -1,9 +1,12 @@
 import { exec } from 'node:child_process'
 import { randomBytes } from 'node:crypto'
 import http from 'node:http'
+import { createInterface } from 'node:readline/promises'
 import {
   refreshSharedDesktopAuthSession,
+  sharedDesktopAuthAccounts,
   writeSharedDesktopAuthSession,
+  type SharedDesktopAuthSession,
 } from '../../src/auth/shared-session'
 import { rnxPublicBrand } from '../../src/public-brand'
 import { rnxExit } from '../run-rnx'
@@ -26,15 +29,80 @@ function printHelp() {
 rnx login — sign in so uploads can attach to your account
 
 usage:
-  rnx login [--origin <url>]
+  rnx login [--origin <url>] [--account <name-or-id>]
 
 options:
-  --origin <url>     auth host (default: ${REMOTE_DEFAULT_ORIGIN})
-                     override with RNX_AUTH_ORIGIN env var
+  --origin <url>            auth host (default: ${REMOTE_DEFAULT_ORIGIN})
+                            override with RNX_AUTH_ORIGIN env var
+  --account <name-or-id>    the account remote simulators and boxes bill to.
+                            one account is chosen for you; several ask.
   -h, --help
 `)
 }
 
+// a session token names the person, not an account. the account that pays for
+// cloud work is chosen here, once, and stored on the session; a person with one
+// account never sees the question.
+async function chooseAccount(
+  session: SharedDesktopAuthSession,
+  requested: string | undefined,
+): Promise<{ id: string; name: string } | null> {
+  const accounts = sharedDesktopAuthAccounts(session.user)
+  if (requested !== undefined) {
+    const wanted = requested.trim().toLowerCase()
+    const match = accounts.find(
+      (account) =>
+        account.id === requested.trim() || account.name.toLowerCase() === wanted,
+    )
+    if (!match) {
+      console.error(
+        `  no account named ${JSON.stringify(requested)}. your accounts:\n` +
+          accounts.map((account) => `    ${account.name} (${account.id})`).join('\n'),
+      )
+      rnxExit(1)
+    }
+    return match
+  }
+  if (accounts.length <= 1) return accounts[0] ?? null
+  if (!process.stdin.isTTY) {
+    console.error(
+      '  this sign-in belongs to several accounts; rerun with --account <name> to choose the one to bill:\n' +
+        accounts.map((account) => `    ${account.name} (${account.id})`).join('\n'),
+    )
+    rnxExit(1)
+  }
+  console.log('  which account should remote simulators and boxes bill to?')
+  accounts.forEach((account, index) => console.log(`    ${index + 1}. ${account.name}`))
+  const prompt = createInterface({ input: process.stdin, output: process.stdout })
+  try {
+    for (;;) {
+      const answer = (await prompt.question(`  account [1-${accounts.length}]: `)).trim()
+      const chosen = accounts[Number(answer) - 1]
+      if (chosen && /^\d+$/.test(answer)) return chosen
+      console.log(`  enter a number from 1 to ${accounts.length}`)
+    }
+  } finally {
+    prompt.close()
+  }
+}
+
+async function finishLogin(
+  origin: string,
+  requestedAccount: string | undefined,
+  fallbackLabel: string | undefined,
+  suffix: string,
+) {
+  const refreshed = await refreshSharedDesktopAuthSession(origin)
+  const account = refreshed ? await chooseAccount(refreshed, requestedAccount) : null
+  if (refreshed && account) {
+    writeSharedDesktopAuthSession({ ...refreshed, accountId: account.id })
+  }
+  const label = refreshed?.user?.email || fallbackLabel || refreshed?.user?.id
+  console.log(
+    `  signed in${label ? ` as ${label}` : ''}${account ? ` (${account.name})` : ''}${suffix}`,
+  )
+}
+
 function extractStringFlag(args: string[], name: string): string | undefined {
   const idx = args.findIndex((a) => a === name)
   if (idx < 0) return undefined
@@ -147,6 +215,7 @@ export async function runLogin(args: string[]) {
 
   const mutableArgs = [...args]
   const origin = resolveDefaultAuthOrigin(extractStringFlag(mutableArgs, '--origin'))
+  const requestedAccount = extractStringFlag(mutableArgs, '--account')
 
   // in dev (localhost), skip the browser and sign in as the shared dev
   // user via POST /api/dev-login. the no-device contract is local-only, so this
@@ -161,13 +230,12 @@ export async function runLogin(args: string[]) {
         origin,
         source: 'cli',
       })
-      const refreshed = await refreshSharedDesktopAuthSession(origin)
-      const label =
-        refreshed?.user?.email ||
-        devResult.email ||
-        refreshed?.user?.id ||
-        devResult.userId
-      console.log(`  signed in${label ? ` as ${label}` : ''} (dev)`)
+      await finishLogin(
+        origin,
+        requestedAccount,
+        devResult.email || devResult.userId,
+        ' (dev)',
+      )
       return
     }
     console.log(`  dev-login not available (${devResult.error}); falling back to browser`)
@@ -285,8 +353,5 @@ export async function runLogin(args: string[]) {
     source: 'cli',
   })
 
-  const refreshed = await refreshSharedDesktopAuthSession(origin)
-  const label =
-    refreshed?.user?.email || result.email || refreshed?.user?.id || result.userId
-  console.log(`  signed in${label ? ` as ${label}` : ''}`)
+  await finishLogin(origin, requestedAccount, result.email || result.userId, '')
 }