@nextclaw/channel-runtime 0.1.13 → 0.1.15

package/dist/index.js

@@ -234,6 +234,8 @@ var TYPING_HEARTBEAT_MS = 6e3;
 var TYPING_AUTO_STOP_MS = 12e4;
 var DISCORD_TEXT_LIMIT = 2e3;
 var DISCORD_MAX_LINES_PER_MESSAGE = 17;
+var STREAM_EDIT_MIN_INTERVAL_MS = 600;
+var STREAM_MAX_UPDATES_PER_MESSAGE = 40;
 var FENCE_RE = /^( {0,3})(`{3,}|~{3,})(.*)$/;
 var DiscordChannel = class extends BaseChannel {
   name = "discord";
@@ -303,23 +305,34 @@ var DiscordChannel = class extends BaseChannel {
     }
     this.stopTyping(msg.chatId);
     const textChannel = channel;
-    const chunks = chunkDiscordText(msg.content ?? "");
+    const content = msg.content ?? "";
+    const textChunkLimit = resolveTextChunkLimit(this.config);
+    const chunks = chunkDiscordText(content, {
+      maxChars: textChunkLimit,
+      maxLines: DISCORD_MAX_LINES_PER_MESSAGE
+    });
     if (chunks.length === 0) {
       return;
     }
     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);
+    const streamingMode = resolveDiscordStreamingMode(this.config);
+    if (streamingMode === "off") {
+      await sendDiscordChunks({
+        textChannel,
+        chunks,
+        replyTo: msg.replyTo ?? void 0,
+        flags
+      });
+      return;
     }
+    await sendDiscordDraftStreaming({
+      textChannel,
+      chunks,
+      replyTo: msg.replyTo ?? void 0,
+      flags,
+      draftChunk: resolveDraftChunkConfig(this.config, textChunkLimit),
+      streamingMode
+    });
   }
   async handleIncoming(message) {
     const selfUserId = this.client?.user?.id;
@@ -780,12 +793,186 @@ function chunkDiscordText(text, opts = {}) {
   }
   return chunks;
 }
+function clampInt(value, min, max) {
+  if (Number.isNaN(value)) {
+    return min;
+  }
+  return Math.min(max, Math.max(min, Math.floor(value)));
+}
+function resolveTextChunkLimit(config) {
+  const configured = typeof config.textChunkLimit === "number" ? config.textChunkLimit : DISCORD_TEXT_LIMIT;
+  return clampInt(configured, 1, DISCORD_TEXT_LIMIT);
+}
+function resolveDiscordStreamingMode(config) {
+  const raw = config.streaming;
+  if (raw === true) {
+    return "partial";
+  }
+  if (raw === false || raw === void 0 || raw === null) {
+    return "off";
+  }
+  if (raw === "progress") {
+    return "partial";
+  }
+  if (raw === "partial" || raw === "block" || raw === "off") {
+    return raw;
+  }
+  return "off";
+}
+function resolveDraftChunkConfig(config, textChunkLimit) {
+  const raw = config.draftChunk ?? {};
+  const minChars = clampInt(raw.minChars ?? 200, 1, textChunkLimit);
+  const maxChars = clampInt(raw.maxChars ?? 800, minChars, textChunkLimit);
+  const breakPreference = raw.breakPreference === "line" || raw.breakPreference === "none" ? raw.breakPreference : "paragraph";
+  return {
+    minChars,
+    maxChars,
+    breakPreference
+  };
+}
+function findDraftBreakIndex(text, start, end, preference) {
+  const slice = text.slice(start, end);
+  if (slice.length === 0) {
+    return null;
+  }
+  if (preference === "paragraph") {
+    const idx = slice.lastIndexOf("\n\n");
+    if (idx >= 0) {
+      return start + idx + 2;
+    }
+  }
+  if (preference === "paragraph" || preference === "line") {
+    const idx = slice.lastIndexOf("\n");
+    if (idx >= 0) {
+      return start + idx + 1;
+    }
+  }
+  for (let i = slice.length - 1; i >= 0; i -= 1) {
+    if (/\s/.test(slice[i])) {
+      return start + i + 1;
+    }
+  }
+  return null;
+}
+function splitDraftChunks(text, config) {
+  const chunks = [];
+  if (!text) {
+    return chunks;
+  }
+  let cursor = 0;
+  const length = text.length;
+  while (cursor < length) {
+    const remaining = length - cursor;
+    if (remaining <= config.maxChars) {
+      chunks.push(text.slice(cursor));
+      break;
+    }
+    const minEnd = Math.min(length, cursor + config.minChars);
+    const maxEnd = Math.min(length, cursor + config.maxChars);
+    let nextEnd = maxEnd;
+    const breakIndex = findDraftBreakIndex(text, minEnd, maxEnd, config.breakPreference);
+    if (breakIndex !== null && breakIndex > cursor) {
+      nextEnd = breakIndex;
+    }
+    if (nextEnd <= cursor) {
+      nextEnd = maxEnd;
+    }
+    chunks.push(text.slice(cursor, nextEnd));
+    cursor = nextEnd;
+  }
+  return chunks;
+}
+async function sleep(ms) {
+  await new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
+}
+async function sendDiscordChunks(params) {
+  const { textChannel, chunks, replyTo, flags } = params;
+  let first = true;
+  for (const chunk of chunks) {
+    const payload = {
+      content: chunk
+    };
+    if (first && replyTo) {
+      payload.reply = { messageReference: replyTo };
+    }
+    if (flags !== void 0) {
+      payload.flags = flags;
+    }
+    await textChannel.send(payload);
+    first = false;
+  }
+}
+async function sendDiscordDraftStreaming(params) {
+  const { textChannel, chunks, replyTo, flags, draftChunk, streamingMode } = params;
+  let first = true;
+  const effectiveDraftChunk = streamingMode === "block" ? draftChunk : {
+    ...draftChunk,
+    minChars: Math.max(1, Math.floor(draftChunk.minChars / 2)),
+    maxChars: Math.max(draftChunk.minChars, Math.floor(draftChunk.maxChars / 2))
+  };
+  for (const chunk of chunks) {
+    const draftChunks = splitDraftChunks(chunk, effectiveDraftChunk);
+    if (draftChunks.length === 0) {
+      continue;
+    }
+    if (draftChunks.length > STREAM_MAX_UPDATES_PER_MESSAGE) {
+      await sendDiscordChunks({
+        textChannel,
+        chunks: [chunk],
+        replyTo: first ? replyTo : void 0,
+        flags
+      });
+      first = false;
+      continue;
+    }
+    let draftMessage = null;
+    let current = "";
+    let lastEditAt = 0;
+    for (const draftPart of draftChunks) {
+      current += draftPart;
+      if (!draftMessage) {
+        const payload = {
+          content: current
+        };
+        if (first && replyTo) {
+          payload.reply = { messageReference: replyTo };
+        }
+        if (flags !== void 0) {
+          payload.flags = flags;
+        }
+        draftMessage = await textChannel.send(
+          payload
+        );
+        first = false;
+        lastEditAt = Date.now();
+        continue;
+      }
+      const waitMs = Math.max(0, lastEditAt + STREAM_EDIT_MIN_INTERVAL_MS - Date.now());
+      if (waitMs > 0) {
+        await sleep(waitMs);
+      }
+      try {
+        await draftMessage.edit({ content: current });
+      } catch {
+        await sendDiscordChunks({
+          textChannel,
+          chunks: [chunk],
+          replyTo: void 0,
+          flags
+        });
+        draftMessage = null;
+        break;
+      }
+      lastEditAt = Date.now();
+    }
+  }
+}
 
 // src/channels/email.ts
 import { ImapFlow } from "imapflow";
 import { simpleParser } from "mailparser";
 import nodemailer from "nodemailer";
-var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var sleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 var EmailChannel = class extends BaseChannel {
   name = "email";
   lastSubjectByChat = /* @__PURE__ */ new Map();
@@ -824,7 +1011,7 @@ var EmailChannel = class extends BaseChannel {
         }
       } catch {
       }
-      await sleep(pollSeconds * 1e3);
+      await sleep2(pollSeconds * 1e3);
     }
   }
   async stop() {
@@ -1577,7 +1764,7 @@ var MochatChannel = class extends BaseChannel {
         });
         await this.handleWatchPayload(payload, "session");
       } catch {
-        await sleep2(Math.max(100, this.config.retryDelayMs));
+        await sleep3(Math.max(100, this.config.retryDelayMs));
       }
     }
   }
@@ -1606,9 +1793,9 @@ var MochatChannel = class extends BaseChannel {
           }
         }
       } catch {
-        await sleep2(sleepMs);
+        await sleep3(sleepMs);
       }
-      await sleep2(sleepMs);
+      await sleep3(sleepMs);
     }
   }
   async handleWatchPayload(payload, targetKind) {
@@ -2088,7 +2275,7 @@ function readGroupId(metadata) {
   }
   return null;
 }
-function sleep2(ms) {
+function sleep3(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
@@ -3172,7 +3359,7 @@ var WhatsAppChannel = class extends BaseChannel {
         if (!this.running) {
           break;
         }
-        await sleep3(5e3);
+        await sleep4(5e3);
       }
     }
   }
@@ -3242,7 +3429,7 @@ var WhatsAppChannel = class extends BaseChannel {
     }
   }
 };
-function sleep3(ms) {
+function sleep4(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextclaw/channel-runtime",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "private": false,
   "description": "Runtime implementations for NextClaw builtin channel plugins.",
   "type": "module",
@@ -15,7 +15,7 @@
   ],
   "dependencies": {
     "@larksuiteoapi/node-sdk": "^1.58.0",
-    "@nextclaw/core": "^0.6.27",
+    "@nextclaw/core": "^0.6.30",
     "@slack/socket-mode": "^1.3.3",
     "@slack/web-api": "^7.6.0",
     "dingtalk-stream": "^2.1.4",