binocs 0.1.0

data/lib/binocs/agent.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'shellwords'
+
+module Binocs
+  class Agent
+    STATUSES = %i[pending running completed failed stopped].freeze
+    TOOLS = %i[claude_code opencode].freeze
+
+    attr_accessor :id, :status, :tool, :worktree_path, :pid, :request_id,
+                  :prompt, :created_at, :output_file, :branch_name,
+                  :request_context, :exit_code
+
+    @@agents = []
+    @@mutex = Mutex.new
+
+    def initialize(attrs = {})
+      @id = attrs[:id] || SecureRandom.uuid[0, 8]
+      @status = attrs[:status] || :pending
+      @tool = attrs[:tool] || Binocs.configuration.agent_tool
+      @worktree_path = attrs[:worktree_path]
+      @pid = attrs[:pid]
+      @request_id = attrs[:request_id]
+      @prompt = attrs[:prompt]
+      @created_at = attrs[:created_at] || Time.now
+      @output_file = attrs[:output_file]
+      @branch_name = attrs[:branch_name]
+      @request_context = attrs[:request_context]
+      @exit_code = nil
+    end
+
+    def running?
+      @status == :running && @pid && process_alive?
+    end
+
+    def completed?
+      @status == :completed
+    end
+
+    def failed?
+      @status == :failed
+    end
+
+    def stopped?
+      @status == :stopped
+    end
+
+    def process_alive?
+      return false unless @pid
+
+      Process.kill(0, @pid)
+      true
+    rescue Errno::ESRCH, Errno::EPERM
+      false
+    end
+
+    def stop!
+      return unless running?
+
+      begin
+        Process.kill('TERM', @pid)
+        sleep 0.5
+        Process.kill('KILL', @pid) if process_alive?
+      rescue Errno::ESRCH, Errno::EPERM
+        # Process already dead
+      end
+
+      @status = :stopped
+    end
+
+    def output
+      return '' unless @output_file && File.exist?(@output_file)
+
+      File.read(@output_file)
+    end
+
+    def output_tail(lines = 50)
+      return '' unless @output_file && File.exist?(@output_file)
+
+      `tail -n #{lines} #{@output_file.shellescape}`.strip
+    end
+
+    def duration
+      return nil unless @created_at
+
+      elapsed = Time.now - @created_at
+      if elapsed < 60
+        "#{elapsed.to_i}s"
+      elsif elapsed < 3600
+        "#{(elapsed / 60).to_i}m"
+      else
+        "#{(elapsed / 3600).to_i}h #{((elapsed % 3600) / 60).to_i}m"
+      end
+    end
+
+    def tool_command
+      case @tool
+      when :claude_code then 'claude'
+      when :opencode then 'opencode'
+      else 'claude'
+      end
+    end
+
+    def short_prompt(max_length = 50)
+      return '' unless @prompt
+
+      @prompt.length > max_length ? "#{@prompt[0, max_length - 3]}..." : @prompt
+    end
+
+    # Class methods for agent registry
+    class << self
+      def all
+        @@mutex.synchronize { @@agents.dup }
+      end
+
+      def running
+        all.select(&:running?)
+      end
+
+      def find(id)
+        @@mutex.synchronize { @@agents.find { |a| a.id == id } }
+      end
+
+      def add(agent)
+        @@mutex.synchronize { @@agents << agent }
+        agent
+      end
+
+      def remove(agent)
+        @@mutex.synchronize { @@agents.delete(agent) }
+      end
+
+      def for_request(request_id)
+        all.select { |a| a.request_id == request_id }
+      end
+
+      def count
+        @@mutex.synchronize { @@agents.length }
+      end
+
+      def running_count
+        running.length
+      end
+
+      def clear_completed
+        @@mutex.synchronize do
+          @@agents.reject! { |a| a.completed? || a.failed? || a.stopped? }
+        end
+      end
+    end
+  end
+end

data/lib/binocs/agent_context.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Binocs
+  class AgentContext
+    class << self
+      def build(request)
+        sections = []
+
+        sections << build_overview(request)
+        sections << build_params(request)
+        sections << build_headers(request)
+        sections << build_body(request)
+        sections << build_response(request)
+        sections << build_logs(request)
+        sections << build_exception(request)
+
+        sections.compact.join("\n\n")
+      end
+
+      private
+
+      def build_overview(request)
+        # Use read_attribute for 'method' to avoid conflict with Object#method
+        http_method = request.respond_to?(:read_attribute) ? request.read_attribute(:method) : request.method
+        <<~SECTION
+          ## Request Overview
+
+          - **Method**: #{http_method || 'N/A'}
+          - **Path**: #{request.path || 'N/A'}
+          - **Full URL**: #{request.try(:full_url) || 'N/A'}
+          - **Controller**: #{request.controller_name || 'N/A'}
+          - **Action**: #{request.action_name || 'N/A'}
+          - **Status Code**: #{request.status_code || 'N/A'}
+          - **Duration**: #{request.try(:formatted_duration) || 'N/A'}
+          - **IP Address**: #{request.ip_address || 'N/A'}
+          - **Timestamp**: #{request.created_at&.iso8601 || 'N/A'}
+        SECTION
+      end
+
+      def build_params(request)
+        params = request.params
+        return nil if params.blank?
+
+        <<~SECTION
+          ## Request Parameters
+
+          ```json
+          #{JSON.pretty_generate(params)}
+          ```
+        SECTION
+      end
+
+      def build_headers(request)
+        sections = []
+
+        req_headers = request.request_headers
+        if req_headers.present?
+          sections << <<~SECTION
+            ## Request Headers
+
+            ```json
+            #{JSON.pretty_generate(req_headers)}
+            ```
+          SECTION
+        end
+
+        res_headers = request.response_headers
+        if res_headers.present?
+          sections << <<~SECTION
+            ## Response Headers
+
+            ```json
+            #{JSON.pretty_generate(res_headers)}
+            ```
+          SECTION
+        end
+
+        sections.any? ? sections.join("\n\n") : nil
+      end
+
+      def build_body(request)
+        body = request.request_body
+        return nil if body.blank?
+
+        formatted_body = format_body(body)
+
+        <<~SECTION
+          ## Request Body
+
+          ```
+          #{formatted_body}
+          ```
+        SECTION
+      end
+
+      def build_response(request)
+        body = request.response_body
+        return nil if body.blank?
+
+        formatted_body = format_body(body)
+
+        <<~SECTION
+          ## Response Body
+
+          ```
+          #{formatted_body}
+          ```
+        SECTION
+      end
+
+      def build_logs(request)
+        logs = request.logs
+        return nil if logs.blank?
+
+        log_lines = logs.map do |log|
+          case log['type']
+          when 'controller'
+            "[#{log['timestamp']}] #{log['controller']}##{log['action']} - #{log['duration']}ms"
+          when 'redirect'
+            "[#{log['timestamp']}] Redirect to #{log['location']} (#{log['status']})"
+          else
+            "[#{log['timestamp']}] #{log['type']}: #{log.except('timestamp', 'type').to_json}"
+          end
+        end
+
+        <<~SECTION
+          ## Request Logs
+
+          ```
+          #{log_lines.join("\n")}
+          ```
+        SECTION
+      end
+
+      def build_exception(request)
+        exc = request.exception
+        return nil if exc.blank?
+
+        backtrace = exc['backtrace']&.first(15)&.join("\n") || 'No backtrace'
+
+        <<~SECTION
+          ## Exception
+
+          - **Class**: #{exc['class']}
+          - **Message**: #{exc['message']}
+
+          ### Backtrace
+
+          ```
+          #{backtrace}
+          ```
+        SECTION
+      end
+
+      def format_body(body)
+        # Try to pretty-print JSON
+        JSON.pretty_generate(JSON.parse(body))
+      rescue JSON::ParserError
+        body
+      end
+    end
+  end
+end

data/lib/binocs/agent_manager.rb

@@ -0,0 +1,302 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'shellwords'
+require 'open3'
+
+module Binocs
+  class AgentManager
+    class << self
+      def launch(request:, prompt:, tool: nil, branch_name: nil, use_worktree: false)
+        tool ||= Binocs.configuration.agent_tool
+
+        # Create agent record
+        agent = Agent.new(
+          request_id: request.id,
+          prompt: prompt,
+          tool: tool,
+          request_context: AgentContext.build(request)
+        )
+
+        # Set up output file path early so we can log to it
+        base_dir = worktree_base_path
+        FileUtils.mkdir_p(base_dir)
+
+        # Generate a name for logs
+        timestamp = Time.now.strftime('%m%d-%H%M%S')
+        prompt_slug = generate_slug(agent.prompt)
+        log_name = "#{timestamp}-#{prompt_slug}"
+        agent.output_file = File.join(base_dir, "#{log_name}.log")
+
+        # Start logging
+        log_to_agent(agent, "=" * 60)
+        log_to_agent(agent, "Binocs Agent Started")
+        log_to_agent(agent, "Time: #{Time.now}")
+        log_to_agent(agent, "Tool: #{agent.tool}")
+        log_to_agent(agent, "Mode: #{use_worktree ? 'New Worktree' : 'Current Branch'}")
+        log_to_agent(agent, "=" * 60)
+        log_to_agent(agent, "")
+
+        if use_worktree
+          # Create worktree for isolated work
+          worktree_name = branch_name && !branch_name.empty? ? branch_name : log_name
+          log_to_agent(agent, "[#{Time.now.strftime('%H:%M:%S')}] Creating git worktree...")
+          worktree_path, branch_name = create_worktree(agent, worktree_name)
+          agent.worktree_path = worktree_path
+          agent.branch_name = branch_name
+          log_to_agent(agent, "[#{Time.now.strftime('%H:%M:%S')}] Worktree created: #{worktree_path}")
+          log_to_agent(agent, "[#{Time.now.strftime('%H:%M:%S')}] Branch: #{branch_name}")
+          log_to_agent(agent, "")
+
+          # Write context file for the agent
+          context_file = File.join(worktree_path, '.binocs-context.md')
+          File.write(context_file, agent.request_context)
+          log_to_agent(agent, "[#{Time.now.strftime('%H:%M:%S')}] Context file written: .binocs-context.md")
+        else
+          # Run in current directory on current branch
+          agent.worktree_path = find_git_root
+          agent.branch_name = current_branch_name
+          log_to_agent(agent, "[#{Time.now.strftime('%H:%M:%S')}] Running on current branch: #{agent.branch_name}")
+          log_to_agent(agent, "[#{Time.now.strftime('%H:%M:%S')}] Directory: #{agent.worktree_path}")
+          log_to_agent(agent, "")
+
+          # Write context file in current directory
+          context_file = File.join(agent.worktree_path, '.binocs-context.md')
+          File.write(context_file, agent.request_context)
+          log_to_agent(agent, "[#{Time.now.strftime('%H:%M:%S')}] Context file written: .binocs-context.md")
+        end
+
+        # Register agent
+        Agent.add(agent)
+
+        # Spawn the process
+        log_to_agent(agent, "[#{Time.now.strftime('%H:%M:%S')}] Starting #{agent.tool_command}...")
+        log_to_agent(agent, "")
+        log_to_agent(agent, "-" * 60)
+        log_to_agent(agent, "Agent Output:")
+        log_to_agent(agent, "-" * 60)
+        log_to_agent(agent, "")
+        spawn_agent(agent)
+
+        agent
+      end
+
+      def continue_session(agent:, prompt:, tool: nil)
+        tool ||= agent.tool
+
+        # Update agent for new session
+        agent.prompt = prompt
+        agent.tool = tool
+        agent.status = :pending
+        agent.created_at = Time.now
+
+        # Log continuation
+        log_to_agent(agent, "")
+        log_to_agent(agent, "=" * 60)
+        log_to_agent(agent, "Continuing Session")
+        log_to_agent(agent, "Time: #{Time.now}")
+        log_to_agent(agent, "Tool: #{tool}")
+        log_to_agent(agent, "=" * 60)
+        log_to_agent(agent, "")
+
+        log_to_agent(agent, "[#{Time.now.strftime('%H:%M:%S')}] Continuing in: #{agent.worktree_path}")
+        log_to_agent(agent, "[#{Time.now.strftime('%H:%M:%S')}] New prompt: #{prompt[0, 50]}...")
+        log_to_agent(agent, "")
+
+        # Spawn the process in the same directory
+        log_to_agent(agent, "[#{Time.now.strftime('%H:%M:%S')}] Starting #{agent.tool_command}...")
+        log_to_agent(agent, "")
+        log_to_agent(agent, "-" * 60)
+        log_to_agent(agent, "Agent Output:")
+        log_to_agent(agent, "-" * 60)
+        log_to_agent(agent, "")
+        spawn_agent(agent)
+
+        agent
+      end
+
+      def log_to_agent(agent, message)
+        return unless agent.output_file
+        File.open(agent.output_file, 'a') { |f| f.puts(message) }
+      end
+
+      def create_worktree(agent, worktree_name)
+        base_dir = worktree_base_path
+        worktree_path = File.join(base_dir, worktree_name)
+        branch_name = "agent/#{worktree_name}"
+
+        # Get current repo root
+        repo_root = find_git_root
+
+        # Create the worktree with a new branch, capturing output
+        Dir.chdir(repo_root) do
+          output = `git worktree add -b #{branch_name.shellescape} #{worktree_path.shellescape} HEAD 2>&1`
+          unless $?.success?
+            log_to_agent(agent, "[ERROR] Git worktree creation failed:")
+            log_to_agent(agent, output)
+            raise "Failed to create git worktree at #{worktree_path}: #{output}"
+          end
+          log_to_agent(agent, output) unless output.strip.empty?
+        end
+
+        [worktree_path, branch_name]
+      end
+
+      def generate_slug(prompt)
+        return 'task' if prompt.nil? || prompt.empty?
+
+        # Take first few words, remove special chars, join with dashes
+        words = prompt.downcase.gsub(/[^a-z0-9\s]/, '').split.first(4)
+        slug = words.join('-')
+        slug = slug[0, 25] if slug.length > 25
+        slug.empty? ? 'task' : slug
+      end
+
+      def spawn_agent(agent)
+        return unless agent.worktree_path && Dir.exist?(agent.worktree_path)
+
+        # Build the full prompt including context
+        full_prompt = build_full_prompt(agent)
+
+        # Create a prompt file for the agent to read
+        prompt_file = File.join(agent.worktree_path, '.binocs-prompt.md')
+        File.write(prompt_file, full_prompt)
+
+        # Build command arguments based on tool
+        cmd_args = build_agent_command_args(agent, prompt_file)
+
+        # Spawn the process
+        pid = Process.spawn(
+          *cmd_args,
+          chdir: agent.worktree_path,
+          out: [agent.output_file, 'a'],
+          err: [agent.output_file, 'a'],
+          pgroup: true
+        )
+
+        Process.detach(pid)
+
+        agent.pid = pid
+        agent.status = :running
+
+        # Start a monitor thread
+        start_monitor_thread(agent)
+      end
+
+      def cleanup(agent)
+        # Stop the process if running
+        agent.stop! if agent.running?
+
+        # Remove the worktree
+        if agent.worktree_path && Dir.exist?(agent.worktree_path)
+          repo_root = find_git_root
+
+          Dir.chdir(repo_root) do
+            system("git worktree remove #{agent.worktree_path.shellescape} --force",
+                   out: File::NULL, err: File::NULL)
+          end
+
+          # Also delete the branch if it exists
+          if agent.branch_name
+            Dir.chdir(repo_root) do
+              system("git branch -D #{agent.branch_name.shellescape}",
+                     out: File::NULL, err: File::NULL)
+            end
+          end
+        end
+
+        # Remove from registry
+        Agent.remove(agent)
+      end
+
+      def open_worktree(agent)
+        return unless agent.worktree_path && Dir.exist?(agent.worktree_path)
+
+        # Open in file manager
+        if RbConfig::CONFIG['host_os'] =~ /darwin/
+          system("open", agent.worktree_path)
+        elsif RbConfig::CONFIG['host_os'] =~ /linux/
+          system("xdg-open", agent.worktree_path)
+        end
+      end
+
+      private
+
+      def worktree_base_path
+        base = Binocs.configuration.agent_worktree_base
+        if base.start_with?('/')
+          base
+        else
+          File.expand_path(base, find_git_root)
+        end
+      end
+
+      def find_git_root
+        dir = Dir.pwd
+        while dir != '/'
+          return dir if File.exist?(File.join(dir, '.git'))
+
+          dir = File.dirname(dir)
+        end
+        Dir.pwd
+      end
+
+      def current_branch_name
+        Dir.chdir(find_git_root) do
+          `git rev-parse --abbrev-ref HEAD`.strip
+        end
+      rescue
+        'unknown'
+      end
+
+      def build_full_prompt(agent)
+        <<~PROMPT
+          # Request Context
+
+          The following is context from an HTTP request that was captured by Binocs.
+          Use this information to understand the issue and implement a fix.
+
+          #{agent.request_context}
+
+          ---
+
+          # Task
+
+          #{agent.prompt}
+
+          ---
+
+          Note: The request context is also saved in `.binocs-context.md` for reference.
+        PROMPT
+      end
+
+      def build_agent_command_args(agent, prompt_file)
+        prompt_content = File.read(prompt_file)
+
+        case agent.tool
+        when :claude_code
+          # Claude Code: use -p for prompt, --dangerously-skip-permissions for autonomous mode
+          [agent.tool_command, '-p', prompt_content, '--dangerously-skip-permissions']
+        when :opencode
+          # OpenCode - run with prompt flag
+          [agent.tool_command, '-p', prompt_content]
+        else
+          [agent.tool_command, '-p', prompt_content]
+        end
+      end
+
+      def start_monitor_thread(agent)
+        Thread.new do
+          begin
+            Process.wait(agent.pid)
+            agent.exit_code = $?.exitstatus
+            agent.status = agent.exit_code == 0 ? :completed : :failed
+          rescue Errno::ECHILD
+            # Process already reaped
+            agent.status = :completed unless agent.status == :stopped
+          end
+        end
+      end
+    end
+  end
+end

data/lib/binocs/configuration.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Binocs
+  class Configuration
+    attr_accessor :enabled,
+                  :retention_period,
+                  :max_body_size,
+                  :ignored_paths,
+                  :ignored_content_types,
+                  :basic_auth_username,
+                  :basic_auth_password,
+                  :max_requests,
+                  :record_request_body,
+                  :record_response_body,
+                  :swagger_spec_url,
+                  :swagger_ui_url,
+                  :agent_tool,
+                  :agent_worktree_base,
+                  :login_path,
+                  :authentication_method
+
+    def initialize
+      @enabled = true
+      @retention_period = 24.hours
+      @max_body_size = 64.kilobytes
+      @ignored_paths = %w[/assets /packs /binocs /cable]
+      @ignored_content_types = %w[image/ video/ audio/ font/]
+      @basic_auth_username = nil
+      @basic_auth_password = nil
+      @max_requests = 1000
+      @record_request_body = true
+      @record_response_body = true
+      @swagger_spec_url = '/api-docs'
+      @swagger_ui_url = '/api-docs/index.html'
+      @agent_tool = :claude_code
+      @agent_worktree_base = '../binocs-agents'
+      @login_path = nil  # Auto-detected from Devise if available, or set manually
+      @authentication_method = nil  # e.g., :authenticate_user! or a Proc
+    end
+
+    def basic_auth_enabled?
+      basic_auth_username.present? && basic_auth_password.present?
+    end
+
+    def swagger_enabled?
+      swagger_spec_url.present?
+    end
+
+    def resolved_login_path
+      return @login_path if @login_path.present?
+
+      # Try to auto-detect Devise login path
+      if defined?(Devise) && defined?(Rails.application.routes)
+        begin
+          Rails.application.routes.url_helpers.new_user_session_path
+        rescue NoMethodError
+          # Devise might use a different scope
+          '/users/sign_in'
+        end
+      else
+        '/login'
+      end
+    end
+  end
+end