@open-mercato/cli 0.4.9-develop-db9ecc46fc → 0.4.9-develop-d989387b7a

package/src/lib/testing/integration.ts

@@ -1,12 +1,13 @@
 import { GenericContainer } from 'testcontainers'
 import { spawn, type ChildProcess, type StdioOptions } from 'node:child_process'
 import { createServer } from 'node:net'
+import { existsSync, readFileSync } from 'node:fs'
 import { mkdir, readdir, readFile, rm, stat, writeFile } from 'node:fs/promises'
 import { createHash } from 'node:crypto'
 import path from 'node:path'
 import { createInterface, type Interface } from 'node:readline/promises'
 import { stdin as input, stdout as output } from 'node:process'
-import { createResolver } from '../resolver'
+import { resolveEnvironment } from '../resolver'
 import { discoverIntegrationSpecFiles as discoverIntegrationSpecFilesShared } from './integration-discovery'
 import { resolveDockerHostFromContext, runCommandAndCapture } from './runtime-utils'
 
@@ -162,8 +163,50 @@ const PLAYWRIGHT_QUICK_FAILURE_THRESHOLD = 6
 const PLAYWRIGHT_QUICK_FAILURE_MAX_DURATION_MS = 1_500
 const PLAYWRIGHT_HEALTH_PROBE_INTERVAL_MS = 3_000
 const ANSI_ESCAPE_REGEX = /\x1b\[[0-?]*[ -/]*[@-~]/g // NOSONAR — ANSI escape sequence pattern
-const resolver = createResolver()
-const projectRootDirectory = resolver.getRootDir()
+const env = resolveEnvironment()
+const projectRootDirectory = env.rootDir
+const appDirectory = env.appDir
+const corePackageRootDirectory = env.packageRoot('@open-mercato/core')
+const uiPackageRootDirectory = env.packageRoot('@open-mercato/ui')
+
+function resolveFirstExistingPath(...candidates: string[]): string | null {
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      return candidate
+    }
+  }
+  return null
+}
+
+function collectExistingPaths(candidates: Array<string | null | undefined>): string[] {
+  const collected = new Set<string>()
+  for (const candidate of candidates) {
+    if (candidate && existsSync(candidate)) {
+      collected.add(candidate)
+    }
+  }
+  return Array.from(collected)
+}
+
+function readPackageScripts(packageRoot: string): Record<string, string> {
+  try {
+    const raw = JSON.parse(readFileSync(path.join(packageRoot, 'package.json'), 'utf8')) as {
+      scripts?: Record<string, string>
+    }
+    return raw.scripts ?? {}
+  } catch {
+    return {}
+  }
+}
+
+const projectScripts = readPackageScripts(projectRootDirectory)
+const appNextConfigPath = resolveFirstExistingPath(
+  path.join(appDirectory, 'next.config.ts'),
+  path.join(appDirectory, 'next.config.js'),
+  path.join(appDirectory, 'next.config.mjs'),
+)
+const APP_MODULES_CHECKSUM_PATH = path.join(appDirectory, '.mercato', 'generated', 'modules.generated.checksum')
+const PROJECT_SUPPORTS_PACKAGE_BUILDS = typeof projectScripts['build:packages'] === 'string'
 const EPHEMERAL_ENV_FILE_PATH = path.join(projectRootDirectory, '.ai', 'qa', 'ephemeral-env.json')
 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')
@@ -172,26 +215,26 @@ 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')
 const APP_BUILD_ARTIFACTS = [
-  path.join(projectRootDirectory, 'apps', 'mercato', '.mercato', 'next', 'BUILD_ID'),
-  path.join(projectRootDirectory, 'apps', 'mercato', '.mercato', 'generated', 'modules.generated.ts'),
-  path.join(projectRootDirectory, 'packages', 'core', 'dist', 'index.js'),
-  path.join(projectRootDirectory, 'packages', 'ui', 'dist', 'index.js'),
+  path.join(appDirectory, '.mercato', 'next', 'BUILD_ID'),
+  path.join(appDirectory, '.mercato', 'generated', 'modules.generated.ts'),
+  path.join(corePackageRootDirectory, 'dist', 'index.js'),
+  path.join(uiPackageRootDirectory, 'dist', 'index.js'),
 ]
-const APP_BUILD_INPUT_PATHS = [
-  path.join(projectRootDirectory, 'apps', 'mercato', 'src'),
-  path.join(projectRootDirectory, 'apps', 'mercato', 'package.json'),
-  path.join(projectRootDirectory, 'apps', 'mercato', 'next.config.ts'),
-  path.join(projectRootDirectory, 'apps', 'mercato', 'tsconfig.json'),
-  path.join(projectRootDirectory, 'packages', 'core', 'src'),
-  path.join(projectRootDirectory, 'packages', 'core', 'package.json'),
-  path.join(projectRootDirectory, 'packages', 'core', 'tsconfig.json'),
-  path.join(projectRootDirectory, 'packages', 'ui', 'src'),
-  path.join(projectRootDirectory, 'packages', 'ui', 'package.json'),
-  path.join(projectRootDirectory, 'packages', 'ui', 'tsconfig.json'),
+const APP_BUILD_INPUT_PATHS = collectExistingPaths([
+  path.join(appDirectory, 'src'),
+  path.join(appDirectory, 'package.json'),
+  appNextConfigPath,
+  path.join(appDirectory, 'tsconfig.json'),
+  resolveFirstExistingPath(path.join(corePackageRootDirectory, 'src'), path.join(corePackageRootDirectory, 'dist')),
+  path.join(corePackageRootDirectory, 'package.json'),
+  path.join(corePackageRootDirectory, 'tsconfig.json'),
+  resolveFirstExistingPath(path.join(uiPackageRootDirectory, 'src'), path.join(uiPackageRootDirectory, 'dist')),
+  path.join(uiPackageRootDirectory, 'package.json'),
+  path.join(uiPackageRootDirectory, 'tsconfig.json'),
   path.join(projectRootDirectory, 'package.json'),
   path.join(projectRootDirectory, 'tsconfig.base.json'),
   path.join(projectRootDirectory, 'yarn.lock'),
-]
+])
 const EXPECTED_TEST_FOLDERS = ['auth', 'catalog', 'crm', 'sales', 'admin', 'api', 'integration'] as const
 const FOLDER_TO_CATEGORY_CODE: Record<string, string> = {
   admin: 'ADMIN',
@@ -295,8 +338,9 @@ function runYarnCommand(
   args: string[],
   environment: NodeJS.ProcessEnv,
   opts: { silent?: boolean } = {},
+  cwd: string = projectRootDirectory,
 ): Promise<void> {
-  return runYarnRawCommand(['run', ...args], environment, opts)
+  return runYarnRawCommand(['run', ...args], environment, opts, cwd)
 }
 
 async function runTimedStep<T>(
@@ -543,11 +587,12 @@ function runYarnRawCommand(
   commandArgs: string[],
   environment: NodeJS.ProcessEnv,
   opts: { silent?: boolean } = {},
+  cwd: string = projectRootDirectory,
 ): Promise<void> {
   return new Promise((resolve, reject) => {
     const outputMode: StdioOptions = opts.silent ? ['ignore', 'pipe', 'pipe'] : 'inherit'
     const command: ChildProcess = spawn(resolveYarnBinary(), commandArgs, {
-      cwd: projectRootDirectory,
+      cwd,
       env: environment,
       stdio: outputMode,
     })
@@ -593,24 +638,15 @@ function runNpxCommand(args: string[], environment: NodeJS.ProcessEnv): Promise<
   })
 }
 
-function runYarnWorkspaceCommand(
-  workspaceName: string,
-  commandName: string,
-  commandArgs: string[],
-  environment: NodeJS.ProcessEnv,
-  opts: { silent?: boolean } = {},
-): Promise<void> {
-  return runYarnRawCommand(['workspace', workspaceName, commandName, ...commandArgs], environment, opts)
-}
-
 function startYarnRawCommand(
   commandArgs: string[],
   environment: NodeJS.ProcessEnv,
   opts: { silent?: boolean } = {},
+  cwd: string = projectRootDirectory,
 ): ChildProcess {
   const outputMode: StdioOptions = opts.silent ? ['ignore', 'pipe', 'pipe'] : 'inherit'
   const processHandle: ChildProcess = spawn(resolveYarnBinary(), commandArgs, {
-    cwd: projectRootDirectory,
+    cwd,
     env: environment,
     stdio: outputMode,
   })
@@ -621,14 +657,13 @@ function startYarnRawCommand(
   return processHandle
 }
 
-function startYarnWorkspaceCommand(
-  workspaceName: string,
-  commandName: string,
-  commandArgs: string[],
+function startYarnCommand(
+  args: string[],
   environment: NodeJS.ProcessEnv,
   opts: { silent?: boolean } = {},
+  cwd: string = projectRootDirectory,
 ): ChildProcess {
-  return startYarnRawCommand(['workspace', workspaceName, commandName, ...commandArgs], environment, opts)
+  return startYarnRawCommand(['run', ...args], environment, opts, cwd)
 }
 
 async function assertContainerRuntimeAvailable(): Promise<void> {
@@ -2501,7 +2536,6 @@ export async function startEphemeralEnvironment(options: EphemeralRuntimeOptions
       }
     }
 
-    const appWorkspace = '@open-mercato/app'
     const shouldUseIsolatedPort = shouldUseIsolatedPortForFreshEnvironment({
       reuseExisting: options.reuseExisting,
       existingStateBeforeReuseAttempt,
@@ -2607,9 +2641,9 @@ export async function startEphemeralEnvironment(options: EphemeralRuntimeOptions
       console.log(`[${options.logPrefix}] Ephemeral database ready at ${databaseHost}:${databasePort}`)
       console.log(`[${options.logPrefix}] Initializing application data (includes migrations)...`)
       await runTimedStep(options.logPrefix, 'Initializing application data', { expectedSeconds: 45 }, async () =>
-        runYarnWorkspaceCommand(appWorkspace, 'initialize', [], commandEnvironment, {
+        runYarnCommand(['initialize'], commandEnvironment, {
           silent: !options.verbose,
-        }))
+        }, appDirectory))
 
       if (!needsBuild) {
         console.log(
@@ -2621,32 +2655,38 @@ export async function startEphemeralEnvironment(options: EphemeralRuntimeOptions
         } else {
           console.log(`[${options.logPrefix}] Build artifacts missing, stale, or out of date; rebuilding artifacts.`)
         }
-        console.log(`[${options.logPrefix}] Building packages...`)
-        await runTimedStep(options.logPrefix, 'Building packages', { expectedSeconds: 20 }, async () =>
-          runYarnCommand(['build:packages'], commandEnvironment, {
-            silent: !options.verbose,
-          }))
+        if (PROJECT_SUPPORTS_PACKAGE_BUILDS) {
+          console.log(`[${options.logPrefix}] Building packages...`)
+          await runTimedStep(options.logPrefix, 'Building packages', { expectedSeconds: 20 }, async () =>
+            runYarnCommand(['build:packages'], commandEnvironment, {
+              silent: !options.verbose,
+            }))
+        } else {
+          console.log(`[${options.logPrefix}] Skipping package build step (no build:packages script at project root).`)
+        }
 
         console.log(`[${options.logPrefix}] Regenerating module artifacts...`)
-        await rm(path.join(projectRootDirectory, 'apps', 'mercato', '.mercato', 'generated', 'modules.generated.checksum'), {
+        await rm(APP_MODULES_CHECKSUM_PATH, {
           force: true,
         })
         await runTimedStep(options.logPrefix, 'Regenerating module artifacts', { expectedSeconds: 8 }, async () =>
           runYarnCommand(['generate'], commandEnvironment, {
             silent: !options.verbose,
-          }))
-
-        console.log(`[${options.logPrefix}] Rebuilding packages after generation...`)
-        await runTimedStep(options.logPrefix, 'Rebuilding packages after generation', { expectedSeconds: 20 }, async () =>
-          runYarnCommand(['build:packages'], commandEnvironment, {
-            silent: !options.verbose,
-          }))
+          }, appDirectory))
+
+        if (PROJECT_SUPPORTS_PACKAGE_BUILDS) {
+          console.log(`[${options.logPrefix}] Rebuilding packages after generation...`)
+          await runTimedStep(options.logPrefix, 'Rebuilding packages after generation', { expectedSeconds: 20 }, async () =>
+            runYarnCommand(['build:packages'], commandEnvironment, {
+              silent: !options.verbose,
+            }))
+        }
 
         console.log(`[${options.logPrefix}] Building application...`)
         await runTimedStep(options.logPrefix, 'Building application', { expectedSeconds: 76 }, async () =>
-          runYarnWorkspaceCommand(appWorkspace, 'build', [], commandEnvironment, {
+          runYarnCommand(['build'], commandEnvironment, {
             silent: !options.verbose,
-          }))
+          }, appDirectory))
       }
 
       if (shouldPersistBuildCache && sourceFingerprintValue) {
@@ -2654,9 +2694,9 @@ export async function startEphemeralEnvironment(options: EphemeralRuntimeOptions
       }
 
       console.log(`[${options.logPrefix}] Starting application on ${applicationBaseUrl}...`)
-      const startedAppProcess = startYarnWorkspaceCommand(appWorkspace, 'start', [], commandEnvironment, {
+      const startedAppProcess = startYarnCommand(['start'], commandEnvironment, {
         silent: !options.verbose,
-      })
+      }, appDirectory)
       applicationProcess = startedAppProcess
 
       await runTimedStep(

package/src/mercato.ts

@@ -11,6 +11,7 @@ import { parseBooleanToken } from '@open-mercato/shared/lib/boolean'
 import { getSslConfig } from '@open-mercato/shared/lib/db/ssl'
 import { getRedisUrl } from '@open-mercato/shared/lib/redis/connection'
 import { resolveInitDerivedSecrets } from './lib/init-secrets'
+import { parseModuleInstallArgs } from './lib/module-install-args'
 // Lazy-imported to avoid pulling in `testcontainers` (devDependency) at startup
 const lazyIntegration = () => import('./lib/testing/integration')
 import type { ChildProcess } from 'node:child_process'
@@ -53,6 +54,51 @@ async function ensureEnvLoaded() {
   } catch {}
 }
 
+function resolveInstalledBinary(baseDirs: string[], relativeBinPath: string): string {
+  const checked = new Set<string>()
+  for (const baseDir of baseDirs) {
+    const candidate = path.join(baseDir, 'node_modules', relativeBinPath)
+    checked.add(candidate)
+    if (fs.existsSync(candidate)) return candidate
+  }
+  throw new Error(
+    `Could not find installed binary "${relativeBinPath}". Checked: ${Array.from(checked).join(', ')}`,
+  )
+}
+
+async function handleDirectEjectCommand(args: string[]): Promise<number> {
+  const { createResolver } = await import('./lib/resolver')
+  const { listEjectableModules, ejectModule } = await import('./lib/eject')
+  const resolver = createResolver()
+  const commandArgs = args.filter(Boolean)
+  const isList = commandArgs.includes('--list') || commandArgs.includes('-l')
+  const moduleId = isList ? undefined : commandArgs.find((arg) => !arg.startsWith('-'))
+
+  if (isList || !moduleId) {
+    const ejectable = listEjectableModules(resolver)
+    if (ejectable.length === 0) {
+      console.log('No ejectable modules found.')
+    } else {
+      console.log('Ejectable modules:\n')
+      for (const mod of ejectable) {
+        const desc = mod.description ? ` — ${mod.description}` : ''
+        console.log(`  ${mod.id} (from: ${mod.from})${desc}`)
+      }
+      console.log('\nUsage: yarn mercato eject <moduleId>')
+    }
+    return 0
+  }
+
+  console.log(`Ejecting module "${moduleId}"...`)
+  ejectModule(resolver, moduleId)
+  console.log(`\n✅ Module "${moduleId}" ejected successfully!\n`)
+  console.log('Next steps:')
+  console.log('  1. Run generators:  yarn mercato generate all')
+  console.log(`  2. Customize:       edit src/modules/${moduleId}/`)
+  console.log('  3. Start dev:       yarn dev')
+  return 0
+}
+
 // Helper to run a CLI command directly (without spawning a process)
 async function runModuleCommand(
   allModules: Module[],
@@ -274,13 +320,14 @@ export async function run(argv = process.argv) {
       // Step 1: Run generators directly (no process spawn)
       console.log('🔧 Preparing modules (registry, entities, DI)...')
       const { createResolver } = await import('./lib/resolver')
-      const { generateEntityIds, generateModuleRegistry, generateModuleRegistryCli, generateModuleEntities, generateModuleDi, generateOpenApi } = await import('./lib/generators')
+      const { generateEntityIds, generateModuleRegistry, generateModuleRegistryCli, generateModuleEntities, generateModuleDi, generateModulePackageSources, generateOpenApi } = await import('./lib/generators')
       const resolver = createResolver()
       await generateEntityIds({ resolver, quiet: true })
       await generateModuleRegistry({ resolver, quiet: true })
       await generateModuleRegistryCli({ resolver, quiet: true })
       await generateModuleEntities({ resolver, quiet: true })
       await generateModuleDi({ resolver, quiet: true })
+      await generateModulePackageSources({ resolver, quiet: true })
       await generateOpenApi({ resolver, quiet: true })
       console.log('✅ Modules prepared\n')
 
@@ -524,39 +571,72 @@ export async function run(argv = process.argv) {
     return exitCode
   }
 
-  // Handle eject command directly (bootstrap-free)
-  if (first === 'eject') {
+  if (first === 'module') {
     try {
-      const { createResolver } = await import('./lib/resolver')
-      const { listEjectableModules, ejectModule } = await import('./lib/eject')
-      const resolver = createResolver()
+      const subcommand = second
+      const commandArgs = remaining.filter(Boolean)
+
+      if (!subcommand || subcommand === 'help' || subcommand === '--help' || subcommand === '-h') {
+        console.log('Usage: yarn mercato module <add|enable|eject> ...')
+        console.log('  yarn mercato module add <packageSpec> [--module <moduleId>] [--eject]')
+        console.log('  yarn mercato module enable <packageName> [--module <moduleId>] [--eject]')
+        console.log('  yarn mercato module eject <moduleId>')
+        return 0
+      }
 
-      const isList = second === '--list' || second === '-l'
-      const moduleId = !isList ? second : undefined
+      if (subcommand === 'add') {
+        const { createResolver } = await import('./lib/resolver')
+        const { addOfficialModule } = await import('./lib/module-install')
+        const { packageSpec, eject, moduleId } = parseModuleInstallArgs(commandArgs)
 
-      if (isList || !moduleId) {
-        const ejectable = listEjectableModules(resolver)
-        if (ejectable.length === 0) {
-          console.log('No ejectable modules found.')
-        } else {
-          console.log('Ejectable modules:\n')
-          for (const mod of ejectable) {
-            const desc = mod.description ? ` — ${mod.description}` : ''
-            console.log(`  ${mod.id} (from: ${mod.from})${desc}`)
-          }
-          console.log('\nUsage: yarn mercato eject <moduleId>')
+        if (!packageSpec) {
+          console.error('Usage: yarn mercato module add <packageSpec> [--module <moduleId>] [--eject]')
+          return 1
         }
+
+        const result = await addOfficialModule(createResolver(), packageSpec, eject, moduleId ?? undefined)
+        console.log(`\n✅ Module "${result.moduleId}" enabled from ${result.from}.\n`)
+        console.log('Next steps:')
+        console.log('  1. Review generated files if needed: .mercato/generated/')
+        console.log('  2. Start dev:                         yarn dev')
         return 0
       }
 
-      console.log(`Ejecting module "${moduleId}"...`)
-      ejectModule(resolver, moduleId)
-      console.log(`\n✅ Module "${moduleId}" ejected successfully!\n`)
-      console.log('Next steps:')
-      console.log('  1. Run generators:  yarn mercato generate all')
-      console.log(`  2. Customize:       edit src/modules/${moduleId}/`)
-      console.log('  3. Start dev:       yarn dev')
-      return 0
+      if (subcommand === 'enable') {
+        const packageName = commandArgs.find((arg) => !arg.startsWith('-'))
+        if (!packageName) {
+          console.error('Usage: yarn mercato module enable <packageName> [--module <moduleId>] [--eject]')
+          return 1
+        }
+
+        const { createResolver } = await import('./lib/resolver')
+        const { enableOfficialModule } = await import('./lib/module-install')
+        const { moduleId, eject } = parseModuleInstallArgs(commandArgs)
+        const result = await enableOfficialModule(createResolver(), packageName, moduleId ?? undefined, eject)
+        console.log(`\n✅ Module "${result.moduleId}" enabled from ${result.from}.\n`)
+        console.log('Next steps:')
+        console.log('  1. Review generated files if needed: .mercato/generated/')
+        console.log('  2. Start dev:                         yarn dev')
+        return 0
+      }
+
+      if (subcommand === 'eject') {
+        return handleDirectEjectCommand(commandArgs)
+      }
+
+      console.error(`Unknown module subcommand "${subcommand}".`)
+      return 1
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : String(error)
+      console.error(`❌ Module command failed: ${message}`)
+      return 1
+    }
+  }
+
+  // Handle eject command directly (bootstrap-free)
+  if (first === 'eject') {
+    try {
+      return handleDirectEjectCommand(parts.slice(1))
     } catch (error: unknown) {
       const message = error instanceof Error ? error.message : String(error)
       console.error(`❌ Eject failed: ${message}`)
@@ -880,7 +960,7 @@ export async function run(argv = process.argv) {
         command: 'all',
         run: async (args: string[]) => {
           const { createResolver } = await import('./lib/resolver')
-          const { generateEntityIds, generateModuleRegistry, generateModuleRegistryCli, generateModuleEntities, generateModuleDi, generateOpenApi } = await import('./lib/generators')
+          const { generateEntityIds, generateModuleRegistry, generateModuleRegistryCli, generateModuleEntities, generateModuleDi, generateModulePackageSources, generateOpenApi } = await import('./lib/generators')
           const resolver = createResolver()
           const quiet = args.includes('--quiet') || args.includes('-q')
 
@@ -890,6 +970,7 @@ export async function run(argv = process.argv) {
           await generateModuleRegistryCli({ resolver, quiet })
           await generateModuleEntities({ resolver, quiet })
           await generateModuleDi({ resolver, quiet })
+          await generateModulePackageSources({ resolver, quiet })
           await generateOpenApi({ resolver, quiet })
           console.log('All generators completed.')
         },
@@ -907,9 +988,10 @@ export async function run(argv = process.argv) {
         command: 'registry',
         run: async (args: string[]) => {
           const { createResolver } = await import('./lib/resolver')
-          const { generateModuleRegistry } = await import('./lib/generators')
+          const { generateModulePackageSources, generateModuleRegistry } = await import('./lib/generators')
           const resolver = createResolver()
           await generateModuleRegistry({ resolver, quiet: args.includes('--quiet') })
+          await generateModulePackageSources({ resolver, quiet: args.includes('--quiet') })
         },
       },
       {
@@ -976,13 +1058,10 @@ export async function run(argv = process.argv) {
         command: 'dev',
         run: async () => {
           const { spawn } = await import('child_process')
-          const path = await import('path')
-          const { createResolver } = await import('./lib/resolver')
-          const resolver = createResolver()
-          const appDir = resolver.getAppDir()
-
-          // In monorepo, packages are hoisted to root; in standalone, they're in app's node_modules
-          const nodeModulesBase = resolver.isMonorepo() ? resolver.getRootDir() : appDir
+          const { resolveEnvironment } = await import('./lib/resolver')
+          const env = resolveEnvironment()
+          const appDir = env.appDir
+          const nodeModulesBases = Array.from(new Set([env.rootDir, appDir]))
 
           const processes: ChildProcess[] = []
           const autoSpawnWorkers = process.env.AUTO_SPAWN_WORKERS !== 'false'
@@ -1003,9 +1082,13 @@ export async function run(argv = process.argv) {
 
           console.log('[server] Starting Open Mercato in dev mode...')
 
-          // Resolve paths relative to where node_modules are located
-          const nextBin = path.join(nodeModulesBase, 'node_modules/next/dist/bin/next')
-          const mercatoBin = path.join(nodeModulesBase, 'node_modules/@open-mercato/cli/bin/mercato')
+          // Ensure module-package-sources.css exists before Next.js starts
+          const { createResolver: createResolverForSources } = await import('./lib/resolver')
+          const { generateModulePackageSources } = await import('./lib/generators')
+          await generateModulePackageSources({ resolver: createResolverForSources(), quiet: true })
+
+          const nextBin = resolveInstalledBinary(nodeModulesBases, 'next/dist/bin/next')
+          const mercatoBin = resolveInstalledBinary(nodeModulesBases, '@open-mercato/cli/bin/mercato')
 
           // Start Next.js dev
           const nextProcess = spawn('node', [nextBin, 'dev', '--turbopack'], {
@@ -1053,13 +1136,10 @@ export async function run(argv = process.argv) {
         command: 'start',
         run: async () => {
           const { spawn } = await import('child_process')
-          const path = await import('path')
-          const { createResolver } = await import('./lib/resolver')
-          const resolver = createResolver()
-          const appDir = resolver.getAppDir()
-
-          // In monorepo, packages are hoisted to root; in standalone, they're in app's node_modules
-          const nodeModulesBase = resolver.isMonorepo() ? resolver.getRootDir() : appDir
+          const { resolveEnvironment } = await import('./lib/resolver')
+          const env = resolveEnvironment()
+          const appDir = env.appDir
+          const nodeModulesBases = Array.from(new Set([env.rootDir, appDir]))
 
           const processes: ChildProcess[] = []
           const autoSpawnWorkers = process.env.AUTO_SPAWN_WORKERS !== 'false'
@@ -1080,9 +1160,8 @@ export async function run(argv = process.argv) {
 
           console.log('[server] Starting Open Mercato in production mode...')
 
-          // Resolve paths relative to where node_modules are located
-          const nextBin = path.join(nodeModulesBase, 'node_modules/next/dist/bin/next')
-          const mercatoBin = path.join(nodeModulesBase, 'node_modules/@open-mercato/cli/bin/mercato')
+          const nextBin = resolveInstalledBinary(nodeModulesBases, 'next/dist/bin/next')
+          const mercatoBin = resolveInstalledBinary(nodeModulesBases, '@open-mercato/cli/bin/mercato')
 
           // Start Next.js production server
           const nextProcess = spawn('node', [nextBin, 'start'], {