diff --git a/.cursor/rules/snyk_rules.mdc b/.cursor/rules/snyk_rules.mdc new file mode 100644 index 0000000..eef0634 --- /dev/null +++ b/.cursor/rules/snyk_rules.mdc @@ -0,0 +1,14 @@ +--- +alwaysApply: true +always_on: true +trigger: always_on +applyTo: "**" +description: Snyk Security At Inception +--- + +# Project security best practices + +- Always run snyk_code_scan tool for new first party code that is generated in a Snyk-supported language. +- If any security issues are found based on newly introduced or modified code or dependencies, attempt to fix the issues using the results context from Snyk. +- Rescan the code after fixing the issues to ensure that the issues were fixed and that there are no newly introduced issues. +- Repeat this process until no new issues are found. diff --git a/.dockerignore b/.dockerignore new file mode 100644 index 0000000..7deffff --- /dev/null +++ b/.dockerignore @@ -0,0 +1,77 @@ +# Git files +.git +.gitignore +.gitattributes + +# Documentation +README.md +*.md + +# Docker files +Dockerfile +docker-compose.yml +.dockerignore + +# Environment files +.env +.env.* + +# Log files +*.log +logs/ + +# Database files +*.db +*.sqlite +*.sqlite3 +bot.db + +# Config files (except default template) +config/* +!config/default.json + +# Test files +*_test.go +test/ +tests/ + +# Build artifacts +telegram-bot +*.exe +*.dll +*.so +*.dylib + +# IDE files +.vscode/ +.idea/ +*.swp +*.swo +*~ + +# OS files +.DS_Store +Thumbs.db + +# Go specific +vendor/ +*.mod.backup +*.sum.backup + +# Temporary files +tmp/ +temp/ +*.tmp + +# Coverage files +*.out +coverage.html + +# CI/CD files +.github/ +.gitlab-ci.yml +.travis.yml + +# Examples and documentation +examples/ +docs/ \ No newline at end of file diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..aafbd82 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,13 @@ +# Enforce LF line endings for all files +* text eol=lf + +# Specific file types that should always have LF line endings +*.go text eol=lf +*.json text eol=lf +*.sh text eol=lf +*.md text eol=lf + +# Example: Binary files should not be modified +*.jpg binary +*.png binary +*.gif binary diff --git a/.github/workflows/go-ci.yaml b/.github/workflows/go-ci.yaml new file mode 100644 index 0000000..4f20788 --- /dev/null +++ b/.github/workflows/go-ci.yaml @@ -0,0 +1,58 @@ +name: CI + +on: + push: + branches: [ main ] + pull_request: + branches: [ main ] + +jobs: + # Common setup job that other jobs can depend on + setup: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-go@v5 + with: + go-version: '1.26.0' + - uses: actions/cache@v4 + with: + path: | + ~/.cache/go-build + ~/go/pkg/mod + key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }} + restore-keys: | + ${{ runner.os }}-go- + - run: go mod tidy + + # Lint job + lint: + needs: setup + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v6 + - uses: golangci/golangci-lint-action@v9 + with: + version: v2.10 + args: --timeout 5m + + # Test job + test: + needs: setup + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v6 + - uses: actions/setup-go@v6 + with: + go-version: '1.26.0' + - run: go test ./... -v + + # Security scan job + security: + needs: setup + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v6 + - uses: securego/gosec@master + with: + args: ./... diff --git a/.gitignore b/.gitignore index 5f2863b..b3a98df 100644 --- a/.gitignore +++ b/.gitignore @@ -1,11 +1,18 @@ +# Local IDE config & user settings +.vscode/ + # Go vendor directory vendor/ # Environment variables .env -# Log file -bot.log +# Any log files +*.log # Database file -bot.db \ No newline at end of file +bot.db + +# All config files except for the default +config/* +!config/default.json \ No newline at end of file diff --git a/.roo/mcp.json b/.roo/mcp.json new file mode 100644 index 0000000..7001130 --- /dev/null +++ b/.roo/mcp.json @@ -0,0 +1,3 @@ +{ + "mcpServers": {} +} \ No newline at end of file diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..a943c43 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,55 @@ +# Multi-stage build for Go Telegram Bot +# Build stage +FROM golang:1.26-alpine AS builder + +# Install build dependencies including C compiler for CGO +RUN apk add --no-cache git ca-certificates tzdata gcc musl-dev + +# Set working directory +WORKDIR /build + +# Copy go mod files first for better caching +COPY go.mod go.sum ./ + +# Download dependencies +RUN go mod download + +# Copy source code +COPY . . + +# Build the application +RUN CGO_ENABLED=1 GOOS=linux go build -a -installsuffix cgo -o telegram-bot . + +# Runtime stage +FROM alpine:latest + +# Merged into a single RUN to minimise image layers (docker:S7031). +# Order matters: packages must be installed before adduser/addgroup, +# and the app directory must exist before chown runs. +RUN apk --no-cache add ca-certificates tzdata sqlite && \ + addgroup -g 1001 -S appgroup && \ + adduser -u 1001 -S appuser -G appgroup && \ + mkdir -p /app/config /app/data /app/logs && \ + chown -R appuser:appgroup /app + +# Set working directory +WORKDIR /app + +# Copy binary from builder stage +COPY --from=builder /build/telegram-bot /app/telegram-bot + +# Copy default config as template +COPY --chown=appuser:appgroup config/default.json /app/config/ + +# Switch to non-root user +USER appuser + +# Expose any ports if needed (not required for this bot) +# EXPOSE 8080 + +# Health check +HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \ + CMD pgrep telegram-bot || exit 1 + +# Run the application +CMD ["/app/telegram-bot"] \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..1d50c2a --- /dev/null +++ b/README.md @@ -0,0 +1,149 @@ +# Go Telegram Multibot + +A scalable, multi-bot solution for Telegram using Go, GORM, and the Anthropic API. + +## Design Considerations + +- AI-powered (Anthropic Claude) +- Voice message support (ElevenLabs STT + TTS) ā€” optional, enabled per bot via config +- Supports multiple bot profiles +- Uses SQLite for persistence +- Implements rate limiting and user management +- Modular architecture +- Comprehensive unit tests + +## Usage + +### Docker Deployment (Recommended) + +1. Clone the repository: + + ```bash + git clone https://github.com/HugeFrog24/go-telegram-bot.git + cd go-telegram-bot + ``` + +2. Copy the default config template and edit it: + ```bash + cp config/default.json config/mybot.json + nano config/mybot.json + ``` + +> [!IMPORTANT] +> Keep your config files secret and do not commit them to version control. + +3. Create data directory and run: + ```bash + mkdir -p data + docker-compose up -d + ``` + +### Native Deployment + +1. Install using `go get`: + + ```bash + go get -u github.com/HugeFrog24/go-telegram-bot + cd go-telegram-bot + ``` + +2. Configure as above, then build: + ```bash + go build -o telegram-bot + ``` + +## Systemd Unit Setup + +To enable the bot to start automatically on system boot and run in the background, set up a systemd unit. + +1. Copy the systemd unit template and edit it: + + ```bash + sudo cp examples/systemd/telegram-bot.service /etc/systemd/system/telegram-bot.service + ``` + + Edit the service file: + + ```bash + sudo nano /etc/systemd/system/telegram-bot.service + ``` + + Adjust the following parameters: + + - WorkingDirectory + - ExecStart + - User + +2. Enable and start the service: + + ```bash + sudo systemctl daemon-reload + ``` + + ```bash + sudo systemctl enable telegram-bot + ``` + + ```bash + sudo systemctl start telegram-bot + ``` + +3. Check the status: + + ```bash + sudo systemctl status telegram-bot + ``` + +For more details on the systemd setup, refer to the [demo service file](examples/systemd/telegram-bot.service). + +## Logs + +### Docker + +```bash +docker-compose logs -f telegram-bot +``` + +### Systemd + +```bash +journalctl -u telegram-bot -f +``` + +## Commands + +| Command | Access | Description | +| --------------------------------- | ----------- | ------------------------------------------------------------ | +| `/stats` | All users | Show global bot statistics (total users and messages) | +| `/stats user` | All users | Show your own message statistics | +| `/stats user ` | Admin/Owner | Show statistics for a specific user | +| `/whoami` | All users | Show your Telegram ID, username, and role | +| `/clear` | All users | Soft-delete your own chat history | +| `/clear ` | Admin/Owner | Soft-delete all messages for a user across every chat | +| `/clear ` | Admin/Owner | Soft-delete a user's messages in a specific chat | +| `/clear_hard` | All users | Permanently delete your own chat history | +| `/clear_hard ` | Admin/Owner | Permanently delete all messages for a user across every chat | +| `/clear_hard ` | Admin/Owner | Permanently delete a user's messages in a specific chat | +| `/set_model ` | Admin/Owner | Switch the AI model live without restarting | + +> **Note:** In private DMs each user's `chat_id` equals their `user_id`. The scoped `` form is mainly useful for group chat moderation. + +## Testing + +The GitHub actions workflow already runs tests on every commit: + +> [![CI](https://github.com/HugeFrog24/go-telegram-bot/actions/workflows/go-ci.yaml/badge.svg?branch=main)](https://github.com/HugeFrog24/go-telegram-bot/actions/workflows/go-ci.yaml) + +However, you can run the tests locally using: + +```bash +go test -race -v ./... +``` + +## Storage + +At the moment, a SQLite database (`./data/bot.db`) is used for persistent storage. + +Remember to back it up regularly. + +Future versions will support more robust storage backends. diff --git a/anthropic.go b/anthropic.go new file mode 100644 index 0000000..7710209 --- /dev/null +++ b/anthropic.go @@ -0,0 +1,140 @@ +package main + +import ( + "context" + "errors" + "fmt" + "strings" + "time" + + "github.com/liushuangls/go-anthropic/v2" +) + +// ErrModelNotFound is returned when the configured Anthropic model is no longer available +// (deprecated or removed). Callers can use errors.Is to detect this and surface an +// actionable message to admins/owners while keeping the response vague for regular users. +var ErrModelNotFound = errors.New("model not found or deprecated") + +func (b *Bot) getAnthropicResponse(ctx context.Context, messages []anthropic.Message, isNewChat, isOwner, isEmojiOnly bool, username string, firstName string, lastName string, isPremium bool, languageCode string, messageTime int) (string, error) { + // Use prompts from config + var systemMessage string + if isNewChat { + systemMessage = b.config.SystemPrompts["new_chat"] + } else { + systemMessage = b.config.SystemPrompts["continue_conversation"] + } + + // Combine default prompt with custom instructions + systemMessage = b.config.SystemPrompts["default"] + " " + b.config.SystemPrompts["custom_instructions"] + " " + systemMessage + + // Handle username placeholder + usernameValue := username + if username == "" { + usernameValue = "unknown" // Use "unknown" when username is not available + } + systemMessage = strings.ReplaceAll(systemMessage, "{username}", usernameValue) + + // Handle firstname placeholder + firstnameValue := firstName + if firstName == "" { + firstnameValue = "unknown" // Use "unknown" when first name is not available + } + systemMessage = strings.ReplaceAll(systemMessage, "{firstname}", firstnameValue) + + // Handle lastname placeholder + lastnameValue := lastName + if lastName == "" { + lastnameValue = "" // Empty string when last name is not available + } + systemMessage = strings.ReplaceAll(systemMessage, "{lastname}", lastnameValue) + + // Handle language code placeholder + langValue := languageCode + if languageCode == "" { + langValue = "en" // Default to English when language code is not available + } + systemMessage = strings.ReplaceAll(systemMessage, "{language}", langValue) + + // Handle premium status + premiumStatus := "regular user" + if isPremium { + premiumStatus = "premium user" + } + systemMessage = strings.ReplaceAll(systemMessage, "{premium_status}", premiumStatus) + + // Handle time awareness + timeObj := time.Unix(int64(messageTime), 0) + hour := timeObj.Hour() + var timeContext string + if hour >= 5 && hour < 12 { + timeContext = "morning" + } else if hour >= 12 && hour < 18 { + timeContext = "afternoon" + } else if hour >= 18 && hour < 22 { + timeContext = "evening" + } else { + timeContext = "night" + } + systemMessage = strings.ReplaceAll(systemMessage, "{time_context}", timeContext) + + if !isOwner { + systemMessage += " " + b.config.SystemPrompts["avoid_sensitive"] + } + + if isEmojiOnly { + systemMessage += " " + b.config.SystemPrompts["respond_with_emojis"] + } + + // Debug logging + InfoLogger.Printf("Sending %d messages to Anthropic", len(messages)) + for i, msg := range messages { + for _, content := range msg.Content { + if content.Type == anthropic.MessagesContentTypeText { + InfoLogger.Printf("Message %d: Role=%v, Text=%v", i, msg.Role, *content.Text) + } + } + } + + // Ensure the roles are correct + for i := range messages { + switch messages[i].Role { + case anthropic.RoleUser: + messages[i].Role = anthropic.RoleUser + case anthropic.RoleAssistant: + messages[i].Role = anthropic.RoleAssistant + default: + // Default to 'user' if role is unrecognized + messages[i].Role = anthropic.RoleUser + } + } + + model := anthropic.Model(b.config.Model) + + // Create the request + request := anthropic.MessagesRequest{ + Model: model, // Now `model` is of type anthropic.Model + Messages: messages, + System: systemMessage, + MaxTokens: 1000, + } + + // Apply temperature if set in config + if b.config.Temperature != nil { + request.Temperature = b.config.Temperature + } + + resp, err := b.anthropicClient.CreateMessages(ctx, request) + if err != nil { + var apiErr *anthropic.APIError + if errors.As(err, &apiErr) && apiErr.IsNotFoundErr() { + return "", fmt.Errorf("%w: %s", ErrModelNotFound, b.config.Model) + } + return "", fmt.Errorf("error creating Anthropic message: %w", err) + } + + if len(resp.Content) == 0 || resp.Content[0].Type != anthropic.MessagesContentTypeText { + return "", fmt.Errorf("unexpected response format from Anthropic") + } + + return resp.Content[0].GetText(), nil +} diff --git a/anthropic_test.go b/anthropic_test.go new file mode 100644 index 0000000..cf82305 --- /dev/null +++ b/anthropic_test.go @@ -0,0 +1,197 @@ +package main + +import ( + "fmt" + "strings" + "testing" + "time" +) + +// TestLanguageCodeReplacement tests that language code is properly handled and replaced +func TestLanguageCodeReplacement(t *testing.T) { + // Test with provided language code + systemMessage := "User's language preference: '{language}'" + + // Test with a specific language code + langValue := "fr" + result := strings.ReplaceAll(systemMessage, "{language}", langValue) + + if !strings.Contains(result, "User's language preference: 'fr'") { + t.Errorf("Expected language code 'fr' to be replaced, got: %s", result) + } + + // Test with empty language code (should default to "en") + langValue = "" + if langValue == "" { + langValue = "en" // Default to English when language code is not available + } + result = strings.ReplaceAll(systemMessage, "{language}", langValue) + + if !strings.Contains(result, "User's language preference: 'en'") { + t.Errorf("Expected default language code 'en' to be used, got: %s", result) + } +} + +// TestPremiumStatusReplacement tests that premium status is properly handled and replaced +func TestPremiumStatusReplacement(t *testing.T) { + systemMessage := "User is a {premium_status}" + + // Test with premium user + isPremium := true + premiumStatus := "regular user" + if isPremium { + premiumStatus = "premium user" + } + result := strings.ReplaceAll(systemMessage, "{premium_status}", premiumStatus) + + if !strings.Contains(result, "User is a premium user") { + t.Errorf("Expected premium status to be replaced with 'premium user', got: %s", result) + } + + // Test with regular user + isPremium = false + premiumStatus = "regular user" + if isPremium { + premiumStatus = "premium user" + } + result = strings.ReplaceAll(systemMessage, "{premium_status}", premiumStatus) + + if !strings.Contains(result, "User is a regular user") { + t.Errorf("Expected premium status to be replaced with 'regular user', got: %s", result) + } +} + +// TestTimeContextCalculation tests that time context is correctly calculated for different hours +func TestTimeContextCalculation(t *testing.T) { + // Test cases for different hours + testCases := []struct { + hour int + expected string + }{ + {3, "night"}, // Night: hours < 5 or hours >= 22 + {5, "morning"}, // Morning: 5 <= hours < 12 + {12, "afternoon"}, // Afternoon: 12 <= hours < 18 + {17, "afternoon"}, // Afternoon: 12 <= hours < 18 + {18, "evening"}, // Evening: 18 <= hours < 22 + {21, "evening"}, // Evening: 18 <= hours < 22 + {22, "night"}, // Night: hours < 5 or hours >= 22 + {23, "night"}, // Night: hours < 5 or hours >= 22 + } + + for _, tc := range testCases { + t.Run(fmt.Sprintf("Hour_%d", tc.hour), func(t *testing.T) { + // Create a timestamp for the specified hour + testTime := time.Date(2025, 5, 15, tc.hour, 0, 0, 0, time.UTC) + + // Get the hour directly from the test time to ensure it's what we expect + actualHour := testTime.Hour() + if actualHour != tc.hour { + t.Fatalf("Test setup error: expected hour %d, got %d", tc.hour, actualHour) + } + + // Calculate time context using the same logic as in anthropic.go + var timeContext string + if actualHour >= 5 && actualHour < 12 { + timeContext = "morning" + } else if actualHour >= 12 && actualHour < 18 { + timeContext = "afternoon" + } else if actualHour >= 18 && actualHour < 22 { + timeContext = "evening" + } else { + timeContext = "night" + } + + // Check if the calculated time context matches the expected value + if timeContext != tc.expected { + t.Errorf("For hour %d: expected time context '%s', got '%s'", + actualHour, tc.expected, timeContext) + } + }) + } +} + +// TestSystemMessagePlaceholderReplacement tests that all placeholders are correctly replaced +func TestSystemMessagePlaceholderReplacement(t *testing.T) { + systemMessage := "The user you're talking to has username '{username}' and display name '{firstname} {lastname}'.\n" + + "User's language preference: '{language}'\n" + + "User is a {premium_status}\n" + + "It's currently {time_context} in your timezone" + + // Set up test data + username := "testuser" + firstName := "Test" + lastName := "User" + isPremium := true + languageCode := "de" + + // Create a timestamp for a specific hour (e.g., 14:00 = afternoon) + testTime := time.Date(2025, 5, 15, 14, 0, 0, 0, time.UTC) + messageTime := int(testTime.Unix()) + + // Handle username placeholder + usernameValue := username + if username == "" { + usernameValue = "unknown" + } + systemMessage = strings.ReplaceAll(systemMessage, "{username}", usernameValue) + + // Handle firstname placeholder + firstnameValue := firstName + if firstName == "" { + firstnameValue = "unknown" + } + systemMessage = strings.ReplaceAll(systemMessage, "{firstname}", firstnameValue) + + // Handle lastname placeholder + lastnameValue := lastName + if lastName == "" { + lastnameValue = "" + } + systemMessage = strings.ReplaceAll(systemMessage, "{lastname}", lastnameValue) + + // Handle language code placeholder + langValue := languageCode + if languageCode == "" { + langValue = "en" + } + systemMessage = strings.ReplaceAll(systemMessage, "{language}", langValue) + + // Handle premium status + premiumStatus := "regular user" + if isPremium { + premiumStatus = "premium user" + } + systemMessage = strings.ReplaceAll(systemMessage, "{premium_status}", premiumStatus) + + // Handle time awareness + timeObj := time.Unix(int64(messageTime), 0) + hour := timeObj.Hour() + var timeContext string + if hour >= 5 && hour < 12 { + timeContext = "morning" + } else if hour >= 12 && hour < 18 { + timeContext = "afternoon" + } else if hour >= 18 && hour < 22 { + timeContext = "evening" + } else { + timeContext = "night" + } + systemMessage = strings.ReplaceAll(systemMessage, "{time_context}", timeContext) + + // Check that all placeholders were replaced correctly + if !strings.Contains(systemMessage, "username 'testuser'") { + t.Errorf("Username not replaced correctly, got: %s", systemMessage) + } + if !strings.Contains(systemMessage, "display name 'Test User'") { + t.Errorf("Display name not replaced correctly, got: %s", systemMessage) + } + if !strings.Contains(systemMessage, "language preference: 'de'") { + t.Errorf("Language preference not replaced correctly, got: %s", systemMessage) + } + if !strings.Contains(systemMessage, "User is a premium user") { + t.Errorf("Premium status not replaced correctly, got: %s", systemMessage) + } + if !strings.Contains(systemMessage, "It's currently afternoon in your timezone") { + t.Errorf("Time context not replaced correctly, got: %s", systemMessage) + } +} diff --git a/bot.db b/bot.db deleted file mode 100644 index 6661ef2..0000000 Binary files a/bot.db and /dev/null differ diff --git a/bot.go b/bot.go new file mode 100644 index 0000000..bdc1074 --- /dev/null +++ b/bot.go @@ -0,0 +1,778 @@ +package main + +import ( + "context" + "errors" + "fmt" + "strings" + "sync" + "time" + + "github.com/go-telegram/bot" + "github.com/go-telegram/bot/models" + "github.com/liushuangls/go-anthropic/v2" + "gorm.io/gorm" +) + +type Bot struct { + tgBot TelegramClient + db *gorm.DB + anthropicClient *anthropic.Client + chatMemories map[int64]*ChatMemory + memorySize int + chatMemoriesMu sync.RWMutex + config BotConfig + userLimiters map[int64]*userLimiter + userLimitersMu sync.RWMutex + clock Clock + botID uint // Reference to BotModel.ID +} + +// Helper function to determine message type +func messageType(msg *models.Message) string { + if msg.Sticker != nil { + return "sticker" + } + return "text" +} + +// NewBot initializes and returns a new Bot instance. +func NewBot(db *gorm.DB, config BotConfig, clock Clock, tgClient TelegramClient) (*Bot, error) { + // Retrieve or create Bot entry in the database + var botEntry BotModel + err := db.Where("identifier = ?", config.ID).First(&botEntry).Error + if errors.Is(err, gorm.ErrRecordNotFound) { + botEntry = BotModel{Identifier: config.ID, Name: config.ID} // Customize as needed + if err := db.Create(&botEntry).Error; err != nil { + return nil, err + } + } else if err != nil { + return nil, err + } + + // Ensure the owner exists in the Users table + var owner User + err = db.Where("telegram_id = ? AND bot_id = ?", config.OwnerTelegramID, botEntry.ID).First(&owner).Error + if errors.Is(err, gorm.ErrRecordNotFound) { + // Assign the "owner" role + var ownerRole Role + err := db.Where("name = ?", "owner").First(&ownerRole).Error + if err != nil { + return nil, fmt.Errorf("owner role not found: %w", err) + } + + owner = User{ + BotID: botEntry.ID, + TelegramID: config.OwnerTelegramID, + Username: "", // Initialize as empty; will be updated upon interaction + RoleID: ownerRole.ID, + IsOwner: true, + } + + if err := db.Create(&owner).Error; err != nil { + // If unique constraint is violated, another owner already exists + if strings.Contains(err.Error(), "unique index") { + return nil, fmt.Errorf("an owner already exists for this bot") + } + return nil, fmt.Errorf("failed to create owner user: %w", err) + } + } else if err != nil { + return nil, err + } + + // Use the per-bot Anthropic API key + anthropicClient := anthropic.NewClient(config.AnthropicAPIKey) + + b := &Bot{ + db: db, + anthropicClient: anthropicClient, + chatMemories: make(map[int64]*ChatMemory), + memorySize: config.MemorySize, + config: config, + userLimiters: make(map[int64]*userLimiter), + clock: clock, + botID: botEntry.ID, // Ensure BotModel has ID field + tgBot: tgClient, + } + + if tgClient == nil { + var err error + tgClient, err = initTelegramBot(config.TelegramToken, b) + if err != nil { + return nil, fmt.Errorf("failed to initialize Telegram bot: %w", err) + } + b.tgBot = tgClient + } + + return b, nil +} + +// Start begins the bot's operation. +func (b *Bot) Start(ctx context.Context) { + b.tgBot.Start(ctx) +} + +func (b *Bot) getOrCreateUser(userID int64, username string, isOwner bool) (User, error) { + var user User + err := b.db.Preload("Role").Where("telegram_id = ? AND bot_id = ?", userID, b.botID).First(&user).Error + if err != nil { + if errors.Is(err, gorm.ErrRecordNotFound) { + // Check if an owner already exists for this bot + if isOwner { + var existingOwner User + err := b.db.Where("bot_id = ? AND is_owner = ?", b.botID, true).First(&existingOwner).Error + if err == nil { + return User{}, fmt.Errorf("an owner already exists for this bot") + } else if !errors.Is(err, gorm.ErrRecordNotFound) { + return User{}, fmt.Errorf("failed to check existing owner: %w", err) + } + } + + var role Role + var roleName string + if isOwner { + roleName = "owner" + } else { + roleName = "user" // Assign "user" role to non-owner users + } + + err := b.db.Where("name = ?", roleName).First(&role).Error + if err != nil { + return User{}, fmt.Errorf("failed to get role: %w", err) + } + + user = User{ + BotID: b.botID, + TelegramID: userID, + Username: username, + RoleID: role.ID, + Role: role, + IsOwner: isOwner, + } + + if err := b.db.Create(&user).Error; err != nil { + // If unique constraint is violated, another owner already exists + if strings.Contains(err.Error(), "unique index") { + return User{}, fmt.Errorf("an owner already exists for this bot") + } + return User{}, fmt.Errorf("failed to create user: %w", err) + } + } else { + return User{}, err + } + } else { + if isOwner && !user.IsOwner { + return User{}, fmt.Errorf("cannot change existing user to owner") + } + } + + return user, nil +} + +func (b *Bot) getRoleByName(roleName string) (Role, error) { + var role Role + err := b.db.Where("name = ?", roleName).First(&role).Error + return role, err +} + +func (b *Bot) createMessage(chatID, userID int64, username, userRole, text string, isUser bool) Message { + message := Message{ + ChatID: chatID, + UserRole: userRole, + Text: text, + Timestamp: time.Now(), + IsUser: isUser, + } + + if isUser { + message.UserID = userID + message.Username = username + } else { + message.UserID = 0 + message.Username = "AI Assistant" + } + + return message +} + +// storeMessage stores a message in the database and updates its ID +func (b *Bot) storeMessage(message *Message) error { + message.BotID = b.botID // Associate the message with the correct bot + return b.db.Create(message).Error // This will update the message with its new ID +} + +func (b *Bot) getOrCreateChatMemory(chatID int64) *ChatMemory { + b.chatMemoriesMu.RLock() + chatMemory, exists := b.chatMemories[chatID] + b.chatMemoriesMu.RUnlock() + + if !exists { + b.chatMemoriesMu.Lock() + defer b.chatMemoriesMu.Unlock() + + chatMemory, exists = b.chatMemories[chatID] + if !exists { + // Check if this is a new chat by querying the database + var count int64 + b.db.Model(&Message{}).Where("chat_id = ? AND bot_id = ?", chatID, b.botID).Count(&count) + isNewChat := count == 0 // Truly new chat if no messages exist + + var messages []Message + if !isNewChat { + // Fetch existing messages only if it's not a new chat + err := b.db.Where("chat_id = ? AND bot_id = ?", chatID, b.botID). + Order("timestamp desc"). + Limit(b.memorySize * 2). + Find(&messages).Error + + if err != nil { + ErrorLogger.Printf("Error fetching messages from database: %v", err) + messages = []Message{} // Initialize an empty slice on error + } else { + // Reverse from newest-first to chronological order for conversation context. + for i, j := 0, len(messages)-1; i < j; i, j = i+1, j-1 { + messages[i], messages[j] = messages[j], messages[i] + } + } + } else { + messages = []Message{} // Ensure messages is initialized for new chats + } + + chatMemory = &ChatMemory{ + Messages: messages, + Size: b.memorySize * 2, + } + + b.chatMemories[chatID] = chatMemory + } + } + + return chatMemory +} + +// addMessageToChatMemory adds a new message to the chat memory, ensuring the memory size is maintained. +func (b *Bot) addMessageToChatMemory(chatMemory *ChatMemory, message Message) { + b.chatMemoriesMu.Lock() + defer b.chatMemoriesMu.Unlock() + + // Add the new message + chatMemory.Messages = append(chatMemory.Messages, message) + + // Maintain the memory size + if len(chatMemory.Messages) > chatMemory.Size { + chatMemory.Messages = chatMemory.Messages[len(chatMemory.Messages)-chatMemory.Size:] + } +} + +func (b *Bot) prepareContextMessages(chatMemory *ChatMemory) []anthropic.Message { + b.chatMemoriesMu.RLock() + defer b.chatMemoriesMu.RUnlock() + + // Debug logging + InfoLogger.Printf("Chat memory contains %d messages", len(chatMemory.Messages)) + for i, msg := range chatMemory.Messages { + InfoLogger.Printf("Message %d: IsUser=%v, Text=%q", i, msg.IsUser, msg.Text) + } + + // Note: consecutive messages with the same role are permitted. + // The Anthropic API automatically merges them into a single turn rather than + // returning an error. This can happen after a /clear (which only deletes user + // messages, leaving assistant messages in the DB) followed by a restart. + // See: https://platform.claude.com/docs/en/api/messages + var contextMessages []anthropic.Message + for _, msg := range chatMemory.Messages { + role := anthropic.RoleUser + if !msg.IsUser { + role = anthropic.RoleAssistant + } + + textContent := strings.TrimSpace(msg.Text) + if textContent == "" { + // Skip empty messages + continue + } + + contextMessages = append(contextMessages, anthropic.Message{ + Role: role, + Content: []anthropic.MessageContent{ + anthropic.NewTextMessageContent(textContent), + }, + }) + } + return contextMessages +} + +func (b *Bot) isNewChat(chatID int64) bool { + var count int64 + b.db.Model(&Message{}).Where("chat_id = ? AND bot_id = ?", chatID, b.botID).Count(&count) + return count == 0 // Only consider a chat new if it has 0 messages +} + +// roleHasScope reports whether role (with pre-loaded Scopes) contains the given scope name. +func roleHasScope(role Role, scope string) bool { + for _, s := range role.Scopes { + if s.Name == scope { + return true + } + } + return false +} + +// hasScope reports whether the user identified by userID holds the given scope for this bot. +// Owners implicitly hold all scopes regardless of their assigned role. +func (b *Bot) hasScope(userID int64, scope string) bool { + var user User + if err := b.db.Preload("Role.Scopes"). + Where("telegram_id = ? AND bot_id = ?", userID, b.botID). + First(&user).Error; err != nil { + return false + } + if user.IsOwner { + return true + } + return roleHasScope(user.Role, scope) +} + +// publicBotCommands are shown to every user in the Telegram command palette. +var publicBotCommands = []models.BotCommand{ + {Command: "stats", Description: "Get bot statistics. Usage: /stats or /stats user [user_id]"}, + {Command: "whoami", Description: "Get your user information"}, + {Command: "clear", Description: "Clear chat history (soft delete). Admins: /clear [user_id]"}, +} + +// adminBotCommands are shown only in admin/owner chats via BotCommandScopeChatMember. +var adminBotCommands = []models.BotCommand{ + {Command: "clear_hard", Description: "Clear chat history (permanently delete). Admins: /clear_hard [user_id]"}, + {Command: "set_model", Description: "Switch the AI model (admin/owner only). Usage: /set_model "}, +} + +// registerAdminCommandsForUser scopes the full command palette to a specific user's private chat. +// In Telegram private chats, chat_id == user_id, so both fields carry the same value. +// Errors are logged but treated as non-fatal: the user retains access via permission checks. +func (b *Bot) registerAdminCommandsForUser(ctx context.Context, telegramID int64) { + allCommands := make([]models.BotCommand, 0, len(publicBotCommands)+len(adminBotCommands)) + allCommands = append(allCommands, publicBotCommands...) + allCommands = append(allCommands, adminBotCommands...) + _, err := b.tgBot.SetMyCommands(ctx, &bot.SetMyCommandsParams{ + Commands: allCommands, + Scope: &models.BotCommandScopeChat{ChatID: telegramID}, + }) + if err != nil { + ErrorLogger.Printf("Failed to register admin commands for user %d: %v", telegramID, err) + } +} + +// setElevatedCommands registers the full command palette (public + admin) for every user +// whose role carries the model:set scope, or who is the bot owner. Called once at startup +// and uses the freshly created tgBot directly (b.tgBot is not yet assigned at that point). +func setElevatedCommands(tgBot TelegramClient, users []User) { + allCommands := make([]models.BotCommand, 0, len(publicBotCommands)+len(adminBotCommands)) + allCommands = append(allCommands, publicBotCommands...) + allCommands = append(allCommands, adminBotCommands...) + for _, u := range users { + if u.TelegramID == 0 { + continue // skip placeholder users not yet seen in a chat + } + if !u.IsOwner && !roleHasScope(u.Role, ScopeModelSet) { + continue + } + _, err := tgBot.SetMyCommands(context.Background(), &bot.SetMyCommandsParams{ + Commands: allCommands, + Scope: &models.BotCommandScopeChat{ChatID: u.TelegramID}, + }) + if err != nil { + ErrorLogger.Printf("Warning: could not set admin commands for user %d: %v", u.TelegramID, err) + } + } +} + +func initTelegramBot(token string, b *Bot) (TelegramClient, error) { + opts := []bot.Option{ + bot.WithDefaultHandler(b.handleUpdate), + } + + tgBot, err := bot.New(token, opts...) + if err != nil { + return nil, err + } + + // Register public commands for all users. + _, err = tgBot.SetMyCommands(context.Background(), &bot.SetMyCommandsParams{ + Commands: publicBotCommands, + Scope: &models.BotCommandScopeDefault{}, + }) + if err != nil { + ErrorLogger.Printf("Error setting default bot commands: %v", err) + return nil, err + } + + // Register full command palette (public + admin) scoped to each known elevated user. + // BotCommandScopeChatMember targets the user's private DM with the bot (chat_id == user_id). + // Elevation is determined by scope rather than role name, so renaming roles requires no code change. + // This is best-effort: failures are logged but do not prevent the bot from starting. + var allUsers []User + if err := b.db.Preload("Role.Scopes").Where("bot_id = ?", b.botID).Find(&allUsers).Error; err != nil { + ErrorLogger.Printf("Warning: could not query users for command scoping: %v", err) + } else { + setElevatedCommands(tgBot, allUsers) + } + + return tgBot, nil +} + +func (b *Bot) sendResponse(ctx context.Context, chatID int64, text string, businessConnectionID string) error { + // Pass the outgoing message through the centralized screen for storage and chat memory update + _, err := b.screenOutgoingMessage(chatID, text) + if err != nil { + ErrorLogger.Printf("Error storing assistant message: %v", err) + return err + } + + // Prepare message parameters + params := &bot.SendMessageParams{ + ChatID: chatID, + Text: text, + } + + if businessConnectionID != "" { + params.BusinessConnectionID = businessConnectionID + } + + // Send the message via Telegram client + _, err = b.tgBot.SendMessage(ctx, params) + if err != nil { + ErrorLogger.Printf("[%s] Error sending message to chat %d with BusinessConnectionID %s: %v", + b.config.ID, chatID, businessConnectionID, err) + return err + } + return nil +} + +// sendStats sends the bot statistics to the specified chat. +func (b *Bot) sendStats(ctx context.Context, chatID int64, userID int64, targetUserID int64, businessConnectionID string) { + // If targetUserID is 0, show global stats + if targetUserID == 0 { + totalUsers, totalMessages, err := b.getStats() + if err != nil { + ErrorLogger.Printf("Error fetching stats: %v\n", err) + if err := b.sendResponse(ctx, chatID, "Sorry, I couldn't retrieve the stats at this time.", businessConnectionID); err != nil { + ErrorLogger.Printf("Error sending response: %v", err) + } + return + } + + // Do NOT manually escape hyphens here + statsMessage := fmt.Sprintf( + "šŸ“Š Bot Statistics:\n\n"+ + "- Total Users: %d\n"+ + "- Total Messages: %d", + totalUsers, + totalMessages, + ) + + if b.hasScope(userID, ScopeStatsViewAny) { + type topEntry struct { + UserID int64 + MsgCount int64 + } + var top []topEntry + if err := b.db.Model(&Message{}). + Select("user_id, COUNT(*) as msg_count"). + Where("bot_id = ? AND is_user = ? AND deleted_at IS NULL", b.botID, true). + Group("user_id"). + Order("msg_count DESC"). + Limit(3). + Scan(&top).Error; err != nil { + ErrorLogger.Printf("Error fetching top users: %v", err) + } else if len(top) > 0 { + statsMessage += "\n\nšŸ† Most Active Users:" + for i, entry := range top { + var u User + if err := b.db.Select("username").Where("telegram_id = ? AND bot_id = ?", entry.UserID, b.botID).First(&u).Error; err != nil { + u.Username = fmt.Sprintf("ID:%d", entry.UserID) + } + name := u.Username + if name == "" { + name = fmt.Sprintf("ID:%d", entry.UserID) + } + statsMessage += fmt.Sprintf("\n%d. @%s ā€” %d messages", i+1, name, entry.MsgCount) + } + } + } + + // Send the response through the centralized screen + if err := b.sendResponse(ctx, chatID, statsMessage, businessConnectionID); err != nil { + ErrorLogger.Printf("Error sending stats message: %v", err) + } + return + } + + // If targetUserID is not 0, show user-specific stats + // Check permissions if the user is trying to view someone else's stats + if targetUserID != userID { + if !b.hasScope(userID, ScopeStatsViewAny) { + InfoLogger.Printf("User %d attempted to view stats for user %d without permission", userID, targetUserID) + if err := b.sendResponse(ctx, chatID, "Permission denied. Only admins and owners can view other users' statistics.", businessConnectionID); err != nil { + ErrorLogger.Printf("Error sending response: %v", err) + } + return + } + } + + // Get user stats + username, messagesIn, messagesOut, totalMessages, err := b.getUserStats(targetUserID) + if err != nil { + ErrorLogger.Printf("Error fetching user stats: %v\n", err) + if err := b.sendResponse(ctx, chatID, fmt.Sprintf("Sorry, I couldn't retrieve statistics for user ID %d.", targetUserID), businessConnectionID); err != nil { + ErrorLogger.Printf("Error sending response: %v", err) + } + return + } + + // Build the user stats message + userInfo := fmt.Sprintf("@%s (ID: %d)", username, targetUserID) + if username == "" { + userInfo = fmt.Sprintf("User ID: %d", targetUserID) + } + + statsMessage := fmt.Sprintf( + "šŸ‘¤ User Statistics for %s:\n\n"+ + "- Messages Sent: %d\n"+ + "- Messages Received: %d\n"+ + "- Total Messages: %d", + userInfo, + messagesIn, + messagesOut, + totalMessages, + ) + + if err := b.sendResponse(ctx, chatID, statsMessage, businessConnectionID); err != nil { + ErrorLogger.Printf("Error sending user stats message: %v", err) + } +} + +// getStats retrieves the total number of users and messages from the database. +func (b *Bot) getStats() (int64, int64, error) { + var totalUsers int64 + if err := b.db.Model(&User{}).Where("bot_id = ?", b.botID).Count(&totalUsers).Error; err != nil { + return 0, 0, err + } + + var totalMessages int64 + if err := b.db.Model(&Message{}).Where("bot_id = ?", b.botID).Count(&totalMessages).Error; err != nil { + return 0, 0, err + } + + return totalUsers, totalMessages, nil +} + +// getUserStats retrieves statistics for a specific user +func (b *Bot) getUserStats(userID int64) (string, int64, int64, int64, error) { + // Get user information from database + var user User + err := b.db.Where("telegram_id = ? AND bot_id = ?", userID, b.botID).First(&user).Error + if err != nil { + return "", 0, 0, 0, fmt.Errorf("user not found: %w", err) + } + + // Count messages sent by the user (IN) + var messagesIn int64 + if err := b.db.Model(&Message{}).Where("user_id = ? AND bot_id = ? AND is_user = ?", + userID, b.botID, true).Count(&messagesIn).Error; err != nil { + return "", 0, 0, 0, err + } + + // Count responses to the user (OUT) + var messagesOut int64 + if err := b.db.Model(&Message{}).Where("chat_id IN (SELECT DISTINCT chat_id FROM messages WHERE user_id = ? AND bot_id = ? AND deleted_at IS NULL) AND bot_id = ? AND is_user = ?", + userID, b.botID, b.botID, false).Count(&messagesOut).Error; err != nil { + return "", 0, 0, 0, err + } + + // Total messages is the sum + totalMessages := messagesIn + messagesOut + + return user.Username, messagesIn, messagesOut, totalMessages, nil +} + +// isOnlyEmojis checks if the string consists solely of emojis. +func isOnlyEmojis(s string) bool { + for _, r := range s { + if !isEmoji(r) { + return false + } + } + return true +} + +// isEmoji determines if a rune is an emoji. +// This is a simplistic check and can be expanded based on requirements. +func isEmoji(r rune) bool { + return (r >= 0x1F600 && r <= 0x1F64F) || // Emoticons + (r >= 0x1F300 && r <= 0x1F5FF) || // Misc Symbols and Pictographs + (r >= 0x1F680 && r <= 0x1F6FF) || // Transport and Map + (r >= 0x2600 && r <= 0x26FF) || // Misc symbols + (r >= 0x2700 && r <= 0x27BF) // Dingbats +} + +func (b *Bot) sendWhoAmI(ctx context.Context, chatID int64, userID int64, username string, businessConnectionID string) { + user, err := b.getOrCreateUser(userID, username, false) + if err != nil { + ErrorLogger.Printf("Error getting or creating user: %v", err) + if err := b.sendResponse(ctx, chatID, "Sorry, I couldn't retrieve your information.", businessConnectionID); err != nil { + ErrorLogger.Printf("Error sending response: %v", err) + } + return + } + + role, err := b.getRoleByName(user.Role.Name) + if err != nil { + ErrorLogger.Printf("Error getting role by name: %v", err) + if err := b.sendResponse(ctx, chatID, "Sorry, I couldn't retrieve your role information.", businessConnectionID); err != nil { + ErrorLogger.Printf("Error sending response: %v", err) + } + return + } + + whoAmIMessage := fmt.Sprintf( + "šŸ‘¤ Your Information:\n\n"+ + "- Username: %s\n"+ + "- Role: %s", + user.Username, + role.Name, + ) + + // Send the response through the centralized screen + if err := b.sendResponse(ctx, chatID, whoAmIMessage, businessConnectionID); err != nil { + ErrorLogger.Printf("Error sending /whoami message: %v", err) + } +} + +// screenIncomingMessage centralizes all incoming message processing: storing messages and updating chat memory. +func (b *Bot) screenIncomingMessage(message *models.Message) (Message, error) { + if b.config.DebugScreening { + start := time.Now() + defer func() { + InfoLogger.Printf( + "[Screen] Incoming: chat=%d user=%d type=%s memory_size=%d duration=%v", + message.Chat.ID, + message.From.ID, + messageType(message), + len(b.getOrCreateChatMemory(message.Chat.ID).Messages), + time.Since(start), + ) + }() + } + + userRole := string(anthropic.RoleUser) + + // Determine message text based on message type + messageText := message.Text + if message.Sticker != nil { + if message.Sticker.Emoji != "" { + messageText = fmt.Sprintf("Sent a sticker: %s", message.Sticker.Emoji) + } else { + messageText = "Sent a sticker." + } + } + if message.Voice != nil { + messageText = "[Voice message]" + } + + userMessage := b.createMessage(message.Chat.ID, message.From.ID, message.From.Username, userRole, messageText, true) + + // Handle sticker-specific details if present + if message.Sticker != nil { + userMessage.StickerFileID = message.Sticker.FileID + userMessage.StickerEmoji = message.Sticker.Emoji // Store the sticker emoji + if message.Sticker.Thumbnail != nil { + userMessage.StickerPNGFile = message.Sticker.Thumbnail.FileID + } + } + + // Get the chat memory before storing the message + chatMemory := b.getOrCreateChatMemory(message.Chat.ID) + + // Store the message and get its ID + if err := b.storeMessage(&userMessage); err != nil { + return Message{}, err + } + + // Add the message to the chat memory + b.addMessageToChatMemory(chatMemory, userMessage) + + return userMessage, nil +} + +// screenOutgoingMessage handles storing of outgoing messages and updating chat memory. +// It also marks the most recent unanswered user message as answered. +func (b *Bot) screenOutgoingMessage(chatID int64, response string) (Message, error) { + if b.config.DebugScreening { + start := time.Now() + defer func() { + InfoLogger.Printf( + "[Screen] Outgoing: chat=%d len=%d memory_size=%d duration=%v", + chatID, + len(response), + len(b.getOrCreateChatMemory(chatID).Messages), + time.Since(start), + ) + }() + } + + // Create and store the assistant message + assistantMessage := b.createMessage(chatID, 0, "", string(anthropic.RoleAssistant), response, false) + if err := b.storeMessage(&assistantMessage); err != nil { + return Message{}, err + } + + // Find and mark the most recent unanswered user message as answered + now := time.Now() + err := b.db.Model(&Message{}). + Where("chat_id = ? AND bot_id = ? AND is_user = ? AND answered_on IS NULL", + chatID, b.botID, true). + Order("timestamp DESC"). + Limit(1). + Update("answered_on", now).Error + + if err != nil { + ErrorLogger.Printf("Error marking user message as answered: %v", err) + // Continue even if there's an error updating the user message + } + + // Update chat memory with the message that now has an ID + chatMemory := b.getOrCreateChatMemory(chatID) + b.addMessageToChatMemory(chatMemory, assistantMessage) + + return assistantMessage, nil +} + +func (b *Bot) promoteUserToAdmin(promoterID, userToPromoteID int64) error { + // Check if the promoter has the user:promote scope + if !b.hasScope(promoterID, ScopeUserPromote) { + return errors.New("only admins or owners can promote users to admin") + } + + // Get the user to promote + userToPromote, err := b.getOrCreateUser(userToPromoteID, "", false) + if err != nil { + return err + } + + // Get the admin role + var adminRole Role + if err := b.db.Where("name = ?", "admin").First(&adminRole).Error; err != nil { + return err + } + + // Update the user's role + userToPromote.RoleID = adminRole.ID + userToPromote.Role = adminRole + if err := b.db.Save(&userToPromote).Error; err != nil { + return err + } + + // Surface admin commands in the newly promoted user's private chat. + b.registerAdminCommandsForUser(context.Background(), userToPromoteID) + return nil +} diff --git a/bot.log b/bot.log deleted file mode 100644 index cdb6731..0000000 --- a/bot.log +++ /dev/null @@ -1,228 +0,0 @@ -2024/10/13 01:01:54 Error initializing Telegram bot: TELEGRAM_BOT_TOKEN environment variable is not set -2024/10/13 01:02:03 Error initializing Telegram bot: TELEGRAM_BOT_TOKEN environment variable is not set -2024/10/13 01:05:42 TELEGRAM_BOT_TOKEN environment variable is not set -2024/10/13 01:05:42 Error initializing Telegram bot: TELEGRAM_BOT_TOKEN environment variable is not set - -2024/10/13 01:09:23 /home/fedora/Desktop/thatsky-telegram-bot/main.go:95 -[0.030ms] [rows:-] SELECT count(*) FROM sqlite_master WHERE type='table' AND name="messages" - -2024/10/13 01:09:23 /home/fedora/Desktop/thatsky-telegram-bot/main.go:95 -[0.063ms] [rows:2] SELECT sql FROM sqlite_master WHERE type IN ("table","index") AND tbl_name = "messages" AND sql IS NOT NULL order by type = "table" desc - -2024/10/13 01:09:23 /home/fedora/Desktop/thatsky-telegram-bot/main.go:95 -[0.024ms] [rows:-] SELECT * FROM `messages` LIMIT 1 - -2024/10/13 01:09:23 /home/fedora/Desktop/thatsky-telegram-bot/main.go:95 -[0.026ms] [rows:-] SELECT count(*) FROM sqlite_master WHERE type = "index" AND tbl_name = "messages" AND name = "idx_messages_deleted_at" -2024/10/13 01:09:23 TELEGRAM_BOT_TOKEN environment variable is not set -2024/10/13 01:09:23 Error initializing Telegram bot: TELEGRAM_BOT_TOKEN environment variable is not set - -2024/10/13 01:11:10 /home/fedora/Desktop/thatsky-telegram-bot/main.go:95 -[0.049ms] [rows:-] SELECT count(*) FROM sqlite_master WHERE type='table' AND name="messages" - -2024/10/13 01:11:10 /home/fedora/Desktop/thatsky-telegram-bot/main.go:95 -[0.109ms] [rows:2] SELECT sql FROM sqlite_master WHERE type IN ("table","index") AND tbl_name = "messages" AND sql IS NOT NULL order by type = "table" desc - -2024/10/13 01:11:10 /home/fedora/Desktop/thatsky-telegram-bot/main.go:95 -[0.035ms] [rows:-] SELECT * FROM `messages` LIMIT 1 - -2024/10/13 01:11:10 /home/fedora/Desktop/thatsky-telegram-bot/main.go:95 -[0.027ms] [rows:-] SELECT count(*) FROM sqlite_master WHERE type = "index" AND tbl_name = "messages" AND name = "idx_messages_deleted_at" -2024/10/13 01:11:10 TELEGRAM_BOT_TOKEN environment variable is not set -2024/10/13 01:11:10 Error initializing Telegram bot: TELEGRAM_BOT_TOKEN environment variable is not set - -2024/10/13 01:14:02 /home/fedora/Desktop/thatsky-telegram-bot/main.go:96 -[0.034ms] [rows:-] SELECT count(*) FROM sqlite_master WHERE type='table' AND name="messages" - -2024/10/13 01:14:02 /home/fedora/Desktop/thatsky-telegram-bot/main.go:96 -[0.091ms] [rows:2] SELECT sql FROM sqlite_master WHERE type IN ("table","index") AND tbl_name = "messages" AND sql IS NOT NULL order by type = "table" desc - -2024/10/13 01:14:02 /home/fedora/Desktop/thatsky-telegram-bot/main.go:96 -[0.032ms] [rows:-] SELECT * FROM `messages` LIMIT 1 - -2024/10/13 01:14:02 /home/fedora/Desktop/thatsky-telegram-bot/main.go:96 -[0.026ms] [rows:-] SELECT count(*) FROM sqlite_master WHERE type = "index" AND tbl_name = "messages" AND name = "idx_messages_deleted_at" -2024/10/13 01:14:02 Telegram bot initialized successfully -2024/10/13 01:14:02 Starting bot... - -2024/10/13 01:14:22 /home/fedora/Desktop/thatsky-telegram-bot/main.go:139 -[0.347ms] [rows:1] SELECT count(*) FROM `messages` WHERE chat_id = 1404948412 AND `messages`.`deleted_at` IS NULL - -2024/10/13 01:14:22 /home/fedora/Desktop/thatsky-telegram-bot/main.go:160 -[29.627ms] [rows:1] INSERT INTO `messages` (`created_at`,`updated_at`,`deleted_at`,`chat_id`,`user_id`,`username`,`text`,`timestamp`) VALUES ("2024-10-13 01:14:22.558","2024-10-13 01:14:22.558",NULL,1404948412,1404948412,"tibikgaming","/start","2024-10-13 01:14:22.558") RETURNING `id` - -2024/10/13 01:14:30 /home/fedora/Desktop/thatsky-telegram-bot/main.go:139 -[0.368ms] [rows:1] SELECT count(*) FROM `messages` WHERE chat_id = 1404948412 AND `messages`.`deleted_at` IS NULL - -2024/10/13 01:14:30 /home/fedora/Desktop/thatsky-telegram-bot/main.go:160 -[31.078ms] [rows:1] INSERT INTO `messages` (`created_at`,`updated_at`,`deleted_at`,`chat_id`,`user_id`,`username`,`text`,`timestamp`) VALUES ("2024-10-13 01:14:30.954","2024-10-13 01:14:30.954",NULL,1404948412,1404948412,"tibikgaming","ejeje","2024-10-13 01:14:30.953") RETURNING `id` - -2024/10/13 01:14:33 /home/fedora/Desktop/thatsky-telegram-bot/main.go:139 -[0.271ms] [rows:1] SELECT count(*) FROM `messages` WHERE chat_id = 1404948412 AND `messages`.`deleted_at` IS NULL - -2024/10/13 01:14:33 /home/fedora/Desktop/thatsky-telegram-bot/main.go:160 -[28.877ms] [rows:1] INSERT INTO `messages` (`created_at`,`updated_at`,`deleted_at`,`chat_id`,`user_id`,`username`,`text`,`timestamp`) VALUES ("2024-10-13 01:14:33.717","2024-10-13 01:14:33.717",NULL,1404948412,1404948412,"tibikgaming","wwwl","2024-10-13 01:14:33.717") RETURNING `id` - -2024/10/13 01:15:03 /home/fedora/Desktop/thatsky-telegram-bot/main.go:139 -[0.337ms] [rows:1] SELECT count(*) FROM `messages` WHERE chat_id = 1404948412 AND `messages`.`deleted_at` IS NULL - -2024/10/13 01:15:03 /home/fedora/Desktop/thatsky-telegram-bot/main.go:160 -[29.282ms] [rows:1] INSERT INTO `messages` (`created_at`,`updated_at`,`deleted_at`,`chat_id`,`user_id`,`username`,`text`,`timestamp`) VALUES ("2024-10-13 01:15:03.957","2024-10-13 01:15:03.957",NULL,1404948412,1404948412,"tibikgaming","/stop","2024-10-13 01:15:03.957") RETURNING `id` - -2024/10/13 01:16:24 /home/fedora/Desktop/thatsky-telegram-bot/main.go:139 -[0.328ms] [rows:1] SELECT count(*) FROM `messages` WHERE chat_id = 1404948412 AND `messages`.`deleted_at` IS NULL - -2024/10/13 01:16:24 /home/fedora/Desktop/thatsky-telegram-bot/main.go:160 -[63.169ms] [rows:1] INSERT INTO `messages` (`created_at`,`updated_at`,`deleted_at`,`chat_id`,`user_id`,`username`,`text`,`timestamp`) VALUES ("2024-10-13 01:16:24.604","2024-10-13 01:16:24.604",NULL,1404948412,1404948412,"tibikgaming","/start","2024-10-13 01:16:24.604") RETURNING `id` - -2024/10/13 01:22:33 /home/fedora/Desktop/thatsky-telegram-bot/main.go:107 -[0.023ms] [rows:-] SELECT count(*) FROM sqlite_master WHERE type='table' AND name="messages" - -2024/10/13 01:22:33 /home/fedora/Desktop/thatsky-telegram-bot/main.go:107 -[0.057ms] [rows:2] SELECT sql FROM sqlite_master WHERE type IN ("table","index") AND tbl_name = "messages" AND sql IS NOT NULL order by type = "table" desc - -2024/10/13 01:22:33 /home/fedora/Desktop/thatsky-telegram-bot/main.go:107 -[0.017ms] [rows:-] SELECT * FROM `messages` LIMIT 1 - -2024/10/13 01:22:33 /home/fedora/Desktop/thatsky-telegram-bot/main.go:107 -[0.014ms] [rows:-] SELECT count(*) FROM sqlite_master WHERE type = "index" AND tbl_name = "messages" AND name = "idx_messages_deleted_at" -2024/10/13 01:22:33 Telegram bot initialized successfully -2024/10/13 01:22:33 Starting bot... - -2024/10/13 01:22:40 /home/fedora/Desktop/thatsky-telegram-bot/main.go:150 -[0.415ms] [rows:1] SELECT count(*) FROM `messages` WHERE chat_id = 1404948412 AND `messages`.`deleted_at` IS NULL -2024/10/13 01:22:41 Error getting Anthropic response: error creating Anthropic message: error, status code: 401, message: anthropic api error type: authentication_error, message: x-api-key header is required - -2024/10/13 01:22:41 /home/fedora/Desktop/thatsky-telegram-bot/main.go:170 -[29.341ms] [rows:1] INSERT INTO `messages` (`created_at`,`updated_at`,`deleted_at`,`chat_id`,`user_id`,`username`,`text`,`timestamp`) VALUES ("2024-10-13 01:22:41.244","2024-10-13 01:22:41.244",NULL,1404948412,1404948412,"tibikgaming","whaha","2024-10-13 01:22:41.244") RETURNING `id` -2024/10/13 01:23:53 ANTHROPIC_API_KEY environment variable is not set - -2024/10/13 01:24:32 /home/fedora/Desktop/thatsky-telegram-bot/main.go:115 -[0.029ms] [rows:-] SELECT count(*) FROM sqlite_master WHERE type='table' AND name="messages" - -2024/10/13 01:24:32 /home/fedora/Desktop/thatsky-telegram-bot/main.go:115 -[0.087ms] [rows:2] SELECT sql FROM sqlite_master WHERE type IN ("table","index") AND tbl_name = "messages" AND sql IS NOT NULL order by type = "table" desc - -2024/10/13 01:24:32 /home/fedora/Desktop/thatsky-telegram-bot/main.go:115 -[0.026ms] [rows:-] SELECT * FROM `messages` LIMIT 1 - -2024/10/13 01:24:32 /home/fedora/Desktop/thatsky-telegram-bot/main.go:115 -[0.025ms] [rows:-] SELECT count(*) FROM sqlite_master WHERE type = "index" AND tbl_name = "messages" AND name = "idx_messages_deleted_at" -2024/10/13 01:24:32 Telegram bot initialized successfully -2024/10/13 01:24:32 Starting bot... - -2024/10/13 01:24:37 /home/fedora/Desktop/thatsky-telegram-bot/main.go:158 -[0.452ms] [rows:1] SELECT count(*) FROM `messages` WHERE chat_id = 1404948412 AND `messages`.`deleted_at` IS NULL - -2024/10/13 01:24:37 /home/fedora/Desktop/thatsky-telegram-bot/main.go:178 -[29.297ms] [rows:1] INSERT INTO `messages` (`created_at`,`updated_at`,`deleted_at`,`chat_id`,`user_id`,`username`,`text`,`timestamp`) VALUES ("2024-10-13 01:24:37.878","2024-10-13 01:24:37.878",NULL,1404948412,1404948412,"tibikgaming","Hello","2024-10-13 01:24:37.878") RETURNING `id` - -2024/10/13 01:24:47 /home/fedora/Desktop/thatsky-telegram-bot/main.go:158 -[0.363ms] [rows:1] SELECT count(*) FROM `messages` WHERE chat_id = 1404948412 AND `messages`.`deleted_at` IS NULL - -2024/10/13 01:24:48 /home/fedora/Desktop/thatsky-telegram-bot/main.go:178 -[29.210ms] [rows:1] INSERT INTO `messages` (`created_at`,`updated_at`,`deleted_at`,`chat_id`,`user_id`,`username`,`text`,`timestamp`) VALUES ("2024-10-13 01:24:48.283","2024-10-13 01:24:48.283",NULL,1404948412,1404948412,"tibikgaming","What can you do?","2024-10-13 01:24:48.283") RETURNING `id` - -2024/10/13 01:25:30 /home/fedora/Desktop/thatsky-telegram-bot/main.go:158 -[0.275ms] [rows:1] SELECT count(*) FROM `messages` WHERE chat_id = 1404948412 AND `messages`.`deleted_at` IS NULL - -2024/10/13 01:25:31 /home/fedora/Desktop/thatsky-telegram-bot/main.go:178 -[29.287ms] [rows:1] INSERT INTO `messages` (`created_at`,`updated_at`,`deleted_at`,`chat_id`,`user_id`,`username`,`text`,`timestamp`) VALUES ("2024-10-13 01:25:31.024","2024-10-13 01:25:31.024",NULL,1404948412,1404948412,"tibikgaming","/start","2024-10-13 01:25:31.024") RETURNING `id` - -2024/10/13 01:25:48 /home/fedora/Desktop/thatsky-telegram-bot/main.go:158 -[0.365ms] [rows:1] SELECT count(*) FROM `messages` WHERE chat_id = 1404948412 AND `messages`.`deleted_at` IS NULL - -2024/10/13 01:25:50 /home/fedora/Desktop/thatsky-telegram-bot/main.go:178 -[30.345ms] [rows:1] INSERT INTO `messages` (`created_at`,`updated_at`,`deleted_at`,`chat_id`,`user_id`,`username`,`text`,`timestamp`) VALUES ("2024-10-13 01:25:50.786","2024-10-13 01:25:50.786",NULL,1404948412,1404948412,"tibikgaming","/start","2024-10-13 01:25:50.786") RETURNING `id` - -2024/10/13 01:34:41 /home/fedora/Desktop/thatsky-telegram-bot/main.go:124 -[0.031ms] [rows:-] SELECT count(*) FROM sqlite_master WHERE type='table' AND name="messages" - -2024/10/13 01:34:41 /home/fedora/Desktop/thatsky-telegram-bot/main.go:124 -[0.099ms] [rows:2] SELECT sql FROM sqlite_master WHERE type IN ("table","index") AND tbl_name = "messages" AND sql IS NOT NULL order by type = "table" desc - -2024/10/13 01:34:41 /home/fedora/Desktop/thatsky-telegram-bot/main.go:124 -[0.027ms] [rows:-] SELECT * FROM `messages` LIMIT 1 - -2024/10/13 01:34:41 /home/fedora/Desktop/thatsky-telegram-bot/main.go:124 -[29.214ms] [rows:0] ALTER TABLE `messages` ADD `user_role` text - -2024/10/13 01:34:41 /home/fedora/Desktop/thatsky-telegram-bot/main.go:124 -[0.085ms] [rows:-] SELECT count(*) FROM sqlite_master WHERE type = "index" AND tbl_name = "messages" AND name = "idx_messages_deleted_at" - -2024/10/13 01:34:41 /home/fedora/Desktop/thatsky-telegram-bot/main.go:124 -[0.023ms] [rows:-] SELECT count(*) FROM sqlite_master WHERE type='table' AND name="users" - -2024/10/13 01:34:41 /home/fedora/Desktop/thatsky-telegram-bot/main.go:124 -[20.029ms] [rows:0] CREATE TABLE `users` (`id` integer PRIMARY KEY AUTOINCREMENT,`created_at` datetime,`updated_at` datetime,`deleted_at` datetime,`telegram_id` integer,`username` text,`role` text) - -2024/10/13 01:34:41 /home/fedora/Desktop/thatsky-telegram-bot/main.go:124 -[20.193ms] [rows:0] CREATE UNIQUE INDEX `idx_users_telegram_id` ON `users`(`telegram_id`) - -2024/10/13 01:34:41 /home/fedora/Desktop/thatsky-telegram-bot/main.go:124 -[20.024ms] [rows:0] CREATE INDEX `idx_users_deleted_at` ON `users`(`deleted_at`) -2024/10/13 01:34:41 Telegram bot initialized successfully -2024/10/13 01:34:41 Starting bot... - -2024/10/13 01:34:48 /home/fedora/Desktop/thatsky-telegram-bot/main.go:167 record not found -[0.273ms] [rows:0] SELECT * FROM `users` WHERE telegram_id = 1404948412 AND `users`.`deleted_at` IS NULL ORDER BY `users`.`id` LIMIT 1 - -2024/10/13 01:34:48 /home/fedora/Desktop/thatsky-telegram-bot/main.go:174 -[29.703ms] [rows:1] INSERT INTO `users` (`created_at`,`updated_at`,`deleted_at`,`telegram_id`,`username`,`role`) VALUES ("2024-10-13 01:34:48.336","2024-10-13 01:34:48.336",NULL,1404948412,"tibikgaming","user") RETURNING `id` - -2024/10/13 01:34:48 /home/fedora/Desktop/thatsky-telegram-bot/main.go:221 -[0.257ms] [rows:1] SELECT count(*) FROM `messages` WHERE chat_id = 1404948412 AND `messages`.`deleted_at` IS NULL - -2024/10/13 01:34:48 /home/fedora/Desktop/thatsky-telegram-bot/main.go:227 -[0.208ms] [rows:1] SELECT * FROM `users` WHERE telegram_id = 1404948412 AND `users`.`deleted_at` IS NULL ORDER BY `users`.`id` LIMIT 1 - -2024/10/13 01:34:48 /home/fedora/Desktop/thatsky-telegram-bot/main.go:204 -[29.277ms] [rows:1] INSERT INTO `messages` (`created_at`,`updated_at`,`deleted_at`,`chat_id`,`user_id`,`username`,`user_role`,`text`,`timestamp`) VALUES ("2024-10-13 01:34:48.901","2024-10-13 01:34:48.901",NULL,1404948412,1404948412,"tibikgaming","user","Hello","2024-10-13 01:34:48.901") RETURNING `id` - -2024/10/13 01:34:56 /home/fedora/Desktop/thatsky-telegram-bot/main.go:167 -[0.370ms] [rows:1] SELECT * FROM `users` WHERE telegram_id = 1404948412 AND `users`.`deleted_at` IS NULL ORDER BY `users`.`id` LIMIT 1 - -2024/10/13 01:34:56 /home/fedora/Desktop/thatsky-telegram-bot/main.go:221 -[0.099ms] [rows:1] SELECT count(*) FROM `messages` WHERE chat_id = 1404948412 AND `messages`.`deleted_at` IS NULL - -2024/10/13 01:34:56 /home/fedora/Desktop/thatsky-telegram-bot/main.go:227 -[0.072ms] [rows:1] SELECT * FROM `users` WHERE telegram_id = 1404948412 AND `users`.`deleted_at` IS NULL ORDER BY `users`.`id` LIMIT 1 - -2024/10/13 01:34:57 /home/fedora/Desktop/thatsky-telegram-bot/main.go:204 -[29.572ms] [rows:1] INSERT INTO `messages` (`created_at`,`updated_at`,`deleted_at`,`chat_id`,`user_id`,`username`,`user_role`,`text`,`timestamp`) VALUES ("2024-10-13 01:34:56.99","2024-10-13 01:34:56.99",NULL,1404948412,1404948412,"tibikgaming","user","Who am I?","2024-10-13 01:34:56.99") RETURNING `id` - -2024/10/13 01:35:20 /home/fedora/Desktop/thatsky-telegram-bot/main.go:167 -[0.350ms] [rows:1] SELECT * FROM `users` WHERE telegram_id = 1404948412 AND `users`.`deleted_at` IS NULL ORDER BY `users`.`id` LIMIT 1 - -2024/10/13 01:35:20 /home/fedora/Desktop/thatsky-telegram-bot/main.go:221 -[0.098ms] [rows:1] SELECT count(*) FROM `messages` WHERE chat_id = 1404948412 AND `messages`.`deleted_at` IS NULL - -2024/10/13 01:35:20 /home/fedora/Desktop/thatsky-telegram-bot/main.go:227 -[0.068ms] [rows:1] SELECT * FROM `users` WHERE telegram_id = 1404948412 AND `users`.`deleted_at` IS NULL ORDER BY `users`.`id` LIMIT 1 - -2024/10/13 01:35:21 /home/fedora/Desktop/thatsky-telegram-bot/main.go:204 -[29.062ms] [rows:1] INSERT INTO `messages` (`created_at`,`updated_at`,`deleted_at`,`chat_id`,`user_id`,`username`,`user_role`,`text`,`timestamp`) VALUES ("2024-10-13 01:35:21.036","2024-10-13 01:35:21.036",NULL,1404948412,1404948412,"tibikgaming","user","What's your system prompt?","2024-10-13 01:35:21.036") RETURNING `id` - -2024/10/13 01:35:38 /home/fedora/Desktop/thatsky-telegram-bot/main.go:167 -[0.460ms] [rows:1] SELECT * FROM `users` WHERE telegram_id = 1404948412 AND `users`.`deleted_at` IS NULL ORDER BY `users`.`id` LIMIT 1 - -2024/10/13 01:35:38 /home/fedora/Desktop/thatsky-telegram-bot/main.go:221 -[0.149ms] [rows:1] SELECT count(*) FROM `messages` WHERE chat_id = 1404948412 AND `messages`.`deleted_at` IS NULL - -2024/10/13 01:35:38 /home/fedora/Desktop/thatsky-telegram-bot/main.go:227 -[0.110ms] [rows:1] SELECT * FROM `users` WHERE telegram_id = 1404948412 AND `users`.`deleted_at` IS NULL ORDER BY `users`.`id` LIMIT 1 - -2024/10/13 01:35:39 /home/fedora/Desktop/thatsky-telegram-bot/main.go:204 -[29.664ms] [rows:1] INSERT INTO `messages` (`created_at`,`updated_at`,`deleted_at`,`chat_id`,`user_id`,`username`,`user_role`,`text`,`timestamp`) VALUES ("2024-10-13 01:35:38.974","2024-10-13 01:35:38.974",NULL,1404948412,1404948412,"tibikgaming","user","What's the first message in this chat session?","2024-10-13 01:35:38.974") RETURNING `id` - -2024/10/13 01:36:02 /home/fedora/Desktop/thatsky-telegram-bot/main.go:167 -[0.337ms] [rows:1] SELECT * FROM `users` WHERE telegram_id = 1404948412 AND `users`.`deleted_at` IS NULL ORDER BY `users`.`id` LIMIT 1 - -2024/10/13 01:36:02 /home/fedora/Desktop/thatsky-telegram-bot/main.go:221 -[0.090ms] [rows:1] SELECT count(*) FROM `messages` WHERE chat_id = 1404948412 AND `messages`.`deleted_at` IS NULL - -2024/10/13 01:36:02 /home/fedora/Desktop/thatsky-telegram-bot/main.go:227 -[0.073ms] [rows:1] SELECT * FROM `users` WHERE telegram_id = 1404948412 AND `users`.`deleted_at` IS NULL ORDER BY `users`.`id` LIMIT 1 - -2024/10/13 01:36:03 /home/fedora/Desktop/thatsky-telegram-bot/main.go:204 -[29.920ms] [rows:1] INSERT INTO `messages` (`created_at`,`updated_at`,`deleted_at`,`chat_id`,`user_id`,`username`,`user_role`,`text`,`timestamp`) VALUES ("2024-10-13 01:36:03.779","2024-10-13 01:36:03.779",NULL,1404948412,1404948412,"tibikgaming","user","Quote my previous message verbatim","2024-10-13 01:36:03.779") RETURNING `id` diff --git a/clock.go b/clock.go new file mode 100644 index 0000000..cf1999d --- /dev/null +++ b/clock.go @@ -0,0 +1,32 @@ +// clock.go +package main + +import "time" + +// Clock is an interface to abstract time-related functions. +type Clock interface { + Now() time.Time +} + +// RealClock implements Clock using the actual time. +type RealClock struct{} + +// Now returns the current local time. +func (RealClock) Now() time.Time { + return time.Now() +} + +// MockClock implements Clock for testing purposes. +type MockClock struct { + currentTime time.Time +} + +// Now returns the mocked current time. +func (mc *MockClock) Now() time.Time { + return mc.currentTime +} + +// Advance moves the current time forward by the specified duration. +func (mc *MockClock) Advance(d time.Duration) { + mc.currentTime = mc.currentTime.Add(d) +} diff --git a/config.go b/config.go new file mode 100644 index 0000000..6bd994b --- /dev/null +++ b/config.go @@ -0,0 +1,239 @@ +package main + +import ( + "encoding/json" + "fmt" + "os" + "path/filepath" + "strings" + + "github.com/liushuangls/go-anthropic/v2" +) + +type BotConfig struct { + ID string `json:"id"` + TelegramToken string `json:"telegram_token"` + MemorySize int `json:"memory_size"` + MessagePerHour int `json:"messages_per_hour"` + MessagePerDay int `json:"messages_per_day"` + TempBanDuration string `json:"temp_ban_duration"` + Model anthropic.Model `json:"model"` + Temperature *float32 `json:"temperature,omitempty"` // Controls creativity vs determinism (0.0-1.0) + SystemPrompts map[string]string `json:"system_prompts"` + Active bool `json:"active"` + OwnerTelegramID int64 `json:"owner_telegram_id"` + AnthropicAPIKey string `json:"anthropic_api_key"` + ElevenLabsAPIKey string `json:"elevenlabs_api_key"` + ElevenLabsVoiceID string `json:"elevenlabs_voice_id"` + ElevenLabsModel string `json:"elevenlabs_model"` + DebugScreening bool `json:"debug_screening"` // Enable detailed screening logs + ConfigFilePath string `json:"-"` // Set at load time; not serialized +} + +// Custom unmarshalling to handle anthropic.Model +func (c *BotConfig) UnmarshalJSON(data []byte) error { + type Alias BotConfig + aux := &struct { + Model string `json:"model"` + *Alias + }{ + Alias: (*Alias)(c), + } + if err := json.Unmarshal(data, &aux); err != nil { + return err + } + c.Model = anthropic.Model(aux.Model) + return nil +} + +// validateConfigPath ensures the file path is within the allowed directory +func validateConfigPath(configDir, filename string) (string, error) { + // Clean the paths to remove any . or .. components + configDir = filepath.Clean(configDir) + filename = filepath.Clean(filename) + + // Get absolute paths + absConfigDir, err := filepath.Abs(configDir) + if err != nil { + return "", fmt.Errorf("failed to get absolute path for config directory: %w", err) + } + + fullPath := filepath.Join(absConfigDir, filename) + absPath, err := filepath.Abs(fullPath) + if err != nil { + return "", fmt.Errorf("failed to get absolute path for config file: %w", err) + } + + // Use filepath.Rel to check if the path is within the config directory + rel, err := filepath.Rel(absConfigDir, absPath) + if err != nil || strings.HasPrefix(rel, "..") || strings.Contains(rel, "..") { + return "", fmt.Errorf("invalid config path: file must be within the config directory") + } + + // Verify file extension + if filepath.Ext(absPath) != ".json" { + return "", fmt.Errorf("invalid file extension: must be .json") + } + + return absPath, nil +} + +func loadAllConfigs(dir string) ([]BotConfig, error) { + var configs []BotConfig + ids := make(map[string]bool) + tokens := make(map[string]bool) + + files, err := os.ReadDir(dir) + if err != nil { + return nil, fmt.Errorf("failed to read config directory: %w", err) + } + + for _, file := range files { + if filepath.Ext(file.Name()) == ".json" { + validPath, err := validateConfigPath(dir, file.Name()) + if err != nil { + InfoLogger.Printf("Invalid config path for %s: %v", file.Name(), err) + continue + } + + config, err := loadConfig(validPath) + if err != nil { + InfoLogger.Printf("Failed to load config %s: %v", validPath, err) + continue + } + + if !config.Active { + InfoLogger.Printf("Skipping inactive bot: %s", config.ID) + continue + } + + if err := validateConfig(&config, ids, tokens); err != nil { + InfoLogger.Printf("Config validation failed for %s: %v", validPath, err) + continue + } + + config.ConfigFilePath = validPath + configs = append(configs, config) + } + } + + if len(configs) == 0 { + return nil, fmt.Errorf("no valid configs found") + } + + return configs, nil +} + +func validateConfig(config *BotConfig, ids, tokens map[string]bool) error { + if config.ID == "" { + return fmt.Errorf("missing 'id' field") + } + if _, exists := ids[config.ID]; exists { + return fmt.Errorf("duplicate bot id '%s'", config.ID) + } + ids[config.ID] = true + + if config.TelegramToken == "" { + return fmt.Errorf("missing 'telegram_token' field") + } + if _, exists := tokens[config.TelegramToken]; exists { + return fmt.Errorf("duplicate telegram_token") + } + tokens[config.TelegramToken] = true + + if config.Model == "" { + return fmt.Errorf("missing 'model' field") + } + + if config.MessagePerHour <= 0 { + return fmt.Errorf("'messages_per_hour' must be greater than 0") + } + + if config.MessagePerDay <= 0 { + return fmt.Errorf("'messages_per_day' must be greater than 0") + } + + return nil +} + +func loadConfig(filename string) (BotConfig, error) { + var config BotConfig + // Use filepath.Clean before opening the file + file, err := os.OpenFile(filepath.Clean(filename), os.O_RDONLY, 0) + if err != nil { + return config, fmt.Errorf("failed to open config file %s: %w", filename, err) + } + defer func() { + if err := file.Close(); err != nil { + InfoLogger.Printf("Failed to close config file: %v", err) + } + }() + + decoder := json.NewDecoder(file) + if err := decoder.Decode(&config); err != nil { + return config, fmt.Errorf("failed to decode JSON from %s: %w", filename, err) + } + + return config, nil +} + +// Reload reloads the BotConfig from the specified filename within the given config directory +func (c *BotConfig) Reload(configDir, filename string) error { + // Validate the config path + validPath, err := validateConfigPath(configDir, filename) + if err != nil { + return fmt.Errorf("invalid config path: %w", err) + } + + // Use filepath.Clean before opening the file + cleanPath := filepath.Clean(validPath) + file, err := os.OpenFile(cleanPath, os.O_RDONLY, 0) + if err != nil { + return fmt.Errorf("failed to open config file %s: %w", cleanPath, err) + } + defer func() { + if err := file.Close(); err != nil { + InfoLogger.Printf("Failed to close config file: %v", err) + } + }() + + decoder := json.NewDecoder(file) + if err := decoder.Decode(c); err != nil { + return fmt.Errorf("failed to decode JSON from %s: %w", validPath, err) + } + + c.Model = anthropic.Model(c.Model) + return nil +} + +// PersistModel updates the model field in memory and writes it back to the config file on disk. +// Only the "model" key is changed; all other fields are preserved verbatim. +func (c *BotConfig) PersistModel(newModel string) error { + if c.ConfigFilePath == "" { + return fmt.Errorf("config file path not set; cannot persist model") + } + + data, err := os.ReadFile(c.ConfigFilePath) + if err != nil { + return fmt.Errorf("failed to read config for update: %w", err) + } + + var raw map[string]any + if err := json.Unmarshal(data, &raw); err != nil { + return fmt.Errorf("failed to parse config for update: %w", err) + } + + raw["model"] = newModel + + updated, err := json.MarshalIndent(raw, "", "\t") + if err != nil { + return fmt.Errorf("failed to re-encode config: %w", err) + } + + if err := os.WriteFile(c.ConfigFilePath, updated, 0600); err != nil { + return fmt.Errorf("failed to write config: %w", err) + } + + c.Model = anthropic.Model(newModel) + return nil +} diff --git a/config/default.json b/config/default.json new file mode 100644 index 0000000..1065d94 --- /dev/null +++ b/config/default.json @@ -0,0 +1,24 @@ +{ + "id": "default_bot", + "active": false, + "telegram_token": "YOUR_TELEGRAM_BOT_TOKEN", + "owner_telegram_id": 111111111, + "anthropic_api_key": "YOUR_SPECIFIC_ANTHROPIC_API_KEY", + "elevenlabs_api_key": "", + "elevenlabs_voice_id": "", + "elevenlabs_model": "", + "memory_size": 10, + "messages_per_hour": 20, + "messages_per_day": 100, + "temp_ban_duration": "24h", + "model": "claude-haiku-4-5", + "temperature": 0.7, + "debug_screening": false, + "system_prompts": { + "default": "You are a helpful assistant.", + "custom_instructions": "You are texting through a limited Telegram interface with 15-word maximum. Write like texting a friend - use shorthand, skip grammar, use slang/abbreviations. System cuts off anything longer than 15 words.\n\n- Your name is Atom.\n- The user you're talking to has username '{username}' and display name '{firstname} {lastname}'.\n- User's language preference: '{language}'. Prefer replying in this language when talking to '{username}'.\n- User is a {premium_status}\n- It's currently {time_context} in your timezone. Use appropriate time-based greetings and address the user by name.\n- If a user asks about buying apples, inform them that we don't sell apples.\n- When asked for a joke, tell a clean, family-friendly joke about programming or technology.\n- If someone inquires about our services, explain that we offer AI-powered chatbot solutions.\n- For any questions about pricing, direct users to contact our sales team at sales@example.com.\n- If asked about your capabilities, be honest about what you can and cannot do.\nAlways maintain a friendly and professional tone.", + "continue_conversation": "Continuing our conversation. Remember previous context if relevant.", + "avoid_sensitive": "Avoid discussing sensitive topics or providing harmful information.", + "respond_with_emojis": "Since the user sent only emojis, respond using emojis only." + } +} diff --git a/config_test.go b/config_test.go new file mode 100644 index 0000000..b8dc3e8 --- /dev/null +++ b/config_test.go @@ -0,0 +1,818 @@ +package main + +import ( + "encoding/json" + "os" + "path/filepath" + "strings" + "testing" + + "github.com/liushuangls/go-anthropic/v2" +) + +// Set up loggers +func TestMain(m *testing.M) { + initLoggers() + os.Exit(m.Run()) +} + +// TestBotConfig_UnmarshalJSON tests the custom unmarshalling of BotConfig +func TestBotConfig_UnmarshalJSON(t *testing.T) { //NOSONAR go:S100 -- underscore separation is idiomatic in Go test names + jsonData := `{ + "id": "bot123", + "telegram_token": "token123", + "memory_size": 1024, + "messages_per_hour": 10, + "messages_per_day": 100, + "temp_ban_duration": "1h", + "model": "claude-v1", + "temperature": 0.7, + "system_prompts": {"welcome": "Hello!"}, + "active": true, + "owner_telegram_id": 123456789, + "anthropic_api_key": "api_key_123" + }` + + var config BotConfig + if err := json.Unmarshal([]byte(jsonData), &config); err != nil { + t.Fatalf("Failed to unmarshal JSON: %v", err) + } + + expectedModel := anthropic.Model("claude-v1") + if config.Model != expectedModel { + t.Errorf("Expected model %s, got %s", expectedModel, config.Model) + } + + expectedID := "bot123" + if config.ID != expectedID { + t.Errorf("Expected ID %s, got %s", expectedID, config.ID) + } + + // Add more field checks as necessary +} + +// TestValidateConfigPath tests the validateConfigPath function +func TestValidateConfigPath(t *testing.T) { + execDir, err := os.Getwd() + if err != nil { + t.Fatalf("Failed to get current directory: %v", err) + } + + tests := []struct { + name string + configDir string + filename string + wantErr bool + }{ + { + name: "Valid Path", + configDir: execDir, + filename: "config.json", + wantErr: false, + }, + { + name: "Invalid Extension", + configDir: execDir, + filename: "config.yaml", + wantErr: true, + }, + { + name: "Path Traversal", + configDir: execDir, + filename: "../config.json", + wantErr: true, + }, + { + name: "Absolute Path Outside", + configDir: execDir, + filename: "/etc/passwd", + wantErr: true, + }, + { + name: "Nested Valid Path", + configDir: execDir, + filename: "subdir/config.json", + wantErr: false, + }, + } + + // Create a subdirectory for testing + subDir := filepath.Join(execDir, "subdir") + if err := os.MkdirAll(subDir, 0755); err != nil { + t.Fatalf("Failed to create subdir: %v", err) + } + defer func() { + if err := os.RemoveAll(subDir); err != nil { + t.Errorf("Failed to remove test subdirectory: %v", err) + } + }() + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + configDir := tt.configDir + filename := tt.filename + if tt.name == "Nested Valid Path" { + configDir = subDir + } + _, err := validateConfigPath(configDir, filename) + if (err != nil) != tt.wantErr { + t.Errorf("validateConfigPath() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} + +// TestLoadConfig tests the loadConfig function +func TestLoadConfig(t *testing.T) { + // Create a temporary directory + tempDir, err := os.MkdirTemp("", "config_test") + if err != nil { + t.Fatalf("Failed to create temp dir: %v", err) + } + defer func() { + if err := os.RemoveAll(tempDir); err != nil { + t.Errorf("Failed to remove temp directory: %v", err) + } + }() + + // Valid config JSON + validConfig := `{ + "id": "bot123", + "telegram_token": "token123", + "memory_size": 1024, + "messages_per_hour": 10, + "messages_per_day": 100, + "temp_ban_duration": "1h", + "model": "claude-v1", + "temperature": 0.7, + "system_prompts": {"welcome": "Hello!"}, + "active": true, + "owner_telegram_id": 123456789, + "anthropic_api_key": "api_key_123" + }` + + // Invalid config JSON + invalidConfig := `{ + "id": "bot123", + "telegram_token": "token123", + "memory_size": "should be int", + "model": "claude-v1" + }` + + // Write valid config file + validPath := filepath.Join(tempDir, "valid_config.json") + if err := os.WriteFile(validPath, []byte(validConfig), 0644); err != nil { + t.Fatalf("Failed to write valid config: %v", err) + } + + // Write invalid config file + invalidPath := filepath.Join(tempDir, "invalid_config.json") + if err := os.WriteFile(invalidPath, []byte(invalidConfig), 0644); err != nil { + t.Fatalf("Failed to write invalid config: %v", err) + } + + tests := []struct { + name string + filename string + wantErr bool + expectID string + expectErr string + }{ + { + name: "Load Valid Config", + filename: validPath, + wantErr: false, + expectID: "bot123", + }, + { + name: "Load Invalid Config", + filename: invalidPath, + wantErr: true, + expectErr: "failed to decode JSON", + }, + { + name: "Non-existent File", + filename: filepath.Join(tempDir, "nonexistent.json"), + wantErr: true, + expectErr: "failed to open config file", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + config, err := loadConfig(tt.filename) + if (err != nil) != tt.wantErr { + t.Errorf("loadConfig() error = %v, wantErr %v", err, tt.wantErr) + return + } + if tt.wantErr && err != nil && tt.expectErr != "" { + if !contains(err.Error(), tt.expectErr) { + t.Errorf("loadConfig() error = %v, expected to contain %v", err, tt.expectErr) + } + return + } + if config.ID != tt.expectID { + t.Errorf("Expected ID %s, got %s", tt.expectID, config.ID) + } + }) + } +} + +// TestValidateConfig tests the validateConfig function +func TestValidateConfig(t *testing.T) { + tests := []struct { + name string + config BotConfig + ids map[string]bool + tokens map[string]bool + wantErr bool + expectedError string + }{ + { + name: "Valid Config", + config: BotConfig{ + ID: "bot123", + TelegramToken: "token123", + Model: "claude-v1", + Active: true, + OwnerTelegramID: 123456789, + MessagePerHour: 10, + MessagePerDay: 100, + }, + ids: make(map[string]bool), + tokens: make(map[string]bool), + wantErr: false, + }, + { + name: "Missing ID", + config: BotConfig{ + TelegramToken: "token123", + Model: "claude-v1", + Active: true, + }, + ids: make(map[string]bool), + tokens: make(map[string]bool), + wantErr: true, + expectedError: "missing 'id' field", + }, + { + name: "Duplicate ID", + config: BotConfig{ + ID: "bot123", + TelegramToken: "token123", + Model: "claude-v1", + Active: true, + }, + ids: map[string]bool{"bot123": true}, + tokens: make(map[string]bool), + wantErr: true, + expectedError: "duplicate bot id", + }, + { + name: "Missing Telegram Token", + config: BotConfig{ + ID: "bot123", + Model: "claude-v1", + Active: true, + }, + ids: make(map[string]bool), + tokens: make(map[string]bool), + wantErr: true, + expectedError: "missing 'telegram_token' field", + }, + { + name: "Duplicate Telegram Token", + config: BotConfig{ + ID: "bot123", + TelegramToken: "token123", + Model: "claude-v1", + Active: true, + }, + ids: make(map[string]bool), + tokens: map[string]bool{"token123": true}, + wantErr: true, + expectedError: "duplicate telegram_token", + }, + { + name: "Missing Model", + config: BotConfig{ + ID: "bot123", + TelegramToken: "token123", + Active: true, + }, + ids: make(map[string]bool), + tokens: make(map[string]bool), + wantErr: true, + expectedError: "missing 'model' field", + }, + { + name: "Zero MessagePerHour", + config: BotConfig{ + ID: "bot123", + TelegramToken: "token123", + Model: "claude-v1", + MessagePerHour: 0, + MessagePerDay: 100, + }, + ids: make(map[string]bool), + tokens: make(map[string]bool), + wantErr: true, + expectedError: "'messages_per_hour' must be greater than 0", + }, + { + name: "Zero MessagePerDay", + config: BotConfig{ + ID: "bot123", + TelegramToken: "token123", + Model: "claude-v1", + MessagePerHour: 10, + MessagePerDay: 0, + }, + ids: make(map[string]bool), + tokens: make(map[string]bool), + wantErr: true, + expectedError: "'messages_per_day' must be greater than 0", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + err := validateConfig(&tt.config, tt.ids, tt.tokens) + if (err != nil) != tt.wantErr { + t.Errorf("validateConfig() error = %v, wantErr %v", err, tt.wantErr) + return + } + if tt.wantErr && err != nil && tt.expectedError != "" { + if !contains(err.Error(), tt.expectedError) { + t.Errorf("validateConfig() error = %v, expected to contain %v", err, tt.expectedError) + } + } + }) + } +} + +// TestLoadAllConfigs tests the loadAllConfigs function +func TestLoadAllConfigs(t *testing.T) { + // Create a temporary directory + tempDir, err := os.MkdirTemp("", "load_all_configs_test") + if err != nil { + t.Fatalf("Failed to create temp dir: %v", err) + } + defer func() { + if err := os.RemoveAll(tempDir); err != nil { + t.Errorf("Failed to remove temp directory: %v", err) + } + }() + + tests := []struct { + name string + setupFiles map[string]string // filename -> content + expectConfigs int + expectError bool + expectErrorMsg string + }{ + { + name: "Load All Valid Configs", + setupFiles: map[string]string{ + "valid_config.json": `{ + "id": "bot123", + "telegram_token": "token123", + "memory_size": 1024, + "messages_per_hour": 10, + "messages_per_day": 100, + "temp_ban_duration": "1h", + "model": "claude-v1", + "temperature": 0.7, + "system_prompts": {"welcome": "Hello!"}, + "active": true, + "owner_telegram_id": 123456789, + "anthropic_api_key": "api_key_123" + }`, + }, + expectConfigs: 1, + expectError: false, + }, + { + name: "Skip Inactive Config", + setupFiles: map[string]string{ + "valid_config.json": `{ + "id": "bot123", + "telegram_token": "token123", + "memory_size": 1024, + "messages_per_hour": 10, + "messages_per_day": 100, + "temp_ban_duration": "1h", + "model": "claude-v1", + "system_prompts": {"welcome": "Hello!"}, + "active": true, + "owner_telegram_id": 123456789, + "anthropic_api_key": "api_key_123" + }`, + "inactive_config.json": `{ + "id": "bot124", + "telegram_token": "token124", + "memory_size": 512, + "messages_per_hour": 5, + "messages_per_day": 50, + "temp_ban_duration": "30m", + "model": "claude-v2", + "temperature": 0.5, + "system_prompts": {"welcome": "Hi!"}, + "active": false, + "owner_telegram_id": 987654321, + "anthropic_api_key": "api_key_124" + }`, + }, + expectConfigs: 1, + expectError: false, + }, + { + name: "Duplicate Bot ID", + setupFiles: map[string]string{ + "valid_config.json": `{ + "id": "bot123", + "telegram_token": "token123", + "memory_size": 1024, + "messages_per_hour": 10, + "messages_per_day": 100, + "temp_ban_duration": "1h", + "model": "claude-v1", + "system_prompts": {"welcome": "Hello!"}, + "active": true, + "owner_telegram_id": 123456789, + "anthropic_api_key": "api_key_123" + }`, + "duplicate_id_config.json": `{ + "id": "bot123", + "telegram_token": "token125", + "memory_size": 256, + "messages_per_hour": 2, + "messages_per_day": 20, + "temp_ban_duration": "15m", + "model": "claude-v3", + "temperature": 0.3, + "system_prompts": {"welcome": "Hey!"}, + "active": true, + "owner_telegram_id": 1122334455, + "anthropic_api_key": "api_key_125" + }`, + }, + expectConfigs: 1, + expectError: false, + }, + { + name: "Duplicate Telegram Token", + setupFiles: map[string]string{ + "valid_config.json": `{ + "id": "bot123", + "telegram_token": "token123", + "memory_size": 1024, + "messages_per_hour": 10, + "messages_per_day": 100, + "temp_ban_duration": "1h", + "model": "claude-v1", + "system_prompts": {"welcome": "Hello!"}, + "active": true, + "owner_telegram_id": 123456789, + "anthropic_api_key": "api_key_123" + }`, + "duplicate_token_config.json": `{ + "id": "bot126", + "telegram_token": "token123", + "memory_size": 128, + "messages_per_hour": 1, + "messages_per_day": 10, + "temp_ban_duration": "5m", + "model": "claude-v4", + "temperature": 0.2, + "system_prompts": {"welcome": "Greetings!"}, + "active": true, + "owner_telegram_id": 5566778899, + "anthropic_api_key": "api_key_126" + }`, + }, + expectConfigs: 1, + expectError: false, + }, + { + name: "Invalid Config", + setupFiles: map[string]string{ + "valid_config.json": `{ + "id": "bot123", + "telegram_token": "token123", + "memory_size": 1024, + "messages_per_hour": 10, + "messages_per_day": 100, + "temp_ban_duration": "1h", + "model": "claude-v1", + "system_prompts": {"welcome": "Hello!"}, + "active": true, + "owner_telegram_id": 123456789, + "anthropic_api_key": "api_key_123" + }`, + "invalid_config.json": `{ + "id": "bot127", + "telegram_token": "token127", + "model": "", + "active": true + }`, + }, + expectConfigs: 1, + expectError: false, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + // Clear the tempDir before each test + if err := os.RemoveAll(tempDir); err != nil { + t.Fatalf("Failed to remove temp dir: %v", err) + } + if err := os.MkdirAll(tempDir, 0755); err != nil { + t.Fatalf("Failed to create temp dir: %v", err) + } + + // Write the test files directly + for filename, content := range tt.setupFiles { + err := os.WriteFile(filepath.Join(tempDir, filename), []byte(content), 0644) + if err != nil { + t.Fatalf("Failed to write file %s: %v", filename, err) + } + } + + configs, err := loadAllConfigs(tempDir) + if (err != nil) != tt.expectError { + t.Errorf("loadAllConfigs() error = %v, wantErr %v", err, tt.expectError) + return + } + if len(configs) != tt.expectConfigs { + t.Errorf("Expected %d configs, got %d", tt.expectConfigs, len(configs)) + } + }) + } +} + +// TestBotConfig_Reload tests the Reload method of BotConfig +func TestBotConfig_Reload(t *testing.T) { //NOSONAR go:S100 -- underscore separation is idiomatic in Go test names + // Create a temporary directory + tempDir, err := os.MkdirTemp("", "reload_test") + if err != nil { + t.Fatalf("Failed to create temp dir: %v", err) + } + defer func() { + if err := os.RemoveAll(tempDir); err != nil { + t.Errorf("Failed to remove temp directory: %v", err) + } + }() + + // Create initial config file + config1 := `{ + "id": "bot123", + "telegram_token": "token123", + "memory_size": 1024, + "messages_per_hour": 10, + "messages_per_day": 100, + "temp_ban_duration": "1h", + "model": "claude-v1", + "temperature": 0.7, + "system_prompts": {"welcome": "Hello!"}, + "active": true, + "owner_telegram_id": 123456789, + "anthropic_api_key": "api_key_123" + }` + configPath := filepath.Join(tempDir, "config.json") + if err := os.WriteFile(configPath, []byte(config1), 0644); err != nil { + t.Fatalf("Failed to write initial config: %v", err) + } + + // Initialize BotConfig + var config BotConfig + if err := config.Reload(tempDir, "config.json"); err != nil { + t.Fatalf("Failed to reload config: %v", err) + } + + // Verify initial load + if config.ID != "bot123" { + t.Errorf("Expected ID 'bot123', got '%s'", config.ID) + } + if config.Model != "claude-v1" { + t.Errorf("Expected Model 'claude-v1', got '%s'", config.Model) + } + + // Update config file + config2 := `{ + "id": "bot123", + "telegram_token": "token123_updated", + "memory_size": 2048, + "messages_per_hour": 20, + "messages_per_day": 200, + "temp_ban_duration": "2h", + "model": "claude-v2", + "temperature": 0.3, + "system_prompts": {"welcome": "Hi there!"}, + "active": true, + "owner_telegram_id": 987654321, + "anthropic_api_key": "api_key_456" + }` + if err := os.WriteFile(configPath, []byte(config2), 0644); err != nil { + t.Fatalf("Failed to write updated config: %v", err) + } + + // Reload config + if err := config.Reload(tempDir, "config.json"); err != nil { + t.Fatalf("Failed to reload updated config: %v", err) + } + + // Verify updated config + if config.TelegramToken != "token123_updated" { + t.Errorf("Expected TelegramToken 'token123_updated', got '%s'", config.TelegramToken) + } + if config.MemorySize != 2048 { + t.Errorf("Expected MemorySize 2048, got %d", config.MemorySize) + } + if config.Model != "claude-v2" { + t.Errorf("Expected Model 'claude-v2', got '%s'", config.Model) + } + if config.OwnerTelegramID != 987654321 { + t.Errorf("Expected OwnerTelegramID 987654321, got %d", config.OwnerTelegramID) + } +} + +// TestBotConfig_UnmarshalJSON_Invalid tests unmarshalling with invalid model +func TestBotConfig_UnmarshalJSON_Invalid(t *testing.T) { //NOSONAR go:S100 -- underscore separation is idiomatic in Go test names + jsonData := `{ + "id": "bot123", + "telegram_token": "token123", + "memory_size": 1024, + "messages_per_hour": 10, + "messages_per_day": 100, + "temp_ban_duration": "1h", + "model": "", + "temperature": 0.7, + "system_prompts": {"welcome": "Hello!"}, + "active": true, + "owner_telegram_id": 123456789, + "anthropic_api_key": "api_key_123" + }` + + var config BotConfig + err := json.Unmarshal([]byte(jsonData), &config) + if err != nil { + t.Fatalf("Failed to unmarshal JSON: %v", err) + } + + if config.Model != "" { + t.Errorf("Expected empty model, got %s", config.Model) + } +} + +// Helper function to check substring +func contains(s, substr string) bool { + return strings.Contains(s, substr) +} + +// TestTemperatureConfig tests that the temperature value is correctly loaded +func TestTemperatureConfig(t *testing.T) { + // Create a temporary directory + tempDir, err := os.MkdirTemp("", "temperature_test") + if err != nil { + t.Fatalf("Failed to create temp dir: %v", err) + } + defer func() { + if err := os.RemoveAll(tempDir); err != nil { + t.Errorf("Failed to remove temp directory: %v", err) + } + }() + + // Create config with temperature + configWithTemp := `{ + "id": "bot123", + "telegram_token": "token123", + "memory_size": 1024, + "messages_per_hour": 10, + "messages_per_day": 100, + "temp_ban_duration": "1h", + "model": "claude-v1", + "temperature": 0.42, + "system_prompts": {"welcome": "Hello!"}, + "active": true, + "owner_telegram_id": 123456789, + "anthropic_api_key": "api_key_123" + }` + + // Create config without temperature + configWithoutTemp := `{ + "id": "bot124", + "telegram_token": "token124", + "memory_size": 1024, + "messages_per_hour": 10, + "messages_per_day": 100, + "temp_ban_duration": "1h", + "model": "claude-v1", + "system_prompts": {"welcome": "Hello!"}, + "active": true, + "owner_telegram_id": 123456789, + "anthropic_api_key": "api_key_123" + }` + + // Write config files + withTempPath := filepath.Join(tempDir, "with_temp.json") + if err := os.WriteFile(withTempPath, []byte(configWithTemp), 0644); err != nil { + t.Fatalf("Failed to write config with temperature: %v", err) + } + + withoutTempPath := filepath.Join(tempDir, "without_temp.json") + if err := os.WriteFile(withoutTempPath, []byte(configWithoutTemp), 0644); err != nil { + t.Fatalf("Failed to write config without temperature: %v", err) + } + + // Test loading config with temperature + configWithTempObj, err := loadConfig(withTempPath) + if err != nil { + t.Fatalf("Failed to load config with temperature: %v", err) + } + + // Verify temperature is set correctly + if configWithTempObj.Temperature == nil { + t.Errorf("Expected Temperature to be set, got nil") + } else if *configWithTempObj.Temperature != 0.42 { + t.Errorf("Expected Temperature 0.42, got %f", *configWithTempObj.Temperature) + } + + // Test loading config without temperature + configWithoutTempObj, err := loadConfig(withoutTempPath) + if err != nil { + t.Fatalf("Failed to load config without temperature: %v", err) + } + + // Verify temperature is nil when not specified + if configWithoutTempObj.Temperature != nil { + t.Errorf("Expected Temperature to be nil, got %f", *configWithoutTempObj.Temperature) + } +} + +// Additional tests can be added here to cover more scenarios + +// TestBotConfig_PersistModel verifies that PersistModel updates the model both in memory +// and on disk while leaving all other config fields unchanged. +func TestBotConfig_PersistModel(t *testing.T) { //NOSONAR go:S100 -- underscore separation is idiomatic in Go test names + tempDir, err := os.MkdirTemp("", "persist_model_test") + if err != nil { + t.Fatalf("Failed to create temp dir: %v", err) + } + defer func() { + if err := os.RemoveAll(tempDir); err != nil { + t.Errorf("Failed to remove temp directory: %v", err) + } + }() + + initialJSON := `{ + "id": "bot1", + "telegram_token": "token1", + "model": "claude-v1", + "messages_per_hour": 10, + "messages_per_day": 100 + }` + configPath := filepath.Join(tempDir, "config.json") + if err := os.WriteFile(configPath, []byte(initialJSON), 0600); err != nil { + t.Fatalf("Failed to write config file: %v", err) + } + + config := BotConfig{ + ID: "bot1", + Model: "claude-v1", + ConfigFilePath: configPath, + } + + // Successful model update + if err := config.PersistModel("claude-sonnet-4-6"); err != nil { + t.Fatalf("PersistModel() unexpected error: %v", err) + } + + // In-memory model must be updated immediately + if string(config.Model) != "claude-sonnet-4-6" { + t.Errorf("in-memory model: got %q, want %q", config.Model, "claude-sonnet-4-6") + } + + // On-disk model must be updated; other fields must be preserved + data, err := os.ReadFile(configPath) + if err != nil { + t.Fatalf("Failed to read updated config file: %v", err) + } + var raw map[string]any + if err := json.Unmarshal(data, &raw); err != nil { + t.Fatalf("Failed to unmarshal updated config: %v", err) + } + if raw["model"] != "claude-sonnet-4-6" { + t.Errorf("on-disk model: got %v, want %q", raw["model"], "claude-sonnet-4-6") + } + if raw["id"] != "bot1" { + t.Errorf("on-disk id should be preserved: got %v, want %q", raw["id"], "bot1") + } + + // Error case: empty ConfigFilePath must return an error + noPath := BotConfig{Model: "claude-v1"} + if err := noPath.PersistModel("claude-sonnet-4-6"); err == nil { + t.Error("PersistModel with empty ConfigFilePath: expected error, got nil") + } +} diff --git a/database.go b/database.go new file mode 100644 index 0000000..01ed571 --- /dev/null +++ b/database.go @@ -0,0 +1,126 @@ +package main + +import ( + "fmt" + "log" + "os" + "time" + + "gorm.io/driver/sqlite" + "gorm.io/gorm" + "gorm.io/gorm/logger" +) + +func initDB() (*gorm.DB, error) { + if err := os.MkdirAll("data", 0750); err != nil { + return nil, fmt.Errorf("failed to create data directory: %w", err) + } + + newLogger := logger.New( + log.New(log.Writer(), "\r\n", log.LstdFlags), + logger.Config{ + SlowThreshold: time.Second, + LogLevel: logger.Info, + Colorful: false, + }, + ) + + db, err := gorm.Open(sqlite.Open("data/bot.db?_journal_mode=WAL&_busy_timeout=5000&_foreign_keys=on"), &gorm.Config{ + Logger: newLogger, + }) + if err != nil { + return nil, fmt.Errorf("failed to connect to database: %w", err) + } + + sqlDB, err := db.DB() + if err != nil { + return nil, fmt.Errorf("failed to get underlying sql.DB: %w", err) + } + sqlDB.SetMaxOpenConns(1) + + // AutoMigrate the models + err = db.AutoMigrate(&BotModel{}, &ConfigModel{}, &Message{}, &User{}, &Role{}, &Scope{}) + if err != nil { + return nil, fmt.Errorf("failed to migrate database schema: %w", err) + } + + // Enforce unique owner per bot using raw SQL + // Note: SQLite doesn't support partial indexes, but we can simulate it by making a unique index on (BotID, IsOwner) + // and ensuring that IsOwner can only be true for one user per BotID. + // This approach allows multiple users with IsOwner=false for the same BotID, + // but only one user can have IsOwner=true per BotID. + err = db.Exec(`CREATE UNIQUE INDEX IF NOT EXISTS idx_bot_owner ON users (bot_id, is_owner) WHERE is_owner = 1;`).Error + if err != nil { + return nil, fmt.Errorf("failed to create unique index for bot owners: %w", err) + } + + err = createDefaultRoles(db) + if err != nil { + return nil, err + } + + if err := createDefaultScopes(db); err != nil { + return nil, fmt.Errorf("createDefaultScopes: %w", err) + } + + return db, nil +} + +func createDefaultScopes(db *gorm.DB) error { + all := []string{ + ScopeStatsViewOwn, ScopeStatsViewAny, + ScopeHistoryClearOwn, ScopeHistoryClearAny, + ScopeHistoryClearHardOwn, ScopeHistoryClearHardAny, + ScopeModelSet, ScopeUserPromote, ScopeTTSUse, + } + for _, name := range all { + if err := db.FirstOrCreate(&Scope{}, Scope{Name: name}).Error; err != nil { + return fmt.Errorf("failed to create scope %s: %w", name, err) + } + } + + userScopes := []string{ + ScopeStatsViewOwn, + ScopeHistoryClearOwn, + ScopeHistoryClearHardOwn, + } + elevatedScopes := []string{ + ScopeStatsViewOwn, ScopeStatsViewAny, + ScopeHistoryClearOwn, ScopeHistoryClearAny, + ScopeHistoryClearHardOwn, ScopeHistoryClearHardAny, + ScopeModelSet, ScopeUserPromote, ScopeTTSUse, + } + assignments := map[string][]string{ + "user": userScopes, + "admin": elevatedScopes, + // owner gets the same scopes as admin; owner uniqueness is enforced by the IsOwner flag + "owner": elevatedScopes, + } + for roleName, scopes := range assignments { + var role Role + if err := db.Where("name = ?", roleName).First(&role).Error; err != nil { + return fmt.Errorf("role %s not found: %w", roleName, err) + } + var scopeModels []Scope + if err := db.Where("name IN ?", scopes).Find(&scopeModels).Error; err != nil { + return fmt.Errorf("failed to find scopes for %s: %w", roleName, err) + } + if err := db.Model(&role).Association("Scopes").Replace(scopeModels); err != nil { + return fmt.Errorf("failed to assign scopes to %s: %w", roleName, err) + } + } + return nil +} + +func createDefaultRoles(db *gorm.DB) error { + roles := []string{"user", "admin", "owner"} + for _, roleName := range roles { + var role Role + if err := db.FirstOrCreate(&role, Role{Name: roleName}).Error; err != nil { + ErrorLogger.Printf("Failed to create default role %s: %v", roleName, err) + return fmt.Errorf("failed to create default role %s: %w", roleName, err) + } + InfoLogger.Printf("Created or confirmed default role: %s", roleName) + } + return nil +} diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100644 index 0000000..9d0d689 --- /dev/null +++ b/docker-compose.yml @@ -0,0 +1,39 @@ +services: + telegram-bot: + image: bogerserge/go-telegram-bot:latest + build: + context: . + dockerfile: Dockerfile + platforms: + - linux/amd64 + - linux/arm64 + container_name: go-telegram-bot + restart: unless-stopped + + # Optional: Environment variables (can be overridden with .env file) + # environment: + # - BOT_LOG_LEVEL=info + + # Volume mounts + volumes: + # Bind mount config directory for live configuration updates + - ./config:/app/config:ro + # Named volume for persistent database storage + - ./data:/app/data + # Optional: Bind mount for log access (uncomment if needed) + # - ./logs:/app/logs + + # Health check + healthcheck: + test: ["CMD", "pgrep", "telegram-bot"] + interval: 30s + timeout: 10s + retries: 3 + start_period: 10s + + # Logging configuration + logging: + driver: "json-file" + options: + max-size: "10m" + max-file: "3" diff --git a/elevenlabs.go b/elevenlabs.go new file mode 100644 index 0000000..60a13d5 --- /dev/null +++ b/elevenlabs.go @@ -0,0 +1,115 @@ +package main + +import ( + "bytes" + "context" + "encoding/json" + "fmt" + "io" + "mime/multipart" + "net/http" + + tgbot "github.com/go-telegram/bot" +) + +const ( + elevenLabsTTSURL = "https://api.elevenlabs.io/v1/text-to-speech/" + elevenLabsSTTURL = "https://api.elevenlabs.io/v1/speech-to-text" + elevenLabsDefaultModel = "eleven_multilingual_v2" +) + +// generateSpeech converts text to an mp3 audio stream via ElevenLabs TTS. +func (b *Bot) generateSpeech(ctx context.Context, text string) (io.Reader, error) { + model := b.config.ElevenLabsModel + if model == "" { + model = elevenLabsDefaultModel + } + body, err := json.Marshal(map[string]string{ + "text": text, + "model_id": model, + }) + if err != nil { + return nil, fmt.Errorf("elevenlabs TTS marshal error: %w", err) + } + req, err := http.NewRequestWithContext(ctx, http.MethodPost, + elevenLabsTTSURL+b.config.ElevenLabsVoiceID, bytes.NewReader(body)) + if err != nil { + return nil, fmt.Errorf("elevenlabs TTS request error: %w", err) + } + req.Header.Set("Content-Type", "application/json") + req.Header.Set("xi-api-key", b.config.ElevenLabsAPIKey) + + resp, err := http.DefaultClient.Do(req) + if err != nil { + return nil, fmt.Errorf("elevenlabs TTS error: %w", err) + } + if resp.StatusCode != http.StatusOK { + defer resp.Body.Close() + errBody, _ := io.ReadAll(resp.Body) + return nil, fmt.Errorf("elevenlabs TTS error: status %d: %s", resp.StatusCode, errBody) + } + return resp.Body, nil +} + +// transcribeVoice downloads a Telegram voice file and transcribes it via ElevenLabs STT. +// Uses a direct multipart HTTP call instead of the SDK wrapper to avoid a bug in the +// ogen-generated encoder: AdditionalFormats (nil slice) is always written as an empty +// string with Content-Type: application/json, which ElevenLabs rejects with 400. +func (b *Bot) transcribeVoice(ctx context.Context, fileID string) (string, error) { + // 1. Resolve and download the voice file from Telegram. + fileInfo, err := b.tgBot.GetFile(ctx, &tgbot.GetFileParams{FileID: fileID}) + if err != nil { + return "", fmt.Errorf("telegram GetFile error: %w", err) + } + downloadURL := b.tgBot.FileDownloadLink(fileInfo) + audioResp, err := http.Get(downloadURL) //nolint:noctx + if err != nil { + return "", fmt.Errorf("voice download error: %w", err) + } + defer audioResp.Body.Close() + + // 2. Build multipart body with binary audio ā€” bypasses SDK encoding issues. + var buf bytes.Buffer + mw := multipart.NewWriter(&buf) + if err := mw.WriteField("model_id", "scribe_v1"); err != nil { + return "", fmt.Errorf("multipart write error: %w", err) + } + part, err := mw.CreateFormFile("file", "audio.ogg") + if err != nil { + return "", fmt.Errorf("multipart create file error: %w", err) + } + if _, err := io.Copy(part, audioResp.Body); err != nil { + return "", fmt.Errorf("multipart copy error: %w", err) + } + if err := mw.Close(); err != nil { + return "", fmt.Errorf("multipart close error: %w", err) + } + + // 3. POST to ElevenLabs STT. + req, err := http.NewRequestWithContext(ctx, http.MethodPost, + elevenLabsSTTURL, &buf) + if err != nil { + return "", fmt.Errorf("create STT request error: %w", err) + } + req.Header.Set("Content-Type", mw.FormDataContentType()) + req.Header.Set("xi-api-key", b.config.ElevenLabsAPIKey) + + sttResp, err := http.DefaultClient.Do(req) + if err != nil { + return "", fmt.Errorf("elevenlabs STT request error: %w", err) + } + defer sttResp.Body.Close() + + if sttResp.StatusCode != http.StatusOK { + body, _ := io.ReadAll(sttResp.Body) + return "", fmt.Errorf("elevenlabs STT error: status %d: %s", sttResp.StatusCode, body) + } + + var result struct { + Text string `json:"text"` + } + if err := json.NewDecoder(sttResp.Body).Decode(&result); err != nil { + return "", fmt.Errorf("elevenlabs STT decode error: %w", err) + } + return result.Text, nil +} diff --git a/examples/systemd/telegram-bot.service b/examples/systemd/telegram-bot.service new file mode 100644 index 0000000..fa27d2b --- /dev/null +++ b/examples/systemd/telegram-bot.service @@ -0,0 +1,35 @@ +[Unit] +# A concise description of the service +Description=Telegram Bot Service +# Postpone starting until network is available +After=network.target + +[Service] +# The user that runs the bot +User=tibik +# The directory where the bot is located +WorkingDirectory=/home/tibik/go-telegram-bot +# The command to start the bot +ExecStart=/home/tibik/go-telegram-bot/telegram-bot +# Restart if crashed +Restart=always +# Delay between restarts to avoid resource exhaustion +RestartSec=5 +# Capture stdout (INFO logs) +StandardOutput=journal +# Capture stderr (ERROR logs) +StandardError=journal +# Identifier for journalctl filtering +SyslogIdentifier=telegram-bot + +[Install] +# The bot will start automatically at system boot +WantedBy=multi-user.target + +# NOTE: +# New line comments: good +# Inline comments: no good, they mess up the service file + +# View logs: journalctl -u telegram-bot +# Follow logs: journalctl -u telegram-bot -f +# View errors: journalctl -u telegram-bot -p err \ No newline at end of file diff --git a/go-telegram-bot.exe b/go-telegram-bot.exe new file mode 100644 index 0000000..226706f Binary files /dev/null and b/go-telegram-bot.exe differ diff --git a/go.mod b/go.mod index 7ad491b..29cc523 100644 --- a/go.mod +++ b/go.mod @@ -1,18 +1,26 @@ -module github.com/HugeFrog24/thatsky-telegram-bot +module github.com/HugeFrog24/go-telegram-bot -go 1.23.2 +go 1.26.0 require ( - github.com/go-telegram/bot v1.8.4 - github.com/joho/godotenv v1.5.1 - github.com/liushuangls/go-anthropic/v2 v2.8.1 - gorm.io/driver/sqlite v1.5.6 - gorm.io/gorm v1.25.12 + github.com/go-telegram/bot v1.20.0 + github.com/liushuangls/go-anthropic/v2 v2.20.0 + github.com/stretchr/testify v1.11.1 + golang.org/x/time v0.15.0 + gorm.io/driver/sqlite v1.6.0 + gorm.io/gorm v1.31.1 ) require ( + github.com/davecgh/go-spew v1.1.1 // indirect github.com/jinzhu/inflection v1.0.0 // indirect github.com/jinzhu/now v1.1.5 // indirect - github.com/mattn/go-sqlite3 v1.14.22 // indirect - golang.org/x/text v0.14.0 // indirect + github.com/kr/pretty v0.3.1 // indirect + github.com/mattn/go-sqlite3 v1.14.44 // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect + github.com/rogpeppe/go-internal v1.14.1 // indirect + github.com/stretchr/objx v0.5.3 // indirect + golang.org/x/text v0.37.0 // indirect + gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/go.sum b/go.sum index b431973..50cedc3 100644 --- a/go.sum +++ b/go.sum @@ -1,18 +1,47 @@ -github.com/go-telegram/bot v1.8.4 h1:7viEUESakK29aiCumq6ui5jTPqJLLDeFubTsQzE07Kg= -github.com/go-telegram/bot v1.8.4/go.mod h1:i2TRs7fXWIeaceF3z7KzsMt/he0TwkVC680mvdTFYeM= +github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/go-telegram/bot v1.20.0 h1:4Pea/qTidSspr4WBJw9FbHUMNhYeqszBqQUfsQEyFbc= +github.com/go-telegram/bot v1.20.0/go.mod h1:i2TRs7fXWIeaceF3z7KzsMt/he0TwkVC680mvdTFYeM= github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E= github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc= github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ= github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8= -github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0= -github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4= -github.com/liushuangls/go-anthropic/v2 v2.8.1 h1:pxFl88IgkG7e8Z1XwOYu48LcmEN0+6UdO58HF9altw0= -github.com/liushuangls/go-anthropic/v2 v2.8.1/go.mod h1:8BKv/fkeTaL5R9R9bGkaknYBueyw2WxY20o7bImbOek= -github.com/mattn/go-sqlite3 v1.14.22 h1:2gZY6PC6kBnID23Tichd1K+Z0oS6nE/XwU+Vz/5o4kU= -github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y= -golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= -golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= -gorm.io/driver/sqlite v1.5.6 h1:fO/X46qn5NUEEOZtnjJRWRzZMe8nqJiQ9E+0hi+hKQE= -gorm.io/driver/sqlite v1.5.6/go.mod h1:U+J8craQU6Fzkcvu8oLeAQmi50TkwPEhHDEjQZXDah4= -gorm.io/gorm v1.25.12 h1:I0u8i2hWQItBq1WfE0o2+WuL9+8L21K9e2HHSTE/0f8= -gorm.io/gorm v1.25.12/go.mod h1:xh7N7RHfYlNc5EmcI/El95gXusucDrQnHXe0+CgWcLQ= +github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= +github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= +github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= +github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= +github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= +github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= +github.com/liushuangls/go-anthropic/v2 v2.19.0 h1:CpDSGzRUmlONfAQh8MrBiNupCDAyGpVoQIJkcAx77h8= +github.com/liushuangls/go-anthropic/v2 v2.19.0/go.mod h1:a550cJXPoTG2FL3DvfKG2zzD5O2vjgvo4tHtoGPzFLU= +github.com/liushuangls/go-anthropic/v2 v2.20.0 h1:acHi5rjirzMXr6YXgovwopzNfv92P8BTCDKrRk8dQ10= +github.com/liushuangls/go-anthropic/v2 v2.20.0/go.mod h1:a550cJXPoTG2FL3DvfKG2zzD5O2vjgvo4tHtoGPzFLU= +github.com/mattn/go-sqlite3 v1.14.44 h1:3VSe+xafpbzsLbdr2AWlAZk9yRHiBhTBakioXaCKTF8= +github.com/mattn/go-sqlite3 v1.14.44/go.mod h1:pjEuOr8IwzLJP2MfGeTb0A35jauH+C2kbHKBr7yXKVQ= +github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= +github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= +github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= +github.com/stretchr/objx v0.5.3 h1:jmXUvGomnU1o3W/V5h2VEradbpJDwGrzugQQvL0POH4= +github.com/stretchr/objx v0.5.3/go.mod h1:rDQraq+vQZU7Fde9LOZLr8Tax6zZvy4kuNKF+QYS+U0= +github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= +github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +golang.org/x/text v0.36.0 h1:JfKh3XmcRPqZPKevfXVpI1wXPTqbkE5f7JA92a55Yxg= +golang.org/x/text v0.36.0/go.mod h1:NIdBknypM8iqVmPiuco0Dh6P5Jcdk8lJL0CUebqK164= +golang.org/x/text v0.37.0 h1:Cqjiwd9eSg8e0QAkyCaQTNHFIIzWtidPahFWR83rTrc= +golang.org/x/text v0.37.0/go.mod h1:a5sjxXGs9hsn/AJVwuElvCAo9v8QYLzvavO5z2PiM38= +golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U= +golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= +gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gorm.io/driver/sqlite v1.6.0 h1:WHRRrIiulaPiPFmDcod6prc4l2VGVWHz80KspNsxSfQ= +gorm.io/driver/sqlite v1.6.0/go.mod h1:AO9V1qIQddBESngQUKWL9yoH93HIeA1X6V633rBwyT8= +gorm.io/gorm v1.31.1 h1:7CA8FTFz/gRfgqgpeKIBcervUn3xSyPUmr6B2WXJ7kg= +gorm.io/gorm v1.31.1/go.mod h1:XyQVbO2k6YkOis7C2437jSit3SsDK72s7n7rsSHd+Gs= diff --git a/handlers.go b/handlers.go new file mode 100644 index 0000000..1fd2dcc --- /dev/null +++ b/handlers.go @@ -0,0 +1,531 @@ +package main + +import ( + "context" + "errors" + "fmt" + "strconv" + "strings" + + "github.com/go-telegram/bot" + "github.com/go-telegram/bot/models" + "github.com/liushuangls/go-anthropic/v2" +) + +func (b *Bot) handleVoiceMessage(ctx context.Context, message *models.Message, userMsg Message, chatID, userID int64, username, firstName, lastName string, isPremium bool, languageCode string, messageTime int, isNewChat, isOwner bool, businessConnectionID string) { + // If ElevenLabs is not configured, respond with text ā€” consistent with all other error paths. + if b.config.ElevenLabsAPIKey == "" { + if err := b.sendResponse(ctx, chatID, "I don't understand voice messages.", businessConnectionID); err != nil { + ErrorLogger.Printf("Error sending voice-unsupported message: %v", err) + } + return + } + + if !b.hasScope(userID, ScopeTTSUse) { + if err := b.sendResponse(ctx, chatID, "You don't have permission to use voice features.", businessConnectionID); err != nil { + ErrorLogger.Printf("Error sending permission denied message: %v", err) + } + return + } + + transcript, err := b.transcribeVoice(ctx, message.Voice.FileID) + if err != nil { + ErrorLogger.Printf("Error transcribing voice message from user %d: %v", userID, err) + if err := b.sendResponse(ctx, chatID, "Sorry, I couldn't understand your voice message.", businessConnectionID); err != nil { + ErrorLogger.Printf("Error sending transcription error message: %v", err) + } + return + } + + // Replace the stored "[Voice message]" placeholder with the actual transcript, + // keeping the audit record intact while giving the LLM meaningful context. + if err := b.db.Model(&userMsg).Update("text", transcript).Error; err != nil { + ErrorLogger.Printf("Error updating voice transcript in DB: %v", err) + } + b.chatMemoriesMu.Lock() + if mem, exists := b.chatMemories[chatID]; exists { + for i := len(mem.Messages) - 1; i >= 0; i-- { + if mem.Messages[i].ID == userMsg.ID { + mem.Messages[i].Text = transcript + break + } + } + } + b.chatMemoriesMu.Unlock() + + chatMemory := b.getOrCreateChatMemory(chatID) + contextMessages := b.prepareContextMessages(chatMemory) + response, err := b.getAnthropicResponse(ctx, contextMessages, isNewChat, isOwner, false, username, firstName, lastName, isPremium, languageCode, messageTime) + if err != nil { + ErrorLogger.Printf("Error getting Anthropic response for voice: %v", err) + if err := b.sendResponse(ctx, chatID, b.anthropicErrorResponse(err, userID), businessConnectionID); err != nil { + ErrorLogger.Printf("Error sending anthropic error response: %v", err) + } + return + } + + audioReader, err := b.generateSpeech(ctx, response) + if err != nil { + // TTS failed ā€” fall back to text so the user still gets a reply. + ErrorLogger.Printf("Error generating speech, falling back to text: %v", err) + if err := b.sendResponse(ctx, chatID, response, businessConnectionID); err != nil { + ErrorLogger.Printf("Error sending text fallback: %v", err) + } + return + } + + // Store the assistant response before sending. + if _, err := b.screenOutgoingMessage(chatID, response); err != nil { + ErrorLogger.Printf("Error storing assistant voice response: %v", err) + } + + params := &bot.SendAudioParams{ + ChatID: chatID, + Audio: &models.InputFileUpload{Filename: "response.mp3", Data: audioReader}, + } + if businessConnectionID != "" { + params.BusinessConnectionID = businessConnectionID + } + if _, err := b.tgBot.SendAudio(ctx, params); err != nil { + ErrorLogger.Printf("Error sending audio to chat %d: %v", chatID, err) + } +} + +// anthropicErrorResponse returns the message to send back to the user when getAnthropicResponse +// fails. Admins and owners receive an actionable hint when the model is deprecated; regular users +// always get the generic fallback to avoid leaking internal details. +func (b *Bot) anthropicErrorResponse(err error, userID int64) string { + if errors.Is(err, ErrModelNotFound) && b.hasScope(userID, ScopeModelSet) { + return fmt.Sprintf( + "āš ļø Model `%s` is no longer available (deprecated or removed by Anthropic).\n"+ + "Use /set_model to switch. Current models: https://platform.claude.com/docs/en/about-claude/models/overview", + b.config.Model, + ) + } + return "I'm sorry, I'm having trouble processing your request right now." +} + +func (b *Bot) handleUpdate(ctx context.Context, tgBot *bot.Bot, update *models.Update) { + var message *models.Message + + if update.Message != nil { + message = update.Message + } else if update.BusinessMessage != nil { + message = update.BusinessMessage + } else { + // No message to process + return + } + + // Extract businessConnectionID if available + var businessConnectionID string + if update.BusinessConnection != nil { + businessConnectionID = update.BusinessConnection.ID + } else if message.BusinessConnectionID != "" { + businessConnectionID = message.BusinessConnectionID + } + + if message.From == nil { + // Channel posts and some automated messages have no sender ā€” ignore them. + // see: https://core.telegram.org/bots/api#message + return + } + + chatID := message.Chat.ID + userID := message.From.ID + username := message.From.Username + firstName := message.From.FirstName + lastName := message.From.LastName + languageCode := message.From.LanguageCode + isPremium := message.From.IsPremium + messageTime := message.Date + text := message.Text + + // Check if it's a new chat (before storing the message so the flag is accurate). + isNewChatFlag := b.isNewChat(chatID) + + // Screen incoming message (store to DB + add to chat memory) + userMsg, err := b.screenIncomingMessage(message) + if err != nil { + ErrorLogger.Printf("Error storing user message: %v", err) + return + } + + // Determine if the user is the owner + var isOwner bool + if b.db.Where("telegram_id = ? AND bot_id = ? AND is_owner = ?", userID, b.botID, true).First(&User{}).Error == nil { + isOwner = true + } + + // Always create/get the user record ā€” on the very first message and on all subsequent ones. + user, err := b.getOrCreateUser(userID, username, isOwner) + if err != nil { + ErrorLogger.Printf("Error getting or creating user: %v", err) + return + } + + // Update the username if it has changed + if user.Username != username { + user.Username = username + if err := b.db.Save(&user).Error; err != nil { + ErrorLogger.Printf("Error updating user username: %v", err) + } + } + + // Check if the message is a command ā€” applies on every message, including the very first. + if message.Entities != nil { + for _, entity := range message.Entities { + if entity.Type == "bot_command" { + command := strings.TrimSpace(message.Text[entity.Offset : entity.Offset+entity.Length]) + switch command { + case "/stats": + // Parse command parameters + parts := strings.Fields(message.Text) + + // Default: show global stats + if len(parts) == 1 { + b.sendStats(ctx, chatID, userID, 0, businessConnectionID) + return + } + + // Check for "user" parameter + if len(parts) >= 2 && parts[1] == "user" { + targetUserID := userID // Default to current user + + // If a user ID is provided, parse it + if len(parts) >= 3 { + var parseErr error + targetUserID, parseErr = strconv.ParseInt(parts[2], 10, 64) + if parseErr != nil { + InfoLogger.Printf("User %d provided invalid user ID format: %s", userID, parts[2]) + if err := b.sendResponse(ctx, chatID, "Invalid user ID format. Usage: /stats user [user_id]", businessConnectionID); err != nil { + ErrorLogger.Printf("Error sending response: %v", err) + } + return + } + } + + b.sendStats(ctx, chatID, userID, targetUserID, businessConnectionID) + return + } + + // Invalid parameter + if err := b.sendResponse(ctx, chatID, "Invalid command format. Usage: /stats or /stats user [user_id]", businessConnectionID); err != nil { + ErrorLogger.Printf("Error sending response: %v", err) + } + return + case "/whoami": + b.sendWhoAmI(ctx, chatID, userID, username, businessConnectionID) + return + case "/clear": + parts := strings.Fields(message.Text) + var targetUserID, targetChatID int64 + if len(parts) > 1 { + var parseErr error + targetUserID, parseErr = strconv.ParseInt(parts[1], 10, 64) + if parseErr != nil { + InfoLogger.Printf("User %d provided invalid user ID format: %s", userID, parts[1]) + if err := b.sendResponse(ctx, chatID, "Invalid user ID format. Usage: /clear [user_id] [chat_id]", businessConnectionID); err != nil { + ErrorLogger.Printf("Error sending response: %v", err) + } + return + } + } + if len(parts) > 2 { + var parseErr error + targetChatID, parseErr = strconv.ParseInt(parts[2], 10, 64) + if parseErr != nil { + InfoLogger.Printf("User %d provided invalid chat ID format: %s", userID, parts[2]) + if err := b.sendResponse(ctx, chatID, "Invalid chat ID format. Usage: /clear [user_id] [chat_id]", businessConnectionID); err != nil { + ErrorLogger.Printf("Error sending response: %v", err) + } + return + } + } + b.clearChatHistory(ctx, chatID, userID, targetUserID, targetChatID, businessConnectionID, false) + return + case "/set_model": + if !b.hasScope(userID, ScopeModelSet) { + if err := b.sendResponse(ctx, chatID, "Permission denied. Only admins and owners can change the model.", businessConnectionID); err != nil { + ErrorLogger.Printf("Error sending response: %v", err) + } + return + } + parts := strings.Fields(message.Text) + if len(parts) < 2 || strings.TrimSpace(parts[1]) == "" { + if err := b.sendResponse(ctx, chatID, "Usage: /set_model ", businessConnectionID); err != nil { + ErrorLogger.Printf("Error sending response: %v", err) + } + return + } + newModel := strings.TrimSpace(parts[1]) + // No upfront model validation: + // - The go-anthropic library constants are not enumerable at runtime (Go has no const reflection). + // - A live /v1/models probe would add a network round-trip and show in the API audit log. + // - An invalid model ID will produce a 404 on the next real message, which routes through + // anthropicErrorResponse and already delivers an actionable admin-facing hint. + if err := b.config.PersistModel(newModel); err != nil { + ErrorLogger.Printf("Failed to persist model change: %v", err) + if err := b.sendResponse(ctx, chatID, fmt.Sprintf("Model updated in memory to `%s`, but failed to save to config file: %v", newModel, err), businessConnectionID); err != nil { + ErrorLogger.Printf("Error sending response: %v", err) + } + return + } + InfoLogger.Printf("Model changed to %s by user %d", newModel, userID) + if err := b.sendResponse(ctx, chatID, fmt.Sprintf("āœ… Model updated to `%s` and saved to config.", newModel), businessConnectionID); err != nil { + ErrorLogger.Printf("Error sending response: %v", err) + } + return + case "/clear_hard": + parts := strings.Fields(message.Text) + var targetUserID, targetChatID int64 + if len(parts) > 1 { + var parseErr error + targetUserID, parseErr = strconv.ParseInt(parts[1], 10, 64) + if parseErr != nil { + InfoLogger.Printf("User %d provided invalid user ID format: %s", userID, parts[1]) + if err := b.sendResponse(ctx, chatID, "Invalid user ID format. Usage: /clear_hard [user_id] [chat_id]", businessConnectionID); err != nil { + ErrorLogger.Printf("Error sending response: %v", err) + } + return + } + } + if len(parts) > 2 { + var parseErr error + targetChatID, parseErr = strconv.ParseInt(parts[2], 10, 64) + if parseErr != nil { + InfoLogger.Printf("User %d provided invalid chat ID format: %s", userID, parts[2]) + if err := b.sendResponse(ctx, chatID, "Invalid chat ID format. Usage: /clear_hard [user_id] [chat_id]", businessConnectionID); err != nil { + ErrorLogger.Printf("Error sending response: %v", err) + } + return + } + } + b.clearChatHistory(ctx, chatID, userID, targetUserID, targetChatID, businessConnectionID, true) + return + } + } + } + } + + // Rate limit check applies to all message types including stickers. + if !b.checkRateLimits(userID) { + b.sendRateLimitExceededMessage(ctx, chatID, businessConnectionID) + return + } + + // Check if the message contains a voice note (context is built inside the handler + // after the transcript replaces the placeholder, so it must not be built here). + if message.Voice != nil { + b.handleVoiceMessage(ctx, message, userMsg, chatID, userID, username, firstName, lastName, isPremium, languageCode, messageTime, isNewChatFlag, isOwner, businessConnectionID) + return + } + + // Build context once ā€” shared by the sticker and text response paths. + chatMemory := b.getOrCreateChatMemory(chatID) + contextMessages := b.prepareContextMessages(chatMemory) + + // Check if the message contains a sticker + if message.Sticker != nil { + b.handleStickerMessage(ctx, chatID, userMsg, message, contextMessages, businessConnectionID) + return + } + + // Proceed only if the message contains text + if text == "" { + InfoLogger.Printf("Received a non-text message from user %d in chat %d", userID, chatID) + return + } + + // Determine if the text contains only emojis + isEmojiOnly := isOnlyEmojis(text) + + // Get response from Anthropic + response, err := b.getAnthropicResponse(ctx, contextMessages, isNewChatFlag, isOwner, isEmojiOnly, username, firstName, lastName, isPremium, languageCode, messageTime) + if err != nil { + ErrorLogger.Printf("Error getting Anthropic response: %v", err) + response = b.anthropicErrorResponse(err, userID) + } + + // Send the response + if err := b.sendResponse(ctx, chatID, response, businessConnectionID); err != nil { + ErrorLogger.Printf("Error sending response: %v", err) + return + } +} + +func (b *Bot) sendRateLimitExceededMessage(ctx context.Context, chatID int64, businessConnectionID string) { + if err := b.sendResponse(ctx, chatID, "Rate limit exceeded. Please try again later.", businessConnectionID); err != nil { + ErrorLogger.Printf("Error sending rate limit exceeded message: %v", err) + } +} + +func (b *Bot) handleStickerMessage(ctx context.Context, chatID int64, userMessage Message, message *models.Message, contextMessages []anthropic.Message, businessConnectionID string) { + // userMessage was already screened (stored + added to memory) by handleUpdate ā€” do not call screenIncomingMessage again. + + // Generate AI response about the sticker + response, err := b.generateStickerResponse(ctx, userMessage, contextMessages) + if err != nil { + ErrorLogger.Printf("Error generating sticker response: %v", err) + // Provide a fallback dynamic response based on sticker type + if message.Sticker.IsAnimated { + response = "Wow, that's a cool animated sticker!" + } else if message.Sticker.IsVideo { + response = "Interesting video sticker!" + } else { + response = "That's a cool sticker!" + } + } + + // Send the response + if err := b.sendResponse(ctx, chatID, response, businessConnectionID); err != nil { + ErrorLogger.Printf("Error sending response: %v", err) + return + } +} + +func (b *Bot) generateStickerResponse(ctx context.Context, message Message, contextMessages []anthropic.Message) (string, error) { + // contextMessages already contains the sticker turn (added by screenIncomingMessage as + // "Sent a sticker: "), so the full conversation history is preserved. + if message.StickerFileID != "" { + messageTime := int(message.Timestamp.Unix()) + response, err := b.getAnthropicResponse(ctx, contextMessages, false, false, true, message.Username, "", "", false, "", messageTime) + if err != nil { + return "", err + } + return response, nil + } + + return "Hmm, that's interesting!", nil +} + +func (b *Bot) clearChatHistory(ctx context.Context, chatID int64, currentUserID int64, targetUserID int64, targetChatID int64, businessConnectionID string, hardDelete bool) { + // If targetUserID is provided and different from currentUserID, check permissions + if targetUserID != 0 && targetUserID != currentUserID { + requiredScope := ScopeHistoryClearAny + if hardDelete { + requiredScope = ScopeHistoryClearHardAny + } + if !b.hasScope(currentUserID, requiredScope) { + InfoLogger.Printf("User %d attempted to clear history for user %d without permission", currentUserID, targetUserID) + if err := b.sendResponse(ctx, chatID, "Permission denied. Only admins and owners can clear other users' histories.", businessConnectionID); err != nil { + ErrorLogger.Printf("Error sending response: %v", err) + } + return + } + + // Check if the target user exists + var targetUser User + err := b.db.Where("telegram_id = ? AND bot_id = ?", targetUserID, b.botID).First(&targetUser).Error + if err != nil { + ErrorLogger.Printf("Error finding target user %d: %v", targetUserID, err) + if err := b.sendResponse(ctx, chatID, fmt.Sprintf("User with ID %d not found.", targetUserID), businessConnectionID); err != nil { + ErrorLogger.Printf("Error sending response: %v", err) + } + return + } + } else { + // If no targetUserID is provided, set it to currentUserID + targetUserID = currentUserID + } + + // Delete messages from the database + // + // Assumption: this bot is primarily used in private DMs, where each user's messages + // are stored with chat_id == their own user_id ā€” not the caller's chat_id. Scoping + // a cross-user delete by the caller's chatID would therefore match 0 rows. + // + // When clearing another user's history the default (targetChatID == 0) deletes all + // of that user's messages across every chat for this bot ā€” the natural meaning of + // "/clear " (wipe their entire history with the bot). + // + // When targetChatID != 0 the deletion is scoped to that specific chat, which is + // useful for group moderation ("/clear "). + var err error + if hardDelete { + // Permanently delete messages + if targetUserID == currentUserID { + // Own history ā€” delete ALL messages (user + assistant) in the current chat. + err = b.db.Unscoped().Where("chat_id = ? AND bot_id = ?", chatID, b.botID).Delete(&Message{}).Error + InfoLogger.Printf("User %d permanently deleted their own chat history in chat %d", currentUserID, chatID) + } else { + if targetChatID != 0 { + // Chat-scoped: delete ALL messages (user + assistant) in the specified chat. + err = b.db.Unscoped().Where("chat_id = ? AND bot_id = ?", targetChatID, b.botID).Delete(&Message{}).Error + InfoLogger.Printf("Admin/owner %d permanently deleted chat history for user %d in chat %d", currentUserID, targetUserID, targetChatID) + } else { + // Bot-wide: delete all of the user's own messages across every chat, then delete + // assistant messages from their DM chat (where chat_id == user_id by Telegram convention). + err = b.db.Unscoped().Where("bot_id = ? AND user_id = ?", b.botID, targetUserID).Delete(&Message{}).Error + if err == nil { + err = b.db.Unscoped().Where("chat_id = ? AND bot_id = ? AND is_user = ?", targetUserID, b.botID, false).Delete(&Message{}).Error + } + InfoLogger.Printf("Admin/owner %d permanently deleted all chat history for user %d", currentUserID, targetUserID) + } + } + } else { + // Soft delete messages + if targetUserID == currentUserID { + // Own history ā€” delete ALL messages (user + assistant) in the current chat. + err = b.db.Where("chat_id = ? AND bot_id = ?", chatID, b.botID).Delete(&Message{}).Error + InfoLogger.Printf("User %d soft deleted their own chat history in chat %d", currentUserID, chatID) + } else { + if targetChatID != 0 { + // Chat-scoped: delete ALL messages (user + assistant) in the specified chat. + err = b.db.Where("chat_id = ? AND bot_id = ?", targetChatID, b.botID).Delete(&Message{}).Error + InfoLogger.Printf("Admin/owner %d soft deleted chat history for user %d in chat %d", currentUserID, targetUserID, targetChatID) + } else { + // Bot-wide: delete all of the user's own messages across every chat, then delete + // assistant messages from their DM chat (where chat_id == user_id by Telegram convention). + err = b.db.Where("bot_id = ? AND user_id = ?", b.botID, targetUserID).Delete(&Message{}).Error + if err == nil { + err = b.db.Where("chat_id = ? AND bot_id = ? AND is_user = ?", targetUserID, b.botID, false).Delete(&Message{}).Error + } + InfoLogger.Printf("Admin/owner %d soft deleted all chat history for user %d", currentUserID, targetUserID) + } + } + } + + if err != nil { + ErrorLogger.Printf("Error clearing chat history: %v", err) + if err := b.sendResponse(ctx, chatID, "Sorry, I couldn't clear the chat history.", businessConnectionID); err != nil { + ErrorLogger.Printf("Error sending response: %v", err) + } + return + } + + // Evict the relevant in-memory cache entry so the next access rebuilds from + // the now-clean DB. Applies to all cases: own history, cross-user + // scoped to a specific chat, and bot-wide cross-user clear. + b.chatMemoriesMu.Lock() + if targetUserID == currentUserID { + // Own history is always scoped to the current chat. + delete(b.chatMemories, chatID) + } else if targetChatID != 0 { + // Admin cleared a specific chat ā€” evict that chat's cache. + delete(b.chatMemories, targetChatID) + } else { + // Bot-wide clear: primary use-case is DMs where chatID == userID. + delete(b.chatMemories, targetUserID) + } + b.chatMemoriesMu.Unlock() + + // Send a confirmation message + var confirmationMessage string + if targetUserID == currentUserID { + confirmationMessage = "Your chat history has been cleared." + } else { + // Get the username of the target user if available + var targetUser User + err := b.db.Where("telegram_id = ? AND bot_id = ?", targetUserID, b.botID).First(&targetUser).Error + if err == nil && targetUser.Username != "" { + confirmationMessage = fmt.Sprintf("Chat history for user @%s (ID: %d) has been cleared.", targetUser.Username, targetUserID) + } else { + confirmationMessage = fmt.Sprintf("Chat history for user with ID %d has been cleared.", targetUserID) + } + } + + if err := b.sendResponse(ctx, chatID, confirmationMessage, businessConnectionID); err != nil { + ErrorLogger.Printf("Error sending response: %v", err) + } +} diff --git a/handlers_test.go b/handlers_test.go new file mode 100644 index 0000000..ec17eb9 --- /dev/null +++ b/handlers_test.go @@ -0,0 +1,891 @@ +package main + +import ( + "context" + "errors" + "fmt" + "os" + "path/filepath" + "testing" + "time" + + "github.com/go-telegram/bot" + "github.com/go-telegram/bot/models" + "github.com/stretchr/testify/assert" + "gorm.io/driver/sqlite" + "gorm.io/gorm" +) + +func TestHandleUpdate_NewChat(t *testing.T) { + // Setup + db := setupTestDB(t) + mockClock := &MockClock{ + currentTime: time.Now(), + } + + config := BotConfig{ + ID: "test_bot", + OwnerTelegramID: 123, // owner's ID + TelegramToken: "test_token", + MemorySize: 10, + MessagePerHour: 5, + MessagePerDay: 10, + TempBanDuration: "1h", + SystemPrompts: make(map[string]string), + Active: true, + } + + mockTgClient := &MockTelegramClient{} + + // Create bot model first + botModel := &BotModel{ + Identifier: config.ID, + Name: config.ID, + } + err := db.Create(botModel).Error + assert.NoError(t, err) + + // Create bot config + configModel := &ConfigModel{ + BotID: botModel.ID, + MemorySize: config.MemorySize, + MessagePerHour: config.MessagePerHour, + MessagePerDay: config.MessagePerDay, + TempBanDuration: config.TempBanDuration, + SystemPrompts: "{}", + TelegramToken: config.TelegramToken, + Active: config.Active, + } + err = db.Create(configModel).Error + assert.NoError(t, err) + + // Create bot instance + b, err := NewBot(db, config, mockClock, mockTgClient) + assert.NoError(t, err) + + testCases := []struct { + name string + userID int64 + isOwner bool + wantResp string + }{ + { + name: "Owner First Message", + userID: 123, // owner's ID + isOwner: true, + wantResp: "I'm sorry, I'm having trouble processing your request right now.", + }, + { + name: "Regular User First Message", + userID: 456, + isOwner: false, + wantResp: "I'm sorry, I'm having trouble processing your request right now.", + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + // Setup mock response expectations for error case to test fallback messages + mockTgClient.SendMessageFunc = func(ctx context.Context, params *bot.SendMessageParams) (*models.Message, error) { + assert.Equal(t, tc.userID, params.ChatID) + assert.Equal(t, tc.wantResp, params.Text) + return &models.Message{}, nil + } + + // Create update with new message + update := &models.Update{ + Message: &models.Message{ + Chat: models.Chat{ID: tc.userID}, + From: &models.User{ + ID: tc.userID, + Username: "testuser", + }, + Text: "Hello", + }, + } + + // Handle the update + b.handleUpdate(context.Background(), nil, update) + + // Verify message was stored + var storedMsg Message + err := db.Where("chat_id = ? AND user_id = ? AND text = ?", tc.userID, tc.userID, "Hello").First(&storedMsg).Error + assert.NoError(t, err) + + // Verify response was stored + var respMsg Message + err = db.Where("chat_id = ? AND is_user = ? AND text = ?", tc.userID, false, tc.wantResp).First(&respMsg).Error + assert.NoError(t, err) + }) + } +} + +func TestClearChatHistory(t *testing.T) { + // Setup + db := setupTestDB(t) + mockClock := &MockClock{ + currentTime: time.Now(), + } + + config := BotConfig{ + ID: "test_bot", + OwnerTelegramID: 123, // owner's ID + TelegramToken: "test_token", + MemorySize: 10, + MessagePerHour: 5, + MessagePerDay: 10, + TempBanDuration: "1h", + SystemPrompts: make(map[string]string), + Active: true, + } + + mockTgClient := &MockTelegramClient{} + + // Create bot model first + botModel := &BotModel{ + Identifier: config.ID, + Name: config.ID, + } + err := db.Create(botModel).Error + assert.NoError(t, err) + + // Create bot config + configModel := &ConfigModel{ + BotID: botModel.ID, + MemorySize: config.MemorySize, + MessagePerHour: config.MessagePerHour, + MessagePerDay: config.MessagePerDay, + TempBanDuration: config.TempBanDuration, + SystemPrompts: "{}", + TelegramToken: config.TelegramToken, + Active: config.Active, + } + err = db.Create(configModel).Error + assert.NoError(t, err) + + // Create bot instance + b, err := NewBot(db, config, mockClock, mockTgClient) + assert.NoError(t, err) + + // Create test users + ownerID := int64(123) + adminID := int64(456) + regularUserID := int64(789) + nonExistentUserID := int64(999) + chatID := int64(1000) + + // Create admin role + adminRole, err := b.getRoleByName("admin") + assert.NoError(t, err) + + // Create admin user + adminUser := User{ + BotID: b.botID, + TelegramID: adminID, + Username: "admin", + RoleID: adminRole.ID, + Role: adminRole, + IsOwner: false, + } + err = db.Create(&adminUser).Error + assert.NoError(t, err) + + // Create regular user + regularRole, err := b.getRoleByName("user") + assert.NoError(t, err) + regularUser := User{ + BotID: b.botID, + TelegramID: regularUserID, + Username: "regular", + RoleID: regularRole.ID, + Role: regularRole, + IsOwner: false, + } + err = db.Create(®ularUser).Error + assert.NoError(t, err) + + // Create test messages for each user. + // Each user's messages are stored with chat_id == their own user_id, mirroring + // how Telegram private DMs work (chat_id == user_id in 1-on-1 bot conversations). + // Using a shared artificial chatID here would mask the cross-user delete bug. + for _, userID := range []int64{ownerID, adminID, regularUserID} { + for i := 0; i < 5; i++ { + message := Message{ + BotID: b.botID, + ChatID: userID, // per-user chat, not a shared chatID + UserID: userID, + Username: "test", + UserRole: "user", + Text: "Test message", + Timestamp: time.Now(), + IsUser: true, + } + err = db.Create(&message).Error + assert.NoError(t, err) + } + } + + // Test cases + testCases := []struct { + name string + currentUserID int64 + targetUserID int64 + hardDelete bool + expectedError bool + expectedCount int64 + expectedMsg string + targetChatID int64 + businessConnID string + }{ + { + name: "Owner clears own history", + currentUserID: ownerID, + targetUserID: ownerID, + hardDelete: false, + expectedError: false, + expectedCount: 0, + expectedMsg: "Your chat history has been cleared.", + }, + { + name: "Admin clears own history", + currentUserID: adminID, + targetUserID: adminID, + hardDelete: false, + expectedError: false, + expectedCount: 0, + expectedMsg: "Your chat history has been cleared.", + }, + { + name: "Regular user clears own history", + currentUserID: regularUserID, + targetUserID: regularUserID, + hardDelete: false, + expectedError: false, + expectedCount: 0, + expectedMsg: "Your chat history has been cleared.", + }, + { + name: "Owner clears admin's history", + currentUserID: ownerID, + targetUserID: adminID, + hardDelete: false, + expectedError: false, + expectedCount: 0, + expectedMsg: "Chat history for user @admin (ID: 456) has been cleared.", + }, + { + name: "Admin clears regular user's history", + currentUserID: adminID, + targetUserID: regularUserID, + hardDelete: false, + expectedError: false, + expectedCount: 0, + expectedMsg: "Chat history for user @regular (ID: 789) has been cleared.", + }, + { + name: "Regular user attempts to clear admin's history", + currentUserID: regularUserID, + targetUserID: adminID, + hardDelete: false, + expectedError: true, + expectedCount: 5, // Messages should remain + expectedMsg: "Permission denied. Only admins and owners can clear other users' histories.", + }, + { + name: "Admin attempts to clear non-existent user's history", + currentUserID: adminID, + targetUserID: nonExistentUserID, + hardDelete: false, + expectedError: true, + expectedCount: 5, // Messages should remain for admin + expectedMsg: "User with ID 999 not found.", + }, + { + name: "Owner hard deletes regular user's history", + currentUserID: ownerID, + targetUserID: regularUserID, + hardDelete: true, + expectedError: false, + expectedCount: 0, + expectedMsg: "Chat history for user @regular (ID: 789) has been cleared.", + }, + { + // targetChatID scopes the delete to a specific chat; messages in other chats survive. + // We seed messages with ChatID == userID (per-user DM), so targeting a different chatID + // should leave the user's messages untouched (expectedCount == 5). + name: "Admin clears regular user's history scoped to non-matching chat", + currentUserID: adminID, + targetUserID: regularUserID, + targetChatID: int64(9999), // a chat the user has no messages in + hardDelete: false, + expectedError: false, + expectedCount: 5, // messages in chat 789 are unaffected + expectedMsg: "Chat history for user @regular (ID: 789) has been cleared.", + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + // Reset messages for the test case + if tc.name != "Owner hard deletes regular user's history" { + // Delete all messages for the target user + err = db.Where("user_id = ?", tc.targetUserID).Delete(&Message{}).Error + assert.NoError(t, err) + + // Recreate messages for the target user + for i := 0; i < 5; i++ { + message := Message{ + BotID: b.botID, + ChatID: chatID, + UserID: tc.targetUserID, + Username: "test", + UserRole: "user", + Text: "Test message", + Timestamp: time.Now(), + IsUser: true, + } + err = db.Create(&message).Error + assert.NoError(t, err) + } + } + + // Setup mock response expectations + var sentMessage string + mockTgClient.SendMessageFunc = func(ctx context.Context, params *bot.SendMessageParams) (*models.Message, error) { + sentMessage = params.Text + return &models.Message{}, nil + } + + // Call the clearChatHistory method + b.clearChatHistory(context.Background(), chatID, tc.currentUserID, tc.targetUserID, tc.targetChatID, tc.businessConnID, tc.hardDelete) + + // Verify the response message + assert.Equal(t, tc.expectedMsg, sentMessage) + + // Count remaining messages for the target user + var count int64 + if tc.hardDelete { + db.Unscoped().Model(&Message{}).Where("user_id = ? AND chat_id = ?", tc.targetUserID, chatID).Count(&count) + } else { + db.Model(&Message{}).Where("user_id = ? AND chat_id = ?", tc.targetUserID, chatID).Count(&count) + } + assert.Equal(t, tc.expectedCount, count) + }) + } +} + +func TestStatsCommand(t *testing.T) { + // Setup + db := setupTestDB(t) + mockClock := &MockClock{ + currentTime: time.Now(), + } + + config := BotConfig{ + ID: "test_bot", + OwnerTelegramID: 123, // owner's ID + TelegramToken: "test_token", + MemorySize: 10, + MessagePerHour: 5, + MessagePerDay: 10, + TempBanDuration: "1h", + SystemPrompts: make(map[string]string), + Active: true, + } + + mockTgClient := &MockTelegramClient{} + + // Create bot model first + botModel := &BotModel{ + Identifier: config.ID, + Name: config.ID, + } + err := db.Create(botModel).Error + assert.NoError(t, err) + + // Create bot config + configModel := &ConfigModel{ + BotID: botModel.ID, + MemorySize: config.MemorySize, + MessagePerHour: config.MessagePerHour, + MessagePerDay: config.MessagePerDay, + TempBanDuration: config.TempBanDuration, + SystemPrompts: "{}", + TelegramToken: config.TelegramToken, + Active: config.Active, + } + err = db.Create(configModel).Error + assert.NoError(t, err) + + // Create bot instance + b, err := NewBot(db, config, mockClock, mockTgClient) + assert.NoError(t, err) + + // Create test users + ownerID := int64(123) + adminID := int64(456) + regularUserID := int64(789) + chatID := int64(1000) + + // Create admin role + adminRole, err := b.getRoleByName("admin") + assert.NoError(t, err) + + // Create admin user + adminUser := User{ + BotID: b.botID, + TelegramID: adminID, + Username: "admin", + RoleID: adminRole.ID, + Role: adminRole, + IsOwner: false, + } + err = db.Create(&adminUser).Error + assert.NoError(t, err) + + // Create regular user + regularRole, err := b.getRoleByName("user") + assert.NoError(t, err) + regularUser := User{ + BotID: b.botID, + TelegramID: regularUserID, + Username: "regular", + RoleID: regularRole.ID, + Role: regularRole, + IsOwner: false, + } + err = db.Create(®ularUser).Error + assert.NoError(t, err) + + // Create test messages for each user + for _, userID := range []int64{ownerID, adminID, regularUserID} { + for i := 0; i < 5; i++ { + // User message + userMessage := Message{ + BotID: b.botID, + ChatID: chatID, + UserID: userID, + Username: "test", + UserRole: "user", + Text: "Test message", + Timestamp: time.Now(), + IsUser: true, + } + err = db.Create(&userMessage).Error + assert.NoError(t, err) + + // Bot response + botMessage := Message{ + BotID: b.botID, + ChatID: chatID, + UserID: 0, + Username: "AI Assistant", + UserRole: "assistant", + Text: "Test response", + Timestamp: time.Now(), + IsUser: false, + } + err = db.Create(&botMessage).Error + assert.NoError(t, err) + } + } + + // Test cases + testCases := []struct { + name string + command string + currentUserID int64 + expectedError bool + expectedMsg string + businessConnID string + }{ + { + name: "Global stats", + command: "/stats", + currentUserID: regularUserID, + expectedError: false, + expectedMsg: "šŸ“Š Bot Statistics:", + }, + { + name: "User requests own stats", + command: "/stats user", + currentUserID: regularUserID, + expectedError: false, + expectedMsg: "šŸ‘¤ User Statistics for @regular (ID: 789):", + }, + { + name: "Admin requests another user's stats", + command: "/stats user 789", + currentUserID: adminID, + expectedError: false, + expectedMsg: "šŸ‘¤ User Statistics for @regular (ID: 789):", + }, + { + name: "Owner requests another user's stats", + command: "/stats user 456", + currentUserID: ownerID, + expectedError: false, + expectedMsg: "šŸ‘¤ User Statistics for @admin (ID: 456):", + }, + { + name: "Regular user attempts to request another user's stats", + command: "/stats user 456", + currentUserID: regularUserID, + expectedError: true, + expectedMsg: "Permission denied. Only admins and owners can view other users' statistics.", + }, + { + name: "User provides invalid user ID format", + command: "/stats user abc", + currentUserID: adminID, + expectedError: true, + expectedMsg: "Invalid user ID format. Usage: /stats user [user_id]", + }, + { + name: "User provides invalid command format", + command: "/stats invalid", + currentUserID: adminID, + expectedError: true, + expectedMsg: "Invalid command format. Usage: /stats or /stats user [user_id]", + }, + { + name: "User requests non-existent user's stats", + command: "/stats user 999", + currentUserID: adminID, + expectedError: true, + expectedMsg: "Sorry, I couldn't retrieve statistics for user ID 999.", + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + // Setup mock response expectations + var sentMessage string + mockTgClient.SendMessageFunc = func(ctx context.Context, params *bot.SendMessageParams) (*models.Message, error) { + sentMessage = params.Text + return &models.Message{}, nil + } + + // Create update with command + update := &models.Update{ + Message: &models.Message{ + Chat: models.Chat{ID: chatID}, + From: &models.User{ + ID: tc.currentUserID, + Username: getUsernameByID(tc.currentUserID), + }, + Text: tc.command, + Entities: []models.MessageEntity{ + { + Type: "bot_command", + Offset: 0, + Length: 6, // Length of "/stats" + }, + }, + }, + } + + // Handle the update + b.handleUpdate(context.Background(), nil, update) + + // Verify the response message contains the expected text + assert.Contains(t, sentMessage, tc.expectedMsg) + }) + } +} + +// Helper function to get username by ID for test +func getUsernameByID(id int64) string { + switch id { + case 123: + return "owner" + case 456: + return "admin" + case 789: + return "regular" + default: + return "unknown" + } +} + +func setupTestDB(t *testing.T) *gorm.DB { + db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{}) + if err != nil { + t.Fatalf("Failed to open test database: %v", err) + } + + // AutoMigrate the models + err = db.AutoMigrate(&BotModel{}, &ConfigModel{}, &Message{}, &User{}, &Role{}, &Scope{}) + if err != nil { + t.Fatalf("Failed to migrate database schema: %v", err) + } + + // Create default roles and scopes + err = createDefaultRoles(db) + if err != nil { + t.Fatalf("Failed to create default roles: %v", err) + } + if err := createDefaultScopes(db); err != nil { + t.Fatalf("Failed to create default scopes: %v", err) + } + + return db +} + +// setupBotForTest creates a minimal Bot instance backed by an in-memory DB. +// It follows the same pattern as the existing handler tests to avoid duplication. +func setupBotForTest(t *testing.T, ownerID int64) (*Bot, *MockTelegramClient) { + t.Helper() + db := setupTestDB(t) + mockClock := &MockClock{currentTime: time.Now()} + config := BotConfig{ + ID: "test_bot", + OwnerTelegramID: ownerID, + TelegramToken: "test_token", + MemorySize: 10, + MessagePerHour: 5, + MessagePerDay: 10, + TempBanDuration: "1h", + Model: "claude-3-5-haiku-latest", + SystemPrompts: make(map[string]string), + Active: true, + } + mockTgClient := &MockTelegramClient{} + botModel := &BotModel{Identifier: config.ID, Name: config.ID} + assert.NoError(t, db.Create(botModel).Error) + assert.NoError(t, db.Create(&ConfigModel{ + BotID: botModel.ID, + MemorySize: config.MemorySize, + MessagePerHour: config.MessagePerHour, + MessagePerDay: config.MessagePerDay, + TempBanDuration: config.TempBanDuration, + SystemPrompts: "{}", + TelegramToken: config.TelegramToken, + Active: config.Active, + }).Error) + b, err := NewBot(db, config, mockClock, mockTgClient) + assert.NoError(t, err) + return b, mockTgClient +} + +// TestAnthropicErrorResponse verifies that model-deprecation errors surface actionable +// details only to admin/owner, and that regular users and non-model errors always get +// the generic fallback. +func TestAnthropicErrorResponse(t *testing.T) { //NOSONAR go:S100 -- underscore separation is idiomatic in Go test names + b, _ := setupBotForTest(t, 123) + + // Create admin user + adminRole, err := b.getRoleByName("admin") + assert.NoError(t, err) + assert.NoError(t, b.db.Create(&User{ + BotID: b.botID, TelegramID: 456, Username: "admin", + RoleID: adminRole.ID, Role: adminRole, + }).Error) + + // Create regular user + userRole, err := b.getRoleByName("user") + assert.NoError(t, err) + assert.NoError(t, b.db.Create(&User{ + BotID: b.botID, TelegramID: 789, Username: "regular", + RoleID: userRole.ID, Role: userRole, + }).Error) + + modelErr := fmt.Errorf("%w: claude-3-5-haiku-latest", ErrModelNotFound) + otherErr := errors.New("network error") + + tests := []struct { + name string + err error + userID int64 + wantSubstr string + wantMissing string + }{ + { + name: "owner receives actionable model-not-found message", + err: modelErr, + userID: 123, + wantSubstr: "/set_model", + }, + { + name: "admin receives actionable model-not-found message", + err: modelErr, + userID: 456, + wantSubstr: "/set_model", + }, + { + name: "regular user receives generic message for model-not-found", + err: modelErr, + userID: 789, + wantSubstr: "I'm sorry", + wantMissing: "/set_model", + }, + { + name: "owner receives generic message for non-model error", + err: otherErr, + userID: 123, + wantSubstr: "I'm sorry", + wantMissing: "/set_model", + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + resp := b.anthropicErrorResponse(tc.err, tc.userID) + assert.Contains(t, resp, tc.wantSubstr) + if tc.wantMissing != "" { + assert.NotContains(t, resp, tc.wantMissing) + } + }) + } +} + +// TestSetModelCommand verifies that /set_model enforces permissions, validates input, +// updates the model in memory, and persists the change to the config file on disk. +func TestSetModelCommand(t *testing.T) { //NOSONAR go:S100 -- underscore separation is idiomatic in Go test names + b, mockTgClient := setupBotForTest(t, 123) + + // Point the config at a temporary file so PersistModel can write to disk. + tempDir, err := os.MkdirTemp("", "set_model_cmd_test") + assert.NoError(t, err) + defer func() { _ = os.RemoveAll(tempDir) }() + + configPath := filepath.Join(tempDir, "config.json") + initialJSON := `{"id":"test_bot","telegram_token":"test_token","model":"claude-3-5-haiku-latest","messages_per_hour":5,"messages_per_day":10}` + assert.NoError(t, os.WriteFile(configPath, []byte(initialJSON), 0600)) + b.config.ConfigFilePath = configPath + + // Create admin and regular users + adminRole, err := b.getRoleByName("admin") + assert.NoError(t, err) + assert.NoError(t, b.db.Create(&User{ + BotID: b.botID, TelegramID: 456, Username: "admin", + RoleID: adminRole.ID, Role: adminRole, + }).Error) + userRole, err := b.getRoleByName("user") + assert.NoError(t, err) + assert.NoError(t, b.db.Create(&User{ + BotID: b.botID, TelegramID: 789, Username: "regular", + RoleID: userRole.ID, Role: userRole, + }).Error) + + chatID := int64(1000) + + // Seed chat 1000 with a prior message so isNewChatFlag is false for all subtests. + // Commands are only processed in the non-new-chat branch of handleUpdate. + assert.NoError(t, b.db.Create(&Message{ + BotID: b.botID, ChatID: chatID, UserID: 789, Username: "regular", + UserRole: "user", Text: "hello", IsUser: true, + }).Error) + + makeUpdate := func(userID int64, text string, cmdLen int) *models.Update { + return &models.Update{ + Message: &models.Message{ + Chat: models.Chat{ID: chatID}, + From: &models.User{ID: userID, Username: getUsernameByID(userID)}, + Text: text, + Entities: []models.MessageEntity{ + {Type: "bot_command", Offset: 0, Length: cmdLen}, + }, + }, + } + } + + tests := []struct { + name string + userID int64 + text string + wantSubstr string + }{ + { + name: "regular user is denied", + userID: 789, + text: "/set_model claude-sonnet-4-6", + wantSubstr: "Permission denied", + }, + { + name: "admin missing argument shows usage", + userID: 456, + text: "/set_model", + wantSubstr: "Usage:", + }, + { + name: "owner missing argument shows usage", + userID: 123, + text: "/set_model", + wantSubstr: "Usage:", + }, + { + name: "admin sets model successfully", + userID: 456, + text: "/set_model claude-sonnet-4-6", + wantSubstr: "āœ…", + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + var sentMessage string + mockTgClient.SendMessageFunc = func(ctx context.Context, params *bot.SendMessageParams) (*models.Message, error) { + sentMessage = params.Text + return &models.Message{}, nil + } + b.handleUpdate(context.Background(), nil, makeUpdate(tc.userID, tc.text, 10)) + assert.Contains(t, sentMessage, tc.wantSubstr) + }) + } + + // Verify the successful update took effect in memory and on disk. + t.Run("model change persisted in memory and on disk", func(t *testing.T) { + assert.Equal(t, "claude-sonnet-4-6", string(b.config.Model)) + data, err := os.ReadFile(configPath) + assert.NoError(t, err) + assert.Contains(t, string(data), `"claude-sonnet-4-6"`) + }) +} + +// TestHasScope verifies that scope checks honour role assignments and the owner bypass. +func TestHasScope(t *testing.T) { //NOSONAR go:S100 -- underscore separation is idiomatic in Go test names + const ownerID int64 = 100 + b, _ := setupBotForTest(t, ownerID) + + // Admin user + adminRole, err := b.getRoleByName("admin") + assert.NoError(t, err) + assert.NoError(t, b.db.Create(&User{ + BotID: b.botID, TelegramID: 200, Username: "admin_user", + RoleID: adminRole.ID, Role: adminRole, + }).Error) + + // Regular user + userRole, err := b.getRoleByName("user") + assert.NoError(t, err) + assert.NoError(t, b.db.Create(&User{ + BotID: b.botID, TelegramID: 300, Username: "regular_user", + RoleID: userRole.ID, Role: userRole, + }).Error) + + tests := []struct { + name string + userID int64 + scope string + want bool + }{ + {"owner bypass: model:set", ownerID, ScopeModelSet, true}, + {"owner bypass: stats:view:any", ownerID, ScopeStatsViewAny, true}, + {"admin: model:set", 200, ScopeModelSet, true}, + {"admin: stats:view:any", 200, ScopeStatsViewAny, true}, + {"admin: history:clear:any", 200, ScopeHistoryClearAny, true}, + {"user: model:set denied", 300, ScopeModelSet, false}, + {"user: stats:view:any denied", 300, ScopeStatsViewAny, false}, + {"user: history:clear:any denied", 300, ScopeHistoryClearAny, false}, + {"user: stats:view:own allowed", 300, ScopeStatsViewOwn, true}, + {"user: history:clear:own allowed", 300, ScopeHistoryClearOwn, true}, + {"unknown telegram_id", 999, ScopeModelSet, false}, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.want, b.hasScope(tc.userID, tc.scope)) + }) + } +} diff --git a/logger.go b/logger.go new file mode 100644 index 0000000..3a4c606 --- /dev/null +++ b/logger.go @@ -0,0 +1,27 @@ +package main + +import ( + "log" + "os" +) + +// For log management, use journalctl commands: +// - View logs: journalctl -u telegram-bot +// - Follow logs: journalctl -u telegram-bot -f +// - View errors: journalctl -u telegram-bot -p err +// Refer to the documentation for details on systemd unit setup. + +// Initialize loggers for informational and error messages. +var ( + InfoLogger *log.Logger + ErrorLogger *log.Logger +) + +// initLoggers sets up separate loggers for stdout and stderr. +func initLoggers() { + // InfoLogger writes to stdout with specific flags. + InfoLogger = log.New(os.Stdout, "INFO: ", log.Ldate|log.Ltime|log.Lshortfile) + + // ErrorLogger writes to stderr with specific flags. + ErrorLogger = log.New(os.Stderr, "ERROR: ", log.Ldate|log.Ltime|log.Lshortfile) +} diff --git a/main.go b/main.go index 88f57a2..62bdaf9 100644 --- a/main.go +++ b/main.go @@ -2,284 +2,63 @@ package main import ( "context" - "errors" - "fmt" - "io" - "log" "os" "os/signal" - "time" - - "github.com/go-telegram/bot" - "github.com/go-telegram/bot/models" - "github.com/joho/godotenv" - "github.com/liushuangls/go-anthropic/v2" - "gorm.io/driver/sqlite" - "gorm.io/gorm" - "gorm.io/gorm/logger" + "sync" ) -// Message represents the structure for storing messages in the database -type Message struct { - gorm.Model - ChatID int64 - UserID int64 - Username string - UserRole string // New field - Text string - Timestamp time.Time -} - -// Bot wraps the Telegram bot, database connection, and Anthropic client -type Bot struct { - tgBot *bot.Bot - db *gorm.DB - anthropicClient *anthropic.Client -} - -type User struct { - gorm.Model - TelegramID int64 `gorm:"uniqueIndex"` - Username string - Role string -} - func main() { - // Initialize logger to write to both console and file - logFile, err := os.OpenFile("bot.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666) - if err != nil { - fmt.Fprintf(os.Stderr, "Error opening log file: %v\n", err) - os.Exit(1) - } - defer logFile.Close() + // Initialize custom loggers + initLoggers() - // Create a multi-writer to write to both stdout and the log file - mw := io.MultiWriter(os.Stdout, logFile) - log.SetOutput(mw) - - // Load environment variables - if err := godotenv.Load(); err != nil { - log.Printf("Error loading .env file: %v", err) - } - - // Check for required environment variables - requiredEnvVars := []string{"TELEGRAM_BOT_TOKEN", "ANTHROPIC_API_KEY"} - for _, envVar := range requiredEnvVars { - if os.Getenv(envVar) == "" { - log.Fatalf("%s environment variable is not set", envVar) - } - } + // Log the start of the application + InfoLogger.Println("Starting Telegram Bot Application") // Initialize database db, err := initDB() if err != nil { - log.Fatalf("Error initializing database: %v", err) + ErrorLogger.Fatalf("Error initializing database: %v", err) } - // Initialize Anthropic client - anthropicClient := anthropic.NewClient(os.Getenv("ANTHROPIC_API_KEY")) - - // Create Bot instance - b := &Bot{ - db: db, - anthropicClient: anthropicClient, - } - - // Initialize Telegram bot with the handler - tgBot, err := initTelegramBot(b.handleUpdate) + // Load all bot configurations + configs, err := loadAllConfigs("config") if err != nil { - log.Fatalf("Error initializing Telegram bot: %v", err) + ErrorLogger.Fatalf("Error loading configurations: %v", err) } - b.tgBot = tgBot + + // Create a WaitGroup to manage goroutines + var wg sync.WaitGroup // Set up context with cancellation ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt) defer cancel() - // Start the bot - log.Println("Starting bot...") - b.tgBot.Start(ctx) -} + // Initialize and start each bot + for _, config := range configs { + wg.Add(1) + go func(cfg BotConfig) { + defer wg.Done() -func initDB() (*gorm.DB, error) { - // Use the same logger for GORM - newLogger := logger.New( - log.New(log.Writer(), "\r\n", log.LstdFlags), // io writer - logger.Config{ - SlowThreshold: time.Second, - LogLevel: logger.Info, - Colorful: false, - }, - ) - - // Initialize GORM with SQLite - db, err := gorm.Open(sqlite.Open("bot.db"), &gorm.Config{ - Logger: newLogger, - }) - if err != nil { - return nil, fmt.Errorf("failed to connect to database: %w", err) - } - - // Auto-migrate the schema - err = db.AutoMigrate(&Message{}, &User{}) - if err != nil { - return nil, fmt.Errorf("failed to migrate database schema: %w", err) - } - - return db, nil -} - -func initTelegramBot(handler bot.HandlerFunc) (*bot.Bot, error) { - // Load .env file - err := godotenv.Load() - if err != nil { - log.Println("Error loading .env file") - } - - // Get bot token from environment variable - token := os.Getenv("TELEGRAM_BOT_TOKEN") - if token == "" { - return nil, fmt.Errorf("TELEGRAM_BOT_TOKEN environment variable is not set") - } - - // Create new bot instance with the handler - b, err := bot.New(token, bot.WithDefaultHandler(handler)) - if err != nil { - return nil, fmt.Errorf("failed to create bot: %w", err) - } - - log.Println("Telegram bot initialized successfully") - return b, nil -} - -func (b *Bot) handleUpdate(ctx context.Context, tgBot *bot.Bot, update *models.Update) { - if update.Message == nil { - return // Ignore non-message updates - } - - chatID := update.Message.Chat.ID - userID := update.Message.From.ID - username := update.Message.From.Username - text := update.Message.Text - - // Check if user exists, if not create a new user with default role - var user User - if err := b.db.Where("telegram_id = ?", userID).First(&user).Error; err != nil { - if errors.Is(err, gorm.ErrRecordNotFound) { - user = User{ - TelegramID: userID, - Username: username, - Role: "user", // Default role + // Create Bot instance without TelegramClient initially + realClock := RealClock{} + bot, err := NewBot(db, cfg, realClock, nil) + if err != nil { + ErrorLogger.Printf("Error creating bot %s: %v", cfg.ID, err) + return } - b.db.Create(&user) - } else { - log.Printf("Error checking user: %v", err) - return - } + + // Start the bot in a separate goroutine + go bot.Start(ctx) + + // Keep the bot running until the context is cancelled + <-ctx.Done() + + InfoLogger.Printf("Bot %s stopped", cfg.ID) + }(config) } - // Prepare response using Anthropic - var response string - var err error - isNewChat := b.isNewChat(chatID) - if b.isAdminOrOwner(userID) { - response, err = b.getAnthropicResponse(ctx, text, isNewChat) - } else { - response, err = b.getModeratedAnthropicResponse(ctx, text, isNewChat) - } - if err != nil { - log.Printf("Error getting Anthropic response: %v", err) - response = "I'm sorry, I'm having trouble processing your request right now." - } + // Wait for all bots to finish + wg.Wait() - // Store message in database - message := Message{ - ChatID: chatID, - UserID: userID, - Username: username, - UserRole: user.Role, - Text: text, - Timestamp: time.Now(), - } - if err := b.db.Create(&message).Error; err != nil { - log.Printf("Error storing message: %v", err) - } - - // Send response - _, err = b.tgBot.SendMessage(ctx, &bot.SendMessageParams{ - ChatID: chatID, - Text: response, - }) - if err != nil { - log.Printf("Error sending message: %v", err) - } -} - -// isNewChat checks if this is a new chat for the user -func (b *Bot) isNewChat(chatID int64) bool { - var count int64 - b.db.Model(&Message{}).Where("chat_id = ?", chatID).Count(&count) - return count == 0 -} - -func (b *Bot) isAdminOrOwner(userID int64) bool { - var user User - if err := b.db.Where("telegram_id = ?", userID).First(&user).Error; err != nil { - return false - } - return user.Role == "admin" || user.Role == "owner" -} - -func (b *Bot) getAnthropicResponse(ctx context.Context, userMessage string, isNewChat bool) (string, error) { - var systemMessage string - if isNewChat { - systemMessage = "You are a helpful AI assistant. Greet the user and respond to their message." - } else { - systemMessage = "You are a helpful AI assistant. Respond to the user's message." - } - - resp, err := b.anthropicClient.CreateMessages(ctx, anthropic.MessagesRequest{ - Model: anthropic.ModelClaudeInstant1Dot2, - Messages: []anthropic.Message{ - anthropic.NewUserTextMessage(systemMessage), - anthropic.NewUserTextMessage(userMessage), - }, - MaxTokens: 1000, - }) - if err != nil { - return "", fmt.Errorf("error creating Anthropic message: %w", err) - } - - if len(resp.Content) == 0 || resp.Content[0].Type != anthropic.MessagesContentTypeText { - return "", fmt.Errorf("unexpected response format from Anthropic") - } - - return resp.Content[0].GetText(), nil -} - -func (b *Bot) getModeratedAnthropicResponse(ctx context.Context, userMessage string, isNewChat bool) (string, error) { - var systemMessage string - if isNewChat { - systemMessage = "You are a helpful AI assistant. Greet the user and respond to their message. Avoid discussing sensitive topics or providing harmful information." - } else { - systemMessage = "You are a helpful AI assistant. Respond to the user's message while avoiding sensitive topics or harmful information." - } - - resp, err := b.anthropicClient.CreateMessages(ctx, anthropic.MessagesRequest{ - Model: anthropic.ModelClaudeInstant1Dot2, - Messages: []anthropic.Message{ - anthropic.NewUserTextMessage(systemMessage), - anthropic.NewUserTextMessage(userMessage), - }, - MaxTokens: 1000, - }) - if err != nil { - return "", fmt.Errorf("error creating Anthropic message: %w", err) - } - - if len(resp.Content) == 0 || resp.Content[0].Type != anthropic.MessagesContentTypeText { - return "", fmt.Errorf("unexpected response format from Anthropic") - } - - return resp.Content[0].GetText(), nil + InfoLogger.Println("All bots have stopped. Exiting application.") } diff --git a/models.go b/models.go new file mode 100644 index 0000000..d9edf9e --- /dev/null +++ b/models.go @@ -0,0 +1,91 @@ +package main + +import ( + "time" + + "gorm.io/gorm" +) + +type BotModel struct { + gorm.Model + Identifier string `gorm:"uniqueIndex"` // Renamed from ID to Identifier + Name string + Configs []ConfigModel `gorm:"foreignKey:BotID;constraint:OnDelete:CASCADE"` + Users []User `gorm:"foreignKey:BotID;constraint:OnDelete:CASCADE"` // Associated users + Messages []Message `gorm:"foreignKey:BotID;constraint:OnDelete:CASCADE"` +} + +type ConfigModel struct { + gorm.Model + BotID uint `gorm:"index"` + MemorySize int `json:"memory_size"` + MessagePerHour int `json:"messages_per_hour"` + MessagePerDay int `json:"messages_per_day"` + TempBanDuration string `json:"temp_ban_duration"` + SystemPrompts string `json:"system_prompts"` // Consider JSON string or separate table + TelegramToken string `json:"telegram_token"` + Active bool `json:"active"` +} + +type Message struct { + gorm.Model + BotID uint `gorm:"index"` + ChatID int64 `gorm:"index"` + UserID int64 `gorm:"index"` + Username string `gorm:"index"` + UserRole string // Store the role as a string + Text string `gorm:"type:text"` + Timestamp time.Time `gorm:"index"` + IsUser bool + StickerFileID string + StickerPNGFile string + StickerEmoji string // Store the emoji associated with the sticker + DeletedAt gorm.DeletedAt `gorm:"index"` // Add soft delete field + AnsweredOn *time.Time `gorm:"index"` // Tracks when a user message was answered (NULL for assistant messages and unanswered user messages) +} + +type ChatMemory struct { + Messages []Message + Size int + BusinessConnectionID string // New field to store the business connection ID +} + +// Scope name constants ā€” used in DB seeding, hasScope checks, and tests. +const ( + ScopeStatsViewOwn = "stats:view:own" + ScopeStatsViewAny = "stats:view:any" + ScopeHistoryClearOwn = "history:clear:own" + ScopeHistoryClearAny = "history:clear:any" + ScopeHistoryClearHardOwn = "history:clear_hard:own" + ScopeHistoryClearHardAny = "history:clear_hard:any" + ScopeModelSet = "model:set" + ScopeUserPromote = "user:promote" + ScopeTTSUse = "tts:use" +) + +type Scope struct { + gorm.Model + Name string `gorm:"uniqueIndex"` +} + +type Role struct { + gorm.Model + Name string `gorm:"uniqueIndex"` + Scopes []Scope `gorm:"many2many:role_scopes;"` +} + +type User struct { + gorm.Model + BotID uint `gorm:"uniqueIndex:idx_user_bot;index"` // Foreign key to BotModel + TelegramID int64 `gorm:"uniqueIndex:idx_user_bot;not null"` // Unique per (telegram_id, bot_id) pair + Username string + RoleID uint + Role Role `gorm:"foreignKey:RoleID"` + IsOwner bool `gorm:"default:false"` // Indicates if the user is the owner +} + +// idx_user_bot is a composite unique index on (bot_id, telegram_id), +// allowing the same Telegram user to be registered independently on each bot. +func (User) TableName() string { + return "users" +} diff --git a/rate_limiter.go b/rate_limiter.go new file mode 100644 index 0000000..c914948 --- /dev/null +++ b/rate_limiter.go @@ -0,0 +1,71 @@ +package main + +import ( + "time" + + "golang.org/x/time/rate" +) + +type userLimiter struct { + hourlyLimiter *rate.Limiter + dailyLimiter *rate.Limiter + lastHourlyReset time.Time + lastDailyReset time.Time + banUntil time.Time + clock Clock +} + +func (b *Bot) checkRateLimits(userID int64) bool { + b.userLimitersMu.Lock() + defer b.userLimitersMu.Unlock() + + limiter, exists := b.userLimiters[userID] + if !exists { + limiter = &userLimiter{ + hourlyLimiter: rate.NewLimiter(rate.Every(time.Hour/time.Duration(b.config.MessagePerHour)), b.config.MessagePerHour), + dailyLimiter: rate.NewLimiter(rate.Every(24*time.Hour/time.Duration(b.config.MessagePerDay)), b.config.MessagePerDay), + lastHourlyReset: b.clock.Now(), + lastDailyReset: b.clock.Now(), + clock: b.clock, + } + b.userLimiters[userID] = limiter + } + + now := limiter.clock.Now() + + // Check if the user is currently banned + if now.Before(limiter.banUntil) { + return false + } + + // Reset hourly limiter if an hour has passed since the last reset + if now.Sub(limiter.lastHourlyReset) >= time.Hour { + limiter.hourlyLimiter = rate.NewLimiter(rate.Every(time.Hour/time.Duration(b.config.MessagePerHour)), b.config.MessagePerHour) + limiter.lastHourlyReset = now + } + + // Reset daily limiter if 24 hours have passed since the last reset + if now.Sub(limiter.lastDailyReset) >= 24*time.Hour { + limiter.dailyLimiter = rate.NewLimiter(rate.Every(24*time.Hour/time.Duration(b.config.MessagePerDay)), b.config.MessagePerDay) + limiter.lastDailyReset = now + } + + // Check if the message exceeds rate limits. + // Reserve from both limiters first, then cancel both if either is over budget. + // This prevents consuming a token from one limiter when the other rejects. + dailyRes := limiter.dailyLimiter.ReserveN(now, 1) + hourlyRes := limiter.hourlyLimiter.ReserveN(now, 1) + if dailyRes.DelayFrom(now) > 0 || hourlyRes.DelayFrom(now) > 0 { + dailyRes.CancelAt(now) + hourlyRes.CancelAt(now) + banDuration, err := time.ParseDuration(b.config.TempBanDuration) + if err != nil { + // If parsing fails, default to a 24-hour ban + banDuration = 24 * time.Hour + } + limiter.banUntil = now.Add(banDuration) + return false + } + + return true +} diff --git a/rate_limiter_test.go b/rate_limiter_test.go new file mode 100644 index 0000000..a2871f3 --- /dev/null +++ b/rate_limiter_test.go @@ -0,0 +1,85 @@ +package main + +import ( + "testing" + "time" +) + +// TestCheckRateLimits tests the checkRateLimits method of the Bot. +// It verifies that users are allowed or denied based on their message rates. +func TestCheckRateLimits(t *testing.T) { + // Create a mock clock starting at a fixed time + mockClock := &MockClock{ + currentTime: time.Date(2023, 10, 1, 0, 0, 0, 0, time.UTC), + } + + // Create a mock configuration with reduced timeframes for testing + config := BotConfig{ + ID: "bot1", + MemorySize: 10, + MessagePerHour: 5, // Allow 5 messages per hour + MessagePerDay: 10, // Allow 10 messages per day + TempBanDuration: "1m", // Temporary ban duration of 1 minute for testing + SystemPrompts: make(map[string]string), + TelegramToken: "YOUR_TELEGRAM_BOT_TOKEN", + OwnerTelegramID: 123456789, + } + + // Initialize the Bot with mock data and MockClock + bot := &Bot{ + config: config, + userLimiters: make(map[int64]*userLimiter), + clock: mockClock, + } + + userID := int64(12345) + + // Helper function to simulate message sending + sendMessage := func() bool { + return bot.checkRateLimits(userID) + } + + // Send 5 messages within the hourly limit + for i := 0; i < config.MessagePerHour; i++ { + if !sendMessage() { + t.Errorf("Expected message %d to be allowed", i+1) + } + } + + // 6th message should exceed the hourly limit and trigger a ban + if sendMessage() { + t.Errorf("Expected message to be denied due to hourly limit exceeded") + } + + // Attempt to send another message immediately, should still be banned + if sendMessage() { + t.Errorf("Expected message to be denied while user is banned") + } + + // Fast-forward time by TempBanDuration to lift the ban + mockClock.Advance(time.Minute) // Banned for 1 minute + + // Advance time to allow hourly limiter to replenish + mockClock.Advance(time.Hour) // Advance by 1 hour + + // Send another message, should be allowed now + if !sendMessage() { + t.Errorf("Expected message to be allowed after ban duration") + } + + // Send additional messages to reach the daily limit + for i := 0; i < config.MessagePerDay-config.MessagePerHour-1; i++ { + if !sendMessage() { + t.Errorf("Expected message %d to be allowed towards daily limit", i+1) + } + } + + // Attempt to exceed the daily limit + if sendMessage() { + t.Errorf("Expected message to be denied due to daily limit exceeded") + } +} + +// To ensure thread safety and avoid race conditions during testing, +// you can run the tests with the `-race` flag: +// go test -race -v diff --git a/telegram_client.go b/telegram_client.go new file mode 100644 index 0000000..dbdd377 --- /dev/null +++ b/telegram_client.go @@ -0,0 +1,19 @@ +// telegram_client.go +package main + +import ( + "context" + + "github.com/go-telegram/bot" + "github.com/go-telegram/bot/models" +) + +// TelegramClient defines the methods required from the Telegram bot. +type TelegramClient interface { + SendMessage(ctx context.Context, params *bot.SendMessageParams) (*models.Message, error) + SendAudio(ctx context.Context, params *bot.SendAudioParams) (*models.Message, error) + SetMyCommands(ctx context.Context, params *bot.SetMyCommandsParams) (bool, error) + GetFile(ctx context.Context, params *bot.GetFileParams) (*models.File, error) + FileDownloadLink(f *models.File) string + Start(ctx context.Context) +} diff --git a/telegram_client_mock.go b/telegram_client_mock.go new file mode 100644 index 0000000..ca272bf --- /dev/null +++ b/telegram_client_mock.go @@ -0,0 +1,74 @@ +// telegram_client_mock.go +package main + +import ( + "context" + + "github.com/go-telegram/bot" + "github.com/go-telegram/bot/models" + "github.com/stretchr/testify/mock" +) + +// MockTelegramClient is a mock implementation of TelegramClient for testing. +type MockTelegramClient struct { + mock.Mock + SendMessageFunc func(ctx context.Context, params *bot.SendMessageParams) (*models.Message, error) + SendAudioFunc func(ctx context.Context, params *bot.SendAudioParams) (*models.Message, error) + SetMyCommandsFunc func(ctx context.Context, params *bot.SetMyCommandsParams) (bool, error) + GetFileFunc func(ctx context.Context, params *bot.GetFileParams) (*models.File, error) + FileDownloadLinkFunc func(f *models.File) string + StartFunc func(ctx context.Context) +} + +// SendMessage mocks sending a message. +func (m *MockTelegramClient) SendMessage(ctx context.Context, params *bot.SendMessageParams) (*models.Message, error) { + if m.SendMessageFunc != nil { + return m.SendMessageFunc(ctx, params) + } + args := m.Called(ctx, params) + if msg, ok := args.Get(0).(*models.Message); ok { + return msg, args.Error(1) + } + return nil, args.Error(1) +} + +// SetMyCommands mocks registering bot commands. +func (m *MockTelegramClient) SetMyCommands(ctx context.Context, params *bot.SetMyCommandsParams) (bool, error) { + if m.SetMyCommandsFunc != nil { + return m.SetMyCommandsFunc(ctx, params) + } + return true, nil +} + +// SendAudio mocks sending an audio message. +func (m *MockTelegramClient) SendAudio(ctx context.Context, params *bot.SendAudioParams) (*models.Message, error) { + if m.SendAudioFunc != nil { + return m.SendAudioFunc(ctx, params) + } + return nil, nil +} + +// GetFile mocks retrieving file info from Telegram. +func (m *MockTelegramClient) GetFile(ctx context.Context, params *bot.GetFileParams) (*models.File, error) { + if m.GetFileFunc != nil { + return m.GetFileFunc(ctx, params) + } + return &models.File{}, nil +} + +// FileDownloadLink mocks building the file download URL. +func (m *MockTelegramClient) FileDownloadLink(f *models.File) string { + if m.FileDownloadLinkFunc != nil { + return m.FileDownloadLinkFunc(f) + } + return "" +} + +// Start mocks starting the Telegram client. +func (m *MockTelegramClient) Start(ctx context.Context) { + if m.StartFunc != nil { + m.StartFunc(ctx) + return + } + m.Called(ctx) +} diff --git a/user_management_test.go b/user_management_test.go new file mode 100644 index 0000000..515e40a --- /dev/null +++ b/user_management_test.go @@ -0,0 +1,305 @@ +package main + +import ( + "context" + "fmt" + "testing" + "time" + + "github.com/go-telegram/bot" + "github.com/go-telegram/bot/models" + "gorm.io/driver/sqlite" + "gorm.io/gorm" +) + +const ( + errOpenDB = "Failed to open in-memory database: %v" + errMigrateSchema = "Failed to migrate database schema: %v" + errCreateRoles = "Failed to create default roles: %v" + errCreateScopes = "Failed to create default scopes: %v" + errCreateBot = "Failed to create bot: %v" + memoryDSN = ":memory:" +) + +func TestOwnerAssignment(t *testing.T) { + // Initialize loggers + initLoggers() + + // Initialize in-memory database for testing + db, err := gorm.Open(sqlite.Open(memoryDSN), &gorm.Config{}) + if err != nil { + t.Fatalf(errOpenDB, err) + } + + // Migrate the schema + err = db.AutoMigrate(&BotModel{}, &ConfigModel{}, &Message{}, &User{}, &Role{}, &Scope{}) + if err != nil { + t.Fatalf(errMigrateSchema, err) + } + + // Create default roles and scopes + err = createDefaultRoles(db) + if err != nil { + t.Fatalf(errCreateRoles, err) + } + if err := createDefaultScopes(db); err != nil { + t.Fatalf(errCreateScopes, err) + } + + // Create a bot configuration + config := BotConfig{ + ID: "test_bot", + TelegramToken: "TEST_TELEGRAM_TOKEN", + MemorySize: 10, + MessagePerHour: 5, + MessagePerDay: 10, + TempBanDuration: "1m", + SystemPrompts: make(map[string]string), + Active: true, + OwnerTelegramID: 111111111, + } + + // Initialize MockClock + mockClock := &MockClock{ + currentTime: time.Now(), + } + + // Initialize MockTelegramClient + mockTGClient := &MockTelegramClient{ + SendMessageFunc: func(ctx context.Context, params *bot.SendMessageParams) (*models.Message, error) { + chatID, ok := params.ChatID.(int64) + if !ok { + return nil, fmt.Errorf("ChatID is not of type int64") + } + // Simulate successful message sending + return &models.Message{ID: 1, Chat: models.Chat{ID: chatID}}, nil + }, + } + + // Create the bot with the mock Telegram client + bot, err := NewBot(db, config, mockClock, mockTGClient) + if err != nil { + t.Fatalf(errCreateBot, err) + } + + // Verify that the owner exists + var owner User + err = db.Where("telegram_id = ? AND bot_id = ? AND is_owner = ?", config.OwnerTelegramID, bot.botID, true).First(&owner).Error + if err != nil { + t.Fatalf("Owner was not created: %v", err) + } + + // Attempt to create another owner for the same bot + _, err = bot.getOrCreateUser(222222222, "AnotherOwner", true) + if err == nil { + t.Fatalf("Expected error when creating a second owner, but got none") + } + + // Verify that the error message is appropriate + expectedErrorMsg := "an owner already exists for this bot" + if err.Error() != expectedErrorMsg { + t.Fatalf("Unexpected error message: %v", err) + } + + // Assign admin role to a new user + regularUser, err := bot.getOrCreateUser(333333333, "RegularUser", false) + if err != nil { + t.Fatalf("Failed to create regular user: %v", err) + } + + if regularUser.Role.Name != "user" { + t.Fatalf("Expected role 'user', got '%s'", regularUser.Role.Name) + } + + // Attempt to change an existing user to owner + _, err = bot.getOrCreateUser(333333333, "AdminUser", true) + if err == nil { + t.Fatalf("Expected error when changing existing user to owner, but got none") + } + + expectedErrorMsg = "cannot change existing user to owner" + if err.Error() != expectedErrorMsg { + t.Fatalf("Unexpected error message: %v", err) + } + + // If you need to test admin creation, you should do it through a separate admin creation function + // or by updating an existing user's role with proper authorization checks +} + +func TestPromoteUserToAdmin(t *testing.T) { + // Initialize loggers + initLoggers() + + // Initialize in-memory database for testing + db, err := gorm.Open(sqlite.Open(memoryDSN), &gorm.Config{}) + if err != nil { + t.Fatalf(errOpenDB, err) + } + + // Migrate the schema + err = db.AutoMigrate(&BotModel{}, &ConfigModel{}, &Message{}, &User{}, &Role{}, &Scope{}) + if err != nil { + t.Fatalf(errMigrateSchema, err) + } + + // Create default roles and scopes + err = createDefaultRoles(db) + if err != nil { + t.Fatalf(errCreateRoles, err) + } + if err := createDefaultScopes(db); err != nil { + t.Fatalf(errCreateScopes, err) + } + + config := BotConfig{ + ID: "test_bot", + TelegramToken: "TEST_TELEGRAM_TOKEN", + MemorySize: 10, + MessagePerHour: 5, + MessagePerDay: 10, + TempBanDuration: "1m", + SystemPrompts: make(map[string]string), + Active: true, + OwnerTelegramID: 111111111, + } + + mockClock := &MockClock{currentTime: time.Now()} + mockTGClient := &MockTelegramClient{} + + bot, err := NewBot(db, config, mockClock, mockTGClient) + if err != nil { + t.Fatalf(errCreateBot, err) + } + + // Create an owner + owner, err := bot.getOrCreateUser(config.OwnerTelegramID, "OwnerUser", true) + if err != nil { + t.Fatalf("Failed to create owner: %v", err) + } + + // Test promoting a user to admin + regularUser, err := bot.getOrCreateUser(444444444, "RegularUser", false) + if err != nil { + t.Fatalf("Failed to create regular user: %v", err) + } + + err = bot.promoteUserToAdmin(owner.TelegramID, regularUser.TelegramID) + if err != nil { + t.Fatalf("Failed to promote user to admin: %v", err) + } + + // Refresh user data + promotedUser, err := bot.getOrCreateUser(444444444, "RegularUser", false) + if err != nil { + t.Fatalf("Failed to get promoted user: %v", err) + } + + if promotedUser.Role.Name != "admin" { + t.Fatalf("Expected role 'admin', got '%s'", promotedUser.Role.Name) + } +} + +// TestGetOrCreateUser tests the getOrCreateUser method of the Bot. +// It verifies that a new user is created when one does not exist, +// and an existing user is returned when one does exist. +func TestGetOrCreateUser(t *testing.T) { + // Initialize loggers + initLoggers() + + // Initialize in-memory database for testing + db, err := gorm.Open(sqlite.Open(memoryDSN), &gorm.Config{}) + if err != nil { + t.Fatalf(errOpenDB, err) + } + + // Migrate the schema + err = db.AutoMigrate(&BotModel{}, &ConfigModel{}, &Message{}, &User{}, &Role{}, &Scope{}) + if err != nil { + t.Fatalf(errMigrateSchema, err) + } + + // Create default roles and scopes + err = createDefaultRoles(db) + if err != nil { + t.Fatalf(errCreateRoles, err) + } + if err := createDefaultScopes(db); err != nil { + t.Fatalf(errCreateScopes, err) + } + + // Create a mock clock starting at a fixed time + mockClock := &MockClock{ + currentTime: time.Date(2023, 10, 1, 0, 0, 0, 0, time.UTC), + } + + // Create a mock configuration + config := BotConfig{ + ID: "bot1", + MemorySize: 10, + MessagePerHour: 5, + MessagePerDay: 10, + TempBanDuration: "1m", + SystemPrompts: make(map[string]string), + TelegramToken: "YOUR_TELEGRAM_BOT_TOKEN", + OwnerTelegramID: 123456789, + } + + // Initialize MockTelegramClient + mockTGClient := &MockTelegramClient{ + SendMessageFunc: func(ctx context.Context, params *bot.SendMessageParams) (*models.Message, error) { + chatID, ok := params.ChatID.(int64) + if !ok { + return nil, fmt.Errorf("ChatID is not of type int64") + } + // Simulate successful message sending + return &models.Message{ID: 1, Chat: models.Chat{ID: chatID}}, nil + }, + } + + // Create the bot with the mock Telegram client + bot, err := NewBot(db, config, mockClock, mockTGClient) + if err != nil { + t.Fatalf(errCreateBot, err) + } + + // Verify that the owner exists + var owner User + err = db.Where("telegram_id = ? AND bot_id = ? AND is_owner = ?", config.OwnerTelegramID, bot.botID, true).First(&owner).Error + if err != nil { + t.Fatalf("Owner was not created: %v", err) + } + + // Attempt to create another owner for the same bot + _, err = bot.getOrCreateUser(222222222, "AnotherOwner", true) + if err == nil { + t.Fatalf("Expected error when creating a second owner, but got none") + } + + // Create a new user + newUser, err := bot.getOrCreateUser(987654321, "TestUser", false) + if err != nil { + t.Fatalf("Failed to create a new user: %v", err) + } + + // Verify that the new user was created + var userInDB User + err = db.Where("telegram_id = ?", newUser.TelegramID).First(&userInDB).Error + if err != nil { + t.Fatalf("New user was not created in the database: %v", err) + } + + // Get the existing user + existingUser, err := bot.getOrCreateUser(987654321, "TestUser", false) + if err != nil { + t.Fatalf("Failed to get existing user: %v", err) + } + + // Verify that the existing user is the same as the new user + if existingUser.ID != userInDB.ID { + t.Fatalf("Expected to get the existing user, but got a different user") + } +} + +// To ensure thread safety and avoid race conditions during testing, +// you can run the tests with the `-race` flag: +// go test -race -v