@hienlh/ppm 0.9.30 → 0.9.32

package/src/services/clawbot/clawbot-streamer.ts

@@ -0,0 +1,245 @@
+import type { ChatEvent, ResultSubtype } from "../../types/chat.ts";
+import type { ClawBotTelegram } from "./clawbot-telegram.ts";
+import {
+  markdownToTelegramHtml,
+  chunkMessage,
+  escapeHtml,
+} from "./clawbot-formatter.ts";
+
+const MAX_MSG_LEN = 4096;
+const TYPING_REFRESH_MS = 4000;
+const PLACEHOLDER = "\u2026"; // ellipsis
+
+export interface StreamConfig {
+  showToolCalls: boolean;
+  showThinking: boolean;
+}
+
+export interface StreamResult {
+  contextWindowPct?: number;
+  resultSubtype?: ResultSubtype;
+  /** All Telegram message IDs sent during this stream */
+  messageIds: number[];
+  /** New session ID if session was migrated */
+  newSessionId?: string;
+}
+
+/**
+ * Consume a ChatEvent stream and progressively send/edit Telegram messages.
+ *
+ * Flow:
+ * 1. Send placeholder message
+ * 2. Accumulate text/tool/thinking events
+ * 3. Edit message every time ClawBotTelegram allows (1s throttle)
+ * 4. When text exceeds 4096, finalize current msg, start new one
+ * 5. On done/error, finalize and return result
+ */
+export async function streamToTelegram(
+  chatId: number | string,
+  events: AsyncIterable<ChatEvent>,
+  telegram: ClawBotTelegram,
+  config: StreamConfig,
+): Promise<StreamResult> {
+  const result: StreamResult = { messageIds: [] };
+  let accumulated = "";
+  let currentMsgId: number | null = null;
+  let lastTypingTime = 0;
+
+  const refreshTyping = async (): Promise<void> => {
+    const now = Date.now();
+    if (now - lastTypingTime >= TYPING_REFRESH_MS) {
+      lastTypingTime = now;
+      await telegram.sendTyping(chatId);
+    }
+  };
+
+  // Send placeholder
+  await telegram.sendTyping(chatId);
+  lastTypingTime = Date.now();
+  const placeholder = await telegram.sendMessage(chatId, PLACEHOLDER);
+  if (placeholder) {
+    currentMsgId = placeholder.message_id;
+    result.messageIds.push(currentMsgId);
+  }
+
+  const finalizeAndStartNew = async (text: string): Promise<void> => {
+    if (currentMsgId && text.trim()) {
+      const html = markdownToTelegramHtml(text);
+      await telegram.editMessageFinal(chatId, currentMsgId, html);
+    }
+    accumulated = "";
+    currentMsgId = null;
+  };
+
+  const sendNewMessage = async (text: string): Promise<void> => {
+    const html = markdownToTelegramHtml(text);
+    const chunks = chunkMessage(html, MAX_MSG_LEN);
+    for (const chunk of chunks) {
+      const sent = await telegram.sendMessage(chatId, chunk);
+      if (sent) {
+        currentMsgId = sent.message_id;
+        result.messageIds.push(currentMsgId);
+      }
+    }
+  };
+
+  const editCurrent = async (): Promise<void> => {
+    if (!currentMsgId || !accumulated.trim()) return;
+
+    const html = markdownToTelegramHtml(accumulated);
+    if (html.length > MAX_MSG_LEN) {
+      const splitPoint = findSplitPoint(accumulated, MAX_MSG_LEN * 0.8);
+      const first = accumulated.slice(0, splitPoint);
+      const rest = accumulated.slice(splitPoint).trimStart();
+
+      await finalizeAndStartNew(first);
+      accumulated = rest;
+      if (rest) {
+        await sendNewMessage(rest);
+      }
+      return;
+    }
+
+    await telegram.editMessage(chatId, currentMsgId, html);
+  };
+
+  // Process event stream
+  try {
+    for await (const event of events) {
+      await refreshTyping();
+
+      switch (event.type) {
+        case "text": {
+          accumulated += event.content;
+          await editCurrent();
+          break;
+        }
+
+        case "thinking": {
+          if (config.showThinking && event.content) {
+            accumulated += `\n<i>${escapeHtml(event.content)}</i>\n`;
+            await editCurrent();
+          }
+          break;
+        }
+
+        case "tool_use": {
+          if (config.showToolCalls) {
+            const toolName = event.tool;
+            const inputPreview = formatToolInput(event.input);
+            accumulated += `\n🔧 <code>${escapeHtml(toolName)}</code>(${escapeHtml(inputPreview)})\n`;
+            await editCurrent();
+          }
+          break;
+        }
+
+        case "tool_result": {
+          if (config.showToolCalls && event.isError) {
+            accumulated += `\n⚠️ <code>${escapeHtml(event.output.slice(0, 200))}</code>\n`;
+            await editCurrent();
+          }
+          break;
+        }
+
+        case "error": {
+          accumulated += `\n\n❌ <b>Error:</b> ${escapeHtml(event.message)}`;
+          await editCurrent();
+          break;
+        }
+
+        case "done": {
+          result.contextWindowPct = event.contextWindowPct;
+          result.resultSubtype = event.resultSubtype;
+          break;
+        }
+
+        case "session_migrated": {
+          result.newSessionId = event.newSessionId;
+          break;
+        }
+
+        case "account_retry": {
+          accumulated += `\n⏳ <i>Switching account: ${escapeHtml(event.reason)}</i>\n`;
+          await editCurrent();
+          break;
+        }
+
+        default:
+          // Ignore unknown events (system, team_detected, account_info, etc.)
+          break;
+      }
+    }
+  } catch (err) {
+    accumulated += `\n\n❌ <b>Stream error:</b> ${escapeHtml((err as Error).message)}`;
+  }
+
+  // Final edit with complete content
+  if (currentMsgId && accumulated.trim()) {
+    const html = markdownToTelegramHtml(accumulated);
+    const chunks = chunkMessage(html, MAX_MSG_LEN);
+
+    if (chunks.length === 1) {
+      await telegram.editMessageFinal(chatId, currentMsgId, chunks[0]!);
+    } else {
+      await telegram.editMessageFinal(chatId, currentMsgId, chunks[0]!);
+      for (let i = 1; i < chunks.length; i++) {
+        const sent = await telegram.sendMessage(chatId, chunks[i]!);
+        if (sent) result.messageIds.push(sent.message_id);
+      }
+    }
+  } else if (currentMsgId && !accumulated.trim()) {
+    await telegram.editMessageFinal(
+      chatId,
+      currentMsgId,
+      "<i>No response generated.</i>",
+    );
+  }
+
+  return result;
+}
+
+// ── Helpers ─────────────────────────────────────────────────────
+
+/** Format tool input for compact display */
+function formatToolInput(input: unknown): string {
+  if (!input) return "";
+  if (typeof input === "string") return input.slice(0, 80);
+
+  try {
+    const obj = input as Record<string, unknown>;
+    const keys = Object.keys(obj);
+    if (keys.length === 0) return "";
+
+    if ("command" in obj) return String(obj.command).slice(0, 80);
+    if ("file_path" in obj) return String(obj.file_path).slice(0, 80);
+    if ("pattern" in obj) return String(obj.pattern).slice(0, 80);
+    if ("query" in obj) return String(obj.query).slice(0, 80);
+    if ("url" in obj) return String(obj.url).slice(0, 80);
+
+    const firstKey = keys[0]!;
+    return `${firstKey}=${String(obj[firstKey]).slice(0, 60)}`;
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * Find a good split point in text, aiming for targetLen.
+ * Prefers double newline > single newline > space.
+ */
+function findSplitPoint(text: string, targetLen: number): number {
+  if (text.length <= targetLen) return text.length;
+
+  const window = text.slice(0, Math.floor(targetLen));
+
+  let point = window.lastIndexOf("\n\n");
+  if (point > targetLen * 0.3) return point;
+
+  point = window.lastIndexOf("\n");
+  if (point > targetLen * 0.3) return point;
+
+  point = window.lastIndexOf(" ");
+  if (point > targetLen * 0.3) return point;
+
+  return Math.floor(targetLen);
+}

package/src/services/clawbot/clawbot-telegram.ts

@@ -0,0 +1,251 @@
+import type {
+  TelegramUpdate,
+  TelegramMessage,
+  TelegramSentMessage,
+  ClawBotCommand,
+} from "../../types/clawbot.ts";
+
+const TELEGRAM_API = "https://api.telegram.org/bot";
+const POLL_TIMEOUT = 25;
+const MIN_EDIT_INTERVAL = 1000;
+const BOT_TOKEN_RE = /^\d+:[A-Za-z0-9_-]{30,50}$/;
+
+/** Known ClawBot slash commands */
+const COMMANDS = new Set([
+  "start", "project", "new", "sessions", "resume",
+  "status", "stop", "memory", "forget", "remember", "help",
+]);
+
+export type UpdateHandler = (update: TelegramUpdate) => Promise<void>;
+
+export class ClawBotTelegram {
+  private token: string;
+  private offset = 0;
+  private running = false;
+  private abortController: AbortController | null = null;
+  private retryCount = 0;
+
+  /** Track last edit time per chatId:messageId to throttle */
+  private lastEditTime = new Map<string, number>();
+
+  constructor(token: string) {
+    if (!BOT_TOKEN_RE.test(token)) {
+      throw new Error("Invalid Telegram bot token format");
+    }
+    this.token = token;
+  }
+
+  // ── Polling ─────────────────────────────────────────────────────
+
+  /** Start long-polling loop. Calls handler for each update. */
+  async startPolling(handler: UpdateHandler): Promise<void> {
+    if (this.running) return;
+    this.running = true;
+    this.retryCount = 0;
+    console.log("[clawbot] Polling started");
+
+    while (this.running) {
+      try {
+        const updates = await this.getUpdates();
+        this.retryCount = 0;
+
+        for (const update of updates) {
+          this.offset = update.update_id + 1;
+          try {
+            await handler(update);
+          } catch (err) {
+            console.error("[clawbot] Handler error:", (err as Error).message);
+          }
+        }
+      } catch (err) {
+        if (!this.running) break;
+        this.retryCount++;
+        const delay = Math.min(1000 * 2 ** this.retryCount, 30_000);
+        console.error(
+          `[clawbot] Poll error (retry ${this.retryCount}): ${(err as Error).message}. Retrying in ${delay}ms`,
+        );
+        await Bun.sleep(delay);
+      }
+    }
+
+    console.log("[clawbot] Polling stopped");
+  }
+
+  /** Stop polling gracefully */
+  stop(): void {
+    this.running = false;
+    this.abortController?.abort();
+    this.lastEditTime.clear();
+  }
+
+  get isRunning(): boolean {
+    return this.running;
+  }
+
+  // ── Telegram API Methods ────────────────────────────────────────
+
+  /** Fetch updates via long-polling */
+  private async getUpdates(): Promise<TelegramUpdate[]> {
+    this.abortController = new AbortController();
+    const fetchTimeout = setTimeout(
+      () => this.abortController?.abort(),
+      (POLL_TIMEOUT + 10) * 1000,
+    );
+
+    try {
+      const res = await fetch(`${TELEGRAM_API}${this.token}/getUpdates`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          offset: this.offset,
+          timeout: POLL_TIMEOUT,
+          allowed_updates: ["message"],
+        }),
+        signal: this.abortController.signal,
+      });
+
+      const json = (await res.json()) as { ok: boolean; result?: TelegramUpdate[] };
+      if (!json.ok || !json.result) return [];
+      return json.result;
+    } finally {
+      clearTimeout(fetchTimeout);
+      this.abortController = null;
+    }
+  }
+
+  /** Send a text message */
+  async sendMessage(
+    chatId: number | string,
+    text: string,
+    parseMode: "HTML" | "Markdown" = "HTML",
+  ): Promise<TelegramSentMessage | null> {
+    try {
+      const res = await this.callApi("sendMessage", {
+        chat_id: chatId,
+        text,
+        parse_mode: parseMode,
+        disable_web_page_preview: true,
+      });
+      const json = (await res.json()) as { ok: boolean; result?: TelegramSentMessage; description?: string };
+      if (!json.ok) {
+        console.error(`[clawbot] sendMessage failed: ${json.description}`);
+        return null;
+      }
+      return json.result ?? null;
+    } catch (err) {
+      console.error(`[clawbot] sendMessage error: ${(err as Error).message}`);
+      return null;
+    }
+  }
+
+  /** Edit an existing message text (throttled at 1s intervals) */
+  async editMessage(
+    chatId: number | string,
+    messageId: number,
+    text: string,
+    parseMode: "HTML" | "Markdown" = "HTML",
+  ): Promise<boolean> {
+    const key = `${chatId}:${messageId}`;
+    const now = Date.now();
+    const lastEdit = this.lastEditTime.get(key) ?? 0;
+    if (now - lastEdit < MIN_EDIT_INTERVAL) return false;
+
+    this.lastEditTime.set(key, now);
+
+    try {
+      const res = await this.callApi("editMessageText", {
+        chat_id: chatId,
+        message_id: messageId,
+        text,
+        parse_mode: parseMode,
+        disable_web_page_preview: true,
+      });
+      const json = (await res.json()) as { ok: boolean; description?: string };
+      if (!json.ok) {
+        if (json.description?.includes("not modified")) return true;
+        console.error(`[clawbot] editMessage failed: ${json.description}`);
+        return false;
+      }
+      return true;
+    } catch (err) {
+      console.error(`[clawbot] editMessage error: ${(err as Error).message}`);
+      return false;
+    }
+  }
+
+  /** Force-edit (bypass throttle) — used for final message */
+  async editMessageFinal(
+    chatId: number | string,
+    messageId: number,
+    text: string,
+    parseMode: "HTML" | "Markdown" = "HTML",
+  ): Promise<boolean> {
+    const key = `${chatId}:${messageId}`;
+    this.lastEditTime.delete(key);
+    return this.editMessage(chatId, messageId, text, parseMode);
+  }
+
+  /** Send "typing" chat action */
+  async sendTyping(chatId: number | string): Promise<void> {
+    try {
+      await this.callApi("sendChatAction", {
+        chat_id: chatId,
+        action: "typing",
+      });
+    } catch {
+      // Best-effort, ignore errors
+    }
+  }
+
+  /** Delete a message */
+  async deleteMessage(chatId: number | string, messageId: number): Promise<void> {
+    try {
+      await this.callApi("deleteMessage", {
+        chat_id: chatId,
+        message_id: messageId,
+      });
+    } catch {
+      // Best-effort
+    }
+  }
+
+  // ── Command Parsing ─────────────────────────────────────────────
+
+  /** Parse a Telegram message into a ClawBotCommand if it starts with / */
+  static parseCommand(message: TelegramMessage): ClawBotCommand | null {
+    const text = message.text ?? message.caption ?? "";
+    if (!text.startsWith("/")) return null;
+
+    const match = text.match(/^\/(\w+)(?:@\S+)?\s*(.*)/s);
+    if (!match) return null;
+
+    const command = match[1]!.toLowerCase();
+    if (!COMMANDS.has(command)) return null;
+
+    return {
+      command,
+      args: match[2]?.trim() ?? "",
+      chatId: message.chat.id,
+      messageId: message.message_id,
+      userId: message.from?.id ?? 0,
+      username: message.from?.username,
+    };
+  }
+
+  // ── Private Helpers ─────────────────────────────────────────────
+
+  private async callApi(method: string, body: Record<string, unknown>): Promise<Response> {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 10_000);
+    try {
+      return await fetch(`${TELEGRAM_API}${this.token}/${method}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+        signal: controller.signal,
+      });
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+}

package/src/services/config.service.ts

@@ -19,7 +19,7 @@ const PPM_DIR = resolve(homedir(), ".ppm");
 
 /** Top-level config keys stored in the config table (not projects) */
 const CONFIG_TABLE_KEYS: (keyof PpmConfig)[] = [
-  "device_name", "port", "host", "theme", "auth", "ai", "push", "telegram",
+  "device_name", "port", "host", "theme", "auth", "ai", "push", "telegram", "clawbot",
 ];
 
 class ConfigService {