vxrn 1.21.6 → 1.21.7

package/src/exports/clean.ts

@@ -1,39 +1,73 @@
-import FSExtra from 'fs-extra'
-import { rm } from 'node:fs/promises'
-import { join } from 'node:path'
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
 import type { VXRNOptions } from '../types'
 import { fillOptions } from '../config/getOptionsFilled'
 import { getSSRExternalsCachePath } from '../plugins/autoDepOptimizePlugin'
 import { getCacheDir } from '../utils/getCacheDir'
+import { readState, writeState } from '../utils/state'
 
-/**
- * The main entry point for dev mode
- *
- * Note that much of the logic is being run by plugins:
- *
- *  - createFileSystemRouterPlugin does most of the fs-routes/request handling
- *  - clientTreeShakePlugin handles loaders/transforms
- *
- */
+const CLEAN_LOCK_WAIT_MS = 25
+const CLEAN_LOCK_TIMEOUT_MS = 60_000
 
-export const clean = async (rest: VXRNOptions, only?: 'vite') => {
-  const options = await fillOptions(rest)
-  const { root } = options
+function getErrorCode(err: unknown) {
+  if (err instanceof Error && 'code' in err && typeof err.code === 'string') {
+    return err.code
+  }
+}
+
+async function withCacheCleanLock<T>(cacheDir: string, action: () => Promise<T>) {
+  const lockPath = join(dirname(cacheDir), '.vxrn-clean.lock')
+  const startedAt = Date.now()
+  await mkdir(dirname(lockPath), { recursive: true })
+
+  while (true) {
+    try {
+      await writeFile(lockPath, `${process.pid}\n`, { flag: 'wx' })
+      break
+    } catch (err) {
+      if (getErrorCode(err) !== 'EEXIST') {
+        throw err
+      }
+
+      if (Date.now() - startedAt >= CLEAN_LOCK_TIMEOUT_MS) {
+        let owner = 'unknown process'
+        try {
+          owner = `process ${(await readFile(lockPath, 'utf8')).trim()}`
+        } catch (readErr) {
+          if (getErrorCode(readErr) === 'ENOENT') {
+            continue
+          }
+          throw readErr
+        }
+        throw new Error(`Timed out waiting for VXRN cache cleanup lock held by ${owner}`)
+      }
+      await new Promise<void>((resolve) => setTimeout(resolve, CLEAN_LOCK_WAIT_MS))
+    }
+  }
+
+  try {
+    return await action()
+  } finally {
+    await rm(lockPath, { force: true })
+  }
+}
+
+async function removeCachePaths(root: string, only?: 'vite') {
+  const removeVxrnCache = process.env.VXRN_DONT_CLEAN_SELF
+    ? rm(getSSRExternalsCachePath(root)).catch(throwIfNotMissingError)
+    : rm(getCacheDir(root), {
+        recursive: true,
+        force: true,
+      }).catch(throwIfNotMissingError)
 
   console.info(`[vxrn] cleaning`)
 
   await Promise.all([
-    rm(getSSRExternalsCachePath(root)).catch(throwIfNotMissingError),
     rm(join(root, 'node_modules', '.vite'), {
       recursive: true,
       force: true,
     }).catch(throwIfNotMissingError),
-    process.env.VXRN_DONT_CLEAN_SELF
-      ? null
-      : rm(getCacheDir(root), {
-          recursive: true,
-          force: true,
-        }).catch(throwIfNotMissingError),
+    removeVxrnCache,
     only === 'vite'
       ? null
       : rm(join(root, 'dist'), {
@@ -43,10 +77,40 @@ export const clean = async (rest: VXRNOptions, only?: 'vite') => {
   ])
 }
 
-function throwIfNotMissingError(err: unknown) {
-  if (err instanceof Error) {
-    if ((err as NodeJS.ErrnoException).code !== 'ENOENT') {
-      throw Error
+export async function prepareCacheForVersion({
+  root,
+  cacheDir,
+  versionHash,
+  forceClean = false,
+}: {
+  root: string
+  cacheDir: string
+  versionHash: string
+  forceClean?: boolean
+}) {
+  return withCacheCleanLock(cacheDir, async () => {
+    const state = await readState(cacheDir)
+    const versionChanged = !!state.versionHash && state.versionHash !== versionHash
+    const shouldClean = forceClean || versionChanged
+
+    if (shouldClean) {
+      await removeCachePaths(root, 'vite')
+    }
+    if (shouldClean || state.versionHash !== versionHash) {
+      await writeState(cacheDir, { versionHash })
     }
+
+    return shouldClean
+  })
+}
+
+export const clean = async (rest: VXRNOptions, only?: 'vite') => {
+  const options = await fillOptions(rest)
+  await withCacheCleanLock(options.cacheDir, () => removeCachePaths(options.root, only))
+}
+
+function throwIfNotMissingError(err: unknown) {
+  if (getErrorCode(err) !== 'ENOENT') {
+    throw err
   }
 }

package/src/exports/dev.ts

@@ -44,7 +44,7 @@ export const dev = async (optionsIn: DevOptions) => {
   const { fillOptions } = await import('../config/getOptionsFilled')
   const { getViteServerConfig } = await import('../config/getViteServerConfig')
   const { printServerUrls } = await import('../utils/printServerUrls')
-  const { clean } = await import('./clean')
+  const { prepareCacheForVersion } = await import('./clean')
   const { filterViteServerResolvedUrls } =
     await import('../utils/filterViteServerResolvedUrls')
   const { removeUndefined } = await import('../utils/removeUndefined')
@@ -107,8 +107,13 @@ export default defineConfig({
 
   bindKeypressInput()
 
-  if (options.clean) {
-    await clean(optionsIn, options.clean)
+  const cacheWasCleaned = await prepareCacheForVersion({
+    root: options.root,
+    cacheDir,
+    versionHash: options.versionHash,
+    forceClean: optionsIn.clean === true,
+  })
+  if (options.clean || cacheWasCleaned) {
     // signal metro to reset its cache as well
     process.env.METRO_RESET_CACHE = '1'
   }

package/src/serve/node.test.ts

@@ -0,0 +1,63 @@
+import { createServer } from 'node:http'
+import { Hono } from 'hono'
+import { describe, expect, test } from 'vitest'
+import { honoServeNode } from './node'
+
+describe('honoServeNode', () => {
+  test('rejects when the listener cannot bind', async () => {
+    const occupied = createServer()
+    await new Promise<void>((resolve, reject) => {
+      occupied.once('error', reject)
+      occupied.listen(0, '127.0.0.1', resolve)
+    })
+    const address = occupied.address()
+    if (!address || typeof address === 'string') throw new Error('missing test port')
+
+    const app = new Hono().get('/health', (context) => context.text('ok'))
+    await expect(
+      honoServeNode(app, { host: '127.0.0.1', port: address.port })
+    ).rejects.toMatchObject({ code: 'EADDRINUSE' })
+
+    await new Promise<void>((resolve, reject) =>
+      occupied.close((error) => (error ? reject(error) : resolve()))
+    )
+  })
+
+  test('overwrites the trusted peer address header from the socket', async () => {
+    const reservation = createServer()
+    await new Promise<void>((resolve, reject) => {
+      reservation.once('error', reject)
+      reservation.listen(0, '127.0.0.1', resolve)
+    })
+    const address = reservation.address()
+    if (!address || typeof address === 'string') throw new Error('missing test port')
+    await new Promise<void>((resolve, reject) =>
+      reservation.close((error) => (error ? reject(error) : resolve()))
+    )
+
+    const app = new Hono().get('/peer', (context) =>
+      context.text(context.req.header('x-vxrn-peer-address') || '')
+    )
+    const running = honoServeNode(app, { host: '127.0.0.1', port: address.port })
+    await new Promise<void>((resolve, reject) => {
+      const startedAt = Date.now()
+      const probe = async () => {
+        try {
+          const response = await fetch(`http://127.0.0.1:${address.port}/peer`, {
+            headers: { 'x-vxrn-peer-address': '203.0.113.9' },
+          })
+          expect(await response.text()).toBe('127.0.0.1')
+          resolve()
+        } catch (error) {
+          if (Date.now() - startedAt > 2_000) reject(error)
+          else setTimeout(probe, 20)
+        }
+      }
+      void probe()
+    })
+    const shutdown = process.listeners('SIGTERM').at(-1)
+    expect(shutdown).toBeTypeOf('function')
+    shutdown?.('SIGTERM')
+    await running
+  })
+})

package/src/serve/node.ts

@@ -1,8 +1,6 @@
-import { createServer, type Server } from 'node:http'
+import { createServer } from 'node:http'
 import { networkInterfaces, platform } from 'node:os'
 import { getRequestListener } from '@hono/node-server'
-import { serve as honoServe } from '@hono/node-server'
-import type { ServerType } from '@hono/node-server'
 import type { Hono } from 'hono'
 import colors from 'picocolors'
 import type { VXRNServeOptions } from '../types'
@@ -35,21 +33,20 @@ export async function honoServeNode(app: Hono, options: VXRNServeOptions) {
   const port = options.port ?? 3000
   const host = options.host ?? '0.0.0.0'
 
-  let server: Server | ServerType
-
-  if (canReusePort) {
-    // bypass @hono/node-server's serve() to use reusePort directly
-    // kernel distributes connections across workers - no IPC bottleneck
-    const listener = getRequestListener(app.fetch)
-    server = createServer(listener)
-    server.listen({ port, host, reusePort: true })
-  } else {
-    server = honoServe({
-      fetch: app.fetch,
-      port,
-      hostname: host,
-    })
-  }
+  const listener = getRequestListener((request, env) => {
+    request.headers.delete('x-vxrn-peer-address')
+    const address = env.incoming.socket.remoteAddress
+    if (address) request.headers.set('x-vxrn-peer-address', address)
+    return app.fetch(request, env)
+  })
+  const server = createServer(listener)
+  server.listen({
+    port,
+    host,
+    ...(canReusePort && process.env.ONE_CLUSTER_WORKER === '1'
+      ? { reusePort: true }
+      : {}),
+  })
 
   const colorUrl = (url: string) =>
     colors.cyan(url.replace(/:(\d+)\//, (_, port) => `:${colors.bold(port)}/`))
@@ -71,17 +68,16 @@ export async function honoServeNode(app: Hono, options: VXRNServeOptions) {
   }
   console.info()
 
-  const shutdown = () => {
-    server.close(() => {
-      process.exit(0)
-    })
-  }
+  const shutdown = () => server.close()
 
-  process.on('SIGINT', shutdown)
-  process.on('SIGTERM', shutdown)
+  process.once('SIGINT', shutdown)
+  process.once('SIGTERM', shutdown)
 
-  await new Promise<void>((res) => {
+  await new Promise<void>((res, rej) => {
+    server.once('error', rej)
     server.on('close', () => {
+      process.off('SIGINT', shutdown)
+      process.off('SIGTERM', shutdown)
       res()
     })
   })

package/src/utils/state.ts

@@ -1,4 +1,6 @@
 import FSExtra from 'fs-extra'
+import { randomUUID } from 'node:crypto'
+import { rename, rm } from 'node:fs/promises'
 import { join } from 'node:path'
 
 type State = {
@@ -20,6 +22,12 @@ export async function readState(cacheDir: string) {
 
 export async function writeState(cacheDir: string, state: State) {
   const statePath = join(cacheDir, 'state.json')
+  const pendingStatePath = `${statePath}.${process.pid}.${randomUUID()}.tmp`
   await FSExtra.ensureDir(cacheDir)
-  await FSExtra.writeJSON(statePath, state)
+  try {
+    await FSExtra.writeJSON(pendingStatePath, state)
+    await rename(pendingStatePath, statePath)
+  } finally {
+    await rm(pendingStatePath, { force: true })
+  }
 }

package/types/config/getOptionsFilled.d.ts

@@ -54,6 +54,7 @@ export declare function fillOptions(options: VXRNOptions, { mode }?: {
     };
     readonly packageRootDir: string;
     readonly cacheDir: string;
+    readonly versionHash: string;
     readonly skipEnv?: boolean;
     readonly build?: {
         server?: boolean | import("..").VXRNBuildOptions;
@@ -86,6 +87,7 @@ export declare function getOptionsFilled(): {
     };
     readonly packageRootDir: string;
     readonly cacheDir: string;
+    readonly versionHash: string;
     readonly skipEnv?: boolean;
     readonly build?: {
         server?: boolean | import("..").VXRNBuildOptions;

package/types/config/getOptionsFilled.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getOptionsFilled.d.ts","sourceRoot":"","sources":["../../src/config/getOptionsFilled.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAOjD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC,CAAA;AAIvE,wBAAsB,WAAW,CAC/B,OAAO,EAAE,WAAW,EACpB,EAAE,IAAY,EAAE,GAAE;IAAE,IAAI,CAAC,EAAE,IAAI,CAAA;CAAO;;;;;;;;;;;;;;;;;;;;;;;;;;cAelC,CAAN;eAME,CADF;;;;GA+CC;AAED,wBAAgB,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;cAtD1B,CAAN;eAME,CADF;;;;SAmDC"}
+{"version":3,"file":"getOptionsFilled.d.ts","sourceRoot":"","sources":["../../src/config/getOptionsFilled.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAOjD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC,CAAA;AAIvE,wBAAsB,WAAW,CAC/B,OAAO,EAAE,WAAW,EACpB,EAAE,IAAY,EAAE,GAAE;IAAE,IAAI,CAAC,EAAE,IAAI,CAAA;CAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;cAgB9B,CAAR;eAKQ,CAAC;;;;GA4CV;AAED,wBAAgB,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;cAnDtB,CAAR;eAKQ,CAAC;;;;SAgDV"}

package/types/exports/build.d.ts

@@ -29,6 +29,7 @@ export declare const build: (optionsIn: VXRNOptions, buildArgs?: BuildArgs) => P
         };
         readonly packageRootDir: string;
         readonly cacheDir: string;
+        readonly versionHash: string;
         readonly skipEnv?: boolean;
         readonly build?: {
             server?: boolean | import("..").VXRNBuildOptions;

package/types/exports/build.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/exports/build.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAkB,MAAM,UAAU,CAAA;AAaxE,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAuBtD,eAAO,MAAM,KAAK,GAAU,WAAW,WAAW,EAAE,YAAW,SAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAiDrE,CAAN;mBAKsE,CAAC;;;;;;;;;;;;EA4SxE,CAAA"}
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/exports/build.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAkB,MAAM,UAAU,CAAA;AAaxE,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAuBtD,eAAO,MAAM,KAAK,GAAU,WAAW,WAAW,EAAE,YAAW,SAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAiDrE,CAAN;mBAKsE,CAAC;;;;;;;;;;;;EA4SxE,CAAA"}

package/types/exports/clean.d.ts

@@ -1,12 +1,9 @@
 import type { VXRNOptions } from '../types';
-/**
- * The main entry point for dev mode
- *
- * Note that much of the logic is being run by plugins:
- *
- *  - createFileSystemRouterPlugin does most of the fs-routes/request handling
- *  - clientTreeShakePlugin handles loaders/transforms
- *
- */
+export declare function prepareCacheForVersion({ root, cacheDir, versionHash, forceClean, }: {
+    root: string;
+    cacheDir: string;
+    versionHash: string;
+    forceClean?: boolean;
+}): Promise<boolean>;
 export declare const clean: (rest: VXRNOptions, only?: "vite") => Promise<void>;
 //# sourceMappingURL=clean.d.ts.map

package/types/exports/clean.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clean.d.ts","sourceRoot":"","sources":["../../src/exports/clean.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAK3C;;;;;;;;GAQG;AAEH,eAAO,MAAM,KAAK,GAAU,MAAM,WAAW,EAAE,OAAO,MAAM,kBAyB3D,CAAA"}
+{"version":3,"file":"clean.d.ts","sourceRoot":"","sources":["../../src/exports/clean.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAuF3C,wBAAsB,sBAAsB,CAAC,EAC3C,IAAI,EACJ,QAAQ,EACR,WAAW,EACX,UAAkB,GACnB,EAAE;IACD,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB,oBAeA;AAED,eAAO,MAAM,KAAK,GAAU,MAAM,WAAW,EAAE,OAAO,MAAM,kBAG3D,CAAA"}

package/types/exports/clean.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clean.test.d.ts","sourceRoot":"","sources":["../../src/exports/clean.test.ts"],"names":[],"mappings":""}

package/types/exports/dev.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../src/exports/dev.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAkB3C,MAAM,MAAM,UAAU,GAAG,WAAW,GAAG;IACrC,KAAK,CAAC,EAAE,OAAO,CAAA;IACf;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,CAAA;AAED,eAAO,MAAM,GAAG,GAAU,WAAW,UAAU;;;;;;EAsL9C,CAAA"}
+{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../src/exports/dev.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAkB3C,MAAM,MAAM,UAAU,GAAG,WAAW,GAAG;IACrC,KAAK,CAAC,EAAE,OAAO,CAAA;IACf;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,CAAA;AAED,eAAO,MAAM,GAAG,GAAU,WAAW,UAAU;;;;;;EA2L9C,CAAA"}

package/types/serve/node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../src/serve/node.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,MAAM,CAAA;AAEhC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAgBhD,QAAA,MAAM,YAAY,SAMT,CAAA;AAET,OAAO,EAAE,YAAY,EAAE,CAAA;AAEvB,wBAAsB,aAAa,CAAC,GAAG,EAAE,IAAI,EAAE,OAAO,EAAE,gBAAgB,iBAsDvE"}
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../src/serve/node.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,MAAM,CAAA;AAEhC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAgBhD,QAAA,MAAM,YAAY,SAMT,CAAA;AAET,OAAO,EAAE,YAAY,EAAE,CAAA;AAEvB,wBAAsB,aAAa,CAAC,GAAG,EAAE,IAAI,EAAE,OAAO,EAAE,gBAAgB,iBAoDvE"}

package/types/serve/node.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.test.d.ts","sourceRoot":"","sources":["../../src/serve/node.test.ts"],"names":[],"mappings":""}

package/types/utils/state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../src/utils/state.ts"],"names":[],"mappings":"AAGA,KAAK,KAAK,GAAG;IACX,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,CAAA;AAED,wBAAsB,SAAS,CAAC,QAAQ,EAAE,MAAM,kBAW/C;AAED,wBAAsB,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,iBAI9D"}
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../src/utils/state.ts"],"names":[],"mappings":"AAKA,KAAK,KAAK,GAAG;IACX,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,CAAA;AAED,wBAAsB,SAAS,CAAC,QAAQ,EAAE,MAAM,kBAW/C;AAED,wBAAsB,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,iBAU9D"}