Merge branch 'main' into vincentkoc-code/telegram-media-max-config

vincentkoc · web-flow · commit 35527363fbc5 · 2026-03-06T11:50:13.000-05:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -203,6 +203,8 @@ Docs: https://docs.openclaw.ai
 - Skills/openai-image-gen CLI validation: validate `--background` and `--style` inputs early, normalize supported values, and warn when those flags are ignored for incompatible models. (#36762) Thanks @shuofengzhang and @vincentkoc.
 - Skills/openai-image-gen output formats: validate `--output-format` values early, normalize aliases like `jpg -> jpeg`, and warn when the flag is ignored for incompatible models. (#36648) Thanks @shuofengzhang and @vincentkoc.
 - WhatsApp media upload caps: make outbound media sends and auto-replies honor `channels.whatsapp.mediaMaxMb` with per-account overrides so inbound and outbound limits use the same channel config. Thanks @vincentkoc.
+- Windows/Plugin install: when OpenClaw runs on Windows via Bun and `npm-cli.js` is not colocated with the runtime binary, fall back to `npm.cmd`/`npx.cmd` through the existing `cmd.exe` wrapper so `openclaw plugins install` no longer fails with `spawn EINVAL`. (#38056) Thanks @0xlin2023.
+- Telegram/send retry classification: retry grammY `Network request ... failed after N attempts` envelopes in send flows without reclassifying plain `Network request ... failed!` wrappers as transient, restoring the intended retry path while keeping broad send-context message matching tight. (#38056) Thanks @0xlin2023.
 
 ## 2026.3.2
 
diff --git a/src/process/exec.test.ts b/src/process/exec.test.ts
@@ -1,5 +1,6 @@
 import type { ChildProcess } from "node:child_process";
 import { EventEmitter } from "node:events";
+import fs from "node:fs";
 import process from "node:process";
 import { describe, expect, it, vi } from "vitest";
 import { attachChildProcessBridge } from "./child-process-bridge.js";
@@ -77,6 +78,20 @@ describe("runCommandWithTimeout", () => {
       expect(result.stdout.trim()).toMatch(/^\d+\.\d+\.\d+$/);
     },
   );
+
+  it.runIf(process.platform === "win32")(
+    "falls back to npm.cmd when npm-cli.js is unavailable",
+    async () => {
+      const existsSpy = vi.spyOn(fs, "existsSync").mockReturnValue(false);
+      try {
+        const result = await runCommandWithTimeout(["npm", "--version"], { timeoutMs: 10_000 });
+        expect(result.code).toBe(0);
+        expect(result.stdout.trim()).toMatch(/^\d+\.\d+\.\d+$/);
+      } finally {
+        existsSpy.mockRestore();
+      }
+    },
+  );
 });
 
 describe("attachChildProcessBridge", () => {
diff --git a/src/process/exec.ts b/src/process/exec.ts
@@ -58,7 +58,13 @@ function resolveNpmArgvForWindows(argv: string[]): string[] | null {
   const nodeDir = path.dirname(process.execPath);
   const cliPath = path.join(nodeDir, "node_modules", "npm", "bin", cliName);
   if (!fs.existsSync(cliPath)) {
-    return null;
+    // Bun-based runs don't ship npm-cli.js next to process.execPath.
+    // Fall back to npm.cmd/npx.cmd so we still route through cmd wrapper
+    // (avoids direct .cmd spawn EINVAL on patched Node).
+    const command = argv[0] ?? "";
+    const ext = path.extname(command).toLowerCase();
+    const shimmedCommand = ext ? command : `${command}.cmd`;
+    return [shimmedCommand, ...argv.slice(1)];
   }
   return [process.execPath, cliPath, ...argv.slice(1)];
 }
diff --git a/src/telegram/network-errors.test.ts b/src/telegram/network-errors.test.ts
@@ -49,6 +49,15 @@ describe("isRecoverableTelegramNetworkError", () => {
     expect(isRecoverableTelegramNetworkError(undiciSnippetErr, { context: "polling" })).toBe(true);
   });
 
+  it("treats grammY failed-after envelope errors as recoverable in send context", () => {
+    expect(
+      isRecoverableTelegramNetworkError(
+        new Error("Network request for 'sendMessage' failed after 2 attempts."),
+        { context: "send" },
+      ),
+    ).toBe(true);
+  });
+
   it("returns false for unrelated errors", () => {
     expect(isRecoverableTelegramNetworkError(new Error("invalid token"))).toBe(false);
   });
diff --git a/src/telegram/network-errors.ts b/src/telegram/network-errors.ts
@@ -33,6 +33,8 @@ const RECOVERABLE_ERROR_NAMES = new Set([
 ]);
 
 const ALWAYS_RECOVERABLE_MESSAGES = new Set(["fetch failed", "typeerror: fetch failed"]);
+const GRAMMY_NETWORK_REQUEST_FAILED_AFTER_RE =
+  /^network request(?:\s+for\s+["']?[^"']+["']?)?\s+failed\s+after\b.*[!.]?$/i;
 
 const RECOVERABLE_MESSAGE_SNIPPETS = [
   "undici",
@@ -106,6 +108,9 @@ export function isRecoverableTelegramNetworkError(
     if (message && ALWAYS_RECOVERABLE_MESSAGES.has(message)) {
       return true;
     }
+    if (message && GRAMMY_NETWORK_REQUEST_FAILED_AFTER_RE.test(message)) {
+      return true;
+    }
     if (allowMessageMatch && message) {
       if (RECOVERABLE_MESSAGE_SNIPPETS.some((snippet) => message.includes(snippet))) {
         return true;
diff --git a/src/telegram/send.test.ts b/src/telegram/send.test.ts
@@ -779,6 +779,31 @@ describe("sendMessageTelegram", () => {
     expect(sendMessage).toHaveBeenCalledTimes(1);
   });
 
+  it("retries when grammY network envelope message includes failed-after wording", async () => {
+    const chatId = "123";
+    const sendMessage = vi
+      .fn()
+      .mockRejectedValueOnce(
+        new Error("Network request for 'sendMessage' failed after 1 attempts."),
+      )
+      .mockResolvedValueOnce({
+        message_id: 7,
+        chat: { id: chatId },
+      });
+    const api = { sendMessage } as unknown as {
+      sendMessage: typeof sendMessage;
+    };
+
+    const result = await sendMessageTelegram(chatId, "hi", {
+      token: "tok",
+      api,
+      retry: { attempts: 2, minDelayMs: 0, maxDelayMs: 0, jitter: 0 },
+    });
+
+    expect(sendMessage).toHaveBeenCalledTimes(2);
+    expect(result).toEqual({ messageId: "7", chatId });
+  });
+
   it("sends GIF media as animation", async () => {
     const chatId = "123";
     const sendAnimation = vi.fn().mockResolvedValue({
