Connect WhatsApp
to Claude.

// WABridges + Claude: a WhatsApp bot in one file.
// Webhook in -> Claude -> POST /send/text out. Run it against the sandbox
// first (no phone needed), then point CUSTOMER_REF at a real bridge.
import express from "express";
import crypto from "node:crypto";
import Anthropic from "@anthropic-ai/sdk";

const { WA_API_KEY, WA_WEBHOOK_SECRET, ANTHROPIC_API_KEY, CUSTOMER_REF = "sandbox", PORT = 3000 } = process.env;
const BASE = `https://wabridges.com/api/instances/${CUSTOMER_REF}/proxy`;

// Customize me.
const SYSTEM_PROMPT = `You are a friendly assistant answering on WhatsApp.
Keep replies short (1-3 sentences), plain text, no markdown.`;

const client = new Anthropic({ apiKey: ANTHROPIC_API_KEY });
const history = new Map(); // chat_id -> Anthropic.MessageParam[] (last 10 exchanges)
const seen = new Set();    // X-Webhook-Event-Id dedupe: delivery is at-least-once

const app = express();
app.use(express.json({ verify: (req, _res, buf) => { req.rawBody = buf; } }));

// Same check as https://wabridges.com/docs/webhooks#verify
function verifyWebhook(req) {
  const m = (req.get("X-Webhook-Signature") || "").match(/^t=(\d+),v1=([0-9a-f]+)$/);
  if (!m) return false;
  const [, t, v1] = m;
  if (Math.abs(Date.now() / 1000 - Number(t)) > 300) return false; // stale
  const expected = crypto.createHmac("sha256", WA_WEBHOOK_SECRET).update(`${t}.`).update(req.rawBody).digest("hex");
  return v1.length === expected.length && crypto.timingSafeEqual(Buffer.from(v1), Buffer.from(expected));
}

app.post("/hook", (req, res) => {
  if (!verifyWebhook(req)) return res.sendStatus(401);
  res.sendStatus(200); // ack first: the bridge retries anything slower than 10s

  const ev = req.body;
  const id = req.get("X-Webhook-Event-Id");
  if (ev.event !== "message" || ev.from_me || ev.is_group || ev.type !== "text") return;
  if (seen.has(id)) return;
  seen.add(id);
  if (seen.size > 1000) seen.delete(seen.values().next().value);

  reply(ev.chat_id, ev.body, id).catch((e) => console.error("reply failed:", e));
});

async function reply(chat, text, eventId) {
  const msgs = history.get(chat) ?? [];
  msgs.push({ role: "user", content: text });

  let answer;
  try {
    const r = await client.messages.create({
      model: "claude-sonnet-5",
      max_tokens: 1024,                  // WhatsApp replies are short on purpose
      output_config: { effort: "low" },  // chat: fast and cheap; raise for harder tasks
      system: SYSTEM_PROMPT,
      messages: msgs,
    });
    answer = r.stop_reason === "refusal"
      ? "Sorry, I can't help with that one."
      : r.content.filter((b) => b.type === "text").map((b) => b.text).join("\n").trim();
  } catch (e) {
    answer = e instanceof Anthropic.RateLimitError ? "I'm a bit busy, try again in a minute." : "Something went wrong on my side.";
    console.error("claude:", e.message);
  }
  answer ||= "...";

  msgs.push({ role: "assistant", content: answer });
  history.set(chat, msgs.slice(-20));
  await sendText(chat, answer, eventId);
}

async function sendText(chat, body, idempotencyKey, retried = false) {
  const res = await fetch(`${BASE}/send/text`, {
    method: "POST",
    headers: { Authorization: `Bearer ${WA_API_KEY}`, "Content-Type": "application/json", "Idempotency-Key": idempotencyKey },
    body: JSON.stringify({ chat, body }),
  });
  if (res.status === 503 && !retried) { // an idle bridge is waking up: honor Retry-After once
    await new Promise((r) => setTimeout(r, 1000 * (Number(res.headers.get("Retry-After")) || 5)));
    return sendText(chat, body, idempotencyKey, true);
  }
  if (!res.ok) console.error("send failed:", res.status, await res.text());
}

app.listen(PORT, () => console.log(`bot listening on :${PORT} for bridge "${CUSTOMER_REF}"`));

"""WABridges + Claude: a WhatsApp bot in one file.

Webhook in -> Claude -> POST /send/text out. Run it against the sandbox first
(no phone needed), then point CUSTOMER_REF at a real bridge.
"""
import hashlib
import hmac
import os
import re
import threading
import time
from collections import OrderedDict, defaultdict, deque

import anthropic
import requests
from flask import Flask, request

WA_API_KEY = os.environ["WA_API_KEY"]
WA_WEBHOOK_SECRET = os.environ["WA_WEBHOOK_SECRET"]
CUSTOMER_REF = os.environ.get("CUSTOMER_REF", "sandbox")
BASE = f"https://wabridges.com/api/instances/{CUSTOMER_REF}/proxy"

# Customize me.
SYSTEM_PROMPT = """You are a friendly assistant answering on WhatsApp.
Keep replies short (1-3 sentences), plain text, no markdown."""

client = anthropic.Anthropic()  # reads ANTHROPIC_API_KEY
history = defaultdict(lambda: deque(maxlen=20))  # chat_id -> last 10 exchanges
seen = OrderedDict()  # X-Webhook-Event-Id dedupe: delivery is at-least-once
app = Flask(__name__)


def verify_webhook() -> bool:
    """Same check as https://wabridges.com/docs/webhooks#verify"""
    m = re.fullmatch(r"t=(\d+),v1=([0-9a-f]+)", request.headers.get("X-Webhook-Signature", ""))
    if not m:
        return False
    t, v1 = m.groups()
    if abs(time.time() - int(t)) > 300:  # stale
        return False
    expected = hmac.new(WA_WEBHOOK_SECRET.encode(), f"{t}.".encode() + request.get_data(), hashlib.sha256).hexdigest()
    return hmac.compare_digest(v1, expected)


@app.post("/hook")
def hook():
    if not verify_webhook():
        return "", 401
    ev = request.get_json(silent=True) or {}
    event_id = request.headers.get("X-Webhook-Event-Id", "")
    if ev.get("event") != "message" or ev.get("from_me") or ev.get("is_group") or ev.get("type") != "text":
        return "", 200
    if event_id in seen:
        return "", 200
    seen[event_id] = True
    if len(seen) > 1000:
        seen.popitem(last=False)
    # Ack now: the bridge retries anything slower than 10s. Reply in the background.
    threading.Thread(target=reply, args=(ev["chat_id"], ev["body"], event_id), daemon=True).start()
    return "", 200


def reply(chat: str, text: str, event_id: str) -> None:
    msgs = history[chat]
    msgs.append({"role": "user", "content": text})
    try:
        r = client.messages.create(
            model="claude-sonnet-5",
            max_tokens=1024,                   # WhatsApp replies are short on purpose
            output_config={"effort": "low"},   # chat: fast and cheap; raise for harder tasks
            system=SYSTEM_PROMPT,
            messages=list(msgs),
        )
        if r.stop_reason == "refusal":
            answer = "Sorry, I can't help with that one."
        else:
            answer = "\n".join(b.text for b in r.content if b.type == "text").strip()
    except anthropic.RateLimitError:
        answer = "I'm a bit busy, try again in a minute."
    except anthropic.APIError as e:
        print("claude:", e)
        answer = "Something went wrong on my side."
    answer = answer or "..."
    msgs.append({"role": "assistant", "content": answer})
    send_text(chat, answer, event_id)


def send_text(chat: str, body: str, idempotency_key: str, retried: bool = False) -> None:
    res = requests.post(
        f"{BASE}/send/text",
        json={"chat": chat, "body": body},
        headers={"Authorization": f"Bearer {WA_API_KEY}", "Idempotency-Key": idempotency_key},
        timeout=30,
    )
    if res.status_code == 503 and not retried:  # an idle bridge is waking up: honor Retry-After once
        time.sleep(int(res.headers.get("Retry-After", "5")))
        return send_text(chat, body, idempotency_key, True)
    if not res.ok:
        print("send failed:", res.status_code, res.text)


if __name__ == "__main__":
    app.run(port=int(os.environ.get("PORT", "3000")))