mixdog 0.9.22 → 0.9.23

package/src/tui/app/use-mouse-input.mjs

@@ -28,6 +28,14 @@ const MOUSE_CTRL_MASK = 16;
 // every modifier bit) so a shift-held left-click can extend an existing
 // selection instead of starting a fresh one.
 const MOUSE_SHIFT_MASK = 4;
+// Windows Terminal (1.25+) forwards shift+click/drag to the app during VT
+// mouse mode while ALSO painting its own native selection — honoring the
+// events would draw two overlapping highlights (app blue + WT white). In WT,
+// drop every shift-modified button event so shift stays purely native
+// (native highlight + native Ctrl+C copy); plain drag / ctrl+click /
+// right-click remain the app-owned selection paths. Other terminals keep
+// the shift-extend behavior (with XTSHIFTESCAPE opted in from index.jsx).
+const IS_WINDOWS_TERMINAL = Boolean(process.env.WT_SESSION);
 
 export function useMouseInput({
   inkInput,
@@ -56,7 +64,10 @@ export function useMouseInput({
   setMeasuredRowsVersion,
   clearStitchBuffer,
 }) {
-  const mouseZoomPassthroughTimerRef = useRef(null);
+  const zoomTimerRef = useRef(null);
+  // Edge auto-scroll timer state (see the effect below). Owned at hook scope so
+  // it survives re-subscribes; the drag itself lives on the App-owned dragRef.
+  const edgeAutoscrollRef = useRef({ dir: 0, timer: null, noMove: 0 });
 
   const passthroughCtrlWheelZoom = useCallback(() => {
     if (!stdout?.write) return;
@@ -65,21 +76,21 @@ export function useMouseInput({
     } catch {
       return;
     }
-    if (mouseZoomPassthroughTimerRef.current) clearTimeout(mouseZoomPassthroughTimerRef.current);
-    mouseZoomPassthroughTimerRef.current = setTimeout(() => {
-      mouseZoomPassthroughTimerRef.current = null;
+    if (zoomTimerRef.current) clearTimeout(zoomTimerRef.current);
+    zoomTimerRef.current = setTimeout(() => {
+      zoomTimerRef.current = null;
       try {
         stdout.write(ALT_SCROLL_ON + MOUSE_TRACKING_ON);
       } catch {
         // The terminal may already be closing.
       }
     }, 700);
-    mouseZoomPassthroughTimerRef.current.unref?.();
-  }, [stdout]);
+    zoomTimerRef.current.unref?.();
+  }, [stdout, zoomTimerRef]);
 
   useEffect(() => () => {
-    if (mouseZoomPassthroughTimerRef.current) clearTimeout(mouseZoomPassthroughTimerRef.current);
-  }, []);
+    if (zoomTimerRef.current) clearTimeout(zoomTimerRef.current);
+  }, [zoomTimerRef]);
 
   // Optional mouse handling. When index.jsx enables SGR mouse tracking
   // (?1000h button + ?1002h drag-motion + ?1006h SGR coords).
@@ -175,6 +186,83 @@ export function useMouseInput({
       promptMouseSelectionRef.current?.clear?.();
       applySelectionRect(null);
     };
+    // Edge auto-scroll TIMER (ref: ScrollKeybindingHandler useDragToScroll).
+    // SGR mode 1002 reports drag-motion only when the pointer changes CELL, so
+    // a pointer held stationary at the top/bottom edge stops emitting events
+    // and the motion-driven scroll below stalls. This interval keeps scrolling
+    // — scrollTranscriptRows' active-drag branch re-extends the selection to
+    // the still-held `last` cell each step — until the pointer leaves the edge,
+    // the drag ends, or a scroll boundary is reached (delta clamps to 0).
+    const EDGE_AUTOSCROLL_INTERVAL_MS = 50;
+    const stopEdgeAutoscroll = () => {
+      const st = edgeAutoscrollRef.current;
+      if (st.timer) { clearInterval(st.timer); st.timer = null; }
+      st.dir = 0;
+      st.noMove = 0;
+    };
+    const startEdgeAutoscroll = (dir) => {
+      const st = edgeAutoscrollRef.current;
+      if (st.dir === dir && st.timer) return; // already scrolling this way
+      stopEdgeAutoscroll();
+      st.dir = dir;
+      st.noMove = 0;
+      st.timer = setInterval(() => {
+        const drag = dragRef.current;
+        const st2 = edgeAutoscrollRef.current;
+        if (!drag.active || drag.region !== 'transcript' || st2.dir === 0) {
+          stopEdgeAutoscroll();
+          return;
+        }
+        const before = Number(scrollTargetRef.current) || 0;
+        queueScrollCoalesced(st2.dir * 3);
+        // A SINGLE unchanged tick is ambiguous: the coalescer may not have
+        // flushed this delta yet (queued behind its 16ms leading-edge timer),
+        // so scrollTarget legitimately reads the same value mid-flight. Only a
+        // real top/bottom clamp keeps it pinned across several ticks. Require
+        // CONSECUTIVE no-move ticks (>=3 ⇒ >150ms ≫ the 16ms coalescer window,
+        // so any pending scroll has certainly flushed) before stopping — any
+        // movement resets the counter (ref useDragToScroll's getScrollTop<=0 /
+        // >=max boundary stop).
+        if ((Number(scrollTargetRef.current) || 0) !== before) {
+          st2.noMove = 0;
+        } else if (++st2.noMove >= 3) {
+          stopEdgeAutoscroll();
+        }
+      }, EDGE_AUTOSCROLL_INTERVAL_MS);
+      st.timer.unref?.();
+    };
+    // Finalize an in-flight drag exactly like the button-release path: push the
+    // final rect from the given point, and reconcile measured row heights. Used
+    // by the real release below AND by the ctrl+wheel zoom passthrough, whose
+    // mouse-tracking disable can swallow the release event entirely.
+    const finalizeActiveDrag = (fx, fy) => {
+      const drag = dragRef.current;
+      if (!drag.active) return;
+      stopEdgeAutoscroll();
+      const region = drag.region;
+      if (region === 'prompt') {
+        const offset = promptOffsetAt(fx, fy);
+        drag.active = false;
+        promptMouseSelectionRef.current?.extendTo?.(offset, true);
+        return;
+      }
+      const span = drag.anchorSpan;
+      const finalY = region === 'status' ? clampToStatusBand(fy) : clampToTranscriptViewport(fy);
+      drag.active = false;
+      if (span) {
+        const rect = buildSpanRect(span, fx, finalY, region, drag.anchorScroll);
+        applySelectionRect(rect);
+      } else {
+        const anchor = region === 'status'
+          ? drag.anchor
+          : selectionPointAtCurrentScroll(drag.anchor, drag.anchorScroll);
+        const rect = linearSelection(anchor, { x: fx, y: finalY });
+        const empty = rect.x1 === rect.x2 && rect.y1 === rect.y2;
+        if (empty) applySelectionRect(null);
+        else applySelectionRect(rect);
+      }
+      if (TRANSCRIPT_MEASURED_ROWS) setMeasuredRowsVersion((v) => (v + 1) % 1000000);
+    };
     // Typed 'mouse' channel handler. Receives one event per emit:
     //   • ParsedMouse {kind:'mouse',button,action,col,row,sequence} — click/drag
     //   • ParsedKey   {kind:'key',name:'wheelup'|'wheeldown',sequence} — wheel
@@ -193,6 +281,19 @@ export function useMouseInput({
         const wm = WHEEL_SGR.exec(seq);
         const ctrl = wm ? ((Number(wm[1]) & MOUSE_CTRL_MASK) !== 0) : false;
         if (ctrl) {
+          // Zoom passthrough disables mouse tracking for ~700ms, during which
+          // the button-release event may never arrive — leaving the drag stuck
+          // active and the edge-autoscroll interval firing forever. Finalize
+          // the in-flight drag from its last known point (same path as a real
+          // release: final applySelectionRect + measured-rows reconcile) so
+          // Ctrl+C still copies the full text, then hand the wheel to the
+          // terminal's font zoom. stopEdgeAutoscroll is folded into finalize.
+          if (dragRef.current.active) {
+            const last = dragRef.current.last || {};
+            finalizeActiveDrag(Number(last.x) || 0, Number(last.y) || 0);
+          } else {
+            stopEdgeAutoscroll();
+          }
           passthroughCtrlWheelZoom();
           return;
         }
@@ -201,9 +302,8 @@ export function useMouseInput({
         // Fall through to the wheel-scroll dispatch below (shared with the
         // previous SGR path) so slash-palette/overlay/scroll routing is identical.
         if (up !== 0 || down !== 0) {
-          if (dragRef.current.active) return;
           const palette = slashPaletteRef.current;
-          if (palette.open && palette.count > 0) {
+          if (!dragRef.current.active && palette.open && palette.count > 0) {
             const step = down - up;
             if (step !== 0) {
               setSlashIndex((index) => Math.max(0, Math.min(palette.count - 1, index + step)));
@@ -212,6 +312,11 @@ export function useMouseInput({
           }
           if (overlayBlocksGlobalTranscriptScroll(scrollFocusRef.current)) return;
           const STEP = 3; // rows per wheel notch; immediate updates feel steadier in Windows Terminal
+          // Wheel while a selection is live (mid-drag OR after release) scrolls
+          // the transcript instead of being dropped: scrollTranscriptRows'
+          // active-drag branch rebuilds the rect (anchor→last), the released
+          // branch shifts it — both keep the highlight and stitch-harvest the
+          // rows that scroll off (ref ScrollKeybindingHandler wheel path).
           queueScrollCoalesced((up - down) * STEP);
         }
         return;
@@ -229,7 +334,86 @@ export function useMouseInput({
         // (button & 3); MOUSE_MODIFIER_MASK above is scroll-routing-only and
         // deliberately treats shift as noise there.
         const shiftHeld = (button & MOUSE_SHIFT_MASK) !== 0;
+        const ctrlHeld = (button & MOUSE_CTRL_MASK) !== 0;
+        // WT reserves shift+mouse for its NATIVE selection and (per its docs)
+        // never forwards those events; keep this guard as a belt-and-braces so
+        // a future WT that starts forwarding them can never double-paint.
+        if (IS_WINDOWS_TERMINAL && shiftHeld) return;
+        // WT's native (shift+drag) selection overlay is NOT cleared by our
+        // incremental repaints — it would sit on top of the app selection as a
+        // second highlight. Any app-owned button press means the user is done
+        // with that native selection: force one full clear+rewrite frame
+        // (BSU/ESU-wrapped, no flash) which dismisses it before we paint ours.
+        if (IS_WINDOWS_TERMINAL && press && !isMotion) {
+          store.forceRenderRepaint?.();
+        }
+        // Ctrl+left-click is the app-side extend trigger (baseButton =
+        // button & 3 already maps ctrl+left press to button 0); right-button
+        // press is the second trigger (its own block below). This is
+        // unrelated to the ctrl+WHEEL zoom passthrough, which is handled in
+        // the wheel path and never reaches this button-press code.
+        const extendHeld = shiftHeld || ctrlHeld;
+        const isRightPress = baseButton === 2 && press && !isMotion;
+        if (isRightPress) {
+          // Right-button press = extend-click. Extends the existing selection in
+          // the pressed region using the SAME logic as the shift/ctrl paths, but
+          // ONLY when there is something extendable there; with nothing to extend
+          // it is ignored entirely (no selection clear, no drag start).
+          if (isInPromptBox(x, y)) {
+            const ctl = promptMouseSelectionRef.current;
+            if (ctl?.hasSelection?.()) {
+              applySelectionRect(null);
+              const offset = promptOffsetAt(x, y);
+              stopSmoothScroll();
+              // Right-click extend is a one-shot: apply immediately and leave the
+              // drag INACTIVE so the right-button release can't finalize (the
+              // generic !press branch is left-button-only anyway).
+              dragRef.current = { anchor: { x, y }, anchorScroll: 0, last: { x, y }, active: false, rect: null, region: 'prompt', anchorSpan: null };
+              if (offset != null) ctl.extendTo?.(offset, true);
+              lastClickRef.current = { x: -1, y: -1, t: 0 };
+            }
+            return;
+          }
+          const inTranscriptR = isInTranscriptViewport(y);
+          const inStatusR = !inTranscriptR && isInStatusBand(y);
+          if (!inTranscriptR && !inStatusR) return;
+          const regionR = inTranscriptR ? 'transcript' : 'status';
+          const nowR = Date.now();
+          if (dragRef.current.region === regionR && dragRef.current.anchorSpan) {
+            promptMouseSelectionRef.current?.clear?.();
+            const selectionY = regionR === 'status' ? clampToStatusBand(y) : clampToTranscriptViewport(y);
+            const span = dragRef.current.anchorSpan;
+            const rect = buildSpanRect(span, x, selectionY, regionR, dragRef.current.anchorScroll);
+            stopSmoothScroll();
+            dragRef.current = { ...dragRef.current, last: { x, y: selectionY }, active: false, region: regionR };
+            applySelectionRect(rect);
+            lastClickRef.current = { x, y, t: nowR, count: 1 };
+            return;
+          }
+          if (
+            dragRef.current.region === regionR
+            && !dragRef.current.anchorSpan
+            && dragRef.current.anchor
+            && dragRef.current.rect
+            && !(dragRef.current.rect.x1 === dragRef.current.rect.x2 && dragRef.current.rect.y1 === dragRef.current.rect.y2)
+          ) {
+            promptMouseSelectionRef.current?.clear?.();
+            const selectionY = regionR === 'status' ? clampToStatusBand(y) : clampToTranscriptViewport(y);
+            const anchor = regionR === 'status'
+              ? dragRef.current.anchor
+              : selectionPointAtCurrentScroll(dragRef.current.anchor, dragRef.current.anchorScroll);
+            const rect = linearSelection(anchor, { x, y: selectionY });
+            stopSmoothScroll();
+            dragRef.current = { ...dragRef.current, last: { x, y: selectionY }, active: false, region: regionR };
+            applySelectionRect(rect);
+            lastClickRef.current = { x, y, t: nowR, count: 1 };
+            return;
+          }
+          return;
+        }
         if (baseButton === 0 && press && !isMotion) {
+          // A fresh press ends any prior drag's held-at-edge auto-scroll.
+          stopEdgeAutoscroll();
           // Region router: a press decides which surface owns this selection.
           // Prompt box takes priority (it overlaps no transcript rows), then the
           // transcript viewport, then the bottom statusline band. A press
@@ -244,7 +428,7 @@ export function useMouseInput({
             // Shift+click extends the EXISTING prompt selection (anchor stays
             // put, cursor jumps to the click) instead of starting a fresh
             // zero-width anchor at the click point.
-            if (shiftHeld && ctl?.hasSelection?.()) {
+            if (extendHeld && ctl?.hasSelection?.()) {
               if (offset != null) ctl.extendTo?.(offset, true);
               lastClickRef.current = { x: -1, y: -1, t: 0 };
               return;
@@ -295,6 +479,28 @@ export function useMouseInput({
           // A press always clears the prompt-box selection (single active region).
           promptMouseSelectionRef.current?.clear?.();
           const now = Date.now();
+          // Shift+click on an existing word/line (anchorSpan) selection extends
+          // that selection by whole words/lines to the click point, preserving
+          // the original anchor span (mirrors selection.ts extendSelection).
+          if (
+            extendHeld
+            && dragRef.current.region === region
+            && dragRef.current.anchorSpan
+          ) {
+            const selectionY = region === 'status' ? clampToStatusBand(y) : clampToTranscriptViewport(y);
+            const span = dragRef.current.anchorSpan;
+            const rect = buildSpanRect(span, x, selectionY, region, dragRef.current.anchorScroll);
+            stopSmoothScroll();
+            dragRef.current = {
+              ...dragRef.current,
+              last: { x, y: selectionY },
+              active: true,
+              region,
+            };
+            applySelectionRect(rect);
+            lastClickRef.current = { x, y, t: now, count: 1 };
+            return;
+          }
           // Shift+click extends the existing ink-grid selection in this SAME
           // region from its original anchor to the new click point, instead of
           // starting a fresh anchor here. Only applies to a plain char-drag
@@ -302,7 +508,7 @@ export function useMouseInput({
           // anchorSpan or an empty/absent selection falls through to a normal
           // fresh press below.
           if (
-            shiftHeld
+            extendHeld
             && dragRef.current.region === region
             && !dragRef.current.anchorSpan
             && dragRef.current.anchor
@@ -432,55 +638,33 @@ export function useMouseInput({
             // scroll away the very rows being selected.
             if (y <= 1 && (y < prevDragY || y < top)) {
               queueScrollCoalesced(3);
+              startEdgeAutoscroll(1);
             } else if (y >= frameRows - 5 && (y > prevDragY || y > bottom)) {
               queueScrollCoalesced(-3);
+              startEdgeAutoscroll(-1);
+            } else {
+              // Pointer moved back inside the viewport (or along an edge row
+              // without pushing toward it): halt any held-at-edge auto-scroll.
+              stopEdgeAutoscroll();
             }
           }
-        } else if (!press && dragRef.current.active) {
-          const region = dragRef.current.region;
-          if (region === 'prompt') {
-            // Finalize the prompt selection; highlight persists (copy on Ctrl+C).
-            const offset = promptOffsetAt(x, y);
-            dragRef.current.active = false;
-            promptMouseSelectionRef.current?.extendTo?.(offset, true);
-            return;
-          }
+        } else if (!press && baseButton === 0 && dragRef.current.active) {
           // Button release while dragging: finalize with the release coordinate
           // (the SGR release event carries col/row) and keep the selection
           // visible. Copy is NOT automatic — the user presses Ctrl+C to copy.
-          // The highlight stays until ESC or a plain click.
-          const span = dragRef.current.anchorSpan;
-          const releaseY = region === 'status' ? clampToStatusBand(y) : clampToTranscriptViewport(y);
-          dragRef.current.active = false;
-          if (span) {
-            // Word/line multi-click release: finalize from the span to the
-            // word/line at the release cell. A release-without-motion resolves
-            // to the span itself (in-span target), so the original word/line
-            // highlight stays — never cleared as "empty" like a bare click.
-            const rect = buildSpanRect(span, x, releaseY, region, dragRef.current.anchorScroll);
-            applySelectionRect(rect);
-          } else {
-            const anchor = region === 'status'
-              ? dragRef.current.anchor
-              : selectionPointAtCurrentScroll(dragRef.current.anchor, dragRef.current.anchorScroll);
-            const rect = linearSelection(anchor, { x, y: releaseY });
-            const empty = rect.x1 === rect.x2 && rect.y1 === rect.y2;
-            if (empty) {
-              applySelectionRect(null); // a plain click clears any prior highlight
-            } else {
-              // Push the final rect so ink re-renders the visible selection.
-              applySelectionRect(rect);
-            }
-          }
-          // Drag is over: the measured-height harvest was skipped for every
-          // motion commit (see the harvest effect's dragRef guard), so force one
-          // re-measure now to reconcile any row whose true height drifted from
-          // its estimate while the drag was in flight.
-          if (TRANSCRIPT_MEASURED_ROWS) setMeasuredRowsVersion((v) => (v + 1) % 1000000);
+          // The highlight stays until ESC or a plain click. finalizeActiveDrag
+          // handles region routing (prompt/word-line/char), the empty→clear
+          // case, edge-autoscroll stop, and the measured-rows reconcile — same
+          // path the ctrl+wheel zoom passthrough uses. Guarded to baseButton 0
+          // so a stray right-button release never finalizes.
+          finalizeActiveDrag(x, y);
         }
       }
     };
     inkInput.on('mouse', onMouse);
-    return () => { inkInput.off('mouse', onMouse); };
+    return () => {
+      inkInput.off('mouse', onMouse);
+      stopEdgeAutoscroll();
+    };
   }, [inkInput, isRawModeSupported, store, passthroughCtrlWheelZoom, rows, scrollTranscriptRows, queueScrollCoalesced, applySelectionRect, applySelectionRectThrottled, selectionPointAtCurrentScroll, buildSpanRect]);
 }

package/src/tui/app/use-prompt-handlers.mjs

@@ -12,6 +12,7 @@
 import { useCallback } from 'react';
 import {
   readClipboardImageAttachment,
+  readClipboardText,
   readImageAttachmentFromPath,
   splitPastedImagePathCandidates,
 } from '../paste-attachments.mjs';
@@ -57,36 +58,24 @@ export function usePromptHandlers({
   const handlePromptPaste = useCallback((text, meta = {}) => {
     const source = String(meta?.source || 'paste');
     const value = String(text ?? '');
-    if (source === 'clipboard-image-shortcut' && !value) {
-      return readClipboardImageAttachment()
-        .then((image) => {
-          if (!image) {
-            showPromptHint('no image found on clipboard', 'plain');
-            return false;
-          }
-          const ref = registerPastedImage(image);
-          showPromptHint(`attached ${image.filename || 'clipboard image'}`, 'plain');
-          return ref;
-        })
-        .catch((e) => {
-          showPromptHint(`image paste failed: ${e?.message || e}`, 'warn');
-          return false;
-        });
-    }
-
-    const chunks = splitPastedImagePathCandidates(value);
-    const hasImagePath = chunks.some((chunk) => chunk.imagePath);
-    // No image paths in the paste: fold the whole text into a token when it is
-    // large, otherwise let PromptInput insert it raw (return undefined).
-    if (!hasImagePath) {
-      if (shouldFoldPastedText(value)) return registerPastedText(value);
-      return undefined;
-    }
-    // Mixed paste: resolve each image chunk to an image ref, then fold each
-    // CONTIGUOUS run of non-image text into its own token (only if over
-    // threshold) so content order around image refs is preserved. '\n'
-    // separator chunks are plain text and stay inside their surrounding run.
-    return Promise.all(chunks.map(async (chunk) => {
+    // Fold-or-insert text pipeline shared by bracketed paste and the Ctrl+V text
+    // path. returnRaw=true makes the "insert raw" case return the string itself
+    // (needed by the clipboard-text path, whose outer `text` is empty so the
+    // handleExternalPaste fallback would insert nothing).
+    const processText = (raw, returnRaw = false) => {
+      const chunks = splitPastedImagePathCandidates(raw);
+      const hasImagePath = chunks.some((chunk) => chunk.imagePath);
+      // No image paths: fold the whole text into a token when large, otherwise
+      // insert it raw (return undefined → PromptInput inserts, or the string).
+      if (!hasImagePath) {
+        if (shouldFoldPastedText(raw)) return registerPastedText(raw);
+        return returnRaw ? raw : undefined;
+      }
+      // Mixed paste: resolve each image chunk to an image ref, then fold each
+      // CONTIGUOUS run of non-image text into its own token (only if over
+      // threshold) so content order around image refs is preserved. '\n'
+      // separator chunks are plain text and stay inside their surrounding run.
+      return Promise.all(chunks.map(async (chunk) => {
       if (!chunk.imagePath) return chunk.text;
       try {
         const image = await readImageAttachmentFromPath(chunk.text, state.cwd || process.cwd());
@@ -117,6 +106,36 @@ export function usePromptHandlers({
       flushRun();
       return out;
     });
+    };
+
+    // Ctrl+V / Meta+V: opencode clipboard.read() model. Prefer OS-clipboard TEXT
+    // (routed through the SAME fold pipeline as bracketed paste); when the
+    // clipboard holds no text, fall back to the image-attachment path. The async
+    // read result is applied by handleExternalPaste under its pasteGeneration
+    // staleness guard, so a stale resolve is dropped.
+    if (source === 'clipboard-shortcut' && !value) {
+      return readClipboardText()
+        .then((clip) => {
+          const normalized = String(clip ?? '').replace(/\r\n?/g, '\n');
+          if (normalized) return processText(normalized, true);
+          return readClipboardImageAttachment()
+            .then((image) => {
+              if (!image) {
+                showPromptHint('no text or image found on clipboard', 'plain');
+                return false;
+              }
+              const ref = registerPastedImage(image);
+              showPromptHint(`attached ${image.filename || 'clipboard image'}`, 'plain');
+              return ref;
+            });
+        })
+        .catch((e) => {
+          showPromptHint(`paste failed: ${e?.message || e}`, 'warn');
+          return false;
+        });
+    }
+
+    return processText(value);
   }, [registerPastedImage, registerPastedText, showPromptHint, state.cwd]);
 
   const handlePromptHistoryNavigate = useCallback((direction, currentText = '', meta = {}) => {