Telegram Bots with Bun.js

Install Bun and initialize a new TypeScript project.

Explain key differences between Bun and Node.js runtimes relevant to bot development.

Use Bun's built-in package manager to add and manage dependencies.

Run and debug TypeScript files directly using Bun's runtime and inspector.

Manage environment variables for API keys and configuration using Bun's built-in support for .env files.

Use Bun's optimized `fetch` API to make external HTTP requests.

Create a new bot via BotFather and obtain an API token.

Describe the Telegram Bot API architecture: updates, methods, and types.

Differentiate between long polling and webhook update mechanisms.

Send a message by making a raw HTTP POST request to the `sendMessage` method.

Receive updates by implementing a basic long polling loop using `getUpdates`.

Explain the role of the grammY framework and its advantages for TypeScript development.

Initialize and configure a grammY bot project using Bun.

Launch a bot using long polling and verify it responds to messages.

Implement basic error handling using grammY's error boundary to catch and log runtime errors.

Implement graceful shutdown for a long-polling bot to handle process termination signals.

Register and handle built-in and custom bot commands (e.g., /start, /help).

Use grammY's Context object to inspect message properties and send replies.

Parse command arguments and parameters from user input.

Filter and respond to different message types (e.g., text, photos, documents).

Send formatted replies using Markdown and HTML parse modes.

Create reply keyboards with custom button layouts.

Create inline keyboards with callback data buttons.

Handle callback query events and send acknowledgements using `answerCallbackQuery`.

Edit or delete existing messages dynamically in response to user interactions.

Structure callback data to represent a hierarchical menu system.

Implement a handler that edits a message to display a sub-menu based on a user's selection.

Implement a 'back' button functionality to navigate to a parent menu.

Explain grammY's middleware execution model and the `next()` function.

Write a custom middleware function for logging all incoming updates.

Implement an authentication middleware to restrict bot access to specific users.

Use grammY's Composer class to organize handlers into reusable modules.

Configure grammY's session plugin to persist user-specific state across updates.

Implement a form-like data collection flow using the grammY conversations plugin.

Validate and sanitize user input at each step of a conversation.

Handle conversation branching, timeouts, and cancellation.

Integrate an external API call within a grammY command handler using Bun's `fetch`.

Parse and transform JSON API responses into formatted bot messages.

Implement robust error handling for API failures with graceful user feedback.

Set up the Anthropic SDK and configure API credentials in a Bun project.

Send user prompts to the Claude API and return responses as bot messages.

Use the grammY session plugin to maintain conversation history for multi-turn interactions with Claude.

Implement streaming responses from the Claude API for real-time progressive replies.

Handle Claude API rate limits, token limits, and error responses gracefully.

Set up a webhook endpoint using Bun's built-in HTTP server.

Register and configure the webhook URL with the Telegram Bot API.

Secure the webhook endpoint using a secret token.

Deploy a Telegram bot to a cloud platform such as Railway or Fly.io.

Implement structured logging for the deployed bot to capture application events and errors.

Set up basic health checks for the deployed bot service.