peachsim 0.1.577 → 0.1.579

package/src/vite-plugin-one.ts

@@ -8,14 +8,16 @@
 
 import fs from 'fs'
 import { randomUUID } from 'node:crypto'
+import { createRequire } from 'node:module'
 import path from 'path'
+import { swiftPackageDirectories } from 'vxrn'
+import { WebSocket, WebSocketServer } from 'ws'
 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'
@@ -26,21 +28,23 @@ import {
   serveRuntimeFile,
   SOOTSIM_RUNTIME_MISSING_MESSAGE,
 } from './runtime-assets'
+import type { PeachPluginOptions } from './vite'
 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 peach simulator loading this server's bundle once the dev
-  // server is listening. skipped when CI or PEACH_NO_OPEN is set.
-  open?: RnxDesktopOpenOption
-}
+const SWIFT_HMR_PATH = '/__peach/swift-hmr'
+// every swift route sits under this prefix. the swift host (compiler client,
+// resource packer, module glue) loads on the first request for one, so an app
+// that imports no swift never evaluates it.
+const SWIFT_ROUTE_PREFIX = '/__peach/swift'
+let swiftHost: Promise<typeof import('peachsim/vite-swift')> | undefined
+const loadSwiftHost = () => (swiftHost ??= import('peachsim/vite-swift'))
+// the Kotlin host (toolchain fetch, compile, artifact serving) loads the same
+// way, on the first /__peach/kotlin request from an Android device
+const KOTLIN_ROUTE_PREFIX = '/__peach/kotlin'
+let kotlinHost: Promise<typeof import('peachsim/vite-kotlin')> | undefined
+const loadKotlinHost = () => (kotlinHost ??= import('peachsim/vite-kotlin'))
 
-export function rnxPlugin(options: RnxPluginOptions = {}): Plugin {
+export function rnxPlugin(options: PeachPluginOptions = {}): Plugin {
   const prefix = options.prefix || '/__soot'
 
   return {
@@ -60,24 +64,223 @@ export function rnxPlugin(options: RnxPluginOptions = {}): Plugin {
 
     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()
+      let swiftPackages: Map<string, string> | undefined
+      // the workspace SwiftUI module beside peachsim compiles locally; an
+      // npm install has none (null), and its packages compile on Contrast.
+      let swiftModuleRoot: string | null | undefined
+      const moduleRootFor = (): string | undefined => {
+        if (swiftModuleRoot === undefined) {
+          const peachsimPackage = createRequire(
+            path.join(server.config.root, 'package.json'),
+          ).resolve('peachsim/package.json')
+          const moduleRoot = path.resolve(
+            path.dirname(peachsimPackage),
+            '../sootsim-swift',
+          )
+          swiftModuleRoot = fs.existsSync(path.join(moduleRoot, 'toolchain.json'))
+            ? moduleRoot
+            : null
+        }
+        return swiftModuleRoot ?? undefined
+      }
+      const activeSwiftPackages = new Set<string>()
+      const packageMap = () => {
+        swiftPackages ??= swiftPackageDirectories(server.config.root)
+        return swiftPackages
+      }
+      const wsOptions = server.config.server.ws
+      const httpServer =
+        server.httpServer ??
+        (wsOptions && typeof wsOptions === 'object' ? wsOptions.server : undefined)
+      const swiftSockets = httpServer
+        ? new WebSocketServer({ noServer: true })
+        : undefined
+      const hmrPath = SWIFT_HMR_PATH
       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,
+      const devOrigin = () => `http://localhost:${listeningPort()}`
+      const sendSwiftChange = (change: object) => {
+        const message = JSON.stringify(change)
+        for (const client of swiftSockets?.clients ?? []) {
+          if (client.readyState === WebSocket.OPEN) client.send(message)
+        }
+      }
+      if (httpServer && swiftSockets) {
+        httpServer.on('upgrade', (req, socket, head) => {
+          if (new URL(req.url ?? '/', 'http://localhost').pathname !== SWIFT_HMR_PATH)
+            return
+          swiftSockets.handleUpgrade(req, socket, head, (client) => {
+            swiftSockets.emit('connection', client, req)
+          })
+        })
+        httpServer.once('close', () => {
+          for (const client of swiftSockets.clients) client.terminate()
+          swiftSockets.close()
+        })
+      }
+      server.watcher.on('add', (file) => {
+        if (path.basename(file) === 'Package.swift') swiftPackages = undefined
+      })
+      server.watcher.on('unlink', (file) => {
+        if (path.basename(file) === 'Package.swift') swiftPackages = undefined
+      })
+      // a Kotlin source edit reaches the next call: the seam drops the module
+      // it imported and asks for the app's Kotlin again
+      let kotlinModuleRoot: string | undefined
+      server.watcher.on('all', (_event, file) => {
+        if (!kotlinModuleRoot) return
+        if (file.endsWith('.kt') || file.startsWith(`${kotlinModuleRoot}${path.sep}`))
+          sendSwiftChange({ type: 'kotlin', packageName: 'kotlin' })
+      })
+      server.middlewares.use((req, res, next) => {
+        const pathname = (req.url ?? '').split('?')[0]
+        if (!pathname.startsWith(KOTLIN_ROUTE_PREFIX)) return next()
+        loadKotlinHost()
+          .then(async (host) => {
+            if (host.serveKotlinArtifact(pathname, res)) return
+            if (pathname !== '/__peach/kotlin-package') return next()
+            if (!kotlinModuleRoot) {
+              const moduleRoot = path.join(
+                path.dirname(
+                  createRequire(path.join(server.config.root, 'package.json')).resolve(
+                    'peachsim/package.json',
+                  ),
+                ),
+                'kotlin',
+              )
+              kotlinModuleRoot = moduleRoot
+              server.watcher.add(path.join(moduleRoot, 'Sources'))
+            }
+            try {
+              const artifact = await host.kotlinArtifact(
+                server.config.root,
+                kotlinModuleRoot,
+                devOrigin(),
+              )
+              res.setHeader('access-control-allow-origin', '*')
+              res.setHeader('content-type', 'application/json')
+              res.end(JSON.stringify({ ...artifact, hmrPath }))
+            } catch (error) {
+              res.statusCode = 500
+              res.setHeader('access-control-allow-origin', '*')
+              res.end(error instanceof Error ? error.message : String(error))
+            }
+          })
+          .catch(next)
+      })
+      server.watcher.on('change', (file) => {
+        if (activeSwiftPackages.size === 0) return
+        const moduleRoot = moduleRootFor()
+        let packages: Map<string, string>
+        try {
+          packages = packageMap()
+        } catch (error) {
+          for (const packageName of activeSwiftPackages) {
+            sendSwiftChange({
+              type: 'error',
+              packageName,
+              message: error instanceof Error ? error.message : String(error),
+            })
+          }
+          return
+        }
+        for (const packageName of activeSwiftPackages) {
+          const packagePath = packages.get(packageName)
+          if (!packagePath) continue
+          if (
+            !file.startsWith(`${packagePath}${path.sep}`) &&
+            !(moduleRoot && file.startsWith(`${moduleRoot}${path.sep}`))
+          )
+            continue
+          void loadSwiftHost()
+            .then((host) =>
+              host.swiftPackageMetadata(
+                packagePath,
+                packageName,
+                moduleRoot,
+                devOrigin(),
+              ),
+            )
+            .then((metadata) => {
+              sendSwiftChange({
+                type: 'package',
+                packageName,
+                metadata: { ...metadata, hmrPath },
+              })
+            })
+            .catch((error: unknown) => {
+              sendSwiftChange({
+                type: 'error',
+                packageName,
+                message: error instanceof Error ? error.message : String(error),
+              })
+            })
+        }
+      })
+      server.middlewares.use((req, res, next) => {
+        const pathname = (req.url ?? '').split('?')[0]
+        if (!pathname.startsWith(SWIFT_ROUTE_PREFIX)) return next()
+        loadSwiftHost()
+          .then((host) => {
+            if (host.serveSwiftPackageAsset(pathname, res)) return
+            const prefix = '/__peach/swift-package/'
+            if (!pathname.startsWith(prefix)) return next()
+            if (!swiftSockets) {
+              res.statusCode = 501
+              res.end('Peach Swift hot reload requires a Vite HTTP server')
+              return
+            }
+            const packageName = pathname.slice(prefix.length)
+            let packagePath: string | undefined
+            try {
+              packagePath = packageMap().get(packageName)
+            } catch (error) {
+              res.statusCode = 500
+              res.end(error instanceof Error ? error.message : String(error))
+              return
+            }
+            if (!packagePath) {
+              res.statusCode = 404
+              res.end(`swift package ${packageName} was not found`)
+              return
+            }
+            const moduleRoot = moduleRootFor()
+            activeSwiftPackages.add(packageName)
+            server.watcher.add(host.swiftPackageWatchFiles(packagePath, moduleRoot))
+            void host
+              .swiftPackageMetadata(packagePath, packageName, moduleRoot, devOrigin())
+              .then((metadata) => {
+                res.setHeader('access-control-allow-origin', '*')
+                res.setHeader('content-type', 'application/json')
+                res.end(JSON.stringify({ ...metadata, hmrPath }))
+              })
+              .catch((error: unknown) => {
+                res.statusCode = 500
+                res.end(error instanceof Error ? error.message : String(error))
+              })
+          })
+          .catch(next)
+      })
+      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 bundleForPort = (port: number): string => {
+        const fullBundleUrl = bundleUrl.startsWith('http')
+          ? bundleUrl
+          : `http://localhost:${port}${bundleUrl.startsWith('/') ? '' : '/'}${bundleUrl}`
+        return tagRnxBundleForPlugin(
+          fullBundleUrl,
           `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
@@ -247,18 +450,3 @@ export function rnxPlugin(options: RnxPluginOptions = {}): Plugin {
 
 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'