Concepts clés

Comprenez les briques de base de Rawtoh — événements, déclencheurs, actions et processus.

Rawtoh repose sur quelques idées simples. Les comprendre vous aidera à construire des automatisations puissantes.

La boucle d’automatisation

Dans Rawtoh, chaque automatisation suit le même parcours :

Module→ émet →Événement→ correspond à →Déclencheur→ exécute →Action

Il en résulte un processus — une trace complète de ce qui s’est passé, de ce qui a été exécuté et du résultat, réussite ou échec.

Événement

Un événement est quelque chose qui s’est produit. Il est émis par un module et représente une donnée — un message dans le chat Twitch, un changement de morceau sur Spotify, un changement de scène OBS, ou tout ce que votre module personnalisé envoie.

Que contient un événement ?

Champ	Description
`name`	Le type d’événement, par ex. `chat.message`
`payload`	Des données JSON arbitraires — le contenu de l’événement
`emitter_group`	Le type de module qui l’a émis (par ex. `twitch`)
`emitter_name`	L’instance précise qui l’a émis (par ex. `main-bot`)

Les événements sont conservés et consultables dans le panneau Activité. Vous pouvez mettre des événements en favoris pour éviter qu’ils ne soient supprimés lors du nettoyage.

Déclencheur

Un déclencheur est une règle qui surveille des événements précis et décide s’il faut exécuter une action. Il relie un motif d’événement à un morceau de code.

Quand un déclencheur correspond

Un déclencheur se déclenche lorsque toutes ces conditions sont réunies :

Le champ emitter_group de l’événement correspond au groupe de modules du déclencheur
Le champ name de l’événement correspond au nom d’événement du déclencheur
La condition TypeScript du déclencheur s’évalue à une valeur vraie (truthy)
La temporisation est écoulée (si elle est configurée)
Le déclencheur et son action sont tous deux activés

Code du déclencheur

Le program du déclencheur est un module TypeScript qui importe l’événement depuis "rawtoh" et utilise export default pour décider si l’action doit s’exécuter :

import { event } from "rawtoh"

// Only fire for messages starting with "!"
export default event.payload.message.startsWith("!")

Temporisation

Les déclencheurs prennent en charge une temporisation, avec deux modes :

Limitation (throttle) — se déclenche immédiatement, puis ignore les événements pendant la durée définie
Anti-rebond (debounce) — attend que la durée s’écoule sans nouvel événement avant de se déclencher. Chaque nouvel événement relance le minuteur.

Action

Une action est le code qui s’exécute lorsqu’un déclencheur se déclenche. Les actions sont des programmes TypeScript qui peuvent :

Lire le payload de l’événement qui les a déclenchées
Appeler des méthodes sur les modules connectés via module()
Lire, écrire et mettre à jour de façon atomique des données persistantes via storage
Journaliser des messages avec log()
Mettre l’exécution en pause avec await sleep(ms)

Tout cela s’importe depuis le module "rawtoh".

Exemple de code d’action

import { event, log, module } from "rawtoh"

// Respond to a chat command
const user = event.payload.username

// Call the Twitch module to send a message
await module("twitch").request("chat.say", {
  message: `Hello @${user}, welcome!`
})

// Log for debugging
log("Greeted", user)

Organisation

Les actions sont organisées par chemin, comme dans un système de fichiers. Par exemple : /twitch/chat/greet ou /obs/scene-switch. Vous pouvez ainsi regrouper dans des dossiers les automatisations qui vont ensemble.

Script partagé

Un script partagé est un morceau de code réutilisable, que n’importe quel déclencheur ou n’importe quelle action peut importer. Il vous évite de dupliquer la même logique d’une automatisation à l’autre.

Les scripts partagés utilisent la syntaxe TypeScript standard export / import et sont organisés par chemin, tout comme les actions.

Exemple

// /utils/format (shared script)
export function greet(name) {
  return `Hello, ${name}!`
}

Importez-le ensuite dans n’importe quelle action ou n’importe quel déclencheur :

import { module } from "rawtoh"
import { greet } from "/utils/format"

await module("twitch").request("chat.say", {
  message: greet(event.payload.username)
})

Les scripts partagés peuvent importer depuis "rawtoh" et depuis d’autres scripts partagés. Ils acceptent aussi bien les chemins absolus (/utils/format) que les chemins relatifs (./format). Attention : les scripts partagés importés par des déclencheurs ne doivent pas utiliser les API réservées aux actions (log, module, storage, sleep).

Automatisation

Une automatisation est un prompt accompagné des déclencheurs et des actions que l’IA de Rawtoh a générés à partir de celui-ci. C’est une façon de créer des scripts, pas un autre type de script : ce qu’elle produit s’exécute, se journalise et se modifie exactement comme les scripts que vous écrivez vous-même.

Dans l’éditeur de scripts, une automatisation se trouve à la racine de l’Explorateur et s’ouvre comme un dossier contenant ses scripts générés. Modifier le prompt puis régénérer les réécrit sur place ; supprimer l’automatisation les supprime. Consultez la page IA pour les détails.

Processus

Un processus est la trace d’une exécution. Chaque fois qu’un événement correspond à un déclencheur et exécute une action, un processus est créé pour en suivre le résultat.

Un processus contient :

L’événement qui l’a déclenché
Le déclencheur qui a correspondu
Ses heures de début et de fin
S’il a réussi ou échoué (avec le détail de l’erreur)
Les journaux du processus — la sortie des appels à log() dans le code de votre action
Les journaux d’appels aux modules — chaque appel RPC que votre action a adressé à un module, avec ses paramètres et sa durée

Vous pouvez passer en revue tous les processus dans le panneau Activité de l’éditeur de scripts, pour déboguer et surveiller vos automatisations.