daemora 1.0.2 → 1.0.4

package/src/channels/BlueBubblesChannel.js

@@ -0,0 +1,112 @@
+import { BaseChannel } from "./BaseChannel.js";
+import taskQueue from "../core/TaskQueue.js";
+
+/**
+ * BlueBubbles Channel - connects to a BlueBubbles server for iMessage relay.
+ * BlueBubbles runs on a Mac and exposes a REST + WebSocket API for iMessages.
+ *
+ * Setup:
+ * 1. Install BlueBubbles on a Mac: https://bluebubbles.app
+ * 2. Enable the server and note the server URL + password
+ * 3. Set env: BLUEBUBBLES_URL, BLUEBUBBLES_PASSWORD
+ *
+ * Config:
+ *   url        - BlueBubbles server URL (e.g. http://192.168.1.100:1234)
+ *   password   - BlueBubbles server password
+ *   allowlist  - Optional array of phone numbers / email addresses
+ *   model      - Optional model override
+ */
+export class BlueBubblesChannel extends BaseChannel {
+  constructor(config) {
+    super("bluebubbles", config);
+    this.ws = null;
+  }
+
+  get _baseUrl() {
+    return this.config.url?.replace(/\/$/, "");
+  }
+
+  async start() {
+    if (!this.config.url || !this.config.password) {
+      console.log("[Channel:BlueBubbles] Skipped - missing BLUEBUBBLES_URL or BLUEBUBBLES_PASSWORD");
+      return;
+    }
+
+    try {
+      const { WebSocket } = await import("ws");
+      const wsUrl = this._baseUrl.replace(/^http/, "ws") + `/api/v1/socket.io/?password=${encodeURIComponent(this.config.password)}&transport=websocket`;
+
+      this.ws = new WebSocket(wsUrl);
+
+      this.ws.on("open", () => {
+        this.running = true;
+        console.log(`[Channel:BlueBubbles] Connected to ${this._baseUrl}`);
+      });
+
+      this.ws.on("message", async (raw) => {
+        let msg;
+        try { msg = JSON.parse(raw); } catch { return; }
+
+        // BlueBubbles sends Socket.IO-style messages
+        if (!msg?.event || msg.event !== "new-message") return;
+        const data = msg.data;
+        if (!data || data.isFromMe) return;
+
+        const sender = data.handle?.id || data.chats?.[0]?.participants?.[0]?.id;
+        if (!sender || !this.isAllowed(sender)) return;
+
+        const input = data.text?.trim();
+        if (!input) return;
+
+        const chatGuid = data.chats?.[0]?.guid;
+        const channelMeta = { chatGuid, sender, messageGuid: data.guid };
+
+        const task = await taskQueue.enqueue({
+          input,
+          channel: "bluebubbles",
+          sessionId: this.getSessionId(sender),
+          channelMeta,
+          model: this.getModel(),
+        });
+
+        const result = await taskQueue.waitForResult(task.id);
+        if (!this.isTaskMerged(result)) {
+          await this.sendReply(channelMeta, result.result || "(no response)");
+        }
+      });
+
+      this.ws.on("error", (err) => console.log(`[Channel:BlueBubbles] WS error: ${err.message}`));
+      this.ws.on("close", () => {
+        this.running = false;
+        console.log("[Channel:BlueBubbles] Disconnected");
+      });
+    } catch (err) {
+      console.log(`[Channel:BlueBubbles] Failed to start: ${err.message}`);
+    }
+  }
+
+  async stop() {
+    if (this.ws) {
+      this.ws.close();
+      this.running = false;
+    }
+    console.log("[Channel:BlueBubbles] Stopped");
+  }
+
+  async sendReply(channelMeta, text) {
+    if (!channelMeta?.chatGuid) return;
+    const fetchFn = globalThis.fetch || (await import("node-fetch")).default;
+    await fetchFn(`${this._baseUrl}/api/v1/message/text`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Basic ${Buffer.from(`:${this.config.password}`).toString("base64")}`,
+      },
+      body: JSON.stringify({
+        chatGuid: channelMeta.chatGuid,
+        message: text,
+        method: "private-api",
+      }),
+    });
+  }
+}

package/src/channels/DiscordChannel.js

@@ -7,7 +7,7 @@ import { join, extname, basename } from "node:path";
 import { tmpdir } from "node:os";
 
 /**
- * Discord Channel — receives messages via Discord Bot API.
+ * Discord Channel - receives messages via Discord Bot API.
  *
  * Setup:
  * 1. Go to https://discord.com/developers/applications
@@ -17,9 +17,9 @@ import { tmpdir } from "node:os";
  * 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
+ *   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)
@@ -34,7 +34,7 @@ export class DiscordChannel extends BaseChannel {
 
   async start() {
     if (!this.config.token) {
-      console.log(`[Channel:Discord] Skipped — no DISCORD_BOT_TOKEN`);
+      console.log(`[Channel:Discord] Skipped - no DISCORD_BOT_TOKEN`);
       return;
     }
 
@@ -58,7 +58,7 @@ export class DiscordChannel extends BaseChannel {
       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)`);
+        console.log(`[Channel:Discord] Allowlist active - ${this.config.allowlist.length} authorized user(s)`);
       }
     });
 
@@ -111,7 +111,7 @@ export class DiscordChannel extends BaseChannel {
 
         const ct = attachment.contentType || "";
         if (ct.startsWith("audio/")) {
-          console.log(`[Channel:Discord] Audio attachment — transcribing...`);
+          console.log(`[Channel:Discord] Audio attachment - transcribing...`);
           const transcript = await transcribeAudio(localPath);
           inputParts.push(transcript.startsWith("Error:")
             ? `[Audio file: ${localPath}]\n${transcript}`
@@ -139,7 +139,7 @@ export class DiscordChannel extends BaseChannel {
       try {
         const completedTask = await taskQueue.waitForCompletion(task.id);
 
-        // Absorbed into a concurrent session — response already sent via original task
+        // Absorbed into a concurrent session - response already sent via original task
         if (this.isTaskMerged(completedTask)) {
           await this._removeReaction(message, "⏳");
           await this.sendReaction({ message }, "✅");

package/src/channels/EmailChannel.js

@@ -2,47 +2,75 @@ import { BaseChannel } from "./BaseChannel.js";
 import taskQueue from "../core/TaskQueue.js";
 
 /**
- * Email Channel — polls IMAP for incoming emails, replies via SMTP.
+ * Email Channel - polls IMAP for incoming emails, replies via SMTP or Resend.
  *
- * 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)
+ * Two setup options (can combine both):
+ *
+ * OPTION A - Resend (recommended, easiest):
+ *   RESEND_API_KEY=re_xxxx          → outbound sending via Resend
+ *   RESEND_FROM=you@yourdomain.com  → the "from" address (must be verified in Resend)
+ *
+ * OPTION B - Gmail IMAP/SMTP (traditional):
+ *   EMAIL_USER=you@gmail.com
+ *   EMAIL_PASSWORD=xxxx-xxxx-xxxx-xxxx  ← Gmail App Password (not your real password)
+ *   (IMAP/SMTP hosts default to Gmail - no need to set those)
+ *
+ * For full email agent (receive AND send), combine both or use Gmail IMAP/SMTP.
+ * Resend only handles outbound - you still need EMAIL_USER+PASSWORD for IMAP inbox polling.
  */
 export class EmailChannel extends BaseChannel {
   constructor(config) {
     super("email", config);
     this.transporter = null;
+    this.fromAddress = 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`);
+    const hasResend  = !!this.config.resendApiKey;
+    const hasSmtp    = !!(this.config.user && this.config.password);
+    const hasInbound = hasSmtp;  // IMAP requires EMAIL_USER + EMAIL_PASSWORD
+
+    if (!hasResend && !hasSmtp) {
+      console.log(`[Channel:Email] Skipped - set RESEND_API_KEY or 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})`);
+    // ── Outbound transport ────────────────────────────────────────────────────
+    if (hasResend) {
+      // Resend SMTP relay - no extra package needed, just nodemailer
+      this.transporter = nodemailer.default.createTransport({
+        host: "smtp.resend.com",
+        port: 465,
+        secure: true,
+        auth: { user: "resend", pass: this.config.resendApiKey },
+      });
+      this.fromAddress = this.config.resendFrom || `daemora@resend.dev`;
+      console.log(`[Channel:Email] Outbound: Resend (from: ${this.fromAddress})`);
+    } else {
+      // Traditional SMTP (Gmail, etc.)
+      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 },
+      });
+      this.fromAddress = this.config.user;
+      console.log(`[Channel:Email] Outbound: SMTP (${this.config.smtp.host})`);
+    }
 
-    // Poll immediately on start
-    this.pollEmails();
+    // ── Inbound polling (IMAP) ────────────────────────────────────────────────
+    if (hasInbound) {
+      this.running = true;
+      this.pollTimer = setInterval(() => this.pollEmails(), 60000);
+      console.log(`[Channel:Email] Inbound: IMAP polling every 60s (${this.config.user})`);
+      this.pollEmails();
+    } else {
+      console.log(`[Channel:Email] Inbound: disabled (set EMAIL_USER+EMAIL_PASSWORD to enable IMAP polling)`);
+    }
   }
 
   async stop() {
@@ -124,7 +152,7 @@ export class EmailChannel extends BaseChannel {
       const emailMatch = from.match(/<([^>]+)>/);
       const senderEmail = emailMatch ? emailMatch[1] : from;
 
-      // Extract body (simplified — takes text after headers)
+      // 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;
 
@@ -161,7 +189,7 @@ export class EmailChannel extends BaseChannel {
     if (!this.transporter) return;
 
     await this.transporter.sendMail({
-      from: this.config.user,
+      from: this.fromAddress,
       to: channelMeta.senderEmail,
       subject: `Re: ${channelMeta.subject}`,
       text: text,

package/src/channels/FeishuChannel.js

@@ -0,0 +1,140 @@
+import { BaseChannel } from "./BaseChannel.js";
+import taskQueue from "../core/TaskQueue.js";
+
+/**
+ * Feishu / Lark Channel - receives events via Feishu Event API (webhook mode).
+ *
+ * Setup:
+ * 1. Create a Feishu app at https://open.feishu.cn/app
+ * 2. Enable "Bot" capability and add "im:message:receive_v1" event subscription
+ * 3. Set the webhook URL to: https://your-domain.com/channels/feishu
+ * 4. Set env: FEISHU_APP_ID, FEISHU_APP_SECRET, FEISHU_VERIFICATION_TOKEN
+ *
+ * Config:
+ *   appId             - Feishu App ID
+ *   appSecret         - Feishu App Secret
+ *   verificationToken - Event verification token
+ *   port              - Webhook port (default 3004)
+ *   allowlist         - Optional array of Feishu open_id values
+ *   model             - Optional model override
+ */
+export class FeishuChannel extends BaseChannel {
+  constructor(config) {
+    super("feishu", config);
+    this.server = null;
+    this.accessToken = null;
+    this.tokenExpiry = 0;
+  }
+
+  async start() {
+    if (!this.config.appId || !this.config.appSecret) {
+      console.log("[Channel:Feishu] Skipped - missing FEISHU_APP_ID or FEISHU_APP_SECRET");
+      return;
+    }
+
+    const { createServer } = await import("node:http");
+
+    this.server = createServer(async (req, res) => {
+      if (req.method !== "POST" || req.url !== "/channels/feishu") {
+        res.writeHead(404).end();
+        return;
+      }
+
+      let body = "";
+      req.on("data", d => body += d);
+      req.on("end", async () => {
+        try {
+          const payload = JSON.parse(body);
+
+          // URL verification challenge
+          if (payload.type === "url_verification") {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ challenge: payload.challenge }));
+            return;
+          }
+
+          res.writeHead(200).end("ok");
+
+          const event = payload.event;
+          if (payload.header?.event_type !== "im.message.receive_v1") return;
+
+          const msg = event.message;
+          if (msg.message_type !== "text") return;
+
+          const senderId = event.sender?.sender_id?.open_id;
+          if (!senderId || !this.isAllowed(senderId)) return;
+
+          const content = JSON.parse(msg.content || "{}");
+          const input = content.text?.trim();
+          if (!input) return;
+
+          const channelMeta = {
+            chatId: event.message.chat_id,
+            senderId,
+            messageId: msg.message_id,
+          };
+
+          const task = await taskQueue.enqueue({
+            input,
+            channel: "feishu",
+            sessionId: this.getSessionId(senderId),
+            channelMeta,
+            model: this.getModel(),
+          });
+
+          const result = await taskQueue.waitForResult(task.id);
+          if (!this.isTaskMerged(result)) {
+            await this.sendReply(channelMeta, result.result || "(no response)");
+          }
+        } catch (err) {
+          console.log(`[Channel:Feishu] Error processing event: ${err.message}`);
+        }
+      });
+    });
+
+    const port = this.config.port || 3004;
+    await new Promise(resolve => this.server.listen(port, resolve));
+    this.running = true;
+    console.log(`[Channel:Feishu] Webhook listening on port ${port}/channels/feishu`);
+  }
+
+  async _getAccessToken() {
+    if (this.accessToken && Date.now() < this.tokenExpiry) return this.accessToken;
+    const fetchFn = globalThis.fetch || (await import("node-fetch")).default;
+    const res = await fetchFn("https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ app_id: this.config.appId, app_secret: this.config.appSecret }),
+    });
+    const data = await res.json();
+    this.accessToken = data.tenant_access_token;
+    this.tokenExpiry = Date.now() + (data.expire - 60) * 1000;
+    return this.accessToken;
+  }
+
+  async stop() {
+    if (this.server) {
+      await new Promise(resolve => this.server.close(resolve));
+      this.running = false;
+    }
+    console.log("[Channel:Feishu] Stopped");
+  }
+
+  async sendReply(channelMeta, text) {
+    if (!channelMeta?.chatId) return;
+    const token = await this._getAccessToken();
+    const fetchFn = globalThis.fetch || (await import("node-fetch")).default;
+    await fetchFn("https://open.feishu.cn/open-apis/im/v1/messages?receive_id_type=chat_id", {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${token}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        receive_id: channelMeta.chatId,
+        msg_type: "text",
+        content: JSON.stringify({ text }),
+      }),
+    });
+  }
+}

package/src/channels/GoogleChatChannel.js

@@ -6,7 +6,7 @@ import { join, extname } from "node:path";
 import { tmpdir } from "node:os";
 
 /**
- * Google Chat Channel — receives messages via Chat App webhook.
+ * Google Chat Channel - receives messages via Chat App webhook.
  *
  * Setup:
  * 1. Go to https://console.cloud.google.com → New project → Enable "Google Chat API"
@@ -19,10 +19,10 @@ import { tmpdir } from "node:os";
  * 4. Set GOOGLE_CHAT_PROJECT_NUMBER (from Google Cloud project settings)
  *
  * Config:
- *   serviceAccount — JSON string of service account key (GOOGLE_CHAT_SERVICE_ACCOUNT)
- *   projectNumber  — Google Cloud project number (GOOGLE_CHAT_PROJECT_NUMBER)
- *   allowlist      — Optional array of Google user IDs / emails allowed to use the bot
- *   model          — Optional model override
+ *   serviceAccount - JSON string of service account key (GOOGLE_CHAT_SERVICE_ACCOUNT)
+ *   projectNumber  - Google Cloud project number (GOOGLE_CHAT_PROJECT_NUMBER)
+ *   allowlist      - Optional array of Google user IDs / emails allowed to use the bot
+ *   model          - Optional model override
  *
  * Unlike OpenClaw's 1000+ LOC implementation with multi-account support,
  * streaming coalescing, and GraphQL-style actions, this keeps it simple:
@@ -36,7 +36,7 @@ export class GoogleChatChannel extends BaseChannel {
 
   async start() {
     if (!this.config.serviceAccount) {
-      console.log(`[Channel:GoogleChat] Skipped — set GOOGLE_CHAT_SERVICE_ACCOUNT`);
+      console.log(`[Channel:GoogleChat] Skipped - set GOOGLE_CHAT_SERVICE_ACCOUNT`);
       return;
     }
 
@@ -46,7 +46,7 @@ export class GoogleChatChannel extends BaseChannel {
       this.running = true;
       console.log(`[Channel:GoogleChat] Ready (webhook: POST /webhooks/googlechat)`);
       if (this.config.allowlist?.length) {
-        console.log(`[Channel:GoogleChat] Allowlist active — ${this.config.allowlist.length} authorized user(s)`);
+        console.log(`[Channel:GoogleChat] Allowlist active - ${this.config.allowlist.length} authorized user(s)`);
       }
     } catch (err) {
       console.log(`[Channel:GoogleChat] Failed to initialise auth: ${err.message}`);
@@ -130,7 +130,7 @@ export class GoogleChatChannel extends BaseChannel {
     const input = inputParts.join("\n");
     console.log(`[Channel:GoogleChat] Message from ${userName} (${userId}): "${input.slice(0, 80)}"`);
 
-    // Enqueue and wait — Google Chat allows up to 30s for synchronous reply
+    // Enqueue and wait - Google Chat allows up to 30s for synchronous reply
     const task = taskQueue.enqueue({
       input,
       channel:     "googlechat",

package/src/channels/HttpChannel.js

@@ -1,7 +1,7 @@
 import { BaseChannel } from "./BaseChannel.js";
 
 /**
- * HTTP Channel — already handled by Express routes in index.js.
+ * HTTP Channel - already handled by Express routes in index.js.
  * This class exists for registry consistency but delegates to existing routes.
  */
 export class HttpChannel extends BaseChannel {
@@ -20,7 +20,7 @@ export class HttpChannel extends BaseChannel {
   }
 
   async sendReply(channelMeta, text) {
-    // HTTP is sync — response sent directly in the route handler
+    // HTTP is sync - response sent directly in the route handler
     // No async reply needed
   }
 }

package/src/channels/IRCChannel.js

@@ -0,0 +1,144 @@
+import { BaseChannel } from "./BaseChannel.js";
+import taskQueue from "../core/TaskQueue.js";
+import { createConnection } from "node:net";
+import { createInterface } from "node:readline";
+
+/**
+ * IRC Channel - connects to an IRC server and responds to direct messages and !ask commands.
+ *
+ * Setup:
+ * 1. Set env: IRC_SERVER, IRC_PORT (default 6667), IRC_NICK, IRC_CHANNEL (optional)
+ *    Optional: IRC_PASSWORD (NickServ), IRC_COMMAND_PREFIX (default "!ask")
+ *
+ * Config:
+ *   server    - IRC server hostname (e.g. irc.libera.chat)
+ *   port      - Port (default 6667, use 6697 for SSL)
+ *   nick      - Bot nickname
+ *   channel   - Channel to join (with #)
+ *   password  - NickServ password (optional)
+ *   prefix    - Command prefix (default "!ask")
+ *   allowlist - Optional array of IRC nicks
+ *   model     - Optional model override
+ */
+export class IRCChannel extends BaseChannel {
+  constructor(config) {
+    super("irc", config);
+    this.socket = null;
+    this.rl = null;
+    this.nick = config.nick || "daemora-bot";
+    this.server = config.server;
+    this.port = config.port || 6667;
+    this.ircChannel = config.channel;
+    this.prefix = config.prefix || "!ask";
+  }
+
+  async start() {
+    if (!this.server || !this.nick) {
+      console.log("[Channel:IRC] Skipped - missing IRC_SERVER or IRC_NICK");
+      return;
+    }
+
+    try {
+      this.socket = createConnection(this.port, this.server);
+      this.rl = createInterface({ input: this.socket });
+
+      this.socket.on("connect", () => {
+        if (this.config.password) {
+          this._send(`PASS ${this.config.password}`);
+        }
+        this._send(`NICK ${this.nick}`);
+        this._send(`USER ${this.nick} 0 * :Daemora Agent Bot`);
+        if (this.ircChannel) {
+          setTimeout(() => this._send(`JOIN ${this.ircChannel}`), 3000);
+        }
+        this.running = true;
+        console.log(`[Channel:IRC] Connected to ${this.server}:${this.port}`);
+      });
+
+      this.rl.on("line", async (line) => {
+        // PING/PONG keep-alive
+        if (line.startsWith("PING")) {
+          this._send(`PONG ${line.slice(5)}`);
+          return;
+        }
+
+        // Parse PRIVMSG: :nick!user@host PRIVMSG target :message
+        const match = line.match(/^:(\S+?)!(\S+)@\S+ PRIVMSG (\S+) :(.+)$/);
+        if (!match) return;
+
+        const [, senderNick, , target, message] = match;
+        if (senderNick.toLowerCase() === this.nick.toLowerCase()) return;
+
+        // Determine if it's a DM (target === our nick) or channel command
+        const isDM = target.toLowerCase() === this.nick.toLowerCase();
+        const hasPrefix = message.toLowerCase().startsWith(this.prefix.toLowerCase());
+        const mentioned = message.toLowerCase().includes(this.nick.toLowerCase());
+
+        if (!isDM && !hasPrefix && !mentioned) return;
+        if (!this.isAllowed(senderNick)) return;
+
+        const input = isDM
+          ? message.trim()
+          : message.replace(new RegExp(`^${this.prefix}\\s*`, "i"), "")
+                   .replace(new RegExp(`${this.nick}[:,]?\\s*`, "ig"), "")
+                   .trim();
+
+        if (!input) return;
+
+        const replyTarget = isDM ? senderNick : target;
+        const channelMeta = { target: replyTarget, nick: senderNick };
+
+        const task = await taskQueue.enqueue({
+          input,
+          channel: "irc",
+          sessionId: this.getSessionId(senderNick),
+          channelMeta,
+          model: this.getModel(),
+        });
+
+        const result = await taskQueue.waitForResult(task.id);
+        if (!this.isTaskMerged(result)) {
+          await this.sendReply(channelMeta, result.result || "(no response)");
+        }
+      });
+
+      this.socket.on("error", (err) => console.log(`[Channel:IRC] Error: ${err.message}`));
+      this.socket.on("close", () => {
+        this.running = false;
+        console.log("[Channel:IRC] Disconnected");
+      });
+    } catch (err) {
+      console.log(`[Channel:IRC] Failed to start: ${err.message}`);
+    }
+  }
+
+  _send(text) {
+    if (this.socket?.writable) {
+      this.socket.write(`${text}\r\n`);
+    }
+  }
+
+  async stop() {
+    if (this.socket) {
+      this._send("QUIT :Daemora shutting down");
+      this.socket.destroy();
+      this.running = false;
+    }
+    console.log("[Channel:IRC] Stopped");
+  }
+
+  async sendReply(channelMeta, text) {
+    if (!channelMeta?.target) return;
+    // Split long responses into multiple lines (IRC limit 512 bytes per message)
+    const lines = text.split("\n").flatMap(line =>
+      line.match(/.{1,400}/g) || [line]
+    );
+    for (const line of lines.slice(0, 20)) { // max 20 lines to avoid flood
+      this._send(`PRIVMSG ${channelMeta.target} :${line}`);
+      await new Promise(r => setTimeout(r, 100)); // anti-flood delay
+    }
+    if (lines.length > 20) {
+      this._send(`PRIVMSG ${channelMeta.target} :(${lines.length - 20} more lines truncated)`);
+    }
+  }
+}