forest_liana 9.19.0 → 9.20.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 92281c1baf13dfbbdbe418f2a11833ad15a665c1109f1e4ad0a5f395e32ab090
-  data.tar.gz: 71946c62175f706e11528dbac2a3e7600f780a7847596be724c74675ef8299a0
+  metadata.gz: 7e6590ae4597f44757af9a98c3f4d8ba9e83652eedd857f45aeb1fe365e8a8ae
+  data.tar.gz: 5aa5f3150171dd65dac411007c311b9cb5409c9eb97d1a415d31e908001b0d34
 SHA512:
-  metadata.gz: f6eced39681d8c424791ed625807cb3ce9e8e741a9ed7f1ca711f225219219d2415cafa222b8df4eaa99185f57c98ca2f8766df724719d36e791af695ad1f2ee
-  data.tar.gz: 4df825ec3296694e8fcf7cdc0d7eb86a481667af477ce9b7e500ba69afdc1bb86d343049f2493d896c9a70dc19100f984dcd301e5da80703520cf17ae0121dcc
+  metadata.gz: 6d848b970f6f68edd2a162f40e546740878c6fc7e2b298a3c494f6641fce908b41e2412a9e3457d13edef7d6433ce9f5704b77604851b2fd7aeca5eb60cfe691
+  data.tar.gz: 2828ff99f57028970cc2ec4e1662b70203d0d077ca0bbb45350dd4d29d09bffaffd1ef907b923e666cfc28704f97db62358bdf6709cf4b7c16bac822cd1afa15

data/app/controllers/forest_liana/actions_controller.rb

@@ -58,7 +58,7 @@ module ForestLiana
       begin
         # action.hooks[:change] is a hashmap here
         # to do the validation, only the hook names are require
-        change_hooks_name = action.hooks[:change].nil? ? nil : action.hooks[:change].keys
+        change_hooks_name = action.hooks && action.hooks[:change] ? action.hooks[:change].keys : nil
         ForestLiana::SmartActionFieldValidator.validate_smart_action_fields(result[:fields], action.name, change_hooks_name)
       rescue ForestLiana::Errors::SmartActionInvalidFieldError => invalid_field_error
         FOREST_LOGGER.warn invalid_field_error.message
@@ -107,10 +107,15 @@ module ForestLiana
         # Get the smart action hook load context
         context = get_smart_action_load_ctx(action.fields)
 
-        # Call the user-defined load hook.
-        result = action.hooks[:load].(context)
+        if action.hooks && action.hooks[:load].present?
+          # Call the user-defined load hook.
+          result = action.hooks[:load].(context)
 
-        handle_result(result, action)
+          handle_result(result, action)
+        else
+          # No load hook declared: answer the static form (Node agent parity) instead of a 404.
+          handle_result(context[:fields], action)
+        end
       end
     end
 

data/app/controllers/forest_liana/workflow_executions_controller.rb

@@ -1,71 +1,126 @@
 require 'httparty'
+require 'uri'
 
 module ForestLiana
   class WorkflowExecutionsController < ApplicationController
-    FORWARDED_HEADERS = %w[Authorization Cookie].freeze
-    UPSTREAM_TIMEOUT_IN_SECONDS = 10
+    # Never forwarded (request or response): hop-by-hop, Host, and body-framing headers.
+    # render json: re-serializes the body, so the upstream length/encoding no longer match — and
+    # forwarding accept-encoding would defeat Net::HTTP'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
+    UNSAFE_PATH_FRAGMENTS = ['..', '%2e', '%2E', '\\', "\0"].freeze
+    OPEN_TIMEOUT_IN_SECONDS = 2
+    REQUEST_TIMEOUT_IN_SECONDS = 120
     UPSTREAM_ERRORS = [
       HTTParty::Error,
       SocketError,
       Errno::ECONNREFUSED,
       Net::OpenTimeout,
       Net::ReadTimeout,
-      Timeout::Error
+      Timeout::Error,
+      OpenSSL::SSL::SSLError
     ].freeze
 
-    def show
-      forward_to_executor(method: :get, suffix: '')
-    end
-
-    def trigger
-      forward_to_executor(method: :post, suffix: '/trigger')
-    end
-
-    private
-
-    def forward_to_executor(method:, suffix:)
+    # Catch-all: forward any verb/sub-path verbatim to the executor, so a new executor route needs
+    # no change here.
+    def proxy
       base = ForestLiana.workflow_executor_url
-      if base.blank?
-        head :not_found
-        return
-      end
+      return head(:not_found) if base.blank?
+
+      normalized_base = base.sub(%r{/+\z}, '')
+      path = safe_executor_path
+      return head(:not_found) if path.nil?
+      return head(:not_found) unless same_origin?(normalized_base, path)
 
-      url = "#{base.sub(%r{/+\z}, '')}/runs/#{params[:run_id]}#{suffix}"
       response = HTTParty.send(
-        method,
-        url,
-        headers: forwarded_headers,
+        request.request_method_symbol,
+        "#{normalized_base}#{path}",
+        headers: forwarded_request_headers,
         query: forwarded_query,
-        body: forwarded_body(method),
+        body: forwarded_body,
         verify: Rails.env.production?,
-        timeout: UPSTREAM_TIMEOUT_IN_SECONDS
+        # Don't follow redirects: a 3xx Location to an off-origin host would bypass the origin guard.
+        follow_redirects: false,
+        open_timeout: OPEN_TIMEOUT_IN_SECONDS,
+        timeout: REQUEST_TIMEOUT_IN_SECONDS
       )
 
+      forward_response_headers(response)
       render json: response.parsed_response, status: response.code
     rescue *UPSTREAM_ERRORS => e
       Rails.logger.error("[ForestLiana] workflow executor proxy error: #{e.class}: #{e.message}")
       render json: { error: 'workflow_executor_unreachable' }, status: :service_unavailable
     end
 
-    def forwarded_headers
-      base = { 'Content-Type' => 'application/json' }
-      FORWARDED_HEADERS.each_with_object(base) do |name, acc|
-        value = request.headers[name]
-        acc[name] = value if value.present?
+    private
+
+    # First-pass rejection of escape attempts; the authoritative origin check is same_origin?.
+    def safe_executor_path
+      wildcard = params[:path].to_s
+      return nil if wildcard.empty? || wildcard.start_with?('/')
+      return nil if UNSAFE_PATH_FRAGMENTS.any? { |fragment| wildcard.include?(fragment) }
+
+      "/#{wildcard}"
+    end
+
+    # Authoritative SSRF check: forwarding must never leave the executor origin.
+    def same_origin?(base, path)
+      base_uri = URI.parse(base)
+      target = URI.parse("#{base}#{path}")
+      target.scheme == base_uri.scheme && target.host == base_uri.host && target.port == base_uri.port
+    rescue URI::InvalidURIError
+      false
+    end
+
+    def forwarded_request_headers
+      request.headers.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[name] = value.to_s
       end
     end
 
+    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 titleize_header(rack_name)
+      rack_name.split('_').map(&:capitalize).join('-')
+    end
+
+    # Strip the routing key (the glob) and Rails internals so only real query params reach the executor.
     def forwarded_query
       params
-        .except(:run_id, :controller, :action, :format)
+        .except(:path, :controller, :action, :format)
         .to_unsafe_h
     end
 
-    def forwarded_body(method)
-      return nil if method == :get
+    def forwarded_body
+      return nil if request.get? || request.head?
+
+      request.raw_post.presence
+    end
+
+    # Forward executor response headers (minus hop-by-hop) so executor-set headers survive the proxy.
+    def forward_response_headers(upstream_response)
+      upstream_response.headers.each do |name, value|
+        next if name.nil? || SKIPPED_HEADERS.include?(name.to_s.downcase)
+
+        forwarded = value.is_a?(Array) ? value.join(', ') : value.to_s
+        next if forwarded.empty?
 
-      raw = request.raw_post
-      raw.presence
+        response.headers[name.to_s] = forwarded
+      end
     end
   end
 end

data/config/routes/actions.rb

@@ -1,9 +1,8 @@
 ForestLiana.apimap.each do |collection|
   if !collection.actions.empty?
     collection.actions.each do |action|
-      if action.hooks && action.hooks[:load].present?
-        post action.endpoint.sub('forest', '') + '/hooks/load' => 'actions#load', action_name: ActiveSupport::Inflector.parameterize(action.name)
-      end
+      # Unconditional: clients probe /hooks/load even when no load hook is declared.
+      post action.endpoint.sub('forest', '') + '/hooks/load' => 'actions#load', action_name: ActiveSupport::Inflector.parameterize(action.name)
       if action.hooks && action.hooks[:change].present?
         post action.endpoint.sub('forest', '') + '/hooks/change' => 'actions#change', action_name: ActiveSupport::Inflector.parameterize(action.name)
       end

data/config/routes.rb

@@ -23,10 +23,10 @@ ForestLiana::Engine.routes.draw do
   # Scopes
   post '/scope-cache-invalidation' => 'scopes#invalidate_scope_cache'
 
-  # Workflow executor proxy (mounted only when ForestLiana.workflow_executor_url is set)
+  # Workflow executor proxy: single catch-all forwarding every verb/sub-path verbatim.
+  # Mounted only when ForestLiana.workflow_executor_url is set.
   if ForestLiana.workflow_executor_url.present?
-    get  '_internal/workflow-executions/:run_id'         => 'workflow_executions#show'
-    post '_internal/workflow-executions/:run_id/trigger' => 'workflow_executions#trigger'
+    match '_internal/executor/*path' => 'workflow_executions#proxy', via: :all
   end
 
   # Stripe Integration

data/lib/forest_liana/version.rb

@@ -1,3 +1,3 @@
 module ForestLiana
-  VERSION = "9.19.0"
+  VERSION = "9.20.1"
 end

data/spec/dummy/lib/forest_liana/collections/island.rb

@@ -28,6 +28,19 @@ class Forest::Island
 
   action 'test'
 
+  action 'static_form_action',
+    fields: [{
+      field: 'static_field',
+      type: 'String',
+      default_value: nil,
+      enums: nil,
+      is_required: false,
+      is_read_only: false,
+      reference: nil,
+      description: nil,
+      widget: nil
+    }]
+
   action 'my_action',
     fields: [foo],
     hooks: {

data/spec/requests/actions_controller_spec.rb

@@ -130,6 +130,25 @@ describe 'Requesting Actions routes', :type => :request  do
         expect(response.status).to eq(422)
       end
 
+      it 'should respond 200 with the static form when the action has no load hook' do
+        post '/forest/actions/static_form_action/hooks/load', params: JSON.dump(params), headers: headers
+        action = island.actions.select { |action| action.name == 'static_form_action' }.first
+        static_field = action.fields.select { |field| field[:field] == 'static_field' }.first
+        expect(response.status).to eq(200)
+        expect(JSON.parse(response.body)).to eq({'fields' => [static_field.merge({:value => nil}).transform_keys { |key| key.to_s.camelize(:lower) }.stringify_keys]})
+
+        first_body = response.body
+        post '/forest/actions/static_form_action/hooks/load', params: JSON.dump(params), headers: headers
+        expect(response.status).to eq(200)
+        expect(response.body).to eq(first_body)
+      end
+
+      it 'should respond 200 with empty fields when the action has no form at all' do
+        post '/forest/actions/test/hooks/load', params: JSON.dump(params), headers: headers
+        expect(response.status).to eq(200)
+        expect(JSON.parse(response.body)).to eq({'fields' => []})
+      end
+
       it 'should respond 500 with bad hook result type' do
         post '/forest/actions/fail_action/hooks/load', params: JSON.dump(params), headers: headers
         expect(response.status).to eq(500)

data/spec/requests/workflow_executions_spec.rb

@@ -1,4 +1,7 @@
 require 'rails_helper'
+require 'zlib'
+require 'stringio'
+require 'socket'
 
 describe 'Workflow executor proxy', type: :request do
   let(:run_id) { 'run_abc123' }
@@ -31,7 +34,16 @@ describe 'Workflow executor proxy', type: :request do
     instance_double(
       HTTParty::Response,
       parsed_response: { 'id' => run_id, 'state' => 'pending' },
-      code: 200
+      code: 200,
+      headers: {
+        'content-type' => 'application/json',
+        # arbitrary executor response header — must be forwarded untouched.
+        'x-executor-custom' => 'passthrough-value',
+        # hop-by-hop response header — must be dropped, not forwarded.
+        'transfer-encoding' => 'chunked',
+        # body-framing header — meaningless once the body is re-serialized; must be dropped.
+        'content-encoding' => 'gzip'
+      }
     )
   end
 
@@ -42,77 +54,130 @@ describe 'Workflow executor proxy', type: :request do
 
     allow(HTTParty).to receive(:get).and_return(executor_response)
     allow(HTTParty).to receive(:post).and_return(executor_response)
+    allow(HTTParty).to receive(:delete).and_return(executor_response)
   end
 
-  describe 'GET /forest/_internal/workflow-executions/:run_id' do
-    it 'forwards GET to the executor /runs/:run_id endpoint' do
-      get "/forest/_internal/workflow-executions/#{run_id}", params: { foo: 'bar' }, headers: auth_headers
+  describe 'generic forwarding' do
+    it 'forwards a run GET (caller includes runs/), preserving the sub-path and query verbatim' do
+      get "/forest/_internal/executor/runs/#{run_id}", params: { foo: 'bar' }, headers: auth_headers
 
       expect(HTTParty).to have_received(:get).with(
         "#{executor_url}/runs/#{run_id}",
+        hash_including(query: hash_including('foo' => 'bar'))
+      )
+    end
+
+    it 'forwards a POST trigger with the raw body untouched (no reshaping)' do
+      raw = { step: 'approve', value: 42 }.to_json
+
+      post(
+        "/forest/_internal/executor/runs/#{run_id}/trigger",
+        params: raw,
+        headers: auth_headers
+      )
+
+      expect(HTTParty).to have_received(:post).with(
+        "#{executor_url}/runs/#{run_id}/trigger",
+        hash_including(body: raw)
+      )
+    end
+
+    it 'forwards a non-runs route verbatim (no /runs prefix injected)' do
+      delete '/forest/_internal/executor/mcp-oauth-credentials', headers: auth_headers
+
+      expect(HTTParty).to have_received(:delete).with(
+        "#{executor_url}/mcp-oauth-credentials",
+        anything
+      )
+    end
+
+    it 'forwards client headers (e.g. Authorization / Cookie) to the executor' do
+      get "/forest/_internal/executor/runs/#{run_id}", headers: auth_headers
+
+      expect(HTTParty).to have_received(:get).with(
+        anything,
         hash_including(
           headers: hash_including(
             'Authorization' => "Bearer #{bearer_token}",
             'Cookie' => 'forest_session_token=session-xyz'
-          ),
-          query: hash_including('foo' => 'bar')
+          )
         )
       )
     end
 
+    it 'does not follow redirects (a 3xx Location must not escape the executor origin)' do
+      get "/forest/_internal/executor/runs/#{run_id}", headers: auth_headers
+
+      expect(HTTParty).to have_received(:get).with(
+        anything,
+        hash_including(follow_redirects: false)
+      )
+    end
+
     it 'returns the executor status and body verbatim' do
-      get "/forest/_internal/workflow-executions/#{run_id}", headers: auth_headers
+      get "/forest/_internal/executor/runs/#{run_id}", headers: auth_headers
 
       expect(response.status).to eq(200)
       expect(JSON.parse(response.body)).to eq('id' => run_id, 'state' => 'pending')
     end
 
-    it 'rejects unauthenticated requests with 401' do
-      get "/forest/_internal/workflow-executions/#{run_id}"
+    it 'forwards executor response headers except hop-by-hop / encoding ones' do
+      get "/forest/_internal/executor/runs/#{run_id}", headers: auth_headers
 
-      expect(response.status).to eq(401)
-      expect(HTTParty).not_to have_received(:get)
+      expect(response.headers['x-executor-custom']).to eq('passthrough-value')
+      expect(response.headers['transfer-encoding']).to be_nil
+      # content-encoding would tell the client the re-serialized JSON is gzipped → corruption.
+      expect(response.headers['content-encoding']).to be_nil
     end
-  end
 
-  describe 'POST /forest/_internal/workflow-executions/:run_id/trigger' do
-    let(:trigger_body) { { step: 'approve', value: 42 } }
+    it 'does not forward accept-encoding (would defeat transparent gzip decompression)' do
+      get "/forest/_internal/executor/runs/#{run_id}",
+          headers: auth_headers.merge('Accept-Encoding' => 'gzip, deflate')
 
-    it 'forwards POST to the executor /runs/:run_id/trigger endpoint with the body' do
-      post(
-        "/forest/_internal/workflow-executions/#{run_id}/trigger",
-        params: trigger_body.to_json,
-        headers: auth_headers
+      expect(HTTParty).to have_received(:get).with(
+        anything,
+        hash_including(headers: hash_excluding('Accept-Encoding'))
       )
+    end
+  end
 
-      expect(HTTParty).to have_received(:post).with(
-        "#{executor_url}/runs/#{run_id}/trigger",
-        hash_including(
-          headers: hash_including('Authorization' => "Bearer #{bearer_token}"),
-          body: trigger_body.to_json
-        )
-      )
+  describe 'SSRF guard (cannot escape the executor origin)' do
+    [
+      '..',
+      '../mcp-oauth-credentials',
+      "#{'run_abc123'}/../../mcp-oauth-credentials",
+      '%2e%2e/mcp-oauth-credentials'
+    ].each do |evil_path|
+      it "rejects #{evil_path.inspect} with 404 and never forwards" do
+        get "/forest/_internal/executor/#{evil_path}", headers: auth_headers
+
+        expect(response.status).to eq(404)
+        expect(HTTParty).not_to have_received(:get)
+      end
     end
+  end
 
-    it 'returns the executor response' do
-      post(
-        "/forest/_internal/workflow-executions/#{run_id}/trigger",
-        params: trigger_body.to_json,
-        headers: auth_headers
-      )
+  describe 'authentication' do
+    it 'rejects unauthenticated requests with 401' do
+      get "/forest/_internal/executor/runs/#{run_id}"
 
-      expect(response.status).to eq(200)
-      expect(JSON.parse(response.body)).to eq('id' => run_id, 'state' => 'pending')
+      expect(response.status).to eq(401)
+      expect(HTTParty).not_to have_received(:get)
     end
   end
 
   describe 'when the executor returns an error status' do
     let(:executor_response) do
-      instance_double(HTTParty::Response, parsed_response: { 'error' => 'invalid_step' }, code: 422)
+      instance_double(
+        HTTParty::Response,
+        parsed_response: { 'error' => 'invalid_step' },
+        code: 422,
+        headers: { 'content-type' => 'application/json' }
+      )
     end
 
     it 'forwards the executor status and body to the client' do
-      get "/forest/_internal/workflow-executions/#{run_id}", headers: auth_headers
+      get "/forest/_internal/executor/runs/#{run_id}", headers: auth_headers
 
       expect(response.status).to eq(422)
       expect(JSON.parse(response.body)).to eq('error' => 'invalid_step')
@@ -125,13 +190,73 @@ describe 'Workflow executor proxy', type: :request do
     end
 
     it 'returns 503 service_unavailable' do
-      get "/forest/_internal/workflow-executions/#{run_id}", headers: auth_headers
+      get "/forest/_internal/executor/runs/#{run_id}", headers: auth_headers
+
+      expect(response.status).to eq(503)
+      expect(JSON.parse(response.body)).to eq('error' => 'workflow_executor_unreachable')
+    end
+  end
+
+  describe 'when the executor connection fails at the transport level (e.g. SSL)' do
+    before do
+      allow(HTTParty).to receive(:get).and_raise(OpenSSL::SSL::SSLError.new('cert verify failed'))
+    end
+
+    it 'returns 503 rather than a generic 500' do
+      get "/forest/_internal/executor/runs/#{run_id}", headers: auth_headers
 
       expect(response.status).to eq(503)
       expect(JSON.parse(response.body)).to eq('error' => 'workflow_executor_unreachable')
     end
   end
 
+  # Real local server + real HTTParty (no stub) to exercise actual gzip decompression.
+  describe 'when the executor gzip-compresses the response (nginx in front)' do
+    let(:gz_body) do
+      io = StringIO.new
+      writer = Zlib::GzipWriter.new(io)
+      writer.write({ 'id' => run_id, 'state' => 'pending' }.to_json)
+      writer.close
+      io.string
+    end
+
+    around do |example|
+      server = TCPServer.new('127.0.0.1', 0)
+      port = server.addr[1]
+      thread = Thread.new do
+        client = server.accept
+        client.readpartial(4096)
+        client.write(
+          "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\n" \
+          "Content-Encoding: gzip\r\nContent-Length: #{gz_body.bytesize}\r\n" \
+          "Connection: close\r\n\r\n"
+        )
+        client.write(gz_body)
+        client.close
+      rescue IOError, Errno::ECONNRESET, Errno::EPIPE
+        nil
+      end
+
+      original = ForestLiana.workflow_executor_url
+      ForestLiana.workflow_executor_url = "http://127.0.0.1:#{port}"
+      example.run
+    ensure
+      ForestLiana.workflow_executor_url = original
+      thread&.kill
+      server&.close
+    end
+
+    before { allow(HTTParty).to receive(:get).and_call_original }
+
+    it 'decompresses the body and drops the stale content-encoding' do
+      get "/forest/_internal/executor/runs/#{run_id}", headers: auth_headers
+
+      expect(response.status).to eq(200)
+      expect(JSON.parse(response.body)).to eq('id' => run_id, 'state' => 'pending')
+      expect(response.headers['content-encoding']).to be_nil
+    end
+  end
+
   describe 'when ForestLiana.workflow_executor_url is blank' do
     around do |example|
       original = ForestLiana.workflow_executor_url
@@ -145,7 +270,7 @@ describe 'Workflow executor proxy', type: :request do
       # Note: routes are mounted at boot based on workflow_executor_url being
       # present. This test exercises the runtime guard inside the controller
       # for scenarios where config is mutated after boot (e.g. tests).
-      get "/forest/_internal/workflow-executions/#{run_id}", headers: auth_headers
+      get "/forest/_internal/executor/runs/#{run_id}", headers: auth_headers
 
       expect(response.status).to eq(404)
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: forest_liana
 version: !ruby/object:Gem::Version
-  version: 9.19.0
+  version: 9.20.1
 platform: ruby
 authors:
 - Sandro Munda
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-10 00:00:00.000000000 Z
+date: 2026-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails