Revert "fix(assets,nuxt): stop dev-bridge file-watcher leak that OOMs/hangs Nuxt"

This reverts commit 0dfd33e.

Author: antfubot

packages/nuxt/src/module.ts

@@ -139,20 +139,14 @@ export default defineNuxtModule<ModuleOptions>({
         ?? (nuxt.options.devServer as any)?.host
         ?? options.devframe.cli?.host
 
-      // Client build only: the browser talks to Nuxt's client dev server,
-      // so the RPC/WS bridge and its `__connection.json` middleware must
-      // live there. Adding it to the server (Nitro/SSR) build too would
-      // spin up a second, redundant bridge + file watcher inside the SSR
-      // build context — wasted resources at best, and a source of dev-server
-      // instability at worst.
       addVitePlugin(viteDevBridge(options.devframe, {
         base: options.baseURL ?? './',
         devMiddleware: {
           port: mw.port,
           host,
           flags: mw.flags,
         },
-      }) as any, { server: false })
+      }) as any)
     }
   },
 })

plugins/assets/src/node/index.ts

@@ -1,7 +1,6 @@
 import type { DevframeNodeContext } from 'devframe/types'
 import { existsSync } from 'node:fs'
 import fsp from 'node:fs/promises'
-import { resolve } from 'pathe'
 import { UPLOAD_CHANNEL } from '../rpc/functions/upload'
 import { alwaysFunctions, readFunctions, writeFunctions } from '../rpc/index'
 import { configureAssets } from './context'
@@ -28,14 +27,7 @@ export interface SetupAssetsOptions {
   serveStatic: boolean
 }
 
-// Keyed by absolute managed directory, not by context: a host (Nuxt / Vite)
-// recreates the dev bridge — and thus a fresh `DevframeNodeContext` — on every
-// config reload and once per build environment. Keying by directory caps live
-// watchers at one per directory no matter how many times setup re-runs, so
-// they can't accumulate and exhaust the heap. `ctxToDir` lets a specific
-// context dispose its own watcher (tests).
-const watchersByDir = new Map<string, () => Promise<void>>()
-const ctxToDir = new WeakMap<DevframeNodeContext, string>()
+const watchers = new WeakMap<DevframeNodeContext, () => Promise<void>>()
 
 /**
  * Register the assets RPC surface on a devframe node context: ensures the
@@ -77,14 +69,8 @@ export async function setupAssets(ctx: DevframeNodeContext, options: SetupAssets
       ctx.rpc.register(fn)
   }
 
-  if (ctx.mode === 'dev') {
-    const dir = resolve(options.dir)
-    // Replace any watcher left over from a prior dev-bridge cycle on the
-    // same directory before starting a fresh one bound to this context.
-    await watchersByDir.get(dir)?.()
-    watchersByDir.set(dir, watchAssetsDir(ctx, options.dir))
-    ctxToDir.set(ctx, dir)
-  }
+  if (ctx.mode === 'dev')
+    watchers.set(ctx, watchAssetsDir(ctx, options.dir))
 }
 
 /**
@@ -93,14 +79,10 @@ export async function setupAssets(ctx: DevframeNodeContext, options: SetupAssets
  * leaked chokidar watcher doesn't keep the process alive.
  */
 export async function disposeAssetsWatcher(ctx: DevframeNodeContext): Promise<void> {
-  const dir = ctxToDir.get(ctx)
-  if (!dir)
-    return
-  ctxToDir.delete(ctx)
-  const dispose = watchersByDir.get(dir)
+  const dispose = watchers.get(ctx)
   if (!dispose)
     return
-  watchersByDir.delete(dir)
+  watchers.delete(ctx)
   await dispose()
 }
 

plugins/assets/src/node/watcher.ts

@@ -3,18 +3,11 @@ import { watch } from 'chokidar'
 import { debounce } from 'perfect-debounce'
 import { CHANGED_EVENT } from '../constants'
 
-// Never descend into these — following a symlink or a stray copy of one of
-// these into the managed directory would otherwise make chokidar walk a huge
-// tree (a common cause of dev-server OOM).
-const IGNORED_RE = /(?:^|[/\\])(?:node_modules|\.git|\.nuxt|\.output|\.turbo|\.cache|dist)(?:[/\\]|$)/
-
 /**
  * Watch the managed directory and broadcast {@link CHANGED_EVENT} (debounced)
  * whenever a file is added, removed, or changed, so connected UIs refresh
  * their listing live. Returns a disposer; call it when the devframe shuts
- * down — a leaked watcher keeps the process alive and, when a host (Nuxt /
- * Vite) recreates the dev bridge across reloads, accumulates until the
- * process runs out of heap.
+ * down (tests in particular — a leaked watcher keeps the process alive).
  */
 export function watchAssetsDir(ctx: DevframeNodeContext, dir: string): () => Promise<void> {
   const notify = debounce(async () => {
@@ -23,14 +16,11 @@ export function watchAssetsDir(ctx: DevframeNodeContext, dir: string): () => Pro
 
   const watcher = watch(dir, {
     ignoreInitial: true,
-    // Don't traverse symlinks — a link pointing at `node_modules` (or a
-    // parent dir) would otherwise blow up memory / inotify watches.
-    followSymlinks: false,
-    ignorePermissionErrors: true,
-    ignored: (path: string) => IGNORED_RE.test(path),
-    // A managed asset dir is shallow in practice; cap depth so a misconfigured
-    // `dir` (e.g. a project root) can't make the initial scan runaway.
-    depth: 16,
+    // Directories can nest arbitrarily deep (icon sets, generated builds
+    // dropped into the managed dir, …) — chokidar's default depth is
+    // unlimited, but pin a generous cap so a runaway symlink loop can't
+    // spin the watcher forever.
+    depth: 32,
   })
   watcher
     .on('add', () => void notify())

plugins/assets/test/assets.test.ts

@@ -181,29 +181,4 @@ describe('assets plugin', () => {
     await waitFor(() => changed)
     expect(await call(client, 'devframes:plugin:assets:list')).toHaveLength(1)
   })
-
-  it('replaces the watcher across dev-bridge restarts on the same directory', async () => {
-    // A host (Nuxt / Vite) recreates the dev bridge — and a fresh context —
-    // on every reload. Starting a second cycle on the same directory must
-    // supersede the first watcher, not stack another one (which would leak
-    // until the process runs out of heap). The proof: the newest cycle's
-    // watcher is the live one, so its client still receives change events.
-    const first = await startAssetsServer(dir)
-    server = await startAssetsServer(dir) // second cycle; afterEach closes this one
-    try {
-      const clientB = bootClient(server.port)
-      let changed = false
-      clientB.onEvent('devframes:plugin:assets:changed', () => {
-        changed = true
-      })
-      await call(clientB, 'devframes:plugin:assets:list')
-
-      await fsp.writeFile(join(dir, 'after-restart.txt'), 'x', 'utf-8')
-      await waitFor(() => changed)
-      expect(changed).toBe(true)
-    }
-    finally {
-      await first.close()
-    }
-  })
 })