peachsim 0.1.649 → 0.1.650

package/cli/commands/support.ts

@@ -0,0 +1,399 @@
+// peach support — ask for help, report a problem, and read our replies
+// (plans/peach-cloud/partner-support.md). every item belongs to the account the
+// CLI login names, so `status` lists them without the caller keeping ids.
+//
+//   peach support ask "<question>" [--no-wait] [--wait <minutes>] [--json]
+//   peach support report [--app <dir>] [--dry-run] [--yes] "<description>"
+//   peach support status [--new] [--json]
+//   peach support fund [--amount <usd>]
+
+import { resolve } from 'node:path'
+import { TOPUP_DEFAULT_USD } from 'peach-engine/billing/plans'
+import {
+  readSharedDesktopAuthSession,
+  writeSharedDesktopAuthSession,
+} from '../../src/auth/shared-session'
+import { readSharedConfig, writeSharedConfig } from '../../src/home-paths'
+import { openUrl } from '../open-url'
+import { runReportIssue, supportEndpoint, toolchainContext } from './report-issue'
+
+const POLL_MS = 10_000
+const FUND_POLL_MS = 3_000
+const FUND_WAIT_MS = 30 * 60_000
+const DEFAULT_WAIT_MINUTES = 15
+const SEEN_KEY = 'supportSeenAt'
+
+type Reply = { body: string; createdAt: number }
+
+type Item = {
+  id: string
+  kind: 'ask' | 'report'
+  note: string | null
+  status: string
+  createdAt: number
+  updatedAt: number
+  replies: Reply[]
+  fixCommit: string | null
+  release: string | null
+}
+
+const USAGE =
+  '  usage:\n' +
+  '    peach support ask "<question>" [--no-wait] [--wait <minutes>] [--json]\n' +
+  '    peach support report [--app <dir>] [--dry-run] [--yes] "<description>"\n' +
+  '    peach support status [--new] [--json]\n' +
+  '    peach support fund [--amount <usd>]\n'
+
+function signInHint(): number {
+  process.stderr.write('  sign in first with `peach login`, or set PEACH_API_KEY.\n')
+  return 1
+}
+
+function field(value: unknown, key: string): unknown {
+  return value && typeof value === 'object' ? Reflect.get(value, key) : undefined
+}
+
+function toItem(value: unknown): Item | null {
+  const id = field(value, 'id')
+  const kind = field(value, 'kind')
+  const status = field(value, 'status')
+  const createdAt = field(value, 'createdAt')
+  const updatedAt = field(value, 'updatedAt')
+  const replies = field(value, 'replies')
+  if (
+    typeof id !== 'string' ||
+    (kind !== 'ask' && kind !== 'report') ||
+    typeof status !== 'string' ||
+    typeof createdAt !== 'number' ||
+    typeof updatedAt !== 'number' ||
+    !Array.isArray(replies)
+  ) {
+    return null
+  }
+  const note = field(value, 'note')
+  const fixCommit = field(value, 'fixCommit')
+  const release = field(value, 'release')
+  return {
+    id,
+    kind,
+    note: typeof note === 'string' ? note : null,
+    status,
+    createdAt,
+    updatedAt,
+    fixCommit: typeof fixCommit === 'string' ? fixCommit : null,
+    release: typeof release === 'string' ? release : null,
+    replies: replies.flatMap((reply) => {
+      const body = field(reply, 'body')
+      const at = field(reply, 'createdAt')
+      return typeof body === 'string' && typeof at === 'number'
+        ? [{ body, createdAt: at }]
+        : []
+    }),
+  }
+}
+
+// the server's error message, never an html error page
+async function failure(response: Response): Promise<string> {
+  // support routes answer { error }, billing routes { message }
+  const body: unknown = await response.json().catch(() => null)
+  const message = field(body, 'error') ?? field(body, 'message')
+  return `${response.status} ${typeof message === 'string' ? message : response.statusText}`
+}
+
+async function fetchItems(id?: string): Promise<Item[]> {
+  const target = supportEndpoint()
+  const url = new URL('/api/sootsim/support', target.origin)
+  if (id) url.searchParams.set('id', id)
+  const response = await fetch(url, {
+    headers: target.headers,
+    signal: AbortSignal.timeout(15_000),
+  })
+  if (!response.ok) throw new Error(await failure(response))
+  const items = field(await response.json(), 'items')
+  return Array.isArray(items) ? items.flatMap((item) => toItem(item) ?? []) : []
+}
+
+// an ask is done once it is answered or closed without one
+function settled(item: Item): boolean {
+  return !['received', 'answering', 'waitlisted'].includes(item.status)
+}
+
+function indent(text: string, prefix = '    '): string {
+  return text
+    .trim()
+    .split('\n')
+    .map((line) => `${prefix}${line}`)
+    .join('\n')
+}
+
+function summary(note: string | null): string {
+  const line = (note ?? '').trim().split('\n')[0] ?? ''
+  return line.length > 90 ? `${line.slice(0, 89)}…` : line
+}
+
+function formatItem(item: Item, seenAt: number): string {
+  const fresh = item.updatedAt > seenAt || item.replies.some((r) => r.createdAt > seenAt)
+  const lines = [
+    `  ${fresh ? '* ' : ''}${item.kind} ${item.id}  ${item.status}  ${new Date(item.createdAt).toISOString().slice(0, 16).replace('T', ' ')}`,
+    `    ${summary(item.note)}`,
+  ]
+  if (item.fixCommit) {
+    lines.push(
+      item.release
+        ? `    fixed in ${item.fixCommit.slice(0, 10)}, shipped in runtime v${item.release} (\`peach upgrade\` picks it up)`
+        : `    fixed in ${item.fixCommit.slice(0, 10)}, not in a runtime release yet`,
+    )
+  }
+  for (const reply of item.replies) {
+    lines.push(
+      `    reply ${new Date(reply.createdAt).toISOString().slice(0, 16).replace('T', ' ')}${reply.createdAt > seenAt ? ' (new)' : ''}:`,
+      indent(reply.body, '      '),
+    )
+  }
+  return lines.join('\n')
+}
+
+function flagValue(args: string[], flag: string): string | null {
+  const index = args.indexOf(flag)
+  if (index === -1) return null
+  const value = args[index + 1]
+  if (!value || value.startsWith('-')) throw new Error(`${flag} requires a value`)
+  return value
+}
+
+// an ask sends the question and the toolchain context: CLI and runtime
+// versions and the dependency compatibility scan of the app directory. never
+// source, env, logs, or screenshots.
+async function askPayload(question: string, appDir: string) {
+  const context = await toolchainContext(appDir)
+  return {
+    kind: 'ask',
+    note: question,
+    timestamp: new Date().toISOString(),
+    sootsim_version: context.runtimeVersion,
+    cli_version: context.cliVersion,
+    bundle: context,
+  }
+}
+
+async function runAsk(args: string[]): Promise<number> {
+  const json = args.includes('--json')
+  const noWait = args.includes('--no-wait')
+  let waitMinutes = DEFAULT_WAIT_MINUTES
+  let app: string | null
+  try {
+    const wait = flagValue(args, '--wait')
+    if (wait) waitMinutes = Number(wait)
+    app = flagValue(args, '--app')
+  } catch (error) {
+    process.stderr.write(`  ${error instanceof Error ? error.message : error}\n${USAGE}`)
+    return 1
+  }
+  if (!Number.isFinite(waitMinutes) || waitMinutes < 0) {
+    process.stderr.write(`  --wait takes minutes\n${USAGE}`)
+    return 1
+  }
+  const valued = new Set(['--wait', '--app'])
+  const words = args.filter(
+    (arg, i) => !arg.startsWith('-') && !valued.has(args[i - 1] ?? ''),
+  )
+  const question = words.join(' ').trim()
+  if (!question) {
+    process.stderr.write(`  ask a question\n${USAGE}`)
+    return 1
+  }
+  const target = supportEndpoint()
+  if (!target.signedIn) return signInHint()
+
+  const response = await fetch(new URL('/api/sootsim/report-issue', target.origin), {
+    method: 'POST',
+    headers: { ...target.headers, 'content-type': 'application/json' },
+    body: JSON.stringify(await askPayload(question, resolve(app ?? '.'))),
+    signal: AbortSignal.timeout(15_000),
+  }).catch((error: unknown) => error)
+  if (!(response instanceof Response)) {
+    process.stderr.write(`  ask failed: ${String(response)}\n`)
+    return 1
+  }
+  if (!response.ok) {
+    process.stderr.write(`  ask failed: ${await failure(response)}\n`)
+    return 1
+  }
+  const body: unknown = await response.json().catch(() => null)
+  const id = field(body, 'id')
+  if (typeof id !== 'string') {
+    process.stderr.write('  ask failed: the server returned no id\n')
+    return 1
+  }
+  // an ask past the account's unapproved allowance is kept, queued until approval
+  if (field(body, 'status') === 'waitlisted') {
+    const message = String(field(body, 'message') ?? '')
+    if (json)
+      process.stdout.write(`${JSON.stringify({ id, status: 'waitlisted', message })}\n`)
+    else process.stdout.write(`\n  asked (${id}), queued: ${message}.\n\n`)
+    return 0
+  }
+  if (!json) {
+    process.stdout.write(
+      `\n  asked (${id}). Sent the question, CLI and runtime versions, and the\n` +
+        `  dependency compatibility scan; no source, env, logs or screenshots.\n`,
+    )
+  }
+  if (noWait || waitMinutes === 0) {
+    if (json) process.stdout.write(`${JSON.stringify({ id, status: 'received' })}\n`)
+    else process.stdout.write(`  the answer shows in \`peach support status\`.\n\n`)
+    return 0
+  }
+
+  if (!json)
+    process.stdout.write(`  waiting up to ${waitMinutes} minutes for the answer…\n`)
+  const deadline = Date.now() + waitMinutes * 60_000
+  let last: Item | null = null
+  while (Date.now() < deadline) {
+    await new Promise((done) => setTimeout(done, POLL_MS))
+    last = (await fetchItems(id).catch(() => []))[0] ?? last
+    if (last && settled(last)) break
+  }
+  if (json) {
+    process.stdout.write(`${JSON.stringify(last ?? { id, status: 'received' })}\n`)
+    return 0
+  }
+  if (!last || !settled(last)) {
+    process.stdout.write(
+      `  still working on it. \`peach support status\` shows the answer when it lands.\n\n`,
+    )
+    return 0
+  }
+  const answer = last.replies.at(-1)?.body
+  process.stdout.write(answer ? `\n${indent(answer, '  ')}\n\n` : `  ${last.status}\n\n`)
+  return 0
+}
+
+// opens a prepaid top-up checkout in the default browser, waits for it to be
+// paid, and binds the funded account to this login
+async function runFund(args: string[]): Promise<number> {
+  const at = args.indexOf('--amount')
+  const amountUsd = at >= 0 ? Number(args[at + 1]) : TOPUP_DEFAULT_USD
+  if (!Number.isFinite(amountUsd) || amountUsd <= 0) {
+    process.stderr.write(`  --amount takes dollars\n${USAGE}`)
+    return 1
+  }
+  const target = supportEndpoint()
+  if (!target.signedIn) return signInHint()
+  const created = await fetch(new URL('/api/sootsim/billing/checkout', target.origin), {
+    method: 'POST',
+    headers: { ...target.headers, 'content-type': 'application/json' },
+    body: JSON.stringify({ amountUsd }),
+    signal: AbortSignal.timeout(15_000),
+  }).catch((error: unknown) => error)
+  if (!(created instanceof Response)) {
+    process.stderr.write(`  fund failed: ${String(created)}\n`)
+    return 1
+  }
+  if (!created.ok) {
+    process.stderr.write(`  fund failed: ${await failure(created)}\n`)
+    return 1
+  }
+  const body: unknown = await created.json().catch(() => null)
+  const url = field(body, 'url')
+  const id = field(body, 'id')
+  if (typeof url !== 'string' || typeof id !== 'string') {
+    process.stderr.write('  fund failed: the server returned no checkout\n')
+    return 1
+  }
+  process.stdout.write(`\n  opening the payment page in your browser:\n  ${url}\n`)
+  await openUrl(url, { background: false }).catch(() => {
+    process.stdout.write('  could not open a browser; open the link above.\n')
+  })
+  process.stdout.write('  waiting for the payment to finish…\n')
+
+  const statusUrl = new URL('/api/sootsim/billing/checkout-status', target.origin)
+  statusUrl.searchParams.set('id', id)
+  const deadline = Date.now() + FUND_WAIT_MS
+  while (Date.now() < deadline) {
+    await new Promise((done) => setTimeout(done, FUND_POLL_MS))
+    const response = await fetch(statusUrl, {
+      headers: target.headers,
+      signal: AbortSignal.timeout(15_000),
+    }).catch(() => null)
+    if (!response?.ok) continue
+    const state: unknown = await response.json().catch(() => null)
+    if (field(state, 'status') === 'expired') {
+      process.stdout.write('  the payment page expired without a payment.\n\n')
+      return 1
+    }
+    if (field(state, 'paid') !== true) continue
+    const accountId = field(state, 'accountId')
+    const session = readSharedDesktopAuthSession()
+    if (typeof accountId === 'string' && session && session.accountId !== accountId) {
+      writeSharedDesktopAuthSession({ ...session, accountId })
+    }
+    process.stdout.write('  funded. this login now uses the funded account.\n\n')
+    return 0
+  }
+  process.stdout.write(
+    '  no payment yet. run `peach support fund` again once it is done.\n\n',
+  )
+  return 1
+}
+
+async function runStatus(args: string[]): Promise<number> {
+  if (!supportEndpoint().signedIn) return signInHint()
+  let items: Item[]
+  try {
+    items = await fetchItems()
+  } catch (error) {
+    process.stderr.write(
+      `  status failed: ${error instanceof Error ? error.message : error}\n`,
+    )
+    return 1
+  }
+  const seen = readSharedConfig()[SEEN_KEY]
+  const seenAt = typeof seen === 'number' ? seen : 0
+  const isNew = (item: Item) =>
+    item.updatedAt > seenAt || item.replies.some((reply) => reply.createdAt > seenAt)
+  const shown = args.includes('--new') ? items.filter(isNew) : items
+  writeSharedConfig({ [SEEN_KEY]: Date.now() })
+  if (args.includes('--json')) {
+    process.stdout.write(
+      `${JSON.stringify({ items: shown.map((item) => ({ ...item, new: isNew(item) })) }, null, 2)}\n`,
+    )
+    return 0
+  }
+  if (shown.length === 0) {
+    process.stdout.write(
+      args.includes('--new')
+        ? '\n  nothing new since the last check.\n\n'
+        : '\n  no asks or reports yet. `peach support ask "<question>"` asks for help.\n\n',
+    )
+    return 0
+  }
+  process.stdout.write(
+    `\n${shown.map((item) => formatItem(item, seenAt)).join('\n\n')}\n\n` +
+      `  * changed since the last check\n\n`,
+  )
+  return 0
+}
+
+export async function runSupport(args: string[]): Promise<number> {
+  const [sub, ...rest] = args
+  switch (sub) {
+    case 'ask':
+      return runAsk(rest)
+    case 'report':
+      return runReportIssue(rest)
+    case 'status':
+      return runStatus(rest)
+    case 'fund':
+      return runFund(rest)
+    case undefined:
+    case 'help':
+    case '--help':
+    case '-h':
+      process.stdout.write(USAGE)
+      return 0
+    default:
+      process.stderr.write(`  unknown support command: ${sub}\n${USAGE}`)
+      return 1
+  }
+}

package/cli/commands/swift.ts

@@ -2,13 +2,13 @@ import fs from 'node:fs'
 import http from 'node:http'
 import path from 'node:path'
 import { WebSocket, WebSocketServer } from 'ws'
-import { isLoopbackHost, resolveContrastBackendOrigin } from '../../src/backend-origin'
-import { swiftGuestBundle } from '../../src/swift-guest'
+import { resolveContrastBackendOrigin } from '../../src/backend-origin'
+import { swiftGuestBundle } from '../../src/guest-bundle'
 import { SWIFT_HMR_PATH, SWIFT_PACKAGE_PATH } from '../../src/swift-submit'
 import { authHeaderValue, resolveCliAuth } from '../auth'
 import { PeachExit } from '../run-rnx'
-import { createBridge } from '../ws-bridge'
-import { runCloseCommand, runOpenCommand, type OpenCommandResources } from './control'
+import { runOpenCommand, type OpenCommandResources } from './control'
+import { closeGuestResources, isLoopbackGuestRequest } from './guest-host'
 import type { SwiftEntryModuleArgs } from '../../../sootsim-swift/src/entryModule'
 
 export async function runSwift(
@@ -134,19 +134,7 @@ export async function runSwift(
     })
     return building
   }
-  const validRequest = (req: http.IncomingMessage): 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
-    }
-  }
+  const validRequest = (req: http.IncomingMessage) => isLoopbackGuestRequest(req, origin)
   const server = http.createServer((req, res) => {
     if (!validRequest(req)) {
       res.statusCode = 403
@@ -285,41 +273,7 @@ export async function runSwift(
     sockets.close()
     server.closeAllConnections()
     await new Promise<void>((resolve) => server.close(() => resolve()))
-    if (resources.simId && resources.port) {
-      try {
-        await runCloseCommand(['--sim', resources.simId], { port: resources.port })
-      } catch (error) {
-        console.error(`  Swift preview cleanup failed: ${String(error)}`)
-        code = 1
-      }
-    }
-    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))
-          code = 1
-        }
-      }
-    }
-    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)}`)
-        code = 1
-      } finally {
-        bridge.close()
-      }
-    }
+    if (!(await closeGuestResources(resources, 'Swift preview'))) code = 1
     host.disposeSwiftProject(packagePath)
   }
   return code

package/cli/commands/telemetry.ts

@@ -1,27 +1,24 @@
-// `peach config telemetry on|off` — retained as the command spelling for the
-// product analytics preference shown by guided setup and Settings.
+// `peach config telemetry on|off` — the bounded diagnostics and automatic
+// crash report preference shown by guided setup and Settings. both are on until
+// turned off here.
 //
 // this is the process-wide preference; `DO_NOT_TRACK=1` still forces opt-out
-// for a single run regardless of stored consent, including CI and agents.
+// for a single run regardless of the stored choice, including CI and agents.
 
 import {
   configFilePath,
   readPrivacyPreferences,
   writePrivacyPreferences,
 } from '../../src/home-paths'
+import { PRIVACY_NOTICE } from '../privacy'
 import { rnxExit } from '../run-rnx'
 
 function printStatus(): void {
   const preferences = readPrivacyPreferences()
-  const enabled = preferences.configured && preferences.productAnalytics
-  console.log(`  bounded diagnostics are ${enabled ? 'ON' : 'OFF'}`)
-  console.log('  fields: CLI/runtime versions, OS/arch, command name, random install ID')
   console.log(
-    '  diagnostics: package name/version/unsupported API; error class and first-line error/warning messages (300 characters, paths redacted)',
-  )
-  console.log(
-    '  explicit opt-in also applies in CI, pipes and agent runs; DO_NOT_TRACK wins',
+    `  bounded diagnostics are ${preferences.productAnalytics ? 'ON' : 'OFF'}, automatic crash reports are ${preferences.crashReports ? 'ON' : 'OFF'}`,
   )
+  for (const line of PRIVACY_NOTICE) console.log(`  ${line}`)
   console.log(`  config: ${configFilePath()}`)
   const doNotTrack = process.env.DO_NOT_TRACK
   if (doNotTrack === '1' || doNotTrack === 'true') {
@@ -41,14 +38,14 @@ export async function runTelemetry(args: string[]): Promise<void> {
       return
 
     case 'on':
-      writePrivacyPreferences({ productAnalytics: true, crashReports: false })
-      console.log('  bounded diagnostics ON')
+      writePrivacyPreferences({ productAnalytics: true, crashReports: true })
+      console.log('  diagnostics and crash reports ON')
       console.log(`  config: ${configFilePath()}`)
       return
 
     case 'off':
       writePrivacyPreferences({ productAnalytics: false, crashReports: false })
-      console.log('  bounded diagnostics OFF')
+      console.log('  diagnostics and crash reports OFF')
       console.log(`  config: ${configFilePath()}`)
       return
 

package/cli/main.ts

@@ -23,9 +23,9 @@ import { IS_STANDALONE } from './standalone'
 // rejections that don't match this shape still get the verbose stack so we
 // don't paper over real bugs.
 async function handleTopLevelError(err: unknown): Promise<never> {
-  const { trackCliError, flushCliTelemetry } = await import('./telemetry')
+  const { trackCliError, flushCliTelemetry, reportCliCrash } = await import('./telemetry')
   trackCliError(err)
-  await flushCliTelemetry()
+  await flushCliTelemetry(1)
   const msg = err instanceof Error ? err.message : String(err)
   // peach's known top-level errors are all single-line, narrow strings.
   // everything else gets the full stack so unexpected crashes still surface.
@@ -48,6 +48,8 @@ async function handleTopLevelError(err: unknown): Promise<never> {
     process.stderr.write(`  ${msg}\n`)
     process.exit(1)
   }
+  // an unexpected crash is ours to fix: it goes to the issue queue on its own
+  await reportCliCrash(err)
   // bun can render an async-thrown error's stack with a bare `Error` header, so
   // the message always goes first.
   process.stderr.write(`  ${msg}\n`)
@@ -114,8 +116,8 @@ if (
   parsed.command !== 'setup' &&
   parsed.command !== 'telemetry'
 ) {
-  const { ensurePrivacyChoice } = await import('./privacy')
-  await ensurePrivacyChoice({ prompt: true })
+  const { noticePrivacyDefaults } = await import('./privacy')
+  noticePrivacyDefaults()
 }
 
 // one-shot "engine upgraded in the background" banner. the daemon's hourly
@@ -229,7 +231,7 @@ async function scheduleAutomaticCliUpdate(exitCode: number): Promise<void> {
 
 async function exitWithFlush(code: number): Promise<never> {
   const { flushCliTelemetry } = await import('./telemetry')
-  await flushCliTelemetry()
+  await flushCliTelemetry(code)
   await scheduleAutomaticCliUpdate(code)
   await scheduleAutomaticCleanup()
   process.exit(code)
@@ -562,6 +564,17 @@ try {
         )
       }
 
+      case 'kotlin': {
+        if (globalSimTarget) {
+          console.error('  peach kotlin owns a new preview and cannot target --sim')
+          await exitWithFlush(1)
+        }
+        const { runKotlin } = await import('./commands/kotlin')
+        await exitWithFlush(
+          await runKotlin(parsed.commandArgs, { port, device, driver, headless }),
+        )
+      }
+
       case 'preview': {
         const { runPreview } = await import('./commands/preview')
         await exitWithFlush(await runPreview(parsed.commandArgs))
@@ -614,10 +627,9 @@ try {
         await exitWithFlush(runProjectReport(parsed.commandArgs))
       }
 
-      case 'report-issue': {
-        const { runReportIssue } = await import('./commands/report-issue')
-        const code = await runReportIssue(parsed.commandArgs)
-        await exitWithFlush(code)
+      case 'support': {
+        const { runSupport } = await import('./commands/support')
+        await exitWithFlush(await runSupport(parsed.commandArgs))
       }
 
       case 'desktop': {
@@ -734,6 +746,6 @@ try {
 }
 
 const { flushCliTelemetry } = await import('./telemetry')
-await flushCliTelemetry()
+await flushCliTelemetry(0)
 await scheduleAutomaticCliUpdate(0)
 await scheduleAutomaticCleanup()

package/cli/outbound-endpoints.ts

@@ -44,9 +44,16 @@ export const OUTBOUND_ENDPOINTS: Record<string, OutboundEndpointDeclaration> = {
   bounded_diagnostics: {
     category: 'bounded-diagnostics',
     destination: 'configured PostHog ingestion host',
-    preConsent: false,
+    preConsent: true,
     payload:
-      'anonymous install id, CLI/runtime versions, OS/arch, command name, package compatibility fields, error class and bounded path-redacted first-line error/warning messages',
+      'anonymous install id, CLI/runtime versions, OS/arch, command name, exit code and duration bucket, package compatibility fields, error class and bounded path-redacted first-line error/warning messages; on until `peach config telemetry off` or DO_NOT_TRACK',
+  },
+  crash_report: {
+    category: 'bounded-diagnostics',
+    destination: 'configured Contrast origin, /api/sootsim/report-issue',
+    preConsent: true,
+    payload:
+      'an unexpected CLI crash: error class, bounded path-redacted first-line message, command name, CLI/runtime versions, OS/arch and a dedupe signature, at most once a day per signature; on until `peach config telemetry off` or DO_NOT_TRACK',
   },
   contrast_user_action: {
     category: 'explicit-user-action',
@@ -544,6 +551,18 @@ export const DECLARED_OUTBOUND_CALLS: Record<string, OutboundCallDeclaration> =
     category: 'contrast_user_action',
     count: 1,
   },
+  "packages/peachsim/cli/commands/support.ts :: fetch :: new URL('/api/sootsim/billing/checkout', target.origin)":
+    { category: 'contrast_user_action', count: 1 },
+  "packages/peachsim/cli/commands/support.ts :: fetch :: new URL('/api/sootsim/report-issue', target.origin)":
+    { category: 'contrast_user_action', count: 1 },
+  'packages/peachsim/cli/commands/support.ts :: fetch :: statusUrl': {
+    category: 'contrast_user_action',
+    count: 1,
+  },
+  'packages/peachsim/cli/commands/support.ts :: fetch :: url': {
+    category: 'contrast_user_action',
+    count: 1,
+  },
   'packages/peachsim/cli/commands/runtime.ts :: websocket :: `ws://127.0.0.1:${port}`': {
     category: 'local_development',
     count: 1,
@@ -578,6 +597,8 @@ export const DECLARED_OUTBOUND_CALLS: Record<string, OutboundCallDeclaration> =
     category: 'release_notes',
     count: 1,
   },
+  'packages/peachsim/cli/telemetry.ts :: fetch :: `${endpoint.origin}/api/sootsim/report-issue`':
+    { category: 'crash_report', count: 1 },
   'packages/peachsim/cli/telemetry.ts :: fetch :: `${config.host}/batch/`': {
     category: 'bounded_diagnostics',
     count: 1,