@open-mercato/cli 0.6.4-develop.4382.1.6b4f656b77 → 0.6.4

package/src/lib/deploy/railway/source.ts

@@ -0,0 +1,143 @@
+import { execFileSync } from 'node:child_process'
+import { existsSync, readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+import type { RailwaySource, RailwaySourceMode } from './types'
+
+type CommandRunner = (command: string, args: string[], cwd: string) => string
+
+const defaultRunner: CommandRunner = (command, args, cwd) =>
+  execFileSync(command, args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim()
+
+function tryRun(runner: CommandRunner, command: string, args: string[], cwd: string): string | null {
+  try {
+    return runner(command, args, cwd)
+  } catch {
+    return null
+  }
+}
+
+export function normalizeGitRepository(remoteUrl: string): string | null {
+  const trimmed = remoteUrl.trim().replace(/\.git$/, '')
+  const sshMatch = trimmed.match(/^git@github\.com:([^/]+\/[^/]+)$/)
+  if (sshMatch) return sshMatch[1] ?? null
+  try {
+    const parsed = new URL(trimmed)
+    if (parsed.hostname !== 'github.com') return null
+    return parsed.pathname.replace(/^\/+/, '') || null
+  } catch {
+    return null
+  }
+}
+
+export function inspectGitSource(cwd: string, runner: CommandRunner = defaultRunner): RailwaySource | null {
+  const branch = tryRun(runner, 'git', ['branch', '--show-current'], cwd)
+  const remoteUrl = tryRun(runner, 'git', ['remote', 'get-url', 'origin'], cwd)
+  if (!branch || !remoteUrl) return null
+  const repo = normalizeGitRepository(remoteUrl)
+  if (!repo) return null
+  const commitSha = tryRun(runner, 'git', ['rev-parse', 'HEAD'], cwd) ?? undefined
+  return {
+    mode: 'git',
+    reason: `GitHub remote origin and branch ${branch} detected`,
+    repo,
+    branch,
+    commitSha,
+  }
+}
+
+export function assertGitDeployReady(cwd: string, runner: CommandRunner = defaultRunner): void {
+  const status = tryRun(runner, 'git', ['status', '--porcelain'], cwd)
+  if (status === null) throw new Error('Git is required for --source git.')
+  if (status.length > 0) throw new Error('Git-backed deploy requires a clean working tree.')
+  const upstream = tryRun(runner, 'git', ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'], cwd)
+  if (!upstream) throw new Error('The current branch has no upstream. Push it before a Git-backed deploy.')
+  const ahead = tryRun(runner, 'git', ['rev-list', '--count', '@{u}..HEAD'], cwd)
+  if (ahead === null || Number.parseInt(ahead, 10) > 0) {
+    throw new Error('The current branch has local commits that are not pushed to its upstream.')
+  }
+  const behind = tryRun(runner, 'git', ['rev-list', '--count', 'HEAD..@{u}'], cwd)
+  if (behind === null || Number.parseInt(behind, 10) > 0) {
+    throw new Error('The current branch is behind its upstream. Pull the latest commits before a Git-backed deploy.')
+  }
+}
+
+export function isRailwayCliAvailable(cwd: string, runner: CommandRunner = defaultRunner): boolean {
+  return tryRun(runner, 'railway', ['--version'], cwd) !== null
+}
+
+export function resolveRailwaySource(
+  mode: RailwaySourceMode,
+  cwd: string,
+  runner: CommandRunner = defaultRunner,
+): RailwaySource {
+  const gitSource = inspectGitSource(cwd, runner)
+  if (mode === 'git') {
+    if (!gitSource) {
+      throw new Error('--source git requires a GitHub origin remote and a current branch.')
+    }
+    assertGitDeployReady(cwd, runner)
+    return gitSource
+  }
+  if (mode === 'local') {
+    if (!isRailwayCliAvailable(cwd, runner)) {
+      throw new Error('--source local requires the Railway CLI. Install it from https://docs.railway.com/reference/cli-api.')
+    }
+    return { mode: 'local', reason: 'Local upload explicitly requested' }
+  }
+  if (gitSource) {
+    try {
+      assertGitDeployReady(cwd, runner)
+      return gitSource
+    } catch (error) {
+      if (!isRailwayCliAvailable(cwd, runner)) throw error
+      const reason = error instanceof Error ? error.message : 'Git source is not deployable'
+      return {
+        mode: 'local',
+        reason: `${reason} Falling back to railway up.`,
+      }
+    }
+  }
+  if (!isRailwayCliAvailable(cwd, runner)) {
+    throw new Error('No usable GitHub remote found and the Railway CLI is unavailable for local upload.')
+  }
+  return { mode: 'local', reason: 'No usable GitHub remote found; falling back to railway up' }
+}
+
+const REQUIRED_IGNORE_ENTRIES = [
+  { label: '.env', matches: (line: string) => line === '.env' || line === '.env*' },
+  { label: '.env.*', matches: (line: string) => line === '.env.*' || line === '.env*' },
+  { label: '*.pem', matches: (line: string) => line === '*.pem' },
+  { label: '*.key', matches: (line: string) => line === '*.key' },
+  { label: 'id_rsa', matches: (line: string) => line === 'id_*' || line === 'id_rsa' },
+  { label: 'id_ed25519', matches: (line: string) => line === 'id_*' || line === 'id_ed25519' },
+  { label: '.git', matches: (line: string) => line === '.git' },
+  { label: '.railway', matches: (line: string) => line === '.railway' },
+  { label: 'node_modules', matches: (line: string) => line === 'node_modules' },
+  { label: '.yarn/cache', matches: (line: string) => line === '.yarn/cache' },
+  { label: '.next', matches: (line: string) => line === '.next' },
+  { label: '.turbo', matches: (line: string) => line === '.turbo' },
+  { label: '*.db', matches: (line: string) => line === '*.db' },
+  { label: '*.sqlite', matches: (line: string) => line === '*.sqlite' || line === '*.sqlite*' },
+  { label: '*.sqlite3', matches: (line: string) => line === '*.sqlite3' || line === '*.sqlite*' },
+  { label: '.mercato/railway.json', matches: (line: string) =>
+    line === '.mercato/railway.json' || line === '.mercato/railway.json*' },
+  { label: '.mercato/railway.json.local', matches: (line: string) =>
+    line === '.mercato/railway.json.local' || line === '.mercato/railway.json*' },
+]
+
+export function assertLocalUploadSafe(cwd: string): void {
+  const ignorePath = resolve(cwd, '.railwayignore')
+  if (!existsSync(ignorePath)) {
+    throw new Error('Local Railway upload requires a .railwayignore file.')
+  }
+  const entries = readFileSync(ignorePath, 'utf8')
+    .split(/\r?\n/)
+    .map((line) => line.trim().replace(/^\/+|\/+$/g, ''))
+    .filter((line) => line.length > 0 && !line.startsWith('#') && !line.startsWith('!'))
+  const missing = REQUIRED_IGNORE_ENTRIES
+    .filter((requirement) => !entries.some(requirement.matches))
+    .map((requirement) => requirement.label)
+  if (missing.length > 0) {
+    throw new Error(`.railwayignore is missing required safety entries: ${missing.join(', ')}`)
+  }
+}

package/src/lib/deploy/railway/state.ts

@@ -0,0 +1,45 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs'
+import { dirname, resolve } from 'node:path'
+import type { RailwayState } from './types'
+
+export function railwayStatePath(cwd: string, track: boolean): string {
+  return resolve(cwd, '.mercato', track ? 'railway.json' : 'railway.json.local')
+}
+
+function isRailwayState(value: unknown): value is RailwayState {
+  if (!value || typeof value !== 'object') return false
+  const record = value as Record<string, unknown>
+  return (
+    record.schemaVersion === 1 &&
+    record.provider === 'railway' &&
+    typeof record.projectName === 'string' &&
+    typeof record.environments === 'object' &&
+    record.environments !== null
+  )
+}
+
+export function loadRailwayState(path: string): RailwayState | null {
+  if (!existsSync(path)) return null
+  const parsed: unknown = JSON.parse(readFileSync(path, 'utf8'))
+  if (!isRailwayState(parsed)) {
+    throw new Error(`Unsupported or invalid Railway state file: ${path}`)
+  }
+  return parsed
+}
+
+export function createRailwayState(projectName: string, cliVersion: string): RailwayState {
+  return {
+    schemaVersion: 1,
+    provider: 'railway',
+    projectName,
+    environments: {},
+    writtenBy: { cliVersion },
+  }
+}
+
+export function saveRailwayState(path: string, state: RailwayState): void {
+  mkdirSync(dirname(path), { recursive: true })
+  const temporaryPath = `${path}.tmp`
+  writeFileSync(temporaryPath, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 })
+  renameSync(temporaryPath, path)
+}

package/src/lib/deploy/railway/token.ts

@@ -0,0 +1,49 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { dirname, join } from 'node:path'
+
+export function railwayTokenConfigPath(
+  environment: NodeJS.ProcessEnv = process.env,
+  platform: NodeJS.Platform = process.platform,
+): string {
+  if (platform === 'win32') {
+    return join(environment.APPDATA || join(homedir(), 'AppData', 'Roaming'), 'open-mercato', 'railway.json')
+  }
+  return join(environment.XDG_CONFIG_HOME || join(homedir(), '.config'), 'open-mercato', 'railway.json')
+}
+
+export function readCachedRailwayToken(path: string, platform: NodeJS.Platform = process.platform): string | null {
+  if (!existsSync(path)) return null
+  if (platform !== 'win32') {
+    const mode = statSync(path).mode & 0o777
+    if ((mode & 0o077) !== 0) {
+      throw new Error(`Refusing to read ${path}: permissions must be 0600.`)
+    }
+  }
+  const parsed: unknown = JSON.parse(readFileSync(path, 'utf8'))
+  if (!parsed || typeof parsed !== 'object') return null
+  const token = (parsed as Record<string, unknown>).token
+  return typeof token === 'string' && token.trim() ? token.trim() : null
+}
+
+export function writeCachedRailwayToken(path: string, token: string): void {
+  mkdirSync(dirname(path), { recursive: true })
+  writeFileSync(path, `${JSON.stringify({ token }, null, 2)}\n`, { mode: 0o600 })
+  if (process.platform !== 'win32') chmodSync(path, 0o600)
+}
+
+export function resolveRailwayToken(input: {
+  flagToken?: string
+  environment?: NodeJS.ProcessEnv
+  configPath?: string
+}): { token: string | null; source: 'flag' | 'environment' | 'cache' | null } {
+  const environment = input.environment ?? process.env
+  if (input.flagToken?.trim()) return { token: input.flagToken.trim(), source: 'flag' }
+  if (environment.RAILWAY_API_TOKEN?.trim()) {
+    return { token: environment.RAILWAY_API_TOKEN.trim(), source: 'environment' }
+  }
+  const configPath = input.configPath ?? railwayTokenConfigPath(environment)
+  const cached = readCachedRailwayToken(configPath)
+  if (cached) return { token: cached, source: 'cache' }
+  return { token: null, source: null }
+}

package/src/lib/deploy/railway/types.ts

@@ -0,0 +1,87 @@
+export type RailwaySourceMode = 'auto' | 'git' | 'local'
+export type ResolvedRailwaySourceMode = Exclude<RailwaySourceMode, 'auto'>
+
+export type RailwayDeployOptions = {
+  project?: string
+  environment: string
+  service: string
+  worker: boolean
+  source: RailwaySourceMode
+  region?: string
+  envFile?: string
+  domain?: string
+  waitDomain: boolean
+  volume?: string
+  token?: string
+  nonInteractive: boolean
+  dryRun: boolean
+  cleanup: boolean
+  yes: boolean
+  writeEnv: boolean
+  track: boolean
+  forceRename: boolean
+  timeoutSeconds: number
+  allowedSecretKeys: string[]
+  verbose: boolean
+  help: boolean
+}
+
+export type RailwaySource = {
+  mode: ResolvedRailwaySourceMode
+  reason: string
+  repo?: string
+  branch?: string
+  commitSha?: string
+}
+
+export type RailwayEnvironmentState = {
+  environmentId?: string
+  appServiceId?: string
+  workerServiceId?: string
+  postgresServiceId?: string
+  redisServiceId?: string
+  domainId?: string
+  volumeId?: string
+  appUrl?: string
+  source?: RailwaySource
+  lastDeployIds?: {
+    app?: string
+    worker?: string
+  }
+}
+
+export type RailwayState = {
+  schemaVersion: 1
+  provider: 'railway'
+  projectId?: string
+  workspaceId?: string
+  projectName: string
+  environments: Record<string, RailwayEnvironmentState>
+  writtenBy: {
+    cliVersion: string
+  }
+}
+
+export type RailwayGraphqlOperation = {
+  name: string
+  query: string
+  mutation?: boolean
+}
+
+export type RailwayGraphqlClient = {
+  request<T>(operation: RailwayGraphqlOperation, variables?: Record<string, unknown>): Promise<T>
+}
+
+export type RailwayService = {
+  id: string
+  name: string
+}
+
+export type RailwayDeployment = {
+  id: string
+  status: string
+  staticUrl?: string | null
+  url?: string | null
+  serviceId?: string | null
+  environmentId?: string | null
+}

package/src/lib/generators/openapi.ts

@@ -485,6 +485,9 @@ process.stdout.write(JSON.stringify(deepClone(doc), (_, v) =>
     }
     return null
   } finally {
+    // Shut down esbuild's persistent Go service so it does not deadlock at
+    // process exit when a plugin request is still in flight.
+    try { await esbuild.stop() } catch {}
     // Clean up old files from previous tsx-based approach
     for (const file of ['_openapi-register.mjs', '_openapi-loader.mjs', '_next-stub.cjs']) {
       try { fs.unlinkSync(path.join(cacheDir, file)) } catch {}

package/src/lib/testing/__tests__/integration.test.ts

@@ -17,7 +17,10 @@ import {
   resolveAppReadyTimeoutMs,
   shouldReuseBuildArtifacts,
   acquireEphemeralRuntimeLock,
+  waitForApplicationReadiness,
 } from '../integration'
+import { EventEmitter } from 'node:events'
+import type { ChildProcess } from 'node:child_process'
 
 const CACHE_TTL_ENV_VAR = 'OM_INTEGRATION_BUILD_CACHE_TTL_SECONDS'
 const APP_READY_TIMEOUT_ENV_VAR = 'OM_INTEGRATION_APP_READY_TIMEOUT_SECONDS'
@@ -556,3 +559,79 @@ describe('integration cache and options', () => {
     }
   })
 })
+
+describe('waitForApplicationReadiness', () => {
+  const makeFakeProcess = (): ChildProcess => new EventEmitter() as unknown as ChildProcess
+  const sleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms))
+
+  it('serializes probe cycles so slow probes never pile up concurrent login attempts', async () => {
+    let inFlight = 0
+    let maxInFlight = 0
+    let loginPageCycles = 0
+
+    const fetchSpy = jest.spyOn(global, 'fetch').mockImplementation(async (input) => {
+      const url = typeof input === 'string' ? input : String(input)
+      inFlight += 1
+      maxInFlight = Math.max(maxInFlight, inFlight)
+      try {
+        // Each probe fetch is slower than the retry interval; the old race-against-a-tick loop
+        // would launch overlapping cycles here and blow past 3 concurrent in-flight requests.
+        await sleep(40)
+        const isLoginPage = url.endsWith('/login') && !url.endsWith('/api/auth/login')
+        if (isLoginPage) {
+          loginPageCycles += 1
+          if (loginPageCycles <= 2) {
+            return { status: 503, ok: false, text: async () => '' } as unknown as Response
+          }
+          return {
+            status: 200,
+            ok: true,
+            text: async () => '<!doctype html><script src="/_next/static/chunks/app.js"></script>',
+          } as unknown as Response
+        }
+        if (url.endsWith('/api/auth/login')) {
+          return { status: 200, ok: true, text: async () => JSON.stringify({ token: 'token' }) } as unknown as Response
+        }
+        if (url.includes('/api/customers/people')) {
+          return { status: 200, ok: true, text: async () => JSON.stringify({ items: [] }) } as unknown as Response
+        }
+        return { status: 200, ok: true, text: async () => '' } as unknown as Response
+      } finally {
+        inFlight -= 1
+      }
+    })
+
+    try {
+      await waitForApplicationReadiness('http://127.0.0.1:5001', makeFakeProcess(), {
+        timeoutMs: 5_000,
+        intervalMs: 5,
+        stabilizationMs: 10,
+      })
+      // One cycle issues exactly three parallel probe fetches (login page, backend login,
+      // authenticated login). Serialized cycles keep the peak at three; overlap would exceed it.
+      expect(maxInFlight).toBeLessThanOrEqual(3)
+      expect(loginPageCycles).toBeGreaterThanOrEqual(3)
+    } finally {
+      fetchSpy.mockRestore()
+    }
+  })
+
+  it('fails fast when the application process exits before becoming ready', async () => {
+    const fetchSpy = jest.spyOn(global, 'fetch').mockImplementation(async () => {
+      await sleep(20)
+      return { status: 503, ok: false, text: async () => '' } as unknown as Response
+    })
+    const fakeProcess = makeFakeProcess()
+
+    try {
+      const readiness = waitForApplicationReadiness('http://127.0.0.1:5001', fakeProcess, {
+        timeoutMs: 5_000,
+        intervalMs: 5,
+      })
+      setTimeout(() => fakeProcess.emit('exit', 1), 30)
+      await expect(readiness).rejects.toThrow(/exited before readiness check \(exit 1\)/)
+    } finally {
+      fetchSpy.mockRestore()
+    }
+  })
+})

package/src/lib/testing/__tests__/runtime-utils.test.ts

@@ -1,4 +1,48 @@
-import { redactPostgresUrl } from '../runtime-utils'
+import { createServer } from 'node:net'
+import { getFreePort, isPortAvailable, redactPostgresUrl } from '../runtime-utils'
+
+async function listen(host: string, port: number): Promise<{ close: () => Promise<void> }> {
+  return new Promise((resolve, reject) => {
+    const server = createServer()
+    server.once('error', reject)
+    server.listen(port, host, () => {
+      resolve({
+        close: () => new Promise((closeResolve, closeReject) => {
+          server.close((error) => {
+            if (error) {
+              closeReject(error)
+              return
+            }
+            closeResolve()
+          })
+        }),
+      })
+    })
+  })
+}
+
+describe('integration port helpers', () => {
+  it('treats wildcard IPv6 listeners as occupying the app port', async () => {
+    const port = await getFreePort()
+    let listener: { close: () => Promise<void> } | null = null
+
+    try {
+      listener = await listen('::', port)
+    } catch (error) {
+      const errorCode = (error as NodeJS.ErrnoException).code
+      if (errorCode === 'EAFNOSUPPORT') {
+        return
+      }
+      throw error
+    }
+
+    try {
+      await expect(isPortAvailable(port)).resolves.toBe(false)
+    } finally {
+      await listener.close()
+    }
+  })
+})
 
 describe('redactPostgresUrl', () => {
   it('redacts password in a postgres url', () => {

package/src/lib/testing/integration.ts

@@ -8,6 +8,7 @@ import path from 'node:path'
 import { createInterface, type Interface } from 'node:readline/promises'
 import { stdin as input, stdout as output } from 'node:process'
 import spawn from 'cross-spawn'
+import { fetchWithTimeout, type FetchWithTimeoutInit } from '@open-mercato/shared/lib/http/fetchWithTimeout'
 import { resolveEnvironment } from '../resolver'
 import { resolveSpawnCommand } from '../spawn'
 import { discoverIntegrationSpecFiles as discoverIntegrationSpecFilesShared } from './integration-discovery'
@@ -774,6 +775,14 @@ function delay(milliseconds: number): Promise<void> {
   })
 }
 
+// Each readiness probe fetch is bounded so a single stuck connection cannot consume the whole
+// readiness budget; on timeout it surfaces as a probe failure and the next cycle retries.
+const READINESS_PROBE_FETCH_TIMEOUT_MS = 15_000
+
+function probeFetch(input: string, init: FetchWithTimeoutInit = {}): Promise<Response> {
+  return fetchWithTimeout(input, { timeoutMs: READINESS_PROBE_FETCH_TIMEOUT_MS, ...init })
+}
+
 export function resolveBuildCacheTtlSeconds(logPrefix: string): number {
   const rawValue = process.env[BUILD_CACHE_TTL_ENV_VAR]
   if (!rawValue) {
@@ -1105,10 +1114,17 @@ export async function shouldRebuildBuildArtifacts(
 }
 
 async function getFreePort(): Promise<number> {
-  return new Promise((resolve, reject) => {
+  const tryListen = (host: string): Promise<number | null> => new Promise((resolve, reject) => {
     const server = createServer()
-    server.on('error', reject)
-    server.listen(0, '127.0.0.1', () => {
+    server.on('error', (error) => {
+      const errorCode = (error as NodeJS.ErrnoException).code
+      if (errorCode === 'EAFNOSUPPORT') {
+        resolve(null)
+        return
+      }
+      reject(error)
+    })
+    server.listen(0, host, () => {
       const address = server.address()
       if (!address || typeof address === 'string') {
         server.close()
@@ -1125,6 +1141,8 @@ async function getFreePort(): Promise<number> {
       })
     })
   })
+
+  return (await tryListen('::')) ?? await tryListen('127.0.0.1') ?? Promise.reject(new Error('Unable to allocate free port'))
 }
 
 async function isPortAvailable(port: number): Promise<boolean> {
@@ -1145,17 +1163,17 @@ async function isPortAvailable(port: number): Promise<boolean> {
     })
   })
 
-  const ipv4Availability = await canBind('127.0.0.1')
-  if (ipv4Availability === false) {
+  const wildcardIpv6Availability = await canBind('::')
+  if (wildcardIpv6Availability === false) {
     return false
   }
 
-  const ipv6Availability = await canBind('::1')
-  if (ipv6Availability === false) {
+  const ipv4Availability = await canBind('127.0.0.1')
+  if (ipv4Availability === false) {
     return false
   }
 
-  return ipv4Availability === true || ipv6Availability === true
+  return wildcardIpv6Availability === true || ipv4Availability === true
 }
 
 async function getPreferredPort(preferredPort: number): Promise<number> {
@@ -1263,7 +1281,7 @@ function isSuccessfulBrowserNavigationStatus(status: number): boolean {
 
 async function probeLoginPage(baseUrl: string): Promise<LoginPageProbeResult> {
   try {
-    const response = await fetch(`${baseUrl}/login`, {
+    const response = await probeFetch(`${baseUrl}/login`, {
       method: 'GET',
       redirect: 'manual',
     })
@@ -1309,7 +1327,7 @@ async function probeBackendLoginEndpoint(baseUrl: string): Promise<BackendLoginP
     const form = new URLSearchParams()
     form.set('email', 'integration-healthcheck@example.invalid')
     form.set('password', 'invalid-password')
-    const response = await fetch(`${baseUrl}/api/auth/login`, {
+    const response = await probeFetch(`${baseUrl}/api/auth/login`, {
       method: 'POST',
       redirect: 'manual',
       headers: {
@@ -1341,7 +1359,7 @@ async function probeAuthenticatedApi(baseUrl: string): Promise<AuthenticatedApiP
     const form = new URLSearchParams()
     form.set('email', 'admin@acme.com')
     form.set('password', 'secret')
-    const loginResponse = await fetch(`${baseUrl}/api/auth/login`, {
+    const loginResponse = await probeFetch(`${baseUrl}/api/auth/login`, {
       method: 'POST',
       redirect: 'manual',
       headers: {
@@ -1372,7 +1390,7 @@ async function probeAuthenticatedApi(baseUrl: string): Promise<AuthenticatedApiP
       }
     }
 
-    const apiResponse = await fetch(`${baseUrl}/api/customers/people?pageSize=1`, {
+    const apiResponse = await probeFetch(`${baseUrl}/api/customers/people?pageSize=1`, {
       headers: {
         Authorization: `Bearer ${token}`,
       },
@@ -1732,30 +1750,51 @@ export async function tryReuseExistingEnvironment(options: EphemeralRuntimeOptio
   }
 }
 
-async function waitForApplicationReadiness(
+export async function waitForApplicationReadiness(
   baseUrl: string,
   appProcess: ChildProcess,
-  options: { timeoutMs: number },
+  options: { timeoutMs: number; intervalMs?: number; stabilizationMs?: number },
 ): Promise<void> {
   const startTimestamp = Date.now()
-  const exitPromise = getProcessExitPromise(appProcess)
-  const readinessStabilizationMs = 600
+  const intervalMs = options.intervalMs ?? APP_READY_INTERVAL_MS
+  const readinessStabilizationMs = options.stabilizationMs ?? 600
   let lastProbe: ApplicationReadinessProbeResult | null = null
 
+  // Wrap process exit into a single never-rejecting promise so we can race it without piling up
+  // rejection handlers or losing the exit code across loop iterations.
+  let exitCode: number | null = null
+  const exitSignal = getProcessExitPromise(appProcess).then(
+    (code) => {
+      exitCode = code ?? null
+      return { exited: true as const }
+    },
+    () => {
+      exitCode = null
+      return { exited: true as const }
+    },
+  )
+  const exitError = () =>
+    new Error(`Application process exited before readiness check (exit ${exitCode ?? 'unknown'})`)
+
   while (Date.now() - startTimestamp < options.timeoutMs) {
-    const result = await Promise.race([
-      probeApplicationReadiness(baseUrl).then((probe) => ({ kind: 'probe' as const, probe })),
-      exitPromise.then((code) => ({ kind: 'exit' as const, code })),
-      delay(APP_READY_INTERVAL_MS).then(() => ({ kind: 'timeout' as const })),
+    // Run one probe cycle to completion before starting the next. Overlapping cycles (the previous
+    // race-against-a-1s-tick design) abandoned slow probes without cancelling them, so every second
+    // a fresh /api/auth/login attempt piled onto the most expensive endpoint — amplifying the very
+    // contention that delays readiness when 15 ephemeral shards boot in parallel. Each fetch is
+    // independently bounded by fetchWithTimeout, so a stuck connection cannot stall the cycle.
+    const cycle = await Promise.race([
+      probeApplicationReadiness(baseUrl).then((probe) => ({ probe })),
+      exitSignal,
     ])
 
-    if (result.kind === 'probe') {
-      lastProbe = result.probe
-      if (!result.probe.ready) {
-        continue
-      }
+    if ('exited' in cycle) {
+      throw exitError()
+    }
+
+    lastProbe = cycle.probe
+    if (cycle.probe.ready) {
       const processExited = await Promise.race([
-        exitPromise.then(() => true),
+        exitSignal.then(() => true),
         delay(readinessStabilizationMs).then(() => false),
       ])
       if (processExited) {
@@ -1763,8 +1802,15 @@ async function waitForApplicationReadiness(
       }
       return
     }
-    if (result.kind === 'exit') {
-      throw new Error(`Application process exited before readiness check (exit ${result.code ?? 'unknown'})`)
+
+    const remainingMs = options.timeoutMs - (Date.now() - startTimestamp)
+    if (remainingMs <= 0) break
+    const waited = await Promise.race([
+      exitSignal,
+      delay(Math.min(intervalMs, remainingMs)).then(() => null),
+    ])
+    if (waited && 'exited' in waited) {
+      throw exitError()
     }
   }