API del backend y firma

# 1) Alta del dominio: el backend envía un OTP de 6 dígitos (válido 15 min) al correo
curl -sS -X POST "$BACKEND/api/auth/register-domain" \
  -H 'content-type: application/json' \
  -d '{"email":"admin@mi-empresa.com","domain":"mail.mi-empresa.com","password":"<contraseña>","resendApiKey":"<tu-clave-de-resend>"}'
# => {"success":true,"message":"OTP sent to email"}

# 2) Verificar y, opcionalmente, registrar la clave pública Ed25519 de esta instancia
curl -sS -X POST "$BACKEND/api/auth/verify-domain" \
  -H 'content-type: application/json' \
  -d '{"email":"admin@mi-empresa.com","otp":"123456","signingPublicKey":"<clave-publica-base64url>"}'
# => {"success":true,"manager":{"id":"...","email":"...","role":"OWNER"},"domain":{"id":"...","name":"mail.mi-empresa.com"}}

# Público, sin autenticación
curl -sS "$BACKEND/api/config?domain=mail.mi-empresa.com"
# => {"config":{"id":"...","name":"...","displayName":"...","theme":{...},"logo":"..."},
#     "extensions":[{"id":"core-dlp","name":"...","template":{...},"settings":{}}]}

# Clave pública del backend (solo si tiene BACKEND_SIGNING_PRIVATE_KEY; si no, 404 {"available":false})
curl -sS "$BACKEND/.well-known/bloomx-backend-key.json"
# => {"version":1,"alg":"Ed25519","kid":"...","publicKey":"...","jwk":{"kty":"OKP","crv":"Ed25519","x":"...","kid":"..."}}

# Con la sesión de manager (cookie auth_session) dueño del dominio: registrar o ROTAR la clave pública
curl -sS -X POST "$BACKEND/api/manager/domain-key" \
  -H 'content-type: application/json' -b 'auth_session=<cookie>' \
  -d '{"domainId":"<id>","signingPublicKey":"<clave-publica-base64url>"}'
# => {"success":true,"registered":true,"fingerprint":"<16 hex>"}

// sign-request.mjs  (Node >= 18, solo node:crypto)
import crypto from 'node:crypto';

const BACKEND = process.env.NEXT_PUBLIC_BACKEND_URL;            // https://backend.example.com
const DOMAIN = 'mail.mi-empresa.com';                            // el dominio (tenant) registrado
const PRIVATE_KEY = crypto.createPrivateKey(
    (process.env.BLOOMX_DOMAIN_PRIVATE_KEY ?? '').replace(/\\n/g, '\n'), // PEM PKCS8 en una linea
);

export async function signedFetch(path, { method = 'POST', body, userId = '', userEmail = '', callback = '' } = {}) {
    const raw = body === undefined ? '' : JSON.stringify(body);   // los MISMOS bytes que se envian
    const url = new URL(path, BACKEND);
    const timestamp = String(Math.floor(Date.now() / 1000));
    const nonce = crypto.randomBytes(18).toString('base64url');   // 24 caracteres: cumple ^[A-Za-z0-9_-]{16,64}$

    const canonical = [
        'BLOOMX-SIG-V1',
        method.toUpperCase(),
        url.pathname + url.search,                                 // ruta + query tal como la ve el backend
        crypto.createHash('sha256').update(raw).digest('hex'),     // sha256 del cuerpo crudo (vacio en GET)
        DOMAIN.toLowerCase(),
        timestamp,
        nonce,
        userId,
        userEmail,
        callback,                                                  // https://<tu-dominio> o ''
    ].join('\n');

    const signature = crypto.sign(null, Buffer.from(canonical, 'utf8'), PRIVATE_KEY).toString('base64url');

    return fetch(url, {
        method,
        headers: {
            'content-type': 'application/json',
            'X-BloomX-Domain': DOMAIN,
            'X-BloomX-Signature': signature,
            'X-BloomX-Timestamp': timestamp,
            'X-BloomX-Nonce': nonce,
            'X-User-Id': userId,
            'X-User-Email': userEmail,
            ...(callback ? { 'X-BloomX-Callback': callback } : {}),
        },
        body: raw || undefined,
    });
}

// Ejemplo: ejecutar una acción de una extensión instalada
const res = await signedFetch('/api/extension/execute', {
    userId: 'user_123',
    userEmail: 'ana@mi-empresa.com',
    body: { extensionId: 'core-hello', action: 'hello', params: { name: 'Ana' } },
});
console.log(res.status, await res.json());

// Lo que hace el backend (resumen de src/lib/domain-auth.ts)
// 1. domain = X-BloomX-Domain (obligatorio si el dominio tiene clave)
// 2. |now - timestamp| <= 120 s y nonce ^[A-Za-z0-9_-]{16,64}$
// 3. canonical = mismo string de arriba, con el cuerpo crudo recibido
// 4. crypto.verify(null, canonical, publicKeyDelDominio, base64url(signature))  // firma de 64 bytes
// 5. el nonce (domain:nonce) se consume UNA vez, solo si la firma es valida

ALTER TABLE "Domain" ADD COLUMN IF NOT EXISTS "signingPublicKey" TEXT;