buninu-linux 0.3.0 → 0.4.0

package/initramfs/bin/bunterm

@@ -0,0 +1,66 @@
+#!/bin/bun
+// bunterm — a graphical terminal emulator on the Linux framebuffer.
+
+import { showDocument } from "../lib/document.js";
+import { runTerminal } from "../lib/bunterm/terminal.js";
+
+const usage = () => {
+  console.error(`Usage:
+  bunterm [/dev/ttyN] [--font-size N] [--fb /dev/fb0] [-e command [argument...]]
+  bunterm -h | --help`);
+};
+
+const main = async () => {
+  const options = { argv: [] };
+  const arguments_ = process.argv.slice(2);
+  for (let index = 0; index < arguments_.length; index++) {
+    const argument = arguments_[index];
+    if (argument === "-h" || argument === "--help") {
+      await showDocument("bunterm");
+      return 0;
+    }
+    if (argument === "-e") {
+      if (index + 1 >= arguments_.length) {
+        usage();
+        throw new Error("-e needs a command");
+      }
+      options.command = arguments_[index + 1];
+      options.argv = arguments_.slice(index + 2);
+      break;
+    }
+    const valued = (name) => {
+      const value = argument.startsWith(`${name}=`) ? argument.slice(name.length + 1) : arguments_[++index];
+      if (value === undefined) {
+        usage();
+        throw new Error(`${name} needs a value`);
+      }
+      return value;
+    };
+    if (argument === "--font-size" || argument.startsWith("--font-size=")) {
+      options.fontSize = Number(valued("--font-size"));
+      if (!Number.isFinite(options.fontSize) || options.fontSize < 6) throw new Error("--font-size must be a number of at least 6");
+    } else if (argument === "--line-height" || argument.startsWith("--line-height=")) {
+      options.lineHeight = Number(valued("--line-height"));
+      if (!Number.isFinite(options.lineHeight) || options.lineHeight <= 0) throw new Error("--line-height must be a positive number");
+    } else if (argument === "--fb" || argument.startsWith("--fb=")) {
+      options.device = valued("--fb");
+    } else if (argument === "--no-blink") {
+      options.cursorBlink = false;
+    } else if (argument.startsWith("/dev/")) {
+      options.console = argument;
+    } else {
+      usage();
+      throw new Error(`unexpected argument: ${argument}`);
+    }
+  }
+  return runTerminal(options);
+};
+
+let status = 1;
+try {
+  status = await main();
+} catch (error) {
+  console.error(`bunterm: ${error?.message ?? error}`);
+}
+// A pending console read would otherwise keep the process alive.
+process.exit(status);

package/initramfs/bin/ip

@@ -9,7 +9,8 @@
 // shown but not configured.
 
 import { readdirSync, readFileSync } from "node:fs";
-import { cString, ptr, withInetSocket, Errno, SysError, showDocument } from "../lib/dlopen.js";
+import { cString, ptr, withInetSocket, Errno, SysError } from "../lib/dlopen.js";
+import { showDocument } from "../lib/document.js";
 
 const fail = (message, status = 1) => {
   console.error(`ip: ${message}`);

package/initramfs/bin/mount

@@ -10,7 +10,8 @@
 // is not there yet.
 
 import { existsSync, mkdirSync, openSync, readSync, closeSync, readdirSync, readFileSync } from "node:fs";
-import { libc, cString, ptr, errno, strerror, Errno, SysError, showDocument } from "../lib/dlopen.js";
+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) => {

package/initramfs/bin/poweroff

@@ -1,31 +1,10 @@
 #!/bin/bun
 // poweroff — sync filesystems and power off through Linux reboot(2).
 
-import { libc, check, showDocument } from "../lib/dlopen.js";
+import { LINUX_REBOOT_CMD_POWER_OFF, runPowerCommand } from "../lib/power.js";
 
-const LINUX_REBOOT_CMD_POWER_OFF = 0x4321fedc;
-const arguments_ = process.argv.slice(2);
-
-if (arguments_.length === 1 && (arguments_[0] === "-h" || arguments_[0] === "--help")) {
-  await showDocument("poweroff");
-  process.exit(0);
-}
-
-if (arguments_.length !== 0) {
-  console.error("Usage: poweroff [-h | --help]");
-  process.exit(1);
-}
-
-console.log("poweroff: syncing filesystems");
-libc.symbols.sync();
-console.log("poweroff: powering off");
-try {
-  check("reboot(LINUX_REBOOT_CMD_POWER_OFF)", libc.symbols.reboot(LINUX_REBOOT_CMD_POWER_OFF));
-} catch (error) {
-  console.error(`poweroff: ${error.message}`);
-  process.exit(1);
-}
-
-// A successful reboot(2) never returns.
-console.error("poweroff: reboot returned without powering off");
-process.exit(1);
+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); }
+}

package/initramfs/bin/reboot

@@ -0,0 +1,10 @@
+#!/bin/bun
+// reboot — thin wrapper over the shared sync-and-reboot implementation.
+
+import { LINUX_REBOOT_CMD_RESTART, runPowerCommand } from "../lib/power.js";
+
+await runPowerCommand({
+  name: "reboot",
+  command: { name: "LINUX_REBOOT_CMD_RESTART", value: LINUX_REBOOT_CMD_RESTART },
+  action: "restarting",
+});

package/initramfs/bin/tar

@@ -0,0 +1,169 @@
+#!/bin/bun
+// tar — a small tar/gzip/zstd CLI over Bun.Archive.
+
+import { lstat, readdir } from "node:fs/promises";
+import { basename, join, resolve } from "node:path";
+import { showDocument } from "../lib/document.js";
+
+const fail = (message) => {
+  console.error(`tar: ${message}`);
+  process.exit(2);
+};
+
+const usage = () => {
+  console.error(`Usage:
+  tar -cf ARCHIVE FILE...
+  tar -xf ARCHIVE [-C DIR] [MEMBER...]
+  tar -tf ARCHIVE [MEMBER...]
+  tar -h | --help
+
+Try 'tar --help' for the full manual.`);
+  process.exit(2);
+};
+
+const options = { operation: null, archive: null, directory: ".", compression: null, verbose: false, operands: [] };
+const argv = process.argv.slice(2);
+if (argv.length === 0) usage();
+const take = (index, option) => {
+  if (index + 1 >= argv.length) fail(`${option} requires an argument`);
+  return argv[index + 1];
+};
+
+for (let index = 0; index < argv.length; index++) {
+  const argument = argv[index];
+  const oldStyleOptions = index === 0 && /^[cxtrvfz]+$/.test(argument)
+    && /[cxtr]/.test(argument);
+  if (argument === "--") { options.operands.push(...argv.slice(index + 1)); break; }
+  if (argument === "-h" || argument === "--help") {
+    await showDocument("tar");
+    process.exit(0);
+  }
+  if (argument === "--zstd") { options.compression = "zstd"; continue; }
+  if (argument === "--gzip") { options.compression = "gzip"; continue; }
+  if (argument === "-C" || argument === "--directory") {
+    options.directory = take(index++, argument);
+    continue;
+  }
+  if (argument.startsWith("--directory=")) {
+    options.directory = argument.slice(12);
+    continue;
+  }
+  if (argument === "-f" || argument === "--file") {
+    options.archive = take(index++, argument);
+    continue;
+  }
+  if (argument.startsWith("--file=")) {
+    options.archive = argument.slice(7);
+    continue;
+  }
+  if ((argument.startsWith("-") && argument !== "-") || oldStyleOptions) {
+    const flags = oldStyleOptions ? argument : argument.slice(1);
+    for (let offset = 0; offset < flags.length; offset++) {
+      const flag = flags[offset];
+      if ("cxt".includes(flag)) {
+        if (options.operation && options.operation !== flag) fail("only one of -c, -x, or -t may be used");
+        options.operation = flag;
+      } else if (flag === "r") {
+        fail("-r append is not supported by Bun.Archive");
+      } else if (flag === "v") options.verbose = true;
+      else if (flag === "z") options.compression = "gzip";
+      else if (flag === "f") {
+        const attached = flags.slice(offset + 1);
+        options.archive = attached || take(index++, "-f");
+        break;
+      } else fail(`unknown option -- ${flag}`);
+    }
+    continue;
+  }
+  options.operands.push(argument);
+}
+
+if (!options.operation) fail("one of -c, -x, or -t is required");
+if (!options.archive) fail("an archive must be specified with -f");
+
+const archiveBytes = async () => {
+  const bytes = options.archive === "-"
+    ? await Bun.stdin.bytes()
+    : await Bun.file(options.archive).bytes();
+  const zstd = options.compression === "zstd" || /\.(?:zst|tzst)$/i.test(options.archive);
+  return zstd ? Bun.zstdDecompressSync(bytes) : bytes;
+};
+
+const patterns = () => options.operands.flatMap((name) => {
+  const clean = name.replace(/^\.\//, "").replace(/\/$/, "");
+  return [clean, `${clean}/**`];
+});
+
+const verboseListing = (name, file) => {
+  const modified = Number.isFinite(file.lastModified) && file.lastModified > 0
+    ? new Date(file.lastModified).toISOString().replace("T", " ").slice(0, 16)
+    : "---- -- -- --:--";
+  return `${String(file.size).padStart(12)} ${modified} ${name}`;
+};
+
+if (options.operation === "x" || options.operation === "t") {
+  let archive;
+  try {
+    archive = new Bun.Archive(await archiveBytes());
+  } catch (error) {
+    fail(error?.message || String(error));
+  }
+
+  if (options.operation === "t") {
+    try {
+      const files = await archive.files(options.operands.length ? patterns() : undefined);
+      for (const [name, file] of files) {
+        console.log(options.verbose ? verboseListing(name, file) : name);
+      }
+    } catch (error) {
+      fail(error?.message || String(error));
+    }
+  } else {
+    try {
+      if (options.verbose) {
+        const files = await archive.files(options.operands.length ? patterns() : undefined);
+        for (const name of files.keys()) console.log(name);
+      }
+      await archive.extract(options.directory, options.operands.length ? { glob: patterns() } : undefined);
+    } catch (error) {
+      fail(error?.message || String(error));
+    }
+  }
+  process.exit(0);
+}
+
+if (options.operands.length === 0) fail("refusing to create an empty archive");
+const root = resolve(options.directory);
+const inputs = {};
+
+const add = async (diskPath, archivePath) => {
+  const info = await lstat(diskPath);
+  if (info.isSymbolicLink()) fail(`${archivePath}: creating symbolic links is not supported by Bun.Archive`);
+  if (info.isDirectory()) {
+    for (const entry of await readdir(diskPath)) await add(join(diskPath, entry), `${archivePath}/${entry}`);
+    return;
+  }
+  if (!info.isFile()) fail(`${archivePath}: unsupported file type`);
+  const name = archivePath.replaceAll("\\", "/").replace(/^\.\//, "").replace(/^\/+/, "");
+  if (!name || name === ".." || name.startsWith("../") || name.includes("/../")) fail(`${archivePath}: unsafe archive path`);
+  // Bun 1.4.3 accepts Blob in ArchiveInput, but a lazy BunFile is currently
+  // archived as zero bytes. Materialise it until Bun.Archive handles BunFile
+  // contents directly.
+  inputs[name] = await Bun.file(diskPath).bytes();
+  if (options.verbose) console.error(name);
+};
+
+try {
+  for (const operand of options.operands) {
+    const diskPath = resolve(root, operand);
+    const name = operand.startsWith("/") ? basename(operand) : operand.replace(/\/$/, "");
+    await add(diskPath, name);
+  }
+  const archive = new Bun.Archive(inputs, options.compression === "gzip" ? { compress: "gzip" } : undefined);
+  const output = options.compression === "zstd"
+    ? Bun.zstdCompressSync(await archive.bytes())
+    : archive;
+  await Bun.write(options.archive === "-" ? Bun.stdout : options.archive, output);
+} catch (error) {
+  fail(error?.message || String(error));
+}