openclaw-channel-dmwork 0.5.10 → 0.5.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-channel-dmwork",
-  "version": "0.5.10",
+  "version": "0.5.12",
   "description": "DMWork channel plugin for OpenClaw via WuKongIM WebSocket",
   "main": "index.ts",
   "type": "module",

package/src/api-fetch.test.ts

@@ -716,3 +716,81 @@ describe("sendMediaMessage", () => {
     expect(payload.height).toBeUndefined();
   });
 });
+
+// ---------------------------------------------------------------------------
+// ensureTextCharset
+// ---------------------------------------------------------------------------
+describe("ensureTextCharset", () => {
+  it("appends charset=utf-8 to text/plain", async () => {
+    const { ensureTextCharset } = await import("./api-fetch.js");
+    expect(ensureTextCharset("text/plain")).toBe("text/plain; charset=utf-8");
+  });
+
+  it("appends charset=utf-8 to text/markdown", async () => {
+    const { ensureTextCharset } = await import("./api-fetch.js");
+    expect(ensureTextCharset("text/markdown")).toBe("text/markdown; charset=utf-8");
+  });
+
+  it("appends charset=utf-8 to text/html", async () => {
+    const { ensureTextCharset } = await import("./api-fetch.js");
+    expect(ensureTextCharset("text/html")).toBe("text/html; charset=utf-8");
+  });
+
+  it("does not modify image/jpeg", async () => {
+    const { ensureTextCharset } = await import("./api-fetch.js");
+    expect(ensureTextCharset("image/jpeg")).toBe("image/jpeg");
+  });
+
+  it("does not double-add charset if already present", async () => {
+    const { ensureTextCharset } = await import("./api-fetch.js");
+    expect(ensureTextCharset("text/plain; charset=utf-8")).toBe("text/plain; charset=utf-8");
+  });
+
+  it("does not override existing charset=gbk", async () => {
+    const { ensureTextCharset } = await import("./api-fetch.js");
+    expect(ensureTextCharset("text/plain; charset=gbk")).toBe("text/plain; charset=gbk");
+  });
+
+  it("does not modify application/json", async () => {
+    const { ensureTextCharset } = await import("./api-fetch.js");
+    expect(ensureTextCharset("application/json")).toBe("application/json");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// uploadFileToCOS — putParams includes ContentType
+// ---------------------------------------------------------------------------
+describe("uploadFileToCOS putParams ContentType", () => {
+  it("passes ContentType to cos.putObject", async () => {
+    let capturedParams: any = null;
+
+    vi.resetModules();
+
+    // Mock cos-nodejs-sdk-v5 before importing api-fetch
+    vi.doMock("cos-nodejs-sdk-v5", () => {
+      return {
+        default: class FakeCOS {
+          putObject(params: any, cb: any) {
+            capturedParams = params;
+            cb(null, { Location: "bucket.cos.region.myqcloud.com/key" });
+          }
+        },
+      };
+    });
+
+    const { uploadFileToCOS } = await import("./api-fetch.js");
+    await uploadFileToCOS({
+      credentials: { tmpSecretId: "id", tmpSecretKey: "key", sessionToken: "tok" },
+      startTime: 0,
+      expiredTime: 9999999999,
+      bucket: "test-bucket",
+      region: "ap-test",
+      key: "test/file.txt",
+      fileBody: Buffer.from("hello"),
+      contentType: "text/plain; charset=utf-8",
+    });
+
+    expect(capturedParams).not.toBeNull();
+    expect(capturedParams.ContentType).toBe("text/plain; charset=utf-8");
+  });
+});

package/src/api-fetch.ts

@@ -114,11 +114,25 @@ export function inferContentType(filename: string): string {
     ".pdf": "application/pdf", ".zip": "application/zip",
     ".doc": "application/msword", ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
     ".xls": "application/vnd.ms-excel", ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-    ".txt": "text/plain", ".json": "application/json",
+    ".txt": "text/plain", ".md": "text/markdown", ".markdown": "text/markdown",
+    ".csv": "text/csv", ".html": "text/html", ".htm": "text/html",
+    ".css": "text/css", ".xml": "text/xml", ".yaml": "text/yaml", ".yml": "text/yaml",
+    ".json": "application/json",
   };
   return map[ext] ?? "application/octet-stream";
 }
 
+/**
+ * Ensure text/* content types include a charset parameter.
+ * If the content type starts with "text/" and has no charset, appends "; charset=utf-8".
+ */
+export function ensureTextCharset(contentType: string): string {
+  if (contentType.startsWith("text/") && !contentType.includes("charset")) {
+    return contentType + "; charset=utf-8";
+  }
+  return contentType;
+}
+
 /**
  * Parse image dimensions from buffer (PNG/JPEG/GIF/WebP).
  * Lightweight — reads only the header bytes, no external dependencies.
@@ -577,6 +591,7 @@ export async function uploadFileToCOS(params: {
     Region: params.region,
     Key: params.key,
     Body: params.fileBody,
+    ContentType: params.contentType,
   };
   if (params.fileSize != null) {
     putParams.ContentLength = params.fileSize;

package/src/bug-repro.test.ts

@@ -0,0 +1,390 @@
+/**
+ * Bug fix verification tests for WebSocket reconnect v2 (Issue #139)
+ *
+ * These tests verify that three bugs have been FIXED:
+ *   Bug A: Exponential backoff now works (reconnectAttempts not reset prematurely)
+ *   Bug B: Kicked bots reconnect even during cooldown window
+ *   Bug C: Rapid silent disconnects now trigger onError for token refresh
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+// Track mock WS instances created during tests
+const mockWsInstances: any[] = [];
+
+vi.mock("ws", () => {
+  class MockWS {
+    static OPEN = 1;
+    binaryType = "arraybuffer";
+    readyState = 1;
+    private handlers = new Map<string, Function[]>();
+
+    constructor(public url: string) {
+      (globalThis as any).__mockWsInstances?.push(this);
+    }
+
+    on(event: string, handler: Function) {
+      if (!this.handlers.has(event)) this.handlers.set(event, []);
+      this.handlers.get(event)!.push(handler);
+    }
+
+    send = vi.fn();
+
+    close() {
+      this.readyState = 3; // CLOSED
+      queueMicrotask(() => this.emit("close"));
+    }
+
+    emit(event: string, ...args: any[]) {
+      const handlers = this.handlers.get(event);
+      if (handlers) {
+        for (const h of handlers) h(...args);
+      }
+    }
+  }
+
+  return { default: MockWS, WebSocket: MockWS };
+});
+
+vi.mock("curve25519-js", () => ({
+  generateKeyPair: () => ({
+    private: new Uint8Array(32),
+    public: new Uint8Array(32),
+  }),
+  sharedKey: () => new Uint8Array(32),
+}));
+
+import { WKSocket } from "./socket.js";
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+/** Build a minimal CONNACK packet with reasonCode=1 (success) */
+function buildConnackSuccess(): ArrayBuffer {
+  const serverVersion = 4;
+  const reasonCode = 1; // success
+  const serverKey = Buffer.from(new Uint8Array(32)).toString("base64");
+  const salt = "1234567890123456";
+
+  const body: number[] = [];
+  body.push(serverVersion);
+  for (let i = 0; i < 8; i++) body.push(0); // timeDiff
+  body.push(reasonCode);
+  const keyBytes = [...Buffer.from(serverKey)];
+  body.push((keyBytes.length >> 8) & 0xff, keyBytes.length & 0xff);
+  body.push(...keyBytes);
+  const saltBytes = [...Buffer.from(salt)];
+  body.push((saltBytes.length >> 8) & 0xff, saltBytes.length & 0xff);
+  body.push(...saltBytes);
+  for (let i = 0; i < 8; i++) body.push(0); // nodeId
+
+  const header = (2 << 4) | 1; // CONNACK with hasServerVersion
+  const packet = new Uint8Array([header, body.length, ...body]);
+  return packet.buffer;
+}
+
+/** Build a CONNACK packet with reasonCode=0 (kicked) */
+function buildConnackKicked(): ArrayBuffer {
+  const serverVersion = 4;
+  const reasonCode = 0; // kicked
+
+  const body: number[] = [];
+  body.push(serverVersion);
+  for (let i = 0; i < 8; i++) body.push(0); // timeDiff
+  body.push(reasonCode);
+  // serverKey (empty)
+  body.push(0, 0);
+  // salt (empty)
+  body.push(0, 0);
+  for (let i = 0; i < 8; i++) body.push(0); // nodeId
+
+  const header = (2 << 4) | 1;
+  const packet = new Uint8Array([header, body.length, ...body]);
+  return packet.buffer;
+}
+
+// ─── Test Suites ────────────────────────────────────────────────────────────
+
+describe("Bug A fix: Exponential backoff grows correctly", () => {
+  let setTimeoutCalls: { fn: Function; delay: number }[];
+  let originalSetTimeout: typeof setTimeout;
+  let dateNowSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    mockWsInstances.length = 0;
+    (globalThis as any).__mockWsInstances = mockWsInstances;
+    setTimeoutCalls = [];
+    originalSetTimeout = global.setTimeout;
+    global.setTimeout = vi.fn((fn: Function, delay?: number) => {
+      setTimeoutCalls.push({ fn, delay: delay ?? 0 });
+      return 999 as any;
+    }) as any;
+  });
+
+  afterEach(() => {
+    global.setTimeout = originalSetTimeout;
+    dateNowSpy?.mockRestore();
+    delete (globalThis as any).__mockWsInstances;
+    vi.restoreAllMocks();
+  });
+
+  it("delays should GROW after 5 connect→CONNACK→close cycles", () => {
+    /**
+     * With the fix, reconnectAttempts only resets after the 30s stable timer
+     * fires (which requires the connection to stay up for 30s). Connections
+     * that live <30s keep the backoff counter, so delays grow exponentially.
+     *
+     * We mock Date.now so each connection appears to last 6s (>5s threshold)
+     * to isolate Bug A from Bug C's rapid-disconnect detection.
+     */
+    let now = 10000;
+    dateNowSpy = vi.spyOn(Date, "now").mockImplementation(() => now);
+
+    const socket = new WKSocket({
+      wsUrl: "ws://test:5200",
+      uid: "bot1",
+      token: "tok1",
+      onMessage: vi.fn(),
+      onConnected: vi.fn(),
+      onDisconnected: vi.fn(),
+    });
+
+    const reconnectDelays: number[] = [];
+
+    for (let cycle = 0; cycle < 5; cycle++) {
+      socket.connect();
+      const ws = mockWsInstances[mockWsInstances.length - 1];
+      ws.emit("open");
+
+      // CONNACK success → sets lastConnectTime = now, starts stable timer
+      ws.emit("message", buildConnackSuccess());
+
+      // Advance time by 6s (above 5s rapid-disconnect threshold,
+      // but well below the 30s stable timer)
+      now += 6000;
+
+      setTimeoutCalls = [];
+      ws.emit("close");
+
+      // The only setTimeout from the close handler is scheduleReconnect
+      if (setTimeoutCalls.length > 0) {
+        reconnectDelays.push(setTimeoutCalls[0].delay);
+      }
+    }
+
+    // All 5 cycles should have produced reconnect delays
+    expect(reconnectDelays).toHaveLength(5);
+
+    // Delays should strictly increase (exponential backoff working)
+    for (let i = 1; i < reconnectDelays.length; i++) {
+      expect(reconnectDelays[i]).toBeGreaterThan(reconnectDelays[i - 1]);
+    }
+
+    // First delay ~3000ms (base), with ±25% jitter → [2250, 3750]
+    expect(reconnectDelays[0]).toBeGreaterThanOrEqual(2250);
+    expect(reconnectDelays[0]).toBeLessThanOrEqual(4500);
+
+    // Last delay should be much larger (~48000ms at attempt 4)
+    expect(reconnectDelays[4]).toBeGreaterThan(20000);
+
+    socket.disconnect();
+  });
+});
+
+
+describe("Bug B fix: Kicked during cooldown still reconnects", () => {
+  it("channel.ts onError handler reconnects even when cooldown is active", () => {
+    /**
+     * With the fix, the else branch in channel.ts onError reconnects the
+     * bot with current credentials when cooldown is active, instead of
+     * doing nothing and letting the bot die permanently.
+     */
+    let lastTokenRefreshAt = 0;
+    const TOKEN_REFRESH_COOLDOWN_MS = 60_000;
+    let isRefreshingToken = false;
+    let stopped = false;
+    let tokenRefreshCount = 0;
+    let reconnectCount = 0;
+
+    // Simulate the FIXED onError handler from channel.ts
+    function onError(err: Error) {
+      const cooldownElapsed = Date.now() - lastTokenRefreshAt > TOKEN_REFRESH_COOLDOWN_MS;
+      if (cooldownElapsed && !isRefreshingToken && !stopped &&
+          (err.message.includes("Kicked") || err.message.includes("Connect failed"))) {
+        isRefreshingToken = true;
+        lastTokenRefreshAt = Date.now();
+        tokenRefreshCount++;
+        // Would do: socket.disconnect() + socket.updateCredentials() + socket.connect()
+        reconnectCount++;
+        isRefreshingToken = false;
+      } else if (!isRefreshingToken && !stopped &&
+          (err.message.includes("Kicked") || err.message.includes("Connect failed"))) {
+        // FIX: Cooldown active — skip token refresh but still reconnect
+        // Would do: socket.disconnect() + socket.connect()
+        reconnectCount++;
+      }
+    }
+
+    // First kick — cooldown not active yet, full refresh happens
+    onError(new Error("Kicked by server"));
+    expect(tokenRefreshCount).toBe(1);
+    expect(reconnectCount).toBe(1);
+
+    // Second kick — within 60s cooldown
+    onError(new Error("Kicked by server"));
+
+    // FIX VERIFIED: reconnect still happens (via else branch), just no token refresh
+    expect(tokenRefreshCount).toBe(1); // no new refresh (cooldown active)
+    expect(reconnectCount).toBe(2);    // reconnect DID happen!
+  });
+
+  it("socket reconnects after channel.ts calls disconnect+connect on kick", () => {
+    /**
+     * When CONNACK returns kicked (reasonCode=0), needReconnect is set to false
+     * and the close event won't trigger scheduleReconnect. But channel.ts can
+     * call socket.disconnect() + socket.connect() to revive the bot.
+     */
+    const originalSetTimeout = global.setTimeout;
+    const setTimeoutCalls: { fn: Function; delay: number }[] = [];
+    global.setTimeout = vi.fn((fn: Function, delay?: number) => {
+      setTimeoutCalls.push({ fn, delay: delay ?? 0 });
+      return 999 as any;
+    }) as any;
+
+    mockWsInstances.length = 0;
+    (globalThis as any).__mockWsInstances = mockWsInstances;
+
+    const onError = vi.fn();
+    const socket = new WKSocket({
+      wsUrl: "ws://test:5200",
+      uid: "bot1",
+      token: "tok1",
+      onMessage: vi.fn(),
+      onError,
+    });
+
+    // Initial connection → kicked
+    socket.connect();
+    const ws1 = mockWsInstances[0];
+    ws1.emit("open");
+    ws1.emit("message", buildConnackKicked());
+
+    expect(onError).toHaveBeenCalledWith(expect.objectContaining({
+      message: "Kicked by server",
+    }));
+
+    // needReconnect is false after kick, close won't trigger scheduleReconnect
+    setTimeoutCalls.length = 0;
+    ws1.emit("close");
+    expect(setTimeoutCalls.length).toBe(0);
+
+    // FIX: channel.ts calls disconnect + connect → bot reconnects
+    socket.disconnect();
+    socket.connect();
+
+    // Verify a new WebSocket was created (bot is alive!)
+    expect(mockWsInstances.length).toBeGreaterThan(1);
+    const ws2 = mockWsInstances[mockWsInstances.length - 1];
+    expect(ws2).not.toBe(ws1);
+
+    socket.disconnect();
+    global.setTimeout = originalSetTimeout;
+    delete (globalThis as any).__mockWsInstances;
+    vi.restoreAllMocks();
+  });
+});
+
+
+describe("Bug C fix: Rapid silent disconnects trigger onError", () => {
+  it("onError fires after 3 consecutive rapid disconnects", () => {
+    /**
+     * With the fix, the close handler tracks rapid disconnects (connections
+     * lasting <5s). After 3 consecutive rapid disconnects, it calls onError
+     * with "Connect failed: rapid disconnect detected" so channel.ts can
+     * refresh the token.
+     */
+    const originalSetTimeout = global.setTimeout;
+    global.setTimeout = vi.fn((fn: Function, delay?: number) => {
+      return 999 as any;
+    }) as any;
+
+    mockWsInstances.length = 0;
+    (globalThis as any).__mockWsInstances = mockWsInstances;
+
+    const onError = vi.fn();
+    const socket = new WKSocket({
+      wsUrl: "ws://test:5200",
+      uid: "bot1",
+      token: "tok1",
+      onMessage: vi.fn(),
+      onError,
+      onConnected: vi.fn(),
+      onDisconnected: vi.fn(),
+    });
+
+    // Simulate 3 rapid connect→CONNACK→immediate-close cycles
+    // (connection lasting <5s each time, simulating server restart)
+    for (let i = 0; i < 3; i++) {
+      socket.connect();
+      const ws = mockWsInstances[mockWsInstances.length - 1];
+      ws.emit("open");
+      ws.emit("message", buildConnackSuccess());
+      // Connection closes immediately (server restart, no Kicked packet)
+      ws.emit("close");
+    }
+
+    // FIX VERIFIED: onError IS called after 3 rapid disconnects
+    expect(onError).toHaveBeenCalledTimes(1);
+    expect(onError).toHaveBeenCalledWith(expect.objectContaining({
+      message: "Connect failed: rapid disconnect detected",
+    }));
+
+    socket.disconnect();
+    global.setTimeout = originalSetTimeout;
+    delete (globalThis as any).__mockWsInstances;
+    vi.restoreAllMocks();
+  });
+
+  it("rapid-disconnect loop with stale token triggers onError for refresh", () => {
+    /**
+     * Simulates the production scenario: server restarts, bot reconnects with
+     * stale token, server silently closes again. After 3 such cycles, onError
+     * fires so channel.ts can refresh the token.
+     */
+    const originalSetTimeout = global.setTimeout;
+    global.setTimeout = vi.fn((fn: Function, delay?: number) => {
+      return 999 as any;
+    }) as any;
+
+    mockWsInstances.length = 0;
+    (globalThis as any).__mockWsInstances = mockWsInstances;
+
+    const onError = vi.fn();
+    const socket = new WKSocket({
+      wsUrl: "ws://test:5200",
+      uid: "bot1",
+      token: "stale-token",
+      onMessage: vi.fn(),
+      onError,
+    });
+
+    // 3 rapid connect→close cycles (simulating stale token scenario)
+    for (let i = 0; i < 3; i++) {
+      socket.connect();
+      const ws = mockWsInstances[mockWsInstances.length - 1];
+      ws.emit("open");
+      ws.emit("message", buildConnackSuccess());
+      ws.emit("close");
+    }
+
+    // FIX VERIFIED: After 3 short-lived connections, onError fires
+    // This allows channel.ts to refresh the token
+    expect(onError).toHaveBeenCalledTimes(1);
+    expect(onError).toHaveBeenCalledWith(expect.objectContaining({
+      message: "Connect failed: rapid disconnect detected",
+    }));
+
+    socket.disconnect();
+    global.setTimeout = originalSetTimeout;
+    delete (globalThis as any).__mockWsInstances;
+    vi.restoreAllMocks();
+  });
+});

package/src/channel.ts

@@ -11,7 +11,7 @@ import {
   resolveDmworkAccount,
   type ResolvedDmworkAccount,
 } from "./accounts.js";
-import { registerBot, sendMessage, sendHeartbeat, sendMediaMessage, inferContentType, fetchBotGroups, getGroupMd, parseImageDimensions, parseImageDimensionsFromFile, getUploadCredentials, uploadFileToCOS } from "./api-fetch.js";
+import { registerBot, sendMessage, sendHeartbeat, sendMediaMessage, inferContentType, ensureTextCharset, fetchBotGroups, getGroupMd, parseImageDimensions, parseImageDimensionsFromFile, getUploadCredentials, uploadFileToCOS } from "./api-fetch.js";
 import { WKSocket } from "./socket.js";
 import { handleInboundMessage, type DmworkStatusSink } from "./inbound.js";
 import { ChannelType, MessageType, type BotMessage, type MessagePayload } from "./types.js";
@@ -445,7 +445,7 @@ export const dmworkPlugin: ChannelPlugin<ResolvedDmworkAccount> = {
         tempPath = dl.tempPath;
         localFilePath = dl.tempPath;
         contentType = dl.contentType;
-        if (!contentType) contentType = inferContentType(filename);
+        if (!contentType || contentType === "application/octet-stream") contentType = inferContentType(filename);
         const st = statSync(tempPath);
         fileBody = createReadStream(tempPath);
         fileSize = st.size;
@@ -469,7 +469,7 @@ export const dmworkPlugin: ChannelPlugin<ResolvedDmworkAccount> = {
           key: creds.key,
           fileBody,
           fileSize,
-          contentType,
+          contentType: ensureTextCharset(contentType),
           cdnBaseUrl: creds.cdnBaseUrl,
         });
 
@@ -640,13 +640,18 @@ export const dmworkPlugin: ChannelPlugin<ResolvedDmworkAccount> = {
             botToken: account.config.botToken!,
           }).then(() => {
             consecutiveHeartbeatFailures = 0; // Reset on success
-          }).catch((err) => {
+          }).catch(async (err) => {
             consecutiveHeartbeatFailures++;
-            log?.error?.(`dmwork: heartbeat failed (${consecutiveHeartbeatFailures}/${MAX_HEARTBEAT_FAILURES}): ${String(err)}`);
+            log?.error?.(`dmwork: [${account.accountId}] heartbeat failed (${consecutiveHeartbeatFailures}/${MAX_HEARTBEAT_FAILURES}): ${String(err)}`);
             if (consecutiveHeartbeatFailures >= MAX_HEARTBEAT_FAILURES && !stopped) {
-              log?.warn?.("dmwork: too many heartbeat failures, triggering reconnect...");
+              log?.warn?.(`dmwork: [${account.accountId}] too many heartbeat failures, triggering reconnect...`);
               consecutiveHeartbeatFailures = 0;
-              socket.disconnect();
+              if (heartbeatTimer) { clearInterval(heartbeatTimer); heartbeatTimer = null; }
+              const backoffMs = 3000 + Math.floor(Math.random() * 2000);
+              await new Promise(r => setTimeout(r, backoffMs));
+              if (stopped) return;
+              await socket.disconnectAndWait();
+              socket.stopReconnectTimer();
               socket.connect();
             }
           });
@@ -670,7 +675,10 @@ export const dmworkPlugin: ChannelPlugin<ResolvedDmworkAccount> = {
       const TOKEN_REFRESH_COOLDOWN_MS = 60_000; // 60 seconds
       let isRefreshingToken = false; // Guard against concurrent refreshes (#43)
 
-      // 5b. Heartbeat failure tracking — reconnect after consecutive failures (#42)
+      // 5b. Cooldown reconnect timer — deduplicate to prevent self-kick storms (#139)
+      let cooldownReconnectTimer: ReturnType<typeof setTimeout> | null = null;
+
+      // 5c. Heartbeat failure tracking — reconnect after consecutive failures (#42)
       let consecutiveHeartbeatFailures = 0;
       const MAX_HEARTBEAT_FAILURES = 3;
 
@@ -740,18 +748,20 @@ export const dmworkPlugin: ChannelPlugin<ResolvedDmworkAccount> = {
         },
 
         onConnected: () => {
-          log?.info?.(`dmwork: WebSocket connected to ${wsUrl}`);
+          log?.info?.(`dmwork: [${account.accountId}] WebSocket connected to ${wsUrl}`);
           statusSink({ lastError: null });
+          consecutiveHeartbeatFailures = 0;
           startHeartbeat();
         },
 
         onDisconnected: () => {
-          log?.warn?.("dmwork: WebSocket disconnected, will reconnect...");
+          log?.warn?.(`dmwork: [${account.accountId}] WebSocket disconnected, will reconnect...`);
+          if (heartbeatTimer) { clearInterval(heartbeatTimer); heartbeatTimer = null; }
           statusSink({ lastError: "disconnected" });
         },
 
         onError: async (err: Error) => {
-          log?.error?.(`dmwork: WebSocket error: ${err.message}`);
+          log?.error?.(`dmwork: [${account.accountId}] WebSocket error: ${err.message}`);
           statusSink({ lastError: err.message });
 
           // If kicked or connect failed, try refreshing the IM token with a cooldown
@@ -762,30 +772,49 @@ export const dmworkPlugin: ChannelPlugin<ResolvedDmworkAccount> = {
               (err.message.includes("Kicked") || err.message.includes("Connect failed"))) {
             isRefreshingToken = true;
             lastTokenRefreshAt = Date.now();
-            log?.warn?.("dmwork: connection rejected — refreshing IM token...");
+            log?.warn?.(`dmwork: [${account.accountId}] connection rejected — refreshing IM token...`);
             try {
+              await socket.disconnectAndWait();
               const fresh = await registerBot({
                 apiUrl: account.config.apiUrl,
                 botToken: account.config.botToken!,
                 forceRefresh: true,
               });
               credentials = fresh;
-              log?.info?.("dmwork: got fresh IM token, reconnecting WS...");
-              socket.disconnect();
+              log?.info?.(`dmwork: [${account.accountId}] got fresh IM token, reconnecting WS...`);
               socket.updateCredentials(fresh.robot_id, fresh.im_token);
               // Stagger reconnect to avoid thundering herd when multiple bots
               // refresh tokens simultaneously after server-wide token expiry
               const staggerMs = Math.floor(Math.random() * 5000);
-              log?.info?.(`dmwork: staggering reconnect by ${staggerMs}ms`);
+              log?.info?.(`dmwork: [${account.accountId}] staggering reconnect by ${staggerMs}ms`);
               await new Promise(r => setTimeout(r, staggerMs));
               if (stopped) return; // account was stopped during stagger delay
               socket.connect();
             } catch (refreshErr) {
-              log?.error?.(`dmwork: token refresh failed: ${String(refreshErr)}`);
+              log?.error?.(`dmwork: [${account.accountId}] token refresh failed: ${String(refreshErr)}`);
               // Keep cooldown active even on failure to prevent rapid retry hammering
             } finally {
               isRefreshingToken = false;
             }
+          } else if (!isRefreshingToken && !stopped &&
+              (err.message.includes("Kicked") || err.message.includes("Connect failed"))) {
+            // Cooldown active — skip token refresh but still reconnect with current credentials.
+            // Deduplicate: clear any pending cooldown reconnect timer to prevent self-kick storms
+            // where multiple setTimeout callbacks fire simultaneously, each calling connect(),
+            // causing the same bot to have multiple WS connections that kick each other (#139).
+            if (cooldownReconnectTimer) {
+              clearTimeout(cooldownReconnectTimer);
+            }
+            log?.warn?.(`dmwork: [${account.accountId}] cooldown active, scheduling reconnect with current credentials...`);
+            const backoffMs = 5000 + Math.floor(Math.random() * 5000);
+            cooldownReconnectTimer = setTimeout(async () => {
+              cooldownReconnectTimer = null;
+              if (!stopped) {
+                await socket.disconnectAndWait();
+                socket.stopReconnectTimer();
+                socket.connect();
+              }
+            }, backoffMs);
           }
         },
       });
@@ -799,6 +828,7 @@ export const dmworkPlugin: ChannelPlugin<ResolvedDmworkAccount> = {
           stopped = true;
           socket.disconnect();
           if (heartbeatTimer) { clearInterval(heartbeatTimer); heartbeatTimer = null; }
+          if (cooldownReconnectTimer) { clearTimeout(cooldownReconnectTimer); cooldownReconnectTimer = null; }
           ctx.setStatus({
             accountId: account.accountId,
             running: false,

package/src/inbound.ts

@@ -1,5 +1,5 @@
 import type { ChannelLogSink, OpenClawConfig } from "openclaw/plugin-sdk";
-import { sendMessage, sendReadReceipt, sendTyping, getChannelMessages, getGroupMembers, getGroupMd, postJson, sendMediaMessage, inferContentType, parseImageDimensions, parseImageDimensionsFromFile, getUploadCredentials, uploadFileToCOS } from "./api-fetch.js";
+import { sendMessage, sendReadReceipt, sendTyping, getChannelMessages, getGroupMembers, getGroupMd, postJson, sendMediaMessage, inferContentType, ensureTextCharset, parseImageDimensions, parseImageDimensionsFromFile, getUploadCredentials, uploadFileToCOS } from "./api-fetch.js";
 import type { ResolvedDmworkAccount } from "./accounts.js";
 import type { BotMessage } from "./types.js";
 import { ChannelType, MessageType } from "./types.js";
@@ -160,7 +160,7 @@ export async function uploadAndSendMedia(params: {
       key: creds.key,
       fileBody,
       fileSize,
-      contentType,
+      contentType: ensureTextCharset(contentType),
       cdnBaseUrl: creds.cdnBaseUrl,
     });