hotswap 0.2.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9fb57abbaa8c101d3ec89ba7beb71a1c363fef0dc8504169f3d346851d3df277
-  data.tar.gz: cd24097f831156becc966d22fba0aba7db145d2d5eb40b2b90f49048b9090dd2
+  metadata.gz: ad93b96b0ced98527e4b48c2df94758034ea339c08cf0ef5b9aaeb60f62cd1cc
+  data.tar.gz: de80e2a8e41794142c2785d44dbeaf21114888a4e85dcf3009af4118d7ba64ee
 SHA512:
-  metadata.gz: 1f195e3c1335758d3b6cd69c4f51b34edeb82c1f787b8331909460b2716f0ee72bdd569d740d5c5a61d4c12c60b97432346de97a4fe5b453c2251f9cd246fa7f
-  data.tar.gz: 1588206ad76daf621e41c7f98c5f5c8545fde3e5f8fe7cfdd2c295bfba84787d34e56e6ba1d0e5a141a9ac9b1dacd609210e8c4870ff37558bb970f9d02fb5ee
+  metadata.gz: 2a45194ce3883a74d3e5f5bfe12ef5da08a0d301eb2a5fa507a8fc8c94c79611fbddccdcb287febfc7cc6486ce10a7e260f4213a15f6d1d6119f4597dea90fc4
+  data.tar.gz: 819ae0bab10da130c146ccc863161cdf8c36964731bafe37efc95a9f1c27b0b7bbf307254397f08b45367ce07ceceb8e88f1339ba9a953b2c6ccaa940e49ebf8

data/exe/hotswap

@@ -1,51 +1,80 @@
 #!/usr/bin/env ruby
 
 require "socket"
-require "shellwords"
+require "json"
+
+# Inline protocol encode/decode so the client has zero gem dependencies
+module ThorSocketProtocol
+  HEADER_SIZE = 5
+
+  def self.encode(channel, data)
+    data = data.b
+    [channel, data.bytesize].pack("CN") + data
+  end
+
+  def self.decode(io)
+    header = io.read(HEADER_SIZE)
+    return nil if header.nil? || header.bytesize < HEADER_SIZE
+    channel, length = header.unpack("CN")
+    payload = io.read(length)
+    return nil if payload.nil? || payload.bytesize < length
+    [channel, payload]
+  end
+end
+
+STDIN_CH  = 0
+STDOUT_CH = 1
+STDERR_CH = 2
+CTRL_CH   = 3
 
 socket_path = ENV.fetch("HOTSWAP_SOCKET", "tmp/sockets/hotswap.sock")
-stderr_socket_path = ENV.fetch("HOTSWAP_STDERR_SOCKET", "tmp/sockets/hotswap.stderr.sock")
 
 unless File.exist?(socket_path)
   $stderr.puts "ERROR: socket not found at #{socket_path}"
   exit 1
 end
 
-# Connect stderr socket first so it's ready before the command runs
-stderr_sock = nil
-if File.exist?(stderr_socket_path)
-  stderr_sock = UNIXSocket.new(stderr_socket_path)
-end
-
 sock = UNIXSocket.new(socket_path)
 
-# Shell-escape args to preserve spaces in file paths
-args = ARGV.map { |a| Shellwords.escape(a) }.join(" ")
-sock.write(args + "\n")
+# Send control frame with args and tty status
+control = { "args" => ARGV, "tty" => $stdout.tty? }
+sock.write(ThorSocketProtocol.encode(CTRL_CH, JSON.generate(control)))
 
-# Pipe stdin to socket (only if data is being piped in)
+# Pipe stdin if '-' is an argument and stdin isn't a tty
 writer = nil
-if !$stdin.tty?
+if ARGV.include?("-") && !$stdin.tty?
   writer = Thread.new do
-    IO.copy_stream($stdin, sock) rescue nil
-    sock.close_write rescue nil
+    begin
+      buf = String.new(capacity: 16384)
+      while $stdin.read(16384, buf)
+        sock.write(ThorSocketProtocol.encode(STDIN_CH, buf))
+      end
+    rescue IOError, Errno::EPIPE
+    ensure
+      sock.write(ThorSocketProtocol.encode(STDIN_CH, "")) rescue nil
+    end
   end
-else
-  sock.close_write
 end
 
-# Pipe stderr socket to local stderr (in background thread)
-stderr_reader = nil
-if stderr_sock
-  stderr_reader = Thread.new do
-    IO.copy_stream(stderr_sock, $stderr) rescue nil
+# Read frames from server
+exit_code = 0
+loop do
+  result = ThorSocketProtocol.decode(sock)
+  break unless result
+
+  channel, data = result
+  case channel
+  when STDOUT_CH
+    $stdout.write(data)
+  when STDERR_CH
+    $stderr.write(data)
+  when CTRL_CH
+    ctrl = JSON.parse(data)
+    exit_code = ctrl.fetch("exit", 0)
+    break
   end
 end
 
-# Pipe socket output to stdout
-IO.copy_stream(sock, $stdout) rescue nil
-
 writer&.join
-stderr_reader&.join
-stderr_sock&.close rescue nil
 sock.close rescue nil
+exit exit_code

data/lib/hotswap/cli.rb

@@ -6,30 +6,16 @@ module Hotswap
       false
     end
 
-    class Shell < Thor::Shell::Basic
-      def initialize(stdout, stderr)
-        super()
-        @_stdout = stdout
-        @_stderr = stderr
-      end
-
-      def stdout = @_stdout
-      def stderr = @_stderr
-    end
-
     def self.run(args, stdin: $stdin, stdout: $stdout, stderr: $stderr)
       Thread.current[:hotswap_stdin] = stdin
-      Thread.current[:hotswap_stdout] = stdout
-      Thread.current[:hotswap_stderr] = stderr
 
       args = ["help"] if args.empty?
-      start(args, shell: Shell.new(stdout, stderr))
+      shell = Thor::Socket::Shell.new(stdout, stderr)
+      start(args, shell: shell)
     rescue SystemExit
       # Thor calls exit on errors — catch it so we don't kill the server
     ensure
       Thread.current[:hotswap_stdin] = nil
-      Thread.current[:hotswap_stdout] = nil
-      Thread.current[:hotswap_stderr] = nil
     end
 
     desc "cp SRC DST", "Copy a database to/from the running server"
@@ -46,37 +32,39 @@ module Hotswap
         hotswap cp - db/production.sqlite3                # push from stdin
         hotswap cp db/production.sqlite3 -                # pull to stdout
     DESC
+    method_option :skip_integrity_check, type: :boolean, default: false, desc: "Skip SQLite integrity check on push"
+    method_option :skip_schema_check, type: :boolean, default: false, desc: "Skip schema compatibility check on push"
     def cp(src, dst)
       src_db = resolve_database(src)
       dst_db = resolve_database(dst)
 
       if src_db && dst_db
-        io_err.write("ERROR: source and destination can't both be managed databases\n")
+        shell.stderr.write("ERROR: source and destination can't both be managed databases\n")
         return
       end
 
       if dst_db
         source = (src == "-") ? io_in : src
-        dst_db.push(source, stdout: io_out, stderr: io_err)
+        dst_db.push(source, stdout: shell.stdout, stderr: shell.stderr,
+          skip_integrity_check: options[:skip_integrity_check],
+          skip_schema_check: options[:skip_schema_check])
       elsif src_db
-        destination = (dst == "-") ? io_out : dst
-        src_db.pull(destination, stderr: io_err)
+        destination = (dst == "-") ? shell.stdout : dst
+        src_db.pull(destination, stderr: shell.stderr)
       else
         paths = Hotswap.databases.map(&:path).join(", ")
-        io_err.write("ERROR: neither path matches a managed database (#{paths})\n")
+        shell.stderr.write("ERROR: neither path matches a managed database (#{paths})\n")
       end
     end
 
-desc "version", "Print the hotswap version"
+    desc "version", "Print the hotswap version"
     def version
-      io_out.write("hotswap #{Hotswap::VERSION}\n")
+      shell.stdout.write("hotswap #{Hotswap::VERSION}\n")
     end
 
     private
 
-    def io_in  = Thread.current[:hotswap_stdin]  || $stdin
-    def io_out = Thread.current[:hotswap_stdout] || $stdout
-    def io_err = Thread.current[:hotswap_stderr] || $stderr
+    def io_in = Thread.current[:hotswap_stdin] || $stdin
 
     def resolve_database(path)
       return nil if path == "-"

data/lib/hotswap/database.rb

@@ -11,7 +11,7 @@ module Hotswap
     end
 
     # Push a new database from an IO stream or file path
-    def push(source, stdout: $stdout, stderr: $stderr)
+    def push(source, stdout: $stdout, stderr: $stderr, skip_integrity_check: false, skip_schema_check: false)
       source_label = source.is_a?(String) ? source : "stdin"
       logger.info "push started: #{source_label} → #{@path}"
 
@@ -22,18 +22,42 @@ module Hotswap
       begin
         IO.copy_stream(input, temp)
         temp.close
-        logger.info "received #{File.size(temp.path)} bytes, running integrity check"
-
-        db = SQLite3::Database.new(temp.path)
-        result = db.execute("PRAGMA integrity_check")
-        db.close
-        unless result == [["ok"]]
-          logger.error "integrity check failed for #{source_label}"
-          stderr.write("ERROR: integrity check failed\n")
-          return false
+        logger.info "received #{File.size(temp.path)} bytes"
+
+        unless skip_integrity_check
+          logger.info "running integrity check"
+          db = SQLite3::Database.new(temp.path)
+          result = db.execute("PRAGMA integrity_check")
+          db.close
+          unless result == [["ok"]]
+            logger.error "integrity check failed for #{source_label}"
+            stderr.write("ERROR: integrity check failed\n")
+            return false
+          end
+          logger.info "integrity check passed"
+        end
+
+        unless skip_schema_check
+          logger.info "running schema check"
+          new_db = SQLite3::Database.new(temp.path)
+          cur_db = SQLite3::Database.new(@path)
+          new_schema = new_db.execute("SELECT sql FROM sqlite_master WHERE sql IS NOT NULL ORDER BY type, name").flatten
+          cur_schema = cur_db.execute("SELECT sql FROM sqlite_master WHERE sql IS NOT NULL ORDER BY type, name").flatten
+          new_db.close
+          cur_db.close
+
+          if new_schema != cur_schema
+            logger.error "schema mismatch for #{source_label}"
+            diff_lines = []
+            (cur_schema - new_schema).each { |s| diff_lines << "- #{s}" }
+            (new_schema - cur_schema).each { |s| diff_lines << "+ #{s}" }
+            stderr.write("ERROR: schema mismatch\n#{diff_lines.join("\n")}\n")
+            return false
+          end
+          logger.info "schema check passed"
         end
 
-        logger.info "integrity check passed, acquiring swap lock"
+        logger.info "acquiring swap lock"
         stderr.write("Swapping database...\n")
 
         Middleware::SWAP_LOCK.synchronize do

data/lib/hotswap/railtie.rb

@@ -21,18 +21,12 @@ module Hotswap
         end
       end
 
-      # Socket paths
+      # Socket path
       if app.config.hotswap.socket_path
         Hotswap.socket_path = app.config.hotswap.socket_path
       else
         Hotswap.socket_path = File.join(app.root, "tmp", "sockets", "hotswap.sock")
       end
-
-      if app.config.hotswap.stderr_socket_path
-        Hotswap.stderr_socket_path = app.config.hotswap.stderr_socket_path
-      else
-        Hotswap.stderr_socket_path = File.join(app.root, "tmp", "sockets", "hotswap.stderr.sock")
-      end
     end
 
     initializer "hotswap.middleware" do |app|
@@ -40,9 +34,15 @@ module Hotswap
     end
 
     server do
-      server = Hotswap::SocketServer.new
+      server = Thor::Socket::Server.new(
+        Hotswap::CLI,
+        socket_path: Hotswap.socket_path,
+        logger: Hotswap.logger
+      )
       server.start
 
+      Hotswap.logger.info "managing #{Hotswap.databases.size} database(s): #{Hotswap.databases.map(&:path).join(', ')}"
+
       at_exit { server.stop }
     end
   end

data/lib/hotswap/version.rb

@@ -1,3 +1,3 @@
 module Hotswap
-  VERSION = "0.2.3"
+  VERSION = "0.3.0"
 end

data/lib/hotswap.rb

@@ -2,15 +2,15 @@ require "logger"
 require_relative "hotswap/version"
 require_relative "hotswap/middleware"
 require_relative "hotswap/database"
+require_relative "thor/socket"
 require_relative "hotswap/cli"
-require_relative "hotswap/socket_server"
 require_relative "hotswap/railtie" if defined?(Rails::Railtie)
 
 module Hotswap
   class Error < StandardError; end
 
   class << self
-    attr_accessor :socket_path, :stderr_socket_path
+    attr_accessor :socket_path
     attr_writer :logger
 
     def logger
@@ -50,5 +50,4 @@ module Hotswap
   end
 
   self.socket_path = "tmp/sockets/hotswap.sock"
-  self.stderr_socket_path = "tmp/sockets/hotswap.stderr.sock"
 end

data/lib/thor/socket.rb

@@ -0,0 +1,353 @@
+require "socket"
+require "json"
+require "thor"
+
+class Thor
+  module Socket
+    module Protocol
+      CHANNEL_STDIN   = 0
+      CHANNEL_STDOUT  = 1
+      CHANNEL_STDERR  = 2
+      CHANNEL_CONTROL = 3
+
+      HEADER_SIZE = 5 # 1 byte channel + 4 bytes length
+
+      def self.encode(channel, data)
+        data = data.b
+        [channel, data.bytesize].pack("CN") + data
+      end
+
+      def self.decode(io)
+        header = io.read(HEADER_SIZE)
+        return nil if header.nil? || header.bytesize < HEADER_SIZE
+
+        channel, length = header.unpack("CN")
+        payload = io.read(length)
+        return nil if payload.nil? || payload.bytesize < length
+
+        [channel, payload]
+      end
+    end
+
+    class FramedWriter
+      def initialize(io, channel)
+        @io = io
+        @channel = channel
+        @mutex = Mutex.new
+      end
+
+      def write(data)
+        data = data.to_s
+        return 0 if data.empty?
+        frame = Protocol.encode(@channel, data)
+        @mutex.synchronize { @io.write(frame) }
+        data.bytesize
+      end
+
+      def puts(str = "")
+        write(str.to_s + "\n")
+      end
+
+      def print(str)
+        write(str.to_s)
+      end
+
+      def flush
+        @mutex.synchronize { @io.flush rescue nil }
+      end
+
+      def binmode
+        self
+      end
+
+      def close
+        # no-op — the underlying socket is closed by the connection
+      end
+    end
+
+    class FramedReader
+      def initialize(io)
+        @io = io
+        @buffer = String.new(encoding: Encoding::BINARY)
+        @eof = false
+      end
+
+      def read(length = nil, buf = nil)
+        if length.nil?
+          # Read all remaining stdin data
+          chunks = []
+          chunks << @buffer.dup unless @buffer.empty?
+          @buffer.clear
+          until @eof
+            data = read_next_stdin_frame
+            break unless data
+            chunks << data
+          end
+          result = chunks.join
+          if buf
+            buf.replace(result)
+          else
+            result
+          end
+        else
+          fill_buffer(length)
+          chunk = @buffer.slice!(0, length)
+          return nil if chunk.nil? || chunk.empty?
+          if buf
+            buf.replace(chunk)
+          else
+            chunk
+          end
+        end
+      end
+
+      def gets
+        loop do
+          if (idx = @buffer.index("\n"))
+            return @buffer.slice!(0, idx + 1)
+          end
+          return @buffer.slice!(0, @buffer.bytesize) if @eof && !@buffer.empty?
+          return nil if @eof
+          data = read_next_stdin_frame
+          return nil unless data
+        end
+      end
+
+      def eof?
+        @buffer.empty? && @eof
+      end
+
+      private
+
+      def fill_buffer(target)
+        while @buffer.bytesize < target && !@eof
+          data = read_next_stdin_frame
+          break unless data
+        end
+      end
+
+      def read_next_stdin_frame
+        return nil if @eof
+        result = Protocol.decode(@io)
+        if result.nil?
+          @eof = true
+          return nil
+        end
+        channel, data = result
+        if channel == Protocol::CHANNEL_STDIN && !data.empty?
+          @buffer << data
+          data
+        else
+          @eof = true
+          nil
+        end
+      end
+    end
+
+    class Shell < Thor::Shell::Basic
+      attr_reader :stdout, :stderr
+
+      def initialize(stdout, stderr, tty: false)
+        super()
+        @stdout = stdout
+        @stderr = stderr
+        @tty = tty
+      end
+
+      def can_display_colors?
+        false
+      end
+
+      private
+
+      def prepare_message(message, *_color)
+        message.to_s
+      end
+    end
+
+    class Connection
+      CONNECTION_TIMEOUT = 10
+
+      def initialize(socket, cli_class, logger: nil)
+        @socket = socket
+        @cli_class = cli_class
+        @logger = logger
+      end
+
+      def handle
+        unless IO.select([@socket], nil, nil, CONNECTION_TIMEOUT)
+          @logger&.warn "connection timed out"
+          send_control("error" => "connection timeout")
+          return
+        end
+
+        result = Protocol.decode(@socket)
+        unless result
+          @logger&.warn "empty connection"
+          return
+        end
+
+        channel, data = result
+        unless channel == Protocol::CHANNEL_CONTROL
+          @logger&.warn "expected control frame, got channel #{channel}"
+          return
+        end
+
+        control = JSON.parse(data)
+        args = control.fetch("args", [])
+        tty = control.fetch("tty", false)
+
+        @logger&.info "command: #{args.join(' ')}" unless args.empty?
+
+        stdout_writer = FramedWriter.new(@socket, Protocol::CHANNEL_STDOUT)
+        stderr_writer = FramedWriter.new(@socket, Protocol::CHANNEL_STDERR)
+        stdin_reader = FramedReader.new(@socket)
+
+        run_cli(args, stdin: stdin_reader, stdout: stdout_writer, stderr: stderr_writer, tty: tty)
+
+        send_control("exit" => 0)
+      rescue => e
+        @logger&.error "connection error: #{e.message}"
+        send_control("exit" => 1, "error" => e.message) rescue nil
+      ensure
+        @socket.close rescue nil
+      end
+
+      private
+
+      def run_cli(args, stdin:, stdout:, stderr:, tty:)
+        if @cli_class.respond_to?(:run)
+          @cli_class.run(args, stdin: stdin, stdout: stdout, stderr: stderr)
+        else
+          args = ["help"] if args.empty?
+          shell = Shell.new(stdout, stderr, tty: tty)
+          @cli_class.start(args, shell: shell)
+        end
+      rescue SystemExit
+        # Thor calls exit on errors — catch it so we don't kill the server
+      end
+
+      def send_control(data)
+        frame = Protocol.encode(Protocol::CHANNEL_CONTROL, JSON.generate(data))
+        @socket.write(frame)
+      end
+    end
+
+    class Server
+      attr_reader :socket_path
+
+      def initialize(cli_class, socket_path:, logger: nil)
+        @cli_class = cli_class
+        @socket_path = socket_path
+        @logger = logger
+        @server = nil
+        @thread = nil
+      end
+
+      def start
+        cleanup_stale_socket(@socket_path)
+        FileUtils.mkdir_p(File.dirname(@socket_path))
+        @server = UNIXServer.new(@socket_path)
+        @thread = Thread.new { accept_loop }
+        @thread.report_on_exception = false
+        @logger&.info "listening on #{@socket_path}"
+        self
+      end
+
+      def stop
+        @logger&.info "shutting down"
+        @server&.close
+        @thread&.kill
+        File.delete(@socket_path) if @socket_path && File.exist?(@socket_path)
+      end
+
+      private
+
+      def accept_loop
+        loop do
+          client = @server.accept
+          Thread.new(client) do |sock|
+            Connection.new(sock, @cli_class, logger: @logger).handle
+          end
+        end
+      rescue IOError, Errno::EBADF
+        # Server was closed, exit gracefully
+      end
+
+      def cleanup_stale_socket(path)
+        return unless File.exist?(path)
+        begin
+          test = UNIXSocket.new(path)
+          test.close
+          raise "Socket #{path} is already in use"
+        rescue Errno::ECONNREFUSED, Errno::ENOENT
+          File.delete(path)
+        end
+      end
+    end
+
+    class Client
+      def self.connect(socket_path, args:, stdin: $stdin, stdout: $stdout, stderr: $stderr, tty: $stdout.tty?)
+        new(socket_path, args: args, stdin: stdin, stdout: stdout, stderr: stderr, tty: tty).run
+      end
+
+      def initialize(socket_path, args:, stdin:, stdout:, stderr:, tty:)
+        @socket_path = socket_path
+        @args = args
+        @stdin = stdin
+        @stdout = stdout
+        @stderr = stderr
+        @tty = tty
+      end
+
+      def run
+        sock = UNIXSocket.new(@socket_path)
+
+        # Send control frame
+        control = { "args" => @args, "tty" => @tty }
+        sock.write(Protocol.encode(Protocol::CHANNEL_CONTROL, JSON.generate(control)))
+
+        # Pipe stdin if '-' is an argument and stdin isn't a tty
+        writer = nil
+        if @args.include?("-") && !@stdin.tty?
+          writer = Thread.new do
+            begin
+              buf = String.new(capacity: 16384)
+              while @stdin.read(16384, buf)
+                sock.write(Protocol.encode(Protocol::CHANNEL_STDIN, buf))
+              end
+            rescue IOError, Errno::EPIPE
+              # stdin closed or socket gone
+            ensure
+              # Send an empty stdin frame to signal EOF, then stop writing
+              sock.write(Protocol.encode(Protocol::CHANNEL_STDIN, "")) rescue nil
+            end
+          end
+        end
+
+        # Read frames from server
+        exit_code = 0
+        loop do
+          result = Protocol.decode(sock)
+          break unless result
+
+          channel, data = result
+          case channel
+          when Protocol::CHANNEL_STDOUT
+            @stdout.write(data)
+          when Protocol::CHANNEL_STDERR
+            @stderr.write(data)
+          when Protocol::CHANNEL_CONTROL
+            ctrl = JSON.parse(data)
+            exit_code = ctrl.fetch("exit", 0)
+            break
+          end
+        end
+
+        writer&.join
+        sock.close rescue nil
+        exit_code
+      end
+    end
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: hotswap
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.0
 platform: ruby
 authors:
 - Brad Gessler
 bindir: exe
 cert_chain: []
-date: 2026-02-28 00:00:00.000000000 Z
+date: 2026-03-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -163,8 +163,8 @@ files:
 - lib/hotswap/database.rb
 - lib/hotswap/middleware.rb
 - lib/hotswap/railtie.rb
-- lib/hotswap/socket_server.rb
 - lib/hotswap/version.rb
+- lib/thor/socket.rb
 licenses:
 - MIT
 metadata: {}

data/lib/hotswap/socket_server.rb

@@ -1,124 +0,0 @@
-require "socket"
-require "shellwords"
-
-module Hotswap
-  class SocketServer
-    attr_reader :socket_path, :stderr_socket_path
-
-    CONNECTION_TIMEOUT = 10
-
-    def initialize(socket_path: Hotswap.socket_path, stderr_socket_path: Hotswap.stderr_socket_path)
-      @socket_path = socket_path
-      @stderr_socket_path = stderr_socket_path
-      @server = nil
-      @stderr_server = nil
-      @thread = nil
-      @stderr_client = nil
-      @stderr_mutex = Mutex.new
-    end
-
-    def start
-      cleanup_stale_socket(@socket_path)
-      cleanup_stale_socket(@stderr_socket_path)
-
-      FileUtils.mkdir_p(File.dirname(@socket_path))
-      @server = UNIXServer.new(@socket_path)
-      @stderr_server = UNIXServer.new(@stderr_socket_path)
-
-      @thread = Thread.new { accept_loop }
-      @thread.report_on_exception = false
-
-      logger.info "listening on #{@socket_path}"
-      logger.info "stderr socket on #{@stderr_socket_path}"
-      logger.info "managing #{Hotswap.databases.size} database(s): #{Hotswap.databases.map(&:path).join(', ')}"
-      self
-    end
-
-    def stop
-      logger.info "shutting down"
-      @server&.close
-      @stderr_server&.close
-      @thread&.kill
-      @stderr_mutex.synchronize do
-        @stderr_client&.close rescue nil
-        @stderr_client = nil
-      end
-      [@socket_path, @stderr_socket_path].each do |path|
-        File.delete(path) if path && File.exist?(path)
-      end
-    end
-
-    private
-
-    def logger = Hotswap.logger
-
-    def accept_loop
-      ios = [@server, @stderr_server]
-      loop do
-        readable, = IO.select(ios)
-        readable.each do |server|
-          client = server.accept
-          if server == @stderr_server
-            @stderr_mutex.synchronize do
-              @stderr_client&.close rescue nil
-              @stderr_client = client
-            end
-          else
-            Thread.new(client) { |sock| handle_connection(sock) }
-          end
-        end
-      end
-    rescue IOError, Errno::EBADF
-      # Server was closed, exit gracefully
-    end
-
-    def take_stderr_client
-      @stderr_mutex.synchronize do
-        client = @stderr_client
-        @stderr_client = nil
-        client
-      end
-    end
-
-    def handle_connection(socket)
-      unless IO.select([socket], nil, nil, CONNECTION_TIMEOUT)
-        logger.warn "connection timed out"
-        socket.write("ERROR: connection timeout\n") rescue nil
-        return
-      end
-
-      line = socket.gets
-      return unless line
-
-      parts = Shellwords.split(line.strip)
-      logger.info "command: #{parts.join(' ')}" unless parts.empty?
-
-      # Grab the stderr socket if one is waiting
-      stderr_io = take_stderr_client
-
-      Hotswap::CLI.run(
-        parts,
-        stdin: socket,
-        stdout: socket,
-        stderr: stderr_io || $stderr
-      )
-    rescue => e
-      logger.error "connection error: #{e.message}"
-      socket.write("ERROR: #{e.message}\n") rescue nil
-    ensure
-      stderr_io&.close rescue nil
-      socket.close rescue nil
-    end
-
-    def cleanup_stale_socket(path)
-      return unless File.exist?(path)
-      begin
-        test = UNIXSocket.new(path)
-        test.close
-        raise Hotswap::Error, "Socket #{path} is already in use"
-      rescue Errno::ECONNREFUSED, Errno::ENOENT
-        File.delete(path)
-      end
-    end
-  end
-end