@soimy/dingtalk 3.6.2-beta.1 → 3.6.2

package/index.ts

@@ -1,18 +1,36 @@
 import { defineChannelPluginEntry, type OpenClawPluginApi } from "openclaw/plugin-sdk/core";
 import { readStringParam } from "openclaw/plugin-sdk/param-readers";
+import { getAccessToken } from "./src/auth";
 import { dingtalkPlugin } from "./src/channel";
-import { getConfig } from "./src/config";
-import { appendToDoc, createDoc, DocCreateAppendError, listDocs, searchDocs } from "./src/docs-service";
+import { getConfig, listDingTalkAccountIds, resolveDingTalkAccount } from "./src/config";
+import {
+  appendToDoc,
+  createDoc,
+  DocCreateAppendError,
+  listDocs,
+  searchDocs,
+} from "./src/docs-service";
 import { accumulateUsage } from "./src/run-usage-store";
 import { setDingTalkRuntime } from "./src/runtime";
+import { sendMessage } from "./src/send-service";
 
 type GatewayMethodContext = Pick<
   Parameters<Parameters<OpenClawPluginApi["registerGatewayMethod"]>[1]>[0],
-  "params" | "respond"
+  "context" | "params" | "respond"
 >;
 
+/**
+ * Register the canonical OpenClaw DingTalk docs RPC namespace.
+ *
+ * The `dingtalk-connector.docs.*` names below are compatibility aliases for
+ * existing connector-style Gateway callers that already use the
+ * `dingtalk-connector` prefix. They intentionally share the same handlers as
+ * `dingtalk.docs.*`; this plugin does not vendor or mirror a separate
+ * third-party connector implementation. New OpenClaw callers should prefer the
+ * canonical `dingtalk.docs.*` namespace.
+ */
 function registerDingTalkDocsGatewayMethods(api: OpenClawPluginApi): void {
-  api.registerGatewayMethod("dingtalk.docs.create", async ({ respond, params }: GatewayMethodContext) => {
+  const createHandler = async ({ respond, params }: GatewayMethodContext) => {
     const accountId = readStringParam(params, "accountId");
     const spaceId = readStringParam(params, "spaceId", { required: true });
     const title = readStringParam(params, "title", { required: true });
@@ -41,34 +59,221 @@ function registerDingTalkDocsGatewayMethods(api: OpenClawPluginApi): void {
       }
       throw error;
     }
-  });
+  };
 
-  api.registerGatewayMethod("dingtalk.docs.append", async ({ respond, params }: GatewayMethodContext) => {
+  const appendHandler = async ({ respond, params }: GatewayMethodContext) => {
     const accountId = readStringParam(params, "accountId");
     const docId = readStringParam(params, "docId", { required: true });
     const content = readStringParam(params, "content", { required: true, allowEmpty: false });
     const config = getConfig(api.config, accountId ?? undefined);
     const result = await appendToDoc(config, docId, content, api.logger);
     return respond(true, result);
-  });
+  };
 
-  api.registerGatewayMethod("dingtalk.docs.search", async ({ respond, params }: GatewayMethodContext) => {
+  const searchHandler = async ({ respond, params }: GatewayMethodContext) => {
     const accountId = readStringParam(params, "accountId");
     const keyword = readStringParam(params, "keyword", { required: true });
     const spaceId = readStringParam(params, "spaceId");
     const config = getConfig(api.config, accountId ?? undefined);
     const docs = await searchDocs(config, keyword, spaceId, api.logger);
     return respond(true, { docs });
-  });
+  };
 
-  api.registerGatewayMethod("dingtalk.docs.list", async ({ respond, params }: GatewayMethodContext) => {
+  const listHandler = async ({ respond, params }: GatewayMethodContext) => {
     const accountId = readStringParam(params, "accountId");
     const spaceId = readStringParam(params, "spaceId", { required: true });
     const parentId = readStringParam(params, "parentId");
     const config = getConfig(api.config, accountId ?? undefined);
     const docs = await listDocs(config, spaceId, parentId, api.logger);
     return respond(true, { docs });
-  });
+  };
+
+  api.registerGatewayMethod("dingtalk.docs.create", createHandler);
+  api.registerGatewayMethod("dingtalk.docs.append", appendHandler);
+  api.registerGatewayMethod("dingtalk.docs.search", searchHandler);
+  api.registerGatewayMethod("dingtalk.docs.list", listHandler);
+  api.registerGatewayMethod("dingtalk-connector.docs.create", createHandler);
+  api.registerGatewayMethod("dingtalk-connector.docs.append", appendHandler);
+  api.registerGatewayMethod("dingtalk-connector.docs.search", searchHandler);
+  api.registerGatewayMethod("dingtalk-connector.docs.list", listHandler);
+}
+
+function getContentParam(params: Record<string, unknown>): string | undefined {
+  return readStringParam(params, "content") ?? readStringParam(params, "message");
+}
+
+function getErrorMessage(error: unknown, fallback: string): string {
+  return error instanceof Error ? error.message : fallback;
+}
+
+function maskClientId(clientId: string | undefined): string | null {
+  if (!clientId) {
+    return null;
+  }
+  return clientId.length <= 4 ? "****" : `****${clientId.slice(-4)}`;
+}
+
+function isConnectorSendTarget(target: string): boolean {
+  return /^(user|group):\S+$/.test(target);
+}
+
+async function sendGatewayMessage(params: {
+  api: OpenClawPluginApi;
+  respond: GatewayMethodContext["respond"];
+  accountId?: string;
+  target: string;
+  content: string;
+  storePath?: string;
+  useAICard?: unknown;
+}) {
+  const config = getConfig(params.api.config, params.accountId);
+  const accountId = params.accountId ?? "default";
+  if (!config.clientId || !config.clientSecret) {
+    return params.respond(false, { error: "DingTalk not configured" });
+  }
+  let result: Awaited<ReturnType<typeof sendMessage>>;
+  try {
+    result = await sendMessage(config, params.target, params.content, {
+      log: params.api.logger,
+      accountId,
+      conversationId: params.target,
+      storePath: params.storePath,
+      forceMarkdown: params.useAICard === false,
+    });
+  } catch (error: unknown) {
+    const message = getErrorMessage(error, "send failed");
+    params.api.logger?.warn?.(`[DingTalk][GatewayRPC] send failed: ${message}`);
+    return params.respond(false, { error: message });
+  }
+  return params.respond(
+    result.ok,
+    result.ok
+      ? {
+          ok: true,
+          target: params.target,
+          messageId: result.messageId ?? null,
+          tracking: result.tracking ?? null,
+        }
+      : { error: result.error || "send failed" },
+  );
+}
+
+/**
+ * Register compatibility Gateway RPCs for connector-style DingTalk callers.
+ *
+ * Compatibility target: callers that address DingTalk through the historical
+ * `dingtalk-connector.*` Gateway namespace. The maintenance boundary is only
+ * this thin parameter/response adapter; canonical plugin behavior, auth, docs,
+ * sending, and persistence remain implemented by this repository's existing
+ * `dingtalk.*` services. Do not add connector-only behavior here unless it is
+ * also documented as part of this compatibility surface.
+ */
+function registerDingTalkConnectorCompatibilityGatewayMethods(api: OpenClawPluginApi): void {
+  api.registerGatewayMethod(
+    "dingtalk-connector.sendToUser",
+    async ({ context, respond, params }: GatewayMethodContext) => {
+      const accountId = readStringParam(params, "accountId");
+      const userId = readStringParam(params, "userId", { required: true });
+      const content = getContentParam(params);
+      if (!content) {
+        return respond(false, { error: "content or message is required" });
+      }
+      return sendGatewayMessage({
+        api,
+        respond,
+        accountId: accountId ?? undefined,
+        target: `user:${userId}`,
+        content,
+        storePath: context?.cronStorePath,
+        useAICard: params.useAICard,
+      });
+    },
+  );
+
+  api.registerGatewayMethod(
+    "dingtalk-connector.sendToGroup",
+    async ({ context, respond, params }: GatewayMethodContext) => {
+      const accountId = readStringParam(params, "accountId");
+      const openConversationId = readStringParam(params, "openConversationId", { required: true });
+      const content = getContentParam(params);
+      if (!content) {
+        return respond(false, { error: "content or message is required" });
+      }
+      return sendGatewayMessage({
+        api,
+        respond,
+        accountId: accountId ?? undefined,
+        target: `group:${openConversationId}`,
+        content,
+        storePath: context?.cronStorePath,
+        useAICard: params.useAICard,
+      });
+    },
+  );
+
+  api.registerGatewayMethod(
+    "dingtalk-connector.send",
+    async ({ context, respond, params }: GatewayMethodContext) => {
+      const accountId = readStringParam(params, "accountId");
+      const target = readStringParam(params, "target", { required: true });
+      const content = getContentParam(params);
+      if (!content) {
+        return respond(false, { error: "content or message is required" });
+      }
+      if (!isConnectorSendTarget(target)) {
+        return respond(false, { error: "target must start with user: or group:" });
+      }
+      return sendGatewayMessage({
+        api,
+        respond,
+        accountId: accountId ?? undefined,
+        target,
+        content,
+        storePath: context?.cronStorePath,
+        useAICard: params.useAICard,
+      });
+    },
+  );
+
+  api.registerGatewayMethod(
+    "dingtalk-connector.status",
+    async ({ respond }: GatewayMethodContext) => {
+      const accountIds = listDingTalkAccountIds(api.config);
+      const accounts = accountIds.length > 0 ? accountIds : ["default"];
+      return respond(true, {
+        channel: "dingtalk",
+        accounts: accounts.map((accountId) => {
+          const account = resolveDingTalkAccount(api.config, accountId);
+          return {
+            accountId,
+            configured: account.configured,
+            enabled: account.enabled !== false,
+            name: account.name ?? null,
+            clientId: maskClientId(account.clientId),
+          };
+        }),
+      });
+    },
+  );
+
+  api.registerGatewayMethod(
+    "dingtalk-connector.probe",
+    async ({ respond, params }: GatewayMethodContext) => {
+      const accountId = readStringParam(params, "accountId");
+      const config = getConfig(api.config, accountId ?? undefined);
+      if (!config.clientId || !config.clientSecret) {
+        return respond(false, { error: "DingTalk not configured" });
+      }
+      try {
+        await getAccessToken(config, api.logger);
+        return respond(true, { ok: true, clientId: maskClientId(config.clientId) });
+      } catch (error: unknown) {
+        const message = getErrorMessage(error, "probe failed");
+        api.logger?.warn?.(`[DingTalk][GatewayRPC] probe failed: ${message}`);
+        return respond(false, { error: message });
+      }
+    },
+  );
 }
 
 export { dingtalkPlugin } from "./src/channel";
@@ -82,11 +287,24 @@ export default defineChannelPluginEntry({
   setRuntime: setDingTalkRuntime,
   registerFull(api) {
     registerDingTalkDocsGatewayMethods(api);
+    registerDingTalkConnectorCompatibilityGatewayMethods(api);
 
-    api.on("llm_output", (event: { runId: string; usage?: { input?: number; output?: number; cacheRead?: number; cacheWrite?: number; total?: number } }) => {
-      if (event.usage) {
-        accumulateUsage(event.runId, event.usage);
-      }
-    });
+    api.on(
+      "llm_output",
+      (event: {
+        runId: string;
+        usage?: {
+          input?: number;
+          output?: number;
+          cacheRead?: number;
+          cacheWrite?: number;
+          total?: number;
+        };
+      }) => {
+        if (event.usage) {
+          accumulateUsage(event.runId, event.usage);
+        }
+      },
+    );
   },
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soimy/dingtalk",
-  "version": "3.6.2-beta.1",
+  "version": "3.6.2",
   "description": "DingTalk (钉钉) channel plugin for OpenClaw",
   "keywords": [
     "bot",