heathrow 0.7.0

data/lib/heathrow/plugin/base.rb

@@ -0,0 +1,212 @@
+require 'json'
+
+module Heathrow
+  module Plugin
+    # Base class for all Heathrow plugins
+    #
+    # All communication source plugins (Gmail, Slack, Discord, etc.) should inherit from this class.
+    #
+    # Required Methods:
+    #   - fetch_messages: Fetch new messages from the source
+    #
+    # Optional Methods:
+    #   - send_message: Send a message (if two-way communication supported)
+    #   - delete_message: Delete a message
+    #   - mark_read: Mark message as read on the source
+    #   - can_reply?: Does this source support replying?
+    #   - can_delete?: Does this source support deleting messages?
+    #   - setup_wizard: Configuration wizard steps
+    #   - validate_config: Validate source configuration
+    #   - capabilities: List of capabilities this plugin supports
+    #
+    class Base
+      attr_reader :source, :config, :logger, :event_bus
+
+      def initialize(source, logger: nil, event_bus: nil)
+        @source = source
+        @config = parse_config(source['config'])
+        @logger = logger
+        @event_bus = event_bus
+        @capabilities = default_capabilities
+      end
+
+      # Fetch new messages from the source
+      # Must return an array of message hashes:
+      #   [{
+      #     external_id: "msg_123",
+      #     sender: "user@example.com",
+      #     sender_name: "John Doe",
+      #     recipients: ["me@example.com"],
+      #     subject: "Hello",
+      #     content: "Message content",
+      #     timestamp: 1234567890,
+      #     ...
+      #   }]
+      def fetch_messages
+        raise NotImplementedError, "#{self.class} must implement fetch_messages"
+      end
+
+      # Send a message through this source
+      # Returns [success, result_or_error]
+      def send_message(recipients, subject: nil, content:, **options)
+        raise NotImplementedError, "#{self.class} does not support sending messages"
+      end
+
+      # Delete a message (if supported)
+      def delete_message(external_id)
+        raise NotImplementedError, "#{self.class} does not support deleting messages"
+      end
+
+      # Mark message as read on the source (if supported)
+      def mark_read(external_id)
+        raise NotImplementedError, "#{self.class} does not support marking messages as read"
+      end
+
+      # Capabilities
+      def can_reply?
+        @capabilities.include?('write')
+      end
+
+      def can_delete?
+        @capabilities.include?('delete')
+      end
+
+      def can_mark_read?
+        @capabilities.include?('mark_read')
+      end
+
+      def supports_real_time?
+        @capabilities.include?('real_time')
+      end
+
+      def supports_attachments?
+        @capabilities.include?('attachments')
+      end
+
+      def supports_threads?
+        @capabilities.include?('threads')
+      end
+
+      # Get all capabilities
+      def capabilities
+        @capabilities
+      end
+
+      # Setup wizard for configuration
+      # Returns array of wizard steps:
+      #   [{
+      #     key: 'api_key',
+      #     prompt: 'Enter your API key:',
+      #     type: 'text',
+      #     required: true
+      #   }]
+      def setup_wizard
+        []
+      end
+
+      # Validate configuration
+      # Returns [valid, error_message]
+      def validate_config
+        [true, nil]
+      end
+
+      # Health check
+      # Returns [healthy, status_message]
+      def health_check
+        begin
+          # Default: try to fetch messages as health check
+          fetch_messages
+          [true, "OK"]
+        rescue => e
+          [false, e.message]
+        end
+      end
+
+      # Get source metadata
+      def metadata
+        {
+          type: self.class.name.split('::').last.downcase,
+          capabilities: @capabilities,
+          config_keys: @config.keys
+        }
+      end
+
+      protected
+
+      # Parse configuration (handles both JSON string and Hash)
+      def parse_config(config)
+        return {} if config.nil?
+        return config if config.is_a?(Hash)
+
+        begin
+          JSON.parse(config)
+        rescue JSON::ParserError
+          {}
+        end
+      end
+
+      # Default capabilities for a read-only source
+      def default_capabilities
+        ['read']
+      end
+
+      # Log helper methods
+      def log_info(message, context = {})
+        @logger&.info(message, context.merge(plugin: self.class.name))
+      end
+
+      def log_error(message, error = nil, context = {})
+        ctx = context.merge(plugin: self.class.name)
+        ctx[:error] = error if error
+        @logger&.error(message, ctx)
+      end
+
+      def log_debug(message, context = {})
+        @logger&.debug(message, context.merge(plugin: self.class.name))
+      end
+
+      # Publish event helper
+      def publish_event(event_name, data = {})
+        @event_bus&.publish(event_name, data.merge(plugin: self.class.name))
+      end
+
+      # Helper: Convert timestamp to Unix timestamp
+      def to_unix_timestamp(time)
+        case time
+        when Integer
+          time
+        when Time
+          time.to_i
+        when String
+          Time.parse(time).to_i
+        else
+          Time.now.to_i
+        end
+      end
+
+      # Helper: Normalize message data to Heathrow format
+      def normalize_message(data)
+        {
+          external_id: data[:external_id] || data[:id],
+          sender: data[:sender] || data[:from],
+          sender_name: data[:sender_name] || data[:from_name],
+          recipients: Array(data[:recipients] || data[:to]),
+          cc: Array(data[:cc]),
+          bcc: Array(data[:bcc]),
+          subject: data[:subject],
+          content: data[:content] || data[:body] || data[:text],
+          html_content: data[:html_content] || data[:html],
+          timestamp: to_unix_timestamp(data[:timestamp] || data[:created_at] || Time.now),
+          read: data[:read],
+          starred: data[:starred],
+          replied: data[:replied],
+          thread_id: data[:thread_id],
+          parent_id: data[:parent_id],
+          labels: Array(data[:labels] || data[:tags]),
+          attachments: Array(data[:attachments]),
+          metadata: data[:metadata] || {}
+        }
+      end
+    end
+  end
+end

data/lib/heathrow/plugin_manager.rb

@@ -0,0 +1,141 @@
+# Plugin manager for communication source plugins with error boundaries
+module Heathrow
+  class PluginManager
+    attr_reader :plugins, :plugin_errors, :logger, :event_bus
+
+    def initialize(logger: nil, event_bus: nil)
+      @plugins = {}
+      @plugin_errors = {}
+      @plugin_dir = HEATHROW_PLUGINS
+      @logger = logger
+      @event_bus = event_bus
+      ensure_plugin_directory
+      load_plugins
+    end
+
+    def ensure_plugin_directory
+      require 'fileutils'
+      FileUtils.mkdir_p(@plugin_dir) unless Dir.exist?(@plugin_dir)
+    end
+
+    def load_plugins
+      # Load built-in plugins
+      load_builtin_plugins
+
+      # Load user plugins from ~/.heathrow/plugins/
+      Dir.glob(File.join(@plugin_dir, '*.rb')).each do |plugin_file|
+        load_plugin(plugin_file)
+      end
+
+      @logger&.info("PluginManager: Loaded #{@plugins.size} plugin(s)")
+      @event_bus&.publish('plugins.loaded', plugin_types: @plugins.keys)
+    end
+
+    def load_builtin_plugins
+      # Built-in source plugins will auto-register when required
+      # This is handled by the create_source method
+    end
+
+    def load_plugin(plugin_file)
+      begin
+        require plugin_file
+        # Plugin should register itself via PluginManager.register
+        @logger&.info("PluginManager: Loaded plugin from #{plugin_file}")
+      rescue StandardError => e
+        error_msg = "Failed to load plugin #{plugin_file}: #{e.message}"
+        @logger&.error(error_msg, error: e)
+        @plugin_errors[plugin_file] = e
+      end
+    end
+
+    def register(type, plugin_class)
+      @plugins[type] = plugin_class
+      @logger&.debug("PluginManager: Registered plugin type '#{type}'")
+      @event_bus&.publish('plugin.registered', type: type, class: plugin_class.name)
+    end
+
+    def get_plugin(type)
+      @plugins[type]
+    end
+
+    def available_types
+      @plugins.keys
+    end
+
+    def plugin_registered?(type)
+      @plugins.key?(type)
+    end
+    
+    def create_source(type, source)
+      # Try to load the source module dynamically with error boundary
+      begin
+        # Handle 'web' as 'webpage' for the module
+        module_name = type == 'web' ? 'webpage' : type
+        require_relative "sources/#{module_name}"
+
+        # Get the class
+        class_name = module_name.capitalize
+        source_class = Heathrow::Sources.const_get(class_name)
+
+        # Create instance with error boundary
+        instance = source_class.new(source)
+
+        @logger&.info("PluginManager: Created source instance for type '#{type}'", source_id: source['id'])
+        @event_bus&.publish('source.created', type: type, source_id: source['id'])
+
+        instance
+      rescue LoadError => e
+        error_msg = "Source module not found: #{module_name}"
+        @logger&.error(error_msg, error: e, type: type)
+        @event_bus&.publish('source.create_failed', type: type, error: e.message)
+        nil
+      rescue StandardError => e
+        error_msg = "Error creating source"
+        @logger&.error(error_msg, error: e, type: type)
+        @event_bus&.publish('source.create_failed', type: type, error: e.message)
+        nil
+      end
+    end
+
+    # Execute plugin method with error boundary
+    # Returns [success, result_or_error]
+    def safe_execute(plugin_instance, method_name, *args)
+      begin
+        result = plugin_instance.send(method_name, *args)
+        @logger&.debug("PluginManager: Executed #{method_name} successfully")
+        [true, result]
+      rescue => e
+        @logger&.error("PluginManager: Error in #{method_name}", error: e)
+        @event_bus&.publish('plugin.error', method: method_name, error: e.message)
+        [false, e]
+      end
+    end
+
+    # Get plugin health status
+    def plugin_health
+      {
+        total_plugins: @plugins.size,
+        plugin_types: @plugins.keys,
+        errors: @plugin_errors.transform_values { |e| e.message }
+      }
+    end
+
+    # Reload a specific plugin
+    def reload_plugin(type)
+      @plugins.delete(type)
+      load_plugins
+      @logger&.info("PluginManager: Reloaded plugin type '#{type}'")
+    end
+
+    # Unregister a plugin
+    def unregister(type)
+      if @plugins.delete(type)
+        @logger&.info("PluginManager: Unregistered plugin type '#{type}'")
+        @event_bus&.publish('plugin.unregistered', type: type)
+        true
+      else
+        false
+      end
+    end
+  end
+end

data/lib/heathrow/poller.rb

@@ -0,0 +1,93 @@
+# Background polling service for fetching messages
+require 'thread'
+
+module Heathrow
+  class Poller
+    attr_reader :running
+    
+    def initialize(db, plugin_manager)
+      @db = db
+      @plugin_manager = plugin_manager
+      @running = false
+      @thread = nil
+      @mutex = Mutex.new
+    end
+    
+    def start
+      return if @running
+      
+      @running = true
+      @thread = Thread.new do
+        run_polling_loop
+      end
+    end
+    
+    def stop
+      @running = false
+      @thread&.join(5) # Wait up to 5 seconds for thread to finish
+    end
+    
+    private
+    
+    def run_polling_loop
+      while @running
+        begin
+          poll_sources
+          sleep 10 # Check every 10 seconds
+        rescue StandardError => e
+          log_error("Polling error: #{e.message}")
+        end
+      end
+    end
+    
+    def poll_sources
+      sources = @db.get_sources(true) # Only enabled sources
+      
+      sources.each do |source_data|
+        source = Source.new(
+          id: source_data['id'],
+          type: source_data['type'],
+          name: source_data['name'],
+          config: source_data['config'],
+          enabled: source_data['enabled'] == 1,
+          poll_interval: source_data['poll_interval'],
+          last_poll: source_data['last_poll']
+        )
+        
+        next unless source.should_poll?
+        
+        poll_source(source)
+      end
+    end
+    
+    def poll_source(source)
+      plugin = @plugin_manager.create_source(source.type, source)
+      return unless plugin
+      
+      begin
+        messages = plugin.fetch_messages
+        
+        @mutex.synchronize do
+          messages.each do |msg_data|
+            message = Message.new(msg_data)
+            message.source_id = source.id
+            message.source_type = source.type
+            
+            @db.insert_message(message.to_h.values)
+          end
+          
+          @db.update_source_poll_time(source.id)
+        end
+      rescue StandardError => e
+        log_error("Error polling #{source.name}: #{e.message}")
+      end
+    end
+    
+    def log_error(message)
+      log_file = File.join(HEATHROW_LOGS, 'poller.log')
+      File.open(log_file, 'a') do |f|
+        f.puts "[#{Time.now}] #{message}"
+      end
+    end
+  end
+end

data/lib/heathrow/smtp_sender.rb

@@ -0,0 +1,204 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'tempfile'
+require 'shellwords'
+
+module Heathrow
+  # SMTP sender module - supports OAuth2 and standard SMTP
+  # Configure oauth2_domains, smtp_command, safe_dir in ~/.heathrowrc
+  class SmtpSender
+    attr_reader :from_address, :config
+
+    def initialize(from_address, config = {})
+      @from_address = from_address
+      @config = config
+      cfg = Heathrow::Config.instance
+      @oauth2_domains = cfg&.rc('oauth2_domains', %w[gmail.com]) || %w[gmail.com]
+      @smtp_command = cfg&.rc('smtp_command', File.expand_path('~/bin/gmail_smtp'))
+      @safe_dir = cfg&.rc('safe_dir', File.join(Dir.home, '.heathrow', 'mail'))
+      @smtp_log_path = File.join(@safe_dir, '.smtp.log')
+    end
+    
+    # Send an email message
+    # @param mail [Mail::Message] The mail object to send
+    # @param recipients [String, Array] Recipient email addresses
+    # @return [Hash] Result with :success and :message keys
+    def send(mail, recipients = nil)
+      # Extract recipients from mail object if not provided
+      recipients ||= extract_recipients(mail)
+      
+      # Determine sending method based on from address
+      if uses_oauth2?
+        send_via_gmail_smtp(mail, recipients)
+      elsif config['smtp_server']
+        send_via_smtp_server(mail, recipients)
+      else
+        { success: false, message: "No SMTP configuration available for #{from_address}" }
+      end
+    end
+    
+    # Check if this address uses OAuth2 via gmail_smtp
+    def uses_oauth2?
+      return false unless from_address
+      
+      domain = from_address.split('@').last
+      @oauth2_domains.include?(domain)
+    end
+    
+    # Class method for quick sending
+    def self.send_message(from, to, subject, body, in_reply_to = nil, config = {})
+      require 'mail'
+      
+      mail = Mail.new do
+        from     from
+        to       to
+        subject  subject
+        body     body
+      end
+      
+      # Add threading headers if replying
+      if in_reply_to
+        mail['In-Reply-To'] = in_reply_to
+        mail['References'] = in_reply_to
+      end
+      
+      sender = new(from, config)
+      sender.send(mail)
+    end
+    
+    private
+    
+    # Send using integrated OAuth2 module
+    def send_via_gmail_smtp(mail, recipients)
+      require_relative 'oauth2_smtp'
+      
+      # Use the integrated OAuth2 SMTP module
+      oauth2 = Heathrow::OAuth2Smtp.new(from_address)
+      result = oauth2.send(mail, recipients)
+      
+      # Add fallback to external script if integrated module fails
+      if !result[:success] && File.exist?(@smtp_command)
+        send_via_external_script(mail, recipients)
+      else
+        result
+      end
+    end
+    
+    # Fallback to external gmail_smtp script
+    def send_via_external_script(mail, recipients)
+      begin
+        tempfile = Tempfile.new(['heathrow-mail', '.eml'])
+        tempfile.write(mail.to_s)
+        tempfile.flush
+        
+        recipient_list = Array(recipients).map(&:strip).join(' ')
+        cmd = "#{@smtp_command} -f #{Shellwords.escape(from_address)} -i #{recipient_list}"
+        
+        success = system("#{cmd} < #{Shellwords.escape(tempfile.path)}")
+        
+        if success
+          { success: true, message: "Message sent via OAuth2 (external script)" }
+        else
+          error_msg = read_smtp_log_error
+          { success: false, message: "Send failed: #{error_msg}" }
+        end
+        
+      rescue => e
+        { success: false, message: "Error sending: #{e.message}" }
+      ensure
+        tempfile&.close
+        tempfile&.unlink
+      end
+    end
+    
+    # Send using configured SMTP server
+    def send_via_smtp_server(mail, recipients)
+      require 'net/smtp'
+      
+      begin
+        smtp_config = config['smtp_server'] ? config : default_smtp_config
+        
+        smtp = Net::SMTP.new(
+          smtp_config['smtp_server'],
+          smtp_config['smtp_port'] || 587
+        )
+        
+        # Enable TLS for secure ports
+        if smtp_config['smtp_port'] != 25
+          smtp.enable_starttls
+        end
+        
+        # Authenticate and send
+        bare_from = from_address[/<([^>]+)>/, 1] || from_address.strip
+        bare_recipients = Array(recipients).map { |r| r[/<([^>]+)>/, 1] || r.strip }
+
+        smtp.start(
+          smtp_config['smtp_server'],
+          smtp_config['smtp_username'] || bare_from,
+          smtp_config['smtp_password'],
+          :plain
+        ) do |smtp_conn|
+          smtp_conn.send_message(
+            mail.to_s,
+            bare_from,
+            bare_recipients
+          )
+        end
+        
+        { success: true, message: "Message sent via SMTP server" }
+        
+      rescue => e
+        { success: false, message: "SMTP send failed: #{e.message}" }
+      end
+    end
+    
+    # Extract recipients from mail object
+    def extract_recipients(mail)
+      recipients = []
+      recipients += Array(mail.to) if mail.to
+      recipients += Array(mail.cc) if mail.cc
+      recipients += Array(mail.bcc) if mail.bcc
+      recipients.map(&:to_s).uniq
+    end
+    
+    # Read last error from SMTP log
+    def read_smtp_log_error
+      return "Unknown error" unless File.exist?(@smtp_log_path)
+      
+      # Get last 5 lines from log
+      lines = File.readlines(@smtp_log_path).last(5)
+      
+      # Look for error indicators
+      error_lines = lines.select { |l| l =~ /error|fail|denied|invalid/i }
+      
+      if error_lines.any?
+        error_lines.join(' ').strip
+      else
+        lines.join(' ').strip
+      end
+    rescue
+      "Could not read SMTP log"
+    end
+    
+    # Default SMTP configuration for common providers
+    def default_smtp_config
+      case from_address
+      when /@gmail\.com$/
+        {
+          'smtp_server' => 'smtp.gmail.com',
+          'smtp_port' => 587,
+          'smtp_username' => from_address
+        }
+      when /@(outlook|hotmail|live)\.com$/
+        {
+          'smtp_server' => 'smtp-mail.outlook.com',
+          'smtp_port' => 587,
+          'smtp_username' => from_address
+        }
+      else
+        {}
+      end
+    end
+  end
+end

data/lib/heathrow/source.rb

@@ -0,0 +1,39 @@
+# Source model for communication sources
+module Heathrow
+  class Source
+    attr_accessor :id, :type, :name, :config, :enabled, :poll_interval, :last_poll
+    
+    def initialize(attrs = {})
+      @id = attrs[:id] || generate_id
+      @type = attrs[:type]
+      @name = attrs[:name]
+      @config = attrs[:config] || {}
+      @enabled = attrs[:enabled] != false
+      @poll_interval = attrs[:poll_interval] || 60
+      @last_poll = attrs[:last_poll]
+    end
+    
+    def generate_id
+      "#{@type}_#{Time.now.to_i}_#{rand(1000)}"
+    end
+    
+    def to_h
+      {
+        id: @id,
+        type: @type,
+        name: @name,
+        config: @config.to_json,
+        enabled: @enabled ? 1 : 0,
+        poll_interval: @poll_interval,
+        last_poll: @last_poll
+      }
+    end
+    
+    def should_poll?
+      return false unless @enabled
+      return true if @last_poll.nil?
+      
+      Time.now - Time.parse(@last_poll) >= @poll_interval
+    end
+  end
+end