mxup 0.2.0

data/lib/mxup/launcher.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'shellwords'
+
+module Mxup
+  # Generates and manages per-window launcher scripts.
+  #
+  # Each declared window with non-trivial content (setup snippet, wait_for,
+  # env vars, or a command) gets a launcher script at
+  #   ~/.local/share/mxup/<session>/<window>_launcher.sh
+  #
+  # The keys sent to tmux are simply ". <path>", so we can rewrite the script
+  # on every `mxup up` without having to re-send anything to healthy panes.
+  class Launcher
+    def initialize(config, runtime_root: RUNTIME_DIR)
+      @config       = config
+      @runtime_root = runtime_root
+    end
+
+    def session_runtime_dir
+      File.join(@runtime_root, @config.session)
+    end
+
+    def script_path(window_name)
+      File.join(session_runtime_dir, "#{window_name}_launcher.sh")
+    end
+
+    # Returns the shell keys to send to a fresh pane for this window. Empty
+    # string for a window that has nothing to execute (bare interactive shell).
+    def command_for(window)
+      content?(window) ? ". #{script_path(window.name)}" : ''
+    end
+
+    # Materialise launcher scripts for every window that needs one. Safe to
+    # call repeatedly; overwrites existing files.
+    def write_all
+      FileUtils.mkdir_p(session_runtime_dir)
+      @config.windows.each do |win|
+        next unless content?(win)
+        path = script_path(win.name)
+        File.write(path, build_script(win))
+        File.chmod(0o755, path)
+      end
+    end
+
+    def cleanup
+      dir = session_runtime_dir
+      FileUtils.rm_rf(dir) if Dir.exist?(dir)
+    end
+
+    # Build (but don't write) the shell text for a window's launcher script.
+    # Exposed for inspection/tests; production callers use #write_all.
+    def build_script(window)
+      sections = []
+      sections << "# mxup launcher for #{window.name}"
+      sections << "cd #{Shellwords.escape(window.root)}"
+
+      if @config.setup && !@config.setup.empty?
+        sections << ''
+        @config.setup.split("\n").each { |l| sections << l }
+      end
+
+      if window.wait_for
+        sections << ''
+        sections.concat(build_wait_block(window.wait_for))
+      end
+
+      if window.env.any?
+        sections << ''
+        window.env.each { |k, v| sections << "export #{k}=#{Shellwords.escape(v)}" }
+      end
+
+      if window.command && !window.command.empty?
+        sections << ''
+        sections << window.command
+      end
+
+      sections.join("\n") + "\n"
+    end
+
+    # Shell snippet (array of lines) implementing a wait_for check.
+    def build_wait_block(spec)
+      check = probe_for(spec)
+      lines = []
+      lines << "echo 'Waiting for #{spec.label}...'"
+      lines << "_mxup_wait_start=$(date +%s)"
+      lines << ''
+
+      if spec.timeout
+        lines << "until #{check}; do"
+        lines << "  _mxup_elapsed=$(($(date +%s) - _mxup_wait_start))"
+        lines << "  if [ \"$_mxup_elapsed\" -ge #{spec.timeout.to_i} ]; then"
+        lines << "    echo 'Timed out waiting for #{spec.label} after #{spec.timeout.to_i}s' >&2"
+        lines << '    break'
+        lines << '  fi'
+        lines << "  echo \"  still waiting... (${_mxup_elapsed}s of #{spec.timeout.to_i}s)\""
+        lines << "  sleep #{spec.interval}"
+        lines << 'done'
+      else
+        lines << "until #{check}; do"
+        lines << "  echo \"  still waiting... ($(($(date +%s) - _mxup_wait_start))s)\""
+        lines << "  sleep #{spec.interval}"
+        lines << 'done'
+      end
+
+      lines << ''
+      lines << "echo '#{spec.label} is ready.'"
+      lines
+    end
+
+    private
+
+    def content?(window)
+      (@config.setup && !@config.setup.empty?) ||
+        window.wait_for ||
+        window.env.any? ||
+        (window.command && !window.command.empty?)
+    end
+
+    def probe_for(spec)
+      case spec.type
+      when :tcp
+        host, port = spec.target.split(':', 2)
+        "nc -z #{host} #{port} 2>/dev/null"
+      when :http
+        "curl -sf #{Shellwords.escape(spec.target)} >/dev/null 2>&1"
+      when :path
+        "[ -e #{Shellwords.escape(spec.target)} ]"
+      when :script
+        spec.target
+      end
+    end
+  end
+end

data/lib/mxup/layout_manager.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Mxup
+  # Applies / switches tmux layouts without killing processes.
+  #
+  # switch_layout is a three-step operation:
+  #   1. Flatten any multi-pane windows back to standalone windows (break-pane)
+  #   2. Re-group windows per the target layout (join-pane + select-layout)
+  #   3. Reorder the windows to match config order
+  class LayoutManager
+    def initialize(config, session: config.session, dry_run: false,
+                   resolver: PaneResolver.new(config, session: session),
+                   out: nil)
+      @config       = config
+      @session      = session
+      @dry_run      = dry_run
+      @resolver     = resolver
+      @out_override = out
+    end
+
+    def out
+      @out_override || $stdout
+    end
+
+    def show(active: @resolver.stored_layout)
+      if @config.layout_names.empty?
+        out.puts 'No layouts defined in config.'
+        return
+      end
+
+      out.puts 'Available layouts:'
+      @config.layout_names.each do |name|
+        marker = name == active ? ' (active)' : ''
+        groups = @config.groups_for(name)
+        if groups.empty?
+          out.puts "  #{name}#{marker}: flat (all standalone)"
+        else
+          desc = groups.map { |g| "#{g.name}=[#{g.window_names.join(',')}]" }.join(', ')
+          out.puts "  #{name}#{marker}: #{desc}"
+        end
+      end
+    end
+
+    def switch(target_layout)
+      unless Tmux.has_session?(@session)
+        abort "Session #{@session} is not running."
+      end
+      unless @config.layout_names.include?(target_layout)
+        abort "Layout '#{target_layout}' not found in config. " \
+              "Available: #{@config.layout_names.join(', ')}"
+      end
+
+      current = @resolver.stored_layout
+      if current == target_layout
+        out.puts "Already using layout '#{target_layout}'."
+        return
+      end
+
+      if @dry_run
+        out.puts "[dry-run] Would switch layout from '#{current}' to '#{target_layout}'"
+        return
+      end
+
+      out.puts "Switching layout: #{current || 'none'} → #{target_layout}..."
+      flatten_to_standalone
+      apply(target_layout)
+      reorder(target_layout)
+      Tmux.set_environment(@session, 'MXUP_LAYOUT', target_layout)
+      out.puts "Layout switched to '#{target_layout}'."
+    end
+
+    # Collapse every multi-pane window into individual standalone windows.
+    # Run before applying a new layout to start from a clean state.
+    def flatten_to_standalone
+      multi = Tmux.list_panes(@session)
+                  .group_by { |p| p[:name] }
+                  .select   { |_, ps| ps.size > 1 }
+
+      multi.each do |win_name, panes|
+        sorted = panes.sort_by { |p| p[:pane_index] }.reverse
+
+        sorted.each do |pane|
+          next if pane[:pane_index].zero?
+          logical = pane[:title].to_s.empty? \
+            ? "#{win_name}_#{pane[:pane_index]}" \
+            : pane[:title]
+          Tmux.break_pane(@session, win_name, pane[:pane_index], logical)
+        end
+
+        first = sorted.last
+        first_logical = first[:title].to_s.empty? ? win_name : first[:title]
+        Tmux.rename_window(@session, win_name, first_logical) if first_logical != win_name
+      end
+    end
+
+    # Apply a named layout to a session whose windows are currently all standalone.
+    def apply(layout_name)
+      groups = @config.groups_for(layout_name)
+
+      groups.each do |group|
+        next if group.window_names.size < 2
+
+        first_wn = group.window_names.first
+        Tmux.rename_window(@session, first_wn, group.name)
+
+        group.window_names.drop(1).each do |wn|
+          Tmux.join_pane(@session, wn, group.name)
+        end
+
+        group.window_names.each_with_index do |wn, idx|
+          Tmux.set_pane_title(@session, group.name, idx, wn)
+        end
+        Tmux.select_layout(@session, group.name, group.split)
+      end
+
+      # Single-window "groups" still get their window renamed to the group name
+      # so that subsequent lookups (status, target) find them.
+      groups.select { |g| g.window_names.size == 1 }.each do |group|
+        wn = group.window_names.first
+        Tmux.rename_window(@session, wn, group.name)
+        Tmux.set_pane_title(@session, group.name, 0, wn)
+      end
+    end
+
+    # Move windows so their tmux indices match the order declared in config.
+    # Two-phase to avoid collisions: first park everyone in a high-index scratch
+    # zone, then move them into their final slots.
+    def reorder(layout_name = @resolver.active_layout)
+      return if @dry_run
+
+      order = @config.effective_window_order(layout_name)
+      names = order.map { |e| e[:name] }
+
+      names.each_with_index do |name, i|
+        cur = Tmux.list_windows(@session).find { |w| w[:name] == name }
+        next unless cur
+        Tmux.move_window(@session, name, 900 + i)
+      end
+
+      names.each_with_index do |name, target_idx|
+        Tmux.move_window(@session, name, target_idx)
+      end
+    end
+  end
+end

data/lib/mxup/pane_resolver.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Mxup
+  # Answers the question "where is the logical window <foo> actually living
+  # in tmux right now?" given the config + active layout + live tmux state.
+  #
+  # Separating this from Runner means Reconciler, LayoutManager, ExecRunner,
+  # StatusView and Target can all share a single source of truth.
+  class PaneResolver
+    def initialize(config, session: config.session, layout_override: nil)
+      @config          = config
+      @session         = session
+      @layout_override = layout_override
+    end
+
+    # The layout the caller asked for, or the one persisted in the session's
+    # tmux environment, or the config's default. May be nil if no layouts at all.
+    def active_layout
+      return @layout_override if @layout_override
+      Tmux.has_session?(@session) ? stored_layout : @config.default_layout
+    end
+
+    # Same as #active_layout but ignores any --layout override — used when we
+    # need to know what's really in the session right now (e.g. to decide
+    # whether a layout switch is needed).
+    def stored_layout
+      if Tmux.has_session?(@session)
+        stored = Tmux.show_environment(@session, 'MXUP_LAYOUT')
+        return stored if stored && @config.layout_names.include?(stored)
+      end
+      @config.default_layout
+    end
+
+    # Resolve a logical window name to a tmux target string (either "window"
+    # for a standalone, or "group.pane_index" for a grouped window). Returns
+    # nil if the window isn't currently in the session.
+    def pane_target(window_name, layout = active_layout)
+      result = @config.find_group_for_window(layout, window_name)
+
+      if result
+        group, cfg_idx = result
+        return nil unless window_exists?(group.name)
+
+        pane = Tmux.list_panes(@session)
+                   .find { |p| p[:name] == group.name && p[:title] == window_name }
+        actual_idx = pane ? pane[:pane_index] : cfg_idx
+        Tmux.pane_target(group.name, actual_idx)
+      else
+        window_exists?(window_name) ? window_name : nil
+      end
+    end
+
+    # Look up the pane metadata hash for an already-resolved tmux target.
+    def pane_for(target)
+      if target =~ /\A(.+)\.(\d+)\z/
+        win_name = Regexp.last_match(1)
+        pane_idx = Regexp.last_match(2).to_i
+        Tmux.list_panes(@session)
+            .find { |p| p[:name] == win_name && p[:pane_index] == pane_idx }
+      else
+        Tmux.list_panes(@session)
+            .find { |p| p[:name] == target && p[:pane_index] == 0 }
+      end
+    end
+
+    def window_exists?(name)
+      Tmux.list_windows(@session).any? { |w| w[:name] == name }
+    end
+  end
+end

data/lib/mxup/process_probe.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Mxup
+  # Walks the process tree from a pane PID down to the interesting leaf, and
+  # reads `ps` fields from an arbitrary pid. Used by StatusView to show the
+  # actual command the user cares about (not the `zsh -c` wrapping it).
+  module ProcessProbe
+    module_function
+
+    # Follow pgrep -P down the descendant tree until a leaf (no children) is
+    # reached. Falls back to the starting pid if pgrep is unavailable.
+    def leaf_pid(pid)
+      current = pid
+      loop do
+        child = `pgrep -P #{current} 2>/dev/null`.strip.split("\n").first
+        break if child.nil? || child.empty?
+        current = child.to_i
+      end
+      current
+    end
+
+    def ps_field(pid, field)
+      val = `ps -p #{pid} -o #{field}= 2>/dev/null`.strip
+      val.empty? ? nil : val
+    end
+  end
+end

data/lib/mxup/reconciler.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+module Mxup
+  # Drives `mxup up`: creates a session from scratch when missing, or brings
+  # the existing session in line with the config.
+  #
+  # Reconciliation rules:
+  #   - missing windows   → create + start command
+  #   - extra windows     → kill (with warning)
+  #   - idle/crashed      → re-send the command
+  #   - running healthy   → leave alone
+  #   - layout changed    → regroup panes without killing PIDs
+  class Reconciler
+    def initialize(config, launcher:, resolver:, layout_manager:,
+                   dry_run: false, out: nil, err: nil)
+      @config         = config
+      @session        = config.session
+      @launcher       = launcher
+      @resolver       = resolver
+      @layout_manager = layout_manager
+      @dry_run        = dry_run
+      @out_override   = out
+      @err_override   = err
+    end
+
+    def out
+      @out_override || $stdout
+    end
+
+    def err
+      @err_override || $stderr
+    end
+
+    def up
+      if Tmux.has_session?(@session)
+        reconcile
+      else
+        create_fresh
+      end
+    end
+
+    private
+
+    def create_fresh
+      out.puts "Creating session #{@session}..."
+      @launcher.write_all unless @dry_run
+
+      layout = @resolver.active_layout
+      order  = @config.effective_window_order(layout)
+
+      if @dry_run
+        order.each do |entry|
+          if entry[:type] == :group
+            names = entry[:group].window_names.join(', ')
+            out.puts "[dry-run] Would create pane group: #{entry[:name]} (#{names})"
+          else
+            out.puts "[dry-run] Would create window: #{entry[:name]}"
+          end
+        end
+        return
+      end
+
+      create_first_entry(order.first)
+      order.drop(1).each { |entry| create_entry(entry) }
+
+      Tmux.set_environment(@session, 'MXUP_LAYOUT', layout) if layout
+      Tmux.set_environment(@session, 'MXUP_PROFILE', @config.profile) if @config.profile
+      out.puts "Session #{@session} is up (#{@config.windows.size} windows)."
+    end
+
+    def create_first_entry(entry)
+      if entry[:type] == :group
+        group     = entry[:group]
+        first_win = @config.window_by_name(group.window_names.first)
+        Tmux.new_session(@session, group.name, first_win.root)
+        populate_pane_group_in_existing_window(group)
+        out.puts "  #{group.name}: created (#{group.window_names.join(', ')})"
+      else
+        win = @config.window_by_name(entry[:name])
+        Tmux.new_session(@session, win.name, win.root)
+        Tmux.set_pane_title(@session, win.name, 0, win.name)
+        Tmux.send_keys(@session, win.name, @launcher.command_for(win))
+        out.puts "  #{win.name}: created"
+      end
+    end
+
+    def create_entry(entry)
+      if entry[:type] == :group
+        create_pane_group(entry[:group])
+        out.puts "  #{entry[:name]}: created (#{entry[:group].window_names.join(', ')})"
+      else
+        win = @config.window_by_name(entry[:name])
+        create_standalone(win)
+        out.puts "  #{win.name}: created"
+      end
+    end
+
+    def reconcile
+      out.puts "Reconciling session #{@session}..."
+      @launcher.write_all unless @dry_run
+
+      layout = @resolver.active_layout
+      stored = Tmux.show_environment(@session, 'MXUP_LAYOUT')
+
+      @layout_manager.switch(layout) if layout && stored && stored != layout
+
+      existing_panes   = Tmux.list_panes(@session)
+      existing_windows = Tmux.list_windows(@session).map { |w| w[:name] }
+      order            = @config.effective_window_order(layout)
+
+      remove_extras(existing_windows, order)
+      order.each { |entry| reconcile_entry(entry, existing_panes, existing_windows) }
+
+      @layout_manager.reorder(layout) unless @dry_run
+      Tmux.set_environment(@session, 'MXUP_LAYOUT', layout) if layout && !@dry_run
+      Tmux.set_environment(@session, 'MXUP_PROFILE', @config.profile) if @config.profile && !@dry_run
+      out.puts 'Reconciliation complete.'
+    end
+
+    def remove_extras(existing_windows, order)
+      expected = order.map { |e| e[:name] }.to_set
+      existing_windows.reject { |n| expected.include?(n) }.each do |name|
+        if @dry_run
+          out.puts "  [dry-run] Would remove extra window: #{name}"
+        else
+          err.puts "  #{name}: not in config — removing"
+          Tmux.kill_window(@session, name)
+        end
+      end
+    end
+
+    def reconcile_entry(entry, panes, windows)
+      if entry[:type] == :group
+        reconcile_group(entry[:group], panes, windows)
+      else
+        reconcile_standalone(entry[:name], panes)
+      end
+    end
+
+    def reconcile_group(group, panes, windows)
+      unless windows.include?(group.name)
+        if @dry_run
+          out.puts "  [dry-run] Would create pane group: #{group.name}"
+        else
+          create_pane_group(group)
+          out.puts "  #{group.name}: created (#{group.window_names.join(', ')})"
+        end
+        return
+      end
+
+      expected = group.window_names.size
+      current  = Tmux.pane_count(@session, group.name)
+      if current != expected
+        if @dry_run
+          out.puts "  [dry-run] Would recreate pane group: #{group.name} " \
+                    "(pane count #{current} != #{expected})"
+        else
+          Tmux.kill_window(@session, group.name)
+          create_pane_group(group)
+          out.puts "  #{group.name}: recreated (pane count changed)"
+        end
+        return
+      end
+
+      group_panes = panes.select { |p| p[:name] == group.name }
+                         .sort_by { |p| p[:pane_index] }
+
+      group.window_names.each_with_index do |wn, idx|
+        win  = @config.window_by_name(wn)
+        pane = group_panes.find { |p| p[:title] == wn } ||
+               group_panes.find { |p| p[:pane_index] == idx }
+        next unless pane
+
+        actual_idx = pane[:pane_index]
+        target     = Tmux.pane_target(group.name, actual_idx)
+
+        if SHELLS.include?(pane[:fg_cmd])
+          if @dry_run
+            out.puts "  [dry-run] Would restart idle pane: #{wn} in #{group.name}"
+          else
+            Tmux.send_keys(@session, target, @launcher.command_for(win))
+            out.puts "  #{wn}: restarted (was idle) [#{group.name}.#{actual_idx}]"
+          end
+        else
+          out.puts "  #{wn}: running (#{pane[:fg_cmd]}) — ok [#{group.name}.#{actual_idx}]"
+        end
+      end
+    end
+
+    def reconcile_standalone(window_name, panes)
+      win  = @config.window_by_name(window_name)
+      pane = panes.find { |p| p[:name] == window_name }
+
+      if pane.nil?
+        if @dry_run
+          out.puts "  [dry-run] Would create missing window: #{window_name}"
+        else
+          create_standalone(win)
+          out.puts "  #{window_name}: created (was missing)"
+        end
+      elsif SHELLS.include?(pane[:fg_cmd])
+        if @dry_run
+          out.puts "  [dry-run] Would restart idle window: #{window_name}"
+        else
+          Tmux.send_keys(@session, window_name, @launcher.command_for(win))
+          out.puts "  #{window_name}: restarted (was idle)"
+        end
+      else
+        out.puts "  #{window_name}: running (#{pane[:fg_cmd]}) — ok"
+      end
+    end
+
+    def create_pane_group(group)
+      first_win = @config.window_by_name(group.window_names.first)
+      Tmux.new_window(@session, group.name, first_win.root)
+      populate_pane_group_in_existing_window(group)
+    end
+
+    def populate_pane_group_in_existing_window(group)
+      group.window_names.drop(1).each_with_index do |wn, i|
+        win = @config.window_by_name(wn)
+        Tmux.split_window(@session, group.name, win.root, target_pane: i)
+      end
+
+      Tmux.select_layout(@session, group.name, group.split)
+
+      group.window_names.each_with_index do |wn, idx|
+        win = @config.window_by_name(wn)
+        Tmux.set_pane_title(@session, group.name, idx, win.name)
+        Tmux.send_keys(@session, Tmux.pane_target(group.name, idx), @launcher.command_for(win))
+      end
+    end
+
+    def create_standalone(win)
+      Tmux.new_window(@session, win.name, win.root)
+      Tmux.set_pane_title(@session, win.name, 0, win.name)
+      Tmux.send_keys(@session, win.name, @launcher.command_for(win))
+    end
+  end
+end