@soimy/dingtalk 3.2.0 → 3.4.0

package/src/config-schema.ts

@@ -1,6 +1,13 @@
 import { z } from "zod";
+import { DEFAULT_MESSAGE_CONTEXT_TTL_DAYS } from "./message-context-store";
 
-const DingTalkAccountConfigSchema = z.object({
+const AckReactionSchema = z.union([
+  z.literal(""),
+  z.enum(["off", "emoji", "kaomoji"]),
+  z.string().min(1),
+]);
+
+const DingTalkAccountConfigShape = {
   /** Account name (optional display name) */
   name: z.string().optional(),
 
@@ -25,17 +32,24 @@ const DingTalkAccountConfigSchema = z.object({
   /** Direct message policy: open, pairing, or allowlist */
   dmPolicy: z.enum(["open", "pairing", "allowlist"]).optional().default("open"),
 
-  /** Group message policy: open or allowlist */
-  groupPolicy: z.enum(["open", "allowlist"]).optional().default("open"),
+  /** Group message policy: open, allowlist, or disabled */
+  groupPolicy: z.enum(["open", "allowlist", "disabled"]).optional().default("open"),
 
   /** List of allowed user IDs for allowlist policy */
   allowFrom: z.array(z.string()).optional(),
 
+  /** List of allowed user IDs for group allowlist policy */
+  groupAllowFrom: z.array(z.string()).optional(),
+
+  /** Default disabled. Enabling "all" allows learned displayName lookup but may misroute on stale/duplicate names and is available to all callers until upstream exposes requester authz context. */
+  displayNameResolution: z.enum(["disabled", "all"]).optional().default("disabled"),
+
   mediaUrlAllowlist: z.array(z.string()).optional(),
 
-  /** Show thinking indicator while processing */
-  showThinking: z.boolean().optional().default(true),
+  /** Native ack reaction mode: off, emoji, or kaomoji */
+  ackReaction: AckReactionSchema.optional(),
 
+  journalTTLDays: z.number().int().min(1).optional().default(DEFAULT_MESSAGE_CONTEXT_TTL_DAYS),
   /** Enable debug logging */
   debug: z.boolean().optional().default(false),
 
@@ -60,6 +74,8 @@ const DingTalkAccountConfigSchema = z.object({
       z.string(),
       z.object({
         systemPrompt: z.string().optional(),
+        requireMention: z.boolean().optional(),
+        groupAllowFrom: z.array(z.string()).optional(),
       }),
     )
     .optional(),
@@ -81,12 +97,19 @@ const DingTalkAccountConfigSchema = z.object({
   /** Maximum number of runtime reconnect cycles before giving up (default: 10) */
   maxReconnectCycles: z.number().int().min(1).optional().default(10),
 
+  /** Maximum time (ms) for a single reconnect cycle before starting a new cycle (default: 50000) */
+  reconnectDeadlineMs: z.number().int().min(5000).optional().default(50000),
+
   /** Whether to use ConnectionManager (default: true). When false, rely on DWClient native keepAlive+autoReconnect. */
   useConnectionManager: z.boolean().optional().default(true),
 
   /** Maximum inbound media file size in MB (overrides runtime default when set) */
   mediaMaxMb: z.number().int().min(1).optional(),
 
+  /** Whether to enable underlying stream keepAlive heartbeat; defaults to !useConnectionManager when omitted */
+  keepAlive: z.boolean().optional(),
+  /** Bypass system/global HTTP(S) proxy for DingTalk outbound send/card/upload APIs */
+  bypassProxyForSend: z.boolean().optional().default(false),
   proactivePermissionHint: z
     .object({
       enabled: z.boolean().optional().default(true),
@@ -94,7 +117,42 @@ const DingTalkAccountConfigSchema = z.object({
     })
     .optional()
     .default({ enabled: true, cooldownHours: 24 }),
-});
+
+  /** Enable real-time card streaming (default: false).
+   *  When true, card updates are streamed per-token with 300ms throttle for a smoother experience, at the cost of more API calls. */
+  cardRealTimeStream: z.boolean().optional().default(false),
+
+  /** AICard degrade duration in milliseconds after trigger errors (default: 30 minutes) */
+  aicardDegradeMs: z.number().int().min(60_000).optional().default(30 * 60 * 1000),
+
+  /** Enable local learning loop (default: false) */
+  learningEnabled: z.boolean().optional(),
+
+  /** Auto-apply generated reflections into session notes/global rules (default: false) */
+  learningAutoApply: z.boolean().optional(),
+
+  /** Session learning note TTL in milliseconds (default: 6 hours) */
+  learningNoteTtlMs: z.number().int().min(60_000).optional(),
+
+  /** @deprecated Use learningEnabled */
+  feedbackLearningEnabled: z.boolean().optional(),
+
+  /** @deprecated Use learningAutoApply */
+  feedbackLearningAutoApply: z.boolean().optional(),
+
+  /** @deprecated Use learningNoteTtlMs */
+  feedbackLearningNoteTtlMs: z.number().int().min(60_000).optional(),
+
+  /** Whether to convert markdown tables to plain text for better rendering on some clients (default: true) */
+  convertMarkdownTables: z.boolean().optional().default(true),
+
+  /** @mention the sender after card finalization in group chats.
+   *  Set to a non-empty string (e.g. "✅ 回复完成") to enable — the value is used as the message text.
+   *  Leave empty or omit to disable. */
+  cardAtSender: z.string().optional(),
+} as const;
+
+const DingTalkAccountConfigSchema = z.object(DingTalkAccountConfigShape);
 
 /**
  * DingTalk configuration schema using Zod

package/src/config.ts

@@ -3,8 +3,61 @@ import * as path from "node:path";
 import type { OpenClawConfig } from "openclaw/plugin-sdk";
 import type { DingTalkConfig } from "./types";
 
+const WINDOWS_ROOT_DIRECTORIES = new Set([
+  "Users",
+  "Program Files",
+  "Program Files (x86)",
+  "ProgramData",
+  "Windows",
+  "Documents and Settings",
+]);
+const DEFAULT_LEARNING_NOTE_TTL_MS = 6 * 60 * 60 * 1000;
+
+function normalizeLearningConfig(
+  config: DingTalkConfig,
+  options: { applyDefaults: boolean },
+): DingTalkConfig {
+  const learningEnabled = config.learningEnabled ?? config.feedbackLearningEnabled;
+  const learningAutoApply = config.learningAutoApply ?? config.feedbackLearningAutoApply;
+  const learningNoteTtlMs = config.learningNoteTtlMs ?? config.feedbackLearningNoteTtlMs;
+  return {
+    ...config,
+    learningEnabled: options.applyDefaults ? learningEnabled ?? false : learningEnabled,
+    learningAutoApply: options.applyDefaults ? learningAutoApply ?? false : learningAutoApply,
+    learningNoteTtlMs: options.applyDefaults
+      ? learningNoteTtlMs ?? DEFAULT_LEARNING_NOTE_TTL_MS
+      : learningNoteTtlMs,
+  };
+}
+
+/**
+ * Merge channel-level defaults into an account-specific config.
+ * Account-level values take precedence; `accounts` key is excluded to avoid recursion.
+ */
+export function mergeAccountWithDefaults(
+  channelCfg: DingTalkConfig,
+  accountCfg: DingTalkConfig,
+): DingTalkConfig {
+  const { accounts: _accounts, ...defaults } = channelCfg;
+  const normalizedAccountCfg = normalizeLearningConfig(accountCfg, { applyDefaults: false });
+  const overrides: Partial<DingTalkConfig> = {};
+  for (const [key, value] of Object.entries(normalizedAccountCfg)) {
+    if (value !== undefined) {
+      Object.assign(overrides, { [key]: value });
+    }
+  }
+  return normalizeLearningConfig(
+    {
+      ...defaults,
+      ...overrides,
+    },
+    { applyDefaults: true },
+  );
+}
+
 /**
  * Resolve DingTalk config for an account.
+ * Named accounts inherit channel-level defaults with account-level overrides.
  * Falls back to top-level config for single-account setups.
  */
 export function getConfig(cfg: OpenClawConfig, accountId?: string): DingTalkConfig {
@@ -14,10 +67,18 @@ export function getConfig(cfg: OpenClawConfig, accountId?: string): DingTalkConf
   }
 
   if (accountId && dingtalkCfg.accounts?.[accountId]) {
-    return dingtalkCfg.accounts[accountId];
+    return mergeAccountWithDefaults(dingtalkCfg, dingtalkCfg.accounts[accountId]);
+  }
+
+  if (accountId) {
+    return normalizeLearningConfig(dingtalkCfg, { applyDefaults: true });
   }
 
-  return dingtalkCfg;
+  if (dingtalkCfg.accounts && Object.keys(dingtalkCfg.accounts).length > 0) {
+    return dingtalkCfg;
+  }
+
+  return normalizeLearningConfig(dingtalkCfg, { applyDefaults: true });
 }
 
 export function isConfigured(cfg: OpenClawConfig, accountId?: string): boolean {
@@ -25,6 +86,19 @@ export function isConfigured(cfg: OpenClawConfig, accountId?: string): boolean {
   return Boolean(config.clientId && config.clientSecret);
 }
 
+/**
+ * Resolve relative paths against a base directory, with intelligent platform-specific handling.
+ *
+ * Supports:
+ * - ~ and ~/ expansion to home directory
+ * - Absolute paths (Unix: /path, Windows: \path or C:\path)
+ * - Relative paths resolved against cwd
+ * - Windows absolute paths without drive letters (e.g., Users\name\.openclaw\file.txt)
+ * - Mixed path separators (/ and \)
+ *
+ * @param input - The path string to resolve
+ * @returns The resolved absolute path
+ */
 export function resolveRelativePath(input: string): string {
   const trimmed = input.trim();
   if (!trimmed) {
@@ -32,6 +106,8 @@ export function resolveRelativePath(input: string): string {
   }
 
   const segments = (value: string): string[] => value.split(/[\\/]+/).filter(Boolean);
+  const pathSegments = segments(trimmed);
+  const firstSegment = pathSegments[0];
 
   // Expand bare "~" and "~/" or "~\\" prefixes into the user home directory.
   if (trimmed === "~") {
@@ -41,13 +117,27 @@ export function resolveRelativePath(input: string): string {
     return path.resolve(os.homedir(), ...segments(trimmed.slice(2)));
   }
 
+  if (process.platform === "win32") {
+    // On Windows, OpenClaw may drop the leading "\" from root-based paths like
+    // "Users\name\.openclaw\workspace\file.xlsx". Only recover paths that start
+    // with well-known root directories to avoid misclassifying ordinary relative paths.
+    if (/^[a-zA-Z]:[\\/]/.test(trimmed)) {
+      return path.win32.normalize(trimmed);
+    }
+    if (firstSegment && /^[a-zA-Z]:$/.test(firstSegment)) {
+      return path.win32.resolve(`${firstSegment}\\`, ...pathSegments.slice(1));
+    }
+    if (firstSegment && WINDOWS_ROOT_DIRECTORIES.has(firstSegment)) {
+      return path.win32.resolve("\\", ...pathSegments);
+    }
+  }
   // Treat both "/" and "\\" as absolute root prefixes for cross-platform input.
   if (/^[\\/]/.test(trimmed)) {
-    return path.resolve(path.sep, ...segments(trimmed));
+    return path.resolve(path.sep, ...pathSegments);
   }
 
   // Resolve relative path against cwd; supports mixed separators and "..\\..".
-  return path.resolve(process.cwd(), ...segments(trimmed));
+  return path.resolve(process.cwd(), ...pathSegments);
 }
 
 export const resolveUserPath = resolveRelativePath;
@@ -55,7 +145,7 @@ export const resolveUserPath = resolveRelativePath;
 export function resolveGroupConfig(
   cfg: DingTalkConfig,
   groupId: string,
-): { systemPrompt?: string } | undefined {
+): { systemPrompt?: string; requireMention?: boolean; groupAllowFrom?: string[] } | undefined {
   // Group config supports exact match first, then wildcard fallback.
   const groups = cfg.groups;
   if (!groups) {
@@ -64,6 +154,72 @@ export function resolveGroupConfig(
   return groups[groupId] || groups["*"] || undefined;
 }
 
+function hasOwn(obj: unknown, key: string): boolean {
+  return typeof obj === "object" && obj !== null && Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+function resolveAgentIdentityEmoji(cfg: OpenClawConfig, agentId?: string | null): string | undefined {
+  const targetAgentId = String(agentId || "").trim();
+  if (!targetAgentId) {
+    return undefined;
+  }
+  const agents = Array.isArray((cfg as any)?.agents?.list) ? (cfg as any).agents.list : [];
+  const agent = agents.find((entry: any) => String(entry?.id || "").trim() === targetAgentId);
+  const emoji = typeof agent?.identity?.emoji === "string" ? agent.identity.emoji.trim() : "";
+  return emoji || undefined;
+}
+
+function normalizeAckReactionValue(value: unknown): string | undefined {
+  if (typeof value !== "string") {
+    return undefined;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return "";
+  }
+  const normalized = trimmed.toLowerCase();
+  if (normalized === "off") {
+    return "off";
+  }
+  if (normalized === "emoji") {
+    return "emoji";
+  }
+  if (normalized === "kaomoji") {
+    return "kaomoji";
+  }
+  if (trimmed === "🤔思考中") {
+    return "emoji";
+  }
+  return trimmed;
+}
+
+export function resolveAckReactionSetting(params: {
+  cfg: OpenClawConfig;
+  accountId?: string | null;
+  agentId?: string | null;
+}): string | undefined {
+  const dingtalk = (params.cfg?.channels as any)?.dingtalk;
+  const accountId = String(params.accountId || "").trim();
+  const accountConfig =
+    accountId && dingtalk?.accounts && typeof dingtalk.accounts === "object"
+      ? dingtalk.accounts[accountId]
+      : undefined;
+
+  if (hasOwn(accountConfig, "ackReaction")) {
+    return normalizeAckReactionValue(accountConfig.ackReaction);
+  }
+  if (hasOwn(dingtalk, "ackReaction")) {
+    return normalizeAckReactionValue(dingtalk.ackReaction);
+  }
+
+  const messages = (params.cfg as any)?.messages;
+  if (hasOwn(messages, "ackReaction")) {
+    return normalizeAckReactionValue(messages.ackReaction);
+  }
+
+  return resolveAgentIdentityEmoji(params.cfg, params.agentId) || "👀";
+}
+
 /**
  * Strip group/user prefixes used by CLI targeting.
  * Returns raw DingTalk target ID and whether caller explicitly requested a user target.