buninu 0.5.0 → 0.7.0

package/CHANGELOG.md

@@ -1,5 +1,52 @@
 # Changelog
 
+## 0.7.0 - 2026-10-26
+
+- Sync jsgotty to 1.4.0:
+  * Add horizontal and diagonal scrolling through terminal mouse reporting,
+    including Shift-wheel horizontal scrolling and preserved wheel modifiers.
+  * Double-tap and hold the second tap to drag with the left mouse button when
+    application mouse reporting is enabled. Release the button on touch
+    cancellation, backgrounding or disconnect; ordinary swipes still scroll.
+  * Add Right click to the existing image long-press menu, sending the click
+    at the position where the menu was opened without removing the image.
+  * Prevent Android WebView from automatically zooming the terminal's hidden
+    input after native long-press paste, including at reduced viewport zoom.
+    Keep native paste, IME input and pinch zoom on the visible terminal.
+- Sync jsmdcui to 0.19.4:
+  * Restore Dockerfile highlighting and improve compatibility with Micro's
+    syntax definitions by translating Go regexp flags and POSIX character
+    classes while preserving scoped flags.
+  * Fix nested HTML/XML highlighting regions so quoted attributes return to
+    their enclosing tags and unfinished attributes retain state across lines.
+  * Use iterative region scanning to support long minified lines without
+    recursive stack exhaustion or truncating highlighting.
+  * Guard against zero-width region cycles, cyclic syntax/state trees and
+    excessively nested regexp conversion. Disable failing rules individually
+    instead of losing an entire syntax definition; retain support for long
+    lines. These guards do not impose timeouts on individual JavaScript regexps.
+
+## 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:

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

@@ -332,3 +332,24 @@ 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.
+
+### Touch dragging and right click
+
+When the application enables mouse reporting, double-tap and hold the second tap to drag with the left button; lifting your finger releases it. Single-finger swipes still scroll. The existing image long-press menu now includes `Right click` below `Remove image`; it sends a right click at the position where the menu was opened. Pinch zoom and the existing remove-image gesture remain unchanged. To disable double-tap dragging, set `window.touchDoubleTapDrag = false` in the page JavaScript.

package/apps/jsgotty/README.md

@@ -334,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/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);
+};

package/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;