vxrn 2.8.1 → 2.9.1

package/src/exports/clean.ts

@@ -1,4 +1,5 @@
-import { mkdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { mkdir, readFile, rm, stat, writeFile } from 'node:fs/promises'
+import { createServer, type Server } from 'node:net'
 import { dirname, join } from 'node:path'
 import type { VXRNOptions } from '../types'
 import { fillOptions } from '../config/getOptionsFilled'
@@ -15,40 +16,196 @@ function getErrorCode(err: unknown) {
   }
 }
 
-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 })
+// test knob in the same vein as VXRN_DONT_CLEAN_SELF: shorten the 60s
+// acquisition timeout so failure-path cleanup is provable without a
+// minute-long test. production callers never set it.
+function getCleanLockTimeoutMs(): number {
+  const override = Number.parseInt(process.env.VXRN_CLEAN_LOCK_TIMEOUT_MS ?? '', 10)
+  if (Number.isSafeInteger(override) && override > 0) {
+    return override
+  }
+  return CLEAN_LOCK_TIMEOUT_MS
+}
+
+// well clear of dev ports (3000/5173/8081/19000s) and the ephemeral ranges,
+// so a foreign occupant is only ever a hash collision with another vxrn root
+const CLEAN_LOCK_PORT_BASE = 24_000
+const CLEAN_LOCK_PORT_COUNT = 1_000
+
+// canonical ownership identity: device and inode of the lock directory, so
+// every pathname spelling of the same physical cache (symlinks, dot
+// segments, case variants, bind mounts) shares one mutex port. hashing the
+// raw pathname would let aliases acquire simultaneously.
+async function getCacheCleanLockPort(lockDir: string): Promise<number> {
+  const info = await stat(lockDir)
+  let hash = 0x811c9dc5
+  const identity = `${info.dev}:${info.ino}`
+  for (let index = 0; index < identity.length; index++) {
+    hash ^= identity.charCodeAt(index)
+    hash = Math.imul(hash, 0x01000193)
+  }
+  return CLEAN_LOCK_PORT_BASE + (hash >>> 0) % CLEAN_LOCK_PORT_COUNT
+}
+
+// only ESRCH means the owner is gone, any other failure keeps the lock safe
+// by treating it as live (same semantics as processExists in dev.ts)
+function isLockOwnerAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch (err) {
+    return getErrorCode(err) !== 'ESRCH'
+  }
+}
+
+// legacy file content is pid-only; anything else is an unknown owner that
+// must be waited on, never removed
+function parseLockOwnerPid(content: string): number | undefined {
+  const trimmed = content.trim()
+  if (!/^\d+$/.test(trimmed)) {
+    return undefined
+  }
+  const pid = Number.parseInt(trimmed, 10)
+  if (!Number.isSafeInteger(pid) || pid <= 0) {
+    return undefined
+  }
+  return pid
+}
 
+// join the legacy pid-file protocol so old-version cleaners and this cleaner
+// exclude each other. returns true when this process created the file and
+// must delete it on release. a dead owner's corpse is never deleted (that
+// read-then-unlink cannot be atomic); it only routes around file creation
+// while the port mutex below still serializes new cleaners.
+async function joinLegacyLock(
+  lockPath: string,
+  startedAt: number,
+  timeoutMs: number
+): Promise<boolean> {
   while (true) {
     try {
       await writeFile(lockPath, `${process.pid}\n`, { flag: 'wx' })
-      break
+      return true
     } 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}`)
+    let content: string
+    try {
+      content = await readFile(lockPath, 'utf8')
+    } catch (err) {
+      if (getErrorCode(err) === 'ENOENT') {
+        continue
       }
-      await new Promise<void>((resolve) => setTimeout(resolve, CLEAN_LOCK_WAIT_MS))
+      throw err
     }
+
+    const pid = parseLockOwnerPid(content)
+    if (pid !== undefined && !isLockOwnerAlive(pid)) {
+      return false
+    }
+    if (Date.now() - startedAt >= timeoutMs) {
+      const owner = pid === undefined ? 'unknown process' : `process ${pid}`
+      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))
+  }
+}
+
+function tryListen(server: Server, port: number): Promise<NodeJS.ErrnoException | undefined> {
+  return new Promise((resolve) => {
+    server.once('error', (err: Error) => resolve(err as NodeJS.ErrnoException))
+    server.once('listening', () => resolve(undefined))
+    server.listen({ port, host: '127.0.0.1', exclusive: true })
+  })
+}
+
+// ownership is an exclusive loopback listen, which the kernel grants
+// atomically and frees on any holder death. live and unknown legacy owners
+// are respected by the file phase above; the port serializes new cleaners
+// even past a dead owner's corpse, which no participant ever deletes.
+async function acquirePortLock(
+  port: number,
+  startedAt: number,
+  timeoutMs: number
+): Promise<() => Promise<void>> {
+  while (true) {
+    // fresh server per attempt, same shape as the daemon port probe.
+    // ordinary connections are rejected at once so a stray client can never
+    // strand release: under node an accepted connection otherwise keeps the
+    // close callback pending.
+    const server = createServer((socket) => {
+      socket.on('error', () => {})
+      socket.destroy()
+    })
+    const err = await tryListen(server, port)
+    if (!err) {
+      // held referenced until release so the loop cannot exit mid-hold
+      return async () => {
+        await new Promise<void>((resolve) => {
+          server.close(() => resolve())
+        })
+      }
+    }
+
+    if (getErrorCode(err) !== 'EADDRINUSE') {
+      throw err
+    }
+    if (Date.now() - startedAt >= timeoutMs) {
+      throw new Error(`Timed out waiting for VXRN cache cleanup lock (127.0.0.1:${port})`)
+    }
+    await new Promise<void>((resolve) => setTimeout(resolve, CLEAN_LOCK_WAIT_MS))
+  }
+}
+
+// only our own participation file is removed, and only while it still
+// carries our pid; a replacement is never touched. the read-then-remove
+// cannot hit a replacement: installing one needs the path absent, and the
+// path is only absent after our own remove (or a crash, whose corpse no
+// participant ever deletes), since every participant creates with wx.
+async function removeOwnLegacyLock(lockPath: string): Promise<void> {
+  try {
+    if ((await readFile(lockPath, 'utf8')) === `${process.pid}\n`) {
+      await rm(lockPath, { force: true })
+    }
+  } catch (err) {
+    if (getErrorCode(err) !== 'ENOENT') {
+      throw err
+    }
+  }
+}
+
+async function withCacheCleanLock<T>(cacheDir: string, action: () => Promise<T>) {
+  const lockDir = dirname(cacheDir)
+  const lockPath = join(lockDir, '.vxrn-clean.lock')
+  const startedAt = Date.now()
+  const timeoutMs = getCleanLockTimeoutMs()
+  await mkdir(lockDir, { recursive: true })
+  const created = await joinLegacyLock(lockPath, startedAt, timeoutMs)
+
+  let releasePort: () => Promise<void>
+  try {
+    releasePort = await acquirePortLock(await getCacheCleanLockPort(lockDir), startedAt, timeoutMs)
+  } catch (err) {
+    if (created) {
+      try {
+        await removeOwnLegacyLock(lockPath)
+      } catch {
+        // acquisition already failed; the original error stays actionable
+      }
+    }
+    throw err
   }
 
   try {
     return await action()
   } finally {
-    await rm(lockPath, { force: true })
+    await releasePort()
+    if (created) {
+      await removeOwnLegacyLock(lockPath)
+    }
   }
 }
 

package/src/exports/expoPlugin.test.mjs

@@ -48,7 +48,7 @@ describe('vxrn Expo project patches', () => {
   it('keeps WebGPU header resolution inside its own CocoaPods target', () => {
     const generated = patches.injectWebGPUHeaderPathsIntoPodfile(podfile)
     expect(patches.injectWebGPUHeaderPathsIntoPodfile(generated)).toBe(generated)
-    const result = JSON.parse(execFileSync('ruby', ['-rjson', '-e', `
+    const result = JSON.parse(execFileSync('ruby', ['--disable-gems', '-rjson', '-e', `
       Config = Struct.new(:build_settings)
       Target = Struct.new(:name, :build_configurations)
       Project = Struct.new(:targets)
@@ -147,10 +147,53 @@ function expoProject() {
     join(scopedDirectory, 'config-plugins'),
     'dir'
   )
+  // the plugin writes the sdk bindings with the app's one package
+  const oneRoot = createRequire(import.meta.url).resolve('one/package.json')
+  symlinkSync(oneRoot.slice(0, -'/package.json'.length), join(projectRoot, 'node_modules', 'one'), 'dir')
   return projectRoot
 }
 
 describe('vxrn/expo-plugin', () => {
+  it('prebuilds an app without SDK imports when Xcode is unavailable', () => {
+    const projectRoot = expoProject()
+    const iosRoot = join(projectRoot, 'ios')
+    mkdirSync(iosRoot)
+    writeFileSync(join(iosRoot, 'Podfile'), podfile)
+    const output = execFileSync(process.execPath, ['--input-type=module', '-e', `
+      import withVxrn from ${JSON.stringify(new URL('../../expo-plugin.cjs', import.meta.url).href)}
+      const projectRoot = process.argv[1]
+      const config = withVxrn({ name: 'TestApp', slug: 'test-app', _internal: { projectRoot } })
+      await config.mods.ios.dangerous({
+        ...config,
+        modRequest: {
+          projectRoot, platformProjectRoot: projectRoot + '/ios',
+          platform: 'ios', modName: 'dangerous', projectName: 'TestApp', introspect: false,
+        },
+        modResults: {},
+      })
+    `, projectRoot], { env: { ...process.env, PATH: '' }, encoding: 'utf8' })
+    expect(output).toBe('')
+    expect(existsSync(join(iosRoot, 'OneSwiftPackages', 'OneSDKBindings'))).toBe(false)
+    expect(readFileSync(join(iosRoot, 'Podfile'), 'utf8')).toContain('[vxrn/one] fmt c++17 fix')
+  })
+
+  it('raises the ios deployment target to the one the One pod requires', async () => {
+    const projectRoot = expoProject()
+    const config = withVxrn({ name: 'TestApp', slug: 'test-app', _internal: { projectRoot } })
+    const run = async (modResults) =>
+      (await config.mods.ios.podfileProperties({
+        ...config,
+        modRequest: { projectRoot, platform: 'ios', modName: 'podfileProperties', projectName: 'TestApp', introspect: false },
+        modResults,
+      })).modResults['ios.deploymentTarget']
+    const { minimumVersion } = JSON.parse(
+      readFileSync(join(projectRoot, 'node_modules/one/schema.json'), 'utf8')
+    )
+    expect(await run({})).toBe(`${minimumVersion}.0`)
+    expect(await run({ 'ios.deploymentTarget': '16.4' })).toBe(`${minimumVersion}.0`)
+    expect(await run({ 'ios.deploymentTarget': '99.0' })).toBe('99.0')
+  })
+
   it('combines background location and audio modes', async () => {
     const projectRoot = expoProject()
     const config = withVxrn(

package/src/exports/prebuild.ts

@@ -20,11 +20,15 @@ export const prebuild = async ({
   platform,
   'no-install': noInstall = false,
   app,
+  beforeInstall,
 }: {
   root: string
   platform?: 'ios' | 'android' | string
   'no-install'?: boolean
   app: PrebuildAppConfig
+  // runs once the native projects exist and before discovery and install, so
+  // a caller can add local pods the podfile picks up
+  beforeInstall?: () => Promise<void>
 }) => {
   validatePrebuildApp(app, platform)
 
@@ -67,6 +71,8 @@ export const prebuild = async ({
     await generateForPlatform(root, 'android', app)
   }
 
+  await beforeInstall?.()
+
   // community config reads the generated projects, so discover after generation
   // and before installation. `--no-install` never fakes the linked package set.
   const inventory = await getNativeDependencyInventory(root)

package/src/exports/prebuildWithoutExpo.test.ts

@@ -165,6 +165,45 @@ const APP_DELEGATE_PBXPROJ = `		761780EF2CA45674006654EF /* SceneDelegate.swift
 \t\t\t\tINFOPLIST_FILE = HelloWorld/Info.plist;`
 
 describe('template rendering', () => {
+  it.each(['/', '\\'])('remaps Android package paths using %s separators', (separator) => {
+    for (const file of ['MainActivity.kt', 'MainApplication.kt']) {
+      expect(
+        renderPrebuildFile({
+          relativePath: ['app', 'src', 'main', 'java', 'com', 'helloworld', file].join(separator),
+          content: 'package com.helloworld\n',
+          platform: 'android',
+          app: {
+            name: 'OneBasic',
+            android: { applicationId: 'dev.onestack.starter' },
+          },
+        })
+      ).toEqual({
+        destRelativePath: `app/src/main/java/dev/onestack/starter/${file}`,
+        content: 'package dev.onestack.starter\n',
+      })
+    }
+  })
+
+  it.each(['/', '\\'])('stamps platform files using %s separators', (separator) => {
+    const manifest = renderPrebuildFile({
+      relativePath: ['app', 'src', 'main', 'AndroidManifest.xml'].join(separator),
+      content: '<manifest>\n<uses-permission android:name="android.permission.INTERNET" />\n</manifest>',
+      platform: 'android',
+      app: { name: 'OneBasic', android: { applicationId: 'dev.onestack.starter', permissions: ['CAMERA'] } },
+    })
+    expect(manifest.destRelativePath).toBe('app/src/main/AndroidManifest.xml')
+    expect(manifest.content).toContain('<uses-permission android:name="android.permission.CAMERA" />')
+
+    const plist = renderPrebuildFile({
+      relativePath: ['HelloWorld', 'Info.plist'].join(separator),
+      content: '<dict>\n\t<key>LSRequiresIPhoneOS</key>\n</dict>',
+      platform: 'ios',
+      app: { name: 'OneBasic', scheme: 'onebasic', ios: { bundleId: 'dev.onestack.starter' } },
+    })
+    expect(plist.destRelativePath).toBe('OneBasic/Info.plist')
+    expect(plist.content).toContain('<string>onebasic</string>')
+  })
+
   it('applies names, ids, and platform versions', () => {
     const ios = renderPrebuildFile({
       relativePath: 'HelloWorld.xcodeproj/project.pbxproj',
@@ -1510,12 +1549,13 @@ describe('generateForPlatform determinism', () => {
     const appWithIcon = {
       ...app,
       version: '9.9.9',
-      ios: { ...app.ios, buildNumber: '4242', tablet: true, alternateIcons: {
+      alternateIcons: {
         TestAlternate: {
           source: fileURLToPath(new URL('../../../../examples/one-basic/public/app-icon.png', import.meta.url)),
           backgroundColor: '#123456',
         },
-      } },
+      },
+      ios: { ...app.ios, buildNumber: '4242', tablet: true },
       android: {
         ...app.android,
         versionCode: 4242,
@@ -1627,6 +1667,39 @@ describe('generateForPlatform determinism', () => {
       )
     ).metadata()
     expect(androidIcon).toMatchObject({ width: 192, height: 192 })
+    // the picker previews ship as plain resources on both platforms
+    expect(
+      await sharp(
+        join(output, 'android', 'app', 'src', 'main', 'res', 'drawable-nodpi', 'app_icon_preview_test_alternate.png')
+      ).metadata()
+    ).toMatchObject({ width: 192, height: 192 })
+    expect(
+      await sharp(
+        join(output, 'ios', 'MyApp', 'Images.xcassets', 'AppIconPreviewPrimary.imageset', 'preview@2x.png')
+      ).metadata()
+    ).toMatchObject({ width: 128, height: 128 })
+    // alternate icons become launcher aliases that forward into the host
+    const androidMain = join(output, 'android', 'app', 'src', 'main')
+    const manifest = readFileSync(join(androidMain, 'AndroidManifest.xml'), 'utf8')
+    const hostActivity = manifest.match(/<activity\b[^>]*android:name="\.MainActivity"[\s\S]*?<\/activity>/)?.[0]
+    expect(hostActivity).toBeDefined()
+    expect(hostActivity).not.toContain('category.LAUNCHER')
+    expect(manifest).toMatch(
+      /<activity-alias\s+android:name="\.Primary"\s+android:targetActivity="\.AppIconLauncherActivity"\s+android:enabled="true"/
+    )
+    expect(manifest).toMatch(
+      /<activity-alias\s+android:name="\.TestAlternate"\s+android:targetActivity="\.AppIconLauncherActivity"\s+android:enabled="false"[^>]*android:icon="@mipmap\/ic_launcher_test_alternate"/
+    )
+    expect(manifest.match(/category\.LAUNCHER/g)).toHaveLength(2)
+    expect(
+      readFileSync(
+        join(androidMain, 'java', 'dev', 'one', 'myapp', 'AppIconLauncherActivity.kt'),
+        'utf8'
+      )
+    ).toContain('setClass(this, MainActivity::class.java)')
+    expect(
+      await sharp(join(androidMain, 'res', 'mipmap-xxxhdpi', 'ic_launcher_test_alternate_round.png')).metadata()
+    ).toMatchObject({ width: 192, height: 192 })
     const iosApp = join(output, 'ios', 'MyApp')
     // contained artwork is drawn at its launch width in points, at 1x to 3x
     for (const [filename, width] of [
@@ -2911,3 +2984,62 @@ dependencies {
     expect(readFileSync(appGradle, 'utf8')).toBe(updated)
   })
 })
+
+describe('ios 18 icon appearances', () => {
+  it('writes dark and tinted entries beside the light icon', async () => {
+    const workspaceRoot = fileURLToPath(new URL('../../../..', import.meta.url))
+    const output = mkdtempSync(join(tmpdir(), 'vxrn-prebuild-appearances-'))
+    const art = fileURLToPath(
+      new URL('../../../../examples/one-basic/public/app-icon.png', import.meta.url)
+    )
+    await generateForPlatform(
+      workspaceRoot,
+      'ios',
+      {
+        ...app,
+        icon: {
+          source: art,
+          backgroundColor: '#336699',
+          dark: { backgroundColor: '#101820' },
+          tinted: {},
+        },
+      },
+      join(output, 'ios')
+    )
+    const dir = join(output, 'ios', 'MyApp', 'Images.xcassets', 'AppIcon.appiconset')
+    const contents: { images: Array<Record<string, unknown>> } = JSON.parse(
+      readFileSync(join(dir, 'Contents.json'), 'utf8')
+    )
+    expect(contents.images).toEqual([
+      { filename: 'icon-1024.png', idiom: 'universal', platform: 'ios', size: '1024x1024' },
+      {
+        appearances: [{ appearance: 'luminosity', value: 'dark' }],
+        filename: 'icon-1024-dark.png',
+        idiom: 'universal',
+        platform: 'ios',
+        size: '1024x1024',
+      },
+      {
+        appearances: [{ appearance: 'luminosity', value: 'tinted' }],
+        filename: 'icon-1024-tinted.png',
+        idiom: 'universal',
+        platform: 'ios',
+        size: '1024x1024',
+      },
+    ])
+    for (const file of ['icon-1024.png', 'icon-1024-dark.png', 'icon-1024-tinted.png']) {
+      expect(await sharp(join(dir, file)).metadata()).toMatchObject({
+        width: 1024,
+        height: 1024,
+      })
+    }
+    // the tinted layer is gray: equal channels at the center pixel
+    const { data } = await sharp(join(dir, 'icon-1024-tinted.png'))
+      .removeAlpha()
+      .extract({ left: 512, top: 512, width: 1, height: 1 })
+      .raw()
+      .toBuffer({ resolveWithObject: true })
+    expect(data[0]).toBe(data[1])
+    expect(data[1]).toBe(data[2])
+  })
+})