pi-telebridge 1.0.0

package/README.md

@@ -0,0 +1,55 @@
+# pi-telebridge
+
+A [pi](https://github.com/badlogic/pi-mono) extension that creates a two-way relay between your active pi coding agent session and a Telegram bot. Enable it per-session with `/telegram`, then interact with your session from your phone.
+
+- **Agent → Phone**: Every final assistant response is forwarded to your Telegram chat
+- **Phone → Agent**: Your Telegram replies are injected as user messages into the session
+
+Both the pi TUI and Telegram inputs coexist — you can use either at any time.
+
+## Install
+
+```bash
+pi install npm:pi-telebridge
+```
+
+## Setup
+
+1. Create a bot with [@BotFather](https://t.me/BotFather) on Telegram and copy the token
+2. In pi, run `/telegram setup`
+3. Enter your bot token when prompted
+4. Send any message to your bot on Telegram — this links your chat ID
+5. Done! Config is saved to `~/.pi/agent/telebridge.json`
+
+### Environment Variables (optional)
+
+You can skip the interactive setup by setting these beforehand:
+
+| Variable | Purpose |
+|----------|---------|
+| `TELEGRAM_BOT_TOKEN` | Bot token from @BotFather |
+| `TELEGRAM_CHAT_ID` | Your Telegram chat ID |
+
+## Usage
+
+| Command | Description |
+|---------|-------------|
+| `/telegram` | Toggle relay on/off for this session |
+| `/telegram setup` | Guided setup: enter bot token, discover chat ID |
+| `/telegram status` | Show connection state, chat ID, relay status |
+
+When the relay is enabled:
+- A **📡 TG** indicator appears in the footer
+- Every assistant response is forwarded to your Telegram chat
+- Messages you send to the bot are injected into the pi session
+- If the agent is idle, your message starts a new turn; if busy, it's queued as a follow-up
+
+## Security
+
+- Only messages from your configured `chat_id` are accepted
+- All other Telegram messages are silently ignored
+- Bot token and chat ID are stored locally in `~/.pi/agent/telebridge.json`
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "pi-telebridge",
+  "version": "1.0.0",
+  "description": "A pi extension that creates a two-way relay between your active pi coding agent session and a Telegram bot.",
+  "type": "module",
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "pi",
+    "telegram",
+    "telegram-bot"
+  ],
+  "author": "acarerdinc",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/acarerdinc/pi-telebridge.git"
+  },
+  "homepage": "https://github.com/acarerdinc/pi-telebridge#readme",
+  "bugs": {
+    "url": "https://github.com/acarerdinc/pi-telebridge/issues"
+  },
+  "pi": {
+    "extensions": ["./src/index.ts"]
+  },
+  "scripts": {
+    "clean": "echo 'nothing to clean'",
+    "build": "echo 'nothing to build'",
+    "check": "echo 'nothing to check'"
+  },
+  "dependencies": {
+    "grammy": "^1.35.0"
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-coding-agent": "*"
+  }
+}

package/src/bot.ts

@@ -0,0 +1,141 @@
+import { Bot } from "grammy";
+
+let botInstance: Bot | null = null;
+let currentToken: string | null = null;
+
+export type IncomingMessageHandler = (chatId: number, text: string) => void;
+
+let onIncomingMessage: IncomingMessageHandler | null = null;
+let allowedChatId: number | null = null;
+let chatIdDiscoveryResolve: ((chatId: number) => void) | null = null;
+
+/**
+ * Get or create the grammy Bot singleton.
+ * If token changes, the old bot is stopped and a new one created.
+ */
+export async function startBot(token: string): Promise<Bot> {
+	if (botInstance && currentToken === token) {
+		return botInstance;
+	}
+
+	// Stop old bot if token changed
+	if (botInstance) {
+		await stopBot();
+	}
+
+	const bot = new Bot(token);
+
+	bot.on("message:text", (ctx) => {
+		const chatId = ctx.chat.id;
+		const text = ctx.message.text;
+
+		// Chat ID discovery mode
+		if (chatIdDiscoveryResolve) {
+			chatIdDiscoveryResolve(chatId);
+			chatIdDiscoveryResolve = null;
+			return;
+		}
+
+		// Security: only accept messages from allowed chat
+		if (allowedChatId !== null && chatId !== allowedChatId) {
+			return;
+		}
+
+		// Forward to handler
+		if (onIncomingMessage) {
+			onIncomingMessage(chatId, text);
+		}
+	});
+
+	// Catch errors so they don't crash the process
+	bot.catch((err) => {
+		console.error("[telebridge] Bot error:", err.message);
+	});
+
+	// Start long polling (non-blocking)
+	bot.start({
+		onStart: () => {
+			// Bot is polling
+		},
+	});
+
+	botInstance = bot;
+	currentToken = token;
+
+	return bot;
+}
+
+export async function stopBot(): Promise<void> {
+	if (botInstance) {
+		try {
+			await botInstance.stop();
+		} catch {
+			// Ignore errors during shutdown
+		}
+		botInstance = null;
+		currentToken = null;
+	}
+}
+
+export function getBot(): Bot | null {
+	return botInstance;
+}
+
+export function setAllowedChatId(chatId: number | null): void {
+	allowedChatId = chatId;
+}
+
+export function setIncomingMessageHandler(handler: IncomingMessageHandler | null): void {
+	onIncomingMessage = handler;
+}
+
+/**
+ * Wait for the first message to arrive from any chat.
+ * Used during setup to discover the user's chat ID.
+ */
+export function waitForChatId(): Promise<number> {
+	return new Promise<number>((resolve) => {
+		chatIdDiscoveryResolve = resolve;
+	});
+}
+
+/**
+ * Send a text message. Falls back silently on error.
+ */
+export async function sendText(chatId: number, text: string, parseMode?: "HTML"): Promise<void> {
+	if (!botInstance) return;
+	try {
+		await botInstance.api.sendMessage(chatId, text, {
+			parse_mode: parseMode,
+		});
+	} catch (err: any) {
+		console.error("[telebridge] Send error:", err.message);
+	}
+}
+
+/**
+ * Send a photo. Falls back silently on error.
+ */
+export async function sendPhoto(chatId: number, url: string, caption?: string): Promise<void> {
+	if (!botInstance) return;
+	try {
+		await botInstance.api.sendPhoto(chatId, url, {
+			caption,
+			parse_mode: "HTML",
+		});
+	} catch (err: any) {
+		console.error("[telebridge] Photo send error:", err.message);
+	}
+}
+
+/**
+ * Send a typing indicator.
+ */
+export async function sendTyping(chatId: number): Promise<void> {
+	if (!botInstance) return;
+	try {
+		await botInstance.api.sendChatAction(chatId, "typing");
+	} catch {
+		// Ignore
+	}
+}

package/src/config.ts

@@ -0,0 +1,55 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+
+export interface TelebridgeConfig {
+	botToken: string;
+	chatId: number | null;
+}
+
+const CONFIG_DIR = path.join(os.homedir(), ".pi", "agent");
+const CONFIG_FILE = path.join(CONFIG_DIR, "telebridge.json");
+
+export function loadConfig(): TelebridgeConfig | null {
+	try {
+		const raw = fs.readFileSync(CONFIG_FILE, "utf-8");
+		const data = JSON.parse(raw);
+		if (typeof data.botToken === "string") {
+			return {
+				botToken: data.botToken,
+				chatId: typeof data.chatId === "number" ? data.chatId : null,
+			};
+		}
+		return null;
+	} catch {
+		return null;
+	}
+}
+
+export function saveConfig(config: TelebridgeConfig): void {
+	fs.mkdirSync(CONFIG_DIR, { recursive: true });
+	fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");
+}
+
+export function resolveToken(): string | null {
+	// 1. Environment variable takes priority
+	const envToken = process.env.TELEGRAM_BOT_TOKEN;
+	if (envToken) return envToken;
+
+	// 2. Fall back to config file
+	const config = loadConfig();
+	return config?.botToken ?? null;
+}
+
+export function resolveChatId(): number | null {
+	// 1. Environment variable takes priority
+	const envChatId = process.env.TELEGRAM_CHAT_ID;
+	if (envChatId) {
+		const parsed = parseInt(envChatId, 10);
+		if (!isNaN(parsed)) return parsed;
+	}
+
+	// 2. Fall back to config file
+	const config = loadConfig();
+	return config?.chatId ?? null;
+}

package/src/formatter.ts

@@ -0,0 +1,155 @@
+/**
+ * Converts markdown text to Telegram-compatible HTML.
+ *
+ * Handles:
+ * - Fenced code blocks → <pre><code>...</code></pre>
+ * - Inline code → <code>...</code>
+ * - Bold **text** → <b>text</b>
+ * - Italic *text* → <i>text</i>
+ * - Strikethrough ~~text~~ → <s>text</s>
+ * - Links [text](url) → <a href="url">text</a>
+ * - HTML entity escaping inside code
+ *
+ * Telegram limit: 4096 characters per message.
+ */
+
+const TELEGRAM_MAX_LENGTH = 4096;
+const TRUNCATION_NOTICE = "\n\n<i>[truncated — see pi terminal]</i>";
+
+function escapeHtml(text: string): string {
+	return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+export function markdownToTelegramHtml(md: string): string {
+	let html = "";
+	const lines = md.split("\n");
+	let inCodeBlock = false;
+	let codeLang = "";
+	let codeContent = "";
+
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+
+		// Fenced code block start/end
+		if (line.trimStart().startsWith("```")) {
+			if (!inCodeBlock) {
+				inCodeBlock = true;
+				codeLang = line.trimStart().slice(3).trim();
+				codeContent = "";
+			} else {
+				// Close code block
+				inCodeBlock = false;
+				if (codeLang) {
+					html += `<pre><code class="language-${escapeHtml(codeLang)}">`;
+				} else {
+					html += "<pre><code>";
+				}
+				html += escapeHtml(codeContent);
+				html += "</code></pre>\n";
+				codeLang = "";
+			}
+			continue;
+		}
+
+		if (inCodeBlock) {
+			if (codeContent) codeContent += "\n";
+			codeContent += line;
+			continue;
+		}
+
+		// Normal line — convert inline markdown
+		html += convertInlineMarkdown(line) + "\n";
+	}
+
+	// If code block was never closed, dump it anyway
+	if (inCodeBlock) {
+		html += "<pre><code>";
+		html += escapeHtml(codeContent);
+		html += "</code></pre>\n";
+	}
+
+	return html.trimEnd();
+}
+
+function convertInlineMarkdown(line: string): string {
+	// Escape HTML first in non-code parts
+	// We need to be careful: process inline code first, then escape the rest
+
+	// Extract inline code spans to protect them
+	const codeSpans: string[] = [];
+	let processed = line.replace(/`([^`]+)`/g, (_match, code) => {
+		const idx = codeSpans.length;
+		codeSpans.push(`<code>${escapeHtml(code)}</code>`);
+		return `\x00CODE${idx}\x00`;
+	});
+
+	// Now escape HTML in the remaining text
+	processed = escapeHtml(processed);
+
+	// Bold **text** or __text__
+	processed = processed.replace(/\*\*(.+?)\*\*/g, "<b>$1</b>");
+	processed = processed.replace(/__(.+?)__/g, "<b>$1</b>");
+
+	// Italic *text* or _text_ (but not inside words for underscore)
+	processed = processed.replace(/\*(.+?)\*/g, "<i>$1</i>");
+
+	// Strikethrough ~~text~~
+	processed = processed.replace(/~~(.+?)~~/g, "<s>$1</s>");
+
+	// Links [text](url)
+	processed = processed.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');
+
+	// Restore inline code spans
+	processed = processed.replace(/\x00CODE(\d+)\x00/g, (_match, idx) => {
+		return codeSpans[parseInt(idx, 10)];
+	});
+
+	return processed;
+}
+
+/**
+ * Split a message into chunks that fit Telegram's 4096 char limit.
+ * Tries to split at newlines when possible.
+ */
+export function splitForTelegram(html: string): string[] {
+	if (html.length <= TELEGRAM_MAX_LENGTH) {
+		return [html];
+	}
+
+	const chunks: string[] = [];
+	let remaining = html;
+
+	while (remaining.length > 0) {
+		if (remaining.length <= TELEGRAM_MAX_LENGTH) {
+			chunks.push(remaining);
+			break;
+		}
+
+		// Reserve space for truncation notice on the first chunk if needed
+		const maxChunk = TELEGRAM_MAX_LENGTH - TRUNCATION_NOTICE.length;
+
+		// Try to find a newline to split at
+		let splitAt = remaining.lastIndexOf("\n", maxChunk);
+		if (splitAt <= 0) {
+			// No good newline, just split at max
+			splitAt = maxChunk;
+		}
+
+		const chunk = remaining.slice(0, splitAt);
+		chunks.push(chunk);
+		remaining = remaining.slice(splitAt).trimStart();
+	}
+
+	// Add truncation notice to last chunk if we split
+	if (chunks.length > 1) {
+		const last = chunks[chunks.length - 1];
+		if (last.length + TRUNCATION_NOTICE.length > TELEGRAM_MAX_LENGTH) {
+			// Trim last chunk to fit the notice
+			chunks[chunks.length - 1] = last.slice(0, TELEGRAM_MAX_LENGTH - TRUNCATION_NOTICE.length) + TRUNCATION_NOTICE;
+		} else {
+			chunks[chunks.length - 1] = last + TRUNCATION_NOTICE;
+		}
+	}
+
+	return chunks;
+}

package/src/index.ts

@@ -0,0 +1,246 @@
+import type { ExtensionAPI, ExtensionContext, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import { loadConfig, saveConfig, resolveToken, resolveChatId } from "./config.js";
+import { startBot, stopBot, getBot, setAllowedChatId, setIncomingMessageHandler, waitForChatId, sendText, sendTyping } from "./bot.js";
+import { markdownToTelegramHtml, splitForTelegram } from "./formatter.js";
+
+export default function (pi: ExtensionAPI) {
+	let relayEnabled = false;
+	let chatId: number | null = null;
+	let botToken: string | null = null;
+
+	// ── Setup Flow ──────────────────────────────────────────────
+
+	async function runSetup(ctx: ExtensionCommandContext): Promise<boolean> {
+		// 1. Resolve bot token
+		botToken = resolveToken();
+		if (!botToken) {
+			const input = await ctx.ui.input("Enter your Telegram bot token (from @BotFather):");
+			if (!input || !input.trim()) {
+				ctx.ui.notify("Setup cancelled — no token provided", "warning");
+				return false;
+			}
+			botToken = input.trim();
+		}
+
+		// 2. Start bot
+		ctx.ui.notify("Starting Telegram bot...", "info");
+		try {
+			await startBot(botToken);
+		} catch (err: any) {
+			ctx.ui.notify(`Failed to start bot: ${err.message}`, "error");
+			botToken = null;
+			return false;
+		}
+
+		// 3. Resolve chat ID
+		chatId = resolveChatId();
+		if (!chatId) {
+			ctx.ui.notify("Send any message to your bot on Telegram to link your chat...", "info");
+			chatId = await waitForChatId();
+			ctx.ui.notify(`Chat ID discovered: ${chatId}`, "info");
+		}
+
+		// 4. Persist config
+		saveConfig({ botToken, chatId });
+		setAllowedChatId(chatId);
+
+		// 5. Wire up incoming message handler
+		wireIncomingHandler(ctx);
+
+		ctx.ui.notify(`✅ Telegram connected! Chat ID: ${chatId}`, "info");
+		return true;
+	}
+
+	function isSetUp(): boolean {
+		return getBot() !== null && chatId !== null;
+	}
+
+	// ── Incoming Message Handler ────────────────────────────────
+
+	function wireIncomingHandler(ctx: ExtensionContext) {
+		setIncomingMessageHandler((_incomingChatId, text) => {
+			if (!relayEnabled) {
+				sendText(_incomingChatId, "⚠️ Relay is disabled. Enable with /telegram in pi.");
+				return;
+			}
+
+			// Notify in TUI
+			if (ctx.hasUI) {
+				ctx.ui.notify(`📱 Telegram: ${text.length > 60 ? text.slice(0, 60) + "…" : text}`, "info");
+			}
+
+			// Send to agent
+			if (ctx.isIdle()) {
+				pi.sendUserMessage(text);
+			} else {
+				pi.sendUserMessage(text, { deliverAs: "followUp" });
+			}
+		});
+	}
+
+	// ── Relay Toggle ────────────────────────────────────────────
+
+	async function enableRelay(ctx: ExtensionContext) {
+		relayEnabled = true;
+		pi.appendEntry("telebridge-state", { enabled: true });
+
+		if (ctx.hasUI) {
+			const theme = ctx.ui.theme;
+			ctx.ui.setStatus("telebridge", theme.fg("success", "📡 TG"));
+			ctx.ui.notify("🟢 Telegram relay enabled", "info");
+		}
+
+		if (chatId) {
+			await sendText(chatId, "📡 Connected to pi session");
+		}
+	}
+
+	async function disableRelay(ctx: ExtensionContext) {
+		relayEnabled = false;
+		pi.appendEntry("telebridge-state", { enabled: false });
+
+		if (ctx.hasUI) {
+			ctx.ui.setStatus("telebridge", undefined);
+			ctx.ui.notify("🔴 Telegram relay disabled", "info");
+		}
+
+		if (chatId) {
+			await sendText(chatId, "📴 Disconnected from pi session");
+		}
+	}
+
+	// ── Commands ────────────────────────────────────────────────
+
+	pi.registerCommand("telegram", {
+		description: "Toggle Telegram relay (setup | status | on/off)",
+		handler: async (args, ctx) => {
+			const subcommand = args?.trim().toLowerCase();
+
+			if (subcommand === "setup") {
+				await runSetup(ctx);
+				return;
+			}
+
+			if (subcommand === "status") {
+				const botRunning = getBot() !== null;
+				const lines = [
+					`Bot: ${botRunning ? "✅ running" : "❌ stopped"}`,
+					`Chat ID: ${chatId ?? "not set"}`,
+					`Relay: ${relayEnabled ? "🟢 enabled" : "🔴 disabled"}`,
+				];
+				ctx.ui.notify(lines.join("\n"), "info");
+				return;
+			}
+
+			// Toggle: set up first if needed
+			if (!isSetUp()) {
+				const ok = await runSetup(ctx);
+				if (!ok) return;
+			}
+
+			// Toggle relay
+			if (relayEnabled) {
+				await disableRelay(ctx);
+			} else {
+				await enableRelay(ctx);
+			}
+		},
+	});
+
+	// ── Session Events ──────────────────────────────────────────
+
+	pi.on("session_start", async (_event, ctx) => {
+		// Restore relay state from session entries
+		relayEnabled = false;
+		for (const entry of ctx.sessionManager.getEntries()) {
+			if (entry.type === "custom" && entry.customType === "telebridge-state") {
+				const data = (entry as { data?: { enabled?: boolean } }).data;
+				relayEnabled = data?.enabled ?? false;
+			}
+		}
+
+		// If relay was enabled, try to reconnect the bot
+		if (relayEnabled) {
+			botToken = resolveToken();
+			chatId = resolveChatId();
+
+			if (botToken && chatId) {
+				try {
+					await startBot(botToken);
+					setAllowedChatId(chatId);
+					wireIncomingHandler(ctx);
+
+					if (ctx.hasUI) {
+						const theme = ctx.ui.theme;
+						ctx.ui.setStatus("telebridge", theme.fg("success", "📡 TG"));
+					}
+				} catch {
+					relayEnabled = false;
+					if (ctx.hasUI) {
+						ctx.ui.notify("⚠️ Telebridge: failed to reconnect bot", "warning");
+					}
+				}
+			} else {
+				relayEnabled = false;
+			}
+		}
+	});
+
+	pi.on("session_shutdown", async () => {
+		if (relayEnabled && chatId) {
+			await sendText(chatId, "📴 pi session ended");
+		}
+		await stopBot();
+	});
+
+	// ── Agent → Telegram (outgoing) ─────────────────────────────
+
+	pi.on("agent_start", async () => {
+		if (relayEnabled && chatId) {
+			await sendTyping(chatId);
+		}
+	});
+
+	pi.on("agent_end", async (event) => {
+		if (!relayEnabled || !chatId) return;
+
+		// Extract the last assistant message text
+		const messages = event.messages ?? [];
+		let assistantText = "";
+
+		for (let i = messages.length - 1; i >= 0; i--) {
+			const msg = messages[i];
+			if (msg.role === "assistant") {
+				// Extract text content blocks
+				if (typeof msg.content === "string") {
+					assistantText = msg.content;
+				} else if (Array.isArray(msg.content)) {
+					assistantText = msg.content
+						.filter((block: any) => block.type === "text")
+						.map((block: any) => block.text)
+						.join("\n");
+				}
+				break;
+			}
+		}
+
+		if (!assistantText.trim()) return;
+
+		// Convert markdown to Telegram HTML and split if needed
+		const html = markdownToTelegramHtml(assistantText);
+		const chunks = splitForTelegram(html);
+
+		for (const chunk of chunks) {
+			try {
+				await sendText(chatId!, chunk, "HTML");
+			} catch {
+				// If HTML parsing fails, try plain text
+				try {
+					await sendText(chatId!, assistantText.slice(0, 4096));
+				} catch {
+					// Give up silently
+				}
+			}
+		}
+	});
+}