buninu-linux 0.14.57 → 0.15.58

package/initramfs/buninu/apps/jsgotty/tests/kitty-keyboard.test.js

@@ -0,0 +1,102 @@
+const test=require('node:test');
+const assert=require('node:assert/strict');
+const {KittyKeyboard,SUPPORTED}=require('../static/js/kitty-keyboard.js');
+function setup(android=true) {
+  const handlers=new Map(),sent=[];
+  const term={parser:{registerCsiHandler:(id,fn)=>{handlers.set((id.prefix||id.intermediates||'')+id.final,fn);return {dispose(){}};},registerEscHandler:(id,fn)=>{handlers.set('ESC'+id.final,fn);return {dispose(){}};}},buffer:{active:{type:'normal'}},options:{},input:(s,user)=>sent.push([s,user])};
+  const keyboard=new KittyKeyboard(term,{android});
+  const mode=(prefix,params=[])=>handlers.get(prefix+'u')(params);
+  const event=(options={})=>({type:'keydown',key:'a',code:'KeyA',keyCode:65,location:0,repeat:false,ctrlKey:false,altKey:false,shiftKey:false,metaKey:false,getModifierState:()=>false,preventDefault(){this.prevented=true;},stopPropagation(){},...options});
+  const send=options=>{const e=event(options);return {e,result:keyboard.handle(e)};};
+  return {keyboard,term,sent,handlers,mode,send,event};
+}
+test('negotiation, bit operations, bounded stacks, separate screens and reset',()=>{
+ const t=setup();t.mode('?');assert.deepEqual(t.sent.pop(),['\x1b[?0u',false]);
+ t.mode('>',[11]);t.mode('>',[1]);t.mode('<');assert.equal(t.keyboard.flags,11);
+ t.mode('=',[2,3]);assert.equal(t.keyboard.flags,9);t.mode('=',[2,2]);assert.equal(t.keyboard.flags,11);
+ t.term.buffer.active.type='alternate';assert.equal(t.keyboard.flags,0);t.mode('>',[3]);
+ t.term.buffer.active.type='normal';assert.equal(t.keyboard.flags,11);
+ for(let i=0;i<100;i++)t.mode('>',[1]);assert.equal(t.keyboard.state.stack.length,32);
+ t.mode('<',[99999]);assert.equal(t.keyboard.flags,0);
+ t.mode('=',[31]);assert.equal(t.keyboard.flags,SUPPORTED);t.mode('=',[0]);assert.equal(t.keyboard.flags,0);
+ t.handlers.get('ESCc')();t.term.buffer.active.type='alternate';assert.equal(t.keyboard.flags,0);
+});
+test('all sixteen Shift/Alt/Ctrl/Super combinations stay distinct for all letters and navigation',()=>{
+ for(const key of [...'abcdefghijklmnopqrstuvwxyz','ArrowLeft','ArrowRight','ArrowUp','ArrowDown','Tab','Enter','Backspace','Insert','PageUp','PageDown','F1','F12','PrintScreen']) {
+  const seen=new Set();
+  for(let mask=0;mask<16;mask++) {
+   const t=setup();t.mode('>',[11]);t.send({key,code:key.length===1?'Key'+key.toUpperCase():key,shiftKey:!!(mask&1),altKey:!!(mask&2),ctrlKey:!!(mask&4),metaKey:!!(mask&8)});
+   assert.equal(t.sent.length,1,`${key} ${mask}`);seen.add(t.sent[0][0]);
+  }
+  assert.equal(seen.size,16,key);
+ }
+});
+test('Android Meta pair repairs missing metaKey, including keyup and combinations',()=>{
+ const t=setup();t.mode('>',[11]);
+ t.send({key:'Meta',code:'',keyCode:91});
+ assert.deepEqual(t.sent.pop(),['\x1b[57444;9u',true]);
+ const {e}=t.send({key:'x',code:'',keyCode:88,ctrlKey:true,shiftKey:true});
+ assert.equal(e.metaKey,true);assert.equal(e.getModifierState('Meta'),true);
+ assert.deepEqual(t.sent.pop(),['\x1b[120;14u',true]);
+ t.send({type:'keyup',key:'x',code:'',keyCode:88,ctrlKey:true,shiftKey:true});assert.equal(t.sent.pop()[0],'\x1b[120;14:3u');
+ t.send({type:'keyup',key:'Meta',code:'',keyCode:91});assert.equal(t.sent.pop()[0],'\x1b[57444;1:3u');
+ t.send({key:'x',code:'KeyX'});assert.equal(t.sent.pop()[0],'\x1b[120u');
+});
+test('both Meta keys, repeats and focus cleanup do not leave modifiers held',()=>{
+ const t=setup();t.mode('>',[11]);
+ t.send({key:'Meta',code:'MetaLeft',location:1});t.send({key:'Meta',code:'MetaRight',location:2});
+ t.send({type:'keyup',key:'Meta',code:'MetaLeft',location:1});assert.equal(t.sent.at(-1)[0],'\x1b[57444;9:3u');
+ t.send({repeat:true});assert.equal(t.sent.at(-1)[0],'\x1b[97;9:2u');
+ t.keyboard.clearHeld();assert.equal(t.keyboard.metaKeys.size,0);
+ t.send();assert.equal(t.sent.at(-1)[0],'\x1b[97u');
+});
+test('legacy remains unchanged; disabling mode restores text and ordinary controls',()=>{
+ const t=setup();assert.equal(t.send({ctrlKey:true}).result,true);assert.equal(t.sent.length,0);
+ t.mode('>',[1]);assert.equal(t.send().result,true);
+ for(const key of ['Tab','Enter','Backspace'])assert.equal(t.send({key,code:key}).result,true);
+ t.send({ctrlKey:true,key:'i',code:'KeyI'});assert.equal(t.sent.pop()[0],'\x1b[105;5u');
+ t.send({ctrlKey:true,shiftKey:true,key:'I',code:'KeyI'});assert.equal(t.sent.pop()[0],'\x1b[105;6u');
+ t.mode('<');assert.equal(t.send({ctrlKey:true}).result,true);
+});
+test('printable keys in disambiguation mode do not generate release events',()=>{
+ const t=setup();t.mode('>',[3]);t.send();t.send({type:'keyup'});assert.equal(t.sent.length,0);
+ t.send({ctrlKey:true});t.send({type:'keyup',ctrlKey:true});assert.deepEqual(t.sent.map(s=>s[0]),['\x1b[97;5u','\x1b[97;5:3u']);
+});
+test('dead Alt keys recover before encoding; regular composition is untouched',()=>{
+ const t=setup();t.mode('>',[11]);
+ for(const k of 'ENUI'){t.send({key:'Dead',code:'Key'+k,altKey:true});assert.equal(t.sent.pop()[0],`\x1b[${k.toLowerCase().charCodeAt(0)};3u`);}
+ assert.equal(t.send({isComposing:true,key:'Process'}).result,true);
+ assert.equal(t.send({key:'Dead',altKey:false}).result,true);
+});
+test('AltGr is not encoded as Ctrl+Alt; non-Latin layout key values are preserved',()=>{
+ const t=setup();t.mode('>',[11]);
+ t.send({key:'€',code:'KeyE',ctrlKey:true,altKey:true,getModifierState:k=>k==='AltGraph'});assert.equal(t.sent.pop()[0],'\x1b[8364u');
+ t.send({key:'ф',code:'KeyA',ctrlKey:true});assert.equal(t.sent.pop()[0],'\x1b[1092;5u');
+});
+test('keypad, media and lock modifiers have dedicated encodings',()=>{
+ const t=setup();t.mode('>',[11]);
+ t.send({key:'Enter',code:'NumpadEnter',location:3});assert.equal(t.sent.pop()[0],'\x1b[57414u');
+ t.send({key:'AudioVolumeUp',code:'AudioVolumeUp'});assert.equal(t.sent.pop()[0],'\x1b[57439u');
+ t.send({getModifierState:k=>k==='CapsLock'});assert.equal(t.sent.pop()[0],'\x1b[97;65u');
+});
+test('normal non-Android Meta and input disabled are not rewritten',()=>{
+ const t=setup(false);t.mode('>',[11]);t.send({key:'Meta',code:'MetaLeft'});const {e}=t.send();assert.equal(e.metaKey,false);
+ t.term.options.disableStdin=true;const count=t.sent.length;assert.equal(t.send({metaKey:true}).result,true);assert.equal(t.sent.length,count);
+});
+test('keypress cannot duplicate encoded keydown, but later ordinary text is not swallowed',()=>{
+ const t=setup();t.mode('>',[1]);t.send({ctrlKey:true});assert.equal(t.send({type:'keypress',ctrlKey:true}).result,false);
+ t.send({key:'b',code:'KeyB'});assert.equal(t.send({type:'keypress',key:'b',code:'KeyB'}).result,true);
+});
+test('Android release-only accent shortcuts still use Kitty encoding',()=>{
+ const t=setup();t.mode('>',[11]);t.send({type:'keyup',key:'Dead',code:'',keyCode:69,altKey:true});
+ assert.deepEqual(t.sent.map(x=>x[0]),['\x1b[101;3u','\x1b[101;3:3u']);
+});
+test('Omarchy workspace and monitor chords retain all modifiers',()=>{
+ for(const key of [...'1234567890','ArrowLeft','ArrowRight','ArrowUp','ArrowDown','Tab','Home','`']) {
+  const t=setup();t.mode('>',[11]);
+  t.send({key,code:key.length===1?'':key,metaKey:true,shiftKey:true,altKey:true});
+  assert.match(t.sent.at(-1)[0],/;12[~uABCDH]$/);
+  t.send({key,code:key.length===1?'':key,metaKey:true,shiftKey:true,ctrlKey:true});
+  assert.match(t.sent.at(-1)[0],/;14[~uABCDH]$/);
+ }
+});

package/initramfs/buninu/apps/jsgotty/tests/manual/README.md

@@ -0,0 +1,20 @@
+# 鍵盤診斷（手動）
+
+此工具不由正式前端載入，也不需要修改 `static/js/gotty.js` 或安裝依賴。
+
+1. 在與 Android WebView 共用本機網路的環境啟動收集器：
+
+   ```sh
+   node tests/manual/keyboard-collector.cjs
+   # 可指定 port 與輸出檔；預設 18766、系統暫存目錄的 jsgotty-keyboard-debug.jsonl
+   ```
+
+2. 連上 jsgotty 後，透過該頁面的 DevTools Console 或 CDP `Runtime.evaluate` 執行收集器印出的 JavaScript。每次啟動會產生新 token。若要從另一台裝置連線，需要另行調整收集器位址與監聽設定。
+3. 按下要測試的組合鍵，讀取收集器顯示的 JSONL 路徑。每頁最多 2000 筆、10 分鐘；重跑載入指令即可開始新一輪。檔案採追加寫入，以 `session` 分組並依 `sequence` 排序，避免 HTTP 到達順序不同造成誤判。
+4. 停止頁面診斷：`window.stopGottyKeyboardDebug()`；或重新載入頁面。收集器按 Ctrl-C 停止。
+
+記錄內容包含原始 keydown/keypress/keyup、beforeinput/input、composition 事件、既有按鍵處理器回傳值、事件處理完成後的取消狀態，以及 xterm `onData` 的 UTF-8 位元組（前 64 bytes）。onData 是前端產生的終端資料，並非伺服器 PTY 接收確認。診斷期間只輸入測試內容，避免留下密碼或其他敏感輸入。
+
+紀錄也保留於 `window.__gottyKeyboardRecords`；傳輸失敗原因在 `window.__gottyKeyboardDeliveryError`。若無需 HTTP 收集器，可直接在 Console/CDP 執行 `keyboard-debug.js` 的內容，再呼叫 `window.startGottyKeyboardDebug()`。
+
+工具透過 `element.__gottyXterm` 尋找終端，暫時包裝 xterm 的 `_core._customKeyEventHandler`，停止時還原。因此升級 xterm 後需要再確認這個內部欄位；正式產品不依賴此診斷工具。舊的 `#keyboard-debug` 網址片段不再啟用任何診斷。

package/initramfs/buninu/apps/jsgotty/tests/manual/keyboard-collector.cjs

@@ -0,0 +1,55 @@
+// Usage: node tests/manual/keyboard-collector.cjs [port] [output.jsonl]
+const http = require('node:http');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const { randomBytes } = require('node:crypto');
+const port = Number(process.argv[2] || 18766);
+const file = path.resolve(process.argv[3] || path.join(os.tmpdir(), 'jsgotty-keyboard-debug.jsonl'));
+const token = randomBytes(16).toString('hex');
+const endpoint = `http://127.0.0.1:${port}/${token}`;
+const client = fs.readFileSync(path.join(__dirname, 'keyboard-debug.js'), 'utf8') +
+  `\nwindow.startGottyKeyboardDebug({endpoint:${JSON.stringify(endpoint)}});\n`;
+let count = 0;
+http.createServer((req, res) => {
+  res.setHeader('Access-Control-Allow-Origin', '*');
+  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+  res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+  res.setHeader('Access-Control-Allow-Private-Network', 'true');
+  res.setHeader('Cache-Control', 'no-store');
+  if (req.url !== '/' + token && req.url !== '/' + token + '/client.js') {
+    res.writeHead(404); return res.end();
+  }
+  if (req.method === 'OPTIONS') { res.writeHead(204); return res.end(); }
+  if (req.method === 'GET' && req.url.endsWith('/client.js')) {
+    res.setHeader('Content-Type', 'application/javascript');
+    return res.end(client);
+  }
+  if (req.method !== 'POST' || req.url !== '/' + token) {
+    res.writeHead(405); return res.end();
+  }
+  let body = '';
+  req.on('data', chunk => {
+    body += chunk;
+    if (body.length > 16384) req.destroy();
+  });
+  req.on('end', () => {
+    if (count >= 20000) { res.writeHead(429); return res.end(); }
+    let event;
+    try { event = JSON.parse(body); }
+    catch { res.writeHead(400); return res.end(); }
+    try {
+      fs.appendFileSync(file, JSON.stringify({receivedAt: new Date().toISOString(), event}) + '\n', {mode: 0o600});
+      count++;
+      res.writeHead(204); res.end();
+    } catch (error) {
+      console.error(error.message);
+      res.writeHead(500); res.end();
+    }
+  });
+}).listen(port, '127.0.0.1', () => {
+  console.log('Log (append): ' + file);
+  console.log('Run in the connected jsgotty page via DevTools or CDP:');
+  console.log(`fetch(${JSON.stringify(endpoint + '/client.js')}).then(r => r.text()).then(source => (0, eval)(source))`);
+  console.log('Stop browser capture: window.stopGottyKeyboardDebug()');
+});

package/initramfs/buninu/apps/jsgotty/tests/manual/keyboard-debug.js

@@ -0,0 +1,74 @@
+// Manually loaded diagnostic helper. Never loaded by the production frontend.
+window.startGottyKeyboardDebug = ({ endpoint, term } = {}) => {
+  window.stopGottyKeyboardDebug?.();
+  term ??= Array.from(document.querySelectorAll("*")).find(el => el.__gottyXterm)?.__gottyXterm;
+  if (!term) throw new Error("No jsgotty xterm found; connect the terminal first.");
+  const listeners = [];
+  let stopped = false;
+  const records = [];
+  const started = Date.now();
+  const session = Math.random().toString(36).slice(2);
+  window.__gottyKeyboardRecords = records;
+  window.__gottyKeyboardDebug = (stage, details = {}) => {
+    if (stopped || records.length >= 2000 || Date.now() - started > 600000) return;
+    const record = { session, sequence: records.length, time: new Date().toISOString(), stage, ...details };
+    records.push(record);
+    console.log("[gotty-keyboard]", record);
+    if (endpoint) fetch(endpoint, {
+      method: "POST", headers: { "Content-Type": "text/plain" },
+      body: JSON.stringify(record),
+    }).catch(error => { window.__gottyKeyboardDeliveryError = String(error); });
+  };
+  window.__gottyKeyboardDebug("ready", {
+    userAgent: navigator.userAgent, platform: navigator.platform,
+    userAgentData: navigator.userAgentData?.platform,
+  });
+  for (const type of ["keydown", "keypress", "keyup", "beforeinput", "input",
+    "compositionstart", "compositionupdate", "compositionend"]) {
+    const listener = event => {
+      const details = {
+        type, key: event.key, code: event.code, keyCode: event.keyCode,
+        charCode: event.charCode, which: event.which, altKey: event.altKey,
+        ctrlKey: event.ctrlKey, metaKey: event.metaKey, shiftKey: event.shiftKey,
+        altGraph: event.getModifierState?.("AltGraph"),
+        isComposing: event.isComposing, repeat: event.repeat,
+        cancelable: event.cancelable, defaultPrevented: event.defaultPrevented,
+        inputType: event.inputType, data: event.data?.slice(0, 64),
+        target: event.target?.tagName, trusted: event.isTrusted,
+      };
+      window.__gottyKeyboardDebug("capture", details);
+      setTimeout(() => window.__gottyKeyboardDebug("after-dispatch", {
+        ...details, defaultPrevented: event.defaultPrevented,
+      }));
+    };
+    window.addEventListener(type, listener, true);
+    listeners.push([type, listener]);
+  }
+  // Preserve the existing Android handler, including its return value.
+  const previousHandler = term._core?._customKeyEventHandler;
+  if (!term._core) throw new Error("Unsupported xterm internals");
+  const handler = event => {
+    const result = previousHandler ? previousHandler.call(term._core, event) : true;
+    window.__gottyKeyboardDebug("alt-handler", {
+      type: event.type, key: event.key, code: event.code,
+      result, defaultPrevented: event.defaultPrevented,
+    });
+    return result;
+  };
+  term.attachCustomKeyEventHandler(handler);
+  const subscription = term.onData(text => {
+    const bytes = new TextEncoder().encode(text);
+    window.__gottyKeyboardDebug("terminal-data", {
+      length: bytes.length, bytes: Array.from(bytes.slice(0, 64)),
+    });
+  });
+  window.stopGottyKeyboardDebug = () => {
+    stopped = true;
+    for (const [type, listener] of listeners) window.removeEventListener(type, listener, true);
+    subscription.dispose();
+    if (term._core._customKeyEventHandler === handler)
+      term.attachCustomKeyEventHandler(previousHandler);
+  };
+  return { records, stop: window.stopGottyKeyboardDebug };
+};
+

package/initramfs/buninu/apps/jsgotty/tests/manual/kitty-keyboard.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+// Run inside jsgotty. Exits after 60 seconds or unmodified Escape/q/Ctrl-C.
+// Uses only built-ins and restores the prior Kitty mode and raw mode on exit.
+const input=process.stdin, output=process.stdout;
+const cyan = '\x1b[96m', reset = '\x1b[0m';
+const keyNames = {
+  9: 'tab', 13: 'enter', 27: 'esc', 32: 'space', 127: 'backspace',
+  57358: 'caps-lock', 57359: 'scroll-lock', 57360: 'num-lock',
+  57361: 'print-screen', 57362: 'pause', 57363: 'menu',
+  57409: 'kp-decimal', 57410: 'kp-divide', 57411: 'kp-multiply',
+  57412: 'kp-subtract', 57413: 'kp-add', 57414: 'kp-enter',
+  57415: 'kp-equal', 57416: 'kp-separator',
+  57417: 'kp-left', 57418: 'kp-right', 57419: 'kp-up', 57420: 'kp-down',
+  57421: 'kp-page-up', 57422: 'kp-page-down', 57423: 'kp-home',
+  57424: 'kp-end', 57425: 'kp-insert', 57426: 'kp-delete', 57427: 'kp-begin',
+  57428: 'media-play', 57429: 'media-pause', 57430: 'media-play-pause',
+  57431: 'media-reverse', 57432: 'media-stop', 57433: 'media-fast-forward',
+  57434: 'media-rewind', 57435: 'media-next', 57436: 'media-previous',
+  57437: 'media-record', 57438: 'volume-down', 57439: 'volume-up',
+  57440: 'volume-mute', 57453: 'altgr', 57454: 'iso-level5-shift',
+};
+for (let n=13; n<=35; n++) keyNames[57376+n-13] = 'f'+n;
+for (let n=0; n<=9; n++) keyNames[57399+n] = 'kp-'+n;
+const modifierKeys = ['shift', 'ctrl', 'alt', 'super', 'hyper', 'meta'];
+const modifierBits = [1, 4, 2, 8, 16, 32];
+function readableChord(key, suffix, bits) {
+  const number = Number(key.split(':')[0] || 1);
+  let name;
+  if (suffix === 'u') {
+    if (number >= 57441 && number <= 57452) {
+      const index = (number-57441)%6;
+      name = modifierKeys[index] + (number >= 57447 ? '-right' : '-left');
+      bits &= ~modifierBits[index]; // "super-left", not "super-super-left".
+    } else {
+      name = keyNames[number];
+      if (!name) name = number >= 33 && number <= 0x10ffff &&
+        !(number >= 0x7f && number <= 0x9f) &&
+        !(number >= 0xd800 && number <= 0xf8ff)
+        ? String.fromCodePoint(number) : 'key-'+number;
+    }
+  } else if (suffix === '~') {
+    name = {2:'insert', 3:'delete', 5:'page-up', 6:'page-down', 7:'home', 8:'end',
+      11:'f1', 12:'f2', 13:'f3', 14:'f4', 15:'f5', 17:'f6',
+      18:'f7', 19:'f8', 20:'f9', 21:'f10', 23:'f11', 24:'f12'}[number];
+  } else {
+    name = {A:'up', B:'down', C:'right', D:'left', E:'begin',
+      F:'end', H:'home', P:'f1', Q:'f2', S:'f4'}[suffix];
+  }
+  const modifiers = [[4,'ctrl'], [2,'alt'], [1,'shift'], [8,'super'],
+    [16,'hyper'], [32,'meta'], [64,'caps-lock'], [128,'num-lock']]
+    .filter(([bit]) => bits & bit).map(([,label]) => label);
+  return [...modifiers, name || `key-${number}${suffix}`].join('-');
+}
+if(!input.isTTY || !output.isTTY) {console.error('Run this inside an interactive jsgotty terminal.');process.exit(1);}
+const wasRaw=Boolean(input.isRaw);let closed=false,buffer='';
+const finish=()=>{if(closed)return;closed=true;clearTimeout(timer);output.write('\x1b[<u\r\nKeyboard mode restored.\r\n');input.setRawMode(wasRaw);input.pause();};
+const timer=setTimeout(finish,60000);
+process.on('SIGINT',finish);process.on('SIGTERM',finish);process.on('exit',finish);
+input.setRawMode(true);input.setEncoding('utf8');input.resume();
+output.write('Kitty keyboard test: try SUP, CTRL, ALT, SHFT + letters/arrows.\r\nEscape, q or Ctrl-C exits; automatic exit in 60 seconds.\r\n\x1b[>11u\x1b[?u');
+input.on('data',data=>{
+ if(closed)return;
+ buffer+=data;
+ while(buffer) {
+  const match=/^\x1b\[([?]?)([0-9:;]*)([u~A-Z])/.exec(buffer);
+  if(!match) {
+   if(buffer==='\x1b' || /^\x1b\[[?0-9:;]*$/.test(buffer))break;
+   const ch=[...buffer][0];buffer=buffer.slice(ch.length);output.write('legacy '+JSON.stringify(ch)+'\r\n');
+   if(ch==='q'||ch==='\x03') {finish();return;}continue;
+  }
+  buffer=buffer.slice(match[0].length);
+  if(match[1]==='?'){output.write('negotiated flags='+match[2]+' (expected 11)\r\n');continue;}
+  const [key,mod='1']=match[2].split(';');const [encoded,type='1']=mod.split(':');const bits=Number(encoded)-1;
+  const names=[[1,'Shift'],[2,'Alt'],[4,'Ctrl'],[8,'Super'],[16,'Hyper'],[32,'Meta'],[64,'CapsLock'],[128,'NumLock']].filter(([bit])=>bits&bit).map(([,name])=>name);
+  const chord = readableChord(key, match[3], bits);
+  output.write(`${cyan}${chord}${reset}  ${{1:'press',2:'repeat',3:'release'}[type]||type}  raw=${JSON.stringify(match[0])} key=${key}${match[3]} modifiers=${names.join('+')||'none'}\r\n`);
+  if(match[3]==='u' && type==='1' && ((!(bits&63)&&['27','113'].includes(key)) || ((bits&63)===4 && key==='99'))) {finish();return;}
+ }
+ if(buffer.length>4096)buffer='';
+});

package/initramfs/buninu/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buninu",
-  "version": "0.4.21",
+  "version": "0.5.0",
   "description": "Buninu is a portable, self-bootstrapping Unix-like userspace built on Bun that runs across operating systems",
   "type": "module",
   "main": "./bin/init.js",

package/initramfs/init.js

@@ -462,7 +462,10 @@ Type bunterm in bunmsh: Graphical Terminal
         ...process.env,
         PATH:  classic_path + ":" +
                buninu_path,
-        HOME:"/buninu"
+        HOME:"/buninu",
+        PULSE_SERVER:"127.0.0.1",
+        XDG_RUNTIME_DIR:"/tmp",
+        WAYLAND_DISPLAY:"wayland-buninu"
       },
       stdin: "inherit",
       stdout: "inherit",
@@ -540,11 +543,12 @@ const configureEthernet = () => {
 };
 
 // Explicit full coldplug for this deliberately tiny system: load every .ko
-// represented in modules.dep, recursively including each module's declared
+// represented in modules.dep except GPU modules (cfg.gpu only), including declared
 // dependencies. Failures are reported individually without stopping the rest.
 const configureModules = () => {
   const { modprobeAll } = require("/lib/modprobe.js");
-  const report = modprobeAll();
+  const { isGpuPath } = require("/lib/gpu.js");
+  const report = modprobeAll({ accept: (module, path) => !isGpuPath(module, path) });
   console.log(`modules: ${report.inserted.length} newly loaded, ${report.errors.length} failed`);
   for (const { module, error } of report.errors) console.log(`modules: ${module}: ${error}`);
   return report;
@@ -579,12 +583,24 @@ const configureSound = () => {
   return devices;
 };
 
+const configureGraphics = () => {
+  try {
+    const { configureGpu } = require("/lib/gpu.js");
+    const { autoload, tryModprobe } = require("/lib/modprobe.js");
+    return configureGpu({ autoload, tryModprobe });
+  } catch (error) {
+    console.log(`[gpu] failed: ${error?.message ?? error}; init continues`);
+    return { errors: [String(error?.message ?? error)] };
+  }
+};
+
 globalThis.cfg = Object.freeze(Object.defineProperties({}, {
   all: { enumerable: true, get: configureModules },
   disk: { enumerable: true, get: configureDisks },
   net: { enumerable: true, get: configureEthernet },
   power: { enumerable: true, get: configureBattery },
   sound: { enumerable: true, get: configureSound },
+  gpu: { enumerable: true, get: configureGraphics },
 }));
 
 // Compatibility aliases for images and notes that used the original API.

package/initramfs/lib/bunterm/clipboard.js

@@ -24,6 +24,20 @@ const runXclip = async (args, input) => {
   return output;
 };
 
+export const readClipboard = async () => Buffer.from(await runXclip(["-o"])).toString("utf8");
+export const writeClipboard = (text) => runXclip([], Buffer.from(text, "utf8"));
+
+// Match xterm's paste behavior: normalize newlines and prevent embedded closing
+// delimiters from escaping bracketed paste. Legacy programs have not negotiated
+// DECSET 2004 and must receive plain text.
+export function pasteText(term, text, write) {
+  text = text.replace(/\r\n|\n/g, "\r");
+  if (term._core?.coreService?.decPrivateModes?.bracketedPasteMode) {
+    text = `\x1b[200~${text.replace(/\x1b/g, "")}\x1b[201~`;
+  }
+  write(text);
+}
+
 // Registers the OSC 52 handler on an xterm.js terminal. `reply` sends bytes
 // back to the program, as the terminal's other replies do. A read the xclip
 // call cannot answer is still answered, with empty contents, so the program

package/initramfs/lib/bunterm/commands.js

@@ -0,0 +1,37 @@
+// Local bunterm commands. Deliberately separate from the child shell.
+export function createCommands({fontSize, setFontSize, copy, paste, switchVT}) {
+  const commands = new Map([
+    ["help", () => "font SIZE / + / - | copy | paste | vt NUMBER | help"],
+    ["font", args => {
+      if (args.length !== 1) throw new Error("Usage: font SIZE / + / -");
+      const size = args[0] === "+" ? fontSize()+1 : args[0] === "-" ? fontSize()-1 : Number(args[0]);
+      setFontSize(size);
+      return `Font: ${fontSize()}`;
+    }],
+    ["copy", async args => {
+      if (args.length) throw new Error("Usage: copy");
+      await copy();
+      return "Copied";
+    }],
+    ["paste", async args => {
+      if (args.length) throw new Error("Usage: paste");
+      await paste();
+      return "Pasted";
+    }],
+    ["vt", async args => {
+      if (args.length !== 1 || !/^[1-9]\d*$/.test(args[0]) || Number(args[0]) > 63) throw new Error("Usage: vt 1..63");
+      await switchVT(Number(args[0]));
+      return "";
+    }],
+  ]);
+  return {
+    commands,
+    async execute(line) {
+      const [name, ...args] = line.trim().split(/\s+/);
+      if (!name) return "";
+      const command = commands.get(name);
+      if (!command) throw new Error(`Unknown command: ${name}; try help`);
+      return await command(args);
+    },
+  };
+}

package/initramfs/lib/bunterm/fps.js

@@ -0,0 +1,38 @@
+// Count newly presented Kitty images, not pointer, menu or counter repaints.
+export function createFpsMeter(now = () => performance.now()) {
+  let enabled = false, seen = new WeakSet(), frames = 0, since = 0, value = 0;
+  return {
+    get enabled() { return enabled; },
+    get value() { return value; },
+    toggle(images = []) {
+      enabled = !enabled;
+      seen = new WeakSet(images.map(({image}) => image)); frames = 0; value = 0; since = now();
+      return enabled;
+    },
+    presented(images) {
+      if (!enabled) return;
+      let fresh = false;
+      for (const {image} of images) {
+        if (!seen.has(image)) { seen.add(image); fresh = true; }
+      }
+      if (fresh) frames++;
+    },
+    sample() {
+      const time = now(), elapsed = time - since;
+      value = enabled && elapsed > 0 ? frames * 1000 / elapsed : 0;
+      frames = 0; since = time;
+      return value;
+    },
+    draw(renderer) {
+      if (!enabled) return;
+      const label = `FPS ${value.toFixed(1)}`;
+      const columns = Math.min(renderer.columns, label.length + 2);
+      const width = columns * renderer.cellWidth;
+      const x = renderer.offsetX + renderer.columns * renderer.cellWidth - width;
+      const y = renderer.offsetY;
+      renderer.canvas.drawRect(renderer.CanvasKit.XYWHRect(x,y,width,renderer.cellHeight),
+        renderer.paintFor([20,25,30]));
+      renderer.drawText(label,x,y,columns,[65,220,230],{align:"center"});
+    },
+  };
+}

package/initramfs/lib/bunterm/images.js

@@ -1,3 +1,4 @@
+import {createRawImage} from '../raw-image.js';
 // /lib/bunterm/images.js — kitty graphics protocol placements on the cell
 // grid.
 //
@@ -15,12 +16,13 @@ const number = (value, fallback = 0) => {
 // Decodes a transferred image into a Skia Image. Format 100 is PNG (or any
 // encoded format Skia knows); 24 and 32 are raw RGB / RGBA. Bun.Image, when
 // present, transcodes encodings Skia cannot read on its own.
-export const decodeImage = async (CanvasKit, image) => {
+export const decodeImage = async (CanvasKit, image, {deferRaw = false} = {}) => {
   // The local parser supplies bytes; retain compatibility with base64 callers.
   const bytes = typeof image.data === "string" ? Buffer.from(image.data, "base64") : image.data;
-  if (image.format === 24 || image.format === 32) {
+  if (image.format === 24 || image.format === 32 || image.format === 0x42475241) {
     const { width, height } = image;
-    if (!width || !height) throw new Error("raw image without dimensions");
+    if (!Number.isInteger(width)||!Number.isInteger(height)||width<1||height<1||width*height>16777216
+      ||bytes.byteLength!==width*height*(image.format===24?3:4)) throw new Error("invalid raw image dimensions or byte count");
     let pixels = bytes;
     if (image.format === 24) {
       pixels = Buffer.alloc(width * height * 4, 255);
@@ -30,9 +32,11 @@ export const decodeImage = async (CanvasKit, image) => {
         pixels[o + 2] = bytes[i + 2];
       }
     }
+    const colorType = image.format === 0x42475241 ? CanvasKit.ColorType.BGRA_8888 : CanvasKit.ColorType.RGBA_8888;
+    if (deferRaw) return createRawImage(CanvasKit, pixels, width, height, colorType);
     const decoded = CanvasKit.MakeImage({
       width, height,
-      colorType: CanvasKit.ColorType.RGBA_8888,
+      colorType: image.format === 0x42475241 ? CanvasKit.ColorType.BGRA_8888 : CanvasKit.ColorType.RGBA_8888,
       alphaType: CanvasKit.AlphaType.Unpremul,
       colorSpace: CanvasKit.ColorSpace.SRGB,
     }, pixels, width * 4);
@@ -75,7 +79,7 @@ export class ImageStore {
     const replacesImage = decoded && this.imageSources.get(image.id) !== image;
     if (!decoded || replacesImage) {
       try {
-        const replacement = await decodeImage(this.CanvasKit, image);
+        const replacement = await decodeImage(this.CanvasKit, image, {deferRaw: true});
         if (replacesImage) {
           // Kitty requires retransmitting a non-zero image id to delete the
           // old image and all its placements.  Screen-streaming clients such

package/initramfs/lib/bunterm/input.js

@@ -6,8 +6,9 @@
 // "linux" console sequences for a few keys are rewritten into the xterm
 // forms that programs seeing TERM=xterm-256color expect.
 
-import { closeSync, openSync, read } from "node:fs";
+import { closeSync, openSync, readSync, constants } from "node:fs";
 import { libc, ptr, errno, strerror } from "../dlopen.js";
+import { ConsoleKeys, MediumRawDecoder } from "./keycodes.js";
 
 const TCGETS = 0x5401;
 const TCSETS = 0x5402;
@@ -108,33 +109,75 @@ export const translateKeys = (text, { applicationCursorKeys = false } = {}) => {
 // Opens the keyboard: `device` names a console such as /dev/tty1; without
 // it the process's own stdin is used (it must be a terminal). `onData`
 // receives Buffers. close() restores the previous terminal settings.
-export const openKeyboard = ({ device = null, onData, onError = () => {} }) => {
-  const fd = device ? openSync(device, "r+") : 0;
-  const saved = getTermios(fd);
-  setTermios(fd, rawTermios(saved));
+export const openKeyboard = ({ device = null, onData, onKey = () => {}, onError = () => {} }) => {
+  // Own a nonblocking file description: no outstanding async read can deliver
+  // bytes from the previous keyboard mode after a protocol transition.
+  const fd = openSync(device || "/proc/self/fd/0", constants.O_RDWR | constants.O_NONBLOCK);
+  let saved;
+  try {
+    saved = getTermios(fd);
+    setTermios(fd, rawTermios(saved));
+  } catch (error) {
+    closeSync(fd);
+    throw error;
+  }
+  const originalMode = new Int32Array(1);
+  const canReadMode = libc.symbols.ioctl(fd, 0x4b44, ptr(originalMode)) === 0;
+  let enhanced = false, decoder, keys;
+  const setEnhanced = (enabled) => {
+    if (enabled === enhanced) return;
+    if (!canReadMode) throw new Error("Kitty keyboard needs a Linux virtual console (KDGKBMODE)");
+    const maps = [];
+    if (enabled) {
+      // Unicode keysyms can only be queried while the console is still in
+      // K_UNICODE, before switching to K_MEDIUMRAW.
+      for (let table = 0; table < 4; table++) {
+        maps[table] = [];
+        for (let number = 0; number < 256; number++) {
+          const entry = new Uint8Array([table,number,0,0]);
+          maps[table][number] = libc.symbols.ioctl(fd,0x4b46,ptr(entry)) === 0
+            ? new DataView(entry.buffer).getUint16(2,true) : null;
+        }
+      }
+    }
+    // Discard only console typeahead at the mode boundary, never PTY input.
+    if (libc.symbols.ioctl(fd, 0x540b, 0) === -1) fail("TCFLSH");
+    if (libc.symbols.ioctl(fd, 0x4b45, enabled ? 2 : originalMode[0]) === -1) fail("KDSKBMODE");
+    enhanced = enabled;
+    decoder = new MediumRawDecoder();
+    const leds = new Uint8Array(1);
+    libc.symbols.ioctl(fd, 0x4b64, ptr(leds));
+    keys = new ConsoleKeys({ leds: leds[0], lookup: (table, number) => maps[table]?.[number] });
+  };
   let open = true;
+  let timer;
   const chunk = Buffer.alloc(4096);
   const pump = () => {
     if (!open) return;
-    read(fd, chunk, 0, chunk.length, null, (error, count) => {
-      if (!open) return;
-      if (error) {
-        if (error.code === "EAGAIN") { setTimeout(pump, 10); return; }
-        onError(error);
-        return;
+    try {
+      for (let batch = 0; batch < 16; batch++) {
+        const count = readSync(fd, chunk, 0, chunk.length, null);
+        if (!count) break;
+          if (enhanced) decoder.feed(chunk.subarray(0, count), (code, down) => onKey(keys.event(code, down)));
+          else onData(Buffer.from(chunk.subarray(0, count)));
       }
-      if (count > 0) onData(Buffer.from(chunk.subarray(0, count)));
-      pump();
-    });
+    } catch (error) {
+      if (error.code !== "EAGAIN" && error.code !== "EWOULDBLOCK") { onError(error); return; }
+    }
+    timer = setTimeout(pump, 4);
   };
   pump();
   return {
     fd,
+    setEnhanced,
+    clearHeld() { keys?.held.clear(); },
     close() {
       if (!open) return;
       open = false;
+      clearTimeout(timer);
+      try { setEnhanced(false); } catch (error) { onError(error); }
       try { setTermios(fd, saved); } catch {}
-      if (device) closeSync(fd);
+      closeSync(fd);
     },
   };
 };