Build a Grok Bot clone: a team of always-on AI agents with the Baguette Bot API

mkdir my-team && cd my-team
npm init -y
npm pkg set type=module
npm i express node-cron
mkdir public
export BAGUETTE_API_KEY=bb_live_…
export TOPIC="AI in Europe"
# optional
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 ?? "AI in 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 = {
  researcher: { name: "Researcher", idle_minutes: 2, instructions:
    "You research the web with Chrome. You check every fact at its source and always note its URL. " +
    "If a site asks you to sign in, don't make up credentials: say so in your answer." },
  writer: { name: "Writer", idle_minutes: 2, instructions:
    "You write clear, plain newsletters in English. You only use facts from the notes you are given, with their links." },
  reviewer: { name: "Reviewer", idle_minutes: 1, instructions:
    "You review texts. If it is ready to publish, answer only APPROVED. Otherwise, list the corrections needed, numbered, without rewriting the text." },
};

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("en-GB")}  ${text}`); console.log(text); };

// A task, and the agent's final answer, even past 120 s
async function ask(role, content) {
  const id = team[role];
  note(`${ROLES[role].name}: working`);
  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 at most
    await sleep(5000);
    const agent = await api(`/v1/agents/${id}`);
    if (agent.status === "working") continue;
    if (agent.status === "blocked") { note(`${ROLES[role].name} is blocked: ${agent.status_text ?? "open its screen"}`); 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}: no answer after 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} not found on ${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") });

// Shutting a computer down as soon as it's no longer needed stops billing
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("Already running, skipping this round");
  running = true;
  try {
    await ask("researcher",
      `Find the 5 most important news items of the week about ${TOPIC}. ` +
      "For each: a title, a three-line summary and the source URL. Save it all in ~/Documents/notes.md.");
    const notes = await download("researcher", "~/Documents/notes.md");
    await stopComputer("researcher");
    await upload("writer", "~/Uploads/notes.md", notes);

    let draft = await ask("writer",
      "The researcher's notes are in ~/Uploads/notes.md. Write this week's newsletter " +
      "(500 words at most, in Markdown) and answer with its text only.");
    for (let round = 1; round <= 2; round++) {
      const review = await ask("reviewer", `Review this newsletter:\n\n${draft}`);
      if (review.trim().startsWith("APPROVED")) { note("Reviewer: approved"); break; }
      draft = await ask("writer",
        `The reviewer asks for these corrections:\n\n${review}\n\nApply them and answer with the corrected text only.`);
    }
    await Promise.all(["writer", "reviewer"].map(stopComputer));

    await writeFile(`newsletter-${new Date().toISOString().slice(0, 10)}.md`, draft);
    await notify(`Newsletter ready:\n\n${draft}`);
    note("Newsletter ready");
  } catch (e) {
    note(`Error: ${e.message}`);
    await notify(`The newsletter failed: ${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 }); });

// An interactive link to an agent's screen (boots the computer if needed)
app.post("/api/live/:role", route(async (req, res) => {
  const id = team[req.params.role];
  if (!id) return res.status(404).json({ error: "Unknown role" });
  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 });
}));

// Local only: an interactive link gives control of the computer
app.listen(3000, "127.0.0.1", () => console.log("http://localhost:3000"));

<!-- public/index.html -->
<!doctype html>
<html lang="en">
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>My team</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>My agent team</h1>
  <p><button id="run">Run the newsletter now</button></p>
  <p>Take over the computer of the
    <button data-role="researcher">researcher</button>
    <button data-role="writer">writer</button>
    <button data-role="reviewer">reviewer</button>
  </p>
  <iframe id="screen" title="Agent's screen"></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 ? "Running…\n" : "") + s.journal.join("\n");
  }, 3000);
</script>
</body>
</html>