yatfa 1.0.88 → 1.0.90

package/lib/yatfa_agent/interaction.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module YatfaAgent
+  # User interaction and container lifecycle decisions.
+  # Mixed into Agent via extend — methods become available as Agent.xxx.
+  # Responsible for prompts, user input handling, and container state conflict resolution.
+  #
+  # NOTE: These methods use bare calls (e.g., `non_interactive?` not `self.non_interactive?`)
+  # because they're resolved on Agent's singleton class at runtime, where all extended
+  # module methods and Agent's own methods are available. This also ensures test stubs
+  # (via define_singleton_method on Agent) intercept internal calls correctly.
+  module Interaction
+    # Prompt user for input with a default value
+    def prompt(message, default: nil, options: nil)
+      loop do
+        print message
+        input = $stdin.gets&.strip&.downcase || ""
+
+        # Handle default on empty input
+        if input.empty? && default
+          return default
+        end
+
+        # If options specified, validate input
+        if options
+          valid = options.any? { |opt| opt.downcase == input || opt.downcase.start_with?(input) }
+          if valid
+            # Return the full option that matches
+            return options.find { |opt| opt.downcase.start_with?(input) }
+          end
+          puts "   Invalid option. Please choose: #{options.join('/')}"
+        else
+          return input
+        end
+      end
+    end
+
+    # Check if running in non-interactive mode
+    def non_interactive?
+      !$stdin.tty? || ENV['YATFA_NO_PROMPT'] == '1' || ARGV.include?('--no-prompt') || ARGV.include?('-d')
+    end
+
+    # Handle running container: prompt user for action
+    def handle_running_container(agent_type, container_name, config, agent_configs)
+      puts "⚠️  #{agent_type} agent is already running (#{container_name})"
+
+      # Check if container was created before last deploy
+      deploy_manifest = File.join(File.dirname(__FILE__), '..', '..', 'deploy', '.deploy-manifest.json')
+      version_file = File.join(File.dirname(__FILE__), '..', '..', 'VERSION')
+      stale = false
+
+      if File.exist?(version_file)
+        current_version = File.read(version_file).strip
+        container_version = IO.popen(["docker", "exec", container_name, "printenv", "YATFA_VERSION_NUM"], err: File::NULL, &:read).strip
+        if !container_version.empty? && container_version != current_version
+          puts "   🆕 New version deployed (container: #{container_version}, current: #{current_version})"
+          stale = true
+        end
+      elsif File.exist?(deploy_manifest)
+        deploy_time = File.mtime(deploy_manifest)
+        container_created = container_creation_time(container_name)
+        if container_created && container_created < deploy_time
+          puts "   🆕 New deploy detected (container from #{format_time(container_created)}, deploy at #{format_time(deploy_time)})"
+          stale = true
+        end
+      end
+
+      puts ""
+
+      if non_interactive?
+        puts "   Running in non-interactive mode. Run 'npx yatfa #{agent_type}' to attach, or stop the container first."
+        puts "   docker stop #{container_name}"
+        exit 0
+      end
+
+      default_choice = stale ? "R" : "A"
+      choice = prompt("   [A]ttach / [R]estart / [C]ancel? [#{default_choice == 'R' ? 'a/R/c' : 'A/r/c'}]: ", default: default_choice, options: %w[A R C])
+
+      case choice
+      when "A"
+        puts ""
+        attach(agent_type, config, agent_configs)
+      when "R"
+        puts ""
+        puts "🔄 Stopping existing container..."
+        system("docker", "stop", container_name, err: File::NULL, out: File::NULL)
+        system("docker", "rm", "-f", container_name, err: File::NULL, out: File::NULL)
+        return true # Continue with start
+      when "C"
+        puts "   Cancelled."
+        exit 0
+      end
+    end
+
+    # Banner file is no longer generated on the host.
+    # System prompt is generated inside the container by setup-agent.rb
+    # using AGENT_TYPE and REPOSITORIES_CONTEXT env vars.
+
+    # Handle stopped container: prompt user for action
+    def handle_stopped_container(agent_type, container_name, config, agent_configs)
+      puts "⚠️  #{agent_type} agent container exists but is stopped (#{container_name})"
+      puts ""
+
+      if non_interactive?
+        puts "   Non-interactive mode: starting existing container."
+        system("docker", "start", container_name, out: File::NULL)
+        puts "✅ Agent started in background"
+        prompt_to_attach(agent_type, container_name, config, agent_configs)
+        exit 0
+      end
+
+      choice = prompt("   [S]tart existing / [R]ecreate / [C]ancel? [S/r/c]: ", default: "S", options: %w[S R C])
+
+      case choice
+      when "S"
+        puts ""
+        puts "🔄 Starting existing container..."
+        system("docker", "start", container_name, out: File::NULL)
+        puts "✅ Agent started in background"
+        prompt_to_attach(agent_type, container_name, config, agent_configs)
+        exit 0
+      when "R"
+        puts ""
+        puts "🔄 Removing stopped container..."
+        system("docker", "rm", "-f", container_name, err: File::NULL, out: File::NULL)
+      when "C"
+        puts "   Cancelled."
+        exit 0
+      end
+    end
+
+    # Prompt user to attach after starting a new agent
+    def prompt_to_attach(agent_type, container_name, config, agent_configs)
+      if non_interactive?
+        # Non-interactive: just print helpful info
+        puts "   Logs:   docker logs -f #{container_name}"
+        puts "   Stop:   docker stop #{container_name}"
+        puts "   Attach: docker exec -it #{container_name} tmux attach -t agent"
+        return
+      end
+
+      choice = prompt("   Agent started. Attach to session? [Y/n]: ", default: "Y", options: %w[Y N])
+
+      if choice == "Y"
+        puts ""
+        # Wait briefly for container to initialize
+        print "   Waiting for agent to initialize"
+        5.times do
+          print "."
+          sleep 1
+        end
+        puts ""
+        attach(agent_type, config, agent_configs)
+      else
+        puts ""
+        puts "   Agent is running in background."
+        puts "   Logs:   docker logs -f #{container_name}"
+        puts "   Stop:   docker stop #{container_name}"
+        puts "   Attach: docker exec -it #{container_name} tmux attach -t agent"
+      end
+    end
+  end
+end

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yatfa",
-  "version": "1.0.88",
+  "version": "1.0.90",
   "description": "YATFA - Yet Another Tool For Agents",
   "bin": "./bin/run-yatfa-agent.rb",
   "files": [

package/setup/agent_bridge.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+# Agent bridge binary download, tmux wrapper, and helper script installation
+# Extracted from setup-agent.rb for modularity (Round 2)
+#
+# Handles:
+#   - Architecture detection and multi-strategy bridge download
+#     (local override → Civo S3 presigned URL → GitHub fallback)
+#   - tmux binary download and INSIDE_TMUX=1 patching
+#   - Generic file download utility (download_file)
+#   - Helper script installation to /usr/local/bin
+#
+# Dependencies:
+#   - YATFA_RAW_URL constant is defined by setup-agent.rb
+#   - open-uri is loaded by setup-agent.rb before this file is required
+#
+# Consumers of download_file():
+#   - claude_settings.rb uses download_file() for hook installation
+#   - This file is loaded before claude_settings.rb to ensure the method exists
+
+# Helper scripts installed into /usr/local/bin by setup_helper_scripts!
+# Single source of truth — deploy/deploy reads this list too.
+HELPER_SCRIPTS = %w[fetch-skill-variant.sh fetch-review-context.sh attach-screenshot.sh].freeze
+
+def download_agent_bridge!
+  # Detect architecture
+  arch = `uname -m`.strip
+  if arch == "x86_64"
+    arch = "amd64"
+  elsif arch == "aarch64" || arch == "arm64"
+    arch = "arm64"
+  else
+    puts "❌ Unsupported architecture: #{arch}"
+    exit 1
+  end
+
+  target_dir = "/usr/local/bin"
+
+  # 1. Check for local override in /tmp/overrides (development mode)
+  override_dir = "/tmp/overrides"
+  if Dir.exist?(override_dir)
+    local_override = File.join(override_dir, "agent-bridge-linux-#{arch}")
+    if File.exist?(local_override)
+      puts "🔧 Using local override: #{local_override}"
+      system("sudo cp #{local_override} #{target_dir}/agent-bridge")
+      system("sudo chmod +x #{target_dir}/agent-bridge")
+      puts "✅ agent-bridge installed from local override"
+      return download_agent_bridge_tmux!(target_dir)
+    end
+  end
+
+  # 2. Check if binaries are mounted at /tmp (dev mode)
+  if File.exist?("/tmp/agent-bridge")
+    puts "🔧 Installing mounted agent-bridge..."
+    system("sudo cp /tmp/agent-bridge #{target_dir}/agent-bridge")
+    system("sudo chmod +x #{target_dir}/agent-bridge")
+    puts "✅ agent-bridge installed from mount"
+    return download_agent_bridge_tmux!(target_dir)
+  end
+
+  # 3. Try Civo bucket download (production mode)
+  if ENV["CIVO_ACCESS_KEY_ID"] && ENV["CIVO_SECRET_KEY"]
+    puts "📥 Downloading agent-bridge from Civo bucket..."
+    if download_from_civo!(arch, target_dir)
+      return download_agent_bridge_tmux!(target_dir)
+    else
+      puts "⚠️  Civo download failed, falling back to GitHub..."
+    end
+  end
+
+  # 4. Fallback to GitHub raw URLs (legacy)
+  bridge_url = "#{YATFA_RAW_URL}/bin/agent-bridge-linux-#{arch}"
+  puts "📥 Downloading agent-bridge for linux-#{arch} from GitHub..."
+  system("sudo curl -fsSL #{bridge_url} -o #{target_dir}/agent-bridge")
+  system("sudo chmod +x #{target_dir}/agent-bridge")
+
+  puts "✅ agent-bridge installed to #{target_dir}"
+  download_agent_bridge_tmux!(target_dir)
+end
+
+def download_from_civo!(arch, target_dir)
+  require "aws-sdk-s3"
+
+  region = ENV["CIVO_REGION"] || "LON1"
+  endpoint = ENV["CIVO_ENDPOINT"] || "https://objectstore.fra1.civo.com"
+  bucket = ENV["YATFA_BINARIES_BUCKET"] || "yatfa"
+  version = ENV["AGENT_BRIDGE_VERSION"] || "latest"
+
+  binary_name = "agent-bridge-linux-#{arch}"
+  key = "agent-bridge/#{version}/#{binary_name}"
+
+  puts "   Region: #{region}"
+  puts "   Bucket: #{bucket}"
+  puts "   Version: #{version}"
+  puts "   Binary: #{binary_name}"
+
+  begin
+    # Configure Civo S3-compatible client
+    Aws.config.update({
+      region: region,
+      endpoint: endpoint,
+      access_key_id: ENV["CIVO_ACCESS_KEY_ID"],
+      secret_access_key: ENV["CIVO_SECRET_KEY"]
+    })
+
+    s3 = Aws::S3::Resource.new
+    obj = s3.bucket(bucket).object(key)
+
+    # Generate presigned URL (valid for 1 hour)
+    url = obj.presigned_url(:get, expires_in: 3600)
+
+    puts "✅ Generated presigned URL"
+
+    # Download via curl (array form avoids shell interpolation of URL)
+    system("sudo", "curl", "-fsSL", url, "-o", "#{target_dir}/agent-bridge")
+
+    unless $?.success?
+      puts "❌ Failed to download agent-bridge from Civo"
+      return false
+    end
+
+    system("sudo chmod +x #{target_dir}/agent-bridge")
+    puts "✅ Downloaded agent-bridge from Civo"
+    return true
+
+  rescue LoadError
+    puts "⚠️  aws-sdk-s3 gem not installed"
+    return false
+  rescue Aws::S3::Errors::NoSuchKey
+    puts "❌ Version #{version} not found in bucket"
+    return false
+  rescue => e
+    puts "❌ Civo download failed: #{e.message}"
+    return false
+  end
+end
+
+def download_agent_bridge_tmux!(target_dir)
+  bridge_tmux_url = "#{YATFA_RAW_URL}/bin/agent-bridge-tmux"
+
+  if File.exist?("/tmp/agent-bridge-tmux")
+    puts "🔧 Installing mounted agent-bridge-tmux..."
+    system("sudo cp /tmp/agent-bridge-tmux #{target_dir}/agent-bridge-tmux")
+    system("sudo chmod +x #{target_dir}/agent-bridge-tmux")
+  else
+    system("sudo curl -fsSL #{bridge_tmux_url} -o #{target_dir}/agent-bridge-tmux")
+    system("sudo chmod +x #{target_dir}/agent-bridge-tmux")
+  end
+
+  # Patch agent-bridge-tmux to force INSIDE_TMUX=1
+  # Note: This is now fixed in the repo, but we keep this for backward compatibility
+  # with older agent-bridge-tmux scripts if cached
+  puts "🔧 Patching agent-bridge-tmux to force INSIDE_TMUX=1..."
+
+  # Read the file (we can read /usr/local/bin files usually)
+  content = File.read("#{target_dir}/agent-bridge-tmux")
+
+  # Replace the command if not already present
+  unless content.include?("export INSIDE_TMUX=1")
+    new_content = content.gsub(
+      "&& agent-bridge\"",
+      "&& export INSIDE_TMUX=1 && agent-bridge\""
+    )
+
+    # Write to temp file
+    File.write("/tmp/agent-bridge-tmux-patched", new_content)
+
+    # Move to destination with sudo
+    system("sudo mv /tmp/agent-bridge-tmux-patched #{target_dir}/agent-bridge-tmux")
+    system("sudo chmod +x #{target_dir}/agent-bridge-tmux")
+  end
+
+  return target_dir
+end
+
+def install_helper_script(bin_dir, script_name)
+  url = "#{YATFA_RAW_URL}/bin/#{script_name}"
+  begin
+    script_content = URI.open(url).read
+    puts "   (from remote: #{url})"
+  rescue OpenURI::HTTPError, Errno::ENOENT => e
+    puts "⚠️  Failed to download #{script_name}: #{e.message}"
+    return false
+  end
+
+  target = File.join(bin_dir, script_name)
+  temp_script = "/tmp/#{script_name}.temp"
+  File.write(temp_script, script_content)
+  system("sudo mv #{temp_script} #{target}")
+  system("sudo chmod +x #{target}")
+  puts "✅ Installed #{script_name} to #{bin_dir}"
+  true
+end
+
+# Download a file from remote URL to a destination directory
+# @param script_name [String] filename to download
+# @param remote_url [String] full URL to download from
+# @param dest_dir [String] directory to save into
+# @param executable [Boolean] whether to chmod 0755 (default: true)
+# @param label [String] human-readable label for log messages (default: script_name)
+# @return [String, nil] downloaded file path, or nil on failure
+def download_file(script_name:, remote_url:, dest_dir:, executable: true, label: nil)
+  label ||= script_name
+  dest_path = File.join(dest_dir, script_name)
+
+  puts "📥 Downloading #{label}..."
+  begin
+    content = URI.open(remote_url).read
+    File.write(dest_path, content)
+    File.chmod(0755, dest_path) if executable
+    puts "✅ Installed #{label} to #{dest_path}"
+    dest_path
+  rescue OpenURI::HTTPError => e
+    puts "⚠️  Failed to download #{label}: #{e.message}"
+    nil
+  end
+end
+
+def setup_helper_scripts!
+  # Install helper scripts that skills use for command injection
+  bin_dir = "/usr/local/bin"
+
+  puts "🛠️  Setting up helper scripts..."
+
+  HELPER_SCRIPTS.each do |script_name|
+    install_helper_script(bin_dir, script_name)
+  end
+end

package/setup/claude_settings.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+# Claude CLI settings, LLM credentials, and hook installation
+# Extracted from setup-agent.rb for modularity
+#
+# Handles:
+#   - Fetching LLM credentials from the backend API (BYOK support)
+#   - Configuring ~/.claude/settings.json with env vars and hooks
+#   - Installing SessionStart/Stop hooks
+#   - Setting up the project hooks wrapper
+#
+# Dependencies:
+#   - download_file() is defined by agent_bridge.rb
+#   - YATFA_RAW_URL constant is defined by setup-agent.rb
+#   - Standard library requires (json, fileutils, etc.) are loaded
+#     by setup-agent.rb before this file is required
+
+def fetch_llm_credentials!
+  rails_api_url = ENV["YATFA_API_URL"]
+  rails_api_key = ENV["YATFA_API_KEY"]
+
+  unless rails_api_url && !rails_api_url.empty? && rails_api_key && !rails_api_key.empty?
+    puts "❌ YATFA_API_URL or YATFA_API_KEY not set"
+    return nil
+  end
+
+  # Fetch LLM credentials from Rails API
+  uri = URI("#{rails_api_url}/llm/credentials")
+  http = Net::HTTP.new(uri.host, uri.port)
+  http.use_ssl = uri.scheme == "https"
+  http.open_timeout = 10
+  http.read_timeout = 10
+
+  request = Net::HTTP::Get.new(uri)
+  request["X-API-Key"] = rails_api_key
+  request["Accept"] = "application/json"
+
+  begin
+    puts "🔍 Fetching LLM credentials from #{rails_api_url}/llm/credentials..."
+    response = http.request(request)
+
+    if response.is_a?(Net::HTTPSuccess)
+      data = JSON.parse(response.body)
+      puts "✅ LLM credentials fetched successfully"
+      data
+    elsif response.is_a?(Net::HTTPNotFound)
+      puts "❌ No LLM credentials configured in backend"
+      nil
+    else
+      puts "❌ Failed to fetch LLM credentials: #{response.code} #{response.message}"
+      puts "   Response: #{response.body}"
+      nil
+    end
+  rescue Net::OpenTimeout, Net::ReadTimeout => e
+    puts "❌ Timeout fetching LLM credentials: #{e.message}"
+    nil
+  rescue => e
+    puts "❌ Error fetching LLM credentials: #{e.message}"
+    nil
+  end
+end
+
+def setup_claude_settings!
+  settings_dir = File.expand_path("~/.claude")
+  FileUtils.mkdir_p(settings_dir)
+  home_settings_json = File.join(settings_dir, "settings.json")
+
+  puts "🔧 Configuring ~/.claude/settings.json..."
+
+  settings_config = {}
+
+  # Fetch LLM credentials from Rails backend (BYOK support)
+  llm_credentials = fetch_llm_credentials!
+
+  if llm_credentials
+    puts "✅ Fetched LLM credentials from backend (source: #{llm_credentials['source']})"
+
+    # Configure Claude CLI with LLM provider environment variables
+    settings_config["env"] ||= {}
+    settings_config["env"]["ANTHROPIC_AUTH_TOKEN"] = llm_credentials["api_key"]
+
+    if llm_credentials["base_url"] && !llm_credentials["base_url"].empty?
+      settings_config["env"]["ANTHROPIC_BASE_URL"] = llm_credentials["base_url"]
+      puts "   Custom base URL: #{llm_credentials['base_url']}"
+    else
+      settings_config["env"].delete("ANTHROPIC_BASE_URL") if settings_config["env"]["ANTHROPIC_BASE_URL"]
+      puts "   Using default Anthropic base URL"
+    end
+
+    # Configure model selection if specified
+    # Each model tier can be configured independently
+    %w[haiku sonnet opus].each do |tier|
+      key = "model_#{tier}"
+      if llm_credentials[key] && !llm_credentials[key].empty?
+        settings_config["env"]["ANTHROPIC_DEFAULT_#{tier.upcase}_MODEL"] = llm_credentials[key]
+        puts "   #{tier.capitalize} model: #{llm_credentials[key]}"
+      end
+    end
+
+    # Configure context window if specified (value is in k-units, append 'k' suffix)
+    if llm_credentials["context_window"] && !llm_credentials["context_window"].to_s.empty?
+      context_window_value = llm_credentials["context_window"].to_i
+      if context_window_value > 0
+        settings_config["env"]["CLAUDE_CODE_AUTO_COMPACT_WINDOW"] = "#{context_window_value}000"
+        puts "   Context window: #{context_window_value}k tokens"
+      end
+    end
+
+    unless %w[haiku sonnet opus].any? { |tier| llm_credentials["model_#{tier}"] }
+      puts "   Using default Anthropic models"
+    end
+  else
+    puts "❌ No LLM credentials found in backend!"
+    puts "   Please configure LLM API key for this agent or its project in the Yatfa dashboard."
+    puts "   Agent will fail to start without credentials."
+    exit 1
+  end
+
+  # No settings loaded from host - agent is fully self-contained
+
+  # Configure hooks
+  settings_config["hooks"] ||= {}
+  hooks_dir = File.join(settings_dir, "hooks")
+  FileUtils.mkdir_p(hooks_dir)
+
+  # SessionStart hook: skill knowledge injection
+  install_hook!(
+    settings_config, hooks_dir,
+    hook_type: "SessionStart",
+    script_name: "inject-skill-knowledge.rb",
+    match_substring: "inject-skill-knowledge.rb",
+    command_prefix: "ruby"
+  )
+
+  # Install sessionstart-input.sh for repository context injection
+  download_file(
+    script_name: "sessionstart-input.sh",
+    remote_url: "#{YATFA_RAW_URL}/hooks/sessionstart-input.sh",
+    dest_dir: hooks_dir,
+    label: "SessionStart input hook"
+  )
+
+  # Add agent-specific settings
+  settings_config["skipDangerousModePermissionPrompt"] = true
+
+  # Stop hook: session-end learning capture
+  install_hook!(
+    settings_config, hooks_dir,
+    hook_type: "Stop",
+    script_name: "sessionend-output.sh",
+    match_substring: "sessionend-output.sh",
+    command_prefix: "bash"
+  )
+
+  # Download and register project hooks wrapper
+  # The wrapper fetches user-defined hooks from the API at runtime (with caching),
+  # executes them, and reports results back for observability.
+  setup_project_hooks_wrapper!(settings_config, hooks_dir)
+
+  File.write(home_settings_json, JSON.pretty_generate(settings_config))
+  puts "✅ ~/.claude/settings.json configured with skill hooks"
+end
+
+# Install a Claude settings hook by downloading the script and registering it.
+#
+# Handles the common pattern: ensure hook array → remove old entry → download → append.
+#
+# @param settings_config [Hash] the settings.json hash being built
+# @param hooks_dir [String] directory to download hook scripts into
+# @param hook_type [String] Claude hook type (e.g. "SessionStart", "Stop")
+# @param script_name [String] filename of the hook script to download
+# @param match_substring [String] substring to match when removing old hook entries
+# @param command_prefix [String] command prefix ("ruby" or "bash")
+def install_hook!(settings_config, hooks_dir, hook_type:, script_name:, match_substring:, command_prefix:)
+  settings_config["hooks"][hook_type] ||= []
+  # Remove old hook entry if present (idempotent re-runs)
+  settings_config["hooks"][hook_type].reject! do |h|
+    h["hooks"]&.first&.dig("command")&.include?(match_substring)
+  end
+
+  dest_path = download_file(
+    script_name: script_name,
+    remote_url: "#{YATFA_RAW_URL}/hooks/#{script_name}",
+    dest_dir: hooks_dir,
+    label: "#{hook_type} hook"
+  )
+
+  if dest_path
+    settings_config["hooks"][hook_type] << {
+      "hooks" => [{ "type" => "command", "command" => "#{command_prefix} \"#{dest_path}\"" }]
+    }
+  else
+    puts "⚠️ Skipping #{hook_type} hook configuration (download failed)"
+  end
+end
+
+# Download and register the project hooks wrapper as a SessionStart hook.
+# The wrapper handles fetching user-defined hooks from the API at runtime,
+# executing them, and reporting results. Hook content is managed by users
+# via the Yatfa config UI and stored as ProjectConfig records.
+def setup_project_hooks_wrapper!(settings_config, hooks_dir)
+  wrapper_path = download_file(
+    script_name: "project-hooks-wrapper.rb",
+    remote_url: "#{YATFA_RAW_URL}/hooks/project-hooks-wrapper.rb",
+    dest_dir: hooks_dir,
+    label: "Project hooks wrapper"
+  )
+
+  if wrapper_path
+    settings_config["hooks"]["SessionStart"] << {
+      "hooks" => [{ "type" => "command", "command" => "ruby \"#{wrapper_path}\"" }]
+    }
+    puts "✅ Registered project hooks wrapper"
+  else
+    puts "⚠️  Skipping project hooks wrapper (download failed)"
+  end
+end