mxup 0.2.0 → 0.3.0

data/lib/mxup/status_view.rb

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
 
 require 'set'
+require 'json'
 
 module Mxup
   # Renders `mxup status` output.
   class StatusView
     INDENT = '    '
+    # Max length for the `command:` line in `mxup status` (long JVM -cp, etc.).
+    STATUS_COMMAND_MAX = 256
 
     def initialize(config, resolver:, out: nil)
       @config       = config
@@ -34,6 +37,7 @@ module Mxup
       bits << "layout: #{active}"             if active
       suffix       = bits.empty? ? '' : " (#{bits.join(', ')})"
       out.puts "SESSION: #{@session} — up since #{created_at}#{suffix}"
+      render_watcher_line
       out.puts
 
       panes           = Tmux.list_panes(@session)
@@ -54,6 +58,43 @@ module Mxup
 
     private
 
+    def render_watcher_line
+      return if @config.live_env.empty?
+
+      pid_path   = Watcher.pid_path(@session)
+      state_path = Watcher.state_path(@session)
+      pid        = File.exist?(pid_path) ? File.read(pid_path).strip.to_i : nil
+      alive      = pid && pid > 0 && watcher_alive?(pid)
+
+      if alive
+        count = @config.live_env.size
+        last  = last_restart_summary(state_path)
+        out.puts "watcher: pid #{pid} (#{count} command#{count == 1 ? '' : 's'}#{last})"
+      else
+        out.puts 'watcher: not running'
+      end
+    end
+
+    def watcher_alive?(pid)
+      Process.kill(0, pid)
+      true
+    rescue Errno::ESRCH, Errno::EPERM
+      false
+    end
+
+    def last_restart_summary(state_path)
+      return '' unless File.exist?(state_path)
+
+      data = JSON.parse(File.read(state_path))
+      last = data['last_restart'] || {}
+      return '' if last.empty?
+
+      win, ts = last.max_by { |_, v| v }
+      ", last restart #{win} at #{Time.at(ts).strftime('%H:%M:%S')}"
+    rescue StandardError
+      ''
+    end
+
     def render_group(group, panes, lines, printed)
       group_panes = panes.select { |p| p[:name] == group.name }
                          .sort_by { |p| p[:pane_index] }
@@ -139,11 +180,19 @@ module Mxup
     def running_status(pane, indent)
       leaf    = ProcessProbe.leaf_pid(pane[:pid])
       cmd     = ProcessProbe.ps_field(leaf, 'args') || pane[:fg_cmd]
+      cmd     = truncate_status_command(cmd)
       elapsed = ProcessProbe.ps_field(leaf, 'etime')&.strip || '?'
       started = ProcessProbe.ps_field(leaf, 'lstart') || '?'
       "RUNNING  pid=#{leaf}  elapsed=#{elapsed}  fg=#{pane[:fg_cmd]}\n" \
         "#{indent}command: #{cmd}\n" \
         "#{indent}started: #{started}"
     end
+
+    def truncate_status_command(str)
+      return str if str.nil? || str.empty?
+      return str if str.length <= STATUS_COMMAND_MAX
+
+      "#{str[0, STATUS_COMMAND_MAX - 3]}..."
+    end
   end
 end

data/lib/mxup/tmux.rb

@@ -7,6 +7,12 @@ module Mxup
   # knows about mxup's own config. Kept as a module so callers can reference
   # Mxup::Tmux.list_panes(...) without instantiating anything.
   module Tmux
+    # Raised when a tmux command that is expected to succeed exits non-zero.
+    # Carries tmux's own stderr so a failure surfaces with context (e.g. a
+    # "pane too small" split) at the point it happens, instead of as a
+    # confusing downstream error like "can't find pane 4".
+    class Error < StandardError; end
+
     module_function
 
     # --- inspection --------------------------------------------------------
@@ -54,26 +60,26 @@ module Mxup
     # --- mutation ----------------------------------------------------------
 
     def new_session(name, first_window_name, root)
-      system("tmux new-session -d -s #{esc(name)} -n #{esc(first_window_name)} -c #{esc(root)}")
+      run!('new-session', "tmux new-session -d -s #{esc(name)} -n #{esc(first_window_name)} -c #{esc(root)}")
     end
 
     def new_window(session, name, root)
-      system("tmux new-window -t #{esc(session)} -n #{esc(name)} -c #{esc(root)}")
+      run!('new-window', "tmux new-window -t #{esc(session)} -n #{esc(name)} -c #{esc(root)}")
     end
 
     def split_window(session, window, root, target_pane: nil)
       target = target_pane \
         ? "#{esc(session)}:#{esc(window)}.#{target_pane}" \
         : "#{esc(session)}:#{esc(window)}"
-      system("tmux split-window -t #{target} -c #{esc(root)} -d")
+      run!('split-window', "tmux split-window -t #{target} -c #{esc(root)} -d")
     end
 
     def select_layout(session, window, layout)
-      system("tmux select-layout -t #{esc(session)}:#{esc(window)} #{esc(layout)}")
+      run!('select-layout', "tmux select-layout -t #{esc(session)}:#{esc(window)} #{esc(layout)}")
     end
 
     def join_pane(session, src_window, dst_window)
-      system("tmux join-pane -s #{esc(session)}:#{esc(src_window)} -t #{esc(session)}:#{esc(dst_window)} -d")
+      run!('join-pane', "tmux join-pane -s #{esc(session)}:#{esc(src_window)} -t #{esc(session)}:#{esc(dst_window)} -d")
     end
 
     # Break a pane out into its own window. Without an explicit -t target,
@@ -81,20 +87,20 @@ module Mxup
     # would send it to whichever session the user happens to be attached to
     # when running tests. Always pin the destination to the source session.
     def break_pane(session, window, pane_index, new_window_name)
-      system("tmux break-pane -s #{esc(session)}:#{esc(window)}.#{pane_index} " \
-             "-t #{esc(session)}: -n #{esc(new_window_name)} -d")
+      run!('break-pane', "tmux break-pane -s #{esc(session)}:#{esc(window)}.#{pane_index} " \
+           "-t #{esc(session)}: -n #{esc(new_window_name)} -d")
     end
 
     def rename_window(session, old_name, new_name)
-      system("tmux rename-window -t #{esc(session)}:#{esc(old_name)} #{esc(new_name)}")
+      run!('rename-window', "tmux rename-window -t #{esc(session)}:#{esc(old_name)} #{esc(new_name)}")
     end
 
     def set_pane_title(session, window, pane_index, title)
-      system("tmux select-pane -t #{esc(session)}:#{esc(window)}.#{pane_index} -T #{esc(title)}")
+      run!('select-pane', "tmux select-pane -t #{esc(session)}:#{esc(window)}.#{pane_index} -T #{esc(title)}")
     end
 
     def set_environment(session, key, value)
-      system("tmux set-environment -t #{esc(session)} #{esc(key)} #{esc(value)}")
+      run!('set-environment', "tmux set-environment -t #{esc(session)} #{esc(key)} #{esc(value)}")
     end
 
     # Returns the value stored in the session's environment, or nil if unset
@@ -114,11 +120,11 @@ module Mxup
     end
 
     def send_keys(session, target, keys)
-      system("tmux send-keys -t #{esc(session)}:#{esc(target)} #{esc(keys)} Enter")
+      run!('send-keys', "tmux send-keys -t #{esc(session)}:#{esc(target)} #{esc(keys)} Enter")
     end
 
     def send_interrupt(session, target)
-      system("tmux send-keys -t #{esc(session)}:#{esc(target)} C-c")
+      run!('send-keys', "tmux send-keys -t #{esc(session)}:#{esc(target)} C-c")
     end
 
     def move_window(session, src_name, dst_index)
@@ -139,5 +145,16 @@ module Mxup
     def esc(val)
       Shellwords.escape(val.to_s)
     end
+
+    # Run a tmux command that must succeed. Captures stdout+stderr so a
+    # failure can be re-raised with tmux's own message; returns true on
+    # success. Best-effort calls (predicates, teardown, reordering) keep
+    # using system() directly and stay tolerant of failure.
+    def run!(action, cmd)
+      output = `#{cmd} 2>&1`.strip
+      return true if $?.success?
+
+      raise Error, "tmux #{action} failed#{output.empty? ? '' : ": #{output}"}"
+    end
   end
 end

data/lib/mxup/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mxup
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

data/lib/mxup/watcher.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+require 'shellwords'
+
+module Mxup
+  # Re-evaluates the commands declared in `config.live_env` and restarts
+  # dependent windows when a command's output changes.
+  #
+  # Typically launched as a detached child process from `Runner#up` via
+  # `mxup watch <session>`; can also be invoked directly in the foreground
+  # for debugging.
+  class Watcher
+    POLL_INTERVAL = 2
+
+    def initialize(config, session: config.session, launcher: nil,
+                   out: $stdout, err: $stderr, interval: POLL_INTERVAL)
+      @config   = config
+      @session  = session
+      @launcher = launcher || Launcher.new(config)
+      @out      = out
+      @err      = err
+      @interval = interval
+      @stop     = false
+      @cmd_to_windows = build_index
+      @outputs  = @cmd_to_windows.keys.each_with_object({}) { |c, h| h[c] = evaluate(c) }
+      @state    = { pid: Process.pid, started_at: Time.now.to_i, last_restart: {} }
+    end
+
+    # Path of the watcher state file inside the session's runtime dir.
+    def self.state_path(session, runtime_root: RUNTIME_DIR)
+      File.join(runtime_root, session, 'watcher.state')
+    end
+
+    def self.pid_path(session, runtime_root: RUNTIME_DIR)
+      File.join(runtime_root, session, 'watcher.pid')
+    end
+
+    def self.log_path(session, runtime_root: RUNTIME_DIR)
+      File.join(runtime_root, session, 'watcher.log')
+    end
+
+    def run
+      install_signal_handlers
+      write_state
+      log "watching #{@cmd_to_windows.size} command(s) for session #{@session}"
+
+      until @stop
+        unless Tmux.has_session?(@session)
+          log "session #{@session} is gone; exiting"
+          break
+        end
+
+        @cmd_to_windows.each_key { |cmd| check(cmd) }
+        sleep @interval
+      end
+
+      cleanup_state
+      0
+    end
+
+    # Exposed for tests.
+    def tick
+      @cmd_to_windows.each_key { |cmd| check(cmd) }
+    end
+
+    def commands
+      @cmd_to_windows.keys
+    end
+
+    private
+
+    def build_index
+      idx = Hash.new { |h, k| h[k] = [] }
+      @config.windows.each do |win|
+        win.live_env.each do |var|
+          cmd = @config.live_env[var]
+          idx[cmd] << win.name unless idx[cmd].include?(win.name)
+        end
+      end
+      idx
+    end
+
+    # Run a live_env command in the config base dir and return its stdout,
+    # or nil if it exits non-zero (so a transiently failing command reads as
+    # "no value" rather than an empty string change).
+    def evaluate(command)
+      out = `{ cd #{Shellwords.escape(@config.live_env_dir)} && #{command}; } 2>/dev/null`
+      $?.success? ? out : nil
+    rescue StandardError
+      nil
+    end
+
+    def check(command)
+      current = evaluate(command)
+      previous = @outputs[command]
+      return if current == previous
+
+      @outputs[command] = current
+      return if current.nil? # command now failing; don't trigger on value->none
+
+      windows = @cmd_to_windows[command]
+      log "live_env output changed; restarting: #{windows.join(', ')}"
+      windows.each { |wn| restart_window(wn) }
+    end
+
+    def restart_window(window_name)
+      win = @config.window_by_name(window_name)
+      return unless win
+
+      target = pane_target(window_name)
+      unless target
+        log "  #{window_name}: not in session, skipping"
+        return
+      end
+
+      Restarter.restart(@session, target, @launcher.command_for(win))
+      @state[:last_restart][window_name] = Time.now.to_i
+      write_state
+    end
+
+    def pane_target(window_name)
+      PaneResolver.new(@config, session: @session).pane_target(window_name)
+    end
+
+    def install_signal_handlers
+      %w[TERM INT].each do |sig|
+        Signal.trap(sig) { @stop = true }
+      end
+    end
+
+    def write_state
+      path = self.class.state_path(@session)
+      FileUtils.mkdir_p(File.dirname(path))
+      File.write(path, JSON.pretty_generate(@state.merge(commands: commands)))
+    rescue StandardError => e
+      log "warn: could not write state: #{e.message}"
+    end
+
+    def cleanup_state
+      path = self.class.state_path(@session)
+      File.delete(path) if File.exist?(path)
+    rescue StandardError
+      # best-effort
+    end
+
+    def log(msg)
+      @out.puts "[mxup watch #{@session}] #{Time.now.strftime('%H:%M:%S')} #{msg}"
+      @out.flush if @out.respond_to?(:flush)
+    end
+  end
+
+  # Shared "restart this window in-place" helper. Used by Runner#restart_existing
+  # and by the Watcher daemon. Sends two Ctrl-Cs and re-sources the launcher.
+  module Restarter
+    module_function
+
+    def restart(session, target, command_keys, interrupt_delay: nil)
+      delay = interrupt_delay || (defined?(Runner) ? Runner.interrupt_delay : 1.0)
+      Tmux.send_interrupt(session, target)
+      sleep delay
+      Tmux.send_interrupt(session, target)
+      sleep delay
+      Tmux.send_keys(session, target, command_keys)
+    end
+  end
+end

data/lib/mxup.rb

@@ -9,6 +9,7 @@
 #
 # Internals are organised into focused modules under lib/mxup/:
 #   Config / Window / PaneGroup / WaitSpec   — pure data
+#   EnvFile                                  — required_env validation + .env scaffolding
 #   Tmux                                     — thin tmux(1) wrapper
 #   Launcher                                 — per-window launcher scripts
 #   PaneResolver                             — logical-name → tmux target
@@ -16,6 +17,7 @@
 #   LayoutManager                            — layout switching (flatten + regroup)
 #   StatusView                               — `status` rendering
 #   ExecRunner                               — `exec` with marker + timeout
+#   Watcher / Restarter                      — live_env command-output daemon
 #   GracefulStop                             — cooperative SIGINT-then-wait
 #   ProcessProbe                             — pane → real leaf process info
 #   Runner                                   — facade delegating to the above
@@ -24,12 +26,14 @@
 require_relative 'mxup/version'
 
 module Mxup
-  CONFIG_DIR   = File.expand_path('~/.config/mxup')
-  RUNTIME_DIR  = File.expand_path('~/.local/share/mxup')
-  SHELLS       = %w[zsh bash sh fish dash].freeze
+  CONFIG_DIR        = File.expand_path('~/.config/mxup')
+  LOCAL_CONFIG_DIR  = '.mxup'
+  RUNTIME_DIR       = File.expand_path('~/.local/share/mxup')
+  SHELLS            = %w[zsh bash sh fish dash].freeze
 end
 
 require_relative 'mxup/config'
+require_relative 'mxup/env_file'
 require_relative 'mxup/tmux'
 require_relative 'mxup/launcher'
 require_relative 'mxup/process_probe'
@@ -39,5 +43,6 @@ require_relative 'mxup/layout_manager'
 require_relative 'mxup/reconciler'
 require_relative 'mxup/status_view'
 require_relative 'mxup/exec_runner'
+require_relative 'mxup/watcher'
 require_relative 'mxup/runner'
 require_relative 'mxup/cli'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mxup
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Vladislav Saifulin
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-25 00:00:00.000000000 Z
+date: 2026-07-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -57,6 +57,7 @@ files:
 - lib/mxup.rb
 - lib/mxup/cli.rb
 - lib/mxup/config.rb
+- lib/mxup/env_file.rb
 - lib/mxup/exec_runner.rb
 - lib/mxup/graceful_stop.rb
 - lib/mxup/launcher.rb
@@ -68,6 +69,7 @@ files:
 - lib/mxup/status_view.rb
 - lib/mxup/tmux.rb
 - lib/mxup/version.rb
+- lib/mxup/watcher.rb
 homepage: https://github.com/Recognized/mxup
 licenses:
 - MIT