buninu 0.4.21 → 0.6.0

package/apps/jsgotty/tests/arrow-modifiers.test.js

@@ -0,0 +1,80 @@
+const assert = require('node:assert/strict');
+const test = require('node:test');
+const fs = require('node:fs');
+const path = require('node:path');
+const vm = require('node:vm');
+
+// Exercise the keyboard encoder shipped in the frontend bundle.
+const bundle = fs.readFileSync(path.join(__dirname, '../static/js/gotty.js'), 'utf8');
+const marker = 't.evaluateKeyboardEvent = function (e, t, i, n) {';
+const start = bundle.indexOf(marker);
+assert.ok(start >= 0);
+const end = bundle.indexOf('\n                  },\n                  482:', start);
+assert.ok(end > start);
+const source = bundle.slice(start + 't.evaluateKeyboardEvent = '.length, end).trim().replace(/;$/, '');
+const evaluate = vm.runInNewContext(`(${source})`, { r: { C0: { ESC: '\x1b', US: '\x1f' } }, s: {} });
+const arrows = [[37, 'D'], [38, 'A'], [39, 'C'], [40, 'B']];
+
+for (const isMac of [false, true]) {
+  test(`arrow modifiers stay distinct (isMac=${isMac})`, () => {
+    for (const [keyCode, suffix] of arrows) {
+      for (const applicationCursorMode of [false, true]) {
+        const sequences = new Set();
+        for (let mask = 0; mask < 8; mask++) {
+          const result = evaluate({
+            keyCode, metaKey: false,
+            shiftKey: Boolean(mask & 1), altKey: Boolean(mask & 2), ctrlKey: Boolean(mask & 4),
+          }, applicationCursorMode, isMac, false);
+          const expected = mask
+            ? `\x1b[1;${mask + 1}${suffix}`
+            : `\x1b${applicationCursorMode ? 'O' : '['}${suffix}`;
+          assert.equal(result.key, expected);
+          sequences.add(result.key);
+        }
+        assert.equal(sequences.size, 8);
+      }
+    }
+  });
+}
+
+test('Alt Insert/PageUp/PageDown keep Alt while preserving existing shortcuts', () => {
+  for (const isMac of [false, true]) {
+    const encode = (keyCode, modifiers = {}) => evaluate({
+      keyCode, shiftKey: false, altKey: false, ctrlKey: false, metaKey: false,
+      ...modifiers,
+    }, false, isMac, false);
+    for (const [keyCode, parameter] of [[45, 2], [33, 5], [34, 6]]) {
+      assert.equal(encode(keyCode).key, `\x1b[${parameter}~`);
+      assert.equal(encode(keyCode, { altKey: true }).key, `\x1b[${parameter};3~`);
+    }
+    for (const [keyCode, parameter, scrollType] of [[33, 5, 2], [34, 6, 3]]) {
+      assert.equal(encode(keyCode, { ctrlKey: true }).key, `\x1b[${parameter};5~`);
+      assert.equal(encode(keyCode, { ctrlKey: true, altKey: true }).key, `\x1b[${parameter};7~`);
+      for (const ctrlKey of [false, true]) {
+        for (const altKey of [false, true]) {
+          const result = encode(keyCode, { shiftKey: true, ctrlKey, altKey });
+          assert.equal(result.type, scrollType);
+          assert.equal(result.key, undefined);
+        }
+      }
+    }
+    for (const modifiers of [
+      { ctrlKey: true }, { shiftKey: true }, { ctrlKey: true, shiftKey: true },
+      { ctrlKey: true, altKey: true }, { shiftKey: true, altKey: true },
+    ]) assert.equal(encode(45, modifiers).key, undefined);
+  }
+});
+
+
+test('Ctrl slash sends US like Ctrl underscore, including alternate layout keyCodes', () => {
+  for (const isMac of [false, true]) {
+    for (const keyCode of [191, 226]) {
+      const result = evaluate({ key: '/', keyCode, ctrlKey: true,
+        shiftKey: false, altKey: false, metaKey: false }, false, isMac, false);
+      assert.equal(result.key, '\x1f');
+    }
+    const plain = evaluate({ key: '/', keyCode: 191, ctrlKey: false,
+      shiftKey: false, altKey: false, metaKey: false }, false, isMac, false);
+    assert.equal(plain.key, '/');
+  }
+});

package/apps/jsgotty/tests/client-exit.test.mjs

@@ -0,0 +1,45 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import vm from 'node:vm';
+const source=fs.readFileSync(new URL('../client.mjs',import.meta.url),'utf8');
+const methods=source.slice(source.indexOf('  let exiting = false;'),source.indexOf('  const stopViewerInput ='));
+function fixture(){
+ const calls=[],callbacks=[];
+ const handlers=vm.runInNewContext(`(()=>{${methods};return {exitClient,handleViewerInput};})()`,{
+  cleanup:()=>calls.push('cleanup'),reportDisconnected:()=>calls.push('report'),
+  ws:{close:()=>calls.push('close')},terminalInput:b=>b,
+  process:{stdout:{write:(s,done)=>callbacks.push(done)},exit:code=>calls.push(code)},
+ });
+ return {calls,callbacks,...handlers};
+}
+for(const [input,code] of [[[3,4],130],[[4,3],0],[[17,3],0]]){
+ test(`viewer exit handles first key only: ${input}`,()=>{
+  const f=fixture();f.handleViewerInput(Buffer.from(input));
+  assert.deepEqual(f.calls,['cleanup','report','close']);assert.equal(f.callbacks.length,1);
+  assert.ok(!f.calls.includes(code),'does not exit before output flush');
+  f.callbacks[0]();assert.equal(f.calls.at(-1),code);
+ });
+}
+test('concurrent exit requests queue only one flush and retain first exit code',()=>{
+ const f=fixture();f.exitClient(130);f.exitClient(143);f.exitClient(0);
+ assert.equal(f.callbacks.length,1);assert.deepEqual(f.calls,['cleanup','report','close']);
+ f.callbacks[0]();assert.equal(f.calls.at(-1),130);
+});
+for (const [key, code] of [[99,130],[100,0],[113,0]]) {
+ for (const sequence of ['\x1b['+key+';5u', '\x1b['+key+';5:1u', '\x1b['+key+';197u', '\x1b[27;5;'+key+'~']) {
+  test('viewer encoded Ctrl key '+JSON.stringify(sequence)+' split',()=>{
+   const f=fixture();
+   for(const byte of Buffer.from(sequence)) f.handleViewerInput(Buffer.from([byte]));
+   assert.equal(f.callbacks.length,1);f.callbacks[0]();assert.equal(f.calls.at(-1),code);
+  });
+ }
+}
+test('viewer ignores release and other modifiers before exit press',()=>{
+ const f=fixture();
+ for(const sequence of ['\x1b[99;5:3u','\x1b[100;1u','\x1b[113;7u','\x1b[<0;99;100M'])
+  f.handleViewerInput(Buffer.from(sequence));
+ assert.equal(f.callbacks.length,0);
+ f.handleViewerInput(Buffer.from('\x1b[113;5:2u'));
+ assert.equal(f.callbacks.length,1);
+});

package/apps/jsgotty/tests/client-modes.test.mjs

@@ -0,0 +1,105 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {ModeProbe,captureTerminalModes} from '../client-modes.mjs';
+import modes from '../terminal-modes.js';
+import {PassThrough} from 'node:stream';
+const {TerminalModeTracker}=modes;
+test('private reply split at every byte preserves typing and both Kitty stacks',()=>{
+ const p=new ModeProbe('a'.repeat(32));const t=new TerminalModeTracker();
+ t.consume(Buffer.from('\x1b[>1u\x1b[?1049h\x1b[>11u'));
+ const reply=p.privatePrefix+Buffer.from(JSON.stringify(t.snapshot())).toString('base64')+'\x07';
+ const out=[];for(const c of Buffer.from('before'+reply+'after'))out.push(p.consume(Buffer.from([c])));
+ assert.equal(Buffer.concat(out).toString(),'beforeafter');assert.equal(p.complete,true);assert.deepEqual(p.state,t.snapshot());
+ assert.equal(p.consume('\x1b').toString(),'\x1b','Escape is immediate after successful negotiation');
+});
+test('standard replies are consumed once; later application queries pass unchanged',()=>{
+ const p=new ModeProbe();p.standardQuery();
+ const replies='\x1b[?1049;2$y\x1b[?1002;1$y\x1b[?7;0$y\x1b[?11u';
+ assert.equal(p.consume(replies).length,0);assert.equal(p.state.mouse,'DRAG');assert.equal(p.state.alternate,false);
+ assert.equal(p.state.kitty.normal.flags,11);assert.equal(p.state.dec.wraparound,null);
+ assert.equal(p.consume(replies).toString(),replies);
+});
+test('no reply does not mean defaults, nor intercept application replies forever',()=>{
+ const p=new ModeProbe();p.standardQuery();p.replyDeadline=1;
+ const reply='\x1b[?1049;1$y\x1b[?11u';assert.equal(p.consume(reply).toString(),reply);
+ assert.equal(p.state.alternate,null);assert.equal(p.state.kitty.normal.flags,null);
+});
+test('foreign nonce, keys, mouse and a large paste are transparent',()=>{
+ const p=new ModeProbe();const data=Buffer.from('\x1b]777;jsgotty-modes;other;ignored\x07\x1b[<64;3;4M'+ '漢字'.repeat(200000));
+ assert.deepEqual(p.consume(data),data);
+});
+test('capture falls back after silence and restores stdin raw state',async()=>{
+ const input=new PassThrough();input.isTTY=true;input.isRaw=false;input.setRawMode=v=>{input.isRaw=v;};
+ const output=new PassThrough();output.isTTY=true;const sent=[];output.on('data',b=>sent.push(b.toString()));
+ const result=await captureTerminalModes(input,output,{timeout:30});
+ assert.equal(input.isRaw,false);assert.equal(result.state.mouse,null);assert.equal(sent.length,2);
+ assert.match(sent[0],/jsgotty-modes/);assert.match(sent[1],/\?1049\$p/);
+});
+
+for (const unsupportedFirst of [false,true]) {
+ test(`unsupported mouse modes count as inactive replies (${unsupportedFirst?'first':'last'})`,()=>{
+  const p=new ModeProbe();p.standardQuery();
+  const known='\x1b[?1000;2$y\x1b[?1002;2$y\x1b[?1003;2$y\x1b[?1006;2$y';
+  const unsupported='\x1b[?9;0$y\x1b[?1016;0$y';
+  p.consume(unsupportedFirst?unsupported+known:known+unsupported);
+  assert.equal(p.state.mouse,'NONE');assert.equal(p.state.encoding,'DEFAULT');
+  p.consume('\x1b[?7;0$y\x1b[?25;0$y\x1b[?1049;0$y');
+  assert.equal(p.state.dec.wraparound,null);assert.equal(p.state.cursorHidden,null);assert.equal(p.state.alternate,null);
+  const local=new TerminalModeTracker();Object.assign(local,structuredClone(p.state));
+  local.consume(Buffer.from('\x1b[?1003h\x1b[?1006h'));
+  const cleanup=modes.modeTransition(local.snapshot(),p.state);
+  assert.ok(cleanup.includes('\x1b[?1003l'));assert.ok(cleanup.includes('\x1b[?1006l'));
+  local.consume(Buffer.from(cleanup));assert.equal(local.mouse,'NONE');assert.equal(local.encoding,'DEFAULT');
+ });
+}
+test('unsupported replies do not override active modes or fill unanswered fields',()=>{
+ const p=new ModeProbe();p.standardQuery();
+ p.consume('\x1b[?9;0$y\x1b[?1016;0$y');
+ assert.equal(p.state.mouse,null);assert.equal(p.state.encoding,null);
+ p.consume('\x1b[?1002;1$y\x1b[?1006;1$y');
+ assert.equal(p.state.mouse,'DRAG');assert.equal(p.state.encoding,'SGR');
+ p.consume('\x1b[?1000;0$y\x1b[?1003;0$y');
+ assert.equal(p.state.mouse,'DRAG');
+});
+
+test('multiple active replies preserve individual switches and select explicit priorities',()=>{
+ const p=new ModeProbe();p.standardQuery();
+ for(const n of [1003,1002,1000,1016,1006])p.consume(`\x1b[?${n};1$y`);
+ p.consume('\x1b[?9;2$y');
+ assert.equal(p.state.mouse,'ANY');assert.equal(p.state.encoding,'SGR_PIXELS');
+ assert.deepEqual(p.state.mouseModeBits,{9:false,1000:true,1002:true,1003:true});
+ assert.deepEqual(p.state.mouseEncodingBits,{1006:true,1016:true});
+ assert.deepEqual(modes.validateSnapshot(p.state),p.state);
+ const bits={9:true,1000:false,1002:false,1003:false,1006:false,1016:false};
+ const cleanup=modes.modeTransition(new TerminalModeTracker().snapshot(),p.state);
+ for(const [,n,on] of cleanup.matchAll(/\x1b\[\?(\d+)([hl])/g))bits[n]=on==='h';
+ assert.deepEqual(bits,{...p.state.mouseModeBits,...p.state.mouseEncodingBits});
+ // The same sequence on an exclusive xterm-style terminal ends at the
+ // effective mode, without trying to change its parser semantics.
+ const exclusive=new TerminalModeTracker();exclusive.consume(Buffer.from(cleanup));
+ assert.equal(exclusive.mouse,'ANY');assert.equal(exclusive.encoding,'SGR_PIXELS');
+});
+
+test('partial query restoration leaves unreported switches untouched',()=>{
+ const p=new ModeProbe();p.standardQuery();p.consume('\x1b[?1000;2$y\x1b[?1006;1$y');
+ const cleanup=modes.modeTransition(new TerminalModeTracker().snapshot(),p.state,{normalizeMouse:true});
+ assert.equal(cleanup,'\x1b[?1000l\x1b[?1006h');
+});
+
+test('normalization clears every conflicting switch, even if aggregate appears unchanged',()=>{
+ for(const target of [{mouse:'NONE',encoding:'DEFAULT'},{mouse:'VT200',encoding:'SGR'}]){
+  const state={...new TerminalModeTracker().snapshot(),...target};
+  const bits={9:true,1000:true,1002:true,1003:true,1006:true,1016:true};
+  const seq=modes.modeTransition(state,state,{normalizeMouse:true});
+  for(const [,n,on] of seq.matchAll(/\x1b\[\?(\d+)([hl])/g))bits[n]=on==='h';
+  assert.deepEqual(bits,{9:false,1000:target.mouse==='VT200',1002:false,1003:false,1006:target.encoding==='SGR',1016:false});
+ }
+});
+
+test('hidden Kitty restore requires an explicit capability in a valid private reply',()=>{
+ for(const advertised of [undefined,0,true,1]){
+  const p=new ModeProbe(),reply={...new TerminalModeTracker().snapshot(),kittyRestore:advertised};
+  p.consume(p.privatePrefix+Buffer.from(JSON.stringify(reply)).toString('base64')+'\x07');
+  assert.equal(p.complete,true);assert.equal(p.kittyRestore,advertised===1);
+ }
+});

package/apps/jsgotty/tests/clipboard-browser.test.js

@@ -0,0 +1,81 @@
+// Opt-in real bundled-xterm integration; no browser/dependency downloads.
+// CHROMIUM_HEADLESS=/path/to/chromium-headless-shell node --test tests/kitty-keyboard-browser.test.js
+const test=require('node:test');
+const assert=require('node:assert/strict');
+const fs=require('node:fs');
+const path=require('node:path');
+const http=require('node:http');
+const {spawn}=require('node:child_process');
+const {once}=require('node:events');
+const WebSocket=require('ws');
+const {ClipboardHost,handleOSC52}=require('../clipboard.js');
+const root=path.join(__dirname,'../static');
+test('browser OSC52 write/read reaches server clipboard and replies to PTY', {skip:!process.env.CHROMIUM_HEADLESS,timeout:60000},async()=>{
+ const bundle=fs.readFileSync(path.join(root,'js/gotty.js'),'utf8').replace('(i.nc = void 0));','(i.nc = void 0)); window.TestGoTTYXterm = i(634).GoTTYXterm; window.TestWebTTY = i(609).WebTTY;');
+ const server=http.createServer((req,res)=>{
+  if(req.url==='/bundle.js'){res.setHeader('Content-Type','text/javascript');res.end(bundle);}
+  else if(req.url==='/keyboard.js'){res.setHeader('Content-Type','text/javascript');res.end(fs.readFileSync(path.join(root,'js/kitty-keyboard.js')));}
+  else res.end('<!doctype html><div id="fixture" style="width:800px;height:600px"></div><script src="/keyboard.js"></script><script src="/bundle.js"></script><script>window.wrapper=new TestGoTTYXterm(document.getElementById("fixture"));window.sent=[];wrapper.onInput(b=>sent.push(new TextDecoder().decode(b)));wrapper.kittyKeyboard.android=true;</script>');
+ });
+ const dir=fs.mkdtempSync(require('node:os').tmpdir()+'/jsgotty-clipboard-');
+ const oldPath=process.env.PATH,oldFixture=process.env.JSGOTTY_CLIPBOARD_FIXTURE;
+ const fake=`#!${process.execPath}
+const fs=require('node:fs'),file=process.env.JSGOTTY_CLIPBOARD_FIXTURE;
+const read=process.argv.includes('-o');fs.appendFileSync(file+'.log',read?'read\\n':'write\\n');
+if(read)process.stdout.write(fs.readFileSync(file));else fs.writeFileSync(file,fs.readFileSync(0));
+`;
+ fs.writeFileSync(path.join(dir,'xclip'),fake,{mode:0o700});
+ process.env.PATH=dir+path.delimiter+oldPath;process.env.JSGOTTY_CLIPBOARD_FIXTURE=path.join(dir,'data');
+ const host=new ClipboardHost();
+ const sockets=new WebSocket.Server({server});
+ sockets.on('connection',socket=>{
+  const session={closed:false,isWriter:ws=>ws===socket && socket.readyState===WebSocket.OPEN,
+    backend:{write:data=>socket.send(data.toString())}};
+  socket.on('message',data=>{const text=data.toString();if(text[0]==='C')handleOSC52(session,socket,text.slice(1),host);});
+  socket.on('close',()=>{session.closed=true;});
+ });
+ server.listen(0,'127.0.0.1');await once(server,'listening');
+ const child=spawn(process.env.CHROMIUM_HEADLESS,['--no-sandbox','--disable-gpu','--remote-debugging-port=0','http://127.0.0.1:'+server.address().port],{detached:true,stdio:['ignore','ignore','pipe']});
+ let ws;
+ try{
+  const endpoint=await new Promise((resolve,reject)=>{let log='';const timer=setTimeout(()=>reject(Error('Browser startup timeout: '+log)),15000);child.on('error',reject);child.on('exit',code=>{clearTimeout(timer);reject(Error('Browser exited '+code+': '+log));});child.stderr.on('data',b=>{log+=b;const m=log.match(/DevTools listening on (ws:\/\/[^\s]+)/);if(m){clearTimeout(timer);resolve(m[1]);}});});
+  const u=new URL(endpoint);let tab;
+  for(let i=0;i<50;i++){tab=(await (await fetch('http://'+u.host+'/json/list')).json()).find(x=>x.type==='page');if(tab)break;await new Promise(r=>setTimeout(r,100));}
+  ws=new WebSocket(tab.webSocketDebuggerUrl);await once(ws,'open');let id=0;const pending=new Map();ws.on('message',data=>{const m=JSON.parse(data);if(pending.has(m.id)){const {resolve,reject}=pending.get(m.id);pending.delete(m.id);m.error?reject(m.error):resolve(m.result);}});
+  const call=(method,params)=>new Promise((resolve,reject)=>{pending.set(++id,{resolve,reject});ws.send(JSON.stringify({id,method,params}));});
+  for(let i=0;i<50;i++){const r=await call('Runtime.evaluate',{expression:'Boolean(window.wrapper)',returnByValue:true});if(r.result.value)break;await new Promise(r=>setTimeout(r,100));}
+  const result=await call('Runtime.evaluate',{awaitPromise:true,returnByValue:true,expression:`(async()=>{
+
+   const term=wrapper.term;
+   const socket=new WebSocket('ws://'+location.host);
+   await new Promise((resolve,reject)=>{socket.onopen=resolve;socket.onerror=reject;});
+   const replies=[];socket.onmessage=e=>replies.push(e.data);
+   const webtty=new TestWebTTY(wrapper,null,'','');
+   webtty.connection={send:data=>socket.send(data)};
+   const write=s=>new Promise(r=>term.write(s,r));
+   const equal=(a,b)=>{if(a!==b)throw Error(JSON.stringify({a,b}));};
+   const encoded=btoa(unescape(encodeURIComponent('你好 OSC52\\n')));
+   // The worker invokes an isolated fake xclip, never the system clipboard.
+   await write('\\x1b]52;c;'+encoded.slice(0,2));
+   await write(encoded.slice(2)+'\\x07');
+   await write('\\x1b]52;c;?\\x1b\\\\');
+   for(let i=0;i<200&&!replies.length;i++)await new Promise(r=>setTimeout(r,10));
+   equal(replies.shift(),'\\x1b]52;c;'+encoded+'\\x1b\\\\');
+   await write('\\x1b]52;c;\\x07\\x1b]52;c;?\\x07');
+   for(let i=0;i<200&&!replies.length;i++)await new Promise(r=>setTimeout(r,10));
+   equal(replies.shift(),'\\x1b]52;c;\\x1b\\\\');
+   equal(term.buffer.active.getLine(0).translateToString(true),'');
+   socket.close();
+   wrapper.close();return 'ok';
+  })()`});
+  assert.equal(result.exceptionDetails,undefined,JSON.stringify(result.exceptionDetails));assert.equal(result.result.value,'ok');
+  assert.equal(fs.readFileSync(path.join(dir,'data.log'),'utf8'),'write\nread\nwrite\nread\n');
+ }finally{
+  ws?.close();if(child.pid){try{process.kill(-child.pid,'SIGTERM');}catch{}}
+  for(const socket of sockets.clients)socket.terminate();
+  await host.close();sockets.close();
+  process.env.PATH=oldPath;if(oldFixture===undefined)delete process.env.JSGOTTY_CLIPBOARD_FIXTURE;else process.env.JSGOTTY_CLIPBOARD_FIXTURE=oldFixture;
+  fs.rmSync(dir,{recursive:true,force:true});
+  server.closeAllConnections();await new Promise(r=>server.close(r));
+ }
+});

package/apps/jsgotty/tests/clipboard.test.js

@@ -0,0 +1,75 @@
+const test=require('node:test');
+const assert=require('node:assert/strict');
+const fs=require('node:fs');
+const crypto=require('node:crypto');
+const {createClipboard,parseOSC52,executeOSC52,handleOSC52,ClipboardHost}=require('../clipboard.js');
+const powershell=require('../clipboard-powershell.js');
+function fixture(platform,available,results={}){
+ const calls=[];const clipboard=createClipboard({platform,find:name=>available.includes(name)?name:null,run:(args,opts)=>{
+  calls.push({args,opts});const result=results[args[0]];return typeof result==='function'?result(args,opts):(result||{ok:true,stdout:'value'});
+ }});return {clipboard,calls};
+}
+test('xclip is first on Linux, Android, macOS and Windows',()=>{
+ for(const platform of ['linux','android','darwin','win32']){
+  const f=fixture(platform,['xclip','wl-copy','wl-paste','termux-clipboard-set','termux-clipboard-get','pbcopy','pbpaste','powershell.exe']);
+  f.clipboard.write('你好');assert.equal(f.clipboard.read(),'value');
+  assert.deepEqual(f.calls.map(c=>c.args[0]),['xclip','xclip']);
+  assert.equal(f.calls[0].opts.stdin,'你好');
+ }
+});
+test('missing or failing backends fall through per operation; empty read is success',()=>{
+ const f=fixture('android',['xclip','termux-clipboard-get','termux-clipboard-set','wl-paste'],{
+  xclip:{ok:false},'termux-clipboard-get':{ok:true,stdout:''},'termux-clipboard-set':{ok:true},
+ });
+ f.clipboard.write('cached');assert.equal(f.clipboard.read(),'');
+ assert.deepEqual(f.calls.map(c=>c.args[0]),['xclip','termux-clipboard-set','xclip','termux-clipboard-get']);
+ const g=fixture('linux',['wl-paste','xsel'],{'wl-paste':{ok:false}});
+ assert.equal(g.clipboard.read(),'value');assert.deepEqual(g.calls.map(c=>c.args[0]),['wl-paste','xsel']);
+});
+test('failed host access uses cache; every read retries host before cache',()=>{
+ let fail=false;const f=fixture('linux',['xclip'],{xclip:()=>fail?{ok:false}:{ok:true,stdout:'fresh'}});
+ f.clipboard.write('cached');fail=true;assert.equal(f.clipboard.read(),'cached');
+ fail=false;assert.equal(f.clipboard.read(),'fresh');assert.equal(f.calls.length,3);
+});
+test('selections, base64 Unicode, clearing and queries use OSC52 responses',()=>{
+ const c=createClipboard({find:()=>null});const encoded=Buffer.from('你好\ntext').toString('base64');
+ assert.equal(executeOSC52(c,parseOSC52('cp;'+encoded)),null);
+ assert.equal(executeOSC52(c,parseOSC52('p;?')),`\x1b]52;p;${encoded}\x1b\\`);
+ executeOSC52(c,parseOSC52('c;!'));assert.equal(executeOSC52(c,parseOSC52('c;?')),'\x1b]52;c;\x1b\\');
+ executeOSC52(c,parseOSC52(';'+encoded));assert.equal(c.read('cut0'),'你好\ntext');
+ assert.equal(parseOSC52('invalid;?'),null);assert.equal(parseOSC52('c;'+ 'A'.repeat(1048576)),null);
+});
+test('PowerShell uses original quote escaping and strips exactly one line ending',()=>{
+ const calls=[];const p=powershell('powershell.exe',(args,options)=>{calls.push({args,options});return {ok:true,stdout:'text\r\n\r\n'};},r=>r.stdout);
+ assert.equal(p.read(),'text\r\n');assert.equal(p.write("a'b\n$literal"),true);
+ assert.equal(calls[1].args[3],"Set-Clipboard 'a''b\n$literal'");
+});
+test('read-only connections cannot access host clipboard or inject replies',async()=>{
+ let writer=false,resolve;const writes=[],requests=[];
+ const session={closed:false,isWriter:()=>writer,backend:{write:b=>writes.push(b.toString())}};
+ const host={execute:r=>{requests.push(r);return new Promise(r=>resolve=r);}};
+ handleOSC52(session,{},'c;?',host);assert.equal(requests.length,0);
+ writer=true;handleOSC52(session,{},'c;?',host);assert.equal(requests.length,1);
+ writer=false;resolve('secret');await Promise.resolve();assert.equal(writes.length,0);
+ writer=true;handleOSC52(session,{},'c;?',host);resolve('reply');await Promise.resolve();assert.deepEqual(writes,['reply']);
+});
+test('worker preserves ordered writes/reads without touching system clipboard',async()=>{
+ const host=new ClipboardHost();
+ try{
+  const encoded=Buffer.from('isolated cut buffer').toString('base64');
+  const write=host.execute(parseOSC52('7;'+encoded));const read=host.execute(parseOSC52('7;?'));
+  assert.equal(await write,null);assert.equal(await read,`\x1b]52;7;${encoded}\x1b\\`);
+ }finally{await host.close();}
+});
+
+test('vendored PowerShell function remains byte-for-byte identical to jsmdcui',()=>{
+ const source=fs.readFileSync(require.resolve('../clipboard-powershell.js'),'utf8');
+ const body=source.slice(source.indexOf('function powershellClipboard(shell) {'),source.indexOf('\nreturn powershellClipboard(shell);'));
+ assert.equal(crypto.createHash('sha256').update(body).digest('hex'),'38246f0cea399f9c6a56ac8716e11b8d3fba89233b439f31011cc75a47a7d241');
+});
+
+test('large and unpadded base64 payloads parse without recursive regexp overflow',()=>{
+ const text='x'.repeat(500000);assert.equal(parseOSC52('c;'+Buffer.from(text).toString('base64')).text,text);
+ assert.equal(parseOSC52('c;aGk').text,'hi');
+ assert.deepEqual(parseOSC52('cs;?').registers,['clipboard']);
+});

package/apps/jsgotty/tests/kitty-keyboard-browser.test.js

@@ -0,0 +1,53 @@
+// Opt-in real bundled-xterm integration; no browser/dependency downloads.
+// CHROMIUM_HEADLESS=/path/to/chromium-headless-shell node --test tests/kitty-keyboard-browser.test.js
+const test=require('node:test');
+const assert=require('node:assert/strict');
+const fs=require('node:fs');
+const path=require('node:path');
+const http=require('node:http');
+const {spawn}=require('node:child_process');
+const {once}=require('node:events');
+const WebSocket=require('ws');
+const root=path.join(__dirname,'../static');
+test('shipped xterm parses Kitty modes and delivers one encoded DOM event per key', {skip:!process.env.CHROMIUM_HEADLESS,timeout:60000},async()=>{
+ const bundle=fs.readFileSync(path.join(root,'js/gotty.js'),'utf8').replace('(i.nc = void 0));','(i.nc = void 0)); window.TestGoTTYXterm = i(634).GoTTYXterm;');
+ const server=http.createServer((req,res)=>{
+  if(req.url==='/bundle.js'){res.setHeader('Content-Type','text/javascript');res.end(bundle);}
+  else if(req.url==='/keyboard.js'){res.setHeader('Content-Type','text/javascript');res.end(fs.readFileSync(path.join(root,'js/kitty-keyboard.js')));}
+  else res.end('<!doctype html><div id="fixture" style="width:800px;height:600px"></div><script src="/keyboard.js"></script><script src="/bundle.js"></script><script>window.wrapper=new TestGoTTYXterm(document.getElementById("fixture"));window.sent=[];wrapper.onInput(b=>sent.push(new TextDecoder().decode(b)));wrapper.kittyKeyboard.android=true;</script>');
+ });
+ server.listen(0,'127.0.0.1');await once(server,'listening');
+ const child=spawn(process.env.CHROMIUM_HEADLESS,['--no-sandbox','--disable-gpu','--remote-debugging-port=0','http://127.0.0.1:'+server.address().port],{detached:true,stdio:['ignore','ignore','pipe']});
+ let ws;
+ try{
+  const endpoint=await new Promise((resolve,reject)=>{let log='';const timer=setTimeout(()=>reject(Error('Browser startup timeout: '+log)),15000);child.on('error',reject);child.on('exit',code=>{clearTimeout(timer);reject(Error('Browser exited '+code+': '+log));});child.stderr.on('data',b=>{log+=b;const m=log.match(/DevTools listening on (ws:\/\/[^\s]+)/);if(m){clearTimeout(timer);resolve(m[1]);}});});
+  const u=new URL(endpoint);let tab;
+  for(let i=0;i<50;i++){tab=(await (await fetch('http://'+u.host+'/json/list')).json()).find(x=>x.type==='page');if(tab)break;await new Promise(r=>setTimeout(r,100));}
+  ws=new WebSocket(tab.webSocketDebuggerUrl);await once(ws,'open');let id=0;const pending=new Map();ws.on('message',data=>{const m=JSON.parse(data);if(pending.has(m.id)){const {resolve,reject}=pending.get(m.id);pending.delete(m.id);m.error?reject(m.error):resolve(m.result);}});
+  const call=(method,params)=>new Promise((resolve,reject)=>{pending.set(++id,{resolve,reject});ws.send(JSON.stringify({id,method,params}));});
+  for(let i=0;i<50;i++){const r=await call('Runtime.evaluate',{expression:'Boolean(window.wrapper)',returnByValue:true});if(r.result.value)break;await new Promise(r=>setTimeout(r,100));}
+  const result=await call('Runtime.evaluate',{awaitPromise:true,returnByValue:true,expression:`(async()=>{
+   const term=wrapper.term, kb=wrapper.kittyKeyboard;
+   const write=s=>new Promise(r=>term.write(s,r));
+   const equal=(a,b)=>{if(JSON.stringify(a)!==JSON.stringify(b))throw Error(JSON.stringify({actual:a,expected:b}));};
+   const key=(type,key,code,mods={})=>term.textarea.dispatchEvent(new KeyboardEvent(type,{key,code,bubbles:true,cancelable:true,...mods}));
+   await write('\\x1b[?u');equal(sent.splice(0),['\\x1b[?0u']);
+   // Split escape sequence across writes: only the parser may enable the mode.
+   await write('\\x1b[>');await write('11u');equal(kb.flags,11);
+   key('keydown','Meta','MetaLeft');key('keydown','x','KeyX',{ctrlKey:true,shiftKey:true});
+   key('keypress','x','KeyX',{ctrlKey:true,shiftKey:true});key('keyup','x','KeyX',{ctrlKey:true,shiftKey:true});key('keyup','Meta','MetaLeft');
+   equal(sent.splice(0),['\\x1b[57444;9u','\\x1b[120;14u','\\x1b[120;14:3u','\\x1b[57444;1:3u']);
+   await write('\\x1b[?1049h');equal(kb.flags,0);await write('\\x1b[>1u');equal(kb.flags,1);
+   await write('\\x1b[?1049l');equal(kb.flags,11);
+   await write('\\x1b[<u');equal(kb.flags,0);
+   key('keydown','c','KeyC',{ctrlKey:true,keyCode:67});key('keyup','c','KeyC',{ctrlKey:true,keyCode:67});equal(sent.splice(0),['\\x03']);
+   await write('\\x1b[>11u');await write('\\x1bc');equal(kb.flags,0);
+   await write('\\x1b[?u');equal(sent.splice(0),['\\x1b[?0u']);
+   wrapper.close();return 'ok';
+  })()`});
+  assert.equal(result.exceptionDetails,undefined,JSON.stringify(result.exceptionDetails));assert.equal(result.result.value,'ok');
+ }finally{
+  ws?.close();if(child.pid){try{process.kill(-child.pid,'SIGTERM');}catch{}}
+  server.closeAllConnections();await new Promise(r=>server.close(r));
+ }
+});

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