---
title: Une commande pour faire lire votre Jira à GitHub Copilot, et voir ce que coûte chaque réponse
description: pilotkit est une CLI open source qui connecte une licence GitHub Copilot à Jira et Confluence en une commande, avec un serveur MCP en lecture seule et le jeton d’API dans le trousseau du système, plus un bureau local qui affiche les crédits IA de chaque réponse.
date: 2026-10-12
tags: GitHub Copilot, MCP, Jira, Confluence
project: https://github.com/brbousnguar/pilotkit
---

GitHub Copilot peut lire vos tickets Jira et vos pages Confluence. Il lui faut juste, au préalable, un serveur MCP, un jeton d’API Atlassian et deux fichiers de config dans deux formats différents. [pilotkit](https://github.com/brbousnguar/pilotkit) fait tout ça en une commande, `pilotkit setup`, et ajoute un petit bureau local, une page de chat qui affiche ce que chaque réponse a coûté en crédits IA.

C’est open source et sur npm : `npm install -g pilotkit`. Tout est parti d’un bureau de ce genre que je fais tourner au travail. pilotkit, c’est la version que les collègues peuvent installer sur leur propre PC sans que je sois assis à côté d’eux.

## Copilot ne voit pas encore vos tickets

Une licence Copilot donne accès au chat, au mode agent dans VS Code et à une CLI. Aucun des trois ne sait que votre site Atlassian existe.

Le faire à la main, c’est installer un serveur MCP, créer un jeton d’API et, en général, le coller dans un fichier JSON, puis enregistrer le serveur deux fois : `copilot mcp add` pour la CLI Copilot, et un `mcp.json` pour VS Code dans un autre format. Facile à faire une fois pour soi, fastidieux quand il faut y guider toute une équipe.

<figure class="fd-fig" aria-labelledby="pk1-cap" data-desc="Deux façons de connecter Copilot à Jira et Confluence. À la main, quatre tâches : installer un serveur MCP, créer un jeton d’API Atlassian et le coller dans un fichier JSON, enregistrer le serveur dans la CLI Copilot avec copilot mcp add, et écrire un mcp.json pour VS Code dans un autre format. Avec pilotkit, une seule commande, pilotkit setup : le jeton va dans le trousseau du système et jamais dans un fichier, et le serveur est enregistré dans les deux clients sans toucher aux autres serveurs.">
<div class="mp-two-row">
<div class="mp-two-card">
<p class="mp-two-who">À la main</p>
<p class="mp-two-name">Quatre tâches</p>
<p class="mp-two-line">Installer un serveur MCP</p>
<p class="mp-two-line">Créer un jeton d’API, le coller dans un fichier JSON</p>
<p class="mp-two-line"><code>copilot mcp add</code> pour la CLI Copilot</p>
<p class="mp-two-line">Un <code>mcp.json</code> pour VS Code, dans un autre format</p>
</div>
<p class="mp-two-vs">contre</p>
<div class="mp-two-card mp-two-peter">
<p class="mp-two-who">pilotkit</p>
<p class="mp-two-name">Une commande</p>
<p class="mp-two-line"><code>pilotkit setup</code></p>
<p class="mp-two-line">Le jeton va dans le trousseau du système, jamais dans un fichier</p>
<p class="mp-two-line">Enregistré dans les deux clients, autres serveurs conservés</p>
</div>
</div>
<figcaption id="pk1-cap">Même résultat, deux chemins. La carte en bleu, c’est celle que vous pouvez confier à un collègue.</figcaption>
</figure>

## Ce que fait une seule commande

Le setup enchaîne trois vérifications et n’enregistre que ce qui a réussi :

1. **Copilot.** Il trouve la CLI Copilot, propose de l’installer et vous connecte avec `copilot login`.
2. **Atlassian.** Il demande le site, votre e-mail et un jeton d’API, puis les vérifie d’un seul appel à `/rest/api/3/myself`. Un mauvais jeton a droit à deux essais de plus.
3. **Clients.** Il enregistre le serveur dans la CLI Copilot et dans chaque `mcp.json` utilisateur de VS Code qu’il trouve, en conservant les autres serveurs et une sauvegarde du fichier.

Le jeton n’atterrit jamais dans un fichier de config. Sur Mac, il va dans le trousseau macOS via `security -i`, qui lit sa commande sur stdin. Passer le jeton en argument le mettrait dans la liste des processus, où d’autres programmes lancés sous votre compte peuvent le lire avec `ps`. Sur Windows, c’est un fichier que seul votre compte Windows peut déchiffrer (DPAPI), et sur Linux, c’est le Secret Service.

Un bug que j’ai attrapé avant qu’il ne fasse de victime : avec Homebrew, le chemin que Node donne pour lui-même pointe dans un dossier `Cellar` versionné. Enregistrez celui-là, et la commande casse au prochain `brew upgrade`. Le setup enregistre maintenant le chemin `opt/`, qui survit aux mises à jour.

<figure class="fd-fig mp-trio-fig" aria-labelledby="pk2-cap" data-desc="Ce que fait pilotkit setup, en trois vérifications. Un, Copilot : il trouve la CLI Copilot, propose de l’installer et se connecte avec copilot login. Deux, Atlassian : il demande le site, l’e-mail et un jeton d’API, et les valide avec un appel à /rest/api/3/myself ; un mauvais jeton a droit à deux essais de plus. Trois, clients : il enregistre le serveur dans la CLI Copilot et dans chaque mcp.json utilisateur de VS Code, en conservant les autres serveurs et une sauvegarde. Le jeton est stocké dans le trousseau macOS, dans un fichier protégé par DPAPI sous Windows ou dans le Secret Service sous Linux, jamais dans un fichier de config.">
<ol class="mp-trio">
<li class="mp-trio-step">
<p class="mp-trio-n"><b>1</b>Copilot</p>
<p class="mp-trio-what">Trouver ou installer la CLI, puis <code>copilot login</code></p>
</li>
<li class="mp-trio-step">
<p class="mp-trio-n"><b>2</b>Atlassian</p>
<p class="mp-trio-what">Site, e-mail et jeton, validés via <code>/myself</code></p>
</li>
<li class="mp-trio-step">
<p class="mp-trio-n"><b>3</b>Clients</p>
<p class="mp-trio-what">CLI Copilot et VS Code, autres serveurs conservés</p>
</li>
</ol>
<p class="mp-strip"><b>Le jeton</b><span>Trousseau macOS, DPAPI sous Windows ou Secret Service sous Linux. Jamais un fichier de config.</span></p>
<figcaption id="pk2-cap">Chaque étape vérifie sa réponse avant que la suivante ne commence, donc un mauvais jeton n’est jamais enregistré.</figcaption>
</figure>

## Sept outils, tous en lecture seule

Le serveur MCP a sept outils : `whoami`, `jira_my_issues`, `jira_search`, `jira_get_issue`, `jira_list_projects`, `confluence_search` et `confluence_get_page`. Ils n’envoient que des requêtes `GET`, avec votre propre compte Atlassian, donc Copilot voit ce que vous verriez dans un navigateur, et rien de plus. Il ne peut ni commenter, ni déplacer un ticket, ni modifier une page. Besoin d’un commentaire ? Demandez un brouillon et collez-le vous-même.

Ils renvoient aussi du texte court, exprès. Jira stocke les descriptions en ADF, un arbre JSON, et Confluence stocke les pages en XHTML. Les deux sont verbeux. Chaque caractère renvoyé par un outil repart vers le modèle à chaque appel suivant du chat, donc pilotkit les convertit en Markdown compact et coupe par défaut une description à 6 000 caractères et une page à 8 000.

<figure class="fd-fig" aria-labelledby="pk3-cap" data-desc="Les sept outils de pilotkit, tous en lecture seule : whoami, jira_my_issues, jira_search, jira_get_issue, jira_list_projects, confluence_search et confluence_get_page. Aucun outil n’écrit : ni commentaire, ni transition, ni modification de page. Leur sortie est courte exprès : l’ADF de Jira et le XHTML de Confluence deviennent du Markdown compact, avec par défaut une description coupée à 6 000 caractères et une page à 8 000, parce que chaque caractère renvoyé par un outil repart avec chaque appel suivant au modèle.">
<div class="mw-ro">
<div class="mw-tools">
<p class="mw-tools-h">Lecture</p>
<ul class="mw-chips"><li>whoami</li><li>jira_my_issues</li><li>jira_search</li><li>jira_get_issue</li><li>jira_list_projects</li><li>confluence_search</li><li>confluence_get_page</li></ul>
<p class="mw-tools-h">Écriture</p>
<ul class="mw-chips mw-chips-none"><li>commentaire</li><li>transition</li><li>modifier une page</li></ul>
</div>
</div>
<p class="mp-strip"><b>Sortie courte</b><span>L’ADF et le XHTML deviennent du Markdown compact, coupé à 6 000 et 8 000 caractères.</span></p>
<figcaption id="pk3-cap">Sept outils qui lisent, aucun qui écrit. Ceux qui sont barrés n’existent pas.</figcaption>
</figure>

## Le plus amusant : ce que coûte une réponse

Copilot facture en crédits IA sur un quota mensuel, et la fenêtre de chat ne vous dit pas ce qu’une question vient de dépenser. Alors `pilotkit start` ouvre un bureau sur `127.0.0.1:8717` qui fait tourner Copilot via le [Copilot SDK](https://github.com/github/copilot-sdk) officiel, et qui compte.

Après chaque appel au modèle, le SDK envoie un événement `assistant.usage`. Son champ `copilotUsage.totalNanoAiu` donne le coût en nano-unités IA (nano AI units), et il en faut 1 000 000 000 pour faire un crédit. Le bureau stocke ce coût par appel dans SQLite et affiche le total sous chaque réponse, avec un tableau des appels au modèle et des appels d’outil qui l’ont produite.

Ma première vraie question, sur mes tickets Jira ouverts, avec Claude Haiku 5.5 : **2 appels au modèle, 1 appel d’outil, 0,12 crédit**. Le premier appel a demandé `jira_my_issues`, le second a rédigé la réponse. Une relance dans le même chat a coûté 0,03.

Quand un appel revient sans coût, le bureau l’estime à partir du prix des tokens du modèle et le marque d’un ≈. Chaque chat a aussi un plafond, 60 crédits par défaut, que Copilot applique lui-même via `sessionLimits.maxAiCredits`. Copilot refuse un plafond inférieur à 30.

<figure class="fd-fig mp-trio-fig" aria-labelledby="pk4-cap" data-desc="Ce qu’a coûté une réponse, sur un vrai essai. Un : un appel au modèle lit la question et demande jira_my_issues. Deux : l’appel d’outil lit Jira avec votre propre compte. Trois : un second appel au modèle rédige la réponse à partir du résultat. Avec Claude Haiku 5.5, cette première question a pris 2 appels au modèle et 1 appel d’outil, pour 0,12 crédit ; une relance dans le même chat a coûté 0,03. Chaque chat a un plafond, 60 crédits par défaut. Le coût vient de l’événement assistant.usage que le Copilot SDK envoie après chaque appel au modèle : un crédit vaut 1 000 000 000 de nano-unités IA.">
<ol class="mp-trio">
<li class="mp-trio-step">
<p class="mp-trio-n"><b>1</b>Appel au modèle</p>
<p class="mp-trio-what">Lit la question, demande <code>jira_my_issues</code></p>
</li>
<li class="mp-trio-step">
<p class="mp-trio-n"><b>2</b>Appel d’outil</p>
<p class="mp-trio-what">Lit Jira avec votre propre compte</p>
</li>
<li class="mp-trio-step">
<p class="mp-trio-n"><b>3</b>Appel au modèle</p>
<p class="mp-trio-what">Rédige la réponse à partir du résultat</p>
</li>
</ol>
<div class="mp-stats">
<p><b>0,12</b><span>crédit pour cette première question, Claude Haiku 5.5</span></p>
<p><b>0,03</b><span>pour une relance dans le même chat</span></p>
<p><b>60</b><span>crédits, le plafond par défaut d’un chat</span></p>
</div>
<p class="mp-strip"><b>1 crédit</b><span>1 000 000 000 de nano-unités IA, lus dans <code>assistant.usage</code> après chaque appel au modèle.</span></p>
<figcaption id="pk4-cap">Une réponse, démontée. Les chiffres viennent de ma première vraie question sur le bureau.</figcaption>
</figure>

## Verrouillé sur cette machine

Un bureau qui dépense des crédits ne devrait répondre à personne d’autre. Il n’écoute que sur `127.0.0.1`, mais cela seul ne suffit pas : une page web que vous visitez peut toujours envoyer des requêtes à localhost. Il vérifie donc deux choses de plus.

L’en-tête `Host` doit valoir `127.0.0.1` ou `localhost`. Un nom DNS qui pointe vers 127.0.0.1 reçoit un `421`, ce qui bloque le DNS rebinding. Et chaque écriture exige un en-tête `X-Pilotkit: 1`. Un formulaire ou une image sur un autre site ne peut pas en envoyer, donc il reçoit un `403` et ne peut pas dépenser vos crédits.

À l’intérieur, les sessions Copilot du bureau ne voient que les outils pilotkit. Un gestionnaire de permissions refuse le shell, les fichiers, les URL et les autres serveurs MCP, avec une raison que le modèle peut lire.

<figure class="fd-fig" aria-labelledby="pk5-cap" data-desc="Qui peut utiliser le bureau. Vous, dans votre propre navigateur, sur 127.0.0.1 port 8717 : vous y accédez. Un formulaire ou une image sur un autre site n’envoie pas d’en-tête X-Pilotkit, donc son écriture reçoit un 403. Un nom DNS qui pointe vers 127.0.0.1 arrive avec un mauvais en-tête Host et reçoit un 421. Et dans le bureau, un modèle qui demande un shell est refusé par le gestionnaire de permissions, avec la raison. Les chats du bureau ne voient que les sept outils de pilotkit.">
<ol class="ts-list ts-who">
<li class="ts-yes"><p class="ts-who-n">Vous, dans votre navigateur</p><p class="ts-hop">127.0.0.1:8717</p><p class="ts-end">le bureau</p></li>
<li class="ts-no"><p class="ts-who-n">Un formulaire sur un autre site</p><p class="ts-hop">pas de X-Pilotkit ✗</p><p class="ts-end">403</p></li>
<li class="ts-no"><p class="ts-who-n">Un nom DNS pointé ici</p><p class="ts-hop">mauvais Host ✗</p><p class="ts-end">421</p></li>
<li class="ts-no"><p class="ts-who-n">Le modèle, qui demande un shell</p><p class="ts-hop">gestionnaire de permissions ✗</p><p class="ts-end">refusé, avec la raison</p></li>
</ol>
<p class="mp-strip"><b>Outils dans un chat du bureau</b><span>Seulement les sept de pilotkit.</span></p>
<figcaption id="pk5-cap">Quatre façons de frapper à la porte, une seule qui entre. Le 421 et le 403, c’est ce que le bureau a répondu quand je les ai essayés.</figcaption>
</figure>

## Votre logo, pas le mien

Je l’ai fait pour des collègues, donc il doit ressembler à l’outil de leur entreprise, pas à mon projet perso. Mais un logo d’entreprise est une marque déposée, et il n’a rien à faire dans un dépôt public.

Le package reste donc neutre, et un pack de marque porte l’identité visuelle : un dossier avec un `brand.json` et un logo, partagé en interne sur un drive ou une URL intranet.

```bash
pilotkit setup --brand ./brand-acme
```

Il définit le nom, le logo, la couleur d’accent et la phrase d’accueil sur le bureau et dans le setup, et peut pré-remplir le site Atlassian. Le dépôt fournit un seul exemple, pour une entreprise qui n’existe pas : Acme.

<figure class="fd-fig" aria-labelledby="pk6-cap" data-desc="Où vit l’identité visuelle. Le package public pilotkit est neutre : le nom, le logo et la couleur de pilotkit, plus un pack d’exemple pour une entreprise inventée, Acme. Le pack d’une entreprise reste en interne, sur un drive ou une URL intranet : son nom, son logo et sa couleur d’accent, une phrase d’accueil et des liens d’aide, et le site Atlassian pré-rempli. Il s’applique avec pilotkit setup --brand suivi du dossier ou de l’URL.">
<div class="mp-two-row">
<div class="mp-two-card">
<p class="mp-two-who">Package public</p>
<p class="mp-two-name">Bureau pilotkit</p>
<p class="mp-two-line">Nom, logo et couleur neutres</p>
<p class="mp-two-line">Un pack d’exemple, pour une Acme inventée</p>
</div>
<p class="mp-two-vs">+</p>
<div class="mp-two-card mp-two-peter">
<p class="mp-two-who">Le pack de votre entreprise</p>
<p class="mp-two-name">Votre bureau</p>
<p class="mp-two-line">Votre nom, votre logo, votre couleur d’accent</p>
<p class="mp-two-line">Une phrase d’accueil, des liens d’aide, le site Atlassian pré-rempli</p>
<p class="mp-two-line">Partagé sur un drive ou une URL intranet</p>
</div>
</div>
<p class="mp-strip"><b>Appliqué avec</b><span><code>pilotkit setup --brand &lt;folder or URL&gt;</code></span></p>
<figcaption id="pk6-cap">Les marques restent chez l’entreprise qui les possède. Le dépôt public ne connaît qu’Acme.</figcaption>
</figure>

## Essayez-le

```bash
npm install -g pilotkit
pilotkit setup
pilotkit start
```

Il vous faut Node 22.13 ou plus récent, un abonnement Copilot et un site Atlassian Cloud. Une fois le setup fait, les mêmes outils marchent aussi dans le mode agent de VS Code et dans la CLI Copilot. `pilotkit doctor` vérifie chaque élément et dit quoi lancer quand quelque chose cloche.

<figure class="fd-fig mp-loop" aria-labelledby="pk7-cap" data-desc="Démarrer en trois étapes. Un : l’installer depuis npm avec npm install -g pilotkit ; il faut Node 22.13 ou plus récent. Deux : lancer pilotkit setup pour se connecter à Copilot et brancher Atlassian. Trois : lancer pilotkit start et poser ses questions sur le bureau, ou utiliser les mêmes outils dans le mode agent de VS Code ou dans la CLI Copilot. Testé sur macOS avec un vrai site Jira et Confluence Cloud ; Windows et Linux ne sont pas encore vérifiés.">
<div class="mp-loop-in">
<div class="flow" role="group" aria-label="Démarrer : installer pilotkit depuis npm, lancer pilotkit setup, puis pilotkit start">
  <div class="flow-node">
    <p class="flow-label">1 · npm</p>
    <h3>Installer</h3>
    <ul>
      <li>npm install -g pilotkit</li>
      <li>Node 22.13 ou plus récent</li>
    </ul>
  </div>
  <div class="flow-link" aria-hidden="true"><span>→</span></div>
  <div class="flow-node">
    <p class="flow-label">2 · Setup</p>
    <h3>Connecter</h3>
    <ul>
      <li>pilotkit setup</li>
      <li>Connexion Copilot, jeton Atlassian</li>
    </ul>
  </div>
  <div class="flow-link" aria-hidden="true"><span>→</span></div>
  <div class="flow-node">
    <p class="flow-label">3 · Questions</p>
    <h3>Bureau</h3>
    <ul>
      <li>pilotkit start</li>
      <li>Ou VS Code, ou la CLI Copilot</li>
    </ul>
  </div>
</div>
</div>
<p class="mp-strip"><b>Testé</b><span>macOS, avec un vrai site Jira et Confluence Cloud. Pas encore : Windows et Linux.</span></p>
<figcaption id="pk7-cap">Trois commandes jusqu’à une première réponse.</figcaption>
</figure>

C’est une toute première version, la v0.1, sous licence Apache-2.0, sur [npm](https://www.npmjs.com/package/pilotkit). Je l’ai testé sur macOS avec un vrai site Jira et Confluence Cloud : les sept outils, le bureau, sur ordinateur comme sur téléphone, et les garde-fous ci-dessus. Windows et Linux ne sont pas encore vérifiés, donc si vous le lancez là-dessus, dites-moi ce qui casse. Les issues sont ouvertes sur [GitHub](https://github.com/brbousnguar/pilotkit).

*GitHub Copilot est une marque de GitHub ; Atlassian, Jira et Confluence sont des marques d’Atlassian. pilotkit est un projet indépendant.*