如何监控采用stdio: inherit的spawn子进程标准输出？单元测试场景下的解决方案问询

你遇到的问题很典型：当子进程配置stdio: inherit时，它会直接复用父进程的标准输入/输出/错误的系统文件描述符，完全绕过了Node.js在JavaScript层面封装的process.stdout对象。这就是为什么你重写process.stdout.write没有效果——子进程的输出根本没走这个JS方法，直接写到了系统级的stdout里。

下面提供两种可行的解决方案，你可以根据场景选择：

方案1：替换stdio: inherit为管道，同时转发输出 #

如果你的子进程不需要直接控制终端（比如不需要处理颜色、光标移动等交互操作），这个方法最简单。我们把stdio改成pipe模式，手动监听子进程的输出，既收集内容，又把它转发到父进程的stdout，模拟inherit的效果：

const { spawn } = require('child_process');

function exec(command, args) {
  // 配置stdio：stdin继承父进程，stdout和stderr用管道
  const child = spawn(command, args, { stdio: ['inherit', 'pipe', 'pipe'] });
  
  let collectedOutput = '';
  let collectedError = '';

  // 监听子进程stdout，收集并转发
  child.stdout.on('data', (chunk) => {
    const content = chunk.toString();
    collectedOutput += content;
    process.stdout.write(content); // 保持原有的输出行为
  });

  // 同理处理stderr
  child.stderr.on('data', (chunk) => {
    const content = chunk.toString();
    collectedError += content;
    process.stderr.write(content);
  });

  // 把收集的内容挂载到child对象上，方便外部获取
  child.collectedOutput = collectedOutput;
  child.collectedError = collectedError;

  return child;
}

// 使用示例
const echo = exec('echo', ['hello', 'world']);
echo.on('exit', () => {
  console.log('捕获到的输出:', echo.collectedOutput);
  // 输出：捕获到的输出: hello world\n
});

这个方法的优点是代码简洁、易维护，完全用Node.js内置API实现，不会有文件描述符泄漏的风险。

方案2：底层文件描述符拦截（适合必须用stdio: inherit的场景） #

如果你的子进程需要直接和终端交互（比如使用readline、输出带颜色的文本），pipe模式可能会破坏这些行为。这时候需要用系统级的文件描述符操作来拦截输出：

const { spawn } = require('child_process');
const fs = require('fs');

function execAndMonitor(command, args) {
  return new Promise((resolve, reject) => {
    // 保存父进程原有的stdout文件描述符
    const originalStdoutFd = fs.dupSync(process.stdout.fd);
    // 创建一个管道，用于拦截输出
    const [readFd, writeFd] = fs.pipeSync();

    // 将父进程的stdout重定向到管道的写端
    fs.dupSync(writeFd, process.stdout.fd);
    fs.closeSync(writeFd);

    let collectedOutput = '';
    // 从管道读端读取内容，同时写回原stdout保持显示
    const readStream = fs.createReadStream(null, { fd: readFd });
    readStream.on('data', (chunk) => {
      const content = chunk.toString();
      collectedOutput += content;
      fs.writeSync(originalStdoutFd, content);
    });

    readStream.on('error', reject);

    // 执行子进程，保持stdio: inherit
    const child = spawn(command, args, { stdio: 'inherit' });

    child.on('exit', (code) => {
      // 恢复父进程原有的stdout
      fs.dupSync(originalStdoutFd, process.stdout.fd);
      fs.closeSync(originalStdoutFd);
      readStream.destroy();
      
      resolve({ code, collectedOutput });
    });

    child.on('error', reject);
  });
}

// 使用示例
execAndMonitor('echo', ['hello', 'world'])
  .then((result) => {
    console.log('\n最终捕获的输出:', result.collectedOutput);
  })
  .catch(console.error);

这个方法通过dup2（Node.js里的fs.dupSync）复制和重定向文件描述符，能捕获所有写到stdout的内容，包括子进程用stdio: inherit时的输出。但要注意必须正确恢复文件描述符，避免资源泄漏。

为什么你原来的方法无效？ #

再补充一下原因：Node.js的process.stdout是一个Stream对象，它的write方法是JavaScript层面的封装，最终会调用系统API写入文件描述符。但当子进程用stdio: inherit时，它直接拿到父进程stdout的文件描述符，绕过了Node.js的Stream层，直接向系统写入数据——所以你重写的process.stdout.write根本不会被调用。

内容的提问来源于stack exchange，提问作者Brett Zamir