slack-smart-bot 1.8.2 → 1.9.1

data/lib/slack/smart-bot/commands/on_bot/ruby_code.rb

@@ -13,39 +13,64 @@ class SlackSmartBot
       (!user.key?(:enterprise_user) or ( user.key?(:enterprise_user) and !config[:allow_access][__method__].include?(user[:enterprise_user].id)))
       respond "You don't have access to use this command, please contact an Admin to be able to use it: <@#{config.admins.join(">, <@")}>"
     else
-      unless code.match?(/System/i) or code.match?(/Kernel/i) or code.include?("File") or
+      unless code.match?(/System/i) or code.match?(/Kernel/i) or code.include?("File.") or
             code.include?("`") or code.include?("exec") or code.include?("spawn") or code.include?("IO.") or
             code.match?(/open3/i) or code.match?(/bundle/i) or code.match?(/gemfile/i) or code.include?("%x") or
-            code.include?("ENV") or code.match?(/=\s*IO/)
+            code.include?("ENV") or code.match?(/=\s*IO/) or code.include?("Dir.") or code.match?(/=\s*IO/) or
+            code.match?(/=\s*File/) or code.match?(/=\s*Dir/) or code.match?(/<\s*File/) or code.match?(/<\s*Dir/) or
+            code.match?(/\w+:\s*File/) or code.match?(/\w+:\s*Dir/)
+        react :running
         unless rules_file.empty?
           begin
             eval(File.new(config.path+rules_file).read) if File.exist?(config.path+rules_file)
           end
         end
 
-        respond "Running", dest if code.size > 100
+        respond "Running", dest if code.size > 200
 
         begin
           code.gsub!(/^\W*$/, "") #to remove special chars from slack when copy/pasting
+          code.gsub!('$','\$') #to take $ as literal, fex: puts '$lolo' => puts '\$lolo'
           ruby = "ruby -e \"#{code.gsub('"', '\"')}\""
           if defined?(project_folder) and project_folder.to_s != "" and Dir.exist?(project_folder)
             ruby = ("cd #{project_folder} &&" + ruby)
           else
             def project_folder() "" end
           end
-          stdout, stderr, status = Open3.capture3(ruby)
-          if stderr == ""
-            if stdout == ""
-              respond "Nothing returned. Remember you need to use p or puts to print", dest
+
+          stdin, stdout, stderr, wait_thr = Open3.popen3(ruby)
+          timeout = timeoutt = 20
+          procstart = Time.now
+          while (wait_thr.status == 'run' or wait_thr.status == 'sleep') and timeout > 0
+            timeout -= 0.1
+            sleep 0.1
+          end
+          if timeout > 0
+            stdout = stdout.read
+            stderr = stderr.read
+            if stderr == ""
+              if stdout == ""
+                respond "Nothing returned. Remember you need to use p or puts to print", dest
+              else
+                respond stdout, dest
+              end
             else
-              respond stdout, dest
+              respond "#{stderr}\n#{stdout}", dest
             end
           else
-            respond "#{stderr}\n#{stdout}", dest
+            respond "The process didn't finish in #{timeoutt} secs so it was aborted. Timeout!"
+            pids = `pgrep -P #{wait_thr.pid}`.split("\n").map(&:to_i) #todo: it needs to be adapted for Windows
+            pids.each do |pid|
+              begin
+                Process.kill("KILL", pid)
+              rescue
+              end
+            end
           end
         rescue Exception => exc
           respond exc, dest
         end
+        unreact :running
       else
         respond "Sorry I cannot run this due security reasons", dest
       end

data/lib/slack/smart-bot/commands/on_bot/run_repl.rb

@@ -4,7 +4,6 @@ class SlackSmartBot
   # help: `run repl SESSION_NAME ENV_VAR=VALUE ENV_VAR=VALUE`
   # help: `run live SESSION_NAME`
   # help: `run irb SESSION_NAME`
-  # help: 
   # help:     Will run the repl session specified and return the output. 
   # help:     You can supply the Environmental Variables you need for the Session
   # help:     It will return only the values that were print out on the repl with puts, print, p or pp
@@ -22,7 +21,7 @@ class SlackSmartBot
       Dir.mkdir("#{config.path}/repl") unless Dir.exist?("#{config.path}/repl")
       Dir.mkdir("#{config.path}/repl/#{@channel_id}") unless Dir.exist?("#{config.path}/repl/#{@channel_id}")
       if File.exist?("#{config.path}/repl/#{@channel_id}/#{session_name}.run")
-        if @repls.key?(session_name) and @repls[session_name][:type] == :private and 
+        if @repls.key?(session_name) and (@repls[session_name][:type] == :private or @repls[session_name][:type] == :private_clean) and 
           @repls[session_name][:creator_name]!=user.name and 
           !config.admins.include?(user.name)
           respond "The REPL with session name: #{session_name} is private", dest
@@ -44,7 +43,7 @@ class SlackSmartBot
               eval(File.new(config.path+rules_file).read) if File.exist?(config.path+rules_file)
             end
           end
-          if File.exist?("#{project_folder}/.smart-bot-repl")
+          if File.exist?("#{project_folder}/.smart-bot-repl") and @repls[session_name][:type] != :private_clean and @repls[session_name][:type] != :public_clean
             content += File.read("#{project_folder}/.smart-bot-repl")
             content += "\n"
           end

data/lib/slack/smart-bot/commands/on_bot/see_repls.rb

@@ -14,7 +14,7 @@ class SlackSmartBot
     else
       message = ""
       @repls.sort.to_h.each do |session_name, repl|
-        if (repl.creator_name == user.name or repl.type == :public) or (config.admins.include?(user.name) and typem == :on_dm)
+        if (repl.creator_name == user.name or repl.type == :public or repl.type == :public_clean) or (config.admins.include?(user.name) and typem == :on_dm)
           message += "(#{repl.type}) *#{session_name}*: #{repl.description} / created: #{repl.created} / accessed: #{repl.accessed} / creator: #{repl.creator_name} / runs: #{repl.runs_by_creator+repl.runs_by_others} / gets: #{repl.gets} \n"
         end
       end

data/lib/slack/smart-bot/commands/on_bot/see_shortcuts.rb

@@ -13,26 +13,44 @@ class SlackSmartBot
     else
       unless typem == :on_extended
         msg = ""
-        if @shortcuts[:all].keys.size > 0
+        if @shortcuts[:all].keys.size > 0 or @shortcuts_global[:all].keys.size > 0
           msg = "*Available shortcuts for all:*\n"
-          @shortcuts[:all].each { |name, value|
-            msg += "    _#{name}: #{value}_\n"
-          }
+          
+          if @shortcuts[:all].keys.size > 0
+            @shortcuts[:all].each { |name, value|
+              msg += "    _#{name}: #{value}_\n"
+            }
+          end
+          if @shortcuts_global[:all].keys.size > 0
+            @shortcuts_global[:all].each { |name, value|
+              msg += "    _#{name} (global): #{value}_\n"
+            }
+          end
           respond msg, dest
         end
-
+        msg2 = ''
         if @shortcuts.keys.include?(from) and @shortcuts[from].keys.size > 0
           new_hash = @shortcuts[from].dup
           @shortcuts[:all].keys.each { |k| new_hash.delete(k) }
           if new_hash.keys.size > 0
-            msg = "*Available shortcuts for #{from}:*\n"
+            msg2 = "*Available shortcuts for #{from}:*\n"
             new_hash.each { |name, value|
-              msg += "    _#{name}: #{value}_\n"
+              msg2 += "    _#{name}: #{value}_\n"
+            }
+          end
+        end
+        if @shortcuts_global.keys.include?(from) and @shortcuts_global[from].keys.size > 0
+          new_hash = @shortcuts_global[from].dup
+          @shortcuts_global[:all].keys.each { |k| new_hash.delete(k) }
+          if new_hash.keys.size > 0
+            msg2 = "*Available shortcuts for #{from}:*\n" if msg2 == ''
+            new_hash.each { |name, value|
+              msg2 += "    _#{name} (global): #{value}_\n"
             }
-            respond msg, dest
           end
         end
-        respond "No shortcuts found", dest if msg == ""
+        respond msg2 unless msg2 == ''
+        respond "No shortcuts found" if (msg + msg2) == ""
       end
     end
   end

data/lib/slack/smart-bot/commands/on_extended/bot_rules.rb

@@ -7,7 +7,15 @@ class SlackSmartBot
       respond "You don't have access to use this command, please contact an Admin to be able to use it: <@#{config.admins.join(">, <@")}>"
     else
       if typem == :on_extended or typem == :on_call #for the other cases above.
-        help_filtered = get_help(rules_file, dest, from, true)
+
+        if help_command.to_s != ''
+          help_command = '' if help_command.to_s.match?(/^\s*expanded\s*$/i) or help_command.to_s.match?(/^\s*extended\s*$/i)
+          expanded = true
+        else
+          expanded = false
+        end 
+  
+        help_filtered = get_help(rules_file, dest, from, true, expanded)
 
         if help_command.to_s != ""
           help_found = false
@@ -38,6 +46,11 @@ class SlackSmartBot
           def git_project() "" end
           def project_folder() "" end
         end
+        unless expanded
+          message_not_expanded = "*If you want to see the expanded version of `bot rules`, please call `bot rules expanded`*\n"
+          message_not_expanded += "*Also to get specific expanded help for a specific command or rule call `bot rules COMMAND`*\n"
+          respond message_not_expanded
+        end
       end
     end
   end

data/lib/slack/smart-bot/commands/on_master/admin_master/exit_bot.rb

@@ -11,10 +11,10 @@ class SlackSmartBot
     save_stats(__method__)
     if config.on_master_bot
       if config.admins.include?(from) #admin user
-        unless @questions.keys.include?(from)
+        if answer.empty?
           ask("are you sure?", command, from, dest)
         else
-          case @questions[from]
+          case answer
           when /yes/i, /yep/i, /sure/i
             respond "Game over!", dest
             respond "Ciao #{display_name}!", dest
@@ -33,7 +33,7 @@ class SlackSmartBot
               exit!
             end
           when /no/i, /nope/i, /cancel/i
-            @questions.delete(from)
+            answer_delete(from)
             respond "Thanks, I'm happy to be alive", dest
           else
             ask("I don't understand, are you sure do you want me to close? (yes or no)", command, from, dest)

data/lib/slack/smart-bot/commands/on_master/admin_master/notify_message.rb

@@ -18,7 +18,7 @@ class SlackSmartBot
           end
           respond "Bot channels have been notified", dest
         elsif where == "all" #all
-          myconv = client.web_client.users_conversations(exclude_archived: true, limit: 100, types: "im, public_channel,private_channel").channels
+          myconv = get_channels(bot_is_in: true)
           myconv.each do |c|
             respond message, c.id unless c.name == config.master_channel
           end

data/lib/slack/smart-bot/commands/on_master/admin_master/set_maintenance.rb

@@ -0,0 +1,41 @@
+class SlackSmartBot
+  # helpmaster: ----------------------------------------------
+  # helpmaster: `set maintenance on`
+  # helpmaster: `set maintenance on MESSAGE`
+  # helpmaster: `set maintenance off`
+  # helpmaster: `turn maintenance on`
+  # helpmaster: `turn maintenance on MESSAGE`
+  # helpmaster: `turn maintenance off`
+  # helpmaster:    The SmartBot will be on maintenance and responding with a generic message
+  # helpmaster:    Only works if you are on Master channel and you are a master admin user
+  # helpmaster:
+  def set_maintenance(from, status, message)
+    save_stats(__method__)
+    if config.on_master_bot
+      if config.admins.include?(from) #admin user
+        if message == ''
+          config.on_maintenance_message = "Sorry I'm on maintenance so I cannot attend your request."
+        else
+          config.on_maintenance_message = message
+        end
+
+        if status == 'on'
+          config.on_maintenance = true
+          respond "From now on I'll be on maintenance status so I won't be responding accordingly."
+        else
+          config.on_maintenance = false
+          respond "From now on I won't be on maintenance. Everything is back to normal!"
+        end
+        
+        file = File.open("#{config.path}/config_tmp.status", "w")
+        file.write config.inspect
+        file.close
+    
+      else
+        respond 'Only master admins on master channel can use this command.'
+      end
+    else
+      respond 'Only master admins on master channel can use this command.'
+    end
+  end
+end

data/lib/slack/smart-bot/commands/on_master/create_bot.rb

@@ -24,13 +24,9 @@ class SlackSmartBot
           channel_id = @channels_id[channel]
         end
         #todo: add pagination for case more than 1000 channels on the workspace
-        channels = client.web_client.conversations_list(
-          types: "private_channel,public_channel",
-          limit: "1000",
-          exclude_archived: "true",
-        ).channels
+        channels = get_channels()
         channel_found = channels.detect { |c| c.name == channel }
-        members = client.web_client.conversations_members(channel: @channels_id[channel]).members unless channel_found.nil?
+        members = get_channel_members(@channels_id[channel]) unless channel_found.nil?
 
         if channel_id.nil?
           respond "There is no channel with that name: #{channel}, please be sure is written exactly the same", dest
@@ -39,7 +35,7 @@ class SlackSmartBot
         elsif @bots_created.keys.include?(channel_id)
           respond "There is already a bot in this channel: #{channel}, kill it before", dest
         elsif config[:nick_id] != channel_found.creator and !members.include?(config[:nick_id])
-          respond "You need to add first to the channel the smart bot user: #{config[:nick]}", dest
+          respond "You need to add first to the channel the smart bot user: <@#{config[:nick_id]}>", dest
         else
           if channel_id != config[:channel]
             begin
@@ -60,7 +56,7 @@ class SlackSmartBot
               FileUtils.copy_file(default_rules, config.path + rules_file) unless File.exist?(config.path + rules_file)
               FileUtils.copy_file(default_general_rules, config.path + general_rules_file) unless File.exist?(config.path + general_rules_file)
               admin_users = Array.new()
-              creator_info = client.web_client.users_info(user: channel_found.creator)
+              creator_info = get_user_info(channel_found.creator)
               admin_users = [from, creator_info.user.name] + config.masters
               admin_users.uniq!
               @logger.info "ruby #{config.file_path} \"#{channel}\" \"#{admin_users.join(",")}\" \"#{rules_file}\" on"

data/lib/slack/smart-bot/listen.rb

@@ -6,7 +6,7 @@ class SlackSmartBot
     get_bots_created()
       @buffer_complete = [] unless defined?(@buffer_complete)
       b = File.read("#{config.path}/buffer_complete.log")
-      result = b.scan(/^\|(\w+)\|(\w+)\|([^~]+)~~~/m)
+      result = b.scan(/^\|(\w+)\|(\w+)\|(\w+)\|([^~]+)~~~/m)
       result.delete(nil)
       new_messages = result[@buffer_complete.size..-1]
       unless new_messages.nil? or new_messages.empty?
@@ -14,7 +14,8 @@ class SlackSmartBot
         new_messages.each do |message|
           channel = message[0].strip
           user = message[1].strip
-          command = message[2].to_s.strip
+          user_name = message[2].strip
+          command = message[3].to_s.strip
           # take in consideration that on simulation we are treating all messages even those that are not populated on real cases like when the message is not populated to the specific bot connection when message is sent with the bot          
           @logger.info "treat message: #{message}" if config.testing
 
@@ -23,18 +24,18 @@ class SlackSmartBot
             command.scan(/`([^`]+)`/).flatten.each do |cmd|
               if cmd.to_s!=''
                 cmd = "^#{cmd}"
-                treat_message({channel: channel, user: user, text: cmd}, false)
+                treat_message({channel: channel, user: user, text: cmd, user_name: user_name}, false)
               end
             end
           elsif command.match?(/^\s*\-!/)
             command.scan(/`([^`]+)`/).flatten.each do |cmd|
               if cmd.to_s!=''
                 cmd = "!#{cmd}"
-                treat_message({channel: channel, user: user, text: cmd}, false)
+                treat_message({channel: channel, user: user, text: cmd, user_name: user_name}, false)
               end
             end
           else
-            treat_message({channel: channel, user: user, text: command})
+            treat_message({channel: channel, user: user, text: command, user_name: user_name})
           end
         end
       end

data/lib/slack/smart-bot/process.rb

@@ -1,11 +1,15 @@
 class SlackSmartBot
   def process(user, command, dest, dchannel, rules_file, typem, files, ts)
     from = user.name
-    
-    if user.profile.display_name.to_s.match?(/\A\s*\z/)
-      user.profile.display_name = user.profile.real_name
+    if config.simulate
+      display_name = user.profile.display_name
+    else
+      if user.profile.display_name.to_s.match?(/\A\s*\z/)
+        user.profile.display_name = user.profile.real_name
+      end
+      display_name = user.profile.display_name
     end
-    display_name = user.profile.display_name
+    
     processed = true
 
     on_demand = false
@@ -23,205 +27,240 @@ class SlackSmartBot
         command = command2
         on_demand = true
     end
+    if (on_demand or 
+      (@listening.key?(from) and (@listening[from].key?(dest) or @listening[from].key?(Thread.current[:thread_ts])) )) and 
+      config.on_maintenance and !command.match?(/\A(set|turn)\s+maintenance\s+off\s*\z/)
+      respond config.on_maintenance_message, dest
+      processed = true
+    end
 
-    #todo: check :on_pg in this case
-    if typem == :on_master or typem == :on_bot or typem == :on_pg or typem == :on_dm
-      case command
+    if !config.on_maintenance or (config.on_maintenance and command.match?(/\A(set|turn)\s+maintenance\s+off\s*\z/))
+      #todo: check :on_pg in this case
+      if typem == :on_master or typem == :on_bot or typem == :on_pg or typem == :on_dm
+    
+        case command
 
-      when /^\s*(Hello|Hallo|Hi|Hola|What's\sup|Hey|Hæ)\s(#{@salutations.join("|")})\s*$/i
-        hi_bot(user, dest, dchannel, from, display_name)
-      when /^\s*(Bye|Bæ|Good\sBye|Adiós|Ciao|Bless|Bless\sBless|Adeu)\s(#{@salutations.join("|")})\s*$/i
-        bye_bot(dest, from, display_name)
-      when /^\s*bot\s+(rules|help)\s*(.+)?$/i, /^bot,? what can I do/i
-        $1.to_s.match?(/rules/i) ? specific = true : specific = false
-        help_command = $2
+        when /^\s*(Hello|Hallo|Hi|Hola|What's\sup|Hey|Hæ)\s+(#{@salutations.join("|")})\s*$/i
+          hi_bot(user, dest, dchannel, from, display_name)
+        when /^\s*what's\s+new\s*$/i
+          whats_new(user, dest, dchannel, from, display_name)
+        when /^\s*(Bye|Bæ|Good\s+Bye|Adiós|Ciao|Bless|Bless\sBless|Adeu)\s+(#{@salutations.join("|")})\s*$/i
+          bye_bot(dest, from, display_name)
+        when /^\s*bot\s+(rules|help)\s*(.+)?$/i, /^bot,? what can I do/i
+          $1.to_s.match?(/rules/i) ? specific = true : specific = false
+          help_command = $2
 
-        bot_help(user, from, dest, dchannel, specific, help_command, rules_file)
-      when /^\s*use\s+(rules\s+)?(from\s+)?<#C\w+\|(.+)>\s*$/i, /^use\s+(rules\s+)?(from\s+)?([^\s]+\s*$)/i
-        channel = $3
-        use_rules(dest, channel, user, dchannel)
-      when /^\s*stop using rules (from\s+)<#\w+\|(.+)>/i, /^stop using rules (from\s+)(.+)/i
-        channel = $2
-        stop_using_rules(dest, channel, user, dchannel)
-      when /^\s*extend\s+rules\s+(to\s+)<#C\w+\|(.+)>/i, /^extend\s+rules\s+(to\s+)(.+)/i,
-           /^\s*use\s+rules\s+(on\s+)<#C\w+\|(.+)>/i, /^use\s+rules\s+(on\s+)(.+)/i
-        channel = $2
-        extend_rules(dest, user, from, channel, typem)
-      when /^\s*stop using rules (on\s+)<#\w+\|(.+)>/i, /^stop using rules (on\s+)(.+)/i
-        channel = $2
-        stop_using_rules_on(dest, user, from, channel, typem)
-      when /^\s*exit\sbot\s*$/i, /^quit\sbot\s*$/i, /^close\sbot\s*$/i
-        exit_bot(command, from, dest, display_name)
-      when /^\s*start\s(this\s)?bot$/i
-        start_bot(dest, from)
-      when /^\s*pause\s(this\s)?bot$/i
-        pause_bot(dest, from)
-      when /^\s*bot\sstatus/i
-        bot_status(dest, user)
-      when /\Anotify\s+<#(C\w+)\|.+>\s+(.+)\s*\z/im, /\Anotify\s+(all)?\s*(.+)\s*\z/im
-        where = $1
-        message = $2
-        notify_message(dest, from, where, message)
-      when /^\s*create\s+(cloud\s+)?bot\s+on\s+<#C\w+\|(.+)>\s*/i, /^create\s+(cloud\s+)?bot\s+on\s+(.+)\s*/i
-        cloud = !$1.nil?
-        channel = $2
-        create_bot(dest, user, cloud, channel)
-      when /^\s*kill\sbot\son\s<#C\w+\|(.+)>\s*$/i, /^kill\sbot\son\s(.+)\s*$/i
-        channel = $1
-        kill_bot_on_channel(dest, from, channel)
-      when /^\s*(add|create)\s+(silent\s+)?routine\s+(\w+)\s+(every)\s+(\d+)\s*(days|hours|minutes|seconds|mins|min|secs|sec|d|h|m|s)\s*(\s<#(C\w+)\|.+>\s*)?(\s.+)?\s*$/i,
-        /^\s*(add|create)\s+(silent\s+)?routine\s+(\w+)\s+on\s+(monday|tuesday|wednesday|thursday|friday|saturday|sunday)s?\s+at\s+(\d+:\d+:?\d+?)\s*()(\s<#(C\w+)\|.+>\s*)?(\s.+)?\s*$/i,
-        /^\s*(add|create)\s+(silent\s+)?routine\s+(\w+)\s+(at)\s+(\d+:\d+:?\d+?)\s*()(\s<#(C\w+)\|.+>\s*)?(\s.+)?\s*$/i
-        silent = $2.to_s!=''
-        name = $3.downcase
-        type = $4
-        number_time = $5
-        period = $6
-        channel = $8
-        command_to_run = $9
-        add_routine(dest, from, user, name, type, number_time, period, command_to_run, files, silent, channel)
-      when /^\s*(kill|delete|remove)\s+routine\s+(\w+)\s*$/i
-        name = $2.downcase
-        remove_routine(dest, from, name)
-      when /^\s*(run|execute)\s+routine\s+(\w+)\s*$/i
-        name = $2.downcase
-        run_routine(dest, from, name)
-      when /^\s*pause\s+routine\s+(\w+)\s*$/i
-        name = $1.downcase
-        pause_routine(dest, from, name)
-      when /^\s*start\s+routine\s+(\w+)\s*$/i
-        name = $1.downcase
-        start_routine(dest, from, name)
-      when /^\s*see\s+(all\s+)?routines\s*$/i
-        all = $1.to_s != ""
-        see_routines(dest, from, user, all)
-      when /^\s*get\s+bot\s+logs?\s*$/i
-        get_bot_logs(dest, from, typem)
-      when /^\s*bot\s+stats\s*(.*)\s*$/i
-        opts = $1.to_s
-        all_opts = opts.downcase.split(' ')
-        st_channel = opts.scan(/<#(\w+)\|.+>/).join
-        st_from = opts.scan(/from\s+(\d\d\d\d[\/\-\.]\d\d[\/\-\.]\d\d)/).join
-        st_from = st_from.gsub('.','-').gsub('/','-')
-        st_to = opts.scan(/to\s+(\d\d\d\d[\/\-\.]\d\d[\/\-\.]\d\d)/).join
-        st_to = st_to.gsub('.','-').gsub('/','-')
-        st_user = opts.scan(/<@([^>]+)>/).join
-        exclude_masters = opts.match?(/exclude\s+masters?/i)
-        monthly = false
-        if all_opts.include?('today')
-          st_from = st_to = "#{Time.now.strftime("%Y-%m-%d")}"
-        elsif all_opts.include?('monthly')
-          monthly = true
+          bot_help(user, from, dest, dchannel, specific, help_command, rules_file)
+        when /^\s*use\s+(rules\s+)?(from\s+)?<#C\w+\|(.+)>\s*$/i, /^use\s+(rules\s+)?(from\s+)?([^\s]+\s*$)/i
+          channel = $3
+          use_rules(dest, channel, user, dchannel)
+        when /^\s*stop\s+using\s+rules\s+(from\s+)<#\w+\|(.+)>/i, /^stop\s+using\s+rules\s+(from\s+)(.+)/i
+          channel = $2
+          stop_using_rules(dest, channel, user, dchannel)
+        when /^\s*extend\s+rules\s+(to\s+)<#C\w+\|(.+)>/i, /^extend\s+rules\s+(to\s+)(.+)/i,
+            /^\s*use\s+rules\s+(on\s+)<#C\w+\|(.+)>/i, /^use\s+rules\s+(on\s+)(.+)/i
+          channel = $2
+          extend_rules(dest, user, from, channel, typem)
+        when /^\s*stop\s+using\s+rules\s+(on\s+)<#\w+\|(.+)>/i, /^stop\s+using\s+rules\s+(on\s+)(.+)/i
+          channel = $2
+          stop_using_rules_on(dest, user, from, channel, typem)
+        when /^\s*exit\s+bot\s*$/i, /^quit\s+bot\s*$/i, /^close\s+bot\s*$/i
+          exit_bot(command, from, dest, display_name)
+        when /^\s*start\s+(this\s+)?bot$/i
+          start_bot(dest, from)
+        when /^\s*pause\s+(this\s+)?bot$/i
+          pause_bot(dest, from)
+        when /^\s*bot\s+status/i
+          bot_status(dest, user)
+        when /\Anotify\s+<#(C\w+)\|.+>\s+(.+)\s*\z/im, /\Anotify\s+(all)?\s*(.+)\s*\z/im
+          where = $1
+          message = $2
+          notify_message(dest, from, where, message)
+        when /^\s*create\s+(cloud\s+)?bot\s+on\s+<#C\w+\|(.+)>\s*/i, /^create\s+(cloud\s+)?bot\s+on\s+(.+)\s*/i
+          cloud = !$1.nil?
+          channel = $2
+          create_bot(dest, user, cloud, channel)
+        when /^\s*kill\s+bot\s+on\s+<#C\w+\|(.+)>\s*$/i, /^kill\s+bot\s+on\s+(.+)\s*$/i
+          channel = $1
+          kill_bot_on_channel(dest, from, channel)
+        when /^\s*(add|create)\s+(silent\s+)?routine\s+(\w+)\s+(every)\s+(\d+)\s*(days|hours|minutes|seconds|mins|min|secs|sec|d|h|m|s)\s*(\s<#(C\w+)\|.+>\s*)?(\s.+)?\s*$/i,
+          /^\s*(add|create)\s+(silent\s+)?routine\s+(\w+)\s+on\s+(monday|tuesday|wednesday|thursday|friday|saturday|sunday)s?\s+at\s+(\d+:\d+:?\d+?)\s*()(\s<#(C\w+)\|.+>\s*)?(\s.+)?\s*$/i,
+          /^\s*(add|create)\s+(silent\s+)?routine\s+(\w+)\s+(at)\s+(\d+:\d+:?\d+?)\s*()(\s<#(C\w+)\|.+>\s*)?(\s.+)?\s*$/i
+          silent = $2.to_s!=''
+          name = $3.downcase
+          type = $4
+          number_time = $5
+          period = $6
+          channel = $8
+          command_to_run = $9
+          add_routine(dest, from, user, name, type, number_time, period, command_to_run, files, silent, channel)
+        when /^\s*(kill|delete|remove)\s+routine\s+(\w+)\s*$/i
+          name = $2.downcase
+          remove_routine(dest, from, name)
+        when /^\s*(run|execute)\s+routine\s+(\w+)\s*$/i
+          name = $2.downcase
+          run_routine(dest, from, name)
+        when /^\s*pause\s+routine\s+(\w+)\s*$/i
+          name = $1.downcase
+          pause_routine(dest, from, name)
+        when /^\s*start\s+routine\s+(\w+)\s*$/i
+          name = $1.downcase
+          start_routine(dest, from, name)
+        when /^\s*see\s+(all\s+)?routines\s*$/i
+          all = $1.to_s != ""
+          see_routines(dest, from, user, all)
+        when /^\s*get\s+bot\s+logs?\s*$/i
+          get_bot_logs(dest, from, typem)
+        when /^\s*bot\s+stats\s*(.*)\s*$/i
+          opts = $1.to_s
+          all_opts = opts.downcase.split(' ')
+          all_data = all_opts.include?('alldata')
+          st_channel = opts.scan(/<#(\w+)\|.+>/).join
+          st_from = opts.scan(/from\s+(\d\d\d\d[\/\-\.]\d\d[\/\-\.]\d\d)/).join
+          st_from = st_from.gsub('.','-').gsub('/','-')
+          st_to = opts.scan(/to\s+(\d\d\d\d[\/\-\.]\d\d[\/\-\.]\d\d)/).join
+          st_to = st_to.gsub('.','-').gsub('/','-')
+          st_user = opts.scan(/<@([^>]+)>/).join
+          st_command = opts.scan(/\s+command\s+(\w+)/i).join.downcase
+          st_command = opts.scan(/^command\s+(\w+)/i).join.downcase if st_command == ''
+          exclude_masters = all_opts.include?('exclude') && all_opts.include?('masters')
+          exclude_routines = all_opts.include?('exclude') && all_opts.include?('routines')
+          if exclude_masters
+            opts.gsub!(/\s+masters$/,'')
+            opts.gsub!(/\s+masters\s+/,'')
+          end
+          if exclude_routines
+            opts.gsub!(/\s+routines$/,'')
+            opts.gsub!(/\s+routines\s+/,'')
+          end
+          monthly = false
+          if all_opts.include?('today')
+            st_from = st_to = "#{Time.now.strftime("%Y-%m-%d")}"
+          elsif all_opts.include?('monthly')
+            monthly = true
+          end
+          exclude_command = opts.scan(/exclude\s+([^\s]+)/i).join
+          unless @master_admin_users_id.include?(user.id)
+            st_user = user.id
+          end
+          if (typem == :on_master or typem == :on_bot) and dest[0]!='D' #routine bot stats to be published on DM
+            st_channel = dchannel
+          end
+          bot_stats(dest, user, typem, st_channel, st_from, st_to, st_user, st_command, exclude_masters, exclude_routines, exclude_command, monthly, all_data)
+        when /\A(set|turn)\s+maintenance\s+(on|off)\s*()\z/im, /\A(set|turn)\s+maintenance\s+(on)\s*(.+)\s*\z/im
+          status = $2.downcase
+          message = $3.to_s
+          set_maintenance(from, status, message)
+        else
+          processed = false
         end
-        exclude_command = opts.scan(/exclude\s+([^\s]+)/i).join
-        exclude_command = '' if exclude_command == 'masters'
-        bot_stats(dest, from, typem, st_channel, st_from, st_to, st_user, exclude_masters, exclude_command, monthly)
       else
         processed = false
       end
-    else
-      processed = false
-    end
 
-    # only when :on and (listening or on demand or direct message)
-    if @status == :on and
-       (@questions.key?(from) or
-       (@repl_sessions.key?(from) and dest==@repl_sessions[from][:dest] and 
-        ((@repl_sessions[from][:on_thread] and Thread.current[:thread_ts] == @repl_sessions[from][:thread_ts]) or
-         (!@repl_sessions[from][:on_thread] and !Thread.current[:on_thread]))) or 
-         (@listening.key?(from) and typem != :on_extended and 
-         ((@listening[from].key?(dest) and !Thread.current[:on_thread]) or 
-          (@listening[from].key?(Thread.current[:thread_ts]) and Thread.current[:on_thread] ) )) or
-        typem == :on_dm or typem == :on_pg or on_demand)
-      processed2 = true
+      # only when :on and (listening or on demand or direct message)
+      if @status == :on and
+        (!answer.empty? or
+        (@repl_sessions.key?(from) and dest==@repl_sessions[from][:dest] and 
+          ((@repl_sessions[from][:on_thread] and Thread.current[:thread_ts] == @repl_sessions[from][:thread_ts]) or
+          (!@repl_sessions[from][:on_thread] and !Thread.current[:on_thread]))) or 
+          (@listening.key?(from) and typem != :on_extended and 
+          ((@listening[from].key?(dest) and !Thread.current[:on_thread]) or 
+            (@listening[from].key?(Thread.current[:thread_ts]) and Thread.current[:on_thread] ) )) or
+          typem == :on_dm or typem == :on_pg or on_demand)
+        processed2 = true
+    
+        case command
 
-      case command
+        # bot rules for extended channels
+        when /^bot\s+rules\s*(.+)?$/i
+          help_command = $1
+          bot_rules(dest, help_command, typem, rules_file, user)
+        when /^\s*(add\s+)?(global\s+|generic\s+)?shortcut\s+(for\sall)?\s*([^:]+)\s*:\s*(.+)/i, 
+          /^(add\s+)(global\s+|generic\s+)?sc\s+(for\sall)?\s*([^:]+)\s*:\s*(.+)/i
+          for_all = $3
+          shortcut_name = $4.to_s.downcase
+          command_to_run = $5
+          global = $2.to_s != ''
+          add_shortcut(dest, user, typem, for_all, shortcut_name, command, command_to_run, global)
+        when /^\s*(delete|remove)\s+(global\s+|generic\s+)?shortcut\s+(.+)/i, 
+          /^(delete|remove)\s+(global\s+|generic\s+)?sc\s+(.+)/i
+          shortcut = $3.to_s.downcase
+          global = $2.to_s != ''
 
-      # bot rules for extended channels
-      when /^bot\s+rules\s*(.+)?$/i
-        help_command = $1
-        bot_rules(dest, help_command, typem, rules_file, user)
-      when /^\s*(add\s)?shortcut\s(for\sall)?\s*([^:]+)\s*:\s*(.+)/i, /^(add\s)sc\s(for\sall)?\s*([^:]+)\s*:\s*(.+)/i
-        for_all = $2
-        shortcut_name = $3.to_s.downcase
-        command_to_run = $4
-        add_shortcut(dest, user, typem, for_all, shortcut_name, command, command_to_run)
-      when /^\s*(delete|remove)\s+shortcut\s+(.+)/i, /^(delete|remove)\s+sc\s+(.+)/i
-        shortcut = $2.to_s.downcase
-        delete_shortcut(dest, user, shortcut, typem, command)
-      when /^\s*see\sshortcuts/i, /^see\ssc/i
-        see_shortcuts(dest, user, typem)
+          delete_shortcut(dest, user, shortcut, typem, command, global)
+        when /^\s*see\s+shortcuts/i, /^see\ssc/i
+          see_shortcuts(dest, user, typem)
 
-        #kept to be backwards compatible
-      when /^\s*id\schannel\s<#C\w+\|(.+)>\s*/i, /^id channel (.+)/
-        unless typem == :on_extended
-          channel_name = $1
-          get_channels_name_and_id()
-          if @channels_id.keys.include?(channel_name)
-            respond "the id of #{channel_name} is #{@channels_id[channel_name]}", dest
-          else
-            respond "channel: #{channel_name} not found", dest
+          #kept to be backwards compatible
+        when /^\s*id\schannel\s<#C\w+\|(.+)>\s*/i, /^id channel (.+)/
+          unless typem == :on_extended
+            channel_name = $1
+            get_channels_name_and_id()
+            if @channels_id.keys.include?(channel_name)
+              respond "the id of #{channel_name} is #{@channels_id[channel_name]}", dest
+            else
+              respond "channel: #{channel_name} not found", dest
+            end
           end
-        end
-      when /^\s*ruby\s(.+)/im, /^\s*code\s(.+)/im
-        code = $1
-        code.gsub!("\\n", "\n")
-        code.gsub!("\\r", "\r")
-        @logger.info code
-        ruby_code(dest, user, code, rules_file)
-      when /^\s*(private\s+)?(repl|irb|live)\s*()()()$/i, 
-        /^\s*(private\s+)?(repl|irb|live)\s+([\w\-]+)()()\s*$/i,
-        /^\s*(private\s+)?(repl|irb|live)\s+([\w\-]+)\s*:\s+"([^"]+)"()\s*$/i,
-        /^\s*(private\s+)?(repl|irb|live)\s+([\w\-]+)\s*:\s+"([^"]+)"\s+(.+)\s*$/i,
-        /^\s*(private\s+)?(repl|irb|live)\s+([\w\-]+)()\s+(.+)\s*$/i,
-        /^\s*(private\s+)?(repl|irb|live)()\s+()(.+)\s*$/i
-            if $1.to_s!=''
-          type = :private
+        when /^\s*ruby\s(.+)/im, /^\s*code\s(.+)/im
+          code = $1
+          code.gsub!("\\n", "\n")
+          code.gsub!("\\r", "\r")
+          @logger.info code
+          ruby_code(dest, user, code, rules_file)
+        when /^\s*(private\s+|clean\s+|clean\s+private\s+|private\s+clean\s+)?(repl|irb|live)\s*()()()$/i, 
+          /^\s*(private\s+|clean\s+|clean\s+private\s+|private\s+clean\s+)?(repl|irb|live)\s+([\w\-]+)()()\s*$/i,
+          /^\s*(private\s+|clean\s+|clean\s+private\s+|private\s+clean\s+)?(repl|irb|live)\s+([\w\-]+)\s*:\s+"([^"]+)"()\s*$/i,
+          /^\s*(private\s+|clean\s+|clean\s+private\s+|private\s+clean\s+)?(repl|irb|live)\s+([\w\-]+)\s*:\s+"([^"]+)"\s+(.+)\s*$/i,
+          /^\s*(private\s+|clean\s+|clean\s+private\s+|private\s+clean\s+)?(repl|irb|live)\s+([\w\-]+)()\s+(.+)\s*$/i,
+          /^\s*(private\s+|clean\s+|clean\s+private\s+|private\s+clean\s+)?(repl|irb|live)()\s+()(.+)\s*$/i
+          opts_type = $1.to_s.downcase.split(' ')
+          opts_type.include?('private') ? type = :private : type = :public
+          type = "#{type}_clean".to_sym if opts_type.include?('clean')
+          
+          session_name = $3
+          description = $4
+          opts = " #{$5}"
+          env_vars = opts.scan(/\s+[\w\-]+="[^"]+"/i) + opts.scan(/\s+[\w\-]+='[^']+'/i)  
+          opts.scan(/\s+[\w\-]+=[^'"\s]+/i).flatten.each do |ev|
+            env_vars << ev.gsub('=',"='") + "'"
+          end
+          env_vars.each_with_index do |ev, idx|
+              ev.gsub!("=","']=")
+              ev.lstrip!
+              env_vars[idx] = "ENV['#{ev}"
+          end
+          repl(dest, user, session_name, env_vars.flatten, rules_file, command, description, type)
+        when /^\s*get\s+(repl|irb|live)\s+([\w\-]+)\s*/i
+          session_name = $2
+          get_repl(dest, user, session_name)      
+        when /^\s*run\s+(repl|irb|live)\s+([\w\-]+)()\s*$/i,
+          /^\s*run\s+(repl|irb|live)\s+([\w\-]+)\s+(.+)\s*$/i
+          session_name = $2
+          opts = " #{$3}"
+          env_vars = opts.scan(/\s+[\w\-]+="[^"]+"/i) + opts.scan(/\s+[\w\-]+='[^']+'/i)  
+          opts.scan(/\s+[\w\-]+=[^'"\s]+/i).flatten.each do |ev|
+            env_vars << ev.gsub('=',"='") + "'"
+          end
+          env_vars.each_with_index do |ev, idx|
+              ev.gsub!("=","']=")
+              ev.lstrip!
+              env_vars[idx] = "ENV['#{ev}"
+          end
+          run_repl(dest, user, session_name, env_vars.flatten, rules_file)      
+        when /^\s*(delete|remove)\s+(repl|irb|live)\s+([\w\-]+)\s*$/i
+          repl_name = $3
+          delete_repl(dest, user, repl_name)
+        when /^\s*see\s+(repls|repl|irb|irbs)\s*$/i
+          see_repls(dest, user, typem)
         else
-          type = :public
-        end
-        session_name = $3
-        description = $4
-        opts = " #{$5}"
-        env_vars = opts.scan(/\s+[\w\-]+="[^"]+"/i) + opts.scan(/\s+[\w\-]+='[^']+'/i)  
-        opts.scan(/\s+[\w\-]+=[^'"\s]+/i).flatten.each do |ev|
-          env_vars << ev.gsub('=',"='") + "'"
-        end
-        env_vars.each_with_index do |ev, idx|
-            ev.gsub!("=","']=")
-            ev.lstrip!
-            env_vars[idx] = "ENV['#{ev}"
-        end
-        repl(dest, user, session_name, env_vars.flatten, rules_file, command, description, type)
-      when /^\s*get\s+(repl|irb|live)\s+([\w\-]+)\s*/i
-        session_name = $2
-        get_repl(dest, user, session_name)      
-      when /^\s*run\s+(repl|irb|live)\s+([\w\-]+)()\s*$/i,
-        /^\s*run\s+(repl|irb|live)\s+([\w\-]+)\s+(.+)\s*$/i
-        session_name = $2
-        opts = " #{$3}"
-        env_vars = opts.scan(/\s+[\w\-]+="[^"]+"/i) + opts.scan(/\s+[\w\-]+='[^']+'/i)  
-        opts.scan(/\s+[\w\-]+=[^'"\s]+/i).flatten.each do |ev|
-          env_vars << ev.gsub('=',"='") + "'"
-        end
-        env_vars.each_with_index do |ev, idx|
-            ev.gsub!("=","']=")
-            ev.lstrip!
-            env_vars[idx] = "ENV['#{ev}"
-        end
-        run_repl(dest, user, session_name, env_vars.flatten, rules_file)      
-      when /^\s*(delete|remove)\s+(repl|irb|live)\s+([\w\-]+)\s*$/i
-        repl_name = $3
-        delete_repl(dest, user, repl_name)
-      when /^\s*see\s+(repls|repl|irb|irbs)\s*$/i
-        see_repls(dest, user, typem)
-      else
-        processed2 = false
-      end #of case
+          processed2 = false
+        end #of case
 
-      processed = true if processed or processed2
+        processed = true if processed or processed2
+      end
     end
-
     return processed
   end
 end