Configuration de Grok Bot dans Cursor

Grok Bot dans Cursor apporte des routines d'automatisation pilotées par l'IA directement dans votre flux de travail de développement. En configurant des routines webhook, des déclencheurs Slack et des workflows d'automatisation, vous pouvez connecter des services externes et laisser le bot gérer les tâches répétitives automatiquement. Ce guide couvre l'ensemble du processus de configuration, de la configuration initiale au dépannage avancé.

Qu'est-ce que Grok Bot ?

Grok Bot est une couche d'automatisation dans Cursor qui utilise des routines basées sur webhook pour répondre aux événements de services externes. Lorsqu'un déclencheur se déclenche, le bot exécute une routine prédéfinie, comme l'analyse de code, la génération de résumés ou l'envoi de notifications.

Les composants principaux d'une configuration Grok Bot sont :

• Routines : Séquences d'actions que le bot effectue lorsqu'il est déclenché
• Déclencheurs : Événements qui démarrent une routine, comme un message Slack ou un appel webhook
• URL Webhook : Adresses de point de terminaison vers lesquelles les services externes envoient des données
• Actions : Étapes individuelles au sein d'une routine, comme des modifications de fichiers, des commandes terminal ou des appels API

astuce

Avant de configurer Grok Bot, assurez-vous que votre installation Cursor est à jour. Les fonctionnalités de routine webhook reçoivent des améliorations fréquentes, et les versions antérieures peuvent ne pas prendre en charge tous les types de déclencheurs décrits dans ce guide.

Configuration initiale

Activation de Grok Bot

Pour activer Grok Bot dans Cursor, accédez aux paramètres d'automatisation :

1. Ouvrez les paramètres Cursor (Ctrl+, ou Cmd+,)
2. Naviguez vers la section Automations dans la barre latérale gauche
3. Basculez Enable Grok Bot pour activer la fonctionnalité
4. Cliquez sur Generate Webhook Secret pour créer une clé secrète pour authentifier les requêtes entrantes

// Exemple de configuration générée stockée dans settings.json
{
  "cursor.grokBot.enabled": true,
  "cursor.grokBot.webhookSecret": "whsec_abc123def456ghi789",
  "cursor.grokBot.defaultModel": "cursor-agent-pro",
  "cursor.grokBot.maxConcurrentRoutines": 3
}

attention

Gardez votre secret webhook privé. Toute personne ayant ce secret peut déclencher des routines sur votre machine. Si le secret est compromis, générez-en un nouveau immédiatement depuis le panneau des paramètres.

Création de votre première routine

Une routine est un ensemble d'instructions que le bot suit lorsqu'il est déclenché. Créez-en une depuis le panneau Automations :

1. Ouvrez le panneau Automations (Ctrl+Shift+A)
2. Cliquez sur New Routine
3. Donnez à la routine un nom descriptif, comme « Slack Code Review Request »
4. Sélectionnez un type de déclencheur (Webhook, Slack, Manuel ou Planifié)
5. Définissez les actions que la routine doit effectuer
6. Enregistrez et activez la routine

# Exemple de configuration de routine
name: "Slack Code Review Request"
description: "When a Slack message mentions @code-review, analyze the referenced file"
trigger:
  type: slack
  condition: "message.contains('@code-review')"
actions:
  - type: parse_message
    extract:
      file_path: "regex:review\\s+(.+)"
      question: "regex:asking\\s+(.+)"
  - type: read_file
    path: "{{file_path}}"
  - type: analyze
    prompt: "Review this code for potential issues, security vulnerabilities, and improvement suggestions."
  - type: slack_reply
    message: "{{analysis_result}}"

Routines Webhook

Les routines webhook permettent aux services externes de déclencher des actions dans Cursor en envoyant des requêtes HTTP POST vers une URL désignée.

Comprendre l'URL Webhook

Lorsque vous créez une routine déclenchée par webhook, Cursor génère une URL webhook unique. Cette URL est l'adresse vers laquelle les services externes envoient leurs charges utiles.

# Exemple de format d'URL webhook
http://localhost:7541/webhooks/routines/rtn_abc123def456

attention

Un problème courant signalé par les utilisateurs est que la configuration de la routine webhook n'affiche aucune URL POST. Cela se produit généralement lorsque la routine n'a pas été entièrement enregistrée ou que le type de déclencheur n'a pas été défini sur « Webhook » avant l'enregistrement. Si vous ne voyez pas d'URL POST, suivez ces étapes :

1. Rouvrez l'éditeur de routine
2. Confirmez que le type de déclencheur est défini sur « Webhook »
3. Cliquez explicitement sur Save (ne fermez pas simplement le panneau)
4. Rouvrez la routine pour vérifier que l'URL est maintenant affichée

Si l'URL n'apparaît toujours pas, redémarrez Cursor et réessayez. Il s'agit d'un problème connu qui a été signalé et dont la correction est suivie.

Enregistrement d'une routine webhook

Voici comment créer une routine déclenchée par webhook étape par étape :

1. Ouvrez le panneau Automations
2. Cliquez sur New Routine
3. Définissez le nom sur « GitHub PR Notification »
4. Définissez le type de déclencheur sur Webhook
5. Enregistrez la routine pour générer l'URL webhook
6. Copiez l'URL POST affichée
7. Configurez votre service externe pour envoyer des requêtes à cette URL

# Exemple : Envoi d'un webhook depuis une GitHub Action
import json
import urllib.request

webhook_url = "http://localhost:7541/webhooks/routines/rtn_abc123def456"
webhook_secret = "whsec_abc123def456ghi789"

payload = {
    "event": "pull_request.opened",
    "repository": "my-org/my-repo",
    "pr_number": 42,
    "pr_title": "Add payment gateway integration",
    "author": "jane-dev",
    "changed_files": ["src/payment/stripe.ts", "src/api/routes.ts"],
}

req = urllib.request.Request(
    webhook_url,
    data=json.dumps(payload).encode("utf-8"),
    headers={
        "Content-Type": "application/json",
        "X-Webhook-Secret": webhook_secret,
    },
    method="POST",
)

try:
    with urllib.request.urlopen(req) as response:
        print(f"Status: {response.status}")
        print(f"Response: {response.read().decode()}")
except urllib.error.URLError as e:
    print(f"Webhook delivery failed: {e}")

Validation des requêtes webhook

Validez toujours les requêtes webhook entrantes pour vous assurer qu'elles proviennent d'une source de confiance. Le secret webhook que vous avez généré lors de la configuration doit être inclus dans l'en-tête X-Webhook-Secret.

// Exemple de logique de validation (Node.js)
const crypto = require("crypto");

function validateWebhook(req, res, next) {
  const secret = req.headers["x-webhook-secret"];
  const expectedSecret = process.env.CURSOR_WEBHOOK_SECRET;

  if (!secret || secret !== expectedSecret) {
    return res.status(401).json({ error: "Invalid webhook secret" });
  }

  // Optionnel : vérifier l'horodatage de la requête pour empêcher les attaques par rejeu
  const timestamp = req.headers["x-webhook-timestamp"];
  const now = Date.now();
  const maxAge = 5 * 60 * 1000; // 5 minutes

  if (timestamp && now - parseInt(timestamp) > maxAge) {
    return res.status(401).json({ error: "Webhook timestamp expired" });
  }

  next();
}

astuce

Pour les configurations de production, utilisez un outil comme ngrok ou Cloudflare Tunnel pour exposer votre point de terminaison webhook local à Internet. Cela permet aux services externes comme GitHub, Slack ou Jira d'atteindre votre instance Cursor locale.

Intégration Slack

Slack est l'une des sources de déclenchement les plus courantes pour les routines Grok Bot. Vous pouvez configurer Slack pour envoyer des messages à Cursor lorsque des événements spécifiques se produisent.

Configuration d'un déclencheur Slack

1. Allez sur la page des applications de l'API Slack
2. Cliquez sur Create New App et choisissez From scratch
3. Nommez l'application « Cursor Grok Bot » et sélectionnez votre espace de travail
4. Sous Event Subscriptions, activez les événements
5. Saisissez votre URL webhook Cursor comme URL de requête
6. Abonnez-vous aux événements bot message.channels et reaction_added
7. Sous OAuth & Permissions, ajoutez les portées chat:write et channels:read
8. Installez l'application dans votre espace de travail et copiez le jeton OAuth Bot User

// Exemple : Gestionnaire de déclencheur Slack dans une routine Grok Bot
const slackTrigger = {
  type: "slack",
  events: ["message.channels"],
  conditions: {
    // Déclencher uniquement lorsque le message mentionne @cursor-bot
    mentions_bot: true,
    // Déclencher uniquement dans des canaux spécifiques
    channels: ["#code-review", "#bug-reports", "#deployments"],
    // Ignorer les messages du bot lui-même
    ignore_bots: true,
  },
};

Envoi de réponses à Slack

Lorsqu'une routine se termine, vous pouvez renvoyer le résultat au canal Slack d'origine :

const { WebClient } = require("@slack/web-api");

const slack = new WebClient(process.env.SLACK_BOT_TOKEN);

async function replyToSlack(channel, text) {
  await slack.chat.postMessage({
    channel: channel,
    text: text,
    // Optionnel : formater en tant que message Slack Block Kit
    blocks: [
      {
        type: "section",
        text: {
          type: "mrkdwn",
          text: text,
        },
      },
      {
        type: "divider",
      },
      {
        type: "context",
        elements: [
          {
            type: "mrkdwn",
            text: ":robot_face: Generated by Cursor Grok Bot",
          },
        ],
      },
    ],
  });
}

attention

Si votre déclencheur Slack ne se déclenche pas, vérifiez les causes courantes suivantes :

1. L'application Slack n'est pas abonnée aux bons types d'événements
2. L'utilisateur bot n'a pas la permission de lire le canal cible
3. L'URL webhook est incorrecte ou inaccessible depuis Internet
4. L'en-tête X-Webhook-Secret ne correspond pas à la valeur attendue
5. Le filtre de condition dans votre routine ne correspond pas au message entrant

Slack ne relance pas les livraisons webhook échouées par défaut. Si votre point de terminaison renvoie une réponse non 200, l'événement est silencieusement abandonné. Vérifiez toujours les journaux de l'API Slack pour les erreurs de livraison.

Configuration des déclencheurs

Grok Bot prend en charge plusieurs types de déclencheurs au-delà des webhooks et Slack. Comprendre chaque type de déclencheur vous aide à choisir le bon pour votre cas d'utilisation.

Types de déclencheurs disponibles

Type de déclencheur	Description	Cas d'utilisation
Webhook	Requête HTTP POST de n'importe quel service externe	Événements GitHub, mises à jour Jira, pipelines CI/CD
Slack	Messages ou réactions Slack	Notifications d'équipe, demandes de revue de code
Schedule	Déclencheur temporel (expression cron)	Vérifications périodiques, résumés nocturnes
File Watch	Déclenché lorsqu'un fichier change sur le disque	Auto-formatage, auto-test à l'enregistrement
Manual	Déclenché par un raccourci clavier ou une commande	Analyse de code à la demande

Exemple de déclencheur planifié

name: "Nightly Dependency Audit"
description: "Check for outdated dependencies every night at 2 AM"
trigger:
  type: schedule
  cron: "0 2 * * *"
actions:
  - type: terminal_command
    command: "npm audit --json"
  - type: analyze
    prompt: "Analyze these npm audit results and summarize the critical vulnerabilities."
  - type: slack_reply
    channel: "#security-alerts"
    message: "{{analysis_result}}"

Exemple de déclencheur de surveillance de fichiers

name: "Auto-Format on Save"
description: "Run formatter whenever a TypeScript file is saved"
trigger:
  type: file_watch
  patterns:
    - "**/*.ts"
    - "**/*.tsx"
  events: ["save"]
actions:
  - type: terminal_command
    command: "npx prettier --write {{file_path}}"
  - type: terminal_command
    command: "npx eslint --fix {{file_path}}"

astuce

Les déclencheurs de surveillance de fichiers peuvent être bruyants si vous enregistrez fréquemment. Ajoutez une période de temporisation à la configuration du déclencheur pour regrouper les enregistrements rapides en une seule exécution. Cela empêche le bot d'exécuter plusieurs routines qui se chevauchent pour le même fichier.

Édition des routines

Les routines sont stockées sous forme de fichiers de configuration YAML et peuvent être modifiées directement ou via l'éditeur visuel dans Cursor.

Utilisation de l'éditeur visuel

L'éditeur visuel du panneau Automations fournit une interface glisser-déposer pour construire des routines :

1. Faites glisser des blocs d'action depuis la palette à gauche
2. Arrangez-les dans l'ordre souhaité
3. Cliquez sur chaque bloc pour configurer ses paramètres
4. Utilisez le bouton Test pour exécuter la routine avec un exemple d'entrée
5. Enregistrez la routine pour l'activer

Édition directe du YAML

Pour plus de contrôle, vous pouvez éditer directement le fichier YAML de routine. Les fichiers de routine sont stockés dans le répertoire .cursor/automations/ :

# Lister toutes les routines
ls -la .cursor/automations/

# Éditer une routine spécifique
code .cursor/automations/nightly-audit.yaml

# .cursor/automations/code-review-bot.yaml
name: "Smart Code Review Bot"
description: "Analyzes changed files and posts a review comment"
trigger:
  type: webhook
  filter:
    event: "pull_request.opened"
actions:
  - type: parse_payload
    extract:
      pr_number: "$.pull_request.number"
      changed_files: "$.pull_request.changed_files"
      repo: "$.repository.full_name"

  - type: loop
    over: "{{changed_files}}"
    actions:
      - type: read_file
        path: "{{item}}"
      - type: analyze
        prompt: |
          Review this file for:
          1. Security vulnerabilities
          2. Performance issues
          3. Code style violations
          4. Missing error handling

  - type: format_output
    template: |
      ## Automated Code Review

      {{#each results}}
      ### {{this.file}}
      {{this.review}}
      {{/each}}

  - type: webhook_response
    status: 200
    body: "{{formatted_output}}"

attention

Lors de l'édition directe des fichiers YAML de routine, validez toujours la syntaxe avant d'enregistrer. Un fichier YAML malformé fera échouer la routine silencieusement. Utilisez cursor.automations.validate dans la palette de commandes pour vérifier toutes les routines.

Workflows d'automatisation

La combinaison de plusieurs routines crée des workflows d'automatisation puissants qui connectent l'ensemble de votre pipeline de développement.

Exemple de workflow : Automatisation du cycle de vie des PR

Ce workflow automatise l'ensemble du cycle de vie des pull requests :

# Routine 1 : PR ouverte - Analyse initiale
name: "PR Initial Analysis"
trigger:
  type: webhook
  filter:
    event: "pull_request.opened"
actions:
  - type: analyze
    prompt: "Summarize this PR and identify the main changes."
  - type: slack_reply
    channel: "#pr-updates"
    message: "New PR: {{pr_title}}\nSummary: {{analysis_result}}"

---

# Routine 2 : Demande de revue de PR - Analyse approfondie
name: "PR Deep Analysis"
trigger:
  type: slack
  conditions:
    mentions_bot: true
    contains_keyword: "deep-review"
actions:
  - type: analyze
    prompt: "Perform a comprehensive code review including security, performance, and architecture."
  - type: slack_reply
    channel: "{{trigger_channel}}"
    message: "{{analysis_result}}"

---

# Routine 3 : PR fusionnée - Mise à jour de la documentation
name: "PR Merged - Update Docs"
trigger:
  type: webhook
  filter:
    event: "pull_request.closed"
    merged: true
actions:
  - type: analyze
    prompt: "Update the README and CHANGELOG based on the merged changes."
  - type: terminal_command
    command: "git add README.md CHANGELOG.md && git commit -m 'docs: update for PR #{{pr_number}}'"

Exemple de workflow : Réponse aux incidents

name: "Incident Response Bot"
description: "When an error alert is posted to Slack, analyze and suggest fixes"
trigger:
  type: slack
  channels: ["#alerts", "#incidents"]
  conditions:
    contains_keyword: "ERROR"
actions:
  - type: parse_message
    extract:
      error_text: "regex:ERROR:\\s*(.+)"
      stack_trace: "regex:at\\s+(.+)"

  - type: search_codebase
    query: "{{error_text}}"

  - type: analyze
    prompt: |
      An error has occurred. Here is the error message and the relevant code.
      Suggest a fix and explain the root cause.
      Error: {{error_text}}
      Stack trace: {{stack_trace}}
      Relevant file: {{search_result}}

  - type: slack_reply
    channel: "{{trigger_channel}}"
    message: |
      :rotating_light: *Automated Analysis*
      *Likely cause:* {{analysis_result.cause}}
      *Suggested fix:* {{analysis_result.fix}}
      *File to check:* {{search_result}}

astuce

Construisez vos workflows de manière incrémentale. Commencez par une routine de notification simple, testez-la à fond, puis ajoutez des actions plus complexes. Cela facilite l'identification de l'étape défaillante lorsque quelque chose ne va pas.

Dépannage

L'URL Webhook ne s'affiche pas

C'est le problème le plus couramment signalé. Lors de la création d'une routine déclenchée par webhook, le champ URL POST peut apparaître vide.

Cause racine : La routine a été enregistrée avant que le type de déclencheur ne soit défini, ou la routine n'a été que partiellement enregistrée.

Solution :

1. Supprimez la routine et créez-en une nouvelle
2. Définissez le type de déclencheur sur « Webhook » avant de saisir d'autres détails
3. Cliquez sur Save et attendez la génération de l'URL
4. Si l'URL n'apparaît toujours pas, vérifiez le panneau de sortie Cursor pour les erreurs (View > Output > Cursor Automations)
5. En solution de contournement, vous pouvez construire manuellement l'URL en utilisant l'ID de routine du fichier YAML :

http://localhost:7541/webhooks/routines/{ROUTINE_ID}

Les déclencheurs Slack ne se déclenchent pas

Si vos déclencheurs Slack ne répondent pas aux messages :

1. Vérifiez que l'application Slack est installée dans votre espace de travail
2. Vérifiez que l'URL d'abonnement aux événements est accessible (utilisez la fonction de vérification de l'API Slack)
3. Confirmez que l'utilisateur bot a été invité dans le canal cible (/invite @cursor-grok-bot)
4. Vérifiez que les conditions de la routine ne sont pas trop restrictives
5. Consultez le journal Cursor Automations pour les événements entrants :

# Afficher le journal d'automatisation
cat .cursor/automations/logs/automation.log | tail -100

# Filtrer les événements Slack
grep "slack" .cursor/automations/logs/automation.log

attention

Slack a un délai d'attente de 3 secondes pour la vérification de l'URL d'abonnement aux événements. Si Cursor met plus de 3 secondes à répondre à la requête de vérification initiale, Slack rejettera l'URL. Assurez-vous que Cursor est en cours d'exécution et réactif lorsque vous configurez l'abonnement aux événements dans le tableau de bord de l'API Slack.

Problèmes d'édition de routine

Si vous ne pouvez pas enregistrer ou éditer une routine :

1. Vérifiez que le fichier YAML est valide en utilisant la palette de commandes
2. Assurez-vous qu'aucun autre processus n'a verrouillé le fichier de routine
3. Vérifiez que vous avez les permissions d'écriture dans le répertoire .cursor/automations/
4. Essayez de supprimer le répertoire .cursor/automations/cache/ pour forcer un rafraîchissement
5. Redémarrez Cursor si l'éditeur visuel devient non responsive

Débogage de l'exécution des routines

Activez la journalisation de débogage pour voir des informations détaillées sur l'exécution des routines :

// Dans settings.json
{
  "cursor.grokBot.debug": true,
  "cursor.grokBot.logLevel": "verbose"
}

# Afficher les journaux de débogage en temps réel
tail -f .cursor/automations/logs/automation.log

# Filtrer pour une routine spécifique
grep "routine_id: rtn_abc123" .cursor/automations/logs/automation.log

Meilleures pratiques

• Commencez simple : Commencez par une routine de notification de base avant de construire des workflows complexes
• Testez avec un exemple d'entrée : Utilisez le bouton Test dans l'éditeur visuel avant d'activer une routine
• Utilisez les conditions à bon escient : Ajoutez des filtres de condition pour empêcher les routines de se déclencher sur chaque message ou événement
• Surveillez le temps d'exécution : Les routines de longue durée peuvent bloquer l'exécution d'autres routines. Définissez un délai d'attente.
• Contrôlez vos routines par version : Stockez les fichiers YAML de routine dans votre dépôt git pour la collaboration d'équipe
• Documentez vos workflows : Ajoutez des descriptions claires à chaque routine pour que les coéquipiers en comprennent le but
• Pivotez les secrets webhook : Régénérez périodiquement votre secret webhook pour la sécurité
• Utilisez des variables d'environnement : Référencez les valeurs sensibles via des variables d'environnement plutôt que de les coder en dur dans le YAML

astuce

Créez un dépôt de routines partagé que votre équipe peut référencer. Chaque membre de l'équipe peut s'abonner aux routines dont il a besoin, et les mises à jour sont automatiquement récupérées lorsque le dépôt est tiré. Cela favorise la cohérence au sein de l'équipe.

Conclusion

Grok Bot dans Cursor fournit une couche d'automatisation flexible qui connecte votre éditeur à des services externes via des routines webhook et des déclencheurs Slack. En suivant les étapes de configuration de ce guide et en abordant les scénarios de dépannage courants, vous pouvez construire des workflows d'automatisation robustes qui font gagner du temps et réduisent les efforts manuels.

Les choses les plus importantes à retenir sont : validez toujours les requêtes webhook, définissez le type de déclencheur avant d'enregistrer une routine, et testez minutieusement avec les outils de test intégrés avant d'activer les routines en production. Avec ces pratiques en place, Grok Bot devient une partie fiable de votre boîte à outils de développement.