Run a subprocess and capture its output snippet

import { execFile } from 'node:child_process';
import { promisify } from 'node:util';

const run = promisify(execFile); // execFile: argv list, NO shell

const { stdout } = await run('git', ['status']); // injection-safe
console.log(stdout);

import { execFile } from 'node:child_process';
import { promisify } from 'node:util';

const execFileAsync = promisify(execFile);

export async function run(
  cmd: string,
  args: readonly string[]
): Promise<{ stdout: string; stderr: string; code: number }> {
  try {
    const r = await execFileAsync(cmd, args, { encoding: 'utf8' });
    return { stdout: r.stdout, stderr: r.stderr, code: 0 };
  } catch (err: any) { // non-zero exit lands HERE
    return { stdout: err.stdout, stderr: err.stderr, code: err.code };
  }
}

import (
	"fmt"
	"os/exec"
)

out, err := exec.Command("git", "status").Output() // argv, no shell
if err != nil {
	if exitErr, ok := err.(*exec.ExitError); ok {
		fmt.Fatalf("exit %d: %s", exitErr.ExitCode(), exitErr.Stderr)
	}
	fmt.Fatalf("spawn failed: %v", err) // binary missing, etc.
}
fmt.Print(string(out))

use std::process::Command;

let out = Command::new("git")
    .arg("status")  // argv — there is no shell to inject into
    .output()       // captures stdout AND stderr, no deadlock
    .expect("failed to start git");

println!("exit={}", out.status.code().unwrap_or(-1));
println!("stdout:\n{}", String::from_utf8_lossy(&out.stdout));

$proc = proc_open(['git', 'status'], [ // argv ARRAY — no shell
    1 => ['pipe', 'w'],
    2 => ['pipe', 'w'],
], $pipes);

$stdout = stream_get_contents($pipes[1]);
$stderr = stream_get_contents($pipes[2]);
fclose($pipes[1]);
fclose($pipes[2]);

$code = proc_close($proc); // exit code is data

import subprocess

r = subprocess.run(
    ['git', 'status'],    # argv list — no shell
    capture_output=True,  # stdout AND stderr, no deadlock
    text=True,            # str, not bytes
    check=False,          # non-zero exit is not an exception
)

print(r.returncode, r.stdout, r.stderr)

#include <stdio.h>
#include <sys/wait.h>

FILE *p = popen("git status", "r"); // ALWAYS runs via sh -c
if (!p) { perror("popen"); return 1; }

char line[256];
while (fgets(line, sizeof line, p)) // drain stdout (stderr not captured)
    fputs(line, stdout);

int st = pclose(p); // ENCODED wait status, not the exit code
if (WIFEXITED(st))
    printf("exit=%d\n", WEXITSTATUS(st));

using System.Diagnostics;

var psi = new ProcessStartInfo("git")
{
    RedirectStandardOutput = true,
    RedirectStandardError = true,
    UseShellExecute = false, // required for redirects — and no shell
};
psi.ArgumentList.Add("status"); // argv entries — NOT an Arguments string

using var process = Process.Start(psi)!;

// Start BOTH readers before waiting — draining one pipe while the
// other fills is the deadlock again, just sequential:
Task<string> stdoutTask = process.StandardOutput.ReadToEndAsync();
Task<string> stderrTask = process.StandardError.ReadToEndAsync();
await process.WaitForExitAsync();

Console.WriteLine($"exit={process.ExitCode}");
Console.WriteLine(await stdoutTask);
Console.Error.WriteLine(await stderrTask);

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.List;

Process p = new ProcessBuilder(List.of("git", "status")) // argv — no shell
        .redirectErrorStream(true)                        // merge the streams
        .start();

// Read the output BEFORE waitFor — the child blocks when its pipe
// buffer fills, and waitFor blocks waiting for the child: deadlock.
StringBuilder sb = new StringBuilder();
try (BufferedReader r = new BufferedReader(
        new InputStreamReader(p.getInputStream()))) {
    r.lines().forEach(line -> sb.append(line).append('\n'));
}

int code = p.waitFor(); // NOW safe — pipes already drained
System.out.print(code + "\n" + sb);

import Foundation

let process = Process()
process.executableURL = URL(fileURLWithPath: "/usr/bin/git")
process.arguments = ["status"] // argv array — no shell

let pipe = Pipe()
process.standardOutput = pipe
process.standardError = pipe // both streams, one reader

try process.run()
let data = pipe.fileHandleForReading.readDataToEndOfFile()
process.waitUntilExit() // AFTER the drain

let output = String(data: data, encoding: .utf8) ?? ""
print("exit=\(process.terminationStatus)")
print(output)

val process = ProcessBuilder(listOf("git", "status")) // argv — no shell
    .redirectErrorStream(true)
    .start()

// Drain the merged stream BEFORE waitFor — same JVM deadlock rule:
val output = process.inputStream.bufferedReader().readText()
val code = process.waitFor()

println("exit=$code\n$output")

require 'open3'

stdout, stderr, status = Open3.capture3('git', 'status') # argv, no shell

puts status.exitstatus # exit code is data
puts stdout

const std = @import("std");

const result = try std.process.Child.run(.{
    .allocator = allocator,
    .argv = &.{ "git", "status" }, // argv slice — std.process has no shell
});

defer allocator.free(result.stdout);
defer allocator.free(result.stderr);

switch (result.term) {
    .Exited => |code| std.debug.print("exit={d}\n{s}", .{ code, result.stdout }),
    else => std.debug.print("killed by signal\n", .{}),
}