rails-blocks-cli 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a208908dfd35e07556c86dc68f85642d7f0b4428927f370898fa91611155881f
+  data.tar.gz: ea4678983d9e63e30a99450b665c3ec4be126e4b72ca1e616f0953e497345561
+SHA512:
+  metadata.gz: 1ea4fe353fbe84f63aa493a9040b4ac51c736f47715e4be550912b2c307c4a188cf727b2f7c7522969954f94d2bc01a42b1909cca99c2807cdbf13dcdc68415e
+  data.tar.gz: a9f560d47c9f4dae1ea9dfa3b14f43fa49287913a9bbb787ab361ae84411a8b06d3da7762898de4c4d05c63a9aa091f046426188c5f1f550567c3f38408792d2

data/README.md

@@ -0,0 +1,45 @@
+# Rails Blocks CLI
+
+Static-first installer for Rails Blocks components.
+
+Free component metadata and packages are read from the public `Rails-Blocks` GitHub artifact registry. The Rails Blocks app is only contacted for login, account status, and Pro component access.
+
+## Example
+
+```bash
+# List free components from the public registry
+rails-blocks list --free
+
+# Read component documentation in the terminal
+rails-blocks docs accordion
+
+# Install one component as shared ERB partials
+rails-blocks install accordion --as erb_template
+
+# Preview installing all free components as shared partials
+rails-blocks install --all --free --as partial --dry-run
+
+# Review local changes before updating a component package
+rails-blocks diff accordion --as partial
+
+# Update a component package after reviewing the diff
+rails-blocks update accordion --as partial
+
+# Compare one local Stimulus controller with the latest version
+rails-blocks diff stimulus tooltip
+
+# Update all free Stimulus controllers
+rails-blocks update stimulus --all --free
+
+# Log in before fetching Pro packages
+rails-blocks login
+
+# Install one Pro component as ViewComponent files
+rails-blocks install dropdown --as view_component
+
+# Install all Pro components as ViewComponent files
+rails-blocks install --all --pro --as view_component
+
+# Update all Pro-access Stimulus controllers
+rails-blocks update stimulus --all --pro
+```

data/exe/rails-blocks

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require "rails_blocks/cli"
+
+RailsBlocks::CLI.new(ARGV).run

data/lib/rails_blocks/cli.rb

@@ -0,0 +1,492 @@
+require "fileutils"
+require "json"
+require "net/http"
+require "open3"
+require "tempfile"
+require "uri"
+require "zip"
+
+module RailsBlocks
+  class CLI
+    DownloadError = Class.new(StandardError)
+
+    DEFAULT_REGISTRY_URL = "https://raw.githubusercontent.com/Rails-Blocks/components/main/registry.json".freeze
+    DEFAULT_API_URL = "https://railsblocks.com".freeze
+
+    def initialize(argv)
+      @argv = argv.dup
+    end
+
+    def run
+      command = @argv.shift
+
+      case command
+      when "list" then list
+      when "search" then search(@argv.join(" "))
+      when "show" then show(@argv.shift)
+      when "docs" then docs(@argv.shift)
+      when "examples" then examples(@argv.shift)
+      when "install" then install(@argv.shift)
+      when "diff" then diff(@argv.shift)
+      when "update" then update(@argv.shift)
+      when "login" then login
+      when "logout" then logout
+      when "whoami" then whoami
+      when "agents" then agents
+      when "mcp" then mcp
+      when "doctor" then doctor
+      else help
+      end
+    end
+
+    private
+
+    attr_reader :argv
+
+    def list
+      components.each do |component|
+        next unless include_component?(component)
+
+        puts "#{component['slug']}#{component['pro'] ? ' (pro)' : ''} - #{component['title']}"
+      end
+    end
+
+    def search(query)
+      abort "Usage: rails-blocks search QUERY" if query.to_s.strip.empty?
+
+      components.select { |component| component["slug"].include?(query.tr("-", "_")) || component["title"].downcase.include?(query.downcase) }.each do |component|
+        puts "#{component['slug']}#{component['pro'] ? ' (pro)' : ''} - #{component['title']}"
+      end
+    end
+
+    def show(slug)
+      component = find_component(slug)
+      puts JSON.pretty_generate(component)
+    end
+
+    def docs(slug)
+      component = find_component(slug)
+      if component["pro"]
+        puts api_get("/api/v1/components/#{component['slug']}/docs")["markdown"]
+      else
+        path = cached_component_file(component["slug"], "#{component['slug'].upcase}.md")
+        puts File.exist?(path) ? File.read(path) : "Docs are available at #{component['docs_path']}"
+      end
+    end
+
+    def examples(slug)
+      component = find_component(slug)
+      if component["pro"]
+        puts JSON.pretty_generate(api_get("/api/v1/components/#{component['slug']}/examples"))
+      else
+        Dir.glob(File.join(cache_dir, "components", component["slug"], "USAGE.*.erb")).each do |path|
+          puts "\n# #{File.basename(path)}\n\n"
+          puts File.read(path)
+        end
+      end
+    end
+
+    def install(slug)
+      implementation = package_implementation
+      dry_run = argv.include?("--dry-run")
+
+      return install_all(implementation, dry_run: dry_run) if slug == "--all"
+
+      abort "Usage: rails-blocks install COMPONENT [--as erb_template|view_component|partial] [--dry-run] [--force]" if slug.to_s.empty?
+
+      component = find_component(slug)
+      install_component(component, implementation, dry_run: dry_run)
+    end
+
+    def install_all(implementation, dry_run:)
+      selected_components = components.select { |component| include_component?(component) }
+      abort "No components matched the selected filters." if selected_components.empty?
+
+      failures = []
+
+      selected_components.each do |component|
+        puts "\nInstalling #{component['slug']}#{component['pro'] ? ' (pro)' : ''} as #{implementation}..."
+        install_component(component, implementation, dry_run: dry_run)
+      rescue StandardError => error
+        failures << [component["slug"], error.message]
+        warn "Failed to install #{component['slug']}: #{error.message}"
+      end
+
+      puts "\nInstalled #{selected_components.size - failures.size} of #{selected_components.size} components."
+      return if failures.empty?
+
+      warn "Failures: #{failures.map(&:first).join(', ')}"
+      exit(1)
+    end
+
+    def install_component(component, implementation, dry_run:)
+      if component["pro"]
+        install_pro(component, implementation, dry_run: dry_run)
+      else
+        install_free(component, implementation, dry_run: dry_run)
+      end
+    end
+
+    def diff(target)
+      change_files(target, mode: :diff)
+    end
+
+    def update(target)
+      change_files(target, mode: :update)
+    end
+
+    def change_files(target, mode:)
+      abort "Usage: rails-blocks #{mode} COMPONENT|--all|stimulus [NAME|--all] [--as erb_template|view_component|partial] [--free|--pro] [--dry-run]" if target.to_s.empty?
+
+      if target == "stimulus"
+        change_stimulus_files(argv.shift, mode: mode)
+      elsif target == "--all"
+        change_all_components(mode: mode)
+      else
+        component = find_component(target)
+        change_component_files(component, mode: mode)
+      end
+    end
+
+    def change_all_components(mode:)
+      selected_components = components.select { |component| include_component?(component) }
+      abort "No components matched the selected filters." if selected_components.empty?
+
+      failures = []
+
+      selected_components.each do |component|
+        puts "\n#{mode_label(mode)} #{component['slug']}#{component['pro'] ? ' (pro)' : ''} as #{package_implementation}..."
+        change_component_files(component, mode: mode)
+      rescue StandardError => error
+        failures << [component["slug"], error.message]
+        warn "Failed to #{mode} #{component['slug']}: #{error.message}"
+      end
+
+      puts "\n#{mode_label(mode)} #{selected_components.size - failures.size} of #{selected_components.size} components."
+      return if failures.empty?
+
+      warn "Failures: #{failures.map(&:first).join(', ')}"
+      exit(1)
+    end
+
+    def change_component_files(component, mode:)
+      data = component["pro"] ? pro_package_data(component, package_implementation) : free_package_data(component, package_implementation)
+      process_zip(data, mode: mode) { |entry_name| Pathname.pwd.join(entry_name) }
+    end
+
+    def change_stimulus_files(name, mode:)
+      abort "Usage: rails-blocks #{mode} stimulus NAME|--all [--free|--pro] [--dry-run]" if name.to_s.empty?
+
+      process_zip(stimulus_package_data, mode: mode) do |entry_name|
+        filename = File.basename(entry_name)
+        next unless name == "--all" || filename == stimulus_controller_filename(name)
+
+        Pathname.pwd.join("app", "javascript", "controllers", filename)
+      end
+    end
+
+    def login
+      email = option_value("--email")
+      body = { name: "Rails Blocks CLI", scopes: %w[cli mcp_read mcp_install], email: email }.compact
+      response = api_post("/api/v1/cli_sessions", body, auth: false)
+      puts "Open #{response['verification_uri']} and approve code #{response['code']}."
+      puts "Polling for approval..."
+
+      loop do
+        sleep(response["interval"] || 3)
+        status = api_get("/api/v1/cli_sessions/#{response['code']}", auth: false)
+        next unless status["status"] == "approved"
+
+        save_config("api_token" => status["token"], "api_url" => api_url)
+        puts "Logged in as Rails Blocks Pro token #{status['token_prefix']}."
+        break
+      end
+    end
+
+    def logout
+      save_config(config.reject { |key, _| key == "api_token" })
+      puts "Logged out."
+    end
+
+    def whoami
+      puts JSON.pretty_generate(api_get("/api/v1/me"))
+    end
+
+    def agents
+      subcommand = argv.shift
+      case subcommand
+      when "create"
+        name = argv.shift || "Rails Blocks Agent"
+        response = api_post("/api/v1/cli_sessions", { name: name, scopes: %w[cli mcp_read mcp_install] }, auth: false)
+        puts "Approve #{response['verification_uri']} for #{name}."
+      else
+        puts "Agent tokens can be created and revoked from the Rails Blocks account page."
+      end
+    end
+
+    def mcp
+      puts "Add @rails-blocks/mcp to your MCP client and point it at this rails-blocks executable."
+    end
+
+    def doctor
+      puts "Registry: #{registry_url}"
+      puts "API: #{api_url}"
+      puts "Token: #{api_token ? 'present' : 'missing'}"
+    end
+
+    def help
+      puts "Usage: rails-blocks [list|search|show|docs|examples|install|diff|update|login|logout|whoami|agents|mcp|doctor]"
+      puts "       rails-blocks install COMPONENT [--as erb_template|view_component|partial] [--dry-run] [--force]"
+      puts "       rails-blocks install --all [--free|--pro] [--as erb_template|view_component|partial] [--dry-run] [--force]"
+      puts "       rails-blocks diff COMPONENT|--all [--free|--pro] [--as erb_template|view_component|partial]"
+      puts "       rails-blocks update COMPONENT|--all [--free|--pro] [--as erb_template|view_component|partial] [--dry-run]"
+      puts "       rails-blocks diff stimulus NAME|--all [--free|--pro]"
+      puts "       rails-blocks update stimulus NAME|--all [--free|--pro] [--dry-run]"
+    end
+
+    def install_free(component, implementation, dry_run:)
+      install_zip(free_package_data(component, implementation), dry_run: dry_run)
+    end
+
+    def install_pro(component, implementation, dry_run:)
+      install_zip(pro_package_data(component, implementation), dry_run: dry_run)
+    end
+
+    def free_package_data(component, implementation)
+      zip_url = component["package_url"].to_s.sub("#{component['slug']}.zip", "#{component['slug']}-#{implementation}.zip")
+      download(zip_url)
+    end
+
+    def pro_package_data(component, implementation)
+      response = api_get("/api/v1/components/#{component['slug']}/signed_package_url?implementation=#{implementation}")
+      download(response["url"], auth: true)
+    end
+
+    def stimulus_package_data
+      type = component_filter == :pro ? "pro" : "free"
+      if type == "free"
+        stimulus_artifact = registry["stimulus_controllers"]
+        return download(stimulus_artifact["package_url"]) if stimulus_artifact&.dig("package_url")
+      end
+
+      download(api_url_for("/api/v1/stimulus_controllers?type=#{type}"), auth: type == "pro")
+    end
+
+    def install_zip(data, dry_run:)
+      zip_entries(data).each do |entry|
+        destination = Pathname.pwd.join(entry[:name])
+        puts "#{dry_run ? 'Would write' : 'Writing'} #{destination}"
+        next if dry_run
+        raise "#{destination} already exists. Use --force when overwrite support is enabled." if destination.exist? && !argv.include?("--force")
+
+        FileUtils.mkdir_p(destination.dirname)
+        File.binwrite(destination, entry[:content])
+      end
+    end
+
+    def process_zip(data, mode:)
+      counts = { changed: 0, unchanged: 0, skipped: 0 }
+
+      zip_entries(data).each do |entry|
+        destination = yield(entry[:name])
+        unless destination
+          counts[:skipped] += 1
+          next
+        end
+
+        if mode == :diff
+          diff_file(destination, entry[:content], counts)
+        else
+          update_file(destination, entry[:content], counts)
+        end
+      end
+
+      puts "No matching files found." if counts.values.sum.zero? || (counts[:changed].zero? && counts[:unchanged].zero?)
+      counts
+    end
+
+    def zip_entries(data)
+      entries = []
+      Zip::File.open_buffer(data) do |zip|
+        entries = zip.entries.reject(&:directory?).map do |entry|
+          { name: entry.name, content: entry.get_input_stream.read }
+        end
+      end
+      entries
+    end
+
+    def diff_file(destination, new_content, counts)
+      old_content = destination.exist? ? File.binread(destination) : ""
+      if old_content == new_content
+        counts[:unchanged] += 1
+        puts "No changes #{destination}"
+        return
+      end
+
+      counts[:changed] += 1
+      puts unified_diff(old_content, new_content, destination.exist? ? destination.to_s : "/dev/null", destination.to_s)
+    end
+
+    def update_file(destination, new_content, counts)
+      old_content = destination.exist? ? File.binread(destination) : nil
+      if old_content == new_content
+        counts[:unchanged] += 1
+        puts "Unchanged #{destination}"
+        return
+      end
+
+      counts[:changed] += 1
+      puts "#{argv.include?('--dry-run') ? 'Would update' : old_content.nil? ? 'Writing' : 'Updating'} #{destination}"
+      return if argv.include?("--dry-run")
+
+      FileUtils.mkdir_p(destination.dirname)
+      File.binwrite(destination, new_content)
+    end
+
+    def unified_diff(old_content, new_content, old_label, new_label)
+      old_file = Tempfile.new("rails-blocks-old")
+      new_file = Tempfile.new("rails-blocks-new")
+      old_file.binmode
+      new_file.binmode
+      old_file.write(old_content)
+      new_file.write(new_content)
+      old_file.flush
+      new_file.flush
+
+      output, = Open3.capture2e("diff", "-u", "--label", old_label, "--label", new_label, old_file.path, new_file.path)
+      output
+    ensure
+      old_file&.close!
+      new_file&.close!
+    end
+
+    def stimulus_controller_filename(name)
+      normalized = name.to_s.tr("-", "_")
+      normalized.end_with?("_controller.js") ? normalized : "#{normalized}_controller.js"
+    end
+
+    def mode_label(mode)
+      mode == :diff ? "Diffing" : "Updating"
+    end
+
+    def components
+      registry.fetch("components")
+    end
+
+    def find_component(slug)
+      normalized = slug.to_s.tr("-", "_")
+      components.find { |component| component["slug"] == normalized } || abort("Component not found: #{slug}")
+    end
+
+    def include_component?(component)
+      case component_filter
+      when :pro then component["pro"]
+      when :free then !component["pro"]
+      else true
+      end
+    end
+
+    def component_filter
+      return :pro if argv.include?("--pro")
+      return :free if argv.include?("--free")
+
+      :all
+    end
+
+    def registry
+      @registry ||= JSON.parse(download(registry_url))
+    rescue DownloadError => error
+      abort "Could not load the Rails Blocks registry from #{registry_url}: #{error.message}"
+    rescue JSON::ParserError => error
+      abort "Could not parse the Rails Blocks registry from #{registry_url}: #{error.message}"
+    end
+
+    def download(url, auth: false, redirects: 3)
+      uri = URI(url)
+      request = Net::HTTP::Get.new(uri)
+      request["Authorization"] = "Bearer #{api_token}" if auth && api_token
+      response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") { |http| http.request(request) }
+
+      if response.is_a?(Net::HTTPRedirection) && response["location"] && redirects.positive?
+        return download(URI.join(url, response["location"]).to_s, redirects: redirects - 1)
+      end
+
+      raise DownloadError, "#{response.code} #{response.message}" unless response.is_a?(Net::HTTPSuccess)
+
+      response.body
+    end
+
+    def api_get(path, auth: true)
+      request_json(Net::HTTP::Get, path, auth: auth)
+    end
+
+    def api_post(path, body, auth: true)
+      request_json(Net::HTTP::Post, path, body: body, auth: auth)
+    end
+
+    def request_json(method, path, body: nil, auth: true)
+      uri = URI(api_url_for(path))
+      request = method.new(uri)
+      request["Content-Type"] = "application/json"
+      request["Authorization"] = "Bearer #{api_token}" if auth && api_token
+      request.body = JSON.generate(body) if body
+      response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") { |http| http.request(request) }
+      abort(response.body) unless response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPCreated)
+
+      JSON.parse(response.body)
+    end
+
+    def api_url_for(path)
+      return path if path.to_s.match?(/\Ahttps?:\/\//)
+
+      URI.join(api_url, path).to_s
+    end
+
+    def cached_component_file(slug, filename)
+      File.join(cache_dir, "components", slug, filename)
+    end
+
+    def option_value(name)
+      index = argv.index(name)
+      index ? argv[index + 1] : nil
+    end
+
+    def package_implementation
+      implementation = option_value("--as") || "erb_template"
+      return "erb_template" if implementation == "partial"
+      return implementation if %w[erb_template view_component].include?(implementation)
+
+      abort "Unsupported implementation: #{implementation}. Use erb_template, view_component, or partial."
+    end
+
+    def registry_url
+      ENV.fetch("RAILS_BLOCKS_REGISTRY_URL", config.fetch("registry_url", DEFAULT_REGISTRY_URL))
+    end
+
+    def api_url
+      ENV.fetch("RAILS_BLOCKS_API_URL", config.fetch("api_url", DEFAULT_API_URL))
+    end
+
+    def api_token
+      ENV["RAILS_BLOCKS_API_TOKEN"] || config["api_token"]
+    end
+
+    def config
+      @config ||= File.exist?(config_path) ? JSON.parse(File.read(config_path)) : {}
+    end
+
+    def save_config(values)
+      FileUtils.mkdir_p(File.dirname(config_path))
+      File.write(config_path, JSON.pretty_generate(values))
+      @config = values
+    end
+
+    def config_path
+      File.expand_path("~/.rails_blocks/config.json")
+    end
+
+    def cache_dir
+      File.expand_path("~/.rails_blocks/cache")
+    end
+  end
+end

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: rails-blocks-cli
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Rails Blocks
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+executables:
+- rails-blocks
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- exe/rails-blocks
+- lib/rails_blocks/cli.rb
+homepage: https://railsblocks.com/docs/cli
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: Install Rails Blocks components from the command line
+test_files: []