discourse-systray 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 342570ecbf8771500b6be8dd6deba05ceb429b4465746c3fa2fc822dedbff311
-  data.tar.gz: c6a5dbc3ab88a256c2d9f5a9bda9def61ce26ec46a32280e4a81c144335f1017
+  metadata.gz: 5210b401c239734ab826f42710f3d925e65e52d62b9a5f8b3da18d56b874469b
+  data.tar.gz: 838fac902e2cad6158ea5c5f52086047f4687b5871e1ce5c4b4989203d6e3eda
 SHA512:
-  metadata.gz: 183b3a72d39b1f6525d7a2ce533829349709192f8da6ede5d53ae231441a3064e37e04eaa94050ed3e63327784184c9b004049521c7a79fc6f2db688618aec96
-  data.tar.gz: 5c803012c9fdcaeea04465e8803e66f3531cec3c3487616256e24ede3b28d4e2a0e3a3e59c583fdb9a1a1618d411de98297b43b77ed7abd2c664e2a4a2e648de
+  metadata.gz: a4694037048949cbb48696ff280327b1d1f6f6349685de9e8a55fcfc81f27326e4812e526c0976c7615a0d0076543139c158744cd451841503b32f70d0963597
+  data.tar.gz: 7193b7995de0c0ff81ca6224c12d478b916bb3972ec896a4266cfbf7a12dc1881091f9cc28c434d3fc65f190e0902e031dbcca6bb66ff705cd92f7891a53e766

data/bin/discourse-systray

@@ -3,4 +3,4 @@
 
 require "discourse_systray/systray"
 
-DiscourseSystemTray.new.run
+DiscourseSystray::Systray.run

data/lib/discourse_systray/systray.rb

@@ -5,503 +5,714 @@ require "timeout"
 require "fileutils"
 require "json"
 
-# Parse command line options
-OPTIONS = { debug: false, path: nil }
-
-OptionParser
-  .new do |opts|
-    opts.banner = "Usage: systray.rb [options]"
-    opts.on("--debug", "Enable debug mode") { OPTIONS[:debug] = true }
-    opts.on("--path PATH", "Set Discourse path") { |p| OPTIONS[:path] = p }
-  end
-  .parse!
+module ::DiscourseSystray
+  class Systray
+    CONFIG_DIR = File.expand_path("~/.config/discourse-systray")
+    CONFIG_FILE = File.join(CONFIG_DIR, "config.json")
+    OPTIONS = { debug: false, path: nil }
+
+    def self.load_or_prompt_config
+      OptionParser
+        .new do |opts|
+          opts.banner = "Usage: systray.rb [options]"
+          opts.on("--debug", "Enable debug mode") { OPTIONS[:debug] = true }
+          opts.on("--path PATH", "Set Discourse path") do |p|
+            OPTIONS[:path] = p
+          end
+          opts.on("--console", "Enable console mode") do
+            OPTIONS[:console] = true
+          end
+          opts.on("--attach", "Attach to existing systray") do
+            OPTIONS[:attach] = true
+          end
+        end
+        .parse!
+      FileUtils.mkdir_p(CONFIG_DIR) unless Dir.exist?(CONFIG_DIR)
 
-class DiscourseSystemTray
-  CONFIG_DIR = File.expand_path("~/.config/discourse-systray")
-  CONFIG_FILE = File.join(CONFIG_DIR, "config.json")
+      if OPTIONS[:path]
+        save_config(path: OPTIONS[:path])
+        return OPTIONS[:path]
+      end
 
-  def self.load_or_prompt_config
-    FileUtils.mkdir_p(CONFIG_DIR) unless Dir.exist?(CONFIG_DIR)
+      if File.exist?(CONFIG_FILE)
+        config = JSON.parse(File.read(CONFIG_FILE))
+        return config["path"] if config["path"] && Dir.exist?(config["path"])
+      end
 
-    if OPTIONS[:path]
-      save_config(path: OPTIONS[:path])
-      return OPTIONS[:path]
-    end
+      # Show dialog to get path
+      dialog =
+        Gtk::FileChooserDialog.new(
+          title: "Select Discourse Directory",
+          parent: nil,
+          action: :select_folder,
+          buttons: [["Cancel", :cancel], ["Select", :accept]]
+        )
+
+      path = nil
+      if dialog.run == :accept
+        path = dialog.filename
+        save_config(path: path)
+      else
+        puts "No Discourse path specified. Exiting."
+        exit 1
+      end
 
-    if File.exist?(CONFIG_FILE)
-      config = JSON.parse(File.read(CONFIG_FILE))
-      return config["path"] if config["path"] && Dir.exist?(config["path"])
+      dialog.destroy
+      path
     end
 
-    # Show dialog to get path
-    dialog =
-      Gtk::FileChooserDialog.new(
-        title: "Select Discourse Directory",
-        parent: nil,
-        action: :select_folder,
-        buttons: [["Cancel", :cancel], ["Select", :accept]]
-      )
+    def self.save_config(path:, window_geometry: nil)
+      config = { path: path }
+      config[:window_geometry] = window_geometry if window_geometry
+      File.write(CONFIG_FILE, JSON.generate(config))
+      nil # Prevent return value from being printed
+    end
 
-    path = nil
-    if dialog.run == :accept
-      path = dialog.filename
-      save_config(path: path)
-    else
-      puts "No Discourse path specified. Exiting."
-      exit 1
+    def self.load_config
+      return {} unless File.exist?(CONFIG_FILE)
+      JSON.parse(File.read(CONFIG_FILE))
+    rescue JSON::ParserError
+      {}
+    end
+    BUFFER_SIZE = 2000
+
+    def initialize
+      @discourse_path = self.class.load_or_prompt_config unless OPTIONS[:attach]
+      @running = false
+      @ember_output = []
+      @unicorn_output = []
+      @processes = {}
+      @ember_running = false
+      @unicorn_running = false
+      @ember_line_count = 0
+      @unicorn_line_count = 0
+      @status_window = nil
     end
 
-    dialog.destroy
-    path
-  end
+    def init_systray
+      @indicator = Gtk::StatusIcon.new
+      @indicator.pixbuf =
+        GdkPixbuf::Pixbuf.new(
+          file: File.join(File.dirname(__FILE__), "../../assets/discourse.png")
+        )
+      @indicator.tooltip_text = "Discourse Manager"
+
+      @indicator.signal_connect("popup-menu") do |tray, button, time|
+        menu = Gtk::Menu.new
+
+        # Create menu items with icons
+        start_item = Gtk::ImageMenuItem.new(label: "Start Discourse")
+        start_item.image =
+          Gtk::Image.new(icon_name: "media-playback-start", size: :menu)
+
+        stop_item = Gtk::ImageMenuItem.new(label: "Stop Discourse")
+        stop_item.image =
+          Gtk::Image.new(icon_name: "media-playback-stop", size: :menu)
+
+        status_item = Gtk::ImageMenuItem.new(label: "Show Status")
+        status_item.image =
+          Gtk::Image.new(icon_name: "utilities-system-monitor", size: :menu)
+
+        quit_item = Gtk::ImageMenuItem.new(label: "Quit")
+        quit_item.image =
+          Gtk::Image.new(icon_name: "application-exit", size: :menu)
+
+        # Add items in new order
+        menu.append(start_item)
+        menu.append(stop_item)
+        menu.append(Gtk::SeparatorMenuItem.new)
+        menu.append(status_item)
+        menu.append(Gtk::SeparatorMenuItem.new)
+        menu.append(quit_item)
+
+        start_item.signal_connect("activate") do
+          set_icon(:running)
+          start_discourse
+          @running = true
+        end
 
-  def self.save_config(path:, window_geometry: nil)
-    config = { path: path }
-    config[:window_geometry] = window_geometry if window_geometry
-    File.write(CONFIG_FILE, JSON.generate(config))
-    nil # Prevent return value from being printed
-  end
+        stop_item.signal_connect("activate") do
+          set_icon(:stopped)
+          stop_discourse
+          @running = false
+        end
 
-  def self.load_config
-    return {} unless File.exist?(CONFIG_FILE)
-    JSON.parse(File.read(CONFIG_FILE))
-  rescue JSON::ParserError
-    {}
-  end
-  BUFFER_SIZE = 2000
-
-  def initialize
-    @discourse_path = self.class.load_or_prompt_config
-    @indicator = Gtk::StatusIcon.new
-    @indicator.pixbuf = GdkPixbuf::Pixbuf.new(file: File.join(File.dirname(__FILE__), "../../assets/discourse.png"))
-    @indicator.tooltip_text = "Discourse Manager"
-    @running = false
-    @ember_output = []
-    @unicorn_output = []
-    @processes = {}
-    @ember_running = false
-    @unicorn_running = false
-    @status_window = nil
-
-    # Create right-click menu
-    @indicator.signal_connect("popup-menu") do |tray, button, time|
-      menu = Gtk::Menu.new
-
-      # Create menu items with icons
-      start_item = Gtk::ImageMenuItem.new(label: "Start Discourse")
-      start_item.image =
-        Gtk::Image.new(icon_name: "media-playback-start", size: :menu)
-
-      stop_item = Gtk::ImageMenuItem.new(label: "Stop Discourse")
-      stop_item.image =
-        Gtk::Image.new(icon_name: "media-playback-stop", size: :menu)
-
-      status_item = Gtk::ImageMenuItem.new(label: "Show Status")
-      status_item.image =
-        Gtk::Image.new(icon_name: "utilities-system-monitor", size: :menu)
-
-      quit_item = Gtk::ImageMenuItem.new(label: "Quit")
-      quit_item.image =
-        Gtk::Image.new(icon_name: "application-exit", size: :menu)
-
-      # Add items in new order
-      menu.append(start_item)
-      menu.append(stop_item)
-      menu.append(Gtk::SeparatorMenuItem.new)
-      menu.append(status_item)
-      menu.append(Gtk::SeparatorMenuItem.new)
-      menu.append(quit_item)
-
-      start_item.signal_connect("activate") do
-        set_icon(:running)
-        start_discourse
-        @running = true
-      end
+        quit_item.signal_connect("activate") do
+          cleanup
+          Gtk.main_quit
+        end
 
-      stop_item.signal_connect("activate") do
-        set_icon(:stopped)
-        stop_discourse
-        @running = false
-      end
+        status_item.signal_connect("activate") { show_status_window }
+
+        menu.show_all
 
-      quit_item.signal_connect("activate") do
-        cleanup
-        Gtk.main_quit
+        # Show/hide items based on running state - AFTER show_all
+        start_item.visible = !@running
+        stop_item.visible = @running
+        menu.popup(nil, nil, button, time)
       end
+    end
 
-      status_item.signal_connect("activate") { show_status_window }
+    def start_discourse
+      @ember_output.clear
+      @unicorn_output.clear
 
-      menu.show_all
+      Dir.chdir(@discourse_path) do
+        @processes[:ember] = start_process("bin/ember-cli")
+        @ember_running = true
+        @processes[:unicorn] = start_process("bin/unicorn")
+        @unicorn_running = true
+        update_tab_labels if @notebook
+      end
+    end
 
-      # Show/hide items based on running state - AFTER show_all
-      start_item.visible = !@running
-      stop_item.visible = @running
-      menu.popup(nil, nil, button, time)
+    def stop_discourse
+      cleanup
     end
-  end
 
-  def start_discourse
-    @ember_output.clear
-    @unicorn_output.clear
+    def cleanup
+      return if @processes.empty?
 
-    Dir.chdir(@discourse_path) do
-      @processes[:ember] = start_process("bin/ember-cli")
-      @ember_running = true
-      @processes[:unicorn] = start_process("bin/unicorn")
-      @unicorn_running = true
-      update_tab_labels if @notebook
-    end
-  end
+      # First disable updates to prevent race conditions
+      @view_timeouts&.values&.each do |id|
+        begin
+          GLib::Source.remove(id)
+        rescue StandardError => e
+          puts "Error removing timeout: #{e}" if OPTIONS[:debug]
+        end
+      end
+      @view_timeouts&.clear
 
-  def stop_discourse
-    cleanup
-  end
+      # Then stop processes
+      @processes.each do |name, process|
+        begin
+          Process.kill("TERM", process[:pid])
+          # Wait for process to finish with timeout
+          Timeout.timeout(10) { process[:thread].join }
+        rescue StandardError => e
+          puts "Error stopping #{name}: #{e}" if OPTIONS[:debug]
+        end
+      end
+      @processes.clear
+      @ember_running = false
+      @unicorn_running = false
 
-  def cleanup
-    return if @processes.empty?
+      # Finally clean up UI elements
+      update_tab_labels if @notebook && !@notebook.destroyed?
 
-    @processes.each do |name, process|
-      begin
-        Process.kill("TERM", process[:pid])
-        # Wait for process to finish with timeout
-        Timeout.timeout(10) { process[:thread].join }
-      rescue StandardError => e
-        puts "Error stopping #{name}: #{e}" if OPTIONS[:debug]
+      if @status_window && !@status_window.destroyed?
+        @status_window.destroy
+        @status_window = nil
       end
     end
-    @processes.clear
-    @ember_running = false
-    @unicorn_running = false
-    update_tab_labels if @notebook
-
-    # Clean up window and timeouts on exit
-    if @status_window
-      # Clean up any existing timeouts
-      if @view_timeouts
-        @view_timeouts.values.each do |id|
-          begin
-            GLib::Source.remove(id)
-          rescue StandardError
-            nil
+
+    def start_process(command, console: false)
+      return start_console_process(command) if console
+      stdin, stdout, stderr, wait_thr = Open3.popen3(command)
+
+      # Create a monitor thread that will detect if process dies
+      monitor_thread =
+        Thread.new do
+          wait_thr.value # Wait for process to finish
+          is_ember = command.include?("ember-cli")
+          @ember_running = false if is_ember
+          @unicorn_running = false unless is_ember
+          GLib::Idle.add do
+            update_tab_labels if @notebook
+            false
           end
         end
-        @view_timeouts.clear
-      end
-      @status_window.destroy
-      @status_window = nil
-    end
-  end
-
-  def start_process(command)
-    stdin, stdout, stderr, wait_thr = Open3.popen3(command)
 
-    # Create a monitor thread that will detect if process dies
-    monitor_thread =
+      # Monitor stdout - send to both console and UX buffer
       Thread.new do
-        wait_thr.value # Wait for process to finish
-        is_ember = command.include?("ember-cli")
-        @ember_running = false if is_ember
-        @unicorn_running = false unless is_ember
-        GLib::Idle.add do
-          update_tab_labels if @notebook
-          false
+        while line = stdout.gets
+          buffer =
+            command.include?("ember-cli") ? @ember_output : @unicorn_output
+          publish_to_pipe(line)
+          puts "[OUT] #{line}" if OPTIONS[:debug]
+          buffer << line
+          buffer.shift if buffer.size > BUFFER_SIZE
+          # Force GUI update
+          GLib::Idle.add do
+            update_all_views
+            false
+          end
         end
       end
 
-    # Monitor stdout
-    Thread.new do
-      while line = stdout.gets
-        buffer = command.include?("ember-cli") ? @ember_output : @unicorn_output
-        puts "[OUT] #{line}" if OPTIONS[:debug]
-        buffer << line
-        buffer.shift if buffer.size > BUFFER_SIZE
-        # Force GUI update
-        GLib::Idle.add do
-          update_all_views
-          false
+      # Monitor stderr - send to both console and UX buffer
+      Thread.new do
+        while line = stderr.gets
+          buffer =
+            command.include?("ember-cli") ? @ember_output : @unicorn_output
+          publish_to_pipe("ERROR: #{line}")
+          puts "[ERR] #{line}" if OPTIONS[:debug]
+          buffer << line
+          buffer.shift if buffer.size > BUFFER_SIZE
+          # Force GUI update
+          GLib::Idle.add do
+            update_all_views
+            false
+          end
         end
       end
+
+      {
+        pid: wait_thr.pid,
+        stdin: stdin,
+        stdout: stdout,
+        stderr: stderr,
+        thread: wait_thr,
+        monitor: monitor_thread
+      }
     end
 
-    # Monitor stderr
-    Thread.new do
-      while line = stderr.gets
-        buffer = command.include?("ember-cli") ? @ember_output : @unicorn_output
-        puts "[ERR] #{line}" if OPTIONS[:debug]
-        buffer << line
-        buffer.shift if buffer.size > BUFFER_SIZE
-        # Force GUI update
-        GLib::Idle.add do
-          update_all_views
-          false
+    def show_status_window
+      if @status_window&.visible?
+        @status_window.present
+        # Force window to current workspace in i3
+        if @status_window.window
+          @status_window.window.raise
+          if system("which i3-msg >/dev/null 2>&1")
+            # First move to current workspace, then focus
+            system(
+              "i3-msg '[id=#{@status_window.window.xid}] move workspace current'"
+            )
+            system("i3-msg '[id=#{@status_window.window.xid}] focus'")
+          end
         end
+        return
       end
-    end
 
-    {
-      pid: wait_thr.pid,
-      stdin: stdin,
-      stdout: stdout,
-      stderr: stderr,
-      thread: wait_thr,
-      monitor: monitor_thread
-    }
-  end
+      # Clean up any existing window
+      if @status_window
+        @status_window.destroy
+        @status_window = nil
+      end
 
-  def show_status_window
-    if @status_window&.visible?
-      @status_window.present
-      # Force window to current workspace in i3
-      if @status_window.window
-        @status_window.window.raise
-        if system("which i3-msg >/dev/null 2>&1")
-          # First move to current workspace, then focus
-          system(
-            "i3-msg '[id=#{@status_window.window.xid}] move workspace current'"
-          )
-          system("i3-msg '[id=#{@status_window.window.xid}] focus'")
-        end
+      @status_window = Gtk::Window.new("Discourse Status")
+      @status_window.set_wmclass("discourse-status", "Discourse Status")
+
+      # Load saved geometry or use defaults
+      config = self.class.load_config
+      if config["window_geometry"]
+        geo = config["window_geometry"]
+        @status_window.move(geo["x"], geo["y"])
+        @status_window.resize(geo["width"], geo["height"])
+      else
+        @status_window.set_default_size(800, 600)
+        @status_window.window_position = :center
+      end
+      @status_window.type_hint = :dialog
+      @status_window.set_role("discourse-status-dialog")
+
+      # Handle window destruction and hide
+      @status_window.signal_connect("delete-event") do
+        save_window_geometry
+        @status_window.hide
+        true # Prevent destruction
       end
-      return
-    end
 
-    # Clean up any existing window
-    if @status_window
-      @status_window.destroy
-      @status_window = nil
-    end
+      # Save position and size when window is moved or resized
+      @status_window.signal_connect("configure-event") do
+        save_window_geometry
+        false
+      end
 
-    @status_window = Gtk::Window.new("Discourse Status")
-    @status_window.set_wmclass("discourse-status", "Discourse Status")
-
-    # Load saved geometry or use defaults
-    config = self.class.load_config
-    if config["window_geometry"]
-      geo = config["window_geometry"]
-      @status_window.move(geo["x"], geo["y"])
-      @status_window.resize(geo["width"], geo["height"])
-    else
-      @status_window.set_default_size(800, 600)
-      @status_window.window_position = :center
-    end
-    @status_window.type_hint = :dialog
-    @status_window.set_role("discourse-status-dialog")
-
-    # Handle window destruction and hide
-    @status_window.signal_connect("delete-event") do
-      save_window_geometry
-      @status_window.hide
-      true # Prevent destruction
-    end
+      @notebook = Gtk::Notebook.new
 
-    # Save position and size when window is moved or resized
-    @status_window.signal_connect("configure-event") do
-      save_window_geometry
-      false
-    end
+      @ember_view = create_log_view(@ember_output)
+      @ember_label = create_status_label("Ember CLI", @ember_running)
+      @notebook.append_page(@ember_view, @ember_label)
 
-    @notebook = Gtk::Notebook.new
+      @unicorn_view = create_log_view(@unicorn_output)
+      @unicorn_label = create_status_label("Unicorn", @unicorn_running)
+      @notebook.append_page(@unicorn_view, @unicorn_label)
 
-    @ember_view = create_log_view(@ember_output)
-    @ember_label = create_status_label("Ember CLI", @ember_running)
-    @notebook.append_page(@ember_view, @ember_label)
+      @status_window.add(@notebook)
+      @status_window.show_all
+    end
 
-    @unicorn_view = create_log_view(@unicorn_output)
-    @unicorn_label = create_status_label("Unicorn", @unicorn_running)
-    @notebook.append_page(@unicorn_view, @unicorn_label)
+    def update_all_views
+      return unless @status_window && !@status_window.destroyed?
+      return unless @ember_view && @unicorn_view
+      return unless @ember_view.child && @unicorn_view.child
+      return if @ember_view.destroyed? || @unicorn_view.destroyed?
+      return if @ember_view.child.destroyed? || @unicorn_view.child.destroyed?
 
-    @status_window.add(@notebook)
-    @status_window.show_all
-  end
+      begin
+        if @ember_view.visible? && @ember_view.child.visible?
+          update_log_view(@ember_view.child, @ember_output)
+        end
+        if @unicorn_view.visible? && @unicorn_view.child.visible?
+          update_log_view(@unicorn_view.child, @unicorn_output)
+        end
+      rescue StandardError => e
+        puts "Error updating views: #{e}" if OPTIONS[:debug]
+      end
+    end
 
-  def update_all_views
-    return unless @ember_view && @unicorn_view
+    def create_log_view(buffer)
+      scroll = Gtk::ScrolledWindow.new
+      text_view = Gtk::TextView.new
+      text_view.editable = false
+      text_view.wrap_mode = :word
+
+      # Set white text on black background
+      text_view.override_background_color(:normal, Gdk::RGBA.new(0, 0, 0, 1))
+      text_view.override_color(:normal, Gdk::RGBA.new(1, 1, 1, 1))
+
+      # Create text tags for colors
+      _tag_table = text_view.buffer.tag_table
+      create_ansi_tags(text_view.buffer)
+
+      # Initial text
+      update_log_view(text_view, buffer)
+
+      # Store timeouts in instance variable for proper cleanup
+      @view_timeouts ||= {}
+
+      # Set up periodic refresh with validity check
+      timeout_id =
+        GLib::Timeout.add(500) do
+          if text_view&.parent.nil? || text_view.destroyed?
+            @view_timeouts.delete(text_view.object_id)
+            false # Stop the timeout if view is destroyed
+          else
+            begin
+              update_log_view(text_view, buffer)
+            rescue StandardError => e
+              puts "Error updating log view: #{e}" if OPTIONS[:debug]
+            end
+            true # Keep the timeout active
+          end
+        end
 
-    update_log_view(@ember_view.child, @ember_output)
-    update_log_view(@unicorn_view.child, @unicorn_output)
-  end
+      @view_timeouts[text_view.object_id] = timeout_id
 
-  def create_log_view(buffer)
-    scroll = Gtk::ScrolledWindow.new
-    text_view = Gtk::TextView.new
-    text_view.editable = false
-    text_view.wrap_mode = :word
+      # Clean up timeout when view is destroyed
+      text_view.signal_connect("destroy") do
+        if timeout_id = @view_timeouts.delete(text_view.object_id)
+          begin
+            GLib::Source.remove(timeout_id)
+          rescue StandardError
+            nil
+          end
+        end
+      end
 
-    # Set white text on black background
-    text_view.override_background_color(:normal, Gdk::RGBA.new(0, 0, 0, 1))
-    text_view.override_color(:normal, Gdk::RGBA.new(1, 1, 1, 1))
+      scroll.add(text_view)
+      scroll
+    end
 
-    # Create text tags for colors
-    _tag_table = text_view.buffer.tag_table
-    create_ansi_tags(text_view.buffer)
+    def create_ansi_tags(buffer)
+      # Basic ANSI colors
+      {
+        "31" => "#ff6b6b", # Brighter red
+        "32" => "#87ff87", # Brighter green
+        "33" => "#ffff87", # Brighter yellow
+        "34" => "#87d7ff", # Brighter blue
+        "35" => "#ff87ff", # Brighter magenta
+        "36" => "#87ffff", # Brighter cyan
+        "37" => "#ffffff" # White
+      }.each do |code, color|
+        buffer.create_tag("ansi_#{code}", foreground: color)
+      end
+
+      # Add more tags for bold, etc
+      buffer.create_tag("bold", weight: :bold)
+    end
 
-    # Initial text
-    update_log_view(text_view, buffer)
+    def update_log_view(text_view, buffer)
+      return if text_view.nil? || text_view.destroyed?
+      return if text_view.buffer.nil? || text_view.buffer.destroyed?
+
+      # Determine which offset counter to use
+      offset_var =
+        (
+          if buffer.equal?(@ember_output)
+            :@ember_line_count
+          else
+            :@unicorn_line_count
+          end
+        )
+      current_offset = instance_variable_get(offset_var)
+
+      # Don't call if we've already processed all lines
+      return if buffer.size <= current_offset
+
+      adj = text_view&.parent&.vadjustment
+      was_at_bottom = (adj && adj.value >= adj.upper - adj.page_size - 50)
+      old_value = adj ? adj.value : 0
+
+      # Process only the new lines
+      new_lines = buffer[current_offset..-1]
+      new_lines.each do |line|
+        ansi_segments =
+          line.scan(/\e\[([0-9;]*)m([^\e]*)|\e\[K([^\e]*)|([^\e]+)/)
+
+        ansi_segments.each do |codes, text_part, clear_part, plain|
+          chunk = text_part || clear_part || plain.to_s
+          chunk_start_iter = text_view.buffer.end_iter
+          text_view.buffer.insert(chunk_start_iter, chunk)
+
+          # For each ANSI code, apply tags
+          if codes
+            codes
+              .split(";")
+              .each do |code|
+                case code
+                when "1"
+                  text_view.buffer.apply_tag(
+                    "bold",
+                    chunk_start_iter,
+                    text_view.buffer.end_iter
+                  )
+                when "31".."37"
+                  text_view.buffer.apply_tag(
+                    "ansi_#{code}",
+                    chunk_start_iter,
+                    text_view.buffer.end_iter
+                  )
+                end
+              end
+          end
+        end
+      end
 
-    # Store timeouts in instance variable for proper cleanup
-    @view_timeouts ||= {}
+      # Update our offset counter
+      instance_variable_set(offset_var, buffer.size)
 
-    # Set up periodic refresh with validity check
-    timeout_id =
-      GLib::Timeout.add(1000) do
-        if text_view&.parent.nil? || !text_view&.parent&.visible?
-          @view_timeouts.delete(text_view.object_id)
-          false # Stop the timeout if view is destroyed
+      # Restore scroll position
+      if adj
+        if was_at_bottom
+          adj.value = adj.upper - adj.page_size
         else
-          begin
-            update_log_view(text_view, buffer)
-          rescue StandardError
-            nil
-          end
-          true # Keep the timeout active
+          adj.value = old_value
         end
       end
+    end
 
-    @view_timeouts[text_view.object_id] = timeout_id
+    def create_status_label(text, running)
+      box = Gtk::Box.new(:horizontal, 5)
+      label = Gtk::Label.new(text)
+      status = Gtk::Label.new
+      color =
+        (
+          if running
+            Gdk::RGBA.new(0.2, 0.8, 0.2, 1)
+          else
+            Gdk::RGBA.new(0.8, 0.2, 0.2, 1)
+          end
+        )
+      status.override_color(:normal, color)
+      status.text = running ? "●" : "○"
+      box.pack_start(label, expand: false, fill: false, padding: 0)
+      box.pack_start(status, expand: false, fill: false, padding: 0)
+      box.show_all
+      box
+    end
+
+    def update_tab_labels
+      return unless @notebook && !@notebook.destroyed?
+      return unless @ember_label && @unicorn_label
+      return if @ember_label.destroyed? || @unicorn_label.destroyed?
 
-    # Clean up timeout when view is destroyed
-    text_view.signal_connect("destroy") do
-      if timeout_id = @view_timeouts.delete(text_view.object_id)
+      [@ember_label, @unicorn_label].each do |label|
+        next unless label.children && label.children.length > 1
+        next if label.children[1].destroyed?
+
+        is_running = label == @ember_label ? @ember_running : @unicorn_running
         begin
-          GLib::Source.remove(timeout_id)
-        rescue StandardError
-          nil
+          label.children[1].text = is_running ? "●" : "○"
+          label.children[1].override_color(
+            :normal,
+            Gdk::RGBA.new(
+              is_running ? 0.2 : 0.8,
+              is_running ? 0.8 : 0.2,
+              0.2,
+              1
+            )
+          )
+        rescue StandardError => e
+          puts "Error updating label: #{e}" if OPTIONS[:debug]
         end
       end
     end
 
-    scroll.add(text_view)
-    scroll
-  end
+    def save_window_geometry
+      return unless @status_window&.visible? && @status_window.window
+
+      x, y = @status_window.position
+      width, height = @status_window.size
 
-  def create_ansi_tags(buffer)
-    # Basic ANSI colors
-    {
-      "31" => "#ff6b6b", # Brighter red
-      "32" => "#87ff87", # Brighter green
-      "33" => "#ffff87", # Brighter yellow
-      "34" => "#87d7ff", # Brighter blue
-      "35" => "#ff87ff", # Brighter magenta
-      "36" => "#87ffff", # Brighter cyan
-      "37" => "#ffffff" # White
-    }.each do |code, color|
-      buffer.create_tag("ansi_#{code}", foreground: color)
+      self.class.save_config(
+        path: @discourse_path,
+        window_geometry: {
+          "x" => x,
+          "y" => y,
+          "width" => width,
+          "height" => height
+        }
+      )
     end
 
-    # Add more tags for bold, etc
-    buffer.create_tag("bold", weight: :bold)
-  end
+    def set_icon(status)
+      icon_file = status == :running ? "discourse_running.png" : "discourse.png"
+      icon_path = File.join(File.dirname(__FILE__), "../../assets", icon_file)
+      @indicator.pixbuf = GdkPixbuf::Pixbuf.new(file: icon_path)
+    end
 
-  def update_log_view(text_view, buffer)
-    return if buffer.empty? || text_view.nil? || !text_view.visible?
-    return unless text_view.parent&.visible?
-
-    text_view.buffer.text = ""
-    iter = text_view.buffer.get_iter_at(offset: 0)
-
-    buffer.each do |line|
-      # Parse ANSI sequences
-      segments = line.scan(/\e\[([0-9;]*)m([^\e]*)|\e\[K([^\e]*)|([^\e]+)/)
-
-      segments.each do |codes, text, clear_line, plain|
-        if codes
-          codes
-            .split(";")
-            .each do |code|
-              case code
-              when "1"
-                text_view.buffer.apply_tag("bold", iter, iter)
-              when "31".."37"
-                text_view.buffer.apply_tag("ansi_#{code}", iter, iter)
-              end
-            end
-          text_view.buffer.insert(iter, text)
-        elsif clear_line
-          text_view.buffer.insert(iter, clear_line)
-        else
-          text_view.buffer.insert(iter, plain || "")
+    def start_console_process(command)
+      stdin, stdout, stderr, wait_thr = Open3.popen3(command)
+
+      # Pipe stdout to console and add to buffer
+      Thread.new do
+        while line = stdout.gets
+          buffer =
+            command.include?("ember-cli") ? @ember_output : @unicorn_output
+          print line
+          buffer << line
+          buffer.shift if buffer.size > BUFFER_SIZE
+        end
+      end
+
+      # Pipe stderr to console and add to buffer
+      Thread.new do
+        while line = stderr.gets
+          buffer =
+            command.include?("ember-cli") ? @ember_output : @unicorn_output
+          STDERR.print line
+          buffer << line
+          buffer.shift if buffer.size > BUFFER_SIZE
         end
       end
+
+      {
+        pid: wait_thr.pid,
+        stdin: stdin,
+        stdout: stdout,
+        stderr: stderr,
+        thread: wait_thr
+      }
     end
 
-    # Scroll to bottom if near bottom
-    if text_view&.parent&.vadjustment
-      adj = text_view.parent.vadjustment
-      if adj.value >= adj.upper - adj.page_size - 50
-        adj.value = adj.upper - adj.page_size
+    PIPE_PATH = "/tmp/discourse_systray_cmd"
+    PID_FILE = "/tmp/discourse_systray.pid"
+
+    def self.running?
+      return false unless File.exist?(PID_FILE)
+      pid = File.read(PID_FILE).to_i
+      Process.kill(0, pid)
+      true
+    rescue Errno::ESRCH, Errno::ENOENT
+      begin
+        File.unlink(PID_FILE)
+      rescue StandardError
+        nil
       end
+      false
     end
-  end
 
-  def create_status_label(text, running)
-    box = Gtk::Box.new(:horizontal, 5)
-    label = Gtk::Label.new(text)
-    status = Gtk::Label.new
-    color =
-      (
-        if running
-          Gdk::RGBA.new(0.2, 0.8, 0.2, 1)
-        else
-          Gdk::RGBA.new(0.8, 0.2, 0.2, 1)
+    attr_reader :discourse_path
+
+    def self.run
+      new.run
+    end
+
+    def run
+      if OPTIONS[:attach]
+        require "rb-inotify"
+
+        notifier = INotify::Notifier.new
+
+        begin
+          pipe = File.open(PIPE_PATH, "r")
+
+          # Watch for pipe deletion
+          notifier.watch(File.dirname(PIPE_PATH), :delete) do |event|
+            if event.name == File.basename(PIPE_PATH)
+              puts "Pipe was deleted, exiting."
+              exit 0
+            end
+          end
+
+          # Read from pipe in a separate thread
+          reader =
+            Thread.new do
+              begin
+                while true
+                  if IO.select([pipe], nil, nil, 0.5)
+                    while line = pipe.gets
+                      puts line
+                      STDOUT.flush
+                    end
+                  end
+
+                  sleep 0.1
+                  unless File.exist?(PIPE_PATH)
+                    puts "Pipe was deleted, exiting."
+                    exit 0
+                  end
+                end
+              rescue EOFError, IOError
+                puts "Pipe closed, exiting."
+                exit 0
+              end
+            end
+
+          # Handle notifications in main thread
+          notifier.run
+        rescue Errno::ENOENT
+          puts "Pipe doesn't exist, exiting."
+          exit 1
+        ensure
+          reader&.kill
+          pipe&.close
+          notifier&.close
         end
-      )
-    status.override_color(:normal, color)
-    status.text = running ? "●" : "○"
-    box.pack_start(label, expand: false, fill: false, padding: 0)
-    box.pack_start(status, expand: false, fill: false, padding: 0)
-    box.show_all
-    box
-  end
+      else
+        return if self.class.running?
 
-  def update_tab_labels
-    return unless @notebook
-    @ember_label.children[1].text = @ember_running ? "●" : "○"
-    @ember_label.children[1].override_color(
-      :normal,
-      Gdk::RGBA.new(
-        @ember_running ? 0.2 : 0.8,
-        @ember_running ? 0.8 : 0.2,
-        0.2,
-        1
-      )
-    )
-
-    @unicorn_label.children[1].text = @unicorn_running ? "●" : "○"
-    @unicorn_label.children[1].override_color(
-      :normal,
-      Gdk::RGBA.new(
-        @unicorn_running ? 0.2 : 0.8,
-        @unicorn_running ? 0.8 : 0.2,
-        0.2,
-        1
-      )
-    )
-  end
+        system("mkfifo #{PIPE_PATH}") unless File.exist?(PIPE_PATH)
 
-  def save_window_geometry
-    return unless @status_window&.visible? && @status_window.window
+        # Create named pipe and write PID file
+        system("mkfifo #{PIPE_PATH}") unless File.exist?(PIPE_PATH)
+        File.write(PID_FILE, Process.pid.to_s)
 
-    x, y = @status_window.position
-    width, height = @status_window.size
+        # Set up cleanup on exit
+        at_exit do
+          begin
+            File.unlink(PIPE_PATH) if File.exist?(PIPE_PATH)
+            File.unlink(PID_FILE) if File.exist?(PID_FILE)
+          rescue StandardError => e
+            puts "Error during cleanup: #{e}" if OPTIONS[:debug]
+          end
+        end
 
-    self.class.save_config(
-      path: @discourse_path,
-      window_geometry: {
-        "x" => x,
-        "y" => y,
-        "width" => width,
-        "height" => height
-      }
-    )
-  end
+        # Initialize GTK
+        Gtk.init
 
-  def set_icon(status)
-    icon_file = status == :running ? "discourse_running.png" : "discourse.png"
-    icon_path = File.join(File.dirname(__FILE__), "../../assets", icon_file)
-    @indicator.pixbuf = GdkPixbuf::Pixbuf.new(file: icon_path)
-  end
+        # Setup systray icon and menu
+        init_systray
 
-  def run
-    Gtk.main
+        # Start GTK main loop
+        Gtk.main
+      end
+    end
+
+    def publish_to_pipe(msg)
+      return unless File.exist?(PIPE_PATH)
+      puts "Publish to pipe: #{msg}" if OPTIONS[:debug]
+      begin
+        File.open(PIPE_PATH, "w") { |f| f.puts(msg) }
+      rescue Errno::EPIPE, IOError => e
+        puts "Error writing to pipe: #{e}" if OPTIONS[:debug]
+      end
+    end
+
+    def handle_command(cmd)
+      puts "Received command: #{cmd}" if OPTIONS[:debug]
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: discourse-systray
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Sam Saffron
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-01-23 00:00:00.000000000 Z
+date: 2025-01-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gtk3
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: rb-inotify
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.1
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement