maestro-agent 0.0.1 → 0.0.3

package/src/bridges/telegram/polling.ts

@@ -0,0 +1,185 @@
+/**
+ * Telegram Long Polling Gateway
+ *
+ * 主动轮询 Telegram getUpdates API，无需 webhook、无需公网地址。
+ * 本地 NAT/防火墙后也能正常工作。
+ */
+
+import type { HubContext } from "../../core/server";
+import { getConfig } from "../../api/config";
+import {
+  getBindingForChat,
+  handleTelegramCommand,
+  isTelegramCommand,
+  pushAgentReplyToTelegram,
+} from "./index";
+import { insertChatMessage, runAgentLoop } from "../../api/chat";
+
+const TG_API = "https://api.telegram.org";
+
+interface TelegramPollingOptions {
+  botToken: string;
+  pollingInterval?: number; // ms between polls when no updates, default 1000
+  timeout?: number; // long-poll timeout in seconds, default 30
+}
+
+export class TelegramPollingGateway {
+  private botToken: string;
+  private ctx: HubContext;
+  private offset = 0;
+  private running = false;
+  private timeout: number;
+  private pollingInterval: number;
+  private abortController: AbortController | null = null;
+
+  constructor(ctx: HubContext, options: TelegramPollingOptions) {
+    this.ctx = ctx;
+    this.botToken = options.botToken;
+    this.timeout = options.timeout ?? 30;
+    this.pollingInterval = options.pollingInterval ?? 1000;
+  }
+
+  start() {
+    if (this.running) return;
+    this.running = true;
+    console.log("[telegram-polling] Gateway started, polling for updates...");
+    this.poll();
+  }
+
+  stop() {
+    this.running = false;
+    this.abortController?.abort();
+    console.log("[telegram-polling] Gateway stopped.");
+  }
+
+  private async poll() {
+    if (!this.running) return;
+    try {
+      const updates = await this.getUpdates();
+      for (const update of updates) {
+        this.offset = update.update_id + 1;
+        await this.handleUpdate(update).catch((err) => {
+          console.error("[telegram-polling] Error handling update:", err.message);
+        });
+      }
+    } catch (err: any) {
+      if (!this.running) return;
+      console.error("[telegram-polling] Poll error:", err.message);
+      await sleep(this.pollingInterval * 3);
+    }
+    if (this.running) {
+      setTimeout(() => this.poll(), 0);
+    }
+  }
+
+  private async getUpdates(): Promise<any[]> {
+    this.abortController = new AbortController();
+    const url = `${TG_API}/bot${this.botToken}/getUpdates?offset=${this.offset}&timeout=${this.timeout}&allowed_updates=["message","edited_message"]`;
+    const res = await fetch(url, {
+      signal: this.abortController.signal,
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`Telegram API ${res.status}: ${text}`);
+    }
+    const data = await res.json() as any;
+    if (!data.ok) throw new Error(`Telegram error: ${data.description}`);
+    return data.result || [];
+  }
+
+  private async handleUpdate(update: any) {
+    const msg = update.message || update.edited_message;
+    if (!msg?.text) return;
+
+    const chatId = msg.chat?.id;
+    const text = msg.text;
+    if (!chatId) return;
+
+    // Slash command
+    if (isTelegramCommand(text)) {
+      const response = handleTelegramCommand(this.ctx.db, text, chatId);
+      await this.sendResponse(response);
+      return;
+    }
+
+    // Non-command: check workspace binding
+    const binding = getBindingForChat(this.ctx.db, chatId);
+    if (binding) {
+      // Bridge to workspace chat
+      const humanMsg = insertChatMessage(this.ctx, binding.workspace_id, "human", "telegram", text);
+      this.ctx.bus.publish("chat.message", {
+        workspace_id: binding.workspace_id,
+        message_id: humanMsg.id,
+        seq: humanMsg.seq,
+        sender_type: "human",
+        source: "telegram",
+        tg_chat_id: String(chatId),
+      });
+
+      // Trigger agent loop (non-blocking)
+      runAgentLoop(this.ctx, binding.workspace_id).catch((err) => {
+        console.error(`[telegram-polling] agent loop error for ${binding.workspace_id}:`, err.message);
+      });
+      return;
+    }
+
+    // Not bound, show help
+    const response = handleTelegramCommand(this.ctx.db, text, chatId);
+    await this.sendResponse(response);
+  }
+
+  private async sendResponse(response: any) {
+    if (!response?.payload) return;
+    await fetch(`${TG_API}/bot${this.botToken}/${response.method}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(response.payload),
+    }).catch((err) => {
+      console.error("[telegram-polling] Send error:", err.message);
+    });
+  }
+}
+
+/**
+ * 启动 Telegram polling gateway（如果配置了 BOT_TOKEN）。
+ * 同时注册 agent reply push-back 监听。
+ */
+export function startTelegramPolling(ctx: HubContext): TelegramPollingGateway | null {
+  const botToken = getConfig(ctx, "telegram_bot_token") || process.env.MAESTRO_TELEGRAM_BOT_TOKEN;
+  if (!botToken) {
+    return null;
+  }
+
+  const gateway = new TelegramPollingGateway(ctx, { botToken });
+  gateway.start();
+
+  // Push agent replies back to TG
+  ctx.bus.on("chat.message", async (event: any) => {
+    if (event.sender_type !== "agent") return;
+    if (event.source === "telegram") return;
+
+    const workspaceId = event.workspace_id;
+    if (!workspaceId) return;
+
+    const binding = ctx.db.query("SELECT chat_id FROM telegram_binding WHERE workspace_id = ?").get(workspaceId) as any;
+    if (!binding) return;
+
+    const msg = event.message_id
+      ? ctx.db.query("SELECT content, sender_id FROM chat_message WHERE id = ?").get(event.message_id) as any
+      : null;
+    if (!msg?.content) return;
+
+    await pushAgentReplyToTelegram({
+      bot_token: botToken,
+      chat_id: binding.chat_id,
+      sender_id: msg.sender_id || "MAESTRO",
+      content: msg.content,
+    });
+  });
+
+  return gateway;
+}
+
+function sleep(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/chat/index.ts

@@ -0,0 +1,86 @@
+import { getDb, generateId, now } from "../core/db";
+
+export interface ChatCommandOptions {
+  hubDir: string;
+}
+
+export interface ChatCommandResult {
+  status: number;
+  stdout: string;
+  stderr: string;
+}
+
+export async function runChatCommand(args: string[], opts: ChatCommandOptions): Promise<ChatCommandResult> {
+  const jsonMode = hasFlag(args, "--json");
+  const command = args[0];
+
+  try {
+    if (command === "send") {
+      const workspaceId = args[1];
+      if (!workspaceId) return fail("Usage: maestro chat send <workspace_id> <message>");
+      const content = args.slice(2).filter(a => !a.startsWith("--")).join(" ");
+      if (!content) return fail("Usage: maestro chat send <workspace_id> <message>");
+
+      const hubUrl = process.env.MAESTRO_HUB_URL || "http://localhost:7423";
+      const resp = await fetch(`${hubUrl}/api/chat/messages`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ workspace_id: workspaceId, content }),
+      });
+      if (!resp.ok) {
+        const err = await resp.json().catch(() => ({ error: resp.statusText }));
+        return fail((err as any).error || `HTTP ${resp.status}`);
+      }
+      const msg = await resp.json() as any;
+      return ok(msg, jsonMode, `sent ${msg.id} (agent will respond asynchronously)`);
+    }
+
+    if (command === "history") {
+      const workspaceId = args[1];
+      if (!workspaceId) return fail("Usage: maestro chat history <workspace_id>");
+      const limit = Number(flagValue(args, "--limit") || "20");
+
+      const hubUrl = process.env.MAESTRO_HUB_URL || "http://localhost:7423";
+      const url = `${hubUrl}/api/chat/messages?workspace_id=${encodeURIComponent(workspaceId)}&limit=${limit}`;
+      const resp = await fetch(url);
+      if (!resp.ok) return fail(`HTTP ${resp.status}`);
+      const messages = await resp.json() as any[];
+      return ok(messages, jsonMode, renderMessages(messages));
+    }
+
+    return fail(`Unknown command: ${command || ""}\nUsage: maestro chat <send|history> ...`);
+  } catch (err: any) {
+    return fail(err.message);
+  }
+}
+
+function renderMessages(messages: any[]): string {
+  if (!messages || messages.length === 0) return "no messages";
+  return messages.map((m) => {
+    const time = new Date(m.created_at).toLocaleTimeString();
+    const role = m.sender_type === "human" ? "you" : "agent";
+    return `[${time}] ${role}: ${m.content}`;
+  }).join("\n");
+}
+
+function flagValue(args: string[], flag: string): string | undefined {
+  const index = args.indexOf(flag);
+  if (index === -1) return undefined;
+  return args[index + 1];
+}
+
+function hasFlag(args: string[], flag: string): boolean {
+  return args.includes(flag);
+}
+
+function ok(data: unknown, jsonMode: boolean, text: string): ChatCommandResult {
+  return {
+    status: 0,
+    stdout: jsonMode ? `${JSON.stringify(data)}\n` : `${text}\n`,
+    stderr: "",
+  };
+}
+
+function fail(message: string): ChatCommandResult {
+  return { status: 1, stdout: "", stderr: `${message}\n` };
+}