yatfa 1.0.65

package/bin/run-yatfa-agent.rb

@@ -0,0 +1,69 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# YATFA Agent Runner (Yet Another Tool For Agents)
+# Usage: npx yatfa-agent [worker|planner|reviewer|researcher]
+#        npx yatfa-agent attach [agent-type]
+#        npx yatfa-agent setup
+#
+# Requirements:
+#   - Docker
+#   - Ruby
+#   - Dockerfile.sandbox in project root
+#   - yatfa.env.rb in project root (gitignored)
+
+require_relative "../lib/yatfa_agent/config"
+require_relative "../lib/yatfa_agent/docker"
+require_relative "../lib/yatfa_agent/agent"
+require_relative "../lib/yatfa_agent/setup"
+require_relative "../agents"
+
+def show_usage
+  puts "YATFA Agent Runner (Yet Another Tool For Agents)"
+  puts ""
+  puts "Usage:"
+  puts "  npx yatfa-agent setup                    # Interactive setup wizard"
+  puts "  npx yatfa-agent [worker|planner|reviewer|researcher]  # Run agent"
+  puts "  npx yatfa-agent attach [agent-type]      # Attach to running agent"
+  puts ""
+  puts "Setup:"
+  puts "  Run 'npx yatfa-agent setup' for interactive configuration"
+  puts ""
+  puts "Manual setup:"
+  puts "  1. Create Dockerfile.sandbox (see https://github.com/RoM4iK/yatfa-public/blob/main/README.md)"
+  puts "  2. Create yatfa.env.rb (see https://github.com/RoM4iK/yatfa-public/blob/main/README.md)"
+  puts "  3. echo 'yatfa.env.rb' >> .gitignore"
+  puts "  4. npx yatfa-agent worker"
+  exit 1
+end
+
+# Main
+show_usage if ARGV.empty?
+
+command = ARGV[0].downcase
+
+# Handle setup command
+if command == "setup"
+  wizard = YatfaAgent::Setup::SetupWizard.new
+  wizard.run
+  exit 0
+end
+
+# Handle attach command
+if command == "attach"
+  agent_type = ARGV[1]&.downcase
+  abort "Usage: npx yatfa-agent attach [agent-type]" unless agent_type
+  config = YatfaAgent::Config.load
+  YatfaAgent::Config.fetch_repositories!(config)
+  YatfaAgent::Agent.attach(agent_type, config, AGENT_CONFIGS)
+else
+  # Handle run commands (worker, planner, reviewer, researcher)
+  config = YatfaAgent::Config.load
+  # Fetch repositories from Rails API before building
+  YatfaAgent::Config.fetch_repositories!(config)
+  YatfaAgent::Docker.build_image(config)
+  # For "run" command, use second argument as agent type
+  # For "attach" command, handled separately above
+  agent_type_to_run = (command == "run") ? ARGV[1] : command
+  YatfaAgent::Agent.run(agent_type_to_run, config, AGENT_CONFIGS)
+end

package/lib/yatfa_agent/agent.rb

@@ -0,0 +1,289 @@
+# frozen_string_literal: true
+require 'fileutils'
+
+module YatfaAgent
+  module Agent
+    def self.run(agent_type, config, agent_configs)
+      unless agent_configs.keys.include?(agent_type)
+        puts "❌ Unknown agent type: #{agent_type}"
+        puts "   Available: #{agent_configs.keys.join(', ')}"
+        exit 1
+      end
+
+      agent_def = agent_configs[agent_type]
+      agent_config = config.dig("agents", agent_type) || {}
+      container_name = agent_config["container_name"] || agent_def[:name]
+
+      puts "🚀 Starting #{agent_type} agent..."
+
+      # Stop existing container if running
+      system("docker", "rm", "-f", container_name, err: File::NULL, out: File::NULL)
+
+      # Write banner to a persistent temp file (not auto-deleted)
+      banner_path = "/tmp/yatfa-agent-banner-#{agent_type}.txt"
+      FileUtils.rm_rf(banner_path)
+
+      # Append repository context to banner
+      banner_content = agent_def[:banner].dup
+      if config["repositories"]&.any?
+        sorted_repos = config["repositories"].sort_by { |r| r["position"] || 0 }
+        repo_info = sorted_repos.map do |repo|
+          name = repo["name"]
+          path = repo["path_in_sandbox"] || "/workspace/#{name}"
+          "  - **#{name}**: #{path}"
+        end.join("\n")
+
+        banner_content += "\n\n## REPOSITORY STRUCTURE\n\n"
+        banner_content += "This project has #{sorted_repos.count} repositories:\n\n"
+        banner_content += "#{repo_info}\n\n"
+      end
+
+      File.write(banner_path, banner_content)
+
+      docker_cmd = build_docker_command(container_name, agent_type, config, agent_config, agent_def, banner_path)
+
+      success = system(*docker_cmd)
+
+      if success
+        puts "✅ Agent started in background"
+        puts ""
+        puts "   Attach: npx yatfa-agent attach #{agent_type}"
+        puts "   Logs:   docker logs -f #{container_name}"
+        puts "   Stop:   docker stop #{container_name}"
+      else
+        puts "❌ Failed to start agent"
+        exit 1
+      end
+    end
+
+    def self.attach(agent_type, config, agent_configs)
+      unless agent_configs.keys.include?(agent_type)
+        puts "❌ Unknown agent type: #{agent_type}"
+        exit 1
+      end
+
+      agent_def = agent_configs[agent_type]
+      agent_config = config.dig("agents", agent_type) || {}
+      container_name = agent_config["container_name"] || agent_def[:name]
+
+      running = `docker ps --filter name=^#{container_name}$ --format '{{.Names}}'`.strip
+
+      if running.empty?
+        puts "⚠️  #{agent_type} agent is not running. Auto-starting..."
+        Docker.build_image(config)
+        run(agent_type, config, agent_configs)
+        sleep 3
+      end
+
+      puts "📎 Attaching to #{agent_type} agent..."
+      
+      user = detect_agent_user(container_name)
+      puts "   User: #{user}"
+
+      # Wait for tmux session to be ready
+      10.times do
+        if system("docker", "exec", "-u", user, container_name, "tmux", "has-session", "-t", "agent", err: File::NULL, out: File::NULL)
+          break
+        end
+        sleep 1
+      end
+
+      # Attach to agent session which has the status bar
+      # Must run as agent user since tmux server runs under that user
+      exec("docker", "exec", "-it", "-u", user, container_name, "tmux", "attach", "-t", "agent")
+    end
+
+    private
+
+    def self.build_docker_command(container_name, agent_type, config, agent_config, agent_def, banner_path)
+      docker_cmd = [
+        "docker", "run", "-d",
+        "--name", container_name,
+        "--network", "host",
+        "--restart", "unless-stopped",
+        "--tmpfs", "/rails/tmp",
+        "--tmpfs", "/rails/log"
+      ]
+
+      # Inject custom environment variables from config
+      # Merge global env with agent-specific env (agent-specific takes precedence)
+      merged_env = {}
+      merged_env.merge!(config["env"]) if config["env"]
+      merged_env.merge!(agent_config["env"]) if agent_config["env"]
+      
+      if merged_env.any?
+        merged_env.each do |k, v|
+          docker_cmd += ["-e", "#{k}=#{v}"]
+        end
+        global_count = config["env"]&.size || 0
+        agent_count = agent_config["env"]&.size || 0
+        if agent_count > 0
+          puts "🌿 Injected #{global_count} global + #{agent_count} agent-specific env vars"
+        else
+          puts "🌿 Injected #{global_count} custom env vars from config"
+        end
+      end
+
+      docker_cmd += [
+        "-v", "#{banner_path}:/etc/yatfa/system-prompt.txt:ro",
+        "-e", "YATFA_VERSION=main",
+        "-e", "SKILLS=#{agent_def[:skills]&.join(',')}",
+        "-e", "AGENT_TYPE=#{agent_type}",
+        "-e", "YATFA_URL=#{YatfaAgent::Config.yatfa_url(config)}",
+        "-e", "YATFA_API_KEY=#{agent_config['mcp_api_key']}"
+      ]
+
+      add_github_auth!(docker_cmd, config)
+      add_git_config!(docker_cmd, config)
+      add_repository_mounts!(docker_cmd, config)
+      add_development_mounts!(docker_cmd)
+
+      local_setup_script = File.join(File.dirname(__FILE__), "..", "..", "setup-agent.rb")
+      
+      if File.exist?(local_setup_script)
+        docker_cmd += [Config.image_name(config), "ruby", "/tmp/setup-agent.rb"]
+      else
+        docker_cmd += [Config.image_name(config)]
+      end
+
+      docker_cmd
+    end
+
+    def self.add_github_auth!(docker_cmd, config)
+      github = config["github"] || {}
+
+      # New method: GitHub authentication is handled by the backend
+      # Agents get tokens via YATFA_API_KEY using the /github/token endpoint
+      # No GitHub credentials need to be passed into the container
+
+      # Deprecation warning for old GitHub App config
+      if github["method"] == "app" || github["app_client_id"] || github["app_installation_id"]
+        puts "⚠️  Warning: GitHub App configuration in yatfa.env.rb is deprecated"
+        puts "   GitHub credentials are now managed centrally in the Rails backend"
+        puts "   You can remove the 'github' section from yatfa.env.rb"
+        puts "   The backend will use its own GitHub App credentials to generate tokens"
+      end
+
+      # Optional: Support GH_TOKEN fallback for development/testing
+      if github["token"]
+        docker_cmd.concat(["-e", "GH_TOKEN=#{github['token']}"])
+        puts "🔑 Using GitHub token authentication (fallback mode)"
+      else
+        puts "✅ GitHub authentication will be handled by backend (YATFA_API_KEY)"
+      end
+    end
+
+    def self.add_git_config!(docker_cmd, config)
+      return unless (git_config = config["git"])
+      
+      docker_cmd.concat(["-e", "GIT_USER_NAME=#{git_config['user_name']}"]) if git_config["user_name"]
+      docker_cmd.concat(["-e", "GIT_USER_EMAIL=#{git_config['user_email']}"]) if git_config["user_email"]
+    end
+
+    def self.add_repository_mounts!(docker_cmd, config)
+      return unless config["repositories"].is_a?(Array) && config["repositories"].any?
+
+      puts "📚 Configuring #{config['repositories'].count} repositories..."
+
+      # Build REPOSITORIES_CONTEXT for sessionstart hook (format: "name:path,name:path")
+      sorted_repos = config["repositories"].sort_by { |r| r["position"] || 0 }
+      repos_context = sorted_repos.map do |repo|
+        repo_name = repo["name"]
+        sandbox_path = repo["path_in_sandbox"] || "/workspace/#{repo_name}"
+        "#{repo_name}:#{sandbox_path}"
+      end.join(",")
+
+      docker_cmd.concat(["-e", "REPOSITORIES_CONTEXT=#{repos_context}"])
+
+      # Pass repository config via environment variables for container to clone
+      repo_config_json = sorted_repos.to_json
+      docker_cmd.concat(["-e", "REPOSITORIES_CONFIG=#{repo_config_json}"])
+
+      sorted_repos.each do |repo|
+        repo_name = repo["name"]
+        sandbox_path = repo["path_in_sandbox"] || "/workspace/#{repo_name}"
+        puts "   - #{repo_name}: #{sandbox_path} (will be cloned in container)"
+      end
+    end
+
+    def self.add_development_mounts!(docker_cmd)
+      # Check for local setup-agent.rb (for development)
+      local_setup_script = File.join(File.dirname(__FILE__), "..", "..", "setup-agent.rb")
+
+      # Check for local agent-bridge binaries (for development)
+      arch = `uname -m`.strip
+      linux_arch = (arch == "x86_64") ? "amd64" : "arm64"
+
+      # Try multiple possible paths for the binary (built Go binaries in dist/)
+      possible_paths = [
+        File.join(Dir.pwd, "overrides", "agent-bridge-linux-#{linux_arch}"),              # YATFA_SANDBOX/overrides
+        File.join(Dir.pwd, "yatfa-public", "dist", "agent-bridge-linux-#{linux_arch}"),  # Running from metafolder
+        File.join(Dir.pwd, "dist", "agent-bridge-linux-#{linux_arch}"),                    # Running from yatfa-public
+      ]
+
+      linux_bridge = nil
+      possible_paths.each do |path|
+        if File.exist?(path)
+          linux_bridge = path
+          break
+        end
+      end
+
+      local_bridge_default = File.join(Dir.pwd, "bin", "agent-bridge")
+      local_tmux = File.join(File.dirname(__FILE__), "..", "..", "bin", "agent-bridge-tmux")
+
+      if File.exist?(local_setup_script)
+        puts "🔧 Using local setup-agent.rb for development"
+        docker_cmd.concat(["-v", "#{File.expand_path(local_setup_script)}:/tmp/setup-agent.rb:ro"])
+      end
+
+      if linux_bridge && File.exist?(linux_bridge)
+        puts "🔧 Using local linux binary: #{linux_bridge}"
+        docker_cmd.concat(["-v", "#{File.expand_path(linux_bridge)}:/tmp/agent-bridge:ro"])
+      elsif File.exist?(local_bridge_default)
+        # Check if it's a binary or script
+        is_script = File.read(local_bridge_default, 4) == "#!/b"
+        if is_script
+          puts "⚠️  bin/agent-bridge is a host wrapper script. Please run 'bin/build-bridge' to generate linux binaries."
+        else
+          puts "🔧 Using local agent-bridge binary"
+          docker_cmd.concat(["-v", "#{local_bridge_default}:/tmp/agent-bridge:ro"])
+        end
+      end
+
+      if File.exist?(local_tmux)
+        docker_cmd.concat(["-v", "#{File.expand_path(local_tmux)}:/tmp/agent-bridge-tmux:ro"])
+      end
+    end
+
+    def self.detect_agent_user(container_name)
+      # Determine the user to attach as
+      # Robust method: find the user running the agent process (tmux or bridge)
+      user = `docker exec #{container_name} ps aux | grep "[a]gent-bridge-tmux" | awk '{print $1}' | head -n 1`.strip
+      
+      if user.empty?
+        user = `docker exec #{container_name} ps aux | grep "[t]mux new-session" | awk '{print $1}' | head -n 1`.strip
+      end
+
+      if user.empty?
+        # Fallback to previous heuristic
+        detected_user = `docker exec #{container_name} whoami 2>/dev/null`.strip
+        if detected_user == "root" || detected_user.empty?
+          uid = Process.uid
+          mapped_user = `docker exec #{container_name} getent passwd #{uid} | cut -d: -f1`.strip
+          user = mapped_user unless mapped_user.empty?
+        else
+          user = detected_user
+        end
+      end
+      
+      if user.empty?
+        # Final Fallback
+        user = "rails"
+        puts "⚠️  Could not detect agent user, defaulting to '#{user}'"
+      end
+      
+      user
+    end
+  end
+end

package/lib/yatfa_agent/config.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require "json"
+
+module YatfaAgent
+  module Config
+    def self.load
+      rb_config_file = File.join(Dir.pwd, "yatfa.env.rb")
+
+      unless File.exist?(rb_config_file)
+        puts "❌ Error: yatfa.env.rb not found in current directory"
+        puts ""
+        puts "Create yatfa.env.rb:"
+        puts "  {"
+        puts "    yatfa_url: 'https://yatfa.example.com',  # Required"
+        puts "    # OR legacy name:"
+        puts "    rails_api_url: 'https://yatfa.example.com/api/v1',"
+        puts "    # ..."
+        puts "    # Paste your stripped .env content here:"
+        puts "    dot_env: <<~ENV"
+        puts "      STRIPE_KEY=sk_test_..."
+        puts "      OPENAI_KEY=sk-..."
+        puts "    ENV"
+        puts "  }"
+        puts "  echo 'yatfa.env.rb' >> .gitignore"
+        puts "        exit 1"
+      end
+
+      puts "⚙️  Loading configuration from yatfa.env.rb"
+      config = eval(File.read(rb_config_file), binding, rb_config_file)
+
+      # Convert symbols to strings for easier handling before JSON normalization
+      config = config.transform_keys(&:to_s)
+
+      # Parse dot_env heredoc if present
+      if (dotenv = config["dot_env"])
+        config["env"] ||= {}
+        # Ensure env is string-keyed
+        config["env"] = config["env"].transform_keys(&:to_s)
+
+        dotenv.each_line do |line|
+          line = line.strip
+          next if line.empty? || line.start_with?('#')
+          k, v = line.split('=', 2)
+          next unless k && v
+          # Remove surrounding quotes and trailing comments (simple)
+          v = v.strip.gsub(/^['"]|['"]$/, '')
+          config["env"][k.strip] = v
+        end
+
+        config.delete("dot_env")
+        puts "🌿 Parsed dot_env into #{config['env'].size} environment variables"
+      end
+
+      # Normalize per-agent env hashes
+      if config["agents"].is_a?(Hash)
+        config["agents"].each do |agent_key, agent_config|
+          agent_key = agent_key.to_s
+          if agent_config.is_a?(Hash) && agent_config["env"].is_a?(Hash)
+            agent_config["env"] = agent_config["env"].transform_keys(&:to_s)
+          elsif agent_config.is_a?(Hash) && agent_config[:env].is_a?(Hash)
+            agent_config["env"] = agent_config[:env].transform_keys(&:to_s)
+          end
+        end
+      end
+
+      # Normalize symbols to strings for consistency via JSON round-trip
+      JSON.parse(JSON.generate(config))
+    end
+
+    def self.yatfa_url(config)
+      # Support both new name and legacy name for backwards compatibility
+      config["yatfa_url"] || config["yafta_url"] || config["rails_api_url"]
+    end
+
+    def self.api_url(config)
+      # Derive API URL from yatfa_url
+      yatfa_base = yatfa_url(config)
+
+      # If yatfa_url already includes /api/v1, return as-is
+      return yatfa_base if yatfa_base.end_with?("/api/v1") || yatfa_base.end_with?("/api/")
+
+      # Otherwise, assume it's the base URL and append /api/v1
+      "#{yatfa_base}/api/v1"
+    end
+
+    def self.ws_url(config)
+      # Derive WebSocket URL from yatfa_url by replacing protocol and adding /cable endpoint
+      api_base = yatfa_url(config)
+      "#{api_base.sub(/^https:\/\//, "wss://").sub(/^http:\/\//, "ws://")}/cable"
+    end
+
+    def self.fetch_repositories!(config)
+      # Support both old and new config keys
+      api_base = api_url(config)
+
+      return unless api_base
+
+      # Use to first available agent's MCP API key
+      mcp_api_key = nil
+      if config["agents"].is_a?(Hash)
+        config["agents"].each do |_, agent_config|
+          if agent_config.is_a?(Hash) && agent_config["mcp_api_key"]
+            mcp_api_key = agent_config["mcp_api_key"]
+            break
+          end
+        end
+      end
+
+      return unless mcp_api_key
+
+      # First, discover which project we belong to via /whoami
+      require "net/http"
+      require "json"
+      require "uri"
+
+      whoami_uri = URI("#{api_base}/whoami")
+      whoami_response = Net::HTTP.get_response(whoami_uri, { "X-API-Key" => mcp_api_key, "Accept" => "application/json" })
+
+      if whoami_response.code != "200"
+        puts "⚠️  Unable to discover project from /whoami (HTTP #{whoami_response.code})"
+        return
+      end
+
+      agent_info = JSON.parse(whoami_response.body)
+      project_id = agent_info["project_id"]
+      project_name = agent_info["name"] rescue "unknown"
+
+      puts "🔑 Authenticated as #{agent_info["name"]} (project #{project_id})"
+
+      # Then fetch repositories from Rails API (scoped to our project)
+      uri = URI("#{api_base}/repositories")
+      begin
+        response = Net::HTTP.get_response(uri, { "X-API-Key" => mcp_api_key, "Accept" => "application/json" })
+
+        if response.code == "200"
+          repositories = JSON.parse(response.body)
+
+          if repositories.any?
+            config["repositories"] = repositories
+
+            # Build REPOSITORIES_CONTEXT string: "name:path,name:path"
+            repo_context = repositories.map { |r| "#{r['name']}:#{r['path_in_sandbox']}" }.join(",")
+            config["env"] ||= {}
+            config["env"]["REPOSITORIES_CONTEXT"] = repo_context
+
+            puts "📚 Loaded #{repositories.count} repositories for project #{project_id} (#{project_name})"
+            repositories.each do |repo|
+              puts "   - #{repo['name']}: #{repo['path_in_sandbox']}"
+            end
+          end
+        else
+          puts "⚠️  Unable to fetch repositories (HTTP #{response.code})"
+        end
+      rescue StandardError => e
+        puts "⚠️  Failed to fetch repositories: #{e.message}"
+      end
+    end
+
+    def self.image_name(config)
+      "yatfa-sandbox"
+    end
+  end
+end

package/lib/yatfa_agent/docker.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module YatfaAgent
+  module Docker
+    def self.check_dockerfile!
+      unless File.exist?("Dockerfile.sandbox")
+        puts "❌ Error: Dockerfile.sandbox not found"
+        puts ""
+        puts "Please create Dockerfile.sandbox by copying your existing Dockerfile"
+        puts "and adding the required agent dependencies."
+        puts ""
+        puts "See https://github.com/RoM4iK/yatfa-public/blob/main/README.md for instructions."
+        exit 1
+      end
+    end
+
+    def self.build_image(config)
+      check_dockerfile!
+
+      user_id = `id -u`.strip
+      group_id = `id -g`.strip
+
+      puts "🏗️  Building Docker image..."
+
+      # Handle .dockerignore.sandbox
+      dockerignore_sandbox = ".dockerignore.sandbox"
+      dockerignore_original = ".dockerignore"
+      dockerignore_backup = ".dockerignore.bak"
+
+      has_sandbox_ignore = File.exist?(dockerignore_sandbox)
+      has_original_ignore = File.exist?(dockerignore_original)
+
+      if has_sandbox_ignore
+        puts "📦 Swapping .dockerignore with .dockerignore.sandbox..."
+        if has_original_ignore
+          FileUtils.mv(dockerignore_original, dockerignore_backup)
+        end
+        FileUtils.cp(dockerignore_sandbox, dockerignore_original)
+      end
+
+      success = false
+      begin
+        success = system(
+          "docker", "build",
+          "--build-arg", "USER_ID=#{user_id}",
+          "--build-arg", "GROUP_ID=#{group_id}",
+          "-t", Config.image_name(config),
+          "-f", "Dockerfile.sandbox",
+          "."
+        )
+      ensure
+        if has_sandbox_ignore
+          # Restore original state
+          FileUtils.rm(dockerignore_original) if File.exist?(dockerignore_original)
+          if has_original_ignore
+            FileUtils.mv(dockerignore_backup, dockerignore_original)
+          end
+          puts "🧹 Restored original .dockerignore"
+        end
+      end
+
+      unless success
+        puts "❌ Failed to build Docker image"
+        exit 1
+      end
+
+      puts "✅ Docker image built"
+    end
+  end
+end