openclaw-channel-dmwork 0.2.21 → 0.2.23

package/openclaw.plugin.json

@@ -1,5 +1,5 @@
 {
-  "id": "dmwork",
+  "id": "openclaw-channel-dmwork",
   "channels": [
     "dmwork"
   ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-channel-dmwork",
-  "version": "0.2.21",
+  "version": "0.2.23",
   "description": "DMWork channel plugin for OpenClaw via WuKongIM WebSocket",
   "main": "index.ts",
   "type": "module",
@@ -11,7 +11,9 @@
   ],
   "scripts": {
     "build": "tsc",
-    "type-check": "tsc --noEmit"
+    "type-check": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
   "dependencies": {
     "axios": "^1.7.0",
@@ -24,10 +26,11 @@
   "devDependencies": {
     "@types/ws": "^8.5.10",
     "openclaw": "2026.3.1",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "vitest": "^3.0.0"
   },
   "openclaw": {
-    "id": "dmwork",
+    "id": "openclaw-channel-dmwork",
     "type": "channel",
     "extensions": [
       "index.ts"
@@ -36,4 +39,4 @@
   "bundledDependencies": [
     "wukongimjssdk"
   ]
-}
+}

package/src/accounts.ts

@@ -18,6 +18,8 @@ export type ResolvedDmworkAccount = {
     pollIntervalMs: number;
     heartbeatIntervalMs: number;
     requireMention?: boolean;
+    historyLimit?: number;  // 群聊历史消息条数限制
+    historyPromptTemplate?: string;  // Template for group history context injection
   };
 };
 
@@ -73,6 +75,8 @@ export function resolveDmworkAccount(params: {
       pollIntervalMs,
       heartbeatIntervalMs,
       requireMention: accountConfig.requireMention ?? channel.requireMention,
+      historyLimit: accountConfig.historyLimit ?? channel.historyLimit ?? 20,
+      historyPromptTemplate: accountConfig.historyPromptTemplate ?? channel.historyPromptTemplate,
     },
   };
 }

package/src/api-fetch.test.ts

@@ -0,0 +1,158 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+/**
+ * Tests for api-fetch.ts functions.
+ *
+ * Verifies that async functions properly await their responses
+ * and return resolved data instead of Promises.
+ */
+describe("fetchBotGroups", () => {
+  const originalFetch = global.fetch;
+
+  beforeEach(() => {
+    // Reset fetch mock before each test
+    vi.restoreAllMocks();
+  });
+
+  afterEach(() => {
+    // Restore original fetch
+    global.fetch = originalFetch;
+  });
+
+  it("should return an array, not a Promise", async () => {
+    // Mock fetch to return a successful response
+    const mockGroups = [
+      { group_no: "group1", name: "Test Group 1" },
+      { group_no: "group2", name: "Test Group 2" },
+    ];
+
+    global.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: vi.fn().mockResolvedValue(mockGroups),
+    }) as unknown as typeof fetch;
+
+    // Import dynamically to use mocked fetch
+    const { fetchBotGroups } = await import("./api-fetch.js");
+
+    const result = await fetchBotGroups({
+      apiUrl: "http://localhost:8090",
+      botToken: "test-token",
+    });
+
+    // Critical: result should be the actual array, not a Promise
+    expect(Array.isArray(result)).toBe(true);
+    expect(result).toHaveLength(2);
+    expect(result[0].group_no).toBe("group1");
+    expect(result[1].name).toBe("Test Group 2");
+  });
+
+  it("should return empty array on non-ok response", async () => {
+    global.fetch = vi.fn().mockResolvedValue({
+      ok: false,
+      status: 500,
+    }) as unknown as typeof fetch;
+
+    const { fetchBotGroups } = await import("./api-fetch.js");
+
+    const result = await fetchBotGroups({
+      apiUrl: "http://localhost:8090",
+      botToken: "test-token",
+    });
+
+    expect(Array.isArray(result)).toBe(true);
+    expect(result).toHaveLength(0);
+  });
+
+  it("should properly await json() call", async () => {
+    // This test specifically verifies the fix for issue #29
+    // If await is missing, the result would be a Promise object
+    const mockGroups = [{ group_no: "g1", name: "Group" }];
+    const jsonMock = vi.fn().mockResolvedValue(mockGroups);
+
+    global.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: jsonMock,
+    }) as unknown as typeof fetch;
+
+    const { fetchBotGroups } = await import("./api-fetch.js");
+
+    const result = await fetchBotGroups({
+      apiUrl: "http://localhost:8090",
+      botToken: "test-token",
+    });
+
+    // Verify json() was called
+    expect(jsonMock).toHaveBeenCalled();
+
+    // Verify result is resolved data, not a Promise
+    expect(result).not.toBeInstanceOf(Promise);
+    expect(result).toEqual(mockGroups);
+
+    // Additional check: calling array methods should work
+    expect(result.length).toBe(1);
+    expect(result.map((g) => g.name)).toEqual(["Group"]);
+  });
+});
+
+describe("log parameter type compatibility", () => {
+  const originalFetch = global.fetch;
+
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  afterEach(() => {
+    global.fetch = originalFetch;
+  });
+
+  it("should accept ChannelLogSink-compatible log parameter", async () => {
+    // Simulates ChannelLogSink type from OpenClaw SDK:
+    // { info: (msg: string) => void; error: (msg: string) => void; ... }
+    const channelLogSink = {
+      info: (msg: string) => console.log(msg),
+      warn: (msg: string) => console.warn(msg),
+      error: (msg: string) => console.error(msg),
+    };
+
+    const mockGroups = [{ group_no: "g1", name: "Group" }];
+
+    global.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: vi.fn().mockResolvedValue(mockGroups),
+    }) as unknown as typeof fetch;
+
+    const { fetchBotGroups } = await import("./api-fetch.js");
+
+    // This should compile without TypeScript errors
+    const result = await fetchBotGroups({
+      apiUrl: "http://localhost:8090",
+      botToken: "test-token",
+      log: channelLogSink,
+    });
+
+    expect(result).toEqual(mockGroups);
+  });
+
+  it("should call log.error on non-ok response", async () => {
+    const errorSpy = vi.fn();
+    const log = {
+      info: vi.fn(),
+      error: errorSpy,
+    };
+
+    global.fetch = vi.fn().mockResolvedValue({
+      ok: false,
+      status: 401,
+    }) as unknown as typeof fetch;
+
+    const { fetchBotGroups } = await import("./api-fetch.js");
+
+    await fetchBotGroups({
+      apiUrl: "http://localhost:8090",
+      botToken: "test-token",
+      log,
+    });
+
+    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining("401"));
+  });
+});

package/src/api-fetch.ts

@@ -5,6 +5,8 @@
 
 import { ChannelType, MessageType } from "./types.js";
 
+const DEFAULT_TIMEOUT_MS = 30_000;
+
 const DEFAULT_HEADERS = {
   "Content-Type": "application/json",
 };
@@ -15,7 +17,7 @@ async function postJson<T>(
   path: string,
   payload: Record<string, unknown>,
   signal?: AbortSignal,
-): Promise<T> {
+): Promise<T | undefined> {
   const url = `${apiUrl.replace(/\/+$/, "")}${path}`;
   const response = await fetch(url, {
     method: "POST",
@@ -33,7 +35,7 @@ async function postJson<T>(
   }
 
   const text = await response.text();
-  if (!text) return {} as T;
+  if (!text) return undefined;
   return JSON.parse(text) as T;
 }
 
@@ -125,13 +127,23 @@ export async function registerBot(params: {
   const path = params.forceRefresh
     ? "/v1/bot/register?force_refresh=true"
     : "/v1/bot/register";
-  return postJson(params.apiUrl, params.botToken, path, {}, params.signal);
+  const result = await postJson<{
+    robot_id: string;
+    im_token: string;
+    ws_url: string;
+    api_url: string;
+    owner_uid: string;
+    owner_channel_id: string;
+  }>(params.apiUrl, params.botToken, path, {}, params.signal);
+  if (!result) throw new Error("DMWork bot registration returned empty response");
+  return result;
 }
 
 // Fetch the groups the bot belongs to
 export async function fetchBotGroups(params: {
   apiUrl: string;
   botToken: string;
+  log?: { info?: (msg: string) => void; error?: (msg: string) => void };
 }): Promise<Array<{ group_no: string; name: string }>> {
   const url = `${params.apiUrl}/v1/bot/groups`;
   const resp = await fetch(url, {
@@ -139,10 +151,122 @@ export async function fetchBotGroups(params: {
     headers: {
       "Authorization": `Bearer ${params.botToken}`,
     },
+    signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS),
   });
   if (!resp.ok) {
-    // Fallback: return empty if API not available
+    params.log?.error?.(`dmwork: fetchBotGroups failed: ${resp.status}`);
+    return [];
+  }
+  return await resp.json();
+}
+
+/**
+ * 获取群成员列表
+ */
+export interface GroupMember {
+  uid: string;
+  name: string;
+  role?: string;    // admin/member
+  robot?: boolean;  // 是否是机器人
+}
+
+export async function getGroupMembers(params: {
+  apiUrl: string;
+  botToken: string;
+  groupNo: string;  // 群 ID (channel_id)
+  log?: { info?: (msg: string) => void; error?: (msg: string) => void };
+}): Promise<GroupMember[]> {
+  const url = `${params.apiUrl.replace(/\/+$/, "")}/v1/bot/groups/${params.groupNo}/members`;
+  try {
+    const resp = await fetch(url, {
+      method: "GET",
+      headers: {
+        "Authorization": `Bearer ${params.botToken}`,
+      },
+      signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS),
+    });
+    if (!resp.ok) {
+      params.log?.error?.(`dmwork: getGroupMembers failed: ${resp.status}`);
+      return [];
+    }
+    const data = await resp.json();
+    // Normalize to strict array to prevent silent failures
+    const members = Array.isArray(data?.members)
+      ? data.members
+      : Array.isArray(data)
+        ? data
+        : [];
+    return members as GroupMember[];
+  } catch (err) {
+    params.log?.error?.(`dmwork: getGroupMembers error: ${err}`);
+    return [];
+  }
+}
+
+/**
+ * 获取频道历史消息（用于注入上下文）
+ * @param params.log - Optional logger for consistent logging with OpenClaw log system
+ */
+export async function getChannelMessages(params: {
+  apiUrl: string;
+  botToken: string;
+  channelId: string;
+  channelType: ChannelType;
+  limit?: number;
+  signal?: AbortSignal;
+  log?: { info?: (msg: string) => void; error?: (msg: string) => void };
+}): Promise<Array<{ from_uid: string; content: string; timestamp: number; type?: number; url?: string; name?: string }>> {
+  try {
+    const url = `${params.apiUrl.replace(/\/+$/, "")}/v1/bot/messages/sync`;
+    const limit = params.limit ?? 20;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${params.botToken}`,
+      },
+      body: JSON.stringify({
+        channel_id: params.channelId,
+        channel_type: params.channelType,
+        limit,
+        start_message_seq: 0,
+        end_message_seq: 0,
+        pull_mode: 1,  // 1 = pull up (newer messages)
+      }),
+      signal: params.signal,
+    });
+
+    if (!response.ok) {
+      params.log?.info?.(`dmwork: getChannelMessages failed: ${response.status}`);
+      return [];
+    }
+
+    const data = await response.json();
+    const messages = data.messages ?? [];
+    return messages.map((m: any) => {
+      // payload is base64-encoded JSON string
+      let payload: any = {};
+      if (m.payload) {
+        try {
+          const decoded = Buffer.from(m.payload, "base64").toString("utf-8");
+          payload = JSON.parse(decoded);
+        } catch {
+          // If decoding fails, try treating payload as already-parsed object
+          payload = typeof m.payload === "object" ? m.payload : {};
+        }
+      }
+      return {
+        from_uid: m.from_uid ?? "unknown",
+        type: payload.type ?? undefined,
+        url: payload.url ?? undefined,
+        name: payload.name ?? undefined,
+        content: payload.content ?? "",
+        // Convert seconds to milliseconds (API returns seconds, internal standard is ms)
+        timestamp: (m.timestamp ?? Math.floor(Date.now() / 1000)) * 1000,
+      };
+    });
+  } catch (err) {
+    params.log?.error?.(`dmwork: getChannelMessages error: ${err}`);
     return [];
   }
-  return resp.json();
 }

package/src/channel.test.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+/**
+ * Tests for channel.ts singleton timer behavior.
+ * Verifies that cleanup timer doesn't accumulate during hot reloads.
+ *
+ * Fixes: https://github.com/dmwork-org/dmwork-adapters/issues/54
+ */
+
+describe("ensureCleanupTimer singleton pattern", () => {
+  let originalSetInterval: typeof setInterval;
+  let setIntervalCalls: number;
+
+  beforeEach(() => {
+    originalSetInterval = global.setInterval;
+    setIntervalCalls = 0;
+
+    // Track setInterval calls
+    global.setInterval = vi.fn(() => {
+      setIntervalCalls++;
+      // Return a mock timer object that won't actually run
+      const timerId = { unref: vi.fn() } as unknown as NodeJS.Timeout;
+      return timerId;
+    }) as unknown as typeof setInterval;
+  });
+
+  afterEach(() => {
+    global.setInterval = originalSetInterval;
+    vi.resetModules();
+  });
+
+  it("should only create one cleanup timer on first import", async () => {
+    // Fresh import - timer should be created lazily now (not at module load)
+    // Since we changed to lazy initialization, no timer at import time
+    vi.resetModules();
+    const { dmworkPlugin } = await import("./channel.js");
+
+    // At this point, no timer should have been created yet
+    // Timer is created when startAccount is called
+    expect(dmworkPlugin).toBeDefined();
+    expect(dmworkPlugin.id).toBe("dmwork");
+  });
+
+  it("should expose ensureCleanupTimer via gateway.startAccount pattern", async () => {
+    vi.resetModules();
+    const { dmworkPlugin } = await import("./channel.js");
+
+    // The gateway.startAccount method should exist and call ensureCleanupTimer
+    expect(dmworkPlugin.gateway?.startAccount).toBeDefined();
+    expect(typeof dmworkPlugin.gateway?.startAccount).toBe("function");
+  });
+});
+
+describe("dmworkPlugin structure", () => {
+  it("should have correct plugin id and meta", async () => {
+    const { dmworkPlugin } = await import("./channel.js");
+
+    expect(dmworkPlugin.id).toBe("dmwork");
+    expect(dmworkPlugin.meta.id).toBe("dmwork");
+    expect(dmworkPlugin.meta.label).toBe("DMWork");
+  });
+
+  it("should have gateway.startAccount defined", async () => {
+    const { dmworkPlugin } = await import("./channel.js");
+
+    expect(dmworkPlugin.gateway).toBeDefined();
+    expect(dmworkPlugin.gateway?.startAccount).toBeDefined();
+  });
+
+  it("should support direct and group chat types", async () => {
+    const { dmworkPlugin } = await import("./channel.js");
+
+    expect(dmworkPlugin.capabilities?.chatTypes).toContain("direct");
+    expect(dmworkPlugin.capabilities?.chatTypes).toContain("group");
+  });
+});

package/src/channel.ts

@@ -15,6 +15,7 @@ import { registerBot, sendMessage, sendHeartbeat } 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";
+import { parseMentions } from "./mention-utils.js";
 // HistoryEntry type - compatible with any version
 type HistoryEntry = { sender: string; body: string; timestamp: number };
 const DEFAULT_GROUP_HISTORY_LIMIT = 20;
@@ -30,6 +31,80 @@ function getOrCreateHistoryMap(accountId: string): Map<string, any[]> {
   return m;
 }
 
+// Module-level member mapping: displayName -> uid
+// Used to resolve @mentions in AI replies
+const _memberMaps = new Map<string, Map<string, string>>();
+function getOrCreateMemberMap(accountId: string): Map<string, string> {
+  let m = _memberMaps.get(accountId);
+  if (!m) {
+    m = new Map<string, string>();
+    _memberMaps.set(accountId, m);
+  }
+  return m;
+}
+
+// Module-level reverse mapping: uid -> displayName
+// Used to show display names instead of uids in replies
+const _uidToNameMaps = new Map<string, Map<string, string>>();
+function getOrCreateUidToNameMap(accountId: string): Map<string, string> {
+  let m = _uidToNameMaps.get(accountId);
+  if (!m) {
+    m = new Map<string, string>();
+    _uidToNameMaps.set(accountId, m);
+  }
+  return m;
+}
+
+// Group member cache timestamps: groupId -> lastFetchedAt (ms)
+const _groupCacheTimestamps = new Map<string, Map<string, number>>();
+function getOrCreateGroupCacheTimestamps(accountId: string): Map<string, number> {
+  let m = _groupCacheTimestamps.get(accountId);
+  if (!m) {
+    m = new Map<string, number>();
+    _groupCacheTimestamps.set(accountId, m);
+  }
+  return m;
+}
+
+
+// --- Cache cleanup: evict groups inactive for >4 hours ---
+const CACHE_MAX_AGE_MS = 4 * 60 * 60 * 1000;
+const CACHE_CLEANUP_INTERVAL_MS = 30 * 60 * 1000;
+const _cacheActivity = new Map<string, Map<string, number>>();
+
+function touchCache(accountId: string, groupId: string): void {
+  let m = _cacheActivity.get(accountId);
+  if (!m) { m = new Map(); _cacheActivity.set(accountId, m); }
+  m.set(groupId, Date.now());
+}
+
+function cleanupStaleCaches(): void {
+  const cutoff = Date.now() - CACHE_MAX_AGE_MS;
+  for (const [accountId, activityMap] of _cacheActivity) {
+    for (const [groupId, lastAccess] of activityMap) {
+      if (lastAccess < cutoff) {
+        _historyMaps.get(accountId)?.delete(groupId);
+        _memberMaps.get(accountId)?.delete(groupId);
+        _uidToNameMaps.get(accountId)?.delete(groupId);
+        _groupCacheTimestamps.get(accountId)?.delete(groupId);
+        activityMap.delete(groupId);
+      }
+    }
+    if (activityMap.size === 0) _cacheActivity.delete(accountId);
+  }
+}
+
+// Singleton timer to prevent accumulation during hot reload (#54)
+let _cleanupTimer: NodeJS.Timeout | null = null;
+
+function ensureCleanupTimer(): void {
+  if (_cleanupTimer) return; // Already running
+  _cleanupTimer = setInterval(cleanupStaleCaches, CACHE_CLEANUP_INTERVAL_MS);
+  if (typeof _cleanupTimer === "object" && _cleanupTimer && "unref" in _cleanupTimer) {
+    _cleanupTimer.unref();
+  }
+}
+
 const meta = {
   id: "dmwork",
   label: "DMWork",
@@ -45,7 +120,7 @@ export const dmworkPlugin: ChannelPlugin<ResolvedDmworkAccount> = {
   meta,
   capabilities: {
     chatTypes: ["direct", "group"],
-    media: false,
+    media: true,
     reactions: false,
     threads: false,
   },
@@ -104,6 +179,19 @@ export const dmworkPlugin: ChannelPlugin<ResolvedDmworkAccount> = {
           channelId = groupPart;
         }
         channelType = ChannelType.Group;
+
+        // Parse @mentions from message content (e.g., "@chenpipi_bot", "@陈皮皮")
+        // Uses shared utility for consistent regex across inbound/outbound (fixes #31)
+        const contentMentionNames = parseMentions(content);
+        for (const name of contentMentionNames) {
+          if (name && !mentionUids.includes(name)) {
+            mentionUids.push(name);
+            console.log(`[dmwork] parsed @mention from content: ${name}`);
+          }
+        }
+        if (mentionUids.length > 0) {
+          console.log(`[dmwork] sending message with mentionUids: ${mentionUids.join(", ")}`);
+        }
       }
 
       await sendMessage({
@@ -142,6 +230,9 @@ export const dmworkPlugin: ChannelPlugin<ResolvedDmworkAccount> = {
   },
   gateway: {
     startAccount: async (ctx) => {
+      // Ensure cleanup timer is running (singleton pattern for hot reload safety)
+      ensureCleanupTimer();
+
       const account = ctx.account;
       if (!account.configured || !account.config.botToken) {
         throw new Error(
@@ -199,17 +290,40 @@ export const dmworkPlugin: ChannelPlugin<ResolvedDmworkAccount> = {
           sendHeartbeat({
             apiUrl: account.config.apiUrl,
             botToken: account.config.botToken!,
+          }).then(() => {
+            consecutiveHeartbeatFailures = 0; // Reset on success
           }).catch((err) => {
-            log?.error?.(`dmwork: heartbeat failed: ${String(err)}`);
+            consecutiveHeartbeatFailures++;
+            log?.error?.(`dmwork: heartbeat failed (${consecutiveHeartbeatFailures}/${MAX_HEARTBEAT_FAILURES}): ${String(err)}`);
+            if (consecutiveHeartbeatFailures >= MAX_HEARTBEAT_FAILURES && !stopped) {
+              log?.warn?.("dmwork: too many heartbeat failures, triggering reconnect...");
+              consecutiveHeartbeatFailures = 0;
+              socket.disconnect();
+              socket.connect();
+            }
           });
         }, account.config.heartbeatIntervalMs);
       };
 
       // 4. Group history map — persists across auto-restarts (module-level)
       const groupHistories = getOrCreateHistoryMap(account.accountId);
+      
+      // 4b. Member name->uid map — for resolving @mentions in replies
+      const memberMap = getOrCreateMemberMap(account.accountId);
+      
+      // 4c. Reverse map uid->name — for showing display names in replies
+      const uidToNameMap = getOrCreateUidToNameMap(account.accountId);
+      
+      // 4d. Group cache timestamps — track when each group's members were last fetched
+      const groupCacheTimestamps = getOrCreateGroupCacheTimestamps(account.accountId);
 
       // 5. Token refresh state — detect stale cached token
       let hasRefreshedToken = false;
+      let isRefreshingToken = false; // Guard against concurrent refreshes (#43)
+
+      // 5b. Heartbeat failure tracking — reconnect after consecutive failures (#42)
+      let consecutiveHeartbeatFailures = 0;
+      const MAX_HEARTBEAT_FAILURES = 3;
 
       // 6. Connect WebSocket — pure real-time via WuKongIM SDK
       const socket = new WKSocket({
@@ -220,18 +334,25 @@ export const dmworkPlugin: ChannelPlugin<ResolvedDmworkAccount> = {
         onMessage: (msg: BotMessage) => {
           // Skip self messages
           if (msg.from_uid === credentials.robot_id) return;
-          // Skip non-text for now
-          if (!msg.payload || msg.payload.type !== MessageType.Text) return;
+          // Skip unsupported message types (Location, Card)
+          const supportedTypes = [MessageType.Text, MessageType.Image, MessageType.GIF, MessageType.Voice, MessageType.Video, MessageType.File];
+          if (!msg.payload || !supportedTypes.includes(msg.payload.type)) return;
 
           log?.info?.(
             `dmwork: recv message from=${msg.from_uid} channel=${msg.channel_id ?? "DM"} type=${msg.channel_type ?? 1}`,
           );
 
+          // Track cache activity for cleanup
+          if (msg.channel_id) touchCache(account.accountId, msg.channel_id);
+
           handleInboundMessage({
             account,
             message: msg,
             botUid: credentials.robot_id,
             groupHistories,
+            memberMap,
+            uidToNameMap,
+            groupCacheTimestamps,
             log,
             statusSink,
           }).catch((err) => {
@@ -256,8 +377,10 @@ export const dmworkPlugin: ChannelPlugin<ResolvedDmworkAccount> = {
           statusSink({ lastError: err.message });
 
           // If kicked or connect failed, try refreshing the IM token once
-          if (!hasRefreshedToken && !stopped &&
+          // Use isRefreshingToken to prevent concurrent refresh attempts (#43)
+          if (!hasRefreshedToken && !isRefreshingToken && !stopped &&
               (err.message.includes("Kicked") || err.message.includes("Connect failed"))) {
+            isRefreshingToken = true;
             hasRefreshedToken = true;
             log?.warn?.("dmwork: connection rejected — refreshing IM token...");
             try {
@@ -273,6 +396,9 @@ export const dmworkPlugin: ChannelPlugin<ResolvedDmworkAccount> = {
               socket.connect();
             } catch (refreshErr) {
               log?.error?.(`dmwork: token refresh failed: ${String(refreshErr)}`);
+              hasRefreshedToken = false; // Allow retry on next error (#43)
+            } finally {
+              isRefreshingToken = false;
             }
           }
         },