muxr 0.1.10 → 0.2.0

data/bin/muxr

@@ -7,6 +7,10 @@ require "fileutils"
 require "rbconfig"
 require "socket"
 
+def configured_prefix_letter
+  Muxr::Renderer.prefix_letter(Muxr::Config.load.prefix)
+end
+
 if ARGV.include?("-v") || ARGV.include?("--version")
   puts "muxr #{Muxr::VERSION}"
   exit 0
@@ -18,27 +22,31 @@ if ARGV.include?("-l") || ARGV.include?("--list")
   exit 0
 end
 
-if ARGV.include?("--install-skill")
-  # Copies skills/muxr-control into ~/.claude/skills/muxr-control so the
-  # claude CLI loads it from anywhere. We *copy* rather than symlink so the
-  # install survives a RubyGems upgrade (which deletes the old versioned
-  # gem path that a symlink would have pointed at). Idempotent: re-running
-  # this after a `gem update muxr` is the supported way to refresh the
-  # skill content.
+install_skill_arg = ARGV.find { |a| a == "--install-skill" || a.start_with?("--install-skill=") }
+
+if install_skill_arg
+  requested_strategy = install_skill_arg.split("=", 2)[1]
+  unless [nil, "copy", "link"].include?(requested_strategy)
+    $stderr.puts "muxr: --install-skill takes `copy` or `link` (got #{requested_strategy.inspect})"
+    exit 1
+  end
   src = File.expand_path("../skills/muxr-control", __dir__)
   unless File.directory?(src)
     $stderr.puts "muxr: skill source not found at #{src} (was the gem packaged without skills/?)"
     exit 1
   end
+  running_from_source_checkout = File.directory?(File.expand_path("../.git", __dir__))
+  strategy = requested_strategy || (running_from_source_checkout ? "link" : "copy")
   claude_skills = File.expand_path("~/.claude/skills")
   dst = File.join(claude_skills, "muxr-control")
   FileUtils.mkdir_p(claude_skills)
-  # Wipe any prior install — symlink (from older dev installs) or directory.
-  if File.symlink?(dst) || File.exist?(dst)
-    FileUtils.rm_rf(dst)
+  FileUtils.rm_rf(dst) if File.symlink?(dst) || File.exist?(dst)
+  if strategy == "link"
+    FileUtils.ln_s(src, dst)
+  else
+    FileUtils.mkdir_p(dst)
+    FileUtils.cp_r(File.join(src, "."), dst)
   end
-  FileUtils.mkdir_p(dst)
-  FileUtils.cp_r(File.join(src, "."), dst)
 
   # Pick the most stable absolute path we can point claude's mcp config at:
   #
@@ -49,13 +57,31 @@ if ARGV.include?("--install-skill")
   #    sits next to the running `muxr` binary.
   bin_stub = File.join(Gem.bindir, "muxr-mcp") rescue nil
   bridge = (bin_stub && File.exist?(bin_stub)) ? bin_stub : File.expand_path("muxr-mcp", __dir__)
+  puts(
+    if strategy == "link"
+      <<~LINKED
+        ✓ Linked skill: #{dst}
+                     -> #{src}
+
+        Edits to the skill are live in new claude sessions with no re-run.
+        Force a copy instead with `muxr --install-skill=copy`.
+      LINKED
+    else
+      <<~COPIED
+        ✓ Copied skill to: #{dst}
+          (source: #{src})
+
+        Re-run `muxr --install-skill` after `gem update muxr` to refresh the
+        skill contents. An installed gem is copied rather than linked because
+        RubyGems prunes the old versioned gem directory on upgrade, which
+        would leave a symlink dangling. If you know this path is stable, force
+        a symlink with `muxr --install-skill=link`.
+      COPIED
+    end
+  )
+  puts
+  letter = configured_prefix_letter
   puts <<~MSG
-    ✓ Copied skill to: #{dst}
-      (source: #{src})
-
-    Re-run `muxr --install-skill` after `gem update muxr` to refresh the
-    skill contents.
-
     Next, register the muxr MCP bridge with Claude Code at USER scope
     (so every claude session sees it, not just ones started from your
     home directory):
@@ -71,35 +97,44 @@ if ARGV.include?("--install-skill")
         claude mcp add muxr muxr-mcp --scope user
 
     Then restart any running Claude Code sessions so they pick up the new
-    config, and launch claude from inside a muxr drawer (Ctrl-a C) — the
-    bridge auto-detects the session via MUXR_SESSION / MUXR_CONTROL_SOCKET.
+    config. Any claude you launch from inside muxr — a tiled pane or the
+    Claude drawer (Ctrl-#{letter} C) — auto-detects its session via MUXR_SESSION /
+    MUXR_CONTROL_SOCKET, which muxr injects into every PTY it spawns.
+    Outside muxr the bridge stays quiet and offers no tools.
+
+    Panes that were already running before this install won't have those
+    vars — open a new pane (Ctrl-#{letter} c) to pick them up.
   MSG
   exit 0
 end
 
 if ARGV.include?("-h") || ARGV.include?("--help")
+  letter = configured_prefix_letter
+  source = letter == "a" ? "" : ", from #{Muxr::Config.path_from_env.sub(Dir.home, "~")}"
   puts <<~USAGE
     muxr #{Muxr::VERSION} — a tiling terminal multiplexer
 
     Usage:
-      muxr                 attach the default session (auto-spawn if needed)
+      muxr                 attach the session for the current directory (auto-spawn if needed)
       muxr <name>          attach (or start) the named session
       muxr -s <name>       same as above
       muxr --list          list running sessions and exit
-      muxr --install-skill symlink the MCP skill into ~/.claude/skills and exit
+      muxr --install-skill install the MCP skill into ~/.claude/skills and exit
+                           (symlinks from a source checkout, copies from an
+                            installed gem; force with --install-skill=copy|link)
       muxr --version       print version and exit
       muxr --help          this help
 
-    Keybindings (Ctrl-a prefix):
-      C-a c   new pane            C-a n / p   next / prev pane
-      C-a a   toggle last pane    C-a 1..9    jump to pane by number
-      C-a k   close pane          C-a Tab     cycle layout
-      C-a ~   toggle drawer       C-a Enter   promote to master
-      C-a C   Claude drawer       (MCP-aware; needs `muxr --install-skill` + bridge configured)
-      C-a :   command prompt      C-a ?       toggle help
-      C-a d   detach (server stays running)
-      C-a q   kill session (with y/n confirmation)
-      C-a C-a send literal C-a
+    Keybindings (Ctrl-#{letter} prefix#{source}):
+      C-#{letter} c   new pane            C-#{letter} n / p   next / prev pane
+      C-#{letter} a   toggle last pane    C-#{letter} 1..9    jump to pane by number
+      C-#{letter} x   close pane          C-#{letter} Tab     cycle layout
+      C-#{letter} ~   toggle drawer       C-#{letter} Enter   promote to master
+      C-#{letter} C   Claude drawer       (as is claude in any pane; needs `muxr --install-skill`)
+      C-#{letter} :   command prompt      C-#{letter} ?       toggle help
+      C-#{letter} d   detach (server stays running)
+      C-#{letter} q   kill session (with y/n confirmation)
+      C-#{letter} C-#{letter} send literal C-#{letter}
   USAGE
   exit 0
 end
@@ -131,7 +166,7 @@ end
 def session_name_from(argv)
   idx = argv.index("-s") || argv.index("--session")
   return argv[idx + 1] if idx && argv[idx + 1]
-  argv.find { |a| !a.start_with?("-") } || "default"
+  argv.find { |a| !a.start_with?("-") } || Muxr::Application.default_session_name
 end
 
 def probe_socket(path)

data/bin/muxr-mcp

@@ -9,10 +9,15 @@
 #
 #   1. $MUXR_CONTROL_SOCKET (absolute path) — exact override
 #   2. $MUXR_SESSION (session name)         — resolved to standard path
-#   3. otherwise: error
+#   3. whichever live session lists $MUXR_PANE as a pane it owns, when the
+#      two above name a session that no longer has us (see below)
+#   4. otherwise: no tools, and an explanatory error if called anyway
 #
-# Both env vars are injected automatically when claude is launched from the
-# muxr Claude-drawer (Ctrl-a C), so end users almost never set them by hand.
+# muxr injects all three vars into every PTY it spawns, so end users never set
+# them by hand. They are a snapshot of where the pane was when its shell
+# started, which is why (3) exists: a pane can be moved to another session
+# while its shell keeps running, and a running process's environment cannot
+# be rewritten from outside.
 #
 # Typical claude-code mcp config:
 #
@@ -63,7 +68,7 @@ class MuxrMcpBridge
   # ids from muxr_panes_list.
   PANE_REF = {
     "type" => "string",
-    "description" => "Stable 6-hex pane id from muxr_panes_list (e.g. \"a3f9b2\"). Ids survive splits, kills, and promote_to_master — always prefer them over the positional slot numbers shown in the status bar."
+    "description" => "Stable 6-hex pane id from muxr_panes_list (e.g. \"a3f9b2\"), or the name the human gave the pane with :rename (e.g. \"api\"). Ids survive splits, kills, and promote_to_master — always prefer them over the positional slot numbers shown in the status bar."
   }.freeze
 
   TOOL_SCHEMAS = [
@@ -238,15 +243,22 @@ class MuxrMcpBridge
     }
   ].freeze
 
+  SELF_FORBIDDEN_PANE_METHODS = ["pane.read", "pane.send_input", "pane.run", "pane.kill"].freeze
+
+  DEFAULT_SOCKETS_DIR = File.join(Dir.home, ".muxr", "sockets")
+  DISCOVERY_TIMEOUT   = 0.5
+  OWNERSHIP_TTL       = 10.0
+
   def initialize
     @socket = nil
     @next_request_id = 0
     @read_buffer = +""
     @in_drawer = ENV["MUXR_DRAWER_SELF"] == "1"
+    @own_pane = ENV["MUXR_PANE"].to_s
+    @verified_at = nil
   end
 
   def run
-    connect_to_muxr
     loop do
       line = $stdin.gets
       break if line.nil?
@@ -280,7 +292,7 @@ class MuxrMcpBridge
     when "initialized", "notifications/initialized"
       # notification, no reply
     when "tools/list"
-      respond(id, { "tools" => TOOL_SCHEMAS })
+      respond(id, { "tools" => session_reachable? ? TOOL_SCHEMAS : [] })
     when "tools/call"
       handle_tool_call(id, params)
     when "ping"
@@ -310,6 +322,17 @@ class MuxrMcpBridge
       return
     end
 
+    unless ensure_owning_connection
+      respond_tool_error(id, connection_error)
+      return
+    end
+
+    if targets_own_pane?(muxr_method, args)
+      respond_tool_error(id, "#{muxr_method} is unavailable on pane #{@own_pane} — that is the pane this claude " \
+                             "session is running in. Use muxr_panes_list to pick a different pane.")
+      return
+    end
+
     response = send_muxr_request(muxr_method, args)
     if response.nil?
       respond_tool_error(id, "muxr server closed the connection")
@@ -329,7 +352,7 @@ class MuxrMcpBridge
   # Send one NDJSON request to the muxr control socket and block until the
   # response with the matching id arrives. Server-pushed events (no id, or
   # id mismatch) are silently dropped — the v1 bridge doesn't forward them.
-  def send_muxr_request(method, params)
+  def send_muxr_request(method, params, retrying: false)
     @next_request_id += 1
     rid = @next_request_id
     payload = JSON.generate({ "id" => rid, "method" => method, "params" => params }) + "\n"
@@ -337,11 +360,22 @@ class MuxrMcpBridge
 
     loop do
       line = read_muxr_line
-      return nil unless line  # EOF
+      break unless line
       msg = JSON.parse(line)
       next unless msg["id"] == rid
       return msg
     end
+
+    reconnect_and_retry(method, params, retrying: retrying)
+  rescue SystemCallError, IOError
+    reconnect_and_retry(method, params, retrying: retrying)
+  end
+
+  def reconnect_and_retry(method, params, retrying:)
+    drop_connection
+    return nil if retrying
+    return nil unless ensure_connection
+    send_muxr_request(method, params, retrying: true)
   end
 
   # Line-oriented read on the muxr socket. Reads in chunks and emits one
@@ -360,17 +394,139 @@ class MuxrMcpBridge
     nil
   end
 
-  def connect_to_muxr
-    path = ENV["MUXR_CONTROL_SOCKET"] || derive_socket_from_session
-    if path.nil? || path.empty?
-      die("set MUXR_CONTROL_SOCKET to the path of the muxr control socket, " \
-          "or MUXR_SESSION to the session name (the drawer-launched claude sets these for you).")
+  def targets_own_pane?(muxr_method, args)
+    return false if @own_pane.empty?
+    return false unless SELF_FORBIDDEN_PANE_METHODS.include?(muxr_method)
+    ref = args["pane"].to_s
+    ref == @own_pane || names_own_pane?(ref)
+  end
+
+  def names_own_pane?(ref)
+    panes = send_muxr_request("panes.list", {})&.dig("result", "panes") || []
+    return false if panes.any? { |pane| pane["id"].to_s == ref }
+    panes.any? { |pane| pane["id"].to_s == @own_pane && pane["name"] == ref }
+  end
+
+  def control_socket_path
+    path = ENV["MUXR_CONTROL_SOCKET"]
+    path = derive_socket_from_session if path.nil? || path.empty?
+    path
+  end
+
+  def env_socket_path
+    path = control_socket_path
+    return nil if path.nil? || path.empty? || !File.exist?(path)
+    path
+  end
+
+  def resolve_control_socket
+    env_path = env_socket_path
+    return env_path if @own_pane.empty?
+    return env_path if env_path && socket_owns_own_pane?(env_path)
+    discover_owning_socket(skip: env_path) || env_path
+  end
+
+  def sockets_dir
+    path = control_socket_path
+    return DEFAULT_SOCKETS_DIR if path.nil? || path.empty?
+    File.dirname(path)
+  end
+
+  def discover_owning_socket(skip: nil)
+    dir = sockets_dir
+    return nil unless File.directory?(dir)
+    Dir.glob(File.join(dir, "*.ctrl.sock")).sort.find do |path|
+      next false if path == skip
+      socket_owns_own_pane?(path)
     end
-    unless File.exist?(path)
-      die("muxr control socket not found at #{path} — is the server running? " \
-          "Start it with `muxr <session>`.")
+  end
+
+  def socket_owns_own_pane?(path)
+    sock = UNIXSocket.new(path)
+    sock.write(JSON.generate("id" => 1, "method" => "panes.list", "params" => {}) + "\n")
+    deadline = monotonic + DISCOVERY_TIMEOUT
+    buffer = +""
+    loop do
+      remaining = deadline - monotonic
+      return false if remaining <= 0
+      return false unless IO.select([sock], nil, nil, remaining)
+      buffer << sock.readpartial(64 * 1024)
+      while (nl = buffer.index("\n"))
+        line = buffer.slice!(0..nl)
+        msg = JSON.parse(line) rescue nil
+        next unless msg && msg["id"] == 1
+        return owns_own_pane?(msg["result"])
+      end
+    end
+  rescue SystemCallError, IOError, EOFError
+    false
+  ensure
+    sock&.close rescue nil
+  end
+
+  def owns_own_pane?(result)
+    panes = result.is_a?(Hash) ? result["panes"] : nil
+    return false unless panes.is_a?(Array)
+    panes.any? { |pane| pane["id"].to_s == @own_pane && !mirror?(pane) }
+  end
+
+  def mirror?(pane)
+    !pane["origin"].nil?
+  end
+
+  def monotonic
+    Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  end
+
+  def session_reachable?
+    !resolve_control_socket.nil?
+  end
+
+  def connection_error
+    path = control_socket_path
+    if path.nil? || path.empty?
+      "not running inside muxr — no MUXR_CONTROL_SOCKET or MUXR_SESSION in the environment. " \
+        "Start a pane with `muxr <session>` and run claude from inside it."
+    elsif @own_pane.empty?
+      "muxr control socket not found at #{path} — is the server running? Start it with `muxr <session>`."
+    else
+      "no live muxr session owns pane #{@own_pane} (#{path} is gone, and no other session claims it) — " \
+        "is the server running? Start it with `muxr <session>`."
     end
+  end
+
+  def ensure_connection
+    return true if @socket && !@socket.closed?
+    path = resolve_control_socket
+    return false if path.nil?
     @socket = UNIXSocket.new(path)
+    @read_buffer.clear
+    @verified_at = monotonic
+    true
+  rescue SystemCallError, IOError
+    @socket = nil
+    false
+  end
+
+  def ensure_owning_connection
+    return false unless ensure_connection
+    return true if @own_pane.empty?
+    return true if @verified_at && monotonic - @verified_at < OWNERSHIP_TTL
+
+    if owns_own_pane?(send_muxr_request("panes.list", {})&.fetch("result", nil))
+      @verified_at = monotonic
+      return true
+    end
+
+    drop_connection
+    ensure_connection
+  end
+
+  def drop_connection
+    @socket&.close rescue nil
+    @socket = nil
+    @read_buffer.clear
+    @verified_at = nil
   end
 
   def derive_socket_from_session