muxr 0.1.0

data/lib/muxr/client.rb

@@ -0,0 +1,145 @@
+require "socket"
+require "io/console"
+
+module Muxr
+  # The muxr client. It is a small front-end whose only jobs are:
+  #   1. Connect to the server's Unix socket and send HELLO with the
+  #      terminal's current size.
+  #   2. Put the controlling TTY into the alt screen + raw mode.
+  #   3. Forward every STDIN read as an INPUT frame.
+  #   4. Write every OUTPUT frame payload straight to STDOUT.
+  #   5. Send RESIZE on SIGWINCH; exit cleanly on BYE / server EOF.
+  #
+  # The client owns no Session, no PTYs, and no Renderer — that all lives in
+  # the server process. This is the piece that comes and goes during detach
+  # / reattach.
+  class Client
+    SELECT_TIMEOUT = 0.1
+
+    def initialize(session_name)
+      @session_name = session_name
+      @socket_path = Application.socket_path_for(session_name)
+      @sock = nil
+      @running = false
+      @resize_pending = false
+      @exit_code = 0
+      @bye_reason = nil
+    end
+
+    # Opens the socket. Returns true on success. Raises Errno::ENOENT /
+    # Errno::ECONNREFUSED to the caller, which is bin/muxr's job to handle by
+    # spawning a server.
+    def connect
+      @sock = UNIXSocket.new(@socket_path)
+      rows, cols = terminal_size
+      Protocol.write(@sock, Protocol::HELLO, Protocol.encode_size(rows, cols))
+      true
+    end
+
+    def run
+      raise "must call #connect first" unless @sock
+
+      enter_terminal_mode
+      install_winch_trap
+      @running = true
+
+      begin
+        loop_forever
+      ensure
+        leave_terminal_mode
+        @sock.close rescue nil
+      end
+
+      @exit_code
+    end
+
+    private
+
+    def loop_forever
+      while @running
+        if @resize_pending
+          @resize_pending = false
+          send_resize
+        end
+
+        ready, = IO.select([STDIN, @sock], nil, nil, SELECT_TIMEOUT)
+        next unless ready
+
+        ready.each do |io|
+          if io == STDIN
+            forward_stdin
+          else
+            consume_server_frame
+          end
+        end
+      end
+    end
+
+    def forward_stdin
+      data = STDIN.read_nonblock(4096)
+      Protocol.write(@sock, Protocol::INPUT, data)
+    rescue IO::WaitReadable
+      # spurious wake-up; nothing to do.
+    rescue EOFError, Errno::EPIPE, Errno::ECONNRESET, IOError
+      @running = false
+    end
+
+    def consume_server_frame
+      type, payload = Protocol.read(@sock)
+      if type.nil?
+        @running = false
+        @bye_reason ||= "server closed connection"
+        return
+      end
+
+      case type
+      when Protocol::OUTPUT
+        STDOUT.write(payload)
+        STDOUT.flush
+      when Protocol::BYE
+        @bye_reason = payload.to_s
+        @running = false
+      else
+        # Unknown frame type; ignore.
+      end
+    end
+
+    def send_resize
+      rows, cols = terminal_size
+      Protocol.write(@sock, Protocol::RESIZE, Protocol.encode_size(rows, cols))
+    rescue Errno::EPIPE, Errno::ECONNRESET, IOError
+      @running = false
+    end
+
+    def terminal_size
+      IO.console.winsize
+    rescue StandardError
+      [24, 80]
+    end
+
+    def install_winch_trap
+      Signal.trap("WINCH") { @resize_pending = true }
+    end
+
+    def enter_terminal_mode
+      STDIN.raw!
+      STDIN.echo = false
+      STDOUT.write("\e[?1049h\e[?25l\e[2J\e[H\e[0m")
+      STDOUT.flush
+    end
+
+    def leave_terminal_mode
+      STDOUT.write("\e[0m\e[?25h\e[?1049l")
+      STDOUT.flush
+      begin
+        STDIN.cooked!
+        STDIN.echo = true
+      rescue StandardError
+        # terminal may have already been reset by a signal handler.
+      end
+      if @bye_reason && !@bye_reason.empty? && @bye_reason != "detached"
+        $stderr.puts "muxr: #{@bye_reason}"
+      end
+    end
+  end
+end

data/lib/muxr/command_dispatcher.rb

@@ -0,0 +1,65 @@
+module Muxr
+  # Parses ":"-prefixed commands typed at the command prompt and routes them
+  # to the Application. Unknown commands result in a flashed status message
+  # rather than a hard error so the user never gets dropped out of the
+  # multiplexer for a typo.
+  class CommandDispatcher
+    def initialize(app)
+      @app = app
+    end
+
+    def dispatch(line)
+      parts = line.to_s.strip.split(/\s+/)
+      return if parts.empty?
+
+      cmd, *args = parts
+      case cmd
+      when "layout"  then handle_layout(args)
+      when "drawer"  then handle_drawer(args)
+      when "save"    then @app.save_session
+      when "restore" then @app.restore_session
+      when "sessions", "ls" then @app.list_sessions
+      when "quit", "q", "exit"
+        @app.quit
+      when "new", "c"
+        @app.new_pane
+      when "close", "kill", "k"
+        @app.close_focused
+      when "next"    then @app.focus_next
+      when "prev"    then @app.focus_prev
+      when "master"  then @app.promote_master
+      when "help"    then @app.show_help
+      when "detach"  then @app.detach
+      else
+        @app.flash("unknown command: #{cmd}")
+      end
+    end
+
+    private
+
+    def handle_layout(args)
+      name = args[0]
+      if name.nil?
+        @app.cycle_layout
+        return
+      end
+      sym = name.to_sym
+      if Window::LAYOUTS.include?(sym)
+        @app.session.window.set_layout(sym)
+        @app.invalidate
+      else
+        @app.flash("unknown layout: #{name}")
+      end
+    end
+
+    def handle_drawer(args)
+      case args[0]
+      when nil, "toggle" then @app.toggle_drawer
+      when "show"        then @app.show_drawer
+      when "hide"        then @app.hide_drawer
+      when "reset"       then @app.reset_drawer
+      else                    @app.flash("drawer: #{args[0]}?")
+      end
+    end
+  end
+end

data/lib/muxr/drawer.rb

@@ -0,0 +1,44 @@
+module Muxr
+  # A Drawer is a single persistent overlay pane, rendered on top of the tiled
+  # layout. Toggling visibility never tears down the underlying PTY — the
+  # drawer's shell process and scrollback survive across hide/show.
+  #
+  # The actual Pane is injected (rather than constructed here) so tests can
+  # exercise the visibility/state machine without spawning real shells.
+  class Drawer
+    attr_accessor :pane, :visible
+    attr_reader :origin_cwd
+
+    def initialize(pane: nil, origin_cwd: nil)
+      @pane = pane
+      @visible = false
+      @origin_cwd = origin_cwd
+    end
+
+    def visible?
+      @visible
+    end
+
+    def show!
+      @visible = true
+    end
+
+    def hide!
+      @visible = false
+    end
+
+    def toggle!
+      @visible = !@visible
+    end
+
+    def cwd
+      pane&.cwd || @origin_cwd
+    end
+
+    def close
+      @pane&.close
+      @pane = nil
+      @visible = false
+    end
+  end
+end

data/lib/muxr/input_handler.rb

@@ -0,0 +1,218 @@
+module Muxr
+  # Translates raw keystrokes into either commands (when the Ctrl-a prefix is
+  # active) or passthrough bytes to the focused pane. The handler is a small
+  # state machine: :idle → :prefix → :idle, with a separate :command branch
+  # for the ":"-driven mini-command line.
+  class InputHandler
+    PREFIX = "\x01".freeze # Ctrl-a
+
+    PREFIX_BINDINGS = {
+      "c"    => :new_pane,
+      "n"    => :focus_next,
+      "p"    => :focus_prev,
+      "a"    => :focus_last,
+      "k"    => :close_focused,
+      "\t"   => :cycle_layout,
+      "\r"   => :promote_master,
+      "\n"   => :promote_master,
+      "~"    => :toggle_drawer,
+      "d"    => :detach,
+      "?"    => :show_help,
+      "q"    => :quit_immediate,
+      "["    => :enter_scrollback,
+      "]"    => :paste_from_buffer
+    }.freeze
+
+    SCROLLBACK_BINDINGS = {
+      "j"    => :line_forward,
+      "k"    => :line_back,
+      "\x04" => :half_forward, # Ctrl-d
+      "\x15" => :half_back,    # Ctrl-u
+      "d"    => :half_forward,
+      "u"    => :half_back,
+      "\x06" => :full_forward, # Ctrl-f
+      "\x02" => :full_back,    # Ctrl-b
+      "f"    => :full_forward,
+      "b"    => :full_back,
+      " "    => :full_forward,
+      "g"    => :top,
+      "G"    => :bottom
+    }.freeze
+
+    SCROLLBACK_EXITS = ["q", "\e", "\x03"].freeze # q, Esc, Ctrl-c
+
+    SELECTION_BINDINGS = {
+      "h"    => :left,
+      "l"    => :right,
+      "j"    => :down,
+      "k"    => :up,
+      "0"    => :line_start,
+      "$"    => :line_end,
+      "g"    => :top,
+      "G"    => :bottom,
+      "\x04" => :half_down, # Ctrl-d
+      "\x15" => :half_up,   # Ctrl-u
+      "d"    => :half_down,
+      "u"    => :half_up,
+      "\x06" => :full_down, # Ctrl-f
+      "\x02" => :full_up,   # Ctrl-b
+      "f"    => :full_down,
+      "b"    => :full_up,
+      " "    => :full_down
+    }.freeze
+
+    SELECTION_YANK = ["\r", "\n", "y"].freeze
+    SELECTION_CANCEL = ["q", "\e", "\x03"].freeze # q, Esc, Ctrl-c
+
+    DIGIT_RE = /\A[1-9]\z/.freeze
+
+    attr_reader :state, :command_buffer
+
+    def initialize(app)
+      @app = app
+      @state = :idle
+      @command_buffer = +""
+    end
+
+    def feed(data)
+      data.each_char do |ch|
+        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
+          handle_command_input(ch)
+        when :scrollback
+          handle_scrollback_input(ch)
+        when :selection
+          handle_selection_input(ch)
+        end
+      end
+    end
+
+    def enter_help_mode
+      @state = :help
+    end
+
+    def enter_confirm_quit
+      @state = :confirm_quit
+    end
+
+    def enter_scrollback_mode
+      @state = :scrollback
+    end
+
+    def enter_selection_mode
+      @state = :selection
+    end
+
+    def enter_idle_mode
+      @state = :idle
+    end
+
+    def cancel
+      @state = :idle
+      @command_buffer = +""
+    end
+
+    private
+
+    def handle_prefix(ch)
+      action = PREFIX_BINDINGS[ch]
+      case
+      when ch == ":"
+        @state = :command
+        @command_buffer = +""
+      when ch == PREFIX
+        @app.send_to_focused(PREFIX)
+        @state = :idle
+      when DIGIT_RE.match?(ch)
+        @app.focus_pane_number(ch.to_i)
+        @state = :idle
+      when action
+        @app.public_send(action)
+        @state = :idle if @state == :prefix
+      else
+        # Unknown prefix-key: return to idle silently.
+        @state = :idle
+      end
+    end
+
+    def handle_confirm_quit(ch)
+      @state = :idle
+      if ch == "y" || ch == "Y"
+        @app.confirm_quit
+      else
+        @app.cancel_quit
+      end
+    end
+
+    def handle_scrollback_input(ch)
+      if SCROLLBACK_EXITS.include?(ch)
+        @state = :idle
+        @app.exit_scrollback
+        return
+      end
+      if ch == "v"
+        @app.enter_selection
+        return
+      end
+      action = SCROLLBACK_BINDINGS[ch]
+      @app.scroll_focused(action) if action
+      # Unknown keys: ignored. Avoids accidental shell input when the user
+      # mistypes inside scrollback mode.
+    end
+
+    def handle_selection_input(ch)
+      if SELECTION_YANK.include?(ch)
+        @app.exit_selection(yank: true)
+        return
+      end
+      if SELECTION_CANCEL.include?(ch)
+        @app.exit_selection(yank: false)
+        return
+      end
+      case ch
+      when "v"
+        @app.toggle_selection(:linear)
+        return
+      when "\x16" # Ctrl-v
+        @app.toggle_selection(:block)
+        return
+      end
+      action = SELECTION_BINDINGS[ch]
+      @app.move_selection(action) if action
+      # Unknown keys ignored — same rationale as scrollback mode.
+    end
+
+    def handle_command_input(ch)
+      case ch
+      when "\r", "\n"
+        cmd = @command_buffer.dup
+        @command_buffer = +""
+        @state = :idle
+        @app.run_command(cmd)
+      when "\e"
+        @command_buffer = +""
+        @state = :idle
+        @app.invalidate
+      when "\x7f", "\b"
+        @command_buffer.chop!
+        @app.invalidate
+      else
+        @command_buffer << ch if ch.ord >= 0x20
+        @app.invalidate
+      end
+    end
+  end
+end

data/lib/muxr/layout_manager.rb

@@ -0,0 +1,91 @@
+module Muxr
+  # Pure functions that turn (layout_name, pane_count, screen_rect) into an
+  # array of pane rectangles. No mutable state; safe to call repeatedly on
+  # every render. Following xmonad, layouts decide geometry — users never
+  # resize panes by hand.
+  module LayoutManager
+    Rect = Struct.new(:x, :y, :w, :h) do
+      def to_a
+        [x, y, w, h]
+      end
+    end
+
+    LAYOUTS = %i[tall grid monocle].freeze
+
+    module_function
+
+    def compute(layout, count, area, focused_index: 0, master_index: 0)
+      return [] if count <= 0
+      master_index = master_index.clamp(0, count - 1)
+      focused_index = focused_index.clamp(0, count - 1)
+      case layout
+      when :tall    then tall(count, area, master_index)
+      when :grid    then grid(count, area)
+      when :monocle then monocle(count, area, focused_index)
+      else
+        raise ArgumentError, "Unknown layout: #{layout.inspect}"
+      end
+    end
+
+    # Master pane on the left taking half the width; remaining panes stack
+    # vertically on the right, dividing the remaining height evenly.
+    def tall(count, area, master_index = 0)
+      master_index = master_index.clamp(0, count - 1)
+      return [Rect.new(area.x, area.y, area.w, area.h)] if count == 1
+
+      master_w = [area.w / 2, 1].max
+      stack_w  = [area.w - master_w, 1].max
+      others   = (0...count).to_a - [master_index]
+      slave_count = others.length
+      base_h = area.h / slave_count
+      remainder = area.h - base_h * slave_count
+
+      rects = Array.new(count)
+      rects[master_index] = Rect.new(area.x, area.y, master_w, area.h)
+
+      y = area.y
+      others.each_with_index do |idx, i|
+        h = base_h + (i < remainder ? 1 : 0)
+        rects[idx] = Rect.new(area.x + master_w, y, stack_w, h)
+        y += h
+      end
+      rects
+    end
+
+    # Roughly square grid. Each row stretches its panes to fill the full width
+    # so an underfull bottom row doesn't leave gaps.
+    def grid(count, area)
+      cols_per_row = Math.sqrt(count).ceil
+      rows = (count.to_f / cols_per_row).ceil
+
+      base_h = area.h / rows
+      h_rem  = area.h - base_h * rows
+
+      rects = []
+      idx = 0
+      y = area.y
+      rows.times do |r|
+        remaining = count - idx
+        in_row = [cols_per_row, remaining].min
+        row_h = base_h + (r < h_rem ? 1 : 0)
+        col_w = area.w / in_row
+        w_rem = area.w - col_w * in_row
+        x = area.x
+        in_row.times do |c|
+          w = col_w + (c < w_rem ? 1 : 0)
+          rects << Rect.new(x, y, w, row_h)
+          x += w
+          idx += 1
+        end
+        y += row_h
+      end
+      rects
+    end
+
+    # All panes occupy the full area; the focused pane is the one drawn last
+    # (the Renderer is responsible for the z-order).
+    def monocle(count, area, _focused_index = 0)
+      Array.new(count) { Rect.new(area.x, area.y, area.w, area.h) }
+    end
+  end
+end

data/lib/muxr/pane.rb

@@ -0,0 +1,52 @@
+module Muxr
+  # A Pane bundles a Terminal emulator buffer with the PTYProcess running the
+  # shell that feeds it. The Window keeps a list of panes; the Renderer asks
+  # each pane for its current grid contents and cursor position.
+  class Pane
+    attr_reader :id, :terminal, :process
+    attr_accessor :rect
+
+    def initialize(id:, rows: 24, cols: 80, cwd: nil, command: nil, process: nil)
+      @id = id
+      @rows = rows
+      @cols = cols
+      @terminal = Terminal.new(rows: rows, cols: cols)
+      @process = process || PTYProcess.new(rows: rows, cols: cols, cwd: cwd, command: command)
+      @rect = nil
+      @initial_cwd = cwd || @process.cwd
+    end
+
+    def io
+      @process.io
+    end
+
+    def write(data)
+      @process.write(data)
+    end
+
+    def read_from_pty
+      data = @process.read_nonblock
+      return nil unless data
+      @terminal.feed(data)
+      data
+    end
+
+    def resize(rows, cols)
+      return if rows == @terminal.rows && cols == @terminal.cols
+      @terminal.resize(rows, cols)
+      @process.resize(rows, cols)
+    end
+
+    def alive?
+      @process.alive?
+    end
+
+    def cwd
+      @process.cwd || @initial_cwd
+    end
+
+    def close
+      @process.close
+    end
+  end
+end

data/lib/muxr/protocol.rb

@@ -0,0 +1,73 @@
+module Muxr
+  # Length-prefixed framing for client <-> server messages over a Unix socket.
+  #
+  # Wire format per message:
+  #   [1 byte type][4 bytes BE length][length bytes payload]
+  #
+  # Types are single ASCII letters so they're easy to recognise in tcpdump or
+  # hex dumps:
+  #   H  hello   (client -> server, payload: "ROWS COLS")
+  #   I  input   (client -> server, payload: raw STDIN bytes)
+  #   R  resize  (client -> server, payload: "ROWS COLS")
+  #   B  bye     (either way, payload: optional reason string)
+  #   O  output  (server -> client, payload: raw bytes to write to STDOUT)
+  module Protocol
+    HELLO  = "H".freeze
+    INPUT  = "I".freeze
+    RESIZE = "R".freeze
+    BYE    = "B".freeze
+    OUTPUT = "O".freeze
+
+    HEADER_SIZE = 5
+
+    # Reads exactly one framed message from +io+. Returns [type, payload] or
+    # nil on EOF / truncated frame. Blocks until the full message arrives.
+    def self.read(io)
+      header = read_exact(io, HEADER_SIZE)
+      return nil unless header
+      type = header[0]
+      length = header.byteslice(1, 4).unpack1("N")
+      payload =
+        if length.zero?
+          ""
+        else
+          read_exact(io, length)
+        end
+      return nil unless payload
+      [type, payload]
+    end
+
+    # Writes one framed message. +payload+ is treated as raw bytes (binary).
+    def self.write(io, 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)
+    end
+
+    # Encodes a "ROWS COLS" string for HELLO / RESIZE payloads.
+    def self.encode_size(rows, cols)
+      "#{rows.to_i} #{cols.to_i}"
+    end
+
+    # Returns [rows, cols] or nil if malformed.
+    def self.decode_size(payload)
+      parts = payload.to_s.strip.split(/\s+/)
+      return nil unless parts.length == 2
+      r = Integer(parts[0]) rescue nil
+      c = Integer(parts[1]) rescue nil
+      return nil unless r && c
+      [r, c]
+    end
+
+    def self.read_exact(io, n)
+      buf = +""
+      while buf.bytesize < n
+        chunk = io.read(n - buf.bytesize)
+        return nil if chunk.nil? || chunk.empty?
+        buf << chunk
+      end
+      buf
+    end
+    private_class_method :read_exact
+  end
+end