maestro-agent 0.0.1 → 0.0.2

package/src/api/workspaces.ts

@@ -0,0 +1,150 @@
+import { join } from "path";
+import type { Router } from "../core/router";
+import { json, body } from "../core/router";
+import type { HubContext } from "../core/server";
+import { generateId, now } from "../core/db";
+import { required } from "../core/validate";
+import { recommendRoles } from "../chief";
+
+export function registerWorkspaceRoutes(router: Router, ctx: HubContext) {
+  router.post("/api/workspaces", async (req) => {
+    const { name, goal } = await body(req);
+    required({ name }, ["name"]);
+    const id = generateId("ws");
+    const ts = now();
+    ctx.db.run(
+      "INSERT INTO workspace (id, name, goal, status, created_at, updated_at) VALUES (?, ?, ?, 'active', ?, ?)",
+      [id, name, goal || null, ts, ts]
+    );
+    ctx.bus.publish("workspace.created", { id, name });
+    return json({ id, name, goal, status: "active", created_at: ts, updated_at: ts }, 201);
+  });
+
+  router.get("/api/workspaces", () => {
+    const rows = ctx.db.query("SELECT * FROM workspace ORDER BY created_at DESC").all();
+    return json(rows);
+  });
+
+  router.get("/api/workspaces/:id", (_req, params) => {
+    const row = ctx.db.query("SELECT * FROM workspace WHERE id = ?").get(params.id);
+    if (!row) return json({ error: "Not found" }, 404);
+    return json(row);
+  });
+
+  router.patch("/api/workspaces/:id", async (req, params) => {
+    const updates = await body(req);
+    const fields: string[] = [];
+    const values: any[] = [];
+    for (const key of ["name", "goal", "status"]) {
+      if (updates[key] !== undefined) {
+        fields.push(`${key} = ?`);
+        values.push(updates[key]);
+      }
+    }
+    if (fields.length === 0) return json({ error: "No fields to update" }, 400);
+    fields.push("updated_at = ?");
+    values.push(now());
+    values.push(params.id);
+    ctx.db.run(`UPDATE workspace SET ${fields.join(", ")} WHERE id = ?`, values);
+    const row = ctx.db.query("SELECT * FROM workspace WHERE id = ?").get(params.id);
+    return json(row);
+  });
+
+  router.delete("/api/workspaces/:id", (_req, params) => {
+    const workspace = ctx.db.query("SELECT * FROM workspace WHERE id = ?").get(params.id) as any;
+    if (!workspace) return json({ error: "Not found" }, 404);
+    // 检查是否有关联 project
+    const projects = ctx.db.query("SELECT id FROM project WHERE workspace_id = ?").all(params.id);
+    if (projects.length > 0) return json({ error: "Cannot delete workspace with existing projects" }, 409);
+    ctx.db.run("DELETE FROM workspace WHERE id = ?", [params.id]);
+    ctx.bus.publish("workspace.deleted", { id: params.id });
+    return json({ ok: true });
+  });
+
+  // Recommend roles for a workspace based on its goal
+  router.post("/api/workspaces/:id/recommend-roles", (_req, params) => {
+    const workspace = ctx.db.query("SELECT * FROM workspace WHERE id = ?").get(params.id) as any;
+    if (!workspace) return json({ error: "Workspace not found" }, 404);
+    const recommendations = recommendRoles(workspace.goal || workspace.name);
+    return json(recommendations);
+  });
+
+  router.post("/api/workspaces/:id/pause", (_req, params) => {
+    const workspace = ctx.db.query("SELECT * FROM workspace WHERE id = ?").get(params.id) as any;
+    if (!workspace) return json({ error: "Not found" }, 404);
+    if (workspace.status !== "active") return json({ error: "Only active workspaces can be paused" }, 409);
+    const ts = now();
+    ctx.db.run("UPDATE workspace SET status = 'paused', updated_at = ? WHERE id = ?", [ts, params.id]);
+    ctx.bus.publish("workspace.paused", { id: params.id });
+    const row = ctx.db.query("SELECT * FROM workspace WHERE id = ?").get(params.id);
+    return json(row);
+  });
+
+  router.post("/api/workspaces/:id/resume", (_req, params) => {
+    const workspace = ctx.db.query("SELECT * FROM workspace WHERE id = ?").get(params.id) as any;
+    if (!workspace) return json({ error: "Not found" }, 404);
+    if (workspace.status !== "paused") return json({ error: "Only paused workspaces can be resumed" }, 409);
+    const ts = now();
+    ctx.db.run("UPDATE workspace SET status = 'active', updated_at = ? WHERE id = ?", [ts, params.id]);
+    ctx.bus.publish("workspace.resumed", { id: params.id });
+    const row = ctx.db.query("SELECT * FROM workspace WHERE id = ?").get(params.id);
+    return json(row);
+  });
+
+  // Wizard: create project + assign roles + instantiate agents in one step
+  router.post("/api/workspaces/:id/wizard", async (req, params) => {
+    const workspace = ctx.db.query("SELECT * FROM workspace WHERE id = ?").get(params.id) as any;
+    if (!workspace) return json({ error: "Workspace not found" }, 404);
+
+    const { project_name, roles } = await body(req);
+    if (!project_name) return json({ error: "project_name is required" }, 400);
+    if (!roles || !Array.isArray(roles) || roles.length === 0) {
+      return json({ error: "roles array is required" }, 400);
+    }
+
+    const ts = now();
+
+    // 1. Create project
+    const projectId = generateId("proj");
+    ctx.db.run(
+      "INSERT INTO project (id, workspace_id, name, status, created_by, created_at, updated_at) VALUES (?, ?, ?, 'active', 'wizard', ?, ?)",
+      [projectId, params.id, project_name, ts, ts]
+    );
+
+    // 2. Assign roles to workspace and instantiate agents
+    const createdAgents: any[] = [];
+    for (const roleSpec of roles) {
+      const { role_id, runtime_id, headcount } = roleSpec;
+      if (!role_id || !runtime_id) continue;
+
+      // Update role's workspace_id and project_id
+      ctx.db.run(
+        "UPDATE role SET workspace_id = ?, project_id = ?, updated_at = ? WHERE id = ?",
+        [params.id, projectId, ts, role_id]
+      );
+
+      const role = ctx.db.query("SELECT * FROM role WHERE id = ?").get(role_id) as any;
+      const count = headcount || role?.headcount || 1;
+
+      // Create agents
+      for (let i = 0; i < count; i++) {
+        const agentId = generateId("agent");
+        const name = `${role?.name || role_id}-${i + 1}`;
+        const workdir = null;
+        ctx.db.run(
+          "INSERT INTO agent (id, role_id, runtime_id, name, workdir, status, created_at, last_active_at) VALUES (?, ?, ?, ?, ?, 'idle', ?, ?)",
+          [agentId, role_id, runtime_id, name, workdir, ts, ts]
+        );
+        createdAgents.push({ id: agentId, name, role_id, runtime_id, status: "idle" });
+        ctx.bus.publish("agent.spawned", { id: agentId, name, runtime_id });
+      }
+    }
+
+    ctx.bus.publish("project.created", { id: projectId, workspace_id: params.id });
+
+    return json({
+      project: { id: projectId, name: project_name, workspace_id: params.id },
+      agents: createdAgents,
+    }, 201);
+  });
+}

package/src/bridges/lark/index.ts

@@ -0,0 +1,213 @@
+import type { Database } from "bun:sqlite";
+import { generateId, now } from "../../core/db";
+import { countTasksByPredicate, isActiveTaskStatus, isInitialTaskStatus } from "../../workflows";
+
+export interface LarkCard {
+  type: "card";
+  title: string;
+  fields?: Record<string, number>;
+  items?: any[];
+}
+
+export function handleLarkCommand(db: Database, text: string): LarkCard {
+  const command = text.trim();
+  
+  if (command === "/status") {
+    return {
+      type: "card",
+      title: "MAESTRO Status",
+      fields: {
+        workspaces: count(db, "workspace"),
+        projects: count(db, "project"),
+        open_tasks: countTasksByPredicate(db, (task) => isInitialTaskStatus(db, task)),
+        working_agents: countWhere(db, "agent", "status = 'working'"),
+        agent_runtimes: count(db, "agent_runtime"),
+        unread_inbox: countWhere(db, "inbox_message", "status = 'unread'"),
+      },
+    };
+  }
+
+  if (command === "/inbox") {
+    return {
+      type: "card",
+      title: "MAESTRO Inbox",
+      items: db.query("SELECT * FROM inbox_message WHERE to_actor = 'user' ORDER BY created_at DESC LIMIT 10").all() as any[],
+    };
+  }
+
+  if (command === "/workspaces") {
+    const workspaces = db.query("SELECT id, name, status FROM workspace WHERE status = 'active' ORDER BY created_at DESC LIMIT 10").all() as any[];
+    return {
+      type: "card",
+      title: "Active Workspaces",
+      items: workspaces.map(m => ({ body: `${m.name} (${m.id}) — ${m.status}` })),
+    };
+  }
+
+  if (command.startsWith("/agent ")) {
+    const query = command.slice(7).trim();
+    const agent = db.query("SELECT * FROM agent WHERE id = ? OR name LIKE ?").get(query, `%${query}%`) as any;
+    if (!agent) return { type: "card", title: "Agent Not Found", items: [{ body: `No agent matching: ${query}` }] };
+    return {
+      type: "card",
+      title: `Agent: ${agent.name}`,
+      fields: { status: agent.status, role_id: agent.role_id || "none", runtime: agent.runtime_id || "none" },
+    };
+  }
+
+  if (command === "/tasks" || command.startsWith("/tasks ")) {
+    const tasks = (db.query("SELECT id, title, status FROM task ORDER BY priority DESC, created_at ASC").all() as any[])
+      .filter((task) => isActiveTaskStatus(db, task))
+      .slice(0, 10);
+    return {
+      type: "card",
+      title: "Tasks",
+      items: tasks.map(t => ({ body: `[${t.status}] ${t.title} (${t.id})` })),
+    };
+  }
+
+  return {
+    type: "card",
+    title: "MAESTRO",
+    items: [{ body: "Commands: /status, /inbox, /workspaces, /agent <name>, /tasks" }],
+  };
+}
+
+export interface LarkWebhookOptions {
+  verificationToken?: string;
+}
+
+export async function handleLarkWebhook(db: Database, payload: any, opts: LarkWebhookOptions = {}): Promise<any> {
+  if (opts.verificationToken && payload.token && payload.token !== opts.verificationToken) {
+    return { error: "Invalid Lark verification token" };
+  }
+
+  if (payload.type === "url_verification") {
+    return { challenge: payload.challenge };
+  }
+
+  const text = extractLarkText(payload);
+  return handleLarkCommand(db, text);
+}
+
+export async function verifyLarkSignature(input: {
+  timestamp: string;
+  signature: string;
+  body: string;
+  secret: string;
+}): Promise<boolean> {
+  const key = await crypto.subtle.importKey(
+    "raw",
+    new TextEncoder().encode(`${input.timestamp}\n${input.secret}`),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"],
+  );
+  const digest = await crypto.subtle.sign("HMAC", key, new TextEncoder().encode(input.body));
+  const expected = Buffer.from(digest).toString("base64");
+  return timingSafeEqual(expected, input.signature);
+}
+
+export function handleLarkBatchInbox(db: Database, input: {
+  action: "read" | "reply";
+  ids: string[];
+  actor?: string;
+  body?: string;
+}) {
+  let updated = 0;
+  const ts = now();
+  for (const id of input.ids || []) {
+    const message = db.query("SELECT * FROM inbox_message WHERE id = ?").get(id) as any;
+    if (!message) continue;
+    if (input.action === "read") {
+      db.run("UPDATE inbox_message SET status = 'read', read_at = ? WHERE id = ?", [ts, id]);
+      updated++;
+    }
+    if (input.action === "reply") {
+      db.run(
+        `INSERT INTO inbox_message (id, kind, from_actor, to_actor, subject, body, ref_json, status, created_at)
+         VALUES (?, 'reply', ?, ?, ?, ?, ?, 'unread', ?)`,
+        [
+          generateId("msg"),
+          input.actor || "user",
+          message.from_actor,
+          message.subject,
+          input.body || "",
+          JSON.stringify({ reply_to: id }),
+          ts,
+        ],
+      );
+      db.run("UPDATE inbox_message SET status = 'replied' WHERE id = ?", [id]);
+      updated++;
+    }
+  }
+  return { updated };
+}
+
+export function buildLarkNotification(message: { kind: string; subject?: string; body?: string }) {
+  return {
+    msg_type: "interactive",
+    card: {
+      header: {
+        title: { tag: "plain_text", content: message.subject || `MAESTRO ${message.kind}` },
+      },
+      elements: [
+        {
+          tag: "div",
+          text: { tag: "lark_md", content: message.body || "" },
+        },
+      ],
+    },
+  };
+}
+
+export async function sendLarkNotification(input: {
+  webhook_url: string;
+  kind: string;
+  subject?: string;
+  body?: string;
+  fetchImpl?: typeof fetch;
+}) {
+  const payload = buildLarkNotification(input);
+  const fetcher = input.fetchImpl || fetch;
+  const res = await fetcher(input.webhook_url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(payload),
+  });
+  const response = await res.json().catch(() => ({}));
+  return { delivered: res.ok, status: res.status, response, payload };
+}
+
+function extractLarkText(payload: any): string {
+  const content = payload?.event?.message?.content;
+  if (typeof content === "string") {
+    try {
+      return JSON.parse(content).text || "";
+    } catch {
+      return content;
+    }
+  }
+  return payload.text || "";
+}
+
+function timingSafeEqual(a: string, b: string): boolean {
+  const left = Buffer.from(a);
+  const right = Buffer.from(b);
+  if (left.length !== right.length) return false;
+  return crypto.subtle ? constantTimeCompare(left, right) : a === b;
+}
+
+function constantTimeCompare(left: Buffer, right: Buffer): boolean {
+  let diff = 0;
+  for (let i = 0; i < left.length; i++) diff |= left[i] ^ right[i];
+  return diff === 0;
+}
+
+function count(db: Database, table: string): number {
+  return (db.query(`SELECT COUNT(*) AS count FROM ${table}`).get() as any).count;
+}
+
+function countWhere(db: Database, table: string, where: string): number {
+  return (db.query(`SELECT COUNT(*) AS count FROM ${table} WHERE ${where}`).get() as any).count;
+}

package/src/bridges/telegram/index.ts

@@ -0,0 +1,273 @@
+import type { Database } from "bun:sqlite";
+import { generateId, now } from "../../core/db";
+import { countTasksByPredicate, isActiveTaskStatus, isInitialTaskStatus } from "../../workflows";
+
+export interface TelegramApiCall {
+  method: "sendMessage";
+  payload: {
+    chat_id: number | string;
+    text: string;
+    parse_mode?: "Markdown";
+    disable_web_page_preview?: boolean;
+  };
+}
+
+export interface TelegramBridgeResult {
+  response?: TelegramApiCall;
+  bridged?: boolean; // true if message was forwarded to workspace chat
+}
+
+export function handleTelegramCommand(db: Database, text: string, chatId: number | string): TelegramApiCall {
+  const command = text.trim();
+
+  // /bind <workspace_name> — 绑定当前 group 到 workspace
+  if (command.startsWith("/bind ")) {
+    const wsName = command.slice(6).trim();
+    if (!wsName) {
+      return { method: "sendMessage", payload: buildTelegramMessage({ chat_id: chatId, subject: "Bind", body: "Usage: /bind <workspace_name>" }) };
+    }
+    const workspace = db.query("SELECT id, name FROM workspace WHERE LOWER(name) = LOWER(?) AND status = 'active'").get(wsName) as any;
+    if (!workspace) {
+      return { method: "sendMessage", payload: buildTelegramMessage({ chat_id: chatId, subject: "Bind Failed", body: `Workspace not found: ${wsName}` }) };
+    }
+    const ts = now();
+    db.run(
+      "INSERT OR REPLACE INTO telegram_binding (chat_id, workspace_id, bound_at) VALUES (?, ?, ?)",
+      [String(chatId), workspace.id, ts]
+    );
+    return { method: "sendMessage", payload: buildTelegramMessage({ chat_id: chatId, subject: "Bound", body: `This group is now linked to workspace: ${workspace.name}\n\n⚠️ To receive all messages, either:\n• Promote the bot to Group Admin, or\n• Disable Group Privacy via @BotFather (Bot Settings → Group Privacy → Turn off), then remove and re-add the bot` }) };
+  }
+
+  // /unbind — 解除绑定
+  if (command === "/unbind") {
+    db.run("DELETE FROM telegram_binding WHERE chat_id = ?", [String(chatId)]);
+    return { method: "sendMessage", payload: buildTelegramMessage({ chat_id: chatId, subject: "Unbound", body: "This group is no longer linked to any workspace." }) };
+  }
+
+  if (command === "/status") {
+    return {
+      method: "sendMessage",
+      payload: buildTelegramMessage({
+        chat_id: chatId,
+        subject: "MAESTRO Status",
+        body: [
+          `workspaces: ${count(db, "workspace")}`,
+          `projects: ${count(db, "project")}`,
+          `open_tasks: ${countTasksByPredicate(db, (task) => isInitialTaskStatus(db, task))}`,
+          `working_agents: ${countWhere(db, "agent", "status = 'working'")}`,
+          `agent_runtimes: ${count(db, "agent_runtime")}`,
+          `unread_inbox: ${countWhere(db, "inbox_message", "status = 'unread'")}`,
+        ].join("\n"),
+      }),
+    };
+  }
+
+  if (command === "/inbox") {
+    const rows = db.query("SELECT * FROM inbox_message WHERE to_actor = 'user' ORDER BY created_at DESC LIMIT 10").all() as any[];
+    return {
+      method: "sendMessage",
+      payload: buildTelegramMessage({
+        chat_id: chatId,
+        subject: "MAESTRO Inbox",
+        body: rows.length === 0
+          ? "No inbox messages."
+          : rows.map((row) => `- ${row.subject || row.kind}: ${row.body || ""}`).join("\n"),
+      }),
+    };
+  }
+
+  if (command === "/workspaces") {
+    const workspaces = db.query("SELECT id, name, status FROM workspace WHERE status = 'active' ORDER BY created_at DESC LIMIT 10").all() as any[];
+    return {
+      method: "sendMessage",
+      payload: buildTelegramMessage({
+        chat_id: chatId,
+        subject: "Active Workspaces",
+        body: workspaces.length === 0
+          ? "No active workspaces."
+          : workspaces.map(m => `- ${m.name} (${m.id}) — ${m.status}`).join("\n"),
+      }),
+    };
+  }
+
+  if (command.startsWith("/agent ")) {
+    const query = command.slice(7).trim();
+    const agent = db.query("SELECT * FROM agent WHERE id = ? OR name LIKE ?").get(query, `%${query}%`) as any;
+    if (!agent) {
+      return {
+        method: "sendMessage",
+        payload: buildTelegramMessage({
+          chat_id: chatId,
+          subject: "Agent Not Found",
+          body: `No agent matching: ${query}`,
+        }),
+      };
+    }
+    return {
+      method: "sendMessage",
+      payload: buildTelegramMessage({
+        chat_id: chatId,
+        subject: `Agent: ${agent.name}`,
+        body: `status: ${agent.status}\nrole_id: ${agent.role_id || "none"}\nruntime: ${agent.runtime_id || "none"}`,
+      }),
+    };
+  }
+
+  if (command === "/tasks" || command.startsWith("/tasks ")) {
+    const tasks = (db.query("SELECT id, title, status FROM task ORDER BY priority DESC, created_at ASC").all() as any[])
+      .filter((task) => isActiveTaskStatus(db, task))
+      .slice(0, 10);
+    return {
+      method: "sendMessage",
+      payload: buildTelegramMessage({
+        chat_id: chatId,
+        subject: "Tasks",
+        body: tasks.length === 0
+          ? "No active tasks."
+          : tasks.map(t => `[${t.status}] ${t.title} (${t.id})`).join("\n"),
+      }),
+    };
+  }
+
+  return {
+    method: "sendMessage",
+    payload: buildTelegramMessage({
+      chat_id: chatId,
+      subject: "MAESTRO",
+      body: "Commands: /bind <workspace>, /unbind, /status, /inbox, /workspaces, /agent <name>, /tasks",
+    }),
+  };
+}
+
+export function handleTelegramWebhook(
+  db: Database,
+  payload: any,
+  opts: { secretToken?: string; requestToken?: string } = {},
+) {
+  if (opts.secretToken && opts.requestToken !== opts.secretToken) {
+    return { ok: false, error: "Invalid Telegram secret token" };
+  }
+  const chatId = payload?.message?.chat?.id || payload?.edited_message?.chat?.id;
+  const text = payload?.message?.text || payload?.edited_message?.text || "";
+  if (!chatId) return { ok: false, error: "Missing Telegram chat id" };
+  return { ok: true, response: handleTelegramCommand(db, text, chatId) };
+}
+
+export function handleTelegramBatchInbox(db: Database, input: {
+  action: "read" | "reply";
+  ids: string[];
+  actor?: string;
+  body?: string;
+}) {
+  let updated = 0;
+  const ts = now();
+  for (const id of input.ids || []) {
+    const message = db.query("SELECT * FROM inbox_message WHERE id = ?").get(id) as any;
+    if (!message) continue;
+    if (input.action === "read") {
+      db.run("UPDATE inbox_message SET status = 'read', read_at = ? WHERE id = ?", [ts, id]);
+      updated++;
+    }
+    if (input.action === "reply") {
+      db.run(
+        `INSERT INTO inbox_message (id, kind, from_actor, to_actor, subject, body, ref_json, status, created_at)
+         VALUES (?, 'reply', ?, ?, ?, ?, ?, 'unread', ?)`,
+        [
+          generateId("msg"),
+          input.actor || "user",
+          message.from_actor,
+          message.subject,
+          input.body || "",
+          JSON.stringify({ reply_to: id }),
+          ts,
+        ],
+      );
+      db.run("UPDATE inbox_message SET status = 'replied' WHERE id = ?", [id]);
+      updated++;
+    }
+  }
+  return { updated };
+}
+
+export function buildTelegramMessage(input: { chat_id: number | string; subject?: string; body?: string }) {
+  return {
+    chat_id: input.chat_id,
+    text: `*${escapeMarkdown(input.subject || "MAESTRO")}*\n${escapeMarkdown(input.body || "")}`,
+    parse_mode: "Markdown" as const,
+    disable_web_page_preview: true,
+  };
+}
+
+export async function sendTelegramNotification(input: {
+  bot_token: string;
+  chat_id: number | string;
+  subject?: string;
+  body?: string;
+  api_base?: string;
+  fetchImpl?: typeof fetch;
+}) {
+  const payload = buildTelegramMessage(input);
+  const base = (input.api_base || "https://api.telegram.org").replace(/\/$/, "");
+  const fetcher = input.fetchImpl || fetch;
+  const res = await fetcher(`${base}/bot${input.bot_token}/sendMessage`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(payload),
+  });
+  const response = await res.json().catch(() => ({}));
+  return { delivered: res.ok && response.ok !== false, status: res.status, response, payload };
+}
+
+function escapeMarkdown(text: string): string {
+  return text.replace(/([_*[\]()~`>#+\-=|{}.!])/g, "\\$1");
+}
+
+function count(db: Database, table: string): number {
+  return (db.query(`SELECT COUNT(*) AS count FROM ${table}`).get() as any).count;
+}
+
+function countWhere(db: Database, table: string, where: string): number {
+  return (db.query(`SELECT COUNT(*) AS count FROM ${table} WHERE ${where}`).get() as any).count;
+}
+
+// ─── Workspace Chat Bridge ───────────────────────────────────────────────────
+
+/**
+ * Look up workspace binding for a Telegram chat.
+ */
+export function getBindingForChat(db: Database, chatId: number | string): { workspace_id: string } | null {
+  return db.query("SELECT workspace_id FROM telegram_binding WHERE chat_id = ?").get(String(chatId)) as any || null;
+}
+
+/**
+ * Check if a message is a command (starts with /).
+ */
+export function isTelegramCommand(text: string): boolean {
+  return text.trim().startsWith("/");
+}
+
+/**
+ * Push an agent reply back to the bound TG group.
+ */
+export async function pushAgentReplyToTelegram(input: {
+  bot_token: string;
+  chat_id: string;
+  sender_id: string;
+  content: string;
+  api_base?: string;
+  fetchImpl?: typeof fetch;
+}) {
+  const text = `🤖 *${escapeMarkdown(input.sender_id)}*\n${escapeMarkdown(input.content)}`;
+  const base = (input.api_base || "https://api.telegram.org").replace(/\/$/, "");
+  const fetcher = input.fetchImpl || fetch;
+  await fetcher(`${base}/bot${input.bot_token}/sendMessage`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      chat_id: input.chat_id,
+      text,
+      parse_mode: "Markdown",
+      disable_web_page_preview: true,
+    }),
+  }).catch(() => {});
+}