@soimy/dingtalk 3.5.0 → 3.5.2

package/src/send-service.ts

@@ -1,5 +1,5 @@
 import * as path from "node:path";
-import axios from "axios";
+import axios from "./http-client";
 import { getAccessToken } from "./auth";
 import {
   isCardInTerminalState,
@@ -37,6 +37,53 @@ import type {
 
 export { detectMediaTypeFromExtension } from "./media-utils";
 
+const MARKDOWN_LOCAL_IMAGE_RE =
+  /!\[([^\]]*)\]\((file:\/\/\/[^)]+|\/(?:tmp|var|private|Users|home|root)[^)]+|[A-Za-z]:[\\/][^)]+)\)/g;
+
+function decodeMarkdownLocalImagePath(rawPath: string): string {
+  const unescapedPath = rawPath.replace(/\\ /g, " ");
+  if (unescapedPath.startsWith("file://")) {
+    try {
+      return decodeURIComponent(unescapedPath.replace("file://", ""));
+    } catch {
+      return unescapedPath.replace("file://", "");
+    }
+  }
+  return unescapedPath;
+}
+
+async function replaceMarkdownLocalImages(params: {
+  config: DingTalkConfig;
+  text: string;
+  log?: Logger;
+  mediaLocalRoots?: string[];
+}): Promise<string> {
+  const matches = [...params.text.matchAll(MARKDOWN_LOCAL_IMAGE_RE)];
+  if (matches.length === 0) {
+    return params.text;
+  }
+
+  let result = params.text;
+  for (const match of matches) {
+    const [fullMatch, altText, rawPath] = match;
+    const mediaPath = decodeMarkdownLocalImagePath(rawPath);
+    const uploadResult = await uploadMedia(params.config, mediaPath, "image", params.log, {
+      mediaLocalRoots: params.mediaLocalRoots,
+    });
+
+    if (!uploadResult?.mediaId) {
+      params.log?.warn?.(
+        `[DingTalk] Markdown local image upload failed, keep original reference: ${mediaPath}`,
+      );
+      continue;
+    }
+
+    result = result.replace(fullMatch, () => `![${altText}](${uploadResult.mediaId})`);
+  }
+
+  return result;
+}
+
 type ProactiveTextSendResult = AxiosResponse | { tracking: DingTalkTrackingMetadata };
 
 function isTrackingResult(result: ProactiveTextSendResult): result is { tracking: DingTalkTrackingMetadata } {
@@ -225,7 +272,7 @@ export async function sendProactiveTextOrMarkdown(
 
   // In card mode, use card API to avoid oToMessages/batchSend permission requirement.
   const messageType = config.messageType || "markdown";
-  if (messageType === "card" && config.cardTemplateId && !options.forceMarkdown) {
+  if (messageType === "card" && !options.forceMarkdown) {
     log?.debug?.(
       `[DingTalk] Using card API for proactive message to user ${resolvedTarget}${proactiveRiskTag}`,
     );
@@ -252,7 +299,16 @@ export async function sendProactiveTextOrMarkdown(
     ? "https://api.dingtalk.com/v1.0/robot/groupMessages/send"
     : "https://api.dingtalk.com/v1.0/robot/oToMessages/batchSend";
 
-  const normalizedText = config.convertMarkdownTables !== false ? convertMarkdownTablesToPlainText(text) : text;
+  const textWithUploadedLocalImages = await replaceMarkdownLocalImages({
+    config,
+    text,
+    log,
+    mediaLocalRoots: options.mediaLocalRoots,
+  });
+  const normalizedText =
+    config.convertMarkdownTables !== false
+      ? convertMarkdownTablesToPlainText(textWithUploadedLocalImages)
+      : textWithUploadedLocalImages;
   const { useMarkdown, title } = detectMarkdownAndExtractTitle(normalizedText, options, "OpenClaw 提醒");
 
   log?.debug?.(
@@ -531,7 +587,16 @@ export async function sendBySession(
   }
 
   // Fallback to text/markdown reply payload.
-  const normalizedText = config.convertMarkdownTables !== false ? convertMarkdownTablesToPlainText(text) : text;
+  const textWithUploadedLocalImages = await replaceMarkdownLocalImages({
+    config,
+    text,
+    log,
+    mediaLocalRoots: options.mediaLocalRoots,
+  });
+  const normalizedText =
+    config.convertMarkdownTables !== false
+      ? convertMarkdownTablesToPlainText(textWithUploadedLocalImages)
+      : textWithUploadedLocalImages;
   const { useMarkdown, title } = detectMarkdownAndExtractTitle(normalizedText, options, "Clawdbot 消息");
   const chunks = splitMarkdownChunks(normalizedText, DINGTALK_TEXT_CHUNK_LIMIT);
 
@@ -582,20 +647,18 @@ export async function sendMessage(
           return { ok: true };
         }
 
-        if (config.cardTemplateId) {
-          const proactiveResult = await sendProactiveCardText(config, conversationId, text, log);
-          if (!proactiveResult.ok) {
-            return { ok: false, error: proactiveResult.error || "Card send failed" };
-          }
-          return {
-            ok: true,
-            tracking: {
-              processQueryKey: proactiveResult.processQueryKey,
-              outTrackId: proactiveResult.outTrackId,
-              cardInstanceId: proactiveResult.cardInstanceId,
-            },
-          };
+        const proactiveResult = await sendProactiveCardText(config, conversationId, text, log);
+        if (!proactiveResult.ok) {
+          return { ok: false, error: proactiveResult.error || "Card send failed" };
         }
+        return {
+          ok: true,
+          tracking: {
+            processQueryKey: proactiveResult.processQueryKey,
+            outTrackId: proactiveResult.outTrackId,
+            cardInstanceId: proactiveResult.cardInstanceId,
+          },
+        };
       }
     }
 

package/src/targeting/agent-routing.ts

@@ -8,6 +8,7 @@
  */
 
 import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
+import { maybeResolveTextAlias } from "openclaw/plugin-sdk/command-auth";
 import { resolveAtAgents } from "./agent-name-matcher";
 import { resolveRobotCode } from "../config";
 import { parseLearnCommand } from "../learning-command-service";
@@ -93,16 +94,22 @@ export async function resolveSubAgentRoute(params: {
   const atMentions = extractedContent.atMentions || [];
   // DM has no @picker list from DingTalk; only group chats provide atUsers for real-user hints.
   const atUserDingtalkIds = isGroup ? extractedContent.atUserDingtalkIds : undefined;
-  // Strip quoted prefix before checking /learn to avoid false positives
-  // when the quoted message itself contains a /learn command.
+  // Strip quoted prefix before checking commands to avoid false positives
+  // when the quoted message itself contains a command.
   const textForCommandCheck = extractedContent.text.replace(/^\[引用[^\]]*\]\s*/, "");
   const isLearnCommand = parseLearnCommand(textForCommandCheck).scope !== "unknown";
+  // Slash commands like /new, /stop, /reasoning etc. must bypass sub-agent
+  // routing so they reach the framework's own command handling layer.
+  // Strip leading @mention tokens first since DM text may look like "@Agent /new".
+  const textWithoutMentions = textForCommandCheck.replace(/^(?:@\S+\s+)*/u, "").trim();
+  const isSlashCommand = maybeResolveTextAlias(textWithoutMentions, cfg) !== null;
 
   if (
     atMentions.length === 0 ||
     !cfg.agents?.list ||
     cfg.agents.list.length === 0 ||
-    isLearnCommand
+    isLearnCommand ||
+    isSlashCommand
   ) {
     return null;
   }
@@ -173,7 +180,7 @@ export async function dispatchSubAgents(params: {
         dingtalkConfig,
         subAgentOptions: {
           agentId: agentMatch.agentId,
-          responsePrefix: `[${sanitizeAgentName(agentMatch.matchedName)}] `,
+          responsePrefix: `> 🤖 **${sanitizeAgentName(agentMatch.matchedName)}**:\n\n`,
           matchedName: agentMatch.matchedName,
         },
         preDownloadedMedia,

package/src/{group-members-store.ts → targeting/group-members-store.ts}

@@ -1,6 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { readNamespaceJson, writeNamespaceJsonAtomic } from "./persistence-store";
+import { readNamespaceJson, writeNamespaceJsonAtomic } from "../persistence-store";
 
 const GROUP_MEMBERS_NAMESPACE = "members.group-roster";
 

package/src/types.ts

@@ -44,7 +44,9 @@ export interface DingTalkConfig extends OpenClawConfig {
   ackReaction?: AckReactionConfigValue;
   debug?: boolean;
   messageType?: "markdown" | "card";
+  /** @deprecated 已固定使用内置模板契约 */
   cardTemplateId?: string;
+  /** @deprecated 已固定使用内置模板契约 */
   cardTemplateKey?: string;
   groups?: Record<string, { systemPrompt?: string; requireMention?: boolean; groupAllowFrom?: string[] }>;
   accounts?: Record<string, DingTalkConfig>;
@@ -103,7 +105,9 @@ export interface DingTalkChannelConfig {
   ackReaction?: AckReactionConfigValue;
   debug?: boolean;
   messageType?: "markdown" | "card";
+  /** @deprecated 已固定使用内置模板契约 */
   cardTemplateId?: string;
+  /** @deprecated 已固定使用内置模板契约 */
   cardTemplateKey?: string;
   groups?: Record<string, { systemPrompt?: string; requireMention?: boolean; groupAllowFrom?: string[] }>;
   accounts?: Record<string, DingTalkConfig>;
@@ -618,6 +622,7 @@ export const AICardStatus = {
   PROCESSING: "1",
   INPUTING: "2",
   FINISHED: "3",
+  STOPPED: "4",
   FAILED: "5",
 } as const;
 
@@ -639,7 +644,7 @@ export interface AICardInstance {
   storePath?: string;
   createdAt: number;
   lastUpdated: number;
-  state: AICardState; // Current card state: PROCESSING, INPUTING, FINISHED, FAILED
+  state: AICardState; // Current card state: PROCESSING, INPUTING, FINISHED, STOPPED, FAILED
   config?: DingTalkConfig; // Store config reference for token refresh
   lastStreamedContent?: string;
   outTrackId?: string;

package/src/utils.ts

@@ -5,6 +5,171 @@ import * as os from "node:os";
 import * as path from "node:path";
 import type { Logger, RetryOptions } from "./types";
 
+type PluginDebugLogParams = {
+  accountId: string;
+  storePath?: string;
+  debug?: boolean;
+  baseLog?: Logger;
+  now?: () => Date;
+  fsImpl?: Pick<typeof fs, "appendFileSync" | "mkdirSync">;
+};
+
+type PluginDebugWriter = {
+  filePath: string;
+  warned: boolean;
+  directoryReady: boolean;
+};
+
+const pluginDebugWriters = new Map<string, PluginDebugWriter>();
+const closedPluginDebugScopes = new Set<string>();
+
+function padNumber(value: number, width = 2): string {
+  return String(value).padStart(width, "0");
+}
+
+function formatTimezoneOffset(date: Date): string {
+  const offsetMinutes = -date.getTimezoneOffset();
+  const sign = offsetMinutes >= 0 ? "+" : "-";
+  const absoluteMinutes = Math.abs(offsetMinutes);
+  const hours = Math.floor(absoluteMinutes / 60);
+  const minutes = absoluteMinutes % 60;
+  return `${sign}${padNumber(hours)}:${padNumber(minutes)}`;
+}
+
+function formatPluginDebugTimestamp(date: Date): string {
+  return `${date.getFullYear()}-${padNumber(date.getMonth() + 1)}-${padNumber(date.getDate())} ${padNumber(date.getHours())}:${padNumber(date.getMinutes())}:${padNumber(date.getSeconds())}.${padNumber(date.getMilliseconds(), 3)}${formatTimezoneOffset(date)}`;
+}
+
+function formatPluginDebugDate(date: Date): string {
+  return `${date.getFullYear()}-${padNumber(date.getMonth() + 1)}-${padNumber(date.getDate())}`;
+}
+
+function resolvePluginDebugLogFilePath(params: { storePath: string; accountId: string; date: Date }): string {
+  return path.join(
+    path.dirname(params.storePath),
+    "logs",
+    "dingtalk",
+    params.accountId,
+    `debug-${formatPluginDebugDate(params.date)}.log`,
+  );
+}
+
+function formatPluginDebugLine(params: { accountId: string; date: Date; message: string }): string {
+  return `[${formatPluginDebugTimestamp(params.date)}] [debug] [dingtalk] [account:${params.accountId}] ${params.message}`;
+}
+
+function buildPluginDebugWriterKey(params: { storePath: string; accountId: string; date: Date }): string {
+  return JSON.stringify([params.storePath, params.accountId, formatPluginDebugDate(params.date)]);
+}
+
+function buildPluginDebugScopeKey(params: { storePath: string; accountId: string }): string {
+  return JSON.stringify([params.storePath, params.accountId]);
+}
+
+function resolvePluginDebugWriter(params: {
+  storePath: string;
+  accountId: string;
+  date: Date;
+}): PluginDebugWriter {
+  const key = buildPluginDebugWriterKey(params);
+  const existing = pluginDebugWriters.get(key);
+  if (existing) {
+    return existing;
+  }
+
+  const created = {
+    filePath: resolvePluginDebugLogFilePath(params),
+    warned: false,
+    directoryReady: false,
+  };
+  pluginDebugWriters.set(key, created);
+  return created;
+}
+
+export function resolvePluginDebugLog(params: PluginDebugLogParams): Logger {
+  const baseLog = params.baseLog;
+  const fsImpl = params.fsImpl ?? fs;
+  const scopeKey = params.storePath
+    ? buildPluginDebugScopeKey({ storePath: params.storePath, accountId: params.accountId })
+    : undefined;
+
+  if (scopeKey) {
+    closedPluginDebugScopes.delete(scopeKey);
+  }
+
+  return {
+    debug: (message: string) => {
+      if (!params.debug) {
+        baseLog?.debug?.(message);
+        return;
+      }
+
+      const date = params.now ? params.now() : new Date();
+      const line = formatPluginDebugLine({
+        accountId: params.accountId,
+        date,
+        message,
+      });
+
+      try {
+        process.stdout.write(`${line}\n`);
+      } catch {
+        // Ignore stdout failures so plugin debug logging never breaks message handling.
+      }
+
+      if (params.storePath && scopeKey && !closedPluginDebugScopes.has(scopeKey)) {
+        const writer = resolvePluginDebugWriter({
+          storePath: params.storePath,
+          accountId: params.accountId,
+          date,
+        });
+        try {
+          if (!writer.directoryReady) {
+            fsImpl.mkdirSync(path.dirname(writer.filePath), { recursive: true });
+            writer.directoryReady = true;
+          }
+          fsImpl.appendFileSync(writer.filePath, `${line}\n`, "utf8");
+        } catch (err) {
+          if (!writer.warned) {
+            writer.warned = true;
+            baseLog?.warn?.(
+              `[DingTalk] Plugin debug log file unavailable: accountId=${params.accountId} path=${writer.filePath} error=${getErrorMessage(err)}`,
+            );
+          }
+        }
+      }
+
+      try {
+        baseLog?.debug?.(message);
+      } catch {
+        // Ignore upstream debug failures so plugin-owned debug remains best-effort.
+      }
+    },
+    info: (message: string) => baseLog?.info?.(message),
+    warn: (message: string) => baseLog?.warn?.(message),
+    error: (message: string) => baseLog?.error?.(message),
+  };
+}
+
+export function closePluginDebugLog(params: { accountId: string; storePath?: string }): void {
+  if (!params.storePath) {
+    return;
+  }
+
+  const scopeKey = buildPluginDebugScopeKey({
+    storePath: params.storePath,
+    accountId: params.accountId,
+  });
+  closedPluginDebugScopes.add(scopeKey);
+
+  for (const key of pluginDebugWriters.keys()) {
+    const [writerStorePath, writerAccountId] = JSON.parse(key) as [string, string, string];
+    if (writerStorePath === params.storePath && writerAccountId === params.accountId) {
+      pluginDebugWriters.delete(key);
+    }
+  }
+}
+
 /**
  * Mask sensitive fields in data for safe logging
  * Prevents PII leakage in debug logs