Flujo de Autorización de Dispositivos

import { AurisClient } from '@auris/js'
 
const auris = new AurisClient({
  domain: 'auth.tudominio.com',
  clientId: 'tu-client-id-de-app-dispositivo',
})
 
// Paso 1: Solicitar un código de dispositivo
const deviceAuth = await fetch('https://auth.tudominio.com/api/oauth/device/code', {
  method: 'POST',
  headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
  body: new URLSearchParams({
    client_id: 'tu-client-id-de-app-dispositivo',
    scope: 'openid profile email',
  }),
}).then(r => r.json())
 
// Paso 2: Mostrar al usuario
console.log(`Ve a: ${deviceAuth.verification_uri}`)
console.log(`Introduce el código: ${deviceAuth.user_code}`)
 
// Paso 3: Sondear para obtener el token
const token = await sondearToken(deviceAuth)
 
async function sondearToken(deviceAuth) {
  const interval = deviceAuth.interval * 1000 // convertir a ms
  const expiresAt = Date.now() + deviceAuth.expires_in * 1000
 
  while (Date.now() < expiresAt) {
    await new Promise(resolve => setTimeout(resolve, interval))
 
    const response = await fetch('https://auth.tudominio.com/api/auth/token', {
      method: 'POST',
      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
      body: new URLSearchParams({
        grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
        device_code: deviceAuth.device_code,
        client_id: 'tu-client-id-de-app-dispositivo',
      }),
    })
 
    if (response.ok) {
      return await response.json()
    }
 
    const error = await response.json()
 
    if (error.error === 'authorization_pending') {
      continue // el usuario aún no ha aprobado
    }
    if (error.error === 'slow_down') {
      await new Promise(resolve => setTimeout(resolve, 5000)) // esperar más
      continue
    }
    if (error.error === 'expired_token') {
      throw new Error('El código del dispositivo ha expirado. Por favor reinicia el flujo.')
    }
    if (error.error === 'access_denied') {
      throw new Error('El usuario rechazó la solicitud de autorización.')
    }
 
    throw new Error(`Error inesperado: ${error.error}`)
  }
 
  throw new Error('El código del dispositivo ha expirado.')
}

# Paso 1: Solicitar un código de dispositivo
curl -X POST https://auth.tudominio.com/api/oauth/device/code \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "client_id=tu-client-id-de-app-dispositivo" \
  -d "scope=openid profile email"
 
# Respuesta:
# {
#   "device_code": "GmRhmhcxhwAzkoEqiMEg_DnyEysNkuNhszIySk9eS",
#   "user_code": "WDJB-MJHT",
#   "verification_uri": "https://auth.tudominio.com/hosted/device",
#   "verification_uri_complete": "https://auth.tudominio.com/hosted/device?user_code=WDJB-MJHT",
#   "expires_in": 600,
#   "interval": 5
# }
 
# Paso 2: El usuario visita verification_uri e introduce el user_code
 
# Paso 3: Sondear para el token (repetir cada `interval` segundos)
curl -X POST https://auth.tudominio.com/api/auth/token \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "grant_type=urn:ietf:params:oauth:grant-type:device_code" \
  -d "device_code=GmRhmhcxhwAzkoEqiMEg_DnyEysNkuNhszIySk9eS" \
  -d "client_id=tu-client-id-de-app-dispositivo"
 
# Respuesta pendiente (HTTP 400):
# { "error": "authorization_pending" }
 
# Respuesta de éxito (HTTP 200):
# {
#   "access_token": "eyJhbGciOiJSUzI1NiJ9...",
#   "token_type": "Bearer",
#   "expires_in": 3600,
#   "refresh_token": "dGhpcyBpcyBhIHJlZnJlc2g...",
#   "scope": "openid profile email"
# }

#!/usr/bin/env node
// Ejemplo: flujo de inicio de sesión en herramienta CLI con autorización de dispositivo
 
import open from 'open'
import readline from 'readline'
 
const AURIS_DOMAIN = 'https://auth.tudominio.com'
const CLIENT_ID = 'tu-client-id-cli'
 
async function iniciarSesion() {
  // Solicitar código de dispositivo
  const respuestaCodigo = await fetch(`${AURIS_DOMAIN}/api/oauth/device/code`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
    body: new URLSearchParams({ client_id: CLIENT_ID, scope: 'openid profile' }),
  }).then(r => r.json())
 
  console.log('\n  Tu código de autorización es:\n')
  console.log(`    ${respuestaCodigo.user_code}\n`)
  console.log(`  Visita: ${respuestaCodigo.verification_uri}\n`)
 
  // Intentar abrir el navegador automáticamente
  const uriCompleto = respuestaCodigo.verification_uri_complete
  if (uriCompleto) {
    console.log('  Abriendo navegador...')
    await open(uriCompleto)
  }
 
  // Sondear para el token
  console.log('  Esperando autorización...\n')
 
  let interval = respuestaCodigo.interval * 1000
  const deadline = Date.now() + respuestaCodigo.expires_in * 1000
 
  while (Date.now() < deadline) {
    await new Promise(r => setTimeout(r, interval))
 
    const res = await fetch(`${AURIS_DOMAIN}/api/auth/token`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
      body: new URLSearchParams({
        grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
        device_code: respuestaCodigo.device_code,
        client_id: CLIENT_ID,
      }),
    })
 
    if (res.ok) {
      const token = await res.json()
      console.log('  ¡Autenticado con éxito!')
      return token
    }
 
    const err = await res.json()
    if (err.error === 'slow_down') {
      interval += 5000
    } else if (err.error !== 'authorization_pending') {
      throw new Error(`Autorización fallida: ${err.error}`)
    }
  }
 
  throw new Error('La autorización expiró.')
}
 
iniciarSesion()
  .then(token => console.log('Token:', token.access_token.slice(0, 20) + '...'))
  .catch(err => console.error(err.message))