Créer un clone de Grok Bot : une équipe d'agents IA toujours actifs avec l'API Baguette Bot

mkdir mon-equipe && cd mon-equipe
npm init -y
npm pkg set type=module
npm i express node-cron
mkdir public
export BAGUETTE_API_KEY=bb_live_…
export TOPIC="l'IA en Europe"
# optionnel
export TELEGRAM_TOKEN=123456:ABC… TELEGRAM_CHAT_ID=123456789

// server.js
import express from "express";
import cron from "node-cron";
import { readFile, writeFile } from "node:fs/promises";

const KEY = process.env.BAGUETTE_API_KEY;
const BASE = "https://api.baguettebot.com";
const TOPIC = process.env.TOPIC ?? "l'IA en Europe";
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

const api = (path, body, method = body ? "POST" : "GET") =>
  fetch(BASE + path, {
    method,
    headers: { Authorization: `Bearer ${KEY}`, "Content-Type": "application/json" },
    body: body && JSON.stringify(body),
  }).then(async (r) => {
    const text = await r.text();
    const data = text ? JSON.parse(text) : {};
    if (!r.ok) throw new Error(data.error?.message ?? r.statusText);
    return data;
  });

const ROLES = {
  chercheur: { name: "Chercheur", idle_minutes: 2, instructions:
    "Tu fais de la veille sur le web avec Chrome. Tu vérifies chaque information à la source et tu notes toujours son URL. " +
    "Si un site te demande de te connecter, n'invente pas d'identifiants : dis-le dans ta réponse." },
  redacteur: { name: "Rédacteur", idle_minutes: 2, instructions:
    "Tu écris des newsletters claires et sobres en français. Tu n'utilises que les faits des notes qu'on te donne, avec leurs liens." },
  relecteur: { name: "Relecteur", idle_minutes: 1, instructions:
    "Tu relis des textes. S'il est prêt à être publié, réponds uniquement VALIDÉ. Sinon, liste les corrections nécessaires, numérotées, sans réécrire le texte." },
};

async function loadTeam() {
  let team = {};
  try { team = JSON.parse(await readFile("team.json", "utf8")); } catch {}
  for (const [role, def] of Object.entries(ROLES)) {
    if (!team[role]) team[role] = (await api("/v1/agents", { ...def, metadata: { team: "newsletter", role } })).id;
  }
  await writeFile("team.json", JSON.stringify(team, null, 2));
  return team;
}
const team = await loadTeam();

const journal = [];
const note = (text) => { journal.push(`${new Date().toLocaleTimeString("fr-FR")}  ${text}`); console.log(text); };

// Une tâche, et la réponse finale de l'agent, même au-delà de 120 s
async function ask(role, content) {
  const id = team[role];
  note(`${ROLES[role].name} : au travail`);
  const run = await api(`/v1/agents/${id}/messages`, { content, wait: true });
  if (run.status === "done") return run.output;

  for (let i = 0; i < 360; i++) { // 30 minutes au plus
    await sleep(5000);
    const agent = await api(`/v1/agents/${id}`);
    if (agent.status === "working") continue;
    if (agent.status === "blocked") { note(`${ROLES[role].name} est bloqué : ${agent.status_text ?? "ouvre son écran"}`); continue; }
    const page = await api(`/v1/agents/${id}/messages?after=${run.message_id}&limit=200`);
    const messages = page.data ?? page;
    return messages.filter((m) => m.role === "assistant" && m.content).at(-1)?.content ?? "";
  }
  throw new Error(`${ROLES[role].name} : pas de réponse après 30 minutes`);
}

async function download(role, path) {
  const r = await fetch(`${BASE}/v1/agents/${team[role]}/files?path=${encodeURIComponent(path)}`, {
    headers: { Authorization: `Bearer ${KEY}` },
  });
  if (!r.ok) throw new Error(`${path} introuvable chez ${ROLES[role].name}`);
  return Buffer.from(await r.arrayBuffer());
}
const upload = (role, path, buffer) =>
  api(`/v1/agents/${team[role]}/files`, { path, content_base64: buffer.toString("base64") });

// Éteindre un ordinateur dès qu'on n'en a plus besoin arrête la facturation
const stopComputer = (role) => api(`/v1/agents/${team[role]}/computer/stop`, {}).catch(() => {});

async function notify(text) {
  const { TELEGRAM_TOKEN, TELEGRAM_CHAT_ID } = process.env;
  if (!TELEGRAM_TOKEN) return;
  await fetch(`https://api.telegram.org/bot${TELEGRAM_TOKEN}/sendMessage`, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ chat_id: TELEGRAM_CHAT_ID, text: text.slice(0, 4000) }),
  });
}

let running = false;
async function runNewsletter() {
  if (running) return note("Déjà en cours, on saute ce tour");
  running = true;
  try {
    await ask("chercheur",
      `Trouve les 5 informations les plus importantes de la semaine sur ${TOPIC}. ` +
      "Pour chacune : un titre, trois lignes de résumé et l'URL de la source. Enregistre le tout dans ~/Documents/notes.md.");
    const notes = await download("chercheur", "~/Documents/notes.md");
    await stopComputer("chercheur");
    await upload("redacteur", "~/Uploads/notes.md", notes);

    let draft = await ask("redacteur",
      "Les notes du chercheur sont dans ~/Uploads/notes.md. Écris la newsletter de la semaine " +
      "(500 mots au plus, en Markdown) et réponds uniquement avec son texte.");
    for (let round = 1; round <= 2; round++) {
      const review = await ask("relecteur", `Relis cette newsletter :\n\n${draft}`);
      if (review.trim().startsWith("VALIDÉ")) { note("Relecteur : validé"); break; }
      draft = await ask("redacteur",
        `Le relecteur demande ces corrections :\n\n${review}\n\nApplique-les et réponds uniquement avec le texte corrigé.`);
    }
    await Promise.all(["redacteur", "relecteur"].map(stopComputer));

    await writeFile(`newsletter-${new Date().toISOString().slice(0, 10)}.md`, draft);
    await notify(`Newsletter prête :\n\n${draft}`);
    note("Newsletter prête");
  } catch (e) {
    note(`Erreur : ${e.message}`);
    await notify(`La newsletter a échoué : ${e.message}`).catch(() => {});
  } finally {
    running = false;
  }
}

cron.schedule("0 8 * * 1", runNewsletter, { timezone: "Europe/Paris" });

const route = (fn) => (req, res) => fn(req, res).catch((e) => res.status(500).json({ error: e.message }));
const app = express();
app.use(express.static("public"));

app.get("/api/state", (req, res) => res.json({ running, journal: journal.slice(-30) }));
app.post("/api/run", (req, res) => { runNewsletter(); res.json({ ok: true }); });

// Un lien interactif vers l'écran d'un agent (on allume l'ordinateur si besoin)
app.post("/api/live/:role", route(async (req, res) => {
  const id = team[req.params.role];
  if (!id) return res.status(404).json({ error: "Rôle inconnu" });
  if ((await api(`/v1/agents/${id}/computer`)).status !== "running") {
    await api(`/v1/agents/${id}/computer/start`, {});
    for (let i = 0; i < 30 && (await api(`/v1/agents/${id}/computer`)).status !== "running"; i++) await sleep(2000);
  }
  const live = await api(`/v1/agents/${id}/computer/live`, { interactive: true, ttl_seconds: 900 });
  res.json({ url: live.url });
}));

// Uniquement en local : un lien interactif donne le contrôle de l'ordinateur
app.listen(3000, "127.0.0.1", () => console.log("http://localhost:3000"));

<!-- public/index.html -->
<!doctype html>
<html lang="fr">
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Mon équipe</title>
<style>
  body { font: 15px/1.5 system-ui, sans-serif; max-width: 1000px; margin: 0 auto; padding: 16px; }
  button { padding: 6px 12px; margin: 2px; }
  iframe { width: 100%; aspect-ratio: 16 / 10; border: 0; border-radius: 12px; background: #111; margin: 12px 0; }
  pre { background: #f3f3f3; padding: 12px; border-radius: 10px; white-space: pre-wrap; }
</style>
<body>
  <h1>Mon équipe d'agents</h1>
  <p><button id="run">Lancer la newsletter maintenant</button></p>
  <p>Prendre la main sur l'ordinateur du
    <button data-role="chercheur">chercheur</button>
    <button data-role="redacteur">rédacteur</button>
    <button data-role="relecteur">relecteur</button>
  </p>
  <iframe id="screen" title="Écran de l'agent"></iframe>
  <pre id="journal">…</pre>
<script>
  document.getElementById("run").onclick = () => fetch("/api/run", { method: "POST" });
  for (const b of document.querySelectorAll("[data-role]")) {
    b.onclick = async () => {
      b.disabled = true;
      const r = await fetch("/api/live/" + b.dataset.role, { method: "POST" }).then((x) => x.json());
      b.disabled = false;
      if (r.url) document.getElementById("screen").src = r.url; else alert(r.error);
    };
  }
  setInterval(async () => {
    const s = await fetch("/api/state").then((x) => x.json());
    document.getElementById("journal").textContent = (s.running ? "En cours…\n" : "") + s.journal.join("\n");
  }, 3000);
</script>
</body>
</html>