peachsim 0.1.527 → 0.1.570

package/cli/commands/three-mode.ts

@@ -9,7 +9,7 @@ import { dirname, extname, resolve } from 'node:path'
 import {
   isThreeModeSetting,
   THREE_MODE_SETTING_IDS,
-} from 'sootsim-engine/screenshots/tokens'
+} from 'peach-engine/screenshots/tokens'
 import { rnxExit } from '../run-rnx'
 import {
   callInBridgeWrite,

package/cli/commands/upload.ts

@@ -9,18 +9,18 @@ import { createHash } from 'crypto'
 import { readFileSync } from 'fs'
 import path from 'path'
 import { gzipSync, gunzipSync } from 'zlib'
-import { shouldCompress } from 'sootsim-engine/preview/compress'
-import { brotliBundle } from 'sootsim-engine/preview/compress-node'
+import { shouldCompress } from 'peach-engine/preview/compress'
+import { brotliBundle } from 'peach-engine/preview/compress-node'
 import {
   runPresignedUpload,
   type InitRequestBody,
-} from 'sootsim-engine/preview/presigned-upload'
+} from 'peach-engine/preview/presigned-upload'
 import {
   TRACE_CAPTURE_POSTROLL_MS,
   TRACE_CAPTURE_PREROLL_MS,
   isTraceTimelineEvent,
   parseTraceTimelineJsonl,
-} from 'sootsim-engine/preview/trace'
+} from 'peach-engine/preview/trace'
 import { rnxPublicBrand } from '../../src/public-brand'
 import { fetchAppFontFiles } from '../app-fonts'
 import { fetchAppSplashImages } from '../app-splash'
@@ -34,7 +34,7 @@ import {
   evalInBridge,
   parseBridgeCliArgs,
 } from '../ws-bridge'
-import type { SootSimTimelineEvent } from '@rnx/globals'
+import type { SootSimTimelineEvent } from '@peach/globals'
 
 interface UploadOptions {
   port?: number

package/cli/commands/what-happened.ts

@@ -25,7 +25,7 @@ import {
   inspectTimelineSummary,
   NOISY_TIMELINE_KINDS,
 } from './inspect/core'
-import type { SootSimTimelineEvent, SootSimTimelineQuery } from '@rnx/globals'
+import type { SootSimTimelineEvent, SootSimTimelineQuery } from '@peach/globals'
 
 interface WhatHappenedOptions {
   port?: number

package/cli/desktop-companion.ts

@@ -12,7 +12,7 @@ function getSootsimRoot(): string | null {
   if (_sootsimRoot !== undefined) return _sootsimRoot
   try {
     _sootsimRoot = dirname(
-      fileURLToPath(import.meta.resolve('sootsim-engine/package.json')),
+      fileURLToPath(import.meta.resolve('peach-engine/package.json')),
     )
   } catch {
     _sootsimRoot = null
@@ -54,7 +54,7 @@ function findDevElectron(): DesktopCompanionInstall | null {
   if (!existsSync(engineMain)) return null
 
   // walk up from engine dir looking for a node_modules/.bin/electron.
-  // the repo layout is packages/sootsim-engine next to a root node_modules,
+  // the repo layout is packages/peach-engine next to a root node_modules,
   // but also works when installed as a dependency.
   const electronBin = findElectronBin(engineDir)
   if (!electronBin) return null
@@ -194,7 +194,7 @@ export function findDesktopCompanion(): DesktopCompanionInstall | null {
     if (!existsSync(engineMain)) {
       console.error(
         `  dist-electron/main.cjs missing in ${engineDir}.\n` +
-          `  run: bun run --cwd packages/sootsim-engine build:electron-main\n` +
+          `  run: bun run --cwd packages/peach-engine build:electron-main\n` +
           `  (or keep it fresh with: bun run watch:sootsim:electron-main)`,
       )
     } else {

package/cli/drivers/playwright-sim-host.ts

@@ -1,8 +1,8 @@
 import {
   readBrowserCompositeCaptureRequest,
   resolveBrowserCompositeCdpClip,
-} from '../../../sootsim-engine/src/capture/browser-composite'
-import { createBrowserPointerDispatcher } from '../../../sootsim-engine/src/render-worker/browser-pointer'
+} from '../../../peach-engine/src/capture/browser-composite'
+import { createBrowserPointerDispatcher } from '../../../peach-engine/src/render-worker/browser-pointer'
 // the detached browser host, as CJS source.
 //
 // it resolves playwright from the absolute path the driver hands it, launches

package/cli/flow-file.ts

@@ -16,6 +16,13 @@ export interface FlowFrontmatter {
   env?: Record<string, string>
   // maestro-compatible: workspace tag filtering (config.yml includeTags/excludeTags)
   tags?: string[]
+  // maestro-compatible: display name for reports. defaults the junit
+  // testcase id, name, and classname when properties does not override them.
+  name?: string
+  // maestro-compatible: custom junit <property> entries. junitId and
+  // junitClassname are reserved: they set the testcase attributes and are
+  // not emitted as properties.
+  properties?: Record<string, string>
 }
 
 // parse flow file. accepts three shapes:

package/cli/flow-live-status.ts

@@ -44,17 +44,21 @@ export class FlowLiveStatusReporter {
     private getSimId?: () => string | undefined,
   ) {}
 
-  private async send(payload: Record<string, unknown>, simId: string | undefined) {
+  private async send(
+    payload: Record<string, unknown>,
+    simId: string | undefined,
+  ): Promise<unknown> {
     const reply: unknown = await this.bridge.send({
       type: 'flowStatus',
       simId,
       status: { runId: this.runId, flowName: this.flowName, ...payload },
     })
     this.paused = replyPaused(reply)
+    return reply
   }
 
-  private async push(payload: Record<string, unknown>): Promise<void> {
-    if (this.disabled) return
+  private async push(payload: Record<string, unknown>): Promise<unknown> {
+    if (this.disabled) return undefined
     try {
       const simId = this.getSimId?.()
       if (
@@ -77,19 +81,68 @@ export class FlowLiveStatusReporter {
         }
       }
       this.lastSimId = simId
-      await this.send(payload, simId)
+      return await this.send(payload, simId)
     } catch (error) {
       this.disabled = true
       console.log(
         `[flow]   live status unavailable (${error instanceof Error ? error.message.slice(0, 120) : error}) — continuing without the devtools rail`,
       )
+      return undefined
     }
   }
 
-  async plan(steps: PlanStep[]): Promise<void> {
+  async plan(steps: PlanStep[], options: { dryRun?: boolean } = {}): Promise<void> {
     this.plannedSteps = steps.map((step) => ({ ...step }))
     this.completedSteps.clear()
-    await this.push({ phase: 'plan', state: 'running', steps, source: this.flowSource })
+    await this.push({
+      phase: 'plan',
+      state: options.dryRun ? 'idle' : 'running',
+      dryRun: options.dryRun,
+      steps,
+      source: this.flowSource,
+    })
+  }
+
+  async waitForStart(): Promise<void> {
+    if (this.disabled) return
+    while (!this.disabled) {
+      await new Promise((resolve) => setTimeout(resolve, 200))
+      const reply = await this.push({ phase: 'heartbeat', state: 'idle' })
+      if (
+        reply &&
+        typeof reply === 'object' &&
+        'control' in reply &&
+        typeof (reply as { control?: unknown }).control === 'object'
+      ) {
+        const ctrl = (reply as { control: { start?: boolean } }).control
+        if (ctrl?.start === true) {
+          return
+        }
+      }
+    }
+  }
+
+  async waitForResetOrRerun(): Promise<'reset' | 'start' | 'exit'> {
+    if (this.disabled) return 'exit'
+    while (!this.disabled) {
+      await new Promise((resolve) => setTimeout(resolve, 200))
+      const reply = await this.push({ phase: 'heartbeat' })
+      if (
+        reply &&
+        typeof reply === 'object' &&
+        'control' in reply &&
+        typeof (reply as { control?: unknown }).control === 'object'
+      ) {
+        const ctrl = (reply as { control: { reset?: boolean; start?: boolean } }).control
+        if (ctrl?.reset === true) {
+          return 'reset'
+        }
+        if (ctrl?.start === true) {
+          return 'start'
+        }
+      }
+    }
+    return 'exit'
   }
 
   async step(
@@ -114,10 +167,14 @@ export class FlowLiveStatusReporter {
   // steps only, so a pause never interrupts a step mid-gesture.
   async waitWhilePaused(): Promise<void> {
     if (this.disabled) return
-    while (this.paused) {
+    const reply = await this.push({ phase: 'heartbeat' })
+    if (replyPaused(reply)) {
+      this.paused = true
+    }
+    while (this.paused && !this.disabled) {
       console.log('[flow]   paused from devtools — waiting…')
       while (this.paused && !this.disabled) {
-        await new Promise((resolve) => setTimeout(resolve, PAUSE_POLL_MS))
+        await new Promise((resolve) => setTimeout(resolve, 200))
         await this.push({ phase: 'heartbeat', state: 'paused' })
       }
       if (!this.disabled) console.log('[flow]   resumed')

package/cli/help-core.ts

@@ -1,10 +1,10 @@
-import { cliCommandMetas } from '@rnx/skills/cli'
+import { cliCommandMetas } from '@peach/skills/cli'
 import {
   renderCliCommandHelp,
   renderCliGroupHelp,
   renderCliIndexHelp,
-} from '@rnx/skills/cli/renderers'
-import { formatFlagHelp } from 'sootsim-engine/settings/cli-flags'
+} from '@peach/skills/cli/renderers'
+import { formatFlagHelp } from 'peach-engine/settings/cli-flags'
 import {
   DEFAULT_SOOTSIM_BRIDGE_PORT,
   DEFAULT_SOOTSIM_BRIDGE_URL,

package/cli/hidden-runtime-alias.ts

@@ -1,4 +1,4 @@
-import { getCliInspectVerbMetaByPath } from '@rnx/skills/cli'
+import { getCliInspectVerbMetaByPath } from '@peach/skills/cli'
 import type { ParsedArgs } from './parse-args'
 
 const HIDDEN_RUNTIME_ALIAS_GROUPS = ['do', 'get'] as const

package/cli/maestro-report.ts

@@ -0,0 +1,178 @@
+// maestro-compatible run reports: junit xml, per-flow commands.json, and the
+// session/flow maestro.log text. pure builders over playback receipts — no
+// bridge, no filesystem — so the workspace tests cover them without a sim.
+//
+// the shapes mirror maestro's own outputs (test-reports-and-artifacts): one
+// <testsuite name="Test Suite"> per invocation, flow-header `properties:`
+// as <property> children, junitId/junitClassname reserved for the testcase
+// attributes, commands.json carrying one entry per executed step.
+
+import type { SootSimFlowTraceStep } from './bridge-flow-runner'
+
+export function escapeXml(value: string): string {
+  return value
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;')
+}
+
+export interface JUnitCaseInput {
+  // flow path as printed in the run (relative to the invocation cwd)
+  file: string
+  name: string
+  id: string
+  classname: string
+  // custom flow-header properties with the reserved junit keys removed
+  properties: Record<string, string>
+  tags: string[]
+  timeSeconds: number
+  failure: { message: string; body: string } | null
+}
+
+export interface JUnitSuiteInput {
+  device: string
+  cases: JUnitCaseInput[]
+}
+
+function formatJUnitTime(seconds: number): string {
+  return (Number.isFinite(seconds) && seconds >= 0 ? seconds : 0).toFixed(3)
+}
+
+export function buildJUnitXml(suite: JUnitSuiteInput): string {
+  const failures = suite.cases.filter((c) => c.failure !== null).length
+  const totalTime = suite.cases.reduce(
+    (sum, c) => sum + (Number.isFinite(c.timeSeconds) ? c.timeSeconds : 0),
+    0,
+  )
+  const lines = [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<testsuites>',
+    `  <testsuite name="Test Suite" device="${escapeXml(suite.device)}" tests="${suite.cases.length}" failures="${failures}" time="${formatJUnitTime(totalTime)}">`,
+  ]
+  for (const c of suite.cases) {
+    lines.push(
+      `    <testcase id="${escapeXml(c.id)}" name="${escapeXml(c.name)}" classname="${escapeXml(c.classname)}" file="${escapeXml(c.file)}" time="${formatJUnitTime(c.timeSeconds)}">`,
+    )
+    const properties: Array<{ name: string; value: string }> = []
+    if (c.tags.length > 0) {
+      properties.push({ name: 'tags', value: c.tags.join(',') })
+    }
+    for (const [name, value] of Object.entries(c.properties)) {
+      properties.push({ name, value })
+    }
+    if (properties.length > 0) {
+      lines.push('      <properties>')
+      for (const p of properties) {
+        lines.push(
+          `        <property name="${escapeXml(p.name)}" value="${escapeXml(p.value)}"/>`,
+        )
+      }
+      lines.push('      </properties>')
+    }
+    if (c.failure) {
+      lines.push(`      <failure message="${escapeXml(c.failure.message)}">`)
+      lines.push(escapeXml(c.failure.body))
+      lines.push('      </failure>')
+    }
+    lines.push('    </testcase>')
+  }
+  lines.push('  </testsuite>')
+  lines.push('</testsuites>')
+  return `${lines.join('\n')}\n`
+}
+
+// the first failed trace step as a junit failure. a flow that died before
+// producing steps (parse error, sim never attached) has no failed step, so
+// the caller passes its own fallback text instead of an empty failure.
+export function failureFromTraceSteps(
+  steps: SootSimFlowTraceStep[],
+  fallbackMessage: string,
+): { message: string; body: string } {
+  const failed = steps.find((step) => step.status === 'failure')
+  if (!failed) {
+    return { message: fallbackMessage, body: fallbackMessage }
+  }
+  const error = failed.error || 'flow step failed'
+  const message = error.split('\n')[0] || fallbackMessage
+  const bodyLines = [`step ${failed.stepIndex + 1} (${failed.stepName}): ${error}`]
+  if (failed.screenshotPath) {
+    bodyLines.push(`screenshot: ${failed.screenshotPath}`)
+  }
+  return { message, body: bodyLines.join('\n') }
+}
+
+export interface FlowCommandsEntry {
+  sequenceNumber: number
+  command: string
+  status: SootSimFlowTraceStep['status']
+  durationMs: number
+  error?: string
+  artifacts: string[]
+}
+
+export function buildFlowCommandsJson(steps: SootSimFlowTraceStep[]): string {
+  const entries: FlowCommandsEntry[] = steps.map((step) => ({
+    sequenceNumber: step.stepIndex + 1,
+    command: step.targetLabel ? `${step.stepName} ${step.targetLabel}` : step.stepName,
+    status: step.status,
+    durationMs: step.durationMs,
+    ...(step.error ? { error: step.error } : {}),
+    artifacts: step.screenshotPath ? [step.screenshotPath] : [],
+  }))
+  return `${JSON.stringify(entries, null, 2)}\n`
+}
+
+export interface SessionLogFlow {
+  file: string
+  passed: boolean
+  durationMs: number
+  steps: SootSimFlowTraceStep[]
+}
+
+function formatLogDuration(ms: number): string {
+  return `${(Math.max(0, ms) / 1000).toFixed(1)}s`
+}
+
+function formatLogStep(step: SootSimFlowTraceStep): string {
+  const label = step.targetLabel ? `${step.stepName} ${step.targetLabel}` : step.stepName
+  const base = `  ${step.stepIndex + 1}. ${label} - ${step.status} (${formatLogDuration(step.durationMs)})`
+  if (step.status === 'failure' && step.error) {
+    return `${base}: ${step.error.split('\n')[0]}`
+  }
+  return base
+}
+
+// one flow's section, shared by the session log and the per-flow logs file
+// so the two never disagree about what a flow did.
+export function buildFlowLogLines(flow: SessionLogFlow): string[] {
+  const lines = [
+    `# flow: ${flow.file} - ${flow.passed ? 'pass' : 'FAIL'} (${formatLogDuration(flow.durationMs)}, ${flow.steps.length} steps)`,
+  ]
+  for (const step of flow.steps) {
+    lines.push(formatLogStep(step))
+  }
+  return lines
+}
+
+export function buildSessionLog(input: {
+  startedAtIso: string
+  root: string
+  device: string
+  flows: SessionLogFlow[]
+}): string {
+  const passed = input.flows.filter((flow) => flow.passed).length
+  const lines = [
+    '# rnx maestro session log',
+    `# started: ${input.startedAtIso}`,
+    `# root: ${input.root}`,
+    `# device: ${input.device}`,
+    `# result: ${passed}/${input.flows.length} passed`,
+  ]
+  for (const flow of input.flows) {
+    lines.push('#')
+    lines.push(...buildFlowLogLines(flow))
+  }
+  return `${lines.join('\n')}\n`
+}

package/cli/main.ts

@@ -254,7 +254,7 @@ const commandArgsWithSim = globalSimTarget
 
 // apply device/theme/home-screen to settings store if provided
 if (device || theme || homeScreen) {
-  const { settingsStore } = await import('sootsim-engine/settings/store')
+  const { settingsStore } = await import('peach-engine/settings/store')
   const overrides: Record<string, any> = {}
   if (device) overrides.deviceModel = device
   if (theme) overrides.colorScheme = theme