Simple Auth

La classe SimpleAuth fournit une authentification par token reposant sur une association simple entre tokens et utilisateurs. Elle est incluse dans @mastra/core/server et convient au développement, aux tests et aux scénarios d’authentification simples par clé API.

Cas d’utilisation

• Développement local et tests
• Authentification simple par clé API
• Prototypage avant l’intégration d’un fournisseur d’identité complet
• Services internes utilisant des tokens statiques

Installation

SimpleAuth est inclus dans @mastra/core et ne nécessite aucun package supplémentaire.

import { SimpleAuth } from '@mastra/core/server'

Exemple d’utilisation

src/mastra/index.ts

import { Mastra } from '@mastra/core'
import { SimpleAuth } from '@mastra/core/server'

// Define your user type
type User = {
  id: string
  name: string
  role: 'admin' | 'user'
}

export const mastra = new Mastra({
  server: {
    auth: new SimpleAuth<User>({
      tokens: {
        'sk-admin-token-123': {
          id: 'user-1',
          name: 'Admin User',
          role: 'admin',
        },
        'sk-user-token-456': {
          id: 'user-2',
          name: 'Regular User',
          role: 'user',
        },
      },
    }),
  },
})

Options de configuration

Option	Type	Requise	Description
tokens	Record<string, TUser>	Oui	Association des tokens aux objets utilisateur
headers	string | string[]	Non	En-têtes supplémentaires dans lesquels rechercher des tokens
name	string	Non	Nom du Provider utilisé dans les journaux
authorizeUser	(user, request) => boolean	Non	Fonction d’autorisation personnalisée
protected	(RegExp | string)[]	Non	Chemins qui nécessitent une authentification
public	(RegExp | string)[]	Non	Chemins qui contournent l’authentification

En-têtes par défaut

SimpleAuth vérifie par défaut les en-têtes suivants :

• Authorization (avec ou sans le préfixe Bearer)
• X-Playground-Access

Ajoutez des en-têtes personnalisés avec l’option headers :

new SimpleAuth({
  tokens: {/* ... */},
  headers: ['X-API-Key', 'X-Custom-Auth'],
})

Effectuer des requêtes authentifiées

Incluez votre token dans l’en-tête Authorization :

curl -X POST http://localhost:4111/api/agents/myAgent/generate \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer sk-admin-token-123" \
  -d '{"messages": "Hello"}'

Ou sans le préfixe Bearer :

curl -X POST http://localhost:4111/api/agents/myAgent/generate \
  -H "Content-Type: application/json" \
  -H "Authorization: sk-admin-token-123" \
  -d '{"messages": "Hello"}'

Autorisation personnalisée

Ajoutez une logique d’autorisation personnalisée ou fondée sur les rôles :

new SimpleAuth<User>({
  tokens: {
    'sk-admin-token': { id: '1', name: 'Admin', role: 'admin' },
    'sk-user-token': { id: '2', name: 'User', role: 'user' },
  },
  authorizeUser: (user, request) => {
    // Only admins can access /admin routes
    if (request.url.includes('/admin')) {
      return user.role === 'admin'
    }
    return true
  },
})

Variables d’environnement

Pour les configurations proches de la production, chargez les tokens depuis des variables d’environnement :

const tokens: Record<string, User> = {}

// Load from environment
const adminToken = process.env.ADMIN_API_KEY
if (adminToken) {
  tokens[adminToken] = { id: 'admin', name: 'Admin', role: 'admin' }
}

const userToken = process.env.USER_API_KEY
if (userToken) {
  tokens[userToken] = { id: 'user', name: 'User', role: 'user' }
}

export const mastra = new Mastra({
  server: {
    auth: new SimpleAuth({ tokens }),
  },
})

With MastraClient

Configurez le client avec votre token :

import { MastraClient } from '@mastra/client-js'

const client = new MastraClient({
  baseUrl: 'http://localhost:4111',
  headers: {
    Authorization: 'Bearer sk-admin-token-123',
  },
})

const agent = client.getAgent('myAgent')
const response = await agent.generate('Hello')

Limites

SimpleAuth privilégie la simplicité et non la sécurité en production :

• Les tokens sont stockés en mémoire
• Aucun mécanisme d’expiration ou de renouvellement des tokens
• Aucune vérification cryptographique
• Tous les tokens doivent être connus au démarrage

Pour les applications en production, envisagez d’utiliser JWT, Clerk, Auth0 ou un autre fournisseur d’identité.