@soimy/dingtalk 3.5.0 → 3.5.2

package/src/channel.ts

@@ -7,6 +7,7 @@ import { readStringParam } from "openclaw/plugin-sdk/param-readers";
 import { extractToolSend } from "openclaw/plugin-sdk/tool-send";
 import { getAccessToken } from "./auth";
 import { analyzeCardCallback } from "./card-callback-service";
+import { handleCardAction } from "./card/card-action-handler";
 import {
   createAICard,
   streamAICard,
@@ -32,7 +33,7 @@ import {
   recordExplicitFeedbackLearning,
 } from "./feedback-learning-service";
 import { handleDingTalkMessage } from "./inbound-handler";
-import { getLogger } from "./logger-context";
+import { getLogger, setCurrentLogger } from "./logger-context";
 import { prepareMediaInput, resolveOutboundMediaType } from "./media-utils";
 import { dingtalkSetupAdapter, dingtalkSetupWizard } from "./onboarding.js";
 import { resolveOriginalPeerId, preloadPeerIdsFromSessions } from "./peer-id-registry";
@@ -61,11 +62,13 @@ import type {
 } from "./types";
 import { ConnectionState } from "./types";
 import {
+  closePluginDebugLog,
   cleanupOrphanedTempFiles,
   createResolve4FallbackLookup,
   formatDingTalkConnectionErrorLog,
   formatDingTalkErrorPayloadLog,
   getCurrentTimestamp,
+  resolvePluginDebugLog,
 } from "./utils";
 
 type InstrumentedDWClient = {
@@ -459,14 +462,15 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
       const storePath = rt.channel.session.resolveStorePath(cfg.session?.store, {
         agentId: accountId,
       });
+      const effectiveLog = getLogger(accountId) || log;
       try {
         const result = await sendMessage(config, to, text, {
-          log,
+          log: effectiveLog,
           accountId,
           storePath,
           conversationId: to,
         });
-        getLogger()?.debug?.(`[DingTalk] sendText: "${text}" result: ${JSON.stringify(result)}`);
+        effectiveLog?.debug?.(`[DingTalk] sendText: "${text}" result: ${JSON.stringify(result)}`);
         if (!result.ok) {
           throw new Error(result.error || "sendText failed");
         }
@@ -486,7 +490,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
         };
       } catch (err: any) {
         if (err?.response?.data !== undefined) {
-          log?.error?.(formatDingTalkErrorPayloadLog("outbound.sendText", err.response.data));
+          effectiveLog?.error?.(formatDingTalkErrorPayloadLog("outbound.sendText", err.response.data));
         }
         throw new Error(
           typeof err?.response?.data === "string"
@@ -513,6 +517,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
       const storePath = rt.channel.session.resolveStorePath(cfg.session?.store, {
         agentId: accountId,
       });
+      const effectiveLog = getLogger(accountId) || log;
       if (!config.clientId) {
         throw new Error("DingTalk not configured");
       }
@@ -520,7 +525,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
       // Support mediaPath/filePath/mediaUrl aliases for better CLI compatibility.
       const rawMediaPath = mediaPath || filePath || mediaUrl;
 
-      getLogger()?.debug?.(
+      effectiveLog?.debug?.(
         `[DingTalk] sendMedia called: to=${to}, mediaPath=${mediaPath}, filePath=${filePath}, mediaUrl=${mediaUrl}, rawMediaPath=${rawMediaPath}`,
       );
 
@@ -538,10 +543,10 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
       let preparedMedia;
       try {
         try {
-          preparedMedia = await prepareMediaInput(rawMediaPath, log, config.mediaUrlAllowlist);
+          preparedMedia = await prepareMediaInput(rawMediaPath, effectiveLog, config.mediaUrlAllowlist);
         } catch (err: any) {
           if (err?.response?.data !== undefined) {
-            log?.error?.(
+            effectiveLog?.error?.(
               formatDingTalkErrorPayloadLog("outbound.sendMedia.prepare", err.response.data),
             );
           }
@@ -558,7 +563,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
           ? preparedMedia.path
           : resolveRelativePath(preparedMedia.path);
 
-        getLogger()?.debug?.(
+        effectiveLog?.debug?.(
           `[DingTalk] sendMedia resolved path: rawMediaPath=${rawMediaPath}, actualMediaPath=${actualMediaPath}`,
         );
 
@@ -570,7 +575,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
         let result;
         try {
           result = await sendProactiveMedia(config, to, actualMediaPath, mediaType, {
-            log,
+            log: effectiveLog,
             accountId,
             storePath,
             conversationId: to,
@@ -578,7 +583,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
           });
         } catch (err: any) {
           if (err?.response?.data !== undefined) {
-            log?.error?.(
+            effectiveLog?.error?.(
               formatDingTalkErrorPayloadLog("outbound.sendMedia.send", err.response.data),
             );
           }
@@ -586,7 +591,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
             cause: err,
           });
         }
-        getLogger()?.debug?.(
+        effectiveLog?.debug?.(
           `[DingTalk] sendMedia: ${mediaType} file=${actualMediaPath} result: ${JSON.stringify(result)}`,
         );
 
@@ -608,7 +613,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
         );
       } catch (err: any) {
         if (err?.response?.data !== undefined) {
-          log?.error?.(formatDingTalkErrorPayloadLog("outbound.sendMedia", err.response.data));
+          effectiveLog?.error?.(formatDingTalkErrorPayloadLog("outbound.sendMedia", err.response.data));
         }
         throw new Error(
           typeof err?.response?.data === "string"
@@ -638,29 +643,37 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
         accountStorePath = undefined;
       }
 
-      ctx.log?.info?.(`[${account.accountId}] Initializing DingTalk Stream client...`);
+      const pluginLog = resolvePluginDebugLog({
+        accountId: account.accountId,
+        storePath: accountStorePath,
+        debug: config.debug,
+        baseLog: ctx.log,
+      });
+      setCurrentLogger(pluginLog, account.accountId);
+
+      pluginLog?.info?.(`[${account.accountId}] Initializing DingTalk Stream client...`);
 
       // Preload known peer IDs from sessions so outbound delivery (e.g. cron
       // jobs that fire immediately after startup) can resolve the original
       // case-sensitive conversationId before any inbound message has arrived.
       preloadPeerIdsFromSessions();
-      ctx.log?.debug?.(`[${account.accountId}] Peer ID registry preloaded from sessions`);
+      pluginLog?.debug?.(`[${account.accountId}] Peer ID registry preloaded from sessions`);
 
-      cleanupOrphanedTempFiles(ctx.log);
+      cleanupOrphanedTempFiles(pluginLog);
       try {
         const recovered = await recoverPendingCardsForAccount(
           config,
           account.accountId,
           accountStorePath,
-          ctx.log,
+          pluginLog,
         );
         if (recovered > 0) {
-          ctx.log?.info?.(
+          pluginLog?.info?.(
             `[${account.accountId}] Recovered and finalized ${recovered} unfinished card(s) from previous runtime`,
           );
         }
       } catch (err: any) {
-        ctx.log?.warn?.(
+        pluginLog?.warn?.(
           `[${account.accountId}] Failed to recover unfinished cards: ${err.message}`,
         );
       }
@@ -682,7 +695,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
         });
         (c as any).sslopts = {
           ...(c as any).sslopts,
-          lookup: createResolve4FallbackLookup(ctx.log, account.accountId),
+          lookup: createResolve4FallbackLookup(pluginLog, account.accountId),
         };
 
         instrumentConnectionStages(c);
@@ -701,7 +714,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
               c.socketCallBackResponse(messageId, { success: true });
               stats.acked += 1;
             } catch (ackError: any) {
-              ctx.log?.warn?.(
+              pluginLog?.warn?.(
                 `[${account.accountId}] Failed to acknowledge callback ${messageId}: ${ackError.message}`,
               );
             }
@@ -722,38 +735,38 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
                 accountId: account.accountId,
                 data,
                 sessionWebhook: data.sessionWebhook,
-                log: ctx.log,
+                log: pluginLog,
                 dingtalkConfig: config,
               });
               stats.processed += 1;
               if (stats.received % INBOUND_COUNTER_LOG_EVERY === 0) {
-                logInboundCounters(ctx.log, account.accountId, "periodic");
+                logInboundCounters(pluginLog, account.accountId, "periodic");
               }
               return;
             }
 
             if (isMessageProcessed(dedupKey)) {
-              ctx.log?.debug?.(`[${account.accountId}] Skipping duplicate message: ${dedupKey}`);
+              pluginLog?.debug?.(`[${account.accountId}] Skipping duplicate message: ${dedupKey}`);
               stats.dedupSkipped += 1;
               acknowledge();
-              logInboundCounters(ctx.log, account.accountId, "dedup-skipped");
+              logInboundCounters(pluginLog, account.accountId, "dedup-skipped");
               return;
             }
 
             const inflightSince = processingDedupKeys.get(dedupKey);
             if (inflightSince !== undefined) {
               if (Date.now() - inflightSince > INFLIGHT_TTL_MS) {
-                ctx.log?.warn?.(
+                pluginLog?.warn?.(
                   `[${account.accountId}] Releasing stale in-flight lock for ${dedupKey} (held ${Date.now() - inflightSince}ms > TTL ${INFLIGHT_TTL_MS}ms)`,
                 );
                 processingDedupKeys.delete(dedupKey);
               } else {
-                ctx.log?.debug?.(
+                pluginLog?.debug?.(
                   `[${account.accountId}] Skipping in-flight duplicate message: ${dedupKey}`,
                 );
                 stats.inflightSkipped += 1;
                 acknowledge();
-                logInboundCounters(ctx.log, account.accountId, "inflight-skipped");
+                logInboundCounters(pluginLog, account.accountId, "inflight-skipped");
                 return;
               }
             }
@@ -766,21 +779,21 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
                 accountId: account.accountId,
                 data,
                 sessionWebhook: data.sessionWebhook,
-                log: ctx.log,
+                log: pluginLog,
                 dingtalkConfig: config,
               });
               stats.processed += 1;
               markMessageProcessed(dedupKey);
               if (stats.received % INBOUND_COUNTER_LOG_EVERY === 0) {
-                logInboundCounters(ctx.log, account.accountId, "periodic");
+                logInboundCounters(pluginLog, account.accountId, "periodic");
               }
             } finally {
               processingDedupKeys.delete(dedupKey);
             }
           } catch (error: any) {
             stats.failed += 1;
-            logInboundCounters(ctx.log, account.accountId, "failed");
-            ctx.log?.error?.(`[${account.accountId}] Error processing message: ${error.message}`);
+            logInboundCounters(pluginLog, account.accountId, "failed");
+            pluginLog?.error?.(`[${account.accountId}] Error processing message: ${error.message}`);
           }
         });
 
@@ -793,7 +806,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
             try {
               c.socketCallBackResponse(messageId, { success: true });
             } catch (ackError: any) {
-              ctx.log?.warn?.(
+              pluginLog?.warn?.(
                 `[${account.accountId}] Failed to acknowledge card callback ${messageId}: ${ackError.message}`,
               );
             }
@@ -802,7 +815,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
           try {
             const payload = JSON.parse(res.data);
             const analysis = analyzeCardCallback(payload);
-            ctx.log?.info?.(
+            pluginLog?.info?.(
               `[${account.accountId}] [DingTalk][CardCallback] action=${analysis.summary} raw=${JSON.stringify(payload)}`,
             );
 
@@ -825,20 +838,32 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
                   analysis.feedbackAckText,
                   {
                     accountId: account.accountId,
-                    log: ctx.log,
+                    log: pluginLog,
                   },
                 );
-                ctx.log?.info?.(
+                pluginLog?.info?.(
                   `[${account.accountId}] [DingTalk][CardCallback] feedback ack sent to ${analysis.feedbackTarget}`,
                 );
               } catch (sendErr: any) {
-                ctx.log?.warn?.(
+                pluginLog?.warn?.(
                   `[${account.accountId}] [DingTalk][CardCallback] Failed to send feedback ack: ${sendErr?.message || String(sendErr)}`,
                 );
               }
             }
+            const actionResult = await handleCardAction({
+              analysis,
+              cfg,
+              accountId: account.accountId,
+              config,
+              log: pluginLog,
+            });
+            if (!actionResult.handled && analysis.actionId && analysis.actionId !== "feedback_up" && analysis.actionId !== "feedback_down") {
+              pluginLog?.debug?.(
+                `[${account.accountId}] [DingTalk][CardCallback] Unhandled actionId=${analysis.actionId}`,
+              );
+            }
           } catch (error: any) {
-            ctx.log?.error?.(
+            pluginLog?.error?.(
               `[${account.accountId}] [DingTalk][CardCallback] Failed to parse callback: ${error.message}`,
             );
           } finally {
@@ -864,15 +889,15 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
           return;
         }
         stopped = true;
-        ctx.log?.info?.(`[${account.accountId}] Stopping DingTalk Stream client...`);
+        pluginLog?.info?.(`[${account.accountId}] Stopping DingTalk Stream client...`);
         void finalizeActiveCardsForAccount(
           config,
           account.accountId,
           "⚠️ 服务正在重启，当前回复已中断。请重新发送你的问题。",
           accountStorePath,
-          ctx.log,
+          pluginLog,
         ).catch((err: any) => {
-          ctx.log?.debug?.(
+          pluginLog?.debug?.(
             `[${account.accountId}] Failed to finalize active cards during stop: ${err.message}`,
           );
         });
@@ -882,7 +907,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
           try {
             client.disconnect();
           } catch (err: any) {
-            ctx.log?.warn?.(`[${account.accountId}] Error during disconnect: ${err.message}`);
+            pluginLog?.warn?.(`[${account.accountId}] Error during disconnect: ${err.message}`);
           }
           nativeStopResolve?.();
         }
@@ -893,12 +918,16 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
           lastStopAt: getCurrentTimestamp(),
         });
 
-        ctx.log?.info?.(`[${account.accountId}] DingTalk Stream client stopped`);
+        pluginLog?.info?.(`[${account.accountId}] DingTalk Stream client stopped`);
+        closePluginDebugLog({
+          accountId: account.accountId,
+          storePath: accountStorePath,
+        });
       };
 
       if (abortSignal) {
         if (abortSignal.aborted) {
-          ctx.log?.warn?.(
+          pluginLog?.warn?.(
             `[${account.accountId}] Abort signal already active, skipping connection`,
           );
 
@@ -916,7 +945,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
           if (stopped) {
             return;
           }
-          ctx.log?.info?.(
+          pluginLog?.info?.(
             `[${account.accountId}] Abort signal received, stopping DingTalk Stream client...`,
           );
           stopClient();
@@ -933,11 +962,11 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
               lastStartAt: getCurrentTimestamp(),
               lastError: null,
             });
-            ctx.log?.info?.(`[${account.accountId}] DingTalk Stream client connected successfully`);
+            pluginLog?.info?.(`[${account.accountId}] DingTalk Stream client connected successfully`);
             await nativeStopPromise;
           }
         } catch (err: any) {
-          ctx.log?.error?.(
+          pluginLog?.error?.(
             formatDingTalkConnectionErrorLog(
               // Use connect.open as base scope; instrumentation can override to connect.websocket
               "connect.open",
@@ -971,7 +1000,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
           if (stopped) {
             return;
           }
-          ctx.log?.debug?.(
+          pluginLog?.debug?.(
             `[${account.accountId}] Connection state changed to: ${state}${error ? ` (${error})` : ""}`,
           );
           if (state === ConnectionState.CONNECTED) {
@@ -994,7 +1023,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
               }
             }
             if (cleared > 0) {
-              ctx.log?.info?.(
+              pluginLog?.info?.(
                 `[${account.accountId}] Cleared ${cleared} stale in-flight lock(s) on disconnect`,
               );
             }
@@ -1007,7 +1036,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
         },
       };
 
-      ctx.log?.debug?.(
+      pluginLog?.debug?.(
         `[${account.accountId}] Connection config: maxAttempts=${connectionConfig.maxAttempts}, ` +
           `initialDelay=${connectionConfig.initialDelay}ms, maxDelay=${connectionConfig.maxDelay}ms, ` +
           `jitter=${connectionConfig.jitter}`,
@@ -1017,7 +1046,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
         client,
         account.accountId,
         connectionConfig,
-        ctx.log,
+        pluginLog,
         createStreamClient,
       );
 
@@ -1031,17 +1060,17 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
             lastStartAt: getCurrentTimestamp(),
             lastError: null,
           });
-          ctx.log?.info?.(`[${account.accountId}] DingTalk Stream client connected successfully`);
+          pluginLog?.info?.(`[${account.accountId}] DingTalk Stream client connected successfully`);
 
           await connectionManager.waitForStop();
         } else {
-          ctx.log?.info?.(
+          pluginLog?.info?.(
             `[${account.accountId}] DingTalk Stream client connect() completed but channel is ` +
               `not running (stopped=${stopped}, connected=${connectionManager.isConnected()})`,
           );
         }
       } catch (err: any) {
-        ctx.log?.error?.(
+        pluginLog?.error?.(
           formatDingTalkConnectionErrorLog(
             // Use connect.open as base scope; instrumentation can override to connect.websocket
             "connect.open",

package/src/command/card-stop-command.ts

@@ -0,0 +1,78 @@
+import { resolveNativeCommandSessionTargets } from "openclaw/plugin-sdk/command-auth";
+import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
+import { getDingTalkRuntime } from "../runtime";
+import type { Logger } from "../types";
+
+/**
+ * Dispatch a native targeted `/stop` command through the OpenClaw SDK,
+ * replacing the previous self-built Gateway WebSocket `chat.abort` approach.
+ *
+ * Uses the same `resolveNativeCommandSessionTargets` + `CommandSource: "native"`
+ * model as Telegram / Discord / Slack slash commands, producing:
+ *   - A dedicated command SessionKey (`agent:<agentId>:dingtalk:card-stop:<userId>`)
+ *   - A CommandTargetSessionKey pointing at the real conversation session
+ *
+ * Inside the SDK, `dispatch-from-config` → `tryFastAbortFromMessage` picks up
+ * the `/stop` body, resolves the target session via `CommandTargetSessionKey`,
+ * and executes `abortEmbeddedPiRun` + `clearSessionQueues`.
+ *
+ * Accesses SDK functions via `getDingTalkRuntime().channel.reply` — the same
+ * pattern used by `inbound-handler.ts` — while reusing the upstream native
+ * command session-target helper exported by the plugin SDK.
+ */
+export async function dispatchDingTalkCardStopCommand(params: {
+  cfg: OpenClawConfig;
+  accountId: string;
+  agentId: string;
+  targetSessionKey: string;
+  clickerUserId: string;
+  log?: Logger;
+}): Promise<{ ok: boolean }> {
+  const rt = getDingTalkRuntime();
+
+  const { sessionKey: commandSessionKey, commandTargetSessionKey } =
+    resolveNativeCommandSessionTargets({
+      agentId: params.agentId,
+      sessionPrefix: "dingtalk:card-stop",
+      userId: params.clickerUserId,
+      targetSessionKey: params.targetSessionKey,
+    });
+
+  const ctx = rt.channel.reply.finalizeInboundContext({
+    Body: "/stop",
+    RawBody: "/stop",
+    CommandBody: "/stop",
+    SessionKey: commandSessionKey,
+    CommandTargetSessionKey: commandTargetSessionKey,
+    CommandSource: "native" as const,
+    CommandAuthorized: true,
+    AccountId: params.accountId,
+    Provider: "dingtalk",
+    Surface: "dingtalk",
+    // "direct" because the synthetic /stop body contains no @mentions to strip.
+    // The actual chat type of the target session is irrelevant for abort routing.
+    ChatType: "direct",
+    From: `dingtalk:card-stop:${params.clickerUserId}`,
+    To: `card-stop:${params.clickerUserId}`,
+    SenderId: params.clickerUserId,
+    OriginatingChannel: "dingtalk",
+  });
+
+  // DispatchInboundResult = { queuedFinal, counts } — the return value does
+  // not expose whether tryFastAbortFromMessage took the fast-abort path.
+  // Treat successful dispatch as best-effort abort, consistent with the
+  // previous gateway chat.abort approach.
+  await rt.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+    ctx,
+    cfg: params.cfg,
+    dispatcherOptions: {
+      responsePrefix: "",
+      deliver: async () => {
+        // SDK abort confirmation text is swallowed here; the card
+        // finalize path handles stopped content independently.
+      },
+    },
+  });
+
+  return { ok: true };
+}