buninu-linux 0.2.0

package/fetch-alpine.sh

@@ -0,0 +1,80 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+cd "$(dirname "$0")"
+
+base=https://dl-cdn.alpinelinux.org/alpine/v3.24/main/x86_64
+linux_flavor=${LINUX_FLAVOR:-virt}
+linux_package="linux-$linux_flavor-6.18.52-r0.apk"
+musl_package=musl-1.2.6-r2.apk
+stub_package=systemd-efistub-260.2-r0.apk
+if [ "$linux_flavor" = lts ]; then
+    linux_sha256=bd81f00522a7c7deb96886811a087c453d48530c0c8f742412ad73e24236037c
+else
+    linux_sha256=dff0c365a6d6c0fd015175af08dca0c39048fa39df6ef3150a7ea88d2cfdfa4f
+fi
+
+musl_sha256=573712e2f49c15bfc20a2699f204acdfc74c772722b15e7353d768057fae0e71
+stub_sha256=8e64a5a3afee5f930e6e6716be726dc6d405530ac7f8fa5be6251dae68671ec9
+
+kernel_release="6.18.52-0-$linux_flavor"
+
+mkdir -p downloads kernel initramfs/lib \
+    "initramfs/lib/modules/$kernel_release/kernel/net/core" \
+    "initramfs/lib/modules/$kernel_release/kernel/drivers/net" \
+    "initramfs/lib/modules/$kernel_release/kernel/drivers/virtio"
+
+. ./scripts/fetch.sh
+
+fetch "$base/$linux_package" "$linux_package" "$linux_sha256"
+fetch "$base/$musl_package" "$musl_package" "$musl_sha256"
+fetch "$base/$stub_package" "$stub_package" "$stub_sha256"
+
+tar --warning=no-unknown-keyword -xOf "downloads/$linux_package" \
+    "boot/vmlinuz-$linux_flavor" > "kernel/vmlinuz-$linux_flavor"
+tar --warning=no-unknown-keyword -xOf "downloads/$musl_package" \
+    lib/ld-musl-x86_64.so.1 > initramfs/lib/ld-musl-x86_64.so.1
+tar --warning=no-unknown-keyword -xOf "downloads/$stub_package" \
+    usr/lib/systemd/boot/efi/linuxx64.efi.stub > kernel/linuxx64.efi.stub
+tar --warning=no-unknown-keyword -xOf "downloads/$linux_package" \
+    "lib/modules/$kernel_release/kernel/net/core/failover.ko.gz" \
+    | gzip -dc > "initramfs/lib/modules/$kernel_release/kernel/net/core/failover.ko"
+tar --warning=no-unknown-keyword -xOf "downloads/$linux_package" \
+    "lib/modules/$kernel_release/kernel/drivers/net/net_failover.ko.gz" \
+    | gzip -dc > "initramfs/lib/modules/$kernel_release/kernel/drivers/net/net_failover.ko"
+tar --warning=no-unknown-keyword -xOf "downloads/$linux_package" \
+    "lib/modules/$kernel_release/kernel/drivers/net/virtio_net.ko.gz" \
+    | gzip -dc > "initramfs/lib/modules/$kernel_release/kernel/drivers/net/virtio_net.ko"
+
+if [ "$linux_flavor" = lts ]; then
+    for module in virtio_ring virtio virtio_pci_legacy_dev virtio_pci_modern_dev virtio_pci; do
+        tar --warning=no-unknown-keyword -xOf "downloads/$linux_package" \
+            "lib/modules/$kernel_release/kernel/drivers/virtio/$module.ko.gz" \
+            | gzip -dc > "initramfs/lib/modules/$kernel_release/kernel/drivers/virtio/$module.ko"
+    done
+fi
+
+if [ "${REAL_MACHINE:-}" = 1 ]; then
+    mkdir -p \
+        "initramfs/lib/modules/$kernel_release/kernel/drivers/usb/common" \
+        "initramfs/lib/modules/$kernel_release/kernel/drivers/usb/core" \
+        "initramfs/lib/modules/$kernel_release/kernel/drivers/usb/host" \
+        "initramfs/lib/modules/$kernel_release/kernel/drivers/hid/usbhid"
+    for module in \
+        drivers/usb/common/usb-common \
+        drivers/usb/core/usbcore \
+        drivers/usb/host/xhci-hcd \
+        drivers/usb/host/xhci-pci \
+        drivers/usb/host/xhci-pci-renesas \
+        drivers/hid/hid \
+        drivers/hid/hid-generic \
+        drivers/hid/usbhid/usbhid; do
+        tar --warning=no-unknown-keyword -xOf "downloads/$linux_package" \
+            "lib/modules/$kernel_release/kernel/$module.ko.gz" \
+            | gzip -dc > "initramfs/lib/modules/$kernel_release/kernel/$module.ko"
+    done
+fi
+
+chmod 0755 initramfs/lib/ld-musl-x86_64.so.1
+
+echo "Fetched Alpine linux-$linux_flavor kernel, virtio-net modules, musl, and the x64 UKI stub."

package/fetch-bun.sh

@@ -0,0 +1,41 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+cd "$(dirname "$0")"
+
+bun_version=1.4.2
+alpine_base=https://dl-cdn.alpinelinux.org/alpine/v3.24/main/x86_64
+bun_url="https://github.com/oven-sh/bun/releases/download/bun-v${bun_version}/bun-linux-x64-musl-baseline.zip"
+bun_zip="bun-linux-x64-musl-baseline-${bun_version}.zip"
+libstdcpp_package=libstdc++-15.2.0-r5.apk
+libgcc_package=libgcc-15.2.0-r5.apk
+bun_sha256=76e1db84e98f22f78de0a87e309bfbbf297732847f9720db36750646c85c8c18
+libstdcpp_sha256=14c987b556f5385a5db18376e788c75f37d85321b8dc1920d926ea7daac1d6f6
+libgcc_sha256=393dcd32629f06d7d85409c272d142d0c082772d10b87ef55ee82f47de3be637
+
+mkdir -p downloads initramfs/bin initramfs/lib initramfs/dev initramfs/proc initramfs/sys initramfs/tmp
+
+. ./scripts/fetch.sh
+
+fetch "$bun_url" "$bun_zip" "$bun_sha256"
+fetch "$alpine_base/$libstdcpp_package" "$libstdcpp_package" "$libstdcpp_sha256"
+fetch "$alpine_base/$libgcc_package" "$libgcc_package" "$libgcc_sha256"
+
+test -s initramfs/lib/ld-musl-x86_64.so.1 || {
+  echo "error: fetch stage incomplete: run ./fetch-alpine.sh first (./index.js -f runs both)" >&2
+  exit 1
+}
+
+unzip -p "downloads/$bun_zip" \
+  'bun-linux-x64-musl-baseline/bun' > initramfs/bin/bun
+tar --warning=no-unknown-keyword -xOf "downloads/$libstdcpp_package" \
+  usr/lib/libstdc++.so.6.0.34 > initramfs/lib/libstdc++.so.6
+tar --warning=no-unknown-keyword -xOf "downloads/$libgcc_package" \
+  usr/lib/libgcc_s.so.1 > initramfs/lib/libgcc_s.so.1
+
+# Keep libc as a distinct inode from the active dynamic loader. Calling dlopen
+# on the loader inode itself deadlocks, while this physical copy is FFI-safe.
+cp initramfs/lib/ld-musl-x86_64.so.1 initramfs/lib/libc.musl-x86_64.so.1
+chmod 0755 initramfs/init.js initramfs/bin/bun initramfs/lib/*.so*
+
+echo "Fetched Bun $bun_version and its x86_64 musl runtime into initramfs/."

package/fetch-plus-build.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+cd "$(dirname "$0")"
+
+./fetch-alpine.sh
+./fetch-bun.sh
+./build-uki.sh
+./build-image.sh
+
+echo "Buninu Linux image is ready: vda.img. Run stage: ./index.js -r (run-qemu.sh) in native Termux."

package/hello/build-hello.sh

@@ -0,0 +1,14 @@
+#!/data/data/com.termux/files/usr/bin/bash
+set -euo pipefail
+
+cd "$(dirname "$0")/.."
+mkdir -p vda/EFI/BOOT
+
+clang --target=x86_64-pc-win32-coff \
+    -ffreestanding -fshort-wchar -mno-red-zone -Wall -Wextra -Werror \
+    -c hello/hello.c -o hello/hello.obj
+
+lld-link /subsystem:efi_application /entry:efi_main /nodefaultlib \
+    /machine:x64 /out:vda/EFI/BOOT/BOOTX64.EFI hello/hello.obj
+
+echo "Built hello EFI at vda/EFI/BOOT/BOOTX64.EFI"

package/hello/hello.c

@@ -0,0 +1,50 @@
+typedef unsigned long long UINTN;
+typedef unsigned short CHAR16;
+typedef void *EFI_HANDLE;
+typedef void *EFI_EVENT;
+typedef UINTN EFI_STATUS;
+
+#define EFIAPI __attribute__((ms_abi))
+
+typedef struct EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL;
+typedef struct EFI_SIMPLE_TEXT_INPUT_PROTOCOL EFI_SIMPLE_TEXT_INPUT_PROTOCOL;
+typedef EFI_STATUS(EFIAPI *EFI_TEXT_STRING)(EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *, CHAR16 *);
+
+typedef struct {
+    unsigned short ScanCode;
+    CHAR16 UnicodeChar;
+} EFI_INPUT_KEY;
+
+typedef EFI_STATUS(EFIAPI *EFI_INPUT_READ_KEY)(EFI_SIMPLE_TEXT_INPUT_PROTOCOL *,
+                                               EFI_INPUT_KEY *);
+
+struct EFI_SIMPLE_TEXT_INPUT_PROTOCOL {
+    void *Reset;
+    EFI_INPUT_READ_KEY ReadKeyStroke;
+    EFI_EVENT WaitForKey;
+};
+
+struct EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL {
+    void *Reset;
+    EFI_TEXT_STRING OutputString;
+};
+
+typedef struct {
+    char _pad[48];
+    EFI_SIMPLE_TEXT_INPUT_PROTOCOL *ConIn;
+    EFI_HANDLE ConsoleOutHandle;
+    EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *ConOut;
+} EFI_SYSTEM_TABLE;
+
+EFI_STATUS EFIAPI efi_main(EFI_HANDLE image, EFI_SYSTEM_TABLE *system_table) {
+    (void)image;
+    system_table->ConOut->OutputString(system_table->ConOut,
+        L"\r\nHello world from x64 UEFI!\r\n"
+        L"Press any key to exit to UEFI firmware...\r\n");
+
+    EFI_INPUT_KEY key;
+    while (system_table->ConIn->ReadKeyStroke(system_table->ConIn, &key) != 0)
+        __asm__ volatile("pause");
+
+    return 0;
+}

package/index.js

@@ -0,0 +1,235 @@
+#!/usr/bin/env bun
+
+// Single entry point over the build scripts. The scripts stay the source of
+// truth and run fine on their own; this adds one command, a usage screen,
+// stage flags that combine, and a check that the tools each stage needs are
+// present before anything starts. Written against node: APIs only, so it runs
+// under node as well as bun.
+
+import pkg from "./package.json" with { type: "json" };
+import { spawnSync } from "node:child_process";
+import { accessSync, constants, copyFileSync, readFileSync } from "node:fs";
+import { delimiter, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const rootDir = dirname(fileURLToPath(import.meta.url));
+const invocationDir = process.cwd();
+
+// Pipeline order. Flags select stages; this array fixes the order they run in.
+const stages = [
+  {
+    flag: "fetch",
+    short: "f",
+    scripts: ["fetch-alpine.sh", "fetch-bun.sh"],
+    tools: ["curl", "unzip", "tar", "gzip", "sha256sum"],
+  },
+  {
+    flag: "build",
+    short: "b",
+    scripts: ["build-uki.sh", "build-image.sh"],
+    tools: [
+      "fakeroot", "cpio", "gzip",
+      "x86_64-w64-mingw32-objcopy", "x86_64-w64-mingw32-objdump",
+      "parted", "mkfs.fat", "mmd", "mcopy",
+    ],
+  },
+  {
+    flag: "run",
+    short: "r",
+    scripts: ["run-qemu.sh"],
+    tools: ["qemu-system-x86_64"],
+  },
+];
+
+function fail(message) {
+  console.error(`${pkg.name}: ${message}`);
+  process.exit(1);
+}
+
+function usage() {
+  return `${pkg.name} - ${pkg.description}
+
+Usage:
+  ${pkg.name} [-f] [-b] [-r] [--export] [--linux-lts] [--real] [-- qemu arguments]
+
+Stages (always run in this order, whichever you pick):
+  -f, --fetch   download and verify the pinned kernel, musl, GCC runtime,
+                EFI stub and Bun      (fetch-alpine.sh, fetch-bun.sh)
+  -b, --build   pack the initramfs, assemble the UKI, write vda.img
+                                       (build-uki.sh, build-image.sh)
+  -r, --run     boot vda.img under QEMU (run-qemu.sh)
+
+  --export      after -b/--build, copy the image to
+                ./buninu-linux-${pkg.version}.img
+
+  --linux-lts   use Alpine's general-purpose linux-lts kernel for fetch/build
+                (the default is the smaller linux-virt kernel)
+  --real        build for a physical machine: use linux-lts, make tty0 the
+                primary console, and include USB xHCI/HID keyboard modules
+
+  -h, --help    show this
+  -V, --version show name, version, runtime and platform
+  --readme      render README.md in the terminal and exit
+
+Short flags combine: -fbr is the whole pipeline, -br is what an edit to
+initramfs/init.js needs, -r just boots what is already there. Anything after
+-- goes to qemu-system-x86_64 verbatim (for example: -r -- -m 1G).
+
+Fetch and build need the PRoot toolchain from README section 0; run needs
+qemu-system-x86_64, which Termux provides. Tools missing for the stages you
+picked are reported before anything starts.
+`;
+}
+
+function parse(argv) {
+  const selected = new Set();
+  const passthrough = [];
+  let linuxLts = false;
+  let real = false;
+  let exportImage = false;
+  let sawSeparator = false;
+
+  for (const argument of argv) {
+    if (sawSeparator) {
+      passthrough.push(argument);
+    } else if (argument === "--") {
+      sawSeparator = true;
+    } else if (argument === "-h" || argument === "--help") {
+      console.log(usage());
+      process.exit(0);
+    } else if (argument === "-V" || argument === "--version") {
+      printVersion();
+      process.exit(0);
+    } else if (argument === "--readme") {
+      printReadme();
+      process.exit(0);
+    } else if (argument === "--linux-lts") {
+      linuxLts = true;
+    } else if (argument === "--real") {
+      real = true;
+    } else if (argument === "--export") {
+      exportImage = true;
+    } else if (argument.startsWith("--")) {
+      const stage = stages.find((s) => `--${s.flag}` === argument);
+      if (!stage) fail(`unknown option ${argument}\n\n${usage()}`);
+      selected.add(stage);
+    } else if (argument.startsWith("-") && argument.length > 1) {
+      for (const letter of argument.slice(1)) {
+        const stage = stages.find((s) => s.short === letter);
+        if (!stage) fail(`unknown option -${letter} in ${argument}\n\n${usage()}`);
+        selected.add(stage);
+      }
+    } else {
+      fail(`unexpected argument ${argument}\n\n${usage()}`);
+    }
+  }
+
+  if (selected.size === 0) {
+    console.error(usage());
+    process.exit(1);
+  }
+  if (passthrough.length > 0 && !selected.has(stages[2])) {
+    fail("arguments after -- only make sense with -r/--run");
+  }
+  if ((linuxLts || real) && !selected.has(stages[0]) && !selected.has(stages[1])) {
+    fail("--linux-lts/--real only make sense with -f/--fetch or -b/--build");
+  }
+  if (exportImage && !selected.has(stages[1])) {
+    fail("--export requires -b/--build (use -fb --export for a clean build)");
+  }
+  return { selected, passthrough, linuxLts, real, exportImage };
+}
+
+// Same shape as Buninu's --version. The runtime line tells you whether this
+// ran under bun or node, which matters for --readme's rendering.
+function printVersion() {
+  const runtime =
+    typeof Bun !== "undefined" ? `Bun ${Bun.version}` : `Node ${process.versions.node}`;
+  console.log(`${pkg.name}: ${pkg.description}`);
+  console.log("Version:", pkg.version);
+  console.log("Runtime:", runtime);
+  console.log("Platform:", `${process.platform}/${process.arch}`);
+}
+
+// Same as Buninu's --readme: Bun renders the Markdown to ANSI with clickable
+// links. Under node there is no renderer, so the file is printed as-is.
+function printReadme() {
+  const path = resolve(rootDir, "README.md");
+  let markdown;
+  try {
+    markdown = readFileSync(path, "utf8");
+  } catch (error) {
+    fail(`README not found: ${path} (${error.message})`);
+  }
+  const rendered =
+    typeof Bun !== "undefined" && typeof Bun.markdown?.ansi === "function"
+      ? Bun.markdown.ansi(markdown, { hyperlinks: true })
+      : markdown;
+  process.stdout.write(rendered.endsWith("\n") ? rendered : rendered + "\n");
+}
+
+// `command -v` without a shell: look for an executable on PATH.
+function hasTool(name) {
+  for (const directory of (process.env.PATH ?? "").split(delimiter)) {
+    if (!directory) continue;
+    try {
+      accessSync(join(directory, name), constants.X_OK);
+      return true;
+    } catch {}
+  }
+  return false;
+}
+
+function checkTools(selectedStages) {
+  const missing = [];
+  for (const stage of selectedStages) {
+    for (const tool of stage.tools) {
+      if (!hasTool(tool)) missing.push(`${tool} (for --${stage.flag})`);
+    }
+  }
+  if (missing.length > 0) {
+    fail(
+      `missing tools, nothing was run:\n  ${missing.join("\n  ")}\n` +
+        "See README section 0 for the packages that provide them.",
+    );
+  }
+}
+
+function runScript(stage, script, args = [], env = process.env) {
+  const path = resolve(rootDir, script);
+  console.log(`\n==> [${stage.flag}] ${script}${args.length ? " " + args.join(" ") : ""}`);
+  const result = spawnSync(path, args, { cwd: rootDir, stdio: "inherit", env });
+  if (result.error) fail(`could not start ${script}: ${result.error.message}`);
+  if (result.status !== 0) {
+    fail(`${script} exited with status ${result.status ?? "signal " + result.signal}`);
+  }
+}
+
+const { selected, passthrough, linuxLts, real, exportImage } = parse(process.argv.slice(2));
+const ordered = stages.filter((stage) => selected.has(stage));
+checkTools(ordered);
+
+for (const stage of ordered) {
+  for (const script of stage.scripts) {
+    runScript(
+      stage,
+      script,
+      stage.flag === "run" ? passthrough : [],
+      linuxLts || real
+        ? { ...process.env, LINUX_FLAVOR: "lts", ...(real && { REAL_MACHINE: "1" }) }
+        : process.env,
+    );
+  }
+}
+
+if (exportImage) {
+  const source = resolve(rootDir, "vda.img");
+  const destination = resolve(invocationDir, `buninu-linux-${pkg.version}.img`);
+  try {
+    accessSync(source, constants.R_OK);
+    copyFileSync(source, destination);
+  } catch (error) {
+    fail(`could not export image to ${destination}: ${error.message}`);
+  }
+  console.log(`\nExported ${destination}`);
+}

package/initramfs/bin/sh

@@ -0,0 +1,3 @@
+#!/bin/bun
+
+import "../buninu/apps/bunmsh/src/main.js";

package/initramfs/buninu/.bashrc

@@ -0,0 +1,11 @@
+#!/bin/sh
+
+alias ls="ls --color=auto"
+
+alias grep="grep --color=auto"
+
+alias diff="diff --color"
+
+alias pspa="ps -eo pid,args"
+
+alias pspac='ps -eo pid,args>"$HOME"/.pspidargs.sh ; glow "$HOME"/.pspidargs.sh'