peachsim 0.1.570 → 0.1.571

package/README.md

@@ -33,7 +33,7 @@ What this workspace gives you:
 - `rnxsim/jump-to-source-babel` — an optional Babel plugin that annotates JSX
   with source locations so inspect mode can open the selected element in your
   editor
-- `rnxsim/detox` — a drop-in Detox driver + jest preset
+- `peachsim/detox` — a drop-in Detox driver + jest preset
 - `rnxsim/sdk` — the inspect/interact verbs as a programmatic API
 - `rnxsim/bridge-contract-input` — parsers turning untrusted JSON into
   bridge-contract arguments
@@ -445,7 +445,7 @@ no code changes — just add one line to your jest config:
 
 ```js
 // jest config
-{ preset: 'rnxsim/detox' }
+{ preset: 'peachsim/detox' }
 ```
 
 Or use the CLI directly:

package/cli/bridge-flow-runner.ts

@@ -1163,7 +1163,9 @@ export class SootSimBridgeFlowRunner {
 
   async assertVisible(target: string | { id?: string; text?: string }) {
     const opts = typeof target === 'string' ? { text: target } : target
-    for (let attempt = 0; attempt < 15; attempt++) {
+    // maestro auto-retries assertions for up to 7 seconds before failing; a
+    // shorter window fails flows real maestro passes.
+    for (let attempt = 0; attempt < 35; attempt++) {
       if (await this.isElementVisible(opts)) {
         return
       }
@@ -1184,13 +1186,19 @@ export class SootSimBridgeFlowRunner {
 
   async assertNotVisible(target: string | { id?: string; text?: string }) {
     const opts = typeof target === 'string' ? { text: target } : target
-    if (await this.isElementVisible(opts)) {
-      const found = await this.findElement(opts)
-      const where = found
-        ? ` at (${Math.round(found.absolutePosition.x)},${Math.round(found.absolutePosition.y)})`
-        : ''
-      throw new Error(`assertNotVisible: ${JSON.stringify(opts)} IS visible${where}`)
+    // like assertVisible, maestro waits up to 7 seconds for the element to
+    // disappear rather than failing on the first visible sample.
+    for (let attempt = 0; attempt < 35; attempt++) {
+      if (!(await this.isElementVisible(opts))) {
+        return
+      }
+      await sleep(200)
     }
+    const found = await this.findElement(opts)
+    const where = found
+      ? ` at (${Math.round(found.absolutePosition.x)},${Math.round(found.absolutePosition.y)})`
+      : ''
+    throw new Error(`assertNotVisible: ${JSON.stringify(opts)} IS visible${where}`)
   }
 
   // visibility is the engine's call, not a layout-bounds guess. the old test

package/cli/cloud-dispatch.ts

@@ -29,6 +29,7 @@ const CLOUD_TARGET_COMMANDS = new Set([
   'shell',
   'state',
   'storage',
+  'test',
   'timeline',
   'wait',
   'what-happened',

package/cli/cloud-test-result-files.ts

@@ -0,0 +1,97 @@
+// shared cloud-test result-file contract between the test interpreters and
+// the hosted recorder.
+//
+// each maestro flow writes its recording + registration ids where the
+// recorder collects them. single-flow jobs write only the bare
+// preview-result.json / test-result.json; a multi-flow run additionally
+// writes one numbered pair per flow so no flow's ids overwrite another's.
+// the bare file stays the last flow's, so older readers keep working.
+// every flow writes its files unconditionally: a failed upload or
+// registration leaves null ids, never a missing entry, so the collector
+// always sees one entry per flow in run order.
+
+import { readdirSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+export interface CloudTestFlowResult {
+  flow: string | null
+  previewId: string | null
+  previewUrl: string | null
+  runId: string | null
+}
+
+// every file one flow's ids land in: the bare file always (last flow wins,
+// as before), plus the flow's own numbered file on multi-flow runs.
+export function cloudTestResultFileNames(
+  kind: 'preview' | 'test',
+  flowIndex: number,
+  flowCount: number,
+): string[] {
+  const base = kind === 'preview' ? 'preview-result' : 'test-result'
+  if (flowCount < 2) return [`${base}.json`]
+  return [`${base}.json`, `${base}-${flowIndex + 1}.json`]
+}
+
+function readResultJson(workDir: string, name: string): Record<string, unknown> | null {
+  try {
+    const parsed: unknown = JSON.parse(readFileSync(join(workDir, name), 'utf8'))
+    return parsed && typeof parsed === 'object'
+      ? (parsed as Record<string, unknown>)
+      : null
+  } catch {
+    return null
+  }
+}
+
+function stringField(obj: Record<string, unknown> | null, name: string): string | null {
+  const value = obj?.[name]
+  return typeof value === 'string' ? value : null
+}
+
+function previewIdFrom(preview: Record<string, unknown> | null): string | null {
+  return (
+    stringField(preview, 'previewId') ??
+    stringField(preview, 'previewUrl')?.match(/\/preview\/([a-z0-9_-]+)/i)?.[1] ??
+    null
+  )
+}
+
+// every flow's ids in run order: the numbered files when the runner wrote
+// them, else the single bare pair. missing or unparseable files read as
+// null ids, never throw. discovery unions both sides: an upload failure
+// leaves no preview file and a registration failure leaves no test file,
+// and either way the flow keeps its entry with null ids instead of
+// disappearing and letting a later flow pose as the last.
+export function collectCloudTestFlowResults(
+  workDir: string,
+  cloudOrigin: string,
+): CloudTestFlowResult[] {
+  const one = (previewName: string, testName: string): CloudTestFlowResult => {
+    const preview = readResultJson(workDir, previewName)
+    const test = readResultJson(workDir, testName)
+    const previewId = previewIdFrom(preview)
+    return {
+      flow: stringField(preview, 'flow') ?? stringField(test, 'flow'),
+      previewId,
+      previewUrl:
+        stringField(preview, 'previewUrl') ??
+        (previewId ? `${cloudOrigin.replace(/\/$/, '')}/preview/${previewId}` : null),
+      runId: stringField(test, 'runId'),
+    }
+  }
+  let numbered: number[] = []
+  try {
+    const indices = new Set<number>()
+    for (const name of readdirSync(workDir)) {
+      const match = name.match(/^(?:preview|test)-result-(\d+)\.json$/)
+      if (match) indices.add(Number(match[1]))
+    }
+    numbered = [...indices].sort((a, b) => a - b)
+  } catch {
+    numbered = []
+  }
+  if (numbered.length > 0) {
+    return numbered.map((n) => one(`preview-result-${n}.json`, `test-result-${n}.json`))
+  }
+  return [one('preview-result.json', 'test-result.json')]
+}

package/cli/commands/maestro.ts

@@ -10,6 +10,7 @@ import * as fs from 'fs'
 import * as path from 'path'
 import yaml from 'yaml'
 import { resolveCliAuth } from '../auth'
+import { cloudTestResultFileNames } from '../cloud-test-result-files'
 import { parseFlowFile, type FlowFrontmatter } from '../flow-file'
 import {
   buildFlowCommandsJson,
@@ -65,13 +66,22 @@ options:
   --config <path>        read the workspace config (flows/tags) from this file
                          instead of <dir>/config.yaml
   --format junit         write a junit xml report (default ./report.xml)
+                         JUNIT, NOOP also accepted (case-insensitive)
   --output <file>        junit report path (needs --format junit)
   --test-output-dir <dir>
                          per-flow screenshots, commands.json, and logs/maestro.log
                          (config key testOutputDir:; CLI wins over config)
   --debug-output <dir>   write a session maestro.log there
+  --flatten-debug-output accepted; rnx output is already flat
+  --test-suite-name <n>  junit testsuite name (default "Test Suite")
   --platform ios         accepted; any other platform is refused (rnx is iOS-only)
+                         (-p stays the rnx bridge-port short)
   --no-ansi              accepted; rnx output is already plain text
+  --udid <id>            warned; rnx manages its own sim (pin one with --sim)
+  -s, --shards <n>       warned; rnx runs the full selection on one sim
+  --shard-all, --shard-split <spec>
+                         warned; rnx runs the full selection on one sim
+  -c                     warned; --continuous runs once under rnx
   --device <model>       override the flow frontmatter device for this run
   --new                  force a fresh browser window for this run
   --headed               force a fresh, VISIBLE window (implies --new,
@@ -162,11 +172,13 @@ function looksLikeFlag(s: string): boolean {
 // extract --env KEY=VALUE pairs from argv and apply to process.env for the
 // duration of the run. returns argv with the consumed flags removed so the
 // rest can be forwarded to runFlowPlayback verbatim.
-function applyEnvFlags(args: string[]): string[] {
+export function applyEnvFlags(args: string[]): string[] {
   const out: string[] = []
   for (let i = 0; i < args.length; i++) {
-    if (args[i] === '--env' || args[i] === '-e') {
-      const kv = args[i + 1]
+    const arg = args[i] as string
+    const inline = arg.startsWith('--env=') ? arg.slice('--env='.length) : null
+    if (arg === '--env' || arg === '-e' || inline !== null) {
+      const kv = inline ?? args[i + 1]
       if (!kv || !kv.includes('=')) {
         throw new Error(`--env expects KEY=VALUE (got ${JSON.stringify(kv ?? '')})`)
       }
@@ -174,10 +186,10 @@ function applyEnvFlags(args: string[]): string[] {
       const key = kv.slice(0, eq)
       const value = kv.slice(eq + 1)
       process.env[key] = value
-      i += 1
+      if (inline === null) i += 1
       continue
     }
-    out.push(args[i])
+    out.push(arg)
   }
   return out
 }
@@ -204,6 +216,7 @@ export interface MaestroCompatOptions {
   testOutputDir: string | null
   debugOutput: string | null
   platform: string | null
+  testSuiteName: string | null
 }
 
 const MAESTRO_COMPAT_VALUE_FLAGS = new Set([
@@ -215,6 +228,14 @@ const MAESTRO_COMPAT_VALUE_FLAGS = new Set([
   '--test-output-dir',
   '--debug-output',
   '--platform',
+  '--udid',
+  '--test-suite-name',
+  '--shards',
+  '--shard-all',
+  '--shard-split',
+  '--api-key',
+  '--api-url',
+  '--screen-size',
 ])
 
 function splitTagList(value: string): string[] {
@@ -237,6 +258,7 @@ export function extractMaestroCompatFlags(args: string[]): {
     testOutputDir: null,
     debugOutput: null,
     platform: null,
+    testSuiteName: null,
   }
   const rest: string[] = []
   for (let i = 0; i < args.length; i++) {
@@ -267,7 +289,8 @@ export function extractMaestroCompatFlags(args: string[]): {
           compat.configPath = value
           break
         case '--format':
-          compat.format = value
+          // maestro spells it JUNIT; normalize so either case works.
+          compat.format = value.toLowerCase()
           break
         case '--output':
           compat.output = value
@@ -284,6 +307,28 @@ export function extractMaestroCompatFlags(args: string[]): {
           }
           compat.platform = value
           break
+        case '--udid':
+          console.warn(
+            '  warn: --udid selects a Maestro simulator; rnx manages its own sim — pin one with --sim instead',
+          )
+          break
+        case '--test-suite-name':
+          compat.testSuiteName = value
+          break
+        case '--shards':
+        case '--shard-all':
+        case '--shard-split':
+          console.warn(
+            `  warn: ${head} shards across Maestro devices; rnx runs the full selection on one sim`,
+          )
+          break
+        case '--api-key':
+        case '--api-url':
+          console.warn(`  warn: ${head} is Maestro beta AI analysis; rnx ignores it`)
+          break
+        case '--screen-size':
+          console.warn('  warn: --screen-size is web-only; rnx ignores it')
+          break
       }
       continue
     }
@@ -299,22 +344,62 @@ export function extractMaestroCompatFlags(args: string[]): {
       rest.push('--device')
       continue
     }
-    if (a === '--no-ansi') {
+    if (a === '--no-ansi' || a === '--no-color') {
       // trivially satisfied: rnx prints no ANSI escapes anywhere on this path.
       continue
     }
-    if (a === '--continuous') {
+    if (a === '--ansi' || a === '--color') {
+      console.warn('  warn: rnx prints no ANSI escapes; colored output is unavailable')
+      continue
+    }
+    if (a === '--continuous' || a === '-c') {
       console.warn('  warn: --continuous is not implemented in rnx — running once')
       continue
     }
+    if (a === '--flatten-debug-output') {
+      // rnx writes one <dir>/maestro.log with no per-run subfolders or
+      // timestamps, so the maestro layout flag is already satisfied.
+      continue
+    }
+    if (a === '--analyze') {
+      console.warn('  warn: --analyze is Maestro beta AI analysis; rnx ignores it')
+      continue
+    }
+    if (a === '-s') {
+      const count = args[i + 1]
+      if (!count || count.startsWith('-')) throw new Error('-s expects a value')
+      i += 1
+      console.warn(
+        '  warn: -s shards across Maestro devices; rnx runs the full selection on one sim',
+      )
+      continue
+    }
+    if (head === '-p') {
+      // -p is the rnx bridge-port short, not maestro's --platform short. a
+      // non-numeric value is a pasted maestro command line; fail loud with
+      // the mapping instead of pinning the bridge to a NaN port.
+      const value = eq > 0 ? a.slice(eq + 1) : args[i + 1]
+      if (value !== undefined && !value.startsWith('-') && !/^\d+$/.test(value)) {
+        throw new Error(
+          `-p is the rnx bridge-port short; use --platform for the Maestro platform (got ${JSON.stringify(value)})`,
+        )
+      }
+      rest.push(a)
+      continue
+    }
     rest.push(a)
   }
   if (
     compat.format !== null &&
-    !['junit', 'html', 'html-detailed'].includes(compat.format)
+    !['junit', 'html', 'html-detailed', 'noop'].includes(compat.format)
   ) {
     throw new Error(`unsupported --format: ${compat.format} (rnx writes junit reports)`)
   }
+  if (compat.format === 'html' || compat.format === 'html-detailed') {
+    console.warn(
+      '  warn: --format html is not implemented in rnx — running without a report',
+    )
+  }
   return { rest, compat }
 }
 
@@ -705,7 +790,7 @@ export async function runMaestro(
     steps: ReturnType<typeof getLastFlowTraceSteps>
     frontmatter: FlowFrontmatter
   }> = []
-  for (const file of files) {
+  for (const [flowIndex, file] of files.entries()) {
     console.log(`\n  ▶ ${path.relative(cwd, file)}`)
     const playbackArgs = [file, ...forwardArgs]
     let flowTestDir: string | null = null
@@ -789,17 +874,20 @@ export async function runMaestro(
     }
 
     const upload = getLastFlowPreviewUploadResult()
-    if (upload?.shareId || upload?.previewUrl) {
-      try {
-        fs.writeFileSync(
-          path.join(cwd, 'preview-result.json'),
-          JSON.stringify({
-            previewId: upload.shareId,
-            previewUrl: upload.previewUrl,
-          }),
-        )
-      } catch {}
-    } else if (args.includes('--preview')) {
+    // the receipt files are the per-flow manifest: always written, with
+    // null ids when the upload failed, so the flow never disappears from
+    // the collected entries.
+    const previewPayload = {
+      flow: path.relative(cwd, file) || file,
+      previewId: upload?.shareId ?? null,
+      previewUrl: upload?.previewUrl ?? null,
+    }
+    try {
+      for (const name of cloudTestResultFileNames('preview', flowIndex, files.length)) {
+        fs.writeFileSync(path.join(cwd, name), JSON.stringify(previewPayload))
+      }
+    } catch {}
+    if (!upload?.shareId && !upload?.previewUrl && args.includes('--preview')) {
       console.error('  error: required hosted recording upload failed')
       if (exit === 0) exit = 1
       if (worstExit === 0) worstExit = 1
@@ -822,21 +910,24 @@ export async function runMaestro(
       })
       if (run) {
         console.log(`  run: ${run.id}${run.traceUrl ? ` · replay: ${run.traceUrl}` : ''}`)
-        try {
-          fs.writeFileSync(
-            path.join(cwd, 'test-result.json'),
-            JSON.stringify({
-              runId: run.id,
-              previewUrl: run.previewUrl,
-              traceUrl: run.traceUrl,
-            }),
-          )
-        } catch {}
       } else if (process.env.RNX_REQUIRE_REGISTRATION === 'true') {
         console.error('  error: required hosted run registration failed')
         if (exit === 0) exit = 1
         if (worstExit === 0) worstExit = 1
       }
+      // like the preview receipt above: always written, null ids when the
+      // registration failed, so the flow keeps its collected entry.
+      const testPayload = {
+        flow: path.relative(cwd, file) || file,
+        runId: run?.id ?? null,
+        previewUrl: run?.previewUrl ?? null,
+        traceUrl: run?.traceUrl ?? null,
+      }
+      try {
+        for (const name of cloudTestResultFileNames('test', flowIndex, files.length)) {
+          fs.writeFileSync(path.join(cwd, name), JSON.stringify(testPayload))
+        }
+      } catch {}
     }
     // artifact, upload, and registration failures above flip the local exit
     // after the result was pushed; the report below must see the final one.
@@ -865,6 +956,7 @@ export async function runMaestro(
         buildJUnitXml({
           device: deviceLabel,
           cases: results.map((r) => junitCaseForResult(cwd, r)),
+          ...(compat.testSuiteName ? { name: compat.testSuiteName } : {}),
         }),
       )
       console.log(`  junit: ${path.relative(cwd, junitPath) || junitPath}`)

package/cli/commands/test.ts

@@ -7,6 +7,7 @@ import {
   RNX_CLOUD_TEST_FILES_MAX_BYTES,
   RNX_CLOUD_TEST_FILES_MAX_COUNT,
 } from '../../src/cloud-contract'
+import { isCloudTestValueFlag, parseCloudTestArgs } from '../../src/cloud-test-args'
 import { authHeaderValue, resolveCliAuth } from '../auth'
 import {
   parseCloudTestSidecarPorts,
@@ -58,8 +59,18 @@ const VALUE_FLAGS = new Set([
   '--test-output-dir',
   '--debug-output',
   '--platform',
+  '--udid',
+  '--test-suite-name',
+  '--shards',
+  '-s',
+  '--shard-all',
+  '--shard-split',
+  '--api-key',
+  '--api-url',
+  '--screen-size',
   '-t',
   '--testNamePattern',
+  '--testPathPattern',
   '--testTimeout',
   '--grep',
   '--maxWorkers',
@@ -88,7 +99,10 @@ function targetIndexFromArgs(args: string[]): number {
   for (let index = 0; index < args.length; index++) {
     const arg = args[index]
     if (VALUE_FLAGS.has(arg)) {
-      index += 1
+      // a missing value must not swallow the next flag: only skip a
+      // present, non-flag-shaped token, like valueAfter.
+      const next = args[index + 1]
+      if (next !== undefined && !next.startsWith('-')) index += 1
       continue
     }
     if (arg.startsWith('--') && arg.includes('=')) {
@@ -104,6 +118,122 @@ function targetFromArgs(args: string[]): string | null {
   return index >= 0 ? args[index] : null
 }
 
+// flags the cloud submitter consumes into the submission itself (app,
+// origin, tunnel, polling): skipped silently by the testArgs walk, with
+// their values. contract: harden owns the list's server half.
+const CLOUD_CONSUMED_FLAGS = new Set([
+  '--app',
+  '--bundle',
+  '--bundle-url',
+  '--url',
+  '--origin',
+  '--owner',
+  '--repo',
+  '--config',
+  '--cancel',
+  '--poll-interval',
+  '--timeout',
+  '--sidecar-ports',
+  '--hosted',
+  '--cloud',
+])
+
+// execution-environment flags the hosted recorder owns: warned on every
+// cloud submit, never forwarded.
+const RECORDER_OWNED_FLAGS = new Set([
+  '--maxWorkers',
+  '--testTimeout',
+  '--shard',
+  '--device',
+  '--sim',
+  '--headless',
+  '--preview',
+])
+
+// report/output flags the local-only block already warned about: skipped
+// silently here so one flag never warns twice.
+const CLOUD_ALREADY_WARNED_FLAGS = new Set([
+  '--format',
+  '--output',
+  '--test-output-dir',
+  '--debug-output',
+])
+
+export interface CloudTestArgsWalk {
+  testArgs: string[]
+  warnings: string[]
+}
+
+// split the cloud argv into the testArgs slice the recorder appends
+// verbatim plus one warning per dropped arg. pure: the caller prints
+// the warnings and validates through parseCloudTestArgs, so a filter is
+// never silently dropped and malformed selection fails pre-submit with
+// the server's own message.
+export function collectCloudTestArgs(forwarded: string[]): CloudTestArgsWalk {
+  const testArgs: string[] = []
+  const warnings: string[] = []
+  const targetIndex = targetIndexFromArgs(forwarded)
+  const takesValue = (name: string): boolean =>
+    isCloudTestValueFlag(name) || VALUE_FLAGS.has(name)
+  let i = 0
+  while (i < forwarded.length) {
+    const arg = forwarded[i]
+    if (i === targetIndex) {
+      i += 1
+      continue
+    }
+    if (!arg.startsWith('-') || arg === '-') {
+      warnings.push(
+        `cloud ignores ${arg}: unexpected positional argument (one test target only)`,
+      )
+      i += 1
+      continue
+    }
+    const eq = arg.indexOf('=')
+    const head = eq > 0 ? arg.slice(0, eq) : arg
+    const inline = eq > 0
+    // a missing value must not swallow the next flag: only a present,
+    // non-flag-shaped token is consumed as a value.
+    const nextIsValue =
+      !inline &&
+      takesValue(head) &&
+      i + 1 < forwarded.length &&
+      !forwarded[i + 1].startsWith('-')
+    if (CLOUD_CONSUMED_FLAGS.has(head) || CLOUD_ALREADY_WARNED_FLAGS.has(head)) {
+      i += nextIsValue ? 2 : 1
+      continue
+    }
+    if (isCloudTestValueFlag(head)) {
+      if (inline) {
+        testArgs.push(arg)
+        i += 1
+        continue
+      }
+      const value = forwarded[i + 1]
+      if (value !== undefined && !value.startsWith('-')) {
+        testArgs.push(arg, value)
+        i += 2
+        continue
+      }
+      // a lone selection flag: emit it so the pre-submit parse names it
+      // (`<flag> expects a value`) instead of running unfiltered.
+      testArgs.push(arg)
+      i += 1
+      continue
+    }
+    if (RECORDER_OWNED_FLAGS.has(head)) {
+      warnings.push(
+        `cloud ignores ${head}: the hosted recorder owns the execution environment`,
+      )
+      i += nextIsValue ? 2 : 1
+      continue
+    }
+    warnings.push(`cloud ignores ${arg}: applies to local runs only`)
+    i += nextIsValue ? 2 : 1
+  }
+  return { testArgs, warnings }
+}
+
 const APP_FLAGS = ['--app', '--bundle', '--bundle-url']
 
 function isAppFlag(arg: string): boolean {
@@ -564,8 +694,6 @@ export async function runCloudTest(
   }
 
   const localOnly = [
-    '--include-tags',
-    '--exclude-tags',
     '--format',
     '--output',
     '--test-output-dir',
@@ -577,6 +705,22 @@ export async function runCloudTest(
     )
   }
 
+  // selection flags ride testArgs to the recorder; everything else the
+  // walk drops gets one warning, never silence. validated pre-submit so
+  // malformed selection fails here with the server's own message,
+  // before any tunnel or upload side effect.
+  const walk = collectCloudTestArgs(forwarded)
+  for (const warning of walk.warnings) console.warn(`  warn: ${warning}`)
+  let cloudTestArgs: string[] | null = null
+  if (walk.testArgs.length > 0) {
+    const parsed = parseCloudTestArgs(walk.testArgs)
+    if (!parsed.ok) {
+      console.error(`  error: ${parsed.message}`)
+      return 1
+    }
+    cloudTestArgs = parsed.args
+  }
+
   const auth = resolveCliAuth()
   if (!auth) {
     console.error('  error: rnx test --cloud requires `rnx login` or RNX_API_KEY')
@@ -691,6 +835,7 @@ export async function runCloudTest(
   if (tunnelSidecarPorts) submitPayload.sidecarPorts = tunnelSidecarPorts
   if (owner) submitPayload.owner = owner
   if (repo) submitPayload.repo = repo
+  if (cloudTestArgs) submitPayload.testArgs = cloudTestArgs
 
   try {
     const endpoint = `${origin.replace(/\/$/, '')}/api/sootsim/runner/jobs`
@@ -754,6 +899,12 @@ export async function runCloudTest(
           previewId?: string | null
           previewUrl?: string | null
           runId?: string | null
+          flows?: Array<{
+            flow?: string | null
+            previewId?: string | null
+            previewUrl?: string | null
+            runId?: string | null
+          }> | null
           exitCode?: number | null
           failureReason?: string | null
         } | null
@@ -782,6 +933,13 @@ export async function runCloudTest(
         if (result?.runId) {
           console.log(`  run:       ${result.runId}`)
         }
+        if (result?.flows && result.flows.length > 1) {
+          result.flows.forEach((flow, index) => {
+            console.log(
+              `  flow ${index + 1}:    ${flow.flow ?? '(unknown flow)'} preview=${flow.previewUrl ?? flow.previewId ?? 'none'} run=${flow.runId ?? 'none'}`,
+            )
+          })
+        }
         if (result?.failureReason) {
           console.error(`  failure:   ${result.failureReason}`)
         }

package/cli/maestro-report.ts

@@ -34,6 +34,8 @@ export interface JUnitCaseInput {
 export interface JUnitSuiteInput {
   device: string
   cases: JUnitCaseInput[]
+  // --test-suite-name; absent keeps the existing "Test Suite" name.
+  name?: string
 }
 
 function formatJUnitTime(seconds: number): string {
@@ -49,7 +51,7 @@ export function buildJUnitXml(suite: JUnitSuiteInput): string {
   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)}">`,
+    `  <testsuite name="${escapeXml(suite.name ?? 'Test Suite')}" device="${escapeXml(suite.device)}" tests="${suite.cases.length}" failures="${failures}" time="${formatJUnitTime(totalTime)}">`,
   ]
   for (const c of suite.cases) {
     lines.push(