zillacore 0.0.1

data/monitor/view-logs-rofi.rb

@@ -0,0 +1,194 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# ZillaCore 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/zillacore-monitor.sock"
+API_URL = "http://localhost:4567/api/status"
+CONFIG_PATH = File.expand_path("~/.zillacore/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
+
+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
+
+def fetch_state_from_api
+  uri = URI(API_URL)
+  response = Net::HTTP.get_response(uri)
+  return nil unless response.is_a?(Net::HTTPSuccess)
+
+  JSON.parse(response.body)
+end
+
+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", "ZillaCore", "Server not reachable")
+    exit 1
+  end
+  data
+rescue StandardError => e
+  system("notify-send", "ZillaCore Error", e.message)
+  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?
+  system("notify-send", "ZillaCore", "No active agent sessions")
+  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
+  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 }
+
+  (s["children"] || []).each do |c|
+    cmd_short = c["cmd"].to_s.split("/").last.to_s.split.first.to_s
+    cmd_short = c["cmd"].to_s[0..40] if cmd_short.empty?
+    next if INFRA_CMDS.any? { |ic| cmd_short.start_with?(ic) }
+
+    entries << {
+      display: "   └ 🔪 Kill: #{cmd_short} (#{format_elapsed(c["elapsed_seconds"])}) [PID #{c["pid"]}]",
+      type: :kill_child, pid: c["pid"], cmd: cmd_short
+    }
+  end
+end
+
+# If only one session with no children, open log directly
+if entries.size == 1 && entries[0][:type] == :log
+  spawn("alacritty", "-e", "tail", "-f", entries[0][:log]) if entries[0][:log]
+  exit 0
+end
+
+def find_launcher
+  %w[rofi fuzzel wofi zenity].find { |cmd| system("which #{cmd} > /dev/null 2>&1") }
+end
+
+def run_menu(launcher, entries)
+  menu_text = entries.map { |e| e[:display] }.join("\n")
+  case launcher
+  when "rofi"
+    IO.popen(%w[rofi -dmenu -i -p] + ["Agent Sessions"], "r+") do |io|
+      io.puts menu_text
+      io.close_write
+      io.read.strip
+    end
+  when "fuzzel"
+    IO.popen(%w[fuzzel --dmenu --prompt] + ["Agent Sessions: "], "r+") do |io|
+      io.puts menu_text
+      io.close_write
+      io.read.strip
+    end
+  when "wofi"
+    IO.popen(%w[wofi --dmenu --prompt] + ["Agent Sessions"], "r+") do |io|
+      io.puts menu_text
+      io.close_write
+      io.read.strip
+    end
+  when "zenity"
+    IO.popen(["zenity", "--list", "--title", "Agent Sessions", "--column", "Session", "--width", "600", "--height", "400"], "r+",
+             err: "/dev/null") do |io|
+      entries.each { |e| io.puts e[:display] }
+      io.close_write
+      io.read.strip
+    end
+  end
+end
+
+launcher = find_launcher
+unless launcher
+  system("notify-send", "ZillaCore", "No menu launcher found (install rofi, fuzzel, wofi, or zenity)")
+  exit 1
+end
+
+selected_line = run_menu(launcher, entries)
+
+unless selected_line.to_s.empty?
+  selected = entries.find { |e| e[:display].strip == selected_line.strip }
+  if selected
+    case selected[:type]
+    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}")
+      response = Net::HTTP.post(uri, "", { "Content-Type" => "application/json" })
+      if response.is_a?(Net::HTTPSuccess)
+        system("notify-send", "ZillaCore", "Killed session: #{selected[:agent]}")
+      else
+        system("notify-send", "ZillaCore", "Failed to kill session: #{selected[:agent]}")
+      end
+    when :kill_child
+      pid = selected[:pid]
+      begin
+        Process.kill("TERM", pid)
+      rescue StandardError
+        nil
+      end
+      Thread.new do
+        sleep 3
+        begin
+          Process.kill("KILL", pid)
+        rescue StandardError
+          nil
+        end
+      end
+      system("notify-send", "ZillaCore", "Killed #{selected[:cmd]} (PID #{pid})")
+    end
+  end
+end

data/monitor/view-logs.rb

@@ -0,0 +1,119 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# ZillaCore Log Viewer
+# Shows a rofi menu to select which agent log to tail
+
+require "json"
+require "net/http"
+require "socket"
+
+SOCKET_PATH = "/tmp/zillacore-monitor.sock"
+API_URL = "http://localhost:4567/api/status"
+CONFIG_PATH = File.expand_path("~/.zillacore/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
+
+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
+
+def fetch_state_from_api
+  uri = URI(API_URL)
+  response = Net::HTTP.get_response(uri)
+  return nil unless response.is_a?(Net::HTTPSuccess)
+
+  JSON.parse(response.body)
+end
+
+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
+    puts "Error: Server not reachable"
+    exit 1
+  end
+  data
+rescue StandardError => e
+  puts "Error: #{e.message}"
+  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?
+  system("notify-send", "ZillaCore", "No active agent sessions")
+  exit 0
+end
+
+# If only one session, open it directly
+if sessions.size == 1
+  log_file = sessions[0]["log_file"]
+  exec("alacritty", "-e", "tail", "-f", log_file) if log_file
+  exit 0
+end
+
+# Multiple sessions: use fzf if available, otherwise just open the first one
+if system("which fzf > /dev/null 2>&1")
+  # Build fzf menu
+  options = sessions.map 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
+
+    "#{emoji} #{agent}: #{context} (#{elapsed})|#{s["log_file"]}"
+  end
+
+  menu_text = options.join("\n")
+  selected = `echo "#{menu_text}" | fzf --prompt="Agent Logs: "`.strip
+
+  unless selected.empty?
+    log_file = selected.split("|").last
+    exec("alacritty", "-e", "tail", "-f", log_file)
+  end
+else
+  # No menu system, just open the first log
+  log_file = sessions[0]["log_file"]
+  exec("alacritty", "-e", "tail", "-f", log_file) if log_file
+end

data/monitor/waybar-config-updater.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# ZillaCore Waybar Config Updater
+# Dynamically updates waybar config with per-agent modules
+
+require "json"
+
+WAYBAR_CONFIG = File.expand_path("~/.config/waybar/config.jsonc")
+WAYBAR_SCRIPT = File.expand_path("~/Code/zillacore/monitor/waybar.rb")
+
+def load_config
+  content = File.read(WAYBAR_CONFIG)
+  # Strip comments for JSON parsing
+  json_content = content.lines.reject { |line| line.strip.start_with?("//") }.join
+  JSON.parse(json_content)
+end
+
+def save_config(config)
+  File.write(WAYBAR_CONFIG, JSON.pretty_generate(config))
+end
+
+def zillacore_modules
+  output = `#{WAYBAR_SCRIPT} --config`
+  JSON.parse(output)
+end
+
+# Load current config
+config = load_config
+
+# Get dynamic ZillaCore modules
+zillacore_data = zillacore_modules
+modules = zillacore_data["modules"]
+module_configs = zillacore_data["config"]
+
+# Remove old zillacore modules and groups from modules-right
+config["modules-right"].reject! { |m| m.to_s.start_with?("custom/zillacore") || m.to_s == "group/zillacore-agents" }
+
+# Insert new modules at the beginning of modules-right
+config["modules-right"] = modules + config["modules-right"]
+
+# Remove old zillacore module configs and groups
+config.each_key do |key|
+  config.delete(key) if key.to_s.start_with?("custom/zillacore") || key.to_s == "group/zillacore-agents"
+end
+
+# Add new module configs
+module_configs.each do |name, cfg|
+  config[name] = cfg
+end
+
+# Save updated config
+save_config(config)
+
+# Reload waybar
+system("killall", "-SIGUSR2", "waybar")

data/monitor/waybar-deploy-env.rb

@@ -0,0 +1,206 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# ZillaCore Waybar Per-Environment Deploy Module
+# Usage: waybar-deploy-env.rb <env_key>
+#        waybar-deploy-env.rb <env_key> --click
+#        waybar-deploy-env.rb <env_key> --deploy
+
+require "json"
+require "net/http"
+require "shellwords"
+require "uri"
+require "time"
+
+SERVER_URL = "http://localhost:4567"
+RECENT_WINDOW = 30 * 60
+
+env_key = ARGV.find { |a| !a.start_with?("--") }
+unless env_key
+  puts({ text: "?", tooltip: "No env specified", class: "error" }.to_json)
+  exit
+end
+
+def fetch_deployments
+  uri = URI("#{SERVER_URL}/api/deployments")
+  response = Net::HTTP.get_response(uri)
+  JSON.parse(response.body)["deployments"] || []
+rescue StandardError
+  nil
+end
+
+def time_ago(iso_time)
+  return nil unless iso_time
+
+  seconds = (Time.now - Time.parse(iso_time)).to_i
+  return "#{seconds}s ago" if seconds < 60
+
+  minutes = seconds / 60
+  return "#{minutes}m ago" if minutes < 60
+
+  hours = minutes / 60
+  "#{hours}h ago"
+end
+
+def resize_deploy_terminal
+  # Shrink the deploy terminal to ~15% width after it tiles in at 50%
+  # Calculates resize delta from monitor width dynamically
+  script = "sleep 0.5 && " \
+           'width=$(hyprctl monitors -j | ruby -rjson -e "puts JSON.parse(STDIN.read)[0][%q(width)]") && ' \
+           "delta=$(( (width / 2) - (width * 15 / 100) )) && " \
+           'hyprctl --batch "dispatch focuswindow class:zillacore-deploy; dispatch resizeactive -${delta} 0"'
+  spawn("bash", "-c", script, %i[out err] => "/dev/null")
+end
+
+def handle_click(env_key, deployment)
+  return unless deployment
+
+  if deployment["last_deploy_status"] == "failed" && deployment["last_deploy_log"]
+    log = deployment["last_deploy_log"]
+    if File.exist?(log.to_s)
+      spawn("alacritty", "--class", "zillacore-deploy", "-e", "bash", "-c",
+            "echo '=== Deploy failure: #{deployment["label"] || env_key} ===' && echo && cat #{Shellwords.escape(log)} && echo && echo 'Press Enter to close...' && read",
+            %i[out err] => "/dev/null")
+      resize_deploy_terminal
+      return
+    end
+  end
+
+  url = deployment["url"]
+  spawn("xdg-open", url, %i[out err] => "/dev/null") if url
+end
+
+def handle_deploy(env_key, deployment)
+  return unless deployment
+
+  prefill = deployment["status"] == "occupied" && deployment["card_number"] ? deployment["card_number"].to_s : ""
+  card_number = `timeout 60 zenity --entry --title="Deploy to #{env_key}" --text="Fizzy card number:"#{unless prefill.empty?
+                                                                                                         " --entry-text=#{Shellwords.escape(prefill)}"
+                                                                                                       end} 2>/dev/null`.strip
+  return if card_number.empty?
+
+  matches = Dir.glob(File.expand_path("~/Code/*fizzy-#{card_number}-*/"))
+  worktree = matches.find { |d| File.directory?(d) }
+  unless worktree
+    `timeout 10 zenity --error --text="No worktree found for card ##{card_number}" 2>/dev/null`
+    return
+  end
+
+  # Resolve AWS_PROFILE from deployments config
+  aws_profile = nil
+  config_file = File.expand_path("~/.zillacore/deployments.json")
+  if File.exist?(config_file)
+    cfg = begin
+      JSON.parse(File.read(config_file))
+    rescue StandardError
+      {}
+    end
+    aws_profile = cfg.dig("environments", env_key, "aws_profile")
+  end
+
+  deploy_script = <<~BASH
+    cd #{Shellwords.escape(worktree)}
+    #{"export AWS_PROFILE=#{Shellwords.escape(aws_profile)}" if aws_profile}
+    echo "🚀 #{env_key} deploy in progress..."
+    echo
+    logfile=$(mktemp)
+    ./scripts/deploy.sh #{Shellwords.escape(env_key)} 2>&1 | tee "$logfile"
+    status=${PIPESTATUS[0]}
+    if [ $status -ne 0 ] && grep -q "checksums previously recorded in the dependency lock file" "$logfile"; then
+      echo
+      echo "⚠️  Terraform lock file mismatch — removing lock and running init -upgrade..."
+      echo
+      rm -f infrastructure/#{Shellwords.escape(env_key)}/.terraform.lock.hcl
+      (cd infrastructure/#{Shellwords.escape(env_key)} && terraform init -upgrade)
+      echo
+      echo "🔄 Retrying deploy..."
+      echo
+      ./scripts/deploy.sh #{Shellwords.escape(env_key)} 2>&1
+      status=$?
+    fi
+    rm -f "$logfile"
+    echo
+    if [ $status -eq 0 ]; then echo "✅ Deploy complete"; else echo "❌ Deploy failed (exit $status)"; fi
+    echo "Press Enter to close..."
+    read
+  BASH
+
+  # Mark deploying via API so waybar turns orange immediately
+  begin
+    uri = URI("#{SERVER_URL}/api/deployments/#{env_key}/deploying")
+    req = Net::HTTP::Post.new(uri, "Content-Type" => "application/json")
+    req.body = { worktree: worktree }.to_json
+    Net::HTTP.start(uri.hostname, uri.port) { |http| http.request(req) }
+  rescue StandardError
+    # Non-fatal — deploy proceeds even if server is unreachable
+  end
+
+  spawn("alacritty", "--class", "zillacore-deploy", "-e", "bash", "-c", deploy_script, %i[out err] => "/dev/null")
+  resize_deploy_terminal
+end
+
+def generate_output(env_key)
+  deployments = fetch_deployments
+  unless deployments
+    puts({ text: "", tooltip: "#{env_key}: server unreachable", class: "error" }.to_json)
+    return
+  end
+
+  d = deployments.find { |dep| dep["env"] == env_key }
+  unless d
+    puts({ text: "", tooltip: "#{env_key}: not configured", class: "error" }.to_json)
+    return
+  end
+
+  label = d["label"] || env_key
+
+  if d["status"] == "occupied"
+    deploy_time = d["last_deploy_at"] || d["deployed_at"]
+    recent = deploy_time && (Time.now - Time.parse(deploy_time)) < RECENT_WINDOW
+    status = d["last_deploy_status"]
+
+    if status == "deploying"
+      dot = '<span color="#ffaa00">●</span>'
+      css_class = "deploy-deploying"
+    elsif status == "failed"
+      dot = '<span color="#ff4444">●</span>'
+      css_class = "deploy-failed"
+    elsif recent && status == "success"
+      dot = '<span color="#4488ff">●</span>'
+      css_class = "deploy-recent"
+    else
+      dot = '<span color="#ff4444">●</span>'
+      css_class = "deploy-occupied"
+    end
+
+    card = d["card_number"] ? "##{d["card_number"]}" : d["branch"] || "unknown"
+    branch = d["branch"] ? " — #{d["branch"]}" : ""
+    ago = time_ago(d["deployed_at"])
+    status_icon = case status
+                  when "deploying" then "🚀"
+                  when "failed" then "💥"
+                  when "success" then recent ? "🚀✅" : "🔴"
+                  else "🔴"
+                  end
+    tooltip = "#{status_icon} #{label}: #{card}#{branch}#{" (#{ago})" if ago}\nClick: open URL | Right-click: deploy"
+  else
+    dot = '<span color="#44ff44">●</span>'
+    css_class = "deploy-available"
+    ago = time_ago(d["cleared_at"])
+    last = d["last_card"] ? " (was ##{d["last_card"]})" : ""
+    tooltip = "🟢 #{label}: Available#{" #{ago}" if ago}#{last}\nRight-click: deploy"
+  end
+
+  puts({ text: dot, tooltip: tooltip, class: css_class }.to_json)
+end
+
+deployments = fetch_deployments
+deployment = deployments&.find { |d| d["env"] == env_key }
+
+if ARGV.include?("--click")
+  handle_click(env_key, deployment)
+elsif ARGV.include?("--deploy")
+  handle_deploy(env_key, deployment)
+else
+  generate_output(env_key)
+end