handmux 0.11.0 → 0.12.0

package/public/index.html

@@ -42,8 +42,8 @@
       @keyframes bootDot { 0%,100% { opacity: .22; transform: translateY(0); } 40% { opacity: 1; transform: translateY(-3px); } }
       @media (prefers-reduced-motion: reduce) { .boot-glow, .boot-dots i { animation: none; opacity: .8; } }
     </style>
-    <script type="module" crossorigin src="/assets/index-9fmzTpZ-.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-CJZ28YE2.css" media="print" onload="this.media='all'"><noscript><link rel="stylesheet" crossorigin href="/assets/index-CJZ28YE2.css"></noscript>
+    <script type="module" crossorigin src="/assets/index-DpMN2jCF.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-DJNPeU_h.css" media="print" onload="this.media='all'"><noscript><link rel="stylesheet" crossorigin href="/assets/index-DJNPeU_h.css"></noscript>
   </head>
   <body>
     <div id="boot-splash" aria-hidden="true">

package/src/httpApi.js

@@ -417,7 +417,7 @@ export function createApiRouter({
       // all key off the same trimmed capture. See trimCapture.js.
       const raw = await commands.capturePane(req.query.pane, lines);
       const ansi = capTrailingBlankRows(raw);
-      const { width, height, cursorX, cursorY, cursorVisible } = await commands.paneInfo(req.query.pane);
+      const { width, height, cursorX, cursorY, cursorVisible, altScreen, mouseAware } = await commands.paneInfo(req.query.pane);
       // The cursor's row counted from the BOTTOM of the (trimmed) capture. The live screen is the
       // capture's last `height` rows, so the cursor sits `height-1-cursorY` rows above the bottom —
       // less however many trailing blank rows capTrailingBlankRows dropped (all of them below the
@@ -431,11 +431,13 @@ export function createApiRouter({
       // an unchanged screen returns 204 (empty) so an idle pane stops re-sending the whole capture.
       // The cursor is folded in so a bare left/right (which moves the cursor but not the text) still
       // yields a fresh frame — otherwise the move would 204 and the cursor would never visibly track.
+      // mouseAware is folded in too: toggling an app's mouse mode (e.g. `:set mouse=a` in vim) changes
+      // whether a swipe should wheel-scroll or just hint, and the client only re-reads it on a fresh frame.
       const hash = createHash('sha1')
-        .update(`${width}x${height}\n${cur.col},${cursorY},${cur.vis ? 1 : 0}\n${ansi}`)
+        .update(`${width}x${height}\n${cur.col},${cursorY},${cur.vis ? 1 : 0}\n${altScreen ? 1 : 0}${mouseAware ? 'm' : ''}\n${ansi}`)
         .digest('hex').slice(0, 16);
       if (req.query.since === hash) return res.status(204).end();
-      const json = JSON.stringify({ ansi, width, height, hash, cur });
+      const json = JSON.stringify({ ansi, width, height, hash, cur, alt: altScreen, mouseAware });
       res.set('Content-Type', 'application/json');
       res.set('Vary', 'Accept-Encoding'); // both 200 branches vary on encoding (correct for any caching proxy)
       // Capture text is mostly SGR codes + spaces — gzip crushes it ~10x. (204s are empty, never gzipped.)
@@ -507,6 +509,29 @@ export function createApiRouter({
     } catch (e) { next(e); }
   });
 
+  // Swipe-to-scroll for full-screen (ALT-screen) apps: the client can't scroll the alt buffer itself
+  // (no scrollback), so it forwards the finger travel here and we inject wheel events the app scrolls on.
+  // SAFETY: we re-read the pane's mouse state at inject time and REFUSE unless it's actually reporting
+  // mouse — otherwise the raw escape bytes would print into the shell as literal `<65;…M` garbage. The
+  // client's cached mouseAware is only a UX hint; this check is the real guard (mouse mode can toggle
+  // between the poll and the gesture). Positioned at the pane centre so a split-aware app scrolls the
+  // region the finger is over; a lone full-screen app ignores the position.
+  r.post('/scroll', async (req, res, next) => {
+    const { pane, dir, lines } = req.body || {};
+    if (!isPaneId(pane)) return res.status(400).json({ error: 'bad pane id' });
+    if (dir !== 'up' && dir !== 'down') return res.status(400).json({ error: 'bad dir' });
+    try {
+      const { altScreen, mouseAware, mouseSgr, width, height } = await commands.paneInfo(pane);
+      if (!altScreen || !mouseAware) return res.json({ ok: false, reason: 'no-mouse' });
+      await commands.sendWheel(pane, dir, lines, {
+        sgr: mouseSgr,
+        col: Math.max(1, Math.floor((width || 2) / 2)),
+        row: Math.max(1, Math.floor((height || 2) / 2)),
+      });
+      res.json({ ok: true });
+    } catch (e) { next(e); }
+  });
+
   // --- Capabilities probe ---------------------------------------------------------------------
   // Optional integrations are configured per-install (open-source installs ship without keys), so the
   // client asks what's actually available and hides controls that can't work — e.g. the mic when no

package/src/tmux/commands.js

@@ -91,16 +91,46 @@ export async function capturePane(paneId, linesBack) {
 // visibility — it snapshots cells only — so we read them here for the client to re-place xterm's own
 // cursor onto Claude's input cell). cursor_x/cursor_y are 0-based, relative to the visible screen;
 // cursor_flag is DECTCEM visibility (1 while Claude accepts input, 0 while it's working / in a dialog).
+// alternate_on = the pane is on the ALT screen (a full-screen app: vim/htop/less/a mouse-mode TUI). The
+// alt buffer has no scrollback, so the phone can't swipe-scroll it. mouse_any_flag = the app has requested
+// mouse reporting (any mode); mouse_sgr_flag = it negotiated the SGR (1006) encoding. Together they let the
+// client translate a swipe into wheel events the app scrolls on (sendWheel) instead of a dead swipe.
 export async function paneInfo(paneId) {
   const out = await runTmux(['display-message', '-p', '-t', paneId,
-    '#{pane_width}\t#{pane_height}\t#{cursor_x}\t#{cursor_y}\t#{cursor_flag}']);
-  const [width, height, cx, cy, cflag] = out.trim().split('\t');
+    '#{pane_width}\t#{pane_height}\t#{cursor_x}\t#{cursor_y}\t#{cursor_flag}\t#{alternate_on}\t#{mouse_any_flag}\t#{mouse_sgr_flag}']);
+  const [width, height, cx, cy, cflag, alt, mAny, mSgr] = out.trim().split('\t');
   return {
     width: Number(width), height: Number(height),
     cursorX: Number(cx), cursorY: Number(cy), cursorVisible: cflag === '1',
+    altScreen: alt === '1', mouseAware: mAny === '1', mouseSgr: mSgr === '1',
   };
 }
 
+// Inject mouse-wheel scroll events so a full-screen app on the ALT screen scrolls itself — exactly what a
+// desktop wheel does. dir 'up' scrolls toward earlier content (SGR button 64), 'down' toward later (65);
+// `count` notches go out in ONE send-keys as a repeated escape run. Only meaningful when the app requested
+// mouse reporting — the CALLER MUST verify paneInfo().mouseAware first, or these escape bytes land in the
+// shell as literal text. `sgr` picks the 1006 encoding the app negotiated (else the legacy X10 form);
+// `col`/`row` are the 1-based pointer position the event reports at (the pane centre — irrelevant to a lone
+// full-screen app, but lets a split-aware app scroll the region under the finger).
+export async function sendWheel(paneId, dir, count, opts = {}) {
+  await runTmux(['send-keys', '-t', paneId, '-l', '--', wheelSeq(dir, count, opts)]);
+}
+
+// Pure: build the terminal byte run for `count` wheel notches (kept separate so the encoding is unit-
+// tested without spawning tmux). `count` is clamped to 1..60 (one flick shouldn't inject hundreds).
+export function wheelSeq(dir, count, { sgr = true, col = 1, row = 1 } = {}) {
+  const n = Math.min(Math.max(Math.trunc(Number(count)) || 1, 1), 60);
+  const btn = dir === 'up' ? 64 : 65;
+  const c = Math.max(1, Math.trunc(col) || 1);
+  const r = Math.max(1, Math.trunc(row) || 1);
+  const unit = sgr
+    ? `\x1b[<${btn};${c};${r}M`
+    // legacy X10: ESC [ M  <btn+32> <col+32> <row+32>, each coordinate byte capped at 223.
+    : `\x1b[M${String.fromCharCode(btn + 32, Math.min(c, 223) + 32, Math.min(r, 223) + 32)}`;
+  return unit.repeat(n);
+}
+
 // Resolve a pane to its tmux session name + window for routing a notification back to it. The hook
 // gives us only $TMUX_PANE; this turns "%263" into the session/window the phone navigates by.
 export async function paneLocation(paneId) {