peachsim 0.1.527

package/src/skills/types.ts

@@ -0,0 +1,41 @@
+// skill type definitions — self-contained agent capabilities
+
+export type SkillType = 'testing' | 'screenshot' | 'review' | 'performance' | 'custom'
+
+export interface SkillTool {
+  name: string
+  description: string
+  parameters: Record<string, { type: string; description: string; required?: boolean }>
+  execute: (params: Record<string, any>, context: SkillContext) => Promise<SkillResult>
+}
+
+export interface SkillContext {
+  url: string // sootsim URL
+  projectDir: string // project root
+  outputDir: string // where to write artifacts
+  verbose: boolean
+}
+
+export interface SkillResult {
+  success: boolean
+  message: string
+  artifacts?: SkillArtifact[]
+  data?: Record<string, any>
+}
+
+export interface SkillArtifact {
+  type: 'screenshot' | 'video' | 'report' | 'flow' | 'json'
+  name: string
+  path: string
+}
+
+export interface RNXSkill {
+  name: string
+  description: string
+  type: SkillType
+  version: string
+  triggers: string[] // natural language patterns that activate this skill
+  tools: SkillTool[]
+  setup?: (context: SkillContext) => Promise<void>
+  teardown?: (context: SkillContext) => Promise<void>
+}

package/src/swift-submit.ts

@@ -0,0 +1,185 @@
+/**
+ * swift-compile's caller half: ask the compile host for this project's wasm
+ * artifact, and poll until it is published.
+ *
+ * This is the `.swift` transform's one request path, shared by every host
+ * that renders a project's swift sources: the in-IDE bundler worker (posts
+ * its own origin's `/api/swift-compile`), the node bundle builder used by
+ * the test-drive CLI and the deploy publisher (posts an absolute endpoint),
+ * and the One/rolldown `.swift` transform (same, with a `ccdn_` credential).
+ * A caller never compiles in-process: the container is the one compiler, and
+ * no bundler is that instance.
+ *
+ * It lives here (rather than in the app's `src/bundler/`) because the One
+ * transform ships in this package and cannot import app code; the app's own
+ * callers import this subpath back. The route path and the outcome shape are
+ * the wire coupling to `src/compile/swiftCompileContract.ts`, which owns the
+ * server-side caps, parsers, and refusals and imports these back.
+ *
+ * Browser-safe: node-only submitters live beside their call sites.
+ */
+
+export const SWIFT_COMPILE_PATH = '/api/swift-compile'
+
+export interface SwiftImageUpload {
+  /** the raster file picked for the asset (has the extension). */
+  file: string
+  /** the raster bytes, base64: carried once so the service can publish them. */
+  data: string
+}
+
+export type SwiftCompileOutcome =
+  /**
+   * the artifact is published; the bundler mounts it by url and hash.
+   *
+   * `artifactUrl` is root-relative (`/compile/asset/<sha256>`), because the
+   * host that compiles has no browser origin in front of it: the local node
+   * dev server and the cf-build container would each have to guess one. The
+   * caller that renders the module resolves it against its own origin, which
+   * is the origin the artifact route is served from in dev and in prod alike.
+   */
+  | {
+      status: 'published'
+      artifactUrl: string
+      hash: string
+      /**
+       * the published photo rasters, bundle asset name to absolute url.
+       * root-relative like the artifact url; the caller resolves it against
+       * its own origin, and the entry embeds it as the image table. absent
+       * when the request packs no images.
+       */
+      imageUrls?: Record<string, string>
+    }
+  /**
+   * the build is running; poll the same source set again. One build is tens of
+   * seconds and a service-binding request is cancelled at about four, so the
+   * container answers this before the connection dies and the caller polls.
+   */
+  | { status: 'compiling'; hash: string }
+  /** refused before any work: no entry, too many files, over a cap, over a rate limit. */
+  | { status: 'refused'; detail: string }
+  /** the compiler ran and failed; detail carries its diagnostic verbatim. */
+  | { status: 'failed'; detail: string }
+
+const POLL_INTERVAL_MS = 1500
+
+export interface SwiftCompileContext {
+  /**
+   * the compile credential: the signed preview token `BundlerSessionRuntime`
+   * mints for a live project session, or a `ccdn_` API key. `compileCredential.server.ts`
+   * is the one verifier. absent means this build has no credential and a
+   * project with `.swift` sources cannot be compiled.
+   */
+  assetReadToken?: string
+  /**
+   * absolute origin of the app serving `/api/swift-compile`. The browser
+   * worker omits it and posts its own origin; a node caller that is not that
+   * app must pass one.
+   */
+  endpoint?: string
+}
+
+export type SwiftCompileSubmit = (work: {
+  files: Record<string, string>
+  /** the bundle pack; absent means the project packs none. */
+  resources?: Record<string, string>
+  /** the photo rasters to publish; absent means the project packs none. */
+  images?: Record<string, SwiftImageUpload>
+  entry: string
+}) => Promise<SwiftCompileOutcome>
+
+/** the HTTP submitter, shared by the browser worker and the node build. */
+export function httpSwiftCompileSubmit(
+  context: SwiftCompileContext,
+): SwiftCompileSubmit | undefined {
+  const { assetReadToken, endpoint } = context
+  if (!assetReadToken) return undefined
+  const url = endpoint
+    ? `${endpoint.replace(/\/+$/, '')}${SWIFT_COMPILE_PATH}`
+    : SWIFT_COMPILE_PATH
+
+  return async (work) => {
+    let response: Response
+    try {
+      response = await fetch(url, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ ...work, token: assetReadToken }),
+      })
+    } catch (error) {
+      throw new Error(
+        `contrast-bundler: fetch failed for ${url} while compiling ${work.entry}: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error },
+      )
+    }
+    if (!response.ok) {
+      const detail = (await response.text()).trim()
+      throw new Error(
+        `contrast-bundler: the swift compile for ${work.entry} answered ${response.status}${detail ? `: ${detail}` : ''}`,
+      )
+    }
+    return (await response.json()) as SwiftCompileOutcome
+  }
+}
+
+export interface SwiftModuleAddress {
+  /** absolute url the tenant fetches the wasm from. */
+  url: string
+  hash: string
+  /** bundle asset name to absolute photo url, when the pack publishes any. */
+  imageUrls?: Record<string, string>
+}
+
+/** the service answers root-relative; the caller that knows the origin resolves. */
+function resolveImageUrls(
+  urls: Record<string, string>,
+  origin: string,
+): Record<string, string> {
+  const resolved: Record<string, string> = {}
+  for (const [name, url] of Object.entries(urls)) {
+    resolved[name] = new URL(url, origin).href
+  }
+  return resolved
+}
+
+/**
+ * one project's swift sources as a published artifact address.
+ *
+ * `origin` is the origin the artifact route answers on — the app's own origin
+ * for the browser worker, the caller's compile origin for a node build. The
+ * contract's url is root-relative because the compile host has no browser
+ * origin in front of it, so the resolution happens here, at the one caller
+ * that knows both.
+ */
+export async function compileSwiftProject(
+  submit: SwiftCompileSubmit,
+  work: {
+    files: Record<string, string>
+    resources?: Record<string, string>
+    images?: Record<string, SwiftImageUpload>
+    entry: string
+  },
+  origin: string,
+): Promise<SwiftModuleAddress> {
+  while (true) {
+    const outcome = await submit(work)
+    switch (outcome.status) {
+      case 'published':
+        return {
+          url: new URL(outcome.artifactUrl, origin).href,
+          hash: outcome.hash,
+          ...(outcome.imageUrls === undefined
+            ? {}
+            : { imageUrls: resolveImageUrls(outcome.imageUrls, origin) }),
+        }
+      case 'compiling':
+        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS))
+        continue
+      case 'refused':
+      case 'failed':
+        throw new Error(
+          `contrast-bundler: the swift sources for ${work.entry} cannot be compiled: ${outcome.detail}`,
+        )
+    }
+  }
+}

package/src/swift.ts

@@ -0,0 +1,7 @@
+// the runtime the `.swift` vite transform emits its module against. the
+// implementation lives beside the toolchain it drives, in sootsim-swift.
+export {
+  createSwiftEntry,
+  type SwiftEntryOptions,
+  type SwiftModuleOptions,
+} from '../../sootsim-swift/src/mount.tsx'

package/src/team-machine-prompt.ts

@@ -0,0 +1,73 @@
+import { spawn } from 'node:child_process'
+import {
+  isValidTeamMachineSessionId,
+  teamMachineSessionIdFromCliIdentity,
+} from './agent-identity.ts'
+import type { AgentPromptEnvelope } from './agent-prompt.ts'
+
+export { teamMachineSessionIdFromCliIdentity } from './agent-identity.ts'
+
+export function formatTeamMachinePromptText(prompt: AgentPromptEnvelope): string {
+  return typeof prompt.text === 'string' ? prompt.text.trim() : ''
+}
+
+function resolveTeamMachineCommand(explicit?: string): string {
+  const fromArg = explicit?.trim()
+  if (fromArg) return fromArg
+  return 'tm'
+}
+
+export async function sendPromptToTeamMachineSession(input: {
+  sessionId: string
+  prompt: AgentPromptEnvelope
+  command?: string
+  timeoutMs?: number
+}): Promise<void> {
+  const sessionId = input.sessionId.trim()
+  if (!isValidTeamMachineSessionId(sessionId)) {
+    throw new Error(`invalid Team Machine session id: ${sessionId || '<empty>'}`)
+  }
+  const text = formatTeamMachinePromptText(input.prompt)
+  if (!text) {
+    throw new Error('prompt text is empty')
+  }
+
+  const command = resolveTeamMachineCommand(input.command)
+  const timeoutMs = input.timeoutMs ?? 15_000
+  await new Promise<void>((resolve, reject) => {
+    const child = spawn(command, ['send', sessionId, text], {
+      stdio: ['ignore', 'ignore', 'pipe'],
+      env: process.env,
+    })
+    let stderr = ''
+    const timer = setTimeout(() => {
+      try {
+        child.kill('SIGTERM')
+      } catch {}
+      reject(new Error(`tm send timed out after ${Math.round(timeoutMs / 1000)}s`))
+    }, timeoutMs)
+
+    child.stderr?.setEncoding('utf8')
+    child.stderr?.on('data', (chunk) => {
+      if (stderr.length < 4000) stderr += String(chunk)
+    })
+    child.on('error', (err) => {
+      clearTimeout(timer)
+      reject(err)
+    })
+    child.on('close', (code, signal) => {
+      clearTimeout(timer)
+      if (code === 0) {
+        resolve()
+        return
+      }
+      const detail = stderr.trim()
+      reject(
+        new Error(
+          detail ||
+            `tm send exited with ${signal ? `signal ${signal}` : `code ${code ?? 'unknown'}`}`,
+        ),
+      )
+    })
+  })
+}

package/src/vite-plugin-one.ts

@@ -0,0 +1,264 @@
+// sootsim plugin for One/Vite — serves the installed sootsim runtime at /__soot/
+// from ~/.rnx/runtimes/<version>. version-owned localhost origins remain
+// bound to that directory across an active-runtime update.
+//
+// usage in vite.config.ts:
+//   import { rnxPlugin } from 'rnxsim/vite'
+//   export default { plugins: [one(), rnxPlugin()] }
+
+import fs from 'fs'
+import { randomUUID } from 'node:crypto'
+import path from 'path'
+import { DEFAULT_SOOTSIM_BRIDGE_PORT } from './bridge-constants'
+import {
+  launchRnxDesktop,
+  resolveRnxDesktopAppName,
+  resolveRnxDesktopLaunchTarget,
+  tagRnxBundleForPlugin,
+  type RnxDesktopOpenOption,
+} from './dev-server-open'
+import { isDaemonLockfileFresh, readDaemonLockfile } from './home-paths'
+import { handleReplacementModuleRequest } from './host/replacement-module-handler'
+import {
+  isRootRuntimeAssetPath,
+  resolveRuntimeFilePath,
+  resolveRuntimeRootForRequestHost,
+  serveRuntimeFile,
+  SOOTSIM_RUNTIME_MISSING_MESSAGE,
+} from './runtime-assets'
+import type { Plugin } from 'vite'
+
+export interface RnxPluginOptions {
+  // custom bundle URL (default: auto-detect from One's metro)
+  bundleUrl?: string
+  // path prefix (default: '/__soot')
+  prefix?: string
+  // disable sootsim
+  enabled?: boolean
+  // launch the sootsim simulator loading this server's bundle once the dev
+  // server is listening. skipped when CI or RNX_NO_OPEN is set.
+  open?: RnxDesktopOpenOption
+}
+
+export function rnxPlugin(options: RnxPluginOptions = {}): Plugin {
+  const prefix = options.prefix || '/__soot'
+
+  return {
+    name: 'sootsim-one',
+
+    // use-latest-callback ships a CJS main (module.exports, no default) with
+    // an esm.mjs shim that re-imports it. react-native-bottom-tabs
+    // default-imports it from source served live, so vite hands the browser
+    // the raw CJS file and the import fails with 'does not provide an export
+    // named default' before anything mounts. forcing it through dep
+    // optimization lets esbuild's CJS interop answer the default import, and
+    // every bare import of it (including the nested copy's) resolves to the
+    // one pre-bundled instance.
+    config() {
+      return { optimizeDeps: { include: ['use-latest-callback'] } }
+    },
+
+    configureServer(server) {
+      if (options.enabled === false) return
+      const bundleUrl =
+        options.bundleUrl ||
+        '/node_modules/one/metro-entry.bundle?platform=ios&dev=true&minify=false'
+      const appName = resolveRnxDesktopAppName(options.open, server.config.root)
+      const replacementToken = randomUUID()
+      const configuredPort = server.config.server.port || 8081
+      const listeningPort = (): number => {
+        const address = server.httpServer?.address()
+        return address && typeof address === 'object' ? address.port : configuredPort
+      }
+      const bundleForPort = (port: number): string =>
+        tagRnxBundleForPlugin(
+          bundleUrl,
+          `http://localhost:${port}`,
+          replacementToken,
+          server.config.root,
+          appName,
+        )
+
+      // build the shell HTML, injecting the bundle URL (so main.tsx loads this
+      // app's bundle) AND window.__sootsimBridgePort. the bridge-port injection
+      // mirrors the dev-stack bridge-host: without it the engine's
+      // resolveBridgePort() falls back to a location-derived guess that mis-maps
+      // a non-Contrast app port (the mobile template's :4400 -> 9068) and the sim
+      // can't reach the bridge. resolved per-request from the daemon lockfile
+      // (the CLI's `open` writes/uses it before the shell loads) so the engine
+      // targets the SAME bridge the CLI does; default port otherwise.
+      const buildShellHtml = (runtimeRoot: string): string => {
+        const html = fs.readFileSync(path.join(runtimeRoot, 'index.html'), 'utf8')
+        const lock = readDaemonLockfile()
+        const bridgePort =
+          lock && isDaemonLockfileFresh(lock) && lock.bridgePort > 0
+            ? lock.bridgePort
+            : DEFAULT_SOOTSIM_BRIDGE_PORT
+        // inject the bridge port + a default bundle (only when the URL has none,
+        // so the CLI's resolved bundle wins), and PRESERVE the existing query.
+        // preserving the query is essential: `rnx open` stamps the open URL
+        // with `inspectOpen=<token>` and matches the registered sim by that
+        // token (waitForSimMatch). the old code forced `?bundle=` only and
+        // stripped inspectOpen, so the sim registered but never matched and
+        // `open` timed out after 60s.
+        const inject =
+          `<script>(function(){var u=new URL(location.href);` +
+          `if(!u.searchParams.has('bundle'))u.searchParams.set('bundle',${JSON.stringify(bundleForPort(listeningPort()))});` +
+          `window.__sootsimBridgePort=${bridgePort};` +
+          `history.replaceState(null,'','${prefix}/'+u.search)})()</script>`
+        return html.replace('</head>', inject + '</head>')
+      }
+
+      // mirror Set-Cookie into a readable header for sootsim's fetch wrapper
+      server.middlewares.use((req, res, next) => {
+        const origWriteHead = res.writeHead.bind(res)
+        res.writeHead = function (statusCode: number, ...args: unknown[]) {
+          const setCookie = res.getHeader('set-cookie')
+          if (setCookie) {
+            const value = Array.isArray(setCookie)
+              ? setCookie.join(', ')
+              : String(setCookie)
+            res.setHeader('x-sootsim-set-cookie', value)
+            res.setHeader('access-control-expose-headers', 'x-sootsim-set-cookie')
+          }
+          return (origWriteHead as (...args: unknown[]) => typeof res)(
+            statusCode,
+            ...args,
+          )
+        } as typeof res.writeHead
+        next()
+      })
+
+      // serve a minimal /__server-scan describing THIS vite dev server, so a
+      // sootsim shell loaded from <port>/__soot can resolve this app's native
+      // bundle. dev-bundle-resolution's resolvePortViaServerScan fetches
+      // `/__server-scan` RELATIVE to the shell origin; when the shell is loaded
+      // from this target origin, that hits here. without it the request SPA-
+      // falls-back to 404 and the bundle never resolves (rnx open hangs).
+      // we describe only this server (the shell drives THIS app) — no localhost-
+      // wide scan, so the published plugin pulls in no shell-only scanner
+      // internals. shape matches DiscoveredServer enough for the resolver.
+      server.middlewares.use((req, res, next) => {
+        if ((req.url || '').split('?')[0] !== '/__server-scan') return next()
+        const scanPort = listeningPort()
+        const pluginBundleUrl = bundleForPort(scanPort)
+        const absoluteBundleUrl = pluginBundleUrl.startsWith('http')
+          ? pluginBundleUrl
+          : `http://localhost:${scanPort}${pluginBundleUrl}`
+        res.setHeader('content-type', 'application/json')
+        res.end(
+          JSON.stringify([
+            {
+              port: scanPort,
+              framework: 'one',
+              bundleUrl: absoluteBundleUrl,
+              ...(appName ? { projectName: appName } : {}),
+              lastSeen: Date.now(),
+            },
+          ]),
+        )
+      })
+
+      server.middlewares.use((req, res, next) => {
+        void handleReplacementModuleRequest(req, res, {
+          projectRoot: server.config.root,
+          requestToken: replacementToken,
+          requireLoopbackOrigin: true,
+        }).then((handled) => {
+          if (!handled) next()
+        })
+      })
+
+      server.middlewares.use((req, res, next) => {
+        const url = req.url || ''
+        const pathname = url.split('?')[0]
+        const runtimeRoot = resolveRuntimeRootForRequestHost(req.headers.host)
+
+        if (!runtimeRoot) {
+          if (
+            pathname === prefix ||
+            pathname === prefix + '/' ||
+            pathname.startsWith(prefix + '/')
+          ) {
+            res.statusCode = 500
+            res.end(SOOTSIM_RUNTIME_MISSING_MESSAGE)
+            return
+          }
+          next()
+          return
+        }
+
+        // root-relative runtime assets emitted by the shell and engine vite
+        // builds. only intercept when the asset exists in the active runtime.
+        if (isRootRuntimeAssetPath(pathname)) {
+          const fullPath = resolveRuntimeFilePath(runtimeRoot, pathname)
+          if (fullPath) {
+            serveRuntimeFile(req, res, fullPath)
+            return
+          }
+        }
+
+        // serve the sootsim HTML shell — inject bundle URL + bridge port
+        if (pathname === prefix || pathname === prefix + '/') {
+          res.setHeader('content-type', 'text/html')
+          res.end(buildShellHtml(runtimeRoot))
+          return
+        }
+
+        // serve runtime files under /__soot/*.
+        if (pathname.startsWith(prefix + '/')) {
+          const fullPath = resolveRuntimeFilePath(
+            runtimeRoot,
+            pathname.slice(prefix.length),
+          )
+          if (fullPath) {
+            serveRuntimeFile(req, res, fullPath)
+            return
+          }
+
+          // extensionless in-shell routes should still load the shell.
+          const ext = path.extname(pathname)
+          if (!ext) {
+            res.setHeader('content-type', 'text/html')
+            res.end(buildShellHtml(runtimeRoot))
+            return
+          }
+        }
+
+        next()
+      })
+
+      const port = configuredPort
+      const sootsimUrl = `http://localhost:${port}${prefix}/`
+      console.log(`[rnx] serving at ${sootsimUrl}`)
+
+      if (appName && !process.env.CI && !process.env.RNX_NO_OPEN) {
+        server.httpServer?.once('listening', () => {
+          const openPort = listeningPort()
+          launchRnxDesktop(
+            resolveRnxDesktopLaunchTarget(openPort, bundleForPort(openPort)),
+            appName,
+          )
+        })
+      }
+    },
+  }
+}
+
+export const sootsimPlugin = rnxPlugin
+export default rnxPlugin
+
+// the `.swift` transform is opt-in per project: an app that never imports a
+// `.swift` file has no reason to watch for one, and an app that ships a native
+// ios/ tree (every swift file in it is a pod or an xcode target, not app
+// source) would otherwise rebuild the wrong package on every edit. a local
+// vite app registers `swiftPlugin` in both the bundler that builds its native
+// bundle and the main dev server that serves the artifact; a One app on the
+// rolldown native engine registers `swiftRemotePlugin` through
+// `native.bundlerOptions.plugins` instead, which submits to
+// `/api/swift-compile` and needs no local toolchain and no serving.
+export { swiftPlugin, type SwiftPluginOptions } from './vite-plugin-swift.ts'
+export {
+  swiftRemotePlugin,
+  type SwiftRemotePluginOptions,
+} from './rolldown-plugin-swift.ts'