rnxsim 0.1.365 → 0.1.367

package/cli/commands/box.ts

@@ -0,0 +1,200 @@
+// `rnx box` — the box environment.
+//
+// bare `rnx box` is LOCAL and mounts the current checkout at /project. `rnx box
+// create` provisions a durable cloud box. everything else in the namespace is
+// cloud lifecycle. the cloud side is not built yet; those verbs fail by name
+// and say what works instead, so nothing advertises a capability that always
+// fails.
+
+import path from 'node:path'
+import { createInterface } from 'node:readline'
+import { createHarnessShell, HarnessProjectFs, PROJECT_MOUNT } from '@contrast/harness'
+import { rnxPublicBrand } from '../../src/public-brand'
+import { findRepositoryPackageRoot } from '../setup-repository'
+import { resolvePlacement } from '../ws-bridge'
+import { CheckoutFilePlane, CheckoutRequiresGitError } from './box/checkout-plane'
+import { createRnxCommand } from './box/rnx-command'
+
+interface BoxCommandOptions {
+  port?: number
+  verbose?: boolean
+}
+
+const CLOUD_SUBCOMMANDS = new Set(['create', 'ls', 'connect', 'stop', 'delete'])
+
+function usage(): void {
+  const rnx = rnxPublicBrand.commandName
+  console.log(`
+  ${rnx} box — start a local box and enter its shell
+
+  usage:
+    ${rnx} box                     start a local box over the current checkout
+    ${rnx} box create              create a cloud box and enter its shell
+    ${rnx} box create --name=<n>   create a named cloud box
+
+  a local box mounts this checkout at ${PROJECT_MOUNT}, gives you a shell with
+  ls, cat, find, rg, sed, pipes and redirects, and registers ${rnx} itself as a
+  shell command. writes go straight to the checkout — there is no second copy.
+`)
+}
+
+export async function runBox(
+  args: string[],
+  opts: BoxCommandOptions = {},
+): Promise<number> {
+  if (args.includes('--help') || args.includes('-h')) {
+    usage()
+    return 0
+  }
+
+  // a box inside a box would mount the same checkout twice and give the
+  // user two shells writing through one filesystem. refuse at the top rather
+  // than letting the second one start and quietly race the first.
+  const placement = resolvePlacement()
+  if (placement === 'local-box') {
+    console.error(
+      `  ${rnxPublicBrand.commandName} box: you are already in a box.\n` +
+        `  this shell is the box — run ${rnxPublicBrand.commandName} commands directly, or \`exit\` to leave.`,
+    )
+    return 1
+  }
+
+  const subcommand = args.find((arg) => !arg.startsWith('-'))
+  if (subcommand !== undefined) {
+    if (CLOUD_SUBCOMMANDS.has(subcommand)) {
+      console.error(
+        `  ${rnxPublicBrand.commandName} box ${subcommand} needs a cloud box, which is not built yet.\n` +
+          `  \`${rnxPublicBrand.commandName} box\` runs the same shell locally over this checkout.`,
+      )
+      return 1
+    }
+    console.error(
+      `  unknown command: ${rnxPublicBrand.commandName} box ${subcommand}\n` +
+        `  run \`${rnxPublicBrand.commandName} box --help\` to see the box surface.`,
+    )
+    return 1
+  }
+
+  return runLocalBox(opts)
+}
+
+async function runLocalBox(opts: BoxCommandOptions): Promise<number> {
+  // findRepositoryPackageRoot answers both halves of what a box needs: the
+  // nearest package.json, and only when it sits inside a git repository. git
+  // is what decides which files belong to the project, so a box without it
+  // would have to walk the whole directory tree — measured at 230k files on
+  // this repo against 15k from git.
+  const root = findRepositoryPackageRoot(process.cwd())
+  if (!root) {
+    console.error(
+      `  ${rnxPublicBrand.commandName} box: no project here.\n` +
+        `  the box needs a directory inside a git repository that has a\n` +
+        `  package.json. it asks git which files belong to the project, so it\n` +
+        `  never walks node_modules or build output. run \`git init\` if this is\n` +
+        `  a new project.`,
+    )
+    return 1
+  }
+
+  const plane = new CheckoutFilePlane(root)
+  try {
+    await plane.refresh()
+  } catch (error) {
+    if (error instanceof CheckoutRequiresGitError) {
+      console.error(`  ${rnxPublicBrand.commandName} box: ${error.message}`)
+      return 1
+    }
+    throw error
+  }
+
+  const shell = createHarnessShell({
+    projectFs: new HarnessProjectFs(plane),
+    commands: [createRnxCommand({ root, shellCwd: () => shell.cwd })],
+  })
+
+  const relative = path.relative(root, process.cwd())
+  console.log(`  ...starting local box`)
+  console.log(`  ...mounting ${root} at ${PROJECT_MOUNT}`)
+  console.log(`  ...accessing shell\n`)
+  if (opts.verbose) {
+    console.log(`  ${plane.index().size} project files indexed\n`)
+  }
+
+  return repl(shell, plane, relative)
+}
+
+async function repl(
+  shell: ReturnType<typeof createHarnessShell>,
+  plane: CheckoutFilePlane,
+  startRelative: string,
+): Promise<number> {
+  const rl = createInterface({ input: process.stdin, output: process.stdout })
+
+  // enter where the user was standing, so `rnx box` from a subdirectory does
+  // not silently teleport them to the project root.
+  if (startRelative && !startRelative.startsWith('..')) {
+    await shell.exec(`cd ${JSON.stringify(startRelative)}`)
+  }
+
+  const prompt = () => {
+    rl.setPrompt(`${shell.cwd} > `)
+    rl.prompt()
+  }
+
+  // readline delivers a pasted block, or a piped script, as a burst of `line`
+  // events. run them one at a time in order — dropping the ones that arrive
+  // while a command is running would silently execute only the first line of
+  // a paste.
+  let queue: Promise<void> = Promise.resolve()
+  // stdin ended: stop printing prompts, but still finish what is already
+  // queued — piping a script in must run every line, not just the first.
+  let inputEnded = false
+  // the user typed `exit`: abandon anything still queued behind it.
+  let stopped = false
+
+  const run = async (command: string) => {
+    if (stopped) return
+    try {
+      // the checkout is shared with editors, agents, and the user's own
+      // terminal, so re-read the file set before every command rather than
+      // trusting a snapshot taken when the box started.
+      await plane.refresh()
+      const result = await shell.exec(command)
+      if (result.text && result.text !== '(no output)') console.log(result.text)
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : String(error))
+    }
+    if (!inputEnded && !stopped) prompt()
+  }
+
+  return new Promise<number>((resolve) => {
+    prompt()
+
+    rl.on('line', (line) => {
+      const command = line.trim()
+      if (!command) {
+        queue = queue.then(() => {
+          if (!inputEnded && !stopped) prompt()
+        })
+        return
+      }
+      if (command === 'exit' || command === 'quit') {
+        queue = queue.then(() => {
+          stopped = true
+          rl.close()
+        })
+        return
+      }
+      queue = queue.then(() => run(command))
+    })
+
+    rl.on('close', () => {
+      inputEnded = true
+      // let any already-queued command finish before the process exits.
+      queue.then(() => {
+        console.log()
+        resolve(0)
+      })
+    })
+  })
+}

package/cli/commands/control.ts

@@ -9,6 +9,7 @@ import {
 } from 'sootsim-engine/settings'
 import { WebSocket } from 'ws'
 import { probePort } from '../../scripts/dev-server-scanner'
+import { isAppDeepLinkTarget, openAppUrl } from '../../src/app-url'
 import { isLoopbackHost } from '../../src/backend-origin'
 import { resolveSootsimShellBaseUrlForBridgePort } from '../../src/bridge-constants'
 import {
@@ -65,7 +66,7 @@ import {
   worldForBridgePort,
   type BridgeSimInfo,
 } from '../ws-bridge'
-import { WAIT_READY_PROBE, readyProbeHasContent, type ReadyProbe } from './inspect/core'
+import { inspectDescribe, inspectWaitReady } from './inspect/core'
 import { isAgentEnv } from './inspect/env'
 import type { DriverId, DriverLaunchResult } from '../drivers/types'
 
@@ -161,31 +162,6 @@ function normalizeKnownTarget(target: string): string {
   return target.trim()
 }
 
-const DEEP_LINK_SCHEME_RE = /^[A-Za-z][A-Za-z0-9+.-]*:/
-
-export function normalizeDeepLinkTarget(target: string): string {
-  const trimmed = target.trim()
-  if (!trimmed) {
-    throw new Error('expected <url-or-route>')
-  }
-  if (DEEP_LINK_SCHEME_RE.test(trimmed) || trimmed.startsWith('/')) {
-    return trimmed
-  }
-  return `/${trimmed}`
-}
-
-function isObjectRecord(value: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === 'object'
-}
-
-function shouldOpenAsDeepLink(target: string): boolean {
-  const trimmed = target.trim()
-  if (!trimmed) return false
-  if (trimmed.startsWith('/')) return true
-  if (!DEEP_LINK_SCHEME_RE.test(trimmed)) return false
-  return !/^https?:\/\//i.test(trimmed)
-}
-
 export async function ensureBridgeForOpen(
   preferredPort: number,
   explicitPort = false,
@@ -1272,19 +1248,12 @@ async function maybeDescribeAfterOpen(wsPort: number, simId: string, args: strin
       simIdSource: 'flag',
     })
     try {
-      let readyProbe: ReadyProbe | null = null
+      let readyProbe: Awaited<ReturnType<typeof inspectWaitReady>> | null = null
       try {
-        readyProbe = (await bridge.send({
-          type: 'evaluate',
-          code: WAIT_READY_PROBE,
-        })) as ReadyProbe | null
+        readyProbe = await inspectWaitReady(bridge, 1)
       } catch {}
       if (readyProbe) {
-        const readyEnough =
-          readyProbe.flag === true &&
-          !readyProbe.loadingText &&
-          readyProbeHasContent(readyProbe)
-        if (!readyEnough) {
+        if (!readyProbe.ready) {
           const reason = readyProbe.loadingText
             ? `still showing "${readyProbe.loadingText}"`
             : readyProbe.flag !== true
@@ -1298,29 +1267,16 @@ async function maybeDescribeAfterOpen(wsPort: number, simId: string, args: strin
           console.log('  before interacting, run: rnx wait ready --max-ms 120000')
         }
       }
-      const dumpOpts = { describe: true, verbose: false, filter: '' }
-      const code = `(async () => {
-        const t = window.__sootsimTest
-        const ms = window.SootSim?.bridges?.mainShell
-        if (!t) return null
-        let shell = null
-        try { shell = ms?.getState ? await ms.getState() : null } catch {}
-        const tree = await t.dumpTree(12, ${JSON.stringify(dumpOpts)})
-        return { tree, shell }
-      })()`
-      const result = (await bridge.send({ type: 'evaluate', code })) as {
-        tree: string | null
-        shell: { state?: string; activeApp?: string } | null
-      } | null
+      const result = await inspectDescribe(bridge, {
+        describe: true,
+        verbose: false,
+        filter: '',
+        compact: true,
+        hideXy: false,
+        maxDepth: 12,
+      })
       if (!result?.tree) return
       console.log('')
-      if (result.shell?.state) {
-        const parts = [
-          `state=${result.shell.state}`,
-          result.shell.activeApp ? `app=${result.shell.activeApp}` : null,
-        ].filter(Boolean)
-        console.log(`  shell: ${parts.join(' ')}`)
-      }
       console.log(result.tree)
     } finally {
       bridge.close()
@@ -1385,27 +1341,10 @@ export async function runLinkCommand(args: string[], opts: ControlCommandOptions
     process.exit(1)
   }
 
-  let target: string
-  try {
-    target = normalizeDeepLinkTarget(parsed.positional[0] ?? '')
-  } catch (err) {
-    console.error(`  rnx open: ${err instanceof Error ? err.message : String(err)}`)
-    process.exit(1)
-  }
-
   const bridge = createBridgeFromParsed(parsed)
   const simHint = parsed.simId ? ` --sim ${parsed.simId}` : ''
   try {
-    const result = await bridge.send({
-      type: 'call',
-      path: 'SootSim.bridges.test.openDeepLink',
-      args: [target],
-    })
-    if (isObjectRecord(result) && result.ok === false) {
-      throw new Error(
-        typeof result.error === 'string' ? result.error : 'deep-link dispatch failed',
-      )
-    }
+    const target = await openAppUrl(bridge, parsed.positional[0] ?? '')
     console.log(`  opened deep link: ${target}`)
   } catch (err) {
     console.error(`  link failed: ${err instanceof Error ? err.message : String(err)}`)
@@ -1475,7 +1414,7 @@ export async function runOpenCommand(
   }
   const target = parsed.positional[0] || ''
 
-  if (shouldOpenAsDeepLink(target)) {
+  if (isAppDeepLinkTarget(target)) {
     if (openInNewSim) {
       console.error(
         '  rnx open: deep links target the current app; remove --new, --profile, or --ephemeral',

package/cli/commands/detox.ts

@@ -12,6 +12,7 @@
 
 import { spawn } from 'child_process'
 import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from 'fs'
+import { createRequire } from 'module'
 import { tmpdir } from 'os'
 import { dirname, resolve, join, relative } from 'path'
 import { rnxPublicBrand } from '../../src/public-brand'
@@ -195,7 +196,23 @@ export async function runDetox(args: string[], opts: RunDetoxOpts = {}): Promise
   console.log(`    port:     ${port}${headed ? ' (headed)' : ''}`)
   if (localConfig) console.log(`    config:   ${localConfig}`)
 
-  const child = spawn('npx', jestArgs, {
+  // proof capture retains several full-resolution frames while jest tears its
+  // browser down. node 24.16.0's maglev collector can crash in
+  // ClearStaleLeftTrimmedPointerVisitor after every assertion has passed.
+  // the conformance lane pins that exact node runtime, so disable only its
+  // unstable optimization tier. normal user detox runs keep their own node
+  // defaults and still resolve jest through npx.
+  const proofCapture =
+    process.env.CONFORMANCE_PROOF === '1' || !!process.env.CONFORMANCE_PROOF_DIR
+  const command = proofCapture ? 'node' : 'npx'
+  const commandArgs = proofCapture
+    ? [
+        '--no-maglev',
+        createRequire(join(process.cwd(), 'package.json')).resolve('jest/bin/jest'),
+        ...jestArgs.slice(1),
+      ]
+    : jestArgs
+  const child = spawn(command, commandArgs, {
     cwd: process.cwd(),
     stdio: 'inherit',
     env: {