buninu-linux 0.2.1 → 0.3.1

package/initramfs/buninu/apps/bunmsh/src/mouse.js

@@ -21,7 +21,13 @@ function partialMarkerSuffixLength(text, marker) {
   return 0;
 }
 
-export function mouseInput(onMouse, onCursorPosition, onShortcut = () => {}, onPaste = () => {}) {
+export function mouseInput(
+  onMouse,
+  onCursorPosition,
+  onShortcut = () => {},
+  onPaste = () => {},
+  onEditShortcut = () => {},
+) {
   const decoder = new StringDecoder("utf8");
   let pending = "";
   // Bracketed paste (\x1b[200~ ... \x1b[201~): everything between the
@@ -48,6 +54,25 @@ export function mouseInput(onMouse, onCursorPosition, onShortcut = () => {}, onP
         source = source.replace(/\x1bc/g, () => { onShortcut("tab-close"); return ""; });
       }
       let output = "";
+      const flushOutput = () => {
+        if (!output) return;
+        this.push(output);
+        output = "";
+      };
+      const appendPlainText = (text) => {
+        let start = 0;
+        for (let index = 0; index < text.length; index++) {
+          const side = text[index] === "\x15" ? "head"
+            : text[index] === "\x0b" ? "tail"
+            : null;
+          if (!side) continue;
+          output += text.slice(start, index);
+          flushOutput();
+          onEditShortcut(side);
+          start = index + 1;
+        }
+        output += text.slice(start);
+      };
       while (source) {
         if (pasting) {
           const end = source.indexOf(PASTE_END);
@@ -66,8 +91,8 @@ export function mouseInput(onMouse, onCursorPosition, onShortcut = () => {}, onP
           continue;
         }
         const escape = source.indexOf("\x1b[");
-        if (escape < 0) { output += source; break; }
-        output += source.slice(0, escape);
+        if (escape < 0) { appendPlainText(source); break; }
+        appendPlainText(source.slice(0, escape));
         source = source.slice(escape);
         if (source.startsWith(PASTE_START)) {
           pasting = true;
@@ -93,7 +118,7 @@ export function mouseInput(onMouse, onCursorPosition, onShortcut = () => {}, onP
         output += source.slice(0, 2);
         source = source.slice(2);
       }
-      if (output) this.push(output);
+      flushOutput();
       done();
     },
   });

package/initramfs/buninu/apps/bunmsh/src/shell.js

@@ -787,7 +787,15 @@ async function pathnameFields(field, state) {
     return ch;
   }).join("");
   const glob = new Bun.Glob(pattern);
-  const matches = [...glob.scanSync({ cwd: state.cwd, dot: false, onlyFiles: false })].sort();
+  // Shell pathname expansion follows a directory symlink used as an
+  // intermediate path component. Bun.Glob defaults this off, which makes
+  // patterns such as /sys/class/*/device silently miss sysfs class links.
+  const matches = [...glob.scanSync({
+    cwd: state.cwd,
+    dot: false,
+    onlyFiles: false,
+    followSymlinks: true,
+  })].sort();
   return matches.length ? matches : [value];
 }
 

package/initramfs/buninu/apps/bunmsh/test/shell1.test.js

@@ -53,6 +53,7 @@ import { fancyLs } from "../src/fancy-ls.js";
 import { MOUSE_OFF, MOUSE_ON, mouseInput } from "../src/mouse.js";
 import { canonicalEnvironment, environmentValue, homeRelativePath } from "../src/environment.js";
 import { findIsRegularBuiltin } from "../src/find.js";
+import { toggleSavedText } from "../src/line-edit.js";
 
 async function run(source, options = {}) {
   const state = createState({
@@ -181,6 +182,36 @@ describe("completion", () => {
     ]);
   });
 
+  test("toggles independently saved Ctrl-U heads and Ctrl-K tails", () => {
+    const cutHead = toggleSavedText("headtail", 4, "", "head");
+    expect(cutHead).toEqual({ line: "tail", cursor: 0, saved: "head", changed: true });
+    expect(toggleSavedText(cutHead.line, cutHead.cursor, cutHead.saved, "head"))
+      .toEqual({ line: "headtail", cursor: 4, saved: "", changed: true });
+
+    const cutTail = toggleSavedText("headtail", 4, "", "tail");
+    expect(cutTail).toEqual({ line: "head", cursor: 4, saved: "tail", changed: true });
+    expect(toggleSavedText(cutTail.line, cutTail.cursor, cutTail.saved, "tail"))
+      .toEqual({ line: "headtail", cursor: 4, saved: "", changed: true });
+  });
+
+  test("intercepts Ctrl-U and Ctrl-K outside bracketed paste", async () => {
+    const edits = [];
+    const pasted = [];
+    let forwarded = "";
+    const input = mouseInput(() => {}, () => {}, () => {},
+      (text) => pasted.push(text),
+      (side) => edits.push({ side, forwarded }));
+    input.on("data", (chunk) => { forwarded += chunk.toString(); });
+    input.end("abc\x15def\x0b\x1b[200~x\x15y\x0bz\x1b[201~");
+    await new Promise((resolve) => input.once("end", resolve));
+    expect(edits).toEqual([
+      { side: "head", forwarded: "abc" },
+      { side: "tail", forwarded: "abcdef" },
+    ]);
+    expect(forwarded).toBe("abcdef");
+    expect(pasted).toEqual(["x\x15y\x0bz"]);
+  });
+
   test("imports Bash and Fish history by default and can be disabled", async () => {
     expect(parseBashHistory("#1720000000\necho bash\n\nshared\n"))
       .toEqual(["echo bash", "shared"]);
@@ -575,6 +606,7 @@ describe("execution", () => {
       mkdirSync(join(cwd, "targetdir"));
       symlinkSync("target.txt", join(cwd, "link_ok"));
       symlinkSync("targetdir", join(cwd, "link_dir"));
+      await Bun.write(join(cwd, "targetdir", "inside.js"), "export {};\n");
       symlinkSync("/nonexistent/path", join(cwd, "link_broken"));
       symlinkSync("loop_b", join(cwd, "loop_a"));
       symlinkSync("loop_a", join(cwd, "loop_b"));
@@ -597,6 +629,15 @@ describe("execution", () => {
       const plain = await run("builtin lsfancy", { cwd });
       expect(plain.stdout).toContain("🔗 link_ok");
       expect(plain.stdout).toContain("🚫 link_broken");
+
+      // A command-line link to a directory is followed for an ordinary
+      // listing, but -l, -d, and -F inspect/classify the link itself.
+      const followed = await run("builtin lsfancy link_dir", { cwd });
+      expect(followed.stdout).toContain("inside.js");
+      const linkLong = await run("builtin lsfancy -l link_dir", { cwd });
+      expect(linkLong.stdout).toContain("link_dir -> targetdir");
+      expect((await run("builtin lsfancy -d link_dir", { cwd })).stdout).toContain("🔗 link_dir");
+      expect((await run("builtin lsfancy -F link_dir", { cwd })).stdout).toContain("link_dir@");
     } finally { rmSync(cwd, { recursive: true, force: true }); }
   });
 
@@ -624,6 +665,35 @@ describe("execution", () => {
     } finally { rmSync(cwd, { recursive: true, force: true }); }
   });
 
+  test("builtin ls lists glob-expanded files as files, not directory sections", async () => {
+    const cwd = mkdtempSync(join(tmpdir(), "bunmsh-ls-glob-"));
+    try {
+      await Bun.write(join(cwd, "first.sh"), "#!/bin/sh\n");
+      await Bun.write(join(cwd, "final.sh"), "#!/bin/sh\n");
+      await Bun.write(join(cwd, "other.txt"), "other\n");
+      const output = await run("builtin ls f*.sh", { cwd });
+      expect(output).toMatchObject({ status: 0, stderr: "" });
+      expect(output.stdout).toContain("first.sh");
+      expect(output.stdout).toContain("final.sh");
+      expect(output.stdout).not.toContain("other.txt");
+      expect(output.stdout).not.toContain("first.sh:");
+      expect(output.stdout).not.toContain("final.sh:");
+      expect(output.stdout).not.toContain("\n\n");
+
+      await Bun.write(join(cwd, "-odd"), "odd\n");
+      const afterDoubleDash = await run("builtin ls -- -odd", { cwd });
+      expect(afterDoubleDash).toMatchObject({ status: 0, stderr: "" });
+      expect(afterDoubleDash.stdout).toContain("-odd");
+
+      mkdirSync(join(cwd, ".hidden-target"));
+      await Bun.write(join(cwd, ".hidden-target", "through-link.js"), "export {};\n");
+      symlinkSync(".hidden-target", join(cwd, "class-link"));
+      const throughLink = await run("builtin ls ./*/*.js", { cwd });
+      expect(throughLink).toMatchObject({ status: 0, stderr: "" });
+      expect(throughLink.stdout).toContain("./class-link/through-link.js");
+    } finally { rmSync(cwd, { recursive: true, force: true }); }
+  });
+
   test("fallback find filters paths and supports both -exec modes", async () => {
     const cwd = mkdtempSync(join(tmpdir(), "bunmsh-find-"));
     try {

package/initramfs/buninu/apps/jsmdcui/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable user-visible changes to jsmdcui are documented here.
 
+## [0.19.2] - 2026-09-21
+
+### Added
+
+- Quickly pressing `Ctrl-W` twice now switches to the next tab like `Alt-T`
+  from either an editor or terminal pane. A single press retains its existing
+  next-pane behavior. At the rightmost tab, when every tab contains only
+  terminal panes, the double press creates a new editor tab instead of cycling
+  back, ensuring keyboard-only access to editing and other non-terminal work.
+
 ## [0.19.0] - 2026-08-24
 
 ### Fixed

package/initramfs/buninu/apps/jsmdcui/README.md

@@ -793,6 +793,8 @@ selection, search, and copy remain available.
 | `Ctrl-F` | Search; use `Ctrl-N` and `Ctrl-P` for the next and previous match. |
 | `Ctrl-G` | Open the editor help. |
 | `Alt-G` | Show or hide the shortcut bar. |
+| `Ctrl-W` | Switch to the next pane in the current tab. |
+| `Ctrl-W` twice quickly | Switch to the next tab like `Alt-T`. At the rightmost tab, if every tab contains only terminal panes, create a new editor tab instead of cycling back. |
 | `Ctrl-Q` or `Alt-Q` | Close the current UI. |
 
 To preview another color theme, press `Ctrl-E` or click on `€`, type `theme `, then use `Tab`

package/initramfs/buninu/apps/jsmdcui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsmdcui",
-  "version": "0.19.1",
+  "version": "0.19.2",
   "description": "Markdown as a Common UI for Terminals and Web Browsers",
   "type": "module",
   "main": "./src/index.js",

package/initramfs/buninu/apps/jsmdcui/runtime/help/commands.md

@@ -151,7 +151,10 @@ quotes here but these are not necessary when entering the command in micro.
 
 * `term ['exec']`: Open a terminal emulator running the given executable. If no
    executable is given, this will open the default shell in the terminal
-   emulator.
+   emulator. `Ctrl-W` switches panes in both editor and terminal panes. Press
+   it twice quickly to cycle to the next tab like `Alt-T`; at the rightmost
+   tab, if every tab is a terminal, this creates a new editor tab instead of
+   cycling back.
 
 ---
 

package/initramfs/buninu/apps/jsmdcui/runtime/help/help.md

@@ -793,6 +793,8 @@ selection, search, and copy remain available.
 | `Ctrl-F` | Search; use `Ctrl-N` and `Ctrl-P` for the next and previous match. |
 | `Ctrl-G` | Open the editor help. |
 | `Alt-G` | Show or hide the shortcut bar. |
+| `Ctrl-W` | Switch to the next pane in the current tab. |
+| `Ctrl-W` twice quickly | Switch to the next tab like `Alt-T`. At the rightmost tab, if every tab contains only terminal panes, create a new editor tab instead of cycling back. |
 | `Ctrl-Q` or `Alt-Q` | Close the current UI. |
 
 To preview another color theme, press `Ctrl-E` or click on `€`, type `theme `, then use `Tab`

package/initramfs/buninu/apps/jsmdcui/src/index.js

@@ -2796,6 +2796,8 @@ class App {
     this.tabRects = [];
     this._escBuf = null;   // pending lone ESC bytes waiting for alt-key combo
     this._escTimer = null;
+    this._ctrlWTime = 0;
+    this._ctrlWTimer = null;
     this._suggestionsRow = null;
     this._suggestionRects = [];
     this._acHScroll = 0;
@@ -3790,7 +3792,7 @@ class App {
     const titleStyle = { ...defaultStyle, reverse: true };
     const scrollMsg = vt && vt.scrollOffset > 0
       ? ` -- SCROLLBACK (${vt.scrollOffset}/${vt.scrollback.length}) wheel↑↓ to browse, any key to return`
-      : (isActive ? " [Esc: close  Ctrl-W: switch pane]" : "");
+      : (isActive ? " [Esc=close,Ctrl-W/*2=Next Pane/Tab]" : "");
     putText(this.screen, pane.x, pane.y, ` Terminal${scrollMsg}`.padEnd(pane.w), titleStyle, pane.w);
     if (!vt) return;
     const renderRows = pane.h - 1;
@@ -4228,14 +4230,12 @@ class App {
         this.render();
         return;
       }
-      // Ctrl-W: switch pane focus without closing
+      // Ctrl-W: switch pane focus without closing. A quick second Ctrl-W
+      // cycles tabs, with an editor-tab escape hatch when every tab is a
+      // terminal and the current one is already the rightmost tab.
       if (text === "\x17") {
-        const panes = this.tab.panes();
-        if (panes.length > 1) {
-          const idx = panes.indexOf(this.tab.activePane);
-          this.tab.activePane = panes[(idx + 1) % panes.length];
-          this.render();
-        }
+        await this.handleCtrlW();
+        this.render();
         return;
       }
 
@@ -4525,11 +4525,7 @@ class App {
         await runAction("AddTab", this);
         break;
       case "ctrl-w": { //switchPane
-        const panes = this.tab.panes();
-        if (panes.length > 1) {
-          const idx = panes.indexOf(this.tab.activePane);
-          this.tab.activePane = panes[(idx + 1) % panes.length];
-        }
+        await this.handleCtrlW();
         break;
       }
       case "ctrl-y": //redo
@@ -5403,6 +5399,37 @@ class App {
     return this.setActiveTab((this.activeTabIdx + 1) % this.tabs.length);
   }
 
+  _clearCtrlW() {
+    if (this._ctrlWTimer) clearTimeout(this._ctrlWTimer);
+    this._ctrlWTimer = null;
+    this._ctrlWTime = 0;
+  }
+
+  async handleCtrlW() {
+    const now = Date.now();
+    const isDouble = this._ctrlWTime > 0 && now - this._ctrlWTime < 400;
+    this._clearCtrlW();
+
+    if (isDouble) {
+      const atRightmostTab = this.activeTabIdx === this.tabs.length - 1;
+      const allTabsAreTerminal = this.tabs.every((tab) =>
+        tab.panes().length > 0 && tab.panes().every((pane) => pane.type === "term")
+      );
+      if (atRightmostTab && allTabsAreTerminal) await this.addTab();
+      else this.nextTab();
+      return;
+    }
+
+    this._ctrlWTime = now;
+    this._ctrlWTimer = setTimeout(() => this._clearCtrlW(), 400);
+
+    const panes = this.tab.panes();
+    if (panes.length > 1) {
+      const idx = panes.indexOf(this.tab.activePane);
+      this.tab.activePane = panes[(idx + 1) % panes.length];
+    }
+  }
+
   async handlePrompt(text) {
     const key = parseKey(text);
 

package/initramfs/buninu/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buninu",
-  "version": "0.4.12",
+  "version": "0.4.13",
   "description": "Buninu is a portable, self-bootstrapping Unix-like userspace built on Bun that runs across operating systems",
   "type": "module",
   "main": "./bin/init.js",

package/initramfs/init.js

@@ -37,6 +37,10 @@ const libc = dlopen("/lib/libc.musl-x86_64.so.1", {
     args: [FFIType.i32],
     returns: FFIType.i32,
   },
+  mkdir: {
+    args: [FFIType.ptr, FFIType.i32],
+    returns: FFIType.i32,
+  },
 });
 
 const cString = (value) => new TextEncoder().encode(`${value}\0`);
@@ -63,18 +67,23 @@ const errno = () => read.i32(errnoLocation);
 //
 // EBUSY is tolerated so this still works if something else mounted them first.
 const mountFilesystems = () => {
-  for (const [source, target, type] of [
+  for (const [source, target, type, data] of [
     ["proc", "/proc", "proc"],
     ["sysfs", "/sys", "sysfs"],
     ["devtmpfs", "/dev", "devtmpfs"],
     ["tmpfs", "/tmp", "tmpfs"],
+    // Since Linux 4.7 open("/dev/ptmx") resolves through /dev/pts/ptmx, so
+    // without this mount every pty open fails with ENODEV. The directory is
+    // created on the devtmpfs mounted just above.
+    ["devpts", "/dev/pts", "devpts", "gid=5,mode=620,ptmxmode=666"],
   ]) {
+    if (type === "devpts") libc.symbols.mkdir(ptr(cString(target)), 0o755);
     const result = libc.symbols.mount(
       ptr(cString(source)),
       ptr(cString(target)),
       ptr(cString(type)),
       0n,
-      null,
+      data === undefined ? null : ptr(cString(data)),
     );
     if (result === 0) continue;
     if (errno() === 16) continue; // EBUSY: already mounted
@@ -83,13 +92,23 @@ const mountFilesystems = () => {
 };
 
 mountFilesystems();
-console.log("init.js: mounted /proc, /sys, /dev, /tmp");
+console.log("init.js: mounted /proc, /sys, /dev, /tmp, /dev/pts");
 
 const { default: repl } = await import("node:repl");
 const { mkdirSync, writeFileSync } = await import("node:fs");
 
 global.repl = repl;
 
+// QEMU user networking exposes its DNS proxy at 10.0.2.3. A real-machine
+// image instead starts with public resolvers until the user configures DNS
+// for the local network.
+writeFileSync(
+  "/etc/resolv.conf",
+  process.env.REAL_MACHINE === "1"
+    ? "nameserver 1.1.1.1\nnameserver 8.8.8.8\n"
+    : "nameserver 10.0.2.3\n",
+);
+
 
 const loadModule = (path) => {
   const name = cString(path);
@@ -203,6 +222,36 @@ const configureRealKeyboard = () => {
   ]) loadModule(`/lib/modules/${release}/kernel/${module}`);
 };
 
+// ACPI battery, AC adapter, power button and thermal zones are modules on
+// Alpine's kernels; until they are loaded /sys/class/power_supply is empty.
+// Loaded on demand from the REPL as cfg.power, through /lib/modprobe.js (a
+// require() is fine here: /proc exists by the time anyone can type it). The
+// modules are only in the image when it was built with --real.
+const configureBattery = () => {
+  const { modprobe } = require("/lib/modprobe.js");
+  for (const module of ["battery", "ac", "button", "thermal"]) {
+    try {
+      const inserted = modprobe(module);
+      console.log(`acpi: ${module} ${inserted.length ? "loaded" : "already loaded"}`);
+    } catch (error) {
+      console.error(`acpi: ${module}: ${error.message}`);
+    }
+  }
+  const { readdirSync, readFileSync } = require("node:fs");
+  const read = (path) => { try { return readFileSync(path, "utf8").trim(); } catch { return "-"; } };
+  const supplies = (() => { try { return readdirSync("/sys/class/power_supply"); } catch { return []; } })();
+  if (supplies.length === 0) console.log("power_supply: nothing registered (no ACPI battery or AC adapter on this machine)");
+  for (const name of supplies) {
+    const base = `/sys/class/power_supply/${name}`;
+    const type = read(`${base}/type`);
+    const detail = type === "Battery"
+      ? `${read(`${base}/status`)} ${read(`${base}/capacity`)}%`
+      : `online=${read(`${base}/online`)}`;
+    console.log(`power_supply: ${name} ${type} ${detail}`);
+  }
+  return supplies;
+};
+
 const reapChildren = () => {
   const status = new Int32Array(1);
   while (libc.symbols.waitpid(-1, ptr(status), 1) > 0) {}
@@ -213,6 +262,13 @@ process.on("SIGCHLD", reapChildren);
 process.on("SIGTERM", () => console.log("PID 1 received SIGTERM"));
 process.on("SIGINT", () => console.log("PID 1 received SIGINT"));
 
+// The REPL catches what its eval throws, but not a rejection or a throw
+// from a timer or callback: Bun then exits, and PID 1 exiting is a kernel
+// panic ("Attempted to kill init!"). With a listener installed Bun only
+// reports, so a stray `Promise.reject()` at the prompt stays a message.
+process.on("uncaughtException", (error) => console.error("PID 1 uncaught exception (ignored):", error));
+process.on("unhandledRejection", (reason) => console.error("PID 1 unhandled rejection (ignored):", reason));
+
 
 try {
   bringUpLoopback();
@@ -228,6 +284,7 @@ try {
   console.error("USB keyboard setup failed:", error);
 }
 
+
 try {
   configureQemuNetwork();
   console.log("network: eth0 10.0.2.15/24 via 10.0.2.2");
@@ -289,7 +346,8 @@ const launchBuninu = () => {
   const shell = Bun.spawnSync([
     "/bin/bun", entry, "--local"
   ], {
-    env: { 
+    env: {
+      ...process.env,
       PATH:"/bin:/usr/bin:/buninu/bin",
       HOME:"/buninu"
     },
@@ -309,19 +367,109 @@ const launchBuninu = () => {
 //  Configuration complete
 
 
+globalThis.bunmsh = launchBunmsh;
+//console.log("Type bunmsh() to install and enter the bunmsh shell.");
+
+globalThis.start = launchBuninu;
+
+// cfg.net loads every packaged network module, including PHY and bus support
+// that a kernel userspace modprobe helper would normally load on demand. It
+// then reports the device matches and lists the resulting interfaces. The
+// address and route are still yours to set with `ip`.
+const configureEthernet = () => {
+  const { autoload, modprobeAll } = require("/lib/modprobe.js");
+  const { readdirSync, readFileSync } = require("node:fs");
+  const read = (path) => { try { return readFileSync(path, "utf8").trim(); } catch { return "-"; } };
+  const all = modprobeAll({ accept: (_module, path) => path.startsWith("kernel/drivers/net/") });
+  console.log(`eth: loaded all packaged network modules (${all.inserted.length} newly loaded, ${all.errors.length} failed)`);
+  for (const { module, error } of all.errors) console.log(`eth: ${module}: ${error}`);
+  const report = autoload({
+    // PCI class 02 (network), virtio device id 1 (net), every USB device —
+    // but only network drivers, so a USB keyboard does not show up as usbhid.
+    accept: (modalias) => /^usb:/.test(modalias) || /^virtio:d00000001v/.test(modalias) || /bc02sc/.test(modalias),
+    acceptModule: (module, path) => path.startsWith("kernel/drivers/net/"),
+  });
+  if (report.length === 0) console.log("eth: no network device matched a module in the image (driver built in, or not built with --real)");
+  // Network devices nothing in the image claims, so the chip is at least named.
+  try {
+    for (const device of readdirSync("/sys/bus/pci/devices")) {
+      const modalias = read(`/sys/bus/pci/devices/${device}/modalias`);
+      if (!/bc02sc/.test(modalias) || report.some((entry) => entry.device === device)) continue;
+      const [, vendor, id] = /^pci:v0000([0-9A-F]{4})d0000([0-9A-F]{4})/.exec(modalias) ?? [];
+      const kind = /bc02sc80/.test(modalias) ? "wireless" : "network";
+      console.log(`eth: pci ${device} ${kind} controller ${vendor}:${id} has no driver in the image`);
+    }
+  } catch {}
+  for (const { bus, device, modules, loaded, error } of report) {
+    const status = error ?? (loaded.length ? `loaded ${loaded.join(" ")}` : "already loaded");
+    console.log(`eth: ${bus} ${device} -> ${modules.join(" ")}: ${status}`);
+  }
+  const interfaces = (() => { try { return readdirSync("/sys/class/net").filter((name) => name !== "lo"); } catch { return []; } })();
+  for (const name of interfaces) {
+    const carrier = read(`/sys/class/net/${name}/carrier`);
+    console.log(`eth: ${name} ${read(`/sys/class/net/${name}/address`)} ${read(`/sys/class/net/${name}/operstate`)}${carrier === "1" ? " carrier" : ""}`);
+  }
+  if (interfaces.length) console.log(`eth:
+  Next steps in shell( after start() ):
+  ip link set ${interfaces[0]} up
+  ip addr add A.B.C.D/24 dev ${interfaces[0]};
+  ip route add default via GATEWAY
+`);
+  return interfaces;
+};
 
+// Explicit full coldplug for this deliberately tiny system: load every .ko
+// represented in modules.dep, recursively including each module's declared
+// dependencies. Failures are reported individually without stopping the rest.
+const configureModules = () => {
+  const { modprobeAll } = require("/lib/modprobe.js");
+  const report = modprobeAll();
+  console.log(`modules: ${report.inserted.length} newly loaded, ${report.errors.length} failed`);
+  for (const { module, error } of report.errors) console.log(`modules: ${module}: ${error}`);
+  return report;
+};
 
+// Load the packaged storage stack so devtmpfs can expose disks before the
+// user has a concrete /dev path to pass to mount. This covers virtio block,
+// SATA/PATA/SCSI, NVMe behind VMD, and USB mass-storage/UAS.
+const configureDisks = () => {
+  const { modprobeAll } = require("/lib/modprobe.js");
+  const { readdirSync } = require("node:fs");
+  const storagePath = /^kernel\/drivers\/(?:ata\/|block\/virtio_blk\.ko$|nvme\/|pci\/controller\/vmd\.ko$|scsi\/|usb\/storage\/)/;
+  const report = modprobeAll({ accept: (_module, path) => storagePath.test(path) });
+  console.log(`disk: ${report.inserted.length} newly loaded, ${report.errors.length} failed`);
+  for (const { module, error } of report.errors) console.log(`disk: ${module}: ${error}`);
+  const devices = (() => { try { return readdirSync("/sys/class/block"); } catch { return []; } })();
+  console.log(`disk: ${devices.length ? devices.map((name) => `/dev/${name}`).join(" ") : "no block devices registered"}`);
+  return devices;
+};
 
-console.log(`
+globalThis.cfg = Object.freeze(Object.defineProperties({}, {
+  all: { enumerable: true, get: configureModules },
+  disk: { enumerable: true, get: configureDisks },
+  net: { enumerable: true, get: configureEthernet },
+  power: { enumerable: true, get: configureBattery },
+}));
+
+// Compatibility aliases for images and notes that used the original API.
+globalThis.cfgEth = configureEthernet;
+globalThis.cfgNet = configureEthernet;
+globalThis.cfgDisk = configureDisks;
+globalThis.cfgMod = configureModules;
+globalThis.cfgBat = configureBattery;
+
+const showWelcome = () => {
+  console.log(`
 Welcome to Buninu Linux!
 Bun ${Bun.version} is now PID ${process.pid}
-`);
-
-globalThis.bunmsh = launchBunmsh;
-//console.log("Type bunmsh() to install and enter the bunmsh shell.");
+Type start() to run buninu --local`);
+  if (process.env.REAL_MACHINE === "1") {
+    console.log(`Configuration getters: ${Object.keys(globalThis.cfg).map((name) => `cfg.${name}`).join(", ")}`);
+  }
+  console.log();
+};
 
-globalThis.start = launchBuninu;
-console.log("Type start() to run buninu --local");
+showWelcome();
 
 const startRepl = () => {
   const server = repl.start({
@@ -330,6 +478,11 @@ const startRepl = () => {
     output: process.stdout,
     terminal: true,
   });
+  // Run before REPL's own line listener so its next prompt is printed after
+  // the repeated welcome. Empty and whitespace-only lines both trigger it.
+  server.prependListener("line", (line) => {
+    if (line.trim() === "") showWelcome();
+  });
   server.on("exit", () => {
     console.log("REPL exited; restarting it to keep PID 1 alive.");
     setTimeout(startRepl, 0);