moltbot-dingtalk-stream 1.0.7 → 1.0.9

package/src/runtime.ts

@@ -0,0 +1,227 @@
+import { DWClient } from "dingtalk-stream";
+import axios from "axios";
+
+// Types for Clawdbot core runtime (obtained from pluginRuntime)
+export interface ClawdbotCoreRuntime {
+  channel: {
+    routing: {
+      resolveAgentRoute: (opts: {
+        cfg: unknown;
+        channel: string;
+        accountId: string;
+        peer: { kind: "direct" | "group"; id: string };
+      }) => { agentId: string; sessionKey: string; accountId: string };
+    };
+    reply: {
+      formatAgentEnvelope: (opts: {
+        channel: string;
+        from: string;
+        timestamp?: number;
+        previousTimestamp?: number | null;
+        envelope: unknown;
+        body: string;
+      }) => string;
+      resolveEnvelopeFormatOptions: (cfg: unknown) => unknown;
+      resolveHumanDelayConfig: (cfg: unknown, agentId?: string) => unknown;
+      finalizeInboundContext: (ctx: unknown) => unknown;
+      createReplyDispatcherWithTyping: (opts: {
+        responsePrefix?: string;
+        responsePrefixContextProvider?: () => Promise<string>;
+        humanDelay?: unknown;
+        deliver: (payload: { text?: string; content?: string; mediaUrls?: string[] }) => Promise<void>;
+        onError?: (err: unknown, info: { kind: string }) => void;
+        onReplyStart?: () => void;
+        onIdle?: () => void;
+      }) => {
+        dispatcher: unknown;
+        replyOptions: Record<string, unknown>;
+        markDispatchIdle: () => void;
+      };
+      dispatchReplyFromConfig: (opts: {
+        ctx: unknown;
+        cfg: unknown;
+        dispatcher: unknown;
+        replyOptions?: Record<string, unknown>;
+      }) => Promise<{ queuedFinal: boolean; counts: { final: number } }>;
+      dispatchReplyWithBufferedBlockDispatcher: (opts: {
+        ctx: unknown;
+        cfg: unknown;
+        dispatcherOptions: {
+          deliver: (payload: { text?: string; content?: string }) => Promise<void>;
+          onError?: (err: unknown, info: { kind: string }) => void;
+        };
+      }) => Promise<void>;
+    };
+    session: {
+      resolveStorePath: (
+        storeConfig: unknown,
+        opts: { agentId: string }
+      ) => string;
+      readSessionUpdatedAt?: (opts: { storePath: string; sessionKey: string }) => number | null;
+      recordInboundSession: (opts: {
+        storePath: string;
+        sessionKey: string;
+        ctx: unknown;
+        onRecordError: (err: unknown) => void;
+      }) => Promise<void>;
+    };
+    text: {
+      resolveMarkdownTableMode: (opts: {
+        cfg: unknown;
+        channel: string;
+        accountId: string;
+      }) => "off" | "plain" | "markdown" | "bullets" | "code";
+      chunkMarkdownTextWithMode: (text: string, limit: number, mode: string) => string[];
+      resolveChunkMode: (cfg: unknown, channel: string, accountId?: string) => string;
+    };
+  };
+  logging: {
+    shouldLogVerbose: () => boolean;
+    getChildLogger: (opts: { module: string }) => {
+      info: (msg: string) => void;
+      warn: (msg: string) => void;
+      error: (msg: string) => void;
+      debug?: (msg: string) => void;
+    };
+  };
+}
+
+// Types
+export interface DingTalkRuntime {
+  channel: {
+    dingtalk: {
+      sendMessage: (
+        target: string,
+        text: string,
+        opts?: { accountId?: string; mediaUrl?: string }
+      ) => Promise<{ ok: boolean; error?: string }>;
+      probe: (
+        clientId: string,
+        clientSecret: string,
+        timeoutMs?: number
+      ) => Promise<{ ok: boolean; error?: string; bot?: { name?: string } }>;
+      getClient: (accountId: string) => DWClient | undefined;
+      setClient: (accountId: string, client: DWClient) => void;
+      removeClient: (accountId: string) => void;
+      setSessionWebhook: (conversationId: string, webhook: string) => void;
+      getSessionWebhook: (conversationId: string) => string | undefined;
+    };
+  };
+  logging: {
+    shouldLogVerbose: () => boolean;
+  };
+}
+
+// Storage
+const activeClients = new Map<string, DWClient>();
+const sessionWebhooks = new Map<string, string>();
+
+// Runtime implementation
+const dingtalkRuntime: DingTalkRuntime = {
+  channel: {
+    dingtalk: {
+      sendMessage: async (target, text, opts = {}) => {
+        // Try multiple formats to find webhook
+        // target can be: "dingtalk:user:xxx", "dingtalk:channel:xxx", or plain conversationId
+        const normalizedTarget = target
+          .replace(/^dingtalk:(user|channel|group):/, "")
+          .replace(/^dingtalk:/, "");
+        
+        let webhook = sessionWebhooks.get(target) 
+          || sessionWebhooks.get(normalizedTarget);
+        
+        // Fallback: iterate all keys for partial match
+        if (!webhook) {
+          for (const [key, value] of sessionWebhooks.entries()) {
+            if (key.includes(normalizedTarget) || normalizedTarget.includes(key)) {
+              webhook = value;
+              break;
+            }
+          }
+        }
+        
+        if (!webhook) {
+          console.error(`[DingTalk] No webhook for target: ${target}, normalized: ${normalizedTarget}, available keys: ${Array.from(sessionWebhooks.keys()).join(", ")}`);
+          return { ok: false, error: `No webhook available for target: ${target}` };
+        }
+
+        try {
+          const payload: Record<string, unknown> = {
+            msgtype: "text",
+            text: { content: text },
+          };
+
+          // Use markdown format for media (DingTalk text messages don't support embedded images)
+          if (opts.mediaUrl) {
+            payload.msgtype = "markdown";
+            payload.markdown = {
+              title: "Message",
+              text: `${text}\n\n![image](${opts.mediaUrl})`,
+            };
+            delete payload.text;
+          }
+
+          console.log(`[DingTalk] Sending to webhook: ${webhook.substring(0, 50)}...`);
+          await axios.post(webhook, payload, {
+            headers: { "Content-Type": "application/json" },
+            timeout: 10000,
+          });
+          return { ok: true };
+        } catch (error) {
+          console.error(`[DingTalk] Send failed:`, error);
+          return {
+            ok: false,
+            error: error instanceof Error ? error.message : String(error),
+          };
+        }
+      },
+
+      probe: async (clientId, clientSecret, timeoutMs = 5000) => {
+        try {
+          // Verify credentials by fetching access_token from DingTalk API
+          const response = await axios.post(
+            "https://api.dingtalk.com/v1.0/oauth2/accessToken",
+            { appKey: clientId, appSecret: clientSecret },
+            {
+              headers: { "Content-Type": "application/json" },
+              timeout: timeoutMs,
+            }
+          );
+
+          if (response.data?.accessToken) {
+            return { ok: true, bot: { name: "DingTalk Bot" } };
+          }
+          return { ok: false, error: "Invalid credentials" };
+        } catch (error) {
+          return {
+            ok: false,
+            error: error instanceof Error ? error.message : String(error),
+          };
+        }
+      },
+
+      getClient: (accountId) => activeClients.get(accountId),
+      setClient: (accountId, client) => activeClients.set(accountId, client),
+      removeClient: (accountId) => activeClients.delete(accountId),
+      setSessionWebhook: (conversationId, webhook) =>
+        sessionWebhooks.set(conversationId, webhook),
+      getSessionWebhook: (conversationId) => sessionWebhooks.get(conversationId),
+    },
+  },
+  logging: {
+    shouldLogVerbose: () => process.env.DEBUG === "true",
+  },
+};
+
+let runtimeInstance: DingTalkRuntime | null = null;
+
+export function getDingTalkRuntime(): DingTalkRuntime {
+  if (!runtimeInstance) {
+    runtimeInstance = dingtalkRuntime;
+  }
+  return runtimeInstance;
+}
+
+export function setDingTalkRuntime(runtime: DingTalkRuntime): void {
+  runtimeInstance = runtime;
+}

package/src/schema.ts

@@ -0,0 +1,316 @@
+import type { z } from "zod";
+
+// Channel ID
+export const CHANNEL_ID = "moltbot-dingtalk-stream";
+export const DEFAULT_ACCOUNT_ID = "default";
+
+// DingTalk account configuration interface
+export interface DingTalkAccountConfig {
+  enabled?: boolean;
+  clientId?: string;
+  clientSecret?: string;
+  webhookUrl?: string;
+  name?: string;
+  // Group settings
+  groupPolicy?: "open" | "allowlist";
+  requireMention?: boolean;
+  // DM settings
+  dm?: {
+    policy?: "open" | "pairing" | "allowlist";
+    allowFrom?: string[];
+  };
+}
+
+// Resolved account with computed fields
+export interface ResolvedDingTalkAccount {
+  accountId: string;
+  name?: string;
+  enabled: boolean;
+  configured: boolean;
+  clientId: string;
+  clientSecret: string;
+  tokenSource: "config" | "env" | "none";
+  config: DingTalkAccountConfig;
+}
+
+// Channel configuration interface
+export interface DingTalkChannelConfig {
+  enabled?: boolean;
+  clientId?: string;
+  clientSecret?: string;
+  webhookUrl?: string;
+  name?: string;
+  groupPolicy?: "open" | "allowlist";
+  requireMention?: boolean;
+  dm?: {
+    policy?: "open" | "pairing" | "allowlist";
+    allowFrom?: string[];
+  };
+  accounts?: Record<string, DingTalkAccountConfig>;
+}
+
+// Full config interface
+export interface ClawdbotConfig {
+  channels?: {
+    [CHANNEL_ID]?: DingTalkChannelConfig;
+    defaults?: {
+      groupPolicy?: "open" | "allowlist";
+    };
+    [key: string]: unknown;
+  };
+  [key: string]: unknown;
+}
+
+// Config schema for validation
+export const DingTalkConfigSchema = {
+  type: "object" as const,
+  properties: {
+    enabled: { type: "boolean" as const },
+    clientId: { type: "string" as const },
+    clientSecret: { type: "string" as const },
+    webhookUrl: { type: "string" as const },
+    name: { type: "string" as const },
+    groupPolicy: { type: "string" as const, enum: ["open", "allowlist"] },
+    requireMention: { type: "boolean" as const },
+    dm: {
+      type: "object" as const,
+      properties: {
+        policy: { type: "string" as const, enum: ["open", "pairing", "allowlist"] },
+        allowFrom: { type: "array" as const, items: { type: "string" as const } },
+      },
+    },
+    accounts: {
+      type: "object" as const,
+      additionalProperties: {
+        type: "object" as const,
+        properties: {
+          enabled: { type: "boolean" as const },
+          clientId: { type: "string" as const },
+          clientSecret: { type: "string" as const },
+          webhookUrl: { type: "string" as const },
+          name: { type: "string" as const },
+        },
+        required: ["clientId", "clientSecret"],
+      },
+    },
+  },
+};
+
+// Helper functions
+export function listDingTalkAccountIds(cfg: ClawdbotConfig): string[] {
+  const channelConfig = cfg.channels?.[CHANNEL_ID];
+  if (!channelConfig) return [];
+
+  const accountIds: string[] = [];
+
+  // Check for top-level (default) account
+  if (channelConfig.clientId && channelConfig.clientSecret) {
+    accountIds.push(DEFAULT_ACCOUNT_ID);
+  }
+
+  // Check for named accounts
+  const accounts = channelConfig.accounts;
+  if (accounts) {
+    for (const id of Object.keys(accounts)) {
+      if (id !== DEFAULT_ACCOUNT_ID || !accountIds.includes(DEFAULT_ACCOUNT_ID)) {
+        accountIds.push(id);
+      }
+    }
+  }
+
+  return accountIds;
+}
+
+export function resolveDingTalkAccount(opts: {
+  cfg: ClawdbotConfig;
+  accountId?: string;
+}): ResolvedDingTalkAccount {
+  const { cfg, accountId = DEFAULT_ACCOUNT_ID } = opts;
+  const channelConfig = cfg.channels?.[CHANNEL_ID];
+
+  // Try to get account config
+  let accountConfig: DingTalkAccountConfig | undefined;
+  let tokenSource: "config" | "env" | "none" = "none";
+
+  if (accountId === DEFAULT_ACCOUNT_ID) {
+    // For default account, check top-level first, then accounts.default
+    if (channelConfig?.clientId && channelConfig?.clientSecret) {
+      accountConfig = {
+        enabled: channelConfig.enabled,
+        clientId: channelConfig.clientId,
+        clientSecret: channelConfig.clientSecret,
+        webhookUrl: channelConfig.webhookUrl,
+        name: channelConfig.name,
+        groupPolicy: channelConfig.groupPolicy,
+        requireMention: channelConfig.requireMention,
+        dm: channelConfig.dm,
+      };
+      tokenSource = "config";
+    } else if (channelConfig?.accounts?.[DEFAULT_ACCOUNT_ID]) {
+      accountConfig = channelConfig.accounts[DEFAULT_ACCOUNT_ID];
+      tokenSource = "config";
+    } else if (process.env.DINGTALK_CLIENT_ID && process.env.DINGTALK_CLIENT_SECRET) {
+      accountConfig = {
+        enabled: true,
+        clientId: process.env.DINGTALK_CLIENT_ID,
+        clientSecret: process.env.DINGTALK_CLIENT_SECRET,
+        webhookUrl: process.env.DINGTALK_WEBHOOK_URL,
+      };
+      tokenSource = "env";
+    }
+  } else {
+    // Named account
+    accountConfig = channelConfig?.accounts?.[accountId];
+    if (accountConfig) {
+      tokenSource = "config";
+    }
+  }
+
+  const config = accountConfig || { clientId: "", clientSecret: "" };
+
+  return {
+    accountId,
+    name: config.name,
+    enabled: config.enabled ?? true,
+    configured: Boolean(config.clientId?.trim() && config.clientSecret?.trim()),
+    clientId: config.clientId || "",
+    clientSecret: config.clientSecret || "",
+    tokenSource,
+    config,
+  };
+}
+
+export function resolveDefaultDingTalkAccountId(cfg: ClawdbotConfig): string {
+  const accountIds = listDingTalkAccountIds(cfg);
+  return accountIds.includes(DEFAULT_ACCOUNT_ID)
+    ? DEFAULT_ACCOUNT_ID
+    : accountIds[0] || DEFAULT_ACCOUNT_ID;
+}
+
+export function normalizeAccountId(accountId?: string): string {
+  if (!accountId || accountId === "default" || accountId === "") {
+    return DEFAULT_ACCOUNT_ID;
+  }
+  return accountId.toLowerCase().replace(/[^a-z0-9_-]/g, "_");
+}
+
+export function setAccountEnabledInConfig(opts: {
+  cfg: ClawdbotConfig;
+  accountId: string;
+  enabled: boolean;
+}): ClawdbotConfig {
+  const { cfg, accountId, enabled } = opts;
+  const channelConfig = cfg.channels?.[CHANNEL_ID] || {};
+
+  if (accountId === DEFAULT_ACCOUNT_ID && channelConfig.clientId) {
+    // Top-level default account
+    return {
+      ...cfg,
+      channels: {
+        ...cfg.channels,
+        [CHANNEL_ID]: {
+          ...channelConfig,
+          enabled,
+        },
+      },
+    };
+  }
+
+  // Named account
+  return {
+    ...cfg,
+    channels: {
+      ...cfg.channels,
+      [CHANNEL_ID]: {
+        ...channelConfig,
+        accounts: {
+          ...channelConfig.accounts,
+          [accountId]: {
+            ...channelConfig.accounts?.[accountId],
+            enabled,
+          },
+        },
+      },
+    },
+  };
+}
+
+export function deleteAccountFromConfig(opts: {
+  cfg: ClawdbotConfig;
+  accountId: string;
+}): ClawdbotConfig {
+  const { cfg, accountId } = opts;
+  const channelConfig = cfg.channels?.[CHANNEL_ID];
+
+  if (!channelConfig) return cfg;
+
+  if (accountId === DEFAULT_ACCOUNT_ID && channelConfig.clientId) {
+    // Remove top-level credentials
+    const { clientId, clientSecret, webhookUrl, name, ...rest } = channelConfig;
+    return {
+      ...cfg,
+      channels: {
+        ...cfg.channels,
+        [CHANNEL_ID]: rest,
+      },
+    };
+  }
+
+  // Remove named account
+  if (channelConfig.accounts?.[accountId]) {
+    const { [accountId]: removed, ...remainingAccounts } = channelConfig.accounts;
+    return {
+      ...cfg,
+      channels: {
+        ...cfg.channels,
+        [CHANNEL_ID]: {
+          ...channelConfig,
+          accounts: remainingAccounts,
+        },
+      },
+    };
+  }
+
+  return cfg;
+}
+
+export function applyAccountNameToConfig(opts: {
+  cfg: ClawdbotConfig;
+  accountId: string;
+  name?: string;
+}): ClawdbotConfig {
+  const { cfg, accountId, name } = opts;
+  if (!name) return cfg;
+
+  const channelConfig = cfg.channels?.[CHANNEL_ID] || {};
+
+  if (accountId === DEFAULT_ACCOUNT_ID && channelConfig.clientId) {
+    return {
+      ...cfg,
+      channels: {
+        ...cfg.channels,
+        [CHANNEL_ID]: {
+          ...channelConfig,
+          name,
+        },
+      },
+    };
+  }
+
+  return {
+    ...cfg,
+    channels: {
+      ...cfg.channels,
+      [CHANNEL_ID]: {
+        ...channelConfig,
+        accounts: {
+          ...channelConfig.accounts,
+          [accountId]: {
+            ...channelConfig.accounts?.[accountId],
+            name,
+          },
+        },
+      },
+    },
+  };
+}

package/dist/clawdbot.plugin.json

@@ -1,59 +0,0 @@
-{
-    "id": "moltbot-dingtalk-stream",
-    "name": "DingTalk Stream Channel",
-    "version": "1.0.7",
-    "description": "Custom channel for integrating Moltbot with DingTalk (Stream Mode)",
-    "author": "Jack",
-    "license": "MIT",
-    "extensions": {
-        "channels": [
-            "./index.js"
-        ]
-    },
-    "channels": [
-        "moltbot-dingtalk-stream"
-    ],
-    "configSchema": {
-        "type": "object",
-        "properties": {
-            "channels": {
-                "type": "object",
-                "properties": {
-                    "moltbot-dingtalk-stream": {
-                        "type": "object",
-                        "properties": {
-                            "accounts": {
-                                "type": "object",
-                                "additionalProperties": {
-                                    "type": "object",
-                                    "properties": {
-                                        "enabled": {
-                                            "type": "boolean",
-                                            "description": "Whether this account is enabled"
-                                        },
-                                        "clientId": {
-                                            "type": "string",
-                                            "description": "AppKey from DingTalk developer console"
-                                        },
-                                        "clientSecret": {
-                                            "type": "string",
-                                            "description": "AppSecret from DingTalk developer console"
-                                        },
-                                        "webhookUrl": {
-                                            "type": "string",
-                                            "description": "Optional webhook URL for proactive messages"
-                                        }
-                                    },
-                                    "required": [
-                                        "clientId",
-                                        "clientSecret"
-                                    ]
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-}

package/dist/package.json

@@ -1,11 +0,0 @@
-{
-    "name": "moltbot-dingtalk-stream",
-    "version": "1.0.7",
-    "description": "DingTalk channel plugin for Clawdbot (Stream Mode)",
-    "main": "index.js",
-    "clawdbot": {
-        "extensions": [
-            "./index.js"
-        ]
-    }
-}