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

[alex-mooreslab]

I'm also facing this issue, on Ubuntu.

So if I tell Chokidar to watch:
/home/<my-user>/some/path/file.csv

But if the parent folders don't exist when Chokidar starts watching it... Then it won't trigger when it finally does exist.

This also doesn't work while usePolling is set to true.

  const watcher = chokidar.watch(absolutePath, {
    usePolling: true,
  })

  console.debug(`Watching file at ${absolutePath}`)

  function onChange() {
    const content = readFileSyncSafe(absolutePath)

    event.reply(IPC_SIGNALS.fileChangedEvent, {
      watchId,
      files: [ content ],
    } satisfies WatchEvent)
  }

  watcher.on('all', () => onChange())
  watcher.on('add', () => onChange())
  watcher.on('error', console.error)

How I have tested it:

1. I work with a python app that writes exports to a .csv file, and it makes the parent dirs when it writes it. When that writes the file and it finally exists, Chokidar doesn't fire any events at all because the parent folders didn't exist when I started the .watch() command.
2. I'll begin Chokidar watching it, and then I'll cut/paste the parent folder(s) to the expected location and Chokidar won't emit any events. Even though the path matches perfectly with what it should have been expecting.

Notes:

• I am on Ubuntu LTS (24.04.1)
• Using Node.js 22.19.0 (This is the current LTS version, "Jod")
• The repository is managed with Yarn Berry (4.9.2)
• This Chokidar watch command does run on the main thread of an Electron app, which should be pure node.js

I realize my above statement may mislead conclusions about Electron being a potential culprit.

To make sure Electron isn't a culprit, I put together this sample linux test script, and I can recreate this bug with this test script:

import chokidar from 'chokidar'
import { rmSync, existsSync, readFileSync, mkdirSync } from 'node:fs'
import { spawnSync } from 'node:child_process'
import { dirname, resolve } from 'node:path'
import { tmpdir } from 'node:os'

async function main() {
  // Setup:
  const tmp = tmpdir()
  const file = resolve(`${tmp}/some/path/to/watch.csv`)

  // Ensure the parents don't exist first:
  if (existsSync(`${tmp}/some`)) {
    rmSync(`${tmp}/some`, {
      force: true,
      recursive: true,
    })
  }
  console.log('Ensured parent dir does not exist')

  // Begin watching:
  console.log(`Watching file at ${file}`)
  const watcher = chokidar.watch(file, {
    usePolling: true,
  })
  watcher.on('all', console.log)
  watcher.on('add', console.log)
  watcher.on('error', console.error)

  // Create the file to watch:
  mkdirSync(
    resolve(
      dirname(file),
    ),
    { recursive: true },
  )
  spawnSync(`echo 'Here is some test data!' > ${file}`, {
    shell: true,
  })
  console.log(`  $ echo 'Here is some test data!' > ${file}`)
  console.log('Wrote initial file')

  console.log('Waiting 1 second...')
  await new Promise((resolve) => setTimeout(resolve, 1_000))
  console.log('Manually reading file to confirm existance:')
  console.log(`File content: ${readFileSync(file, 'utf-8')}`)
  console.log(existsSync(file) ? 'File exists!' : 'File does not exist!')

  console.log('Modifying file...')
  spawnSync('echo "Here is some NEW test data!" >> ' + file, {
    shell: true,
  })
  console.log(`Updated file content: ${readFileSync(file, 'utf-8')}`)

  console.log('Waiting 1 second...')
  await new Promise((resolve) => setTimeout(resolve, 1_000))

  process.exit(0)
}

main()

I ran this script with tsx:

yarn global add tsx
tsx ./test.ts

As you can see, it fails to ever emit the event from chokidar.

> tsx ./test.ts
Ensured parent dir does not exist
Watching file at /tmp/some/path/to/watch.csv
  $ echo 'Here is some test data!' > /tmp/some/path/to/watch.csv
Wrote initial file
Waiting 1 second...
Manually reading file to confirm existance:
File content: Here is some test data!

File exists!
Modifying file...
Updated file content: Here is some test data!
Here is some NEW test data!

Waiting 1 second...

[alex-mooreslab]

@Ehesp

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

I think your test passes, because I have noticed that if node.js directly creates the parent directory before a content write then chokidar works.

In your bun code, I think this is what is making it pass locally:

await fs.mkdir("./test/foo/.bar", { recursive: true })

However, if something else writes to it or makes the parent directory (linux touch file, linux echo, python script, user does cut/paste of the parent folder in the GUI, etc) then it doesn't work.