How to fix Error: EBADF: bad file descriptor, read (file descriptor closed) in Node.js

const fs = require('fs');

// autoClose defaults to true - stream handles closing
const readStream = fs.createReadStream('/path/to/file.txt');

readStream.on('data', (chunk) => {
  console.log('Read:', chunk.length, 'bytes');
});

readStream.on('end', () => {
  console.log('Stream finished, descriptor auto-closed');
});

readStream.on('error', (err) => {
  console.error('Stream error:', err);
  // Stream will still auto-close on error
});

const fs = require('fs/promises');

async function readFile() {
  const fileHandle = await fs.open('/path/to/file.txt', 'r');

  // Create stream from file handle
  const stream = fileHandle.createReadStream();

  stream.on('data', (chunk) => {
    console.log('Chunk:', chunk.toString());
  });

  // Wait for stream to finish - DON'T close fileHandle here
  await new Promise((resolve, reject) => {
    stream.on('end', resolve);
    stream.on('error', reject);
  });

  // Now safe to close
  await fileHandle.close();
}

const fs = require('fs/promises');

async function manualControl() {
  const fileHandle = await fs.open('/path/to/file.txt', 'r');

  try {
    const stream = fileHandle.createReadStream({
      autoClose: false // We'll close manually
    });

    // Process stream
    for await (const chunk of stream) {
      console.log('Processing:', chunk.length, 'bytes');
    }

    // Stream finished, now safe to close
    await fileHandle.close();
    console.log('File handle closed successfully');

  } catch (err) {
    console.error('Error:', err);
    await fileHandle.close(); // Close even on error
  }
}

const fs = require('fs/promises');

let fileHandle = null;

async function safeClose() {
  if (fileHandle && !fileHandle.closed) {
    try {
      await fileHandle.close();
      console.log('File handle closed');
    } catch (err) {
      if (err.code !== 'EBADF') {
        throw err; // Re-throw non-EBADF errors
      }
      // EBADF means already closed, ignore
      console.log('Descriptor already closed');
    }
    fileHandle = null;
  }
}

async function openAndRead() {
  try {
    fileHandle = await fs.open('/path/to/file.txt', 'r');
    const content = await fileHandle.readFile('utf8');
    console.log(content);
  } finally {
    await safeClose();
  }
}

const fs = require('fs/promises');

async function concurrentSafeRead() {
  const fileHandle = await fs.open('/path/to/file.txt', 'r');

  try {
    // Multiple reads - wait for all to complete
    const results = await Promise.all([
      fileHandle.read(Buffer.alloc(100), 0, 100, 0),
      fileHandle.read(Buffer.alloc(100), 0, 100, 100),
      fileHandle.read(Buffer.alloc(100), 0, 100, 200),
    ]);

    console.log('All reads completed:', results);

  } finally {
    // Only close after all operations finish
    await fileHandle.close();
  }
}

# Check current limit
ulimit -n

# Increase soft limit temporarily (until reboot)
ulimit -n 4096

# For permanent change, edit /etc/security/limits.conf
# Add these lines:
* soft nofile 4096
* hard nofile 8192

// Check current limits
const { exec } = require('child_process');

exec('ulimit -n', (err, stdout) => {
  console.log('File descriptor limit:', stdout.trim());
});