simplex-chat 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b49dea10199c71c10df356701b53087eda1e8aeb5c31348e39a62032280d96b
-  data.tar.gz: e97b4de663eb4abe3aac556b6f8a1b2cf1dcce1d37b2ebfdfc645a7b8e9c05a4
+  metadata.gz: 662e4bdcc4df337d7382a5b1c13dc3ac7f9f89db0ea69d5b97c778f20e0d841c
+  data.tar.gz: c9fba2eb82c77f0e35ff434864b4a8443edd41662697f4de46f1c10dd412d059
 SHA512:
-  metadata.gz: c2c78755a44732f0b2ab43a080981d4f332c414e2080ff8e4d8ddf76a6af8ed53a0e6c5699561df33b0d8e9d713c92774c1dbff75cc60809adb4ff463f10af8f
-  data.tar.gz: 70eb7367381d1442ed72ff4ae92ed7d876d99e1d3d506bd4da9eafa833f7e1e32c814bec37e052ca9c0b932f726bba59668459de646fac20b004fff14f0ced15
+  metadata.gz: c2f3f4895711d3e1e26b1b1cb843aee645fac8b52d4b6f57621f0ac1ad6966363a9130eea9b48af896d2640547792e9577ae25e47a096d48bbf293d6b634c00f
+  data.tar.gz: f5a533224f6058317f47fef4c65874320823dd55517282c84ce30d31d438d365f00e968a39bf688c009a58be68b47fe130e1c76bbba2def81cf11cb46b15b739

data/lib/simplex-chat/cmd-runner.rb

@@ -0,0 +1,163 @@
+module SimpleXChat
+  class BasicCommand
+    attr_reader :name, :num_args, :desc, :min_role
+
+    # TODO: Allow optional arguments
+    def initialize(name, desc="", num_args: 0, min_role: GroupMemberRole::MEMBER,
+                   per_sender_cooldown_secs: nil, per_issuer_cooldown_secs: nil)
+      @name = name
+      @num_args = num_args
+      @desc = desc
+      @min_role = min_role
+      @per_sender_cooldown_secs = per_sender_cooldown_secs
+      @per_issuer_cooldown_secs = per_issuer_cooldown_secs
+      @last_runs = {
+        :per_sender => {},
+        :per_issuer => {}
+      }
+      @last_runs_lock = Mutex.new
+    end
+
+    def validate_and_execute(client, chat_msg, args)
+      return if not validate(client, chat_msg, args)
+      execute client, chat_msg, args
+    end
+
+    private
+
+    def validate(client, chat_msg, args)
+      msg_text = chat_msg[:msg_text]
+      chat_type = chat_msg[:chat_type]
+      issuer = chat_msg[:contact]
+      issuer_role = chat_msg[:contact_role]
+      sender = chat_msg[:sender]
+
+      # Verify that user has permissions to run the command
+      role_hierarchy = {
+        GroupMemberRole::MEMBER => 0,
+        GroupMemberRole::ADMIN => 1,
+        GroupMemberRole::OWNER => 2
+      }
+      perms = role_hierarchy[issuer_role]
+      if issuer_role != nil and perms == nil || perms < role_hierarchy[@min_role]
+        client.api_send_text_message chat_type, sender, "@#{issuer}: You do not have permission to run this command (required: #{@min_role})"
+        return false
+      end
+
+      # Verify arguments
+      if args.length != @num_args
+        client.api_send_text_message chat_type, sender, "@#{issuer}: Incorrect number of arguments (required: #{@num_args})"
+        return false
+      end
+
+      # Verify per sender cooldown
+      # NOTE: This should be the last verification, because
+      #       it will update the last-validated-runs object
+      is_on_cooldown = true
+      remaining_cooldown = 0.0
+      chat = "#{chat_type}#{sender}"
+      chat_and_issuer = "#{chat_type}#{sender}[#{issuer}]"
+      @last_runs_lock.synchronize {
+        sender_last_run = @last_runs[:per_sender][chat]
+        issuer_last_run = @last_runs[:per_issuer][chat_and_issuer]
+        now = Time.now
+        if sender_last_run != nil && @per_sender_cooldown_secs != nil
+          time_diff = now - sender_last_run
+          if time_diff < @per_sender_cooldown_secs
+            remaining_cooldown = @per_sender_cooldown_secs - time_diff
+          end
+        end
+
+        if issuer_last_run != nil && @per_issuer_cooldown_secs != nil
+          time_diff = now - issuer_last_run
+          if time_diff < @per_issuer_cooldown_secs
+            cooldown = @per_issuer_cooldown_secs - time_diff
+            remaining_cooldown = [cooldown, remaining_cooldown].max
+          end
+        end
+
+        break if remaining_cooldown > 0.0
+
+        @last_runs[:per_sender][chat] = now
+        @last_runs[:per_issuer][chat_and_issuer] = now
+        is_on_cooldown = false
+      }
+
+      if is_on_cooldown
+        client.api_send_text_message chat_type, sender, "@#{issuer}: On cooldown, try again in #{remaining_cooldown.round(1)} seconds"
+        return false
+      end
+      
+
+      return true
+    end
+
+    def execute(client, chat_msg, args)
+      raise NoMethodError.new(
+        "[!] Default BasicCommand::execute called, nothing will be done\n" \
+        "    Extend this class to implement custom execution behavior"
+      )
+    end
+  end
+
+  class BasicCommandRunner
+    def initialize(client, commands, prefix)
+      @client = client
+      @commands = commands.map { |cmd|
+        { "#{prefix}#{cmd.name}" => cmd }
+      }.reduce({}, &:merge)
+      @prefix = prefix
+      @logger = Logging.logger
+    end
+
+    def listen(max_backlog_secs: 5.0)
+      loop do
+        begin
+          break if process_next_event(max_backlog_secs) == :stop
+        rescue SimpleXChat::GenericError => e
+          @logger.error("[!] Caught error: #{e}")
+        rescue => e
+          raise e
+        end
+      end
+    end
+
+    private
+
+    def process_next_event(max_backlog_secs)
+      chat_msg = @client.next_chat_message(max_backlog_secs: max_backlog_secs)
+      if chat_msg == nil
+        @logger.warn("Message queue is closed")
+        return :stop
+      end
+      @logger.debug("Chat message: #{chat_msg}")
+
+      msg_text = chat_msg[:msg_text]
+      chat_type = chat_msg[:chat_type]
+      issuer = chat_msg[:contact]
+      issuer_role = chat_msg[:contact_role]
+      sender = chat_msg[:sender]
+
+      # Verify if this is a registered command
+      message_items = msg_text.split(" ")
+      first_word = message_items[0]
+
+      # React to all messages we will process
+      if first_word.start_with?(@prefix)
+        @client.api_reaction chat_msg[:chat_type], chat_msg[:sender_id], chat_msg[:msg_item_id], emoji: '🚀'
+      end
+
+      command = @commands[first_word]
+      if command == nil
+        @client.api_send_text_message chat_msg[:chat_type], chat_msg[:sender], "@#{issuer}: Unknown command"
+        return
+      end
+
+      args = message_items[1..]
+
+      # Run command
+      @logger.debug("Validating and executing command '#{command.name}' for: #{chat_type}#{sender} [#{issuer}]: #{msg_text}")
+      command.validate_and_execute @client, chat_msg, args
+    end
+  end
+end

data/lib/simplex-chat/logger.rb

@@ -0,0 +1,18 @@
+require 'logger'
+
+module SimpleXChat
+  module Logging
+    def self.logger(dest: $stderr, log_level: Logger::INFO)
+      if @logger == nil
+        @logger = Logger.new(dest)
+        @logger.level = log_level
+        @logger.progname = 'simplex-chat'
+        @logger.formatter = -> (severity, datetime, progname, msg) {
+          "| [#{severity}] | #{datetime} | (#{progname}) :: #{msg}\n"
+        }
+      end
+
+      @logger
+    end
+  end
+end

data/lib/simplex-chat/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SimpleXChat
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 end

data/lib/simplex-chat.rb

@@ -4,6 +4,7 @@ require_relative 'simplex-chat/version'
 require_relative 'simplex-chat/errors'
 require_relative 'simplex-chat/patches'
 require_relative 'simplex-chat/types'
+require_relative 'simplex-chat/logger'
 
 module SimpleXChat
   require 'net/http'
@@ -14,9 +15,7 @@ module SimpleXChat
   require 'time'
 
   class ClientAgent
-    attr_accessor :on_message
-
-    def initialize(client_uri, connect: true, log_level: Logger::INFO, timeout_ms: 10_000, interval_ms: 100)
+    def initialize(client_uri, connect: true, timeout_ms: 10_000, interval_ms: 100)
       @uri = client_uri
       @message_queue = Queue.new
       @chat_message_queue = Queue.new
@@ -30,12 +29,7 @@ module SimpleXChat
       @timeout_ms = timeout_ms
       @interval_ms = interval_ms
 
-      @logger = Logger.new($stderr)
-      @logger.level = log_level
-      @logger.progname = 'simplex-chat'
-      @logger.formatter = -> (severity, datetime, progname, msg) {
-        "| [#{severity}] | #{datetime} | (#{progname}) :: #{msg}\n"
-      }
+      @logger = Logging.logger
 
       self.connect if connect
 
@@ -110,7 +104,13 @@ module SimpleXChat
       #       a chat message queue to insert one or
       #       more messages at a time, but poll just
       #       one at a time
-      return @chat_message_queue.pop if not @chat_message_queue.empty?
+      # NOTE: We use non-blocking pop for thread safety
+      begin
+        chat_msg = @chat_message_queue.pop(true)
+        return chat_msg
+      rescue ThreadError
+        @logger.debug("Chat message queue is empty, waiting for new messages...")
+      end
   
       loop do
         msg = next_message
@@ -135,13 +135,20 @@ module SimpleXChat
           end
 
           @chat_message_queue.push chat_message
+          @logger.debug("Chat message pushed to queue: #{chat_message}")
         end
 
         # NOTE: Even after parsing the messages, the
         #       chat message queue can be empty because
         #       all the messages are too old, so we have
         #       to check again
-        return @chat_message_queue.pop if not @chat_message_queue.empty?
+        begin
+          chat_msg = @chat_message_queue.pop(true)
+          @logger.debug("Chat message popped from queue")
+          return chat_msg
+        rescue ThreadError
+          @logger.debug("Chat message queue is still empty, waiting for new messages...")
+        end
       end
 
       nil

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: simplex-chat
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - rdbo
 bindir: exe
 cert_chain: []
-date: 2025-03-05 00:00:00.000000000 Z
+date: 2025-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: websocket
@@ -48,7 +48,9 @@ files:
 - README.md
 - Rakefile
 - lib/simplex-chat.rb
+- lib/simplex-chat/cmd-runner.rb
 - lib/simplex-chat/errors.rb
+- lib/simplex-chat/logger.rb
 - lib/simplex-chat/patches.rb
 - lib/simplex-chat/types.rb
 - lib/simplex-chat/version.rb