From 6f5241afb5bd1d6a1a8724bf06cc6f205c279402 Mon Sep 17 00:00:00 2001 From: Soccera1 <129828376+Soccera1@users.noreply.github.com> Date: Sat, 18 Jul 2026 09:27:17 +1000 Subject: Refactor to single call --- src/commands/stdbuf.js | 195 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 195 insertions(+) create mode 100644 src/commands/stdbuf.js (limited to 'src/commands/stdbuf.js') 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); -- cgit v1.3