@soimy/dingtalk 3.2.0 → 3.4.0

package/src/messaging/quoted-context.ts

@@ -0,0 +1,269 @@
+import type { MessageRecord } from "../message-context-store";
+import type { Logger, QuotedRef } from "../types";
+import { resolveQuotedRecord } from "./quoted-ref";
+
+const DEFAULT_MAX_DEPTH = 3;
+const DEFAULT_PER_HOP_BODY_LIMIT = 1200;
+const DEFAULT_TOTAL_BODY_LIMIT = 3600;
+
+export interface QuotedChainEntry {
+  depth: number;
+  direction: MessageRecord["direction"];
+  messageType: string;
+  sender?: string;
+  body: string;
+  createdAt: number;
+}
+
+export interface ResolvedQuotedRuntimeContext {
+  replyToId?: string;
+  replyToBody: string;
+  replyToSender?: string;
+  replyToIsQuote: true;
+  chain: QuotedChainEntry[];
+  untrustedContext?: string;
+}
+
+export interface QuotedRuntimePreview {
+  text?: string;
+  messageType?: string;
+  senderId?: string;
+}
+
+function normalizePositiveInteger(value: number | undefined, fallback: number): number {
+  return typeof value === "number" && Number.isFinite(value) && value > 0
+    ? Math.floor(value)
+    : fallback;
+}
+
+function trimmedString(value: string | undefined): string | undefined {
+  if (typeof value !== "string") {
+    return undefined;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+
+function deriveReplyToId(record: MessageRecord): string | undefined {
+  if (record.direction === "inbound") {
+    return trimmedString(record.msgId);
+  }
+  return (
+    trimmedString(record.delivery?.processQueryKey) ||
+    trimmedString(record.delivery?.messageId) ||
+    trimmedString(record.delivery?.outTrackId) ||
+    trimmedString(record.delivery?.cardInstanceId) ||
+    trimmedString(record.msgId)
+  );
+}
+
+function deriveSender(record: MessageRecord): string | undefined {
+  return record.direction === "outbound" ? "assistant" : undefined;
+}
+
+function deriveMessageType(record: MessageRecord): string {
+  return trimmedString(record.messageType) || "unknown";
+}
+
+function buildBodyPlaceholder(record: MessageRecord): string {
+  const messageType = trimmedString(record.messageType) || "message";
+  return `[Quoted ${messageType}]`;
+}
+
+function buildPreviewPlaceholder(preview: QuotedRuntimePreview | undefined): string {
+  const messageType = trimmedString(preview?.messageType) || "message";
+  return `[Quoted ${messageType}]`;
+}
+
+function resolveRecordBody(record: MessageRecord): string {
+  return (
+    trimmedString(record.attachmentText) ||
+    trimmedString(record.text) ||
+    buildBodyPlaceholder(record)
+  );
+}
+
+function resolvePreviewBody(preview: QuotedRuntimePreview | undefined): string | undefined {
+  return trimmedString(preview?.text) || (preview ? buildPreviewPlaceholder(preview) : undefined);
+}
+
+function deriveReplyToIdFromQuotedRef(quotedRef: QuotedRef | undefined): string | undefined {
+  if (!quotedRef?.key || !quotedRef.value) {
+    return undefined;
+  }
+  return trimmedString(quotedRef.value);
+}
+
+function derivePreviewSender(quotedRef?: QuotedRef): string | undefined {
+  if (quotedRef?.targetDirection === "outbound") {
+    return "assistant";
+  }
+  return undefined;
+}
+
+function truncateBody(value: string, limit: number): string {
+  if (limit <= 0) {
+    return "";
+  }
+  return value.length <= limit ? value : value.slice(0, limit);
+}
+
+function fingerprintQuotedRef(quotedRef: QuotedRef | undefined): string | undefined {
+  if (!quotedRef) {
+    return undefined;
+  }
+  const direction = quotedRef.targetDirection;
+  const key = quotedRef.key || "";
+  const value = quotedRef.value || "";
+  const fallbackCreatedAt =
+    typeof quotedRef.fallbackCreatedAt === "number" && Number.isFinite(quotedRef.fallbackCreatedAt)
+      ? String(quotedRef.fallbackCreatedAt)
+      : "";
+  if (!direction) {
+    return undefined;
+  }
+  return JSON.stringify([direction, key, value, fallbackCreatedAt]);
+}
+
+function buildChainEntry(params: {
+  record: MessageRecord;
+  depth: number;
+  remainingBodyBudget: number;
+  perHopBodyLimit: number;
+}): QuotedChainEntry | null {
+  const limit = Math.min(params.perHopBodyLimit, params.remainingBodyBudget);
+  if (limit <= 0) {
+    return null;
+  }
+  const body = truncateBody(resolveRecordBody(params.record), limit);
+  return {
+    depth: params.depth,
+    direction: params.record.direction,
+    messageType: deriveMessageType(params.record),
+    sender: deriveSender(params.record),
+    body,
+    createdAt: params.record.createdAt,
+  };
+}
+
+export function resolveQuotedRuntimeContext(params: {
+  storePath?: string;
+  accountId: string;
+  conversationId: string | null;
+  quotedRef?: QuotedRef;
+  firstRecord?: MessageRecord | null;
+  firstPreview?: QuotedRuntimePreview;
+  log?: Logger;
+  maxDepth?: number;
+  perHopBodyLimit?: number;
+  totalBodyLimit?: number;
+}): ResolvedQuotedRuntimeContext | null {
+  if (!params.quotedRef) {
+    return null;
+  }
+
+  const maxDepth = normalizePositiveInteger(params.maxDepth, DEFAULT_MAX_DEPTH);
+  const perHopBodyLimit = normalizePositiveInteger(
+    params.perHopBodyLimit,
+    DEFAULT_PER_HOP_BODY_LIMIT,
+  );
+  const totalBodyLimit = normalizePositiveInteger(params.totalBodyLimit, DEFAULT_TOTAL_BODY_LIMIT);
+
+  const chain: QuotedChainEntry[] = [];
+  const seenRecordIds = new Set<string>();
+  const seenQuotedRefFingerprints = new Set<string>();
+  let firstResolvedRecord: MessageRecord | null = null;
+  let remainingBodyBudget = totalBodyLimit;
+  let currentQuotedRef: QuotedRef | undefined = params.quotedRef;
+  let currentRecord = params.firstRecord ?? null;
+
+  for (let depth = 1; depth <= maxDepth && currentQuotedRef; depth += 1) {
+    if (depth > 1 || !currentRecord) {
+      currentRecord = resolveQuotedRecord({
+        storePath: params.storePath,
+        accountId: params.accountId,
+        conversationId: params.conversationId,
+        quotedRef: currentQuotedRef,
+        log: params.log,
+      });
+    }
+    if (!currentRecord) {
+      break;
+    }
+    if (!firstResolvedRecord) {
+      firstResolvedRecord = currentRecord;
+    }
+
+    const recordId = `${currentRecord.direction}:${currentRecord.msgId}`;
+    if (seenRecordIds.has(recordId)) {
+      break;
+    }
+    seenRecordIds.add(recordId);
+
+    const currentFingerprint = fingerprintQuotedRef(currentQuotedRef);
+    if (currentFingerprint) {
+      if (seenQuotedRefFingerprints.has(currentFingerprint)) {
+        break;
+      }
+      seenQuotedRefFingerprints.add(currentFingerprint);
+    }
+
+    const entry = buildChainEntry({
+      record: currentRecord,
+      depth,
+      remainingBodyBudget,
+      perHopBodyLimit,
+    });
+    if (!entry) {
+      break;
+    }
+    chain.push(entry);
+    remainingBodyBudget -= entry.body.length;
+
+    const nextQuotedRef = currentRecord.quotedRef;
+    if (!nextQuotedRef) {
+      break;
+    }
+
+    const nextFingerprint = fingerprintQuotedRef(nextQuotedRef);
+    if (nextFingerprint && seenQuotedRefFingerprints.has(nextFingerprint)) {
+      break;
+    }
+
+    currentQuotedRef = nextQuotedRef;
+    currentRecord = null;
+  }
+
+  const replyToRecord = firstResolvedRecord ?? params.firstRecord ?? null;
+  const stableReplyToId = replyToRecord ? deriveReplyToId(replyToRecord) : undefined;
+  if (replyToRecord && stableReplyToId) {
+    return {
+      replyToId: stableReplyToId,
+      replyToBody: chain[0].body,
+      replyToSender: chain[0].sender,
+      replyToIsQuote: true,
+      chain,
+      untrustedContext:
+        chain.length > 1
+          ? JSON.stringify({
+              quotedChain: chain.slice(1),
+            })
+          : undefined,
+    };
+  }
+
+  const previewBody = resolvePreviewBody(params.firstPreview);
+  const previewReplyToId = deriveReplyToIdFromQuotedRef(params.quotedRef);
+  if (!previewBody) {
+    return null;
+  }
+
+  return {
+    replyToId: previewReplyToId,
+    replyToBody: truncateBody(previewBody, perHopBodyLimit),
+    replyToSender: derivePreviewSender(params.quotedRef),
+    replyToIsQuote: true,
+    chain: [],
+    untrustedContext: undefined,
+  };
+}

package/src/messaging/quoted-ref.ts

@@ -0,0 +1,97 @@
+import {
+  resolveByQuotedRef,
+  type MessageRecord,
+} from "../message-context-store";
+import type { DingTalkInboundMessage, Logger, MessageContent, QuotedRef } from "../types";
+
+function firstTrimmedString(...candidates: Array<string | undefined>): string | undefined {
+  for (const candidate of candidates) {
+    if (typeof candidate === "string" && candidate.trim()) {
+      return candidate.trim();
+    }
+  }
+  return undefined;
+}
+
+function firstFiniteNumber(...candidates: Array<number | undefined>): number | undefined {
+  for (const candidate of candidates) {
+    if (typeof candidate === "number" && Number.isFinite(candidate)) {
+      return candidate;
+    }
+  }
+  return undefined;
+}
+
+export function buildInboundQuotedRef(
+  data: DingTalkInboundMessage,
+  content: MessageContent,
+): QuotedRef | undefined {
+  const repliedMsg = data.text?.repliedMsg;
+  const repliedMsgId = firstTrimmedString(repliedMsg?.msgId, data.originalMsgId, content.quoted?.msgId);
+  const fallbackCreatedAt = firstFiniteNumber(
+    repliedMsg?.createdAt,
+    content.quoted?.cardCreatedAt,
+    content.quoted?.fileCreatedAt,
+  );
+  const isOutboundQuoted =
+    firstTrimmedString(data.originalProcessQueryKey) !== undefined ||
+    repliedMsg?.senderId === data.chatbotUserId ||
+    content.quoted?.isQuotedCard === true;
+  if (isOutboundQuoted) {
+    const processQueryKey = firstTrimmedString(data.originalProcessQueryKey, content.quoted?.processQueryKey);
+    if (processQueryKey) {
+      return {
+        targetDirection: "outbound",
+        key: "processQueryKey",
+        value: processQueryKey,
+        fallbackCreatedAt,
+      };
+    }
+    if (!fallbackCreatedAt) {
+      return undefined;
+    }
+    return {
+      targetDirection: "outbound",
+      fallbackCreatedAt,
+    };
+  }
+  if (!repliedMsgId) {
+    return undefined;
+  }
+  return {
+    targetDirection: "inbound",
+    key: "msgId",
+    value: repliedMsgId,
+  };
+}
+
+export function createReplyQuotedRef(msgId: string | undefined): QuotedRef | undefined {
+  const value = firstTrimmedString(msgId);
+  if (!value) {
+    return undefined;
+  }
+  return {
+    targetDirection: "inbound",
+    key: "msgId",
+    value,
+  };
+}
+
+export function resolveQuotedRecord(params: {
+  storePath?: string;
+  accountId: string;
+  conversationId: string | null;
+  quotedRef?: QuotedRef;
+  log?: Logger;
+}): MessageRecord | null {
+  if (!params.quotedRef) {
+    return null;
+  }
+  return resolveByQuotedRef({
+    storePath: params.storePath,
+    accountId: params.accountId,
+    conversationId: params.conversationId,
+    quotedRef: params.quotedRef,
+    log: params.log,
+  });
+}

package/src/onboarding.ts

@@ -1,5 +1,6 @@
 import type { OpenClawConfig, ChannelOnboardingAdapter, WizardPrompter } from "openclaw/plugin-sdk";
 import { DEFAULT_ACCOUNT_ID, normalizeAccountId, formatDocsLink } from "openclaw/plugin-sdk";
+import { DEFAULT_MESSAGE_CONTEXT_TTL_DAYS } from "./message-context-store.js";
 import type { DingTalkConfig, DingTalkChannelConfig } from "./types.js";
 import { listDingTalkAccountIds, resolveDingTalkAccount } from "./types.js";
 
@@ -103,6 +104,10 @@ function applyAccountConfig(params: {
     ...(input.dmPolicy ? { dmPolicy: input.dmPolicy } : {}),
     ...(input.groupPolicy ? { groupPolicy: input.groupPolicy } : {}),
     ...(input.allowFrom && input.allowFrom.length > 0 ? { allowFrom: input.allowFrom } : {}),
+    ...(input.groupAllowFrom && input.groupAllowFrom.length > 0 ? { groupAllowFrom: input.groupAllowFrom } : {}),
+    ...(input.displayNameResolution
+      ? { displayNameResolution: input.displayNameResolution }
+      : {}),
     ...(input.messageType ? { messageType: input.messageType } : {}),
     ...(input.cardTemplateId ? { cardTemplateId: input.cardTemplateId } : {}),
     ...(input.cardTemplateKey ? { cardTemplateKey: input.cardTemplateKey } : {}),
@@ -113,6 +118,7 @@ function applyAccountConfig(params: {
       ? { useConnectionManager: input.useConnectionManager }
       : {}),
     ...(typeof input.mediaMaxMb === "number" ? { mediaMaxMb: input.mediaMaxMb } : {}),
+    ...(typeof input.journalTTLDays === "number" ? { journalTTLDays: input.journalTTLDays } : {}),
   };
 
   if (useDefault) {
@@ -315,10 +321,61 @@ export const dingtalkOnboardingAdapter: ChannelOnboardingAdapter = {
       options: [
         { label: "Open - any group can use bot", value: "open" },
         { label: "Allowlist - only allowed groups", value: "allowlist" },
+        { label: "Disabled - block all group messages", value: "disabled" },
       ],
       initialValue: resolved.groupPolicy ?? "open",
     });
 
+    if (groupPolicyValue === "allowlist") {
+      await prompter.note(
+        [
+          'groupPolicy=allowlist requires "groups" config to specify allowed group IDs.',
+          "After setup, manually add group conversationIds to your config:",
+          "",
+          '  "groups": { "cidXXX": {}, "cidYYY": { "systemPrompt": "..." } }',
+          "",
+          "Groups not listed will be blocked. Use \"*\" as key to allow all groups.",
+        ].join("\n"),
+      );
+    }
+
+    let groupAllowFrom: string[] | undefined;
+    if (groupPolicyValue !== "disabled") {
+      const groupAllowFromEntry = await prompter.text({
+        message: "Group sender allowlist - user IDs allowed in groups (comma-separated, optional)",
+        placeholder: "user1, user2",
+        initialValue: (resolved.groupAllowFrom || []).join(", ") || undefined,
+      });
+      const parsedGroupAllowFrom = parseList(String(groupAllowFromEntry ?? ""));
+      groupAllowFrom = parsedGroupAllowFrom.length > 0 ? parsedGroupAllowFrom : undefined;
+    }
+
+    await prompter.note(
+      [
+        "Enabling learned displayName target resolution has tradeoffs:",
+        "- learned names come from observed inbound messages and can become stale",
+        "- duplicate display names can resolve to the wrong group or user",
+        "- current upstream target resolution does not provide requester authz, so \"all\" applies to every caller that can reach the send flow",
+        "Use explicit IDs for sensitive or high-risk deliveries.",
+      ].join("\n"),
+      "displayName resolution risk",
+    );
+
+    const displayNameResolutionValue = await prompter.select({
+      message: "Learned displayName target resolution",
+      options: [
+        {
+          label: "Disabled - require explicit IDs",
+          value: "disabled",
+        },
+        {
+          label: "All - learned lookup for all callers (higher risk)",
+          value: "all",
+        },
+      ],
+      initialValue: resolved.displayNameResolution ?? "disabled",
+    });
+
     let maxReconnectCycles: number | undefined;
     const wantsReconnectLimits = await prompter.confirm({
       message: "Configure runtime reconnect cycle limit? (recommended)",
@@ -378,6 +435,41 @@ export const dingtalkOnboardingAdapter: ChannelOnboardingAdapter = {
       mediaMaxMb = Number.isInteger(parsedMediaMax) && parsedMediaMax > 0 ? parsedMediaMax : 20;
     }
 
+    let journalTTLDays: number | undefined;
+    const wantsJournalTTL = await prompter.confirm({
+      message: "Configure quote journal retention in days?",
+      initialValue: typeof resolved.journalTTLDays === "number",
+    });
+    if (wantsJournalTTL) {
+      const parsedJournalTTL = Number(
+        String(
+          await prompter.text({
+            message: "Quote journal retention days",
+            placeholder: String(DEFAULT_MESSAGE_CONTEXT_TTL_DAYS),
+            initialValue:
+              typeof resolved.journalTTLDays === "number"
+                ? String(resolved.journalTTLDays)
+                : String(DEFAULT_MESSAGE_CONTEXT_TTL_DAYS),
+            validate: (value) => {
+              const raw = String(value ?? "").trim();
+              const num = Number(raw);
+              if (!raw) {
+                return "Required";
+              }
+              if (!Number.isInteger(num) || num < 1) {
+                return "Must be an integer >= 1";
+              }
+              return undefined;
+            },
+          }),
+        ).trim(),
+      );
+      journalTTLDays =
+        Number.isInteger(parsedJournalTTL) && parsedJournalTTL > 0
+          ? parsedJournalTTL
+          : DEFAULT_MESSAGE_CONTEXT_TTL_DAYS;
+    }
+
     const next = applyAccountConfig({
       cfg,
       accountId,
@@ -388,14 +480,17 @@ export const dingtalkOnboardingAdapter: ChannelOnboardingAdapter = {
         corpId,
         agentId,
         dmPolicy: dmPolicyValue as "open" | "allowlist",
-        groupPolicy: groupPolicyValue as "open" | "allowlist",
+        groupPolicy: groupPolicyValue as "open" | "allowlist" | "disabled",
         allowFrom,
+        groupAllowFrom,
+        displayNameResolution: displayNameResolutionValue as "disabled" | "all",
         mediaUrlAllowlist,
         messageType,
         cardTemplateId,
         cardTemplateKey,
         maxReconnectCycles,
         mediaMaxMb,
+        journalTTLDays,
       },
     });
 

package/src/peer-id-registry.ts

@@ -8,7 +8,13 @@
  * can be delivered correctly.
  */
 
+import { readFileSync, readdirSync } from "fs";
+import * as os from "os";
+import { join } from "path";
+import { getLogger } from "./logger-context";
+
 const peerIdMap = new Map<string, string>();
+let preloaded = false;
 
 /**
  * Register an original peer ID, keyed by its lowercased form.
@@ -20,14 +26,31 @@ export function registerPeerId(originalId: string): void {
   peerIdMap.set(originalId.toLowerCase(), originalId);
 }
 
+function maybeRegisterDingTalkGroupPeerId(value: unknown): void {
+  // DingTalk group openConversationId values are base64-like and consistently start with "cid".
+  // User IDs in DM contexts do not follow this pattern and do not require case restoration.
+  if (typeof value === "string" && value.startsWith("cid")) {
+    registerPeerId(value);
+  }
+}
+
 /**
  * Resolve a possibly-lowercased peer ID back to its original casing.
+ *
+ * If registry is empty at first outbound call (for example, cron/delivery queue
+ * fires before inbound callbacks), perform a one-time lazy preload from sessions.
+ *
  * Returns the original if found, otherwise returns the input as-is.
  */
 export function resolveOriginalPeerId(id: string): string {
   if (!id) {
     return id;
   }
+
+  if (!preloaded) {
+    preloadPeerIdsFromSessions();
+  }
+
   return peerIdMap.get(id.toLowerCase()) || id;
 }
 
@@ -36,4 +59,83 @@ export function resolveOriginalPeerId(id: string): string {
  */
 export function clearPeerIdRegistry(): void {
   peerIdMap.clear();
+  preloaded = false;
+}
+
+/**
+ * Preload known peer IDs from all agents' sessions.json files.
+ *
+ * Safe to call repeatedly:
+ * - without explicit homeDir: runs once, then no-ops;
+ * - with explicit homeDir: always runs (useful for tests).
+ */
+export function preloadPeerIdsFromSessions(homeDir?: string): void {
+  if (!homeDir && preloaded) {
+    return;
+  }
+
+  const home = homeDir || os.homedir();
+  const agentsDir = join(home, ".openclaw", "agents");
+  const log = getLogger();
+  let preloadCompleted = false;
+
+  try {
+    const agentDirs = readdirSync(agentsDir, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => entry.name);
+
+    for (const agentName of agentDirs) {
+      const sessionsPath = join(agentsDir, agentName, "sessions", "sessions.json");
+
+      try {
+        const raw = readFileSync(sessionsPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object") {
+          continue;
+        }
+
+        for (const session of Object.values(parsed as Record<string, unknown>)) {
+          if (!session || typeof session !== "object") {
+            continue;
+          }
+
+          const sessionRecord = session as Record<string, unknown>;
+          maybeRegisterDingTalkGroupPeerId(sessionRecord.lastTo);
+
+          const origin = sessionRecord.origin;
+          if (!origin || typeof origin !== "object") {
+            continue;
+          }
+
+          const originRecord = origin as Record<string, unknown>;
+          maybeRegisterDingTalkGroupPeerId(originRecord.from);
+          maybeRegisterDingTalkGroupPeerId(originRecord.to);
+        }
+      } catch (err) {
+        // sessions.json may be missing or malformed for some agents; ignore per file.
+        log?.debug?.(
+          `[DingTalk][PeerIdRegistry] Failed to parse preload sessions file ${sessionsPath}: ${
+            err instanceof Error ? err.message : String(err)
+          }`,
+        );
+      }
+    }
+    preloadCompleted = true;
+  } catch (err) {
+    const errorCode = (err as NodeJS.ErrnoException | undefined)?.code;
+    if (errorCode === "ENOENT") {
+      // agents directory may not exist yet; this is a stable no-op state.
+      preloadCompleted = true;
+    } else {
+      log?.debug?.(
+        `[DingTalk][PeerIdRegistry] Failed to scan preload directory ${agentsDir}: ${
+          err instanceof Error ? err.message : String(err)
+        }`,
+      );
+    }
+  }
+
+  if (!homeDir && preloadCompleted) {
+    preloaded = true;
+  }
 }