zillacore 0.0.1

data/lib/zillacore/zoho_mail_api.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+# Zoho Mail REST API client for fetching email content.
+# Used when webhook payloads don't include the body (which is most of the time).
+#
+# Requires zoho.json to have:
+#   "api": {
+#     "client_id": "...",
+#     "client_secret": "...",
+#     "refresh_token": "...",
+#     "account_id": "..."
+#   }
+
+ZOHO_TOKEN_URL = "https://accounts.zoho.com/oauth/v2/token"
+ZOHO_MAIL_API_BASE = "https://mail.zoho.com/api/accounts"
+
+# In-memory cache for access token (expires after ~55 min to be safe)
+@zoho_access_token = nil
+@zoho_token_expires_at = Time.at(0)
+
+def zoho_api_configured?
+  api = ZOHO_CONFIG["api"]
+  api && api["client_id"] && api["client_secret"] && api["refresh_token"] && api["account_id"]
+end
+
+def zoho_refresh_access_token!
+  api = ZOHO_CONFIG["api"]
+  uri = URI(ZOHO_TOKEN_URL)
+  res = Net::HTTP.post_form(uri, {
+                              "grant_type" => "refresh_token",
+                              "client_id" => api["client_id"],
+                              "client_secret" => api["client_secret"],
+                              "refresh_token" => api["refresh_token"]
+                            })
+
+  data = JSON.parse(res.body)
+  if data["access_token"]
+    @zoho_access_token = data["access_token"]
+    @zoho_token_expires_at = Time.now + 3300 # ~55 min
+    LOG.info "[Zoho:API] Refreshed access token"
+    @zoho_access_token
+  else
+    LOG.error "[Zoho:API] Token refresh failed: #{data["error"]}"
+    nil
+  end
+rescue StandardError => e
+  LOG.error "[Zoho:API] Token refresh error: #{e.message}"
+  nil
+end
+
+def zoho_access_token
+  return @zoho_access_token if @zoho_access_token && Time.now < @zoho_token_expires_at
+
+  zoho_refresh_access_token!
+end
+
+# Fetch email content by messageId using the "original message" endpoint.
+# This endpoint doesn't require a folder ID — just accountId + messageId.
+# Returns plain-text body extracted from the MIME content, or nil.
+def fetch_zoho_email_content(message_id)
+  return nil unless zoho_api_configured?
+
+  token = zoho_access_token
+  return nil unless token
+
+  account_id = ZOHO_CONFIG.dig("api", "account_id")
+  uri = URI("#{ZOHO_MAIL_API_BASE}/#{account_id}/messages/#{message_id}/originalmessage")
+
+  http = Net::HTTP.new(uri.host, uri.port)
+  http.use_ssl = true
+  req = Net::HTTP::Get.new(uri)
+  req["Authorization"] = "Zoho-oauthtoken #{token}"
+  req["Accept"] = "application/json"
+
+  res = http.request(req)
+  data = JSON.parse(res.body)
+
+  if data.dig("status", "code") == 200
+    raw_mime = data.dig("data", "content").to_s
+    text = extract_text_from_mime(raw_mime)
+    LOG.info "[Zoho:API] Fetched content for message #{message_id} (#{text.length} chars)"
+    text
+  else
+    LOG.warn "[Zoho:API] Failed to fetch content: #{data.dig("status", "description")}"
+    nil
+  end
+rescue StandardError => e
+  LOG.error "[Zoho:API] Error fetching content: #{e.message}"
+  nil
+end
+
+# Extract readable text from raw MIME content.
+# Prefers text/plain part; falls back to stripping HTML from text/html part.
+def extract_text_from_mime(mime)
+  # Try to find text/plain part
+  if mime =~ %r{Content-Type: text/plain[^\r\n]*\r?\n(?:Content-Transfer-Encoding:[^\r\n]*\r?\n)?(?:\r?\n)(.*?)(?:\r?\n------=_Part|\z)}mi
+    return Regexp.last_match(1).gsub("\r\n", "\n").strip
+  end
+
+  # Fallback: extract text/html part and strip tags
+  if mime =~ %r{Content-Type: text/html[^\r\n]*\r?\n(?:Content-Transfer-Encoding:[^\r\n]*\r?\n)?(?:\r?\n)(.*?)(?:\r?\n------=_Part|\z)}mi
+    html = Regexp.last_match(1).gsub("\r\n", "\n")
+    return html.gsub(/<[^>]+>/, " ").gsub(/&nbsp;/i, " ").gsub(/&amp;/i, "&")
+               .gsub(/&lt;/i, "<").gsub(/&gt;/i, ">").gsub(/\s+/, " ").strip
+  end
+
+  # Last resort: strip all HTML-ish content from the whole thing
+  mime.gsub(/<[^>]+>/, " ").gsub(/\s+/, " ").strip
+end

data/lib/zillacore.rb

@@ -0,0 +1,10 @@
+require_relative "zillacore/config"
+require_relative "zillacore/users"
+require_relative "zillacore/agents"
+require_relative "zillacore/brain"
+require_relative "zillacore/skills"
+require_relative "zillacore/sessions"
+require_relative "zillacore/prompts"
+require_relative "zillacore/planning"
+require_relative "zillacore/helpers"
+require_relative "zillacore/cron"

data/monitor/daemon.rb

@@ -0,0 +1,99 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# ZillaCore Monitor Daemon
+# Polls /api/status and exposes agent state via Unix socket for waybar
+# No longer triggers config updates - waybar module polls this socket directly
+
+require "json"
+require "net/http"
+require "socket"
+
+SOCKET_PATH = "/tmp/zillacore-monitor.sock"
+API_URL = "http://localhost:4567/api/status"
+POLL_INTERVAL = 2 # seconds
+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"]] = { color: agent["color"], emoji: agent["emoji"] }
+  end
+  agents
+rescue StandardError => e
+  warn "Failed to load waybar.json: #{e.message}"
+  {}
+end
+
+AGENTS = load_agent_config.freeze
+
+@state = { sessions: [], count: 0, recent: [], last_update: nil }
+
+def fetch_status
+  uri = URI(API_URL)
+  response = Net::HTTP.get_response(uri)
+  return nil unless response.is_a?(Net::HTTPSuccess)
+
+  JSON.parse(response.body)
+rescue StandardError => e
+  warn "Failed to fetch status: #{e.message}"
+  nil
+end
+
+def update_state
+  data = fetch_status
+  return unless data
+
+  @state = {
+    sessions: data["sessions"],
+    count: data["count"],
+    recent: data["recent"] || [],
+    last_update: Time.now.to_i
+  }
+end
+
+def handle_client(client)
+  client.puts @state.to_json
+  client.close
+rescue StandardError => e
+  warn "Error handling client: #{e.message}"
+end
+
+def start_server
+  FileUtils.rm_f(SOCKET_PATH)
+
+  server = UNIXServer.new(SOCKET_PATH)
+  File.chmod(0o666, SOCKET_PATH)
+
+  # Write PID file
+  File.write("/tmp/zillacore-daemon.pid", Process.pid)
+
+  puts "Monitor daemon started, socket: #{SOCKET_PATH}"
+
+  # Start polling thread
+  poller = Thread.new do
+    loop do
+      update_state
+      sleep POLL_INTERVAL
+    end
+  end
+
+  # Initial state fetch
+  update_state
+
+  # Accept client connections
+  loop do
+    client = server.accept
+    Thread.new { handle_client(client) }
+  end
+rescue Interrupt
+  puts "\nShutting down..."
+  poller&.kill
+  FileUtils.rm_f(SOCKET_PATH)
+  FileUtils.rm_f("/tmp/zillacore-daemon.pid")
+  exit 0
+end
+
+start_server

data/monitor/deploy-env-macos.rb

@@ -0,0 +1,131 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# ZillaCore macOS Deploy Action
+# Prompts for a Fizzy card number via osascript, finds the worktree, and deploys.
+# Usage: deploy-env-macos.rb <env_key>
+
+require "English"
+require "json"
+require "net/http"
+require "shellwords"
+require "uri"
+
+SERVER_URL = "http://localhost:4567"
+
+env_key = ARGV[0]
+exit unless env_key
+
+def fetch_deployments
+  uri = URI("#{SERVER_URL}/api/deployments")
+  response = Net::HTTP.get_response(uri)
+  JSON.parse(response.body)["deployments"] || []
+rescue StandardError
+  nil
+end
+
+deployments = fetch_deployments
+deployment = deployments&.find { |d| d["env"] == env_key }
+
+prefill = deployment && deployment["status"] == "occupied" && deployment["card_number"] ? deployment["card_number"].to_s : ""
+
+# Prompt via AppleScript
+prompt_script = <<~APPLESCRIPT
+  set defaultAnswer to "#{prefill}"
+  set dialogResult to display dialog "Fizzy card number:" default answer defaultAnswer with title "Deploy to #{env_key}" buttons {"Cancel", "Deploy"} default button "Deploy"
+  return text returned of dialogResult
+APPLESCRIPT
+
+card_number = `osascript -e #{Shellwords.escape(prompt_script)} 2>/dev/null`.strip
+exit if card_number.empty?
+
+# Find worktree via card_map.json
+card_map_path = File.expand_path("~/.zillacore/card_map.json")
+worktree = nil
+if File.exist?(card_map_path)
+  card_map = begin
+    JSON.parse(File.read(card_map_path))
+  rescue StandardError
+    {}
+  end
+  entry = card_map.values.find { |e| e["card_number"].to_s == card_number }
+  worktree = entry["worktree"] if entry && entry["worktree"] && File.directory?(entry["worktree"].to_s)
+end
+
+# Fallback: glob for worktree directories
+unless worktree
+  matches = Dir.glob(File.expand_path("~/projects/sogholdings/*fizzy-#{card_number}-*/"))
+  worktree = matches.find { |d| File.directory?(d) }
+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")
+  exit
+end
+
+# Resolve AWS_PROFILE
+config_file = File.expand_path("~/.zillacore/deployments.json")
+aws_profile = nil
+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
+
+# Mark deploying
+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
+end
+
+# Build deploy script
+deploy_script = <<~BASH
+  cd #{Shellwords.escape(worktree)}
+  #{"export AWS_PROFILE=#{Shellwords.escape(aws_profile)}" if aws_profile}
+  echo "🚀 Deploying card ##{card_number} to #{env_key}..."
+  echo "   Worktree: #{worktree}"
+  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
+  echo "Press any key to close..."
+  read -n 1
+BASH
+
+# Write to temp file and run in Terminal.app
+script_file = "/tmp/zillacore-deploy-#{env_key}-#{$PROCESS_ID}.sh"
+File.write(script_file, deploy_script)
+File.chmod(0o755, script_file)
+
+terminal_script = <<~APPLESCRIPT
+  tell application "Terminal"
+    activate
+    do script "#{script_file.gsub('"', '\\"')}; rm -f #{script_file.gsub('"', '\\"')}"
+  end tell
+APPLESCRIPT
+
+system("osascript", "-e", terminal_script)

data/monitor/menubar.rb

@@ -0,0 +1,295 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# ZillaCore macOS Menu Bar Plugin (xbar/SwiftBar)
+# Reads from monitor daemon socket and outputs xbar-format text
+# Mirrors monitor/waybar.rb patterns for macOS-native display
+
+require "json"
+require "net/http"
+require "shellwords"
+require "socket"
+require "time"
+require "uri"
+
+SERVER_URL = "http://localhost:4567"
+SOCKET_PATH = "/tmp/zillacore-monitor.sock"
+CONFIG_PATH = File.expand_path("~/.zillacore/waybar.json")
+DEFAULT_EMOJI = "❓"
+SELF_PATH = File.realpath(__FILE__)
+
+def load_config
+  JSON.parse(File.read(CONFIG_PATH))
+rescue StandardError => e
+  warn "Failed to load waybar.json: #{e.message}"
+  {}
+end
+
+CONFIG = load_config.freeze
+
+def load_agent_config
+  agents = {}
+  (CONFIG["agents"] || []).each do |agent|
+    agents[agent["name"].downcase] = { emoji: agent["emoji"], color: agent["color"] }
+  end
+  agents
+end
+
+AGENTS = load_agent_config.freeze
+FIZZY_ACCOUNT_ID = CONFIG["fizzy_account_id"]
+DISCORD_GUILD_ID = CONFIG["discord_guild_id"]
+
+def fetch_state
+  socket = UNIXSocket.new(SOCKET_PATH)
+  data = socket.read
+  socket.close
+  JSON.parse(data)
+rescue Errno::ENOENT
+  { "sessions" => [], "count" => 0, "recent" => [], "error" => "daemon not running" }
+rescue StandardError => e
+  { "sessions" => [], "count" => 0, "recent" => [], "error" => e.message }
+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
+
+DEPLOY_RECENT_WINDOW = 30 * 60
+
+def deploy_dot(dep)
+  status = dep["last_deploy_status"]
+  if status == "deploying"
+    "🟠"
+  elsif status == "failed"
+    "💥"
+  elsif dep["status"] == "occupied"
+    deploy_time = dep["last_deploy_at"] || dep["deployed_at"]
+    recent = deploy_time && (Time.now - Time.parse(deploy_time)) < DEPLOY_RECENT_WINDOW
+    recent ? "🚀" : "🔴"
+  else
+    "🟢"
+  end
+end
+
+LOG_VIEWER_PATH = File.join(File.dirname(SELF_PATH), "view-logs-macos.rb")
+DEPLOY_SCRIPT_PATH = File.join(File.dirname(SELF_PATH), "deploy-env-macos.rb")
+
+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
+
+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
+
+def log_action(log_file)
+  return "" unless log_file
+
+  " | shell=#{LOG_VIEWER_PATH} param1=#{log_file} terminal=false refresh=false"
+end
+
+OPEN_SCRIPT = File.join(File.dirname(SELF_PATH), "open-action.sh")
+
+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(card_key)
+  return nil unless card_key
+
+  if card_key.start_with?("card-")
+    card_num = card_key.split("-")[1]
+    "https://app.fizzy.do/#{FIZZY_ACCOUNT_ID}/cards/#{card_num}" if FIZZY_ACCOUNT_ID && card_num
+  elsif card_key.start_with?("discord-") && DISCORD_GUILD_ID
+    parts = card_key.split("-")
+    # discord-AGENT-CHANNEL_ID-MESSAGE_ID (agent name may contain hyphens, IDs are last two numeric parts)
+    channel_id = parts[-2]
+    message_id = parts[-1]
+    "https://discord.com/channels/#{DISCORD_GUILD_ID}/#{channel_id}/#{message_id}" if channel_id && message_id
+  end
+end
+
+def prompt_action(card_key)
+  url = prompt_url(card_key)
+  return "" unless 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)
+  return "" unless path
+
+  " | shell=#{OPEN_SCRIPT} param1=#{path.shellescape} terminal=false refresh=false"
+end
+
+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 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 — agent emojis + deploy dots
+  parts = []
+  parts << sessions.map { |s| AGENTS.dig(s["agent"]&.downcase, :emoji) || DEFAULT_EMOJI }.join(" ") if sessions.any?
+  parts << deployments.map { |d| deploy_dot(d) }.join if deployments&.any?
+  title = parts.any? ? parts.join(" ") : "💤"
+  lines << title
+  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}"
+
+      tail_log(s["log_file"]).each do |line|
+        lines << "-- #{format_log_line(line)} | font=#{LOG_FONT} size=#{LOG_SIZE}"
+      end
+      lines << "-- ---" if s["log_file"]
+      lines << "-- Tail Log#{log_action(s["log_file"])}" if s["log_file"]
+      lines << "-- View Full Log#{full_log_action(s["log_file"])}" if s["log_file"]
+      lines << "-- Open Prompt#{prompt_action(s["card_key"])}" unless prompt_url(s["card_key"]).nil?
+      wt = worktree_path(s["log_file"], s["card_key"])
+      lines << "-- Open Worktree#{worktree_action(s["log_file"], s["card_key"])}" if wt
+    end
+  else
+    lines << "No active sessions | size=12"
+  end
+
+  # Recent completed sessions
+  if recent.any?
+    lines << "---"
+    lines << "Recent | size=12"
+    recent.each do |s|
+      agent_key = (s["agent"] || "").downcase
+      emoji = AGENTS.dig(agent_key, :emoji) || DEFAULT_EMOJI
+      context = format_context(s["card_key"])
+      ago = time_ago(s["finished_at"]) || "?"
+      lines << "#{emoji} #{s["agent"]}: #{context} — #{ago}"
+
+      tail_log(s["log_file"]).each do |line|
+        lines << "-- #{format_log_line(line)} | font=#{LOG_FONT} size=#{LOG_SIZE}"
+      end
+      lines << "-- ---" if s["log_file"]
+      lines << "-- Tail Log#{log_action(s["log_file"])}" if s["log_file"]
+      lines << "-- View Full Log#{full_log_action(s["log_file"])}" if s["log_file"]
+      lines << "-- Open Prompt#{prompt_action(s["card_key"])}" unless prompt_url(s["card_key"]).nil?
+      wt = worktree_path(s["log_file"], s["card_key"])
+      lines << "-- Open Worktree#{worktree_action(s["log_file"], s["card_key"])}" if wt
+    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(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}"
+        url = d["url"]
+        lines << (url ? "#{line} | href=#{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/open-action.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+# Opens a URL in browser, a directory in Finder, or a file in the default viewer.
+# Used by the SwiftBar menubar plugin for prompt links, worktrees, and full log views.
+
+arg="$1"
+
+if [[ "$arg" == https://discord.com/* ]]; then
+  open "discord://${arg#https://}"
+elif [[ "$arg" == http* ]]; then
+  open "$arg"
+elif [[ -d "$arg" ]]; then
+  open -a Kiro "$arg"
+elif [[ -f "$arg" ]]; then
+  open -a "Console" "$arg" 2>/dev/null || open "$arg"
+fi