daemora 1.0.0

package/src/channels/SlackChannel.js

@@ -0,0 +1,329 @@
+import { BaseChannel } from "./BaseChannel.js";
+import taskQueue from "../core/TaskQueue.js";
+import eventBus from "../core/EventBus.js";
+import { transcribeAudio } from "../tools/transcribeAudio.js";
+import { createReadStream, writeFileSync, mkdirSync } from "node:fs";
+import { join, extname, basename } from "node:path";
+import { tmpdir } from "node:os";
+
+/**
+ * Slack Channel — receives messages via Slack Bolt + Socket Mode.
+ *
+ * Socket Mode means NO public webhook URL needed — works on any machine.
+ *
+ * Setup:
+ * 1. Go to https://api.slack.com/apps → Create New App → From Scratch
+ * 2. Under "Socket Mode" → Enable Socket Mode → Generate App-Level Token (xapp-...)
+ *    → Grant scope: connections:write → copy token as SLACK_APP_TOKEN
+ * 3. Under "OAuth & Permissions" → Bot Token Scopes: add:
+ *      chat:write, channels:history, groups:history, im:history, mpim:history,
+ *      channels:read, groups:read, im:read, mpim:read, app_mentions:read,
+ *      reactions:write, reactions:read
+ *    → Install app to workspace → copy Bot User OAuth Token (xoxb-...) as SLACK_BOT_TOKEN
+ * 4. Under "Event Subscriptions" → Enable Events → Subscribe to bot events:
+ *      message.im, app_mention
+ * 5. Set env: SLACK_BOT_TOKEN, SLACK_APP_TOKEN
+ *
+ * Config:
+ *   botToken  — xoxb-... token
+ *   appToken  — xapp-... token for Socket Mode
+ *   allowlist — Optional array of Slack user IDs (Uxxxxxxxx) allowed to use the bot
+ *   model     — Optional model override
+ *
+ * The bot responds to:
+ *   - Direct messages (message.im)
+ *   - @mentions in channels (app_mention)
+ */
+export class SlackChannel extends BaseChannel {
+  constructor(config) {
+    super("slack", config);
+    this.app = null;
+    this.botUserId = null;
+  }
+
+  async start() {
+    if (!this.config.botToken || !this.config.appToken) {
+      console.log(`[Channel:Slack] Skipped — need SLACK_BOT_TOKEN and SLACK_APP_TOKEN`);
+      return;
+    }
+
+    const { App } = await import("@slack/bolt");
+
+    this.app = new App({
+      token: this.config.botToken,
+      appToken: this.config.appToken,
+      socketMode: true,
+      logLevel: "error",
+    });
+
+    // Resolve bot's own user ID
+    try {
+      const authResult = await this.app.client.auth.test({ token: this.config.botToken });
+      this.botUserId = authResult.user_id;
+    } catch (_) {}
+
+    // Handle @mentions in channels
+    this.app.event("app_mention", async ({ event, say }) => {
+      const text = event.text
+        .replace(/<@[A-Z0-9]+>/g, "")
+        .trim();
+
+      if (!text) {
+        await say({ text: "Yes? Send me a task.", thread_ts: event.ts });
+        return;
+      }
+
+      await this._handleMessage({
+        text,
+        userId: event.user,
+        channelId: event.channel,
+        threadTs: event.thread_ts || event.ts,
+        messageTs: event.ts,
+        say,
+      });
+    });
+
+    // Handle direct messages
+    this.app.message(async ({ message, say }) => {
+      if (message.bot_id) return; // Ignore bot messages
+
+      const hasFiles = message.files && message.files.length > 0;
+      if (!message.text && !hasFiles) return;
+
+      await this._handleMessage({
+        text: message.text?.trim() || "",
+        files: message.files || [],
+        userId: message.user,
+        channelId: message.channel,
+        threadTs: message.thread_ts || message.ts,
+        messageTs: message.ts,
+        say,
+      });
+    });
+
+    // Approval replies
+    eventBus.on("approval:request", async (data) => {
+      if (data.channelMeta?.channel !== "slack") return;
+      try {
+        await this.app.client.chat.postMessage({
+          token: this.config.botToken,
+          channel: data.channelMeta?.channelId,
+          text: data.message,
+          thread_ts: data.channelMeta?.threadTs,
+        });
+      } catch (_) {}
+    });
+
+    try {
+      await this.app.start();
+      this.running = true;
+      console.log(`[Channel:Slack] Started (Socket Mode)`);
+      if (this.config.allowlist?.length) {
+        console.log(`[Channel:Slack] Allowlist active — ${this.config.allowlist.length} authorized user(s)`);
+      }
+    } catch (err) {
+      console.log(`[Channel:Slack] Failed to start: ${err.message}`);
+    }
+  }
+
+  async _handleMessage({ text, files = [], userId, channelId, threadTs, messageTs, say }) {
+    // Allowlist check
+    if (!this.isAllowed(userId)) {
+      console.log(`[Channel:Slack] Blocked (not in allowlist): ${userId}`);
+      await say({ text: "You are not authorized to use this agent.", thread_ts: threadTs });
+      return;
+    }
+
+    console.log(`[Channel:Slack] Message from ${userId}: "${text.slice(0, 80)}"${files.length ? ` + ${files.length} file(s)` : ""}`);
+
+    // React ⏳ to show we're working
+    await this._addReaction(channelId, messageTs, "hourglass_flowing_sand");
+
+    // Build input from text + files
+    const inputParts = text ? [text] : [];
+    for (const file of files) {
+      const localPath = await this._downloadFile(file);
+      if (!localPath) continue;
+
+      const mimeType = file.mimetype || "";
+      if (mimeType.startsWith("audio/")) {
+        console.log(`[Channel:Slack] Audio file — transcribing...`);
+        const transcript = await transcribeAudio(localPath);
+        inputParts.push(transcript.startsWith("Error:")
+          ? `[Audio file: ${localPath}]\n${transcript}`
+          : `[Audio transcript]: ${transcript}`);
+      } else if (mimeType.startsWith("image/")) {
+        inputParts.push(`[Photo received: ${localPath}]\nUser caption: ${file.title || text || "Describe and respond to this image."}`);
+      } else if (mimeType.startsWith("video/")) {
+        inputParts.push(`[Video received: ${localPath}]`);
+      } else {
+        inputParts.push(`[File received: ${localPath} (${file.name || "document"}, ${_fmtSize(file.size)})]`);
+      }
+    }
+
+    const input = inputParts.join("\n");
+
+    const task = taskQueue.enqueue({
+      input,
+      channel: "slack",
+      channelMeta: { userId, channelId, threadTs, messageTs, channel: "slack" },
+      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(channelId, messageTs, "hourglass_flowing_sand");
+        await this._addReaction(channelId, messageTs, "white_check_mark");
+        return;
+      }
+
+      const failed = completedTask.status === "failed";
+      const response = failed
+        ? `Sorry, I encountered an error: ${completedTask.error}`
+        : completedTask.result || "Done.";
+
+      // Swap ⏳ for ✅ or ❌
+      await this._removeReaction(channelId, messageTs, "hourglass_flowing_sand");
+      await this._addReaction(channelId, messageTs, failed ? "x" : "white_check_mark");
+
+      // Reply in thread to keep conversations clean
+      const chunks = splitMessage(response, 3800);
+      for (const chunk of chunks) {
+        await say({ text: chunk, thread_ts: threadTs });
+      }
+    } catch (error) {
+      console.error(`[Channel:Slack] Error:`, error.message);
+      await this._removeReaction(channelId, messageTs, "hourglass_flowing_sand");
+      await this._addReaction(channelId, messageTs, "x");
+      await say({ text: "Sorry, something went wrong. Please try again.", thread_ts: threadTs });
+    }
+  }
+
+  async stop() {
+    if (this.app) {
+      await this.app.stop().catch(() => {});
+      this.running = false;
+      console.log(`[Channel:Slack] Stopped`);
+    }
+  }
+
+  async sendReply(channelMeta, text) {
+    if (!this.app) return;
+    const chunks = splitMessage(text, 3800);
+    for (const chunk of chunks) {
+      await this.app.client.chat.postMessage({
+        token: this.config.botToken,
+        channel: channelMeta.channelId,
+        text: chunk,
+        thread_ts: channelMeta.threadTs,
+      }).catch((err) => console.log(`[Channel:Slack] sendReply error: ${err.message}`));
+    }
+  }
+
+  /**
+   * Add an emoji reaction to a Slack message.
+   * @param {string} channelId
+   * @param {string} timestamp  - message ts
+   * @param {string} name       - reaction name without colons (e.g. "white_check_mark")
+   */
+  async sendReaction(channelMeta, emoji) {
+    // Map unicode emoji to Slack reaction names
+    const emojiMap = { "✅": "white_check_mark", "❌": "x", "⏳": "hourglass_flowing_sand" };
+    const name = emojiMap[emoji] || emoji;
+    await this._addReaction(channelMeta.channelId, channelMeta.messageTs, name);
+  }
+
+  async _addReaction(channelId, timestamp, name) {
+    try {
+      await this.app.client.reactions.add({
+        token: this.config.botToken,
+        channel: channelId,
+        timestamp,
+        name,
+      });
+    } catch (_) {}
+  }
+
+  async _removeReaction(channelId, timestamp, name) {
+    try {
+      await this.app.client.reactions.remove({
+        token: this.config.botToken,
+        channel: channelId,
+        timestamp,
+        name,
+      });
+    } catch (_) {}
+  }
+
+  /**
+   * Send a local file to a Slack channel.
+   */
+  async sendFile(channelMeta, filePath, caption) {
+    if (!this.app) return;
+    try {
+      await this.app.client.filesUploadV2({
+        token: this.config.botToken,
+        channel_id: channelMeta.channelId,
+        file: createReadStream(filePath),
+        filename: basename(filePath),
+        initial_comment: caption || undefined,
+      });
+    } catch (err) {
+      console.log(`[Channel:Slack] sendFile error: ${err.message}`);
+    }
+  }
+
+  /**
+   * Download a Slack file to /tmp (requires bot token for auth).
+   */
+  async _downloadFile(file) {
+    try {
+      const url = file.url_private || file.url_private_download;
+      if (!url) return null;
+
+      const ext = extname(file.name || file.title || "").split("?")[0] || "";
+      const tmpDir = join(tmpdir(), "daemora-slack");
+      mkdirSync(tmpDir, { recursive: true });
+      const filePath = join(tmpDir, `${file.id}${ext}`);
+
+      const res = await fetch(url, {
+        headers: { Authorization: `Bearer ${this.config.botToken}` },
+        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:Slack] File 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/TeamsChannel.js

@@ -0,0 +1,272 @@
+import { BaseChannel } from "./BaseChannel.js";
+import taskQueue from "../core/TaskQueue.js";
+import { transcribeAudio } from "../tools/transcribeAudio.js";
+import { writeFileSync, mkdirSync } from "node:fs";
+import { join, extname } from "node:path";
+import { tmpdir } from "node:os";
+
+/**
+ * Microsoft Teams Channel — receives messages via Bot Framework v4 (CloudAdapter).
+ *
+ * Setup:
+ * 1. Go to https://portal.azure.com → Create a resource → Azure Bot
+ * 2. Set messaging endpoint to: https://your-server/webhooks/teams
+ * 3. Under "Configuration" → copy App ID as TEAMS_APP_ID
+ * 4. Under "Configuration" → Manage Password → New client secret → copy as TEAMS_APP_PASSWORD
+ * 5. In the bot resource → Channels → Add Microsoft Teams
+ *
+ * Config:
+ *   appId       — Microsoft App ID from Azure Bot registration
+ *   appPassword — Client secret from Azure AD app registration
+ *   allowlist   — Optional array of Teams user IDs / AAD object IDs
+ *   model       — Optional model override
+ *
+ * Unlike OpenClaw's 461-line channel with Adaptive Cards and Graph API,
+ * this is minimal: text messages + file attachments + proactive reply.
+ *
+ * Teams has a 5-second webhook timeout, so we ack immediately and
+ * deliver the agent reply via adapter.continueConversation().
+ */
+export class TeamsChannel extends BaseChannel {
+  constructor(config) {
+    super("teams", config);
+    this.adapter = null;
+    this._conversationRefs = new Map(); // userId → conversationReference
+  }
+
+  async start() {
+    if (!this.config.appId || !this.config.appPassword) {
+      console.log(`[Channel:Teams] Skipped — set TEAMS_APP_ID and TEAMS_APP_PASSWORD`);
+      return;
+    }
+
+    const {
+      CloudAdapter,
+      ConfigurationBotFrameworkAuthentication,
+      TurnContext,
+    } = await import("botbuilder");
+
+    this._TurnContext = TurnContext;
+
+    const auth = new ConfigurationBotFrameworkAuthentication({
+      MicrosoftAppId: this.config.appId,
+      MicrosoftAppPassword: this.config.appPassword,
+    });
+
+    this.adapter = new CloudAdapter(auth);
+
+    this.adapter.onTurnError = async (context, error) => {
+      console.error(`[Channel:Teams] Turn error: ${error.message}`);
+      try { await context.sendActivity("Sorry, something went wrong. Please try again."); } catch (_) {}
+    };
+
+    this.running = true;
+    console.log(`[Channel:Teams] Ready (webhook: POST /webhooks/teams)`);
+    if (this.config.allowlist?.length) {
+      console.log(`[Channel:Teams] Allowlist active — ${this.config.allowlist.length} authorized user(s)`);
+    }
+  }
+
+  /**
+   * Handle inbound webhook from Bot Framework.
+   * Called by Express route in index.js.
+   * Must respond with HTTP 200 within ~5 seconds, so we ack immediately
+   * and deliver the agent reply via proactive messaging.
+   */
+  async handleWebhook(req, res) {
+    if (!this.adapter) {
+      res.status(503).json({ error: "Teams channel not started" });
+      return;
+    }
+
+    await this.adapter.process(req, res, async (context) => {
+      const type = context.activity.type;
+
+      // Welcome message when bot is added to a conversation
+      if (type === "conversationUpdate") {
+        const added = context.activity.membersAdded || [];
+        for (const member of added) {
+          if (member.id !== context.activity.recipient.id) {
+            await context.sendActivity("Hello! I'm Daemora. Send me a message and I'll get to work.");
+          }
+        }
+        return;
+      }
+
+      if (type !== "message") return;
+
+      const userId      = context.activity.from?.id || "unknown";
+      const userName    = context.activity.from?.name || "User";
+      const channelId   = context.activity.channelData?.teamsChannelId || context.activity.conversation?.id;
+      const text        = (context.activity.text || "").replace(/<at[^>]*>.*?<\/at>/gi, "").trim();
+      const attachments = context.activity.attachments || [];
+
+      // Allowlist check
+      if (!this.isAllowed(userId)) {
+        await context.sendActivity("You are not authorized to use this agent.");
+        return;
+      }
+
+      // Build input from text + any file attachments
+      const inputParts = text ? [text] : [];
+      for (const att of attachments) {
+        if (att.contentType === "application/vnd.microsoft.teams.file.download.info") {
+          const localPath = await this._downloadAttachment(att);
+          if (localPath) {
+            const ct = att.contentType || "";
+            if (ct.includes("audio")) {
+              const transcript = await transcribeAudio(localPath);
+              inputParts.push(transcript.startsWith("Error:")
+                ? `[Audio file: ${localPath}]\n${transcript}`
+                : `[Audio transcript]: ${transcript}`);
+            } else {
+              inputParts.push(`[File received: ${localPath}]`);
+            }
+          }
+        } else if (att.contentUrl) {
+          const ext = _extFromContentType(att.contentType || "");
+          const localPath = await this._downloadUrl(att.contentUrl, ext, this.config);
+          if (localPath) {
+            if ((att.contentType || "").startsWith("image/")) {
+              inputParts.push(`[Photo received: ${localPath}]${text ? "" : "\nDescribe this image."}`);
+            } else {
+              inputParts.push(`[File received: ${localPath} (${att.name || "attachment"})]`);
+            }
+          }
+        }
+      }
+
+      if (inputParts.length === 0) {
+        await context.sendActivity("Send me a message and I'll get to work.");
+        return;
+      }
+
+      const input = inputParts.join("\n");
+      console.log(`[Channel:Teams] Message from ${userName} (${userId}): "${input.slice(0, 80)}"`);
+
+      // Save conversation reference for proactive reply later
+      const ref = this._TurnContext.getConversationReference(context.activity);
+      this._conversationRefs.set(userId, ref);
+
+      // Ack with typing indicator — keeps Teams from showing "delivery failed"
+      await context.sendActivity({ type: "typing" });
+
+      // Enqueue task and reply proactively (don't await — we must return within 5s)
+      const task = taskQueue.enqueue({
+        input,
+        channel:     "teams",
+        channelMeta: { userId, channelId, userName, channel: "teams" },
+        sessionId:   this.getSessionId(userId),
+        model:       this.getModel(),
+      });
+
+      // Fire-and-forget: wait for completion then deliver via continueConversation
+      taskQueue.waitForCompletion(task.id)
+        .then(async (completedTask) => {
+          if (this.isTaskMerged(completedTask)) return; // absorbed into concurrent session
+          const failed   = completedTask.status === "failed";
+          const response = failed
+            ? `Sorry, I encountered an error: ${completedTask.error}`
+            : completedTask.result || "Done.";
+
+          await this.adapter.continueConversation(ref, async (proactiveCtx) => {
+            const chunks = splitMessage(response, 4000);
+            for (const chunk of chunks) {
+              await proactiveCtx.sendActivity(chunk);
+            }
+          });
+        })
+        .catch((err) => {
+          console.error(`[Channel:Teams] Reply error: ${err.message}`);
+        });
+    });
+  }
+
+  async stop() {
+    this.running = false;
+    this._conversationRefs.clear();
+    console.log(`[Channel:Teams] Stopped`);
+  }
+
+  async sendReply(channelMeta, text) {
+    if (!this.adapter) return;
+    const ref = this._conversationRefs.get(channelMeta.userId);
+    if (!ref) return;
+    try {
+      await this.adapter.continueConversation(ref, async (ctx) => {
+        const chunks = splitMessage(text, 4000);
+        for (const chunk of chunks) { await ctx.sendActivity(chunk); }
+      });
+    } catch (err) {
+      console.log(`[Channel:Teams] sendReply error: ${err.message}`);
+    }
+  }
+
+  async sendFile(channelMeta, filePath, caption) {
+    if (!this.adapter) return;
+    const ref = this._conversationRefs.get(channelMeta.userId);
+    if (!ref) return;
+    try {
+      // Teams file sending requires SharePoint upload for larger files.
+      // For simplicity: send the file path as text with caption.
+      // Full file upload requires Graph API + bot permissions — out of scope here.
+      const msg = caption
+        ? `${caption}\n(File: ${filePath})`
+        : `File: ${filePath}`;
+      await this.adapter.continueConversation(ref, async (ctx) => {
+        await ctx.sendActivity(msg);
+      });
+    } catch (err) {
+      console.log(`[Channel:Teams] sendFile error: ${err.message}`);
+    }
+  }
+
+  async _downloadUrl(url, ext, cfg) {
+    try {
+      const headers = {};
+      // Teams content URLs may require the bot credentials for auth
+      if (cfg?.appId && cfg?.appPassword) {
+        const creds = Buffer.from(`${cfg.appId}:${cfg.appPassword}`).toString("base64");
+        headers["Authorization"] = `Basic ${creds}`;
+      }
+      const res = await fetch(url, { headers, signal: AbortSignal.timeout(30000) });
+      if (!res.ok) return null;
+      const tmpDir = join(tmpdir(), "daemora-teams");
+      mkdirSync(tmpDir, { recursive: true });
+      const filePath = join(tmpDir, `att-${Date.now()}${ext}`);
+      writeFileSync(filePath, Buffer.from(await res.arrayBuffer()));
+      return filePath;
+    } catch { return null; }
+  }
+
+  async _downloadAttachment(att) {
+    const info = att.content?.downloadUrl;
+    if (!info) return null;
+    const ext = att.name ? extname(att.name) : "";
+    return this._downloadUrl(info, ext, this.config);
+  }
+}
+
+function _extFromContentType(ct) {
+  const map = {
+    "image/jpeg": ".jpg", "image/png": ".png", "image/gif": ".gif",
+    "audio/ogg": ".ogg", "audio/mpeg": ".mp3", "video/mp4": ".mp4",
+    "application/pdf": ".pdf",
+  };
+  return map[ct] || "";
+}
+
+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;
+}