buninu-linux 0.7.55 → 0.8.55

package/fetch-npm.sh

@@ -0,0 +1,44 @@
+#!/usr/bin/env bash
+set -euo pipefail
+umask 022
+cd "$(dirname "$0")"
+
+# These application tarballs are architecture-independent. Do not install,
+# extract, or run npm lifecycle scripts here; pack-time layout comes later.
+downloads_dir="$PWD/downloads/npm"
+. ./scripts/fetch.sh
+
+# Fixed three-line YAML blocks, not shell code: never source or eval them.
+header='^"((@[a-z0-9._-]+/)?[a-z0-9._-]+)@([0-9]+\.[0-9]+\.[0-9]+(-[A-Za-z0-9.-]+)?)":$'
+source='^  - (https://registry\.npmjs\.org/[^[:space:]"#]+\.tgz)$'
+digest='^  - sha256:([a-f0-9]{64})$'
+invalid() { echo "error: invalid or duplicate npm pin: $line" >&2; exit 1; }
+state=0
+seen='|'
+archives=() urls=() hashes=()
+while IFS= read -r line || [[ -n "$line" ]]; do
+    line=${line%$'\r'}
+    [[ "$line" =~ ^[[:space:]]*$ || "$line" == \#* ]] && continue
+    case "$state" in
+        0)
+            [[ "$line" =~ $header ]] || invalid
+            name=${BASH_REMATCH[1]} version=${BASH_REMATCH[3]}
+            archive=${name#@}
+            archive=${archive/\//-}-$version.tgz
+            [[ "$seen" != *"|$archive|"* ]] || invalid
+            seen="$seen$archive|"
+            state=1 ;;
+        1)
+            [[ "$line" =~ $source ]] || invalid
+            url=${BASH_REMATCH[1]}
+            state=2 ;;
+        2)
+            [[ "$line" =~ $digest ]] || invalid
+            archives+=("$archive") urls+=("$url") hashes+=("${BASH_REMATCH[1]}")
+            state=0 ;;
+    esac
+done < scripts/npm-packages.md
+[[ "$state" == 0 && ${#archives[@]} -gt 0 ]] || invalid
+for ((i=0; i<${#archives[@]}; i++)); do
+    fetch "${urls[i]}" "${archives[i]}" "${hashes[i]}"
+done

package/fetch-plus-build.sh

@@ -5,6 +5,7 @@ cd "$(dirname "$0")"
 
 ./fetch-alpine.sh
 ./fetch-bun.sh
+./fetch-npm.sh
 ./build-uki.sh
 ./build-image.sh
 

package/index.js

@@ -12,6 +12,7 @@ import { createHash } from "node:crypto";
 import { accessSync, constants, copyFileSync, existsSync, readFileSync } from "node:fs";
 import { delimiter, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { jsToolsEnabled } from "./scripts/js-tools.js";
 
 const rootDir = dirname(fileURLToPath(import.meta.url));
 const invocationDir = process.cwd();
@@ -43,7 +44,7 @@ const stages = [
   {
     flag: "fetch",
     short: "f",
-    scripts: ["fetch-alpine.sh", "fetch-bun.sh"],
+    scripts: ["fetch-alpine.sh", "fetch-bun.sh", "fetch-npm.sh"],
     tools: () => ["curl", "unzip", "tar", "gzip", "sha256sum"],
   },
   {
@@ -83,17 +84,18 @@ Usage:
 
 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)
+                EFI stub, Bun and npm application tarballs
+                (scripts/fetch.js by default)
   -b, --build   pack the initramfs, assemble the UKI, write vda.img
-                                       (build-uki.sh, build-image.sh)
+                (scripts/build.js by default)
   -r, --run     boot vda.img under QEMU (run-qemu.sh), with KVM or
                 Hypervisor.framework when the guest matches the host CPU
 
   --arch ARCH   guest architecture: x86_64 (default; alias amd64, x64) or
                 aarch64 (alias arm64, native speed on Apple Silicon). A bare
                 -r boots whichever one vda.img was last built for
-  --docker      run fetch and build inside a Debian container built from
-                ./Dockerfile; always on for macOS, which lacks the toolchain
+  --docker      with JS tools disabled, run fetch/build in the Debian
+                container from ./Dockerfile; automatic on macOS in shell mode
 
   --export      after -b/--build, copy the image to
                 ./buninu-linux-${pkg.version}.img (x86_64) or
@@ -120,11 +122,12 @@ initramfs/init.js needs, -r just boots what is already there. Anything after
 -- goes to qemu-system-x86_64 or qemu-system-aarch64 verbatim (for example:
 -r -- -smp 4).
 
-With BUNINU_JS_TOOLS=1 in the environment, fetch and build are done in
-JavaScript (scripts/fetch.js, scripts/build.js) and need only node or bun:
-no Debian toolchain and no Docker.
+Fetch and build use JavaScript by default (scripts/fetch.js, scripts/build.js).
+Host Bun is required for npm extraction; no Debian toolchain or Docker is used.
+Set BUNINU_JS_TOOLS=0, off or false to select the shell tools instead
+(case-insensitive; surrounding whitespace is ignored).
 
-Fetch and build need the Debian toolchain from README "Build environment"
+With JS tools disabled, fetch and build need the Debian toolchain from README "Build environment"
 (PRoot, a Debian or Ubuntu host, or --docker); run needs QEMU (Termux
 pkg, apt, or brew install qemu). Tools missing for the stages you picked are
 reported before anything starts.
@@ -254,10 +257,9 @@ function hasTool(name) {
   return false;
 }
 
-// BUNINU_JS_TOOLS=1: fetch and build run scripts/fetch.js and scripts/build.js
-// in this process instead of the shell scripts, so they need no toolchain
-// and no Docker; run is unchanged.
-const jsTools = process.env.BUNINU_JS_TOOLS === "1";
+// JS tools are the default; explicit 0/off/false selects shell tools.
+// Run remains unchanged. JS fetch/build bypass Docker.
+const jsTools = jsToolsEnabled();
 const usesJs = (stage) => jsTools && stage.flag !== "run";
 const inDocker = (stage) => useDocker && stage.flag !== "run" && !jsTools;
 

package/initramfs/bin/buninu-browser

@@ -0,0 +1,24 @@
+#!/bin/bun
+// Keep distribution resource setup and the offline casty launcher outside the
+// npm package, so a later `bun i` can replace that package without losing them.
+import { resolve, join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { ensureBrowserResources } from "../lib/browser-resources.js";
+
+const root = resolve(import.meta.dir, "..");
+const modules = join(root, "usr/lib/node_modules");
+const browser = join(modules, "buninu-browser");
+ensureBrowserResources(browser, root);
+const entry = join(browser, "index.js");
+const { chooseFrontend } = await import(pathToFileURL(entry).href);
+const args = process.argv.slice(2);
+const choice = chooseFrontend(args);
+const casty = choice.frontend === "casty";
+const child = Bun.spawn({
+  cmd: [process.execPath, casty ? join(modules, "@drxiaozhi/casty/index.js") : entry,
+    ...(casty ? choice.args : args)],
+  env: casty ? { ...process.env, CASTY_BROWSER: join(browser, "buninu-browser.js") } : process.env,
+  stdio: ["inherit", "inherit", "inherit"],
+});
+for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) process.on(signal, () => child.kill(signal));
+process.exit(await child.exited);

package/initramfs/bin/jspinyin

@@ -0,0 +1,12 @@
+#!/bin/bun
+// Use the distribution's jsmdcui instead of the package's `bun x` launcher.
+import { resolve } from "node:path";
+
+const root = resolve(import.meta.dir, "..");
+const child = Bun.spawn({
+  cmd: [process.execPath, resolve(root, "buninu/apps/jsmdcui/src/index.js"), "--tui",
+    ...process.argv.slice(2), resolve(root, "usr/lib/node_modules/@drxiaozhi/jspinyin/im.md")],
+  stdio: ["inherit", "inherit", "inherit"],
+});
+for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) process.on(signal, () => child.kill(signal));
+process.exit(await child.exited);

package/initramfs/bin/jspulse

@@ -0,0 +1,2 @@
+#!/bin/bun
+import "../usr/lib/node_modules/@drxiaozhi/jspulse/jspulse.js";

package/initramfs/bin/tar

@@ -5,6 +5,8 @@ import { lstat, readdir } from "node:fs/promises";
 import { linkSync, mkdirSync, rmSync, symlinkSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
 import { showDocument } from "../lib/document.js";
+import { extractStripped } from "../lib/tar-strip.js";
+import { excludeMatcher } from "../lib/tar-exclude.js";
 
 const fail = (message) => {
   console.error(`tar: ${message}`);
@@ -22,7 +24,7 @@ Try 'tar --help' for the full manual.`);
   process.exit(2);
 };
 
-const options = { operation: null, archive: null, directory: ".", compression: null, verbose: false, operands: [] };
+const options = { operation: null, archive: null, directory: ".", compression: null, verbose: false, operands: [], strip: 0, excludes: [] };
 const argv = process.argv.slice(2);
 if (argv.length === 0) usage();
 const take = (index, option) => {
@@ -41,14 +43,20 @@ for (let index = 0; index < argv.length; index++) {
   }
   if (argument === "--zstd") { options.compression = "zstd"; continue; }
   if (argument === "--gzip") { options.compression = "gzip"; continue; }
+  if (argument === "--strip-components" || argument.startsWith("--strip-components=")) {
+    const value = argument === "--strip-components" ? take(index++, argument) : argument.slice(19);
+    if (!/^\d+$/.test(value) || !Number.isSafeInteger(Number(value))) {
+      fail("--strip-components requires a non-negative safe integer");
+    }
+    options.strip = Number(value);
+    continue;
+  }
   // GNU tar compatibility used by js-udocker. Bun.Archive never restores
   // ownership or permissions, and extraction replaces existing files, so
   // these options already describe its normal extraction behaviour.
   if (argument === "--no-same-owner" || argument === "--no-same-permissions" || argument === "--overwrite") continue;
-  // Bun.Archive does not extract device nodes. js-udocker separately removes
-  // whiteout files after extraction, so its excludes are safe no-ops here.
-  if (argument === "--exclude") { take(index++, argument); continue; }
-  if (argument.startsWith("--exclude=")) continue;
+  if (argument === "--exclude") { options.excludes.push(take(index++, argument)); continue; }
+  if (argument.startsWith("--exclude=")) { options.excludes.push(argument.slice(10)); continue; }
   if (argument === "-C" || argument === "--directory") {
     options.directory = take(index++, argument);
     continue;
@@ -90,6 +98,7 @@ for (let index = 0; index < argv.length; index++) {
 
 if (!options.operation) fail("one of -c, -x, or -t is required");
 if (!options.archive) fail("an archive must be specified with -f");
+const excluded = excludeMatcher(options.excludes);
 
 const archiveBytes = async () => {
   const bytes = options.archive === "-"
@@ -201,6 +210,8 @@ const scanEntries = (bytes) => {
     const target = extended.linkpath ?? longTarget ?? text(block, 157, 100);
     entries.push({
       name: name.replace(/^\.\//, ""),
+      archiveName: name,
+      dataOffset: offset,
       kind: entryKinds[flag] ?? "file",
       target,
       size,
@@ -281,6 +292,28 @@ const restoreLinks = (entries) => {
   }
 };
 
+// Opt-in path only: keep the existing Bun.Archive extraction unchanged for
+// ordinary extraction and --strip-components=0 without excludes. Reuse the
+// scanned-entry extractor for excludes: no glob whitelist can accidentally
+// reinterpret literal metacharacters in retained archive names.
+if (options.operation === "x" && (options.strip > 0 || options.excludes.length)) {
+  try {
+    const bytes = tarBytes(await archiveBytes());
+    const entries = scanEntries(bytes);
+    if (!entries) throw new Error("invalid tar archive");
+    const wanted = options.operands.length ? patterns().map((pattern) => new Bun.Glob(pattern)) : null;
+    const members = entries.filter((entry) => !excluded(entry.name)
+      && !(entry.kind === "hardlink" && excluded(entry.target))
+      && (!wanted || wanted.some((glob) => glob.match(entry.name))));
+    extractStripped(bytes, members, options.directory, options.strip, {
+      verbose: options.verbose, filtered: options.operands.length > 0 || options.excludes.length > 0,
+    });
+  } catch (error) {
+    fail(error?.message || String(error));
+  }
+  process.exit(0);
+}
+
 if (options.operation === "x" || options.operation === "t") {
   let archive;
   try {
@@ -299,7 +332,7 @@ if (options.operation === "x" || options.operation === "t") {
       .map(([name, file]) => ({ name, kind: "file", target: "", size: file.size, mode: 0o644, mtime: file.lastModified }));
 
   if (options.operation === "t") {
-    for (const entry of members) {
+    for (const entry of members.filter((entry) => !excluded(entry.name))) {
       console.log(options.verbose ? verboseListing(entry) : entry.name);
     }
   } else {
@@ -321,6 +354,7 @@ const root = resolve(options.directory);
 const inputs = {};
 
 const add = async (diskPath, archivePath) => {
+  if (excluded(archivePath)) return;
   const info = await lstat(diskPath);
   if (info.isSymbolicLink()) fail(`${archivePath}: creating symbolic links is not supported by Bun.Archive`);
   if (info.isDirectory()) {

package/initramfs/bin/top

@@ -2,6 +2,7 @@
 // top — periodically render snapshots and process lines supplied by ps.
 
 import { showDocument } from "../lib/document.js";
+import { memoryText } from "../lib/top-memory.js";
 import {
   CLOCK_TICKS,
   formatProcessHeader,
@@ -20,13 +21,6 @@ const uptimeText = (seconds) => {
   return `${days ? `${days} day${days === 1 ? "" : "s"}, ` : ""}${hours}:${String(minutes).padStart(2, "0")}`;
 };
 
-const memoryText = (memory) => {
-  const total = memory.MemTotal ?? 0;
-  const free = memory.MemFree ?? 0;
-  const cache = (memory.Buffers ?? 0) + (memory.Cached ?? 0) + (memory.SReclaimable ?? 0);
-  return `MiB Mem : ${(total / 1024).toFixed(1)} total, ${(free / 1024).toFixed(1)} free, ${((total - free - cache) / 1024).toFixed(1)} used, ${(cache / 1024).toFixed(1)} buff/cache`;
-};
-
 const intervalRows = (snapshot, previous) => {
   if (!previous) return snapshot.processes;
   const elapsed = Math.max(0.001, (snapshot.at - previous.at) / 1000);

package/initramfs/buninu/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 0.4.19 - 2026-10-12
+
+- Sync bunmsh to 0.3.11: more POSIX syntax
+
 ## 0.4.18 - 2026-09-29
 
 - Sync jsgotty to 1.1.14: Kitty for Windows

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

@@ -2,6 +2,34 @@
 
 All notable user-visible changes to bunmsh are documented here.
 
+## [0.3.11] - 2026-10-12
+
+### Fixed
+
+- Keep multiline quoted words, command substitutions and here-documents
+  together when parsing compound-command bodies, rather than treating their
+  continuation lines as separate commands or compound keywords.
+
+- Accept additional `if`/`elif` and `while`/`until` header layouts, including
+  `then` or `do` on the following line, and execute commands placed on the
+  same line after `then`.
+
+- Improve comment handling in compound keyword and case-arm scanning, and
+  include nearby source text in several compound-syntax error messages.
+
+### Added
+
+- Initial support for parenthesized subshell groups, executed in a child
+  bunmsh with inherited shell state, including groups embedded in command
+  sequences and leading groups followed by `&&`, `||` or `;`.
+  Subshell redirection is still limited: the leading-group path handles
+  discarding stdout/stderr to `/dev/null`, but does not yet implement
+  general file redirection or descriptor duplication.
+
+- Recognize general numeric output-descriptor duplication syntax such as
+  `3>&1`. Only the existing `1>&2` and `2>&1` handling is implemented for
+  ordinary commands; other numeric pairs are currently accepted but ignored.
+
 ## [0.3.10] - 2026-09-29
 
 ### Fixed

package/initramfs/buninu/apps/bunmsh/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunmsh",
-  "version": "0.3.10",
+  "version": "0.3.11",
   "description": "Cross-platform command shell for Bun JavaScript",
   "license": "MIT",
   "type": "module",

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

@@ -806,11 +806,13 @@ async function main(argv) {
 
   if (command !== null) {
     const name = argv[i] ?? "bunmsh";
-    const state = createState({
-      args: [name, ...argv.slice(i + 1)],
-      mouseTracking: forceMouse || undefined,
-      pathSearch: builtinOnly ? false : undefined,
-    });
+    const state = process.env.BUNMSH_INTERNAL_PIPELINE_STATE
+      ? pipelineChildState()
+      : createState({
+          args: [name, ...argv.slice(i + 1)],
+          mouseTracking: forceMouse || undefined,
+          pathSearch: builtinOnly ? false : undefined,
+        });
     const result = await execute(command, state);
     return state.exitRequested ? state.exitStatus : result.status;
   }