woods 1.6.4 → 2.0.0.beta1

data/lib/woods/console/connection_manager.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'json'
-require 'open3'
 require 'shellwords'
 
 # @see Woods
@@ -11,162 +9,79 @@ module Woods
   module Console
     class ConnectionError < Woods::Error; end
 
-    # Manages the bridge process connection via Docker exec, direct spawn, or SSH.
-    #
-    # Spawns and manages the bridge process, sends JSON-lines requests,
-    # receives responses. Implements heartbeat (30s) and reconnect with
-    # exponential backoff (max 5 retries).
-    #
-    # @example
-    #   manager = ConnectionManager.new(config: {
-    #     'mode' => 'direct',
-    #     'command' => 'bundle exec rails runner bridge.rb'
-    #   })
-    #   manager.connect!
-    #   response = manager.send_request({ 'id' => 'r1', 'tool' => 'status', 'params' => {} })
-    #   manager.disconnect!
+    # Resolves and launches an embedded Console MCP process.
     #
+    # The former implementation spoke a private JSON-lines bridge protocol to
+    # a scaffold that returned static data. The supported path now forwards the
+    # MCP client's stdio directly to the real embedded server by replacing this
+    # process with a direct, Docker, or SSH command.
     class ConnectionManager
-      MAX_RETRIES = 5
-      HEARTBEAT_INTERVAL = 30
-
-      # @param config [Hash] Connection configuration
-      # @option config [String] 'mode' Connection mode: 'docker', 'direct', or 'ssh'
-      # @option config [String] 'command' Command to run the bridge
-      # @option config [String] 'container' Docker container name (docker mode)
-      # @option config [String] 'directory' Working directory (direct mode)
-      # @option config [String] 'host' SSH host (ssh mode)
-      # @option config [String] 'user' SSH user (ssh mode)
+      DEFAULT_COMMAND = 'bundle exec rake woods:console'
+
+      # @param config [Hash] Process-launch configuration
+      # @option config [String] 'mode' direct, docker, or ssh (default: direct)
+      # @option config [String] 'command' Embedded server command
+      # @option config [String] 'directory' Working directory for direct mode
+      # @option config [String] 'container' Container name for docker mode
+      # @option config [String] 'host' SSH host for ssh mode
+      # @option config [String] 'user' Optional SSH user
       def initialize(config:)
         @config = config
-        @mode = config['mode'] || 'direct'
-        @command = config['command'] || 'bundle exec rails runner lib/woods/console/bridge.rb'
-        @stdin = nil
-        @stdout = nil
-        @wait_thread = nil
-        @retries = 0
-        @last_heartbeat = nil
+        @mode = config.fetch('mode', 'direct')
+        @embedded_command = config.fetch('command', DEFAULT_COMMAND)
       end
 
-      # Spawn the bridge process.
+      # Return the argv used to launch the embedded MCP server.
       #
-      # @return [void]
-      # @raise [ConnectionError] if the process cannot be started
-      def connect!
-        cmd = build_command
-        if @mode == 'direct' && @config['directory']
-          Dir.chdir(@config['directory']) do
-            @stdin, @stdout, @wait_thread = Open3.popen2(*cmd)
-          end
-        else
-          @stdin, @stdout, @wait_thread = Open3.popen2(*cmd)
+      # @return [Array<String>]
+      # @raise [ConnectionError] when the mode is invalid or incomplete
+      def command
+        case @mode
+        when 'direct' then embedded_argv
+        when 'docker' then docker_command
+        when 'ssh' then ssh_command
+        else raise ConnectionError, "Unknown connection mode: #{@mode}"
         end
-        @last_heartbeat = Time.now
-        @retries = 0
-      rescue StandardError => e
-        raise ConnectionError, "Failed to connect (#{@mode}): #{e.message}"
       end
 
-      # Terminate the bridge process.
+      # Replace the current process with the embedded MCP server.
       #
-      # @return [void]
-      def disconnect!
-        @stdin&.close
-        @stdout&.close
-        @wait_thread&.value
-        @stdin = nil
-        @stdout = nil
-        @wait_thread = nil
-      end
-
-      # Send a request to the bridge and read the response.
-      #
-      # @param request [Hash] JSON-serializable request hash
-      # @return [Hash] Parsed response hash
-      # @raise [ConnectionError] if communication fails after retries
-      def send_request(request)
-        ensure_connected!
-        @stdin.puts(JSON.generate(request))
-        @stdin.flush
-        line = @stdout.gets
-        raise ConnectionError, 'Bridge process closed unexpectedly' unless line
-
-        @last_heartbeat = Time.now
-        JSON.parse(line)
-      rescue IOError, Errno::EPIPE, Errno::ECONNRESET => e
-        reconnect_or_raise!(e)
-        retry
-      end
-
-      # Check if the bridge process is alive.
+      # Process replacement gives the MCP client direct ownership of lifecycle:
+      # EOF, INT, and TERM reach the real server without an intermediate process
+      # that can hang while waiting for a child.
       #
-      # @return [Boolean]
-      def alive?
-        return false unless @wait_thread
-
-        @wait_thread.alive?
-      end
-
-      # Check if a heartbeat is needed (30s since last communication).
-      #
-      # @return [Boolean]
-      def heartbeat_needed?
-        return false unless @last_heartbeat
-
-        (Time.now - @last_heartbeat) >= HEARTBEAT_INTERVAL
+      # @return [void]
+      # @raise [ConnectionError] when the process cannot be launched
+      def replace_process!
+        if @mode == 'direct' && @config['directory']
+          Dir.chdir(@config['directory']) { exec(*command) }
+        else
+          exec(*command)
+        end
+      rescue SystemCallError, ArgumentError => e
+        raise ConnectionError, "Failed to launch embedded Console MCP (#{@mode}): #{e.message}"
       end
 
       private
 
-      # Build the shell command based on connection mode.
-      #
-      # @return [Array<String>]
-      def build_command
-        case @mode
-        when 'docker' then build_docker_command
-        when 'ssh'    then build_ssh_command
-        when 'direct' then build_direct_command
-        else raise ConnectionError, "Unknown connection mode: #{@mode}"
-        end
+      def embedded_argv
+        argv = @embedded_command.to_s.shellsplit
+        raise ConnectionError, 'Console command must not be empty' if argv.empty?
+
+        argv
+      rescue ArgumentError => e
+        raise ConnectionError, "Invalid console command: #{e.message}"
       end
 
-      def build_docker_command
+      def docker_command
         container = @config['container'] || raise(ConnectionError, 'Docker mode requires container name')
-        ['docker', 'exec', '-i', container] + @command.shellsplit
+        ['docker', 'exec', '-i', container] + embedded_argv
       end
 
-      def build_ssh_command
+      def ssh_command
         host = @config['host'] || raise(ConnectionError, 'SSH mode requires host')
-        user = @config['user']
-        target = user ? "#{user}@#{host}" : host
-        ['ssh', target] + @command.shellsplit
-      end
-
-      def build_direct_command
-        @command.shellsplit
-      end
-
-      # Ensure the connection is active.
-      def ensure_connected!
-        return if alive?
-
-        connect!
-      end
-
-      # Attempt reconnection with exponential backoff.
-      #
-      # @param error [StandardError] The original error
-      # @raise [ConnectionError] if max retries exceeded
-      def reconnect_or_raise!(error)
-        @retries += 1
-        if @retries > MAX_RETRIES
-          raise ConnectionError,
-                "Connection failed after #{MAX_RETRIES} retries: #{error.message}"
-        end
-
-        sleep((2**(@retries - 1)) * 0.1)
-        disconnect!
-        connect!
+        target = @config['user'] ? "#{@config['user']}@#{host}" : host
+        ['ssh', target] + embedded_argv
       end
     end
   end

data/lib/woods/console/credential_index.rb

@@ -46,7 +46,7 @@ module Woods
     #   index.redact("token: sk_live_actual_secret_value")
     #     # => "token: [REDACTED:credential]"
     #
-    class CredentialIndex # rubocop:disable Metrics/ClassLength
+    class CredentialIndex
       # Captured at require time so the mtime-check warning has a stable
       # reference point even if the clock skews later. Frozen immediately
       # to prevent accidental mutation.
@@ -68,7 +68,6 @@ module Woods
       MISSING_KEY_ERRORS = %w[
         ActiveSupport::EncryptedConfiguration::MissingKeyError
         ActiveSupport::EncryptedFile::MissingKeyError
-        ActiveSupport::EncryptedFile::MissingContentError
         ActiveSupport::MessageEncryptor::InvalidMessage
       ].freeze
 
@@ -91,19 +90,13 @@ module Woods
         # @return [CredentialIndex] populated index, or an empty index when
         #   the credentials store can't be opened.
         def build(rails_app:)
-          refresh(rails_app: rails_app)
+          new(secrets: collect_secrets(rails_app))
         rescue StandardError => e
           raise unless missing_key_error?(e)
 
           new(secrets: [])
         end
 
-        # Strict refresh: construct the replacement completely before a caller
-        # installs it. Unlike boot-time .build, errors must preserve the old index.
-        def refresh(rails_app:)
-          new(secrets: collect_secrets(rails_app))
-        end
-
         # Emit a structured log warning when any of the given credentials
         # files has a modification time newer than `process_start`. This
         # catches the common "rotated credentials but forgot to restart"
@@ -143,23 +136,12 @@ module Woods
         private
 
         def collect_secrets(rails_app)
-          config = fresh_credentials(rails_app.credentials).config
+          config = rails_app.credentials.config
           collected = []
           walk(config, collected)
           collected
         end
 
-        def fresh_credentials(credentials)
-          return credentials unless defined?(ActiveSupport::EncryptedConfiguration) &&
-                                    credentials.is_a?(ActiveSupport::EncryptedConfiguration)
-
-          require_relative 'encrypted_credential_snapshot'
-          EncryptedCredentialSnapshot.new(
-            config_path: credentials.content_path, key_path: credentials.key_path,
-            env_key: credentials.env_key, raise_if_missing_key: true
-          )
-        end
-
         def walk(node, collected)
           case node
           when Hash  then node.each_value { |v| walk(v, collected) }
@@ -187,10 +169,7 @@ module Woods
       def initialize(secrets:)
         filtered = Array(secrets).select { |s| s.is_a?(String) && s.length >= MIN_LENGTH }
         @secrets = filtered.to_set.freeze
-        # Regexp alternatives match in order: a shorter prefix must not consume
-        # only the start of a longer indexed credential and expose its suffix.
-        longest_first = @secrets.each_with_index.sort_by { |secret, idx| [-secret.length, idx] }.map(&:first)
-        @pattern = @secrets.empty? ? nil : Regexp.union(longest_first)
+        @pattern = @secrets.empty? ? nil : Regexp.union(@secrets.to_a)
       end
 
       # @return [Boolean] true when no secrets were collected (missing key,
@@ -215,34 +194,7 @@ module Woods
       def redact(str)
         return str if empty? || !str.is_a?(String) || !@pattern.match?(str)
 
-        offset = 0
-        parts = []
-        redaction_spans(str).each do |start, finish|
-          parts << str[offset...start] << REDACTED
-          offset = finish
-        end
-        parts << str[offset..]
-        parts.join
-      end
-
-      private
-
-      # Search from each match's start, rather than its end, so an overlapping
-      # credential cannot expose its suffix after an earlier replacement.
-      # Union the covered spans before changing the original string.
-      def redaction_spans(str)
-        spans = []
-        offset = 0
-        while (match = @pattern.match(str, offset))
-          start, finish = match.offset(0)
-          if spans.last && start < spans.last[1]
-            spans.last[1] = [spans.last[1], finish].max
-          else
-            spans << [start, finish]
-          end
-          offset = start + 1
-        end
-        spans
+        str.gsub(@pattern, REDACTED)
       end
     end
   end

data/lib/woods/console/credential_scanner.rb

@@ -145,7 +145,7 @@ module Woods
 
       # Scan a value (String, Hash, Array, or any other object) for credentials.
       #
-      # Strings and Symbols are scanned against every active pattern. Hash values and Array
+      # Strings are gsub'd against every active pattern. Hash values and Array
       # elements are walked recursively; keys and non-string scalars
       # (Integer, Float, true/false, nil) pass through untouched.
       #
@@ -155,18 +155,17 @@ module Woods
       #   for patterns that fired — callers should treat a missing key as zero.
       def scan(value)
         counts = {}
-        scanned = walk(value, counts, @secret_index)
+        scanned = walk(value, counts)
         [scanned, counts]
       end
 
       private
 
-      def walk(value, counts, index)
+      def walk(value, counts)
         case value
-        when String then scan_string(value, counts, index)
-        when Symbol then scan_string(value.to_s, counts, index).to_sym
-        when Hash   then walk_hash(value, counts, index)
-        when Array  then value.map { |item| walk(item, counts, index) }
+        when String then scan_string(value, counts)
+        when Hash   then walk_hash(value, counts)
+        when Array  then value.map { |item| walk(item, counts) }
         else value
         end
       end
@@ -178,19 +177,19 @@ module Woods
       # credential-shaped string is emitted as a Symbol after redaction
       # (e.g. `:"[REDACTED]"`). String keys stay Strings. Non-String,
       # non-Symbol keys (Integer, etc.) pass through unchanged.
-      def walk_hash(hash, counts, index)
+      def walk_hash(hash, counts)
         hash.each_with_object({}) do |(key, val), out|
           scanned_key = case key
-                        when String then scan_string(key, counts, index)
-                        when Symbol then scan_string(key.to_s, counts, index).to_sym
+                        when String then scan_string(key, counts)
+                        when Symbol then scan_string(key.to_s, counts).to_sym
                         else             key
                         end
-          out[scanned_key] = walk(val, counts, index)
+          out[scanned_key] = walk(val, counts)
         end
       end
 
-      def scan_string(str, counts, index)
-        result = redact_indexed_secrets(str, counts, index)
+      def scan_string(str, counts)
+        result = redact_indexed_secrets(str, counts)
         result = scan_encoded_forms(result, counts)
         @active_patterns.inject(result) do |acc, (name, pattern)|
           acc.gsub(pattern) do
@@ -291,10 +290,10 @@ module Woods
         printable.to_f / str.length >= PRINTABLE_RATIO_THRESHOLD
       end
 
-      def redact_indexed_secrets(str, counts, index)
-        return str unless index&.match?(str)
+      def redact_indexed_secrets(str, counts)
+        return str unless @secret_index&.match?(str)
 
-        redacted = index.redact(str)
+        redacted = @secret_index.redact(str)
         counts[INDEX_HIT] = (counts[INDEX_HIT] || 0) + redacted.scan(CredentialIndex::REDACTED).size
         redacted
       end

data/lib/woods/console/dispatch_pipeline.rb

@@ -2,6 +2,7 @@
 
 require 'json'
 require_relative 'response_context'
+require_relative 'input_contract'
 
 module Woods
   module Console
@@ -10,8 +11,7 @@ module Woods
     # Encapsulates everything that happens between MCP's `define_tool` block
     # firing and the `MCP::Tool::Response` returning to the client:
     #
-    #   1. Coerce integer-typed args from strings. MCP clients sometimes send
-    #      `"10"` for an `integer` property — we normalize before dispatch.
+    #   1. Strictly parse integer strings and enforce schema bounds.
     #   2. Run the Layer 1 table gate ({ResponseContext#enforce!}).
     #   3. Translate the tool args into a bridge/executor request via the
     #      handler proc supplied in the {ToolSpec}.
@@ -31,8 +31,7 @@ module Woods
     class DispatchPipeline
       # @param tool_name [String]
       # @param handler [#call] Maps a Hash of tool args to a bridge request Hash.
-      # @param integer_keys [Array<Symbol>] Property keys declared as `integer`
-      #   in the tool schema.
+      # @param properties [Hash] ToolSpec JSON Schema properties.
       # @param conn_mgr [#send_request] ConnectionManager or EmbeddedExecutor.
       # @param ctx [ResponseContext] Bundles the three response-safety layers.
       #   Defaults to the Null context so tests can stub minimally.
@@ -40,11 +39,11 @@ module Woods
       # @param logger [#warn, nil] Structured logger used for credential-scan
       #   and table-gate telemetry. Failures are swallowed so observability
       #   issues never break a tool response.
-      def initialize(tool_name:, handler:, integer_keys:, conn_mgr:, # rubocop:disable Metrics/ParameterLists
+      def initialize(tool_name:, handler:, properties:, conn_mgr:, # rubocop:disable Metrics/ParameterLists
                      ctx: NullResponseContext.instance, renderer: nil, logger: nil)
         @tool_name = tool_name
         @handler = handler
-        @integer_keys = integer_keys
+        @properties = properties
         @conn_mgr = conn_mgr
         @ctx = ctx
         @renderer = renderer
@@ -56,52 +55,61 @@ module Woods
       # @param args [Hash] Tool arguments (symbol keys from MCP).
       # @return [MCP::Tool::Response]
       def call(args)
-        coerce_integer_args!(args)
+        InputContract.normalize!(args, @properties)
         @ctx.enforce!(args)
         request = @handler.call(args).transform_keys(&:to_s)
         send_to_bridge(request)
       rescue TableGateError => e
         log_table_gate_rejection(args, e)
-        error_response(e.message)
-      rescue SqlValidationError, ForbiddenExpressionError => e
-        error_response(e.message)
+        error_response(scan_early_error(e.message))
+      rescue InputContract::ValidationError, SqlValidationError, ForbiddenExpressionError => e
+        error_response(scan_early_error(e.message))
+      rescue StandardError => e
+        # Catch-all for pipeline bugs — a renderer NoMethodError, an encoding
+        # oddity, a handler defect (L9). Without it the exception escaped into
+        # the `mcp` gem's own handling of a raising tool block, which can echo
+        # `Class: message` to the client: a leak channel the executor's
+        # responses are already sanitized against. Answer with the same
+        # sanitized shape the executor uses (class name only, details logged
+        # server-side), still routed through the credential scan so nothing an
+        # exception message picked up reaches the client either.
+        log_unexpected_error(e)
+        error_response(scan_early_error(sanitized_unexpected_error(e)))
       end
 
       private
 
-      def coerce_integer_args!(args)
-        @integer_keys.each { |k| args[k] = args[k].to_i if args[k].is_a?(String) }
+      # Client-safe stand-in for an unexpected exception. Names the tool so an
+      # agent can retry or report, and nothing else — the class and message
+      # go to the log instead.
+      def sanitized_unexpected_error(_error)
+        "Internal error in #{@tool_name} (details logged server-side)"
+      end
+
+      def log_unexpected_error(error)
+        return unless @logger
+
+        @logger.warn(
+          'console.dispatch.unexpected_error',
+          tool: @tool_name,
+          error_class: error.class.name,
+          message: error.message
+        )
+      rescue StandardError
+        nil
       end
 
       def send_to_bridge(request)
         response = @conn_mgr.send_request(request)
         return error_from_response(response, request) unless response['ok']
 
-        render_response(response['result'], request)
-      rescue ConnectionError => e
-        scanned = scan_for_credentials("Connection error: #{e.message}", request)
-        error_response(scanned)
-      end
-
-      def render_response(result, request)
-        # Remove protected values before custom serializers run, then scan
-        # the materialized representation consumed by both response renderers.
-        result = @ctx.redact(result)
-        result = JSON.parse(JSON.generate(result))
-        result = @ctx.redact(result)
+        result = @ctx.redact(response['result'])
         result = scan_for_credentials(result, request)
         text = @renderer ? @renderer.render_default(result) : JSON.pretty_generate(result)
         success_response(text)
-      rescue StandardError
-        # SDK 0.x includes uncaught exception messages in its tool errors.
-        # Serializer/parser/renderer messages may contain unscanned values.
-        rendering_error_response(request)
-      end
-
-      def rendering_error_response(request)
-        error_response(scan_for_credentials('Console response could not be serialized safely.', request))
-      rescue StandardError
-        error_response('[REDACTION_FAILED]')
+      rescue ConnectionError => e
+        scanned = scan_for_credentials("Connection error: #{e.message}", request)
+        error_response(scanned)
       end
 
       def error_from_response(response, request)
@@ -116,6 +124,10 @@ module Woods
         scanned
       end
 
+      def scan_early_error(message)
+        scan_for_credentials(message, 'tool' => @tool_name.delete_prefix('console_'))
+      end
+
       def log_credential_hits(request, counts)
         return unless @logger