create-mercato-app 0.6.6-develop.6317.1.b3be10ab84 → 0.6.6-develop.6331.1.a33b8e99b7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-mercato-app",
-  "version": "0.6.6-develop.6317.1.b3be10ab84",
+  "version": "0.6.6-develop.6331.1.a33b8e99b7",
   "type": "module",
   "description": "Create a new Open Mercato application",
   "main": "./dist/index.js",

package/template/package.json.template

@@ -12,6 +12,7 @@
     "dev": "node ./scripts/dev.mjs",
     "dev:classic": "node ./scripts/dev.mjs --classic",
     "dev:verbose": "node ./scripts/dev.mjs --verbose",
+    "dev:fix-wsl-watchers": "node ./scripts/fix-wsl-inotify.mjs",
     "dev:reset": "node ./scripts/dev-reset.mjs",
     "build": "yarn generate && cross-env NODE_OPTIONS=--max-old-space-size=8192 next build",
     "start": "mercato server start",

package/template/scripts/dev-inotify-limits.mjs

@@ -0,0 +1,270 @@
+import fs from 'node:fs'
+import { spawnSync as defaultSpawnSync } from 'node:child_process'
+
+export const DEFAULT_INOTIFY_LIMITS = {
+  max_user_watches: 4194304,
+  max_user_instances: 4096,
+  max_queued_events: 65536,
+}
+
+const INOTIFY_PROC_DIR = '/proc/sys/fs/inotify'
+const WSL_MARKER_PATHS = [
+  '/proc/sys/kernel/osrelease',
+  '/proc/version',
+]
+
+export const VSCODE_WATCHER_EXCLUDES = {
+  '**/.git/**': true,
+  '**/.turbo/**': true,
+  '**/dist/**': true,
+  '**/node_modules/**': true,
+  '.ai/tmp/**': true,
+  '.claude/**': true,
+  '.mercato/**': true,
+  'apps/mercato/.mercato/**': true,
+}
+
+function parseInteger(value) {
+  const parsed = Number.parseInt(String(value ?? '').trim(), 10)
+  return Number.isInteger(parsed) ? parsed : null
+}
+
+export function detectWsl({
+  platform = process.platform,
+  readFileSync = fs.readFileSync,
+} = {}) {
+  if (platform !== 'linux') return false
+
+  for (const markerPath of WSL_MARKER_PATHS) {
+    try {
+      const marker = String(readFileSync(markerPath, 'utf8')).toLowerCase()
+      if (marker.includes('microsoft') || marker.includes('wsl')) {
+        return true
+      }
+    } catch {
+      // Non-WSL Linux images may not expose both marker files.
+    }
+  }
+
+  return false
+}
+
+export function readCurrentInotifyLimits({
+  readFileSync = fs.readFileSync,
+} = {}) {
+  const values = {}
+  const errors = {}
+
+  for (const name of Object.keys(DEFAULT_INOTIFY_LIMITS)) {
+    const filePath = `${INOTIFY_PROC_DIR}/${name}`
+    try {
+      const value = parseInteger(readFileSync(filePath, 'utf8'))
+      if (value === null) {
+        errors[name] = `invalid value in ${filePath}`
+      } else {
+        values[name] = value
+      }
+    } catch (error) {
+      errors[name] = error?.message ?? String(error)
+    }
+  }
+
+  return { values, errors }
+}
+
+export function findInotifyLimitIssues(current, required = DEFAULT_INOTIFY_LIMITS) {
+  const issues = []
+
+  for (const [name, minimum] of Object.entries(required)) {
+    const currentValue = current?.[name]
+    if (typeof currentValue !== 'number') continue
+    if (currentValue < minimum) {
+      issues.push({ name, current: currentValue, required: minimum })
+    }
+  }
+
+  return issues
+}
+
+export function buildSysctlAssignments(
+  issues,
+  required = DEFAULT_INOTIFY_LIMITS,
+) {
+  return issues.map((issue) => `fs.inotify.${issue.name}=${required[issue.name]}`)
+}
+
+export function buildPersistentSysctlConfig(required = DEFAULT_INOTIFY_LIMITS) {
+  return [
+    '# Open Mercato dev server file-watch limits',
+    ...Object.entries(required).map(([name, value]) => `fs.inotify.${name}=${value}`),
+    '',
+  ].join('\n')
+}
+
+export function buildManualInotifyFix({ required = DEFAULT_INOTIFY_LIMITS } = {}) {
+  const assignments = Object.entries(required)
+    .map(([name, value]) => `fs.inotify.${name}=${value}`)
+    .join(' ')
+  const config = buildPersistentSysctlConfig(required).replace(/\n/g, '\\n')
+
+  return [
+    `sudo sysctl -w ${assignments}`,
+    `printf '${config}' | sudo tee /etc/sysctl.d/99-open-mercato-inotify.conf >/dev/null`,
+    'sudo sysctl --system',
+  ]
+}
+
+export function mergeVsCodeWatcherExcludes(settings, excludes = VSCODE_WATCHER_EXCLUDES) {
+  const next = {
+    ...(settings && typeof settings === 'object' && !Array.isArray(settings) ? settings : {}),
+  }
+  let changed = false
+
+  for (const key of ['files.watcherExclude', 'search.exclude']) {
+    const current = next[key] && typeof next[key] === 'object' && !Array.isArray(next[key])
+      ? next[key]
+      : {}
+    const merged = { ...current }
+
+    for (const [pattern, value] of Object.entries(excludes)) {
+      if (merged[pattern] !== value) {
+        merged[pattern] = value
+        changed = true
+      }
+    }
+
+    if (next[key] !== merged) {
+      next[key] = merged
+    }
+  }
+
+  return { settings: next, changed }
+}
+
+function resolveSysctlCommand({ getuid = process.getuid?.bind(process), nonInteractive = true } = {}) {
+  if (typeof getuid === 'function' && getuid() === 0) {
+    return { command: 'sysctl', args: ['-w'] }
+  }
+
+  return {
+    command: 'sudo',
+    args: [nonInteractive ? '-n' : null, 'sysctl', '-w'].filter(Boolean),
+  }
+}
+
+export function applyInotifyLimits({
+  issues,
+  required = DEFAULT_INOTIFY_LIMITS,
+  spawnSync = defaultSpawnSync,
+  getuid = process.getuid?.bind(process),
+  nonInteractive = true,
+  stdio = 'pipe',
+} = {}) {
+  if (!Array.isArray(issues) || issues.length === 0) {
+    return { ok: true, skipped: true }
+  }
+
+  const { command, args } = resolveSysctlCommand({ getuid, nonInteractive })
+  const assignments = buildSysctlAssignments(issues, required)
+  const result = spawnSync(command, [...args, ...assignments], {
+    encoding: 'utf8',
+    stdio,
+  })
+
+  return {
+    ok: result.status === 0,
+    command,
+    args: [...args, ...assignments],
+    status: result.status,
+    error: result.error,
+    stderr: result.stderr,
+    stdout: result.stdout,
+  }
+}
+
+export function formatInotifyLimitFailure({
+  current,
+  issues,
+  manualCommands = buildManualInotifyFix(),
+  isWsl = false,
+} = {}) {
+  const location = isWsl ? 'WSL2/Linux' : 'Linux'
+  const issueLines = issues.map((issue) =>
+    `  fs.inotify.${issue.name}: ${issue.current} < ${issue.required}`,
+  )
+
+  return [
+    `❌ ${location} file-watch limits are too low for Turbopack.`,
+    'Turbopack will panic with "OS file watch limit reached" unless these sysctl values are raised.',
+    '',
+    ...issueLines,
+    '',
+    'Run this once in your WSL/Linux terminal:',
+    ...manualCommands.map((line) => `  ${line}`),
+    '',
+    `Current values: ${JSON.stringify(current)}`,
+  ].join('\n')
+}
+
+export function ensureDevInotifyLimits({
+  env = process.env,
+  platform = process.platform,
+  readFileSync = fs.readFileSync,
+  spawnSync = defaultSpawnSync,
+  getuid = process.getuid?.bind(process),
+  required = DEFAULT_INOTIFY_LIMITS,
+} = {}) {
+  const rawMode = String(env.OM_DEV_INOTIFY_CHECK ?? '').trim().toLowerCase()
+  if (['0', 'false', 'off', 'skip'].includes(rawMode)) {
+    return { ok: true, skipped: true, reason: 'disabled' }
+  }
+
+  if (platform !== 'linux') {
+    return { ok: true, skipped: true, reason: 'non-linux' }
+  }
+
+  const isWsl = detectWsl({ platform, readFileSync })
+  const { values, errors } = readCurrentInotifyLimits({ readFileSync })
+  const issues = findInotifyLimitIssues(values, required)
+
+  if (issues.length === 0) {
+    return { ok: true, current: values, isWsl }
+  }
+
+  const applyResult = applyInotifyLimits({
+    issues,
+    required,
+    spawnSync,
+    getuid,
+    nonInteractive: true,
+    stdio: 'pipe',
+  })
+
+  if (applyResult.ok) {
+    return {
+      ok: true,
+      fixed: true,
+      current: values,
+      issues,
+      isWsl,
+      applyResult,
+    }
+  }
+
+  const manualCommands = buildManualInotifyFix({ required })
+  return {
+    ok: false,
+    current: values,
+    errors,
+    issues,
+    isWsl,
+    applyResult,
+    manualCommands,
+    message: formatInotifyLimitFailure({
+      current: values,
+      issues,
+      manualCommands,
+      isWsl,
+    }),
+  }
+}

package/template/scripts/dev.mjs

@@ -23,6 +23,7 @@ import {
   stripAnsi,
 } from './dev-splash-helpers.mjs'
 import { purgeAppBuildCaches } from './dev-cache-purge.mjs'
+import { ensureDevInotifyLimits } from './dev-inotify-limits.mjs'
 import { killProcessTree } from './dev-shutdown-utils.mjs'
 import { resolveSpawnCommand } from './dev-spawn-utils.mjs'
 import { createDevSplashCodingFlow } from './dev-splash-coding-flow.mjs'
@@ -317,6 +318,32 @@ function printDevLogLocation() {
   process.env.OM_DEV_LOG_ANNOUNCED = '1'
 }
 
+function ensureDevFileWatchLimits() {
+  const result = ensureDevInotifyLimits()
+  if (result.fixed) {
+    console.log('🔧 Raised Linux inotify file-watch limits for Turbopack')
+    return true
+  }
+  if (result.ok) {
+    return true
+  }
+
+  updateSplashState({
+    phase: 'File-watch limits too low',
+    detail: 'Raise Linux inotify limits before starting Turbopack',
+    failed: true,
+    failureLines: result.message.split('\n').filter(Boolean).slice(0, 10),
+    failureCommand: 'yarn dev:fix-wsl-watchers',
+    ready: false,
+    readyUrl: null,
+    loginUrl: null,
+    activity: 'File-watch limit preflight failed',
+  })
+  console.error(result.message)
+  shutdown(1)
+  return false
+}
+
 function spawnCommand(command, commandArgs, options = {}) {
   const resolvedSpawn = resolveSpawnCommand(command, commandArgs)
   const teeRequested = options.mirrorOutput === true
@@ -1756,6 +1783,7 @@ async function runClassicStandaloneDev() {
 async function main() {
   printDevLogLocation()
   await startSplashServer()
+  if (!ensureDevFileWatchLimits()) return
 
   if (!isMonorepo) {
     if (setupMode) {

package/template/scripts/fix-wsl-inotify.mjs

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+import readline from 'node:readline/promises'
+import {
+  DEFAULT_INOTIFY_LIMITS,
+  buildPersistentSysctlConfig,
+  buildSysctlAssignments,
+  buildManualInotifyFix,
+  detectWsl,
+  findInotifyLimitIssues,
+  mergeVsCodeWatcherExcludes,
+  readCurrentInotifyLimits,
+} from './dev-inotify-limits.mjs'
+
+const PERSIST_PATH = '/etc/sysctl.d/99-open-mercato-inotify.conf'
+const noPersist = process.argv.includes('--no-persist')
+const assumeYes = process.argv.includes('--yes') || process.argv.includes('-y')
+const applyVsCode = process.argv.includes('--vscode')
+const skipVsCode = process.argv.includes('--no-vscode')
+
+async function confirm(question, { defaultYes = false } = {}) {
+  if (assumeYes) return true
+  if (!process.stdin.isTTY || !process.stdout.isTTY) return false
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
+  try {
+    const suffix = defaultYes ? ' [Y/n] ' : ' [y/N] '
+    const answer = (await rl.question(`${question}${suffix}`)).trim().toLowerCase()
+    if (!answer) return defaultYes
+    return answer === 'y' || answer === 'yes'
+  } finally {
+    rl.close()
+  }
+}
+
+function run(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    stdio: options.input ? ['pipe', 'inherit', 'inherit'] : 'inherit',
+    input: options.input,
+    encoding: 'utf8',
+  })
+  if (result.status !== 0) {
+    process.exit(result.status ?? 1)
+  }
+}
+
+async function maybeUpdateVsCodeSettings() {
+  if (skipVsCode) return
+
+  const shouldApply = applyVsCode || (!assumeYes && await confirm(
+    'Optionally update .vscode/settings.json to exclude generated/cache/worktree folders from VS Code file watching? This modifies a tracked workspace file.',
+  ))
+  if (!shouldApply) return
+
+  const settingsPath = path.join(process.cwd(), '.vscode', 'settings.json')
+  let settings = {}
+  if (fs.existsSync(settingsPath)) {
+    try {
+      settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'))
+    } catch (error) {
+      console.warn(`Could not parse ${settingsPath}; leaving VS Code settings unchanged: ${error?.message ?? error}`)
+      return
+    }
+  }
+
+  const { settings: nextSettings, changed } = mergeVsCodeWatcherExcludes(settings)
+  if (!changed) {
+    console.log('VS Code watcher excludes already include the recommended Open Mercato patterns.')
+    return
+  }
+
+  fs.mkdirSync(path.dirname(settingsPath), { recursive: true })
+  fs.writeFileSync(settingsPath, `${JSON.stringify(nextSettings, null, 4)}\n`)
+  console.log(`Updated ${settingsPath}. Reload the WSL VS Code window so existing watcher handles are released.`)
+}
+
+function printCurrent(prefix) {
+  const { values } = readCurrentInotifyLimits()
+  console.log(`${prefix} ${JSON.stringify(values)}`)
+  return values
+}
+
+if (process.platform !== 'linux') {
+  console.log('Linux inotify limits do not apply on this platform; no sysctl changes are needed.')
+  process.exit(0)
+}
+
+const current = printCurrent('Current inotify limits:')
+const issues = findInotifyLimitIssues(current)
+
+if (issues.length === 0) {
+  console.log('Inotify limits already satisfy Open Mercato dev requirements.')
+  await maybeUpdateVsCodeSettings()
+  process.exit(0)
+}
+
+if (detectWsl()) {
+  console.log('WSL detected; raising Linux inotify limits for Turbopack.')
+} else {
+  console.log('Raising Linux inotify limits for Turbopack.')
+}
+
+for (const command of buildManualInotifyFix()) {
+  console.log(`  ${command}`)
+}
+
+if (!await confirm('Apply these sysctl changes now?', { defaultYes: true })) {
+  console.log('No changes applied.')
+  process.exit(1)
+}
+
+run('sudo', ['sysctl', '-w', ...buildSysctlAssignments(issues)])
+
+if (!noPersist) {
+  run('sudo', ['tee', PERSIST_PATH], {
+    input: buildPersistentSysctlConfig(DEFAULT_INOTIFY_LIMITS),
+  })
+  run('sudo', ['sysctl', '--system'])
+}
+
+printCurrent('Updated inotify limits:')
+await maybeUpdateVsCodeSettings()