buninu-linux 0.3.1 → 0.5.1

package/initramfs/bin/tar

@@ -2,7 +2,8 @@
 // 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 { linkSync, mkdirSync, rmSync, symlinkSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
 import { showDocument } from "../lib/document.js";
 
 const fail = (message) => {
@@ -89,16 +90,186 @@ const archiveBytes = async () => {
   return zstd ? Bun.zstdDecompressSync(bytes) : bytes;
 };
 
+// ----------------------------------------------------------- tar headers --
+//
+// Bun.Archive extracts files, and symbolic links only when their target is
+// relative and stays inside the extraction directory, which drops every
+// absolute target (`/bin/busybox` — 306 of the 335 links in an Alpine
+// minirootfs), every hard link, and every non-regular entry in
+// `Archive.files()`. The header scan below reads the archive itself, so
+// listing is complete and the links can be restored afterwards. Formats:
+// POSIX ustar, GNU long names (`L`/`K`) and pax extended headers (`x`).
+
+const BLOCK = 512;
+const decoder = new TextDecoder();
+
+const text = (block, offset, length) => {
+  let end = offset;
+  const stop = offset + length;
+  while (end < stop && block[end] !== 0) end++;
+  return decoder.decode(block.subarray(offset, end));
+};
+
+const octal = (block, offset, length) => {
+  // GNU base-256 encoding for values that do not fit the octal field.
+  if (block[offset] & 0x80) {
+    let value = block[offset] & 0x7f;
+    for (let index = offset + 1; index < offset + length; index++) value = value * 256 + block[index];
+    return value;
+  }
+  const digits = text(block, offset, length).trim();
+  const value = Number.parseInt(digits, 8);
+  return Number.isFinite(value) ? value : 0;
+};
+
+// The header checksum is computed with its own field read as spaces. A
+// mismatch means this is not a tar header, so scanning stops there.
+const checksumMatches = (block) => {
+  let sum = 0;
+  for (let index = 0; index < BLOCK; index++) {
+    sum += index >= 148 && index < 156 ? 0x20 : block[index];
+  }
+  return sum === octal(block, 148, 8);
+};
+
+const paxRecords = (data) => {
+  const records = {};
+  let offset = 0;
+  const content = decoder.decode(data);
+  while (offset < content.length) {
+    const space = content.indexOf(" ", offset);
+    if (space === -1) break;
+    const length = Number.parseInt(content.slice(offset, space), 10);
+    if (!Number.isFinite(length) || length <= 0) break;
+    const record = content.slice(space + 1, offset + length).replace(/\n$/, "");
+    const equals = record.indexOf("=");
+    if (equals > 0) records[record.slice(0, equals)] = record.slice(equals + 1);
+    offset += length;
+  }
+  return records;
+};
+
+const entryKinds = {
+  "0": "file", "\0": "file", "1": "hardlink", "2": "symlink", "3": "character",
+  "4": "block", "5": "directory", "6": "fifo", "7": "file",
+};
+
+// Every member of the archive, in order, as { name, kind, target, size, mode,
+// mtime }. Returns null when the bytes do not parse as tar.
+const scanEntries = (bytes) => {
+  const entries = [];
+  let offset = 0;
+  let longName = null;
+  let longTarget = null;
+  let extended = {};
+  while (offset + BLOCK <= bytes.length) {
+    const block = bytes.subarray(offset, offset + BLOCK);
+    offset += BLOCK;
+    if (block.every((byte) => byte === 0)) break; // end-of-archive blocks
+    if (!checksumMatches(block)) return entries.length ? entries : null;
+    const flag = String.fromCharCode(block[156] || 0x30);
+    const size = extended.size !== undefined ? Number(extended.size) : octal(block, 124, 12);
+    const dataBlocks = Math.ceil(size / BLOCK) * BLOCK;
+    const data = bytes.subarray(offset, offset + size);
+    if (flag === "L" || flag === "K") {
+      const value = decoder.decode(data).replace(/\0+$/, "");
+      if (flag === "L") longName = value; else longTarget = value;
+      offset += dataBlocks;
+      continue;
+    }
+    if (flag === "x" || flag === "X") {
+      extended = { ...extended, ...paxRecords(data) };
+      offset += dataBlocks;
+      continue;
+    }
+    if (flag === "g") {
+      offset += dataBlocks;
+      continue;
+    }
+    const prefix = text(block, 345, 155);
+    const stored = text(block, 0, 100);
+    const name = extended.path ?? longName ?? (prefix ? `${prefix}/${stored}` : stored);
+    const target = extended.linkpath ?? longTarget ?? text(block, 157, 100);
+    entries.push({
+      name: name.replace(/^\.\//, ""),
+      kind: entryKinds[flag] ?? "file",
+      target,
+      size,
+      mode: octal(block, 100, 8) & 0o7777,
+      mtime: octal(block, 136, 12) * 1000,
+    });
+    longName = null;
+    longTarget = null;
+    extended = {};
+    offset += dataBlocks;
+  }
+  return entries;
+};
+
+const tarBytes = (bytes) => {
+  if (bytes[0] === 0x1f && bytes[1] === 0x8b) return Bun.gunzipSync(bytes);
+  if (bytes[0] === 0x28 && bytes[1] === 0xb5 && bytes[2] === 0x2f && bytes[3] === 0xfd) {
+    return Bun.zstdDecompressSync(bytes);
+  }
+  return bytes;
+};
+
+// Where a member lands, following GNU tar: a leading `/` is stripped, and a
+// name that climbs out with `..` is refused. A link's target is never
+// examined — an absolute symbolic link is a normal thing for a root
+// filesystem to contain — and since links are made after every file, nothing
+// is ever written through one.
+const memberName = (name) => {
+  const stripped = name.replace(/^\/+/, "");
+  const parts = stripped.split("/");
+  if (parts.includes("..")) return null;
+  return stripped || null;
+};
+
 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)
+const kindMarks = { directory: "/", symlink: "@", fifo: "|", character: "#", block: "#" };
+
+const verboseListing = (entry) => {
+  const modified = entry.mtime > 0
+    ? new Date(entry.mtime).toISOString().replace("T", " ").slice(0, 16)
     : "---- -- -- --:--";
-  return `${String(file.size).padStart(12)} ${modified} ${name}`;
+  const suffix = entry.kind === "symlink" ? ` -> ${entry.target}`
+    : entry.kind === "hardlink" ? ` link to ${entry.target}`
+    : "";
+  return `${String(entry.size).padStart(12)} ${modified} ${entry.name}${kindMarks[entry.kind] ?? ""}${suffix}`;
+};
+
+// Creates the links Bun.Archive left out. Files are already in place, so a
+// hard link finds its target and a symbolic link cannot be written through.
+const restoreLinks = (entries) => {
+  for (const entry of entries) {
+    if (entry.kind !== "symlink" && entry.kind !== "hardlink") continue;
+    const name = memberName(entry.name);
+    if (!name || !entry.target) continue;
+    const path = resolve(options.directory, name);
+    try {
+      mkdirSync(dirname(path), { recursive: true });
+      try {
+        if (entry.kind === "symlink") symlinkSync(entry.target, path);
+        else linkSync(resolve(options.directory, memberName(entry.target) ?? entry.target), path);
+      } catch (error) {
+        if (error.code !== "EEXIST") throw error;
+        // GNU tar replaces what is in the way rather than following it.
+        rmSync(path, { force: true });
+        if (entry.kind === "symlink") symlinkSync(entry.target, path);
+        else linkSync(resolve(options.directory, memberName(entry.target) ?? entry.target), path);
+      }
+    } catch (error) {
+      // A hard link whose target was filtered out by a member pattern is
+      // expected; anything else is worth reporting without stopping.
+      if (entry.kind === "hardlink" && error.code === "ENOENT" && options.operands.length) continue;
+      console.error(`tar: ${entry.name}: ${error.message}`);
+    }
+  }
 };
 
 if (options.operation === "x" || options.operation === "t") {
@@ -109,22 +280,26 @@ if (options.operation === "x" || options.operation === "t") {
     fail(error?.message || String(error));
   }
 
+  // The header scan is what makes listing and links complete; if the bytes
+  // do not parse as tar, fall back to what Bun.Archive reports.
+  const scanned = scanEntries(tarBytes(await archiveBytes()));
+  const wanted = options.operands.length ? patterns().map((pattern) => new Bun.Glob(pattern)) : null;
+  const members = scanned
+    ? scanned.filter((entry) => !wanted || wanted.some((glob) => glob.match(entry.name)))
+    : [...(await archive.files(options.operands.length ? patterns() : undefined))]
+      .map(([name, file]) => ({ name, kind: "file", target: "", size: file.size, mode: 0o644, mtime: file.lastModified }));
+
   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));
+    for (const entry of members) {
+      console.log(options.verbose ? verboseListing(entry) : entry.name);
     }
   } else {
     try {
       if (options.verbose) {
-        const files = await archive.files(options.operands.length ? patterns() : undefined);
-        for (const name of files.keys()) console.log(name);
+        for (const entry of members) console.log(entry.name);
       }
       await archive.extract(options.directory, options.operands.length ? { glob: patterns() } : undefined);
+      restoreLinks(members);
     } catch (error) {
       fail(error?.message || String(error));
     }

package/initramfs/buninu/CHANGELOG.md

@@ -1,5 +1,45 @@
 # Changelog
 
+## 0.4.15 - 2026-09-22
+
+### Changed
+
+- Sync jsgotty to 1.1.12
+  * Export `BunPtyBackend` from `gotty.js`, the PTY layer built on
+    `Bun.spawn({ terminal })`, so other programs can run a command on a
+    pseudo-terminal without their own FFI. Buninu Linux's `bunterm`, a
+    graphical terminal on the framebuffer, is its first user, together with
+    the already exported `KittyGraphicsParser`
+
+### Fixed
+
+- jsgotty: a chunked kitty graphics transfer whose first chunk names an
+  image id (`i=`) is now continued by later chunks that carry only `m=`, as
+  the protocol allows. Previously those chunks were treated as new anonymous
+  transfers, so the image never completed. jsgotty's own `showimg` repeats
+  the id in every chunk and was unaffected; `kitten icat`, timg, chafa and
+  similar clients were
+
+## 0.4.13 - 2026-09-22
+
+### Changed
+
+- Sync bunmsh to 0.3.9
+  * `Ctrl-U` removes and saves the text before the cursor; pressing it again
+    at the beginning of the line restores it. `Ctrl-K` independently toggles
+    the text after the cursor when at the end of the line
+  * Unquoted pathname patterns follow directory symbolic links used as
+    intermediate path components, as traditional shells do, so patterns such
+    as `/sys/class/net/*/device` pass through sysfs class links
+  * The fallback `ls`/`lsfancy` lists a glob's files as one listing instead
+    of one section per file, honors `--`, and follows a command-line symlink
+    to a directory
+- Sync jsmdcui to 0.19.2
+  * Pressing `Ctrl-W` twice quickly switches to the next tab like `Alt-T`
+    from either an editor or a terminal pane; at the rightmost tab, when every
+    tab holds only terminal panes, it opens a new editor tab instead of
+    cycling back
+
 ## 0.4.12 - 2026-09-20
 
 ### Fixed

package/initramfs/buninu/apps/jsgotty/gotty.js

@@ -1173,9 +1173,9 @@ class KittyGraphicsParser {
 
     if (control.m === "1") {
       this.transfers.set(key, existing);
-      if (!control.i && !control.I) {
-        this.implicitTransferKey = key;
-      }
+      //  Later chunks of a transfer only need m=; they continue the transfer
+      //  in progress whether or not its first chunk named an image id.
+      this.implicitTransferKey = key;
       return null;
     }
 
@@ -3314,6 +3314,7 @@ async function bootstrap() {
 
 module.exports.CursorStateTracker = CursorStateTracker;
 module.exports.KittyGraphicsParser = KittyGraphicsParser;
+module.exports.BunPtyBackend = BunPtyBackend;
 module.exports.webSocketOriginAllowed = webSocketOriginAllowed;
 
 if (require.main === module) {

package/initramfs/buninu/apps/jsgotty/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsgotty",
-  "version": "1.1.11",
+  "version": "1.1.12",
   "description": "Share your terminal as a web application: A JavaScript rewrite of GoTTY",
   "license": "MIT",
   "bin": {

package/initramfs/buninu/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buninu",
-  "version": "0.4.13",
+  "version": "0.4.15",
   "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

@@ -94,6 +94,79 @@ const mountFilesystems = () => {
 mountFilesystems();
 console.log("init.js: mounted /proc, /sys, /dev, /tmp, /dev/pts");
 
+// Num Lock. The keypad's lock state lives per virtual console in the
+// kernel's keyboard table, and the kernel starts every console with it off,
+// so the keypad types arrows instead of digits. KDSKBLED carries the current
+// flags in its low nibble and the ones a console is reset to in its high
+// nibble; KDSETLED with a value above 7 puts the physical LED back to
+// following those flags. A console allocated later (Ctrl-Alt-F3 for the
+// first time) starts from the kernel default again, so numlock() is left in
+// the REPL for that case.
+const KDSETLED = 0x4b32;
+const KDGKBLED = 0x4b64;
+const KDSKBLED = 0x4b65;
+const LED_NUM = 0x02;
+
+// Nothing here is essential to booting, so a console that is not a virtual
+// terminal, a missing device node or a rejected ioctl is skipped rather than
+// reported: the remaining consoles are still set, and the system comes up
+// either way.
+const setNumLock = (enabled = true) => {
+  const consoles = [];
+  const paths = ["/dev/tty0", "/dev/console", "/dev/tty"];
+  for (let index = 1; index <= 12; index++) paths.push(`/dev/tty${index}`);
+  for (const path of paths) {
+    let fd = -1;
+    try {
+      fd = libc.symbols.open(cString(path), 2, 0);
+      if (fd < 0) continue;
+      const state = new Uint8Array(1);
+      if (libc.symbols.ioctl(fd, KDGKBLED, ptr(state)) !== 0) continue;
+      const current = enabled ? state[0] | LED_NUM : state[0] & ~LED_NUM;
+      const fallback = enabled ? (state[0] >> 4) | LED_NUM : (state[0] >> 4) & ~LED_NUM;
+      const flags = (current & 7) | ((fallback & 7) << 4);
+      if (libc.symbols.ioctl(fd, KDSKBLED, flags) !== 0) continue;
+      libc.symbols.ioctl(fd, KDSETLED, 0x80);
+      consoles.push(path);
+    } catch {
+      // This console keeps whatever state it had; the others still get set.
+    } finally {
+      if (fd >= 0) {
+        try { libc.symbols.close(fd); } catch {}
+      }
+    }
+  }
+  return consoles;
+};
+
+globalThis.numlock = setNumLock;
+try {
+  const consoles = setNumLock(true);
+  console.log(consoles.length
+    ? `init.js: num lock on (${consoles.join(" ")})`
+    : "init.js: no virtual console accepted a num lock setting");
+} catch (error) {
+  console.error(`init.js: num lock: ${error?.message ?? error}`);
+}
+
+// The input layer's character devices, so a pointing device has a
+// /dev/input/event* node for `bunterm --mouse` to read. Loading them only
+// creates those nodes: the console keyboard is unaffected, and nothing reads
+// a pointer unless it is asked to. A USB mouse also needs the usbhid stack,
+// which `cfg.all` or a --real boot brings in.
+try {
+  const { tryModprobe } = await import("/lib/modprobe.js");
+  const loaded = ["evdev", "psmouse"].filter((module) => tryModprobe(module) !== null);
+  const { readdirSync } = await import("node:fs");
+  const devices = (() => {
+    try { return readdirSync("/dev/input").filter((name) => name.startsWith("event")); } catch { return []; }
+  })();
+  console.log(`init.js: input modules ${loaded.length ? loaded.join(" ") : "none"}`
+    + ` (${devices.length} event device${devices.length === 1 ? "" : "s"})`);
+} catch (error) {
+  console.error(`init.js: input modules: ${error?.message ?? error}`);
+}
+
 const { default: repl } = await import("node:repl");
 const { mkdirSync, writeFileSync } = await import("node:fs");
 
@@ -341,6 +414,12 @@ const launchBunmsh = () => {
 
 const launchBuninu = () => {
 
+  console.log(`
+Type bunterm in bunmsh: Graphical Terminal
+  Shows Emojis, CJK chars
+  Supports Kitty Graphics Protocol
+`)
+
   const entry = `/buninu/bin/init.js`;
   console.log(`buninu: Starting ${entry} --local`);
   const shell = Bun.spawnSync([
@@ -348,7 +427,7 @@ const launchBuninu = () => {
   ], {
     env: {
       ...process.env,
-      PATH:"/bin:/usr/bin:/buninu/bin",
+      PATH:"/bin:/sbin:/usr/bin:/usr/sbin:/buninu/.bun/bin:/buninu/bin",
       HOME:"/buninu"
     },
     stdin: "inherit",