peachsim 0.1.1625 → 0.1.1640

package/cli/commands/upload.ts

@@ -1,6 +1,6 @@
-// peach record upload — capture the currently-loaded bundle + device spec from
-// a running peach sim and POST it to the Contrast upload endpoint. returns a
-// /preview/<id> url that loads this bundle in a frame.
+// peach record upload — publish a recording from a running simulator. scene
+// recordings carry their own content identity; --live-bundle adds the app
+// bundle for interactive playback under the existing bundle identity.
 //
 // uploads with no repository association are private by default: only
 // signed-in members of the uploader's account can open the link until the
@@ -9,7 +9,8 @@
 // associated with the user's account.
 
 import { createHash, randomUUID } from 'crypto'
-import { readFileSync } from 'fs'
+import { readFileSync, rmSync } from 'fs'
+import { tmpdir } from 'os'
 import path from 'path'
 import { gzipSync, gunzipSync } from 'zlib'
 import { readProfileTrace } from '@peach/globals/profile-trace'
@@ -36,11 +37,13 @@ import {
   mergeProfileTimeline,
   profileFrameSummary,
 } from 'peach-engine/profiler/profile-trace'
+import { readSceneRecordingUpload } from 'peach-engine/remote-stream/scene-recording'
 import {
   resolvedExpoAppIconUrl,
   expoConfigFromManifest,
 } from '../../../peach-engine/src/engine/expo-manifest'
 import { loopbackOriginOf } from '../../src/backend-origin'
+import { parseExpoManifestBody } from '../../src/expo-manifest-body'
 import { rnxPublicBrand } from '../../src/public-brand'
 import { fetchAppFontFiles } from '../app-fonts'
 import { fetchAppSplashImages } from '../app-splash'
@@ -57,6 +60,7 @@ import {
   parseBridgeCliArgs,
 } from '../ws-bridge'
 import type { SootSimTimelineEvent } from '@peach/globals'
+import type { BundleSnapshot } from 'peach-engine/preview/capture-bundle'
 
 interface UploadOptions {
   port?: number
@@ -83,19 +87,6 @@ function parseServerMessage(responseText?: string): string | null {
   }
 }
 
-type BundleSnapshot = {
-  bundleUrl: string | null
-  entry: string | null
-  deviceSpec: InitRequestBody['deviceSpec']
-  runtimeVersion: string | null
-  pageHref: string
-  transformedBundle: {
-    url: string
-    byteLength: number
-    timestamp: number
-  } | null
-}
-
 type AttachedInteractionSnapshot = {
   meta: NonNullable<InitRequestBody['snapshots']>[number] & { id: string }
   bytes: Uint8Array
@@ -181,10 +172,10 @@ export function resolvePublicPreviewOrigin(
 
 function printHelp() {
   console.log(`
-peach record upload — publish the current recorded bundle as a /preview/<id> link
+peach record upload — publish a recording as a /preview/<id> link
 
 usage:
-  peach record upload [--origin <url>] [--public-origin <url>] (--events <path> | --video <path>) [--screenshot <path>] [--owner <org> --repo <repo>] [--sim <sim>] [--open] [--assets-only]
+  peach record upload [--origin <url>] [--public-origin <url>] (--events <path> | --video <path> | --scene <path>) [--live-bundle] [--screenshot <path>] [--owner <org> --repo <repo>] [--sim <sim>] [--open] [--assets-only]
 
 options:
   --origin <url>     upload target (default: ${REMOTE_DEFAULT_ORIGIN})
@@ -194,8 +185,8 @@ options:
                      for prod uploads, upload origin for localhost/custom origins).
                      override with PEACH_PREVIEW_ORIGIN env var
   --events <path>    path to a gzipped events .jsonl.gz file to attach
-                     required unless --video is present; previews must
-                     have replay or recording playback data
+                     required unless --video or --scene is present;
+                     previews must have replay or recording playback data
   --screenshot <path>
                      path to a PNG thumbnail to attach to the share
   --snapshot-manifest <path>
@@ -205,6 +196,11 @@ options:
                      /api/preview/flow-video?id=<share-id>
   --video-duration-ms <ms>
                      duration hint for attached flow video
+  --scene <path>     a scene recording (.psr.gz) of a remote viewer's display
+                     stream. the preview paints it through the simulator's
+                     renderer instead of playing a video; uploads without a
+                     live bundle by default
+  --live-bundle     include the running app bundle for Live alongside --scene
   --timeline-events <path>
                      extra trace timeline rows, JSONL or JSONL gz
   --trace-profile <path>
@@ -436,6 +432,13 @@ export async function runUpload(
   const screenshotPath = extractStringFlag(mutableArgs, '--screenshot')
   const snapshotManifestPath = extractStringFlag(mutableArgs, '--snapshot-manifest')
   const videoPath = extractStringFlag(mutableArgs, '--video')
+  const scenePath = extractStringFlag(mutableArgs, '--scene')
+  const includeLiveBundle = extractBoolFlag(mutableArgs, '--live-bundle')
+  if (includeLiveBundle && !scenePath) {
+    console.error('  --live-bundle requires --scene')
+    peachExit(1)
+  }
+  const hasBundle = includeLiveBundle || !scenePath
   const timelineEventsPath = extractStringFlag(mutableArgs, '--timeline-events')
   const traceProfilePath = extractStringFlag(mutableArgs, '--trace-profile')
   const failureBundleDir = extractStringFlag(mutableArgs, '--failure-bundle')
@@ -468,9 +471,9 @@ export async function runUpload(
     console.error('  --billing-kind test_run is only for hosted test jobs')
     peachExit(1)
   }
-  if (!eventsPath && !videoPath) {
+  if (!eventsPath && !videoPath && !scenePath) {
     console.error(
-      '  preview uploads require playback data: pass --events or --video.\n' +
+      '  preview uploads require playback data: pass --events, --video or --scene.\n' +
         '  for a normal local preview, use `peach record --mode combined --open`\n' +
         '  or `peach maestro test --preview` instead of uploading a bundle-only snapshot.',
     )
@@ -493,6 +496,7 @@ export async function runUpload(
   })
 
   const bridge = createBridgeFromParsed(parsed)
+  let shellUrl: string | null = null
   let snapshot: BundleSnapshot
   // bundle-origin manifest (no bodies) — CLI re-fetches these over http so
   // they can be large without blowing the ws frame cap. sibling bundle
@@ -513,6 +517,7 @@ export async function runUpload(
   const localTraceTimelineCount = traceTimelineEvents.length
   let transformedBundleText: string | null = null
   try {
+    if (scenePath) shellUrl = await evalInBridge<string>(bridge, 'location.href')
     snapshot = await evalInBridge<BundleSnapshot>(
       bridge,
       '(typeof window.__sootsimCaptureBundle === "function") ? window.__sootsimCaptureBundle() : null',
@@ -660,7 +665,7 @@ export async function runUpload(
         }
       }
     }
-    if (snapshot?.transformedBundle) {
+    if (hasBundle && snapshot?.transformedBundle) {
       transformedBundleText = await pullTransformedBundle(
         bridge,
         snapshot.transformedBundle.byteLength,
@@ -703,7 +708,7 @@ export async function runUpload(
     )
     peachExit(2)
   }
-  if (!snapshot.bundleUrl) {
+  if (hasBundle && !snapshot.bundleUrl) {
     console.error(
       '  no ?bundle= URL on the current peach tab.\n' +
         '  open the app you want to share first (e.g. peach open 8082), then run upload.',
@@ -716,15 +721,15 @@ export async function runUpload(
   // does not have to re-run sootsim's transforms. fall back to re-fetching
   // the raw metro URL + forcing lazy=false when the transform hasn't
   // published yet (e.g., tab was opened but bundle not finished loading).
-  let bundleBytes: Uint8Array
+  let bundleBytes: Uint8Array | undefined
   let isTransformed = false
-  if (transformedBundleText !== null) {
+  if (hasBundle && transformedBundleText !== null) {
     bundleBytes = new TextEncoder().encode(transformedBundleText)
     isTransformed = true
     console.log(
       `  using post-transform bundle: ${(bundleBytes.byteLength / 1024).toFixed(1)} KiB`,
     )
-  } else {
+  } else if (hasBundle && snapshot.bundleUrl) {
     const fetchBundleUrl = forceInlineBundle(snapshot.bundleUrl)
     if (fetchBundleUrl !== snapshot.bundleUrl) {
       console.log(`  forcing lazy=false for self-contained bundle`)
@@ -872,6 +877,17 @@ export async function runUpload(
     )
   }
 
+  let sceneBytes: Uint8Array | undefined
+  let sceneStream: InitRequestBody['sceneStream']
+  if (scenePath) {
+    sceneBytes = readFileSync(scenePath)
+    const { header, slot } = await readSceneRecordingUpload(sceneBytes)
+    sceneStream = slot
+    console.log(
+      `  attaching scene stream: ${(sceneBytes.byteLength / 1024).toFixed(1)} KiB, ${header.frameCount} frames over ${Math.round(header.durationMs)}ms`,
+    )
+  }
+
   // priority: PEACH_API_KEY env → github runner token → saved credential
   // file → session token. github runner auth is what keeps installed PR
   // previews from requiring a new Contrast secret.
@@ -883,11 +899,26 @@ export async function runUpload(
     console.error('  set PEACH_API_KEY=sk_rnx_... or run `peach login`.')
     peachExit(1)
   }
+  if (sceneBytes && shellUrl && cliAuth.kind === 'github') {
+    const { renderSceneToVideo } = await import('../scene-video')
+    const output = path.join(tmpdir(), `peach-scene-video-${Date.now()}.mp4`)
+    try {
+      const rendered = await renderSceneToVideo({ scene: sceneBytes, shellUrl, output })
+      videoBytes = readFileSync(output)
+      videoContentType = 'video/mp4'
+      videoDurationMs = rendered.durationMs
+      console.log(
+        `  rendered scene video: ${rendered.frameCount} frames at 60 fps, ${rendered.sizeBytes} bytes in ${(rendered.renderTimeMs / 1000).toFixed(1)}s`,
+      )
+    } finally {
+      rmSync(output, { force: true })
+    }
+  }
   const resolvedAuthHeader = authHeaderValue(cliAuth)
 
   const bundleOrigin = (() => {
     try {
-      return new URL(snapshot.bundleUrl).origin
+      return snapshot.bundleUrl ? new URL(snapshot.bundleUrl).origin : null
     } catch {
       return null
     }
@@ -1002,16 +1033,16 @@ export async function runUpload(
   // explicitly so the installed app keeps its identity in share replay.
   const appIdentityFiles: PreparedFile[] = []
   let appManifest: string | undefined
-  const metroOrigin = loopbackOriginOf(snapshot.bundleUrl)
-  if (metroOrigin) {
+  const metroOrigin = snapshot.bundleUrl ? loopbackOriginOf(snapshot.bundleUrl) : null
+  if (metroOrigin && snapshot.bundleUrl) {
     const platform = new URL(snapshot.bundleUrl).searchParams.get('platform') || 'ios'
     const manifestUrl = `${metroOrigin}/`
     const response = await fetch(manifestUrl, {
       headers: { 'expo-platform': platform, accept: 'application/json' },
       signal: AbortSignal.timeout(30_000),
     })
-    if (response.ok && response.headers.get('content-type')?.includes('json')) {
-      const manifest: unknown = await response.json()
+    if (response.ok && !response.headers.get('content-type')?.includes('html')) {
+      const manifest: unknown = parseExpoManifestBody(await response.text())
       const config = expoConfigFromManifest(manifest)
       if (config) {
         appManifest = manifestUrl
@@ -1085,19 +1116,31 @@ export async function runUpload(
   // brotli source bytes for the upload. finalize verifies the source hash,
   // minifies in the node build container, and stores one canonical brotli
   // bundle. assets stay gzip below.
-  const bundleBr = brotliBundle(bundleBytes)
-  const bundleSha256 = createHash('sha256').update(bundleBytes).digest('hex')
-  console.log(
-    `  bundle raw=${(bundleBytes.byteLength / 1024).toFixed(1)} KiB br=${(bundleBr.byteLength / 1024).toFixed(1)} KiB`,
-  )
+  const bundleBr = bundleBytes ? brotliBundle(bundleBytes) : undefined
+  const identityBytes = bundleBytes ?? sceneBytes
+  if (!identityBytes) throw new Error('upload requires a bundle or scene recording')
+  const contentHash = createHash('sha256').update(identityBytes).digest('hex')
+  if (bundleBytes && bundleBr) {
+    console.log(
+      `  bundle raw=${(bundleBytes.byteLength / 1024).toFixed(1)} KiB br=${(bundleBr.byteLength / 1024).toFixed(1)} KiB`,
+    )
+  }
 
   const initBody: InitRequestBody = {
-    contentHash: bundleSha256,
-    bundleSizeBytes: bundleBytes.byteLength,
-    bundleContentType: guessBundleContentType(snapshot.bundleUrl),
-    bundleEncoding: 'br',
-    bundleMinified: false,
-    bundleOrigin,
+    contentHash,
+    hasBundle,
+    ...(bundleBytes && snapshot.bundleUrl
+      ? {
+          bundleSizeBytes: bundleBytes.byteLength,
+          bundleNativeAppIdentityHeader: snapshot.bundleNativeAppIdentityHeader,
+          bundleContentType: guessBundleContentType(snapshot.bundleUrl),
+          bundleEncoding: 'br',
+          bundleMinified: false,
+          bundleOrigin,
+          entry: snapshot.entry,
+          isTransformed,
+        }
+      : {}),
     runtimeVersion: snapshot.runtimeVersion ?? undefined,
     // config-only fonts resolved by `peach open` and carried on the engine
     // URL. persist them onto the share meta so /preview/<id> re-applies
@@ -1108,8 +1151,6 @@ export async function runUpload(
     // /preview/<id> re-applies `?appSplash=` and paints the same splash; the
     // image bytes are staged above so the engine's <img> resolves in preview.
     appSplash: appSplashWire || undefined,
-    entry: snapshot.entry,
-    isTransformed,
     deviceSpec: snapshot.deviceSpec,
     installationId: gitHubIdentity?.installationId ?? undefined,
     repoId: gitHubIdentity?.repoId,
@@ -1179,6 +1220,7 @@ export async function runUpload(
             durationMs: videoDurationMs,
           }
         : undefined,
+    sceneStream,
   }
 
   const filesByHash = new Map<string, Uint8Array>()
@@ -1191,7 +1233,7 @@ export async function runUpload(
   }
 
   const putT0 = Date.now()
-  let putBytes = bundleBr.byteLength
+  let putBytes = bundleBr?.byteLength ?? 0
   for (const f of prepared) putBytes += f.bytes.byteLength
   if (eventsGz) putBytes += eventsGz.byteLength
   putBytes += timelineGz.byteLength
@@ -1201,6 +1243,7 @@ export async function runUpload(
   for (const snapshot of interactionSnapshots) putBytes += snapshot.bytes.byteLength
   if (failureBundleGz) putBytes += failureBundleGz.byteLength
   if (videoBytes) putBytes += videoBytes.byteLength
+  if (sceneBytes) putBytes += sceneBytes.byteLength
 
   const initUrl = `${normalizeOrigin(origin)}/api/preview/upload/init`
   console.log(`  init: ${initUrl}`)
@@ -1217,6 +1260,7 @@ export async function runUpload(
         timelineBytes: timelineGz,
         storageBytes: storageGz,
         videoBytes,
+        sceneStreamBytes: sceneBytes,
         failureBundleBytes: failureBundleGz,
         snapshotBytes,
       },
@@ -1225,13 +1269,14 @@ export async function runUpload(
     })
     finalize = result.finalize
     const totalObjects =
-      1 +
+      (result.init.bundle ? 1 : 0) +
       result.init.files.length +
       (result.init.events ? 1 : 0) +
       (result.init.timeline ? 1 : 0) +
       (result.init.storage ? 1 : 0) +
       result.init.snapshots.length +
       (result.init.flowVideo ? 1 : 0) +
+      (result.init.sceneStream ? 1 : 0) +
       (result.init.failureBundle ? 1 : 0)
     console.log(
       `  PUT ${totalObjects} objects in ${Date.now() - putT0}ms (${(putBytes / 1024).toFixed(1)} KiB)`,

package/cli/desktop-companion.ts

@@ -1,9 +1,29 @@
 import { execFileSync, spawn } from 'child_process'
-import { existsSync, mkdirSync, writeFileSync } from 'fs'
+import {
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readdirSync,
+  symlinkSync,
+  unlinkSync,
+  writeFileSync,
+} from 'fs'
+import { createHash } from 'node:crypto'
+import { tmpdir } from 'os'
 import { dirname, join, resolve } from 'path'
 import { fileURLToPath } from 'url'
-import { activeDesktopHostApp, isNativeHostBundle } from '../src/desktop-host-delivery'
-import { rnxHomeDir } from '../src/home-paths'
+import {
+  activeDesktopHostApp,
+  desktopHostPlatform,
+  isNativeHostBundle,
+} from '../src/desktop-host-delivery'
+import {
+  isDaemonLockfileFresh,
+  isDevBridgeLockfileFresh,
+  readDaemonLockfile,
+  readDevBridgeLockfiles,
+  rnxHomeDir,
+} from '../src/home-paths'
 
 // resolved lazily: peach-engine is a workspace package in dev, but absent
 // from the published npm tarball. don't crash module load just because the
@@ -95,22 +115,31 @@ export function findInstalledDesktopCompanion(): DesktopCompanionInstall | null
     : findNativeDesktopCompanion()
 }
 
+// leftover Electron bundles. /Applications/Peach.app is the native host on a
+// case-insensitive volume, so bundle id decides, not the path's letter case.
+function retiredElectronApps(): string[] {
+  if (process.platform === 'darwin') {
+    return [
+      '/Applications/peach.app',
+      resolve(process.env.HOME || '', 'Applications/peach.app'),
+    ].filter((candidate) => existsSync(candidate) && !isNativeHostBundle(candidate))
+  }
+  if (process.platform !== 'linux') return []
+  return [
+    resolve(process.env.HOME || '', 'Applications/peach.AppImage'),
+    resolve(process.env.HOME || '', '.local/bin/peach.AppImage'),
+    '/opt/peach/peach.AppImage',
+    '/opt/peach/peach',
+  ].filter((candidate) => existsSync(candidate))
+}
+
 // existing Electron apps stay on disk; CLI users receive the migration once.
+// the notice names those apps and does not reject a native host beside them.
 export function notifyDesktopMigration(): void {
   if (process.platform !== 'darwin' && process.platform !== 'linux') return
-  const legacy =
-    process.platform === 'darwin'
-      ? [
-          '/Applications/peach.app',
-          resolve(process.env.HOME || '', 'Applications/peach.app'),
-        ].some((candidate) => existsSync(candidate) && !isNativeHostBundle(candidate))
-      : ['Applications/peach.AppImage', '.local/bin/peach.AppImage'].some((candidate) =>
-          existsSync(resolve(process.env.HOME || '', candidate)),
-        ) ||
-        existsSync('/opt/peach/peach.AppImage') ||
-        existsSync('/opt/peach/peach')
+  const legacy = retiredElectronApps()
   const marker = join(rnxHomeDir(), 'electron-native-migration')
-  if (!legacy || existsSync(marker)) return
+  if (legacy.length === 0 || existsSync(marker)) return
   mkdirSync(rnxHomeDir(), { recursive: true })
   try {
     writeFileSync(marker, '', { flag: 'wx' })
@@ -119,7 +148,7 @@ export function notifyDesktopMigration(): void {
     throw error
   }
   console.error(
-    '  Electron has retired on Mac and Linux. Install the native app: peach desktop install',
+    `  Electron has retired on Mac and Linux (${legacy.join(', ')}). Install the native app: peach desktop install`,
   )
 }
 
@@ -154,6 +183,21 @@ export function wantsNativeDesktop(opts: DesktopCompanionOptions = {}): boolean
   )
 }
 
+// the native app is the simulator window wherever it ships: always on Apple
+// silicon, and on Linux x64 in a desktop session once installed or when a
+// person is present to approve its package install's sudo prompt.
+export function nativeDesktopIsDefault(): boolean {
+  const platform = desktopHostPlatform()
+  if (platform === 'mac-arm64') return true
+  if (platform !== 'linux-x64') return false
+  if (!process.env.DISPLAY && !process.env.WAYLAND_DISPLAY) return false
+  return (
+    findNativeDesktopCompanion() !== null ||
+    process.stdin.isTTY === true ||
+    process.getuid?.() === 0
+  )
+}
+
 export function getNativeDesktopAppPath(): string | null {
   const explicitApp = process.env.PEACH_DESKTOP_APP
   if (!explicitApp)
@@ -284,6 +328,47 @@ async function openInConnectedMacApp(
   }
 }
 
+// PeachDesktop shipped before PEACH_BRIDGE_PORT seeds the page from
+// PEACH_HOME/daemon.json and ignores the launch URL's wsPort. when this
+// command is waiting on a different bridge, give the child a home whose
+// lock names that bridge. the caller's daemon.json is left untouched.
+// a newer host that prefers the env, the URL pin, or a fresh daemon still
+// sees this same port (the isolated-home rule in desktop host bridge selection).
+function macDesktopLaunchHome(bridgePort: number): string {
+  const home = rnxHomeDir()
+  const daemon = readDaemonLockfile()
+  if (isDaemonLockfileFresh(daemon) && daemon.bridgePort === bridgePort) return home
+  const dev = readDevBridgeLockfiles().find(
+    (lock) => lock.bridgePort === bridgePort && isDevBridgeLockfileFresh(lock),
+  )
+  const homeKey = createHash('sha256').update(home).digest('hex')
+  const dir = join(tmpdir(), 'peach-desktop-launch', homeKey, String(bridgePort))
+  mkdirSync(dir, { recursive: true })
+  if (existsSync(home)) {
+    for (const name of readdirSync(home)) {
+      if (name === 'daemon.json') continue
+      const dest = join(dir, name)
+      try {
+        lstatSync(dest)
+      } catch {
+        symlinkSync(join(home, name), dest)
+      }
+    }
+  }
+  const lockPath = join(dir, 'daemon.json')
+  try {
+    if (lstatSync(lockPath).isSymbolicLink()) unlinkSync(lockPath)
+  } catch {
+    // no lock yet
+  }
+  const pid = dev && dev.pid > 1 ? dev.pid : process.pid
+  writeFileSync(
+    lockPath,
+    JSON.stringify({ schema: 1, pid, bridgePort, heartbeatAt: Date.now() }),
+  )
+  return dir
+}
+
 export async function launchDesktopCompanion(
   url?: string,
   install = findDesktopCompanion(),
@@ -339,7 +424,7 @@ export async function launchDesktopCompanion(
       '-a',
       install.path,
       '--env',
-      `PEACH_HOME=${rnxHomeDir()}`,
+      `PEACH_HOME=${opts.bridgePort && launchUrl ? macDesktopLaunchHome(opts.bridgePort) : rnxHomeDir()}`,
     ]
     if (opts.bridgePort) {
       openArgs.push('--env', `PEACH_BRIDGE_PORT=${opts.bridgePort}`)

package/cli/drivers/desktop.ts

@@ -1,5 +1,6 @@
 // desktop driver selection is shared with companion discovery.
 
+import { desktopHostPlatform, headlessHostCommand } from '../../src/desktop-host-delivery'
 import {
   findDesktopCompanion,
   launchDesktopCompanion,
@@ -18,7 +19,19 @@ export function createDesktopDriver(id: 'desktop' | 'electron'): Driver {
   const missing = `peach ${id} app not installed (run \`peach desktop install${native ? '' : ' --electron'}\`)`
   function probe(): DriverAvailability {
     const install = findDesktopCompanion({ native })
-    if (!install) return { available: false, reason: missing }
+    if (!install) {
+      const host =
+        id === 'desktop' && native && desktopHostPlatform() === 'linux-x64'
+          ? headlessHostCommand()
+          : null
+      return host
+        ? {
+            available: true,
+            reason: null,
+            detail: `headless host @ ${host[0]} (use --driver playwright --headless)`,
+          }
+        : { available: false, reason: missing }
+    }
     return {
       available: true,
       reason: null,