muxr 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ab53a383e7781f83ff106e503047cf5952b12193d0d65e2b29631f2beda6bcf5
-  data.tar.gz: 0fcef17549ae1745d76fe530a97f12740c9556704bbe724f1b4690932c7cabc5
+  metadata.gz: d19432b15ff535a2ce8f4bfb5b759ddd3599b4fb0af949d7871cf1059497c483
+  data.tar.gz: ce58f726a5a9dc186deb042c0d0e31fa8694676d0cdb4c496cfb57668d5fd4c1
 SHA512:
-  metadata.gz: 4440cb89e4295407dce42ca26c474c64441ff556cb285769b085e0474448132085d9bb6ad9af91699e6349a915c90fe6ebd33825d7ee68f315cafc26ccac5244
-  data.tar.gz: e17c2f092dcd76ca617bfbfd6acdf1e5475ea9fd7afe0a7458539af95eaa32b0282d499a094f19a6887b6fd228f03d470d5a8c6b9b167b9838e6989edd20ee74
+  metadata.gz: 5b96c66aa1b96e853e7d268c012f8bc5e62fdf77c1e3d4e89360b764d4cfc1d20bdb271be81acad05f26417d09e17fe27f437680cb00a33fcf6f2c934600fef2
+  data.tar.gz: '045758a0d3ec1e4f2d6bfe4bb887743cc2ab80310bd842190b362e9a9976fd023b8818c35d13f80478839bbbb12d91372b22ddabc91ee430afda8c3ce3b0853a'

data/CHANGELOG.md

@@ -6,6 +6,30 @@ follow [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.1.3] - 2026-05-11
+
+### Fixed
+- Large pastes into a pane no longer hang the server. PTY writes are now
+  non-blocking and buffered per pane, with the writer fd added to the
+  event loop's `IO.select` write set so back-pressure from a slow reader
+  (e.g. Claude Code processing a multi-KB paste) can't deadlock the
+  single-threaded server. Idle pass-through input is also batched into a
+  single `send_to_focused` chunk instead of one call per byte.
+- Client↔server socket writes are now non-blocking too, with per-side
+  outgoing buffers and the socket added to `IO.select`'s write set when
+  there's queued data. The previous blocking `Protocol.write` could
+  deadlock both ends when a paste produced enough redraw traffic to fill
+  both directions of the unix-socket kernel buffer at once (vim and
+  Claude Code both reproduced this).
+
+### Added
+- Enable bracketed paste mode (`\e[?2004h`) on the outer terminal when
+  the client attaches. The terminal emulator now wraps pastes with
+  `\e[200~...\e[201~`, those markers flow through muxr to the focused
+  pane, and apps that opt in (Claude Code, vim, modern readline) again
+  recognise the input as a paste — Claude Code collapses it to
+  `[Pasted text +N lines]` instead of typing the whole thing out.
+
 ## [0.1.2] - 2026-05-11
 
 ### Added

data/lib/muxr/application.rb

@@ -57,6 +57,7 @@ module Muxr
       @help_visible = false
       @next_pane_id = 0
       @current_client = nil
+      @client_write_buffer = +"".b
       @listening_socket = nil
       @socket_path = self.class.socket_path_for(@session_name)
       @paste_buffer = +""
@@ -401,12 +402,29 @@ module Muxr
       end
     end
 
-    # Called by the FramedOutput adapter; ships one OUTPUT frame to the
-    # currently attached client. No-op when nobody is attached.
+    # Called by the FramedOutput adapter; queues one OUTPUT frame to the
+    # currently attached client and tries to push as much as the socket
+    # will take without blocking. Anything left over stays in
+    # @client_write_buffer and gets flushed by the event loop when the
+    # socket reports writable. This prevents a slow client (or slow
+    # terminal upstream of the client) from deadlocking the server when
+    # the server is also trying to read from that same client.
     def deliver_output(bytes)
-      sock = @current_client
-      return unless sock
-      Protocol.write(sock, Protocol::OUTPUT, bytes)
+      return unless @current_client
+      @client_write_buffer << Protocol.frame(Protocol::OUTPUT, bytes)
+      drain_client_writes
+    end
+
+    def drain_client_writes
+      return unless @current_client
+      return if @client_write_buffer.empty?
+      loop do
+        n = @current_client.write_nonblock(@client_write_buffer)
+        @client_write_buffer = @client_write_buffer.byteslice(n..-1) || +"".b
+        break if @client_write_buffer.empty?
+      end
+    rescue IO::WaitWritable
+      # Socket send buffer is full; the rest stays queued.
     rescue Errno::EPIPE, Errno::ECONNRESET, IOError
       drop_client_silently
     end
@@ -479,25 +497,40 @@ module Muxr
 
     def loop_forever
       while @running
-        ready_ios = [@listening_socket]
-        ready_ios << @current_client if @current_client
-        @session.window.panes.each { |p| ready_ios << p.io if p.alive? }
-        if @session.drawer&.pane && @session.drawer.pane.alive?
-          ready_ios << @session.drawer.pane.io
+        read_ios  = [@listening_socket]
+        read_ios << @current_client if @current_client
+        @session.window.panes.each { |p| read_ios << p.io if p.alive? }
+        drawer_pane = @session.drawer&.pane
+        read_ios << drawer_pane.io if drawer_pane&.alive?
+
+        write_ios = []
+        @session.window.panes.each do |p|
+          write_ios << p.writer_io if p.alive? && p.pending_write?
+        end
+        if drawer_pane&.alive? && drawer_pane.pending_write?
+          write_ios << drawer_pane.writer_io
         end
+        write_ios << @current_client if @current_client && !@client_write_buffer.empty?
 
         timeout = @message ? 0.25 : SELECT_TIMEOUT
-        ready, = IO.select(ready_ios, nil, nil, timeout)
-
-        if ready
-          ready.each do |io|
-            if io == @listening_socket
-              accept_client
-            elsif io == @current_client
-              consume_client_frame
-            else
-              consume_pane_io(io)
-            end
+        ready_r, ready_w, = IO.select(read_ios, write_ios, nil, timeout)
+
+        ready_r&.each do |io|
+          if io == @listening_socket
+            accept_client
+          elsif io == @current_client
+            consume_client_frame
+          else
+            consume_pane_io(io)
+          end
+        end
+
+        ready_w&.each do |io|
+          if io == @current_client
+            drain_client_writes
+          else
+            pane = pane_for_writer_io(io)
+            pane&.drain_writes
           end
         end
 
@@ -579,6 +612,13 @@ module Muxr
       nil
     end
 
+    def pane_for_writer_io(io)
+      pane = @session.window.panes.find { |p| p.writer_io == io }
+      return pane if pane
+      return @session.drawer.pane if @session.drawer&.pane && @session.drawer.pane.writer_io == io
+      nil
+    end
+
     def prune_dead_panes
       dead = @session.window.panes.reject(&:alive?)
       return if dead.empty?
@@ -612,6 +652,11 @@ module Muxr
 
     def disconnect_client(reason: nil)
       return unless @current_client
+      # Best-effort: drop any queued OUTPUT (the client is going away),
+      # send a final BYE, then close. BYE is small enough that one
+      # blocking write won't meaningfully wedge anything even if the
+      # client's recv is sluggish.
+      @client_write_buffer = +"".b
       safe_protocol_write(@current_client, Protocol::BYE, reason || "")
       @current_client.close rescue nil
       @current_client = nil
@@ -621,6 +666,7 @@ module Muxr
       return unless @current_client
       @current_client.close rescue nil
       @current_client = nil
+      @client_write_buffer = +"".b
     end
 
     def safe_protocol_write(io, type, payload = "")

data/lib/muxr/client.rb

@@ -24,6 +24,7 @@ module Muxr
       @resize_pending = false
       @exit_code = 0
       @bye_reason = nil
+      @write_buffer = +"".b
     end
 
     # Opens the socket. Returns true on success. Raises Errno::ENOENT /
@@ -62,28 +63,55 @@ module Muxr
           send_resize
         end
 
-        ready, = IO.select([STDIN, @sock], nil, nil, SELECT_TIMEOUT)
-        next unless ready
+        write_ios = @write_buffer.empty? ? nil : [@sock]
+        ready_r, ready_w, = IO.select([STDIN, @sock], write_ios, nil, SELECT_TIMEOUT)
+        next unless ready_r || ready_w
 
-        ready.each do |io|
+        ready_r&.each do |io|
           if io == STDIN
             forward_stdin
           else
             consume_server_frame
           end
         end
+
+        drain_writes if ready_w&.include?(@sock)
       end
     end
 
     def forward_stdin
       data = STDIN.read_nonblock(4096)
-      Protocol.write(@sock, Protocol::INPUT, data)
+      queue_frame(Protocol::INPUT, data)
     rescue IO::WaitReadable
       # spurious wake-up; nothing to do.
     rescue EOFError, Errno::EPIPE, Errno::ECONNRESET, IOError
       @running = false
     end
 
+    def queue_frame(type, payload)
+      @write_buffer << Protocol.frame(type, payload)
+      drain_writes
+    end
+
+    # Push as much of @write_buffer to the server as the socket will
+    # accept without blocking. Anything left over stays queued and the
+    # event loop picks it back up when select reports the socket
+    # writable. Mirrors the server-side OUTPUT drain — without it, a
+    # busy server (rendering large vim/Claude-code redraws) could fill
+    # this socket's send buffer and wedge the client mid-paste.
+    def drain_writes
+      return if @write_buffer.empty?
+      loop do
+        n = @sock.write_nonblock(@write_buffer)
+        @write_buffer = @write_buffer.byteslice(n..-1) || +"".b
+        break if @write_buffer.empty?
+      end
+    rescue IO::WaitWritable
+      # Socket send buffer full; remainder stays queued.
+    rescue Errno::EPIPE, Errno::ECONNRESET, IOError
+      @running = false
+    end
+
     def consume_server_frame
       type, payload = Protocol.read(@sock)
       if type.nil?
@@ -106,7 +134,7 @@ module Muxr
 
     def send_resize
       rows, cols = terminal_size
-      Protocol.write(@sock, Protocol::RESIZE, Protocol.encode_size(rows, cols))
+      queue_frame(Protocol::RESIZE, Protocol.encode_size(rows, cols))
     rescue Errno::EPIPE, Errno::ECONNRESET, IOError
       @running = false
     end
@@ -124,12 +152,17 @@ module Muxr
     def enter_terminal_mode
       STDIN.raw!
       STDIN.echo = false
-      STDOUT.write("\e[?1049h\e[?25l\e[2J\e[H\e[0m")
+      # Enable bracketed paste on the outer terminal so iTerm/Terminal/etc.
+      # wrap pastes with \e[200~...\e[201~. Those markers flow through
+      # untouched to the focused pane's PTY, which lets Claude Code, vim,
+      # modern bash, etc. recognise the input as a paste and collapse it
+      # instead of typing it out character-by-character.
+      STDOUT.write("\e[?1049h\e[?25l\e[2J\e[H\e[0m\e[?2004h")
       STDOUT.flush
     end
 
     def leave_terminal_mode
-      STDOUT.write("\e[0m\e[?25h\e[?1049l")
+      STDOUT.write("\e[?2004l\e[0m\e[?25h\e[?1049l")
       STDOUT.flush
       begin
         STDIN.cooked!

data/lib/muxr/input_handler.rb

@@ -85,19 +85,32 @@ module Muxr
     end
 
     def feed(data)
-      data.each_char do |ch|
+      remaining = data
+      until remaining.empty?
+        if @state == :idle
+          # Fast path for pass-through: forward everything up to the next
+          # Ctrl-a as a single chunk so a large paste doesn't turn into one
+          # PTY write per byte. PREFIX is single-byte ASCII (\x01) and never
+          # appears mid-UTF-8, so byte/char index match.
+          idx = remaining.index(PREFIX)
+          if idx.nil?
+            @app.send_to_focused(remaining)
+            return
+          end
+          @app.send_to_focused(remaining[0...idx]) if idx > 0
+          @state = :prefix
+          remaining = remaining[(idx + 1)..] || ""
+          next
+        end
+
+        ch = remaining[0]
+        remaining = remaining[1..] || ""
         case @state
         when :help
           @app.dismiss_help
           @state = :idle
         when :confirm_quit
           handle_confirm_quit(ch)
-        when :idle
-          if ch == PREFIX
-            @state = :prefix
-          else
-            @app.send_to_focused(ch)
-          end
         when :prefix
           handle_prefix(ch)
         when :command

data/lib/muxr/pane.rb

@@ -20,6 +20,18 @@ module Muxr
       @process.io
     end
 
+    def writer_io
+      @process.writer_io
+    end
+
+    def pending_write?
+      @process.pending_write?
+    end
+
+    def drain_writes
+      @process.drain
+    end
+
     def write(data)
       @process.write(data)
     end

data/lib/muxr/protocol.rb

@@ -39,9 +39,20 @@ module Muxr
 
     # Writes one framed message. +payload+ is treated as raw bytes (binary).
     def self.write(io, type, payload = "")
+      io.write(frame(type, payload))
+    end
+
+    # Builds the on-the-wire bytes for a single frame without writing them.
+    # Lets callers append to an outgoing buffer (for non-blocking flushes
+    # later) instead of doing a synchronous io.write.
+    def self.frame(type, payload = "")
       raise ArgumentError, "type must be a single byte" unless type.is_a?(String) && type.bytesize == 1
       bytes = payload.to_s.b
-      io.write(type + [bytes.bytesize].pack("N") + bytes)
+      buf = +"".b
+      buf << type.b
+      buf << [bytes.bytesize].pack("N")
+      buf << bytes
+      buf
     end
 
     # Encodes a "ROWS COLS" string for HELLO / RESIZE payloads.

data/lib/muxr/pty_process.rb

@@ -10,6 +10,7 @@ module Muxr
       @rows = rows
       @cols = cols
       @exited = false
+      @write_buffer = +"".b
 
       shell = command || ENV["SHELL"] || "/bin/sh"
       env = ENV.to_h.merge("TERM" => "xterm-256color").merge(env_overrides)
@@ -23,11 +24,42 @@ module Muxr
       resize(rows, cols)
     end
 
+    # Appends bytes to the per-process outgoing buffer and tries to flush as
+    # many as the PTY will accept right now. Any remainder stays buffered;
+    # the event loop drains it later when the writer fd is reported writable.
+    # This avoids deadlocking the single-threaded server when the inner
+    # program is slow to read (large pastes were the original motivating
+    # case — see CHANGELOG 0.1.3).
     def write(data)
-      @writer.write(data)
-      @writer.flush
+      return if @exited
+      return if data.nil? || data.empty?
+      @write_buffer << data.b
+      drain
+    end
+
+    # Push as much of @write_buffer through the PTY as it'll take without
+    # blocking. Safe to call repeatedly — both from write() and from the
+    # event loop when select reports the writer fd writable.
+    def drain
+      return if @exited || @write_buffer.empty?
+      loop do
+        n = @writer.write_nonblock(@write_buffer)
+        @write_buffer = @write_buffer.byteslice(n..-1) || +"".b
+        break if @write_buffer.empty?
+      end
+    rescue IO::WaitWritable
+      # Kernel buffer full; the rest stays queued.
     rescue Errno::EIO, IOError, Errno::EPIPE
       @exited = true
+      @write_buffer.clear
+    end
+
+    def pending_write?
+      !@write_buffer.empty?
+    end
+
+    def writer_io
+      @writer
     end
 
     def read_nonblock(max = 8192)

data/lib/muxr/version.rb

@@ -1,3 +1,3 @@
 module Muxr
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: muxr
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Roel Bondoc