@xmanrui/dsh-im 4.38.0 → 4.38.1

package/src/channels/whatsapp/whatsapp-markdown.mjs

@@ -0,0 +1,59 @@
+// A conservative projection of common Markdown into WhatsApp's text dialect.
+// Unsupported structures stay literal; code and link destinations are protected.
+function inline(text) {
+  const saved = [];
+  let marker = '\u0000';
+  while (text.includes(marker)) marker += '\u0000';
+  const stash = value => `${marker}${saved.push(value) - 1}${marker}`;
+  let value = text.replace(/(`+)([^\n]*?)\1/g, (_match, ticks, code) => (
+    // WhatsApp cannot represent embedded backticks in inline code safely.
+    stash(code.includes('`') ? `${ticks}${code}${ticks}` : `\`${code}\``)
+  ));
+  value = value.replace(/\\([\\`*_{}[\]()#+.!~>-])/g, match => stash(match));
+  value = value.replace(/!?\[([^\]\n]+)\]\((https?:\/\/(?:[^\s()]|\([^\s()]*\))+)(?:\s+"[^"\n]*")?\)/g,
+    (_match, label, url) => stash(`${label} (${url})`));
+  value = value.replace(/https?:\/\/[^\s<>]+/g, url => stash(url));
+  // Leave nested delimiters untouched instead of guessing their meaning.
+  value = value.replace(/(?<![*_])(\*\*|__)([^*_\n]+)\1(?![*_])/g,
+    (_match, _marker, body) => stash(`*${body}*`));
+  value = value.replace(/(?<![\w*_])\*([^*\n]+)\*(?![*_])/g, (_match, body) => `_${body}_`);
+  value = value.replace(/(?<!~)~~([^~\n]+)~~(?!~)/g, '~$1~');
+  const token = new RegExp(`${marker}(\\d+)${marker}`, 'g');
+  // A later protected URL can contain an earlier token; restore both passes.
+  for (let pass = 0; pass <= saved.length && value.includes(marker); pass++) {
+    value = value.replace(token, (match, index) => saved[Number(index)] ?? match);
+  }
+  return value;
+}
+
+export function markdownToWhatsapp(text) {
+  const lines = text.replace(/\r\n?/g, '\n').split('\n');
+  const result = [];
+  let table = false;
+  for (let index = 0; index < lines.length; index++) {
+    const line = lines[index];
+    const open = /^ {0,3}(`{3,}|~{3,})(.*)$/.exec(line);
+    if (open && !(open[1][0] === '`' && open[2].includes('`'))) {
+      let end = index + 1;
+      for (; end < lines.length; end++) {
+        const close = /^ {0,3}(`{3,}|~{3,})[ \t]*$/.exec(lines[end]);
+        if (close && close[1][0] === open[1][0] && close[1].length >= open[1].length) break;
+      }
+      const body = lines.slice(index + 1, end);
+      // Embedded triple backticks cannot be represented by WhatsApp's fence.
+      // Preserve the entire original block instead of changing code boundaries.
+      if (body.some(value => value.includes('```'))) result.push(...lines.slice(index, end + 1));
+      else result.push('```', ...body, '```');
+      index = end;
+      table = false;
+      continue;
+    }
+    if (line.includes('|') && /^\s*\|?\s*:?-+:?\s*\|[\s|:-]*$/.test(lines[index + 1] ?? '')) table = true;
+    if (table && line.includes('|')) { result.push(line); continue; }
+    table = false;
+    const heading = /^ {0,3}#{1,6}\s+(.+?)(?:\s+#+)?\s*$/.exec(line);
+    // A heading with its own inline delimiters stays literal rather than nested.
+    result.push(heading && !/[*_`]/.test(heading[1]) ? `*${heading[1]}*` : inline(line));
+  }
+  return result.join('\n');
+}

package/src/channels/whatsapp/whatsapp-runtime.mjs

@@ -14,6 +14,9 @@ import { t } from '../shared/i18n.mjs';
 import { ImagePromptError } from '../shared/image-prompt.mjs';
 import { trackOutboundArtifactProviderPromise } from '../shared/semantic/artifact.mjs';
 import { createWhatsappBridgeStatus, WhatsappHarnessBridge } from './whatsapp-bridge.mjs';
+import { createTextDeliveryBlock } from '../shared/semantic/delivery.mjs';
+import { chunkMarkdownText } from '../shared/markdown-chunks.mjs';
+import { markdownToWhatsapp } from './whatsapp-markdown.mjs';
 import {
   WHATSAPP_ACCESS_MODES,
   normalizeWhatsappAccountJid,
@@ -490,6 +493,25 @@ export class WhatsappBotClient {
     return { providerMessageIds };
   }
 
+  async sendDelivery(target, value) {
+    const block = createTextDeliveryBlock(value);
+    if (block.format === 'plain') return this.sendText(target, block.text);
+    let chunks;
+    try {
+      chunks = chunkMarkdownText(markdownToWhatsapp(block.text), WHATSAPP_TEXT_LIMIT);
+    } catch {
+      this.#logger.warn?.('[dsh-im:whatsapp] Markdown could not be prepared; sending plain text');
+      return this.sendText(target, block.text);
+    }
+    await this.#stopTyping(target.jid);
+    const providerMessageIds = [];
+    for (const [index, chunk] of chunks.entries()) {
+      const result = await this.#sendTextMessage(target, chunk, { quote: index === 0 });
+      providerMessageIds.push(result.key.id);
+    }
+    return { providerMessageIds };
+  }
+
   async #sendTextMessage(target, text, { edit, quote = true } = {}) {
     this.#signal?.throwIfAborted();
     const messageId = randomBytes(10).toString('hex').toUpperCase();
@@ -886,7 +908,7 @@ export class WhatsappRuntime {
     }, options);
   }
 
-  async sendProactiveText(target, text, { signal } = {}) {
+  async sendProactiveText(target, text, { signal, format = 'plain' } = {}) {
     const jid = typeof target?.route?.jid === 'string' ? target.route.jid.trim() : '';
     const validUser = target?.kind === 'user'
       && /^[^@\s]+@(s\.whatsapp\.net|lid)$/.test(jid);
@@ -902,6 +924,9 @@ export class WhatsappRuntime {
       throw error;
     }
     signal?.throwIfAborted();
+    if (format === 'markdown') {
+      return this.#client.sendDelivery({ jid }, createTextDeliveryBlock(text, format));
+    }
     return this.#client.sendText({ jid }, text);
   }