yatfa 1.0.94 → 1.0.96

package/bin/install-agent.sh

@@ -101,7 +101,7 @@ YATFA_VERSION=${YATFA_VERSION:-main}
 cat << 'EOF' > /usr/local/bin/setup-agent
 #!/bin/bash
 YATFA_VERSION=${YATFA_VERSION:-main}
-BASE_URL="https://objectstore.fra1.civo.com/yatfa/${YATFA_VERSION}"
+BASE_URL="https://pub-06ce56b9a9c143118036f593f07ac1d8.r2.dev/${YATFA_VERSION}"
 # Use local setup/ dir if mounted (dev mode), otherwise download all from remote
 if [ -f "/tmp/setup/setup-agent.rb" ]; then
   echo "🔧 Using local setup/ (dev mode)"

package/lib/yatfa_agent/config.rb

@@ -1,10 +1,15 @@
 # frozen_string_literal: true
 
 require "json"
+require "digest"
 require_relative "http"
 
 module YatfaAgent
   module Config
+    # Image name returned when the project's Dockerfile.sandbox is not present
+    # (e.g. image_name queried before the file is materialized, or offline).
+    DEFAULT_IMAGE_NAME = "yatfa-sandbox"
+    DOCKERFILE_SANDBOX = "Dockerfile.sandbox"
     # Walk up the directory tree from +start_dir+ (default: Dir.pwd)
     # looking for yatfa.env.rb. Returns the directory containing the
     # config file, or nil if not found.
@@ -104,22 +109,27 @@ module YatfaAgent
       "#{api_base.sub(/^https:\/\//, "wss://").sub(/^http:\/\//, "ws://")}/cable"
     end
 
+    # Extract the first available agent MCP API key from the config.
+    # Returns nil when no key is configured.
+    def self.agent_api_key(config)
+      agents = config["agents"]
+      return nil unless agents.is_a?(Hash)
+
+      agents.each_value do |agent_config|
+        return agent_config["mcp_api_key"] if agent_config.is_a?(Hash) && agent_config["mcp_api_key"]
+      end
+
+      nil
+    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
+      # Use the first available agent's MCP API key
+      mcp_api_key = agent_api_key(config)
 
       return unless mcp_api_key
 
@@ -146,6 +156,10 @@ module YatfaAgent
       project_id = agent_info["project_id"]
       project_name = agent_info["name"] rescue "unknown"
 
+      # Expose the resolved project id so downstream steps can scope per-project
+      # resources (image tag, dockerfile_sandbox fetch) without another round-trip.
+      config["project_id"] = project_id if project_id
+
       puts "🔑 Authenticated as #{agent_info["name"]} (project #{project_id})"
 
       # Then fetch repositories from Rails API (scoped to our project)
@@ -176,8 +190,20 @@ module YatfaAgent
       end
     end
 
+    # Per-project Docker image tag so concurrent projects on one host don't
+    # clobber the shared "yatfa-sandbox" tag.
+    #
+    # The tag is derived from a digest of the project's Dockerfile.sandbox
+    # content: projects with an identical dockerfile share one image (no
+    # redundant rebuilds), while projects with different dockerfiles build to
+    # distinct tags and never overwrite each other. Falls back to
+    # +DEFAULT_IMAGE_NAME+ when no Dockerfile.sandbox is present (e.g. the tag
+    # is queried before the file is materialized, or while running offline).
     def self.image_name(config)
-      "yatfa-sandbox"
+      content = File.exist?(DOCKERFILE_SANDBOX) ? File.read(DOCKERFILE_SANDBOX) : nil
+      return DEFAULT_IMAGE_NAME if content.nil? || content.empty?
+
+      "yatfa-sandbox-#{Digest::SHA256.hexdigest(content)[0, 16]}"
     end
   end
 end

package/lib/yatfa_agent/docker.rb

@@ -4,22 +4,74 @@ require "fileutils"
 require "json"
 require "time"
 require_relative "http"
+require_relative "config"
 
 module YatfaAgent
   module Docker
     STAMP_FILE = ".yatfa-build-stamp"
-    VERSION_URL = "https://objectstore.fra1.civo.com/yatfa/main/version.json"
-
-    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
+    VERSION_URL = "https://pub-06ce56b9a9c143118036f593f07ac1d8.r2.dev/main/version.json"
+    DOCKERFILE_NAME = "Dockerfile.sandbox"
+
+    # Ensure a Dockerfile.sandbox is available for the build.
+    #
+    # A local ./Dockerfile.sandbox always wins (override semantics — we never
+    # silently overwrite a file the user placed). When no local file is present,
+    # we try to materialize one from the project's active
+    # `dockerfile_sandbox/default` ProjectConfig via the API, using the agent's
+    # existing API key. If neither is available, we exit with a clear, actionable
+    # error instead of a stack trace.
+    #
+    # @param config [Hash] the loaded yatfa.env.rb config (carries yatfa_url,
+    #   project_id, and the agent mcp_api_key needed to scope the request)
+    def self.check_dockerfile!(config = {})
+      return if File.exist?(DOCKERFILE_NAME)
+
+      fetched = fetch_remote_dockerfile(config)
+      if fetched
+        File.write(DOCKERFILE_NAME, fetched)
+        puts "📥 Wrote Dockerfile.sandbox from project config (dockerfile_sandbox/default)"
+        return
       end
+
+      puts "❌ Error: Dockerfile.sandbox not found"
+      puts ""
+      puts "No local Dockerfile.sandbox and no active 'dockerfile_sandbox' project config"
+      puts "was found. Provide one of:"
+      puts "  • a local ./Dockerfile.sandbox, OR"
+      puts "  • a 'dockerfile_sandbox' config in your project (Project Configurations UI / API)"
+      puts ""
+      puts "See https://github.com/RoM4iK/yatfa-public/blob/main/README.md for instructions."
+      exit 1
+    end
+
+    # Fetch the project's active dockerfile_sandbox/default config content.
+    # Returns the dockerfile content [String], or nil when the project cannot
+    # be identified, the API is unreachable, or no such config is stored.
+    # Never raises — a missing remote config is a normal "fall back to error" case.
+    def self.fetch_remote_dockerfile(config)
+      api_base = Config.api_url(config)
+      project_id = config["project_id"]
+      api_key = Config.agent_api_key(config)
+
+      return nil if api_base.nil? || api_base.to_s.empty?
+      return nil if project_id.nil? || project_id.to_s.empty?
+      return nil if api_key.nil? || api_key.to_s.empty?
+
+      url = "#{api_base}/projects/#{project_id}/configs/dockerfile_sandbox/default"
+      auth_headers = { "X-API-Key" => api_key, "Accept" => "application/json" }
+
+      data = YatfaAgent::HTTP.get(url, headers: auth_headers)
+      return nil unless data.is_a?(Hash)
+
+      content = data["content"]
+      content.nil? || content.to_s.empty? ? nil : content.to_s
+    rescue YatfaAgent::HTTP::Error => e
+      # 404 just means no dockerfile_sandbox config is stored — not an error.
+      warn "⚠️  No dockerfile_sandbox config fetched (HTTP #{e.status_code})" unless e.status_code == 404
+      nil
+    rescue StandardError => e
+      warn "⚠️  Failed to fetch dockerfile_sandbox config (#{e.class}: #{e.message})"
+      nil
     end
 
     def self.fetch_remote_version
@@ -48,7 +100,7 @@ module YatfaAgent
     end
 
     def self.build_image(config)
-      check_dockerfile!
+      check_dockerfile!(config)
 
       user_id = `id -u`.strip
       group_id = `id -g`.strip

package/lib/yatfa_agent/setup.rb

@@ -524,12 +524,12 @@ module YatfaAgent
           ARG GROUP_ID=1000
 
           # Cache busting: only rebuilds when install-agent.sh infrastructure changes
-          ADD https://objectstore.fra1.civo.com/yatfa/${YATFA_VERSION}/version.json /tmp/yatfa_version.json
+          ADD https://pub-06ce56b9a9c143118036f593f07ac1d8.r2.dev/${YATFA_VERSION}/version.json /tmp/yatfa_version.json
 
           # Install YATFA agent infrastructure
           # This layer is cached unless install-agent.sh changes (detected via version.json above)
           # setup-agent.rb, skills, and hooks download fresh on every container startup
-          RUN curl -fsSL https://objectstore.fra1.civo.com/yatfa/${YATFA_VERSION}/bin/install-agent.sh | bash
+          RUN curl -fsSL https://pub-06ce56b9a9c143118036f593f07ac1d8.r2.dev/${YATFA_VERSION}/bin/install-agent.sh | bash
 
           # Ensure /workspace is owned by agent user and writable
           # The install-agent.sh script creates a user with USER_ID, so we use that ID directly
@@ -561,10 +561,8 @@ module YatfaAgent
         puts "  1. Ensure 'yatfa.env.rb' is in .gitignore:"
         puts "     echo 'yatfa.env.rb' >> .gitignore"
         puts ""
-        puts "  2. Build the sandbox Docker image:"
-        puts "     docker build -f Dockerfile.sandbox -t yatfa-sandbox ."
-        puts ""
-        puts "  3. Start an agent:"
+        puts "  2. Start an agent (the sandbox image builds automatically on first run,"
+        puts "     tagged from your Dockerfile.sandbox):"
         if @config[:agents].key?(:worker)
           puts "     npx yatfa worker"
         elsif @config[:agents].key?(:planner)

package/lib/yatfa_agent/updater.rb

@@ -2,6 +2,8 @@
 
 require "json"
 require "time"
+require_relative "config"
+require_relative "docker"
 
 module YatfaAgent
   module Updater
@@ -130,17 +132,23 @@ module YatfaAgent
         #    Both Config.load and Docker.build_image call exit(1) on failure,
         #    which SystemExit catches here (not caught by rescue StandardError).
         puts "   Building fresh image..."
+        fresh_image = nil
         begin
           project_root = find_project_root_for_container(config)
           if project_root && Dir.exist?(project_root)
             Dir.chdir(project_root) do
               docker_config = load_config_for_container(project_root)
               Docker.build_image(docker_config)
+              # Resolve the tag while still inside the project root so the
+              # freshly built image (not the stale one baked into the old
+              # container) is used to recreate it.
+              fresh_image = Config.image_name(docker_config)
             end
           else
             puts "   ⚠️  Could not find project root, attempting build in cwd"
             docker_config = Config.load
             Docker.build_image(docker_config)
+            fresh_image = Config.image_name(docker_config)
           end
         rescue SystemExit => e
           puts "   ❌ Build failed (exit #{e.status}), keeping old container running"
@@ -154,7 +162,7 @@ module YatfaAgent
 
         # 4. Recreate container with preserved config
         puts "   Starting new container..."
-        new_cmd = build_recreate_command(name, config, new_version)
+        new_cmd = build_recreate_command(name, config, new_version, image: fresh_image)
         success = system(*new_cmd)
 
         if success
@@ -262,8 +270,10 @@ module YatfaAgent
     # @param name [String] container name
     # @param config [Hash] container inspect data
     # @param new_version [String] target infrastructure version number
+    # @param image [String, nil] freshly built image tag to run (takes
+    #   precedence over the stale image baked into the old container)
     # @return [Array<String>] docker command arguments
-    def self.build_recreate_command(name, config, new_version)
+    def self.build_recreate_command(name, config, new_version, image: nil)
       cmd = ["docker", "run", "-d", "--name", name]
 
       # Preserve restart policy
@@ -319,9 +329,11 @@ module YatfaAgent
         entrypoint_extra = entrypoint[1..]
       end
 
-      # Use the same image
-      image = config.dig("Config", "Image")
-      cmd += [image || "yatfa-sandbox"]
+      # Use the freshly built image when provided (so an update-cycle rebuild
+      # actually takes effect); otherwise preserve the container's existing
+      # image, falling back to the default tag.
+      resolved_image = image || config.dig("Config", "Image") || Config::DEFAULT_IMAGE_NAME
+      cmd += [resolved_image]
 
       # Use the original CMD (prepended with any extra entrypoint args)
       original_cmd = config.dig("Config", "Cmd")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yatfa",
-  "version": "1.0.94",
+  "version": "1.0.96",
   "description": "YATFA - Yet Another Tool For Agents",
   "bin": "./bin/run-yatfa-agent.rb",
   "files": [
@@ -16,4 +16,4 @@
   },
   "author": "",
   "license": "ISC"
-}
+}

package/setup/git_credential_helper.rb

@@ -0,0 +1,250 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Repo-aware GitHub App token credential helper for YATFA agent containers.
+#
+# Installed as /usr/local/bin/git-auth-helper and wired into git via:
+#   git config --global credential.helper  '!/usr/local/bin/git-auth-helper'
+#   git config --global credential.useHttpPath true
+#
+# Two invocation modes:
+#
+# 1. git credential helper — git invokes this as `git-auth-helper <action>`
+#    (action = get|store|erase) and feeds the credential description on stdin.
+#    With useHttpPath=true, that description includes `path=owner/repo[.git]`,
+#    which lets us mint a token scoped to THAT repository's GitHub App
+#    installation. This is required for projects spanning multiple installations
+#    (e.g. repos across different orgs): a single installation token cannot
+#    clone cross-org repos. On `get`, the full credential response
+#    (protocol/host/username/password) is printed to stdout.
+#
+# 2. token-only mode — invoked with no recognized action (e.g. by the `gh`
+#    wrapper as `$(git-auth-helper)`). Prints just the default project token.
+#
+# Tokens are cached per installation (a repo->installation index plus one cache
+# file per installation_id), so sibling repos under the same installation share
+# a single minted token and only hit the backend once per expiry window.
+#
+# This file is BOTH the standalone in-container script (run via its shebang, the
+# `if __FILE__ == $PROGRAM_NAME` guard fires) AND a require-able module for the
+# test suite (the guard does not fire when required, exposing the unit-testable
+# class methods).
+
+require "json"
+require "net/http"
+require "uri"
+require "time"
+require "fileutils"
+
+module YatfaAgent
+  module GitCredentialHelper
+    DEFAULT_CACHE_DIR = "/tmp/github-token-cache"
+    DEFAULT_HOST = "github.com"
+    DEFAULT_USERNAME = "x-access-token"
+    DEFAULT_KEY = "__default__"
+    BUFFER_SECONDS = 300 # refresh 5 minutes before the token expires
+    CREDENTIAL_ACTIONS = %w[get store erase].freeze
+
+    module_function
+
+    # Reduce a git credential `path` attribute to a normalized "owner/repo"
+    # full name, or nil when it can't be reduced to exactly owner/repo.
+    #
+    #   "RoM4iK/yatfa.git" -> "RoM4iK/yatfa"
+    #   "/yatfa-ai/router"  -> "yatfa-ai/router"
+    #   nil / "" / "info/refs" -> nil
+    def normalize_path(path)
+      return nil if path.nil?
+
+      p = path.to_s.strip
+      return nil if p.empty?
+
+      p = p.sub(/\/+\z/, "")    # trailing slashes
+      p = p.sub(/\A\/+/, "")    # leading slashes
+      p = p.sub(/\.git\z/i, "") # trailing .git
+      p = p.sub(/\A\/+/, "")    # leading slashes again (after .git strip)
+      return nil if p.empty?
+
+      owner, repo = p.split("/", 2)
+      return nil if owner.to_s.empty? || repo.to_s.empty?
+      # Reject multi-segment paths (e.g. "org/repo/extra") — not a repo root.
+      return nil if repo.include?("/")
+
+      "#{owner}/#{repo}"
+    end
+
+    # Parse git's newline-delimited `key=value` credential input into a Hash.
+    def parse_input(input)
+      attrs = {}
+      input.to_s.each_line do |line|
+        line = line.strip
+        next if line.empty?
+        key, value = line.split("=", 2)
+        attrs[key] = value if key && !key.empty?
+      end
+      attrs
+    end
+
+    # Build the backend token URL, appending `?repo=<full_name>` when scoped.
+    def build_token_url(api_url, repo)
+      base = api_url.to_s.chomp("/")
+      url = "#{base}/github/token"
+      return url if repo.nil? || repo.empty?
+      "#{url}?repo=#{URI.encode_www_form_component(repo)}"
+    end
+
+    # Default backend fetcher. Returns the parsed response Hash on HTTP 200,
+    # nil on any failure (non-2xx, network error, bad JSON). Never raises.
+    def fetch_token_data(api_url, api_key, repo)
+      uri = URI(build_token_url(api_url, repo))
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = (uri.scheme == "https")
+      http.open_timeout = 5
+      http.read_timeout = 10
+      request = Net::HTTP::Get.new(uri)
+      request["X-API-Key"] = api_key.to_s
+      request["Accept"] = "application/json"
+      response = http.request(request)
+      return nil unless response.is_a?(Net::HTTPSuccess)
+      parsed = JSON.parse(response.body)
+      parsed.is_a?(Hash) ? parsed : nil
+    rescue StandardError
+      nil
+    end
+
+    # Resolve a usable token for `repo` (or the default project token when nil),
+    # using the per-installation cache and falling back to the default token
+    # when a repo-scoped fetch fails (older backend, unregistered repo, etc.).
+    def resolve_token(repo, cache_dir:, env:, http_fetch:)
+      api_url = env["YATFA_API_URL"]
+      api_key = env["YATFA_API_KEY"]
+      return nil if api_url.nil? || api_url.to_s.empty?
+      return nil if api_key.nil? || api_key.to_s.empty?
+
+      cached = read_cached_token(repo, cache_dir)
+      return cached if cached
+
+      data = http_fetch.call(api_url, api_key, repo)
+      # Fallback: repo-scoped fetch failed -> try the default token path.
+      data = http_fetch.call(api_url, api_key, nil) if data.nil? && !repo.nil?
+      return nil if data.nil? || data["token"].nil? || data["token"].to_s.empty?
+
+      expires_at = parse_expires_at(data["expires_at"])
+      write_cached_token(repo, data["installation_id"], data["token"], expires_at, cache_dir)
+      data["token"]
+    end
+
+    # Dispatch entry point. Returns a process exit code (0 success, 1 failure).
+    def run(argv, stdin: $stdin, stdout: $stdout, stderr: $stderr,
+            cache_dir: DEFAULT_CACHE_DIR, env: nil, http_fetch: nil)
+      env_hash = env || ENV.to_h
+      fetch = http_fetch || method(:fetch_token_data)
+      action = argv.first.to_s
+
+      if CREDENTIAL_ACTIONS.include?(action)
+        if action == "get"
+          attrs = parse_input(read_stdin(stdin))
+          repo = normalize_path(attrs["path"])
+          token = resolve_token(repo, cache_dir: cache_dir, env: env_hash, http_fetch: fetch)
+          if token.nil?
+            stderr.puts("git-auth-helper: failed to obtain GitHub token" + (repo ? " for #{repo}" : ""))
+            return 1
+          end
+          stdout.puts("protocol=https")
+          stdout.puts("host=#{DEFAULT_HOST}")
+          stdout.puts("username=#{DEFAULT_USERNAME}")
+          stdout.puts("password=#{token}")
+        end
+        # store/erase: no-op — we manage our own cache, not git's credential store.
+        return 0
+      end
+
+      # Token-only mode (e.g. the `gh` wrapper): print just the default token.
+      token = resolve_token(nil, cache_dir: cache_dir, env: env_hash, http_fetch: fetch)
+      if token.nil?
+        stderr.puts("git-auth-helper: failed to obtain GitHub token")
+        return 1
+      end
+      stdout.puts(token)
+      0
+    end
+
+    # -----------------------------------------------------------------
+    # Per-installation cache (repo -> installation_id index + one file per id)
+    # -----------------------------------------------------------------
+
+    def index_path(cache_dir)
+      File.join(cache_dir, "index.json")
+    end
+
+    def read_index(cache_dir)
+      return {} unless File.exist?(index_path(cache_dir))
+      parsed = JSON.parse(File.read(index_path(cache_dir)))
+      parsed.is_a?(Hash) ? parsed : {}
+    rescue StandardError
+      {}
+    end
+
+    def write_index(cache_dir, map)
+      FileUtils.mkdir_p(cache_dir)
+      File.write(index_path(cache_dir), map.to_json)
+    rescue StandardError
+      nil
+    end
+
+    def installation_cache_path(cache_dir, installation_id)
+      return nil if installation_id.nil?
+      id = installation_id.to_s.gsub(/[^0-9a-zA-Z_-]/, "")
+      File.join(cache_dir, "inst-#{id}.json")
+    end
+
+    # Look up a non-expired cached token for `repo` (or the default token).
+    def read_cached_token(repo, cache_dir)
+      map = read_index(cache_dir)
+      inst_id = repo ? map[repo] : map[DEFAULT_KEY]
+      return nil if inst_id.nil?
+
+      path = installation_cache_path(cache_dir, inst_id)
+      return nil unless path && File.exist?(path)
+      data = JSON.parse(File.read(path))
+      return nil unless data.is_a?(Hash) && data["token"] && data["expires_at"]
+      return data["token"] if Time.parse(data["expires_at"]) > Time.now + BUFFER_SECONDS
+      nil
+    rescue StandardError
+      nil
+    end
+
+    # Persist a token keyed by installation_id, and record the repo->id mapping.
+    def write_cached_token(repo, installation_id, token, expires_at, cache_dir)
+      path = installation_cache_path(cache_dir, installation_id)
+      if path
+        FileUtils.mkdir_p(cache_dir)
+        File.write(path, { "token" => token, "expires_at" => expires_at.iso8601 }.to_json)
+      end
+      if installation_id
+        map = read_index(cache_dir)
+        map[repo || DEFAULT_KEY] = installation_id
+        write_index(cache_dir, map)
+      end
+    rescue StandardError
+      nil
+    end
+
+    def parse_expires_at(value)
+      return Time.now + 3600 - BUFFER_SECONDS if value.nil? || value.to_s.empty?
+      Time.parse(value.to_s)
+    rescue StandardError
+      Time.now + 3600 - BUFFER_SECONDS
+    end
+
+    def read_stdin(stdin)
+      stdin.read
+    rescue StandardError
+      ""
+    end
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+  exit(YatfaAgent::GitCredentialHelper.run(ARGV))
+end

package/setup/repositories.rb

@@ -54,16 +54,27 @@ def clone_repositories!
         end
       else
         puts "   ✓ #{repo_name} already exists at #{sandbox_path}"
-        # Fetch all remotes to ensure branches are up to date
+        # Fetch all remotes to ensure branches are up to date.
+        # The repo ALREADY EXISTS, so a fetch failure (transient network blip,
+        # DNS hiccup, expired creds) is NOT fatal — the agent can still work on
+        # previously-fetched code. Surface the failure honestly with a warning
+        # rather than a false "✓" (and do NOT exit, which would restart-loop).
         Dir.chdir(sandbox_path) do
-          system("git", "fetch", "--all")
-          puts "   ✓ Fetched all remotes for #{repo_name}"
+          fetch_success = system("git", "fetch", "--all")
+          if fetch_success
+            puts "   ✓ Fetched all remotes for #{repo_name}"
+          else
+            puts "   ⚠️  git fetch for #{repo_name} failed — checkout may be stale; continuing on previously-fetched state"
+          end
         end
       end
 
-      # Add repository path to git safe.directory to avoid "dubious ownership" errors
-      system("git", "config", "--global", "--add", "safe.directory", sandbox_path)
-      puts "   ✓ Added #{sandbox_path} to git safe.directory"
+      # Add repository path to git safe.directory to avoid "dubious ownership" errors.
+      # Surface a config failure honestly rather than a false "✓" (non-fatal — the
+      # repo still works, the user may just see a "dubious ownership" warning later).
+      config_success = system("git", "config", "--global", "--add", "safe.directory", sandbox_path)
+      puts config_success ? "   ✓ Added #{sandbox_path} to git safe.directory" :
+                            "   ⚠️  Failed to add #{sandbox_path} to git safe.directory (may see 'dubious ownership' errors)"
     end
 
     puts "✅ Repositories cloned"

package/setup/setup-agent.rb

@@ -45,7 +45,7 @@ require_relative "skills"
 
 SCRIPT_DIR = File.dirname(File.expand_path(__FILE__))
 YATFA_VERSION = ENV["YATFA_VERSION"] || "main"
-YATFA_SCRIPTS_BASE_URL = "https://objectstore.fra1.civo.com/yatfa"
+YATFA_SCRIPTS_BASE_URL = "https://pub-06ce56b9a9c143118036f593f07ac1d8.r2.dev"
 YATFA_RAW_URL = "#{YATFA_SCRIPTS_BASE_URL}/#{YATFA_VERSION}"
 
 # Valid agent types
@@ -244,26 +244,37 @@ def setup_claude_config!
 end
 
 def setup_git_config!
-  # Configure identity if provided
+  # Configure identity if provided.
+  # Each `git config` return value is captured and reported honestly — a failed
+  # config (read-only $HOME, full disk, restricted FS) is NOT fatal, but must
+  # NOT be hidden behind an unconditional ✅. Mirrors the repositories.rb:75-77
+  # precedent (YATFA-2842). Non-fatal: setup continues so a transient/recoverable
+  # failure does not restart-loop the container.
   if ENV["GIT_USER_NAME"] && !ENV["GIT_USER_NAME"].empty?
-    system("git", "config", "--global", "user.name", ENV["GIT_USER_NAME"])
-    puts "✅ Git user.name configured"
+    name_success = system("git", "config", "--global", "user.name", ENV["GIT_USER_NAME"])
+    puts name_success ? "✅ Git user.name configured" :
+                        "⚠️  Failed to set git user.name (later commits may fail authoring)"
   end
 
   if ENV["GIT_USER_EMAIL"] && !ENV["GIT_USER_EMAIL"].empty?
-    system("git", "config", "--global", "user.email", ENV["GIT_USER_EMAIL"])
-    puts "✅ Git user.email configured"
+    email_success = system("git", "config", "--global", "user.email", ENV["GIT_USER_EMAIL"])
+    puts email_success ? "✅ Git user.email configured" :
+                         "⚠️  Failed to set git user.email (later commits may fail authoring)"
   end
 
-  # Force HTTPS instead of SSH to ensure our token auth works
-  # This fixes "Permission denied (publickey)" when the repo uses git@github.com remote
-  system("git config --global url.\"https://github.com/\".insteadOf \"git@github.com:\"")
-  puts "✅ Git configured to force HTTPS for GitHub"
-
-  # Avoid "dubious ownership" errors in containers
-  # Note: Individual repository paths are added in clone_repositories! after cloning
-  system("git", "config", "--global", "--add", "safe.directory", Dir.pwd)
-  puts "✅ Git configured to trust #{Dir.pwd}"
+  # Force HTTPS instead of SSH to ensure our token auth works.
+  # This fixes "Permission denied (publickey)" when the repo uses git@github.com remote.
+  # If this silently fails, SSH-remote repos are NOT rewritten to HTTPS, so the
+  # HTTPS App-token auth path never engages → high impact, must be surfaced.
+  https_success = system("git config --global url.\"https://github.com/\".insteadOf \"git@github.com:\"")
+  puts https_success ? "✅ Git configured to force HTTPS for GitHub" :
+                       "⚠️  Failed to force HTTPS for GitHub (SSH-remote clones may fail with \"Permission denied (publickey)\")"
+
+  # Avoid "dubious ownership" errors in containers.
+  # Note: Individual repository paths are added in clone_repositories! after cloning.
+  safe_success = system("git", "config", "--global", "--add", "safe.directory", Dir.pwd)
+  puts safe_success ? "✅ Git configured to trust #{Dir.pwd}" :
+                      "⚠️  Failed to set git safe.directory for #{Dir.pwd} (may see 'dubious ownership' errors)"
 end
 
 

package/setup/setup-github.rb

@@ -29,98 +29,20 @@ def setup_github_auth!
   if rails_api_url && !rails_api_url.empty? && rails_api_key && !rails_api_key.empty?
     puts "🔐 Configuring GitHub App authentication (via backend)..."
 
-    # Create helper script that calls backend API
-    helper_content = <<~RUBY
-      #!/usr/bin/env ruby
-      require 'json'
-      require 'net/http'
-      require 'uri'
-      require 'time'
-
-      def get_token_from_backend
-        rails_api_url = ENV['YATFA_API_URL']
-        rails_api_key = ENV['YATFA_API_KEY']
-
-        unless rails_api_url && rails_api_key
-          STDERR.puts "❌ Error: YATFA_API_URL or YATFA_API_KEY not set"
-          exit 1
-        end
-
-        # Build GitHub token endpoint URL
-        token_url = "\#{rails_api_url.chomp('/')}/github/token"
-
-        uri = URI(token_url)
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = uri.scheme == 'https'
-        http.open_timeout = 5
-        http.read_timeout = 10
-
-        request = Net::HTTP::Get.new(uri)
-        request['X-API-Key'] = rails_api_key
-        request['Accept'] = 'application/json'
-
-        response = http.request(request)
-
-        unless response.is_a?(Net::HTTPSuccess)
-          STDERR.puts "❌ Error: Backend API returned \#{response.code} for GitHub token"
-          exit 1
-        end
-
-        data = JSON.parse(response.body)
-        token = data['token']
-
-        unless token
-          STDERR.puts "❌ Error: No token in backend response"
-          exit 1
-        end
-
-        data  # Return full response including expires_at
-      rescue Net::OpenTimeout, Net::ReadTimeout => e
-        STDERR.puts "❌ Error: Backend API timeout: \#{e.message}"
-        exit 1
-      rescue StandardError => e
-        STDERR.puts "❌ Error: \#{e.class} - \#{e.message}"
-        exit 1
-      end
-
-      def find_or_create_cached_token
-        cache_file = '/tmp/github-app-token-cache'
-        cached_token = read_cached_token(cache_file)
-        return cached_token if cached_token
-
-        token_data = get_token_from_backend
-        expires_at = token_data['expires_at'] ? Time.parse(token_data['expires_at']) : (Time.now + 3600 - 300)
-        token = token_data['token']
-
-        cache_data = {
-          token: token,
-          expires_at: expires_at.iso8601
-        }
-        File.write(cache_file, cache_data.to_json)
-        token
-      end
-
-      def read_cached_token(cache_file)
-        return nil unless File.exist?(cache_file)
-        cache = JSON.parse(File.read(cache_file))
-        return nil if cache['token'].nil? || cache['expires_at'].nil?
-        return cache['token'] if Time.parse(cache['expires_at']) > Time.now + 300
-        nil
-      rescue JSON::ParserError
-        nil
-      end
-
-      puts find_or_create_cached_token
-    RUBY
-
-    # Install helper via sudo to /usr/local/bin
+    # Install the repo-aware credential helper (setup/git_credential_helper.rb).
+    # It mints a token scoped to the requested repo's GitHub App installation,
+    # which is required for projects spanning multiple installations/orgs.
     helper_path = "/usr/local/bin/git-auth-helper"
-    File.write("/tmp/git-auth-helper", helper_content)
+    source_path = File.join(__dir__, "git_credential_helper.rb")
+    File.write("/tmp/git-auth-helper", File.read(source_path))
     system("sudo", "mv", "/tmp/git-auth-helper", helper_path)
     system("sudo", "chmod", "+x", helper_path)
 
-    # Configure git (array form avoids shell interpolation of helper path)
-    system("git", "config", "--global", "credential.helper", "!f() { test \"$1\" = get && echo \"protocol=https\" && echo \"host=github.com\" && echo \"username=x-access-token\" && p=$(#{helper_path}) && echo \"password=$p\"; }; f")
+    # Wire the helper into git. useHttpPath=true makes git send the repo path on
+    # stdin so the helper can request a repo-scoped token (?repo=owner/repo).
+    # Array form avoids shell interpolation of the helper path.
+    system("git", "config", "--global", "credential.helper", "!#{helper_path}")
+    system("git", "config", "--global", "credential.useHttpPath", "true")
 
     # Configure gh CLI wrapper for auto-refresh and permission controls
     if install_gh_wrapper!(real_gh_path: "/usr/bin/gh", with_token_refresh: true, token_helper_path: helper_path)
@@ -172,7 +94,9 @@ def install_gh_wrapper!(real_gh_path:, with_token_refresh: false, token_helper_p
 
   wrapper_path = "/usr/local/bin/gh"
 
-  # Build token export line if auto-refresh is enabled
+  # Build token export line if auto-refresh is enabled.
+  # Invoked with no args, git-auth-helper runs in token-only mode and prints the
+  # default project token (cached per installation).
   token_export = with_token_refresh ? "export GH_TOKEN=$(#{token_helper_path})\n\n" : ""
 
   wrapper_content = <<~BASH