brainiac 0.0.6 → 0.0.8

data/monitor/{view-logs-rofi.rb → waybar/view_logs.rb}

@@ -1,76 +1,21 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-# Brainiac Log Viewer (Rofi version)
-# Shows a rofi menu to select which agent log to tail
-# Non-blocking, safe for waybar on-click
-
-require "json"
-require "net/http"
-require "socket"
-
-SOCKET_PATH = "/tmp/brainiac-monitor.sock"
-API_URL = "http://localhost:4567/api/status"
-CONFIG_PATH = File.expand_path("~/.brainiac/waybar.json")
-
-# Load agent configuration from JSON
-def load_agent_config
-  config = JSON.parse(File.read(CONFIG_PATH))
-  agents = {}
-  config["agents"].each do |agent|
-    agents[agent["name"].downcase] = agent["emoji"]
-  end
-  default_emoji = config["default_emoji"] || "❓"
-  [agents, default_emoji]
-rescue StandardError => e
-  warn "Failed to load waybar.json: #{e.message}"
-  [{}, "❓"]
-end
+# Brainiac Log Viewer (Linux — rofi/fuzzel/wofi/zenity/fzf)
+# Shows a menu to select which agent log to tail, with kill support.
 
-AGENTS, DEFAULT_EMOJI = load_agent_config
-
-def fetch_state_from_socket
-  socket = UNIXSocket.new(SOCKET_PATH)
-  data = socket.read
-  socket.close
-  JSON.parse(data)
-end
+require_relative "../shared"
 
-def fetch_state_from_api
-  uri = URI(API_URL)
-  response = Net::HTTP.get_response(uri)
-  return nil unless response.is_a?(Net::HTTPSuccess)
+AGENTS = load_agent_config.freeze
+INFRA_CMDS = %w[kiro-cli-chat ruby-lsp clangd gopls].freeze
 
-  JSON.parse(response.body)
-end
+state = fetch_state
 
-def fetch_state
-  # Prefer socket (daemon mode) — faster, no HTTP overhead
-  fetch_state_from_socket
-rescue Errno::ENOENT, Errno::ECONNREFUSED
-  # Daemon not running — fall back to direct API call
-  data = fetch_state_from_api
-  unless data
-    system("notify-send", "Brainiac", "Server not reachable")
-    exit 1
-  end
-  data
-rescue StandardError => e
-  system("notify-send", "Brainiac Error", e.message)
+if state["error"]
+  system("notify-send", "Brainiac Error", state["error"])
   exit 1
 end
 
-def format_elapsed(seconds)
-  return "#{seconds}s" if seconds < 60
-
-  minutes = seconds / 60
-  return "#{minutes}m" if minutes < 60
-
-  hours = minutes / 60
-  "#{hours}h"
-end
-
-state = fetch_state
 sessions = state["sessions"] || []
 
 if sessions.empty?
@@ -78,24 +23,15 @@ if sessions.empty?
   exit 0
 end
 
-INFRA_CMDS = %w[kiro-cli-chat ruby-lsp clangd gopls].freeze
-
 # Build menu entries: sessions + their child processes
 entries = []
 sessions.each do |s|
   agent = s["agent"]
   elapsed = format_elapsed(s["elapsed_seconds"])
-  card_key = s["card_key"]
-  context = if card_key.start_with?("discord-")
-              "Discord chat"
-            elsif card_key.start_with?("card-")
-              card_key.split("-")[1]
-            else
-              card_key
-            end
-  emoji = AGENTS[agent.downcase] || DEFAULT_EMOJI
+  context = format_context(s["card_key"])
+  emoji = AGENTS.dig(agent&.downcase, :emoji) || DEFAULT_EMOJI
   entries << { display: "#{emoji} #{agent}: #{context} (#{elapsed})", type: :log, log: s["log_file"] }
-  entries << { display: "   ⛔ Kill session: #{agent} (#{context})", type: :kill_session, card_key: card_key, agent: agent }
+  entries << { display: "   ⛔ Kill session: #{agent} (#{context})", type: :kill_session, card_key: s["card_key"], agent: agent }
 
   (s["children"] || []).each do |c|
     cmd_short = c["cmd"].to_s.split("/").last.to_s.split.first.to_s
@@ -116,7 +52,7 @@ if entries.size == 1 && entries[0][:type] == :log
 end
 
 def find_launcher
-  %w[rofi fuzzel wofi zenity].find { |cmd| system("which #{cmd} > /dev/null 2>&1") }
+  %w[rofi fuzzel wofi zenity fzf].find { |cmd| system("which #{cmd} > /dev/null 2>&1") }
 end
 
 def run_menu(launcher, entries)
@@ -147,12 +83,14 @@ def run_menu(launcher, entries)
       io.close_write
       io.read.strip
     end
+  when "fzf"
+    `echo "#{menu_text}" | fzf --prompt="Agent Sessions: "`.strip
   end
 end
 
 launcher = find_launcher
 unless launcher
-  system("notify-send", "Brainiac", "No menu launcher found (install rofi, fuzzel, wofi, or zenity)")
+  system("notify-send", "Brainiac", "No menu launcher found (install rofi, fuzzel, wofi, zenity, or fzf)")
   exit 1
 end
 
@@ -165,30 +103,25 @@ unless selected_line.to_s.empty?
     when :log
       spawn("alacritty", "-e", "tail", "-f", selected[:log]) if selected[:log]
     when :kill_session
-      card_key = selected[:card_key]
-      uri = URI("http://localhost:4567/api/sessions/kill/#{card_key}")
+      uri = URI("#{SERVER_URL}/api/sessions/kill/#{selected[:card_key]}")
       response = Net::HTTP.post(uri, "", { "Content-Type" => "application/json" })
-      if response.is_a?(Net::HTTPSuccess)
-        system("notify-send", "Brainiac", "Killed session: #{selected[:agent]}")
-      else
-        system("notify-send", "Brainiac", "Failed to kill session: #{selected[:agent]}")
-      end
+      msg = response.is_a?(Net::HTTPSuccess) ? "Killed session: #{selected[:agent]}" : "Failed to kill session: #{selected[:agent]}"
+      system("notify-send", "Brainiac", msg)
     when :kill_child
-      pid = selected[:pid]
       begin
-        Process.kill("TERM", pid)
+        Process.kill("TERM", selected[:pid])
       rescue StandardError
         nil
       end
       Thread.new do
         sleep 3
         begin
-          Process.kill("KILL", pid)
+          Process.kill("KILL", selected[:pid])
         rescue StandardError
           nil
         end
       end
-      system("notify-send", "Brainiac", "Killed #{selected[:cmd]} (PID #{pid})")
+      system("notify-send", "Brainiac", "Killed #{selected[:cmd]} (PID #{selected[:pid]})")
     end
   end
 end

data/monitor/{deploy-env-macos.rb → xbar/deploy_env.rb}

@@ -59,8 +59,9 @@ unless worktree
 end
 
 unless worktree
-  system("osascript", "-e",
-         "display dialog \"No worktree found for card ##{card_number}\" buttons {\"OK\"} default button \"OK\" with title \"Deploy Failed\" with icon stop")
+  dialog = "display dialog \"No worktree found for card ##{card_number}\" " \
+           "buttons {\"OK\"} default button \"OK\" with title \"Deploy Failed\" with icon stop"
+  system("osascript", "-e", dialog)
   exit
 end
 

data/monitor/xbar/plugin.rb

@@ -0,0 +1,149 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Brainiac macOS Menu Bar Plugin (xbar/SwiftBar)
+# Outputs xbar-format text: sessions, recent, deployments.
+
+require "shellwords"
+require "time"
+require_relative "../shared"
+
+SELF_PATH = File.realpath(__FILE__)
+AGENTS = load_agent_config.freeze
+CONFIG = load_monitor_config.freeze
+
+# URL patterns for different session types — configured in ~/.brainiac/waybar.json or monitor config
+# Plugins can add their patterns here via the config file.
+
+LOG_VIEWER_PATH = File.join(File.dirname(SELF_PATH), "view_logs.rb")
+DEPLOY_SCRIPT_PATH = File.join(File.dirname(SELF_PATH), "deploy_env.rb")
+OPEN_SCRIPT = File.join(File.dirname(SELF_PATH), "open_action.sh")
+
+def log_action(log_file)
+  return "" unless log_file
+
+  " | shell=#{LOG_VIEWER_PATH} param1=#{log_file} terminal=false refresh=false"
+end
+
+def full_log_action(log_file)
+  return "" unless log_file
+
+  " | shell=#{OPEN_SCRIPT} param1=#{log_file.shellescape} terminal=false refresh=false"
+end
+
+def prompt_url(session)
+  # Prefer URL provided directly by the source plugin in session data
+  return session["url"] if session.is_a?(Hash) && session["url"]
+
+  nil
+end
+
+def prompt_action(session)
+  url = prompt_url(session)
+  url ? " | shell=#{OPEN_SCRIPT} param1=#{url} terminal=false refresh=false" : ""
+end
+
+def worktree_path(log_file, card_key)
+  return nil unless log_file && card_key&.start_with?("card-")
+
+  dir = File.dirname(log_file, 2)
+  dir if File.directory?(dir) && dir != "/"
+end
+
+def worktree_action(log_file, card_key)
+  path = worktree_path(log_file, card_key)
+  path ? " | shell=#{OPEN_SCRIPT} param1=#{path.shellescape} terminal=false refresh=false" : ""
+end
+
+def render_session_submenu(session)
+  lines = tail_log(session["log_file"]).map { |line| "-- #{format_log_line(line)} | font=#{LOG_FONT} size=#{LOG_SIZE}" }
+  lines << "-- ---" if session["log_file"]
+  lines << "-- Tail Log#{log_action(session["log_file"])}" if session["log_file"]
+  lines << "-- View Full Log#{full_log_action(session["log_file"])}" if session["log_file"]
+  lines << "-- Open Prompt#{prompt_action(session)}" unless prompt_url(session).nil?
+  wt = worktree_path(session["log_file"], session["card_key"])
+  lines << "-- Open Worktree#{worktree_action(session["log_file"], session["card_key"])}" if wt
+  lines
+end
+
+def generate_output
+  state = fetch_state
+  deployments = fetch_deployments
+
+  return ["⚠️", "---", state["error"], "---", "Refresh | refresh=true"].join("\n") if state["error"] && !deployments
+
+  sessions = state["sessions"] || []
+  recent = state["recent"] || []
+  lines = []
+
+  # Title line
+  parts = []
+  parts << sessions.map { |s| AGENTS.dig(s["agent"]&.downcase, :emoji) || DEFAULT_EMOJI }.join(" ") if sessions.any?
+  parts << deployments.map { |d| deploy_dot_emoji(d) }.join if deployments&.any?
+  lines << (parts.any? ? parts.join(" ") : "💤")
+  lines << "---"
+
+  # Active sessions
+  if sessions.any?
+    lines << "Active | size=12"
+    sessions.each do |s|
+      agent_key = (s["agent"] || "").downcase
+      emoji = AGENTS.dig(agent_key, :emoji) || DEFAULT_EMOJI
+      color = AGENTS.dig(agent_key, :color)
+      color_str = color ? " color=#{hex_color(color)}" : ""
+      context = format_context(s["card_key"])
+      elapsed = format_elapsed(s["elapsed_seconds"] || 0)
+      lines << "#{emoji} #{s["agent"]}: #{context} (#{elapsed}) |#{color_str}"
+      lines.concat(render_session_submenu(s))
+    end
+  else
+    lines << "No active sessions | size=12"
+  end
+
+  # Recent
+  if recent.any?
+    lines << "---"
+    lines << "Recent | size=12"
+    recent.each do |s|
+      emoji = AGENTS.dig((s["agent"] || "").downcase, :emoji) || DEFAULT_EMOJI
+      context = format_context(s["card_key"])
+      ago = time_ago(s["finished_at"]) || "?"
+      lines << "#{emoji} #{s["agent"]}: #{context} — #{ago}"
+      lines.concat(render_session_submenu(s))
+    end
+  end
+
+  # Deployments
+  if deployments&.any?
+    lines << "---"
+    lines << "Deployments | size=12"
+    deployments.each do |d|
+      label = d["label"] || d["env"]
+      env = d["env"]
+      dot = deploy_dot_emoji(d)
+      if d["status"] == "occupied"
+        card = d["card_number"] ? "##{d["card_number"]}" : d["branch"] || "unknown"
+        ago = time_ago(d["deployed_at"])
+        status_label = case d["last_deploy_status"]
+                       when "deploying" then " — deploying…"
+                       when "failed" then " — FAILED"
+                       else ""
+                       end
+        line = "#{dot} #{label}: #{card}#{status_label}#{" (#{ago})" if ago}"
+        lines << (d["url"] ? "#{line} | href=#{d["url"]}" : line)
+      else
+        ago = time_ago(d["cleared_at"])
+        last = d["last_card"] ? " (was ##{d["last_card"]})" : ""
+        lines << "#{dot} #{label}: Available#{" #{ago}" if ago}#{last}"
+      end
+      lines << "-- Deploy to #{label} | shell=#{DEPLOY_SCRIPT_PATH} param1=#{env} terminal=false refresh=true"
+      lines << "-- Open #{label} | shell=#{OPEN_SCRIPT} param1=#{d["url"]} terminal=false refresh=false" if d["status"] == "occupied" && d["url"]
+    end
+  end
+
+  lines << "---"
+  lines << "Refresh | refresh=true"
+  lines.join("\n")
+end
+
+puts generate_output

data/monitor/{setup-menubar.rb → xbar/setup.rb}

@@ -1,8 +1,12 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-# One-time setup script to install Brainiac menubar plugin into xbar or SwiftBar
-# Run this once — the plugin will then auto-refresh on its configured interval
+# One-time setup: installs Brainiac menu bar plugin into xbar or SwiftBar.
+#
+# Detects which app is installed and symlinks the plugin.
+# Run this once — the plugin auto-refreshes on its configured interval.
+
+require "fileutils"
 
 PLUGIN_APPS = [
   {
@@ -18,7 +22,7 @@ PLUGIN_APPS = [
 ].freeze
 
 SYMLINK_NAME = "brainiac.2s.rb"
-SOURCE_PATH = File.join(File.dirname(File.expand_path(__FILE__)), "menubar.rb")
+SOURCE_PATH = File.join(File.dirname(File.expand_path(__FILE__)), "plugin.rb")
 
 def detect_plugin_app
   PLUGIN_APPS.each do |app|
@@ -27,33 +31,8 @@ def detect_plugin_app
   nil
 end
 
-def install_plugin(plugin_dir, source_path)
-  FileUtils.mkdir_p(plugin_dir)
-  link_path = File.join(plugin_dir, SYMLINK_NAME)
-
-  # Remove existing symlink/file if present
-  File.delete(link_path) if File.exist?(link_path) || File.symlink?(link_path)
-
-  File.symlink(source_path, link_path)
-rescue StandardError => e
-  warn "✗ Failed to create symlink: #{e.message}"
-  warn "  Source: #{source_path}"
-  warn "  Target: #{link_path}"
-  exit 1
-end
-
-def verify_executable!(path) # rubocop:disable Naming/PredicateMethod
-  unless File.executable?(path)
-    File.chmod(0o755, path)
-    warn "  Fixed executable permission on #{path}"
-  end
-  File.executable?(path)
-end
-
 # --- Main ---
 
-require "fileutils"
-
 app = detect_plugin_app
 
 unless app
@@ -69,10 +48,15 @@ unless app
 end
 
 puts "Detected #{app[:name]}"
-install_plugin(app[:plugin_dir], SOURCE_PATH)
-verify_executable!(SOURCE_PATH)
 
+FileUtils.mkdir_p(app[:plugin_dir])
 link_path = File.join(app[:plugin_dir], SYMLINK_NAME)
+
+File.delete(link_path) if File.exist?(link_path) || File.symlink?(link_path)
+File.symlink(SOURCE_PATH, link_path)
+File.chmod(0o755, SOURCE_PATH)
+
 puts "✓ Installed Brainiac plugin into #{app[:name]}"
 puts "  Symlink: #{link_path} → #{SOURCE_PATH}"
 puts "  Refresh interval: 2s"
+puts "  Restart #{app[:name]} to activate"