@life-and-dev/mdsite 0.0.3

package/mdsite-nuxt/scripts/renderer-hooks.test.ts

@@ -0,0 +1,277 @@
+import path from 'node:path'
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const {
+  buildContentDataMock,
+  copyFaviconsToPublicMock,
+  existsSyncMock,
+  generateFaviconsMock,
+  generateWebManifestMock,
+  loadMdsiteConfigSyncMock,
+  parseYamlMock,
+  readFileSyncMock,
+  resolveMdsiteConfigPathMock,
+  rmMock,
+  startWatcherMock,
+  statSyncMock,
+  stringifyYamlMock,
+  syncContentMock,
+  writeFileSyncMock,
+} = vi.hoisted(() => ({
+  buildContentDataMock: vi.fn(),
+  copyFaviconsToPublicMock: vi.fn(),
+  existsSyncMock: vi.fn(),
+  generateFaviconsMock: vi.fn(),
+  generateWebManifestMock: vi.fn(),
+  loadMdsiteConfigSyncMock: vi.fn(),
+  parseYamlMock: vi.fn(),
+  readFileSyncMock: vi.fn(),
+  resolveMdsiteConfigPathMock: vi.fn(),
+  rmMock: vi.fn(),
+  startWatcherMock: vi.fn(),
+  statSyncMock: vi.fn(),
+  stringifyYamlMock: vi.fn(),
+  syncContentMock: vi.fn(),
+  writeFileSyncMock: vi.fn(),
+}))
+
+vi.mock('fs', () => ({
+  default: {
+    existsSync: existsSyncMock,
+    statSync: statSyncMock,
+    readFileSync: readFileSyncMock,
+    writeFileSync: writeFileSyncMock,
+    promises: {
+      rm: rmMock,
+    },
+  },
+}))
+
+vi.mock('yaml', () => ({
+  default: {
+    parse: parseYamlMock,
+    stringify: stringifyYamlMock,
+  },
+}))
+
+vi.mock('./generate-indices.js', () => ({
+  buildContentData: buildContentDataMock,
+}))
+
+vi.mock('./generate-favicons.js', () => ({
+  copyFaviconsToPublic: copyFaviconsToPublicMock,
+  generateFavicons: generateFaviconsMock,
+  generateWebManifest: generateWebManifestMock,
+}))
+
+vi.mock('./sync-content.js', () => ({
+  startWatcher: startWatcherMock,
+  syncContent: syncContentMock,
+}))
+
+vi.mock('../utils/mdsite-config.js', () => ({
+  loadMdsiteConfigSync: loadMdsiteConfigSyncMock,
+  resolveMdsiteConfigPath: resolveMdsiteConfigPathMock,
+}))
+
+import {
+  prepareRendererRuntime,
+  runBuildFallbackHooks,
+  runSetupHooks,
+} from './renderer-hooks.js'
+
+describe('renderer hooks orchestration', () => {
+  const originalEnv = { ...process.env }
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    process.env = { ...originalEnv }
+
+    resolveMdsiteConfigPathMock.mockReturnValue('/renderer/mdsite.yml')
+    loadMdsiteConfigSyncMock.mockReturnValue({
+      config: { site: { name: 'Docs' } },
+      configPath: '/renderer/mdsite.yml',
+      contentDir: '/renderer/docs',
+    })
+    existsSyncMock.mockImplementation((target: string) => target === '/renderer/docs')
+    statSyncMock.mockReturnValue({ isFile: () => true })
+    stringifyYamlMock.mockReturnValue('compat-config')
+    generateFaviconsMock.mockResolvedValue(true)
+    buildContentDataMock.mockResolvedValue(undefined)
+    copyFaviconsToPublicMock.mockResolvedValue(undefined)
+    generateWebManifestMock.mockResolvedValue(undefined)
+    startWatcherMock.mockResolvedValue(undefined)
+    syncContentMock.mockResolvedValue(undefined)
+    rmMock.mockResolvedValue(undefined)
+  })
+
+  it('prepares runtime from the resolved mdsite config and exports stable env values', () => {
+    const runtime = prepareRendererRuntime('/renderer', {
+      configPath: '/renderer/mdsite.yml',
+      contentPath: '/input/docs',
+    })
+
+    expect(resolveMdsiteConfigPathMock).toHaveBeenCalledWith({
+      configPath: '/renderer/mdsite.yml',
+      contentPath: '/input/docs',
+    })
+    expect(loadMdsiteConfigSyncMock).toHaveBeenCalledWith({
+      configPath: '/renderer/mdsite.yml',
+      contentPath: '/input/docs',
+    })
+    expect(runtime).toEqual({
+      config: { site: { name: 'Docs' } },
+      configPath: '/renderer/mdsite.yml',
+      contentDir: '/renderer/docs',
+      rootDir: '/renderer',
+    })
+    expect(process.env.NUXT_CONTENT_PATH).toBe('/renderer/docs')
+    expect(process.env.CONTENT_DIR).toBe('/renderer/docs')
+    expect(process.env.MDSITE_CONFIG_PATH).toBe('/renderer/mdsite.yml')
+  })
+
+  it('falls back to the legacy compatibility config when no explicit mdsite config resolves', () => {
+    resolveMdsiteConfigPathMock.mockReturnValue(undefined)
+    existsSyncMock.mockImplementation((target: string) => (
+      target === '/renderer/content.config.yml' || target === path.join('/renderer', 'legacy-docs')
+    ))
+    parseYamlMock.mockReturnValue({
+      content: {
+        path: 'legacy-docs',
+      },
+      siteName: 'Legacy Docs',
+    })
+    loadMdsiteConfigSyncMock.mockReturnValue({
+      config: { site: { name: 'Legacy Docs' } },
+      configPath: '/renderer/.mdsite-compat.yml',
+      contentDir: path.join('/renderer', 'legacy-docs'),
+    })
+
+    const runtime = prepareRendererRuntime('/renderer')
+
+    expect(readFileSyncMock).toHaveBeenCalledWith('/renderer/content.config.yml', 'utf8')
+    expect(writeFileSyncMock).toHaveBeenCalledWith('/renderer/.mdsite-compat.yml', 'compat-config', 'utf8')
+    expect(loadMdsiteConfigSyncMock).toHaveBeenCalledWith({
+      configPath: '/renderer/.mdsite-compat.yml',
+      contentPath: path.join('/renderer', 'legacy-docs'),
+    })
+    expect(runtime.configPath).toBe('/renderer/.mdsite-compat.yml')
+    expect(process.env.MDSITE_CONFIG_PATH).toBe('/renderer/.mdsite-compat.yml')
+    expect(process.env.NUXT_CONTENT_PATH).toBe(path.join('/renderer', 'legacy-docs'))
+  })
+
+  it('exits when no renderer config can be resolved', () => {
+    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+    const processExitSpy = vi.spyOn(process, 'exit').mockImplementation((code?: number) => {
+      throw new Error(`process.exit(${code ?? 0})`)
+    })
+
+    resolveMdsiteConfigPathMock.mockReturnValue(undefined)
+    existsSyncMock.mockReturnValue(false)
+
+    expect(() => prepareRendererRuntime('/renderer')).toThrow('process.exit(1)')
+    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('No mdsite.yml configuration found'))
+
+    consoleErrorSpy.mockRestore()
+    processExitSpy.mockRestore()
+  })
+
+  it('exits when the resolved content directory does not exist', () => {
+    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+    const processExitSpy = vi.spyOn(process, 'exit').mockImplementation((code?: number) => {
+      throw new Error(`process.exit(${code ?? 0})`)
+    })
+
+    existsSyncMock.mockReturnValue(false)
+
+    expect(() => prepareRendererRuntime('/renderer')).toThrow('process.exit(1)')
+    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Content directory not found'))
+
+    consoleErrorSpy.mockRestore()
+    processExitSpy.mockRestore()
+  })
+
+  it('runs the dev wrapper contract and clears .data for uncached dev startup', async () => {
+    const runtime = await runSetupHooks('dev', '/renderer')
+
+    expect(rmMock).toHaveBeenCalledWith(path.join('/renderer', '.data'), {
+      force: true,
+      recursive: true,
+    })
+    expect(startWatcherMock).toHaveBeenCalledTimes(1)
+    expect(syncContentMock).not.toHaveBeenCalled()
+    expect(buildContentDataMock).not.toHaveBeenCalled()
+    expect(generateFaviconsMock).not.toHaveBeenCalled()
+    expect(process.env.MDSITE_RENDERER_ORCHESTRATED).toBe('1')
+    expect(runtime.contentDir).toBe('/renderer/docs')
+  })
+
+  it('keeps cached dev startup on the same wrapper contract without clearing .data', async () => {
+    await runSetupHooks('dev', '/renderer', { cached: true })
+
+    expect(rmMock).not.toHaveBeenCalled()
+    expect(startWatcherMock).toHaveBeenCalledTimes(1)
+    expect(syncContentMock).not.toHaveBeenCalled()
+  })
+
+  it('runs non-dev setup hooks in orchestration order and publishes favicon assets on success', async () => {
+    await runSetupHooks('generate', '/renderer', { configPath: '/renderer/mdsite.yml' })
+
+    expect(syncContentMock).toHaveBeenCalledTimes(1)
+    expect(buildContentDataMock).toHaveBeenCalledTimes(1)
+    expect(generateFaviconsMock).toHaveBeenCalledTimes(1)
+    expect(copyFaviconsToPublicMock).toHaveBeenCalledTimes(1)
+    expect(generateWebManifestMock).toHaveBeenCalledWith('Docs')
+    expect(syncContentMock.mock.invocationCallOrder[0]).toBeLessThan(buildContentDataMock.mock.invocationCallOrder[0])
+    expect(buildContentDataMock.mock.invocationCallOrder[0]).toBeLessThan(generateFaviconsMock.mock.invocationCallOrder[0])
+    expect(process.env.MDSITE_RENDERER_ORCHESTRATED).toBe('1')
+  })
+
+  it('runs setup mode through the same non-dev orchestration path as build and generate', async () => {
+    await runSetupHooks('setup', '/renderer', { configPath: '/renderer/mdsite.yml' })
+
+    expect(syncContentMock).toHaveBeenCalledTimes(1)
+    expect(buildContentDataMock).toHaveBeenCalledTimes(1)
+    expect(generateFaviconsMock).toHaveBeenCalledTimes(1)
+    expect(copyFaviconsToPublicMock).toHaveBeenCalledTimes(1)
+    expect(generateWebManifestMock).toHaveBeenCalledWith('Docs')
+    expect(startWatcherMock).not.toHaveBeenCalled()
+    expect(rmMock).not.toHaveBeenCalled()
+    expect(process.env.MDSITE_RENDERER_ORCHESTRATED).toBe('1')
+  })
+
+  it('marks orchestration complete for build mode on the same shared non-dev path', async () => {
+    await runSetupHooks('build', '/renderer', { configPath: '/renderer/mdsite.yml' })
+
+    expect(syncContentMock).toHaveBeenCalledTimes(1)
+    expect(buildContentDataMock).toHaveBeenCalledTimes(1)
+    expect(generateFaviconsMock).toHaveBeenCalledTimes(1)
+    expect(startWatcherMock).not.toHaveBeenCalled()
+    expect(process.env.MDSITE_RENDERER_ORCHESTRATED).toBe('1')
+  })
+
+  it('runs build fallback hooks without publishing favicon assets when generation reports no output', async () => {
+    generateFaviconsMock.mockResolvedValue(false)
+
+    await runBuildFallbackHooks('Docs')
+
+    expect(buildContentDataMock).toHaveBeenCalledTimes(1)
+    expect(generateFaviconsMock).toHaveBeenCalledTimes(1)
+    expect(copyFaviconsToPublicMock).not.toHaveBeenCalled()
+    expect(generateWebManifestMock).not.toHaveBeenCalled()
+  })
+
+  it('keeps non-dev orchestration error-safe when favicon generation reports no output', async () => {
+    generateFaviconsMock.mockResolvedValue(false)
+
+    await runSetupHooks('generate', '/renderer', { configPath: '/renderer/mdsite.yml' })
+
+    expect(syncContentMock).toHaveBeenCalledTimes(1)
+    expect(buildContentDataMock).toHaveBeenCalledTimes(1)
+    expect(generateFaviconsMock).toHaveBeenCalledTimes(1)
+    expect(copyFaviconsToPublicMock).not.toHaveBeenCalled()
+    expect(generateWebManifestMock).not.toHaveBeenCalled()
+    expect(process.env.MDSITE_RENDERER_ORCHESTRATED).toBe('1')
+  })
+})

package/mdsite-nuxt/scripts/renderer-hooks.ts

@@ -0,0 +1,141 @@
+import fs from 'fs'
+import path from 'path'
+import YAML from 'yaml'
+
+import { buildContentData } from './generate-indices.js'
+import { generateFavicons, copyFaviconsToPublic, generateWebManifest } from './generate-favicons.js'
+import { startWatcher, syncContent } from './sync-content.js'
+import { loadMdsiteConfigSync, resolveMdsiteConfigPath } from '../utils/mdsite-config.js'
+
+export interface RendererRuntime {
+  config: ReturnType<typeof loadMdsiteConfigSync>['config']
+  configPath: string
+  contentDir: string
+  rootDir: string
+}
+
+export function prepareRendererRuntime(rootDir: string, options: {
+  configPath?: string
+  contentPath?: string
+} = {}): RendererRuntime {
+  let configPath = resolveMdsiteConfigPath({
+    configPath: options.configPath,
+    contentPath: options.contentPath ?? process.env.NUXT_CONTENT_PATH
+  })
+
+  if (!configPath) {
+    configPath = ensureLegacyCompatibilityConfig(rootDir)
+  }
+
+  if (!configPath) {
+    console.error('❌ No mdsite.yml configuration found. Set MDSITE_CONFIG_PATH or pass a mdsite.yml path.')
+    process.exit(1)
+  }
+
+  const { config, contentDir } = loadMdsiteConfigSync({
+    configPath,
+    contentPath: options.contentPath ?? process.env.NUXT_CONTENT_PATH
+  })
+
+  process.env.NUXT_CONTENT_PATH = contentDir
+  process.env.CONTENT_DIR = contentDir
+  process.env.MDSITE_CONFIG_PATH = configPath
+
+  console.log(`🚀 Preparing site: ${config.site.name}`)
+  console.log(`📂 Content path: ${contentDir}`)
+  console.log(`📑 Config file: ${configPath}`)
+
+  if (!fs.existsSync(contentDir)) {
+    console.error(`❌ Content directory not found: ${contentDir}`)
+    process.exit(1)
+  }
+
+  return {
+    config,
+    configPath,
+    contentDir,
+    rootDir
+  }
+}
+
+export async function runSetupHooks(mode: 'setup' | 'build' | 'generate' | 'dev', rootDir: string, options: {
+  cached?: boolean
+  configPath?: string
+  contentPath?: string
+} = {}): Promise<RendererRuntime> {
+  const runtime = prepareRendererRuntime(rootDir, options)
+
+  if (mode === 'dev') {
+    if (!options.cached) {
+      await fs.promises.rm(path.join(rootDir, '.data'), { recursive: true, force: true })
+    }
+
+    process.env.MDSITE_RENDERER_ORCHESTRATED = '1'
+    await startWatcher()
+    return runtime
+  }
+
+  await syncContent()
+  console.log(`\n🔨 Generating navigation and search index...`)
+  await buildContentData()
+  await generateFaviconAssets(runtime.config.site.name)
+  process.env.MDSITE_RENDERER_ORCHESTRATED = '1'
+
+  return runtime
+}
+
+export async function runBuildFallbackHooks(siteName: string): Promise<void> {
+  console.log(`\n🔨 Generating navigation and search index...`)
+  await buildContentData()
+  await generateFaviconAssets(siteName)
+}
+
+async function generateFaviconAssets(siteName: string): Promise<void> {
+  console.log(`\n🎨 Generating favicons for build...`)
+  const success = await generateFavicons()
+
+  if (success) {
+    await copyFaviconsToPublic()
+    await generateWebManifest(siteName)
+    console.log(`✅ Favicons ready for ${siteName}\n`)
+  }
+}
+
+function ensureLegacyCompatibilityConfig(rootDir: string): string | undefined {
+  const legacyConfigPath = path.join(rootDir, 'content.config.yml')
+
+  if (!fs.existsSync(legacyConfigPath) || !fs.statSync(legacyConfigPath).isFile()) {
+    return undefined
+  }
+
+  const legacyConfig = YAML.parse(fs.readFileSync(legacyConfigPath, 'utf8')) ?? {}
+  const contentDir = path.resolve(rootDir, legacyConfig.content?.path || legacyConfig.content?.git?.path || 'docs')
+  const compatibilityConfigPath = path.join(rootDir, '.mdsite-compat.yml')
+  const compatibilityConfig = {
+    favicon: '',
+    features: {
+      bibleTooltips: legacyConfig.features?.bibleTooltips ?? true,
+      sourceEdit: legacyConfig.features?.sourceEdit ?? true
+    },
+    menu: [],
+    server: {
+      output: '.output',
+      path: '.mdsite',
+      repo: legacyConfig.content?.git?.repo || ''
+    },
+    site: {
+      canonical: legacyConfig.site?.canonical || '',
+      name: legacyConfig.site?.name || path.basename(contentDir) || 'Site'
+    },
+    themes: legacyConfig.themes || {}
+  }
+
+  fs.writeFileSync(compatibilityConfigPath, YAML.stringify(compatibilityConfig), 'utf8')
+  process.env.NUXT_CONTENT_PATH = contentDir
+  process.env.CONTENT_DIR = contentDir
+  process.env.MDSITE_CONFIG_PATH = compatibilityConfigPath
+
+  console.warn(`⚠️ Using legacy compatibility fallback from ${legacyConfigPath}`)
+
+  return compatibilityConfigPath
+}

package/mdsite-nuxt/scripts/start.test.ts

@@ -0,0 +1,164 @@
+import { readFileSync } from 'node:fs'
+import path from 'node:path'
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const {
+  onMock,
+  prepareRendererRuntimeMock,
+  runSetupHooksMock,
+  spawnMock,
+} = vi.hoisted(() => ({
+  onMock: vi.fn(),
+  prepareRendererRuntimeMock: vi.fn(),
+  runSetupHooksMock: vi.fn(),
+  spawnMock: vi.fn(),
+}))
+
+vi.mock('child_process', () => ({
+  spawn: spawnMock,
+}))
+
+vi.mock('./renderer-hooks.js', () => ({
+  prepareRendererRuntime: prepareRendererRuntimeMock,
+  runSetupHooks: runSetupHooksMock,
+}))
+
+describe('renderer start wrapper', () => {
+  const originalArgv = [...process.argv]
+  const originalEnv = { ...process.env }
+  const rootDir = path.resolve(process.cwd())
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    vi.resetModules()
+
+    process.argv = originalArgv.slice(0, 2)
+    process.env = { ...originalEnv }
+
+    runSetupHooksMock.mockResolvedValue(undefined)
+    prepareRendererRuntimeMock.mockReturnValue(undefined)
+    spawnMock.mockReturnValue({ on: onMock })
+  })
+
+  async function importStartWithArgs(args: string[]) {
+    process.argv = ['node', 'scripts/start.ts', ...args]
+    await import('./start.ts')
+  }
+
+  it('wraps default dev startup through runSetupHooks before spawning nuxt dev', async () => {
+    await importStartWithArgs([])
+
+    expect(runSetupHooksMock).toHaveBeenCalledWith('dev', rootDir, {
+      cached: false,
+      configPath: undefined,
+    })
+    expect(prepareRendererRuntimeMock).not.toHaveBeenCalled()
+    expect(spawnMock).toHaveBeenCalledWith('npx', ['nuxt', 'dev'], {
+      cwd: rootDir,
+      env: process.env,
+      stdio: 'inherit',
+    })
+  })
+
+  it('keeps cached dev startup on the same wrapper contract while switching the nuxt command', async () => {
+    await importStartWithArgs(['--cached'])
+
+    expect(runSetupHooksMock).toHaveBeenCalledWith('dev', rootDir, {
+      cached: true,
+      configPath: undefined,
+    })
+    expect(spawnMock).toHaveBeenCalledWith('npx', ['nuxt', 'dev:cached'], {
+      cwd: rootDir,
+      env: process.env,
+      stdio: 'inherit',
+    })
+  })
+
+  it('routes generate through setup hooks before spawning nuxt generate', async () => {
+    await importStartWithArgs(['--generate', 'config/site.yml'])
+
+    expect(runSetupHooksMock).toHaveBeenCalledWith('generate', rootDir, {
+      configPath: 'config/site.yml',
+    })
+    expect(spawnMock).toHaveBeenCalledWith('npx', ['nuxt', 'generate'], {
+      cwd: rootDir,
+      env: process.env,
+      stdio: 'inherit',
+    })
+  })
+
+  it('routes build through setup hooks before spawning nuxt build', async () => {
+    await importStartWithArgs(['--build', 'config/site.yml'])
+
+    expect(runSetupHooksMock).toHaveBeenCalledWith('build', rootDir, {
+      configPath: 'config/site.yml',
+    })
+    expect(prepareRendererRuntimeMock).not.toHaveBeenCalled()
+    expect(spawnMock).toHaveBeenCalledWith('npx', ['nuxt', 'build'], {
+      cwd: rootDir,
+      env: process.env,
+      stdio: 'inherit',
+    })
+  })
+
+  it('routes preview through the renderer runtime wrapper before spawning nuxt preview', async () => {
+    await importStartWithArgs(['--preview', 'config/site.yml'])
+
+    expect(prepareRendererRuntimeMock).toHaveBeenCalledWith(rootDir, {
+      configPath: 'config/site.yml',
+    })
+    expect(runSetupHooksMock).not.toHaveBeenCalled()
+    expect(process.env.MDSITE_RENDERER_ORCHESTRATED).toBe('1')
+    expect(spawnMock).toHaveBeenCalledWith('npx', ['nuxt', 'preview'], {
+      cwd: rootDir,
+      env: process.env,
+      stdio: 'inherit',
+    })
+  })
+
+  it('supports the explicit prepare hook without spawning nuxt', async () => {
+    const processExitSpy = vi.spyOn(process, 'exit').mockImplementation((code?: number) => {
+      throw new Error(`process.exit(${code ?? 0})`)
+    })
+
+    await expect(importStartWithArgs(['--prepare', 'config/site.yml'])).rejects.toThrow('process.exit(0)')
+
+    expect(runSetupHooksMock).toHaveBeenCalledWith('setup', rootDir, {
+      configPath: 'config/site.yml',
+    })
+    expect(spawnMock).not.toHaveBeenCalled()
+
+    processExitSpy.mockRestore()
+  })
+
+  it('exposes stable CLI-facing script names in package.json', () => {
+    const packageJson = JSON.parse(readFileSync(path.join(rootDir, 'package.json'), 'utf8'))
+
+    expect(packageJson.scripts).toMatchObject({
+      build: 'tsx scripts/start.ts --build',
+      'build:renderer': 'npm run build',
+      dev: 'tsx scripts/start.ts',
+      'dev:cached': 'tsx scripts/start.ts --cached',
+      generate: 'tsx scripts/start.ts --generate',
+      'prepare:renderer': 'tsx scripts/start.ts --prepare',
+      preview: 'tsx scripts/start.ts --preview',
+      setup: 'npm run prepare:renderer',
+      'sync-content': 'tsx scripts/sync-content.ts --sync',
+      'generate-indices': 'tsx scripts/generate-indices.ts',
+      'generate-favicons': 'npm run favicon',
+    })
+  })
+
+  it('exposes normalized backend hook script aliases in package.json', () => {
+    const packageJson = JSON.parse(readFileSync(path.join(rootDir, 'package.json'), 'utf8'))
+
+    expect(packageJson.scripts).toMatchObject({
+      'build:renderer': 'npm run build',
+      'prepare:renderer': 'tsx scripts/start.ts --prepare',
+      'prepare:nuxt': 'nuxt prepare',
+      setup: 'npm run prepare:renderer',
+      start: 'tsx scripts/start.ts',
+    })
+  })
+})

package/mdsite-nuxt/scripts/start.ts

@@ -0,0 +1,55 @@
+import { spawn } from 'child_process'
+import path from 'path'
+import { fileURLToPath } from 'url'
+
+import { prepareRendererRuntime, runSetupHooks } from './renderer-hooks.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+const rootDir = path.resolve(__dirname, '..')
+
+
+// Parse arguments
+const args = process.argv.slice(2)
+const isBuild = args.includes('--build')
+const isGenerate = args.includes('--generate')
+const isCached = args.includes('--cached')
+const isPreview = args.includes('--preview')
+const isSetup = args.includes('--setup') || args.includes('--prepare')
+const configArg = args.find(arg => !arg.startsWith('--') && /\.ya?ml$/i.test(arg))
+
+// Determine the command to run
+let nuxtCommand = 'dev'
+if (isBuild) nuxtCommand = 'build'
+if (isGenerate) nuxtCommand = 'generate'
+if (isPreview) nuxtCommand = 'preview'
+if (isCached && !isBuild && !isGenerate) nuxtCommand = 'dev:cached'
+
+if (isSetup) {
+    await runSetupHooks('setup', rootDir, { configPath: configArg })
+    process.exit(0)
+}
+
+if (nuxtCommand.startsWith('dev')) {
+    await runSetupHooks('dev', rootDir, {
+        cached: isCached,
+        configPath: configArg
+    })
+} else if (nuxtCommand === 'build' || nuxtCommand === 'generate') {
+    await runSetupHooks(nuxtCommand, rootDir, { configPath: configArg })
+} else {
+    prepareRendererRuntime(rootDir, { configPath: configArg })
+    process.env.MDSITE_RENDERER_ORCHESTRATED = '1'
+}
+
+console.log(`✨ Starting Nuxt ${nuxtCommand.toUpperCase()}...`)
+
+const nuxtProcess = spawn('npx', ['nuxt', nuxtCommand], {
+    cwd: rootDir,
+    stdio: 'inherit',
+    env: process.env
+})
+
+nuxtProcess.on('close', (code) => {
+    process.exit(code ?? 0)
+})