alvin-bot 4.4.1

package/dist/platforms/index.js

@@ -0,0 +1,130 @@
+/**
+ * Platform Manager — Load and manage multiple platform adapters.
+ *
+ * Automatically detects which platforms are configured (based on env vars)
+ * and starts the appropriate adapters.
+ *
+ * Env vars:
+ * - BOT_TOKEN → Telegram (always active if set)
+ * - DISCORD_TOKEN → Discord
+ * - WHATSAPP_ENABLED=true → WhatsApp (QR code scan required)
+ * - SLACK_BOT_TOKEN + SLACK_APP_TOKEN → Slack (Socket Mode)
+ * - SIGNAL_API_URL + SIGNAL_NUMBER → Signal
+ */
+const adapters = new Map();
+/**
+ * Register a platform adapter.
+ */
+export function registerAdapter(adapter) {
+    adapters.set(adapter.platform, adapter);
+}
+/**
+ * Get a specific adapter by platform name.
+ */
+export function getAdapter(platform) {
+    return adapters.get(platform);
+}
+/**
+ * Get all registered adapters.
+ */
+export function getAllAdapters() {
+    return Array.from(adapters.values());
+}
+/**
+ * Get platform status for dashboard.
+ */
+export function getPlatformStatus() {
+    return Array.from(adapters.entries()).map(([name, _]) => ({
+        platform: name,
+        active: true,
+    }));
+}
+/**
+ * Auto-detect and load platform adapters based on env vars.
+ * Returns list of loaded platforms.
+ */
+export async function autoLoadPlatforms() {
+    const loaded = [];
+    // Discord
+    const discordToken = process.env.DISCORD_TOKEN;
+    if (discordToken) {
+        try {
+            const { DiscordAdapter } = await import("./discord.js");
+            const adapter = new DiscordAdapter(discordToken);
+            registerAdapter(adapter);
+            loaded.push("discord");
+        }
+        catch (err) {
+            console.error("Discord adapter failed to load:", err);
+        }
+    }
+    // WhatsApp
+    if (process.env.WHATSAPP_ENABLED === "true") {
+        try {
+            const { WhatsAppAdapter } = await import("./whatsapp.js");
+            const adapter = new WhatsAppAdapter();
+            registerAdapter(adapter);
+            loaded.push("whatsapp");
+        }
+        catch (err) {
+            console.error("WhatsApp adapter failed to load:", err);
+        }
+    }
+    // Slack
+    const slackBotToken = process.env.SLACK_BOT_TOKEN;
+    const slackAppToken = process.env.SLACK_APP_TOKEN;
+    if (slackBotToken && slackAppToken) {
+        try {
+            const { SlackAdapter } = await import("./slack.js");
+            const adapter = new SlackAdapter(slackBotToken, slackAppToken);
+            registerAdapter(adapter);
+            loaded.push("slack");
+        }
+        catch (err) {
+            console.error("Slack adapter failed to load:", err);
+        }
+    }
+    // Signal
+    const signalUrl = process.env.SIGNAL_API_URL;
+    const signalNumber = process.env.SIGNAL_NUMBER;
+    if (signalUrl && signalNumber) {
+        try {
+            const { SignalAdapter } = await import("./signal.js");
+            const adapter = new SignalAdapter(signalUrl, signalNumber);
+            registerAdapter(adapter);
+            loaded.push("signal");
+        }
+        catch (err) {
+            console.error("Signal adapter failed to load:", err);
+        }
+    }
+    return loaded;
+}
+/**
+ * Start all registered adapters.
+ */
+export async function startAllAdapters(messageHandler) {
+    for (const [name, adapter] of adapters) {
+        try {
+            adapter.onMessage(messageHandler);
+            await adapter.start();
+        }
+        catch (err) {
+            console.error(`Failed to start ${name} adapter:`, err);
+        }
+    }
+}
+/**
+ * Stop all adapters.
+ */
+export async function stopAllAdapters() {
+    for (const [name, adapter] of adapters) {
+        try {
+            await adapter.stop();
+            console.log(`${name} adapter stopped`);
+        }
+        catch (err) {
+            console.error(`Failed to stop ${name}:`, err);
+        }
+    }
+}

package/dist/platforms/signal.js

@@ -0,0 +1,205 @@
+/**
+ * Signal Platform Adapter
+ *
+ * Uses signal-cli (REST API mode) for Signal messaging.
+ * Optional — only loaded if SIGNAL_API_URL is set.
+ *
+ * Setup:
+ * 1. Run signal-cli in REST API mode:
+ *    docker run -p 8080:8080 bbernhard/signal-cli-rest-api
+ * 2. Register/link a phone number via signal-cli
+ * 3. Set SIGNAL_API_URL=http://localhost:8080 and SIGNAL_NUMBER=+49... in .env
+ */
+import fs from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+let _signalState = {
+    status: "disconnected",
+    apiVersion: null,
+    number: null,
+    connectedAt: null,
+    error: null,
+};
+export function getSignalState() {
+    return { ..._signalState };
+}
+export class SignalAdapter {
+    platform = "signal";
+    handler = null;
+    apiUrl;
+    number;
+    pollInterval = null;
+    constructor(apiUrl, number) {
+        this.apiUrl = apiUrl.replace(/\/$/, "");
+        this.number = number;
+    }
+    async start() {
+        _signalState.status = "connecting";
+        _signalState.number = this.number;
+        // Verify connection
+        try {
+            const res = await fetch(`${this.apiUrl}/v1/about`);
+            if (!res.ok)
+                throw new Error(`Signal API not reachable: ${res.status}`);
+            const about = await res.json().catch(() => ({}));
+            _signalState.status = "connected";
+            _signalState.apiVersion = about.version || about.versions?.[0] || null;
+            _signalState.connectedAt = Date.now();
+            console.log("📱 Signal adapter connected");
+        }
+        catch (err) {
+            _signalState.status = "error";
+            _signalState.error = err instanceof Error ? err.message : String(err);
+            console.error("Signal adapter failed:", err);
+            throw err;
+        }
+        // Poll for new messages every 2 seconds
+        this.pollInterval = setInterval(async () => {
+            try {
+                const res = await fetch(`${this.apiUrl}/v1/receive/${encodeURIComponent(this.number)}`);
+                if (!res.ok)
+                    return;
+                const messages = await res.json();
+                for (const msg of messages) {
+                    const data = msg.envelope?.dataMessage;
+                    if (!data)
+                        continue;
+                    if (!this.handler)
+                        continue;
+                    const hasText = !!data.message;
+                    const hasVoice = data.attachments?.some((a) => a.contentType?.startsWith("audio/") || a.voiceNote);
+                    // Must have text or a voice attachment
+                    if (!hasText && !hasVoice)
+                        continue;
+                    const isGroup = !!data.groupInfo;
+                    // Download voice attachment if present
+                    let mediaInfo = undefined;
+                    if (hasVoice) {
+                        try {
+                            const voiceAtt = data.attachments.find((a) => a.contentType?.startsWith("audio/") || a.voiceNote);
+                            if (voiceAtt?.id) {
+                                const attRes = await fetch(`${this.apiUrl}/v1/attachments/${voiceAtt.id}`, { headers: { "Content-Type": "application/json" } });
+                                if (attRes.ok) {
+                                    const tmpDir = join(tmpdir(), "alvin-bot");
+                                    if (!fs.existsSync(tmpDir))
+                                        fs.mkdirSync(tmpDir, { recursive: true });
+                                    const ext = voiceAtt.contentType?.includes("ogg") ? "ogg" : "mp3";
+                                    const audioPath = join(tmpDir, `signal_voice_${Date.now()}.${ext}`);
+                                    fs.writeFileSync(audioPath, Buffer.from(await attRes.arrayBuffer()));
+                                    mediaInfo = { type: "voice", path: audioPath, mimeType: voiceAtt.contentType || "audio/ogg" };
+                                }
+                            }
+                        }
+                        catch (err) {
+                            console.error("Signal: Failed to download voice:", err);
+                        }
+                    }
+                    const incoming = {
+                        platform: "signal",
+                        messageId: msg.envelope.timestamp?.toString() || "",
+                        chatId: isGroup ? data.groupInfo.groupId : msg.envelope.sourceNumber,
+                        userId: msg.envelope.sourceNumber || "",
+                        userName: msg.envelope.sourceName || msg.envelope.sourceNumber || "Unknown",
+                        text: data.message || "",
+                        isGroup,
+                        isMention: !!(data.message && (data.message.includes("@bot") || data.message.includes("Alvin Bot"))),
+                        isReplyToBot: false,
+                        replyToText: data.quote?.text,
+                        media: mediaInfo,
+                    };
+                    // In groups: only respond to mentions (voice in groups always allowed)
+                    if (isGroup && !incoming.isMention && !hasVoice)
+                        continue;
+                    await this.handler(incoming);
+                }
+            }
+            catch { /* poll error — retry next interval */ }
+        }, 2000);
+    }
+    async stop() {
+        if (this.pollInterval) {
+            clearInterval(this.pollInterval);
+            this.pollInterval = null;
+        }
+    }
+    async sendText(chatId, text) {
+        // Determine if chatId is a group or direct message
+        const isGroup = chatId.length > 20; // Signal group IDs are long base64 strings
+        const body = {
+            message: text,
+            number: this.number,
+            recipients: isGroup ? undefined : [chatId],
+        };
+        if (isGroup) {
+            // Send to group
+            await fetch(`${this.apiUrl}/v2/send`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    ...body,
+                    recipients: [chatId],
+                }),
+            });
+        }
+        else {
+            await fetch(`${this.apiUrl}/v2/send`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(body),
+            });
+        }
+    }
+    async sendPhoto(chatId, photo, caption) {
+        // Signal sends attachments as base64 in the message body
+        const base64 = typeof photo === "string"
+            ? fs.readFileSync(photo).toString("base64")
+            : photo.toString("base64");
+        await fetch(`${this.apiUrl}/v2/send`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                message: caption || "",
+                number: this.number,
+                recipients: [chatId],
+                base64_attachments: [`data:image/png;base64,${base64}`],
+            }),
+        });
+    }
+    async sendDocument(chatId, doc, fileName, caption) {
+        const base64 = typeof doc === "string"
+            ? fs.readFileSync(doc).toString("base64")
+            : doc.toString("base64");
+        await fetch(`${this.apiUrl}/v2/send`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                message: caption || fileName,
+                number: this.number,
+                recipients: [chatId],
+                base64_attachments: [`data:application/octet-stream;filename=${fileName};base64,${base64}`],
+            }),
+        });
+    }
+    async react(chatId, messageId, emoji) {
+        try {
+            await fetch(`${this.apiUrl}/v1/reactions/${encodeURIComponent(this.number)}`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    recipient: chatId,
+                    reaction: emoji,
+                    target_author: chatId,
+                    timestamp: parseInt(messageId),
+                }),
+            });
+        }
+        catch { /* ignore */ }
+    }
+    async setTyping(chatId) {
+        // Signal doesn't have a native typing indicator via REST API
+        // No-op to satisfy the interface
+    }
+    onMessage(handler) {
+        this.handler = handler;
+    }
+}

package/dist/platforms/slack.js

@@ -0,0 +1,318 @@
+/**
+ * Slack Platform Adapter
+ *
+ * Uses @slack/bolt (Socket Mode) for real-time messaging.
+ * Optional dependency — only loaded if SLACK_BOT_TOKEN + SLACK_APP_TOKEN are set.
+ *
+ * Socket Mode = no public URL needed. Works behind NAT/firewalls.
+ *
+ * Setup:
+ *   1. Create a Slack App at https://api.slack.com/apps
+ *   2. Enable Socket Mode (Settings → Socket Mode → Enable)
+ *   3. Generate an App-Level Token with connections:write scope → SLACK_APP_TOKEN (xapp-...)
+ *   4. Install to workspace → Bot User OAuth Token → SLACK_BOT_TOKEN (xoxb-...)
+ *   5. Add Bot Token Scopes: chat:write, channels:history, groups:history, im:history,
+ *      mpim:history, app_mentions:read, files:write, reactions:write
+ *   6. Subscribe to events: message.im, message.groups, message.channels, app_mention
+ *   7. Set env vars and restart bot
+ */
+import fs from "fs";
+let _slackState = {
+    status: "disconnected",
+    botName: null,
+    botId: null,
+    teamName: null,
+    connectedAt: null,
+    error: null,
+};
+export function getSlackState() {
+    return { ..._slackState };
+}
+// ── Adapter ────────────────────────────────────────────────────────────────
+export class SlackAdapter {
+    platform = "slack";
+    handler = null;
+    app = null; // Bolt App instance
+    botUserId = "";
+    botToken;
+    appToken;
+    constructor(botToken, appToken) {
+        this.botToken = botToken;
+        this.appToken = appToken;
+    }
+    async start() {
+        _slackState = {
+            status: "connecting", botName: null, botId: null,
+            teamName: null, connectedAt: null, error: null,
+        };
+        let bolt;
+        try {
+            bolt = await import("@slack/bolt");
+        }
+        catch {
+            const msg = "@slack/bolt not installed. Run: npm install @slack/bolt";
+            _slackState = { ..._slackState, status: "error", error: msg };
+            console.error(`\u274C Slack: ${msg}`);
+            throw new Error(msg);
+        }
+        const { App } = bolt;
+        try {
+            this.app = new App({
+                token: this.botToken,
+                appToken: this.appToken,
+                socketMode: true,
+                // Suppress Bolt's default logging (we log ourselves)
+                logLevel: "ERROR",
+            });
+            // Get bot identity
+            const authResult = await this.app.client.auth.test({ token: this.botToken });
+            this.botUserId = authResult.user_id || "";
+            _slackState.botName = authResult.user || null;
+            _slackState.botId = authResult.user_id || null;
+            _slackState.teamName = authResult.team || null;
+            // Handle all messages (DMs + channels where bot is mentioned)
+            this.app.message(async ({ message, say, client }) => {
+                await this.handleMessage(message, say, client);
+            });
+            // Handle @mentions explicitly (app_mention event)
+            this.app.event("app_mention", async ({ event, say, client }) => {
+                await this.handleMention(event, say, client);
+            });
+            await this.app.start();
+            _slackState.status = "connected";
+            _slackState.connectedAt = Date.now();
+            console.log(`\uD83D\uDCAC Slack connected (${_slackState.botName} @ ${_slackState.teamName})`);
+        }
+        catch (err) {
+            _slackState.status = "error";
+            _slackState.error = err instanceof Error ? err.message : String(err);
+            console.error("\u274C Slack adapter failed:", _slackState.error);
+            throw err;
+        }
+    }
+    // ── Message Handling ───────────────────────────────────────────────────────
+    async handleMessage(message, _say, client) {
+        if (!this.handler)
+            return;
+        // Skip bot messages (including own), message_changed, etc.
+        if (message.subtype)
+            return;
+        if (message.bot_id)
+            return;
+        if (!message.text && !message.files)
+            return;
+        const text = (message.text || "").trim();
+        const userId = message.user || "";
+        const channelId = message.channel || "";
+        const messageId = message.ts || "";
+        // Determine channel type
+        // DMs (im) have channel_type "im", group DMs are "mpim", channels are "channel"/"group"
+        const channelType = message.channel_type || "";
+        const isDM = channelType === "im";
+        const isGroup = !isDM;
+        // In channels: only respond to @mentions (handled by app_mention event)
+        // But message event also fires for DMs, so we handle DMs here
+        if (isGroup)
+            return; // Channel messages handled by app_mention
+        // Resolve user name
+        let userName = userId;
+        try {
+            const userInfo = await client.users.info({ user: userId });
+            userName = userInfo.user?.real_name || userInfo.user?.name || userId;
+        }
+        catch { /* fallback to userId */ }
+        // Check for file attachments
+        let media = undefined;
+        if (message.files && message.files.length > 0) {
+            const file = message.files[0];
+            media = this.parseSlackFile(file);
+        }
+        // Check for thread/reply context
+        let replyToText;
+        if (message.thread_ts && message.thread_ts !== message.ts) {
+            try {
+                const thread = await client.conversations.replies({
+                    channel: channelId,
+                    ts: message.thread_ts,
+                    limit: 1,
+                });
+                const parent = thread.messages?.[0];
+                if (parent?.text) {
+                    replyToText = parent.text.length > 500 ? parent.text.slice(0, 500) + "..." : parent.text;
+                }
+            }
+            catch { /* ignore */ }
+        }
+        const incoming = {
+            platform: "slack",
+            messageId,
+            chatId: channelId,
+            userId,
+            userName,
+            text,
+            isGroup: false,
+            isMention: false,
+            isReplyToBot: false,
+            replyToText,
+            media,
+        };
+        await this.handler(incoming);
+    }
+    async handleMention(event, _say, client) {
+        if (!this.handler)
+            return;
+        if (event.bot_id)
+            return;
+        let text = (event.text || "").trim();
+        const userId = event.user || "";
+        const channelId = event.channel || "";
+        const messageId = event.ts || "";
+        // Strip the @mention from text
+        text = text.replace(new RegExp(`<@${this.botUserId}>`, "g"), "").trim();
+        if (!text)
+            return;
+        // Resolve user name
+        let userName = userId;
+        try {
+            const userInfo = await client.users.info({ user: userId });
+            userName = userInfo.user?.real_name || userInfo.user?.name || userId;
+        }
+        catch { /* fallback */ }
+        // File attachments
+        let media = undefined;
+        if (event.files && event.files.length > 0) {
+            media = this.parseSlackFile(event.files[0]);
+        }
+        const incoming = {
+            platform: "slack",
+            messageId,
+            chatId: channelId,
+            userId,
+            userName,
+            text,
+            isGroup: true,
+            isMention: true,
+            isReplyToBot: false,
+            media,
+        };
+        await this.handler(incoming);
+    }
+    parseSlackFile(file) {
+        if (!file)
+            return undefined;
+        const mime = file.mimetype || "";
+        if (mime.startsWith("image/")) {
+            return { type: "photo", url: file.url_private, mimeType: mime, fileName: file.name };
+        }
+        if (mime.startsWith("audio/")) {
+            return { type: "voice", url: file.url_private, mimeType: mime, fileName: file.name };
+        }
+        if (mime.startsWith("video/")) {
+            return { type: "video", url: file.url_private, mimeType: mime, fileName: file.name };
+        }
+        return { type: "document", url: file.url_private, mimeType: mime, fileName: file.name };
+    }
+    // ── Sending ──────────────────────────────────────────────────────────────
+    async sendText(chatId, text, options) {
+        if (!this.app)
+            return;
+        // Slack block limit is ~3000 chars for text blocks, message limit ~40000
+        // But keep it practical — split at 3800 like Telegram
+        const chunks = text.length > 3800
+            ? text.match(/.{1,3800}/gs) || [text]
+            : [text];
+        for (const chunk of chunks) {
+            await this.app.client.chat.postMessage({
+                token: this.botToken,
+                channel: chatId,
+                text: chunk,
+                // Thread reply if replyTo is set
+                ...(options?.replyTo ? { thread_ts: options.replyTo } : {}),
+                // Convert markdown bold/italic to Slack mrkdwn
+                mrkdwn: true,
+            });
+        }
+    }
+    async sendPhoto(chatId, photo, caption) {
+        if (!this.app)
+            return;
+        if (typeof photo === "string") {
+            // File path
+            await this.app.client.filesUploadV2({
+                token: this.botToken,
+                channel_id: chatId,
+                file: fs.createReadStream(photo),
+                filename: "image.png",
+                initial_comment: caption,
+            });
+        }
+        else {
+            // Buffer
+            await this.app.client.filesUploadV2({
+                token: this.botToken,
+                channel_id: chatId,
+                file_uploads: [{
+                        file: photo,
+                        filename: "image.png",
+                    }],
+                initial_comment: caption,
+            });
+        }
+    }
+    async sendDocument(chatId, doc, fileName, caption) {
+        if (!this.app)
+            return;
+        if (typeof doc === "string") {
+            await this.app.client.filesUploadV2({
+                token: this.botToken,
+                channel_id: chatId,
+                file: fs.createReadStream(doc),
+                filename: fileName,
+                initial_comment: caption,
+            });
+        }
+        else {
+            await this.app.client.filesUploadV2({
+                token: this.botToken,
+                channel_id: chatId,
+                file_uploads: [{
+                        file: doc,
+                        filename: fileName,
+                    }],
+                initial_comment: caption,
+            });
+        }
+    }
+    async react(chatId, messageId, emoji) {
+        if (!this.app)
+            return;
+        try {
+            // Slack emoji names don't include colons
+            const name = emoji.replace(/^:|:$/g, "");
+            await this.app.client.reactions.add({
+                token: this.botToken,
+                channel: chatId,
+                timestamp: messageId,
+                name,
+            });
+        }
+        catch { /* ignore — emoji might not exist */ }
+    }
+    async setTyping(chatId) {
+        // Slack doesn't have a public typing indicator API for bots
+        // The closest is the "is typing" shown during Web API calls
+    }
+    async stop() {
+        if (this.app) {
+            try {
+                await this.app.stop();
+            }
+            catch { /* ignore */ }
+            this.app = null;
+        }
+        _slackState.status = "disconnected";
+    }
+    onMessage(handler) {
+        this.handler = handler;
+    }
+}