rnxsim 0.1.313 → 0.1.314

package/cli/commands/setup.ts

@@ -0,0 +1,545 @@
+// sootsim setup — the single guided machine and repository onboarding flow.
+
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import {
+  COMPAT_RESULT_CAVEAT,
+  countScanResults,
+  formatDetailedScanLines,
+  formatScanCounts,
+  scanDeps,
+  type ScanResult,
+} from '@sootsim/compat/web'
+import { DEFAULT_SOOTSIM_BRIDGE_PORT } from '../../src/bridge-constants'
+import { getCliVersion } from '../../src/cli-version'
+import {
+  isDaemonLockfileFresh,
+  readActiveRuntime,
+  readDaemonLockfile,
+  readPrivacyPreferences,
+  runtimeDir,
+  writePrivacyPreferences,
+} from '../../src/home-paths'
+import { sootsimRuntime } from '../../src/runtime-delivery'
+import { confirm } from '../prompt'
+import {
+  applyRepositorySetup,
+  detectPreferredPackageManager,
+  findPackageRoot,
+  formatRepositoryOperations,
+  planRepositorySetup,
+  type RepositorySetupPlan,
+} from '../setup-repository'
+import { trackCliEvent } from '../telemetry'
+import { daemonInstall, getDaemonServiceStatus } from './daemon'
+
+interface SetupOptions {
+  appDir: string
+  ci: boolean
+  dryRun: boolean
+  fromWelcome: boolean
+  json: boolean
+  yes: boolean
+  service: boolean | undefined
+  repository: boolean | undefined
+  productAnalytics: boolean | undefined
+  crashReports: boolean | undefined
+  shareCompatibility: boolean
+}
+
+export interface MachineSetupStatus {
+  daemonSupported: boolean
+  daemonInstalled: boolean
+  daemonRunning: boolean
+  runtimeInstalled: boolean
+  privacyConfigured: boolean
+}
+
+export interface SetupResult {
+  runtimeVersion: string
+  serviceInstalled: boolean
+  repositoryPrepared: boolean
+  compatibilityShared: boolean
+}
+
+type SetupStage =
+  | 'decisions'
+  | 'runtime'
+  | 'repository'
+  | 'service'
+  | 'privacy'
+  | 'compatibility'
+
+export async function runSetup(args: string[]): Promise<SetupResult | undefined> {
+  if (args.includes('--help') || args.includes('-h')) {
+    printHelp()
+    return
+  }
+
+  const options = parseSetupOptions(args)
+  let stage: SetupStage = 'decisions'
+  try {
+    const packageRoot = findPackageRoot(options.appDir)
+    const serviceStatus = getDaemonServiceStatus()
+    const privacy = readPrivacyPreferences()
+    const service = await decideService(options, serviceStatus)
+    const repository = await decideRepository(options, packageRoot)
+    const productAnalytics = await decidePrivacy(
+      options,
+      'productAnalytics',
+      privacy.productAnalytics,
+      privacy.configured,
+    )
+    const crashReports = await decidePrivacy(
+      options,
+      'crashReports',
+      privacy.crashReports,
+      privacy.configured,
+    )
+
+    const manifest = await sootsimRuntime.fetchManifest()
+    const resolvedRuntime = sootsimRuntime.resolveVersion(manifest, { channel: 'stable' })
+    const runtimeVersion = resolvedRuntime.version
+    const cliVersion = getCliVersion()
+    if (cliVersion === '0.0.0') {
+      throw new Error('could not resolve the installed rnxsim CLI version')
+    }
+
+    let repositoryPlan: RepositorySetupPlan | null = null
+    if (repository && packageRoot) {
+      repositoryPlan = planRepositorySetup({
+        appDir: packageRoot,
+        cliVersion,
+      })
+    }
+
+    printIntro(options)
+    printMachineSection(options, serviceStatus, service, runtimeVersion)
+    printRepositorySection(options, packageRoot, repositoryPlan)
+    printPrivacySection(options, productAnalytics, crashReports)
+
+    stage = 'runtime'
+    let installed = false
+    if (!options.dryRun) {
+      const activeRuntime = readActiveRuntime()
+      const result = await sootsimRuntime.install({
+        version: runtimeVersion,
+        channel: 'stable',
+        setActive: true,
+        protectVersions: activeRuntime ? [activeRuntime] : [],
+      })
+      installed = result.installed
+    }
+
+    stage = 'repository'
+    if (repositoryPlan) {
+      await applyRepositorySetup(repositoryPlan, {
+        dryRun: options.dryRun,
+        json: options.json,
+      })
+    }
+
+    stage = 'service'
+    let serviceInstalled = serviceStatus.installed
+    if (service && !serviceStatus.installed && !options.dryRun) {
+      await daemonInstall({ port: DEFAULT_SOOTSIM_BRIDGE_PORT, force: false })
+      serviceInstalled = true
+    }
+
+    stage = 'privacy'
+    if (!options.dryRun) {
+      writePrivacyPreferences({ productAnalytics, crashReports })
+    }
+
+    stage = 'compatibility'
+    const scan = packageRoot ? scanPackage(packageRoot) : null
+    const shareCompatibility = await decideCompatibilitySharing(options, scan)
+    if (shareCompatibility && scan && packageRoot && !options.dryRun) {
+      await shareCompatibilityScan(packageRoot, scan)
+    }
+    printCompatibilitySection(options, scan, shareCompatibility)
+
+    const result: SetupResult = {
+      runtimeVersion,
+      serviceInstalled,
+      repositoryPrepared: repositoryPlan !== null,
+      compatibilityShared: shareCompatibility && !options.dryRun,
+    }
+    const cache = runtimeCacheMetadata(runtimeVersion)
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          {
+            ...result,
+            runtimeInstalled: options.dryRun ? false : installed,
+            dryRun: options.dryRun,
+            cache,
+            repositoryOperations: repositoryPlan
+              ? formatRepositoryOperations(repositoryPlan)
+              : [],
+          },
+          null,
+          2,
+        ),
+      )
+    } else {
+      printReadySection(repositoryPlan)
+    }
+
+    const counts = scan ? countScanResults(scan) : null
+    trackCliEvent({
+      event: 'cli_setup_completed',
+      properties: {
+        service_installed: serviceInstalled,
+        repository_prepared: repositoryPlan !== null,
+        product_analytics: productAnalytics,
+        crash_reports: crashReports,
+        compat_supported: counts?.supported ?? 0,
+        compat_partial: counts?.partial ?? 0,
+        compat_unsupported: counts?.unsupported ?? 0,
+        compat_not_yet_verified: counts?.notYetVerified ?? 0,
+        from_welcome: options.fromWelcome,
+        ci: options.ci,
+        dry_run: options.dryRun,
+      },
+    })
+    return result
+  } catch (error) {
+    const message = boundedMessage(error)
+    trackCliEvent({
+      event: 'cli_setup_failed',
+      properties: { stage, message },
+    })
+    throw error
+  }
+}
+
+export function readMachineSetupStatus(): MachineSetupStatus {
+  const service = getDaemonServiceStatus()
+  const lock = readDaemonLockfile()
+  const activeRuntime = readActiveRuntime()
+  return {
+    daemonSupported: service.supported,
+    daemonInstalled: service.installed,
+    daemonRunning: Boolean(lock && isDaemonLockfileFresh(lock)),
+    runtimeInstalled: Boolean(activeRuntime && fs.existsSync(runtimeDir(activeRuntime))),
+    privacyConfigured: readPrivacyPreferences().configured,
+  }
+}
+
+export function shouldRunSetupForBareCommand(
+  status: MachineSetupStatus = readMachineSetupStatus(),
+): boolean {
+  return !status.runtimeInstalled || !status.privacyConfigured
+}
+
+function parseSetupOptions(args: string[]): SetupOptions {
+  const appIndex = args.indexOf('--app')
+  const appArg = appIndex >= 0 ? args[appIndex + 1] : undefined
+  if (appIndex >= 0 && (!appArg || appArg.startsWith('-'))) {
+    throw new Error('--app requires a directory')
+  }
+  const service = readBooleanFlag(args, '--service', '--no-service')
+  const repository = readBooleanFlag(args, '--repo', '--no-repo')
+  return {
+    appDir: path.resolve(appArg ?? process.cwd()),
+    ci: args.includes('--ci'),
+    dryRun: args.includes('--dry-run'),
+    fromWelcome: args.includes('--from-welcome'),
+    json: args.includes('--json'),
+    yes: args.includes('--yes') || args.includes('-y'),
+    service,
+    repository,
+    productAnalytics: readOnOffFlag(args, '--analytics'),
+    crashReports: readOnOffFlag(args, '--crash-reports'),
+    shareCompatibility: args.includes('--share-compat'),
+  }
+}
+
+function readBooleanFlag(
+  args: string[],
+  positive: string,
+  negative: string,
+): boolean | undefined {
+  if (args.includes(positive) && args.includes(negative)) {
+    throw new Error(`${positive} and ${negative} cannot be used together`)
+  }
+  if (args.includes(positive)) return true
+  if (args.includes(negative)) return false
+  return undefined
+}
+
+function readOnOffFlag(args: string[], name: string): boolean | undefined {
+  const equals = args.find((arg) => arg.startsWith(`${name}=`))
+  const index = args.indexOf(name)
+  const raw = equals?.slice(name.length + 1) ?? (index >= 0 ? args[index + 1] : undefined)
+  if (raw === undefined) return undefined
+  if (raw === 'on' || raw === 'yes' || raw === 'true') return true
+  if (raw === 'off' || raw === 'no' || raw === 'false') return false
+  throw new Error(`${name} must be on or off`)
+}
+
+async function decideService(
+  options: SetupOptions,
+  status: ReturnType<typeof getDaemonServiceStatus>,
+): Promise<boolean> {
+  if (options.ci) {
+    if (options.service === true) throw new Error('--ci cannot install a machine service')
+    return false
+  }
+  if (!status.supported) return false
+  if (status.installed && options.service === undefined) return true
+  if (options.service !== undefined) return options.service
+  if (options.yes) return true
+  requireInteractive(options, '--service or --no-service')
+  return confirm('Install the background service and shared managed runtime?', true)
+}
+
+async function decideRepository(
+  options: SetupOptions,
+  packageRoot: string | null,
+): Promise<boolean> {
+  if (!packageRoot) {
+    if (options.repository === true) throw new Error('--repo requires a package.json')
+    return false
+  }
+  if (options.repository !== undefined) return options.repository
+  if (options.yes) return true
+  requireInteractive(options, '--repo or --no-repo')
+  return confirm(`Prepare ${packageRoot} for reproducible rnx runs?`, true)
+}
+
+async function decidePrivacy(
+  options: SetupOptions,
+  key: 'productAnalytics' | 'crashReports',
+  current: boolean,
+  configured: boolean,
+): Promise<boolean> {
+  const explicit =
+    key === 'productAnalytics' ? options.productAnalytics : options.crashReports
+  if (explicit !== undefined) return explicit
+  if (configured) return current
+  if (options.yes) return true
+  const flag =
+    key === 'productAnalytics' ? '--analytics on|off' : '--crash-reports on|off'
+  requireInteractive(options, flag)
+  const question =
+    key === 'productAnalytics'
+      ? 'Share bounded product analytics?'
+      : 'Send bounded crash reports?'
+  return confirm(question, true)
+}
+
+async function decideCompatibilitySharing(
+  options: SetupOptions,
+  scan: ScanResult | null,
+): Promise<boolean> {
+  if (!scan) return false
+  if (options.shareCompatibility) return true
+  if (options.yes || !process.stdin.isTTY) return false
+  return confirm(
+    'Share dependency names, requested versions, framework, and this compatibility result?',
+    false,
+  )
+}
+
+function requireInteractive(options: SetupOptions, flags: string): void {
+  if (process.stdin.isTTY && !options.ci) return
+  throw new Error(`non-interactive setup requires ${flags}, or --yes to accept defaults`)
+}
+
+function scanPackage(packageRoot: string): ScanResult {
+  const parsed: unknown = JSON.parse(
+    fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'),
+  )
+  if (!parsed || typeof parsed !== 'object') {
+    throw new Error('package.json must contain an object')
+  }
+  return scanDeps(parsed)
+}
+
+async function shareCompatibilityScan(
+  packageRoot: string,
+  scan: ScanResult,
+): Promise<void> {
+  const parsed: unknown = JSON.parse(
+    fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'),
+  )
+  if (!parsed || typeof parsed !== 'object')
+    throw new Error('package.json must be an object')
+  const response = await fetch('https://contrast.dev/api/scan', {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(buildCompatibilitySharePayload(parsed, scan)),
+    signal: AbortSignal.timeout(10_000),
+  })
+  if (!response.ok) {
+    throw new Error(`compatibility sharing failed with HTTP ${response.status}`)
+  }
+}
+
+export function buildCompatibilitySharePayload(manifest: object, scan: ScanResult) {
+  return {
+    dependencies: boundedDependencies(Reflect.get(manifest, 'dependencies')),
+    devDependencies: boundedDependencies(Reflect.get(manifest, 'devDependencies')),
+    framework: scan.framework,
+    result: {
+      framework: scan.framework,
+      rnVersion: scan.rnVersion,
+      packages: scan.packages.slice(0, 200),
+    },
+    source: 'desktop',
+    shared: true,
+  }
+}
+
+function boundedDependencies(value: unknown): Record<string, string> {
+  if (!value || typeof value !== 'object') return {}
+  const output: Record<string, string> = {}
+  for (const [name, version] of Object.entries(value).slice(0, 200)) {
+    if (typeof version !== 'string') continue
+    output[name.slice(0, 160)] = version.slice(0, 80)
+  }
+  return output
+}
+
+function runtimeCacheMetadata(runtimeVersion: string) {
+  const platform = os.platform()
+  const arch = os.arch()
+  return {
+    path: runtimeDir(runtimeVersion),
+    key: `sootsim-runtime-${platform}-${arch}-${runtimeVersion}`,
+    inputs: { platform, arch, runtimeVersion },
+  }
+}
+
+function printIntro(options: SetupOptions): void {
+  if (options.json) return
+  console.log(`\n  ${options.fromWelcome ? 'welcome to rnx' : 'rnxsim setup'}`)
+}
+
+function printMachineSection(
+  options: SetupOptions,
+  status: ReturnType<typeof getDaemonServiceStatus>,
+  service: boolean,
+  runtimeVersion: string,
+): void {
+  if (options.json) return
+  console.log(`\n  1. machine`)
+  console.log(`     stable runtime: ${runtimeVersion}`)
+  console.log(
+    `     background service: ${status.supported ? (service ? 'install' : 'skip') : 'unsupported on this platform'}`,
+  )
+}
+
+function printRepositorySection(
+  options: SetupOptions,
+  packageRoot: string | null,
+  plan: RepositorySetupPlan | null,
+): void {
+  if (options.json) return
+  console.log(`\n  2. repository`)
+  if (!packageRoot) {
+    console.log(`     no package.json found; repository preparation skipped`)
+    return
+  }
+  if (!plan) {
+    console.log(`     skipped for ${packageRoot}`)
+    return
+  }
+  console.log(`     package manager: ${detectPreferredPackageManager(packageRoot)}`)
+  for (const operation of formatRepositoryOperations(plan)) {
+    console.log(`     ${options.dryRun ? 'would run' : 'run'}: ${operation}`)
+  }
+}
+
+function printPrivacySection(
+  options: SetupOptions,
+  productAnalytics: boolean,
+  crashReports: boolean,
+): void {
+  if (options.json) return
+  console.log(`\n  3. privacy`)
+  console.log(`     product analytics: ${productAnalytics ? 'on' : 'off'}`)
+  console.log(
+    `       command, feature, version, platform, and bounded performance events`,
+  )
+  console.log(`     crash reports: ${crashReports ? 'on' : 'off'}`)
+  console.log(
+    `       error type, message, stack, runtime version, platform, and bounded dependency summary`,
+  )
+  console.log(
+    `     source files, environment values, terminal output, app data, screenshots, and recordings are not included`,
+  )
+}
+
+function printCompatibilitySection(
+  options: SetupOptions,
+  scan: ScanResult | null,
+  shared: boolean,
+): void {
+  if (options.json) return
+  console.log(`\n  4. compatibility`)
+  if (!scan) {
+    console.log(`     no package.json found; run \`rnxsim compat\` inside an app later`)
+    return
+  }
+  console.log(`     ${formatScanCounts(scan)}`)
+  for (const line of formatDetailedScanLines(scan)) console.log(`     ${line}`)
+  console.log(`     ${COMPAT_RESULT_CAVEAT}`)
+  console.log(`     dependency sharing: ${shared ? 'yes' : 'no'}`)
+}
+
+function printReadySection(repository: RepositorySetupPlan | null): void {
+  console.log(`\n  5. ready`)
+  if (repository) {
+    const command =
+      repository.packageManager === 'bun'
+        ? 'bun run sootsim'
+        : `${repository.packageManager} run rnxsim`
+    console.log(`     start your app normally, then ${command} -- <port>`)
+  } else {
+    console.log(`     start your app normally, then rnxsim open <port>`)
+  }
+  console.log(
+    `     useful next commands: rnxsim describe; rnxsim get errors; rnxsim compat`,
+  )
+  console.log(
+    `     install agent skills with \`rnxsim skill install\`, then start a new session`,
+  )
+  console.log(
+    `     if a concrete rnx seam is missing or broken, preview \`rnxsim report-issue\` and confirm separately`,
+  )
+}
+
+function boundedMessage(error: unknown): string {
+  const message = error instanceof Error ? error.message : String(error)
+  return message.replace(/(?:\/?[\w.-]+)+/g, '<path>').slice(0, 240)
+}
+
+function printHelp(): void {
+  console.log(`
+rnxsim setup — configure a machine and optionally prepare the current repository
+
+usage:
+  rnxsim setup
+  rnxsim setup --yes
+  rnxsim setup --ci --yes --json
+  rnxsim setup --dry-run --yes
+
+decisions:
+  --service | --no-service
+  --repo | --no-repo
+  --analytics on|off
+  --crash-reports on|off
+  --share-compat
+
+automation:
+  --yes       accept defaults; compatibility sharing still defaults off
+  --ci        never prompt or install a background service
+  --json      emit runtime/cache metadata as JSON
+  --dry-run   print exact repository operations without changing the machine
+  --app DIR   use DIR as the repository search start
+`)
+}

package/cli/commands/shell-boolean-mode.ts

@@ -0,0 +1,81 @@
+import { callInBridge, createBridgeFromParsed, parseBridgeCliArgs } from '../ws-bridge'
+
+export type ShellBooleanModeAction = 'on' | 'off' | 'toggle'
+
+export interface ShellBooleanModeOptions {
+  port?: number
+  verbose?: boolean
+}
+
+export interface ShellBooleanModeConfig {
+  modeKey: string
+  displayName: string
+  actionId: string
+}
+
+export interface ShellBooleanModeResult {
+  current: boolean
+  target: boolean
+  changed: boolean
+}
+
+export function parseShellBooleanModeAction(args: string[]): ShellBooleanModeAction {
+  const action = args[0]?.toLowerCase() ?? 'toggle'
+  if (action !== 'on' && action !== 'off' && action !== 'toggle') {
+    console.error(`  unknown argument: "${action}" (expected on | off | toggle)`)
+    process.exit(1)
+  }
+  return action
+}
+
+export async function runShellBooleanMode(
+  args: string[],
+  opts: ShellBooleanModeOptions,
+  config: ShellBooleanModeConfig,
+): Promise<ShellBooleanModeResult> {
+  const parsed = parseBridgeCliArgs(args, { port: opts.port })
+  const action = parseShellBooleanModeAction(parsed.positional)
+  const bridge = createBridgeFromParsed({ ...parsed, commandTimeoutMs: 5000 })
+  try {
+    const settings = await callInBridge<Record<string, unknown>>(
+      bridge,
+      'SootSim.bridges.settings.get',
+    )
+    const current = Boolean(settings?.[config.modeKey])
+    const target = action === 'on' ? true : action === 'off' ? false : !current
+    if (current === target) {
+      console.log(`  ${config.displayName}: already ${target ? 'on' : 'off'}`)
+      return { current, target, changed: false }
+    }
+    const changed = await bridge.send({
+      type: 'evaluate',
+      acquireLock: true,
+      code: `(async () => {
+        const modeKey = ${JSON.stringify(config.modeKey)}
+        const target = ${JSON.stringify(target)}
+        window.dispatchEvent(new CustomEvent('sootsim:shell-command', {
+          detail: { type: 'fire-action', id: ${JSON.stringify(config.actionId)} },
+        }))
+        const deadline = Date.now() + 1200
+        while (Date.now() < deadline) {
+          if (Boolean(window.SootSim?.bridges?.settings?.get?.()?.[modeKey]) === target) {
+            return true
+          }
+          await new Promise((resolve) => setTimeout(resolve, 40))
+        }
+        return false
+      })()`,
+    })
+    if (!changed) {
+      throw new Error(
+        `${config.displayName} did not change to ${target ? 'on' : 'off'}; the live shell may not support this mode`,
+      )
+    }
+    console.log(
+      `  ${config.displayName}: ${current ? 'on' : 'off'} -> ${target ? 'on' : 'off'}`,
+    )
+    return { current, target, changed: true }
+  } finally {
+    bridge.close()
+  }
+}