maestro-agent 0.0.1 → 0.0.3

package/src/core/server.ts

@@ -0,0 +1,308 @@
+import { Database } from "bun:sqlite";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { registerAgentRoutes } from "../api/agents";
+import { registerAuditRoutes } from "../api/audit";
+import { registerAutopilotRoutes, initAutopilot } from "../api/autopilot";
+import { registerChatRoutes } from "../api/chat";
+import { registerChiefRoutes } from "../api/chief";
+import { getConfig, registerConfigRoutes } from "../api/config";
+import { registerGanttRoutes } from "../api/gantt";
+import { registerHookRoutes } from "../api/hooks";
+import { registerInboxRoutes } from "../api/inbox";
+import { registerLarkRoutes } from "../api/lark";
+import { registerMemoryRoutes } from "../api/memory";
+import { registerOpsRoutes } from "../api/ops";
+import { registerProjectRoutes } from "../api/projects";
+import { registerRoleRoutes } from "../api/roles";
+import { registerRuntimeRoutes } from "../api/runtimes";
+import { registerScheduledTaskRoutes } from "../api/scheduled-tasks";
+import { registerSessionRoutes } from "../api/sessions";
+import { registerSkillRoutes } from "../api/skills";
+import { registerTaskRoutes } from "../api/tasks";
+import { registerTelegramRoutes } from "../api/telegram";
+import { registerTemplateRoutes } from "../api/templates";
+import { registerWebhookRoutes } from "../api/webhooks";
+import { registerWorkspaceRoutes } from "../api/workspaces";
+import { createClaudePlanner, runChiefHeartbeat } from "../chief";
+import { registerDiscoveredRuntimes } from "../discovery";
+import { startGateway } from "../gateway";
+import { recoverInterruptedSessions } from "../ops";
+import { createSessionQueue, startRuntimeScheduler, type SessionQueue } from "../ops/runtime-scheduler";
+import { reloadRolesIfChanged } from "../roles";
+import { runDueScheduledTasks } from "../scheduler";
+import { ensureBuiltinSkills } from "../skills/builtin";
+import { ensureDefaultWorkflow } from "../workflows";
+import { getDb, initSchema } from "./db";
+import { EventBus } from "./event-bus";
+import { Router, json } from "./router";
+
+interface EventClient {
+  ws: any;
+  filters: string[]; // glob patterns, empty = all
+}
+
+export interface HubContext {
+  db: Database;
+  bus: EventBus;
+  hubDir: string;
+  workspaceRoot: string;
+  port: number;
+  sessions: Map<string, any>; // sessionId → PtyProcess
+  wsClients: Map<string, Set<any>>; // sessionId → Set<ws>
+  eventClients: Set<EventClient>; // /space/events subscribers
+  sessionQueue: SessionQueue; // runtimeId → waiting queue
+}
+
+export async function startServer(hubDir: string, port = 7423) {
+  const db = getDb(hubDir);
+  initSchema(db, hubDir);
+  ensureBuiltinSkills(db, hubDir, { sync: false });
+  ensureDefaultWorkflow(db);
+  recoverInterruptedSessions(db);
+
+  // Auto-discover and register local agent CLIs on startup
+  registerDiscoveredRuntimes(db).catch(() => {});
+
+  const bus = new EventBus(db);
+  const ctx: HubContext = {
+    db,
+    bus,
+    hubDir,
+    workspaceRoot: process.cwd(),
+    port,
+    sessions: new Map(),
+    wsClients: new Map(),
+    eventClients: new Set(),
+    sessionQueue: createSessionQueue(),
+  };
+
+  // Wire EventBus → WebSocket broadcast
+  bus.setBroadcast((type, payload, ts) => {
+    const msg = JSON.stringify({ type, payload, ts });
+    for (const client of ctx.eventClients) {
+      if (client.filters.length === 0 || client.filters.some((f) => matchGlob(f, type))) {
+        try { client.ws.send(msg); } catch {}
+      }
+    }
+
+    // Forward to configured IM bridges
+    if (type.startsWith("inbox.")) {
+      const larkUrl = (db.query("SELECT value FROM config WHERE key = 'lark_webhook_url'").get() as any)?.value;
+      if (larkUrl) {
+        import("../bridges/lark").then(({ sendLarkNotification }) => {
+          sendLarkNotification({ webhook_url: larkUrl, kind: type, body: JSON.stringify(payload) }).catch(() => {});
+        });
+      }
+    }
+  });
+
+  const router = new Router();
+  const rolesDir = join(hubDir, "roles");
+  const roleReloadState = { signature: "" };
+  reloadRolesIfChanged(db, rolesDir, roleReloadState);
+  const roleReloadTimer = setInterval(() => {
+    reloadRolesIfChanged(db, rolesDir, roleReloadState);
+  }, 5000);
+  roleReloadTimer.unref?.();
+
+  // 注册 API 路由
+  registerWorkspaceRoutes(router, ctx);
+  registerProjectRoutes(router, ctx);
+  registerTaskRoutes(router, ctx);
+  registerAgentRoutes(router, ctx);
+  registerRuntimeRoutes(router, ctx);
+  registerSessionRoutes(router, ctx);
+  registerMemoryRoutes(router, ctx);
+  registerChatRoutes(router, ctx);
+  registerInboxRoutes(router, ctx);
+  registerHookRoutes(router, ctx);
+  registerAuditRoutes(router, ctx);
+  registerRoleRoutes(router, ctx);
+  registerChiefRoutes(router, ctx);
+  registerLarkRoutes(router, ctx);
+  registerTelegramRoutes(router, ctx);
+  registerOpsRoutes(router, ctx);
+  registerWebhookRoutes(router, ctx);
+  registerConfigRoutes(router, ctx);
+  registerGanttRoutes(router, ctx);
+  registerTemplateRoutes(router, ctx);
+  registerSkillRoutes(router, ctx);
+  registerScheduledTaskRoutes(router, ctx);
+  registerAutopilotRoutes(router, ctx);
+
+  // 静态文件目录
+  const webDistDir = join(import.meta.dir, "../../dist/web");
+
+  const listenPort = port === 0 ? await getAvailablePort() : port;
+  const server = Bun.serve({
+    port: listenPort,
+    async fetch(req, server) {
+      const url = new URL(req.url);
+
+      // WebSocket upgrade
+      if (url.pathname === "/space/events" || url.pathname.startsWith("/space/sessions/")) {
+        if (url.pathname === "/space/events") {
+          const filter = url.searchParams.get("filter") || "";
+          const filters = filter ? filter.split(",").map((f) => f.trim()) : [];
+          const upgraded = server.upgrade(req, { data: { kind: "events", filters } as any });
+          if (upgraded) return undefined as any;
+          return json({ error: "WebSocket upgrade failed" }, 400);
+        }
+        const sessionId = url.pathname.replace("/space/sessions/", "");
+        const upgraded = server.upgrade(req, { data: { kind: "session", sessionId } as any });
+        if (upgraded) return undefined as any;
+        return json({ error: "WebSocket upgrade failed" }, 400);
+      }
+
+      // REST API
+      if (url.pathname.startsWith("/api/")) {
+        return router.handle(req);
+      }
+
+      // 静态文件
+      let filePath = join(webDistDir, url.pathname === "/" ? "index.html" : url.pathname);
+      if (!existsSync(filePath)) {
+        filePath = join(webDistDir, "index.html"); // SPA fallback
+      }
+      if (existsSync(filePath)) {
+        return new Response(Bun.file(filePath));
+      }
+
+      return json({ error: "Not found" }, 404);
+    },
+    websocket: {
+      open(ws) {
+        const data = ws.data as any;
+        if (data.kind === "events") {
+          const client: EventClient = { ws, filters: data.filters || [] };
+          (ws as any)._eventClient = client;
+          ctx.eventClients.add(client);
+          return;
+        }
+        const { sessionId } = data;
+        if (!ctx.wsClients.has(sessionId)) {
+          ctx.wsClients.set(sessionId, new Set());
+        }
+        ctx.wsClients.get(sessionId)!.add(ws);
+        replaySession(ws, ctx, sessionId);
+      },
+      message(ws, msg) {
+        const data = ws.data as any;
+        if (data.kind === "events") return; // events ws is read-only for clients
+        const { sessionId } = data;
+        try {
+          const parsed = JSON.parse(msg as string);
+          if (parsed.type === "stdin") {
+            const proc = ctx.sessions.get(sessionId);
+            if (proc?.stdin) {
+              proc.stdin.write(parsed.data);
+            }
+          }
+        } catch {}
+      },
+      close(ws) {
+        const data = ws.data as any;
+        if (data.kind === "events") {
+          const client = (ws as any)._eventClient;
+          if (client) ctx.eventClients.delete(client);
+          return;
+        }
+        const { sessionId } = data;
+        ctx.wsClients.get(sessionId)?.delete(ws);
+      },
+    },
+  });
+
+  console.log(`🎼 MAESTRO Hub running at http://localhost:${server.port}`);
+
+  // Chief heartbeat auto-start (configurable, default 15 min, PRD §8.2)
+  const chiefIntervalMin = Number(getConfig(ctx, "chief_interval_min", "15"));
+  const chiefIntervalMs = Math.max(5, Math.min(60, chiefIntervalMin)) * 60 * 1000;
+
+  function buildChiefOpts() {
+    const apiKey = getConfig(ctx, "chief_api_key", "") || process.env.ANTHROPIC_API_KEY || "";
+    if (!apiKey) return {};
+    const baseURL = getConfig(ctx, "chief_base_url", "") || process.env.MAESTRO_CHIEF_BASE_URL || "";
+    const model = getConfig(ctx, "chief_model", "") || undefined;
+    return { planner: createClaudePlanner({ apiKey, baseURL: baseURL || undefined, model }) };
+  }
+
+  const chiefTimer = setInterval(async () => {
+    try { await runChiefHeartbeat(db, buildChiefOpts()); } catch (err) {
+      console.error("[chief] heartbeat error:", err);
+    }
+  }, chiefIntervalMs);
+  chiefTimer.unref?.();
+
+  // First heartbeat 30s after startup
+  const chiefInitialTimer = setTimeout(async () => {
+    try { await runChiefHeartbeat(db, buildChiefOpts()); } catch (err) {
+      console.error("[chief] initial heartbeat error:", err);
+    }
+  }, 30_000);
+  (chiefInitialTimer as any).unref?.();
+
+  const scheduledTaskTimer = setInterval(async () => {
+    try { await runDueScheduledTasks(ctx); } catch (err) {
+      console.error("[scheduler] scheduled task error:", err);
+    }
+  }, 30_000);
+  scheduledTaskTimer.unref?.();
+
+  const scheduledTaskInitialTimer = setTimeout(async () => {
+    try { await runDueScheduledTasks(ctx); } catch (err) {
+      console.error("[scheduler] initial scheduled task error:", err);
+    }
+  }, 5_000);
+  (scheduledTaskInitialTimer as any).unref?.();
+
+  const runtimeScheduler = startRuntimeScheduler(ctx);
+
+  // Autopilot: subsumes cron + scheduled task + auto-dispatch
+  const autopilot = initAutopilot(ctx);
+
+  // Telegram long-polling gateway (no webhook needed)
+  const gateway = await startGateway(ctx);
+
+  const originalStop = server.stop.bind(server);
+  server.stop = ((closeActiveConnections?: boolean) => {
+    clearInterval(roleReloadTimer);
+    clearInterval(chiefTimer);
+    clearTimeout(chiefInitialTimer);
+    clearInterval(scheduledTaskTimer);
+    clearTimeout(scheduledTaskInitialTimer);
+    runtimeScheduler.stop();
+    autopilot.stop();
+    gateway?.disconnectAll();
+    return originalStop(closeActiveConnections);
+  }) as typeof server.stop;
+  return server;
+}
+
+function replaySession(ws: any, ctx: HubContext, sessionId: string) {
+  const session = ctx.db.query("SELECT * FROM session WHERE id = ?").get(sessionId) as any;
+  if (!session) {
+    ws.send(JSON.stringify({ type: "error", error: "Session not found" }));
+    return;
+  }
+
+  if (session.transcript_path && existsSync(session.transcript_path)) {
+    const data = readFileSync(session.transcript_path, "utf-8");
+    if (data) ws.send(JSON.stringify({ type: "stdout", data }));
+  }
+
+  if (session.status === "ended") {
+    ws.send(JSON.stringify({ type: "exit", code: null }));
+  }
+}
+
+function getAvailablePort(): Promise<number> {
+  return Promise.resolve(18000 + Math.floor(Math.random() * 20000));
+}
+
+/** Simple glob match: supports "task.*" → matches "task.done", "task.created" etc. */
+function matchGlob(pattern: string, value: string): boolean {
+  const regex = new RegExp("^" + pattern.replace(/\./g, "\\.").replace(/\*/g, ".*") + "$");
+  return regex.test(value);
+}

package/src/core/validate.ts

@@ -0,0 +1,22 @@
+/**
+ * 简单的请求体校验工具
+ */
+export class ValidationError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "ValidationError";
+  }
+}
+
+export function required(obj: Record<string, any>, fields: string[]): void {
+  const missing = fields.filter(f => obj[f] === undefined || obj[f] === null || obj[f] === "");
+  if (missing.length > 0) {
+    throw new ValidationError(`Missing required fields: ${missing.join(", ")}`);
+  }
+}
+
+export function oneOf(value: string, allowed: string[], fieldName: string): void {
+  if (!allowed.includes(value)) {
+    throw new ValidationError(`${fieldName} must be one of: ${allowed.join(", ")}`);
+  }
+}

package/src/discovery/index.ts

@@ -0,0 +1,194 @@
+import type { Database } from "bun:sqlite";
+import { accessSync, constants, existsSync, statSync } from "fs";
+import { join } from "path";
+import { generateId, now } from "../core/db";
+
+export interface DiscoveredRuntime {
+  type: string;
+  cmd: string;
+  version: string | null;
+  model: string | null;
+  status: "ready" | "not_installed";
+}
+
+export interface RegisteredRuntime {
+  id: string;
+  type: string;
+  cmd: string;
+  version: string | null;
+  model: string | null;
+}
+
+export interface RuntimeRegistrationResult {
+  discovered: DiscoveredRuntime[];
+  added: RegisteredRuntime[];
+  skipped: DiscoveredRuntime[];
+}
+
+interface CandidateSpec {
+  type: string;
+  commands: string[];
+  versionArgs: string[];
+  pathEnv: string;    // e.g. MAESTRO_CLAUDE_PATH
+  modelEnv: string;   // e.g. MAESTRO_CLAUDE_MODEL
+}
+
+const CANDIDATES: CandidateSpec[] = [
+  { type: "claude-code", commands: ["claude", "claude-code"], versionArgs: ["--version"], pathEnv: "MAESTRO_CLAUDE_PATH", modelEnv: "MAESTRO_CLAUDE_MODEL" },
+  { type: "codex", commands: ["codex"], versionArgs: ["--version"], pathEnv: "MAESTRO_CODEX_PATH", modelEnv: "MAESTRO_CODEX_MODEL" },
+  { type: "gemini", commands: ["gemini"], versionArgs: ["--version"], pathEnv: "MAESTRO_GEMINI_PATH", modelEnv: "MAESTRO_GEMINI_MODEL" },
+  { type: "opencode", commands: ["opencode"], versionArgs: ["--version"], pathEnv: "MAESTRO_OPENCODE_PATH", modelEnv: "MAESTRO_OPENCODE_MODEL" },
+  { type: "openclaw", commands: ["openclaw"], versionArgs: ["--version"], pathEnv: "MAESTRO_OPENCLAW_PATH", modelEnv: "MAESTRO_OPENCLAW_MODEL" },
+  { type: "hermes", commands: ["hermes"], versionArgs: ["--version"], pathEnv: "MAESTRO_HERMES_PATH", modelEnv: "MAESTRO_HERMES_MODEL" },
+  { type: "blade", commands: ["blade"], versionArgs: ["--version"], pathEnv: "MAESTRO_BLADE_PATH", modelEnv: "MAESTRO_BLADE_MODEL" },
+  { type: "cursor", commands: ["cursor-agent"], versionArgs: ["--version"], pathEnv: "MAESTRO_CURSOR_PATH", modelEnv: "MAESTRO_CURSOR_MODEL" },
+  { type: "kimi", commands: ["kimi"], versionArgs: ["--version"], pathEnv: "MAESTRO_KIMI_PATH", modelEnv: "MAESTRO_KIMI_MODEL" },
+  { type: "kiro", commands: ["kiro-cli"], versionArgs: ["--version"], pathEnv: "MAESTRO_KIRO_PATH", modelEnv: "MAESTRO_KIRO_MODEL" },
+  { type: "aider", commands: ["aider"], versionArgs: ["--version"], pathEnv: "MAESTRO_AIDER_PATH", modelEnv: "MAESTRO_AIDER_MODEL" },
+];
+
+const TYPE_ALIASES: Record<string, string[]> = {
+  "claude-code": ["claude", "claude-code"],
+};
+
+function getFullPath(): string {
+  const base = process.env.PATH || "";
+  const home = process.env.HOME || "";
+  const extras = [
+    `${home}/.nvm/versions/node/current/bin`,
+    `${home}/.volta/bin`,
+    `${home}/.bun/bin`,
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+  ];
+  return [...new Set([...base.split(":"), ...extras])].join(":");
+}
+
+async function which(cmd: string): Promise<string | null> {
+  let bunPath: string | null = null;
+  try {
+    bunPath = Bun.which(cmd);
+  } catch {
+    bunPath = null;
+  }
+
+  const path = findInPath(cmd, getFullPath());
+  return path ?? bunPath;
+}
+
+function findInPath(cmd: string, pathValue: string): string | null {
+  for (const dir of pathValue.split(":")) {
+    if (!dir) continue;
+    const candidate = join(dir, cmd);
+    try {
+      if (!existsSync(candidate) || !statSync(candidate).isFile()) continue;
+      accessSync(candidate, constants.X_OK);
+      return candidate;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
+async function getVersion(cmd: string, args: string[]): Promise<string | null> {
+  try {
+    const env = { ...process.env, PATH: getFullPath() };
+    const proc = Bun.spawn([cmd, ...args], {
+      stdout: "pipe",
+      stderr: "pipe",
+      env,
+      signal: AbortSignal.timeout(2000),
+    });
+    const [code, stdout, stderr] = await Promise.all([
+      proc.exited,
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+    ]);
+    const text = `${stdout}\n${stderr}`.trim();
+    if (code === 0 && text) return text.split("\n")[0].trim();
+  } catch {
+    // Version probing is best-effort; PATH discovery is the source of truth.
+  }
+  return null;
+}
+
+export async function discoverRuntimes(): Promise<DiscoveredRuntime[]> {
+  const results: DiscoveredRuntime[] = [];
+
+  for (const c of CANDIDATES) {
+    const model = process.env[c.modelEnv]?.trim() || null;
+
+    // Priority 1: explicit path from env var
+    const envPath = process.env[c.pathEnv]?.trim();
+    if (envPath) {
+      const version = await getVersion(envPath, c.versionArgs);
+      results.push({ type: c.type, cmd: envPath, version, model, status: "ready" });
+      continue;
+    }
+
+    // Priority 2: search PATH for known command names
+    for (const command of c.commands) {
+      const path = await which(command);
+      if (!path) continue;
+
+      const version = await getVersion(path, c.versionArgs);
+      results.push({ type: c.type, cmd: path, version, model, status: "ready" });
+      break;
+    }
+  }
+
+  return results;
+}
+
+export async function registerDiscoveredRuntimes(
+  db: Database,
+  discovered?: DiscoveredRuntime[]
+): Promise<RuntimeRegistrationResult> {
+  discovered = discovered ?? (await discoverRuntimes());
+  const rows = db.query("SELECT type, cmd FROM agent_runtime").all() as { type: string; cmd: string | null }[];
+  const existingTypes = new Set(rows.map((row) => row.type));
+  const existingCmds = new Set(rows.map((row) => row.cmd).filter(Boolean));
+  const added: RegisteredRuntime[] = [];
+  const skipped: DiscoveredRuntime[] = [];
+  const ts = now();
+
+  for (const runtime of discovered) {
+    const typeAliases = TYPE_ALIASES[runtime.type] ?? [runtime.type];
+    if (typeAliases.some((type) => existingTypes.has(type)) || existingCmds.has(runtime.cmd)) {
+      skipped.push(runtime);
+      continue;
+    }
+
+    const id = generateId("runtime");
+    const capabilities = runtime.model ? JSON.stringify([`model:${runtime.model}`]) : "[]";
+    db.run(
+      "INSERT INTO agent_runtime (id, type, transport, cmd, version, capacity, status, capabilities_json, created_at) VALUES (?, ?, 'local-pty', ?, ?, -1, 'online', ?, ?)",
+      [id, runtime.type, runtime.cmd, runtime.version, capabilities, ts]
+    );
+    existingTypes.add(runtime.type);
+    existingCmds.add(runtime.cmd);
+    added.push({
+      id,
+      type: runtime.type,
+      cmd: runtime.cmd,
+      version: runtime.version,
+      model: runtime.model,
+    });
+  }
+
+  return {
+    discovered,
+    added,
+    skipped,
+  };
+}
+
+export function formatRuntimeList(runtimes: Pick<DiscoveredRuntime, "type" | "cmd" | "version" | "model">[]): string[] {
+  return runtimes.map((runtime) => {
+    let label = `${runtime.type} -> ${runtime.cmd}`;
+    if (runtime.version) label += ` (${runtime.version})`;
+    if (runtime.model) label += ` [model: ${runtime.model}]`;
+    return label;
+  });
+}

package/src/gateway/adapters/telegram.ts

@@ -0,0 +1,148 @@
+/**
+ * Telegram Platform Adapter
+ *
+ * 实现 PlatformAdapter 接口，使用 Long Polling 模式。
+ * 无需 webhook、无需公网地址，本地 NAT/防火墙后也能正常工作。
+ */
+
+import type { InboundMessage, MessageHandler, PlatformAdapter, SendOptions, SendResult } from "../../gateway/types";
+
+const TG_API = "https://api.telegram.org";
+
+interface TelegramAdapterOptions {
+  botToken: string;
+  pollingTimeout?: number; // long-poll timeout in seconds, default 30
+  onMessage: MessageHandler;
+}
+
+export class TelegramAdapter implements PlatformAdapter {
+  readonly platform = "telegram";
+  readonly textChunkLimit = 4096;
+
+  private botToken: string;
+  private offset = 0;
+  private running = false;
+  private pollingTimeout: number;
+  private abortController: AbortController | null = null;
+  private onMessage: MessageHandler;
+
+  constructor(options: TelegramAdapterOptions) {
+    this.botToken = options.botToken;
+    this.pollingTimeout = options.pollingTimeout ?? 30;
+    this.onMessage = options.onMessage;
+  }
+
+  async connect(): Promise<boolean> {
+    if (this.running) return true;
+
+    // 先删除 webhook（如果之前设置过），切换到 polling 模式
+    await this.apiCall("deleteWebhook", {}).catch(() => {});
+
+    this.running = true;
+    this.poll(); // 非阻塞启动
+    console.log("[telegram] 💡 Tip: Bot must be Group Admin or have Privacy Mode disabled to receive all messages");
+    return true;
+  }
+
+  async disconnect(): Promise<void> {
+    this.running = false;
+    this.abortController?.abort();
+  }
+
+  async send(chatId: string, text: string, options?: SendOptions): Promise<SendResult> {
+    const parseMode = options?.parseMode === "html" ? "HTML"
+      : options?.parseMode === "markdown" ? "Markdown"
+      : undefined;
+
+    const payload: any = {
+      chat_id: chatId,
+      text,
+      disable_web_page_preview: true,
+    };
+    if (parseMode) payload.parse_mode = parseMode;
+    if (options?.replyToMessageId) payload.reply_to_message_id = options.replyToMessageId;
+    if (options?.threadId) payload.message_thread_id = options.threadId;
+
+    const result = await this.apiCall("sendMessage", payload);
+    if (result?.ok) {
+      return { ok: true, messageId: String(result.result?.message_id || "") };
+    }
+    return { ok: false, error: result?.description || "Unknown error" };
+  }
+
+  async sendTyping(chatId: string): Promise<void> {
+    await this.apiCall("sendChatAction", { chat_id: chatId, action: "typing" }).catch(() => {});
+  }
+
+  // ─── Private ──────────────────────────────────────────────────────────────────
+
+  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.processUpdate(update).catch((err) => {
+          console.error("[telegram] Error processing update:", err.message);
+        });
+      }
+    } catch (err: any) {
+      if (!this.running) return;
+      console.error("[telegram] Poll error:", err.message);
+      await sleep(3000);
+    }
+    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.pollingTimeout}&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 processUpdate(update: any) {
+    const msg = update.message || update.edited_message;
+    if (!msg?.text) return;
+
+    const chatId = msg.chat?.id;
+    if (!chatId) return;
+
+    const inbound: InboundMessage = {
+      platform: "telegram",
+      chatId: String(chatId),
+      text: msg.text,
+      senderId: msg.from?.id ? String(msg.from.id) : undefined,
+      senderName: msg.from?.first_name || msg.from?.username,
+      threadId: msg.message_thread_id ? String(msg.message_thread_id) : undefined,
+      raw: update,
+    };
+
+    await this.onMessage(inbound);
+  }
+
+  private async apiCall(method: string, payload: any): Promise<any> {
+    try {
+      const res = await fetch(`${TG_API}/bot${this.botToken}/${method}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload),
+      });
+      return await res.json();
+    } catch (err: any) {
+      return { ok: false, description: err.message };
+    }
+  }
+}
+
+function sleep(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}