igniter 0.5.1 → 0.5.2

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

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require "find"
+require "json"
+
+module Igniter
+  module Application
+    class ApplicationTransferBundleVerification
+      METADATA_ENTRY = ApplicationTransferBundleArtifact::METADATA_ENTRY
+      FILES_ROOT = ApplicationTransferBundleArtifact::FILES_ROOT
+
+      attr_reader :artifact_path, :manifest, :metadata
+
+      def self.verify(path, metadata: {})
+        new(path: path, metadata: metadata)
+      end
+
+      def initialize(path:, metadata: {})
+        @artifact_path = File.expand_path(path.to_s)
+        @metadata = metadata.dup.freeze
+        @manifest = read_manifest
+        freeze
+      end
+
+      def valid?
+        malformed_entries.empty? && missing_files.empty? && extra_files.empty?
+      end
+
+      def to_h
+        {
+          valid: valid?,
+          artifact_path: artifact_path,
+          metadata_entry: METADATA_ENTRY,
+          missing_files: missing_files,
+          extra_files: extra_files,
+          malformed_entries: malformed_entries,
+          included_file_count: included_file_count,
+          actual_file_count: actual_files.length,
+          surface_count: surfaces.length,
+          metadata: metadata.dup
+        }
+      end
+
+      private
+
+      def read_manifest
+        path = File.join(artifact_path, METADATA_ENTRY)
+        return nil unless File.file?(path)
+
+        JSON.parse(File.read(path), symbolize_names: true)
+      rescue JSON::ParserError
+        nil
+      end
+
+      def plan
+        manifest&.fetch(:plan, nil) || {}
+      end
+
+      def included_files
+        Array(plan.fetch(:included_files, []))
+      end
+
+      def included_file_count
+        plan.fetch(:included_file_count, included_files.length)
+      end
+
+      def surfaces
+        Array(plan.fetch(:surfaces, []))
+      end
+
+      def expected_files
+        included_files.filter_map do |entry|
+          next unless well_formed_file_entry?(entry)
+
+          File.join(FILES_ROOT, entry.fetch(:capsule).to_s, entry.fetch(:relative_path).to_s)
+        end.sort
+      end
+
+      def actual_files
+        root = File.join(artifact_path, FILES_ROOT)
+        return [] unless File.directory?(root)
+
+        files = []
+        Find.find(root) do |path|
+          next if path == root
+
+          if File.symlink?(path)
+            Find.prune if File.directory?(path)
+            next
+          end
+
+          next unless File.file?(path)
+
+          files << relative_to_artifact(path)
+        end
+        files.sort
+      end
+
+      def missing_files
+        expected_files - actual_files
+      end
+
+      def extra_files
+        actual_files - expected_files
+      end
+
+      def malformed_entries
+        entries = []
+        entries << malformed(:metadata_missing, "Metadata manifest is missing.") unless File.file?(metadata_path)
+        entries << malformed(:metadata_invalid, "Metadata manifest is not valid JSON.") if File.file?(metadata_path) && manifest.nil?
+        included_files.each do |entry|
+          next if well_formed_file_entry?(entry)
+
+          entries << malformed(:malformed_file_entry, "Included file entry is malformed or unsafe.", entry: entry)
+        end
+        entries
+      end
+
+      def well_formed_file_entry?(entry)
+        capsule = entry[:capsule] || entry["capsule"]
+        relative_path = entry[:relative_path] || entry["relative_path"]
+        safe_component?(capsule) && safe_relative_path?(relative_path)
+      end
+
+      def safe_component?(value)
+        text = value.to_s
+        return false if text.empty?
+        return false if text.start_with?("/", "\\")
+
+        !text.split(%r{[\\/]}).include?("..")
+      end
+
+      def safe_relative_path?(value)
+        safe_component?(value)
+      end
+
+      def metadata_path
+        File.join(artifact_path, METADATA_ENTRY)
+      end
+
+      def relative_to_artifact(path)
+        path.sub("#{artifact_path}#{File::SEPARATOR}", "")
+      end
+
+      def malformed(code, message, entry: nil)
+        {
+          code: code,
+          message: message,
+          entry: entry
+        }.compact
+      end
+    end
+  end
+end

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

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Igniter
+  module Application
+    class ApplicationTransferIntakePlan
+      METADATA_ENTRY = ApplicationTransferBundleArtifact::METADATA_ENTRY
+      FILES_ROOT = ApplicationTransferBundleArtifact::FILES_ROOT
+
+      attr_reader :verification, :destination_root, :metadata, :artifact_path,
+                  :verification_payload, :bundle_manifest, :planned_files
+
+      def self.build(verification_or_path, destination_root:, metadata: {})
+        verification = verification_or_path.respond_to?(:to_h) ? verification_or_path : ApplicationTransferBundleVerification.verify(verification_or_path)
+        new(verification: verification, destination_root: destination_root, metadata: metadata)
+      end
+
+      def initialize(verification:, destination_root:, metadata: {})
+        @verification = verification
+        @verification_payload = verification.to_h
+        @artifact_path = verification_payload.fetch(:artifact_path)
+        @destination_root = File.expand_path(destination_root.to_s)
+        @metadata = metadata.dup.freeze
+        @bundle_manifest = read_bundle_manifest
+        @planned_files = included_files.filter_map { |entry| planned_file(entry) }.freeze
+        freeze
+      end
+
+      def ready?
+        verification_payload.fetch(:valid) && conflicts.empty? && blockers.empty?
+      end
+
+      def to_h
+        {
+          ready: ready?,
+          destination_root: destination_root,
+          artifact_path: artifact_path,
+          verification_valid: verification_payload.fetch(:valid),
+          planned_files: planned_files,
+          conflicts: conflicts,
+          blockers: blockers,
+          warnings: warnings,
+          required_host_wiring: required_host_wiring,
+          agent_capabilities: agent_capabilities,
+          surface_count: surfaces.length,
+          metadata: metadata.dup
+        }
+      end
+
+      private
+
+      def read_bundle_manifest
+        path = File.join(artifact_path, METADATA_ENTRY)
+        return {} unless File.file?(path)
+
+        JSON.parse(File.read(path), symbolize_names: true)
+      rescue JSON::ParserError
+        {}
+      end
+
+      def bundle_plan
+        bundle_manifest.fetch(:plan, {})
+      end
+
+      def included_files
+        Array(bundle_plan.fetch(:included_files, []))
+      end
+
+      def planned_file(entry)
+        capsule = entry[:capsule] || entry["capsule"]
+        relative_path = entry[:relative_path] || entry["relative_path"]
+        return unsafe_planned_file(entry) unless safe_component?(capsule) && safe_component?(relative_path)
+
+        capsule = capsule.to_sym
+        artifact_relative_path = File.join(FILES_ROOT, capsule.to_s, relative_path.to_s)
+        destination_relative_path = File.join(capsule.to_s, relative_path.to_s)
+        destination_path = File.expand_path(destination_relative_path, destination_root)
+        safe = safe_destination?(destination_path, destination_relative_path)
+        exists = safe && File.exist?(destination_path)
+
+        {
+          capsule: capsule,
+          artifact_path: artifact_relative_path,
+          destination_relative_path: destination_relative_path,
+          destination_path: destination_path,
+          bytes: entry[:bytes],
+          status: exists ? :conflict : :planned,
+          safe: safe
+        }
+      end
+
+      def unsafe_planned_file(entry)
+        {
+          capsule: entry[:capsule] || entry["capsule"],
+          artifact_path: nil,
+          destination_relative_path: nil,
+          destination_path: nil,
+          bytes: entry[:bytes] || entry["bytes"],
+          status: :unsafe,
+          safe: false
+        }
+      end
+
+      def conflicts
+        planned_files.select { |entry| entry.fetch(:status) == :conflict }.map do |entry|
+          entry.merge(code: :destination_exists, message: "Destination file already exists.")
+        end
+      end
+
+      def blockers
+        [].tap do |items|
+          items << blocker(:verification_invalid, "Bundle verification is not valid.", verification_payload) unless
+            verification_payload.fetch(:valid)
+          planned_files.reject { |entry| entry.fetch(:safe) }.each do |entry|
+            items << blocker(:unsafe_destination_path, "Planned destination path is unsafe.", entry)
+          end
+          conflicts.each do |entry|
+            items << blocker(:destination_conflict, "Destination file already exists.", entry)
+          end
+          required_host_wiring.each do |entry|
+            items << blocker(:required_host_wiring, "Required host wiring remains unresolved.", entry)
+          end
+        end
+      end
+
+      def warnings
+        readiness_warnings
+      end
+
+      def readiness_warnings
+        bundle_plan.fetch(:warnings, []).map(&:dup)
+      end
+
+      def required_host_wiring
+        manifest = bundle_plan.fetch(:readiness, {}).fetch(:manifest, {})
+        manifest.fetch(:suggested_host_wiring, []).map(&:dup)
+      end
+
+      def agent_capabilities
+        manifest = bundle_plan.fetch(:readiness, {}).fetch(:manifest, {})
+        manifest.fetch(:capsules, []).flat_map do |capsule|
+          capsule.fetch(:agents, []).map do |agent|
+            normalize_agent(agent).merge(capsule: capsule.fetch(:name).to_sym)
+          end
+        end
+      end
+
+      def normalize_agent(agent)
+        {
+          name: agent.fetch(:name).to_sym,
+          ai_provider: agent.fetch(:ai_provider).to_sym,
+          model: agent[:model],
+          instructions: agent[:instructions],
+          tools: Array(agent.fetch(:tools, [])).map(&:to_sym),
+          memory: agent[:memory],
+          metadata: normalize_hash(agent.fetch(:metadata, {}))
+        }.compact
+      end
+
+      def normalize_hash(value)
+        source = value.respond_to?(:to_h) ? value.to_h : value
+        source.to_h.transform_keys { |key| key.respond_to?(:to_sym) ? key.to_sym : key }
+      end
+
+      def surfaces
+        bundle_plan.fetch(:surfaces, [])
+      end
+
+      def safe_destination?(destination_path, destination_relative_path)
+        return false if destination_relative_path.empty?
+        return false if destination_relative_path.start_with?("/", "\\")
+        return false if destination_relative_path.split(%r{[\\/]}).include?("..")
+
+        destination_path == destination_root || destination_path.start_with?("#{destination_root}#{File::SEPARATOR}")
+      end
+
+      def safe_component?(value)
+        text = value.to_s
+        return false if text.empty?
+        return false if text.start_with?("/", "\\")
+
+        !text.split(%r{[\\/]}).include?("..")
+      end
+
+      def blocker(code, message, entry)
+        {
+          code: code,
+          message: message,
+          entry: entry
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "find"
+
+module Igniter
+  module Application
+    class ApplicationTransferInventory
+      attr_reader :blueprints, :surface_metadata, :enumerate_files,
+                  :capsule_inventories, :metadata
+
+      def self.build(capsules:, surface_metadata: [], enumerate_files: true, metadata: {})
+        blueprints = capsules.map { |entry| entry.respond_to?(:to_blueprint) ? entry.to_blueprint : entry }
+        new(
+          blueprints: blueprints,
+          surface_metadata: surface_metadata,
+          enumerate_files: enumerate_files,
+          metadata: metadata
+        )
+      end
+
+      def initialize(blueprints:, surface_metadata: [], enumerate_files: true, metadata: {})
+        @blueprints = Array(blueprints).freeze
+        @surface_metadata = Array(surface_metadata).map { |entry| normalize_hash(entry) }.freeze
+        @enumerate_files = enumerate_files ? true : false
+        @metadata = metadata.dup.freeze
+        @capsule_inventories = @blueprints.map { |blueprint| inventory_for(blueprint) }.freeze
+        freeze
+      end
+
+      def ready?
+        capsule_inventories.all? { |entry| entry.fetch(:missing_expected_paths).empty? && entry.fetch(:skipped_paths).empty? }
+      end
+
+      def to_h
+        entries = capsule_inventories
+        {
+          ready: ready?,
+          capsule_count: entries.length,
+          capsules: entries,
+          expected_path_count: entries.sum { |entry| entry.fetch(:expected_count) },
+          existing_path_count: entries.sum { |entry| entry.fetch(:existing_count) },
+          missing_path_count: entries.sum { |entry| entry.fetch(:missing_count) },
+          skipped_path_count: entries.sum { |entry| entry.fetch(:skipped_count) },
+          files_enumerated: enumerate_files,
+          file_count: enumerate_files ? entries.sum { |entry| entry.fetch(:file_count) } : :not_enumerated,
+          surfaces: surface_metadata.map(&:dup),
+          metadata: metadata.dup
+        }
+      end
+
+      private
+
+      def inventory_for(blueprint)
+        plan = blueprint.structure_plan(mode: :sparse)
+        entries = plan.entries
+        expected_paths = entries.map { |entry| expected_path_for(entry) }
+        skipped_paths = expected_paths.reject { |entry| path_inside_root?(entry.fetch(:absolute_path), blueprint.root) }
+        present_paths = expected_paths.select { |entry| entry.fetch(:status) == :present }
+        missing_paths = expected_paths.select { |entry| entry.fetch(:status) == :missing }
+        files = enumerate_files ? files_for(blueprint.root, entries) : :not_enumerated
+
+        {
+          name: blueprint.name,
+          root: blueprint.root,
+          layout_profile: blueprint.layout_profile,
+          active_groups: blueprint.active_groups,
+          expected_paths: expected_paths,
+          existing_paths: present_paths,
+          missing_expected_paths: missing_paths,
+          skipped_paths: skipped_paths,
+          expected_count: expected_paths.length,
+          existing_count: present_paths.length,
+          missing_count: missing_paths.length,
+          skipped_count: skipped_paths.length,
+          files_enumerated: enumerate_files,
+          files: files,
+          file_count: enumerate_files ? files.length : :not_enumerated,
+          agents: blueprint.agents.map(&:dup),
+          surfaces: surfaces_for(blueprint)
+        }
+      end
+
+      def expected_path_for(entry)
+        {
+          group: entry.group,
+          path: entry.path,
+          absolute_path: entry.absolute_path,
+          kind: entry.kind,
+          status: entry.status
+        }
+      end
+
+      def files_for(root, entries)
+        files = entries.each_with_object([]) do |entry, memo|
+          next unless entry.present?
+          next unless path_inside_root?(entry.absolute_path, root)
+
+          if entry.kind == :file
+            memo << file_entry(root, entry, entry.absolute_path) if File.file?(entry.absolute_path)
+          elsif File.directory?(entry.absolute_path)
+            collect_directory_files(root, entry, memo)
+          end
+        end
+
+        files.sort_by { |entry| [entry.fetch(:group).to_s, entry.fetch(:relative_path)] }
+      end
+
+      def collect_directory_files(root, entry, memo)
+        Find.find(entry.absolute_path) do |path|
+          next if path == entry.absolute_path
+
+          if File.symlink?(path)
+            Find.prune if File.directory?(path)
+            next
+          end
+
+          next unless File.file?(path)
+          next unless path_inside_root?(path, root)
+
+          memo << file_entry(root, entry, path)
+        end
+      end
+
+      def file_entry(root, entry, path)
+        {
+          group: entry.group,
+          path: path.sub("#{entry.absolute_path}#{File::SEPARATOR}", ""),
+          relative_path: path.sub("#{root}#{File::SEPARATOR}", ""),
+          absolute_path: path,
+          bytes: File.size(path)
+        }
+      end
+
+      def surfaces_for(blueprint)
+        surface_metadata.select do |entry|
+          name = entry[:name] || entry["name"]
+          name && blueprint.web_surfaces.include?(name.to_sym)
+        end.map(&:dup)
+      end
+
+      def path_inside_root?(path, root)
+        absolute_path = File.expand_path(path.to_s)
+        absolute_root = File.expand_path(root.to_s)
+        absolute_path == absolute_root || absolute_path.start_with?("#{absolute_root}#{File::SEPARATOR}")
+      end
+
+      def normalize_hash(value)
+        source = value.respond_to?(:to_h) ? value.to_h : value
+        source.to_h.transform_keys { |key| key.respond_to?(:to_sym) ? key.to_sym : key }
+      end
+    end
+  end
+end