buninu-linux 0.11.56 → 0.14.57

package/initramfs/usr/share/doc/buninu-linux/ping.md

@@ -0,0 +1,91 @@
+# ping — send ICMP echo requests
+
+`ping` sends real IPv4 ICMP or IPv6 ICMPv6 echo requests through Bun FFI.
+It does not execute a system ping, open a TCP connection, or use an HTTP probe.
+
+```sh
+ping [-4|-6] [-nqD] [-c COUNT] [-i SECONDS] [-W SECONDS]
+     [-w SECONDS] [-s BYTES] [-t TTL] [-I ADDRESS|INTERFACE] DESTINATION
+ping --help
+```
+
+| Option | Meaning |
+|---|---|
+| `-c COUNT` | Stop after COUNT requests and their replies/timeouts. Default: 4 requests, then exit. |
+| `-i SECONDS` | Send interval, default 1 second; fractional values supported, minimum 0.002 seconds. |
+| `-W SECONDS` | Per-request reply timeout, default 2 seconds; fractional values supported. |
+| `-w SECONDS` | Overall probing deadline, including outstanding requests. DNS resolution happens first. |
+| `-s BYTES` | Payload size, default 56; 0–65507 bytes. The ICMP header adds 8 bytes. |
+| `-t TTL` | IPv4 TTL or IPv6 hop limit, 1–255; default 64. |
+| `-I ADDRESS` | Bind a source IPv4/IPv6 address. |
+| `-I INTERFACE` | Bind an interface such as `eth0` or `wlan0`; OS permissions may be required. |
+| `-4`, `-6` | Select IPv4 or IPv6. Numeric destinations infer their family; hostnames default to IPv4. |
+| `-n` | Numeric reply addresses (currently always used; no reverse DNS). |
+| `-q` | Print only the initial line and final statistics. |
+| `-D` | Add Unix timestamps to per-packet output. |
+| `-h`, `--help` | Show this document. |
+
+Short options can be combined (`-nq`) and values attached (`-c3`). Use `--`
+to end option parsing. Unknown options are rejected rather than ignored.
+
+```sh
+ping -c 4 1.1.1.1
+ping -c 3 localhost
+ping -6 -c 3 ::1
+ping -n -c 10 -i 0.2 -W 1 -s 1200 192.168.1.1
+ping -q -w 5 192.168.1.1
+ping -I eth0 -c 3 192.168.1.1
+```
+
+Statistics include transmitted/received counts, loss and RTT min/average/max/
+standard deviation. Ctrl-C prints statistics and closes the socket. Exit status
+is 0 if any reply arrived, 1 if none arrived (or a combined `-c`/`-w` deadline
+prevented receiving the requested count), and 2 for argument/setup/system errors.
+RTT is measured by the Bun process, so event-loop scheduling affects it.
+
+The preferred socket is an unprivileged ICMP datagram (ping) socket. If the OS
+refuses that socket, a raw ICMP socket is attempted; this normally requires root
+or `CAP_NET_RAW`. Linux controls datagram access with `ping_group_range`, and
+Android may impose additional restrictions. The command does not change system
+permissions. Replies are matched by identifier, sequence and payload; IPv4
+checksums are checked. Concurrent outstanding probes are supported. Datagram
+replies do not expose their received TTL through this implementation, so it is
+not printed; raw IPv4 replies do include TTL.
+
+Supported runtimes: 64-bit Linux (glibc or musl) and native Android/Termux
+(bionic), on x86_64 or aarch64. `/lib/dlopen.js` chooses libc automatically:
+
+- Android: `libc.so`, then the APEX and `/system/lib64` bionic paths; `__errno`.
+- Linux glibc runtime: `libc.so.6`, then architecture-specific `/lib` and
+  `/usr/lib` glibc paths; `__errno_location`.
+- Linux musl runtime: the adjacent `libc.musl-<arch>.so.1`, its soname,
+  `/lib/libc.musl-<arch>.so.1`, `/lib/ld-musl-<arch>.so.1`, then `libc.so`;
+  `__errno_location`.
+- Search stays within the runtime ABI: loading musl into glibc can crash on
+  errno/TLS access.
+- `BUNINU_LIBC=/absolute/path` overrides the search. A bad override fails
+  explicitly rather than silently selecting a different library. Symbols resolve
+  on first use: an unavailable mount symbol does not prevent ping from using
+  the socket symbols. An explicit override is not rejected based on its filename;
+  matching the runtime ABI remains the caller's responsibility.
+
+Windows requires a separate `iphlpapi.dll` ICMP backend and is not implemented.
+Flood/adaptive modes, IPv4 record-route/timestamps, reverse DNS, broadcast ping,
+and IPv6 scoped address notation (`fe80::1%eth0`) are not implemented.
+
+## Tests
+
+```sh
+bun test test/ping.test.js test/libc.test.js
+```
+
+These compare local IPv4/IPv6 echo replies, payload sizes, counts, quiet output,
+source selection, deadlines and exit codes against the installed system ping.
+RTT values are not expected to match. A missing system ping or unavailable
+loopback ICMP support skips the corresponding network comparisons. Older
+Android systems have a separate `ping6` and a 200 ms interval restriction; the
+reference tests accommodate those without limiting this command's options.
+Packet validation, argument errors, fast intervals and Ctrl-C also have tests.
+
+References: [Linux ICMP sockets](https://man7.org/linux/man-pages/man7/icmp.7.html),
+[Android errno](https://android.googlesource.com/platform/bionic/+/master/libc/include/errno.h).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buninu-linux",
-  "version": "0.11.56",
+  "version": "0.14.57",
   "description": "A Linux distribution running Bun as PID 1 with the Buninu userspace.",
   "type": "module",
   "main": "./index.js",
@@ -37,6 +37,6 @@
     "fetch": "./index.js -f",
     "pack": "./index.js -b",
     "start": "./index.js -r",
-    "check": "for f in ./index.js ./initramfs/init.js ./initramfs/lib/document.js ./initramfs/lib/dlopen.js ./initramfs/lib/fbdev.js ./initramfs/lib/canvas.js ./initramfs/lib/bunterm/glyphs.js ./initramfs/lib/bunterm/renderer.js ./initramfs/lib/bunterm/images.js ./initramfs/lib/bunterm/input.js ./initramfs/lib/bunterm/mouse.js ./initramfs/lib/bunterm/terminal.js ./initramfs/lib/modprobe.js ./initramfs/lib/power.js ./initramfs/bin/bunterm ./initramfs/bin/chroot ./initramfs/bin/mount ./initramfs/bin/umount ./initramfs/bin/ip ./initramfs/bin/ps ./initramfs/bin/top ./initramfs/bin/poweroff ./initramfs/bin/reboot ./initramfs/bin/tar ./initramfs/bin/stripansi; do node --check \"$f\" || exit 1; done"
+    "check": "for f in ./index.js ./initramfs/init.js ./initramfs/lib/document.js ./initramfs/lib/dlopen.js ./initramfs/lib/ping.js ./initramfs/lib/dhcp.js ./initramfs/lib/dhcp-transport.js ./initramfs/lib/dhclient.js ./initramfs/lib/dhcp-start.js ./initramfs/lib/fbdev.js ./initramfs/lib/canvas.js ./initramfs/lib/bunterm/glyphs.js ./initramfs/lib/bunterm/renderer.js ./initramfs/lib/bunterm/images.js ./initramfs/lib/bunterm/input.js ./initramfs/lib/bunterm/mouse.js ./initramfs/lib/bunterm/terminal.js ./initramfs/lib/modprobe.js ./initramfs/lib/power.js ./initramfs/bin/bunterm ./initramfs/bin/chroot ./initramfs/bin/mount ./initramfs/bin/umount ./initramfs/bin/ip ./initramfs/bin/ping ./initramfs/bin/dhclient ./initramfs/bin/ps ./initramfs/bin/top ./initramfs/bin/poweroff ./initramfs/bin/reboot ./initramfs/bin/tar ./initramfs/bin/stripansi; do node --check \"$f\" || exit 1; done"
   }
 }

package/scripts/arch.js

@@ -16,8 +16,8 @@ export const rootDir = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 
 const pins = {
   x86_64: {
-    linuxVirtSha256: "755deb045cfeb8c2bcaa2b2febe01ab2101d747921e64d4cd54d0312321e8d5d",
-    linuxLtsSha256: "b0d8cc4d7e031b5619221e7978920d051bf1dd1e335f6d05d03964b2285fc3b4",
+    linuxVirtSha256: "414aa2572ef88164b1af9905fa6dfbe863bf50f6130d895d57282dea3e15f7b9",
+    linuxLtsSha256: "7614556471859956a436b95813daf409b444aa849ec899178b404e828c5a9d98",
     muslSha256: "573712e2f49c15bfc20a2699f204acdfc74c772722b15e7353d768057fae0e71",
     stubSha256: "8e64a5a3afee5f930e6e6716be726dc6d405530ac7f8fa5be6251dae68671ec9",
     libstdcppSha256: "14c987b556f5385a5db18376e788c75f37d85321b8dc1920d926ea7daac1d6f6",
@@ -32,8 +32,8 @@ const pins = {
     serialMajor: 4,
   },
   aarch64: {
-    linuxVirtSha256: "e3839bfd751ff0a4421484f712b9b29efb514024523736a0ef62521521571b12",
-    linuxLtsSha256: "795bcd49840be7f4ff9566f5f669201bd41202376a455b720a98eb814f0e72f8",
+    linuxVirtSha256: "b3820fee22e0366a15f7c139e5bc00348e333f3e7f77802271df7ded795aee4f",
+    linuxLtsSha256: "67b8f61c5cfb6ac9b5a65cb1610b67d467e6c4ffc17e7d29dbea4bd8c447ff32",
     muslSha256: "5e9674b7f41152fe2119093b5cb4c13eaaadb19c2d5422b2d7267913e663ee6e",
     stubSha256: "a1823d2d7082db555d528f82c1809f276c818aeb5b40f198f4565f104e055c38",
     libstdcppSha256: "2302e766d4e4926038ec166ecb85837ee884576115236ddb565e3a5fca4a11d7",
@@ -67,7 +67,7 @@ export const config = ({
   // The Alpine repository keeps only the newest build of a package, so a pin
   // stops downloading when Alpine bumps it; the hashes then fail loudly.
   const alpineBase = `${mirror}/v3.24/main/${arch}`;
-  const kernelVersion = "6.18.56";
+  const kernelVersion = "6.18.57";
   const kernelRelease = `${kernelVersion}-0-${flavor}`;
   const bunVersion = "1.4.2";
   const downloadsDir = join(rootDir, "downloads", arch);

package/scripts/arch.sh

@@ -44,7 +44,7 @@ fi
 alpine_mirror=${ALPINE_MIRROR:-https://dl-cdn.alpinelinux.org/alpine}
 alpine_base="$alpine_mirror/v3.24/main/$arch"
 
-kernel_version=6.18.56
+kernel_version=6.18.57
 kernel_release="$kernel_version-0-$linux_flavor"
 linux_package="linux-$linux_flavor-$kernel_version-r0.apk"
 musl_package=musl-1.2.6-r2.apk
@@ -63,8 +63,8 @@ musl_libc="libc.musl-$arch.so.1"
 
 case $arch in
     x86_64)
-        linux_virt_sha256=755deb045cfeb8c2bcaa2b2febe01ab2101d747921e64d4cd54d0312321e8d5d
-        linux_lts_sha256=b0d8cc4d7e031b5619221e7978920d051bf1dd1e335f6d05d03964b2285fc3b4
+        linux_virt_sha256=414aa2572ef88164b1af9905fa6dfbe863bf50f6130d895d57282dea3e15f7b9
+        linux_lts_sha256=7614556471859956a436b95813daf409b444aa849ec899178b404e828c5a9d98
         musl_sha256=573712e2f49c15bfc20a2699f204acdfc74c772722b15e7353d768057fae0e71
         stub_sha256=8e64a5a3afee5f930e6e6716be726dc6d405530ac7f8fa5be6251dae68671ec9
         libstdcpp_sha256=14c987b556f5385a5db18376e788c75f37d85321b8dc1920d926ea7daac1d6f6
@@ -82,8 +82,8 @@ case $arch in
         serial_major=4
         ;;
     aarch64)
-        linux_virt_sha256=e3839bfd751ff0a4421484f712b9b29efb514024523736a0ef62521521571b12
-        linux_lts_sha256=795bcd49840be7f4ff9566f5f669201bd41202376a455b720a98eb814f0e72f8
+        linux_virt_sha256=b3820fee22e0366a15f7c139e5bc00348e333f3e7f77802271df7ded795aee4f
+        linux_lts_sha256=67b8f61c5cfb6ac9b5a65cb1610b67d467e6c4ffc17e7d29dbea4bd8c447ff32
         musl_sha256=5e9674b7f41152fe2119093b5cb4c13eaaadb19c2d5422b2d7267913e663ee6e
         stub_sha256=a1823d2d7082db555d528f82c1809f276c818aeb5b40f198f4565f104e055c38
         libstdcpp_sha256=2302e766d4e4926038ec166ecb85837ee884576115236ddb565e3a5fca4a11d7

package/scripts/modules.js

@@ -21,6 +21,7 @@ export const requests = ({ arch, flavor, real }) => [
     "failover",
     "net_failover",
     "virtio_net",
+    "af_packet", // DHCP before an interface has an IPv4 address
   ]),
   ...optional([
     "virtio_pci",

package/scripts/npm-packages.md

@@ -1,19 +1,19 @@
 # npm packages
 # Latest versions checked on 2026-10-11; SHA-256 pins verified against registry SHA-512 integrity.
-# buninu-browser updated and verified on 2026-10-12.
-# casty 1.3.6 and buninu-land 0.1.2 verified on 2026-10-16.
+# buninu-browser 0.2.4 and buninu-land 0.1.4 verified on 2026-10-18.
+# casty 1.3.7 verified on 2026-10-16.
 
-"buninu-browser@0.2.3":
-  - https://registry.npmjs.org/buninu-browser/-/buninu-browser-0.2.3.tgz
-  - sha256:0f7c9cd9df689d7b0900fdf3172851125ebd8aba12bed555be7e091d427146e8
+"buninu-browser@0.2.4":
+  - https://registry.npmjs.org/buninu-browser/-/buninu-browser-0.2.4.tgz
+  - sha256:247c1ae9644b5016d1dc3f74d1c6c18a986e3961b1d86d2497862e4007bc50aa
 
-"buninu-land@0.1.2":
-  - https://registry.npmjs.org/buninu-land/-/buninu-land-0.1.2.tgz
-  - sha256:0b682e1d57f953d9fa9415369c320e4e35bf7575c2859673c26a0789f5369490
+"buninu-land@0.1.4":
+  - https://registry.npmjs.org/buninu-land/-/buninu-land-0.1.4.tgz
+  - sha256:5cda65c60a7af8c7a05ec519a254e0af3f9913ea94f6ae493e5ddc93a8d87407
 
-"@drxiaozhi/casty@1.3.6":
-  - https://registry.npmjs.org/@drxiaozhi/casty/-/casty-1.3.6.tgz
-  - sha256:2b5f84e3a63c2c16fa92dc88faa43eec54edc2fe69154e5270af3cd9e7f472b8
+"@drxiaozhi/casty@1.3.7":
+  - https://registry.npmjs.org/@drxiaozhi/casty/-/casty-1.3.7.tgz
+  - sha256:acc0641fb68c00222ba1cd2b7520ba99c269b996e145e82f18466be4d126b811
 
 "@drxiaozhi/jspulse@0.2.1":
   - https://registry.npmjs.org/@drxiaozhi/jspulse/-/jspulse-0.2.1.tgz

package/scripts/stage-npm.js

@@ -1,7 +1,7 @@
 // Assemble fetched packages in a disposable pack staging tree, never in the
 // source initramfs. No registry access, dependency resolution or lifecycle code.
 import { createHash } from "node:crypto";
-import { chmodSync, existsSync, mkdirSync, readFileSync, symlinkSync, writeFileSync } from "node:fs";
+import { chmodSync, existsSync, mkdirSync, readFileSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
 import { join, relative, resolve } from "node:path";
 import { spawnSync } from "node:child_process";
 import { jsRuntime, rootDir, runIfMain } from "./arch.js";
@@ -34,6 +34,13 @@ export function stageNpm(staging, { packages = npmPackages, downloadsDir = npmDo
       "--exclude=package/usr/lib/canvaskit", "--exclude=package/usr/share/fonts");
     const result = spawnSync(runtime, args, { stdio: "inherit" });
     if (result.status !== 0) throw new Error(`npm extraction failed: ${pkg.name}`);
+    if (pkg.name === "buninu-land") {
+      const wasm = join(destination, "vendor/canvaskit/canvaskit.wasm");
+      const shared = join(staging, "lib/canvaskit/canvaskit.wasm");
+      const systemWasm = existsSync(shared) ? shared : join(rootDir, "initramfs/lib/canvaskit/canvaskit.wasm");
+      // Deduplicate only byte-identical releases; future differing WASM stays bundled.
+      if (existsSync(wasm) && existsSync(systemWasm) && readFileSync(wasm).equals(readFileSync(systemWasm))) unlinkSync(wasm);
+    }
     const info = JSON.parse(readFileSync(join(destination, "package.json"), "utf8"));
     if (info.name !== pkg.name || info.version !== pkg.version) throw new Error(`npm identity mismatch: ${pkg.name}`);
     const entries = typeof info.bin === "string" ? { [pkg.name.split("/").pop()]: info.bin } : info.bin ?? {};

package/scripts/stage-npm.sh

@@ -45,7 +45,15 @@ for ((i=0; i<${#names[@]}; i++)); do
     extra=()
     [[ "$name" != buninu-browser ]] || extra+=(--exclude=package/usr/lib/canvaskit --exclude=package/usr/share/fonts)
     tar -xf "downloads/npm/${archives[i]}" -C "$destination" --strip-components=1 "${extra[@]}"
-    # Bin entries of the four SHA-pinned packages; no package scripts execute.
+    if [[ "$name" == buninu-land ]]; then
+        wasm="$destination/vendor/canvaskit/canvaskit.wasm"
+        shared="$staging/lib/canvaskit/canvaskit.wasm"
+        [[ -f "$shared" ]] || shared=initramfs/lib/canvaskit/canvaskit.wasm
+        if [[ -f "$wasm" && -f "$shared" ]] && cmp -s "$wasm" "$shared"; then
+            rm -- "$wasm"
+        fi
+    fi
+    # Bin entries of the SHA-pinned packages; no package scripts execute.
     bin=${name##*/}; entry=index.js
     [[ "$name" != @drxiaozhi/jspulse ]] || entry=jspulse.js
     chmod 755 "$destination/$entry"

package/test/bunterm-image-bytes.test.js

@@ -0,0 +1,55 @@
+import { expect, test } from 'bun:test';
+import { createRequire } from 'node:module';
+import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { deflateSync } from 'node:zlib';
+import { decodeImage } from '../initramfs/lib/bunterm/images.js';
+const { KittyGraphicsParser } = createRequire(import.meta.url)('../initramfs/buninu/apps/jsgotty/gotty.js');
+const png = Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+aOc8AAAAASUVORK5CYII=', 'base64');
+function parse(parser, control, payload = '') {
+  const { events } = parser.consume(Buffer.from(`\x1b_G${control};${payload}\x1b\\`));
+  return parser.parsePacket(events[0].packet, { row: 1, col: 1 });
+}
+async function checkDecode(image) {
+  const decoded = {};
+  let received;
+  expect(await decodeImage({ MakeImageFromEncoded(bytes) { received = bytes; return decoded; } }, image)).toBe(decoded);
+  // Identity verifies that rendering neither copies nor base64-roundtrips bytes.
+  expect(received).toBe(image.data);
+  expect(received.equals(png)).toBe(true);
+}
+test('binary parser assembles inline chunks and renderer consumes the same bytes', async () => {
+  const parser = new KittyGraphicsParser({ binaryData: true });
+  const encoded = png.toString('base64');
+  expect(parse(parser, 'a=T,f=100,i=1,m=1', encoded.slice(0, 32))).toBeNull();
+  const graphic = parse(parser, 'm=0', encoded.slice(32));
+  await checkDecode(graphic.image);
+  expect(parse(parser, 'a=p,i=1').image).toBe(graphic.image);
+});
+test('binary file transfer reads bytes without re-encoding; compressed inline also works', async () => {
+  const dir = mkdtempSync(join(tmpdir(), 'bunterm-image-bytes-'));
+  try {
+    const path = join(dir, 'frame.png');
+    writeFileSync(path, png);
+    const parser = new KittyGraphicsParser({ binaryData: true });
+    await checkDecode(parse(parser, 'a=T,t=f,f=100,i=1', Buffer.from(path).toString('base64')).image);
+    await checkDecode(parse(parser, 'a=T,f=100,o=z,i=2', deflateSync(png).toString('base64')).image);
+  } finally { rmSync(dir, { recursive: true, force: true }); }
+});
+test('default parser and legacy renderer callers retain base64 compatibility', async () => {
+  const image = parse(new KittyGraphicsParser(), 'a=T,f=100,i=1', png.toString('base64')).image;
+  expect(image.data).toBe(png.toString('base64'));
+  let received;
+  await decodeImage({ MakeImageFromEncoded(bytes) { received = bytes; return {}; } }, image);
+  expect(received.equals(png)).toBe(true);
+});
+test('raw RGBA bytes pass directly to CanvasKit', async () => {
+  const pixels = Buffer.from([1, 2, 3, 255]);
+  const image = parse(new KittyGraphicsParser({ binaryData: true }), 'a=T,f=32,s=1,v=1,i=3', pixels.toString('base64')).image;
+  let received;
+  await decodeImage({ ColorType: { RGBA_8888: 1 }, AlphaType: { Unpremul: 1 }, ColorSpace: { SRGB: 1 },
+    MakeImage(info, bytes, stride) { received = bytes; expect(stride).toBe(4); return {}; } }, image);
+  expect(received).toBe(image.data);
+  expect(received.equals(pixels)).toBe(true);
+});

package/test/dhcp-start.test.js

@@ -0,0 +1,67 @@
+import {test,expect} from 'bun:test';
+import {createDhcpLauncher} from '../initramfs/lib/dhcp-start.js';
+const pause=ms=>Bun.sleep(ms);
+function fakeChild(){
+ let resolve,reject,stdout;
+ const exited=new Promise((yes,no)=>{resolve=yes;reject=no;});
+ return {exited,resolve,reject,kills:[],kill(signal){this.kills.push(signal);},
+ stdout:new ReadableStream({start(c){stdout=c;}}),stderr:null,
+ output(line){stdout.enqueue(Buffer.from(line));},end(){stdout.close();}};
+}
+test('launch returns immediately, isolates spawn failures and reuses running children',async()=>{
+ const calls=[],logs=[],children=[];
+ const launch=createDhcpLauncher({spawn(args){calls.push(args);if(args.at(-1)==='bad')throw new Error('spawn denied');const child=fakeChild();children.push(child);return child;},log:s=>logs.push(s),watchdogMs:500});
+ expect(launch(['bad','eth0','eth1'])).toEqual(['eth0','eth1']);
+ expect(launch(['eth0','eth1'])).toEqual([]);expect(calls.length).toBe(3);
+ expect(calls[2]).toContain('--no-dns');expect(calls[2]).toContain('--metric');
+ expect(logs.some(s=>s.includes('spawn denied'))).toBe(true);
+ for(const child of children){child.end();child.resolve(1);}await pause(5);
+ expect(logs.some(s=>s.includes('(exit 1); other interfaces are unaffected'))).toBe(true);
+ expect(launch(['eth0'])).toEqual(['eth0']);children.at(-1).end();children.at(-1).resolve(0);
+});
+test('watchdog terminates hung acquisition and escalates if SIGTERM does not exit',async()=>{
+ const child=fakeChild(),logs=[];
+ const launch=createDhcpLauncher({spawn:()=>child,log:s=>logs.push(s),watchdogMs:10,killGraceMs:10});
+ launch(['eth0']);await pause(60);
+ expect(child.kills).toEqual(['SIGTERM','SIGKILL']);child.end();child.resolve(137);await pause(5);
+ expect(logs.some(s=>s.includes('timed out; other interfaces are unaffected'))).toBe(true);
+});
+test('successful one-shot exits and clears the watchdog',async()=>{
+ const child=fakeChild();const launch=createDhcpLauncher({spawn:()=>child,log:()=>{},watchdogMs:20,killGraceMs:5});
+ launch(['eth0']);child.output('dhclient: bound to 10.0.2.15/24, lease 86400s\n');child.end();child.resolve(0);await pause(50);
+ expect(child.kills).toEqual([]);
+});
+test('stream rejection, exit rejection, kill failure and throwing logger cannot escape',async()=>{
+ const child=fakeChild(),logs=[];
+ child.stderr=new ReadableStream({start(c){c.error(null);}});
+ child.kill=()=>{throw null;};
+ const launch=createDhcpLauncher({spawn:()=>child,log:s=>logs.push(s),watchdogMs:5,killGraceMs:5});
+ expect(()=>launch(['eth0'])).not.toThrow();await pause(30);child.end();child.reject(null);await pause(5);
+ expect(logs.some(s=>s.startsWith('[dhcp eth0] failed: timed out'))).toBe(true);
+ const bad=createDhcpLauncher({spawn(){throw null;},log(){throw new Error('console failed');}});
+ expect(()=>bad(['eth0'])).not.toThrow();expect(()=>bad(null)).not.toThrow();
+});
+
+test('usb0 success and late eth0 failure each produce one correctly attributed result',async()=>{
+ const children={eth0:fakeChild(),usb0:fakeChild()},logs=[];let stderr;
+ children.eth0.stderr=new ReadableStream({start(c){stderr=c;}});
+ const launch=createDhcpLauncher({spawn:args=>children[args.at(-1)],log:s=>logs.push(s),watchdogMs:500});
+ launch(['eth0','usb0']);
+ children.usb0.output('dhclient: bound to 192.168.42.2/24, lease 3600s\n');children.usb0.end();children.usb0.resolve(0);
+ await pause(5);
+ children.eth0.resolve(1);children.eth0.end();
+ // Exit notification precedes delivery of the error; the final result must wait.
+ await pause(5);stderr.enqueue(Buffer.from('dhclient: no DHCP lease received before timeout\n'));stderr.close();await pause(10);
+ expect(logs.filter(s=>s.includes('configured '))).toEqual(['[dhcp usb0] configured 192.168.42.2/24; command finished']);
+ expect(logs.filter(s=>s.includes('failed:'))).toEqual(['[dhcp eth0] failed: no DHCP lease received before timeout (exit 1); other interfaces are unaffected']);
+ expect(logs.some(s=>s.includes('usb0')&&s.includes('failed'))).toBe(false);
+});
+
+test('unterminated output cannot hold the result open or prevent later invocations',async()=>{
+ const children=[],logs=[];
+ const launch=createDhcpLauncher({spawn(){const c=fakeChild();children.push(c);return c;},log:s=>logs.push(s),watchdogMs:500,outputGraceMs:10});
+ launch(['usb0']);children[0].output('dhclient: bound to 192.168.42.2/24, lease 3600s\n');children[0].resolve(0);
+ await pause(30);
+ expect(logs.some(s=>s.includes('configured 192.168.42.2/24'))).toBe(true);
+ expect(launch(['usb0'])).toEqual(['usb0']);children[1].end();children[1].resolve(0);
+});

package/test/dhcp.test.js

@@ -0,0 +1,99 @@
+import {test,expect} from 'bun:test';
+import {mkdtempSync,readFileSync,writeFileSync,rmSync} from 'node:fs';
+import {tmpdir} from 'node:os';
+import {TYPE,encode,decode,leaseFrom,wrapIPv4,unwrapIPv4,checksum,DhcpClient,NakError} from '../initramfs/lib/dhcp.js';
+import {parseDhclient,Configuration,manageLease} from '../initramfs/lib/dhclient.js';
+const mac=Buffer.from('020000000001','hex');
+function reply(request,type,{ip='10.20.0.10',server=[10,20,0,1],duration=120}={}){
+ const b=Buffer.from(request.subarray(0,240));b[0]=2;Buffer.from(ip.split('.').map(Number)).copy(b,16);
+ const lease=Buffer.alloc(4);lease.writeUInt32BE(duration);
+ return Buffer.concat([b,Buffer.from([53,1,type,54,4,...server,1,4,255,255,255,0,51,4]),lease,Buffer.from([3,4,...server,6,4,1,1,1,1,255])]);
+}
+test('DHCP CLI validates options before opening sockets',()=>{
+ expect(parseDhclient(['-4','-d','-1','-v','-timeout','8','--no-dns','-H','buninu','eth0'])).toMatchObject({interface:'eth0',once:true,timeout:8,dns:false});
+ expect(parseDhclient(['usb0']).interface).toBe('usb0');
+ expect(parseDhclient(['--metric','120','usb0']).metric).toBe(120);
+ for(const args of [['--metric','32767','eth0'],[],['-6','eth0'],['-timeout','NaN','eth0'],['-r','-1','eth0'],['eth0','eth1'],['../bad']])expect(()=>parseDhclient(args)).toThrow();
+});
+test('codec validates xid, MAC, truncation, options, mask and lease timers',()=>{
+ const req=encode({type:TYPE.DISCOVER,xid:123,mac}),ack=reply(req,TYPE.ACK);
+ expect(req.length).toBeGreaterThanOrEqual(300);expect(req.readUInt16BE(10)).toBe(0x8000);
+ const parsed=decode(ack,{xid:123,mac});expect(parsed.type).toBe(TYPE.ACK);
+ expect(decode(ack,{xid:456,mac})).toBeNull();expect(decode(ack,{mac:Buffer.alloc(6)})).toBeNull();
+ expect(decode(ack.subarray(0,ack.length-3))).toBeNull();
+ expect(leaseFrom(parsed,null,1000)).toMatchObject({prefix:24,renewAt:61000,rebindAt:106000,expiresAt:121000});
+ expect(()=>leaseFrom({...parsed,mask:'255.0.255.0'},null,0)).toThrow();
+ expect(leaseFrom({...parsed,t1:200,t2:100},null,0).renewAt).toBe(60000);
+});
+test('packet transport checks header checksum, fragmentation, ports and UDP checksum',()=>{
+ const payload=reply(encode({type:1,xid:1,mac}),5);
+ const packet=wrapIPv4(payload,'10.20.0.1');packet.writeUInt16BE(67,20);packet.writeUInt16BE(68,22);
+ expect(unwrapIPv4(packet)).toEqual(payload);
+ const bad=Buffer.from(packet);bad[12]^=1;expect(unwrapIPv4(bad)).toBeNull();
+ const fragment=Buffer.from(packet);fragment.writeUInt16BE(0x2000,6);fragment.writeUInt16BE(0,10);fragment.writeUInt16BE(checksum(fragment.subarray(0,20)),10);expect(unwrapIPv4(fragment)).toBeNull();
+ packet.writeUInt16BE(123,26);expect(unwrapIPv4(packet)).toBeNull();
+});
+test('DORA retries, ignores unrelated replies, then renews and releases via unicast',async()=>{
+ let time=0,discover=0;const queue=[],sent=[];
+ const transport={send(b,server){sent.push({b,server});const t=b[242];
+   if(t===1&&++discover===1)return;
+   if(t===1){const wrong=reply(b,2);wrong.writeUInt32BE(999,4);queue.push(wrong,reply(b,2));}
+   if(t===3)queue.push(reply(b,5));
+ },receive(){return queue.shift();}};
+ const client=new DhcpClient({transport,mac,timeout:10,now:()=>time,sleep:async ms=>{time+=ms;},random:()=>.5});
+ const lease=await client.acquire();expect(lease.address).toBe('10.20.0.10');expect(discover).toBe(2);
+ time=lease.renewAt;const renewed=await client.renew(lease);expect(renewed.address).toBe(lease.address);
+ const renew=sent.at(-1);expect(renew.server).toBe('10.20.0.1');expect(renew.b.subarray(12,16)).toEqual(Buffer.from([10,20,0,10]));
+ expect(renew.b.readUInt16BE(10)).toBe(0);
+ client.release(renewed);expect(sent.at(-1).b[242]).toBe(7);expect(sent.at(-1).server).toBe(lease.server);
+});
+test('acquisition times out and NAK is surfaced during renewal',async()=>{
+ let time=0;const queue=[];
+ const client=new DhcpClient({transport:{send(){},receive:()=>queue.shift()},mac,timeout:.05,now:()=>time,sleep:async ms=>{time+=ms;}});
+ expect(await client.acquire()).toBeNull();
+ client.transport.send=b=>queue.push(reply(b,6));
+ await expect(client.renew({address:'10.20.0.10',server:'10.20.0.1',rebindAt:1000})).rejects.toBeInstanceOf(NakError);
+});
+test('configuration uses existing ip commands, preserves DNS across renewal and restores it',async()=>{
+ const dir=mkdtempSync(`${tmpdir()}/dhcp-test-`),path=`${dir}/resolv.conf`,calls=[];
+ try {
+  writeFileSync(path,'nameserver 9.9.9.9\n');
+  const config=new Configuration({interface:'eth0',dns:true,resolv:path,metric:100},async args=>calls.push(args));
+  const lease={address:'10.20.0.10',prefix:24,routers:['10.20.0.1'],dns:['1.1.1.1']};
+  await config.apply(lease);const renewed={...lease,dns:['8.8.8.8']};await config.apply(renewed,lease);
+  expect(calls[0]).toEqual(['addr','replace','10.20.0.10/24','brd','+','dev','eth0']);
+  expect(readFileSync(path,'utf8')).toContain('8.8.8.8');await config.clear(renewed);
+  expect(calls).toContainEqual(['route','replace','default','via','10.20.0.1','dev','eth0','metric','100']);
+  expect(calls).toContainEqual(['route','del','default','via','10.20.0.1','dev','eth0','metric','100']);
+  expect(readFileSync(path,'utf8')).toBe('nameserver 9.9.9.9\n');
+  await config.apply(lease);writeFileSync(path,'external edit\n');await config.clear(lease);expect(readFileSync(path,'utf8')).toBe('external edit\n');
+ }finally{rmSync(dir,{recursive:true,force:true});}
+});
+test('default invocation configures once and returns without starting renewal',async()=>{
+ const events=[],lease={address:'10.20.0.10',prefix:24,seconds:60};
+ const client={async acquire(){events.push('acquire');return lease;},renew(){throw new Error('must not renew');},release(){events.push('release');}};
+ await manageLease(client,{async apply(){events.push('apply');},async clear(){events.push('clear');}},{log:()=>{}});
+ expect(events).toEqual(['acquire','apply']);
+ expect(parseDhclient(['usb0']).once).toBe(true);
+});
+test('one-shot keeps a successful lease but cleans up failed configuration',async()=>{
+ const events=[],client={async acquire(){return {address:'10.0.0.2',prefix:24,seconds:60};},release(){events.push('release');}};
+ const config={async apply(){},async clear(){events.push('clear');}};
+ await manageLease(client,config,{once:true,log:()=>{}});expect(events).toEqual([]);
+ config.apply=async()=>{throw new Error('route failed');};
+ await expect(manageLease(client,config,{once:true,log:()=>{}})).rejects.toThrow('route failed');expect(events).toEqual(['release','clear']);
+});
+
+test('runtime libc sendto delivers a UDP datagram on loopback',async()=>{
+ const {libc,ptr,check}=await import('../initramfs/lib/dlopen.js');
+ let received;
+ const server=await Bun.udpSocket({hostname:'127.0.0.1',port:0,socket:{data(_socket,data){received=Buffer.from(data);}}});
+ const fd=check('socket',libc.symbols.socket(2,2,17));
+ try{
+  const target=Buffer.alloc(16);target.writeUInt16LE(2);target.writeUInt16BE(server.port,2);target.set([127,0,0,1],4);
+  const data=Buffer.from('dhcp transport libc probe');
+  expect(check('sendto',Number(libc.symbols.sendto(fd,ptr(data),data.length,0,ptr(target),16)))).toBe(data.length);
+  for(let i=0;i<100&&!received;i++)await Bun.sleep(5);
+  expect(received).toEqual(data);
+ }finally{libc.symbols.close(fd);server.close();}
+});

package/test/fetch-npm.test.js

@@ -23,7 +23,7 @@ const url = `http://127.0.0.1:${server.port}/archive`;
 
 test("five exact registry pins share an architecture-independent cache", () => {
   expect(npmPackages.map(({ name, version }) => `${name}@${version}`)).toEqual([
-    "buninu-browser@0.2.3", "buninu-land@0.1.2", "@drxiaozhi/casty@1.3.6",
+    "buninu-browser@0.2.4", "buninu-land@0.1.4", "@drxiaozhi/casty@1.3.7",
     "@drxiaozhi/jspulse@0.2.1", "@drxiaozhi/jspinyin@0.1.1",
   ]);
   expect(basename(npmDownloadsDir)).toBe("npm");

package/test/libc.test.js

@@ -0,0 +1,41 @@
+import {test,expect} from 'bun:test';
+import {libc,libcPath,errno,strerror,SysError,withInetSocket} from '../initramfs/lib/dlopen.js';
+import {spawnSync} from 'node:child_process';
+test('host libc loads automatically and exposes the platform errno',()=>{
+ expect(libc.symbols.close(-1)).toBe(-1);expect(libcPath.length).toBeGreaterThan(0);expect(errno()).toBe(9);expect(strerror(9)).toContain('descriptor');expect(new SysError('close').errno).toBe(9);
+ if(process.platform==='android')expect(libcPath).toBe('libc.so');
+});
+test('an explicit invalid libc path fails instead of silently falling back',()=>{
+ const r=spawnSync(process.execPath,['-e',`const {libc}=await import(${JSON.stringify(new URL('../initramfs/lib/dlopen.js',import.meta.url).href)});libc.symbols.close(-1)`],{env:{...process.env,BUNINU_LIBC:'/nonexistent/buninu-libc.so'},encoding:'utf8'});
+ expect(r.status).not.toBe(0);expect(r.stderr).toContain('/nonexistent/buninu-libc.so');
+});
+
+test('existing libc socket/ioctl helper still queries loopback without sysfs',()=>{
+ const request=Buffer.alloc(40);request.write('lo');
+ withInetSocket(ioctl=>ioctl(0x8933,request,'SIOCGIFINDEX'));
+ expect(request.readInt32LE(16)).toBeGreaterThan(0);
+});
+
+test('manual library resolves only requested symbols and keeps working after a missing symbol',()=>{
+ const moduleURL=new URL('../initramfs/lib/dlopen.js',import.meta.url).href;
+ const script=`
+ import {mock} from 'bun:test';
+ const ffi=await import('bun:ffi');
+ const calls=[];
+ mock.module('bun:ffi',()=>({...ffi,dlopen(path,symbols){
+   if(path!=='/manual/partial.so')throw new Error('unexpected fallback');
+   const name=Object.keys(symbols)[0];calls.push(name);
+   if(name!=='close')throw new Error('missing '+name);
+   return {symbols:{close:()=>7},close(){}};
+ }}));
+ const {libc}=await import(${JSON.stringify(moduleURL)});
+ if(calls.length)throw new Error('eager symbol resolution');
+ if(libc.symbols.close(0)!==7)throw new Error('supported symbol failed');
+ try {libc.symbols.mount;throw new Error('missing symbol accepted');}
+ catch(e){if(!e.message.includes('missing mount'))throw e;}
+ if(libc.symbols.close(0)!==7)throw new Error('missing symbol poisoned library');
+ if(calls.filter(x=>x==='close').length!==1)throw new Error('symbol not cached');
+ `;
+ const r=spawnSync(process.execPath,['-e',script],{env:{...process.env,BUNINU_LIBC:'/manual/partial.so'},encoding:'utf8'});
+ expect(r.stderr).toBe('');expect(r.status).toBe(0);
+});

package/test/ping.test.js

@@ -0,0 +1,80 @@
+import {test,expect} from 'bun:test';
+import {spawnSync} from 'node:child_process';
+import {resolve} from 'node:path';
+import {parsePing,checksum,echoPacket,isEchoReply} from '../initramfs/lib/ping.js';
+const command=resolve(import.meta.dir,'../initramfs/bin/ping');
+const system=Bun.which('ping');
+const separatePing6=Bun.which('ping6');
+const supports6=system&&spawnSync(system,['-6','-c','1','-W','1','::1'],{encoding:'utf8',timeout:2000}).status===0;
+const run=(args,reference=false)=>{
+ const usePing6=reference&&args.includes('-6')&&!supports6&&separatePing6;
+ const executable=reference?(usePing6?separatePing6:system):process.execPath;
+ const options=reference?args.filter(a=>a!=='-4'&&(!usePing6||a!=='-6')):[command,...args];
+ return spawnSync(executable,options,{encoding:'utf8',timeout:6000,env:{...process.env,LC_ALL:'C'}});
+};
+const summary=s=>{const m=/(\d+) packets transmitted, (\d+) (?:packets )?received,.*?(\d+)% packet loss/.exec(s);return m?m.slice(1).map(Number):null};
+const probe=system?run(['-4','-c','1','-W','1','127.0.0.1'],true):null;
+const available=probe?.status===0;
+
+test('ping parses common flags and rejects malformed arguments',()=>{
+ expect(parsePing(['-4nqD','-c3','-i','.2','-W','1','-w','5','-s','17','-t64','-I','lo','localhost'])).toMatchObject({family:4,count:3,interval:.2,timeout:1,deadline:5,size:17,ttl:64,source:'lo',host:'localhost',quiet:true,timestamp:true});
+ expect(parsePing(['localhost']).count).toBe(4);
+ expect(parsePing(['-6','--','::1']).family).toBe(6);
+ for(const args of [[],['-c'],['-c','0','localhost'],['-c','Infinity','localhost'],['-W','NaN','localhost'],['-s','65508','localhost'],['-s','-1','localhost'],['-t','256','localhost'],['-i','0','localhost'],['-w','0','localhost'],['-Z','localhost'],['a','b']])expect(()=>parsePing(args)).toThrow();
+ expect(parsePing(['--help']).help).toBe(true);
+ expect(run(['-c','0','127.0.0.1']).status).toBe(2);
+});
+
+test('ICMP checksum, reply identity, data integrity and raw IPv4 header validation',()=>{
+ for(const size of [0,1,17,56]){
+  const request=echoPacket(4,123,7,size);expect(checksum(request)).toBe(0);
+  const reply=Buffer.from(request);reply[0]=0;reply.writeUInt16BE(0,2);reply.writeUInt16BE(checksum(reply),2);
+  const info={family:4,raw:false,id:123,seq:7,packet:request};
+  expect(isEchoReply(reply,info)).toBe(true);expect(isEchoReply(request,info)).toBe(false);
+  expect(isEchoReply(reply,{...info,id:124})).toBe(false);expect(isEchoReply(reply,{...info,seq:8})).toBe(false);
+  const ip=Buffer.alloc(24);ip[0]=0x46;ip[9]=1;
+  expect(isEchoReply(Buffer.concat([ip,reply]),{...info,raw:true})).toBe(true);
+  expect(isEchoReply(reply.subarray(0,7),info)).toBe(false);
+  if(size){reply[8]^=1;expect(isEchoReply(reply,info)).toBe(false);}
+ }
+ const packet=echoPacket(6,3,4,8),reply=Buffer.from(packet);reply[0]=129;
+ expect(isEchoReply(reply,{family:6,raw:false,id:3,seq:4,packet})).toBe(true);
+});
+
+for(const size of [0,17,56,1400])test.skipIf(!available)(`system ping comparison: IPv4 count, payload ${size}, statistics and exit status`,()=>{
+ const args=['-4','-n','-c','3','-i','0.2','-W','1','-s',String(size),'127.0.0.1'];
+ const reference=run(args,true),actual=run(args);
+ expect(actual.status).toBe(reference.status);expect(actual.status).toBe(0);
+ expect(summary(actual.stdout)).toEqual(summary(reference.stdout));expect(summary(actual.stdout)).toEqual([3,3,0]);
+ expect(actual.stdout).toContain(`${size+8} bytes from 127.0.0.1`);expect(actual.stdout).toContain('icmp_seq=3');
+ expect(actual.stdout).toMatch(/rtt min\/avg\/max\/mdev = [\d.]+\/[\d.]+\/[\d.]+\/[\d.]+ ms/);
+});
+
+test.skipIf(!available)('system ping comparison: hostname, source address, quiet mode and TTL',()=>{
+ const args=['-4','-n','-q','-c','2','-i','.2','-W','1','-t','32','-I','127.0.0.1','localhost'];
+ const reference=run(args,true),actual=run(args);
+ expect(actual.status).toBe(reference.status);expect(actual.status).toBe(0);expect(summary(actual.stdout)).toEqual(summary(reference.stdout));expect(actual.stdout).not.toContain('icmp_seq=');
+});
+const ipv6=available&&run(['-6','-c','1','-W','1','::1'],true).status===0;
+test.skipIf(!ipv6)('system ping comparison: IPv6 loopback',()=>{
+ const args=['-6','-n','-c','3','-i','.2','-W','1','::1'],reference=run(args,true),actual=run(args);
+ expect(actual.status).toBe(reference.status);expect(actual.status).toBe(0);expect(summary(actual.stdout)).toEqual([3,3,0]);expect(summary(actual.stdout)).toEqual(summary(reference.stdout));
+});
+test.skipIf(!available)('system ping comparison: deadline before requested count returns failure',()=>{
+ const args=['-4','-q','-c','100','-i','.2','-w','1','127.0.0.1'],reference=run(args,true),begin=performance.now(),actual=run(args);
+ expect(actual.status).toBe(reference.status);expect(actual.status).toBe(1);expect(performance.now()-begin).toBeLessThan(2500);expect(summary(actual.stdout)[0]).toBeLessThan(100);
+});
+test.skipIf(!available)('Ctrl-C prints statistics and releases the socket',async()=>{
+ const child=Bun.spawn([process.execPath,command,'-i','.2','127.0.0.1'],{stdout:'pipe',stderr:'pipe'});
+ const reader=child.stdout.getReader();let output='';
+ try{
+  for(;;){const {value,done}=await reader.read();if(done)break;output+=new TextDecoder().decode(value);if(output.includes('icmp_seq=')){child.kill('SIGINT');break;}}
+  for(;;){const {value,done}=await reader.read();if(done)break;output+=new TextDecoder().decode(value);}
+  expect(await child.exited).toBe(0);expect(output).toContain('ping statistics');expect(summary(output)[1]).toBeGreaterThan(0);
+ }finally{child.kill();reader.releaseLock();}
+},6000);
+
+test.skipIf(!available)('sub-200ms interval and fractional timeout are supported independently of old Android ping',()=>{
+ const r=run(['-c','3','-i','.01','-W','.1','-D','127.0.0.1']);
+ expect(r.status).toBe(0);expect(summary(r.stdout)).toEqual([3,3,0]);expect(r.stdout).toMatch(/\[\d+\.\d+\] 64 bytes/);
+});