teen_process

What is teen_process?

The teen_process npm package provides utilities for executing system commands and managing child processes in Node.js. It simplifies the process of running shell commands, handling their output, and managing subprocesses.

What are teen_process's main functionalities?

exec

The `exec` function allows you to run shell commands and capture their output. In this example, the `ls -la` command is executed, and its output is logged to the console.

const { exec } = require('teen_process');

async function runCommand() {
  try {
    const { stdout, stderr } = await exec('ls', ['-la']);
    console.log('Output:', stdout);
    console.error('Error:', stderr);
  } catch (err) {
    console.error('Command failed:', err);
  }
}

runCommand();

spawn

The `spawn` function is used to launch a new process with a given command. This example demonstrates how to spawn the `ls -la` command and handle its stdout, stderr, and exit events.

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

function runSpawn() {
  const child = spawn('ls', ['-la']);

  child.stdout.on('data', (data) => {
    console.log(`stdout: ${data}`);
  });

  child.stderr.on('data', (data) => {
    console.error(`stderr: ${data}`);
  });

  child.on('close', (code) => {
    console.log(`child process exited with code ${code}`);
  });
}

runSpawn();

execFile

The `execFile` function is similar to `exec`, but it is specifically designed for executing files. In this example, the `node -v` command is executed to get the Node.js version.

const { execFile } = require('teen_process');

async function runExecFile() {
  try {
    const { stdout, stderr } = await execFile('node', ['-v']);
    console.log('Node version:', stdout);
    console.error('Error:', stderr);
  } catch (err) {
    console.error('Command failed:', err);
  }
}

runExecFile();

Other packages similar to teen_process

child_process

The `child_process` module is a core Node.js module that provides similar functionality to `teen_process`. It allows you to spawn new processes, execute commands, and handle their output. However, `teen_process` offers a more user-friendly API and additional features like promise-based execution.

execa

The `execa` package is a popular alternative to `teen_process` for executing shell commands in Node.js. It provides a promise-based API, better error handling, and more features for managing child processes. Compared to `teen_process`, `execa` is more feature-rich and widely used in the community.

shelljs

The `shelljs` package provides a portable (Windows/Linux/OS X) implementation of Unix shell commands in Node.js. It allows you to run shell commands and scripts with a simple API. While `shelljs` focuses on providing a shell-like environment, `teen_process` is more focused on managing child processes and executing commands.

README

node-teen_process

A grown-up version of Node's child_process. exec is really useful, but it suffers many limitations. This is an es7 (async/await) implementation of exec that uses spawn under the hood. It takes care of wrapping commands and arguments so we don't have to care about escaping spaces. It can also return stdout/stderr even when the command fails, or times out. Importantly, it's also not susceptible to max buffer issues.

Examples:

import { exec } from 'teen_process';

# basic usage
let {stdout, stderr, code} = await exec('ls', ['/usr/local/bin']);
console.log(stdout.split("\n"));  // array of files
console.log(stderr);              // ''
console.log(code);                // 0

# works with spaces
let res = await exec('/command/with spaces.sh', ['foo', 'argument with spaces'])
# as though we had run: "/command/with spaces.sh" foo "argument with spaces"

# takes options cwd, env, timeout, and killSignal
await exec('sleep', ['10'], {timeout: 500, killSignal: 'SIGINT'});

# defaults:
# {
#   cwd: undefined,
#   env: process.env,
#   timeout: null,
#   killSignal: 'SIGTERM'
# }