personality 0.1.4 → 0.1.5

data/lib/personality/mcp/oauth.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "json"
+require "openssl"
+require "uri"
+
+module Personality
+  module MCP
+    class OAuth
+      # Static client credentials (set via env or generate once)
+      CLIENT_ID = ENV.fetch("PSN_OAUTH_CLIENT_ID") { "psn-mcp-client" }
+      CLIENT_SECRET = ENV.fetch("PSN_OAUTH_CLIENT_SECRET") { SecureRandom.hex(32) }
+
+      # Token signing key
+      TOKEN_SECRET = ENV.fetch("PSN_TOKEN_SECRET") { SecureRandom.hex(32) }
+
+      attr_reader :base_url
+
+      def initialize(base_url:)
+        @base_url = base_url.chomp("/")
+        @auth_codes = {} # code => { client_id:, redirect_uri:, code_challenge:, expires_at: }
+        @tokens = {}     # token => { client_id:, expires_at: }
+      end
+
+      # GET /.well-known/oauth-protected-resource
+      def protected_resource_metadata
+        {
+          resource: base_url,
+          authorization_servers: [base_url],
+          bearer_methods_supported: ["header"]
+        }
+      end
+
+      # GET /.well-known/oauth-authorization-server
+      def authorization_server_metadata
+        {
+          issuer: base_url,
+          authorization_endpoint: "#{base_url}/authorize",
+          token_endpoint: "#{base_url}/token",
+          registration_endpoint: "#{base_url}/register",
+          response_types_supported: ["code"],
+          grant_types_supported: ["authorization_code", "client_credentials", "refresh_token"],
+          code_challenge_methods_supported: ["S256"],
+          token_endpoint_auth_methods_supported: ["client_secret_basic", "client_secret_post", "none"]
+        }
+      end
+
+      # POST /register - Dynamic client registration (simple version)
+      def register(params)
+        # For simplicity, just return our static client
+        # A real implementation would create unique clients
+        {
+          client_id: CLIENT_ID,
+          client_secret: CLIENT_SECRET,
+          client_id_issued_at: Time.now.to_i,
+          client_secret_expires_at: 0 # never expires
+        }
+      end
+
+      # GET /authorize - Authorization endpoint
+      def authorize(params)
+        client_id = params["client_id"]
+        redirect_uri = params["redirect_uri"]
+        state = params["state"]
+        code_challenge = params["code_challenge"]
+        code_challenge_method = params["code_challenge_method"]
+        response_type = params["response_type"]
+
+        # Validate required params
+        unless client_id && redirect_uri && response_type == "code"
+          return {error: "invalid_request", error_description: "Missing required parameters"}
+        end
+
+        # Validate client (for now, accept our static client or any registered)
+        # In production, validate against registered clients
+
+        # Auto-approve (personal use) - generate authorization code
+        code = SecureRandom.urlsafe_base64(32)
+        @auth_codes[code] = {
+          client_id: client_id,
+          redirect_uri: redirect_uri,
+          code_challenge: code_challenge,
+          code_challenge_method: code_challenge_method,
+          expires_at: Time.now + 600 # 10 minutes
+        }
+
+        # Build redirect URL
+        redirect = URI.parse(redirect_uri)
+        query_params = URI.decode_www_form(redirect.query || "")
+        query_params << ["code", code]
+        query_params << ["state", state] if state
+        redirect.query = URI.encode_www_form(query_params)
+
+        {redirect_to: redirect.to_s}
+      end
+
+      # POST /token - Token endpoint
+      def token(params, auth_header: nil)
+        grant_type = params["grant_type"]
+
+        # Extract client credentials from Basic auth header if present
+        if auth_header&.start_with?("Basic ")
+          decoded = begin
+            auth_header[6..].unpack1("m0")
+          rescue
+            nil
+          end
+          if decoded
+            basic_client_id, basic_client_secret = decoded.split(":", 2)
+            params["client_id"] ||= basic_client_id
+            params["client_secret"] ||= basic_client_secret
+          end
+        end
+
+        case grant_type
+        when "authorization_code"
+          exchange_code(params)
+        when "refresh_token"
+          refresh_token(params)
+        when "client_credentials"
+          client_credentials(params)
+        else
+          {error: "unsupported_grant_type"}
+        end
+      end
+
+      # Validate Bearer token from Authorization header
+      def validate_token(auth_header)
+        return nil unless auth_header&.start_with?("Bearer ")
+
+        token = auth_header[7..]
+        token_data = @tokens[token]
+
+        return nil unless token_data
+        return nil if Time.now > token_data[:expires_at]
+
+        token_data
+      end
+
+      private
+
+      def exchange_code(params)
+        code = params["code"]
+        client_id = params["client_id"]
+        redirect_uri = params["redirect_uri"]
+        code_verifier = params["code_verifier"]
+
+        # Find and validate auth code
+        auth_code = @auth_codes.delete(code)
+        unless auth_code
+          return {error: "invalid_grant", error_description: "Invalid or expired code"}
+        end
+
+        if Time.now > auth_code[:expires_at]
+          return {error: "invalid_grant", error_description: "Code expired"}
+        end
+
+        if auth_code[:client_id] != client_id
+          return {error: "invalid_grant", error_description: "Client mismatch"}
+        end
+
+        if auth_code[:redirect_uri] != redirect_uri
+          return {error: "invalid_grant", error_description: "Redirect URI mismatch"}
+        end
+
+        # Validate PKCE
+        if auth_code[:code_challenge]
+          unless verify_pkce(code_verifier, auth_code[:code_challenge], auth_code[:code_challenge_method])
+            return {error: "invalid_grant", error_description: "PKCE verification failed"}
+          end
+        end
+
+        # Generate tokens
+        generate_tokens(client_id)
+      end
+
+      def refresh_token(params)
+        params["refresh_token"]
+        # Simple refresh - just generate new tokens
+        # In production, validate refresh token
+        generate_tokens(params["client_id"] || "unknown")
+      end
+
+      def client_credentials(params)
+        client_id = params["client_id"]
+        client_secret = params["client_secret"]
+
+        # Validate client credentials
+        unless client_id == CLIENT_ID && client_secret == CLIENT_SECRET
+          return {error: "invalid_client", error_description: "Invalid client credentials"}
+        end
+
+        generate_tokens(client_id)
+      end
+
+      def generate_tokens(client_id)
+        access_token = SecureRandom.urlsafe_base64(32)
+        refresh_token = SecureRandom.urlsafe_base64(32)
+        expires_in = 3600 # 1 hour
+
+        @tokens[access_token] = {
+          client_id: client_id,
+          expires_at: Time.now + expires_in
+        }
+
+        {
+          access_token: access_token,
+          token_type: "Bearer",
+          expires_in: expires_in,
+          refresh_token: refresh_token
+        }
+      end
+
+      def verify_pkce(verifier, challenge, method)
+        return false unless verifier && challenge
+
+        case method
+        when "S256"
+          digest = OpenSSL::Digest::SHA256.digest(verifier)
+          # URL-safe base64 without padding (RFC 7636)
+          expected = [digest].pack("m0").tr("+/", "-_").delete("=")
+          secure_compare(expected, challenge)
+        when "plain", nil
+          secure_compare(verifier, challenge)
+        else
+          false
+        end
+      end
+
+      def secure_compare(a, b)
+        return false if a.nil? || b.nil?
+        return false if a.bytesize != b.bytesize
+        a.bytes.zip(b.bytes).reduce(0) { |acc, (x, y)| acc | (x ^ y) }.zero?
+      end
+    end
+  end
+end

data/lib/personality/mcp/rack_app.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require "rack"
+require "mcp"
+require "mcp/server/transports/streamable_http_transport"
+require_relative "server"
+require_relative "oauth"
+
+module Personality
+  module MCP
+    class RackApp
+      ALLOWED_ORIGINS = %w[
+        https://claude.ai
+        https://console.anthropic.com
+      ].freeze
+
+      def initialize(base_url: nil)
+        @base_url = base_url || ENV.fetch("PSN_BASE_URL", "https://psn.saiden.dev")
+        @oauth = OAuth.new(base_url: @base_url)
+        @server = build_server
+        @transport = ::MCP::Server::Transports::StreamableHTTPTransport.new(@server, stateless: true)
+      end
+
+      def call(env)
+        request = Rack::Request.new(env)
+        origin = env["HTTP_ORIGIN"]
+
+        # Debug logging
+        warn "[MCP] #{request.request_method} #{request.path_info} Origin: #{origin.inspect}"
+
+        # Handle CORS preflight
+        if request.options?
+          return cors_preflight_response(request)
+        end
+
+        # Route OAuth endpoints
+        case request.path_info
+        when "/.well-known/oauth-protected-resource"
+          return json_response(@oauth.protected_resource_metadata, origin)
+
+        when "/.well-known/oauth-authorization-server"
+          return json_response(@oauth.authorization_server_metadata, origin)
+
+        when "/register"
+          if request.post?
+            params = parse_body(request)
+            return json_response(@oauth.register(params), origin)
+          end
+
+        when "/authorize"
+          if request.get?
+            params = request.params
+            result = @oauth.authorize(params)
+            if result[:redirect_to]
+              return [302, {"Location" => result[:redirect_to]}, []]
+            else
+              return json_response(result, origin, status: 400)
+            end
+          end
+
+        when "/token"
+          if request.post?
+            params = parse_body(request)
+            auth_header = env["HTTP_AUTHORIZATION"]
+            result = @oauth.token(params, auth_header: auth_header)
+            status = result[:error] ? 400 : 200
+            return json_response(result, origin, status: status)
+          end
+        end
+
+        # Handle MCP endpoint at /mcp or root /
+        unless request.path_info == "/" || request.path_info == "/mcp"
+          return [404, add_cors_headers({"Content-Type" => "application/json"}, origin), ['{"error":"Not found"}']]
+        end
+
+        # For MCP endpoints, validate Bearer token
+        auth_header = env["HTTP_AUTHORIZATION"]
+        unless @oauth.validate_token(auth_header)
+          # Return 401 to trigger OAuth flow
+          return [401, add_cors_headers({"Content-Type" => "application/json", "WWW-Authenticate" => "Bearer"}, origin), ['{"error":"Unauthorized"}']]
+        end
+
+        # Validate Origin (DNS rebinding protection)
+        unless valid_origin?(origin)
+          return [403, {"Content-Type" => "application/json"}, ['{"error":"Invalid origin"}']]
+        end
+
+        # Delegate to MCP transport
+        status, headers, body = @transport.handle_request(request)
+
+        # Add CORS headers to response
+        headers = add_cors_headers(headers, origin)
+
+        [status, headers, body]
+      end
+
+      private
+
+      def build_server
+        DB.migrate!
+        # HTTP server defaults to :core mode (no indexer - that runs locally)
+        mode = ENV.fetch("PSN_MCP_MODE", "core").to_sym
+        server = Server.new(mode: mode)
+        server.instance_variable_get(:@server)
+      end
+
+      def parse_body(request)
+        body = request.body.read
+        request.body.rewind
+        return {} if body.empty?
+
+        content_type = request.content_type || ""
+        if content_type.include?("application/json")
+          JSON.parse(body)
+        else
+          # application/x-www-form-urlencoded
+          URI.decode_www_form(body).to_h
+        end
+      rescue JSON::ParserError
+        {}
+      end
+
+      def json_response(data, origin, status: 200)
+        headers = add_cors_headers({"Content-Type" => "application/json"}, origin)
+        [status, headers, [JSON.generate(data)]]
+      end
+
+      def cors_preflight_response(request)
+        origin = request.env["HTTP_ORIGIN"]
+        headers = {
+          "Access-Control-Allow-Origin" => valid_origin?(origin) ? origin : "",
+          "Access-Control-Allow-Methods" => "GET, POST, DELETE, OPTIONS",
+          "Access-Control-Allow-Headers" => "Content-Type, Accept, Authorization, X-API-Key, Mcp-Session-Id, MCP-Protocol-Version",
+          "Access-Control-Max-Age" => "86400"
+        }
+        [204, headers, []]
+      end
+
+      def add_cors_headers(headers, origin)
+        headers = headers.dup
+        if valid_origin?(origin)
+          headers["Access-Control-Allow-Origin"] = origin
+          headers["Access-Control-Expose-Headers"] = "Mcp-Session-Id"
+        end
+        headers
+      end
+
+      def valid_origin?(origin)
+        return true if origin.nil? # Non-browser clients
+        return true if origin.start_with?("http://localhost", "http://127.0.0.1")
+        ALLOWED_ORIGINS.include?(origin)
+      end
+    end
+  end
+end