peachsim 0.1.577 → 0.1.579

package/cli/cloud-client.ts

@@ -62,6 +62,7 @@ import type {
   ParsedBridgeCliArgs,
   WsBridge,
 } from './ws-bridge.ts'
+import { isRecord } from '../src/is-record'
 
 export const DEFAULT_RNX_CLOUD_ORIGIN = rnxPublicBrand.origin
 export const MAX_RNX_CLOUD_BUNDLE_BYTES = RNX_CLOUD_MAX_ARTIFACT_BYTES
@@ -115,10 +116,6 @@ interface CloudCommandEnvelope {
   command: Record<string, unknown>
 }
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === 'object' && !Array.isArray(value)
-}
-
 // three services answer this client and each states a failure its own way:
 // the box service says { error: '<sentence>' }, the site's public api says
 // { error: '<code>', message: '<sentence>' }, and its service-to-service api

package/cli/cloud-session.ts

@@ -1,5 +1,6 @@
 import { fstatSync, writeSync } from 'node:fs'
 import { isLoopbackHost } from '../src/backend-origin.ts'
+import { isRecord } from '../src/is-record'
 
 const CLOUD_SESSION_VERSION = 3 as const
 const SHELL_UPDATE_FD_ENV = 'PEACH_SHELL_UPDATE_FD'
@@ -61,10 +62,6 @@ export interface CloudBoxSession {
   artifact?: CloudSessionArtifactIdentity
 }
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === 'object' && !Array.isArray(value)
-}
-
 export function normalizeCloudOrigin(source: string): string {
   let parsed: URL
   try {

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

@@ -18,6 +18,8 @@ export interface CloudTestFlowResult {
   previewId: string | null
   previewUrl: string | null
   runId: string | null
+  // the step a failed flow stopped on and why, or null
+  failure: string | null
 }
 
 // every file one flow's ids land in: the bare file always (last flow wins,
@@ -77,6 +79,7 @@ export function collectCloudTestFlowResults(
         stringField(preview, 'previewUrl') ??
         (previewId ? `${cloudOrigin.replace(/\/$/, '')}/preview/${previewId}` : null),
       runId: stringField(test, 'runId'),
+      failure: stringField(preview, 'failure'),
     }
   }
   let numbered: number[] = []

package/cli/cloud-test-tunnel.ts

@@ -4,7 +4,7 @@
 // bundle, the submitter publishes that stack through a token-gated
 // cloudflared quick tunnel and submits the tunnel origin plus the mode-2
 // fields (hostHeader, jobToken, sidecarPorts). the recorder projects the
-// origin back to loopback (scripts/runner/sootsim-recorder.ts), so flows
+// origin back to loopback (scripts/runner/peach-recorder.ts), so flows
 // keep their unmodified localhost authorities.
 //
 // the handshake mirrors packages/contrast-runner/src/hosted.ts, which this
@@ -26,6 +26,7 @@ import {
 import { createServer, request as httpRequest } from 'node:http'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
+import { sleep } from '../src/sleep'
 
 // must match packages/contrast-runner/src/hostedPorts.ts.
 const UPSTREAM_PORT_HEADER = 'x-contrast-upstream-port'
@@ -222,10 +223,6 @@ async function ensureCloudflared(): Promise<boolean> {
   return cloudflaredAvailable()
 }
 
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms))
-}
-
 function childAlive(child: ChildProcess): boolean {
   return child.exitCode === null && child.signalCode === null
 }

package/cli/command-registry.ts

@@ -123,6 +123,8 @@ const VALUE_FLAGS = new Set([
   '-p',
   '--timeout',
   '--device',
+  '--posture',
+  '--os-version',
   '--output',
   '-o',
   '--out',

package/cli/commands/agent.ts

@@ -12,21 +12,14 @@
 // wrapper is live.
 
 import fs from 'node:fs'
+import os from 'node:os'
 import path from 'node:path'
 import {
   AgentDaemonError,
   connectToDaemon,
   type AgentDaemonClient,
 } from '../../src/agent-daemon-client'
-import { parseAgentEventLine, type AgentEvent } from '../../src/agent-events'
-import {
-  eventsFifoPath,
-  pidIsAlive,
-  promptFifoPath,
-  sessionDir,
-  transcriptPath,
-  type Provider,
-} from '../../src/agent-sessions'
+import { pidIsAlive, transcriptPath, type Provider } from '../../src/agent-sessions'
 import {
   costThisWeek,
   deleteProject,
@@ -35,11 +28,13 @@ import {
   listProjects,
   listSessions,
   upsertProject,
-  type AgentSession,
-  type AttachedProject,
 } from '../../src/attached-projects'
+import { readCurrentSimId } from '../current-sim'
 import { printCommandHelp } from '../help'
-import { resolveDefaultBridgePort } from '../ws-bridge'
+import { createBridge, resolveDefaultBridgePort } from '../ws-bridge'
+import { inspectDescribe } from './inspect/core'
+import type { AgentEvent } from '../../src/agent-events'
+import type { AgentInspectMessage } from '../../src/agent-prompt'
 
 // the bridge this invocation talks to: `-p`, else the same dev-bridge or
 // daemon pick every other command makes (PORT_OFFSET and SOOTSIM_BRIDGE_PORT
@@ -74,6 +69,10 @@ export async function runAgentCommand(
         return await cmdPrompt(rest)
       case 'watch':
         return await cmdWatch(rest)
+      case 'listen':
+        return await cmdListen(rest)
+      case 'info':
+        return await cmdInfo(rest)
       case 'transcript':
         return await cmdTranscript(rest)
       case 'end':
@@ -342,6 +341,144 @@ async function cmdWatch(argv: string[]): Promise<number> {
   return exit
 }
 
+async function cmdListen(argv: string[]): Promise<number> {
+  const { flags } = parseFlags(argv, { '--sim': 'value' })
+  const simId = ((flags['--sim'] as string) || readCurrentSimId() || '').trim()
+  if (!simId) {
+    process.stderr.write('no current sim. run `peach use <id>` or pass `--sim <id>`.\n')
+    return 1
+  }
+  const client = await connectToDaemon({
+    port: daemonPort,
+    commandTimeoutMs: 0,
+    clientLabel: 'peach-agent-listen',
+  })
+  try {
+    const message = await client.listenForInspect(simId)
+    const artifacts = await saveInspectArtifacts(message)
+    printInspectMessage(message, artifacts)
+    return 0
+  } finally {
+    client.close()
+  }
+}
+
+async function saveInspectArtifacts(message: AgentInspectMessage): Promise<{
+  inspectPath: string
+  describePath: string
+  screenshotPath: string | null
+}> {
+  const dir = path.join(os.tmpdir(), 'peach-inspect', message.id)
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 })
+  const inspectPath = path.join(dir, 'inspect.json')
+  const describePath = path.join(dir, 'describe.txt')
+  const screenshotPath = path.join(dir, 'screenshot.png')
+  fs.writeFileSync(inspectPath, JSON.stringify(message, null, 2) + '\n', {
+    mode: 0o600,
+  })
+
+  const bridge = createBridge(daemonPort, {
+    commandTimeoutMs: 15_000,
+    simId: message.simId,
+  })
+  let savedScreenshot: string | null = null
+  try {
+    try {
+      const described = await inspectDescribe(bridge, {
+        describe: true,
+        verbose: false,
+        filter: '',
+        compact: false,
+        hideXy: false,
+        fullText: true,
+      })
+      fs.writeFileSync(describePath, described.tree ?? 'no visible nodes\n', {
+        mode: 0o600,
+      })
+    } catch (error) {
+      fs.writeFileSync(
+        describePath,
+        `describe unavailable: ${error instanceof Error ? error.message : String(error)}\n`,
+        { mode: 0o600 },
+      )
+    }
+    try {
+      const dataUrl: unknown = await bridge.send({ type: 'screenshot' })
+      const prefix = 'data:image/png;base64,'
+      if (typeof dataUrl === 'string' && dataUrl.startsWith(prefix)) {
+        fs.writeFileSync(
+          screenshotPath,
+          Buffer.from(dataUrl.slice(prefix.length), 'base64'),
+          {
+            mode: 0o600,
+          },
+        )
+        savedScreenshot = screenshotPath
+      }
+    } catch {}
+  } finally {
+    bridge.close()
+  }
+  return { inspectPath, describePath, screenshotPath: savedScreenshot }
+}
+
+function printInspectMessage(
+  message: AgentInspectMessage,
+  artifacts: { inspectPath: string; describePath: string; screenshotPath: string | null },
+): void {
+  const request = message.prompt.displayText ?? message.prompt.text
+  const context = [
+    ...(message.prompt.inspectSummary?.split('\n') ?? []),
+    ...(message.prompt.inspectTrace?.split('\n') ?? []),
+  ]
+    .map((line) => line.trim())
+    .filter((line, index, lines) => line && lines.indexOf(line) === index)
+    .slice(0, 4)
+  const lines = [
+    `PEACH INSPECT ${message.id}`,
+    `Request: ${request}`,
+    `Sim: ${message.simId}`,
+    ...context.map((line, index) => `${index === 0 ? 'Target' : 'Context'}: ${line}`),
+    `Describe: ${artifacts.describePath}`,
+    `Inspect: ${artifacts.inspectPath}`,
+    ...(artifacts.screenshotPath ? [`Screenshot: ${artifacts.screenshotPath}`] : []),
+    `More: peach agent info ${message.id}`,
+  ]
+  process.stdout.write(lines.join('\n') + '\n')
+}
+
+async function cmdInfo(argv: string[]): Promise<number> {
+  const messageId = argv[0]?.trim() ?? ''
+  if (!/^inspect-[a-f0-9-]+$/.test(messageId)) {
+    process.stderr.write('usage: peach agent info <message-id>\n')
+    return 2
+  }
+  const dir = path.join(os.tmpdir(), 'peach-inspect', messageId)
+  const inspectPath = path.join(dir, 'inspect.json')
+  if (!fs.existsSync(inspectPath)) {
+    process.stderr.write(`inspect message not found: ${messageId}\n`)
+    return 1
+  }
+  const message: unknown = JSON.parse(fs.readFileSync(inspectPath, 'utf8'))
+  process.stdout.write(
+    JSON.stringify(
+      {
+        message,
+        artifacts: {
+          inspect: inspectPath,
+          describe: path.join(dir, 'describe.txt'),
+          screenshot: fs.existsSync(path.join(dir, 'screenshot.png'))
+            ? path.join(dir, 'screenshot.png')
+            : null,
+        },
+      },
+      null,
+      2,
+    ) + '\n',
+  )
+  return 0
+}
+
 function formatEvent(ev: AgentEvent): string {
   const ts = fmtTs(ev.ts)
   switch (ev.type) {
@@ -426,14 +563,3 @@ function shortId(id: string): string {
 function fmtTs(ts: number): string {
   return new Date(ts).toISOString().replace('T', ' ').slice(0, 19)
 }
-
-// keep these importable for the legacy e2e script paths — the canonical
-// source of truth is now `sootsim/agent-sessions`.
-export const __internals = {
-  sessionDir,
-  promptFifoPath,
-  eventsFifoPath,
-  transcriptPath,
-  parseAgentEventLine,
-}
-export type { AgentSession, AttachedProject }

package/cli/commands/assert.ts

@@ -14,6 +14,7 @@
 //   2   misuse — bad flags, unknown verb    (treated as bad by bisect)
 
 import { spawn } from 'child_process'
+import { sleep } from '../../src/sleep'
 import { rnxExit } from '../run-rnx'
 import { rnxSelfInvocation } from '../self-invocation'
 
@@ -496,10 +497,6 @@ export async function runAssert(rawArgs: string[]): Promise<void> {
   }
 }
 
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms))
-}
-
 function printHelp(): void {
   process.stdout.write(`
 peach assert — run any read verb and convert its output into a bisect-friendly exit code.

package/cli/commands/box/peach-command.ts

@@ -0,0 +1,62 @@
+// peach operations registered as just-bash commands.
+//
+// `peach` inside a box shell is the same CLI, re-invoked as a child process with
+// the shell's own cwd. that is deliberate — spelling the verbs a second time
+// in shell-command form would be a second implementation of every command, and
+// the spec is explicit that the CLI and the in-shell commands are clients of
+// one implementation, not two.
+
+import { spawn } from 'node:child_process'
+import path from 'node:path'
+import { defineCommand, type CustomCommand } from '@peach/box/shell'
+import { PROJECT_MOUNT } from '@peach/box/shell'
+import { peachPublicBrand } from '../../../src/public-brand'
+import { rnxSelfInvocation } from '../../self-invocation'
+import { PEACH_PLACEMENT_ENV } from '../../ws-bridge'
+
+// map a shell path under /project back onto the real checkout, so a child
+// process started from `cd src && peach describe` sees the directory the user
+// is actually standing in.
+function hostCwd(root: string, shellCwd: string): string {
+  if (shellCwd === PROJECT_MOUNT) return root
+  if (!shellCwd.startsWith(`${PROJECT_MOUNT}/`)) return root
+  return path.join(root, shellCwd.slice(PROJECT_MOUNT.length + 1))
+}
+
+export function createPeachCommand(options: {
+  root: string
+  shellCwd: () => string
+}): CustomCommand {
+  return defineCommand(peachPublicBrand.commandName, async (args) => {
+    const { executable, prefixArgs } = rnxSelfInvocation()
+    const child = spawn(executable, [...prefixArgs, ...args], {
+      cwd: hostCwd(options.root, options.shellCwd()),
+      // mark the child as running inside a local box. this is the only thing
+      // that sets a placement — nothing infers one from cwd — and it is what
+      // lets `peach box` refuse to nest inside itself.
+      env: { ...process.env, [PEACH_PLACEMENT_ENV]: 'local-box' },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    })
+
+    let stdout = ''
+    let stderr = ''
+    child.stdout.on('data', (chunk) => {
+      stdout += String(chunk)
+    })
+    child.stderr.on('data', (chunk) => {
+      stderr += String(chunk)
+    })
+
+    const exitCode = await new Promise<number>((resolve) => {
+      child.once('error', (error) => {
+        stderr += `${peachPublicBrand.commandName}: ${error.message}\n`
+        resolve(1)
+      })
+      child.once('close', (code) => resolve(code ?? 0))
+    })
+
+    return { stdout, stderr, exitCode }
+  })
+}
+
+export const createRnxCommand = createPeachCommand

package/cli/commands/box/plane-share.ts

@@ -136,73 +136,3 @@ export function sharePlane(root: string, opts: { port?: number } = {}): PlaneSha
     },
   }
 }
-
-/**
- * How many boxes hold `root` right now, without registering anything.
- *
- * `plane:register` cannot answer this: registering is what makes a root
- * reachable over a loopback socket, so a readiness probe that asked with it
- * would both authorize the root and count itself in the answer.
- */
-export async function planeStatus(
-  root: string,
-  opts: { port?: number } = {},
-): Promise<{ holders: number; registered: boolean } | { declined: string }> {
-  const chosen = target(opts.port)
-  if ('declined' in chosen) return chosen
-  const port = chosen.port
-
-  return new Promise((resolve) => {
-    let done = false
-    let socket: WebSocket | null = null
-    const finish = (
-      value: { holders: number; registered: boolean } | { declined: string },
-    ) => {
-      if (done) return
-      done = true
-      clearTimeout(timer)
-      try {
-        socket?.close()
-      } catch {}
-      resolve(value)
-    }
-    const timer = setTimeout(
-      () => finish({ declined: `bridge on port ${port} did not answer plane:status` }),
-      REGISTER_TIMEOUT_MS,
-    )
-
-    try {
-      socket = new WebSocket(bridgeWsUrl(port))
-    } catch (error) {
-      finish({ declined: error instanceof Error ? error.message : String(error) })
-      return
-    }
-    socket.on('error', (error) => finish({ declined: error.message }))
-    socket.on('close', () => finish({ declined: `bridge on port ${port} closed` }))
-    socket.on('open', () => {
-      socket?.send(JSON.stringify({ type: 'plane:status', id: 'status', root }))
-    })
-    socket.on('message', (data) => {
-      let parsed: unknown
-      try {
-        parsed = JSON.parse(String(data))
-      } catch {
-        return
-      }
-      if (typeof parsed !== 'object' || parsed === null) return
-      const reply: Record<string, unknown> = { ...parsed }
-      if (reply.id !== 'status') return
-      if (reply.error) {
-        finish({ declined: String(reply.error) })
-        return
-      }
-      // the daemon nests its payload under `result`, the same shape
-      // plane:register answers in.
-      const result = (reply.result ?? {}) as Record<string, unknown>
-      finish({
-        holders: Number(result.holders ?? 0),
-        registered: Boolean(result.registered),
-      })
-    })
-  })
-}

package/cli/commands/box/rnx-command.ts

@@ -1,60 +1 @@
-// step 4: RNX operations registered as just-bash commands.
-//
-// `peach` inside a box shell is the same CLI, re-invoked as a child process with
-// the shell's own cwd. that is deliberate — spelling the verbs a second time
-// in shell-command form would be a second implementation of every command, and
-// the spec is explicit that the CLI and the in-shell commands are clients of
-// one implementation, not two.
-
-import { spawn } from 'node:child_process'
-import path from 'node:path'
-import { defineCommand, type CustomCommand } from '@peach/box/shell'
-import { PROJECT_MOUNT } from '@peach/box/shell'
-import { rnxPublicBrand } from '../../../src/public-brand'
-import { rnxSelfInvocation } from '../../self-invocation'
-import { PEACH_PLACEMENT_ENV } from '../../ws-bridge'
-
-// map a shell path under /project back onto the real checkout, so a child
-// process started from `cd src && peach describe` sees the directory the user
-// is actually standing in.
-function hostCwd(root: string, shellCwd: string): string {
-  if (shellCwd === PROJECT_MOUNT) return root
-  if (!shellCwd.startsWith(`${PROJECT_MOUNT}/`)) return root
-  return path.join(root, shellCwd.slice(PROJECT_MOUNT.length + 1))
-}
-
-export function createRnxCommand(options: {
-  root: string
-  shellCwd: () => string
-}): CustomCommand {
-  return defineCommand(rnxPublicBrand.commandName, async (args) => {
-    const { executable, prefixArgs } = rnxSelfInvocation()
-    const child = spawn(executable, [...prefixArgs, ...args], {
-      cwd: hostCwd(options.root, options.shellCwd()),
-      // mark the child as running inside a local box. this is the only thing
-      // that sets a placement — nothing infers one from cwd — and it is what
-      // lets `peach box` refuse to nest inside itself.
-      env: { ...process.env, [PEACH_PLACEMENT_ENV]: 'local-box' },
-      stdio: ['ignore', 'pipe', 'pipe'],
-    })
-
-    let stdout = ''
-    let stderr = ''
-    child.stdout.on('data', (chunk) => {
-      stdout += String(chunk)
-    })
-    child.stderr.on('data', (chunk) => {
-      stderr += String(chunk)
-    })
-
-    const exitCode = await new Promise<number>((resolve) => {
-      child.once('error', (error) => {
-        stderr += `${rnxPublicBrand.commandName}: ${error.message}\n`
-        resolve(1)
-      })
-      child.once('close', (code) => resolve(code ?? 0))
-    })
-
-    return { stdout, stderr, exitCode }
-  })
-}
+export { createPeachCommand, createRnxCommand } from './peach-command'

package/cli/commands/box/search-command.ts

@@ -103,6 +103,19 @@ const FLAG_MAP: Record<string, string> = {
   '--fixed-strings': '-F',
 }
 
+// presentational no-ops, accepted without effect because they match the output
+// by construction: it never prints headings, always numbers lines, and never
+// emits color. refusing them burned a wave turn on `rg -n x --no-heading`.
+// --no-line-number is deliberately absent: the output is numbered, so it
+// contradicts the output and stays refused like every semantic flag.
+const NOOP_FLAGS = new Set([
+  '--no-heading',
+  '--heading',
+  '--color',
+  '-n',
+  '--line-number',
+])
+
 export function createSearchCommand(options: { root: string }): CustomCommand {
   return defineCommand('rg', async (args) => {
     const flags: string[] = []
@@ -112,6 +125,7 @@ export function createSearchCommand(options: { root: string }): CustomCommand {
         bare.push(arg)
         continue
       }
+      if (NOOP_FLAGS.has(arg) || arg.startsWith('--color=')) continue
       const mapped = FLAG_MAP[arg]
       if (!mapped) {
         return {

package/cli/commands/box.ts

@@ -38,8 +38,8 @@ import { findRepositoryPackageRoot } from '../setup-repository'
 import { resolvePlacement } from '../ws-bridge'
 import { BundleFilePlane } from './box/bundle-plane'
 import { CheckoutFilePlane, CheckoutRequiresGitError } from './box/checkout-plane'
+import { createPeachCommand } from './box/peach-command'
 import { sharePlane } from './box/plane-share'
-import { createRnxCommand } from './box/rnx-command'
 import { createSearchCommand } from './box/search-command'
 import type { BoxShellSession } from '@peach/box/client'
 import type { BoxTemplateResolution } from '@peach/box/template'
@@ -747,7 +747,7 @@ async function runLocalBox(opts: BoxCommandOptions): Promise<number> {
     createBoxHostProvider({
       shell: {
         commands: [
-          createRnxCommand({
+          createPeachCommand({
             root,
             shellCwd: () => session?.cwd ?? PROJECT_MOUNT,
           }),