brainiac 0.0.11 → 0.0.13

data/lib/brainiac/handlers/zoho.rb

@@ -1,429 +0,0 @@
-# frozen_string_literal: true
-
-# Zoho Mail outgoing webhook handler.
-#
-# Zoho Mail fires outgoing webhooks when emails match configured conditions.
-# This handler receives those webhooks, verifies the HMAC-SHA256 signature,
-# and dispatches notifications to Discord.
-#
-# Config: ~/.brainiac/zoho.json
-# Docs: https://www.zoho.com/mail/help/dev-platform/webhook.html
-
-require "English"
-require_relative "../zoho_mail_api"
-
-ZOHO_CONFIG_FILE = File.join(BRAINIAC_DIR, "zoho.json")
-
-def load_zoho_config
-  return {} unless File.exist?(ZOHO_CONFIG_FILE)
-
-  JSON.parse(File.read(ZOHO_CONFIG_FILE))
-rescue JSON::ParserError => e
-  LOG.error "[Zoho] Failed to parse config: #{e.message}"
-  {}
-end
-
-ZOHO_CONFIG = load_zoho_config
-
-def reload_zoho_config!(force: false)
-  return unless file_changed?(ZOHO_CONFIG_FILE, force: force)
-
-  ZOHO_CONFIG.replace(load_zoho_config)
-  LOG.info "[Zoho] Reloaded configuration"
-end
-
-def default_project_config
-  key = default_project_key
-  key ? PROJECTS[key] : PROJECTS.values.first
-end
-
-def zoho_triage_project_tags
-  tags = ZOHO_CONFIG["triage_project_tags"]
-  return "Use your best judgement to identify the relevant project." unless tags&.any?
-
-  tags.map { |t| "  - `#{t["tag"]}` — #{t["description"]}" }.join("\n")
-end
-
-def zoho_triage_agent_assignment
-  rules = ZOHO_CONFIG["triage_agent_assignment"]
-  return "Assign to the default agent." unless rules&.any?
-
-  rules.map { |r| "  - #{r}" }.join("\n")
-end
-
-# Zoho sends the signing secret in the X-Hook-Secret header on the very first
-# request. We store it in the config file so subsequent requests can be verified.
-# If the secret is already in the config, we use that.
-def zoho_hook_secret
-  ZOHO_CONFIG["hook_secret"]
-end
-
-def save_zoho_hook_secret(secret)
-  ZOHO_CONFIG["hook_secret"] = secret
-  File.write(ZOHO_CONFIG_FILE, JSON.pretty_generate(ZOHO_CONFIG))
-  LOG.info "[Zoho] Saved hook_secret to #{ZOHO_CONFIG_FILE}"
-end
-
-# Verify the X-Hook-Signature header (base64 HMAC-SHA256 of the raw body).
-def verify_zoho_signature!(request, payload_body)
-  signature = request.env["HTTP_X_HOOK_SIGNATURE"]
-  return unless signature # First request won't have a signature, just the secret
-
-  secret = zoho_hook_secret
-  halt 500, { error: "No hook_secret configured — waiting for initial Zoho handshake" }.to_json unless secret
-
-  computed = Base64.strict_encode64(OpenSSL::HMAC.digest("sha256", secret, payload_body))
-  halt 403, { error: "Invalid Zoho signature" }.to_json unless Rack::Utils.secure_compare(signature, computed)
-end
-
-# Check if an email contains any of the exclude words (checked against subject, from, and body).
-def zoho_email_excluded?(email, exclude_words)
-  return false if exclude_words.nil? || exclude_words.empty?
-
-  searchable = [email["subject"], email["fromAddress"], email["toAddress"], email["summary"], email["html"]].join(" ").downcase
-  Array(exclude_words).any? { |word| searchable.include?(word.downcase) }
-end
-
-# Match an email against configured rules. Returns the first matching rule or nil.
-# If no rules match, returns a fallback rule (if configured) so nothing is missed.
-def zoho_rule_matches?(rule, email)
-  return false if rule["enabled"] == false
-
-  %w[from_contains to_contains subject_contains].each do |field|
-    pattern = rule[field]
-    next if pattern.nil? || pattern.empty?
-
-    email_field = case field
-                  when "from_contains" then email["fromAddress"]
-                  when "to_contains" then email["toAddress"]
-                  when "subject_contains" then email["subject"]
-                  end
-    return false unless email_field.to_s.downcase.include?(pattern.downcase)
-  end
-
-  if rule["body_contains"] && !rule["body_contains"].empty?
-    body = "#{email["summary"]}#{email["html"]}"
-    return false unless body.downcase.include?(rule["body_contains"].downcase)
-  end
-
-  !zoho_email_excluded?(email, rule["exclude_words"])
-end
-
-def match_zoho_rule(email)
-  rules = ZOHO_CONFIG["rules"] || []
-  matched = rules.find { |rule| zoho_rule_matches?(rule, email) }
-  return matched if matched
-
-  # Fallback: post unmatched emails so nothing slips through
-  fallback = zoho_fallback_rule
-  return nil if fallback && zoho_email_excluded?(email, ZOHO_CONFIG.dig("fallback", "exclude_words"))
-
-  fallback
-end
-
-# Returns the fallback rule config, or nil if not configured.
-def zoho_fallback_rule
-  fallback = ZOHO_CONFIG["fallback"]
-  return nil unless fallback && fallback["enabled"] != false
-
-  { "label" => fallback["label"] || "Unmatched Email",
-    "emoji" => fallback["emoji"] || "📬",
-    "discord_channel_id" => fallback["discord_channel_id"],
-    "notify_as" => fallback["notify_as"] }
-end
-
-# Extract body text from email payload for notification display.
-def extract_zoho_body_text(email, rule)
-  body_text = email["summary"].to_s.strip
-  if body_text.empty?
-    raw_html = (email["html"] || email["content"] || email["body"] || "").to_s
-    body_text = raw_html.gsub(/<[^>]+>/, " ").gsub(/&nbsp;/i, " ").gsub(/\s+/, " ").strip
-  end
-
-  body_text = fetch_zoho_email_content(email["messageId"]).to_s if body_text.empty? && rule["show_body"] && email["messageId"]
-
-  return nil if body_text.empty?
-
-  max_len = rule["show_body"] ? 1800 : 500
-  body_text = "#{body_text[0..max_len]}..." if body_text.length > max_len
-  body_text
-end
-
-# Format a Discord notification for a matched email.
-def format_zoho_notification(email, rule)
-  label = rule["label"] || "Zoho Mail"
-  emoji = rule["emoji"] || "📧"
-  parts = ["#{emoji} **#{label}**"]
-  parts << "**Subject:** #{email["subject"]}" if email["subject"]
-  parts << "**From:** #{email["fromAddress"]}" if email["fromAddress"]
-  parts << "**To:** #{email["toAddress"]}" if email["toAddress"]
-
-  body_text = extract_zoho_body_text(email, rule)
-  parts << "```\n#{body_text}\n```" if body_text
-
-  parts.join("\n")
-end
-
-# Send the notification to the configured channel.
-def notify_zoho_match(email, rule)
-  target = rule["notify_target"] || rule["discord_channel_id"] || ZOHO_CONFIG["default_notify_target"] || ZOHO_CONFIG["default_discord_channel_id"]
-  channel = rule["notify_channel"] || ZOHO_CONFIG["notify_channel"] || "discord"
-
-  unless target
-    LOG.warn "[Zoho] No notify_target configured for rule '#{rule["label"]}' and no default set"
-    return
-  end
-
-  message = format_zoho_notification(email, rule)
-  agent = rule["notify_as"] || ZOHO_CONFIG["notify_as"]
-
-  LOG.info "[Zoho] Sending notification via #{channel} to #{target}"
-  send_notification(:zoho_email, message, channel: channel, target: target, agent: agent)
-end
-
-# ---------------------------------------------------------------------------
-# Zoho Email Triage — dispatch an agent to decide if a support email needs a card
-# ---------------------------------------------------------------------------
-
-ZOHO_TRIAGE_DIR = File.join(BRAINIAC_DIR, "tmp", "zoho", "triage")
-FileUtils.mkdir_p(ZOHO_TRIAGE_DIR)
-
-ZOHO_TRIAGE_PROMPT = <<~PROMPT
-  You are triaging a support email. Decide whether this email needs a card or not.
-
-  ## Email
-  **From:** {{FROM}}
-  **To:** {{TO}}
-  **Subject:** {{SUBJECT}}
-  **Body:**
-  ```
-  {{BODY}}
-  ```
-
-  ## Decision Criteria
-  **Needs a card** (something is broken, a bug report, a feature request, a workflow issue):
-  - Create a card with a clear title summarizing the issue
-  - Tag with `support` plus a project tag if you can identify the relevant project
-  - Assign to the appropriate agent
-
-  **Does NOT need a card** (account questions, password resets, general inquiries, spam, marketing):
-  - Just explain why briefly
-
-  **Borderline** (you're not sure):
-  - Mark as borderline and explain why — a human will decide
-
-  ## Project Tags (use the tag name, not the ID)
-  {{PROJECT_TAGS}}
-
-  ## Agent Assignment
-  {{AGENT_ASSIGNMENT}}
-
-  ## Response Format
-  Write ONLY valid JSON to stdout (no markdown, no explanation outside the JSON):
-
-  For "needs a card":
-  ```json
-  {
-    "decision": "create_card",
-    "title": "Brief descriptive title for the card",
-    "description": "HTML description with relevant details from the email",
-    "project_tag": "project-tag-name or null",
-    "assign_to": "agent-name from the assignment rules above"
-  }
-  ```
-
-  For "does not need a card":
-  ```json
-  {
-    "decision": "skip",
-    "reason": "Brief explanation of why no card is needed"
-  }
-  ```
-
-  For "borderline":
-  ```json
-  {
-    "decision": "borderline",
-    "reason": "Why you're unsure — what makes this ambiguous"
-  }
-  ```
-PROMPT
-
-# Dispatch an agent to triage a support email. The agent decides whether to create
-# a card or just notify Discord.
-def dispatch_zoho_triage(email, rule)
-  agent_name = rule["dispatch_agent"]
-  timestamp = Time.now.strftime("%Y%m%d-%H%M%S")
-  response_file = File.join(ZOHO_TRIAGE_DIR, "triage-#{timestamp}.json")
-  log_file = File.join(ZOHO_TRIAGE_DIR, "triage-#{timestamp}.log")
-
-  prompt_file = write_zoho_triage_prompt(email, response_file, timestamp)
-
-  agent_key = agent_name.downcase.gsub(/[^a-z0-9-]/, "-")
-  project_config = default_project_config
-  resolved = resolve_project_cli_config(project_config || DEFAULT_PROJECT)
-
-  cmd = [resolved["agent_cli"]]
-  cmd.push("--agent", agent_key)
-  cmd.concat(resolved["agent_cli_args"].split)
-
-  spawn_env = {}
-  agent_env = agent_env_for(agent_name)
-  spawn_env.merge!(agent_env) unless agent_env.empty?
-
-  work_dir = project_config ? project_config["repo_path"] : Dir.pwd
-
-  LOG.info "[Zoho:Triage] Dispatching #{agent_name} for: #{email["subject"]}"
-  LOG.info "[Zoho:Triage] Command: #{cmd.join(" ")}"
-
-  pid = spawn(spawn_env, *cmd,
-              chdir: work_dir, in: prompt_file,
-              out: [log_file, "w"], err: %i[child out])
-
-  monitor_zoho_triage(pid, response_file, log_file, prompt_file, email, rule)
-  pid
-end
-
-def write_zoho_triage_prompt(email, response_file, timestamp)
-  body = (email["summary"] || email["html"] || "").to_s.gsub(/\s+/, " ").strip
-  body = body[0..2000] if body.length > 2000
-
-  prompt = ZOHO_TRIAGE_PROMPT
-           .gsub("{{FROM}}", email["fromAddress"].to_s)
-           .gsub("{{TO}}", email["toAddress"].to_s)
-           .gsub("{{SUBJECT}}", email["subject"].to_s)
-           .gsub("{{BODY}}", body)
-           .gsub("{{PROJECT_TAGS}}", zoho_triage_project_tags)
-           .gsub("{{AGENT_ASSIGNMENT}}", zoho_triage_agent_assignment)
-  prompt += "\n\nWrite your JSON response to: #{response_file}\n"
-
-  prompt_file = File.join(ZOHO_TRIAGE_DIR, "triage-prompt-#{timestamp}.md")
-  File.write(prompt_file, prompt)
-  prompt_file
-end
-
-def monitor_zoho_triage(pid, response_file, log_file, prompt_file, email, rule)
-  Thread.new do
-    Process.wait(pid)
-    exit_status = $CHILD_STATUS
-    LOG.info "[Zoho:Triage] Agent finished (exit: #{exit_status.exitstatus})"
-
-    decision = read_zoho_triage_response(response_file, log_file)
-    if decision
-      execute_zoho_triage_decision(decision, email, rule)
-    else
-      LOG.warn "[Zoho:Triage] No valid decision from agent — falling back to Discord notification"
-      notify_zoho_match(email, rule)
-    end
-
-    Thread.new do
-      sleep 300
-      FileUtils.rm_f(prompt_file)
-    end
-  end
-end
-
-# Read the triage response — try the response file first, then extract from log
-def read_zoho_triage_response(response_file, log_file)
-  # Try response file
-  if File.exist?(response_file) && !File.empty?(response_file)
-    content = File.read(response_file).strip
-    return parse_triage_json(content)
-  end
-
-  # Fallback: extract JSON from log output
-  if File.exist?(log_file)
-    log_content = File.read(log_file)
-    # Look for JSON block in the log
-    if (match = log_content.match(/\{[^{}]*"decision"\s*:\s*"[^"]+?"[^{}]*\}/m))
-      return parse_triage_json(match[0])
-    end
-  end
-
-  nil
-end
-
-def parse_triage_json(content)
-  # Strip markdown code fences if present
-  content = content.gsub(/```json\s*/, "").gsub(/```\s*/, "").strip
-  JSON.parse(content)
-rescue JSON::ParserError => e
-  LOG.warn "[Zoho:Triage] Failed to parse response JSON: #{e.message}"
-  nil
-end
-
-# Act on the triage decision
-def execute_zoho_triage_decision(decision, email, rule)
-  channel_id = rule["notify_target"] || rule["discord_channel_id"] ||
-               ZOHO_CONFIG["default_notify_target"] || ZOHO_CONFIG["default_discord_channel_id"]
-  notify_channel = rule["notify_channel"] || ZOHO_CONFIG["notify_channel"] || "discord"
-  bot_name = rule["notify_as"] || ZOHO_CONFIG["notify_as"]
-
-  case decision["decision"]
-  when "create_card"
-    create_zoho_triage_card(decision, email, channel_id, notify_channel, bot_name)
-  when "skip"
-    msg = "📧 **Support Email — No Card Needed**\n"
-    msg += "**Subject:** #{email["subject"]}\n"
-    msg += "**From:** #{email["fromAddress"]}\n"
-    msg += "**Reason:** #{decision["reason"]}"
-    send_notification(:zoho_triage, msg, channel: notify_channel, target: channel_id, agent: bot_name)
-    LOG.info "[Zoho:Triage] Skipped card: #{decision["reason"]}"
-  when "borderline"
-    msg = "⚠️ **Support Email — Needs Human Decision**\n"
-    msg += "**Subject:** #{email["subject"]}\n"
-    msg += "**From:** #{email["fromAddress"]}\n"
-    msg += "**Why borderline:** #{decision["reason"]}\n"
-    summary = (email["summary"] || "").to_s[0..300]
-    msg += "```\n#{summary}\n```" unless summary.empty?
-    send_notification(:zoho_triage, msg, channel: notify_channel, target: channel_id, agent: bot_name)
-    LOG.info "[Zoho:Triage] Borderline — posted for human decision"
-  else
-    LOG.warn "[Zoho:Triage] Unknown decision: #{decision["decision"]}"
-    notify_zoho_match(email, rule)
-  end
-end
-
-# Create a card from the triage decision
-def create_zoho_triage_card(decision, email, channel_id, notify_channel, bot_name)
-  board_id = ZOHO_CONFIG["triage_board_id"]
-  unless board_id
-    LOG.error "[Zoho:Triage] No triage_board_id configured in zoho.json"
-    return
-  end
-  title = decision["title"] || email["subject"]
-  description = decision["description"] || "<p>Support email from #{email["fromAddress"]}: #{email["subject"]}</p>"
-
-  # Build tag list — always include 'support', plus project tag if identified
-  tags = ["support"]
-  tags << decision["project_tag"] if decision["project_tag"]
-
-  # Emit hook — work item plugin handles card creation (card management plugins)
-  results = Brainiac.emit(:create_work_item,
-                          board_id: board_id,
-                          title: title,
-                          description: description,
-                          tags: tags,
-                          assign_to: decision["assign_to"])
-
-  card_info = results.compact.first
-  if card_info
-    card_number = card_info[:number]
-    card_url = card_info[:url]
-    LOG.info "[Zoho:Triage] Created card ##{card_number}: #{title}"
-
-    # Notify configured channel
-    msg = "🎫 **Support Card Created: [##{card_number}](#{card_url})**\n"
-    msg += "**Title:** #{title}\n"
-    msg += "**Assigned to:** #{decision["assign_to"] || "unassigned"}\n"
-    msg += "**Tags:** #{tags.join(", ")}\n"
-    msg += "**From:** #{email["fromAddress"]}"
-    send_notification(:zoho_triage, msg, channel: notify_channel, target: channel_id, agent: bot_name)
-  else
-    LOG.warn "[Zoho:Triage] No work item plugin handled card creation"
-    notify_zoho_match(email, { "label" => "Support Email (no card plugin)", "emoji" => "⚠️" }.merge(rule_defaults(nil)))
-  end
-rescue StandardError => e
-  LOG.error "[Zoho:Triage] Error creating card: #{e.message}\n#{e.backtrace.first(3).join("\n")}"
-  notify_zoho_match(email, { "label" => "Support Email", "emoji" => "🆘" }.merge(rule_defaults(nil)))
-end

data/lib/brainiac/zoho_mail_api.rb

@@ -1,110 +0,0 @@
-# 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/templates/github.json.example

@@ -1,4 +0,0 @@
-{
-  "webhook_secret": "your-github-webhook-secret",
-  "repos": {}
-}

data/templates/zoho.json.example

@@ -1,27 +0,0 @@
-{
-  "hook_secret": null,
-  "default_discord_channel_id": "YOUR_DISCORD_CHANNEL_ID",
-  "notify_as": "threepio",
-  "rules": [
-    {
-      "label": "Item Sold",
-      "enabled": true,
-      "from_contains": "",
-      "to_contains": "",
-      "subject_contains": "sold",
-      "body_contains": "",
-      "exclude_words": [],
-      "emoji": "💰",
-      "discord_channel_id": null,
-      "notify_as": null
-    }
-  ],
-  "fallback": {
-    "enabled": true,
-    "label": "Unmatched Email",
-    "emoji": "📬",
-    "exclude_words": [],
-    "discord_channel_id": null,
-    "notify_as": null
-  }
-}