@soimy/dingtalk 3.6.11 → 3.7.0

package/src/channel.ts

@@ -1,22 +1,27 @@
 import { buildJsonChannelConfigSchema } from "openclaw/plugin-sdk/channel-config-schema";
 import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
 import pluginManifest from "../openclaw.plugin.json";
-import { getConfig, isConfigured, mergeAccountWithDefaults, resolveGroupConfig } from "./config";
 import {
   CHANNEL_INFLIGHT_NAMESPACE_POLICY,
   createDingTalkGateway,
 } from "./gateway/channel-gateway";
-import { dingtalkSetupAdapter, dingtalkSetupWizard } from "./onboarding.js";
 import { createDingTalkMessageActions } from "./messaging/channel-actions";
 import { createDingTalkOutbound } from "./messaging/channel-outbound";
 import { createDingTalkStatus } from "./platform/channel-status";
-import { hasConfiguredSecretInput } from "./secret-input";
+import {
+  getConfig,
+  isConfigured,
+  mergeAccountWithDefaults,
+  resolveGroupConfig,
+} from "./platform/config";
+import { dingtalkSetupAdapter, dingtalkSetupWizard } from "./platform/onboarding.js";
+import { hasConfiguredSecretInput } from "./platform/secret-input";
+import type { DingTalkChannelPlugin, ResolvedAccount } from "./platform/types";
 import {
   listDingTalkDirectoryGroups,
   listDingTalkDirectoryUsers,
 } from "./targeting/target-directory-adapter";
 import { looksLikeDingTalkTargetId, normalizeDingTalkTarget } from "./targeting/target-input";
-import type { DingTalkChannelPlugin, ResolvedAccount } from "./types";
 
 // DingTalk Channel Definition (assembly layer).
 // Heavy logic is delegated to service modules for maintainability.
@@ -98,13 +103,6 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
       }
       return config.groupPolicy !== "open";
     },
-    resolveGroupIntroHint: ({ groupId, groupChannel }: any): string | undefined => {
-      const parts = [`conversationId=${groupId}`];
-      if (groupChannel) {
-        parts.push(`sessionKey=${groupChannel}`);
-      }
-      return `DingTalk IDs: ${parts.join(", ")}.`;
-    },
   },
   messaging: {
     normalizeTarget: (raw: string) => (raw ? normalizeDingTalkTarget(raw) : undefined),
@@ -128,13 +126,13 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
 };
 
 export { CHANNEL_INFLIGHT_NAMESPACE_POLICY };
-export { getAccessToken } from "./auth";
-export { createAICard, finishAICard, streamAICard } from "./card-service";
-export { detectMediaTypeFromExtension } from "./media-utils";
-export { getLogger } from "./logger-context";
+export { getAccessToken } from "./platform/auth";
+export { createAICard, finishAICard, streamAICard } from "./card/card-service";
+export { detectMediaTypeFromExtension } from "./messaging/media-utils";
+export { getLogger } from "./platform/logger-context";
 export {
   sendBySession,
   sendMessage,
   sendProactiveMedia,
   uploadMedia,
-} from "./send-service";
+} from "./messaging/send-service";

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

@@ -1,7 +1,7 @@
 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";
+import { getDingTalkRuntime } from "../platform/runtime";
+import type { Logger } from "../platform/types";
 
 /**
  * Dispatch a native targeted `/stop` command through the OpenClaw SDK,

package/src/{feedback-learning-service.ts → command/feedback-learning-service.ts}

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import type { DingTalkConfig, MessageContent } from "../platform/types";
 import {
   appendFeedbackEvent,
   appendOutboundReplySnapshot,
@@ -24,12 +25,14 @@ import {
   upsertTargetSet,
   upsertLearnedRule,
 } from "./feedback-learning-store";
-import type { DingTalkConfig, MessageContent } from "./types";
 
 const NEGATIVE_SIGNAL_PATTERNS: Array<{ pattern: RegExp; category: ReflectionCategory }> = [
   { pattern: /(没看图|没看图片|看图|补发原图|别猜图)/i, category: "missing_image_context" },
   { pattern: /(引用|原文|原消息|别猜|没拿到|没看到)/i, category: "quoted_context_missing" },
-  { pattern: /(不是这个意思|理解错|答偏|重新答|重新回答|我问的是)/i, category: "misunderstood_intent" },
+  {
+    pattern: /(不是这个意思|理解错|答偏|重新答|重新回答|我问的是)/i,
+    category: "misunderstood_intent",
+  },
 ];
 
 function buildRuleInstruction(category: ReflectionCategory): string {
@@ -128,7 +131,9 @@ function updateLearnedRule(
     return;
   }
   const ruleId = `rule_${category}`;
-  const existing = listLearnedRules({ storePath, accountId }).find((rule) => rule.ruleId === ruleId);
+  const existing = listLearnedRules({ storePath, accountId }).find(
+    (rule) => rule.ruleId === ruleId,
+  );
   const negativeCount = (existing?.negativeCount || 0) + 1;
   const positiveCount = existing?.positiveCount || 0;
   const rule: LearnedRuleRecord = {
@@ -286,7 +291,10 @@ export function analyzeImplicitNegativeFeedback(params: {
     snapshot,
     content: params.content,
   });
-  if (category === "generic_negative" && !NEGATIVE_SIGNAL_PATTERNS.some((item) => item.pattern.test(params.signalText))) {
+  if (
+    category === "generic_negative" &&
+    !NEGATIVE_SIGNAL_PATTERNS.some((item) => item.pattern.test(params.signalText))
+  ) {
     return;
   }
 
@@ -418,7 +426,9 @@ export function applyManualGlobalLearningRule(params: {
     return null;
   }
   const ruleId = `manual_${Date.now()}`;
-  const exactReplyMatch = params.instruction.trim().match(/^当用户问[“"](.+?)[”"]时，必须回答[“"](.+?)[”"][。.!！]?$/);
+  const exactReplyMatch = params.instruction
+    .trim()
+    .match(/^当用户问[“"](.+?)[”"]时，必须回答[“"](.+?)[”"][。.!！]?$/);
   upsertLearnedRule({
     storePath: params.storePath,
     accountId: params.accountId,
@@ -452,9 +462,13 @@ export function resolveManualForcedReply(params: {
     return null;
   }
   const targetMatched = params.targetId
-    ? listTargetRules({ storePath: params.storePath, accountId: params.accountId, targetId: params.targetId })
-      .filter((rule) => rule.enabled && rule.manual && rule.triggerText && rule.forcedReply)
-      .find((rule) => normalizeManualTriggerText(rule.triggerText) === text)
+    ? listTargetRules({
+        storePath: params.storePath,
+        accountId: params.accountId,
+        targetId: params.targetId,
+      })
+        .filter((rule) => rule.enabled && rule.manual && rule.triggerText && rule.forcedReply)
+        .find((rule) => normalizeManualTriggerText(rule.triggerText) === text)
     : null;
   if (targetMatched?.forcedReply) {
     return targetMatched.forcedReply;
@@ -502,7 +516,9 @@ export function applyManualTargetLearningRule(params: {
     return null;
   }
   const ruleId = `manual_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-  const exactReplyMatch = params.instruction.trim().match(/^当用户问[“"](.+?)[”"]时，必须回答[“"](.+?)[”"][。.!！]?$/);
+  const exactReplyMatch = params.instruction
+    .trim()
+    .match(/^当用户问[“"](.+?)[”"]时，必须回答[“"](.+?)[”"][。.!！]?$/);
   upsertTargetRule({
     storePath: params.storePath,
     accountId: params.accountId,
@@ -533,13 +549,17 @@ export function applyManualTargetsLearningRule(params: {
     return [];
   }
   return params.targetIds
-    .map((targetId) => applyManualTargetLearningRule({
-      storePath: params.storePath,
-      accountId: params.accountId,
-      targetId,
-      instruction: params.instruction,
-    }))
-    .map((result, index) => result ? { targetId: params.targetIds[index], ruleId: result.ruleId } : null)
+    .map((targetId) =>
+      applyManualTargetLearningRule({
+        storePath: params.storePath,
+        accountId: params.accountId,
+        targetId,
+        instruction: params.instruction,
+      }),
+    )
+    .map((result, index) =>
+      result ? { targetId: params.targetIds[index], ruleId: result.ruleId } : null,
+    )
     .filter(Boolean) as Array<{ targetId: string; ruleId: string }>;
 }
 

package/src/{feedback-learning-store.ts → command/feedback-learning-store.ts}

@@ -1,4 +1,4 @@
-import { readNamespaceJson, writeNamespaceJsonAtomic } from "./persistence-store";
+import { readNamespaceJson, writeNamespaceJsonAtomic } from "../shared/persistence-store";
 
 const MAX_EVENTS = 200;
 const MAX_SNAPSHOTS = 100;
@@ -151,57 +151,70 @@ function writeListBucket<T>(
   });
 }
 
-export function appendFeedbackEvent(
-  params: { storePath?: string; accountId: string; targetId: string; event: FeedbackEventRecord },
-): void {
+export function appendFeedbackEvent(params: {
+  storePath?: string;
+  accountId: string;
+  targetId: string;
+  event: FeedbackEventRecord;
+}): void {
   const bucket = readListBucket<FeedbackEventRecord>(EVENTS_NAMESPACE, params);
   bucket.entries = trimNewest([...bucket.entries, params.event], MAX_EVENTS);
   writeListBucket(EVENTS_NAMESPACE, { ...params, entries: bucket.entries });
 }
 
-export function listFeedbackEvents(
-  params: { storePath?: string; accountId: string; targetId: string },
-): FeedbackEventRecord[] {
+export function listFeedbackEvents(params: {
+  storePath?: string;
+  accountId: string;
+  targetId: string;
+}): FeedbackEventRecord[] {
   return readListBucket<FeedbackEventRecord>(EVENTS_NAMESPACE, params).entries;
 }
 
-export function appendOutboundReplySnapshot(
-  params: { storePath?: string; accountId: string; targetId: string; snapshot: OutboundReplySnapshot },
-): void {
+export function appendOutboundReplySnapshot(params: {
+  storePath?: string;
+  accountId: string;
+  targetId: string;
+  snapshot: OutboundReplySnapshot;
+}): void {
   const bucket = readListBucket<OutboundReplySnapshot>(SNAPSHOTS_NAMESPACE, params);
   bucket.entries = trimNewest([...bucket.entries, params.snapshot], MAX_SNAPSHOTS);
   writeListBucket(SNAPSHOTS_NAMESPACE, { ...params, entries: bucket.entries });
 }
 
-export function listOutboundReplySnapshots(
-  params: { storePath?: string; accountId: string; targetId: string },
-): OutboundReplySnapshot[] {
+export function listOutboundReplySnapshots(params: {
+  storePath?: string;
+  accountId: string;
+  targetId: string;
+}): OutboundReplySnapshot[] {
   return readListBucket<OutboundReplySnapshot>(SNAPSHOTS_NAMESPACE, params).entries;
 }
 
-export function appendReflectionRecord(
-  params: { storePath?: string; accountId: string; targetId: string; reflection: ReflectionRecord },
-): void {
+export function appendReflectionRecord(params: {
+  storePath?: string;
+  accountId: string;
+  targetId: string;
+  reflection: ReflectionRecord;
+}): void {
   const bucket = readListBucket<ReflectionRecord>(REFLECTIONS_NAMESPACE, params);
   bucket.entries = trimNewest([...bucket.entries, params.reflection], MAX_REFLECTIONS);
   writeListBucket(REFLECTIONS_NAMESPACE, { ...params, entries: bucket.entries });
 }
 
-export function listReflectionRecords(
-  params: { storePath?: string; accountId: string; targetId: string },
-): ReflectionRecord[] {
+export function listReflectionRecords(params: {
+  storePath?: string;
+  accountId: string;
+  targetId: string;
+}): ReflectionRecord[] {
   return readListBucket<ReflectionRecord>(REFLECTIONS_NAMESPACE, params).entries;
 }
 
-export function appendSessionLearningNote(
-  params: {
-    storePath?: string;
-    accountId: string;
-    targetId: string;
-    note: Omit<SessionLearningNote, "expiresAt"> & { expiresAt?: number };
-    ttlMs?: number;
-  },
-): void {
+export function appendSessionLearningNote(params: {
+  storePath?: string;
+  accountId: string;
+  targetId: string;
+  note: Omit<SessionLearningNote, "expiresAt"> & { expiresAt?: number };
+  ttlMs?: number;
+}): void {
   const ttlMs = params.ttlMs && params.ttlMs > 0 ? params.ttlMs : DEFAULT_NOTE_TTL_MS;
   const nowMs = Date.now();
   const bucket = readListBucket<SessionLearningNote>(SESSION_NOTES_NAMESPACE, params);
@@ -216,18 +229,23 @@ export function appendSessionLearningNote(
   });
 }
 
-export function listActiveSessionLearningNotes(
-  params: { storePath?: string; accountId: string; targetId: string; nowMs?: number },
-): SessionLearningNote[] {
+export function listActiveSessionLearningNotes(params: {
+  storePath?: string;
+  accountId: string;
+  targetId: string;
+  nowMs?: number;
+}): SessionLearningNote[] {
   const nowMs = params.nowMs ?? Date.now();
   return readListBucket<SessionLearningNote>(SESSION_NOTES_NAMESPACE, params).entries.filter(
     (note) => note.expiresAt > nowMs,
   );
 }
 
-export function upsertLearnedRule(
-  params: { storePath?: string; accountId: string; rule: LearnedRuleRecord },
-): void {
+export function upsertLearnedRule(params: {
+  storePath?: string;
+  accountId: string;
+  rule: LearnedRuleRecord;
+}): void {
   if (!params.storePath) {
     return;
   }
@@ -253,9 +271,10 @@ export function upsertLearnedRule(
   });
 }
 
-export function listLearnedRules(
-  params: { storePath?: string; accountId: string },
-): LearnedRuleRecord[] {
+export function listLearnedRules(params: {
+  storePath?: string;
+  accountId: string;
+}): LearnedRuleRecord[] {
   if (!params.storePath) {
     return [];
   }
@@ -268,9 +287,11 @@ export function listLearnedRules(
   return Object.values(bucket.rules).toSorted((left, right) => right.updatedAt - left.updatedAt);
 }
 
-export function disableLearnedRule(
-  params: { storePath?: string; accountId: string; ruleId: string },
-): boolean {
+export function disableLearnedRule(params: {
+  storePath?: string;
+  accountId: string;
+  ruleId: string;
+}): boolean {
   if (!params.storePath) {
     return false;
   }
@@ -298,9 +319,11 @@ export function disableLearnedRule(
   return true;
 }
 
-export function deleteLearnedRule(
-  params: { storePath?: string; accountId: string; ruleId: string },
-): boolean {
+export function deleteLearnedRule(params: {
+  storePath?: string;
+  accountId: string;
+  ruleId: string;
+}): boolean {
   if (!params.storePath) {
     return false;
   }
@@ -323,9 +346,10 @@ export function deleteLearnedRule(
   return true;
 }
 
-function readTargetRuleIndex(
-  params: { storePath?: string; accountId: string },
-): TargetRuleIndexBucket {
+function readTargetRuleIndex(params: {
+  storePath?: string;
+  accountId: string;
+}): TargetRuleIndexBucket {
   if (!params.storePath) {
     return { updatedAt: 0, targetIds: [] };
   }
@@ -337,9 +361,11 @@ function readTargetRuleIndex(
   });
 }
 
-function writeTargetRuleIndex(
-  params: { storePath?: string; accountId: string; targetIds: string[] },
-): void {
+function writeTargetRuleIndex(params: {
+  storePath?: string;
+  accountId: string;
+  targetIds: string[];
+}): void {
   if (!params.storePath) {
     return;
   }
@@ -354,9 +380,11 @@ function writeTargetRuleIndex(
   });
 }
 
-function readTargetRuleBucket(
-  params: { storePath?: string; accountId: string; targetId: string },
-): LearnedRuleBucket {
+function readTargetRuleBucket(params: {
+  storePath?: string;
+  accountId: string;
+  targetId: string;
+}): LearnedRuleBucket {
   if (!params.storePath) {
     return { updatedAt: 0, rules: {} };
   }
@@ -368,9 +396,12 @@ function readTargetRuleBucket(
   });
 }
 
-function writeTargetRuleBucket(
-  params: { storePath?: string; accountId: string; targetId: string; bucket: LearnedRuleBucket },
-): void {
+function writeTargetRuleBucket(params: {
+  storePath?: string;
+  accountId: string;
+  targetId: string;
+  bucket: LearnedRuleBucket;
+}): void {
   if (!params.storePath) {
     return;
   }
@@ -382,9 +413,12 @@ function writeTargetRuleBucket(
   });
 }
 
-export function upsertTargetRule(
-  params: { storePath?: string; accountId: string; targetId: string; rule: LearnedRuleRecord },
-): void {
+export function upsertTargetRule(params: {
+  storePath?: string;
+  accountId: string;
+  targetId: string;
+  rule: LearnedRuleRecord;
+}): void {
   if (!params.storePath) {
     return;
   }
@@ -411,18 +445,24 @@ export function upsertTargetRule(
   });
 }
 
-export function listTargetRules(
-  params: { storePath?: string; accountId: string; targetId: string },
-): LearnedRuleRecord[] {
+export function listTargetRules(params: {
+  storePath?: string;
+  accountId: string;
+  targetId: string;
+}): LearnedRuleRecord[] {
   return Object.values(readTargetRuleBucket(params).rules).toSorted(
     (left, right) => right.updatedAt - left.updatedAt,
   );
 }
 
-export function listAllScopedRules(
-  params: { storePath?: string; accountId: string },
-): ScopedLearnedRuleRecord[] {
-  const globalRules = listLearnedRules(params).map((rule) => ({ ...rule, scope: "global" as const }));
+export function listAllScopedRules(params: {
+  storePath?: string;
+  accountId: string;
+}): ScopedLearnedRuleRecord[] {
+  const globalRules = listLearnedRules(params).map((rule) => ({
+    ...rule,
+    scope: "global" as const,
+  }));
   const targetIds = readTargetRuleIndex(params).targetIds;
   const targetRules = targetIds.flatMap((targetId) =>
     listTargetRules({ ...params, targetId }).map((rule) => ({
@@ -431,12 +471,16 @@ export function listAllScopedRules(
       targetId,
     })),
   );
-  return [...targetRules, ...globalRules].toSorted((left, right) => right.updatedAt - left.updatedAt);
+  return [...targetRules, ...globalRules].toSorted(
+    (left, right) => right.updatedAt - left.updatedAt,
+  );
 }
 
-export function disableScopedRule(
-  params: { storePath?: string; accountId: string; ruleId: string },
-): { existed: boolean; scope?: "global" | "target"; targetId?: string } {
+export function disableScopedRule(params: {
+  storePath?: string;
+  accountId: string;
+  ruleId: string;
+}): { existed: boolean; scope?: "global" | "target"; targetId?: string } {
   if (disableLearnedRule(params)) {
     return { existed: true, scope: "global" };
   }
@@ -463,9 +507,11 @@ export function disableScopedRule(
   return { existed: false };
 }
 
-export function deleteScopedRule(
-  params: { storePath?: string; accountId: string; ruleId: string },
-): { existed: boolean; scope?: "global" | "target"; targetId?: string } {
+export function deleteScopedRule(params: {
+  storePath?: string;
+  accountId: string;
+  ruleId: string;
+}): { existed: boolean; scope?: "global" | "target"; targetId?: string } {
   if (deleteLearnedRule(params)) {
     return { existed: true, scope: "global" };
   }
@@ -487,9 +533,12 @@ export function deleteScopedRule(
   return { existed: false };
 }
 
-export function upsertTargetSet(
-  params: { storePath?: string; accountId: string; name: string; targetIds: string[] },
-): void {
+export function upsertTargetSet(params: {
+  storePath?: string;
+  accountId: string;
+  name: string;
+  targetIds: string[];
+}): void {
   if (!params.storePath) {
     return;
   }
@@ -512,9 +561,11 @@ export function upsertTargetSet(
   });
 }
 
-export function getTargetSet(
-  params: { storePath?: string; accountId: string; name: string },
-): TargetSetRecord | null {
+export function getTargetSet(params: {
+  storePath?: string;
+  accountId: string;
+  name: string;
+}): TargetSetRecord | null {
   if (!params.storePath) {
     return null;
   }
@@ -527,9 +578,10 @@ export function getTargetSet(
   return bucket.sets[params.name] || null;
 }
 
-export function listTargetSets(
-  params: { storePath?: string; accountId: string },
-): TargetSetRecord[] {
+export function listTargetSets(params: {
+  storePath?: string;
+  accountId: string;
+}): TargetSetRecord[] {
   if (!params.storePath) {
     return [];
   }

package/src/command/inbound-command-dispatch-service.ts

@@ -1,3 +1,9 @@
+import type {
+  DingTalkConfig,
+  HandleDingTalkMessageParams,
+  MessageContent,
+} from "../platform/types";
+import type { SessionPeerSourceKind } from "../targeting/session-peer-store";
 import {
   applyManualGlobalLearningRule,
   applyManualSessionLearningNote,
@@ -10,7 +16,7 @@ import {
   listLearningTargetSets,
   listScopedLearningRules,
   resolveManualForcedReply,
-} from "../feedback-learning-service";
+} from "./feedback-learning-service";
 import {
   formatLearnAppliedReply,
   formatLearnCommandHelp,
@@ -24,7 +30,7 @@ import {
   formatWhoAmIReply,
   isLearningOwner,
   parseLearnCommand,
-} from "../learning-command-service";
+} from "./learning-command-service";
 import {
   formatSessionAliasBoundReply,
   formatSessionAliasClearedReply,
@@ -34,9 +40,7 @@ import {
   formatSessionAliasValidationErrorReply,
   parseSessionCommand,
   validateSessionAlias,
-} from "../session-command-service";
-import type { SessionPeerSourceKind } from "../session-peer-store";
-import type { DingTalkConfig, HandleDingTalkMessageParams, MessageContent } from "../types";
+} from "./session-command-service";
 
 type InboundCommandDispatchParams = {
   cfg: HandleDingTalkMessageParams["cfg"];
@@ -405,7 +409,9 @@ export async function handleInboundCommandDispatch(
         accountId: params.accountId,
       })
         .slice(0, 10)
-        .map((targetSet) => `- [target-set] ${targetSet.name} => ${targetSet.targetIds.join(", ")}`);
+        .map(
+          (targetSet) => `- [target-set] ${targetSet.name} => ${targetSet.targetIds.join(", ")}`,
+        );
       await params.sendReply(formatLearnListReply([...rules, ...targetSets]));
       return true;
     }