pray-cli 1.6.0

data/lib/pray/resolve.rb

@@ -0,0 +1,396 @@
+# frozen_string_literal: true
+
+module Pray
+  ResolvedProject = Struct.new(
+    :manifest_path, :project_root, :manifest, :manifest_hash, :packages,
+    :local_files, :source_revisions, :source_host_keys, :environment
+  ) do
+    def lockfile_hash
+      manifest_hash
+    end
+  end
+
+  ResolvedPackage = Struct.new(
+    :declaration, :root, :spec, :tree_hash, :artifact_hash, :artifact,
+    :selected_exports, :source_checksum, :export_bodies, :skill_files,
+    :signer_fingerprint, :registry_latest_version
+  )
+
+  ResolvedLocalFile = Struct.new(
+    :path, :manifest_path, :content, :position, :optional
+  )
+
+  module Resolve
+    module_function
+
+    def project_root_from_manifest(manifest_path)
+      parent = File.dirname(manifest_path)
+      (parent.empty? || parent == ".") ? "." : parent
+    end
+
+    def canonical_project_root(manifest_path)
+      root = project_root_from_manifest(manifest_path)
+      return Pathname(root).cleanpath.to_s if Pathname(root).absolute?
+
+      File.expand_path(root)
+    end
+
+    def resolve_project(manifest_path, offline: false, refresh: false, environment: nil)
+      options = ResolveOptions.new(offline: offline, refresh: refresh, environment: environment)
+      resolve_project_with_options(manifest_path, options)
+    end
+
+    def resolve_project_with_options(manifest_path, options = ResolveOptions.new)
+      project_root = canonical_project_root(manifest_path)
+      resolve_project_in_context(manifest_path, project_root, options)
+    end
+
+    def resolve_project_in_context(manifest_path, project_root, options = ResolveOptions.new)
+      user_config = Config.load_user_config
+      lockfile_path = File.join(project_root, "Prayfile.lock")
+      lockfile_hints = File.exist?(lockfile_path) ? Pray.read_lockfile(lockfile_path) : nil
+      manifest_text = Pray.read_manifest_text(manifest_path)
+      manifest = Pray.parse_manifest(manifest_text)
+      manifest.deprecation_warnings.each { |warning| warn(warning) }
+      Environment.validate_environment(manifest, options.environment)
+      manifest_hash = manifest.manifest_hash
+      sources = source_map(manifest.sources)
+      git_sources = GitSources.prepare_git_sources(
+        project_root,
+        manifest.sources,
+        lockfile_hints,
+        refresh: options.refresh || options.refresh_source_revisions
+      )
+      source_revisions = git_sources.transform_values(&:revision)
+      source_host_keys = Trust.prepare_source_host_keys(manifest.sources)
+
+      packages = []
+      seen = {}
+      errors = []
+      manifest.packages.each do |declaration|
+        package = resolve_package(
+          project_root,
+          sources,
+          git_sources,
+          user_config,
+          declaration,
+          lockfile_hints,
+          offline: options.offline
+        )
+        if seen[package.declaration.name]
+          raise Error.resolution("duplicate package declaration: #{package.declaration.name}")
+        end
+
+        seen[package.declaration.name] = true
+        packages << package
+      rescue Error => error
+        errors << "#{declaration.name}: #{error.message}"
+      end
+      raise Error.resolution(errors.join("\n")) unless errors.empty?
+
+      local_files = []
+      local_errors = []
+      manifest.local.each do |local|
+        local_files << resolve_local_file(project_root, local)
+      rescue Error => error
+        local_errors << "local #{local.path}: #{error.message}"
+      end
+      raise Error.resolution(local_errors.join("\n")) unless local_errors.empty?
+
+      ResolvedProject.new(
+        manifest_path: manifest_path,
+        project_root: project_root,
+        manifest: manifest,
+        manifest_hash: manifest_hash,
+        packages: packages,
+        local_files: local_files,
+        source_revisions: source_revisions,
+        source_host_keys: source_host_keys,
+        environment: options.environment
+      )
+    end
+
+    def resolve_project_with_git_refresh_fallback(
+      manifest_path,
+      offline: false,
+      refresh: false,
+      allow_git_refresh_fallback: false,
+      environment: nil
+    )
+      options = ResolveOptions.new(offline: offline, refresh: refresh, environment: environment)
+      resolve_project_with_options(manifest_path, options)
+    rescue Error => error
+      if allow_git_refresh_fallback &&
+          !offline &&
+          !refresh &&
+          resolution_may_benefit_from_git_source_refresh?(error)
+        refreshed = ResolveOptions.new(offline: offline, refresh: true, environment: environment)
+        resolve_project_with_options(manifest_path, refreshed)
+      else
+        raise
+      end
+    end
+
+    def resolution_may_benefit_from_git_source_refresh?(error)
+      error.category == :resolution && error.message.include?("no registry version")
+    end
+
+    def missing_local_embed_guidance(path)
+      "Prayfile lists `local \"#{path}\"` but the file does not exist. " \
+        "Create the file or remove the entry from Prayfile, then run `pray install`."
+    end
+
+    def resolve_package(project_root, sources, git_sources, user_config, declaration, lockfile, offline: false)
+      root, registry_latest_version = resolve_package_root_with_metadata(
+        project_root, sources, git_sources, user_config, declaration, lockfile, offline: offline
+      )
+      spec_path = find_prayspec_file(root)
+      spec_text = File.read(spec_path)
+      spec = Pray.parse_package_spec(spec_text).canonicalized
+      if spec.name != declaration.name
+        raise Error.resolution(
+          "package path #{root.inspect} declares #{spec.name.inspect}, expected #{declaration.name.inspect}"
+        )
+      end
+      unless Constraint.version_satisfies(spec.version, declaration.constraint)
+        raise Error.resolution(
+          "package #{declaration.name} version #{spec.version} does not satisfy constraint #{declaration.constraint}"
+        )
+      end
+
+      selected_exports = select_exports(declaration, spec)
+      file_bytes = load_package_file_bytes(root, spec)
+      tree_hash = PackageSpec.tree_hash_from_file_bytes(file_bytes)
+      export_bodies = load_export_bodies(file_bytes, spec, selected_exports)
+      skill_files = build_skill_file_index(spec)
+
+      ResolvedPackage.new(
+        declaration: declaration,
+        root: root,
+        spec: spec,
+        tree_hash: tree_hash,
+        artifact_hash: tree_hash,
+        artifact: "path:#{File.dirname(spec_path)}",
+        selected_exports: selected_exports,
+        source_checksum: tree_hash,
+        export_bodies: export_bodies,
+        skill_files: skill_files,
+        signer_fingerprint: nil,
+        registry_latest_version: registry_latest_version
+      )
+    end
+
+    def resolve_package_root_with_metadata(
+      project_root, sources, git_sources, user_config, declaration, lockfile, offline: false
+    )
+      if (local_path = user_config.local.package[declaration.name])
+        return [File.expand_path(local_path, project_root), nil]
+      end
+      return [File.expand_path(declaration.path, project_root), nil] if declaration.path
+
+      if declaration.source
+        source = sources[declaration.source]
+        raise Error.resolution("unknown source: #{declaration.source}") unless source
+
+        if (local_path = user_config.local.source[declaration.source])
+          source_root = File.expand_path(local_path, project_root)
+          resolved = Registry.resolve_local_registry_package_root(
+            project_root,
+            "local:#{declaration.source}",
+            source_root,
+            declaration,
+            preferred_version: lockfile_preferred_version(lockfile, declaration.name),
+            offline: offline
+          )
+          return [resolved.root, resolved.registry_latest_version]
+        end
+
+        case source.kind
+        when "path"
+          return [File.join(project_root, source.url, declaration.name.tr("/", "-")), nil]
+        when "registry", "static index"
+          resolved = Registry.resolve_registry_package_root(
+            project_root,
+            source.url,
+            declaration,
+            preferred_version: lockfile_preferred_version(lockfile, declaration.name),
+            offline: offline
+          )
+          return [resolved.root, resolved.registry_latest_version]
+        when "pray_ssh"
+          raise Error.unsupported("pray_ssh sources are not implemented yet in pray-cli Ruby")
+        when "git"
+          checkout = git_sources[source.name]
+          raise Error.resolution("git source #{source.name} was not prepared") unless checkout
+
+          clone_url = source.url.delete_prefix("git+")
+          distribution_root = GitSources.resolve_distribution_root(checkout.cache_directory, checkout.subdir)
+          source_key = checkout.revision.to_s.empty? ? clone_url : "#{clone_url}@#{checkout.revision}"
+          resolved = Registry.resolve_local_registry_package_root(
+            project_root,
+            source_key,
+            distribution_root,
+            declaration,
+            preferred_version: lockfile_preferred_version(lockfile, declaration.name),
+            offline: offline
+          )
+          return [resolved.root, resolved.registry_latest_version]
+        else
+          raise Error.unsupported("source kind #{source.kind} not implemented yet")
+        end
+      end
+
+      if declaration.git || declaration.tarball || declaration.oci
+        raise Error.unsupported("remote sources are not implemented yet")
+      end
+
+      [File.join(project_root, declaration.name.tr("/", "-")), nil]
+    end
+
+    def resolve_package_root(project_root, sources, git_sources, user_config, declaration, lockfile = nil)
+      resolve_package_root_with_metadata(project_root, sources, git_sources, user_config, declaration, lockfile).first
+    end
+
+    def lockfile_preferred_version(lockfile, package_name)
+      return nil unless lockfile
+
+      lockfile.package.find { |entry| entry.name == package_name }&.version
+    end
+
+    def resolve_local_file(project_root, declaration)
+      path = File.join(project_root, declaration.path)
+      unless File.exist?(path)
+        if declaration.optional
+          return ResolvedLocalFile.new(
+            path: path,
+            manifest_path: declaration.path,
+            content: "",
+            position: declaration.position,
+            optional: true
+          )
+        end
+        raise Error.resolution(missing_local_embed_guidance(declaration.path))
+      end
+
+      ResolvedLocalFile.new(
+        path: path,
+        manifest_path: declaration.path,
+        content: Hashing.normalize_line_endings(File.read(path)),
+        position: declaration.position,
+        optional: declaration.optional
+      )
+    end
+
+    def find_prayspec_file(root)
+      files = Dir.children(root).filter_map do |entry|
+        path = File.join(root, entry)
+        (File.file?(path) && File.extname(entry) == ".prayspec") ? path : nil
+      end
+      case files.length
+      when 1 then files.first
+      when 0 then raise Error.resolution("no prayspec file found in #{root.inspect}")
+      else raise Error.resolution("multiple prayspec files found in #{root.inspect}")
+      end
+    end
+
+    def source_map(sources)
+      sources.to_h { |source| [source.name, source] }
+    end
+
+    def select_exports(declaration, spec)
+      unless declaration.exports.empty?
+        declaration.exports.each do |export|
+          unless spec.exports.key?(export)
+            raise Error.resolution("package #{declaration.name} does not export #{export}")
+          end
+        end
+        return declaration.exports
+      end
+
+      roles = declaration.roles || []
+      return spec.exports.keys.sort if roles.empty? && declaration.file.nil?
+
+      effective_roles = roles.dup
+      effective_roles << "file" if declaration.file && !effective_roles.include?("file")
+
+      selected = []
+      effective_roles.each do |role|
+        compatible = spec.exports.filter_map do |name, export|
+          name if Destination.export_kind_matches_role?(export.kind, role)
+        end
+        case compatible.length
+        when 1
+          selected << compatible.first unless selected.include?(compatible.first)
+        when 0
+          raise Error.resolution(
+            "package #{declaration.name} has no export compatible with #{role}"
+          )
+        else
+          raise Error.resolution(
+            "package #{declaration.name} has multiple exports compatible with #{role}; set export: \"name\""
+          )
+        end
+      end
+      selected
+    end
+
+    def load_package_file_bytes(root, spec)
+      file_bytes = {}
+      spec.files.each do |file|
+        path = File.join(root, file)
+        raise Error.integrity("package file missing: #{file}") unless File.exist?(path)
+        raise Error.integrity("package file is a directory: #{file}") if File.directory?(path)
+
+        file_bytes[file] = File.binread(path)
+      end
+      file_bytes
+    end
+
+    def load_export_bodies(file_bytes, spec, selected_exports)
+      export_bodies = {}
+      selected_exports.each do |export_name|
+        entry = spec.exports[export_name]
+        raise Error.resolution("package #{spec.name} is missing export #{export_name}") unless entry
+        next unless entry.kind == "fragment"
+
+        bytes = file_bytes[entry.path]
+        raise Error.integrity("package file missing for export #{export_name}: #{entry.path}") unless bytes
+
+        export_bodies[export_name] = Hashing.normalize_line_endings(bytes.force_encoding(Encoding::UTF_8))
+      end
+      export_bodies
+    end
+
+    def build_skill_file_index(spec)
+      index = {}
+      spec.exports.each do |export_name, export|
+        next unless %w[folder skill].include?(export.kind)
+
+        folder_prefix = export.path.delete_suffix("/")
+        files = indexed_files_under_prefix(spec.files, folder_prefix)
+        index[export_name] = files unless files.empty?
+      end
+      spec.skills.each do |skill_name, skill|
+        next if index.key?(skill_name)
+
+        skill_prefix = skill.path.delete_suffix("/")
+        files = indexed_files_under_prefix(spec.files, skill_prefix)
+        index[skill_name] = files unless files.empty?
+      end
+      index
+    end
+
+    def indexed_files_under_prefix(files, prefix)
+      files.filter_map { |file| skill_relative_file(file, prefix) }
+    end
+
+    def skill_relative_file(file, skill_prefix)
+      return nil unless file.start_with?(skill_prefix)
+
+      relative = file.delete_prefix(skill_prefix).delete_prefix("/")
+      return nil if relative.empty? || file == skill_prefix
+
+      relative
+    end
+  end
+end

data/lib/pray/resolve_context.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Pray
+  ResolveOptions = Struct.new(
+    :offline, :refresh, :unlocked_packages, :refresh_source_revisions,
+    :ignore_locked_versions, :environment
+  ) do
+    def initialize(
+      offline: false,
+      refresh: false,
+      unlocked_packages: Set.new,
+      refresh_source_revisions: false,
+      ignore_locked_versions: false,
+      environment: nil
+    )
+      super
+    end
+  end
+end

data/lib/pray/serve.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "socket"
+require "fileutils"
+require "pathname"
+require "json"
+require_relative "path_safety"
+require_relative "serve_federation"
+
+module Pray
+  module Serve
+    DEFAULT_MAX_CONNECTIONS = 8
+
+    module_function
+
+    def run_server(root:, host: "127.0.0.1", port: 7429, max_connections: DEFAULT_MAX_CONNECTIONS)
+      root = File.expand_path(root)
+      server = TCPServer.new(host, port)
+      connection_slots = SizedQueue.new(max_connections)
+      max_connections.times { connection_slots << true }
+      puts "Serving #{root} on http://#{host}:#{port}"
+
+      loop do
+        socket = server.accept
+        begin
+          connection_slots.pop(true)
+        rescue ThreadError
+          socket.print(service_unavailable)
+          socket.close
+          next
+        end
+
+        Thread.new { serve_connection(root, socket, connection_slots) }
+      rescue Interrupt
+        break
+      end
+    ensure
+      server&.close
+    end
+
+    def serve_connection(root, socket, connection_slots)
+      handle_connection(root, socket)
+    ensure
+      connection_slots << true unless connection_slots.closed?
+      socket.close unless socket.closed?
+    end
+
+    def handle_connection(root, socket)
+      request_line = socket.gets
+      return unless request_line
+
+      method, path, = request_line.split
+      headers = read_headers(socket)
+      body_length = headers["content-length"].to_i
+      body = body_length.positive? ? socket.read(body_length) : ""
+
+      response = dispatch_request(root, method, path, body)
+      socket.print(response)
+    end
+
+    def read_headers(socket)
+      headers = {}
+      loop do
+        line = socket.gets
+        break if line.nil? || line.strip.empty?
+
+        name, value = line.split(":", 2)
+        headers[name.strip.downcase] = value.strip if name && value
+      end
+      headers
+    end
+
+    def dispatch_request(root, method, path, body = "")
+      path = path.split("?", 2).first
+
+      case [method, path]
+      when ["GET", "/.well-known/pray-federation.json"]
+        return ServeFederation.discovery_response(root)
+      when ["GET", "/v1/sync/index"]
+        return ServeFederation.index_response(root)
+      when ["POST", "/v1/confessions"]
+        return ServeFederation.append_confession(root, body)
+      end
+
+      if method == "GET" && path.start_with?("/v1/sync/package/")
+        return ServeFederation.package_response(root, path)
+      end
+
+      return not_found unless method == "GET"
+
+      if path == "/"
+        return html_response("<h1>Pray distribution</h1><p>Root: #{root}</p>")
+      end
+
+      file_path = PathSafety.join_under_root(root, path.delete_prefix("/"))
+      return not_found unless file_path
+      return not_found unless File.file?(file_path)
+
+      content_type = content_type_for(file_path)
+      file_body = File.binread(file_path)
+      ok_response(content_type, file_body)
+    end
+
+    def content_type_for(path)
+      case File.extname(path)
+      when ".json" then "application/json"
+      when ".praypkg" then "application/octet-stream"
+      else "text/plain"
+      end
+    end
+
+    def ok_response(content_type, body)
+      "HTTP/1.1 200 OK\r\nContent-Type: #{content_type}\r\nContent-Length: #{body.bytesize}\r\nConnection: close\r\n\r\n#{body}"
+    end
+
+    def html_response(body)
+      ok_response("text/html", body)
+    end
+
+    def not_found
+      body = "not found"
+      "HTTP/1.1 404 Not Found\r\nContent-Type: text/plain\r\nContent-Length: #{body.bytesize}\r\nConnection: close\r\n\r\n#{body}"
+    end
+
+    def service_unavailable
+      body = "too many connections"
+      "HTTP/1.1 503 Service Unavailable\r\nContent-Type: text/plain\r\nContent-Length: #{body.bytesize}\r\nConnection: close\r\n\r\n#{body}"
+    end
+  end
+end

data/lib/pray/serve_federation.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Pray
+  module ServeFederation
+    module_function
+
+    def discovery_response(root)
+      peers = read_peers(root)
+      body = {
+        "spec" => "pray-federation-v1",
+        "server" => {
+          "name" => "pray",
+          "version" => VERSION,
+          "capabilities" => ["static_registry", "federation"]
+        },
+        "sync" => {
+          "index_url" => "/v1/sync/index",
+          "package_url" => "/v1/sync/package/{name}",
+          "artifact_url" => "/v1/artifacts/{package}/{version}/{artifact}",
+          "since_param" => "since"
+        },
+        "peers" => peers
+      }
+      Serve.ok_response("application/json", JSON.pretty_generate(body))
+    end
+
+    def index_response(root)
+      index = Publish.load_registry_index(root)
+      packages = index.packages.filter_map do |name|
+        metadata = Publish.load_registry_package_metadata(
+          Publish.registry_metadata_path(root, name), name
+        )
+        next if metadata.versions.empty?
+
+        updated_at = metadata.versions.map { |version| version.published_at.to_s }.max || "0"
+        {
+          "name" => name,
+          "updated_at" => updated_at,
+          "url" => "/v1/sync/package/#{name}"
+        }
+      end
+      body = {
+        "spec" => "prayfile-distribution-1",
+        "sync_version" => 0,
+        "packages" => packages
+      }
+      Serve.ok_response("application/json", JSON.pretty_generate(body))
+    end
+
+    def package_response(root, path)
+      name = path.delete_prefix("/v1/sync/package/")
+      metadata_path = Publish.registry_metadata_path(root, name)
+      return Serve.not_found unless File.file?(metadata_path)
+
+      metadata = Publish.load_registry_package_metadata(metadata_path, name)
+      body = {
+        "name" => metadata.name,
+        "updated_at" => metadata.versions.map { |version| version.published_at.to_s }.max || "0",
+        "versions" => metadata.versions.map { |version| transport_version(version) }
+      }
+      Serve.ok_response("application/json", JSON.pretty_generate(body))
+    end
+
+    def append_confession(root, body)
+      FileUtils.mkdir_p(File.join(root, "v1"))
+      path = File.join(root, "v1", "confessions.jsonl")
+      File.open(path, "a") { |file| file.puts(body.to_s.b) }
+      Serve.ok_response("application/json", JSON.generate({"status" => "ok"}))
+    end
+
+    def transport_version(version)
+      hash = {
+        "version" => version.version,
+        "artifact" => version.artifact,
+        "artifact_hash" => version.artifact_hash.to_s,
+        "tree_hash" => version.tree_hash.to_s,
+        "yanked" => version.yanked,
+        "targets" => version.targets,
+        "exports" => version.exports,
+        "published_at" => version.published_at.to_s
+      }
+      if version.signer || version.signer_fingerprint
+        hash["publisher"] = {
+          "id" => version.signer.to_s,
+          "key_fingerprint" => version.signer_fingerprint.to_s
+        }
+      end
+      if version.signature
+        hash["signature"] = {
+          "public_key" => version.signer.to_s,
+          "signature" => version.signature,
+          "value" => version.signature
+        }
+      end
+      hash
+    end
+
+    def read_peers(root)
+      path = File.join(root, "v1", "peers.json")
+      return [] unless File.file?(path)
+
+      Array(JSON.parse(File.read(path)))
+    rescue JSON::ParserError
+      []
+    end
+  end
+end