peachsim 0.1.577 → 0.1.579

package/src/rolldown-plugin-swift.ts

@@ -1,244 +0,0 @@
-// `.swift` handling for One's native rolldown engine: submit the owning
-// swiftpm package to `/api/swift-compile` and answer every `.swift` import
-// with the module that mounts the published artifact.
-//
-// this is the remote twin of `vite-plugin-swift.ts`. that plugin calls the
-// shared project-unit compiler and serves the artifact from dev-server
-// middleware. the native engine is its own rolldown instance with no
-// middleware seam, so this plugin compiles nothing in-process and serves
-// nothing. the artifact url the service answers is absolute (compile-cdn), so
-// there is nothing to serve. same compiler, same store, same hash, same
-// credential as the browser worker — one path, no second toolchain to install
-// for `one dev`.
-//
-// an app registers it through One's native plugin seam, not `config.plugins`
-// (which never reach the native engine):
-//
-//   // vite.config.ts
-//   export default {
-//     plugins: [one({
-//       native: {
-//         bundler: 'vite',
-//         bundlerOptions: {
-//           plugins: [swiftRemotePlugin({
-//             endpoint: 'https://contrast.dev',
-//             assetReadToken: process.env.CONTRAST_CCDN_KEY,
-//           })],
-//         },
-//       },
-//     })],
-//   }
-//
-// no babel anywhere in this path: resolveId and load only, emitting an ESM
-// module. offline `one dev` fails loud at the submit, the same as a browser
-// build without a credential; the standalone `peach` CLI keeps the local
-// toolchain plugin for that case.
-
-import fs from 'node:fs'
-import path from 'node:path'
-import {
-  enumerateBundleImages,
-  enumerateBundleJson,
-} from '../../sootsim-swift/src/bundleAssets'
-import { swiftEntryModuleEsm } from '../../sootsim-swift/src/entryModule'
-import { compileSwiftProject, httpSwiftCompileSubmit } from './swift-submit'
-import { entryRootId } from './vite-plugin-swift'
-import type { SwiftModuleAddress } from './swift-submit'
-import type { Plugin } from 'vite'
-
-const VIRTUAL_PREFIX = '\0peach-swift-remote:'
-
-export interface SwiftRemotePluginOptions {
-  /** origin serving `/api/swift-compile` (the Contrast app). */
-  endpoint: string
-  /** a `ccdn_` API key or dev session token the compile verifier accepts. */
-  assetReadToken: string
-  /**
-   * directory uploaded `.swift` imports resolve under. defaults to the
-   * nearest `Package.swift` above each imported file — the swiftpm package
-   * that owns it — which is the compile unit, exactly like the local host.
-   * an app that keeps sources somewhere else names that package explicitly.
-   */
-  packagePath?: string
-}
-
-interface RemoteProject {
-  packagePath: string
-  address: SwiftModuleAddress | null
-}
-
-// one address per package per process: a failed submit keeps serving the
-// last published artifact (and warns) rather than failing the module, so
-// the edit that fixes the error still has a graph to rebuild.
-const projects = new Map<string, RemoteProject>()
-
-function projectFor(packagePath: string): RemoteProject {
-  const existing = projects.get(packagePath)
-  if (existing) return existing
-  const created: RemoteProject = { packagePath, address: null }
-  projects.set(packagePath, created)
-  return created
-}
-
-// every file under a directory, posix-relative, skipping what can never be
-// a source, a manifest, or bundle content. a nested Package.swift is a
-// separate package with its own compile: its files belong to that unit.
-// `.build` holds tens of thousands of intermediates and no bundle content;
-// walking it per import would tax every reload.
-function packageFiles(root: string): string[] {
-  const found: string[] = []
-  const walk = (dir: string): void => {
-    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-      if (
-        entry.name.startsWith('.') ||
-        entry.name === 'node_modules' ||
-        entry.name === '.build'
-      )
-        continue
-      const full = path.join(dir, entry.name)
-      if (entry.isDirectory()) {
-        if (full !== root && fs.existsSync(path.join(full, 'Package.swift'))) continue
-        walk(full)
-      } else {
-        found.push(path.relative(root, full).split(path.sep).join(path.posix.sep))
-      }
-    }
-  }
-  walk(root)
-  return found
-}
-
-// the file map the service compiles: the package's `.swift` sources plus
-// its root manifest, keyed package-relative. the manifest is partitioning
-// input only — the service emits its own manifest that links every target
-// against its SwiftUI module — so a standard local package travels as is.
-function sourceFiles(packagePath: string): Record<string, string> {
-  const files: Record<string, string> = {}
-  for (const relative of packageFiles(packagePath)) {
-    if (!relative.endsWith('.swift')) continue
-    files[relative] = fs.readFileSync(
-      path.join(packagePath, ...relative.split('/')),
-      'utf8',
-    )
-  }
-  return files
-}
-
-// the bundle pack and the photo uploads, through the shared enumeration
-// both hosts pack with, so the collision winner here is the winner on the
-// local host too. binary bytes straight from disk: this host is node.
-function bundlePack(packagePath: string): {
-  resources: Record<string, string>
-  images: Record<string, { file: string; data: string }>
-  watched: string[]
-} {
-  const relative = packageFiles(packagePath)
-  const disk = (file: string): string => path.join(packagePath, ...file.split('/'))
-  const resources: Record<string, string> = {}
-  const watched: string[] = []
-  for (const { base, file } of enumerateBundleJson(relative)) {
-    resources[base] = fs.readFileSync(disk(file)).toString('base64')
-    watched.push(file)
-  }
-  const images: Record<string, { file: string; data: string }> = {}
-  const byRelative = new Map(relative.map((file) => [file, disk(file)]))
-  for (const { name, file } of enumerateBundleImages(relative, (candidate) => {
-    const absolute = byRelative.get(candidate)
-    if (!absolute || path.basename(absolute) !== 'Contents.json') return null
-    try {
-      return fs.readFileSync(absolute, 'utf8')
-    } catch {
-      return null
-    }
-  })) {
-    const absolute = byRelative.get(file)
-    if (!absolute) continue
-    images[name] = {
-      file: path.posix.basename(file),
-      data: fs.readFileSync(absolute).toString('base64'),
-    }
-    watched.push(file)
-  }
-  return { resources, images, watched }
-}
-
-// the swiftpm package that owns an imported file: the nearest directory at
-// or above the file that holds a Package.swift. a `.swift` file with no
-// package above it (a pod, an xcode target) is refused loud rather than
-// compiled as the wrong unit.
-function packageFor(file: string, stop?: string): string {
-  let dir = path.dirname(file)
-  for (;;) {
-    if (fs.existsSync(path.join(dir, 'Package.swift'))) return dir
-    if ((stop !== undefined && dir === stop) || path.dirname(dir) === dir) break
-    dir = path.dirname(dir)
-  }
-  throw new Error(
-    `no Package.swift above ${file}; a .swift import needs a swiftpm package like the one in packages/sootsim-swift/example`,
-  )
-}
-
-export function swiftRemotePlugin(options: SwiftRemotePluginOptions): Plugin {
-  const submit = httpSwiftCompileSubmit({
-    assetReadToken: options.assetReadToken,
-    endpoint: options.endpoint,
-  })
-  if (!submit) {
-    throw new Error(
-      'swiftRemotePlugin needs an assetReadToken: a build without a compile credential cannot compile .swift sources',
-    )
-  }
-  return {
-    name: 'peach-swift-remote',
-    enforce: 'pre',
-
-    async resolveId(source, importer) {
-      if (source.startsWith(VIRTUAL_PREFIX)) return source
-      if (!source.endsWith('.swift')) return null
-      const resolved = await this.resolve(source, importer, { skipSelf: true })
-      if (!resolved) throw new Error(`cannot resolve swift source ${source}`)
-      return VIRTUAL_PREFIX + resolved.id
-    },
-
-    async load(id) {
-      if (!id.startsWith(VIRTUAL_PREFIX)) return null
-      const file = id.slice(VIRTUAL_PREFIX.length)
-      if (!fs.existsSync(file)) throw new Error(`swift source ${file} no longer exists`)
-      const packagePath = options.packagePath ?? packageFor(file)
-      const project = projectFor(packagePath)
-      const files = sourceFiles(packagePath)
-      const entry = path.relative(packagePath, file).split(path.sep).join(path.posix.sep)
-      for (const source of Object.keys(files)) {
-        this.addWatchFile(path.join(packagePath, ...source.split('/')))
-      }
-      const pack = bundlePack(packagePath)
-      for (const watched of pack.watched) {
-        this.addWatchFile(path.join(packagePath, ...watched.split('/')))
-      }
-      try {
-        project.address = await compileSwiftProject(
-          submit,
-          { files, resources: pack.resources, images: pack.images, entry },
-          options.endpoint,
-        )
-      } catch (error) {
-        // a compile error must not fail this module: the graph would stop
-        // watching it and the fix would never rebuild. the last published
-        // artifact keeps rendering while the diagnostic is reported here.
-        if (!project.address) throw error
-        this.warn(error instanceof Error ? error.message : String(error))
-      }
-      const address = project.address
-      // every import mounts through the one entry: the artifact answers
-      // whether it is a view or an app root at runtime, so the transform
-      // never re-derives the conformance from source.
-      return swiftEntryModuleEsm({
-        url: address.url,
-        hash: address.hash,
-        rootId: entryRootId(packagePath, file),
-        resources: address.imageUrls ?? {},
-        bundleFiles: pack.resources,
-      })
-    },
-  }
-}

package/src/team-machine-prompt.ts

@@ -1,73 +0,0 @@
-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'}`}`,
-        ),
-      )
-    })
-  })
-}