@open-mercato/cli 0.6.6-develop.6507.1.cc8b36505d → 0.6.6-develop.6513.1.12f0383844

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-mercato/cli",
-  "version": "0.6.6-develop.6507.1.cc8b36505d",
+  "version": "0.6.6-develop.6513.1.12f0383844",
   "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.6-develop.6507.1.cc8b36505d",
-    "@open-mercato/shared": "0.6.6-develop.6507.1.cc8b36505d",
+    "@open-mercato/queue": "0.6.6-develop.6513.1.12f0383844",
+    "@open-mercato/shared": "0.6.6-develop.6513.1.12f0383844",
     "cross-spawn": "^7.0.6",
     "pg": "8.22.0",
     "semver": "^7.8.5",
@@ -71,10 +71,10 @@
     "typescript": "^6.0.3"
   },
   "peerDependencies": {
-    "@open-mercato/shared": "0.6.6-develop.6507.1.cc8b36505d"
+    "@open-mercato/shared": "0.6.6-develop.6513.1.12f0383844"
   },
   "devDependencies": {
-    "@open-mercato/shared": "0.6.6-develop.6507.1.cc8b36505d",
+    "@open-mercato/shared": "0.6.6-develop.6513.1.12f0383844",
     "@types/jest": "^30.0.0",
     "jest": "^30.4.2",
     "ts-jest": "^29.4.11"

package/src/lib/__tests__/queue-worker-supervisor.test.ts

@@ -170,6 +170,97 @@ describe('startLazyWorkerSupervisor', () => {
     expect((child as any).kill).toHaveBeenCalledWith('SIGTERM')
   })
 
+  it('starts the shared worker with extra arguments when an embedded scheduler needs it', async () => {
+    const child = createFakeChild()
+    const spawnFn = jest.fn(() => child) as unknown as jest.MockedFunction<LazySupervisorSpawnFn>
+    const probeFn = jest.fn(async (queueName, strategy) =>
+      emptyProbe(queueName, strategy),
+    ) as jest.MockedFunction<LazySupervisorProbeFn>
+    const shouldStartSharedWorker = jest.fn(async () => true)
+
+    const handle = startLazyWorkerSupervisor({
+      mercatoBin: '/tmp/mercato',
+      appDir: '/tmp/app',
+      runtimeEnv: { ...process.env },
+      workers: [makeWorker('events')],
+      pollMs: 250,
+      restartOnUnexpectedExit: false,
+      strategy: 'local',
+      spawnMode: 'shared',
+      sharedWorkerArgs: ['--with-scheduler'],
+      shouldStartSharedWorker,
+      spawnFn,
+      probeFn,
+      logger: silentLogger,
+    })
+
+    await flushAsync(20)
+
+    expect(shouldStartSharedWorker).toHaveBeenCalled()
+    expect(spawnFn).toHaveBeenCalledTimes(1)
+    expect(spawnFn.mock.calls[0][1]).toEqual([
+      '/tmp/mercato',
+      'queue',
+      'worker',
+      '--all',
+      '--with-scheduler',
+    ])
+    expect(silentLogger.log).toHaveBeenCalledWith(
+      '[lazy-supervisor] Enabled schedule detected — starting shared worker for all queues',
+    )
+
+    await handle.close()
+  })
+
+  it('restarts the shared worker when an embedded scheduler remains enabled', async () => {
+    const firstChild = createFakeChild()
+    const secondChild = createFakeChild()
+    const spawnFn = jest
+      .fn()
+      .mockImplementationOnce(() => firstChild)
+      .mockImplementationOnce(() => secondChild) as unknown as jest.MockedFunction<LazySupervisorSpawnFn>
+    const probeFn = jest.fn(async (queueName, strategy) =>
+      emptyProbe(queueName, strategy),
+    ) as jest.MockedFunction<LazySupervisorProbeFn>
+    const shouldStartSharedWorker = jest.fn(async () => true)
+    const shouldRestartSharedWorker = jest.fn(async () => true)
+
+    const handle = startLazyWorkerSupervisor({
+      mercatoBin: '/tmp/mercato',
+      appDir: '/tmp/app',
+      runtimeEnv: { ...process.env },
+      workers: [makeWorker('events')],
+      pollMs: 250,
+      restartOnUnexpectedExit: true,
+      strategy: 'local',
+      spawnMode: 'shared',
+      sharedWorkerArgs: ['--with-scheduler'],
+      shouldStartSharedWorker,
+      shouldRestartSharedWorker,
+      spawnFn,
+      probeFn,
+      logger: silentLogger,
+    })
+
+    await flushAsync(20)
+    expect(spawnFn).toHaveBeenCalledTimes(1)
+
+    firstChild.triggerExit(1)
+    await flushAsync(40)
+
+    expect(shouldRestartSharedWorker).toHaveBeenCalled()
+    expect(spawnFn).toHaveBeenCalledTimes(2)
+    expect(spawnFn.mock.calls[1][1]).toEqual([
+      '/tmp/mercato',
+      'queue',
+      'worker',
+      '--all',
+      '--with-scheduler',
+    ])
+
+    await handle.close()
+  })
+
   it('does not spawn when probe reports an error', async () => {
     const spawnFn = jest.fn() as unknown as jest.MockedFunction<LazySupervisorSpawnFn>
     const probeFn = jest.fn(async (queueName, strategy) => ({

package/src/lib/queue-worker-supervisor.ts

@@ -52,6 +52,12 @@ export type LazyWorkerSupervisorOptions = {
   restartOnUnexpectedExit: boolean
   spawnMode?: LazyWorkerSpawnMode
   strategy?: QueueStrategyType
+  /** Start the shared worker even with no ready queue jobs (for an embedded scheduler). */
+  shouldStartSharedWorker?: () => Promise<boolean>
+  /** Restart the shared worker with no ready queue jobs after an unexpected exit. */
+  shouldRestartSharedWorker?: () => Promise<boolean>
+  /** Extra arguments for the shared worker command only. */
+  sharedWorkerArgs?: readonly string[]
   /** Override for tests. Defaults to `child_process.spawn`. */
   spawnFn?: LazySupervisorSpawnFn
   /** Override for tests. Defaults to `getQueuePendingProbe`. */
@@ -236,21 +242,25 @@ export function startLazyWorkerSupervisor(
     })
   }
 
-  function spawnSharedWorker(triggerQueueNames: string[]): void {
+  function spawnSharedWorker(triggerQueueNames: string[], schedulerTriggered = false): void {
     if (stopping) return
     if (activeSharedChild) return
     if (startingSharedWorker) return
     startingSharedWorker = true
 
-    const triggerSummary = triggerQueueNames.length > 0
-      ? ` after pending job(s) on ${triggerQueueNames.join(', ')}`
-      : ''
-    logger.log(`[lazy-supervisor] Pending job detected${triggerSummary} — starting shared worker for all queues`)
+    if (schedulerTriggered) {
+      logger.log('[lazy-supervisor] Enabled schedule detected — starting shared worker for all queues')
+    } else {
+      const triggerSummary = triggerQueueNames.length > 0
+        ? ` in ${triggerQueueNames.join(', ')}`
+        : ''
+      logger.log(`[lazy-supervisor] Pending job detected${triggerSummary} — starting shared worker for all queues`)
+    }
     let child: ChildProcess
     try {
       child = spawnFn(
         'node',
-        [options.mercatoBin, 'queue', 'worker', '--all'],
+        [options.mercatoBin, 'queue', 'worker', '--all', ...(options.sharedWorkerArgs ?? [])],
         {
           stdio: 'inherit',
           env: options.runtimeEnv,
@@ -306,6 +316,18 @@ export function startLazyWorkerSupervisor(
         if (readyQueues.length > 0) {
           logger.warn('[lazy-supervisor] Restarting shared worker because jobs remain pending.')
           spawnSharedWorker(readyQueues)
+          return
+        }
+        if (options.shouldRestartSharedWorker) {
+          try {
+            if (await options.shouldRestartSharedWorker()) {
+              logger.warn('[lazy-supervisor] Restarting shared worker because an enabled schedule remains.')
+              spawnSharedWorker([], true)
+            }
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err)
+            logger.warn(`[lazy-supervisor] Shared-worker restart condition failed: ${message}`)
+          }
         }
       })()
     })
@@ -355,8 +377,21 @@ export function startLazyWorkerSupervisor(
         spawnQueueWorker(group.queueName)
       }
     }
-    if (spawnMode === 'shared' && readySharedQueues.length > 0) {
-      spawnSharedWorker(readySharedQueues)
+    if (spawnMode === 'shared') {
+      if (readySharedQueues.length > 0) {
+        spawnSharedWorker(readySharedQueues)
+        return
+      }
+      if (options.shouldStartSharedWorker) {
+        try {
+          if (await options.shouldStartSharedWorker()) {
+            spawnSharedWorker([], true)
+          }
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err)
+          logger.warn(`[lazy-supervisor] Shared-worker start condition failed: ${message}`)
+        }
+      }
     }
   }
 

package/src/mercato.ts

@@ -1,7 +1,7 @@
 // Note: Generated files and DI container are imported statically to avoid ESM/CJS interop issues.
 // Commands that need to run before generation (e.g., `init`) handle missing modules gracefully.
 
-import { runWorker } from '@open-mercato/queue/worker'
+import { registerWorkerShutdownHook, runWorker } from '@open-mercato/queue/worker'
 import type { Module, ModuleWorker } from '@open-mercato/shared/modules/registry'
 import { getCliModules, hasCliModules, registerCliModules } from './registry'
 export { getCliModules, hasCliModules, registerCliModules }
@@ -28,7 +28,7 @@ import {
   resolveLazySchedulerPollMs,
   resolveLazySchedulerRestart,
 } from './lib/auto-spawn-scheduler'
-import { startLazySchedulerSupervisor } from './lib/scheduler-supervisor'
+import { probeEnabledSchedules, startLazySchedulerSupervisor } from './lib/scheduler-supervisor'
 import {
   startInProcessGenerateWatcher,
   type GenerateWatcherHandle,
@@ -77,6 +77,10 @@ function getRegisteredCliWorkers(modules: Module[] = getCliModules()): ModuleWor
   return allWorkers
 }
 
+function shouldEmbedLocalSchedulerInSharedWorker(env: NodeJS.ProcessEnv = process.env): boolean {
+  return parseBooleanToken(env.OM_DEV_EMBED_SCHEDULER_IN_SHARED_WORKER) === true
+}
+
 export function padByCodePointWidth(value: string, targetWidth: number): string {
   const valueWidth = [...value].length
   if (valueWidth >= targetWidth) return value
@@ -1548,6 +1552,7 @@ export async function run(argv = process.argv) {
         command: 'worker',
         run: async (args: string[]) => {
           const isAllQueues = args.includes('--all')
+          const runSchedulerInWorker = isAllQueues && args.includes('--with-scheduler')
           const queueName = isAllQueues ? null : args[0]
 
           // Collect all discovered workers from modules
@@ -1616,6 +1621,26 @@ export async function run(argv = process.argv) {
 
             await Promise.all(workerPromises)
 
+            if (runSchedulerInWorker) {
+              const queueStrategy = process.env.QUEUE_STRATEGY || 'local'
+              if (queueStrategy !== 'local') {
+                throw new Error('[worker] --with-scheduler is supported only with QUEUE_STRATEGY=local.')
+              }
+              const schedulerContainer = await createRequestContainer()
+              const localScheduler = schedulerContainer.resolve('localSchedulerService') as {
+                start?: () => Promise<void>
+                stop?: () => Promise<void>
+              } | undefined
+              if (!localScheduler?.start || !localScheduler.stop) {
+                throw new Error('[worker] Local scheduler service is unavailable.')
+              }
+              await localScheduler.start()
+              registerWorkerShutdownHook(async () => {
+                await localScheduler.stop?.()
+              })
+              console.log('[worker] Local scheduler started in the shared worker process.')
+            }
+
             console.log('[worker] All workers started. Press Ctrl+C to stop')
 
             // Keep the process alive
@@ -2088,6 +2113,13 @@ export async function run(argv = process.argv) {
               const autoSpawnSchedulerMode = resolveAutoSpawnSchedulerMode(process.env)
               const queueStrategy = process.env.QUEUE_STRATEGY || 'local'
               const schedulerCommand = lookupModuleCommand(getCliModules(), 'scheduler', 'start')
+              const embedSchedulerInSharedWorker =
+                shouldEmbedLocalSchedulerInSharedWorker(process.env)
+                && queueStrategy === 'local'
+                && autoSpawnWorkersMode === 'lazy'
+                && resolveLazySpawnMode(process.env) === 'shared'
+                && autoSpawnSchedulerMode !== 'off'
+                && schedulerCommand.status === 'ok'
               const nextRuntime = startNextDev(runtimeEnv)
               const restartPromise = waitForDevRestart()
               const backgroundStartAbort = new AbortController()
@@ -2139,6 +2171,23 @@ export async function run(argv = process.argv) {
                       pollMs: resolveLazyPollMs(process.env),
                       restartOnUnexpectedExit: resolveLazyRestart(process.env),
                       spawnMode: lazySpawnMode,
+                      ...(embedSchedulerInSharedWorker
+                        ? {
+                            sharedWorkerArgs: ['--with-scheduler'],
+                            shouldStartSharedWorker: async () => {
+                              const schedules = await probeEnabledSchedules(runtimeEnv)
+                              return !schedules.error && schedules.enabledSchedules > 0
+                            },
+                            ...(resolveLazySchedulerRestart(process.env)
+                              ? {
+                                  shouldRestartSharedWorker: async () => {
+                                    const schedules = await probeEnabledSchedules(runtimeEnv)
+                                    return !schedules.error && schedules.enabledSchedules > 0
+                                  },
+                                }
+                              : {}),
+                          }
+                        : {}),
                     })
                   } else {
                     console.log('[server] Eager worker auto-spawn enabled - starting workers for all queues...')
@@ -2152,7 +2201,9 @@ export async function run(argv = process.argv) {
                   }
                 }
 
-                if (autoSpawnSchedulerMode !== 'off' && queueStrategy === 'local') {
+                if (embedSchedulerInSharedWorker && activeLazySupervisor) {
+                  console.log('[server] Local scheduler will run inside the lazy shared worker process.')
+                } else if (autoSpawnSchedulerMode !== 'off' && queueStrategy === 'local') {
                   if (schedulerCommand.status !== 'ok') {
                     console.log(`[server] Skipping scheduler auto-start — ${describeMissingModuleCommand(schedulerCommand)}`)
                   } else if (autoSpawnSchedulerMode === 'lazy') {