peachsim 0.1.648 → 0.1.650

package/README.md

@@ -284,14 +284,15 @@ Peach sends no analytics, crash report, command event, app data, project data, o
 identity by default. An unsigned-in interactive run may request the runtime it
 is about to execute and the stable standalone CLI version document. The latter
 runs after the command in a detached process at most once every 20 hours and can
-be disabled with `PEACH_UPDATE_CHECK=off`. The first human run asks once about
-bounded diagnostics, defaults to no, and never prompts in a non-TTY shell, CI,
-or an agent. An automated first run is declined for that process without
-consuming the later human choice. Legacy browser and Electron telemetry senders
-are removed rather than being enabled by this consent.
-
-Opt-in diagnostics are limited to package name/version/unsupported API or error
-class. Peach never sends source, file paths, project names, app content, commands,
+be disabled with `PEACH_UPDATE_CHECK=off`. Bounded diagnostics and automatic
+crash reports are on by default; the first human run says once what they send,
+and `peach config telemetry off` or `DO_NOT_TRACK=1` turns them off. Legacy
+browser and Electron telemetry senders are removed rather than being enabled by
+this default.
+
+Diagnostics are limited to package name/version/unsupported API, error class
+and first-line message, and the command name with its exit code; a crash report
+files the same error fields in the issue queue. Peach never sends source, file paths, project names, app content, commands,
 identity, screenshots, or recordings as diagnostics. Cloud commands such as
 login, upload, billing, issue reporting, generated flows, and screenshot decks
 contact their documented service only when explicitly invoked. The complete
@@ -362,7 +363,7 @@ peach open /settings    # route via React Native Linking
 peach describe          # dump UI tree
 peach get errors 5      # recent runtime failures
 peach compat            # scan native package compatibility
-peach report-issue "…"  # preview an opt-in compatibility report
+peach support report "…"  # preview an opt-in compatibility report
 peach find --testid cta # inspect one node deeply
 peach debug enable animated,layout
 peach debug trace shell on 240

package/cli/command-registry.ts

@@ -43,6 +43,7 @@ const NODE_COMMAND_NAMES = [
   'remote',
   'preview',
   'swift',
+  'kotlin',
   'box',
   'list',
   'use',
@@ -50,7 +51,7 @@ const NODE_COMMAND_NAMES = [
   'close',
   'compat',
   'project-report',
-  'report-issue',
+  'support',
   'desktop',
   'login',
   'logout',

package/cli/commands/guest-host.ts

@@ -0,0 +1,67 @@
+// what `peach swift` and `peach kotlin` share: a loopback-only guest host
+// and the teardown of the simulator, driver and bridge their open started.
+import { isLoopbackHost } from '../../src/backend-origin'
+import { createBridge } from '../ws-bridge'
+import { runCloseCommand, type OpenCommandResources } from './control'
+import type http from 'node:http'
+
+export function isLoopbackGuestRequest(
+  req: http.IncomingMessage,
+  origin: string,
+): boolean {
+  if (req.headers.host !== new URL(origin).host) return false
+  if (!req.headers.origin) return true
+  try {
+    const requestOrigin = new URL(req.headers.origin)
+    return (
+      (requestOrigin.protocol === 'http:' || requestOrigin.protocol === 'https:') &&
+      isLoopbackHost(requestOrigin.hostname)
+    )
+  } catch {
+    return false
+  }
+}
+
+// answers whether every owned resource closed
+export async function closeGuestResources(
+  resources: OpenCommandResources,
+  label: string,
+): Promise<boolean> {
+  let closed = true
+  if (resources.simId && resources.port) {
+    try {
+      await runCloseCommand(['--sim', resources.simId], { port: resources.port })
+    } catch (error) {
+      console.error(`  ${label} cleanup failed: ${String(error)}`)
+      closed = false
+    }
+  }
+  if (
+    resources.driver?.driverId === 'playwright' &&
+    resources.driver.launched &&
+    resources.driver.pid
+  ) {
+    try {
+      process.kill(resources.driver.pid, 'SIGTERM')
+    } catch (error) {
+      if (!(error instanceof Error && 'code' in error && error.code === 'ESRCH')) {
+        console.error(String(error))
+        closed = false
+      }
+    }
+  }
+  if (resources.bridge && !resources.bridgeReady) resources.bridge.kill('SIGTERM')
+  if (resources.bridge && resources.bridgeReady && resources.port) {
+    const bridge = createBridge(resources.port)
+    try {
+      if ((await bridge.listSims()).length === 0) resources.bridge.kill('SIGTERM')
+      else console.log('  preserving the bridge adopted by another simulator')
+    } catch (error) {
+      console.error(`  cannot verify owned bridge cleanup: ${String(error)}`)
+      closed = false
+    } finally {
+      bridge.close()
+    }
+  }
+  return closed
+}

package/cli/commands/kotlin.ts

@@ -0,0 +1,231 @@
+import fs from 'node:fs'
+import http from 'node:http'
+import path from 'node:path'
+import { DEFAULT_DEVICE_BY_PLATFORM, devices } from 'peach-engine/settings/devices'
+import { WebSocket, WebSocketServer } from 'ws'
+import { kotlinGuestBundle } from '../../src/guest-bundle'
+import {
+  readKotlinApp,
+  type ComposeAndroidPins,
+  type KotlinAppProject,
+} from '../../src/kotlin-app'
+import { PeachExit } from '../run-rnx'
+import { runOpenCommand, type OpenCommandResources } from './control'
+import { closeGuestResources, isLoopbackGuestRequest } from './guest-host'
+
+const GUEST_PATH = '/__peach/kotlin-guest.js'
+const HMR_PATH = '/__peach/kotlin-hmr'
+// peachsim's Kotlin module: two levels above this file in source (cli/commands)
+// and in the built CLI (dist-cli/chunks)
+const MODULE_ROOT = path.resolve(import.meta.dirname, '../../kotlin')
+
+function composePins(): ComposeAndroidPins {
+  const toolchain: unknown = JSON.parse(
+    fs.readFileSync(path.join(MODULE_ROOT, 'toolchain.json'), 'utf8'),
+  )
+  const android =
+    typeof toolchain === 'object' && toolchain !== null
+      ? Reflect.get(Reflect.get(toolchain, 'compose') ?? {}, 'android')
+      : undefined
+  const pin = (name: string) => {
+    const value: unknown = android ? Reflect.get(android, name) : undefined
+    if (typeof value !== 'string')
+      throw new Error(`Kotlin toolchain has no Compose ${name} pin`)
+    return value
+  }
+  return {
+    ui: pin('ui'),
+    foundation: pin('foundation'),
+    runtime: pin('runtime'),
+    material3: pin('material3'),
+  }
+}
+
+// opens an Android app module the way the device launches it: the manifest's
+// launcher activity, cold-started in Peach's Kotlin process. sources compile
+// locally; an edit recompiles and starts a new process, as a rebuilt app does.
+export async function runKotlin(
+  args: string[],
+  opts: { port?: number; device?: string; driver?: string; headless?: boolean } = {},
+): Promise<number> {
+  const input = [...args]
+  const openArgs: string[] = []
+  let hostPort = 0
+  let activity: string | undefined
+  const valueFlags = new Set(['--driver', '--profile', '--cdp-port', '--base-url'])
+  const booleanFlags = new Set([
+    '--headless',
+    '--headed',
+    '--ephemeral',
+    '--quiet',
+    '--proof',
+  ])
+  let modulePath = ''
+  for (let index = 0; index < input.length; index++) {
+    const arg = input[index]
+    if (
+      arg === '--host-port' ||
+      arg === '--activity' ||
+      arg === '--device' ||
+      valueFlags.has(arg)
+    ) {
+      const value = input[++index]
+      if (!value || value.startsWith('-')) throw new Error(`${arg} requires a value`)
+      if (arg === '--host-port') {
+        hostPort = Number(value)
+        if (!Number.isInteger(hostPort) || hostPort < 1 || hostPort > 65535)
+          throw new Error('--host-port must be a port from 1 to 65535')
+      } else if (arg === '--activity') activity = value
+      else if (arg === '--device') opts.device = value
+      else openArgs.push(arg, value)
+    } else if (booleanFlags.has(arg)) openArgs.push(arg)
+    else if (arg.startsWith('-')) throw new Error(`unknown peach kotlin flag: ${arg}`)
+    else if (modulePath)
+      throw new Error('peach kotlin expects one Android app module directory')
+    else modulePath = path.resolve(arg)
+  }
+  if (!modulePath) throw new Error('usage: peach kotlin <android-app-module>')
+  const device = opts.device ?? DEFAULT_DEVICE_BY_PLATFORM.android
+  const spec: unknown = Reflect.get(devices, device)
+  if (!spec || Reflect.get(spec, 'platform') !== 'android')
+    throw new Error(
+      `peach kotlin runs an Android app; ${device} is not an Android device`,
+    )
+  const pins = composePins()
+  let project: KotlinAppProject = readKotlinApp(modulePath, { activity, pins })
+  const host = await import('../../src/kotlin-host')
+  const controller = new AbortController()
+  const resources: OpenCommandResources = {}
+  const sockets = new WebSocketServer({ noServer: true })
+  let origin = ''
+  const routes = () => ({
+    root: project.projectDir,
+    moduleRoot: MODULE_ROOT,
+    origin,
+    hmrPath: HMR_PATH,
+    project,
+  })
+  const server = http.createServer((req, res) => {
+    if (!isLoopbackGuestRequest(req, origin)) {
+      res.statusCode = 403
+      res.end('forbidden Kotlin host origin')
+      return
+    }
+    res.setHeader('access-control-allow-origin', req.headers.origin ?? '*')
+    res.setHeader('vary', 'origin')
+    res.setHeader('cache-control', 'no-store')
+    const pathname = new URL(req.url ?? '/', origin).pathname
+    if (pathname === GUEST_PATH) {
+      res.setHeader('content-type', 'application/javascript')
+      res.end(kotlinGuestBundle())
+      return
+    }
+    void host.serveKotlinRequest(pathname, res, routes()).then((served) => {
+      if (served) return
+      res.statusCode = 404
+      res.end('unknown Kotlin host asset')
+    })
+  })
+  server.on('upgrade', (req, socket, head) => {
+    if (
+      !isLoopbackGuestRequest(req, origin) ||
+      new URL(req.url ?? '/', origin).pathname !== HMR_PATH
+    ) {
+      socket.destroy()
+      return
+    }
+    sockets.handleUpgrade(req, socket, head, (client) =>
+      sockets.emit('connection', client, req),
+    )
+  })
+  // an edit rereads the module, rebuilds it, then tells the guest to start a
+  // new process; a failed build leaves the running process and prints why
+  let building: Promise<void> | undefined
+  let pending = false
+  const rebuild = () => {
+    pending = true
+    building ??= (async () => {
+      while (pending && !controller.signal.aborted) {
+        pending = false
+        try {
+          project = readKotlinApp(modulePath, { activity, pins })
+          const artifact = await host.kotlinAppArtifact(project, MODULE_ROOT, origin)
+          console.log(`  Kotlin artifact: ${artifact.hash}`)
+          const message = JSON.stringify({ type: 'kotlin', packageName: 'kotlin' })
+          for (const client of sockets.clients)
+            if (client.readyState === WebSocket.OPEN) client.send(message)
+        } catch (error) {
+          console.error(error instanceof Error ? error.message : String(error))
+        }
+      }
+    })().finally(() => {
+      building = undefined
+    })
+  }
+  const stop = () => controller.abort()
+  process.once('SIGINT', stop)
+  process.once('SIGTERM', stop)
+  let watcher: fs.FSWatcher | undefined
+  let code = 0
+  try {
+    await new Promise<void>((resolve, reject) => {
+      server.once('error', reject)
+      server.listen(hostPort, '127.0.0.1', () => {
+        server.removeListener('error', reject)
+        const address = server.address()
+        if (!address || typeof address === 'string') {
+          reject(new Error('Kotlin host has no loopback port'))
+          return
+        }
+        origin = `http://127.0.0.1:${address.port}`
+        resolve()
+      })
+    })
+    console.log(`  Kotlin app: ${project.launcher.name} in ${project.moduleDir}`)
+    const artifact = await host.kotlinAppArtifact(project, MODULE_ROOT, origin)
+    console.log(`  Kotlin artifact: ${artifact.hash}`)
+    watcher = fs.watch(project.moduleDir, { recursive: true }, (_event, file) => {
+      if (
+        file &&
+        file
+          .split(/[\\/]/)
+          .some((segment) => segment === 'build' || segment.startsWith('.'))
+      )
+        return
+      rebuild()
+    })
+    controller.signal.throwIfAborted()
+    openArgs.push('--device', device)
+    if (opts.driver) openArgs.push('--driver', opts.driver)
+    if (opts.headless) openArgs.push('--headless')
+    await runOpenCommand([`${origin}${GUEST_PATH}`, '--new', '--no-hmr', ...openArgs], {
+      port: opts.port,
+      resources,
+      signal: controller.signal,
+      ownerPid: process.pid,
+    })
+    await new Promise<void>((resolve) => {
+      if (controller.signal.aborted) resolve()
+      else controller.signal.addEventListener('abort', () => resolve(), { once: true })
+    })
+  } catch (error) {
+    if (!controller.signal.aborted) {
+      console.error(
+        `  peach kotlin failed: ${error instanceof Error ? error.message : String(error)}`,
+      )
+      code = error instanceof PeachExit ? error.code : 1
+    }
+  } finally {
+    controller.abort()
+    process.removeListener('SIGINT', stop)
+    process.removeListener('SIGTERM', stop)
+    watcher?.close()
+    await building
+    for (const client of sockets.clients) client.terminate()
+    sockets.close()
+    server.closeAllConnections()
+    await new Promise<void>((resolve) => server.close(() => resolve()))
+    if (!(await closeGuestResources(resources, 'Kotlin app'))) code = 1
+  }
+  return code
+}

package/cli/commands/project-report.ts

@@ -352,7 +352,7 @@ export function formatProjectReport(report: ProjectReport): string {
   lines.push(
     ...report.notes,
     '',
-    'To send this report: peach report-issue "<description>"',
+    'To send this report: peach support report "<description>"',
     'Review the preview and explicitly confirm before sending.',
     '',
   )

package/cli/commands/report-issue.ts

@@ -1,4 +1,4 @@
-// peach report-issue — submit an explicitly approved compatibility report.
+// peach support report — submit an explicitly approved compatibility report.
 
 import { existsSync } from 'node:fs'
 import { resolve } from 'node:path'
@@ -28,6 +28,7 @@ type ReportIssueOptions = {
 }
 
 export type ReportIssuePayload = {
+  kind: 'report'
   note: string
   timestamp: string
   sootsim_version: string | null
@@ -114,12 +115,11 @@ export function parseReportIssueOptions(
   }
 }
 
-export async function createReportIssuePayload(
-  options: Pick<ReportIssueOptions, 'appDir' | 'description'> & { scopeToApp?: boolean },
-  now = new Date(),
-): Promise<ReportIssuePayload> {
-  const manifest = readProjectManifest(options.appDir)
-  const installed = manifest ? installedManifest(options.appDir, manifest) : null
+// the context every support request carries: CLI and runtime versions, the
+// platform, and the dependency compatibility scan of the app directory
+export async function toolchainContext(appDir: string) {
+  const manifest = readProjectManifest(appDir)
+  const installed = manifest ? installedManifest(appDir, manifest) : null
   const safeVersions = (deps: Record<string, string> | undefined) =>
     deps &&
     Object.fromEntries(
@@ -140,37 +140,57 @@ export async function createReportIssuePayload(
   const runtimeVersion = activeRuntime
     ? sanitizeProjectReportVersion(activeRuntime)
     : null
+  return {
+    activeApp:
+      compatibility && compatibility.projectName !== 'unknown'
+        ? { appName: compatibility.projectName }
+        : null,
+    reportSource: 'cli' as const,
+    runtimeVersion,
+    cliVersion,
+    platform: process.platform,
+    arch: process.arch,
+    compatibility,
+  }
+}
 
+export async function createReportIssuePayload(
+  options: Pick<ReportIssueOptions, 'appDir' | 'description'> & { scopeToApp?: boolean },
+  now = new Date(),
+): Promise<ReportIssuePayload> {
+  const context = await toolchainContext(options.appDir)
   return {
+    kind: 'report',
     note: options.description,
     timestamp: now.toISOString(),
-    sootsim_version: runtimeVersion,
-    cli_version: cliVersion,
+    sootsim_version: context.runtimeVersion,
+    cli_version: context.cliVersion,
     bundle: {
-      activeApp:
-        compatibility && compatibility.projectName !== 'unknown'
-          ? { appName: compatibility.projectName }
-          : null,
-      reportSource: 'cli',
-      runtimeVersion,
-      cliVersion,
-      platform: process.platform,
-      arch: process.arch,
-      compatibility,
+      ...context,
       projectReport: createProjectReport(options.appDir, options.scopeToApp),
     },
   }
 }
 
-function reportEndpoint(): { url: string; authorization: string | null } {
+// where support requests go and who they come from: the login's origin and
+// bearer, and the account a `peach login --account` sign-in chose. a report
+// may go anonymously; an ask or a status read needs the sign-in.
+export function supportEndpoint(): {
+  origin: string
+  headers: Record<string, string>
+  signedIn: boolean
+} {
   const auth = resolveCliAuth()
-  const origin =
-    auth?.kind === 'session' ? auth.origin.replace(/\/+$/, '') : DEFAULT_REPORT_ORIGIN
-  const authorization = auth && auth.kind !== 'github' ? authHeaderValue(auth) : null
-  return {
-    url: `${origin}/api/sootsim/report-issue`,
-    authorization,
+  if (!auth || auth.kind === 'github') {
+    return { origin: DEFAULT_REPORT_ORIGIN, headers: {}, signedIn: false }
   }
+  const headers: Record<string, string> = { authorization: authHeaderValue(auth) }
+  if (auth.kind === 'session' && auth.accountId) {
+    headers['x-rnx-account-id'] = auth.accountId
+  }
+  const origin =
+    auth.kind === 'session' ? auth.origin.replace(/\/+$/, '') : DEFAULT_REPORT_ORIGIN
+  return { origin, headers, signedIn: true }
 }
 
 function compatibilitySummary(scan: ScanResult | null): string {
@@ -197,7 +217,7 @@ export async function runReportIssue(
   } catch (error) {
     dependencies.stderr(
       `  ${error instanceof Error ? error.message : String(error)}\n` +
-        `  usage: peach report-issue [--app <dir>] [--dry-run] [--yes] "<description>"\n`,
+        `  usage: peach support report [--app <dir>] [--dry-run] [--yes] "<description>"\n`,
     )
     return 1
   }
@@ -253,13 +273,12 @@ export async function runReportIssue(
     }
   }
 
-  const endpoint = reportEndpoint()
-  const headers: Record<string, string> = { 'content-type': 'application/json' }
-  if (endpoint.authorization) headers.authorization = endpoint.authorization
+  const endpoint = supportEndpoint()
+  const headers = { ...endpoint.headers, 'content-type': 'application/json' }
 
   let response: Response
   try {
-    response = await dependencies.request(endpoint.url, {
+    response = await dependencies.request(`${endpoint.origin}/api/sootsim/report-issue`, {
       method: 'POST',
       headers,
       body: JSON.stringify(payload),
@@ -284,6 +303,10 @@ export async function runReportIssue(
 
   const parsed: unknown = await response.json().catch(() => null)
   const id = readResponseId(parsed)
-  dependencies.stdout(id ? `\n  sent. Report id: ${id}\n` : `\n  sent. Thank you.\n`)
+  dependencies.stdout(
+    id
+      ? `\n  sent. Report id: ${id}\n  our replies and the fix show in \`peach support status\`.\n`
+      : `\n  sent. Thank you.\n`,
+  )
   return 0
 }

package/cli/commands/setup.ts

@@ -17,7 +17,7 @@ import {
 } from '../../src/home-paths'
 import { rnxRuntime } from '../../src/runtime-delivery'
 import { findDesktopCompanion } from '../desktop-companion'
-import { canPromptForPrivacyChoice } from '../privacy'
+import { PRIVACY_NOTICE } from '../privacy'
 import { confirm, select } from '../prompt'
 import {
   applyRepositorySetup,
@@ -159,8 +159,8 @@ export async function runSetup(
       )
     }
 
-    const productAnalytics = await decidePrivacy(options, privacy)
-    const crashReports = false
+    const productAnalytics = decidePrivacy(options, privacy)
+    const crashReports = productAnalytics
 
     const repositoryPlan = packageRoot
       ? planRepositorySetup({ appDir: packageRoot, cliVersion })
@@ -337,20 +337,16 @@ async function decideSimulatorDriver(
   return choice === 0 ? 'playwright' : 'electron'
 }
 
-async function decidePrivacy(
+// diagnostics and crash reports are on unless turned off; setup says so once
+// and records the choice
+function decidePrivacy(
   options: SetupOptions,
   current: ReturnType<typeof readPrivacyPreferences>,
-): Promise<boolean> {
+): boolean {
   if (options.productAnalytics !== undefined) return options.productAnalytics
   if (current.configured) return current.productAnalytics
-  if (options.yes || options.ci || !canPromptForPrivacyChoice()) return false
-  printPromptBlock('Private by default', [
-    'Diagnostics stay off unless you opt in, including CI, pipes and agent runs. DO_NOT_TRACK overrides opt-in.',
-    'Reports include CLI/runtime versions, OS/arch, command name and a random install ID.',
-    'They include package incompatibilities, error classes and first-line error/warning messages (300 characters, paths redacted).',
-    'Reports exclude arguments, stacks, app source and structured app data.',
-  ])
-  return confirm('Share bounded diagnostics to improve peach?', false)
+  if (!options.json) printPromptBlock('Diagnostics', PRIVACY_NOTICE)
+  return true
 }
 
 async function decideRepository(
@@ -414,7 +410,7 @@ choices:
   --repo | --no-repo
 
 automation:
-  --yes       accept recommended machine defaults; diagnostics and repo changes stay off
+  --yes       accept recommended machine defaults; repo changes stay off
   --ci        never prompt or install a background service
   --json      emit runtime and cache metadata as JSON
   --dry-run   show choices and repository operations without changing anything