buninu-linux 0.2.1 → 0.3.1

package/initramfs/bin/mount

@@ -0,0 +1,401 @@
+#!/bin/bun
+// mount — mount a filesystem, or list what is mounted. `mount --help` renders
+// /usr/share/doc/buninu-linux/mount.md.
+//
+// A Bun script over the mount(2) binding in /lib/dlopen.js. Filesystem
+// drivers and block-device drivers are kernel modules on the Alpine kernels
+// this distro boots, so the command loads them through /lib/modprobe.js:
+// ext4 (with jbd2/mbcache/crc16), vfat/exfat/ntfs3 with their NLS tables,
+// and common virtio / SATA / NVMe / USB storage drivers when the device node
+// is not there yet.
+
+import { existsSync, mkdirSync, openSync, readSync, closeSync, readdirSync, readFileSync } from "node:fs";
+import { libc, cString, ptr, errno, strerror, Errno, SysError } from "../lib/dlopen.js";
+import { showDocument } from "../lib/document.js";
+import { modprobe, tryModprobe, modulesDirectory, ModuleNotFound } from "../lib/modprobe.js";
+
+const fail = (message, status = 32) => {
+  console.error(`mount: ${message}`);
+  process.exit(status);
+};
+
+// ---------------------------------------------------------------- options --
+
+// <linux/mount.h> flags, keyed by the -o word that sets or clears them.
+const MS = {
+  RDONLY: 1n, NOSUID: 2n, NODEV: 4n, NOEXEC: 8n, SYNCHRONOUS: 16n, REMOUNT: 32n,
+  MANDLOCK: 64n, DIRSYNC: 128n, NOSYMFOLLOW: 256n, NOATIME: 1024n, NODIRATIME: 2048n,
+  BIND: 4096n, MOVE: 8192n, REC: 16384n, SILENT: 32768n, UNBINDABLE: 1n << 17n,
+  PRIVATE: 1n << 18n, SLAVE: 1n << 19n, SHARED: 1n << 20n, RELATIME: 1n << 21n,
+  STRICTATIME: 1n << 24n, LAZYTIME: 1n << 25n,
+};
+
+const flagWords = {
+  ro: [MS.RDONLY, true], rw: [MS.RDONLY, false],
+  nosuid: [MS.NOSUID, true], suid: [MS.NOSUID, false],
+  nodev: [MS.NODEV, true], dev: [MS.NODEV, false],
+  noexec: [MS.NOEXEC, true], exec: [MS.NOEXEC, false],
+  sync: [MS.SYNCHRONOUS, true], async: [MS.SYNCHRONOUS, false],
+  dirsync: [MS.DIRSYNC, true],
+  mand: [MS.MANDLOCK, true], nomand: [MS.MANDLOCK, false],
+  noatime: [MS.NOATIME, true], atime: [MS.NOATIME, false],
+  nodiratime: [MS.NODIRATIME, true], diratime: [MS.NODIRATIME, false],
+  relatime: [MS.RELATIME, true], norelatime: [MS.RELATIME, false],
+  strictatime: [MS.STRICTATIME, true], nostrictatime: [MS.STRICTATIME, false],
+  lazytime: [MS.LAZYTIME, true], nolazytime: [MS.LAZYTIME, false],
+  nosymfollow: [MS.NOSYMFOLLOW, true], symfollow: [MS.NOSYMFOLLOW, false],
+  silent: [MS.SILENT, true], loud: [MS.SILENT, false],
+  remount: [MS.REMOUNT, true],
+  bind: [MS.BIND, true], rbind: [MS.BIND | MS.REC, true],
+  move: [MS.MOVE, true],
+  shared: [MS.SHARED, true], rshared: [MS.SHARED | MS.REC, true],
+  private: [MS.PRIVATE, true], rprivate: [MS.PRIVATE | MS.REC, true],
+  slave: [MS.SLAVE, true], rslave: [MS.SLAVE | MS.REC, true],
+  unbindable: [MS.UNBINDABLE, true], runbindable: [MS.UNBINDABLE | MS.REC, true],
+  defaults: [0n, true], auto: [0n, true], noauto: [0n, true], user: [0n, true],
+  nouser: [0n, true], nofail: [0n, true], _netdev: [0n, true],
+};
+
+// Splits "-o ro,noatime,size=64M" into mount(2) flags plus the data string the
+// filesystem driver parses itself.
+const parseOptions = (list, state) => {
+  for (const word of list.split(",")) {
+    if (!word) continue;
+    const key = word.split("=")[0];
+    if (word in flagWords) {
+      const [bit, set] = flagWords[word];
+      state.flags = set ? state.flags | bit : state.flags & ~bit;
+    } else if (key === "loop") {
+      fail("loop devices are not supported yet");
+    } else {
+      state.data.push(word);
+    }
+  }
+};
+
+const usage = () => {
+  console.error(`Usage:
+  mount [-l]
+  mount [-fv] [-t TYPE] [-o OPTIONS] [-r|-w] [--mkdir] SOURCE TARGET
+  mount -L LABEL|-U UUID [-t TYPE] [-o OPTIONS] TARGET
+  mount --bind|--rbind|--move OLD NEW
+  mount -o remount[,ro|rw] TARGET
+  mount -h | --help          full manual (mount.md)`);
+  process.exit(1);
+};
+
+const parseArguments = (argv) => {
+  const state = { flags: 0n, data: [], positional: [], type: null, mkdir: false, verbose: false, fake: false };
+  const takeValue = (i, flag) => {
+    if (i + 1 >= argv.length) fail(`option ${flag} needs an argument`, 1);
+    return argv[i + 1];
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const argument = argv[i];
+    if (argument === "-h" || argument === "--help") state.help = true;
+    else if (argument === "-t" || argument === "--types") state.type = argv[++i] ?? usage();
+    else if (argument.startsWith("--types=")) state.type = argument.slice(8);
+    else if (argument.startsWith("-t") && argument.length > 2) state.type = argument.slice(2);
+    else if (argument === "-o" || argument === "--options") parseOptions(takeValue(i++, "-o"), state);
+    else if (argument.startsWith("--options=")) parseOptions(argument.slice(10), state);
+    else if (argument.startsWith("-o") && argument.length > 2) parseOptions(argument.slice(2), state);
+    else if (argument === "-L" || argument === "--label") state.source = `LABEL=${takeValue(i++, "-L")}`;
+    else if (argument === "-U" || argument === "--uuid") state.source = `UUID=${takeValue(i++, "-U")}`;
+    else if (argument === "-r" || argument === "--read-only") state.flags |= MS.RDONLY;
+    else if (argument === "-w" || argument === "--rw" || argument === "--read-write") state.flags &= ~MS.RDONLY;
+    else if (argument === "-B" || argument === "--bind") state.flags |= MS.BIND;
+    else if (argument === "-R" || argument === "--rbind") state.flags |= MS.BIND | MS.REC;
+    else if (argument === "-M" || argument === "--move") state.flags |= MS.MOVE;
+    else if (argument === "--make-shared") state.flags |= MS.SHARED;
+    else if (argument === "--make-private") state.flags |= MS.PRIVATE;
+    else if (argument === "--make-rshared") state.flags |= MS.SHARED | MS.REC;
+    else if (argument === "--make-rprivate") state.flags |= MS.PRIVATE | MS.REC;
+    else if (argument === "--mkdir") state.mkdir = true;
+    else if (/^-[fv]{2,}$/.test(argument)) {
+      if (argument.includes("f")) state.fake = true;
+      if (argument.includes("v")) state.verbose = true;
+    }
+    else if (argument === "-v" || argument === "--verbose") state.verbose = true;
+    else if (argument === "-f" || argument === "--fake") state.fake = true;
+    else if (argument === "-l" || argument === "-n" || argument === "--no-mtab" || argument === "-i" || argument === "--no-canonicalize") {}
+    else if (argument === "-a" || argument === "--all") fail("there is no /etc/fstab on this system, so -a does nothing", 1);
+    else if (argument === "--") state.positional.push(...argv.slice(i + 1)), i = argv.length;
+    else if (argument.startsWith("-") && argument.length > 1) console.error(`mount: unknown option ${argument}`), usage();
+    else state.positional.push(argument);
+  }
+  return state;
+};
+
+// -------------------------------------------------------------- listing ----
+
+const listMounts = () => {
+  const table = readFileSync("/proc/self/mounts", "utf8");
+  const unescape = (field) => field.replace(/\\([0-7]{3})/g, (_, code) => String.fromCharCode(parseInt(code, 8)));
+  for (const line of table.split("\n")) {
+    if (!line) continue;
+    const [source, target, type, options] = line.split(" ").map(unescape);
+    console.log(`${source} on ${target} type ${type} (${options})`);
+  }
+};
+
+// ---------------------------------------------------------------- probing --
+
+// Reads the first 128 KiB of a block device: enough for every superblock
+// magic checked below (btrfs sits at 64 KiB, ISO 9660 at 32 KiB).
+const readHeader = (device) => {
+  const fd = openSync(device, "r");
+  try {
+    const buffer = Buffer.alloc(128 * 1024);
+    const length = readSync(fd, buffer, 0, buffer.length, 0);
+    return buffer.subarray(0, length);
+  } finally {
+    closeSync(fd);
+  }
+};
+
+const ascii = (buffer, offset, length) =>
+  buffer.subarray(offset, offset + length).toString("latin1").replace(/\0.*$/s, "").trim();
+
+const hex = (buffer, offset, length, reverse = false) => {
+  const bytes = [...buffer.subarray(offset, offset + length)];
+  if (reverse) bytes.reverse();
+  return bytes.map((byte) => byte.toString(16).padStart(2, "0")).join("").toUpperCase();
+};
+
+// { type, label, uuid } for the volume at `device`, or null when unknown.
+// Identifies what the shipped drivers can mount, plus a few more so the
+// error for an unsupported volume can at least name it.
+const probe = (device) => {
+  let header;
+  try {
+    header = readHeader(device);
+  } catch {
+    return null;
+  }
+  const at = (offset, text) =>
+    header.length >= offset + text.length && header.subarray(offset, offset + text.length).toString("latin1") === text;
+  const u16 = (offset) => header.readUInt16LE(offset);
+  const u32 = (offset) => header.readUInt32LE(offset);
+
+  if (header.length >= 0x800 && u16(0x438) === 0xef53) {
+    // ext2/3/4 share the superblock; a journal means ext3+, extents or
+    // 64-bit or metadata_csum mean ext4. The ext4 driver handles ext3 too.
+    const compat = u32(0x45c), incompat = u32(0x460), roCompat = u32(0x464);
+    const type = incompat & 0x2c0 || roCompat & 0x478 ? "ext4" : compat & 0x4 ? "ext3" : "ext2";
+    const raw = hex(header, 0x468, 16);
+    const uuid = `${raw.slice(0, 8)}-${raw.slice(8, 12)}-${raw.slice(12, 16)}-${raw.slice(16, 20)}-${raw.slice(20)}`.toLowerCase();
+    return { type, label: ascii(header, 0x478, 16), uuid };
+  }
+  if (at(3, "NTFS    ")) return { type: "ntfs3", label: "", uuid: hex(header, 0x48, 8, true) };
+  if (at(3, "EXFAT   ")) return { type: "exfat", label: "", uuid: `${hex(header, 0x66, 2, true)}-${hex(header, 0x64, 2, true)}` };
+  if (header.length >= 512 && u16(510) === 0xaa55 && (at(0x52, "FAT") || at(0x36, "FAT"))) {
+    const fat32 = at(0x52, "FAT32");
+    const serialOffset = fat32 ? 0x43 : 0x27;
+    const labelOffset = fat32 ? 0x47 : 0x2b;
+    let label = ascii(header, labelOffset, 11);
+    if (label === "NO NAME") label = "";
+    return { type: "vfat", label, uuid: `${hex(header, serialOffset + 2, 2, true)}-${hex(header, serialOffset, 2, true)}` };
+  }
+  if (at(0, "XFSB")) return { type: "xfs", label: ascii(header, 0x6c, 12), uuid: "" };
+  if (at(0x10040, "_BHRfS_M")) return { type: "btrfs", label: ascii(header, 0x1012b, 256), uuid: "" };
+  if (at(0, "hsqs")) return { type: "squashfs", label: "", uuid: "" };
+  if (at(0x8001, "CD001")) return { type: "iso9660", label: ascii(header, 0x8028, 32), uuid: "" };
+  if (header.length >= 0x404 && u32(0x400) === 0xf2f52010) return { type: "f2fs", label: "", uuid: "" };
+  if (header.length >= 4096 && at(4096 - 10, "SWAPSPACE2")) return { type: "swap", label: "", uuid: "" };
+  return null;
+};
+
+const blockDevices = () => {
+  try {
+    return readdirSync("/sys/class/block")
+      .filter((name) => !/^(loop|ram|zram|sr)\d/.test(name))
+      .sort()
+      .map((name) => `/dev/${name}`)
+      .filter((path) => existsSync(path));
+  } catch {
+    return [];
+  }
+};
+
+const findVolume = (key, value) => {
+  for (const device of blockDevices()) {
+    const info = probe(device);
+    if (!info) continue;
+    const candidate = key === "LABEL" ? info.label : info.uuid;
+    if (candidate.toUpperCase() === value.toUpperCase()) return device;
+  }
+  return null;
+};
+
+// LABEL=/UUID= sources need udev's /dev/disk/by-*; this scans instead.
+const resolveSource = (source) => {
+  const match = /^(LABEL|UUID)=(.+)$/.exec(source);
+  if (!match) return source;
+  ensureBlockDrivers(null);
+  const device = findVolume(match[1], match[2]);
+  if (!device) fail(`can't find ${source}`);
+  return device;
+};
+
+// ---------------------------------------------------------------- drivers --
+
+const sleep = (milliseconds) => Bun.sleepSync(milliseconds);
+
+// The device name says which driver creates it. Loading is skipped when the
+// node already exists, so this costs nothing after the first mount.
+const ensureBlockDrivers = (device) => {
+  if (device && existsSync(device)) return;
+  const drivers = device === null
+    ? ["virtio_blk", "vmd", "nvme", "ahci", "ata_generic", "pata_acpi", "usb_storage", "uas", "sd_mod"]
+    : /^\/dev\/vd/.test(device) ? ["virtio_blk"]
+    : /^\/dev\/sd/.test(device) ? ["ahci", "ata_generic", "pata_acpi", "usb_storage", "uas", "sd_mod"]
+    : /^\/dev\/nvme/.test(device) ? ["vmd", "nvme"]
+    : [];
+  let loaded = 0;
+  for (const driver of drivers) loaded += tryModprobe(driver)?.length ?? 0;
+  if (device === null) {
+    if (loaded) sleep(500);
+    return;
+  }
+  // devtmpfs creates the node once the driver has probed the disk.
+  for (let waited = 0; !existsSync(device) && waited < 3000; waited += 100) sleep(100);
+};
+
+const kernelFilesystems = () => {
+  try {
+    return new Set(
+      readFileSync("/proc/filesystems", "utf8").split("\n").map((line) => line.split("\t").pop()).filter(Boolean),
+    );
+  } catch {
+    return new Set();
+  }
+};
+
+// The kernel's own request_module() has no /sbin/modprobe to run here, so the
+// filesystem driver and the NLS tables FAT/exFAT/NTFS ask for are loaded
+// before mount(2). Names come from the fs-* aliases (ntfs -> ntfs3, ...).
+// A type with no module is still handed to mount(2): the kernel knows about
+// built-in filesystems that neither /proc/filesystems (unreadable) nor
+// modules.builtin (tmpfs, proc, ...) may list, and answers ENODEV otherwise.
+let driverHint = "";
+const ensureFilesystemDriver = (type, data) => {
+  const registered = kernelFilesystems();
+  const loaded = [];
+  if (!registered.has(type)) {
+    try {
+      loaded.push(...modprobe(`fs-${type}`));
+    } catch (error) {
+      if (!(error instanceof ModuleNotFound)) throw error;
+      driverHint = ` (no ${type} module in ${modulesDirectory()})`;
+    }
+  }
+  if (["vfat", "msdos", "exfat", "ntfs3", "iso9660", "udf"].includes(type)) {
+    const charsets = new Set(["utf8", "cp437", "iso8859-1"]);
+    for (const option of data) {
+      const [key, value] = option.split("=");
+      if (key === "iocharset" || key === "nls") charsets.add(value);
+      if (key === "codepage") charsets.add(`cp${value}`);
+    }
+    for (const charset of charsets) loaded.push(...(tryModprobe(`nls_${charset}`) ?? []));
+  }
+  return loaded;
+};
+
+// ---------------------------------------------------------------- mounting -
+
+const explain = (code, source, target, type) => {
+  switch (code) {
+    case Errno.EPERM: return "must be superuser to use mount";
+    case Errno.ENOENT: return existsSync(target) ? `special device ${source} does not exist` : `mount point ${target} does not exist`;
+    case Errno.ENOTDIR: return `mount point ${target} is not a directory`;
+    case Errno.EBUSY: return `${source} already mounted or ${target} busy`;
+    case Errno.ENODEV: return `unknown filesystem type '${type}'${driverHint}`;
+    case Errno.EROFS: return `${source} is write-protected; try -o ro`;
+    case Errno.EACCES: return `${source} is not readable`;
+    case Errno.ENXIO: return `${source}: no such device or the partition has not been detected`;
+    case Errno.EINVAL: return `wrong fs type, bad option, bad superblock on ${source}, missing codepage or helper program, or other error (dmesg may say more)`;
+    default: return `${strerror(code)}`;
+  }
+};
+
+const doMount = (source, target, type, flags, data, { verbose, fake }) => {
+  if (verbose || fake) {
+    const words = [];
+    for (const [name, bit] of Object.entries(MS)) if (flags & bit) words.push(name.toLowerCase());
+    console.log(`mount(${source}, ${target}, ${type ?? "(none)"}, [${words.join(",")}], "${data}")`);
+  }
+  if (fake) return;
+  const dataBytes = data ? cString(data) : null;
+  const typeBytes = type ? cString(type) : null;
+  const result = libc.symbols.mount(
+    ptr(cString(source)),
+    ptr(cString(target)),
+    typeBytes ? ptr(typeBytes) : null,
+    flags,
+    dataBytes ? ptr(dataBytes) : null,
+  );
+  if (result === 0) return;
+  const code = errno();
+  // The kernel demotes a dirty NTFS or a FAT with errors to read-only rather
+  // than fail; when it does refuse outright, tell the user the escape hatch.
+  const hint = type === "ntfs3" && code === Errno.EINVAL
+    ? " — a Windows volume left dirty by hibernation or Fast Startup needs -o force, or -o ro" : "";
+  fail(explain(code, source, target, type) + hint);
+};
+
+const main = async () => {
+  const state = parseArguments(process.argv.slice(2));
+  if (state.help) return showDocument("mount");
+
+  if (state.source) state.positional.unshift(state.source);
+  if (state.positional.length === 0) return listMounts();
+
+  const pure = state.flags & (MS.BIND | MS.MOVE | MS.REMOUNT | MS.SHARED | MS.PRIVATE | MS.SLAVE | MS.UNBINDABLE);
+  let [source, target] = state.positional;
+  if (state.positional.length === 1) {
+    // `mount -o remount,rw /` and `mount --make-private /` name the target only.
+    if (!(state.flags & MS.REMOUNT) && !(state.flags & (MS.SHARED | MS.PRIVATE | MS.SLAVE | MS.UNBINDABLE))) usage();
+    target = source;
+    source = "none";
+  } else if (state.positional.length > 2) usage();
+
+  if (state.mkdir) mkdirSync(target, { recursive: true });
+
+  let type = state.type;
+  const loaded = [];
+  if (!pure) {
+    source = resolveSource(source);
+    if (source.startsWith("/dev/")) {
+      ensureBlockDrivers(source);
+      if (!existsSync(source)) fail(`special device ${source} does not exist`);
+    }
+    if (!type || type === "auto") {
+      const info = source.startsWith("/dev/") ? probe(source) : null;
+      if (!info) fail(`can't identify the filesystem on ${source}; use -t TYPE`);
+      if (info.type === "swap") fail(`${source} is swap space, not a filesystem`);
+      type = info.type;
+      if (state.verbose) console.log(`${source}: ${info.type}${info.label ? ` label "${info.label}"` : ""}${info.uuid ? ` uuid ${info.uuid}` : ""}`);
+    }
+    if (type === "ntfs") type = "ntfs3";
+    if (type === "ext3") type = "ext4";
+    loaded.push(...ensureFilesystemDriver(type, state.data));
+  }
+  if (state.verbose && loaded.length) console.log(`loaded modules: ${loaded.join(" ")}`);
+
+  doMount(source, target, pure ? null : type, state.flags, state.data.join(","), state);
+  // mount(2) ignores every other flag on a bind, so `--bind -o ro` takes a
+  // second, remount pass the way util-linux does it.
+  if (state.flags & MS.BIND && state.flags & MS.RDONLY && !(state.flags & MS.REMOUNT)) {
+    doMount("none", target, null, MS.REMOUNT | MS.BIND | MS.RDONLY | (state.flags & MS.REC), "", state);
+  }
+  if (state.fake) console.log("(DRY RUN)");
+  else if (state.verbose) console.log(`${source} mounted on ${target}.`);
+};
+
+try {
+  await main();
+} catch (error) {
+  if (error instanceof SysError) fail(error.message);
+  if (error?.code === "ENOENT" || error?.code === "EACCES") fail(`${error.path ?? ""}: ${error.message}`);
+  throw error;
+}

package/initramfs/bin/poweroff

@@ -0,0 +1,10 @@
+#!/bin/bun
+// poweroff — sync filesystems and power off through Linux reboot(2).
+
+import { LINUX_REBOOT_CMD_POWER_OFF, runPowerCommand } from "../lib/power.js";
+
+await runPowerCommand({
+  name: "poweroff",
+  command: { name: "LINUX_REBOOT_CMD_POWER_OFF", value: LINUX_REBOOT_CMD_POWER_OFF },
+  action: "powering off",
+});

package/initramfs/bin/ps

@@ -0,0 +1,256 @@
+#!/bin/bun
+// ps — a /proc process snapshot, formatter, and command-line frontend.
+
+import { readdirSync, readFileSync } from "node:fs";
+import { showDocument } from "../lib/document.js";
+
+export const CLOCK_TICKS = 100;
+
+const read = (path) => readFileSync(path, "utf8");
+const numberFrom = (text, pattern) => Number(pattern.exec(text)?.[1] ?? 0);
+
+const ttyName = (number) => {
+  if (!number) return "?";
+  const device = number >>> 0;
+  const major = (device >>> 8) & 0xfff;
+  const minor = (device & 0xff) | ((device >>> 12) & 0xfff00);
+  if (major >= 136 && major <= 143) return `pts/${minor}`;
+  if (major === 4 && minor < 64) return `tty${minor}`;
+  if (major === 5 && minor === 0) return "tty";
+  return `${major}:${minor}`;
+};
+
+const cpuTime = (seconds) => {
+  const whole = Math.max(0, Math.floor(seconds));
+  const hours = Math.floor(whole / 3600);
+  const minutes = Math.floor(whole % 3600 / 60);
+  const secs = whole % 60;
+  return hours
+    ? `${hours}:${String(minutes).padStart(2, "0")}:${String(secs).padStart(2, "0")}`
+    : `${String(minutes).padStart(2, "0")}:${String(secs).padStart(2, "0")}`;
+};
+
+const elapsedTime = (seconds) => {
+  const whole = Math.max(0, Math.floor(seconds));
+  const days = Math.floor(whole / 86400);
+  const clock = [Math.floor(whole % 86400 / 3600), Math.floor(whole % 3600 / 60), whole % 60]
+    .map((part) => String(part).padStart(2, "0")).join(":");
+  return days ? `${days}-${clock}` : clock;
+};
+
+const startText = (started, short = false) => {
+  const date = new Date(started);
+  const now = new Date();
+  if (date.toDateString() === now.toDateString())
+    return `${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}`;
+  if (short || date.getFullYear() === now.getFullYear())
+    return date.toLocaleString("en-US", { month: "short", day: "2-digit" }).replace(" ", "");
+  return String(date.getFullYear());
+};
+
+const readUsers = () => {
+  const users = new Map();
+  try {
+    for (const line of read("/etc/passwd").split("\n")) {
+      const fields = line.split(":");
+      if (/^\d+$/.test(fields[2] ?? "") && !users.has(Number(fields[2])))
+        users.set(Number(fields[2]), fields[0]);
+    }
+  } catch {}
+  return users;
+};
+
+const readMemory = () => {
+  const result = {};
+  try {
+    for (const match of read("/proc/meminfo").matchAll(/^(\w+):\s+(\d+)/gm))
+      result[match[1]] = Number(match[2]);
+  } catch {}
+  return result;
+};
+
+const readCpu = () => {
+  try {
+    const values = read("/proc/stat").match(/^cpu\s+(.+)$/m)?.[1].trim().split(/\s+/).map(Number) ?? [];
+    const total = values.reduce((sum, value) => sum + value, 0);
+    return { total, idle: (values[3] ?? 0) + (values[4] ?? 0), count: Math.max(1, read("/proc/stat").match(/^cpu\d+\s/gm)?.length ?? 1) };
+  } catch { return { total: 0, idle: 0, count: 1 }; }
+};
+
+export function readProcessSnapshot() {
+  const users = readUsers();
+  const memory = readMemory();
+  let uptime = 0;
+  let bootSeconds = 0;
+  let loadAverage = [0, 0, 0];
+  try { uptime = Number(read("/proc/uptime").split(/\s+/)[0]); } catch {}
+  try { bootSeconds = numberFrom(read("/proc/stat"), /^btime\s+(\d+)/m); } catch {}
+  try { loadAverage = read("/proc/loadavg").trim().split(/\s+/).slice(0, 3).map(Number); } catch {}
+  const bootTime = bootSeconds ? bootSeconds * 1000 : Date.now() - uptime * 1000;
+  let pids = [];
+  try {
+    pids = readdirSync("/proc", { withFileTypes: true })
+      .filter((entry) => entry.isDirectory() && /^\d+$/.test(entry.name))
+      .map((entry) => Number(entry.name)).sort((a, b) => a - b);
+  } catch (error) { throw new Error(`cannot read /proc: ${error.message}`); }
+
+  const processes = [];
+  for (const pid of pids) {
+    try {
+      let args = readFileSync(`/proc/${pid}/cmdline`).toString("utf8").replace(/\0/g, " ").replace(/[\r\n]+/g, " ").trimEnd();
+      if (!args) args = `[${read(`/proc/${pid}/comm`).trim().replace(/[\r\n]+/g, " ")}]`;
+      const status = read(`/proc/${pid}/status`);
+      const stat = read(`/proc/${pid}/stat`);
+      const close = stat.lastIndexOf(")");
+      if (close < 0) continue;
+      const open = stat.indexOf("(");
+      const fields = stat.slice(close + 2).trim().split(/\s+/);
+      const command = stat.slice(open + 1, close);
+      const uid = numberFrom(status, /^Uid:\s+(\d+)/m);
+      const vmSize = numberFrom(status, /^VmSize:\s+(\d+)/m);
+      const rss = numberFrom(status, /^VmRSS:\s+(\d+)/m);
+      const ppid = Number(fields[1]);
+      const session = Number(fields[3]);
+      const ttyNumber = Number(fields[4]);
+      // /proc/PID/stat field 9 is flags. `fields` starts at field 3, so
+      // index 6 contains PF_KTHREAD and does not rely on guessing from argv.
+      const kernelThread = (Number(fields[6]) & 0x00200000) !== 0;
+      const ticks = Number(fields[11]) + Number(fields[12]);
+      const nice = Number(fields[16]);
+      const threads = Number(fields[17]);
+      const started = bootTime + Number(fields[19]) / CLOCK_TICKS * 1000;
+      const elapsed = Math.max(0.01, (Date.now() - started) / 1000);
+      let state = fields[0];
+      if (nice < 0) state += "<"; else if (nice > 0) state += "N";
+      if (session === pid) state += "s";
+      if (threads > 1) state += "l";
+      if (Number(fields[5]) > 0 && Number(fields[5]) === Number(fields[2])) state += "+";
+      processes.push({
+        pid, ppid, uid, user: users.get(uid) ?? String(uid), args, command,
+        tty: ttyName(ttyNumber), ttyNumber, session, state, kernelThread,
+        processor: Number(fields[36] ?? 0), priority: Number(fields[15]), nice, threads, ticks,
+        cpu: ticks / CLOCK_TICKS / elapsed * 100,
+        memory: memory.MemTotal ? rss / memory.MemTotal * 100 : 0,
+        vmSize, rss, size: Math.ceil(Number(fields[20]) / 4096),
+        time: cpuTime(ticks / CLOCK_TICKS), elapsed, started,
+      });
+    } catch {}
+  }
+  return { processes, memory, cpu: readCpu(), uptime, loadAverage, at: Date.now() };
+}
+
+export const processFieldDefinitions = {
+  pid: { header: "PID", numeric: true, minimum: 5, value: (r) => r.pid },
+  ppid: { header: "PPID", numeric: true, minimum: 5, value: (r) => r.ppid },
+  uid: { header: "UID", numeric: true, minimum: 5, value: (r) => r.uid },
+  user: { header: "USER", value: (r) => r.user }, euser: { header: "EUSER", value: (r) => r.user },
+  comm: { header: "COMMAND", value: (r) => r.command }, args: { header: "COMMAND", value: (r) => r.args },
+  cmd: { header: "CMD", value: (r) => r.args }, command: { header: "COMMAND", value: (r) => r.args },
+  tty: { header: "TT", value: (r) => r.tty }, tt: { header: "TT", value: (r) => r.tty },
+  stat: { header: "STAT", value: (r) => r.state }, state: { header: "S", value: (r) => r.state[0] },
+  c: { header: "C", numeric: true, value: (r) => Math.floor(r.cpu) },
+  "%cpu": { header: "%CPU", numeric: true, value: (r) => r.cpu.toFixed(1) }, pcpu: { header: "%CPU", numeric: true, value: (r) => r.cpu.toFixed(1) },
+  "%mem": { header: "%MEM", numeric: true, value: (r) => r.memory.toFixed(1) }, pmem: { header: "%MEM", numeric: true, value: (r) => r.memory.toFixed(1) },
+  vsz: { header: "VSZ", numeric: true, value: (r) => r.vmSize }, rss: { header: "RSS", numeric: true, value: (r) => r.rss },
+  sz: { header: "SZ", numeric: true, value: (r) => r.size }, time: { header: "TIME", numeric: true, value: (r) => r.time },
+  etime: { header: "ELAPSED", numeric: true, value: (r) => elapsedTime(r.elapsed) }, etimes: { header: "ELAPSED", numeric: true, value: (r) => Math.floor(r.elapsed) },
+  start: { header: "STARTED", value: (r) => startText(r.started) }, stime: { header: "STIME", value: (r) => startText(r.started, true) },
+  lstart: { header: "STARTED", value: (r) => new Date(r.started).toString().slice(0, 24) },
+  ni: { header: "NI", numeric: true, value: (r) => r.nice }, nice: { header: "NI", numeric: true, value: (r) => r.nice },
+  pri: { header: "PRI", numeric: true, value: (r) => r.priority }, psr: { header: "PSR", numeric: true, value: (r) => r.processor },
+};
+
+export function prepareProcessFormat(rows, fields) {
+  const names = Array.isArray(fields) ? fields : fields.toLowerCase().split(/[\s,]+/).filter(Boolean);
+  if (!names.length) throw new Error("empty -o format");
+  return names.map((name) => {
+    const definition = processFieldDefinitions[name];
+    if (!definition) throw new Error(`unsupported output field '${name}'`);
+    const width = Math.max(definition.minimum ?? 0, definition.header.length,
+      ...rows.map((row) => String(definition.value(row)).length));
+    return { name, ...definition, width };
+  });
+}
+
+export const formatProcessHeader = (format) => format.map((f) =>
+  f.numeric ? f.header.padStart(f.width) : f.header.padEnd(f.width)).join(" ").trimEnd();
+
+export const formatProcessLine = (row, format) => format.map((f, index) => {
+  const value = String(f.value(row));
+  if (index === format.length - 1 && !f.numeric) return value;
+  return f.numeric ? value.padStart(f.width) : value.padEnd(f.width);
+}).join(" ").trimEnd();
+
+export function formatProcessTable(rows, fields) {
+  const format = prepareProcessFormat(rows, fields);
+  return [formatProcessHeader(format), ...rows.map((row) => formatProcessLine(row, format))];
+}
+
+const formatPresetTable = (rows, fields, headers = {}) => {
+  const format = prepareProcessFormat(rows, fields).map((field) => {
+    const header = headers[field.name] ?? field.header;
+    return { ...field, header, width: Math.max(field.width, header.length) };
+  });
+  return [formatProcessHeader(format), ...rows.map((row) => formatProcessLine(row, format))];
+};
+
+export function selectProcesses(rows, { all = false, selection = "default" } = {}) {
+  if (all) return rows;
+  const own = rows.find((row) => row.pid === process.pid);
+  const ownUid = own?.uid ?? process.geteuid?.() ?? process.getuid?.() ?? 0;
+  const ownTty = own?.ttyNumber ?? 0;
+  return rows.filter((row) => {
+    // A boot-console shell and kernel threads can all be UID 0 and have no
+    // controlling TTY. Plain ps must not accidentally behave like ps -e.
+    if (row.kernelThread) return false;
+    if (selection === "unix-a") return row.ttyNumber !== 0 && row.session !== row.pid;
+    if (selection === "any-with-tty") return row.ttyNumber !== 0;
+    if (selection === "own-any-tty") return row.uid === ownUid;
+    return row.uid === ownUid && row.ttyNumber === ownTty && row.session !== row.pid;
+  });
+}
+
+const usage = () => { throw new Error("Usage: ps | ps -e|-A [-o fields] | ps -ef | ps aux | ps ax\nTry 'ps --help' for the full manual."); };
+
+async function main(argv) {
+  let fields = null, view = "default", all = false, selection = "default";
+  for (let index = 0; index < argv.length; index++) {
+    const argument = argv[index];
+    if (argument === "-h" || argument === "--help") return showDocument("ps");
+    if (["-e", "-A", "--all"].includes(argument)) { all = true; continue; }
+    if (["-f", "-ef", "-Af"].includes(argument)) { view = "full"; if (argument !== "-f") all = true; continue; }
+    if (["-F", "-eF", "-AF"].includes(argument)) { view = "extra-full"; if (argument !== "-F") all = true; continue; }
+    if (["aux", "-aux"].includes(argument)) { view = "aux"; all = true; continue; }
+    if (["ax", "-ax"].includes(argument)) { view = "bsd"; all = true; continue; }
+    if (argument === "a") { view = "bsd"; selection = "any-with-tty"; continue; }
+    if (argument === "x") { view = "bsd"; selection = "own-any-tty"; continue; }
+    if (argument === "-a") { selection = "unix-a"; continue; }
+    if (argument === "-x") { selection = "own-any-tty"; continue; }
+    if (argument === "-o" || argument === "--format") { fields = argv[++index] ?? usage(); view = "basic"; continue; }
+    if (argument.startsWith("--format=")) { fields = argument.slice(9); view = "basic"; continue; }
+    const combined = /^-([eA]*)o(.*)$/.exec(argument);
+    if (combined) { fields = combined[2] || argv[++index] || usage(); view = "basic"; if (combined[1]) all = true; continue; }
+    usage();
+  }
+  const rows = selectProcesses(readProcessSnapshot().processes, { all, selection });
+  const presets = {
+    full: ["user", "pid", "ppid", "c", "stime", "tty", "time", "args"],
+    "extra-full": ["user", "pid", "ppid", "c", "sz", "rss", "psr", "stime", "tty", "time", "args"],
+    aux: ["user", "pid", "%cpu", "%mem", "vsz", "rss", "tty", "stat", "start", "time", "args"],
+    bsd: ["pid", "tty", "stat", "time", "args"], default: ["pid", "tty", "time", "comm"],
+  };
+  try {
+    const headers = view === "default" ? { tty: "TTY", comm: "CMD" }
+      : view === "full" || view === "extra-full" ? { user: "UID", tty: "TTY", args: "CMD" }
+      : view === "aux" ? { tty: "TTY", start: "START" }
+      : view === "bsd" ? { tty: "TTY" } : {};
+    for (const line of fields
+      ? formatProcessTable(rows, fields)
+      : formatPresetTable(rows, presets[view], headers)) console.log(line);
+  } catch (error) { throw new Error(`ps: ${error.message}`); }
+}
+
+if (import.meta.main) {
+  try { await main(process.argv.slice(2)); }
+  catch (error) { console.error(error.message); process.exit(1); }
+}