rosett-ai 1.3.3

data/lib/rosett_ai/dbus/focus_monitor_interface.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'dbus'
+
+module RosettAi
+  module DBus
+    # D-Bus interface for focus monitoring.
+    #
+    # Interface: be.neatnerds.rosettai.FocusMonitor
+    # Methods:
+    #   GetCurrentFocus() -> (ss)  Return (app_id, window_title)
+    # Signals:
+    #   FocusChanged(app_id: s, title: s)  Emitted on active window change
+    class FocusMonitorInterface < ::DBus::Object
+      INTERFACE = 'be.neatnerds.rosettai.FocusMonitor'
+
+      dbus_interface INTERFACE do
+        dbus_method :GetCurrentFocus, 'out app_id:s, out title:s' do
+          get_current_focus
+        end
+
+        dbus_signal :FocusChanged, 'app_id:s, title:s'
+      end
+
+      def initialize(path)
+        super
+        @current_app_id = ''
+        @current_title = ''
+        @adapter = nil
+        @monitor_thread = nil
+      end
+
+      # Start focus monitoring
+      def start
+        compositor = CompositorDetector.detect
+        RosettAi.logger.info("Detected compositor: #{compositor}")
+
+        @adapter = create_adapter(compositor)
+        return unless @adapter
+
+        @adapter.on_focus_change do |app_id, title|
+          handle_focus_change(app_id, title)
+        end
+
+        @adapter.start
+      end
+
+      # Stop focus monitoring
+      def stop
+        @adapter&.stop
+        @adapter = nil
+      end
+
+      private
+
+      # Get current focus
+      #
+      # @return [Array<String, String>] [app_id, title]
+      def get_current_focus
+        [@current_app_id, @current_title]
+      end
+
+      # Handle focus change event
+      #
+      # @param app_id [String] Application identifier
+      # @param title [String] Window title
+      def handle_focus_change(app_id, title)
+        return if app_id == @current_app_id && title == @current_title
+
+        @current_app_id = app_id
+        @current_title = title
+
+        RosettAi.logger.debug("Focus changed: #{app_id} - #{title}")
+        FocusChanged(app_id, title)
+      end
+
+      # Create appropriate adapter for the compositor
+      #
+      # @param compositor [Symbol] Compositor type
+      # @return [FocusAdapters::Base, nil]
+      def create_adapter(compositor)
+        case compositor
+        when :sway, :i3
+          FocusAdapters::I3Adapter.new
+        when :hyprland
+          FocusAdapters::HyprlandAdapter.new
+        when :gnome
+          FocusAdapters::GnomeAdapter.new
+        when :kwin
+          FocusAdapters::KwinAdapter.new
+        when :x11
+          FocusAdapters::X11Adapter.new
+        else
+          RosettAi.logger.warn("No focus adapter for compositor: #{compositor}")
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/rosett_ai/dbus/manager_interface.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'dbus'
+
+module RosettAi
+  module DBus
+    # D-Bus interface for Rosett-AI management operations.
+    #
+    # Interface: be.neatnerds.rosettai.Manager
+    # Methods:
+    #   Compile(engine: s) -> s   Run compilation for specified engine
+    #   SwitchContext(name: s)    Switch to named context
+    #   GetStatus() -> a{sv}      Return service status dictionary
+    # Properties:
+    #   Version: s (read)         Service version string
+    # Signals:
+    #   ContextChanged(name: s)   Emitted after context switch
+    #
+    # Security:
+    # - Rate limiting (10 req/s, burst 20) prevents DoS via rapid method calls
+    # - Compile operations have stricter limits (2 req/s, burst 5)
+    class ManagerInterface < ::DBus::Object
+      INTERFACE = 'be.neatnerds.rosettai.Manager'
+
+      # Rate limit configurations per operation type
+      RATE_LIMITS = {
+        default: { rate: 10, burst: 20 },
+        compile: { rate: 2, burst: 5 },     # Compile is expensive
+        config: { rate: 5, burst: 10 }      # Config changes need moderation
+      }.freeze
+
+      # Keys allowed via D-Bus SetConfig — prevents arbitrary config mutation
+      SETCONFIG_ALLOWED_KEYS = [
+        'default_engine',
+        'cache.enabled',
+        'cache.ttl_hours',
+        'detect.on_init'
+      ].freeze
+
+      dbus_interface INTERFACE do
+        dbus_method :Compile, 'in engine:s, out result:s' do |engine|
+          compile(engine)
+        end
+
+        dbus_method :SwitchContext, 'in context_name:s' do |context_name|
+          switch_context(context_name)
+        end
+
+        dbus_method :GetStatus, 'out status:a{sv}' do
+          get_status
+        end
+
+        dbus_method :Shutdown, '' do
+          shutdown
+        end
+
+        dbus_method :SetConfig, 'in key:s, in value:s, out result:s' do |key, value|
+          set_config(key, value)
+        end
+
+        dbus_method :ListEngines, 'out engines:a(ss)' do
+          list_engines
+        end
+
+        dbus_attr_reader :version, 's'
+
+        dbus_signal :ContextChanged, 'context_name:s'
+      end
+
+      attr_writer :service
+
+      def initialize(path)
+        super
+        @current_context = 'default'
+        @service = nil
+        @rate_limiters = build_rate_limiters
+      end
+
+      # Version property
+      #
+      # @return [String]
+      def version
+        RosettAi::VERSION
+      end
+
+      private
+
+      # Run compilation for the specified engine
+      #
+      # @param engine [String] Engine name (claude, generic, agents_md, etc.)
+      # @return [String] Compilation result message
+      def compile(engine)
+        rate_limit!(:compile, 'Compile')
+        RosettAi.logger.info("D-Bus compile requested for engine: #{engine}")
+
+        # Use the compilation pipeline
+        backend = RosettAi::Compiler::Backend.for(engine)
+        pipeline = RosettAi::Compiler::CompilationPipeline.new(
+          source_dir: RosettAi.root.join('conf'),
+          target_dir: resolve_target_dir(backend),
+          schema_dir: RosettAi.root.join('conf', 'schemas'),
+          backend: backend
+        )
+
+        results = pipeline.compile
+        count = results.size
+        "Compiled #{count} file(s) successfully"
+      rescue RosettAi::CompileError => e
+        "Compilation failed: #{e.message}"
+      rescue StandardError => e
+        RosettAi.logger.error("Compile error: #{e.message}")
+        "Error: #{e.message}"
+      end
+
+      # Switch to named context
+      #
+      # @param context_name [String] Context name to switch to
+      def switch_context(context_name)
+        rate_limit!(:default, 'SwitchContext')
+        RosettAi.logger.info("D-Bus context switch: #{@current_context} -> #{context_name}")
+        @current_context = context_name
+
+        # Emit signal
+        ContextChanged(context_name)
+      end
+
+      # Get service status
+      #
+      # @return [Hash] Status dictionary
+      def get_status
+        rate_limit!(:default, 'GetStatus')
+        {
+          'version' => RosettAi::VERSION,
+          'running' => true,
+          'current_context' => @current_context,
+          'pid' => Process.pid,
+          'dbus_name' => Service::BUS_NAME
+        }
+      end
+
+      # Initiate graceful service shutdown.
+      # Thread is required to avoid blocking the D-Bus event loop during shutdown.
+      def shutdown
+        RosettAi.logger.info('D-Bus shutdown requested')
+        Thread.new do
+          sleep(0.1)
+          @service&.stop
+        end
+        nil
+      end
+
+      # Update a configuration key via RaiConfig
+      #
+      # @param key [String] dot-separated config key (e.g. 'default_engine')
+      # @param value [String] new value
+      # @return [String] result message
+      def set_config(key, value)
+        rate_limit!(:config, 'SetConfig')
+        return reject_disallowed_key(key) unless SETCONFIG_ALLOWED_KEYS.include?(key)
+
+        RosettAi.logger.info("D-Bus SetConfig: #{key} = #{value}")
+        RosettAi.rai_config.update(key, value)
+        "OK: #{key} = #{value}"
+      rescue StandardError => e
+        RosettAi.logger.error("SetConfig error: #{e.message}")
+        "Error: #{e.message}"
+      end
+
+      # List available engines with display names.
+      #
+      # @return [Array<Array(String, String)>] [name, display_name] tuples
+      def list_engines
+        rate_limit!(:default, 'ListEngines')
+        RosettAi::Engines::Registry.available.map do |name|
+          manifest = RosettAi::Engines::Registry.manifest(name)
+          [name, manifest['display_name'] || name]
+        end
+      rescue StandardError => e
+        RosettAi.logger.error("ListEngines error: #{e.message}")
+        []
+      end
+
+      def reject_disallowed_key(key)
+        RosettAi.logger.warn("D-Bus SetConfig rejected disallowed key: #{key}")
+        "Error: key '#{key}' is not allowed via D-Bus (permitted: #{SETCONFIG_ALLOWED_KEYS.join(', ')})"
+      end
+
+      def resolve_target_dir(backend)
+        dir = backend.profile.output_dir
+        dir ? Pathname.new(File.expand_path(dir)) : RosettAi.paths.rules_dir
+      end
+
+      def build_rate_limiters
+        RATE_LIMITS.transform_values do |config|
+          RateLimiter.new(rate: config[:rate], burst: config[:burst])
+        end
+      end
+
+      def rate_limit!(category, method_name)
+        return unless @rate_limiters # Skip rate limiting in tests without full init
+
+        limiter = @rate_limiters[category] || @rate_limiters[:default]
+        limiter.consume!(method_name)
+      rescue RateLimiter::RateLimitExceeded => e
+        RosettAi.logger.warn("D-Bus rate limit exceeded: #{e.message}")
+        raise ::DBus::Error, "org.freedesktop.DBus.Error.LimitsExceeded: #{e.message}"
+      end
+    end
+  end
+end

data/lib/rosett_ai/dbus/plugin_manager_interface.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'dbus'
+
+module RosettAi
+  module DBus
+    # D-Bus interface for plugin management.
+    #
+    # Interface: be.neatnerds.rosettai.PluginManager
+    # Methods:
+    #   ListPlugins(type: s) -> a(sss)   Return array of [name, display_name, version]
+    #   InstallPlugin(type: s, name: s) -> (bs)  Install a plugin
+    #   RemovePlugin(type: s, name: s) -> (bs)   Remove a plugin
+    # Signals:
+    #   PluginInstalled(type: s, name: s, version: s)
+    #   PluginRemoved(type: s, name: s)
+    #
+    # @author hugo
+    # @author claude
+    class PluginManagerInterface < ::DBus::Object
+      INTERFACE = 'be.neatnerds.rosettai.PluginManager'
+
+      VALID_TYPES = ['engine', 'gui', 'mcp'].freeze
+
+      dbus_interface INTERFACE do
+        dbus_method :ListPlugins, 'in type:s, out plugins:aas' do |type|
+          list_plugins(type)
+        end
+
+        dbus_method :InstallPlugin, 'in type:s, in name:s, out success:b, out message:s' do |type, name|
+          install_plugin(type, name)
+        end
+
+        dbus_method :RemovePlugin, 'in type:s, in name:s, out success:b, out message:s' do |type, name|
+          remove_plugin(type, name)
+        end
+
+        dbus_signal :PluginInstalled, 'type:s, name:s, version:s'
+        dbus_signal :PluginRemoved, 'type:s, name:s'
+      end
+
+      private
+
+      # List plugins of a given type from the registry.
+      #
+      # @param type [String] plugin type ('engine', 'gui', 'mcp')
+      # @return [Array<Array<String>>] array of [name, display_name, version] tuples
+      def list_plugins(type)
+        validate_type!(type)
+        type_sym = type.to_sym
+        plugins = RosettAi::Plugins::Registry.available(type_sym)
+
+        [plugins.map do |name|
+          mod = RosettAi::Plugins::Registry.plugin_module(type_sym, name)
+          [name, mod.display_name, mod.version]
+        end]
+      rescue StandardError => e
+        RosettAi.logger.error("ListPlugins failed: #{e.message}")
+        [[]]
+      end
+
+      # Install a plugin using the appropriate package manager.
+      #
+      # @param type [String] plugin type
+      # @param name [String] plugin name
+      # @return [Array(Boolean, String)] [success, message]
+      def install_plugin(type, name)
+        authorize_plugin_management!
+        validate_type!(type)
+        validate_name!(name)
+        RosettAi.logger.warn("D-Bus plugin install: #{type}/#{name}")
+
+        pm = select_package_manager
+        package_name = plugin_package_name(type, name)
+
+        if pm.install(package_name)
+          RosettAi::Plugins::Registry.reset!
+          RosettAi::Plugins::Registry.discover!
+          self.PluginInstalled(type, name, 'installed')
+          [true, "Installed #{package_name}"]
+        else
+          [false, "Failed to install #{package_name}"]
+        end
+      rescue ::DBus::Error
+        raise
+      rescue PackageManager::Base::PackageManagerError => e
+        [false, e.message]
+      rescue StandardError => e
+        RosettAi.logger.error("InstallPlugin failed: #{e.message}")
+        [false, "Error: #{e.message}"]
+      end
+
+      # Remove a plugin using the appropriate package manager.
+      #
+      # @param type [String] plugin type
+      # @param name [String] plugin name
+      # @return [Array(Boolean, String)] [success, message]
+      def remove_plugin(type, name)
+        authorize_plugin_management!
+        validate_type!(type)
+        validate_name!(name)
+        RosettAi.logger.warn("D-Bus plugin remove: #{type}/#{name}")
+
+        pm = select_package_manager
+        package_name = plugin_package_name(type, name)
+
+        if pm.remove(package_name)
+          RosettAi::Plugins::Registry.reset!
+          RosettAi::Plugins::Registry.discover!
+          self.PluginRemoved(type, name)
+          [true, "Removed #{package_name}"]
+        else
+          [false, "Failed to remove #{package_name}"]
+        end
+      rescue ::DBus::Error
+        raise
+      rescue PackageManager::Base::PackageManagerError => e
+        [false, e.message]
+      rescue StandardError => e
+        RosettAi.logger.error("RemovePlugin failed: #{e.message}")
+        [false, "Error: #{e.message}"]
+      end
+
+      # Verify that plugin management via D-Bus is explicitly enabled in config.
+      #
+      # @raise [::DBus::Error] when dbus.allow_plugin_management is not true
+      def authorize_plugin_management!
+        return if RosettAi.rai_config.dbus_allow_plugin_management?
+
+        raise ::DBus::Error,
+              'be.neatnerds.rosettai.Error.NotAuthorized: Plugin management via D-Bus is disabled. ' \
+              'Set dbus.allow_plugin_management: true in ~/.config/rosett-ai/config.yml'
+      end
+
+      def validate_type!(type)
+        return if VALID_TYPES.include?(type)
+
+        raise ArgumentError, "Invalid plugin type: #{type}. Valid: #{VALID_TYPES.join(', ')}"
+      end
+
+      def validate_name!(name)
+        return if name.match?(/\A[a-z0-9][a-z0-9_-]*\z/)
+
+        raise ArgumentError, "Invalid plugin name: #{name}"
+      end
+
+      # Map plugin type + name to a package name.
+      # Convention: rosett-ai-<type>-<name> for apt, rosett-ai-<type>-<name> for gems.
+      #
+      # @return [String]
+      def plugin_package_name(type, name)
+        "rosett-ai-#{type}-#{name}"
+      end
+
+      # Select the best available package manager.
+      #
+      # @return [PackageManager::Base]
+      def select_package_manager
+        apt = PackageManager::Apt.new
+        return apt if apt.available?
+
+        PackageManager::GemBackend.new
+      end
+    end
+  end
+end

data/lib/rosett_ai/dbus/rate_limiter.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module DBus
+    # Token bucket rate limiter for D-Bus method calls.
+    #
+    # Provides application-level rate limiting to prevent resource exhaustion
+    # from rapid D-Bus method invocations. Each method type can have its own
+    # rate limit.
+    #
+    # Thread-safe: uses mutex for bucket state.
+    #
+    # @example
+    #   limiter = RateLimiter.new(rate: 10, burst: 20)
+    #   if limiter.allow?
+    #     # process request
+    #   else
+    #     raise RateLimitExceeded
+    #   end
+    class RateLimiter
+      # Raised when rate limit is exceeded
+      class RateLimitExceeded < RosettAi::Error
+        def initialize(method_name = nil)
+          msg = method_name ? "Rate limit exceeded for #{method_name}" : 'Rate limit exceeded'
+          super(msg)
+        end
+      end
+
+      # Default limits (requests per second / burst capacity)
+      DEFAULT_RATE = 10
+      DEFAULT_BURST = 20
+
+      # @param rate [Numeric] tokens added per second
+      # @param burst [Integer] maximum bucket capacity
+      def initialize(rate: DEFAULT_RATE, burst: DEFAULT_BURST)
+        @rate = rate.to_f
+        @burst = burst
+        @tokens = burst.to_f
+        @last_update = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        @mutex = Mutex.new
+      end
+
+      # Check if a request is allowed and consume a token if so.
+      #
+      # @return [Boolean] true if request is allowed
+      def allow?
+        @mutex.synchronize do
+          refill_tokens
+          if @tokens >= 1.0
+            @tokens -= 1.0
+            true
+          else
+            false
+          end
+        end
+      end
+
+      # Consume a token or raise RateLimitExceeded.
+      #
+      # @param method_name [String, nil] optional method name for error message
+      # @raise [RateLimitExceeded] if no tokens available
+      def consume!(method_name = nil)
+        raise RateLimitExceeded, method_name unless allow?
+      end
+
+      # Current available tokens (for monitoring/debugging).
+      #
+      # @return [Float] current token count
+      def available_tokens
+        @mutex.synchronize do
+          refill_tokens
+          @tokens
+        end
+      end
+
+      private
+
+      def refill_tokens
+        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        elapsed = now - @last_update
+        @tokens = [(@tokens + (elapsed * @rate)), @burst.to_f].min
+        @last_update = now
+      end
+    end
+  end
+end

data/lib/rosett_ai/dbus/service.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'dbus'
+
+module RosettAi
+  module DBus
+    # Main D-Bus session service for Rosett-AI.
+    #
+    # Exports interfaces under be.neatnerds.rosettai bus name:
+    # - be.neatnerds.rosettai.Manager: compile, context switching, status
+    # - be.neatnerds.rosettai.FocusMonitor: active window tracking
+    # - org.kde.StatusNotifierItem: system tray presence
+    #
+    # The service is designed to gracefully degrade when D-Bus is unavailable.
+    class Service
+      BUS_NAME = 'be.neatnerds.rosettai'
+      OBJECT_PATH = '/be/neatnerds/rosett-ai'
+
+      attr_reader :bus, :main_loop, :manager, :focus_monitor, :status_notifier
+
+      def initialize
+        @running = false
+        @main_loop = nil
+      end
+
+      # Start the D-Bus service
+      #
+      # @return [Boolean] true if started successfully
+      def start
+        return false if @running
+
+        connect_to_session_bus
+        export_interfaces
+        request_bus_name
+        @running = true
+        true
+      rescue ::DBus::Error => e
+        RosettAi.logger.error("D-Bus service failed to start: #{e.message}")
+        false
+      end
+
+      # Run the event loop (blocking)
+      def run
+        return unless @running
+
+        @main_loop = ::DBus::Main.new
+        @main_loop << @bus
+        RosettAi.logger.info("D-Bus service running on #{BUS_NAME}")
+        @main_loop.run
+      rescue Interrupt
+        stop
+      end
+
+      # Stop the D-Bus service
+      def stop
+        return unless @running
+
+        @main_loop&.quit
+        @focus_monitor&.stop
+        @running = false
+        RosettAi.logger.info('D-Bus service stopped')
+      end
+
+      # Check if the service is running
+      #
+      # @return [Boolean]
+      def running?
+        @running
+      end
+
+      # Check if D-Bus session bus is available
+      #
+      # @return [Boolean]
+      def self.dbus_available?
+        ::DBus::SessionBus.instance
+        true
+      rescue ::DBus::Error
+        false
+      end
+
+      private
+
+      def connect_to_session_bus
+        @bus = ::DBus::SessionBus.instance
+      end
+
+      def export_interfaces
+        @service = @bus.request_service(BUS_NAME)
+
+        @manager = ManagerInterface.new(OBJECT_PATH)
+        @manager.service = self
+        @focus_monitor = FocusMonitorInterface.new(OBJECT_PATH)
+
+        @service.export(@manager)
+        @service.export(@focus_monitor)
+
+        export_status_notifier
+
+        # Start focus monitoring
+        @focus_monitor.start
+      end
+
+      def export_status_notifier
+        @status_notifier = StatusNotifierInterface.new("#{OBJECT_PATH}/StatusNotifier")
+        @service.export(@status_notifier)
+        RosettAi.logger.debug('StatusNotifierItem exported')
+      rescue StandardError => e
+        RosettAi.logger.warn("StatusNotifierItem unavailable: #{e.message}")
+        @status_notifier = nil
+      end
+
+      def request_bus_name
+        # Bus name already requested via request_service above
+        RosettAi.logger.debug("Registered bus name: #{BUS_NAME}")
+      end
+    end
+  end
+end