buninu 0.5.0 → 0.7.0

package/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/apps/jsgotty/package-lock.json

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

package/apps/jsgotty/package.json

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

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

package/apps/jsgotty/static/js/gotty.js

@@ -12168,7 +12168,8 @@
           (t.msgSetWindowTitle = "3"),
           (t.msgSetPreferences = "4"),
           (t.msgSetReconnect = "5"),
-          (t.msgSetBufferSize = "6"));
+          (t.msgSetBufferSize = "6"),
+          (t.msgRestoreModes = "m"));
         t.WebTTY = class {
           term;
           connectionFactory;
@@ -12193,6 +12194,9 @@
             this.reconnectDeadline = 0;
             this.reconnectAttempts = 0;
             this.zmodemExpectedSeq = 0;
+            this.term.onClipboard?.(data => {
+              if (!this.disconnected) this.connection.send("C" + data);
+            });
           }
           open() {
             let e;
@@ -12330,6 +12334,9 @@
                       const e = JSON.parse(i);
                       this.term.setPreferences(e);
                       break;
+                    case t.msgRestoreModes:
+                      this.term.applySessionModes(JSON.parse(i));
+                      break;
                     case t.msgSetReconnect:
                       const r = JSON.parse(i);
                       "number" == typeof r
@@ -12540,12 +12547,30 @@
 	              })),
 	              (this.fitAddOn = new s.FitAddon()),
 	              (this.zmodemAddon = new a.ZModemAddon({
-	                toTerminal: (e) => this.term.write(e),
+	                toTerminal: (e) => this.writeTerminal(e),
 	                toServer: (e) => this.sendInput(e),
 	              })),
               (this.kittyKeyboard = new globalThis.GoTTYKittyKeyboard.KittyKeyboard(this.term, {
                 android: /Android/i.test(navigator.userAgent),
               })),
+              this.term.parser.registerOscHandler(52, data => {
+                if (!this.disconnected && data.length <= 1048576) this.clipboardHandler?.(data);
+                return true;
+              }),
+              this.term.parser.registerOscHandler(777, data => {
+                const match = /^jsgotty-modes;([a-f0-9]{32})$/.exec(data);
+                if (!match) {
+                  const restore = /^jsgotty-kitty-v1;(normal|alternate);(\d{1,2});(\d{1,2}(?:,\d{1,2})*)?$/.exec(data);
+                  if (!restore) return false;
+                  const flags = +restore[2], stack = restore[3] ? restore[3].split(',').map(Number) : [];
+                  if (flags > 31 || stack.length > 32 || stack.some(n => n > 31)) return true;
+                  this.kittyKeyboard.states[restore[1]] = {flags: flags & 11, stack: stack.map(n => n & 11)};
+                  return true;
+                }
+                this.term.input("\x1b]777;jsgotty-modes;" + match[1] + ";" +
+                  btoa(JSON.stringify({...this.sessionModes(), kittyRestore: 1})) + "\x07", false);
+                return true;
+              }),
               this.term.attachCustomKeyEventHandler((event) =>
                 this.kittyKeyboard.handle(event) && this.handleAndroidAltKey(event),
               ),
@@ -12676,8 +12701,73 @@
           getMessage() {
             return this.message;
           }
+          enqueueTerminal(task) {
+            this.terminalTasks ||= [];
+            this.terminalTasks.push(task);
+            if (this.terminalBusy) return;
+            this.terminalBusy = true;
+            const next = () => {
+              const task = this.terminalTasks.shift();
+              if (!task) { this.terminalBusy = false; return; }
+              task(next);
+            };
+            next();
+          }
+          writeTerminal(data) {
+            this.enqueueTerminal(done => this.term.write(data, done));
+          }
+          onClipboard(handler) {
+            this.clipboardHandler = handler;
+          }
+          sessionModes() {
+            const core = this.term._core;
+            return {dec: {...core.coreService.decPrivateModes},
+              mouse: core.coreMouseService.activeProtocol,
+              encoding: core.coreMouseService.activeEncoding,
+              cursorHidden: !!core.coreService.isCursorHidden,
+              alternate: this.term.buffer.active.type === "alternate",
+              kitty: JSON.parse(JSON.stringify(this.kittyKeyboard.states))};
+          }
+          applySessionModes(state) {
+            this.enqueueTerminal(done => this.term.write("", () => this.restoreSessionModes(state, done)));
+          }
+          restoreSessionModes(state, done) {
+            if (!state || !state.dec) { done(); return; }
+            const core = this.term._core;
+            const dec = core.coreService.decPrivateModes;
+            const mouse = core.coreMouseService;
+            // A socket-only reconnect keeps xterm's modes, so send only differences:
+            // DECOM homes the cursor and 1049 overwrites the saved cursor.
+            let sequence = "";
+            const alternate = this.term.buffer.active.type === "alternate";
+            if (!!state.alternate !== alternate) sequence += `\x1b[?1049${state.alternate ? "h" : "l"}`;
+            const flags = {1:"applicationCursorKeys", 6:"origin", 7:"wraparound", 45:"reverseWraparound",
+              66:"applicationKeypad", 1004:"sendFocus", 2004:"bracketedPasteMode"};
+            for (const [mode, name] of Object.entries(flags))
+              if (!!state.dec[name] !== !!dec[name]) sequence += `\x1b[?${mode}${state.dec[name] ? "h" : "l"}`;
+            if (!!state.cursorHidden !== !!core.coreService.isCursorHidden)
+              sequence += `\x1b[?25${state.cursorHidden ? "l" : "h"}`;
+            if (state.mouse !== mouse.activeProtocol) {
+              const modes = {X10:9, VT200:1000, DRAG:1002, ANY:1003};
+              sequence += modes[state.mouse] ? `\x1b[?${modes[state.mouse]}h` : "\x1b[?1000l";
+            }
+            if (state.encoding !== mouse.activeEncoding) {
+              const modes = {SGR:1006, SGR_PIXELS:1016};
+              sequence += modes[state.encoding] ? `\x1b[?${modes[state.encoding]}h` : "\x1b[?1006l";
+            }
+            const complete = () => {
+            // Assigned rather than replayed so the push stack never doubles; the server
+            // keeps every flag, so mask to the ones kitty-keyboard.js implements.
+            const supported = (s) => ({flags: s.flags & 11, stack: s.stack.map((f) => f & 11)});
+            if (state.kitty?.normal && state.kitty?.alternate)
+              this.kittyKeyboard.states = {normal: supported(state.kitty.normal), alternate: supported(state.kitty.alternate)};
+              done();
+            };
+            if (sequence) this.term.write(sequence, complete);
+            else complete();
+          }
           setDisconnected(e) {
-            if (e) this.kittyKeyboard.reset();
+            if (e) this.kittyKeyboard.clearHeld(false);
             this.disconnected = !!e;
           }
           setReconnectAction(e) {
@@ -12789,7 +12879,8 @@
             this.term.blur();
           }
           reset() {
-            this.kittyKeyboard.reset();
+            // Reconnecting the transport does not reset the running PTY's modes.
+            this.kittyKeyboard.clearHeld(false);
             (this.removeMessage(), this.term.clear());
           }
           close() {
@@ -15906,8 +15997,15 @@
                                 !1 === e._customWheelEventHandler(t)
                               )
                                 return !1;
-                              if (0 === e.viewport.getLinesScrolled(t))
-                                return !1;
+                              // Preserve both axes of diagonal wheel/touch gestures.
+                              // CoreMouseService already encodes wheel actions 2/3 as 66/67.
+                              if (t.deltaX) e.coreMouseService.triggerMouseEvent({
+                                col: i.col, row: i.row, x: i.x, y: i.y,
+                                button: 4, action: t.deltaX < 0 ? 2 : 3,
+                                ctrl: t.ctrlKey, alt: t.altKey, shift: t.shiftKey,
+                              });
+                              if (0 === e.viewport.getLinesScrolled(t, true))
+                                return !!t.deltaX;
                               ((s = t.deltaY < 0 ? 0 : 1), (r = 4));
                               break;
                             default:
@@ -16881,8 +16979,9 @@
                         }
                         return { bufferElements: s, cursorElement: i };
                       }
-                      getLinesScrolled(e) {
-                        if (0 === e.deltaY || e.shiftKey) return 0;
+                      getLinesScrolled(e, mouseReporting = false) {
+                        // Shift belongs to the remote application while mouse reporting is active.
+                        if (0 === e.deltaY || (e.shiftKey && !mouseReporting)) return 0;
                         let t = this._applyScrollModifier(e.deltaY, e);
                         return (
                           e.deltaMode === WheelEvent.DOM_DELTA_PIXEL

package/apps/jsgotty/static/js/kitty.js

@@ -561,6 +561,26 @@
     state.renderBound = state.renderDisposables.length > 0;
   }
 
+  // Touch gestures report mouse input without DOM mousedown: xterm's DOM
+  // handler focuses its hidden textarea, which can zoom Android WebView.
+  function reportTouchMouse(type, point, button = 0) {
+    const core = terminal?.__gottyXterm?._core;
+    if (!core?.coreMouseService?.areMouseEventsActive) return;
+    const screen = core.screenElement;
+    if (!screen) return;
+    const rect = screen.getBoundingClientRect();
+    const coords = core._mouseService.getMouseReportCoords({
+      clientX: Math.max(rect.left, Math.min(rect.right - 1, point.clientX)),
+      clientY: Math.max(rect.top, Math.min(rect.bottom - 1, point.clientY)),
+    }, screen);
+    if (!coords) return;
+    core.coreMouseService.triggerMouseEvent({
+      ...coords, button,
+      action: type === "mousedown" ? 1 : type === "mousemove" ? 32 : 0,
+      ctrl: false, alt: false, shift: false,
+    });
+  }
+
   function dispatchSyntheticWheel(target, touch, deltaX, deltaY) {
     if (!target) {
       return;
@@ -597,22 +617,69 @@
       return screen || viewport || xterm || terminal;
     };
 
+    let lastTap = null;
+    let drag = null;
+    const mouse = (type, point) => reportTouchMouse(type, point);
+    const releaseDrag = () => {
+      if (drag) {
+        const point = drag;
+        drag = null;
+        mouse("mouseup", point);
+      }
+    };
+    const cancelGesture = () => {
+      releaseDrag();
+      lastTap = null;
+      state.touchScroll = null;
+    };
+    state.cancelTouchGesture = cancelGesture;
+    bindTarget.addEventListener("contextmenu", (event) => {
+      if (drag) { event.preventDefault(); event.stopImmediatePropagation(); }
+    }, true);
+    window.addEventListener("blur", cancelGesture);
+    document.addEventListener("visibilitychange", () => {
+      if (document.hidden) cancelGesture();
+    });
+
     bindTarget.addEventListener("touchstart", (event) => {
       if (event.touches.length !== 1) {
-        state.touchScroll = null;
+        cancelGesture();
         return;
       }
       const touch = event.touches[0];
+      const reporting = terminal.__gottyXterm?._core?.coreMouseService?.areMouseEventsActive;
+      if (reporting && window.touchDoubleTapDrag !== false && lastTap &&
+          performance.now() - lastTap.time < 350 &&
+          Math.hypot(touch.clientX - lastTap.x, touch.clientY - lastTap.y) < 24) {
+        lastTap = null;
+        state.touchScroll = null;
+        drag = { identifier: touch.identifier, clientX: touch.clientX, clientY: touch.clientY };
+        // Cancel compatibility mouse events: this is the second press, not a third click.
+        event.preventDefault();
+        mouse("mousedown", drag);
+        return;
+      }
+      lastTap = null;
       state.touchScroll = {
+        startX: touch.clientX, startY: touch.clientY, startTime: performance.now(), moved: false,
         identifier: touch.identifier,
         lastX: touch.clientX,
         lastY: touch.clientY,
         residualX: 0,
         residualY: 0
       };
-    }, { passive: true });
+    }, { passive: false });
 
     bindTarget.addEventListener("touchmove", (event) => {
+      if (drag) {
+        const touch = Array.from(event.touches).find(t => t.identifier === drag.identifier);
+        if (!touch || event.touches.length !== 1) { cancelGesture(); return; }
+        event.preventDefault();
+        drag.clientX = touch.clientX;
+        drag.clientY = touch.clientY;
+        mouse("mousemove", drag);
+        return;
+      }
       if (!state.touchScroll) {
         return;
       }
@@ -621,6 +688,8 @@
         return;
       }
 
+      if (Math.hypot(touch.clientX - state.touchScroll.startX,
+          touch.clientY - state.touchScroll.startY) > 8) state.touchScroll.moved = true;
       const deltaX = state.touchScroll.lastX - touch.clientX;
       const deltaY = state.touchScroll.lastY - touch.clientY;
       state.touchScroll.lastX = touch.clientX;
@@ -653,11 +722,20 @@
       state.touchScroll.residualY -= ticksY * threshold * stepY;
     }, { passive: false });
 
-    const clearTouchScroll = () => {
+    bindTarget.addEventListener("touchend", (event) => {
+      if (drag) {
+        event.preventDefault();
+        releaseDrag();
+      } else {
+        const scroll = state.touchScroll;
+        if (scroll && !scroll.moved && event.touches.length === 0 &&
+            performance.now() - scroll.startTime < 350) {
+          lastTap = { x: scroll.lastX, y: scroll.lastY, time: performance.now() };
+        }
+      }
       state.touchScroll = null;
-    };
-    bindTarget.addEventListener("touchend", clearTouchScroll, { passive: true });
-    bindTarget.addEventListener("touchcancel", clearTouchScroll, { passive: true });
+    }, { passive: false });
+    bindTarget.addEventListener("touchcancel", cancelGesture, { passive: true });
     state.touchBound = true;
   }
 
@@ -676,9 +754,25 @@
     removeButton.textContent = "Remove image";
     menu.appendChild(removeButton);
 
+    const separator = document.createElement("hr");
+    const rightButton = document.createElement("button");
+    rightButton.type = "button";
+    rightButton.className = "kitty-context-menu__item";
+    rightButton.textContent = "Right click";
+    menu.append(separator, rightButton);
+    rightButton.addEventListener("click", (event) => {
+      event.preventDefault();
+      event.stopPropagation();
+      const point = state.contextMenu?.point;
+      hideContextMenu();
+      if (!point || !terminal.__gottyXterm?._core?.coreMouseService?.areMouseEventsActive) return;
+      reportTouchMouse("mousedown", { clientX: point.x, clientY: point.y }, 2);
+      reportTouchMouse("mouseup", { clientX: point.x, clientY: point.y }, 2);
+    });
+
     state.contextMenu = {
       root: menu,
-      removeButton,
+      removeButton, rightButton, separator,
       targetKey: null
     };
 
@@ -722,6 +816,9 @@
   function showContextMenu(x, y, key) {
     const menu = ensureContextMenu();
     menu.targetKey = key;
+    menu.point = { x, y };
+    const reporting = !!terminal.__gottyXterm?._core?.coreMouseService?.areMouseEventsActive;
+    menu.rightButton.hidden = menu.separator.hidden = !reporting;
     menu.root.hidden = false;
 
     const margin = 10;
@@ -1004,6 +1101,15 @@
     return false;
   }
 
+  const watchedSockets = new WeakSet();
+  function watchTouchSocket(socket) {
+    if (watchedSockets.has(socket)) return;
+    watchedSockets.add(socket);
+    socket.addEventListener("close", () => {
+      if (state.socket === socket) state.cancelTouchGesture?.();
+    });
+  }
+
   const nativeSend = WebSocket.prototype.send;
   const nativeOnOpen = WebSocket.prototype.addEventListener;
   WebSocket.prototype.addEventListener = function (type, listener, options) {
@@ -1012,6 +1118,7 @@
     }
       const wrapped = function (event) {
         state.socket = this;
+        watchTouchSocket(this);
         inspectTerminalOutput(event.data);
         if (typeof event.data === "string" && event.data[0] === MSG_KITTY) {
           if (handleKittyMessage(event.data.slice(1))) {
@@ -1058,6 +1165,7 @@
       }
       const wrapped = function (event) {
         state.socket = this;
+        watchTouchSocket(this);
         inspectTerminalOutput(event.data);
         if (typeof event.data === "string" && event.data[0] === MSG_KITTY) {
           if (handleKittyMessage(event.data.slice(1))) {