actionagent 0.0.0 → 1.2.0

data/app/services/action_agent/mcp_catalog.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+module ActionAgent
+  # The catalog of MCP servers the dashboard knows about.
+  #
+  # Serves three jobs that would otherwise each need their own list:
+  #
+  # 1. **Listing** — the MCP Services view shows these as the servers a
+  #    workspace can connect, whether or not it has used one yet.
+  # 2. **Attribution** — telemetry only carries the tool name a provider
+  #    invoked. When that name is namespaced (+mcp__playwright__…+) the server
+  #    is explicit; when it isn't, TOOL_HINTS maps well-known bare tool names
+  #    back to the server that serves them, so a workspace running the
+  #    reference servers still gets grouped traffic instead of a flat list.
+  # 3. **Provisioning** — entries marked +sandbox: true+ can be started inside
+  #    a sandbox session, using the command recorded here.
+  #
+  # Detection never depends on this catalog: a server that isn't listed still
+  # shows up in the MCP Services view (as +known: false+) the moment a
+  # namespaced tool call from it is ingested. The catalog only adds names,
+  # descriptions, and the ability to launch.
+  class McpCatalog
+    # Whether a server can be started inside a sandbox session. Servers that
+    # need workspace-specific credentials (github, slack, postgres) are
+    # listable and attributable but not launchable from the dashboard — there
+    # is nowhere safe to source their secrets from yet.
+    SERVERS = [
+      {
+        key: "playwright",
+        name: "Playwright",
+        description: "Drives a real browser: navigate pages, snapshot the accessibility tree, click elements.",
+        transport: "stdio",
+        command: "npx @playwright/mcp@latest",
+        package: "@playwright/mcp",
+        categories: %w[browser automation],
+        docs_url: "https://github.com/microsoft/playwright-mcp",
+        sandbox: true,
+        sandbox_type: "playwright_mcp",
+        # The platform's own Playwright tools (AgentToolbox "playwright_mcp")
+        # invoke these bare, without the mcp__ namespace.
+        tool_hints: %w[browser_navigate browser_snapshot browser_click browser_type browser_take_screenshot]
+      },
+      {
+        key: "filesystem",
+        name: "Filesystem",
+        description: "Reads and writes files under an allow-listed set of directories.",
+        transport: "stdio",
+        command: "npx @modelcontextprotocol/server-filesystem",
+        package: "@modelcontextprotocol/server-filesystem",
+        categories: %w[files],
+        docs_url: "https://github.com/modelcontextprotocol/servers/tree/main/src/filesystem",
+        sandbox: true,
+        sandbox_type: "terminal",
+        tool_hints: %w[read_file read_text_file write_file edit_file list_directory directory_tree move_file search_files]
+      },
+      {
+        key: "fetch",
+        name: "Fetch",
+        description: "Fetches a URL and converts the page to markdown for the model to read.",
+        transport: "stdio",
+        command: "uvx mcp-server-fetch",
+        package: "mcp-server-fetch",
+        categories: %w[web],
+        docs_url: "https://github.com/modelcontextprotocol/servers/tree/main/src/fetch",
+        sandbox: true,
+        sandbox_type: "research",
+        tool_hints: %w[fetch fetch_url]
+      },
+      {
+        key: "git",
+        name: "Git",
+        description: "Reads and manipulates a local git repository: status, diff, log, commit.",
+        transport: "stdio",
+        command: "uvx mcp-server-git",
+        package: "mcp-server-git",
+        categories: %w[code vcs],
+        docs_url: "https://github.com/modelcontextprotocol/servers/tree/main/src/git",
+        sandbox: true,
+        sandbox_type: "terminal",
+        tool_hints: %w[git_status git_diff git_log git_commit git_add git_create_branch]
+      },
+      {
+        key: "memory",
+        name: "Memory",
+        description: "A persistent knowledge graph the agent can write facts to and recall across runs.",
+        transport: "stdio",
+        command: "npx @modelcontextprotocol/server-memory",
+        package: "@modelcontextprotocol/server-memory",
+        categories: %w[memory],
+        docs_url: "https://github.com/modelcontextprotocol/servers/tree/main/src/memory",
+        sandbox: true,
+        sandbox_type: "terminal",
+        tool_hints: %w[create_entities create_relations add_observations search_nodes read_graph]
+      },
+      {
+        key: "sequential-thinking",
+        name: "Sequential Thinking",
+        description: "Gives the model a scratchpad for multi-step reasoning it can revise as it goes.",
+        transport: "stdio",
+        command: "npx @modelcontextprotocol/server-sequential-thinking",
+        package: "@modelcontextprotocol/server-sequential-thinking",
+        categories: %w[reasoning],
+        docs_url: "https://github.com/modelcontextprotocol/servers/tree/main/src/sequentialthinking",
+        sandbox: true,
+        sandbox_type: "research",
+        tool_hints: %w[sequentialthinking]
+      },
+      {
+        key: "github",
+        name: "GitHub",
+        description: "Reads and writes GitHub issues, pull requests, and repository contents.",
+        transport: "http",
+        url: "https://api.githubcopilot.com/mcp/",
+        categories: %w[code vcs],
+        docs_url: "https://github.com/github/github-mcp-server",
+        sandbox: false,
+        requires_credentials: [ "GITHUB_TOKEN" ],
+        tool_hints: %w[create_issue get_issue list_issues create_pull_request get_file_contents search_code]
+      },
+      {
+        key: "slack",
+        name: "Slack",
+        description: "Posts messages and reads channel history in a connected Slack workspace.",
+        transport: "stdio",
+        command: "npx @modelcontextprotocol/server-slack",
+        package: "@modelcontextprotocol/server-slack",
+        categories: %w[communication],
+        docs_url: "https://github.com/modelcontextprotocol/servers/tree/main/src/slack",
+        sandbox: false,
+        requires_credentials: [ "SLACK_BOT_TOKEN", "SLACK_TEAM_ID" ],
+        tool_hints: %w[slack_post_message slack_list_channels slack_get_channel_history]
+      },
+      {
+        key: "postgres",
+        name: "Postgres",
+        description: "Runs read-only SQL against a Postgres database and inspects its schema.",
+        transport: "stdio",
+        command: "npx @modelcontextprotocol/server-postgres",
+        package: "@modelcontextprotocol/server-postgres",
+        categories: %w[data],
+        docs_url: "https://github.com/modelcontextprotocol/servers/tree/main/src/postgres",
+        sandbox: false,
+        requires_credentials: [ "DATABASE_URL" ],
+        tool_hints: %w[query describe_table list_tables]
+      },
+      {
+        key: "activeagents",
+        name: "Active Agent",
+        description: "This dashboard's own agents, exposed as MCP tools and agent:// resources over Streamable HTTP.",
+        transport: "http",
+        # Relative to wherever the engine is mounted — the same <mount>/mcp
+        # route the dashboard serves.
+        url: "<mount>/mcp",
+        categories: %w[agents platform],
+        docs_url: "https://docs.activeagents.ai/mcp",
+        sandbox: false,
+        first_party: true,
+        requires_credentials: [ "Platform API key" ],
+        tool_hints: %w[call_agent list_agents]
+      }
+    ].freeze
+
+    # key => entry, for O(1) lookup by name.
+    BY_KEY = SERVERS.index_by { |server| server[:key] }.freeze
+
+    # Bare tool name => server key. Built from each entry's tool_hints, so
+    # adding a server to SERVERS is all it takes to teach attribution about
+    # its tools. First declaration wins on collision (a name served by two
+    # catalog entries stays with the earlier, more specific one).
+    TOOL_HINTS = SERVERS.each_with_object({}) do |server, map|
+      Array(server[:tool_hints]).each { |tool| map[tool] ||= server[:key] }
+    end.freeze
+
+    class << self
+      # Every catalog entry, as API-shaped hashes.
+      #
+      # @return [Array<Hash>]
+      def all
+        SERVERS.map { |server| present(server) }
+      end
+
+      # Entries that can be started inside a sandbox session.
+      #
+      # @return [Array<Hash>]
+      def launchable
+        all.select { |server| server[:sandbox] }
+      end
+
+      # @param key [String, Symbol]
+      # @return [Hash, nil] the catalog entry, or nil when unknown
+      def find(key)
+        entry = BY_KEY[key.to_s]
+        present(entry) if entry
+      end
+
+      # @param key [String, Symbol]
+      # @return [Boolean] whether the server can be started in a sandbox
+      def launchable?(key)
+        BY_KEY[key.to_s]&.fetch(:sandbox, false) || false
+      end
+
+      # The catalog server a bare (non-namespaced) tool name belongs to.
+      #
+      # Only consulted after namespace parsing fails — an explicit
+      # +mcp__server__tool+ name always wins over a hint, because the trace
+      # said so and this table is only an educated guess.
+      #
+      # @param tool_name [String, Symbol]
+      # @return [String, nil] the server key
+      def server_for_tool(tool_name)
+        TOOL_HINTS[tool_name.to_s]
+      end
+
+      # The display name for a server key, falling back to the key itself for
+      # servers detected in telemetry but absent from the catalog.
+      #
+      # @param key [String, Symbol]
+      # @return [String]
+      def display_name(key)
+        BY_KEY[key.to_s]&.fetch(:name) || key.to_s
+      end
+
+      private
+
+      # Drops the internal-only tool_hints and normalizes optional keys so
+      # every entry serializes with the same shape.
+      def present(server)
+        {
+          key: server[:key],
+          name: server[:name],
+          description: server[:description],
+          transport: server[:transport],
+          command: server[:command],
+          url: server[:url],
+          package: server[:package],
+          categories: Array(server[:categories]),
+          docs_url: server[:docs_url],
+          sandbox: server.fetch(:sandbox, false),
+          sandbox_type: server[:sandbox_type],
+          first_party: server.fetch(:first_party, false),
+          requires_credentials: Array(server[:requires_credentials]),
+          tools: Array(server[:tool_hints])
+        }
+      end
+    end
+  end
+end

data/app/services/action_agent/mcp_recording_middleware.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+module ActionAgent
+  # Middleware for recording MCP tool calls during browser automation
+  #
+  # This middleware intercepts Playwright MCP tool calls and records them
+  # to a SessionRecording for playback and debugging.
+  #
+  # Usage:
+  #   middleware = McpRecordingMiddleware.new(session_recording: recording)
+  #
+  #   # Process a tool call
+  #   result = middleware.intercept(tool_call) do
+  #     # Execute the actual MCP tool
+  #     mcp_client.call_tool(tool_call)
+  #   end
+  #
+  class McpRecordingMiddleware
+    # Map of Playwright MCP tool names to our action types
+    PLAYWRIGHT_TOOLS = {
+      "browser_navigate" => "navigate",
+      "browser_click" => "click",
+      "browser_type" => "type",
+      "browser_fill_form" => "form_fill",
+      "browser_press_key" => "key_press",
+      "browser_snapshot" => "snapshot",
+      "browser_take_screenshot" => "snapshot",
+      "browser_hover" => "hover",
+      "browser_select_option" => "select",
+      "browser_file_upload" => "file_upload",
+      "browser_handle_dialog" => "dialog",
+      "browser_evaluate" => "evaluate",
+      "browser_wait_for" => "wait",
+      "browser_drag" => "drag",
+      "browser_scroll" => "scroll"
+    }.freeze
+
+    attr_reader :recording_service
+
+    def initialize(session_recording: nil, sandbox_session: nil, agent_run: nil)
+      @recording = session_recording
+      @sandbox_session = sandbox_session
+      @agent_run = agent_run
+
+      # Create or find recording if not provided
+      @recording ||= find_or_create_recording
+      @recording_service = SessionRecordingService.new(@recording) if @recording
+    end
+
+    # Intercept an MCP tool call and record it
+    def intercept(tool_name:, parameters:)
+      action_type = PLAYWRIGHT_TOOLS[tool_name]
+
+      # If not a Playwright tool, just execute and return
+      unless action_type
+        return yield if block_given?
+        return nil
+      end
+
+      # Execute the tool
+      result = nil
+      screenshot = nil
+      error = nil
+
+      begin
+        result = yield if block_given?
+
+        # Extract screenshot from result if present
+        screenshot = extract_screenshot(result)
+      rescue => e
+        error = e.message
+        raise
+      ensure
+        # Record the action
+        record_action(action_type, tool_name, parameters, result, screenshot, error)
+      end
+
+      result
+    end
+
+    # Convenience method for recording a navigation
+    def record_navigate(url:, screenshot: nil)
+      @recording_service&.navigate(url: url, screenshot: screenshot)
+    end
+
+    # Convenience method for recording a click
+    def record_click(selector:, screenshot: nil, element_description: nil)
+      @recording_service&.click(
+        selector: selector,
+        screenshot: screenshot,
+        metadata: { element: element_description }.compact
+      )
+    end
+
+    # Convenience method for recording text input
+    def record_type(selector:, text:, screenshot: nil)
+      @recording_service&.type(selector: selector, text: text, screenshot: screenshot)
+    end
+
+    # Record current page state for handoff
+    def capture_for_handoff(url:, cookies: nil, local_storage: nil, form_values: nil)
+      @recording_service&.capture_handoff_state(
+        url: url,
+        cookies: cookies,
+        local_storage: local_storage,
+        form_values: form_values
+      )
+    end
+
+    # Complete the recording
+    def complete!
+      @recording_service&.complete!
+    end
+
+    # Fail the recording
+    def fail!(error_message = nil)
+      @recording_service&.fail!(error_message)
+    end
+
+    private
+
+    def find_or_create_recording
+      if @sandbox_session
+        SessionRecording.recording.find_by(sandbox_session: @sandbox_session) ||
+          SessionRecording.start!(sandbox_session: @sandbox_session)
+      elsif @agent_run
+        SessionRecording.recording.find_by(agent_run: @agent_run) ||
+          SessionRecording.start!(agent_run: @agent_run)
+      end
+    end
+
+    def record_action(action_type, tool_name, parameters, result, screenshot, error)
+      return unless @recording_service
+
+      metadata = {
+        tool_name: tool_name,
+        parameters: parameters,
+        error: error
+      }.compact
+
+      case action_type
+      when "navigate"
+        @recording_service.navigate(
+          url: parameters["url"],
+          screenshot: screenshot
+        )
+      when "click"
+        @recording_service.click(
+          selector: parameters["ref"] || parameters["selector"],
+          screenshot: screenshot,
+          metadata: metadata.merge(
+            element: parameters["element"],
+            button: parameters["button"]
+          ).compact
+        )
+      when "type"
+        @recording_service.type(
+          selector: parameters["ref"] || parameters["selector"],
+          text: parameters["text"],
+          screenshot: screenshot,
+          metadata: metadata
+        )
+      when "form_fill"
+        @recording_service.fill_form(
+          fields: parameters["fields"] || [],
+          screenshot: screenshot
+        )
+      when "key_press"
+        @recording_service.key_press(
+          key: parameters["key"],
+          screenshot: screenshot
+        )
+      when "snapshot"
+        # For snapshots, extract DOM if available
+        dom = extract_dom(result)
+        @recording_service.capture_snapshot(
+          screenshot: screenshot,
+          dom: dom,
+          full_page: parameters["fullPage"]
+        )
+      when "hover"
+        @recording_service.hover(
+          selector: parameters["ref"] || parameters["selector"],
+          screenshot: screenshot
+        )
+      when "select"
+        @recording_service.select_option(
+          selector: parameters["ref"] || parameters["selector"],
+          values: parameters["values"] || [],
+          screenshot: screenshot
+        )
+      when "file_upload"
+        @recording_service.file_upload(
+          paths: parameters["paths"] || [],
+          screenshot: screenshot
+        )
+      when "dialog"
+        @recording_service.dialog(
+          accept: parameters["accept"],
+          text: parameters["promptText"],
+          screenshot: screenshot
+        )
+      when "evaluate"
+        @recording_service.evaluate(
+          function: parameters["function"],
+          result: result,
+          screenshot: screenshot
+        )
+      else
+        # Generic recording for other actions
+        @recording&.record_action!(
+          action_type: action_type,
+          selector: parameters["ref"] || parameters["selector"],
+          value: parameters.to_json,
+          screenshot: screenshot,
+          metadata: metadata
+        )
+      end
+    end
+
+    def extract_screenshot(result)
+      return nil unless result.is_a?(Hash) || result.respond_to?(:[])
+
+      # Try different paths where screenshot data might be
+      result["screenshot"] ||
+        result[:screenshot] ||
+        result.dig("data", "screenshot") ||
+        result.dig(:data, :screenshot)
+    end
+
+    def extract_dom(result)
+      return nil unless result.is_a?(Hash) || result.respond_to?(:[])
+
+      result["dom"] ||
+        result[:dom] ||
+        result["snapshot"] ||
+        result[:snapshot] ||
+        result.dig("data", "dom")
+    end
+  end
+end

data/app/services/action_agent/mock_sandbox_backend.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module ActionAgent
+  # In-memory sandbox backend. Ships with the engine so the sandbox surface
+  # is exercisable in development and tests without any container runtime;
+  # backends that talk to real infrastructure are registered by the host app
+  # (see ActionAgent.sandbox_backends).
+  class MockSandboxBackend
+    def initialize
+      @sandboxes = {}
+    end
+
+    def create_sandbox(session, instance_tier: nil)
+      tier = instance_tier || SandboxInstanceTier.free_tier
+      name = "mock-sandbox-#{SecureRandom.hex(4)}"
+
+      @sandboxes[name] = {
+        container_name: name,
+        container_ip: "127.0.0.1",
+        url: "http://127.0.0.1:8080",
+        session_id: session.session_id,
+        status: "running",
+        instance_tier: tier.id,
+        resources: {
+          cpu_cores: tier.cpu_cores,
+          memory_gb: tier.memory_gb,
+          gpu: tier.gpu
+        },
+        hourly_cost: tier.hourly_cost.to_f,
+        created_at: Time.current
+      }
+      @sandboxes[name]
+    end
+
+    def status(sandbox_id)
+      @sandboxes[sandbox_id] || { status: "not_found" }
+    end
+
+    def terminate(sandbox_id)
+      @sandboxes.delete(sandbox_id)
+      true
+    end
+
+    def list_sandboxes
+      @sandboxes.values
+    end
+
+    def cleanup_expired
+      0
+    end
+  end
+end

data/app/services/action_agent/playwright_mcp_client.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module ActionAgent
+  require "net/http"
+  require "resolv"
+
+  # Minimal MCP client (streamable HTTP transport) for a Playwright MCP
+  # server — typically `npx @playwright/mcp --port 8931` running beside the
+  # app in development, or a sandbox-provisioned browser container in
+  # production. Speaks just enough JSON-RPC for tools/call: initialize once
+  # per process, then call tools under the session id the server hands back.
+  class PlaywrightMcpClient
+    DEFAULT_URL = ENV.fetch("PLAYWRIGHT_MCP_URL", "http://host.orb.internal:8931/mcp")
+    OPEN_TIMEOUT_SECONDS = 5
+    READ_TIMEOUT_SECONDS = 60
+
+    class Error < StandardError; end
+
+    def self.instance
+      @instance ||= new
+    end
+
+    def self.reset!
+      @instance = nil
+    end
+
+    def initialize(url: DEFAULT_URL)
+      @uri = URI(url)
+      @mutex = Mutex.new
+    end
+
+    # Returns { text:, is_error: } — the tool result's text content.
+    def call_tool(name, arguments = {})
+      Rails.logger.debug("[PlaywrightMcpClient] call #{name} args=#{arguments.inspect[0, 200]}")
+      ensure_session!
+      response = post(
+        { jsonrpc: "2.0", id: next_id, method: "tools/call",
+          params: { name: name, arguments: arguments } },
+        session: @session_id
+      )
+      result = response["result"]
+      unless result
+        Rails.logger.warn("[PlaywrightMcpClient] #{name} unexpected response: #{response.inspect[0, 500]}")
+        raise Error, (response.dig("error", "message") || "empty MCP response")
+      end
+
+      text = Array(result["content"]).filter_map { |block| block["text"] }.join("\n")
+      { text: text, is_error: result["isError"] ? true : false }
+    rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Net::OpenTimeout, SocketError => e
+      self.class.reset!
+      raise Error, "Playwright MCP server unreachable at #{@uri} (#{e.class}): start it with `npx @playwright/mcp --port 8931`"
+    end
+
+    private
+
+    def ensure_session!
+      @mutex.synchronize do
+        next if @session_id
+
+        _body, response = post_raw(
+          { jsonrpc: "2.0", id: next_id, method: "initialize",
+            params: { protocolVersion: "2025-03-26", capabilities: {},
+                      clientInfo: { name: "activeagents", version: "1.0" } } }
+        )
+        @session_id = response["mcp-session-id"]
+        raise Error, "MCP server did not return a session id" unless @session_id
+
+        post({ jsonrpc: "2.0", method: "notifications/initialized" }, session: @session_id)
+      end
+    end
+
+    def post(payload, session: nil)
+      body, _response = post_raw(payload, session: session)
+      body
+    end
+
+    def post_raw(payload, session: nil)
+      # Tool calls run inside the provider SDK's streaming enumerator — a
+      # fiber, where Net::HTTP reads of SSE bodies misbehave (headers arrive,
+      # body comes back empty). A dedicated thread always does real blocking
+      # IO outside any fiber/scheduler context.
+      Thread.new { blocking_post_raw(payload, session: session) }.value
+    end
+
+    def blocking_post_raw(payload, session: nil)
+      http = Net::HTTP.new(@uri.host, @uri.port)
+      # Container->host bridge hostnames (host.orb.internal) publish an IPv6
+      # address whose path doesn't reach the server; dual-stack connects then
+      # fail intermittently. Pin to IPv4 while keeping the Host header.
+      if (ipv4 = ipv4_address)
+        http.ipaddr = ipv4
+      end
+      http.open_timeout = OPEN_TIMEOUT_SECONDS
+      http.read_timeout = READ_TIMEOUT_SECONDS
+      request = Net::HTTP::Post.new(@uri.request_uri)
+      request["Content-Type"] = "application/json"
+      request["Accept"] = "application/json, text/event-stream"
+      request["Mcp-Session-Id"] = session if session
+      request.body = payload.to_json
+
+      response = http.request(request)
+      Rails.logger.debug(
+        "[PlaywrightMcpClient] #{payload[:method]} -> #{response.code} " \
+        "ct=#{response['Content-Type']} bytes=#{response.body.to_s.bytesize} session=#{session ? 'yes' : 'no'}"
+      )
+      unless response.code.to_i.between?(200, 299)
+        Rails.logger.warn("[PlaywrightMcpClient] HTTP #{response.code}: #{response.body.to_s[0, 300]}")
+        raise Error, "MCP server returned HTTP #{response.code}"
+      end
+
+      parsed = parse_body(response)
+      if parsed.empty? && payload[:id]
+        Rails.logger.warn("[PlaywrightMcpClient] unparsed body (#{response['Content-Type']}): #{response.body.to_s[0, 500]}")
+      end
+      [ parsed, response ]
+    end
+
+    # Streamable HTTP answers as plain JSON or as an SSE stream whose data:
+    # lines carry the JSON-RPC response — accept both.
+    def parse_body(response)
+      body = response.body.to_s
+      return {} if body.empty?
+
+      if response["Content-Type"].to_s.include?("text/event-stream")
+        body.lines
+            .select { |line| line.start_with?("data:") }
+            .filter_map { |line| JSON.parse(line.delete_prefix("data:").strip) rescue nil }
+            .find { |json| json["result"] || json["error"] } || {}
+      else
+        JSON.parse(body)
+      end
+    rescue JSON::ParserError
+      {}
+    end
+
+    def ipv4_address
+      return @ipv4_address if defined?(@ipv4_address)
+
+      @ipv4_address = Resolv.getaddresses(@uri.host).find { |address| address =~ Resolv::IPv4::Regex }
+    rescue Resolv::ResolvError
+      @ipv4_address = nil
+    end
+
+    def next_id
+      @id = (@id || 0) + 1
+    end
+  end
+end