Build an OpenClaw clone with the Baguette Bot API: your personal agent on Telegram, no exposed server

mkdir my-claw && cd my-claw
npm init -y && npm pkg set type=module

// bot.js (Node 18+, no dependencies)
import { readFile, writeFile } from "node:fs/promises";

const KEY = process.env.BAGUETTE_API_KEY;
const BASE = "https://api.baguettebot.com";
const TG = `https://api.telegram.org/bot${process.env.TELEGRAM_TOKEN}`;
const ALLOWED = new Set((process.env.ALLOWED_USERS ?? "").split(",").map((s) => s.trim()).filter(Boolean));
if (!KEY || !process.env.TELEGRAM_TOKEN || !ALLOWED.size) {
  throw new Error("BAGUETTE_API_KEY, TELEGRAM_TOKEN and ALLOWED_USERS are required");
}
const auth = { Authorization: `Bearer ${KEY}` };
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

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

const tg = (method, body) =>
  fetch(`${TG}/${method}`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) })
    .then((r) => r.json())
    .then((j) => { if (!j.ok) throw new Error(j.description); return j.result; });

// Telegram caps a message at 4096 characters: split it
async function say(chat_id, text) {
  text ||= "(empty answer)";
  for (let i = 0; i < text.length; i += 4000) await tg("sendMessage", { chat_id, text: text.slice(i, i + 4000) });
}

/* ---------- one agent per chat ---------- */

const INSTRUCTIONS = `You are your user's personal assistant; they talk to you from Telegram.
You work on your own computer (Chrome, terminal, files), which keeps its files between requests.
Answer in English, in short plain text: it is read on a phone.`;

const DB = new URL("./agents.json", import.meta.url);
let agents = {};
try { agents = JSON.parse(await readFile(DB, "utf8")); } catch { /* first run */ }

async function agentFor(chatId) {
  if (agents[chatId]) return agents[chatId];
  // agents.json lost? Find the agent again through its metadata.
  const { data } = await api("/v1/agents?limit=500");
  const agent = data.find((a) => a.metadata?.telegram_chat_id === String(chatId)) ??
    await api("/v1/agents", {
      name: `Telegram ${chatId}`,
      instructions: INSTRUCTIONS,
      idle_minutes: 5,
      metadata: { telegram_chat_id: String(chatId) },
    });
  agents[chatId] = agent.id;
  await writeFile(DB, JSON.stringify(agents, null, 2));
  return agent.id;
}

async function messagesAfter(id, after) {
  const all = [];
  for (;;) {
    const { data } = await api(`/v1/agents/${id}/messages?after=${after}&limit=200`);
    all.push(...data);
    if (data.length < 200) return all;
    after = data.at(-1).id;
  }
}

/* ---------- one task, followed live ---------- */

async function runTask(agentId, content, onProgress) {
  const ctrl = new AbortController();
  const res = await fetch(`${BASE}/v1/agents/${agentId}/events`, { headers: auth, signal: ctrl.signal });
  if (!res.ok) throw new Error(`Event stream: HTTP ${res.status}`);
  const reader = res.body.pipeThrough(new TextDecoderStream()).getReader();
  let buffer = "", run = null, working = false, end = null;
  try {
    while (!end) {
      const { value, done } = await reader.read();
      if (done) break;
      buffer += value;
      let i;
      while (!end && (i = buffer.indexOf("\n\n")) !== -1) {
        const chunk = buffer.slice(0, i); buffer = buffer.slice(i + 2);
        const type = /^event: (.+)$/m.exec(chunk)?.[1];
        const data = /^data: (.+)$/m.exec(chunk)?.[1];
        if (!type || !data) continue;
        const ev = JSON.parse(data);
        // Only send the task once the stream is open, so nothing is missed
        if (type === "ready" && !run) run = await api(`/v1/agents/${agentId}/messages`, { content, wait: false });
        else if (type === "status" && ev.status === "working") { working = true; if (ev.text) onProgress(ev.text); }
        else if (type === "status" && working) end = ev.status; // idle or blocked
        else if (type === "message" && ev.role === "tool" && ev.tool?.summary) onProgress(ev.tool.summary);
      }
    }
  } finally { ctrl.abort(); }
  if (!run) throw new Error("The stream closed before the task started");
  // The stream dropped midway: wait for the end by polling the agent
  while (!end) {
    await sleep(5000);
    const a = await api(`/v1/agents/${agentId}`);
    if (a.status !== "working") end = a.status;
  }
  const messages = await messagesAfter(agentId, run.message_id);
  const answer = [...messages].reverse().find((m) => m.role === "assistant" && m.content)?.content;
  return { status: end, answer };
}

// A single "Working" message, edited at most every 3 s
function progress(chat_id) {
  let id = null, last = "", next = "", timer = null, closed = false;
  const flush = async () => {
    timer = null;
    if (closed || next === last) return;
    last = next;
    const text = `Working: ${next}`.slice(0, 4000);
    try {
      if (!id) id = (await tg("sendMessage", { chat_id, text })).message_id;
      else await tg("editMessageText", { chat_id, message_id: id, text });
    } catch { /* same text or too fast: harmless */ }
  };
  return {
    update: (text) => { next = text; timer ??= setTimeout(flush, 3000); },
    done: () => { closed = true; clearTimeout(timer); },
  };
}

/* ---------- commands ---------- */

async function sendScreen(chat_id, agentId) {
  const r = await fetch(`${BASE}/v1/agents/${agentId}/computer/screenshot`, { headers: auth });
  if (r.status === 409) return say(chat_id, "My computer is off. It boots again with the next task.");
  if (!r.ok) return say(chat_id, `Screenshot failed (HTTP ${r.status}).`);
  const form = new FormData();
  form.append("chat_id", String(chat_id));
  form.append("photo", new Blob([await r.arrayBuffer()], { type: "image/jpeg" }), "screen.jpg");
  const j = await fetch(`${TG}/sendPhoto`, { method: "POST", body: form }).then((x) => x.json());
  if (!j.ok) throw new Error(j.description);
}

const busy = new Set();

async function handle(msg) {
  const chat_id = msg.chat.id, text = msg.text?.trim();
  if (!text) return;
  if (!ALLOWED.has(String(msg.from?.id))) {
    console.log(`Refused: user ${msg.from?.id} (@${msg.from?.username ?? "?"}), chat ${chat_id}`);
    return; // no reply: a stranger learns nothing
  }
  const command = text.startsWith("/") ? text.split(/[\s@]/)[0] : null;
  if (command === "/start") return say(chat_id, "Give me a task. /screen to see my screen, /stop to stop me.");
  const agentId = await agentFor(chat_id);
  if (command === "/stop") { await api(`/v1/agents/${agentId}/stop`, {}); return say(chat_id, "Task stopped."); }
  if (command === "/screen") return sendScreen(chat_id, agentId);
  if (busy.has(chat_id)) return say(chat_id, "I'm still on the previous task. /screen to see where I am, /stop to stop it.");

  busy.add(chat_id);
  const p = progress(chat_id);
  try {
    await tg("sendChatAction", { chat_id, action: "typing" });
    const { status, answer } = await runTask(agentId, text, p.update);
    p.done();
    await say(chat_id, answer ?? "Done.");
    if (status === "blocked") {
      const live = await api(`/v1/agents/${agentId}/computer/live`, { interactive: true, ttl_seconds: 900 });
      await say(chat_id, `I need you (a login, a captcha…). Take over here, the link expires in 15 minutes:\n${live.url}\nMessage me when you're done.`);
    }
  } catch (e) {
    p.done();
    await say(chat_id, `Error: ${e.message}`);
  } finally {
    busy.delete(chat_id);
  }
}

/* ---------- long polling: no incoming connections ---------- */

let offset = 0;
console.log("Bot ready.");
for (;;) {
  try {
    const updates = await tg("getUpdates", { offset, timeout: 50, allowed_updates: ["message"] });
    for (const u of updates) {
      offset = u.update_id + 1;
      if (u.message) handle(u.message).catch((e) => console.error(e));
    }
  } catch (e) {
    console.error(e.message);
    await sleep(5000);
  }
}

BAGUETTE_API_KEY=bb_live_… TELEGRAM_TOKEN=123456:ABC… ALLOWED_USERS=0 node bot.js
# Refused: user 812345678 (@you), chat 812345678

BAGUETTE_API_KEY=bb_live_… TELEGRAM_TOKEN=123456:ABC… ALLOWED_USERS=812345678 node bot.js