muxr 0.1.4 → 0.1.6

data/lib/muxr/renderer.rb

@@ -4,13 +4,30 @@ module Muxr
   # new frame against the previous one and only repositions/redraws cells
   # whose contents changed, keeping output volume low between ticks.
   class Renderer
-    BORDER_FOCUSED      = [:c256, 11].freeze  # yellow
+    BORDER_FOCUSED      = [:c256, 11].freeze  # yellow (fallback when no mode color)
     BORDER_UNFOCUSED    = [:c256, 8].freeze   # grey
     BORDER_DRAWER_FOCUS = [:c256, 13].freeze  # magenta
     BORDER_DRAWER_IDLE  = [:c256, 5].freeze   # dark magenta
     STATUS_BG           = [:c256, 236].freeze
     STATUS_FG           = [:c256, 252].freeze
 
+    # Vim-style mode palette. Used in two places: the focused pane border
+    # (so the user can see at a glance what mode they're in) and the
+    # [MODE] chip in the status bar (same color, smaller real estate).
+    # :prefix maps to the same green as :passthrough because :prefix is a
+    # transient sub-state under passthrough — sharing the color avoids a
+    # one-frame border flicker when pressing Ctrl-a.
+    MODE_COLOR = {
+      normal:       [:c256, 51].freeze,   # cyan
+      passthrough:  [:c256, 42].freeze,   # green
+      prefix:       [:c256, 42].freeze,   # green (passthrough sub-state)
+      command:      [:c256, 226].freeze,  # yellow
+      scrollback:   [:c256, 214].freeze,  # orange
+      selection:    [:c256, 201].freeze,  # magenta
+      confirm_quit: [:c256, 196].freeze,  # red
+      help:         [:c256, 39].freeze    # blue
+    }.freeze
+
     HORIZONTAL = "─".freeze
     VERTICAL   = "│".freeze
     TL         = "┌".freeze
@@ -18,9 +35,9 @@ module Muxr
     BL         = "└".freeze
     BR         = "┘".freeze
 
-    Cell = Struct.new(:char, :fg, :bg, :attrs) do
+    Cell = Struct.new(:char, :fg, :bg, :attrs, :hyperlink) do
       def ==(other)
-        other.is_a?(Cell) && char == other.char && fg == other.fg && bg == other.bg && attrs == other.attrs
+        other.is_a?(Cell) && char == other.char && fg == other.fg && bg == other.bg && attrs == other.attrs && hyperlink == other.hyperlink
       end
     end
 
@@ -32,7 +49,10 @@ module Muxr
     end
 
     def enter_alt_screen
-      @out.write("\e[?1049h\e[?25l\e[2J\e[H\e[0m")
+      # Close any stale OSC 8 hyperlink the outer terminal might be carrying
+      # from before we attached, so the first frame's run-tracker matches
+      # reality.
+      @out.write("\e[?1049h\e[?25l\e[2J\e[H\e[0m\e]8;;\e\\")
       @out.flush
       @prev = nil
     end
@@ -46,15 +66,15 @@ module Muxr
       @prev = nil
     end
 
-    def render(session, input_state: :idle, command_buffer: "", message: nil, help: false)
+    def render(session, input_state: :normal, command_buffer: "", message: nil, help: false)
       w = session.width
       h = session.height
       return if w < 4 || h < 3
 
-      frame = Array.new(h) { Array.new(w) { Cell.new(" ", nil, nil, 0) } }
+      frame = Array.new(h) { Array.new(w) { Cell.new(" ", nil, nil, 0, nil) } }
 
-      compose_panes(frame, session)
-      compose_drawer(frame, session) if session.drawer&.visible?
+      compose_panes(frame, session, input_state: input_state)
+      compose_drawer(frame, session, input_state: input_state) if session.drawer&.visible?
       compose_status_bar(frame, session, input_state: input_state, command_buffer: command_buffer, message: message)
       compose_help(frame, session) if help
 
@@ -63,7 +83,7 @@ module Muxr
 
     private
 
-    def compose_panes(frame, session)
+    def compose_panes(frame, session, input_state: :normal)
       win = session.window
       content_area = LayoutManager::Rect.new(0, 0, session.width, session.height - 1)
       rects = LayoutManager.compute(
@@ -93,27 +113,48 @@ module Muxr
         focused = (i == win.focused_index) && !(session.focus_drawer && session.drawer&.visible?)
         title = "##{i + 1}"
         title += "/#{win.panes.length}" if monocle
+        # Stable id sits after the slot number so monocle reads "#1/3 a3f9b2".
+        # respond_to? guard keeps renderer tests (which use simple struct fakes)
+        # from blowing up when a pane stand-in doesn't implement #id.
+        title += " #{pane.id}" if pane.respond_to?(:id) && pane.id.is_a?(String)
+        title += " [P]" if pane.respond_to?(:private?) && pane.private?
         title += " ★" if i == win.master_index
-        title += " (" + win.layout.to_s + ")" if i == win.focused_index
+        # Foreground command (e.g. "npm test", "vim"). Set by the poller
+        # thread; nil when the shell itself is foreground. Truncate so a
+        # long invocation doesn't push the title past what draw_box will
+        # render — draw_box silently drops titles that don't fit.
+        if pane.respond_to?(:foreground_command) && pane.foreground_command
+          cmd = pane.foreground_command.to_s[0, 16]
+          title += " · #{cmd}"
+        end
         if pane.terminal.scrolled_back?
           title += " [scrollback #{pane.terminal.view_offset}/#{pane.terminal.scrollback_size}]"
         end
         draw_box(frame, rect,
-                 border: focused ? BORDER_FOCUSED : BORDER_UNFOCUSED,
+                 border: focused ? mode_color(input_state) : BORDER_UNFOCUSED,
                  bold_border: focused,
                  title: title,
                  title_focused: focused)
+        # Mode chip lives in the top-right corner of the focused container
+        # (this pane, or the drawer — see compose_drawer). Showing it on
+        # the same edge as the title but on the opposite side keeps both
+        # readable without one crowding the other.
+        draw_mode_chip(frame, rect, input_state, title) if focused
         copy_terminal(frame, pane, rect.x + 1, rect.y + 1)
       end
     end
 
-    def compose_drawer(frame, session)
+    def compose_drawer(frame, session, input_state: :normal)
       drawer = session.drawer
       return unless drawer&.pane
 
       w = session.width
       h = session.height
-      dh = (h * 0.35).round.clamp(5, h - 2)
+      # Drawer height is the larger of "16 rows" or 35% of the screen — the
+      # 35% rule is fine on tall terminals but uselessly small on short ones,
+      # so we floor it at 16 to keep the drawer practical. Final clamp keeps
+      # room for panes + status bar on very small terminals.
+      dh = [16, (h * 0.35).round].max.clamp(5, h - 2)
       dy = h - 1 - dh
       rect = LayoutManager::Rect.new(0, dy, w, dh)
       drawer.pane.rect = rect
@@ -141,9 +182,47 @@ module Muxr
                bold_border: true,
                title: title,
                title_focused: focused)
+      draw_mode_chip(frame, rect, input_state, title) if focused
       copy_terminal(frame, drawer.pane, rect.x + 1, rect.y + 1)
     end
 
+    def mode_color(input_state)
+      MODE_COLOR[input_state] || BORDER_FOCUSED
+    end
+
+    # Paint the " [MODE] " chip on the top border, hugging the right corner.
+    # Skipped when there isn't at least one column of breathing room between
+    # the title (anchored at the top-left) and the chip — otherwise long
+    # titles + a wide chip would overdraw each other and produce garbage.
+    def draw_mode_chip(frame, rect, input_state, title)
+      chip = " [#{mode_label(input_state)}] "
+      chip_start = rect.x + rect.w - 1 - chip.length
+      title_text = " #{title} "
+      title_end = rect.x + 2 + title_text.length - 1
+      return if chip_start <= title_end + 1
+      chip_color = mode_color(input_state)
+      chip.each_char.with_index do |ch, j|
+        set_cell(frame, rect.y, chip_start + j, ch, fg: chip_color, attrs: Terminal::BOLD)
+      end
+    end
+
+    # Two-letter-ish mode label shown in the leftmost slot of the status bar.
+    # Lets the user see at a glance whether single-key bindings are active
+    # (NORMAL) or every key passes through to the focused pane (PASS).
+    def mode_label(input_state)
+      case input_state
+      when :normal       then "NORMAL"
+      when :passthrough  then "PASS"
+      when :prefix       then "^A"
+      when :command      then "CMD"
+      when :scrollback   then "SCROLL"
+      when :selection    then "SEL"
+      when :confirm_quit then "QUIT?"
+      when :help         then "HELP"
+      else                    "?"
+      end
+    end
+
     def compose_status_bar(frame, session, input_state:, command_buffer:, message:)
       y = session.height - 1
       w = session.width
@@ -154,7 +233,8 @@ module Muxr
         else                                  "hidden"
         end
 
-      left = " [#{session.name}]"
+      left = " [#{mode_label(input_state)}]"
+      left << " [#{session.name}]"
       left << " panes:#{win.panes.length}"
       left << " layout:#{win.layout}"
       focused_label =
@@ -181,6 +261,21 @@ module Muxr
         c.attrs = 0
       end
 
+      # Recolor the leading "[MODE]" chip in the mode's accent color. The
+      # chip lives at offset 1 (after one leading space) and runs for
+      # bracket+label+bracket characters. Full-row overlays below will
+      # overwrite this when active (command/scrollback/selection) — that's
+      # fine, those modes already convey themselves loudly.
+      chip = "[#{mode_label(input_state)}]"
+      chip_color = mode_color(input_state)
+      chip_start = 1
+      chip_end = [chip_start + chip.length, w].min
+      (chip_start...chip_end).each do |x|
+        c = frame[y][x]
+        c.fg = chip_color
+        c.attrs |= Terminal::BOLD
+      end
+
       if input_state == :command
         overlay = ":#{command_buffer}"
         overlay = overlay[0, w]
@@ -222,7 +317,7 @@ module Muxr
           mode = focused.terminal.selection_mode == :block ? "BLOCK" : "CHAR"
         end
         label = mode ? "SELECTION/#{mode}" : "SELECTION (cursor)"
-        overlay = " #{label}  h/j/k/l move  v char  C-v block  y/Enter yank  q cancel "
+        overlay = " #{label}  h/j/k/l move  v/space char  C-v block  y/Enter yank  q cancel "
         overlay = overlay[0, w]
         overlay.each_char.with_index do |ch, x|
           c = frame[y][x]
@@ -256,26 +351,33 @@ module Muxr
     HELP_LINES = [
       "muxr — keybindings",
       "",
-      "  C-a c       new pane",
-      "  C-a n / p   next / prev pane",
-      "  C-a a       toggle to previously focused pane",
-      "  C-a 1..9    jump to pane by number",
-      "  C-a k       close focused pane",
-      "  C-a Tab     cycle layout (tall → grid → monocle)",
-      "  C-a Enter   promote focused pane to master",
-      "  C-a ~       toggle drawer",
-      "  C-a [       enter scrollback (j/k d/u f g/G C-b/C-f; v→cursor, q quits)",
-      "              cursor: v select, C-v block, y yank, q cancel",
-      "              motions: h/j/k/l 0/^/$ w/e/b W/E/B H/M/L g/G",
-      "  C-a ]       paste internal copy buffer",
-      "  C-a d       detach (server keeps running)",
-      "  C-a q       kill session (asks y/n)",
-      "  C-a :       command prompt",
-      "  C-a ?       toggle this help",
-      "  C-a C-a     send literal C-a",
+      "NORMAL mode (default; no prefix)",
+      "  h / j / k / l   focus pane left / down / up / right",
+      "  i               drop into passthrough mode",
+      "  c / K           new / close pane",
+      "  t / g / m       layout: tall / grid / monocle",
+      "  Tab / Enter     cycle layout / promote to master",
+      "  a / 1..9        last pane / jump by number",
+      "  s               enter scrollback",
+      "  ~ / C / P       drawer / Claude drawer / toggle private",
+      "  : / ?           command prompt / toggle this help",
+      "  ] / d / q       paste buffer / detach / kill session",
+      "",
+      "PASSTHROUGH mode (keys reach the focused pane; prefix is Ctrl-a)",
+      "  C-a Esc         return to normal mode",
+      "  C-a c K t g m   same as normal-mode bindings",
+      "  C-a Tab Enter   cycle layout / promote master",
+      "  C-a n / p / a   next / prev / last pane",
+      "  C-a [ ]         scrollback / paste buffer",
+      "  C-a C-a         send literal Ctrl-a to focused pane",
+      "",
+      "SCROLLBACK mode (exits to the mode you came from)",
+      "  j/k d/u f/b g/G  scroll  C-b/C-f page  v→cursor",
+      "  cursor: h/j/k/l 0/^/$ w/e/b W/E/B H/M/L g/G",
+      "          v select, C-v block, y/Enter yank, q/Esc cancel",
       "",
       "Commands: layout {tall|grid|monocle}, drawer {toggle|show|hide|reset},",
-      "          save, restore, sessions, quit, new, close, next, prev",
+      "          claude, save, restore, sessions, quit, new, close, next, prev",
       "",
       "press any key to dismiss"
     ].freeze
@@ -356,6 +458,7 @@ module Muxr
           dst.bg = src.bg
           dst.attrs = src.attrs
           dst.attrs |= Terminal::REVERSE if selection && term.selected_at_visible?(r, c)
+          dst.hyperlink = src.hyperlink
         end
       end
     end
@@ -382,6 +485,9 @@ module Muxr
       cur_fg = :unset
       cur_bg = :unset
       cur_attrs = :unset
+      # We close any open hyperlink at end-of-frame, so the outer terminal
+      # always starts a new frame in the "no hyperlink" state.
+      cur_hyperlink = nil
       last_y = nil
       last_x = nil
 
@@ -399,11 +505,17 @@ module Muxr
             cur_bg = cell.bg
             cur_attrs = cell.attrs
           end
+          if cell.hyperlink != cur_hyperlink
+            out << "\e]8;;\e\\" if cur_hyperlink
+            out << "\e]#{cell.hyperlink}\e\\" if cell.hyperlink
+            cur_hyperlink = cell.hyperlink
+          end
           out << cell.char
           last_y = y
           last_x = x + cell.char.length
         end
       end
+      out << "\e]8;;\e\\" if cur_hyperlink
       out << "\e[0m"
       out << cursor_position(session, input_state: input_state, command_buffer: command_buffer)
       out << "\e[?2026l"

data/lib/muxr/session.rb

@@ -45,7 +45,7 @@ module Muxr
         "focused_index"  => @window.focused_index,
         "master_index"   => @window.master_index,
         "focus_drawer"   => @focus_drawer,
-        "panes"          => @window.panes.map { |p| { "cwd" => safe_cwd(p) } },
+        "panes"          => @window.panes.map { |p| { "id" => safe_id(p), "cwd" => safe_cwd(p), "private" => safe_private(p) } },
         "drawer"         => serialize_drawer
       }
     end
@@ -76,11 +76,22 @@ module Muxr
       pane.respond_to?(:cwd) ? pane.cwd : nil
     end
 
+    def safe_id(pane)
+      return nil unless pane.respond_to?(:id)
+      id = pane.id
+      id.is_a?(String) ? id : nil
+    end
+
+    def safe_private(pane)
+      pane.respond_to?(:private?) && pane.private?
+    end
+
     def serialize_drawer
       return nil unless @drawer
       {
         "visible" => @drawer.visible?,
-        "cwd"     => @drawer.cwd
+        "cwd"     => @drawer.cwd,
+        "command" => @drawer.respond_to?(:command) ? @drawer.command : nil
       }
     end
   end

data/lib/muxr/terminal.rb

@@ -12,6 +12,11 @@ module Muxr
 
     SCROLLBACK_MAX = 5000
 
+    # Cap on the OSC payload we buffer before parsing. URLs in OSC 8 can be
+    # long but rarely exceed a few hundred bytes; 4 KiB lets the parser stay
+    # tolerant of weird inputs without giving an attacker an unbounded sink.
+    OSC_MAX_LEN = 4096
+
     # Inner programs (fzf ≥ 0.41, neovim, helix, …) bracket coherent screen
     # updates with `\e[?2026h … \e[?2026l` (DECSET 2026 — "Synchronized
     # Output"). When we see the open, we know more bytes are coming that
@@ -20,12 +25,13 @@ module Muxr
     # program (which left ?2026h open) cannot wedge the pane indefinitely.
     SYNC_TIMEOUT = 0.2
 
-    Cell = Struct.new(:char, :fg, :bg, :attrs) do
+    Cell = Struct.new(:char, :fg, :bg, :attrs, :hyperlink) do
       def reset!
         self.char = " "
         self.fg = nil
         self.bg = nil
         self.attrs = 0
+        self.hyperlink = nil
       end
 
       def copy_from(other)
@@ -33,6 +39,7 @@ module Muxr
         self.fg = other.fg
         self.bg = other.bg
         self.attrs = other.attrs
+        self.hyperlink = other.hyperlink
       end
     end
 
@@ -53,7 +60,14 @@ module Muxr
       @scroll_bottom = rows - 1
       @parser_state = :ground
       @parser_params = +""
+      @parser_osc = +""
       @feed_remainder = +"".b
+      # Currently-active OSC 8 hyperlink body (the "8;params;URI" payload that
+      # we'll wrap back around runs of cells when rendering), or nil when no
+      # hyperlink is open. Interned via @hyperlink_intern so repeated identical
+      # links share one frozen string for fast equality and small memory.
+      @current_hyperlink = nil
+      @hyperlink_intern = {}
       @dirty = true
       @scrollback = []
       @view_offset = 0
@@ -62,6 +76,19 @@ module Muxr
       @selection_mode = :linear
       @sync_pending = false
       @sync_started_at = nil
+      @pending_replies = +"".b
+    end
+
+    # Bytes the emulator owes back to the inner program in response to a
+    # query (currently DSR / Device Status Report — `\e[5n` and `\e[6n`).
+    # The Pane drains this after each feed and writes it to the PTY's input
+    # side. Without it, programs like the AWS CLI fall back with a warning
+    # ("your terminal doesn't support cursor position requests (CPR)").
+    def take_pending_replies!
+      return nil if @pending_replies.empty?
+      data = @pending_replies
+      @pending_replies = +"".b
+      data
     end
 
     # True iff the inner program has opened a synchronized-output block
@@ -89,6 +116,20 @@ module Muxr
       @buffer[r][c]
     end
 
+    # Return the currently-visible grid as a text string (rows joined by "\n",
+    # trailing whitespace stripped on each row). Used by the control surface
+    # to expose pane contents to programmatic clients (the MCP bridge in
+    # particular). This walks visible_cell so callers see whatever the user
+    # is currently looking at, including scrollback.
+    def dump_text
+      lines = Array.new(@rows) do |r|
+        row = String.new(capacity: @cols)
+        @cols.times { |c| row << visible_cell(r, c).char }
+        row.rstrip
+      end
+      lines.join("\n")
+    end
+
     # Returns the Cell that should be visible at (r, c) given the current
     # scrollback view_offset. When view_offset == 0 this is the live grid.
     # When view_offset > 0, rows in the top of the visible area are sourced
@@ -421,7 +462,25 @@ module Muxr
     private
 
     def blank_cell
-      Cell.new(" ", nil, nil, 0)
+      Cell.new(" ", nil, nil, 0, nil)
+    end
+
+    # Parse the just-completed OSC payload. We only care about OSC 8
+    # (hyperlinks): `8;params;URI`. An empty URI closes the active link.
+    # Anything else (window-title OSC 0/1/2, palette OSC 4, …) is silently
+    # consumed — the emulator doesn't model it.
+    def finalize_osc
+      payload = @parser_osc
+      @parser_osc = +""
+      return if payload.empty?
+      return unless payload.start_with?("8;")
+      parts = payload.split(";", 3)
+      uri = parts[2]
+      if uri.nil? || uri.empty?
+        @current_hyperlink = nil
+      else
+        @current_hyperlink = (@hyperlink_intern[payload] ||= payload.dup.freeze)
+      end
     end
 
     def process_char(ch)
@@ -435,11 +494,18 @@ module Muxr
         csi_char(ch, b)
       when :osc
         if b == 0x07 || b == 0x9c
+          finalize_osc
           @parser_state = :ground
         elsif b == 0x1b
           @parser_state = :osc_esc
+        elsif @parser_osc.bytesize < OSC_MAX_LEN
+          @parser_osc << ch
         end
       when :osc_esc
+        # ST is `ESC \`. Anything else is malformed but we still flush — most
+        # terminals are lenient here, and being strict would swallow the
+        # payload on slightly buggy emitters.
+        finalize_osc
         @parser_state = :ground
       when :charset
         @parser_state = :ground
@@ -478,6 +544,7 @@ module Muxr
         @parser_params = +""
       when 0x5d # ]
         @parser_state = :osc
+        @parser_osc = +""
       when 0x28, 0x29, 0x2a, 0x2b # ( ) * +
         @parser_state = :charset
       when 0x37 # 7  save cursor
@@ -645,6 +712,16 @@ module Muxr
         @saved_cursor = [@cursor_row, @cursor_col]
       when "u"
         @cursor_row, @cursor_col = @saved_cursor
+      when "n"
+        # DSR — Device Status Report. `\e[5n` asks if the terminal is OK,
+        # `\e[6n` (CPR) asks for the cursor position. The reply rides back
+        # through the PTY's input side; see take_pending_replies!.
+        case pms[0] || 0
+        when 5
+          @pending_replies << "\e[0n".b
+        when 6
+          @pending_replies << "\e[#{@cursor_row + 1};#{@cursor_col + 1}R".b
+        end
       when "h", "l"
         # Non-private mode set/reset — nothing we need to honor. (DEC private
         # `?`-prefixed mode sequences are short-circuited above.)
@@ -662,6 +739,7 @@ module Muxr
       cell.fg = @fg
       cell.bg = @bg
       cell.attrs = @attrs
+      cell.hyperlink = @current_hyperlink
       if @cursor_col >= @cols - 1
         @autowrap_pending = true
       else
@@ -983,6 +1061,7 @@ module Muxr
       @scroll_top = 0
       @scroll_bottom = @rows - 1
       @autowrap_pending = false
+      @current_hyperlink = nil
     end
   end
 end

data/lib/muxr/version.rb

@@ -1,3 +1,3 @@
 module Muxr
-  VERSION = "0.1.4"
+  VERSION = "0.1.6"
 end

data/lib/muxr.rb

@@ -3,6 +3,7 @@ require_relative "muxr/pty_process"
 require_relative "muxr/terminal"
 require_relative "muxr/pane"
 require_relative "muxr/drawer"
+require_relative "muxr/foreground_command"
 require_relative "muxr/layout_manager"
 require_relative "muxr/window"
 require_relative "muxr/session"
@@ -10,6 +11,7 @@ require_relative "muxr/renderer"
 require_relative "muxr/input_handler"
 require_relative "muxr/command_dispatcher"
 require_relative "muxr/protocol"
+require_relative "muxr/control_server"
 require_relative "muxr/application"
 require_relative "muxr/client"
 

data/muxr.gemspec

@@ -26,10 +26,12 @@ Gem::Specification.new do |spec|
   }
 
   spec.bindir        = "bin"
-  spec.executables   = ["muxr"]
+  spec.executables   = ["muxr", "muxr-mcp"]
   spec.files         = Dir[
     "lib/**/*.rb",
     "bin/muxr",
+    "bin/muxr-mcp",
+    "skills/**/*",
     "README.md",
     "CHANGELOG.md",
     "LICENSE.txt",