peachsim 0.1.939 → 0.1.1399

package/cli/commands/maestro-compare.ts

@@ -0,0 +1,554 @@
+// peach maestro compare <flow-or-dir>: run a partner's existing maestro flows
+// on their own iOS simulator under real maestro, then on peach, and write one
+// html report pairing every screen (iOS, peach, pixel diff), both sides'
+// errors and per-step timing. maestro-compare.ts holds the report pieces.
+
+import { spawn, spawnSync } from 'child_process'
+import * as fs from 'fs'
+import * as os from 'os'
+import * as path from 'path'
+import { devices } from 'peach-engine/settings/devices'
+import { rnxHomeDir } from '../../src/home-paths'
+import { parseFlowFile } from '../flow-file'
+import {
+  buildCompareHtml,
+  compareScreens,
+  comparePassed,
+  instrumentFlowSource,
+  nativeStepsFromCommandsJson,
+  peachStepsFromCommandsJson,
+  screensOverThreshold,
+  type CompareCapture,
+  type CompareFlow,
+  type CompareReport,
+  type CompareSide,
+} from '../maestro-compare'
+import { collectFlowFiles, loadMaestroWorkspaceConfig } from '../maestro-workspace'
+import { FLOW_ARG_VALUE_FLAGS } from './flow'
+import { applyEnvFlags, runMaestro, type RunMaestroOptions } from './maestro'
+
+function printHelp() {
+  console.log(`
+peach maestro compare — run your maestro flows on your iOS simulator and on
+peach, then write an html report: every screen side by side with a pixel
+diff, both sides' errors, and per-step timing.
+
+usage:
+  peach maestro compare <flow-or-dir> [options]
+
+needs real maestro (https://maestro.dev) and a booted iOS simulator with your
+app installed. peach runs the same flows against the app it has open.
+
+options:
+  --udid <id>            iOS simulator to run maestro on (default: the one booted)
+  --out <dir>            report directory (default ~/.peach/compare/<time>)
+  --threshold <percent>  flag screens differing by more than this (default 0.5)
+  --maestro <path>       maestro binary (default: maestro on PATH, then ~/.maestro/bin)
+  --env KEY=VALUE        passed to both runs (repeatable)
+  --include-tags, --exclude-tags, --config
+                         flow selection, passed to both runs
+  other flags (--sim, --device, --headless, ...) go to the peach run
+
+exits 0 when both sides pass every flow and no screen is over the threshold.
+`)
+}
+
+function takeFlag(args: string[], name: string): string | undefined {
+  const i = args.indexOf(name)
+  if (i < 0) return undefined
+  const value = args[i + 1]
+  if (!value || value.startsWith('-')) throw new Error(`${name} expects a value`)
+  args.splice(i, 2)
+  return value
+}
+
+function findMaestro(explicit: string | undefined): string | null {
+  if (explicit) return fs.existsSync(explicit) ? explicit : null
+  const which = spawnSync('which', ['maestro'], { encoding: 'utf8' })
+  if (which.status === 0 && which.stdout.trim()) return which.stdout.trim()
+  const home = path.join(os.homedir(), '.maestro', 'bin', 'maestro')
+  return fs.existsSync(home) ? home : null
+}
+
+function bootedSimulators(): Array<{ udid: string; name: string }> {
+  const out = spawnSync('xcrun', ['simctl', 'list', 'devices', 'booted', '-j'], {
+    encoding: 'utf8',
+  })
+  if (out.status !== 0) return []
+  const devices = JSON.parse(out.stdout).devices as Record<
+    string,
+    Array<{ udid: string; name: string; state: string }>
+  >
+  return Object.values(devices)
+    .flat()
+    .filter((d) => d.state === 'Booted')
+    .map(({ udid, name }) => ({ udid, name }))
+}
+
+function simulatorName(udid: string): string {
+  return bootedSimulators().find((d) => d.udid === udid)?.name ?? udid
+}
+
+function appInstalled(udid: string, appId: string): boolean {
+  return (
+    spawnSync('xcrun', ['simctl', 'get_app_container', udid, appId], { stdio: 'ignore' })
+      .status === 0
+  )
+}
+
+// peach draws the iOS marketing status bar (9:41, full signal and battery);
+// the simulator shows the real clock unless told otherwise.
+function overrideStatusBar(udid: string) {
+  spawnSync(
+    'xcrun',
+    [
+      'simctl',
+      'status_bar',
+      udid,
+      'override',
+      '--time',
+      '9:41',
+      '--dataNetwork',
+      'wifi',
+      '--wifiMode',
+      'active',
+      '--wifiBars',
+      '3',
+      '--cellularMode',
+      'active',
+      '--cellularBars',
+      '4',
+      '--batteryState',
+      'charged',
+      '--batteryLevel',
+      '100',
+    ],
+    { stdio: 'ignore' },
+  )
+}
+
+function runLogged(bin: string, args: string[], logPath: string): Promise<number> {
+  return new Promise((resolve) => {
+    const log = fs.createWriteStream(logPath)
+    const child = spawn(bin, args, { stdio: ['ignore', 'pipe', 'pipe'] })
+    const forward = (chunk: Buffer) => {
+      log.write(chunk)
+      for (const line of chunk.toString().split('\n')) {
+        if (line.trim()) console.log(`  ios │ ${line}`)
+      }
+    }
+    child.stdout.on('data', forward)
+    child.stderr.on('data', forward)
+    child.on('close', (code) => {
+      log.end()
+      resolve(code ?? 1)
+    })
+    child.on('error', (err) => {
+      log.end()
+      console.error(`  error: could not start maestro: ${err.message}`)
+      resolve(1)
+    })
+  })
+}
+
+// the status bar band of the device whose screen matches the iOS capture's
+// pixel size (peach's own device table); 0 for a size no device has.
+function statusBarPx(png: Buffer): number {
+  // png ihdr: width and height are the big-endian words at bytes 16 and 20
+  const width = png.readUInt32BE(16)
+  const height = png.readUInt32BE(20)
+  const spec = Object.values(devices).find(
+    (d) =>
+      Math.round(d.width * d.scale) === width &&
+      Math.round(d.height * d.scale) === height,
+  )
+  return spec ? spec.statusBarHeight * spec.scale : 0
+}
+
+// the flow as its author would name it: relative inside the working
+// directory, home-relative or absolute outside it.
+function displayPath(cwd: string, file: string): string {
+  const rel = path.relative(cwd, file)
+  if (rel && !rel.startsWith('..') && !path.isAbsolute(rel)) return rel
+  const home = os.homedir()
+  return file.startsWith(home + path.sep) ? `~${file.slice(home.length)}` : file
+}
+
+function readJson(file: string): unknown {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+function formatConsoleEntry(entry: unknown): string {
+  if (typeof entry === 'string') return entry
+  if (entry && typeof entry === 'object') {
+    const e = entry as Record<string, unknown>
+    const text = e.message ?? e.text ?? e.args
+    if (typeof text === 'string') return text
+    if (Array.isArray(text)) return text.map(String).join(' ')
+  }
+  return JSON.stringify(entry).slice(0, 2000)
+}
+
+function formatFailedRequest(entry: unknown): string {
+  if (!entry || typeof entry !== 'object') return `request failed: ${String(entry)}`
+  const e = entry as Record<string, unknown>
+  return `request failed: ${e.method ?? 'GET'} ${e.url ?? '?'} ${e.status ?? e.error ?? ''}`.trim()
+}
+
+function sideFromSteps(
+  steps: CompareSide['steps'],
+  ran: boolean,
+  extraErrors: string[],
+): CompareSide {
+  const failed = steps.find((s) => s.status === 'failed')
+  return {
+    status: !ran ? 'not run' : failed ? 'failed' : 'passed',
+    durationMs: steps.reduce((sum, s) => sum + s.durationMs, 0),
+    steps,
+    errors: [
+      ...(failed
+        ? [`step "${failed.label}" failed: ${failed.error ?? 'no message'}`]
+        : []),
+      ...extraErrors,
+    ],
+  }
+}
+
+// peach names each flow's output dir after the file stem, suffixing repeats
+// in run order (commands/maestro.ts uniqueFlowDir).
+function peachFlowDirs(root: string, files: string[]): string[] {
+  const seen = new Map<string, number>()
+  return files.map((file) => {
+    const slug =
+      path
+        .basename(file)
+        .replace(/\.(ya?ml)$/i, '')
+        .replace(/[^A-Za-z0-9._-]+/g, '_') || 'flow'
+    const n = (seen.get(slug) ?? 0) + 1
+    seen.set(slug, n)
+    return path.join(root, n === 1 ? slug : `${slug}-${n}`)
+  })
+}
+
+export async function runMaestroCompare(
+  argv: string[],
+  opts: RunMaestroOptions = {},
+): Promise<number> {
+  if (argv.includes('--help') || argv.includes('-h')) {
+    printHelp()
+    return 0
+  }
+  let args: string[]
+  const envPairs: string[] = []
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === '--env' || argv[i] === '-e') envPairs.push('--env', argv[i + 1] ?? '')
+    else if (argv[i]!.startsWith('--env=')) envPairs.push('--env', argv[i]!.slice(6))
+  }
+  try {
+    // sets process.env for the peach run and drops the flags from its argv
+    args = applyEnvFlags(argv)
+  } catch (err) {
+    console.error(`  error: ${(err as Error).message}`)
+    return 1
+  }
+  let udid: string | undefined
+  let outFlag: string | undefined
+  let thresholdFlag: string | undefined
+  let maestroFlag: string | undefined
+  const shared: string[] = []
+  try {
+    udid = takeFlag(args, '--udid')
+    outFlag = takeFlag(args, '--out')
+    thresholdFlag = takeFlag(args, '--threshold')
+    maestroFlag = takeFlag(args, '--maestro')
+    for (const name of ['--include-tags', '--exclude-tags', '--config']) {
+      const value = takeFlag(args, name)
+      if (value) shared.push(name, value)
+    }
+  } catch (err) {
+    console.error(`  error: ${(err as Error).message}`)
+    return 1
+  }
+  const threshold = thresholdFlag === undefined ? 0.5 : Number(thresholdFlag)
+  if (!Number.isFinite(threshold) || threshold < 0) {
+    console.error('  error: --threshold expects a percentage, for example 0.5')
+    return 1
+  }
+  const positional = args.findIndex(
+    (a, i) =>
+      !a.startsWith('-') && !(i > 0 && FLOW_ARG_VALUE_FLAGS.includes(args[i - 1]!)),
+  )
+  if (positional < 0) {
+    console.error('  error: pass the flow file or directory to compare')
+    printHelp()
+    return 1
+  }
+  const cwd = process.cwd()
+  const target = path.resolve(cwd, args[positional]!)
+  const peachArgs = args.filter((_, i) => i !== positional)
+  if (!fs.existsSync(target)) {
+    console.error(`  error: ${target} not found`)
+    return 1
+  }
+
+  const maestro = findMaestro(maestroFlag)
+  if (!maestro) {
+    console.error(`  error: maestro not found. install it with:
+    curl -fsSL "https://get.maestro.mobile.dev" | bash
+  or pass --maestro <path>`)
+    return 1
+  }
+  if (!udid) {
+    const booted = bootedSimulators()
+    if (booted.length !== 1) {
+      console.error(
+        booted.length === 0
+          ? '  error: no iOS simulator is booted. boot the one with your app installed, or pass --udid'
+          : `  error: ${booted.length} simulators are booted; pass --udid with one of:\n${booted.map((d) => `    ${d.udid}  ${d.name}`).join('\n')}`,
+      )
+      return 1
+    }
+    udid = booted[0]!.udid
+  }
+
+  // the same selection maestro's planner makes, then an instrumented copy of
+  // each selected flow at the same relative path.
+  const targetIsDir = fs.statSync(target).isDirectory()
+  const root = targetIsDir ? target : path.dirname(target)
+  let files: string[]
+  try {
+    const sharedValue = (name: string) => {
+      const i = shared.indexOf(name)
+      return i >= 0 ? shared[i + 1] : undefined
+    }
+    const tags = (name: string) =>
+      sharedValue(name)
+        ?.split(',')
+        .map((t) => t.trim())
+        .filter(Boolean) ?? null
+    files = targetIsDir
+      ? collectFlowFiles(target, {
+          configPath: sharedValue('--config'),
+          includeTags: tags('--include-tags'),
+          excludeTags: tags('--exclude-tags'),
+        })
+      : [target]
+  } catch (err) {
+    console.error(`  error: ${(err as Error).message}`)
+    return 1
+  }
+  if (files.length === 0) {
+    console.error(`  error: no flows selected in ${target}`)
+    return 1
+  }
+
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-')
+  const out = path.resolve(cwd, outFlag ?? path.join(rnxHomeDir(), 'compare', stamp))
+  const flowsDir = path.join(out, 'flows')
+  fs.mkdirSync(flowsDir, { recursive: true })
+  const instrumented: Array<{
+    file: string
+    copy: string
+    name: string
+    appId?: string
+    captures: CompareCapture[]
+  }> = []
+  for (const file of files) {
+    const source = fs.readFileSync(file, 'utf8')
+    let result: ReturnType<typeof instrumentFlowSource>
+    try {
+      result = instrumentFlowSource(source, path.dirname(file))
+    } catch (err) {
+      console.error(`  error: ${path.relative(cwd, file)}: ${(err as Error).message}`)
+      return 1
+    }
+    const copy = path.join(flowsDir, path.relative(root, file))
+    fs.mkdirSync(path.dirname(copy), { recursive: true })
+    fs.writeFileSync(copy, result.source)
+    const frontmatter = parseFlowFile(source).frontmatter as Record<string, unknown>
+    instrumented.push({
+      file,
+      copy,
+      name:
+        typeof frontmatter.name === 'string'
+          ? frontmatter.name
+          : path.basename(file).replace(/\.(ya?ml)$/i, ''),
+      appId: typeof frontmatter.appId === 'string' ? frontmatter.appId : undefined,
+      captures: result.captures,
+    })
+  }
+  if (targetIsDir) {
+    const configAt = shared.indexOf('--config')
+    const explicitConfig = configAt >= 0 ? shared[configAt + 1] : undefined
+    const config = loadMaestroWorkspaceConfig(target, explicitConfig)
+    if (config.path && !explicitConfig) {
+      fs.copyFileSync(config.path, path.join(flowsDir, path.relative(root, config.path)))
+    }
+  }
+  const runTarget = targetIsDir ? flowsDir : instrumented[0]!.copy
+
+  for (const appId of new Set(instrumented.map((f) => f.appId).filter(Boolean))) {
+    if (!appInstalled(udid, appId!)) {
+      console.error(
+        `  error: ${appId} is not installed on simulator ${udid}. build and install your app there first (for example \`npx expo run:ios\`).`,
+      )
+      return 1
+    }
+  }
+
+  const device = simulatorName(udid)
+  console.log(`
+  peach maestro compare — ${files.length} flow${files.length === 1 ? '' : 's'}
+  iOS:    ${device} (${udid})
+  report: ${out}
+`)
+
+  // 1. real maestro on the iOS simulator
+  overrideStatusBar(udid)
+  const nativeOut = path.join(out, 'ios')
+  let nativeExit: number
+  try {
+    nativeExit = await runLogged(
+      maestro,
+      [
+        '--udid',
+        udid,
+        'test',
+        runTarget,
+        '--test-output-dir',
+        nativeOut,
+        '--no-ansi',
+        ...shared,
+        ...envPairs,
+      ],
+      path.join(out, 'ios.log'),
+    )
+  } finally {
+    spawnSync('xcrun', ['simctl', 'status_bar', udid, 'clear'], { stdio: 'ignore' })
+  }
+  console.log(`\n  ios │ maestro exited ${nativeExit}\n`)
+
+  // 2. peach, same instrumented flows (its --env already applied above)
+  const peachOut = path.join(out, 'peach')
+  await runMaestro(
+    ['test', runTarget, '--test-output-dir', peachOut, ...shared, ...peachArgs],
+    {
+      ...opts,
+      captureConsole: true,
+    },
+  )
+
+  // 3. pair and diff
+  const nativeRun = fs.existsSync(nativeOut)
+    ? fs
+        .readdirSync(nativeOut)
+        .map((d) => path.join(nativeOut, d))
+        .filter((d) => fs.statSync(d).isDirectory())
+        .sort()
+        .pop()
+    : undefined
+  const peachDirs = peachFlowDirs(
+    peachOut,
+    instrumented.map((f) => f.copy),
+  )
+  const imagesDir = path.join(out, 'images')
+  const flows: CompareFlow[] = []
+  for (const [i, flow] of instrumented.entries()) {
+    const nativeDir = nativeRun ? path.join(nativeRun, flow.name) : null
+    const peachDir = peachDirs[i]!
+    const nativeRan = Boolean(nativeDir && fs.existsSync(nativeDir))
+    const peachRan = fs.existsSync(path.join(peachDir, 'commands.json'))
+    const nativeSteps = nativeRan
+      ? nativeStepsFromCommandsJson(readJson(path.join(nativeDir!, 'commands.json')))
+      : []
+    const peachSteps = peachRan
+      ? peachStepsFromCommandsJson(readJson(path.join(peachDir, 'commands.json')))
+      : []
+    const consoleJson = readJson(path.join(peachDir, 'logs', 'console.json')) as {
+      errors?: unknown[]
+      requests?: unknown[]
+    } | null
+    const peachConsole = [
+      ...[...new Set((consoleJson?.errors ?? []).map(formatConsoleEntry))].map(
+        (e) => `console error: ${e}`,
+      ),
+      ...(consoleJson?.requests ?? []).map(formatFailedRequest),
+    ]
+    const screens = []
+    for (const capture of flow.captures) {
+      const nativePng = nativeDir
+        ? path.join(nativeDir, 'takeScreenshot', `${capture.name}.png`)
+        : ''
+      const peachPng = path.join(peachDir, 'screenshots', `${capture.name}.png`)
+      const hasNative = Boolean(nativePng) && fs.existsSync(nativePng)
+      const hasPeach = fs.existsSync(peachPng)
+      const imageRel = path.join(
+        'images',
+        `${i + 1}-${capture.name.split('/').pop()}.png`,
+      )
+      if (hasNative && hasPeach) {
+        const nativeBytes = fs.readFileSync(nativePng)
+        const { diff, triptych } = compareScreens(
+          nativeBytes,
+          fs.readFileSync(peachPng),
+          {
+            maskTopPx: statusBarPx(nativeBytes),
+          },
+        )
+        fs.mkdirSync(imagesDir, { recursive: true })
+        fs.writeFileSync(path.join(out, imageRel), triptych)
+        screens.push({ ...capture, image: imageRel, diff })
+      } else if (hasNative || hasPeach) {
+        const only = path.relative(out, hasNative ? nativePng : peachPng)
+        screens.push({
+          ...capture,
+          ...(hasNative ? { nativeOnly: only } : { peachOnly: only }),
+        })
+      } else {
+        screens.push({ ...capture })
+      }
+    }
+    flows.push({
+      name: flow.name,
+      file: displayPath(cwd, flow.file),
+      native: sideFromSteps(
+        nativeSteps,
+        nativeRan,
+        nativeRan
+          ? []
+          : [
+              `maestro produced no output for this flow (exit ${nativeExit}); see ios.log`,
+            ],
+      ),
+      peach: sideFromSteps(peachSteps, peachRan, peachConsole),
+      screens,
+    })
+  }
+
+  const report: CompareReport = {
+    createdAt: new Date().toISOString(),
+    device,
+    thresholdPercent: threshold,
+    flows,
+  }
+  fs.writeFileSync(path.join(out, 'report.json'), `${JSON.stringify(report, null, 2)}\n`)
+  const htmlPath = path.join(out, 'report.html')
+  fs.writeFileSync(htmlPath, buildCompareHtml(report))
+
+  const over = screensOverThreshold(report)
+  const compared = flows.flatMap((f) => f.screens).filter((s) => s.diff).length
+  console.log(`
+  compare summary:`)
+  for (const flow of flows) {
+    console.log(
+      `    ${flow.name}: iOS ${flow.native.status}, Peach ${flow.peach.status}, ${flow.screens.filter((s) => s.diff).length}/${flow.screens.length} screens paired`,
+    )
+  }
+  console.log(`  ${compared} screens compared, ${over.length} over ${threshold}%`)
+  console.log(`  report: ${htmlPath}\n`)
+  return comparePassed(report) ? 0 : 1
+}

package/cli/commands/maestro-generate.ts

@@ -222,9 +222,12 @@ function parseObservedSelector(
     throw new Error(`generated selector was never observed: ${JSON.stringify(raw)}`)
   }
   const selector: ObservedSelector & { timeout?: number } = {}
-  // id selectors are regexes in Maestro, so quote the observed literal id.
-  if (typeof id === 'string') selector.id = id.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-  if (typeof text === 'string') selector.text = text
+  // maestro id and text selectors are regexes; generated observations are literals.
+  for (const key of ['id', 'text'] satisfies Array<'id' | 'text'>) {
+    const literal = raw[key]
+    if (typeof literal === 'string')
+      selector[key] = literal.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  }
   if (raw.index !== undefined) {
     if (
       typeof raw.index !== 'number' ||

package/cli/commands/maestro.ts

@@ -46,6 +46,9 @@ import { resolveDefaultUploadOrigin } from './upload'
 export interface RunMaestroOptions {
   port?: number
   verbose?: boolean
+  // write each flow's app console to <test-output>/<flow>/logs/console.json
+  // (maestro compare reads it for the errors Peach saw)
+  captureConsole?: boolean
 }
 
 const MAESTRO_DIRS = ['.maestro', 'maestro']
@@ -59,6 +62,8 @@ usage:
   peach maestro test <flow-or-dir>      # mirrors "maestro test"
   peach maestro load <flow>             # load flow into runner without running (--dry-run)
   peach maestro test .maestro/          # workspace globs, root flows by default
+  peach maestro compare <flow-or-dir>   # run on your iOS simulator and on peach,
+                                        # html report: screens, pixel diff, errors, timing
   peach maestro generate "<goal>"       # generate, run, and upload a Maestro flow
   peach maestro start|keep|end          # author a flow from live CLI actions
   peach maestro validate <flow>         # validate a Maestro YAML file
@@ -307,6 +312,11 @@ export async function runMaestro(
   if (sub === 'init') {
     return runInit(cwd)
   }
+  if (sub === 'compare') {
+    const { runMaestroCompare } = await import('./maestro-compare')
+    // compare forwards --env to real maestro too, so it reads the raw argv
+    return runMaestroCompare(hoistLeadingSimFlag([...args]).slice(1), opts)
+  }
   if (sub === 'generate') {
     const { runMaestroGenerate } = await import('./maestro-generate')
     return runMaestroGenerate(remaining.slice(1))
@@ -544,10 +554,22 @@ export async function runMaestro(
     let exit = 0
     const startedAt = Date.now()
     try {
+      const consoleDir =
+        opts.captureConsole && flowTestDir ? path.join(flowTestDir, 'logs') : null
       exit = await runFlowPlayback(playbackArgs, {
         beforeSteps: async () => {
           console.log(`\n  ▶ ${path.relative(cwd, file)}`)
         },
+        ...(consoleDir
+          ? {
+              afterSteps: async (driver) => {
+                fs.writeFileSync(
+                  path.join(consoleDir, 'console.json'),
+                  `${JSON.stringify(await driver.readConsole(), null, 2)}\n`,
+                )
+              },
+            }
+          : {}),
       })
     } catch (err) {
       if (err instanceof DisconnectedSimError) {

package/cli/commands/mode.ts

@@ -1,4 +1,4 @@
-import { rnxExit } from '../run-rnx'
+import { peachExit } from '../run-rnx'
 import { runScreenshotMode } from './screenshot-mode'
 import { runShowTouchesMode } from './show-touches-mode'
 import { runThreeMode } from './three-mode'
@@ -44,7 +44,7 @@ export async function runMode(args: string[], opts: ModeOptions): Promise<void>
   if (!sub) {
     printHelp()
     if (!args.includes('--help') && !args.includes('-h')) {
-      rnxExit(1)
+      peachExit(1)
     }
     return
   }

package/cli/commands/no-bridge-hint.ts

@@ -3,10 +3,14 @@
 import type { BridgeSimInfo } from '../ws-bridge'
 
 export function printMissingCompanionHint(native = false) {
-  console.error('  no peach desktop companion found.')
+  console.error(
+    native
+      ? '  no native peach desktop host found.'
+      : '  no peach desktop companion found.',
+  )
   console.error('')
   console.error('  install the desktop app:')
-  console.error(`    peach desktop install${native ? ' --native' : ''}`)
+  console.error('    peach desktop install')
   console.error('')
   console.error('  or install the recommended background service:')
   console.error('    peach daemon install')