alvin-bot 4.4.1

package/dist/index.js

@@ -0,0 +1,442 @@
+// ── Bootstrap: ensure ~/.alvin-bot/ exists + migrate legacy data ────
+import { ensureDataDirs, seedDefaults } from "./init-data-dir.js";
+import { hasLegacyData, migrateFromLegacy } from "./migrate.js";
+// 1. Create directory structure (no files yet)
+ensureDataDirs();
+// 2. Migrate legacy data BEFORE seeding defaults (so real data wins over templates)
+if (hasLegacyData()) {
+    console.log("📦 Legacy data detected in repo — migrating to ~/.alvin-bot/ ...");
+    const result = migrateFromLegacy();
+    if (result.copied.length > 0) {
+        console.log(`   Copied: ${result.copied.join(", ")}`);
+    }
+    console.log("   Migration done. Old files left in place (clean up manually).");
+}
+// 3. Seed defaults for any files that don't exist yet (fresh install)
+seedDefaults();
+// ── Normal imports (safe now — DATA_DIR is ready) ──────────────────
+import { Bot, InlineKeyboard } from "grammy";
+import { config } from "./config.js";
+// ── Pre-flight config validation (warnings, not fatal) ──────────────
+const hasTelegram = !!config.botToken;
+let hasProvider = true;
+if (!hasTelegram) {
+    console.warn("⚠️  BOT_TOKEN not set — Telegram disabled. WebUI + Cron still active.");
+    console.warn("   Run 'alvin-bot setup' or set BOT_TOKEN in ~/.alvin-bot/.env");
+}
+if (config.allowedUsers.length === 0 && hasTelegram) {
+    console.warn("⚠️  ALLOWED_USERS not set — nobody can message the Telegram bot yet.");
+    console.warn("   Send /start to @userinfobot on Telegram to find your ID.");
+}
+// Check if the chosen provider has a corresponding API key
+const providerKeyMap = {
+    groq: "GROQ_API_KEY",
+    "nvidia-llama-3.3-70b": "NVIDIA_API_KEY",
+    "nvidia-kimi-k2.5": "NVIDIA_API_KEY",
+    "gemini-2.5-flash": "GOOGLE_API_KEY",
+    openai: "OPENAI_API_KEY",
+    "gpt-4o": "OPENAI_API_KEY",
+    openrouter: "OPENROUTER_API_KEY",
+};
+const requiredKey = providerKeyMap[config.primaryProvider];
+if (requiredKey) {
+    const keyName = requiredKey.replace("_API_KEY", "").toLowerCase();
+    if (!config.apiKeys[keyName]) {
+        hasProvider = false;
+        console.warn(`⚠️  ${requiredKey} is missing — AI chat won't work until configured.`);
+        console.warn(`   Your provider "${config.primaryProvider}" needs this key.`);
+        console.warn(`   Run 'alvin-bot setup' or edit ~/.alvin-bot/.env`);
+    }
+}
+import { authMiddleware, addApprovedUser, removePendingPairing } from "./middleware/auth.js";
+import { registerCommands } from "./handlers/commands.js";
+import { handleMessage } from "./handlers/message.js";
+import { handlePhoto } from "./handlers/photo.js";
+import { handleVoice } from "./handlers/voice.js";
+import { handleDocument } from "./handlers/document.js";
+import { handleVideo } from "./handlers/video.js";
+import { initEngine } from "./engine.js";
+import { loadPlugins, registerPluginCommands, unloadPlugins } from "./services/plugins.js";
+import { initMCP, disconnectMCP, hasMCPConfig } from "./services/mcp.js";
+import { startWebServer } from "./web/server.js";
+import { startScheduler, stopScheduler, setNotifyCallback } from "./services/cron.js";
+import { processQueue, cleanupQueue, setSenders, enqueue } from "./services/delivery-queue.js";
+import { discoverTools } from "./services/tool-discovery.js";
+import { startHeartbeat } from "./services/heartbeat.js";
+import { initEmbeddings } from "./services/embeddings.js";
+import { loadSkills } from "./services/skills.js";
+import { loadHooks } from "./services/hooks.js";
+import { registerShutdownHandler } from "./services/restart.js";
+import { cancelAllSubAgents } from "./services/subagents.js";
+import { scanAssets } from "./services/asset-index.js";
+// Scan asset directory and generate INDEX.json + INDEX.md
+const assetScanResult = scanAssets();
+if (assetScanResult.assets.length > 0) {
+    console.log(`📂 Assets: ${assetScanResult.assets.length} files indexed`);
+}
+// Discover available system tools (cached for prompt injection)
+discoverTools();
+// Load skill files
+loadSkills();
+// Load user-defined lifecycle hooks from ~/.alvin-bot/hooks/
+const hookCount = loadHooks();
+if (hookCount > 0)
+    console.log(`Hooks: ${hookCount} loaded`);
+// Initialize multi-model engine (skip if no provider key)
+let registry = null;
+if (hasProvider) {
+    registry = initEngine();
+    console.log(`Engine initialized. Primary: ${registry.getActiveKey()}`);
+}
+else {
+    console.warn("⚠️  Engine not initialized — no AI provider configured.");
+}
+// Load plugins
+const pluginResult = await loadPlugins();
+if (pluginResult.loaded.length > 0) {
+    console.log(`Plugins loaded: ${pluginResult.loaded.join(", ")}`);
+}
+if (pluginResult.errors.length > 0) {
+    for (const err of pluginResult.errors) {
+        console.error(`Plugin error (${err.name}): ${err.error}`);
+    }
+}
+// Initialize MCP servers (if configured)
+if (hasMCPConfig()) {
+    const mcpResult = await initMCP();
+    if (mcpResult.connected.length > 0) {
+        console.log(`MCP servers: ${mcpResult.connected.join(", ")}`);
+    }
+    if (mcpResult.errors.length > 0) {
+        for (const err of mcpResult.errors) {
+            console.error(`MCP error (${err.name}): ${err.error}`);
+        }
+    }
+}
+// Telegram bot instance (null if no BOT_TOKEN)
+let bot = null;
+if (hasTelegram) {
+    bot = new Bot(config.botToken);
+    // Auth middleware — alle Messages durchlaufen das
+    bot.use(authMiddleware);
+    // Commands registrieren
+    registerCommands(bot);
+    registerPluginCommands(bot);
+    // ── WhatsApp Approval Callbacks ──────────────────────────────────────────────
+    bot.callbackQuery(/^wa:approve:(.+)$/, async (ctx) => {
+        const approvalId = ctx.match[1];
+        const { removePendingApproval, getWhatsAppAdapter } = await import("./platforms/whatsapp.js");
+        const pending = removePendingApproval(approvalId);
+        if (!pending) {
+            await ctx.answerCallbackQuery("⏰ Anfrage abgelaufen");
+            await ctx.editMessageText(ctx.msg?.text + "\n\n⏰ _Abgelaufen_", { parse_mode: "Markdown" }).catch(() => { });
+            return;
+        }
+        await ctx.answerCallbackQuery("✅ Approved");
+        await ctx.editMessageText(ctx.msg?.text + `\n\n✅ Approved`, { parse_mode: "HTML" }).catch(() => { });
+        // Process the message through the platform handler
+        const adapter = getWhatsAppAdapter();
+        if (adapter) {
+            adapter.processApprovedMessage(pending.incoming).catch(err => console.error("WhatsApp approved message processing error:", err));
+        }
+    });
+    bot.callbackQuery(/^wa:deny:(.+)$/, async (ctx) => {
+        const approvalId = ctx.match[1];
+        const { removePendingApproval } = await import("./platforms/whatsapp.js");
+        const pending = removePendingApproval(approvalId);
+        await ctx.answerCallbackQuery("❌ Abgelehnt");
+        await ctx.editMessageText((ctx.msg?.text || "") + `\n\n❌ Abgelehnt`, { parse_mode: "HTML" }).catch(() => { });
+        // Clean up temp media files
+        if (pending?.incoming.media?.path) {
+            const fs = await import("fs");
+            fs.unlink(pending.incoming.media.path, () => { });
+        }
+    });
+    // ── DM Pairing Approval Callbacks ───────────────────────────────────────────
+    bot.callbackQuery(/^pair:(approve|deny):(\d+)$/, async (ctx) => {
+        const action = ctx.match[1];
+        const code = ctx.match[2];
+        const pairing = removePendingPairing(code);
+        if (!pairing) {
+            await ctx.answerCallbackQuery("⏰ Request expired or already handled");
+            await ctx.editMessageText((ctx.msg?.text || "") + "\n\n⏰ _Expired_", { parse_mode: "Markdown" }).catch(() => { });
+            return;
+        }
+        if (action === "approve") {
+            addApprovedUser(pairing.userId);
+            await ctx.answerCallbackQuery("✅ User approved");
+            const userTag = pairing.username ? `@${pairing.username}` : `ID ${pairing.userId}`;
+            await ctx.editMessageText((ctx.msg?.text || "") + `\n\n✅ Approved — ${userTag} can now chat with the bot.`, { parse_mode: "Markdown" }).catch(() => { });
+            // Notify the user they've been approved
+            try {
+                await ctx.api.sendMessage(pairing.userId, "✅ You've been approved! You can now chat with the bot.");
+            }
+            catch { /* user may have blocked the bot */ }
+        }
+        else {
+            await ctx.answerCallbackQuery("❌ User denied");
+            const userTag = pairing.username ? `@${pairing.username}` : `ID ${pairing.userId}`;
+            await ctx.editMessageText((ctx.msg?.text || "") + `\n\n❌ Denied — ${userTag} will not be able to chat.`, { parse_mode: "Markdown" }).catch(() => { });
+            // Notify the user they've been denied
+            try {
+                await ctx.api.sendMessage(pairing.userId, "❌ Your access request was denied by the admin.");
+            }
+            catch { /* user may have blocked the bot */ }
+        }
+    });
+    // Content handlers (Reihenfolge wichtig: spezifisch vor allgemein)
+    bot.on("message:voice", handleVoice);
+    bot.on("message:video", handleVideo);
+    bot.on("message:video_note", handleVideo);
+    bot.on("message:photo", handlePhoto);
+    bot.on("message:document", handleDocument);
+    bot.on("message:text", handleMessage);
+    // Error handling — log but don't crash
+    bot.catch((err) => {
+        const ctx = err.ctx;
+        const e = err.error;
+        console.error(`Error handling update ${ctx?.update?.update_id}:`, e);
+        // Try to notify the user
+        if (ctx?.chat?.id) {
+            ctx.reply("⚠️ An internal error occurred. Please try again.").catch(() => { });
+        }
+    });
+}
+// Delivery queue intervals (started later, cleared on shutdown)
+let queueInterval = null;
+let queueCleanupInterval = null;
+// Graceful shutdown
+let isShuttingDown = false;
+const shutdown = async () => {
+    if (isShuttingDown)
+        return;
+    isShuttingDown = true;
+    console.log("Graceful shutdown initiated...");
+    cancelAllSubAgents();
+    stopScheduler();
+    if (queueInterval)
+        clearInterval(queueInterval);
+    if (queueCleanupInterval)
+        clearInterval(queueCleanupInterval);
+    if (bot)
+        bot.stop();
+    await unloadPlugins().catch(() => { });
+    await disconnectMCP().catch(() => { });
+    console.log("Goodbye! 👋");
+    process.exit(0);
+};
+// Register for graceful self-restart (used by tool-executor when AI triggers restart)
+registerShutdownHandler(shutdown);
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
+process.on("uncaughtException", (err) => {
+    console.error("Uncaught exception:", err);
+    // Don't exit on uncaught exceptions — try to keep running
+});
+process.on("unhandledRejection", (reason) => {
+    console.error("Unhandled rejection:", reason);
+});
+// Start optional platform adapters via Platform Manager
+async function startOptionalPlatforms() {
+    const { handlePlatformMessage } = await import("./handlers/platform-message.js");
+    const { autoLoadPlatforms, startAllAdapters, getAllAdapters } = await import("./platforms/index.js");
+    const loaded = await autoLoadPlatforms();
+    if (loaded.length > 0) {
+        await startAllAdapters(async (msg) => {
+            const adapter = getAllAdapters().find(a => a.platform === msg.platform);
+            if (adapter)
+                await handlePlatformMessage(msg, adapter);
+        });
+        const icons = { whatsapp: "📱", discord: "🎮", signal: "🔒" };
+        for (const p of loaded) {
+            console.log(`${icons[p] || "📡"} ${p.charAt(0).toUpperCase() + p.slice(1)} platform started`);
+        }
+        // Wire WhatsApp approval flow — routes to best available channel
+        if (loaded.includes("whatsapp") && bot) {
+            const { setApprovalRequestFn, setApprovalChannel, getWhatsAppAdapter } = await import("./platforms/whatsapp.js");
+            const telegramBot = bot; // capture for closure
+            setApprovalRequestFn(async (pending) => {
+                const mediaTag = pending.mediaType ? ` [${pending.mediaType}]` : "";
+                // ── Strategy: Try Telegram first → fallback to WhatsApp DM → Discord → Signal
+                let sent = false;
+                // 1. Telegram (preferred — has inline keyboards)
+                if (!sent && config.botToken && config.allowedUsers.length > 0) {
+                    try {
+                        const ownerChatId = config.allowedUsers[0];
+                        const msgText = `💬 <b>WhatsApp Approval</b>\n\n` +
+                            `<b>Gruppe:</b> ${pending.groupName}\n` +
+                            `<b>Von:</b> ${pending.senderName} (+${pending.senderNumber})\n` +
+                            `<b>Message:</b>${mediaTag}\n` +
+                            `<blockquote>${pending.preview || "(no text)"}</blockquote>`;
+                        const keyboard = new InlineKeyboard()
+                            .text("✅ Approve", `wa:approve:${pending.id}`)
+                            .text("❌ Ablehnen", `wa:deny:${pending.id}`);
+                        await telegramBot.api.sendMessage(ownerChatId, msgText, {
+                            parse_mode: "HTML",
+                            reply_markup: keyboard,
+                        });
+                        setApprovalChannel("telegram");
+                        sent = true;
+                    }
+                    catch (err) {
+                        console.warn("Approval via Telegram failed, trying fallback:", err instanceof Error ? err.message : err);
+                    }
+                }
+                // 2. WhatsApp DM (self-chat) — text-based approval
+                if (!sent) {
+                    try {
+                        const adapter = getWhatsAppAdapter();
+                        const ownerWaId = adapter?.getOwnerChatId();
+                        if (adapter && ownerWaId) {
+                            const plainText = `🔐 *WhatsApp Approval*\n\n` +
+                                `*Gruppe:* ${pending.groupName}\n` +
+                                `*Von:* ${pending.senderName} (+${pending.senderNumber})\n` +
+                                `*Message:*${mediaTag}\n` +
+                                `> ${pending.preview || "(no text)"}\n\n` +
+                                `Antworte *ok* oder *nein*`;
+                            await adapter.sendText(ownerWaId, plainText);
+                            setApprovalChannel("whatsapp");
+                            sent = true;
+                        }
+                    }
+                    catch (err) {
+                        console.warn("Approval via WhatsApp DM failed, trying fallback:", err instanceof Error ? err.message : err);
+                    }
+                }
+                // 3. Discord DM
+                if (!sent) {
+                    try {
+                        const { getAdapter } = await import("./platforms/index.js");
+                        const discord = getAdapter("discord");
+                        if (discord) {
+                            await discord.sendText("owner", `🔐 WhatsApp Approval\n\nGroup: ${pending.groupName}\nFrom: ${pending.senderName} (+${pending.senderNumber})\nMessage:${mediaTag}\n> ${pending.preview || "(no text)"}\n\nReact with ✅ or ❌`);
+                            setApprovalChannel("discord");
+                            sent = true;
+                        }
+                    }
+                    catch { /* Discord not available */ }
+                }
+                // 4. Signal
+                if (!sent) {
+                    try {
+                        const { getAdapter } = await import("./platforms/index.js");
+                        const signal = getAdapter("signal");
+                        if (signal) {
+                            await signal.sendText("owner", `🔐 WhatsApp Approval\n\nGroup: ${pending.groupName}\nFrom: ${pending.senderName}\nMessage: ${pending.preview || "(no text)"}\n\nReply ok or no`);
+                            setApprovalChannel("signal");
+                            sent = true;
+                        }
+                    }
+                    catch { /* Signal not available */ }
+                }
+                if (!sent) {
+                    console.error("❌ No channel available for WhatsApp approval! Auto-denying.");
+                }
+            });
+        }
+    }
+}
+startOptionalPlatforms().catch(err => console.error("Platform startup error:", err));
+// Start Web UI (ALWAYS — regardless of Telegram/AI config)
+const webServer = startWebServer();
+// Start Cron Scheduler — route notifications through delivery queue for reliability
+setNotifyCallback(async (target, text) => {
+    if (target.platform === "web") {
+        // Web notifications are handled by the WebSocket clients polling cron status
+        return;
+    }
+    enqueue(target.platform, String(target.chatId), text);
+});
+startScheduler();
+// Wire delivery queue senders
+setSenders({
+    telegram: async (chatId, content) => {
+        if (!bot)
+            throw new Error("Telegram bot not initialized");
+        await bot.api.sendMessage(Number(chatId), content, { parse_mode: "Markdown" }).catch(() => bot.api.sendMessage(Number(chatId), content));
+    },
+    whatsapp: async (chatId, content) => {
+        const { getAdapter } = await import("./platforms/index.js");
+        const adapter = getAdapter("whatsapp");
+        if (adapter) {
+            await adapter.sendText(chatId, content);
+        }
+        else {
+            throw new Error("WhatsApp adapter not loaded");
+        }
+    },
+    discord: async (chatId, content) => {
+        const { getAdapter } = await import("./platforms/index.js");
+        const adapter = getAdapter("discord");
+        if (adapter) {
+            await adapter.sendText(chatId, content);
+        }
+        else {
+            throw new Error("Discord adapter not loaded");
+        }
+    },
+    slack: async (chatId, content) => {
+        const { getAdapter } = await import("./platforms/index.js");
+        const adapter = getAdapter("slack");
+        if (adapter) {
+            await adapter.sendText(chatId, content);
+        }
+        else {
+            throw new Error("Slack adapter not loaded");
+        }
+    },
+    signal: async (chatId, content) => {
+        const { getAdapter } = await import("./platforms/index.js");
+        const adapter = getAdapter("signal");
+        if (adapter) {
+            await adapter.sendText(chatId, content);
+        }
+        else {
+            throw new Error("Signal adapter not loaded");
+        }
+    },
+});
+// Start delivery queue processor (30s interval)
+queueInterval = setInterval(async () => {
+    try {
+        await processQueue();
+    }
+    catch (err) {
+        console.error("Delivery queue error:", err);
+    }
+}, 30000);
+// Cleanup old entries every hour
+queueCleanupInterval = setInterval(() => {
+    try {
+        cleanupQueue();
+    }
+    catch (err) {
+        console.error("Queue cleanup error:", err);
+    }
+}, 3600000);
+// Start Telegram polling (if configured)
+import { setTelegramConnected } from "./platforms/telegram.js";
+if (bot) {
+    await bot.start({
+        drop_pending_updates: true,
+        onStart: () => {
+            const me = bot.botInfo;
+            setTelegramConnected(me.first_name, me.username);
+            console.log(`🤖 Alvin Bot started (@${me.username})`);
+            console.log(`   Provider: ${registry?.getActiveKey() || "none"}`);
+            console.log(`   Users: ${config.allowedUsers.length} authorized`);
+            // Start heartbeat monitor
+            startHeartbeat();
+            // Index memory vectors in background (non-blocking)
+            initEmbeddings().catch(() => { });
+        },
+    });
+}
+else {
+    console.log(`🤖 Alvin Bot started (WebUI-only mode)`);
+    console.log(`   Provider: ${registry?.getActiveKey() || "none"}`);
+    console.log(`   WebUI: http://localhost:${process.env.WEB_PORT || 3100}`);
+    // Start heartbeat monitor even without Telegram
+    startHeartbeat();
+    initEmbeddings().catch(() => { });
+}

package/dist/init-data-dir.js

@@ -0,0 +1,81 @@
+/**
+ * Data Directory Bootstrap — Ensures ~/.alvin-bot/ exists with all required structure.
+ *
+ * Called as the very first thing at bot startup, before any service imports.
+ * Idempotent — safe to call multiple times.
+ */
+import fs from "fs";
+import { DATA_DIR, MEMORY_DIR, USERS_DIR, RUNTIME_DIR, WHATSAPP_AUTH, BACKUP_DIR, SOUL_FILE, TOOLS_MD, TOOLS_JSON, CRON_FILE, MCP_CONFIG, FALLBACK_FILE, CUSTOM_MODELS, WA_GROUPS, SOUL_EXAMPLE, TOOLS_EXAMPLE_MD, TOOLS_EXAMPLE_JSON, WA_MEDIA_DIR, DELIVERY_QUEUE_FILE, AGENTS_FILE, HOOKS_DIR, USER_SKILLS_DIR, APPROVED_USERS_FILE } from "./paths.js";
+/**
+ * Create the directory structure only (no file seeding).
+ * Must run BEFORE migration so directories exist for copying.
+ */
+export function ensureDataDirs() {
+    const dirs = [
+        DATA_DIR,
+        MEMORY_DIR,
+        USERS_DIR,
+        RUNTIME_DIR,
+        WHATSAPP_AUTH,
+        WA_MEDIA_DIR,
+        BACKUP_DIR,
+        HOOKS_DIR,
+        USER_SKILLS_DIR,
+    ];
+    for (const dir of dirs) {
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+    }
+}
+/**
+ * Seed default files for a fresh install (only if they don't exist yet).
+ * Must run AFTER migration so legacy data takes priority over templates.
+ */
+export function seedDefaults() {
+    // SOUL.md — copy from example template if available
+    if (!fs.existsSync(SOUL_FILE)) {
+        if (fs.existsSync(SOUL_EXAMPLE)) {
+            fs.copyFileSync(SOUL_EXAMPLE, SOUL_FILE);
+        }
+        else {
+            fs.writeFileSync(SOUL_FILE, "# Bot Personality\n\nYou are a direct, lightly sarcastic, and genuinely helpful AI assistant.\nYou have opinions, you verify your work, and you don't pad answers with filler.\nMirror the user's language naturally.\n");
+        }
+    }
+    // TOOLS.md — copy from example template if available
+    if (!fs.existsSync(TOOLS_MD)) {
+        if (fs.existsSync(TOOLS_EXAMPLE_MD)) {
+            fs.copyFileSync(TOOLS_EXAMPLE_MD, TOOLS_MD);
+        }
+    }
+    // tools.json (legacy) — copy from example if available
+    if (!fs.existsSync(TOOLS_JSON)) {
+        if (fs.existsSync(TOOLS_EXAMPLE_JSON)) {
+            fs.copyFileSync(TOOLS_EXAMPLE_JSON, TOOLS_JSON);
+        }
+    }
+    // Empty JSON defaults
+    const jsonDefaults = [
+        [CRON_FILE, "[]"],
+        [DELIVERY_QUEUE_FILE, "[]"],
+        [CUSTOM_MODELS, "[]"],
+        [APPROVED_USERS_FILE, "[]"],
+        [WA_GROUPS, '{"groups":[]}'],
+        [FALLBACK_FILE, ""], // Empty = use env defaults
+        [MCP_CONFIG, ""], // Empty = no MCP servers
+    ];
+    for (const [file, defaultContent] of jsonDefaults) {
+        if (!fs.existsSync(file) && defaultContent) {
+            fs.writeFileSync(file, defaultContent);
+        }
+    }
+    // MEMORY.md — seed with empty template
+    const memoryFile = `${MEMORY_DIR}/MEMORY.md`;
+    if (!fs.existsSync(memoryFile)) {
+        fs.writeFileSync(memoryFile, "# Long-term Memory\n\n> This file is your agent's long-term memory. Add important context here.\n");
+    }
+    // AGENTS.md — seed with default standing orders template
+    if (!fs.existsSync(AGENTS_FILE)) {
+        fs.writeFileSync(AGENTS_FILE, "# Standing Orders\n\n> Permanent instructions that apply to every session.\n> Edit this file to add rules, workflows, or recurring tasks.\n");
+    }
+}