rails-agent-stack 0.1.1

data/app/controllers/rails_agents/open_wire_inbound_controller.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "json"
+
+module RailsAgents
+  # Receives open-wire/1 message.inbound POSTs from the Open-Wire gateway.
+  # Mounted under the Rails Agents engine (no separate OpenWire::Engine).
+  #
+  #   POST /agents/open_wire/inbound
+  #   Headers: X-Open-Wire-Secret, X-Open-Wire-Protocol, X-Open-Wire-Installation
+  #
+  # Resolves agent via:
+  #   ?agent=order_notification  OR  JSON meta / installation mapping in channels/*.yml
+  class OpenWireInboundController < ApplicationController
+    skip_forgery_protection
+
+    def create
+      slug = resolve_agent_slug
+      return render json: { error: "agent is required (?agent=slug)" }, status: :bad_request if slug.blank?
+
+      klass = load_agent_class(slug)
+      return render json: { error: "Agent not found" }, status: :not_found unless klass
+
+      secret = webhook_secret_for(slug)
+      return render json: { error: "Open-Wire webhook secret not configured for agent" }, status: :unauthorized if secret.blank?
+
+      message = RailsAgents::OpenWireAdapter.verify_inbound!(
+        secret: secret,
+        body: request.raw_post,
+        headers: request.headers
+      )
+
+      result = dispatch_to_agent(klass, message, slug)
+
+      render json: {
+        object: "open_wire_inbound_ack",
+        data: {
+          agent: slug,
+          message_id: message.id,
+          thread_id: message.thread_id,
+          result: result
+        }
+      }
+    rescue ::OpenWire::AuthError => e
+      render json: { error: e.message }, status: :unauthorized
+    rescue ::OpenWire::WebhookError => e
+      render json: { error: e.message }, status: :unprocessable_entity
+    rescue StandardError => e
+      Rails.logger.error("[RailsAgents::OpenWireInbound] #{e.class}: #{e.message}\n#{e.backtrace&.first(8)&.join("\n")}")
+      render json: { error: "Inbound handler failed" }, status: :internal_server_error
+    end
+
+    private
+
+    def resolve_agent_slug
+      params[:agent].presence ||
+        params[:agent_slug].presence ||
+        request.headers["X-Rails-Agent-Slug"].presence
+    end
+
+    def webhook_secret_for(slug)
+      yml = channel_yml(slug)
+      return ENV["OPEN_WIRE_WEBHOOK_SECRET"].presence unless yml
+
+      yml[/open_wire_webhook_secret:\s*["']?([^"'\s]+)/, 1].presence ||
+        ENV["OPEN_WIRE_WEBHOOK_SECRET"].presence
+    end
+
+    def installation_id_for(slug)
+      yml = channel_yml(slug)
+      return nil unless yml
+
+      yml[/open_wire_installation_id:\s*["']?([^"'\s]+)/, 1]
+    end
+
+    def channel_yml(slug)
+      %w[slack.yml slack.yaml].each do |name|
+        path = Rails.root.join("app", "agents", slug, "channels", name)
+        return path.read if path.file?
+      end
+      nil
+    end
+
+    def dispatch_to_agent(klass, message, slug)
+      # Prefer class-level on_channel_message callback when defined.
+      if klass.respond_to?(:channel_message_handler) && klass.channel_message_handler
+        return klass.channel_message_handler.call(message)
+      end
+
+      # Default: forward into agent run so Cloud/HITL loop can continue.
+      run_message = [
+        "open_wire_inbound:",
+        "channel: #{message.channel}",
+        "thread_id: #{message.thread_id}",
+        "from: #{message.from_id}",
+        "to: #{message.to_id}",
+        "kind: #{message.to_kind}",
+        "text: #{message.text}"
+      ].join("\n")
+
+      session_id = message.thread_id.present? ? "ow:#{message.thread_id}" : nil
+      result = klass.run(run_message, session_id: session_id)
+
+      maybe_auto_reply(slug, message, result)
+
+      {
+        mode: "agent_run",
+        run_id: (result.respond_to?(:id) ? result.id : nil),
+        output_preview: result.to_s.to_s[0, 240]
+      }
+    end
+
+    def maybe_auto_reply(slug, message, result)
+      installation_id = message.installation_id.presence || installation_id_for(slug)
+      return unless installation_id && message.to_id.present?
+
+      text =
+        if result.respond_to?(:output)
+          result.output.to_s
+        else
+          result.to_s
+        end
+      text = text.strip
+      return if text.empty?
+
+      # Cap auto-reply length for Slack
+      text = text[0, 2800]
+      RailsAgents::OpenWireAdapter.reply!(
+        installation_id: installation_id,
+        to: { id: message.to_id, kind: message.dm? ? "dm" : "channel" },
+        text: text,
+        thread_id: message.thread_id
+      )
+    rescue ::OpenWire::Error => e
+      Rails.logger.warn("[RailsAgents::OpenWireInbound] auto-reply skipped: #{e.message}")
+    end
+
+    def load_agent_class(slug)
+      safe_slug = slug.to_s
+      return nil unless safe_slug.match?(/\A[a-zA-Z0-9_-]+\z/)
+
+      path = Rails.root.join("app", "agents", safe_slug, "agent.rb")
+      return nil unless path.file?
+
+      source = path.read
+      class_name = source[/class\s+([A-Z][A-Za-z0-9_:]*)\s*<\s*RailsAgents::/, 1]
+      return nil unless class_name
+
+      require_dependency path.to_s
+      class_name.constantize
+    end
+  end
+end

data/app/controllers/rails_agents/pulls_controller.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module RailsAgents
+  class PullsController < ApplicationController
+    # Deprecated: JSON pull from embed bridge. Prefer local `app/agents/` + `rails-agents sync`.
+    # Kept for CLI `rails-agents pull` and backward compatibility until cloud authoring is removed.
+    def create
+      load_local_credentials!
+
+      unless RailsAgents.config.configured?
+        return render json: { ok: false, error: "Not connected to Rails Agent Cloud" }, status: :unprocessable_entity
+      end
+
+      agent_id = params[:agent_id].presence || params[:agent].presence || params.dig(:pull, :agent_id)
+      if agent_id.blank?
+        return render json: { ok: false, error: "agent_id is required" }, status: :bad_request
+      end
+
+      result = LocalSync.new.pull!(agent_id)
+      render json: result
+    rescue LocalSync::Error, Client::Error => e
+      render json: { ok: false, error: e.message }, status: :unprocessable_entity
+    end
+
+    private
+
+    def load_local_credentials!
+      path = Rails.root.join("config/rails_agents_credentials.yml")
+      return unless path.exist?
+
+      data = YAML.safe_load(path.read) || {}
+      RailsAgents.configure do |config|
+        config.api_key = data["api_key"] if data["api_key"].present?
+        config.project_id = data["project_id"] if data["project_id"].present?
+      end
+    rescue Psych::SyntaxError
+      nil
+    end
+  end
+end

data/app/controllers/rails_agents/registrations_controller.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module RailsAgents
+  class RegistrationsController < ApplicationController
+    include LocalAuth
+
+    before_action :redirect_if_configured!
+
+    def new
+      @github_url = github_oauth_url
+      pending = session[:ra_auth]
+      if pending.is_a?(Hash) && pending["email"].present? && pending["purpose"] == "signup"
+        @step = :code
+        @email = pending["email"]
+        @name = pending["name"]
+        @workspace = pending["workspace"].presence || default_workspace
+        @dev_code = pending["dev_code"]
+      else
+        @step = :email
+        @workspace = default_workspace
+      end
+    end
+
+    def create
+      @github_url = github_oauth_url
+      @workspace = params[:workspace].to_s.strip.presence || default_workspace
+      @name = params[:name].to_s.strip
+      @email = params[:email].to_s.strip.downcase
+
+      if @email.blank?
+        flash.now[:alert] = "Email is required."
+        @step = :email
+        render :new, status: :unprocessable_entity
+        return
+      end
+
+      response = Client.new.email_start(
+        email: @email,
+        purpose: "signup",
+        name: @name.presence,
+        company: @workspace
+      )
+      session[:ra_auth] = {
+        "purpose" => "signup",
+        "email" => @email,
+        "name" => @name,
+        "workspace" => @workspace,
+        "dev_code" => response["devCode"] || response["dev_code"]
+      }
+      @step = :code
+      @dev_code = session[:ra_auth]["dev_code"]
+      render :new
+    rescue Client::Error => e
+      flash.now[:alert] = e.message
+      @step = :email
+      render :new, status: :unprocessable_entity
+    end
+
+    def verify
+      pending = session[:ra_auth] || {}
+      @email = pending["email"].to_s
+      @name = pending["name"].to_s
+      @workspace = pending["workspace"].to_s
+      @github_url = github_oauth_url
+      code = params[:code].to_s.strip
+
+      if @email.blank? || code.blank?
+        flash.now[:alert] = "Enter the code we emailed you."
+        @step = :code
+        render :new, status: :unprocessable_entity
+        return
+      end
+
+      response = Client.new.email_verify(
+        email: @email,
+        code: code,
+        name: @name.presence,
+        company: @workspace.presence
+      )
+      session.delete(:ra_auth)
+      complete_cloud_auth!(response)
+    rescue Client::Error => e
+      flash.now[:alert] = e.message
+      @step = :code
+      @dev_code = pending["dev_code"]
+      @github_url = github_oauth_url
+      render :new, status: :unprocessable_entity
+    end
+
+    private
+
+    def default_workspace
+      (Rails.application.class.module_parent_name rescue "MyApp")
+    end
+  end
+end

data/app/controllers/rails_agents/schema_controller.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module RailsAgents
+  class SchemaController < ApplicationController
+    # GET /agents/schema — table list for Knowledge → Rails database connector
+    def show
+      databases = configured_databases
+      tables = active_record_tables
+      tables.concat(mongoid_collections) if tables.empty? || databases.any? { |db| db[:adapter] == "mongoid" }
+      primary = databases.find { |db| db[:name] == "primary" } || databases.first
+
+      render json: {
+        ok: true,
+        tables: tables,
+        adapter: primary&.dig(:adapter),
+        databases: databases,
+        config_files: detected_config_files
+      }
+    rescue StandardError => e
+      render json: { ok: false, error: e.message, tables: [] }, status: :unprocessable_entity
+    end
+
+    private
+
+    def configured_databases
+      configs = []
+      if defined?(ActiveRecord::Base)
+        ActiveRecord::Base.configurations.configs_for(env_name: Rails.env).each do |db|
+          configs << {
+            name: db.name.to_s,
+            adapter: normalize_adapter(db.adapter),
+            raw_adapter: db.adapter.to_s,
+            source: "config/database.yml"
+          }
+        end
+      end
+      if Rails.root.join("config/mongoid.yml").exist?
+        configs << {
+          name: "mongoid",
+          adapter: "mongoid",
+          raw_adapter: "mongodb",
+          source: "config/mongoid.yml"
+        }
+      end
+      configs.uniq { |db| [db[:name], db[:adapter], db[:source]] }
+    rescue StandardError
+      []
+    end
+
+    def active_record_tables
+      return [] unless defined?(ActiveRecord::Base)
+
+      ActiveRecord::Base.connection.tables
+        .reject { |table| internal_table?(table) }
+        .sort
+        .map do |name|
+          columns =
+            begin
+              ActiveRecord::Base.connection.columns(name).map(&:name)
+            rescue StandardError
+              []
+            end
+          {
+            name: name,
+            columns: columns.first(40),
+            kind: "table",
+            samples: sample_rows(name, columns)
+          }
+        end
+    rescue StandardError
+      []
+    end
+
+    def sample_rows(_table, columns)
+      return [] if columns.blank?
+
+      quoted = ActiveRecord::Base.connection.quote_table_name(_table)
+      rows = ActiveRecord::Base.connection.exec_query("SELECT * FROM #{quoted} LIMIT 8").to_a
+      rows.map do |row|
+        row.transform_values { |value| truncate_sample(value) }
+      end
+    rescue StandardError
+      []
+    end
+
+    def truncate_sample(value)
+      text = value.is_a?(String) ? value : value.inspect
+      text.length > 120 ? "#{text[0, 117]}..." : text
+    end
+
+    def mongoid_collections
+      return [] unless defined?(Mongoid) && Mongoid.respond_to?(:default_client)
+
+      Mongoid.default_client.database.collection_names
+        .reject { |name| name.start_with?("system.") }
+        .sort
+        .map { |name| { name: name, columns: [], kind: "collection", samples: [] } }
+    rescue StandardError
+      []
+    end
+
+    def detected_config_files
+      %w[config/database.yml config/mongoid.yml]
+        .select { |path| Rails.root.join(path).exist? }
+    end
+
+    def normalize_adapter(adapter)
+      value = adapter.to_s.downcase
+      return "postgresql" if value.include?("postgres") || value.include?("postgis") || value.include?("cockroach")
+      return "mysql" if value.include?("mysql") || value.include?("trilogy") || value.include?("maria")
+      return "sqlite" if value.include?("sqlite")
+      return "sqlserver" if value.include?("sqlserver")
+      return "oracle" if value.include?("oracle")
+
+      value.presence || "active_record"
+    end
+
+    def internal_table?(table)
+      table.start_with?("ar_", "solid_", "rails_agents") ||
+        %w[schema_migrations ar_internal_metadata].include?(table)
+    end
+  end
+end

data/app/controllers/rails_agents/sessions_controller.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RailsAgents
+  class SessionsController < ApplicationController
+    include LocalAuth
+
+    before_action :redirect_if_configured!, only: %i[new create verify]
+
+    def new
+      @github_url = github_oauth_url
+      pending = session[:ra_auth]
+      if pending.is_a?(Hash) && pending["email"].present? && pending["purpose"] == "signin"
+        @step = :code
+        @email = pending["email"]
+        @dev_code = pending["dev_code"]
+      else
+        @step = :email
+      end
+    end
+
+    def create
+      @github_url = github_oauth_url
+      @email = params[:email].to_s.strip.downcase
+
+      if @email.blank?
+        flash.now[:alert] = "Email is required."
+        @step = :email
+        render :new, status: :unprocessable_entity
+        return
+      end
+
+      response = Client.new.email_start(email: @email, purpose: "signin")
+      session[:ra_auth] = {
+        "purpose" => "signin",
+        "email" => @email,
+        "dev_code" => response["devCode"] || response["dev_code"]
+      }
+      @step = :code
+      @dev_code = session[:ra_auth]["dev_code"]
+      render :new
+    rescue Client::Error => e
+      flash.now[:alert] = e.message
+      @step = :email
+      render :new, status: :unprocessable_entity
+    end
+
+    def verify
+      pending = session[:ra_auth] || {}
+      @email = pending["email"].to_s
+      @github_url = github_oauth_url
+      code = params[:code].to_s.strip
+
+      if @email.blank? || code.blank?
+        flash.now[:alert] = "Enter the code we emailed you."
+        @step = :code
+        render :new, status: :unprocessable_entity
+        return
+      end
+
+      response = Client.new.email_verify(email: @email, code: code)
+      session.delete(:ra_auth)
+      complete_cloud_auth!(response)
+    rescue Client::Error => e
+      flash.now[:alert] = e.message
+      @step = :code
+      @dev_code = pending["dev_code"]
+      render :new, status: :unprocessable_entity
+    end
+
+    def destroy
+      cloud = RailsAgents.config.dashboard_base.to_s.chomp("/")
+      cloud = "https://cloud.rails-agent.com" if cloud.blank?
+      redirect_to "#{cloud}/signin", allow_other_host: true
+    end
+  end
+end

data/app/controllers/rails_agents/tool_bridge_controller.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "timeout"
+require "uri"
+
+module RailsAgents
+  class ToolBridgeController < ApplicationController
+    skip_forgery_protection
+
+    def create
+      return render json: { error: "Unauthorized" }, status: :unauthorized unless authorized_runtime?
+
+      klass = load_agent_class(params[:agent])
+      tool = klass&.tool_definitions&.fetch(params[:tool].to_sym, nil)
+      return render json: { error: "Tool not found" }, status: :not_found unless tool
+
+      arguments = request.request_parameters.presence || {}
+      result = tool.call(**arguments.deep_symbolize_keys)
+      render json: { ok: true, result: result }
+    rescue ArgumentError => e
+      render json: { error: e.message }, status: :unprocessable_entity
+    rescue StandardError => e
+      Rails.logger.error("[RailsAgents::ToolBridge] #{e.class}: #{e.message}")
+      render json: { error: "Tool execution failed" }, status: :internal_server_error
+    end
+
+    private
+
+    def authorized_runtime?
+      token = request.authorization.to_s.sub(/\ABearer\s+/i, "")
+      return false if token.empty?
+
+      uri = URI("#{RailsAgents.config.api_v1_base}/auth/introspect")
+      req = Net::HTTP::Get.new(uri)
+      req["Authorization"] = "Bearer #{token}"
+      response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") do |http|
+        http.open_timeout = 3
+        http.read_timeout = 5
+        http.request(req)
+      end
+      return false unless response.is_a?(Net::HTTPSuccess)
+
+      body = JSON.parse(response.body)
+      body.dig("data", "projectId").to_s == RailsAgents.config.project_id.to_s
+    rescue JSON::ParserError, IOError, SystemCallError, Timeout::Error
+      false
+    end
+
+    def load_agent_class(slug)
+      safe_slug = slug.to_s
+      return nil unless safe_slug.match?(/\A[a-zA-Z0-9_-]+\z/)
+
+      path = Rails.root.join("app", "agents", safe_slug, "agent.rb")
+      return nil unless path.file?
+
+      source = path.read
+      class_name = source[/class\s+([A-Z][A-Za-z0-9_:]*)\s*<\s*RailsAgents::/, 1]
+      return nil unless class_name
+
+      require_dependency path.to_s
+      class_name.constantize
+    end
+  end
+end
+

data/app/views/layouts/rails_agents/application.html.erb

@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>Rails Agent</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Fraunces:ital,opsz,wght@0,9..144,500;0,9..144,600;0,9..144,700;1,9..144,500;1,9..144,600&family=Inter:wght@400;500;600&family=JetBrains+Mono:wght@400;500&display=swap" rel="stylesheet">
+    <%= csrf_meta_tags if respond_to?(:csrf_meta_tags) %>
+    <%= stylesheet_link_tag "rails_agents/application", media: "all" %>
+  </head>
+  <body class="rails-agents-body">
+    <main class="<%= configured? ? "rails-agents-main--embed" : nil %>">
+      <%= yield %>
+    </main>
+  </body>
+</html>