---
title: "Comandi slash: aggiungi /comandi alla tua community mssgs"
description: "Comandi slash per la tua community mssgs: mssgs invia il messaggio al tuo servizio web e pubblica la tua risposta JSON come card. Richiesta, risposta e limiti."
canonical: https://mss.gs/it/docs/commands
language: it
---

# Aggiungi comandi slash

Dai alla tua community i suoi /comandi . Quando un membro ne scrive uno, mssgs invia il messaggio al tuo servizio web e pubblica ciò che risponde: una card, dei pulsanti, una risposta che vede solo chi ha chiesto.

## Cosa puoi fare

- **Rispondi con una card** Rispondi con del JSON e compare nel canale come card.

- **Sai chi ha chiesto** Ricevi il membro e i suoi ruoli, così puoi verificare chi può fare cosa.

- **Rispondi in privato** Mostra la risposta solo al membro che l’ha chiesta.

- **Prenditi il tuo tempo** Rispondi con un loader entro 5 secondi, poi finisci tramite la callback URL.

Nell'app

Scrivi / e compaiono i comandi della community

#### Amsterdam

Il tuo servizio risponde, mssgs pubblica la card

Il selettore e la card sono quelli dell’app. Il piè di pagina dice chi ha usato quale comando.

- [Per iniziare](#quick-start)

- [Impostazioni](#settings)

- [Cosa ricevi](#request)

- [Cosa rispondi](#reply)

- [Cinque secondi](#timing)

- [Risposte private](#private)

- [Un esempio completo](#example)

- [Limiti](#limits)

## Per iniziare

- 1 Crea il trigger Nell’app desktop apri **Gestisci il server → Trigger** della tua community e aggiungine uno: il comando a cui reagisce, come /weather , e l’URL del tuo servizio web.

### Ricevi il messaggio

Quando un membro invia un messaggio che inizia con /weather , mssgs lo invia in POST al tuo 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=..."
}
```

### Rispondi con JSON

Rispondi entro 5 secondi con uno status 2xx e del JSON. Diventa una card nel canale.

```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

## Impostazioni

Ogni trigger ha queste impostazioni in **Gestisci il server → Trigger**.

| Impostazione | Cosa fa |
| --- | --- |
| Nome del trigger | Come si chiama il trigger, mostrato accanto al comando nel selettore. |
| Parola da riconoscere | Il testo con cui deve iniziare un messaggio, come /weather . La barra è consueta, non obbligatoria. |
| Endpoint URL | Dove mssgs invia il messaggio. |
| Segreto del webhook | Facoltativo. mssgs firma ogni richiesta con il segreto, vedi sotto. |
| Attivo | Spegni il trigger senza eliminarlo. |
| Pubblica il messaggio corrispondente | Se il /weather Amsterdam scritto dal membro resta nel canale sopra la tua risposta. |
| Mostra una risposta di attesa | Mostra una card di caricamento mentre il tuo servizio lavora. |
| Gruppi utenti ammessi | Lo attivano solo i membri con questi ruoli. Per tutti gli altri è un messaggio normale. |

## Cosa ricevi

Un POST con un body JSON. Tra gli header c’è User-Agent: mssgs-webhook/1.0 .

| Campo | Tipo | Cos’è |
| --- | --- | --- |
| server_guid | string | La community. |
| channel_guid | string | Il canale in cui è stato inviato il messaggio. |
| trigger_match | string | Il comando riconosciuto, come /weather . |
| message.content | string | L’intero messaggio, comando compreso. |
| message.member_guid | string | Il membro che l’ha inviato, in questa community. |
| message.user_guid | string | L’account della stessa persona, uguale in ogni community. |
| message.group_guids | array | I ruoli del membro. |
| message.cms | number | Quando è stato inviato, in millisecondi. |
| message.is_action_button | boolean | true quando il trigger è stato attivato da un pulsante e non da un comando scritto. |
| message.action_payload | object | Il payload del pulsante, per le pressioni dei pulsanti. |
| callback_url | string | Aggiorna o elimina la tua risposta in seguito, per 30 minuti. |
| stream_url | string | Uno stream live di risposte, reazioni e pressioni dei pulsanti sulla tua risposta, per 10 minuti. |

### Verificare chi può fare cosa

Confronta message.group_guids con i ruoli di cui ti fidi, per esempio per far eseguire /ban solo ai moderatori. Per tenere un comando del tutto lontano da tutti gli altri, imposta i suoi ruoli nelle impostazioni del trigger.

## Cosa rispondi

Qualsiasi status 2xx con un body JSON, fino a 4 MB. Invia almeno uno tra message_container e actions .

| Campo | Tipo | Cos’è |
| --- | --- | --- |
| message_container | object | La card. Qui funziona ogni campo delle card dei messaggi, compresi la pillola di stato, il badge, le statistiche diff e il ragionamento ripiegato. |
| title , description , color , ... | string | Forma breve: i campi della card al primo livello vengono racchiusi in una card per te. |
| actions | array | Pulsanti sotto la card. Vedi pulsanti. |
| visible_to_member_guids | array | Solo questi membri vedono la risposta. Vedi risposte private. |

## Cinque secondi

mssgs aspetta la tua risposta per 5 secondi. Se ti serve più tempo, rispondi subito con una card di caricamento e finisci tramite callback_url , che resta valida per 30 minuti.

```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 } })
});
```

## Risposte private

Metti gli id dei membri in visible_to_member_guids e solo loro vedono la tua risposta. Usa il member_guid della richiesta per rispondere solo alla persona che ha chiesto.

```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 esempio completo

Un comando /weather in Node.js con Express, che risponde con una card.

```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);
```

## Limiti

| Limite | Valore |
| --- | --- |
| Tempo per rispondere | 5 secondi |
| Dimensione della risposta | 4 MB |
| Comandi per membro | 5 ogni 5 secondi |
| Aggiornare la risposta in seguito | 30 minuti, tramite callback_url |
| Stream live della risposta | 10 minuti, tramite stream_url |

## Continua a costruire