hooksniff 0.1.0 → 0.3.0

data/lib/hooksniff/client.rb

@@ -1,213 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "models"
-
-module HookSniff
-  class Client
-    attr_reader :endpoints, :webhooks
-
-    def initialize(api_key:, base_url: nil, timeout: nil)
-      @api_key = api_key
-      @base_url = (base_url || DEFAULT_BASE_URL).chomp("/")
-      @timeout = timeout || DEFAULT_TIMEOUT
-      @endpoints = EndpointsResource.new(self)
-      @webhooks = WebhooksResource.new(self)
-    end
-
-    # Get platform statistics
-    def stats
-      resp = request(:get, "/stats")
-      Models::Stats.new(resp)
-    end
-
-    # @api internal
-    def request(method, path, body: nil)
-      uri = URI("#{@base_url}#{path}")
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = (uri.scheme == "https")
-      http.open_timeout = @timeout
-      http.read_timeout = @timeout
-
-      case method
-      when :get
-        req = Net::HTTP::Get.new(uri)
-      when :post
-        req = Net::HTTP::Post.new(uri)
-      when :delete
-        req = Net::HTTP::Delete.new(uri)
-      else
-        raise ArgumentError, "Unsupported HTTP method: #{method}"
-      end
-
-      req["Authorization"] = "Bearer #{@api_key}"
-      req["Content-Type"] = "application/json"
-      req["User-Agent"] = "hooksniff-ruby/#{VERSION}"
-
-      req.body = JSON.generate(body) if body
-
-      response = http.request(req)
-
-      case response.code.to_i
-      when 200..299
-        content_type = response["content-type"] || ""
-        if content_type.include?("text/csv")
-          response.body
-        else
-          JSON.parse(response.body) rescue response.body
-        end
-      when 400
-        raise ValidationError, parse_error_message(response)
-      when 401
-        raise AuthenticationError, parse_error_message(response)
-      when 404
-        raise NotFoundError, parse_error_message(response)
-      when 413
-        raise PayloadTooLargeError, parse_error_message(response)
-      when 429
-        raise RateLimitError, parse_error_message(response)
-      else
-        raise Error, "HTTP #{response.code}: #{parse_error_message(response)}"
-      end
-    end
-
-    private
-
-    def parse_error_message(response)
-      body = JSON.parse(response.body)
-      body.dig("error", "message") || "HTTP #{response.code}"
-    rescue
-      "HTTP #{response.code}"
-    end
-  end
-
-  class EndpointsResource
-    def initialize(client)
-      @client = client
-    end
-
-    def create(url:, description: nil, retry_policy: nil)
-      body = { url: url }
-      body[:description] = description if description
-      if retry_policy
-        body[:retry_policy] = {
-          max_attempts: retry_policy[:max_attempts],
-          backoff: retry_policy[:backoff],
-          initial_delay_secs: retry_policy[:initial_delay_secs],
-          max_delay_secs: retry_policy[:max_delay_secs]
-        }.compact
-      end
-
-      resp = @client.request(:post, "/endpoints", body: body)
-      Models::Endpoint.new(resp)
-    end
-
-    def get(endpoint_id)
-      resp = @client.request(:get, "/endpoints/#{endpoint_id}")
-      Models::Endpoint.new(resp)
-    end
-
-    def list(page: 1, per_page: 20)
-      params = { page: page.to_s, per_page: per_page.to_s }
-      query = URI.encode_www_form(params)
-      resp = @client.request(:get, "/endpoints?#{query}")
-      {
-        endpoints: (resp["endpoints"] || resp).map { |ep| Models::Endpoint.new(ep) },
-        total: resp["total"] || 0,
-        page: resp["page"] || page,
-        per_page: resp["per_page"] || per_page
-      }
-    end
-
-    def delete(endpoint_id)
-      resp = @client.request(:delete, "/endpoints/#{endpoint_id}")
-      resp["deleted"] != false
-    end
-
-    def rotate_secret(endpoint_id)
-      @client.request(:post, "/endpoints/#{endpoint_id}/rotate-secret")
-    end
-
-    private
-  end
-
-  class WebhooksResource
-    def initialize(client)
-      @client = client
-    end
-
-    # Send a webhook
-    def send(endpoint_id:, event: nil, data:)
-      body = { endpoint_id: endpoint_id, data: data }
-      body[:event] = event if event
-      resp = @client.request(:post, "/webhooks", body: body)
-      Models::Delivery.new(resp)
-    end
-
-    # Get a delivery by ID
-    def get(delivery_id)
-      resp = @client.request(:get, "/webhooks/#{delivery_id}")
-      Models::Delivery.new(resp)
-    end
-
-    # List deliveries with optional filters
-    def list(status: nil, page: 1, per_page: 20)
-      params = { page: page.to_s, per_page: per_page.to_s }
-      params[:status] = status if status
-      query = URI.encode_www_form(params)
-      resp = @client.request(:get, "/webhooks?#{query}")
-      Models::DeliveryList.new(resp)
-    end
-
-    # Replay a delivery
-    def replay(delivery_id)
-      resp = @client.request(:post, "/webhooks/#{delivery_id}/replay")
-      Models::Delivery.new(resp)
-    end
-
-    # Send multiple webhooks in a batch
-    def batch(webhooks)
-      body = {
-        webhooks: webhooks.map do |w|
-          item = { endpoint_id: w[:endpoint_id], data: w[:data] }
-          item[:event] = w[:event] if w[:event]
-          item
-        end
-      }
-      resp = @client.request(:post, "/webhooks/batch", body: body)
-      Models::BatchResult.new(resp)
-    end
-
-    # Get delivery attempts
-    def attempts(delivery_id)
-      resp = @client.request(:get, "/webhooks/#{delivery_id}/attempts")
-      resp.map { |a| Models::DeliveryAttempt.new(a) }
-    end
-
-    # Export deliveries
-    def export(format: nil, status: nil, date_from: nil, date_to: nil)
-      params = {}
-      params[:format] = format if format
-      params[:status] = status if status
-      params[:date_from] = date_from if date_from
-      params[:date_to] = date_to if date_to
-      query = URI.encode_www_form(params)
-      query = "?#{query}" unless query.empty?
-
-      resp = @client.request(:get, "/webhooks/export#{query}")
-      return resp if format == "csv"
-
-      resp.map { |d| Models::Delivery.new(d) }
-    end
-
-    # Search deliveries with filters
-    def search(query: nil, event: nil, status: nil, endpoint_id: nil, page: 1, per_page: 20)
-      params = { page: page.to_s, per_page: per_page.to_s }
-      params[:q] = query if query
-      params[:event] = event if event
-      params[:status] = status if status
-      params[:endpoint_id] = endpoint_id if endpoint_id
-      query_str = URI.encode_www_form(params)
-      @client.request(:get, "/search?#{query_str}")
-    end
-  end
-end

data/lib/hooksniff/errors.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module HookSniff
-  class Error < StandardError
-    attr_reader :status_code, :error_code
-
-    def initialize(message, status_code: nil, error_code: nil)
-      super(message)
-      @status_code = status_code
-      @error_code = error_code
-    end
-  end
-
-  class AuthenticationError < Error
-    def initialize(message = "Unauthorized: invalid or missing API key")
-      super(message, status_code: 401, error_code: "UNAUTHORIZED")
-    end
-  end
-
-  class NotFoundError < Error
-    def initialize(message = "Resource not found")
-      super(message, status_code: 404, error_code: "NOT_FOUND")
-    end
-  end
-
-  class RateLimitError < Error
-    def initialize(message = "Rate limit exceeded")
-      super(message, status_code: 429, error_code: "RATE_LIMIT_EXCEEDED")
-    end
-  end
-
-  class ValidationError < Error
-    def initialize(message = "Bad request")
-      super(message, status_code: 400, error_code: "BAD_REQUEST")
-    end
-  end
-
-  class PayloadTooLargeError < Error
-    def initialize(message = "Payload too large")
-      super(message, status_code: 413, error_code: "PAYLOAD_TOO_LARGE")
-    end
-  end
-end

data/lib/hooksniff/models.rb

@@ -1,136 +0,0 @@
-# frozen_string_literal: true
-
-module HookSniff
-  module Models
-    class Endpoint
-      attr_reader :id, :url, :description, :is_active, :retry_policy, :created_at
-
-      def initialize(data)
-        @id = data["id"]
-        @url = data["url"]
-        @description = data["description"]
-        @is_active = data["is_active"]
-        @retry_policy = data["retry_policy"] ? RetryPolicy.new(data["retry_policy"]) : nil
-        @created_at = data["created_at"]
-      end
-
-      def to_h
-        {
-          id: @id,
-          url: @url,
-          description: @description,
-          is_active: @is_active,
-          retry_policy: @retry_policy&.to_h,
-          created_at: @created_at
-        }
-      end
-    end
-
-    class RetryPolicy
-      attr_reader :max_attempts, :backoff, :initial_delay_secs, :max_delay_secs
-
-      def initialize(data)
-        @max_attempts = data["max_attempts"]
-        @backoff = data["backoff"]
-        @initial_delay_secs = data["initial_delay_secs"]
-        @max_delay_secs = data["max_delay_secs"]
-      end
-
-      def to_h
-        {
-          max_attempts: @max_attempts,
-          backoff: @backoff,
-          initial_delay_secs: @initial_delay_secs,
-          max_delay_secs: @max_delay_secs
-        }.compact
-      end
-    end
-
-    class Delivery
-      attr_reader :id, :endpoint_id, :event, :status, :attempt_count, :response_status, :replay_count, :created_at
-
-      def initialize(data)
-        @id = data["id"]
-        @endpoint_id = data["endpoint_id"]
-        @event = data["event"]
-        @status = data["status"]
-        @attempt_count = data["attempt_count"] || 0
-        @response_status = data["response_status"]
-        @replay_count = data["replay_count"] || 0
-        @created_at = data["created_at"]
-      end
-
-      def to_h
-        {
-          id: @id,
-          endpoint_id: @endpoint_id,
-          event: @event,
-          status: @status,
-          attempt_count: @attempt_count,
-          response_status: @response_status,
-          replay_count: @replay_count,
-          created_at: @created_at
-        }
-      end
-    end
-
-    class DeliveryAttempt
-      attr_reader :id, :attempt_number, :status_code, :response_body, :duration_ms, :error_message, :created_at
-
-      def initialize(data)
-        @id = data["id"]
-        @attempt_number = data["attempt_number"]
-        @status_code = data["status_code"]
-        @response_body = data["response_body"]
-        @duration_ms = data["duration_ms"]
-        @error_message = data["error_message"]
-        @created_at = data["created_at"]
-      end
-
-      def to_h
-        {
-          id: @id,
-          attempt_number: @attempt_number,
-          status_code: @status_code,
-          response_body: @response_body,
-          duration_ms: @duration_ms,
-          error_message: @error_message,
-          created_at: @created_at
-        }
-      end
-    end
-
-    class DeliveryList
-      attr_reader :deliveries, :total, :page, :per_page
-
-      def initialize(data)
-        @deliveries = (data["deliveries"] || []).map { |d| Delivery.new(d) }
-        @total = data["total"]
-        @page = data["page"]
-        @per_page = data["per_page"]
-      end
-    end
-
-    class BatchResult
-      attr_reader :deliveries, :errors
-
-      def initialize(data)
-        @deliveries = (data["deliveries"] || []).map { |d| Delivery.new(d) }
-        @errors = data["errors"] || []
-      end
-    end
-
-    class Stats
-      attr_reader :total_deliveries, :delivered, :failed, :pending, :success_rate, :endpoints_count
-
-      def initialize(data)
-        @total_deliveries = data["total_deliveries"]
-        @delivered = data["delivered"]
-        @failed = data["failed"]
-        @pending = data["pending"]
-        @success_rate = data["success_rate"]
-        @endpoints_count = data["endpoints_count"]
-      end
-    end
-  end
-end

data/lib/hooksniff/verification.rb

@@ -1,134 +0,0 @@
-# frozen_string_literal: true
-
-module HookSniff
-  # Verify a webhook signature using HMAC-SHA256.
-  #
-  # @param payload [String] The raw request body
-  # @param signature [String] The signature from the X-Hookrelay-Signature header
-  # @param secret [String] The endpoint's signing secret (starts with "whsec_")
-  # @return [Boolean] true if the signature is valid
-  def self.verify_signature(payload, signature, secret)
-    return false if payload.nil? || payload.empty?
-    return false if signature.nil? || signature.empty?
-    return false if secret.nil? || secret.empty?
-
-    expected_hex = signature.start_with?("sha256=") ? signature[7..] : signature
-
-    computed = OpenSSL::HMAC.hexdigest("SHA256", secret, payload)
-
-    # Constant-time comparison to prevent timing attacks
-    secure_compare(computed, expected_hex)
-  rescue
-    false
-  end
-
-  # Verify a webhook signature from an incoming request (Standard Webhooks + Svix compatible).
-  #
-  # Supports both Standard Webheaders headers (webhook-id, webhook-signature, webhook-timestamp)
-  # and Svix headers (svix-id, svix-signature, svix-timestamp) as fallback.
-  #
-  # @param payload [String] The raw request body
-  # @param headers [Hash] The request headers (symbol or string keys)
-  # @param secret [String] The endpoint's signing secret
-  # @param tolerance_secs [Integer] Max age in seconds (default: 300)
-  # @return [Hash] { valid: bool, payload: parsed_data, error: string }
-  def self.verify_webhook_from_headers(payload:, headers:, secret:, tolerance_secs: 300)
-    # Normalize header keys to lowercase strings
-    normalized = headers.transform_keys { |k| k.to_s.downcase }
-
-    msg_id = normalized["webhook-id"]
-    timestamp = normalized["webhook-timestamp"]
-    signature_header = normalized["webhook-signature"]
-
-    # Fallback to Svix headers
-    unless msg_id && timestamp && signature_header
-      msg_id ||= normalized["svix-id"]
-      timestamp ||= normalized["svix-timestamp"]
-      signature_header ||= normalized["svix-signature"]
-    end
-
-    verify_webhook(
-      payload: payload,
-      msg_id: msg_id,
-      timestamp: timestamp,
-      signature_header: signature_header,
-      secret: secret,
-      tolerance_secs: tolerance_secs,
-    )
-  end
-
-  # Verify a webhook signature from an incoming request (Standard Webhooks compatible).
-  #
-  # @param payload [String] The raw request body
-  # @param msg_id [String] The webhook-id header
-  # @param timestamp [String] The webhook-timestamp header
-  # @param signature_header [String] The webhook-signature header
-  # @param secret [String] The endpoint's signing secret
-  # @param tolerance_secs [Integer] Max age in seconds (default: 300)
-  # @return [Hash] { valid: bool, payload: parsed_data, error: string }
-  def self.verify_webhook(payload:, msg_id:, timestamp:, signature_header:, secret:, tolerance_secs: 300)
-    return { valid: false, error: "Missing webhook-id header" } if msg_id.nil? || msg_id.empty?
-    return { valid: false, error: "Missing webhook-timestamp header" } if timestamp.nil? || timestamp.empty?
-    return { valid: false, error: "Missing webhook-signature header" } if signature_header.nil? || signature_header.empty?
-    return { valid: false, error: "Missing request body" } if payload.nil? || payload.empty?
-
-    ts = timestamp.to_i
-    return { valid: false, error: "Invalid webhook timestamp" } if ts == 0
-
-    now = Time.now.to_i
-
-    if now - ts > tolerance_secs
-      return { valid: false, error: "Message timestamp too old" }
-    end
-    if ts > now + tolerance_secs
-      return { valid: false, error: "Message timestamp too new" }
-    end
-
-    # Compute expected signature
-    signed_content = "#{msg_id}.#{timestamp}.#{payload}"
-    secret_bytes = decode_secret(secret)
-
-    expected_sig = Base64.strict_encode64(
-      OpenSSL::HMAC.digest("SHA256", secret_bytes, signed_content)
-    )
-    expected_full = "v1,#{expected_sig}"
-
-    # Check each signature in the header (space-separated)
-    signatures = signature_header.split(" ")
-    verified = signatures.any? do |sig|
-      sig_stripped = sig.strip
-      next unless sig_stripped.start_with?("v1,")
-      secure_compare(sig_stripped, expected_full)
-    end
-
-    unless verified
-      return { valid: false, error: "Invalid webhook signature" }
-    end
-
-    # Parse the payload
-    begin
-      parsed = JSON.parse(payload)
-      { valid: true, payload: parsed }
-    rescue JSON::ParserError
-      { valid: true, payload: payload }
-    end
-  end
-
-  private_class_method def self.decode_secret(secret)
-    stripped = secret.start_with?("whsec_") ? secret[6..] : secret
-    # Add padding in case secret is unpadded base64
-    Base64.strict_decode64(stripped + "==")
-  rescue ArgumentError
-    secret.bytes.pack("C*")
-  end
-
-  # Constant-time string comparison
-  def self.secure_compare(a, b)
-    return false if a.nil? || b.nil?
-    return false if a.bytesize != b.bytesize
-
-    result = 0
-    a.bytes.zip(b.bytes) { |x, y| result |= x ^ y }
-    result == 0
-  end
-end

data/lib/hooksniff/version.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-module HookSniff
-  VERSION = "0.1.0"
-end

data/lib/hooksniff.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require "net/http"
-require "uri"
-require "openssl"
-
-require_relative "hooksniff/version"
-require_relative "hooksniff/errors"
-require_relative "hooksniff/client"
-require_relative "hooksniff/verification"
-
-module HookSniff
-  # Default API base URL
-  DEFAULT_BASE_URL = "https://hooksniff-api-1046140057667.europe-west1.run.app/v1"
-
-  # Default request timeout in seconds
-  DEFAULT_TIMEOUT = 30
-end