muxr 0.1.3 → 0.1.5

data/lib/muxr/application.rb

@@ -16,16 +16,25 @@ module Muxr
   # attach via Renderer#reset_frame!.
   class Application
     SELECT_TIMEOUT = 0.05
+    # ~60 Hz cap on full repaints. Keystrokes in fzf or vim navigation can
+    # trigger PTY bursts faster than the terminal can usefully display them;
+    # the cap collapses those bursts and stops intermediate frames from
+    # showing through.
+    MIN_FRAME_INTERVAL = 1.0 / 60
     SOCKETS_DIR    = File.join(Dir.home, ".muxr", "sockets").freeze
     DEFAULT_WIDTH  = 80
     DEFAULT_HEIGHT = 24
 
-    attr_reader :session, :renderer, :input, :session_name
+    attr_reader :session, :renderer, :input, :session_name, :control_server
 
     def self.socket_path_for(name)
       File.join(SOCKETS_DIR, "#{name}.sock")
     end
 
+    def self.control_socket_path_for(name)
+      File.join(SOCKETS_DIR, "#{name}.ctrl.sock")
+    end
+
     # Names of sessions whose server socket is currently accepting connections.
     # Stale sockets (file exists, no listener) are skipped but left in place;
     # cleanup happens on the next attach attempt.
@@ -55,12 +64,14 @@ module Muxr
       @message = nil
       @message_expires = nil
       @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)
+      @control_socket_path = self.class.control_socket_path_for(@session_name)
+      @control_server = nil
       @paste_buffer = +""
+      @last_render_at = nil
     end
 
     attr_reader :paste_buffer
@@ -81,12 +92,14 @@ module Muxr
       target&.write(data)
     end
 
-    def new_pane
-      cwd = focused_pane&.cwd
-      @session.window.add_pane(make_pane(cwd: cwd))
+    def new_pane(cwd: nil)
+      cwd ||= focused_pane&.cwd
+      pane = make_pane(cwd: cwd)
+      @session.window.add_pane(pane)
       @session.focus_drawer = false
       @session.window.focused_index = @session.window.panes.length - 1
       invalidate
+      pane
     end
 
     def focus_next
@@ -150,15 +163,30 @@ module Muxr
       invalidate
     end
 
-    def toggle_drawer
-      ensure_drawer
-      @session.drawer.toggle!
-      @session.focus_drawer = @session.drawer.visible?
-      @session.focus_drawer = false unless @session.drawer.visible?
-      renderer.reset_frame!
+    # Toggle the privacy flag on the focused pane. Private panes are
+    # redacted from the MCP control surface (panes.list strips cwd; read /
+    # send_input / run / subscribe / kill all refuse). Only the human can
+    # flip this — there is intentionally no control method to do it.
+    def toggle_private_focused
+      pane = focused_pane
+      return unless pane
+      pane.toggle_private!
+      flash(pane.private? ? "pane #{pane.id} marked private (hidden from MCP)" : "pane #{pane.id} unmarked private")
       invalidate
     end
 
+    def toggle_drawer
+      toggle_drawer_kind(command: nil)
+    end
+
+    # Ctrl-a C / :claude — opens a drawer whose shell is `claude`, with
+    # MUXR_SESSION + MUXR_CONTROL_SOCKET + MUXR_FOCUSED_PANE in the env so
+    # the muxr-mcp bridge inside that claude process auto-attaches to this
+    # session.
+    def toggle_claude_drawer
+      toggle_drawer_kind(command: "claude")
+    end
+
     def show_drawer
       ensure_drawer
       @session.drawer.show!
@@ -471,20 +499,30 @@ module Muxr
       @listening_socket = UNIXServer.new(@socket_path)
       File.chmod(0o600, @socket_path) rescue nil
 
+      # Sibling control socket — multi-client, NDJSON, used by bin/muxr-mcp
+      # and any other programmatic driver. Connected control clients do not
+      # count as "attached", so a Claude Code session can poke the muxr
+      # server without contending with the human's TTY client.
+      @control_server = ControlServer.new(self, @control_socket_path)
+      @control_server.start
+
       @session  = Session.new(name: @session_name, width: DEFAULT_WIDTH, height: DEFAULT_HEIGHT)
       @renderer = Renderer.new(out: FramedOutput.new(self))
       @input    = InputHandler.new(self)
 
-      first_pane = make_pane
-      @session.window.add_pane(first_pane)
+      saved = Session.load(@session_name)
+      first_id = saved && saved.dig("panes", 0, "id")
+      @session.window.add_pane(make_pane(id: first_id))
 
-      restore_panes_if_saved
+      restore_panes_if_saved(saved) if saved
 
       @running = true
     end
 
     def teardown
       disconnect_client
+      @control_server&.stop
+      @control_server = nil
       if @listening_socket
         @listening_socket.close rescue nil
       end
@@ -502,6 +540,7 @@ module Muxr
         @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?
+        read_ios.concat(@control_server.read_ios) if @control_server
 
         write_ios = []
         @session.window.panes.each do |p|
@@ -511,8 +550,23 @@ module Muxr
           write_ios << drawer_pane.writer_io
         end
         write_ios << @current_client if @current_client && !@client_write_buffer.empty?
+        write_ios.concat(@control_server.write_ios) if @control_server
 
         timeout = @message ? 0.25 : SELECT_TIMEOUT
+        # If a render is queued but we're inside the frame-rate budget, wake
+        # up as soon as the budget expires so the deferred paint lands on time.
+        if @current_client && @needs_render && @last_render_at
+          budget = MIN_FRAME_INTERVAL - (monotonic_now - @last_render_at)
+          timeout = budget.clamp(0, timeout) if budget < timeout
+        end
+        # If a pane is mid-synchronized-output (DEC 2026), wake up no later
+        # than its safety deadline so a crashed inner program can't wedge
+        # rendering past Terminal::SYNC_TIMEOUT.
+        deadline = nearest_sync_deadline
+        if deadline
+          remaining = deadline - monotonic_now
+          timeout = remaining.clamp(0, timeout) if remaining < timeout
+        end
         ready_r, ready_w, = IO.select(read_ios, write_ios, nil, timeout)
 
         ready_r&.each do |io|
@@ -520,6 +574,8 @@ module Muxr
             accept_client
           elsif io == @current_client
             consume_client_frame
+          elsif @control_server&.owns?(io)
+            @control_server.handle_read(io)
           else
             consume_pane_io(io)
           end
@@ -528,13 +584,18 @@ module Muxr
         ready_w&.each do |io|
           if io == @current_client
             drain_client_writes
+          elsif @control_server&.owns?(io)
+            @control_server.handle_write(io)
           else
             pane = pane_for_writer_io(io)
             pane&.drain_writes
           end
         end
 
+        @control_server&.tick
+
         prune_dead_panes
+        prune_dead_drawer
         expire_message
 
         if @session.window.panes.empty?
@@ -542,13 +603,38 @@ module Muxr
           break
         end
 
-        if @current_client && @needs_render
-          render
-          @needs_render = false
+        if @current_client && @needs_render && !any_pane_syncing?
+          now = monotonic_now
+          if @last_render_at.nil? || (now - @last_render_at) >= MIN_FRAME_INTERVAL
+            render
+            @last_render_at = now
+            @needs_render = false
+          end
         end
       end
     end
 
+    def monotonic_now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    # True iff any pane (or the drawer) has opened a DEC 2026 synchronized
+    # output block that hasn't yet closed or timed out. Used to defer the
+    # outer paint so it lands on a fully-formed inner frame.
+    def any_pane_syncing?
+      return true if @session.window.panes.any? { |p| p.terminal.sync_pending? }
+      drawer = @session.drawer&.pane
+      return true if drawer && drawer.terminal.sync_pending?
+      false
+    end
+
+    def nearest_sync_deadline
+      deadlines = @session.window.panes.filter_map { |p| p.terminal.sync_deadline }
+      d = @session.drawer&.pane&.terminal&.sync_deadline
+      deadlines << d if d
+      deadlines.min
+    end
+
     def accept_client
       sock = @listening_socket.accept
       if @current_client
@@ -602,7 +688,14 @@ module Muxr
       pane = pane_for_io(io)
       return unless pane
       data = pane.read_from_pty
-      invalidate if data
+      if data
+        invalidate
+        # Notify the control surface so any pending pane.run waiters reset
+        # their idle window and any pane.subscribe clients get a new frame.
+        # read_from_pty already fed the bytes into the Terminal; the control
+        # server pulls the resulting text out of pane.terminal.dump_text.
+        @control_server&.on_pane_output(pane.id, data) if pane.id.is_a?(String)
+      end
     end
 
     def pane_for_io(io)
@@ -626,6 +719,25 @@ module Muxr
       invalidate
     end
 
+    # When the shell (or claude) inside the drawer exits, tear the drawer
+    # down so the next Ctrl-a ~ / Ctrl-a C spawns a fresh one. Without this
+    # the drawer pane stays mounted around a dead PTY and looks like the
+    # multiplexer is wedged.
+    def prune_dead_drawer
+      drawer = @session.drawer
+      return unless drawer
+      pane = drawer.pane
+      return unless pane
+      return if pane.alive?
+      kind = drawer.command ? "#{drawer.command} drawer" : "drawer"
+      drawer.close
+      @session.drawer = nil
+      @session.focus_drawer = false
+      renderer.reset_frame!
+      flash("#{kind} exited")
+      invalidate
+    end
+
     def expire_message
       return unless @message_expires
       if Time.now >= @message_expires
@@ -693,20 +805,62 @@ module Muxr
       end
     end
 
-    def make_pane(cwd: nil)
-      @next_pane_id += 1
-      Pane.new(id: @next_pane_id, rows: 24, cols: 80, cwd: cwd)
+    def make_pane(cwd: nil, id: nil)
+      Pane.new(id: id, rows: 24, cols: 80, cwd: cwd)
     end
 
-    def ensure_drawer
+    def ensure_drawer(command: nil)
       return if @session.drawer
       cwd = focused_pane&.cwd
-      pane = Pane.new(id: :drawer, rows: 10, cols: 80, cwd: cwd)
-      @session.drawer = Drawer.new(pane: pane, origin_cwd: cwd)
+      pane = Pane.new(
+        id: :drawer,
+        rows: 10,
+        cols: 80,
+        cwd: cwd,
+        command: command,
+        env_overrides: drawer_env
+      )
+      @session.drawer = Drawer.new(pane: pane, origin_cwd: cwd, command: command)
+    end
+
+    # Toggle the drawer; if a different kind is currently up, tear it down
+    # and replace it with the requested kind. Keeps the drawer slot a single
+    # PTY so users don't end up with a confusing menagerie of overlays.
+    def toggle_drawer_kind(command:)
+      current = @session.drawer
+      if current.nil?
+        ensure_drawer(command: command)
+        @session.drawer.show!
+        @session.focus_drawer = true
+      elsif current.command == command
+        current.toggle!
+        @session.focus_drawer = current.visible?
+      else
+        current.close
+        @session.drawer = nil
+        ensure_drawer(command: command)
+        @session.drawer.show!
+        @session.focus_drawer = true
+      end
+      renderer.reset_frame!
+      invalidate
     end
 
-    def restore_panes_if_saved
-      data = Session.load(@session_name)
+    # Env vars exposed to every drawer PTY. The MCP bridge reads these to
+    # auto-connect to the right session; MUXR_DRAWER_SELF lets it refuse
+    # drawer.* methods so a claude drawer can't recurse into its own PTY.
+    def drawer_env
+      env = {
+        "MUXR_SESSION"        => @session_name.to_s,
+        "MUXR_CONTROL_SOCKET" => @control_socket_path.to_s,
+        "MUXR_DRAWER_SELF"    => "1"
+      }
+      focused = focused_pane
+      env["MUXR_FOCUSED_PANE"] = focused.id.to_s if focused&.id.is_a?(String)
+      env
+    end
+
+    def restore_panes_if_saved(data)
       return unless data
 
       if data["layout"] && Window::LAYOUTS.include?(data["layout"].to_sym)
@@ -714,15 +868,30 @@ module Muxr
       end
 
       panes_data = data["panes"] || []
+      # Restore privacy flag for the already-created first pane.
+      if panes_data[0] && panes_data[0]["private"] && @session.window.panes[0]
+        @session.window.panes[0].mark_private!
+      end
       panes_data[1..]&.each do |entry|
         cwd = entry["cwd"]
-        @session.window.add_pane(make_pane(cwd: cwd))
+        id  = entry["id"]
+        pane = make_pane(cwd: cwd, id: id)
+        pane.mark_private! if entry["private"]
+        @session.window.add_pane(pane)
       end
 
       if data["drawer"]
         cwd = data["drawer"]["cwd"]
-        pane = Pane.new(id: :drawer, rows: 10, cols: 80, cwd: cwd)
-        drawer = Drawer.new(pane: pane, origin_cwd: cwd)
+        command = data["drawer"]["command"]
+        pane = Pane.new(
+          id: :drawer,
+          rows: 10,
+          cols: 80,
+          cwd: cwd,
+          command: command,
+          env_overrides: drawer_env
+        )
+        drawer = Drawer.new(pane: pane, origin_cwd: cwd, command: command)
         drawer.visible = !!data["drawer"]["visible"]
         @session.drawer = drawer
         @session.focus_drawer = drawer.visible?

data/lib/muxr/command_dispatcher.rb

@@ -16,6 +16,8 @@ module Muxr
       case cmd
       when "layout"  then handle_layout(args)
       when "drawer"  then handle_drawer(args)
+      when "claude"  then @app.toggle_claude_drawer
+      when "private" then @app.toggle_private_focused
       when "save"    then @app.save_session
       when "restore" then @app.restore_session
       when "sessions", "ls" then @app.list_sessions