pray-cli 1.6.0

data/lib/pray/session.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Pray
+  SessionFile = Struct.new(
+    :server_url, :email, :token, :kind, :signer_fingerprint,
+    keyword_init: true
+  )
+
+  module Session
+    module_function
+
+    def session_file_path(root)
+      File.join(root, ".pray", "session.json")
+    end
+
+    def persist(root, session)
+      path = session_file_path(root)
+      FileUtils.mkdir_p(File.dirname(path))
+      sessions = load_sessions(path)
+      existing = sessions.find { |entry| entry.server_url == session.server_url }
+      if existing
+        existing.email = session.email
+        existing.token = session.token
+        existing.kind = session.kind
+        existing.signer_fingerprint = session.signer_fingerprint
+      else
+        sessions << session
+      end
+      document = if sessions.length == 1
+        session_to_hash(sessions.first)
+      else
+        {"sessions" => sessions.map { |entry| session_to_hash(entry) }}
+      end
+      File.write(path, JSON.pretty_generate(document))
+      session
+    end
+
+    def load_latest(root)
+      sessions = load_sessions(session_file_path(root))
+      sessions.reverse.find { |session| !session.email.to_s.strip.empty? }
+    end
+
+    def current_signer(root)
+      session = load_latest(root)
+      return session.email if session && !session.email.to_s.strip.empty?
+
+      "local"
+    end
+
+    def current_signer_fingerprint(root)
+      session = load_latest(root)
+      fingerprint = session&.signer_fingerprint.to_s.strip
+      fingerprint.empty? ? nil : fingerprint
+    end
+
+    def load_sessions(path)
+      return [] unless File.file?(path)
+
+      data = JSON.parse(File.read(path))
+      entries = (data.is_a?(Hash) && data.key?("sessions")) ? data["sessions"] : [data]
+      Array(entries).map { |entry| session_from_hash(entry) }
+    rescue JSON::ParserError => error
+      raise Error.parse("session file", error.message)
+    end
+
+    def session_to_hash(session)
+      hash = {
+        "server_url" => session.server_url,
+        "email" => session.email,
+        "token" => session.token,
+        "kind" => session.kind
+      }
+      hash["signer_fingerprint"] = session.signer_fingerprint if session.signer_fingerprint
+      hash
+    end
+
+    def session_from_hash(entry)
+      SessionFile.new(
+        server_url: entry["server_url"],
+        email: entry["email"],
+        token: entry["token"],
+        kind: entry["kind"],
+        signer_fingerprint: entry["signer_fingerprint"]
+      )
+    end
+  end
+end

data/lib/pray/ssh_agent.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "socket"
+require "base64"
+
+module Pray
+  module SshAgent
+    module_function
+
+    def sign(public_key, message)
+      agent_socket = ENV["SSH_AUTH_SOCK"]
+      raise Error.unsupported("SSH_AUTH_SOCK is not set") if agent_socket.to_s.empty?
+
+      raw_key_bytes = parse_ssh_ed25519_public_key(public_key)
+      public_key_blob = +""
+      write_ssh_string(public_key_blob, "ssh-ed25519")
+      write_ssh_string(public_key_blob, raw_key_bytes)
+
+      payload = +""
+      write_ssh_string(payload, public_key_blob)
+      write_ssh_string(payload, message)
+      write_u32(payload, 0)
+
+      UNIXSocket.open(agent_socket) do |stream|
+        write_ssh_message(stream, 13, payload)
+        message_type, response = read_ssh_message(stream)
+        unless message_type == 14
+          raise Error.resolution("ssh agent returned unexpected message type: #{message_type}")
+        end
+
+        signature_blob = read_ssh_string_bytes(response)
+        parse_ssh_signature_blob(signature_blob)
+      end
+    end
+
+    def parse_ssh_ed25519_public_key(public_key)
+      fields = public_key.split(/\s+/)
+      algorithm = fields[0]
+      raise Error.unsupported("public key must include an algorithm") unless algorithm
+      unless algorithm == "ssh-ed25519"
+        raise Error.unsupported("unsupported public key algorithm: #{algorithm}")
+      end
+
+      key_value = fields[1]
+      raise Error.unsupported("public key must include key bytes") unless key_value
+
+      blob = Base64.decode64(key_value)
+      cursor = blob.b
+      blob_algorithm = read_ssh_string!(cursor)
+      unless blob_algorithm == "ssh-ed25519"
+        raise Error.parse("public key", "ed25519 public key blob must start with ssh-ed25519")
+      end
+
+      key_bytes = read_ssh_string!(cursor)
+      unless key_bytes.bytesize == 32
+        raise Error.parse("public key", "ed25519 public key must be 32 bytes")
+      end
+
+      key_bytes
+    end
+
+    def parse_ssh_signature_blob(signature_blob)
+      cursor = signature_blob.b
+      algorithm = read_ssh_string!(cursor)
+      unless algorithm == "ssh-ed25519"
+        raise Error.unsupported("unsupported ssh signature algorithm: #{algorithm}")
+      end
+
+      Base64.strict_encode64(read_ssh_string!(cursor))
+    end
+
+    def write_ssh_message(stream, message_type, payload)
+      buffer = message_type.chr + payload
+      stream.write([buffer.bytesize].pack("N"))
+      stream.write(buffer)
+    end
+
+    def read_ssh_message(stream)
+      length = stream.read(4)&.unpack1("N")
+      raise Error.resolution("empty ssh agent response") unless length
+
+      buffer = stream.read(length)
+      raise Error.resolution("truncated ssh agent response") if buffer.nil? || buffer.bytesize < 1
+
+      [buffer.getbyte(0), buffer.byteslice(1, buffer.bytesize - 1).to_s]
+    end
+
+    def write_ssh_string(buffer, bytes)
+      bytes = bytes.b
+      buffer << [bytes.bytesize].pack("N")
+      buffer << bytes
+    end
+
+    def write_u32(buffer, value)
+      buffer << [value].pack("N")
+    end
+
+    def read_ssh_string!(cursor)
+      raise Error.resolution("truncated ssh agent response") if cursor.bytesize < 4
+
+      length = cursor.byteslice(0, 4).unpack1("N")
+      cursor.slice!(0, 4)
+      raise Error.resolution("truncated ssh agent response") if cursor.bytesize < length
+
+      value = cursor.byteslice(0, length)
+      cursor.slice!(0, length)
+      value
+    end
+
+    def read_ssh_string_bytes(buffer)
+      cursor = buffer.b
+      read_ssh_string!(cursor)
+    end
+  end
+end

data/lib/pray/statement_surface.rb

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+
+module Pray
+  module StatementSurface
+    module_function
+
+    def expand_statement_surface(statement)
+      trimmed = statement.strip
+      return [] if trimmed.empty?
+
+      Literal.split_top_level(trimmed, ";").flat_map { |segment| expand_one_surface(segment) }
+    end
+
+    def expand_one_surface(statement)
+      trimmed = statement.strip
+      return [] if trimmed.empty?
+
+      braced = expand_brace_block(trimmed)
+      return braced if braced
+
+      [normalize_keyword_call(trimmed)]
+    end
+
+    def expand_brace_block(statement)
+      keyword = leading_identifier(statement)
+      return nil unless keyword
+
+      after_keyword = statement[keyword.length..].lstrip
+      # Only keyword{…}, keyword(…){…}, or keyword "…"{…} — not spec.exports = {…}.
+      header = split_brace_header(after_keyword)
+      return nil unless header
+
+      args, after_open = header
+      close_offset = matching_close_brace(after_open)
+      return nil unless close_offset
+      return nil unless after_open[(close_offset + 1)..].to_s.strip.empty?
+
+      body = after_open[0...close_offset].strip
+      return nil unless Literal.is_balanced?(body)
+
+      header_args = unwrap_outer_parens(args)
+      open = header_args.empty? ? "#{keyword} do" : "#{keyword} #{header_args} do"
+      output = [open]
+      output.concat(expand_statement_surface(body)) unless body.empty?
+      output << "end"
+      output
+    end
+
+    def split_brace_header(after_keyword)
+      if after_keyword.start_with?("{")
+        return ["", after_keyword[1..]]
+      end
+      if after_keyword.start_with?("(")
+        close = matching_close_paren(after_keyword)
+        return nil unless close
+
+        trailing = after_keyword[(close + 1)..].to_s.lstrip
+        return nil unless trailing.start_with?("{")
+
+        return [after_keyword[1...close].strip, trailing[1..]]
+      end
+      first = after_keyword[0]
+      return nil unless ['"', "'", ":"].include?(first)
+
+      brace_offset = find_top_level_char(after_keyword, "{")
+      return nil unless brace_offset
+
+      [after_keyword[0...brace_offset].strip, after_keyword[(brace_offset + 1)..]]
+    end
+
+    def normalize_keyword_call(statement)
+      spaced = normalize_spaced_block_opener(statement)
+      return spaced if spaced
+
+      keyword = leading_identifier(statement)
+      return statement unless keyword
+
+      after_keyword = statement[keyword.length..].lstrip
+      return statement unless after_keyword.start_with?("(")
+
+      close = matching_close_paren(after_keyword)
+      return statement unless close
+
+      inner = after_keyword[1...close].strip
+      trailing = after_keyword[(close + 1)..].to_s.strip
+      trailing.empty? ? "#{keyword} #{inner}" : "#{keyword} #{inner} #{trailing}"
+    end
+
+    def normalize_spaced_block_opener(statement)
+      trimmed = statement.strip
+      %w[pray template].each do |keyword|
+        next unless trimmed.start_with?(keyword)
+
+        rest = trimmed[keyword.length..].lstrip
+        return "#{keyword} do" if rest == "do"
+      end
+      nil
+    end
+
+    def split_symbol_assignment(statement)
+      trimmed = statement.strip
+      call = split_symbol_call(trimmed)
+      return call if call
+
+      match = trimmed.match(/\A(\S+)\s+(.+)\z/)
+      return nil unless match
+
+      key = match[1].strip
+      value = match[2].strip
+      return nil if key.empty? || value.empty?
+
+      [key, value]
+    end
+
+    def split_symbol_call(statement)
+      key = leading_identifier(statement)
+      return nil unless key
+
+      after_key = statement[key.length..].lstrip
+      return nil unless after_key.start_with?("(") && after_key.end_with?(")")
+      return nil unless matching_close_paren(after_key) == after_key.length - 1
+
+      inner = after_key[1...-1].strip
+      return nil if inner.empty?
+
+      [key, inner]
+    end
+
+    def leading_identifier(input)
+      trimmed = input.lstrip
+      end_index = 0
+      while end_index < trimmed.length
+        character = trimmed[end_index]
+        break unless character.match?(/[A-Za-z0-9_]/)
+
+        end_index += 1
+      end
+      return nil if end_index.zero?
+
+      ident = trimmed[0...end_index]
+      return nil unless ident[0].match?(/[A-Za-z]/)
+
+      ident
+    end
+
+    def unwrap_outer_parens(input)
+      trimmed = input.strip
+      if trimmed.start_with?("(") && matching_close_paren(trimmed) == trimmed.length - 1
+        return trimmed[1...-1].strip
+      end
+
+      trimmed
+    end
+
+    def matching_close_paren(input)
+      matching_close_delimited(input, "(", ")")
+    end
+
+    def matching_close_brace(input)
+      depth = 1
+      quote = nil
+      escaped = false
+      input.each_char.with_index do |character, index|
+        if quote
+          if escaped
+            escaped = false
+          elsif character == "\\"
+            escaped = true
+          elsif character == quote
+            quote = nil
+          end
+          next
+        end
+
+        case character
+        when '"', "'"
+          quote = character
+        when "{"
+          depth += 1
+        when "}"
+          depth -= 1
+          return index if depth.zero?
+        end
+      end
+      nil
+    end
+
+    def matching_close_delimited(input, open, close)
+      return nil unless input.start_with?(open)
+
+      depth = 0
+      quote = nil
+      escaped = false
+      input.each_char.with_index do |character, index|
+        if quote
+          if escaped
+            escaped = false
+          elsif character == "\\"
+            escaped = true
+          elsif character == quote
+            quote = nil
+          end
+          next
+        end
+
+        if character == open
+          depth += 1
+        elsif character == close
+          depth -= 1
+          return index if depth.zero?
+        end
+      end
+      nil
+    end
+
+    def find_top_level_char(input, needle)
+      depth = 0
+      quote = nil
+      escaped = false
+      input.each_char.with_index do |character, index|
+        if quote
+          if escaped
+            escaped = false
+          elsif character == "\\"
+            escaped = true
+          elsif character == quote
+            quote = nil
+          end
+          next
+        end
+
+        case character
+        when '"', "'"
+          quote = character
+        when "(", "[", "{"
+          return index if depth.zero? && character == needle
+
+          depth += 1
+        when ")", "]", "}"
+          depth -= 1
+        else
+          return index if depth.zero? && character == needle
+        end
+      end
+      nil
+    end
+
+    class Reader
+      def initialize
+        @pending = []
+      end
+
+      def push_raw(statement)
+        @pending.concat(StatementSurface.expand_statement_surface(statement))
+      end
+
+      def next
+        @pending.shift
+      end
+    end
+  end
+end

data/lib/pray/substitute.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Pray
+  module Substitute
+    PLACEHOLDER_PREFIX = "((pray:"
+    PLACEHOLDER_SUFFIX = "))"
+
+    module_function
+
+    def pray_symbol_key?(key)
+      return false if key.nil? || key.empty?
+
+      key.match?(/\A[A-Za-z0-9._\/-]+\z/)
+    end
+
+    def substitute_pray_symbols(text, symbols)
+      lookup = symbols.is_a?(Hash) ? symbols : symbols.to_h
+      output = +""
+      rest = text
+
+      loop do
+        start = rest.index(PLACEHOLDER_PREFIX)
+        unless start
+          output << rest
+          return output
+        end
+
+        output << rest[0...start]
+        after_prefix = rest[(start + PLACEHOLDER_PREFIX.length)..]
+        end_index = after_prefix.index(PLACEHOLDER_SUFFIX)
+        raise Error.render("unclosed ((pray:...) placeholder") unless end_index
+
+        path = after_prefix[0...end_index]
+        unless pray_symbol_key?(path)
+          raise Error.render("invalid ((pray:...)) path `#{path}`")
+        end
+
+        value = lookup[path]
+        unless value
+          raise Error.render(
+            "unknown pray symbol `#{path}`; declare it in `pray do ... end`"
+          )
+        end
+
+        output << value
+        rest = after_prefix[(end_index + PLACEHOLDER_SUFFIX.length)..]
+      end
+    end
+  end
+end