Great question! I’ve run into similar needs before—wanting better control over docker exec than shelljs offers, while avoiding the limitations you’ve hit with dockerode. Let’s break down your best paths forward:

1. Fix & Enhance Dockerode Usage (It Does Support Exec Success Checks!) #

First off, don’t write off dockerode entirely—you might just be missing a key step to check exec success. The library does let you retrieve the exit code of an exec command via the exec.inspect() method, which is how you’ll confirm if the command succeeded.

Here’s a working example that captures output and verifies success:

const Docker = require('dockerode');
const docker = new Docker();

async function runDockerExec() {
  const container = docker.getContainer('your-container-id-or-name');
  
  // Configure your exec command
  const execOptions = {
    Cmd: ['sh', '-c', 'echo "Hello from container" && exit 0'], // Replace with your command
    AttachStdout: true,
    AttachStderr: true
  };

  try {
    // Create the exec instance
    const exec = await container.exec(execOptions);
    // Start the exec stream
    const stream = await exec.start({ hijack: true, stdin: false });

    // Capture output from the stream
    let output = '';
    stream.on('data', (chunk) => {
      output += chunk.toString();
    });

    // Once the stream ends, check the exit code
    stream.on('end', async () => {
      const execStatus = await exec.inspect();
      if (execStatus.ExitCode === 0) {
        console.log('✅ Command executed successfully!');
        console.log('Output:', output.trim());
      } else {
        console.error(`❌ Command failed with exit code ${execStatus.ExitCode}`);
        console.error('Error output:', output.trim());
      }
    });
  } catch (err) {
    console.error('Failed to set up exec command:', err);
  }
}

runDockerExec();

This approach gives you full control over the exec process, including real-time output capture and explicit success/failure checks via the exit code.

2. Directly Call the Docker REST API (Full Control, No SDK Limitations) #

If you want to bypass SDKs entirely, Docker exposes a complete REST API that powers all CLI commands—including docker exec. This gives you absolute control over every part of the workflow, with no gaps in feature support.

You can use any HTTP client (like axios or even Node’s native http module) to interact with the API. Here’s a quick example with axios:

const axios = require('axios');

// Point to your Docker socket (adjust the API version if needed)
const dockerApiUrl = 'http://localhost/v1.41';

async function execViaDockerAPI() {
  const containerId = 'your-container-id-or-name';
  const command = ['ls', '-l', '/app']; // Your target command

  try {
    // Step 1: Create an exec instance
    const execCreateResponse = await axios.post(
      `${dockerApiUrl}/containers/${containerId}/exec`,
      { Cmd: command, AttachStdout: true, AttachStderr: true }
    );
    const execId = execCreateResponse.data.Id;

    // Step 2: Start the exec command and capture output
    const execStartResponse = await axios.post(
      `${dockerApiUrl}/exec/${execId}/start`,
      { hijack: true, stdin: false },
      { responseType: 'stream' }
    );

    let output = '';
    execStartResponse.data.on('data', (chunk) => {
      output += chunk.toString();
    });

    // Step 3: Wait for the stream to end, then check exit code
    await new Promise(resolve => execStartResponse.data.on('end', resolve));
    const execInspectResponse = await axios.get(`${dockerApiUrl}/exec/${execId}/json`);
    const exitCode = execInspectResponse.data.ExitCode;

    if (exitCode === 0) {
      console.log('✅ API-based exec succeeded!');
      console.log('Output:', output.trim());
    } else {
      console.error(`❌ API-based exec failed with exit code ${exitCode}`);
      console.error('Error output:', output.trim());
    }
  } catch (err) {
    console.error('API request failed:', err);
  }
}

execViaDockerAPI();

This is the most flexible option—you can tweak every parameter supported by Docker’s exec API, and there’s no risk of missing features that SDKs might not have implemented yet.

3. Use Child Process Spawn (Simple, CLI-Parity Control) #

If you want behavior identical to running docker exec in your terminal, Node’s built-in child_process.spawn is a great choice. Unlike shelljs, it lets you directly capture exit codes, streams, and errors without extra wrapper overhead.

Here’s how to use it:

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

function runExecWithSpawn() {
  // Spawn the docker exec command (matches exactly what you'd run in terminal)
  const dockerProcess = spawn('docker', [
    'exec',
    'your-container-id-or-name',
    'sh',
    '-c',
    'echo "Test command" && exit 0' // Replace with your command
  ]);

  let stdout = '';
  let stderr = '';

  // Capture standard output
  dockerProcess.stdout.on('data', (data) => {
    stdout += data.toString();
  });

  // Capture error output
  dockerProcess.stderr.on('data', (data) => {
    stderr += data.toString();
  });

  // Check exit code when process finishes
  dockerProcess.on('close', (exitCode) => {
    if (exitCode === 0) {
      console.log('✅ Spawned exec succeeded!');
      console.log('STDOUT:', stdout.trim());
    } else {
      console.error(`❌ Spawned exec failed with exit code ${exitCode}`);
      console.error('STDERR:', stderr.trim());
    }
  });

  // Handle process startup errors
  dockerProcess.on('error', (err) => {
    console.error('Failed to start docker exec process:', err);
  });
}

runExecWithSpawn();

This method is straightforward, requires zero external dependencies, and gives you full visibility into whether the command succeeded via the exit code. It’s especially useful if you’re already familiar with the docker exec CLI syntax.

Final Recommendations #

• Stick with dockerode if you prefer an SDK—just make sure to use exec.inspect() to get exit codes. This should solve your success-checking need without switching tools.
• Use the Docker REST API if you need maximum control over every aspect of the exec workflow (e.g., custom headers, advanced stream handling).
• Go with child_process.spawn if you want exact parity with the docker exec CLI and don’t want to add any extra dependencies.

内容的提问来源于stack exchange，提问作者Nithin D J