yatfa 1.0.66 → 1.0.67

package/README.md

@@ -104,21 +104,34 @@ Launches interactive setup wizard to configure `yatfa.env.rb`.
 
 ### Run Agents
 
+When you run an agent, the CLI automatically:
+1. **Checks if the agent is already running** - prompts to Attach, Restart, or Cancel
+2. **Starts the agent** - creates the Docker container
+3. **Prompts to attach** - after starting, asks if you want to attach to the session
+
 ```bash
-# Start an agent
 npx yatfa worker
 npx yatfa planner
 npx yatfa reviewer
 npx yatfa researcher
 ```
 
-### Attach to Running Agents
+#### Non-interactive Mode (for CI/scripts)
 
 ```bash
-npx yatfa attach worker
+# Run without prompts
+npx yatfa worker --no-prompt
+# or
+YATFA_NO_PROMPT=1 npx yatfa worker
 ```
 
-Opens tmux session to view agent activity.
+### Attach to Running Agents (deprecated)
+
+The `attach` command still works but is deprecated. Running `npx yatfa <agent-type>` now prompts to attach automatically.
+
+```bash
+npx yatfa attach worker  # Deprecated - use 'npx yatfa worker' instead
+```
 
 ### List Running Agents
 
@@ -241,8 +254,10 @@ See hook files for implementation details and customization options.
 
 ## Attaching to Running Agent
 
+After starting an agent, the CLI will prompt you to attach. You can also attach directly:
+
 ```bash
-docker exec -it <container> tmux attach -t agent-wrapper
+docker exec -it <container> tmux attach -t agent
 ```
 
 Press `Ctrl+B` then `D` to detach.

package/bin/run-yatfa-agent.rb

@@ -3,7 +3,6 @@
 
 # YATFA Agent Runner (Yet Another Tool For Agents)
 # Usage: npx yatfa [worker|planner|reviewer|researcher]
-#        npx yatfa attach [agent-type]
 #        npx yatfa setup
 #
 # Requirements:
@@ -22,9 +21,12 @@ def show_usage
   puts "YATFA Agent Runner (Yet Another Tool For Agents)"
   puts ""
   puts "Usage:"
-  puts "  npx yatfa setup                    # Interactive setup wizard"
-  puts "  npx yatfa [worker|planner|reviewer|researcher]  # Run agent"
-  puts "  npx yatfa attach [agent-type]      # Attach to running agent"
+  puts "  npx yatfa setup                               # Interactive setup wizard"
+  puts "  npx yatfa [worker|planner|reviewer|researcher] # Run agent (prompts to attach)"
+  puts ""
+  puts "Options:"
+  puts "  --no-prompt, -d    Run without prompts (for CI/scripts)"
+  puts "  YATFA_NO_PROMPT=1  Environment variable alternative"
   puts ""
   puts "Setup:"
   puts "  Run 'npx yatfa setup' for interactive configuration"
@@ -49,8 +51,12 @@ if command == "setup"
   exit 0
 end
 
-# Handle attach command
+# Handle attach command (deprecated - will still work)
 if command == "attach"
+  puts ""
+  puts "⚠️  Deprecation: The 'attach' command is deprecated"
+  puts "   Running `npx yatfa <agent-type>` now prompts to attach automatically."
+  puts ""
   agent_type = ARGV[1]&.downcase
   abort "Usage: npx yatfa attach [agent-type]" unless agent_type
   config = YatfaAgent::Config.load

package/lib/yatfa_agent/agent.rb

@@ -3,6 +3,72 @@ require 'fileutils'
 
 module YatfaAgent
   module Agent
+    # Check if container is currently running
+    def self.container_running?(container_name)
+      # Use IO.popen with array arguments to avoid shell injection
+      result = IO.popen(["docker", "ps", "--filter", "name=^#{container_name}$", "--format", "{{.Names}}"], err: File::NULL, &:read).strip
+      !result.empty?
+    end
+
+    # Prompt user for input with a default value
+    def self.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 self.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 self.handle_running_container(agent_type, container_name, config, agent_configs)
+      puts "⚠️  #{agent_type} agent is already running (#{container_name})"
+      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
+
+      choice = prompt("   [A]ttach / [R]estart / [C]ancel? [A/r/c]: ", default: "A", 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
+
     def self.run(agent_type, config, agent_configs)
       unless agent_configs.keys.include?(agent_type)
         puts "❌ Unknown agent type: #{agent_type}"
@@ -14,10 +80,15 @@ module YatfaAgent
       agent_config = config.dig("agents", agent_type) || {}
       container_name = agent_config["container_name"] || agent_def[:name]
 
-      puts "🚀 Starting #{agent_type} agent..."
+      # Check if container is already running and handle interactively
+      if container_running?(container_name)
+        should_continue = handle_running_container(agent_type, container_name, config, agent_configs)
+        # If user chose Attach or Cancel, the method calls exec/exit, so we never reach here
+        # If user chose Restart, should_continue is true and we proceed to start a new container
+        return unless should_continue
+      end
 
-      # Stop existing container if running
-      system("docker", "rm", "-f", container_name, err: File::NULL, out: File::NULL)
+      puts "🚀 Starting #{agent_type} agent..."
 
       # Write banner to a persistent temp file (not auto-deleted)
       banner_path = "/tmp/yatfa-banner-#{agent_type}.txt"
@@ -47,15 +118,46 @@ module YatfaAgent
       if success
         puts "✅ Agent started in background"
         puts ""
-        puts "   Attach: npx yatfa attach #{agent_type}"
-        puts "   Logs:   docker logs -f #{container_name}"
-        puts "   Stop:   docker stop #{container_name}"
+
+        # Prompt to attach (interactive mode only)
+        prompt_to_attach(agent_type, container_name, config, agent_configs)
       else
         puts "❌ Failed to start agent"
         exit 1
       end
     end
 
+    # Prompt user to attach after starting a new agent
+    def self.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
+
     def self.attach(agent_type, config, agent_configs)
       unless agent_configs.keys.include?(agent_type)
         puts "❌ Unknown agent type: #{agent_type}"
@@ -66,7 +168,7 @@ module YatfaAgent
       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
+      running = IO.popen(["docker", "ps", "--filter", "name=^#{container_name}$", "--format", "{{.Names}}"], err: File::NULL, &:read).strip
 
       if running.empty?
         puts "⚠️  #{agent_type} agent is not running. Auto-starting..."
@@ -208,52 +310,27 @@ module YatfaAgent
 
     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
+      # Try multiple paths: relative to gem, relative to cwd
+      setup_script_paths = [
+        File.join(File.dirname(__FILE__), "..", "..", "setup-agent.rb"),  # Relative to gem
+        File.join(Dir.pwd, "tinker-public", "setup-agent.rb"),             # Running from metafolder
+        File.join(Dir.pwd, "setup-agent.rb"),                               # Running from yatfa-public
       ]
 
-      linux_bridge = nil
-      possible_paths.each do |path|
+      local_setup_script = nil
+      setup_script_paths.each do |path|
         if File.exist?(path)
-          linux_bridge = path
+          local_setup_script = 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)
+      # Mount local setup-agent.rb for development if present
+      # Binaries are always fetched from bucket by setup-agent.rb
+      if 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)

package/lib/yatfa_agent/config.rb

@@ -5,16 +5,14 @@ require "json"
 module YatfaAgent
   module Config
     def self.load
-      rb_config_file = File.join(Dir.pwd, "yatfa.env.rb")
+      config_file = File.join(Dir.pwd, "yatfa.env.rb")
 
-      unless File.exist?(rb_config_file)
+      unless File.exist?(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"
@@ -23,11 +21,11 @@ module YatfaAgent
         puts "    ENV"
         puts "  }"
         puts "  echo 'yatfa.env.rb' >> .gitignore"
-        puts "        exit 1"
+        exit 1
       end
 
       puts "⚙️  Loading configuration from yatfa.env.rb"
-      config = eval(File.read(rb_config_file), binding, rb_config_file)
+      config = eval(File.read(config_file), binding, config_file)
 
       # Convert symbols to strings for easier handling before JSON normalization
       config = config.transform_keys(&:to_s)
@@ -69,8 +67,7 @@ module YatfaAgent
     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"]
+      config["yatfa_url"] || config["rails_api_url"]
     end
 
     def self.api_url(config)

package/package.json

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