@open-mercato/cli 0.6.8-develop.7099.1.7ba2771d06 → 0.7.0

package/src/lib/generators/route-manifest-shards.ts

@@ -39,16 +39,9 @@ export function getRouteManifestShardKey(kind: RouteManifestShardKind, pathname:
   return firstSegment.toLowerCase()
 }
 
-function indentDeclaration(declaration: string): string {
-  return declaration
-    .split('\n')
-    .map((line) => (line.length > 0 ? `  ${line}` : line))
-    .join('\n')
-}
-
 function renderArray(entries: RouteManifestShardEntry[]): string {
   if (entries.length === 0) return '[]'
-  return `[\n${entries.map((entry) => indentDeclaration(entry.declaration)).join(',\n')}\n]`
+  return `[\n${entries.map((entry) => `  ${entry.declaration}`).join(',\n')}\n]`
 }
 
 function uniqueImports(entries: RouteManifestShardEntry[]): string[] {

package/src/lib/spawn.ts

@@ -28,22 +28,21 @@ function assertWindowsCmdSafeValue(value: string, label: string): string {
 export function resolveSpawnCommand(
   command: string,
   commandArgs: string[] = [],
-  options: { platform?: NodeJS.Platform; detached?: boolean } = {},
+  options: { platform?: NodeJS.Platform } = {},
 ): {
   command: string
   args: string[]
-  spawnOptions: { shell?: boolean; windowsVerbatimArguments?: boolean; detached?: boolean }
+  spawnOptions: { shell?: boolean; windowsVerbatimArguments?: boolean }
 } {
   const platform = options.platform ?? process.platform
   const safeCommand = assertProcessSafeValue(command, 'Process command')
   const safeArgs = commandArgs.map((arg, index) => assertProcessSafeValue(arg, `Process argument #${index + 1}`))
-  const detachedSpawnOptions = options.detached ? { detached: true } : {}
 
   if (!isWindowsCmdScript(safeCommand, platform)) {
     return {
       command: safeCommand,
       args: safeArgs,
-      spawnOptions: { ...detachedSpawnOptions },
+      spawnOptions: {},
     }
   }
 
@@ -52,6 +51,6 @@ export function resolveSpawnCommand(
     args: safeArgs.map((arg, index) =>
       assertWindowsCmdSafeValue(arg, `Windows command argument #${index + 1}`),
     ),
-    spawnOptions: { ...detachedSpawnOptions },
+    spawnOptions: {},
   }
 }

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

@@ -20,17 +20,8 @@ import {
   shouldReuseBuildArtifacts,
   acquireEphemeralRuntimeLock,
   waitForApplicationReadiness,
-  createBoundedOutputBuffer,
-  formatCapturedOutput,
-  CAPTURED_OUTPUT_MAX_LENGTH,
-  killProcessTree,
-  terminateProcessTree,
-  registerEphemeralShutdownHandlers,
 } from '../integration'
-import type { CapturedOutputProcess, ShutdownProcessRef } from '../integration'
-import { resolveSpawnCommand } from '../../spawn'
 import { EventEmitter } from 'node:events'
-import { spawn } from 'node:child_process'
 import type { ChildProcess } from 'node:child_process'
 
 const CACHE_TTL_ENV_VAR = 'OM_INTEGRATION_BUILD_CACHE_TTL_SECONDS'
@@ -933,430 +924,4 @@ describe('waitForApplicationReadiness', () => {
       fetchSpy.mockRestore()
     }
   })
-
-  it('includes the captured stderr tail when the application process exits unexpectedly', 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() as CapturedOutputProcess
-    fakeProcess.readCapturedOutput = () => 'Error: listen EADDRINUSE: address already in use :::5001'
-
-    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\)/)
-      await expect(readiness).rejects.toThrow(/EADDRINUSE/)
-    } finally {
-      fetchSpy.mockRestore()
-    }
-  })
-})
-
-describe('createBoundedOutputBuffer', () => {
-  it('keeps the most recent output and drops the oldest once the cap is exceeded', () => {
-    const buffer = createBoundedOutputBuffer()
-    const lineCount = 200
-
-    for (let index = 0; index < lineCount; index += 1) {
-      buffer.append(`line-${index}:${'x'.repeat(500)}\n`)
-    }
-
-    const result = buffer.read()
-    expect(result).toContain('…(truncated)…')
-    expect(result).toContain(`line-${lineCount - 1}:`)
-    expect(result).not.toContain('line-0:')
-    expect(result.length).toBeLessThanOrEqual(CAPTURED_OUTPUT_MAX_LENGTH + '…(truncated)…'.length)
-  })
-
-  it('returns the raw output untouched when it stays under the cap', () => {
-    const buffer = createBoundedOutputBuffer()
-    buffer.append('hello ')
-    buffer.append('world')
-    expect(buffer.read()).toBe('hello world')
-  })
-})
-
-describe('killProcessTree', () => {
-  it('kills the POSIX process group via a negated pid', () => {
-    const calls: Array<[number, NodeJS.Signals]> = []
-    killProcessTree(4242, 'SIGTERM', {
-      platform: 'linux',
-      killPosixProcessGroup: (pid, signal) => {
-        calls.push([pid, signal])
-      },
-    })
-    expect(calls).toEqual([[4242, 'SIGTERM']])
-  })
-
-  it('asks Windows for a graceful process-tree kill on SIGTERM', () => {
-    const calls: Array<[number, { forced: boolean }]> = []
-    killProcessTree(4242, 'SIGTERM', {
-      platform: 'win32',
-      killWindowsProcessTree: (pid, options) => {
-        calls.push([pid, options])
-      },
-    })
-    expect(calls).toEqual([[4242, { forced: false }]])
-  })
-
-  it('escalates to a forced Windows process-tree kill on SIGKILL', () => {
-    const calls: Array<[number, { forced: boolean }]> = []
-    killProcessTree(4242, 'SIGKILL', {
-      platform: 'win32',
-      killWindowsProcessTree: (pid, options) => {
-        calls.push([pid, options])
-      },
-    })
-    expect(calls).toEqual([[4242, { forced: true }]])
-  })
-
-  it('negates the pid when falling back to the default POSIX killer', () => {
-    const killSpy = jest.spyOn(process, 'kill').mockImplementation(() => true)
-    try {
-      killProcessTree(4242, 'SIGTERM', { platform: 'linux' })
-      expect(killSpy).toHaveBeenCalledWith(-4242, 'SIGTERM')
-    } finally {
-      killSpy.mockRestore()
-    }
-  })
-})
-
-describe('terminateProcessTree', () => {
-  const makeFakeProcessWithPid = (pid: number): CapturedOutputProcess => {
-    const fakeProcess = new EventEmitter() as unknown as CapturedOutputProcess
-    fakeProcess.pid = pid
-    return fakeProcess
-  }
-
-  it('does not throw when the process already exited on its own (ESRCH)', async () => {
-    const fakeProcess = makeFakeProcessWithPid(4242)
-    const esrchError = Object.assign(new Error('kill ESRCH'), { code: 'ESRCH' })
-
-    await expect(
-      terminateProcessTree(fakeProcess, {
-        platform: 'linux',
-        gracePeriodMs: 10,
-        killPosixProcessGroup: () => {
-          throw esrchError
-        },
-      }),
-    ).resolves.toBeUndefined()
-  })
-
-  it('still kills the group of a process that already reported its exit, without waiting on it', async () => {
-    const fakeProcess = makeFakeProcessWithPid(4242)
-    fakeProcess.exitCode = 1
-    const calls: NodeJS.Signals[] = []
-
-    const startedAt = Date.now()
-    await terminateProcessTree(fakeProcess, {
-      platform: 'linux',
-      gracePeriodMs: 5_000,
-      killPosixProcessGroup: (_pid, signal) => {
-        calls.push(signal)
-      },
-    })
-
-    // A reaped leader means no `'exit'` event will ever settle the wait, not that its group is
-    // empty — the descendants it spawned are exactly the orphan #5333 is about.
-    expect(calls).toEqual(['SIGKILL'])
-    expect(Date.now() - startedAt).toBeLessThan(1_000)
-  })
-
-  it('resolves as soon as the process exits, without burning the rest of the grace period', async () => {
-    const fakeProcess = makeFakeProcessWithPid(4242)
-    const calls: NodeJS.Signals[] = []
-
-    const startedAt = Date.now()
-    const termination = terminateProcessTree(fakeProcess, {
-      platform: 'linux',
-      gracePeriodMs: 5_000,
-      killPosixProcessGroup: (_pid, signal) => {
-        calls.push(signal)
-      },
-    })
-    setTimeout(() => fakeProcess.emit('exit', 0), 10)
-    await termination
-
-    expect(calls).toEqual(['SIGTERM'])
-    expect(Date.now() - startedAt).toBeLessThan(1_000)
-  })
-
-  it('escalates to SIGKILL when the tree outlives the grace period', async () => {
-    // A live pid the escalation's `isProcessRunning` guard will confirm, without signalling anything
-    // real — the injected killer records instead of killing.
-    const fakeProcess = makeFakeProcessWithPid(process.pid)
-    const calls: NodeJS.Signals[] = []
-
-    await terminateProcessTree(fakeProcess, {
-      platform: 'linux',
-      gracePeriodMs: 10,
-      killPosixProcessGroup: (_pid, signal) => {
-        calls.push(signal)
-      },
-    })
-
-    expect(calls).toEqual(['SIGTERM', 'SIGKILL'])
-  })
-
-  it('propagates a non-ESRCH failure from the killer', async () => {
-    const fakeProcess = makeFakeProcessWithPid(4242)
-    const permissionError = Object.assign(new Error('kill EPERM'), { code: 'EPERM' })
-
-    await expect(
-      terminateProcessTree(fakeProcess, {
-        platform: 'linux',
-        killPosixProcessGroup: () => {
-          throw permissionError
-        },
-      }),
-    ).rejects.toThrow(/EPERM/)
-  })
-})
-
-describe('formatCapturedOutput', () => {
-  it('keeps the stdout tail visible when stderr also captured output', () => {
-    expect(formatCapturedOutput('a deprecation warning', 'the real failure')).toBe(
-      '--- stderr ---\na deprecation warning\n--- stdout ---\nthe real failure',
-    )
-  })
-
-  it('returns the single populated stream unlabelled', () => {
-    expect(formatCapturedOutput('only stderr', '')).toBe('only stderr')
-    expect(formatCapturedOutput('', 'only stdout')).toBe('only stdout')
-    expect(formatCapturedOutput('', '')).toBe('')
-  })
-})
-
-describe('registerEphemeralShutdownHandlers', () => {
-  const makeProcessRef = () => {
-    const listeners = new Map<string, Array<() => void>>()
-    const raised: Array<[number, NodeJS.Signals]> = []
-    const processRef: ShutdownProcessRef = {
-      pid: 9999,
-      once: ((event: string, handler: () => void) => {
-        listeners.set(event, [...(listeners.get(event) ?? []), handler])
-        return processRef
-      }) as ShutdownProcessRef['once'],
-      off: ((event: string, handler: () => void) => {
-        listeners.set(event, (listeners.get(event) ?? []).filter((entry) => entry !== handler))
-        return processRef
-      }) as ShutdownProcessRef['off'],
-      removeAllListeners: ((event: string) => {
-        listeners.delete(event)
-        return processRef
-      }) as ShutdownProcessRef['removeAllListeners'],
-      kill: ((pid: number, signal: NodeJS.Signals) => {
-        raised.push([pid, signal])
-        return true
-      }) as ShutdownProcessRef['kill'],
-    }
-    const emit = (event: string) => {
-      for (const handler of [...(listeners.get(event) ?? [])]) handler()
-    }
-    const listenerCount = (event: string) => (listeners.get(event) ?? []).length
-    return { processRef, emit, raised, listenerCount }
-  }
-
-  // The regression guard for the interrupt path: `detached: true` puts the app tree in its own
-  // session, so unless the runner tears it down on SIGINT the tree survives Ctrl+C holding
-  // `server-start.lock` — the exact orphan this harness exists to prevent.
-  it.each<NodeJS.Signals>(['SIGINT', 'SIGTERM'])(
-    'stops the environment and re-raises %s so the runner still exits on the signal',
-    async (signal) => {
-      const { processRef, emit, raised } = makeProcessRef()
-      let stopCallCount = 0
-      registerEphemeralShutdownHandlers({
-        stop: async () => {
-          stopCallCount += 1
-        },
-        killApplicationTree: () => {},
-        processRef,
-      })
-
-      emit(signal)
-      await new Promise((resolve) => setImmediate(resolve))
-
-      expect(stopCallCount).toBe(1)
-      expect(raised).toEqual([[9999, signal]])
-    },
-  )
-
-  it('re-raises the signal even when stopping the environment fails', async () => {
-    const { processRef, emit, raised } = makeProcessRef()
-    registerEphemeralShutdownHandlers({
-      stop: async () => {
-        throw new Error('teardown blew up')
-      },
-      killApplicationTree: () => {},
-      processRef,
-    })
-
-    emit('SIGINT')
-    await new Promise((resolve) => setImmediate(resolve))
-
-    expect(raised).toEqual([[9999, 'SIGINT']])
-  })
-
-  it('kills the application tree on the hard-exit sweep', () => {
-    const { processRef, emit } = makeProcessRef()
-    let killCallCount = 0
-    registerEphemeralShutdownHandlers({
-      stop: async () => {},
-      killApplicationTree: () => {
-        killCallCount += 1
-      },
-      processRef,
-    })
-
-    emit('exit')
-    expect(killCallCount).toBe(1)
-  })
-
-  // The environment is restarted on retry, so handlers that are never removed stack one dead
-  // closure per attempt until Node warns about a listener leak.
-  it('removes every listener on dispose so repeated environment starts do not stack them', () => {
-    const { processRef, listenerCount } = makeProcessRef()
-    const first = registerEphemeralShutdownHandlers({
-      stop: async () => {},
-      killApplicationTree: () => {},
-      processRef,
-    })
-    expect(listenerCount('exit')).toBe(1)
-    expect(listenerCount('SIGINT')).toBe(1)
-
-    first.dispose()
-    expect(listenerCount('exit')).toBe(0)
-    expect(listenerCount('SIGINT')).toBe(0)
-    expect(listenerCount('SIGTERM')).toBe(0)
-
-    registerEphemeralShutdownHandlers({
-      stop: async () => {},
-      killApplicationTree: () => {},
-      processRef,
-    }).dispose()
-    expect(listenerCount('exit')).toBe(0)
-  })
-})
-
-// Every other process-lifecycle test here drives injected fakes, so nothing pins down the part
-// that can only fail against the real OS: whether `detached: true` plus a negated-pid signal
-// actually reaps the grandchildren the wrapper spawned. `sh` stands in for the `yarn start`
-// wrapper and `sleep` for the `mercato start`/Next tree it would leave behind.
-const describeOnPosix = process.platform === 'win32' ? describe.skip : describe
-
-describeOnPosix('terminateProcessTree against a real detached process tree', () => {
-  const isProcessAlive = (pid: number): boolean => {
-    try {
-      process.kill(pid, 0)
-      return true
-    } catch (error) {
-      return (error as NodeJS.ErrnoException).code !== 'ESRCH'
-    }
-  }
-
-  const waitUntilGone = async (pid: number, timeoutMs = 5_000): Promise<boolean> => {
-    const deadline = Date.now() + timeoutMs
-    while (Date.now() < deadline) {
-      if (!isProcessAlive(pid)) return true
-      await new Promise((resolve) => setTimeout(resolve, 25))
-    }
-    return !isProcessAlive(pid)
-  }
-
-  it('kills the grandchild the wrapper spawned, not just the wrapper itself', async () => {
-    const resolvedSpawn = resolveSpawnCommand('/bin/sh', ['-c', 'sleep 30 & echo $!; wait'], {
-      detached: true,
-    })
-    const wrapperProcess = spawn(resolvedSpawn.command, resolvedSpawn.args, {
-      stdio: ['ignore', 'pipe', 'ignore'],
-      ...resolvedSpawn.spawnOptions,
-    }) as CapturedOutputProcess
-
-    let grandchildPid = 0
-    try {
-      grandchildPid = await new Promise<number>((resolve, reject) => {
-        const timer = setTimeout(() => reject(new Error('timed out waiting for the grandchild pid')), 5_000)
-        wrapperProcess.stdout?.once('data', (chunk: Buffer) => {
-          clearTimeout(timer)
-          resolve(Number.parseInt(chunk.toString().trim(), 10))
-        })
-      })
-
-      expect(Number.isInteger(grandchildPid)).toBe(true)
-      // The detached spawn puts the wrapper in its own process group, so the group id is its pid.
-      expect(grandchildPid).not.toBe(wrapperProcess.pid)
-      expect(isProcessAlive(grandchildPid)).toBe(true)
-
-      await terminateProcessTree(wrapperProcess, { gracePeriodMs: 1_000 })
-
-      await expect(waitUntilGone(grandchildPid)).resolves.toBe(true)
-      await expect(waitUntilGone(wrapperProcess.pid as number)).resolves.toBe(true)
-    } finally {
-      for (const pid of [grandchildPid, wrapperProcess.pid ?? 0]) {
-        if (pid && isProcessAlive(pid)) {
-          try {
-            process.kill(pid, 'SIGKILL')
-          } catch {}
-        }
-      }
-    }
-  }, 20_000)
-
-  // The shape `waitForApplicationReadiness` reports: the `yarn` wrapper dies non-zero (port in use,
-  // broken build, worker dead on boot) while the `mercato start`/Next tree it spawned lives on. The
-  // leader is already reaped by the time teardown runs, so this is the case an exit short-circuit in
-  // `terminateProcessTree` silently skips — leaving the orphan that still holds `server-start.lock`.
-  it('kills a grandchild that outlived its already-exited wrapper', async () => {
-    const resolvedSpawn = resolveSpawnCommand('/bin/sh', ['-c', 'sleep 30 & echo $!; exit 1'], {
-      detached: true,
-    })
-    const wrapperProcess = spawn(resolvedSpawn.command, resolvedSpawn.args, {
-      stdio: ['ignore', 'pipe', 'ignore'],
-      ...resolvedSpawn.spawnOptions,
-    }) as CapturedOutputProcess
-
-    let grandchildPid = 0
-    try {
-      // `'exit'` and the stdout `'data'` carrying the pid are independent events with no ordering
-      // guarantee, so both are awaited separately. Waiting for `'close'` instead would deadlock:
-      // the detached grandchild inherits this stdout pipe and holds it open for its whole lifetime.
-      const withTimeout = <T,>(label: string, subscribe: (resolve: (value: T) => void) => void) =>
-        new Promise<T>((resolve, reject) => {
-          const timer = setTimeout(() => reject(new Error(`timed out waiting for ${label}`)), 5_000)
-          subscribe((value) => {
-            clearTimeout(timer)
-            resolve(value)
-          })
-        })
-
-      const [pidText] = await Promise.all([
-        withTimeout<string>('the grandchild pid', (resolve) =>
-          wrapperProcess.stdout?.once('data', (chunk: Buffer) => resolve(chunk.toString())),
-        ),
-        withTimeout<void>('the wrapper to exit', (resolve) => wrapperProcess.once('exit', () => resolve())),
-      ])
-      grandchildPid = Number.parseInt(pidText.trim(), 10)
-
-      expect(Number.isInteger(grandchildPid)).toBe(true)
-      expect(wrapperProcess.exitCode).toBe(1)
-      expect(isProcessAlive(grandchildPid)).toBe(true)
-
-      await terminateProcessTree(wrapperProcess, { gracePeriodMs: 1_000 })
-
-      await expect(waitUntilGone(grandchildPid)).resolves.toBe(true)
-    } finally {
-      for (const pid of [grandchildPid, wrapperProcess.pid ?? 0]) {
-        if (pid && isProcessAlive(pid)) {
-          try {
-            process.kill(pid, 'SIGKILL')
-          } catch {}
-        }
-      }
-    }
-  }, 20_000)
 })