daemora 1.0.1 → 1.0.3

package/src/channels/SlackChannel.js

@@ -7,9 +7,9 @@ import { join, extname, basename } from "node:path";
 import { tmpdir } from "node:os";
 
 /**
- * Slack Channel — receives messages via Slack Bolt + Socket Mode.
+ * Slack Channel - receives messages via Slack Bolt + Socket Mode.
  *
- * Socket Mode means NO public webhook URL needed — works on any machine.
+ * 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
@@ -25,10 +25,10 @@ import { tmpdir } from "node:os";
  * 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
+ *   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)
@@ -43,7 +43,7 @@ export class SlackChannel extends BaseChannel {
 
   async start() {
     if (!this.config.botToken || !this.config.appToken) {
-      console.log(`[Channel:Slack] Skipped — need SLACK_BOT_TOKEN and SLACK_APP_TOKEN`);
+      console.log(`[Channel:Slack] Skipped - need SLACK_BOT_TOKEN and SLACK_APP_TOKEN`);
       return;
     }
 
@@ -119,7 +119,7 @@ export class SlackChannel extends BaseChannel {
       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)`);
+        console.log(`[Channel:Slack] Allowlist active - ${this.config.allowlist.length} authorized user(s)`);
       }
     } catch (err) {
       console.log(`[Channel:Slack] Failed to start: ${err.message}`);
@@ -147,7 +147,7 @@ export class SlackChannel extends BaseChannel {
 
       const mimeType = file.mimetype || "";
       if (mimeType.startsWith("audio/")) {
-        console.log(`[Channel:Slack] Audio file — transcribing...`);
+        console.log(`[Channel:Slack] Audio file - transcribing...`);
         const transcript = await transcribeAudio(localPath);
         inputParts.push(transcript.startsWith("Error:")
           ? `[Audio file: ${localPath}]\n${transcript}`
@@ -174,7 +174,7 @@ export class SlackChannel 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(channelId, messageTs, "hourglass_flowing_sand");
         await this._addReaction(channelId, messageTs, "white_check_mark");

package/src/channels/TeamsChannel.js

@@ -6,7 +6,7 @@ import { join, extname } from "node:path";
 import { tmpdir } from "node:os";
 
 /**
- * Microsoft Teams Channel — receives messages via Bot Framework v4 (CloudAdapter).
+ * Microsoft Teams Channel - receives messages via Bot Framework v4 (CloudAdapter).
  *
  * Setup:
  * 1. Go to https://portal.azure.com → Create a resource → Azure Bot
@@ -16,10 +16,10 @@ import { tmpdir } from "node:os";
  * 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
+ *   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.
@@ -36,7 +36,7 @@ export class TeamsChannel extends BaseChannel {
 
   async start() {
     if (!this.config.appId || !this.config.appPassword) {
-      console.log(`[Channel:Teams] Skipped — set TEAMS_APP_ID and TEAMS_APP_PASSWORD`);
+      console.log(`[Channel:Teams] Skipped - set TEAMS_APP_ID and TEAMS_APP_PASSWORD`);
       return;
     }
 
@@ -63,7 +63,7 @@ export class TeamsChannel extends BaseChannel {
     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)`);
+      console.log(`[Channel:Teams] Allowlist active - ${this.config.allowlist.length} authorized user(s)`);
     }
   }
 
@@ -148,10 +148,10 @@ export class TeamsChannel extends BaseChannel {
       const ref = this._TurnContext.getConversationReference(context.activity);
       this._conversationRefs.set(userId, ref);
 
-      // Ack with typing indicator — keeps Teams from showing "delivery failed"
+      // 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)
+      // Enqueue task and reply proactively (don't await - we must return within 5s)
       const task = taskQueue.enqueue({
         input,
         channel:     "teams",
@@ -209,7 +209,7 @@ export class TeamsChannel extends BaseChannel {
     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.
+      // Full file upload requires Graph API + bot permissions - out of scope here.
       const msg = caption
         ? `${caption}\n(File: ${filePath})`
         : `File: ${filePath}`;

package/src/channels/TelegramChannel.js

@@ -6,7 +6,7 @@ import { join, extname } from "node:path";
 import { tmpdir } from "node:os";
 
 /**
- * Telegram Channel — receives messages via Telegram Bot API (grammy).
+ * Telegram Channel - receives messages via Telegram Bot API (grammy).
  *
  * Handles:
  *   ✅ Text messages
@@ -23,9 +23,9 @@ import { tmpdir } from "node:os";
  *   ✅ Documents (any other file)
  *
  * Config:
- *   token     — Bot token from @BotFather
- *   allowlist — Optional array of chat IDs allowed to send tasks. Empty = open.
- *   model     — Optional model override
+ *   token     - Bot token from @BotFather
+ *   allowlist - Optional array of chat IDs allowed to send tasks. Empty = open.
+ *   model     - Optional model override
  */
 export class TelegramChannel extends BaseChannel {
   constructor(config) {
@@ -38,7 +38,7 @@ export class TelegramChannel extends BaseChannel {
     this._InputFile = InputFile;
 
     if (!this.config.token) {
-      console.log(`[Channel:Telegram] Skipped — no TELEGRAM_BOT_TOKEN`);
+      console.log(`[Channel:Telegram] Skipped - no TELEGRAM_BOT_TOKEN`);
       return;
     }
 
@@ -78,7 +78,7 @@ export class TelegramChannel extends BaseChannel {
         return;
       }
 
-      console.log(`[Channel:Telegram] Voice from ${userName} (${chatId}) — transcribing...`);
+      console.log(`[Channel:Telegram] Voice from ${userName} (${chatId}) - transcribing...`);
       await ctx.replyWithChatAction("typing");
       await this.sendReaction({ chatId, messageId: ctx.message.message_id }, "⏳");
 
@@ -198,7 +198,7 @@ export class TelegramChannel extends BaseChannel {
     this.running = true;
     console.log(`[Channel:Telegram] Started as @${me.username}`);
     if (this.config.allowlist?.length) {
-      console.log(`[Channel:Telegram] Allowlist active — ${this.config.allowlist.length} authorized chat(s)`);
+      console.log(`[Channel:Telegram] Allowlist active - ${this.config.allowlist.length} authorized chat(s)`);
     }
   }
 
@@ -218,7 +218,7 @@ export class TelegramChannel extends BaseChannel {
     try {
       const completedTask = await taskQueue.waitForCompletion(task.id);
 
-      // Task was absorbed into a concurrent agent session — response already sent
+      // Task was absorbed into a concurrent agent session - response already sent
       if (this.isTaskMerged(completedTask)) {
         await this.sendReaction({ chatId, messageId }, "✅");
         return;

package/src/channels/TwitchChannel.js

@@ -0,0 +1,128 @@
+import { BaseChannel } from "./BaseChannel.js";
+import taskQueue from "../core/TaskQueue.js";
+
+/**
+ * Twitch Channel - receives chat commands via Twitch IRC (TMI).
+ *
+ * Setup:
+ * 1. Create a Twitch app at https://dev.twitch.tv/console
+ * 2. Generate an OAuth token for the bot account (chat:read, chat:edit scope)
+ *    Use: https://twitchapps.com/tmi/
+ * 3. Set env: TWITCH_BOT_USERNAME, TWITCH_OAUTH_TOKEN, TWITCH_CHANNEL
+ *
+ * The bot responds to "!ask <question>" or "@botname <question>" in chat.
+ *
+ * Config:
+ *   username   - Bot Twitch username
+ *   token      - OAuth token (without "oauth:" prefix)
+ *   channel    - Twitch channel to join (without #)
+ *   prefix     - Command prefix, default "!ask"
+ *   allowlist  - Optional array of Twitch usernames (mods, subscribers, etc.)
+ *   model      - Optional model override
+ */
+export class TwitchChannel extends BaseChannel {
+  constructor(config) {
+    super("twitch", config);
+    this.ws = null;
+    this.channel = (config.channel || "").toLowerCase();
+    this.prefix = config.prefix || "!ask";
+  }
+
+  async start() {
+    if (!this.config.username || !this.config.token || !this.channel) {
+      console.log("[Channel:Twitch] Skipped - missing TWITCH_BOT_USERNAME, TWITCH_OAUTH_TOKEN, or TWITCH_CHANNEL");
+      return;
+    }
+
+    try {
+      const { WebSocket } = await import("ws");
+      this.ws = new WebSocket("wss://irc-ws.chat.twitch.tv:443");
+
+      this.ws.on("open", () => {
+        this.ws.send(`PASS oauth:${this.config.token}`);
+        this.ws.send(`NICK ${this.config.username}`);
+        this.ws.send(`JOIN #${this.channel}`);
+        this.running = true;
+        console.log(`[Channel:Twitch] Connected to #${this.channel}`);
+      });
+
+      this.ws.on("message", async (raw) => {
+        const line = raw.toString().trim();
+
+        // Keep alive
+        if (line.startsWith("PING")) {
+          this.ws.send("PONG :tmi.twitch.tv");
+          return;
+        }
+
+        // Parse: :user!user@user.tmi.twitch.tv PRIVMSG #channel :message
+        const match = line.match(/^:(\w+)!\w+@\w+\.tmi\.twitch\.tv PRIVMSG #(\w+) :(.+)$/);
+        if (!match) return;
+
+        const [, username, , message] = match;
+        if (username.toLowerCase() === this.config.username.toLowerCase()) return;
+
+        // Check for command prefix or @mention
+        const mentioned = message.toLowerCase().includes(`@${this.config.username.toLowerCase()}`);
+        const hasPrefix = message.toLowerCase().startsWith(this.prefix.toLowerCase());
+        if (!hasPrefix && !mentioned) return;
+
+        if (!this.isAllowed(username)) {
+          this._sendChat(`@${username} Sorry, you're not on the allowlist.`);
+          return;
+        }
+
+        const input = message
+          .replace(new RegExp(`^${this.prefix}\\s*`, "i"), "")
+          .replace(new RegExp(`@${this.config.username}\\s*`, "ig"), "")
+          .trim();
+
+        if (!input) return;
+
+        const channelMeta = { channel: this.channel, username };
+
+        const task = await taskQueue.enqueue({
+          input,
+          channel: "twitch",
+          sessionId: this.getSessionId(username),
+          channelMeta,
+          model: this.getModel(),
+        });
+
+        const result = await taskQueue.waitForResult(task.id);
+        if (!this.isTaskMerged(result)) {
+          // Twitch chat max 500 chars per message
+          const reply = (result.result || "(no response)").slice(0, 490);
+          this._sendChat(`@${username} ${reply}`);
+        }
+      });
+
+      this.ws.on("error", (err) => console.log(`[Channel:Twitch] WS error: ${err.message}`));
+      this.ws.on("close", () => {
+        this.running = false;
+        console.log("[Channel:Twitch] Disconnected");
+      });
+    } catch (err) {
+      console.log(`[Channel:Twitch] Failed to start: ${err.message}`);
+    }
+  }
+
+  _sendChat(text) {
+    if (this.ws?.readyState === 1) {
+      this.ws.send(`PRIVMSG #${this.channel} :${text.slice(0, 490)}`);
+    }
+  }
+
+  async stop() {
+    if (this.ws) {
+      this.ws.close();
+      this.running = false;
+    }
+    console.log("[Channel:Twitch] Stopped");
+  }
+
+  async sendReply(channelMeta, text) {
+    const prefix = channelMeta?.username ? `@${channelMeta.username} ` : "";
+    this._sendChat(`${prefix}${text.slice(0, 490 - prefix.length)}`);
+  }
+}

package/src/channels/WhatsAppChannel.js

@@ -6,7 +6,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 /**
- * WhatsApp Channel — receives messages via Twilio webhook.
+ * WhatsApp Channel - receives messages via Twilio webhook.
  *
  * Setup:
  * 1. Create Twilio account + WhatsApp sandbox
@@ -14,11 +14,11 @@ import { tmpdir } from "node:os";
  * 3. Set env: TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN, TWILIO_WHATSAPP_FROM
  *
  * Config:
- *   accountSid — Twilio account SID
- *   authToken  — Twilio auth token
- *   from       — Your WhatsApp number (whatsapp:+14155238886)
- *   allowlist  — Optional array of phone numbers (+1234567890) allowed to send tasks
- *   model      — Optional model override
+ *   accountSid - Twilio account SID
+ *   authToken  - Twilio auth token
+ *   from       - Your WhatsApp number (whatsapp:+14155238886)
+ *   allowlist  - Optional array of phone numbers (+1234567890) allowed to send tasks
+ *   model      - Optional model override
  */
 export class WhatsAppChannel extends BaseChannel {
   constructor(config) {
@@ -28,7 +28,7 @@ export class WhatsAppChannel extends BaseChannel {
 
   async start() {
     if (!this.config.accountSid || !this.config.authToken) {
-      console.log(`[Channel:WhatsApp] Skipped — no Twilio credentials`);
+      console.log(`[Channel:WhatsApp] Skipped - no Twilio credentials`);
       return;
     }
 
@@ -37,7 +37,7 @@ export class WhatsAppChannel extends BaseChannel {
     this.running = true;
     console.log(`[Channel:WhatsApp] Ready (webhook: POST /webhooks/whatsapp)`);
     if (this.config.allowlist?.length) {
-      console.log(`[Channel:WhatsApp] Allowlist active — ${this.config.allowlist.length} authorized number(s)`);
+      console.log(`[Channel:WhatsApp] Allowlist active - ${this.config.allowlist.length} authorized number(s)`);
     }
   }
 
@@ -78,7 +78,7 @@ export class WhatsAppChannel extends BaseChannel {
       if (!localPath) continue;
 
       if (mediaType.startsWith("audio/")) {
-        console.log(`[Channel:WhatsApp] Audio media — transcribing...`);
+        console.log(`[Channel:WhatsApp] Audio media - transcribing...`);
         const transcript = await transcribeAudio(localPath);
         inputParts.push(transcript.startsWith("Error:")
           ? `[Audio file: ${localPath}]\n${transcript}`
@@ -106,7 +106,7 @@ export class WhatsAppChannel extends BaseChannel {
     // Wait for completion
     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)) return;
 
     // Send reply via Twilio

package/src/channels/ZaloChannel.js

@@ -0,0 +1,119 @@
+import { BaseChannel } from "./BaseChannel.js";
+import taskQueue from "../core/TaskQueue.js";
+
+/**
+ * Zalo Channel - receives messages via Zalo Official Account API.
+ * Popular messaging platform in Vietnam (~75M users).
+ *
+ * Setup:
+ * 1. Create a Zalo Official Account at https://oa.zalo.me
+ * 2. Register an app and get App ID + App Secret
+ * 3. Get an access token via OAuth or ZCA token
+ * 4. Set env: ZALO_APP_ID, ZALO_APP_SECRET, ZALO_ACCESS_TOKEN
+ * 5. Configure webhook URL: https://your-domain.com/channels/zalo
+ *
+ * Config:
+ *   appId       - Zalo App ID
+ *   appSecret   - Zalo App Secret
+ *   accessToken - Zalo OA access token
+ *   port        - Webhook port (default 3005)
+ *   allowlist   - Optional array of Zalo user IDs
+ *   model       - Optional model override
+ */
+export class ZaloChannel extends BaseChannel {
+  constructor(config) {
+    super("zalo", config);
+    this.server = null;
+  }
+
+  async start() {
+    if (!this.config.appId || !this.config.accessToken) {
+      console.log("[Channel:Zalo] Skipped - missing ZALO_APP_ID or ZALO_ACCESS_TOKEN");
+      return;
+    }
+
+    const { createServer } = await import("node:http");
+
+    this.server = createServer(async (req, res) => {
+      if (req.url !== "/channels/zalo") {
+        res.writeHead(404).end();
+        return;
+      }
+
+      // Zalo sends GET for webhook verification
+      if (req.method === "GET") {
+        const url = new URL(req.url, `http://localhost`);
+        const challenge = url.searchParams.get("challenge");
+        res.writeHead(200, { "Content-Type": "text/plain" });
+        res.end(challenge || "ok");
+        return;
+      }
+
+      if (req.method !== "POST") {
+        res.writeHead(405).end();
+        return;
+      }
+
+      let body = "";
+      req.on("data", d => body += d);
+      req.on("end", async () => {
+        res.writeHead(200).end("ok");
+        try {
+          const payload = JSON.parse(body);
+          if (payload.event_name !== "user_send_text") return;
+
+          const senderId = payload.sender?.id;
+          if (!senderId || !this.isAllowed(senderId)) return;
+
+          const input = payload.message?.text?.trim();
+          if (!input) return;
+
+          const channelMeta = { senderId };
+          const task = await taskQueue.enqueue({
+            input,
+            channel: "zalo",
+            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:Zalo] Error: ${err.message}`);
+        }
+      });
+    });
+
+    const port = this.config.port || 3005;
+    await new Promise(resolve => this.server.listen(port, resolve));
+    this.running = true;
+    console.log(`[Channel:Zalo] Webhook listening on port ${port}/channels/zalo`);
+  }
+
+  async stop() {
+    if (this.server) {
+      await new Promise(resolve => this.server.close(resolve));
+      this.running = false;
+    }
+    console.log("[Channel:Zalo] Stopped");
+  }
+
+  async sendReply(channelMeta, text) {
+    if (!channelMeta?.senderId) return;
+    const fetchFn = globalThis.fetch || (await import("node-fetch")).default;
+    await fetchFn(`https://openapi.zalo.me/v3.0/oa/message/cs`, {
+      method: "POST",
+      headers: {
+        "access_token": this.config.accessToken,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        recipient: { user_id: channelMeta.senderId },
+        message: { text: text.slice(0, 2000) },
+      }),
+    });
+  }
+}

package/src/channels/iMessageChannel.js

@@ -0,0 +1,150 @@
+import { BaseChannel } from "./BaseChannel.js";
+import taskQueue from "../core/TaskQueue.js";
+import { execSync } from "node:child_process";
+
+/**
+ * iMessage Channel - send/receive iMessages on macOS via AppleScript.
+ *
+ * Setup:
+ * 1. Must run on macOS with Messages app configured
+ * 2. Grant Accessibility and Automation permissions to Terminal/Node
+ * 3. Set env: IMESSAGE_POLL_INTERVAL_MS (default 5000)
+ *    Optional: IMESSAGE_ALLOWLIST - comma-separated phone numbers/emails
+ *
+ * Note: Polling-based (reads latest unread messages periodically).
+ * This is a best-effort implementation — macOS AppleScript access to iMessages
+ * has limitations; consider BlueBubbles channel for more reliable access.
+ *
+ * Config:
+ *   pollIntervalMs - How often to check for new messages (default 5000)
+ *   allowlist      - Optional array of phone numbers/emails
+ *   model          - Optional model override
+ */
+export class iMessageChannel extends BaseChannel {
+  constructor(config) {
+    super("imessage", config);
+    this.pollInterval = null;
+    this.pollMs = config.pollIntervalMs || 5000;
+    this.lastChecked = new Date();
+    this.processedIds = new Set();
+  }
+
+  async start() {
+    if (process.platform !== "darwin") {
+      console.log("[Channel:iMessage] Skipped - macOS only");
+      return;
+    }
+
+    try {
+      // Test that osascript can access Messages
+      execSync("osascript -e 'tell application \"Messages\" to count chats'", { timeout: 5000 });
+    } catch {
+      console.log("[Channel:iMessage] Skipped - cannot access Messages app (check Accessibility permissions)");
+      return;
+    }
+
+    this.running = true;
+    console.log(`[Channel:iMessage] Started polling every ${this.pollMs}ms`);
+
+    this.pollInterval = setInterval(() => this._poll(), this.pollMs);
+  }
+
+  async _poll() {
+    try {
+      const script = `
+        tell application "Messages"
+          set output to {}
+          repeat with aChat in chats
+            if (count of messages of aChat) > 0 then
+              set lastMsg to last message of aChat
+              set msgDate to date sent of lastMsg
+              set msgId to id of lastMsg
+              if msgDate > date "${this.lastChecked.toLocaleString()}" then
+                if incoming of lastMsg then
+                  set msgContent to content of lastMsg
+                  set senderId to handle id of sender of lastMsg
+                  set end of output to msgId & "|" & senderId & "|" & msgContent
+                end if
+              end if
+            end if
+          end repeat
+          return output
+        end tell
+      `;
+
+      let raw;
+      try {
+        raw = execSync(`osascript -e '${script.replace(/'/g, "\\'")}'`, {
+          encoding: "utf-8", timeout: 10000
+        });
+      } catch { return; }
+
+      this.lastChecked = new Date();
+      if (!raw.trim()) return;
+
+      const messages = raw.trim().split(", ");
+      for (const msg of messages) {
+        const [id, sender, ...contentParts] = msg.split("|");
+        const content = contentParts.join("|").trim();
+        if (!id || !sender || !content) continue;
+        if (this.processedIds.has(id)) continue;
+        this.processedIds.add(id);
+
+        if (!this.isAllowed(sender)) continue;
+
+        const channelMeta = { sender, chatId: sender };
+        const task = await taskQueue.enqueue({
+          input: content,
+          channel: "imessage",
+          sessionId: this.getSessionId(sender),
+          channelMeta,
+          model: this.getModel(),
+        });
+
+        taskQueue.waitForResult(task.id).then(result => {
+          if (!this.isTaskMerged(result)) {
+            this.sendReply(channelMeta, result.result || "(no response)");
+          }
+        }).catch(() => {});
+      }
+
+      // Keep processedIds from growing unbounded
+      if (this.processedIds.size > 1000) {
+        const arr = [...this.processedIds];
+        this.processedIds = new Set(arr.slice(-500));
+      }
+    } catch (err) {
+      // Silent — polling failures are expected occasionally
+    }
+  }
+
+  async stop() {
+    if (this.pollInterval) {
+      clearInterval(this.pollInterval);
+      this.pollInterval = null;
+    }
+    this.running = false;
+    console.log("[Channel:iMessage] Stopped");
+  }
+
+  async sendReply(channelMeta, text) {
+    if (!channelMeta?.sender) return;
+    const sender = channelMeta.sender;
+    // Split into chunks (AppleScript may time out on very long strings)
+    const chunks = text.match(/[\s\S]{1,1000}/g) || [text];
+    for (const chunk of chunks) {
+      const script = `
+        tell application "Messages"
+          set targetService to 1st service whose service type = iMessage
+          set targetBuddy to buddy "${sender.replace(/"/g, '\\"')}" of targetService
+          send "${chunk.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}" to targetBuddy
+        end tell
+      `;
+      try {
+        execSync(`osascript -e '${script.replace(/'/g, "\\'")}'`, { timeout: 10000 });
+      } catch (err) {
+        console.log(`[Channel:iMessage] Send error: ${err.message}`);
+      }
+    }
+  }
+}