@open-mercato/cli 0.6.7-develop.6669.1.40b669666b → 0.6.7-develop.6671.1.4b925c5096

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-mercato/cli",
-  "version": "0.6.7-develop.6669.1.40b669666b",
+  "version": "0.6.7-develop.6671.1.4b925c5096",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",
@@ -60,8 +60,8 @@
     "@mikro-orm/decorators": "^7.1.5",
     "@mikro-orm/migrations": "^7.1.5",
     "@mikro-orm/postgresql": "^7.1.5",
-    "@open-mercato/queue": "0.6.7-develop.6669.1.40b669666b",
-    "@open-mercato/shared": "0.6.7-develop.6669.1.40b669666b",
+    "@open-mercato/queue": "0.6.7-develop.6671.1.4b925c5096",
+    "@open-mercato/shared": "0.6.7-develop.6671.1.4b925c5096",
     "cross-spawn": "^7.0.6",
     "pg": "8.22.0",
     "semver": "^7.8.5",
@@ -72,10 +72,10 @@
     "typescript-js": "npm:typescript@6.0.3"
   },
   "peerDependencies": {
-    "@open-mercato/shared": "0.6.7-develop.6669.1.40b669666b"
+    "@open-mercato/shared": "0.6.7-develop.6671.1.4b925c5096"
   },
   "devDependencies": {
-    "@open-mercato/shared": "0.6.7-develop.6669.1.40b669666b",
+    "@open-mercato/shared": "0.6.7-develop.6671.1.4b925c5096",
     "@types/jest": "^30.0.0",
     "jest": "^30.4.2",
     "ts-jest": "^29.4.11"

package/src/__tests__/mercato.test.ts

@@ -37,7 +37,10 @@ function buildMockChildProcessModule(routeAutoExit: MockChildSpawnRouter) {
     if (autoExit) {
       queueMicrotask(() => {
         if (child.exitCode !== null || child.signalCode !== null) return
-        if (pathIncludes(spawnargs[1] ?? '', 'next/dist/bin/next') && spawnargs.includes('dev')) {
+        // A routed non-zero exit models a crash during startup, so the child must
+        // never announce readiness first — that is what the cold-start retry keys on.
+        const crashesBeforeReady = typeof autoExit.code === 'number' && autoExit.code !== 0
+        if (!crashesBeforeReady && pathIncludes(spawnargs[1] ?? '', 'next/dist/bin/next') && spawnargs.includes('dev')) {
           child.stdout.emit('data', '✓ Ready in 1ms\n')
         }
         queueMicrotask(() => {
@@ -868,6 +871,325 @@ describe('server dev managed process exits', () => {
     consoleLogSpy.mockRestore()
   })
 
+  it('retries the Next.js dev server once when it exits before reporting ready', async () => {
+    const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation()
+    const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation()
+    process.env.AUTO_SPAWN_WORKERS = 'false'
+
+    jest.doMock('node:fs', () => {
+      const actual = jest.requireActual('node:fs')
+      return {
+        ...actual,
+        existsSync: jest.fn((candidate: string) =>
+          pathIncludes(candidate, 'next/dist/bin/next') || pathIncludes(candidate, '@open-mercato/cli/bin/mercato'),
+        ),
+        unlinkSync: jest.fn(),
+      }
+    })
+    jest.doMock('../lib/generators', () => ({
+      generateModulePackageSources: jest.fn().mockResolvedValue(undefined),
+    }))
+    jest.doMock('../lib/resolver', () => ({
+      resolveEnvironment: () => ({
+        appDir: '/tmp/test-app',
+        rootDir: '/tmp/test-root',
+      }),
+      createResolver: () => ({}),
+    }))
+    jest.doMock('child_process', () => {
+      const { EventEmitter } = jest.requireActual('node:events')
+      let nextSpawnCount = 0
+
+      const createChild = (autoExit?: { code: number | null; signal?: NodeJS.Signals | null; ready?: boolean }) => {
+        const child = new EventEmitter() as any
+        child.stdout = new EventEmitter()
+        child.stderr = new EventEmitter()
+        child.killed = false
+        child.exitCode = null
+        child.signalCode = null
+        child.kill = jest.fn(() => true)
+
+        if (autoExit) {
+          queueMicrotask(() => {
+            if (autoExit.ready) child.stdout.emit('data', '✓ Ready in 1ms\n')
+            queueMicrotask(() => {
+              child.exitCode = autoExit.code
+              child.signalCode = autoExit.signal ?? null
+              child.emit('exit', child.exitCode, child.signalCode)
+            })
+          })
+        }
+
+        return child
+      }
+
+      return {
+        spawn: jest.fn((_command: string, args: string[]) => {
+          if (pathIncludes(args[0] ?? '', 'next/dist/bin/next')) {
+            nextSpawnCount += 1
+            return nextSpawnCount === 1
+              ? createChild({ code: 1 })
+              : createChild({ code: null, signal: 'SIGTERM', ready: true })
+          }
+          return createChild()
+        }),
+      }
+    })
+
+    const mercato = await import('../mercato')
+    const exitCode = await mercato.run(['node', 'mercato', 'server', 'dev'])
+    const { spawn } = await import('child_process')
+    const nextSpawns = (spawn as jest.Mock).mock.calls.filter((call) =>
+      pathIncludes(call[1]?.[0] ?? '', 'next/dist/bin/next'),
+    )
+
+    expect(exitCode).toBe(0)
+    expect(nextSpawns).toHaveLength(2)
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      '[server] Next.js dev server exited before becoming ready (exit code 1). Retrying once...',
+    )
+    expect(consoleErrorSpy).not.toHaveBeenCalled()
+
+    consoleErrorSpy.mockRestore()
+    consoleLogSpy.mockRestore()
+  })
+
+  it('reports the failure when the retried Next.js dev server also exits before reporting ready', async () => {
+    const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation()
+    const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation()
+    process.env.AUTO_SPAWN_WORKERS = 'false'
+
+    jest.doMock('node:fs', () => {
+      const actual = jest.requireActual('node:fs')
+      return {
+        ...actual,
+        existsSync: jest.fn((candidate: string) =>
+          pathIncludes(candidate, 'next/dist/bin/next') || pathIncludes(candidate, '@open-mercato/cli/bin/mercato'),
+        ),
+        unlinkSync: jest.fn(),
+      }
+    })
+    jest.doMock('../lib/generators', () => ({
+      generateModulePackageSources: jest.fn().mockResolvedValue(undefined),
+    }))
+    jest.doMock('../lib/resolver', () => ({
+      resolveEnvironment: () => ({
+        appDir: '/tmp/test-app',
+        rootDir: '/tmp/test-root',
+      }),
+      createResolver: () => ({}),
+    }))
+    jest.doMock('child_process', () =>
+      buildMockChildProcessModule((args) =>
+        pathIncludes(args[0] ?? '', 'next/dist/bin/next') ? { code: 1 } : undefined,
+      ),
+    )
+
+    const mercato = await import('../mercato')
+    const exitCode = await mercato.run(['node', 'mercato', 'server', 'dev'])
+    const { spawn } = await import('child_process')
+    const nextSpawns = (spawn as jest.Mock).mock.calls.filter((call) =>
+      pathIncludes(call[1]?.[0] ?? '', 'next/dist/bin/next'),
+    )
+
+    expect(exitCode).toBe(1)
+    expect(nextSpawns).toHaveLength(2)
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      '💥 Failed: [server] Next.js dev server exited unexpectedly with exit code 1.',
+    )
+
+    consoleErrorSpy.mockRestore()
+    consoleLogSpy.mockRestore()
+  })
+
+  it.each([
+    ['Failed to restore task data (corrupted database or bug)'],
+    ['Unable to open static sorted file'],
+    ['TurbopackInternalError'],
+  ])('clears the Turbopack dev cache and restarts once on the lone signature %s', async (signature) => {
+    const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation()
+    const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation()
+    process.env.AUTO_SPAWN_WORKERS = 'false'
+    const rmSync = jest.fn()
+
+    jest.doMock('node:fs', () => {
+      const actual = jest.requireActual('node:fs')
+      return {
+        ...actual,
+        existsSync: jest.fn((candidate: string) =>
+          pathIncludes(candidate, 'next/dist/bin/next') || pathIncludes(candidate, '@open-mercato/cli/bin/mercato'),
+        ),
+        unlinkSync: jest.fn(),
+        rmSync,
+      }
+    })
+    jest.doMock('../lib/generators', () => ({
+      generateModulePackageSources: jest.fn().mockResolvedValue(undefined),
+    }))
+    jest.doMock('../lib/resolver', () => ({
+      resolveEnvironment: () => ({
+        appDir: '/tmp/test-app',
+        rootDir: '/tmp/test-root',
+      }),
+      createResolver: () => ({}),
+    }))
+    jest.doMock('child_process', () => {
+      const { EventEmitter } = jest.requireActual('node:events')
+      let nextSpawnCount = 0
+
+      const createChild = (options?: { output?: string; code?: number | null; signal?: NodeJS.Signals | null; ready?: boolean }) => {
+        const child = new EventEmitter() as any
+        child.stdout = new EventEmitter()
+        child.stderr = new EventEmitter()
+        child.killed = false
+        child.exitCode = null
+        child.signalCode = null
+        child.kill = jest.fn(() => true)
+
+        if (options) {
+          queueMicrotask(() => {
+            if (options.output) child.stderr.emit('data', options.output)
+            if (options.ready) child.stdout.emit('data', '✓ Ready in 1ms\n')
+            queueMicrotask(() => {
+              child.exitCode = options.code ?? null
+              child.signalCode = options.signal ?? null
+              child.emit('exit', child.exitCode, child.signalCode)
+            })
+          })
+        }
+
+        return child
+      }
+
+      return {
+        spawn: jest.fn((_command: string, args: string[]) => {
+          if (pathIncludes(args[0] ?? '', 'next/dist/bin/next')) {
+            nextSpawnCount += 1
+            return nextSpawnCount === 1
+              ? createChild({ output: `⨯ ${signature}\n`, code: 1 })
+              : createChild({ code: null, signal: 'SIGTERM', ready: true })
+          }
+          return createChild()
+        }),
+      }
+    })
+
+    const mercato = await import('../mercato')
+    const exitCode = await mercato.run(['node', 'mercato', 'server', 'dev'])
+    const { spawn } = await import('child_process')
+    const nextSpawns = (spawn as jest.Mock).mock.calls.filter((call) =>
+      pathIncludes(call[1]?.[0] ?? '', 'next/dist/bin/next'),
+    )
+    const cacheRemovals = rmSync.mock.calls.filter(([target]) =>
+      pathIncludes(String(target), '.mercato/next/dev'),
+    )
+
+    expect(exitCode).toBe(0)
+    expect(nextSpawns).toHaveLength(2)
+    expect(cacheRemovals).toHaveLength(1)
+    expect(cacheRemovals[0][1]).toEqual({ recursive: true, force: true })
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      '[server] Detected corrupted Turbopack dev cache. Clearing .mercato/next/dev and restarting Next.js once...',
+    )
+    // Corruption recovery owns this exit; the generic cold-start retry must not also fire.
+    expect(consoleLogSpy).not.toHaveBeenCalledWith(
+      expect.stringContaining('exited before becoming ready'),
+    )
+
+    consoleErrorSpy.mockRestore()
+    consoleLogSpy.mockRestore()
+  })
+
+  it('takes the plain cold-start retry without purging the cache when no corruption signature is present', async () => {
+    const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation()
+    const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation()
+    process.env.AUTO_SPAWN_WORKERS = 'false'
+    const rmSync = jest.fn()
+
+    jest.doMock('node:fs', () => {
+      const actual = jest.requireActual('node:fs')
+      return {
+        ...actual,
+        existsSync: jest.fn((candidate: string) =>
+          pathIncludes(candidate, 'next/dist/bin/next') || pathIncludes(candidate, '@open-mercato/cli/bin/mercato'),
+        ),
+        unlinkSync: jest.fn(),
+        rmSync,
+      }
+    })
+    jest.doMock('../lib/generators', () => ({
+      generateModulePackageSources: jest.fn().mockResolvedValue(undefined),
+    }))
+    jest.doMock('../lib/resolver', () => ({
+      resolveEnvironment: () => ({
+        appDir: '/tmp/test-app',
+        rootDir: '/tmp/test-root',
+      }),
+      createResolver: () => ({}),
+    }))
+    jest.doMock('child_process', () => {
+      const { EventEmitter } = jest.requireActual('node:events')
+      let nextSpawnCount = 0
+
+      const createChild = (options?: { output?: string; code?: number | null; signal?: NodeJS.Signals | null; ready?: boolean }) => {
+        const child = new EventEmitter() as any
+        child.stdout = new EventEmitter()
+        child.stderr = new EventEmitter()
+        child.killed = false
+        child.exitCode = null
+        child.signalCode = null
+        child.kill = jest.fn(() => true)
+
+        if (options) {
+          queueMicrotask(() => {
+            if (options.output) child.stderr.emit('data', options.output)
+            if (options.ready) child.stdout.emit('data', '✓ Ready in 1ms\n')
+            queueMicrotask(() => {
+              child.exitCode = options.code ?? null
+              child.signalCode = options.signal ?? null
+              child.emit('exit', child.exitCode, child.signalCode)
+            })
+          })
+        }
+
+        return child
+      }
+
+      return {
+        spawn: jest.fn((_command: string, args: string[]) => {
+          if (pathIncludes(args[0] ?? '', 'next/dist/bin/next')) {
+            nextSpawnCount += 1
+            return nextSpawnCount === 1
+              ? createChild({ output: 'Another next dev server is already running.\n', code: 1 })
+              : createChild({ code: null, signal: 'SIGTERM', ready: true })
+          }
+          return createChild()
+        }),
+      }
+    })
+
+    const mercato = await import('../mercato')
+    const exitCode = await mercato.run(['node', 'mercato', 'server', 'dev'])
+    const { spawn } = await import('child_process')
+    const nextSpawns = (spawn as jest.Mock).mock.calls.filter((call) =>
+      pathIncludes(call[1]?.[0] ?? '', 'next/dist/bin/next'),
+    )
+    const cacheRemovals = rmSync.mock.calls.filter(([target]) =>
+      pathIncludes(String(target), '.mercato/next/dev'),
+    )
+
+    expect(exitCode).toBe(0)
+    expect(nextSpawns).toHaveLength(2)
+    // A lock conflict is not cache corruption — the dev cache must survive.
+    expect(cacheRemovals).toHaveLength(0)
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      '[server] Next.js dev server exited before becoming ready (exit code 1). Retrying once...',
+    )
+
+    consoleErrorSpy.mockRestore()
+    consoleLogSpy.mockRestore()
+  })
+
   it('starts the lazy worker supervisor instead of `queue worker --all` when OM_AUTO_SPAWN_WORKERS_LAZY=true', async () => {
     const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation()
     const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation()

package/src/lib/__tests__/post-generate-invalidation.test.ts

@@ -47,6 +47,30 @@ describe('runPostGenerateStructuralInvalidation', () => {
     }
   })
 
+  it('advances mtime without reopening generated artifacts for writing', async () => {
+    const appDir = fs.mkdtempSync(path.join(os.tmpdir(), 'post-generate-invalidation-mtime-'))
+    try {
+      const generatedDir = path.join(appDir, '.mercato', 'generated')
+      fs.mkdirSync(generatedDir, { recursive: true })
+      const generatedTs = path.join(generatedDir, 'modules.generated.ts')
+      fs.writeFileSync(generatedTs, 'export const modules = []\n')
+      const staleTime = new Date(Date.now() - 60_000)
+      fs.utimesSync(generatedTs, staleTime, staleTime)
+      const before = fs.statSync(generatedTs)
+
+      await runPostGenerateStructuralInvalidation(appDir)
+
+      const after = fs.statSync(generatedTs)
+      expect(after.mtimeMs).toBeGreaterThan(before.mtimeMs)
+      expect(after.size).toBe(before.size)
+      // ctime advances on a metadata-only touch; a rewrite would also bump the
+      // inode's write generation, so assert the content survived byte for byte.
+      expect(fs.readFileSync(generatedTs, 'utf8')).toBe('export const modules = []\n')
+    } finally {
+      fs.rmSync(appDir, { recursive: true, force: true })
+    }
+  })
+
   it('still refreshes generated artifacts when cache maintenance fails', async () => {
     const appDir = fs.mkdtempSync(path.join(os.tmpdir(), 'post-generate-invalidation-failure-'))
     const error = new Error('cache unavailable')

package/src/lib/post-generate-invalidation.ts

@@ -21,13 +21,16 @@ function touchGeneratedFiles(appDir: string): string[] {
   if (!fs.existsSync(generatedDir) || !fs.statSync(generatedDir).isDirectory()) return []
 
   const touched: string[] = []
+  // `utimes` advances mtime without opening the file for writing. Rewriting the
+  // identical bytes would truncate multi-megabyte registries first, and Turbopack
+  // reads them concurrently during a dev compile — it can observe the empty window.
+  const touchedAt = new Date()
   const entries = fs.readdirSync(generatedDir, { withFileTypes: true })
     .sort((left, right) => left.name.localeCompare(right.name))
   for (const entry of entries) {
     if (!entry.isFile() || !TOUCHABLE_GENERATED_FILE_PATTERN.test(entry.name)) continue
     const filePath = path.join(generatedDir, entry.name)
-    const contents = fs.readFileSync(filePath)
-    fs.writeFileSync(filePath, contents)
+    fs.utimesSync(filePath, touchedAt, touchedAt)
     touched.push(filePath)
   }
   return touched

package/src/mercato.ts

@@ -100,6 +100,11 @@ const TURBOPACK_CORRUPTION_PATTERNS = [
   'TurbopackInternalError',
 ]
 
+// Next.js gives up on `.mercato/next/dev/lock` after 1000ms, so a dev server
+// that lost a startup race against a still-shutting-down sibling needs a
+// slightly longer pause before the retry can win the lock.
+const DEV_COLD_START_RETRY_DELAY_MS = 1500
+
 const BUILTIN_CLI_MODULE_IDS = new Set(['queue', 'generate', 'deploy', 'db', 'server', 'test'])
 
 function collectNestedErrors(error: unknown, seen = new Set<unknown>()): ErrorWithCause[] {
@@ -264,7 +269,7 @@ async function ensureDatabaseExists(dbUrl: string): Promise<boolean> {
 }
 
 function isTurbopackCacheCorruption(output: string): boolean {
-  return TURBOPACK_CORRUPTION_PATTERNS.every((pattern) => output.includes(pattern))
+  return TURBOPACK_CORRUPTION_PATTERNS.some((pattern) => output.includes(pattern))
 }
 
 function removeTurbopackDevCache(appDir: string): void {
@@ -1960,6 +1965,7 @@ export async function run(argv = process.argv) {
 
           let processes: ChildProcess[] = []
           let didRetryCorruptedTurbopackCache = false
+          let didRetryFailedColdStart = false
           let stopping = false
           let devRestartPromiseResolve: ((result: DevServerRestartResult) => void) | null = null
           let activeLazySupervisor: ReturnType<typeof startLazyWorkerSupervisor> | null = null
@@ -2122,6 +2128,30 @@ export async function run(argv = process.argv) {
                   restarted.readyPromise.then(readyResolve)
                   return resolve(await restarted.exitPromise)
                 }
+                // A dev server that dies before it ever reported "ready in" lost a
+                // startup race rather than crashing on user code: a sibling instance
+                // still holding the dev lock, a port that is about to free up, or a
+                // bundler init hiccup on a cold cache. Those all clear on their own,
+                // which is why a second `yarn dev` usually succeeds — retry once here
+                // so the first run succeeds too.
+                if (
+                  !didRetryFailedColdStart
+                  && !reportedReady
+                  && !stopping
+                  && typeof code === 'number'
+                  && code !== 0
+                ) {
+                  didRetryFailedColdStart = true
+                  lastRestartReason = 'a failed cold start'
+                  writeDevSplashRuntimeRestarting(lastRestartReason)
+                  console.log(`[server] Next.js dev server exited before becoming ready (exit code ${code}). Retrying once...`)
+                  await new Promise((wake) => setTimeout(wake, DEV_COLD_START_RETRY_DELAY_MS))
+                  if (!stopping) {
+                    const restarted = startNextDev(runtimeEnv)
+                    restarted.readyPromise.then(readyResolve)
+                    return resolve(await restarted.exitPromise)
+                  }
+                }
                 resolve({
                   label: 'Next.js dev server',
                   code,