peachsim 0.1.649 → 0.1.651

package/skills/contrast/SKILL.md

@@ -20,6 +20,7 @@ automation, inspecting the render tree, and managing sims.
 | command | description |
 | --- | --- |
 | `peach swift` | preview a SwiftPM app with hosted compilation and live Swift edits |
+| `peach kotlin` | run an Android Compose app module from its launcher activity |
 | `peach maestro` | author, generate, and run Maestro YAML flows against peach |
 | `peach detox` | run existing Detox suites against peach on headless Chromium |
 | `peach cleanup` | inspect and reclaim local peach disk usage |
@@ -56,7 +57,7 @@ automation, inspecting the render tree, and managing sims.
 | `peach setup` | configure optional local conveniences |
 | `peach compat` | check package compatibility |
 | `peach project-report` | print local project and toolchain metadata |
-| `peach report-issue` | send an explicitly approved compatibility report |
+| `peach support` | ask for help, report a problem, and read our replies |
 | `peach desktop` | launch or install the desktop companion |
 | `peach daemon` | manage the recommended background bridge service |
 | `peach version` | show the CLI + engine runtime versions you are running |

package/skills/peach-setup/SKILL.md

@@ -119,13 +119,13 @@ run `peach compat --json` from the app project root during setup. if the scan
 identifies a plausible missing Peach seam, or the running app gives concrete
 evidence that behavior is missing or broken specifically in Peach, summarize
 the package, expected behavior, actual behavior, and runtime evidence for the
-user. then offer to send that finding with `peach report-issue`.
+user. then offer to send that finding with `peach support report`.
 
 **never submit a report automatically or behind the user's back.** wait for an
 explicit yes. only then run this from the app project root:
 
 ```sh
-peach report-issue --yes "<package; expected behavior; actual behavior; runtime evidence>"
+peach support report --yes "<package; expected behavior; actual behavior; runtime evidence>"
 ```
 
 the command automatically attaches the local compatibility scan plus bounded

package/src/{swift-guest.ts → guest-bundle.ts}

@@ -1,5 +1,6 @@
-// the built-in guest uses the existing Metro runtime and host module seam.
-// the author supplies Swift; this entry carries no engine or compiler code.
+// the built-in guests use the existing Metro runtime and host module seam.
+// the author supplies Swift or Kotlin; an entry carries no engine or compiler
+// code, only the registration of the host module's root.
 import {
   appendRNXMetroModuleIdentityFooter,
   RNX_METRO_MODULE_IDENTITY_VERSION,
@@ -7,12 +8,26 @@ import {
 import { METRO_REQUIRE_POLYFILL } from './metro-runtime-source'
 
 export function swiftGuestBundle(packageName: string): string {
+  return guestBundle(
+    'peachsim/swift',
+    `AppRegistry.registerComponent('PeachSwift', () => host.createSwiftPreviewEntry(${JSON.stringify(packageName)}))`,
+  )
+}
+
+export function kotlinGuestBundle(): string {
+  return guestBundle(
+    'peachsim/kotlin',
+    `AppRegistry.registerComponent('PeachKotlin', () => host.KotlinAppRoot)`,
+  )
+}
+
+function guestBundle(hostModule: string, registration: string): string {
   const modules = [
     {
-      name: 'peach-swift-entry.js',
+      name: 'peach-guest-entry.js',
       code: `const { AppRegistry } = require(1)
-const { createSwiftPreviewEntry } = require(2)
-AppRegistry.registerComponent('PeachSwift', () => createSwiftPreviewEntry(${JSON.stringify(packageName)}))`,
+const host = require(2)
+${registration}`,
       deps: [1, 2],
     },
     {
@@ -21,8 +36,8 @@ AppRegistry.registerComponent('PeachSwift', () => createSwiftPreviewEntry(${JSON
       deps: [],
     },
     {
-      name: 'peachsim/swift',
-      code: `module.exports = global.__contrastHostModules['peachsim/swift']`,
+      name: hostModule,
+      code: `module.exports = global.__contrastHostModules[${JSON.stringify(hostModule)}]`,
       deps: [],
     },
     {

package/src/home-paths.ts

@@ -264,13 +264,15 @@ export interface PrivacyPreferences {
   configured: boolean
 }
 
+// bounded diagnostics and automatic crash reports are on until the person turns
+// them off (`peach config telemetry off`, or DO_NOT_TRACK for one run).
 export function readPrivacyPreferences(): PrivacyPreferences {
   const settings = readSharedConfig().settings
   const productAnalytics = settings?.productAnalytics
   const crashReports = settings?.crashReports
   return {
-    productAnalytics: typeof productAnalytics === 'boolean' ? productAnalytics : false,
-    crashReports: typeof crashReports === 'boolean' ? crashReports : false,
+    productAnalytics: typeof productAnalytics === 'boolean' ? productAnalytics : true,
+    crashReports: typeof crashReports === 'boolean' ? crashReports : true,
     configured: typeof productAnalytics === 'boolean',
   }
 }
@@ -286,7 +288,7 @@ export function writePrivacyPreferences(
   })
 }
 
-// created only after explicit consent, alongside the privacy preferences.
+// created on the first diagnostic sent, alongside the privacy preferences.
 export function readOrCreateAnonymousId(): string {
   const existing = readSharedConfig().settings?.anonymousId
   if (

package/src/kotlin-app.ts

@@ -0,0 +1,411 @@
+// reads a pure Kotlin Android app module the way its Gradle build and the
+// device resolve it, for the subset Peach boots: one module's `main` source
+// set, its own manifest, literal Gradle values and the pinned Compose closure.
+// anything outside that subset rejects with its location, never approximated.
+
+import fs from 'node:fs'
+import path from 'node:path'
+
+export interface KotlinAppProject {
+  projectDir: string
+  moduleDir: string
+  sources: string[]
+  language: string
+  packageName: string
+  namespace: string
+  targetSdk: number
+  optOutEdgeToEdge: boolean
+  applicationClass: string | null
+  launcher: { name: string; targetClass: string }
+}
+
+export interface ComposeAndroidPins {
+  ui: string
+  foundation: string
+  runtime: string
+  material3: string
+}
+
+const ANDROID_NS = 'android:'
+const MAIN = 'android.intent.action.MAIN'
+const LAUNCHER = 'android.intent.category.LAUNCHER'
+const PLUGINS = new Set([
+  'com.android.application',
+  'org.jetbrains.kotlin.android',
+  'org.jetbrains.kotlin.plugin.compose',
+])
+// the closure Peach links. compose artifacts must match its Android pins; the
+// activity, lifecycle and savedstate artifacts are Peach's platform actuals.
+const PLATFORM_GROUPS = new Set([
+  'androidx.activity',
+  'androidx.lifecycle',
+  'androidx.savedstate',
+])
+const COMPOSE_PIN: Record<string, keyof ComposeAndroidPins> = {
+  'androidx.compose.ui': 'ui',
+  'androidx.compose.foundation': 'foundation',
+  'androidx.compose.runtime': 'runtime',
+  'androidx.compose.material3': 'material3',
+}
+
+interface XmlElement {
+  name: string
+  attributes: Record<string, string>
+  children: XmlElement[]
+}
+
+// manifest XML: elements and quoted attributes; comments, declarations and
+// text are skipped
+function parseXml(text: string, file: string): XmlElement {
+  const root: XmlElement = { name: '#document', attributes: {}, children: [] }
+  const stack = [root]
+  const body = text.replace(/<!--[\s\S]*?-->/g, '').replace(/<\?[\s\S]*?\?>/g, '')
+  for (const match of body.matchAll(
+    /<(\/?)([\w:.-]+)((?:\s+[\w:.-]+\s*=\s*"[^"]*")*)\s*(\/?)>/g,
+  )) {
+    const [, closing, name, rawAttributes, selfClosing] = match
+    if (!name) continue
+    if (closing) {
+      const open = stack.pop()
+      if (open?.name !== name)
+        throw new Error(`${file}: </${name}> closes <${open?.name}>`)
+      continue
+    }
+    const attributes: Record<string, string> = {}
+    for (const [, key, value] of (rawAttributes ?? '').matchAll(
+      /([\w:.-]+)\s*=\s*"([^"]*)"/g,
+    ))
+      if (key)
+        attributes[key] = (value ?? '').replaceAll('&quot;', '"').replaceAll('&amp;', '&')
+    const element: XmlElement = { name, attributes, children: [] }
+    stack.at(-1)?.children.push(element)
+    if (!selfClosing) stack.push(element)
+  }
+  if (stack.length !== 1)
+    throw new Error(`${file}: <${stack.at(-1)?.name}> is never closed`)
+  return root
+}
+
+function readGradle(dir: string): { file: string; text: string } | null {
+  for (const name of ['build.gradle.kts', 'build.gradle']) {
+    const file = path.join(dir, name)
+    if (fs.existsSync(file)) return { file, text: fs.readFileSync(file, 'utf8') }
+  }
+  return null
+}
+
+function lineOf(text: string, index: number): number {
+  return text.slice(0, index).split('\n').length
+}
+
+// a literal `name = value` or `name value`; any other assignment of the name
+// is a value Peach cannot read without running Gradle
+function gradleLiteral(
+  gradle: { file: string; text: string },
+  name: string,
+  pattern: string,
+): string | null {
+  const literal = new RegExp(`\\b${name}\\s*=?\\s*(${pattern})\\s*$`, 'm').exec(
+    gradle.text,
+  )
+  if (literal?.[1]) return literal[1].replace(/^"|"$/g, '')
+  const any = new RegExp(`\\b${name}\\b\\s*=?\\s*\\S`, 'm').exec(gradle.text)
+  if (any)
+    throw new Error(
+      `${gradle.file}:${lineOf(gradle.text, any.index)}: ${name} must be a literal for peach kotlin`,
+    )
+  return null
+}
+
+function kotlinPluginVersion(
+  projectDir: string,
+  moduleGradle: { file: string; text: string },
+) {
+  const sources = [readGradle(projectDir), moduleGradle].filter((value) => value !== null)
+  for (const gradle of sources) {
+    const match =
+      /id\(\s*"org\.jetbrains\.kotlin\.android"\s*\)\s*version\s*"([^"]+)"/.exec(
+        gradle.text,
+      ) ?? /kotlin\(\s*"android"\s*\)\s*version\s*"([^"]+)"/.exec(gradle.text)
+    if (match?.[1]) return match[1]
+  }
+  const catalog = path.join(projectDir, 'gradle', 'libs.versions.toml')
+  if (fs.existsSync(catalog)) {
+    const match = /^kotlin\s*=\s*"([^"]+)"/m.exec(fs.readFileSync(catalog, 'utf8'))
+    if (match?.[1]) return match[1]
+  }
+  throw new Error(
+    `${projectDir} declares no literal org.jetbrains.kotlin.android plugin version`,
+  )
+}
+
+function checkModuleGradle(
+  gradle: { file: string; text: string },
+  pins: ComposeAndroidPins,
+) {
+  const at = (index: number) => `${gradle.file}:${lineOf(gradle.text, index)}`
+  for (const match of gradle.text.matchAll(
+    /\bid\(\s*"([^"]+)"\s*\)|\bkotlin\(\s*"([^"]+)"\s*\)/g,
+  )) {
+    const plugin = match[1] ?? `org.jetbrains.kotlin.${match[2]}`
+    if (!PLUGINS.has(plugin))
+      throw new Error(
+        `${at(match.index)}: plugin ${plugin} is not supported by peach kotlin`,
+      )
+  }
+  for (const block of gradle.text.matchAll(/\bdependencies\s*\{/g)) {
+    // the block runs to its matching brace, on one line or many; every
+    // statement in it must be a literal dependency Peach can check
+    const start = block.index + block[0].length
+    let depth = 1
+    let end = start
+    for (; end < gradle.text.length && depth > 0; end++) {
+      if (gradle.text[end] === '{') depth++
+      else if (gradle.text[end] === '}') depth--
+    }
+    if (depth > 0) throw new Error(`${at(block.index)}: dependencies block never closes`)
+    const body = gradle.text.slice(start, end - 1)
+    for (const statement of body.matchAll(/[^\n;]+/g)) {
+      const text = statement[0].replace(/\/\/.*$/, '').trim()
+      if (!text) continue
+      const where = at(start + statement.index)
+      const call = /^(\w+)\s*\(\s*(.*?)\s*\)$/.exec(text)
+      if (!call) throw new Error(`${where}: ${text} is not a literal dependency`)
+      const [, configuration = '', value = ''] = call
+      if (/^(test|androidTest|debug|release)/.test(configuration)) continue
+      const coordinate = /^["']([^"':]+):([^"':]+):([^"']+)["']$/.exec(value)
+      if (!coordinate)
+        throw new Error(`${where}: ${value} is not a literal group:artifact:version`)
+      const [, group = '', artifact, version] = coordinate
+      const pin = COMPOSE_PIN[group]
+      if (pin) {
+        if (version !== pins[pin])
+          throw new Error(
+            `${where}: ${group}:${artifact}:${version} differs from Peach's Compose ${pin} ${pins[pin]}`,
+          )
+      } else if (!PLATFORM_GROUPS.has(group))
+        throw new Error(`${where}: ${group}:${artifact} is not in Peach's Kotlin closure`)
+    }
+  }
+}
+
+function themeOptsOut(moduleDir: string, theme: string | undefined): boolean {
+  const name = theme?.startsWith('@style/') ? theme.slice('@style/'.length) : null
+  if (!name) return false
+  const values = path.join(moduleDir, 'src/main/res/values')
+  if (!fs.existsSync(values)) throw new Error(`${theme} names no style in ${values}`)
+  for (const file of fs.readdirSync(values).filter((entry) => entry.endsWith('.xml'))) {
+    const full = path.join(values, file)
+    const resources = parseXml(fs.readFileSync(full, 'utf8'), full)
+    for (const style of resources.children.flatMap((element) => element.children)) {
+      if (style.name !== 'style' || style.attributes.name !== name) continue
+      if (style.attributes.parent?.startsWith('@style/'))
+        throw new Error(
+          `${full}: style ${name} inherits an app style; peach kotlin reads one level`,
+        )
+      const items = fs
+        .readFileSync(full, 'utf8')
+        .match(new RegExp(`<style\\b[^>]*name="${name}"[\\s\\S]*?</style>`))?.[0]
+      return /<item\s+name="android:windowOptOutEdgeToEdgeEnforcement"\s*>\s*true\s*</.test(
+        items ?? '',
+      )
+    }
+  }
+  throw new Error(`${theme} names no style in ${values}`)
+}
+
+function enabled(element: XmlElement): boolean {
+  return element.attributes[`${ANDROID_NS}enabled`] !== 'false'
+}
+
+// PackageParser: a component with an intent filter must declare
+// android:exported from target SDK 31 and defaults to exported below it.
+// launching from the home screen or the shell needs an exported component.
+function exported(element: XmlElement, targetSdk: number, manifestFile: string): boolean {
+  const value = element.attributes[`${ANDROID_NS}exported`]
+  if (value !== undefined) return value === 'true'
+  const filtered = element.children.some((child) => child.name === 'intent-filter')
+  if (filtered && targetSdk >= 31)
+    throw new Error(
+      `${manifestFile}: ${element.attributes[`${ANDROID_NS}name`]} has an intent filter and no android:exported, which fails to install from target SDK 31`,
+    )
+  return filtered
+}
+
+function isLauncher(element: XmlElement): boolean {
+  return element.children.some(
+    (filter) =>
+      filter.name === 'intent-filter' &&
+      filter.children.some(
+        (child) =>
+          child.name === 'action' && child.attributes[`${ANDROID_NS}name`] === MAIN,
+      ) &&
+      filter.children.some(
+        (child) =>
+          child.name === 'category' && child.attributes[`${ANDROID_NS}name`] === LAUNCHER,
+      ),
+  )
+}
+
+export function readKotlinApp(
+  moduleArg: string,
+  options: { activity?: string; pins: ComposeAndroidPins },
+): KotlinAppProject {
+  const moduleDir = fs.realpathSync(path.resolve(moduleArg))
+  const manifestFile = path.join(moduleDir, 'src/main/AndroidManifest.xml')
+  if (!fs.existsSync(manifestFile))
+    throw new Error(
+      `${moduleDir} is not an Android app module: no src/main/AndroidManifest.xml`,
+    )
+  let projectDir = moduleDir
+  while (
+    !['settings.gradle.kts', 'settings.gradle'].some((name) =>
+      fs.existsSync(path.join(projectDir, name)),
+    )
+  ) {
+    const parent = path.dirname(projectDir)
+    if (parent === projectDir)
+      throw new Error(`${moduleDir} has no settings.gradle above it`)
+    projectDir = parent
+  }
+  const gradle = readGradle(moduleDir)
+  if (!gradle) throw new Error(`${moduleDir} has no build.gradle`)
+  checkModuleGradle(gradle, options.pins)
+  const namespace = gradleLiteral(gradle, 'namespace', '"[\\w.]+"')
+  const applicationId = gradleLiteral(gradle, 'applicationId', '"[\\w.]+"')
+  const targetSdk = Number(gradleLiteral(gradle, 'targetSdk(?:Version)?', '\\d+'))
+  if (!Number.isInteger(targetSdk) || targetSdk <= 0)
+    throw new Error(`${gradle.file}: declares no literal targetSdk`)
+  const kotlin = kotlinPluginVersion(projectDir, gradle)
+  const language = /^(\d+)\.(\d+)/.exec(kotlin)?.slice(1, 3).join('.')
+  if (!language)
+    throw new Error(`Kotlin plugin version ${kotlin} names no language version`)
+
+  const manifest = parseXml(fs.readFileSync(manifestFile, 'utf8'), manifestFile)
+  const root = manifest.children.find((element) => element.name === 'manifest')
+  const application = root?.children.find((element) => element.name === 'application')
+  if (!root || !application) throw new Error(`${manifestFile} has no <application>`)
+  const base = namespace ?? root.attributes.package
+  if (!base)
+    throw new Error(`${gradle.file}: declares no namespace and the manifest no package`)
+  const className = (name: string) =>
+    name.startsWith('.') ? base + name : name.includes('.') ? name : `${base}.${name}`
+  if (application.attributes[`${ANDROID_NS}appComponentFactory`])
+    throw new Error(
+      `${manifestFile}: android:appComponentFactory is not supported by peach kotlin`,
+    )
+  for (const element of application.children) {
+    if (element.name === 'provider')
+      throw new Error(
+        `${manifestFile}: <provider ${element.attributes[`${ANDROID_NS}name`]}> is not supported by peach kotlin`,
+      )
+    if (element.attributes[`${ANDROID_NS}process`])
+      throw new Error(
+        `${manifestFile}: android:process on ${element.attributes[`${ANDROID_NS}name`]} is not supported by peach kotlin`,
+      )
+  }
+  if (application.attributes[`${ANDROID_NS}process`])
+    throw new Error(
+      `${manifestFile}: android:process on <application> is not supported by peach kotlin`,
+    )
+  for (const [key, value] of [
+    ...[root, application].flatMap((element) => Object.entries(element.attributes)),
+  ])
+    if (value.includes('${'))
+      throw new Error(`${manifestFile}: ${key}="${value}" is a Gradle placeholder`)
+
+  const activities = application.children.filter((element) => element.name === 'activity')
+  const components = application.children.filter(
+    (element) => element.name === 'activity' || element.name === 'activity-alias',
+  )
+  const target = (element: XmlElement) => {
+    const name = element.attributes[`${ANDROID_NS}name`]
+    if (!name) throw new Error(`${manifestFile}: <${element.name}> has no android:name`)
+    if (element.name === 'activity') return className(name)
+    const targetName = element.attributes[`${ANDROID_NS}targetActivity`]
+    const activity = activities.find(
+      (candidate) =>
+        className(candidate.attributes[`${ANDROID_NS}name`] ?? '') ===
+        className(targetName ?? ''),
+    )
+    if (!targetName || !activity)
+      throw new Error(
+        `${manifestFile}: activity-alias ${name} targets no declared activity`,
+      )
+    if (!enabled(activity)) return null
+    return className(targetName)
+  }
+  const applicationEnabled = enabled(application)
+  let chosen: XmlElement | undefined
+  if (options.activity) {
+    const wanted = className(options.activity)
+    chosen = components.find(
+      (element) => className(element.attributes[`${ANDROID_NS}name`] ?? '') === wanted,
+    )
+    if (!chosen)
+      throw new Error(`Error type 3: Activity class {${base}/${wanted}} does not exist.`)
+    if (!applicationEnabled || !enabled(chosen) || target(chosen) === null)
+      throw new Error(`Activity {${base}/${wanted}} is disabled`)
+    if (!exported(chosen, targetSdk, manifestFile))
+      throw new Error(`Permission Denial: ${base}/${wanted} is not exported`)
+  } else {
+    const launchers = applicationEnabled
+      ? components.filter(
+          (element) =>
+            enabled(element) &&
+            isLauncher(element) &&
+            exported(element, targetSdk, manifestFile) &&
+            target(element) !== null,
+        )
+      : []
+    if (launchers.length === 0)
+      throw new Error(
+        `${manifestFile}: no enabled activity resolves the MAIN/LAUNCHER intent`,
+      )
+    if (launchers.length > 1)
+      throw new Error(
+        `${manifestFile}: ${launchers.map((element) => element.attributes[`${ANDROID_NS}name`]).join(', ')} all resolve the launcher intent; pick one with --activity`,
+      )
+    chosen = launchers[0]
+  }
+  const launcherName = className(chosen?.attributes[`${ANDROID_NS}name`] ?? '')
+  const targetClass = chosen ? target(chosen) : null
+  if (!targetClass) throw new Error(`${launcherName} targets a disabled activity`)
+  const themeOwner = activities.find(
+    (element) => className(element.attributes[`${ANDROID_NS}name`] ?? '') === targetClass,
+  )
+  const theme =
+    themeOwner?.attributes[`${ANDROID_NS}theme`] ??
+    application.attributes[`${ANDROID_NS}theme`]
+  const applicationName = application.attributes[`${ANDROID_NS}name`]
+
+  const sources: string[] = []
+  for (const set of ['java', 'kotlin']) {
+    const dir = path.join(moduleDir, 'src/main', set)
+    if (!fs.existsSync(dir)) continue
+    const walk = (current: string) => {
+      for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+        const full = path.join(current, entry.name)
+        if (entry.isDirectory()) walk(full)
+        else if (entry.name.endsWith('.java'))
+          throw new Error(`${full}: Java sources are not supported by peach kotlin`)
+        else if (entry.name.endsWith('.kt')) sources.push(full)
+      }
+    }
+    walk(dir)
+  }
+  if (sources.length === 0)
+    throw new Error(`${moduleDir}/src/main holds no Kotlin sources`)
+  return {
+    projectDir,
+    moduleDir,
+    sources: sources.sort(),
+    language,
+    packageName: applicationId ?? base,
+    namespace: base,
+    targetSdk,
+    optOutEdgeToEdge: themeOptsOut(moduleDir, theme),
+    applicationClass: applicationName ? className(applicationName) : null,
+    launcher: { name: launcherName, targetClass },
+  }
+}