peachsim 0.1.577 → 0.1.579

package/kotlin/README.md

@@ -0,0 +1,18 @@
+# peachsim kotlin
+
+The Android side of a One app's directly imported Kotlin in Peach. Owner spec:
+[`specs/rnx-swift.md`](../../../specs/rnx-swift.md) (direct native source imports).
+
+- `toolchain.json`: the pinned Kotlin compiler and the kotlinx-coroutines
+  Kotlin/Wasm klibs, with their sha256. `peachsim/vite-kotlin` fetches them once
+  into `~/.peach/kotlin/<version>`. kotlinc needs a Java runtime (17 or newer)
+  from `JAVA_HOME` or `PATH`, the one an Android build uses.
+- `Sources/`: the Android and One declarations app Kotlin and One's generated
+  glue compile against: `org.json` with Android's parse and print rules,
+  `androidx.annotation.Keep`, `dev.onejs.one.OneNativeSourceDispatch` and
+  `dev.onejs.one.source.OneModule`.
+
+The dev server compiles every `.kt` source of the app, One's glue for each and
+a generated entry into one Kotlin/Wasm module, held to the Kotlin language
+version React Native's Android build pins. Replay:
+`scripts/debug/peach-one-native-source-guest.sh`.

package/kotlin/Sources/androidx/annotation/Keep.kt

@@ -0,0 +1,4 @@
+package androidx.annotation
+
+// R8 keeps what this marks on device; Peach compiles no shrinker
+annotation class Keep

package/kotlin/Sources/dev/onejs/one/OneNativeSourceDispatch.kt

@@ -0,0 +1,7 @@
+package dev.onejs.one
+
+// One's android interface, as packages/one/android declares it
+interface OneNativeSourceDispatch {
+    val contractHash: String
+    suspend fun call(module: String, method: String, argsJson: String): String
+}

package/kotlin/Sources/dev/onejs/one/source/OneModule.kt

@@ -0,0 +1,4 @@
+package dev.onejs.one.source
+
+// One's android marker interface for a directly imported Kotlin module
+interface OneModule

package/kotlin/Sources/org/json/JSON.kt

@@ -0,0 +1,244 @@
+package org.json
+
+// the part of android's org.json that One's generated glue and app modules
+// use, with android's parse and print rules: an integer literal parses as Int,
+// or Long past Int, anything with a fraction or exponent as Double; a number
+// whose value is integral prints without a fraction; '/' prints escaped.
+
+class JSONException(message: String) : RuntimeException(message)
+
+private class JSONTokener(private val text: String) {
+    private var at = 0
+
+    private fun skip() {
+        while (at < text.length && text[at].isWhitespace()) at++
+    }
+
+    private fun next(): Char {
+        if (at >= text.length) throw JSONException("End of input at character $at of $text")
+        return text[at++]
+    }
+
+    private fun peek(): Char {
+        skip()
+        if (at >= text.length) throw JSONException("End of input at character $at of $text")
+        return text[at]
+    }
+
+    fun nextValue(): Any = when (peek()) {
+        '[' -> { at++; array() }
+        '{' -> { at++; objectValue() }
+        '"', '\'' -> string(next())
+        else -> literal()
+    }
+
+    private fun array(): JSONArray {
+        val result = JSONArray()
+        if (peek() == ']') { at++; return result }
+        while (true) {
+            result.put(nextValue())
+            when (peek().also { at++ }) {
+                ']' -> return result
+                ',', ';' -> continue
+                else -> throw JSONException("Unterminated array at character $at of $text")
+            }
+        }
+    }
+
+    private fun objectValue(): JSONObject {
+        val result = JSONObject()
+        if (peek() == '}') { at++; return result }
+        while (true) {
+            val name = nextValue() as? String ?: throw JSONException("Names must be strings at character $at of $text")
+            if (peek() != ':' && text[at] != '=') throw JSONException("Expected ':' after $name at character $at of $text")
+            at++
+            if (text.getOrNull(at) == '>') at++
+            result.put(name, nextValue())
+            when (peek().also { at++ }) {
+                '}' -> return result
+                ',', ';' -> continue
+                else -> throw JSONException("Unterminated object at character $at of $text")
+            }
+        }
+    }
+
+    private fun string(quote: Char): String {
+        val out = StringBuilder()
+        while (true) {
+            val c = next()
+            if (c == quote) return out.toString()
+            if (c != '\\') { out.append(c); continue }
+            when (val escaped = next()) {
+                'u' -> {
+                    if (at + 4 > text.length) throw JSONException("Unterminated escape sequence at character $at of $text")
+                    out.append(text.substring(at, at + 4).toInt(16).toChar())
+                    at += 4
+                }
+                't' -> out.append('\t')
+                'b' -> out.append('\b')
+                'n' -> out.append('\n')
+                'r' -> out.append('\r')
+                'f' -> out.append('\u000c')
+                else -> out.append(escaped)
+            }
+        }
+    }
+
+    private fun literal(): Any {
+        val start = at
+        while (at < text.length && text[at] !in "\r\n\t ,:#/\\;=[]{}\"'") at++
+        val word = text.substring(start, at)
+        if (word.isEmpty()) throw JSONException("Expected literal value at character $at of $text")
+        when (word.lowercase()) {
+            "null" -> return JSONObject.NULL
+            "true" -> return true
+            "false" -> return false
+        }
+        if (word.none { it == '.' || it == 'e' || it == 'E' }) {
+            val long = word.toLongOrNull()
+            if (long != null) return if (long in Int.MIN_VALUE..Int.MAX_VALUE) long.toInt() else long
+        }
+        return word.toDoubleOrNull() ?: word
+    }
+}
+
+private fun quote(value: String, out: StringBuilder) {
+    out.append('"')
+    for (c in value) {
+        when (c) {
+            '"', '\\', '/' -> out.append('\\').append(c)
+            '\t' -> out.append("\\t")
+            '\b' -> out.append("\\b")
+            '\n' -> out.append("\\n")
+            '\r' -> out.append("\\r")
+            '\u000c' -> out.append("\\f")
+            else -> if (c.code <= 0x1f) out.append("\\u").append(c.code.toString(16).padStart(4, '0')) else out.append(c)
+        }
+    }
+    out.append('"')
+}
+
+private fun numberToString(number: Number): String {
+    val double = number.toDouble()
+    if (double.isNaN() || double.isInfinite()) throw JSONException("Forbidden numeric value: $number")
+    if (double == 0.0 && 1.0 / double < 0) return "-0"
+    val long = number.toLong()
+    if (double == long.toDouble()) return long.toString()
+    return number.toString()
+}
+
+private fun write(value: Any?, out: StringBuilder) {
+    when (value) {
+        null, JSONObject.NULL -> out.append("null")
+        is String -> quote(value, out)
+        is Boolean -> out.append(value)
+        is Number -> out.append(numberToString(value))
+        is JSONArray -> value.writeTo(out)
+        is JSONObject -> value.writeTo(out)
+        else -> quote(value.toString(), out)
+    }
+}
+
+class JSONArray() {
+    private val values = ArrayList<Any?>()
+
+    constructor(json: String) : this() {
+        val parsed = JSONTokener(json).nextValue()
+        if (parsed !is JSONArray) throw JSONException("Value $json of type ${parsed::class.simpleName} cannot be converted to JSONArray")
+        values.addAll(parsed.values)
+    }
+
+    constructor(collection: Collection<*>) : this() {
+        for (item in collection) values.add(JSONObject.wrap(item))
+    }
+
+    fun length(): Int = values.size
+
+    fun opt(index: Int): Any? = values.getOrNull(index)
+
+    fun get(index: Int): Any {
+        if (index < 0 || index >= values.size) throw JSONException("Index $index out of range [0..${values.size})")
+        return values[index] ?: throw JSONException("Value at $index is null.")
+    }
+
+    fun put(value: Any?): JSONArray {
+        values.add(value)
+        return this
+    }
+
+    internal fun writeTo(out: StringBuilder) {
+        out.append('[')
+        values.forEachIndexed { index, value ->
+            if (index > 0) out.append(',')
+            write(value, out)
+        }
+        out.append(']')
+    }
+
+    override fun toString(): String = StringBuilder().also { writeTo(it) }.toString()
+}
+
+class JSONObject() {
+    private val fields = LinkedHashMap<String, Any?>()
+
+    constructor(json: String) : this() {
+        val parsed = JSONTokener(json).nextValue()
+        if (parsed !is JSONObject) throw JSONException("Value $json of type ${parsed::class.simpleName} cannot be converted to JSONObject")
+        fields.putAll(parsed.fields)
+    }
+
+    constructor(map: Map<*, *>) : this() {
+        for ((key, value) in map) fields[key as? String ?: throw NullPointerException("key == null")] = wrap(value)
+    }
+
+    fun length(): Int = fields.size
+
+    fun has(name: String): Boolean = fields.containsKey(name)
+
+    fun opt(name: String): Any? = fields[name]
+
+    fun get(name: String): Any = fields[name] ?: throw JSONException("No value for $name")
+
+    fun put(name: String, value: Any?): JSONObject {
+        if (value == null) fields.remove(name) else {
+            if (value is Number) numberToString(value)
+            fields[name] = value
+        }
+        return this
+    }
+
+    fun keys(): Iterator<String> = fields.keys.iterator()
+
+    internal fun writeTo(out: StringBuilder) {
+        out.append('{')
+        var first = true
+        for ((key, value) in fields) {
+            if (!first) out.append(',')
+            first = false
+            quote(key, out)
+            out.append(':')
+            write(value, out)
+        }
+        out.append('}')
+    }
+
+    override fun toString(): String = StringBuilder().also { writeTo(it) }.toString()
+
+    companion object {
+        val NULL: Any = object {
+            override fun equals(other: Any?): Boolean = other == null || other === this
+            override fun hashCode(): Int = 0
+            override fun toString(): String = "null"
+        }
+
+        fun wrap(value: Any?): Any? = when (value) {
+            null -> NULL
+            is JSONArray, is JSONObject, NULL -> value
+            is Collection<*> -> JSONArray(value)
+            is Array<*> -> JSONArray(value.toList())
+            is Map<*, *> -> JSONObject(value)
+            is Boolean, is Byte, is Char, is Double, is Float, is Int, is Long, is Short, is String -> value
+            else -> null
+        }
+    }
+}

package/kotlin/toolchain.json

@@ -0,0 +1,19 @@
+{
+  "compiler": {
+    "version": "2.4.20",
+    "url": "https://github.com/JetBrains/kotlin/releases/download/v2.4.20/kotlin-compiler-2.4.20.zip",
+    "sha256": "59e9ca74c7904ef2c122b12114937673ccce68de820a663f0ed66ccf8799e0b7"
+  },
+  "libraries": [
+    {
+      "name": "kotlinx-coroutines-core-wasm-js-1.11.0.klib",
+      "url": "https://repo1.maven.org/maven2/org/jetbrains/kotlinx/kotlinx-coroutines-core-wasm-js/1.11.0/kotlinx-coroutines-core-wasm-js-1.11.0.klib",
+      "sha256": "1280b9f74850a4892a3641efa2a5779e5423b84aa7077cc60ddd50decbab921f"
+    },
+    {
+      "name": "atomicfu-wasm-js-0.32.1.klib",
+      "url": "https://repo1.maven.org/maven2/org/jetbrains/kotlinx/atomicfu-wasm-js/0.32.1/atomicfu-wasm-js-0.32.1.klib",
+      "sha256": "1bdc5a5216944b8f9a396d2f0c7df320b43d6921725baad1afc04cc8e2ae48e3"
+    }
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peachsim",
-  "version": "0.1.577",
+  "version": "0.1.579",
   "description": "Vite and Metro plugins, testing drivers, and SDK exports for peach.",
   "author": "Tamagui LLC",
   "license": "SEE LICENSE IN LICENSE",
@@ -30,7 +30,7 @@
       "default": "./dist-lib/auth/shared-session.cjs"
     },
     "./vite": {
-      "types": "./src/vite-plugin-one.ts",
+      "types": "./src/vite.d.ts",
       "source": "./src/vite-plugin-one.ts",
       "default": "./dist-lib/vite.cjs"
     },
@@ -39,6 +39,16 @@
       "source": "./src/swift.ts",
       "default": "./dist-lib/swift.cjs"
     },
+    "./vite-swift": {
+      "types": "./src/vite-plugin-swift.ts",
+      "source": "./src/vite-plugin-swift.ts",
+      "default": "./dist-lib/vite-swift.cjs"
+    },
+    "./vite-kotlin": {
+      "types": "./src/vite-plugin-kotlin.ts",
+      "source": "./src/vite-plugin-kotlin.ts",
+      "default": "./dist-lib/vite-kotlin.cjs"
+    },
     "./swift-submit": {
       "types": "./src/swift-submit.ts",
       "source": "./src/swift-submit.ts",
@@ -260,6 +270,7 @@
     "dist-lib/",
     "src/",
     "cli/",
+    "kotlin/",
     "skills/",
     "scripts/dev-server-scanner.ts",
     "scripts/optional-demo-registry.ts",
@@ -283,6 +294,7 @@
     "oxc-parser": "^0.112.0",
     "playwright-core": "1.61.0",
     "sucrase": "3.35.1",
+    "svgpath": "2.6.0",
     "terser": "^5.49.0",
     "ws": "^8.18.0"
   },

package/scripts/dev-server-scanner.ts

@@ -707,22 +707,6 @@ function applyManifest(
   return result
 }
 
-export function __applyManifestForTests(
-  result: DiscoveredServer,
-  manifestBody: string,
-  buildIconProxyUrl?: (externalUrl: string) => string,
-): DiscoveredServer {
-  return applyManifest(
-    result,
-    {
-      statusCode: 200,
-      body: manifestBody,
-      hostname: new URL(result.bundleUrl).hostname,
-    },
-    buildIconProxyUrl,
-  )
-}
-
 // ── name/icon enrichment ────────────────────────────────────────────────────
 // a server's display name + icon come ONLY from its expo manifest (GET / with
 // expo-platform), which is far slower than the cheap signature probes: One apps
@@ -1115,8 +1099,6 @@ function isSootSimSelfServer(server: DiscoveredServer): boolean {
   return false
 }
 
-export const __isSootSimSelfServerForTests = isSootSimSelfServer
-
 // per-(port, pid) probe cache. as long as the same process still owns the
 // port, its signature endpoints can't have changed, so we return the cached
 // result without issuing any HTTP. negative results (null) are cached too,

package/scripts/optional-demo-registry.ts

@@ -94,20 +94,3 @@ export async function loadOptionalDemoApps(): Promise<OptionalDemoApp[]> {
 export function optionalDemoAppsSync(): OptionalDemoApp[] {
   return cached ?? []
 }
-
-/** replace the registry with a fixed list, and restore it on the returned
- *  handle. what the real registry holds depends on which third-party app
- *  checkouts and credential files happen to exist on the machine, so a test
- *  that reads it asserts on the developer's home directory rather than on the
- *  code. it passes on the box that has them and fails everywhere else. */
-export function __withOptionalDemoAppsForTests(apps: OptionalDemoApp[]): {
-  restore: () => void
-} {
-  const previous = cached
-  cached = apps
-  return {
-    restore: () => {
-      cached = previous
-    },
-  }
-}

package/skills/contrast/SKILL.md

@@ -9,7 +9,7 @@ description: >-
 
 overview of all available skills and CLI commands in this repo.
 
-> this file is auto-generated by `bun scripts/generate-contrast-skill.ts`.
+> this file is auto-generated by `bun scripts/generate/contrast-skill.ts`.
 > to update, edit the source registries and re-run the generator.
 
 ## Peach CLI commands
@@ -50,7 +50,7 @@ automation, inspecting the render tree, and managing sims.
 | `peach use` | select a connected sim |
 | `peach skill` | install and inspect bundled peach agent skills |
 | `peach claim` | take an exclusive lease on a sim |
-| `peach agent` | attached projects + local agent sessions (codex/claude) |
+| `peach agent` | inspect messages, attached projects, and local agent sessions |
 | `peach close` | close a connected sim |
 | `peach setup` | configure optional local conveniences |
 | `peach compat` | check package compatibility |

package/skills/peach-setup/SKILL.md

@@ -5,6 +5,22 @@ description: Get Peach connected to your React Native app with no project setup
 
 # Peach setup
 
+## receive inspect messages
+
+after opening and pinning a sim, run this whenever you finish a turn and can
+accept feedback from the simulator:
+
+```sh
+peach agent listen
+```
+
+it returns one pending inspect message immediately, or waits for the next one,
+then exits. handle the request and run it again. the printed context is meant
+to be sufficient for the usual edit. only open the saved `describe.txt` when
+you need more screen context, `inspect.json` for exact inspect data, or the
+screenshot when color, clipping, spacing, or another visual detail matters.
+`peach agent info <message-id>` prints the complete message and artifact paths.
+
 you want to drive a React Native app with Peach from the CLI. this skill
 takes you from a running development server to a connected, pinned sim that
 every other Peach skill assumes exists. Peach requires no project setup or per-app

package/src/agent-daemon-client.ts

@@ -17,7 +17,11 @@ import { resolveSootsimInvocation, type Provider } from './agent-sessions.ts'
 import { DEFAULT_SOOTSIM_BRIDGE_PORT } from './bridge-constants.ts'
 import { shouldSkipPersistentDaemon } from './home-paths.ts'
 import type { AgentEvent } from './agent-events.ts'
-import type { AgentPromptEnvelope } from './agent-prompt.ts'
+import type {
+  AgentInspectListenerStatus,
+  AgentInspectMessage,
+  AgentPromptEnvelope,
+} from './agent-prompt.ts'
 import type { AgentSession, AttachedProject } from './attached-projects.ts'
 
 export interface AgentDaemonClientOptions {
@@ -74,7 +78,7 @@ export class AgentDaemonError extends Error {
 type PendingEntry = {
   resolve: (value: unknown) => void
   reject: (err: Error) => void
-  timer: ReturnType<typeof setTimeout>
+  timer: ReturnType<typeof setTimeout> | null
 }
 
 type EventCallback = (payload: { sessionId: string; event: AgentEvent }) => void
@@ -165,16 +169,23 @@ export class AgentDaemonClient {
     })
   }
 
-  async sendClaimedPrompt(
+  async listenForInspect(simId: string): Promise<AgentInspectMessage> {
+    return this.send<AgentInspectMessage>('agent:listen-inspect', { simId })
+  }
+
+  async getInspectListenerStatus(simId: string): Promise<AgentInspectListenerStatus> {
+    return this.send<AgentInspectListenerStatus>('agent:get-inspect-listener-status', {
+      simId,
+    })
+  }
+
+  async sendInspectMessage(
     simId: string,
     prompt: AgentPromptEnvelope,
-  ): Promise<{ ok: true; routed: 'team-machine'; sessionId: string }> {
-    return this.send<{ ok: true; routed: 'team-machine'; sessionId: string }>(
-      'agent:send-claimed-prompt',
-      {
-        simId,
-        prompt,
-      },
+  ): Promise<{ ok: true; queued: boolean; messageId: string }> {
+    return this.send<{ ok: true; queued: boolean; messageId: string }>(
+      'agent:send-inspect-message',
+      { simId, prompt },
     )
   }
 
@@ -238,15 +249,18 @@ export class AgentDaemonClient {
     }
     const id = this.nextId++
     return new Promise<T>((resolve, reject) => {
-      const timer = setTimeout(() => {
-        this.pending.delete(id)
-        reject(
-          new AgentDaemonError(
-            `${type} timed out after ${Math.round(this.commandTimeoutMs / 1000)}s`,
-            'TIMEOUT',
-          ),
-        )
-      }, this.commandTimeoutMs)
+      const timer =
+        this.commandTimeoutMs > 0
+          ? setTimeout(() => {
+              this.pending.delete(id)
+              reject(
+                new AgentDaemonError(
+                  `${type} timed out after ${Math.round(this.commandTimeoutMs / 1000)}s`,
+                  'TIMEOUT',
+                ),
+              )
+            }, this.commandTimeoutMs)
+          : null
       this.pending.set(id, {
         resolve: resolve as (value: unknown) => void,
         reject,
@@ -255,7 +269,7 @@ export class AgentDaemonClient {
       try {
         this.ws.send(JSON.stringify({ id, type, ...payload }))
       } catch (err) {
-        clearTimeout(timer)
+        if (timer) clearTimeout(timer)
         this.pending.delete(id)
         reject(err instanceof Error ? err : new Error(String(err)))
       }
@@ -293,7 +307,7 @@ export class AgentDaemonClient {
     const entry = this.pending.get(msg.id)
     if (!entry) return
     this.pending.delete(msg.id)
-    clearTimeout(entry.timer)
+    if (entry.timer) clearTimeout(entry.timer)
     if (msg.error) {
       entry.reject(new AgentDaemonError(msg.error, msg.code))
     } else {
@@ -305,7 +319,7 @@ export class AgentDaemonClient {
     if (this.closed) return
     this.closed = true
     for (const [, entry] of this.pending) {
-      clearTimeout(entry.timer)
+      if (entry.timer) clearTimeout(entry.timer)
       entry.reject(new AgentDaemonError('daemon disconnected', 'DISCONNECT'))
     }
     this.pending.clear()

package/src/agent-identity.ts

@@ -1,5 +1,3 @@
-const TEAM_MACHINE_SESSION_RE = /^[A-Za-z0-9._:-]{1,160}$/
-
 export function agentSessionIdFromCliIdentity(identity: string | null): string | null {
   if (!identity) return null
   const colon = identity.indexOf(':')
@@ -8,16 +6,3 @@ export function agentSessionIdFromCliIdentity(identity: string | null): string |
   const value = identity.slice(colon + 1).trim()
   return source === 'PEACH_CLI_IDENTITY' && value ? value : null
 }
-
-export function teamMachineSessionIdFromCliIdentity(
-  identity: string | null,
-): string | null {
-  if (!identity?.startsWith('TM_SESSION:')) return null
-  const sessionId = identity.slice('TM_SESSION:'.length).trim()
-  if (!TEAM_MACHINE_SESSION_RE.test(sessionId)) return null
-  return sessionId
-}
-
-export function isValidTeamMachineSessionId(sessionId: string): boolean {
-  return TEAM_MACHINE_SESSION_RE.test(sessionId)
-}

package/src/agent-prompt.ts

@@ -5,6 +5,18 @@ export interface AgentPromptEnvelope {
   inspectTrace?: string
 }
 
+export interface AgentInspectMessage {
+  id: string
+  simId: string
+  createdAt: string
+  prompt: AgentPromptEnvelope
+}
+
+export interface AgentInspectListenerStatus {
+  simId: string
+  listening: boolean
+}
+
 const ENVELOPE_MARKER = 'sootsim-agent-prompt-v1'
 
 function cleanPromptText(value: string | undefined): string {