activeagent 1.1.0 → 1.2.0

data/lib/active_agent/dashboard/app/models/active_agent/dashboard/recording_action.rb

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveAgent
-  module Dashboard
-    # Represents a single browser action within a session recording.
-    #
-    # Actions capture user and agent interactions like clicks, typing,
-    # navigation, and form submissions.
-    #
-    class RecordingAction < ApplicationRecord
-      belongs_to :session_recording, class_name: "ActiveAgent::Dashboard::SessionRecording"
-      has_one :snapshot, class_name: "ActiveAgent::Dashboard::RecordingSnapshot", dependent: :nullify
-
-      ACTION_TYPES = %w[
-        navigate
-        click
-        type
-        scroll
-        snapshot
-        select
-        hover
-        drag
-        file_upload
-        dialog
-        evaluate
-        wait
-        form_fill
-        key_press
-        focus
-        submit
-        handoff
-        user_action
-        completion
-      ].freeze
-
-      validates :action_type, presence: true, inclusion: { in: ACTION_TYPES }
-      validates :sequence, presence: true, uniqueness: { scope: :session_recording_id }
-      validates :timestamp_ms, presence: true
-
-      scope :ordered, -> { order(:sequence) }
-      scope :with_screenshots, -> { where.not(screenshot_key: nil) }
-
-      # Get the screenshot URL (signed URL from storage)
-      def screenshot_url(expires_in: 15.minutes)
-        return nil unless screenshot_key.present?
-
-        ActiveAgent::Dashboard.storage_service&.signed_url_for(screenshot_key, expires_in: expires_in)
-      end
-
-      # Get the DOM snapshot content
-      def dom_snapshot_content
-        return nil unless dom_snapshot_key.present?
-
-        ActiveAgent::Dashboard.storage_service&.fetch_snapshot(dom_snapshot_key)
-      end
-
-      # Format for API response
-      def as_json_for_api
-        {
-          id: id,
-          action_type: action_type,
-          sequence: sequence,
-          timestamp_ms: timestamp_ms,
-          selector: selector,
-          value: redacted_value,
-          screenshot_url: screenshot_url,
-          has_dom_snapshot: dom_snapshot_key.present?,
-          metadata: safe_metadata,
-          created_at: created_at.iso8601
-        }
-      end
-
-      # Get browser state at this action (for handoff)
-      def browser_state
-        {
-          url: extract_url,
-          form_values: metadata["form_values"],
-          scroll_position: metadata["scroll_position"],
-          active_element: selector,
-          action_type: action_type
-        }
-      end
-
-      private
-
-      def redacted_value
-        return value unless should_redact?
-
-        "[REDACTED]"
-      end
-
-      def should_redact?
-        return false unless value.present?
-
-        sensitive_patterns = [
-          /password/i,
-          /credit.?card/i,
-          /cvv/i,
-          /ssn/i,
-          /social.?security/i,
-          /\b\d{16}\b/,
-          /\b\d{3}-\d{2}-\d{4}\b/
-        ]
-
-        selector_is_sensitive = sensitive_patterns.any? { |p| selector&.match?(p) }
-        value_is_sensitive = sensitive_patterns.any? { |p| value.match?(p) }
-
-        selector_is_sensitive || value_is_sensitive
-      end
-
-      def safe_metadata
-        metadata.except("password", "credit_card", "cvv", "ssn")
-      end
-
-      def extract_url
-        case action_type
-        when "navigate"
-          value
-        else
-          metadata["url"] || metadata["page_url"]
-        end
-      end
-    end
-  end
-end

data/lib/active_agent/dashboard/app/models/active_agent/dashboard/recording_snapshot.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveAgent
-  module Dashboard
-    # Stores screenshots and DOM snapshots from session recordings.
-    #
-    # Supports Active Storage for file attachment and provides
-    # signed URLs for secure access.
-    #
-    class RecordingSnapshot < ApplicationRecord
-      belongs_to :session_recording, class_name: "ActiveAgent::Dashboard::SessionRecording"
-      belongs_to :recording_action, class_name: "ActiveAgent::Dashboard::RecordingAction", optional: true
-
-      has_one_attached :file if defined?(ActiveStorage)
-
-      SNAPSHOT_TYPES = %w[screenshot dom full_page].freeze
-
-      validates :storage_key, presence: true, uniqueness: true
-      validates :snapshot_type, presence: true, inclusion: { in: SNAPSHOT_TYPES }
-
-      scope :screenshots, -> { where(snapshot_type: "screenshot") }
-      scope :dom_snapshots, -> { where(snapshot_type: "dom") }
-      scope :ordered, -> { order(:created_at) }
-
-      # Get a signed URL for the file
-      def signed_url(expires_in: 15.minutes)
-        return nil unless respond_to?(:file) && file.attached?
-
-        file.url(expires_in: expires_in)
-      rescue StandardError
-        nil
-      end
-
-      # Store file data
-      def store!(data, filename: nil, content_type: nil)
-        return unless respond_to?(:file)
-
-        content_type ||= infer_content_type
-        filename ||= generate_filename
-
-        file.attach(
-          io: StringIO.new(data),
-          filename: filename,
-          content_type: content_type
-        )
-
-        update!(file_size_bytes: data.bytesize)
-      end
-
-      # For API response
-      def as_json_for_api
-        {
-          id: id,
-          storage_key: storage_key,
-          snapshot_type: snapshot_type,
-          width: width,
-          height: height,
-          file_size_bytes: file_size_bytes,
-          url: signed_url,
-          created_at: created_at.iso8601
-        }
-      end
-
-      private
-
-      def infer_content_type
-        case snapshot_type
-        when "screenshot", "full_page"
-          "image/png"
-        when "dom"
-          "text/html"
-        else
-          "application/octet-stream"
-        end
-      end
-
-      def generate_filename
-        ext = snapshot_type == "dom" ? "html" : "png"
-        "#{storage_key.tr('/', '_')}.#{ext}"
-      end
-    end
-  end
-end

data/lib/active_agent/dashboard/app/models/active_agent/dashboard/sandbox_run.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveAgent
-  module Dashboard
-    # Tracks individual task executions within a sandbox session.
-    #
-    # Each sandbox run represents a single agent task execution,
-    # capturing input, output, timing, and any errors.
-    #
-    class SandboxRun < ApplicationRecord
-      belongs_to :sandbox_session, class_name: "ActiveAgent::Dashboard::SandboxSession", optional: true
-
-      enum :status, {
-        pending: 0,
-        running: 1,
-        completed: 2,
-        failed: 3,
-        cancelled: 4
-      }
-
-      validates :task, presence: true
-      validates :status, presence: true
-
-      scope :recent, -> { order(created_at: :desc) }
-      scope :completed_runs, -> { where(status: [ :completed, :failed ]) }
-
-      # Summary for API responses
-      def summary
-        {
-          id: id,
-          task: task.truncate(100),
-          status: status,
-          duration_ms: duration_ms,
-          tokens_used: tokens_used,
-          created_at: created_at&.iso8601,
-          completed_at: completed_at&.iso8601
-        }
-      end
-
-      # Detailed info including full result
-      def details
-        summary.merge(
-          task: task,
-          result: result,
-          error: error,
-          screenshots: screenshots || [],
-          started_at: started_at&.iso8601
-        )
-      end
-    end
-  end
-end

data/lib/active_agent/dashboard/app/models/active_agent/dashboard/sandbox_session.rb

@@ -1,169 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveAgent
-  module Dashboard
-    # Manages sandbox execution sessions for agent runs.
-    #
-    # Sandbox sessions provide isolated execution environments for running
-    # agents with tools like browser automation, file system access, etc.
-    #
-    # Supports both local (Docker/Incus) and cloud (Cloud Run) sandbox providers.
-    #
-    # @example Creating a sandbox session
-    #   session = ActiveAgent::Dashboard::SandboxSession.create!(
-    #     sandbox_type: "playwright_mcp"
-    #   )
-    #   session.provision!
-    #
-    class SandboxSession < ApplicationRecord
-      # Owner associations - optional to support anonymous users
-      belongs_to :user, class_name: ActiveAgent::Dashboard.user_class, optional: true if ActiveAgent::Dashboard.user_class
-      belongs_to :account, class_name: ActiveAgent::Dashboard.account_class, optional: true if ActiveAgent::Dashboard.multi_tenant?
-      belongs_to :agent_template, class_name: "ActiveAgent::Dashboard::AgentTemplate", optional: true
-
-      has_many :sandbox_runs, class_name: "ActiveAgent::Dashboard::SandboxRun", dependent: :destroy
-      has_one :session_recording, class_name: "ActiveAgent::Dashboard::SessionRecording", dependent: :nullify
-
-      # Session statuses
-      enum :status, {
-        pending: 0,
-        provisioning: 1,
-        ready: 2,
-        running: 3,
-        completed: 4,
-        expired: 5,
-        failed: 6
-      }
-
-      # Sandbox types
-      SANDBOX_TYPES = %w[playwright_mcp terminal research].freeze
-
-      # Default limits (can be overridden by platform tier limits)
-      DEFAULT_LIMITS = {
-        max_runs: 10,
-        timeout_seconds: 300,
-        max_tokens: 50_000,
-        session_duration_minutes: 15
-      }.freeze
-
-      # Validations
-      validates :session_id, presence: true, uniqueness: true
-      validates :sandbox_type, inclusion: { in: SANDBOX_TYPES }
-
-      # Callbacks
-      before_validation :generate_session_id, on: :create
-      before_create :set_defaults
-
-      # Scopes
-      scope :active, -> { where(status: [ :pending, :provisioning, :ready, :running ]) }
-      scope :expired_sessions, -> { where("expires_at < ?", Time.current) }
-      scope :by_type, ->(type) { where(sandbox_type: type) }
-      scope :anonymous, -> { where(user_id: nil) }
-      scope :recent, -> { order(created_at: :desc) }
-
-      # Check if session is still valid
-      def active?
-        !expired? && !failed? && !completed? && expires_at > Time.current
-      end
-
-      # Check if can run more tasks
-      def can_run?
-        active? && runs_count < max_runs
-      end
-
-      # Record a new run (thread-safe for parallel execution)
-      def record_run!(task:, result:, duration_ms:, tokens:, screenshots: [], provider: nil)
-        run = {
-          id: SecureRandom.uuid,
-          task: task,
-          result: result,
-          duration_ms: duration_ms,
-          tokens: tokens,
-          screenshots: screenshots,
-          provider: provider,
-          status: "completed",
-          created_at: Time.current.iso8601
-        }
-
-        with_lock do
-          reload
-          self.runs = runs + [ run ]
-          self.runs_count = runs.size
-          self.total_tokens += tokens
-          self.total_duration_ms += duration_ms
-          self.last_activity_at = Time.current
-          save!
-        end
-
-        run
-      end
-
-      # Provision the sandbox
-      def provision!
-        return if provisioning? || ready?
-
-        update!(status: :provisioning)
-
-        # Use configured sandbox service
-        if Rails.env.development? || Rails.env.test?
-          ActiveAgent::Dashboard::SandboxProvisionJob.perform_now(id)
-        else
-          ActiveAgent::Dashboard::SandboxProvisionJob.perform_later(id)
-        end
-      end
-
-      # Mark as ready with sandbox URL
-      def mark_ready!(sandbox_url:, sandbox_job_id: nil)
-        update!(
-          status: :ready,
-          cloud_run_url: sandbox_url,
-          cloud_run_job_id: sandbox_job_id
-        )
-      end
-
-      # Expire the session
-      def expire!
-        update!(status: :expired)
-        ActiveAgent::Dashboard::SandboxCleanupJob.perform_later(id) if cloud_run_job_id.present?
-      end
-
-      # Summary for API responses
-      def summary
-        {
-          id: id,
-          session_id: session_id,
-          sandbox_type: sandbox_type,
-          status: status,
-          runs_count: runs_count,
-          max_runs: max_runs,
-          total_tokens: total_tokens,
-          expires_at: expires_at&.iso8601,
-          created_at: created_at.iso8601,
-          cloud_run_url: cloud_run_url
-        }
-      end
-
-      # Detailed info including runs
-      def details
-        summary.merge(
-          runs: runs,
-          total_duration_ms: total_duration_ms,
-          last_activity_at: last_activity_at&.iso8601
-        )
-      end
-
-      private
-
-      def generate_session_id
-        self.session_id ||= SecureRandom.uuid
-      end
-
-      def set_defaults
-        limits = ActiveAgent::Dashboard.sandbox_limits || DEFAULT_LIMITS
-        self.expires_at ||= limits[:session_duration_minutes].minutes.from_now
-        self.max_runs ||= limits[:max_runs]
-        self.timeout_seconds ||= limits[:timeout_seconds]
-      end
-    end
-  end
-end

data/lib/active_agent/dashboard/app/models/active_agent/dashboard/session_recording.rb

@@ -1,193 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveAgent
-  module Dashboard
-    # Records browser sessions for playback and analysis.
-    #
-    # Session recordings capture the sequence of actions taken during
-    # an agent run or sandbox session, including screenshots, DOM snapshots,
-    # and timing information.
-    #
-    # @example Starting a recording
-    #   recording = ActiveAgent::Dashboard::SessionRecording.start!(
-    #     agent_run: run,
-    #     name: "checkout_flow"
-    #   )
-    #
-    # @example Recording an action
-    #   recording.record_action!(
-    #     action_type: "click",
-    #     selector: "button.submit",
-    #     screenshot: screenshot_data
-    #   )
-    #
-    class SessionRecording < ApplicationRecord
-      belongs_to :agent_run, class_name: "ActiveAgent::Dashboard::AgentRun", optional: true
-      belongs_to :sandbox_session, class_name: "ActiveAgent::Dashboard::SandboxSession", optional: true
-
-      has_many :recording_actions, class_name: "ActiveAgent::Dashboard::RecordingAction", dependent: :destroy
-      has_many :recording_snapshots, class_name: "ActiveAgent::Dashboard::RecordingSnapshot", dependent: :destroy
-
-      enum :status, { recording: 0, completed: 1, failed: 2 }
-
-      validates :status, presence: true
-      validate :must_have_parent, unless: -> { demo_recording? || user_session? }
-
-      scope :recent, -> { order(created_at: :desc) }
-      scope :for_agent, ->(agent_id) { joins(:agent_run).where(agent_runs: { agent_id: agent_id }) }
-      scope :demo, -> { where(name: "lander_demo") }
-      scope :user_sessions, -> { where("name LIKE ?", "user_takeover_%") }
-
-      # Check if this is a demo recording (doesn't require parent)
-      def demo_recording?
-        name&.start_with?("lander_") || name == "demo"
-      end
-
-      # Check if this is a user takeover session (doesn't require parent)
-      def user_session?
-        name&.start_with?("user_takeover_")
-      end
-
-      # Start a new recording session
-      def self.start!(agent_run: nil, sandbox_session: nil, name: nil)
-        create!(
-          agent_run: agent_run,
-          sandbox_session: sandbox_session,
-          name: name || generate_name(agent_run, sandbox_session),
-          status: :recording,
-          metadata: { started_at: Time.current.iso8601 }
-        )
-      end
-
-      # Start a user takeover session (for lander demo analytics)
-      def self.start_user_session!(visitor_id: nil, parent_demo_id: nil, page_url: nil)
-        create!(
-          name: "user_takeover_#{Time.current.strftime('%Y%m%d_%H%M%S')}_#{SecureRandom.hex(4)}",
-          status: :recording,
-          metadata: {
-            started_at: Time.current.iso8601,
-            session_type: "user_takeover",
-            visitor_id: visitor_id,
-            parent_demo_id: parent_demo_id,
-            page_url: page_url,
-            user_agent: nil
-          }
-        )
-      end
-
-      # Record a browser action
-      def record_action!(action_type:, selector: nil, value: nil, screenshot: nil, dom_snapshot: nil, metadata: {})
-        raise "Recording already completed" unless recording?
-
-        action = recording_actions.create!(
-          action_type: action_type,
-          sequence: next_sequence,
-          timestamp_ms: elapsed_ms,
-          selector: selector,
-          value: value,
-          metadata: metadata
-        )
-
-        if screenshot.present?
-          snapshot = store_snapshot(screenshot, :screenshot, action)
-          action.update!(screenshot_key: snapshot.storage_key)
-        end
-
-        if dom_snapshot.present?
-          snapshot = store_snapshot(dom_snapshot, :dom, action)
-          action.update!(dom_snapshot_key: snapshot.storage_key)
-        end
-
-        increment!(:action_count)
-        action
-      end
-
-      # Complete the recording
-      def complete!
-        return unless recording?
-
-        update!(
-          status: :completed,
-          duration_ms: elapsed_ms,
-          metadata: metadata.merge(completed_at: Time.current.iso8601)
-        )
-      end
-
-      # Mark recording as failed
-      def fail!(error_message = nil)
-        return unless recording?
-
-        update!(
-          status: :failed,
-          duration_ms: elapsed_ms,
-          metadata: metadata.merge(
-            failed_at: Time.current.iso8601,
-            error: error_message
-          )
-        )
-      end
-
-      # Get timeline data for playback
-      def timeline
-        recording_actions.order(:sequence).map do |action|
-          {
-            id: action.id,
-            type: action.action_type,
-            sequence: action.sequence,
-            timestamp_ms: action.timestamp_ms,
-            selector: action.selector,
-            value: action.value,
-            screenshot_key: action.screenshot_key,
-            metadata: action.metadata
-          }
-        end
-      end
-
-      private
-
-      def must_have_parent
-        return if agent_run.present? || sandbox_session.present?
-
-        errors.add(:base, "must belong to an agent_run or sandbox_session")
-      end
-
-      def self.generate_name(agent_run, sandbox_session)
-        prefix = if agent_run&.agent
-          agent_run.agent.name.parameterize
-        elsif sandbox_session&.agent_template
-          sandbox_session.agent_template.name.parameterize
-        else
-          "session"
-        end
-
-        "#{prefix}_#{Time.current.strftime('%Y%m%d_%H%M%S')}"
-      end
-
-      def next_sequence
-        (recording_actions.maximum(:sequence) || 0) + 1
-      end
-
-      def elapsed_ms
-        ((Time.current - created_at) * 1000).to_i
-      end
-
-      def store_snapshot(data, snapshot_type, action = nil)
-        storage_key = generate_storage_key(snapshot_type, action&.sequence)
-
-        recording_snapshots.create!(
-          recording_action: action,
-          storage_key: storage_key,
-          snapshot_type: snapshot_type,
-          file_size_bytes: data.bytesize
-        )
-      end
-
-      def generate_storage_key(snapshot_type, sequence = nil)
-        parts = [ "recordings", id, snapshot_type.to_s ]
-        parts << sequence.to_s if sequence
-        parts << SecureRandom.hex(8)
-        parts.join("/")
-      end
-    end
-  end
-end