fix(cron): truncate failure alert error text on UTF-16 boundary (#97298)

zenglingbiao · web-flow · commit 686a2876c7f4 · 2026-06-28T13:59:06.000-07:00
* fix(cron): truncate failure alert error text on UTF-16 boundary

* test(cron): add regression test for UTF-16 safe failure alert truncation

Verify that emitFailureAlert does not produce dangling surrogates when
truncating a cron failure error message with a non-BMP character (emoji)
straddling the 200-code-unit truncation boundary.

* fix(test): cover last code unit in surrogate scan

The dangling surrogate check loop stopped at length-1, missing a
high surrogate at the final position. Extend to i &lt; alertText.length
so charCodeAt(i+1) returns NaN for the last char, correctly failing
the high-surrogate pair assertion.

* fix(test): address lint issues in regression test

- Use template literal instead of string concatenation
- Add braces to type guard if-statement
diff --git a/src/cron/service.failure-alert.test.ts b/src/cron/service.failure-alert.test.ts
@@ -589,4 +589,64 @@ describe("CronService failure alerts", () => {
     cron.stop();
     await store.cleanup();
   });
+
+  it("truncates failure alert error text on UTF-16 code-point boundary", async () => {
+    const store = await makeStorePath();
+    const sendCronFailureAlert = vi.fn(async () => undefined);
+    // 209 code units: emoji (surrogate pair) at positions 199-200 straddles the 200-unit boundary
+    const longError = `${"x".repeat(199)}🎉trailing`;
+    const runIsolatedAgentJob = vi.fn(async () => ({
+      status: "error" as const,
+      error: longError,
+    }));
+
+    const cron = createFailureAlertCron({
+      storePath: store.storePath,
+      cronConfig: { failureAlert: { enabled: true, after: 1 } },
+      runIsolatedAgentJob,
+      sendCronFailureAlert,
+    });
+
+    await cron.start();
+    const job = await cron.add({
+      name: "utf16 boundary job",
+      enabled: true,
+      schedule: { kind: "every", everyMs: 60_000 },
+      sessionTarget: "isolated",
+      wakeMode: "next-heartbeat",
+      payload: { kind: "agentTurn", message: "ping" },
+      delivery: { mode: "announce", channel: "telegram", to: "19098680" },
+    });
+
+    await cron.run(job.id, "force");
+    expect(sendCronFailureAlert).toHaveBeenCalledTimes(1);
+    const alertText = alertCallArg(sendCronFailureAlert).text;
+    expect(typeof alertText).toBe("string");
+    if (typeof alertText !== "string") {
+      throw new Error("expected failure alert text");
+    }
+
+    // Verify no dangling surrogates in the truncated error text.
+    // Must check every character including the last: a dangling high surrogate
+    // at the final position would be missed by stopping at length-1.
+    for (let i = 0; i < alertText.length; i++) {
+      const cu = alertText.charCodeAt(i);
+      if (cu >= 0xd800 && cu <= 0xdbff) {
+        expect(alertText.charCodeAt(i + 1) >= 0xdc00 && alertText.charCodeAt(i + 1) <= 0xdfff).toBe(
+          true,
+        );
+      }
+      if (cu >= 0xdc00 && cu <= 0xdfff) {
+        expect(
+          i > 0 && alertText.charCodeAt(i - 1) >= 0xd800 && alertText.charCodeAt(i - 1) <= 0xdbff,
+        ).toBe(true);
+      }
+    }
+
+    // Verify the emoji was excluded (truncated at the safe boundary before it)
+    expect(alertText).not.toContain("🎉");
+
+    cron.stop();
+    await store.cleanup();
+  });
 });
diff --git a/src/cron/service/failure-alerts.ts b/src/cron/service/failure-alerts.ts
@@ -1,6 +1,7 @@
 /** Resolves and emits cron failure-alert notifications. */
 import { normalizeOptionalLowercaseString } from "@openclaw/normalization-core/string-coerce";
 import { resolveFailoverReasonFromError } from "../../agents/failover-error.js";
+import { truncateUtf16Safe } from "../../shared/utf16-slice.js";
 import type { CronFailureNotificationDelivery, CronJob, CronMessageChannel } from "../types.js";
 import type { CronServiceState } from "./state.js";
 
@@ -113,7 +114,7 @@ function emitFailureAlert(
   },
 ) {
   const safeJobName = params.job.name || params.job.id;
-  const truncatedError = (params.error?.trim() || "unknown reason").slice(0, 200);
+  const truncatedError = truncateUtf16Safe(params.error?.trim() || "unknown reason", 200);
   const errorReason =
     params.status === "error" && typeof params.error === "string"
       ? (resolveFailoverReasonFromError(params.error, params.provider) ?? undefined)
