aven 0.0.3

data/app/controllers/aven/articles_controller.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Aven
+  class ArticlesController < Aven::ApplicationController
+    include Aven::Authentication
+
+    before_action :authenticate_user!
+    before_action :set_article, only: [:show, :edit, :update, :destroy]
+
+    # GET /articles
+    def index
+      @articles = current_workspace.aven_articles.recent
+
+      respond_to do |format|
+        format.html { view_component("articles/index", articles: @articles, current_user:) }
+        format.json { render json: @articles }
+      end
+    end
+
+    # GET /articles/:id
+    def show
+      respond_to do |format|
+        format.html { view_component("articles/show", article: @article, current_user:) }
+        format.json { render json: @article }
+      end
+    end
+
+    # GET /articles/new
+    def new
+      @article = current_workspace.aven_articles.build
+
+      respond_to do |format|
+        format.html { view_component("articles/new", article: @article, current_user:) }
+        format.json { render json: @article }
+      end
+    end
+
+    # GET /articles/:id/edit
+    def edit
+      respond_to do |format|
+        format.html { view_component("articles/edit", article: @article, current_user:) }
+        format.json { render json: @article }
+      end
+    end
+
+    # POST /articles
+    def create
+      @article = current_workspace.aven_articles.build(article_params)
+      @article.author = current_user
+
+      if @article.save
+        respond_to do |format|
+          format.html { redirect_to article_path(@article), notice: "Article was successfully created." }
+          format.json { render json: @article, status: :created }
+        end
+      else
+        respond_to do |format|
+          format.html do
+            response.status = :unprocessable_entity
+            view_component("articles/new", article: @article, current_user:)
+          end
+          format.json { render json: { errors: @article.errors }, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    # PATCH/PUT /articles/:id
+    def update
+      if @article.update(article_params)
+        respond_to do |format|
+          format.html { redirect_to article_path(@article), notice: "Article was successfully updated." }
+          format.json { render json: @article }
+        end
+      else
+        respond_to do |format|
+          format.html do
+            response.status = :unprocessable_entity
+            view_component("articles/edit", article: @article, current_user:)
+          end
+          format.json { render json: { errors: @article.errors }, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    # DELETE /articles/:id
+    def destroy
+      @article.destroy
+
+      respond_to do |format|
+        format.html { redirect_to articles_path, notice: "Article was successfully deleted." }
+        format.json { head :no_content }
+      end
+    end
+
+    private
+
+      def set_article
+        @article = current_workspace.aven_articles.friendly.find(params[:id])
+      end
+
+      def article_params
+        params.require(:article).permit(
+          :title,
+          :intro,
+          :description,
+          :published_at,
+          :main_visual,
+          tag_list: [],
+          article_attachments_attributes: [:id, :file, :position, :_destroy],
+          article_relationships_attributes: [:id, :related_article_id, :position, :_destroy]
+        )
+      end
+  end
+end

data/app/controllers/aven/auth_controller.rb

@@ -0,0 +1,12 @@
+module Aven
+  class AuthController < ApplicationController
+    def logout
+      sign_out
+      begin
+        redirect_to(main_app.root_path, notice: "You have been signed out successfully.")
+      rescue NoMethodError
+        redirect_to(root_path, notice: "You have been signed out successfully.")
+      end
+    end
+  end
+end

data/app/controllers/aven/chat/threads_controller.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Aven
+  module Chat
+    class ThreadsController < Aven::ApplicationController
+      before_action :authenticate_user!
+      before_action :set_thread, only: [:show, :ask, :ask_agent]
+
+      def index
+        @threads = current_workspace.aven_chat_threads
+          .where(user: current_user)
+          .recent
+          .limit(50)
+
+        render json: @threads
+      end
+
+      def show
+        render json: @thread.as_json(
+          include: {
+            messages: { only: [:id, :role, :status, :content, :created_at] }
+          }
+        )
+      end
+
+      def create
+        @thread = current_workspace.aven_chat_threads.build(
+          user: current_user,
+          **thread_params
+        )
+
+        if @thread.save
+          render json: @thread, status: :created
+        else
+          render json: { errors: @thread.errors }, status: :unprocessable_entity
+        end
+      end
+
+      # POST /chat/threads/:id/ask
+      def ask
+        message = @thread.ask(params[:question])
+        render json: { message:, thread: @thread }
+      end
+
+      # POST /chat/threads/:id/ask_agent
+      def ask_agent
+        agent = current_workspace.aven_agentic_agents.find(params[:agent_id])
+        question = params[:question].presence
+
+        message = @thread.ask_with_agent(agent, question)
+        render json: { message:, thread: @thread }
+      end
+
+      private
+
+        def set_thread
+          @thread = current_workspace.aven_chat_threads
+            .where(user: current_user)
+            .find(params[:id])
+        end
+
+        def thread_params
+          params.permit(:title, :context_markdown)
+        end
+    end
+  end
+end

data/app/controllers/aven/oauth/auth0_controller.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+
+module Aven
+  module Oauth
+    class Auth0Controller < BaseController
+      # Auth0 uses your domain (e.g., your-tenant.auth0.com or your-tenant.us.auth0.com)
+      # These URLs will be constructed dynamically based on the configured domain
+      DEFAULT_SCOPE = "openid email profile"
+
+      protected
+
+        def authorization_url(state)
+          params = {
+            client_id: oauth_config[:client_id],
+            redirect_uri: callback_url,
+            response_type: "code",
+            scope: oauth_config[:scope] || DEFAULT_SCOPE,
+            state:
+          }
+
+          # Optionally add audience parameter if specified (for API access)
+          params[:audience] = oauth_config[:audience] if oauth_config[:audience].present?
+
+          "#{auth0_authorization_url}?#{params.to_query}"
+        end
+
+        def exchange_code_for_token(code)
+          params = {
+            grant_type: "authorization_code",
+            client_id: oauth_config[:client_id],
+            client_secret: oauth_config[:client_secret],
+            code:,
+            redirect_uri: callback_url
+          }
+
+          oauth_request(URI(auth0_token_url), params)
+        end
+
+        def fetch_user_info(access_token)
+          response = oauth_get_request(URI(auth0_userinfo_url), access_token)
+
+          {
+            id: response[:sub],
+            email: response[:email],
+            name: response[:name] || response[:nickname],
+            picture: response[:picture]
+          }
+        end
+
+      private
+
+        def callback_url
+          aven.oauth_auth0_callback_url(host: request.host, protocol: request.protocol)
+        end
+
+        def oauth_config
+          @oauth_config ||= Aven.configuration.oauth_providers[:auth0] || raise("Auth0 OAuth not configured")
+        end
+
+        def auth0_domain
+          @auth0_domain ||= oauth_config[:domain] || raise("Auth0 domain not configured")
+        end
+
+        def auth0_base_url
+          @auth0_base_url ||= auth0_domain.start_with?("http") ? auth0_domain : "https://#{auth0_domain}"
+        end
+
+        def auth0_authorization_url
+          "#{auth0_base_url}/authorize"
+        end
+
+        def auth0_token_url
+          "#{auth0_base_url}/oauth/token"
+        end
+
+        def auth0_userinfo_url
+          "#{auth0_base_url}/userinfo"
+        end
+    end
+  end
+end

data/app/controllers/aven/oauth/base_controller.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+module Aven
+  module Oauth
+    class BaseController < ApplicationController
+      skip_before_action :verify_authenticity_token, only: [:callback]
+
+      # Initiates OAuth flow
+      def create
+        state = SecureRandom.hex(16)
+        session[:oauth_state] = state
+
+        redirect_to authorization_url(state), allow_other_host: true
+      end
+
+      # Handles OAuth callback
+      def callback
+        validate_state!
+
+        token_data = exchange_code_for_token(params[:code])
+        user_info = fetch_user_info(token_data[:access_token])
+
+        user = find_or_create_user(user_info, token_data)
+
+        if user.persisted?
+          sign_in_and_redirect(user)
+        else
+          handle_failed_authentication(user)
+        end
+      rescue => e
+        Rails.logger.error("OAuth authentication failed: #{e.class.name} - #{e.message}")
+        Rails.logger.error(e.backtrace.first(10).join("\n")) unless Rails.env.production?
+
+        error_message = if Rails.env.production?
+          "Authentication failed. Please try again."
+        else
+          "#{e.message}"
+        end
+
+        error_class = Rails.env.production? ? nil : e.class.name
+        render_error_page(error_message, error_class)
+      end
+
+      # Renders OAuth error page
+      def error
+        @error_message = params[:message] || "Authentication failed"
+        @error_class = params[:error_class]
+
+        view_component(
+          "oauth/error",
+          error_message: @error_message,
+          error_class: @error_class,
+          current_user:
+        )
+      end
+
+      protected
+
+        # Must be implemented by subclasses
+        def authorization_url(state)
+          raise NotImplementedError
+        end
+
+        def exchange_code_for_token(code)
+          raise NotImplementedError
+        end
+
+        def fetch_user_info(access_token)
+          raise NotImplementedError
+        end
+
+        # Common helper methods
+        def validate_state!
+          if params[:state] != session[:oauth_state]
+            raise StandardError, "Invalid state parameter"
+          end
+          session.delete(:oauth_state)
+        end
+
+        def find_or_create_user(user_info, token_data)
+          auth_tenant = request.host
+
+          user = Aven::User.where(auth_tenant:)
+                           .where("remote_id = ? OR email = ?", user_info[:id].to_s, user_info[:email])
+                           .first_or_initialize
+
+          user.tap do |u|
+            u.auth_tenant = auth_tenant
+            u.remote_id = user_info[:id].to_s
+            u.email = user_info[:email]
+            u.access_token = token_data[:access_token]
+            u.save
+          end
+        end
+
+        def sign_in_and_redirect(user)
+          sign_in(user)
+          set_current_workspace_for(user)
+          redirect_to after_sign_in_path_for(user)
+        end
+
+        def set_current_workspace_for(user)
+          workspace = user.workspaces.first
+
+          # Create default workspace if user has none (new sign up)
+          if workspace.nil?
+            workspace = Aven::Workspace.create!(label: "Default Workspace")
+            Aven::WorkspaceUser.create!(user:, workspace:)
+            user.reload
+          end
+
+          # Set current workspace in session
+          session[:workspace_id] = workspace.id
+        end
+
+        def handle_failed_authentication(user)
+          error_message = if !Rails.env.production? && user.errors.any?
+            user.errors.full_messages.join(", ")
+          else
+            "Failed to create user account"
+          end
+
+          error_class = Rails.env.production? ? nil : "User::ValidationError"
+          render_error_page(error_message, error_class)
+        end
+
+        def render_error_page(message, error_class = nil)
+          view_component(
+            "oauth/error",
+            error_message: message,
+            error_class:,
+            current_user:
+          )
+        end
+
+        def after_sign_in_path_for(resource)
+          stored_location_for(resource) ||
+            Aven.configuration.resolve_authenticated_root_path ||
+            begin
+              main_app.root_path
+            rescue NoMethodError
+              root_path
+            end
+        end
+
+        # HTTP helper for OAuth requests
+        def oauth_request(uri, params, headers = {})
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE if Rails.env.development?
+
+          request = Net::HTTP::Post.new(uri)
+          request.set_form_data(params)
+          headers.each { |key, value| request[key] = value }
+
+          response = http.request(request)
+
+          unless response.is_a?(Net::HTTPSuccess)
+            raise StandardError, "OAuth request failed: #{response.body}"
+          end
+
+          JSON.parse(response.body, symbolize_names: true)
+        end
+
+        def oauth_get_request(uri, access_token)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE if Rails.env.development?
+
+          request = Net::HTTP::Get.new(uri)
+          request["Authorization"] = "Bearer #{access_token}"
+
+          response = http.request(request)
+
+          unless response.is_a?(Net::HTTPSuccess)
+            raise StandardError, "OAuth request failed: #{response.body}"
+          end
+
+          JSON.parse(response.body, symbolize_names: true)
+        end
+    end
+  end
+end