actionagent 1.7.2 → 1.8.0

data/app/models/action_agent/code_session.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module ActionAgent
+  # A headless Claude Code session run inside an app_runtime sandbox's
+  # checkout: the prompt, the stream-json transcript as it arrived, the
+  # outcome Claude Code reported, and the diff the session left in the
+  # working tree.
+  #
+  # The transcript is scrubbed of the sandbox's secrets (its GitHub token and
+  # Claude Code credential) before it is stored, and bounded: long strings
+  # are truncated and events past MAX_EVENTS are counted rather than kept.
+  class CodeSession < ApplicationRecord
+    include Ownable
+    owned_by :user, :account
+
+    belongs_to :sandbox_session
+
+    enum :status, { queued: 0, running: 1, succeeded: 2, failed: 3, cancelled: 4 }
+
+    MAX_PROMPT_CHARACTERS = 20_000
+    MAX_EVENTS = 1_000
+    # Per string inside an event: tool results can be whole files.
+    MAX_EVENT_STRING = 4_000
+    MAX_DIFF_BYTES = 500_000
+
+    validates :prompt, presence: true, length: { maximum: MAX_PROMPT_CHARACTERS }
+
+    scope :recent, -> { order(created_at: :desc) }
+
+    # JSON columns carry no default on MySQL or SQLite (see the migration).
+    def events
+      Array(super)
+    end
+
+    def finished?
+      succeeded? || failed? || cancelled?
+    end
+
+    # Whether an outcome and a diff may still be recorded for this session.
+    # finished_at is set once nothing more will be: by CodeSessionJob when it
+    # settles a session it ran (whatever the backend returned, raised or
+    # refused), or by the cancel of a session that never left the queue. A
+    # session cancelled while running is finished at once but settled only
+    # when its Claude Code has stopped, so its diff may still come, and its
+    # transcript still grow, until then.
+    def diff_pending?
+      finished_at.nil?
+    end
+
+    # The values that must never be stored: the checkout token and the
+    # Claude Code credential this session ran with.
+    def secrets
+      spec = sandbox_session.checkout_spec rescue nil
+      [ spec&.dig(:token), *sandbox_session.runtime_environment.values ].compact
+    end
+
+    # Appends one stream-json event, scrubbed and bounded. Past MAX_EVENTS
+    # only the count grows, so a runaway session cannot grow the row without
+    # limit.
+    def append_event!(event, secrets: self.secrets)
+      stored = truncate_strings(SecretScrubber.scrub(event.to_h, secrets))
+
+      with_lock do
+        list = events
+        if list.size < MAX_EVENTS
+          self.events = list + [ stored ]
+        else
+          self.dropped_events_count = dropped_events_count.to_i + 1
+        end
+        save!
+      end
+    end
+
+    # Records Claude Code's final "result" event.
+    def record_result!(event)
+      usage = event["usage"].is_a?(Hash) ? event["usage"] : {}
+
+      update!(
+        result: event["result"].to_s.presence && SecretScrubber.scrub(event["result"].to_s, secrets).truncate(MAX_EVENT_STRING * 4),
+        claude_session_id: event["session_id"],
+        num_turns: event["num_turns"],
+        duration_ms: event["duration_ms"],
+        total_cost_usd: event["total_cost_usd"],
+        input_tokens: usage["input_tokens"],
+        output_tokens: usage["output_tokens"]
+      )
+    end
+
+    def diff=(value)
+      text = SecretScrubber.scrub(value.to_s, secrets)
+      super(text.bytesize > MAX_DIFF_BYTES ? "#{text.byteslice(0, MAX_DIFF_BYTES).scrub}\n… diff truncated" : text)
+    end
+
+    def summary
+      {
+        id: id,
+        sandbox_session_id: sandbox_session.session_id,
+        status: status,
+        prompt: prompt,
+        model: model,
+        result: result,
+        error_message: error_message,
+        num_turns: num_turns,
+        duration_ms: duration_ms,
+        total_cost_usd: total_cost_usd&.to_f,
+        input_tokens: input_tokens,
+        output_tokens: output_tokens,
+        event_count: events.size + dropped_events_count.to_i,
+        # What a client polls until: false once nothing about the session
+        # changes any more.
+        diff_pending: diff_pending?,
+        started_at: started_at&.iso8601,
+        finished_at: finished_at&.iso8601,
+        created_at: created_at&.iso8601
+      }
+    end
+
+    # The summary plus the transcript from event index +after+ onward (for
+    # incremental polling) and the diff once finished.
+    def details(after: 0)
+      after = after.to_i.clamp(0, events.size)
+      summary.merge(
+        events: events.drop(after),
+        events_offset: after,
+        dropped_events_count: dropped_events_count.to_i,
+        diff: finished? ? diff : nil
+      )
+    end
+
+    private
+
+    def truncate_strings(value)
+      case value
+      when String then value.length > MAX_EVENT_STRING ? "#{value[0, MAX_EVENT_STRING]}… (truncated)" : value
+      when Hash then value.to_h { |key, item| [ key, truncate_strings(item) ] }
+      when Array then value.map { |item| truncate_strings(item) }
+      else value
+      end
+    end
+  end
+end

data/app/models/action_agent/evaluation_run.rb

@@ -25,6 +25,19 @@ module ActionAgent
       value.is_a?(Hash) ? value : {}
     end
 
+    # The checkout sandbox a scenario run replayed against
+    # (ScenarioEvaluationRunner records it), as { "session_id", "server_key",
+    # "repository", "repository_ref" }; nil for a run against the agent's own
+    # servers only.
+    def sandbox
+      value = selection["sandbox"]
+      return value if value.is_a?(Hash)
+
+      # Still pending: run_later! recorded only what was asked for.
+      id = selection["sandbox_id"]
+      { "session_id" => id } if id.is_a?(String) && id.present?
+    end
+
     # The candidate models a scenario run compared, in the order they were
     # requested; empty for a generation-sampling run.
     def models
@@ -211,7 +224,8 @@ module ActionAgent
           "evaluation" => evaluation.name,
           "agent" => evaluation.agent&.name,
           "run" => id,
-          "finished" => completed_at&.iso8601
+          "finished" => completed_at&.iso8601,
+          "sandbox" => sandbox_label
         }.compact.merge(report_metadata),
         verdict: recorded_verdict,
         judge_label: judge_label,
@@ -226,6 +240,14 @@ module ActionAgent
     ModelSpec = ActiveAgent::Evals::ModelSpec
     private_constant :ModelSpec
 
+    # How the report's header names the sandbox: its checkout and session.
+    def sandbox_label
+      return nil unless sandbox
+
+      checkout = [ sandbox["repository"], sandbox["repository_ref"] ].compact_blank.join("@")
+      [ checkout.presence, "sandbox #{sandbox["session_id"].to_s.first(8)}" ].compact.join(" · ")
+    end
+
     # The candidate specs the run was asked to compare, keyed by
     # [provider, model] in the order requested. ScenarioEvaluationRunner
     # persists each ModelSpec#to_h in `selection`, and it is that label —

data/app/models/action_agent/github_connection.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module ActionAgent
+  # An owner's GitHub OAuth grant (Settings -> Integrations) and the
+  # repositories they made available to the workspace.
+  #
+  # The access token is encrypted at rest like a provider key and never
+  # rendered back to the client. +repositories+ holds only what GitHub
+  # itself listed for this token when the owner chose them (see
+  # Api::GithubConnectionsController#update), so a checkout sandbox can
+  # trust a name found here without asking GitHub again.
+  class GithubConnection < ApplicationRecord
+    include Ownable
+    owned_by :account, :user
+
+    encrypts :access_token if ActionAgent.encrypt_credentials
+
+    validates :access_token, :github_user_id, :login, presence: true
+    # One connection per owner; which column that means depends on the
+    # configured mode, so it is checked at validation time.
+    validate :unique_within_owner
+
+    # JSON columns carry no default on MySQL or SQLite (see the migration), so
+    # an unset column reads as nil.
+    def repositories
+      Array(super)
+    end
+
+    def repository_names
+      repositories.map { |repo| repo["full_name"] }
+    end
+
+    def repository(full_name)
+      repositories.find { |repo| repo["full_name"].casecmp?(full_name.to_s) }
+    end
+
+    def client
+      GithubClient.new(access_token)
+    end
+
+    # The checkout a sandbox backend clones: repository, ref, and an
+    # authenticated HTTPS clone URL. Carries the token — hand it to a backend,
+    # never to a response.
+    def checkout_spec(full_name, ref: nil)
+      repo = repository(full_name) or raise ArgumentError, "#{full_name} is not an available repository"
+
+      {
+        repository: repo["full_name"],
+        ref: ref.presence || repo["default_branch"],
+        clone_url: "https://github.com/#{repo["full_name"]}.git",
+        username: "x-access-token",
+        token: access_token
+      }
+    end
+
+    def as_summary
+      {
+        login: login,
+        avatar_url: avatar_url,
+        scopes: scopes.to_s.split(/[\s,]+/).reject(&:blank?),
+        repositories: repositories,
+        connected_at: created_at&.iso8601,
+        updated_at: updated_at&.iso8601
+      }
+    end
+
+    private
+
+    def unique_within_owner
+      siblings = self.class.for_owner(owner)
+      siblings = siblings.where.not(id: id) if persisted?
+      errors.add(:base, "GitHub is already connected") if siblings.exists?
+    end
+  end
+end

data/app/models/action_agent/provider_key.rb

@@ -5,22 +5,52 @@ module ActionAgent
   # Generation runs (AgentExecutionService and the evaluation LLM judge)
   # prefer these over the platform's ENV-configured keys, so users can run
   # agents with their own OpenAI/Anthropic/OpenRouter accounts — or point
-  # ollama at their own host (e.g. a tunnel to a locally running instance).
+  # ollama at their own host: a locally running instance, a tunnel to one, or
+  # a remote/cloud server that additionally needs a Bearer API key.
   #
-  # The credential is encrypted at rest with Active Record Encryption. API
-  # keys are never rendered back to the client — only a masked hint; ollama
-  # hosts are not secret and are shown in full (see #display_hint).
+  # The credential (and the optional api_key) is encrypted at rest with
+  # Active Record Encryption. API keys are never rendered back to the client —
+  # only a masked hint; ollama hosts are not secret and are shown in full
+  # (see #display_hint).
+  #
+  # A connection credential (Claude Code) is stored the same way but is not a
+  # generation provider: no agent runs "on" it. It is handed to runtimes that
+  # need it — a checkout sandbox runs Claude Code sessions with it — through
+  # #runtime_environment. For Claude Code that is an Anthropic API key only
+  # (see CLAUDE_CODE_CREDENTIAL).
   class ProviderKey < ApplicationRecord
     # Providers that authenticate with an API key.
     KEY_PROVIDERS = %w[openai anthropic openrouter].freeze
-    # Providers addressed by host URL instead of a key.
+    # Providers addressed by host URL instead of a key (with an optional key
+    # for remote servers).
     HOST_PROVIDERS = %w[ollama].freeze
-    PROVIDERS = (KEY_PROVIDERS + HOST_PROVIDERS).freeze
+    # Tools connected with a credential, configured beside the providers
+    # (Settings -> Integrations) but never offered to the agent builder.
+    CONNECTION_PROVIDERS = %w[claude_code].freeze
+    PROVIDERS = (KEY_PROVIDERS + HOST_PROVIDERS + CONNECTION_PROVIDERS).freeze
+
+    # Only an Anthropic API key (sk-ant-api03-…, from the Claude Console or
+    # a supported cloud provider). Anthropic does not let third-party
+    # products collect, store or route requests through Claude.ai
+    # subscription credentials (a `claude setup-token` token, sk-ant-oat…):
+    # https://code.claude.com/docs/en/legal-and-compliance.md. A developer
+    # who wants their own subscription on their own machine uses
+    # ActionAgent.claude_code_auth = :local_login instead, where the
+    # dashboard never touches the credential.
+    CLAUDE_CODE_CREDENTIAL = /\Ask-ant-api\d{2}-[A-Za-z0-9_-]+\z/
+    # A Claude subscription token, as earlier versions stored. Recognized so
+    # a stored one is never handed out (see #needs_replacing?).
+    SUBSCRIPTION_TOKEN_PREFIX = "sk-ant-oat"
 
     include Ownable
     owned_by :account, :user
 
-    encrypts :credential if ActionAgent.encrypt_credentials
+    if ActionAgent.encrypt_credentials
+      encrypts :credential
+      encrypts :api_key
+    end
+
+    before_validation :normalize_host_credential, if: :host_based?
 
     validates :provider, presence: true, inclusion: { in: PROVIDERS }
     # One credential per provider per owner; which column that means
@@ -29,26 +59,128 @@ module ActionAgent
     validates :credential, presence: true, length: { maximum: 500 }
     validates :credential, format: { with: %r{\Ahttps?://\S+\z}, message: "must be an http(s):// URL" },
       if: :host_based?
+    validates :credential, format: {
+      with: CLAUDE_CODE_CREDENTIAL,
+      message: "must be an Anthropic API key (sk-ant-api…) from the Claude Console (https://platform.claude.com). " \
+        "Claude subscription tokens (`claude setup-token`, sk-ant-oat…) cannot be stored: Anthropic does not allow " \
+        "third-party apps to hold Claude.ai credentials. To use your own Claude login on this machine, set " \
+        "ActionAgent.claude_code_auth = :local_login with the :local sandbox backend instead"
+    }, if: -> { provider == "claude_code" }
+    validates :api_key, length: { maximum: 500 }, allow_nil: true
+
+    # Deletes every Claude Code connection that still holds a Claude
+    # subscription token (see #needs_replacing?), whoever owns it. The
+    # credential is encrypted, so each is read to tell. Their owners see
+    # Claude Code as not connected, and connect an API key again.
+    #
+    # @return [Integer] how many were deleted
+    def self.purge_subscription_tokens!
+      where(provider: "claude_code").find_each.count do |key|
+        key.needs_replacing? && key.destroy!
+      end
+    end
+
+    def self.kind_of_provider(provider)
+      if HOST_PROVIDERS.include?(provider) then "host"
+      elsif CONNECTION_PROVIDERS.include?(provider) then "connection"
+      else "key"
+      end
+    end
+
+    # Ollama's OpenAI-compatible API lives under /v1. Accept the bare server
+    # address people naturally paste (http://localhost:11434, a tunnel
+    # hostname) and add the path; trailing slashes are dropped so the client
+    # can join paths cleanly. An explicit non-root path is left alone, for
+    # servers behind a reverse proxy.
+    def self.normalize_host(value)
+      host = value.to_s.strip.chomp("/")
+      return host if host.blank?
+
+      uri = URI.parse(host)
+      return host unless uri.is_a?(URI::HTTP)
+
+      uri.path = "/v1" if uri.path.blank? || uri.path == "/"
+      uri.to_s.chomp("/")
+    rescue URI::InvalidURIError
+      host
+    end
 
     def host_based?
       HOST_PROVIDERS.include?(provider)
     end
 
+    def connection?
+      CONNECTION_PROVIDERS.include?(provider)
+    end
+
+    # Only host-based providers carry an optional key (a remote Ollama behind
+    # an authenticating proxy, or Ollama Cloud).
+    def api_key?
+      host_based? && api_key.present?
+    end
+
     # Options merged into generate_with for runs owned by this key's owner,
-    # overriding the host app's config/active_agent.yml credentials.
+    # overriding the host app's config/active_agent.yml credentials. A
+    # connection credential configures no generation.
     def generation_options
-      host_based? ? { host: credential } : { access_token: credential }
+      return {} if connection?
+      return { access_token: credential } unless host_based?
+
+      { host: credential, access_token: api_key.presence }.compact
+    end
+
+    # Environment variables a runtime needs to use this credential, for the
+    # credentials that are consumed by a process rather than a provider
+    # client: Claude Code reads an API key from ANTHROPIC_API_KEY.
+    #
+    # A subscription token stored before those were refused is never handed
+    # to a process: it yields nothing, as if Claude Code were not connected,
+    # until it is replaced with an API key.
+    #
+    # @return [Hash{String => String}]
+    def runtime_environment
+      return {} unless provider == "claude_code"
+      return {} if needs_replacing? || !CLAUDE_CODE_CREDENTIAL.match?(credential.to_s)
+
+      { "ANTHROPIC_API_KEY" => credential }
+    end
+
+    # A Claude Code connection that still holds a Claude subscription token
+    # (sk-ant-oat…), stored by an earlier version. It is no longer used and
+    # must be replaced with an API key; `bin/rails
+    # action_agent:claude_code:purge_subscription_tokens` deletes them all.
+    def needs_replacing?
+      provider == "claude_code" && credential.to_s.start_with?(SUBSCRIPTION_TOKEN_PREFIX)
     end
 
     # "sk-a…Q2z9" for keys; hosts are shown in full.
     def display_hint
       return credential if host_based?
 
-      "#{credential.first(4)}…#{credential.last(4)}"
+      mask(credential)
+    end
+
+    # Masked hint for the optional host-provider key, nil when none is set.
+    def api_key_hint
+      api_key? ? mask(api_key) : nil
+    end
+
+    # Reachability + served models for host-based providers.
+    def probe
+      OllamaHostProbe.call(host: credential, api_key: api_key)
     end
 
     private
 
+    def mask(value)
+      "#{value.first(4)}…#{value.last(4)}"
+    end
+
+    def normalize_host_credential
+      self.credential = self.class.normalize_host(credential) if credential.present?
+      self.api_key = api_key.presence&.strip
+    end
+
     def provider_unique_within_owner
       return if provider.blank?