slack-smart-bot 1.10.0 → 1.12.0

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

@@ -17,7 +17,7 @@ class SlackSmartBot
   # help:     If 'clean' specified the repl won't pre execute the code written on the .smart-bot-repl file
   # help:     To avoid a message to be treated, start the message with '-'.
   # help:     Send _quit_, _bye_ or _exit_ to finish the session.
-  # help:     Send puts, print, p or pp if you want to print out something when using `run repl` later.
+  # help:     Send puts, print, p or pp if you want to print out something when using _run repl_ later.
   # help:     After 30 minutes of no communication with the Smart Bot the session will be dismissed.
   # help:     If you declare on your rules file a method called 'project_folder' returning the path for the project folder, the code will be executed from that folder. 
   # help:     By default it will be automatically loaded the gems: string_pattern, nice_hash and nice_http
@@ -30,6 +30,7 @@ class SlackSmartBot
   # help:       _repl delete_logs_
   # help:       _private repl random-ssn_
   # help:     <https://github.com/MarioRuiz/slack-smart-bot#repl|more info>
+  # help: command_id: :repl
   # help:
   def repl(dest, user, session_name, env_vars, rules_file, command, description, type)
     #todo: add more tests
@@ -78,11 +79,14 @@ class SlackSmartBot
           update_repls()        
         end
         react :running
+        @ts_react ||= {}
         if Thread.current[:ts].to_s == ''
-          @ts_react = Thread.current[:thread_ts]
+          @ts_react[session_name] = Thread.current[:thread_ts]
         else
-          @ts_react = Thread.current[:ts]
+          @ts_react[session_name] = Thread.current[:ts]
         end        
+        @ts_repl ||= {}
+        @ts_repl[session_name] = ''
 
         message = "Session name: *#{session_name}*
         From now on I will execute all you write as a Ruby command and I will keep the session open until you send `quit` or `bye` or `exit`. 
@@ -115,14 +119,15 @@ class SlackSmartBot
         end
 
         process_to_run = '
-            ruby -e "' + env_vars.join("\n") + '
+            ' + env_vars.join("\n") + '
             require \"amazing_print\"
+            require \"stringio\"
             bindme' + serialt + ' = binding
             eval(\"require \'nice_http\'\" , bindme' + serialt + ')
             def ls(obj)
               (obj.methods - Object.methods)
             end
-            
+            file_run_path = \"' +  + File.expand_path(config.path) + '/repl/' + @channel_id + '/' + session_name + '.rb\"
             file_input_repl = File.open(\"' + File.expand_path(config.path) + '/repl/' + @channel_id + '/' + session_name + '.input\", \"r\")
             ' + pre_execute + '
             while true do 
@@ -141,18 +146,40 @@ class SlackSmartBot
                   end
                   error = false
                   begin
-                    resp_repl = eval(code_to_run_repl.gsub(/^\s*(puts|print|p|pp)\s/, \"\"), bindme' + serialt + ')
+                    begin
+                      original_stdout = $stdout
+                      $stdout = StringIO.new 
+                      resp_repl = eval(code_to_run_repl, bindme' + serialt + ')
+                      stdout_repl = $stdout.string
+                    ensure 
+                      $stdout = original_stdout
+                    end
                   rescue Exception => resp_repl
                     error = true
                   end
-                  unless error
+                  if error
+                    open(\"' + File.expand_path(config.path) + '/repl/' + @channel_id + '/' + session_name + '.output\", \"a+\") {|f|
+                      f.puts \"\`\`\`\n#{resp_repl.to_s.gsub(/^.+' + session_name + '\.rb:\d+:/,\"\")}\`\`\`\"
+                    }
+                  else
                     if code_to_run_repl.match?(/^\s*p\s+/i)
+                      resp_repl = stdout_repl unless stdout_repl.to_s == \'\'
+                      if stdout_repl.to_s == \'\'
+                        resp_repl = resp_repl.inspect
+                      else
+                        resp_repl = stdout_repl 
+                      end
                       open(\"' + File.expand_path(config.path) + '/repl/' + @channel_id + '/' + session_name + '.output\", \"a+\") {|f|
-                        f.puts \"\`\`\`\n#{resp_repl.inspect}\n\`\`\`\"
+                        f.puts \"\`\`\`\n#{resp_repl}\`\`\`\"
                       }
                     else
+                      if stdout_repl.to_s == \'\'
+                        resp_repl = resp_repl.ai
+                      else
+                        resp_repl = stdout_repl 
+                      end
                       open(\"' + File.expand_path(config.path) + '/repl/' + @channel_id + '/' + session_name + '.output\", \"a+\") {|f|
-                        f.puts \"\`\`\`\n#{resp_repl.ai}\n\`\`\`\"
+                        f.puts \"\`\`\`\n#{resp_repl}\`\`\`\"
                       }
                     end
                     unless !add_to_run_repl
@@ -163,16 +190,35 @@ class SlackSmartBot
                   end
                 end
               end
-            end"
+            end
         '
         unless rules_file.empty? # to get the project_folder
           begin
             eval(File.new(config.path+rules_file).read) if File.exist?(config.path+rules_file)
           end
         end
-        started = Time.now
-        process_to_run = ("cd #{project_folder} &&" + process_to_run) if defined?(project_folder)
+        process_to_run.gsub!('\"','"')
+        file_run_path = "./tmp/repl/#{@channel_id}/#{session_name}.rb"
+        if defined?(project_folder)
+          Dir.mkdir("#{project_folder}/tmp/") unless Dir.exist?("#{project_folder}/tmp/")
+          Dir.mkdir("#{project_folder}/tmp/repl") unless Dir.exist?("#{project_folder}/tmp/repl")
+          Dir.mkdir("#{project_folder}/tmp/repl/#{@channel_id}/") unless Dir.exist?("#{project_folder}/tmp/repl/#{@channel_id}/")
+          file_run = File.open(file_run_path.gsub('./',"#{project_folder}/"), "w")
+          file_run.write process_to_run
+          file_run.close
+        else
+          Dir.mkdir("./tmp/") unless Dir.exist?("./tmp/")
+          Dir.mkdir("./tmp/repl") unless Dir.exist?("./tmp/repl")
+          Dir.mkdir("./tmp/repl/#{@channel_id}/") unless Dir.exist?("./tmp/repl/#{@channel_id}/")
+          file_run = File.open(file_run_path, "w")
+          file_run.write process_to_run
+          file_run.close
+        end
 
+        process_to_run = "ruby #{file_run_path}"
+
+        started = Time.now
+        process_to_run = ("cd #{project_folder} && " + process_to_run) if defined?(project_folder)
         stdin, stdout, stderr, wait_thr = Open3.popen3(process_to_run)
         timeout = 30 * 60 # 30 minutes
         
@@ -185,7 +231,7 @@ class SlackSmartBot
                   f.puts 'quit'
                 }
                 respond "REPL session finished: #{@repl_sessions[from][:name]}", dest
-                unreact :running, @ts_react
+                unreact :running, @ts_react[@repl_sessions[from].name]
                 pids = `pgrep -P #{@repl_sessions[from][:pid]}`.split("\n").map(&:to_i) #todo: it needs to be adapted for Windows
                 pids.each do |pid|
                   begin
@@ -199,6 +245,10 @@ class SlackSmartBot
             sleep 0.2
             resp_repl = file_output_repl.read
             if resp_repl.to_s!=''
+              if @ts_repl[@repl_sessions[from].name].to_s != ''
+                unreact(:running, @ts_repl[@repl_sessions[from].name]) 
+                @ts_repl[@repl_sessions[from].name] = ''
+              end
               if resp_repl.to_s.lines.count < 60 and resp_repl.to_s.size < 3500
                 respond resp_repl, dest
               else
@@ -211,6 +261,8 @@ class SlackSmartBot
             @logger.fatal excp
           end
         end
+      elsif @repl_sessions.key?(from) and @repl_sessions[from][:command].to_s == ''
+        respond 'You are already in a repl on this SmartBot. You need to quit that one before starting a new one.'
       else
         @repl_sessions[from][:finished] = Time.now
         code = @repl_sessions[from][:command]
@@ -224,7 +276,9 @@ class SlackSmartBot
           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/) or code.include?("Dir.") 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/)
+          code.match?(/\w+:\s*File/) or code.match?(/\w+:\s*Dir/) or 
+          code.match?(/=?\s*(require|load)(\(|\s)/i)
+
           respond "Sorry I cannot run this due security reasons", dest
         else
           @repl_sessions[from][:input]<<code
@@ -234,7 +288,7 @@ class SlackSmartBot
               f.puts code
             }
             respond "REPL session finished: #{@repl_sessions[from][:name]}", dest
-            unreact :running, @ts_react
+            unreact :running, @ts_react[@repl_sessions[from].name]
             pids = `pgrep -P #{@repl_sessions[from][:pid]}`.split("\n").map(&:to_i) #todo: it needs to be adapted for Windows
             pids.each do |pid|
               begin
@@ -246,6 +300,10 @@ class SlackSmartBot
           when /^\s*-/i
             #ommit
           else
+            if @ts_repl[@repl_sessions[from].name].to_s == ''
+              @ts_repl[@repl_sessions[from].name] = Thread.current[:ts]
+              react :running 
+            end
             open("#{config.path}/repl/#{@channel_id}/#{@repl_sessions[from][:name]}.input", 'a+') {|f|
               f.puts code
             }

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

@@ -6,6 +6,7 @@ class SlackSmartBot
   # help:       _code puts (34344/99)*(34+14)_
   # help:       _ruby require 'json'; res=[]; 20.times {res<<rand(100)}; my_json={result: res}; puts my_json.to_json_
   # help:     <https://github.com/MarioRuiz/slack-smart-bot#running-ruby-code-on-a-conversation|more info>
+  # help: command_id: :ruby_code
   # help:
 
   def ruby_code(dest, user, code, rules_file)

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

@@ -2,27 +2,39 @@ class SlackSmartBot
   # help: ----------------------------------------------
   # help: `run repl SESSION_NAME`
   # help: `run repl SESSION_NAME ENV_VAR=VALUE ENV_VAR=VALUE`
+  # help: `run repl SESSION_NAME PARAMS`
   # help: `run live SESSION_NAME`
   # help: `run irb SESSION_NAME`
-  # help:     Will run the repl session specified and return the output. 
+  # help:     Will run the repl session specified and return the output.
   # help:     You can supply the Environmental Variables you need for the Session
+  # help:     PARAMS: Also it is possible to supply code that will be run before the repl code on the same session.
   # help:     It will return only the values that were print out on the repl with puts, print, p or pp
   # help:     Example:
   # help:       _run repl CreateCustomer LOCATION=spain HOST='https://10.30.40.50:8887'_
   # help:     <https://github.com/MarioRuiz/slack-smart-bot#repl|more info>
+  # help: command_id: :run_repl
   # help:
-  def run_repl(dest, user, session_name, env_vars, rules_file)
+  def run_repl(dest, user, session_name, env_vars, prerun, rules_file)
     #todo: add tests
     from = user.name
     if has_access?(__method__, user)
       save_stats(__method__)
       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}")
+      code = prerun.join("\n")
       if File.exist?("#{config.path}/repl/#{@channel_id}/#{session_name}.run")
-        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)
+        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
+           !is_admin?(user.name)
           respond "The REPL with session name: #{session_name} is private", dest
+        elsif !prerun.empty? and (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/) or code.include?("Dir.") 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/) or
+                                  code.match?(/=?\s*(require|load)(\(|\s)/i))
+          respond "Sorry I cannot run this due security reasons", dest
         else
           if @repls.key?(session_name) #not temp
             @repls[session_name][:accessed] = Time.now.to_s
@@ -31,47 +43,124 @@ class SlackSmartBot
             else
               @repls[session_name][:runs_by_others] += 1
             end
-            update_repls()        
+            update_repls()
           end
 
           content = env_vars.join("\n")
           content += "\nrequire 'nice_http'\n"
           unless rules_file.empty? # to get the project_folder
             begin
-              eval(File.new(config.path+rules_file).read) if File.exist?(config.path+rules_file)
+              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") and 
-            ((@repls.key?(session_name) and @repls[session_name][:type] != :private_clean and @repls[session_name][:type] != :public_clean) or !@repls.key?(session_name))
+          if File.exist?("#{project_folder}/.smart-bot-repl") and
+             ((@repls.key?(session_name) and @repls[session_name][:type] != :private_clean and @repls[session_name][:type] != :public_clean) or !@repls.key?(session_name))
             content += File.read("#{project_folder}/.smart-bot-repl")
             content += "\n"
           end
-          content += File.read("#{config.path}/repl/#{@channel_id}/#{session_name}.run").gsub(/^(quit|exit|bye)$/i,'') #todo: remove this gsub, it will never contain it
+          unless prerun.empty?
+            content += prerun.join("\n")
+            content += "\n"
+          end
+          content += File.read("#{config.path}/repl/#{@channel_id}/#{session_name}.run").gsub(/^(quit|exit|bye)$/i, "") #todo: remove this gsub, it will never contain it
           Dir.mkdir("#{project_folder}/tmp") unless Dir.exist?("#{project_folder}/tmp")
           Dir.mkdir("#{project_folder}/tmp/repl") unless Dir.exist?("#{project_folder}/tmp/repl")
-          File.write("#{project_folder}/tmp/repl/#{session_name}.rb", content, mode: "w+")
-          process_to_run = "ruby  ./tmp/repl/#{session_name}.rb"
+          if Thread.current[:on_thread] 
+            # to force stdout.each to be performed every 3 seconds
+            content = "Thread.new do
+              while true do
+                puts ''
+                sleep 3
+              end
+            end
+            #{content}
+            "
+          end
+          random = "5:LN&".gen
+          File.write("#{project_folder}/tmp/repl/#{session_name}_#{user.name}_#{random}.rb", content, mode: "w+")
+          process_to_run = "ruby  ./tmp/repl/#{session_name}_#{user.name}_#{random}.rb"
           process_to_run = ("cd #{project_folder} && #{process_to_run}") if defined?(project_folder)
-          respond "Running REPL #{session_name}"
-          stdout, stderr, status = Open3.capture3(process_to_run)
-          if stderr == ""
-            if stdout == ""
-              respond "*#{session_name}*: Nothing returned."
-            else
-              if stdout.to_s.lines.count < 60 and stdout.to_s.size < 3500
-                respond "*#{session_name}*: #{stdout}"
+          respond "Running REPL #{session_name} (id: #{random})"
+          @run_repls[random] = { user: user.name, name: session_name, pid: '' }
+          react :running
+
+          require "pty"
+          timeout = 60 * 60 * 4 # 4 hours
+
+          started = Time.now
+          results = []
+          begin
+            PTY.spawn(process_to_run) do |stdout, stdin, pid|
+              last_result = -1
+              last_time = Time.now
+              @run_repls[random].pid = pid
+              begin
+                stdout.each do |line|
+                  if (Time.now - started) > timeout
+                    respond "run REPL session finished. Max time reached: #{session_name} (id: #{random})", dest
+                    pids = `pgrep -P #{pid}`.split("\n").map(&:to_i) #todo: it needs to be adapted for Windows
+                    pids.each do |pd|
+                      begin
+                        Process.kill("KILL", pd)
+                      rescue
+                      end
+                    end
+                    break
+                  else
+                    results << line
+                    if Thread.current[:on_thread]
+                      if (Time.now - last_time) > 2
+                        if (results.size - last_result) < 60 and results[(last_result + 1)..-1].join.size < 3500
+                          output = ""
+                          results[(last_result + 1)..-1].each do |li|
+                            if li.match?(/^\s*{.+}\s*$/) or li.match?(/^\s*\[.+\]\s*$/)
+                              output += "```\n#{li}```\n"
+                            else
+                              output += li
+                            end
+                          end
+                          respond output
+                        else
+                          send_file(dest, "", "response.rb", "", "text/plain", "ruby", content: results[(last_result + 1)..-1].join)
+                        end
+                        last_result = results.size - 1
+                        last_time = Time.now
+                      end
+                    end
+                  end
+                end
+              rescue Errno::EIO
+                @logger.warn "run_repl PTY Errno:EIO error"
+              end
+              if results.empty?
+                respond "*#{session_name}* (id: #{random}): Nothing returned."
               else
-                send_file(dest, "", 'response.rb', "", 'text/plain', "ruby", content: stdout)
+                if last_result != (results.size - 1)
+                  if (results.size - last_result) < 60 and results[(last_result + 1)..-1].join.size < 3500
+                    output = ""
+                    results[(last_result + 1)..-1].each do |li|
+                      if li.match?(/^\s*{.+}\s*$/) or li.match?(/^\s*\[.+\]\s*$/)
+                        output += "```\n#{li}```\n"
+                      else
+                        output += li
+                      end
+                    end
+                    if Thread.current[:on_thread]
+                      respond output
+                    else
+                      respond "*#{session_name}* (id: #{random}):\n#{output}"
+                    end
+                  else
+                    send_file(dest, "", "response.rb", "", "text/plain", "ruby", content: results[(last_result + 1)..-1].join)
+                  end
+                end
               end
             end
-          else
-            if (stdout.to_s+stderr.to_s).lines.count < 60
-              respond "*#{session_name}*: #{stdout} #{stderr}"
-            else
-              send_file(dest, "", 'response.rb', "", 'text/plain', "ruby", content: (stdout.to_s+stderr.to_s))
-            end
-
+          rescue PTY::ChildExited
+            @logger.warn "run_repl PTY The child process exited!"
           end
+          @run_repls.delete(random) if @run_repls.key?(random)
+          unreact :running
         end
       else
         respond "The REPL with session name: #{session_name} doesn't exist on this Smart Bot Channel", dest

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

@@ -4,6 +4,7 @@ class SlackSmartBot
   # help: `see irbs`
   # help:     It will display the repls
   # help:     <https://github.com/MarioRuiz/slack-smart-bot#repl|more info>
+  # help: command_id: :see_repls
   # help:
   def see_repls(dest, user, typem)
     #todo: add tests
@@ -12,7 +13,7 @@ class SlackSmartBot
     if has_access?(__method__, user)
       message = ""
       @repls.sort.to_h.each do |session_name, repl|
-        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)
+        if (repl.creator_name == user.name or repl.type == :public or repl.type == :public_clean) or (is_admin?(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

@@ -4,6 +4,7 @@ class SlackSmartBot
   # help: `see sc`
   # help:    It will display the shortcuts stored for the user and for :all
   # help:    <https://github.com/MarioRuiz/slack-smart-bot#shortcuts|more info>
+  # help: command_id: :see_shortcuts
   # help:
   def see_shortcuts(dest, user, typem)
     save_stats(__method__)
@@ -28,7 +29,7 @@ class SlackSmartBot
         end
         msg2 = ''
         if @shortcuts.keys.include?(from) and @shortcuts[from].keys.size > 0
-          new_hash = @shortcuts[from].dup
+          new_hash = @shortcuts[from].deep_copy
           @shortcuts[:all].keys.each { |k| new_hash.delete(k) }
           if new_hash.keys.size > 0
             msg2 = "*Available shortcuts for #{from}:*\n"
@@ -38,7 +39,7 @@ class SlackSmartBot
           end
         end
         if @shortcuts_global.keys.include?(from) and @shortcuts_global[from].keys.size > 0
-          new_hash = @shortcuts_global[from].dup
+          new_hash = @shortcuts_global[from].deep_copy
           @shortcuts_global[:all].keys.each { |k| new_hash.delete(k) }
           if new_hash.keys.size > 0
             msg2 = "*Available shortcuts for #{from}:*\n" if msg2 == ''

data/lib/slack/smart-bot/commands/on_master/admin/kill_bot_on_channel.rb

@@ -4,6 +4,7 @@ class SlackSmartBot
   # helpmaster:    kills the bot on the specified channel
   # helpmaster:    Only works if you are on Master channel and you created that bot or you are an admin user
   # helpmaster:    <https://github.com/MarioRuiz/slack-smart-bot#bot-management|more info>
+  # helpmaster: command_id: :kill_bot_on_channel
   # helpmaster:
   def kill_bot_on_channel(dest, from, channel)
     save_stats(__method__)
@@ -20,15 +21,15 @@ class SlackSmartBot
         respond "There is no channel with that name: #{channel}, please be sure is written exactly the same", dest
       elsif @bots_created.keys.include?(channel_id)
         @bots_created[channel_id] ||= {}
-        if @bots_created[channel_id][:admins].to_s.split(",").include?(from)
+        if @bots_created[channel_id][:admins].to_s.split(",").include?(from) # todo: consider adding is_admin?
           if @bots_created[channel_id][:thread].kind_of?(Thread) and @bots_created[channel_id][:thread].alive?
             @bots_created[channel_id][:thread].kill
           end
           @bots_created.delete(channel_id)
-          update_bots_file()
-          respond "Bot on channel: #{channel}, has been killed and deleted.", dest
           send_msg_channel(channel, "Bot has been killed by #{from}")
-          save_status :off, :killed, "The admin killed SmartBot on *<##{channel_id}|#{@channels_name[channel_id]}>*"
+          respond "Bot on channel: #{channel}, has been killed and deleted.", dest
+          save_status :off, :killed, "The admin killed SmartBot on *##{@channels_name[channel_id]}*"
+          update_bots_file()
         else
           respond "You need to be the creator or an admin of that bot channel", dest
         end

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

@@ -7,11 +7,12 @@ class SlackSmartBot
   # helpadmin:    The bot stops running and also stops all the bots created from this master channel
   # helpadmin:    You can use this command only if you are an admin user and you are on the master channel
   # helpadmin:    <https://github.com/MarioRuiz/slack-smart-bot#bot-management|more info>
+  # helpadmin: command_id: :exit_bot
   # helpadmin:
   def exit_bot(command, from, dest, display_name)
     save_stats(__method__)
     if config.on_master_bot
-      if config.admins.include?(from) #admin user
+      if config.masters.include?(from) #admin user
         if answer.empty?
           ask("are you sure?", command, from, dest)
         else
@@ -22,7 +23,7 @@ class SlackSmartBot
             @bots_created.each { |key, value|
               value[:thread] = ""
               send_msg_channel(key, "Bot has been closed by #{from}")
-              save_status :off, :exited, "The admin closed SmartBot on *<##{key}|#{value.channel_name}>*"
+              save_status :off, :exited, "The admin closed SmartBot on *##{value.channel_name}*"
               sleep 0.5
             }
             update_bots_file()

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

@@ -8,11 +8,12 @@ class SlackSmartBot
   # helpmaster:    It will send a notification message to the specified channel and to its extended channels
   # helpmaster:    Only works if you are on Master channel and you are a master admin user
   # helpmaster:    <https://github.com/MarioRuiz/slack-smart-bot#sending-notifications|more info>
+  # helpmaster: command_id: :notify_message
   # helpmaster:
   def notify_message(dest, from, where, message)
     save_stats(__method__)
     if config.on_master_bot
-      if config.admins.include?(from) #admin user
+      if config.masters.include?(from) #admin user
         if where.nil? #not all and not channel
           @bots_created.each do |k, v|
             respond message, k

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

@@ -2,21 +2,24 @@ class SlackSmartBot
   # helpmaster: ----------------------------------------------
   # helpmaster: `publish announcements`
   # helpmaster:    It will publish on all channels the announcements added by using 'add announcement' command.
+  # helpmaster:    It won't be published if less than 11 messages published on the channel since last time this command was called.
   # helpmaster:    Only works if you are on Master channel and you are a master admin user
   # helpmaster:    The messages stored on a DM won't be published.
   # helpmaster:    This is very convenient to be called from a *Routine* for example every weekday at 09:00.
   # helpmaster:    <https://github.com/MarioRuiz/slack-smart-bot#announcements|more info>
+  # helpmaster: command_id: :publish_announcements
   # helpmaster:
   def publish_announcements(user)
     save_stats(__method__)
     if config.on_master_bot
-      if config.admins.include?(user.name) #admin user
+      if config.masters.include?(user.name) #admin user
         channels = Dir.entries("#{config.path}/announcements/")
         channels.select! {|i| i[/\.csv$/]}
         channels.each do |channel|
           channel.gsub!('.csv','')
-          unless channel[0]== 'D'
-            see_announcements(user, '', channel, true, true)
+          unless channel[0]== 'D' or (@announcements_activity_after.key?(channel) and @announcements_activity_after[channel] <= 10)
+            see_announcements(user, '', channel, false, true)
+            @announcements_activity_after[channel] = 0
             sleep 0.5 # to avoid reach ratelimit
           end
         end

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

@@ -11,11 +11,12 @@ class SlackSmartBot
   # helpmaster:      _set general message `We will be on *maintenance* at *12:00*`_
   # helpmaster:      _set general message `:information_source: Pay attention: We will be on *maintenance* in *#{((Time.new(2021,6,18,13,30,0)-Time.now)/60).to_i} minutes*`_
   # helpmaster:    <https://github.com/MarioRuiz/slack-smart-bot#bot-management|more info>
+  # helpmaster: command_id: :set_general_message
   # helpmaster:
   def set_general_message(from, status, message)
     save_stats(__method__)
     if config.on_master_bot
-      if config.admins.include?(from) #admin user
+      if config.masters.include?(from) #admin user
         if status == 'on'
           config.general_message = message
           respond "General message has been set."

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

@@ -14,11 +14,12 @@ class SlackSmartBot
   # helpmaster:      _set maintenance on We are on maintenance. We'll be available again in #{((Time.new(2021,6,18,13,30,0)-Time.now)/60).to_i} minutes_
   # helpmaster:      _turn maintenance on `We are on *maintenance* until *12:00*`_
   # helpmaster:    <https://github.com/MarioRuiz/slack-smart-bot#bot-management|more info>
+  # helpmaster: command_id: :set_maintenance
   # helpmaster:
   def set_maintenance(from, status, message)
     save_stats(__method__)
     if config.on_master_bot
-      if config.admins.include?(from) #admin user
+      if config.masters.include?(from) #admin user
         if message == ''
           config.on_maintenance_message = "Sorry I'm on maintenance so I cannot attend your request."
         else

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

@@ -9,6 +9,7 @@ class SlackSmartBot
   # helpmaster:    Follow the instructions in case creating cloud bots
   # helpmaster:    In case 'silent' won't display the Bot initialization message on the CHANNEL_NAME
   # helpmaster:    <https://github.com/MarioRuiz/slack-smart-bot#bot-management|more info>
+  # helpmaster: command_id: :create_bot
   # helpmaster:
   def create_bot(dest, user, type, channel)
     cloud = type.include?('cloud')

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

@@ -0,0 +1,41 @@
+class SlackSmartBot
+  # helpmaster: ----------------------------------------------
+  # helpmaster: `where is smartbot?`
+  # helpmaster: `which channels smartbot?`
+  # helpmaster: `where is a member smartbot?`
+  # helpmaster:    It will list all channels where the smartbot is a member.
+  # helpmaster: command_id: :where_smartbot
+  # helpmaster:
+  def where_smartbot(user)
+    #todo: add tests
+    save_stats(__method__)
+    if has_access?(__method__, user)
+      channels = get_channels(bot_is_in: true)
+      message = []
+      extended = @bots_created.values.extended.flatten
+      channels.each do |c|
+        type = ''
+        unless c.id[0] == "D"
+            if @bots_created.key?(c.id)
+                type = '_`(SmartBot)`_'
+            elsif c.id == @master_bot_id
+                type = '_`(Master)`_'
+            elsif extended.include?(c.name)
+                @bots_created.each do |bot,values|
+                    if values.extended.include?(c.name)
+                        type += "_`(Extended from ##{values.channel_name})`_ "
+                    end
+                end
+            end
+          if c.is_private?
+            message << "#{c.id}: *##{c.name}* #{type}"
+          else
+            message << "#{c.id}: *<##{c.id}>* #{type}"
+          end
+        end
+      end
+      message.sort!
+      respond "*<@#{config.nick_id}> is a member of:*\n\n#{message.join("\n")}"
+    end
+  end
+end