@soimy/dingtalk 2.7.0 → 3.0.0

package/src/config-schema.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { z } from "zod";
 
 const DingTalkAccountConfigSchema = z.object({
   /** Account name (optional display name) */
@@ -23,10 +23,10 @@ const DingTalkAccountConfigSchema = z.object({
   agentId: z.union([z.string(), z.number()]).optional(),
 
   /** Direct message policy: open, pairing, or allowlist */
-  dmPolicy: z.enum(['open', 'pairing', 'allowlist']).optional().default('open'),
+  dmPolicy: z.enum(["open", "pairing", "allowlist"]).optional().default("open"),
 
   /** Group message policy: open or allowlist */
-  groupPolicy: z.enum(['open', 'allowlist']).optional().default('open'),
+  groupPolicy: z.enum(["open", "allowlist"]).optional().default("open"),
 
   /** List of allowed user IDs for allowlist policy */
   allowFrom: z.array(z.string()).optional(),
@@ -38,7 +38,7 @@ const DingTalkAccountConfigSchema = z.object({
   debug: z.boolean().optional().default(false),
 
   /** Message type for replies: markdown or card */
-  messageType: z.enum(['markdown', 'card']).optional().default('markdown'),
+  messageType: z.enum(["markdown", "card"]).optional().default("markdown"),
 
   /** Card template ID for AI interactive cards
    * obtain the template ID from DingTalk Developer Console.
@@ -50,7 +50,7 @@ const DingTalkAccountConfigSchema = z.object({
    * Default: 'msgContent' - maps to the content field in the card template
    * This key is used in the streaming API to update specific fields in the card.
    */
-  cardTemplateKey: z.string().optional().default('content'),
+  cardTemplateKey: z.string().optional().default("content"),
 
   /** Per-group configuration, keyed by conversationId (supports "*" wildcard) */
   groups: z
@@ -58,7 +58,7 @@ const DingTalkAccountConfigSchema = z.object({
       z.string(),
       z.object({
         systemPrompt: z.string().optional(),
-      })
+      }),
     )
     .optional(),
 
@@ -83,12 +83,7 @@ const DingTalkAccountConfigSchema = z.object({
  */
 export const DingTalkConfigSchema: z.ZodTypeAny = DingTalkAccountConfigSchema.extend({
   /** Multi-account configuration */
-  accounts: z
-    .record(
-      z.string(),
-      DingTalkAccountConfigSchema.optional()
-    )
-    .optional(),
+  accounts: z.record(z.string(), DingTalkAccountConfigSchema.optional()).optional(),
 });
 
 export type DingTalkConfig = z.infer<typeof DingTalkConfigSchema>;

package/src/config.ts

@@ -0,0 +1,79 @@
+import * as os from "node:os";
+import * as path from "node:path";
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import type { DingTalkConfig } from "./types";
+
+/**
+ * Resolve DingTalk config for an account.
+ * Falls back to top-level config for single-account setups.
+ */
+export function getConfig(cfg: OpenClawConfig, accountId?: string): DingTalkConfig {
+  const dingtalkCfg = cfg?.channels?.dingtalk as DingTalkConfig | undefined;
+  if (!dingtalkCfg) {
+    return {} as DingTalkConfig;
+  }
+
+  if (accountId && dingtalkCfg.accounts?.[accountId]) {
+    return dingtalkCfg.accounts[accountId];
+  }
+
+  return dingtalkCfg;
+}
+
+export function isConfigured(cfg: OpenClawConfig, accountId?: string): boolean {
+  const config = getConfig(cfg, accountId);
+  return Boolean(config.clientId && config.clientSecret);
+}
+
+export function resolveRelativePath(input: string): string {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    return trimmed;
+  }
+
+  const segments = (value: string): string[] => value.split(/[\\/]+/).filter(Boolean);
+
+  // Expand bare "~" and "~/" or "~\\" prefixes into the user home directory.
+  if (trimmed === "~") {
+    return path.resolve(os.homedir());
+  }
+  if (trimmed.startsWith("~/") || trimmed.startsWith("~\\")) {
+    return path.resolve(os.homedir(), ...segments(trimmed.slice(2)));
+  }
+
+  // Treat both "/" and "\\" as absolute root prefixes for cross-platform input.
+  if (/^[\\/]/.test(trimmed)) {
+    return path.resolve(path.sep, ...segments(trimmed));
+  }
+
+  // Resolve relative path against cwd; supports mixed separators and "..\\..".
+  return path.resolve(process.cwd(), ...segments(trimmed));
+}
+
+export const resolveUserPath = resolveRelativePath;
+
+export function resolveGroupConfig(
+  cfg: DingTalkConfig,
+  groupId: string,
+): { systemPrompt?: string } | undefined {
+  // Group config supports exact match first, then wildcard fallback.
+  const groups = cfg.groups;
+  if (!groups) {
+    return undefined;
+  }
+  return groups[groupId] || groups["*"] || undefined;
+}
+
+/**
+ * Strip group/user prefixes used by CLI targeting.
+ * Returns raw DingTalk target ID and whether caller explicitly requested a user target.
+ */
+export function stripTargetPrefix(target: string): { targetId: string; isExplicitUser: boolean } {
+  if (target.startsWith("group:")) {
+    return { targetId: target.slice(6), isExplicitUser: false };
+  }
+  if (target.startsWith("user:")) {
+    return { targetId: target.slice(5), isExplicitUser: true };
+  }
+  return { targetId: target, isExplicitUser: false };
+}

package/src/connection-manager.ts

@@ -9,9 +9,14 @@
  * - Structured logging for all connection events
  */
 
-import type { DWClient } from 'dingtalk-stream';
-import type { ConnectionState, ConnectionManagerConfig, ConnectionAttemptResult, Logger } from './types';
-import { ConnectionState as ConnectionStateEnum } from './types';
+import type { DWClient } from "dingtalk-stream";
+import type {
+  ConnectionState,
+  ConnectionManagerConfig,
+  ConnectionAttemptResult,
+  Logger,
+} from "./types";
+import { ConnectionState as ConnectionStateEnum } from "./types";
 
 /**
  * ConnectionManager handles the robust connection lifecycle for DWClient
@@ -84,14 +89,20 @@ export class ConnectionManager {
    */
   private async attemptConnection(): Promise<ConnectionAttemptResult> {
     if (this.stopped) {
-      return { success: false, attempt: this.attemptCount, error: new Error('Connection manager stopped') };
+      return {
+        success: false,
+        attempt: this.attemptCount,
+        error: new Error("Connection manager stopped"),
+      };
     }
 
     this.attemptCount++;
     this.state = ConnectionStateEnum.CONNECTING;
     this.notifyStateChange();
 
-    this.log?.info?.(`[${this.accountId}] Connection attempt ${this.attemptCount}/${this.config.maxAttempts}...`);
+    this.log?.info?.(
+      `[${this.accountId}] Connection attempt ${this.attemptCount}/${this.config.maxAttempts}...`,
+    );
 
     try {
       // Call DWClient connect method
@@ -101,17 +112,19 @@ export class ConnectionManager {
       // This prevents race condition where stop() is called during connection
       if (this.stopped) {
         this.log?.warn?.(
-          `[${this.accountId}] Connection succeeded but manager was stopped during connect - disconnecting`
+          `[${this.accountId}] Connection succeeded but manager was stopped during connect - disconnecting`,
         );
         try {
           this.client.disconnect();
         } catch (disconnectErr: any) {
-          this.log?.debug?.(`[${this.accountId}] Error during post-connect disconnect: ${disconnectErr.message}`);
+          this.log?.debug?.(
+            `[${this.accountId}] Error during post-connect disconnect: ${disconnectErr.message}`,
+          );
         }
         return {
           success: false,
           attempt: this.attemptCount,
-          error: new Error('Connection manager stopped during connect'),
+          error: new Error("Connection manager stopped during connect"),
         };
       }
 
@@ -125,14 +138,16 @@ export class ConnectionManager {
 
       return { success: true, attempt: successfulAttempt };
     } catch (err: any) {
-      this.log?.error?.(`[${this.accountId}] Connection attempt ${this.attemptCount} failed: ${err.message}`);
+      this.log?.error?.(
+        `[${this.accountId}] Connection attempt ${this.attemptCount} failed: ${err.message}`,
+      );
 
       // Check if we've exceeded max attempts
       if (this.attemptCount >= this.config.maxAttempts) {
         this.state = ConnectionStateEnum.FAILED;
-        this.notifyStateChange('Max connection attempts reached');
+        this.notifyStateChange("Max connection attempts reached");
         this.log?.error?.(
-          `[${this.accountId}] Max connection attempts (${this.config.maxAttempts}) reached. Giving up.`
+          `[${this.accountId}] Max connection attempts (${this.config.maxAttempts}) reached. Giving up.`,
         );
         return { success: false, attempt: this.attemptCount, error: err };
       }
@@ -142,7 +157,7 @@ export class ConnectionManager {
       const nextDelay = this.calculateNextDelay(this.attemptCount - 1);
 
       this.log?.warn?.(
-        `[${this.accountId}] Will retry connection in ${(nextDelay / 1000).toFixed(2)}s (attempt ${this.attemptCount + 1}/${this.config.maxAttempts})`
+        `[${this.accountId}] Will retry connection in ${(nextDelay / 1000).toFixed(2)}s (attempt ${this.attemptCount + 1}/${this.config.maxAttempts})`,
       );
 
       return { success: false, attempt: this.attemptCount, error: err, nextDelay };
@@ -154,13 +169,15 @@ export class ConnectionManager {
    */
   public async connect(): Promise<void> {
     if (this.stopped) {
-      throw new Error('Cannot connect: connection manager is stopped');
+      throw new Error("Cannot connect: connection manager is stopped");
     }
 
     // Clear any existing reconnect timer
     this.clearReconnectTimer();
 
-    this.log?.info?.(`[${this.accountId}] Starting DingTalk Stream client with robust connection...`);
+    this.log?.info?.(
+      `[${this.accountId}] Starting DingTalk Stream client with robust connection...`,
+    );
 
     // Keep trying until success or max attempts reached
     while (!this.stopped && this.state !== ConnectionStateEnum.CONNECTED) {
@@ -173,9 +190,11 @@ export class ConnectionManager {
       }
 
       // Check if connection was stopped during connect
-      if (result.error?.message === 'Connection manager stopped during connect') {
-        this.log?.info?.(`[${this.accountId}] Connection cancelled: manager stopped during connect`);
-        throw new Error('Connection cancelled: connection manager stopped');
+      if (result.error?.message === "Connection manager stopped during connect") {
+        this.log?.info?.(
+          `[${this.accountId}] Connection cancelled: manager stopped during connect`,
+        );
+        throw new Error("Connection cancelled: connection manager stopped");
       }
 
       if (!result.nextDelay || this.attemptCount >= this.config.maxAttempts) {
@@ -213,7 +232,9 @@ export class ConnectionManager {
 
       // If we believe we're connected but DWClient disagrees, trigger reconnection
       if (this.state === ConnectionStateEnum.CONNECTED && !client.connected) {
-        this.log?.warn?.(`[${this.accountId}] Connection health check failed - detected disconnection`);
+        this.log?.warn?.(
+          `[${this.accountId}] Connection health check failed - detected disconnection`,
+        );
         if (this.healthCheckInterval) {
           clearInterval(this.healthCheckInterval);
         }
@@ -230,7 +251,9 @@ export class ConnectionManager {
 
       // Handler for socket close event
       this.socketCloseHandler = (code: number, reason: string) => {
-        this.log?.warn?.(`[${this.accountId}] WebSocket closed event (code: ${code}, reason: ${reason || 'none'})`);
+        this.log?.warn?.(
+          `[${this.accountId}] WebSocket closed event (code: ${code}, reason: ${reason || "none"})`,
+        );
 
         // Only trigger reconnection if we were previously connected and not stopping
         if (!this.stopped && this.state === ConnectionStateEnum.CONNECTED) {
@@ -243,14 +266,16 @@ export class ConnectionManager {
 
       // Handler for socket error event
       this.socketErrorHandler = (error: Error) => {
-        this.log?.error?.(`[${this.accountId}] WebSocket error event: ${error?.message || 'Unknown error'}`);
+        this.log?.error?.(
+          `[${this.accountId}] WebSocket error event: ${error?.message || "Unknown error"}`,
+        );
       };
 
       // Listen to socket events
       // Use 'once' for close to avoid duplicate reconnection triggers
-      socket.once('close', this.socketCloseHandler);
+      socket.once("close", this.socketCloseHandler);
       // Use 'once' for error as well to prevent accumulation across reconnects
-      socket.once('error', this.socketErrorHandler);
+      socket.once("error", this.socketErrorHandler);
     }
   }
 
@@ -270,11 +295,11 @@ export class ConnectionManager {
       const socket = this.monitoredSocket;
 
       if (this.socketCloseHandler) {
-        socket.removeListener('close', this.socketCloseHandler);
+        socket.removeListener("close", this.socketCloseHandler);
         this.socketCloseHandler = undefined;
       }
       if (this.socketErrorHandler) {
-        socket.removeListener('error', this.socketErrorHandler);
+        socket.removeListener("error", this.socketErrorHandler);
         this.socketErrorHandler = undefined;
       }
 
@@ -287,12 +312,16 @@ export class ConnectionManager {
    * Handle runtime disconnection and trigger reconnection
    */
   private handleRuntimeDisconnection(): void {
-    if (this.stopped) return;
+    if (this.stopped) {
+      return;
+    }
 
-    this.log?.warn?.(`[${this.accountId}] Runtime disconnection detected, initiating reconnection...`);
+    this.log?.warn?.(
+      `[${this.accountId}] Runtime disconnection detected, initiating reconnection...`,
+    );
 
     this.state = ConnectionStateEnum.DISCONNECTED;
-    this.notifyStateChange('Runtime disconnection detected');
+    this.notifyStateChange("Runtime disconnection detected");
     this.attemptCount = 0; // Reset attempt counter for runtime reconnection
 
     // Clear any existing timer
@@ -300,7 +329,9 @@ export class ConnectionManager {
 
     // Start reconnection with initial delay
     const delay = this.calculateNextDelay(0);
-    this.log?.info?.(`[${this.accountId}] Scheduling reconnection in ${(delay / 1000).toFixed(2)}s`);
+    this.log?.info?.(
+      `[${this.accountId}] Scheduling reconnection in ${(delay / 1000).toFixed(2)}s`,
+    );
 
     this.reconnectTimer = setTimeout(() => {
       this.reconnect().catch((err) => {
@@ -313,7 +344,9 @@ export class ConnectionManager {
    * Reconnect after runtime disconnection
    */
   private async reconnect(): Promise<void> {
-    if (this.stopped) return;
+    if (this.stopped) {
+      return;
+    }
 
     this.log?.info?.(`[${this.accountId}] Attempting to reconnect...`);
 
@@ -321,7 +354,9 @@ export class ConnectionManager {
       await this.connect();
       this.log?.info?.(`[${this.accountId}] Reconnection successful`);
     } catch (err: any) {
-      if (this.stopped) return;
+      if (this.stopped) {
+        return;
+      }
 
       this.log?.error?.(`[${this.accountId}] Reconnection failed: ${err.message}`);
       this.state = ConnectionStateEnum.FAILED;
@@ -332,7 +367,7 @@ export class ConnectionManager {
       this.attemptCount = 0;
       this.clearReconnectTimer();
       this.log?.warn?.(
-        `[${this.accountId}] Reconnection cycle failed; scheduling next reconnect in ${(delay / 1000).toFixed(2)}s`
+        `[${this.accountId}] Reconnection cycle failed; scheduling next reconnect in ${(delay / 1000).toFixed(2)}s`,
       );
       this.reconnectTimer = setTimeout(() => {
         void this.reconnect();
@@ -344,7 +379,9 @@ export class ConnectionManager {
    * Stop the connection manager and cleanup resources
    */
   public stop(): void {
-    if (this.stopped) return;
+    if (this.stopped) {
+      return;
+    }
 
     this.log?.info?.(`[${this.accountId}] Stopping connection manager...`);
 

package/src/dedup.ts

@@ -0,0 +1,66 @@
+// ============ Message Deduplication ============
+// Prevent duplicate processing when DingTalk retries delivery.
+// In-memory TTL map + lazy cleanup keeps overhead small.
+
+const processedMessages = new Map<string, number>();
+const MESSAGE_DEDUP_TTL = 60000;
+const MESSAGE_DEDUP_MAX_SIZE = 1000;
+let messageCounter = 0;
+
+// Check whether message is still inside dedup window.
+export function isMessageProcessed(dedupKey: string): boolean {
+  const now = Date.now();
+  const expiresAt = processedMessages.get(dedupKey);
+
+  if (expiresAt === undefined) {
+    return false;
+  }
+
+  if (now >= expiresAt) {
+    processedMessages.delete(dedupKey);
+    return false;
+  }
+
+  return true;
+}
+
+// Mark message as processed and lazily cleanup expired entries.
+export function markMessageProcessed(dedupKey: string): void {
+  const expiresAt = Date.now() + MESSAGE_DEDUP_TTL;
+  processedMessages.set(dedupKey, expiresAt);
+
+  // Hard cap for burst protection.
+  if (processedMessages.size > MESSAGE_DEDUP_MAX_SIZE) {
+    const now = Date.now();
+    for (const [key, expiry] of processedMessages.entries()) {
+      if (now >= expiry) {
+        processedMessages.delete(key);
+      }
+    }
+
+    // Safety valve: if still over cap after expired-entry sweep, drop oldest entries.
+    if (processedMessages.size > MESSAGE_DEDUP_MAX_SIZE) {
+      const removeCount = processedMessages.size - MESSAGE_DEDUP_MAX_SIZE;
+      let removed = 0;
+      for (const key of processedMessages.keys()) {
+        processedMessages.delete(key);
+        if (++removed >= removeCount) {
+          break;
+        }
+      }
+    }
+    return;
+  }
+
+  // Deterministic lightweight cleanup every 10 messages.
+  messageCounter++;
+  if (messageCounter >= 10) {
+    messageCounter = 0;
+    const now = Date.now();
+    for (const [key, expiry] of processedMessages.entries()) {
+      if (now >= expiry) {
+        processedMessages.delete(key);
+      }
+    }
+  }
+}

package/src/group-members-store.ts

@@ -0,0 +1,45 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+function groupMembersFilePath(storePath: string, groupId: string): string {
+  const dir = path.join(path.dirname(storePath), "dingtalk-members");
+  const safeId = groupId.replace(/\+/g, "-").replace(/\//g, "_");
+  return path.join(dir, `${safeId}.json`);
+}
+
+export function noteGroupMember(
+  storePath: string,
+  groupId: string,
+  userId: string,
+  name: string,
+): void {
+  if (!userId || !name) {
+    return;
+  }
+  const filePath = groupMembersFilePath(storePath, groupId);
+  let roster: Record<string, string> = {};
+  try {
+    roster = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  } catch {}
+  if (roster[userId] === name) {
+    return;
+  }
+  roster[userId] = name;
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(roster, null, 2));
+}
+
+export function formatGroupMembers(storePath: string, groupId: string): string | undefined {
+  const filePath = groupMembersFilePath(storePath, groupId);
+  let roster: Record<string, string> = {};
+  try {
+    roster = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  } catch {
+    return undefined;
+  }
+  const entries = Object.entries(roster);
+  if (entries.length === 0) {
+    return undefined;
+  }
+  return entries.map(([id, name]) => `${name} (${id})`).join(", ");
+}