hooksniff 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d57c84b0d53e5a0affb8331d0a7b6f875783237e8e39791c472be7dde9b55633
+  data.tar.gz: c0515dc716d6c05b45779530f87af8c0bfa1be1e7de760055510311ebbdf60c8
+SHA512:
+  metadata.gz: 68b178b1d814e4112af255c973522bc461d21042ab835c90dbc4ad7d4a7be29c1fd5c6d9ff0c7416cd79776e90422dc30e525def3f125c1cf8a5662b9eea1f01
+  data.tar.gz: f1c27cbb1954ab4a1785cdd351bce37d1bdce6b695282925c07a2c90f19ffbf4927ca2e702f089666679f0ceafaef7844777d4a97322101b8818f363ee084229

data/README.md

@@ -0,0 +1,220 @@
+# HookSniff Ruby SDK
+
+Official Ruby client for the [HookSniff](https://hooksniff.vercel.app) webhook delivery service.
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "hooksniff"
+```
+
+Or install directly:
+
+```bash
+gem install hooksniff
+```
+
+## Quick Start
+
+```ruby
+require "hooksniff"
+
+# Initialize client
+client = HookSniff::Client.new(api_key: "hr_live_your_api_key_here")
+
+# Create a webhook endpoint
+endpoint = client.endpoints.create(
+  url: "https://myapp.com/webhook",
+  description: "Order notifications"
+)
+puts "Endpoint created: #{endpoint[:id]}"
+
+# Send a webhook
+delivery = client.webhooks.send(
+  endpoint_id: endpoint[:id],
+  event: "order.created",
+  data: { order_id: "12345", amount: 99.99 }
+)
+puts "Delivery queued: #{delivery[:id]}, status: #{delivery[:status]}"
+
+# Check delivery status
+status = client.webhooks.get(delivery[:id])
+puts "Status: #{status[:status]}, attempts: #{status[:attempt_count]}"
+
+# List deliveries
+deliveries = client.webhooks.list(status: "failed", page: 1)
+deliveries[:deliveries].each do |d|
+  puts "  #{d[:id]}: #{d[:status]}"
+end
+
+# Replay a failed delivery
+replayed = client.webhooks.replay(delivery[:id])
+puts "Replay queued: #{replayed[:id]}"
+```
+
+## Batch Webhooks
+
+Send multiple webhooks in a single request (max 100):
+
+```ruby
+results = client.webhooks.batch([
+  { endpoint_id: "ep_1", event: "order.created", data: { order_id: "12345" } },
+  { endpoint_id: "ep_2", event: "payment.completed", data: { payment_id: "pay_67890" } }
+])
+
+puts "Delivered: #{results[:deliveries].length}"
+puts "Errors: #{results[:errors].length}"
+results[:errors].each do |err|
+  puts "  Item #{err['index']}: #{err['error']}"
+end
+```
+
+## Retry Policy
+
+Configure custom retry behavior when creating endpoints:
+
+```ruby
+endpoint = client.endpoints.create(
+  url: "https://myapp.com/webhook",
+  description: "Critical notifications",
+  retry_policy: {
+    max_attempts: 5,
+    backoff: "exponential",
+    initial_delay_secs: 10,
+    max_delay_secs: 3600
+  }
+)
+```
+
+## Delivery Attempts
+
+Inspect individual delivery attempts:
+
+```ruby
+attempts = client.webhooks.attempts(delivery[:id])
+attempts.each do |attempt|
+  puts "  Attempt #{attempt[:attempt_number]}: status=#{attempt[:status_code]}, " \
+       "duration=#{attempt[:duration_ms]}ms"
+  puts "    Error: #{attempt[:error_message]}" if attempt[:error_message]
+end
+```
+
+## Export Logs
+
+Export webhook logs as JSON or CSV:
+
+```ruby
+# JSON export
+logs = client.webhooks.export(format: "json", status: "failed")
+
+# CSV export
+csv_data = client.webhooks.export(format: "csv", date_from: "2024-01-01")
+File.write("webhooks.csv", csv_data)
+```
+
+## Signature Verification
+
+Verify incoming webhook signatures in your handler:
+
+```ruby
+require "hooksniff"
+require "sinatra"
+
+post "/webhook" do
+  payload = request.body.read
+  signature = request.env["HTTP_X_HOOKRELAY_SIGNATURE"]
+  secret = "whsec_your_endpoint_signing_secret"
+
+  unless HookSniff.verify_signature(payload, signature, secret)
+    halt 401, { error: "Invalid signature" }.to_json
+  end
+
+  data = JSON.parse(payload)
+  puts "Received event: #{data['event']}"
+  content_type :json
+  { received: true }.to_json
+end
+```
+
+### Standard Webhooks Verification
+
+For Standard Webhooks compatible verification:
+
+```ruby
+result = HookSniff.verify_webhook(
+  payload: request.body.read,
+  msg_id: request.env["HTTP_WEBHOOK_ID"],
+  timestamp: request.env["HTTP_WEBHOOK_TIMESTAMP"],
+  signature_header: request.env["HTTP_WEBHOOK_SIGNATURE"],
+  secret: "whsec_..."
+)
+
+unless result[:valid]
+  halt 401, { error: result[:error] }.to_json
+end
+
+puts "Event: #{result[:payload]['event']}"
+```
+
+## Error Handling
+
+```ruby
+begin
+  delivery = client.webhooks.send(
+    endpoint_id: "nonexistent",
+    event: "test.event",
+    data: { test: true }
+  )
+rescue HookSniff::AuthenticationError => e
+  puts "Invalid API key"
+rescue HookSniff::NotFoundError => e
+  puts "Endpoint not found"
+rescue HookSniff::RateLimitError => e
+  puts "Rate limit exceeded - try again later"
+rescue HookSniff::ValidationError => e
+  puts "Invalid request: #{e.message}"
+rescue HookSniff::PayloadTooLargeError => e
+  puts "Payload exceeds maximum size"
+end
+```
+
+## API Reference
+
+### `HookSniff::Client.new(api_key:, base_url: nil, timeout: nil)`
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `api_key` | `String` | required | Your HookSniff API key |
+| `base_url` | `String` | `https://hooksniff-api-1046140057667.europe-west1.run.app/v1` | API base URL |
+| `timeout` | `Integer` | `30` | Request timeout in seconds |
+
+### `client.endpoints`
+
+- `.create(url:, description: nil, retry_policy: nil)` → `Hash`
+- `.get(endpoint_id)` → `Hash`
+- `.list` → `Array<Hash>`
+- `.delete(endpoint_id)` → `Boolean`
+
+### `client.webhooks`
+
+- `.send(endpoint_id:, data:, event: nil)` → `Hash`
+- `.get(delivery_id)` → `Hash`
+- `.list(status: nil, page: 1, per_page: 20)` → `Hash`
+- `.replay(delivery_id)` → `Hash`
+- `.batch(webhooks)` → `Hash`
+- `.attempts(delivery_id)` → `Array<Hash>`
+- `.export(format: nil, status: nil, date_from: nil, date_to: nil)` → `Array<Hash> | String`
+
+### `HookSniff.verify_signature(payload, signature, secret)` → `Boolean`
+
+Verify a webhook signature using HMAC-SHA256.
+
+### `HookSniff.verify_webhook(payload:, msg_id:, timestamp:, signature_header:, secret:, tolerance_secs: 300)` → `Hash`
+
+Verify a webhook using Standard Webheaders headers.
+
+## License
+
+MIT

data/lib/hooksniff/client.rb

@@ -0,0 +1,213 @@
+# 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

@@ -0,0 +1,43 @@
+# 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

@@ -0,0 +1,136 @@
+# 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

@@ -0,0 +1,134 @@
+# 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

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

data/lib/hooksniff.rb

@@ -0,0 +1,19 @@
+# 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

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: hooksniff
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- HookSniff
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-05-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: net-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: uri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.12.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.12.0
+description: Ruby SDK for the HookSniff webhook delivery platform. Provides API client,
+  webhook sending, delivery management, and signature verification.
+email:
+- support@hooksniff.dev
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/hooksniff.rb
+- lib/hooksniff/client.rb
+- lib/hooksniff/errors.rb
+- lib/hooksniff/models.rb
+- lib/hooksniff/verification.rb
+- lib/hooksniff/version.rb
+homepage: https://github.com/hooksniff/hooksniff-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.3
+signing_key:
+specification_version: 4
+summary: Official Ruby client for HookSniff webhook delivery service
+test_files: []