steep 1.10.0 → 2.0.0

data/lib/steep/daemon/server.rb

@@ -0,0 +1,476 @@
+# frozen_string_literal: true
+
+module Steep
+  module Daemon
+    class Server
+      attr_reader :config, :project, :stderr
+      attr_reader :file_tracker, :shutdown_flag
+      attr_reader :warmup_status, :warmup_mutex
+
+      # LSP file change types (from Language Server Protocol specification)
+      FILE_CHANGE_TYPE = {
+        created: 1,
+        changed: 2,
+        deleted: 3
+      }.freeze
+
+      class FileTracker
+        def initialize
+          @mtimes = {}
+          @pending_changes = {}
+          @mutex = Mutex.new
+        end
+
+        def register(paths)
+          @mutex.synchronize do
+            paths.each do |path|
+              key = path.to_s
+              @mtimes[key] ||= safe_mtime(key)
+            end
+          end
+        end
+
+        def record_changes(changes)
+          @mutex.synchronize do
+            changes.each do |path, type|
+              @pending_changes[path] = type
+            end
+          end
+        end
+
+        def flush_pending_changes
+          @mutex.synchronize do
+            changes = @pending_changes.to_a
+            @pending_changes.clear
+
+            changes.each do |path, type|
+              @mtimes[path] = type == :deleted ? nil : safe_mtime(path)
+            end
+
+            changes
+          end
+        end
+
+        def track_and_detect(paths)
+          @mutex.synchronize do
+            changed = [] #: Array[[String, Symbol]]
+            paths.each do |path|
+              key = path.to_s
+              current = safe_mtime(key)
+              old = @mtimes[key]
+
+              if old.nil?
+                @mtimes[key] = current
+                changed << [key, :created] if current
+              elsif current != old
+                @mtimes[key] = current
+                type = current ? :changed : :deleted
+                changed << [key, type]
+              end
+            end
+            changed
+          end
+        end
+
+        private
+
+        def safe_mtime(path)
+          File.mtime(path)
+        rescue Errno::ENOENT
+          nil
+        end
+      end
+
+      def initialize(config:, project:, stderr:)
+        @config = config
+        @project = project
+        @stderr = stderr
+        @shutdown_flag = false
+        @file_tracker = FileTracker.new
+        @warmup_status = :not_started  # :warming_up, :ready, :failed
+        @warmup_mutex = Mutex.new
+      end
+
+      def run
+        Steep.logger.info { "Steep server starting for #{Dir.pwd}" }
+        Steep.logger.info { "PID: #{Process.pid}" }
+
+        client_read, server_write = IO.pipe
+        server_read, client_write = IO.pipe
+
+        client_reader = LanguageServer::Protocol::Transport::Io::Reader.new(client_read)
+        client_writer = LanguageServer::Protocol::Transport::Io::Writer.new(client_write)
+        server_reader = LanguageServer::Protocol::Transport::Io::Reader.new(server_read)
+        server_writer = LanguageServer::Protocol::Transport::Io::Writer.new(server_write)
+
+        job_count = (ENV["STEEP_SERVER_JOB_COUNT"] || [Etc.nprocessors - 1, 1].max).to_i
+
+        Steep.logger.info { "Starting #{job_count} typecheck worker(s)..." }
+
+        workers = ::Steep::Server::WorkerProcess.start_typecheck_workers(
+          steepfile: @project.steepfile_path,
+          args: [],
+          delay_shutdown: true,
+          steep_command: nil,
+          count: job_count
+        )
+
+        interaction_worker = ::Steep::Server::WorkerProcess.start_worker(
+          :interaction,
+          name: "interaction",
+          steepfile: @project.steepfile_path,
+          steep_command: nil
+        )
+
+        master = ::Steep::Server::Master.new(
+          project: @project,
+          reader: server_reader,
+          writer: server_writer,
+          interaction_worker: interaction_worker,
+          typecheck_workers: workers,
+          refork: true
+        )
+        master.typecheck_automatically = false
+
+        master_thread = Thread.start do
+          Thread.current.abort_on_exception = true
+          master.start
+        end
+
+        Steep.logger.info { "Initializing (loading RBS environment)..." }
+        init_id = SecureRandom.alphanumeric(10)
+        client_writer.write(method: :initialize, id: init_id, params: {})
+        wait_for_response(client_reader, init_id)
+
+        all_paths = collect_all_project_paths
+        @file_tracker.register(all_paths)
+
+        Steep.logger.info { "Server ready. Tracking #{all_paths.size} files." }
+        Steep.logger.info { "Socket: #{@config.socket_path}" }
+
+        # SAFE: Verify socket path is actually a socket before deleting (prevents symlink attacks)
+        if File.exist?(@config.socket_path)
+          unless File.socket?(@config.socket_path)
+            raise "#{@config.socket_path} exists but is not a socket (possible symlink attack)"
+          end
+          File.delete(@config.socket_path)
+        end
+        @unix_server = UNIXServer.new(@config.socket_path)
+        # SAFE: Restrict socket access to owner only (prevents unauthorized connections)
+        File.chmod(0600, @config.socket_path)
+
+        warmup_thread = Thread.new do
+          Thread.current.abort_on_exception = false
+          set_warmup_status(:warming_up)
+          stderr.puts "Warming up type checker (loading gem signatures and RBS files)..."
+          warm_typecheck_on_startup(client_writer, client_reader)
+          stderr.puts "Warm-up complete. Ready for fast type checking."
+          set_warmup_status(:ready)
+        rescue StandardError => e
+          Steep.logger.error { "Warm-up error: #{e.class}: #{e.message}" }
+          Steep.logger.debug { e.backtrace&.first(10)&.join("\n") }
+          set_warmup_status(:failed)
+        end
+
+        watcher_thread = start_background_watcher(client_writer, client_reader)
+
+        server = @unix_server or raise
+
+        Signal.trap("TERM") { @shutdown_flag = true; server.close rescue nil }
+        Signal.trap("INT")  { @shutdown_flag = true; server.close rescue nil }
+
+        until @shutdown_flag
+          begin
+            ready = IO.select([server], nil, nil, 1) # steep:ignore UnresolvedOverloading
+            next unless ready
+
+            client_socket = server.accept
+
+            unless warmup_ready?
+              sleep 0.1 until warmup_ready? || @shutdown_flag
+            end
+
+            next if @shutdown_flag
+
+            handle_client(client_socket, client_writer, client_reader)
+          rescue IOError, Errno::EBADF
+            break if @shutdown_flag
+            raise
+          rescue StandardError => e
+            Steep.logger.error { "Error handling client: #{e.class}: #{e.message}" }
+            Steep.logger.debug { e.backtrace&.first(10)&.join("\n") }
+          ensure
+            client_socket&.close rescue nil
+          end
+        end
+
+        Steep.logger.info { "Shutting down..." }
+        warmup_thread&.kill
+        watcher_thread&.kill
+        shutdown_master(client_writer, client_reader)
+        master_thread.join(10)
+      rescue StandardError => e
+        Steep.logger.fatal { "Fatal error: #{e.class}: #{e.message}" }
+        Steep.logger.error { e.backtrace&.join("\n") }
+      ensure
+        Daemon.cleanup
+        Steep.logger.info { "Server stopped." }
+      end
+
+      private
+
+      def warmup_ready?
+        @warmup_mutex.synchronize { @warmup_status == :ready }
+      end
+
+      def set_warmup_status(status)
+        @warmup_mutex.synchronize { @warmup_status = status }
+      end
+
+      def handle_client(client_socket, master_writer, master_reader)
+        client_reader = LanguageServer::Protocol::Transport::Io::Reader.new(client_socket)
+        client_writer = LanguageServer::Protocol::Transport::Io::Writer.new(client_socket)
+
+        request = read_one_message(client_reader) or return
+
+        if request[:method] == ::Steep::Server::CustomMethods::TypeCheck::METHOD || request[:method].nil?
+          handle_typecheck_request(request, client_writer, master_writer, master_reader)
+        else
+          handle_lsp_request(request, client_writer, master_writer, master_reader)
+        end
+      rescue Errno::EPIPE, IOError
+        Steep.logger.warn { "Client disconnected during request" }
+      end
+
+      def handle_typecheck_request(request, client_writer, master_writer, master_reader)
+        client_request_id = request[:id]
+        params = request[:params]
+
+        code_count = params[:code_paths]&.size || 0
+        sig_count  = params[:signature_paths]&.size || 0
+        Steep.logger.info { "Check request: #{code_count} code, #{sig_count} signature files" }
+
+        sync_changed_files(master_writer, params)
+
+        request_guid = SecureRandom.uuid
+        master_writer.write(
+          ::Steep::Server::CustomMethods::TypeCheck.request(request_guid, params)
+        )
+
+        master_reader.read do |message|
+          if message[:id] == request_guid
+            client_writer.write({ id: client_request_id, result: message[:result] })
+            return
+          end
+
+          client_writer.write(message)
+        end
+      end
+
+      def handle_lsp_request(request, client_writer, master_writer, master_reader)
+        client_request_id = request[:id]
+        method = request[:method]
+
+        Steep.logger.info { "LSP request: #{method}" }
+
+        request_guid = SecureRandom.uuid
+        master_writer.write({
+          id: request_guid,
+          method: method,
+          params: request[:params]
+        })
+
+        master_reader.read do |message|
+          if message[:id] == request_guid
+            client_writer.write({ id: client_request_id, result: message[:result] })
+            return
+          end
+        end
+      end
+
+      def sync_changed_files(master_writer, params)
+        request_paths = [] #: Array[String]
+        (params[:code_paths] || []).each { |_, path| request_paths << path }
+        (params[:signature_paths] || []).each { |_, path| request_paths << path }
+
+        changes_map = {} #: Hash[String, Symbol]
+        @file_tracker.flush_pending_changes.each { |path, type| changes_map[path] = type }
+        @file_tracker.track_and_detect(request_paths).each { |path, type| changes_map[path] = type }
+
+        return if changes_map.empty?
+
+        Steep.logger.info { "Syncing #{changes_map.size} changed file(s) to workers" }
+
+        lsp_changes = changes_map.map do |path, type|
+          { uri: "file://#{path}", type: FILE_CHANGE_TYPE[type] }
+        end
+
+        master_writer.write(
+          method: "workspace/didChangeWatchedFiles",
+          params: { changes: lsp_changes }
+        )
+      end
+
+      def collect_all_project_paths
+        paths = Set.new
+        loader = ::Steep::Services::FileLoader.new(base_dir: @project.base_dir)
+
+        @project.targets.each do |target|
+          loader.each_path_in_target(target) do |path|
+            abs = @project.absolute_path(path)
+            paths << abs.to_s if abs.file?
+          end
+        end
+
+        sig_dir = @project.base_dir + "sig"
+        if sig_dir.directory?
+          sig_dir.glob("**/*.rbs").each { |p| paths << p.to_s if p.file? }
+        end
+
+        paths.to_a
+      end
+
+      def start_background_watcher(master_writer, master_reader)
+        require "listen"
+
+        watch_dirs = [@project.base_dir.to_s]
+
+        listener = Listen.to(*watch_dirs, only: /\.(rb|rbs)$/, wait_for_delay: 1) do |modified, added, removed|
+          all_paths = modified + added + removed
+          next if all_paths.empty?
+
+          changes = build_lsp_changes(all_paths, added, removed)
+          next if changes.empty?
+
+          has_signature_change = all_paths.any? { |p| p.end_with?(".rbs") }
+
+          Steep.logger.info { "Watcher: #{changes.size} file(s) changed" +
+                              (has_signature_change ? " (includes signatures, pre-warming...)" : "") }
+
+          master_writer.write(
+            method: "workspace/didChangeWatchedFiles",
+            params: { changes: changes }
+          )
+
+          if has_signature_change
+            warm_typecheck(master_writer, master_reader)
+          end
+        rescue StandardError => e
+          Steep.logger.error { "Watcher error: #{e.class}: #{e.message}" }
+          Steep.logger.debug { e.backtrace&.first(5)&.join("\n") }
+        end
+
+        Thread.new do
+          listener.start
+          sleep
+        rescue StandardError => e
+          Steep.logger.error { "Watcher thread error: #{e.class}: #{e.message}" }
+        end
+      end
+
+      def categorize_path_changes(all_paths, added, removed)
+        added_set = added.to_set
+        removed_set = removed.to_set
+
+        all_paths.map do |path|
+          if added_set.include?(path)
+            :created
+          elsif removed_set.include?(path)
+            :deleted
+          else
+            :changed
+          end
+        end
+      end
+
+      def build_lsp_changes(all_paths, added, removed)
+        types = categorize_path_changes(all_paths, added, removed)
+
+        all_paths.zip(types).map do |path, type|
+          { uri: "file://#{path}", type: FILE_CHANGE_TYPE[type || :changed] }
+        end
+      end
+
+      def collect_warmup_files
+        params = { library_paths: [], inline_paths: [], signature_paths: [], code_paths: [] } #: ::Steep::Server::CustomMethods::TypeCheck::params
+        loader = ::Steep::Services::FileLoader.new(base_dir: @project.base_dir)
+
+        @project.targets.each do |target|
+          loader.each_path_in_target(target) do |path|
+            abs = @project.absolute_path(path)
+            if abs.file? && abs.to_s.end_with?(".rb")
+              params[:code_paths] << [target.name.to_s, abs.to_s]
+              break
+            end
+          end
+        end
+
+        params
+      end
+
+      def warm_typecheck(master_writer, master_reader)
+        params = collect_warmup_files
+        return if params[:code_paths].empty?
+
+        guid = SecureRandom.uuid
+        Steep.logger.info { "Watcher: warm-up typecheck started (#{params[:code_paths].size} targets)" }
+        master_writer.write(
+          ::Steep::Server::CustomMethods::TypeCheck.request(guid, params)
+        )
+
+        master_reader.read do |message|
+          if message[:id] == guid
+            Steep.logger.info { "Watcher: warm-up typecheck completed" }
+            break
+          end
+        end
+      end
+
+      def warm_typecheck_on_startup(master_writer, master_reader)
+        params = collect_warmup_files
+
+        if params[:code_paths].empty?
+          Steep.logger.warn { "No Ruby files found for warm-up, skipping" }
+          return
+        end
+
+        guid = SecureRandom.uuid
+        Steep.logger.info { "Checking #{params[:code_paths].size} file(s) to trigger RBS loading..." }
+
+        start_time = Time.now
+        master_writer.write(
+          ::Steep::Server::CustomMethods::TypeCheck.request(guid, params)
+        )
+
+        master_reader.read do |message|
+          if message[:id] == guid
+            elapsed = Time.now - start_time
+            Steep.logger.info { "RBS environment loaded in #{elapsed.round(2)}s" }
+            break
+          end
+        end
+      end
+
+      def wait_for_response(reader, id)
+        reader.read do |message|
+          return message if message[:id] == id
+        end
+      end
+
+      def read_one_message(reader)
+        reader.read do |message|
+          return message
+        end
+      end
+
+      def shutdown_master(writer, reader)
+        id = SecureRandom.alphanumeric(10)
+        writer.write(method: :shutdown, id: id)
+        wait_for_response(reader, id)
+        writer.write(method: :exit)
+      rescue StandardError => e
+        Steep.logger.error { "Shutdown error: #{e.message}" }
+      end
+    end
+  end
+end

data/lib/steep/daemon.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+
+require "steep/daemon/configuration"
+require "steep/daemon/server"
+
+module Steep
+  module Daemon
+    SOCKET_DIR = File.join(Dir.tmpdir, "steep-server")
+
+    LARGE_LOG_FILE_THRESHOLD = 10 * 1024 * 1024
+
+    class << self
+      def config
+        @config ||= Configuration.new
+      end
+
+      def project_id
+        config.project_id
+      end
+
+      def socket_path
+        config.socket_path
+      end
+
+      def pid_path
+        config.pid_path
+      end
+
+      def log_path
+        config.log_path
+      end
+
+      def starting?
+        return false unless File.exist?(pid_path)
+        return false if File.exist?(socket_path)
+
+        pid = File.read(pid_path).to_i
+        Process.kill(0, pid)
+        true
+      rescue Errno::ESRCH, Errno::ENOENT
+        false
+      end
+
+      def running?
+        return false unless File.exist?(pid_path) && File.exist?(socket_path)
+
+        pid = File.read(pid_path).to_i
+        Process.kill(0, pid)
+        socket = UNIXSocket.new(socket_path)
+        socket.close
+        true
+      rescue Errno::ESRCH, Errno::ENOENT, Errno::ECONNREFUSED, Errno::ENOTSOCK
+        false
+      end
+
+      def cleanup
+        [socket_path, pid_path].each do |path|
+          File.delete(path)
+        rescue Errno::ENOENT
+          # File already deleted
+        end
+      end
+
+      def start(stderr:)
+        if running?
+          stderr.puts "Steep server already running (PID: #{File.read(pid_path).strip})"
+          return true
+        end
+
+        cleanup
+
+        unless Steep.can_fork?
+          stderr.puts "The daemon server is not supported on this platform (fork() is not available)"
+          return false
+        end
+
+        child_pid = fork do
+          Process.setsid
+          daemon_pid = fork do
+            File.write(pid_path, Process.pid.to_s)
+            log_file = File.open(log_path, "a")
+            log_file.sync = true
+            $stdout.reopen(log_file)
+            $stderr.reopen(log_file)
+            $stdin.reopen("/dev/null")
+            run_server(stderr:)
+          end
+          exit!(0) if daemon_pid
+        end
+
+        Process.waitpid(child_pid) if child_pid
+
+        40.times do
+          sleep 0.5
+          next unless running?
+
+          stderr.puts "Steep server started (PID: #{File.read(pid_path).strip})"
+          return true
+        end
+
+        stderr.puts "Failed to start steep server. Check log: #{log_path}"
+        false
+      end
+
+      def stop(stderr:)
+        unless File.exist?(pid_path)
+          stderr.puts "Steep server is not running"
+          return
+        end
+
+        pid = File.read(pid_path).to_i
+        Process.kill("TERM", pid)
+        process_alive = true
+        20.times do
+          sleep 0.5
+          Process.kill(0, pid)
+        rescue Errno::ESRCH
+          process_alive = false
+          break
+        end
+
+        if process_alive
+          Process.kill("KILL", pid)
+          stderr.puts "Steep server did not stop gracefully, forcefully killed (PID: #{pid})"
+        else
+          stderr.puts "Steep server stopped (PID: #{pid})"
+        end
+        cleanup
+      rescue Errno::ESRCH
+        cleanup
+        stderr.puts "Steep server was not running (cleaned up stale files)"
+      end
+
+      def status(stderr:)
+        if running?
+          pid = File.read(pid_path).to_i
+          stderr.puts "Steep server running (PID: #{pid})"
+          stderr.puts "  Socket: #{socket_path}"
+          stderr.puts "  Log:    #{log_path}"
+
+          if File.exist?(log_path)
+            log_content = if File.size(log_path) > LARGE_LOG_FILE_THRESHOLD
+                            # SAFE: log_path is controlled internally, no user input
+                            `tail -n 20 #{log_path.shellescape}`
+                          else
+                            File.readlines(log_path).last(20).join
+                          end
+
+            if log_content.include?("Warm-up complete")
+              stderr.puts "  Status: Ready"
+            elsif log_content.include?("Warming up type checker")
+              stderr.puts "  Status: Warming up (loading RBS environment)"
+            else
+              stderr.puts "  Status: Starting"
+            end
+          end
+        else
+          stderr.puts "Steep server is not running"
+
+          if File.exist?(pid_path) || File.exist?(socket_path)
+            stderr.puts "  (Found stale files - run 'steep server stop' to clean up)"
+          end
+        end
+      end
+
+      private
+
+      def run_server(stderr:)
+        project = load_project
+        server = Server.new(config: config, project: project, stderr:)
+        server.run
+      end
+
+      def load_project
+        steep_file = Pathname("Steepfile")
+        steep_file_path = steep_file.realpath
+
+        project = ::Steep::Project.new(steepfile_path: steep_file_path)
+        ::Steep::Project::DSL.parse(project, steep_file.read, filename: steep_file.to_s)
+
+        project.targets.each do |target|
+          case target.options.load_collection_lock
+          when nil, RBS::Collection::Config::Lockfile
+            # OK
+          when RBS::Collection::Config::CollectionNotAvailable
+            config_path = target.options.collection_config_path || raise
+            lockfile_path = RBS::Collection::Config.to_lockfile_path(config_path)
+            RBS::Collection::Installer.new(
+              lockfile_path: lockfile_path, stdout: $stderr
+            ).install_from_lockfile
+            target.options.load_collection_lock(force: true)
+          end
+        end
+
+        project
+      end
+    end
+  end
+end