@soimy/dingtalk 3.3.0 → 3.4.1

package/src/targeting/target-directory-adapter.ts

@@ -0,0 +1,152 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
+import type { ChannelDirectoryEntry } from "openclaw/plugin-sdk/directory-runtime";
+import { getConfig, stripTargetPrefix } from "../config";
+import { resolveOriginalPeerId } from "../peer-id-registry";
+import { getDingTalkRuntime } from "../runtime";
+import { listKnownGroupTargets, listKnownUserTargets } from "./target-directory-store";
+
+export type DirectoryListParams = {
+  cfg: OpenClawConfig;
+  accountId?: string | null;
+  query?: string | null;
+  limit?: number | null;
+  runtime?: unknown;
+};
+
+type RuntimeSessionResolver = {
+  resolveStorePath?: (store: unknown, options: { agentId?: string | null | undefined }) => string;
+};
+
+function normalizeDirectoryAccountId(accountId?: string | null): string {
+  const resolved = String(accountId || "default").trim();
+  return resolved || "default";
+}
+
+function normalizeDirectoryLimit(limit?: number | null): number | undefined {
+  if (typeof limit !== "number" || !Number.isFinite(limit) || limit <= 0) {
+    return undefined;
+  }
+  return Math.floor(limit);
+}
+
+function resolveDirectoryStorePath(params: {
+  cfg: OpenClawConfig;
+  accountId?: string | null;
+  runtime?: unknown;
+}): string | undefined {
+  const normalizedAccountId = normalizeDirectoryAccountId(params.accountId);
+  const runtimeSession = (
+    params.runtime as { channel?: { session?: RuntimeSessionResolver } } | undefined
+  )?.channel?.session;
+  if (runtimeSession?.resolveStorePath) {
+    return runtimeSession.resolveStorePath(params.cfg.session?.store, {
+      agentId: normalizedAccountId,
+    });
+  }
+  try {
+    const rt = getDingTalkRuntime();
+    return rt.channel.session.resolveStorePath(params.cfg.session?.store, {
+      agentId: normalizedAccountId,
+    });
+  } catch {
+    return undefined;
+  }
+}
+
+function shouldFilterDirectoryByQuery(params: DirectoryListParams): boolean {
+  // OpenClaw target-resolver currently uses a query-insensitive cache key and
+  // always calls directory list APIs with limit=undefined. If we filter by
+  // query at this layer during resolver calls, one miss can poison cache for
+  // later different queries. Keep resolver reads query-agnostic.
+  return params.limit !== undefined;
+}
+
+function isDisplayNameResolutionEnabled(params: {
+  cfg: OpenClawConfig;
+  accountId?: string | null;
+}): boolean {
+  const mode = getConfig(params.cfg, params.accountId ?? undefined).displayNameResolution;
+  // Current upstream target resolution does not pass requester owner/authz context into
+  // plugin targetResolver/directory callbacks, so owner-only resolution is not yet safe.
+  // Keep the config explicit: only "all" enables learned displayName resolution for now.
+  // TODO(upstream target-resolver): add a true owner-only mode once requester authorization
+  // is plumbed into plugin resolver and directory entry points.
+  return mode === "all";
+}
+
+export function listDingTalkDirectoryGroups(params: DirectoryListParams): ChannelDirectoryEntry[] {
+  if (!isDisplayNameResolutionEnabled(params)) {
+    return [];
+  }
+  const accountId = normalizeDirectoryAccountId(params.accountId);
+  const storePath = resolveDirectoryStorePath(params);
+  const filterByQuery = shouldFilterDirectoryByQuery(params);
+  const groups = listKnownGroupTargets({
+    storePath,
+    accountId,
+    query: filterByQuery ? (params.query ?? undefined) : undefined,
+    limit: filterByQuery ? normalizeDirectoryLimit(params.limit) : undefined,
+  });
+  const groupEntries: ChannelDirectoryEntry[] = groups.map((entry) => ({
+    kind: "group" as const,
+    id: resolveOriginalPeerId(entry.conversationId),
+    name: entry.currentTitle,
+    handle: entry.conversationId,
+    rank: entry.lastSeenAt,
+    raw: entry,
+  }));
+
+  if (filterByQuery) {
+    return groupEntries;
+  }
+
+  // TODO(upstream target-resolver): remove this fallback once bare user labels
+  // can be classified and routed to listPeers() instead of only listGroups().
+  // Temporary hack for the current upstream target-resolver flow: bare names
+  // are classified as "group" before directory lookup, so user displayName
+  // targets never reach listPeers(). Merge users into the resolver-only group
+  // lookup set so "displayName -> targetId" can still resolve for DingTalk.
+  const users = listKnownUserTargets({
+    storePath,
+    accountId,
+  });
+  const userEntries: ChannelDirectoryEntry[] = users.map((entry) => ({
+    kind: "user" as const,
+    id: entry.canonicalUserId,
+    name: entry.currentDisplayName,
+    handle: entry.staffId || entry.senderId,
+    rank: entry.lastSeenAt,
+    raw: entry,
+  }));
+
+  return [...groupEntries, ...userEntries].toSorted(
+    (left, right) => (right.rank || 0) - (left.rank || 0),
+  );
+}
+
+export function listDingTalkDirectoryUsers(params: DirectoryListParams): ChannelDirectoryEntry[] {
+  if (!isDisplayNameResolutionEnabled(params)) {
+    return [];
+  }
+  const accountId = normalizeDirectoryAccountId(params.accountId);
+  const storePath = resolveDirectoryStorePath(params);
+  const filterByQuery = shouldFilterDirectoryByQuery(params);
+  const users = listKnownUserTargets({
+    storePath,
+    accountId,
+    query: filterByQuery ? (params.query ?? undefined) : undefined,
+    limit: filterByQuery ? normalizeDirectoryLimit(params.limit) : undefined,
+  });
+  return users.map((entry) => ({
+    kind: "user",
+    id: entry.canonicalUserId,
+    name: entry.currentDisplayName,
+    handle: entry.staffId || entry.senderId,
+    rank: entry.lastSeenAt,
+    raw: entry,
+  }));
+}
+
+export function normalizeResolvedDingTalkTarget(raw: string): string {
+  return resolveOriginalPeerId(stripTargetPrefix(raw).targetId);
+}

package/src/targeting/target-directory-store.ts

@@ -0,0 +1,396 @@
+import { readNamespaceJson, writeNamespaceJsonAtomic } from "../persistence-store";
+
+const TARGET_DIRECTORY_NAMESPACE = "targets.directory";
+const MAX_HISTORICAL_NAMES = 20;
+const MAX_RECENT_CONVERSATIONS = 20;
+const LAST_SEEN_WRITE_THROTTLE_MS = 60 * 1000;
+
+export interface GroupTargetEntry {
+  conversationId: string;
+  currentTitle: string;
+  historicalTitles: string[];
+  lastSeenAt: number;
+}
+
+export interface UserTargetEntry {
+  canonicalUserId: string;
+  staffId?: string;
+  senderId: string;
+  currentDisplayName: string;
+  historicalDisplayNames: string[];
+  lastSeenAt: number;
+  lastSeenInConversationIds: string[];
+}
+
+interface TargetDirectoryState {
+  version: 1;
+  groups: Record<string, GroupTargetEntry>;
+  users: Record<string, UserTargetEntry>;
+}
+
+const inMemoryFallbackState = new Map<string, TargetDirectoryState>();
+const persistedStateCache = new Map<string, TargetDirectoryState>();
+
+function fallbackState(): TargetDirectoryState {
+  return {
+    version: 1,
+    groups: {},
+    users: {},
+  };
+}
+
+function trimValue(value: string | undefined): string {
+  return String(value || "").trim();
+}
+
+function normalizeLookup(value: string | undefined): string {
+  return trimValue(value).replace(/\s+/g, " ").toLowerCase();
+}
+
+function normalizeScopeKey(storePath: string | undefined, accountId: string): string {
+  return JSON.stringify([storePath || "__memory__", accountId]);
+}
+
+function readState(params: { storePath?: string; accountId: string }): TargetDirectoryState {
+  const scopeKey = normalizeScopeKey(params.storePath, params.accountId);
+  if (!params.storePath) {
+    return inMemoryFallbackState.get(scopeKey) || fallbackState();
+  }
+  const cached = persistedStateCache.get(scopeKey);
+  if (cached) {
+    return cached;
+  }
+  const state = readNamespaceJson<TargetDirectoryState>(TARGET_DIRECTORY_NAMESPACE, {
+    storePath: params.storePath,
+    scope: { accountId: params.accountId },
+    fallback: fallbackState(),
+  });
+  persistedStateCache.set(scopeKey, state);
+  return state;
+}
+
+function writeState(params: {
+  storePath?: string;
+  accountId: string;
+  state: TargetDirectoryState;
+}): void {
+  const scopeKey = normalizeScopeKey(params.storePath, params.accountId);
+  if (!params.storePath) {
+    inMemoryFallbackState.set(scopeKey, params.state);
+    return;
+  }
+  persistedStateCache.set(scopeKey, params.state);
+  writeNamespaceJsonAtomic(TARGET_DIRECTORY_NAMESPACE, {
+    storePath: params.storePath,
+    scope: { accountId: params.accountId },
+    data: params.state,
+  });
+}
+
+export function clearTargetDirectoryStateCache(): void {
+  inMemoryFallbackState.clear();
+  persistedStateCache.clear();
+}
+
+function appendUniqueText(list: string[], value: string, maxSize: number): string[] {
+  const normalized = normalizeLookup(value);
+  if (!normalized) {
+    return list;
+  }
+  const existingIndex = list.findIndex((item) => normalizeLookup(item) === normalized);
+  if (existingIndex >= 0) {
+    return list;
+  }
+  const nextList = [...list, value.trim()];
+  return nextList.length > maxSize ? nextList.slice(nextList.length - maxSize) : nextList;
+}
+
+function appendUniqueRecentConversation(list: string[], value: string, maxSize: number): string[] {
+  const normalized = normalizeLookup(value);
+  if (!normalized) {
+    return list;
+  }
+  const exists = list.some((item) => normalizeLookup(item) === normalized);
+  if (exists) {
+    return list;
+  }
+  const nextList = [...list, value.trim()];
+  return nextList.length > maxSize ? nextList.slice(nextList.length - maxSize) : nextList;
+}
+
+function shouldRefreshLastSeen(
+  existingLastSeen: number | undefined,
+  nextLastSeen: number,
+): boolean {
+  const previous = Number.isFinite(existingLastSeen) ? Number(existingLastSeen) : 0;
+  if (previous <= 0) {
+    return true;
+  }
+  if (nextLastSeen <= previous) {
+    return false;
+  }
+  return nextLastSeen - previous >= LAST_SEEN_WRITE_THROTTLE_MS;
+}
+
+function findUserKeyByIdentifiers(
+  state: TargetDirectoryState,
+  params: { canonicalUserId?: string; staffId?: string; senderId?: string },
+): string | undefined {
+  const canonical = normalizeLookup(params.canonicalUserId);
+  if (canonical && state.users[params.canonicalUserId || ""]) {
+    return params.canonicalUserId;
+  }
+
+  const staffNorm = normalizeLookup(params.staffId);
+  const senderNorm = normalizeLookup(params.senderId);
+  for (const [key, entry] of Object.entries(state.users)) {
+    if (canonical && normalizeLookup(key) === canonical) {
+      return key;
+    }
+    if (staffNorm && normalizeLookup(entry.staffId) === staffNorm) {
+      return key;
+    }
+    if (senderNorm && normalizeLookup(entry.senderId) === senderNorm) {
+      return key;
+    }
+  }
+  return undefined;
+}
+
+export function upsertObservedGroupTarget(params: {
+  storePath?: string;
+  accountId: string;
+  conversationId: string;
+  title?: string;
+  seenAt?: number;
+}): void {
+  const conversationId = trimValue(params.conversationId);
+  if (!conversationId) {
+    return;
+  }
+  const nowMs = params.seenAt && Number.isFinite(params.seenAt) ? params.seenAt : Date.now();
+  const title = trimValue(params.title) || conversationId;
+  const state = readState({ storePath: params.storePath, accountId: params.accountId });
+  const existingEntry = state.groups[conversationId];
+
+  if (!existingEntry) {
+    const nextState: TargetDirectoryState = {
+      ...state,
+      groups: {
+        ...state.groups,
+        [conversationId]: {
+          conversationId,
+          currentTitle: title,
+          historicalTitles: [],
+          lastSeenAt: nowMs,
+        },
+      },
+    };
+    writeState({ storePath: params.storePath, accountId: params.accountId, state: nextState });
+    return;
+  }
+
+  const titleChanged = normalizeLookup(existingEntry.currentTitle) !== normalizeLookup(title);
+  const nextHistoricalTitles = titleChanged
+    ? appendUniqueText(
+        existingEntry.historicalTitles,
+        existingEntry.currentTitle,
+        MAX_HISTORICAL_NAMES,
+      )
+    : existingEntry.historicalTitles;
+  const nextLastSeenCandidate = Math.max(existingEntry.lastSeenAt || 0, nowMs);
+  const nextLastSeenAt =
+    titleChanged || nextHistoricalTitles !== existingEntry.historicalTitles
+      ? nextLastSeenCandidate
+      : shouldRefreshLastSeen(existingEntry.lastSeenAt, nextLastSeenCandidate)
+        ? nextLastSeenCandidate
+        : existingEntry.lastSeenAt;
+
+  if (
+    !titleChanged &&
+    nextHistoricalTitles === existingEntry.historicalTitles &&
+    nextLastSeenAt === existingEntry.lastSeenAt
+  ) {
+    return;
+  }
+
+  const nextEntry: GroupTargetEntry = {
+    conversationId,
+    currentTitle: titleChanged ? title : existingEntry.currentTitle,
+    historicalTitles: nextHistoricalTitles,
+    lastSeenAt: nextLastSeenAt,
+  };
+  const nextState: TargetDirectoryState = {
+    ...state,
+    groups: {
+      ...state.groups,
+      [conversationId]: nextEntry,
+    },
+  };
+  writeState({ storePath: params.storePath, accountId: params.accountId, state: nextState });
+}
+
+export function upsertObservedUserTarget(params: {
+  storePath?: string;
+  accountId: string;
+  senderId: string;
+  staffId?: string;
+  displayName?: string;
+  conversationId?: string;
+  seenAt?: number;
+}): void {
+  const senderId = trimValue(params.senderId);
+  if (!senderId) {
+    return;
+  }
+  const staffId = trimValue(params.staffId);
+  const canonicalUserId = staffId || senderId;
+  const nowMs = params.seenAt && Number.isFinite(params.seenAt) ? params.seenAt : Date.now();
+  const displayName = trimValue(params.displayName) || canonicalUserId;
+  const conversationId = trimValue(params.conversationId);
+
+  const state = readState({ storePath: params.storePath, accountId: params.accountId });
+  const existingKey = findUserKeyByIdentifiers(state, {
+    canonicalUserId,
+    staffId,
+    senderId,
+  });
+  const existingEntry = existingKey ? state.users[existingKey] : undefined;
+
+  if (!existingEntry) {
+    const nextState: TargetDirectoryState = {
+      ...state,
+      users: {
+        ...state.users,
+        [canonicalUserId]: {
+          canonicalUserId,
+          staffId: staffId || undefined,
+          senderId,
+          currentDisplayName: displayName,
+          historicalDisplayNames: [],
+          lastSeenAt: nowMs,
+          lastSeenInConversationIds: conversationId ? [conversationId] : [],
+        },
+      },
+    };
+    writeState({ storePath: params.storePath, accountId: params.accountId, state: nextState });
+    return;
+  }
+
+  const displayNameChanged =
+    normalizeLookup(existingEntry.currentDisplayName) !== normalizeLookup(displayName);
+  const nextHistoricalDisplayNames = displayNameChanged
+    ? appendUniqueText(
+        existingEntry.historicalDisplayNames,
+        existingEntry.currentDisplayName,
+        MAX_HISTORICAL_NAMES,
+      )
+    : existingEntry.historicalDisplayNames;
+  const nextConversationIds = conversationId
+    ? appendUniqueRecentConversation(
+        existingEntry.lastSeenInConversationIds,
+        conversationId,
+        MAX_RECENT_CONVERSATIONS,
+      )
+    : existingEntry.lastSeenInConversationIds;
+  const normalizedStaffId = staffId || undefined;
+  const staffIdChanged = existingEntry.staffId !== normalizedStaffId;
+  const senderIdChanged = existingEntry.senderId !== senderId;
+  const canonicalUserIdChanged =
+    existingEntry.canonicalUserId !== canonicalUserId || existingKey !== canonicalUserId;
+  const metadataChanged =
+    displayNameChanged ||
+    nextHistoricalDisplayNames !== existingEntry.historicalDisplayNames ||
+    nextConversationIds !== existingEntry.lastSeenInConversationIds ||
+    staffIdChanged ||
+    senderIdChanged ||
+    canonicalUserIdChanged;
+  const nextLastSeenCandidate = Math.max(existingEntry.lastSeenAt || 0, nowMs);
+  const nextLastSeenAt = metadataChanged
+    ? nextLastSeenCandidate
+    : shouldRefreshLastSeen(existingEntry.lastSeenAt, nextLastSeenCandidate)
+      ? nextLastSeenCandidate
+      : existingEntry.lastSeenAt;
+
+  if (!metadataChanged && nextLastSeenAt === existingEntry.lastSeenAt) {
+    return;
+  }
+
+  const nextEntry: UserTargetEntry = {
+    canonicalUserId,
+    staffId: normalizedStaffId,
+    senderId,
+    currentDisplayName: displayNameChanged ? displayName : existingEntry.currentDisplayName,
+    historicalDisplayNames: nextHistoricalDisplayNames,
+    lastSeenAt: nextLastSeenAt,
+    lastSeenInConversationIds: nextConversationIds,
+  };
+
+  const nextUsers =
+    existingKey && existingKey !== canonicalUserId
+      ? Object.fromEntries(Object.entries(state.users).filter(([key]) => key !== existingKey))
+      : { ...state.users };
+  nextUsers[canonicalUserId] = nextEntry;
+
+  const nextState: TargetDirectoryState = {
+    ...state,
+    users: nextUsers,
+  };
+  writeState({ storePath: params.storePath, accountId: params.accountId, state: nextState });
+}
+
+function matchesGroupQuery(entry: GroupTargetEntry, query: string): boolean {
+  const normalizedQuery = normalizeLookup(query);
+  if (!normalizedQuery) {
+    return true;
+  }
+  const candidates = [entry.conversationId, entry.currentTitle, ...entry.historicalTitles];
+  return candidates.some((value) => normalizeLookup(value) === normalizedQuery);
+}
+
+function matchesUserQuery(entry: UserTargetEntry, query: string): boolean {
+  const normalizedQuery = normalizeLookup(query);
+  if (!normalizedQuery) {
+    return true;
+  }
+  const candidates = [
+    entry.canonicalUserId,
+    entry.staffId || "",
+    entry.senderId,
+    entry.currentDisplayName,
+    ...entry.historicalDisplayNames,
+  ];
+  return candidates.some((value) => normalizeLookup(value) === normalizedQuery);
+}
+
+export function listKnownGroupTargets(params: {
+  storePath?: string;
+  accountId: string;
+  query?: string;
+  limit?: number;
+}): GroupTargetEntry[] {
+  const state = readState({ storePath: params.storePath, accountId: params.accountId });
+  const entries = Object.values(state.groups)
+    .filter((entry) => matchesGroupQuery(entry, params.query || ""))
+    .toSorted((a, b) => b.lastSeenAt - a.lastSeenAt);
+  if (params.limit && params.limit > 0) {
+    return entries.slice(0, params.limit);
+  }
+  return entries;
+}
+
+export function listKnownUserTargets(params: {
+  storePath?: string;
+  accountId: string;
+  query?: string;
+  limit?: number;
+}): UserTargetEntry[] {
+  const state = readState({ storePath: params.storePath, accountId: params.accountId });
+  const entries = Object.values(state.users)
+    .filter((entry) => matchesUserQuery(entry, params.query || ""))
+    .toSorted((a, b) => b.lastSeenAt - a.lastSeenAt);
+  if (params.limit && params.limit > 0) {
+    return entries.slice(0, params.limit);
+  }
+  return entries;
+}

package/src/targeting/target-input.ts

@@ -0,0 +1,62 @@
+import { stripTargetPrefix } from "../config";
+
+function stripProviderPrefix(raw: string): string {
+  return raw.replace(/^(dingtalk|dd|ding)\s*:\s*/i, "");
+}
+
+function parseDingTalkTargetInput(raw: string): {
+  targetId: string;
+  explicitUser: boolean;
+  explicitGroup: boolean;
+} {
+  const providerStripped = stripProviderPrefix(raw.trim()).trim();
+  const explicitGroup = providerStripped.startsWith("group:");
+  const { targetId, isExplicitUser } = stripTargetPrefix(providerStripped);
+  return {
+    targetId: targetId.trim(),
+    explicitUser: isExplicitUser,
+    explicitGroup,
+  };
+}
+
+export function normalizeDingTalkTarget(raw: string): string | undefined {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return undefined;
+  }
+  const providerStripped = stripProviderPrefix(trimmed).trim();
+  const { targetId } = stripTargetPrefix(providerStripped);
+  const normalized = targetId.trim();
+  return normalized || undefined;
+}
+
+export function looksLikeDingTalkTargetId(raw: string, normalized?: string): boolean {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return false;
+  }
+  const parsed = parseDingTalkTargetInput(trimmed);
+  if (parsed.explicitUser || parsed.explicitGroup) {
+    return true;
+  }
+  const candidate = (normalized || parsed.targetId).trim();
+  if (!candidate) {
+    return false;
+  }
+  if (/^cid[\w+\-/=]*$/i.test(candidate)) {
+    return true;
+  }
+  if (/^\+?\d{6,}$/.test(candidate)) {
+    return true;
+  }
+  if (/^[A-Za-z0-9+/=]{16,}$/.test(candidate) && /[+/=]/.test(candidate)) {
+    return true;
+  }
+  if (/^(?=.*[A-Za-z])(?=.*\d)[A-Za-z0-9]{24,}$/.test(candidate)) {
+    return true;
+  }
+  if (/^[A-Za-z0-9_-]{24,}$/.test(candidate) && /\d/.test(candidate)) {
+    return true;
+  }
+  return false;
+}