zillacore 0.0.1

data/monitor/waybar-deployments.rb

@@ -0,0 +1,239 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# ZillaCore Waybar Deployments Module
+# Polls /api/deployments and outputs JSON for waybar
+
+require "json"
+require "net/http"
+require "shellwords"
+require "uri"
+require "time"
+
+SERVER_URL = "http://localhost:4567"
+
+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
+  return "#{hours}h ago" if hours < 24
+
+  "#{hours / 24}d ago"
+end
+
+def generate_output
+  deployments = fetch_deployments
+  unless deployments
+    puts({ text: "", tooltip: "Deploy tracker: server unreachable", class: "error" }.to_json)
+    return
+  end
+
+  if deployments.empty?
+    puts({ text: "", tooltip: "No environments configured", class: "empty" }.to_json)
+    return
+  end
+
+  recent_window = 30 * 60 # 30 minutes
+
+  dots = deployments.map do |d|
+    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 == "failed"
+        '<span color="#ff4444" background="#440000">●</span>'
+      elsif recent && status == "success"
+        '<span color="#4488ff">●</span>'
+      else
+        '<span color="#ff4444">●</span>'
+      end
+    else
+      '<span color="#44ff44">●</span>'
+    end
+  end
+  text = dots.join(" ")
+
+  # Determine CSS class based on deploy states
+  has_recent_success = deployments.any? do |d|
+    t = d["last_deploy_at"] || d["deployed_at"]
+    d["last_deploy_status"] == "success" && t && (Time.now - Time.parse(t)) < recent_window
+  end
+  has_failure = deployments.any? { |d| d["last_deploy_status"] == "failed" }
+
+  css_class = if has_failure
+                "deploy-failed"
+              elsif has_recent_success
+                "deploy-recent"
+              else
+                "deployments"
+              end
+
+  tooltip_lines = deployments.map do |d|
+    label = d["label"] || d["env"]
+    if d["status"] == "occupied"
+      card = d["card_number"] ? "##{d["card_number"]}" : d["branch"] || "unknown"
+      branch = d["branch"] ? " — #{d["branch"]}" : ""
+      ago = time_ago(d["deployed_at"])
+      status_icon = case d["last_deploy_status"]
+                    when "failed" then "💥"
+                    when "success"
+                      t = d["last_deploy_at"] || d["deployed_at"]
+                      t && (Time.now - Time.parse(t)) < recent_window ? "🚀✅" : "🔴"
+                    else "🔴"
+                    end
+      "#{status_icon} #{label}: #{card}#{branch}#{" (#{ago})" if ago}"
+    else
+      ago = time_ago(d["cleared_at"])
+      last = d["last_card"] ? " (was ##{d["last_card"]})" : ""
+      "🟢 #{label}: Available#{" #{ago}" if ago}#{last}"
+    end
+  end
+
+  puts({ text: text, tooltip: tooltip_lines.join("\n"), class: css_class }.to_json)
+end
+
+def resize_deploy_terminal
+  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
+  deployments = fetch_deployments
+  return unless deployments&.any?
+
+  # If any environment has a failed deploy, show the log
+  failed = deployments.find { |d| d["last_deploy_status"] == "failed" && d["last_deploy_log"] }
+  if failed && File.exist?(failed["last_deploy_log"].to_s)
+    spawn("alacritty", "-e", "bash", "-c",
+          "echo '=== Deploy failure: #{failed["label"] || failed["env"]} ===' && echo && cat #{Shellwords.escape(failed["last_deploy_log"])} && echo && echo 'Press Enter to close...' && read",
+          %i[out err] => "/dev/null")
+    return
+  end
+
+  # Otherwise open environment URLs
+  options = deployments.filter_map do |d|
+    url = d["url"]
+    next unless url
+
+    label = d["label"] || d["env"]
+    status = d["status"] == "occupied" ? "🔴" : "🟢"
+    card = d["card_number"] ? " ##{d["card_number"]}" : ""
+    ["#{status} #{label}#{card}", url]
+  end
+  return if options.empty?
+
+  if options.length == 1
+    spawn("xdg-open", options[0][1], %i[out err] => "/dev/null")
+  else
+    labels = options.map(&:first)
+    choice = `timeout 30 zenity --list --title="Open Environment" --column="Environment" #{labels.map do |l|
+      Shellwords.escape(l)
+    end.join(" ")} 2>/dev/null`.strip
+    return if choice.empty?
+
+    selected = options.find { |label, _| label == choice }
+    spawn("xdg-open", selected[1], %i[out err] => "/dev/null") if selected
+  end
+end
+
+def handle_deploy
+  deployments = fetch_deployments
+  return unless deployments&.any?
+
+  # Pick environment
+  envs = deployments.map { |d| [d["env"], d["label"] || d["env"]] }
+  if envs.length == 1
+    env_key = envs[0][0]
+  else
+    labels = envs.map { |key, label| "#{key}|#{label}" }
+    choice = `timeout 30 zenity --list --title="Deploy to..." --column="Env" --column="Label" #{labels.map do |l|
+      l.split("|").map do |p|
+        Shellwords.escape(p)
+      end.join(" ")
+    end.join(" ")} 2>/dev/null`.strip
+    return if choice.empty?
+
+    env_key = choice
+  end
+
+  # Get card number — pre-fill with current card if environment is occupied
+  selected_dep = deployments.find { |d| d["env"] == env_key }
+  prefill = selected_dep && selected_dep["status"] == "occupied" && selected_dep["card_number"] ? selected_dep["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?
+
+  # Resolve worktree via glob (same pattern as fz shell function)
+  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
+
+  deploy_script = <<~BASH
+    cd #{Shellwords.escape(worktree)}
+    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
+
+if ARGV.include?("--click")
+  handle_click
+elsif ARGV.include?("--deploy")
+  handle_deploy
+else
+  generate_output
+end

data/monitor/waybar.rb

@@ -0,0 +1,146 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# ZillaCore Waybar Module
+# Reads from monitor daemon socket and outputs JSON for waybar
+# Single module that updates content dynamically (no config rewrites)
+
+require "json"
+require "socket"
+require "net/http"
+
+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
+  agents
+rescue StandardError => e
+  warn "Failed to load waybar.json: #{e.message}"
+  {}
+end
+
+AGENTS = load_agent_config.freeze
+DEFAULT_EMOJI = "❓"
+
+def normalize_agent_name(name)
+  name.downcase
+end
+
+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
+  fetch_state_from_api || { "sessions" => [], "count" => 0, "error" => "server not reachable" }
+rescue StandardError => e
+  { "sessions" => [], "count" => 0, "error" => e.message }
+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
+
+INFRA_CMDS = %w[kiro-cli-chat ruby-lsp clangd gopls].freeze
+
+def infra_process?(cmd_short)
+  INFRA_CMDS.any? { |ic| cmd_short.start_with?(ic) }
+end
+
+def escape_pango(str)
+  str.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;")
+end
+
+def generate_output
+  state = fetch_state
+
+  if state["error"]
+    return {
+      text: "⚠️",
+      tooltip: "ZillaCore Error: #{escape_pango(state["error"])}",
+      class: "error"
+    }
+  end
+
+  sessions = state["sessions"] || []
+
+  if sessions.empty?
+    return {
+      text: "💤",
+      tooltip: "No active agent sessions",
+      class: "idle"
+    }
+  end
+
+  # Build text: show emoji for each active agent
+  text_parts = sessions.map { |s| AGENTS[normalize_agent_name(s["agent"])] || DEFAULT_EMOJI }
+  text = text_parts.join(" ")
+
+  # Build tooltip
+  tooltip_lines = sessions.map do |s|
+    agent_display = s["agent"]
+    emoji = AGENTS[normalize_agent_name(agent_display)] || DEFAULT_EMOJI
+    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
+
+    lines = ["#{emoji} #{agent_display}: #{context} (#{elapsed})"]
+
+    children = (s["children"] || []).reject do |c|
+      cmd_short = c["cmd"].to_s.split("/").last.to_s.split.first.to_s
+      infra_process?(cmd_short)
+    end
+
+    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?
+      lines << "   └ #{escape_pango(cmd_short)} (#{format_elapsed(c["elapsed_seconds"])}) [PID #{c["pid"]}]"
+    end
+
+    lines.join("\n")
+  end
+
+  tooltip_lines << "\n[Click to manage]"
+
+  {
+    text: text,
+    tooltip: tooltip_lines.join("\n"),
+    class: "working"
+  }
+end
+
+puts generate_output.to_json

data/monitor/xbar.3s.rb

@@ -0,0 +1,179 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# ZillaCore xbar Plugin (macOS menu bar)
+# Reads from monitor daemon socket and outputs xbar-formatted text
+# Filename encodes refresh interval: xbar.3s.rb = every 3 seconds
+#
+# <xbar.title>ZillaCore Agent Monitor</xbar.title>
+# <xbar.version>v1.0</xbar.version>
+# <xbar.author>ZillaCore</xbar.author>
+# <xbar.desc>Shows active AI agent sessions in the macOS menu bar</xbar.desc>
+# <xbar.dependencies>ruby</xbar.dependencies>
+
+require "json"
+require "shellwords"
+require "socket"
+
+SOCKET_PATH = "/tmp/zillacore-monitor.sock"
+CONFIG_PATH = File.expand_path("~/.zillacore/waybar.json")
+
+def load_agent_config
+  config = JSON.parse(File.read(CONFIG_PATH))
+  agents = {}
+  config["agents"].each do |agent|
+    agents[agent["name"].downcase] = { emoji: agent["emoji"], color: agent["color"] }
+  end
+  [agents, config["default_emoji"] || "❓"]
+rescue StandardError
+  [{}, "❓"]
+end
+
+AGENTS, DEFAULT_EMOJI = load_agent_config
+
+COLOR_MAP = {
+  "red" => "#ff5555", "green" => "#50fa7b", "blue" => "#8be9fd",
+  "yellow" => "#f1fa8c", "cyan" => "#8be9fd", "magenta" => "#ff79c6",
+  "purple" => "#bd93f9", "pink" => "#ff79c6", "white" => "#f8f8f2"
+}.freeze
+
+def hex_color(name)
+  COLOR_MAP[name] || name
+end
+
+def fetch_state
+  socket = UNIXSocket.new(SOCKET_PATH)
+  data = socket.read
+  socket.close
+  JSON.parse(data)
+rescue Errno::ENOENT
+  { "error" => "daemon not running" }
+rescue StandardError => e
+  { "error" => e.message }
+end
+
+def format_elapsed(seconds)
+  return "#{seconds}s" if seconds < 60
+
+  minutes = seconds / 60
+  return "#{minutes}m" if minutes < 60
+
+  "#{minutes / 60}h"
+end
+
+def format_context(card_key)
+  return "" unless card_key
+
+  if card_key.start_with?("discord-")
+    "Discord"
+  elsif card_key.start_with?("card-")
+    "##{card_key.split("-")[1]}"
+  else
+    card_key
+  end
+end
+
+def time_ago(iso_string)
+  return nil unless iso_string
+
+  seconds = (Time.now - Time.parse(iso_string)).to_i
+  "#{format_elapsed(seconds)} ago"
+rescue StandardError
+  nil
+end
+
+ANSI_REGEX = /\e\[[0-9;]*[a-zA-Z]|\e\[\?[0-9;]*[a-zA-Z]/
+LOG_PREVIEW_LINES = 15
+LOG_LINE_MAX = 80
+LOG_FONT = "SFMono-Regular"
+LOG_SIZE = 12
+
+def tail_log(log_file, lines: LOG_PREVIEW_LINES)
+  return [] unless log_file && File.exist?(log_file)
+
+  raw = `tail -n 50 #{log_file.shellescape} 2>/dev/null`
+  raw.encode("UTF-8", invalid: :replace, undef: :replace, replace: "")
+     .lines
+     .map { |l| l.gsub(ANSI_REGEX, "").gsub(/[^[:print:]\t]/, "").strip }
+     .reject(&:empty?)
+     .last(lines)
+rescue StandardError
+  []
+end
+
+def format_log_line(text)
+  text.length > LOG_LINE_MAX ? "#{text[0, LOG_LINE_MAX]}…" : text
+end
+
+state = fetch_state
+
+if state["error"]
+  puts "⚠️ | color=red"
+  puts "---"
+  puts "ZillaCore: #{state["error"]} | color=red"
+  exit
+end
+
+sessions = state["sessions"] || []
+recent = state["recent"] || []
+view_logs_script = File.join(__dir__, "view-logs-macos.rb")
+
+# Menu bar title
+if sessions.any?
+  puts sessions.map { |s| AGENTS.dig(s["agent"]&.downcase, :emoji) || DEFAULT_EMOJI }.join(" ")
+else
+  puts "💤"
+end
+
+puts "---"
+
+# Active sessions
+if sessions.any?
+  puts "Active | size=12"
+  sessions.each do |s|
+    agent = s["agent"] || "Unknown"
+    info = AGENTS[agent.downcase] || {}
+    emoji = info[:emoji] || DEFAULT_EMOJI
+    color = info[:color] ? " | color=#{hex_color(info[:color])}" : ""
+    elapsed = format_elapsed(s["elapsed_seconds"] || 0)
+    context = format_context(s["card_key"])
+
+    puts "#{emoji} #{agent}: #{context} (#{elapsed})#{color}"
+
+    log_lines = tail_log(s["log_file"])
+    if log_lines.any?
+      log_lines.each do |line|
+        puts "-- #{format_log_line(line)} | font=#{LOG_FONT} size=#{LOG_SIZE}"
+      end
+      puts "-- ---"
+    end
+
+    puts "-- Open Full Log | shell=#{view_logs_script} param1=#{s["log_file"]} terminal=false refresh=false" if s["log_file"]
+  end
+else
+  puts "No active sessions | size=12"
+end
+
+# Recent completed sessions
+if recent.any?
+  puts "---"
+  puts "Recent | size=12"
+  recent.each do |s|
+    agent = s["agent"] || "Unknown"
+    emoji = AGENTS.dig(agent.downcase, :emoji) || DEFAULT_EMOJI
+    context = format_context(s["card_key"])
+    ago = time_ago(s["finished_at"]) || "?"
+
+    puts "#{emoji} #{agent}: #{context} — #{ago}"
+
+    log_lines = tail_log(s["log_file"])
+    if log_lines.any?
+      log_lines.each do |line|
+        puts "-- #{format_log_line(line)} | font=#{LOG_FONT} size=#{LOG_SIZE}"
+      end
+      puts "-- ---"
+    end
+
+    puts "-- Open Full Log | shell=#{view_logs_script} param1=#{s["log_file"]} terminal=false refresh=false" if s["log_file"]
+  end
+end