Post a daily campaign digest to Slack

// digest.mjs
const API_URL = "https://api.versionseven.ai/v1";
const API_KEY = process.env.VICTORIA_API_KEY;
const SLACK_WEBHOOK_URL = process.env.SLACK_WEBHOOK_URL;
const RUNWAY_FLAG_DAYS = 7;
const FALLBACK_FLAG_PCT = 25;

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

// Sends a request, waiting and retrying on 429 and 503.
async function call(path) {
  for (let attempt = 1; ; attempt++) {
    const response = await fetch(`${API_URL}${path}`, { headers: { Authorization: `Bearer ${API_KEY}` } });
    const data = await response.json().catch(() => ({}));
    if ((response.status !== 429 && response.status !== 503) || attempt === 5) {
      if (response.status !== 200) throw new Error(`${path} answered ${response.status} ${data.error ?? ""}`);
      return data;
    }
    await sleep((Number(response.headers.get("Retry-After")) || 2 ** attempt) * 1000);
  }
}

async function listCampaigns() {
  const campaigns = [];
  for (let offset = 0; ; ) {
    const data = await call(`/campaigns?limit=500&offset=${offset}`);
    campaigns.push(...data.campaigns);
    if (!data.has_more) return campaigns;
    offset += data.count;
  }
}

const yesterday = new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString().slice(0, 10);
const pct = (part, whole) => (whole > 0 ? Math.round((part / whole) * 100) : 0);

async function campaignReport(campaign) {
  const [stats, queue, senders, quality] = await Promise.all([
    call(`/campaigns/${campaign.id}/daily-stats?from=${yesterday}&to=${yesterday}`),
    call(`/campaigns/${campaign.id}/queue`),
    call(`/campaigns/${campaign.id}/senders/breakdown?date_filter=7d`),
    call(`/campaigns/${campaign.id}/personalization-quality?days=7`),
  ]);
  const day = stats.days[0] ?? {};
  const lines = [
    `*${campaign.name}*: ${day.leads_first_contacted ?? 0} contacted, ${day.leads_first_replied ?? 0} replied` +
      ` (${day.replies_positive ?? 0} positive), ${day.meetings_booked ?? 0} meetings booked yesterday`,
  ];
  const flags = [];
  if (queue.days_of_runway === null) {
    flags.push(`no runway: ${queue.warnings.join("; ") || "no capacity or no active senders"}`);
  } else if (queue.days_of_runway < RUNWAY_FLAG_DAYS) {
    flags.push(`runway ${queue.days_of_runway} days (${queue.backlog} leads left at ${queue.daily_capacity} a day)`);
  }
  for (const sender of senders.senders) {
    if (sender.is_active && (sender.messages_sent ?? 0) === 0 && (sender.requests ?? 0) === 0) {
      flags.push(`sender ${sender.label} (${sender.platform}) sent nothing in 7 days`);
    }
  }
  for (const field of quality.fields) {
    const missed = (field.fallback ?? 0) + (field.held ?? 0);
    if ((field.runs ?? 0) >= 10 && pct(missed, field.runs) > FALLBACK_FLAG_PCT) {
      flags.push(`AI field {${field.field_name}} fell back or held on ${pct(missed, field.runs)}% of ${field.runs} runs`);
    }
  }
  lines.push(...flags.map((flag) => `  :warning: ${flag}`));
  return lines.join("\n");
}

const campaigns = (await listCampaigns()).filter((campaign) => campaign.is_active);
const reports = [];
for (const campaign of campaigns) {
  reports.push(await campaignReport(campaign));
  await sleep(650); // four calls per campaign, under 100 a minute to any one endpoint
}
const text = campaigns.length
  ? [`:sunrise: Outbound digest for ${yesterday}`, ...reports].join("\n\n")
  : `:sunrise: Outbound digest for ${yesterday}: no active campaigns`;

if (SLACK_WEBHOOK_URL) {
  const response = await fetch(SLACK_WEBHOOK_URL, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ text }),
    signal: AbortSignal.timeout(10_000),
  });
  if (!response.ok) throw new Error(`Slack answered ${response.status}`);
} else {
  console.log(text);
}

# digest.py
import os
import time
from datetime import datetime, timedelta, timezone

import requests

API_URL = "https://api.versionseven.ai/v1"
HEADERS = {"Authorization": f"Bearer {os.environ['VICTORIA_API_KEY']}"}
SLACK_WEBHOOK_URL = os.environ.get("SLACK_WEBHOOK_URL")
RUNWAY_FLAG_DAYS = 7
FALLBACK_FLAG_PCT = 25


def call(path):
    """Sends a request, waiting and retrying on 429 and 503."""
    for attempt in range(1, 6):
        response = requests.get(f"{API_URL}{path}", headers=HEADERS, timeout=30)
        try:
            data = response.json()
        except ValueError:
            data = {}
        if response.status_code not in (429, 503) or attempt == 5:
            if response.status_code != 200:
                raise SystemExit(f"{path} answered {response.status_code} {data.get('error', '')}")
            return data
        time.sleep(float(response.headers.get("Retry-After") or 2**attempt))


def list_campaigns():
    campaigns, offset = [], 0
    while True:
        data = call(f"/campaigns?limit=500&offset={offset}")
        campaigns.extend(data["campaigns"])
        if not data["has_more"]:
            return campaigns
        offset += data["count"]


def pct(part, whole):
    return round(part / whole * 100) if whole else 0


YESTERDAY = (datetime.now(timezone.utc) - timedelta(days=1)).date().isoformat()


def campaign_report(campaign):
    stats = call(f"/campaigns/{campaign['id']}/daily-stats?from={YESTERDAY}&to={YESTERDAY}")
    queue = call(f"/campaigns/{campaign['id']}/queue")
    senders = call(f"/campaigns/{campaign['id']}/senders/breakdown?date_filter=7d")
    quality = call(f"/campaigns/{campaign['id']}/personalization-quality?days=7")
    day = stats["days"][0] if stats["days"] else {}
    lines = [
        f"*{campaign['name']}*: {day.get('leads_first_contacted') or 0} contacted, "
        f"{day.get('leads_first_replied') or 0} replied ({day.get('replies_positive') or 0} positive), "
        f"{day.get('meetings_booked') or 0} meetings booked yesterday"
    ]
    flags = []
    if queue["days_of_runway"] is None:
        flags.append("no runway: " + ("; ".join(queue["warnings"]) or "no capacity or no active senders"))
    elif queue["days_of_runway"] < RUNWAY_FLAG_DAYS:
        flags.append(f"runway {queue['days_of_runway']} days ({queue['backlog']} leads left at {queue['daily_capacity']} a day)")
    for sender in senders["senders"]:
        if sender.get("is_active") and not (sender.get("messages_sent") or 0) and not (sender.get("requests") or 0):
            flags.append(f"sender {sender.get('label')} ({sender.get('platform')}) sent nothing in 7 days")
    for field in quality["fields"]:
        missed = (field.get("fallback") or 0) + (field.get("held") or 0)
        runs = field.get("runs") or 0
        if runs >= 10 and pct(missed, runs) > FALLBACK_FLAG_PCT:
            flags.append(f"AI field {{{field['field_name']}}} fell back or held on {pct(missed, runs)}% of {runs} runs")
    lines.extend(f"  :warning: {flag}" for flag in flags)
    return "\n".join(lines)


def main():
    campaigns = [c for c in list_campaigns() if c.get("is_active")]
    reports = []
    for campaign in campaigns:
        reports.append(campaign_report(campaign))
        time.sleep(0.65)  # four calls per campaign, under 100 a minute to any one endpoint
    if campaigns:
        text = "\n\n".join([f":sunrise: Outbound digest for {YESTERDAY}", *reports])
    else:
        text = f":sunrise: Outbound digest for {YESTERDAY}: no active campaigns"

    if SLACK_WEBHOOK_URL:
        response = requests.post(SLACK_WEBHOOK_URL, json={"text": text}, timeout=10)
        response.raise_for_status()
    else:
        print(text)


if __name__ == "__main__":
    main()