buninu 0.4.21 → 0.6.0

package/CHANGELOG.md

@@ -1,5 +1,45 @@
 # Changelog
 
+## 0.6.0 - 2026-10-25
+
+- Sync jsgotty to 1.3.0:
+  * Add OSC 52 clipboard reads and writes for browser terminals using the
+    server host's clipboard. Try xclip first on every platform, then available
+    platform tools, with an in-memory fallback when all tools fail. Only the
+    session writer performs clipboard operations; CLI clients pass OSC 52
+    through to their terminal emulator.
+  * Restore mouse reporting, mouse encoding, Kitty keyboard state and other
+    terminal modes when reconnecting to an existing session, including from
+    a fresh terminal and through nested CLI clients. Preserve keyboard mode
+    stacks without unnecessarily switching screens.
+  * Probe and restore the CLI client's original terminal modes on exit;
+    handle unsupported mode replies and independently enabled mouse modes
+    without leaving stale mouse reporting behind.
+  * Fix read-only CLI viewer exit shortcuts (Ctrl-C, Ctrl-D and Ctrl-Q) when
+    the enclosing terminal uses Kitty keyboard encoding.
+  * Fix Android WebView double-tap handling at non-default viewport zoom so
+    terminal clicks reach applications instead of triggering browser zoom,
+    while retaining two-finger pinch zoom.
+
+## 0.5.0 - 2026-10-21
+
+- Sync jsgotty to 1.2.0:
+  * Add opt-in Kitty keyboard support for disambiguated shortcuts, including
+    Super, and press/repeat/release events. Support flags 1, 2 and 8, mode
+    queries, and independent mode stacks for normal and alternate screens;
+    legacy keyboard encoding remains the default.
+  * Recover Super state on Android WebViews that deliver Meta key events but
+    omit the modifier state. Handle Android Alt shortcuts without accent
+    dead-key conversion, including recognizable keyup-only events.
+  * Preserve Alt on arrow, Insert, PageUp and PageDown shortcuts, and encode
+    Ctrl+/ as the conventional US control character.
+  * Add a manual keyboard tester with readable, colored shortcut names and
+    raw sequences; restore keyboard and raw modes when it exits.
+  * Allow local Kitty graphics consumers to request binary image data,
+    avoiding a base64 conversion; browser clients retain base64 by default.
+- Sync bunmsh to 0.4.1: use the existing linker-aware shell launcher for the
+  awk fallback's subprocess commands instead of bypassing linker handling.
+
 ## 0.4.21 - 2026-10-15
 
 - Sync jsgotty to 1.1.16: Turn on pixel report

package/apps/bunmsh/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 All notable user-visible changes to bunmsh are documented here.
 
+## [0.4.1] - 2026-10-13
+
+- Fixed awk bypassing linker protection
+
 ## [0.4.0] - 2026-10-13
 
 ### Added and fixed

package/apps/bunmsh/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunmsh",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Cross-platform command shell for Bun JavaScript",
   "license": "MIT",
   "type": "module",

package/apps/bunmsh/src/shell.js

@@ -3236,7 +3236,7 @@ async function runAwkFallback(argv, state, input) {
         try {
           const file=resolvePath(directory,"state.json");
           writeFileSync(file,pipelineBuiltinState(state).env[PIPELINE_STATE_ENV],{mode:0o600});
-          const p=Bun.spawnSync([process.execPath,BUNMSH_ENTRY,"-c",command],{
+          const p=Bun.spawnSync(pipelineCompoundArgv(command),{
             cwd:nativePath(state.cwd),env:{...externalEnvironment(state),[PIPELINE_STATE_ENV]:`@file:${file}`},
             stdin:bytes(text),stdout:"pipe",stderr:"pipe"});
           if(p.error)throw p.error;

package/apps/jsgotty/LICENSES/MIT-jsmdcui.txt

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2016-2020: Zachary Yedidia, et al.
+Copyright (c) 2026 Dr. John (醫者小智)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/apps/jsgotty/NOTICE

@@ -119,3 +119,8 @@ such an executable must also follow Bun's license terms, including the LGPL
 relinking provisions described at
 https://github.com/oven-sh/bun/blob/main/LICENSE.md. The executables carry
 LICENSE, NOTICE and LICENSES/ as embedded assets.
+
+Clipboard backend helpers reference jsmdcui (MIT).
+clipboard-powershell.js retains its powershellClipboard function verbatim from
+jsmdcui/src/platform/clipboard.js, Copyright (c) 2026 Dr. John (醫者小智).
+Full source license: LICENSES/MIT-jsmdcui.txt.

package/apps/jsgotty/README.en.md

@@ -3,6 +3,11 @@
 [中文 README](README.md)
 
 ## News
+
+### 2026/10/21
+
+- Added [Kitty keyboard](#kitty-keyboard) support for distinct modifier combinations, including Super, and press/repeat/release events.
+
 ### 2026/08/16
 - Fixed the disconnected-screen `Reconnect` button not being clickable in WebGL mode.
 - The `Reconnect` UI now stays above the WebGL canvas and receives mouse and touch events correctly; Kitty image handling no longer intercepts right-click / long-press for entering a reconnect token or PID.
@@ -238,6 +243,41 @@ The `jsgotty` server has two connection modes:
 - On disconnect, the overlay provides a `Reconnect` button for immediate manual retry.
 - Right-click / long-press on that button lets you enter a custom reconnect token or PID.
 
+## Kitty keyboard
+
+The web terminal supports the shortcut-related parts of the [Kitty keyboard protocol](https://sw.kovidgoyal.net/kitty/keyboard-protocol/), separately from Kitty graphics. Legacy keyboard encoding remains the default. A terminal application can opt in:
+
+```sh
+printf '\033[>11u'  # 1: disambiguation + 2: repeat/release + 8: all keys
+printf '\033[<u'    # restore the previous mode when the application exits
+```
+
+The receiving application must decode these sequences and restore the mode in its exit/finally handler; do not leave an ordinary shell in this mode. Negotiation supports `CSI ? u`, `CSI = flags ; mode u`, push and pop. Normal and alternate screens have independent stacks, limited to 32 entries. Reconnection, full reset and soft reset clear the state. Use flag `1` for unambiguous shortcuts, or `11` for modifier keys and press/repeat/release reporting.
+
+DOM Meta maps to Kitty **Super (bit 8)**, not the separate Meta bit (32). Super+X is `CSI 120;9u`; Ctrl+Shift+Super+X is `CSI 120;14u`. Release events add `:3` when enabled.
+
+Supported flags are **1, 2 and 8**; alternate keys (4) and associated text (16) are not implemented or reflected in the negotiated flags. IME composition/text commits and paste retain their existing paths; physical keys and releases cannot be inferred from committed text. Letters, digits, punctuation, navigation, Tab/Enter, function keys, keypad keys and standard Kitty media keys retain distinct modifiers. OS/browser-reserved shortcuts may never reach the page. Keys without standard Kitty codes, such as brightness and microphone mute, are not assigned private encodings.
+
+This implements **jsgotty → PTY** encoding. Controlling Hyprland/Omarchy still requires Casty or another receiver to enable/decode Kitty keyboard and forward Super and release events. It does not complete the remote desktop input chain or change the mouse protocol.
+
+Reload the jsgotty page after updating. Run the manual tester inside its terminal:
+
+```sh
+bun tests/manual/kitty-keyboard.js
+```
+
+It prints negotiated flags, raw sequences, modifiers and event types, exits after 60 seconds or unmodified Escape/q/Ctrl-C, and restores the previous keyboard/raw modes. An optional real bundled-xterm test uses an already installed browser:
+
+```sh
+CHROMIUM_HEADLESS=/path/to/chromium-headless-shell node --test tests/kitty-keyboard-browser.test.js
+```
+
+## Android Keyboards
+
+For Android WebViews that deliver Meta down/up but lose `metaKey`, jsgotty tracks both Meta keys inside its own input handler. Blur or page hiding clears held state and sends releases for reported keys when event reporting is enabled.
+
+In the Android terminal, Alt with letters, digits, punctuation, or space sends terminal Alt sequences based on physical key positions (US layout, including Shift), bypassing accent dead-key handling. Alt-E/I/N/U therefore no longer compose characters such as é, ê, ñ, and ü; input methods and paste remain available. When WebView omits `code`, recognized legacy `keyCode` values provide a fallback. Dead keys delivered only as `keyup` send the shortcut on release, without duplicating a previously handled `keydown`. Active composition, Ctrl, Meta, AltGr, and unidentified keys retain their existing handling. This applies only inside the jsgotty terminal and does not modify Android system keyboard settings.
+
 ## Tested platforms
 - Windows x64: Windows 11
 - Linux x64: CachyOS
@@ -292,3 +332,20 @@ bun sz.js file.txt
 - Bun is the primary runtime.
 - On Linux / macOS, PTY support will not work unless the program is launched with Bun.
 - GoTTY config file loading is not implemented yet.
+
+## OSC 52 clipboard
+
+The browser frontend supports OSC 52 writes and `?` queries against the **server host's clipboard**, not the browser device's clipboard. Only the session writer can request access; viewers do not duplicate operations. Query replies are sent directly back to the originating PTY as OSC 52 sequences.
+
+Each operation tries `xclip` first, including on Windows and Android. Missing or failing commands fall through to applicable `termux-clipboard-*`, `wl-copy`/`wl-paste`, `xsel`, macOS `pbcopy`/`pbpaste`, then Windows PowerShell. The PowerShell function is copied verbatim from jsmdcui. If all tools fail, the server uses its in-memory cache. A successful empty read remains empty, rather than returning stale cached text. There is no polling; external commands run in a worker.
+
+Supported selections: `c` (clipboard), `p` (primary), `q` (secondary); `s` maps to clipboard, and `0`–`7` are in-memory buffers. An empty selector uses `s0`. Tools without primary/secondary support do not substitute the clipboard. Requests are limited to 1 MiB.
+
+```sh
+# Write to the server clipboard
+printf '\033]52;c;%s\007' "$(printf 'Hello' | base64 | tr -d '\n')"
+```
+
+Applications can send `ESC ] 52 ; c ; ? ST` to read and receive a base64-encoded OSC 52 reply on stdin.
+
+`jsgotty --client` **does not intercept OSC 52**: it forwards reads and writes unchanged for the outer terminal emulator to handle.

package/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,20 @@ 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**，讀寫控制碼都原樣轉送，交給最外層真正的終端模擬器決定。

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