buninu-linux 0.14.57 → 0.16.59

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

@@ -3,6 +3,11 @@
 [English README](README.en.md)
 
 ## News
+
+### 2026/10/21
+
+- 新增 [Kitty keyboard](#kitty-keyboard) 支援，可區分 Super 等修飾鍵組合，並回報按下、重複與放開事件。
+
 ### 2026/08/16
 - 修正 WebGL 模式下斷線畫面的 `Reconnect` 按鈕無法點擊。
 - `Reconnect` 介面現在會正確位於 WebGL canvas 上方並接收滑鼠與觸控事件；右鍵／長按輸入 reconnect token 或 PID 也不會被 Kitty 圖片事件攔截。
@@ -238,6 +243,41 @@ bun gotty.js --client -k <token|pid> [target]
 - 斷線時會提供 `Reconnect` 按鈕，可手動立即重試。
 - 該按鈕右鍵/長按可輸入自訂 reconnect token 或 PID。
 
+## Kitty keyboard
+
+網頁終端現在支援 [Kitty keyboard protocol](https://sw.kovidgoyal.net/kitty/keyboard-protocol/) 的快捷鍵相關功能，與 Kitty 圖片協定分開。預設仍是原本的鍵盤編碼；由終端內的程式選擇開啟：
+
+```sh
+printf '\033[>11u'  # 1：消除歧義 + 2：重複／放開事件 + 8：回報所有按鍵
+printf '\033[<u'    # 程式退出時還原上一層模式
+```
+
+程式必須能解析新編碼，並在 finally／退出處理中還原模式，不建議直接在一般 shell 長期開啟。支援 `CSI ? u` 查詢、`CSI = flags ; mode u` 設定／加上／移除旗標、`CSI > flags u` push 與 `CSI < count u` pop。主畫面與 alternate screen 各有獨立堆疊（上限 32 層）；重連、完整重設或 soft reset 會清除狀態。只需要無歧義快捷鍵時可用旗標 `1`；需要獨立修飾鍵及所有按鍵的 down/repeat/up 時使用 `11`。
+
+網頁的 Meta 對應 Kitty 的 **Super（bit 8）**，不是協定中的另一個 Meta（bit 32）。例如 Super+X 是 `CSI 120;9u`，Ctrl+Shift+Super+X 是 `CSI 120;14u`；啟用事件回報後，放開會帶 `:3`。
+
+目前支援旗標 **1、2、8**；尚未實作替代鍵位（4）與附帶文字（16），查詢只回報實際啟用的旗標。IME 組字／文字提交與貼上保留既有路徑，不保證能回報實體按鍵或放開事件。字母、數字、標點、方向鍵、Tab、Enter、功能鍵、數字鍵盤與有標準 Kitty 編碼的媒體鍵可區分修飾組合；系統／瀏覽器先攔截的快捷鍵不會到達網頁，亮度、麥克風靜音等沒有標準 Kitty 鍵碼的鍵也不會擅自編成私有序列。
+
+這完成的是 **jsgotty → PTY** 的鍵盤編碼。要操作 Hyprland／Omarchy，Casty 或其他接收程式仍須啟用、解析 Kitty keyboard 並轉送 Super 與放開事件；此項改動不代表整條遠端桌面輸入鏈已完成，也不改變滑鼠協定。
+
+在 jsgotty 終端內手動確認（60 秒後自動退出，或按未修飾的 Esc／q／Ctrl+C）：
+
+```sh
+bun tests/manual/kitty-keyboard.js
+```
+
+測試會印出協商結果、原始序列、修飾鍵及 press/repeat/release；結束時還原鍵盤模式與 raw mode。更新後請重新載入 jsgotty 網頁。可用既有 Chromium 執行真正 xterm 前端測試，不會自動安裝瀏覽器：
+
+```sh
+CHROMIUM_HEADLESS=/path/to/chromium-headless-shell node --test tests/kitty-keyboard-browser.test.js
+```
+
+## Android 鍵盤
+
+Android WebView 若有 `Meta` down/up 卻漏掉 `metaKey`，jsgotty 會在自己的輸入處理中追蹤左右 Meta 並還原 Super。失焦或頁面隱藏時清除按住狀態；已送出的按鍵在事件回報模式下會補送放開。
+
+Android 終端的 Alt＋字母、數字、標點及空白會依實體按鍵位置（美式配置，支援 Shift）送出終端 Alt 序列，不進入重音死鍵流程。因此 Alt-E/I/N/U 等組合不再用來輸入 é、ê、ñ、ü；仍可使用輸入法或貼上。若 WebView 省略 `code`，會回退使用可辨識的 `keyCode`；若死鍵只送出 `keyup`，則在放開時補送一次，避免與已處理的 `keydown` 重複。正在組字、Ctrl、Meta、AltGr，以及無法辨識按鍵的事件維持原本處理。此規則只作用於 jsgotty 終端，不修改 Android 的系統鍵盤配置。
+
 ## Tested platforms 已測試作業系統
 - Windows x64: Windows 11
 - Linux x64: CachyOS
@@ -294,3 +334,24 @@ bun sz.js file.txt
 - 以 Bun 為主要執行方式。
 - Linux / macOS 如果不是用 Bun 執行，PTY 會無法使用。
 - 目前未實作 Go 版的 config 檔載入
+
+## OSC 52 剪貼板
+
+瀏覽器版 jsgotty 支援 OSC 52 寫入與 `?` 查詢。操作的是 **server 所在主機**的剪貼板，不是瀏覽器裝置的剪貼板。只有 session 的 writer 可以執行；viewer 不會重複操作。查詢結果以 OSC 52 回覆直接送回原本的 PTY。
+
+每次操作都先嘗試 `xclip`（包括 Windows／Android），不存在或執行失敗才依序嘗試適用的 `termux-clipboard-*`、`wl-copy`／`wl-paste`、`xsel`、macOS 的 `pbcopy`／`pbpaste`、Windows 的 PowerShell。PowerShell 函式原封不動取自 jsmdcui。所有工具都失敗時使用 server 記憶體快取；成功讀到空字串就是空剪貼板，不會被舊快取取代。沒有輪詢，外部工具在 worker 中執行。
+
+支援 `c`（clipboard）、`p`（primary）、`q`（secondary）；`s` 對應 clipboard，`0`～`7` 為記憶體暫存。空選擇使用 `s0`。不提供 primary／secondary 的工具不會拿 clipboard 冒充。單次 OSC 52 請求上限 1 MiB。
+
+```sh
+# 寫入 server 剪貼板
+printf '\033]52;c;%s\007' "$(printf 'Hello' | base64 | tr -d '\n')"
+```
+
+程式可送出 `ESC ] 52 ; c ; ? ST` 讀取，並從 stdin 接收 base64 編碼的 OSC 52 回覆。
+
+`jsgotty --client` **不攔截 OSC 52**，讀寫控制碼都原樣轉送，交給最外層真正的終端模擬器決定。
+
+### 觸控拖曳與右鍵
+
+在程式啟用滑鼠回報時，快速點兩下並按住第二下可拖曳左鍵，放開即釋放；單指滑動仍是捲動。既有圖片長按選單的 `Remove image` 下方新增 `Right click`，會在叫出選單的原始位置送出右鍵點擊。雙指縮放與原本的移除圖片入口不變。若要停用雙擊拖曳，可在網頁 JavaScript 設定 `window.touchDoubleTapDrag = false`。

package/initramfs/buninu/apps/jsgotty/client-modes.mjs

@@ -0,0 +1,117 @@
+// Read the terminal before attaching. No reset and no guessed default modes.
+import { randomBytes } from 'node:crypto';
+import modes from './terminal-modes.js';
+const {TerminalModeTracker, validateSnapshot, TRACKED_DEC_FLAGS, MOUSE_PROTOCOLS, MOUSE_ENCODINGS} = modes;
+const ESC = '\x1b';
+export class ModeProbe {
+  constructor(nonce = randomBytes(16).toString('hex')) {
+    this.nonce = nonce;
+    this.pending = Buffer.alloc(0);
+    this.complete = false;
+    this.kittyRestore = false;
+    this.state = new TerminalModeTracker().snapshot();
+    for (const key of Object.keys(this.state.dec)) this.state.dec[key] = null;
+    for (const key of ['alternate','cursorHidden','mouse','encoding']) this.state[key] = null;
+    this.state.kitty.normal.flags = this.state.kitty.alternate.flags = null;
+    this.state.mouseModeBits = Object.fromEntries(Object.keys(MOUSE_PROTOCOLS).map(n=>[n,null]));
+    this.state.mouseEncodingBits = Object.fromEntries(Object.keys(MOUSE_ENCODINGS).map(n=>[n,null]));
+    this.replies = new Map();
+    this.outstanding = new Set();
+    this.kittyOutstanding = false;
+    this.privatePrefix = `${ESC}]777;jsgotty-modes;${nonce};`;
+  }
+  privateQuery() { return `${ESC}]777;jsgotty-modes;${this.nonce}\x07`; }
+  standardQuery() {
+    this.outstanding = new Set([...Object.keys(TRACKED_DEC_FLAGS),25,1049,...Object.keys(MOUSE_PROTOCOLS),...Object.keys(MOUSE_ENCODINGS)].map(Number));
+    this.kittyOutstanding = true;
+    this.replyDeadline = Date.now() + 1500;
+    return [...this.outstanding]
+      .map(n => `${ESC}[?${n}$p`).join('') + `${ESC}[?u`;
+  }
+  reply(mode, value) {
+    if (this.complete) return;
+    const yes = value === 1 || value === 3;
+    // An unsupported mode cannot be active, but unlike silence it is a reply.
+    // Still aggregate below when 0 is the last answer in a mouse-mode group.
+    this.replies.set(mode, yes);
+    if (MOUSE_PROTOCOLS[mode]) this.state.mouseModeBits[mode] = yes;
+    if (MOUSE_ENCODINGS[mode]) this.state.mouseEncodingBits[mode] = yes;
+    if (value !== 0) {
+      if (TRACKED_DEC_FLAGS[mode]) this.state.dec[TRACKED_DEC_FLAGS[mode]] = yes;
+      else if (mode === 25) this.state.cursorHidden = !yes;
+      else if (mode === 1049) this.state.alternate = yes;
+    }
+    for (const [name, table, fallback, priority] of [
+      ['mouse',MOUSE_PROTOCOLS,'NONE',[1003,1002,1000,9]],
+      ['encoding',MOUSE_ENCODINGS,'DEFAULT',[1016,1006]],
+    ]) {
+      const active = priority.find(key => this.replies.get(key) === true);
+      if (active) this.state[name] = table[active];
+      else if (Object.keys(table).every(key => this.replies.has(+key))) this.state[name] = fallback;
+    }
+  }
+  consume(chunk) {
+    if ((this.complete && !this.outstanding.size && !this.kittyOutstanding) ||
+        (this.replyDeadline && Date.now() > this.replyDeadline)) {
+      this.outstanding.clear(); this.kittyOutstanding = false;
+      return Buffer.concat([this.flush(), Buffer.from(chunk)]);
+    }
+    this.pending = Buffer.concat([this.pending, Buffer.from(chunk)]);
+    const out = [];
+    while (this.pending.length) {
+      const text = this.pending.toString('latin1');
+      if (text.startsWith(this.privatePrefix)) {
+        const end = text.indexOf('\x07', this.privatePrefix.length);
+        if (end < 0 && text.length < 16384) break;
+        if (end >= 0) {
+          try {
+            const reply = JSON.parse(Buffer.from(text.slice(this.privatePrefix.length,end),'base64').toString());
+            this.state = validateSnapshot(reply);
+            this.kittyRestore = reply.kittyRestore === 1;
+            this.complete = true;
+          } catch {}
+          this.pending = this.pending.subarray(end+1); continue;
+        }
+      }
+      const dec = /^\x1b\[\?(\d+);([0-4])\$y/.exec(text);
+      const kitty = /^\x1b\[\?(\d+)u/.exec(text);
+      if ((dec && this.outstanding.delete(+dec[1])) || (kitty && this.kittyOutstanding)) {
+        if (dec) this.reply(+dec[1],+dec[2]);
+        else {
+          this.kittyOutstanding = false;
+          if (!this.complete && this.state.alternate != null)
+            this.state.kitty[this.state.alternate?'alternate':'normal'].flags = +kitty[1] & 31;
+        }
+        this.pending = this.pending.subarray((dec||kitty)[0].length); continue;
+      }
+      // Hold only possible query replies; normal keystrokes and mouse packets pass unchanged.
+      if (this.privatePrefix.startsWith(text) || (text.length < 64 && /^\x1b\[\?[0-9;\$]*$/.test(text)) || text === ESC+'[') break;
+      // Forward ordinary input in spans; large pastes must not become quadratic.
+      const next = this.pending.indexOf(0x1b, 1);
+      const count = next < 0 ? this.pending.length : next;
+      out.push(this.pending.subarray(0,count));this.pending=this.pending.subarray(count);
+    }
+    return Buffer.concat(out);
+  }
+  flush() { const data=this.pending;this.pending=Buffer.alloc(0);return data; }
+}
+export async function captureTerminalModes(input, output, {timeout=1000, probe=new ModeProbe()}={}) {
+  const buffered=[];
+  if (!input.isTTY || !output.isTTY) {
+    probe.replyDeadline = 1;
+    return {state:probe.state, probe, buffered:Buffer.alloc(0)};
+  }
+  const raw=!!input.isRaw;
+  input.setRawMode(true);
+  await new Promise(resolve=>{
+    let finished=false;
+    const finish=()=>{if(finished)return;finished=true;clearTimeout(fallback);clearTimeout(end);input.off('data',data);resolve();};
+    const data=chunk=>{const rest=probe.consume(chunk);if(rest.length)buffered.push(rest);if(probe.complete)finish();};
+    const fallback=setTimeout(()=>output.write(probe.standardQuery()),Math.min(200,timeout/2));
+    const end=setTimeout(finish,timeout);
+    input.on('data',data);input.resume();output.write(probe.privateQuery());
+  });
+  input.pause();input.setRawMode(raw);
+  buffered.push(probe.flush());
+  return {state:validateSnapshot(probe.state),probe,buffered:Buffer.concat(buffered)};
+}

package/initramfs/buninu/apps/jsgotty/client.mjs

@@ -4,6 +4,10 @@ import process from "node:process";
 import { Buffer } from "node:buffer";
 import WebSocket from "ws";
 import { encodeKittyGraphics, syntheticKittyCursorMotion } from "./client-kitty.mjs";
+import terminalModes from "./terminal-modes.js";
+
+const { TerminalModeTracker, modeTransition, validateSnapshot } = terminalModes;
+import { captureTerminalModes } from "./client-modes.mjs";
 
 const MSG_INPUT = "1";
 const MSG_PING = "2";
@@ -19,6 +23,7 @@ const MSG_SET_BUFFER_SIZE = "6";
 const MSG_KITTY_GRAPHICS = "7";
 const MSG_SET_ROLE = "a";
 const MSG_CONTROL_RESULT = "b";
+const MSG_RESTORE_MODES = "m";
 
 const DEFAULT_URL = "ws://127.0.0.1:8080/ws";
 
@@ -409,6 +414,40 @@ async function main() {
     return;
   }
   const args = buildArguments(options, initArguments);
+  const originalRawMode = !!process.stdin.isRaw;
+  const localModes = new TerminalModeTracker();
+  // A closed terminal surfaces as an async EIO/EPIPE, not a throw. Nobody is
+  // left to read anything, and the PTY keeps its modes, so just exit.
+  for (const stream of [process.stdin, process.stdout, process.stderr]) {
+    stream.on("error", (error) => {
+      if (error.code !== "EIO" && error.code !== "EPIPE") {
+        throw error;
+      }
+      process.exit(process.exitCode ?? 1);
+    });
+  }
+  const writeTerminal = (data) => {
+    process.stdout.write(data);
+    localModes.consume(Buffer.from(data));
+  };
+  const captured = await captureTerminalModes(process.stdin, process.stdout);
+  const originalModes = captured.state;
+  Object.assign(localModes, validateSnapshot(originalModes));
+  let bufferedInput = captured.buffered;
+  let probeFlushTimer, replayingProbe = false;
+  const terminalInput = chunk => {
+    if (replayingProbe) return Buffer.from(chunk);
+    const input = captured.probe.consume(chunk);
+    clearTimeout(probeFlushTimer);
+    // A lone Escape is user input too. Never hold it indefinitely while
+    // filtering a split or late response to our startup queries.
+    if (captured.probe.pending.length) probeFlushTimer = setTimeout(() => {
+      const pending = captured.probe.flush();
+      replayingProbe = true;
+      try { process.stdin.emit("data", pending); } finally { replayingProbe = false; }
+    }, 30);
+    return input;
+  };
   writeStatus(`[gotty] connecting to\n  ${wsUrl}`);
   const ws = new WebSocket(wsUrl, "webtty");
   let pingTimer = null;
@@ -432,7 +471,8 @@ async function main() {
     if (!writable || ws.readyState !== WebSocket.OPEN) {
       return;
     }
-    ws.send(MSG_INPUT + Buffer.from(chunk).toString("base64"));
+    const input = terminalInput(chunk);
+    if (input.length) ws.send(MSG_INPUT + input.toString("base64"));
   };
 
   const handleResize = () => {
@@ -441,21 +481,52 @@ async function main() {
     }
   };
 
+  let exiting = false;
   const exitClient = (code = 0) => {
+    if (exiting) return;
+    exiting = true;
     cleanup();
     reportDisconnected();
     ws.close();
-    process.exit(code);
+    process.stdout.write("", () => process.exit(code));
   };
 
+  // Restoring the viewed session also restores Kitty keyboard modes. Exit
+  // keys can therefore arrive as CSI u rather than legacy control bytes.
+  // Keep CSI packets across chunks; never treat a key-release as a press.
+  let viewerSequence = "";
   const handleViewerInput = (chunk) => {
-    for (const byte of Buffer.from(chunk)) {
-      if (byte === 0x03) {
-        exitClient(130);
+    for (const byte of terminalInput(chunk)) {
+      if (viewerSequence) {
+        viewerSequence += String.fromCharCode(byte);
+        if (viewerSequence === "\x1b[") continue;
+        if (viewerSequence.length === 2 && byte !== 0x5b) {
+          viewerSequence = "";
+          continue;
+        }
+        if (viewerSequence.length > 2 && byte >= 0x40 && byte <= 0x7e) {
+          const sequence = viewerSequence;
+          viewerSequence = "";
+          const kitty = /^\x1b\[(\d+)(?::[0-9:]*)?(?:;(\d+)(?::([123]))?)?(?:;[0-9:]+)?u$/.exec(sequence);
+          const modified = /^\x1b\[27;(\d+);(\d+)~$/.exec(sequence);
+          const key = kitty ? +kitty[1] : modified ? +modified[2] : 0;
+          const modifiers = (kitty ? +(kitty[2] || 1) : modified ? +modified[1] : 1) - 1;
+          // Ignore Caps/Num Lock, but require Ctrl without Alt/Shift/Super.
+          if ((modifiers & ~192) === 4 && (!kitty || kitty[3] !== "3")) {
+            if (key === 99) return exitClient(130);
+            if (key === 100 || key === 113) return exitClient(0);
+          }
+        } else if (viewerSequence.length > 128) {
+          viewerSequence = "";
+        }
+        continue;
       }
-      if (byte === 0x04 || byte === 0x11) {
-        exitClient(0);
+      if (byte === 0x1b) {
+        viewerSequence = "\x1b";
+        continue;
       }
+      if (byte === 0x03) return exitClient(130);
+      if (byte === 0x04 || byte === 0x11) return exitClient(0);
     }
   };
 
@@ -498,7 +569,8 @@ async function main() {
       return;
     }
 
-    const input = Buffer.from(chunk);
+    const input = terminalInput(chunk);
+    if (!input.length) return;
     fallbackProbe = normalizeEcho(input.toString("utf8"));
     ws.send(MSG_INPUT + input.toString("base64"));
     stopFallbackInput();
@@ -532,6 +604,10 @@ async function main() {
       setRawMode(true);
       rawEnabled = process.stdin.isTTY;
       sendResize(ws, options);
+      if (bufferedInput.length) {
+        ws.send(MSG_INPUT + bufferedInput.toString("base64"));
+        bufferedInput = Buffer.alloc(0);
+      }
       return;
     }
 
@@ -558,6 +634,7 @@ pid:
       return;
     }
     closed = true;
+    clearTimeout(probeFlushTimer);
     if (pingTimer) {
       clearInterval(pingTimer);
       pingTimer = null;
@@ -565,8 +642,13 @@ pid:
     setWritable(false);
     stopFallbackInput();
     stopViewerInput();
+    if (process.stdout.isTTY) {
+      try {
+        writeTerminal(modeTransition(localModes.snapshot(), originalModes, { normalizeMouse: true, kittyRestore: captured.probe.kittyRestore }));
+      } catch {}
+    }
     if (rawEnabled) {
-      setRawMode(false);
+      setRawMode(originalRawMode);
       rawEnabled = false;
     }
     process.stdin.pause();
@@ -611,7 +693,7 @@ pid:
             break;
           }
           pendingKittyCursorMotion = "";
-          process.stdout.write(output);
+          writeTerminal(output);
           if (fallbackProbe && accessRole === "") {
             fallbackOutputTail = normalizeEcho(
               `${fallbackOutputTail}${output.toString("utf8")}`
@@ -641,6 +723,14 @@ pid:
           if (encoded) process.stdout.write(encoded);
         } catch {}
         break;
+      case MSG_RESTORE_MODES:
+        // Only local terminal state; the PTY keeps its modes for the next resume.
+        if (process.stdout.isTTY) {
+          try {
+            writeTerminal(modeTransition(localModes.snapshot(), validateSnapshot(JSON.parse(payload)), { normalizeMouse: true, kittyRestore: captured.probe.kittyRestore }));
+          } catch {}
+        }
+        break;
       case MSG_SET_RECONNECT: {
         try {
           const reconnect = JSON.parse(payload);

package/initramfs/buninu/apps/jsgotty/clipboard-powershell.js

@@ -0,0 +1,18 @@
+"use strict";
+// Copied verbatim from jsmdcui/src/platform/clipboard.js (MIT).
+// Keep the function below unchanged; inject its existing command helpers.
+module.exports = function createPowerShellClipboard(shell, runSync, outputOrThrow) {
+function powershellClipboard(shell) {
+  return {
+    name: "powershell",
+    // Get-Clipboard -Raw appends \r\n to stdout; strip exactly one trailing line ending.
+    read: () => outputOrThrow(runSync([shell, "-NoProfile", "-Command", "Get-Clipboard -Raw"], {})).replace(/\r?\n$/, ""),
+    write: (text) => {
+      text=(text+'').replaceAll("'","''") ;
+      return runSync([shell, "-NoProfile", "-Command", `Set-Clipboard '${text}'`], { stdout: "ignore" }).ok ;
+    },
+  };
+}
+
+return powershellClipboard(shell);
+};

package/initramfs/buninu/apps/jsgotty/clipboard.js

@@ -0,0 +1,148 @@
+"use strict";
+const createPowerShellClipboard = require('./clipboard-powershell.js');
+// Self-contained so the worker remains valid after bundling/minification.
+function clipboardRuntime(createPowerShellClipboard) {
+  const {spawnSync} = require('node:child_process');
+  const fs = require('node:fs');
+  const path = require('node:path');
+  const MAX_OSC52 = 1024 * 1024;
+  function which(name) {
+    if (typeof Bun !== 'undefined') return Bun.which(name);
+    const names=process.platform==='win32' && !path.extname(name)
+      ? [name,...(process.env.PATHEXT || '.EXE;.CMD;.BAT').split(';').map(ext=>name+ext)] : [name];
+    for (const dir of (process.env.PATH || '').split(path.delimiter)) {
+      for(const candidate of names) {
+        const file=path.join(dir,candidate);
+        try {fs.accessSync(file,fs.constants.X_OK);if(fs.statSync(file).isFile())return file;} catch {}
+      }
+    }
+    return null;
+  }
+  function runSync(command, options={}) {
+    try {
+      const r=spawnSync(command[0],command.slice(1),{
+        input:options.stdin, encoding:'utf8', timeout:options.timeout ?? 2000,
+        maxBuffer:MAX_OSC52, stdio:['pipe',options.stdout ?? 'pipe','pipe'],windowsHide:true,
+      });
+      return {ok:!r.error && r.status===0,stdout:r.stdout || '',stderr:r.stderr || String(r.error || '')};
+    } catch(error) {return {ok:false,stdout:'',stderr:String(error)};}
+  }
+  function outputOrThrow(result) {
+    if (!result.ok) throw new Error(result.stderr || result.stdout || 'clipboard command failed');
+    return result.stdout;
+  }
+  function createClipboard({find=which,run=runSync,platform=process.platform}={}) {
+    const internal=new Map();
+    function candidates(register,write,text) {
+      const result=[];
+      const command=(name,args)=>{const executable=find(name);if(executable)result.push(()=>run([executable,...args],write?{stdin:text,stdout:'ignore'}:{}));};
+      // Always first, including Windows and Android. Failure does not pin a backend.
+      command('xclip',['-selection',register,...(write?[]:['-o'])]);
+      if(register==='clipboard') {
+        command(write?'termux-clipboard-set':'termux-clipboard-get',[]);
+      }
+      if(register!=='secondary')command(write?'wl-copy':'wl-paste',[...(write?[]:['--no-newline']),...(register==='primary'?['--primary']:[])]);
+      command('xsel',[`--${register}`,write?'--input':'--output']);
+      if(register==='clipboard') {
+        if(platform==='darwin')command(write?'pbcopy':'pbpaste',[]);
+        if(platform==='win32')for(const name of ['pwsh.exe','powershell.exe','pwsh','powershell']){
+          const shell=find(name);if(!shell)continue;
+          const backend=createPowerShellClipboard(shell,run,outputOrThrow);
+          result.push(()=>write?{ok:backend.write(text)}:{ok:true,stdout:backend.read()});
+        }
+      }
+      return result;
+    }
+    return {
+      read(register='clipboard') {
+        if(/^cut[0-7]$/.test(register))return internal.get(register);
+        for(const attempt of candidates(register,false))try {
+          const r=attempt();if(r.ok){internal.set(register,r.stdout);return r.stdout;}
+        }catch{}
+        return internal.get(register);
+      },
+      write(text,register='clipboard') {
+        internal.set(register,text);
+        if(/^cut[0-7]$/.test(register))return;
+        for(const attempt of candidates(register,true,text))try {if(attempt().ok)return;}catch{}
+      },
+    };
+  }
+  function parseOSC52(data) {
+    if(typeof data!=='string'||data.length>MAX_OSC52)return null;
+    const i=data.indexOf(';');if(i<0)return null;
+    const selection=data.slice(0,i),payload=data.slice(i+1);
+    if(!/^[cpqs0-7]*$/.test(selection)||selection.length>16)return null;
+    const registers=[...new Set([...(selection || 's0')].map(c=>({c:'clipboard',p:'primary',q:'secondary',s:'clipboard'}[c]||`cut${c}`)))];
+    if(payload==='?')return {selection,registers,read:true};
+    // OSC 52 specifies clearing the selection for non-base64 data.
+    const valid=/^[A-Za-z0-9+/]*={0,2}$/.test(payload) && payload.replace(/=+$/,'').length % 4 !== 1;
+    return {selection,registers,read:false,text:valid?Buffer.from(payload,'base64').toString('utf8'):''};
+  }
+  function executeOSC52(clipboard,request) {
+    if(request.read) {
+      let text;
+      for(const register of request.registers){text=clipboard.read(register);if(text!==undefined)break;}
+      const data=Buffer.from(text ?? '', 'utf8');
+      if(data.length>MAX_OSC52)return null;
+      return `\x1b]52;${request.selection};${data.toString('base64')}\x1b\\`;
+    }
+    for(const register of request.registers)clipboard.write(request.text,register);
+    return null;
+  }
+  return {createClipboard,parseOSC52,executeOSC52,MAX_OSC52};
+}
+const {createClipboard,parseOSC52,executeOSC52,MAX_OSC52}=clipboardRuntime(createPowerShellClipboard);
+module.exports={createClipboard,parseOSC52,executeOSC52,MAX_OSC52};
+
+// Run the synchronous jsmdcui-compatible backends off the server event loop.
+// Inline the helpers so compiled single-file builds need no external worker file.
+class ClipboardHost {
+  constructor(){this.pending=new Map();this.nextId=0;this.worker=null;}
+  execute(request){
+    if(this.pending.size>=32)return Promise.reject(Error('clipboard queue full'));
+    if(!this.worker){
+      const {Worker}=require('node:worker_threads');
+      const source=`const {parentPort}=require('node:worker_threads');
+const runtime=(${clipboardRuntime.toString()})(${createPowerShellClipboard.toString()});
+const clipboard=runtime.createClipboard();parentPort.on('message',({id,request})=>{
+ try{parentPort.postMessage({id,result:runtime.executeOSC52(clipboard,request)});}
+ catch(error){parentPort.postMessage({id,error:String(error)});}
+});`;
+      const worker=this.worker=new Worker(source,{eval:true});
+      const failed=error=>{
+        if(this.worker!==worker)return;
+        this.worker=null;
+        for(const job of this.pending.values())job.reject(error);
+        this.pending.clear();worker.terminate();
+      };
+      worker.on('error',failed);
+      worker.on('exit',()=>failed(Error('clipboard worker exited')));
+      worker.on('message',({id,result,error})=>{
+        const job=this.pending.get(id);if(!job)return;
+        this.pending.delete(id);error?job.reject(Error(error)):job.resolve(result);
+        if(!this.pending.size)worker.unref();
+      });
+      worker.unref();
+    }
+    return new Promise((resolve,reject)=>{
+      const id=++this.nextId;this.pending.set(id,{resolve,reject});this.worker.ref();
+      this.worker.postMessage({id,request});
+    });
+  }
+  async close(){
+    const worker=this.worker;this.worker=null;
+    for(const job of this.pending.values())job.reject(Error('clipboard closed'));
+    this.pending.clear();if(worker)await worker.terminate();
+  }
+}
+// Authorization is checked both before host access and before returning data.
+function handleOSC52(session,ws,payload,host){
+  if(!session.isWriter(ws))return;
+  const request=parseOSC52(payload);if(!request)return;
+  host.execute(request).then(reply=>{
+    if(reply && !session.closed && session.isWriter(ws))session.backend.write(Buffer.from(reply));
+  }).catch(()=>{});
+}
+module.exports.ClipboardHost=ClipboardHost;
+module.exports.handleOSC52=handleOSC52;

package/initramfs/buninu/apps/jsgotty/gotty.js

@@ -12,7 +12,10 @@ const crypto = require("crypto");
 const zlib = require("zlib");
 const { constants: fsConstants } = require("fs");
 const WebSocket = require("ws");
+const { TerminalModeTracker } = require("./terminal-modes.js");
 const { WebSocketServer } = WebSocket;
+const { ClipboardHost, handleOSC52 } = require("./clipboard.js");
+const clipboardHost = new ClipboardHost();
 
 const MSG_INPUT = "1";
 const MSG_PING = "2";
@@ -34,6 +37,7 @@ const MSG_ZMODEM_MODE = "z";
 const MSG_ZMODEM_OUTPUT = "y";
 const MSG_ZMODEM_ACK = "Y";
 const MSG_KITTY_DEBUG = "K";
+const MSG_RESTORE_MODES = "m";
 const KITTY_TRACE = /^(1|true|yes|on)$/i.test(String(process.env.JSGOTTY_KITTY_DEBUG || ""));
 const WINDOWS_BRIDGE_TRACE = process.env.WINDOWS_BRIDGE_TRACE === "1";
 const WINDOWS_BRIDGE_PREFIX = Buffer.from("@@GOTTYCTL:", "ascii");
@@ -1680,6 +1684,7 @@ class PtySession {
     this.supportsWindowsBridge = process.platform === "win32";
     this.cursorTracker = new CursorStateTracker();
     this.cursorTracker.setDimensions(this.columns || 80);
+    this.modeTracker = new TerminalModeTracker();
     this.kittyParser = new KittyGraphicsParser();
     this.windowsBridgeParser = this.supportsWindowsBridge ? new WindowsBridgeParser("incoming") : null;
     this.outgoingWindowsBridgeParser = this.supportsWindowsBridge ? new WindowsBridgeParser("outgoing") : null;
@@ -1759,6 +1764,7 @@ class PtySession {
         if (!this.supportsWindowsBridge) {
           const cursorBefore = this.cursorTracker.snapshot();
           this.cursorTracker.consume(filteredChunk);
+          this.modeTracker.consume(filteredChunk);
           const cursorAfter = this.cursorTracker.snapshot();
           const controls = cursorControls(filteredChunk);
           if (controls.length > 0) {
@@ -1776,6 +1782,7 @@ class PtySession {
         if (bridged.plain.length > 0) {
           const cursorBefore = this.cursorTracker.snapshot();
           this.cursorTracker.consume(bridged.plain);
+          this.modeTracker.consume(bridged.plain);
           const cursorAfter = this.cursorTracker.snapshot();
           const controls = cursorControls(bridged.plain);
           if (controls.length > 0) {
@@ -1855,6 +1862,9 @@ class PtySession {
       this.writerWs = ws;
     }
     this.sendSessionMetadata(ws, remoteAddr);
+    // Queued ahead of live output; the client applies only modes that differ,
+    // which also clears modes a program turned off while the socket was down.
+    this.send(MSG_RESTORE_MODES, JSON.stringify(this.modeTracker.snapshot()), ws);
     this.startWebSocketHandlers(ws);
     this.notifyRoles();
     return true;
@@ -2442,6 +2452,9 @@ class PtySession {
     }
 
     switch (type) {
+      case "C":
+        handleOSC52(this, ws, payload, clipboardHost);
+        break;
       case MSG_INPUT:
         if (!this.isWriter(ws) || payload.length === 0) {
           return;

package/initramfs/buninu/apps/jsgotty/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "jsgotty",
-  "version": "1.1.16",
+  "version": "1.4.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "jsgotty",
-      "version": "1.1.16",
+      "version": "1.4.0",
       "dependencies": {
         "node-addon-api": "^7.1.1",
         "ws": "^8.18.3"

package/initramfs/buninu/apps/jsgotty/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsgotty",
-  "version": "1.1.16",
+  "version": "1.4.0",
   "description": "Share your terminal as a web application: A JavaScript rewrite of GoTTY",
   "license": "MIT",
   "bin": {

package/initramfs/buninu/apps/jsgotty/static/css/index.css

@@ -10,4 +10,17 @@ html, body, #terminal {
   transition: unset;
   transition-duration: 0.1s;
   transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
-}
+}
+
+/* Keep touch taps available to xterm even with a widened WebView viewport.
+   Include the viewport (a scroll container); preserve panning and pinch zoom. */
+#terminal, #terminal .xterm, #terminal .xterm-viewport, #terminal .xterm-screen {
+    touch-action: manipulation;
+}
+
+/* Chromium skips focused-editable auto-zoom when that element disallows
+   pinch zoom. Restrict only the hidden input, not the terminal canvas:
+   native paste/IME remain available and the visible terminal can still pinch. */
+#terminal .xterm-helper-textarea {
+    touch-action: none;
+}