igniter 0.5.1 → 0.5.2

data/packages/igniter-application/lib/igniter/application/application_transfer_apply_result.rb

@@ -0,0 +1,321 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "set"
+
+module Igniter
+  module Application
+    class ApplicationTransferApplyResult
+      attr_reader :plan_payload, :committed, :metadata, :applied, :skipped, :refusals
+
+      def self.apply(apply_plan, commit: false, metadata: {})
+        new(apply_plan: apply_plan, commit: commit, metadata: metadata)
+      end
+
+      def initialize(apply_plan:, commit: false, metadata: {})
+        @plan_payload = payload_from(apply_plan)
+        @committed = commit == true
+        @metadata = metadata.dup.freeze
+        @applied = []
+        @skipped = []
+        @refusals = []
+        execute
+        @applied.freeze
+        @skipped.freeze
+        @refusals.freeze
+        freeze
+      end
+
+      def executable?
+        value(plan_payload, :executable) == true
+      end
+
+      def to_h
+        {
+          committed: committed,
+          executable: executable?,
+          applied: applied.map(&:dup),
+          skipped: skipped.map(&:dup),
+          refusals: refusals.map(&:dup),
+          operation_count: operations.length,
+          artifact_path: artifact_path,
+          destination_root: destination_root,
+          surface_count: surface_count,
+          metadata: metadata.dup
+        }
+      end
+
+      private
+
+      def execute
+        return refuse_non_executable_plan unless executable?
+        return refuse_commit_preflight if committed && !commit_refusals.empty?
+
+        operations.each { |operation| execute_operation(operation) }
+      end
+
+      def refuse_non_executable_plan
+        refusals << refusal(
+          :plan_not_executable,
+          "Transfer apply plan is not executable.",
+          entry: { blockers: blockers }
+        )
+        operations.each do |operation|
+          skipped << operation_result(operation, :skipped, reason: :plan_not_executable)
+        end
+      end
+
+      def execute_operation(operation)
+        case operation_type(operation)
+        when :ensure_directory
+          execute_directory_operation(operation)
+        when :copy_file
+          execute_copy_operation(operation)
+        when :manual_host_wiring
+          skipped << operation_result(operation, :skipped, reason: :manual_host_wiring_review_only)
+        else
+          refusals << refusal(:unsupported_operation, "Transfer apply operation type is not supported.", entry: operation)
+        end
+      end
+
+      def execute_directory_operation(operation)
+        destination = destination_path(operation)
+        return unless destination
+
+        if File.exist?(destination) && !File.directory?(destination)
+          refusals << refusal(:destination_not_directory, "Destination path exists and is not a directory.", entry: operation)
+          return
+        end
+
+        FileUtils.mkdir_p(destination) if committed && !File.directory?(destination)
+        applied << operation_result(operation, committed ? :applied : :dry_run)
+      end
+
+      def execute_copy_operation(operation)
+        source = source_path(operation)
+        destination = destination_path(operation)
+        return unless source && destination
+
+        unless File.file?(source)
+          refusals << refusal(:missing_source, "Reviewed artifact source file is missing.", entry: operation)
+          return
+        end
+        if File.exist?(destination)
+          refusals << refusal(:destination_exists, "Destination file already exists.", entry: operation)
+          return
+        end
+        if committed && !File.directory?(File.dirname(destination))
+          refusals << refusal(:destination_parent_missing, "Destination parent directory is missing.", entry: operation)
+          return
+        end
+
+        FileUtils.cp(source, destination) if committed
+        applied << operation_result(operation, committed ? :applied : :dry_run)
+      end
+
+      def refuse_commit_preflight
+        refusals.concat(commit_refusals)
+        operations.each do |operation|
+          reason = operation_type(operation) == :manual_host_wiring ? :manual_host_wiring_review_only : :refusals_present
+          skipped << operation_result(operation, :skipped, reason: reason)
+        end
+      end
+
+      def commit_refusals
+        @commit_refusals ||= (root_refusals + operations.flat_map { |operation| operation_refusals(operation) }).freeze
+      end
+
+      def root_refusals
+        [].tap do |items|
+          items << refusal(:missing_artifact_root, "Transfer apply plan artifact path is missing.", entry: plan_payload) unless
+            artifact_root
+          items << refusal(:missing_destination_root, "Transfer apply plan destination root is missing.", entry: plan_payload) unless
+            destination_root_path
+        end
+      end
+
+      def operation_refusals(operation)
+        return [] unless artifact_root && destination_root_path
+
+        case operation_type(operation)
+        when :ensure_directory
+          directory_refusals(operation)
+        when :copy_file
+          copy_refusals(operation)
+        when :manual_host_wiring
+          []
+        else
+          [refusal(:unsupported_operation, "Transfer apply operation type is not supported.", entry: operation)]
+        end
+      end
+
+      def directory_refusals(operation)
+        destination = reviewed_destination_path(operation)
+        return [refusal(:unsafe_destination_path, "Reviewed destination path is unsafe.", entry: operation)] unless destination
+        return [] unless File.exist?(destination) && !File.directory?(destination)
+
+        [refusal(:destination_not_directory, "Destination path exists and is not a directory.", entry: operation)]
+      end
+
+      def copy_refusals(operation)
+        source = reviewed_source_path(operation)
+        destination = reviewed_destination_path(operation)
+        [].tap do |items|
+          items << refusal(:unsafe_source_path, "Reviewed source path is unsafe.", entry: operation) unless source
+          items << refusal(:unsafe_destination_path, "Reviewed destination path is unsafe.", entry: operation) unless destination
+          next unless source && destination
+
+          items << refusal(:missing_source, "Reviewed artifact source file is missing.", entry: operation) unless
+            File.file?(source)
+          items << refusal(:destination_exists, "Destination file already exists.", entry: operation) if
+            File.exist?(destination)
+          items << refusal(:destination_parent_missing, "Destination parent directory is missing.", entry: operation) unless
+            parent_available_for_commit?(File.dirname(destination))
+        end
+      end
+
+      def source_path(operation)
+        path = reviewed_source_path(operation)
+        return path if path
+
+        unsafe_source(operation)
+      end
+
+      def destination_path(operation)
+        path = reviewed_destination_path(operation)
+        return path if path
+
+        unsafe_destination(operation)
+      end
+
+      def reviewed_source_path(operation)
+        relative = value(operation, :source)
+        root = artifact_root
+        return nil unless root
+        return nil if relative.nil? || !safe_relative_path?(relative)
+
+        path = File.expand_path(relative.to_s, root)
+        inside_root?(path, root) ? path : nil
+      end
+
+      def reviewed_destination_path(operation)
+        relative = value(operation, :destination)
+        root = destination_root_path
+        return nil unless root
+        return nil unless safe_relative_path?(relative)
+
+        path = File.expand_path(relative.to_s, root)
+        inside_root?(path, root) ? path : nil
+      end
+
+      def parent_available_for_commit?(path)
+        File.directory?(path) || reviewed_directory_paths.include?(path)
+      end
+
+      def reviewed_directory_paths
+        @reviewed_directory_paths ||= operations.filter_map do |operation|
+          next unless operation_type(operation) == :ensure_directory
+
+          reviewed_destination_path(operation)
+        end.to_set.freeze
+      end
+
+      def unsafe_source(operation)
+        refusals << refusal(:unsafe_source_path, "Reviewed source path is unsafe.", entry: operation)
+        nil
+      end
+
+      def unsafe_destination(operation)
+        refusals << refusal(:unsafe_destination_path, "Reviewed destination path is unsafe.", entry: operation)
+        nil
+      end
+
+      def operation_result(operation, status, reason: nil)
+        {
+          type: operation_type(operation),
+          status: status,
+          source: value(operation, :source),
+          destination: value(operation, :destination),
+          metadata: operation_metadata(operation),
+          reason: reason
+        }.compact
+      end
+
+      def operation_type(operation)
+        type = value(operation, :type)
+        type.respond_to?(:to_sym) ? type.to_sym : type
+      end
+
+      def operation_metadata(operation)
+        metadata = value(operation, :metadata)
+        metadata.respond_to?(:dup) ? metadata.dup : metadata
+      end
+
+      def payload_from(source)
+        payload = source.respond_to?(:to_h) ? source.to_h : source
+        payload.to_h
+      end
+
+      def operations
+        Array(value(plan_payload, :operations))
+      end
+
+      def blockers
+        Array(value(plan_payload, :blockers))
+      end
+
+      def artifact_path
+        value(plan_payload, :artifact_path).to_s
+      end
+
+      def destination_root
+        value(plan_payload, :destination_root).to_s
+      end
+
+      def artifact_root
+        @artifact_root ||= expanded_root(value(plan_payload, :artifact_path))
+      end
+
+      def destination_root_path
+        @destination_root_path ||= expanded_root(value(plan_payload, :destination_root))
+      end
+
+      def surface_count
+        value(plan_payload, :surface_count) || 0
+      end
+
+      def safe_relative_path?(value)
+        text = value.to_s
+        return false if text.empty?
+        return false if text.start_with?("/", "\\")
+
+        !text.split(%r{[\\/]}).include?("..")
+      end
+
+      def inside_root?(path, root)
+        path == root || path.start_with?("#{root}#{File::SEPARATOR}")
+      end
+
+      def expanded_root(value)
+        text = value.to_s
+        return nil if text.empty?
+
+        File.expand_path(text)
+      end
+
+      def value(hash, key)
+        return hash[key] if hash.key?(key)
+
+        hash[key.to_s]
+      end
+
+      def refusal(code, message, entry:)
+        {
+          code: code,
+          message: message,
+          entry: entry
+        }
+      end
+    end
+  end
+end

data/packages/igniter-application/lib/igniter/application/application_transfer_bundle_artifact.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+
+module Igniter
+  module Application
+    class ApplicationTransferBundleArtifactResult
+      attr_reader :written, :artifact_path, :included_file_count,
+                  :metadata_entry, :refusals, :metadata
+
+      def initialize(written:, artifact_path:, included_file_count:, metadata_entry:, refusals:, metadata: {})
+        @written = written == true
+        @artifact_path = artifact_path.to_s.freeze
+        @included_file_count = included_file_count
+        @metadata_entry = metadata_entry
+        @refusals = Array(refusals).map(&:dup).freeze
+        @metadata = metadata.dup.freeze
+        freeze
+      end
+
+      def written?
+        written
+      end
+
+      def to_h
+        {
+          written: written,
+          artifact_path: artifact_path,
+          included_file_count: included_file_count,
+          metadata_entry: metadata_entry,
+          refusals: refusals.map(&:dup),
+          metadata: metadata.dup
+        }
+      end
+    end
+
+    class ApplicationTransferBundleArtifact
+      METADATA_ENTRY = "igniter-transfer-bundle.json"
+      FILES_ROOT = "files"
+
+      attr_reader :plan, :output, :allow_not_ready, :create_parent, :metadata
+
+      def self.write(plan, output:, allow_not_ready: false, create_parent: false, metadata: {})
+        new(
+          plan: plan,
+          output: output,
+          allow_not_ready: allow_not_ready,
+          create_parent: create_parent,
+          metadata: metadata
+        ).write
+      end
+
+      def initialize(plan:, output:, allow_not_ready: false, create_parent: false, metadata: {})
+        @plan = plan
+        @output = File.expand_path(output.to_s)
+        @allow_not_ready = allow_not_ready == true
+        @create_parent = create_parent == true
+        @metadata = metadata.dup.freeze
+        freeze
+      end
+
+      def write
+        payload = plan_payload
+        refusals = refusal_reasons(payload)
+        return result(payload: payload, refusals: refusals, written: false) unless refusals.empty?
+
+        FileUtils.mkdir_p(File.dirname(output)) if create_parent
+        FileUtils.mkdir_p(File.join(output, FILES_ROOT))
+        write_included_files(payload)
+        write_metadata(payload)
+
+        result(payload: payload, refusals: [], written: true)
+      end
+
+      private
+
+      def plan_payload
+        source = plan.respond_to?(:to_h) ? plan.to_h : plan
+        source.to_h
+      end
+
+      def refusal_reasons(payload)
+        [].tap do |items|
+          items << refusal(:bundle_not_allowed, "Bundle plan is not allowed by readiness/policy.") if
+            !payload.fetch(:bundle_allowed) && !allow_not_ready
+          items << refusal(:output_exists, "Output path already exists.") if File.exist?(output)
+          items << refusal(:parent_missing, "Output parent directory does not exist.") unless
+            create_parent || File.directory?(File.dirname(output))
+          items.concat(entry_refusals(payload))
+        end
+      end
+
+      def entry_refusals(payload)
+        payload.fetch(:included_files, []).each_with_object([]) do |entry, items|
+          items << refusal(:unsafe_entry_path, "Included file path is not safe.", entry: entry) unless safe_entry?(entry)
+          items << refusal(:missing_source, "Included file source does not exist.", entry: entry) unless
+            File.file?(entry.fetch(:absolute_path, ""))
+        end
+      end
+
+      def write_included_files(payload)
+        payload.fetch(:included_files, []).each do |entry|
+          destination = File.join(output, FILES_ROOT, entry.fetch(:capsule).to_s, entry.fetch(:relative_path))
+          FileUtils.mkdir_p(File.dirname(destination))
+          FileUtils.cp(entry.fetch(:absolute_path), destination)
+        end
+      end
+
+      def write_metadata(payload)
+        File.write(
+          File.join(output, METADATA_ENTRY),
+          JSON.pretty_generate(metadata_payload(payload)) << "\n"
+        )
+      end
+
+      def metadata_payload(payload)
+        {
+          kind: :igniter_transfer_bundle,
+          subject: payload.fetch(:subject),
+          bundle_allowed: payload.fetch(:bundle_allowed),
+          included_file_count: payload.fetch(:included_file_count),
+          metadata_entry: METADATA_ENTRY,
+          files_root: FILES_ROOT,
+          plan: payload,
+          metadata: metadata.dup
+        }
+      end
+
+      def result(payload:, refusals:, written:)
+        ApplicationTransferBundleArtifactResult.new(
+          written: written,
+          artifact_path: output,
+          included_file_count: written ? payload.fetch(:included_file_count) : 0,
+          metadata_entry: written ? METADATA_ENTRY : nil,
+          refusals: refusals,
+          metadata: metadata
+        )
+      end
+
+      def safe_entry?(entry)
+        relative_path = entry.fetch(:relative_path, "").to_s
+        capsule = entry.fetch(:capsule, "").to_s
+        return false if relative_path.empty? || capsule.empty?
+        return false if relative_path.start_with?("/", "\\")
+        return false if capsule.start_with?("/", "\\")
+
+        !relative_path.split(%r{[\\/]}).include?("..") && !capsule.split(%r{[\\/]}).include?("..")
+      end
+
+      def refusal(code, message, entry: nil)
+        {
+          code: code,
+          message: message,
+          entry: entry
+        }.compact
+      end
+    end
+  end
+end

data/packages/igniter-application/lib/igniter/application/application_transfer_bundle_plan.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Application
+    class ApplicationTransferBundlePlan
+      DEFAULT_POLICY = {
+        allow_not_ready: false
+      }.freeze
+
+      attr_reader :transfer_readiness, :policy, :metadata, :readiness_payload
+
+      def self.build(transfer_readiness: nil, handoff_manifest: nil, transfer_inventory: nil,
+                     capsules: [], subject: :capsule_transfer, host_exports: [], host_capabilities: [],
+                     mount_intents: [], surface_metadata: [], enumerate_files: true, readiness_policy: {},
+                     policy: {}, metadata: {})
+        readiness = transfer_readiness || ApplicationTransferReadiness.build(
+          handoff_manifest: handoff_manifest,
+          transfer_inventory: transfer_inventory,
+          capsules: capsules.map { |entry| entry.respond_to?(:to_blueprint) ? entry.to_blueprint : entry },
+          subject: subject,
+          host_exports: host_exports,
+          host_capabilities: host_capabilities,
+          mount_intents: mount_intents,
+          surface_metadata: surface_metadata,
+          enumerate_files: enumerate_files,
+          policy: readiness_policy
+        )
+
+        new(transfer_readiness: readiness, policy: policy, metadata: metadata)
+      end
+
+      def initialize(transfer_readiness:, policy: {}, metadata: {})
+        @transfer_readiness = transfer_readiness
+        @policy = normalize_policy(policy)
+        @metadata = metadata.dup.freeze
+        @readiness_payload = transfer_readiness.to_h
+        freeze
+      end
+
+      def ready?
+        readiness_payload.fetch(:ready)
+      end
+
+      def bundle_allowed?
+        ready? || policy.fetch(:allow_not_ready)
+      end
+
+      def to_h
+        {
+          subject: subject,
+          ready: ready?,
+          bundle_allowed: bundle_allowed?,
+          capsules: capsules,
+          included_files: included_files,
+          included_file_count: included_file_count,
+          missing_paths: missing_paths,
+          missing_path_count: missing_paths.length,
+          surfaces: surfaces,
+          blockers: readiness_payload.fetch(:blockers),
+          warnings: readiness_payload.fetch(:warnings),
+          policy: policy.dup,
+          readiness: readiness_payload,
+          metadata: metadata.dup
+        }
+      end
+
+      private
+
+      def normalize_policy(value)
+        DEFAULT_POLICY.merge(value).transform_values { |entry| entry == true }.freeze
+      end
+
+      def subject
+        readiness_payload.fetch(:manifest).fetch(:subject)
+      end
+
+      def capsules
+        readiness_payload.fetch(:inventory).fetch(:capsules).map do |entry|
+          {
+            name: entry.fetch(:name),
+            root: entry.fetch(:root),
+            layout_profile: entry.fetch(:layout_profile),
+            active_groups: entry.fetch(:active_groups),
+            file_count: entry.fetch(:file_count),
+            missing_path_count: entry.fetch(:missing_count),
+            skipped_path_count: entry.fetch(:skipped_count)
+          }
+        end
+      end
+
+      def included_files
+        return [] unless readiness_payload.fetch(:inventory).fetch(:files_enumerated)
+
+        files = readiness_payload.fetch(:inventory).fetch(:capsules).flat_map do |capsule|
+          capsule.fetch(:files).map do |entry|
+            entry.merge(capsule: capsule.fetch(:name))
+          end
+        end
+
+        files.sort_by { |entry| [entry.fetch(:capsule).to_s, entry.fetch(:relative_path)] }
+      end
+
+      def included_file_count
+        return :not_enumerated unless readiness_payload.fetch(:inventory).fetch(:files_enumerated)
+
+        included_files.length
+      end
+
+      def missing_paths
+        readiness_payload.fetch(:inventory).fetch(:capsules).flat_map do |capsule|
+          capsule.fetch(:missing_expected_paths).map do |entry|
+            entry.merge(capsule: capsule.fetch(:name))
+          end
+        end
+      end
+
+      def surfaces
+        (
+          readiness_payload.fetch(:manifest).fetch(:surfaces) +
+          readiness_payload.fetch(:inventory).fetch(:surfaces)
+        ).uniq { |entry| [entry[:name] || entry["name"], entry[:kind] || entry["kind"], entry[:path] || entry["path"]] }
+      end
+    end
+  end
+end