@open-mercato/cli 0.5.1-develop.3032.01699048cb → 0.5.1-develop.3043.1a796c3920

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-mercato/cli",
-  "version": "0.5.1-develop.3032.01699048cb",
+  "version": "0.5.1-develop.3043.1a796c3920",
   "type": "module",
   "main": "./dist/index.js",
   "exports": {
@@ -59,8 +59,8 @@
     "@mikro-orm/decorators": "^7.0.13",
     "@mikro-orm/migrations": "^7.0.13",
     "@mikro-orm/postgresql": "^7.0.13",
-    "@open-mercato/queue": "0.5.1-develop.3032.01699048cb",
-    "@open-mercato/shared": "0.5.1-develop.3032.01699048cb",
+    "@open-mercato/queue": "0.5.1-develop.3043.1a796c3920",
+    "@open-mercato/shared": "0.5.1-develop.3043.1a796c3920",
     "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.3032.01699048cb"
+    "@open-mercato/shared": "0.5.1-develop.3043.1a796c3920"
   },
   "devDependencies": {
-    "@open-mercato/shared": "0.5.1-develop.3032.01699048cb",
+    "@open-mercato/shared": "0.5.1-develop.3043.1a796c3920",
     "@types/jest": "^30.0.0",
     "jest": "^30.3.0",
     "ts-jest": "^29.4.9"

package/src/__tests__/mercato.test.ts

@@ -1,3 +1,4 @@
+import type { Module } from '@open-mercato/shared/modules/registry'
 import {
   registerCliModules,
   getCliModules,
@@ -6,6 +7,61 @@ import {
   run,
 } from '../mercato'
 
+type MockChildAutoExit = { code: number | null; signal?: NodeJS.Signals | null } | undefined
+type MockChildSpawnRouter = (args: string[]) => MockChildAutoExit
+
+function buildMockChildProcessModule(routeAutoExit: MockChildSpawnRouter) {
+  const { EventEmitter } = jest.requireActual('node:events')
+
+  const createChild = (spawnargs: string[], autoExit?: MockChildAutoExit) => {
+    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[]) => createChild(['node', ...args], routeAutoExit(args))),
+  }
+}
+
+const eventsWorkerFixture: Pick<Module, 'id' | 'workers'> = {
+  id: 'events',
+  workers: [
+    {
+      id: 'events.test-worker',
+      queue: 'events',
+      concurrency: 1,
+      handler: jest.fn(),
+    },
+  ],
+}
+
 describe('mercato CLI module registration', () => {
   beforeEach(() => {
     // Reset module state by re-importing
@@ -562,16 +618,19 @@ describe('generate post-step structural cache purge', () => {
 
 describe('server dev managed process exits', () => {
   const originalAutoSpawnScheduler = process.env.AUTO_SPAWN_SCHEDULER
+  const originalAutoSpawnWorkers = process.env.AUTO_SPAWN_WORKERS
 
   beforeEach(() => {
     jest.restoreAllMocks()
     jest.resetModules()
     process.env.AUTO_SPAWN_SCHEDULER = 'false'
+    process.env.AUTO_SPAWN_WORKERS = 'true'
   })
 
   afterEach(() => {
     jest.dontMock('child_process')
     jest.dontMock('node:fs')
+    jest.dontMock('../lib/dev-env-reload')
     jest.dontMock('../lib/generators')
     jest.dontMock('../lib/resolver')
     jest.resetModules()
@@ -579,12 +638,220 @@ describe('server dev managed process exits', () => {
 
   afterAll(() => {
     process.env.AUTO_SPAWN_SCHEDULER = originalAutoSpawnScheduler
+    process.env.AUTO_SPAWN_WORKERS = originalAutoSpawnWorkers
+  })
+
+  it('skips scheduler auto-start when the module is not enabled', async () => {
+    const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation()
+    const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation()
+    process.env.AUTO_SPAWN_SCHEDULER = 'true'
+    process.env.AUTO_SPAWN_WORKERS = 'false'
+
+    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', () =>
+      buildMockChildProcessModule((args) =>
+        args[0]?.includes('next/dist/bin/next') ? { code: null, signal: 'SIGTERM' } : undefined,
+      ),
+    )
+
+    const mercato = await import('../mercato')
+    const exitCode = await mercato.run(['node', 'mercato', 'server', 'dev'])
+
+    expect(exitCode).toBe(0)
+    expect(consoleErrorSpy).not.toHaveBeenCalled()
+    expect(consoleLogSpy).toHaveBeenCalledWith('[server] Skipping scheduler auto-start — module not enabled')
+
+    consoleErrorSpy.mockRestore()
+    consoleLogSpy.mockRestore()
+  })
+
+  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', () =>
+      buildMockChildProcessModule((args) => {
+        if (args.slice(1).join(' ') === 'queue worker --all') {
+          return { code: 0 }
+        }
+        return undefined
+      }),
+    )
+
+    const mercato = await import('../mercato')
+    mercato.registerCliModules([eventsWorkerFixture as Module])
+
+    const exitCode = await mercato.run(['node', 'mercato', 'server', 'dev'])
+
+    expect(exitCode).toBe(1)
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      '💥 Failed: [server] Queue worker (events) exited unexpectedly with exit code 0.',
+    )
+
+    consoleErrorSpy.mockRestore()
+    consoleLogSpy.mockRestore()
+  })
+})
+
+describe('server start managed process exits', () => {
+  const originalAutoSpawnScheduler = process.env.AUTO_SPAWN_SCHEDULER
+  const originalAutoSpawnWorkers = process.env.AUTO_SPAWN_WORKERS
+
+  beforeEach(() => {
+    jest.restoreAllMocks()
+    jest.resetModules()
+    process.env.AUTO_SPAWN_SCHEDULER = 'false'
+    process.env.AUTO_SPAWN_WORKERS = 'true'
+  })
+
+  afterEach(() => {
+    jest.dontMock('child_process')
+    jest.dontMock('node:fs')
+    jest.dontMock('../lib/resolver')
+    jest.dontMock('../lib/server-start-lock')
+    jest.resetModules()
+  })
+
+  afterAll(() => {
+    process.env.AUTO_SPAWN_SCHEDULER = originalAutoSpawnScheduler
+    process.env.AUTO_SPAWN_WORKERS = originalAutoSpawnWorkers
+  })
+
+  it('skips scheduler auto-start when the module is not enabled', async () => {
+    const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation()
+    const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation()
+    process.env.AUTO_SPAWN_SCHEDULER = 'true'
+    process.env.AUTO_SPAWN_WORKERS = 'false'
+
+    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'),
+        ),
+      }
+    })
+    jest.doMock('../lib/resolver', () => ({
+      resolveEnvironment: () => ({
+        appDir: '/tmp/test-app',
+        rootDir: '/tmp/test-root',
+      }),
+    }))
+    jest.doMock('../lib/server-start-lock', () => ({
+      acquireServerStartLock: jest.fn(() => ({
+        release: jest.fn(),
+      })),
+    }))
+    jest.doMock('child_process', () =>
+      buildMockChildProcessModule((args) =>
+        args[0]?.includes('next/dist/bin/next') ? { code: null, signal: 'SIGTERM' } : undefined,
+      ),
+    )
+
+    const mercato = await import('../mercato')
+    const exitCode = await mercato.run(['node', 'mercato', 'server', 'start'])
+
+    expect(exitCode).toBe(0)
+    expect(consoleErrorSpy).not.toHaveBeenCalled()
+    expect(consoleLogSpy).toHaveBeenCalledWith('[server] Skipping scheduler auto-start — module not enabled')
+
+    consoleErrorSpy.mockRestore()
+    consoleLogSpy.mockRestore()
   })
 
   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'),
+        ),
+      }
+    })
+    jest.doMock('../lib/resolver', () => ({
+      resolveEnvironment: () => ({
+        appDir: '/tmp/test-app',
+        rootDir: '/tmp/test-root',
+      }),
+    }))
+    jest.doMock('../lib/server-start-lock', () => ({
+      acquireServerStartLock: jest.fn(() => ({
+        release: jest.fn(),
+      })),
+    }))
+    jest.doMock('child_process', () =>
+      buildMockChildProcessModule((args) => {
+        if (args.slice(1).join(' ') === 'queue worker --all') {
+          return { code: 0 }
+        }
+        return undefined
+      }),
+    )
+
+    const mercato = await import('../mercato')
+    mercato.registerCliModules([eventsWorkerFixture as Module])
+
+    const exitCode = await mercato.run(['node', 'mercato', 'server', 'start'])
+
+    expect(exitCode).toBe(1)
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      '💥 Failed: [server] Queue worker (events) exited unexpectedly with exit code 0.',
+    )
+
+    consoleErrorSpy.mockRestore()
+    consoleLogSpy.mockRestore()
+  })
+
+  it('restarts the managed dev runtime when an app env file changes', async () => {
+    const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation()
+    const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation()
+    let envChangeCallback: ((filePath: string) => void) | null = null
+    let reloadCount = 0
+
     jest.doMock('node:fs', () => {
       const actual = jest.requireActual('node:fs')
       return {
@@ -595,6 +862,19 @@ describe('server dev managed process exits', () => {
         unlinkSync: jest.fn(),
       }
     })
+    jest.doMock('../lib/dev-env-reload', () => ({
+      createDevEnvReloader: () => ({
+        reload: jest.fn(() => {
+          reloadCount += 1
+          process.env.RESTART_TOKEN = reloadCount === 1 ? 'initial' : 'changed'
+        }),
+        getWatchedFiles: () => ['/tmp/test-app/.env'],
+      }),
+      watchDevEnvFiles: jest.fn((_appDir: string, onChange: (filePath: string) => void) => {
+        envChangeCallback = onChange
+        return jest.fn()
+      }),
+    }))
     jest.doMock('../lib/generators', () => ({
       generateModulePackageSources: jest.fn().mockResolvedValue(undefined),
     }))
@@ -607,15 +887,14 @@ describe('server dev managed process exits', () => {
     }))
     jest.doMock('child_process', () => {
       const { EventEmitter } = jest.requireActual('node:events')
+      let nextSpawnCount = 0
 
       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
@@ -646,37 +925,34 @@ describe('server dev managed process exits', () => {
       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 })
+            nextSpawnCount += 1
+            if (nextSpawnCount === 1) {
+              queueMicrotask(() => envChangeCallback?.('/tmp/test-app/.env'))
+              return createChild()
+            }
+            return createChild({ code: null, signal: 'SIGTERM' })
           }
-          return createChild(['node', ...args])
+          return createChild()
         }),
       }
     })
 
-    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'])
+    const mercado = await import('../mercato')
+    const exitCode = await mercado.run(['node', 'mercato', 'server', 'dev'])
+    const { spawn } = await import('child_process')
+    const nextSpawns = (spawn as jest.Mock).mock.calls.filter((call) =>
+      call[1]?.[0]?.includes('next/dist/bin/next'),
+    )
 
-    expect(exitCode).toBe(1)
-    expect(consoleErrorSpy).toHaveBeenCalledWith(
-      '💥 Failed: [server] Queue worker exited unexpectedly with exit code 0.',
+    expect(exitCode).toBe(0)
+    expect(nextSpawns).toHaveLength(2)
+    expect(nextSpawns[0][2].env.RESTART_TOKEN).toBe('initial')
+    expect(nextSpawns[1][2].env.RESTART_TOKEN).toBe('changed')
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      '[server] Detected environment file change (.env). Restarting app runtime...',
     )
 
+    delete process.env.RESTART_TOKEN
     consoleErrorSpy.mockRestore()
     consoleLogSpy.mockRestore()
   })

package/src/lib/__integration__/TC-INT-007.spec.ts

@@ -0,0 +1,228 @@
+import { expect, test } from '@playwright/test'
+import { execFileSync } from 'node:child_process'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const repoRoot = path.resolve(__dirname, '..', '..', '..', '..', '..')
+const cliBin = path.join(repoRoot, 'packages', 'cli', 'dist', 'bin.js')
+const fixtureModulePackage = path.join(
+  repoRoot,
+  'packages',
+  'cli',
+  'src',
+  'lib',
+  '__fixtures__',
+  'official-module-package',
+)
+
+function yarnBinary(): string {
+  return process.platform === 'win32' ? 'yarn.cmd' : 'yarn'
+}
+
+function runCommand(command: string, args: string[], cwd: string): string {
+  const yarnCacheFolder = path.join(cwd, '.yarn', 'cache')
+  return execFileSync(command, args, {
+    cwd,
+    encoding: 'utf8',
+    env: {
+      ...process.env,
+      FORCE_COLOR: '0',
+      NODE_NO_WARNINGS: '1',
+      YARN_CACHE_FOLDER: yarnCacheFolder,
+      YARN_ENABLE_GLOBAL_CACHE: '0',
+      YARN_ENABLE_IMMUTABLE_INSTALLS: '0',
+      YARN_NODE_LINKER: 'node-modules',
+    },
+  })
+}
+
+function runMercato(args: string[], cwd: string): string {
+  return runCommand(process.execPath, [cliBin, ...args], cwd)
+}
+
+function writeFile(filePath: string, content: string): void {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true })
+  fs.writeFileSync(filePath, content)
+}
+
+function createCoreWorkspacePackage(rootDir: string, relativeDir: string): string {
+  const coreDir = path.join(rootDir, relativeDir)
+  writeFile(
+    path.join(coreDir, 'package.json'),
+    JSON.stringify(
+      {
+        name: '@open-mercato/core',
+        version: '0.4.7',
+        type: 'module',
+      },
+      null,
+      2,
+    ),
+  )
+  return coreDir
+}
+
+function createMonorepoFixture(rootDir: string): string {
+  writeFile(
+    path.join(rootDir, 'package.json'),
+    JSON.stringify(
+      {
+        name: 'cli-module-monorepo-fixture',
+        private: true,
+        workspaces: ['apps/*', 'packages/*'],
+      },
+      null,
+      2,
+    ),
+  )
+  writeFile(
+    path.join(rootDir, '.yarnrc.yml'),
+    ['nodeLinker: node-modules', 'enableGlobalCache: false', 'cacheFolder: ./.yarn/cache', ''].join('\n'),
+  )
+  createCoreWorkspacePackage(rootDir, path.join('packages', 'core'))
+
+  const appDir = path.join(rootDir, 'apps', 'mercato')
+  writeFile(
+    path.join(appDir, 'package.json'),
+    JSON.stringify(
+      {
+        name: '@open-mercato/app',
+        version: '0.0.0',
+        private: true,
+      },
+      null,
+      2,
+    ),
+  )
+  writeFile(path.join(appDir, 'src', 'modules.ts'), 'export const enabledModules = []\n')
+  return appDir
+}
+
+function createStandaloneFixture(rootDir: string): string {
+  writeFile(
+    path.join(rootDir, '.yarnrc.yml'),
+    ['nodeLinker: node-modules', 'enableGlobalCache: false', 'cacheFolder: ./.yarn/cache', ''].join('\n'),
+  )
+  createCoreWorkspacePackage(rootDir, path.join('vendor', 'core'))
+  writeFile(
+    path.join(rootDir, 'package.json'),
+    JSON.stringify(
+      {
+        name: 'cli-module-standalone-fixture',
+        private: true,
+        dependencies: {
+          '@open-mercato/core': 'file:./vendor/core',
+        },
+      },
+      null,
+      2,
+    ),
+  )
+  writeFile(path.join(rootDir, 'src', 'modules.ts'), 'export const enabledModules = []\n')
+  return rootDir
+}
+
+function readFile(filePath: string): string {
+  return fs.readFileSync(filePath, 'utf8')
+}
+
+test.describe('TC-INT-007: CLI official module install and eject flows', () => {
+  test('module add installs and registers a package-backed module in a monorepo app', () => {
+    const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mercato-cli-monorepo-'))
+
+    try {
+      const appDir = createMonorepoFixture(rootDir)
+      runCommand(yarnBinary(), ['install'], rootDir)
+
+      runMercato(
+        [
+          'module',
+          'add',
+          `@open-mercato/test-package@file:${fixtureModulePackage}`,
+        ],
+        rootDir,
+      )
+
+      const modulesSource = readFile(path.join(appDir, 'src', 'modules.ts'))
+      const cssSource = readFile(path.join(appDir, '.mercato', 'generated', 'module-package-sources.css'))
+      const appPackageJson = JSON.parse(readFile(path.join(appDir, 'package.json'))) as {
+        dependencies?: Record<string, string>
+      }
+
+      expect(modulesSource).toContain("{ id: 'test_package', from: '@open-mercato/test-package' }")
+      expect(cssSource).toContain('node_modules/@open-mercato/test-package/src/**/*.{ts,tsx}')
+      expect(appPackageJson.dependencies?.['@open-mercato/test-package']).toBeTruthy()
+    } finally {
+      fs.rmSync(rootDir, { recursive: true, force: true })
+    }
+  })
+
+  test('module add --eject copies module source and omits package CSS entries', () => {
+    const appDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mercato-cli-standalone-source-'))
+
+    try {
+      createStandaloneFixture(appDir)
+      runCommand(yarnBinary(), ['install'], appDir)
+
+      runMercato(
+        [
+          'module',
+          'add',
+          `@open-mercato/test-package@file:${fixtureModulePackage}`,
+          '--eject',
+        ],
+        appDir,
+      )
+
+      const modulesSource = readFile(path.join(appDir, 'src', 'modules.ts'))
+      const cssSource = readFile(path.join(appDir, '.mercato', 'generated', 'module-package-sources.css'))
+
+      expect(modulesSource).toContain("{ id: 'test_package', from: '@app' }")
+      expect(fs.existsSync(path.join(appDir, 'src', 'modules', 'test_package', 'index.ts'))).toBe(true)
+      expect(cssSource).toBe('')
+    } finally {
+      fs.rmSync(appDir, { recursive: true, force: true })
+    }
+  })
+
+  test('module enable supports package-backed and ejected flows plus both eject entrypoints', () => {
+    const appDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mercato-cli-standalone-eject-'))
+
+    try {
+      createStandaloneFixture(appDir)
+      runCommand(yarnBinary(), ['install'], appDir)
+      runCommand(
+        yarnBinary(),
+        ['add', `@open-mercato/test-package@file:${fixtureModulePackage}`],
+        appDir,
+      )
+
+      runMercato(['module', 'enable', '@open-mercato/test-package'], appDir)
+      expect(readFile(path.join(appDir, 'src', 'modules.ts'))).toContain(
+        "{ id: 'test_package', from: '@open-mercato/test-package' }",
+      )
+
+      writeFile(path.join(appDir, 'src', 'modules.ts'), 'export const enabledModules = []\n')
+      fs.rmSync(path.join(appDir, 'src', 'modules', 'test_package'), { recursive: true, force: true })
+      runMercato(['module', 'enable', '@open-mercato/test-package', '--eject'], appDir)
+      expect(readFile(path.join(appDir, 'src', 'modules.ts'))).toContain("{ id: 'test_package', from: '@app' }")
+      expect(fs.existsSync(path.join(appDir, 'src', 'modules', 'test_package', 'index.ts'))).toBe(true)
+      expect(readFile(path.join(appDir, '.mercato', 'generated', 'module-package-sources.css'))).toBe('')
+
+      writeFile(path.join(appDir, 'src', 'modules.ts'), "export const enabledModules = [{ id: 'test_package', from: '@open-mercato/test-package' }]\n")
+      fs.rmSync(path.join(appDir, 'src', 'modules', 'test_package'), { recursive: true, force: true })
+      runMercato(['module', 'eject', 'test_package'], appDir)
+      expect(readFile(path.join(appDir, 'src', 'modules.ts'))).toContain("{ id: 'test_package', from: '@app' }")
+
+      writeFile(path.join(appDir, 'src', 'modules.ts'), "export const enabledModules = [{ id: 'test_package', from: '@open-mercato/test-package' }]\n")
+      fs.rmSync(path.join(appDir, 'src', 'modules', 'test_package'), { recursive: true, force: true })
+      runMercato(['eject', 'test_package'], appDir)
+      expect(readFile(path.join(appDir, 'src', 'modules.ts'))).toContain("{ id: 'test_package', from: '@app' }")
+    } finally {
+      fs.rmSync(appDir, { recursive: true, force: true })
+    }
+  })
+})