octo-agent 0.11.2

data/lib/octo/server/web_ui_controller.rb

@@ -0,0 +1,487 @@
+# frozen_string_literal: true
+
+require "json"
+require "securerandom"
+require_relative "../ui_interface"
+
+module Octo
+  module Server
+    # WebUIController implements UIInterface for the web server mode.
+    # Instead of writing to stdout, it broadcasts JSON events over WebSocket connections.
+    # Multiple browser tabs can subscribe to the same session_id.
+    #
+    # request_confirmation blocks the calling thread until the browser sends a response,
+    # mirroring the behaviour of JsonUIController (which reads from stdin).
+    class WebUIController
+      include Octo::UIInterface
+
+      attr_reader :session_id
+
+      def initialize(session_id, broadcaster)
+        @session_id  = session_id
+        @broadcaster = broadcaster   # callable: broadcaster.call(session_id, event_hash)
+        @mutex       = Mutex.new
+
+        # Pending confirmation state: { id => ConditionVariable, result => value }
+        @pending_confirmations = {}
+
+        # Channel subscribers: array of objects implementing UIInterface.
+        # All emitted events are forwarded to each subscriber after WebSocket broadcast.
+        @channel_subscribers = []
+        @subscribers_mutex   = Mutex.new
+      end
+
+      # Register a channel subscriber (e.g. ChannelUIController).
+      # The subscriber will receive every UIInterface call that this controller handles.
+      # @param subscriber [#UIInterface methods]
+      # @return [void]
+      def subscribe_channel(subscriber)
+        @subscribers_mutex.synchronize { @channel_subscribers << subscriber }
+      end
+
+      # Remove a previously registered channel subscriber.
+      # @param subscriber [Object]
+      # @return [void]
+      def unsubscribe_channel(subscriber)
+        @subscribers_mutex.synchronize { @channel_subscribers.delete(subscriber) }
+      end
+
+      # @return [Boolean] true if any channel subscribers are registered
+      def channel_subscribed?
+        @subscribers_mutex.synchronize { !@channel_subscribers.empty? }
+      end
+
+      # Deliver a confirmation answer received from the browser.
+      # Called by the HTTP server when a confirmation message arrives over WebSocket.
+      def deliver_confirmation(conf_id, result)
+        @mutex.synchronize do
+          pending = @pending_confirmations[conf_id]
+          return unless pending
+
+          pending[:result] = result
+          pending[:cond].signal
+        end
+      end
+
+      # === Output display ===
+
+      def show_user_message(content, created_at: nil, files: [], source: :web)
+        # content may be an Array (multipart: text + vision image blocks) when
+        # the user uploaded images. Extract plain text and image URLs so the
+        # frontend receives strings it can render directly.
+        images = []
+        if content.is_a?(Array)
+          text_parts = []
+          content.each do |block|
+            next unless block.is_a?(Hash)
+            case block[:type]
+            when "text"
+              text_parts << block[:text]
+            when "image_url"
+              url = block.dig(:image_url, :url)
+              images << url if url
+            end
+          end
+          content = text_parts.join("\n")
+        end
+
+        data = { content: content }
+        data[:created_at] = created_at if created_at
+        # Build ev.images for the frontend renderer (history_user_message):
+        #   - Images with data_url → pass the data_url directly (<img> thumbnail)
+        #   - Disk files (PDF, doc, etc., no data_url) → "pdf:name" sentinel (renders a badge)
+        rendered = Array(files).filter_map do |f|
+          url  = f[:data_url] || f["data_url"]
+          name = f[:name]     || f["name"]
+          url || (name ? "pdf:#{name}" : nil)
+        end
+        images.concat(rendered)
+        data[:images] = images unless images.empty?
+        emit("history_user_message", **data)
+        # Only forward to channel subscribers when the message originated from the WebUI,
+        # to avoid echoing channel messages back to the same channel.
+        return unless source == :web
+        forward_to_subscribers { |sub| sub.show_user_message(content) if sub.respond_to?(:show_user_message) }
+      end
+
+      def show_assistant_message(content, files:)
+        return if (content.nil? || content.to_s.strip.empty?) && files.empty?
+
+        # Rewrite local image paths (file:// and bare absolute) to /api/local-image
+        # proxy URLs only for the browser, which runs on http://localhost and is
+        # blocked by browser security policy from loading file:// directly.
+        # Channel subscribers receive the original content so they can deliver
+        # local images as native attachments via send_file().
+        web_content = Octo::Utils::FileProcessor.rewrite_local_image_urls(content.to_s)
+        emit("assistant_message", content: web_content, files: files)
+        forward_to_subscribers { |sub| sub.show_assistant_message(content, files: files) }
+      end
+
+      def show_tool_call(name, args)
+        args_data = args.is_a?(String) ? (JSON.parse(args) rescue args) : args
+
+        # Special handling for request_user_feedback — emit a dedicated UI event
+        if name.to_s == "request_user_feedback"
+          question = args_data.is_a?(Hash) ? (args_data[:question] || args_data["question"]).to_s : ""
+          context  = args_data.is_a?(Hash) ? (args_data[:context]  || args_data["context"]).to_s  : ""
+          options  = args_data.is_a?(Hash) ? (args_data[:options]  || args_data["options"])        : nil
+
+          # Normalize options to array (guard against malformed data)
+          options = Array(options) if options && !options.is_a?(Array)
+
+          emit("request_feedback",
+               question: question,
+               context: context,
+               options: options || [])
+          # Don't forward to IM subscribers — they get the formatted text version already
+          return
+        end
+
+        # Generate a human-readable summary using the tool's format_call method
+        summary = tool_call_summary(name, args_data)
+
+        # Remember the current in-flight tool call so replay_live_state can re-emit it
+        # when a browser tab re-subscribes after switching sessions.
+        @live_tool_call = { name: name, args: args_data, summary: summary }
+
+        emit("tool_call", name: name, args: args_data, summary: summary)
+        forward_to_subscribers { |sub| sub.show_tool_call(name, args_data) }
+      end
+
+      def show_tool_result(result, ui_payload: nil)
+        @live_tool_call = nil   # tool finished — no longer in-flight
+        emit("tool_result", result: result, ui_payload: ui_payload)
+        forward_to_subscribers { |sub| sub.show_tool_result(result) }
+      end
+
+      def show_tool_error(error)
+        error_msg = error.is_a?(Exception) ? error.message : error.to_s
+        emit("tool_error", error: error_msg)
+        forward_to_subscribers { |sub| sub.show_tool_error(error) }
+      end
+
+      def show_tool_args(formatted_args)
+        emit("tool_args", args: formatted_args)
+        forward_to_subscribers { |sub| sub.show_tool_args(formatted_args) }
+      end
+
+      def show_file_write_preview(path, is_new_file:)
+        emit("file_preview", path: path, operation: "write", is_new_file: is_new_file)
+        forward_to_subscribers { |sub| sub.show_file_write_preview(path, is_new_file: is_new_file) }
+      end
+
+      def show_file_edit_preview(path)
+        emit("file_preview", path: path, operation: "edit")
+        forward_to_subscribers { |sub| sub.show_file_edit_preview(path) }
+      end
+
+      def show_file_error(error_message)
+        emit("file_error", error: error_message)
+        forward_to_subscribers { |sub| sub.show_file_error(error_message) }
+      end
+
+      def show_shell_preview(command)
+        emit("shell_preview", command: command)
+        forward_to_subscribers { |sub| sub.show_shell_preview(command) }
+      end
+
+      def show_diff(old_content, new_content, max_lines: 50)
+        require "diffy"
+        diff = Diffy::Diff.new(old_content, new_content, context: 3).to_s
+        diff_lines = diff.lines
+        emit("diff",
+             old_size: old_content.bytesize,
+             new_size: new_content.bytesize,
+             diff: diff_lines.take(max_lines).join,
+             truncated: diff_lines.size > max_lines)
+        # Diffs are too verbose for IM — intentionally not forwarded
+      rescue LoadError
+        emit("diff", old_size: old_content.bytesize, new_size: new_content.bytesize)
+      end
+
+      def show_token_usage(token_data)
+        emit("token_usage", **token_data)
+        # Token usage is internal detail — intentionally not forwarded
+      end
+
+      def show_complete(iterations:, duration: nil, cache_stats: nil, awaiting_user_feedback: false)
+        data = { iterations: iterations }
+        data[:duration]               = duration            if duration
+        data[:cache_stats]            = cache_stats         if cache_stats
+        data[:awaiting_user_feedback] = awaiting_user_feedback if awaiting_user_feedback
+        emit("complete", **data)
+        forward_to_subscribers do |sub|
+          sub.show_complete(iterations: iterations, duration: duration,
+                            cache_stats: cache_stats, awaiting_user_feedback: awaiting_user_feedback)
+        end
+      end
+
+      def append_output(content)
+        emit("output", content: content)
+        forward_to_subscribers { |sub| sub.append_output(content) }
+      end
+
+      # === Status messages ===
+
+      def show_info(message, prefix_newline: true)
+        emit("info", message: message)
+        forward_to_subscribers { |sub| sub.show_info(message) }
+      end
+
+      def show_warning(message)
+        emit("warning", message: message)
+        forward_to_subscribers { |sub| sub.show_warning(message) }
+      end
+
+      def show_error(message)
+        emit("error", message: message)
+        forward_to_subscribers { |sub| sub.show_error(message) }
+      end
+
+      def show_success(message)
+        emit("success", message: message)
+        forward_to_subscribers { |sub| sub.show_success(message) }
+      end
+
+      def log(message, level: :info)
+        emit("log", level: level.to_s, message: message)
+        # Log forwarding intentionally skipped — too noisy for IM
+      end
+
+      # === Progress ===
+
+      def show_progress(message = nil, prefix_newline: true, progress_type: "thinking", phase: "active", metadata: {})
+        if phase == "active"
+          # Only set start time when transitioning into a fresh progress phase.
+          # Streaming LLM calls fire show_progress every chunk for token updates;
+          # resetting the timer each time would make the elapsed counter jitter
+          # back to 0 in the UI and force the frontend to rebuild its interval.
+          if @live_progress_state.nil? || @live_progress_state[:progress_type] != progress_type
+            @progress_start_time = Time.now
+            @live_stdout_buffer = []
+          end
+          @live_progress_state = {
+            message: message,
+            progress_type: progress_type,
+            metadata: metadata
+          }
+        elsif phase == "done"
+          @live_tool_call = nil   # command finished — nothing left to replay
+          # Keep @live_stdout_buffer intact — it will be reset on the next show_progress call.
+          # This allows a brief replay window even after the command finishes.
+          @live_progress_state = nil
+          @progress_start_time = nil
+        end
+        
+        data = {
+          message: message,
+          progress_type: progress_type,
+          phase: phase,
+          status: phase == "active" ? "start" : "stop"  # backward compat
+        }
+        data[:metadata] = metadata unless metadata.empty?
+        # Always include started_at for "active" phase so the frontend can set the
+        # correct timer origin even on the very first event (not just replay).
+        if phase == "active" && @progress_start_time
+          data[:started_at] = (@progress_start_time.to_f * 1000).round
+        end
+        data[:elapsed] = (Time.now - @progress_start_time).round(1) if phase == "done" && @progress_start_time
+        
+        emit("progress", **data)
+        forward_to_subscribers { |sub| sub.show_progress(message) }
+      end
+
+      # Stream shell stdout/stderr lines to the browser while a command is running.
+      # Called immediately via on_output callback from shell.rb — no polling delay.
+      # Lines are also buffered in @live_stdout_buffer so late-joining subscribers
+      # (e.g. user switches away and back) can receive a replay of what they missed.
+      def show_tool_stdout(lines)
+        return if lines.nil? || lines.empty?
+        @live_stdout_buffer ||= []
+        @live_stdout_buffer.concat(lines)
+        emit("tool_stdout", lines: lines)
+        # Not forwarded to IM subscribers — too noisy
+      end
+
+      # Replay in-progress command state to a newly (re-)subscribing browser tab.
+      # all tool_stdout lines that fired while the user was away are lost.
+      # Replay live state when a client re-subscribes (e.g. after switching sessions).
+      #
+      # Plan C: we do NOT re-emit tool_call here.
+      # The tool-item is already rendered in the DOM via the normal flow.
+      # We only replay:
+      #   1. progress(start) — restores the spinner / progress bar
+      #   2. tool_stdout     — fills in all stdout received so far
+      #
+      # The frontend's appendToolStdout will attach to the last visible .tool-item
+      # even when _liveLastToolItem is null (after the tab re-loaded).
+      def replay_live_state
+        return unless @live_progress_state
+
+        # Replay complete progress state (not just message).
+        # Include started_at (ms since epoch) so the frontend can resume the
+        # elapsed-time counter from the correct origin instead of resetting to 0.
+        state = @live_progress_state
+        started_at_ms = @progress_start_time ? (@progress_start_time.to_f * 1000).round : nil
+
+        emit("progress",
+          message: state[:message],
+          progress_type: state[:progress_type],
+          phase: "active",
+          status: "start",
+          metadata: state[:metadata] || {},
+          started_at: started_at_ms
+        )
+
+        buf = @live_stdout_buffer
+        emit("tool_stdout", lines: buf) if buf && !buf.empty?
+      end
+
+      # === State updates ===
+
+      def update_sessionbar(tasks: nil, status: nil, latency: nil)
+        data = {}
+        data[:tasks]       = tasks       if tasks
+        data[:status]      = status      if status
+        data[:latency]     = latency     if latency
+        emit("session_update", **data) unless data.empty?
+        forward_to_subscribers { |sub| sub.update_sessionbar(tasks: tasks, status: status, latency: latency) }
+      end
+
+      def update_todos(todos)
+        emit("todo_update", todos: todos)
+        forward_to_subscribers { |sub| sub.update_todos(todos) }
+      end
+
+      def update_background_tasks(running: 0, tasks: [])
+        safe_tasks = Array(tasks).map do |t|
+          cmd = (t[:command] || t["command"]).to_s
+          cmd = "#{cmd[0, 80]}…" if cmd.length > 80
+          {
+            handle_id: (t[:handle_id] || t["handle_id"]).to_s,
+            command: cmd,
+            elapsed: (t[:elapsed] || t["elapsed"]).to_i
+          }
+        end
+        emit("background_tasks_update", running: running.to_i, tasks: safe_tasks)
+      end
+
+      def show_background_task_notice(command: nil, handle_id: nil, status: "success")
+        cmd = command.to_s
+        cmd = "#{cmd[0, 60]}…" if cmd.length > 60
+        emit("background_task_notice",
+             command: cmd,
+             handle_id: handle_id.to_s,
+             status: status.to_s)
+      end
+
+      def set_working_status
+        emit("session_update", status: "working")
+        forward_to_subscribers { |sub| sub.set_working_status }
+      end
+
+      def set_idle_status
+        # Clear any in-progress state when transitioning to idle
+        if @live_progress_state
+          emit("progress", phase: "done", status: "stop")
+          @live_progress_state = nil
+          @progress_start_time = nil
+        end
+        emit("session_update", status: "idle")
+        forward_to_subscribers { |sub| sub.set_idle_status }
+      end
+
+      def update_user_message_queue_status(pending: 0)
+        emit("user_message_queue_status", pending: pending.to_i)
+      end
+
+      # === Blocking interaction ===
+      # Emits a request_confirmation event and blocks until the browser responds.
+      # Timeout after 5 minutes to avoid hanging threads forever.
+      CONFIRMATION_TIMEOUT = 300 # seconds
+
+      def request_confirmation(message, default: true)
+        conf_id = "conf_#{SecureRandom.hex(4)}"
+
+        cond    = ConditionVariable.new
+        pending = { cond: cond, result: nil }
+
+        @mutex.synchronize { @pending_confirmations[conf_id] = pending }
+
+        emit("request_confirmation", id: conf_id, message: message, default: default)
+
+        # Notify channel subscribers that confirmation is pending — non-blocking.
+        # They display a notice; the actual decision comes from the Web UI user.
+        forward_to_subscribers { |sub| sub.show_warning("⏳ Confirmation requested: #{message}") }
+
+        # Block until browser replies or timeout
+        @mutex.synchronize do
+          cond.wait(@mutex, CONFIRMATION_TIMEOUT)
+          @pending_confirmations.delete(conf_id)
+          result = pending[:result]
+
+          # Timed out — use default
+          return default if result.nil?
+
+          case result.to_s.downcase
+          when "yes", "y" then true
+          when "no",  "n" then false
+          else result.to_s
+          end
+        end
+      end
+
+      # === Input control (no-ops in web mode) ===
+
+      def clear_input; end
+      def set_input_tips(message, type: :info); end
+
+      # Predicted next-user-message ghost text. Web renders as placeholder +
+      # Tab-to-accept. Channel subscribers (Feishu/WeCom) intentionally do
+      # not forward — there's no input box to ghost-text into.
+      def show_next_message_suggestion(text)
+        emit("next_message_suggestion", text: text.to_s)
+      end
+
+      # === Lifecycle ===
+
+      def stop
+        emit("server_stop")
+      end
+
+
+      # Generate a short human-readable summary for a tool call display.
+      # Delegates to each tool's own format_call method when available.
+      def tool_call_summary(name, args)
+        class_name = name.to_s.split("_").map(&:capitalize).join
+        return nil unless Octo::Tools.const_defined?(class_name)
+
+        tool = Octo::Tools.const_get(class_name).new
+        args_sym = args.is_a?(Hash) ? args.transform_keys(&:to_sym) : {}
+        tool.format_call(args_sym)
+      rescue StandardError
+        nil
+      end
+
+      def emit(type, **data)
+        event = { type: type, session_id: @session_id }.merge(data)
+        @broadcaster.call(@session_id, event)
+      end
+
+      # Forward a UIInterface call to all registered channel subscribers.
+      # Each subscriber is called in the same thread as the caller (Agent thread).
+      # Errors in individual subscribers are rescued and logged so they never
+      # interrupt the main agent execution.
+      def forward_to_subscribers(&block)
+        subscribers = @subscribers_mutex.synchronize { @channel_subscribers.dup }
+        return if subscribers.empty?
+
+        subscribers.each do |sub|
+          block.call(sub)
+        rescue StandardError => e
+          Octo::Logger.error("[WebUIController] channel subscriber error", error: e)
+        end
+      end
+    end
+  end
+end