rnxsim 0.0.0 → 0.1.312

package/src/vite-plugin-one.ts

@@ -0,0 +1,190 @@
+// sootsim plugin for One/Vite — serves the installed sootsim runtime at /__soot/
+// from ~/.sootsim/runtimes/<version>. version-owned localhost origins remain
+// bound to that directory across an active-runtime update.
+//
+// usage in vite.config.ts:
+//   import { sootsimPlugin } from 'sootsim/vite'
+//   export default { plugins: [one(), sootsimPlugin()] }
+
+import fs from 'fs'
+import path from 'path'
+import { DEFAULT_SOOTSIM_BRIDGE_PORT } from './bridge-constants'
+import { isDaemonLockfileFresh, readDaemonLockfile } from './home-paths'
+import {
+  isRootRuntimeAssetPath,
+  resolveRuntimeFilePath,
+  resolveRuntimeRootForRequestHost,
+  serveRuntimeFile,
+  SOOTSIM_RUNTIME_MISSING_MESSAGE,
+} from './runtime-assets'
+import type { Plugin } from 'vite'
+
+export interface SootSimPluginOptions {
+  // custom bundle URL (default: auto-detect from One's metro)
+  bundleUrl?: string
+  // path prefix (default: '/__soot')
+  prefix?: string
+  // disable sootsim
+  enabled?: boolean
+}
+
+export function sootsimPlugin(options: SootSimPluginOptions = {}): Plugin[] {
+  if (options.enabled === false) return []
+
+  const prefix = options.prefix || '/__soot'
+
+  return [
+    {
+      name: 'sootsim-one',
+
+      configureServer(server) {
+        const bundleUrl =
+          options.bundleUrl ||
+          '/node_modules/one/metro-entry.bundle?platform=ios&dev=true&minify=false'
+
+        // 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: `sootsim 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(bundleUrl)});` +
+            `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 (sootsim 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 = server.config.server.port || 8081
+          const absoluteBundleUrl = bundleUrl.startsWith('http')
+            ? bundleUrl
+            : `http://localhost:${scanPort}${bundleUrl}`
+          res.setHeader('content-type', 'application/json')
+          res.end(
+            JSON.stringify([
+              {
+                port: scanPort,
+                framework: 'one',
+                bundleUrl: absoluteBundleUrl,
+                lastSeen: Date.now(),
+              },
+            ]),
+          )
+        })
+
+        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 = server.config.server.port || 8081
+        const sootsimUrl = `http://localhost:${port}${prefix}/`
+        console.log(`[rnx] serving at ${sootsimUrl}`)
+      },
+    },
+  ]
+}
+
+export default sootsimPlugin