ssh_tunnels 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9bcdb9b758ed9d27d0e81ba9bafbf8e50273fa38c2c954b332b916fccb7cc699
-  data.tar.gz: 42d49d0040704dbe2ca4c51040ccfffc797eb2f5cf4dbdc7c322aa51a9f26c27
+  metadata.gz: b54b2afe8325a674248fec24386b471caa39c91584568a2bf8c05f7534b6636b
+  data.tar.gz: 2a18a9f5a2125f7684a250387e132c2299303ff2f02125875d289dd212a4c49e
 SHA512:
-  metadata.gz: 109da60813a282a22c54b91075112e9a2bf5408e2490abe7c625aae87ef7c45ef3633ab698cdfd5f82fa24cf2a0fae04e32a6c86ba9a66b275b2eba97621e4c3
-  data.tar.gz: 117a4e60567f1763cf7c55ca024e4a1a9fc00e4b187209aff3e57edb288b209dd18ab217e958d505a4837b5daab1a8bd9502e098d1640080c091633b60b6f282
+  metadata.gz: 75475d0e47eb73d9ffb8db14abb060fbc83319d1b207d6e0e9081580d43c5d1b834141a7fa39d3dfadd21b04791939d24f7c90faef9589fec45f35a153ff9c8f
+  data.tar.gz: d7133ea6c66c25221137a12bfe7969c19555e51bd9e1931ed0c365fbb4bfa9c8b653c0c5b14467e53e1de27bf38631dd30ac86cd6e4a95a98320b80030821992

data/.rubocop.yml

@@ -2,3 +2,7 @@ AllCops:
   NewCops: enable
   TargetRubyVersion: 3.3
   SuggestExtensions: false
+
+Metrics/BlockLength:
+  Exclude:
+    - 'spec/**/*'

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ssh_tunnels (0.3.0)
+    ssh_tunnels (0.4.0)
       bcrypt_pbkdf (~> 1.1)
       curses (~> 1.4)
       ed25519 (~> 1.3)

data/README.md

@@ -103,6 +103,16 @@ tunnels:
     remote: 8080
 ```
 
+## Live reload
+
+The configuration file is checked once a second while the app is running. Saving a change updates the tunnel list in place, so there is no need to quit and reconnect:
+
+* New tunnels appear and can be connected straight away.
+* Tunnels that are disconnected take their new settings immediately.
+* Tunnels that are connected keep running on their current settings. They are marked `config changed, reconnect to apply` and pick up the new settings when next disconnected.
+* Tunnels deleted from the file are removed from the list if disconnected. If connected they stay listed, marked `removed from config`, until disconnected.
+* An invalid or half-saved file is reported in the status line and leaves the current tunnels untouched until the next successful reload.
+
 ## Contributing
 
 Pull requests are welcome.

data/bin/ssh_tunnels

@@ -22,39 +22,12 @@ end.parse!
 
 config_path = options.fetch(:config_path, File.expand_path('~/.ssh_tunnels.yml'))
 
-unless File.exist?(config_path)
-  warn("Unable to locate configuration file: #{config_path}")
-  exit 1
-end
-
-config = YAML.safe_load_file(config_path)
-
 begin
-  default_gateway = config.fetch('default_gateway', nil)
-  default_local_ip = config.fetch('default_local_ip', nil)
-  unless config.key?('tunnels')
-    warn('Configuration file must provide `tunnels` section. Exiting.')
-    exit 1
-  end
-
-  gateways = config.fetch('gateways', {})
-
-  tunnels = config.fetch('tunnels')
-  error = false
-  tunnels.each do |key, tunnel|
-    if tunnel.key?('gateway') && !gateways.key?(tunnel.fetch('gateway'))
-      error = true
-      warn("Tunnel `#{key}` references unknown gateway `#{tunnel.fetch('gateway')}`")
-    elsif !tunnel.key?('gateway') && default_gateway.nil?
-      error = true
-      warn("Tunnel `#{key}` must provide `gateway` key or define a top-level `default_gateway` configuration.")
-    end
-  end
-
-  if error
-    warn('Configuration errors detected. Exiting.')
-    exit 1
-  end
+  config = SshTunnels::Config.load(config_path)
+rescue SshTunnels::ConfigError => e
+  warn(e.message)
+  warn('Configuration errors detected. Exiting.')
+  exit 1
 end
 
 user = ENV.fetch('USER')
@@ -63,18 +36,9 @@ passphrase = $stdin.noecho(&:gets).chomp
 puts
 
 begin
-  tunnels = tunnels.map do |name, tunnel_config|
-    gateway = if tunnel_config.key?('gateway')
-                gateways.fetch(tunnel_config.fetch('gateway'))
-              else
-                default_gateway
-              end
-    config = { 'local_ip' => default_local_ip }.merge(tunnel_config)
-    SshTunnels::Tunnel.new(name, user, config, gateway, passphrase)
-  end
-  ui = SshTunnels::UI.new(tunnels)
+  ui = SshTunnels::UI.new(config, user, passphrase)
   ui.run
 rescue Interrupt
   puts 'Interrupt detected.'
-  ui.shutdown
+  ui&.shutdown
 end

data/lib/ssh_tunnels/config.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module SshTunnels
+  # Loads and validates a YAML configuration file and builds Tunnel objects
+  # from it. Invalid configuration raises ConfigError rather than exiting so
+  # that a live reload can report the problem and carry on unchanged.
+  class Config
+    REQUIRED_TUNNEL_KEYS = %w[host remote_port].freeze
+
+    attr_reader :path
+
+    def self.load(path)
+      raise ConfigError, "Unable to locate configuration file: #{path}" unless File.exist?(path)
+
+      new(path, YAML.safe_load_file(path))
+    rescue Psych::SyntaxError => e
+      raise ConfigError, "Invalid YAML: #{e.problem} (line #{e.line}, column #{e.column})"
+    end
+
+    def initialize(path, data)
+      @path = path
+      @data = data
+      validate
+    end
+
+    def mtime
+      File.mtime(@path)
+    rescue Errno::ENOENT
+      nil
+    end
+
+    def tunnels(user, passphrase)
+      tunnel_configs.map do |name, tunnel_config|
+        settings = { 'local_ip' => default_local_ip }.merge(tunnel_config)
+        Tunnel.new(name, user, settings, gateway_for(tunnel_config), passphrase)
+      end
+    end
+
+    private
+
+    def validate
+      validate_structure
+      errors = tunnel_configs.flat_map { |name, tunnel_config| tunnel_errors(name, tunnel_config) }
+      raise ConfigError, errors.join("\n") unless errors.empty?
+    end
+
+    def validate_structure
+      raise ConfigError, 'Configuration file must contain a YAML map.' unless @data.is_a?(Hash)
+      raise ConfigError, 'Configuration file must provide `tunnels` section.' unless @data.key?('tunnels')
+      raise ConfigError, '`tunnels` section must be a map.' unless tunnel_configs.is_a?(Hash)
+      raise ConfigError, '`gateways` section must be a map.' unless gateways.is_a?(Hash)
+    end
+
+    def tunnel_errors(name, tunnel_config)
+      return ["Tunnel `#{name}` must be a map."] unless tunnel_config.is_a?(Hash)
+
+      missing = REQUIRED_TUNNEL_KEYS.reject { |key| tunnel_config.key?(key) }
+      missing.map { |key| "Tunnel `#{name}` must provide `#{key}`." } + gateway_errors(name, tunnel_config)
+    end
+
+    def gateway_errors(name, tunnel_config)
+      if tunnel_config.key?('gateway')
+        gateway = tunnel_config.fetch('gateway')
+        return [] if gateways.key?(gateway)
+
+        ["Tunnel `#{name}` references unknown gateway `#{gateway}`."]
+      elsif default_gateway.nil?
+        ["Tunnel `#{name}` must provide `gateway` key or define a top-level `default_gateway` configuration."]
+      else
+        []
+      end
+    end
+
+    def gateway_for(tunnel_config)
+      return default_gateway unless tunnel_config.key?('gateway')
+
+      gateways.fetch(tunnel_config.fetch('gateway'))
+    end
+
+    def tunnel_configs
+      @data.fetch('tunnels')
+    end
+
+    def gateways
+      @data.fetch('gateways', {})
+    end
+
+    def default_gateway
+      @data.fetch('default_gateway', nil)
+    end
+
+    def default_local_ip
+      @data.fetch('default_local_ip', nil)
+    end
+  end
+end

data/lib/ssh_tunnels/tunnel.rb

@@ -1,9 +1,27 @@
 # frozen_string_literal: true
 
 module SshTunnels
+  # rubocop:disable Metrics/ClassLength
   # SSH Tunnel
   class Tunnel
-    attr_reader :name, :error
+    attr_reader :name, :error, :config, :gateway
+
+    # Merges freshly-loaded tunnels into the current list. Tunnels that share a
+    # name keep their existing object (and therefore any live connection) and
+    # receive the new settings via #update. Tunnels no longer present in the
+    # configuration are dropped if inactive, or kept and flagged as removed
+    # while still connected so a file edit never interrupts a live session.
+    def self.reconcile(current, incoming)
+      existing = current.to_h { |tunnel| [tunnel.name, tunnel] }
+      merged = incoming.map do |tunnel|
+        match = existing.delete(tunnel.name)
+        next tunnel if match.nil?
+
+        match.update(tunnel.config, tunnel.gateway)
+        match
+      end
+      merged + existing.values.select(&:active?).each(&:remove)
+    end
 
     def initialize(name, user, config, gateway, passphrase)
       @name = name
@@ -14,6 +32,8 @@ module SshTunnels
       @session = nil
       @thread = nil
       @active = false
+      @pending = nil
+      @removed = false
     end
 
     def to_s
@@ -27,17 +47,46 @@ module SshTunnels
       "#{base} (#{@error})"
     end
 
+    # Called on configuration reload. Inactive tunnels take the new settings
+    # immediately; active tunnels keep running on their current settings and
+    # apply the new ones when next disconnected.
+    def update(config, gateway)
+      @removed = false
+      if config == @config && gateway == @gateway
+        @pending = nil
+      elsif active?
+        @pending = [config, gateway]
+      else
+        apply(config, gateway)
+      end
+    end
+
+    def remove
+      @removed = true
+    end
+
+    def removed?
+      @removed
+    end
+
+    def changed?
+      !@pending.nil?
+    end
+
     def toggle
       active? ? shutdown : open
     end
 
     def open
-      @session = Net::SSH.start(@gateway.fetch('host'), @gateway.fetch('user', @user), options)
-      forward_local
+      apply_pending
+      @error = nil
+      connect
       @active = true
-      @thread = Thread.new { @session.loop(0.001) { @active } }
-    rescue StandardError
-      shutdown
+      @thread = Thread.new { run_loop }
+    rescue StandardError => e
+      @error = e
+      @active = false
+      close_session
       raise
     end
 
@@ -48,13 +97,62 @@ module SshTunnels
     def shutdown
       @active = false
       @thread&.join
-      @session&.close
-      @session = nil
       @thread = nil
+      @session = nil
+      apply_pending
     end
 
     private
 
+    def apply_pending
+      apply(*@pending) unless @pending.nil?
+    end
+
+    def apply(config, gateway)
+      @config = config
+      @gateway = gateway
+      @pending = nil
+      @error = nil
+    end
+
+    def connect
+      @session = Net::SSH.start(@gateway.fetch('host'), @gateway.fetch('user', @user), options)
+      forward_local
+    end
+
+    # Runs in the background thread. When the loop ends — whether because the
+    # user disconnected (@active set to false) or the connection dropped (the
+    # loop raises) — the local forwarded port must be released here. Otherwise
+    # the orphaned listener keeps the port bound, causing connecting apps to
+    # hang and reconnects to fail with "address in use".
+    def run_loop
+      @session.loop(0.001) { @active }
+    rescue StandardError => e
+      @error = e
+    ensure
+      @active = false
+      close_session
+    end
+
+    # Net::SSH::Connection::Session#close only closes channels and the
+    # transport socket; the TCPServer bound by forward.local is only released
+    # by forward.cancel_local, so cancel before closing.
+    def close_session
+      release_port
+      @session&.close
+      @session = nil
+    end
+
+    def release_port
+      return if @session.nil?
+
+      args = [local_port]
+      args << local_host if local_host
+      @session.forward.cancel_local(*args)
+    rescue StandardError
+      nil
+    end
+
     def forward_local
       args = [local_port, remote_host, remote_port]
       args.unshift(local_host) if local_host
@@ -86,4 +184,5 @@ module SshTunnels
       }
     end
   end
+  # rubocop:enable Metrics/ClassLength
 end

data/lib/ssh_tunnels/ui.rb

@@ -5,19 +5,27 @@ module SshTunnels
   # User Interface
   class UI
     IDENTIFIERS = ['1'..'9', 'a'..'z', 'A'..'Z'].map(&:to_a).flatten
-
-    def initialize(tunnels)
-      @tunnels = tunnels
+    COLORS = {
+      white: Curses::COLOR_WHITE,
+      blue: Curses::COLOR_BLUE,
+      green: Curses::COLOR_GREEN,
+      cyan: Curses::COLOR_CYAN,
+      red: Curses::COLOR_RED,
+      yellow: Curses::COLOR_YELLOW
+    }.freeze
+
+    def initialize(config, user, passphrase)
+      @config = config
+      @user = user
+      @passphrase = passphrase
+      @tunnels = config.tunnels(user, passphrase)
+      @config_mtime = config.mtime
     end
 
     def setup
       Curses.init_screen
       Curses.start_color
-      Curses.init_pair(1, Curses::COLOR_WHITE, Curses::COLOR_BLACK)
-      Curses.init_pair(2, Curses::COLOR_BLUE, Curses::COLOR_BLACK)
-      Curses.init_pair(3, Curses::COLOR_GREEN, Curses::COLOR_BLACK)
-      Curses.init_pair(4, Curses::COLOR_CYAN, Curses::COLOR_BLACK)
-      Curses.init_pair(5, Curses::COLOR_RED, Curses::COLOR_BLACK)
+      COLORS.each_value.with_index(1) { |value, pair| Curses.init_pair(pair, value, Curses::COLOR_BLACK) }
       Curses.timeout = 1000
       Curses.curs_set(0)
       Curses.noecho
@@ -44,6 +52,8 @@ module SshTunnels
 
     def monitor
       loop do
+        reload_if_changed
+        prune_removed
         @tunnels.each_with_index do |tunnel, index|
           display_tunnel(tunnel, index)
         end
@@ -61,6 +71,37 @@ module SshTunnels
       clean_status if @status_time && Time.now.utc - @status_time > 2.5
     end
 
+    # The configuration file is polled once per tick (see Curses.timeout). A
+    # change triggers a reload; an unreadable or invalid file leaves the
+    # current tunnels untouched and reports the problem until the next
+    # successful reload.
+    def reload_if_changed
+      mtime = @config.mtime
+      return if mtime == @config_mtime
+
+      @config_mtime = mtime
+      reload
+    end
+
+    def reload
+      @config = Config.load(@config.path)
+      @tunnels = Tunnel.reconcile(@tunnels, @config.tunnels(@user, @passphrase))
+      window.erase
+      status('Configuration reloaded.')
+    rescue ConfigError => e
+      status("Configuration error: #{e.message.lines.first.chomp}", sticky: true)
+    end
+
+    # Tunnels removed from the configuration stay listed while connected and
+    # disappear once they are no longer active.
+    def prune_removed
+      orphans = @tunnels.select { |tunnel| tunnel.removed? && !tunnel.active? }
+      return if orphans.empty?
+
+      @tunnels -= orphans
+      window.erase
+    end
+
     def window
       @window ||= Curses.stdscr
     end
@@ -74,21 +115,45 @@ module SshTunnels
       window.addstr("#{tunnel.name} ")
       window.attrset(color(:cyan))
       window.addstr(tunnel.to_s)
+      display_marker(tunnel)
+      window.clrtoeol
     end
     # rubocop:enable Metrics/AbcSize
 
+    def display_marker(tunnel)
+      marker = tunnel_marker(tunnel)
+      return if marker.nil?
+
+      window.attrset(color(:yellow))
+      window.addstr(" [#{marker}]")
+    end
+
+    def tunnel_marker(tunnel)
+      return 'removed from config, disconnect to clear' if tunnel.removed?
+      return 'config changed, reconnect to apply' if tunnel.changed?
+
+      nil
+    end
+
     def display_usage
       window.setpos(@tunnels.size + 3, 2)
       window.attrset(color(:cyan))
-      message = "[1-#{@tunnels.size}] to connect/disconnect. Press 'q' to quit."
-      window.addstr(message)
+      window.addstr(usage_message)
+      window.clrtoeol
+    end
+
+    def usage_message
+      return "No tunnels configured. Press 'q' to quit." if @tunnels.empty?
+
+      "[1-#{IDENTIFIERS[@tunnels.size - 1]}] to connect/disconnect. Press 'q' to quit."
     end
 
     def process_input(input)
       raise UserQuit if input == 'q'
       return status("Unrecognized input: #{input}") unless input.is_a?(String) && input =~ /\A[0-9a-zA-Z]\Z/
 
-      tunnel = @tunnels[IDENTIFIERS.index { |value| value == input }]
+      index = IDENTIFIERS.index(input)
+      tunnel = index && @tunnels[index]
       return status("Unrecognized tunnel: #{input}") if tunnel.nil?
 
       toggle_tunnel(tunnel)
@@ -107,9 +172,11 @@ module SshTunnels
       tunnel.active? ? color(:green) : color(:blue)
     end
 
-    def status(message)
+    # A sticky status stays until replaced by the next status message rather
+    # than being cleared after a few seconds.
+    def status(message, sticky: false)
       clean_status
-      @status_time = Time.now.utc
+      @status_time = sticky ? nil : Time.now.utc
       window.setpos(*status_coordinates)
       window.attrset(color(:white))
       window.addstr(message)
@@ -120,7 +187,7 @@ module SshTunnels
       y, x = status_coordinates
       window.setpos(y, x)
       window.attrset(color(:white))
-      window.addstr(' ' * (Curses.cols - x))
+      window.clrtoeol
     end
 
     def status_coordinates
@@ -128,15 +195,7 @@ module SshTunnels
     end
 
     def color(name)
-      Curses.color_pair(
-        {
-          white: 1,
-          blue: 2,
-          green: 3,
-          cyan: 4,
-          red: 5
-        }.fetch(name)
-      )
+      Curses.color_pair(COLORS.keys.index(name) + 1)
     end
   end
   # rubocop:enable Metrics/ClassLength

data/lib/ssh_tunnels/version.rb

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

data/lib/ssh_tunnels.rb

@@ -2,12 +2,15 @@
 
 require 'curses'
 require 'net/ssh'
+require 'yaml'
 
 require 'ssh_tunnels/version'
+require 'ssh_tunnels/config'
 require 'ssh_tunnels/tunnel'
 require 'ssh_tunnels/ui'
 
 module SshTunnels
   class Error < StandardError; end
   class UserQuit < Error; end
+  class ConfigError < Error; end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ssh_tunnels
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Bob Farrell
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-05-29 00:00:00.000000000 Z
+date: 2026-09-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bcrypt_pbkdf
@@ -89,6 +89,7 @@ files:
 - bin/ssh_tunnels
 - doc/demo.png
 - lib/ssh_tunnels.rb
+- lib/ssh_tunnels/config.rb
 - lib/ssh_tunnels/tunnel.rb
 - lib/ssh_tunnels/ui.rb
 - lib/ssh_tunnels/version.rb