@netcat-ai/openclaw-weixin 2.4.7

package/src/messaging/markdown-filter.ts

@@ -0,0 +1,361 @@
+/**
+ * Streaming markdown filter — character-level state machine that strips
+ * unsupported markdown syntax on-the-fly.
+ *
+ * Outputs as much filtered text as possible on each `feed()` call, only
+ * holding back the minimum characters needed for pattern disambiguation
+ * (e.g. a trailing `*` that might become `***`).
+ *
+ * Constructs passed through (not filtered):
+ * - Code fences (```)
+ * - Inline code (`)
+ * - Tables (|...|)
+ * - Horizontal rules (---, ***, ___)
+ * - Bold (**)
+ * - Italic/bold-italic wrapping non-CJK content
+ *
+ * Constructs filtered (markers stripped, content kept):
+ * - Italic/bold-italic wrapping CJK content
+ * - Headings H5/H6 (#####, ######)
+ * - Images (![alt](url)) — removed entirely
+ *
+ * States:
+ * - **sol** (start-of-line): checks for line-start patterns (```, >, #####, indent)
+ * - **body**: scans for inline patterns (![, ~~, ***) and outputs safe chars
+ * - **fence**: inside a fenced code block, passes through until closing ```
+ * - **inline**: accumulating content inside an inline marker pair
+ */
+export class StreamingMarkdownFilter {
+  private buf = "";
+  private fence = false;
+  private sol = true;
+  private inl: { type: "image" | "bold3" | "italic" | "ubold3" | "uitalic"; acc: string } | null = null;
+
+  feed(delta: string): string {
+    this.buf += delta;
+    return this.pump(false);
+  }
+
+  flush(): string {
+    return this.pump(true);
+  }
+
+  private pump(eof: boolean): string {
+    let out = "";
+    while (this.buf) {
+      const sLen = this.buf.length;
+      const sSol = this.sol;
+      const sFence = this.fence;
+      const sInl = this.inl;
+
+      if (this.fence) out += this.pumpFence(eof);
+      else if (this.inl) out += this.pumpInline(eof);
+      else if (this.sol) out += this.pumpSOL(eof);
+      else out += this.pumpBody(eof);
+
+      if (this.buf.length === sLen && this.sol === sSol &&
+          this.fence === sFence && this.inl === sInl) break;
+    }
+
+    if (eof && this.inl) {
+      const markers: Record<string, string> = { image: "![", bold3: "***", italic: "*", ubold3: "___", uitalic: "_" };
+      out += (markers[this.inl.type] ?? "") + this.inl.acc;
+      this.inl = null;
+    }
+    return out;
+  }
+
+  /** Inside a code fence: pass content and markers through verbatim. */
+  private pumpFence(eof: boolean): string {
+    if (this.sol) {
+      if (this.buf.length < 3 && !eof) return "";
+      if (this.buf.startsWith("```")) {
+        const nl = this.buf.indexOf("\n", 3);
+        if (nl !== -1) {
+          this.fence = false;
+          const line = this.buf.slice(0, nl + 1);
+          this.buf = this.buf.slice(nl + 1);
+          this.sol = true;
+          return line;
+        }
+        if (eof) {
+          this.fence = false;
+          const line = this.buf;
+          this.buf = "";
+          return line;
+        }
+        return "";
+      }
+      this.sol = false;
+    }
+    const nl = this.buf.indexOf("\n");
+    if (nl !== -1) {
+      const chunk = this.buf.slice(0, nl + 1);
+      this.buf = this.buf.slice(nl + 1);
+      this.sol = true;
+      return chunk;
+    }
+    const chunk = this.buf;
+    this.buf = "";
+    return chunk;
+  }
+
+  /** At start of line: detect and consume line-start patterns, then transition to body. */
+  private pumpSOL(eof: boolean): string {
+    const b = this.buf;
+
+    if (b[0] === "\n") {
+      this.buf = b.slice(1);
+      return "\n";
+    }
+
+    if (b[0] === "`") {
+      if (b.length < 3 && !eof) return "";
+      if (b.startsWith("```")) {
+        const nl = b.indexOf("\n", 3);
+        if (nl !== -1) {
+          this.fence = true;
+          const line = b.slice(0, nl + 1);
+          this.buf = b.slice(nl + 1);
+          this.sol = true;
+          return line;
+        }
+        if (eof) {
+          this.buf = "";
+          return b;
+        }
+        return "";
+      }
+      this.sol = false;
+      return "";
+    }
+
+    if (b[0] === ">") {
+      this.sol = false;
+      return "";
+    }
+
+    if (b[0] === "#") {
+      let n = 0;
+      while (n < b.length && b[n] === "#") n++;
+      if (n === b.length && !eof) return "";
+      if (n >= 5 && n <= 6 && n < b.length && b[n] === " ") {
+        this.buf = b.slice(n + 1);
+        this.sol = false;
+        return "";
+      }
+      this.sol = false;
+      return "";
+    }
+
+    if (b[0] === " " || b[0] === "\t") {
+      if (b.search(/[^ \t]/) === -1 && !eof) return "";
+      this.sol = false;
+      return "";
+    }
+
+    if (b[0] === "-" || b[0] === "*" || b[0] === "_") {
+      const ch = b[0];
+      let j = 0;
+      while (j < b.length && (b[j] === ch || b[j] === " ")) j++;
+      if (j === b.length && !eof) return "";
+      if (j === b.length || b[j] === "\n") {
+        let count = 0;
+        for (let k = 0; k < j; k++) if (b[k] === ch) count++;
+        if (count >= 3) {
+          if (j < b.length) {
+            this.buf = b.slice(j + 1);
+            this.sol = true;
+            return b.slice(0, j + 1);
+          }
+          this.buf = "";
+          return b;
+        }
+      }
+      this.sol = false;
+      return "";
+    }
+
+    this.sol = false;
+    return "";
+  }
+
+  /** Scan line body for inline pattern triggers; output safe chars eagerly. */
+  private pumpBody(eof: boolean): string {
+    let out = "";
+    let i = 0;
+    while (i < this.buf.length) {
+      const c = this.buf[i];
+      if (c === "\n") {
+        out += this.buf.slice(0, i + 1);
+        this.buf = this.buf.slice(i + 1);
+        this.sol = true;
+        return out;
+      }
+      if (c === "!" && i + 1 < this.buf.length && this.buf[i + 1] === "[") {
+        out += this.buf.slice(0, i);
+        this.buf = this.buf.slice(i + 2);
+        this.inl = { type: "image", acc: "" };
+        return out;
+      }
+      if (c === "~") {
+        i++;
+        continue;
+      }
+      if (c === "*") {
+        if (i + 2 < this.buf.length && this.buf[i + 1] === "*" && this.buf[i + 2] === "*") {
+          out += this.buf.slice(0, i);
+          this.buf = this.buf.slice(i + 3);
+          this.inl = { type: "bold3", acc: "" };
+          return out;
+        }
+        if (i + 1 < this.buf.length && this.buf[i + 1] === "*") {
+          i += 2;
+          continue;
+        }
+        if (i + 1 < this.buf.length && this.buf[i + 1] !== " " && this.buf[i + 1] !== "\n") {
+          out += this.buf.slice(0, i);
+          this.buf = this.buf.slice(i + 1);
+          this.inl = { type: "italic", acc: "" };
+          return out;
+        }
+        i++;
+        continue;
+      }
+      if (c === "_") {
+        if (i + 2 < this.buf.length && this.buf[i + 1] === "_" && this.buf[i + 2] === "_") {
+          out += this.buf.slice(0, i);
+          this.buf = this.buf.slice(i + 3);
+          this.inl = { type: "ubold3", acc: "" };
+          return out;
+        }
+        if (i + 1 < this.buf.length && this.buf[i + 1] === "_") {
+          i += 2;
+          continue;
+        }
+        if (i + 1 < this.buf.length && this.buf[i + 1] !== " " && this.buf[i + 1] !== "\n") {
+          out += this.buf.slice(0, i);
+          this.buf = this.buf.slice(i + 1);
+          this.inl = { type: "uitalic", acc: "" };
+          return out;
+        }
+        i++;
+        continue;
+      }
+      i++;
+    }
+
+    let hold = 0;
+    if (!eof) {
+      if (this.buf.endsWith("**")) hold = 2;
+      else if (this.buf.endsWith("__")) hold = 2;
+      else if (this.buf.endsWith("*")) hold = 1;
+      else if (this.buf.endsWith("_")) hold = 1;
+      else if (this.buf.endsWith("!")) hold = 1;
+    }
+    out += this.buf.slice(0, this.buf.length - hold);
+    this.buf = hold > 0 ? this.buf.slice(-hold) : "";
+    return out;
+  }
+
+  /** Accumulate inline content until closing marker is found. */
+  private pumpInline(_eof: boolean): string {
+    if (!this.inl) return "";
+    this.inl.acc += this.buf;
+    this.buf = "";
+
+    switch (this.inl.type) {
+      case "bold3": {
+        const idx = this.inl.acc.indexOf("***");
+        if (idx !== -1) {
+          const content = this.inl.acc.slice(0, idx);
+          this.buf = this.inl.acc.slice(idx + 3);
+          this.inl = null;
+          if (StreamingMarkdownFilter.containsCJK(content)) return content;
+          return `***${content}***`;
+        }
+        return "";
+      }
+      case "ubold3": {
+        const idx = this.inl.acc.indexOf("___");
+        if (idx !== -1) {
+          const content = this.inl.acc.slice(0, idx);
+          this.buf = this.inl.acc.slice(idx + 3);
+          this.inl = null;
+          if (StreamingMarkdownFilter.containsCJK(content)) return content;
+          return `___${content}___`;
+        }
+        return "";
+      }
+      case "italic": {
+        for (let j = 0; j < this.inl.acc.length; j++) {
+          if (this.inl.acc[j] === "\n") {
+            const r = "*" + this.inl.acc.slice(0, j + 1);
+            this.buf = this.inl.acc.slice(j + 1);
+            this.inl = null;
+            this.sol = true;
+            return r;
+          }
+          if (this.inl.acc[j] === "*") {
+            if (j + 1 < this.inl.acc.length && this.inl.acc[j + 1] === "*") {
+              j++;
+              continue;
+            }
+            const content = this.inl.acc.slice(0, j);
+            this.buf = this.inl.acc.slice(j + 1);
+            this.inl = null;
+            if (StreamingMarkdownFilter.containsCJK(content)) return content;
+            return `*${content}*`;
+          }
+        }
+        return "";
+      }
+      case "uitalic": {
+        for (let j = 0; j < this.inl.acc.length; j++) {
+          if (this.inl.acc[j] === "\n") {
+            const r = "_" + this.inl.acc.slice(0, j + 1);
+            this.buf = this.inl.acc.slice(j + 1);
+            this.inl = null;
+            this.sol = true;
+            return r;
+          }
+          if (this.inl.acc[j] === "_") {
+            if (j + 1 < this.inl.acc.length && this.inl.acc[j + 1] === "_") {
+              j++;
+              continue;
+            }
+            const content = this.inl.acc.slice(0, j);
+            this.buf = this.inl.acc.slice(j + 1);
+            this.inl = null;
+            if (StreamingMarkdownFilter.containsCJK(content)) return content;
+            return `_${content}_`;
+          }
+        }
+        return "";
+      }
+      case "image": {
+        const cb = this.inl.acc.indexOf("]");
+        if (cb === -1) return "";
+        if (cb + 1 >= this.inl.acc.length) return "";
+        if (this.inl.acc[cb + 1] !== "(") {
+          const r = "![" + this.inl.acc.slice(0, cb + 1);
+          this.buf = this.inl.acc.slice(cb + 1);
+          this.inl = null;
+          return r;
+        }
+        const cp = this.inl.acc.indexOf(")", cb + 2);
+        if (cp !== -1) {
+          this.buf = this.inl.acc.slice(cp + 1);
+          this.inl = null;
+          return "";
+        }
+        return "";
+      }
+    }
+    return "";
+  }
+
+  private static containsCJK(text: string): boolean {
+    return /[\u2E80-\u9FFF\uAC00-\uD7AF\uF900-\uFAFF]/.test(text);
+  }
+}

package/src/messaging/outbound-hooks.ts

@@ -0,0 +1,88 @@
+import {
+  fireAndForgetHook,
+  buildCanonicalSentMessageHookContext,
+  toPluginMessageContext,
+  toPluginMessageSentEvent,
+} from "openclaw/plugin-sdk/hook-runtime";
+import { getGlobalHookRunner } from "openclaw/plugin-sdk/plugin-runtime";
+
+import { logger } from "../util/logger.js";
+
+const CHANNEL_ID = "openclaw-weixin";
+
+/**
+ * Run message_sending hook before sending.
+ * Returns the (possibly modified) text content plus a cancelled flag.
+ * Hook errors are caught and logged — sending proceeds regardless.
+ */
+export async function applyWeixinMessageSendingHook(params: {
+  to: string;
+  text: string;
+  accountId?: string;
+  mediaUrl?: string;
+  runId?: string;
+}): Promise<{ cancelled: boolean; text: string }> {
+  const hookRunner = getGlobalHookRunner();
+  if (!hookRunner?.hasHooks("message_sending")) {
+    return { cancelled: false, text: params.text };
+  }
+  try {
+    const hookResult = await hookRunner.runMessageSending(
+      {
+        to: params.to,
+        content: params.text,
+        metadata: {
+          channel: CHANNEL_ID,
+          accountId: params.accountId,
+          runId: params.runId,
+          ...(params.mediaUrl ? { mediaUrls: [params.mediaUrl] } : {}),
+        },
+      },
+      { channelId: CHANNEL_ID, accountId: params.accountId },
+    );
+    if (hookResult?.cancel) {
+      return { cancelled: true, text: params.text };
+    }
+    return {
+      cancelled: false,
+      text: hookResult?.content ?? params.text,
+    };
+  } catch (err) {
+    logger.warn(`message_sending hook error, proceeding with send: ${String(err)}`);
+    return { cancelled: false, text: params.text };
+  }
+}
+
+/**
+ * Fire message_sent hook (fire-and-forget) after a send attempt.
+ */
+export function emitWeixinMessageSent(params: {
+  to: string;
+  content: string;
+  success: boolean;
+  error?: string;
+  accountId?: string;
+  runId?: string;
+}): void {
+  const hookRunner = getGlobalHookRunner();
+  if (!hookRunner?.hasHooks("message_sent")) return;
+  const canonical = buildCanonicalSentMessageHookContext({
+    to: params.to,
+    content: params.content,
+    success: params.success,
+    error: params.error,
+    channelId: CHANNEL_ID,
+    accountId: params.accountId,
+    conversationId: params.to,
+    runId: params.runId,
+  });
+  fireAndForgetHook(
+    Promise.resolve(
+      hookRunner!.runMessageSent(
+        toPluginMessageSentEvent(canonical),
+        toPluginMessageContext(canonical),
+      ),
+    ),
+    "weixin: message_sent plugin hook failed",
+  );
+}