aboutsummaryrefslogtreecommitdiff
path: root/src/commands/stdbuf.js
diff options
context:
space:
mode:
authorLily <[email protected]>2026-07-28 16:12:21 +1000
committerGitHub <[email protected]>2026-07-28 16:12:21 +1000
commitc11e17573334dfb487a8e1cc25fa84fa9e138f5c (patch)
treee91dbd19b524f9432da6bcb86b1fc193e0d02e26 /src/commands/stdbuf.js
parent6a2f098e72e71437154ec00506e8e736aa8e1026 (diff)
downloadbnu-c11e17573334dfb487a8e1cc25fa84fa9e138f5c.tar.gz
bnu-c11e17573334dfb487a8e1cc25fa84fa9e138f5c.zip
Refactor coreutils into single-call command modules (#1)
* Refactor to single call
Diffstat (limited to 'src/commands/stdbuf.js')
-rw-r--r--src/commands/stdbuf.js195
1 files changed, 195 insertions, 0 deletions
diff --git a/src/commands/stdbuf.js b/src/commands/stdbuf.js
new file mode 100644
index 0000000..d22cc52
--- /dev/null
+++ b/src/commands/stdbuf.js
@@ -0,0 +1,195 @@
+#!/usr/bin/env bun
+
+import { statSync } from "node:fs";
+import { invalidOptionMessage, localeQuotedEscapedDiagnostic, normalizeLongOptionByPrefix } from "../shared/common.js";
+import { InvocationError, stderr } from "../shared/diagnostics.js";
+import { commandSpawnErrorMessage, isKnownUnexecutableCommand } from "../shared/process.js";
+import { defineCommand, runAsMain } from "../shared/command.js";
+
+export const STDBUF_LONG_OPTIONS = ["input", "output", "error", "help", "version"];
+
+export function stdbufMetaOption(args) {
+ let sawMode = false;
+ for (let i = 0; i < args.length; i++) {
+ const arg = args[i];
+ if (arg === "--") return null;
+ let normalized = arg;
+ if (arg.startsWith("--")) {
+ normalized = normalizeLongOptionByPrefix(arg, STDBUF_LONG_OPTIONS);
+ }
+ const [name, inlineValue] = normalized.startsWith("--") ? normalized.slice(2).split(/=(.*)/s, 2) : [null, undefined];
+ if (name === "help" || name === "version") {
+ if (inlineValue !== undefined) throw new InvocationError(`option '--${name}' doesn't allow an argument`);
+ return normalized;
+ }
+ if (["-i", "-o", "-e"].includes(arg)) {
+ if (i + 1 < args.length) validateStdbufMode(arg[1], args[i + 1]);
+ sawMode = true;
+ i++;
+ continue;
+ }
+ if (["--input", "--output", "--error"].includes(normalized)) {
+ if (i + 1 < args.length) validateStdbufMode(normalized.slice(2, 3), args[i + 1]);
+ sawMode = true;
+ i++;
+ continue;
+ }
+ if (/^-[ioe].+/.test(arg)) {
+ validateStdbufMode(arg[1], arg.slice(2));
+ sawMode = true;
+ continue;
+ }
+ if (/^--(input|output|error)=/.test(normalized)) {
+ const [, name, mode] = normalized.match(/^--(input|output|error)=(.*)$/s);
+ validateStdbufMode(name[0], mode);
+ sawMode = true;
+ continue;
+ }
+ if (arg.startsWith("-")) throw new InvocationError(invalidOptionMessage(arg));
+ if (sawMode) return null;
+ }
+ return null;
+}
+
+export async function stdbufCmd(args) {
+ const { command, env } = stdbufInvocation(args);
+ if (!command.length) throw new InvocationError("missing operand");
+ try {
+ if (await isKnownUnexecutableCommand(command[0])) throw Object.assign(new Error("Permission denied"), { code: "EACCES" });
+ const proc = Bun.spawn(command, { stdin: "inherit", stdout: "inherit", stderr: "inherit", env });
+ return await proc.exited;
+ } catch (error) {
+ const status = stdbufSpawnStatus(command[0], error);
+ stderr(`stdbuf: failed to run command '${command[0]}': ${commandSpawnErrorMessage(error)}\n`);
+ return status;
+ }
+}
+
+export function stdbufSpawnStatus(command, error) {
+ if (command === ".") return 126;
+ if (error?.code === "EACCES" || error?.code === "EISDIR") return 126;
+ if (error?.code === "ENOENT") return 127;
+ if (/not found/i.test(error?.message || "")) return 127;
+ if (/permission denied|is a directory/i.test(error?.message || "")) return 126;
+ return 1;
+}
+
+export function stdbufInvocation(args) {
+ let i = 0;
+ let sawMode = false;
+ const modes = {};
+ const requireValue = (index, option) => {
+ if (index + 1 < args.length) return args[index + 1];
+ if (option.startsWith("--")) throw new InvocationError(`option '${option}' requires an argument`);
+ throw new InvocationError(`option requires an argument -- '${option.slice(1)}'`);
+ };
+ const commandEnv = (command) => ({ command, env: stdbufChildEnv(modes) });
+ while (i < args.length) {
+ let arg = args[i];
+ if (arg.startsWith("--") && arg !== "--") arg = normalizeLongOptionByPrefix(arg, STDBUF_LONG_OPTIONS);
+ const [longName, inlineValue] = arg.startsWith("--") ? arg.slice(2).split(/=(.*)/s, 2) : [null, undefined];
+ if ((longName === "help" || longName === "version") && inlineValue !== undefined) {
+ throw new InvocationError(`option '--${longName}' doesn't allow an argument`);
+ }
+ if (arg === "--") {
+ if (!sawMode) throw new InvocationError("missing operand");
+ return commandEnv(args.slice(i + 1));
+ }
+ if (/^-[ioe].+/.test(arg)) {
+ modes[arg[1]] = validateStdbufMode(arg[1], arg.slice(2));
+ sawMode = true;
+ i++;
+ continue;
+ }
+ if (["-i", "-o", "-e", "--input", "--output", "--error"].includes(arg)) {
+ const stream = arg === "--input" ? "i" : arg === "--output" ? "o" : arg === "--error" ? "e" : arg[1];
+ modes[stream] = validateStdbufMode(stream, requireValue(i, arg));
+ sawMode = true;
+ i += 2;
+ continue;
+ }
+ if (/^--(input|output|error)=/.test(arg)) {
+ const [, name, mode] = arg.match(/^--(input|output|error)=(.*)$/s);
+ modes[name[0]] = validateStdbufMode(name[0], mode);
+ sawMode = true;
+ i++;
+ continue;
+ }
+ if (arg.startsWith("-")) throw new InvocationError(invalidOptionMessage(arg));
+ if (!sawMode) throw new InvocationError("you must specify a buffering mode option");
+ return commandEnv(args.slice(i));
+ }
+ return commandEnv([]);
+}
+
+export function stdbufChildEnv(modes) {
+ const env = { ...process.env };
+ delete env._STDBUF_I;
+ delete env._STDBUF_O;
+ delete env._STDBUF_E;
+ const library = findStdbufLibrary();
+ if (library) env.LD_PRELOAD = env.LD_PRELOAD ? `${library}:${env.LD_PRELOAD}` : library;
+ if (modes.i != null) env._STDBUF_I = modes.i;
+ if (modes.o != null) env._STDBUF_O = modes.o;
+ if (modes.e != null) env._STDBUF_E = modes.e;
+ return env;
+}
+
+export function findStdbufLibrary() {
+ for (const path of ["/usr/libexec/coreutils/libstdbuf.so", "/usr/lib/coreutils/libstdbuf.so"]) {
+ try {
+ if (statSync(path).isFile()) return path;
+ } catch {}
+ }
+ return null;
+}
+
+export function validateStdbufMode(stream, mode) {
+ if (mode == null) throw new InvocationError("missing mode");
+ if (mode === "") throw new InvocationError(`invalid mode ${localeQuotedEscapedDiagnostic("")}`, 125, false);
+ if (mode === "L") {
+ if (stream === "i") throw new InvocationError("line buffering standard input is meaningless");
+ return "L";
+ }
+ if (mode === "0") return "0";
+ if (mode === "l") throw new InvocationError(`invalid mode ${localeQuotedEscapedDiagnostic("l")}`, 125, false);
+ try {
+ const size = parseStdbufSize(mode);
+ return size.toString();
+ } catch (error) {
+ if (error instanceof InvocationError) throw error;
+ throw new InvocationError(`invalid mode ${localeQuotedEscapedDiagnostic(mode)}`, 125, false);
+ }
+}
+
+export function parseStdbufSize(mode) {
+ const text = /^\D+$/.test(mode) ? `1${mode}` : String(mode);
+ const match = text.match(/^(\d+)([A-Za-z]*)$/);
+ if (!match) throw new InvocationError(`invalid mode ${localeQuotedEscapedDiagnostic(mode)}`, 125, false);
+ const binary = {
+ "": 1n,
+ K: 1024n, k: 1024n, KiB: 1024n, kiB: 1024n,
+ M: 1024n ** 2n, m: 1024n ** 2n, MiB: 1024n ** 2n, miB: 1024n ** 2n,
+ G: 1024n ** 3n, g: 1024n ** 3n, GiB: 1024n ** 3n, giB: 1024n ** 3n,
+ T: 1024n ** 4n, t: 1024n ** 4n, TiB: 1024n ** 4n, tiB: 1024n ** 4n,
+ P: 1024n ** 5n, PiB: 1024n ** 5n,
+ E: 1024n ** 6n, EiB: 1024n ** 6n,
+ Z: 1024n ** 7n, ZiB: 1024n ** 7n,
+ Y: 1024n ** 8n, YiB: 1024n ** 8n,
+ };
+ const decimal = {
+ KB: 1000n, kB: 1000n, MB: 1000n ** 2n, mB: 1000n ** 2n,
+ GB: 1000n ** 3n, gB: 1000n ** 3n, TB: 1000n ** 4n, tB: 1000n ** 4n,
+ PB: 1000n ** 5n, EB: 1000n ** 6n, ZB: 1000n ** 7n, YB: 1000n ** 8n,
+ };
+ const scale = binary[match[2]] ?? decimal[match[2]];
+ if (!scale) throw new InvocationError(`invalid mode ${localeQuotedEscapedDiagnostic(mode)}`, 125, false);
+ const amount = BigInt(match[1]) * scale;
+ if (amount > 18446744073709551615n) throw new InvocationError(`invalid mode ${localeQuotedEscapedDiagnostic(mode)}: Value too large for defined data type`, 125, false);
+ return amount;
+}
+
+const singleCall = defineCommand("stdbuf", stdbufCmd, stdbufMetaOption);
+export default singleCall;
+
+if (import.meta.main) await runAsMain(singleCall);