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

The assets plugin starts a chokidar watcher in setup(), but it was only
ever disposed by tests. A Nuxt/Vite host recreates the dev bridge — and a
fresh DevframeNodeContext — on every config reload and once per build
environment, so watchers accumulated until the dev process ran out of
heap ("JS heap out of memory" on Nuxt 4); the destabilised/killed bridge
then surfaced on the client as a WebSocket "socket hang up" (Nuxt 5).

- assets: key live watchers by absolute directory (not by context) so a
  new setup on the same dir supersedes the previous watcher instead of
  stacking another — capping watchers at one per directory regardless of
  reload count. Regression test added.
- assets: harden the watch — followSymlinks:false, ignore node_modules/
  .git/.nuxt/.output/.turbo/.cache/dist, ignorePermissionErrors, and a
  bounded depth — so a symlink or misconfigured dir can't make the scan
  walk a huge tree.
- nuxt: mount the dev RPC/WS bridge on the client build only
  ({ server: false }). The browser talks to Nuxt's client dev server, so
  the second bridge + watcher spun up in the Nitro/SSR build context was
  redundant and a source of instability.

Co-authored-by: opencode <noreply@opencode.ai>

Author: antfubot

packages/nuxt/src/module.ts

@@ -139,14 +139,20 @@ 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)
+      }) as any, { server: false })
     }
   },
 })

plugins/assets/src/node/index.ts

@@ -1,6 +1,7 @@
 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'
@@ -27,7 +28,14 @@ export interface SetupAssetsOptions {
   serveStatic: boolean
 }
 
-const watchers = new WeakMap<DevframeNodeContext, () => Promise<void>>()
+// 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>()
 
 /**
  * Register the assets RPC surface on a devframe node context: ensures the
@@ -69,8 +77,14 @@ export async function setupAssets(ctx: DevframeNodeContext, options: SetupAssets
       ctx.rpc.register(fn)
   }
 
-  if (ctx.mode === 'dev')
-    watchers.set(ctx, watchAssetsDir(ctx, options.dir))
+  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)
+  }
 }
 
 /**
@@ -79,10 +93,14 @@ 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 dispose = watchers.get(ctx)
+  const dir = ctxToDir.get(ctx)
+  if (!dir)
+    return
+  ctxToDir.delete(ctx)
+  const dispose = watchersByDir.get(dir)
   if (!dispose)
     return
-  watchers.delete(ctx)
+  watchersByDir.delete(dir)
   await dispose()
 }
 

plugins/assets/src/node/watcher.ts

@@ -3,11 +3,18 @@ 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 (tests in particular — a leaked watcher keeps the process alive).
+ * 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.
  */
 export function watchAssetsDir(ctx: DevframeNodeContext, dir: string): () => Promise<void> {
   const notify = debounce(async () => {
@@ -16,11 +23,14 @@ export function watchAssetsDir(ctx: DevframeNodeContext, dir: string): () => Pro
 
   const watcher = watch(dir, {
     ignoreInitial: true,
-    // 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,
+    // 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,
   })
   watcher
     .on('add', () => void notify())

plugins/assets/test/assets.test.ts

@@ -181,4 +181,29 @@ 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()
+    }
+  })
 })