---
title: "Commandes slash : des /commandes pour ta communauté mssgs"
description: "Donne à ta communauté mssgs ses commandes slash : mssgs envoie le message à ton service web et publie ta réponse JSON en carte. Réglages, requête, réponse, limites."
canonical: https://mss.gs/fr/docs/commands
language: fr
---

# Ajouter des commandes slash

Donne à ta communauté ses propres /commandes . Quand un membre en tape une, mssgs envoie le message à ton service web et publie ce qu’il répond : une carte, des boutons, une réponse que seul ce membre voit.

## Ce que vous pouvez faire

- **Répondre avec une carte** Réponds en JSON et ta réponse apparaît dans le salon sous forme de carte.

- **Savoir qui a demandé** Tu reçois le membre et ses rôles, pour vérifier qui a le droit de faire quoi.

- **Répondre en privé** Montre la réponse uniquement au membre qui a demandé.

- **Prendre ton temps** Réponds avec un chargement en 5 secondes, puis termine via l’URL de callback.

Dans l'app

Tape / et les commandes de la communauté apparaissent

#### Amsterdam

Ton service répond, mssgs publie la carte

Le sélecteur et la carte sont ceux de l’application. Le pied de carte indique qui a utilisé quelle commande.

- [Démarrage rapide](#quick-start)

- [Réglages](#settings)

- [Ce que tu reçois](#request)

- [Ce que tu réponds](#reply)

- [Cinq secondes](#timing)

- [Réponses privées](#private)

- [Un exemple complet](#example)

- [Limites](#limits)

## Démarrage rapide

- 1 Crée le déclencheur Dans l’application de bureau, ouvre **Gérer le serveur → Déclencheurs** dans ta communauté et ajoutes-en un : la commande à laquelle il réagit, comme /weather , et l’URL de ton service web.

### Reçois le message

Quand un membre envoie un message qui commence par /weather , mssgs l’envoie en POST à ton URL :

```json
{
  "server_guid": "abc12345-...",
  "channel_guid": "def67890-...",
  "trigger_match": "/weather",
  "message": {
    "id": "d01ZZdef6-...",
    "content": "/weather Amsterdam",
    "member_guid": "member-guid",
    "user_guid": "user-guid",
    "group_guids": ["group-guid-1", "group-guid-2"],
    "cms": 1790000000000
  },
  "callback_url": "https://mss.gs/api/v1/trigger-callback/...",
  "stream_url": "https://mss.gs/api/v1/instant/...?token=..."
}
```

### Réponds en JSON

Réponds en moins de 5 secondes avec un statut 2xx et du JSON. Ta réponse devient une carte dans le salon.

```json
{
  "message_container": {
    "color": "blue",
    "title": "Amsterdam",
    "description": "14 °C, light rain until 16:00",
    "fields": [
      { "field": "Wind", "value": "SW 18 km/h" },
      { "field": "Humidity", "value": "82%" }
    ]
  }
}
```

#### Amsterdam

## Réglages

Chaque déclencheur a ces réglages dans **Gérer le serveur → Déclencheurs**.

| Réglage | Ce qu’il fait |
| --- | --- |
| Nom du déclencheur | Le nom du déclencheur, affiché à côté de la commande dans le sélecteur. |
| Mot à reconnaître | Le texte par lequel un message doit commencer, comme /weather . La barre oblique est l’usage, pas une obligation. |
| Point d’accès URL | L’adresse où mssgs envoie le message. |
| Secret du webhook | Facultatif. mssgs signe chaque requête avec, voir plus bas. |
| Actif | Désactive le déclencheur sans le supprimer. |
| Publier le message reconnu | Indique si le /weather Amsterdam du membre reste dans le salon au-dessus de ta réponse. |
| Afficher une réponse de chargement | Affiche une carte de chargement pendant que ton service travaille. |
| Groupes d’utilisateurs autorisés | Seuls les membres qui ont ces rôles le déclenchent. Pour tous les autres, c’est un message ordinaire. |

## Ce que tu reçois

Un POST avec un corps JSON. Les en-têtes contiennent User-Agent: mssgs-webhook/1.0 .

| Champ | Type | Ce que c’est |
| --- | --- | --- |
| server_guid | string | La communauté. |
| channel_guid | string | Le salon où le message a été envoyé. |
| trigger_match | string | La commande qui a correspondu, comme /weather . |
| message.content | string | Le message entier, commande comprise. |
| message.member_guid | string | Le membre qui l’a envoyé, dans cette communauté. |
| message.user_guid | string | Le compte de cette même personne, identique dans chaque communauté. |
| message.group_guids | array | Les rôles du membre. |
| message.cms | number | Le moment de l’envoi, en millisecondes. |
| message.is_action_button | boolean | true quand c’est un bouton qui a lancé le déclencheur, pas une commande tapée. |
| message.action_payload | object | Le payload du bouton, pour les appuis sur un bouton. |
| callback_url | string | Pour mettre à jour ou supprimer ta réponse plus tard, pendant 30 minutes. |
| stream_url | string | Un flux en direct des réponses, réactions et appuis sur les boutons de ta réponse, pendant 10 minutes. |

### Vérifier qui a le droit de faire quoi

Compare message.group_guids aux rôles en qui tu as confiance, par exemple pour que seuls les modérateurs puissent lancer /ban . Pour tenir une commande complètement à l’écart de tous les autres, définis ses rôles dans les réglages du déclencheur.

## Ce que tu réponds

N’importe quel statut 2xx avec un corps JSON, jusqu’à 4 Mo. Envoie au moins l’un des deux, message_container ou actions .

| Champ | Type | Ce que c’est |
| --- | --- | --- |
| message_container | object | La carte. Chaque champ des cartes de message fonctionne ici, y compris la pastille de statut, le badge, les stats de diff et le raisonnement replié. |
| title , description , color , ... | string | Raccourci : les champs de carte placés au premier niveau sont regroupés dans une carte pour toi. |
| actions | array | Des boutons sous la carte. Voir boutons. |
| visible_to_member_guids | array | Seuls ces membres voient la réponse. Voir réponses privées. |

## Cinq secondes

mssgs attend ta réponse 5 secondes. S’il te faut plus longtemps, réponds tout de suite avec une carte de chargement et termine via callback_url , qui reste valable 30 minutes.

```javascript
// Answer within 5 seconds with a loader...
res.json({ message_container: { loader: true, loader_text: 'Looking it up…' } });

// ...then finish in your own time with the callback URL.
await fetch(req.body.callback_url, {
  method: 'PUT',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ message_container: { color: 'blue', title: 'Done', description: result } })
});
```

## Réponses privées

Mets des ids de membres dans visible_to_member_guids et eux seuls voient ta réponse. Utilise le member_guid de la requête pour ne répondre qu’à la personne qui a demandé.

```json
{
  "message_container": {
    "color": "green",
    "title": "You're on the list",
    "description": "Only you can see this reply."
  },
  "visible_to_member_guids": ["<message.member_guid from the request>"]
}
```

## Un exemple complet

Une commande /weather en Node.js avec Express, qui répond avec une carte.

```javascript
import express from 'express';

const app = express();
app.use(express.json());

app.post('/mssgs/weather', async (req, res) => {
  const city = req.body.message.content.replace('/weather', '').trim() || 'Amsterdam';
  const w = await getWeather(city); // your own lookup

  res.json({
    message_container: {
      color: 'blue',
      title: city,
      description: `${w.temp} °C, ${w.summary}`,
      fields: [
        { field: 'Wind', value: w.wind },
        { field: 'Humidity', value: `${w.humidity}%` }
      ]
    }
  });
});

app.listen(3000);
```

## Limites

| Limite | Valeur |
| --- | --- |
| Délai de réponse | 5 secondes |
| Taille de la réponse | 4 Mo |
| Commandes par membre | 5 toutes les 5 secondes |
| Modifier la réponse ensuite | 30 minutes, via callback_url |
| Flux en direct de la réponse | 10 minutes, via stream_url |

## Continuer