Plug-and-Play AI
Content Moderation

import { createHmac, timingSafeEqual } from "crypto";

function verifyWebhook(payload, signature, secret) {
  const expected = `sha256=${createHmac("sha256", secret)
    .update(payload)
    .digest("hex")}`;
  return timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(expected)
  );
}

// In your Express handler:
// const sig = req.headers["x-civitas-signature"];
// const valid = verifyWebhook(req.rawBody, sig, WEBHOOK_SECRET);

package webhook

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
)

func VerifySignature(payload []byte, signature, secret string) bool {
    mac := hmac.New(sha256.New, []byte(secret))
    mac.Write(payload)
    expected := fmt.Sprintf("sha256=%s", hex.EncodeToString(mac.Sum(nil)))
    return hmac.Equal([]byte(expected), []byte(signature))
}

// In your HTTP handler:
// sig := r.Header.Get("X-Civitas-Signature")
// valid := VerifySignature(body, sig, webhookSecret)

async function moderateWithRetry(content, maxRetries = 3) {
  const url = "https://api.civitas-ai.com/api/v1/moderate";

  for (let attempt = 0; attempt < maxRetries; attempt++) {
    const resp = await fetch(url, {
      method: "POST",
      headers: {
        "X-API-Key": process.env.CIVITAS_API_KEY,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({ content }),
    });

    if (resp.status === 429) {
      const reset = parseInt(resp.headers.get("X-RateLimit-Reset") || "0");
      const wait = Math.max(reset - Math.floor(Date.now() / 1000), 1);
      const jitter = Math.min(wait, 2 ** attempt + Math.random());
      await new Promise((r) => setTimeout(r, jitter * 1000));
      continue;
    }

    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
    return await resp.json();
  }
  throw new Error("Max retries exceeded");
}

func ModerateWithRetry(content string, maxRetries int) (map[string]interface{}, error) {
    url := "https://api.civitas-ai.com/api/v1/moderate"

    for attempt := 0; attempt < maxRetries; attempt++ {
        payload, _ := json.Marshal(map[string]string{"content": content})
        req, _ := http.NewRequest("POST", url, bytes.NewBuffer(payload))
        req.Header.Set("X-API-Key", os.Getenv("CIVITAS_API_KEY"))
        req.Header.Set("Content-Type", "application/json")

        resp, err := http.DefaultClient.Do(req)
        if err != nil {
            return nil, err
        }

        if resp.StatusCode == 429 {
            resetStr := resp.Header.Get("X-RateLimit-Reset")
            reset, _ := strconv.ParseInt(resetStr, 10, 64)
            wait := time.Until(time.Unix(reset, 0))
            jitter := time.Duration(math.Min(
                float64(wait),
                math.Pow(2, float64(attempt))+rand.Float64(),
            )) * time.Second
            resp.Body.Close()
            time.Sleep(jitter)
            continue
        }

        defer resp.Body.Close()
        var result map[string]interface{}
        json.NewDecoder(resp.Body).Decode(&result)
        return result, nil
    }
    return nil, fmt.Errorf("max retries exceeded")
}