buninu 0.5.0 → 0.6.0

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

@@ -10,4 +10,10 @@ 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;
+}

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() {

package/apps/jsgotty/terminal-modes.js

@@ -0,0 +1,332 @@
+"use strict";
+
+// All flags defined by the kitty keyboard protocol. Kept unmasked so a CLI
+// client on a real kitty terminal can restore them; the browser masks its own.
+const KITTY_KEYBOARD_FLAGS = 0x1f;
+const TRACKED_DEC_FLAGS = {
+  1: "applicationCursorKeys",
+  6: "origin",
+  7: "wraparound",
+  45: "reverseWraparound",
+  66: "applicationKeypad",
+  1004: "sendFocus",
+  2004: "bracketedPasteMode",
+};
+const MOUSE_PROTOCOLS = { 9: "X10", 1000: "VT200", 1002: "DRAG", 1003: "ANY" };
+const MOUSE_ENCODINGS = { 1006: "SGR", 1016: "SGR_PIXELS" };
+
+// Mirrors the PTY's input/protocol modes so a resumed client can be brought
+// back in sync. Mode semantics follow xterm.js, which renders the output.
+class TerminalModeTracker {
+  constructor() {
+    this.reset();
+    this._state = "text";
+    this._seq = "";
+  }
+
+  reset() {
+    this.dec = {
+      applicationCursorKeys: false,
+      applicationKeypad: false,
+      bracketedPasteMode: false,
+      origin: false,
+      reverseWraparound: false,
+      sendFocus: false,
+      wraparound: true,
+    };
+    this.cursorHidden = false;
+    this.mouse = "NONE";
+    this.encoding = "DEFAULT";
+    this.alternate = false;
+    this.kitty = { normal: { flags: 0, stack: [] }, alternate: { flags: 0, stack: [] } };
+  }
+
+  snapshot() {
+    return {
+      dec: { ...this.dec },
+      cursorHidden: this.cursorHidden,
+      mouse: this.mouse,
+      encoding: this.encoding,
+      alternate: this.alternate,
+      kitty: {
+        normal: { flags: this.kitty.normal.flags, stack: [...this.kitty.normal.stack] },
+        alternate: { flags: this.kitty.alternate.flags, stack: [...this.kitty.alternate.stack] },
+      },
+    };
+  }
+
+  consume(buffer) {
+    // Control sequences are ASCII, so bytes can be scanned without UTF-8 decoding.
+    for (let i = 0; i < buffer.length; i += 1) {
+      const byte = buffer[i];
+      switch (this._state) {
+        case "text":
+          if (byte === 0x1b) {
+            this._state = "esc";
+          }
+          break;
+        case "esc":
+          if (byte === 0x5b) {
+            this._state = "csi";
+            this._seq = "";
+          } else if (byte === 0x5d || byte === 0x50 || byte === 0x5f || byte === 0x5e || byte === 0x58) {
+            this._state = "string";
+            this._osc = byte === 0x5d ? "" : null;
+          } else if (byte === 0x1b) {
+            this._state = "esc";
+          } else if (byte >= 0x20 && byte <= 0x2f) {
+            this._state = "esc-intermediate";
+          } else {
+            this._state = "text";
+            this.handleEsc(byte);
+          }
+          break;
+        case "esc-intermediate":
+          if (byte < 0x20 || byte > 0x2f) {
+            this._state = byte === 0x1b ? "esc" : "text";
+          }
+          break;
+        case "csi":
+          if (byte >= 0x40 && byte <= 0x7e) {
+            this._state = "text";
+            this.handleCsi(this._seq, String.fromCharCode(byte));
+          } else if (byte === 0x1b) {
+            this._state = "esc";
+          } else if (byte === 0x18 || byte === 0x1a || this._seq.length >= 64) {
+            this._state = "text";
+          } else if (byte >= 0x20) {
+            this._seq += String.fromCharCode(byte);
+          }
+          break;
+        case "string":
+          if (byte === 0x07 || byte === 0x18 || byte === 0x1a) {
+            if (byte === 0x07) this.handleOsc();
+            this._state = "text";
+          } else if (byte === 0x1b) {
+            this._state = "string-esc";
+          } else if (this._osc != null) {
+            this._osc = this._osc.length < 256 ? this._osc + String.fromCharCode(byte) : null;
+          }
+          break;
+        case "string-esc":
+          if (byte === 0x5c) this.handleOsc();
+          else this._osc = null;
+          this._state = byte === 0x1b ? "string-esc" : byte === 0x5c ? "text" : "string";
+          break;
+      }
+    }
+  }
+
+  handleOsc() {
+    const match = /^777;jsgotty-kitty-v1;(normal|alternate);(\d{1,2});(\d{1,2}(?:,\d{1,2})*)?$/.exec(this._osc || '');
+    if (!match) return;
+    const flags = +match[2], stack = match[3] ? match[3].split(',').map(Number) : [];
+    if (flags > 31 || stack.length > 32 || stack.some(n=>n > 31)) return;
+    this.kitty[match[1]] = {flags, stack};
+  }
+
+  handleEsc(byte) {
+    if (byte === 0x3d) {
+      this.dec.applicationKeypad = true;
+    } else if (byte === 0x3e) {
+      this.dec.applicationKeypad = false;
+    } else if (byte === 0x63) {
+      this.reset();
+    }
+  }
+
+  handleCsi(seq, final) {
+    const prefix = /^[<=>?]/.test(seq) ? seq[0] : "";
+    const body = prefix ? seq.slice(1) : seq;
+    if (!/^[0-9;:]*$/.test(body)) {
+      if (body === "!" && final === "p") {
+        this.softReset();
+      }
+      return;
+    }
+    const params = body === "" ? [] : body.split(";").map((part) => {
+      const value = Number.parseInt(part, 10);
+      return Number.isFinite(value) ? value : 0;
+    });
+    if (prefix === "?" && (final === "h" || final === "l")) {
+      for (const mode of params) {
+        this.setPrivateMode(mode, final === "h");
+      }
+    } else if (final === "u" && prefix !== "?") {
+      this.handleKittyKeyboard(prefix, params);
+    }
+  }
+
+  softReset() {
+    // DECSTR keeps the active screen and mouse reporting, like xterm.js.
+    const { alternate, mouse, encoding } = this;
+    this.reset();
+    Object.assign(this, { alternate, mouse, encoding });
+  }
+
+  setPrivateMode(mode, enabled) {
+    if (TRACKED_DEC_FLAGS[mode]) {
+      this.dec[TRACKED_DEC_FLAGS[mode]] = enabled;
+    } else if (MOUSE_PROTOCOLS[mode]) {
+      this.mouse = enabled ? MOUSE_PROTOCOLS[mode] : "NONE";
+    } else if (MOUSE_ENCODINGS[mode]) {
+      this.encoding = enabled ? MOUSE_ENCODINGS[mode] : "DEFAULT";
+    } else if (mode === 25) {
+      this.cursorHidden = !enabled;
+    } else if (mode === 47 || mode === 1047 || mode === 1049) {
+      this.alternate = enabled;
+    }
+  }
+
+  handleKittyKeyboard(prefix, params) {
+    const state = this.kitty[this.alternate ? "alternate" : "normal"];
+    const value = (index, fallback = 0) => (Number.isInteger(params[index]) ? params[index] : fallback);
+    if (prefix === ">") {
+      state.stack.push(state.flags);
+      if (state.stack.length > 32) {
+        state.stack.shift();
+      }
+      state.flags = value(0) & KITTY_KEYBOARD_FLAGS;
+    } else if (prefix === "<") {
+      let count = Math.min(value(0) || 1, 33);
+      while (count--) {
+        state.flags = state.stack.pop() ?? 0;
+      }
+    } else if (prefix === "=") {
+      const flags = value(0) & KITTY_KEYBOARD_FLAGS;
+      const mode = value(1) || 1;
+      if (mode === 1) {
+        state.flags = flags;
+      } else if (mode === 2) {
+        state.flags |= flags;
+      } else if (mode === 3) {
+        state.flags &= ~flags;
+      }
+    }
+  }
+}
+
+const DEFAULT_MODES = new TerminalModeTracker().snapshot();
+const MOUSE_PROTOCOL_MODES = { X10: 9, VT200: 1000, DRAG: 1002, ANY: 1003 };
+const MOUSE_ENCODING_MODES = { SGR: 1006, SGR_PIXELS: 1016 };
+
+function sameKitty(a, b) {
+  return a.flags === b.flags && a.stack.length === b.stack.length &&
+    a.stack.every((flags, index) => flags === b.stack[index]);
+}
+
+// Work only on the observed stack; never pop an arbitrary number of entries.
+// With a terminal that cannot report its stack, [] denotes the unseen baseline.
+function kittyTransition(from, to) {
+  if (to.flags == null) return "";
+  let common = 0;
+  while (common < from.stack.length && common < to.stack.length &&
+    from.stack[common] === to.stack[common]) common++;
+  let sequence = "";
+  let flags = from.flags;
+  const pops = from.stack.length - common;
+  if (pops) {
+    sequence += `\x1b[<${pops}u`;
+    flags = from.stack[common];
+  }
+  const first = to.stack[common] ?? to.flags;
+  if (flags !== first) sequence += `\x1b[=${first};1u`;
+  for (let i = common; i < to.stack.length; i++)
+    sequence += `\x1b[>${to.stack[i + 1] ?? to.flags}u`;
+  return sequence;
+}
+
+// Escape sequence that moves a terminal known to be in `from` to `to`, emitting
+// only differences: DECOM homes the cursor and 1049 overwrites the saved cursor.
+function modeTransition(from, to = DEFAULT_MODES, { normalizeMouse = false, kittyRestore = false } = {}) {
+  let sequence = "";
+  const fromScreen = from.alternate ? "alternate" : "normal";
+  const toScreen = to.alternate ? "alternate" : "normal";
+  // Kitty keyboard stacks are per screen, so each is fixed while it is active.
+  if (from.alternate != null && !sameKitty(from.kitty[fromScreen], to.kitty[fromScreen])) {
+    sequence += kittyTransition(from.kitty[fromScreen], to.kitty[fromScreen]);
+  }
+  if (to.alternate != null && from.alternate !== to.alternate) {
+    sequence += `\x1b[?1049${to.alternate ? "h" : "l"}`;
+    if (!sameKitty(from.kitty[toScreen], to.kitty[toScreen])) {
+      sequence += kittyTransition(from.kitty[toScreen], to.kitty[toScreen]);
+    }
+  }
+  const inactive = toScreen === "normal" ? "alternate" : "normal";
+  // Switching screens just to edit a hidden stack destroys alternate contents.
+  // Only emit this extension after the actual terminal advertised support.
+  const hidden = to.kitty[inactive];
+  if (kittyRestore && from.alternate != null && to.alternate != null && fromScreen === toScreen &&
+      !sameKitty(from.kitty[inactive], hidden) && hidden.flags != null && hidden.stack.every(Number.isInteger)) {
+    sequence += `\x1b]777;jsgotty-kitty-v1;${inactive};${hidden.flags};${hidden.stack.join(',')}\x07`;
+  }
+  for (const [mode, name] of Object.entries(TRACKED_DEC_FLAGS)) {
+    if (to.dec[name] == null || from.dec[name] === to.dec[name]) {
+      continue;
+    }
+    if (name === "applicationKeypad") {
+      sequence += to.dec[name] ? "\x1b=" : "\x1b>"; // more widely supported than ?66
+    } else {
+      sequence += `\x1b[?${mode}${to.dec[name] ? "h" : "l"}`;
+    }
+  }
+  if (to.cursorHidden != null && from.cursorHidden !== to.cursorHidden) {
+    sequence += `\x1b[?25${to.cursorHidden ? "l" : "h"}`;
+  }
+  // Raw query results preserve independent switches on native terminals. Reset
+  // first, then enable in priority order so exclusive terminals also end in the
+  // intended effective mode. Unanswered switches are never guessed.
+  for (const [name, bitsName, table] of [
+    ['mouse', 'mouseModeBits', MOUSE_PROTOCOL_MODES],
+    ['encoding', 'mouseEncodingBits', MOUSE_ENCODING_MODES],
+  ]) {
+    const bits = to[bitsName];
+    if (bits) {
+      for (const mode of Object.values(table))
+        if (bits[mode] === false) sequence += `\x1b[?${mode}l`;
+      for (const mode of Object.values(table))
+        if (bits[mode] === true) sequence += `\x1b[?${mode}h`;
+    } else if (to[name] != null && (normalizeMouse || from[name] !== to[name])) {
+      for (const mode of Object.values(table)) sequence += `\x1b[?${mode}l`;
+      if (table[to[name]]) sequence += `\x1b[?${table[to[name]]}h`;
+    }
+  }
+  return sequence;
+}
+
+function validateSnapshot(value) {
+  if (!value || !value.dec || !value.kitty) throw Error("Invalid terminal modes");
+  const result = new TerminalModeTracker().snapshot();
+  for (const key of Object.values(TRACKED_DEC_FLAGS)) {
+    if (typeof value.dec[key] !== 'boolean' && value.dec[key] !== null) throw Error("Invalid DEC mode");
+    result.dec[key] = value.dec[key];
+  }
+  for (const key of ['alternate', 'cursorHidden']) {
+    if (typeof value[key] !== 'boolean' && value[key] !== null) throw Error("Invalid screen mode");
+    result[key] = value[key];
+  }
+  for (const [key, choices] of [['mouse', ['NONE', ...Object.values(MOUSE_PROTOCOLS)]], ['encoding', ['DEFAULT', ...Object.values(MOUSE_ENCODINGS)]]]) {
+    if (value[key] !== null && !choices.includes(value[key])) throw Error("Invalid mouse mode");
+    result[key] = value[key];
+  }
+  for (const [key, table] of [['mouseModeBits', MOUSE_PROTOCOLS], ['mouseEncodingBits', MOUSE_ENCODINGS]]) {
+    if (value[key] === undefined) continue;
+    if (!value[key] || typeof value[key] !== 'object') throw Error('Invalid mouse bits');
+    result[key] = {};
+    for (const mode of Object.keys(table)) {
+      const bit = value[key][mode];
+      if (bit !== null && typeof bit !== 'boolean') throw Error('Invalid mouse bit');
+      result[key][mode] = bit;
+    }
+  }
+  for (const key of ['normal', 'alternate']) {
+    const state = value.kitty[key];
+    const flag = n => Number.isInteger(n) && n >= 0 && n <= KITTY_KEYBOARD_FLAGS;
+    if (!state || (state.flags !== null && !flag(state.flags)) || !Array.isArray(state.stack) ||
+      state.stack.length > 32 || !state.stack.every(n => n === null || flag(n))) throw Error("Invalid Kitty state");
+    result.kitty[key] = {flags: state.flags, stack: [...state.stack]};
+  }
+  return result;
+}
+
+module.exports = { TerminalModeTracker, modeTransition, validateSnapshot, TRACKED_DEC_FLAGS, MOUSE_PROTOCOLS, MOUSE_ENCODINGS };

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

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

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

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