2nd change Dockerfile

.drone.yml

@@ -5,31 +5,103 @@ name: default
 trigger:
   branch:
     - master
+    - dev
   event:
     - push
     - pull_request
 
+# --- НАЧАЛО БЛОКА ЛОКАЛЬНОГО КЭШИРОВАНИЯ ---
+volumes:
+  - name: go-cache # Логическое имя кэша для Go
+    host:
+      # Путь на сервере, где запущен Drone Agent.
+      # Убедитесь, что эта директория существует и у Drone есть права на запись.
+      path: /var/cache/drone/gocache
+  - name: lint-cache # Отдельный кэш для линтера
+    host:
+      path: /var/cache/drone/lintcache
+# --- КОНЕЦ БЛОКА ЛОКАЛЬНОГО КЭШИРОВАНИЯ ---
+
 steps:
-  - name: lint
+  # Общие шаги для всех веток
-    image: golangci/golangci-lint:v1.59-alpine
+  - name: deps
+    image: golang:1.24-alpine
+    volumes:
+      # Монтируем наш go-cache в стандартный GOPATH контейнера
+      - name: go-cache
+        path: /go
     commands:
-      - golangci-lint run ./...
+      # Теперь go mod download будет сразу использовать и сохранять кэш на хост-машине
+      - go mod download
+      - go mod tidy
+
+  - name: lint
+    image: golangci/golangci-lint:v1.64-alpine
+    volumes:
+      # Монтируем кэш линтера
+      - name: lint-cache
+        path: /root/.cache
+    commands:
+      # Линтер автоматически подхватит кэш из /root/.cache
+      - golangci-lint run --timeout=5m --verbose ./...
 
   - name: test
     image: golang:1.24-alpine
+    volumes:
+      # Также монтируем go-cache, чтобы тесты использовали скачанные модули и кэш сборки
+      - name: go-cache
+        path: /go
     commands:
-      - go test -race -cover ./...
+      - apk add --no-cache build-base
-# Шаг сборки и публикации будет добавлен позже
+      # CGO_ENABLED=1 go test теперь будет значительно быстрее при повторных запусках
-#  - name: build-and-publish
+      - CGO_ENABLED=1 go test -race -cover ./...
-#    image: plugins/docker
+
-#    settings:
+  # Шаги сборки и публикации остаются почти без изменений.
-#      repo: gitea.mrixs.me/mrixs/yamusic-bot
+  # Кэширование Docker-слоев (`cache_from`) - это отдельный механизм, и его стоит оставить.
-#      registry: gitea.mrixs.me
+  # Он дополняет кэширование зависимостей, ускоряя саму сборку Docker-образа.
-#      username:
+  - name: build-and-publish-master
-#        from_secret: gitea_username
+    image: plugins/docker
-#      password:
+    settings:
-#        from_secret: gitea_password
+      repo: gitea.mrixs.me/mrixs/yamusic-bot
-#      auto_tag: true
+      registry: gitea.mrixs.me
-#      platforms:
+      username:
-#        - linux/amd64
+        from_secret: gitea_username
-#        - linux/arm64
+      password:
+        from_secret: gitea_password
+      auto_tag: true
+      # Оставляем кэширование Docker-слоев, это очень эффективно
+      cache_from:
+        - gitea.mrixs.me/mrixs/yamusic-bot:latest
+      platforms:
+        - linux/amd64
+        - linux/arm64
+        - linux/arm/v7
+    when:
+      branch:
+        - master
+      event:
+        - push
+
+  - name: build-and-publish-dev
+    image: plugins/docker
+    settings:
+      repo: gitea.mrixs.me/mrixs/yamusic-bot
+      registry: gitea.mrixs.me
+      username:
+        from_secret: gitea_username
+      password:
+        from_secret: gitea_password
+      tags:
+        - dev
+        - dev-${DRONE_COMMIT_SHA:0:7}
+      cache_from:
+        - gitea.mrixs.me/mrixs/yamusic-bot:dev
+      platforms:
+        - linux/amd64
+        - linux/arm64
+        - linux/arm/v7
+    when:
+      branch:
+        - dev
+      event:
+        - push

.gitignore

@@ -1,5 +1,7 @@
 # Binary
 bot
+!cmd/bot
+!internal/bot
 yamusic-bot
 
 # Data

Dockerfile

@@ -4,7 +4,7 @@ FROM golang:1.24-alpine AS builder
 
 # Устанавливаем рабочую директорию
 WORKDIR /app
-
+RUN apk add --no-cache build-base
 # Копируем файлы зависимостей и загружаем их
 # Это позволяет кэшировать слой с зависимостями, если они не менялись
 COPY go.mod go.sum ./
@@ -18,7 +18,7 @@ COPY . .
 # CGO_ENABLED=0 необходимо для статической линковки и использования from scratch.
 # TARGETARCH будет автоматически подставлен Docker Buildx (amd64 или arm64).
 ARG TARGETARCH
-RUN CGO_ENABLED=0 GOOS=linux GOARCH=${TARGETARCH} go build -ldflags="-w -s" -o /app/bot ./cmd/bot
+RUN CGO_ENABLED=1 GOOS=linux GOARCH=${TARGETARCH} go build -ldflags="-w -s" -o /app/bot ./cmd/bot
 
 # ---- Final Stage ----
 # На этом этапе мы создаем финальный образ

LICENSE

@@ -0,0 +1,7 @@
+Copyright 2025 Vladimir Zagainov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -1,17 +1,109 @@
 # Yandex.Music Downloader Bot
 
-[![Build Status](https://drone.mrixs.me/api/badges/Mrixs/yamusic-bot/status.svg)](https://drone.mrixs.me/Mrixs/yamusic-bot)
+[![Build Status](https://drone.mrixs.me/api/badges/Mrixs/yamusic-bot/status.svg?branch=master)](https://drone.mrixs.me/Mrixs/yamusic-bot?branch=master) [![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 
-Удобный и быстрый Telegram-бот для получения аудиофайлов треков из сервиса Yandex.Music по ссылке.
+Удобный и быстрый Telegram-бот для получения аудиофайлов из сервиса Yandex.Music. Работает в inline-режиме, позволяя отправлять музыку в любой чат. Поддерживает поиск, а также ссылки на треки, альбомы и исполнителей.
 
-## Конфигурация
+## 🚀 Основные возможности
 
-_(Будет заполнено позже)_
+*   **Inline-режим:** Используйте бота в любом чате, просто упомянув его `@username`.
+*   **Поддержка ссылок:** Распознает и обрабатывает ссылки на треки, альбомы и страницы исполнителей.
+*   **Поиск:** Если введенный текст не является ссылкой, бот выполнит поиск треков по этому тексту.
+*   **Метаданные:** Автоматически встраивает в аудиофайлы ID3-теги (название, исполнитель, альбом, год) и обложку.
+*   **Кэширование:** Мгновенная отправка уже обработанных треков благодаря системе кэширования на базе SQLite и приватного Telegram-канала.
+*   **Администрирование:** Предоставляет набор команд для администраторов для мониторинга и управления ботом.
 
-## Запуск
+## ⚙️ Конфигурация
 
-_(Будет заполнено позже)_
+Бот настраивается с помощью переменных окружения.
 
-## Использование
+| Переменная                | Описание                                               | Пример                        | Обязательно |
+| ------------------------- | ------------------------------------------------------ | ----------------------------- | ----------- |
+| `TELEGRAM_BOT_TOKEN`      | Токен, полученный от @BotFather.                       | `12345:ABC-DEF`               | **Да**      |
+| `TELEGRAM_ADMIN_IDS`      | Список Telegram ID администраторов через запятую.    | `1234567,9876543`             | **Да**      |
+| `TELEGRAM_CACHE_CHAT_ID`  | ID приватного канала/чата для хранения файлов.         | `-100123456789`               | **Да**      |
+| `YANDEX_MUSIC_TOKEN`      | OAuth-токен для доступа к Yandex.Music API.            | `y0_...`                      | **Да**      |
+| `DATABASE_PATH`           | Путь к файлу базы данных SQLite.                       | `/data/bot.db`                | Нет (`/data/bot.db`) |
+| `LOG_LEVEL`               | Уровень логирования (`debug`, `info`, `warn`, `error`). | `info`                        | Нет (`info`)  |
+| `PROCESSOR_WORKERS`       | Количество воркеров для обработки треков.              | `4`                           | Нет (`4`)     |
+| `YANDEX_API_RATE_LIMIT`   | Запросов в секунду к Yandex API.                       | `5`                           | Нет (`5`)     |
 
-_(Будет заполнено позже)_
+## ▶️ Запуск
+
+### С помощью Docker 🐳
+
+Рекомендуемый способ запуска. Убедитесь, что у вас установлен Docker.
+
+1.  Создайте директорию для хранения базы данных: `mkdir -p ./data`
+2.  Запустите контейнер:
+
+    ```bash
+    docker run -d --name yamusic-bot \
+      -v $(pwd)/data:/data \
+      -e TELEGRAM_BOT_TOKEN="ВАШ_ТОКЕН" \
+      -e TELEGRAM_ADMIN_IDS="ВАШ_ID,ID_ДРУГА" \
+      -e TELEGRAM_CACHE_CHAT_ID="-100..." \
+      -e YANDEX_MUSIC_TOKEN="y0_..." \
+      --restart always \
+      gitea.mrixs.me/mrixs/yamusic-bot:dev
+    ```
+    *Примечание: Используйте тег `:latest` для стабильной версии из ветки `master` или `:dev` для последней сборки из ветки `dev`.*
+
+### С помощью Docker Compose
+
+1.  Создайте файл `docker-compose.yml`:
+    ```yaml
+    version: '3.8'
+    services:
+      bot:
+        image: gitea.mrixs.me/mrixs/yamusic-bot:dev
+        container_name: yamusic-bot
+        restart: always
+        volumes:
+          - ./data:/data
+        environment:
+          - TELEGRAM_BOT_TOKEN=
+          - TELEGRAM_ADMIN_IDS=
+          - TELEGRAM_CACHE_CHAT_ID=
+          - YANDEX_MUSIC_TOKEN=
+          - LOG_LEVEL=info
+    ```
+2.  Заполните переменные окружения в файле или создайте рядом `.env` файл.
+3.  Запустите: `docker-compose up -d`
+
+## 🕹️ Использование
+
+### Для пользователей
+Начните вводить в любом чате `@bot_username`, а затем вставьте ссылку или напишите поисковый запрос.
+
+-   **Ссылка на трек:** `@bot_username https://music.yandex.ru/album/123/track/456`
+-   **Ссылка на альбом:** `@bot_username https://music.yandex.ru/album/123`
+-   **Поиск:** `@bot_username Rammstein - Sonne`
+
+### Для администраторов
+Отправьте команду в личные сообщения боту.
+
+-   `/help` — Показать список команд.
+-   `/stats` — Показать статистику работы бота.
+-   `/find <yandex_track_id>` — Найти трек в кэше по ID.
+-   `/warm <URL>` — "Прогреть" кэш для альбома или исполнителя.
+
+## 🗺️ План разработки (Dev Roadmap)
+
+| Статус | Задача                                                               | Комментарий                                                              |
+| :----: | -------------------------------------------------------------------- | ------------------------------------------------------------------------ |
+|   ✅   | Базовый CI/CD пайплайн (lint, test)                                  | Настроен в `.drone.yml`.                                                 |
+|   ✅   | Основная логика обработки URL (трек, альбом, артист)                 | Реализовано в `internal/bot/handler.go`.                                 |
+|   ✅   | Система кэширования (SQLite + Telegram)                              | Реализовано в `internal/storage` и `internal/processor`.                 |
+|   ✅   | Базовая структура проекта и конфигурация                             | Вся структура соответствует ТЗ.                                          |
+|   ✅   | Административные команды `/help`, `/stats`, `/find`                  | Основной функционал реализован в `internal/admin/handler.go`.            |
+|   ✅   | Публикация Docker-образов в CI/CD                                    | Шаги `build-and-publish-*` активны в `.drone.yml` для `master` и `dev`.    |
+|   ⏳   | Расширение тестового покрытия                                        | Есть тесты для `storage`, но нужны для `processor`, `bot`, `admin`.       |
+|   ⏳   | Финализация документации                                             | Этот `README.md` является частью задачи.                                 |
+|   ❌   | Реализация логики команды `/warm`                                    | Существует только заглушка, фоновая обработка не реализована.             |
+|   ❌   | Ограничение частоты запросов (Rate Limiting) к Yandex API            | Требуется внедрение `rate.Limiter`.                                      |
+|   ❌   | Поддержка текстового поиска и коротких URL                           | Задача из нового ТЗ, требуется реализация в `handler` и `yamusic client`. |
+
+## 📄 Лицензия
+
+Проект распространяется под лицензией MIT. См. файл `LICENSE` для получения дополнительной информации.

cmd/bot/main.go

@@ -0,0 +1,69 @@
+package main
+
+import (
+	"context"
+	"log/slog"
+	"time"
+
+	"gitea.mrixs.me/Mrixs/yamusic-bot/internal/admin"
+	"gitea.mrixs.me/Mrixs/yamusic-bot/internal/bot"
+	"gitea.mrixs.me/Mrixs/yamusic-bot/internal/config"
+	"gitea.mrixs.me/Mrixs/yamusic-bot/internal/processor"
+	"gitea.mrixs.me/Mrixs/yamusic-bot/internal/storage"
+	"gitea.mrixs.me/Mrixs/yamusic-bot/pkg/downloader"
+	"gitea.mrixs.me/Mrixs/yamusic-bot/pkg/logging"
+	"gitea.mrixs.me/Mrixs/yamusic-bot/pkg/tagger"
+	"gitea.mrixs.me/Mrixs/yamusic-bot/pkg/yamusic"
+	tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
+)
+
+func main() {
+	startTime := time.Now()
+	ctx := context.Background()
+
+	// 1. Инициализация конфигурации
+	cfg := config.New()
+
+	// 2. Инициализация логгера
+	logger := logging.NewLogger(cfg.LogLevel)
+	slog.SetDefault(logger)
+
+	slog.Info("Starting Yandex.Music Downloader Bot...", "version", "1.0")
+
+	// 3. Инициализация зависимостей
+	db, err := storage.NewSQLiteStorage(ctx, cfg.DatabasePath)
+	if err != nil {
+		slog.Error("Failed to initialize storage", "error", err)
+		return
+	}
+
+	yandexClient, err := yamusic.NewApiClient(cfg.YandexMusicToken)
+	if err != nil {
+		slog.Error("Failed to initialize yandex client", "error", err)
+		return
+	}
+
+	tgAPI, err := tgbotapi.NewBotAPI(cfg.TelegramBotToken)
+	if err != nil {
+		slog.Error("Failed to initialize telegram bot api", "error", err)
+		return
+	}
+	tgAPI.Debug = cfg.LogLevel == "debug"
+	slog.Info("Authorized on account", "username", tgAPI.Self.UserName)
+
+	// 4. Инициализация компонентов
+	downloaderComponent := downloader.NewHTTPDownloader()
+	taggerComponent := tagger.NewID3Tagger()
+	telegramClient := bot.NewTelegramClientAdapter(tgAPI, cfg.TelegramCacheChatID)
+
+	trackProcessor := processor.NewTrackProcessor(db, yandexClient, downloaderComponent, taggerComponent, telegramClient)
+
+	adminHandler := admin.NewHandler(db, telegramClient, yandexClient, startTime)
+	inlineHandler := bot.NewInlineHandler(yandexClient, trackProcessor, telegramClient)
+
+	// 5. Создание и запуск приложения
+	app := bot.NewApp(cfg, tgAPI, db, adminHandler, inlineHandler)
+	app.Run(ctx)
+
+	slog.Info("Bot stopped.")
+}

example.env

@@ -0,0 +1,8 @@
+TELEGRAM_BOT_TOKEN=aaa:bbb
+TELEGRAM_ADMIN_IDS=ccc
+TELEGRAM_CACHE_CHAT_ID=ddd
+YANDEX_MUSIC_TOKEN=eee
+DATABASE_PATH="/data/bot.db"
+LOG_LEVEL="info"
+PROCESSOR_WORKERS=4
+YANDEX_API_RATE_LIMIT=5

internal/admin/handler.go

@@ -4,6 +4,9 @@ import (
 	"context"
 	"fmt"
 	"log/slog"
+	"os"
+	"path/filepath"
+	"strings"
 	"time"
 
 	"gitea.mrixs.me/Mrixs/yamusic-bot/internal/interfaces"
@@ -56,7 +59,8 @@ func (h *Handler) handleHelp(ctx context.Context, chatID int64) {
 		"/help - Показать это сообщение\n" +
 		"/stats - Показать статистику бота\n" +
 		"/find <yandex_track_id> - Найти трек в кэше по ID\n" +
-		"/warm <URL> - \"Прогреть\" кэш для альбома или исполнителя (в разработке)"
+		"/warm <URL> - \"Прогреть\" кэш для альбома или исполнителя (в разработке)\n" +
+		"/warm --from-dir <path> - Прогреть кэш из локальной директории внутри контейнера"
 
 	if err := h.telegram.SendMessage(ctx, chatID, helpText); err != nil {
 		slog.Error("Failed to send help message", "error", err, "chat_id", chatID)
@@ -110,8 +114,93 @@ func (h *Handler) handleFind(ctx context.Context, chatID int64, trackID string)
 	}
 }
 
-func (h *Handler) handleWarm(ctx context.Context, chatID int64, url string) {
+func (h *Handler) handleWarm(ctx context.Context, chatID int64, args string) {
-	if err := h.telegram.SendMessage(ctx, chatID, "Команда /warm находится в разработке."); err != nil {
+	const fromDirPrefix = "--from-dir "
+	if strings.HasPrefix(args, fromDirPrefix) {
+		dirPath := strings.TrimPrefix(args, fromDirPrefix)
+		h.handleWarmFromDir(ctx, chatID, dirPath)
+		return
+	}
+
+	// Здесь будет логика для прогрева по URL
+	if err := h.telegram.SendMessage(ctx, chatID, "Прогрев по URL находится в разработке."); err != nil {
 		slog.Error("Failed to send 'warm in development' message", "error", err, "chat_id", chatID)
 	}
 }
+
+// handleWarmFromDir запускает фоновую задачу прогрева кэша из локальной директории.
+func (h *Handler) handleWarmFromDir(ctx context.Context, chatID int64, dirPath string) {
+	msg := fmt.Sprintf("Принято в обработку. Начинаю прогрев кэша из директории: `%s`", dirPath)
+	if err := h.telegram.SendMessage(ctx, chatID, msg); err != nil {
+		slog.Error("Failed to send 'warm from dir started' message", "error", err, "chat_id", chatID)
+		return
+	}
+
+	go func() {
+		slog.Info("Starting cache warming from directory", "path", dirPath)
+		files, err := os.ReadDir(dirPath)
+		if err != nil {
+			slog.Error("Failed to read directory for warming", "path", dirPath, "error", err)
+			errMsg := fmt.Sprintf("Ошибка: не удалось прочитать директорию `%s`. Убедитесь, что она существует и доступна.", dirPath)
+			_ = h.telegram.SendMessage(context.Background(), chatID, errMsg)
+			return
+		}
+
+		var addedCount, skippedCount, errorCount int
+		totalFiles := len(files)
+
+		for i, file := range files {
+			if file.IsDir() || !strings.HasSuffix(file.Name(), ".mp3") {
+				continue
+			}
+
+			trackID := strings.TrimSuffix(file.Name(), ".mp3")
+			fullPath := filepath.Join(dirPath, file.Name())
+
+			// 1. Проверяем, есть ли трек в кэше
+			_, err := h.storage.Get(ctx, trackID)
+			if err == nil {
+				slog.Debug("Skipping already cached track", "track_id", trackID)
+				skippedCount++
+				continue
+			}
+
+			// 2. Загружаем в Telegram
+			// Поскольку метатеги уже вшиты, для отображения в кэш-канале можно использовать простые title/performer
+			slog.Debug("Uploading track to cache channel", "track_id", trackID, "path", fullPath)
+			fileID, err := h.telegram.SendAudioToCacheChannel(ctx, fullPath, trackID, "Pre-cached")
+			if err != nil {
+				slog.Error("Failed to upload pre-cached file", "track_id", trackID, "error", err)
+				errorCount++
+				continue
+			}
+
+			// 3. Сохраняем в БД
+			err = h.storage.Set(ctx, trackID, fileID)
+			if err != nil {
+				slog.Error("Failed to save pre-cached file to storage", "track_id", trackID, "error", err)
+				errorCount++
+				continue
+			}
+
+			addedCount++
+			slog.Info("Successfully cached track from local file", "track_id", trackID, "file_id", fileID)
+
+			// Опционально: отправляем прогресс каждые N файлов
+			if (i+1)%1000 == 0 {
+				progressMsg := fmt.Sprintf("Прогресс: обработано %d из %d файлов...", i+1, totalFiles)
+				_ = h.telegram.SendMessage(context.Background(), chatID, progressMsg)
+			}
+		}
+
+		finalMsg := fmt.Sprintf(
+			"✅ Прогрев кэша из директории `%s` завершен.\n\n"+
+				"Новых треков добавлено: %d\n"+
+				"Треков пропущено (уже в кэше): %d\n"+
+				"Ошибок при обработке: %d",
+			dirPath, addedCount, skippedCount, errorCount,
+		)
+		_ = h.telegram.SendMessage(context.Background(), chatID, finalMsg)
+		slog.Info("Finished cache warming from directory", "path", dirPath, "added", addedCount, "skipped", skippedCount, "errors", errorCount)
+	}()
+}

internal/bot/app.go

@@ -0,0 +1,77 @@
+package bot
+
+import (
+	"context"
+	"log/slog"
+	"os"
+	"os/signal"
+	"slices"
+	"syscall"
+
+	"gitea.mrixs.me/Mrixs/yamusic-bot/internal/admin"
+	"gitea.mrixs.me/Mrixs/yamusic-bot/internal/config"
+	"gitea.mrixs.me/Mrixs/yamusic-bot/internal/interfaces"
+	tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
+)
+
+// App - главное приложение бота.
+type App struct {
+	cfg           *config.Config
+	api           *tgbotapi.BotAPI
+	storage       interfaces.TrackStorage
+	adminHandler  *admin.Handler
+	inlineHandler *InlineHandler
+}
+
+// NewApp создает новый экземпляр приложения.
+func NewApp(cfg *config.Config, api *tgbotapi.BotAPI, storage interfaces.TrackStorage, adminHandler *admin.Handler, inlineHandler *InlineHandler) *App {
+	return &App{
+		cfg:           cfg,
+		api:           api,
+		storage:       storage,
+		adminHandler:  adminHandler,
+		inlineHandler: inlineHandler,
+	}
+}
+
+// Run запускает основной цикл бота.
+func (a *App) Run(ctx context.Context) {
+	ctx, cancel := signal.NotifyContext(ctx, os.Interrupt, syscall.SIGTERM)
+	defer cancel()
+
+	u := tgbotapi.NewUpdate(0)
+	u.Timeout = 60
+	updates := a.api.GetUpdatesChan(u)
+
+	slog.Info("Bot is running and waiting for updates...")
+
+	for {
+		select {
+		case update := <-updates:
+			a.handleUpdate(ctx, update)
+		case <-ctx.Done():
+			slog.Info("Shutting down...")
+			a.api.StopReceivingUpdates()
+			if err := a.storage.Close(); err != nil {
+				slog.Error("Failed to close storage", "error", err)
+			}
+			return
+		}
+	}
+}
+
+func (a *App) handleUpdate(ctx context.Context, update tgbotapi.Update) {
+	if update.InlineQuery != nil {
+		go a.inlineHandler.HandleInlineQuery(ctx, update.InlineQuery)
+	} else if update.Message != nil && update.Message.IsCommand() {
+		if a.isAdmin(update.Message.From.ID) {
+			go a.adminHandler.HandleCommand(ctx, update.Message)
+		} else {
+			slog.Warn("Unauthorized command attempt", "user_id", update.Message.From.ID)
+		}
+	}
+}
+
+func (a *App) isAdmin(userID int64) bool {
+	return slices.Contains(a.cfg.TelegramAdminIDs, userID)
+}

internal/bot/handler.go

@@ -0,0 +1,121 @@
+package bot
+
+import (
+	"context"
+	"log/slog"
+	"strconv"
+	"sync"
+
+	"gitea.mrixs.me/Mrixs/yamusic-bot/internal/interfaces"
+	"gitea.mrixs.me/Mrixs/yamusic-bot/internal/model"
+	"gitea.mrixs.me/Mrixs/yamusic-bot/internal/processor"
+	"gitea.mrixs.me/Mrixs/yamusic-bot/pkg/yamusic"
+	tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
+)
+
+// InlineHandler обрабатывает inline-запросы.
+type InlineHandler struct {
+	yandex    interfaces.YandexMusicClient
+	processor *processor.TrackProcessor
+	telegram  interfaces.TelegramClient
+}
+
+// NewInlineHandler создает новый обработчик inline-запросов.
+func NewInlineHandler(yandex interfaces.YandexMusicClient, processor *processor.TrackProcessor, telegram interfaces.TelegramClient) *InlineHandler {
+	return &InlineHandler{
+		yandex:    yandex,
+		processor: processor,
+		telegram:  telegram,
+	}
+}
+
+// HandleInlineQuery обрабатывает входящий inline-запрос.
+func (h *InlineHandler) HandleInlineQuery(ctx context.Context, query *tgbotapi.InlineQuery) {
+	slog.Info("Handling inline query", "user_id", query.From.ID, "query", query.Query)
+
+	urlInfo, err := yamusic.ParseYandexURL(query.Query)
+	if err != nil {
+		h.answerWithError(ctx, query.ID, "Неверный формат ссылки. Поддерживаются ссылки на треки, альбомы и исполнителей Yandex.Music.")
+		return
+	}
+
+	var trackInfos []*model.TrackInfo
+	switch urlInfo.Type {
+	case "track":
+		info, err := h.yandex.GetTrackInfo(ctx, urlInfo.TrackID)
+		if err != nil {
+			slog.Error("Failed to get track info", "track_id", urlInfo.TrackID, "error", err)
+			h.answerWithError(ctx, query.ID, "Не удалось получить информацию о треке.")
+			return
+		}
+		trackInfos = append(trackInfos, info)
+	case "album":
+		infos, err := h.yandex.GetAlbumTrackInfos(ctx, urlInfo.AlbumID)
+		if err != nil {
+			slog.Error("Failed to get album info", "album_id", urlInfo.AlbumID, "error", err)
+			h.answerWithError(ctx, query.ID, "Не удалось получить информацию об альбоме.")
+			return
+		}
+		trackInfos = infos
+	case "artist":
+		infos, err := h.yandex.GetArtistTrackInfos(ctx, urlInfo.ArtistID)
+		if err != nil {
+			slog.Error("Failed to get artist info", "artist_id", urlInfo.ArtistID, "error", err)
+			h.answerWithError(ctx, query.ID, "Не удалось получить информацию об исполнителе.")
+			return
+		}
+		trackInfos = infos
+	}
+
+	if len(trackInfos) == 0 {
+		h.answerWithError(ctx, query.ID, "По этой ссылке ничего не найдено.")
+		return
+	}
+
+	h.processAndAnswer(ctx, query.ID, trackInfos)
+}
+
+func (h *InlineHandler) processAndAnswer(ctx context.Context, queryID string, trackInfos []*model.TrackInfo) {
+	var wg sync.WaitGroup
+	resultsChan := make(chan interface{}, len(trackInfos))
+
+	for i, info := range trackInfos {
+		wg.Add(1)
+		go func(trackInfo *model.TrackInfo, resultID int) {
+			defer wg.Done()
+			fileID, err := h.processor.Process(ctx, trackInfo)
+			if err != nil {
+				slog.Error("Failed to process track", "track_id", trackInfo.YandexTrackID, "error", err)
+				return
+			}
+			result := tgbotapi.NewInlineQueryResultAudio(strconv.Itoa(resultID), fileID, trackInfo.Title)
+			result.Performer = trackInfo.Artist
+			resultsChan <- result
+		}(info, i)
+	}
+
+	wg.Wait()
+	close(resultsChan)
+
+	var finalResults []interface{}
+	for result := range resultsChan {
+		finalResults = append(finalResults, result)
+	}
+
+	if len(finalResults) == 0 {
+		slog.Warn("No results to send after processing", "query_id", queryID)
+		h.answerWithError(ctx, queryID, "Не удалось обработать ни один трек.")
+		return
+	}
+
+	if err := h.telegram.AnswerInlineQuery(ctx, queryID, finalResults); err != nil {
+		slog.Error("Failed to send final answer to inline query", "error", err)
+	}
+}
+
+func (h *InlineHandler) answerWithError(ctx context.Context, queryID, message string) {
+	article := tgbotapi.NewInlineQueryResultArticle(queryID, "Ошибка", message)
+	if err := h.telegram.AnswerInlineQuery(ctx, queryID, []interface{}{article}); err != nil {
+		slog.Error("Failed to answer with error", "error", err)
+	}
+}

internal/bot/telegram.go

@@ -0,0 +1,64 @@
+package bot
+
+import (
+	"context"
+	"fmt"
+	"log/slog"
+
+	tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
+)
+
+// TelegramClientAdapter адаптирует библиотеку tgbotapi под наш интерфейс interfaces.TelegramClient.
+type TelegramClientAdapter struct {
+	api         *tgbotapi.BotAPI
+	cacheChatID int64
+}
+
+// NewTelegramClientAdapter создает новый адаптер.
+func NewTelegramClientAdapter(api *tgbotapi.BotAPI, cacheChatID int64) *TelegramClientAdapter {
+	return &TelegramClientAdapter{
+		api:         api,
+		cacheChatID: cacheChatID,
+	}
+}
+
+// SendAudioToCacheChannel загружает аудиофайл в кэш-канал и возвращает его FileID.
+func (t *TelegramClientAdapter) SendAudioToCacheChannel(ctx context.Context, audioPath, title, performer string) (string, error) {
+	audio := tgbotapi.NewAudio(t.cacheChatID, tgbotapi.FilePath(audioPath))
+	audio.Title = title
+	audio.Performer = performer
+
+	msg, err := t.api.Send(audio)
+	if err != nil {
+		return "", fmt.Errorf("failed to send audio to cache channel: %w", err)
+	}
+	if msg.Audio == nil {
+		return "", fmt.Errorf("sent message does not contain audio")
+	}
+
+	slog.Debug("Audio sent to cache channel", "file_id", msg.Audio.FileID)
+	return msg.Audio.FileID, nil
+}
+
+// AnswerInlineQuery отвечает на inline-запрос.
+func (t *TelegramClientAdapter) AnswerInlineQuery(ctx context.Context, queryID string, results []interface{}) error {
+	inlineConfig := tgbotapi.InlineConfig{
+		InlineQueryID: queryID,
+		Results:       results,
+		CacheTime:     1, // Кэшируем результат на стороне Telegram на 1 секунду
+	}
+
+	if _, err := t.api.Request(inlineConfig); err != nil {
+		return fmt.Errorf("failed to answer inline query: %w", err)
+	}
+	return nil
+}
+
+// SendMessage отправляет текстовое сообщение.
+func (t *TelegramClientAdapter) SendMessage(ctx context.Context, chatID int64, text string) error {
+	msg := tgbotapi.NewMessage(chatID, text)
+	if _, err := t.api.Send(msg); err != nil {
+		return fmt.Errorf("failed to send message: %w", err)
+	}
+	return nil
+}