@adongguo/dingtalk 0.1.3

package/src/monitor.ts

@@ -0,0 +1,127 @@
+import { DWClient, TOPIC_ROBOT } from "dingtalk-stream";
+import type { ClawdbotConfig, RuntimeEnv, HistoryEntry } from "openclaw/plugin-sdk";
+import type { DingTalkConfig, DingTalkIncomingMessage } from "./types.js";
+import { createDingTalkClient } from "./client.js";
+import { resolveDingTalkCredentials } from "./accounts.js";
+import { handleDingTalkMessage } from "./bot.js";
+
+export type MonitorDingTalkOpts = {
+  config?: ClawdbotConfig;
+  runtime?: RuntimeEnv;
+  abortSignal?: AbortSignal;
+  accountId?: string;
+};
+
+let currentClient: DWClient | null = null;
+
+export async function monitorDingTalkProvider(opts: MonitorDingTalkOpts = {}): Promise<void> {
+  const cfg = opts.config;
+  if (!cfg) {
+    throw new Error("Config is required for DingTalk monitor");
+  }
+
+  const dingtalkCfg = cfg.channels?.dingtalk as DingTalkConfig | undefined;
+  const creds = resolveDingTalkCredentials(dingtalkCfg);
+  if (!creds) {
+    throw new Error("DingTalk credentials not configured (appKey, appSecret required)");
+  }
+
+  const log = opts.runtime?.log ?? console.log;
+
+  const connectionMode = dingtalkCfg?.connectionMode ?? "stream";
+
+  if (connectionMode === "stream") {
+    return monitorStream({ cfg, dingtalkCfg: dingtalkCfg!, runtime: opts.runtime, abortSignal: opts.abortSignal });
+  }
+
+  log("dingtalk: webhook mode not implemented in monitor, use HTTP server directly");
+}
+
+async function monitorStream(params: {
+  cfg: ClawdbotConfig;
+  dingtalkCfg: DingTalkConfig;
+  runtime?: RuntimeEnv;
+  abortSignal?: AbortSignal;
+}): Promise<void> {
+  const { cfg, dingtalkCfg, runtime, abortSignal } = params;
+  const log = runtime?.log ?? console.log;
+  const error = runtime?.error ?? console.error;
+
+  log("dingtalk: starting Stream connection...");
+
+  const client = createDingTalkClient(dingtalkCfg);
+  currentClient = client;
+
+  const chatHistories = new Map<string, HistoryEntry[]>();
+
+  return new Promise((resolve, reject) => {
+    const cleanup = () => {
+      if (currentClient === client) {
+        try {
+          client.disconnect();
+        } catch {
+          // Ignore disconnect errors
+        }
+        currentClient = null;
+      }
+    };
+
+    const handleAbort = () => {
+      log("dingtalk: abort signal received, stopping Stream client");
+      cleanup();
+      resolve();
+    };
+
+    if (abortSignal?.aborted) {
+      cleanup();
+      resolve();
+      return;
+    }
+
+    abortSignal?.addEventListener("abort", handleAbort, { once: true });
+
+    try {
+      // Register callback listener for robot messages
+      client.registerCallbackListener(TOPIC_ROBOT, async (res) => {
+        try {
+          const messageData = JSON.parse(res.data) as DingTalkIncomingMessage;
+          log(`dingtalk: received message from ${messageData.senderNick}: ${messageData.text?.content || messageData.msgtype}`);
+
+          await handleDingTalkMessage({
+            cfg,
+            message: messageData,
+            runtime,
+            chatHistories,
+            client,
+          });
+
+          // Acknowledge the message
+          client.socketCallBackResponse(res.headers.messageId, { success: true });
+        } catch (err) {
+          error(`dingtalk: error handling message: ${String(err)}`);
+          // Still acknowledge to prevent redelivery
+          client.socketCallBackResponse(res.headers.messageId, { success: false, error: String(err) });
+        }
+      });
+
+      // Connect to DingTalk Stream
+      client.connect();
+      log("dingtalk: Stream client connected");
+    } catch (err) {
+      cleanup();
+      abortSignal?.removeEventListener("abort", handleAbort);
+      reject(err);
+    }
+  });
+}
+
+export function stopDingTalkMonitor(): void {
+  if (currentClient) {
+    try {
+      currentClient.disconnect();
+    } catch {
+      // Ignore errors
+    }
+    currentClient = null;
+  }
+}

package/src/onboarding.ts

@@ -0,0 +1,355 @@
+import type {
+  ChannelOnboardingAdapter,
+  ChannelOnboardingDmPolicy,
+  ClawdbotConfig,
+  DmPolicy,
+  WizardPrompter,
+} from "openclaw/plugin-sdk";
+import { addWildcardAllowFrom, DEFAULT_ACCOUNT_ID, formatDocsLink } from "openclaw/plugin-sdk";
+
+import { resolveDingTalkCredentials } from "./accounts.js";
+import { probeDingTalk } from "./probe.js";
+import type { DingTalkConfig } from "./types.js";
+
+const channel = "dingtalk" as const;
+
+function setDingTalkDmPolicy(cfg: ClawdbotConfig, dmPolicy: DmPolicy): ClawdbotConfig {
+  const allowFrom =
+    dmPolicy === "open"
+      ? addWildcardAllowFrom(cfg.channels?.dingtalk?.allowFrom)?.map((entry) => String(entry))
+      : undefined;
+  return {
+    ...cfg,
+    channels: {
+      ...cfg.channels,
+      dingtalk: {
+        ...cfg.channels?.dingtalk,
+        dmPolicy,
+        ...(allowFrom ? { allowFrom } : {}),
+      },
+    },
+  };
+}
+
+function setDingTalkAllowFrom(cfg: ClawdbotConfig, allowFrom: string[]): ClawdbotConfig {
+  return {
+    ...cfg,
+    channels: {
+      ...cfg.channels,
+      dingtalk: {
+        ...cfg.channels?.dingtalk,
+        allowFrom,
+      },
+    },
+  };
+}
+
+function parseAllowFromInput(raw: string): string[] {
+  return raw
+    .split(/[\n,;]+/g)
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+}
+
+async function promptDingTalkAllowFrom(params: {
+  cfg: ClawdbotConfig;
+  prompter: WizardPrompter;
+}): Promise<ClawdbotConfig> {
+  const existing = params.cfg.channels?.dingtalk?.allowFrom ?? [];
+  await params.prompter.note(
+    [
+      "Allowlist DingTalk DMs by staffId.",
+      "You can find user staffId in DingTalk admin console or via API.",
+      "Examples:",
+      "- 123456789",
+      "- manager001",
+    ].join("\n"),
+    "DingTalk allowlist",
+  );
+
+  while (true) {
+    const entry = await params.prompter.text({
+      message: "DingTalk allowFrom (user staffIds)",
+      placeholder: "123456789, manager001",
+      initialValue: existing[0] ? String(existing[0]) : undefined,
+      validate: (value) => (String(value ?? "").trim() ? undefined : "Required"),
+    });
+    const parts = parseAllowFromInput(String(entry));
+    if (parts.length === 0) {
+      await params.prompter.note("Enter at least one user.", "DingTalk allowlist");
+      continue;
+    }
+
+    const unique = [
+      ...new Set([...existing.map((v) => String(v).trim()).filter(Boolean), ...parts]),
+    ];
+    return setDingTalkAllowFrom(params.cfg, unique);
+  }
+}
+
+async function noteDingTalkCredentialHelp(prompter: WizardPrompter): Promise<void> {
+  await prompter.note(
+    [
+      "1) Go to DingTalk Developer Console (open-dev.dingtalk.com)",
+      "2) Create an enterprise internal application",
+      "3) Get AppKey (ClientID) and AppSecret (ClientSecret) from Credentials page",
+      "4) Enable Robot capability and select Stream mode",
+      "5) Publish the app or add to test group",
+      "Tip: you can also set DINGTALK_APP_KEY / DINGTALK_APP_SECRET env vars.",
+      `Docs: ${formatDocsLink("/channels/dingtalk", "dingtalk")}`,
+    ].join("\n"),
+    "DingTalk credentials",
+  );
+}
+
+function setDingTalkGroupPolicy(
+  cfg: ClawdbotConfig,
+  groupPolicy: "open" | "allowlist" | "disabled",
+): ClawdbotConfig {
+  return {
+    ...cfg,
+    channels: {
+      ...cfg.channels,
+      dingtalk: {
+        ...cfg.channels?.dingtalk,
+        enabled: true,
+        groupPolicy,
+      },
+    },
+  };
+}
+
+function setDingTalkGroupAllowFrom(cfg: ClawdbotConfig, groupAllowFrom: string[]): ClawdbotConfig {
+  return {
+    ...cfg,
+    channels: {
+      ...cfg.channels,
+      dingtalk: {
+        ...cfg.channels?.dingtalk,
+        groupAllowFrom,
+      },
+    },
+  };
+}
+
+const dmPolicy: ChannelOnboardingDmPolicy = {
+  label: "DingTalk",
+  channel,
+  policyKey: "channels.dingtalk.dmPolicy",
+  allowFromKey: "channels.dingtalk.allowFrom",
+  getCurrent: (cfg) => (cfg.channels?.dingtalk as DingTalkConfig | undefined)?.dmPolicy ?? "pairing",
+  setPolicy: (cfg, policy) => setDingTalkDmPolicy(cfg, policy),
+  promptAllowFrom: promptDingTalkAllowFrom,
+};
+
+export const dingtalkOnboardingAdapter: ChannelOnboardingAdapter = {
+  channel,
+  getStatus: async ({ cfg }) => {
+    const dingtalkCfg = cfg.channels?.dingtalk as DingTalkConfig | undefined;
+    const configured = Boolean(resolveDingTalkCredentials(dingtalkCfg));
+
+    // Try to probe if configured
+    let probeResult = null;
+    if (configured && dingtalkCfg) {
+      try {
+        probeResult = await probeDingTalk(dingtalkCfg);
+      } catch {
+        // Ignore probe errors
+      }
+    }
+
+    const statusLines: string[] = [];
+    if (!configured) {
+      statusLines.push("DingTalk: needs app credentials");
+    } else if (probeResult?.ok) {
+      statusLines.push(`DingTalk: connected (${probeResult.appKey ?? "bot"})`);
+    } else {
+      statusLines.push("DingTalk: configured (connection not verified)");
+    }
+
+    return {
+      channel,
+      configured,
+      statusLines,
+      selectionHint: configured ? "configured" : "needs app creds",
+      quickstartScore: configured ? 2 : 0,
+    };
+  },
+
+  configure: async ({ cfg, prompter }) => {
+    const dingtalkCfg = cfg.channels?.dingtalk as DingTalkConfig | undefined;
+    const resolved = resolveDingTalkCredentials(dingtalkCfg);
+    const hasConfigCreds = Boolean(dingtalkCfg?.appKey?.trim() && dingtalkCfg?.appSecret?.trim());
+    const canUseEnv = Boolean(
+      !hasConfigCreds &&
+        process.env.DINGTALK_APP_KEY?.trim() &&
+        process.env.DINGTALK_APP_SECRET?.trim(),
+    );
+
+    let next = cfg;
+    let appKey: string | null = null;
+    let appSecret: string | null = null;
+
+    if (!resolved) {
+      await noteDingTalkCredentialHelp(prompter);
+    }
+
+    if (canUseEnv) {
+      const keepEnv = await prompter.confirm({
+        message: "DINGTALK_APP_KEY + DINGTALK_APP_SECRET detected. Use env vars?",
+        initialValue: true,
+      });
+      if (keepEnv) {
+        next = {
+          ...next,
+          channels: {
+            ...next.channels,
+            dingtalk: { ...next.channels?.dingtalk, enabled: true },
+          },
+        };
+      } else {
+        appKey = String(
+          await prompter.text({
+            message: "Enter DingTalk AppKey (ClientID)",
+            validate: (value) => (value?.trim() ? undefined : "Required"),
+          }),
+        ).trim();
+        appSecret = String(
+          await prompter.text({
+            message: "Enter DingTalk AppSecret (ClientSecret)",
+            validate: (value) => (value?.trim() ? undefined : "Required"),
+          }),
+        ).trim();
+      }
+    } else if (hasConfigCreds) {
+      const keep = await prompter.confirm({
+        message: "DingTalk credentials already configured. Keep them?",
+        initialValue: true,
+      });
+      if (!keep) {
+        appKey = String(
+          await prompter.text({
+            message: "Enter DingTalk AppKey (ClientID)",
+            validate: (value) => (value?.trim() ? undefined : "Required"),
+          }),
+        ).trim();
+        appSecret = String(
+          await prompter.text({
+            message: "Enter DingTalk AppSecret (ClientSecret)",
+            validate: (value) => (value?.trim() ? undefined : "Required"),
+          }),
+        ).trim();
+      }
+    } else {
+      appKey = String(
+        await prompter.text({
+          message: "Enter DingTalk AppKey (ClientID)",
+          validate: (value) => (value?.trim() ? undefined : "Required"),
+        }),
+      ).trim();
+      appSecret = String(
+        await prompter.text({
+          message: "Enter DingTalk AppSecret (ClientSecret)",
+          validate: (value) => (value?.trim() ? undefined : "Required"),
+        }),
+      ).trim();
+    }
+
+    if (appKey && appSecret) {
+      next = {
+        ...next,
+        channels: {
+          ...next.channels,
+          dingtalk: {
+            ...next.channels?.dingtalk,
+            enabled: true,
+            appKey,
+            appSecret,
+          },
+        },
+      };
+
+      // Test connection
+      const testCfg = next.channels?.dingtalk as DingTalkConfig;
+      try {
+        const probe = await probeDingTalk(testCfg);
+        if (probe.ok) {
+          await prompter.note(
+            `Connected (${probe.appKey ?? "bot"})`,
+            "DingTalk connection test",
+          );
+        } else {
+          await prompter.note(
+            `Connection failed: ${probe.error ?? "unknown error"}`,
+            "DingTalk connection test",
+          );
+        }
+      } catch (err) {
+        await prompter.note(`Connection test failed: ${String(err)}`, "DingTalk connection test");
+      }
+    }
+
+    // Robot code (optional)
+    const currentRobotCode = (next.channels?.dingtalk as DingTalkConfig | undefined)?.robotCode;
+    const robotCode = await prompter.text({
+      message: "Robot code (optional, for media download)",
+      placeholder: "dingxxxxxxxxx",
+      initialValue: currentRobotCode,
+    });
+    if (robotCode) {
+      next = {
+        ...next,
+        channels: {
+          ...next.channels,
+          dingtalk: {
+            ...next.channels?.dingtalk,
+            robotCode: String(robotCode).trim(),
+          },
+        },
+      };
+    }
+
+    // Group policy
+    const groupPolicy = await prompter.select({
+      message: "Group chat policy",
+      options: [
+        { value: "allowlist", label: "Allowlist - only respond in specific groups" },
+        { value: "open", label: "Open - respond in all groups (requires mention)" },
+        { value: "disabled", label: "Disabled - don't respond in groups" },
+      ],
+      initialValue:
+        (next.channels?.dingtalk as DingTalkConfig | undefined)?.groupPolicy ?? "allowlist",
+    });
+    if (groupPolicy) {
+      next = setDingTalkGroupPolicy(next, groupPolicy as "open" | "allowlist" | "disabled");
+    }
+
+    // Group allowlist if needed
+    if (groupPolicy === "allowlist") {
+      const existing = (next.channels?.dingtalk as DingTalkConfig | undefined)?.groupAllowFrom ?? [];
+      const entry = await prompter.text({
+        message: "Group chat allowlist (conversationIds)",
+        placeholder: "cidXXXXX, cidYYYYY",
+        initialValue: existing.length > 0 ? existing.map(String).join(", ") : undefined,
+      });
+      if (entry) {
+        const parts = parseAllowFromInput(String(entry));
+        if (parts.length > 0) {
+          next = setDingTalkGroupAllowFrom(next, parts);
+        }
+      }
+    }
+
+    return { cfg: next, accountId: DEFAULT_ACCOUNT_ID };
+  },
+
+  dmPolicy,
+
+  disable: (cfg) => ({
+    ...cfg,
+    channels: {
+      ...cfg.channels,
+      dingtalk: { ...cfg.channels?.dingtalk, enabled: false },
+    },
+  }),
+};

package/src/outbound.ts

@@ -0,0 +1,46 @@
+import type { ChannelOutboundAdapter } from "openclaw/plugin-sdk";
+import { getDingTalkRuntime } from "./runtime.js";
+import { sendMessageDingTalk } from "./send.js";
+import { sendMediaDingTalk } from "./media.js";
+
+// Note: DingTalk outbound adapter has limited functionality
+// because it requires sessionWebhook which is only available during message handling.
+// This adapter is primarily for interface compatibility.
+
+export const dingtalkOutbound: ChannelOutboundAdapter = {
+  deliveryMode: "direct",
+  chunker: (text, limit) => getDingTalkRuntime().channel.text.chunkMarkdownText(text, limit),
+  chunkerMode: "markdown",
+  textChunkLimit: 4000,
+  sendText: async ({ cfg, to, text }) => {
+    // Note: DingTalk requires sessionWebhook, which must be provided in the 'to' field
+    // Format: sessionWebhook URL directly
+    const result = await sendMessageDingTalk({ cfg, sessionWebhook: to, text });
+    return { channel: "dingtalk", conversationId: result.conversationId, messageId: result.processQueryKey || "" };
+  },
+  sendMedia: async ({ cfg, to, text, mediaUrl }) => {
+    // Send text first if provided
+    if (text?.trim()) {
+      await sendMessageDingTalk({ cfg, sessionWebhook: to, text });
+    }
+
+    // Upload and send media if URL provided
+    if (mediaUrl) {
+      try {
+        const result = await sendMediaDingTalk({ cfg, sessionWebhook: to, mediaUrl });
+        return { channel: "dingtalk", conversationId: result.conversationId, messageId: result.processQueryKey || "" };
+      } catch (err) {
+        // Log the error for debugging
+        console.error(`[dingtalk] sendMediaDingTalk failed:`, err);
+        // Fallback to URL link if upload fails
+        const fallbackText = `📎 ${mediaUrl}`;
+        const result = await sendMessageDingTalk({ cfg, sessionWebhook: to, text: fallbackText });
+        return { channel: "dingtalk", conversationId: result.conversationId, messageId: result.processQueryKey || "" };
+      }
+    }
+
+    // No media URL, just return text result
+    const result = await sendMessageDingTalk({ cfg, sessionWebhook: to, text: text ?? "" });
+    return { channel: "dingtalk", conversationId: result.conversationId, messageId: result.processQueryKey || "" };
+  },
+};

package/src/policy.ts

@@ -0,0 +1,92 @@
+import type { ChannelGroupContext, GroupToolPolicyConfig } from "openclaw/plugin-sdk";
+import type { DingTalkConfig, DingTalkGroupConfig } from "./types.js";
+
+export type DingTalkAllowlistMatch = {
+  allowed: boolean;
+  matchKey?: string;
+  matchSource?: "wildcard" | "id" | "name";
+};
+
+export function resolveDingTalkAllowlistMatch(params: {
+  allowFrom: Array<string | number>;
+  senderId: string;
+  senderName?: string | null;
+}): DingTalkAllowlistMatch {
+  const allowFrom = params.allowFrom
+    .map((entry) => String(entry).trim().toLowerCase())
+    .filter(Boolean);
+
+  if (allowFrom.length === 0) return { allowed: false };
+  if (allowFrom.includes("*")) {
+    return { allowed: true, matchKey: "*", matchSource: "wildcard" };
+  }
+
+  const senderId = params.senderId.toLowerCase();
+  if (allowFrom.includes(senderId)) {
+    return { allowed: true, matchKey: senderId, matchSource: "id" };
+  }
+
+  const senderName = params.senderName?.toLowerCase();
+  if (senderName && allowFrom.includes(senderName)) {
+    return { allowed: true, matchKey: senderName, matchSource: "name" };
+  }
+
+  return { allowed: false };
+}
+
+export function resolveDingTalkGroupConfig(params: {
+  cfg?: DingTalkConfig;
+  groupId?: string | null;
+}): DingTalkGroupConfig | undefined {
+  const groups = params.cfg?.groups ?? {};
+  const groupId = params.groupId?.trim();
+  if (!groupId) return undefined;
+
+  const direct = groups[groupId] as DingTalkGroupConfig | undefined;
+  if (direct) return direct;
+
+  const lowered = groupId.toLowerCase();
+  const matchKey = Object.keys(groups).find((key) => key.toLowerCase() === lowered);
+  return matchKey ? (groups[matchKey] as DingTalkGroupConfig | undefined) : undefined;
+}
+
+export function resolveDingTalkGroupToolPolicy(
+  params: ChannelGroupContext,
+): GroupToolPolicyConfig | undefined {
+  const cfg = params.cfg.channels?.dingtalk as DingTalkConfig | undefined;
+  if (!cfg) return undefined;
+
+  const groupConfig = resolveDingTalkGroupConfig({
+    cfg,
+    groupId: params.groupId,
+  });
+
+  return groupConfig?.tools;
+}
+
+export function isDingTalkGroupAllowed(params: {
+  groupPolicy: "open" | "allowlist" | "disabled";
+  allowFrom: Array<string | number>;
+  senderId: string;
+  senderName?: string | null;
+}): boolean {
+  const { groupPolicy } = params;
+  if (groupPolicy === "disabled") return false;
+  if (groupPolicy === "open") return true;
+  return resolveDingTalkAllowlistMatch(params).allowed;
+}
+
+export function resolveDingTalkReplyPolicy(params: {
+  isDirectMessage: boolean;
+  globalConfig?: DingTalkConfig;
+  groupConfig?: DingTalkGroupConfig;
+}): { requireMention: boolean } {
+  if (params.isDirectMessage) {
+    return { requireMention: false };
+  }
+
+  const requireMention =
+    params.groupConfig?.requireMention ?? params.globalConfig?.requireMention ?? true;
+
+  return { requireMention };
+}

package/src/probe.ts

@@ -0,0 +1,41 @@
+import type { DingTalkConfig, DingTalkProbeResult } from "./types.js";
+import { createDingTalkClient } from "./client.js";
+import { resolveDingTalkCredentials } from "./accounts.js";
+
+export async function probeDingTalk(cfg?: DingTalkConfig): Promise<DingTalkProbeResult> {
+  const creds = resolveDingTalkCredentials(cfg);
+  if (!creds) {
+    return {
+      ok: false,
+      error: "missing credentials (appKey, appSecret)",
+    };
+  }
+
+  try {
+    const client = createDingTalkClient(cfg!);
+
+    // Try to get access token as a connectivity test
+    const accessToken = await client.getAccessToken();
+
+    if (!accessToken) {
+      return {
+        ok: false,
+        appKey: creds.appKey,
+        error: "Failed to get access token",
+      };
+    }
+
+    return {
+      ok: true,
+      appKey: creds.appKey,
+      robotCode: creds.robotCode,
+      connected: true,
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      appKey: creds.appKey,
+      error: err instanceof Error ? err.message : String(err),
+    };
+  }
+}