Files not detected if directory does not exist before watching

[Ehesp]

Describe the bug

Directories which don't exist before starting the watcher are not detected.

Versions (please complete the following information):

• Chokidar version 4.0.3
• Node version 23.6.0
• OS version: debian:bullseye-slim

To Reproduce:

I've got a watcher looking at /home/sandbox.

Before I start the watcher, some files on FS already exist on /home/sandbox/project/.... When the watcher kicks off, it notifies me about all of these files as expected. After a few seconds, a process creates some more files on my filesystem, e.g:

1. /home/sandbox/project/.foo/bar.txt
2. /home/sandbox/.baz/hello.txt

My watcher successfully notifies me about file 1, but does not trigger any changes about file 2.

const watcher = chokidar.watch('/home/sandbox', {
    persistent: true,
    ignoreInitial: false,
    followSymlinks: true,
});

watcher.on('all', (event, filePath) => {
  console.log('[chokidar] all', filePath);
  // only logs /home/sandbox/project/.foo/bar.txt
});

If however, I create the directory before starting the watcher, I get notified about both files:

// Create the directory first
await fs.mkdir('/home/sandbox/.baz', { recursive: true });

const watcher = chokidar.watch('/home/sandbox', {
    persistent: true,
    ignoreInitial: false,
    followSymlinks: true,
});

Now if any files are created inside of /home/sandbox/.baz I get notified

Expected behavior

It picks up changes even if its a new directory

Additional context

Not sure if relevant, but the . directory names are intentional. I have tried a bunch of config options, ignore regex/callbacks but they never register the directory in the first place.

[alexlymannix]

I also have this problem - I am trying to monitor a .log.active file that appears when a user is making changes to a filesystem and stays active for 15 min with the newest actions. However if the .log.active file is not in the directory when I start the watcher it will not be picked up even if I am watching the parent directory.

I am using v3.6

[43081j]

if one of you could make an actual reproduction, that'd be super helpful

i.e. write some steps that cause this problem every time for you, along with a small script (like the ones in the OP) that experiences it

we have tests which test this case, so we know it works. which suggests we need an example we can repro to be able to debug it

[Ehesp]

What's the best way of getting you a real reproduction? Would a repo with a docker setup work?

[alexlymannix]

`this.watcher = chokidar.watch('../../../../../../../Volumes/stage01/.event_audit', {
            ignored: ['**/*.log'], // ignore .log files
            persistent: true,
            usePolling: true,

        });


        // Something to use when events are received.
        const log = console.log.bind(console);


        // Add event listeners.
        this.watcher
            .on('ready', () => {
                log('Initial scan complete. Ready for changes')
                let watchedPaths = this.watcher.getWatched();
                log(watchedPaths);
            })
            .on('add', (path) => {
                log(`File ${path} is  now being watched`)
            })
            .on('change', async (path) => {
                log(`change found ${path}`)

            })
            .on('unlink', path => log(`File ${path} is no longer being watched`))
  
            .on('error', error => log(`Watcher error: ${error}`))
    }`

Steps to reproduce:

1. start watcher
2. add new file to .event_audit
3. new file does not trigger either an add or change event

My code is pretty similar to the example code in the README from what I can see.

[43081j]

@alexlymannix i tried this locally on macOS using both a parent dir (watch ../.event_audit) and a child dir (watch ./.event_audit). both seemed to work fine and successfully log out that the file is being watched

given you have a Volumes, i'm guessing you're also on macOS

when you add a new file, how do you add it? i wonder what we're doing differently 🤔

@Ehesp something like this would be nice:

import * as chokidar from './index.js';
import * as fs from 'node:fs/promises';

await fs.mkdir('./temp');
await fs.mkdir('./temp/dir0');
await fs.writeFile('./temp/dir0/file0.txt', 'hello world');

const watcher = chokidar.watch('/code/chokidar/temp', {
  persistent: true,
  ignoreInitial: false,
  followSymlinks: true
});

watcher.on('all', console.log);

await new Promise((r) => r());

await fs.mkdir('./temp/dir0/.foo');
await fs.writeFile('./temp/dir0/.foo/foo', 'foo');

await fs.mkdir('./temp/.bar');
await fs.writeFile('./temp/.bar/bar', 'bar');

this works for me, but does what you described in your original post unless i missed something

[Ehesp]

Ok this is interesting... I'm using Bun to make things easier, but the following code works locally:

import chokadir from "chokidar";
import * as fs from "node:fs/promises";

// Setup
if (await fs.exists("./test")) {
  await fs.rmdir("./test", { recursive: true });
}
await fs.mkdir("./test", { recursive: true });

// Write a /foo/.bar/baz.txt file, so it exists before watching
await fs
  .mkdir("./test/foo/.bar", { recursive: true })
  .then(() => fs.writeFile("./test/foo/.bar/baz.txt", "Hello, world!"));

// Watch
const watcher = chokadir.watch("./test", {
  persistent: true,
  ignoreInitial: false,
  followSymlinks: true,
});

// Log all events
watcher.on("all", (event, filePath) => {
  console.log("[chokidar]", event, filePath);
});

// Ensure the watcher is ready before writing a file
await new Promise<void>((resolve) => {
  watcher.on("ready", () => resolve());
});

// Write a /foo/.bar/baz.txt file, so it exists before watching
await fs
  .mkdir("./test/.hello", { recursive: true })
  .then(() => fs.writeFile("./test/.hello/world.txt", "Hello, world, again!"));

// Wait for 5 seconds
await new Promise<void>((resolve) => {
  setTimeout(() => {
    resolve();
  }, 5000);
});

await fs.rmdir("./test", { recursive: true });

// Exit
process.exit(0);

The output is as follows (expected):

bun run index.ts      
[chokidar] addDir test
[chokidar] addDir test/foo
[chokidar] addDir test/foo/.bar
[chokidar] add test/foo/.bar/baz.txt
[chokidar] addDir test/.hello
[chokidar] add test/.hello/world.txt

However I ran this inside of Docker on the bullseye-slim image:

FROM oven/bun AS bun
WORKDIR /app
COPY . .
RUN bun install --frozen-lockfile
RUN bun build index.ts --compile --outfile out

FROM debian:bullseye-slim
WORKDIR /app
COPY --from=bun /app/out .

CMD ["./out"]

Running docker build . -t test and then docker run -t test I get:

[chokidar] addDir test
[chokidar] addDir test/foo
[chokidar] addDir test/foo/.bar
[chokidar] add test/foo/.bar/baz.txt

Which matches my experience in production.

Just to be safe, running the bun binary standalone locally (bun build index.ts --compile --outfile out && ./out) has the correct results, so it seems to be a issue inside of the debian:bullseye-slim environment?

I've pushed up the full reproduction here: https://github.com/Ehesp/chokidar-repro