@jeik/dingtalk-connector 0.8.21

package/src/config/accounts.ts

@@ -0,0 +1,242 @@
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId , normalizeResolvedSecretInputString, normalizeSecretInputString } from "../sdk/helpers.ts";
+import type { ClawdbotConfig } from "openclaw/plugin-sdk";
+import type {
+  DingtalkConfig,
+  DingtalkAccountConfig,
+  DingtalkDefaultAccountSelectionSource,
+  ResolvedDingtalkAccount,
+} from "../types/index.ts";
+
+/**
+ * List all configured account IDs from the accounts field.
+ */
+function listConfiguredAccountIds(cfg: ClawdbotConfig): string[] {
+  const accounts = (cfg.channels?.["dingtalk-connector"] as DingtalkConfig)?.accounts;
+  if (!accounts || typeof accounts !== "object") {
+    return [];
+  }
+  return Object.keys(accounts).filter(Boolean);
+}
+
+/**
+ * List all DingTalk account IDs.
+ * If no accounts are configured, returns [DEFAULT_ACCOUNT_ID] for backward compatibility.
+ */
+export function listDingtalkAccountIds(cfg: ClawdbotConfig): string[] {
+  const ids = listConfiguredAccountIds(cfg);
+  if (ids.length === 0) {
+    // Backward compatibility: no accounts configured, use default
+    return [DEFAULT_ACCOUNT_ID];
+  }
+  return [...ids].sort((a, b) => a.localeCompare(b));
+}
+
+/**
+ * Resolve the default account selection and its source.
+ */
+export function resolveDefaultDingtalkAccountSelection(cfg: ClawdbotConfig): {
+  accountId: string;
+  source: DingtalkDefaultAccountSelectionSource;
+} {
+  const preferredRaw = (cfg.channels?.["dingtalk-connector"] as DingtalkConfig | undefined)?.defaultAccount?.trim();
+  const preferred = preferredRaw ? normalizeAccountId(preferredRaw) : undefined;
+  if (preferred) {
+    return {
+      accountId: preferred,
+      source: "explicit-default",
+    };
+  }
+  const ids = listDingtalkAccountIds(cfg);
+  if (ids.includes(DEFAULT_ACCOUNT_ID)) {
+    return {
+      accountId: DEFAULT_ACCOUNT_ID,
+      source: "mapped-default",
+    };
+  }
+  return {
+    accountId: ids[0] ?? DEFAULT_ACCOUNT_ID,
+    source: "fallback",
+  };
+}
+
+/**
+ * Resolve the default account ID.
+ */
+export function resolveDefaultDingtalkAccountId(cfg: ClawdbotConfig): string {
+  return resolveDefaultDingtalkAccountSelection(cfg).accountId;
+}
+
+/**
+ * Get the raw account-specific config.
+ */
+function resolveAccountConfig(
+  cfg: ClawdbotConfig,
+  accountId: string,
+): DingtalkAccountConfig | undefined {
+  const accounts = (cfg.channels?.["dingtalk-connector"] as DingtalkConfig)?.accounts;
+  if (!accounts || typeof accounts !== "object") {
+    return undefined;
+  }
+  return accounts[accountId];
+}
+
+/**
+ * Merge top-level config with account-specific config.
+ * Account-specific fields override top-level fields.
+ */
+function mergeDingtalkAccountConfig(cfg: ClawdbotConfig, accountId: string): DingtalkConfig {
+  const dingtalkCfg = cfg.channels?.["dingtalk-connector"] as DingtalkConfig | undefined;
+
+  // Extract base config (exclude accounts field to avoid recursion)
+  const { accounts: _ignored, defaultAccount: _ignoredDefaultAccount, ...base } = dingtalkCfg ?? {};
+
+  // Get account-specific overrides
+  const account = resolveAccountConfig(cfg, accountId) ?? {};
+
+  // Merge: account config overrides base config
+  return { ...base, ...account } as DingtalkConfig;
+}
+
+/**
+ * Resolve DingTalk credentials from a config.
+ */
+export function resolveDingtalkCredentials(cfg?: DingtalkConfig): {
+  clientId: string;
+  clientSecret: string;
+} | null;
+export function resolveDingtalkCredentials(
+  cfg: DingtalkConfig | undefined,
+  options: { allowUnresolvedSecretRef?: boolean },
+): {
+  clientId: string;
+  clientSecret: string;
+} | null;
+export function resolveDingtalkCredentials(
+  cfg?: DingtalkConfig,
+  options?: { allowUnresolvedSecretRef?: boolean },
+): {
+  clientId: string;
+  clientSecret: string;
+} | null {
+  const normalizeString = (value: unknown): string | undefined => {
+    if (typeof value === "number") {
+      return String(value);
+    }
+    if (typeof value !== "string") {
+      return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed ? trimmed : undefined;
+  };
+
+  const resolveSecretLike = (value: unknown, path: string): string | undefined => {
+    // Missing credential: treat as not configured (no exception).
+    // This path is used in non-onboarding contexts (e.g. channel listing/status),
+    // so we must not throw when credentials are absent.
+    if (value === undefined || value === null) {
+      return undefined;
+    }
+
+    const asString = normalizeString(value);
+    if (asString) {
+      return asString;
+    }
+
+    // In relaxed/onboarding paths only: allow direct env SecretRef reads for UX.
+    // Default resolution path must preserve unresolved-ref diagnostics/policy semantics.
+    if (options?.allowUnresolvedSecretRef && typeof value === "object" && value !== null) {
+      const rec = value as Record<string, unknown>;
+      const source = normalizeString(rec.source)?.toLowerCase();
+      const id = normalizeString(rec.id);
+      if (source === "env" && id) {
+        const envValue = normalizeString(process.env[id]);
+        if (envValue) {
+          return envValue;
+        }
+      }
+    }
+
+    if (options?.allowUnresolvedSecretRef) {
+      return normalizeSecretInputString(value);
+    }
+    return normalizeResolvedSecretInputString({ value, path });
+  };
+
+  const clientId = resolveSecretLike(cfg?.clientId, "channels.dingtalk-connector.clientId");
+  const clientSecret = resolveSecretLike(cfg?.clientSecret, "channels.dingtalk-connector.clientSecret");
+
+  if (!clientId || !clientSecret) {
+    return null;
+  }
+  return {
+    clientId,
+    clientSecret,
+  };
+}
+
+/**
+ * Resolve a complete DingTalk account with merged config.
+ */
+export function resolveDingtalkAccount(params: {
+  cfg: ClawdbotConfig;
+  accountId?: string | null;
+}): ResolvedDingtalkAccount {
+  const hasExplicitAccountId =
+    typeof params.accountId === "string" && params.accountId.trim() !== "";
+  const defaultSelection = hasExplicitAccountId
+    ? null
+    : resolveDefaultDingtalkAccountSelection(params.cfg);
+  const accountId = hasExplicitAccountId
+    ? normalizeAccountId(params.accountId ?? "")
+    : (defaultSelection?.accountId ?? DEFAULT_ACCOUNT_ID);
+  const selectionSource = hasExplicitAccountId
+    ? "explicit"
+    : (defaultSelection?.source ?? "fallback");
+  const dingtalkCfg = params.cfg.channels?.["dingtalk-connector"] as DingtalkConfig | undefined;
+
+  // Base enabled state (top-level)
+  const baseEnabled = dingtalkCfg?.enabled !== false;
+
+  // Merge configs
+  const merged = mergeDingtalkAccountConfig(params.cfg, accountId);
+
+  // Account-level enabled state
+  const accountEnabled = merged.enabled !== false;
+  const enabled = baseEnabled && accountEnabled;
+
+  // Resolve credentials from merged config
+  const creds = resolveDingtalkCredentials(merged);
+  const accountName = (merged as DingtalkAccountConfig).name;
+
+  return {
+    accountId,
+    selectionSource,
+    enabled,
+    configured: Boolean(creds),
+    name: typeof accountName === "string" ? accountName.trim() || undefined : undefined,
+    clientId: creds?.clientId,
+    clientSecret: creds?.clientSecret,
+    config: merged,
+  };
+}
+
+/**
+ * List all enabled and configured accounts.
+ * Deduplicates by clientId to avoid creating multiple connections with the same credentials.
+ */
+export function listEnabledDingtalkAccounts(cfg: ClawdbotConfig): ResolvedDingtalkAccount[] {
+  const accounts = listDingtalkAccountIds(cfg)
+    .map((accountId) => resolveDingtalkAccount({ cfg, accountId }))
+    .filter((account) => account.enabled && account.configured);
+  
+  // Deduplicate by clientId to avoid multiple connections with same credentials
+  const seen = new Set<string>();
+  return accounts.filter((account) => {
+    if (!account.clientId) return true;
+    if (seen.has(account.clientId)) {
+      return false;
+    }
+    seen.add(account.clientId);
+    return true;
+  });
+}

package/src/config/schema.ts

@@ -0,0 +1,180 @@
+import { normalizeAccountId } from "../sdk/helpers.ts";
+import { z } from "zod";
+export { z };
+import { buildSecretInputSchema, hasConfiguredSecretInput } from "../secret-input.ts";
+
+const DmPolicySchema = z.enum(["open", "pairing", "allowlist"]);
+const GroupPolicySchema = z.enum(["open", "allowlist", "disabled"]);
+
+const ToolPolicySchema = z
+  .object({
+    allow: z.array(z.string()).optional(),
+    deny: z.array(z.string()).optional(),
+  })
+  .strict()
+  .optional();
+
+/**
+ * Group session scope for routing DingTalk group messages.
+ * - "group" (default): one session per group chat
+ * - "group_sender": one session per (group + sender)
+ */
+const GroupSessionScopeSchema = z
+  .enum(["group", "group_sender"])
+  .optional();
+
+/**
+ * Group reply mode for DingTalk group messages.
+ * - "aicard" (default): use AI Card with streaming support
+ * - "text": use plain text reply (supports @bot mentions, no AI Card)
+ * - "markdown": use markdown reply (supports @bot mentions, no AI Card)
+ *
+ * When set to "text" or "markdown", group messages will be sent as
+ * plain text/markdown instead of AI Card. This enables bots to @mention
+ * each other in multi-Agent group scenarios.
+ *
+ * ⚠️ Warning: enabling text/markdown mode disables AI Card in group chats.
+ */
+const GroupReplyModeSchema = z
+  .enum(["aicard", "text", "markdown"])
+  .optional();
+
+/**
+ * Dingtalk tools configuration.
+ * Controls which tool categories are enabled.
+ */
+const DingtalkToolsConfigSchema = z
+  .object({
+    docs: z.boolean().optional(), // Document operations (default: true)
+    media: z.boolean().optional(), // Media upload operations (default: true)
+  })
+  .strict()
+  .optional();
+
+export const DingtalkGroupSchema = z
+  .object({
+    requireMention: z.boolean().optional(),
+    tools: ToolPolicySchema,
+    enabled: z.boolean().optional(),
+    allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+    systemPrompt: z.string().optional(),
+    groupSessionScope: GroupSessionScopeSchema,
+  })
+  .strict();
+
+const DingtalkSharedConfigShape = {
+  dmPolicy: DmPolicySchema.optional(),
+  allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+  groupPolicy: GroupPolicySchema.optional(),
+  groupAllowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+  requireMention: z.boolean().optional(),
+  groups: z.record(z.string(), DingtalkGroupSchema.optional()).optional(),
+  historyLimit: z.number().int().min(0).optional(),
+  textChunkLimit: z.number().int().positive().optional(),
+  mediaMaxMb: z.number().positive().optional(),
+  tools: DingtalkToolsConfigSchema,
+  typingIndicator: z.boolean().optional(),
+  resolveSenderNames: z.boolean().optional(),
+  separateSessionByConversation: z.boolean().optional(),
+  sharedMemoryAcrossConversations: z.boolean().optional(),
+  groupSessionScope: GroupSessionScopeSchema,
+  asyncMode: z.boolean().optional(),
+  ackText: z.string().optional(),
+  endpoint: z.string().optional(), // DWClient gateway endpoint
+  debug: z.boolean().optional(), // DWClient debug mode
+  enableMediaUpload: z.boolean().optional(),
+  systemPrompt: z.string().optional(),
+  groupReplyMode: GroupReplyModeSchema,
+  /** AI Card 模板 ID，不填则使用官方默认模板 */
+  cardTemplateId: z.string().optional(),
+  /** AI Card 最终内容变量名，对应卡片模板中的变量字段，不填默认 msgContent */
+  cardContentVar: z.string().optional().default("msgContent"),
+  /** AI Card 中间过程变量名，不填默认 cardContentVar 同值 */
+  cardProcessVar: z.string().optional(),
+  /** AI Card 工具输出变量名，不填则不写入工具输出 */
+  cardToolVar: z.string().optional(),
+};
+
+/**
+ * Per-account configuration.
+ * All fields are optional - missing fields inherit from top-level config.
+ */
+export const DingtalkAccountConfigSchema = z
+  .object({
+    enabled: z.boolean().optional(),
+    name: z.string().optional(), // Display name for this account
+    clientId: z.union([z.string(), z.number()]).optional(),
+    clientSecret: buildSecretInputSchema().optional(),
+    /**
+     * Encrypted DingTalk identity of this bot, used by other agents to @-mention
+     * this bot in group messages. Fill from log line `[BotIdentity] chatbotUserId=...`
+     * after the bot has received at least one group/DM message.
+     */
+    chatbotUserId: z.string().optional(),
+    chatbotCorpId: z.string().optional(),
+    ...DingtalkSharedConfigShape,
+  })
+  .strict();
+
+/**
+ * Base schema (ZodObject) without superRefine, used for JSON Schema generation (Web UI).
+ * superRefine turns the schema into ZodEffects which is not compatible with buildChannelConfigSchema.
+ */
+export const DingtalkConfigBaseSchema = z
+  .object({
+    enabled: z.boolean().optional(),
+    defaultAccount: z.string().optional(),
+    // Top-level credentials (backward compatible for single-account mode)
+    clientId: z.union([z.string(), z.number()]).optional(),
+    clientSecret: buildSecretInputSchema().optional(),
+    ...DingtalkSharedConfigShape,
+    dmPolicy: DmPolicySchema.optional().default("open"),
+    groupPolicy: GroupPolicySchema.optional().default("open"),
+    requireMention: z.boolean().optional().default(true),
+    separateSessionByConversation: z.boolean().optional().default(true),
+    sharedMemoryAcrossConversations: z.boolean().optional().default(false),
+    groupSessionScope: GroupSessionScopeSchema.optional().default("group"),
+    // Multi-account configuration
+    accounts: z.record(z.string(), DingtalkAccountConfigSchema.optional()).optional(),
+  })
+  .strict();
+
+export const DingtalkConfigSchema = DingtalkConfigBaseSchema.superRefine((value, ctx) => {
+    const defaultAccount = value.defaultAccount?.trim();
+    if (defaultAccount && value.accounts && Object.keys(value.accounts).length > 0) {
+      const normalizedDefaultAccount = normalizeAccountId(defaultAccount);
+      if (!Object.prototype.hasOwnProperty.call(value.accounts, normalizedDefaultAccount)) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ["defaultAccount"],
+          message: `channels.dingtalk-connector.defaultAccount="${defaultAccount}" does not match a configured account key`,
+        });
+      }
+    }
+
+    // Validate dmPolicy and allowFrom consistency
+    if (value.dmPolicy === "allowlist") {
+      const allowFrom = value.allowFrom ?? [];
+      if (allowFrom.length === 0) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ["allowFrom"],
+          message:
+            'channels.dingtalk-connector.dmPolicy="allowlist" requires channels.dingtalk-connector.allowFrom to contain at least one entry',
+        });
+      }
+    }
+    
+    // Validate groupPolicy and groupAllowFrom consistency
+    if (value.groupPolicy === "allowlist") {
+      const groupAllowFrom = value.groupAllowFrom ?? [];
+      if (groupAllowFrom.length === 0) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ["groupAllowFrom"],
+          message:
+            'channels.dingtalk-connector.groupPolicy="allowlist" requires channels.dingtalk-connector.groupAllowFrom to contain at least one entry',
+        });
+      }
+    }
+  });