hookd-client 1.3.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eeded85d2f08978163e752d64342ca5e52fd1cf1fcaade7da0305caeb53e03b5
-  data.tar.gz: 966b9eaf4f9d25549f0473471e446628af82c8ea160e5ebbefef518aa1a6fa08
+  metadata.gz: 85c9d3bb1f54b986026f6815e255ecdb515ad9e9bae6a4c78708fcf0f5d133b2
+  data.tar.gz: a8a93a75b73de9eba86444c0104643388f64fb71969c19588465071a6aa2272a
 SHA512:
-  metadata.gz: 0224226f06a4996e6034caabb6182f31d9a7848262a44bd8ed0571fe898a7706f4b95c46bdb0e5617c0bc04f948fc5dc8e5bffbb46cd20de04d9bdcacbe0b2fe
-  data.tar.gz: 88e85eab06e2d351b6231f2769104b6d6a3320ae1cb2ccf68f432dad732a689ee5f50386ca69199534a76fb09425ddfd70f7d711b03b8e4d836e2b25415784ad
+  metadata.gz: fd9081da69578bdea39b76d8bedc0c6d71b1b2a82927b3fc07abadf345d20d10ad58797ea8689d0b84b0ea69d9609d23cb7bdcbd07b5f823fab0afb87eb2f8c7
+  data.tar.gz: caf8b630d270276df0d4a7b05b0bb30c5a96e446ff6b87f3eb9b2b5166789960a768c5545f733e91b58d6404ba5dcff1cf5b044b33798655df9dc5f186a0d1be

data/README.md

@@ -1,6 +1,6 @@
 # Hookd Ruby Client
 
-Ruby client library for [Hookd](https://github.com/JoshuaMart/hookd/server), a DNS/HTTP interaction server for security testing and debugging.
+Ruby client library for [Hookd](https://github.com/JoshuaMart/hookd/server), a DNS/HTTP/SMTP interaction server for security testing and debugging.
 
 ## Installation
 
@@ -35,6 +35,7 @@ hook = client.register
 puts "DNS endpoint: #{hook.dns}"
 puts "HTTP endpoint: #{hook.http}"
 puts "HTTPS endpoint: #{hook.https}"
+puts "Mail endpoint: #{hook.smtp}" if hook.smtp
 
 # Make a request to the HTTP endpoint to simulate an interaction
 Typhoeus.get(hook.http)
@@ -46,6 +47,8 @@ interactions.each do |interaction|
     puts "DNS query: #{interaction.data}"
   elsif interaction.http?
     puts "HTTP request: #{interaction.data}"
+  elsif interaction.smtp?
+    puts "Mail from #{interaction.data['mail_from']}: #{interaction.data['subject']}"
   end
 end
 ```
@@ -95,6 +98,8 @@ results.each do |hook_id, result|
         puts "   - DNS: #{interaction.data['qname']} (#{interaction.data['qtype']})"
       elsif interaction.http?
         puts "   - HTTP: #{interaction.data['method']} #{interaction.data['path']}"
+      elsif interaction.smtp?
+        puts "   - SMTP: #{interaction.data['mail_from']} (#{interaction.data['subject']})"
       end
     end
   end
@@ -108,6 +113,10 @@ The client requires two configuration parameters:
 - `server`: The Hookd server URL (e.g., `https://hookd.example.com`)
 - `token`: Authentication token for API access
 
+An optional `max_response_bytes:` caps the response payload the client will read
+(64 MiB by default; zero or less disables it). Exceeding it raises
+`Hookd::ResponseTooLargeError`.
+
 ### API Reference
 
 #### `Hookd::Client`
@@ -116,7 +125,7 @@ Main client class for interacting with the Hookd server.
 
 ##### `#register(count: nil)`
 
-Register one or more hooks and get DNS/HTTP endpoints.
+Register one or more hooks and get their DNS, HTTP and (when the server runs a mail listener) SMTP endpoints.
 
 **Single hook (default):**
 ```ruby
@@ -155,10 +164,39 @@ Raises:
 - `Hookd::ServerError` - Server error (5xx)
 - `Hookd::ConnectionError` - Connection failed
 
-##### `#activity`
+##### `#register_batch(specs)`
+
+Register one hook per spec in a single request — e.g. one per injectable field,
+each carrying its own context. Hooks come back in spec order; the server
+creates all of them or none (up to 500 per call).
+
+```ruby
+hooks = client.register_batch([
+  { ttl: "7d", metadata: { endpoint_id: "e_412", param: "bio" } },
+  { ttl: "7d", metadata: { endpoint_id: "e_413", param: "name" } }
+])
+# => [#<Hookd::Hook ...>, #<Hookd::Hook ...>]
+```
+
+##### `#hooks(metadata: nil)`
+
+List the long-lived hooks (without interactions) whose top-level metadata
+matches every key/value given; omit `metadata` to list all. Useful to rebuild
+your hook list after losing local state.
+
+```ruby
+client.hooks(metadata: { run_id: "0f3a" })
+```
+
+##### `#activity(metadata: nil)`
+
+Pass `metadata:` to keep only matching hooks, so workers sharing a server each
+see only their own.
+
 
 List the long-lived hooks that currently have pending interactions, so you can
-discover which fired without polling each one; drain the details with `#poll`.
+discover which fired without polling each one; fetch the details with `#read`
+(or `#poll` to drain). Skip hooks whose `last_seq` is not above your cursor.
 
 ```ruby
 client.activity.each do |a|
@@ -239,6 +277,39 @@ Raises:
 - **Efficiency**: Automatic connection reuse with HTTPX
 - **Atomic**: Consistent snapshot of all hooks
 
+##### `#read(hook_id, after:)` and `#ack(hook_id, through:)`
+
+`#poll` deletes what it returns, so a crash before you store the result loses
+it. `#read` leaves the interactions on the server; `#ack` them once your own
+write has committed. Keep the cursor (the last `seq` stored) on your side.
+
+```ruby
+read = client.read(hook_id, after: cursor)
+warn "interactions up to seq #{read.dropped_through} were evicted unread" if read.lost?(cursor)
+
+unless read.interactions.empty?
+  last = read.interactions.last.seq
+  store(read.interactions)          # raises: nothing acknowledged, read again later
+  client.ack(hook_id, through: last) # => number of interactions removed
+  cursor = last
+end
+```
+
+`#read` returns a `Hookd::CursorRead`; `#ack` returns the number removed. Both
+raise `Hookd::NotFoundError` for an unknown hook and `Hookd::ServerError` when
+the server fails, so a failed ack is never mistaken for success.
+
+##### `#read_batch(cursors)` and `#ack_batch(cursors)`
+
+The same for many hooks in one request, keyed by hook ID:
+
+```ruby
+client.read_batch("abc123" => 4, "def456" => 0)
+# => { "abc123" => { interactions: [...], dropped_through: 0, error: nil }, ... }
+client.ack_batch("abc123" => 6)
+# => { "abc123" => { acknowledged: 2, error: nil } }
+```
+
 ##### `#metrics`
 
 Get server metrics (requires authentication).
@@ -259,6 +330,7 @@ Attributes:
 - `dns` (String) - DNS endpoint
 - `http` (String) - HTTP endpoint
 - `https` (String) - HTTPS endpoint
+- `smtp` (String, nil) - Mail address (nil unless the server runs a mail listener)
 - `created_at` (String) - Creation timestamp
 - `expires_at` (String, nil) - Expiry timestamp (long-lived hooks)
 - `metadata` (Hash, nil) - Metadata attached at registration
@@ -271,19 +343,35 @@ Attributes:
 - `hook` (`Hookd::Hook`) - The long-lived hook that fired
 - `pending_count` (Integer) - Number of interactions awaiting poll
 - `last_interaction_at` (String) - Timestamp of the most recent interaction
+- `last_seq` (Integer) - Seq of the most recent interaction
+
+#### `Hookd::CursorRead`
+
+Returned by `#read`.
+
+Attributes:
+- `interactions` (Array<`Hookd::Interaction`>) - Interactions past the cursor
+- `dropped_through` (Integer) - Highest seq evicted before acknowledgement
+- `metadata` (Hash, nil) - Metadata attached at registration
+
+Methods:
+- `#lost?(after)` - True if interactions past `after` were evicted unread
 
 #### `Hookd::Interaction`
 
-Represents a captured DNS or HTTP interaction.
+Represents a captured DNS, HTTP or SMTP interaction.
 
 Attributes:
-- `type` (String) - Interaction type ("dns" or "http")
+- `id` (String) - Interaction identifier
+- `seq` (Integer) - Per-hook sequence number, the cursor for `#read` / `#ack`
+- `type` (String) - Interaction type ("dns", "http" or "smtp")
 - `timestamp` (String) - When the interaction was captured
 - `data` (Hash) - Interaction details
 
 Methods:
 - `#dns?` - Returns true if this is a DNS interaction
 - `#http?` - Returns true if this is an HTTP interaction
+- `#smtp?` - Returns true if this is an SMTP interaction
 
 ### Error Handling
 
@@ -307,3 +395,4 @@ Exception hierarchy:
   - `Hookd::NotFoundError` - 404 Not Found
   - `Hookd::ServerError` - 5xx Server Error
   - `Hookd::ConnectionError` - Network/connection errors
+  - `Hookd::ResponseTooLargeError` - Response above `max_response_bytes`

data/lib/hookd/client.rb

@@ -2,15 +2,24 @@
 
 require 'httpx'
 require 'json'
+require 'uri'
 
 module Hookd
   # HTTP client for interacting with Hookd server
   class Client
-    attr_reader :server, :token
+    # Caps the payload materialised as a String. Generous, since a poll can
+    # return many interactions with full bodies. Zero or less disables it.
+    DEFAULT_MAX_RESPONSE_BYTES = 64 * 1024 * 1024
 
-    def initialize(server:, token:)
+    # How much of an error response is quoted back in the raised message.
+    ERROR_BODY_EXCERPT_BYTES = 1024
+
+    attr_reader :server, :token, :max_response_bytes
+
+    def initialize(server:, token:, max_response_bytes: DEFAULT_MAX_RESPONSE_BYTES)
       @server = server
       @token = token
+      @max_response_bytes = max_response_bytes
       @http = HTTPX.with(
         headers: { 'X-API-Key' => token },
         timeout: {
@@ -38,6 +47,26 @@ module Hookd
       parse_register_response(post('/register', register_body(count, ttl, metadata)))
     end
 
+    # Register one hook per spec in a single request, each with its own ttl and
+    # metadata. The server creates all of them or none.
+    # @param specs [Array<Hash>] entries of { ttl: String or nil, metadata: Hash or nil }
+    # @return [Array<Hookd::Hook>] hooks in spec order
+    # @raise [ArgumentError] if specs is empty or not an array
+    def register_batch(specs)
+      raise ArgumentError, 'specs must be a non-empty array' unless specs.is_a?(Array) && !specs.empty?
+
+      body = specs.map { |spec| register_body(nil, spec[:ttl], spec[:metadata]) || {} }
+      hook_list(post('/register', { hooks: body }))
+    end
+
+    # List long-lived hooks, without interactions, whose metadata matches every
+    # key/value of the filter
+    # @param metadata [Hash, nil] filter on top-level metadata keys
+    # @return [Array<Hookd::Hook>]
+    def hooks(metadata: nil)
+      hook_list(get("/hooks#{metadata_query(metadata)}"))
+    end
+
     # Poll for interactions on a hook
     # @param hook_id [String] the hook ID to poll
     # @return [Array<Hookd::Interaction>] array of interactions (may be empty)
@@ -78,6 +107,60 @@ module Hookd
       raise Error, "Invalid response format: #{e.message}"
     end
 
+    # Read interactions past a cursor without deleting them; acknowledge them
+    # with #ack once stored.
+    # @param hook_id [String] the hook ID to read
+    # @param after [Integer] return interactions with a seq above this
+    # @return [Hookd::CursorRead]
+    # @raise [Hookd::NotFoundError] if hook not found
+    # @raise [Hookd::ServerError] if server returns 5xx
+    # @raise [ArgumentError] if after is invalid
+    def read(hook_id, after:)
+      validate_cursor(after, 'after')
+      response = get("/poll/#{hook_id}?after=#{after}")
+
+      CursorRead.new(
+        interactions: map_interactions(response['interactions']),
+        dropped_through: response['dropped_through'] || 0,
+        metadata: response['metadata']
+      )
+    end
+
+    # Delete interactions up to and including a seq
+    # @param hook_id [String] the hook ID
+    # @param through [Integer] the last seq stored by the caller
+    # @return [Integer] number of interactions removed
+    # @raise [Hookd::NotFoundError] if hook not found
+    # @raise [Hookd::ServerError] if server returns 5xx
+    # @raise [ArgumentError] if through is invalid
+    def ack(hook_id, through:)
+      validate_cursor(through, 'through')
+      handle_response(@http.delete("#{@server}/poll/#{hook_id}?through=#{through}"))['acknowledged']
+    end
+
+    # Read several hooks past their cursors in one request
+    # @param cursors [Hash<String, Integer>] hook ID to seq
+    # @return [Hash<String, Hash>] hook ID to
+    #   { interactions: [...], dropped_through: Integer, error: String or nil }
+    def read_batch(cursors)
+      cursor_batch('/read', 'after', cursors).transform_values do |result|
+        {
+          interactions: map_interactions(result['interactions']),
+          dropped_through: result['dropped_through'] || 0,
+          error: result['error']
+        }
+      end
+    end
+
+    # Acknowledge several hooks in one request
+    # @param cursors [Hash<String, Integer>] hook ID to seq
+    # @return [Hash<String, Hash>] hook ID to { acknowledged: Integer, error: String or nil }
+    def ack_batch(cursors)
+      cursor_batch('/ack', 'through', cursors).transform_values do |result|
+        { acknowledged: result['acknowledged'] || 0, error: result['error'] }
+      end
+    end
+
     # Get server metrics (requires authentication)
     # @return [Hash] metrics data
     # @raise [Hookd::AuthenticationError] if authentication fails
@@ -89,14 +172,15 @@ module Hookd
 
     # List long-lived hooks that currently have pending interactions, so you can
     # discover which of your long-lived hooks fired without polling each one.
-    # Drain the details with #poll. Returns an empty array when none have fired
+    # Fetch the details with #read (or #poll to drain). Returns an empty array when none have fired
     # (or the server has long-lived hooks disabled).
     # @return [Array<Hookd::HookActivity>]
     # @raise [Hookd::AuthenticationError] if authentication fails
     # @raise [Hookd::ServerError] if server returns 5xx
     # @raise [Hookd::ConnectionError] if connection fails
-    def activity
-      response = get('/activity')
+    # @param metadata [Hash, nil] keep only hooks whose metadata matches
+    def activity(metadata: nil)
+      response = get("/activity#{metadata_query(metadata)}")
 
       hooks = response['hooks']
       return [] if hooks.nil? || hooks.empty? || !hooks.is_a?(Array)
@@ -141,6 +225,33 @@ module Hookd
       handle_response(response)
     end
 
+    def metadata_query(metadata)
+      return '' if metadata.nil? || metadata.empty?
+
+      "?#{URI.encode_www_form(metadata.to_h { |k, v| ["metadata.#{k}", v.to_s] })}"
+    end
+
+    def hook_list(response)
+      hooks = response['hooks']
+      raise Error, 'Invalid response format: missing hooks' unless hooks.is_a?(Array)
+
+      hooks.map { |h| Hook.from_hash(h) }
+    end
+
+    def validate_cursor(seq, name)
+      raise ArgumentError, "#{name} must be a non-negative integer" unless seq.is_a?(Integer) && seq >= 0
+    end
+
+    def cursor_batch(path, field, cursors)
+      raise ArgumentError, "#{field} must be a non-empty hash" unless cursors.is_a?(Hash) && !cursors.empty?
+
+      cursors.each_value { |seq| validate_cursor(seq, field) }
+      results = post(path, { field => cursors })['results']
+      raise Error, 'Invalid response format: missing results' unless results.is_a?(Hash)
+
+      results
+    end
+
     def validate_hook_ids(hook_ids)
       raise ArgumentError, 'hook_ids must be an array' unless hook_ids.is_a?(Array)
       raise ArgumentError, 'hook_ids cannot be empty' if hook_ids.empty?
@@ -170,24 +281,49 @@ module Hookd
         raise ConnectionError, "Connection failed: #{error.message}"
       end
 
-      body = response.body.to_s
-
       case response.status
       when 200, 201
-        raise Error, 'Empty response body from server' if body.nil? || body.empty?
-
-        JSON.parse(body)
+        parse_body(response)
       when 401
-        raise AuthenticationError, "Authentication failed: #{body}"
+        raise AuthenticationError, "Authentication failed: #{error_excerpt(response)}"
       when 404
-        raise NotFoundError, "Resource not found: #{body}"
+        raise NotFoundError, "Resource not found: #{error_excerpt(response)}"
       when 500..599
-        raise ServerError, "Server error (#{response.status}): #{body}"
+        raise ServerError, "Server error (#{response.status}): #{error_excerpt(response)}"
       else
-        raise Error, "Unexpected response (#{response.status}): #{body}"
+        raise Error, "Unexpected response (#{response.status}): #{error_excerpt(response)}"
       end
+    end
+
+    def parse_body(response)
+      body = read_body(response, @max_response_bytes)
+      raise Error, 'Empty response body from server' if body.empty?
+
+      JSON.parse(body)
     rescue JSON::ParserError => e
       raise Error, "Invalid JSON response: #{e.message}"
     end
+
+    # Accumulates chunk by chunk and stops at the ceiling, raising unless
+    # truncate is set, in which case it returns the bounded slice.
+    def read_body(response, limit, truncate: false)
+      return response.body.to_s if limit <= 0
+
+      body = nil
+      response.body.each do |chunk|
+        # Seed from the first chunk to keep the payload's own encoding.
+        body = body ? body << chunk : chunk.dup
+        next if body.bytesize <= limit
+        return body.byteslice(0, limit).scrub if truncate
+
+        raise ResponseTooLargeError, "Response exceeds the #{limit} byte limit"
+      end
+      body || ''
+    end
+
+    # A large error page must not become a large exception message.
+    def error_excerpt(response)
+      read_body(response, ERROR_BODY_EXCERPT_BYTES, truncate: true)
+    end
   end
 end

data/lib/hookd/cursor_read.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Hookd
+  # Result of a non-destructive Client#read
+  class CursorRead
+    attr_reader :interactions, :dropped_through, :metadata
+
+    def initialize(interactions:, dropped_through:, metadata: nil)
+      @interactions = interactions
+      @dropped_through = dropped_through
+      @metadata = metadata
+    end
+
+    # True when the server evicted interactions past the cursor before they
+    # were acknowledged.
+    def lost?(after)
+      dropped_through > after
+    end
+
+    def to_s
+      "#<Hookd::CursorRead interactions=#{interactions.size} dropped_through=#{dropped_through}>"
+    end
+  end
+end

data/lib/hookd/error.rb

@@ -15,4 +15,7 @@ module Hookd
 
   # Raised when the server returns a 5xx error
   class ServerError < Error; end
+
+  # Raised when a response exceeds the client's size limit
+  class ResponseTooLargeError < Error; end
 end

data/lib/hookd/hook.rb

@@ -1,17 +1,18 @@
 # frozen_string_literal: true
 
 module Hookd
-  # Represents a registered hook with DNS and HTTP endpoints. expires_at and
-  # metadata are populated for long-lived hooks (registered with a ttl) and nil
-  # otherwise.
+  # Represents a registered hook with its endpoints. smtp is set only when the
+  # server runs a mail listener. expires_at and metadata are populated for
+  # long-lived hooks (registered with a ttl) and nil otherwise.
   class Hook
-    attr_reader :id, :dns, :http, :https, :created_at, :expires_at, :metadata
+    attr_reader :id, :dns, :http, :https, :smtp, :created_at, :expires_at, :metadata
 
-    def initialize(id:, dns:, http:, https:, created_at:, expires_at: nil, metadata: nil)
+    def initialize(id:, dns:, http:, https:, created_at:, smtp: nil, expires_at: nil, metadata: nil)
       @id = id
       @dns = dns
       @http = http
       @https = https
+      @smtp = smtp
       @created_at = created_at
       @expires_at = expires_at
       @metadata = metadata
@@ -26,6 +27,7 @@ module Hookd
         dns: hash['dns'],
         http: hash['http'],
         https: hash['https'],
+        smtp: hash['smtp'],
         created_at: hash['created_at'],
         expires_at: hash['expires_at'],
         metadata: hash['metadata']

data/lib/hookd/hook_activity.rb

@@ -4,12 +4,14 @@ module Hookd
   # Summarises a long-lived hook that currently has pending interactions,
   # returned by Client#activity.
   class HookActivity
-    attr_reader :hook, :pending_count, :last_interaction_at
+    # last_seq is the newest seq held: at or below a cursor, nothing is new.
+    attr_reader :hook, :pending_count, :last_interaction_at, :last_seq
 
-    def initialize(hook:, pending_count:, last_interaction_at:)
+    def initialize(hook:, pending_count:, last_interaction_at:, last_seq: nil)
       @hook = hook
       @pending_count = pending_count
       @last_interaction_at = last_interaction_at
+      @last_seq = last_seq
     end
 
     # Create a HookActivity from an API response hash
@@ -19,7 +21,8 @@ module Hookd
       new(
         hook: Hook.from_hash(hash['hook']),
         pending_count: hash['pending_count'],
-        last_interaction_at: hash['last_interaction_at']
+        last_interaction_at: hash['last_interaction_at'],
+        last_seq: hash['last_seq']
       )
     end
 

data/lib/hookd/interaction.rb

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
 
 module Hookd
-  # Represents a captured DNS or HTTP interaction
+  # Represents a captured DNS, HTTP or SMTP interaction
   class Interaction
-    attr_reader :type, :timestamp, :source_ip, :data
+    # seq increases per hook and is the cursor for Client#read and #ack.
+    attr_reader :id, :seq, :type, :timestamp, :source_ip, :data
 
-    def initialize(type:, timestamp:, source_ip:, data:)
+    def initialize(type:, timestamp:, source_ip:, data:, id: nil, seq: nil)
+      @id = id
+      @seq = seq
       @type = type
       @timestamp = timestamp
       @source_ip = source_ip
@@ -15,6 +18,8 @@ module Hookd
     # Create an Interaction from API response hash
     def self.from_hash(hash)
       new(
+        id: hash['id'],
+        seq: hash['seq'],
         type: hash['type'],
         timestamp: hash['timestamp'],
         source_ip: hash['source_ip'],
@@ -32,12 +37,18 @@ module Hookd
       type == 'http'
     end
 
+    # Check if this is an SMTP interaction
+    def smtp?
+      type == 'smtp'
+    end
+
     def to_s
-      "#<Hookd::Interaction type=#{type} timestamp=#{timestamp} source_ip=#{source_ip}>"
+      "#<Hookd::Interaction seq=#{seq} type=#{type} timestamp=#{timestamp} source_ip=#{source_ip}>"
     end
 
     def inspect
-      "#<Hookd::Interaction:#{object_id.to_s(16)} @type=#{type.inspect}, @timestamp=#{timestamp.inspect}, " \
+      "#<Hookd::Interaction:#{object_id.to_s(16)} @id=#{id.inspect}, @seq=#{seq.inspect}, " \
+        "@type=#{type.inspect}, @timestamp=#{timestamp.inspect}, " \
         "@source_ip=#{source_ip.inspect}, @data=#{data.inspect}>"
     end
   end

data/lib/hookd/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Hookd
-  VERSION = '1.3.0'
+  VERSION = '1.5.0'
 end

data/lib/hookd.rb

@@ -5,6 +5,7 @@ require_relative 'hookd/error'
 require_relative 'hookd/hook'
 require_relative 'hookd/hook_activity'
 require_relative 'hookd/interaction'
+require_relative 'hookd/cursor_read'
 require_relative 'hookd/client'
 
 # Hookd client library for interacting with Hookd DNS/HTTP interaction server

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hookd-client
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Joshua MARTINELLE
@@ -23,8 +23,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-description: Ruby client library for Hookd, a DNS/HTTP interaction server for security
-  testing and debugging
+description: Ruby client library for Hookd, a DNS/SMTP/HTTP interaction server for
+  security testing and debugging
 email:
 - contact@jomar.fr
 executables: []
@@ -34,6 +34,7 @@ files:
 - README.md
 - lib/hookd.rb
 - lib/hookd/client.rb
+- lib/hookd/cursor_read.rb
 - lib/hookd/error.rb
 - lib/hookd/hook.rb
 - lib/hookd/hook_activity.rb