buninu-linux 0.13.56 → 0.15.58

package/test/bunterm-vt-menu.test.js

@@ -0,0 +1,178 @@
+import { test, expect } from "bun:test";
+import { createVtMenu } from "../initramfs/lib/bunterm/vt-menu.js";
+import { createCommands } from "../initramfs/lib/bunterm/commands.js";
+const report = (x, y, pressed = [], released = []) => ({ x, y, pressed, released, buttons: {left: pressed.includes("left")}, wheel: 0, moved: false });
+function fixture(extra = {}) {
+  const selected = [];
+  const menu = createVtMenu({ width: 800, height: 600, rowHeight: 16,
+    list: () => [{number:1,label:"initial"}, {number:3,label:"bunterm"}],
+    select: n => selected.push(n), changed() {}, ...extra });
+  return {menu, selected};
+}
+test("new bunterm is below the tty list, inherits live font size, and prevents double launch", async () => {
+  let size=13, finish; const calls=[];
+  const {menu,selected}=fixture({controls:{fontSize:()=>size,execute:()=>""},
+    create:n=>{calls.push(n);return new Promise(resolve=>{finish=resolve;});}});
+  menu.pointer(report(0,0,["left"]));
+  const labels=[];
+  menu.draw({cellWidth:8,cellHeight:16,CanvasKit:{XYWHRect:(...r)=>r,ClipOp:{Intersect:0}},
+    paintFor:c=>c,drawText:text=>labels.push(text),
+    canvas:{save(){},restore(){},clipRect(){},drawRect(){}}});
+  expect(labels.indexOf("+ 新增 bunterm / New bunterm")).toBe(labels.indexOf("bunterm",2)+1);
+  size=20;
+  menu.input(Buffer.from("\x1b[B".repeat(5)+"\r\r"));
+  await Bun.sleep(0);
+  expect(calls).toEqual([20]);expect(selected).toEqual([]);
+  finish();await Bun.sleep(0);expect(menu.visible).toBe(false);
+});
+
+test("failed new bunterm launch keeps the menu usable", async () => {
+  const {menu}=fixture({controls:{fontSize:()=>13,execute:()=>""},create:()=>{throw Error("No next tty available");}});
+  menu.pointer(report(0,0,["left"]));
+  menu.input(Buffer.from("\x1b[B".repeat(5)+"\r"));
+  await Bun.sleep(0);expect(menu.visible).toBe(true);
+  const labels=[];
+  menu.draw({cellWidth:8,cellHeight:16,CanvasKit:{XYWHRect:(...r)=>r,ClipOp:{Intersect:0}},
+    paintFor:c=>c,drawText:text=>labels.push(text),
+    canvas:{save(){},restore(){},clipRect(){},drawRect(){}}});
+  expect(labels).toContain("No next tty available");
+  menu.input(Buffer.from("\x1b"));expect(menu.visible).toBe(false);
+});
+test("only the top-left four pixels open the menu; open and selection clicks never leak", () => {
+  const {menu,selected} = fixture();
+  expect(menu.pointer(report(2,1,["left"]))).toBe(false);
+  expect(menu.pointer(report(1,2,["left"]))).toBe(false);
+  expect(menu.pointer(report(1,1,["right"]))).toBe(false);
+  expect(menu.pointer(report(1,1,["left"]))).toBe(true);
+  expect(menu.visible).toBe(true);
+  expect(menu.pointer(report(1,1,[],["left"]))).toBe(true);
+  expect(menu.pointer(report(20,55,["left"]))).toBe(true);
+  expect(selected).toEqual([3]);
+  expect(menu.visible).toBe(false);
+  expect(menu.pointer(report(20,55,[],["left"]))).toBe(true);
+  expect(menu.pointer(report(30,60))).toBe(false);
+});
+test("menu consumes application input, supports keyboard selection and dismissal", () => {
+  const {menu,selected} = fixture();
+  menu.pointer(report(0,0,["left"]));
+  expect(menu.input(Buffer.from("shell command"))).toBe(true);
+  menu.input(Buffer.from("\x1b[B"));
+  menu.input(Buffer.from("\r"));
+  expect(selected).toEqual([3]);
+  menu.pointer(report(0,0,[],["left"]));
+  menu.pointer(report(0,0,["left"]));
+  menu.input(Buffer.from("\x1b"));
+  expect(menu.visible).toBe(false);
+  expect(menu.input(Buffer.from("x"))).toBe(false);
+});
+test("short screens scroll selection; renderer overlays are clipped", () => {
+  const {menu,selected} = fixture({height:72});
+  menu.pointer(report(0,0,["left"]));
+  menu.pointer({...report(10,10), wheel:-1});
+  const text=[];
+  menu.draw({cellWidth:8, cellHeight:16, CanvasKit:{XYWHRect:(...r)=>r,ClipOp:{Intersect:0}},
+    paintFor: c=>c, drawText: t=>text.push(t),
+    canvas:{save(){},restore(){},clipRect(){},drawRect(){}}});
+  expect(text).toContain("bunterm");
+  expect(text).not.toContain("initial");
+  menu.input(Buffer.from("\r"));
+  expect(selected).toEqual([3]);
+});
+test("outside click dismisses without selecting or leaking its release", () => {
+  const {menu,selected} = fixture();
+  menu.pointer(report(0,0,["left"]));
+  menu.pointer(report(0,0,[],["left"]));
+  expect(menu.pointer(report(700,300,["left"]))).toBe(true);
+  expect(menu.visible).toBe(false);
+  expect(menu.pointer(report(700,300,[],["left"]))).toBe(true);
+  expect(selected).toEqual([]);
+});
+
+test("Escape after releasing the opener does not eat the next application click", () => {
+  const {menu} = fixture();
+  menu.pointer(report(0,0,["left"]));
+  menu.pointer(report(0,0,[],["left"]));
+  menu.input(Buffer.from("\x1b"));
+  expect(menu.pointer(report(100,100,["left"]))).toBe(false);
+});
+
+test("font and clipboard buttons dispatch local commands; UTF-8 command editing survives split reads", async () => {
+  const calls=[];
+  const {menu}=fixture({controls:{fontSize:()=>13,execute:async line=>{calls.push(line);return "OK";}}});
+  menu.pointer(report(0,0,["left"]));
+  menu.pointer(report(0,0,[],["left"]));
+  for (const [x,y] of [[10,30],[400,30],[10,55],[300,55],[10,80]]) {
+    menu.pointer(report(x,y,["left"]));
+    menu.pointer(report(x,y,[],["left"]));
+  }
+  const bytes=Buffer.from("font 16中文");
+  menu.input(bytes.subarray(0,9)); menu.input(bytes.subarray(9));
+  menu.input(Buffer.from("\x7f\x7f\r")); // remove the two full code points
+  await new Promise(resolve=>setTimeout(resolve,0));
+  expect(calls).toEqual(["font -","font +","copy","paste","font 16"]);
+  expect(menu.visible).toBe(true);
+  menu.input(Buffer.from("\x1b"));
+});
+
+test("command registry validates font/VT arguments and is extensible", async () => {
+  let size=13; const calls=[];
+  const c=createCommands({fontSize:()=>size,setFontSize:n=>{if(!Number.isInteger(n)||n<6||n>96)throw Error("size");size=n;},
+    copy:()=>calls.push("copy"),paste:()=>calls.push("paste"),switchVT:n=>calls.push(n)});
+  expect(await c.execute("font +")).toBe("Font: 14");
+  await c.execute("font 18"); expect(size).toBe(18);
+  await expect(c.execute("font nope")).rejects.toThrow();
+  await expect(c.execute("vt 64")).rejects.toThrow();
+  await expect(c.execute("copy extra")).rejects.toThrow();
+  await expect(c.execute("unknown")).rejects.toThrow("try help");
+  await c.execute("copy"); await c.execute("paste"); await c.execute("vt 3");
+  expect(calls).toEqual(["copy","paste",3]);
+  c.commands.set("example", args=>args.join(" "));
+  expect(await c.execute("example hello world")).toBe("hello world");
+});
+
+test("menu labels current VT and renders a real left-aligned command field with centered font value", () => {
+  const {menu}=fixture({list:()=>[{number:1,label:"tty1 — initial console",current:true}],
+    controls:{fontSize:()=>13,execute:()=>""}});
+  menu.pointer(report(0,0,["left"]));
+  const labels=[];
+  menu.draw({cellWidth:8,cellHeight:16,CanvasKit:{XYWHRect:(...r)=>r,ClipOp:{Intersect:0}},
+    paintFor:c=>c,drawText:(text,x,y,cells,color,options)=>labels.push({text,align:options.align}),
+    canvas:{save(){},restore(){},clipRect(){},drawRect(){}}});
+  expect(labels).toContainEqual({text:"tty1 — initial console (current)",align:"left"});
+  expect(labels).toContainEqual({text:"Click to type a command…",align:"left"});
+  expect(labels).toContainEqual({text:"🔤 字體 Font 13",align:"center"});
+  expect(labels).toContainEqual({text:"📋 複製 Copy",align:"left"});
+  expect(labels).toContainEqual({text:"📥 貼上 Paste",align:"left"});
+  expect(labels.some(x=>x.text===">")).toBe(false);
+});
+
+test("font buttons fit equally and preserve the right margin as fonts grow", () => {
+  const {menu}=fixture({controls:{fontSize:()=>20,execute:()=>""}});
+  menu.pointer(report(0,0,["left"]));
+  for(const cellWidth of [8,12,19,58]) {
+    const labels=[];
+    menu.draw({cellWidth,cellHeight:24,CanvasKit:{XYWHRect:(...r)=>r,ClipOp:{Intersect:0}},
+      paintFor:c=>c,drawText:(text,x,y,cells,color,options)=>labels.push({text,x,cells,align:options.align}),
+      canvas:{save(){},restore(){},clipRect(){},drawRect(){}}});
+    const plus=labels.find(x=>x.text==="[+]"),minus=labels.find(x=>x.text==="[-]");
+    expect(plus.align).toBe("center");expect(minus.align).toBe("center");
+    expect(plus.cells).toBe(minus.cells);
+    expect(plus.x+plus.cells*cellWidth).toBe(412);
+    expect(minus.x).toBe(8);
+  }
+});
+
+test('header FPS control toggles without selecting a tty or leaking the click',()=>{
+ let enabled=false;
+ const {menu,selected}=fixture({controls:{fontSize:()=>13,execute:()=>'',fpsEnabled:()=>enabled,toggleFps:()=>{enabled=!enabled;}}});
+ menu.pointer(report(0,0,['left']));
+ menu.pointer(report(0,0,[],['left']));
+ expect(menu.pointer(report(380,12,['left']))).toBe(true);
+ expect(enabled).toBe(true);expect(menu.visible).toBe(true);expect(selected).toEqual([]);
+ menu.pointer(report(380,12,[],['left']));
+ const labels=[];
+ menu.draw({cellWidth:8,cellHeight:16,CanvasKit:{XYWHRect:(...r)=>r,ClipOp:{Intersect:0}},
+  paintFor:c=>c,drawText:text=>labels.push(text),canvas:{save(){},restore(){},clipRect(){},drawRect(){}}});
+ expect(labels).toContain('[FPS ✓]');
+ menu.pointer(report(380,12,['left']));expect(enabled).toBe(false);
+});

package/test/chroot-bind.test.js

@@ -39,8 +39,21 @@ async function invoke(argumentsFor,env={}) {
  const mock=join(dir,'libc.js');
  writeFileSync(mock,`import {appendFileSync} from 'node:fs';
  const record=(name,...args)=>appendFileSync(${JSON.stringify(log)},JSON.stringify([name,...args.map(a=>typeof a==='bigint'?String(a):a)])+'\\n');
- export const ptr=x=>x,cString=x=>x,errno=()=>1,strerror=()=> 'mock mount denied',Errno={EINVAL:22,EPERM:1};
- export const libc={symbols:{mount:(...a)=>{record('mount',...a);return a[0]?.endsWith('/fail')?-1:0;},umount2:(...a)=>{record('umount',...a);return 0;},chroot:(...a)=>{record('chroot',...a);return 0;}}};`);
+ let entered=false;
+ const bound=new Map();
+ const functions={mount:(...a)=>{record('mount',...a);return a[0]?.endsWith('/fail')?-1:0;},
+ umount2:(...a)=>{record('umount',...a);return process.env.MOCK_UNMOUNT_FAIL?-1:0;},
+ chroot:(...a)=>{record('chroot',...a);entered=true;return 0;},
+ strerror:()=> 'mock mount denied',errno:()=>process.env.MOCK_UNMOUNT_FAIL?5:1};
+ export const libc={symbols:new Proxy({}, {get(_target,name){
+   if(!bound.has(name)){
+     record('resolve',name);
+     if(entered||process.env.MOCK_MISSING_SYMBOL===name)throw Error('Cannot load libc symbol '+name);
+     bound.set(name,functions[name]);
+   }
+   return bound.get(name);
+ }})};
+ export const ptr=x=>x,cString=x=>x,errno=()=>libc.symbols.errno(),strerror=code=>libc.symbols.strerror(code),Errno={EINVAL:22,EPERM:1};`);
  const source=readFileSync(new URL('../initramfs/bin/chroot',import.meta.url),'utf8')
   .replace('"../lib/dlopen.js"',JSON.stringify(mock))
   .replace('"../lib/chroot-options.js"',JSON.stringify(new URL('../initramfs/lib/chroot-options.js',import.meta.url).pathname))
@@ -68,3 +81,28 @@ test('shared tmp replaces default tmpfs and bind failure cleans up even with -k'
  expect(failure.calls.some(c=>c[0]==='chroot')).toBe(false);
  expect(failure.calls.filter(c=>c[0]==='umount').map(c=>c[1])).toEqual([failure.root+'/first']);
 });
+
+test('cleanup symbols are resolved before mounting and remain usable after chroot',async()=>{
+ const r=await invoke(({host})=>['-n','-b',`${host}:/work`],{MOCK_UNMOUNT_FAIL:'1'});
+ expect(r.status).toBe(0);
+ expect(r.stderr).toContain('chroot: unmount /work: mock mount denied');
+ expect(r.stderr).not.toContain('Cannot load libc symbol');
+ const firstMount=r.calls.findIndex(c=>c[0]==='mount');
+ for(const name of ['umount2','strerror','errno']){
+   const index=r.calls.findIndex(c=>c[0]==='resolve'&&c[1]===name);
+   expect(index).toBeGreaterThanOrEqual(0);expect(index).toBeLessThan(firstMount);
+ }
+ expect(r.calls.filter(c=>c[0]==='umount').map(c=>c[2])).toEqual([0,2]);
+});
+
+test('missing cleanup symbol fails before any mount, including keep-mounts',async()=>{
+ const r=await invoke(({host})=>['-n','-k','-b',`${host}:/work`],{MOCK_MISSING_SYMBOL:'umount2'});
+ expect(r.status).toBe(125);expect(r.stderr).toContain('Cannot load libc symbol umount2');
+ expect(r.calls.some(c=>['mount','chroot','umount'].includes(c[0]))).toBe(false);
+});
+
+test('no-mount chroot without binds does not require umount2',async()=>{
+ const r=await invoke(()=>['-n'],{MOCK_MISSING_SYMBOL:'umount2'});
+ expect(r.status).toBe(0);
+ expect(r.calls.some(c=>c[0]==='resolve'&&c[1]==='umount2')).toBe(false);
+});

package/test/chvt.test.js

@@ -0,0 +1,46 @@
+import { test, expect } from "bun:test";
+import { parseChvt, switchVt } from "../initramfs/lib/chvt.js";
+
+test("chvt accepts VT numbers and help, rejects invalid input before opening devices", async () => {
+  expect(parseChvt(["2"])).toEqual({ number: 2 });
+  expect(parseChvt(["63"])).toEqual({ number: 63 });
+  for (const flag of ["-h", "--help"]) expect(parseChvt([flag]).help).toBe(true);
+  for (const args of [[], ["0"], ["64"], ["-1"], ["2x"], ["1", "2"]]) expect(() => parseChvt(args)).toThrow();
+  await expect(switchVt(0, {})).rejects.toThrow();
+});
+
+test("chvt skips PTY/non-VT consoles, activates only a validated VT and closes descriptors", async () => {
+  const events = [];
+  await switchVt(2, {
+    openConsole([path]) {
+      events.push(path);
+      if (path === "/dev/tty0") throw Error("missing");
+      return { path, close: () => events.push(`close ${path}`) };
+    },
+    activeConsole(device) { if (device.path === "/dev/tty") throw Error("not a VT"); },
+    activateConsole(device, number) { events.push(`activate ${device.path} ${number}`); },
+  });
+  expect(events).toEqual(["/dev/tty0", "/dev/tty", "close /dev/tty", "/dev/console", "activate /dev/console 2", "close /dev/console"]);
+});
+
+test("chvt closes console on failed switch without overriding VT owner or trying another switch", async () => {
+  let closed = 0, opened = 0;
+  await expect(switchVt(1, {
+    openConsole() { opened++; return { close() { closed++; } }; },
+    activeConsole() { return 2; },
+    activateConsole() { throw Error("switch denied"); },
+  })).rejects.toThrow("switch denied");
+  expect(opened).toBe(1);
+  expect(closed).toBe(1);
+});
+
+test("chvt CLI help and invalid arguments work without a Linux console", () => {
+  for (const flag of ["-h", "--help"]) {
+    const result = Bun.spawnSync([process.execPath, "initramfs/bin/chvt", flag]);
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout.toString()).toContain("bunterm");
+  }
+  const invalid = Bun.spawnSync([process.execPath, "initramfs/bin/chvt", "0"]);
+  expect(invalid.exitCode).toBe(1);
+  expect(invalid.stderr.toString()).toContain("usage:");
+});

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/fbdev-sync.test.js

@@ -0,0 +1,33 @@
+import { test, expect } from "bun:test";
+import { syncFramebuffer, flush } from "../initramfs/lib/fbdev.js";
+const display = () => ({ address: 0x10000, memoryLength: 4096, path: "/dev/fb0" });
+test("unsupported framebuffer msync is probed once per mapping", () => {
+  for (const code of [22, 95]) {
+    const fb = display(); let calls = 0;
+    const native = { msync(...args) { calls++; expect(args).toEqual([0x10000, 4096, 4]); return -1; }, errno: () => code };
+    syncFramebuffer(fb, native); syncFramebuffer(fb, native);
+    expect(calls).toBe(1);
+    expect(fb.msyncUnsupported).toBe(true);
+  }
+});
+test("supported sync continues every frame and retries EINTR", () => {
+  const fb = display(); let calls = 0;
+  const native = { msync() { return ++calls === 1 ? -1 : 0; }, errno: () => 4 };
+  syncFramebuffer(fb, native); syncFramebuffer(fb, native);
+  expect(calls).toBe(3);
+  expect(fb.msyncUnsupported).toBeUndefined();
+});
+test("real mapping and I/O failures remain visible", () => {
+  for (const code of [5, 12, 9]) {
+    const fb = display();
+    expect(() => syncFramebuffer(fb, {msync: () => -1, errno: () => code, strerror: () => `error ${code}`})).toThrow(`error ${code}`);
+    expect(fb.msyncUnsupported).toBeUndefined();
+  }
+});
+test("pixel writes continue on unsupported sync and respect framebuffer offsets and stride", () => {
+  const fb = {...display(), msyncUnsupported: true, width: 2, height: 2, bytesPerPixel: 1,
+    stride: 4, xOffset: 1, yOffset: 1, pixels: new Uint8Array([1,2,0,0,3,4,0,0]), memory: new Uint8Array(16)};
+  flush(fb);
+  expect([...fb.memory]).toEqual([0,0,0,0,0,1,2,0,0,3,4,0,0,0,0,0]);
+  fb.pixels[0] = 9; flush(fb); expect(fb.memory[5]).toBe(9);
+});

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.3", "@drxiaozhi/casty@1.3.7",
+    "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/gpu.test.js

@@ -0,0 +1,155 @@
+import { test, expect, afterEach } from "bun:test";
+import * as fs from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { configureGpu, framebufferUsers, isGpuPath } from "../initramfs/lib/gpu.js";
+import { extractFirmware, firmwareLinkTarget } from "../scripts/fetch-gpu.js";
+import { readTar } from "../scripts/fetch.js";
+import { requests, select } from "../scripts/modules.js";
+
+const dirs = [];
+const temporary = () => { const p = fs.mkdtempSync(join(tmpdir(), "buninu-gpu-test-")); dirs.push(p); return p; };
+afterEach(() => { for (const dir of dirs.splice(0)) fs.rmSync(dir, { recursive: true, force: true }); });
+const archive = (files, links = {}) => ({ entries: () => Object.entries(files).map(([n,b]) => [n, Buffer.from(b)]), links: () => Object.entries(links) });
+const soft = target => ({ target, hard: false });
+
+test("firmware preserves directory aliases, cross-package links and hardlinks", () => {
+  const root = temporary();
+  const files = extractFirmware([
+    archive({ "lib/firmware/nvidia/ad102/gsp.bin.zst": "firmware", "lib/firmware/amdgpu/a.bin.zst": "amd" }),
+    archive({}, {
+      "lib/firmware/nvidia/ad103": soft("ad102"),
+      "lib/firmware/nvidia/alias.bin.zst": soft("ad103/gsp.bin.zst"),
+      "lib/firmware/radeon/alias.bin.zst": soft("../amdgpu/a.bin.zst"),
+      "lib/firmware/nvidia/hard.bin.zst": { target: "lib/firmware/nvidia/ad102/gsp.bin.zst", hard: true },
+    }),
+  ], root);
+  expect(files).toHaveLength(6);
+  expect(fs.readFileSync(join(root, "lib/firmware/nvidia/ad103/gsp.bin.zst"), "utf8")).toBe("firmware");
+  expect(fs.readFileSync(join(root, "lib/firmware/nvidia/alias.bin.zst"), "utf8")).toBe("firmware");
+  expect(fs.readFileSync(join(root, "lib/firmware/nvidia/hard.bin.zst"), "utf8")).toBe("firmware");
+  expect(fs.readFileSync(join(root, "lib/firmware/radeon/alias.bin.zst"), "utf8")).toBe("amd");
+});
+
+test("firmware rejects escaping, missing and cyclic links before extraction", () => {
+  for (const target of ["/etc/passwd", "../../../etc/passwd", "..\\etc\\passwd"])
+    expect(() => firmwareLinkTarget("lib/firmware/nvidia/x", soft(target))).toThrow();
+  for (const links of [
+    { "lib/firmware/a": soft("missing") },
+    { "lib/firmware/a": soft("b"), "lib/firmware/b": soft("a") },
+    { "lib/firmware/a": soft("a/child") },
+  ]) expect(() => extractFirmware([archive({}, links)], temporary())).toThrow();
+  expect(() => extractFirmware([archive({"lib/firmware/../../escape": "bad"})], temporary())).toThrow();
+});
+
+test.skipIf(!Bun.which("tar"))("APK tar reader retains GNU long symlinks and hardlinks", () => {
+  const root = temporary(), tree = join(root, "tree"); fs.mkdirSync(tree);
+  const name = "x".repeat(120);
+  fs.writeFileSync(join(tree, name), "firmware");
+  fs.linkSync(join(tree, name), join(tree, "hard"));
+  fs.symlinkSync(name, join(tree, "alias"));
+  const pkg = join(root, "package.tar.gz");
+  expect(Bun.spawnSync(["tar", "--format=gnu", "-czf", pkg, "-C", tree, name, "hard", "alias"]).exitCode).toBe(0);
+  const tar = readTar(pkg), links = new Map(tar.links());
+  expect(tar.get(name).toString()).toBe("firmware");
+  expect(links.get("alias")).toEqual({ target: name, hard: false });
+  expect(links.get("hard")).toEqual({ target: name, hard: true });
+});
+
+const runtime = () => {
+  const root = temporary(), calls = [], logs = [];
+  fs.mkdirSync(join(root, "proc/1/fd"), { recursive:true });
+  fs.writeFileSync(join(root, "proc/1/maps"), "");
+  fs.mkdirSync(join(root, "dev/dri"), { recursive:true });
+  fs.writeFileSync(join(root, "dev/dri/renderD129"), "node");
+  fs.writeFileSync(join(root, "dev/fb0"), "node");
+  const io = {...fs,
+    statSync: path => path.includes("renderD") ? { isCharacterDevice: () => true } : fs.statSync(path),
+    chownSync: (path, uid, gid) => calls.push(["chown", uid, gid]),
+    chmodSync: (path, mode) => calls.push(["chmod", mode]),
+  };
+  const options = { root, io, env: {}, log: s => logs.push(s),
+    tryModprobe: name => calls.push(["transport", name]),
+    autoload: options => {
+      const candidates = [ ["amdgpu", "kernel/drivers/gpu/drm/amd/amdgpu/amdgpu.ko"], ["simpledrm", "kernel/drivers/gpu/drm/sysfb/simpledrm.ko"], ["e1000", "kernel/drivers/net/e1000.ko"] ];
+      const modules = candidates.filter(x => options.acceptModule(...x)).map(x => x[0]);
+      calls.push(["autoload", modules]);
+      return [{ bus:"pci", device:"0000:01:00.0", modules, loaded:modules, error:null }];
+    },
+  };
+  return { root, calls, logs, options };
+};
+
+test("cfg.gpu matches only GPU leaf drivers and configures actual render node names", () => {
+  const { options, calls } = runtime(); options.env.BUNINU_RENDER_GID = "107";
+  const result = configureGpu(options);
+  expect(result.errors).toEqual([]);
+  expect(result.renderNodes).toEqual([{path:"/dev/dri/renderD129", driver:"unknown", gid:107}]);
+  expect(calls).toContainEqual(["autoload", ["amdgpu"]]);
+  expect(calls).toContainEqual(["chown", 0, 107]);
+  expect(calls).toContainEqual(["chmod", 0o660]);
+});
+
+test("virtio render nodes report the GPU child driver rather than the PCI transport", () => {
+  const { root, options } = runtime();
+  const device = join(root, "sys/class/drm/renderD129/device");
+  fs.mkdirSync(join(device, "virtio0"), {recursive:true});
+  fs.symlinkSync("/sys/bus/pci/drivers/virtio-pci", join(device, "driver"));
+  fs.symlinkSync("/sys/bus/virtio/drivers/virtio_gpu", join(device, "virtio0/driver"));
+  expect(configureGpu(options).renderNodes[0].driver).toBe("virtio_gpu");
+});
+
+test("no matching GPU and no render node is diagnosed without claiming acceleration", () => {
+  const { root, options, logs } = runtime();
+  fs.unlinkSync(join(root, "dev/dri/renderD129"));
+  options.autoload = () => [];
+  const result = configureGpu(options);
+  expect(result.errors).toEqual([]);
+  expect(result.renderNodes).toEqual([]);
+  expect(logs.some(s=>s.includes("no accessible render node"))).toBe(true);
+});
+
+test("framebuffer fd or surviving mmap prevents GPU takeover before loading anything", () => {
+  for (const mapped of [false, true]) {
+    const { root, options, calls } = runtime();
+    if (mapped) fs.writeFileSync(join(root, "proc/1/maps"), "abc-def rw-s 00000000 00:01 3 /dev/fb0\n");
+    else fs.symlinkSync("/dev/fb0", join(root, "proc/1/fd/4"));
+    expect(framebufferUsers(options)).toEqual(["1"]);
+    expect(configureGpu(options).blocked).toBe(true);
+    expect(calls).toEqual([]);
+  }
+});
+
+test("missing hardware, driver failure and invalid permissions do not escape cfg.gpu", () => {
+  const { options, calls } = runtime();
+  options.env.BUNINU_RENDER_GID = "bad";
+  expect(configureGpu(options).errors.length).toBe(1); expect(calls).toEqual([]);
+  options.env = {};
+  options.autoload = () => { throw Error("driver failed"); };
+  expect(configureGpu(options).errors).toEqual(["driver failed"]);
+  options.autoload = () => []; options.io.chownSync = () => { throw Error("permission denied"); };
+  expect(configureGpu(options).errors[0]).toContain("permission denied");
+});
+
+test("cfg.all's actual loader excludes GPU modules and still loads network/sound", () => {
+  const source = fs.readFileSync(new URL("../initramfs/init.js", import.meta.url), "utf8");
+  const body = source.match(/const configureModules = \(\) => \{([\s\S]*?)\n\};/)[1];
+  const chosen = [];
+  const require = () => ({ isGpuPath, modprobeAll: ({accept}) => {
+    for (const path of ["kernel/drivers/gpu/drm/amd/amdgpu/amdgpu.ko", "kernel/drivers/net/e1000.ko", "kernel/sound/snd.ko"])
+      if (accept("",path)) chosen.push(path);
+    return {inserted:chosen,errors:[]};
+  }});
+  new Function("require", "console", body)(require, {log(){}});
+  expect(chosen).toEqual(["kernel/drivers/net/e1000.ko", "kernel/sound/snd.ko"]);
+  expect(source).toContain("gpu: { enumerable: true, get: configureGraphics }");
+});
+
+test("GPU leaves are optional for kernels without them and their dependencies are selected", () => {
+  const target = {arch:"x86_64",flavor:"lts",real:false};
+  const dep = requests(target).filter(x=>!x.optional).map(({name})=>`kernel/${name}.ko.gz:`);
+  dep.push("kernel/drivers/gpu/drm/amd/amdgpu/amdgpu.ko.gz: kernel/drivers/gpu/drm/ttm/ttm.ko.gz", "kernel/drivers/gpu/drm/ttm/ttm.ko.gz:");
+  const result = select({...target,dep:dep.join("\n"),builtin:"",packageName:"test"});
+  expect(result.selected).toContain("kernel/drivers/gpu/drm/ttm/ttm.ko.gz");
+  expect(result.notes.some(x=>x.includes("i915"))).toBe(true);
+});