forest_admin_agent 1.33.1 → 1.34.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d606dd925365a5389470b0e1a2c0b42d73efd17d12ff543371ae6a5ee92e721
-  data.tar.gz: 5c9cd14e9935df983cbd49dc12be9601982e7003517a4266fe9a7195e9b385c4
+  metadata.gz: 5eac03c350cacd4d12aa3408eb1bc3d0546f7d5999974335b870343609ac3375
+  data.tar.gz: 6d21b84fda83ad2f90bf157c8fc8a0b7f65710d1159cf771645a11f0349c8037
 SHA512:
-  metadata.gz: fcea300520ed0e66411bb1c1a7187461768a628364e2e2213da2a3dfdfaa899d7f312f0ae0a03353c1bc11b357b97590dd138b6fb6118d2e1284dbd2ca2cb106
-  data.tar.gz: 5002a6e10f7d98a09986dd392e88aa3c6bcd296fc87ad3b8ce8ea1b4c76866039b23c887ed23e974fc54535ae9d7725593f52ee83bdad004c5539e911b37f23b
+  metadata.gz: 3c5b3a78c4ac0fa919dfdbddf7518eac9520b36e47a5c258c3f97651fd12989f2fad2ef65a669c4ee6bf3862921ba91b505eb6c4d70a615001e32da927b7c7e1
+  data.tar.gz: 424a07e610f49273e9d12751369ade15ead966d6876f0bf70af4acb5b68444ab508f2b51ef31e3522c2c3b51cfb6fb7e3649d2993c18b194212ef270dfe8669e

data/lib/forest_admin_agent/routes/workflow/workflow_executor_proxy.rb

@@ -1,45 +1,45 @@
 require 'faraday'
+require 'uri'
 
 module ForestAdminAgent
   module Routes
     module Workflow
-      # Forwards workflow-execution traffic from the agent to the workflow executor.
-      # Mounted only when the integrator sets `workflow_executor_url`
+      # Generic proxy: forwards any sub-path/verb under AGENT_PREFIX to the executor verbatim, so a
+      # new executor route needs no change here. Mounted only when `workflow_executor_url` is set.
       class WorkflowExecutorProxy < AbstractAuthenticatedRoute
-        AGENT_PREFIX = '/_internal/workflow-executions'.freeze
-        EXECUTOR_PREFIX = '/runs'.freeze
-        FORWARDED_HEADERS = %w[Authorization Cookie].freeze
-        ROUTING_KEYS = %w[run_id route_alias controller action format].freeze
+        AGENT_PREFIX = '/_internal/executor'.freeze
+        # Never forwarded (request or response): hop-by-hop, Host, and body-framing headers.
+        # Faraday and `render json:` set their own length and de/recompress the body, so relaying
+        # the upstream length/encoding would mismatch the bytes we actually send — and forwarding
+        # accept-encoding would disable Faraday's transparent gzip decompression.
+        SKIPPED_HEADERS = %w[
+          connection keep-alive transfer-encoding upgrade te trailer
+          proxy-authenticate proxy-authorization host
+          content-length content-encoding accept-encoding
+        ].freeze
+        # Fragments that could let the wildcard leave the executor origin once decoded.
+        UNSAFE_PATH_FRAGMENTS = ['..', '%2e', '%2E', '\\', "\0"].freeze
         OPEN_TIMEOUT = 2
-        GET_TIMEOUT = 10
-        TRIGGER_TIMEOUT = 120
+        REQUEST_TIMEOUT = 120
 
         def setup_routes
           return self unless executor_configured?
 
           add_route(
-            'forest_workflow_run_show',
-            'get',
-            "#{AGENT_PREFIX}/:run_id",
-            ->(args) { handle_request(:get, args) }
-          )
-          add_route(
-            'forest_workflow_run_trigger',
-            'post',
-            "#{AGENT_PREFIX}/:run_id/trigger",
-            ->(args) { handle_request(:post, args) }
+            'forest_workflow_executor_proxy',
+            :all,
+            "#{AGENT_PREFIX}/*path",
+            ->(args) { handle_request(args) }
           )
 
           self
         end
 
-        def handle_request(method, args = {})
+        def handle_request(args = {})
           build(args)
 
-          base_url = configured_executor_url
-          run_id = args.dig(:params, 'run_id') || args.dig(:params, :run_id)
-          path = build_path(run_id, method)
-          response = forward(method, base_url, path, args)
+          method = (args[:method] || 'get').to_s.downcase.to_sym
+          response = forward(method, build_target_url(args), args)
 
           {
             content: response.body,
@@ -67,76 +67,98 @@ module ForestAdminAgent
           url.to_s.sub(%r{/+\z}, '')
         end
 
-        def build_path(run_id, method)
-          suffix = method == :post ? '/trigger' : ''
-          "#{EXECUTOR_PREFIX}/#{run_id}#{suffix}"
+        def build_target_url(args)
+          base = configured_executor_url
+          path = build_executor_path(args.dig(:params, 'path') || args.dig(:params, :path))
+          reject_off_origin!(base, path)
+          query = args[:query_string].to_s
+          url = "#{base}#{path}"
+
+          query.empty? ? url : "#{url}?#{query}"
+        end
+
+        # First-pass rejection of escape attempts; the authoritative origin check is reject_off_origin!.
+        def build_executor_path(raw_path)
+          path = raw_path.to_s
+          raise Http::Exceptions::NotFoundError, 'Invalid workflow executor path' if unsafe_path?(path)
+
+          "/#{path}"
+        end
+
+        # Authoritative SSRF check: forwarding must never leave the executor origin.
+        def reject_off_origin!(base, path)
+          base_uri = URI.parse(base)
+          target = URI.parse("#{base}#{path}")
+          same = target.scheme == base_uri.scheme && target.host == base_uri.host &&
+                 target.port == base_uri.port
+          raise Http::Exceptions::NotFoundError, 'Invalid workflow executor path' unless same
+        rescue URI::InvalidURIError
+          raise Http::Exceptions::NotFoundError, 'Invalid workflow executor path'
         end
 
-        def forward(method, base_url, path, args)
-          query = forwarded_query_params(args[:params])
+        def unsafe_path?(path)
+          return true if path.empty? || path.start_with?('/')
+
+          UNSAFE_PATH_FRAGMENTS.any? { |fragment| path.include?(fragment) }
+        end
+
+        def forward(method, target_url, args)
           headers = forwarded_request_headers(args[:headers])
-          body = forwarded_body(method, args[:params])
-          target_url = "#{base_url}#{path}"
+          body = method == :get ? nil : args[:body]
 
-          client = build_client(timeout_for(method))
-          client.run_request(method, target_url, body, headers) do |req|
-            req.params.update(query) unless query.empty?
-          end
+          build_client.run_request(method, target_url, body, headers)
         rescue Faraday::TimeoutError => e
           raise Http::Exceptions::ServiceUnavailableError.new('Workflow executor timed out', cause: e)
         rescue Faraday::ConnectionFailed => e
           raise Http::Exceptions::ServiceUnavailableError.new('Workflow executor unreachable', cause: e)
+        # Any other transport-level Faraday failure (SSL, etc.) is an executor-reachability problem,
+        # not a 500 — Faraday never raises on executor 4xx/5xx (no raise_error middleware).
+        rescue Faraday::Error => e
+          raise Http::Exceptions::ServiceUnavailableError.new('Workflow executor request failed', cause: e)
         end
 
-        def timeout_for(method)
-          method == :get ? GET_TIMEOUT : TRIGGER_TIMEOUT
-        end
-
-        def build_client(request_timeout)
-          Faraday.new(request: { open_timeout: OPEN_TIMEOUT, timeout: request_timeout }) do |f|
-            f.request :json
+        def build_client
+          Faraday.new(request: { open_timeout: OPEN_TIMEOUT, timeout: REQUEST_TIMEOUT }) do |f|
+            # No request :json middleware: body is forwarded raw (not reshaped).
             f.response :json, content_type: /\bjson$/
             f.adapter Faraday.default_adapter
           end
         end
 
-        # Strip Rails-injected routing keys; keep only true client query params.
-        def forwarded_query_params(params)
-          return {} unless params.is_a?(Hash)
+        # `env` is the Rack env: real HTTP headers are the HTTP_* keys (+ CONTENT_TYPE/CONTENT_LENGTH);
+        # rack.*/action_dispatch.*/server vars are not headers and are dropped.
+        def forwarded_request_headers(env)
+          return {} unless env.is_a?(Hash)
 
-          params.each_with_object({}) do |(key, value), acc|
-            next if ROUTING_KEYS.include?(key.to_s)
-            next if value.is_a?(Hash) || value.is_a?(Array) # 'data' body, etc.
+          env.each_with_object({}) do |(key, value), acc|
+            name = http_header_name(key.to_s)
+            next unless name
+            next if SKIPPED_HEADERS.include?(name.downcase)
+            next if value.nil? || value.to_s.empty?
 
-            acc[key.to_s] = value
+            acc[name] = value.to_s
           end
         end
 
-        def forwarded_request_headers(headers)
-          return {} unless headers.is_a?(Hash)
-
-          FORWARDED_HEADERS.each_with_object({}) do |name, acc|
-            value = headers[name] || headers[name.downcase] || headers["HTTP_#{name.upcase}"]
-            acc[name] = value if value && !value.to_s.empty?
+        def http_header_name(env_key)
+          if env_key.start_with?('HTTP_')
+            titleize_header(env_key.delete_prefix('HTTP_'))
+          elsif %w[CONTENT_TYPE CONTENT_LENGTH].include?(env_key)
+            titleize_header(env_key)
           end
         end
 
-        def forwarded_body(method, params)
-          return nil if method == :get
-          return nil unless params.is_a?(Hash)
-
-          # JSON request bodies arrive parsed under :data when sent as JSON:API,
-          # or as the raw top-level params hash otherwise. Prefer :data when
-          # present; fall back to a sanitized copy of params.
-          body = params['data'] || params[:data]
-          return body if body
-
-          params.reject { |key, _| ROUTING_KEYS.include?(key.to_s) }
+        def titleize_header(rack_name)
+          rack_name.split('_').map(&:capitalize).join('-')
         end
 
         def forwarded_response_headers(response)
-          content_type = response.headers['content-type'] || response.headers['Content-Type']
-          content_type ? { 'Content-Type' => content_type } : {}
+          response.headers.each_with_object({}) do |(name, value), acc|
+            next if name.nil? || SKIPPED_HEADERS.include?(name.to_s.downcase)
+            next if value.nil? || value.to_s.empty?
+
+            acc[name.to_s] = value.to_s
+          end
         end
       end
     end

data/lib/forest_admin_agent/utils/schema/schema_emitter.rb

@@ -6,7 +6,7 @@ module ForestAdminAgent
     module Schema
       class SchemaEmitter
         LIANA_NAME = "agent-ruby"
-        LIANA_VERSION = "1.33.1"
+        LIANA_VERSION = "1.34.0"
 
         def self.generate(datasource)
           datasource.collections

data/lib/forest_admin_agent/version.rb

@@ -1,3 +1,3 @@
 module ForestAdminAgent
-  VERSION = "1.33.1"
+  VERSION = "1.34.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: forest_admin_agent
 version: !ruby/object:Gem::Version
-  version: 1.33.1
+  version: 1.34.0
 platform: ruby
 authors:
 - Matthieu
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-06-16 00:00:00.000000000 Z
+date: 2026-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport