gienah 0.1.0

data/lib/gienah/manifest.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Gienah
+  Manifest = Value.define(:id, :name, :version, :api_version, :entry, :activation,
+    :capabilities, :contributes, :limits, :root)
+
+  class Manifest
+    REQUIRED = %w[id name version api_version entry].freeze
+    EXACT_CAPABILITIES = %w[
+      buffer.read buffer.edit workspace.read ui.panel ui.command ui.statusbar
+      ui.decoration completion.provide language.define process.exec exec
+    ].freeze
+    LIMITS = %w[memory_mb request_timeout_ms max_message_bytes max_concurrent_requests startup_timeout_ms].freeze
+
+    class << self
+      def load(path)
+        path = File.expand_path(path.to_s)
+        raise ArgumentError, "manifest does not exist" unless File.file?(path)
+
+        from_hash(JSON.parse(strip_jsonc(File.binread(path))), root: File.dirname(path))
+      rescue JSON::ParserError => error
+        raise ProtocolError, "invalid manifest JSON: #{error.message}"
+      end
+
+      def from_hash(value, root: Dir.pwd)
+        raise ProtocolError, "manifest must be an object" unless value.is_a?(Hash)
+        value = value.transform_keys(&:to_s)
+        REQUIRED.each { |key| raise ProtocolError, "manifest missing #{key}" unless value.key?(key) }
+        id = text(value["id"], "id")
+        name = text(value["name"], "name")
+        version = text(value["version"], "version")
+        api_version = positive_integer(value["api_version"], "api_version")
+        entry = text(value["entry"], "entry")
+        raise ProtocolError, "entry must be relative" if Pathname.new(entry).absolute? || entry.split(File::SEPARATOR).include?("..")
+
+        activation = array(value.fetch("activation", []), "activation").map { |item| text(item, "activation") }
+        capabilities = array(value.fetch("capabilities", []), "capabilities").map do |item|
+          capability = text(item, "capability")
+          validate_capability(capability)
+          capability
+        end.uniq.freeze
+        contributes = value.fetch("contributes", {})
+        raise ProtocolError, "contributes must be an object" unless contributes.is_a?(Hash)
+        limits = validate_limits(value.fetch("limits", {}))
+
+        new(id, name, version, api_version, entry, activation.freeze, capabilities,
+          deep_freeze(contributes), limits, File.expand_path(root.to_s)).freeze
+      end
+
+      private
+
+      def text(value, field)
+        raise ProtocolError, "#{field} must be a nonempty String" unless value.is_a?(String) && !value.empty? && !value.include?("\0")
+
+        value
+      end
+
+      def array(value, field)
+        raise ProtocolError, "#{field} must be an Array" unless value.is_a?(Array)
+
+        value
+      end
+
+      def positive_integer(value, field)
+        raise ProtocolError, "#{field} must be a positive Integer" unless value.is_a?(Integer) && value.positive?
+
+        value
+      end
+
+      def validate_capability(value)
+        return if EXACT_CAPABILITIES.include?(value)
+        return if value.match?(/\A(?:fs\.read|fs\.write|net):.+\z/)
+
+        raise ProtocolError, "unknown capability: #{value}"
+      end
+
+      def validate_limits(value)
+        raise ProtocolError, "limits must be an object" unless value.is_a?(Hash)
+
+        normalized = value.transform_keys(&:to_s)
+        normalized.each do |key, number|
+          raise ProtocolError, "unknown limit: #{key}" unless LIMITS.include?(key)
+          raise ProtocolError, "#{key} must be positive" unless number.is_a?(Numeric) && number.finite? && number.positive?
+        end
+        deep_freeze(normalized)
+      end
+
+      def deep_freeze(value)
+        case value
+        when Hash
+          value.each { |key, item| deep_freeze(key); deep_freeze(item) }
+        when Array
+          value.each { |item| deep_freeze(item) }
+        end
+        value.freeze
+      end
+
+      def strip_jsonc(source)
+        output = +""
+        quote = false
+        escaped = false
+        index = 0
+        while index < source.length
+          char = source[index]
+          if quote
+            output << char
+            if escaped
+              escaped = false
+            elsif char == "\\"
+              escaped = true
+            elsif char == '"'
+              quote = false
+            end
+          elsif char == '"'
+            quote = true
+            output << char
+          elsif char == "/" && source[index + 1] == "/"
+            index += 2
+            index += 1 while index < source.length && source[index] != "\n"
+            output << "\n"
+          elsif char == "/" && source[index + 1] == "*"
+            index += 2
+            index += 1 while index + 1 < source.length && source[index, 2] != "*/"
+            index += 1
+          else
+            output << char
+          end
+          index += 1
+        end
+        output.gsub(/,\s*([}\]])/, '\1')
+      end
+    end
+  end
+end

data/lib/gienah/plugin.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Gienah
+  module Plugin
+    module_function
+
+    def export(name, &handler)
+      raise ArgumentError, "name must be a nonempty String" unless name.is_a?(String) && !name.empty?
+      raise ArgumentError, "handler required" unless handler
+
+      exports[name] = handler
+      nil
+    end
+
+    def on(event, &handler)
+      raise ArgumentError, "event must be a nonempty String" unless event.is_a?(String) && !event.empty?
+      raise ArgumentError, "handler required" unless handler
+
+      listeners[event] << handler
+      nil
+    end
+
+    def call(method, params = {})
+      raise LifecycleError, "plugin is not running" unless running?
+
+      id = next_id
+      write(Protocol.request(id, method, params))
+      loop do
+        message = Protocol.read(@input)
+        raise Error, "host closed the connection" unless message
+        return response_value(message) if message["id"] == id && !message.key?("method")
+
+        dispatch(message)
+      end
+    end
+
+    def notify(method, params = {})
+      raise LifecycleError, "plugin is not running" unless running?
+
+      write(Protocol.notification(method, params))
+      nil
+    end
+
+    def capability?(name)
+      @capabilities.include?(name.to_s)
+    end
+
+    def run(input: $stdin, output: $stdout)
+      @input = input
+      @output = output
+      @input.binmode if @input.respond_to?(:binmode)
+      @output.binmode if @output.respond_to?(:binmode)
+      @running = true
+      loop do
+        message = Protocol.read(@input)
+        break unless message
+
+        dispatch(message)
+        break if @stopped
+      end
+      nil
+    ensure
+      @running = false
+    end
+
+    def reset!
+      @exports = {}
+      @listeners = Hash.new { |hash, key| hash[key] = [] }
+      @capabilities = []
+      @sequence = 0
+      @running = false
+      nil
+    end
+
+    def exports
+      @exports ||= {}
+    end
+
+    def listeners
+      @listeners ||= Hash.new { |hash, key| hash[key] = [] }
+    end
+
+    def running?
+      !!@running
+    end
+
+    def next_id
+      @sequence = (@sequence || 0) + 1
+    end
+
+    def write(message)
+      @output.write(Protocol.frame(message))
+      @output.flush
+    end
+
+    def dispatch(message)
+      if message.key?("method")
+        if message.key?("id")
+          write(handle_request(message))
+        else
+          handle_notification(message)
+        end
+      end
+    end
+
+    def handle_request(message)
+      method = message["method"]
+      params = message.fetch("params", {})
+      case method
+      when "initialize"
+        @capabilities = Array(params["capabilities"]).map(&:to_s).freeze
+        Protocol.response(message["id"], result: {"api_version" => params["api_version"]})
+      when "shutdown"
+        @stopped = true
+        Protocol.response(message["id"], result: nil)
+      else
+        handler = exports[method]
+        unless handler
+          return Protocol.response(message["id"], error: {"code" => -32601, "message" => "method not found: #{method}"})
+        end
+        result = handler.arity == 1 ? handler.call(params) : handler.call(self, params)
+        Protocol.response(message["id"], result: result)
+      end
+    rescue StandardError => error
+      Protocol.response(message["id"], error: {"code" => -32000, "message" => "#{error.class}: #{error.message}"})
+    end
+
+    def handle_notification(message)
+      listeners.fetch(message["method"], []).each { |listener| listener.call(message.fetch("params", {})) }
+    end
+
+    def response_value(message)
+      raise Error, message.fetch("error").fetch("message") if message.key?("error")
+
+      message["result"]
+    end
+
+    reset!
+  end
+end

data/lib/gienah/protocol.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Gienah
+  module Protocol
+    MAX_MESSAGE = 4 * 1024 * 1024
+    MAX_HEADER = 16 * 1024
+    module_function
+
+    def frame(message, max_size: MAX_MESSAGE)
+      validate_message(message)
+      body = JSON.generate(message).b
+      raise ProtocolError, "message exceeds #{max_size} bytes" unless body.bytesize.between?(1, max_size)
+
+      "Content-Length: #{body.bytesize}\r\n\r\n".b + body
+    rescue JSON::GeneratorError => error
+      raise ProtocolError, "invalid JSON: #{error.message}"
+    end
+
+    def read(io, max_size: MAX_MESSAGE)
+      headers = {}
+      bytes = 0
+      loop do
+        line = io.gets("\r\n", MAX_HEADER + 1)
+        return nil if line.nil? && headers.empty?
+        raise ProtocolError, "truncated header" unless line&.end_with?("\r\n")
+        raise ProtocolError, "oversized header" if line.bytesize > MAX_HEADER
+        break if line == "\r\n"
+
+        bytes += line.bytesize
+        raise ProtocolError, "oversized headers" if bytes > MAX_HEADER
+        raise ProtocolError, "non-ASCII header" unless line.ascii_only?
+
+        key, value = line.delete_suffix("\r\n").split(":", 2)
+        raise ProtocolError, "invalid header" unless key&.match?(/\A[A-Za-z][A-Za-z0-9-]*\z/) && value
+        key = key.downcase
+        raise ProtocolError, "duplicate header" if headers.key?(key)
+        headers[key] = value.strip
+      end
+
+      raw_length = headers["content-length"]
+      raise ProtocolError, "missing or invalid Content-Length" unless raw_length&.match?(/\A\d+\z/)
+      length = Integer(raw_length, 10)
+      raise ProtocolError, "message exceeds #{max_size} bytes" unless length.between?(1, max_size)
+      body = read_exact(io, length)
+      raise ProtocolError, "truncated body" unless body&.bytesize == length
+      body.force_encoding(Encoding::UTF_8)
+      raise ProtocolError, "invalid UTF-8 body" unless body.valid_encoding?
+      validate_message(JSON.parse(body))
+    rescue JSON::ParserError => error
+      raise ProtocolError, "invalid JSON: #{error.message}"
+    end
+
+    def validate_message(message)
+      raise ProtocolError, "message must be an object" unless message.is_a?(Hash)
+      version = message["jsonrpc"] || message[:jsonrpc]
+      raise ProtocolError, "jsonrpc must be \"2.0\"" unless version == "2.0"
+      method = message["method"] || message[:method]
+      id_present = message.key?("id") || message.key?(:id)
+      has_result = message.key?("result") || message.key?(:result)
+      has_error = message.key?("error") || message.key?(:error)
+      raise ProtocolError, "method must be a nonempty String" if method && (!method.is_a?(String) || method.empty?)
+      if method
+        raise ProtocolError, "request cannot contain result or error" if has_result || has_error
+        params = message["params"] || message[:params]
+        raise ProtocolError, "params must be an object or array" if params && !params.is_a?(Hash) && !params.is_a?(Array)
+      elsif id_present
+        id = message["id"] || message[:id]
+        raise ProtocolError, "invalid response id" unless id.is_a?(Integer) || id.is_a?(String)
+        raise ProtocolError, "response must contain exactly one result or error" unless has_result ^ has_error
+        error = message["error"] || message[:error]
+        raise ProtocolError, "invalid response error" if has_error && (!error.is_a?(Hash) || !error["message"].is_a?(String))
+      else
+        raise ProtocolError, "message must contain method or id"
+      end
+      message
+    end
+
+    def request(id, method, params = {})
+      {"jsonrpc" => "2.0", "id" => id, "method" => method, "params" => params}
+    end
+
+    def notification(method, params = {})
+      {"jsonrpc" => "2.0", "method" => method, "params" => params}
+    end
+
+    def response(id, result: nil, error: nil)
+      raise ArgumentError, "result and error are exclusive" if !error.nil? && !result.nil?
+      value = {"jsonrpc" => "2.0", "id" => id}
+      error.nil? ? value["result"] = result : value["error"] = error
+      value
+    end
+
+    def read_exact(io, size)
+      data = +"".b
+      while data.bytesize < size
+        chunk = io.read(size - data.bytesize)
+        return nil if chunk.nil? || chunk.empty?
+        data << chunk
+      end
+      data
+    end
+    private_class_method :read_exact
+  end
+end

data/lib/gienah/sandbox.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Gienah
+  module Sandbox
+    module_function
+
+    DANGEROUS = /\A(?:fs\.write:|net:|exec\z|process\.exec\z)/
+
+    def dangerous?(capabilities)
+      Array(capabilities).any? { |capability| capability.match?(DANGEROUS) }
+    end
+
+    def policy_for(capabilities, root:)
+      require "saiph"
+      root = File.expand_path(root.to_s)
+      reads = []
+      writes = []
+      network = false
+      exec = false
+      Array(capabilities).each do |capability|
+        case capability
+        when /\Afs\.read:(.+)/
+          reads << path_for(Regexp.last_match(1), root)
+        when /\Afs\.write:(.+)/
+          writes << path_for(Regexp.last_match(1), root)
+        when /\Anet:/
+          network = true
+        when "exec", "process.exec"
+          exec = true
+        end
+      end
+      Saiph::Policy.new((reads + [root]).uniq, writes.uniq, network, exec, ENV.keys)
+    end
+
+    def available?
+      require "saiph"
+      Saiph.available?
+    rescue LoadError, StandardError
+      false
+    end
+
+    def ensure_safe!(capabilities)
+      raise Error, "OS sandbox is unavailable for dangerous capabilities" if dangerous?(capabilities) && !available?
+    end
+
+    def path_for(pattern, root)
+      pattern = pattern.sub("${workspaceFolder}", root)
+      return root if pattern.include?("*") && !pattern.start_with?("/")
+
+      path = pattern.start_with?("/") ? pattern : File.join(root, pattern)
+      wildcard = path.index(/[*?\[]/)
+      File.expand_path(wildcard ? path[0...wildcard].sub(%r{[/\\]\z}, "") : path)
+    end
+    private_class_method :path_for
+  end
+end

data/lib/gienah/testing/fake_plugin.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Gienah
+  module Testing
+    class FakePlugin
+      attr_reader :capabilities
+
+      def initialize(capabilities: [])
+        @exports = {}
+        @notifications = []
+        @capabilities = capabilities.map(&:to_s)
+      end
+
+      def export(method, &handler)
+        @exports[method] = handler
+        self
+      end
+
+      def on_notification(&handler)
+        @notifications << handler
+        self
+      end
+
+      def transport(manifest, &receive)
+        FakeTransport.new(self, manifest, receive)
+      end
+
+      def dispatch(message)
+        method = message["method"]
+        params = message.fetch("params", {})
+        case method
+        when "initialize"
+          @capabilities = Array(params["capabilities"]).map(&:to_s)
+          Protocol.response(message["id"], result: {"api_version" => params["api_version"]})
+        when "shutdown"
+          Protocol.response(message["id"], result: nil)
+        else
+          handler = @exports[method]
+          return Protocol.response(message["id"], error: {"code" => -32601, "message" => "method not found: #{method}"}) unless handler
+          result = handler.arity == 1 ? handler.call(params) : handler.call(self, params)
+          Protocol.response(message["id"], result: result)
+        end
+      rescue StandardError => error
+        Protocol.response(message["id"], error: {"code" => -32000, "message" => "#{error.class}: #{error.message}"})
+      end
+
+      def notify(method, params = {})
+        @notifications.each { |handler| handler.call(method, params) }
+      end
+    end
+
+    class FakeTransport
+      attr_reader :pid
+
+      def initialize(plugin, manifest, receive)
+        @plugin = plugin
+        @manifest = manifest
+        @receive = receive
+        @pid = Process.pid
+        @closed = false
+      end
+
+      def write(message, **)
+        raise Error, "transport is closed" if @closed
+        response = @plugin.dispatch(message)
+        @receive.call(response, nil) if response
+        nil
+      end
+
+      def alive?
+        !@closed
+      end
+
+      def close(**)
+        @closed = true
+        true
+      end
+    end
+  end
+end

data/lib/gienah/transport.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Gienah
+  class Transport
+    attr_reader :pid
+
+    def self.windows?
+      /mswin|mingw/.match?(RbConfig::CONFIG.fetch("host_os"))
+    end
+
+    def self.open(command, cwd: nil, env: {}, policy: nil, &receive)
+      raise ArgumentError, "receiver required" unless receive
+      raise ArgumentError, "command must be a nonempty Array" unless command.is_a?(Array) && !command.empty?
+
+      input_read, input_write = IO.pipe
+      output_read, output_write = IO.pipe
+      error_read, error_write = IO.pipe
+      [input_read, input_write, output_read, output_write, error_read, error_write].each(&:binmode)
+      options = {in: input_read, out: output_write, err: error_write, close_others: true}
+      options[:chdir] = cwd if cwd
+      options[:new_pgroup] = true if windows?
+      pid = if policy
+        require "saiph"
+        Saiph.spawn(command, policy: policy, **options, env: env)
+      else
+        Process.spawn(env, *command, **options)
+      end
+      [input_read, output_write, error_write].each(&:close)
+      new(input_write, output_read, error_read, pid, receive)
+    rescue Exception
+      [input_read, input_write, output_read, output_write, error_read, error_write].compact.each do |io|
+        io.close unless io.closed?
+      end
+      Process.kill("KILL", pid) if pid
+      Process.wait(pid) if pid
+      raise
+    end
+
+    def initialize(input, output, error, pid, receive)
+      @input = input
+      @output = output
+      @error = error
+      @pid = pid
+      @receive = receive
+      @write_lock = Mutex.new
+      @closed = false
+      @reader = Thread.new { read_loop }
+      @reader.report_on_exception = false
+      @stderr_reader = Thread.new { drain_stderr }
+      @stderr_reader.report_on_exception = false
+    end
+
+    def write(message, max_size: Protocol::MAX_MESSAGE)
+      frame = Protocol.frame(message, max_size: max_size)
+      @write_lock.synchronize do
+        raise Error, "transport is closed" if closed?
+
+        @input.write(frame)
+        @input.flush
+      end
+      nil
+    rescue IOError, Errno::EPIPE => error
+      raise Error, "transport write failed: #{error.message}"
+    end
+
+    def alive?
+      !closed? && (@pid.nil? || process_alive?)
+    end
+
+    def close(grace: 0.5)
+      @closed = true
+      @input.close unless @input.closed?
+      joined = @reader == Thread.current || @reader.join(grace)
+      unless joined
+        terminate("TERM")
+        joined = @reader.join(grace)
+      end
+      unless joined
+        terminate("KILL")
+        @reader.join
+      end
+      @stderr_reader.join(grace) unless @stderr_reader == Thread.current
+      [@output, @error].each { |io| io.close unless io.closed? }
+      if @pid && process_alive?
+        terminate("TERM")
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + grace
+        until Process.waitpid(@pid, Process::WNOHANG)
+          break if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+
+          sleep(0.01)
+        end
+        if process_alive?
+          terminate("KILL")
+          Process.wait(@pid)
+        end
+      end
+      true
+    rescue IOError, Errno::ECHILD
+      true
+    end
+
+    private
+
+    def read_loop
+      loop do
+        message = Protocol.read(@output)
+        break unless message
+
+        @receive.call(message, nil)
+      end
+      @receive.call(nil, Error.new("transport closed")) unless @closed
+    rescue StandardError => error
+      @receive.call(nil, error) unless @closed
+    ensure
+      @closed = true
+    end
+
+    def drain_stderr
+      while @error.read(8_192)
+        break if @closed
+      end
+    rescue IOError
+      nil
+    end
+
+    def closed?
+      @closed
+    end
+
+    def process_alive?
+      Process.kill(0, @pid)
+      true
+    rescue Errno::ESRCH, Errno::ECHILD
+      false
+    rescue Errno::EPERM
+      true
+    end
+
+    def terminate(signal)
+      Process.kill(windows? ? "KILL" : signal, @pid)
+    rescue Errno::ESRCH, Errno::ECHILD
+      nil
+    end
+
+    def windows?
+      self.class.windows?
+    end
+  end
+end

data/lib/gienah/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Gienah
+  VERSION = "0.1.0"
+end