buninu-linux 0.13.56 → 0.15.58

package/test/image-size.test.js

@@ -0,0 +1,17 @@
+import { test, expect } from "bun:test";
+import { imageBytes } from "../scripts/build.js";
+import { layout } from "../initramfs/lib/fat.js";
+const MiB = 1024 * 1024;
+test("image sizing preserves small images and fits GPU firmware payloads plus FAT metadata", () => {
+  expect(imageBytes(80 * MiB)).toBe(128 * MiB);
+  // Actual no-gpu EFI: the former 16 MiB reserve incorrectly made this 192 MiB.
+  expect(imageBytes(113646592)).toBe(128 * MiB);
+  expect(imageBytes(266 * MiB)).toBe(320 * MiB);
+  for (const payload of [0, 100 * MiB, 120 * MiB, 240 * MiB, 266 * MiB, 512 * MiB, 0xffffffff]) {
+    const size = imageBytes(payload);
+    const geometry = layout(size / 512 - 34 - 2048 + 1);
+    expect((geometry.clusters - 3) * geometry.perCluster * 512).toBeGreaterThan(payload);
+    expect(size % (64 * MiB)).toBe(0);
+  }
+  expect(() => imageBytes(0x100000000)).toThrow("FAT32");
+});

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/manual-bunterm-image-paths.js

@@ -0,0 +1,31 @@
+import {runGraphics} from '/lib/fbdev.js';
+import {loadCanvasKit,openCanvas} from '/lib/canvas.js';
+import {claimVirtualConsole} from '/lib/bunterm/vt.js';
+// Manual native Linux benchmark; takes over tty6 temporarily.
+// bun test/manual-bunterm-image-paths.js /path/to/1920x1080.png
+if(!process.argv[2])throw Error('Pass a 1920x1080 PNG filename');
+const CK=await loadCanvasKit(), results=[];
+await runGraphics(async(display,{onRelease,onAcquire})=>{
+ const screen=openCanvas(CK,display);let active=true;onRelease(()=>active=false);onAcquire(()=>active=true);
+ const bytes=await Bun.file(process.argv[2]).bytes();
+ const image=CK.MakeImageFromEncoded(bytes),w=image.width(),h=image.height();
+ if(w!==1920||h!==1080||display.width!==1920||display.height!==1080||display.bitsPerPixel!==32)throw Error("This comparison requires a 1920x1080 image and 32-bit 1920x1080 framebuffer");
+ const src=CK.LTRBRect(0,0,w,h), native=CK.LTRBRect(0,0,w,h),scaled=CK.LTRBRect(0,26,1920,1066);
+ const info={width:w,height:h,colorType:CK.ColorType.RGBA_8888,alphaType:CK.AlphaType.Unpremul,colorSpace:CK.ColorSpace.SRGB};
+ const start=performance.now(),pixels=image.readPixels(0,0,info);
+ if(!pixels)throw Error('readPixels failed');
+ if(screen.colorType===CK.ColorType.BGRA_8888)for(let i=0;i<pixels.length;i+=4){const r=pixels[i];pixels[i]=pixels[i+2];pixels[i+2]=r;}results.push({readPixelsMs:performance.now()-start,width:w,height:h,bytes:pixels?.length});
+ const actions={
+  'rows-scaled':()=>{for(let y=0;y<1080;y+=26){screen.canvas.save();screen.canvas.clipRect(CK.LTRBRect(0,y,1920,Math.min(1080,y+26)),CK.ClipOp.Intersect,false);screen.canvas.drawImageRectOptions(image,src,scaled,CK.FilterMode.Linear,CK.MipmapMode.Linear,null);screen.canvas.restore();}},
+  'single-scaled':()=>screen.canvas.drawImageRectOptions(image,src,scaled,CK.FilterMode.Linear,CK.MipmapMode.Linear,null),
+  'single-1to1':()=>screen.canvas.drawImageRectOptions(image,src,native,CK.FilterMode.Linear,CK.MipmapMode.Linear,null),
+  'drawImage-1to1':()=>screen.canvas.drawImage(image,0,0),
+  'decode-copy-1to1':()=>{const fresh=CK.MakeImageFromEncoded(bytes);try{const p=fresh.readPixels(0,0,info);if(!p)throw Error('decode failed');if(screen.colorType===CK.ColorType.BGRA_8888)for(let i=0;i<p.length;i+=4){const r=p[i];p[i]=p[i+2];p[i+2]=r;}screen.restoreRegion({x:0,y:0,height:Math.min(h,1080),rowBytes:w*4,pixels:p});}finally{fresh.delete();}},
+  'copy-1to1':()=>screen.restoreRegion({x:0,y:0,height:Math.min(h,1080),rowBytes:w*4,pixels}),
+ };
+ try {for(const [name,draw] of Object.entries(actions)){
+   screen.canvas.clear(CK.BLACK);draw();screen.flush();
+   const t=performance.now();let count=0,total=0;while(performance.now()-t<2500){if(!active)throw Error('VT switched');const t0=performance.now();draw();screen.flush();total+=performance.now()-t0;count++;await Bun.sleep(16);}
+   results.push({name,ms:total/count,count});await Bun.write('/tmp/bunterm-image-paths.json',JSON.stringify(results,null,2));
+ }}finally{image.delete();screen.close();}
+},{console:['/dev/tty6'],prepareConsole:claimVirtualConsole});process.exit(0);

package/test/mount-libc-lifetime.test.js

@@ -0,0 +1,50 @@
+import {test,expect} from 'bun:test';
+import {mkdtempSync,writeFileSync,readFileSync,rmSync} from 'node:fs';
+import {tmpdir} from 'node:os';
+import {join} from 'node:path';
+
+// Run the real command with a libc whose path disappears after the first
+// successful mount change. Never mount or unmount anything on the host.
+async function invoke(name,args){
+ const dir=mkdtempSync(join(tmpdir(),'buninu-mount-libc-'));
+ const mock=join(dir,'libc.mjs');
+ writeFileSync(mock,`
+ let hidden=false;
+ const bound=new Map();
+ const functions={mount:()=>{if(hidden)return -1;hidden=true;return 0;},
+ umount2:()=>{if(hidden)return -1;hidden=true;return 0;},
+ errno:()=>5,strerror:()=> 'mock I/O error'};
+ export const libc={symbols:new Proxy({}, {get(_target,name){
+   if(!bound.has(name)){
+     if(hidden)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={},SysError=class extends Error{};
+ `);
+ const source=readFileSync(new URL('../initramfs/bin/'+name,import.meta.url),'utf8')
+ .replace('"../lib/dlopen.js"',JSON.stringify(mock))
+ .replace('import { showDocument } from "../lib/document.js";','const showDocument=async()=>{};')
+ .replace('import { modprobe, tryModprobe, modulesDirectory, ModuleNotFound } from "../lib/modprobe.js";',
+ 'const modprobe=()=>[],tryModprobe=()=>[],modulesDirectory=()=>"";class ModuleNotFound extends Error{}');
+ const entry=join(dir,'command.mjs');writeFileSync(entry,source);
+ try{
+   const child=Bun.spawn([process.execPath,entry,...args],{stdout:'pipe',stderr:'pipe'});
+   const stderr=new Response(child.stderr).text();
+   return {status:await child.exited,stderr:await stderr};
+ }finally{rmSync(dir,{recursive:true,force:true});}
+}
+
+test('read-only bind reports remount failure after the libc path is hidden',async()=>{
+ const r=await invoke('mount',['--bind','-o','ro','/fake-source','/fake-target']);
+ expect(r.status).toBe(32);expect(r.stderr).toContain('mount: mock I/O error');
+ expect(r.stderr).not.toContain('Cannot load libc symbol');
+});
+
+test('later unmount failure reports strerror after an earlier target hides libc',async()=>{
+ const r=await invoke('umount',['/fake-lib','/fake-missing']);
+ expect(r.status).toBe(32);expect(r.stderr).toContain('umount: /fake-missing: mock I/O error.');
+ expect(r.stderr).not.toContain('Cannot load libc symbol');
+});

package/test/no-gpu.test.js

@@ -0,0 +1,43 @@
+import {test,expect} from "bun:test";
+import {mkdtempSync,mkdirSync,writeFileSync,existsSync,rmSync} from "node:fs";
+import {tmpdir} from "node:os";
+import {join} from "node:path";
+import {requests,select} from "../scripts/modules.js";
+import {config} from "../scripts/arch.js";
+import {fetchGpuFirmware,gpuReady} from "../scripts/fetch-gpu.js";
+const additions=new Set(["virtio-gpu","vmwgfx","i915","xe","amdgpu","radeon","nouveau"]);
+test("no-gpu only removes new explicit requests across target configurations",()=>{
+ for(const arch of ["x86_64","aarch64"])for(const flavor of ["lts","virt"])for(const real of [true,false]){
+   const cfg={arch,flavor,real};
+   expect(requests({...cfg,noGpu:true})).toEqual(requests(cfg).filter(r=>!additions.has(r.name)));
+ }
+ expect(config({noGpu:true}).noGpu).toBe(true);
+});
+test("no-gpu retains a GPU-directory dependency when an original module needs it",()=>{
+ const cfg={arch:"x86_64",flavor:"lts",real:false,noGpu:true};
+ const dep=requests(cfg).map(({name})=>`kernel/test/${name}.ko.gz:${name==="snd-hda-intel"?" kernel/drivers/gpu/drm/shared.ko.gz":""}`).join("\n")+"\nkernel/drivers/gpu/drm/shared.ko.gz:";
+ expect(select({...cfg,dep,builtin:"",packageName:"test"}).selected).toContain("kernel/drivers/gpu/drm/shared.ko.gz");
+});
+test("no-gpu clears generated firmware and caches cannot cross GPU modes",async()=>{
+ const root=mkdtempSync(join(tmpdir(),"no-gpu-"));
+ try{
+   const cfg={...config({arch:"x86_64",flavor:"lts",real:true,noGpu:true}),nativeDir:root,modulesRoot:join(root,"modules")};
+   mkdirSync(cfg.modulesRoot,{recursive:true});
+   writeFileSync(join(cfg.modulesRoot,"modules.dep"),"");
+   writeFileSync(join(cfg.modulesRoot,"modules.builtin"),"kernel/drivers/gpu/drm/i915/i915.ko\n");
+   mkdirSync(join(root,"lib/firmware"),{recursive:true});
+   writeFileSync(join(root,"lib/firmware/stale"),"old firmware");
+   await fetchGpuFirmware(cfg);
+   expect(existsSync(join(root,"lib/firmware"))).toBe(false);
+   expect(gpuReady(cfg)).toBe(true);
+   expect(gpuReady({...cfg,noGpu:false})).toBe(false);
+   mkdirSync(join(root,"lib/firmware"));
+   expect(gpuReady(cfg)).toBe(false);
+ }finally{rmSync(root,{recursive:true,force:true});}
+});
+test("launcher documents no-gpu and rejects it without fetch/build",()=>{
+ const help=Bun.spawnSync([process.execPath,"index.js","--help"]);
+ expect(help.exitCode).toBe(0);expect(help.stdout.toString()).toContain("--no-gpu");
+ const invalid=Bun.spawnSync([process.execPath,"index.js","-r","--no-gpu"]);
+ expect(invalid.exitCode).not.toBe(0);expect(invalid.stderr.toString()).toContain("only make sense");
+});

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/);
+});

package/test/readme-cli.test.js

@@ -0,0 +1,29 @@
+import { expect, test } from "bun:test";
+import { fileURLToPath } from "node:url";
+
+const entry = fileURLToPath(new URL("../index.js", import.meta.url));
+
+for (const [flag, filename] of [
+  ["--readme", "README.md"],
+  ["--readme-zh", "README.zh.md"],
+  ["--docs", "README.zh.md"],
+]) {
+  test(`${flag} flushes the complete document to a pipe before exiting`, async () => {
+    const markdown = await Bun.file(new URL(`../${filename}`, import.meta.url)).text();
+    const rendered = Bun.markdown.ansi(markdown, { hyperlinks: true });
+    const expected = rendered.endsWith("\n") ? rendered : `${rendered}\n`;
+    // Both real documents exceed the pipe chunk that was previously truncated.
+    expect(Buffer.byteLength(expected)).toBeGreaterThan(65536);
+    const child = Bun.spawn([process.execPath, entry, flag], {
+      stdout: "pipe", stderr: "pipe",
+    });
+    const [output, errors, status] = await Promise.all([
+      new Response(child.stdout).text(),
+      new Response(child.stderr).text(),
+      child.exited,
+    ]);
+    expect(status).toBe(0);
+    expect(errors).toBe("");
+    expect(output).toBe(expected);
+  });
+}

package/test/stage-npm.test.js

@@ -101,9 +101,16 @@ test("distribution launcher ensures resources then forwards to local casty witho
   `);
   writeFileSync(join(root, "usr/lib/node_modules/@drxiaozhi/casty/index.js"),
     "console.log(JSON.stringify({args:process.argv.slice(2),engine:process.env.CASTY_BROWSER}));");
-  const result = spawnSync(process.execPath, [join(root, "bin/buninu-browser"), "--casty", "https://example.test", "--", "--chromium"], { encoding: "utf8" });
-  expect(result.status).toBe(0);
-  expect(JSON.parse(result.stdout)).toEqual({ args: ["https://example.test", "--", "--chromium"], engine: join(browser, "buninu-browser.js") });
+  for (const args of [
+    ["https://example.test", "--", "--chromium"],
+    ["--", "--help"],
+    ["--", "--version"],
+    ["--", "--window-size=160,90"],
+  ]) {
+    const result = spawnSync(process.execPath, [join(root, "bin/buninu-browser"), "--casty", ...args], { encoding: "utf8" });
+    expect(result.status).toBe(0);
+    expect(JSON.parse(result.stdout)).toEqual({ args, engine: join(browser, "buninu-browser.js") });
+  }
 });
 
 test("land launcher selects bundled casty and preserves package frontend dispatch", async () => {
@@ -130,7 +137,7 @@ test("land launcher selects bundled casty and preserves package frontend dispatc
     });
     expect(result.status).toBe(0);
     expect(JSON.parse(result.stdout)).toEqual({
-      args: args[0] === '--casty' ? args.slice(1) : args,
+      args: ['--no-shortcuts', ...(args[0] === '--casty' ? args.slice(1) : args)],
       engine: join(land, "compositor.js"),
     });
   }

package/test/xdg-open.test.js

@@ -0,0 +1,55 @@
+import {afterAll, expect, test} from 'bun:test';
+import {mkdtempSync,writeFileSync,symlinkSync,rmSync,chmodSync} from 'node:fs';
+import {tmpdir} from 'node:os';
+import {join} from 'node:path';
+import {pathToFileURL} from 'node:url';
+import {browserTarget,parseOpenArgs} from '../initramfs/lib/xdg-open.js';
+const dir=mkdtempSync(join(tmpdir(),'buninu-xdg-open-'));
+afterAll(()=>rmSync(dir,{recursive:true,force:true}));
+const file=join(dir,'中文 # %.html');writeFileSync(file,'<p>test</p>');
+symlinkSync(file,join(dir,'alias.html'));
+test('HTTP and HTTPS remain browser URLs',()=>{
+ expect(browserTarget('https://buninu.org/path?q=one#two')).toBe('https://buninu.org/path?q=one#two');
+ expect(browserTarget('http://localhost:8080')).toBe('http://localhost:8080/');
+ expect(()=>browserTarget('http://')).toThrow();
+});
+test('local files resolve symlinks and escape URL-special characters',()=>{
+ expect(browserTarget('alias.html',dir)).toBe(pathToFileURL(file).href);
+ expect(browserTarget(pathToFileURL(file).href)).toBe(pathToFileURL(file).href);
+ expect(()=>browserTarget('missing',dir)).toThrow();
+ expect(()=>browserTarget(dir)).toThrow('regular file');
+ expect(()=>browserTarget('javascript:alert(1)')).toThrow('Unsupported');
+ expect(()=>browserTarget('mailto:test@example.com')).toThrow('Unsupported');
+});
+test('argument validation',()=>{
+ expect(parseOpenArgs(['--help'])).toEqual({help:true});
+ expect(()=>parseOpenArgs([])).toThrow('Usage');
+ expect(()=>parseOpenArgs(['a','b'])).toThrow('Usage');
+});
+test('launcher passes a single URL argument to a new bunterm and maps launch failure to status 4',async()=>{
+ const stub=join(dir,'bunterm');writeFileSync(stub,`#!${process.execPath}\nconsole.log(JSON.stringify(process.argv.slice(2)));process.exit(7);`);chmodSync(stub,0o755);
+ const browser=join(dir,'buninu-browser');writeFileSync(browser,'#!/bin/sh\nexit 0');chmodSync(browser,0o755);
+ const url='https://example.test/?q=$(touch%20bad)&x=1';
+ const p=Bun.spawn([process.execPath,new URL('../initramfs/bin/xdg-open',import.meta.url).pathname,url],{env:{...process.env,PATH:dir+':'+process.env.PATH},stdout:'pipe',stderr:'pipe'});
+ expect(await p.exited).toBe(4);
+ expect(JSON.parse(await new Response(p.stdout).text())).toEqual(['-e','buninu-browser',url]);
+ expect(await new Response(p.stderr).text()).toBe('');
+});
+
+test('about URLs pass through; Markdown remains a browser file URL',()=>{
+ for(const url of ['about:blank','about:audio','about:custom?x=1#part'])
+  expect(browserTarget(url)).toBe(url);
+ const markdown=join(dir,'note.md');writeFileSync(markdown,'# Note');
+ expect(browserTarget(markdown)).toBe(pathToFileURL(markdown).href);
+});
+
+test('manual aliases, version and standard failure codes work through the command',async()=>{
+ const run=async args=>{const p=Bun.spawn([process.execPath,new URL('../initramfs/bin/xdg-open',import.meta.url).pathname,...args],{env:{...process.env,PATH:'/nonexistent'},stdout:'pipe',stderr:'pipe'});return {code:await p.exited,out:await new Response(p.stdout).text()}};
+ for(const flag of ['-h','--help','--manual']){const r=await run([flag]);expect(r.code).toBe(0);expect(r.out).toContain('Exit codes');}
+ const v=await run(['--version']);expect(v.code).toBe(0);expect(v.out).toContain('xdg-open (Buninu Linux)');
+ expect((await run([])).code).toBe(1);
+ expect((await run(['http://'])).code).toBe(1);
+ expect((await run([join(dir,'absent')])).code).toBe(2);
+ expect((await run(['https://buninu.org'])).code).toBe(3);
+ expect((await run(['mailto:a@example.com'])).code).toBe(4);
+});