pi-ui-extend 0.1.17 → 0.1.18

package/external/pi-tools-suite/src/telegram-mirror/bot.ts

@@ -0,0 +1,228 @@
+/**
+ * Minimal Telegram Bot API client.
+ *
+ * Uses native fetch (Node 18+ / Bun) and long polling via getUpdates.
+ * No dependencies on grammY or node-telegram-bot-api.
+ *
+ * Provides:
+ *   - sendMessage / editMessageText (HTML parse mode)
+ *   - getUpdates long-poll loop with backoff
+ *   - Auth gate by chat_id (single whitelist)
+ *   - Graceful shutdown via AbortController
+ */
+
+export interface TelegramUpdate {
+	update_id: number;
+	message?: {
+		message_id: number;
+		date: number;
+		chat: { id: number; type: string };
+		from?: { id: number; first_name?: string; username?: string };
+		text?: string;
+	};
+}
+
+export interface TelegramMessage {
+	message_id: number;
+	chat: { id: number };
+	date: number;
+	text?: string;
+}
+
+export interface BotConfig {
+	token: string;
+	allowedChatId: number;
+	timeoutMs?: number;
+}
+
+interface SendOptions {
+	parseMode?: "HTML" | "MarkdownV2" | "Markdown";
+	disablePreview?: boolean;
+	silent?: boolean;
+	replyToMessageId?: number;
+}
+
+interface EditOptions {
+	parseMode?: "HTML" | "MarkdownV2" | "Markdown";
+	disablePreview?: boolean;
+}
+
+export class TelegramBot {
+	private readonly baseUrl: string;
+	private readonly allowedChatId: number;
+	private readonly timeoutMs: number;
+	private readonly controller = new AbortController();
+	private polling = false;
+	private lastUpdateId = 0;
+	private consecutiveErrors = 0;
+
+	constructor(config: BotConfig) {
+		if (!config.token) throw new Error("TelegramBot: token is required");
+		this.baseUrl = `https://api.telegram.org/bot${config.token}`;
+		this.allowedChatId = config.allowedChatId;
+		this.timeoutMs = config.timeoutMs ?? 35_000;
+	}
+
+	get signal(): AbortSignal {
+		return this.controller.signal;
+	}
+
+	get chatId(): number {
+		return this.allowedChatId;
+	}
+
+	isAllowedChat(chatId: number): boolean {
+		return chatId === this.allowedChatId;
+	}
+
+	async getMe(): Promise<{ ok: boolean; result?: { username: string; first_name: string } }> {
+		return this.requestJson("GET", "getMe", undefined);
+	}
+
+	async sendMessage(text: string, options: SendOptions = {}): Promise<TelegramMessage | undefined> {
+		return this.requestJson("POST", "sendMessage", {
+			chat_id: this.allowedChatId,
+			text,
+			parse_mode: options.parseMode ?? "HTML",
+			disable_web_page_preview: options.disablePreview ?? true,
+			disable_notification: options.silent ?? false,
+			...(options.replyToMessageId ? { reply_to_message_id: options.replyToMessageId } : {}),
+		});
+	}
+
+	async editMessageText(messageId: number, text: string, options: EditOptions = {}): Promise<TelegramMessage | undefined> {
+		try {
+			return await this.requestJson("POST", "editMessageText", {
+				chat_id: this.allowedChatId,
+				message_id: messageId,
+				text,
+				parse_mode: options.parseMode ?? "HTML",
+				disable_web_page_preview: options.disablePreview ?? true,
+			});
+		} catch (error) {
+			// Telegram returns 400 "message is not modified" if content is identical.
+			// Treat that as success; surface everything else.
+			const message = error instanceof Error ? error.message : String(error);
+			if (/not modified/i.test(message)) return undefined;
+			throw error;
+		}
+	}
+
+	async deleteMessage(messageId: number): Promise<void> {
+		try {
+			await this.requestJson("POST", "deleteMessage", {
+				chat_id: this.allowedChatId,
+				message_id: messageId,
+			});
+		} catch {
+			// best-effort
+		}
+	}
+
+	/**
+	 * Start long-polling loop. The callback receives every update from the
+	 * allowed chat; updates from other chats are dropped silently.
+	 *
+	 * The loop exits cleanly when abort() is called.
+	 */
+	startPolling(onUpdate: (update: TelegramUpdate) => void | Promise<void>): void {
+		if (this.polling) return;
+		this.polling = true;
+		void this.pollLoop(onUpdate);
+	}
+
+	abort(): void {
+		if (this.controller.signal.aborted) return;
+		this.controller.abort();
+		this.polling = false;
+	}
+
+	private async pollLoop(onUpdate: (update: TelegramUpdate) => void | Promise<void>): Promise<void> {
+		while (this.polling && !this.controller.signal.aborted) {
+			try {
+				const payload = await this.requestJson<{
+					ok: boolean;
+					result?: TelegramUpdate[];
+				}>("POST", "getUpdates", {
+					offset: this.lastUpdateId > 0 ? this.lastUpdateId + 1 : undefined,
+					timeout: Math.floor(this.timeoutMs / 1000),
+					allowed_updates: ["message"],
+				});
+
+				this.consecutiveErrors = 0;
+
+				if (!payload?.ok || !Array.isArray(payload.result)) {
+					continue;
+				}
+
+				for (const update of payload.result) {
+					if (update.update_id > this.lastUpdateId) this.lastUpdateId = update.update_id;
+					if (!update.message) continue;
+					if (!this.isAllowedChat(update.message.chat.id)) continue;
+					try {
+						await onUpdate(update);
+					} catch (handlerError) {
+						this.logError("onUpdate handler", handlerError);
+					}
+				}
+			} catch (error) {
+				if (this.controller.signal.aborted) break;
+				this.consecutiveErrors += 1;
+				this.logError("polling", error);
+				// Backoff: 1s → 60s capped
+				const backoff = Math.min(60_000, 1000 * 2 ** Math.min(5, this.consecutiveErrors - 1));
+				await sleep(backoff).catch(() => undefined);
+			}
+		}
+	}
+
+	private async requestJson<T>(method: "GET" | "POST", endpoint: string, body?: Record<string, unknown>): Promise<T> {
+		const url = `${this.baseUrl}/${endpoint}`;
+		const init: RequestInit = {
+			method,
+			signal: this.controller.signal,
+			headers: body ? { "Content-Type": "application/json" } : undefined,
+			body: body ? JSON.stringify(removeUndefined(body)) : undefined,
+		};
+
+		const response = await fetch(url, init);
+		const text = await response.text();
+		let parsed: unknown;
+		try {
+			parsed = text ? JSON.parse(text) : {};
+		} catch {
+			throw new Error(`Telegram API ${endpoint} returned invalid JSON: ${text.slice(0, 200)}`);
+		}
+
+		if (!response.ok || (isRecord(parsed) && parsed.ok === false)) {
+			const desc = isRecord(parsed) && typeof parsed.description === "string" ? parsed.description : text.slice(0, 200);
+			const errorCode = isRecord(parsed) && typeof parsed.error_code === "number" ? parsed.error_code : response.status;
+			throw new Error(`Telegram API ${endpoint} failed (${errorCode}): ${desc}`);
+		}
+
+		return parsed as T;
+	}
+
+	private logError(label: string, error: unknown): void {
+		const message = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+		// Use stderr so we don't pollute the TUI. Pi redirects stderr to its log.
+		// eslint-disable-next-line no-console
+		console.error(`[telegram-mirror] ${label}: ${message}`);
+	}
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function removeUndefined(value: Record<string, unknown>): Record<string, unknown> {
+	const out: Record<string, unknown> = {};
+	for (const [k, v] of Object.entries(value)) {
+		if (v !== undefined) out[k] = v;
+	}
+	return out;
+}
+
+function sleep(ms: number): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/external/pi-tools-suite/src/telegram-mirror/events.ts

@@ -0,0 +1,94 @@
+/**
+ * Pix event → TurnRenderer adapters.
+ *
+ * Keeps a per-turn renderer (one TG message chain per agent turn) and exposes
+ * ExtensionAPI event handlers that append to it.
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { RendererEvent } from "./renderer.js";
+
+/**
+ * Minimal sink for rendering events. The leader wires this to a Multiplexer
+ * (which routes to a TurnRenderer for the active instance); a follower wires
+ * it to an IPC socket so events travel to the leader.
+ */
+export interface RendererSink {
+	push(event: RendererEvent): void;
+}
+
+export function registerPixEventHandlers(pi: ExtensionAPI, hooks: PixMirrorHooks): void {
+	pi.on("agent_start", () => {
+		hooks.getRenderer()?.push({ kind: "turn_start" });
+	});
+
+	pi.on("before_agent_start", (event) => {
+		const prompt = event?.prompt?.trim();
+		if (!prompt) return;
+		hooks.getRenderer()?.push({ kind: "info", text: `user: ${truncate(prompt, 200)}` });
+	});
+
+	pi.on("message_update", (event) => {
+		const type = event?.assistantMessageEvent?.type;
+		if (type === "text_delta") {
+			const delta = (event.assistantMessageEvent as { delta?: string }).delta ?? "";
+			if (delta) hooks.getRenderer()?.push({ kind: "assistant_text", delta });
+			return;
+		}
+		if (type === "thinking_delta" || type === "thinking_start") {
+			// Render a single `💭 thinking…` marker per turn. The renderer
+			// dedupes further thinking events so we don't spam the chat
+			// with streaming thinking chunks.
+			hooks.getRenderer()?.push({ kind: "thinking" });
+			return;
+		}
+	});
+
+	pi.on("tool_execution_start", (event) => {
+		hooks.getRenderer()?.push({
+			kind: "tool_start",
+			toolCallId: event.toolCallId,
+			toolName: event.toolName,
+		});
+	});
+
+	pi.on("tool_execution_end", (event) => {
+		hooks.getRenderer()?.push({
+			kind: "tool_end",
+			toolCallId: event.toolCallId,
+			toolName: event.toolName,
+			isError: event.isError,
+		});
+	});
+
+	pi.on("agent_end", () => {
+		hooks.getRenderer()?.push({ kind: "turn_end", reason: "end" });
+		hooks.notifyAgentEnd();
+	});
+}
+
+export interface PixMirrorHooks {
+	getRenderer(): RendererSink | undefined;
+	notifyAgentEnd(): void;
+}
+
+export function captureAbortableContext(ctx: ExtensionContext | undefined, hooks: ContextCapture): void {
+	if (!ctx) return;
+	hooks.captureAbort(() => ctx.abort());
+	hooks.captureIdle(() => ctx.isIdle());
+	hooks.capturePending(() => ctx.hasPendingMessages());
+	hooks.captureCompact(() => ctx.compact());
+}
+
+export interface ContextCapture {
+	captureAbort(fn: () => void): void;
+	captureIdle(fn: () => boolean): void;
+	capturePending(fn: () => boolean): void;
+	captureCompact(fn: () => void): void;
+}
+
+function truncate(value: string, max: number): string {
+	const collapsed = value.replace(/\s+/g, " ").trim();
+	if (collapsed.length <= max) return collapsed;
+	return `${collapsed.slice(0, Math.max(0, max - 1))}…`;
+}

package/external/pi-tools-suite/src/telegram-mirror/format.ts

@@ -0,0 +1,120 @@
+/**
+ * Minimal markdown → Telegram HTML conversion.
+ *
+ * Telegram supports a small subset of HTML: <b>, <i>, <code>, <pre>, <a>, <s>, <u>.
+ * See https://core.telegram.org/bots/api#html-style
+ *
+ * We escape < > & first, then re-introduce supported tags from common markdown
+ * patterns. This is intentionally lossy — blockquotes, headings, lists render
+ * as plain text. The goal is to keep streaming output legible on a phone screen.
+ */
+
+const ENTITY_RE = /[<>&]/g;
+
+export function escapeHtml(value: string): string {
+	return value.replace(ENTITY_RE, (ch) => {
+		switch (ch) {
+			case "<":
+				return "&lt;";
+			case ">":
+				return "&gt;";
+			case "&":
+				return "&amp;";
+			default:
+				return ch;
+		}
+	});
+}
+
+/**
+ * Convert a chunk of assistant-flavoured markdown to Telegram HTML.
+ *
+ * Handles:
+ *   ```lang\nfenced\n```   → <pre><code class="language-lang">…</code></pre>
+ *   `inline code`          → <code>…</code>
+ *   **bold**               → <b>…</b>
+ *   __bold__ / *italic*    → <b>…</b> / <i>…</i>
+ *
+ * Everything else is HTML-escaped.
+ */
+export function markdownToTelegram(value: string): string {
+	if (!value) return "";
+
+	// Pull out fenced code blocks first so their contents aren't mangled
+	// by inline replacements.
+	const fences: string[] = [];
+	const fenced = value.replace(/```([a-zA-Z0-9_+-]*)\n?([\s\S]*?)```/g, (_m, lang, body) => {
+		const langAttr = typeof lang === "string" && lang.trim() ? ` class="language-${escapeHtml(lang.trim())}"` : "";
+		const rendered = `<pre><code${langAttr}>${escapeHtml(body)}</code></pre>`;
+		fences.push(rendered);
+		return `\u0000FENCE${fences.length - 1}\u0000`;
+	});
+
+	let out = escapeHtml(fenced);
+
+	// Inline code (do before bold/italic so backticks inside ** stay escaped)
+	out = out.replace(/`([^`\n]+?)`/g, (_m, code) => `<code>${code}</code>`);
+
+	// Bold
+	out = out.replace(/\*\*([^*\n]+?)\*\*/g, "<b>$1</b>");
+	out = out.replace(/__([^_\n]+?)__/g, "<b>$1</b>");
+
+	// Italic (single * or _)
+	out = out.replace(/(^|[^*])\*([^*\n]+?)\*(?!\*)/g, "$1<i>$2</i>");
+	out = out.replace(/(^|[^_])_([^_\n]+?)_(?!_)/g, "$1<i>$2</i>");
+
+	// Restore fenced blocks
+	out = out.replace(/\u0000FENCE(\d+)\u0000/g, (_m, idx) => fences[Number(idx)] ?? "");
+
+	return out;
+}
+
+/** Telegram message size limit. */
+export const TELEGRAM_MESSAGE_MAX = 4096;
+
+/**
+ * Split a rendered HTML payload into chunks that fit a single Telegram message.
+ * Tries to break on blank lines first, then on newlines, then hard-splits.
+ *
+ * Each chunk is guaranteed to be <= maxChars characters.
+ */
+export function chunkForTelegram(html: string, maxChars = TELEGRAM_MESSAGE_MAX): string[] {
+	if (html.length <= maxChars) return [html];
+
+	const chunks: string[] = [];
+	let cursor = 0;
+	while (cursor < html.length) {
+		const remaining = html.length - cursor;
+		if (remaining <= maxChars) {
+			chunks.push(html.slice(cursor));
+			break;
+		}
+
+		const window = html.slice(cursor, cursor + maxChars);
+		let cut = -1;
+
+		// Prefer blank line break
+		const blank = window.lastIndexOf("\n\n");
+		if (blank >= maxChars * 0.5) cut = blank + 1;
+
+		// Then any newline
+		if (cut < 0) {
+			const nl = window.lastIndexOf("\n");
+			if (nl >= maxChars * 0.5) cut = nl + 1;
+		}
+
+		// Then a space
+		if (cut < 0) {
+			const sp = window.lastIndexOf(" ");
+			if (sp >= maxChars * 0.5) cut = sp + 1;
+		}
+
+		// Hard cut
+		if (cut < 0) cut = maxChars;
+
+		chunks.push(html.slice(cursor, cursor + cut));
+		cursor += cut;
+	}
+
+	return chunks.filter((chunk) => chunk.length > 0);
+}