peachsim 0.1.527

package/cli/commands/timeline.ts

@@ -0,0 +1,121 @@
+// rnx timeline — control the semantic agent-facing event log
+//
+// `rnx record` is for video/screen capture; `rnx debug record` is
+// for the engine-internal debug-channel ring; this command is the third
+// surface and explicitly distinct: it manages the SootSim.bridges.timeline API,
+// the unified, agent-facing semantic event stream across host / shell
+// worker / tenant worker.
+//
+// usage:
+//   rnx timeline status                      # what's enabled
+//   rnx timeline start [kinds]               # enable kinds (default: opt-in defaults)
+//   rnx timeline stop [kinds]                # disable kinds (or 'all')
+//   rnx timeline clear                       # drop all events + cursors
+//   rnx timeline dump <file>                 # write current ring to JSON
+//
+// see `rnx what-happened` for the read side.
+
+import { writeFileSync } from 'fs'
+import { rnxExit } from '../run-rnx'
+import { callInBridge, createBridgeFromParsed, parseBridgeCliArgs } from '../ws-bridge'
+
+interface TimelineOptions {
+  port?: number
+  verbose?: boolean
+}
+
+function printHelp() {
+  console.log(`
+rnx timeline — control the semantic event timeline
+
+usage:
+  rnx timeline <subcommand> [args]
+
+subcommands:
+  status                  show enabled kinds and ring sizes
+  start [kinds]           enable kinds (csv); 'all' for every opt-in
+  stop [kinds]            disable kinds (csv); 'all' for every kind
+  clear                   drop all events + cursors
+  dump <file>             write current merged ring to JSON
+
+note: cheap kinds (console, fetch, app-launch, keyboard, screen, alert,
+toast, notification, route, shell, actionsheet, picker) record at all times.
+start/stop enables opt-in kinds (react-commit, scroll, gesture, text-input,
+layout, reanimated, animation).
+
+read the timeline with: rnx what-happened
+`)
+}
+
+export async function runTimeline(args: string[], opts: TimelineOptions) {
+  const parsed = parseBridgeCliArgs(args, {
+    port: opts.port,
+    stripBooleanFlags: ['--json', '--help', '-h'],
+  })
+  const sub = parsed.positional[0]
+  if (!sub || args.includes('--help') || args.includes('-h')) {
+    printHelp()
+    rnxExit(0)
+  }
+  const json = args.includes('--json')
+  const bridge = createBridgeFromParsed(parsed)
+
+  const rest = parsed.positional.slice(1)
+  const kinds = rest[0]
+    ? rest[0]
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean)
+    : []
+
+  try {
+    switch (sub) {
+      case 'status': {
+        const status = await callInBridge(bridge, 'SootSim.bridges.timeline.status')
+        console.log(JSON.stringify(status, null, json ? 0 : 2))
+        break
+      }
+      case 'start': {
+        if (kinds.length === 0) kinds.push('all')
+        await callInBridge(bridge, 'SootSim.bridges.timeline.enable', ...kinds)
+        const status = await callInBridge(bridge, 'SootSim.bridges.timeline.status')
+        console.log(JSON.stringify(status, null, json ? 0 : 2))
+        break
+      }
+      case 'stop': {
+        if (kinds.length === 0) kinds.push('all')
+        await callInBridge(bridge, 'SootSim.bridges.timeline.disable', ...kinds)
+        const status = await callInBridge(bridge, 'SootSim.bridges.timeline.status')
+        console.log(JSON.stringify(status, null, json ? 0 : 2))
+        break
+      }
+      case 'clear': {
+        await callInBridge(bridge, 'SootSim.bridges.timeline.clear')
+        console.log('  cleared')
+        break
+      }
+      case 'dump': {
+        const outPath = rest[0]
+        if (!outPath) {
+          console.error('  usage: rnx timeline dump <file>')
+          rnxExit(1)
+        }
+        const result = await callInBridge<{ events: unknown[] }>(
+          bridge,
+          'SootSim.bridges.timeline.recent',
+          { limit: 1_000_000 },
+        )
+        writeFileSync(outPath, JSON.stringify(result.events, null, 2) + '\n')
+        console.log(`  wrote ${result.events.length} event(s) to ${outPath}`)
+        break
+      }
+      default: {
+        console.error(`  unknown subcommand: ${sub}`)
+        printHelp()
+        rnxExit(1)
+      }
+    }
+  } finally {
+    bridge.close()
+  }
+}

package/cli/commands/upgrade.ts

@@ -0,0 +1,167 @@
+// rnx upgrade updates the separately delivered runtime first, then atomically
+// replaces the standalone cli executable. runtime stays first because replacing
+// the running cli's files before later dynamic imports can strand the command.
+
+import { spawnSync } from 'node:child_process'
+import { createHash } from 'node:crypto'
+import fs from 'node:fs'
+import path from 'node:path'
+import { compareSemver } from '@contrast/runtime-delivery'
+import { getCliVersion } from '../../src/cli-version'
+import { isSootsimDevCheckout, readActiveRuntime, runtimeDir } from '../../src/home-paths'
+import { resolveRNXAppConfig } from '../app-config'
+import {
+  DEFAULT_CLI_RELEASE_ORIGIN,
+  fetchCliReleaseFile,
+  refreshCliUpdateCache,
+} from '../cli-update'
+import { fetchRuntimeReleaseNotes, formatRuntimeReleaseNotes } from '../runtime-notes'
+import { IS_STANDALONE } from '../standalone'
+import { runRuntime } from './runtime'
+
+const SHA256_PATTERN = /^[a-f0-9]{64}$/
+
+export interface UpgradeOptions {
+  cliExecutablePath?: string
+  cliReleaseOrigin?: string
+  standalone?: boolean
+  includeReleaseNotes?: boolean
+}
+
+export async function runUpgrade(
+  args: string[],
+  options: UpgradeOptions = {},
+): Promise<void> {
+  const channelIdx = args.indexOf('--channel')
+  const channel =
+    channelIdx >= 0 && args[channelIdx + 1] ? args[channelIdx + 1] : undefined
+
+  console.log('rnx upgrade\n')
+
+  console.log('runtime:')
+  const beforeRuntime = readActiveRuntime()
+  const { config } = await resolveRNXAppConfig()
+  const configuredRuntime = config?.runtimeVersion
+  const configuredRuntimeWasInstalled = configuredRuntime
+    ? fs.existsSync(path.join(runtimeDir(configuredRuntime), 'index.html'))
+    : false
+  if (configuredRuntime) {
+    console.log(`  project config: v${configuredRuntime}`)
+  }
+  const install =
+    configuredRuntime && configuredRuntimeWasInstalled
+      ? null
+      : await runRuntime(
+          [
+            'install',
+            ...(configuredRuntime ? [configuredRuntime, '--set-active=false'] : []),
+            ...(channel ? ['--channel', channel] : []),
+          ],
+          {},
+        )
+  const installedRuntime = install?.version ?? configuredRuntime ?? readActiveRuntime()
+  if (installedRuntime) {
+    console.log(
+      configuredRuntime
+        ? configuredRuntimeWasInstalled
+          ? `  result:  v${installedRuntime} already installed for this project`
+          : `  result:  not installed → v${installedRuntime} for this project`
+        : beforeRuntime && beforeRuntime !== installedRuntime
+          ? `  result:  v${beforeRuntime} → v${installedRuntime}`
+          : !beforeRuntime
+            ? `  result:  not installed → v${installedRuntime}`
+            : `  result:  v${installedRuntime} already current`,
+    )
+  }
+  const releaseNotes =
+    installedRuntime && options.includeReleaseNotes !== false
+      ? await fetchRuntimeReleaseNotes(installedRuntime)
+      : null
+
+  console.log('\ncli:')
+  await upgradeCli(options)
+
+  if (installedRuntime && options.includeReleaseNotes !== false) {
+    console.log(`\n${formatRuntimeReleaseNotes(installedRuntime, releaseNotes)}`)
+  }
+}
+
+export async function upgradeCli(options: UpgradeOptions = {}): Promise<void> {
+  const standalone = options.standalone ?? IS_STANDALONE
+  if (!standalone) {
+    if (isSootsimDevCheckout()) {
+      console.log('  running from the Contrast checkout; pull instead of upgrading')
+      return
+    }
+    throw new Error(
+      'this is not the standalone rnx executable; reinstall from https://rnxsim.com/install.sh',
+    )
+  }
+
+  const releaseOrigin = (options.cliReleaseOrigin ?? DEFAULT_CLI_RELEASE_ORIGIN).replace(
+    /\/+$/,
+    '',
+  )
+  const current = getCliVersion()
+  const { latestVersion: latest } = await refreshCliUpdateCache({ releaseOrigin })
+  if (compareSemver(latest, current) <= 0) {
+    console.log(`  v${current} (latest)`)
+    return
+  }
+
+  const artifact = cliArtifactName()
+  const artifactUrl = `${releaseOrigin}/${latest}/${artifact}`
+  const expectedSha = (await fetchCliReleaseFile(`${artifactUrl}.sha256`, 8_000))
+    .toString('utf8')
+    .trim()
+  if (!SHA256_PATTERN.test(expectedSha)) {
+    throw new Error('rnx update service returned an invalid executable checksum')
+  }
+
+  console.log(`  v${current} → v${latest}`)
+  console.log(`  downloading ${artifact}...`)
+  const executable = await fetchCliReleaseFile(artifactUrl, 120_000)
+  const actualSha = createHash('sha256').update(executable).digest('hex')
+  if (actualSha !== expectedSha) {
+    throw new Error(
+      `downloaded rnx executable failed verification (expected ${expectedSha}, got ${actualSha})`,
+    )
+  }
+
+  const executablePath = path.resolve(options.cliExecutablePath ?? process.execPath)
+  const tempDir = fs.mkdtempSync(path.join(path.dirname(executablePath), '.rnx-update-'))
+  const candidatePath = path.join(tempDir, path.basename(executablePath))
+  try {
+    fs.writeFileSync(candidatePath, executable, { mode: 0o755 })
+    fs.chmodSync(candidatePath, 0o755)
+    verifyCandidate(candidatePath, latest)
+    fs.renameSync(candidatePath, executablePath)
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true })
+  }
+  console.log(`  updated to v${latest}`)
+}
+
+function cliArtifactName(): string {
+  const platform = process.platform === 'darwin' ? 'darwin' : process.platform
+  if (platform !== 'darwin' && platform !== 'linux') {
+    throw new Error('standalone rnx self-update currently supports macOS and Linux')
+  }
+  if (process.arch !== 'arm64' && process.arch !== 'x64') {
+    throw new Error(`standalone rnx does not support ${process.arch}`)
+  }
+  return `rnx-${platform}-${process.arch}`
+}
+
+function verifyCandidate(candidatePath: string, expectedVersion: string): void {
+  const result = spawnSync(candidatePath, ['--version'], {
+    encoding: 'utf8',
+    timeout: 15_000,
+  })
+  const reported = result.stdout.match(/^rnx v([^\s]+)/m)?.[1]
+  if (result.status !== 0 || reported !== expectedVersion) {
+    throw new Error(
+      `downloaded rnx executable reported ${reported ? `v${reported}` : 'no version'}; expected v${expectedVersion}`,
+    )
+  }
+}