alvin-bot 4.4.1

package/dist/handlers/document.js

@@ -0,0 +1,187 @@
+import { InputFile } from "grammy";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import https from "https";
+import { config } from "../config.js";
+import { getSession, addToHistory } from "../services/session.js";
+import { TelegramStreamer } from "../services/telegram.js";
+import { getRegistry } from "../engine.js";
+import { textToSpeech } from "../services/voice.js";
+import { buildSystemPrompt } from "../services/personality.js";
+const TEMP_DIR = path.join(os.tmpdir(), "alvin-bot");
+if (!fs.existsSync(TEMP_DIR))
+    fs.mkdirSync(TEMP_DIR, { recursive: true });
+/** React to a message with an emoji. Silently fails if not supported. */
+async function react(ctx, emoji) {
+    try {
+        await ctx.react(emoji);
+    }
+    catch { /* ignore */ }
+}
+async function downloadFile(url, dest) {
+    return new Promise((resolve, reject) => {
+        const file = fs.createWriteStream(dest);
+        https.get(url, (response) => {
+            response.pipe(file);
+            file.on("finish", () => file.close(() => resolve()));
+        }).on("error", (err) => {
+            fs.unlink(dest, () => { });
+            reject(err);
+        });
+    });
+}
+// File types we can handle
+const SUPPORTED_EXTENSIONS = new Set([
+    ".pdf", ".txt", ".md", ".csv", ".json", ".xml", ".html", ".htm",
+    ".doc", ".docx", ".xls", ".xlsx", ".pptx",
+    ".py", ".js", ".ts", ".jsx", ".tsx", ".java", ".c", ".cpp", ".h",
+    ".rs", ".go", ".rb", ".php", ".sh", ".bash", ".zsh",
+    ".yaml", ".yml", ".toml", ".ini", ".conf", ".cfg",
+    ".log", ".sql", ".env", ".gitignore", ".dockerfile",
+]);
+function isSupportedFile(filename) {
+    const ext = path.extname(filename).toLowerCase();
+    return SUPPORTED_EXTENSIONS.has(ext);
+}
+export async function handleDocument(ctx) {
+    const doc = ctx.message?.document;
+    if (!doc)
+        return;
+    const userId = ctx.from.id;
+    const session = getSession(userId);
+    if (session.isProcessing) {
+        await ctx.reply("Please wait, previous request still running... (/cancel to abort)");
+        return;
+    }
+    const filename = doc.file_name || "unknown";
+    const ext = path.extname(filename).toLowerCase();
+    // Check file size (Telegram max is 20MB for bots)
+    if (doc.file_size && doc.file_size > 20 * 1024 * 1024) {
+        await ctx.reply("⚠️ File too large (max 20 MB).");
+        return;
+    }
+    session.isProcessing = true;
+    session.abortController = new AbortController();
+    const streamer = new TelegramStreamer(ctx.chat.id, ctx.api, ctx.message?.message_id);
+    let finalText = "";
+    const typingInterval = setInterval(() => {
+        ctx.api.sendChatAction(ctx.chat.id, "typing").catch(() => { });
+    }, 4000);
+    try {
+        await react(ctx, "📄");
+        await ctx.api.sendChatAction(ctx.chat.id, "typing");
+        // Download the file
+        const file = await ctx.api.getFile(doc.file_id);
+        const fileUrl = `https://api.telegram.org/file/bot${config.botToken}/${file.file_path}`;
+        const localPath = path.join(TEMP_DIR, `doc_${Date.now()}_${filename}`);
+        await downloadFile(fileUrl, localPath);
+        const caption = ctx.message?.caption || "";
+        const userInstruction = caption || `Analysiere diese Datei: ${filename}`;
+        session.messageCount++;
+        const registry = getRegistry();
+        const activeProvider = registry.getActive();
+        const isSDK = activeProvider.config.type === "claude-sdk";
+        let queryOpts;
+        if (isSDK) {
+            // SDK provider: pass file path — Claude can read files natively
+            queryOpts = {
+                prompt: `Der User hat eine Datei gesendet: ${localPath}\nDateiname: ${filename}\n\nLies die Datei mit dem Read-Tool und bearbeite folgende Anfrage:\n${userInstruction}`,
+                systemPrompt: buildSystemPrompt(true, session.language),
+                workingDir: session.workingDir,
+                effort: session.effort,
+                abortSignal: session.abortController.signal,
+                sessionId: session.sessionId,
+                _sessionState: {
+                    messageCount: session.messageCount,
+                    toolUseCount: session.toolUseCount,
+                },
+            };
+        }
+        else {
+            // Non-SDK: try to extract text content and include in prompt
+            let fileContent = "";
+            if ([".txt", ".md", ".csv", ".json", ".xml", ".html", ".htm",
+                ".py", ".js", ".ts", ".jsx", ".tsx", ".java", ".c", ".cpp", ".h",
+                ".rs", ".go", ".rb", ".php", ".sh", ".bash", ".zsh",
+                ".yaml", ".yml", ".toml", ".ini", ".conf", ".cfg",
+                ".log", ".sql", ".env", ".gitignore", ".dockerfile"].includes(ext)) {
+                // Plain text files — read directly
+                fileContent = fs.readFileSync(localPath, "utf-8");
+                // Truncate very large files
+                if (fileContent.length > 50000) {
+                    fileContent = fileContent.slice(0, 50000) + "\n\n[... File truncated, total " + fileContent.length + " characters]";
+                }
+            }
+            else {
+                fileContent = `[Binary file: ${filename}, ${doc.file_size ? Math.round(doc.file_size / 1024) + " KB" : "unknown size"}. Can only be analyzed with the SDK provider (Claude).]`;
+            }
+            const fullPrompt = `Datei: ${filename}\n\n\`\`\`\n${fileContent}\n\`\`\`\n\n${userInstruction}`;
+            addToHistory(userId, { role: "user", content: fullPrompt });
+            queryOpts = {
+                prompt: fullPrompt,
+                systemPrompt: buildSystemPrompt(false, session.language),
+                workingDir: session.workingDir,
+                effort: session.effort,
+                abortSignal: session.abortController.signal,
+                history: session.history,
+            };
+        }
+        for await (const chunk of registry.queryWithFallback(queryOpts)) {
+            switch (chunk.type) {
+                case "text":
+                    finalText = chunk.text || "";
+                    await streamer.update(finalText);
+                    break;
+                case "tool_use":
+                    if (chunk.toolName)
+                        session.toolUseCount++;
+                    break;
+                case "done":
+                    if (chunk.sessionId)
+                        session.sessionId = chunk.sessionId;
+                    if (chunk.costUsd)
+                        session.totalCost += chunk.costUsd;
+                    session.lastActivity = Date.now();
+                    break;
+                case "error":
+                    await ctx.reply(`Error: ${chunk.error}`);
+                    break;
+            }
+        }
+        await streamer.finalize(finalText);
+        await react(ctx, "👍");
+        if (!isSDK && finalText) {
+            addToHistory(userId, { role: "assistant", content: finalText });
+        }
+        // Voice reply if enabled
+        if (session.voiceReply && finalText.trim()) {
+            try {
+                await ctx.api.sendChatAction(ctx.chat.id, "upload_voice");
+                const audioPath = await textToSpeech(finalText);
+                await ctx.replyWithVoice(new InputFile(fs.readFileSync(audioPath), "response.mp3"));
+                fs.unlink(audioPath, () => { });
+            }
+            catch (err) {
+                console.error("TTS error:", err);
+            }
+        }
+        // Clean up temp file after a delay (SDK might still need it)
+        setTimeout(() => fs.unlink(localPath, () => { }), 60000);
+    }
+    catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        await react(ctx, "👎");
+        if (errorMsg.includes("abort")) {
+            await ctx.reply("Anfrage abgebrochen.");
+        }
+        else {
+            await ctx.reply(`Error: ${errorMsg}`);
+        }
+    }
+    finally {
+        clearInterval(typingInterval);
+        session.isProcessing = false;
+        session.abortController = null;
+    }
+}

package/dist/handlers/message.js

@@ -0,0 +1,200 @@
+import { InputFile } from "grammy";
+import fs from "fs";
+import { getSession, addToHistory, trackProviderUsage, buildSessionKey } from "../services/session.js";
+import { TelegramStreamer } from "../services/telegram.js";
+import { getRegistry } from "../engine.js";
+import { textToSpeech } from "../services/voice.js";
+import { buildSystemPrompt, buildSmartSystemPrompt } from "../services/personality.js";
+import { buildSkillContext } from "../services/skills.js";
+import { isForwardingAllowed } from "../services/access.js";
+import { touchProfile } from "../services/users.js";
+import { trackAndAdapt } from "../services/language-detect.js";
+import { shouldCompact, compactSession } from "../services/compaction.js";
+import { emit } from "../services/hooks.js";
+import { trackUsage } from "../services/usage-tracker.js";
+/** React to a message with an emoji. Silently fails if reactions aren't supported. */
+async function react(ctx, emoji) {
+    try {
+        await ctx.react(emoji);
+    }
+    catch {
+        // Reactions not supported in this chat — silently ignore
+    }
+}
+export async function handleMessage(ctx) {
+    const rawText = ctx.message?.text;
+    if (!rawText || rawText.startsWith("/"))
+        return;
+    let text = rawText;
+    // Forwarded message — add forward context (if allowed)
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const msgAny = ctx.message;
+    if (msgAny?.forward_origin || msgAny?.forward_date) {
+        if (!isForwardingAllowed()) {
+            await ctx.reply("⚠️ Weitergeleitete Nachrichten sind deaktiviert. Aktiviere mit `/security forwards on`", { parse_mode: "Markdown" });
+            return;
+        }
+        const forwardFrom = msgAny.forward_sender_name || "unbekannt";
+        text = `[Weitergeleitete Nachricht von ${forwardFrom}]\n\n${rawText}`;
+    }
+    // Reply context — include quoted message
+    const replyTo = ctx.message?.reply_to_message;
+    if (replyTo?.text) {
+        const quotedText = replyTo.text.length > 500
+            ? replyTo.text.slice(0, 500) + "..."
+            : replyTo.text;
+        text = `[Replying to previous message: "${quotedText}"]\n\n${text}`;
+    }
+    const userId = ctx.from.id;
+    const session = getSession(buildSessionKey("telegram", ctx.chat.id, userId));
+    // Track user profile
+    touchProfile(userId, ctx.from?.first_name, ctx.from?.username, "telegram", text);
+    // Sync session language from persistent profile (on first message)
+    if (session.messageCount === 0) {
+        const { loadProfile } = await import("../services/users.js");
+        const profile = loadProfile(userId);
+        if (profile?.language)
+            session.language = profile.language;
+    }
+    if (session.isProcessing) {
+        // Queue the message instead of rejecting it (max 3)
+        if (session.messageQueue.length < 3) {
+            session.messageQueue.push(text);
+            await react(ctx, "📝");
+        }
+        else {
+            await ctx.reply("⏳ Warteschlange voll (3 Nachrichten). Bitte warten oder /cancel.");
+        }
+        return;
+    }
+    // Consume queued messages (sent while previous query was processing)
+    if (session.messageQueue.length > 0) {
+        const queued = session.messageQueue.splice(0);
+        text = [...queued, text].join("\n\n");
+    }
+    session.isProcessing = true;
+    session.abortController = new AbortController();
+    const streamer = new TelegramStreamer(ctx.chat.id, ctx.api, ctx.message?.message_id);
+    let finalText = "";
+    const typingInterval = setInterval(() => {
+        ctx.api.sendChatAction(ctx.chat.id, "typing").catch(() => { });
+    }, 4000);
+    try {
+        // React with 🤔 to show we're thinking
+        await react(ctx, "🤔");
+        await ctx.api.sendChatAction(ctx.chat.id, "typing");
+        session.messageCount++;
+        emit("message:received", { userId, text, platform: "telegram" });
+        // Determine provider type early for compaction check
+        const registry = getRegistry();
+        const activeProvider = registry.getActive();
+        const isSDK = activeProvider.config.type === "claude-sdk";
+        // Auto-compact if needed (non-SDK only)
+        if (!isSDK) {
+            if (shouldCompact(session)) {
+                const result = await compactSession(session);
+                if (result.removedEntries > 0) {
+                    console.log(`Compacted session: removed ${result.removedEntries} entries, flushed=${result.flushedToMemory}`);
+                }
+            }
+        }
+        // Auto-detect and adapt language from user's message
+        const adaptedLang = trackAndAdapt(userId, text, session.language);
+        if (adaptedLang !== session.language) {
+            session.language = adaptedLang;
+        }
+        // Build query options (with semantic memory search for non-SDK + skill injection)
+        const chatIdStr = String(ctx.chat.id);
+        const skillContext = buildSkillContext(text);
+        const systemPrompt = (isSDK
+            ? buildSystemPrompt(isSDK, session.language, chatIdStr)
+            : await buildSmartSystemPrompt(isSDK, session.language, text, chatIdStr)) + skillContext;
+        const queryOpts = {
+            prompt: text,
+            systemPrompt,
+            workingDir: session.workingDir,
+            effort: session.effort,
+            abortSignal: session.abortController.signal,
+            // SDK-specific
+            sessionId: isSDK ? session.sessionId : null,
+            // Non-SDK: include conversation history
+            history: !isSDK ? session.history : undefined,
+            // SDK checkpoint tracking
+            _sessionState: isSDK ? {
+                messageCount: session.messageCount,
+                toolUseCount: session.toolUseCount,
+            } : undefined,
+        };
+        // Add user message to history (for non-SDK providers)
+        if (!isSDK) {
+            addToHistory(userId, { role: "user", content: text });
+        }
+        // Stream response from provider (with fallback)
+        for await (const chunk of registry.queryWithFallback(queryOpts)) {
+            switch (chunk.type) {
+                case "text":
+                    finalText = chunk.text || "";
+                    await streamer.update(finalText);
+                    break;
+                case "tool_use":
+                    // Could show tool activity indicator
+                    if (chunk.toolName) {
+                        session.toolUseCount++;
+                    }
+                    break;
+                case "done":
+                    if (chunk.sessionId)
+                        session.sessionId = chunk.sessionId;
+                    if (chunk.costUsd)
+                        session.totalCost += chunk.costUsd;
+                    trackProviderUsage(userId, registry.getActiveKey(), chunk.costUsd || 0, chunk.inputTokens, chunk.outputTokens);
+                    trackUsage(registry.getActiveKey(), chunk.inputTokens || 0, chunk.outputTokens || 0, chunk.costUsd || 0);
+                    session.lastActivity = Date.now();
+                    break;
+                case "fallback":
+                    await ctx.reply(`⚡ _${chunk.failedProvider} unavailable — switching to ${chunk.providerName}_`, { parse_mode: "Markdown" });
+                    break;
+                case "error":
+                    await ctx.reply(`Error: ${chunk.error}`);
+                    break;
+            }
+        }
+        await streamer.finalize(finalText);
+        emit("message:sent", { userId, text: finalText, platform: "telegram" });
+        // Clear thinking reaction (replace with nothing — message was answered)
+        await react(ctx, "👍");
+        // Add assistant response to history (for non-SDK providers)
+        if (!isSDK && finalText) {
+            addToHistory(userId, { role: "assistant", content: finalText });
+        }
+        // Voice reply if enabled
+        if (session.voiceReply && finalText.trim()) {
+            try {
+                await ctx.api.sendChatAction(ctx.chat.id, "upload_voice");
+                const audioPath = await textToSpeech(finalText);
+                await ctx.replyWithVoice(new InputFile(fs.readFileSync(audioPath), "response.mp3"));
+                fs.unlink(audioPath, () => { });
+            }
+            catch (err) {
+                console.error("TTS error:", err);
+            }
+        }
+    }
+    catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        await react(ctx, "👎");
+        if (errorMsg.includes("abort")) {
+            await ctx.reply("Anfrage abgebrochen.");
+        }
+        else {
+            await ctx.reply(`Error: ${errorMsg}`);
+        }
+    }
+    finally {
+        clearInterval(typingInterval);
+        session.isProcessing = false;
+        session.abortController = null;
+        // Check for queued messages — they'll be prepended to the next real message
+        // Queue stays in session and gets consumed on next handleMessage call
+    }
+}

package/dist/handlers/photo.js

@@ -0,0 +1,154 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+import https from "https";
+/** React to a message with an emoji. Silently fails if not supported. */
+async function react(ctx, emoji) {
+    try {
+        await ctx.react(emoji);
+    }
+    catch { /* ignore */ }
+}
+import { config } from "../config.js";
+import { getSession, addToHistory } from "../services/session.js";
+import { TelegramStreamer } from "../services/telegram.js";
+import { getRegistry } from "../engine.js";
+import { buildSystemPrompt } from "../services/personality.js";
+const TEMP_DIR = path.join(os.tmpdir(), "alvin-bot");
+if (!fs.existsSync(TEMP_DIR)) {
+    fs.mkdirSync(TEMP_DIR, { recursive: true });
+}
+async function downloadFile(url, dest) {
+    return new Promise((resolve, reject) => {
+        const file = fs.createWriteStream(dest);
+        https.get(url, (response) => {
+            response.pipe(file);
+            file.on("finish", () => file.close(() => resolve()));
+        }).on("error", (err) => {
+            fs.unlink(dest, () => { });
+            reject(err);
+        });
+    });
+}
+export async function handlePhoto(ctx) {
+    const photos = ctx.message?.photo;
+    if (!photos || photos.length === 0)
+        return;
+    const userId = ctx.from.id;
+    const session = getSession(userId);
+    if (session.isProcessing) {
+        await ctx.reply("Please wait, previous request still running... (/cancel to abort)");
+        return;
+    }
+    session.isProcessing = true;
+    session.abortController = new AbortController();
+    const streamer = new TelegramStreamer(ctx.chat.id, ctx.api, ctx.message?.message_id);
+    let finalText = "";
+    const typingInterval = setInterval(() => {
+        ctx.api.sendChatAction(ctx.chat.id, "typing").catch(() => { });
+    }, 4000);
+    try {
+        await react(ctx, "👀");
+        await ctx.api.sendChatAction(ctx.chat.id, "typing");
+        // Get highest resolution photo
+        const photo = photos[photos.length - 1];
+        const file = await ctx.api.getFile(photo.file_id);
+        const fileUrl = `https://api.telegram.org/file/bot${config.botToken}/${file.file_path}`;
+        const ext = path.extname(file.file_path || "") || ".jpg";
+        const imagePath = path.join(TEMP_DIR, `photo_${Date.now()}${ext}`);
+        await downloadFile(fileUrl, imagePath);
+        const caption = ctx.message?.caption || "Analysiere dieses Bild.";
+        session.messageCount++;
+        const registry = getRegistry();
+        const activeProvider = registry.getActive();
+        const isSDK = activeProvider.config.type === "claude-sdk";
+        let queryOpts;
+        if (isSDK) {
+            // SDK: pass image path in prompt — SDK's Read tool handles it natively
+            queryOpts = {
+                prompt: `Analysiere dieses Bild: ${imagePath}\n\n${caption}`,
+                systemPrompt: buildSystemPrompt(true, session.language),
+                workingDir: session.workingDir,
+                effort: session.effort,
+                abortSignal: session.abortController.signal,
+                sessionId: session.sessionId,
+                _sessionState: {
+                    messageCount: session.messageCount,
+                    toolUseCount: session.toolUseCount,
+                },
+            };
+        }
+        else {
+            // Non-SDK: encode image as base64 for vision API
+            let imageContent;
+            if (activeProvider.config.supportsVision) {
+                const imageBuffer = fs.readFileSync(imagePath);
+                imageContent = imageBuffer.toString("base64");
+            }
+            else {
+                // No vision support — tell the user
+                imageContent = "";
+            }
+            if (!activeProvider.config.supportsVision) {
+                await ctx.reply(`⚠️ The current model (${activeProvider.config.name}) does not support image analysis. Switch to a vision model with /model.`);
+                return;
+            }
+            addToHistory(userId, {
+                role: "user",
+                content: caption,
+                images: [imageContent],
+            });
+            queryOpts = {
+                prompt: caption,
+                systemPrompt: buildSystemPrompt(false, session.language),
+                workingDir: session.workingDir,
+                effort: session.effort,
+                abortSignal: session.abortController.signal,
+                history: session.history,
+            };
+        }
+        for await (const chunk of registry.queryWithFallback(queryOpts)) {
+            switch (chunk.type) {
+                case "text":
+                    finalText = chunk.text || "";
+                    await streamer.update(finalText);
+                    break;
+                case "tool_use":
+                    if (chunk.toolName)
+                        session.toolUseCount++;
+                    break;
+                case "done":
+                    if (chunk.sessionId)
+                        session.sessionId = chunk.sessionId;
+                    if (chunk.costUsd)
+                        session.totalCost += chunk.costUsd;
+                    session.lastActivity = Date.now();
+                    break;
+                case "error":
+                    await ctx.reply(`Error: ${chunk.error}`);
+                    break;
+            }
+        }
+        await streamer.finalize(finalText);
+        await react(ctx, "👍");
+        if (!isSDK && finalText) {
+            addToHistory(userId, { role: "assistant", content: finalText });
+        }
+        // Clean up temp file
+        fs.unlink(imagePath, () => { });
+    }
+    catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        if (errorMsg.includes("abort")) {
+            await ctx.reply("Anfrage abgebrochen.");
+        }
+        else {
+            await ctx.reply(`Error: ${errorMsg}`);
+        }
+    }
+    finally {
+        clearInterval(typingInterval);
+        session.isProcessing = false;
+        session.abortController = null;
+    }
+}