pray-cli 1.11.0 → 1.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cce969add8d5bb73ee6fc4b9910d785a0565e24afaeb6d4b80d9383f9fbe828b
-  data.tar.gz: f96cac68f4cf12079056d0ef300c57ab0efa47f3c9ab1e9967a9fe03cb8a5c37
+  metadata.gz: 58da4ada7990f04bc2acf64b33bca633828a586f0918e1e3ff00cc50ddaeb7c5
+  data.tar.gz: ffc0855f9f9dc6466fe1260905b23d9ab74a5d96905562f8307f472dde851849
 SHA512:
-  metadata.gz: a0ec1da337a61097a65ebd7dc091879a978bbb1f13d6eba41ee4149735e8d37b3d32a7634e5b79fbc426e7ef068cf49ac5437c71b9492fe09f5ab439b1c5645b
-  data.tar.gz: 0ea56f7dd07ddf9be173bc0dd3ed399b91d280c36aaea1f703d0a60b9676dba15398cef53c876f71b3c86347611b9dd5f10af6d716152a69e4bf488d7b82996c
+  metadata.gz: 20cab97de54d753c4f7191f6a68469bbc7f4801e16999e7ca8ee13c0e1c5c27e53b8e0c436695a6f457cb169e7f4389d41407f9e56752cf7fed33c329b5fa94b
+  data.tar.gz: 109496e4410f4bc43f63af51a73ec3439f87348a5c1e94dbed712799416d8e47286360f97bb50e37aaad096f8c0957fc3e2a9a26840167fefe7ea1d6dbb66abd

data/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## Unreleased
 
+## 1.12.1 (2026-09-08)
+
+- Refresh a locked git catalog during `pray install` when a newly declared package is missing from the pinned revision, and name that revision with `pray update` if it is still missing.
+
+## 1.12.0 (2026-09-07)
+
+- Speed up planning for large package trees and reuse the resolved lock during installation.
+- Report duplicate lockfile fields as parsing errors with lockfile context.
+- Restore compose files, provisioned destinations, Prayfile, and lock after failed writes, and recover interrupted writes on the next install, plan, or verification on Unix.
+- Preserve later local edits when recovery encounters changed files, and prevent cooperating Pray commands from writing the same project together.
+- Limit destination reads to 32 MiB, saved transaction payload to 64 MiB across 10,000 writes, and grouped conflict details to 100 entries.
+- Report conflicting file and tree destinations together before changing compose output, with steps that preserve local edits.
+- Reject unsupported update options (`--latest`, `--major`, `--dry-run`, and `--json`) instead of silently ignoring them.
+
 ## 1.11.0 (2026-09-04)
 
 - Read the whole eight byte tar checksum field so `.praypkg` archives whose checksum is written as seven octal digits unpack instead of failing integrity.

data/lib/pray/cli/commands/packages.rb

@@ -15,7 +15,7 @@ module Pray
       declaration = Pray.format_package_declaration(
         ManifestPackage.new(name: name, constraint: constraint || "*", path: path)
       )
-      File.write(manifest_path_value, insert_manifest_statement(manifest_text, declaration))
+      Transaction.write_file(manifest_path_value, insert_manifest_statement(manifest_text, declaration))
     end
 
     def remove_command(name)
@@ -28,7 +28,7 @@ module Pray
         raise Error.manifest("package #{name} not found")
       end
 
-      File.write(manifest_path_value, remove_manifest_statement(manifest_text, name))
+      Transaction.write_file(manifest_path_value, remove_manifest_statement(manifest_text, name))
       install_command({locked: false, frozen: false, offline: false})
     end
 

data/lib/pray/cli/commands/workflow.rb

@@ -76,7 +76,7 @@ module Pray
       )
       rendered = Render.render_project(project)
       lockfile = build_lockfile(project, rendered)
-      previous_lockfile = File.exist?(lockfile_path) ? Pray.read_lockfile(lockfile_path) : nil
+      previous_lockfile = project.previous_lockfile
       preview = Plan.build_materialization_preview(
         project, rendered, lockfile, lockfile_path, previous_lockfile
       )
@@ -84,6 +84,14 @@ module Pray
     end
 
     def update_command(arguments)
+      if arguments.any? { |argument| %w[--dry-run --json].include?(argument) }
+        raise Error.unsupported("this Ruby CLI does not support --dry-run or --json for update; use `pray plan` to preview the current Prayfile")
+      end
+      if arguments.any? { |argument| %w[--latest --major].include?(argument) }
+        raise Error.unsupported(
+          "to update beyond the current constraint, edit the package version in Prayfile, then run `pray update`"
+        )
+      end
       package = arguments.reject { |argument| argument.start_with?("--") }.first
       offline = arguments.include?("--offline")
       if package

data/lib/pray/cli/help.rb

@@ -16,7 +16,7 @@ module Pray
       PACKAGE_COMMANDS = [
         "add <name> [constraint] [--path PATH]  declare a package in Prayfile",
         "remove <name>                          remove a package from Prayfile",
-        "update [package] [--major] [--latest] [--dry-run] [--json]",
+        "update [package]",
         "unlock <package>                       clear a locked package pin",
         "vendor                                 copy resolved packages locally",
         "clean                                  remove local cache and vendor trees"
@@ -101,7 +101,7 @@ module Pray
         "update" => <<~TEXT.strip,
           refresh package versions within constraints
 
-          Usage: pray update [package] [--major] [--latest] [--dry-run] [--json]
+          Usage: pray update [package]
         TEXT
         "plan" => <<~TEXT.strip,
           preview install/apply changes

data/lib/pray/cli.rb

@@ -30,7 +30,11 @@ module Pray
       return if maybe_print_help(arguments)
 
       command = parse_command(arguments)
-      dispatch(command)
+      if %i[install apply update unlock add remove render plan verify drift].include?(command.first)
+        Transaction.run(Invocation.invocation_context.project_root) { dispatch(command) }
+      else
+        dispatch(command)
+      end
     end
 
     def maybe_print_help(arguments)

data/lib/pray/config.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "toml-rb"
+require "perfect_toml"
 
 module Pray
   module Config
@@ -22,14 +22,14 @@ module Pray
       path = user_config_path
       return PrayConfig.new unless path && File.file?(path)
 
-      data = TomlRB.load_file(path)
+      data = PerfectTOML.parse(File.read(path, encoding: "UTF-8"))
       PrayConfig.new(
         local: PrayLocalConfig.new(
           package: data.dig("local", "package") || {},
           source: data.dig("local", "source") || {}
         )
       )
-    rescue TomlRB::ParseError => error
+    rescue PerfectTOML::ParseError => error
       raise Error.parse("config", "#{path}: #{error.message}")
     end
 

data/lib/pray/git_refresh.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Pray
+  module GitRefresh
+    module_function
+
+    def resolution_may_benefit_from_git_source_refresh?(error)
+      error.category == :resolution && catalog_miss_message?(error.message)
+    end
+
+    def catalog_miss_message?(message)
+      message.include?("no registry version") ||
+        message.include?("not found in distribution") ||
+        message.include?("not found in git source") ||
+        message.include?("v1/packages/")
+    end
+
+    def annotate_missing_git_catalog(error, package_name:, source_name:, revision:)
+      return error unless error.category == :resolution
+      return error if revision.to_s.empty?
+      return error unless catalog_miss_message?(error.message)
+      return error if error.message.include?("not found in git source")
+
+      Error.resolution(
+        "package #{package_name} was not found in git source #{source_name} at revision #{revision}. " \
+        "Run `pray update` to advance the source pin."
+      )
+    end
+
+    def annotate_failed_refresh(lockfile_path, error)
+      return error unless error.category == :resolution
+      return error unless catalog_miss_message?(error.message)
+
+      pins = locked_git_revision_guidance(lockfile_path)
+      return error if pins.nil?
+
+      package = package_name_from_catalog_miss(error.message) || "the declared package"
+      Error.resolution(
+        "package #{package} was not found in locked git source (#{pins}). " \
+        "Run `pray update` to advance the source pin."
+      )
+    end
+
+    def locked_git_revision_guidance(lockfile_path)
+      return unless File.exist?(lockfile_path)
+
+      lockfile = LockfileIO.read_lockfile(lockfile_path)
+      pins = lockfile.source.filter_map do |source|
+        next unless source.kind == "git" && source.revision
+
+        "#{source.name} at #{source.revision}"
+      end
+      pins.empty? ? nil : pins.join(", ")
+    rescue Error
+      nil
+    end
+
+    def package_name_from_catalog_miss(message)
+      rest = message.delete_prefix("package ")
+      return if rest == message
+
+      ending = rest.index(" was not found") || rest.index(" not found")
+      return unless ending
+
+      name = rest[0, ending].strip
+      name.empty? ? nil : name
+    end
+  end
+end

data/lib/pray/invocation.rb

@@ -49,10 +49,14 @@ module Pray
       if allow_git_refresh_fallback &&
           !options.offline &&
           !options.refresh &&
-          Resolve.resolution_may_benefit_from_git_source_refresh?(error)
+          GitRefresh.resolution_may_benefit_from_git_source_refresh?(error)
         refreshed = options.dup
         refreshed.refresh = true
-        resolve_current_project(refreshed)
+        begin
+          resolve_current_project(refreshed)
+        rescue Error => retry_error
+          raise GitRefresh.annotate_failed_refresh(lockfile_path, retry_error)
+        end
       else
         raise
       end

data/lib/pray/lockfile.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "toml-rb"
+require "perfect_toml"
 
 require_relative "lockfile_serialize"
 
@@ -125,9 +125,9 @@ module Pray
     end
 
     def parse_lockfile(text)
-      data = TomlRB.parse(text)
+      data = PerfectTOML.parse(text)
       from_hash(data)
-    rescue TomlRB::ParseError => error
+    rescue PerfectTOML::ParseError => error
       raise Error.parse("lockfile", error.message)
     end
 
@@ -144,7 +144,7 @@ module Pray
     end
 
     def write_lockfile(path, lockfile)
-      File.write(path, serialize_lockfile(lockfile))
+      Transaction.write_file(path, serialize_lockfile(lockfile))
     end
 
     def write_lockfile_if_changed(path, lockfile)
@@ -153,7 +153,7 @@ module Pray
         return
       end
 
-      File.write(path, serialized)
+      Transaction.write_file(path, serialized)
     end
 
     def lockfiles_equivalent?(left, right)

data/lib/pray/materialize.rb

@@ -4,7 +4,11 @@ module Pray
   module Materialize
     module_function
 
-    def materialize_project(
+    def materialize_project(**options)
+      Transaction.run(Invocation.invocation_context.project_root) { materialize_in_transaction(**options) }
+    end
+
+    def materialize_in_transaction(
       manifest_path: nil,
       frozen: false,
       locked: false,
@@ -30,17 +34,24 @@ module Pray
         if allow_git_refresh_fallback &&
             !offline &&
             !refresh &&
-            Resolve.resolution_may_benefit_from_git_source_refresh?(error)
+            GitRefresh.resolution_may_benefit_from_git_source_refresh?(error)
           refreshed = options.dup
           refreshed.refresh = true
-          Resolve.resolve_project_in_context(manifest_path, project_root, refreshed)
+          begin
+            Resolve.resolve_project_in_context(manifest_path, project_root, refreshed)
+          rescue Error => retry_error
+            raise GitRefresh.annotate_failed_refresh(
+              default_lockfile_path(project_root),
+              retry_error
+            )
+          end
         else
           raise
         end
       end
       rendered = Render.render_project(project)
       lockfile_path = default_lockfile_path(project.project_root)
-      previous_lockfile = File.exist?(lockfile_path) ? Pray.read_lockfile(lockfile_path) : nil
+      previous_lockfile = project.previous_lockfile
       next_lockfile = LockfileIO.build_lockfile(
         project.manifest_hash,
         project.environment,
@@ -58,7 +69,7 @@ module Pray
         unless File.exist?(lockfile_path)
           raise Error.verify("missing Prayfile.lock; run install first")
         end
-        existing = Pray.read_lockfile(lockfile_path)
+        existing = previous_lockfile
         unless Pray.lockfiles_equivalent?(existing, next_lockfile)
           raise Error.verify("lockfile needs update; rerun install to refresh Prayfile.lock")
         end
@@ -80,7 +91,7 @@ module Pray
       end
 
       if frozen
-        existing = File.exist?(lockfile_path) ? Pray.read_lockfile(lockfile_path) : nil
+        existing = previous_lockfile
         if existing
           rendered.each do |target|
             output_path = File.join(project.project_root, target.path)

data/lib/pray/plan.rb

@@ -10,14 +10,13 @@ module Pray
 
     module_function
 
-    def build_materialization_preview(project, rendered, lockfile, lockfile_path, previous_lockfile)
+    def build_materialization_preview(project, rendered, lockfile, _lockfile_path, previous_lockfile)
+      destinations = RenderDest.validate_destinations!(project, previous_lockfile)
       MaterializationPreview.new(
         package_lines: package_summary_lines(previous_lockfile, lockfile, project),
-        lockfile: lockfile_change_status(lockfile_path, lockfile),
+        lockfile: lockfile_change_status(previous_lockfile, lockfile),
         targets: rendered.map { |target| target_change(project, target) },
-        provisioned: Render.planned_provisioned_files(project).map do |file|
-          provisioned_change(project, file, previous_lockfile)
-        end,
+        provisioned: destinations.map { |file, status| [file.path, status.to_s] },
         warnings: []
       )
     end
@@ -51,10 +50,9 @@ module Pray
       end
     end
 
-    def lockfile_change_status(lockfile_path, lockfile)
-      return "create" unless File.exist?(lockfile_path)
+    def lockfile_change_status(existing, lockfile)
+      return "create" unless existing
 
-      existing = Pray.read_lockfile(lockfile_path)
       Pray.lockfiles_equivalent?(lockfile, existing) ? "unchanged" : "update"
     end
 
@@ -62,7 +60,7 @@ module Pray
       path = File.join(project.project_root, target.path)
       change = if !File.exist?(path)
         "write"
-      elsif File.read(path) == target.content
+      elsif RenderDest.read_regular_bytes(path, target.path) == target.content.b
         "unchanged"
       else
         "update"

data/lib/pray/render.rb

@@ -25,20 +25,10 @@ module Pray
     end
 
     def write_rendered_targets(project, rendered, previous_lockfile = nil)
-      rendered.each do |target|
-        PathSafety.validate_destination_path!(target.path)
-        RenderDest.ensure_safe_destination_ancestors!(project.project_root, target.path, target.path)
-        path = File.join(project.project_root, target.path)
-        FileUtils.mkdir_p(File.dirname(path))
-        RenderDest.ensure_safe_destination_ancestors!(project.project_root, target.path, target.path)
-        RenderDest.write_rendered_content(path, target.path, target.content)
-      end
-      materialize_provisioned_exports(project, previous_lockfile)
+      Transaction.run(project.project_root) { RenderDest.write_rendered_targets(project, rendered, previous_lockfile) }
     end
 
-    def materialize_provisioned_exports(project, previous_lockfile = nil)
-      RenderDest.materialize(project, previous_lockfile)
-    end
+    def materialize_provisioned_exports(project, previous_lockfile = nil) = RenderDest.materialize(project, previous_lockfile)
 
     def expected_provisioned_bytes(source, symbols)
       bytes = File.binread(source)
@@ -306,6 +296,7 @@ module Pray
       raise Error.render("folder source directory missing: #{source_root}") unless File.directory?(source_root)
       raise Error.render("no files listed in package manifest for #{source_root}") if relative_files.empty?
 
+      relative_root = relative_project_path(project, destination_root)
       matched = false
       relative_files.each do |relative|
         next if !only.empty? && !only.include?(relative)
@@ -314,9 +305,9 @@ module Pray
         source = File.join(source_root, relative)
         raise Error.render("provisioned file missing: #{source}") unless File.file?(source)
 
-        destination = File.join(destination_root, relative)
+        destination = Pathname(File.join(relative_root, relative)).cleanpath.to_s
         planned << PlannedProvisionedFile.new(
-          path: relative_project_path(project, destination),
+          path: destination,
           source: source,
           package: package_name,
           export: export_name

data/lib/pray/render_dest.rb

@@ -7,6 +7,19 @@ module Pray
   module RenderDest
     module_function
 
+    def write_rendered_targets(project, rendered, previous_lockfile = nil)
+      validate_destinations!(project, previous_lockfile)
+      rendered.each do |target|
+        PathSafety.validate_destination_path!(target.path)
+        ensure_safe_destination_ancestors!(project.project_root, target.path, target.path)
+        path = File.join(project.project_root, target.path)
+        FileUtils.mkdir_p(File.dirname(path))
+        ensure_safe_destination_ancestors!(project.project_root, target.path, target.path)
+        write_rendered_content(path, target.path, target.content)
+      end
+      materialize(project, previous_lockfile)
+    end
+
     def materialize(project, previous_lockfile = nil)
       planned = Render.planned_provisioned_files(project)
       previous = previous_map(previous_lockfile)
@@ -40,15 +53,40 @@ module Pray
       Array(lockfile.provisioned).to_h { |record| [record.path, record] }
     end
 
-    def destination_status(project, file, previous_lockfile = nil)
+    def destination_status(project, file, previous_lockfile = nil, previous = previous_map(previous_lockfile))
       PathSafety.validate_destination_path!(file.path)
       ensure_safe_destination_ancestors!(project.project_root, file.path, file.path)
       destination = File.join(project.project_root, file.path)
       expected = Render.expected_provisioned_bytes(file.source, project.manifest.symbols || {})
-      record = previous_map(previous_lockfile)[file.path.to_s.tr("\\", "/")]
+      record = previous[file.path.to_s.tr("\\", "/")]
       classify_destination(destination, file.path, expected, record)
     end
 
+    def validate_destinations!(project, previous_lockfile = nil)
+      errors = []
+      statuses = []
+      omitted = 0
+      diagnostic_bytes = 0
+      previous = previous_map(previous_lockfile)
+      Render.planned_provisioned_files(project).each do |file|
+        statuses << [file, destination_status(project, file, previous_lockfile, previous)]
+      rescue Error => error
+        raise unless error.category == :render
+
+        message = "#{error.message} (package `#{file.package}`, export `#{file.export}`)"
+        if errors.length < 100 && diagnostic_bytes + message.bytesize < 60 * 1024
+          diagnostic_bytes += message.bytesize
+          errors << message
+        else
+          omitted += 1
+        end
+      end
+      errors << "#{omitted} additional destination conflicts omitted; resolve the listed paths and run `pray plan` again" if omitted > 0
+      raise Error.render(errors.join("\n")) unless errors.empty?
+
+      statuses
+    end
+
     def write_leaf(project, file, previous)
       PathSafety.validate_destination_path!(file.path)
       ensure_safe_destination_ancestors!(project.project_root, file.path, file.path)
@@ -84,11 +122,11 @@ module Pray
       return :update if record && Hashing.sha256_prefixed(on_disk) == record.content_hash
 
       if record
-        raise Error.render("refusing to overwrite `#{display}`; it was provisioned and then edited")
+        raise Error.render("refusing to overwrite `#{display}`; it was written by pray and then edited. Inspect your changes and move the file aside, then run `pray install`")
       end
 
       raise Error.render(
-        "refusing to overwrite `#{display}`; it already exists and is not the expected provisioned file"
+        "refusing to overwrite `#{display}`; its existing contents differ from this package. Inspect the file and move it aside, then run `pray install`. If an older pray wrote it, restore the original Prayfile and package version, run `pray install`, then retry the update"
       )
     end
 
@@ -104,7 +142,7 @@ module Pray
         on_disk = read_regular_bytes(destination, record.path)
         if Hashing.sha256_prefixed(on_disk) == record.content_hash
           ensure_safe_destination_ancestors!(project.project_root, record.path, record.path)
-          File.delete(destination)
+          File.delete(destination) unless Transaction.replace(destination, on_disk, nil)
         end
       end
     end
@@ -124,8 +162,10 @@ module Pray
       return create_bytes(path, display, fresh) if destination_kind(path) == :missing
 
       open_regular(path, display, File::RDWR) do |file|
-        existing = decode_utf8(file.read, display)
+        existing = decode_utf8(read_destination_bytes(file, display), display)
         content = RenderPatch.patch_rendered_content(existing, fresh)
+        return if Transaction.replace(path, existing.b, content.b)
+
         file.rewind
         file.truncate(0)
         file.write(content)
@@ -158,6 +198,8 @@ module Pray
     end
 
     def create_bytes(path, display, bytes)
+      return if Transaction.replace(path, nil, bytes.b)
+
       open_path(path, display, File::WRONLY | File::CREAT | File::EXCL) do |file|
         file.write(bytes)
       end
@@ -165,12 +207,14 @@ module Pray
 
     def update_bytes(path, display, bytes, authorized_hash)
       open_regular(path, display, File::RDWR) do |file|
-        on_disk = file.read
+        on_disk = read_destination_bytes(file, display)
         return if on_disk.b == bytes.b
 
         unless Hashing.sha256_prefixed(on_disk) == authorized_hash
-          raise Error.render("refusing to overwrite `#{display}`; it was provisioned and then edited")
+          raise Error.render("refusing to overwrite `#{display}`; it was written by pray and then edited. Inspect your changes and move the file aside, then run `pray install`")
         end
+        return if Transaction.replace(path, on_disk, bytes.b)
+
         file.rewind
         file.truncate(0)
         file.write(bytes)
@@ -178,7 +222,30 @@ module Pray
     end
 
     def read_regular_bytes(path, display)
-      open_regular(path, display, File::RDONLY) { |file| file.read }
+      open_regular(path, display, File::RDONLY) { |file| read_destination_bytes(file, display) }
+    end
+
+    MAX_DESTINATION_BYTES = 32 * 1024 * 1024
+
+    def read_destination_bytes(file, display)
+      if file.stat.size > MAX_DESTINATION_BYTES
+        raise Error.render("refusing to read `#{display}`; destination exceeds the 32 MiB limit")
+      end
+      bytes = +"".b
+      capacity = [file.stat.size + 1, 64 * 1024].min
+      loop do
+        chunk = file.read([capacity, MAX_DESTINATION_BYTES + 1 - bytes.bytesize].min)
+        break unless chunk
+
+        bytes << chunk
+        if bytes.bytesize > MAX_DESTINATION_BYTES
+          raise Error.render("refusing to read `#{display}`; destination exceeds the 32 MiB limit")
+        end
+        break if chunk.bytesize < capacity
+
+        capacity = 64 * 1024
+      end
+      bytes
     end
 
     def decode_utf8(bytes, display)

data/lib/pray/resolve.rb

@@ -3,7 +3,7 @@
 module Pray
   ResolvedProject = Struct.new(
     :manifest_path, :project_root, :manifest, :manifest_hash, :packages,
-    :local_files, :source_revisions, :source_host_keys, :environment
+    :local_files, :source_revisions, :source_host_keys, :environment, :previous_lockfile
   ) do
     def lockfile_hash
       manifest_hash
@@ -107,7 +107,8 @@ module Pray
         local_files: local_files,
         source_revisions: source_revisions,
         source_host_keys: source_host_keys,
-        environment: options.environment
+        environment: options.environment,
+        previous_lockfile: lockfile_hints
       )
     end
 
@@ -126,14 +127,21 @@ module Pray
           !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)
+        begin
+          resolve_project_with_options(manifest_path, refreshed)
+        rescue Error => retry_error
+          raise GitRefresh.annotate_failed_refresh(
+            File.join(File.dirname(File.expand_path(manifest_path)), "Prayfile.lock"),
+            retry_error
+          )
+        end
       else
         raise
       end
     end
 
     def resolution_may_benefit_from_git_source_refresh?(error)
-      error.category == :resolution && error.message.include?("no registry version")
+      GitRefresh.resolution_may_benefit_from_git_source_refresh?(error)
     end
 
     def missing_local_embed_guidance(path)
@@ -227,14 +235,23 @@ module Pray
           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
-          )
+          resolved = begin
+            Registry.resolve_local_registry_package_root(
+              project_root,
+              source_key,
+              distribution_root,
+              declaration,
+              preferred_version: lockfile_preferred_version(lockfile, declaration.name),
+              offline: offline
+            )
+          rescue Error => error
+            raise GitRefresh.annotate_missing_git_catalog(
+              error,
+              package_name: declaration.name,
+              source_name: source.name,
+              revision: checkout.revision
+            )
+          end
           return [resolved.root, resolved.registry_latest_version]
         else
           raise Error.unsupported("source kind #{source.kind} not implemented yet")

data/lib/pray/transaction/journal.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require "base64"
+require "pathname"
+
+module Pray
+  class TransactionJournal
+    MAX_LOG = 96 * 1024 * 1024
+    MAX_SAVED = 64 * 1024 * 1024
+    MAX_FILE = 32 * 1024 * 1024
+    attr_reader :root
+
+    def initialize(root, directory)
+      @root = root
+      @directory = directory
+      @path = File.join(directory, "journal")
+      @saved = 0
+      @entries = 0
+    end
+
+    def append(record)
+      bytes = JSON.generate(record) + "\n"
+      RenderDest.open_regular(@path, "project recovery journal", File::WRONLY | File::APPEND) do |file|
+        raise Error.render("project recovery journal exceeds its 96 MiB limit") if file.size + bytes.bytesize > MAX_LOG
+
+        file.write(bytes)
+        file.fsync
+      end
+    end
+
+    def replace(path, before, after)
+      return if before == after
+
+      display = Pathname.new(File.expand_path(path)).relative_path_from(Pathname.new(root)).to_s.tr("\\", "/")
+      destination(display)
+      validate_budget(before, after)
+      raise changed(display) if self.class.snapshot(path) != before
+
+      mode = before.nil? ? 0o644 : File.lstat(path).mode & 0o777
+      unless File.exist?(@path)
+        TransactionOwner.private_file(@path, &:fsync)
+        append({"type" => "start", "version" => 1})
+        TransactionOwner.sync_directory(@directory)
+      end
+      append({"type" => "write", "entry" => {"path" => display,
+                                             "before" => before.nil? ? nil : Base64.strict_encode64(before),
+                                             "after_hash" => after.nil? ? nil : Hashing.sha256_prefixed(after), "mode" => mode}})
+      @saved += (before&.bytesize || 0) + (after&.bytesize || 0)
+      @entries += 1
+      install(display, before, after, mode)
+    end
+
+    def validate_budget(before, after)
+      if [before, after].compact.any? { |bytes| bytes.bytesize > MAX_FILE }
+        raise Error.render("destination exceeds the 32 MiB limit")
+      end
+      if @saved + (before&.bytesize || 0) + (after&.bytesize || 0) > MAX_SAVED || @entries == 10_000
+        raise Error.render("project write exceeds the 64 MiB or 10000-file recovery limit")
+      end
+    end
+
+    def destination(display)
+      PathSafety.validate_destination_path!(display)
+      if display == ".pray/write-state" || display.start_with?(".pray/write-state/")
+        raise Error.render("destination overlaps project recovery state")
+      end
+      RenderDest.ensure_safe_destination_ancestors!(root, display, display)
+      File.join(root, display)
+    end
+
+    def install(display, expected, bytes, mode)
+      path = destination(display)
+      FileUtils.mkdir_p(File.dirname(path))
+      destination(display)
+      temporary = File.join(@directory, "#{SecureRandom.hex(16)}.stage")
+      unless bytes.nil?
+        TransactionOwner.private_file(temporary) do |file|
+          file.write(bytes)
+          file.chmod(mode & 0o777)
+          file.fsync
+        end
+      end
+      raise changed(display) if self.class.snapshot(path) != expected
+
+      destination(display)
+      if !bytes.nil? && expected.nil?
+        File.link(temporary, path)
+        File.unlink(temporary)
+      elsif !bytes.nil?
+        File.rename(temporary, path)
+      elsif !expected.nil?
+        File.unlink(path)
+      end
+      sync_parents(path)
+    end
+
+    def sync_parents(path)
+      parent = File.dirname(path)
+      loop do
+        begin
+          TransactionOwner.sync_directory(parent)
+        rescue Errno::ENOENT
+          nil
+        end
+        break if parent == root
+
+        parent = File.dirname(parent)
+      end
+    end
+
+    def recover
+      clean_stages
+      return unless File.exist?(@path)
+
+      entries, undone, committed = TransactionRecords.read(@path)
+      unless committed
+        (entries.length - 1).downto(0) do |index|
+          next if undone.include?(index)
+
+          restore(entries[index])
+          append({"type" => "undone", "index" => index})
+        end
+      end
+      File.unlink(@path)
+      TransactionOwner.sync_directory(@directory)
+      @saved = @entries = 0
+      clean_stages
+    rescue ArgumentError
+      raise Error.render("invalid recovery bytes")
+    end
+
+    def restore(entry)
+      before = entry["before"].nil? ? nil : Base64.strict_decode64(entry["before"])
+      raise Error.render("recovery file exceeds 32 MiB") if before && before.bytesize > MAX_FILE
+
+      current = self.class.snapshot(destination(entry["path"]))
+      if current != before
+        current_hash = current.nil? ? nil : Hashing.sha256_prefixed(current)
+        raise changed(entry["path"]) if !current.nil? && current_hash != entry["after_hash"]
+
+        install(entry["path"], current, before, entry["mode"])
+      end
+      # A prior recovery may have stopped before its directory sync completed.
+      sync_parents(destination(entry["path"]))
+    end
+
+    def commit
+      if File.exist?(@path)
+        append({"type" => "commit"})
+        File.unlink(@path)
+        TransactionOwner.sync_directory(@directory)
+      end
+      clean_stages
+    end
+
+    def clean_stages
+      Dir.children(@directory).each do |name|
+        File.unlink(File.join(@directory, name)) if name.match?(/\A[a-f0-9]{32}\.stage\z/)
+      end
+    end
+
+    def self.snapshot(path)
+      (RenderDest.destination_kind(path) == :missing) ? nil : RenderDest.read_regular_bytes(path, path)
+    end
+
+    def changed(display)
+      Error.render("`#{display}` changed during the interrupted write. Inspect your changes and move the file aside, then retry; recovery data remains in .pray/write-state")
+    end
+  end
+end

data/lib/pray/transaction/owner.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "json"
+require "socket"
+require "securerandom"
+
+module Pray
+  module TransactionOwner
+    module_function
+
+    def acquire(directory, path = File.join(directory, "owner"), depth = 0)
+      raise Error.render("too many interrupted lock recoveries; inspect .pray/write-state") if depth > 16
+
+      owner = {"version" => 1, "pid" => Process.pid, "host" => Socket.gethostname, "token" => SecureRandom.hex(16)}
+      linked = publish_owner(directory, path, owner)
+      if linked
+        sync_directory(directory)
+        return -> { File.unlink(path) if read_owner(path)["token"] == owner["token"] }
+      end
+      previous = read_owner(path)
+      if previous["host"] != Socket.gethostname || alive?(previous["pid"])
+        raise Error.render("another pray command owns this project; retry after it finishes")
+      end
+      # The dead owner's unique token serializes stale-lock removal.
+      release = acquire(directory, File.join(directory, "reclaim-#{previous["token"]}"), depth + 1)
+      begin
+        if read_owner(path)["token"] != previous["token"]
+          raise Error.render("project ownership changed; retry the command")
+        end
+        File.unlink(path)
+        acquire(directory, path, depth + 1)
+      ensure
+        release.call
+      end
+    end
+
+    def publish_owner(directory, path, owner)
+      temporary = File.join(directory, "#{owner["token"]}.owner")
+      private_file(temporary) { |file|
+        file.write(JSON.generate(owner))
+        file.fsync
+      }
+      begin
+        File.link(temporary, path)
+        true
+      rescue Errno::EEXIST
+        false
+      ensure
+        File.unlink(temporary)
+      end
+    end
+
+    def read_owner(path)
+      bytes = RenderDest.read_regular_bytes(path, "project write owner")
+      raise Error.render("invalid project write owner") if bytes.bytesize > 4096
+
+      owner = JSON.parse(bytes)
+      unless owner.is_a?(Hash) && owner["version"] == 1 && owner["pid"].is_a?(Integer) && owner["pid"] > 0 &&
+          owner["host"].is_a?(String) && owner["token"].is_a?(String) && owner["token"].match?(/\A[a-f0-9]{32}\z/)
+        raise Error.render("invalid project write owner")
+      end
+      owner
+    rescue JSON::ParserError
+      raise Error.render("invalid project write owner")
+    end
+
+    def alive?(pid)
+      Process.kill(0, pid)
+      true
+    rescue Errno::ESRCH
+      false
+    rescue Errno::EPERM, RangeError
+      true
+    end
+
+    def private_file(path, &block)
+      no_follow = File.const_defined?(:NOFOLLOW) ? File::NOFOLLOW : 0
+      File.open(path, File::WRONLY | File::CREAT | File::EXCL | no_follow, 0o600, &block)
+    end
+
+    def sync_directory(path)
+      return if Gem.win_platform?
+
+      File.open(path, File::RDONLY, &:fsync)
+    end
+  end
+end

data/lib/pray/transaction/records.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Pray
+  module TransactionRecords
+    module_function
+
+    def read(path)
+      bytes = RenderDest.open_regular(path, "project recovery journal", File::RDWR) do |file|
+        raise Error.render("project recovery journal exceeds its 96 MiB limit") if file.size > TransactionJournal::MAX_LOG
+
+        contents = file.read(TransactionJournal::MAX_LOG + 1) || ""
+        raise Error.render("project recovery journal exceeds its 96 MiB limit") if contents.bytesize > TransactionJournal::MAX_LOG
+
+        complete = (contents.rindex("\n") || -1) + 1
+        file.truncate(complete)
+        file.fsync
+        contents.byteslice(0, complete)
+      end
+      parse(bytes)
+    end
+
+    def parse(bytes)
+      entries = []
+      undone = {}
+      committed = false
+      bytes.lines.each_with_index do |line, index|
+        record = JSON.parse(line)
+        case record["type"]
+        when "start"
+          invalid! unless record["version"] == 1 && index == 0
+        when "write"
+          invalid! unless index > 0 && !committed && undone.empty?
+          validate_entry(record["entry"], entries.length)
+          entries << record["entry"]
+        when "undone"
+          invalid! unless !committed && record["index"].is_a?(Integer) && (0...entries.length).cover?(record["index"])
+          undone[record["index"]] = true
+        when "commit"
+          invalid! unless index > 0 && undone.empty? && !committed
+          committed = true
+        else
+          invalid!
+        end
+      end
+      [entries, undone, committed]
+    rescue JSON::ParserError
+      invalid!
+    end
+
+    def validate_entry(entry, count)
+      invalid! if count >= 10_000
+      invalid! unless entry.is_a?(Hash) && entry["path"].is_a?(String)
+      invalid! unless entry["mode"].is_a?(Integer) && (0..0o777).cover?(entry["mode"])
+      invalid! unless entry["before"].nil? || entry["before"].is_a?(String)
+      if entry["after_hash"]
+        invalid! unless entry["after_hash"].is_a?(String) && entry["after_hash"].match?(/\Asha256:[a-f0-9]{64}\z/)
+      end
+      PathSafety.validate_destination_path!(entry["path"])
+    end
+
+    def invalid!
+      raise Error.render("invalid project recovery journal state")
+    end
+  end
+end

data/lib/pray/transaction.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative "transaction/owner"
+require_relative "transaction/journal"
+require_relative "transaction/records"
+
+module Pray
+  module Transaction
+    module_function
+
+    def run(root)
+      root = File.expand_path(root)
+      current = Thread.current[:pray_write_transaction]
+      return yield if current && current.root == root
+      raise Error.render("a command cannot write two projects in one transaction") if current
+
+      RenderDest.ensure_safe_destination_ancestors!(root, ".pray/write-state/owner", "project write state")
+      directory = File.join(root, ".pray/write-state")
+      FileUtils.mkdir_p(directory, mode: 0o700)
+      RenderDest.ensure_safe_destination_ancestors!(root, ".pray/write-state/owner", "project write state")
+      File.open(directory, File::RDONLY | File::NOFOLLOW) { |file| file.chmod(0o700) }
+      [directory, File.join(root, ".pray"), root].each { |path| TransactionOwner.sync_directory(path) }
+      release = TransactionOwner.acquire(directory)
+      begin
+        journal = TransactionJournal.new(root, directory)
+        journal.recover
+        Thread.current[:pray_write_transaction] = journal
+        begin
+          result = yield
+        rescue => error
+          begin
+            journal.recover
+          rescue => recovery
+            raise Error.render("#{error}\nRecovery stopped: #{recovery}")
+          end
+          raise
+        end
+        journal.commit
+        result
+      ensure
+        Thread.current[:pray_write_transaction] = nil
+        release.call
+      end
+    end
+
+    def replace(path, before, after)
+      journal = Thread.current[:pray_write_transaction]
+      return false unless journal
+
+      journal.replace(path, before, after)
+      true
+    end
+
+    def write_file(path, bytes)
+      journal = Thread.current[:pray_write_transaction]
+      return File.binwrite(path, bytes) unless journal
+
+      journal.replace(path, TransactionJournal.snapshot(path), bytes.b)
+    end
+  end
+end

data/lib/pray/trust.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "toml-rb"
+require "perfect_toml"
 require "fileutils"
 
 module Pray
@@ -44,8 +44,8 @@ module Pray
       path = trust_policy_path(home)
       return nil unless File.file?(path)
 
-      parse_policy(TomlRB.load_file(path))
-    rescue TomlRB::ParseError => error
+      parse_policy(PerfectTOML.parse(File.read(path, encoding: "UTF-8")))
+    rescue PerfectTOML::ParseError => error
       raise Error.parse("trust policy", "#{path}: #{error.message}")
     end
 

data/lib/pray/trust_feed.rb

@@ -44,7 +44,7 @@ module Pray
     end
 
     def parse_compromised_toml(body)
-      data = TomlRB.parse(body)
+      data = PerfectTOML.parse(body)
       Array(data["keys"]).filter_map do |entry|
         key = normalize_key(entry["value"].to_s)
         next if key.empty?
@@ -54,7 +54,7 @@ module Pray
           reference: entry["reference"], reported_at: entry["reported_at"]
         )
       end
-    rescue TomlRB::ParseError
+    rescue PerfectTOML::ParseError
       []
     end
 

data/lib/pray/verify.rb

@@ -114,7 +114,7 @@ module Pray
           next
         end
 
-        text = File.read(absolute_path)
+        text = RenderDest.decode_utf8(RenderDest.read_regular_bytes(absolute_path, target_path), target_path)
         rendered_targets[target_path] = text
         lines = text.lines(chomp: true)
         markers = marker_positions(lines)
@@ -165,7 +165,7 @@ module Pray
         )
       end
 
-      VerifyProvisioned.push_findings(project, report)
+      VerifyProvisioned.push_findings(project, report, lockfile)
 
       [report, rendered_targets, fresh_targets]
     end

data/lib/pray/verify_provisioned.rb

@@ -4,8 +4,9 @@ module Pray
   module VerifyProvisioned
     module_function
 
-    def push_findings(project, report)
+    def push_findings(project, report, lockfile)
       push_exclusive_file_export_findings(project, report)
+      previous = RenderDest.previous_map(lockfile)
       Render.planned_provisioned_files(project).each do |file|
         path_text = file.path.to_s.tr("\\", "/")
         absolute = File.join(project.project_root, file.path)
@@ -23,13 +24,20 @@ module Pray
           )
           next
         end
-        destination_bytes = File.binread(absolute)
+        destination_bytes = RenderDest.read_regular_bytes(absolute, path_text)
         expected_bytes = Render.expected_provisioned_bytes(file.source, project.manifest.symbols || {})
-        next if Hashing.sha256_prefixed(destination_bytes) == Hashing.sha256_prefixed(expected_bytes.b)
+        destination_hash = Hashing.sha256_prefixed(destination_bytes)
+        next if destination_hash == Hashing.sha256_prefixed(expected_bytes.b)
 
+        owned = previous[path_text]&.content_hash == destination_hash
+        recovery = if owned
+          "Run `pray install` to restore it."
+        else
+          "Inspect your changes and move the file aside, then run `pray install` to restore it."
+        end
         report.findings << VerificationFinding.new(
           kind: "package_integrity",
-          message: "Provisioned file `#{path_text}` no longer matches package `#{file.package}`. Run `pray install` to restore it."
+          message: "Provisioned file `#{path_text}` no longer matches package `#{file.package}`. #{recovery}"
         )
       end
     end

data/lib/pray/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Pray
-  VERSION = "1.11.0"
-  GENERATED_BY = "pray 1.11.0"
+  VERSION = "1.12.1"
+  GENERATED_BY = "pray 1.12.1"
 end

data/lib/pray.rb

@@ -22,11 +22,13 @@ require_relative "pray/resolve_context"
 require_relative "pray/resolve_source"
 require_relative "pray/resolve_exports"
 require_relative "pray/invocation"
+require_relative "pray/git_refresh"
 require_relative "pray/resolve"
 require_relative "pray/compose_dest"
 require_relative "pray/render_patch"
 require_relative "pray/render"
 require_relative "pray/render_dest"
+require_relative "pray/transaction"
 require_relative "pray/render_layout"
 require_relative "pray/verify_position"
 require_relative "pray/verify_provisioned"

data/pray-cli.gemspec

@@ -39,7 +39,7 @@ Gem::Specification.new do |spec|
     "rubygems_mfa_required" => "true"
   }
 
-  spec.add_dependency "toml-rb", "~> 4.0"
+  spec.add_dependency "perfect_toml", "~> 0.9", ">= 0.9.1"
   spec.add_dependency "base64", "~> 0.2"
 
   spec.add_development_dependency "rspec", "~> 3.13"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pray-cli
 version: !ruby/object:Gem::Version
-  version: 1.11.0
+  version: 1.12.1
 platform: ruby
 authors:
 - Andrei Makarov
@@ -10,19 +10,25 @@ cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: toml-rb
+  name: perfect_toml
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '0.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '0.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.1
 - !ruby/object:Gem::Dependency
   name: base64
   requirement: !ruby/object:Gem::Requirement
@@ -124,6 +130,7 @@ files:
 - lib/pray/error.rb
 - lib/pray/format_manifest.rb
 - lib/pray/format_serialize.rb
+- lib/pray/git_refresh.rb
 - lib/pray/git_sources.rb
 - lib/pray/hashing.rb
 - lib/pray/http_body.rb
@@ -166,6 +173,10 @@ files:
 - lib/pray/sync.rb
 - lib/pray/tar_validation.rb
 - lib/pray/terminal.rb
+- lib/pray/transaction.rb
+- lib/pray/transaction/journal.rb
+- lib/pray/transaction/owner.rb
+- lib/pray/transaction/records.rb
 - lib/pray/trust.rb
 - lib/pray/trust_feed.rb
 - lib/pray/trust_ops.rb