fs: prevent spurious recursive watch events on prefix siblings

Signed-off-by: marcopiraccini <marco.piraccini@gmail.com>
PR-URL: #63095Fixes: #58868
Reviewed-By: Paolo Insogna <paolo@cowtech.it>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>

Author: marcopiraccini

lib/internal/fs/recursive_watch.js

@@ -25,6 +25,7 @@ const {
 join: pathJoin,
 relative: pathRelative,
 resolve: pathResolve,
+sep: pathSep,
 }=require('path');
 
 letinternalSync;
@@ -106,8 +107,10 @@ class FSWatcher extends EventEmitter {
  #unwatchFiles(file){
 this.#symbolicFiles.delete(file);
 
+constchildPrefix=file+pathSep;
 for(constfilenameofthis.#files.keys()){
-if(StringPrototypeStartsWith(filename,file)){
+if(filename===file||
+StringPrototypeStartsWith(filename,childPrefix)){
 this.#files.delete(filename);
 this.#watchers.get(filename)?.close();
 this.#watchers.delete(filename);

test/parallel/test-fs-watch-recursive-prefix-sibling.js

@@ -0,0 +1,70 @@
+'use strict';
+
+// Regression test for https://github.com/nodejs/node/issues/58868
+
+constcommon=require('../common');
+
+if(common.isIBMi){
+common.skip('IBMi does not support `fs.watch()`');
+}
+
+if(common.isAIX){
+common.skip('folder watch capability is limited in AIX.');
+}
+
+// macOS and Windows use the native recursive watcher and are unaffected.
+if(common.isMacOS||common.isWindows){
+common.skip('regression specific to the JS-based recursive watcher');
+}
+
+constassert=require('assert');
+constfs=require('fs');
+constpath=require('path');
+const{ setTimeout }=require('timers/promises');
+
+consttmpdir=require('../common/tmpdir');
+tmpdir.refresh();
+
+(async()=>{
+constroot=fs.mkdtempSync(path.join(tmpdir.path,'watch-prefix-'));
+
+// Sibling names that share the prefix `foo` with the entries to delete.
+fs.mkdirSync(path.join(root,'foo_bar'));
+fs.writeFileSync(path.join(root,'foo_bar','file.txt'),'');
+fs.mkdirSync(path.join(root,'foo_bar','somedir'));
+fs.writeFileSync(path.join(root,'foo_'),'');
+
+// `foo` (empty) exercises the exact-match branch of `#unwatchFiles`.
+fs.mkdirSync(path.join(root,'foo'));
+
+// `foo2` has descendants and exercises the `file + sep` prefix branch.
+fs.mkdirSync(path.join(root,'foo2'));
+fs.writeFileSync(path.join(root,'foo2','inside.txt'),'');
+fs.mkdirSync(path.join(root,'foo2','sub'));
+
+constevents=[];
+constwatcher=fs.watch(root,{recursive: true},(eventType,filename)=>{
+events.push({ eventType, filename });
+});
+
+// Allow the watcher to fully attach to existing entries.
+awaitsetTimeout(common.platformTimeout(200));
+
+fs.rmdirSync(path.join(root,'foo'));
+fs.rmSync(path.join(root,'foo2'),{recursive: true});
+
+// Wait long enough to capture any spurious follow-up events.
+awaitsetTimeout(common.platformTimeout(500));
+
+watcher.close();
+
+constisSibling=(f)=>
+f==='foo_'||f==='foo_bar'||
+f.startsWith('foo_bar'+path.sep);
+constspurious=events.filter((e)=>isSibling(e.filename));
+assert.deepStrictEqual(
+spurious,
+[],
+`unexpected events for prefix-sibling entries: ${JSON.stringify(spurious)}`,
+);
+})().then(common.mustCall());