slack-smart-bot 1.14.2 → 1.15.0

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

@@ -1,6 +1,7 @@
 class SlackSmartBot
   def process(user, command, dest, dchannel, rules_file, typem, files, ts)
     from = user.name
+    team_id_user = user.team_id + "_" + user.name
     if config.simulate
       display_name = user.profile.display_name
     else
@@ -9,7 +10,7 @@ class SlackSmartBot
       end
       display_name = user.profile.display_name
     end
-    
+
     processed = true
 
     on_demand = false
@@ -28,7 +29,7 @@ class SlackSmartBot
         on_demand = true
     end
     if (on_demand or typem == :on_dm or
-      (@listening.key?(from) and (@listening[from].key?(dest) or @listening[from].key?(Thread.current[:thread_ts])) )) and 
+      (@listening.key?(team_id_user) and (@listening[team_id_user].key?(dest) or @listening[team_id_user].key?(Thread.current[:thread_ts])) )) and
       config.on_maintenance and !command.match?(/\A(set|turn)\s+maintenance\s+off\s*\z/)
       unless Thread.current.key?(:routine) and Thread.current[:routine]
         respond eval("\"" + config.on_maintenance_message + "\"")
@@ -37,82 +38,88 @@ class SlackSmartBot
     end
     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 or 
+      if typem == :on_master or typem == :on_bot or typem == :on_pg or typem == :on_dm or
         (command.match?(/\A\s*bot\s+stats\s*(.*)\s*$/i) and dest==@channels_id[config.stats_channel])
-    
+
         case command
 
         when /\A\s*what's\s+new\s*$/i
           whats_new(user, dest, dchannel, from, display_name)
-        when /\A\s*(#{@salutations.join("|")})\s+(rules|help)\s*(.+)?$/i, /\A(#{@salutations.join("|")}),? what can I do/i
-          $2.to_s.match?(/rules/i) ? specific = true : specific = false
-          help_command = $3
-          bot_help(user, from, dest, dchannel, specific, help_command, rules_file)
+        when /\A(<)?\s*(#{@salutations.join("|")})\s+(rules|help)\s*(.+)?$/i,
+          /\A(<)?\s*(#{@salutations.join("|")})()(),? what can I do/i
+          $1.to_s=='' ? send_to_file = false : send_to_file = true
+          $3.to_s.match?(/rules/i) ? specific = true : specific = false
+          help_command = $4
+          react :runner
+          bot_help(user, from, dest, dchannel, specific, help_command, rules_file, send_to_file: send_to_file)
+          unreact :runner
         when /\A\s*(suggest|random)\s+(command|rule)\s*\z/i, /\A\s*(command|rule)\s+suggestion\s*\z/i
           $2.to_s.match?(/rule/i) || $1.to_s.match?(/rule/i) ? specific = true : specific = false
-          suggest_command(from, dest, dchannel, specific, rules_file)
-        when /\A\s*use\s+(rules\s+)?(from\s+)?<#C\w+\|(.+)>\s*$/i, 
-          /\A\s*use\s+(rules\s+)?(from\s+)?<#(\w+)\|>\s*$/i, 
+          suggest_command(user, dest, dchannel, specific, rules_file)
+        when /\A\s*use\s+(rules\s+)?(from\s+)?<#C\w+\|(.+)>\s*$/i,
+          /\A\s*use\s+(rules\s+)?(from\s+)?<#(\w+)\|>\s*$/i,
           /\Ause\s+(rules\s+)?(from\s+)?([^\s]+\s*$)/i
           channel = $3
           use_rules(dest, channel, user, dchannel)
-        when /\A\s*stop\s+using\s+rules\s+(on\s+)<#\w+\|(.+)>/i, 
-          /\A\s*stop\s+using\s+rules\s+(on\s+)<#(\w+)\|>/i, 
+        when /\A\s*stop\s+using\s+rules\s+(on\s+)<#\w+\|(.+)>/i,
+          /\A\s*stop\s+using\s+rules\s+(on\s+)<#(\w+)\|>/i,
           /\A\s*stop\s+using\s+rules\s+(on\s+)(.+)\s*$/i
           channel = $2
           stop_using_rules_on(dest, user, from, channel, typem)
-        when /\A\s*stop\s+using\s+rules\s*$()()/i, 
-          /\A\s*stop\s+using\s+(rules\s+from\s+)?<#\w+\|(.+)>/i, 
-          /\A\s*stop\s+using\s+(rules\s+from\s+)?<#(\w+)\|>/i, 
+        when /\A\s*stop\s+using\s+rules\s*$()()/i,
+          /\A\s*stop\s+using\s+(rules\s+from\s+)?<#\w+\|(.+)>/i,
+          /\A\s*stop\s+using\s+(rules\s+from\s+)?<#(\w+)\|>/i,
           /\A\s*stop\s+using\s+(rules\s+from\s+)?(.+)\s*$/i
           channel = $2
           channel = @channel_id if channel.to_s == ''
           stop_using_rules(dest, channel, user, dchannel)
-        when /\A\s*extend\s+rules\s+(to\s+)<#C\w+\|(.+)>/i, /\A\s*extend\s+rules\s+(to\s+)<#(\w+)\|>/i, 
+        when /\A\s*extend\s+rules\s+(to\s+)<#C\w+\|(.+)>/i, /\A\s*extend\s+rules\s+(to\s+)<#(\w+)\|>/i,
             /\A\s*extend\s+rules\s+(to\s+)(.+)/i,
-            /\A\s*use\s+rules\s+(on\s+)<#C\w+\|(.+)>/i, /\A\s*use\s+rules\s+(on\s+)<#(\w+)\|>/i, 
+            /\A\s*use\s+rules\s+(on\s+)<#C\w+\|(.+)>/i, /\A\s*use\s+rules\s+(on\s+)<#(\w+)\|>/i,
             /\A\s*use\s+rules\s+(on\s+)(.+)/i
           channel = $2
           extend_rules(dest, user, from, channel, typem)
         when /\A\s*exit\s+bot(\s+silent)?\s*$/i, /\A\s*quit\s+bot(\s+silent)?\s*$/i, /\A\s*close\s+bot(\s+silent)?\s*$/i
           silent = $1.to_s != ''
-          exit_bot(command, from, dest, display_name, silent: silent)
+          exit_bot(command, user, dest, display_name, silent: silent)
         when /\A\s*start\s+(this\s+)?bot$/i
           start_bot(dest, from)
         when /\A\s*pause\s+(this\s+)?bot$/i
           pause_bot(dest, from)
         when /\A\s*bot\s+status/i
           bot_status(dest, user)
-        when /\Anotify\s+<#(C\w+)\|.+>\s+(.+)\s*\z/im, 
-          /\Anotify\s+<#(\w+)\|>\s+(.+)\s*\z/im, 
+        when /\Anotify\s+<#(C\w+)\|.+>\s+(.+)\s*\z/im,
+          /\Anotify\s+<#(\w+)\|>\s+(.+)\s*\z/im,
           /\Anotify\s+(all)?\s*(.+)\s*\z/im
           where = $1
           message = $2
-          notify_message(dest, from, where, message)
+          notify_message(dest, user, where, message)
         when /\Apublish\s+announcements\s*\z/i
           publish_announcements(user)
-        when /\A\s*create\s+(cloud\s+|silent\s+)?bot\s+on\s+<#C\w+\|(.+)>\s*/i, 
-          /\A\s*create\s+(cloud\s+|silent\s+)?bot\s+on\s+<#(\w+)\|>\s*/i, 
-          /\Acreate\s+(cloud\s+|silent\s+)?bot\s+on\s+#(.+)\s*/i, 
+        when /\A\s*create\s+(cloud\s+|silent\s+)?bot\s+on\s+<#C\w+\|(.+)>\s*/i,
+          /\A\s*create\s+(cloud\s+|silent\s+)?bot\s+on\s+<#(\w+)\|>\s*/i,
+          /\Acreate\s+(cloud\s+|silent\s+)?bot\s+on\s+#(.+)\s*/i,
           /\Acreate\s+(cloud\s+|silent\s+)?bot\s+on\s+(.+)\s*/i
           type = $1.to_s.downcase
           channel = $2
+          react :runner
           create_bot(dest, user, type, channel)
-        when /\A\s*kill\s+bot\s+on\s+<#C\w+\|(.+)>\s*$/i, 
-          /\A\s*kill\s+bot\s+on\s+<#(\w+)\|>\s*$/i, 
+          unreact :runner
+        when /\A\s*kill\s+bot\s+on\s+<#C\w+\|(.+)>\s*$/i,
+          /\A\s*kill\s+bot\s+on\s+<#(\w+)\|>\s*$/i,
           /\Akill\s+bot\s+on\s+#(.+)\s*$/i, /\Akill\s+bot\s+on\s+(.+)\s*$/i
           channel = $1
           kill_bot_on_channel(dest, from, channel)
         when /\A\s*(where\s+is|which\s+channels|where\s+is\s+a\s+member)\s+(#{@salutations.join("|")})\??\s*$/i
           where_smartbot(user)
         when /\A\s*(add|create)\s+(silent\s+)?(bgroutine|routine)\s+([\w\.]+)\s+(every)\s+(\d+)\s*(days|hours|minutes|seconds|mins|min|secs|sec|d|h|m|s)\s*(\s#(\w+)\s*)(\s.+)?\s*\z/im,
-          /\A\s*(add|create)\s+(silent\s+)?(bgroutine|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*\z/im,
+          /\A\s*(add|create)\s+(silent\s+)?(bgroutine|routine)\s+([\w\.]+)\s+(every)\s+(\d+)\s*(days|hours|minutes|seconds|mins|min|secs|sec|d|h|m|s)\s*(\s<#([CG]\w+)\|[^>]*>\s*)?(\s.+)?\s*\z/im,
           /\A\s*(add|create)\s+(silent\s+)?(bgroutine|routine)\s+([\w\.]+)\s+on\s+(monday|tuesday|wednesday|thursday|friday|saturday|sunday|weekend|weekday)s?\s+at\s+(\d+:\d+:?\d+?)\s*()(\s#(\w+)\s*)(\s.+)?\s*\z/im,
-          /\A\s*(add|create)\s+(silent\s+)?(bgroutine|routine)\s+([\w\.]+)\s+on\s+(monday|tuesday|wednesday|thursday|friday|saturday|sunday|weekend|weekday)s?\s+at\s+(\d+:\d+:?\d+?)\s*()(\s<#(C\w+)\|.*>\s*)?(\s.+)?\s*\z/im,
+          /\A\s*(add|create)\s+(silent\s+)?(bgroutine|routine)\s+([\w\.]+)\s+on\s+(monday|tuesday|wednesday|thursday|friday|saturday|sunday|weekend|weekday)s?\s+at\s+(\d+:\d+:?\d+?)\s*()(\s<#([CG]\w+)\|[^>]*>\s*)?(\s.+)?\s*\z/im,
           /\A\s*(add|create)\s+(silent\s+)?(bgroutine|routine)\s+([\w\.]+)\s+on\s+the\s+(\d+)[^\s]*\s+at\s+(\d+:\d+:?\d+?)\s*()(\s#(\w+)\s*)(\s.+)?\s*\z/im,
-          /\A\s*(add|create)\s+(silent\s+)?(bgroutine|routine)\s+([\w\.]+)\s+on\s+the\s+(\d+)[^\s]*\s+at\s+(\d+:\d+:?\d+?)\s*()(\s<#(C\w+)\|.*>\s*)?(\s.+)?\s*\z/im,
+          /\A\s*(add|create)\s+(silent\s+)?(bgroutine|routine)\s+([\w\.]+)\s+on\s+the\s+(\d+)[^\s]*\s+at\s+(\d+:\d+:?\d+?)\s*()(\s<#([CG]\w+)\|[^>]*>\s*)?(\s.+)?\s*\z/im,
           /\A\s*(add|create)\s+(silent\s+)?(bgroutine|routine)\s+([\w\.]+)\s+(at)\s+(\d+:\d+:?\d+?)\s*()(\s#(\w+)\s*)(\s.+)?\s*\z/im,
-          /\A\s*(add|create)\s+(silent\s+)?(bgroutine|routine)\s+([\w\.]+)\s+(at)\s+(\d+:\d+:?\d+?)\s*()(\s<#(C\w+)\|.*>\s*)?(\s.+)?\s*\z/im
+          /\A\s*(add|create)\s+(silent\s+)?(bgroutine|routine)\s+([\w\.]+)\s+(at)\s+(\d+:\d+:?\d+?)\s*()(\s<#([GC]\w+)\|[^>]*>\s*)?(\s.+)?\s*\z/im
           silent = $2.to_s!=''
           routine_type = $3.downcase
           name = $4.downcase
@@ -156,7 +163,7 @@ class SlackSmartBot
           regexp = $3.to_s
           see_routines(dest, from, user, all, header, regexp)
         when /\A\s*get\s+bot\s+logs?\s*$/i
-          get_bot_logs(dest, from, typem)
+          get_bot_logs(dest, user, typem)
         when /\A\s*send\s+message\s+(on|to|in)\s+<(https?:[^:]+)>\s*:\s*(.+)\s*$/im,
           /\A\s*send\s+message\s+(on|to|in)\s+(https?:[^:]+)\s*:\s*(.+)\s*$/im,
           /\A\s*send\s+message\s+(on|to|in)\s*([^:]+)\s*:\s*(.+)\s*$/im
@@ -166,7 +173,7 @@ class SlackSmartBot
           to_channel = ''
           to = []
           stats_from = ''
-          stats_to = ''          
+          stats_to = ''
           stats_channel_filter = ''
           stats_command_filter = ''
 
@@ -198,16 +205,16 @@ class SlackSmartBot
               stats_command_filter = opt
             end
           end
-                    
+
           thread_ts.gsub!('.','')
-          send_message(dest, from, typem, to, thread_ts, stats_from, stats_to, stats_channel_filter, stats_command_filter, message)
+          send_message(dest, user, typem, to, thread_ts, stats_from, stats_to, stats_channel_filter, stats_command_filter, message)
         when /\A\s*delete\s+message\s+(http.+)\s*$/i
           url = $1
-          delete_message(from, typem, url)
+          delete_message(user, typem, url)
         when /\A\s*update\s+message\s+(http[^\s]+)\s+(.+)\s*\z/mi
           url = $1
           text = Thread.current[:command_orig].scan(/\A\s*update\s+message\s+<?http[^\s]+\s+(.+)\s*\z/mi).join
-          update_message(from, typem, url, text)
+          update_message(user, typem, url, text)
         when /\A\s*react\s+(on|to|in)\s*([^\s]+)\s+([p\d\.]+)\s+(.+)\s*$/i,
           /\A\s*react\s+(on|to|in)\s*([^\s]+)\s+()(.+)\s*$/i
           to = $2
@@ -227,7 +234,7 @@ class SlackSmartBot
             respond "The channel specified doesn't exist or is in a incorrect format"
           else
             to = to_channel
-            react_to(dest, from, typem, to, thread_ts, emojis)
+            react_to(dest, user, typem, to, thread_ts, emojis)
           end
 
         when /\A\s*(leader\s+board|leaderboard|ranking|podium)()()\s*$/i,
@@ -348,7 +355,7 @@ class SlackSmartBot
           end
           if this_month
             st_from = "#{Date.today.strftime("%Y-%m-01")}"
-            st_to = "#{Date.today.strftime("%Y-%m-%d")}"          
+            st_to = "#{Date.today.strftime("%Y-%m-%d")}"
           elsif last_month
             date = Date.today<<1
             st_from = "#{date.strftime("%Y-%m-01")}"
@@ -394,12 +401,12 @@ class SlackSmartBot
         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)
+          set_maintenance(user, status, message)
         when /\A(set|turn)\s+(general|generic)\s+message\s+(off)\s*()\z/im, /\A(set|turn)\s+(general|generic)\s+message\s+(on\s+)?\s*(.+)\s*\z/im
           status = $3.to_s.downcase
           status = 'on' if status == ''
           message = $4.to_s
-          set_general_message(from, status, message)
+          set_general_message(user, status, message)
         else
           processed = false
         end
@@ -410,25 +417,25 @@ class SlackSmartBot
       # 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
+        (@repl_sessions.key?(team_id_user) and dest==@repl_sessions[team_id_user][:dest] and
+          ((@repl_sessions[team_id_user][:on_thread] and Thread.current[:thread_ts] == @repl_sessions[team_id_user][:thread_ts]) or
+          (!@repl_sessions[team_id_user][:on_thread] and !Thread.current[:on_thread]))) or
+          (@listening.key?(team_id_user) and typem != :on_extended and
+          ((@listening[team_id_user].key?(dest) and !Thread.current[:on_thread]) or
+            (@listening[team_id_user].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
 
-        when /\A\s*(add\s+)?(global\s+|generic\s+)?shortcut\s+(for\sall)?\s*([^:]+)\s*:\s*(.+)/i, 
+        when /\A\s*(add\s+)?(global\s+|generic\s+)?shortcut\s+(for\sall)?\s*([^:]+)\s*:\s*(.+)/i,
           /\A(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 /\A\s*(delete|remove)\s+(global\s+|generic\s+)?shortcut\s+(.+)/i, 
+        when /\A\s*(delete|remove)\s+(global\s+|generic\s+)?shortcut\s+(.+)/i,
           /\A(delete|remove)\s+(global\s+|generic\s+)?sc\s+(.+)/i
           shortcut = $3.to_s.downcase
           global = $2.to_s != ''
@@ -456,7 +463,7 @@ class SlackSmartBot
           code.gsub!(/```\s*$/,'')
           @logger.info code
           ruby_code(dest, user, code, rules_file)
-        when /\A\s*(private\s+|clean\s+|clean\s+private\s+|private\s+clean\s+)?(repl|irb|live)\s*()()()\z/i, 
+        when /\A\s*(private\s+|clean\s+|clean\s+private\s+|private\s+clean\s+)?(repl|irb|live)\s*()()()\z/i,
           /\A\s*(private\s+|clean\s+|clean\s+private\s+|private\s+clean\s+)?(repl|irb|live)\s+([\w\-]+)()()\s*\z/i,
           /\A\s*(private\s+|clean\s+|clean\s+private\s+|private\s+clean\s+)?(repl|irb|live)\s+([\w\-]+)\s*:\s+"([^"]+)"()\s*\z/i,
           /\A\s*(private\s+|clean\s+|clean\s+private\s+|private\s+clean\s+)?(repl|irb|live)\s+([\w\-]+)\s*:\s+"([^"]+)"\s+(.+)\s*\z/i,
@@ -465,11 +472,11 @@ class SlackSmartBot
           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)  
+          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
@@ -481,7 +488,7 @@ class SlackSmartBot
           repl(dest, user, session_name, env_vars.flatten, rules_file, command, description, type)
         when /\A\s*get\s+(repl|irb|live)\s+([\w\-]+)\s*/i
           session_name = $2
-          get_repl(dest, user, session_name)      
+          get_repl(dest, user, session_name)
         when /\A\s*run\s+(repl|irb|live)\s+([\w\-]+)()\s*\z/im,
           /^\s*run\s+(repl|irb|live)\s+([\w\-]+)\s+(.+)\s*$/im
           session_name = $2
@@ -500,7 +507,7 @@ class SlackSmartBot
               env_vars[idx] = "ENV['#{ev}"
           end
           prerun = Thread.current[:command_orig].gsub('```', '`').scan(/\s+`(.+)`/m)
-          run_repl(dest, user, session_name, env_vars.flatten, prerun.flatten, rules_file)      
+          run_repl(dest, user, session_name, env_vars.flatten, prerun.flatten, rules_file)
         when /\A\s*(delete|remove)\s+(repl|irb|live)\s+([\w\-]+)\s*$/i
           repl_name = $3
           delete_repl(dest, user, repl_name)

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

@@ -1,12 +1,16 @@
 class SlackSmartBot
   def process_first(user, text, dest, dchannel, typem, files, ts, thread_ts, routine, routine_name, routine_type, command_orig)
     nick = user.name
+    team_id_user = user.team_id + "_" + nick
+    user.team_id_user = team_id_user
     rules_file = ""
+    Thread.current[:user] = user
+    Thread.current[:team_id_user] = team_id_user
     if text.match(/\A\s*(stop|quit|exit|kill)\s+(iterator|iteration|loop)\s+(\d+)\s*\z/i)
       save_stats :quit_loop, forced: true, data: {dest: dest, typem: typem, user: user, files: false, command: text, routine: routine}
       num_iteration = $3.to_i
-      if config.admins.include?(user.name) or @loops.key?(user.name)
-        if config.admins.include?(user.name)
+      if config.team_id_admins.include?(team_id_user) or @loops.key?(team_id_user)
+        if config.team_id_admins.include?(team_id_user)
           name_loop = ''
           @loops.each do |k,v|
             if v.include?(num_iteration)
@@ -15,7 +19,7 @@ class SlackSmartBot
             end
           end
         else
-          name_loop = user.name
+          name_loop = team_id_user
         end
         if @loops.key?(name_loop) and @loops[name_loop].include?(num_iteration)
           @loops[name_loop].delete(num_iteration)
@@ -35,7 +39,7 @@ class SlackSmartBot
         text = "********" if !found
         text+= " (encrypted #{Thread.current[:command_id]})"
       end
-      @logger.info "command: #{nick}> #{text}"
+      @logger.info "command: #{user.team_id}/#{nick}> #{text}"
       return :next #jal
     end
     if text.match(/\A\s*!*^?\s*(for\s*)?(\d+)\s+times\s+every\s+(\d+)\s*(m|minute|minutes|s|sc|second|seconds)\s+(.+)\s*\z/i)
@@ -52,11 +56,11 @@ class SlackSmartBot
         respond "You can't do that. Maximum times is 24, minimum every is 10 seconds, maximum every is 60 minutes.", dest, thread_ts: thread_ts
         return :next #jal
       end
-      @loops[user.name] ||= []
+      @loops[team_id_user] ||= []
       @num_loops ||= 0
       @num_loops += 1
       loop_id = @num_loops
-      @loops[user.name] << loop_id
+      @loops[team_id_user] << loop_id
       respond "Loop #{loop_id} started. To stop the loop use: `#{['stop','quit','exit', 'kill'].sample} #{['iteration','iterator','loop'].sample} #{loop_id}`", dest, thread_ts: thread_ts
       #todo: command_orig should be reasigned maybe to remove for N times every X seconds. Check.
     else
@@ -89,22 +93,22 @@ class SlackSmartBot
     elsif dest[0] == "C" or dest[0] == "G" # on a channel or private channel
       rules_file = config.rules_file
 
-      if @rules_imported.key?(user.name) and @rules_imported[user.name].key?(dchannel)
-        unless @bots_created.key?(@rules_imported[user.name][dchannel])
+      if @rules_imported.key?(team_id_user) and @rules_imported[team_id_user].key?(dchannel)
+        unless @bots_created.key?(@rules_imported[team_id_user][dchannel])
           get_bots_created()
         end
-        if @bots_created.key?(@rules_imported[user.name][dchannel])
-          rules_file = @bots_created[@rules_imported[user.name][dchannel]][:rules_file]
+        if @bots_created.key?(@rules_imported[team_id_user][dchannel])
+          rules_file = @bots_created[@rules_imported[team_id_user][dchannel]][:rules_file]
         end
       end
-    elsif dest[0] == "D" and @rules_imported.key?(user.name) and @rules_imported[user.name].key?(user.name) #direct message
-      unless @bots_created.key?(@rules_imported[user.name][user.name])
+    elsif dest[0] == "D" and @rules_imported.key?(team_id_user) and @rules_imported[team_id_user].key?(user.name) #direct message
+      unless @bots_created.key?(@rules_imported[team_id_user][user.name])
         get_bots_created()
       end
-      if @bots_created.key?(@rules_imported[user.name][user.name])
-        rules_file = @bots_created[@rules_imported[user.name][user.name]][:rules_file]
+      if @bots_created.key?(@rules_imported[team_id_user][user.name])
+        rules_file = @bots_created[@rules_imported[team_id_user][user.name]][:rules_file]
       end
-    elsif dest[0] == "D" and (!@rules_imported.key?(user.name) or (@rules_imported.key?(user.name) and !@rules_imported[user.name].key?(user.name)))
+    elsif dest[0] == "D" and (!@rules_imported.key?(team_id_user) or (@rules_imported.key?(team_id_user) and !@rules_imported[team_id_user].key?(user.name)))
       if File.exist?("#{config.path}/rules/general_rules.rb")
         rules_file = "/rules/general_rules.rb"
       end
@@ -146,7 +150,8 @@ class SlackSmartBot
         when /removed the access to the rules of (.+) from (.+)\.$/i
           from_name = $1
           to_name = $2
-          if config.on_master_bot and @bots_created[@channels_id[from_name]][:cloud]
+          if config.on_master_bot and @bots_created.key?(@channels_id[from_name]) and
+            @bots_created[@channels_id[from_name]][:cloud]
             @bots_created[@channels_id[from_name]][:extended].delete(to_name)
             update_bots_file()
           end
@@ -191,24 +196,24 @@ class SlackSmartBot
     if command.include?("$") #for adding shortcuts inside commands
       command.scan(/\$([^\$]+)/i).flatten.each do |sc|
         sc.strip!
-        if @shortcuts.key?(nick) and @shortcuts[nick].keys.include?(sc)
-          command.gsub!("$#{sc}", @shortcuts[nick][sc])
+        if @shortcuts.key?(team_id_user) and @shortcuts[team_id_user].keys.include?(sc)
+          command.gsub!("$#{sc}", @shortcuts[team_id_user][sc])
         elsif @shortcuts.key?(:all) and @shortcuts[:all].keys.include?(sc)
           command.gsub!("$#{sc}", @shortcuts[:all][sc])
-        elsif @shortcuts_global.key?(nick) and @shortcuts_global[nick].keys.include?(sc)
-          command.gsub!("$#{sc}", @shortcuts_global[nick][sc])
+        elsif @shortcuts_global.key?(team_id_user) and @shortcuts_global[team_id_user].keys.include?(sc)
+          command.gsub!("$#{sc}", @shortcuts_global[team_id_user][sc])
         elsif @shortcuts_global.key?(:all) and @shortcuts_global[:all].keys.include?(sc)
           command.gsub!("$#{sc}", @shortcuts_global[:all][sc])
         end
       end
       command.scan(/\$([^\s]+)/i).flatten.each do |sc|
         sc.strip!
-        if @shortcuts.key?(nick) and @shortcuts[nick].keys.include?(sc)
-          command.gsub!("$#{sc}", @shortcuts[nick][sc])
+        if @shortcuts.key?(team_id_user) and @shortcuts[team_id_user].keys.include?(sc)
+          command.gsub!("$#{sc}", @shortcuts[team_id_user][sc])
         elsif @shortcuts.key?(:all) and @shortcuts[:all].keys.include?(sc)
           command.gsub!("$#{sc}", @shortcuts[:all][sc])
-        elsif @shortcuts_global.key?(nick) and @shortcuts_global[nick].keys.include?(sc)
-          command.gsub!("$#{sc}", @shortcuts_global[nick][sc])
+        elsif @shortcuts_global.key?(team_id_user) and @shortcuts_global[team_id_user].keys.include?(sc)
+          command.gsub!("$#{sc}", @shortcuts_global[team_id_user][sc])
         elsif @shortcuts_global.key?(:all) and @shortcuts_global[:all].keys.include?(sc)
           command.gsub!("$#{sc}", @shortcuts_global[:all][sc])
         end
@@ -219,16 +224,16 @@ class SlackSmartBot
     end
     if command.scan(/^(shortcut|sc)\s+([^:]+)\s*$/i).any? or
        (@shortcuts.keys.include?(:all) and @shortcuts[:all].keys.include?(command)) or
-       (@shortcuts.keys.include?(nick) and @shortcuts[nick].keys.include?(command)) or
+       (@shortcuts.keys.include?(team_id_user) and @shortcuts[team_id_user].keys.include?(command)) or
        (@shortcuts_global.keys.include?(:all) and @shortcuts_global[:all].keys.include?(command)) or
-       (@shortcuts_global.keys.include?(nick) and @shortcuts_global[nick].keys.include?(command))
+       (@shortcuts_global.keys.include?(team_id_user) and @shortcuts_global[team_id_user].keys.include?(command))
       command = $2.downcase unless $2.nil?
-      if @shortcuts.keys.include?(nick) and @shortcuts[nick].keys.include?(command)
-        text = @shortcuts[nick][command].dup
+      if @shortcuts.keys.include?(team_id_user) and @shortcuts[team_id_user].keys.include?(command)
+        text = @shortcuts[team_id_user][command].dup
       elsif @shortcuts.keys.include?(:all) and @shortcuts[:all].keys.include?(command)
         text = @shortcuts[:all][command].dup
-      elsif @shortcuts_global.keys.include?(nick) and @shortcuts_global[nick].keys.include?(command)
-        text = @shortcuts_global[nick][command].dup
+      elsif @shortcuts_global.keys.include?(team_id_user) and @shortcuts_global[team_id_user].keys.include?(command)
+        text = @shortcuts_global[team_id_user][command].dup
       elsif @shortcuts_global.keys.include?(:all) and @shortcuts_global[:all].keys.include?(command)
         text = @shortcuts_global[:all][command].dup
       else
@@ -247,13 +252,24 @@ class SlackSmartBot
         t = Thread.new do
           begin
             sleep every_seconds * i if every_seconds > 0
-            Thread.exit if command_every!='' and @loops.key?(user.name) and !@loops[user.name].include?(loop_id)
+            Thread.exit if command_every!='' and @loops.key?(team_id_user) and !@loops[team_id_user].include?(loop_id)
             @logger.info "i: #{i}, num_times: #{num_times}, every_seconds: #{every_seconds}, command: #{command_thread}" if command_every!=''
             processed = false
             processed_rules = false
 
+            if command_thread.match?(/\A.+\s+\?\?\s+.+\z/im) and !command_thread.match?(/\A\s*(add|create)\s+(silent\s+)?(bgroutine|routine)\s+([\w\.]+)/im)
+              pos = command_thread.index("??")
+              Thread.current[:prompt] = command_thread[pos+2..-1].strip
+              command_thread = command_thread[0..pos-1].strip
+              Thread.current[:stdout] = ""
+            else
+              Thread.current[:prompt] = ""
+              Thread.current[:stdout] = ""
+            end
             Thread.current[:dest] = dest
             Thread.current[:user] = user
+            Thread.current[:team_id_user] = user.team_id + "_" + user.name
+            Thread.current[:team_id] = user.team_id
             Thread.current[:command] = command_thread.dup
             Thread.current[:rules_file] = rules_file
             Thread.current[:typem] = typem
@@ -271,12 +287,12 @@ class SlackSmartBot
             else
               Thread.current[:on_thread] = true
             end
-            if (dest[0] == "C") || (dest[0] == "G") and @rules_imported.key?(user.name) &&
-                                                        @rules_imported[user.name].key?(dchannel) && @bots_created.key?(@rules_imported[user.name][dchannel])
-              Thread.current[:using_channel] = @rules_imported[user.name][dchannel]
-            elsif dest[0] == "D" && @rules_imported.key?(user.name) && @rules_imported[user.name].key?(user.name) and
-                  @bots_created.key?(@rules_imported[user.name][user.name])
-              Thread.current[:using_channel] = @rules_imported[user.name][user.name]
+            if (dest[0] == "C") || (dest[0] == "G") and @rules_imported.key?(team_id_user) &&
+                                                        @rules_imported[team_id_user].key?(dchannel) && @bots_created.key?(@rules_imported[team_id_user][dchannel])
+              Thread.current[:using_channel] = @rules_imported[team_id_user][dchannel]
+            elsif dest[0] == "D" && @rules_imported.key?(team_id_user) && @rules_imported[team_id_user].key?(user.name) and
+                  @bots_created.key?(@rules_imported[team_id_user][user.name])
+              Thread.current[:using_channel] = @rules_imported[team_id_user][user.name]
             else
               Thread.current[:using_channel] = ""
             end
@@ -300,24 +316,36 @@ class SlackSmartBot
               command_thread = command2
               on_demand = true
             end
+
+            if !config.on_maintenance and @listening.key?(team_id_user) and @listening[team_id_user].key?(Thread.current[:thread_ts]) and !Thread.current[:thread_ts].empty? and
+              ((@active_chat_gpt_sessions.key?(team_id_user) and @active_chat_gpt_sessions[team_id_user].key?(Thread.current[:thread_ts])) or
+              (@chat_gpt_collaborating.key?(team_id_user) and @chat_gpt_collaborating[team_id_user].key?(Thread.current[:thread_ts])))
+              @listening[team_id_user][Thread.current[:thread_ts]] = Time.now
+              command_thread = "? #{command_thread}" #chatgpt
+            end
+
+
             unless config.on_maintenance or @status != :on
               if typem == :on_pub or typem == :on_pg or typem == :on_extended
-                if command_thread.match(/\A\s*(#{@salutations.join("|")})\s+(rules|help)\s*(.+)?$/i) or command_thread.match(/\A(#{@salutations.join("|")}),? what can I do/i)
-                  $2.to_s.match?(/rules/i) ? specific = true : specific = false
-                  help_command = $3
+                if command_thread.match(/\A(<)?\s*(#{@salutations.join("|")})\s+(rules|help)\s*(.+)?$/i) or command_thread.match(/\A(<)?\s*(#{@salutations.join("|")}),? what can I do/i)
+                  $1.to_s=='' ? send_to_file = false : send_to_file = true
+                  $3.to_s.match?(/rules/i) ? specific = true : specific = false
+                  help_command = $4
+                  react :runner
                   if typem == :on_extended and specific
-                    bot_rules(dest, help_command, typem, rules_file, user)
+                    bot_rules(dest, help_command, typem, rules_file, user, send_to_file: send_to_file)
                   else
-                    bot_help(user, user.name, dest, dchannel, specific, help_command, rules_file)
+                    bot_help(user, user.name, dest, dchannel, specific, help_command, rules_file, send_to_file: send_to_file)
                   end
                   processed = true
+                  unreact :runner
                 end
               end
               processed = (processed || general_bot_commands(user, command_thread, dest, files))
               processed = (processed || general_commands(user, command_thread, dest, files)) if defined?(general_commands)
               if processed
                 text_to_log = command_thread.dup
-                
+
                 if Thread.current.key?(:encrypted) and Thread.current[:encrypted].size > 0
                   found = false
                   Thread.current[:encrypted].each do |encdata|
@@ -327,19 +355,19 @@ class SlackSmartBot
                   text_to_log = "********" if !found
                   text_to_log+= " (encrypted #{Thread.current[:command_id]})"
                 end
-                @logger.info "command: #{nick}> #{text_to_log}"
+                @logger.info "command: #{user.team_id}/#{nick}> #{text_to_log}" unless user.id == config.nick_id_granular
               end
             end
 
             if !config.on_maintenance and !processed and typem != :on_pub and typem != :on_pg
               if @status == :on and
                  (!answer.empty? or
-                  (@repl_sessions.key?(nick) and dest == @repl_sessions[nick][:dest] and
-                   ((@repl_sessions[nick][:on_thread] and thread_ts == @repl_sessions[nick][:thread_ts]) or
-                    (!@repl_sessions[nick][:on_thread] and !Thread.current[:on_thread]))) or
-                  (@listening.key?(nick) and typem != :on_extended and
-                   ((@listening[nick].key?(dest) and !Thread.current[:on_thread]) or
-                    (@listening[nick].key?(thread_ts) and Thread.current[:on_thread]))) or
+                  (@repl_sessions.key?(team_id_user) and dest == @repl_sessions[team_id_user][:dest] and
+                   ((@repl_sessions[team_id_user][:on_thread] and thread_ts == @repl_sessions[team_id_user][:thread_ts]) or
+                    (!@repl_sessions[team_id_user][:on_thread] and !Thread.current[:on_thread]))) or
+                  (@listening.key?(team_id_user) and typem != :on_extended and
+                   ((@listening[team_id_user].key?(dest) and !Thread.current[:on_thread]) or
+                    (@listening[team_id_user].key?(thread_ts) and Thread.current[:on_thread]))) or
                   dest[0] == "D" or on_demand)
                   unless processed
                     text_to_log = command_thread.dup
@@ -352,14 +380,14 @@ class SlackSmartBot
                       text_to_log = "********" if !found
                       text_to_log+= " (encrypted #{Thread.current[:command_id]})"
                     end
-                    @logger.info "command: #{nick}> #{text_to_log}"
+                    @logger.info "command: #{user.team_id}/#{nick}> #{text_to_log}" unless user.id == config.nick_id_granular
                   end
                 #todo: verify this
 
                 if dest[0] == "C" or dest[0] == "G" or (dest[0] == "D" and typem == :on_call)
-                  if typem != :on_call and @rules_imported.key?(user.name) and @rules_imported[user.name].key?(dchannel)
-                    if @bots_created.key?(@rules_imported[user.name][dchannel])
-                      if @bots_created[@rules_imported[user.name][dchannel]][:status] != :on
+                  if typem != :on_call and @rules_imported.key?(team_id_user) and @rules_imported[team_id_user].key?(dchannel)
+                    if @bots_created.key?(@rules_imported[team_id_user][dchannel])
+                      if @bots_created[@rules_imported[team_id_user][dchannel]][:status] != :on
                         respond "The bot on that channel is not :on", dest
                         rules_file = ""
                       end
@@ -386,9 +414,9 @@ class SlackSmartBot
                       @logger.warn "It seems like rules method is not defined"
                     end
                   end
-                elsif @rules_imported.key?(user.name) and @rules_imported[user.name].key?(user.name)
-                  if @bots_created.key?(@rules_imported[user.name][user.name])
-                    if @bots_created[@rules_imported[user.name][user.name]][:status] == :on
+                elsif @rules_imported.key?(team_id_user) and @rules_imported[team_id_user].key?(user.name)
+                  if @bots_created.key?(@rules_imported[team_id_user][user.name])
+                    if @bots_created[@rules_imported[team_id_user][user.name]][:status] == :on
                       begin
                         eval(File.new(config.path + rules_file).read) if File.exist?(config.path + rules_file) and ![".", ".."].include?(config.path + rules_file)
                       rescue Exception => stack
@@ -396,7 +424,7 @@ class SlackSmartBot
                         @logger.fatal stack
                       end
                     else
-                      respond "The bot on <##{@rules_imported[user.name][user.name]}|#{@bots_created[@rules_imported[user.name][user.name]][:channel_name]}> is not :on", dest
+                      respond "The bot on <##{@rules_imported[team_id_user][user.name]}|#{@bots_created[@rules_imported[team_id_user][user.name]][:channel_name]}> is not :on", dest
                       rules_file = ""
                     end
                   end
@@ -417,7 +445,7 @@ class SlackSmartBot
                     end
                   end
                 elsif dest[0] == "D" and
-                      (!@rules_imported.key?(user.name) or (@rules_imported.key?(user.name) and !@rules_imported[user.name].key?(user.name))) and
+                      (!@rules_imported.key?(team_id_user) or (@rules_imported.key?(team_id_user) and !@rules_imported[team_id_user].key?(user.name))) and
                       rules_file.include?("general_rules.rb")
                   begin
                     eval(File.new(config.path + rules_file).read) if File.exist?(config.path + rules_file) and ![".", ".."].include?(config.path + rules_file)
@@ -455,21 +483,34 @@ class SlackSmartBot
 
                 processed = (processed_rules || processed)
 
-                if processed and @listening.key?(nick)
-                  if Thread.current[:on_thread] and @listening[nick].key?(Thread.current[:thread_ts])
-                    @listening[nick][Thread.current[:thread_ts]] = Time.now
-                  elsif !Thread.current[:on_thread] and @listening[nick].key?(dest)
-                    @listening[nick][dest] = Time.now
+                if processed and @listening.key?(team_id_user)
+                  if Thread.current[:on_thread] and @listening[team_id_user].key?(Thread.current[:thread_ts])
+                    @listening[team_id_user][Thread.current[:thread_ts]] = Time.now
+                  elsif !Thread.current[:on_thread] and @listening[team_id_user].key?(dest)
+                    @listening[team_id_user][dest] = Time.now
                   end
                 end
               end
             end
 
+            if Thread.current[:prompt].to_s != ''
+              prompt = "#{Thread.current[:command]}\n\n#{Thread.current[:prompt]}\n\n#{Thread.current[:stdout]}\n\n"
+              Thread.current[:prompt] = ''
+              Thread.current[:stdout] = ''
+              if processed
+                if @active_chat_gpt_sessions.key?(team_id_user) and @active_chat_gpt_sessions[team_id_user].key?(Thread.current[:thread_ts])
+                  open_ai_chat(prompt, false, :temporary)
+                else
+                  open_ai_chat(prompt, true, :temporary, model: config[:ai].open_ai.chat_gpt.smartbot_model)
+                end
+              end
+            end
             if processed and config.general_message != "" and !routine
               respond eval("\"" + config.general_message + "\"")
             end
             respond "_*Loop #{loop_id}* (#{i+1}/#{num_times}) <@#{user.name}>: #{command_every}_" if command_every!='' and processed
-            @loops[user.name].delete(loop_id) if command_every!='' and !processed and @loops.key?(user.name) and @loops[user.name].include?(loop_id)
+            @loops[team_id_user].delete(loop_id) if command_every!='' and !processed and @loops.key?(team_id_user) and @loops[team_id_user].include?(loop_id)
+
           rescue Exception => stack
             @logger.fatal stack
           end