@open-mercato/cli 0.5.1-develop.2744.9c8be0dd93 → 0.5.1-develop.2762.90c271efe2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-mercato/cli",
-  "version": "0.5.1-develop.2744.9c8be0dd93",
+  "version": "0.5.1-develop.2762.90c271efe2",
   "type": "module",
   "main": "./dist/index.js",
   "exports": {
@@ -59,8 +59,8 @@
     "@mikro-orm/decorators": "^7.0.10",
     "@mikro-orm/migrations": "^7.0.10",
     "@mikro-orm/postgresql": "^7.0.10",
-    "@open-mercato/queue": "0.5.1-develop.2744.9c8be0dd93",
-    "@open-mercato/shared": "0.5.1-develop.2744.9c8be0dd93",
+    "@open-mercato/queue": "0.5.1-develop.2762.90c271efe2",
+    "@open-mercato/shared": "0.5.1-develop.2762.90c271efe2",
     "cross-spawn": "^7.0.6",
     "pg": "8.20.0",
     "semver": "^7.7.4",
@@ -70,10 +70,10 @@
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "@open-mercato/shared": "0.5.1-develop.2744.9c8be0dd93"
+    "@open-mercato/shared": "0.5.1-develop.2762.90c271efe2"
   },
   "devDependencies": {
-    "@open-mercato/shared": "0.5.1-develop.2744.9c8be0dd93",
+    "@open-mercato/shared": "0.5.1-develop.2762.90c271efe2",
     "@types/jest": "^30.0.0",
     "jest": "^30.3.0",
     "ts-jest": "^29.4.9"

package/src/__tests__/mercato.test.ts

@@ -350,6 +350,109 @@ describe('init command failure output', () => {
     consoleErrorSpy.mockRestore()
     consoleLogSpy.mockRestore()
   })
+
+  it('keeps init successful when lean presets disable optional modules', async () => {
+    const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation()
+    const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation()
+
+    const configsRestoreDefaults = jest.fn().mockResolvedValue(undefined)
+    const authSetup = jest.fn().mockResolvedValue(undefined)
+    const authSeedRoles = jest.fn().mockResolvedValue(undefined)
+    const entitiesSeedEncryption = jest.fn().mockResolvedValue(undefined)
+    const queryIndexReindex = jest.fn().mockResolvedValue(undefined)
+
+    jest.doMock('child_process', () => ({
+      execSync: jest.fn(),
+    }))
+    jest.doMock('pg', () => ({
+      Client: jest.fn().mockImplementation(() => ({
+        connect: jest.fn().mockResolvedValue(undefined),
+        query: jest.fn().mockResolvedValue({
+          rows: [{ org_id: 'org-1', tenant_id: 'tenant-1' }],
+        }),
+        end: jest.fn().mockResolvedValue(undefined),
+      })),
+    }))
+    jest.doMock('../lib/generators', () => ({
+      generateEntityIds: jest.fn().mockResolvedValue(undefined),
+      generateModuleRegistry: jest.fn().mockResolvedValue(undefined),
+      generateModuleRegistryApp: jest.fn().mockResolvedValue(undefined),
+      generateModuleRegistryCli: jest.fn().mockResolvedValue(undefined),
+      generateModuleEntities: jest.fn().mockResolvedValue(undefined),
+      generateModuleDi: jest.fn().mockResolvedValue(undefined),
+      generateModulePackageSources: jest.fn().mockResolvedValue(undefined),
+      generateOpenApi: jest.fn().mockResolvedValue(undefined),
+    }))
+    jest.doMock('../lib/db', () => ({
+      dbMigrate: jest.fn().mockResolvedValue(undefined),
+    }))
+    jest.doMock('../lib/resolver', () => ({
+      createResolver: () => ({
+        getAppDir: () => '/tmp/test-app',
+      }),
+    }))
+    jest.doMock('@open-mercato/shared/lib/bootstrap/dynamicLoader', () => ({
+      bootstrapFromAppRoot: jest.fn().mockResolvedValue({
+        modules: [
+          {
+            id: 'configs',
+            cli: [{ command: 'restore-defaults', run: configsRestoreDefaults }],
+          },
+          {
+            id: 'auth',
+            cli: [
+              { command: 'setup', run: authSetup },
+              { command: 'seed-roles', run: authSeedRoles },
+            ],
+          },
+          {
+            id: 'entities',
+            cli: [{ command: 'seed-encryption', run: entitiesSeedEncryption }],
+          },
+          {
+            id: 'query_index',
+            cli: [{ command: 'reindex', run: queryIndexReindex }],
+          },
+        ],
+      }),
+    }))
+    jest.doMock('@open-mercato/shared/lib/di/container', () => ({
+      createRequestContainer: jest.fn().mockResolvedValue({
+        resolve: jest.fn().mockReturnValue({}),
+      }),
+    }))
+    jest.doMock(
+      '@open-mercato/core/modules/auth/lib/setup-app',
+      () => ({
+        ensureCustomRoleAcls: jest.fn().mockResolvedValue(undefined),
+      }),
+      { virtual: true },
+    )
+
+    const mercato = await import('../mercato')
+    const exitCode = await mercato.run(['node', 'mercato', 'init'])
+
+    expect(exitCode).toBe(0)
+    expect(consoleErrorSpy).not.toHaveBeenCalled()
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      '⏭️  Skipping "feature_toggles:seed-defaults" — module not enabled',
+    )
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      '⏭️  Skipping "dashboards:seed-defaults" — module not enabled',
+    )
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      '⏭️  Skipping "dashboards:enable-analytics-widgets" — module not enabled',
+    )
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      '⏭️  Skipping "search:reindex" — module not enabled',
+    )
+    expect(configsRestoreDefaults).toHaveBeenCalled()
+    expect(authSetup).toHaveBeenCalled()
+    expect(queryIndexReindex).toHaveBeenCalledWith(['--force', '--tenant', 'tenant-1'])
+
+    consoleErrorSpy.mockRestore()
+    consoleLogSpy.mockRestore()
+  })
 })
 
 describe('generate post-step structural cache purge', () => {
@@ -456,3 +559,125 @@ describe('generate post-step structural cache purge', () => {
     consoleLogSpy.mockRestore()
   })
 })
+
+describe('server dev managed process exits', () => {
+  const originalAutoSpawnScheduler = process.env.AUTO_SPAWN_SCHEDULER
+
+  beforeEach(() => {
+    jest.restoreAllMocks()
+    jest.resetModules()
+    process.env.AUTO_SPAWN_SCHEDULER = 'false'
+  })
+
+  afterEach(() => {
+    jest.dontMock('child_process')
+    jest.dontMock('node:fs')
+    jest.dontMock('../lib/generators')
+    jest.dontMock('../lib/resolver')
+    jest.resetModules()
+  })
+
+  afterAll(() => {
+    process.env.AUTO_SPAWN_SCHEDULER = originalAutoSpawnScheduler
+  })
+
+  it('fails loudly when a managed child exits cleanly but unexpectedly', async () => {
+    const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation()
+    const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation()
+
+    jest.doMock('node:fs', () => {
+      const actual = jest.requireActual('node:fs')
+      return {
+        ...actual,
+        existsSync: jest.fn((candidate: string) =>
+          candidate.includes('next/dist/bin/next') || candidate.includes('@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')
+
+      const createChild = (
+        spawnargs: string[],
+        autoExit?: { code: number | null; signal?: NodeJS.Signals | null },
+      ) => {
+        const child = new EventEmitter() as any
+        child.stdout = new EventEmitter()
+        child.stderr = new EventEmitter()
+        child.spawnargs = spawnargs
+        child.killed = false
+        child.exitCode = null
+        child.signalCode = null
+        child.kill = jest.fn((signal: NodeJS.Signals = 'SIGTERM') => {
+          child.killed = true
+          if (child.exitCode !== null || child.signalCode !== null) {
+            return true
+          }
+          child.signalCode = signal
+          queueMicrotask(() => {
+            child.emit('exit', null, signal)
+          })
+          return true
+        })
+
+        if (autoExit) {
+          queueMicrotask(() => {
+            if (child.exitCode !== null || child.signalCode !== null) return
+            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 (args[0]?.includes('next/dist/bin/next')) {
+            return createChild(['node', ...args])
+          }
+          if (args.slice(1).join(' ') === 'queue worker --all') {
+            return createChild(['node', ...args], { code: 0 })
+          }
+          return createChild(['node', ...args])
+        }),
+      }
+    })
+
+    const mercato = await import('../mercato')
+    mercato.registerCliModules([
+      {
+        id: 'events',
+        workers: [
+          {
+            queue: 'events',
+            concurrency: 1,
+            handler: jest.fn(),
+          },
+        ],
+      } as any,
+    ])
+
+    const exitCode = await mercato.run(['node', 'mercato', 'server', 'dev'])
+
+    expect(exitCode).toBe(1)
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      '💥 Failed: [server] Queue worker exited unexpectedly with exit code 0.',
+    )
+
+    consoleErrorSpy.mockRestore()
+    consoleLogSpy.mockRestore()
+  })
+})

package/src/lib/testing/integration.ts

@@ -217,6 +217,8 @@ const EPHEMERAL_ENV_FILE_PATH = path.join(projectRootDirectory, '.ai', 'qa', 'ep
 const EPHEMERAL_ENV_LOCK_PATH = path.join(projectRootDirectory, '.ai', 'qa', 'ephemeral-env.lock')
 const LEGACY_EPHEMERAL_ENV_FILE_PATH = path.join(projectRootDirectory, '.ai', 'qa', 'ephemeral-env.md')
 const EPHEMERAL_BUILD_CACHE_STATE_PATH = path.join(projectRootDirectory, '.ai', 'qa', 'ephemeral-build-cache.json')
+const EPHEMERAL_CACHE_DB_PATH = path.join(projectRootDirectory, '.ai', 'qa', 'ephemeral-cache.sqlite')
+const EPHEMERAL_QUEUE_BASE_DIR = path.join(appDirectory, '.mercato', 'queue')
 const PLAYWRIGHT_INTEGRATION_CONFIG_PATH = '.ai/qa/tests/playwright.config.ts'
 const PLAYWRIGHT_RESULTS_JSON_PATH = path.join(projectRootDirectory, '.ai', 'qa', 'test-results', 'results.json')
 const LEGACY_INTEGRATION_TEST_ROOT = path.join(projectRootDirectory, '.ai', 'qa', 'tests')
@@ -2855,9 +2857,13 @@ export async function startEphemeralEnvironment(options: EphemeralRuntimeOptions
     const databaseHost = databaseContainer.getHost()
     const databasePort = databaseContainer.getMappedPort(5432)
     const databaseUrl = `postgres://${databaseUser}:${databasePassword}@${databaseHost}:${databasePort}/${databaseName}`
+    await rm(EPHEMERAL_CACHE_DB_PATH, { force: true }).catch(() => undefined)
+    await rm(EPHEMERAL_QUEUE_BASE_DIR, { recursive: true, force: true }).catch(() => undefined)
     const enterpriseModulesFlag = process.env.OM_ENABLE_ENTERPRISE_MODULES ?? 'false'
     const commandEnvironment = buildEnvironment({
       DATABASE_URL: databaseUrl,
+      CACHE_STRATEGY: 'sqlite',
+      CACHE_SQLITE_PATH: EPHEMERAL_CACHE_DB_PATH,
       BASE_URL: applicationBaseUrl,
       APP_URL: applicationBaseUrl,
       NEXT_PUBLIC_APP_URL: applicationBaseUrl,
@@ -2889,6 +2895,7 @@ export async function startEphemeralEnvironment(options: EphemeralRuntimeOptions
       AUTO_SPAWN_SCHEDULER: 'false',
       OM_CLI_QUIET: '1',
       MERCATO_QUIET: '1',
+      QUEUE_BASE_DIR: EPHEMERAL_QUEUE_BASE_DIR,
       NODE_NO_WARNINGS: '1',
       PORT: String(applicationPort),
       PW_CAPTURE_SCREENSHOTS: options.captureScreenshots ? '1' : '0',

package/src/mercato.ts

@@ -305,6 +305,38 @@ function buildServerProcessEnvironment(environment: NodeJS.ProcessEnv): NodeJS.P
   return runtimeEnv
 }
 
+type ManagedProcessExitResult = {
+  label: string
+  code: number | null
+  signal: NodeJS.Signals | null
+}
+
+function waitForManagedProcessExit(proc: ChildProcess, label: string): Promise<ManagedProcessExitResult> {
+  return new Promise((resolve) => {
+    proc.on('exit', (code, signal) => {
+      resolve({ label, code, signal })
+    })
+  })
+}
+
+function isExpectedManagedExitSignal(signal: NodeJS.Signals | null): boolean {
+  return signal === 'SIGINT' || signal === 'SIGTERM'
+}
+
+function formatManagedProcessExitStatus(result: ManagedProcessExitResult): string {
+  if (typeof result.code === 'number') {
+    return `exit code ${result.code}`
+  }
+  if (result.signal) {
+    return `signal ${result.signal}`
+  }
+  return 'an unknown status'
+}
+
+function createManagedProcessExitError(result: ManagedProcessExitResult): Error {
+  return new Error(`[server] ${result.label} exited unexpectedly with ${formatManagedProcessExitStatus(result)}.`)
+}
+
 function ensureNextBuildIdInConfiguredDistDir(appDir: string): void {
   const configuredDistDir = path.join(appDir, '.mercato', 'next')
   const configuredBuildIdPath = path.join(configuredDistDir, 'BUILD_ID')
@@ -371,14 +403,14 @@ async function runModuleCommand(
   commandName: string,
   args: string[] = [],
   options: { optional?: boolean; silentOptional?: boolean } = {},
-): Promise<void> {
+): Promise<boolean> {
   const mod = allModules.find((m) => m.id === moduleName)
   if (!mod) {
     if (options.optional) {
       if (!options.silentOptional) {
         console.log(`⏭️  Skipping "${moduleName}:${commandName}" — module not enabled`)
       }
-      return
+      return false
     }
     throw new Error(`Module not found: "${moduleName}"`)
   }
@@ -387,7 +419,7 @@ async function runModuleCommand(
       if (!options.silentOptional) {
         console.log(`⏭️  Skipping "${moduleName}:${commandName}" — module has no CLI commands`)
       }
-      return
+      return false
     }
     throw new Error(`Module "${moduleName}" has no CLI commands`)
   }
@@ -397,11 +429,12 @@ async function runModuleCommand(
       if (!options.silentOptional) {
         console.log(`⏭️  Skipping "${moduleName}:${commandName}" — command not found`)
       }
-      return
+      return false
     }
     throw new Error(`Command "${commandName}" not found in module "${moduleName}"`)
   }
   await cmd.run(args)
+  return true
 }
 
 async function runPostGenerateStructuralCachePurge(quiet: boolean): Promise<void> {
@@ -760,8 +793,11 @@ export async function run(argv = process.argv) {
       console.log('✅ RBAC setup complete:', { tenantId, organizationId: orgId }, '\n')
 
       console.log('🎛️  Seeding feature toggle defaults...')
-      await runModuleCommand(allModules, 'feature_toggles', 'seed-defaults', [])
-      console.log('🎛️  ✅ Feature toggle defaults seeded\n')
+      if (await runModuleCommand(allModules, 'feature_toggles', 'seed-defaults', [], { optional: true })) {
+        console.log('🎛️  ✅ Feature toggle defaults seeded\n')
+      } else {
+        console.log('')
+      }
 
       if (tenantId) {
         console.log('👥 Seeding tenant-scoped roles...')
@@ -828,22 +864,31 @@ export async function run(argv = process.argv) {
           )
           const stressArgs = ['--tenant', tenantId, '--org', orgId, '--count', String(stressTestCount)]
           if (stressTestLite) stressArgs.push('--lite')
-          await runModuleCommand(allModules, 'customers', 'seed-stresstest', stressArgs, { optional: true })
-          console.log(`✅ Stress test customers seeded (requested ${stressTestCount})\n`)
+          if (await runModuleCommand(allModules, 'customers', 'seed-stresstest', stressArgs, { optional: true })) {
+            console.log(`✅ Stress test customers seeded (requested ${stressTestCount})\n`)
+          } else {
+            console.log('')
+          }
         }
 
         console.log('🧩 Enabling default dashboard widgets...')
-        await runModuleCommand(allModules, 'dashboards', 'seed-defaults', ['--tenant', tenantId], { optional: true })
-        console.log('✅ Dashboard widgets enabled\n')
+        if (await runModuleCommand(allModules, 'dashboards', 'seed-defaults', ['--tenant', tenantId], { optional: true })) {
+          console.log('✅ Dashboard widgets enabled\n')
+        } else {
+          console.log('')
+        }
 
         console.log('📊 Enabling analytics widgets for admin and employee roles...')
-        await runModuleCommand(allModules, 'dashboards', 'enable-analytics-widgets', [
+        if (await runModuleCommand(allModules, 'dashboards', 'enable-analytics-widgets', [
           '--tenant',
           tenantId,
           '--roles',
           'admin,employee',
-        ])
-        console.log('✅ Analytics widgets enabled for roles\n')
+        ], { optional: true })) {
+          console.log('✅ Analytics widgets enabled for roles\n')
+        } else {
+          console.log('')
+        }
 
       } else {
         console.log('⚠️  Could not get organization ID or tenant ID, skipping seeding steps\n')
@@ -853,13 +898,19 @@ export async function run(argv = process.argv) {
       const vectorArgs = tenantId
         ? ['--tenant', tenantId, ...(orgId ? ['--org', orgId] : [])]
         : ['--purgeFirst=false']
-      await runModuleCommand(allModules, 'search', 'reindex', vectorArgs, { optional: true })
-      console.log('✅ Search indexes built\n')
+      if (await runModuleCommand(allModules, 'search', 'reindex', vectorArgs, { optional: true })) {
+        console.log('✅ Search indexes built\n')
+      } else {
+        console.log('')
+      }
 
       console.log('🔍 Rebuilding query indexes...')
       const queryIndexArgs = ['--force', ...(tenantId ? ['--tenant', tenantId] : [])]
-      await runModuleCommand(allModules, 'query_index', 'reindex', queryIndexArgs, { optional: true })
-      console.log('✅ Query indexes rebuilt\n')
+      if (await runModuleCommand(allModules, 'query_index', 'reindex', queryIndexArgs, { optional: true })) {
+        console.log('✅ Query indexes rebuilt\n')
+      } else {
+        console.log('')
+      }
 
       const adminPasswordOverride = derivedSecrets.adminPassword
       const employeePasswordOverride = derivedSecrets.employeePassword
@@ -1598,11 +1649,11 @@ export async function run(argv = process.argv) {
           const nextBin = resolveInstalledBinary(nodeModulesBases, 'next/dist/bin/next')
           const mercatoBin = resolveInstalledBinary(nodeModulesBases, '@open-mercato/cli/bin/mercato')
 
-          const startNextDev = (): Promise<void> =>
+          const startNextDev = (): Promise<ManagedProcessExitResult> =>
             new Promise((resolve) => {
               const nextProcess = spawn('node', [nextBin, 'dev', '--turbopack'], {
                 stdio: ['inherit', 'pipe', 'pipe'],
-                env: process.env,
+                env: runtimeEnv,
                 cwd: appDir,
               })
               processes.push(nextProcess)
@@ -1626,19 +1677,23 @@ export async function run(argv = process.argv) {
                 appendOutput(text)
               })
 
-              nextProcess.on('exit', async () => {
+              nextProcess.on('exit', async (code, signal) => {
                 if (!didRetryCorruptedTurbopackCache && isTurbopackCacheCorruption(combinedOutput)) {
                   didRetryCorruptedTurbopackCache = true
                   console.log('[server] Detected corrupted Turbopack dev cache. Clearing .mercato/next/dev and restarting Next.js once...')
                   removeTurbopackDevCache(appDir)
-                  await startNextDev()
-                  return resolve()
+                  return resolve(await startNextDev())
                 }
-                resolve()
+                resolve({
+                  label: 'Next.js dev server',
+                  code,
+                  signal,
+                })
               })
             })
 
           const nextExitPromise = startNextDev()
+          const managedExitPromises: Promise<ManagedProcessExitResult>[] = [nextExitPromise]
 
           // Start workers if enabled
           if (autoSpawnWorkers) {
@@ -1649,10 +1704,11 @@ export async function run(argv = process.argv) {
               console.log('[server] Starting workers for all queues...')
               const workerProcess = spawn('node', [mercatoBin, 'queue', 'worker', '--all'], {
                 stdio: 'inherit',
-                env: process.env,
+                env: runtimeEnv,
                 cwd: appDir,
               })
               processes.push(workerProcess)
+              managedExitPromises.push(waitForManagedProcessExit(workerProcess, 'Queue worker'))
             }
           }
 
@@ -1660,28 +1716,20 @@ export async function run(argv = process.argv) {
             console.log('[server] Starting scheduler polling engine...')
             const schedulerProcess = spawn('node', [mercatoBin, 'scheduler', 'start'], {
               stdio: 'inherit',
-              env: process.env,
+              env: runtimeEnv,
               cwd: appDir,
             })
             processes.push(schedulerProcess)
+            managedExitPromises.push(waitForManagedProcessExit(schedulerProcess, 'Scheduler polling engine'))
           }
 
-          // Wait for any process to exit
-          await Promise.race(
-            [
-              nextExitPromise,
-              ...processes
-                .filter((proc) => proc.spawnargs[1] !== nextBin)
-                .map(
-                  (proc) =>
-                    new Promise<void>((resolve) => {
-                      proc.on('exit', () => resolve())
-                    })
-                ),
-            ]
-          )
+          const firstExit = await Promise.race(managedExitPromises)
 
           await cleanupAndWait()
+
+          if (!isExpectedManagedExitSignal(firstExit.signal)) {
+            throw createManagedProcessExitError(firstExit)
+          }
         },
       },
       {