buninu-browser 0.3.0 → 0.5.0

package/frontends/wayland/clipboard.js

@@ -0,0 +1,80 @@
+// A standard wl_data_device text client. Only explicit copy/paste transfers bytes.
+import {readSync, writeSync} from 'node:fs';
+import {libc} from './transport.js';
+const mimeTypes=['text/plain;charset=utf-8','text/plain','UTF8_STRING','STRING'];
+const limit=1024*1024;
+export class WaylandClipboard {
+  constructor(client) {
+    this.client=client;this.serial=0;this.offers=new Map();this.sources=new Set();this.closed=false;
+    const c=client;
+    this.manager=c.bind('wl_data_device_manager',1);
+    const seat=c.bind('wl_seat',1);
+    this.device=c.object('wl_data_device',(event,args)=>{
+      if(event==='data_offer') {
+        const id=args[0],types=new Set();this.offers.set(id,types);
+        c.objects.set(id,{iface:'wl_data_offer',event:(name,[mime])=>{if(name==='offer')types.add(mime);}});
+      }
+      if(event==='selection') {
+        this.selection=args[0];
+        for(const id of this.offers.keys())if(id!==this.selection){c.request(id,'destroy');this.offers.delete(id);c.objects.delete(id);}
+      }
+    });c.request(this.manager,'get_data_device',this.device,seat);
+  }
+  async transfer(fd,bytes) {
+    const chunks=[];let length=0,offset=0;const deadline=Date.now()+2500;
+    try {
+      libc.fcntl(fd,4,libc.fcntl(fd,3,0)|2048);
+      while(!this.closed&&Date.now()<deadline) {
+        try {
+          if(bytes) {
+            if(offset===bytes.length)return;
+            offset+=writeSync(fd,bytes,offset,bytes.length-offset);
+          } else {
+            const chunk=Buffer.alloc(65536),n=readSync(fd,chunk,0,chunk.length,null);
+            if(!n)return Buffer.concat(chunks).toString();
+            length+=n;if(length>limit)throw Error('Clipboard exceeds limit');chunks.push(chunk.subarray(0,n));
+          }
+        } catch(error) {if(!['EAGAIN','EINTR','EWOULDBLOCK'].includes(error.code))throw error;}
+        await Bun.sleep(4);
+      }
+      throw Error('Clipboard transfer interrupted or timed out');
+    } finally {libc.close(fd);}
+  }
+  async write(text) {
+    if(this.closed||!this.serial)throw Error('Clipboard requires focused Wayland input');
+    const bytes=Buffer.from(text);if(bytes.length>limit)throw Error('Clipboard exceeds limit');
+    const c=this.client;
+    const source=c.object('wl_data_source',(name,args)=>{
+      if(name==='send') {
+        if(!mimeTypes.includes(args[0]))libc.close(args[1]);
+        else this.transfer(args[1],bytes).catch(()=>{});
+      }
+      if(name==='cancelled') {c.request(source,'destroy');this.sources.delete(source);}
+    });
+    this.sources.add(source);
+    c.request(this.manager,'create_data_source',source);
+    for(const mime of mimeTypes)c.request(source,'offer',mime);
+    c.request(this.device,'set_selection',source,this.serial);
+    await c.sync();
+  }
+  async read() {
+    if(this.closed)throw Error('Clipboard closed');
+    const types=this.offers.get(this.selection),mime=mimeTypes.find(type=>types?.has(type));
+    if(!mime)return '';
+    const fds=new Int32Array(2);if(libc.pipe2(fds,2048|0x80000)<0)throw Error('Cannot create clipboard pipe');
+    try{this.client.request(this.selection,'receive',mime,fds[1]);}
+    catch(error){libc.close(fds[0]);throw error;}
+    finally{libc.close(fds[1]);}
+    return this.transfer(fds[0]);
+  }
+  close(){this.closed=true;}
+}
+
+// The standard data device belongs to every Wayland frontend, not QML.
+export function attachClipboard(client,done) {
+  if(!client.globals.has('wl_data_device_manager'))return;
+  const clipboard=new WaylandClipboard(client);
+  client.clipboard=clipboard;
+  done.finally(()=>clipboard.close());
+  return clipboard;
+}

package/frontends/wayland/index.js

@@ -0,0 +1,130 @@
+import {readFileSync,unlinkSync} from 'node:fs';
+import {resolve} from 'node:path';
+import {pathToFileURL} from 'node:url';
+import {createBrowser} from '../../lib/headless-shell.js';
+import {WaylandClient,WaylandWindow} from './client.js';
+import {attachInput} from './input.js';
+import {attachClipboard} from './clipboard.js';
+import {WaylandUrlBar,BAR_HEIGHT} from './urlbar.js';
+import {readClipboard,writeClipboard} from '../../lib/clipboard.js';
+
+// qml handle begin: local QML clipboard uses this frontend's Wayland seat
+import {qmlWindowConstraints} from '../../lib/qml/window-constraints.js';
+import {attachQmlClipboard} from '../../lib/qml/wayland-clipboard.js';
+// qml handle end
+
+export async function launch({url='about:blank',width=800,height=600,socket,chrome}={}) {
+  // qml handle begin: local application windows default to no browser chrome
+  chrome ??= !/\.qml(?:[?#]|$)/i.test(url);
+  // qml handle end
+
+  let browser,client,window,off,titleTimer,toolbar,closed=false,busy=false,dirty=true,ready=false;
+  let pageDirty=true,pageBytes,pageSize='',navigation=0,navigating=0;
+  let resolveDone;const done=new Promise(resolve=>resolveDone=resolve);
+  const close=()=>{if(closed)return;closed=true;clearInterval(titleTimer);off?.();toolbar?.dispose();try{window?.close();}finally{client?.close();browser?.close();resolveDone();}};
+  const fail=e=>{console.error(`Wayland frontend: ${e.message}`);close();};
+  try{
+    client=new WaylandClient(socket);await client.initialize();
+    attachClipboard(client,done);
+    const clipboard={
+      read:async()=>{
+        if(client.clipboard?.selection)return client.clipboard.read();
+        const text=await readClipboard();
+        // A successful host paste seeds the compositor's text cache too.
+        if(text&&client.clipboard?.serial)await client.clipboard.write(text);
+        return text;
+      },
+      write:text=>client.clipboard?client.clipboard.write(text):writeClipboard(text),
+    };
+    browser=await createBrowser({spareRenderer:false,clipboard});
+
+    // qml handle begin: operation-triggered local QML clipboard bridge
+    await attachQmlClipboard(client,browser,done);
+    // qml handle end
+
+    if(chrome ?? true)toolbar=await new WaylandUrlBar(browser.context,{
+      close,changed:()=>{dirty=true;if(ready)void draw();},
+      clipboard,
+    }).initialize();
+    window=new WaylandWindow(client,{width,height:height+(toolbar?BAR_HEIGHT:0)});
+    client.onClose=close;window.onClose=close;
+
+    // qml handle begin: forward declarative window constraints to xdg_toplevel
+    const syncQmlConstraints=qmlWindowConstraints(client,window,browser.context);
+    // qml handle end
+
+    const draw=async()=>{
+      if(closed||!ready||navigating||busy||!dirty||!window.available)return;
+      busy=true;dirty=false;const generation=navigation;let path;
+      try{
+        const w=window.width,h=window.height,bar=toolbar?Math.min(BAR_HEIGHT,h-1):0,z=toolbar?.zoom||1;
+        const size=`${w}:${h}:${z}`;
+        if(pageDirty||pageSize!==size||!pageBytes){
+          pageDirty=false;
+          if(pageSize!==size)await browser.context.resize(w/z,(h-bar)/z,z);
+          const frame=JSON.parse(await browser.context.screenshot({format:'bgra'}));path=frame.path;
+          if(closed||generation!==navigation)return;
+          if(frame.transport!=='file'||frame.format!=='bgra'||frame.stride!==frame.width*4)throw Error('Unexpected raw frame');
+          const pixels=readFileSync(path);
+          if(frame.width===w&&frame.height===h-bar)pageBytes=pixels;
+          else {
+            pageBytes=Buffer.alloc(w*(h-bar)*4,255);
+            for(let row=0;row<Math.min(frame.height,h-bar);row++)pixels.copy(pageBytes,row*w*4,row*frame.stride,row*frame.stride+Math.min(w,frame.width)*4);
+          }
+          pageSize=size;
+        }
+        toolbar?.updateURL(browser.context.url);
+        const parts=toolbar?[toolbar.pixels(w).subarray(0,w*bar*4),pageBytes]:pageBytes;
+        if(!closed&&!window.present(parts,w,h))dirty=true;
+        if(!closed){const title=String(await browser.context.title()||'Buninu Browser');if(generation===navigation&&!closed)client.request(window.toplevel,'set_title',title);}
+      }catch(e){if(!closed&&generation===navigation)fail(e);}finally{if(path)try{unlinkSync(path);}catch{}busy=false;if(!closed&&dirty&&window.available)setTimeout(draw,0);}
+    };
+    // Actual navigation may replace the renderer. Ignore work from the old
+    // document and resume drawing once navigation settles. Editing chrome does
+    // not enter this path and continues to present page animation normally.
+    const navigate=browser.context.navigate;
+    browser.context.navigate=async function(...args){
+      navigation++;navigating++;
+      try{return await navigate.apply(this,args);}
+      finally{navigating--;pageDirty=true;dirty=true;if(ready&&!closed)void draw();}
+    };
+    let readingTitle=false,lastTitle='';
+    titleTimer=setInterval(async()=>{
+      if(closed||!ready||navigating||readingTitle)return;
+      readingTitle=true;const generation=navigation;
+      try{
+        const title=String(await browser.context.title()||'Buninu Browser');
+        if(closed||generation!==navigation)return;
+        toolbar?.updateURL(browser.context.url);
+        // qml handle begin: refresh size hints alongside existing window metadata
+        await syncQmlConstraints();
+        // qml handle end
+
+        if(title!==lastTitle){lastTitle=title;client.request(window.toplevel,'set_title',title);}
+      }catch(e){if(!closed&&generation===navigation)fail(e);}finally{readingTitle=false;}
+    },500);
+    window.onConfigure=()=>{pageDirty=true;dirty=true;draw();};window.onReady=draw;
+    off=browser.context.onFrame(()=>{pageDirty=true;dirty=true;draw();});
+    const input=toolbar?{
+      press:(...args)=>toolbar.press(...args).catch(e=>toolbar.flash(e.message)),
+      pointerButton:(...args)=>toolbar.pointerButton(...args).catch(e=>toolbar.flash(e.message)),
+      move:(...args)=>toolbar.move(...args),scroll:(...args)=>toolbar.scroll(...args),
+    }:browser.context;
+    attachInput(client,window,input,fail);
+    await browser.context.resize(width,height,1);await browser.context.navigate(url);ready=true;draw();
+    // qml handle begin: send initial window size hints
+    await syncQmlConstraints();
+    // qml handle end
+
+    return {browser,client,window,toolbar,close,done};
+  }catch(e){close();throw e;}
+}
+if(import.meta.main){
+  const args=Bun.argv.slice(2).filter(a=>a!=='--');
+  if(args.some(a=>['-h','--help'].includes(a))){console.log('Usage: buninu-browser --wayland [URL or file] [--window-size=800,600]\nUses WAYLAND_DISPLAY and XDG_RUNTIME_DIR. Experimental wl_shm frontend.');process.exit(0);}
+  let width=800,height=600,url='about:blank';
+  for(const arg of args){if(arg.startsWith('--window-size=')){[width,height]=arg.slice(14).split(',').map(Number);}else if(arg.startsWith('-'))throw Error(`Unknown Wayland option: ${arg}`);else url=arg;}
+  if(!Number.isInteger(width)||!Number.isInteger(height)||width<1||height<1||width>8192||height>8192)throw Error('Invalid window size');
+  if(!/^[a-z][a-z\d+.-]*:/i.test(url))url=url.startsWith('/')||url.startsWith('.')?pathToFileURL(resolve(url)).href:`https://${url}`;
+  const app=await launch({url,width,height});for(const signal of ['SIGINT','SIGTERM','SIGHUP'])process.on(signal,app.close);await app.done;
+}

package/frontends/wayland/input.js

@@ -0,0 +1,75 @@
+import {readSync} from 'node:fs';
+import {libc} from './transport.js';
+
+// A deliberately bounded XKB subset, not a replacement for libxkbcommon.
+export function parseKeymap(text) {
+  const codes=new Map(),keys=new Map();
+  for(const m of text.matchAll(/<([^>]+)>\s*=\s*(\d+)/g))codes.set(m[1],Number(m[2])-8);
+  for(const m of text.matchAll(/key\s+<([^>]+)>\s*\{[^}]*\[([^\]]+)\]/g)){
+    const code=codes.get(m[1]);if(code!==undefined)keys.set(code,m[2].split(',').map(s=>s.trim()));
+  }return keys;
+}
+const names={space:' ',Return:'Enter',KP_Enter:'Enter',Tab:'Tab',ISO_Left_Tab:'Tab',Escape:'Escape',BackSpace:'Backspace',Delete:'Delete',Insert:'Insert',Home:'Home',End:'End',Prior:'PageUp',Next:'PageDown',Left:'ArrowLeft',Right:'ArrowRight',Up:'ArrowUp',Down:'ArrowDown',slash:'/',period:'.',comma:',',minus:'-',equal:'=',semicolon:';',apostrophe:"'",bracketleft:'[',bracketright:']',backslash:'\\',grave:'`'};
+export function keysym(symbol){
+  if(names[symbol]!==undefined)return names[symbol];if(!symbol)return null;
+  if(symbol.length===1||/^F\d+$/.test(symbol))return symbol;
+  if(/^(?:0x[\da-f]+|U[\da-f]+)$/i.test(symbol)){let n=parseInt(symbol.replace(/^U/i,''),16);if(n>=0xffbe&&n<=0xffe0)return 'F'+(n-0xffbd);const special={65288:'Backspace',65289:'Tab',65293:'Enter',65307:'Escape',65535:'Delete',65360:'Home',65361:'ArrowLeft',65362:'ArrowUp',65363:'ArrowRight',65364:'ArrowDown',65365:'PageUp',65366:'PageDown',65367:'End',65379:'Insert'};if(special[n])return special[n];if(n>=0xff00&&n<0x1000000)return null;if(n>=0x1000000)n-=0x1000000;return n>0&&n<=0x10ffff?String.fromCodePoint(n):null;}
+  return null;
+}
+export function attachInput(client,window,context,onError) {
+  if(!client.globals.has('wl_seat'))return;
+  let pointer,keyboard,x=0,y=0,focused=false,keys=new Map(),mods=0,locked=0;
+  let lastClick=null, clickCount=0;
+  const modifiers=()=>({modifiers:(mods&8?1:0)|(mods&4?2:0)|(mods&64?4:0)|(mods&1?8:0)});
+  const active=()=>!window.closed&&!client.connection.closed;
+  const invoke=(method,...args)=>{
+    if(!active())return;
+    // A compositor can send leave/modifier events in the same batch as close.
+    // Pending input is cancelled with the renderer; it must not restart/report it.
+    Promise.resolve().then(()=>active()?context[method](...args):undefined)
+      .catch(error=>{if(active())onError(error);});
+  };
+  const seat=client.bind('wl_seat',5,(event,[caps])=>{
+    if(event!=='capabilities')return;
+    if((caps&1)&&!pointer){pointer=client.object('wl_pointer',(name,args)=>{
+      if(name==='enter'){focused=args[1]===window.surface;[x,y]=args.slice(2);}
+      if(name==='leave'){focused=false;lastClick=null;clickCount=0;}
+      if(name==='motion'){[x,y]=args.slice(1);if(focused)invoke('move',x,y,modifiers());}
+
+      // Mouse-triggered copy also has a valid Wayland input serial.
+      if(name==='button'&&focused&&client.clipboard)client.clipboard.serial=args[0];
+
+      if(name==='button'&&focused){
+        const [,time,button,state]=args;
+        if(state){
+          // Wayland supplies monotonic uint32 milliseconds, not a click count.
+          // Allow modest touch jitter in surface coordinates; reset on leave.
+          clickCount=lastClick&&lastClick.button===button&&((time-lastClick.time)>>>0)<400
+            &&Math.abs(x-lastClick.x)<=12&&Math.abs(y-lastClick.y)<=12 ? clickCount+1 : 1;
+          lastClick={time,button,x,y};
+        }
+        const options={clickCount:clickCount||1,...modifiers()};
+        if(context.pointerButton)invoke('pointerButton',x,y,button,state,options);
+        else if(state===0&&button>=272&&button<=274)invoke('click',x,y,{...options,button:button===273?'right':button===274?'middle':'left'});
+      }
+      if(name==='axis'&&focused){
+        // Browser scrolling consumes pixel deltas. Land maps 100 CDP pixels
+        // to 10 Wayland axis units; restore that scale on the client side.
+        // Preserve fractional movement and apply page zoom later in the toolbar.
+        const delta=args[2]*10;
+        invoke('scroll',args[1]===1?delta:0,args[1]===0?delta:0,{x,y});
+      }
+    });client.request(seat,'get_pointer',pointer);}
+    if((caps&2)&&!keyboard){keyboard=client.object('wl_keyboard',(name,args)=>{
+
+      // Use the compositor's real keyboard serial for selection.
+      if(name==='enter'||name==='key')if(client.clipboard)client.clipboard.serial=args[0];
+
+      if(name==='keymap'){const [format,fd,size]=args;try{if(format===1&&size<=1024*1024){const bytes=Buffer.alloc(size);let n=0;while(n<size){const got=readSync(fd,bytes,n,size-n,n);if(!got)break;n+=got;}keys=parseKeymap(bytes.subarray(0,n).toString());}}finally{libc.close(fd);}}
+      if(name==='modifiers'){mods=args[1]|args[2];locked=args[3];}
+      if(name==='key'&&args[3]===1){const symbols=keys.get(args[2]);if(!symbols)return;let shift=!!(mods&1);if((locked&2)&&/^[a-z]$/.test(keysym(symbols[0])||''))shift=!shift;
+        const key=keysym(symbols[shift?1:0]||symbols[0]);if(key)invoke('press',key,{modifiers:(mods&8?1:0)|(mods&4?2:0)|(mods&64?4:0)|(mods&1?8:0)});
+      }
+    });client.request(seat,'get_keyboard',keyboard);}
+  });
+}

package/frontends/wayland/protocol.js

@@ -0,0 +1,55 @@
+// Adapted from buninu-land (MIT; LICENSE-land); XML files unchanged.
+// Interpret upstream XML with Bun's built-in parser at runtime; no generated bindings.
+import { readFileSync } from 'node:fs';
+const list = value => value == null ? [] : Array.isArray(value) ? value : [value];
+const attrs = node => Object.fromEntries(Object.entries(node).filter(([k]) => k.startsWith('@')).map(([k,v]) => [k.slice(1), v]));
+export const interfaces = new Map();
+for (const file of ['wayland', 'xdg-shell']) {
+  const xml = Bun.XML.parse(readFileSync(new URL(`./protocols/${file}.xml`, import.meta.url), 'utf8'));
+  for (const node of list(xml.protocol.interface)) {
+    const spec = { ...attrs(node) };
+    for (const [tag, key] of [['request', 'requests'], ['event', 'events']])
+      spec[key] = list(node[tag]).map(message => ({ ...attrs(message), args: list(message.arg).map(attrs) }));
+    interfaces.set(spec.name, spec);
+  }
+}
+export function decode(spec, bytes, fds) {
+  let offset = 8, fdOffset = 0;
+  const values = [];
+  const word = () => { if (offset + 4 > bytes.length) throw Error('Truncated argument'); const v = bytes.readUInt32LE(offset); offset += 4; return v; };
+  for (const arg of spec.args) {
+    if (arg.type === 'fd') { if (fdOffset === fds.length) return null; values.push(fds[fdOffset++]); continue; }
+    if (arg.type === 'new_id' && !arg.interface) {
+      const n = word(); if (!n || offset + n > bytes.length || bytes[offset + n - 1]) throw Error('Invalid interface string');
+      values.push(bytes.toString('utf8', offset, offset + n - 1)); offset += (n + 3) & ~3;
+      values.push(word(), word()); continue;
+    }
+    const v = word();
+    if (arg.type === 'string' || arg.type === 'array') {
+      if (offset + v > bytes.length) throw Error('Truncated array/string');
+      if (arg.type === 'string' && v && bytes[offset + v - 1]) throw Error('Unterminated string');
+      values.push(arg.type === 'string' ? (v ? bytes.toString('utf8', offset, offset + v - 1) : null) : bytes.subarray(offset, offset + v));
+      offset += (v + 3) & ~3;
+    } else values.push(arg.type === 'fixed' ? (v | 0) / 256 : arg.type === 'int' ? v | 0 : v);
+  }
+  if (offset !== bytes.length) throw Error('Invalid message size');
+  fds.splice(0, fdOffset);
+  return values;
+}
+export function encodeRequest(id, iface, name, values) {
+  const requests=interfaces.get(iface).requests, opcode=requests.findIndex(e=>e.name===name);
+  if(opcode<0)throw Error(`Unknown request ${iface}.${name}`);
+  const parts=[Buffer.alloc(8)],fds=[];
+  const word=v=>{const b=Buffer.alloc(4);b.writeUInt32LE(Number(v)>>>0);parts.push(b);};
+  const bytes=(value,string)=>{const b=string?Buffer.from(value==null?'':value+'\0'):Buffer.from(value);const p=Buffer.alloc(4+((b.length+3)&~3));p.writeUInt32LE(b.length);b.copy(p,4);parts.push(p);};
+  let i=0;
+  for(const arg of requests[opcode].args){
+    const v=values[i++];
+    if(arg.type==='fd'){fds.push(v);continue;}
+    if(arg.type==='new_id'&&!arg.interface){bytes(v,true);word(values[i++]);word(values[i++]);}
+    else if(arg.type==='string'||arg.type==='array')bytes(v,arg.type==='string');
+    else word(arg.type==='fixed'?Math.round(v*256):v);
+  }
+  const data=Buffer.concat(parts);if(data.length>65535)throw Error('Wayland message too large');
+  data.writeUInt32LE(id);data.writeUInt32LE((data.length<<16)|opcode,4);return {data,fds};
+}