fix(irc): long non-ASCII messages are silently truncated at the 512-byte line limit (#99138)

yetval · steipete · web-flow · commit 89881b6611a1 · 2026-07-05T22:10:59.000+01:00
* fix(irc): chunk PRIVMSG by UTF-8 byte budget so long non-ASCII messages are not truncated

IRC caps a full protocol line at 512 bytes, but sendPrivmsg split outbound
text by UTF-16 code units against the 350 char default. Multi-byte text such
as CJK or emoji produced lines far beyond 512 bytes and servers silently
dropped the tail of every oversized chunk. The chunker now also enforces a
UTF-8 byte budget derived from the line framing overhead, splitting on code
point boundaries and preferring spaces, while ASCII chunking is unchanged.

* test(irc): move loopback IRC server helper to shared test helpers

The colocated node:net import tripped the network-runtime-boundary PR diff
scan for extensions/irc/src. The loopback server now lives in test/helpers,
outside the scanned network runtime paths, and the CJK, emoji, and ASCII
chunking cases keep driving the real client over a real TCP socket.

* fix(irc): decouple byte budget from character cap and move loopback helper to irc test-support

The byte budget is now derived only from the 512-byte line limit and framing
overhead, independent of messageChunkMaxChars, so low character caps with
multibyte text keep advancing instead of dropping the message. The loopback
IRC server helper moves from test/helpers to the extension-local package-root
test-support surface so extension tests stay off repo helper bridges and raw
socket use stays outside extensions/irc/src.

* fix(irc): enforce UTF-8 wire limits

* test(irc): satisfy loopback harness lint

* test(irc): avoid implicit Promise return

* test(irc): handle loopback close errors

* fix(irc): preserve boundary word splitting

---------

Co-authored-by: Peter Steinberger &lt;steipete@gmail.com&gt;
diff --git a/extensions/irc/src/client.test.ts b/extensions/irc/src/client.test.ts
@@ -1,6 +1,64 @@
 // Irc tests cover client plugin behavior.
+import net from "node:net";
 import { describe, expect, it } from "vitest";
-import { buildFallbackNick, buildIrcNickServCommands } from "./client.js";
+import { buildFallbackNick, buildIrcNickServCommands, connectIrcClient } from "./client.js";
+
+type LoopbackIrcServer = {
+  port: number;
+  lines: string[];
+  close(): Promise<void>;
+};
+
+async function startLoopbackIrcServer(): Promise<LoopbackIrcServer> {
+  const lines: string[] = [];
+  const sockets = new Set<net.Socket>();
+  const server = net.createServer((socket) => {
+    sockets.add(socket);
+    socket.setEncoding("utf8");
+    let buffer = "";
+    socket.on("data", (chunk: string) => {
+      buffer += chunk;
+      let idx = buffer.indexOf("\n");
+      while (idx !== -1) {
+        const line = buffer.slice(0, idx).replace(/\r$/, "");
+        buffer = buffer.slice(idx + 1);
+        idx = buffer.indexOf("\n");
+        lines.push(line);
+        if (line.startsWith("USER ")) {
+          socket.write(":server 001 bot :welcome\r\n");
+        }
+      }
+    });
+    socket.on("close", () => {
+      sockets.delete(socket);
+    });
+  });
+  await new Promise<void>((resolve) => {
+    server.listen(0, "127.0.0.1", resolve);
+  });
+  const address = server.address();
+  if (!address || typeof address === "string") {
+    throw new Error("expected loopback IRC server to bind a TCP port");
+  }
+  return {
+    port: address.port,
+    lines,
+    close: async () => {
+      for (const socket of sockets) {
+        socket.destroy();
+      }
+      await new Promise<void>((resolve, reject) => {
+        server.close((error) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          resolve();
+        });
+      });
+    },
+  };
+}
 
 describe("irc client nickserv", () => {
   it("builds IDENTIFY command when password is set", () => {
@@ -77,3 +135,122 @@ describe("irc client fallback nick", () => {
     expect(nick).toMatch(/^a+_\d*$/);
   });
 });
+
+async function collectPrivmsgBodies(
+  server: LoopbackIrcServer,
+  text: string,
+  messageChunkMaxChars?: number,
+): Promise<string[]> {
+  const client = await connectIrcClient({
+    host: "127.0.0.1",
+    port: server.port,
+    tls: false,
+    nick: "bot",
+    username: "bot",
+    realname: "OpenClaw Bot",
+    connectTimeoutMs: 5000,
+    messageChunkMaxChars,
+  });
+  const receivedBodies = () =>
+    server.lines
+      .filter((line) => line.startsWith("PRIVMSG #general :"))
+      .map((line) => line.slice("PRIVMSG #general :".length));
+  try {
+    client.sendPrivmsg("#general", text);
+    const deadline = Date.now() + 5000;
+    while (receivedBodies().join("").length < text.length && Date.now() < deadline) {
+      await new Promise((resolve) => {
+        setTimeout(resolve, 10);
+      });
+    }
+  } finally {
+    client.close();
+  }
+  return receivedBodies();
+}
+
+const LONE_SURROGATE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/;
+
+function maxLineBytes(bodies: string[]): number {
+  return Math.max(
+    ...bodies.map((body) => Buffer.byteLength(`PRIVMSG #general :${body}\r\n`, "utf8")),
+  );
+}
+
+describe("irc client privmsg byte-limit chunking", () => {
+  it("splits multi-byte text so every line fits the 512-byte IRC limit", async () => {
+    const server = await startLoopbackIrcServer();
+    try {
+      const text = "漢".repeat(900);
+      const bodies = await collectPrivmsgBodies(server, text);
+      expect(bodies.length).toBeGreaterThan(1);
+      expect(maxLineBytes(bodies)).toBeLessThanOrEqual(512);
+      expect(bodies.join("")).toBe(text);
+    } finally {
+      await server.close();
+    }
+  });
+
+  it("keeps emoji code points intact while honoring the byte limit", async () => {
+    const server = await startLoopbackIrcServer();
+    try {
+      const text = "\u{1F600}".repeat(300);
+      const bodies = await collectPrivmsgBodies(server, text);
+      expect(maxLineBytes(bodies)).toBeLessThanOrEqual(512);
+      for (const body of bodies) {
+        expect(LONE_SURROGATE.test(body)).toBe(false);
+      }
+      expect(bodies.join("")).toBe(text);
+    } finally {
+      await server.close();
+    }
+  });
+
+  it("preserves the existing 350-char chunking for ASCII text", async () => {
+    const server = await startLoopbackIrcServer();
+    try {
+      const text = "a".repeat(900);
+      const bodies = await collectPrivmsgBodies(server, text);
+      expect(bodies.map((body) => body.length)).toEqual([350, 350, 200]);
+      expect(bodies.join("")).toBe(text);
+    } finally {
+      await server.close();
+    }
+  });
+
+  it("honors a low character cap for multibyte text without shrinking chunks to the byte budget", async () => {
+    const server = await startLoopbackIrcServer();
+    try {
+      const text = "漢".repeat(250);
+      const bodies = await collectPrivmsgBodies(server, text, 100);
+      expect(bodies.map((body) => body.length)).toEqual([100, 100, 50]);
+      expect(bodies.join("")).toBe(text);
+    } finally {
+      await server.close();
+    }
+  });
+
+  it("still advances when the character cap is smaller than one multibyte code point's bytes", async () => {
+    const server = await startLoopbackIrcServer();
+    try {
+      const text = "漢".repeat(10);
+      const bodies = await collectPrivmsgBodies(server, text, 2);
+      expect(bodies.map((body) => body.length)).toEqual([2, 2, 2, 2, 2]);
+      expect(bodies.join("")).toBe(text);
+    } finally {
+      await server.close();
+    }
+  });
+
+  it("keeps one astral code point whole when the legacy character cap is one UTF-16 unit", async () => {
+    const server = await startLoopbackIrcServer();
+    try {
+      const text = "\u{1F600}".repeat(10);
+      const bodies = await collectPrivmsgBodies(server, text, 1);
+      expect(bodies.map((body) => body.length)).toEqual(Array(10).fill(2));
+      expect(bodies.join("")).toBe(text);
+    } finally {
+      await server.close();
+    }
+  });
+});
diff --git a/extensions/irc/src/client.ts b/extensions/irc/src/client.ts
@@ -3,27 +3,46 @@ import net from "node:net";
 import tls from "node:tls";
 import { withTimeout } from "openclaw/plugin-sdk/security-runtime";
 import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { sliceUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import {
   parseIrcLine,
   parseIrcPrefix,
   sanitizeIrcOutboundText,
   sanitizeIrcTarget,
 } from "./protocol.js";
 
-function sliceIrcPrivmsgChunk(text: string, end: number): string {
-  const sliced = sliceUtf16Safe(text, 0, end);
-  if (sliced || end <= 0) {
-    return sliced;
-  }
-  // A one-unit budget cannot contain an astral code point. Emit that point
-  // whole so chunking advances without changing one-unit behavior for BMP text.
-  const firstCodePoint = text.codePointAt(0);
-  return firstCodePoint !== undefined && firstCodePoint > 0xffff ? text.slice(0, 2) : sliced;
-}
-
 const IRC_ERROR_CODES = new Set(["432", "464", "465"]);
 const IRC_NICK_COLLISION_CODES = new Set(["433", "436"]);
+const IRC_MAX_LINE_BYTES = 512;
+
+function takeIrcPrivmsgChunk(text: string, maxChars: number, maxBytes: number): string {
+  let end = 0;
+  let bytes = 0;
+  for (const codePoint of text) {
+    const codePointBytes = Buffer.byteLength(codePoint, "utf8");
+    const exceedsCharCap = end > 0 && end + codePoint.length > maxChars;
+    if (exceedsCharCap || bytes + codePointBytes > maxBytes) {
+      break;
+    }
+    end += codePoint.length;
+    bytes += codePointBytes;
+  }
+  if (end === 0) {
+    throw new Error("IRC target leaves no room for message text within the 512-byte line limit");
+  }
+  if (end === text.length) {
+    return text;
+  }
+  const fitted = text.slice(0, end);
+  // A delimiter just beyond the cap already gives this chunk a clean word boundary.
+  if (text[end] === " ") {
+    return fitted;
+  }
+  const splitAt = fitted.lastIndexOf(" ");
+  if (splitAt >= Math.floor(fitted.length / 2)) {
+    return fitted.slice(0, splitAt);
+  }
+  return fitted;
+}
 
 type IrcPrivmsgEvent = {
   senderNick: string;
@@ -223,19 +242,11 @@ export async function connectIrcClient(options: IrcClientOptions): Promise<IrcCl
     if (!cleaned) {
       return;
     }
+    const lineOverheadBytes = Buffer.byteLength(`PRIVMSG ${normalizedTarget} :\r\n`, "utf8");
+    const maxChunkBytes = IRC_MAX_LINE_BYTES - lineOverheadBytes;
     let remaining = cleaned;
     while (remaining.length > 0) {
-      let chunk = remaining;
-      if (chunk.length > messageChunkMaxChars) {
-        let splitAt = chunk.lastIndexOf(" ", messageChunkMaxChars);
-        if (splitAt < Math.floor(messageChunkMaxChars / 2)) {
-          splitAt = messageChunkMaxChars;
-        }
-        chunk = sliceIrcPrivmsgChunk(chunk, splitAt).trim();
-      }
-      if (!chunk) {
-        break;
-      }
+      const chunk = takeIrcPrivmsgChunk(remaining, messageChunkMaxChars, maxChunkBytes).trim();
       sendRaw(`PRIVMSG ${normalizedTarget} :${chunk}`);
       remaining = remaining.slice(chunk.length).trimStart();
     }
