ericrisco/rsc-harness / skills/harness
harness
FlaggedUse when governing a workspace's control plane, code or not — the `01-TOOLS/` tooling layer, the `02-DOCS/` chaos→knowledge wiki, the root Knowledge map. Audits it, migrates legacy `XX-*` folders, scaffolds provider tooling, sweeps the inbox, eats a file the person hands over ("cómete este fichero", "guárdalo en la documentación": moved into 02-DOCS/raw/ and documented), writes root CLAUDE.md/AGENTS.md. NOT the bootstrap front door (that is `init`, which hands off here).
references/providers.yaml
View on GitHub# Provider catalog for harness.
#
# Each entry defines how to DETECT a provider in a workspace and what to SHIP
# inside 01-TOOLS/<ID>/ when it is detected. Adding a new provider = add a new
# entry here. The SKILL.md never needs to change.
#
# Schema:
# id: uppercase folder name under 01-TOOLS/
# category: grouping for 01-TOOLS/README.md
# detectors:
# imports: list of grep patterns for SDK imports (any match)
# env_vars: list of env var names to grep
# deps: list of dependency names in manifests
# env_example: literal body of .env.example
# dashboard_url: provider dashboard for credentials
# files: map of relative path -> file body
# Variables: {{TODAY}}
# manual_only: true if provider has no automated test_connection
# (e.g. credentials kept for human dashboard use)
providers:
- id: STRIPE
category: pagos
detectors:
imports:
- "import stripe"
- "from stripe"
- "require('stripe')"
- "require(\"stripe\")"
- "@stripe/stripe-js"
- "@stripe/stripe-node"
env_vars:
- "STRIPE_SECRET_KEY"
- "STRIPE_PUBLISHABLE_KEY"
- "STRIPE_WEBHOOK_SECRET"
deps:
- "stripe"
- "@stripe/stripe-js"
- "@stripe/stripe-node"
dashboard_url: "https://dashboard.stripe.com/apikeys"
env_example: |
# STRIPE — operational credentials
# Generate at: https://dashboard.stripe.com/apikeys
#
# Copy this file to `.env`, fill in real values, and `chmod 600 .env`.
STRIPE_SECRET_KEY=
STRIPE_PUBLISHABLE_KEY=
STRIPE_WEBHOOK_SECRET=
files:
test_connection.sh: |
#!/usr/bin/env bash
# Smoke-test against Stripe API: GET /v1/account.
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
ENV_PATH="$SCRIPT_DIR/.env"
[ -f "$ENV_PATH" ] || { echo "ERROR: missing $ENV_PATH" >&2; exit 1; }
set -a; source "$ENV_PATH"; set +a
: "${STRIPE_SECRET_KEY:?STRIPE_SECRET_KEY not set in $ENV_PATH}"
RESP=$(curl -fsS -u "$STRIPE_SECRET_KEY:" https://api.stripe.com/v1/account)
echo "$RESP" | python3 -c 'import json,sys; d=json.load(sys.stdin); print(f"OK — account: {d[\"id\"]} ({d.get(\"business_profile\",{}).get(\"name\",\"-\")})")'
README.md: |
# STRIPE
Operations against the project Stripe account: pricing, customers,
subscriptions, webhook events.
## Setup
1. `cp .env.example .env && chmod 600 .env`
2. Set `STRIPE_SECRET_KEY` from https://dashboard.stripe.com/apikeys
3. `./test_connection.sh` — should print `OK — account: acct_…`
## Scripts
| Script | What it does |
|--------|--------------|
| `test_connection.sh` | Smoke-test against `/v1/account`. |
## Notes
- The product backend consumes Stripe via its own runtime SDK.
This tool is for manual terminal-driven operations only.
CREDENTIALS.md: |
# Credentials — STRIPE
## Dashboard
- URL: https://dashboard.stripe.com/apikeys
- 2FA mandatory.
## Variables
| Variable | Type | Where to generate | Rotation |
|----------|------|-------------------|----------|
| `STRIPE_SECRET_KEY` | secret | Dashboard → Developers → API keys | on suspected leak |
| `STRIPE_PUBLISHABLE_KEY` | public | Dashboard → Developers → API keys | n/a |
| `STRIPE_WEBHOOK_SECRET` | secret | Dashboard → Developers → Webhooks → endpoint | whenever the endpoint changes |
## If a credential leaks
1. Revocar inmediatamente en el dashboard (rolling key).
2. Generar una nueva y actualizar `.env` local.
3. Si el backend la consume en runtime: actualizar env vars del despliegue.
- id: MAILJET
category: pagos_email
detectors:
imports:
- "import mailjet_rest"
- "from mailjet_rest"
- "node-mailjet"
- "require('node-mailjet')"
env_vars:
- "MAILJET_API_KEY"
- "MAILJET_API_SECRET"
- "MJ_APIKEY_PUBLIC"
- "MJ_APIKEY_PRIVATE"
deps:
- "mailjet-rest"
- "node-mailjet"
- "mailjet"
dashboard_url: "https://app.mailjet.com/account/apikeys"
env_example: |
# MAILJET — operational credentials
# Generate at: https://app.mailjet.com/account/apikeys
MAILJET_API_KEY=
MAILJET_API_SECRET=
MAILJET_FROM_EMAIL=
MAILJET_FROM_NAME=
files:
test_connection.sh: |
#!/usr/bin/env bash
# Smoke-test against Mailjet API: GET /v3/REST/sender.
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
ENV_PATH="$SCRIPT_DIR/.env"
[ -f "$ENV_PATH" ] || { echo "ERROR: missing $ENV_PATH" >&2; exit 1; }
set -a; source "$ENV_PATH"; set +a
: "${MAILJET_API_KEY:?MAILJET_API_KEY not set}"
: "${MAILJET_API_SECRET:?MAILJET_API_SECRET not set}"
RESP=$(curl -fsS -u "$MAILJET_API_KEY:$MAILJET_API_SECRET" https://api.mailjet.com/v3/REST/sender)
echo "$RESP" | python3 -c 'import json,sys; d=json.load(sys.stdin); print(f"OK — registered senders: {d[\"Count\"]}")'
README.md: |
# MAILJET
Transactional email (verification, invites, password reset).
## Setup
1. `cp .env.example .env && chmod 600 .env`
2. Fill in `MAILJET_API_KEY` and `MAILJET_API_SECRET` from https://app.mailjet.com/account/apikeys
3. `./test_connection.sh`
## Scripts
| Script | What it does |
|--------|--------------|
| `test_connection.sh` | Lists registered senders — confirms auth. |
CREDENTIALS.md: |
# Credentials — MAILJET
Dashboard: https://app.mailjet.com/account/apikeys
| Variable | Type | Where to generate |
|----------|------|-------------------|
| `MAILJET_API_KEY` | public | Dashboard → API Keys |
| `MAILJET_API_SECRET` | secret | Dashboard → API Keys |
| `MAILJET_FROM_EMAIL` | config | Address verified as sender |
| `MAILJET_FROM_NAME` | config | Display name shown to recipients |
- id: HETZNER
category: infra
detectors:
imports:
- "hcloud"
- "from hcloud"
env_vars:
- "HCLOUD_TOKEN"
- "HETZNER_TOKEN"
- "HETZNER_API_TOKEN"
deps:
- "hcloud"
- "hetznercloud"
dashboard_url: "https://console.hetzner.cloud/projects"
env_example: |
# HETZNER Cloud — operational credentials
# Generate at: https://console.hetzner.cloud (proyecto → Security → API tokens)
HCLOUD_TOKEN=
files:
test_connection.py: |
#!/usr/bin/env python3
"""Smoke-test against Hetzner Cloud API: GET /v1/servers."""
import os, sys, urllib.request, urllib.error, json
from pathlib import Path
env_path = Path(__file__).parent / ".env"
if not env_path.exists():
print(f"ERROR: missing {env_path}", file=sys.stderr); sys.exit(1)
for line in env_path.read_text().splitlines():
line = line.strip()
if not line or line.startswith("#") or "=" not in line: continue
k, v = line.split("=", 1); os.environ.setdefault(k, v)
token = os.environ.get("HCLOUD_TOKEN")
if not token:
print("ERROR: HCLOUD_TOKEN not set", file=sys.stderr); sys.exit(1)
req = urllib.request.Request(
"https://api.hetzner.cloud/v1/servers",
headers={"Authorization": f"Bearer {token}"},
)
try:
with urllib.request.urlopen(req, timeout=10) as r:
data = json.load(r)
n = len(data.get("servers", []))
print(f"OK — servers in the project: {n}")
except urllib.error.HTTPError as e:
print(f"FAIL: {e.code} {e.reason}", file=sys.stderr); sys.exit(1)
README.md: |
# HETZNER
Provisioning and operation of Hetzner Cloud servers.
## Setup
1. `cp .env.example .env && chmod 600 .env`
2. Create an API token for the project: https://console.hetzner.cloud
3. `python3 test_connection.py`
## Scripts
| Script | What it does |
|--------|--------------|
| `test_connection.py` | Lists servers in the project — confirms auth. |
CREDENTIALS.md: |
# Credentials — HETZNER
Dashboard: https://console.hetzner.cloud
| Variable | Type | Where to generate | Rotation |
|----------|------|-------------------|----------|
| `HCLOUD_TOKEN` | secret | Project → Security → API tokens | revoke + regenerate on leak |
- id: REPLICATE
category: ia
detectors:
imports:
- "import replicate"
- "from replicate"
- "require('replicate')"
env_vars:
- "REPLICATE_API_TOKEN"
deps:
- "replicate"
dashboard_url: "https://replicate.com/account/api-tokens"
env_example: |
# REPLICATE — operational credentials
# Generate at: https://replicate.com/account/api-tokens
REPLICATE_API_TOKEN=
files:
test_connection.py: |
#!/usr/bin/env python3
"""Smoke-test against Replicate API: GET /v1/account."""
import os, sys, urllib.request, urllib.error, json
from pathlib import Path
env_path = Path(__file__).parent / ".env"
if not env_path.exists():
print(f"ERROR: missing {env_path}", file=sys.stderr); sys.exit(1)
for line in env_path.read_text().splitlines():
line = line.strip()
if not line or line.startswith("#") or "=" not in line: continue
k, v = line.split("=", 1); os.environ.setdefault(k, v)
token = os.environ.get("REPLICATE_API_TOKEN")
if not token:
print("ERROR: REPLICATE_API_TOKEN not set", file=sys.stderr); sys.exit(1)
req = urllib.request.Request(
"https://api.replicate.com/v1/account",
headers={"Authorization": f"Bearer {token}"},
)
try:
with urllib.request.urlopen(req, timeout=10) as r:
data = json.load(r)
print(f"OK — username: {data.get('username','?')} type: {data.get('type','?')}")
except urllib.error.HTTPError as e:
print(f"FAIL: {e.code} {e.reason}", file=sys.stderr); sys.exit(1)
README.md: |
# REPLICATE
Image and model generation via Replicate.
## Setup
1. `cp .env.example .env && chmod 600 .env`
2. Token from https://replicate.com/account/api-tokens
3. `python3 test_connection.py`
CREDENTIALS.md: |
# Credentials — REPLICATE
Dashboard: https://replicate.com/account/api-tokens
| Variable | Type | Rotation |
|----------|------|----------|
| `REPLICATE_API_TOKEN` | secret | revoke + regenerate on leak |
- id: FIREBASE
category: mobile_auth
detectors:
imports:
- "firebase-admin"
- "from firebase_admin"
- "import firebase_admin"
- "firebase/app"
- "firebase/messaging"
- "@react-native-firebase"
env_vars:
- "FIREBASE_PROJECT_ID"
- "FCM_SERVER_KEY"
- "GOOGLE_APPLICATION_CREDENTIALS"
deps:
- "firebase-admin"
- "firebase"
- "@react-native-firebase/app"
dashboard_url: "https://console.firebase.google.com"
env_example: |
# FIREBASE / FCM — operational credentials
# Required: service account JSON downloaded from the Firebase project.
# Console → Project settings → Service accounts → Generate new private key
FIREBASE_PROJECT_ID=
GOOGLE_APPLICATION_CREDENTIALS=./service-account.json
files:
test_connection.py: |
#!/usr/bin/env python3
"""Smoke-test FCM: firma un JWT y pide un access token a Google."""
import os, sys, json, time, base64, hmac, hashlib, urllib.request, urllib.parse
from pathlib import Path
env_path = Path(__file__).parent / ".env"
if not env_path.exists():
print(f"ERROR: missing {env_path}", file=sys.stderr); sys.exit(1)
for line in env_path.read_text().splitlines():
line = line.strip()
if not line or line.startswith("#") or "=" not in line: continue
k, v = line.split("=", 1); os.environ.setdefault(k, v)
sa_path = os.environ.get("GOOGLE_APPLICATION_CREDENTIALS", "./service-account.json")
sa_path = (Path(__file__).parent / sa_path).resolve()
if not sa_path.exists():
print(f"ERROR: service account not found at {sa_path}", file=sys.stderr); sys.exit(1)
try:
from google.oauth2 import service_account
from google.auth.transport.requests import Request
except ImportError:
print("ERROR: pip install google-auth", file=sys.stderr); sys.exit(1)
creds = service_account.Credentials.from_service_account_file(
str(sa_path),
scopes=["https://www.googleapis.com/auth/firebase.messaging"],
)
creds.refresh(Request())
if creds.token:
print(f"OK — FCM access token obtained (project: {os.environ.get('FIREBASE_PROJECT_ID','?')})")
else:
print("FAIL: no token obtained", file=sys.stderr); sys.exit(1)
requirements.txt: |
google-auth>=2.0
README.md: |
# FIREBASE / FCM
Push notifications for Android / iOS / Web via Firebase Cloud Messaging.
## Setup
1. Download the service account JSON from Console → Project settings → Service accounts.
2. Save it as `service-account.json` in this folder (gitignored).
3. `cp .env.example .env && chmod 600 .env` and fill in `FIREBASE_PROJECT_ID`.
4. `pip install -r requirements.txt`
5. `python3 test_connection.py`
CREDENTIALS.md: |
# Credentials — FIREBASE
Dashboard: https://console.firebase.google.com
| Artifact | Where to generate | Notes |
|----------|-------------------|-------|
| service-account.json | Project settings → Service accounts → Generate new private key | DO NOT commit; gitignored |
| `FIREBASE_PROJECT_ID` | Project settings → General | Identifies the project |
## Manual FCM setup per platform
- Android: `google-services.json` in `android/app/`.
- iOS: `GoogleService-Info.plist` in the app bundle.
- Web: client config with `apiKey`, `messagingSenderId`, `appId`.
- id: GOOGLE_OAUTH
category: mobile_auth
detectors:
imports:
- "google-auth-oauthlib"
- "from google.oauth2"
- "next-auth/providers/google"
- "@react-oauth/google"
env_vars:
- "GOOGLE_CLIENT_ID"
- "GOOGLE_CLIENT_SECRET"
- "GOOGLE_OAUTH_CLIENT_ID"
deps:
- "google-auth-oauthlib"
- "@react-oauth/google"
- "next-auth"
dashboard_url: "https://console.cloud.google.com/apis/credentials"
env_example: |
# GOOGLE OAuth 2.0 — operational credentials
# Generate at: https://console.cloud.google.com/apis/credentials
# Need a Client ID + Secret per platform (Web/Android/iOS).
GOOGLE_CLIENT_ID=
GOOGLE_CLIENT_SECRET=
GOOGLE_REDIRECT_URI=
files:
test_connection.sh: |
#!/usr/bin/env bash
# Smoke-test: validate that Google's discovery endpoint responds
# and that GOOGLE_CLIENT_ID has a reasonable shape.
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
ENV_PATH="$SCRIPT_DIR/.env"
[ -f "$ENV_PATH" ] || { echo "ERROR: missing $ENV_PATH" >&2; exit 1; }
set -a; source "$ENV_PATH"; set +a
: "${GOOGLE_CLIENT_ID:?GOOGLE_CLIENT_ID not set}"
[[ "$GOOGLE_CLIENT_ID" == *".apps.googleusercontent.com" ]] || {
echo "FAIL: GOOGLE_CLIENT_ID does not end with .apps.googleusercontent.com" >&2; exit 1; }
curl -fsS https://accounts.google.com/.well-known/openid-configuration > /dev/null
echo "OK — discovery endpoint reachable and client_id shape is valid."
README.md: |
# GOOGLE_OAUTH
Login with Google. Per-platform Client IDs (Web, Android, iOS).
## Setup
1. `cp .env.example .env && chmod 600 .env`
2. Client IDs from https://console.cloud.google.com/apis/credentials
3. `./test_connection.sh`
## Notes
- For Android/iOS: the client_id is shipped in the app (not a secret).
- For Web: you need client_secret and a registered redirect_uri.
CREDENTIALS.md: |
# Credentials — GOOGLE OAuth
Dashboard: https://console.cloud.google.com/apis/credentials
| Variable | Type | Notes |
|----------|------|-------|
| `GOOGLE_CLIENT_ID` | public-ish | OAuth client identifier |
| `GOOGLE_CLIENT_SECRET` | secret | Web only. NEVER in mobile apps. |
| `GOOGLE_REDIRECT_URI` | config | Must match exactly a registered URI |
- id: DB_CLI
category: datos
detectors:
imports:
- "from sqlalchemy"
- "import sqlalchemy"
- "psycopg"
- "asyncpg"
- "from pg"
- "require('pg')"
env_vars:
- "DATABASE_URL"
- "POSTGRES_USER"
- "POSTGRES_PASSWORD"
- "POSTGRES_HOST"
- "POSTGRES_DB"
deps:
- "sqlalchemy"
- "psycopg"
- "psycopg2-binary"
- "asyncpg"
- "pg"
- "drizzle-orm"
dashboard_url: ""
env_example: |
# DB_CLI — access to the project's Postgres database
# If the DB is on a remote server via SSH, set SSH_HOST + SSH_USER.
# If local, only POSTGRES_* is needed.
DATABASE_URL=postgresql://user:pass@host:5432/dbname
# Alternative: individual vars
POSTGRES_HOST=localhost
POSTGRES_PORT=5432
POSTGRES_USER=
POSTGRES_PASSWORD=
POSTGRES_DB=
# Optional — for a DB behind an SSH bastion
SSH_HOST=
SSH_USER=
files:
test_connection.sh: |
#!/usr/bin/env bash
# Smoke-test against Postgres: pg_isready (local or via SSH).
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
ENV_PATH="$SCRIPT_DIR/.env"
[ -f "$ENV_PATH" ] || { echo "ERROR: missing $ENV_PATH" >&2; exit 1; }
set -a; source "$ENV_PATH"; set +a
if [ -n "${SSH_HOST:-}" ] && [ -n "${SSH_USER:-}" ]; then
ssh "${SSH_USER}@${SSH_HOST}" "pg_isready -h ${POSTGRES_HOST:-localhost} -p ${POSTGRES_PORT:-5432}"
echo "OK — Postgres reachable via ${SSH_USER}@${SSH_HOST}."
else
: "${POSTGRES_HOST:?POSTGRES_HOST or DATABASE_URL not set}"
pg_isready -h "${POSTGRES_HOST}" -p "${POSTGRES_PORT:-5432}" -U "${POSTGRES_USER:-postgres}"
echo "OK — Local Postgres reachable."
fi
abrir_psql.sh: |
#!/usr/bin/env bash
# Opens an interactive psql session against the DB in .env.
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
if [ -n "${DATABASE_URL:-}" ]; then
psql "$DATABASE_URL"
else
PGPASSWORD="$POSTGRES_PASSWORD" psql -h "$POSTGRES_HOST" -p "${POSTGRES_PORT:-5432}" -U "$POSTGRES_USER" -d "$POSTGRES_DB"
fi
README.md: |
# DB_CLI
Terminal access to the project's Postgres database.
## Setup
1. `cp .env.example .env && chmod 600 .env` and fill in.
2. `./test_connection.sh`
3. `./abrir_psql.sh` for an interactive session.
## Notes
- If the production DB does not expose a public port, set
`SSH_HOST`/`SSH_USER` and the script will tunnel via SSH.
CREDENTIALS.md: |
# Credentials — DB_CLI
| Variable | Type | Notes |
|----------|------|-------|
| `DATABASE_URL` | secret | Full DSN, alternative to the individual vars |
| `POSTGRES_PASSWORD` | secret | Rotate on exposure |
- id: COOLIFY
category: infra
detectors:
imports: []
env_vars:
- "COOLIFY_TOKEN"
- "COOLIFY_URL"
deps: []
dashboard_url: ""
manual_only: false
env_example: |
# COOLIFY — self-hosted PaaS panel
COOLIFY_URL=
COOLIFY_TOKEN=
files:
test_connection.sh: |
#!/usr/bin/env bash
# Smoke-test against Coolify API: GET /api/v1/version.
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${COOLIFY_URL:?COOLIFY_URL not set}"
: "${COOLIFY_TOKEN:?COOLIFY_TOKEN not set}"
RESP=$(curl -fsS -H "Authorization: Bearer $COOLIFY_TOKEN" "${COOLIFY_URL%/}/api/v1/version")
echo "OK — Coolify version: $RESP"
README.md: |
# COOLIFY
Access to the self-hosted PaaS panel that orchestrates deployments.
## Setup
1. `cp .env.example .env && chmod 600 .env`
2. Token from Coolify → Profile → API tokens.
3. `./test_connection.sh`
CREDENTIALS.md: |
# Credentials — COOLIFY
| Variable | Type | Notes |
|----------|------|-------|
| `COOLIFY_URL` | config | Panel base URL (no trailing slash) |
| `COOLIFY_TOKEN` | secret | Generated from Profile → API tokens |
- id: TAILSCALE
category: infra
detectors:
imports: []
env_vars:
- "TAILSCALE_AUTHKEY"
- "TS_AUTHKEY"
deps: []
dashboard_url: "https://login.tailscale.com/admin/settings/keys"
manual_only: true
env_example: |
# TAILSCALE — auth keys (only if we automate provisioning)
# For normal human use the `tailscale` CLI manages the session without .env.
TAILSCALE_AUTHKEY=
files:
README.md: |
# TAILSCALE
Mesh VPN over WireGuard. Access to internal services without exposing ports.
## Manual setup
- Client: install from https://tailscale.com/download
- `tailscale up` from the device; auth happens in the browser.
- Auth keys (for automated server provisioning) from:
https://login.tailscale.com/admin/settings/keys
## No automated smoke-test
State is verified with `tailscale status` from the official CLI.
CREDENTIALS.md: |
# Credentials — TAILSCALE
Dashboard: https://login.tailscale.com/admin
- Auth keys: single-use, expire. Only for provisioning new nodes
without interactive login.
- Human usage relies on the client's OAuth session — no `.env` secrets.
- id: GITHUB_RUNNER
category: infra
detectors:
imports: []
env_vars:
- "RUNNER_TOKEN"
- "GH_RUNNER_TOKEN"
deps: []
dashboard_url: ""
manual_only: true
env_example: |
# GITHUB self-hosted runner — registration
# Registration token: GitHub → Settings → Actions → Runners → New self-hosted runner
# (Org-level: org Settings, not a single repo.)
GH_OWNER=
GH_RUNNER_TOKEN=
RUNNER_NAME=
RUNNER_LABELS=self-hosted,linux,x64
files:
README.md: |
# GITHUB_RUNNER
Self-hosted GitHub Actions runner.
## Setup
1. `cp .env.example .env && chmod 600 .env`
2. Token from Settings → Actions → Runners → New self-hosted runner.
3. Run the runner following GitHub's instructions for your OS.
The token expires in ~1h; only used at registration time.
## Operations
- Runner status: `sudo systemctl status actions.runner.*`
- Logs: `journalctl -u actions.runner.*`
CREDENTIALS.md: |
# Credentials — GITHUB_RUNNER
| Variable | Type | Notes |
|----------|------|-------|
| `GH_OWNER` | config | Org or user the runner is registered against |
| `GH_RUNNER_TOKEN` | secret | Ephemeral (~1h). Regenerate per registration. |
- id: APPLE
category: mobile_auth
detectors:
imports: []
env_vars:
- "APP_STORE_CONNECT_API_KEY"
- "FASTLANE_USER"
- "MATCH_PASSWORD"
deps: []
dashboard_url: "https://appstoreconnect.apple.com"
manual_only: true
env_example: |
# APPLE — App Store Connect + Fastlane Match
# API key JSON: appstoreconnect.apple.com → Users and Access → Keys
ASC_KEY_ID=
ASC_ISSUER_ID=
ASC_KEY_PATH=./AuthKey_XXXXXXXXXX.p8
# Fastlane Match (keep names EXACT: the SDK requires them)
MATCH_PASSWORD=
MATCH_GIT_URL=
files:
README.md: |
# APPLE
App Store Connect: API key, Fastlane Match (certs/profiles), Team ID.
## Manual setup
1. Download the API key (`.p8`) from App Store Connect → Users and Access → Keys.
2. Save it in this folder as `AuthKey_<KEY_ID>.p8` (gitignored).
3. Configure `MATCH_PASSWORD` and `MATCH_GIT_URL` for the certs repo.
## No automated smoke-test
Verify via Fastlane: `fastlane match development --readonly`.
CREDENTIALS.md: |
# Credentials — APPLE
Dashboard: https://appstoreconnect.apple.com
| Artifact | Notes |
|----------|-------|
| `AuthKey_*.p8` | API key downloaded ONCE. Keep it safe. |
| `ASC_KEY_ID` | Visible next to the key in the dashboard |
| `ASC_ISSUER_ID` | Visible in Users and Access → Keys |
| `MATCH_PASSWORD` | Name required by Fastlane (not `APPLE_*`) |
| `MATCH_GIT_URL` | Private repo with encrypted certs |
- id: GOOGLE_PLAY
category: mobile_auth
detectors:
imports: []
env_vars:
- "GOOGLE_PLAY_SERVICE_ACCOUNT"
- "SUPPLY_JSON_KEY"
deps: []
dashboard_url: "https://play.google.com/console"
manual_only: true
env_example: |
# GOOGLE PLAY Console
# Service account JSON: Play Console → Setup → API access → Service accounts
GOOGLE_PLAY_SERVICE_ACCOUNT=./play-service-account.json
PACKAGE_NAME=
files:
README.md: |
# GOOGLE_PLAY
Play Console: service account JSON, upload keystore, package name.
## Manual setup
1. Create a GCP service account and link it in Play Console → Setup → API access.
2. Download the JSON and save it here as `play-service-account.json` (gitignored).
3. `PACKAGE_NAME` must match `applicationId` from the Android build.
## No automated smoke-test
Verify via Fastlane: `fastlane supply --track internal --skip_upload_apk --skip_upload_aab`.
CREDENTIALS.md: |
# Credentials — GOOGLE_PLAY
Dashboard: https://play.google.com/console
| Artifact | Notes |
|----------|-------|
| `play-service-account.json` | DO NOT commit; gitignored |
| `PACKAGE_NAME` | applicationId of the Android project |
# ------------------------------------------------------------------
# IA / LLMs (texto)
# ------------------------------------------------------------------
- id: OPENAI
category: ia_texto
detectors:
imports: ["import openai", "from openai", "require('openai')", "@ai-sdk/openai", "from langchain_openai"]
env_vars: ["OPENAI_API_KEY", "OPENAI_ORG_ID"]
deps: ["openai", "@ai-sdk/openai", "langchain-openai"]
dashboard_url: "https://platform.openai.com/api-keys"
env_example: |
# OPENAI — generate at https://platform.openai.com/api-keys
OPENAI_API_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${OPENAI_API_KEY:?OPENAI_API_KEY not set}"
N=$(curl -fsS https://api.openai.com/v1/models -H "Authorization: Bearer $OPENAI_API_KEY" | python3 -c 'import json,sys; print(len(json.load(sys.stdin)["data"]))')
echo "OK — $N models available."
README.md: |
# OPENAI
OpenAI API (GPT, embeddings, DALL·E, Whisper).
## Setup
1. `cp .env.example .env && chmod 600 .env`
2. Key from https://platform.openai.com/api-keys
3. `./test_connection.sh`
CREDENTIALS.md: |
# Credentials — OPENAI
Dashboard: https://platform.openai.com/api-keys
| Variable | Type |
|----------|------|
| `OPENAI_API_KEY` | secret |
- id: ANTHROPIC
category: ia_texto
detectors:
imports: ["import anthropic", "from anthropic", "@anthropic-ai/sdk", "@ai-sdk/anthropic", "from langchain_anthropic"]
env_vars: ["ANTHROPIC_API_KEY"]
deps: ["anthropic", "@anthropic-ai/sdk", "@ai-sdk/anthropic", "langchain-anthropic"]
dashboard_url: "https://console.anthropic.com/settings/keys"
env_example: |
# ANTHROPIC — generate at https://console.anthropic.com/settings/keys
ANTHROPIC_API_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${ANTHROPIC_API_KEY:?ANTHROPIC_API_KEY not set}"
N=$(curl -fsS https://api.anthropic.com/v1/models -H "x-api-key: $ANTHROPIC_API_KEY" -H "anthropic-version: 2023-06-01" | python3 -c 'import json,sys; print(len(json.load(sys.stdin)["data"]))')
echo "OK — $N Claude models available."
README.md: |
# ANTHROPIC
Claude API (Opus, Sonnet, Haiku).
## Setup
1. `cp .env.example .env && chmod 600 .env`
2. Key from https://console.anthropic.com/settings/keys
3. `./test_connection.sh`
CREDENTIALS.md: |
# Credentials — ANTHROPIC
Dashboard: https://console.anthropic.com/settings/keys
`ANTHROPIC_API_KEY` — secret. Rotate on leak.
- id: GOOGLE_AI
category: ia_texto
detectors:
imports: ["import google.generativeai", "from google import genai", "@google/generative-ai", "@ai-sdk/google"]
env_vars: ["GOOGLE_API_KEY", "GEMINI_API_KEY", "GOOGLE_GENERATIVE_AI_API_KEY"]
deps: ["google-generativeai", "@google/generative-ai", "@ai-sdk/google"]
dashboard_url: "https://aistudio.google.com/apikey"
env_example: |
# GOOGLE AI (Gemini) — generate at https://aistudio.google.com/apikey
GEMINI_API_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
KEY="${GEMINI_API_KEY:-${GOOGLE_API_KEY:-}}"
[ -n "$KEY" ] || { echo "ERROR: GEMINI_API_KEY not set" >&2; exit 1; }
N=$(curl -fsS "https://generativelanguage.googleapis.com/v1beta/models?key=$KEY" | python3 -c 'import json,sys; print(len(json.load(sys.stdin)["models"]))')
echo "OK — $N Gemini models available."
README.md: |
# GOOGLE_AI
Google Gemini API (text + multimodal).
## Setup
1. `cp .env.example .env && chmod 600 .env`
2. Key from https://aistudio.google.com/apikey
3. `./test_connection.sh`
CREDENTIALS.md: |
# Credentials — GOOGLE_AI
Dashboard: https://aistudio.google.com/apikey
`GEMINI_API_KEY` — secret. Shares AI Studio quotas.
- id: COHERE
category: ia_texto
detectors:
imports: ["import cohere", "from cohere"]
env_vars: ["COHERE_API_KEY", "CO_API_KEY"]
deps: ["cohere", "cohere-ai"]
dashboard_url: "https://dashboard.cohere.com/api-keys"
env_example: |
COHERE_API_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${COHERE_API_KEY:?COHERE_API_KEY not set}"
curl -fsS https://api.cohere.com/v1/check-api-key -X POST -H "Authorization: Bearer $COHERE_API_KEY" >/dev/null
echo "OK — Cohere API key valid."
README.md: |
# COHERE
Cohere API (embed, rerank, command).
CREDENTIALS.md: |
Dashboard: https://dashboard.cohere.com/api-keys
`COHERE_API_KEY` — secret.
- id: MISTRAL
category: ia_texto
detectors:
imports: ["import mistralai", "from mistralai", "@mistralai/mistralai", "@ai-sdk/mistral"]
env_vars: ["MISTRAL_API_KEY"]
deps: ["mistralai", "@mistralai/mistralai", "@ai-sdk/mistral"]
dashboard_url: "https://console.mistral.ai/api-keys"
env_example: |
MISTRAL_API_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${MISTRAL_API_KEY:?MISTRAL_API_KEY not set}"
N=$(curl -fsS https://api.mistral.ai/v1/models -H "Authorization: Bearer $MISTRAL_API_KEY" | python3 -c 'import json,sys; print(len(json.load(sys.stdin)["data"]))')
echo "OK — $N Mistral models."
README.md: |
# MISTRAL
Mistral AI API (Mistral, Codestral, Pixtral).
CREDENTIALS.md: |
Dashboard: https://console.mistral.ai/api-keys
`MISTRAL_API_KEY` — secret.
- id: TOGETHER_AI
category: ia_texto
detectors:
imports: ["import together", "from together", "@ai-sdk/togetherai"]
env_vars: ["TOGETHER_API_KEY", "TOGETHERAI_API_KEY"]
deps: ["together", "@ai-sdk/togetherai"]
dashboard_url: "https://api.together.ai/settings/api-keys"
env_example: |
TOGETHER_API_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${TOGETHER_API_KEY:?TOGETHER_API_KEY not set}"
N=$(curl -fsS https://api.together.xyz/v1/models -H "Authorization: Bearer $TOGETHER_API_KEY" | python3 -c 'import json,sys; print(len(json.load(sys.stdin)))')
echo "OK — $N open-source models via Together."
README.md: |
# TOGETHER_AI
Cheap inference for open-source models (Llama, Mixtral, etc.).
CREDENTIALS.md: |
Dashboard: https://api.together.ai/settings/api-keys
`TOGETHER_API_KEY` — secret.
- id: HUGGINGFACE
category: ia_texto
detectors:
imports: ["from huggingface_hub", "import huggingface_hub", "@huggingface/inference"]
env_vars: ["HF_TOKEN", "HUGGINGFACE_API_KEY", "HUGGINGFACEHUB_API_TOKEN"]
deps: ["huggingface_hub", "@huggingface/inference"]
dashboard_url: "https://huggingface.co/settings/tokens"
env_example: |
HF_TOKEN=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
TOKEN="${HF_TOKEN:-${HUGGINGFACE_API_KEY:-${HUGGINGFACEHUB_API_TOKEN:-}}}"
[ -n "$TOKEN" ] || { echo "ERROR: HF_TOKEN not set" >&2; exit 1; }
USER=$(curl -fsS https://huggingface.co/api/whoami-v2 -H "Authorization: Bearer $TOKEN" | python3 -c 'import json,sys; print(json.load(sys.stdin)["name"])')
echo "OK — authed as $USER."
README.md: |
# HUGGINGFACE
Hub + Inference API + Spaces.
CREDENTIALS.md: |
Dashboard: https://huggingface.co/settings/tokens
`HF_TOKEN` — secret. Minimal scopes for the Inference API.
- id: PERPLEXITY
category: ia_texto
detectors:
imports: ["@ai-sdk/perplexity"]
env_vars: ["PERPLEXITY_API_KEY", "PPLX_API_KEY"]
deps: ["@ai-sdk/perplexity"]
dashboard_url: "https://www.perplexity.ai/settings/api"
env_example: |
PERPLEXITY_API_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
# Perplexity has no /models endpoint; validate via a tiny POST.
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${PERPLEXITY_API_KEY:?PERPLEXITY_API_KEY not set}"
RESP=$(curl -fsS https://api.perplexity.ai/chat/completions \
-H "Authorization: Bearer $PERPLEXITY_API_KEY" \
-H "Content-Type: application/json" \
-d '{"model":"sonar","messages":[{"role":"user","content":"ping"}],"max_tokens":1}')
echo "OK — Perplexity API key valid."
README.md: |
# PERPLEXITY
Perplexity Sonar API (search-grounded LLM).
> The smoke-test sends 1 token. Cost is negligible.
CREDENTIALS.md: |
Dashboard: https://www.perplexity.ai/settings/api
`PERPLEXITY_API_KEY` — secret.
# ------------------------------------------------------------------
# IA / multimedia (audio, imagen, vídeo)
# ------------------------------------------------------------------
- id: ELEVENLABS
category: ia_media
detectors:
imports: ["from elevenlabs", "import elevenlabs", "@elevenlabs/elevenlabs-js"]
env_vars: ["ELEVENLABS_API_KEY", "ELEVEN_API_KEY"]
deps: ["elevenlabs", "@elevenlabs/elevenlabs-js"]
dashboard_url: "https://elevenlabs.io/app/settings/api-keys"
env_example: |
ELEVENLABS_API_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
KEY="${ELEVENLABS_API_KEY:-${ELEVEN_API_KEY:-}}"
[ -n "$KEY" ] || { echo "ERROR: ELEVENLABS_API_KEY not set" >&2; exit 1; }
TIER=$(curl -fsS https://api.elevenlabs.io/v1/user -H "xi-api-key: $KEY" | python3 -c 'import json,sys; print(json.load(sys.stdin).get("subscription",{}).get("tier","?"))')
echo "OK — ElevenLabs tier: $TIER."
README.md: |
# ELEVENLABS
Text-to-speech, voice cloning, dubbing.
CREDENTIALS.md: |
Dashboard: https://elevenlabs.io/app/settings/api-keys
`ELEVENLABS_API_KEY` — secret.
- id: FAL_AI
category: ia_media
detectors:
imports: ["import fal_client", "from fal_client", "@fal-ai/client"]
env_vars: ["FAL_KEY", "FAL_API_KEY"]
deps: ["fal-client", "@fal-ai/client"]
dashboard_url: "https://fal.ai/dashboard/keys"
env_example: |
FAL_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
# Lightweight validation: GET on the queue API with auth Key.
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${FAL_KEY:?FAL_KEY not set}"
curl -fsS https://queue.fal.run/health -H "Authorization: Key $FAL_KEY" >/dev/null
echo "OK — fal.ai queue reachable."
README.md: |
# FAL_AI
Fast inference of image/video models (Flux, etc.).
CREDENTIALS.md: |
Dashboard: https://fal.ai/dashboard/keys
`FAL_KEY` — secret.
- id: DEEPGRAM
category: ia_media
detectors:
imports: ["from deepgram", "import deepgram", "@deepgram/sdk"]
env_vars: ["DEEPGRAM_API_KEY"]
deps: ["deepgram-sdk", "@deepgram/sdk"]
dashboard_url: "https://console.deepgram.com/project/_/keys"
env_example: |
DEEPGRAM_API_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${DEEPGRAM_API_KEY:?DEEPGRAM_API_KEY not set}"
N=$(curl -fsS https://api.deepgram.com/v1/projects -H "Authorization: Token $DEEPGRAM_API_KEY" | python3 -c 'import json,sys; print(len(json.load(sys.stdin)["projects"]))')
echo "OK — $N Deepgram projects."
README.md: |
# DEEPGRAM
Speech-to-text + audio intelligence.
CREDENTIALS.md: |
Dashboard: https://console.deepgram.com
`DEEPGRAM_API_KEY` — secret.
- id: ASSEMBLYAI
category: ia_media
detectors:
imports: ["import assemblyai", "from assemblyai", "assemblyai"]
env_vars: ["ASSEMBLYAI_API_KEY"]
deps: ["assemblyai"]
dashboard_url: "https://www.assemblyai.com/app/account"
env_example: |
ASSEMBLYAI_API_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${ASSEMBLYAI_API_KEY:?ASSEMBLYAI_API_KEY not set}"
curl -fsS https://api.assemblyai.com/v2/transcript -H "Authorization: $ASSEMBLYAI_API_KEY" -G --data-urlencode "limit=1" >/dev/null
echo "OK — AssemblyAI API key valid."
README.md: |
# ASSEMBLYAI
Speech-to-text + LeMUR (LLM sobre audio).
CREDENTIALS.md: |
Dashboard: https://www.assemblyai.com/app/account
`ASSEMBLYAI_API_KEY` — secret.
# ------------------------------------------------------------------
# Email (transaccional)
# ------------------------------------------------------------------
- id: SENDGRID
category: email
detectors:
imports: ["from sendgrid", "import sendgrid", "@sendgrid/mail"]
env_vars: ["SENDGRID_API_KEY"]
deps: ["sendgrid", "@sendgrid/mail"]
dashboard_url: "https://app.sendgrid.com/settings/api_keys"
env_example: |
SENDGRID_API_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${SENDGRID_API_KEY:?SENDGRID_API_KEY not set}"
TYPE=$(curl -fsS https://api.sendgrid.com/v3/scopes -H "Authorization: Bearer $SENDGRID_API_KEY" | python3 -c 'import json,sys; print(len(json.load(sys.stdin)["scopes"]))')
echo "OK — SendGrid API key con $TYPE scopes."
README.md: |
# SENDGRID
Email transaccional (Twilio SendGrid).
CREDENTIALS.md: |
Dashboard: https://app.sendgrid.com/settings/api_keys
`SENDGRID_API_KEY` — secret.
- id: POSTMARK
category: email
detectors:
imports: ["from postmarker", "import postmarker", "postmark"]
env_vars: ["POSTMARK_SERVER_TOKEN", "POSTMARK_API_TOKEN"]
deps: ["postmark", "postmarker"]
dashboard_url: "https://account.postmarkapp.com/servers"
env_example: |
POSTMARK_SERVER_TOKEN=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${POSTMARK_SERVER_TOKEN:?POSTMARK_SERVER_TOKEN not set}"
NAME=$(curl -fsS https://api.postmarkapp.com/server -H "Accept: application/json" -H "X-Postmark-Server-Token: $POSTMARK_SERVER_TOKEN" | python3 -c 'import json,sys; print(json.load(sys.stdin)["Name"])')
echo "OK — Postmark server: $NAME."
README.md: |
# POSTMARK
Email transaccional rápido y simple.
CREDENTIALS.md: |
Dashboard: https://account.postmarkapp.com/servers
`POSTMARK_SERVER_TOKEN` — uno por server, scoped.
- id: RESEND
category: email
detectors:
imports: ["from resend", "import resend", "resend"]
env_vars: ["RESEND_API_KEY"]
deps: ["resend"]
dashboard_url: "https://resend.com/api-keys"
env_example: |
RESEND_API_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${RESEND_API_KEY:?RESEND_API_KEY not set}"
N=$(curl -fsS https://api.resend.com/domains -H "Authorization: Bearer $RESEND_API_KEY" | python3 -c 'import json,sys; print(len(json.load(sys.stdin)["data"]))')
echo "OK — Resend dominios: $N."
README.md: |
# RESEND
Email transaccional para developers (React Email-friendly).
CREDENTIALS.md: |
Dashboard: https://resend.com/api-keys
`RESEND_API_KEY` — secret.
- id: MAILGUN
category: email
detectors:
imports: ["import mailgun", "from mailgun", "mailgun.js"]
env_vars: ["MAILGUN_API_KEY", "MAILGUN_DOMAIN"]
deps: ["mailgun", "mailgun.js"]
dashboard_url: "https://app.mailgun.com/settings/api_security"
env_example: |
MAILGUN_API_KEY=
MAILGUN_DOMAIN=
MAILGUN_REGION=api
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${MAILGUN_API_KEY:?MAILGUN_API_KEY not set}"
REGION="${MAILGUN_REGION:-api}"
N=$(curl -fsS "https://${REGION}.mailgun.net/v4/domains" -u "api:$MAILGUN_API_KEY" | python3 -c 'import json,sys; print(json.load(sys.stdin)["total_count"])')
echo "OK — Mailgun dominios: $N."
README.md: |
# MAILGUN
Email transaccional + email parsing.
CREDENTIALS.md: |
Dashboard: https://app.mailgun.com/settings/api_security
Region: `api` (US) o `api.eu`.
- id: AWS_SES
category: email
detectors:
imports: ["from boto3", "import boto3", "@aws-sdk/client-ses"]
env_vars: ["AWS_SES_ACCESS_KEY_ID", "SES_REGION"]
deps: ["@aws-sdk/client-ses"]
dashboard_url: "https://console.aws.amazon.com/ses"
manual_only: true
env_example: |
# AWS SES — usa el CLI oficial de AWS para verificar.
AWS_ACCESS_KEY_ID=
AWS_SECRET_ACCESS_KEY=
AWS_REGION=eu-west-1
files:
README.md: |
# AWS_SES
Amazon SES para email transaccional. La auth SigV4 es compleja —
verifica con el AWS CLI:
aws ses get-account-sending-enabled --region $AWS_REGION
## No hay smoke-test bash automatizado
SigV4 requiere firma HMAC compleja; usa boto3 o el AWS CLI.
CREDENTIALS.md: |
Dashboard: https://console.aws.amazon.com/ses
Credentials: IAM access key with the `ses:SendEmail` policy.
# ------------------------------------------------------------------
# Payments & billing
# ------------------------------------------------------------------
- id: PADDLE
category: pagos
detectors:
imports: ["@paddle/paddle-node-sdk", "@paddle/paddle-js"]
env_vars: ["PADDLE_API_KEY", "PADDLE_VENDOR_ID", "PADDLE_NOTIFICATION_SECRET"]
deps: ["@paddle/paddle-node-sdk", "@paddle/paddle-js"]
dashboard_url: "https://vendors.paddle.com/authentication"
env_example: |
# PADDLE — generate at https://vendors.paddle.com/authentication
PADDLE_API_KEY=
PADDLE_ENV=sandbox
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${PADDLE_API_KEY:?PADDLE_API_KEY not set}"
HOST="https://api.paddle.com"
[ "${PADDLE_ENV:-}" = "sandbox" ] && HOST="https://sandbox-api.paddle.com"
N=$(curl -fsS "$HOST/products" -H "Authorization: Bearer $PADDLE_API_KEY" | python3 -c 'import json,sys; print(len(json.load(sys.stdin)["data"]))')
echo "OK — Paddle ($PADDLE_ENV) products: $N."
README.md: |
# PADDLE
Merchant-of-record billing (subscriptions, taxes handled).
CREDENTIALS.md: |
Dashboard: https://vendors.paddle.com/authentication
`PADDLE_API_KEY` — secret. Set `PADDLE_ENV=sandbox` for the sandbox.
- id: LEMONSQUEEZY
category: pagos
detectors:
imports: ["@lemonsqueezy/lemonsqueezy.js"]
env_vars: ["LEMONSQUEEZY_API_KEY", "LEMONSQUEEZY_STORE_ID", "LEMONSQUEEZY_WEBHOOK_SECRET"]
deps: ["@lemonsqueezy/lemonsqueezy.js"]
dashboard_url: "https://app.lemonsqueezy.com/settings/api"
env_example: |
LEMONSQUEEZY_API_KEY=
LEMONSQUEEZY_STORE_ID=
LEMONSQUEEZY_WEBHOOK_SECRET=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${LEMONSQUEEZY_API_KEY:?LEMONSQUEEZY_API_KEY not set}"
NAME=$(curl -fsS https://api.lemonsqueezy.com/v1/users/me \
-H "Accept: application/vnd.api+json" \
-H "Authorization: Bearer $LEMONSQUEEZY_API_KEY" \
| python3 -c 'import json,sys; print(json.load(sys.stdin)["data"]["attributes"]["name"])')
echo "OK — Lemon Squeezy authed as $NAME."
README.md: |
# LEMONSQUEEZY
Merchant-of-record SaaS billing (alternative to Paddle).
CREDENTIALS.md: |
Dashboard: https://app.lemonsqueezy.com/settings/api
`LEMONSQUEEZY_API_KEY` — secret. `LEMONSQUEEZY_STORE_ID` from the URL of the store page.
- id: REVENUECAT
category: pagos
detectors:
imports: ["import Purchases", "from purchases", "@revenuecat/purchases-js", "react-native-purchases", "purchases_flutter"]
env_vars: ["REVENUECAT_API_KEY", "REVENUECAT_SECRET_API_KEY"]
deps: ["@revenuecat/purchases-js", "react-native-purchases", "purchases-flutter"]
dashboard_url: "https://app.revenuecat.com/projects"
env_example: |
# Secret API key for server-side ops (mobile clients use public SDK keys).
REVENUECAT_SECRET_API_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${REVENUECAT_SECRET_API_KEY:?REVENUECAT_SECRET_API_KEY not set}"
# v2 API: list projects under the current account.
N=$(curl -fsS https://api.revenuecat.com/v2/projects -H "Authorization: Bearer $REVENUECAT_SECRET_API_KEY" | python3 -c 'import json,sys; print(len(json.load(sys.stdin).get("items",[])))')
echo "OK — RevenueCat projects: $N."
README.md: |
# REVENUECAT
Cross-platform subscription management (iOS + Android + web).
CREDENTIALS.md: |
Dashboard: https://app.revenuecat.com/projects
`REVENUECAT_SECRET_API_KEY` — secret, for server-side calls only.
Public SDK keys (iOS/Android/web) go directly in the client.
# ------------------------------------------------------------------
# Auth & identity
# ------------------------------------------------------------------
- id: CLERK
category: auth
detectors:
imports: ["@clerk/clerk-sdk-node", "@clerk/nextjs", "@clerk/clerk-react", "@clerk/backend", "from clerk_backend_api"]
env_vars: ["CLERK_SECRET_KEY", "CLERK_PUBLISHABLE_KEY", "NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY"]
deps: ["@clerk/nextjs", "@clerk/clerk-sdk-node", "@clerk/backend", "clerk-backend-api"]
dashboard_url: "https://dashboard.clerk.com"
env_example: |
CLERK_SECRET_KEY=
CLERK_PUBLISHABLE_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${CLERK_SECRET_KEY:?CLERK_SECRET_KEY not set}"
N=$(curl -fsS https://api.clerk.com/v1/users?limit=1 -H "Authorization: Bearer $CLERK_SECRET_KEY" | python3 -c 'import json,sys; d=json.load(sys.stdin); print(len(d) if isinstance(d,list) else "?")')
echo "OK — Clerk users endpoint accessible (sample: $N)."
README.md: |
# CLERK
Drop-in auth + user management for Next.js, React, Expo.
CREDENTIALS.md: |
Dashboard: https://dashboard.clerk.com
`CLERK_SECRET_KEY` — backend secret. `CLERK_PUBLISHABLE_KEY` — public.
- id: WORKOS
category: auth
detectors:
imports: ["@workos-inc/node", "@workos-inc/authkit-nextjs", "import workos"]
env_vars: ["WORKOS_API_KEY", "WORKOS_CLIENT_ID"]
deps: ["@workos-inc/node", "@workos-inc/authkit-nextjs", "workos"]
dashboard_url: "https://dashboard.workos.com/api-keys"
env_example: |
WORKOS_API_KEY=
WORKOS_CLIENT_ID=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${WORKOS_API_KEY:?WORKOS_API_KEY not set}"
N=$(curl -fsS "https://api.workos.com/organizations?limit=1" -H "Authorization: Bearer $WORKOS_API_KEY" | python3 -c 'import json,sys; print(len(json.load(sys.stdin)["data"]))')
echo "OK — WorkOS organizations sample: $N."
README.md: |
# WORKOS
Enterprise SSO (SAML, OIDC), SCIM, Directory Sync, AuthKit.
CREDENTIALS.md: |
Dashboard: https://dashboard.workos.com/api-keys
`WORKOS_API_KEY` — secret. `WORKOS_CLIENT_ID` — public.
- id: AUTH0
category: auth
detectors:
imports: ["@auth0/nextjs-auth0", "@auth0/auth0-react", "@auth0/auth0-spa-js", "from auth0"]
env_vars: ["AUTH0_DOMAIN", "AUTH0_CLIENT_ID", "AUTH0_CLIENT_SECRET", "AUTH0_MGMT_API_TOKEN"]
deps: ["@auth0/nextjs-auth0", "@auth0/auth0-react", "auth0"]
dashboard_url: "https://manage.auth0.com"
env_example: |
AUTH0_DOMAIN=
AUTH0_CLIENT_ID=
AUTH0_CLIENT_SECRET=
files:
test_connection.sh: |
#!/usr/bin/env bash
# Auth0: validate that the tenant domain serves OIDC discovery.
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${AUTH0_DOMAIN:?AUTH0_DOMAIN not set}"
ISSUER=$(curl -fsS "https://${AUTH0_DOMAIN}/.well-known/openid-configuration" | python3 -c 'import json,sys; print(json.load(sys.stdin)["issuer"])')
echo "OK — Auth0 tenant reachable: $ISSUER."
README.md: |
# AUTH0
Identity platform (login, MFA, social, enterprise SSO).
> Management API checks need a separate M2M token — see CREDENTIALS.md.
CREDENTIALS.md: |
Dashboard: https://manage.auth0.com
- `AUTH0_DOMAIN` — `<tenant>.auth0.com` or custom domain.
- `AUTH0_CLIENT_ID` / `AUTH0_CLIENT_SECRET` — per Application.
- `AUTH0_MGMT_API_TOKEN` — only needed for Management API calls.
- id: STYTCH
category: auth
detectors:
imports: ["import stytch", "from stytch", "@stytch/nextjs", "stytch"]
env_vars: ["STYTCH_PROJECT_ID", "STYTCH_SECRET"]
deps: ["stytch", "@stytch/nextjs"]
dashboard_url: "https://stytch.com/dashboard/api-keys"
env_example: |
STYTCH_PROJECT_ID=
STYTCH_SECRET=
STYTCH_ENV=test
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${STYTCH_PROJECT_ID:?STYTCH_PROJECT_ID not set}"
: "${STYTCH_SECRET:?STYTCH_SECRET not set}"
HOST="https://test.stytch.com"
[ "${STYTCH_ENV:-test}" = "live" ] && HOST="https://api.stytch.com"
# Lists trusted metadata — read-only, safe smoke test.
curl -fsS "$HOST/v1/projects" -u "$STYTCH_PROJECT_ID:$STYTCH_SECRET" >/dev/null
echo "OK — Stytch ($STYTCH_ENV) auth valid."
README.md: |
# STYTCH
Passwordless + passkeys + B2B SaaS auth APIs.
CREDENTIALS.md: |
Dashboard: https://stytch.com/dashboard/api-keys
`STYTCH_PROJECT_ID` + `STYTCH_SECRET`. Set `STYTCH_ENV=live` for prod.
- id: KINDE
category: auth
detectors:
imports: ["@kinde-oss/kinde-auth-nextjs", "@kinde-oss/kinde-typescript-sdk", "@kinde-oss/kinde-auth-react"]
env_vars: ["KINDE_CLIENT_ID", "KINDE_CLIENT_SECRET", "KINDE_ISSUER_URL", "KINDE_M2M_CLIENT_ID", "KINDE_M2M_CLIENT_SECRET"]
deps: ["@kinde-oss/kinde-auth-nextjs", "@kinde-oss/kinde-typescript-sdk"]
dashboard_url: "https://app.kinde.com"
env_example: |
KINDE_ISSUER_URL=
KINDE_CLIENT_ID=
KINDE_CLIENT_SECRET=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${KINDE_ISSUER_URL:?KINDE_ISSUER_URL not set}"
ISSUER=$(curl -fsS "${KINDE_ISSUER_URL%/}/.well-known/openid-configuration" | python3 -c 'import json,sys; print(json.load(sys.stdin)["issuer"])')
echo "OK — Kinde tenant reachable: $ISSUER."
README.md: |
# KINDE
Auth + user management with feature flags built in.
CREDENTIALS.md: |
Dashboard: https://app.kinde.com
`KINDE_ISSUER_URL` is `https://<subdomain>.kinde.com`.
Management API needs M2M client (see KINDE_M2M_*).
# ------------------------------------------------------------------
# Databases & backend-as-a-service
# ------------------------------------------------------------------
- id: SUPABASE
category: datos
detectors:
imports: ["@supabase/supabase-js", "@supabase/ssr", "from supabase", "import supabase"]
env_vars: ["SUPABASE_URL", "SUPABASE_ANON_KEY", "SUPABASE_SERVICE_ROLE_KEY", "NEXT_PUBLIC_SUPABASE_URL"]
deps: ["@supabase/supabase-js", "@supabase/ssr", "supabase"]
dashboard_url: "https://supabase.com/dashboard"
env_example: |
SUPABASE_URL=
SUPABASE_ANON_KEY=
SUPABASE_SERVICE_ROLE_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${SUPABASE_URL:?SUPABASE_URL not set}"
: "${SUPABASE_ANON_KEY:?SUPABASE_ANON_KEY not set}"
curl -fsS "${SUPABASE_URL%/}/auth/v1/health" -H "apikey: $SUPABASE_ANON_KEY" >/dev/null
echo "OK — Supabase auth service reachable."
README.md: |
# SUPABASE
Postgres + Auth + Storage + Realtime + Edge Functions.
CREDENTIALS.md: |
Dashboard: https://supabase.com/dashboard
`SUPABASE_ANON_KEY` — public.
`SUPABASE_SERVICE_ROLE_KEY` — secret, bypasses RLS. Server-only.
- id: NEON
category: datos
detectors:
imports: ["@neondatabase/serverless", "from neon"]
env_vars: ["NEON_API_KEY", "NEON_PROJECT_ID", "DATABASE_URL"]
deps: ["@neondatabase/serverless"]
dashboard_url: "https://console.neon.tech/app/settings/api-keys"
env_example: |
NEON_API_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${NEON_API_KEY:?NEON_API_KEY not set}"
N=$(curl -fsS https://console.neon.tech/api/v2/projects -H "Authorization: Bearer $NEON_API_KEY" | python3 -c 'import json,sys; print(len(json.load(sys.stdin)["projects"]))')
echo "OK — Neon projects: $N."
README.md: |
# NEON
Serverless Postgres with branching.
CREDENTIALS.md: |
Dashboard: https://console.neon.tech/app/settings/api-keys
`NEON_API_KEY` — secret.
- id: PLANETSCALE
category: datos
detectors:
imports: ["@planetscale/database", "from planetscale"]
env_vars: ["PLANETSCALE_TOKEN", "PLANETSCALE_SERVICE_TOKEN", "PLANETSCALE_SERVICE_TOKEN_NAME", "DATABASE_URL"]
deps: ["@planetscale/database"]
dashboard_url: "https://app.planetscale.com/settings/service-tokens"
env_example: |
PLANETSCALE_SERVICE_TOKEN_NAME=
PLANETSCALE_SERVICE_TOKEN=
PLANETSCALE_ORG=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${PLANETSCALE_SERVICE_TOKEN_NAME:?not set}"
: "${PLANETSCALE_SERVICE_TOKEN:?not set}"
: "${PLANETSCALE_ORG:?not set}"
N=$(curl -fsS "https://api.planetscale.com/v1/organizations/$PLANETSCALE_ORG/databases" \
-H "Authorization: ${PLANETSCALE_SERVICE_TOKEN_NAME}:${PLANETSCALE_SERVICE_TOKEN}" \
| python3 -c 'import json,sys; print(len(json.load(sys.stdin)["data"]))')
echo "OK — PlanetScale databases: $N."
README.md: |
# PLANETSCALE
Serverless MySQL with branching.
CREDENTIALS.md: |
Dashboard: https://app.planetscale.com/settings/service-tokens
Service tokens use `NAME:TOKEN` in the Authorization header.
- id: TURSO
category: datos
detectors:
imports: ["@libsql/client", "libsql_client", "import libsql"]
env_vars: ["TURSO_AUTH_TOKEN", "TURSO_DATABASE_URL", "TURSO_API_TOKEN", "TURSO_ORG"]
deps: ["@libsql/client", "libsql"]
dashboard_url: "https://turso.tech/app"
env_example: |
TURSO_API_TOKEN=
TURSO_ORG=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${TURSO_API_TOKEN:?TURSO_API_TOKEN not set}"
: "${TURSO_ORG:?TURSO_ORG not set}"
N=$(curl -fsS "https://api.turso.tech/v1/organizations/$TURSO_ORG/databases" -H "Authorization: Bearer $TURSO_API_TOKEN" | python3 -c 'import json,sys; print(len(json.load(sys.stdin)["databases"]))')
echo "OK — Turso databases: $N."
README.md: |
# TURSO
SQLite at the edge (libSQL).
CREDENTIALS.md: |
Dashboard: https://turso.tech/app
`TURSO_API_TOKEN` — for platform API.
`TURSO_AUTH_TOKEN` — per-database, for client connections.
- id: MONGODB_ATLAS
category: datos
detectors:
imports: ["pymongo", "from motor", "mongoose", "mongodb"]
env_vars: ["MONGODB_URI", "MONGO_URL", "ATLAS_PUBLIC_KEY", "ATLAS_PRIVATE_KEY"]
deps: ["pymongo", "motor", "mongoose", "mongodb"]
dashboard_url: "https://cloud.mongodb.com"
manual_only: true
env_example: |
# MongoDB Atlas — connection string for runtime + Atlas API key for ops.
MONGODB_URI=
ATLAS_PUBLIC_KEY=
ATLAS_PRIVATE_KEY=
files:
README.md: |
# MONGODB_ATLAS
Managed MongoDB. The Atlas Admin API uses HTTP digest auth which is
non-trivial in plain bash. Verify with:
mongosh "$MONGODB_URI" --eval "db.runCommand({ ping: 1 })"
or use the Atlas CLI: `atlas projects list`.
CREDENTIALS.md: |
Dashboard: https://cloud.mongodb.com
- `MONGODB_URI` — full SRV connection string for runtime.
- `ATLAS_PUBLIC_KEY` / `ATLAS_PRIVATE_KEY` — for Admin API (HTTP digest).
- id: UPSTASH_REDIS
category: datos
detectors:
imports: ["@upstash/redis", "@upstash/ratelimit"]
env_vars: ["UPSTASH_REDIS_REST_URL", "UPSTASH_REDIS_REST_TOKEN", "KV_REST_API_URL", "KV_REST_API_TOKEN"]
deps: ["@upstash/redis", "@upstash/ratelimit"]
dashboard_url: "https://console.upstash.com"
env_example: |
UPSTASH_REDIS_REST_URL=
UPSTASH_REDIS_REST_TOKEN=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
URL="${UPSTASH_REDIS_REST_URL:-${KV_REST_API_URL:-}}"
TOKEN="${UPSTASH_REDIS_REST_TOKEN:-${KV_REST_API_TOKEN:-}}"
[ -n "$URL" ] && [ -n "$TOKEN" ] || { echo "ERROR: missing URL/token" >&2; exit 1; }
# PING via REST API.
curl -fsS "${URL%/}/ping" -H "Authorization: Bearer $TOKEN" | grep -q PONG
echo "OK — Upstash Redis REST responds PONG."
README.md: |
# UPSTASH_REDIS
Serverless Redis (REST API friendly for edge runtimes).
CREDENTIALS.md: |
Dashboard: https://console.upstash.com
Both URL + token are needed; the URL embeds the DB region.
- id: CONVEX
category: datos
detectors:
imports: ["convex/server", "convex/react", "from convex"]
env_vars: ["CONVEX_URL", "CONVEX_DEPLOY_KEY", "CONVEX_DEPLOYMENT", "NEXT_PUBLIC_CONVEX_URL"]
deps: ["convex"]
dashboard_url: "https://dashboard.convex.dev"
manual_only: true
env_example: |
CONVEX_URL=
CONVEX_DEPLOY_KEY=
files:
README.md: |
# CONVEX
Reactive backend (TS functions + realtime DB). The deploy-key is
validated implicitly by `npx convex deploy`; there is no public
read-only smoke endpoint. Verify with:
npx convex run system:listFunctions
## No automated smoke-test in bash
CREDENTIALS.md: |
Dashboard: https://dashboard.convex.dev
`CONVEX_URL` — public deployment URL.
`CONVEX_DEPLOY_KEY` — secret, only needed for CI/CD deploys.
# ------------------------------------------------------------------
# Search & vector databases
# ------------------------------------------------------------------
- id: PINECONE
category: busqueda
detectors:
imports: ["import pinecone", "from pinecone", "@pinecone-database/pinecone"]
env_vars: ["PINECONE_API_KEY", "PINECONE_ENVIRONMENT"]
deps: ["pinecone", "pinecone-client", "@pinecone-database/pinecone"]
dashboard_url: "https://app.pinecone.io"
env_example: |
PINECONE_API_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${PINECONE_API_KEY:?PINECONE_API_KEY not set}"
N=$(curl -fsS https://api.pinecone.io/indexes -H "Api-Key: $PINECONE_API_KEY" -H "X-Pinecone-API-Version: 2025-10" | python3 -c 'import json,sys; print(len(json.load(sys.stdin).get("indexes",[])))')
echo "OK — Pinecone indexes: $N."
README.md: |
# PINECONE
Managed vector database for RAG and similarity search.
CREDENTIALS.md: |
Dashboard: https://app.pinecone.io
`PINECONE_API_KEY` — secret, scoped per project.
- id: WEAVIATE
category: busqueda
detectors:
imports: ["import weaviate", "from weaviate", "weaviate-ts-client", "weaviate-client"]
env_vars: ["WEAVIATE_URL", "WEAVIATE_API_KEY"]
deps: ["weaviate-client", "weaviate-ts-client"]
dashboard_url: "https://console.weaviate.cloud"
env_example: |
WEAVIATE_URL=
WEAVIATE_API_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${WEAVIATE_URL:?WEAVIATE_URL not set}"
AUTH=()
[ -n "${WEAVIATE_API_KEY:-}" ] && AUTH=(-H "Authorization: Bearer ${WEAVIATE_API_KEY}")
VER=$(curl -fsS "${WEAVIATE_URL%/}/v1/meta" "${AUTH[@]+"${AUTH[@]}"}" | python3 -c 'import json,sys; print(json.load(sys.stdin)["version"])')
echo "OK — Weaviate version: $VER."
README.md: |
# WEAVIATE
Open-source vector DB with modules (text2vec, generative, etc.).
CREDENTIALS.md: |
Dashboard: https://console.weaviate.cloud (managed) or self-hosted.
`WEAVIATE_URL` — full base URL including scheme.
- id: QDRANT
category: busqueda
detectors:
imports: ["from qdrant_client", "import qdrant_client", "@qdrant/js-client-rest"]
env_vars: ["QDRANT_URL", "QDRANT_API_KEY"]
deps: ["qdrant-client", "@qdrant/js-client-rest"]
dashboard_url: "https://cloud.qdrant.io"
env_example: |
QDRANT_URL=
QDRANT_API_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${QDRANT_URL:?QDRANT_URL not set}"
AUTH=()
[ -n "${QDRANT_API_KEY:-}" ] && AUTH=(-H "api-key: ${QDRANT_API_KEY}")
N=$(curl -fsS "${QDRANT_URL%/}/collections" "${AUTH[@]+"${AUTH[@]}"}" | python3 -c 'import json,sys; print(len(json.load(sys.stdin)["result"]["collections"]))')
echo "OK — Qdrant collections: $N."
README.md: |
# QDRANT
Vector DB written in Rust. Managed (Qdrant Cloud) or self-hosted.
CREDENTIALS.md: |
Dashboard: https://cloud.qdrant.io
`QDRANT_URL` includes the port (6333 by default for self-hosted).
- id: ALGOLIA
category: busqueda
detectors:
imports: ["algoliasearch", "from algoliasearch", "import algoliasearch", "react-instantsearch"]
env_vars: ["ALGOLIA_APP_ID", "ALGOLIA_ADMIN_API_KEY", "ALGOLIA_SEARCH_API_KEY", "NEXT_PUBLIC_ALGOLIA_APP_ID"]
deps: ["algoliasearch", "react-instantsearch", "algoliasearch-helper"]
dashboard_url: "https://dashboard.algolia.com/account/api-keys"
env_example: |
ALGOLIA_APP_ID=
ALGOLIA_ADMIN_API_KEY=
ALGOLIA_SEARCH_API_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${ALGOLIA_APP_ID:?ALGOLIA_APP_ID not set}"
: "${ALGOLIA_ADMIN_API_KEY:?ALGOLIA_ADMIN_API_KEY not set}"
N=$(curl -fsS "https://${ALGOLIA_APP_ID}.algolia.net/1/indexes" \
-H "X-Algolia-Application-Id: $ALGOLIA_APP_ID" \
-H "X-Algolia-API-Key: $ALGOLIA_ADMIN_API_KEY" \
| python3 -c 'import json,sys; print(json.load(sys.stdin)["nbHits"])')
echo "OK — Algolia indices: $N."
README.md: |
# ALGOLIA
Hosted search-as-a-service. Admin key for ops, search key for clients.
CREDENTIALS.md: |
Dashboard: https://dashboard.algolia.com/account/api-keys
`ALGOLIA_ADMIN_API_KEY` — secret, server-only.
`ALGOLIA_SEARCH_API_KEY` — public, safe for clients.
- id: TYPESENSE
category: busqueda
detectors:
imports: ["import typesense", "from typesense", "typesense"]
env_vars: ["TYPESENSE_API_KEY", "TYPESENSE_HOST", "TYPESENSE_PORT"]
deps: ["typesense"]
dashboard_url: "https://cloud.typesense.org/clusters"
env_example: |
TYPESENSE_HOST=
TYPESENSE_PORT=443
TYPESENSE_PROTOCOL=https
TYPESENSE_API_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${TYPESENSE_HOST:?TYPESENSE_HOST not set}"
: "${TYPESENSE_API_KEY:?TYPESENSE_API_KEY not set}"
PROTO="${TYPESENSE_PROTOCOL:-https}"
PORT="${TYPESENSE_PORT:-443}"
curl -fsS "${PROTO}://${TYPESENSE_HOST}:${PORT}/health" -H "X-TYPESENSE-API-KEY: $TYPESENSE_API_KEY" | grep -q '"ok":true'
echo "OK — Typesense health: ok."
README.md: |
# TYPESENSE
Open-source typo-tolerant search engine. Managed cloud available.
CREDENTIALS.md: |
Dashboard: https://cloud.typesense.org/clusters
`TYPESENSE_API_KEY` — generate per cluster.
- id: MEILISEARCH
category: busqueda
detectors:
imports: ["meilisearch", "import meilisearch", "from meilisearch"]
env_vars: ["MEILI_MASTER_KEY", "MEILI_URL", "MEILISEARCH_HOST"]
deps: ["meilisearch"]
dashboard_url: "https://cloud.meilisearch.com"
env_example: |
MEILI_URL=
MEILI_MASTER_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
URL="${MEILI_URL:-${MEILISEARCH_HOST:-}}"
[ -n "$URL" ] || { echo "ERROR: MEILI_URL not set" >&2; exit 1; }
: "${MEILI_MASTER_KEY:?MEILI_MASTER_KEY not set}"
curl -fsS "${URL%/}/health" -H "Authorization: Bearer $MEILI_MASTER_KEY" | grep -q available
echo "OK — Meilisearch available."
README.md: |
# MEILISEARCH
Open-source instant search. Managed cloud or self-hosted.
CREDENTIALS.md: |
Dashboard: https://cloud.meilisearch.com
`MEILI_MASTER_KEY` — secret. Use scoped API keys for clients.
# ------------------------------------------------------------------
# Observability (logs, errors, tracing, product analytics)
# ------------------------------------------------------------------
- id: SENTRY
category: observabilidad
detectors:
imports: ["@sentry/nextjs", "@sentry/node", "@sentry/react", "import sentry_sdk", "from sentry_sdk"]
env_vars: ["SENTRY_DSN", "SENTRY_AUTH_TOKEN", "SENTRY_ORG", "SENTRY_PROJECT", "NEXT_PUBLIC_SENTRY_DSN"]
deps: ["@sentry/nextjs", "@sentry/node", "@sentry/react", "sentry-sdk", "sentry-cli"]
dashboard_url: "https://sentry.io/settings/auth-tokens/"
env_example: |
SENTRY_DSN=
SENTRY_AUTH_TOKEN=
SENTRY_ORG=
SENTRY_PROJECT=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${SENTRY_AUTH_TOKEN:?SENTRY_AUTH_TOKEN not set}"
: "${SENTRY_ORG:?SENTRY_ORG not set}"
N=$(curl -fsS "https://sentry.io/api/0/organizations/$SENTRY_ORG/projects/" -H "Authorization: Bearer $SENTRY_AUTH_TOKEN" | python3 -c 'import json,sys; print(len(json.load(sys.stdin)))')
echo "OK — Sentry projects: $N."
README.md: |
# SENTRY
Error tracking + performance + session replay.
CREDENTIALS.md: |
Dashboard: https://sentry.io/settings/auth-tokens/
`SENTRY_DSN` — public, for SDK init.
`SENTRY_AUTH_TOKEN` — secret, for sourcemaps upload + API.
- id: DATADOG
category: observabilidad
detectors:
imports: ["from datadog", "import datadog", "datadog-api-client", "dd-trace"]
env_vars: ["DD_API_KEY", "DD_APP_KEY", "DATADOG_API_KEY", "DD_SITE"]
deps: ["datadog", "datadog-api-client", "dd-trace"]
dashboard_url: "https://app.datadoghq.com/organization-settings/api-keys"
env_example: |
DD_API_KEY=
DD_APP_KEY=
DD_SITE=datadoghq.eu
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${DD_API_KEY:?DD_API_KEY not set}"
SITE="${DD_SITE:-datadoghq.com}"
curl -fsS "https://api.${SITE}/api/v1/validate" -H "DD-API-KEY: $DD_API_KEY" | grep -q '"valid":true'
echo "OK — Datadog API key valid ($SITE)."
README.md: |
# DATADOG
Logs + APM + metrics + RUM. Pick `DD_SITE` for your region.
CREDENTIALS.md: |
Dashboard: https://app.datadoghq.com/organization-settings/api-keys
`DD_API_KEY` — for ingest. `DD_APP_KEY` — for API queries.
- id: NEW_RELIC
category: observabilidad
detectors:
imports: ["import newrelic", "newrelic"]
env_vars: ["NEW_RELIC_LICENSE_KEY", "NEW_RELIC_API_KEY", "NEW_RELIC_ACCOUNT_ID"]
deps: ["newrelic"]
dashboard_url: "https://one.newrelic.com/admin-portal/api-keys/home"
env_example: |
NEW_RELIC_API_KEY=
NEW_RELIC_ACCOUNT_ID=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${NEW_RELIC_API_KEY:?NEW_RELIC_API_KEY not set}"
: "${NEW_RELIC_ACCOUNT_ID:?NEW_RELIC_ACCOUNT_ID not set}"
# NerdGraph query for account name (smallest valid request).
curl -fsS https://api.newrelic.com/graphql \
-H "API-Key: $NEW_RELIC_API_KEY" \
-H "Content-Type: application/json" \
-d "{\"query\":\"{ actor { account(id: $NEW_RELIC_ACCOUNT_ID) { name } } }\"}" >/dev/null
echo "OK — New Relic API key valid."
README.md: |
# NEW_RELIC
APM + logs + metrics + browser/mobile.
CREDENTIALS.md: |
Dashboard: https://one.newrelic.com/admin-portal/api-keys/home
`NEW_RELIC_LICENSE_KEY` — for agents (ingest).
`NEW_RELIC_API_KEY` — for NerdGraph queries.
- id: BETTER_STACK
category: observabilidad
detectors:
imports: ["@logtail/node", "@logtail/next", "import logtail", "from logtail"]
env_vars: ["LOGTAIL_SOURCE_TOKEN", "BETTERSTACK_API_TOKEN"]
deps: ["@logtail/node", "@logtail/next", "logtail"]
dashboard_url: "https://logs.betterstack.com"
env_example: |
LOGTAIL_SOURCE_TOKEN=
BETTERSTACK_API_TOKEN=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${BETTERSTACK_API_TOKEN:?BETTERSTACK_API_TOKEN not set}"
N=$(curl -fsS https://logs.betterstack.com/api/v1/sources -H "Authorization: Bearer $BETTERSTACK_API_TOKEN" | python3 -c 'import json,sys; print(len(json.load(sys.stdin)["data"]))')
echo "OK — Better Stack sources: $N."
README.md: |
# BETTER_STACK
Logs (Logtail) + uptime + incident management (formerly Better Uptime).
CREDENTIALS.md: |
Dashboard: https://logs.betterstack.com
`LOGTAIL_SOURCE_TOKEN` — for log ingest.
`BETTERSTACK_API_TOKEN` — for API/management.
- id: AXIOM
category: observabilidad
detectors:
imports: ["@axiomhq/js", "@axiomhq/nextjs", "import axiom"]
env_vars: ["AXIOM_TOKEN", "AXIOM_DATASET", "AXIOM_ORG_ID"]
deps: ["@axiomhq/js", "@axiomhq/nextjs"]
dashboard_url: "https://app.axiom.co/settings/api-tokens"
env_example: |
AXIOM_TOKEN=
AXIOM_DATASET=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${AXIOM_TOKEN:?AXIOM_TOKEN not set}"
N=$(curl -fsS https://api.axiom.co/v1/datasets -H "Authorization: Bearer $AXIOM_TOKEN" | python3 -c 'import json,sys; print(len(json.load(sys.stdin)))')
echo "OK — Axiom datasets: $N."
README.md: |
# AXIOM
Time-series + logs platform with SQL/APL queries.
CREDENTIALS.md: |
Dashboard: https://app.axiom.co/settings/api-tokens
`AXIOM_TOKEN` — API token (per-dataset or org-wide).
- id: HONEYCOMB
category: observabilidad
detectors:
imports: ["@honeycombio/opentelemetry-node", "from honeycomb_beeline"]
env_vars: ["HONEYCOMB_API_KEY", "HONEYCOMB_DATASET"]
deps: ["@honeycombio/opentelemetry-node", "honeycomb-beeline"]
dashboard_url: "https://ui.honeycomb.io/account/api_keys"
env_example: |
HONEYCOMB_API_KEY=
HONEYCOMB_DATASET=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${HONEYCOMB_API_KEY:?HONEYCOMB_API_KEY not set}"
TEAM=$(curl -fsS https://api.honeycomb.io/1/auth -H "X-Honeycomb-Team: $HONEYCOMB_API_KEY" | python3 -c 'import json,sys; print(json.load(sys.stdin)["team"]["slug"])')
echo "OK — Honeycomb team: $TEAM."
README.md: |
# HONEYCOMB
Observability for tracing-heavy distributed systems.
CREDENTIALS.md: |
Dashboard: https://ui.honeycomb.io/account/api_keys
`HONEYCOMB_API_KEY` — secret, scoped per environment.
- id: POSTHOG
category: observabilidad
detectors:
imports: ["posthog-js", "posthog-node", "posthog-python", "import posthog", "from posthog"]
env_vars: ["POSTHOG_API_KEY", "POSTHOG_PROJECT_API_KEY", "POSTHOG_PERSONAL_API_KEY", "NEXT_PUBLIC_POSTHOG_KEY"]
deps: ["posthog-js", "posthog-node", "posthog"]
dashboard_url: "https://app.posthog.com/project/settings"
env_example: |
POSTHOG_PROJECT_API_KEY=
POSTHOG_PERSONAL_API_KEY=
POSTHOG_HOST=https://us.i.posthog.com
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${POSTHOG_PERSONAL_API_KEY:?POSTHOG_PERSONAL_API_KEY not set}"
HOST="${POSTHOG_HOST:-https://us.i.posthog.com}"
NAME=$(curl -fsS "${HOST%/}/api/users/@me/" -H "Authorization: Bearer $POSTHOG_PERSONAL_API_KEY" | python3 -c 'import json,sys; print(json.load(sys.stdin).get("email","?"))')
echo "OK — PostHog authed as $NAME."
README.md: |
# POSTHOG
Product analytics + session replay + feature flags + A/B + LLM observability.
CREDENTIALS.md: |
Dashboard: https://app.posthog.com/project/settings
`POSTHOG_PROJECT_API_KEY` — public, for SDK init.
`POSTHOG_PERSONAL_API_KEY` — secret, for API queries.
- id: LANGFUSE
category: observabilidad
detectors:
imports: ["langfuse", "import langfuse", "from langfuse"]
env_vars: ["LANGFUSE_PUBLIC_KEY", "LANGFUSE_SECRET_KEY", "LANGFUSE_HOST"]
deps: ["langfuse"]
dashboard_url: "https://cloud.langfuse.com"
env_example: |
LANGFUSE_PUBLIC_KEY=
LANGFUSE_SECRET_KEY=
LANGFUSE_HOST=https://cloud.langfuse.com
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${LANGFUSE_PUBLIC_KEY:?LANGFUSE_PUBLIC_KEY not set}"
: "${LANGFUSE_SECRET_KEY:?LANGFUSE_SECRET_KEY not set}"
HOST="${LANGFUSE_HOST:-https://cloud.langfuse.com}"
curl -fsS "${HOST%/}/api/public/projects" -u "$LANGFUSE_PUBLIC_KEY:$LANGFUSE_SECRET_KEY" >/dev/null
echo "OK — Langfuse credentials valid."
README.md: |
# LANGFUSE
LLM observability: tracing, evals, prompts, datasets.
CREDENTIALS.md: |
Dashboard: https://cloud.langfuse.com
Both keys are needed; the public key is used as the username.
- id: LOGFIRE
category: observabilidad
detectors:
imports: ["import logfire", "from logfire"]
env_vars: ["LOGFIRE_TOKEN"]
deps: ["logfire"]
dashboard_url: "https://logfire.pydantic.dev"
env_example: |
LOGFIRE_TOKEN=
files:
test_connection.sh: |
#!/usr/bin/env bash
# Logfire ingests via OTLP; there's no read-only auth endpoint.
# We validate the token format and probe the public OTLP endpoint.
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${LOGFIRE_TOKEN:?LOGFIRE_TOKEN not set}"
curl -fsS -o /dev/null -w "%{http_code}\n" https://logfire-api.pydantic.dev/health | grep -q 200
echo "OK — Logfire ingest endpoint reachable."
README.md: |
# LOGFIRE
Observability built on OpenTelemetry by the Pydantic team.
CREDENTIALS.md: |
Dashboard: https://logfire.pydantic.dev
`LOGFIRE_TOKEN` — secret, scoped per project.
# ------------------------------------------------------------------
# Product analytics
# ------------------------------------------------------------------
- id: MIXPANEL
category: analitica
detectors:
imports: ["import mixpanel", "from mixpanel", "mixpanel-browser", "mixpanel"]
env_vars: ["MIXPANEL_TOKEN", "MIXPANEL_API_SECRET", "MIXPANEL_PROJECT_ID", "MIXPANEL_SA_USER", "MIXPANEL_SA_SECRET"]
deps: ["mixpanel", "mixpanel-browser"]
dashboard_url: "https://mixpanel.com/settings/project"
env_example: |
MIXPANEL_TOKEN=
MIXPANEL_SA_USER=
MIXPANEL_SA_SECRET=
MIXPANEL_PROJECT_ID=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${MIXPANEL_SA_USER:?MIXPANEL_SA_USER not set}"
: "${MIXPANEL_SA_SECRET:?MIXPANEL_SA_SECRET not set}"
: "${MIXPANEL_PROJECT_ID:?MIXPANEL_PROJECT_ID not set}"
curl -fsS "https://mixpanel.com/api/app/projects/$MIXPANEL_PROJECT_ID" -u "$MIXPANEL_SA_USER:$MIXPANEL_SA_SECRET" >/dev/null
echo "OK — Mixpanel service account valid."
README.md: |
# MIXPANEL
Event-based product analytics.
CREDENTIALS.md: |
Dashboard: https://mixpanel.com/settings/project
`MIXPANEL_TOKEN` — public, for SDK init.
`MIXPANEL_SA_USER` / `MIXPANEL_SA_SECRET` — Service Account credentials for API queries.
- id: AMPLITUDE
category: analitica
detectors:
imports: ["@amplitude/analytics-browser", "@amplitude/analytics-node", "amplitude-js", "import amplitude"]
env_vars: ["AMPLITUDE_API_KEY", "AMPLITUDE_SECRET_KEY"]
deps: ["@amplitude/analytics-browser", "@amplitude/analytics-node", "amplitude"]
dashboard_url: "https://amplitude.com/settings"
env_example: |
AMPLITUDE_API_KEY=
AMPLITUDE_SECRET_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
# Amplitude API uses HTTP Basic with api_key:secret_key.
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${AMPLITUDE_API_KEY:?AMPLITUDE_API_KEY not set}"
: "${AMPLITUDE_SECRET_KEY:?AMPLITUDE_SECRET_KEY not set}"
curl -fsS https://amplitude.com/api/2/usersearch?user=test -u "$AMPLITUDE_API_KEY:$AMPLITUDE_SECRET_KEY" >/dev/null
echo "OK — Amplitude credentials valid."
README.md: |
# AMPLITUDE
Product analytics + experimentation.
CREDENTIALS.md: |
Dashboard: https://amplitude.com/settings
Both keys are needed for the API (Basic auth: api_key:secret_key).
- id: PLAUSIBLE
category: analitica
detectors:
imports: ["next-plausible", "plausible-tracker"]
env_vars: ["PLAUSIBLE_API_KEY", "PLAUSIBLE_SITE_ID", "PLAUSIBLE_HOST"]
deps: ["next-plausible", "plausible-tracker"]
dashboard_url: "https://plausible.io/settings/api-keys"
env_example: |
PLAUSIBLE_API_KEY=
PLAUSIBLE_SITE_ID=
PLAUSIBLE_HOST=https://plausible.io
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${PLAUSIBLE_API_KEY:?PLAUSIBLE_API_KEY not set}"
: "${PLAUSIBLE_SITE_ID:?PLAUSIBLE_SITE_ID not set}"
HOST="${PLAUSIBLE_HOST:-https://plausible.io}"
N=$(curl -fsS "${HOST%/}/api/v1/stats/realtime/visitors?site_id=$PLAUSIBLE_SITE_ID" -H "Authorization: Bearer $PLAUSIBLE_API_KEY")
echo "OK — Plausible realtime visitors: $N."
README.md: |
# PLAUSIBLE
Privacy-friendly, GDPR-compliant analytics.
CREDENTIALS.md: |
Dashboard: https://plausible.io/settings/api-keys
`PLAUSIBLE_SITE_ID` is the domain (e.g. `example.com`).
- id: FATHOM
category: analitica
detectors:
imports: ["fathom-client"]
env_vars: ["FATHOM_API_TOKEN", "FATHOM_SITE_ID"]
deps: ["fathom-client"]
dashboard_url: "https://app.usefathom.com/api"
env_example: |
FATHOM_API_TOKEN=
FATHOM_SITE_ID=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${FATHOM_API_TOKEN:?FATHOM_API_TOKEN not set}"
N=$(curl -fsS https://api.usefathom.com/v1/sites -H "Authorization: Bearer $FATHOM_API_TOKEN" | python3 -c 'import json,sys; print(len(json.load(sys.stdin)["data"]))')
echo "OK — Fathom sites: $N."
README.md: |
# FATHOM
Simple, privacy-focused web analytics.
CREDENTIALS.md: |
Dashboard: https://app.usefathom.com/api
`FATHOM_API_TOKEN` — secret.
- id: UMAMI
category: analitica
detectors:
imports: ["@umami/node"]
env_vars: ["UMAMI_API_KEY", "UMAMI_HOST", "UMAMI_WEBSITE_ID"]
deps: ["@umami/node"]
dashboard_url: "https://cloud.umami.is/settings/api"
env_example: |
UMAMI_HOST=https://api.umami.is
UMAMI_API_KEY=
UMAMI_WEBSITE_ID=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${UMAMI_API_KEY:?UMAMI_API_KEY not set}"
HOST="${UMAMI_HOST:-https://api.umami.is}"
curl -fsS "${HOST%/}/v1/me" -H "x-umami-api-key: $UMAMI_API_KEY" >/dev/null
echo "OK — Umami API key valid."
README.md: |
# UMAMI
Open-source, privacy-focused analytics. Cloud or self-hosted.
CREDENTIALS.md: |
Dashboard: https://cloud.umami.is/settings/api
`UMAMI_API_KEY` — secret.
- id: SEGMENT
category: analitica
detectors:
imports: ["@segment/analytics-node", "@segment/analytics-next", "from segment"]
env_vars: ["SEGMENT_WRITE_KEY", "SEGMENT_API_TOKEN"]
deps: ["@segment/analytics-node", "@segment/analytics-next"]
dashboard_url: "https://app.segment.com/goto-my-workspace/settings/access-management"
env_example: |
SEGMENT_WRITE_KEY=
SEGMENT_API_TOKEN=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${SEGMENT_API_TOKEN:?SEGMENT_API_TOKEN not set}"
N=$(curl -fsS https://api.segmentapis.com/sources -H "Authorization: Bearer $SEGMENT_API_TOKEN" | python3 -c 'import json,sys; print(len(json.load(sys.stdin)["data"]["sources"]))')
echo "OK — Segment sources: $N."
README.md: |
# SEGMENT
CDP (Customer Data Platform). Pipes events to other tools.
CREDENTIALS.md: |
Dashboard: https://app.segment.com/goto-my-workspace/settings/access-management
`SEGMENT_WRITE_KEY` — per source, for SDKs.
`SEGMENT_API_TOKEN` — workspace, for Config API.
# ------------------------------------------------------------------
# Deploy & PaaS
# ------------------------------------------------------------------
- id: VERCEL
category: infra
detectors:
imports: ["@vercel/sdk", "@vercel/analytics", "@vercel/blob", "@vercel/kv", "@vercel/postgres"]
env_vars: ["VERCEL_TOKEN", "VERCEL_TEAM_ID", "VERCEL_PROJECT_ID"]
deps: ["@vercel/sdk", "vercel"]
dashboard_url: "https://vercel.com/account/tokens"
env_example: |
VERCEL_TOKEN=
VERCEL_TEAM_ID=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${VERCEL_TOKEN:?VERCEL_TOKEN not set}"
USER=$(curl -fsS https://api.vercel.com/v2/user -H "Authorization: Bearer $VERCEL_TOKEN" | python3 -c 'import json,sys; print(json.load(sys.stdin)["user"]["username"])')
echo "OK — Vercel authed as $USER."
README.md: |
# VERCEL
Frontend + serverless deploy. Tokens scoped per-team.
CREDENTIALS.md: |
Dashboard: https://vercel.com/account/tokens
`VERCEL_TOKEN` — secret. `VERCEL_TEAM_ID` needed for team-scoped calls.
- id: NETLIFY
category: infra
detectors:
imports: ["@netlify/functions", "@netlify/blobs"]
env_vars: ["NETLIFY_AUTH_TOKEN", "NETLIFY_SITE_ID"]
deps: ["netlify", "netlify-cli", "@netlify/functions"]
dashboard_url: "https://app.netlify.com/user/applications#personal-access-tokens"
env_example: |
NETLIFY_AUTH_TOKEN=
NETLIFY_SITE_ID=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${NETLIFY_AUTH_TOKEN:?NETLIFY_AUTH_TOKEN not set}"
N=$(curl -fsS https://api.netlify.com/api/v1/sites -H "Authorization: Bearer $NETLIFY_AUTH_TOKEN" | python3 -c 'import json,sys; print(len(json.load(sys.stdin)))')
echo "OK — Netlify sites: $N."
README.md: |
# NETLIFY
Static + serverless hosting.
CREDENTIALS.md: |
Dashboard: https://app.netlify.com/user/applications#personal-access-tokens
`NETLIFY_AUTH_TOKEN` — secret.
- id: RAILWAY
category: infra
detectors:
imports: []
env_vars: ["RAILWAY_TOKEN", "RAILWAY_API_TOKEN", "RAILWAY_PROJECT_ID"]
deps: ["@railway/cli"]
dashboard_url: "https://railway.app/account/tokens"
env_example: |
RAILWAY_API_TOKEN=
files:
test_connection.sh: |
#!/usr/bin/env bash
# Railway uses GraphQL exclusively.
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${RAILWAY_API_TOKEN:?RAILWAY_API_TOKEN not set}"
curl -fsS https://backboard.railway.app/graphql/v2 \
-H "Authorization: Bearer $RAILWAY_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{"query":"{ me { name } }"}' \
| python3 -c 'import json,sys; d=json.load(sys.stdin); print("OK — Railway authed as", d["data"]["me"]["name"])'
README.md: |
# RAILWAY
Hetzner-style PaaS with templates and Postgres add-ons.
CREDENTIALS.md: |
Dashboard: https://railway.app/account/tokens
`RAILWAY_API_TOKEN` — secret, account-scoped.
- id: FLY_IO
category: infra
detectors:
imports: []
env_vars: ["FLY_API_TOKEN", "FLY_ACCESS_TOKEN", "FLY_ORG"]
deps: []
dashboard_url: "https://fly.io/user/personal_access_tokens"
env_example: |
FLY_API_TOKEN=
FLY_ORG=personal
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
TOKEN="${FLY_API_TOKEN:-${FLY_ACCESS_TOKEN:-}}"
[ -n "$TOKEN" ] || { echo "ERROR: FLY_API_TOKEN not set" >&2; exit 1; }
# Fly Machines REST API.
ORG="${FLY_ORG:-personal}"
N=$(curl -fsS "https://api.machines.dev/v1/apps?org_slug=$ORG" -H "Authorization: Bearer $TOKEN" | python3 -c 'import json,sys; print(len(json.load(sys.stdin).get("apps",[])))')
echo "OK — Fly.io apps in '$ORG': $N."
README.md: |
# FLY_IO
Run apps as Firecracker microVMs in regions worldwide.
CREDENTIALS.md: |
Dashboard: https://fly.io/user/personal_access_tokens
`FLY_API_TOKEN` — secret. `FLY_ORG` is the org slug (default `personal`).
- id: RENDER
category: infra
detectors:
imports: []
env_vars: ["RENDER_API_KEY"]
deps: []
dashboard_url: "https://dashboard.render.com/u/settings#api-keys"
env_example: |
RENDER_API_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${RENDER_API_KEY:?RENDER_API_KEY not set}"
N=$(curl -fsS https://api.render.com/v1/services -H "Authorization: Bearer $RENDER_API_KEY" | python3 -c 'import json,sys; print(len(json.load(sys.stdin)))')
echo "OK — Render services: $N."
README.md: |
# RENDER
PaaS for web services, cron jobs, static sites, databases.
CREDENTIALS.md: |
Dashboard: https://dashboard.render.com/u/settings#api-keys
`RENDER_API_KEY` — secret.
- id: DIGITALOCEAN
category: infra
detectors:
imports: ["pydo", "from digitalocean", "@digitalocean/godo"]
env_vars: ["DIGITALOCEAN_TOKEN", "DO_API_TOKEN", "DIGITALOCEAN_ACCESS_TOKEN"]
deps: ["pydo", "digitalocean"]
dashboard_url: "https://cloud.digitalocean.com/account/api/tokens"
env_example: |
DIGITALOCEAN_TOKEN=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
TOKEN="${DIGITALOCEAN_TOKEN:-${DO_API_TOKEN:-${DIGITALOCEAN_ACCESS_TOKEN:-}}}"
[ -n "$TOKEN" ] || { echo "ERROR: DIGITALOCEAN_TOKEN not set" >&2; exit 1; }
EMAIL=$(curl -fsS https://api.digitalocean.com/v2/account -H "Authorization: Bearer $TOKEN" | python3 -c 'import json,sys; print(json.load(sys.stdin)["account"]["email"])')
echo "OK — DigitalOcean account: $EMAIL."
README.md: |
# DIGITALOCEAN
Droplets, Spaces, App Platform, Managed Databases.
CREDENTIALS.md: |
Dashboard: https://cloud.digitalocean.com/account/api/tokens
`DIGITALOCEAN_TOKEN` — secret. Read + write scope.
- id: CLOUDFLARE
category: infra
detectors:
imports: ["cloudflare", "import cloudflare", "from cloudflare", "@cloudflare/workers-types", "wrangler"]
env_vars: ["CLOUDFLARE_API_TOKEN", "CLOUDFLARE_ACCOUNT_ID", "CF_API_TOKEN"]
deps: ["cloudflare", "wrangler", "@cloudflare/workers-types"]
dashboard_url: "https://dash.cloudflare.com/profile/api-tokens"
env_example: |
CLOUDFLARE_API_TOKEN=
CLOUDFLARE_ACCOUNT_ID=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
TOKEN="${CLOUDFLARE_API_TOKEN:-${CF_API_TOKEN:-}}"
[ -n "$TOKEN" ] || { echo "ERROR: CLOUDFLARE_API_TOKEN not set" >&2; exit 1; }
curl -fsS https://api.cloudflare.com/client/v4/user/tokens/verify -H "Authorization: Bearer $TOKEN" | grep -q '"success":true'
echo "OK — Cloudflare token verified."
README.md: |
# CLOUDFLARE
DNS + CDN + Workers + R2 + D1 + Pages + Tunnels.
CREDENTIALS.md: |
Dashboard: https://dash.cloudflare.com/profile/api-tokens
`CLOUDFLARE_API_TOKEN` — scoped, prefer over global API key.
- id: HEROKU
category: infra
detectors:
imports: []
env_vars: ["HEROKU_API_KEY"]
deps: ["heroku"]
dashboard_url: "https://dashboard.heroku.com/account"
env_example: |
HEROKU_API_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${HEROKU_API_KEY:?HEROKU_API_KEY not set}"
EMAIL=$(curl -fsS https://api.heroku.com/account -H "Accept: application/vnd.heroku+json; version=3" -H "Authorization: Bearer $HEROKU_API_KEY" | python3 -c 'import json,sys; print(json.load(sys.stdin)["email"])')
echo "OK — Heroku account: $EMAIL."
README.md: |
# HEROKU
Classic PaaS for buildpack-based apps.
CREDENTIALS.md: |
Dashboard: https://dashboard.heroku.com/account
`HEROKU_API_KEY` — secret.
- id: VULTR
category: infra
detectors:
imports: []
env_vars: ["VULTR_API_KEY"]
deps: []
dashboard_url: "https://my.vultr.com/settings/#settingsapi"
env_example: |
VULTR_API_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${VULTR_API_KEY:?VULTR_API_KEY not set}"
BAL=$(curl -fsS https://api.vultr.com/v2/account -H "Authorization: Bearer $VULTR_API_KEY" | python3 -c 'import json,sys; print(json.load(sys.stdin)["account"]["balance"])')
echo "OK — Vultr account balance: $BAL."
README.md: |
# VULTR
Cloud servers, block/object storage, bare metal.
CREDENTIALS.md: |
Dashboard: https://my.vultr.com/settings/#settingsapi
`VULTR_API_KEY` — secret. IP allowlist may apply.
# ------------------------------------------------------------------
# Object storage
# ------------------------------------------------------------------
- id: AWS_S3
category: almacenamiento
detectors:
imports: ["@aws-sdk/client-s3", "from boto3", "import boto3"]
env_vars: ["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY", "AWS_REGION", "S3_BUCKET"]
deps: ["@aws-sdk/client-s3", "boto3"]
dashboard_url: "https://console.aws.amazon.com/iam/home"
manual_only: true
env_example: |
AWS_ACCESS_KEY_ID=
AWS_SECRET_ACCESS_KEY=
AWS_REGION=eu-west-1
S3_BUCKET=
files:
README.md: |
# AWS_S3
S3 uses SigV4 signing which is not trivial to implement in plain bash.
Verify with the AWS CLI:
aws s3 ls s3://$S3_BUCKET --region $AWS_REGION
or with boto3:
python -c "import boto3; print(boto3.client('s3').list_buckets()['Buckets'])"
CREDENTIALS.md: |
Dashboard: https://console.aws.amazon.com/iam/home
IAM access key with at minimum `s3:ListBucket`, `s3:GetObject`, `s3:PutObject` on the target bucket.
- id: CLOUDFLARE_R2
category: almacenamiento
detectors:
imports: ["@aws-sdk/client-s3"]
env_vars: ["R2_ACCOUNT_ID", "R2_ACCESS_KEY_ID", "R2_SECRET_ACCESS_KEY", "R2_BUCKET", "R2_ENDPOINT"]
deps: ["@aws-sdk/client-s3"]
dashboard_url: "https://dash.cloudflare.com/?to=/:account/r2/api-tokens"
manual_only: true
env_example: |
R2_ACCOUNT_ID=
R2_ACCESS_KEY_ID=
R2_SECRET_ACCESS_KEY=
R2_BUCKET=
R2_ENDPOINT=https://<account_id>.r2.cloudflarestorage.com
files:
README.md: |
# CLOUDFLARE_R2
S3-compatible object storage. Same SigV4 caveat as AWS_S3 — verify with:
aws --endpoint-url=$R2_ENDPOINT s3 ls s3://$R2_BUCKET
or `wrangler r2 bucket list`.
CREDENTIALS.md: |
Dashboard: https://dash.cloudflare.com/?to=/:account/r2/api-tokens
R2 keys are S3-compatible. Endpoint is per account.
- id: BACKBLAZE_B2
category: almacenamiento
detectors:
imports: ["b2sdk", "from b2sdk"]
env_vars: ["B2_APPLICATION_KEY_ID", "B2_APPLICATION_KEY", "B2_BUCKET"]
deps: ["b2sdk"]
dashboard_url: "https://secure.backblaze.com/app_keys.htm"
env_example: |
B2_APPLICATION_KEY_ID=
B2_APPLICATION_KEY=
B2_BUCKET=
files:
test_connection.sh: |
#!/usr/bin/env bash
# b2_authorize_account is the canonical auth handshake.
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${B2_APPLICATION_KEY_ID:?not set}"
: "${B2_APPLICATION_KEY:?not set}"
ACC=$(curl -fsS https://api.backblazeb2.com/b2api/v3/b2_authorize_account -u "$B2_APPLICATION_KEY_ID:$B2_APPLICATION_KEY" | python3 -c 'import json,sys; print(json.load(sys.stdin)["accountId"])')
echo "OK — Backblaze B2 account: $ACC."
README.md: |
# BACKBLAZE_B2
Cheap S3-compatible (and native) object storage.
CREDENTIALS.md: |
Dashboard: https://secure.backblaze.com/app_keys.htm
`B2_APPLICATION_KEY_ID` + `B2_APPLICATION_KEY`. Restrict to specific bucket.
# ------------------------------------------------------------------
# Realtime, video, WebRTC
# ------------------------------------------------------------------
- id: MUX
category: realtime
detectors:
imports: ["@mux/mux-node", "@mux/mux-player-react"]
env_vars: ["MUX_TOKEN_ID", "MUX_TOKEN_SECRET", "MUX_WEBHOOK_SECRET"]
deps: ["@mux/mux-node", "@mux/mux-player-react"]
dashboard_url: "https://dashboard.mux.com/settings/access-tokens"
env_example: |
MUX_TOKEN_ID=
MUX_TOKEN_SECRET=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${MUX_TOKEN_ID:?MUX_TOKEN_ID not set}"
: "${MUX_TOKEN_SECRET:?MUX_TOKEN_SECRET not set}"
N=$(curl -fsS "https://api.mux.com/video/v1/assets?limit=1" -u "$MUX_TOKEN_ID:$MUX_TOKEN_SECRET" | python3 -c 'import json,sys; print(len(json.load(sys.stdin)["data"]))')
echo "OK — Mux access token valid (sample assets: $N)."
README.md: |
# MUX
Video infrastructure for product teams (upload, transcode, deliver).
CREDENTIALS.md: |
Dashboard: https://dashboard.mux.com/settings/access-tokens
Token id + secret, scoped per env (dev/prod).
- id: LIVEKIT
category: realtime
detectors:
imports: ["livekit-server-sdk", "livekit-client", "from livekit"]
env_vars: ["LIVEKIT_API_KEY", "LIVEKIT_API_SECRET", "LIVEKIT_URL"]
deps: ["livekit-server-sdk", "livekit-client", "livekit"]
dashboard_url: "https://cloud.livekit.io"
manual_only: true
env_example: |
LIVEKIT_URL=
LIVEKIT_API_KEY=
LIVEKIT_API_SECRET=
files:
README.md: |
# LIVEKIT
WebRTC infra (rooms, recording, ingress). The API requires JWTs
signed with the API secret — verify with the official CLI:
livekit-cli list-rooms --url $LIVEKIT_URL --api-key $LIVEKIT_API_KEY --api-secret $LIVEKIT_API_SECRET
CREDENTIALS.md: |
Dashboard: https://cloud.livekit.io
Project URL + API key/secret. Self-hosted is the same env vars.
- id: DAILY_CO
category: realtime
detectors:
imports: ["@daily-co/daily-js", "@daily-co/daily-react"]
env_vars: ["DAILY_API_KEY", "DAILY_DOMAIN"]
deps: ["@daily-co/daily-js", "@daily-co/daily-react"]
dashboard_url: "https://dashboard.daily.co/developers"
env_example: |
DAILY_API_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${DAILY_API_KEY:?DAILY_API_KEY not set}"
DOMAIN=$(curl -fsS https://api.daily.co/v1/ -H "Authorization: Bearer $DAILY_API_KEY" | python3 -c 'import json,sys; print(json.load(sys.stdin).get("domain_name","?"))')
echo "OK — Daily.co domain: $DOMAIN."
README.md: |
# DAILY_CO
Embeddable video calls + meeting infra.
CREDENTIALS.md: |
Dashboard: https://dashboard.daily.co/developers
`DAILY_API_KEY` — secret.
- id: PUSHER
category: realtime
detectors:
imports: ["pusher", "pusher-js", "import pusher"]
env_vars: ["PUSHER_APP_ID", "PUSHER_KEY", "PUSHER_SECRET", "PUSHER_CLUSTER"]
deps: ["pusher", "pusher-js"]
dashboard_url: "https://dashboard.pusher.com"
manual_only: true
env_example: |
PUSHER_APP_ID=
PUSHER_KEY=
PUSHER_SECRET=
PUSHER_CLUSTER=eu
files:
README.md: |
# PUSHER
Channels (pub/sub) + Beams (push). The REST API requires per-request
HMAC-SHA256 signing — easiest to verify with the official SDK:
node -e "const Pusher = require('pusher'); new Pusher({appId: process.env.PUSHER_APP_ID, key: process.env.PUSHER_KEY, secret: process.env.PUSHER_SECRET, cluster: process.env.PUSHER_CLUSTER}).get({path: '/channels'}, console.log)"
CREDENTIALS.md: |
Dashboard: https://dashboard.pusher.com
4 vars: app_id, key, secret, cluster.
- id: ABLY
category: realtime
detectors:
imports: ["ably", "import ably", "from ably"]
env_vars: ["ABLY_API_KEY"]
deps: ["ably"]
dashboard_url: "https://ably.com/accounts/any/apps"
env_example: |
ABLY_API_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${ABLY_API_KEY:?ABLY_API_KEY not set}"
# Time endpoint requires auth and is read-only/cheap.
TS=$(curl -fsS https://rest.ably.io/time -u "$ABLY_API_KEY" | python3 -c 'import json,sys; print(json.load(sys.stdin)[0])')
echo "OK — Ably server timestamp: $TS."
README.md: |
# ABLY
Realtime messaging / pub-sub at scale.
CREDENTIALS.md: |
Dashboard: https://ably.com/accounts/any/apps
`ABLY_API_KEY` has the form `appKeyId:appKeySecret`.
# ------------------------------------------------------------------
# Communications (SMS, voice, push, in-app notifications)
# ------------------------------------------------------------------
- id: TWILIO
category: comunicacion
detectors:
imports: ["twilio", "from twilio", "import twilio"]
env_vars: ["TWILIO_ACCOUNT_SID", "TWILIO_AUTH_TOKEN", "TWILIO_API_KEY", "TWILIO_API_SECRET"]
deps: ["twilio"]
dashboard_url: "https://console.twilio.com"
env_example: |
TWILIO_ACCOUNT_SID=
TWILIO_AUTH_TOKEN=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${TWILIO_ACCOUNT_SID:?TWILIO_ACCOUNT_SID not set}"
: "${TWILIO_AUTH_TOKEN:?TWILIO_AUTH_TOKEN not set}"
STATUS=$(curl -fsS "https://api.twilio.com/2010-04-01/Accounts/$TWILIO_ACCOUNT_SID.json" -u "$TWILIO_ACCOUNT_SID:$TWILIO_AUTH_TOKEN" | python3 -c 'import json,sys; print(json.load(sys.stdin)["status"])')
echo "OK — Twilio account status: $STATUS."
README.md: |
# TWILIO
SMS, voice, WhatsApp, Verify, Video.
CREDENTIALS.md: |
Dashboard: https://console.twilio.com
Account SID + Auth Token from the main account page.
- id: VONAGE
category: comunicacion
detectors:
imports: ["@vonage/server-sdk", "vonage"]
env_vars: ["VONAGE_API_KEY", "VONAGE_API_SECRET"]
deps: ["@vonage/server-sdk", "vonage"]
dashboard_url: "https://dashboard.nexmo.com/settings"
env_example: |
VONAGE_API_KEY=
VONAGE_API_SECRET=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${VONAGE_API_KEY:?VONAGE_API_KEY not set}"
: "${VONAGE_API_SECRET:?VONAGE_API_SECRET not set}"
BAL=$(curl -fsS "https://rest.nexmo.com/account/get-balance?api_key=$VONAGE_API_KEY&api_secret=$VONAGE_API_SECRET" | python3 -c 'import json,sys; print(json.load(sys.stdin)["value"])')
echo "OK — Vonage balance: $BAL."
README.md: |
# VONAGE
SMS, voice, verify (formerly Nexmo).
CREDENTIALS.md: |
Dashboard: https://dashboard.nexmo.com/settings
API key + secret. Some APIs (Conversations) need an Application ID.
- id: ONESIGNAL
category: comunicacion
detectors:
imports: ["react-onesignal", "onesignal-node", "@onesignal/onesignal-react-native"]
env_vars: ["ONESIGNAL_APP_ID", "ONESIGNAL_REST_API_KEY", "ONESIGNAL_USER_AUTH_KEY"]
deps: ["onesignal-node", "react-onesignal", "@onesignal/onesignal-react-native"]
dashboard_url: "https://dashboard.onesignal.com/apps"
env_example: |
ONESIGNAL_APP_ID=
ONESIGNAL_REST_API_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${ONESIGNAL_APP_ID:?ONESIGNAL_APP_ID not set}"
: "${ONESIGNAL_REST_API_KEY:?ONESIGNAL_REST_API_KEY not set}"
N=$(curl -fsS "https://api.onesignal.com/apps/$ONESIGNAL_APP_ID" -H "Authorization: Key $ONESIGNAL_REST_API_KEY" | python3 -c 'import json,sys; print(json.load(sys.stdin)["players"])')
echo "OK — OneSignal app players: $N."
README.md: |
# ONESIGNAL
Multi-channel push (mobile, web, email).
CREDENTIALS.md: |
Dashboard: https://dashboard.onesignal.com/apps
REST API key is per-app, scoped.
- id: EXPO_PUSH
category: comunicacion
detectors:
imports: ["expo-server-sdk", "expo-notifications"]
env_vars: ["EXPO_ACCESS_TOKEN"]
deps: ["expo-server-sdk", "expo-notifications"]
dashboard_url: "https://expo.dev/accounts/[account]/settings/access-tokens"
manual_only: true
env_example: |
EXPO_ACCESS_TOKEN=
files:
README.md: |
# EXPO_PUSH
Push notifications for Expo apps. The push endpoint requires a real
ExponentPushToken from a device — there is no read-only health endpoint.
Verify by calling `expo whoami` after `export EXPO_TOKEN=$EXPO_ACCESS_TOKEN`.
CREDENTIALS.md: |
Dashboard: https://expo.dev/accounts/[account]/settings/access-tokens
`EXPO_ACCESS_TOKEN` — secret, account-scoped.
- id: KNOCK
category: comunicacion
detectors:
imports: ["@knocklabs/node", "@knocklabs/react", "@knocklabs/client"]
env_vars: ["KNOCK_API_KEY", "KNOCK_PUBLIC_API_KEY", "KNOCK_SIGNING_KEY"]
deps: ["@knocklabs/node", "@knocklabs/react"]
dashboard_url: "https://dashboard.knock.app"
env_example: |
KNOCK_API_KEY=
KNOCK_PUBLIC_API_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${KNOCK_API_KEY:?KNOCK_API_KEY not set}"
# List users with a tiny limit; cheap auth check.
curl -fsS "https://api.knock.app/v1/users?page_size=1" -H "Authorization: Bearer $KNOCK_API_KEY" >/dev/null
echo "OK — Knock API key valid."
README.md: |
# KNOCK
Notifications-as-a-service: orchestrate email, push, in-app, SMS.
CREDENTIALS.md: |
Dashboard: https://dashboard.knock.app
Secret key for backend, public key for client SDKs.
# ------------------------------------------------------------------
# Maps / geo
# ------------------------------------------------------------------
- id: GOOGLE_MAPS
category: mapas_geo
detectors:
imports: ["@googlemaps/js-api-loader", "@googlemaps/google-maps-services-js", "@react-google-maps/api"]
env_vars: ["GOOGLE_MAPS_API_KEY", "NEXT_PUBLIC_GOOGLE_MAPS_API_KEY"]
deps: ["@googlemaps/js-api-loader", "@googlemaps/google-maps-services-js", "@react-google-maps/api"]
dashboard_url: "https://console.cloud.google.com/google/maps-apis/credentials"
env_example: |
GOOGLE_MAPS_API_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
# Geocoding a known landmark is cheap (~$0.005) and validates the key.
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${GOOGLE_MAPS_API_KEY:?GOOGLE_MAPS_API_KEY not set}"
STATUS=$(curl -fsS "https://maps.googleapis.com/maps/api/geocode/json?address=Madrid&key=$GOOGLE_MAPS_API_KEY" | python3 -c 'import json,sys; print(json.load(sys.stdin)["status"])')
[ "$STATUS" = "OK" ] || { echo "FAIL: status=$STATUS" >&2; exit 1; }
echo "OK — Google Maps geocoding accessible."
README.md: |
# GOOGLE_MAPS
Maps, Places, Geocoding, Directions, Distance Matrix.
> The smoke-test costs ~$0.005 (1 geocode).
CREDENTIALS.md: |
Dashboard: https://console.cloud.google.com/google/maps-apis/credentials
Restrict the key by HTTP referrer (web) or app bundle (mobile).
- id: MAPBOX
category: mapas_geo
detectors:
imports: ["mapbox-gl", "react-map-gl", "@mapbox/mapbox-sdk"]
env_vars: ["MAPBOX_ACCESS_TOKEN", "NEXT_PUBLIC_MAPBOX_TOKEN", "MAPBOX_SECRET_TOKEN"]
deps: ["mapbox-gl", "react-map-gl", "@mapbox/mapbox-sdk"]
dashboard_url: "https://account.mapbox.com/access-tokens"
env_example: |
MAPBOX_ACCESS_TOKEN=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${MAPBOX_ACCESS_TOKEN:?MAPBOX_ACCESS_TOKEN not set}"
# Geocoding API: 1 free request.
FEATURES=$(curl -fsS "https://api.mapbox.com/geocoding/v5/mapbox.places/Madrid.json?access_token=$MAPBOX_ACCESS_TOKEN&limit=1" | python3 -c 'import json,sys; print(len(json.load(sys.stdin)["features"]))')
echo "OK — Mapbox geocoding returned $FEATURES feature(s)."
README.md: |
# MAPBOX
Vector maps, geocoding, navigation, search.
CREDENTIALS.md: |
Dashboard: https://account.mapbox.com/access-tokens
Public tokens (`pk.*`) for clients, secret tokens (`sk.*`) for server.
# ------------------------------------------------------------------
# Calendar / scheduling
# ------------------------------------------------------------------
- id: CAL_COM
category: productividad
detectors:
imports: ["@calcom/embed-react"]
env_vars: ["CAL_API_KEY", "CALCOM_API_KEY"]
deps: ["@calcom/embed-react"]
dashboard_url: "https://app.cal.com/settings/developer/api-keys"
env_example: |
CALCOM_API_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
KEY="${CALCOM_API_KEY:-${CAL_API_KEY:-}}"
[ -n "$KEY" ] || { echo "ERROR: CALCOM_API_KEY not set" >&2; exit 1; }
# v1: GET /me?apiKey=
EMAIL=$(curl -fsS "https://api.cal.com/v1/me?apiKey=$KEY" | python3 -c 'import json,sys; print(json.load(sys.stdin)["user"]["email"])')
echo "OK — Cal.com user: $EMAIL."
README.md: |
# CAL_COM
Open-source scheduling (Calendly alternative).
CREDENTIALS.md: |
Dashboard: https://app.cal.com/settings/developer/api-keys
`CALCOM_API_KEY` — secret.
- id: CALENDLY
category: productividad
detectors:
imports: []
env_vars: ["CALENDLY_API_KEY", "CALENDLY_ACCESS_TOKEN"]
deps: []
dashboard_url: "https://calendly.com/integrations/api_webhooks"
env_example: |
CALENDLY_ACCESS_TOKEN=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
TOKEN="${CALENDLY_ACCESS_TOKEN:-${CALENDLY_API_KEY:-}}"
[ -n "$TOKEN" ] || { echo "ERROR: CALENDLY_ACCESS_TOKEN not set" >&2; exit 1; }
EMAIL=$(curl -fsS https://api.calendly.com/users/me -H "Authorization: Bearer $TOKEN" | python3 -c 'import json,sys; print(json.load(sys.stdin)["resource"]["email"])')
echo "OK — Calendly user: $EMAIL."
README.md: |
# CALENDLY
Scheduling SaaS. API access requires a paid plan.
CREDENTIALS.md: |
Dashboard: https://calendly.com/integrations/api_webhooks
`CALENDLY_ACCESS_TOKEN` — secret. Personal access tokens for individuals.
# ------------------------------------------------------------------
# Productivity / project management / CRM / dev tools APIs
# ------------------------------------------------------------------
- id: LINEAR
category: productividad
detectors:
imports: ["@linear/sdk"]
env_vars: ["LINEAR_API_KEY"]
deps: ["@linear/sdk"]
dashboard_url: "https://linear.app/settings/api"
env_example: |
LINEAR_API_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
# Linear is GraphQL-only.
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${LINEAR_API_KEY:?LINEAR_API_KEY not set}"
NAME=$(curl -fsS https://api.linear.app/graphql \
-H "Authorization: $LINEAR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"query":"{ viewer { name } }"}' \
| python3 -c 'import json,sys; print(json.load(sys.stdin)["data"]["viewer"]["name"])')
echo "OK — Linear authed as $NAME."
README.md: |
# LINEAR
Issue tracking and project management. GraphQL API.
CREDENTIALS.md: |
Dashboard: https://linear.app/settings/api
`LINEAR_API_KEY` — secret, personal API key.
- id: NOTION
category: productividad
detectors:
imports: ["@notionhq/client", "notion-client"]
env_vars: ["NOTION_API_KEY", "NOTION_TOKEN", "NOTION_DATABASE_ID"]
deps: ["@notionhq/client"]
dashboard_url: "https://www.notion.so/my-integrations"
env_example: |
NOTION_API_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
TOKEN="${NOTION_API_KEY:-${NOTION_TOKEN:-}}"
[ -n "$TOKEN" ] || { echo "ERROR: NOTION_API_KEY not set" >&2; exit 1; }
NAME=$(curl -fsS https://api.notion.com/v1/users/me \
-H "Authorization: Bearer $TOKEN" \
-H "Notion-Version: 2022-06-28" \
| python3 -c 'import json,sys; print(json.load(sys.stdin).get("name","?"))')
echo "OK — Notion integration: $NAME."
README.md: |
# NOTION
Internal integration token gives access to pages explicitly shared with it.
CREDENTIALS.md: |
Dashboard: https://www.notion.so/my-integrations
Internal integration secret. Share each page/db with the integration.
- id: HUBSPOT
category: productividad
detectors:
imports: ["@hubspot/api-client"]
env_vars: ["HUBSPOT_ACCESS_TOKEN", "HUBSPOT_PRIVATE_APP_TOKEN"]
deps: ["@hubspot/api-client", "hubspot-api-client"]
dashboard_url: "https://app.hubspot.com/private-apps"
env_example: |
HUBSPOT_ACCESS_TOKEN=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
TOKEN="${HUBSPOT_ACCESS_TOKEN:-${HUBSPOT_PRIVATE_APP_TOKEN:-}}"
[ -n "$TOKEN" ] || { echo "ERROR: HUBSPOT_ACCESS_TOKEN not set" >&2; exit 1; }
N=$(curl -fsS "https://api.hubapi.com/crm/v3/objects/contacts?limit=1" -H "Authorization: Bearer $TOKEN" | python3 -c 'import json,sys; print(len(json.load(sys.stdin)["results"]))')
echo "OK — HubSpot contacts endpoint accessible (sample: $N)."
README.md: |
# HUBSPOT
CRM + marketing automation + service hub.
CREDENTIALS.md: |
Dashboard: https://app.hubspot.com/private-apps
Private apps use a single bearer token with selectable scopes.
- id: GITHUB_API
category: productividad
detectors:
imports: ["@octokit/rest", "@octokit/core", "from github", "import github"]
env_vars: ["GH_TOKEN", "GITHUB_TOKEN", "GH_PAT", "GITHUB_PAT"]
deps: ["@octokit/rest", "@octokit/core", "pygithub", "octokit"]
dashboard_url: "https://github.com/settings/tokens"
env_example: |
GITHUB_TOKEN=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
TOKEN="${GITHUB_TOKEN:-${GH_TOKEN:-${GH_PAT:-${GITHUB_PAT:-}}}}"
[ -n "$TOKEN" ] || { echo "ERROR: GITHUB_TOKEN not set" >&2; exit 1; }
LOGIN=$(curl -fsS https://api.github.com/user -H "Authorization: Bearer $TOKEN" | python3 -c 'import json,sys; print(json.load(sys.stdin)["login"])')
echo "OK — GitHub authed as $LOGIN."
README.md: |
# GITHUB_API
Programmatic access to GitHub (repos, PRs, issues, releases, Actions).
CREDENTIALS.md: |
Dashboard: https://github.com/settings/tokens (or fine-grained tokens).
Use a fine-grained token scoped to the minimal repos/permissions.
- id: GITLAB_API
category: productividad
detectors:
imports: ["@gitbeaker/rest", "from gitlab", "import gitlab"]
env_vars: ["GITLAB_TOKEN", "GITLAB_PRIVATE_TOKEN"]
deps: ["@gitbeaker/rest", "python-gitlab"]
dashboard_url: "https://gitlab.com/-/user_settings/personal_access_tokens"
env_example: |
GITLAB_TOKEN=
GITLAB_URL=https://gitlab.com
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${GITLAB_TOKEN:?GITLAB_TOKEN not set}"
URL="${GITLAB_URL:-https://gitlab.com}"
NAME=$(curl -fsS "${URL%/}/api/v4/user" -H "PRIVATE-TOKEN: $GITLAB_TOKEN" | python3 -c 'import json,sys; print(json.load(sys.stdin)["username"])')
echo "OK — GitLab authed as $NAME."
README.md: |
# GITLAB_API
Programmatic access to GitLab. Works for SaaS and self-hosted.
CREDENTIALS.md: |
Dashboard: https://gitlab.com/-/user_settings/personal_access_tokens
`GITLAB_URL` defaults to gitlab.com; override for self-hosted instances.
# ------------------------------------------------------------------
# Customer support
# ------------------------------------------------------------------
- id: INTERCOM
category: productividad
detectors:
imports: ["@intercom/messenger-js-sdk", "intercom-client"]
env_vars: ["INTERCOM_ACCESS_TOKEN", "INTERCOM_APP_ID"]
deps: ["intercom-client", "@intercom/messenger-js-sdk"]
dashboard_url: "https://app.intercom.com/a/apps/_/developer-hub"
env_example: |
INTERCOM_ACCESS_TOKEN=
INTERCOM_APP_ID=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${INTERCOM_ACCESS_TOKEN:?INTERCOM_ACCESS_TOKEN not set}"
NAME=$(curl -fsS https://api.intercom.io/me \
-H "Authorization: Bearer $INTERCOM_ACCESS_TOKEN" \
-H "Accept: application/json" \
| python3 -c 'import json,sys; print(json.load(sys.stdin).get("app",{}).get("name","?"))')
echo "OK — Intercom workspace: $NAME."
README.md: |
# INTERCOM
Customer messaging + help center + product tours.
CREDENTIALS.md: |
Dashboard: https://app.intercom.com/a/apps/_/developer-hub
Personal access token (developer hub).
- id: CRISP
category: productividad
detectors:
imports: ["crisp-api"]
env_vars: ["CRISP_IDENTIFIER", "CRISP_KEY", "CRISP_WEBSITE_ID"]
deps: ["crisp-api"]
dashboard_url: "https://app.crisp.chat/initiate/plugin/"
manual_only: true
env_example: |
CRISP_IDENTIFIER=
CRISP_KEY=
CRISP_WEBSITE_ID=
files:
README.md: |
# CRISP
Customer chat + helpdesk. The REST API uses Basic auth with
`identifier:key` plus a Website ID — verify via the official SDK:
node -e "require('crisp-api').authenticateTier('plugin', process.env.CRISP_IDENTIFIER, process.env.CRISP_KEY)"
CREDENTIALS.md: |
Dashboard: https://app.crisp.chat/initiate/plugin/
Plugin tokens scoped to a specific Website ID.
# ------------------------------------------------------------------
# Feature flags / experimentation
# ------------------------------------------------------------------
- id: GROWTHBOOK
category: feature_flags
detectors:
imports: ["@growthbook/growthbook", "@growthbook/growthbook-react", "growthbook"]
env_vars: ["GROWTHBOOK_API_KEY", "GROWTHBOOK_CLIENT_KEY", "GROWTHBOOK_HOST"]
deps: ["@growthbook/growthbook", "@growthbook/growthbook-react", "growthbook"]
dashboard_url: "https://app.growthbook.io/settings/keys"
env_example: |
GROWTHBOOK_HOST=https://api.growthbook.io
GROWTHBOOK_API_KEY=
GROWTHBOOK_CLIENT_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${GROWTHBOOK_API_KEY:?GROWTHBOOK_API_KEY not set}"
HOST="${GROWTHBOOK_HOST:-https://api.growthbook.io}"
N=$(curl -fsS "${HOST%/}/api/v1/features?limit=1" -H "Authorization: Bearer $GROWTHBOOK_API_KEY" | python3 -c 'import json,sys; print(json.load(sys.stdin).get("limit","?"))')
echo "OK — GrowthBook API key valid."
README.md: |
# GROWTHBOOK
Open-source feature flags + experimentation. Cloud or self-hosted.
CREDENTIALS.md: |
Dashboard: https://app.growthbook.io/settings/keys
`GROWTHBOOK_API_KEY` — secret, for the management API.
`GROWTHBOOK_CLIENT_KEY` — public, for SDK init.
- id: LAUNCHDARKLY
category: feature_flags
detectors:
imports: ["launchdarkly-node-server-sdk", "launchdarkly-react-client-sdk", "launchdarkly-js-client-sdk"]
env_vars: ["LAUNCHDARKLY_SDK_KEY", "LAUNCHDARKLY_API_KEY", "LD_SDK_KEY", "LD_API_KEY"]
deps: ["launchdarkly-node-server-sdk", "launchdarkly-react-client-sdk"]
dashboard_url: "https://app.launchdarkly.com/settings/authorization"
env_example: |
LAUNCHDARKLY_API_KEY=
LAUNCHDARKLY_SDK_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
TOKEN="${LAUNCHDARKLY_API_KEY:-${LD_API_KEY:-}}"
[ -n "$TOKEN" ] || { echo "ERROR: LAUNCHDARKLY_API_KEY not set" >&2; exit 1; }
N=$(curl -fsS https://app.launchdarkly.com/api/v2/projects -H "Authorization: $TOKEN" | python3 -c 'import json,sys; print(json.load(sys.stdin)["totalCount"])')
echo "OK — LaunchDarkly projects: $N."
README.md: |
# LAUNCHDARKLY
Enterprise feature flagging + experimentation.
CREDENTIALS.md: |
Dashboard: https://app.launchdarkly.com/settings/authorization
`LAUNCHDARKLY_API_KEY` — for REST API.
`LAUNCHDARKLY_SDK_KEY` — per-environment, for runtime SDKs.
- id: FLAGSMITH
category: feature_flags
detectors:
imports: ["flagsmith", "flagsmith-nodejs"]
env_vars: ["FLAGSMITH_ENVIRONMENT_KEY", "FLAGSMITH_API_URL", "FLAGSMITH_API_TOKEN"]
deps: ["flagsmith", "flagsmith-nodejs"]
dashboard_url: "https://app.flagsmith.com"
env_example: |
FLAGSMITH_API_URL=https://edge.api.flagsmith.com/api/v1
FLAGSMITH_ENVIRONMENT_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${FLAGSMITH_ENVIRONMENT_KEY:?FLAGSMITH_ENVIRONMENT_KEY not set}"
URL="${FLAGSMITH_API_URL:-https://edge.api.flagsmith.com/api/v1}"
# Fetch flags for the env (anonymous identity).
curl -fsS "${URL%/}/flags/" -H "X-Environment-Key: $FLAGSMITH_ENVIRONMENT_KEY" >/dev/null
echo "OK — Flagsmith environment key valid."
README.md: |
# FLAGSMITH
Open-source feature flagging + remote config. Cloud or self-hosted.
CREDENTIALS.md: |
Dashboard: https://app.flagsmith.com
Environment key per env (dev/staging/prod). Admin tokens for management API.
# ------------------------------------------------------------------
# Chatops & automation
# ------------------------------------------------------------------
- id: SLACK_WEBHOOK
category: chat_webhooks
detectors:
imports: ["@slack/webhook", "@slack/web-api", "slack_sdk"]
env_vars: ["SLACK_WEBHOOK_URL", "SLACK_BOT_TOKEN"]
deps: ["@slack/webhook", "@slack/web-api", "slack-sdk"]
dashboard_url: "https://api.slack.com/apps"
env_example: |
SLACK_WEBHOOK_URL=
SLACK_BOT_TOKEN=
files:
test_connection.sh: |
#!/usr/bin/env bash
# Posts a test message — visible in the target channel.
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${SLACK_WEBHOOK_URL:?SLACK_WEBHOOK_URL not set}"
curl -fsS -X POST -H "Content-Type: application/json" \
--data '{"text":"harness smoke-test — ignore."}' \
"$SLACK_WEBHOOK_URL" | grep -q ok
echo "OK — Slack webhook posted a test message."
README.md: |
# SLACK_WEBHOOK
Incoming webhooks + bot token for richer flows (chat.postMessage).
> The smoke-test posts a visible message to the target channel.
CREDENTIALS.md: |
Dashboard: https://api.slack.com/apps
Incoming webhook URL is per-channel. Bot tokens (xoxb-…) for Web API.
- id: DISCORD_WEBHOOK
category: chat_webhooks
detectors:
imports: ["discord.js", "from discord", "import discord"]
env_vars: ["DISCORD_WEBHOOK_URL", "DISCORD_BOT_TOKEN"]
deps: ["discord.js", "discord.py"]
dashboard_url: "https://discord.com/developers/applications"
env_example: |
DISCORD_WEBHOOK_URL=
files:
test_connection.sh: |
#!/usr/bin/env bash
# GET on the webhook URL returns its metadata without sending a message.
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${DISCORD_WEBHOOK_URL:?DISCORD_WEBHOOK_URL not set}"
NAME=$(curl -fsS "$DISCORD_WEBHOOK_URL" | python3 -c 'import json,sys; print(json.load(sys.stdin).get("name","?"))')
echo "OK — Discord webhook: $NAME."
README.md: |
# DISCORD_WEBHOOK
Incoming webhook for posting messages to a channel.
CREDENTIALS.md: |
Dashboard: https://discord.com/developers/applications
Webhook URL contains an embedded token — treat as secret.
- id: TELEGRAM_BOT
category: chat_webhooks
detectors:
imports: ["python-telegram-bot", "telegraf", "node-telegram-bot-api"]
env_vars: ["TELEGRAM_BOT_TOKEN", "TELEGRAM_CHAT_ID"]
deps: ["python-telegram-bot", "telegraf", "node-telegram-bot-api"]
dashboard_url: "https://t.me/BotFather"
env_example: |
TELEGRAM_BOT_TOKEN=
TELEGRAM_CHAT_ID=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${TELEGRAM_BOT_TOKEN:?TELEGRAM_BOT_TOKEN not set}"
NAME=$(curl -fsS "https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/getMe" | python3 -c 'import json,sys; print(json.load(sys.stdin)["result"]["username"])')
echo "OK — Telegram bot: @$NAME."
README.md: |
# TELEGRAM_BOT
Create a bot with @BotFather, then drive it via the Bot API.
CREDENTIALS.md: |
Dashboard: https://t.me/BotFather (chat with @BotFather to create/manage bots)
`TELEGRAM_BOT_TOKEN` — secret. Chat ID is the user/group to message.
- id: N8N
category: automatizacion
detectors:
imports: []
env_vars: ["N8N_API_KEY", "N8N_HOST"]
deps: []
dashboard_url: "https://app.n8n.cloud/settings/api"
env_example: |
N8N_HOST=
N8N_API_KEY=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${N8N_HOST:?N8N_HOST not set}"
: "${N8N_API_KEY:?N8N_API_KEY not set}"
N=$(curl -fsS "${N8N_HOST%/}/api/v1/workflows?limit=1" -H "X-N8N-API-KEY: $N8N_API_KEY" | python3 -c 'import json,sys; print(len(json.load(sys.stdin)["data"]))')
echo "OK — n8n workflows endpoint accessible (sample: $N)."
README.md: |
# N8N
Open-source workflow automation. Self-hosted or n8n Cloud.
CREDENTIALS.md: |
Dashboard: https://app.n8n.cloud/settings/api (or self-hosted equivalent).
`N8N_API_KEY` — secret. Required for all REST API calls.
API surface: workflows CRUD + `/activate` `/deactivate` + `/workflows/{id}/execute`
(recent; no custom input — use a Webhook trigger for runtime params). See the `n8n` skill.
- id: MAKE
category: automatizacion
detectors:
imports: []
env_vars: ["MAKE_API_TOKEN", "MAKE_ZONE"]
deps: []
dashboard_url: "https://www.make.com/en/help/tools/api"
env_example: |
MAKE_ZONE=eu1.make.com # your zone: eu1/eu2/us1/us2 (wrong zone => auth error)
MAKE_API_TOKEN= # Profile > API/token; scopes are fixed at creation
MAKE_TEAM_ID=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${MAKE_ZONE:?MAKE_ZONE not set (e.g. eu1.make.com)}"
: "${MAKE_API_TOKEN:?MAKE_API_TOKEN not set}"
# envelope-agnostic smoke test: -f fails on 4xx/5xx (wrong zone/token); no response-shape parsing
curl -fsS "https://${MAKE_ZONE%/}/api/v2/users/me" -H "Authorization: Token $MAKE_API_TOKEN" > /dev/null
echo "OK — Make API reachable on $MAKE_ZONE (token accepted)."
README.md: |
# MAKE
Make.com (formerly Integromat). Scenarios via /api/v2; blueprint is a stringified JSON
round-trip. Base URL is zone-scoped. See the `make` skill for dynamic create/manage.
CREDENTIALS.md: |
Dashboard: Profile > API (https://www.make.com/en/help/tools/api).
`MAKE_API_TOKEN` — secret; token scopes are immutable after creation. Wrong `MAKE_ZONE`
returns an auth error even with a valid token. Endpoints are case-sensitive.
- id: ZAPIER
category: automatizacion
detectors:
imports: []
env_vars: ["ZAPIER_MCP_URL", "ZAPIER_MCP_API_KEY"]
deps: []
dashboard_url: "https://mcp.zapier.com"
env_example: |
ZAPIER_MCP_URL=https://mcp.zapier.com/api/v1/connect
ZAPIER_MCP_API_KEY= # Bearer key from the Zapier MCP dashboard (2 tasks per call)
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${ZAPIER_MCP_URL:?ZAPIER_MCP_URL not set}"
: "${ZAPIER_MCP_API_KEY:?ZAPIER_MCP_API_KEY not set}"
# Zapier exposes no account-CRUD REST API; smoke-test the MCP endpoint with an initialize handshake.
CODE=$(curl -s -o /dev/null -w '%{http_code}' -X POST "$ZAPIER_MCP_URL" \
-H "Authorization: Bearer $ZAPIER_MCP_API_KEY" -H "Content-Type: application/json" \
-H "Accept: application/json, text/event-stream" \
-d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"rsc","version":"1"}}}')
case "$CODE" in 2*) echo "OK — Zapier MCP endpoint reachable (HTTP $CODE).";; *) echo "FAIL — HTTP $CODE" >&2; exit 1;; esac
README.md: |
# ZAPIER
Zapier has NO public API for a normal user to create/manage their own Zaps. Programmatic
use = Zapier MCP (runs pre-configured actions across 9,000+ apps; does not author Zaps).
See the `zapier` skill for the honest boundary and when to use n8n/Make instead.
CREDENTIALS.md: |
Dashboard: https://mcp.zapier.com — generate an MCP server + Bearer key.
`ZAPIER_MCP_API_KEY` — secret (Bearer). Each successful tool call costs 2 Zapier tasks.
- id: POWER_AUTOMATE
category: automatizacion
detectors:
imports: []
env_vars: ["PA_DATAVERSE_URL", "PA_TENANT_ID", "PA_CLIENT_ID", "PA_CLIENT_SECRET"]
deps: []
dashboard_url: "https://make.powerautomate.com"
env_example: |
PA_DATAVERSE_URL=https://<org>.crm.dynamics.com # your Dataverse org URL (region domain varies)
PA_TENANT_ID= # Entra tenant id
PA_CLIENT_ID= # Entra app registration (needs a Dataverse application user)
PA_CLIENT_SECRET=
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${PA_DATAVERSE_URL:?PA_DATAVERSE_URL not set}"
: "${PA_TENANT_ID:?PA_TENANT_ID not set}"; : "${PA_CLIENT_ID:?PA_CLIENT_ID not set}"; : "${PA_CLIENT_SECRET:?PA_CLIENT_SECRET not set}"
TOKEN=$(curl -fsS "https://login.microsoftonline.com/${PA_TENANT_ID}/oauth2/v2.0/token" \
-d "grant_type=client_credentials&client_id=${PA_CLIENT_ID}&client_secret=${PA_CLIENT_SECRET}&scope=${PA_DATAVERSE_URL%/}/.default" \
| python3 -c 'import json,sys; print(json.load(sys.stdin)["access_token"])')
N=$(curl -fsS "${PA_DATAVERSE_URL%/}/api/data/v9.2/workflows?\$filter=category%20eq%205&\$top=1" \
-H "Authorization: Bearer $TOKEN" -H "Accept: application/json" | python3 -c 'import json,sys; print(len(json.load(sys.stdin)["value"]))')
echo "OK — Dataverse reachable; cloud-flow query returned $N row(s)."
README.md: |
# POWER_AUTOMATE
Microsoft Power Automate cloud flows via the Dataverse Web API (solution-aware flows only;
`api.flow.microsoft.com` is unsupported). Auth is Entra OAuth. See the `power-automate` skill.
CREDENTIALS.md: |
Register an Entra app; add it as a Dataverse application user with a security role granting
Process (workflow) privileges. `PA_CLIENT_SECRET` — secret. Only flows inside a Dataverse
solution are code-manageable; personal "My Flows" are not.
- id: WANDB
category: ia_training
detectors:
imports: ["import wandb", "from wandb", "@wandb/sdk"]
env_vars: ["WANDB_API_KEY", "WANDB_ENTITY", "WANDB_PROJECT"]
deps: ["wandb"]
dashboard_url: "https://wandb.ai/authorize"
env_example: |
# Weights & Biases — experiment tracking for training runs. Key: https://wandb.ai/authorize
WANDB_API_KEY=
# WANDB_ENTITY= # team or username (optional default)
# WANDB_PROJECT= # default project (optional)
files:
test_connection.sh: |
#!/usr/bin/env bash
set -euo pipefail
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
set -a; source "$SCRIPT_DIR/.env"; set +a
: "${WANDB_API_KEY:?WANDB_API_KEY not set}"
# GraphQL viewer whoami; W&B authenticates the API key via HTTP basic (key in the password field).
# If the GraphQL shape/auth changes, the portable fallback is: pip install wandb && wandb login --verify
USER=$(curl -fsS "https://api.wandb.ai/graphql" -u "api:$WANDB_API_KEY" \
-H "Content-Type: application/json" \
-d '{"query":"query { viewer { username } }"}' \
| python3 -c 'import json,sys; print(json.load(sys.stdin)["data"]["viewer"]["username"])')
echo "OK — W&B authed as $USER."
README.md: |
# WANDB
Weights & Biases — experiment tracking / MLOps for training runs (loss curves, sweeps,
artifacts). Used by the `finetuning`, `deep-learning`, and `machine-learning` skills.
CREDENTIALS.md: |
Dashboard: https://wandb.ai/authorize (copy your API key).
`WANDB_API_KEY` — secret. Verify with `wandb login --verify` if the GraphQL check is flaky.
# Categories used to group tools in 01-TOOLS/README.md.
categories:
infra: "Infra & deploy"
datos: "Databases & BaaS"
almacenamiento: "Object storage"
pagos: "Payments & billing"
email: "Email (transactional)"
pagos_email: "Email (transactional, legacy bucket)"
mobile_auth: "Mobile / auth"
auth: "Auth & identity"
ia: "AI / generation (legacy bucket)"
ia_texto: "AI / LLMs"
ia_media: "AI / audio, image, video"
busqueda: "Search & vector databases"
observabilidad: "Observability"
analitica: "Product analytics"
comunicacion: "Communications (SMS, push, voice)"
realtime: "Realtime & video"
mapas_geo: "Maps & geolocation"
productividad: "Productivity / PM / CRM"
feature_flags: "Feature flags"
chat_webhooks: "Chatops webhooks"
automatizacion: "Automation"
ia_training: "AI / training & MLOps"
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| rea-analysis-optimizationmorluto/reaOptimize REA providers and shared analysis workflows for agent context, latency, CPU, and memory while preserving correctness and Evidence. Use for analysis bottlenecks and cache or query design; CI/test-suite optimization belongs to rea-ci-tests-audit. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| rea-ci-tests-auditmorluto/reaAudit REA CI and test suites for correctness, fixture drift, false passes, and measured performance; use for suite or workflow investigations and efficiency changes, rather than ordinary feature testing or a single test failure. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| rea-tool-designmorluto/reaAudit, investigate, design, or change REA investigation tools, CLI/MCP contracts, provider capabilities, and Evidence semantics. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-auditDietrichGebert/ponytailQuality audit of the whole repo: bugs, security, real load, missing tests, speed, and what to delete. Most important first. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |