daemora 1.0.0

package/src/channels/DiscordChannel.js

@@ -0,0 +1,288 @@
+import { BaseChannel } from "./BaseChannel.js";
+import taskQueue from "../core/TaskQueue.js";
+import eventBus from "../core/EventBus.js";
+import { transcribeAudio } from "../tools/transcribeAudio.js";
+import { writeFileSync, mkdirSync } from "node:fs";
+import { join, extname, basename } from "node:path";
+import { tmpdir } from "node:os";
+
+/**
+ * Discord Channel — receives messages via Discord Bot API.
+ *
+ * Setup:
+ * 1. Go to https://discord.com/developers/applications
+ * 2. Create a new application → Bot → copy the token
+ * 3. Enable "Message Content Intent" under Bot → Privileged Gateway Intents
+ * 4. Invite bot to your server with permissions: Send Messages, Read Message History, Add Reactions
+ * 5. Set env: DISCORD_BOT_TOKEN
+ *
+ * Config:
+ *   token     — Bot token
+ *   allowlist — Optional array of Discord user IDs (snowflakes) allowed to use the bot
+ *   model     — Optional model override
+ *
+ * The bot responds to:
+ *   - Direct messages (DMs)
+ *   - Messages that @mention the bot in any channel
+ */
+export class DiscordChannel extends BaseChannel {
+  constructor(config) {
+    super("discord", config);
+    this.client = null;
+    this.botUserId = null;
+  }
+
+  async start() {
+    if (!this.config.token) {
+      console.log(`[Channel:Discord] Skipped — no DISCORD_BOT_TOKEN`);
+      return;
+    }
+
+    const { Client, GatewayIntentBits, Partials } = await import("discord.js");
+
+    this.client = new Client({
+      intents: [
+        GatewayIntentBits.Guilds,
+        GatewayIntentBits.GuildMessages,
+        GatewayIntentBits.MessageContent,
+        GatewayIntentBits.DirectMessages,
+        GatewayIntentBits.DirectMessageTyping,
+        GatewayIntentBits.GuildMessageReactions,
+        GatewayIntentBits.DirectMessageReactions,
+      ],
+      partials: [Partials.Channel, Partials.Message, Partials.Reaction],
+    });
+
+    this.client.once("ready", (c) => {
+      this.botUserId = c.user.id;
+      this.running = true;
+      console.log(`[Channel:Discord] Logged in as ${c.user.tag}`);
+      if (this.config.allowlist?.length) {
+        console.log(`[Channel:Discord] Allowlist active — ${this.config.allowlist.length} authorized user(s)`);
+      }
+    });
+
+    this.client.on("messageCreate", async (message) => {
+      // Ignore messages from bots (including self)
+      if (message.author.bot) return;
+
+      const isDM = message.channel.type === 1; // DM_CHANNEL = 1
+      const isMention = this.botUserId && message.mentions.has(this.botUserId);
+
+      // Only respond to DMs or direct @mentions
+      if (!isDM && !isMention) return;
+
+      const userId = message.author.id;
+
+      // Allowlist check
+      if (!this.isAllowed(userId)) {
+        console.log(`[Channel:Discord] Blocked (not in allowlist): ${userId}`);
+        await message.reply("You are not authorized to use this agent.").catch(() => {});
+        return;
+      }
+
+      // Strip the @mention from the message content
+      const text = message.content
+        .replace(/<@!?\d+>/g, "")
+        .trim();
+
+      const hasAttachments = message.attachments.size > 0;
+
+      if (!text && !hasAttachments) {
+        await message.reply("Send me a message and I'll get to work.").catch(() => {});
+        return;
+      }
+
+      const channelId = message.channelId;
+
+      console.log(`[Channel:Discord] Message from ${message.author.username} (${userId}): "${text.slice(0, 80)}"${hasAttachments ? ` + ${message.attachments.size} attachment(s)` : ""}`);
+
+      // Show typing indicator while processing
+      try { await message.channel.sendTyping(); } catch (_) {}
+
+      // React ⏳ to show we received it
+      await this.sendReaction({ message }, "⏳");
+
+      // Build task input: text + any attachments
+      const inputParts = text ? [text] : [];
+      for (const [, attachment] of message.attachments) {
+        const localPath = await this._downloadAttachment(attachment);
+        if (!localPath) continue;
+
+        const ct = attachment.contentType || "";
+        if (ct.startsWith("audio/")) {
+          console.log(`[Channel:Discord] Audio attachment — transcribing...`);
+          const transcript = await transcribeAudio(localPath);
+          inputParts.push(transcript.startsWith("Error:")
+            ? `[Audio file: ${localPath}]\n${transcript}`
+            : `[Audio transcript]: ${transcript}`);
+        } else if (ct.startsWith("image/")) {
+          inputParts.push(`[Photo received: ${localPath}]\nUser caption: ${attachment.description || text || "Describe and respond to this image."}`);
+        } else if (ct.startsWith("video/")) {
+          inputParts.push(`[Video received: ${localPath}]`);
+        } else {
+          inputParts.push(`[File received: ${localPath} (${attachment.name || "document"}, ${_fmtSize(attachment.size)})]`);
+        }
+      }
+
+      const input = inputParts.join("\n");
+
+      // Enqueue task
+      const task = taskQueue.enqueue({
+        input,
+        channel: "discord",
+        channelMeta: { userId, channelId, messageId: message.id, guildId: message.guildId, channel: "discord" },
+        sessionId: this.getSessionId(userId),
+        model: this.getModel(),
+      });
+
+      try {
+        const completedTask = await taskQueue.waitForCompletion(task.id);
+
+        // Absorbed into a concurrent session — response already sent via original task
+        if (this.isTaskMerged(completedTask)) {
+          await this._removeReaction(message, "⏳");
+          await this.sendReaction({ message }, "✅");
+          return;
+        }
+
+        const failed = completedTask.status === "failed";
+        const response = failed
+          ? `Sorry, I encountered an error: ${completedTask.error}`
+          : completedTask.result || "Done.";
+
+        // Remove ⏳ and add ✅ or ❌
+        await this._removeReaction(message, "⏳");
+        await this.sendReaction({ message }, failed ? "❌" : "✅");
+
+        // Discord message limit: 2000 chars
+        const chunks = splitMessage(response, 1990);
+        await message.reply(chunks[0]).catch(() => {});
+        for (let i = 1; i < chunks.length; i++) {
+          await message.channel.send(chunks[i]).catch(() => {});
+        }
+      } catch (error) {
+        console.error(`[Channel:Discord] Error:`, error.message);
+        await this._removeReaction(message, "⏳");
+        await this.sendReaction({ message }, "❌");
+        try { await message.reply("Sorry, something went wrong. Please try again."); } catch (_) {}
+      }
+    });
+
+    // Listen for approval requests
+    eventBus.on("approval:request", async (data) => {
+      if (data.channelMeta?.channel !== "discord") return;
+      const channel = await this.client.channels.fetch(data.channelMeta?.channelId).catch(() => null);
+      if (channel) await channel.send(data.message).catch(() => {});
+    });
+
+    try {
+      await this.client.login(this.config.token);
+    } catch (err) {
+      console.log(`[Channel:Discord] Login failed: ${err.message}`);
+      this.running = false;
+    }
+  }
+
+  async stop() {
+    if (this.client) {
+      await this.client.destroy();
+      this.running = false;
+      console.log(`[Channel:Discord] Stopped`);
+    }
+  }
+
+  async sendReply(channelMeta, text) {
+    if (!this.client) return;
+    try {
+      const channel = await this.client.channels.fetch(channelMeta.channelId);
+      const chunks = splitMessage(text, 1990);
+      for (const chunk of chunks) {
+        await channel.send(chunk);
+      }
+    } catch (err) {
+      console.log(`[Channel:Discord] sendReply error: ${err.message}`);
+    }
+  }
+
+  /**
+   * React to a Discord message with an emoji.
+   * @param {{ message }} channelMeta - Must include the original Discord Message object
+   * @param {string} emoji
+   */
+  async sendReaction(channelMeta, emoji) {
+    const msg = channelMeta?.message;
+    if (!msg) return;
+    try {
+      await msg.react(emoji);
+    } catch (_) {}
+  }
+
+  /** Remove a specific reaction emoji the bot added. */
+  async _removeReaction(message, emoji) {
+    try {
+      const reaction = message.reactions.cache.get(emoji);
+      if (reaction) await reaction.users.remove(this.client.user.id);
+    } catch (_) {}
+  }
+
+  /**
+   * Send a local file to a Discord channel.
+   */
+  async sendFile(channelMeta, filePath, caption) {
+    if (!this.client) return;
+    try {
+      const channel = await this.client.channels.fetch(channelMeta.channelId);
+      await channel.send({
+        content: caption || undefined,
+        files: [{ attachment: filePath, name: basename(filePath) }],
+      });
+    } catch (err) {
+      console.log(`[Channel:Discord] sendFile error: ${err.message}`);
+    }
+  }
+
+  /**
+   * Download a Discord attachment to /tmp and return the local path.
+   */
+  async _downloadAttachment(attachment) {
+    try {
+      const ext = extname(attachment.name || attachment.url || "").split("?")[0] || "";
+      const tmpDir = join(tmpdir(), "daemora-discord");
+      mkdirSync(tmpDir, { recursive: true });
+      const filePath = join(tmpDir, `${attachment.id}${ext}`);
+
+      const res = await fetch(attachment.url, { signal: AbortSignal.timeout(30000) });
+      if (!res.ok) return null;
+
+      const buffer = await res.arrayBuffer();
+      writeFileSync(filePath, Buffer.from(buffer));
+      return filePath;
+    } catch (err) {
+      console.log(`[Channel:Discord] Attachment download error: ${err.message}`);
+      return null;
+    }
+  }
+}
+
+function _fmtSize(bytes) {
+  if (!bytes) return "unknown size";
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
+
+function splitMessage(text, maxLength) {
+  if (text.length <= maxLength) return [text];
+  const chunks = [];
+  let remaining = text;
+  while (remaining.length > 0) {
+    if (remaining.length <= maxLength) { chunks.push(remaining); break; }
+    let idx = remaining.lastIndexOf("\n", maxLength);
+    if (idx < maxLength * 0.5) idx = remaining.lastIndexOf(" ", maxLength);
+    if (idx === -1) idx = maxLength;
+    chunks.push(remaining.slice(0, idx));
+    remaining = remaining.slice(idx).trimStart();
+  }
+  return chunks;
+}

package/src/channels/EmailChannel.js

@@ -0,0 +1,172 @@
+import { BaseChannel } from "./BaseChannel.js";
+import taskQueue from "../core/TaskQueue.js";
+
+/**
+ * Email Channel — polls IMAP for incoming emails, replies via SMTP.
+ *
+ * Setup:
+ * 1. Enable IMAP on your Gmail (or email provider)
+ * 2. Set env: EMAIL_USER, EMAIL_PASSWORD, EMAIL_IMAP_HOST, EMAIL_SMTP_HOST
+ * 3. For Gmail: use App Password (not regular password)
+ */
+export class EmailChannel extends BaseChannel {
+  constructor(config) {
+    super("email", config);
+    this.transporter = null;
+    this.pollTimer = null;
+    this.processedIds = new Set();
+  }
+
+  async start() {
+    if (!this.config.user || !this.config.password) {
+      console.log(`[Channel:Email] Skipped — no EMAIL_USER/EMAIL_PASSWORD`);
+      return;
+    }
+
+    const nodemailer = await import("nodemailer");
+
+    // Set up SMTP transporter for sending replies
+    this.transporter = nodemailer.default.createTransport({
+      host: this.config.smtp.host,
+      port: this.config.smtp.port,
+      secure: this.config.smtp.port === 465,
+      auth: {
+        user: this.config.user,
+        pass: this.config.password,
+      },
+    });
+
+    // Start polling for new emails
+    this.running = true;
+    this.pollTimer = setInterval(() => this.pollEmails(), 60000); // every 60s
+    console.log(`[Channel:Email] Started (polling every 60s, user: ${this.config.user})`);
+
+    // Poll immediately on start
+    this.pollEmails();
+  }
+
+  async stop() {
+    this.running = false;
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+    console.log(`[Channel:Email] Stopped`);
+  }
+
+  async pollEmails() {
+    try {
+      const Imap = (await import("imap")).default;
+
+      const imap = new Imap({
+        user: this.config.user,
+        password: this.config.password,
+        host: this.config.imap.host,
+        port: this.config.imap.port,
+        tls: true,
+        tlsOptions: { rejectUnauthorized: false },
+      });
+
+      await new Promise((resolve, reject) => {
+        imap.once("ready", () => {
+          imap.openBox("INBOX", false, (err) => {
+            if (err) { reject(err); return; }
+
+            // Search for unseen emails
+            imap.search(["UNSEEN"], (err, results) => {
+              if (err) { imap.end(); reject(err); return; }
+              if (!results || results.length === 0) { imap.end(); resolve(); return; }
+
+              console.log(`[Channel:Email] Found ${results.length} new email(s)`);
+
+              const fetch = imap.fetch(results, { bodies: "", markSeen: true });
+
+              fetch.on("message", (msg) => {
+                let body = "";
+                let headers = {};
+
+                msg.on("body", (stream) => {
+                  stream.on("data", (chunk) => { body += chunk.toString(); });
+                });
+
+                msg.once("attributes", (attrs) => {
+                  headers = attrs;
+                });
+
+                msg.once("end", () => {
+                  this.processEmail(body, headers);
+                });
+              });
+
+              fetch.once("end", () => { imap.end(); resolve(); });
+              fetch.once("error", (err) => { imap.end(); reject(err); });
+            });
+          });
+        });
+
+        imap.once("error", reject);
+        imap.connect();
+      });
+    } catch (error) {
+      console.log(`[Channel:Email] Poll error: ${error.message}`);
+    }
+  }
+
+  async processEmail(rawEmail, attrs) {
+    try {
+      // Simple header parsing
+      const fromMatch = rawEmail.match(/^From:\s*(.+)$/mi);
+      const subjectMatch = rawEmail.match(/^Subject:\s*(.+)$/mi);
+      const from = fromMatch ? fromMatch[1].trim() : "unknown";
+      const subject = subjectMatch ? subjectMatch[1].trim() : "(no subject)";
+
+      // Extract email address from "Name <email>" format
+      const emailMatch = from.match(/<([^>]+)>/);
+      const senderEmail = emailMatch ? emailMatch[1] : from;
+
+      // Extract body (simplified — takes text after headers)
+      const bodyStart = rawEmail.indexOf("\r\n\r\n");
+      const emailBody = bodyStart > -1 ? rawEmail.slice(bodyStart + 4).trim() : rawEmail;
+
+      // Skip if already processed
+      const uid = `${senderEmail}-${subject}-${attrs?.uid || Date.now()}`;
+      if (this.processedIds.has(uid)) return;
+      this.processedIds.add(uid);
+
+      console.log(`[Channel:Email] Processing: from=${senderEmail} subject="${subject}"`);
+
+      const taskInput = `Email from: ${senderEmail}\nSubject: ${subject}\n\nBody:\n${emailBody.slice(0, 5000)}`;
+
+      const task = taskQueue.enqueue({
+        input: taskInput,
+        channel: "email",
+        channelMeta: { senderEmail, subject },
+        sessionId: this.getSessionId(senderEmail),
+      });
+
+      // Wait and reply
+      const completedTask = await taskQueue.waitForCompletion(task.id);
+      if (this.isTaskMerged(completedTask)) return; // absorbed into concurrent session
+      const response = completedTask.status === "failed"
+        ? `Sorry, I encountered an error processing your request: ${completedTask.error}`
+        : completedTask.result || "Done.";
+
+      await this.sendReply({ senderEmail, subject }, response);
+    } catch (error) {
+      console.log(`[Channel:Email] Process error: ${error.message}`);
+    }
+  }
+
+  async sendReply(channelMeta, text) {
+    if (!this.transporter) return;
+
+    await this.transporter.sendMail({
+      from: this.config.user,
+      to: channelMeta.senderEmail,
+      subject: `Re: ${channelMeta.subject}`,
+      text: text,
+    });
+
+    console.log(`[Channel:Email] Reply sent to ${channelMeta.senderEmail}`);
+  }
+}