rails_console_ai 0.13.0

data/lib/rails_console_ai/session_logger.rb

@@ -0,0 +1,90 @@
+module RailsConsoleAI
+  module SessionLogger
+    class << self
+      def log(attrs)
+        return unless RailsConsoleAI.configuration.session_logging
+        return unless table_exists?
+
+        create_attrs = {
+          query:         attrs[:query],
+          conversation:  Array(attrs[:conversation]).to_json,
+          input_tokens:  attrs[:input_tokens] || 0,
+          output_tokens: attrs[:output_tokens] || 0,
+          user_name:     attrs[:user_name] || current_user_name,
+          mode:          attrs[:mode].to_s,
+          name:          attrs[:name],
+          code_executed: attrs[:code_executed],
+          code_output:   attrs[:code_output],
+          code_result:   attrs[:code_result],
+          console_output: attrs[:console_output],
+          executed:      attrs[:executed] || false,
+          provider:      RailsConsoleAI.configuration.provider.to_s,
+          model:         RailsConsoleAI.configuration.resolved_model,
+          duration_ms:   attrs[:duration_ms],
+          created_at:    Time.respond_to?(:current) ? Time.current : Time.now
+        }
+        create_attrs[:slack_thread_ts] = attrs[:slack_thread_ts] if attrs[:slack_thread_ts]
+        record = session_class.create!(create_attrs)
+        record.id
+      rescue => e
+        msg = "RailsConsoleAI: session logging failed: #{e.class}: #{e.message}"
+        $stderr.puts "\e[33m#{msg}\e[0m" if $stderr.respond_to?(:puts)
+        RailsConsoleAI.logger.warn(msg)
+        nil
+      end
+
+      def find_by_slack_thread(thread_ts)
+        return nil unless RailsConsoleAI.configuration.session_logging
+        return nil unless table_exists?
+        session_class.where(slack_thread_ts: thread_ts).order(created_at: :desc).first
+      rescue => e
+        RailsConsoleAI.logger.warn("RailsConsoleAI: session lookup failed: #{e.class}: #{e.message}")
+        nil
+      end
+
+      def update(id, attrs)
+        return unless id
+        return unless RailsConsoleAI.configuration.session_logging
+        return unless table_exists?
+
+        updates = {}
+        updates[:conversation]  = Array(attrs[:conversation]).to_json if attrs.key?(:conversation)
+        updates[:input_tokens]  = attrs[:input_tokens]  if attrs.key?(:input_tokens)
+        updates[:output_tokens] = attrs[:output_tokens] if attrs.key?(:output_tokens)
+        updates[:code_executed] = attrs[:code_executed]  if attrs.key?(:code_executed)
+        updates[:code_output]   = attrs[:code_output]    if attrs.key?(:code_output)
+        updates[:code_result]   = attrs[:code_result]    if attrs.key?(:code_result)
+        updates[:console_output] = attrs[:console_output] if attrs.key?(:console_output)
+        updates[:executed]      = attrs[:executed]       if attrs.key?(:executed)
+        updates[:duration_ms]   = attrs[:duration_ms]    if attrs.key?(:duration_ms)
+        updates[:name]          = attrs[:name]           if attrs.key?(:name)
+
+        session_class.where(id: id).update_all(updates) unless updates.empty?
+      rescue => e
+        msg = "RailsConsoleAI: session update failed: #{e.class}: #{e.message}"
+        $stderr.puts "\e[33m#{msg}\e[0m" if $stderr.respond_to?(:puts)
+        RailsConsoleAI.logger.warn(msg)
+        nil
+      end
+
+      private
+
+      def table_exists?
+        # Only cache positive results — retry on failure so transient
+        # errors (boot timing, connection not ready) don't stick forever
+        return true if @table_exists
+        @table_exists = session_class.connection.table_exists?('rails_console_ai_sessions')
+      rescue
+        false
+      end
+
+      def session_class
+        Object.const_get('RailsConsoleAI::Session')
+      end
+
+      def current_user_name
+        RailsConsoleAI.current_user || ENV['USER']
+      end
+    end
+  end
+end

data/lib/rails_console_ai/slack_bot.rb

@@ -0,0 +1,473 @@
+require 'json'
+require 'uri'
+require 'net/http'
+require 'openssl'
+require 'rails_console_ai/channel/slack'
+require 'rails_console_ai/conversation_engine'
+require 'rails_console_ai/context_builder'
+require 'rails_console_ai/providers/base'
+require 'rails_console_ai/executor'
+
+module RailsConsoleAI
+  class SlackBot
+    def initialize
+      @bot_token = RailsConsoleAI.configuration.slack_bot_token || ENV['SLACK_BOT_TOKEN']
+      @app_token = RailsConsoleAI.configuration.slack_app_token || ENV['SLACK_APP_TOKEN']
+      @channel_ids = resolve_channel_ids
+
+      raise ConfigurationError, "SLACK_BOT_TOKEN is required" unless @bot_token
+      raise ConfigurationError, "SLACK_APP_TOKEN is required (Socket Mode)" unless @app_token
+      raise ConfigurationError, "slack_allowed_usernames must be configured (e.g. ['alice'] or 'ALL')" unless RailsConsoleAI.configuration.slack_allowed_usernames
+
+      @bot_user_id = nil
+      @sessions = {}       # thread_ts → { channel:, engine:, thread: }
+      @user_cache = {}     # slack user_id → display_name
+      @mutex = Mutex.new
+    end
+
+    def start
+      @bot_user_id = slack_api("auth.test", token: @bot_token).dig("user_id")
+      log_startup
+
+      loop do
+        run_socket_mode
+        puts "Reconnecting in 5s..."
+        sleep 5
+      end
+    rescue Interrupt
+      puts "\nSlackBot shutting down."
+    end
+
+    private
+
+    # --- Socket Mode connection ---
+
+    def run_socket_mode
+      url = obtain_wss_url
+      uri = URI.parse(url)
+
+      tcp = TCPSocket.new(uri.host, uri.port || 443)
+      ssl = OpenSSL::SSL::SSLSocket.new(tcp, OpenSSL::SSL::SSLContext.new)
+      ssl.hostname = uri.host
+      ssl.connect
+
+      # WebSocket handshake
+      path = "#{uri.path}?#{uri.query}"
+      handshake = [
+        "GET #{path} HTTP/1.1",
+        "Host: #{uri.host}",
+        "Upgrade: websocket",
+        "Connection: Upgrade",
+        "Sec-WebSocket-Key: #{SecureRandom.base64(16)}",
+        "Sec-WebSocket-Version: 13",
+        "", ""
+      ].join("\r\n")
+
+      ssl.write(handshake)
+
+      # Read HTTP 101 response headers
+      response_line = ssl.gets
+      unless response_line&.include?("101")
+        raise "WebSocket handshake failed: #{response_line}"
+      end
+      # Consume remaining headers
+      loop do
+        line = ssl.gets
+        break if line.nil? || line.strip.empty?
+      end
+
+      puts "Connected to Slack Socket Mode."
+
+      # Main read loop
+      loop do
+        data = read_ws_frame(ssl)
+        next unless data
+
+        begin
+          msg = JSON.parse(data, symbolize_names: true)
+        rescue JSON::ParserError
+          next
+        end
+
+        # Acknowledge immediately (Slack requires fast ack)
+        if msg[:envelope_id]
+          send_ws_frame(ssl, JSON.generate({ envelope_id: msg[:envelope_id] }))
+        end
+
+        case msg[:type]
+        when "hello"
+          # Connection confirmed
+        when "disconnect"
+          puts "Slack disconnect: #{msg[:reason]}"
+          break
+        when "events_api"
+          handle_event(msg)
+        end
+      end
+    rescue EOFError, IOError, Errno::ECONNRESET, OpenSSL::SSL::SSLError => e
+      puts "Socket Mode connection lost: #{e.message}"
+    ensure
+      ssl&.close rescue nil
+      tcp&.close rescue nil
+    end
+
+    def obtain_wss_url
+      result = slack_api("apps.connections.open", token: @app_token)
+      raise "Failed to obtain WSS URL: #{result["error"]}" unless result["ok"]
+      result["url"]
+    end
+
+    # --- WebSocket frame reading/writing (RFC 6455 minimal implementation) ---
+
+    def read_ws_frame(ssl)
+      first_byte = ssl.read(1)&.unpack1("C")
+      return nil unless first_byte
+
+      opcode = first_byte & 0x0F
+      # Handle ping (opcode 9) → send pong (opcode 10)
+      if opcode == 9
+        payload = read_ws_payload(ssl)
+        send_ws_pong(ssl, payload)
+        return nil
+      end
+      # Close frame (opcode 8)
+      return nil if opcode == 8
+      # Only process text frames (opcode 1)
+      return nil unless opcode == 1
+
+      read_ws_payload(ssl)
+    end
+
+    def read_ws_payload(ssl)
+      second_byte = ssl.read(1)&.unpack1("C")
+      return nil unless second_byte
+
+      masked = (second_byte & 0x80) != 0
+      length = second_byte & 0x7F
+
+      if length == 126
+        length = ssl.read(2).unpack1("n")
+      elsif length == 127
+        length = ssl.read(8).unpack1("Q>")
+      end
+
+      if masked
+        mask_key = ssl.read(4).bytes
+        raw = ssl.read(length).bytes
+        raw.each_with_index.map { |b, i| (b ^ mask_key[i % 4]).chr }.join
+      else
+        ssl.read(length)
+      end
+    end
+
+    def send_ws_frame(ssl, text)
+      bytes = text.encode("UTF-8").bytes
+      # Client frames must be masked per RFC 6455
+      mask_key = 4.times.map { rand(256) }
+      masked = bytes.each_with_index.map { |b, i| b ^ mask_key[i % 4] }
+
+      frame = [0x81].pack("C") # FIN + text opcode
+      if bytes.length < 126
+        frame << [(bytes.length | 0x80)].pack("C")
+      elsif bytes.length < 65536
+        frame << [126 | 0x80].pack("C")
+        frame << [bytes.length].pack("n")
+      else
+        frame << [127 | 0x80].pack("C")
+        frame << [bytes.length].pack("Q>")
+      end
+      frame << mask_key.pack("C*")
+      frame << masked.pack("C*")
+      ssl.write(frame)
+    end
+
+    def send_ws_pong(ssl, payload)
+      payload ||= ""
+      bytes = payload.bytes
+      mask_key = 4.times.map { rand(256) }
+      masked = bytes.each_with_index.map { |b, i| b ^ mask_key[i % 4] }
+
+      frame = [0x8A].pack("C") # FIN + pong opcode
+      frame << [(bytes.length | 0x80)].pack("C")
+      frame << mask_key.pack("C*")
+      frame << masked.pack("C*")
+      ssl.write(frame)
+    end
+
+    # --- Slack Web API (minimal, uses Net::HTTP) ---
+
+    def slack_api(method, token: @bot_token, **params)
+      uri = URI("https://slack.com/api/#{method}")
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+
+      if params.empty?
+        req = Net::HTTP::Post.new(uri.path)
+      else
+        req = Net::HTTP::Post.new(uri.path)
+        req.body = JSON.generate(params)
+        req["Content-Type"] = "application/json; charset=utf-8"
+      end
+      req["Authorization"] = "Bearer #{token}"
+
+      resp = http.request(req)
+      JSON.parse(resp.body)
+    rescue => e
+      { "ok" => false, "error" => e.message }
+    end
+
+    def post_message(channel:, thread_ts:, text:)
+      slack_api("chat.postMessage", channel: channel, thread_ts: thread_ts, text: text)
+    end
+
+    # --- Event handling ---
+
+    def handle_event(msg)
+      event = msg.dig(:payload, :event)
+      return unless event
+      return unless event[:type] == "message"
+
+      # Ignore bot messages, subtypes (edits/deletes), own messages
+      return if event[:bot_id]
+      return if event[:user] == @bot_user_id
+      return if event[:subtype]
+
+      text = event[:text]
+      return unless text && !text.strip.empty?
+
+      channel_id = event[:channel]
+      return unless watched_channel?(channel_id)
+
+      thread_ts = event[:thread_ts] || event[:ts]
+      user_id = event[:user]
+      user_name = resolve_user_name(user_id)
+
+      allowed_list = Array(RailsConsoleAI.configuration.slack_allowed_usernames).map(&:to_s).map(&:downcase)
+      unless allowed_list.include?('all') || allowed_list.include?(user_name.to_s.downcase)
+        puts "[#{channel_id}/#{thread_ts}] @#{user_name} << (ignored — not in allowed usernames)"
+        post_message(channel: channel_id, thread_ts: thread_ts, text: "Sorry, I don't recognize your username (@#{user_name}). Ask an admin to add you to the allowed usernames list.")
+        return
+      end
+
+      puts "[#{channel_id}/#{thread_ts}] @#{user_name} << #{text.strip}"
+
+      session = @mutex.synchronize { @sessions[thread_ts] }
+
+      command = text.strip.downcase
+      if command == 'cancel' || command == 'stop'
+        cancel_session(session, channel_id, thread_ts)
+        return
+      end
+
+      if command == 'clear'
+        count = count_bot_messages(channel_id, thread_ts)
+        if count == 0
+          post_message(channel: channel_id, thread_ts: thread_ts, text: "No bot messages to clear.")
+        else
+          post_message(channel: channel_id, thread_ts: thread_ts,
+            text: "This will permanently delete #{count} bot message#{'s' unless count == 1} from this thread. Type `clear!` to confirm.")
+        end
+        return
+      end
+
+      if command == 'clear!'
+        cancel_session(session, channel_id, thread_ts) if session
+        clear_bot_messages(channel_id, thread_ts)
+        return
+      end
+
+      if session
+        handle_thread_reply(session, text.strip)
+      else
+        # New thread, or existing thread after bot restart — start a fresh session
+        start_session(channel_id, thread_ts, text.strip, user_name)
+      end
+    rescue => e
+      RailsConsoleAI.logger.error("SlackBot event handling error: #{e.class}: #{e.message}")
+    end
+
+    def start_session(channel_id, thread_ts, text, user_name)
+      channel = Channel::Slack.new(
+        slack_bot: self,
+        channel_id: channel_id,
+        thread_ts: thread_ts,
+        user_name: user_name
+      )
+
+      sandbox_binding = Object.new.instance_eval { binding }
+      engine = ConversationEngine.new(
+        binding_context: sandbox_binding,
+        channel: channel,
+        slack_thread_ts: thread_ts
+      )
+
+      # Try to restore conversation history from a previous session (e.g. after bot restart)
+      restored = restore_from_db(engine, thread_ts)
+
+      session = { channel: channel, engine: engine, thread: nil }
+      @mutex.synchronize { @sessions[thread_ts] = session }
+
+      session[:thread] = Thread.new do
+        Thread.current.report_on_exception = false
+        begin
+          channel.display_dim("_session: #{channel_id}/#{thread_ts}_")
+          if restored
+            puts "Restored session for thread #{thread_ts} (#{engine.history.length} messages)"
+            channel.display_dim("_(session restored — continuing from previous conversation)_")
+          end
+          engine.process_message(text)
+        rescue => e
+          channel.display_error("Error: #{e.class}: #{e.message}")
+          RailsConsoleAI.logger.error("SlackBot session error: #{e.class}: #{e.message}\n#{e.backtrace.first(5).join("\n")}")
+        ensure
+          ActiveRecord::Base.clear_active_connections! if defined?(ActiveRecord::Base)
+        end
+      end
+    end
+
+    def restore_from_db(engine, thread_ts)
+      require 'rails_console_ai/session_logger'
+      saved = SessionLogger.find_by_slack_thread(thread_ts)
+      return false unless saved
+
+      engine.init_interactive
+      engine.restore_session(saved)
+      true
+    rescue => e
+      RailsConsoleAI.logger.warn("SlackBot: failed to restore session for #{thread_ts}: #{e.message}")
+      false
+    end
+
+    def handle_thread_reply(session, text)
+      channel = session[:channel]
+      engine = session[:engine]
+
+      # If the engine is blocked waiting for user input (ask_user), push to queue
+      if waiting_for_reply?(channel)
+        channel.receive_reply(text)
+        return
+      end
+
+      # Otherwise treat as a new message in the conversation
+      session[:thread] = Thread.new do
+        Thread.current.report_on_exception = false
+        begin
+          engine.process_message(text)
+        rescue => e
+          channel.display_error("Error: #{e.class}: #{e.message}")
+          RailsConsoleAI.logger.error("SlackBot session error: #{e.class}: #{e.message}\n#{e.backtrace.first(5).join("\n")}")
+        ensure
+          ActiveRecord::Base.clear_active_connections! if defined?(ActiveRecord::Base)
+        end
+      end
+    end
+
+    def cancel_session(session, channel_id, thread_ts)
+      if session
+        session[:channel].cancel!
+        session[:channel].display("Stopped.")
+        puts "[#{channel_id}/#{thread_ts}] cancel requested"
+      else
+        post_message(channel: channel_id, thread_ts: thread_ts, text: "No active session to stop.")
+        puts "[#{channel_id}/#{thread_ts}] cancel: no session"
+      end
+      @mutex.synchronize { @sessions.delete(thread_ts) }
+    end
+
+    def count_bot_messages(channel_id, thread_ts)
+      result = slack_get("conversations.replies", channel: channel_id, ts: thread_ts, limit: 200)
+      return 0 unless result["ok"]
+      (result["messages"] || []).count { |m| m["user"] == @bot_user_id }
+    rescue
+      0
+    end
+
+    def clear_bot_messages(channel_id, thread_ts)
+      result = slack_get("conversations.replies", channel: channel_id, ts: thread_ts, limit: 200)
+      unless result["ok"]
+        puts "[#{channel_id}/#{thread_ts}] clear: failed to fetch replies: #{result["error"]}"
+        return
+      end
+
+      bot_messages = (result["messages"] || []).select { |m| m["user"] == @bot_user_id }
+      bot_messages.each do |m|
+        puts "[#{channel_id}/#{thread_ts}] clearing #{channel_id.length} / #{m["ts"]}"
+        slack_api("chat.delete", channel: channel_id, ts: m["ts"])
+      end
+      puts "[#{channel_id}/#{thread_ts}] cleared #{bot_messages.length} bot messages"
+    rescue => e
+      puts "[#{channel_id}/#{thread_ts}] clear failed: #{e.message}"
+    end
+
+    def slack_get(method, **params)
+      uri = URI("https://slack.com/api/#{method}")
+      uri.query = URI.encode_www_form(params)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      req = Net::HTTP::Get.new(uri)
+      req["Authorization"] = "Bearer #{@bot_token}"
+      resp = http.request(req)
+      JSON.parse(resp.body)
+    rescue => e
+      { "ok" => false, "error" => e.message }
+    end
+
+    def waiting_for_reply?(channel)
+      channel.instance_variable_get(:@reply_queue).num_waiting > 0
+    end
+
+    def watched_channel?(channel_id)
+      return true if @channel_ids.nil? || @channel_ids.empty?
+      @channel_ids.include?(channel_id)
+    end
+
+    def resolve_channel_ids
+      ids = RailsConsoleAI.configuration.slack_channel_ids || ENV['CONSOLE_AGENT_SLACK_CHANNELS']
+      return nil if ids.nil?
+      ids = ids.split(',').map(&:strip) if ids.is_a?(String)
+      ids
+    end
+
+    def resolve_user_name(user_id)
+      return @user_cache[user_id] if @user_cache.key?(user_id)
+
+      # users.info requires form-encoded params, not JSON
+      uri = URI("https://slack.com/api/users.info")
+      uri.query = URI.encode_www_form(user: user_id)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      req = Net::HTTP::Get.new(uri)
+      req["Authorization"] = "Bearer #{@bot_token}"
+      resp = http.request(req)
+      result = JSON.parse(resp.body)
+
+      name = result.dig("user", "profile", "display_name")
+      name = result.dig("user", "real_name") if name.nil? || name.empty?
+      name = result.dig("user", "name") if name.nil? || name.empty?
+      @user_cache[user_id] = name || user_id
+    rescue => e
+      RailsConsoleAI.logger.warn("Failed to resolve user name for #{user_id}: #{e.message}")
+      @user_cache[user_id] = user_id
+    end
+
+    def log_startup
+      channel_info = if @channel_ids && !@channel_ids.empty?
+                       "channels: #{@channel_ids.join(', ')}"
+                     else
+                       "all channels"
+                     end
+      puts "RailsConsoleAI SlackBot started (#{channel_info}, bot: #{@bot_user_id})"
+
+      channel = Channel::Slack.new(slack_bot: self, channel_id: "boot", thread_ts: "boot")
+      engine = ConversationEngine.new(
+        binding_context: Object.new.instance_eval { binding },
+        channel: channel
+      )
+      puts "\nFull system prompt for Slack sessions:"
+      puts "-" * 60
+      puts engine.context
+      puts "-" * 60
+      puts
+    end
+  end
+end

data/lib/rails_console_ai/storage/base.rb

@@ -0,0 +1,27 @@
+module RailsConsoleAI
+  module Storage
+    class StorageError < StandardError; end
+
+    class Base
+      def read(key)
+        raise NotImplementedError
+      end
+
+      def write(key, content)
+        raise NotImplementedError
+      end
+
+      def list(pattern)
+        raise NotImplementedError
+      end
+
+      def exists?(key)
+        raise NotImplementedError
+      end
+
+      def delete(key)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/rails_console_ai/storage/file_storage.rb

@@ -0,0 +1,63 @@
+require 'fileutils'
+require 'rails_console_ai/storage/base'
+
+module RailsConsoleAI
+  module Storage
+    class FileStorage < Base
+      attr_reader :root_path
+
+      def initialize(root_path = nil)
+        @root_path = root_path || default_root
+      end
+
+      def read(key)
+        path = full_path(key)
+        return nil unless File.exist?(path)
+        File.read(path)
+      end
+
+      def write(key, content)
+        path = full_path(key)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, content)
+        true
+      rescue Errno::EACCES, Errno::EROFS, IOError => e
+        raise StorageError, "Cannot write #{key}: #{e.message}"
+      end
+
+      def list(pattern)
+        Dir.glob(File.join(@root_path, pattern)).sort.map do |path|
+          path.sub("#{@root_path}/", '')
+        end
+      end
+
+      def exists?(key)
+        File.exist?(full_path(key))
+      end
+
+      def delete(key)
+        path = full_path(key)
+        return false unless File.exist?(path)
+        File.delete(path)
+        true
+      rescue Errno::EACCES, Errno::EROFS, IOError => e
+        raise StorageError, "Cannot delete #{key}: #{e.message}"
+      end
+
+      private
+
+      def full_path(key)
+        sanitized = key.gsub('..', '').gsub(%r{\A/+}, '')
+        File.join(@root_path, sanitized)
+      end
+
+      def default_root
+        if defined?(Rails) && Rails.respond_to?(:root) && Rails.root
+          File.join(Rails.root.to_s, '.rails_console_ai')
+        else
+          File.join(Dir.pwd, '.rails_console_ai')
+        end
+      end
+    end
+  end
+end