fantasy-cli 1.2.6

data/lib/gsd/plugins/installer.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'tmpdir'
+
+module Gsd
+  module Plugins
+    # Plugin Installer - Instala e desinstala plugins
+    #
+    # Responsável por:
+    # - Instalar plugins de várias fontes
+    # - Desinstalar plugins
+    # - Gerenciar dependências
+    class Installer
+      attr_reader :plugins_dir, :loader
+
+      # Inicializa o Installer
+      #
+      # @param plugins_dir [String] Diretório de plugins
+      def initialize(plugins_dir: nil)
+        @plugins_dir = plugins_dir || File.join(Dir.home, '.gsd', 'plugins')
+        @loader = Loader.new(plugins_dir: @plugins_dir)
+        ensure_plugins_dir
+      end
+
+      # Instala plugin
+      #
+      # @param source [String] Fonte do plugin (path, URL, ou nome)
+      # @return [Boolean] true se sucesso
+      def install(source)
+        if source.start_with?('http://', 'https://')
+          install_from_url(source)
+        elsif File.directory?(source)
+          install_from_local(source)
+        else
+          install_from_marketplace(source)
+        end
+      end
+
+      # Desinstala plugin
+      #
+      # @param name [String] Nome do plugin
+      # @return [Boolean] true se sucesso
+      def uninstall(name)
+        return false unless installed?(name)
+
+        # Executa hook de uninstall se existir
+        run_uninstall_hook(name)
+
+        # Remove plugin
+        @loader.remove(name)
+
+        true
+      end
+
+      # Verifica se plugin está instalado
+      #
+      # @param name [String] Nome do plugin
+      # @return [Boolean] true se instalado
+      def installed?(name)
+        plugin_dir = File.join(@plugins_dir, name)
+        File.directory?(plugin_dir)
+      end
+
+      # Lista plugins instalados
+      #
+      # @return [Array<String>] Nomes dos plugins
+      def list_installed
+        Dir.children(@plugins_dir).select do |child|
+          File.directory?(File.join(@plugins_dir, child))
+        end
+      end
+
+      # Atualiza plugin
+      #
+      # @param name [String] Nome do plugin
+      # @return [Boolean] true se sucesso
+      def update(name)
+        return false unless installed?(name)
+
+        # Obtém info do plugin
+        plugin_info = read_plugin_info(name)
+        return false unless plugin_info
+
+        # Se tem URL de origem, atualiza
+        if plugin_info['source_url']
+          uninstall(name)
+          install(plugin_info['source_url'])
+        else
+          warn "[Installer] Plugin #{name} não tem URL de origem para atualização"
+          false
+        end
+      end
+
+      private
+
+      # Garante que diretório existe
+      #
+      # @return [void]
+      def ensure_plugins_dir
+        FileUtils.mkdir_p(@plugins_dir) unless File.directory?(@plugins_dir)
+      end
+
+      # Instala de URL
+      #
+      # @param url [String] URL do plugin
+      # @return [Boolean] true se sucesso
+      def install_from_url(url)
+        @loader.load_url(url)
+      end
+
+      # Instala de caminho local
+      #
+      # @param path [String] Caminho do plugin
+      # @return [Boolean] true se sucesso
+      def install_from_local(path)
+        @loader.load_local(path)
+      end
+
+      # Instala do marketplace
+      #
+      # @param name [String] Nome do plugin
+      # @return [Boolean] true se sucesso
+      def install_from_marketplace(name)
+        # TODO: Implementar marketplace integration
+        warn "[Installer] Marketplace não implementado ainda"
+        false
+      end
+
+      # Lê informações do plugin
+      #
+      # @param name [String] Nome do plugin
+      # @return [Hash, nil] Informações ou nil
+      def read_plugin_info(name)
+        plugin_file = File.join(@plugins_dir, name, 'plugin.json')
+        return nil unless File.exist?(plugin_file)
+
+        JSON.parse(File.read(plugin_file))
+      rescue => e
+        warn "[Installer] Error reading plugin info: #{e.message}"
+        nil
+      end
+
+      # Executa hook de uninstall
+      #
+      # @param name [String] Nome do plugin
+      # @return [void]
+      def run_uninstall_hook(name)
+        hook_file = File.join(@plugins_dir, name, 'hooks', 'uninstall.rb')
+        return unless File.exist?(hook_file)
+
+        require hook_file
+      rescue => e
+        warn "[Installer] Error running uninstall hook: #{e.message}"
+      end
+    end
+  end
+end

data/lib/gsd/plugins/loader.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module Gsd
+  module Plugins
+    # Plugin Loader - Carrega plugins de várias fontes
+    #
+    # Responsável por:
+    # - Carregar plugins locais
+    # - Carregar plugins de URL
+    # - Validar plugins
+    class Loader
+      attr_reader :plugins_dir
+
+      # Inicializa o Plugin Loader
+      #
+      # @param plugins_dir [String] Diretório de plugins
+      def initialize(plugins_dir: nil)
+        @plugins_dir = plugins_dir || File.join(Dir.home, '.gsd', 'plugins')
+        ensure_plugins_dir
+      end
+
+      # Carrega plugin local
+      #
+      # @param path [String] Caminho do plugin
+      # @return [Boolean] true se sucesso
+      def load_local(path)
+        return false unless File.directory?(path)
+
+        plugin_name = File.basename(path)
+        target_dir = File.join(@plugins_dir, plugin_name)
+
+        # Copia plugin para diretório de plugins
+        FileUtils.cp_r(path, target_dir)
+
+        # Valida plugin
+        valid?(plugin_name)
+      end
+
+      # Carrega plugin de URL
+      #
+      # @param url [String] URL do plugin (zip)
+      # @return [Boolean] true se sucesso
+      def load_url(url)
+        require 'open-uri'
+        require 'zip'
+
+        # Download do zip
+        temp_file = Tempfile.new(['plugin', '.zip'])
+        begin
+          URI.open(url) do |remote|
+            temp_file.write(remote.read)
+          end
+          temp_file.close
+
+          # Extrai zip
+          extract_plugin(temp_file.path)
+        ensure
+          temp_file.unlink
+        end
+      end
+
+      # Valida plugin
+      #
+      # @param name [String] Nome do plugin
+      # @return [Boolean] true se válido
+      def valid?(name)
+        plugin_dir = File.join(@plugins_dir, name)
+        return false unless File.directory?(plugin_dir)
+
+        # Verifica arquivos obrigatórios
+        has_plugin_rb = File.exist?(File.join(plugin_dir, 'plugin.rb'))
+        has_plugin_json = File.exist?(File.join(plugin_dir, 'plugin.json'))
+
+        has_plugin_rb && has_plugin_json
+      end
+
+      # Remove plugin
+      #
+      # @param name [String] Nome do plugin
+      # @return [Boolean] true se sucesso
+      def remove(name)
+        plugin_dir = File.join(@plugins_dir, name)
+        return false unless File.directory?(plugin_dir)
+
+        FileUtils.rm_rf(plugin_dir)
+        true
+      end
+
+      private
+
+      # Garante que diretório existe
+      #
+      # @return [void]
+      def ensure_plugins_dir
+        FileUtils.mkdir_p(@plugins_dir) unless File.directory?(@plugins_dir)
+      end
+
+      # Extrai plugin de zip
+      #
+      # @param zip_path [String] Caminho do zip
+      # @return [Boolean] true se sucesso
+      def extract_plugin(zip_path)
+        require 'zip'
+
+        Zip::File.open(zip_path) do |zip|
+          zip.each do |entry|
+            target_path = File.join(@plugins_dir, entry.name)
+            FileUtils.mkdir_p(File.dirname(target_path))
+            zip.extract(entry, target_path)
+          end
+        end
+
+        true
+      rescue => e
+        warn "[Plugin Loader] Error extracting plugin: #{e.message}"
+        false
+      end
+    end
+  end
+end

data/lib/gsd/plugins/manager.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+require 'gsd/plugins/base'
+
+module Gsd
+  module Plugins
+    # Plugin Manager - Gerencia plugins instalados
+    #
+    # Responsável por:
+    # - Carregar plugins
+    # - Ativar/desativar plugins
+    # - Listar plugins
+    # - Gerenciar configurações
+    class Manager
+      attr_reader :plugins, :plugins_dir
+
+      # Inicializa o Plugin Manager
+      #
+      # @param plugins_dir [String] Diretório de plugins
+      def initialize(plugins_dir: nil)
+        @plugins_dir = plugins_dir || default_plugins_dir
+        @plugins = {}
+        @config = {}
+
+        ensure_plugins_dir
+        load_config
+        load_plugins
+      end
+
+      # Lista todos os plugins
+      #
+      # @return [Array<Hash>] Lista de plugins
+      def list
+        @plugins.values.map(&:info)
+      end
+
+      # Lista plugins ativos
+      #
+      # @return [Array<Hash>] Plugins ativos
+      def list_enabled
+        @plugins.values.select(&:enabled?).map(&:info)
+      end
+
+      # Lista plugins inativos
+      #
+      # @return [Array<Hash>] Plugins inativos
+      def list_disabled
+        @plugins.values.reject(&:enabled?).map(&:info)
+      end
+
+      # Obtém plugin por nome
+      #
+      # @param name [String] Nome do plugin
+      # @return [Base, nil] Plugin ou nil
+      def get(name)
+        @plugins[name]
+      end
+
+      # Ativa plugin
+      #
+      # @param name [String] Nome do plugin
+      # @return [Boolean] true se sucesso
+      def enable(name)
+        plugin = @plugins[name]
+        return false unless plugin
+
+        plugin.enable
+        save_config
+        true
+      end
+
+      # Desativa plugin
+      #
+      # @param name [String] Nome do plugin
+      # @return [Boolean] true se sucesso
+      def disable(name)
+        plugin = @plugins[name]
+        return false unless plugin
+
+        plugin.disable
+        save_config
+        true
+      end
+
+      # Recarrega todos os plugins
+      #
+      # @return [void]
+      def reload
+        @plugins.clear
+        load_plugins
+      end
+
+      # Retorna estatísticas de plugins
+      #
+      # @return [Hash] Estatísticas
+      def stats
+        {
+          total: @plugins.count,
+          enabled: list_enabled.count,
+          disabled: list_disabled.count
+        }
+      end
+
+      private
+
+      # Diretório padrão de plugins
+      #
+      # @return [String] Diretório padrão
+      def default_plugins_dir
+        File.join(Dir.home, '.gsd', 'plugins')
+      end
+
+      # Garante que diretório existe
+      #
+      # @return [void]
+      def ensure_plugins_dir
+        FileUtils.mkdir_p(@plugins_dir) unless File.directory?(@plugins_dir)
+      end
+
+      # Carrega configuração
+      #
+      # @return [void]
+      def load_config
+        config_file = File.join(@plugins_dir, 'config.json')
+        return unless File.exist?(config_file)
+
+        @config = JSON.parse(File.read(config_file))
+      end
+
+      # Salva configuração
+      #
+      # @return [void]
+      def save_config
+        config_file = File.join(@plugins_dir, 'config.json')
+        enabled_plugins = @plugins.select { |_, p| p.enabled? }.keys
+        File.write(config_file, JSON.pretty_generate({
+          enabled_plugins: enabled_plugins
+        }))
+      end
+
+      # Carrega plugins do diretório
+      #
+      # @return [void]
+      def load_plugins
+        return unless File.directory?(@plugins_dir)
+
+        Dir.each_child(@plugins_dir) do |child|
+          plugin_path = File.join(@plugins_dir, child)
+          next unless File.directory?(plugin_path)
+
+          plugin_file = File.join(plugin_path, 'plugin.rb')
+          next unless File.exist?(plugin_file)
+
+          load_plugin(plugin_file, child)
+        end
+      end
+
+      # Carrega um plugin específico
+      #
+      # @param plugin_file [String] Arquivo do plugin
+      # @param name [String] Nome do plugin
+      # @return [void]
+      def load_plugin(plugin_file, name)
+        require plugin_file
+
+        # Encontra classe do plugin
+        plugin_class = Gsd::Plugins.constants
+          .map { |c| Gsd::Plugins.const_get(c) }
+          .find { |c| c.is_a?(Class) && c < Gsd::Plugins::Base && c.name != 'Gsd::Plugins::Base' }
+
+        if plugin_class
+          plugin = plugin_class.new
+          @plugins[name] = plugin
+
+          # Ativa se estava ativo na config
+          if @config.dig('enabled_plugins')&.include?(name)
+            plugin.enable
+          end
+        end
+      rescue => e
+        warn "[Plugin Manager] Error loading plugin #{name}: #{e.message}"
+      end
+    end
+  end
+end

data/lib/gsd/plugins/marketplace.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'net/http'
+require 'uri'
+
+module Gsd
+  module Plugins
+    # Marketplace Client - Cliente para marketplace de plugins
+    #
+    # Responsável por:
+    # - Buscar plugins no marketplace
+    # - Listar plugins disponíveis
+    # - Obter informações de plugins
+    class MarketplaceClient
+      attr_reader :base_url, :timeout
+
+      # Inicializa o Marketplace Client
+      #
+      # @param base_url [String] URL base do marketplace
+      # @param timeout [Integer] Timeout em segundos
+      def initialize(base_url: nil, timeout: 10)
+        @base_url = base_url || 'https://plugins.gsd-tools.com'
+        @timeout = timeout
+      end
+
+      # Lista todos os plugins
+      #
+      # @param page [Integer] Número da página
+      # @param per_page [Integer] Plugins por página
+      # @return [Array<Hash>] Lista de plugins
+      def list(page: 1, per_page: 20)
+        request('/api/v1/plugins', { page: page, per_page: per_page })
+      end
+
+      # Busca plugins por query
+      #
+      # @param query [String] Query de busca
+      # @param filters [Hash] Filtros adicionais
+      # @return [Array<Hash>] Plugins encontrados
+      def search(query, filters = {})
+        params = { q: query }.merge(filters)
+        request('/api/v1/plugins/search', params)
+      end
+
+      # Obtém informações de um plugin
+      #
+      # @param name [String] Nome do plugin
+      # @return [Hash, nil] Informações do plugin
+      def get_plugin(name)
+        request("/api/v1/plugins/#{name}")
+      rescue => e
+        warn "[Marketplace] Plugin not found: #{name}"
+        nil
+      end
+
+      # Lista categorias de plugins
+      #
+      # @return [Array<Hash>] Categorias
+      def categories
+        request('/api/v1/categories')
+      end
+
+      # Lista plugins por categoria
+      #
+      # @param category [String] Categoria
+      # @return [Array<Hash>] Plugins da categoria
+      def by_category(category)
+        request("/api/v1/categories/#{category}/plugins")
+      end
+
+      # Lista plugins mais populares
+      #
+      # @param limit [Integer] Limite de plugins
+      # @return [Array<Hash>] Plugins populares
+      def popular(limit: 10)
+        request('/api/v1/plugins/popular', { limit: limit })
+      end
+
+      # Lista plugins mais recentes
+      #
+      # @param limit [Integer] Limite de plugins
+      # @return [Array<Hash>] Plugins recentes
+      def recent(limit: 10)
+        request('/api/v1/plugins/recent', { limit: limit })
+      end
+
+      # Verifica se marketplace está disponível
+      #
+      # @return [Boolean] true se disponível
+      def available?
+        response = http.get('/api/v1/health')
+        response.code == '200'
+      rescue
+        false
+      end
+
+      private
+
+      # Faz requisição HTTP
+      #
+      # @param path [String] Path da API
+      # @param params [Hash] Parâmetros
+      # @return [Array, Hash] Resposta
+      def request(path, params = {})
+        uri = build_uri(path, params)
+        response = http.get(uri.path)
+
+        if response.code == '200'
+          JSON.parse(response.body)
+        else
+          raise MarketplaceError, "API error: #{response.code}"
+        end
+      end
+
+      # Constrói URI
+      #
+      # @param path [String] Path
+      # @param params [Hash] Parâmetros
+      # @return [URI] URI construída
+      def build_uri(path, params)
+        uri = URI("#{@base_url}#{path}")
+        uri.query = URI.encode_www_form(params) if params.any?
+        uri
+      end
+
+      # Retorna objeto HTTP
+      #
+      # @return [Net::HTTP] HTTP object
+      def http
+        uri = URI(@base_url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = (uri.scheme == 'https')
+        http.read_timeout = @timeout
+        http
+      end
+
+      # Marketplace Error class
+      class MarketplaceError < StandardError; end
+    end
+  end
+end

data/lib/gsd/plugins/sandbox.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Gsd
+  module Plugins
+    # Plugin Sandbox - Isola plugins para segurança
+    #
+    # Responsável por:
+    # - Executar plugins em ambiente isolado
+    # - Limitar acesso a recursos
+    # - Prevenir ações maliciosas
+    class Sandbox
+      attr_reader :plugin, :restrictions
+
+      # Inicializa a Sandbox
+      #
+      # @param plugin [Base] Plugin para isolar
+      # @param restrictions [Hash] Restrições
+      def initialize(plugin, restrictions = {})
+        @plugin = plugin
+        @restrictions = {
+          allow_file_system: restrictions[:allow_file_system] || false,
+          allow_network: restrictions[:allow_network] || false,
+          allow_shell: restrictions[:allow_shell] || false,
+          allowed_paths: restrictions[:allowed_paths] || [],
+          max_memory: restrictions[:max_memory] || 100_000_000, # 100MB
+          max_time: restrictions[:max_time] || 5 # 5 seconds
+        }
+      end
+
+      # Executa plugin com segurança
+      #
+      # @param method [Symbol] Método para executar
+      # @param args [Array] Argumentos
+      # @return [Object] Resultado
+      def execute(method, *args)
+        validate_method(method)
+
+        # Executa com timeout
+        Timeout.timeout(@restrictions[:max_time]) do
+          # Executa com limitações
+          with_restrictions do
+            @plugin.send(method, *args)
+          end
+        end
+      rescue Timeout::Error => e
+        raise SecurityError, "Plugin execution timeout (max: #{@restrictions[:max_time]}s)"
+      rescue => e
+        raise SecurityError, "Plugin execution error: #{e.message}"
+      end
+
+      # Verifica se plugin é seguro
+      #
+      # @return [Boolean] true se seguro
+      def safe?
+        !@plugin.respond_to?(:dangerous_methods) || @plugin.dangerous_methods.empty?
+      end
+
+      # Retorna restrições aplicadas
+      #
+      # @return [Hash] Restrições
+      def applied_restrictions
+        @restrictions
+      end
+
+      private
+
+      # Valida método
+      #
+      # @param method [Symbol] Método
+      # @return [void]
+      def validate_method(method)
+        dangerous = [:system, :exec, :spawn, :popen, :` ]
+        if dangerous.include?(method) && !@restrictions[:allow_shell]
+          raise SecurityError, "Method #{method} is not allowed in sandbox"
+        end
+      end
+
+      # Executa com restrições
+      #
+      # @yield Bloco para executar
+      # @return [Object] Resultado
+      def with_restrictions
+        # Salva estado original
+        original_verbose = $VERBOSE
+
+        begin
+          # Aplica restrições
+          $VERBOSE = false if !@restrictions[:allow_warnings]
+
+          # Executa bloco
+          yield
+        ensure
+          # Restaura estado
+          $VERBOSE = original_verbose
+        end
+      end
+
+      # Verifica caminho permitido
+      #
+      # @param path [String] Caminho
+      # @return [Boolean] true se permitido
+      def allowed_path?(path)
+        return true if @restrictions[:allow_file_system]
+
+        @restrictions[:allowed_paths].any? do |allowed|
+          path.start_with?(allowed)
+        end
+      end
+
+      # Security Error class
+      class SecurityError < StandardError; end
+    end
+  end
+end