rnxsim 0.1.369 → 0.1.371

package/cli/commands/box/plane-share.ts

@@ -0,0 +1,208 @@
+// a local box authorizing its own checkout for browser access.
+//
+// the bridge daemon serves the `plane:*` envelope, but it will not open a root
+// nobody has authorized, because a WebSocket to 127.0.0.1 is not subject to
+// CORS and any page the user visits can open one. so the box registers its
+// root and holds the socket for as long as it runs; when the box exits, the
+// registration goes with it and the tab loses reach.
+//
+// THIS NEVER BLOCKS THE BOX. an earlier version awaited the socket before
+// printing the prompt and cost 1450ms of start time on every box, because a
+// daemon built before `plane:*` existed accepts the socket, ignores the
+// message, and never replies, so the client sat on its timeout. a box that
+// cannot share its plane is a box with one capability missing, not a box that
+// starts slowly.
+//
+// IT ALSO REFUSES TO GUESS A PORT. when no lockfile claims a bridge,
+// resolveBridgeWorld reports source 'default' and hands back
+// DEFAULT_SOOTSIM_BRIDGE_PORT, which on a machine running a real daemon is
+// that daemon. registering there would attach a test's or a benchmark's box to
+// another session's daemon, which is exactly what a private SOOTSIM_HOME
+// exists to prevent. so a guessed port is refused by name.
+
+import WebSocket from 'ws'
+import { bridgeWsUrl, resolveBridgeWorld } from '../../ws-bridge'
+
+const REGISTER_TIMEOUT_MS = 1500
+
+export interface PlaneShare {
+  /**
+   * resolves when the daemon has accepted the root, or with a reason it did
+   * not. `holders` is how many boxes now hold this checkout, including this
+   * one, so more than one means another box is writing the same tree.
+   */
+  readonly settled: Promise<{ port: number; holders: number } | { declined: string }>
+  close(): void
+}
+
+function target(
+  explicitPort: number | undefined,
+): { port: number } | { declined: string } {
+  if (explicitPort) return { port: explicitPort }
+  const world = resolveBridgeWorld()
+  if (world.source === 'default') {
+    return {
+      declined:
+        'no daemon or dev bridge claims a port, and the default is another session’s daemon on a shared machine',
+    }
+  }
+  return { port: world.bridgePort }
+}
+
+/**
+ * register `root` with the bridge daemon in the background. returns
+ * immediately; the box never waits on it.
+ */
+export function sharePlane(root: string, opts: { port?: number } = {}): PlaneShare {
+  const chosen = target(opts.port)
+  if ('declined' in chosen) {
+    return { settled: Promise.resolve(chosen), close: () => {} }
+  }
+
+  const port = chosen.port
+  let socket: WebSocket | null = null
+  let closed = false
+
+  const settled = new Promise<{ port: number; holders: number } | { declined: string }>(
+    (resolve) => {
+      let done = false
+      const finish = (
+        value: { port: number; holders: number } | { declined: string },
+      ) => {
+        if (done) return
+        done = true
+        clearTimeout(timer)
+        resolve(value)
+      }
+
+      const timer = setTimeout(() => {
+        // an older daemon accepts the socket and ignores plane:* entirely, so
+        // silence is the expected shape of "not supported" rather than a fault.
+        socket?.close()
+        finish({ declined: `bridge on port ${port} did not answer plane:register` })
+      }, REGISTER_TIMEOUT_MS)
+
+      try {
+        socket = new WebSocket(bridgeWsUrl(port))
+      } catch (error) {
+        finish({ declined: error instanceof Error ? error.message : String(error) })
+        return
+      }
+      if (closed) {
+        socket.close()
+        finish({ declined: 'box exited before the plane registered' })
+        return
+      }
+
+      socket.on('error', (error) => finish({ declined: error.message }))
+      socket.on('close', () => finish({ declined: `bridge on port ${port} closed` }))
+      socket.on('open', () => {
+        // node sends no Origin, so this socket is already cli-role. a browser
+        // client has to send bridge:hello to be corrected off the provisional
+        // sim role; see plans/rnx-cloud/transport-decision.md.
+        socket?.send(JSON.stringify({ type: 'plane:register', id: 'register', root }))
+      })
+      socket.on('message', (data) => {
+        let parsed: unknown
+        try {
+          parsed = JSON.parse(String(data))
+        } catch {
+          return
+        }
+        if (typeof parsed !== 'object' || parsed === null) return
+        const reply: Record<string, unknown> = { ...parsed }
+        if (reply.id !== 'register') return
+        if (reply.error) {
+          socket?.close()
+          finish({ declined: String(reply.error) })
+          return
+        }
+        // the daemon nests its payload under `result`; reading holders off the
+        // envelope silently reported 1 forever, which is the exact silence this
+        // field exists to remove.
+        const result = (reply.result ?? {}) as Record<string, unknown>
+        finish({ port, holders: Number(result.holders ?? 1) })
+      })
+    },
+  )
+
+  return {
+    settled,
+    close: () => {
+      closed = true
+      try {
+        socket?.close()
+      } catch {}
+    },
+  }
+}
+
+/**
+ * How many boxes hold `root` right now, without registering anything.
+ *
+ * `plane:register` cannot answer this: registering is what makes a root
+ * reachable over a loopback socket, so a readiness probe that asked with it
+ * would both authorize the root and count itself in the answer.
+ */
+export async function planeStatus(
+  root: string,
+  opts: { port?: number } = {},
+): Promise<{ holders: number; registered: boolean } | { declined: string }> {
+  const chosen = target(opts.port)
+  if ('declined' in chosen) return chosen
+  const port = chosen.port
+
+  return new Promise((resolve) => {
+    let done = false
+    let socket: WebSocket | null = null
+    const finish = (
+      value: { holders: number; registered: boolean } | { declined: string },
+    ) => {
+      if (done) return
+      done = true
+      clearTimeout(timer)
+      try {
+        socket?.close()
+      } catch {}
+      resolve(value)
+    }
+    const timer = setTimeout(
+      () => finish({ declined: `bridge on port ${port} did not answer plane:status` }),
+      REGISTER_TIMEOUT_MS,
+    )
+
+    try {
+      socket = new WebSocket(bridgeWsUrl(port))
+    } catch (error) {
+      finish({ declined: error instanceof Error ? error.message : String(error) })
+      return
+    }
+    socket.on('error', (error) => finish({ declined: error.message }))
+    socket.on('close', () => finish({ declined: `bridge on port ${port} closed` }))
+    socket.on('open', () => {
+      socket?.send(JSON.stringify({ type: 'plane:status', id: 'status', root }))
+    })
+    socket.on('message', (data) => {
+      let parsed: unknown
+      try {
+        parsed = JSON.parse(String(data))
+      } catch {
+        return
+      }
+      if (typeof parsed !== 'object' || parsed === null) return
+      const reply: Record<string, unknown> = { ...parsed }
+      if (reply.id !== 'status') return
+      if (reply.error) {
+        finish({ declined: String(reply.error) })
+        return
+      }
+      // the daemon nests its payload under `result`, the same shape
+      // plane:register answers in.
+      const result = (reply.result ?? {}) as Record<string, unknown>
+      finish({
+        holders: Number(result.holders ?? 0),
+        registered: Boolean(result.registered),
+      })
+    })
+  })
+}

package/cli/commands/box/rnx-command.ts

@@ -8,8 +8,8 @@
 
 import { spawn } from 'node:child_process'
 import path from 'node:path'
-import { defineCommand, type CustomCommand } from '@contrast/harness'
-import { PROJECT_MOUNT } from '@contrast/harness'
+import { defineCommand, type CustomCommand } from '@contrast/harness/shell'
+import { PROJECT_MOUNT } from '@contrast/harness/shell'
 import { rnxPublicBrand } from '../../../src/public-brand'
 import { RNX_PLACEMENT_ENV } from '../../ws-bridge'
 

package/cli/commands/box/search-command.ts

@@ -0,0 +1,157 @@
+// `rg` inside a local box, run by git rather than by a JavaScript matcher.
+//
+// just-bash implements rg in JavaScript and reads every file body through the
+// plane, so one search of this repo is ~15,000 plane reads. MEASURED in the box
+// shell: 14,093ms and two lines of output, which are its abort message. It does
+// not return results at all, and searching is the most common thing an agent
+// does, so that is the box being unusable on a real project.
+//
+// WHY GIT GREP AND NOT RIPGREP. The first version of this shelled out to `rg`,
+// which turned CI red: the Linux runners have no ripgrep binary, and a box that
+// depends on whatever happens to be installed on the host is not a box. Git is
+// different in kind, not degree: `CheckoutFilePlane` already REFUSES to open a
+// project that is not a git repository and runs `git ls-files` before every
+// single command, so git is a hard, already-enforced requirement. Searching
+// with it adds no dependency and cannot be absent where the box already runs.
+//
+// It also makes the file set correct BY CONSTRUCTION rather than by agreement.
+// The box indexes `git ls-files -co --exclude-standard`, tracked AND
+// untracked-not-ignored, and `git grep --untracked` applies those same rules
+// from the same tool. RAN against a checkout built to expose the difference:
+// tracked, untracked-not-ignored, a dotfile and a dotdir file all match, and
+// gitignored trees do not. Ripgrep needed the plane's path list piped into it
+// to get there, because plain `rg .` silently misses dotfiles and `rg --hidden`
+// searches .git/**.
+//
+// MEASURED on this repo, 14,949 indexed files: 391ms p50 against ripgrep's
+// 260ms and just-bash's 14,093ms. Giving up 130ms to remove a host dependency
+// and an entire class of "works on my machine" is the right trade.
+//
+// It also removes the ARG_MAX chunking the ripgrep version needed. Git walks
+// its own index, so there is one process and one exit code rather than several
+// whose "no match here" had to be merged.
+
+import { spawn } from 'node:child_process'
+import { defineCommand, type CustomCommand } from '@contrast/harness/shell'
+import { PROJECT_MOUNT } from '@contrast/harness/shell'
+
+// generous next to a 414ms p95: this bounds a wedged child, it does not cut off
+// a large search.
+const SEARCH_DEADLINE_MS = 20_000
+
+/**
+ * THE DEADLINE SETTLES THIS PROMISE ITSELF rather than only killing the child.
+ * A spawned child's answer has been observed going missing while the process
+ * stayed alive, with no one able to say which event never arrived, so nothing
+ * that waits on a child event can be trusted to settle. A timer in this process
+ * cannot be missed, so it is the authority and the kill is a side effect.
+ * See docs/testing.md.
+ */
+function runGitGrep(args: string[], cwd: string) {
+  return new Promise<{ stdout: string; stderr: string; exitCode: number }>((resolve) => {
+    const child = spawn('git', args, {
+      cwd,
+      env: process.env,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    })
+    let stdout = ''
+    let stderr = ''
+    let settled = false
+    const finish = (exitCode: number) => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      resolve({ stdout, stderr, exitCode })
+    }
+    const timer = setTimeout(() => {
+      try {
+        child.kill('SIGKILL')
+      } catch {}
+      stderr += `rg: search timed out after ${SEARCH_DEADLINE_MS}ms\n`
+      finish(2)
+    }, SEARCH_DEADLINE_MS)
+
+    child.stdout.on('data', (chunk) => {
+      stdout += String(chunk)
+    })
+    child.stderr.on('data', (chunk) => {
+      stderr += String(chunk)
+    })
+    child.once('error', (error) => {
+      stderr += `rg: ${error.message}\n`
+      finish(2)
+    })
+    child.once('close', (code) => finish(code ?? 0))
+  })
+}
+
+// the rg flags worth honouring, mapped onto git grep's spelling. anything else
+// is REFUSED BY NAME rather than dropped, because a search that silently
+// ignores `-i` returns a confidently wrong answer.
+const FLAG_MAP: Record<string, string> = {
+  '-i': '-i',
+  '--ignore-case': '-i',
+  '-l': '-l',
+  '--files-with-matches': '-l',
+  '-w': '-w',
+  '--word-regexp': '-w',
+  '-c': '-c',
+  '--count': '-c',
+  '-v': '-v',
+  '--invert-match': '-v',
+  '-F': '-F',
+  '--fixed-strings': '-F',
+}
+
+export function createSearchCommand(options: { root: string }): CustomCommand {
+  return defineCommand('rg', async (args) => {
+    const flags: string[] = []
+    const bare: string[] = []
+    for (const arg of args) {
+      if (!arg.startsWith('-')) {
+        bare.push(arg)
+        continue
+      }
+      const mapped = FLAG_MAP[arg]
+      if (!mapped) {
+        return {
+          stdout: '',
+          stderr: `rg: this box does not support ${arg}\n`,
+          exitCode: 2,
+        }
+      }
+      flags.push(mapped)
+    }
+
+    const pattern = bare.shift()
+    if (pattern === undefined) {
+      return { stdout: '', stderr: 'rg: no pattern given\n', exitCode: 2 }
+    }
+
+    // paths are project-relative to git; strip the shell's mount prefix so
+    // `rg x /project/src` and `rg x src` mean the same thing.
+    const scopes = bare.map((p) =>
+      p.startsWith(`${PROJECT_MOUNT}/`) ? p.slice(PROJECT_MOUNT.length + 1) : p,
+    )
+
+    // --untracked is what makes this the plane's set rather than git's tracked
+    // set. -E for extended regex, the closest of git's grammars to ripgrep's.
+    // -e so a pattern beginning with a dash is a pattern, not a flag.
+    const result = await runGitGrep(
+      [
+        'grep',
+        '--no-color',
+        '-n',
+        '-I',
+        '--untracked',
+        '-E',
+        ...flags,
+        '-e',
+        pattern,
+        ...(scopes.length > 0 ? ['--', ...scopes] : []),
+      ],
+      options.root,
+    )
+    return result
+  })
+}