discourse-systray 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5210b401c239734ab826f42710f3d925e65e52d62b9a5f8b3da18d56b874469b
-  data.tar.gz: 838fac902e2cad6158ea5c5f52086047f4687b5871e1ce5c4b4989203d6e3eda
+  metadata.gz: 52f16a25286153255ec00c850f08e74cd2b704903d8adf850705f17aa6898fdb
+  data.tar.gz: 4f708705f6669dff35a737ff328917c3b603b7cc7f87c0c1d3a7602ee0157852
 SHA512:
-  metadata.gz: a4694037048949cbb48696ff280327b1d1f6f6349685de9e8a55fcfc81f27326e4812e526c0976c7615a0d0076543139c158744cd451841503b32f70d0963597
-  data.tar.gz: 7193b7995de0c0ff81ca6224c12d478b916bb3972ec896a4266cfbf7a12dc1881091f9cc28c434d3fc65f190e0902e031dbcca6bb66ff705cd92f7891a53e766
+  metadata.gz: ffaf161d05e11185dde22eb1f4a8c61dd42fa14ffcc72738391e5a8f54c68523f225d8442bd83f49bdec36c15e7237bf58eb351811781f845bedd15f92592781
+  data.tar.gz: 5cf888a341f139472fc4858731310d42e4586910f19992643c015e1be1f95ce20140d9d37ca0b8644f8fd2afa8d363b185cc42509d1a41f96293ae338f3dfa3a

data/lib/discourse_systray/systray.rb

@@ -74,19 +74,73 @@ module ::DiscourseSystray
     rescue JSON::ParserError
       {}
     end
-    BUFFER_SIZE = 2000
+    BUFFER_SIZE = 1000
+    BUFFER_TRIM_INTERVAL = 30 # seconds
 
     def initialize
+      puts "DEBUG: Initializing DiscourseSystray" if OPTIONS[:debug]
+      
       @discourse_path = self.class.load_or_prompt_config unless OPTIONS[:attach]
+      puts "DEBUG: Discourse path: #{@discourse_path}" if OPTIONS[:debug]
+      
       @running = false
       @ember_output = []
       @unicorn_output = []
       @processes = {}
       @ember_running = false
       @unicorn_running = false
-      @ember_line_count = 0
-      @unicorn_line_count = 0
       @status_window = nil
+      @buffer_trim_timer = nil
+      
+      # Initialize pipe queue for background processing
+      initialize_pipe_queue
+      
+      # Add initial welcome message to buffers with timestamp
+      timestamp = Time.now.strftime("%H:%M:%S")
+      @ember_output << "#{timestamp} - Discourse Ember CLI Log\n"
+      @ember_output << "Start Discourse to see Ember CLI logs here.\n"
+      @ember_output << "\n"
+      
+      @unicorn_output << "#{timestamp} - Discourse Unicorn Log\n"
+      @unicorn_output << "Start Discourse to see Unicorn logs here.\n"
+      @unicorn_output << "\n"
+      
+      # Add a visual separator
+      @ember_output << "=" * 50 + "\n"
+      @unicorn_output << "=" * 50 + "\n"
+      
+      puts "DEBUG: Added initial data to buffers" if OPTIONS[:debug]
+      puts "DEBUG: ember_output size: #{@ember_output.size}" if OPTIONS[:debug]
+      puts "DEBUG: unicorn_output size: #{@unicorn_output.size}" if OPTIONS[:debug]
+      
+      # Set up periodic buffer trimming
+      setup_buffer_trim_timer unless OPTIONS[:attach]
+      
+      puts "DEBUG: Initialized DiscourseSystray with path: #{@discourse_path}" if OPTIONS[:debug]
+    end
+    
+    def setup_buffer_trim_timer
+      @buffer_trim_timer = GLib::Timeout.add_seconds(BUFFER_TRIM_INTERVAL) do
+        trim_buffers
+        true # Keep the timer running
+      end
+    end
+    
+    def trim_buffers
+      # Trim buffers if they exceed the buffer size
+      if @ember_output.size > BUFFER_SIZE
+        excess = @ember_output.size - BUFFER_SIZE
+        @ember_output.shift(excess)
+        @ember_line_count = [@ember_line_count - excess, 0].max
+      end
+      
+      if @unicorn_output.size > BUFFER_SIZE
+        excess = @unicorn_output.size - BUFFER_SIZE
+        @unicorn_output.shift(excess)
+        @unicorn_line_count = [@unicorn_line_count - excess, 0].max
+      end
+      
+      true
     end
 
     def init_systray
@@ -182,6 +236,27 @@ module ::DiscourseSystray
         end
       end
       @view_timeouts&.clear
+      
+      # Remove buffer trim timer if it exists
+      if @buffer_trim_timer
+        begin
+          GLib::Source.remove(@buffer_trim_timer)
+          @buffer_trim_timer = nil
+        rescue StandardError => e
+          puts "Error removing buffer trim timer: #{e}" if OPTIONS[:debug]
+        end
+      end
+      
+      # Stop pipe thread
+      if @pipe_thread
+        begin
+          @pipe_queue.push(:exit) if @pipe_queue
+          @pipe_thread.join(2) # Wait up to 2 seconds
+          @pipe_thread.kill if @pipe_thread.alive?
+        rescue StandardError => e
+          puts "Error stopping pipe thread: #{e}" if OPTIONS[:debug]
+        end
+      end
 
       # Then stop processes
       @processes.each do |name, process|
@@ -207,31 +282,90 @@ module ::DiscourseSystray
     end
 
     def start_process(command, console: false)
+      puts "DEBUG: start_process called with command: #{command}" if OPTIONS[:debug]
+      
       return start_console_process(command) if console
-      stdin, stdout, stderr, wait_thr = Open3.popen3(command)
+      
+      begin
+        stdin, stdout, stderr, wait_thr = Open3.popen3(command)
+        puts "DEBUG: Process started with PID: #{wait_thr.pid}" if OPTIONS[:debug]
+      rescue => e
+        puts "DEBUG: Error starting process: #{e.message}" if OPTIONS[:debug]
+        return nil
+      end
 
       # 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
+          begin
+            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
+          rescue => e
+            puts "DEBUG: Error in monitor thread: #{e.message}" if OPTIONS[:debug]
           end
         end
 
-      # Monitor stdout - send to both console and UX buffer
+      # Clear the buffer before starting
+      buffer = command.include?("ember-cli") ? @ember_output : @unicorn_output
+      buffer.clear
+      
+      # Add a start message to the buffer
+      timestamp = Time.now.strftime("%H:%M:%S")
+      buffer << "#{timestamp} - Starting #{command}...\n"
+      
+      # Force immediate GUI update
+      GLib::Idle.add do
+        update_all_views
+        false
+      end
+
+      # Monitor stdout
       Thread.new do
-        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
+        begin
+          while line = stdout.gets
+            buffer = command.include?("ember-cli") ? @ember_output : @unicorn_output
+            puts "[OUT] #{line}" if OPTIONS[:debug]
+            
+            # Add to buffer with size management
+            buffer << line
+            
+            # Print buffer size for debugging
+            if OPTIONS[:debug]
+              puts "DEBUG: Added to buffer: #{line.inspect}"
+              if buffer.size % 10 == 0
+                puts "DEBUG: Buffer size now: #{buffer.size}"
+              end
+            end
+            
+            # Trim if needed
+            if buffer.size > BUFFER_SIZE
+              buffer.shift(buffer.size - BUFFER_SIZE)
+            end
+            
+            # Force GUI update on main thread
+            GLib::Idle.add do
+              update_all_views
+              false
+            end
+            
+            # Also publish to pipe for --attach mode in background
+            publish_to_pipe(line, process: command.include?("ember-cli") ? :ember : :unicorn, stream: :stdout)
+          end
+        rescue => e
+          puts "DEBUG: Error in stdout thread: #{e.message}" if OPTIONS[:debug]
+          puts e.backtrace.join("\n") if OPTIONS[:debug]
+          
+          # Add error to buffer for visibility
+          buffer = command.include?("ember-cli") ? @ember_output : @unicorn_output
+          error_msg = "ERROR: Exception in stdout thread: #{e.message}\n"
+          buffer << error_msg
+          
           # Force GUI update
           GLib::Idle.add do
             update_all_views
@@ -240,15 +374,50 @@ module ::DiscourseSystray
         end
       end
 
-      # Monitor stderr - send to both console and UX buffer
+      # Monitor stderr
       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
+        begin
+          while line = stderr.gets
+            buffer = command.include?("ember-cli") ? @ember_output : @unicorn_output
+            puts "[ERR] #{line}" if OPTIONS[:debug]
+            
+            # Format error line
+            error_line = "E: #{line}"
+            
+            # Add to buffer with size management
+            buffer << error_line
+            
+            # Print buffer size for debugging
+            if OPTIONS[:debug]
+              puts "DEBUG: Added to buffer: #{error_line.inspect}"
+              if buffer.size % 10 == 0
+                puts "DEBUG: Buffer size now: #{buffer.size}"
+              end
+            end
+            
+            # Trim if needed
+            if buffer.size > BUFFER_SIZE
+              buffer.shift(buffer.size - BUFFER_SIZE)
+            end
+            
+            # Force GUI update on main thread
+            GLib::Idle.add do
+              update_all_views
+              false
+            end
+            
+            # Also publish to pipe for --attach mode in background
+            publish_to_pipe(error_line, process: command.include?("ember-cli") ? :ember : :unicorn, stream: :stderr)
+          end
+        rescue => e
+          puts "DEBUG: Error in stderr thread: #{e.message}" if OPTIONS[:debug]
+          puts e.backtrace.join("\n") if OPTIONS[:debug]
+          
+          # Add error to buffer for visibility
+          buffer = command.include?("ember-cli") ? @ember_output : @unicorn_output
+          error_msg = "ERROR: Exception in stderr thread: #{e.message}\n"
+          buffer << error_msg
+          
           # Force GUI update
           GLib::Idle.add do
             update_all_views
@@ -268,28 +437,43 @@ module ::DiscourseSystray
     end
 
     def show_status_window
+      puts "DEBUG: show_status_window called" if OPTIONS[:debug]
+      
       if @status_window&.visible?
+        puts "DEBUG: Status window already visible, presenting it" if OPTIONS[:debug]
         @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}] move workspace current'")
             system("i3-msg '[id=#{@status_window.window.xid}] focus'")
           end
         end
+        
+        # Force an update of the views even if window is already visible
+        GLib::Idle.add do
+          update_all_views
+          false
+        end
+        
         return
       end
 
-      # Clean up any existing window
+      # Clean up any existing window and notebook
       if @status_window
+        puts "DEBUG: Destroying existing status window" if OPTIONS[:debug]
+        @notebook = nil # Clear notebook reference
+        @ember_view = nil
+        @unicorn_view = nil
+        @ember_label = nil
+        @unicorn_label = nil
         @status_window.destroy
         @status_window = nil
       end
 
+      # Create new window and components
+      puts "DEBUG: Creating new status window" if OPTIONS[:debug]
       @status_window = Gtk::Window.new("Discourse Status")
       @status_window.set_wmclass("discourse-status", "Discourse Status")
 
@@ -299,15 +483,18 @@ module ::DiscourseSystray
         geo = config["window_geometry"]
         @status_window.move(geo["x"], geo["y"])
         @status_window.resize(geo["width"], geo["height"])
+        puts "DEBUG: Set window geometry from config: #{geo.inspect}" if OPTIONS[:debug]
       else
         @status_window.set_default_size(800, 600)
         @status_window.window_position = :center
+        puts "DEBUG: Set default window size 800x600" if OPTIONS[:debug]
       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
+        puts "DEBUG: Window delete-event triggered" if OPTIONS[:debug]
         save_window_geometry
         @status_window.hide
         true # Prevent destruction
@@ -319,176 +506,188 @@ module ::DiscourseSystray
         false
       end
 
+      # Create notebook only if it doesn't exist
+      puts "DEBUG: Creating notebook" if OPTIONS[:debug]
       @notebook = Gtk::Notebook.new
 
-      @ember_view = create_log_view(@ember_output)
-      @ember_label = create_status_label("Ember CLI", @ember_running)
-      @notebook.append_page(@ember_view, @ember_label)
+      # Only create views if they don't exist
+      if @ember_view.nil?
+        puts "DEBUG: Creating ember view" if OPTIONS[:debug]
+        @ember_view = create_log_view(@ember_output)
+        @ember_label = create_status_label("Ember CLI", @ember_running)
+        @notebook.append_page(@ember_view, @ember_label)
+      end
 
-      @unicorn_view = create_log_view(@unicorn_output)
-      @unicorn_label = create_status_label("Unicorn", @unicorn_running)
-      @notebook.append_page(@unicorn_view, @unicorn_label)
+      if @unicorn_view.nil?
+        puts "DEBUG: Creating unicorn view" if OPTIONS[:debug]
+        @unicorn_view = create_log_view(@unicorn_output)
+        @unicorn_label = create_status_label("Unicorn", @unicorn_running)
+        @notebook.append_page(@unicorn_view, @unicorn_label)
+      end
 
       @status_window.add(@notebook)
+      puts "DEBUG: Added notebook to status window" if OPTIONS[:debug]
+      
       @status_window.show_all
+      puts "DEBUG: Called show_all on status window" if OPTIONS[:debug]
+      
+      # Force an immediate update of the views
+      GLib::Idle.add do
+        puts "DEBUG: Forcing immediate update after window creation" if OPTIONS[:debug]
+        update_all_views
+        false
+      end
     end
 
     def update_all_views
+      puts "DEBUG: update_all_views called" if OPTIONS[:debug]
+      
+      # Basic validity checks
       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?
-
+      
       begin
-        if @ember_view.visible? && @ember_view.child.visible?
+        # Always update both views for now to ensure content is displayed
+        if @ember_view && !@ember_view.destroyed? && @ember_view.child && !@ember_view.child.destroyed?
           update_log_view(@ember_view.child, @ember_output)
         end
-        if @unicorn_view.visible? && @unicorn_view.child.visible?
+        
+        if @unicorn_view && !@unicorn_view.destroyed? && @unicorn_view.child && !@unicorn_view.child.destroyed?
           update_log_view(@unicorn_view.child, @unicorn_output)
         end
-      rescue StandardError => e
-        puts "Error updating views: #{e}" if OPTIONS[:debug]
+        
+        # Process any pending GTK events
+        while Gtk.events_pending?
+          Gtk.main_iteration_do(false)
+        end
+      rescue => e
+        puts "DEBUG: Error in update_all_views: #{e.message}" if OPTIONS[:debug]
+        puts e.backtrace.join("\n") if OPTIONS[:debug]
       end
     end
 
     def create_log_view(buffer)
+      puts "DEBUG: create_log_view called for #{buffer == @ember_output ? 'ember' : 'unicorn'}" if OPTIONS[:debug]
+      
+      # Create a scrolled window to contain the text view
       scroll = Gtk::ScrolledWindow.new
+      
+      # Create a simple text view with minimal configuration
       text_view = Gtk::TextView.new
       text_view.editable = false
+      text_view.cursor_visible = false
       text_view.wrap_mode = :word
-
-      # Set white text on black background
+      
+      # Use a fixed-width font
+      text_view.monospace = true
+      
+      # Set colors - 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
+      
+      # Set font size explicitly
+      font_desc = Pango::FontDescription.new
+      font_desc.family = "Monospace"
+      font_desc.size = 12 * Pango::SCALE
+      text_view.override_font(font_desc)
+      
+      # Set initial text
+      text_view.buffer.text = "Loading log data...\n"
+      
+      # Add the text view to the scrolled window
+      scroll.add(text_view)
+      
+      # Set up a timer to update the view more frequently
       @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
+      timeout_id = GLib::Timeout.add(250) do
+        if text_view.destroyed? || scroll.destroyed?
+          @view_timeouts.delete(text_view.object_id)
+          false # Stop the timer
+        else
+          begin
+            update_log_view(text_view, buffer)
+          rescue => e
+            puts "DEBUG: Error updating log view: #{e.message}" if OPTIONS[:debug]
           end
+          true # Continue the timer
         end
-
+      end
+      
+      # Store the timeout ID for cleanup
       @view_timeouts[text_view.object_id] = timeout_id
-
-      # Clean up timeout when view is destroyed
+      
+      # Clean up when the 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
+        if id = @view_timeouts.delete(text_view.object_id)
+          GLib::Source.remove(id) rescue nil
         end
       end
-
-      scroll.add(text_view)
+      
+      # Do an initial update
+      update_log_view(text_view, buffer)
+      
+      # Return the scrolled window
       scroll
     end
 
-    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
+    # We're not using ANSI tags anymore since we're stripping ANSI codes
 
     def update_log_view(text_view, buffer)
+      puts "DEBUG: update_log_view called" if OPTIONS[:debug]
+      
+      # Basic validity checks
       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
+      # Debug buffer content
+      if OPTIONS[:debug]
+        puts "DEBUG: Buffer size: #{buffer.size}"
+        if buffer.size > 0
+          puts "DEBUG: First line: #{buffer.first.inspect}"
+          puts "DEBUG: Last line: #{buffer.last.inspect}"
         end
       end
 
-      # Update our offset counter
-      instance_variable_set(offset_var, buffer.size)
+      # If buffer is empty, add a placeholder message
+      if buffer.empty?
+        buffer << "No log data available yet. Start Discourse to see logs.\n"
+      end
 
-      # Restore scroll position
-      if adj
-        if was_at_bottom
+      # Completely replace the buffer content with all lines
+      begin
+        # Make a local copy of the buffer to avoid race conditions
+        buffer_copy = buffer.dup
+        
+        # Join all buffer lines into a single string
+        all_content = buffer_copy.join("")
+        
+        # Strip ANSI codes
+        clean_content = all_content.gsub(/\e\[[0-9;]*[mK]/, '')
+        
+        # Always update the content to ensure it's displayed
+        text_view.buffer.text = clean_content
+        
+        puts "DEBUG: Updated buffer text (#{clean_content.length} chars)" if OPTIONS[:debug]
+        
+        # Scroll to bottom
+        adj = text_view&.parent&.vadjustment
+        if adj
           adj.value = adj.upper - adj.page_size
-        else
-          adj.value = old_value
+        end
+        
+        # Process any pending GTK events to ensure UI updates
+        while Gtk.events_pending?
+          Gtk.main_iteration_do(false)
+        end
+      rescue => e
+        puts "DEBUG: Error updating text view: #{e.message}" if OPTIONS[:debug]
+        puts e.backtrace.join("\n") if OPTIONS[:debug]
+        
+        # Try a fallback approach
+        begin
+          text_view.buffer.text = "Error displaying log. See console for details.\n#{e.message}"
+        rescue => e2
+          puts "DEBUG: Even fallback approach failed: #{e2.message}" if OPTIONS[:debug]
         end
       end
     end
@@ -624,6 +823,12 @@ module ::DiscourseSystray
       if OPTIONS[:attach]
         require "rb-inotify"
 
+        # Set up signal handling for Ctrl+C
+        Signal.trap("INT") do
+          puts "Received interrupt signal, shutting down..."
+          exit 0
+        end
+        
         notifier = INotify::Notifier.new
 
         begin
@@ -638,34 +843,57 @@ module ::DiscourseSystray
           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
+          reader = Thread.new do
+            # Set thread abort on exception
+            Thread.current.abort_on_exception = true
+            
+            begin
+              while true
+                begin
+                  # Use non-blocking read with timeout
+                  ready = IO.select([pipe], nil, nil, 0.1)
+                  if ready && ready[0].include?(pipe)
+                    line = pipe.gets
+                    if line
                       puts line
                       STDOUT.flush
                     end
                   end
+                rescue IOError, Errno::EBADF => e
+                  puts "DEBUG: Pipe read error: #{e.message}" if OPTIONS[:debug]
+                  break
+                end
 
-                  sleep 0.1
-                  unless File.exist?(PIPE_PATH)
-                    puts "Pipe was deleted, exiting."
-                    exit 0
-                  end
+                # Check if pipe still exists
+                unless File.exist?(PIPE_PATH)
+                  puts "Pipe was deleted, exiting."
+                  exit 0
                 end
-              rescue EOFError, IOError
-                puts "Pipe closed, exiting."
-                exit 0
+                
+                # Small sleep to prevent CPU hogging
+                sleep 0.01
               end
+            rescue EOFError, IOError
+              puts "Pipe closed, exiting."
+              exit 0
             end
-
-          # Handle notifications in main thread
-          notifier.run
+          end
+          
+          # Set up non-blocking notifier processing
+          # Instead of notifier.run which blocks indefinitely, use a loop with timeout
+          while true
+            # Process any pending inotify events, with timeout
+            notifier.process
+            
+            # Sleep briefly to prevent CPU hogging
+            sleep 0.1
+          end
         rescue Errno::ENOENT
           puts "Pipe doesn't exist, exiting."
           exit 1
+        rescue Interrupt
+          puts "Interrupted, exiting."
+          exit 0
         ensure
           reader&.kill
           pipe&.close
@@ -695,21 +923,52 @@ module ::DiscourseSystray
 
         # Setup systray icon and menu
         init_systray
-
+        
         # 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]
+    # Queue for pipe messages to avoid blocking
+    def initialize_pipe_queue
+      @pipe_queue = Queue.new
+      @pipe_thread = Thread.new do
+        loop do
+          begin
+            msg = @pipe_queue.pop
+            break if msg == :exit
+            
+            if File.exist?(PIPE_PATH)
+              begin
+                # Use non-blocking write with timeout
+                Timeout.timeout(0.5) do
+                  File.open(PIPE_PATH, "w") do |f|
+                    f.puts(msg)
+                    f.flush
+                  end
+                end
+              rescue Timeout::Error
+                puts "Timeout writing to pipe" if OPTIONS[:debug]
+              rescue Errno::EPIPE, IOError => e
+                puts "Error writing to pipe: #{e}" if OPTIONS[:debug]
+              end
+            end
+          rescue => e
+            puts "Error in pipe thread: #{e}" if OPTIONS[:debug]
+          end
+          
+          # Small sleep to prevent CPU hogging
+          sleep 0.01
+        end
       end
     end
+    
+    def publish_to_pipe(msg, process: nil, stream: nil)
+      source_info = "[#{process || 'unknown'}:#{stream || 'unknown'}]"
+      puts "Publish to pipe #{source_info}: #{msg}" if OPTIONS[:debug]
+      
+      @pipe_queue.push(msg) if @pipe_queue
+    end
 
     def handle_command(cmd)
       puts "Received command: #{cmd}" if OPTIONS[:debug]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: discourse-systray
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - Sam Saffron
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-01-26 00:00:00.000000000 Z
+date: 2025-03-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gtk3