alvin-bot 4.4.1

package/dist/middleware/auth.js

@@ -0,0 +1,215 @@
+import fs from "fs";
+import { InlineKeyboard } from "grammy";
+import { config } from "../config.js";
+import { APPROVED_USERS_FILE } from "../paths.js";
+import { getGroupStatus, registerGroup, trackGroupMessage, } from "../services/access.js";
+/**
+ * Auth + Group Chat + Access Control middleware.
+ *
+ * Security model:
+ * - DMs: controlled by AUTH_MODE env var
+ *   - "allowlist" (default): only ALLOWED_USERS can interact
+ *   - "pairing": unknown users get a 6-digit code, admin must approve
+ *   - "open": all DMs allowed
+ * - Groups: must be approved by admin + only respond to @mentions/replies
+ * - New groups: sends approval request to admin, stays silent until approved
+ * - Blocked groups: completely ignored
+ * - Forwarded messages: can be disabled globally
+ */
+// ── Approved Users (persistent, for pairing mode) ──────────────────
+function loadApprovedUsers() {
+    try {
+        const raw = fs.readFileSync(APPROVED_USERS_FILE, "utf-8");
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed.map(Number).filter(Boolean) : [];
+    }
+    catch {
+        return [];
+    }
+}
+function saveApprovedUsers(ids) {
+    fs.writeFileSync(APPROVED_USERS_FILE, JSON.stringify(ids, null, 2));
+}
+export function addApprovedUser(userId) {
+    const current = loadApprovedUsers();
+    if (!current.includes(userId)) {
+        current.push(userId);
+        saveApprovedUsers(current);
+    }
+}
+export function isApprovedUser(userId) {
+    return loadApprovedUsers().includes(userId);
+}
+const MAX_PENDING = 3;
+const pendingPairings = new Map(); // code → pairing
+function generateCode() {
+    return String(Math.floor(100000 + Math.random() * 900000));
+}
+function cleanExpired() {
+    const now = Date.now();
+    for (const [code, pairing] of pendingPairings.entries()) {
+        if (pairing.expiresAt <= now) {
+            pendingPairings.delete(code);
+        }
+    }
+}
+/** Get a pending pairing by code. Returns undefined if not found or expired. */
+export function getPendingPairing(code) {
+    const pairing = pendingPairings.get(code);
+    if (!pairing)
+        return undefined;
+    if (pairing.expiresAt <= Date.now()) {
+        pendingPairings.delete(code);
+        return undefined;
+    }
+    return pairing;
+}
+/** Remove a pending pairing by code. */
+export function removePendingPairing(code) {
+    const pairing = pendingPairings.get(code);
+    pendingPairings.delete(code);
+    return pairing;
+}
+// ── Middleware ───────────────────────────────────────────────────────
+export async function authMiddleware(ctx, next) {
+    const userId = ctx.from?.id;
+    const chatType = ctx.chat?.type;
+    const isGroup = chatType === "group" || chatType === "supergroup";
+    // ── DM Auth ─────────────────────────────────────
+    if (chatType === "private") {
+        // "open" mode: allow everyone
+        if (config.authMode === "open") {
+            await next();
+            return;
+        }
+        // Always allow configured users
+        if (userId && config.allowedUsers.includes(userId)) {
+            await next();
+            return;
+        }
+        // "pairing" mode: unknown users go through code-based approval
+        if (config.authMode === "pairing" && userId) {
+            // Already approved via pairing?
+            if (isApprovedUser(userId)) {
+                await next();
+                return;
+            }
+            // Check if user already has a pending pairing (avoid duplicate codes)
+            cleanExpired();
+            const existingEntry = [...pendingPairings.values()].find(p => p.userId === userId);
+            if (existingEntry) {
+                await ctx.reply(`Your approval request is still pending.\n\nYour code: \`${existingEntry.code}\`\n\nAsk the bot admin to approve it.`, { parse_mode: "Markdown" });
+                return;
+            }
+            // Enforce max pending limit
+            if (pendingPairings.size >= MAX_PENDING) {
+                await ctx.reply("The approval queue is currently full. Please try again later.");
+                return;
+            }
+            // Generate pairing code
+            const code = generateCode();
+            const pairing = {
+                userId,
+                username: ctx.from?.username,
+                code,
+                expiresAt: Date.now() + 3_600_000, // 1 hour
+            };
+            pendingPairings.set(code, pairing);
+            // Tell user their code
+            await ctx.reply(`Hi! I need admin approval before we can chat.\n\nSend this code to the bot admin: \`${code}\``, { parse_mode: "Markdown" });
+            // Notify admin with approve/deny inline keyboard
+            const adminId = config.allowedUsers[0];
+            if (adminId) {
+                const keyboard = new InlineKeyboard()
+                    .text("✅ Approve", `pair:approve:${code}`)
+                    .text("❌ Deny", `pair:deny:${code}`);
+                const userTag = pairing.username ? `@${pairing.username}` : `ID ${userId}`;
+                try {
+                    await ctx.api.sendMessage(adminId, `🔔 *New DM Pairing Request*\n\n` +
+                        `*User:* ${userTag}\n` +
+                        `*User ID:* \`${userId}\`\n` +
+                        `*Code:* \`${code}\`\n\n` +
+                        `Approve this user to chat with the bot?`, { parse_mode: "Markdown", reply_markup: keyboard });
+                }
+                catch (err) {
+                    console.error("Failed to send pairing approval request:", err);
+                }
+            }
+            return;
+        }
+        // Default "allowlist" mode (or pairing mode but no userId)
+        console.log(`Unauthorized DM attempt from user ID: ${userId || "unknown"} (username: ${ctx.from?.username || "none"})`);
+        await ctx.reply(`Hi! I'm not set up to chat with you yet.\n\nAsk my admin to add your user ID: ${userId || "unknown"}`);
+        return;
+    }
+    // ── Group Access Control ────────────────────────
+    if (isGroup) {
+        const chatId = ctx.chat.id;
+        const chatTitle = ctx.chat && "title" in ctx.chat ? ctx.chat.title || "Unknown" : "Unknown";
+        // Check group approval status
+        const status = getGroupStatus(chatId);
+        if (status === "blocked") {
+            return; // Completely ignore blocked groups
+        }
+        if (status === "new") {
+            // Register and request approval from admin
+            registerGroup(chatId, chatTitle, userId);
+            // Notify the first allowed user (admin) about the new group
+            const adminId = config.allowedUsers[0];
+            if (adminId) {
+                const keyboard = new InlineKeyboard()
+                    .text("✅ Approve", `access:approve:${chatId}`)
+                    .text("❌ Block", `access:block:${chatId}`);
+                try {
+                    await ctx.api.sendMessage(adminId, `🔔 *New group request*\n\n` +
+                        `*Gruppe:* ${chatTitle}\n` +
+                        `*Chat-ID:* \`${chatId}\`\n` +
+                        `*Added by:* ${userId}\n\n` +
+                        `Soll Alvin Bot in dieser Gruppe antworten?`, { parse_mode: "Markdown", reply_markup: keyboard });
+                }
+                catch (err) {
+                    console.error("Failed to send group approval request:", err);
+                }
+            }
+            return; // Don't respond until approved
+        }
+        if (status === "pending") {
+            return; // Still waiting for approval
+        }
+        // status === "approved" — continue with group logic
+        // Only allowed users can trigger the bot in groups
+        if (!userId || !config.allowedUsers.includes(userId)) {
+            return; // Silently ignore unauthorized users
+        }
+        trackGroupMessage(chatId);
+        const message = ctx.message;
+        if (!message) {
+            await next(); // callback queries
+            return;
+        }
+        // Commands always go through
+        if (message.text?.startsWith("/")) {
+            await next();
+            return;
+        }
+        // Check if bot is mentioned
+        const botUsername = ctx.me?.username?.toLowerCase();
+        const text = message.text || message.caption || "";
+        if (botUsername && text.toLowerCase().includes(`@${botUsername}`)) {
+            if (message.text) {
+                message.text = message.text.replace(new RegExp(`@${botUsername}`, "gi"), "").trim();
+            }
+            await next();
+            return;
+        }
+        // Check if replying to a bot message
+        if (message.reply_to_message?.from?.id === ctx.me?.id) {
+            await next();
+            return;
+        }
+        // Otherwise: ignore in groups
+        return;
+    }
+    // ── Callback queries (inline keyboards) ─────────
+    await next();
+}

package/dist/migrate.js

@@ -0,0 +1,139 @@
+/**
+ * Legacy Data Migration — Copies data from old in-repo locations to ~/.alvin-bot/.
+ *
+ * Old layout (in BOT_ROOT):
+ *   docs/MEMORY.md, docs/memory/, docs/users/, docs/tools.json, docs/cron-jobs.json,
+ *   docs/mcp.json, docs/fallback-order.json, docs/custom-models.json, docs/whatsapp-groups.json
+ *   data/access.json, data/whatsapp-auth/, data/wa-media/, data/.sudo-*
+ *   SOUL.md, TOOLS.md
+ *   backups/
+ *
+ * New layout (in DATA_DIR = ~/.alvin-bot/):
+ *   memory/MEMORY.md, memory/*.md, memory/.embeddings.json
+ *   users/
+ *   data/access.json, data/whatsapp-auth/, data/wa-media/, data/.sudo-*
+ *   soul.md, tools.md, tools.json
+ *   cron-jobs.json, mcp.json, fallback-order.json, custom-models.json, whatsapp-groups.json
+ *   backups/
+ *
+ * Does NOT delete source files — the user can clean up manually.
+ */
+import fs from "fs";
+import { resolve } from "path";
+import { BOT_ROOT, MEMORY_DIR, USERS_DIR, BACKUP_DIR, SOUL_FILE, TOOLS_MD, TOOLS_JSON, CRON_FILE, MCP_CONFIG, FALLBACK_FILE, CUSTOM_MODELS, WA_GROUPS, WHATSAPP_AUTH, WA_MEDIA_DIR, ACCESS_FILE, SUDO_ENC_FILE, SUDO_KEY_FILE, MEMORY_FILE, EMBEDDINGS_IDX } from "./paths.js";
+/**
+ * Check if legacy data exists in the old locations.
+ */
+export function hasLegacyData() {
+    const legacyIndicators = [
+        resolve(BOT_ROOT, "docs", "MEMORY.md"),
+        resolve(BOT_ROOT, "docs", "memory"),
+        resolve(BOT_ROOT, "docs", "users"),
+        resolve(BOT_ROOT, "data", "access.json"),
+        resolve(BOT_ROOT, "SOUL.md"),
+    ];
+    return legacyIndicators.some(p => fs.existsSync(p));
+}
+/**
+ * Copy a file if source exists and destination doesn't.
+ */
+function copyIfNew(src, dest) {
+    if (fs.existsSync(src) && !fs.existsSync(dest)) {
+        const destDir = resolve(dest, "..");
+        if (!fs.existsSync(destDir))
+            fs.mkdirSync(destDir, { recursive: true });
+        fs.copyFileSync(src, dest);
+        return true;
+    }
+    return false;
+}
+/**
+ * Recursively copy a directory if source exists and destination doesn't have the files.
+ */
+function copyDirIfNew(src, dest) {
+    if (!fs.existsSync(src))
+        return 0;
+    if (!fs.existsSync(dest))
+        fs.mkdirSync(dest, { recursive: true });
+    let count = 0;
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = resolve(src, entry.name);
+        const destPath = resolve(dest, entry.name);
+        if (entry.isDirectory()) {
+            count += copyDirIfNew(srcPath, destPath);
+        }
+        else if (!fs.existsSync(destPath)) {
+            try {
+                fs.copyFileSync(srcPath, destPath);
+                count++;
+            }
+            catch {
+                // Source may have vanished between readdir and copy (e.g. WhatsApp session files)
+            }
+        }
+    }
+    return count;
+}
+/**
+ * Migrate all legacy data to the new DATA_DIR.
+ * Returns a summary of what was copied.
+ */
+export function migrateFromLegacy() {
+    const copied = [];
+    const skipped = [];
+    function track(label, result) {
+        if (result)
+            copied.push(label);
+        else
+            skipped.push(label);
+    }
+    // ── Single files ─────────────────────────────────────────
+    // SOUL.md → soul.md
+    track("SOUL.md → soul.md", copyIfNew(resolve(BOT_ROOT, "SOUL.md"), SOUL_FILE));
+    // TOOLS.md → tools.md
+    track("TOOLS.md → tools.md", copyIfNew(resolve(BOT_ROOT, "TOOLS.md"), TOOLS_MD));
+    // docs/tools.json → tools.json
+    track("docs/tools.json", copyIfNew(resolve(BOT_ROOT, "docs", "tools.json"), TOOLS_JSON));
+    // docs/MEMORY.md → memory/MEMORY.md
+    track("docs/MEMORY.md", copyIfNew(resolve(BOT_ROOT, "docs", "MEMORY.md"), MEMORY_FILE));
+    // docs/memory/.embeddings.json → memory/.embeddings.json
+    track(".embeddings.json", copyIfNew(resolve(BOT_ROOT, "docs", "memory", ".embeddings.json"), EMBEDDINGS_IDX));
+    // docs/cron-jobs.json → cron-jobs.json
+    track("cron-jobs.json", copyIfNew(resolve(BOT_ROOT, "docs", "cron-jobs.json"), CRON_FILE));
+    // docs/mcp.json → mcp.json
+    track("mcp.json", copyIfNew(resolve(BOT_ROOT, "docs", "mcp.json"), MCP_CONFIG));
+    // docs/fallback-order.json → fallback-order.json
+    track("fallback-order.json", copyIfNew(resolve(BOT_ROOT, "docs", "fallback-order.json"), FALLBACK_FILE));
+    // docs/custom-models.json → custom-models.json
+    track("custom-models.json", copyIfNew(resolve(BOT_ROOT, "docs", "custom-models.json"), CUSTOM_MODELS));
+    // docs/whatsapp-groups.json → whatsapp-groups.json
+    track("whatsapp-groups.json", copyIfNew(resolve(BOT_ROOT, "docs", "whatsapp-groups.json"), WA_GROUPS));
+    // data/access.json → data/access.json
+    track("data/access.json", copyIfNew(resolve(BOT_ROOT, "data", "access.json"), ACCESS_FILE));
+    // data/.sudo-enc → data/.sudo-enc
+    track("data/.sudo-enc", copyIfNew(resolve(BOT_ROOT, "data", ".sudo-enc"), SUDO_ENC_FILE));
+    track("data/.sudo-key", copyIfNew(resolve(BOT_ROOT, "data", ".sudo-key"), SUDO_KEY_FILE));
+    // ── Directories ──────────────────────────────────────────
+    // docs/memory/*.md → memory/*.md
+    const memCount = copyDirIfNew(resolve(BOT_ROOT, "docs", "memory"), MEMORY_DIR);
+    if (memCount > 0)
+        copied.push(`memory/ (${memCount} files)`);
+    // docs/users/ → users/
+    const usersCount = copyDirIfNew(resolve(BOT_ROOT, "docs", "users"), USERS_DIR);
+    if (usersCount > 0)
+        copied.push(`users/ (${usersCount} files)`);
+    // data/whatsapp-auth/ → data/whatsapp-auth/
+    const waAuthCount = copyDirIfNew(resolve(BOT_ROOT, "data", "whatsapp-auth"), WHATSAPP_AUTH);
+    if (waAuthCount > 0)
+        copied.push(`whatsapp-auth/ (${waAuthCount} files)`);
+    // data/wa-media/ → data/wa-media/
+    const waMediaCount = copyDirIfNew(resolve(BOT_ROOT, "data", "wa-media"), WA_MEDIA_DIR);
+    if (waMediaCount > 0)
+        copied.push(`wa-media/ (${waMediaCount} files)`);
+    // backups/ → backups/
+    const backupCount = copyDirIfNew(resolve(BOT_ROOT, "backups"), BACKUP_DIR);
+    if (backupCount > 0)
+        copied.push(`backups/ (${backupCount} files)`);
+    return { copied: copied.filter(c => !c.includes("false")), skipped };
+}

package/dist/paths.js

@@ -0,0 +1,87 @@
+/**
+ * Centralized Path Registry — Single source of truth for all file paths.
+ *
+ * BOT_ROOT = Code directory (where src/, dist/, plugins/, etc. live)
+ * DATA_DIR = User data directory (~/.alvin-bot by default, override with ALVIN_DATA_DIR)
+ *
+ * All personal/runtime data lives in DATA_DIR (outside the repo).
+ * All code/templates/plugins live in BOT_ROOT (inside the repo).
+ */
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+import os from "os";
+// ── Code Directory (repo root) ─────────────────────────────────────
+export const BOT_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+// ── Data Directory (~/.alvin-bot) ──────────────────────────────────
+export const DATA_DIR = resolve(process.env.ALVIN_DATA_DIR || resolve(os.homedir(), ".alvin-bot"));
+// ── Code paths (BOT_ROOT) ──────────────────────────────────────────
+/** web/public/ — Static assets for Web UI */
+export const PUBLIC_DIR = resolve(BOT_ROOT, "web", "public");
+/** plugins/ — Plugin directory */
+export const PLUGINS_DIR = resolve(BOT_ROOT, "plugins");
+/** skills/ — Skill definitions */
+export const SKILLS_DIR = resolve(BOT_ROOT, "skills");
+/** User skills directory (custom, outside repo) */
+export const USER_SKILLS_DIR = resolve(DATA_DIR, "skills");
+/** .env — Environment config (stays in BOT_ROOT for dev, or DATA_DIR for packaged) */
+export const ENV_FILE = resolve(BOT_ROOT, ".env");
+/** Example/template files (always in repo) */
+export const SOUL_EXAMPLE = resolve(BOT_ROOT, "SOUL.example.md");
+export const TOOLS_EXAMPLE_MD = resolve(BOT_ROOT, "TOOLS.example.md");
+export const TOOLS_EXAMPLE_JSON = resolve(BOT_ROOT, "docs", "tools.example.json");
+// ── Data paths (DATA_DIR = ~/.alvin-bot) ───────────────────────────
+/** memory/ — Daily logs and embeddings */
+export const MEMORY_DIR = resolve(DATA_DIR, "memory");
+/** memory/MEMORY.md — Long-term curated memory */
+export const MEMORY_FILE = resolve(DATA_DIR, "memory", "MEMORY.md");
+/** memory/.embeddings.json — Vector index */
+export const EMBEDDINGS_IDX = resolve(DATA_DIR, "memory", ".embeddings.json");
+/** users/ — User profiles and per-user memory */
+export const USERS_DIR = resolve(DATA_DIR, "users");
+/** data/ — Runtime control data */
+export const RUNTIME_DIR = resolve(DATA_DIR, "data");
+/** data/access.json — Group approval status */
+export const ACCESS_FILE = resolve(DATA_DIR, "data", "access.json");
+/** data/approved-users.json — DM-pairing approved user IDs */
+export const APPROVED_USERS_FILE = resolve(DATA_DIR, "data", "approved-users.json");
+/** data/whatsapp-auth/ — WhatsApp session persistence */
+export const WHATSAPP_AUTH = resolve(DATA_DIR, "data", "whatsapp-auth");
+/** data/wa-media/ — WhatsApp temp media */
+export const WA_MEDIA_DIR = resolve(DATA_DIR, "data", "wa-media");
+/** data/.sudo-enc / .sudo-key — Encrypted sudo password */
+export const SUDO_ENC_FILE = resolve(DATA_DIR, "data", ".sudo-enc");
+export const SUDO_KEY_FILE = resolve(DATA_DIR, "data", ".sudo-key");
+/** backups/ — Config snapshots */
+export const BACKUP_DIR = resolve(DATA_DIR, "backups");
+/** soul.md — Bot personality */
+export const SOUL_FILE = resolve(DATA_DIR, "soul.md");
+/** tools.md — Custom tool definitions (Markdown) */
+export const TOOLS_MD = resolve(DATA_DIR, "tools.md");
+/** tools.json — Custom tool definitions (legacy JSON) */
+export const TOOLS_JSON = resolve(DATA_DIR, "tools.json");
+/** cron-jobs.json — Scheduled tasks */
+export const CRON_FILE = resolve(DATA_DIR, "cron-jobs.json");
+/** mcp.json — MCP server config */
+export const MCP_CONFIG = resolve(DATA_DIR, "mcp.json");
+/** fallback-order.json — Provider fallback chain */
+export const FALLBACK_FILE = resolve(DATA_DIR, "fallback-order.json");
+/** custom-models.json — Custom LLM endpoints */
+export const CUSTOM_MODELS = resolve(DATA_DIR, "custom-models.json");
+/** whatsapp-groups.json — WhatsApp group tracking */
+export const WA_GROUPS = resolve(DATA_DIR, "whatsapp-groups.json");
+/** delivery-queue.json — Reliable message delivery queue */
+export const DELIVERY_QUEUE_FILE = resolve(DATA_DIR, "delivery-queue.json");
+/** AGENTS.md — Standing orders (permanent instructions for every session) */
+export const AGENTS_FILE = resolve(DATA_DIR, "AGENTS.md");
+/** hooks/ — User-defined lifecycle event handlers */
+export const HOOKS_DIR = resolve(DATA_DIR, "hooks");
+/** scripts/browse-server.cjs — HTTP gateway for persistent browser sessions */
+export const BROWSE_SERVER_SCRIPT = resolve(BOT_ROOT, "scripts", "browse-server.cjs");
+/** data/exec-allowlist.json — User-defined exec allowlist */
+export const EXEC_ALLOWLIST_FILE = resolve(DATA_DIR, "exec-allowlist.json");
+/** assets/ — User asset files (CVs, cover letters, legal docs, photos) */
+export const ASSETS_DIR = resolve(DATA_DIR, "assets");
+/** assets/INDEX.json — Machine-readable asset registry */
+export const ASSETS_INDEX_JSON = resolve(DATA_DIR, "assets", "INDEX.json");
+/** assets/INDEX.md — Human-readable asset summary (injected into prompts) */
+export const ASSETS_INDEX_MD = resolve(DATA_DIR, "assets", "INDEX.md");

package/dist/platforms/discord.js

@@ -0,0 +1,161 @@
+/**
+ * Discord Platform Adapter
+ *
+ * Uses discord.js to connect to Discord.
+ * Optional dependency — only loaded if DISCORD_TOKEN is set.
+ *
+ * Setup:
+ * 1. Create a bot at https://discord.com/developers/applications
+ * 2. Enable Message Content Intent
+ * 3. Set DISCORD_TOKEN in .env
+ * 4. Invite bot to server with messages.read + messages.write permissions
+ */
+let _discordState = {
+    status: "disconnected",
+    botName: null,
+    botTag: null,
+    guildCount: 0,
+    connectedAt: null,
+    error: null,
+};
+export function getDiscordState() {
+    return { ..._discordState };
+}
+export class DiscordAdapter {
+    platform = "discord";
+    handler = null;
+    client = null; // discord.js Client (dynamic import)
+    token;
+    constructor(token) {
+        this.token = token;
+    }
+    async start() {
+        try {
+            // Dynamic import — discord.js is optional
+            // @ts-ignore — discord.js is an optional dependency
+            const { Client, GatewayIntentBits } = await import("discord.js");
+            this.client = new Client({
+                intents: [
+                    GatewayIntentBits.Guilds,
+                    GatewayIntentBits.GuildMessages,
+                    GatewayIntentBits.MessageContent,
+                    GatewayIntentBits.DirectMessages,
+                ],
+            });
+            this.client.on("messageCreate", async (msg) => {
+                if (msg.author.bot)
+                    return;
+                if (!this.handler)
+                    return;
+                const isMention = msg.mentions.has(this.client.user);
+                const isReplyToBot = msg.reference?.messageId
+                    ? (await msg.channel.messages.fetch(msg.reference.messageId).catch(() => null))?.author?.id === this.client.user.id
+                    : false;
+                const incoming = {
+                    platform: "discord",
+                    messageId: msg.id,
+                    chatId: msg.channel.id,
+                    userId: msg.author.id,
+                    userName: msg.author.displayName || msg.author.username,
+                    userHandle: msg.author.username,
+                    text: msg.content,
+                    isGroup: msg.guild !== null,
+                    isMention,
+                    isReplyToBot,
+                    replyToText: undefined,
+                };
+                // In servers: only respond to mentions or replies
+                if (msg.guild && !isMention && !isReplyToBot)
+                    return;
+                // Strip mention from text
+                if (isMention) {
+                    incoming.text = incoming.text.replace(/<@!?\d+>/g, "").trim();
+                }
+                await this.handler(incoming);
+            });
+            _discordState.status = "connecting";
+            this.client.on("ready", () => {
+                _discordState.status = "connected";
+                _discordState.botName = this.client.user?.displayName || this.client.user?.username || null;
+                _discordState.botTag = this.client.user?.tag || null;
+                _discordState.guildCount = this.client.guilds.cache.size;
+                _discordState.connectedAt = Date.now();
+            });
+            await this.client.login(this.token);
+            console.log(`🎮 Discord adapter started (${this.client.user?.tag})`);
+        }
+        catch (err) {
+            _discordState.status = "error";
+            _discordState.error = err instanceof Error ? err.message : String(err);
+            console.error("Discord adapter failed to start:", err);
+            throw err;
+        }
+    }
+    async stop() {
+        if (this.client) {
+            this.client.destroy();
+        }
+    }
+    async sendText(chatId, text, options) {
+        if (!this.client)
+            return;
+        const channel = await this.client.channels.fetch(chatId);
+        if (!channel?.isTextBased())
+            return;
+        // Discord max message length is 2000
+        if (text.length > 2000) {
+            // Split into chunks
+            const chunks = text.match(/.{1,1990}/gs) || [text];
+            for (const chunk of chunks) {
+                await channel.send({
+                    content: chunk,
+                    reply: options?.replyTo ? { messageReference: options.replyTo } : undefined,
+                });
+            }
+        }
+        else {
+            await channel.send({
+                content: text,
+                reply: options?.replyTo ? { messageReference: options.replyTo } : undefined,
+            });
+        }
+    }
+    async sendPhoto(chatId, photo, caption) {
+        if (!this.client)
+            return;
+        const channel = await this.client.channels.fetch(chatId);
+        if (!channel?.isTextBased())
+            return;
+        // @ts-ignore — discord.js is an optional dependency
+        const { AttachmentBuilder } = await import("discord.js");
+        const attachment = typeof photo === "string"
+            ? new AttachmentBuilder(photo)
+            : new AttachmentBuilder(photo, { name: "image.png" });
+        await channel.send({ content: caption, files: [attachment] });
+    }
+    async react(chatId, messageId, emoji) {
+        if (!this.client)
+            return;
+        try {
+            const channel = await this.client.channels.fetch(chatId);
+            if (!channel?.isTextBased())
+                return;
+            const msg = await channel.messages.fetch(messageId);
+            await msg.react(emoji);
+        }
+        catch { /* ignore */ }
+    }
+    async setTyping(chatId) {
+        if (!this.client)
+            return;
+        try {
+            const channel = await this.client.channels.fetch(chatId);
+            if (channel?.isTextBased())
+                await channel.sendTyping();
+        }
+        catch { /* ignore */ }
+    }
+    onMessage(handler) {
+        this.handler = handler;
+    }
+}