@nextclaw/channel-runtime 0.1.4 → 0.1.5

package/dist/index.js

@@ -228,6 +228,9 @@ var DEFAULT_MEDIA_MAX_MB = 8;
 var MEDIA_FETCH_TIMEOUT_MS = 15e3;
 var TYPING_HEARTBEAT_MS = 8e3;
 var TYPING_AUTO_STOP_MS = 45e3;
+var DISCORD_TEXT_LIMIT = 2e3;
+var DISCORD_MAX_LINES_PER_MESSAGE = 17;
+var FENCE_RE = /^( {0,3})(`{3,}|~{3,})(.*)$/;
 var DiscordChannel = class extends BaseChannel {
   name = "discord";
   client = null;
@@ -285,16 +288,23 @@ var DiscordChannel = class extends BaseChannel {
     }
     this.stopTyping(msg.chatId);
     const textChannel = channel;
-    const payload = {
-      content: msg.content ?? ""
-    };
-    if (msg.replyTo) {
-      payload.reply = { messageReference: msg.replyTo };
+    const chunks = chunkDiscordText(msg.content ?? "");
+    if (chunks.length === 0) {
+      return;
     }
-    if (msg.metadata?.silent === true) {
-      payload.flags = MessageFlags.SuppressNotifications;
+    const flags = msg.metadata?.silent === true ? MessageFlags.SuppressNotifications : void 0;
+    for (const chunk of chunks) {
+      const payload = {
+        content: chunk
+      };
+      if (msg.replyTo) {
+        payload.reply = { messageReference: msg.replyTo };
+      }
+      if (flags !== void 0) {
+        payload.flags = flags;
+      }
+      await textChannel.send(payload);
     }
-    await textChannel.send(payload);
   }
   async handleIncoming(message) {
     const selfUserId = this.client?.user?.id;
@@ -533,6 +543,159 @@ function buildAttachmentSummary(attachments) {
   }
   return `<media:document> (${count} ${count === 1 ? "file" : "files"})`;
 }
+function countLines(text) {
+  if (!text) {
+    return 0;
+  }
+  return text.split("\n").length;
+}
+function parseFenceLine(line) {
+  const match = line.match(FENCE_RE);
+  if (!match) {
+    return null;
+  }
+  const indent = match[1] ?? "";
+  const marker = match[2] ?? "";
+  return {
+    indent,
+    markerChar: marker[0] ?? "`",
+    markerLen: marker.length,
+    openLine: line
+  };
+}
+function closeFenceLine(openFence) {
+  return `${openFence.indent}${openFence.markerChar.repeat(openFence.markerLen)}`;
+}
+function closeFenceIfNeeded(text, openFence) {
+  if (!openFence) {
+    return text;
+  }
+  const closeLine = closeFenceLine(openFence);
+  if (!text) {
+    return closeLine;
+  }
+  if (!text.endsWith("\n")) {
+    return `${text}
+${closeLine}`;
+  }
+  return `${text}${closeLine}`;
+}
+function splitLongLine(line, maxChars, opts) {
+  const limit = Math.max(1, Math.floor(maxChars));
+  if (line.length <= limit) {
+    return [line];
+  }
+  const chunks = [];
+  let remaining = line;
+  while (remaining.length > limit) {
+    if (opts.preserveWhitespace) {
+      chunks.push(remaining.slice(0, limit));
+      remaining = remaining.slice(limit);
+      continue;
+    }
+    const window = remaining.slice(0, limit);
+    let breakIndex = -1;
+    for (let index = window.length - 1; index >= 0; index -= 1) {
+      if (/\s/.test(window[index])) {
+        breakIndex = index;
+        break;
+      }
+    }
+    if (breakIndex <= 0) {
+      breakIndex = limit;
+    }
+    chunks.push(remaining.slice(0, breakIndex));
+    remaining = remaining.slice(breakIndex);
+  }
+  if (remaining.length) {
+    chunks.push(remaining);
+  }
+  return chunks;
+}
+function chunkDiscordText(text, opts = {}) {
+  const maxChars = Math.max(1, Math.floor(opts.maxChars ?? DISCORD_TEXT_LIMIT));
+  const maxLines = Math.max(1, Math.floor(opts.maxLines ?? DISCORD_MAX_LINES_PER_MESSAGE));
+  const body = text ?? "";
+  if (!body) {
+    return [];
+  }
+  if (body.length <= maxChars && countLines(body) <= maxLines) {
+    return [body];
+  }
+  const lines = body.split("\n");
+  const chunks = [];
+  let current = "";
+  let currentLines = 0;
+  let openFence = null;
+  const flush = () => {
+    if (!current) {
+      return;
+    }
+    const payload = closeFenceIfNeeded(current, openFence);
+    if (payload.trim().length) {
+      chunks.push(payload);
+    }
+    current = "";
+    currentLines = 0;
+    if (openFence) {
+      current = openFence.openLine;
+      currentLines = 1;
+    }
+  };
+  for (const line of lines) {
+    const fenceInfo = parseFenceLine(line);
+    const wasInsideFence = openFence !== null;
+    let nextOpenFence = openFence;
+    if (fenceInfo) {
+      if (!openFence) {
+        nextOpenFence = fenceInfo;
+      } else if (openFence.markerChar === fenceInfo.markerChar && fenceInfo.markerLen >= openFence.markerLen) {
+        nextOpenFence = null;
+      }
+    }
+    const reserveChars = nextOpenFence ? closeFenceLine(nextOpenFence).length + 1 : 0;
+    const reserveLines = nextOpenFence ? 1 : 0;
+    const effectiveMaxChars = maxChars - reserveChars;
+    const effectiveMaxLines = maxLines - reserveLines;
+    const charLimit = effectiveMaxChars > 0 ? effectiveMaxChars : maxChars;
+    const lineLimit = effectiveMaxLines > 0 ? effectiveMaxLines : maxLines;
+    const prefixLength = current.length > 0 ? current.length + 1 : 0;
+    const segmentLimit = Math.max(1, charLimit - prefixLength);
+    const segments = splitLongLine(line, segmentLimit, {
+      preserveWhitespace: wasInsideFence
+    });
+    for (let segmentIndex = 0; segmentIndex < segments.length; segmentIndex += 1) {
+      const segment2 = segments[segmentIndex];
+      const isContinuation = segmentIndex > 0;
+      const delimiter = isContinuation ? "" : current.length > 0 ? "\n" : "";
+      const addition = `${delimiter}${segment2}`;
+      const nextLength = current.length + addition.length;
+      const nextLineCount = currentLines + (isContinuation ? 0 : 1);
+      const exceedsChars = nextLength > charLimit;
+      const exceedsLines = nextLineCount > lineLimit;
+      if ((exceedsChars || exceedsLines) && current.length > 0) {
+        flush();
+      }
+      if (current.length > 0) {
+        current += addition;
+        if (!isContinuation) {
+          currentLines += 1;
+        }
+      } else {
+        current = segment2;
+        currentLines = 1;
+      }
+    }
+    openFence = nextOpenFence;
+  }
+  if (current.length) {
+    const payload = closeFenceIfNeeded(current, openFence);
+    if (payload.trim().length) {
+      chunks.push(payload);
+    }
+  }
+  return chunks;
+}
 
 // src/channels/email.ts
 import { ImapFlow } from "imapflow";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextclaw/channel-runtime",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "private": false,
   "description": "Runtime implementations for NextClaw builtin channel plugins.",
   "type": "module",