pi-telegram-plus 0.0.1 → 0.0.2

package/README.md

@@ -1,5 +1,11 @@
 # pi-telegram-plus
 
+<p>
+  <a href="https://www.npmjs.com/package/pi-telegram-plus"><img src="https://img.shields.io/npm/v/pi-telegram-plus?style=flat-square&logo=npm" alt="npm" /></a>
+  <a href="https://github.com/jalyfeng/pi-telegram-plus"><img src="https://img.shields.io/github/license/jalyfeng/pi-telegram-plus?style=flat-square" alt="license" /></a>
+  <img src="https://img.shields.io/badge/node-%3E%3D22.19.0-339933?style=flat-square&logo=node.js" alt="node" />
+</p>
+
 **Full Telegram control of [pi coding agent](https://github.com/earendil-works/pi-coding-agent) — commands, interactive UI, model/session management, file transfer, and real-time streaming output, all from Telegram.**
 
 `pi-telegram-plus` is a pi extension that turns Telegram into a full-featured remote control surface for the pi coding agent. It's not just a notification bot — it mirrors the core pi TUI experience into Telegram, with interactive menus, inline keyboards, file attachments, and live agent output rendering.
@@ -91,6 +97,7 @@ Full interactive UI components built on inline keyboards:
 | `/cwd` | Show current working directory |
 | `/cd` | Switch pi working directory |
 | `/stop` | Abort the current agent turn |
+| `/status` | Show runtime snapshot (workspace, model, context, messages) |
 | `/debug` | Show debug info (model, thinking, streaming, entries) |
 | `/settings` | Open settings menu |
 | `/copy` | Copy last assistant text |
@@ -112,25 +119,23 @@ Full interactive UI components built on inline keyboards:
 - [pi coding agent](https://github.com/earendil-works/pi-coding-agent) installed globally
 - A Telegram bot token from [@BotFather](https://t.me/BotFather)
 
-### Setup
+### Installation
 
-1. **Clone or create the extension directory:**
+**Install via npm (recommended):**
 
 ```bash
-git clone <repo-url> pi-telegram-plus
-cd pi-telegram-plus
-npm install
+pi install npm:pi-telegram-plus
 ```
 
-2. **Configure pi to load the extension:**
+**Or install from source:**
 
 ```bash
-# Inside the pi-telegram-plus directory
+git clone https://github.com/jalyfeng/pi-telegram-plus.git
+cd pi-telegram-plus
+npm install
 pi packages add .
 ```
 
-This registers the extension via `.pi/settings.json`.
-
 3. **Start pi and configure your Telegram bot:**
 
 ```bash
@@ -269,7 +274,7 @@ pi-telegram-plus/
     │   ├── model.ts             # /model, /scoped-models, /thinking
     │   ├── session.ts           # /new, /fork, /clone, /tree, /resume, /cd, /cwd, /name, /session
     │   ├── auth.ts              # /login (OAuth + API key), /logout
-    │   ├── info.ts              # /copy, /export, /import, /share, /changelog, /hotkeys, /debug
+    │   ├── info.ts              # /copy, /export, /import, /share, /status, /changelog, /hotkeys, /debug
     │   ├── lifecycle.ts         # /compact, /reload, /stop, /quit
     │   ├── settings.ts          # /settings menu
     │   ├── tg-config.ts         # /tg-config

package/index.ts

@@ -88,7 +88,11 @@ export default function piTelegramPlus(pi: ExtensionAPI): void {
     refreshStatus();
   };
 
-  const isTelegramEnabled = (): boolean => config.telegramEnabled ?? resolvedConfig?.scope !== "global";
+  const isTelegramEnabled = (): boolean => {
+    if (config.telegramEnabled !== undefined) return config.telegramEnabled;
+    // Default: workspace binding implies intent to use; global requires explicit enable.
+    return resolvedConfig?.scope === "workspace";
+  };
 
   const transport = createTelegramTransport(() => config);
   const ui = createTelegramUiRuntime({
@@ -121,11 +125,11 @@ export default function piTelegramPlus(pi: ExtensionAPI): void {
   // Pi built-in commands (model, session, new, etc.) are already registered by pi core.
   const TUI_VISIBLE_COMMANDS = new Set([
     // tg-* commands
-    "tg-setup", "tg-connect", "tg-disconnect", "tg-config",
-    "tg-bind-cwd", "tg-unbind-cwd", "tg-list",
+    "tg-global-setup", "tg-global-connect", "tg-global-disconnect", "tg-config",
+    "tg-bind-cwd", "tg-unbind-cwd", "tg-cwd-connect", "tg-cwd-disconnect", "tg-list",
     // other pi-telegram-plus custom commands (TUI-only command list excludes /import, which is now
     // a built-in pi command; keep Telegram handler registration only.
-    "cwd", "cd", "thinking", "stop", "debug",
+    "cwd", "cd", "status", "thinking", "stop", "debug",
   ]);
 
   registerAllCommands({
@@ -135,7 +139,10 @@ export default function piTelegramPlus(pi: ExtensionAPI): void {
         pi.registerCommand(name, { description: options.description, handler: options.handler });
       }
     },
-  }, sessionDeps, sessionNameDeps, tgConfigDeps);
+  }, sessionDeps, sessionNameDeps, tgConfigDeps, {
+    getTransport: () => transport,
+    getActiveChatId: () => config.activeChatId,
+  });
 
   registerTelegramCommands({
     registerCommand: (name: string, options: { description?: string; handler: TelegramCommandHandler }) => {
@@ -300,7 +307,7 @@ export default function piTelegramPlus(pi: ExtensionAPI): void {
     } catch (error) {
       switchResolvedConfig({ store: { version: 2, global: {}, workspaces: [] }, scope: "global", config: {} });
       getActiveSession()?.extensionRunner.getUIContext().notify(
-        `Telegram config is not v2 yet. Run /tg-setup to recreate it. ${error instanceof Error ? error.message : String(error)}`,
+        `Telegram config is not v2 yet. Run /tg-global-setup to recreate it. ${error instanceof Error ? error.message : String(error)}`,
         "error",
       );
     }

package/lib/commands/info.ts

@@ -1,8 +1,83 @@
 import { existsSync } from "node:fs";
 import type { CommandRegistry } from "./register.ts";
-import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { escapeHtml } from "../html.ts";
-import type { CapturedAgentSession } from "../types.ts";
+import type { CapturedAgentSession, TelegramTransport } from "../types.ts";
+
+function formatFooterLikeTokenCount(value: number): string {
+  if (value < 1_000) return value.toString();
+  if (value < 10_000) return `${(value / 1_000).toFixed(1)}k`;
+  if (value < 1_000_000) return `${Math.round(value / 1_000)}k`;
+  if (value < 10_000_000) return `${(value / 1_000_000).toFixed(1)}M`;
+  return `${Math.round(value / 1_000_000)}M`;
+}
+
+const STATUS_TEXT_LIMIT = 200;
+
+function truncateStatusText(value: string | undefined): string | undefined {
+  if (value === undefined) return undefined;
+  if (value.length <= STATUS_TEXT_LIMIT) return value;
+  return `${value.slice(0, STATUS_TEXT_LIMIT - 1)}…`;
+}
+
+/**
+ * @internal Exported for tests; not part of the public module API.
+ * Keeps the rendered snapshot under Telegram's 4096-byte (and `splitTelegramText`'s
+ * 3600-byte single-chunk) limit by capping free-form text fields up front.
+ */
+export function buildStatusSnapshot(session: CapturedAgentSession): string {
+  const stats = session.getSessionStats();
+  const usage = session.getContextUsage();
+  const model = session.model;
+  const safeCwd = truncateStatusText(session.sessionManager.getCwd()) ?? "";
+  const safeSessionId = truncateStatusText(stats.sessionId) ?? "";
+  const safeSessionFile = truncateStatusText(stats.sessionFile);
+  const safeSessionName = truncateStatusText(session.sessionManager.getSessionName());
+  const contextWindow = usage?.contextWindow ?? 0;
+  const contextPercent = usage?.percent;
+
+  const stateBadge = session.isStreaming
+    ? "🟢 active"
+    : session.pendingMessageCount > 0
+      ? "🟡 queueing"
+      : "⚪ idle";
+
+  const contextDisplay = contextPercent === null || contextPercent === undefined
+    ? `?/${contextWindow}`
+    : `${contextPercent.toFixed(1)}%/${contextWindow}`;
+
+  // Labels are hard-coded, so escaping is unnecessary; only the value is dynamic.
+  const line = (label: string, value: string): string =>
+    `  <b>${label}</b>  ${escapeHtml(value)}`;
+
+  return [
+    "<b>🛰 TUI Status</b>",
+    "━━━━━━━━━━━━━━━━━━━━",
+    "<b>📂 Workspace</b>",
+    line("cwd", safeCwd),
+    line("session", safeSessionId + (safeSessionName ? ` • ${safeSessionName}` : "")),
+    line("file", safeSessionFile ?? "ephemeral"),
+    "",
+    "<b>🤖 Model</b>",
+    line("model", model ? `${model.provider}/${model.id}` : "(none)"),
+    line("thinking", session.thinkingLevel),
+    line("state", stateBadge),
+    line("queued", String(session.pendingMessageCount)),
+    "",
+    "<b>📊 Context &amp; Tokens</b>",
+    line("context", contextDisplay),
+    line("in", formatFooterLikeTokenCount(stats.tokens.input)),
+    line("out", formatFooterLikeTokenCount(stats.tokens.output)),
+    line("cache R", formatFooterLikeTokenCount(stats.tokens.cacheRead)),
+    line("cache W", formatFooterLikeTokenCount(stats.tokens.cacheWrite)),
+    line("total", formatFooterLikeTokenCount(stats.tokens.total)),
+    line("cost", `$${stats.cost.toFixed(4)}`),
+    "",
+    "<b>💬 Messages</b>",
+    line("user", String(stats.userMessages)),
+    line("assistant", String(stats.assistantMessages)),
+    line("tool calls", String(stats.toolCalls)),
+  ].join("\n");
+}
 
 /**
  * All command handlers capture ctx.ui at entry and use the captured reference.
@@ -10,7 +85,13 @@ import type { CapturedAgentSession } from "../types.ts";
  */
 export function registerInfoCommands(
   registry: CommandRegistry,
-  deps: { getSession: () => CapturedAgentSession | undefined },
+  deps: {
+    getSession: () => CapturedAgentSession | undefined;
+    /** Optional transport for direct sends (bypasses ui.notify wrapping). */
+    getTransport?: () => TelegramTransport | undefined;
+    /** Optional active chat id used for direct sends. */
+    getActiveChatId?: () => number | undefined;
+  },
 ): void {
   // ── /copy ──────────────────────────────────────────────────────────────
   registry.registerCommand("copy", {
@@ -27,6 +108,31 @@ export function registerInfoCommands(
     },
   });
 
+  // ── /status ───────────────────────────────────────────────────────────
+  registry.registerCommand("status", {
+    description: "Show runtime snapshot (workspace, model, context, messages)",
+    handler: async (_args, ctx) => {
+      const ui = ctx.ui;
+      const session = deps.getSession();
+      if (!session) {
+        ui.notify("No active session", "error");
+        return;
+      }
+
+      const html = buildStatusSnapshot(session);
+      const transport = deps.getTransport?.();
+      const chatId = deps.getActiveChatId?.();
+      if (transport && chatId !== undefined) {
+        await transport.sendText(chatId, html).catch(() => {
+          // Fall back to the standard notify path if the direct send fails.
+          ui.notify(html.replace(/<[^>]+>/g, ""), "info");
+        });
+        return;
+      }
+      ui.notify(html, "info");
+    },
+  });
+
   // ── /export ────────────────────────────────────────────────────────────
   registry.registerCommand("export", {
     description: "Export session to HTML or JSONL",

package/lib/commands/register.ts

@@ -1,4 +1,4 @@
-import type { CapturedAgentSession } from "../types.ts";
+import type { CapturedAgentSession, TelegramTransport } from "../types.ts";
 import { registerModelCommands } from "./model.ts";
 import { registerSessionCommands } from "./session.ts";
 import { registerAuthCommands } from "./auth.ts";
@@ -29,12 +29,24 @@ export type TgConfigDeps = SessionDeps & {
   persistConfig: (c: import("../types.ts").TelegramConfig) => Promise<void>;
 };
 
-export function registerAllCommands(registry: CommandRegistry, sessionDeps: SessionDeps, sessionNameDeps: SessionNameDeps, tgConfigDeps?: TgConfigDeps): void {
+/** Optional deps for commands that need to send preformatted HTML directly. */
+export type InfoDeps = {
+  getTransport?: () => TelegramTransport | undefined;
+  getActiveChatId?: () => number | undefined;
+};
+
+export function registerAllCommands(
+  registry: CommandRegistry,
+  sessionDeps: SessionDeps,
+  sessionNameDeps: SessionNameDeps,
+  tgConfigDeps?: TgConfigDeps,
+  infoDeps?: InfoDeps,
+): void {
   registerSettingsCommands(registry, sessionDeps);
   registerModelCommands(registry, sessionDeps);
   registerSessionCommands(registry, sessionNameDeps);
   registerAuthCommands(registry, sessionDeps);
-  registerInfoCommands(registry, sessionDeps);
+  registerInfoCommands(registry, { ...sessionDeps, ...(infoDeps ?? {}) });
   registerLifecycleCommands(registry);
   if (tgConfigDeps) registerTgConfigCommands(registry, tgConfigDeps);
 }

package/lib/commands/telegram-commands.ts

@@ -1,5 +1,5 @@
 import { resolve } from "node:path";
-import { bindWorkspaceTelegramConfig, readTelegramConfigStore, unbindWorkspaceTelegramConfig } from "../config.ts";
+import { bindWorkspaceTelegramConfig, readTelegramConfigStore, unbindWorkspaceTelegramConfig, writeGlobalTelegramConfig } from "../config.ts";
 import { escapeHtml } from "../html.ts";
 import { getTelegramBotUsername } from "../telegram-api.ts";
 import type { ResolvedTelegramConfig, TelegramConfig, TelegramTransport } from "../types.ts";
@@ -20,82 +20,103 @@ export type TelegramCommandDeps = {
   clearStatusError: () => void;
 };
 
-/** Shared "connect and start" sequence used by both /tg-setup and /tg-connect. */
-async function connectAndStart(
+/** Shared "connect and start" sequence for the global bot. */
+async function globalConnectAndStart(
   deps: TelegramCommandDeps,
   token: string,
   botUsername: string | undefined,
 ): Promise<void> {
   const config = deps.getConfig();
   deps.setConfig({ ...config, botToken: token, botUsername, telegramEnabled: true });
-  await deps.persistConfig(deps.getConfig());
+  await writeGlobalTelegramConfig({ botToken: token, botUsername, telegramEnabled: true });
   deps.getPolling().start();
   await deps.syncTelegramCommands();
   deps.refreshStatus();
 }
 
-export function configureTelegramToken(
+async function configureGlobalTelegramToken(
   ui: { input: (title: string, placeholder?: string) => Promise<string | undefined>; inputSecret?: (title: string, placeholder?: string) => Promise<string | undefined> },
   deps: TelegramCommandDeps,
 ): Promise<boolean> {
-  return (async () => {
-    const token = await (ui.inputSecret?.("Telegram bot token") ?? ui.input("Telegram bot token"));
-    if (!token) return false;
-    const botUsername = await getTelegramBotUsername(token).catch(() => undefined);
-    if (!deps.getResolvedConfig()) {
-      deps.switchResolvedConfig({ store: { version: 2, global: {}, workspaces: [] }, scope: "global", config: {} });
+  const token = await (ui.inputSecret?.("Telegram bot token") ?? ui.input("Telegram bot token"));
+  if (!token) return false;
+  const botUsername = await getTelegramBotUsername(token).catch(() => undefined);
+  if (!deps.getResolvedConfig()) {
+    deps.switchResolvedConfig({ store: { version: 2, global: {}, workspaces: [] }, scope: "global", config: {} });
+  }
+  await globalConnectAndStart(deps, token, botUsername);
+  return true;
+}
+
+// ── Handler implementations for reuse by aliases ──────────────────────────
+
+async function handleTgGlobalSetup(
+  _args: string,
+  ctx: any,
+  deps: TelegramCommandDeps,
+): Promise<void> {
+  const ui = ctx.ui as typeof ctx.ui & { inputSecret?: (title: string, placeholder?: string) => Promise<string | undefined> };
+  if (!(await configureGlobalTelegramToken(ui, deps))) return;
+  deps.clearStatusError();
+  deps.startStatusHeartbeat();
+  ui.notify("Telegram global bot token saved and connected.", "info");
+}
+
+async function handleTgGlobalConnect(
+  _args: string,
+  ctx: any,
+  deps: TelegramCommandDeps,
+): Promise<void> {
+  const ui = ctx.ui as typeof ctx.ui & { inputSecret?: (title: string, placeholder?: string) => Promise<string | undefined> };
+  try {
+    if (!deps.getConfig().botToken) {
+      if (!(await configureGlobalTelegramToken(ui, deps))) return;
+    } else {
+      const botUsername = deps.getConfig().botUsername ?? await getTelegramBotUsername(deps.getConfig().botToken!).catch(() => undefined);
+      await globalConnectAndStart(deps, deps.getConfig().botToken!, botUsername);
     }
-    await connectAndStart(deps, token, botUsername);
-    return true;
-  })();
+  } catch { /* connection errors reported via polling onError */ }
+  deps.clearStatusError();
+  deps.startStatusHeartbeat();
+  ui.notify("Telegram global bot connected.", "info");
+}
+
+async function handleTgGlobalDisconnect(
+  _args: string,
+  ctx: any,
+  deps: TelegramCommandDeps,
+): Promise<void> {
+  await deps.getPolling().stop();
+  const config = deps.getConfig();
+  deps.setConfig({ ...config, telegramEnabled: false });
+  await writeGlobalTelegramConfig({ telegramEnabled: false });
+  deps.clearStatusError();
+  deps.refreshStatus();
+  ctx.ui.notify("Telegram global bot disconnected. Token is kept; use /tg-global-connect to reconnect.", "info");
 }
 
+// ── Registration ──────────────────────────────────────────────────────────
+
 export function registerTelegramCommands(
   registry: { registerCommand: (name: string, options: { description?: string; handler: (args: string, ctx: any) => Promise<void> }) => void },
   deps: TelegramCommandDeps,
 ): void {
-  // ── /tg-setup ─────────────────────────────────────────────────────────
-  registry.registerCommand("tg-setup", {
-    description: "Configure Telegram bot token",
-    handler: async (_args, ctx) => {
-      const ui = ctx.ui as typeof ctx.ui & { inputSecret?: (title: string, placeholder?: string) => Promise<string | undefined> };
-      if (!(await configureTelegramToken(ui, deps))) return;
-      deps.clearStatusError();
-      deps.startStatusHeartbeat();
-      ui.notify("Telegram bot token saved and connected.", "info");
-    },
+  // ── /tg-global-setup ──────────────────────────────────────────────────
+  registry.registerCommand("tg-global-setup", {
+    description: "Configure global Telegram bot token and connect",
+    handler: (args, ctx) => handleTgGlobalSetup(args, ctx, deps),
   });
 
-  // ── /tg-connect ───────────────────────────────────────────────────────
-  registry.registerCommand("tg-connect", {
-    description: "Enable/start Telegram connection",
-    handler: async (_args, ctx) => {
-      const ui = ctx.ui as typeof ctx.ui & { inputSecret?: (title: string, placeholder?: string) => Promise<string | undefined> };
-      try {
-        if (!deps.getConfig().botToken) {
-          if (!(await configureTelegramToken(ui, deps))) return;
-        } else {
-          const botUsername = deps.getConfig().botUsername ?? await getTelegramBotUsername(deps.getConfig().botToken!).catch(() => undefined);
-          await connectAndStart(deps, deps.getConfig().botToken!, botUsername);
-        }
-      } catch { /* connection errors reported via polling onError */ }
-      deps.clearStatusError();
-      deps.startStatusHeartbeat();
-      ui.notify("Telegram connected.", "info");
-    },
+  // ── /tg-global-connect ────────────────────────────────────────────────
+  registry.registerCommand("tg-global-connect", {
+    description: "Enable/start the global Telegram bot connection",
+    handler: (args, ctx) => handleTgGlobalConnect(args, ctx, deps),
   });
 
-  // ── /tg-disconnect ────────────────────────────────────────────────────
-  registry.registerCommand("tg-disconnect", {
-    description: "Disable/stop Telegram connection without deleting the token",
-    handler: async (_args, ctx) => {
-      await deps.getPolling().stop();
-      deps.setConfig({ ...deps.getConfig(), telegramEnabled: false });
-      await deps.persistConfig(deps.getConfig());
-      deps.clearStatusError();
-      deps.refreshStatus();
-      ctx.ui.notify("Telegram disconnected. Token is kept; use /tg-connect to reconnect.", "info");
-    },
+  // ── /tg-global-disconnect ─────────────────────────────────────────────
+  registry.registerCommand("tg-global-disconnect", {
+    description: "Disable/stop the global Telegram bot without deleting the token",
+    handler: (args, ctx) => handleTgGlobalDisconnect(args, ctx, deps),
   });
 
   // ── /tg-bind-cwd ──────────────────────────────────────────────────────
@@ -125,6 +146,57 @@ export function registerTelegramCommands(
     },
   });
 
+  // ── /tg-cwd-connect ───────────────────────────────────────────────────
+  registry.registerCommand("tg-cwd-connect", {
+    description: "Enable the Telegram bot for the current directory",
+    handler: async (_args, ctx) => {
+      const previousScope = deps.getResolvedConfig()?.scope;
+      const config = deps.getConfig();
+      // If no bot token is configured at all, prompt user to bind or set up global first
+      if (!config.botToken && !deps.getResolvedConfig()?.store.global?.botToken) {
+        ctx.ui.notify("No Telegram bot configured. Use /tg-global-setup or /tg-bind-cwd first.", "error");
+        return;
+      }
+      // If no token in current scope, try falling back to global
+      if (!config.botToken) {
+        const global = deps.getResolvedConfig()?.store.global;
+        if (global?.botToken) {
+          deps.setConfig({ ...config, botToken: global.botToken, botUsername: global.botUsername });
+        }
+      }
+      deps.setConfig({ ...deps.getConfig(), telegramEnabled: true });
+      await deps.persistConfig(deps.getConfig());
+      await deps.getPolling().stop();
+      if (deps.isTelegramEnabled()) deps.getPolling().start();
+      deps.clearStatusError();
+      deps.startStatusHeartbeat();
+      ctx.ui.notify(`Telegram bot enabled for current scope (${previousScope}).`, "info");
+    },
+  });
+
+  // ── /tg-cwd-disconnect ────────────────────────────────────────────────
+  registry.registerCommand("tg-cwd-disconnect", {
+    description: "Disable the Telegram bot for the current directory",
+    handler: async (_args, ctx) => {
+      const previousScope = deps.getResolvedConfig()?.scope;
+      await deps.getPolling().stop();
+      deps.setConfig({ ...deps.getConfig(), telegramEnabled: false });
+      await deps.persistConfig(deps.getConfig());
+      // If there's a global bot token, switch to it when disabling workspace bot
+      if (previousScope === "workspace") {
+        const global = deps.getResolvedConfig()?.store.global;
+        if (global?.botToken && global?.telegramEnabled !== false) {
+          deps.setConfig({ ...deps.getConfig(), botToken: global.botToken, botUsername: global.botUsername, telegramEnabled: true });
+          await deps.persistConfig(deps.getConfig());
+          deps.getPolling().start();
+        }
+      }
+      deps.clearStatusError();
+      deps.refreshStatus();
+      ctx.ui.notify(`Telegram bot disabled for current scope (${previousScope}).`, "info");
+    },
+  });
+
   // ── /tg-unbind-cwd ────────────────────────────────────────────────────
   registry.registerCommand("tg-unbind-cwd", {
     description: "Remove current directory Telegram bot binding",
@@ -135,7 +207,14 @@ export function registerTelegramCommands(
         return;
       }
       await deps.getPolling().stop();
+      const global = previous.store.global;
       deps.switchResolvedConfig(await unbindWorkspaceTelegramConfig(ctx.cwd || process.cwd()));
+      // Fall back to global bot if it exists and is enabled
+      if (global?.botToken && global?.telegramEnabled !== false) {
+        const newConfig = deps.getConfig();
+        deps.setConfig({ ...newConfig, botToken: global.botToken, botUsername: global.botUsername });
+        await deps.persistConfig(deps.getConfig());
+      }
       if (deps.isTelegramEnabled()) deps.getPolling().start();
       await deps.syncTelegramCommands();
       deps.refreshStatus();
@@ -149,11 +228,14 @@ export function registerTelegramCommands(
     handler: async (_args, ctx) => {
       const store = await readTelegramConfigStore();
       const lines = [
-        `global: ${store.global?.botUsername ? `@${store.global.botUsername}` : store.global?.botToken ? "configured" : "not configured"}`,
+        `global: ${store.global?.botUsername ? `@${store.global.botUsername}` : store.global?.botToken ? "configured" : "not configured"}${store.global?.telegramEnabled === false ? " (disabled)" : store.global?.telegramEnabled ? "" : ""}`,
         "",
         "workspaces:",
         ...((store.workspaces ?? []).length
-          ? (store.workspaces ?? []).map((workspace) => `- ${escapeHtml(workspace.path)}\n  ${workspace.config.botUsername ? `@${workspace.config.botUsername}` : workspace.config.botToken ? "configured" : "not configured"}`)
+          ? (store.workspaces ?? []).map((workspace) => {
+            const status = workspace.config.telegramEnabled === false ? " (disabled)" : "";
+            return `- ${escapeHtml(workspace.path)}\n  ${workspace.config.botUsername ? `@${workspace.config.botUsername}${status}` : workspace.config.botToken ? `configured${status}` : "not configured"}`;
+          })
           : ["none"]),
       ];
       ctx.ui.notify(lines.join("\n"), "info");

package/lib/config.ts

@@ -48,7 +48,7 @@ async function withTelegramConfigLock<T>(run: () => Promise<T>): Promise<T> {
 
 function assertV2Store(value: unknown): TelegramConfigStore {
   if (!value || typeof value !== "object" || (value as { version?: unknown }).version !== 2) {
-    throw new Error("Unsupported Telegram config format. Please recreate ~/.pi/agent/tg.json as version 2 or run /tg-setup.");
+    throw new Error("Unsupported Telegram config format. Please recreate ~/.pi/agent/tg.json as version 2 or run /tg-global-setup.");
   }
   const store = value as TelegramConfigStore;
   return {
@@ -169,3 +169,15 @@ export async function unbindWorkspaceTelegramConfig(cwd: string): Promise<Resolv
     return resolveTelegramConfigStore(store, cwd);
   });
 }
+
+/**
+ * Update only the global section of the Telegram config store.
+ * Merges with existing global config and preserves lastUpdateId monotonically.
+ */
+export async function writeGlobalTelegramConfig(config: TelegramConfig): Promise<void> {
+  await withTelegramConfigLock(async () => {
+    const store = await readTelegramConfigStore();
+    store.global = mergeTelegramConfigForWrite(store.global, config);
+    await writeTelegramConfigStore(store);
+  });
+}

package/lib/markdown.ts

@@ -11,7 +11,14 @@ interface TelegramRendererContext {
 
 function inlineFromTokens(this: TelegramRendererContext, tokens?: unknown[], fallback = ""): string {
   if (Array.isArray(tokens) && tokens.length > 0) {
-    return this.parser.parseInline(tokens as unknown[]);
+    // Temporarily disable \\n appending since this is inline context
+    const prev = _textAppendNewline;
+    _textAppendNewline = false;
+    try {
+      return this.parser.parseInline(tokens as unknown[]);
+    } finally {
+      _textAppendNewline = prev;
+    }
   }
   return escapeHtml(fallback);
 }
@@ -23,9 +30,99 @@ function blockFromTokens(this: TelegramRendererContext, tokens?: unknown[], fall
   return escapeHtml(fallback);
 }
 
+/**
+ * Calculate visible width of text in a monospace environment.
+ * ASCII = 1, CJK / fullwidth / emoji = 2.
+ */
+function visibleWidth(text: string): number {
+  let width = 0;
+  for (const char of text) {
+    const code = char.codePointAt(0)!;
+    if (code <= 0x1f || (code >= 0x7f && code <= 0x9f)) continue;
+    if (
+      (code >= 0x2e80 && code <= 0x9fff) ||   // CJK, Yi, Hangul syllables
+      (code >= 0xac00 && code <= 0xd7af) ||   // Hangul
+      (code >= 0xf900 && code <= 0xfaff) ||   // CJK compatibility
+      (code >= 0xfe30 && code <= 0xfe6f) ||   // CJK compat forms
+      (code >= 0xff01 && code <= 0xff60) ||   // fullwidth forms
+      (code >= 0xffe0 && code <= 0xffe6) ||   // fullwidth signs
+      (code >= 0x1f000 && code <= 0x1f9ff) || // emoji
+      code >= 0x20000                          // CJK extension B
+    ) {
+      width += 2;
+    } else {
+      width += 1;
+    }
+  }
+  return width;
+}
+
+/** Strip HTML tags for visible width calculation. */
+function stripHtmlTags(html: string): string {
+  return html.replace(/<[^>]+>/g, "");
+}
+
+/**
+ * Pad cell text (which may contain HTML tags) to the given visible width.
+ * Optionally wraps the whole cell in <b> for header styling.
+ */
+function padCell(text: string, width: number, bold = false): string {
+  const currentWidth = visibleWidth(stripHtmlTags(text));
+  const padding = Math.max(0, width - currentWidth);
+  // Only wrap in <b> if the text doesn't already start with <b>
+  const cell = bold && !text.startsWith("<b>") ? `<b>${text}</b>` : text;
+  return cell + " ".repeat(padding);
+}
+
+/**
+ * Track list nesting depth for proper indentation.
+ * Resets per top-level markdownToTelegramHtml call.
+ */
+let _listDepth = 0;
+
+/**
+ * Flag: when true, the text renderer appends \\n after content.
+ * True during block-level parse (parser.parse), false during inline
+ * (parser.parseInline) so inline text tokens don't get spurious newlines.
+ */
+let _textAppendNewline = true;
+
 const renderer = {
-  heading(this: TelegramRendererContext, { tokens }: Tokens.Heading): string {
-    return `<b>${inlineFromTokens.call(this, tokens)}</b>\n`;
+  text(this: TelegramRendererContext, token: Tokens.Text | Tokens.Escape): string {
+    if ('tokens' in token && token.tokens && token.tokens.length > 0) {
+      // Text with nested inline tokens — parse inline (disable \\n for nested),
+      // then add \\n only if we are at block level
+      const prev = _textAppendNewline;
+      _textAppendNewline = false;
+      try {
+        return this.parser.parseInline(token.tokens as unknown[]) + (prev ? '\n' : '');
+      } finally {
+        _textAppendNewline = prev;
+      }
+    }
+    // Plain text / escape token
+    return escapeHtml(token.text) + (_textAppendNewline ? '\n' : '');
+  },
+
+  checkbox(this: TelegramRendererContext): string {
+    // Suppress default <input> rendering; custom [x]/[ ] marker is added by list renderer
+    return "";
+  },
+
+
+  heading(this: TelegramRendererContext, token: Tokens.Heading): string {
+    const content = inlineFromTokens.call(this, token.tokens);
+    if (token.depth === 1) {
+      // H1: bold + underline, matching TUI style
+      return `<b><u>${content}</u></b>\n`;
+    }
+    if (token.depth >= 3) {
+      // H3+: bold with # prefix, matching TUI style
+      const prefix = "#".repeat(token.depth) + " ";
+      return `<b>${escapeHtml(prefix)}${content}</b>\n`;
+    }
+    // H2: bold only
+    return `<b>${content}</b>\n`;
   },
 
   paragraph(this: TelegramRendererContext, { tokens }: Tokens.Paragraph): string {
@@ -49,37 +146,101 @@ const renderer = {
   },
 
   code(this: TelegramRendererContext, { text, lang }: Tokens.Code): string {
-    const language = lang ? ` class="language-${escapeHtml(lang)}"` : "";
-    return `<pre><code${language}>${escapeHtml(text)}\n</code></pre>`;
+    const codeContent = escapeHtml(text);
+    const langTag = lang ? escapeHtml(lang) : "";
+    const openMarker = langTag ? `\`\`\`${langTag}` : "\`\`\`";
+    return `<pre><code>${openMarker}\n${codeContent}\n\`\`\`\n</code></pre>`;
   },
 
   table(this: TelegramRendererContext, token: Tokens.Table): string {
-    const rows: string[] = [];
-    if (token.header.length > 0) {
-      rows.push(token.header.map((c) => inlineFromTokens.call(this, c.tokens, c.text)).join(" | "));
-      rows.push(token.header.map(() => "---").join("-+-"));
+    const numCols = token.header.length;
+    if (numCols === 0) return "";
+
+    // Calculate column widths based on all cells (header + rows)
+    const colWidths: number[] = [];
+    for (let i = 0; i < numCols; i++) {
+      let maxW = 0;
+      const hText = stripHtmlTags(inlineFromTokens.call(this, token.header[i].tokens, token.header[i].text));
+      maxW = Math.max(maxW, visibleWidth(hText));
+      for (const row of token.rows) {
+        if (i < row.length) {
+          const cText = stripHtmlTags(inlineFromTokens.call(this, row[i].tokens, row[i].text));
+          maxW = Math.max(maxW, visibleWidth(cText));
+        }
+      }
+      colWidths.push(Math.max(1, maxW));
     }
+
+    const lines: string[] = [];
+
+    // Top border
+    lines.push(`┌─${colWidths.map(w => "─".repeat(w)).join("─┬─")}─┐`);
+
+    // Header (bold)
+    const headerCells = token.header.map((c, i) =>
+      padCell(inlineFromTokens.call(this, c.tokens, c.text), colWidths[i], true),
+    );
+    lines.push(`│ ${headerCells.join(" │ ")} │`);
+
+    // Separator
+    lines.push(`├─${colWidths.map(w => "─".repeat(w)).join("─┼─")}─┤`);
+
+    // Data rows
     for (const row of token.rows) {
-      rows.push(row.map((c) => inlineFromTokens.call(this, c.tokens, c.text)).join(" | "));
+      const cells = row.map((c, i) =>
+        padCell(inlineFromTokens.call(this, c.tokens, c.text), colWidths[i], false),
+      );
+      while (cells.length < numCols) {
+        cells.push(" ".repeat(colWidths[cells.length]));
+      }
+      lines.push(`│ ${cells.join(" │ ")} │`);
     }
-    return `<pre>${rows.join("\n")}</pre>\n`;
+
+    // Bottom border
+    lines.push(`└─${colWidths.map(w => "─".repeat(w)).join("─┴─")}─┘`);
+
+    return `<pre>${lines.join("\n")}</pre>\n`;
   },
 
   list(this: TelegramRendererContext, token: Tokens.List): string {
-    const start = typeof token.start === "number" ? token.start : 1;
-    const lines = token.items.map((item, index) => {
-      const bullet = token.ordered ? `${start + index}. ` : "• ";
-      return bullet + blockFromTokens.call(this, item.tokens, item.text);
-    });
-    return lines.join("\n") + "\n";
+    _listDepth++;
+    try {
+      const start = typeof token.start === "number" ? token.start : 1;
+      const baseIndent = "  ".repeat(Math.max(0, _listDepth - 1));
+      const lines = token.items.map((item, index) => {
+        const bullet = token.ordered ? `${start + index}. ` : "- ";
+        const taskMarker = item.task ? `[${item.checked ? "x" : " "}] ` : "";
+        const marker = bullet + taskMarker;
+        const content = blockFromTokens.call(this, item.tokens, item.text);
+        const contentLines = content.trimEnd().split("\n");
+        const contIndent = " ".repeat(visibleWidth(marker));
+        return contentLines.map((line, i) => {
+          const prefix = i === 0 ? baseIndent + marker : baseIndent + contIndent;
+          return prefix + line;
+        }).join("\n");
+      });
+      return lines.join("\n") + "\n";
+    } finally {
+      _listDepth--;
+    }
   },
 
   listitem(this: TelegramRendererContext, token: Tokens.ListItem): string {
+    // Used when a list item contains block-level children (e.g. nested lists).
+    // blockFromTokens will re-enter `list` for nested lists via parser.parse().
     return blockFromTokens.call(this, token.tokens, token.text);
   },
 
   blockquote(this: TelegramRendererContext, { tokens }: Tokens.Blockquote): string {
-    return `<blockquote>${this.parser.parse(tokens as unknown[])}</blockquote>`;
+    const content = this.parser.parse(tokens as unknown[]).trim();
+    // Only wrap in <i> if content doesn't contain block-level tags
+    const shouldItalic = !/^<blockquote|^<pre|^<ul|^<ol|^<table/i.test(content);
+    const wrapped = shouldItalic ? `<i>${content}</i>` : content;
+    return `<blockquote>${wrapped}</blockquote>\n`;
+  },
+
+  hr(this: TelegramRendererContext): string {
+    return `<pre>─────────────────────</pre>\n`;
   },
 
   image(this: TelegramRendererContext, { text, title }: Tokens.Image): string {
@@ -95,6 +256,8 @@ marked.use({ renderer });
  * formatting within the Telegram supported subset.
  */
 export function markdownToTelegramHtml(markdown: string): string {
+  _listDepth = 0;
+  _textAppendNewline = true;
   return (marked.parse(markdown, { async: false }) as string).replace(/\n+$/, "");
 }
 

package/lib/menu-commands.ts

@@ -31,14 +31,15 @@ const TELEGRAM_MENU_COMMANDS: Array<{ command: string; description: string }> =
   { command: "thinking", description: "Show or change thinking level" },
   { command: "stop", description: "Stop the current agent turn" },
   { command: "debug", description: "Show debug information" },
+  { command: "status", description: "Show runtime snapshot (workspace, model, context, messages)" },
   // tg-* commands visible in the Telegram bot menu.
   // tg-bind-cwd / tg-unbind-cwd are workspace-management commands that
   // require local cwd context and do not belong in the bot command list.
-  { command: "tg-setup", description: "Configure Telegram bot token" },
-  { command: "tg-connect", description: "Enable/start Telegram connection" },
-  { command: "tg-disconnect", description: "Disable/stop Telegram connection" },
-  { command: "tg-config", description: "Configure Telegram message rendering" },
-  { command: "tg-list", description: "List Telegram bot bindings" },
+  { command: "tg_global_setup", description: "Configure global Telegram bot token" },
+  { command: "tg_global_connect", description: "Enable/start global Telegram bot" },
+  { command: "tg_global_disconnect", description: "Disable/stop global Telegram bot" },
+  { command: "tg_config", description: "Configure Telegram message rendering" },
+  { command: "tg_list", description: "List Telegram bot bindings" },
 ];
 
 const toTelegramCommandName = (name: string): string | undefined => {

package/lib/renderer.ts

@@ -201,15 +201,18 @@ export function registerTelegramRenderer(
   };
 
   pi.on("agent_start", async () => {
+    try {
     sentInlineEvents.clear();
     toolArgs.clear();
     toolUpdateAt.clear();
     const turn = deps.getActiveTurn();
     if (!turn) return;
     if (turn.replaceMessageId !== undefined) await deps.transport.editText(turn.chatId, turn.replaceMessageId, "🤖 <b>Working…</b>");
+    } catch { /* suppressed */ }
   });
 
   pi.on("tool_execution_start", async (event) => {
+    try {
     const level = renderLevel(deps.getConfig(), "tool");
     if (level === "hidden") return;
     toolArgs.set(event.toolCallId, event.args);
@@ -218,9 +221,11 @@ export function registerTelegramRenderer(
       : `🔧 ${event.toolName} started
 ${stringifyShort(event.args, 1200)}`;
     await sendInlineEvent(inline);
+    } catch { /* suppressed */ }
   });
 
   pi.on("tool_execution_update", async (event) => {
+    try {
     const level = renderLevel(deps.getConfig(), "tool");
     if (level !== "full") return;
     const now = Date.now();
@@ -231,9 +236,11 @@ ${stringifyShort(event.args, 1200)}`;
     if (!partial || partial === "{}") return;
     await sendInlineEvent(`🔄 ${event.toolName} update
 ${partial}`);
+    } catch { /* suppressed */ }
   });
 
   pi.on("tool_execution_end", async (event) => {
+    try {
     const level = renderLevel(deps.getConfig(), "tool");
     toolUpdateAt.delete(event.toolCallId);
     const args = toolArgs.get(event.toolCallId);
@@ -250,9 +257,11 @@ ${partial}`);
 ${result}`
         : `${status}: ${event.toolName}`);
     }
+    } catch { /* suppressed */ }
   });
 
   pi.on("message_end", async (event) => {
+    try {
     const message = event.message as AnyMessage;
     if (message.role !== "assistant") return;
     const config = deps.getConfig();
@@ -279,6 +288,7 @@ ${result}`
       await deps.transport.editText(turn.chatId, turn.replaceMessageId, `✅ <b>Output sent.</b>\n${noun}`);
       turn.replaceMessageId = undefined;
     }
+    } catch { /* suppressed */ }
   });
 
 }

package/lib/telegram-api.ts

@@ -50,12 +50,17 @@ export async function telegramApi<T>(
   body: Record<string, unknown>,
   signal?: AbortSignal,
 ): Promise<T> {
-  const response = await fetch(`https://api.telegram.org/bot${token}/${method}`, {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify(body),
-    signal,
-  });
+  let response: Response;
+  try {
+    response = await fetch(`https://api.telegram.org/bot${token}/${method}`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body),
+      signal,
+    });
+  } catch (error) {
+    throw new Error(`Telegram API request failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
   const json = (await response.json()) as TelegramApiError & { result: T };
   if (!json.ok) throw new Error(json.description ?? `${method} failed`);
   return json.result;
@@ -72,10 +77,15 @@ export async function getTelegramFile(token: string, fileId: string, signal?: Ab
 
 export async function downloadTelegramFile(token: string, filePath: string, signal?: AbortSignal): Promise<Buffer> {
   const encodedPath = filePath.split("/").map((segment) => encodeURIComponent(segment)).join("/");
-  const response = await fetch(`https://api.telegram.org/file/bot${token}/${encodedPath}`, {
-    method: "GET",
-    signal,
-  });
+  let response: Response;
+  try {
+    response = await fetch(`https://api.telegram.org/file/bot${token}/${encodedPath}`, {
+      method: "GET",
+      signal,
+    });
+  } catch (error) {
+    throw new Error(`Telegram file download failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
   if (!response.ok) {
     throw new Error(`Failed to download Telegram file: ${response.status}`);
   }
@@ -234,14 +244,19 @@ export function createTelegramTransport(getConfig: () => TelegramConfig): Telegr
             type: inferMimeTypeFromPath(path) ?? "application/octet-stream",
           });
           form.set("document", documentBlob, basename(path));
-          const response = await fetch(`https://api.telegram.org/bot${token}/sendDocument`, {
-            method: "POST",
-            body: form,
-            signal,
-          });
-          const json = await response.json() as { ok: boolean; description?: string };
-          if (!json.ok) throw new Error(json.description ?? "sendDocument failed");
-          return;
+          try {
+            const response = await fetch(`https://api.telegram.org/bot${token}/sendDocument`, {
+              method: "POST",
+              body: form,
+              signal,
+            });
+            const json = await response.json() as { ok: boolean; description?: string };
+            if (!json.ok) throw new Error(json.description ?? "sendDocument failed");
+            return;
+          } catch (fetchError) {
+            if ((fetchError as any)?.name === "AbortError") throw fetchError;
+            throw new Error(`Telegram sendDocument failed: ${fetchError instanceof Error ? fetchError.message : String(fetchError)}`);
+          }
         } catch (error) {
           lastError = error;
           if (attempt >= maxRetries || signal?.aborted) throw error;
@@ -272,14 +287,19 @@ export function createTelegramTransport(getConfig: () => TelegramConfig): Telegr
             const bytes = Buffer.from(base64, "base64");
             form.set("photo", new Blob([bytes], { type: mime }), `image.${mime.split("/")[1] ?? "png"}`);
           }
-          const response = await fetch(`https://api.telegram.org/bot${token}/sendPhoto`, {
-            method: "POST",
-            body: form,
-            signal,
-          });
-          const json = await response.json() as { ok: boolean; description?: string };
-          if (!json.ok) throw new Error(json.description ?? "sendPhoto failed");
-          return;
+          try {
+            const response = await fetch(`https://api.telegram.org/bot${token}/sendPhoto`, {
+              method: "POST",
+              body: form,
+              signal,
+            });
+            const json = await response.json() as { ok: boolean; description?: string };
+            if (!json.ok) throw new Error(json.description ?? "sendPhoto failed");
+            return;
+          } catch (fetchError) {
+            if ((fetchError as any)?.name === "AbortError") throw fetchError;
+            throw new Error(`Telegram sendPhoto failed: ${fetchError instanceof Error ? fetchError.message : String(fetchError)}`);
+          }
         } catch (error) {
           lastError = error;
           if (attempt >= maxRetries || signal?.aborted) throw error;

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "pi-telegram-plus",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Full Telegram control of pi coding agent — commands, menus, interactive UI, model management, and more",
   "keywords": [
     "pi-package",