mammoth 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1249f6166082904d6ecac8d74819442681eaac72ae1e23c80a2134c412e235a
-  data.tar.gz: 292272e0696a218c3a75d970476efa3acaa71d54164da139aefa007bbd256ae5
+  metadata.gz: 5fe6f64a39d214c62e11a29fccb091f58cd2a1b8038a0bb803c39c4e018b09b3
+  data.tar.gz: f557c7288df617029808c327b656a8b7cb1f7689eb7f4b6d99032b01bcc0535e
 SHA512:
-  metadata.gz: 4e401e3a8a1778ac6b63338636cc15d5c06ccbeea77e2179af1189ba8d60d1005a2281884e3cc3a09208ac4836f37d94132ab16c3f00b08edfb1c3347fe0e944
-  data.tar.gz: fe8efe54a12f5dae1960eb4cf34c91b1eacd1d91a8609c082349b2a4e900ebda7f5160052b8f7d3bf062b09d16bb84438712f0f7d514ff23b4b16606da8b279a
+  metadata.gz: fe49156b57ff2355fd0e78368cd613fa3fa5dcf5d0a5ebf423ec799558b61a70da7529a123f5b254b904a93e7c7355a049b115308eb051e211894b84443f3444
+  data.tar.gz: 7b24591aa6f3996e51b5762022f680f212cbb1e8412e0e90ff42e34c3485d9f18fb2f4f4c9b9ca4420a697767400a2d37b6ebc600d203e7c4f5f0fbe5e904da2

data/CHANGELOG.md

@@ -1,6 +1,20 @@
 # Changelog
 
-## Unreleased
+## 0.7.0 Unreleased
+
+### Added
+
+- Added explicit adapter registries for operational state, destinations, and delivery runtimes.
+- Added the built-in SQLite operational state adapter.
+- Added the built-in webhook destination adapter registration.
+- Added inline and concurrent runtime adapter registration.
+- Added optional node identity configuration for future control-plane integration.
+- Added local capability reporting for state, destination, runtime, and relay features.
+- Added a reusable status command object behind the CLI status command.
+
+### Changed
+
+- Bumped Mammoth version to `0.7.0`.
 
 ## 0.6.0
 

data/README.md

@@ -57,6 +57,8 @@ https://kanutocd.github.io/mammoth/Mammoth.html
 - public Helm chart support
 - unit and e2e test tasks
 - health and metrics endpoints
+- explicit extension registries for state, destination, and runtime adapters
+- node identity and local capability reporting
 
 ## Boundary
 
@@ -66,6 +68,16 @@ Mammoth does not own pgoutput protocol parsing, value decoding, source
 normalization, ordering policy, or runtime execution. Those belong to the
 upstream CDC Ecosystem components.
 
+## Extensions
+
+Mammoth OSS exposes small adapter registries for future extensions:
+
+- operational state adapters
+- destination adapters
+- runtime adapters
+
+See [`docs/EXTENSIONS.md`](docs/EXTENSIONS.md).
+
 ## Configuration
 
 Mammoth configuration is YAML-backed and IDE-friendly.

data/config/mammoth.example.yml

@@ -34,6 +34,19 @@ mammoth:
   #   production_mammoth
   name: local_mammoth
 
+node:
+  # Optional local node identity for status output and future control-plane
+  # agents. Omit this section to default node_id to the host name and node_name
+  # to mammoth.name.
+  node_id: local-mammoth-1
+  node_name: local-mammoth-dev
+  fleet_id: local-dev
+  environment: development
+  labels:
+    region: local
+  metadata:
+    owner: platform
+
 postgres:
   # PostgreSQL host reachable from the Mammoth process or pod.
   #
@@ -331,6 +344,10 @@ sqlite:
   # records here. In Kubernetes, back this path with a PersistentVolumeClaim.
   path: data/mammoth.db
 
+operational_state:
+  # Mammoth OSS 0.7.0 ships the sqlite operational state adapter.
+  adapter: sqlite
+
 observability:
   # Bind host for the optional health, readiness, and metrics server.
   host: 0.0.0.0

data/config/mammoth.schema.json

@@ -40,6 +40,47 @@
       },
       "description": "Mammoth instance identity and operator-facing metadata."
     },
+    "node": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "node_id": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Stable node identifier used by status output and future control-plane agents."
+        },
+        "node_name": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Human-readable node name."
+        },
+        "fleet_id": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Optional fleet identifier for grouping Mammoth nodes."
+        },
+        "environment": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Optional deployment environment such as development, staging, or production."
+        },
+        "labels": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "string"
+          },
+          "description": "Operator-defined node labels."
+        },
+        "metadata": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "string"
+          },
+          "description": "Operator-defined node metadata."
+        }
+      },
+      "description": "Optional local node identity. Mammoth OSS uses this for status and future extension surfaces only."
+    },
     "postgres": {
       "type": "object",
       "additionalProperties": false,
@@ -223,7 +264,7 @@
             "enum": [
               "webhook"
             ],
-            "description": "Destination adapter type. Mammoth OSS 0.6.0 supports webhook destinations."
+            "description": "Destination adapter type. Mammoth OSS 0.7.0 supports webhook destinations."
           },
           "enabled": {
             "type": "boolean",
@@ -385,6 +426,20 @@
       },
       "description": "SQLite operational store settings for checkpoints, attempts, and dead-letter records."
     },
+    "operational_state": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "adapter": {
+          "type": "string",
+          "enum": [
+            "sqlite"
+          ],
+          "description": "Operational state adapter. Mammoth OSS 0.7.0 ships the sqlite adapter."
+        }
+      },
+      "description": "Operational state adapter selection. SQLite remains the default OSS adapter."
+    },
     "logging": {
       "type": "object",
       "additionalProperties": false,

data/lib/mammoth/application.rb

@@ -10,7 +10,7 @@ module Mammoth
   # injected CDC work source rather than owning upstream CDC source-adapter
   # lifecycle decisions.
   class Application
-    attr_reader :config, :sqlite_store, :consumer, :delivery_worker, :checkpoint_store
+    attr_reader :config, :state_adapter, :consumer, :delivery_worker, :checkpoint_store
 
     # @param config [Mammoth::Configuration] loaded configuration
     # @param source [#each, nil] injectable event source for tests and demos
@@ -18,12 +18,17 @@ module Mammoth
     # @param sleeper [#call] retry sleep strategy
     def initialize(config, source: nil, sink: nil, sleeper: Kernel.method(:sleep))
       @config = config
-      @sqlite_store = SQLiteStore.connect(config.dig("sqlite", "path")).bootstrap!
-      @checkpoint_store = CheckpointStore.new(sqlite_store)
+      @state_adapter = build_state_adapter
+      @checkpoint_store = state_adapter.checkpoint_store
       @consumer = ReplicationConsumer.new(source: source || build_source, delivery_unit: delivery_unit)
       @delivery_worker = sink ? build_delivery_worker(sink: sink, sleeper: sleeper) : build_configured_delivery_worker(sleeper:)
     end
 
+    # @return [Mammoth::SQLiteStore] underlying SQLite store for compatibility
+    def sqlite_store
+      state_adapter.respond_to?(:sqlite_store) ? state_adapter.sqlite_store : nil
+    end
+
     # Start the application runtime and deliver consumed CDC work.
     #
     # @return [Integer] number of processed work units
@@ -54,13 +59,7 @@ module Mammoth
     private
 
     def process_work(runtime, work)
-      if runtime
-        runtime.process_many([work])
-      elsif transaction_delivery?
-        delivery_worker.deliver_transaction(work)
-      else
-        delivery_worker.deliver(work)
-      end
+      runtime.process_many([work])
     end
 
     def process_batch(runtime, batch)
@@ -73,9 +72,8 @@ module Mammoth
     end
 
     def build_runtime
-      return unless runtime_adapter == "concurrent"
-
-      ConcurrentDeliveryRuntime.new(
+      Runtimes::Registry.build(
+        runtime_adapter,
         processor: DeliveryProcessor.new(delivery_worker:, delivery_unit: delivery_unit),
         concurrency: runtime_concurrency,
         timeout: runtime_timeout,
@@ -92,7 +90,7 @@ module Mammoth
         config,
         sink: sink,
         checkpoint_store: checkpoint_store,
-        dead_letter_store: DeadLetterStore.new(sqlite_store),
+        dead_letter_store: state_adapter.dead_letter_store,
         sleeper: sleeper,
         delivery_policy: delivery_policy
       )
@@ -116,7 +114,7 @@ module Mammoth
 
       destinations.map.with_index(1) do |destination, index|
         {
-          sink: WebhookSink.from_destination_config(destination, label: "destinations[#{index - 1}]"),
+          sink: Destinations::Registry.build(destination, label: "destinations[#{index - 1}]"),
           delivery_policy: destination_delivery_policy(destination)
         }
       end
@@ -132,8 +130,12 @@ module Mammoth
       }
     end
 
-    def transaction_delivery?
-      delivery_unit == :transaction
+    def build_state_adapter
+      OperationalState::Registry.build(operational_state_adapter, config)
+    end
+
+    def operational_state_adapter
+      config.dig("operational_state", "adapter") || "sqlite"
     end
 
     def delivery_unit

data/lib/mammoth/capabilities.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Mammoth
+  # Reports local Mammoth capabilities without inspecting private internals.
+  class Capabilities
+    # Built-in OSS data-plane feature capabilities.
+    FEATURES = %w[
+      checkpointing
+      delivery_ledger
+      dead_letters
+      replay
+      health
+      metrics
+      routing
+      fanout
+    ].freeze
+
+    attr_reader :config
+
+    # @param config [Mammoth::Configuration] loaded configuration
+    def initialize(config)
+      @config = config
+    end
+
+    # @param config [Mammoth::Configuration] loaded configuration
+    # @return [Hash] JSON-friendly capabilities
+    def self.call(config)
+      new(config).to_h
+    end
+
+    # @return [Hash] JSON-friendly capabilities
+    def to_h
+      {
+        operational_state: operational_state_adapter,
+        destinations: destination_types,
+        runtimes: Runtimes::Registry.names,
+        runtime: runtime_adapter,
+        features: FEATURES
+      }
+    end
+
+    private
+
+    def operational_state_adapter
+      config.dig("operational_state", "adapter") || "sqlite"
+    end
+
+    def runtime_adapter
+      config.dig("runtime", "adapter") || "inline"
+    end
+
+    def destination_types
+      destinations = config.data["destinations"]
+      return [config.dig("webhook", "type") || "webhook"] unless destinations
+
+      destinations.map { |destination| destination.fetch("type", "webhook") }.uniq.sort
+    end
+  end
+end

data/lib/mammoth/cli.rb

@@ -102,8 +102,7 @@ module Mammoth
     def status
       config = load_config
       store = SQLiteStore.connect(config.dig("sqlite", "path"))
-      Status.call(config, sqlite_store: store)
-      0
+      Commands::StatusCommand.new(config, sqlite_store: store).call
     end
 
     def start

data/lib/mammoth/commands/status_command.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Mammoth
+  # Local command objects shared by CLI and future control-plane agents.
+  module Commands
+    # Reusable local command object for status inspection.
+    class StatusCommand
+      attr_reader :config, :sqlite_store, :output
+
+      # @param config [Mammoth::Configuration] loaded configuration
+      # @param sqlite_store [Mammoth::SQLiteStore, nil] optional operational store
+      # @param output [#puts] output stream
+      def initialize(config, sqlite_store: nil, output: $stdout)
+        @config = config
+        @sqlite_store = sqlite_store
+        @output = output
+      end
+
+      # Execute the status command.
+      #
+      # @return [Integer] process-style status code
+      def call
+        Status.call(config, sqlite_store: sqlite_store, output: output)
+        0
+      end
+    end
+  end
+end

data/lib/mammoth/dead_letter_commands.rb

@@ -144,8 +144,6 @@ module Mammoth
 
         raise ConfigurationError, "unexpected argument #{args[index]}\n#{CLI::USAGE}"
       end
-    rescue ArgumentError
-      raise ConfigurationError, "invalid dead letter list option"
     rescue IndexError
       raise ConfigurationError, "missing value for dead letter option"
     end
@@ -188,13 +186,11 @@ module Mammoth
       end
 
       ids.map do |raw_id|
-        id = Integer(raw_id)
+        id = raw_id
         row = dead_letter_store.fetch(id)
         raise ConfigurationError, "dead letter not found: #{id}" unless row
 
         row
-      rescue ArgumentError
-        raise ConfigurationError, "dead letter id must be an integer"
       end
     end
 

data/lib/mammoth/dead_letter_store.rb

@@ -100,6 +100,10 @@ module Mammoth
       database.get_first_value("SELECT COUNT(*) FROM dead_letters#{where}", values)
     end
 
+    # Count dead letters grouped by destination.
+    #
+    # @param status [String, nil] optional status filter
+    # @return [Array<Hash>] rows with destination_name and count
     def counts_by_destination(status: nil)
       where, values = row_filters(status:)
       database.execute(

data/lib/mammoth/delivered_envelope_store.rb

@@ -93,6 +93,9 @@ module Mammoth
       end
     end
 
+    # Count delivered envelopes grouped by destination.
+    #
+    # @return [Array<Hash>] rows with destination_name and count
     def counts_by_destination
       database.execute(
         "SELECT destination_name, COUNT(*) AS count FROM delivered_envelopes GROUP BY destination_name"

data/lib/mammoth/destinations/adapter.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Mammoth
+  # Destination adapter contracts and registry.
+  module Destinations
+    # Base contract for destination adapters.
+    class Adapter
+      # @return [Hash] JSON-friendly adapter capabilities
+      def self.capabilities
+        { type: adapter_type }
+      end
+
+      # @return [String] adapter type name
+      def self.adapter_type
+        type = name.split("::").last.to_s.delete_suffix("Adapter").downcase
+        type.empty? ? "adapter" : type
+      end
+    end
+  end
+end

data/lib/mammoth/destinations/registry.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Mammoth
+  module Destinations
+    # Registry for destination adapters.
+    module Registry
+      class << self
+        # Register a destination adapter.
+        #
+        # @param name [String, Symbol] adapter name
+        # @param adapter [Object] adapter class
+        # @return [Object] registered adapter
+        def register(name, adapter)
+          registry.register(name, adapter)
+        end
+
+        # Fetch a destination adapter.
+        #
+        # @param name [String, Symbol] adapter name
+        # @return [Object] adapter class
+        def fetch(name)
+          registry.fetch(name)
+        end
+
+        # Build a destination sink from config.
+        #
+        # @param destination [Hash] destination config
+        # @param label [String] config label for errors
+        # @return [Object] delivery sink
+        def build(destination, label:)
+          fetch(destination.fetch("type", "webhook")).build(destination, label: label)
+        end
+
+        # @return [Array<String>] registered destination adapter names
+        def names
+          registry.names
+        end
+
+        # @return [Mammoth::Registry] underlying registry
+        def registry
+          @registry ||= Mammoth::Registry.new("destination")
+        end
+      end
+    end
+  end
+end

data/lib/mammoth/destinations/webhook_adapter.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Mammoth
+  module Destinations
+    # Built-in webhook destination adapter.
+    class WebhookAdapter < Adapter
+      class << self
+        # @return [String] adapter type name
+        def adapter_type
+          "webhook"
+        end
+
+        # Build a webhook sink from destination configuration.
+        #
+        # @param destination [Hash] destination configuration
+        # @param label [String] config path label for errors
+        # @return [Mammoth::WebhookSink]
+        def build(destination, label:)
+          WebhookSink.from_destination_config(destination, label: label)
+        end
+
+        # @return [Hash] JSON-friendly capabilities
+        def capabilities
+          { type: adapter_type, delivery_units: %w[event transaction], signing: true, header_env: true }
+        end
+      end
+    end
+  end
+end

data/lib/mammoth/node_identity.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "socket"
+
+module Mammoth
+  # Local Mammoth node identity used by status and future control-plane agents.
+  class NodeIdentity
+    attr_reader :node_id, :node_name, :fleet_id, :environment, :labels, :metadata
+
+    # @param node_id [String] stable node identifier
+    # @param node_name [String] human-readable node name
+    # @param fleet_id [String, nil] optional fleet identifier
+    # @param environment [String, nil] optional environment name
+    # @param labels [Hash] operator-defined labels
+    # @param metadata [Hash] operator-defined metadata
+    def initialize(node_id:, node_name:, fleet_id: nil, environment: nil, labels: {}, metadata: {})
+      @node_id = node_id
+      @node_name = node_name
+      @fleet_id = fleet_id
+      @environment = environment
+      @labels = labels || {}
+      @metadata = metadata || {}
+    end
+
+    # Build identity from Mammoth configuration.
+    #
+    # @param config [Mammoth::Configuration] loaded configuration
+    # @return [Mammoth::NodeIdentity]
+    def self.from_config(config)
+      identity = config.data["node"] || {}
+      hostname = Socket.gethostname
+      new(
+        node_id: identity["node_id"] || hostname,
+        node_name: identity["node_name"] || config.dig("mammoth", "name") || hostname,
+        fleet_id: identity["fleet_id"],
+        environment: identity["environment"],
+        labels: identity["labels"] || {},
+        metadata: identity["metadata"] || {}
+      )
+    end
+
+    # @return [Hash] JSON-friendly node identity
+    def to_h
+      {
+        node_id: node_id,
+        node_name: node_name,
+        fleet_id: fleet_id,
+        environment: environment,
+        labels: labels,
+        metadata: metadata
+      }
+    end
+  end
+end

data/lib/mammoth/observability_server.rb

@@ -10,7 +10,9 @@ module Mammoth
   # may run it as a sidecar-like process or in a separate process that points at
   # the same SQLite operational database.
   class ObservabilityServer
+    # Default bind host for the observability server.
     DEFAULT_HOST = "0.0.0.0"
+    # Default TCP port for the observability server.
     DEFAULT_PORT = 9393
 
     attr_reader :config, :host, :port, :sqlite_store, :logger, :server

data/lib/mammoth/operational_state/adapter.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Mammoth
+  # Operational state adapter contracts and registry.
+  module OperationalState
+    # Base contract for operational state adapters.
+    class Adapter
+      # @return [void]
+      def initialize; end
+
+      # @return [Mammoth::CheckpointStore]
+      def checkpoint_store
+        raise NotImplementedError, "#{self.class} must implement #checkpoint_store"
+      end
+
+      # @return [Mammoth::DeadLetterStore]
+      def dead_letter_store
+        raise NotImplementedError, "#{self.class} must implement #dead_letter_store"
+      end
+
+      # @return [Mammoth::DeliveredEnvelopeStore]
+      def delivered_envelope_store
+        raise NotImplementedError, "#{self.class} must implement #delivered_envelope_store"
+      end
+
+      # @return [Hash] JSON-friendly state summary
+      def summary
+        {
+          adapter: "unknown",
+          checkpoints: checkpoint_store.count,
+          dead_letters: dead_letter_store.count,
+          delivered_envelopes: delivered_envelope_store.count
+        }
+      end
+    end
+  end
+end

data/lib/mammoth/operational_state/registry.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Mammoth
+  module OperationalState
+    # Registry for operational state adapters.
+    module Registry
+      class << self
+        # Register an operational state adapter.
+        #
+        # @param name [String, Symbol] adapter name
+        # @param adapter [Object] adapter class
+        # @return [Object] registered adapter
+        def register(name, adapter)
+          registry.register(name, adapter)
+        end
+
+        # Fetch an operational state adapter.
+        #
+        # @param name [String, Symbol] adapter name
+        # @return [Object] adapter class
+        def fetch(name)
+          registry.fetch(name)
+        end
+
+        # Build an operational state adapter from config.
+        #
+        # @param name [String, Symbol] adapter name
+        # @param config [Mammoth::Configuration] loaded configuration
+        # @return [Mammoth::OperationalState::Adapter] adapter instance
+        def build(name, config)
+          fetch(name).from_config(config)
+        end
+
+        # @return [Array<String>] registered operational state adapter names
+        def names
+          registry.names
+        end
+
+        # @return [Mammoth::Registry] underlying registry
+        def registry
+          @registry ||= Mammoth::Registry.new("operational_state")
+        end
+      end
+    end
+  end
+end

data/lib/mammoth/operational_state/sqlite_adapter.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Mammoth
+  module OperationalState
+    # SQLite-backed operational state adapter used by Mammoth OSS.
+    class SQLiteAdapter < Adapter
+      attr_reader :sqlite_store
+
+      # @param sqlite_store [Mammoth::SQLiteStore] bootstrapped SQLite store
+      def initialize(sqlite_store)
+        super()
+        @sqlite_store = sqlite_store.bootstrap!
+      end
+
+      # Build a SQLite state adapter from Mammoth configuration.
+      #
+      # @param config [Mammoth::Configuration] loaded configuration
+      # @return [Mammoth::OperationalState::SQLiteAdapter]
+      def self.from_config(config)
+        new(SQLiteStore.connect(config.dig("sqlite", "path")))
+      end
+
+      # @return [Mammoth::CheckpointStore]
+      def checkpoint_store
+        @checkpoint_store ||= CheckpointStore.new(sqlite_store)
+      end
+
+      # @return [Mammoth::DeadLetterStore]
+      def dead_letter_store
+        @dead_letter_store ||= DeadLetterStore.new(sqlite_store)
+      end
+
+      # @return [Mammoth::DeliveredEnvelopeStore]
+      def delivered_envelope_store
+        @delivered_envelope_store ||= DeliveredEnvelopeStore.new(sqlite_store)
+      end
+
+      # @return [Hash] JSON-friendly SQLite state summary
+      def summary
+        super.merge(adapter: "sqlite", path: sqlite_store.path, tables: sqlite_store.tables)
+      end
+    end
+  end
+end

data/lib/mammoth/registry.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Mammoth
+  # Small explicit registry for built-in and extension-provided adapters.
+  class Registry
+    attr_reader :namespace, :entries
+
+    # @param namespace [String] human-readable registry name for errors
+    def initialize(namespace)
+      @namespace = namespace
+      @entries = {}
+    end
+
+    # Register an adapter under a stable name.
+    #
+    # @param name [String, Symbol] adapter name
+    # @param adapter [Object] adapter object or class
+    # @return [Object] registered adapter
+    def register(name, adapter)
+      key = normalize_name(name)
+      raise ConfigurationError, "#{namespace} adapter already registered: #{key}" if entries.key?(key)
+
+      entries[key] = adapter
+    end
+
+    # Fetch a registered adapter.
+    #
+    # @param name [String, Symbol] adapter name
+    # @return [Object] registered adapter
+    def fetch(name)
+      key = normalize_name(name)
+      entries.fetch(key) { raise ConfigurationError, "unknown #{namespace} adapter: #{key}" }
+    end
+
+    # @return [Array<String>] registered adapter names
+    def names
+      entries.keys.sort
+    end
+
+    private
+
+    def normalize_name(name)
+      name.to_s
+    end
+  end
+end

data/lib/mammoth/runtimes/adapter.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Mammoth
+  # Delivery runtime adapter contracts and registry.
+  module Runtimes
+    # Base contract for delivery runtime adapters.
+    class Adapter
+      # @return [void]
+      def initialize; end
+
+      # @return [Hash] JSON-friendly adapter capabilities
+      def self.capabilities
+        { type: adapter_type }
+      end
+
+      # @return [String] adapter type name
+      def self.adapter_type
+        type = name.split("::").last.to_s.delete_suffix("Adapter").downcase
+        type.empty? ? "adapter" : type
+      end
+    end
+  end
+end

data/lib/mammoth/runtimes/concurrent_adapter.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Mammoth
+  module Runtimes
+    # Runtime adapter backed by Mammoth's existing cdc-concurrent wrapper.
+    class ConcurrentAdapter < Adapter
+      class << self
+        # @return [String] adapter type name
+        def adapter_type
+          "concurrent"
+        end
+
+        # Build a concurrent runtime adapter.
+        #
+        # @param processor [#process] delivery processor
+        # @param concurrency [Integer] worker count
+        # @param timeout [Numeric, nil] optional timeout
+        # @param preserve_order [Boolean] preserve ordering when supported
+        # @return [Mammoth::ConcurrentDeliveryRuntime]
+        def build(processor:, concurrency:, timeout:, preserve_order:)
+          ConcurrentDeliveryRuntime.new(
+            processor: processor,
+            concurrency: concurrency,
+            timeout: timeout,
+            preserve_order: preserve_order
+          )
+        end
+      end
+    end
+  end
+end

data/lib/mammoth/runtimes/inline_adapter.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Mammoth
+  module Runtimes
+    # Inline runtime adapter that processes work in the caller thread.
+    class InlineAdapter < Adapter
+      attr_reader :processor
+
+      # @param processor [#process] delivery processor
+      def initialize(processor:)
+        super()
+        @processor = processor
+      end
+
+      # Build an inline runtime.
+      #
+      # @param processor [#process] delivery processor
+      # @return [Mammoth::Runtimes::InlineAdapter]
+      def self.build(processor:, **_options)
+        new(processor: processor)
+      end
+
+      # @return [String] adapter type name
+      def self.adapter_type
+        "inline"
+      end
+
+      # @param items [Array<Object>] work units
+      # @return [Array<Object>] processor results
+      def process_many(items)
+        items.map { |item| processor.process(item) }
+      end
+
+      # @return [nil]
+      def shutdown
+        nil
+      end
+    end
+  end
+end

data/lib/mammoth/runtimes/registry.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Mammoth
+  module Runtimes
+    # Registry for delivery runtime adapters.
+    module Registry
+      class << self
+        # Register a runtime adapter.
+        #
+        # @param name [String, Symbol] adapter name
+        # @param adapter [Object] adapter class
+        # @return [Object] registered adapter
+        def register(name, adapter)
+          registry.register(name, adapter)
+        end
+
+        # Fetch a runtime adapter.
+        #
+        # @param name [String, Symbol] adapter name
+        # @return [Object] adapter class
+        def fetch(name)
+          registry.fetch(name)
+        end
+
+        # Build a runtime adapter.
+        #
+        # @param name [String, Symbol] adapter name
+        # @param options [Hash] adapter-specific build options
+        # @return [Object] runtime adapter
+        def build(name, **options)
+          fetch(name).build(**options)
+        end
+
+        # @return [Array<String>] registered runtime adapter names
+        def names
+          registry.names
+        end
+
+        # @return [Mammoth::Registry] underlying registry
+        def registry
+          @registry ||= Mammoth::Registry.new("runtime")
+        end
+      end
+    end
+  end
+end

data/lib/mammoth/status.rb

@@ -3,39 +3,73 @@
 module Mammoth
   # Builds and prints a boring operational status snapshot.
   class Status
-    attr_reader :config, :sqlite_store
+    attr_reader :config, :sqlite_store, :output
 
     # Print status for a configuration and optional SQLite store.
     #
     # @param config [Mammoth::Configuration] loaded configuration
     # @param sqlite_store [Mammoth::SQLiteStore, nil] operational store
     # @return [void]
-    def self.call(config, sqlite_store: nil)
-      new(config, sqlite_store: sqlite_store).call
+    def self.call(config, sqlite_store: nil, output: $stdout)
+      new(config, sqlite_store: sqlite_store, output: output).call
     end
 
     # @param config [Mammoth::Configuration] loaded configuration
     # @param sqlite_store [Mammoth::SQLiteStore, nil] operational store
-    def initialize(config, sqlite_store: nil)
+    # @param output [#puts] output stream
+    def initialize(config, sqlite_store: nil, output: $stdout)
       @config = config
       @sqlite_store = sqlite_store
+      @output = output
     end
 
     # Print the status snapshot.
     #
     # @return [void]
     def call
-      puts "Mammoth: #{config.dig("mammoth", "name")}"
-      puts "Replication slot: #{config.dig("replication", "slot")}"
-      puts "Replication publications: #{Array(config.dig("replication", "publications")).join(", ")}"
-      puts "Runtime: not started"
-      puts "SQLite: #{sqlite_path}"
-      puts "Destinations: #{destination_names.join(", ")}"
+      status_lines.each { |line| output.puts(line) }
       print_store_state if sqlite_store
     end
 
     private
 
+    def status_lines
+      identity_lines + replication_lines + runtime_lines + destination_lines + ["SQLite: #{sqlite_path}"]
+    end
+
+    def identity_lines
+      [
+        "Mammoth: #{config.dig("mammoth", "name")}",
+        "Node ID: #{node_identity.node_id}",
+        "Node name: #{node_identity.node_name}",
+        "Fleet: #{node_identity.fleet_id || "unassigned"}",
+        "Environment: #{node_identity.environment || "unspecified"}"
+      ]
+    end
+
+    def replication_lines
+      [
+        "Replication slot: #{config.dig("replication", "slot")}",
+        "Replication publications: #{Array(config.dig("replication", "publications")).join(", ")}"
+      ]
+    end
+
+    def runtime_lines
+      [
+        "Runtime: not started",
+        "Runtime adapter: #{capabilities.fetch(:runtime)}",
+        "Operational state: #{capabilities.fetch(:operational_state)}"
+      ]
+    end
+
+    def destination_lines
+      [
+        "Destinations: #{destination_names.join(", ")}",
+        "Destination adapters: #{capabilities.fetch(:destinations).join(", ")}",
+        "Features: #{capabilities.fetch(:features).join(", ")}"
+      ]
+    end
+
     def sqlite_path
       config.dig("sqlite", "path")
     end
@@ -47,11 +81,19 @@ module Mammoth
       [config.dig("webhook", "name")]
     end
 
+    def node_identity
+      @node_identity ||= NodeIdentity.from_config(config)
+    end
+
+    def capabilities
+      @capabilities ||= Capabilities.call(config)
+    end
+
     def print_store_state
       store = sqlite_store.bootstrap!
-      puts "Tables: #{store.tables.join(", ")}"
-      puts "Checkpoints: #{CheckpointStore.new(store).count}"
-      puts "Dead Letters: #{DeadLetterStore.new(store).count}"
+      output.puts "Tables: #{store.tables.join(", ")}"
+      output.puts "Checkpoints: #{CheckpointStore.new(store).count}"
+      output.puts "Dead Letters: #{DeadLetterStore.new(store).count}"
     end
   end
 end

data/lib/mammoth/version.rb

@@ -2,5 +2,5 @@
 
 module Mammoth
   # Current Mammoth gem version.
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 end

data/lib/mammoth.rb

@@ -2,8 +2,12 @@
 
 require_relative "mammoth/version"
 require_relative "mammoth/errors"
+require_relative "mammoth/registry"
 require_relative "mammoth/configuration"
+require_relative "mammoth/node_identity"
+require_relative "mammoth/capabilities"
 require_relative "mammoth/status"
+require_relative "mammoth/commands/status_command"
 require_relative "mammoth/observability_snapshot"
 require_relative "mammoth/observability_server"
 require_relative "mammoth/sqlite_store"
@@ -14,10 +18,20 @@ require_relative "mammoth/event_serializer"
 require_relative "mammoth/transaction_envelope_serializer"
 require_relative "mammoth/route_filter"
 require_relative "mammoth/webhook_sink"
+require_relative "mammoth/operational_state/adapter"
+require_relative "mammoth/operational_state/sqlite_adapter"
+require_relative "mammoth/operational_state/registry"
+require_relative "mammoth/destinations/adapter"
+require_relative "mammoth/destinations/webhook_adapter"
+require_relative "mammoth/destinations/registry"
 require_relative "mammoth/delivery_worker"
 require_relative "mammoth/fanout_delivery_worker"
 require_relative "mammoth/delivery_processor"
 require_relative "mammoth/concurrent_delivery_runtime"
+require_relative "mammoth/runtimes/adapter"
+require_relative "mammoth/runtimes/inline_adapter"
+require_relative "mammoth/runtimes/concurrent_adapter"
+require_relative "mammoth/runtimes/registry"
 require_relative "mammoth/sources/postgres"
 require_relative "mammoth/cdc_source"
 require_relative "mammoth/replication_consumer"
@@ -31,4 +45,8 @@ require_relative "mammoth/cli"
 # PostgreSQL change events are normalized, persisted through local operational
 # state, and delivered to webhook destinations.
 module Mammoth
+  OperationalState::Registry.register("sqlite", OperationalState::SQLiteAdapter)
+  Destinations::Registry.register("webhook", Destinations::WebhookAdapter)
+  Runtimes::Registry.register("inline", Runtimes::InlineAdapter)
+  Runtimes::Registry.register("concurrent", Runtimes::ConcurrentAdapter)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mammoth
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Ken C. Demanawa
@@ -145,9 +145,11 @@ files:
 - exe/mammoth
 - lib/mammoth.rb
 - lib/mammoth/application.rb
+- lib/mammoth/capabilities.rb
 - lib/mammoth/cdc_source.rb
 - lib/mammoth/checkpoint_store.rb
 - lib/mammoth/cli.rb
+- lib/mammoth/commands/status_command.rb
 - lib/mammoth/concurrent_delivery_runtime.rb
 - lib/mammoth/configuration.rb
 - lib/mammoth/dead_letter_commands.rb
@@ -155,13 +157,25 @@ files:
 - lib/mammoth/delivered_envelope_store.rb
 - lib/mammoth/delivery_processor.rb
 - lib/mammoth/delivery_worker.rb
+- lib/mammoth/destinations/adapter.rb
+- lib/mammoth/destinations/registry.rb
+- lib/mammoth/destinations/webhook_adapter.rb
 - lib/mammoth/errors.rb
 - lib/mammoth/event_serializer.rb
 - lib/mammoth/fanout_delivery_worker.rb
+- lib/mammoth/node_identity.rb
 - lib/mammoth/observability_server.rb
 - lib/mammoth/observability_snapshot.rb
+- lib/mammoth/operational_state/adapter.rb
+- lib/mammoth/operational_state/registry.rb
+- lib/mammoth/operational_state/sqlite_adapter.rb
+- lib/mammoth/registry.rb
 - lib/mammoth/replication_consumer.rb
 - lib/mammoth/route_filter.rb
+- lib/mammoth/runtimes/adapter.rb
+- lib/mammoth/runtimes/concurrent_adapter.rb
+- lib/mammoth/runtimes/inline_adapter.rb
+- lib/mammoth/runtimes/registry.rb
 - lib/mammoth/sources/postgres.rb
 - lib/mammoth/sql/__bootstrap__.sql
 - lib/mammoth/sqlite_store.rb