alvin-bot 4.4.1

package/dist/services/heartbeat.js

@@ -0,0 +1,192 @@
+/**
+ * Heartbeat Service — Provider health monitoring with auto-failover.
+ *
+ * Periodically pings providers (tiny completion request) to detect outages.
+ * If the primary provider fails, auto-switches to the first healthy fallback.
+ * When the primary recovers, switches back automatically.
+ *
+ * The heartbeat provider (Groq by default) is always registered as the
+ * last-resort fallback — free, fast, reliable.
+ */
+import { getRegistry } from "../engine.js";
+import { config } from "../config.js";
+// ── Configuration ───────────────────────────────────────────────────────────
+const HEARTBEAT_INTERVAL_MS = 5 * 60 * 1000; // Check every 5 minutes
+const HEARTBEAT_TIMEOUT_MS = 15_000; // 15s timeout per check
+const FAIL_THRESHOLD = 2; // Switch after 2 consecutive failures
+const RECOVERY_THRESHOLD = 1; // Switch back after 1 success
+// Default heartbeat/fallback provider (free, no key needed for check)
+const HEARTBEAT_PROVIDER = "groq";
+// ── State ───────────────────────────────────────────────────────────────────
+const state = {
+    providers: new Map(),
+    intervalId: null,
+    isRunning: false,
+    originalPrimary: "",
+    wasFailedOver: false,
+};
+// ── Public API ──────────────────────────────────────────────────────────────
+/**
+ * Start the heartbeat monitor.
+ */
+export function startHeartbeat() {
+    if (state.isRunning)
+        return;
+    const registry = getRegistry();
+    state.originalPrimary = registry.getActiveKey();
+    state.isRunning = true;
+    // Initial health state for all providers
+    const allProviders = registry;
+    // We'll check providers in the fallback chain
+    const chain = [
+        config.primaryProvider,
+        ...config.fallbackProviders,
+    ].filter((v, i, a) => a.indexOf(v) === i); // dedupe
+    for (const key of chain) {
+        state.providers.set(key, {
+            key,
+            healthy: true, // assume healthy until proven otherwise
+            lastCheck: 0,
+            lastLatencyMs: 0,
+            failCount: 0,
+        });
+    }
+    console.log(`💓 Heartbeat monitor started (${HEARTBEAT_INTERVAL_MS / 1000}s interval, ${chain.length} providers)`);
+    // Run first check after 30s (let bot fully start)
+    setTimeout(() => {
+        runHeartbeat();
+        state.intervalId = setInterval(runHeartbeat, HEARTBEAT_INTERVAL_MS);
+    }, 30_000);
+}
+/**
+ * Stop the heartbeat monitor.
+ */
+export function stopHeartbeat() {
+    if (state.intervalId) {
+        clearInterval(state.intervalId);
+        state.intervalId = null;
+    }
+    state.isRunning = false;
+    console.log("💓 Heartbeat monitor stopped");
+}
+/**
+ * Get current health status of all monitored providers.
+ */
+export function getHealthStatus() {
+    return Array.from(state.providers.values()).map(p => ({
+        key: p.key,
+        healthy: p.healthy,
+        latencyMs: p.lastLatencyMs,
+        failCount: p.failCount,
+        lastCheck: p.lastCheck ? new Date(p.lastCheck).toISOString() : "never",
+        lastError: p.lastError,
+    }));
+}
+/**
+ * Get the fallback order (user-configurable).
+ */
+export function getFallbackOrder() {
+    return config.fallbackProviders;
+}
+/**
+ * Whether we're currently failed over from the primary.
+ */
+export function isFailedOver() {
+    return state.wasFailedOver;
+}
+// ── Internal ────────────────────────────────────────────────────────────────
+async function runHeartbeat() {
+    const registry = getRegistry();
+    for (const [key, health] of state.providers) {
+        const provider = registry.get(key);
+        if (!provider)
+            continue;
+        const start = Date.now();
+        try {
+            // Quick availability check first
+            const available = await Promise.race([
+                provider.isAvailable(),
+                new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), HEARTBEAT_TIMEOUT_MS)),
+            ]);
+            if (!available) {
+                throw new Error("Provider reported unavailable");
+            }
+            // Tiny completion request to verify actual functionality
+            const testResult = await Promise.race([
+                pingProvider(provider, key),
+                new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), HEARTBEAT_TIMEOUT_MS)),
+            ]);
+            // Success
+            health.healthy = true;
+            health.lastLatencyMs = Date.now() - start;
+            health.lastCheck = Date.now();
+            health.lastError = undefined;
+            // Recovery check: if primary was down and is back
+            if (health.failCount > 0) {
+                console.log(`💓 ${key}: recovered (${health.lastLatencyMs}ms)`);
+            }
+            health.failCount = 0;
+        }
+        catch (err) {
+            health.failCount++;
+            health.lastLatencyMs = Date.now() - start;
+            health.lastCheck = Date.now();
+            health.lastError = err instanceof Error ? err.message : String(err);
+            if (health.failCount >= FAIL_THRESHOLD) {
+                health.healthy = false;
+                console.log(`💓 ❌ ${key}: unhealthy (${health.failCount} failures: ${health.lastError})`);
+            }
+            else {
+                console.log(`💓 ⚠️ ${key}: failure ${health.failCount}/${FAIL_THRESHOLD} (${health.lastError})`);
+            }
+        }
+    }
+    // Auto-failover logic
+    handleFailover(registry);
+}
+async function pingProvider(provider, key) {
+    // For CLI-based providers, just check availability (no full query needed)
+    if (key === "claude-sdk" || key === "codex-cli") {
+        const available = await provider.isAvailable();
+        return available ? "ok" : "unavailable";
+    }
+    // For OpenAI-compatible: tiny completion
+    let text = "";
+    for await (const chunk of provider.query({
+        prompt: "Hi",
+        systemPrompt: "Reply with exactly: ok",
+        history: [],
+    })) {
+        if (chunk.type === "text")
+            text = chunk.text;
+        if (chunk.type === "done")
+            return text || "ok";
+        if (chunk.type === "error")
+            throw new Error(chunk.error);
+    }
+    return text || "ok";
+}
+function handleFailover(registry) {
+    const primaryHealth = state.providers.get(state.originalPrimary);
+    const currentKey = registry.getActiveKey();
+    // Case 1: Primary is down → switch to first healthy fallback
+    if (primaryHealth && !primaryHealth.healthy && currentKey === state.originalPrimary) {
+        const fallbackOrder = config.fallbackProviders;
+        for (const fbKey of fallbackOrder) {
+            const fbHealth = state.providers.get(fbKey);
+            if (fbHealth?.healthy) {
+                console.log(`💓 🔄 Auto-failover: ${state.originalPrimary} → ${fbKey}`);
+                registry.switchTo(fbKey);
+                state.wasFailedOver = true;
+                return;
+            }
+        }
+        console.log("💓 ⚠️ All providers unhealthy — staying on primary");
+    }
+    // Case 2: Primary recovered → switch back
+    if (primaryHealth?.healthy && state.wasFailedOver && currentKey !== state.originalPrimary) {
+        console.log(`💓 ✅ Primary recovered — switching back to ${state.originalPrimary}`);
+        registry.switchTo(state.originalPrimary);
+        state.wasFailedOver = false;
+    }
+}

package/dist/services/hooks.js

@@ -0,0 +1,44 @@
+import { readdirSync, existsSync } from "fs";
+import { resolve } from "path";
+import { HOOKS_DIR } from "../paths.js";
+const registry = [];
+export function registerHook(hook) {
+    registry.push(hook);
+}
+export async function emit(event, payload = {}) {
+    const handlers = registry.filter(h => h.event === event);
+    for (const h of handlers) {
+        try {
+            await h.handler({ ...payload, _event: event, _timestamp: Date.now() });
+        }
+        catch (err) {
+            console.error(`Hook error (${h.name}/${event}):`, err);
+        }
+    }
+}
+export function loadHooks() {
+    if (!existsSync(HOOKS_DIR))
+        return 0;
+    const files = readdirSync(HOOKS_DIR).filter(f => f.endsWith(".js") || f.endsWith(".mjs"));
+    let loaded = 0;
+    for (const file of files) {
+        try {
+            const hookPath = resolve(HOOKS_DIR, file);
+            // Use dynamic import for ESM modules
+            import(hookPath).then(mod => {
+                if (mod.event && typeof mod.handler === "function") {
+                    registerHook({ event: mod.event, name: file, handler: mod.handler });
+                    console.log(`Hook loaded: ${file} → ${mod.event}`);
+                }
+            }).catch(err => console.error(`Failed to load hook ${file}:`, err));
+            loaded++;
+        }
+        catch (err) {
+            console.error(`Failed to load hook ${file}:`, err);
+        }
+    }
+    return loaded;
+}
+export function getRegisteredHooks() {
+    return registry.map(h => ({ event: h.event, name: h.name }));
+}

package/dist/services/imagegen.js

@@ -0,0 +1,72 @@
+/**
+ * Image Generation Service — Generate images via Gemini (Nano Banana Pro).
+ *
+ * Uses Google's generativelanguage API with responseModalities: IMAGE.
+ * Requires GOOGLE_API_KEY in .env.
+ */
+import fs from "fs";
+import path from "path";
+import os from "os";
+const TEMP_DIR = path.join(os.tmpdir(), "alvin-bot");
+if (!fs.existsSync(TEMP_DIR))
+    fs.mkdirSync(TEMP_DIR, { recursive: true });
+const MODEL = "gemini-2.0-flash-exp"; // Free tier image gen model
+const API_URL = "https://generativelanguage.googleapis.com/v1beta/models";
+/**
+ * Generate an image from a text prompt using Gemini.
+ */
+export async function generateImage(prompt, apiKey) {
+    if (!apiKey) {
+        return { success: false, error: "GOOGLE_API_KEY not configured" };
+    }
+    try {
+        const url = `${API_URL}/${MODEL}:generateContent?key=${apiKey}`;
+        const response = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                contents: [{
+                        parts: [{ text: `Generate an image: ${prompt}` }],
+                    }],
+                generationConfig: {
+                    responseModalities: ["IMAGE", "TEXT"],
+                },
+            }),
+        });
+        if (!response.ok) {
+            const errText = await response.text().catch(() => "Unknown error");
+            return { success: false, error: `Gemini API error (${response.status}): ${errText}` };
+        }
+        const data = await response.json();
+        // Extract image from response
+        const parts = data.candidates?.[0]?.content?.parts;
+        if (!parts) {
+            return { success: false, error: "No response from Gemini" };
+        }
+        for (const part of parts) {
+            if (part.inlineData?.data) {
+                const ext = part.inlineData.mimeType === "image/png" ? ".png" : ".jpg";
+                const filePath = path.join(TEMP_DIR, `gen_${Date.now()}${ext}`);
+                const buffer = Buffer.from(part.inlineData.data, "base64");
+                fs.writeFileSync(filePath, buffer);
+                return {
+                    success: true,
+                    filePath,
+                    mimeType: part.inlineData.mimeType,
+                };
+            }
+        }
+        // Check if there's a text response explaining why no image was generated
+        const textPart = parts.find(p => p.text);
+        return {
+            success: false,
+            error: textPart?.text || "No image generated",
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            error: `Image generation failed: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+}

package/dist/services/language-detect.js

@@ -0,0 +1,144 @@
+/**
+ * Language Detection & Auto-Adaptation Service
+ *
+ * Detects the language of incoming messages using keyword heuristics,
+ * tracks usage statistics per user, and auto-adapts the preferred language
+ * when a clear pattern emerges.
+ *
+ * No external APIs — lightweight, fast, runs on every message.
+ */
+import { loadProfile, saveProfile } from "./users.js";
+// ── Detection Heuristics ─────────────────────────────────
+// Common words that strongly indicate a language
+const DE_MARKERS = new Set([
+    // Articles, pronouns, prepositions
+    "ich", "du", "er", "sie", "wir", "ihr", "ein", "eine", "der", "die", "das",
+    "den", "dem", "des", "ist", "sind", "hat", "haben", "wird", "werden",
+    "nicht", "und", "oder", "aber", "auch", "noch", "schon", "nur", "sehr",
+    "mit", "von", "für", "auf", "aus", "bei", "nach", "über", "unter",
+    "kann", "muss", "soll", "will", "möchte", "bitte", "danke", "ja", "nein",
+    "wie", "was", "wer", "wo", "wann", "warum", "welche", "welcher",
+    "diese", "dieser", "dieses", "jetzt", "hier", "dort", "heute", "morgen",
+    "hallo", "guten", "morgen", "abend", "nacht", "tschüss", "mach", "mache",
+    "kannst", "könntest", "würde", "würdest", "gibt", "gib", "zeig", "sag",
+    "mir", "dir", "uns", "euch", "mein", "dein", "sein", "kein", "keine",
+    "alle", "alles", "etwas", "nichts", "viel", "mehr", "wenig", "gut",
+    "neue", "neuen", "neues", "ersten", "letzten", "nächsten",
+]);
+const EN_MARKERS = new Set([
+    // Articles, pronouns, prepositions
+    "the", "is", "are", "was", "were", "have", "has", "had", "will", "would",
+    "can", "could", "should", "must", "shall", "may", "might",
+    "not", "and", "but", "also", "still", "already", "only", "very",
+    "with", "from", "for", "about", "into", "through", "between",
+    "this", "that", "these", "those", "here", "there", "now", "then",
+    "what", "who", "where", "when", "why", "which", "how",
+    "please", "thanks", "thank", "yes", "hello", "hey", "bye",
+    "you", "your", "my", "his", "her", "our", "their",
+    "some", "any", "every", "all", "each", "many", "much", "more",
+    "just", "really", "actually", "right", "well", "sure", "okay",
+    "want", "need", "know", "think", "make", "give", "show", "tell",
+    "new", "first", "last", "next", "good", "great",
+    "create", "delete", "update", "send", "check", "find", "search",
+    "daily", "weekly", "summary", "list", "file", "open", "close",
+    "start", "stop", "run", "set", "get", "add", "remove",
+]);
+/**
+ * Detect the language of a text message.
+ * Returns 'de', 'en', or 'unknown'.
+ */
+export function detectLanguage(text) {
+    if (!text || text.length < 3)
+        return "unknown";
+    // Skip commands, URLs, code blocks
+    const cleaned = text
+        .replace(/^\/\w+/g, "") // remove /commands
+        .replace(/https?:\/\/\S+/g, "") // remove URLs
+        .replace(/```[\s\S]*?```/g, "") // remove code blocks
+        .replace(/`[^`]+`/g, "") // remove inline code
+        .toLowerCase();
+    const words = cleaned.split(/[\s,.!?;:()[\]{}'"]+/).filter(w => w.length >= 2);
+    if (words.length < 2)
+        return "unknown";
+    let deScore = 0;
+    let enScore = 0;
+    for (const word of words) {
+        if (DE_MARKERS.has(word))
+            deScore++;
+        if (EN_MARKERS.has(word))
+            enScore++;
+    }
+    // Umlauts are a very strong German signal
+    if (/[äöüß]/i.test(cleaned))
+        deScore += 3;
+    const total = deScore + enScore;
+    if (total < 2)
+        return "unknown"; // too few signals
+    if (deScore > enScore * 1.3)
+        return "de";
+    if (enScore > deScore * 1.3)
+        return "en";
+    return "unknown"; // ambiguous
+}
+/**
+ * Update language statistics for a user and auto-adapt if pattern is clear.
+ * Returns the recommended language for this session.
+ */
+export function trackAndAdapt(userId, text, currentSessionLang) {
+    const profile = loadProfile(userId);
+    if (!profile)
+        return currentSessionLang;
+    // If user explicitly set language, don't auto-switch
+    if (profile.langExplicit)
+        return profile.language;
+    const detected = detectLanguage(text);
+    if (detected === "unknown")
+        return currentSessionLang;
+    // Initialize langStats if missing (existing profiles)
+    if (!profile.langStats) {
+        profile.langStats = { de: 0, en: 0, other: 0 };
+    }
+    // Update stats
+    profile.langStats[detected]++;
+    const total = profile.langStats.de + profile.langStats.en;
+    // Auto-adapt after enough signal (at least 3 messages)
+    if (total >= 3) {
+        const deRatio = profile.langStats.de / total;
+        const enRatio = profile.langStats.en / total;
+        let newLang = profile.language;
+        if (deRatio >= 0.6)
+            newLang = "de";
+        else if (enRatio >= 0.6)
+            newLang = "en";
+        if (newLang !== profile.language) {
+            profile.language = newLang;
+        }
+    }
+    else {
+        // Early phase: follow immediate language for responsiveness
+        profile.language = detected;
+    }
+    saveProfile(profile);
+    return profile.language;
+}
+/**
+ * Mark language as explicitly set by user (disables auto-detection).
+ */
+export function setExplicitLanguage(userId, lang) {
+    const profile = loadProfile(userId);
+    if (!profile)
+        return;
+    profile.language = lang;
+    profile.langExplicit = true;
+    saveProfile(profile);
+}
+/**
+ * Reset to auto-detection mode.
+ */
+export function resetToAutoLanguage(userId) {
+    const profile = loadProfile(userId);
+    if (!profile)
+        return;
+    profile.langExplicit = false;
+    saveProfile(profile);
+}

package/dist/services/markdown.js

@@ -0,0 +1,63 @@
+/**
+ * Telegram Markdown Sanitizer
+ *
+ * Telegram's Markdown parser is strict — unbalanced markers crash message sending.
+ * This module sanitizes AI-generated markdown to be Telegram-safe.
+ */
+/**
+ * Sanitize markdown for Telegram compatibility.
+ * Fixes common issues:
+ * - Unbalanced bold (*), italic (_), code (`) markers
+ * - Nested formatting that Telegram doesn't support
+ * - Code blocks without closing ```
+ */
+export function sanitizeTelegramMarkdown(text) {
+    if (!text)
+        return text;
+    let result = text;
+    // Fix unclosed code blocks (```)
+    const codeBlockCount = (result.match(/```/g) || []).length;
+    if (codeBlockCount % 2 !== 0) {
+        result += "\n```";
+    }
+    // Fix unclosed inline code (`)
+    // Count backticks outside of code blocks
+    const withoutCodeBlocks = result.replace(/```[\s\S]*?```/g, "");
+    const inlineCodeCount = (withoutCodeBlocks.match(/`/g) || []).length;
+    if (inlineCodeCount % 2 !== 0) {
+        result += "`";
+    }
+    // Fix unbalanced bold markers (*) outside code blocks
+    // Simple approach: count * outside code, close if unbalanced
+    const outsideCode = result.replace(/```[\s\S]*?```/g, "").replace(/`[^`]*`/g, "");
+    const boldCount = (outsideCode.match(/\*/g) || []).length;
+    if (boldCount % 2 !== 0) {
+        // Find the last * and remove it (safer than adding one)
+        const lastStarIdx = result.lastIndexOf("*");
+        if (lastStarIdx >= 0) {
+            result = result.slice(0, lastStarIdx) + result.slice(lastStarIdx + 1);
+        }
+    }
+    // Fix unbalanced italic markers (_) outside code blocks
+    const underscoreCount = (outsideCode.match(/_/g) || []).length;
+    if (underscoreCount % 2 !== 0) {
+        const lastIdx = result.lastIndexOf("_");
+        if (lastIdx >= 0) {
+            result = result.slice(0, lastIdx) + result.slice(lastIdx + 1);
+        }
+    }
+    return result;
+}
+/**
+ * Attempt to send with Markdown, fallback to plain text.
+ * Returns the parse_mode that worked (or undefined for plain).
+ */
+export function getMarkdownSafe(text) {
+    try {
+        const sanitized = sanitizeTelegramMarkdown(text);
+        return { text: sanitized, parseMode: "Markdown" };
+    }
+    catch {
+        return { text, parseMode: undefined };
+    }
+}