sermon-js 0.0.0-stage → 0.2.0

package/dist/presets/index.js

@@ -0,0 +1,971 @@
+export { generic } from '../chunk-I3346MUL.js';
+import { definePreset, normalizeReturn } from '../chunk-XPXIDJUU.js';
+import { AwsClient } from 'aws4fetch';
+
+// src/presets/fly.ts
+var MACHINES_API = "https://api.machines.dev/v1";
+var GONE_STATES = /* @__PURE__ */ new Set(["destroyed", "destroying"]);
+var RESTING_STATES = /* @__PURE__ */ new Set(["stopped", "suspended", "stopping", "suspending", "starting", "created"]);
+function crashReason(machine) {
+  const exit = [...machine.events ?? []].filter((event) => event.type === "exit").sort((a, b) => (b.timestamp ?? 0) - (a.timestamp ?? 0))[0]?.request?.exit_event;
+  if (!exit || exit.requested_stop) return void 0;
+  if (exit.oom_killed) return "Out of memory";
+  if (exit.exit_code !== void 0 && exit.exit_code !== 0) return `Crashed (exit code ${exit.exit_code})`;
+  return void 0;
+}
+function withKeys(machines) {
+  const seen = /* @__PURE__ */ new Map();
+  return [...machines].sort((a, b) => (a.region ?? "").localeCompare(b.region ?? "") || a.id.localeCompare(b.id)).map((machine) => {
+    const region = machine.region ?? "unknown";
+    const count = (seen.get(region) ?? 0) + 1;
+    seen.set(region, count);
+    return { machine, region, key: count === 1 ? region : `${region}#${count}` };
+  });
+}
+function median(values) {
+  if (!values.length) return void 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  return sorted[Math.floor((sorted.length - 1) / 2)];
+}
+var app = definePreset()({
+  kind: "fly.app",
+  requiredFields: ["app"],
+  requiredSecrets: ["token"],
+  defaults: { slowMs: 1500 },
+  derive: (options) => ({
+    name: options.app,
+    identity: `fly.app:${options.app}`,
+    description: `Fly app "${options.app}": machine states, then health on running machines only`
+  }),
+  check: async ({ options, secrets, http, slowMs }) => {
+    const health = options.track?.health ?? "/";
+    const healthPath = health === false ? void 0 : typeof health === "string" ? health : health.path ?? "/";
+    const anyStatus = typeof health === "object" && !!health.anyStatus;
+    const list = await http(`${MACHINES_API}/apps/${encodeURIComponent(options.app)}/machines`, {
+      headers: { Authorization: `Bearer ${secrets.token}` }
+    });
+    if (list.status === 404) {
+      return { status: "down", probed: false, httpStatus: 404, error: `App "${options.app}" not found on Fly` };
+    }
+    if (!list.ok || !Array.isArray(list.json)) {
+      return {
+        status: "degraded",
+        probed: false,
+        httpStatus: list.status,
+        error: list.status ? `Fly Machines API HTTP ${list.status}` : `Fly Machines API unreachable: ${list.outcome.error ?? "no response"}`
+      };
+    }
+    const machines = list.json.filter((machine) => !GONE_STATES.has(machine.state));
+    if (machines.length === 0) {
+      return { status: "down", probed: false, error: "No machines: the app has no capacity at all" };
+    }
+    const instances = await Promise.all(
+      withKeys(machines).map(async ({ machine, region, key }) => {
+        const base = { key, region, id: machine.id, state: machine.state };
+        if (machine.state === "failed") return { ...base, status: "down", error: "Machine failed" };
+        if (machine.state !== "started") {
+          const crash = machine.state === "stopped" ? crashReason(machine) : void 0;
+          if (crash) return { ...base, status: "down", error: crash };
+          return { ...base, status: RESTING_STATES.has(machine.state) ? "sleeping" : "degraded" };
+        }
+        const failingChecks = (machine.checks ?? []).filter((c) => c.status !== "passing").map((c) => c.name);
+        const checksError = failingChecks.length ? `Fly health checks failing: ${failingChecks.join(", ")}` : void 0;
+        if (!healthPath) {
+          return { ...base, status: checksError ? "degraded" : "up", error: checksError };
+        }
+        const probe = await http(`https://${options.app}.fly.dev${healthPath}`, {
+          headers: { "fly-force-instance-id": machine.id },
+          okStatuses: anyStatus ? [400, 401, 403, 404, 405, 421] : void 0
+        });
+        let status2 = probe.outcome.status;
+        let error2 = probe.outcome.error;
+        if (status2 === "up" && checksError) {
+          status2 = "degraded";
+          error2 = checksError;
+        } else if (status2 === "up" && probe.latencyMs > slowMs) {
+          status2 = "degraded";
+          error2 = `Slow response: ${probe.latencyMs} ms`;
+        }
+        return {
+          ...base,
+          status: status2,
+          latencyMs: probe.status === void 0 ? void 0 : probe.latencyMs,
+          httpStatus: probe.status,
+          error: error2
+        };
+      })
+    );
+    const down = instances.filter((instance2) => instance2.status === "down");
+    const degraded = instances.filter((instance2) => instance2.status === "degraded");
+    const awake = instances.filter((instance2) => instance2.status === "up" || instance2.status === "degraded");
+    const keysOf = (items) => items.map((instance2) => instance2.key).join(", ");
+    let status;
+    let error;
+    if (down.length === instances.length) {
+      status = "down";
+      error = `All ${instances.length} machine(s) down`;
+    } else if (down.length > 0) {
+      status = "degraded";
+      error = `${down.length}/${instances.length} machine(s) down: ${keysOf(down)}`;
+    } else if (degraded.length > 0) {
+      status = "degraded";
+      error = `Degraded in ${keysOf(degraded)}`;
+    } else {
+      status = awake.length ? "up" : "sleeping";
+    }
+    const probed = instances.some((instance2) => instance2.httpStatus !== void 0 || instance2.latencyMs !== void 0);
+    return {
+      status,
+      probed,
+      // Median of the machines we probed; each machine keeps its own latency
+      latencyMs: median(instances.map((i) => i.latencyMs).filter((l) => l !== void 0)),
+      error,
+      metrics: { machines: `${awake.length}/${instances.length} running` },
+      instances: options.track?.machines === false ? void 0 : instances
+    };
+  }
+});
+var fly = { app };
+
+// src/google-auth.ts
+function parseServiceAccount(json) {
+  if (!json) return void 0;
+  try {
+    const parsed = JSON.parse(json);
+    return parsed.client_email && parsed.private_key ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var base64url = (bytes) => {
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+};
+var encodeJson = (value) => base64url(new TextEncoder().encode(JSON.stringify(value)));
+function pemToPkcs8(pem) {
+  const body = pem.replace(/\\n/g, "\n").replace(/-----BEGIN [^-]+-----|-----END [^-]+-----|\s+/g, "");
+  const binary = atob(body);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+async function signGoogleAssertion({
+  account,
+  scope,
+  now = Date.now()
+}) {
+  const issuedAt = Math.floor(now / 1e3);
+  const unsigned = `${encodeJson({ alg: "RS256", typ: "JWT" })}.${encodeJson({
+    iss: account.client_email,
+    scope,
+    aud: "https://oauth2.googleapis.com/token",
+    iat: issuedAt,
+    exp: issuedAt + 3600
+  })}`;
+  const key = await crypto.subtle.importKey(
+    "pkcs8",
+    pemToPkcs8(account.private_key),
+    { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const signature = await crypto.subtle.sign("RSASSA-PKCS1-v1_5", key, new TextEncoder().encode(unsigned));
+  return `${unsigned}.${base64url(new Uint8Array(signature))}`;
+}
+var tokens = /* @__PURE__ */ new Map();
+function clearGoogleTokens() {
+  tokens.clear();
+}
+async function googleServiceAccountToken({
+  account,
+  scope,
+  http,
+  now = Date.now()
+}) {
+  const cacheKey = `${account.client_email}:${scope}:${account.private_key.length}:${account.private_key.slice(-48)}`;
+  const cached = tokens.get(cacheKey);
+  if (cached && cached.expiresAt > now) return cached.token;
+  const assertion = await signGoogleAssertion({ account, scope, now });
+  const response = await http("https://oauth2.googleapis.com/token", {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "urn:ietf:params:oauth:grant-type:jwt-bearer",
+      assertion
+    }).toString()
+  });
+  const body = response.json;
+  if (!response.ok || !body?.access_token) {
+    throw new Error(
+      `Google auth failed: ${body?.error_description ?? body?.error ?? response.outcome.error ?? "no access token"}`
+    );
+  }
+  const ttlMs = Math.max(6e4, ((body.expires_in ?? 3600) - 300) * 1e3);
+  tokens.set(cacheKey, { token: body.access_token, expiresAt: now + ttlMs });
+  return body.access_token;
+}
+
+// src/presets/gcp.ts
+var SLEEP_STATES = /* @__PURE__ */ new Set(["TERMINATED", "STOPPED", "SUSPENDED", "STOPPING", "SUSPENDING"]);
+var BOOTING_STATES = /* @__PURE__ */ new Set(["PROVISIONING", "STAGING"]);
+var instance = definePreset()({
+  kind: "gcp.instance",
+  requiredFields: ["instance", "zone"],
+  requiredSecrets: ["serviceAccount"],
+  defaults: { slowMs: 1500 },
+  derive: (options) => ({
+    name: options.instance ?? "",
+    identity: `gcp.instance:${options.project ?? ""}/${options.zone ?? ""}/${options.instance ?? ""}`,
+    description: `Google Cloud VM "${options.instance}": status, then health only when running`
+  }),
+  check: async ({ options, secrets, http, now }) => {
+    const account = parseServiceAccount(secrets.serviceAccount);
+    const project = options.project ?? account?.project_id;
+    if (!account || !project) {
+      return { status: "down", probed: false, error: "The service account secret is not a service-account JSON key" };
+    }
+    let token;
+    try {
+      token = await googleServiceAccountToken({
+        account,
+        scope: "https://www.googleapis.com/auth/compute.readonly",
+        http,
+        now
+      });
+    } catch (error) {
+      return { status: "down", probed: false, error: error instanceof Error ? error.message : String(error) };
+    }
+    const info = await http(
+      `https://compute.googleapis.com/compute/v1/projects/${project}/zones/${options.zone}/instances/${options.instance}`,
+      { headers: { Authorization: `Bearer ${token}` } }
+    );
+    const state = info.json?.status;
+    if (!info.ok || !state) {
+      return {
+        status: "down",
+        probed: false,
+        httpStatus: info.status,
+        error: `Compute API: ${info.outcome.error ?? "no instance status"}`
+      };
+    }
+    const metrics = { vm: state, zone: options.zone };
+    if (SLEEP_STATES.has(state)) return { status: "sleeping", probed: false, metrics };
+    if (BOOTING_STATES.has(state)) return { status: "degraded", probed: false, metrics, error: `VM is ${state}` };
+    if (state !== "RUNNING") return { status: "down", probed: false, metrics, error: `VM is ${state}` };
+    const health = options.track?.health;
+    if (!health) return { status: "up", probed: false, metrics };
+    const probe = await http(health, { okStatuses: [400, 401, 403, 404, 405] });
+    return { ...probe.outcome, metrics };
+  }
+});
+var gcp = { instance };
+async function signedCall({
+  http,
+  secrets,
+  service,
+  region,
+  url,
+  init
+}) {
+  const client = new AwsClient({ ...secrets, service, region });
+  const request = await client.sign(url, init);
+  return http(request.url, {
+    method: init.method,
+    headers: Object.fromEntries(request.headers.entries()),
+    body: init.body
+  });
+}
+var credentials = definePreset()({
+  kind: "aws.credentials",
+  requiredSecrets: ["accessKeyId", "secretAccessKey"],
+  derive: (options) => ({
+    name: options.name,
+    description: "Validates the credentials only (STS GetCallerIdentity)"
+  }),
+  check: async ({ secrets, http }) => {
+    const body = "Action=GetCallerIdentity&Version=2011-06-15";
+    const response = await signedCall({
+      http,
+      secrets,
+      service: "sts",
+      region: "us-east-1",
+      url: "https://sts.amazonaws.com/",
+      init: { method: "POST", headers: { "content-type": "application/x-www-form-urlencoded" }, body }
+    });
+    return response.outcome;
+  }
+});
+var s3Bucket = definePreset()({
+  kind: "aws.s3-bucket",
+  requiredFields: ["bucket"],
+  requiredSecrets: ["accessKeyId", "secretAccessKey"],
+  defaults: { slowMs: 1500 },
+  derive: (options) => ({
+    name: options.bucket ?? "",
+    description: "S3 HeadBucket on the storage endpoint"
+  }),
+  check: async ({ options, secrets, http }) => {
+    const region = options.region ?? "us-east-1";
+    const endpoint = (options.endpoint ?? `https://s3.${region}.amazonaws.com`).replace(/\/+$/, "");
+    const response = await signedCall({
+      http,
+      secrets,
+      service: "s3",
+      region,
+      url: `${endpoint}/${options.bucket}`,
+      init: { method: "HEAD" }
+    });
+    return response.outcome;
+  }
+});
+var aws = { credentials, s3Bucket };
+
+// src/presets/databases.ts
+var mongoPing = definePreset()({
+  kind: "mongodb.ping",
+  requiredFields: ["client"],
+  defaults: { slowMs: 500 },
+  derive: () => ({ name: "MongoDB", description: "`ping` command on the database" }),
+  check: ({ options, measure }) => measure(async () => {
+    const client = options.client;
+    const database = "command" in client ? client : client.db();
+    await database.command({ ping: 1 });
+  })
+});
+var mongodb = { ping: mongoPing };
+var redisPing = definePreset()({
+  kind: "redis.ping",
+  requiredFields: ["client"],
+  defaults: { slowMs: 300 },
+  derive: () => ({ name: "Redis", description: "PING" }),
+  check: ({ options, measure }) => measure(async () => {
+    const client = options.client;
+    const reply = "ping" in client ? await client.ping() : "call" in client ? await client.call("PING") : await client.sendCommand(["PING"]);
+    return String(reply).toUpperCase() === "PONG" ? true : { status: "down", error: `Unexpected reply: ${String(reply)}` };
+  })
+});
+var redis = { ping: redisPing };
+var postgresPing = definePreset()({
+  kind: "postgres.ping",
+  requiredFields: ["query"],
+  defaults: { slowMs: 1e3 },
+  derive: () => ({ name: "PostgreSQL", description: "Runs `select 1`" }),
+  check: ({ options, measure }) => measure(async () => {
+    await options.query("select 1");
+  })
+});
+var postgres = { ping: postgresPing };
+
+// src/presets/providers/shared.ts
+var bearer = (token) => ({ Authorization: `Bearer ${token}` });
+var round = (value, digits = 1) => Math.round(value * 10 ** digits) / 10 ** digits;
+function base64(text) {
+  const bytes = new TextEncoder().encode(text);
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary);
+}
+async function call(http, url, init, refine) {
+  const response = await http(url, init);
+  if (!response.ok || !refine) return response.outcome;
+  return { ...response.outcome, ...normalizeReturn(refine(response)) };
+}
+function quota({
+  label,
+  used,
+  limit,
+  unit,
+  resetsAt,
+  warnAbovePct,
+  warning
+}) {
+  const pct = limit > 0 ? used / limit * 100 : 0;
+  const over = pct >= warnAbovePct;
+  return {
+    status: over ? "degraded" : "up",
+    error: over ? warning : void 0,
+    usage: [{ label, used, limit, unit, resetsAt }]
+  };
+}
+
+// src/presets/providers/ai.ts
+var deepgram = definePreset()({
+  kind: "deepgram",
+  requiredSecrets: ["apiKey"],
+  derive: () => ({ name: "Deepgram", identity: "deepgram", description: "Lists projects, then reads the account balance" }),
+  check: async ({ options, secrets, http }) => {
+    const headers = { Authorization: `Token ${secrets.apiKey}` };
+    const projects = await http("https://api.deepgram.com/v1/projects", { headers });
+    if (!projects.ok) return projects.outcome;
+    const projectId = projects.json?.projects?.[0]?.project_id;
+    if (!projectId) return { ...projects.outcome, status: "degraded", error: "No project visible to this key" };
+    if (options.track?.balance === false) return projects.outcome;
+    const warnBelow = options.track?.balance?.warnBelow ?? 20;
+    const balances = await http(`https://api.deepgram.com/v1/projects/${projectId}/balances`, { headers });
+    const balance = balances.json?.balances?.[0];
+    if (!balances.ok || !balance) return projects.outcome;
+    const low = balance.amount < warnBelow;
+    return {
+      ...projects.outcome,
+      latencyMs: Math.max(projects.latencyMs, balances.latencyMs),
+      status: low ? "degraded" : "up",
+      error: low ? "Low balance" : void 0,
+      metrics: { balance: `${round(balance.amount, 2)} ${balance.units}` }
+    };
+  }
+});
+var gladia = definePreset()({
+  kind: "gladia",
+  requiredSecrets: ["apiKey"],
+  derive: () => ({ name: "Gladia", identity: "gladia", description: "Lists live sessions (limit 1)" }),
+  check: ({ secrets, http }) => call(http, "https://api.gladia.io/v2/live?limit=1", { headers: { "x-gladia-key": secrets.apiKey } })
+});
+var speechmatics = definePreset()({
+  kind: "speechmatics",
+  requiredSecrets: ["apiKey"],
+  derive: () => ({
+    name: "Speechmatics",
+    identity: "speechmatics",
+    description: "Lists batch jobs (limit 1), validating the API key"
+  }),
+  check: ({ options, secrets, http }) => call(http, `${(options.baseUrl ?? "https://asr.api.speechmatics.com").replace(/\/+$/, "")}/v2/jobs?limit=1`, {
+    headers: bearer(secrets.apiKey)
+  })
+});
+var openai = definePreset()({
+  kind: "openai",
+  requiredSecrets: ["apiKey"],
+  derive: (options) => ({
+    name: "OpenAI",
+    identity: "openai",
+    description: options.track?.model ? `Checks access to ${options.track.model}` : "Lists models"
+  }),
+  check: ({ options, secrets, http }) => call(
+    http,
+    options.track?.model ? `https://api.openai.com/v1/models/${encodeURIComponent(options.track.model)}` : "https://api.openai.com/v1/models",
+    {
+      headers: {
+        ...bearer(secrets.apiKey),
+        ...options.organization ? { "OpenAI-Organization": options.organization } : {}
+      }
+    }
+  )
+});
+var anthropic = definePreset()({
+  kind: "anthropic",
+  requiredSecrets: ["apiKey"],
+  derive: () => ({ name: "Anthropic", identity: "anthropic", description: "Lists models" }),
+  check: ({ secrets, http }) => call(http, "https://api.anthropic.com/v1/models?limit=1", {
+    headers: { "x-api-key": secrets.apiKey, "anthropic-version": "2023-06-01" }
+  })
+});
+var gemini = definePreset()({
+  kind: "gemini",
+  requiredSecrets: ["apiKey"],
+  derive: () => ({ name: "Google Gemini", identity: "gemini", description: "Lists models" }),
+  check: ({ secrets, http }) => call(http, "https://generativelanguage.googleapis.com/v1beta/models?pageSize=1", {
+    headers: { "x-goog-api-key": secrets.apiKey }
+  })
+});
+var cambai = definePreset()({
+  kind: "cambai",
+  requiredSecrets: ["apiKey"],
+  derive: () => ({ name: "CAMB.AI", identity: "cambai", description: "Lists source languages" }),
+  check: ({ secrets, http }) => call(http, "https://client.camb.ai/apis/source-languages", { headers: { "x-api-key": secrets.apiKey } })
+});
+var elevenlabs = definePreset()({
+  kind: "elevenlabs",
+  requiredSecrets: ["apiKey"],
+  derive: () => ({ name: "ElevenLabs", identity: "elevenlabs", description: "Reads the subscription" }),
+  check: async ({ options, secrets, http }) => {
+    const res = await http("https://api.elevenlabs.io/v1/user/subscription", {
+      headers: { "xi-api-key": secrets.apiKey }
+    });
+    const body = res.json ?? {};
+    if (res.status === 401 && body.detail?.status === "missing_permissions") {
+      return { status: "up", latencyMs: res.latencyMs, httpStatus: 401, metrics: { key: "restricted" } };
+    }
+    if (!res.ok) return res.outcome;
+    const metrics = body.tier ? { tier: body.tier } : void 0;
+    const { character_count: used, character_limit: limit } = body;
+    if (typeof used !== "number" || !limit) return { ...res.outcome, metrics };
+    return {
+      ...res.outcome,
+      ...quota({
+        label: "Credits",
+        used,
+        limit,
+        unit: "credits",
+        // ElevenLabs gives the reset as epoch seconds
+        resetsAt: body.next_character_count_reset_unix ? body.next_character_count_reset_unix * 1e3 : void 0,
+        warnAbovePct: 100 - (options.track?.quota?.warnBelowPct ?? 10),
+        warning: "Credits almost exhausted"
+      }),
+      metrics
+    };
+  }
+});
+
+// src/presets/providers/translation.ts
+var deepl = definePreset()({
+  kind: "deepl",
+  requiredSecrets: ["apiKey"],
+  derive: () => ({ name: "DeepL", identity: "deepl", description: "Reads character usage for the billing period" }),
+  check: ({ options, secrets, http }) => {
+    const host = secrets.apiKey.endsWith(":fx") ? "api-free.deepl.com" : "api.deepl.com";
+    return call(http, `https://${host}/v2/usage`, { headers: { Authorization: `DeepL-Auth-Key ${secrets.apiKey}` } }, (res) => {
+      const { character_count: used, character_limit: limit } = res.json ?? {};
+      if (typeof used !== "number" || !limit) return void 0;
+      return quota({
+        label: "Characters",
+        used,
+        limit,
+        unit: "characters",
+        warnAbovePct: options.track?.quota?.warnAbovePct ?? 90,
+        warning: "Character quota almost exhausted"
+      });
+    });
+  }
+});
+var azureTranslator = definePreset()({
+  kind: "azure.translator",
+  requiredSecrets: ["apiKey"],
+  derive: () => ({ name: "Azure Translator", identity: "azure.translator", description: "Translates a single character" }),
+  check: ({ options, secrets, http }) => call(http, "https://api.cognitive.microsofttranslator.com/translate?api-version=3.0&to=fr", {
+    method: "POST",
+    headers: {
+      "Ocp-Apim-Subscription-Key": secrets.apiKey,
+      "Ocp-Apim-Subscription-Region": options.region ?? "westeurope",
+      "content-type": "application/json"
+    },
+    body: JSON.stringify([{ Text: "a" }])
+  })
+});
+var googleTranslate = definePreset()({
+  kind: "google.translate",
+  requiredSecrets: ["serviceAccount"],
+  derive: () => ({
+    name: "Google Translate",
+    identity: "google.translate",
+    description: "Lists supported languages with Cloud Translation v3"
+  }),
+  check: async ({ options, secrets, http, now }) => {
+    const account = parseServiceAccount(secrets.serviceAccount);
+    if (!account?.project_id) {
+      return { status: "down", probed: false, error: "The service account secret is not a service-account JSON key" };
+    }
+    const token = await googleServiceAccountToken({
+      account,
+      scope: "https://www.googleapis.com/auth/cloud-translation",
+      http,
+      now
+    });
+    return call(
+      http,
+      `https://translation.googleapis.com/v3/projects/${account.project_id}/locations/${options.location ?? "global"}/supportedLanguages`,
+      { headers: bearer(token) },
+      (res) => {
+        const languages = res.json?.languages;
+        return languages ? { status: "up", metrics: { languages: languages.length } } : void 0;
+      }
+    );
+  }
+});
+
+// src/presets/providers/media.ts
+var mux = definePreset()({
+  kind: "mux",
+  requiredSecrets: ["tokenId", "tokenSecret"],
+  derive: () => ({ name: "Mux", identity: "mux", description: "Lists live streams (limit 1)" }),
+  check: ({ secrets, http }) => call(http, "https://api.mux.com/video/v1/live-streams?limit=1", {
+    headers: { Authorization: `Basic ${base64(`${secrets.tokenId}:${secrets.tokenSecret}`)}` }
+  })
+});
+var cloudflareStream = definePreset()({
+  kind: "cloudflare.stream",
+  requiredFields: ["accountId"],
+  requiredSecrets: ["token"],
+  derive: () => ({
+    name: "Cloudflare Stream",
+    identity: "cloudflare.stream",
+    description: "Lists videos (limit 1) and reads storage usage against the plan limit"
+  }),
+  check: async ({ options, secrets, http, combine }) => {
+    const base = `https://api.cloudflare.com/client/v4/accounts/${options.accountId}/stream`;
+    const init = { headers: bearer(secrets.token) };
+    const rejected = (json) => json?.success === false ? { status: "down", error: "Cloudflare API reported success=false" } : void 0;
+    const videos = call(http, `${base}?limit=1`, init, (res) => rejected(res.json));
+    if (options.track?.storage === false) return videos;
+    const warnAbovePct = options.track?.storage?.warnAbovePct ?? 90;
+    const storage = call(http, `${base}/storage-usage`, init, (res) => {
+      const failed = rejected(res.json);
+      if (failed) return failed;
+      const usage = res.json?.result;
+      if (!usage?.totalStorageMinutesLimit) return void 0;
+      return {
+        ...quota({
+          label: "Video storage",
+          used: Math.round(usage.totalStorageMinutes ?? 0),
+          limit: usage.totalStorageMinutesLimit,
+          unit: "min",
+          warnAbovePct,
+          warning: "Stream storage almost full"
+        }),
+        metrics: { videos: usage.videoCount ?? 0 }
+      };
+    });
+    return combine(await Promise.all([videos, storage]));
+  }
+});
+
+// src/presets/providers/services.ts
+var mailersend = definePreset()({
+  kind: "mailersend",
+  requiredSecrets: ["apiKey"],
+  derive: () => ({ name: "MailerSend", identity: "mailersend", description: "Reads the API quota" }),
+  check: ({ options, secrets, http }) => call(http, "https://api.mailersend.com/v1/api-quota", { headers: bearer(secrets.apiKey) }, (res) => {
+    const { quota: limit, remaining, reset } = res.json ?? {};
+    if (!limit || typeof remaining !== "number") return void 0;
+    const resetsAt = reset ? Date.parse(reset) : NaN;
+    return quota({
+      label: "API requests",
+      used: limit - remaining,
+      limit,
+      unit: "requests",
+      resetsAt: Number.isNaN(resetsAt) ? void 0 : resetsAt,
+      warnAbovePct: 100 - (options.track?.quota?.warnBelowPct ?? 10),
+      warning: "API quota almost exhausted"
+    });
+  })
+});
+var github = definePreset()({
+  kind: "github",
+  requiredSecrets: ["token"],
+  derive: (options) => ({
+    name: "GitHub",
+    identity: options.track?.repo ? `github:${options.track.repo}` : "github",
+    description: options.track?.repo ? `Reads the API rate limit and the releases of ${options.track.repo}` : "Reads the API rate limit"
+  }),
+  check: async ({ options, secrets, http, combine }) => {
+    const headers = { ...bearer(secrets.token), "user-agent": "sermon-js", accept: "application/vnd.github+json" };
+    const limit = call(http, "https://api.github.com/rate_limit", { headers }, (res) => {
+      const core = res.json?.resources?.core;
+      if (!core) return void 0;
+      return quota({
+        label: "API requests this hour",
+        used: core.limit - core.remaining,
+        limit: core.limit,
+        unit: "requests",
+        // GitHub gives the reset as epoch seconds
+        resetsAt: core.reset * 1e3,
+        warnAbovePct: 100 - (options.track?.rateLimit?.warnBelowPct ?? 10),
+        warning: "Rate limit almost exhausted"
+      });
+    });
+    if (!options.track?.repo) return limit;
+    const repo = call(http, `https://api.github.com/repos/${options.track.repo}/releases?per_page=1`, { headers });
+    return combine(await Promise.all([limit, repo]));
+  }
+});
+var revolut = definePreset()({
+  kind: "revolut",
+  requiredSecrets: ["apiKey"],
+  derive: () => ({ name: "Revolut Merchant", identity: "revolut", description: "Lists orders (limit 1)" }),
+  check: ({ options, secrets, http }) => {
+    const host = options.environment === "sandbox" ? "sandbox-merchant.revolut.com" : "merchant.revolut.com";
+    return call(http, `https://${host}/api/1.0/orders?limit=1`, {
+      headers: { ...bearer(secrets.apiKey), "Revolut-Api-Version": "2023-09-01" }
+    });
+  }
+});
+var attendee = definePreset()({
+  kind: "attendee",
+  requiredSecrets: ["apiKey"],
+  derive: () => ({ name: "Attendee", identity: "attendee", description: "Lists bots" }),
+  check: ({ options, secrets, http }) => call(http, `${(options.baseUrl || "https://app.attendee.dev").replace(/\/+$/, "")}/api/v1/bots?page_size=1`, {
+    headers: { Authorization: `Token ${secrets.apiKey}` }
+  })
+});
+var axiom = definePreset()({
+  kind: "axiom",
+  requiredFields: ["dataset"],
+  requiredSecrets: ["token"],
+  derive: () => ({ name: "Axiom", identity: "axiom", description: "Ingests an empty batch into the logs dataset" }),
+  check: ({ options, secrets, http }) => call(
+    http,
+    options.edge ? `https://${options.edge}/v1/ingest/${options.dataset}` : `https://api.axiom.co/v1/datasets/${options.dataset}/ingest`,
+    { method: "POST", headers: { ...bearer(secrets.token), "content-type": "application/json" }, body: "[]" }
+  )
+});
+var upstashRedis = definePreset()({
+  kind: "upstash.redis",
+  requiredFields: ["url"],
+  requiredSecrets: ["token"],
+  defaults: { slowMs: 500 },
+  derive: () => ({ name: "Redis", description: "PING through the REST API" }),
+  check: ({ options, secrets, http }) => call(
+    http,
+    options.url.replace(/\/+$/, ""),
+    {
+      method: "POST",
+      headers: { ...bearer(secrets.token), "content-type": "application/json" },
+      body: '["PING"]'
+    },
+    (res) => res.json?.result === "PONG" ? void 0 : { status: "down", error: "Unexpected reply to PING" }
+  )
+});
+var statuspage = definePreset()({
+  kind: "statuspage",
+  requiredFields: ["url"],
+  derive: (options) => {
+    let host = options.url;
+    try {
+      host = new URL(options.url).host;
+    } catch {
+    }
+    return {
+      name: host,
+      identity: `statuspage:${host}`,
+      description: "Status reported by the provider's public status page"
+    };
+  },
+  check: ({ options, http }) => call(http, `${options.url.replace(/\/+$/, "")}/api/v2/status.json`, void 0, (res) => {
+    const { indicator, description } = res.json?.status ?? {};
+    if (!indicator) return { status: "degraded", error: "Not a Statuspage answer" };
+    const status = indicator === "none" ? "up" : indicator === "minor" ? "degraded" : "down";
+    return { status, error: status === "up" ? void 0 : description };
+  })
+});
+var resend = definePreset()({
+  kind: "resend",
+  requiredSecrets: ["apiKey"],
+  derive: () => ({ name: "Resend", identity: "resend", description: "Lists domains" }),
+  check: async ({ secrets, http }) => {
+    const res = await http("https://api.resend.com/domains", { headers: bearer(secrets.apiKey) });
+    const body = res.json ?? {};
+    if (res.status === 401 && body.name === "restricted_api_key") {
+      return { status: "up", latencyMs: res.latencyMs, httpStatus: 401, metrics: { key: "sending only" } };
+    }
+    if (!res.ok || !Array.isArray(body.data)) return res.outcome;
+    const verified = body.data.filter((domain) => domain.status === "verified").length;
+    const unverified = body.data.length > 0 && verified === 0;
+    return {
+      ...res.outcome,
+      status: unverified ? "degraded" : "up",
+      error: unverified ? "No verified domain" : void 0,
+      metrics: { domains: body.data.length, verified }
+    };
+  }
+});
+var meilisearch = definePreset()({
+  kind: "meilisearch",
+  requiredFields: ["host"],
+  requiredSecrets: ["apiKey"],
+  derive: (options) => ({
+    name: "Meilisearch",
+    identity: options.index ? `meilisearch:${options.index}` : "meilisearch",
+    description: options.index ? `Reads the health and the ${options.index} index` : "Reads the health and lists indexes"
+  }),
+  check: async ({ options, secrets, http, combine }) => {
+    const host = options.host.replace(/\/+$/, "");
+    const headers = bearer(secrets.apiKey);
+    const index = options.index ? `/indexes/${encodeURIComponent(options.index)}` : void 0;
+    const health = call(
+      http,
+      `${host}/health`,
+      void 0,
+      (res2) => res2.json?.status === "available" ? void 0 : { status: "down", error: "Not available" }
+    );
+    const access = http(`${host}${index ?? "/indexes?limit=1"}`, { headers }).then((res2) => {
+      if (res2.status !== 404 || !options.index) return res2.outcome;
+      return {
+        status: "degraded",
+        latencyMs: res2.latencyMs,
+        httpStatus: 404,
+        error: `Index ${options.index} not found`
+      };
+    });
+    const stats = http(`${host}${index ?? ""}/stats`, { headers });
+    const outcome = combine(await Promise.all([health, access]));
+    const res = await stats;
+    if (!res.ok) return outcome;
+    const body = res.json ?? {};
+    const documents = body.numberOfDocuments ?? Object.values(body.indexes ?? {}).reduce((sum, entry) => sum + (entry.numberOfDocuments ?? 0), 0);
+    return { ...outcome, metrics: { ...outcome.metrics, documents, ...body.isIndexing ? { indexing: "yes" } : {} } };
+  }
+});
+
+// src/presets/providers/pusher.ts
+var MAX_CHANNELS = 500;
+var CONCURRENCY = 10;
+var DAY_MS = 24 * 60 * 60 * 1e3;
+async function hmacSha256Hex(secret, message) {
+  const encoder = new TextEncoder();
+  const key = await crypto.subtle.importKey("raw", encoder.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, [
+    "sign"
+  ]);
+  const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(message));
+  return [...new Uint8Array(signature)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function signPusherRequest({
+  appId,
+  key,
+  secret,
+  path,
+  params = {},
+  timestamp = Math.floor(Date.now() / 1e3)
+}) {
+  const fullPath = `/apps/${appId}${path}`;
+  const search = new URLSearchParams({
+    ...params,
+    auth_key: key,
+    auth_timestamp: String(timestamp),
+    auth_version: "1.0"
+  });
+  search.sort();
+  const query = decodeURIComponent(search.toString());
+  const signature = await hmacSha256Hex(secret, ["GET", fullPath, query].join("\n"));
+  return `${fullPath}?${query}&auth_signature=${signature}`;
+}
+function baseUrl(options) {
+  const host = options.host || `api-${options.cluster || "mt1"}.pusher.com`;
+  const port = options.port === void 0 || options.port === "" ? void 0 : String(options.port);
+  const tls = options.tls ?? (!port || port === "443");
+  const defaultPort = tls ? "443" : "80";
+  return `${tls ? "https" : "http"}://${host}${port && port !== defaultPort ? `:${port}` : ""}`;
+}
+async function mapLimit(items, limit, fn) {
+  const results = new Array(items.length);
+  let next = 0;
+  await Promise.all(
+    Array.from({ length: Math.min(limit, items.length) }, async () => {
+      while (next < items.length) {
+        const index = next++;
+        results[index] = await fn(items[index]);
+      }
+    })
+  );
+  return results;
+}
+var utcDay = (now) => new Date(now).toISOString().slice(0, 10);
+var pusher = definePreset()({
+  kind: "pusher",
+  requiredFields: ["appId"],
+  requiredSecrets: ["key", "secret"],
+  defaults: { slowMs: 1e3 },
+  derive: (options) => ({
+    name: "Pusher",
+    identity: `pusher:${options.appId ?? ""}`,
+    description: "Lists occupied channels and estimates connections from their subscription counts"
+  }),
+  check: async ({ options, secrets, http, cache, now }) => {
+    const get = async (path, params) => http(
+      `${baseUrl(options)}${await signPusherRequest({
+        appId: options.appId,
+        key: secrets.key,
+        secret: secrets.secret,
+        path,
+        params,
+        timestamp: Math.floor(now / 1e3)
+      })}`
+    );
+    const list = await get("/channels");
+    if (!list.ok) return list.outcome;
+    const names = Object.keys(list.json?.channels ?? {});
+    const queried = names.slice(0, MAX_CHANNELS);
+    let failed = 0;
+    let countingDisabled = false;
+    const counts = await mapLimit(queried, CONCURRENCY, async (name) => {
+      const res = await get(`/channels/${encodeURIComponent(name)}`, { info: "subscription_count" });
+      const count = res.json?.subscription_count;
+      if (!res.ok) failed += 1;
+      else if (typeof count !== "number") countingDisabled = true;
+      return typeof count === "number" ? count : 0;
+    });
+    const connections = counts.reduce((sum, count) => sum + count, 0);
+    const signedInUsers = queried.reduce(
+      (sum, name, index) => name.startsWith("#server-to-user-") ? sum + (counts[index] ?? 0) : sum,
+      0
+    );
+    const peakKey = `peak:${utcDay(now)}`;
+    const peak = Math.max(connections, Number(await cache.get(peakKey)) || 0);
+    await cache.set(peakKey, String(peak), 8 * DAY_MS);
+    const metrics = { channels: names.length, signedInUsers };
+    if (names.length > MAX_CHANNELS) metrics.channelsCounted = MAX_CHANNELS;
+    const max = options.track?.connections?.max;
+    const warnAbovePct = options.track?.connections?.warnAbovePct ?? 90;
+    const usage = [];
+    if (max) {
+      usage.push(
+        { label: "Connections now (estimate)", used: connections, limit: max, unit: "connections" },
+        {
+          label: "Peak connections today (UTC)",
+          used: peak,
+          limit: max,
+          unit: "connections",
+          resetsAt: Date.parse(`${utcDay(now)}T00:00:00Z`) + DAY_MS
+        }
+      );
+    } else {
+      metrics.connections = connections;
+      metrics.peakToday = peak;
+    }
+    const warnings = [];
+    if (max && peak / max * 100 >= warnAbovePct) warnings.push("Connections close to the plan limit");
+    if (countingDisabled) warnings.push("Subscription counting is disabled in the Pusher app settings");
+    const notes = failed > 0 ? [`${failed} channel(s) could not be counted`] : [];
+    return {
+      status: warnings.length ? "degraded" : "up",
+      latencyMs: list.latencyMs,
+      httpStatus: list.status,
+      error: [...warnings, ...notes].join("; ") || void 0,
+      metrics,
+      usage: usage.length ? usage : void 0
+    };
+  }
+});
+
+// src/presets/providers/vercel.ts
+var aiGateway = definePreset()({
+  kind: "vercel.aiGateway",
+  requiredSecrets: ["apiKey"],
+  derive: (options) => ({
+    name: "Vercel AI Gateway",
+    identity: "vercel.aiGateway",
+    description: options.track?.credits === false ? "Lists models" : "Reads the credit balance"
+  }),
+  check: ({ options, secrets, http }) => {
+    const headers = bearer(secrets.apiKey);
+    if (options.track?.credits === false) return call(http, "https://ai-gateway.vercel.sh/v1/models", { headers });
+    const warnBelow = options.track?.credits?.warnBelow ?? 5;
+    return call(http, "https://ai-gateway.vercel.sh/v1/credits", { headers }, (res) => {
+      const body = res.json ?? {};
+      const balance = Number(body.balance);
+      if (body.balance === void 0 || !Number.isFinite(balance)) return void 0;
+      const used = Number(body.total_used);
+      const low = balance < warnBelow;
+      return {
+        status: low ? "degraded" : "up",
+        error: low ? "Low credit balance" : void 0,
+        metrics: {
+          balance: `${round(balance, 2)} USD`,
+          ...body.total_used !== void 0 && Number.isFinite(used) ? { used: `${round(used, 2)} USD` } : {}
+        }
+      };
+    });
+  }
+});
+var blob = definePreset()({
+  kind: "vercel.blob",
+  requiredSecrets: ["token"],
+  derive: () => ({ name: "Vercel Blob", identity: "vercel.blob", description: "Lists one blob of the store" }),
+  check: ({ secrets, http }) => call(http, "https://vercel.com/api/blob?limit=1", {
+    headers: { ...bearer(secrets.token), "x-api-version": "12" }
+  })
+});
+var vercel = { aiGateway, blob };
+
+export { anthropic, attendee, aws, axiom, azureTranslator, cambai, clearGoogleTokens, cloudflareStream, crashReason, deepgram, deepl, elevenlabs, fly, gcp, gemini, github, gladia, googleServiceAccountToken, googleTranslate, mailersend, meilisearch, mongodb, mux, openai, parseServiceAccount, postgres, pusher, redis, resend, revolut, signGoogleAssertion, signPusherRequest, speechmatics, statuspage, upstashRedis, vercel };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map