capsium 0.1.1

data/lib/capsium/packager.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+# lib/capsium/packager.rb
+require "json"
+require "fileutils"
+require "rubygems"
+require "zip"
+
+module Capsium
+  class Packager
+    class FileAlreadyExistsError < StandardError; end
+
+    def pack(package, options = {})
+      package_name = package.metadata.name
+      package_version = package.metadata.version
+      cap_file_path = File.expand_path(
+        File.join(package.path, "..", "#{package_name}-#{package_version}.cap")
+      )
+
+      if File.exist?(cap_file_path)
+        unless options[:force]
+          raise FileAlreadyExistsError,
+                "Package target already exists, aborting: `#{relative_path_current(cap_file_path)}`"
+        end
+
+        puts "Package target already exists, overwriting: `#{relative_path_current(cap_file_path)}`"
+        FileUtils.rm_f(cap_file_path)
+      end
+
+      Dir.mktmpdir do |dir|
+        FileUtils.cp_r("#{package.path}/.", dir)
+        new_package = Package.new(dir)
+        new_package.solidify
+        compress_package(new_package, cap_file_path)
+        puts "Package created: #{relative_path_current(cap_file_path)}"
+      end
+    end
+
+    def compress_package(package, cap_file)
+      Zip::File.open(cap_file, Zip::File::CREATE) do |zipfile|
+        Dir[File.join(package.path, "**", "**")].each do |file|
+          zipfile.add(file.sub("#{package.path}/", ""), file)
+        end
+      end
+    end
+
+    # def package_files
+    #   create_metadata_file
+    #   create_manifest_file
+    #   create_packaging_file
+
+    #   compressor = Compressor.new(@package, @package.metadata[:compression])
+    #   compressor.compress
+
+    #   protector = Protector.new(@package, @package.metadata[:encryption], @package.metadata[:signature])
+    #   protector.apply_encryption_and_sign
+    # end
+
+    # private
+
+    # def create_metadata_file
+    #   metadata_path = File.join(@package.path, Package::METADATA_FILE)
+    #   metadata_content = @package.metadata.to_h
+    #   write_json_file(metadata_path, metadata_content)
+    # end
+
+    # def create_manifest_file
+    #   manifest_path = File.join(@package.path, Package::MANIFEST_FILE)
+    #   manifest_content = {
+    #     files: Dir[File.join(@package.path, '**', '*')].reject { |f| File.directory?(f) }
+    #   }
+    #   write_json_file(manifest_path, manifest_content)
+    # end
+
+    def create_packaging_file
+      packaging_path = File.join(@package.path, Package::PACKAGING_FILE)
+      packaging_content = {
+        name: @package.name,
+        content_path: relative_path_package(@package.content_path),
+        data_path: relative_path_package(@package.data_path),
+        datasets: @package.datasets.map(&:to_h)
+      }
+      write_json_file(packaging_path, packaging_content)
+    end
+
+    def write_json_file(path, content)
+      File.open(path, "w") do |file|
+        file.write(JSON.pretty_generate(content))
+      end
+    end
+
+    def relative_path_package(absolute_path)
+      Pathname.new(absolute_path).relative_path_from(Pathname.new(@package.path)).to_s
+    end
+
+    def relative_path_current(absolute_path)
+      Pathname.new(absolute_path).relative_path_from(Dir.pwd).to_s
+    end
+  end
+end

data/lib/capsium/protector.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+# lib/capsium/protector.rb
+require "openssl"
+require "base64"
+require "json"
+
+module Capsium
+  class Protector
+    def initialize(package, encryption_metadata = nil, digital_signature_metadata = nil)
+      @package = package
+      @encryption_metadata = encryption_metadata
+      @digital_signature_metadata = digital_signature_metadata
+    end
+
+    def apply_encryption_and_sign
+      encrypted_file = apply_encryption if @encryption_metadata
+      sign_package(encrypted_file) if @digital_signature_metadata
+    end
+
+    def verify_signature
+      signature_data = JSON.parse(File.read(signature_file_path))
+      public_key = OpenSSL::PKey::RSA.new(File.read(public_key_path))
+      digest = OpenSSL::Digest.new(signature_data["algorithm"])
+      data = combined_data
+      signature = Base64.decode64(signature_data["signature"])
+
+      public_key.verify(digest, signature, data)
+    end
+
+    private
+
+    def apply_encryption
+      encryption = @encryption_metadata
+      data = File.read(File.join(@package.path, Package::ENCRYPTED_PACKAGING_FILE))
+      cipher = OpenSSL::Cipher.new(encryption[:algorithm])
+      cipher.encrypt
+      key = cipher.random_key
+      iv = cipher.random_iv
+
+      encrypted_data = cipher.update(data) + cipher.final
+      encrypted_file = File.join(@package.path, "#{@package.name}.enc")
+
+      File.open(encrypted_file, "wb") do |f|
+        f.write(iv)
+        f.write(encrypted_data)
+      end
+
+      save_encryption_key(key, encryption[:keyManagement])
+      encrypted_file
+    end
+
+    def save_encryption_key(key, key_management)
+      case key_management
+      when "secure"
+        # Implement secure key storage mechanism
+        File.write(File.join(@package.path, "encryption_key.secure"), Base64.encode64(key))
+      else
+        raise "Unknown key management strategy: #{key_management}"
+      end
+    end
+
+    def sign_package(encrypted_file)
+      key = OpenSSL::PKey::RSA.new(@digital_signature_metadata[:keyLength])
+      data = combined_data(encrypted_file)
+      digest = OpenSSL::Digest.new(@digital_signature_metadata[:algorithm])
+      signature_data = key.sign(digest, data)
+
+      signature_json = {
+        algorithm: @digital_signature_metadata[:algorithm],
+        certificateType: @digital_signature_metadata[:certificateType],
+        signature: Base64.encode64(signature_data)
+      }
+
+      File.write(signature_file_path, JSON.pretty_generate(signature_json))
+      File.write(public_key_path, key.public_key.to_pem)
+    end
+
+    def combined_data(encrypted_file = nil)
+      metadata_content = File.read(File.join(@package.path, Package::METADATA_FILE))
+      signature_content = File.read(signature_file_path).sub(/"signature": ".*"/, '"signature": ""')
+      package_enc_content = File.read(encrypted_file || File.join(@package.path, "#{@package.name}.enc"))
+
+      metadata_content + signature_content + package_enc_content
+    end
+
+    def signature_file_path
+      File.join(@package.path, @digital_signature_metadata[:signatureFile])
+    end
+
+    def public_key_path
+      File.join(@package.path, "public_key.pem")
+    end
+  end
+end

data/lib/capsium/reactor.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+# lib/capsium/reactor.rb
+require "webrick"
+require "json"
+require "listen"
+require "capsium/package"
+
+module Capsium
+  class Reactor
+    DEFAULT_PORT = 8864
+    attr_accessor :package, :package_path, :routes, :port, :server, :server_thread
+
+    def initialize(package, port = DEFAULT_PORT)
+      @package = package
+      @package_path = package.path
+      @port = port
+      @server = WEBrick::HTTPServer.new(Port: @port)
+      load_routes
+      mount_routes
+    end
+
+    def serve
+      @server_thread = start_server
+      start_listener
+    end
+
+    private
+
+    def load_routes
+      @routes = @package.routes.data.routes
+    end
+
+    def mount_routes
+      @routes.each do |route|
+        path = route.path
+        target = route.target
+        content_path = target.fs_path(@package.manifest)
+        puts "mounting route: #{path} => #{content_path}"
+        @server.mount_proc(path.to_s) do |_req, res|
+          res.body = File.read(content_path)
+          res.content_type = target.mime(@package.manifest)
+        end
+      end
+    end
+
+    def start_server
+      @server_thread = Thread.new do
+        trap("INT") do
+          puts "\nShutting down server..."
+          @server.shutdown
+          exit
+        end
+
+        puts "Starting server on http://localhost:#{@port}"
+        @server.start
+      end
+    end
+
+    def restart_server
+      @server.shutdown
+      # @server_thread.kill
+      load_package
+      @server = WEBrick::HTTPServer.new(Port: @port)
+      mount_routes
+      start_server
+    end
+
+    def start_listener
+      listener = Listen.to(@package_path) do |_modified, _added, _removed|
+        puts "Changes detected, reloading..."
+        restart_server
+      end
+
+      listener.start
+      puts "Listening for changes in #{@package_path}..."
+
+      # Wait for the server thread to finish
+      @server_thread.join
+    end
+  end
+end

data/lib/capsium/thor_ext.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Capsium
+  module ThorExt
+    # Configures Thor to behave more like a typical CLI, with better help and error handling.
+    #
+    # - Passing -h or --help to a command will show help for that command.
+    # - Unrecognized options will be treated as errors (instead of being silently ignored).
+    # - Error messages will be printed in red to stderr, without stack trace.
+    # - Full stack traces can be enabled by setting the VERBOSE environment variable.
+    # - Errors will cause Thor to exit with a non-zero status.
+    #
+    # To take advantage of this behavior, your CLI should subclass Thor and extend this module.
+    #
+    #   class CLI < Thor
+    #     extend ThorExt::Start
+    #   end
+    #
+    # Start your CLI with:
+    #
+    #   CLI.start
+    #
+    # In tests, prevent Kernel.exit from being called when an error occurs, like this:
+    #
+    #   CLI.start(args, exit_on_failure: false)
+    #
+    module Start
+      def self.extended(base)
+        super
+        base.check_unknown_options!
+      end
+
+      def start(given_args = ARGV, config = {})
+        config[:shell] ||= Thor::Base.shell.new
+        handle_help_switches(given_args) do |args|
+          dispatch(nil, args, nil, config)
+        end
+      rescue StandardError => e
+        handle_exception_on_start(e, config)
+      end
+
+      private
+
+      def handle_help_switches(given_args)
+        yield(given_args.dup)
+      rescue Thor::UnknownArgumentError => e
+        retry_with_args = []
+
+        if given_args.first == "help"
+          retry_with_args = ["help"] if given_args.length > 1
+        elsif e.unknown.intersect?(%w[-h --help])
+          retry_with_args = ["help", (given_args - e.unknown).first]
+        end
+        raise unless retry_with_args.any?
+
+        yield(retry_with_args)
+      end
+
+      def handle_exception_on_start(error, config)
+        return if error.is_a?(Errno::EPIPE)
+        raise if ENV["VERBOSE"] || !config.fetch(:exit_on_failure, true)
+
+        message = error.message.to_s
+        message.prepend("[#{error.class}] ") if message.empty? || !error.is_a?(Thor::Error)
+
+        config[:shell]&.say_error(message, :red)
+        exit(false)
+      end
+    end
+  end
+end

data/lib/capsium/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Capsium
+  VERSION = "0.1.1"
+end

data/lib/capsium.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "capsium/version"
+require "shale"
+require "shale/adapter/nokogiri"
+Shale.xml_adapter = Shale::Adapter::Nokogiri
+
+module Capsium
+  class Error < StandardError; end
+
+  # Your code goes here...
+end
+
+require_relative "capsium/package"
+require_relative "capsium/packager"

data/sig/capsium.rbs

@@ -0,0 +1,4 @@
+module Capsium
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end