muxr 0.1.5 → 0.1.7

data/lib/muxr/application.rb

@@ -72,8 +72,15 @@ module Muxr
       @control_server = nil
       @paste_buffer = +""
       @last_render_at = nil
+      @foreground_poller = nil
     end
 
+    # Interval for the background thread that refreshes each pane's
+    # foreground-command label. Picked to feel responsive (a long-running
+    # `npm test` shows up within a second of starting) without burning CPU
+    # on macOS, where each tick costs a `ps` fork+exec per pane.
+    FOREGROUND_POLL_INTERVAL = 0.75
+
     attr_reader :paste_buffer
 
     def run
@@ -141,6 +148,116 @@ module Muxr
       invalidate
     end
 
+    # Move focus to the pane spatially adjacent in `direction` (:left/:right/
+    # :up/:down). Called by the normal-mode hjkl bindings. Pulling the live
+    # layout rects keeps this in sync with whatever the renderer is showing.
+    # Monocle has no meaningful direction (every rect is identical) so we
+    # fall back to linear nav so hjkl still does something.
+    def focus_direction(direction)
+      return if @session.window.panes.empty?
+      if @session.focus_drawer && @session.drawer&.visible?
+        @session.focus_drawer = false
+        invalidate
+        return
+      end
+
+      win = @session.window
+      idx = LayoutManager.neighbor(current_pane_rects, win.focused_index, direction)
+      if idx.nil? && win.layout == :monocle
+        case direction
+        when :right, :down then win.focus_next
+        when :left, :up    then win.focus_prev
+        end
+        invalidate
+        return
+      end
+
+      return unless idx
+      win.focus_index(idx)
+      invalidate
+    end
+
+    # Swap the focused pane with its spatial neighbor in `direction`. Bound
+    # to shift-HJKL in normal mode. Mirrors focus_direction's geometry-aware
+    # lookup so the same "what does my arrow point at" intuition decides
+    # which neighbor gets bumped. Monocle has no spatial layout, so HJKL
+    # falls back to reordering by linear next/prev — useful for shuffling
+    # the master before flipping back to tall/grid.
+    def move_direction(direction)
+      return if @session.window.panes.empty?
+      # The drawer isn't part of the tiled pane list; HJKL while focused on
+      # it would be ambiguous. No-op.
+      return if @session.focus_drawer && @session.drawer&.visible?
+
+      win = @session.window
+      idx = LayoutManager.neighbor(current_pane_rects, win.focused_index, direction)
+      if idx.nil? && win.layout == :monocle
+        target = case direction
+                 when :right, :down then (win.focused_index + 1) % win.panes.length
+                 when :left, :up    then (win.focused_index - 1) % win.panes.length
+                 end
+        if target && target != win.focused_index
+          win.move_focused_to(target)
+          invalidate
+        end
+        return
+      end
+
+      return unless idx
+      win.move_focused_to(idx)
+      invalidate
+    end
+
+    # Explicit layout set, used by the normal-mode t/g/m bindings and the
+    # `:layout <name>` command.
+    def set_layout(layout)
+      @session.window.set_layout(layout)
+      flash("layout: #{@session.window.layout}")
+      invalidate
+    rescue ArgumentError => e
+      flash(e.message)
+    end
+
+    # Bound to `i` in normal mode — drops the user into the historical
+    # Ctrl-a-prefixed multiplexer mode.
+    def enter_passthrough_mode
+      @input.enter_passthrough_mode
+      flash("passthrough mode (^a esc to return)")
+      invalidate
+    end
+
+    # Bound to `Ctrl-a Esc` from passthrough — return to normal mode.
+    def enter_normal_mode
+      @input.enter_normal_mode
+      flash("normal mode")
+      invalidate
+    end
+
+    # Two-step close — same shape as the quit flow. Hiding the drawer is
+    # cheap and reversible, so we skip the prompt for the drawer case.
+    def request_close
+      if @session.focus_drawer && @session.drawer&.visible?
+        hide_drawer
+        return
+      end
+      return unless focused_pane
+      return if @input.state == :confirm_close
+      @input.enter_confirm_close
+      flash("close pane? (y/n)")
+      invalidate
+    end
+
+    def confirm_close
+      close_focused
+    end
+
+    def cancel_close
+      @message = nil
+      @message_expires = nil
+      flash("cancelled")
+      invalidate
+    end
+
     def close_focused
       if @session.focus_drawer && @session.drawer&.visible?
         hide_drawer
@@ -276,11 +393,63 @@ module Muxr
     def exit_scrollback
       target = focused_target
       target&.terminal&.clear_selection
+      target&.terminal&.clear_search
       target&.terminal&.scroll_to_bottom
       @renderer.reset_frame!
       invalidate
     end
 
+    # Bound to `/` (forward) and `?` (backward) in scrollback mode. Drops
+    # the user into a buffered prompt; commit_search / cancel_search exit
+    # back to scrollback.
+    def enter_search(direction: :forward)
+      @input.enter_search_mode(direction: direction)
+      invalidate
+    end
+
+    def commit_search(query)
+      target = focused_target
+      return unless target
+      term = target.terminal
+      direction = @input.search_direction
+      count = term.search(query, direction: direction)
+      if query.empty?
+        # Empty query just dismisses the prompt; leave the prior search
+        # state alone (term.search already cleared it though).
+      elsif count.zero?
+        flash("not found: #{query}")
+      else
+        flash("#{count} match#{count == 1 ? "" : "es"} (n/N to navigate)")
+      end
+      @renderer.reset_frame!
+      invalidate
+    end
+
+    def cancel_search
+      @renderer.reset_frame!
+      invalidate
+    end
+
+    def find_next
+      step_search(@input.search_direction)
+    end
+
+    def find_prev
+      step_search(@input.search_direction == :forward ? :backward : :forward)
+    end
+
+    def step_search(direction)
+      target = focused_target
+      return unless target
+      term = target.terminal
+      if term.search_matches.empty?
+        flash("no search active")
+        return
+      end
+      term.find_in_direction(direction)
+      invalidate
+    end
+
     def scroll_focused(action)
       target = focused_target
       return unless target
@@ -486,6 +655,20 @@ module Muxr
       end
     end
 
+    # Live pane rects for the current layout/size, computed the same way the
+    # Renderer does so spatial neighbor lookup matches what the user sees.
+    def current_pane_rects
+      win = @session.window
+      area = LayoutManager::Rect.new(0, 0, @session.width, @session.height - 1)
+      LayoutManager.compute(
+        win.layout,
+        win.panes.length,
+        area,
+        focused_index: win.focused_index,
+        master_index: win.master_index
+      )
+    end
+
     def focused_pane
       @session.window.focused_pane
     end
@@ -517,9 +700,11 @@ module Muxr
       restore_panes_if_saved(saved) if saved
 
       @running = true
+      start_foreground_poller
     end
 
     def teardown
+      stop_foreground_poller
       disconnect_client
       @control_server&.stop
       @control_server = nil
@@ -757,6 +942,8 @@ module Muxr
         @session,
         input_state: @input.state,
         command_buffer: @input.command_buffer,
+        search_buffer: @input.search_buffer,
+        search_direction: @input.search_direction,
         message: @message,
         help: @help_visible
       )
@@ -796,6 +983,55 @@ module Muxr
     # Fire-and-forget pipe to pbcopy. Runs on its own thread so even a slow
     # macOS pbcopy doesn't stall the event loop. Silent when pbcopy is absent
     # (Linux/headless) — selection still goes to the internal buffer.
+    # Background thread that walks every pane and writes its foreground
+    # command back onto pane.foreground_command. Lives off the event loop
+    # because the macOS `ps` path is fork+exec'y; on Linux the procfs reads
+    # would be fast enough on the main thread but a single code path is
+    # easier to reason about. Atomic pointer writes (MRI GVL) mean we don't
+    # need a lock for the renderer's per-frame read.
+    def start_foreground_poller
+      return if @foreground_poller
+      @foreground_poller = Thread.new do
+        while @running
+          begin
+            poll_foreground_commands
+          rescue StandardError
+            # Never let a poller crash kill the server. If the lookup keeps
+            # failing the titles just won't show commands — that's fine.
+          end
+          sleep FOREGROUND_POLL_INTERVAL
+        end
+      end
+    end
+
+    def stop_foreground_poller
+      thread = @foreground_poller
+      @foreground_poller = nil
+      return unless thread
+      # @running has already been flipped off; the thread exits on its next
+      # wake. join with a small timeout so we don't hang teardown if the
+      # thread is mid-`ps`.
+      thread.join(2.0) || thread.kill
+    end
+
+    def poll_foreground_commands
+      # Snapshot so add/remove on the main thread can't trip us mid-iter.
+      panes = @session.window.panes.dup
+      drawer_pane = @session.drawer&.pane
+      panes << drawer_pane if drawer_pane
+      changed = false
+      panes.each do |pane|
+        next unless pane.alive?
+        next unless pane.respond_to?(:pid) && pane.pid
+        name = ForegroundCommand.lookup(pane.pid)
+        if pane.foreground_command != name
+          pane.foreground_command = name
+          changed = true
+        end
+      end
+      invalidate if changed
+    end
+
     def spawn_pbcopy(text)
       Thread.new do
         IO.popen("pbcopy", "w") { |io| io.write(text) }

data/lib/muxr/command_dispatcher.rb

@@ -26,7 +26,7 @@ module Muxr
       when "new", "c"
         @app.new_pane
       when "close", "kill", "k"
-        @app.close_focused
+        @app.request_close
       when "next"    then @app.focus_next
       when "prev"    then @app.focus_prev
       when "master"  then @app.promote_master

data/lib/muxr/foreground_command.rb

@@ -0,0 +1,86 @@
+module Muxr
+  # Looks up the foreground command running inside a PTY by walking from the
+  # shell's pid → its tpgid (foreground process group on the controlling tty)
+  # → that process's command name. Hides the result when the shell itself is
+  # foreground so titles aren't full of "bash" / "zsh" noise.
+  #
+  # Two platform paths:
+  #   Linux: /proc/<pid>/stat (no fork — runs fast even on the main thread,
+  #          though Application uses a background thread anyway)
+  #   macOS: ps -o tpgid=,pgid= -p <pid> + ps -o comm= -p <tpgid>. Two
+  #          fork+execs, ~10–20ms total — exactly the reason callers run
+  #          this off the event-loop thread.
+  #
+  # Returns the command name string or nil. nil also covers "couldn't read"
+  # so callers degrade silently rather than risk showing stale data.
+  module ForegroundCommand
+    # Command names we never want to surface — these are the empty-prompt
+    # case. If a user genuinely runs `bash` inside `bash` we'll under-report
+    # rather than mis-report.
+    SHELLS = %w[bash zsh fish sh dash ksh tcsh csh].freeze
+
+    module_function
+
+    def lookup(pid)
+      return nil unless pid.is_a?(Integer) && pid > 0
+      tpgid, pgid =
+        if File.exist?("/proc/#{pid}/stat")
+          linux_tpgid(pid)
+        else
+          macos_tpgid(pid)
+        end
+      return nil unless tpgid && pgid
+      return nil if tpgid <= 0
+      return nil if tpgid == pgid # shell is its own foreground — empty prompt
+
+      name =
+        if File.exist?("/proc/#{tpgid}/comm")
+          File.read("/proc/#{tpgid}/comm").strip
+        else
+          `ps -o comm= -p #{tpgid} 2>/dev/null`.strip
+        end
+      normalize(name)
+    rescue StandardError
+      nil
+    end
+
+    # Public for testing — strips path/dash/whitespace and filters shells.
+    def normalize(name)
+      return nil if name.nil? || name.empty?
+      name = name.strip
+      name = name.sub(/\A-/, "") # login shells appear as "-bash"
+      name = File.basename(name)
+      return nil if name.empty?
+      return nil if SHELLS.include?(name)
+      name
+    end
+
+    # Public for testing — parses Linux /proc/<pid>/stat into [tpgid, pgid].
+    # The comm field can contain spaces and parens, so we slice from the
+    # last ')' rather than splitting from the start.
+    def parse_linux_stat(raw)
+      idx = raw.rindex(")")
+      return [nil, nil] unless idx
+      tail = raw[(idx + 2)..]
+      return [nil, nil] unless tail
+      fields = tail.split(" ")
+      # After the closing paren the fields are:
+      #   state(0) ppid(1) pgrp(2) session(3) tty_nr(4) tpgid(5) ...
+      pgid  = fields[2]&.to_i
+      tpgid = fields[5]&.to_i
+      [tpgid, pgid]
+    end
+
+    def linux_tpgid(pid)
+      raw = File.read("/proc/#{pid}/stat")
+      parse_linux_stat(raw)
+    end
+
+    def macos_tpgid(pid)
+      out = `ps -o tpgid=,pgid= -p #{pid} 2>/dev/null`.strip
+      return [nil, nil] if out.empty?
+      tpgid, pgid = out.split.map(&:to_i)
+      [tpgid, pgid]
+    end
+  end
+end