connectors 0.1.0

data/lib/connectors/oauth/token_response.rb

@@ -0,0 +1,40 @@
+require "json"
+require "uri"
+
+module Connectors
+  module OAuth
+    # Both OAuth2 token flows accept JSON and form-encoded provider responses.
+    # Validate their shape before any credentials can be persisted.
+    class TokenResponse
+      def self.parse(response)
+        body = begin
+          JSON.parse(response.body.to_s)
+        rescue JSON::ParserError
+          URI.decode_www_form(response.body.to_s).to_h
+        end
+        body = {} unless body.is_a?(Hash)
+
+        token = body["access_token"]
+        if !response.status.between?(200, 299) || body["ok"] == false || body["error"] || !token.is_a?(String) || token.blank?
+          reason = body["error"].presence || "invalid token response"
+          raise Connectors::AuthenticationFailed.new(
+            "OAuth token exchange failed (#{response.status}): #{reason}",
+            status: response.status, body: body
+          )
+        end
+        body
+      end
+
+      def self.normalize(body)
+        expires_at = body["expires_in"] ? Time.now.to_i + body["expires_in"].to_i : body["expires_at"]&.to_i
+        {
+          "access_token" => body["access_token"],
+          "refresh_token" => body["refresh_token"],
+          "expires_at" => expires_at,
+          "scope" => body["scope"],
+          "token_type" => body["token_type"]
+        }.compact
+      end
+    end
+  end
+end

data/lib/connectors/oauth.rb

@@ -0,0 +1,4 @@
+module Connectors
+  module OAuth
+  end
+end

data/lib/connectors/oauth1.rb

@@ -0,0 +1,151 @@
+require "openssl"
+require "base64"
+require "securerandom"
+require "uri"
+require "faraday"
+
+module Connectors
+  # OAuth1.0a — RFC 5849. Two-leg request-token / access-token flow with
+  # HMAC-SHA1/SHA256/SHA512 request signing. n8n parity:
+  # `oauth.service.ts:601-700` (request-token leg) +
+  # `oauth1-credential.controller.ts:43-101` (callback / access-token leg).
+  # n8n uses the `oauth-1.0a` npm package; we implement the signing inline
+  # to keep the engine dependency-free.
+  module OAuth1
+    module_function
+
+    SIG_ALGORITHMS = {
+      "HMAC-SHA1"   => "SHA1",
+      "HMAC-SHA256" => "SHA256",
+      "HMAC-SHA512" => "SHA512"
+    }.freeze
+
+    # Phase 1 of the flow: request the unauthorized request token. Sends an
+    # OAuth1-signed POST to `requestTokenUrl`. Provider returns
+    # `oauth_token` + `oauth_token_secret` (URL-encoded form). We need both
+    # to (a) build the authorize URL the owner is redirected to and (b)
+    # sign the access-token request when the owner returns via callback.
+    def request_token(connector_class, callback_url:)
+      config  = connector_class.oauth1_config or
+        raise Connectors::Error.new("#{connector_class}: oauth1 ... DSL not declared")
+      secrets = Connectors.configuration.oauth_credentials_for(connector_class.connector_key)
+
+      headers = build_authorization_header(
+        method:           "POST",
+        url:              config[:request_token_url],
+        consumer_key:     secrets[:client_id],
+        consumer_secret:  secrets[:client_secret],
+        token:            nil,
+        token_secret:     nil,
+        signature_method: config[:signature_method],
+        extra_params:     { "oauth_callback" => callback_url }
+      )
+
+      response = Faraday.post(config[:request_token_url], "", headers)
+
+      if response.status >= 400
+        raise Connectors::AuthenticationFailed.new(
+          "OAuth1 request_token failed (#{response.status}): #{response.body}",
+          status: response.status, body: response.body
+        )
+      end
+
+      parsed = URI.decode_www_form(response.body.to_s).to_h
+      raise Connectors::AuthenticationFailed.new("OAuth1 request_token response missing oauth_token") \
+        unless parsed["oauth_token"]
+
+      {
+        "oauth_token"        => parsed["oauth_token"],
+        "oauth_token_secret" => parsed["oauth_token_secret"]
+      }
+    end
+
+    # Phase 2: trade the verifier + token for the long-lived access token.
+    def exchange_access_token(connector_class, oauth_token:, oauth_verifier:, oauth_token_secret:)
+      config  = connector_class.oauth1_config or
+        raise Connectors::Error.new("#{connector_class}: oauth1 ... DSL not declared")
+      secrets = Connectors.configuration.oauth_credentials_for(connector_class.connector_key)
+
+      headers = build_authorization_header(
+        method:           "POST",
+        url:              config[:access_token_url],
+        consumer_key:     secrets[:client_id],
+        consumer_secret:  secrets[:client_secret],
+        token:            oauth_token,
+        token_secret:     oauth_token_secret,
+        signature_method: config[:signature_method],
+        extra_params:     { "oauth_verifier" => oauth_verifier }
+      )
+
+      response = Faraday.post(config[:access_token_url], "", headers)
+
+      if response.status >= 400
+        raise Connectors::AuthenticationFailed.new(
+          "OAuth1 access_token exchange failed (#{response.status}): #{response.body}",
+          status: response.status, body: response.body
+        )
+      end
+
+      parsed = URI.decode_www_form(response.body.to_s).to_h
+      raise Connectors::AuthenticationFailed.new("OAuth1 access_token response missing oauth_token") \
+        unless parsed["oauth_token"]
+
+      normalized = {
+        "oauth_token"        => parsed["oauth_token"],
+        "oauth_token_secret" => parsed["oauth_token_secret"],
+        "signature_method"   => config[:signature_method]
+      }
+      connector_class.post_token_exchange(parsed, normalized)
+    end
+
+    # Build an `Authorization: OAuth ...` header for a signed request. Each
+    # `extra_params` entry (e.g. `oauth_callback`, `oauth_verifier`) takes
+    # part in the signature base string and the final header.
+    def build_authorization_header(method:, url:, consumer_key:, consumer_secret:,
+                                   token:, token_secret:, signature_method:, extra_params: {})
+      oauth_params = {
+        "oauth_consumer_key"     => consumer_key.to_s,
+        "oauth_nonce"            => SecureRandom.hex(16),
+        "oauth_signature_method" => signature_method,
+        "oauth_timestamp"        => Time.now.to_i.to_s,
+        "oauth_version"          => "1.0"
+      }
+      oauth_params["oauth_token"] = token if token
+      oauth_params.merge!(extra_params)
+
+      signature = sign(
+        method:           method,
+        url:              url,
+        params:           oauth_params,
+        consumer_secret:  consumer_secret,
+        token_secret:     token_secret,
+        signature_method: signature_method
+      )
+
+      header_params = oauth_params.merge("oauth_signature" => signature)
+      header_value  = header_params.sort.map { |k, v| %(#{percent_encode(k)}="#{percent_encode(v)}") }.join(", ")
+
+      { "Authorization" => "OAuth #{header_value}", "Accept" => "*/*" }
+    end
+
+    # RFC 5849 §3.4.1: signature base string = method & URL & sorted params.
+    # All three are percent-encoded individually then joined by `&`.
+    def sign(method:, url:, params:, consumer_secret:, token_secret:, signature_method:)
+      algo = SIG_ALGORITHMS.fetch(signature_method) do
+        raise Connectors::Error.new("unsupported OAuth1 signature_method #{signature_method.inspect}")
+      end
+
+      sorted_params = params.sort.map { |k, v| "#{percent_encode(k)}=#{percent_encode(v)}" }.join("&")
+      base = [ method.to_s.upcase, percent_encode(url), percent_encode(sorted_params) ].join("&")
+      key  = "#{percent_encode(consumer_secret.to_s)}&#{percent_encode(token_secret.to_s)}"
+
+      Base64.strict_encode64(OpenSSL::HMAC.digest(algo, key, base))
+    end
+
+    # RFC 3986 percent-encoding (stricter than CGI.escape — encodes `*`,
+    # leaves `-._~` intact, uses `%20` not `+` for spaces).
+    def percent_encode(str)
+      str.to_s.b.gsub(/[^A-Za-z0-9\-._~]/) { |c| "%%%02X" % c.ord }
+    end
+  end
+end

data/lib/connectors/permission_check.rb

@@ -0,0 +1,33 @@
+module Connectors
+  # Visibility gate for credentials. Mirrors n8n's two-pronged check
+  # (interfaces.ts:379 + :381) — `genericAuth: true` lets the generic
+  # HTTP-Request node use any credential, and `supportedNodes: [...]`
+  # restricts a credential to a specific node allowlist when set.
+  #
+  # Call from inside a node's execution wrapper before it touches the grant:
+  #
+  #   Connectors::PermissionCheck.permit!(grant, node_type: :slack_send_message)
+  #
+  # Raises `Connectors::CredentialNotPermitted` on a denied match so callers
+  # see one consistent failure mode.
+  module PermissionCheck
+    module_function
+
+    def permits?(grant, node_type:)
+      connector_class = Registry.fetch(grant.connector_key)
+      connector_class.supports_node?(node_type)
+    end
+
+    def permit!(grant, node_type:)
+      connector_class = Registry.fetch(grant.connector_key)
+      return true if connector_class.supports_node?(node_type)
+      reason =
+        if connector_class.supported_nodes.any?
+          "supported_nodes: #{connector_class.supported_nodes.inspect}"
+        else
+          "credential generic-auth-only"
+        end
+      raise CredentialNotPermitted.new(grant.connector_key, node_type, reason: reason)
+    end
+  end
+end

data/lib/connectors/poll_runner.rb

@@ -0,0 +1,50 @@
+module Connectors
+  # Fires one consumer's polling block. Explicit instance keys isolate cursors
+  # and filters even when consumers share credentials. Omitting the key keeps
+  # the legacy, per-grant cursor for existing single-consumer integrations.
+  #
+  # n8n parity: `INodeType#poll(this: IPollFunctions)` (interfaces.ts:2060),
+  # cursor persistence via `getWorkflowStaticData('node')`
+  # (interfaces.ts:1257-1274). The scheduler that decides *when* to fire
+  # this is a workflow-roadmap concern; this primitive just exposes the
+  # one-shot contract.
+  class PollRunner
+    GROUP = "polling".freeze
+
+    def self.run(grant, instance_key: nil)
+      new(grant, instance_key: instance_key).run
+    end
+
+    def initialize(grant, instance_key: nil)
+      @grant     = grant
+      @instance_key = instance_key
+      if !instance_key.nil? && (!instance_key.is_a?(String) || instance_key.blank?)
+        raise ArgumentError, "instance_key must be a nonempty string"
+      end
+      @connector = Registry.fetch(grant.connector_key)
+      @block     = @connector.polling_block or
+        raise Connectors::Error.new("#{@connector}: no polling block declared")
+    end
+
+    def run
+      items_out      = nil
+      static_data_out = nil
+      update_cursor do |sub|
+        items_out       = @block.call(@grant, sub)
+        static_data_out = sub.dup
+      end
+      { items: items_out.is_a?(Array) ? items_out : [], static_data: static_data_out }
+    end
+
+    private
+
+    def update_cursor(&block)
+      if @instance_key
+        state = @grant.poll_states.create_or_find_by!(instance_key: @instance_key)
+        state.update_cursor!(&block)
+      else
+        @grant.update_static_data!(GROUP, &block)
+      end
+    end
+  end
+end

data/lib/connectors/pre_authentication_helpers.rb

@@ -0,0 +1,76 @@
+module Connectors
+  # Helpers passed to a connector's `pre_authentication` block — mirrors
+  # n8n's `IHttpRequestHelper.helpers` surface (n8n source:
+  # packages/workflow/src/interfaces.ts:210-212). The block uses this to
+  # fetch a fresh token from an arbitrary endpoint without needing the
+  # full connector client (which itself depends on credentials that may
+  # not exist yet on first auth).
+  #
+  #   pre_authentication do |credentials, helpers|
+  #     response = helpers.http_request(
+  #       method: :post,
+  #       url:    "#{credentials['url']}/oauth2/token",
+  #       body:   { client_id: credentials['client_id'],
+  #                 client_secret: credentials['client_secret'] },
+  #       headers: { "Content-Type" => "application/x-www-form-urlencoded" }
+  #     )
+  #     { "session_token" => response["access_token"],
+  #       "expires_at"    => Time.now.to_i + response["expires_in"].to_i }
+  #   end
+  class PreAuthenticationHelpers
+    DEFAULT_TIMEOUT = 30
+
+    # Performs the HTTP request through a fresh Faraday connection (no
+    # auth/middleware stack — this runs BEFORE auth injection by design).
+    # Body content-type is inferred from the headers; defaults to JSON.
+    def http_request(method:, url:, body: nil, headers: nil, query: nil, timeout: DEFAULT_TIMEOUT)
+      connection = Faraday.new do |f|
+        f.options.timeout = timeout
+        if json?(headers)
+          f.request  :json
+          f.response :json, content_type: /\bjson\b/
+        elsif form_urlencoded?(headers)
+          f.request  :url_encoded
+          f.response :json, content_type: /\bjson\b/
+        else
+          f.response :json, content_type: /\bjson\b/
+        end
+        f.adapter Faraday.default_adapter
+      end
+
+      response = connection.public_send(method.to_sym, url) do |req|
+        (headers || {}).each { |k, v| req.headers[k.to_s] = v.to_s }
+        req.params = query if query
+        req.body   = body  if body
+      end
+
+      # Match n8n's `helpers.httpRequest` default: non-2xx becomes an error
+      # the pre_authentication hook can catch. Keeps "auth endpoint
+      # exploded" failures visible instead of silently merging a nil token.
+      if response.status >= 400
+        body_preview = response.body.is_a?(String) ? response.body.byteslice(0, 200) : response.body.inspect
+        raise Connectors::ApiError.new(
+          "pre_authentication HTTP #{response.status}: #{body_preview}",
+          status: response.status,
+          body:   response.body
+        )
+      end
+
+      response.body
+    end
+
+    private
+
+    def json?(headers)
+      return true if headers.nil?
+      content_type = (headers["Content-Type"] || headers[:"Content-Type"] || "").to_s
+      content_type.empty? || content_type.include?("json")
+    end
+
+    def form_urlencoded?(headers)
+      (headers || {}).any? do |k, v|
+        k.to_s.downcase == "content-type" && v.to_s.include?("application/x-www-form-urlencoded")
+      end
+    end
+  end
+end

data/lib/connectors/registry.rb

@@ -0,0 +1,38 @@
+module Connectors
+  # In-memory map of connector_key => Connector subclass. Populated when each
+  # connector class is autoloaded (via the `connector key:, ...` DSL call in
+  # the class body).
+  class Registry
+    class << self
+      def register(key, klass)
+        store[key.to_sym] = klass
+      end
+
+      def fetch(key)
+        store.fetch(key.to_sym) { raise UnknownConnector.new(key, known: store.keys) }
+      end
+
+      def registered?(key)
+        store.key?(key.to_sym)
+      end
+
+      def all
+        store.dup
+      end
+
+      def keys
+        store.keys
+      end
+
+      def clear!
+        store.clear
+      end
+
+      private
+
+      def store
+        @store ||= {}
+      end
+    end
+  end
+end

data/lib/connectors/version.rb

@@ -0,0 +1,3 @@
+module Connectors
+  VERSION = "0.1.0"
+end

data/lib/connectors/webhook_context.rb

@@ -0,0 +1,62 @@
+module Connectors
+  # Rich context object passed to `Connector#handle_webhook`. Mirrors n8n's
+  # `IWebhookFunctions` (packages/workflow/src/interfaces.ts:1327-1350): the
+  # handler gets the parsed body AND headers AND query AND a stable
+  # `webhook_name` for multi-webhook providers, without having to thread
+  # `event.request_object.foo` through everywhere.
+  #
+  # Forwards a small set of methods to the underlying `WebhookEvent` so
+  # legacy handlers written against `event.payload_hash` keep working — see
+  # `Connector#handle_webhook` arity detection in `DeliverWebhookJob`.
+  class WebhookContext
+    attr_reader :event
+
+    def initialize(event)
+      @event = event
+    end
+
+    # Parsed body (n8n: `getBodyData()`). Always a Hash — falls back to {}.
+    def body
+      @event.payload_hash
+    end
+    alias payload      body
+    alias payload_hash body
+
+    # Raw (untouched) request body string. nil when the controller couldn't
+    # capture it (form-encoded payloads where Rails consumed the stream).
+    # n8n: `getRequestObject().rawBody`.
+    def raw_body
+      @event.raw_body
+    end
+
+    # All request headers (n8n: `getHeaderData()`). Lowercased keys — same
+    # normalization n8n applies via `req.headers`.
+    def headers
+      @event.headers || {}
+    end
+
+    # Query string parameters (n8n: `getQueryData()`).
+    def query
+      @event.query || {}
+    end
+
+    # Webhook group name that the request hit — `:default` / `:setup` / etc.
+    # n8n: `getWebhookName()`.
+    def webhook_name
+      (@event.webhook_name || "default").to_sym
+    end
+
+    # Provider-side signature header, if present. Convenience accessor —
+    # the controller already extracted this off the raw request for the
+    # idempotency / signature-verification path.
+    def signature
+      @event.signature
+    end
+
+    # The underlying Grant — same as `event.grant`. Lets handlers post back
+    # to the provider via `ctx.grant.connector.client`.
+    def grant
+      @event.grant
+    end
+  end
+end

data/lib/connectors/webhook_lifecycle.rb

@@ -0,0 +1,69 @@
+module Connectors
+  # Runs a connector's webhook_methods callbacks: subscribe = run create
+  # (skipping when check_exists already returns true), unsubscribe = run
+  # delete. State is persisted into `grant.static_data[group_name]`.
+  #
+  # n8n parity: this is the per-trigger activation orchestration that
+  # `cli/src/active-workflow-runner.ts` performs around each
+  # `INodeType#webhookMethods.default.*` call. We provide it as a connector-
+  # side primitive so the eventual workflow-side activation manager can
+  # call into it without re-implementing the gating.
+  class WebhookLifecycle
+    def self.subscribe(grant, hook_url:, webhook_name: :default)
+      new(grant, webhook_name).subscribe(hook_url: hook_url)
+    end
+
+    def self.unsubscribe(grant, webhook_name: :default)
+      new(grant, webhook_name).unsubscribe
+    end
+
+    def initialize(grant, webhook_name)
+      @grant         = grant
+      @webhook_name  = webhook_name.to_sym
+      @connector     = Registry.fetch(grant.connector_key)
+      @group         = @connector.webhook_group(@webhook_name) or
+        raise Connectors::Error.new(
+          "#{@connector}: no webhook_methods declared for group #{@webhook_name.inspect}"
+        )
+    end
+
+    # Mirrors n8n: if checkExists returns true, skip create — provider
+    # already has an equivalent subscription. Otherwise run create.
+    def subscribe(hook_url:)
+      result = nil
+      @grant.update_static_data!(@webhook_name) do |sub|
+        if @group.check_exists && @group.check_exists.call(@grant, hook_url, sub)
+          result = { status: "exists", static_data: sub.dup }
+          next
+        end
+
+        if @group.create.nil?
+          raise Connectors::Error.new("#{@connector}: webhook_methods #{@webhook_name.inspect} has no `create` block")
+        end
+
+        created = @group.create.call(@grant, hook_url, sub)
+        unless created
+          raise Connectors::Error.new("#{@connector}: webhook_methods #{@webhook_name.inspect} create returned false")
+        end
+        result = { status: "created", static_data: sub.dup }
+      end
+      result
+    end
+
+    def unsubscribe
+      if @group.delete.nil?
+        raise Connectors::Error.new("#{@connector}: webhook_methods #{@webhook_name.inspect} has no `delete` block")
+      end
+
+      result = nil
+      @grant.update_static_data!(@webhook_name) do |sub|
+        ok = @group.delete.call(@grant, sub)
+        unless ok
+          raise Connectors::Error.new("#{@connector}: webhook_methods #{@webhook_name.inspect} delete returned false")
+        end
+        result = { status: "deleted", static_data: sub.dup }
+      end
+      result
+    end
+  end
+end

data/lib/connectors/webhook_methods.rb

@@ -0,0 +1,48 @@
+module Connectors
+  # Declarative webhook subscription lifecycle. Mirrors n8n's
+  # `INodeType.webhookMethods.default.{checkExists, create, delete}`
+  # (interfaces.ts:2017, 2091-2095; reference impl in
+  # `packages/nodes-base/nodes/Postmark/PostmarkTrigger.node.ts:114-247`).
+  #
+  # Provider-specific contract:
+  #
+  #   webhook_methods do                    # implicit group: :default
+  #     check_exists do |grant, hook_url, static_data|
+  #       webhooks = grant.connector.client.get("hooks").body["Webhooks"]
+  #       found    = webhooks.find { |h| h["Url"] == hook_url }
+  #       static_data["webhook_id"] = found["ID"] if found
+  #       !found.nil?
+  #     end
+  #
+  #     create do |grant, hook_url, static_data|
+  #       resp = grant.connector.client.post("hooks", { url: hook_url }).body
+  #       static_data["webhook_id"] = resp["ID"]
+  #       true
+  #     end
+  #
+  #     delete do |grant, static_data|
+  #       grant.connector.client.delete("hooks/#{static_data['webhook_id']}")
+  #       static_data.delete("webhook_id")
+  #       true
+  #     end
+  #   end
+  #
+  # Multi-webhook providers (Slack has separate `default` event-delivery
+  # group + `setup` URL-verification group — n8n's `webhooks: IWebhookDescription[]`
+  # at interfaces.ts:2600) declare additional named groups:
+  #
+  #   webhook_methods :setup    do ... end
+  #   webhook_methods :default  do ... end
+  #
+  # The DSL builder for the inner block of `webhook_methods`. Captures each
+  # of the three callbacks into a Group struct.
+  class WebhookMethodsBuilder
+    attr_reader :check_exists_block, :create_block, :delete_block
+
+    def check_exists(&block) @check_exists_block = block end
+    def create(&block)       @create_block       = block end
+    def delete(&block)       @delete_block       = block end
+  end
+
+  WebhookGroup = Struct.new(:name, :check_exists, :create, :delete)
+end

data/lib/connectors/webhooks/verifier.rb

@@ -0,0 +1,31 @@
+module Connectors
+  module Webhooks
+    # Base class for connector-specific webhook signature verifiers.
+    # Subclass and override #verify! to raise Connectors::Webhooks::SignatureInvalid
+    # when the request's signature doesn't match. Typical implementation:
+    #
+    #   class StripeWebhookVerifier < Connectors::Webhooks::Verifier
+    #     def verify!(request)
+    #       signature = request.headers["Stripe-Signature"]
+    #       secret    = @grant.credentials_hash["webhook_secret"]
+    #       expected  = OpenSSL::HMAC.hexdigest("SHA256", secret, request.raw_post)
+    #       unless ActiveSupport::SecurityUtils.secure_compare(signature.to_s, expected)
+    #         raise Connectors::Webhooks::SignatureInvalid.new("bad signature")
+    #       end
+    #     end
+    #   end
+    class Verifier
+      def self.verify!(grant, request)
+        new(grant).verify!(request)
+      end
+
+      def initialize(grant)
+        @grant = grant
+      end
+
+      def verify!(_request)
+        # No-op by default — subclasses override.
+      end
+    end
+  end
+end

data/lib/connectors/webhooks.rb

@@ -0,0 +1,5 @@
+module Connectors
+  module Webhooks
+    class SignatureInvalid < Connectors::Error; end
+  end
+end

data/lib/connectors.rb

@@ -0,0 +1,50 @@
+require "connectors/version"
+require "connectors/engine"
+
+require "connectors/errors"
+require "connectors/configuration"
+require "connectors/grant_policy"
+require "connectors/registry"
+require "connectors/credential_schema"
+require "connectors/credential_type_registry"
+require "connectors/credential_types/http_auth"
+require "connectors/credential_tester"
+require "connectors/auth"
+require "connectors/auth/scheme"
+require "connectors/auth/scheme/oauth2"
+require "connectors/auth/scheme/api_key"
+require "connectors/auth_injection"
+require "connectors/pre_authentication_helpers"
+require "connectors/middleware/auto_refresh"
+require "connectors/middleware/grant_status"
+require "connectors/middleware/rate_limit"
+require "connectors/middleware/error_normalization"
+require "connectors/middleware/authenticate_generic"
+require "connectors/middleware/pre_authentication"
+require "connectors/client_builder"
+require "connectors/action"
+require "connectors/action_builder"
+require "connectors/connector"
+require "connectors/action_runner"
+require "connectors/permission_check"
+require "connectors/oauth"
+require "connectors/oauth/state"
+require "connectors/oauth/grant_writer"
+require "connectors/oauth/authorize_url"
+require "connectors/oauth/client_authentication"
+require "connectors/oauth/token_response"
+require "connectors/oauth/token_exchange"
+require "connectors/oauth/client_credentials"
+require "connectors/oauth/pkce"
+require "connectors/oauth/revoke"
+require "connectors/oauth1"
+require "connectors/webhooks"
+require "connectors/webhooks/verifier"
+require "connectors/webhook_methods"
+require "connectors/webhook_lifecycle"
+require "connectors/webhook_context"
+require "connectors/poll_runner"
+require "connectors/mcp"
+
+module Connectors
+end