paquette 0.1.0

data/lib/paquette/gem_server.rb

@@ -0,0 +1,393 @@
+require "json"
+require "fileutils"
+require "rubygems"
+require "zlib"
+require "stringio"
+require "digest"
+require "time"
+
+require_relative "routes"
+require_relative "gem_server/directory_gem_repository"
+require_relative "gem_server/read_gated_repository"
+require_relative "gem_server/personalizer"
+
+module Paquette
+  class GemServer
+    @@routes = Routes.draw do |r|
+      # Root endpoint
+      r.get "/" do
+        text_ok("Paquette RubyGems Repository")
+      end
+
+      # API endpoints
+      r.post "/api/v1/gems" do
+        handle_push
+      end
+
+      r.delete "/api/v1/gems/yank" do
+        handle_yank
+      end
+
+      r.get "/api/v1/versions" do
+        handle_versions
+      end
+
+      r.get "/api/v1/names" do
+        handle_names
+      end
+
+      r.get "/api/v1/search.json" do |query: nil|
+        handle_search(query)
+      end
+
+      # Specs endpoints
+      r.get "/specs.4.8" do
+        handle_specs("4.8")
+      end
+
+      r.get "/specs.4.8.gz" do
+        handle_specs("4.8.gz")
+      end
+
+      r.get "/latest_specs.4.8" do
+        handle_latest_specs("4.8")
+      end
+
+      r.get "/latest_specs.4.8.gz" do
+        handle_latest_specs("4.8.gz")
+      end
+
+      # Compact index endpoints
+      r.get "/names" do
+        handle_compact_names
+      end
+
+      r.get "/versions" do
+        handle_compact_versions
+      end
+
+      # Dynamic endpoints with parameters
+      r.get "/info/:gem_name" do |gem_name:|
+        info_lines = @repository.compact_info(gem_name)
+
+        if info_lines.empty?
+          not_found("Not Found")
+        else
+          text_ok(info_lines.join("\n"))
+        end
+      end
+
+      r.get "/quick/Marshal.4.8/:gem_spec_name.gemspec.rz" do |gem_spec_name:|
+        # Parse gem name and version from the spec name (e.g., "zip_kit-6.3.2")
+        if (match = gem_spec_name.match(/^(.+?)-(\d+\.\d+\.\d+.*)$/))
+          gem_name, version = match[1], match[2]
+
+          if @repository.gem_exists?(gem_name, version)
+            spec = @repository.gem_spec(gem_name, version)
+            if spec
+              # Marshal the spec and compress it with raw deflate (not gzip)
+              marshaled_spec = Marshal.dump(spec)
+              compressed_spec = Zlib::Deflate.deflate(marshaled_spec)
+              [200, {"Content-Type" => "application/octet-stream"}, [compressed_spec]]
+            else
+              not_found("Spec not found")
+            end
+          else
+            not_found("Gem not found: #{gem_name}-#{version}")
+          end
+        else
+          not_found("Invalid gem spec name: #{gem_spec_name}")
+        end
+      end
+
+      r.get "/gems/:gem_filename" do |gem_filename:|
+        # Extract gem name and version from filename
+        if (match = gem_filename.match(/^(.+)-(\d+\.\d+\.\d+.*)\.gem$/))
+          gem_name, version = match[1], match[2]
+          return not_found("Gem not found or it is not within your license") unless @repository.gem_exists?(gem_name, version)
+
+          # gem_file_path now automatically returns personalized gem
+          gem_path = @repository.gem_file_path(gem_name, version)
+          clen = File.size(gem_path).to_s
+          hh = {"Content-Type" => "application/octet-stream", "Content-Length" => clen}
+
+          [200, hh, File.open(gem_path, "rb")]
+        else
+          not_found("Invalid gem filename")
+        end
+      end
+    end
+
+    # Build a gem server backed by `repository`. Reads, writes, and yanks
+    # all flow through this one object — whether writes are accepted depends
+    # on the wrapper chain the caller assembled. A ReadGatedRepository, for
+    # example, refuses add_gem and yank_gem; a bare DirectoryGemRepository
+    # accepts both. Callers typically construct the stack per-request so
+    # user-specific state (entitlements, license keys) is captured in
+    # plain closures rather than stored on the server.
+    def initialize(repository)
+      @repository = repository
+    end
+
+    def call(env)
+      request = Rack::Request.new(env)
+      route = @@routes.match(request)
+      return not_found("Not found") unless route
+
+      @request = request
+      @@routes.perform_action(route, self, request)
+    end
+
+    private
+
+    def handle_dependencies(request)
+      gems = request.params["gems"]
+
+      # Handle different parameter formats
+      if gems.is_a?(String)
+        # Split comma-separated gem names
+        gems = gems.split(",").map(&:strip)
+      elsif gems.nil?
+        gems = []
+      end
+
+      # If no gems specified, return empty array
+      if gems.empty?
+        return json_ok([])
+      end
+
+      dependencies = []
+      gems.each do |gem_name|
+        gem_versions = @repository.versions_for_gem(gem_name)
+        gem_versions.each do |version|
+          gem_dependencies = @repository.gem_dependencies(gem_name, version)
+          dependencies << {
+            name: gem_name,
+            number: version,
+            platform: "ruby",
+            dependencies: gem_dependencies
+          }
+        end
+      end
+
+      json_ok(dependencies)
+    end
+
+    def handle_dependencies_json(request)
+      handle_dependencies(request)
+    end
+
+    def handle_versions
+      versions = []
+      @repository.gem_versions.each do |name, version|
+        spec = @repository.gem_spec(name, version)
+        versions << {
+          name: name,
+          number: version,
+          platform: spec.platform.to_s,
+          authors: spec.authors,
+          info: spec.description || "",
+          homepage: spec.homepage || "",
+          description: spec.description || "",
+          summary: spec.summary || "",
+          metadata: spec.metadata || {}
+        }
+      end
+
+      json_ok(versions)
+    end
+
+    def handle_names
+      names = @repository.gem_names
+      json_ok(names)
+    end
+
+    def handle_push
+      gem_data = @request.body.read
+
+      spec = @repository.add_gem(gem_data)
+      text_ok("Successfully registered gem: #{spec.name}-#{spec.version}")
+    rescue ReadGatedRepository::WriteNotAllowed => e
+      [403, {"Content-Type" => "text/plain"}, [e.message]]
+    rescue DirectoryGemRepository::GemYanked => e
+      [403, {"Content-Type" => "text/plain"}, [e.message]]
+    rescue DirectoryGemRepository::GemAlreadyExists => e
+      [409, {"Content-Type" => "text/plain"}, [e.message]]
+    rescue DirectoryGemRepository::InvalidGem => e
+      bad_request(e.message)
+    end
+
+    def handle_yank
+      gem_name = @request.params["gem_name"]
+      version = @request.params["version"]
+
+      return bad_request("Missing gem_name") if gem_name.nil? || gem_name.empty?
+      return bad_request("Missing version") if version.nil? || version.empty?
+
+      @repository.yank_gem(gem_name, version)
+      text_ok("Successfully yanked gem: #{gem_name}-#{version}")
+    rescue ReadGatedRepository::WriteNotAllowed => e
+      [403, {"Content-Type" => "text/plain"}, [e.message]]
+    rescue DirectoryGemRepository::GemNotFound => e
+      not_found(e.message)
+    end
+
+    def handle_search(query)
+      query ||= ""
+      results = []
+
+      @repository.gem_versions.each do |name, version|
+        if name.include?(query)
+          results << {
+            name: name,
+            version: version,
+            platform: "ruby",
+            authors: ["Unknown"],
+            info: "Uploaded to Paquette"
+          }
+        end
+      end
+
+      json_ok(results)
+    end
+
+    def handle_specs(version)
+      # Generate specs in the format expected by Bundler
+      specs = generate_specs_array
+
+      # Use Marshal 4.8 format for compatibility with Bundler
+      specs_data = marshal_dump_4_8(specs)
+
+      # For .gz requests, compress the data
+      if version.include?(".gz")
+        specs_data = gzip_compress(specs_data)
+        [200, {"Content-Type" => "application/x-gzip"}, [specs_data]]
+      else
+        [200, {"Content-Type" => "application/octet-stream"}, [specs_data]]
+      end
+    end
+
+    def handle_compact_names
+      names = @repository.gem_names
+      text_ok(names.join("\n"))
+    end
+
+    def handle_compact_versions
+      # Group versions by gem name
+      gem_versions = {}
+      @repository.gem_versions.each do |name, version|
+        gem_versions[name] ||= []
+        gem_versions[name] << version
+      end
+
+      # Sort versions for each gem
+      gem_versions.each { |name, versions| versions.sort! }
+
+      # Generate the content in the official format
+      lines = []
+      lines << "created_at: #{Time.now.utc.iso8601}"
+      lines << "---"
+
+      # Add each gem with its versions and checksum
+      gem_versions.sort.each do |name, versions|
+        versions_str = versions.join(",")
+        # Create a checksum for this gem's versions
+        version_data = "#{name} #{versions.join(" ")}"
+        checksum = Digest::MD5.hexdigest(version_data)
+        lines << "#{name} #{versions_str} #{checksum}"
+      end
+
+      content = lines.join("\n")
+
+      # Calculate overall checksum for the entire content
+      overall_checksum = Digest::MD5.hexdigest(content)
+
+      [200, {"Content-Type" => "text/plain", "X-Checksum-Sha256" => overall_checksum}, [content]]
+    end
+
+    def generate_specs_array
+      # Generate specs array in the format expected by RubyGems/Bundler
+      # Each spec is [gem_name, version, platform]
+      # Use only basic Ruby types to ensure Marshal 4.8 compatibility
+      specs = []
+      @repository.gem_versions.each do |name, version|
+        specs << [name.to_s, version.to_s, "ruby"]
+      end
+      specs
+    end
+
+    def handle_latest_specs(version)
+      # Generate latest specs (only the latest version of each gem)
+      latest_specs = generate_latest_specs_array
+
+      # Use Marshal 4.8 format for compatibility with Bundler
+      specs_data = marshal_dump_4_8(latest_specs)
+
+      # For .gz requests, compress the data
+      if version.include?(".gz")
+        specs_data = gzip_compress(specs_data)
+        [200, {"Content-Type" => "application/x-gzip"}, [specs_data]]
+      else
+        [200, {"Content-Type" => "application/octet-stream"}, [specs_data]]
+      end
+    end
+
+    def generate_latest_specs_array
+      # Generate latest specs array - only the latest version of each gem
+      latest_versions = {}
+      @repository.gem_versions.each do |name, version|
+        if !latest_versions[name] || Gem::Version.new(version) > Gem::Version.new(latest_versions[name])
+          latest_versions[name] = version
+        end
+      end
+
+      specs = []
+      latest_versions.each do |name, version|
+        specs << [name.to_s, version.to_s, "ruby"]
+      end
+      specs
+    end
+
+    def marshal_dump_4_8(obj)
+      # Create Marshal data in format 4.8 for compatibility with Bundler
+      # Use only basic Ruby types to ensure compatibility
+      specs_array = obj.is_a?(Array) ? obj : []
+
+      # Simple Marshal.dump should work with basic types
+      Marshal.dump(specs_array)
+    end
+
+    def gzip_compress(data)
+      # Create proper gzip format with headers, checksums, etc.
+      StringIO.open do |io|
+        Zlib::GzipWriter.wrap(io) do |gz|
+          gz.write(data)
+        end
+        io.string
+      end
+    end
+
+    # Helper methods for common response patterns
+    private
+
+    def json_ok(data)
+      [200, {"Content-Type" => "application/json"}, [JSON.pretty_generate(data)]]
+    end
+
+    def text_ok(data)
+      [200, {"Content-Type" => "text/plain"}, [data]]
+    end
+
+    def not_found(message = "Not Found")
+      [404, {"Content-Type" => "text/plain"}, [message]]
+    end
+
+    def bad_request(message = "Bad Request")
+      [400, {"Content-Type" => "text/plain"}, [message]]
+    end
+
+    def server_error(message = "Internal Server Error")
+      [500, {"Content-Type" => "text/plain"}, [message]]
+    end
+  end
+end

data/lib/paquette/npm_repacker.rb

@@ -0,0 +1,153 @@
+require "fileutils"
+require "digest"
+require "tmpdir"
+require "tempfile"
+require "sourcemap"
+require "json"
+
+module Paquette
+  class NpmRepacker
+    def self.repack(npm_path, &block)
+      new(npm_path).repack(&block)
+    end
+
+    def initialize(npm_path)
+      @npm_path = npm_path
+      @temp_dir = nil
+      @unpacked_package_dir = nil
+    end
+
+    def repack(&block)
+      raise ArgumentError, "Block required" unless block_given?
+      raise ArgumentError, "NPM package not found: #{@npm_path}" unless File.exist?(@npm_path)
+
+      unpack_package
+      process_js_files(&block)
+      new_package_path = repackage_package
+      cleanup
+      new_package_path
+    end
+
+    private
+
+    def unpack_package
+      @temp_dir = Dir.mktmpdir("npm_repacker")
+      @unpacked_package_dir = File.join(@temp_dir, "unpacked_package")
+      FileUtils.mkdir_p(@unpacked_package_dir)
+
+      # Extract the NPM package (tar.gz file)
+      result = system("tar -xzf #{@npm_path} -C #{@unpacked_package_dir}")
+      raise "Failed to unpack NPM package: #{@npm_path}" unless result
+
+      # Find the unpacked package directory - it should be the only directory in unpacked_package_dir
+      @package_dir = Dir.glob(File.join(@unpacked_package_dir, "*")).find { |path| File.directory?(path) }
+      raise "Could not find unpacked package directory" unless @package_dir
+    end
+
+    def process_js_files(&block)
+      # Process .ts, .js, .mjs, .jsx, .tsx files
+      extensions = %w[.ts .js .mjs .jsx .tsx]
+      extensions.each do |ext|
+        Dir.glob(File.join(@package_dir, "**", "*#{ext}")).each do |js_file|
+          process_js_file(js_file, &block)
+        end
+      end
+    end
+
+    def process_js_file(file_path, &block)
+      # Get the relative path within the package directory
+      relative_path = file_path.sub("#{@package_dir}/", "")
+
+      # Create a temporary file for output
+      temp_output = Tempfile.new("npm_repacker_output")
+
+      begin
+        # Open input file in binary mode for reading
+        File.open(file_path, "rb") do |input_file|
+          # Open output file in binary mode for writing
+          File.open(temp_output.path, "wb") do |output_file|
+            # Call the block with input file, output file, and relative path
+            yield(input_file, output_file, relative_path)
+          end
+        end
+
+        # Handle sourcemap updates if this is a JS file
+        if File.extname(file_path) == ".js"
+          update_sourcemap_offsets(file_path, temp_output.path)
+        end
+
+        # Replace the original file with the processed content
+        FileUtils.mv(temp_output.path, file_path)
+      ensure
+        temp_output.close
+        temp_output.unlink if File.exist?(temp_output.path)
+      end
+    end
+
+    def update_sourcemap_offsets(js_file_path, new_js_content_path)
+      # Look for sourcemap reference in the JS file
+      sourcemap_path = find_sourcemap_file(js_file_path)
+      return unless sourcemap_path
+
+      # Calculate the offset difference
+      original_content = File.read(js_file_path)
+      new_content = File.read(new_js_content_path)
+      offset_diff = new_content.length - original_content.length
+
+      return if offset_diff == 0 # No changes, no need to update sourcemap
+
+      # Update the sourcemap
+      update_sourcemap_file(sourcemap_path, offset_diff)
+    end
+
+    def find_sourcemap_file(js_file_path)
+      # Look for sourceMappingURL comment in the JS file
+      content = File.read(js_file_path)
+      if content =~ /\/\/# sourceMappingURL=(.+)/
+        sourcemap_filename = $1.strip
+        sourcemap_path = File.join(File.dirname(js_file_path), sourcemap_filename)
+        return sourcemap_path if File.exist?(sourcemap_path)
+      end
+      nil
+    end
+
+    def update_sourcemap_file(sourcemap_path, offset_diff)
+      # Read and parse the sourcemap
+      sourcemap_content = File.read(sourcemap_path)
+      JSON.parse(sourcemap_content)
+
+      # Sourcemap found and needs updating (debug output removed)
+
+      # For now, we'll just log the information. In a production system,
+      # you would need to implement proper sourcemap offset adjustment
+      # which requires understanding the specific sourcemap format and
+      # updating the mappings array accordingly.
+
+      # TODO: Implement proper sourcemap offset adjustment
+      # This would involve:
+      # 1. Parsing the mappings string
+      # 2. Adjusting the generated line/column positions
+      # 3. Re-encoding the mappings string
+      # 4. Updating the sourcemap JSON
+    rescue
+      # If sourcemap parsing fails, silently continue (debug output removed)
+      # The sourcemap update is not critical for the repacking process
+    end
+
+    def repackage_package
+      # Create a new NPM package
+      package_name = File.basename(@npm_path, ".tgz")
+      new_package_path = File.join(Dir.tmpdir, "#{package_name}-repacked.tgz")
+
+      # Create the new tar.gz file
+      result = system("cd #{@unpacked_package_dir} && tar -czf #{new_package_path} package/")
+      raise "Failed to repackage NPM package" unless result
+
+      new_package_path
+    end
+
+    def cleanup
+      FileUtils.rm_rf(@temp_dir) if @temp_dir && Dir.exist?(@temp_dir)
+    end
+  end
+end

data/lib/paquette/npm_server/directory_npm_repository.rb

@@ -0,0 +1,127 @@
+require_relative "npm_repository"
+require "json"
+
+module Paquette
+  class NpmServer
+    # Repository implementation that reads NPM packages from a directory
+    class DirectoryNpmRepository < NpmRepository
+      def initialize(packages_dir)
+        @packages_dir = packages_dir
+        FileUtils.mkdir_p(@packages_dir)
+      end
+
+      def package_names
+        Dir.glob(File.join(@packages_dir, "*")).select { |path| File.directory?(path) }.map do |package_path|
+          File.basename(package_path)
+        end.sort
+      end
+
+      def package_versions
+        versions = []
+        package_names.each do |package_name|
+          versions_for_package(package_name).each do |version|
+            versions << [package_name, version]
+          end
+        end
+        versions.sort
+      end
+
+      def versions_for_package(package_name)
+        package_dir = File.join(@packages_dir, package_name)
+        return [] unless Dir.exist?(package_dir)
+
+        Dir.glob(File.join(package_dir, "*.tgz")).map do |tgz_path|
+          filename = File.basename(tgz_path, ".tgz")
+          if (match = filename.match(/^#{Regexp.escape(package_name)}-(\d+\.\d+\.\d+.*)$/))
+            match[1]
+          end
+        end.compact.sort
+      end
+
+      def package_file_path(package_name, version)
+        File.join(@packages_dir, package_name, "#{package_name}-#{version}.tgz")
+      end
+
+      def package_exists?(package_name, version)
+        File.exist?(package_file_path(package_name, version))
+      end
+
+      def package_info(package_name, version)
+        package_file = package_file_path(package_name, version)
+        return nil unless File.exist?(package_file)
+
+        # For now, return basic package info
+        # In a real implementation, you'd extract the package.json from the .tgz file
+        {
+          name: package_name,
+          version: version,
+          description: "Package #{package_name} version #{version}",
+          main: "index.js",
+          scripts: {},
+          dependencies: {},
+          devDependencies: {}
+        }
+      end
+
+      def package_dependencies(package_name, version)
+        info = package_info(package_name, version)
+        return {} unless info
+
+        (info[:dependencies] || {}).merge(info[:devDependencies] || {})
+      end
+
+      def package_metadata(package_name)
+        versions = versions_for_package(package_name)
+        return nil if versions.empty?
+
+        # Get the latest version
+        latest_version = versions.max_by { |v| Gem::Version.new(v) }
+
+        metadata = {
+          name: package_name,
+          versions: {},
+          "dist-tags": {
+            latest: latest_version
+          },
+          time: {},
+          maintainers: [],
+          description: "Package #{package_name}",
+          keywords: [],
+          license: "MIT",
+          repository: {},
+          bugs: {},
+          homepage: "",
+          readme: "",
+          readmeFilename: "README.md"
+        }
+
+        # Add version-specific metadata
+        versions.each do |version|
+          info = package_info(package_name, version)
+          next unless info
+
+          metadata[:versions][version] = {
+            name: package_name,
+            version: version,
+            description: info[:description],
+            main: info[:main],
+            scripts: info[:scripts] || {},
+            dependencies: info[:dependencies] || {},
+            devDependencies: info[:devDependencies] || {},
+            dist: {
+              shasum: "dummy-sha", # In real implementation, calculate actual shasum
+              tarball: "#{package_name}/#{package_name}-#{version}.tgz"
+            }
+          }
+
+          metadata[:time][version] = Time.now.iso8601
+        end
+
+        metadata[:time][:created] = Time.now.iso8601
+        metadata[:time][:modified] = Time.now.iso8601
+
+        metadata
+      end
+    end
+  end
+end