Function runSh

packages/kaos/test/shell.test.ts:16–76

* Helper to run a shell command via /bin/sh -c and collect stdout/stderr/exitCode. * Since the new Kaos.exec(...args) doesn't take options, timeout is implemented * by killing the process after the given duration.

(
  kaos: Kaos,
  command: string,
  options?: { timeout?: number; stdinData?: string },
)

 * by killing the process after the given duration.
 */
async function runSh(
  kaos: Kaos,
  command: string,
  options?: { timeout?: number; stdinData?: string },
): Promise<{ stdout: string; stderr: string; exitCode: number }> {
  const proc: KaosProcess = await kaos.exec('/bin/sh', '-c', command);

  // Set up timeout if requested
  let timedOut = false;
  let timer: ReturnType<typeof setTimeout> | undefined;
  if (options?.timeout !== undefined) {
    timer = setTimeout(() => {
      timedOut = true;
      void proc.kill('SIGKILL');
    }, options.timeout);
  }

  // If stdinData is provided, write it and close stdin
  if (options?.stdinData !== undefined) {
    proc.stdin.write(options.stdinData);
    proc.stdin.end();
  } else {
    proc.stdin.end();
  }

  // Collect stdout and stderr concurrently with waiting for process exit
  const stdoutChunks: Buffer[] = [];
  const stderrChunks: Buffer[] = [];

  const stdoutDone = new Promise<void>((resolve) => {
    proc.stdout.on('data', (chunk: Buffer) => {
      stdoutChunks.push(chunk);
    });
    proc.stdout.on('end', () => {
      resolve();
    });
  });

  const stderrDone = new Promise<void>((resolve) => {
    proc.stderr.on('data', (chunk: Buffer) => {
      stderrChunks.push(chunk);
    });
    proc.stderr.on('end', () => {
      resolve();
    });
  });

  const exitCode = await proc.wait();
  await stdoutDone;
  await stderrDone;

  if (timer !== undefined) {
    clearTimeout(timer);
  }

  return {
    stdout: Buffer.concat(stdoutChunks).toString('utf-8'),
    stderr: Buffer.concat(stderrChunks).toString('utf-8'),