opencode-dingtalk 0.2.0

package/dist/dingtalk/dingtalk-api.js

@@ -0,0 +1,126 @@
+// DingTalk API 封装 - 使用 undici/fetch 实现
+// 替代 dingtalk-stream 和 axios
+const DINGTALK_API = "https://api.dingtalk.com";
+// ============ 工具函数 ============
+/**
+ * 带重试的 API 请求
+ */
+async function fetchWithRetry(url, options, maxRetries = 3) {
+    let lastError = null;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+            const response = await fetch(url, {
+                ...options,
+                headers: {
+                    "Content-Type": "application/json",
+                    ...options.headers,
+                },
+            });
+            const data = await response.json();
+            // 检查钉钉 API 错误码
+            if (data.errcode && data.errcode !== 0) {
+                const statusCode = response.status;
+                const isRetryable = data.errcode === 401 || // 未授权
+                    data.errcode === 429 || // 请求过多
+                    (data.errcode && data.errcode >= 500); // 服务端错误
+                if (isRetryable && attempt < maxRetries) {
+                    const delayMs = 100 * Math.pow(2, attempt - 1);
+                    await new Promise((resolve) => setTimeout(resolve, delayMs));
+                    continue;
+                }
+                throw new Error(`DingTalk API error: ${data.errmsg || data.errcode}`);
+            }
+            return data;
+        }
+        catch (err) {
+            lastError = err instanceof Error ? err : new Error(String(err));
+            // 网络错误时重试
+            if (attempt < maxRetries) {
+                const delayMs = 100 * Math.pow(2, attempt - 1);
+                await new Promise((resolve) => setTimeout(resolve, delayMs));
+            }
+        }
+    }
+    throw lastError || new Error("Fetch exhausted without returning");
+}
+// ============ 公开 API ============
+/**
+ * 获取钉钉 access_token
+ */
+export async function getAccessToken(clientId, clientSecret) {
+    const url = `${DINGTALK_API}/v1.0/oauth2/accessToken`;
+    const body = {
+        appKey: clientId,
+        appSecret: clientSecret,
+    };
+    const result = await fetchWithRetry(url, {
+        method: "POST",
+        body: JSON.stringify(body),
+    });
+    return result.accessToken;
+}
+/**
+ * 发送文本消息
+ */
+export async function sendTextMessage(webhook, content) {
+    const payload = {
+        msgtype: "text",
+        text: { content },
+    };
+    await fetchWithRetry(webhook, {
+        method: "POST",
+        body: JSON.stringify(payload),
+    });
+}
+/**
+ * 发送 Markdown 消息
+ */
+export async function sendMarkdownMessage(webhook, title, text) {
+    const payload = {
+        msgtype: "markdown",
+        markdown: { title, text },
+    };
+    await fetchWithRetry(webhook, {
+        method: "POST",
+        body: JSON.stringify(payload),
+    });
+}
+/**
+ * 发送卡片消息
+ */
+export async function sendCardMessage(webhook, cardTemplateId, cardData) {
+    const payload = {
+        msgtype: "interactive_card",
+        interactive_card: {
+            card_template_id: cardTemplateId,
+            card_data: cardData,
+        },
+    };
+    await fetchWithRetry(webhook, {
+        method: "POST",
+        body: JSON.stringify(payload),
+    });
+}
+/**
+ * 发送卡片交互回调响应
+ */
+export async function sendCardCallback(accessToken, callbackId, responseData) {
+    const url = `${DINGTALK_API}/v1.0/card/streaming?access_token=${accessToken}`;
+    const streamBody = {
+        callbackId,
+        responseData,
+    };
+    await fetchWithRetry(url, {
+        method: "PUT",
+        body: JSON.stringify(streamBody),
+    });
+}
+/**
+ * 发送消息到群聊 webhook
+ */
+export async function sendToConversation(webhook, message) {
+    await fetchWithRetry(webhook, {
+        method: "POST",
+        body: JSON.stringify(message),
+    });
+}

package/dist/dingtalk/dingtalk-client.js

@@ -0,0 +1,390 @@
+/**
+ * DingTalk Stream Client - 基于 undici 的实现
+ *
+ * 移除了 dingtalk-stream SDK（CJS包问题），使用 undici 重写
+ * 保留了与原 DWClient 相同的接口
+ */
+import EventEmitter from "events";
+import { request, WebSocket as UndiciWebSocket } from "undici";
+import { EventAck } from "./types.js";
+import { logger } from "../logger.js";
+const GATEWAY_URL = "https://api.dingtalk.com/v1.0/gateway/connections/open";
+const GET_TOKEN_URL = "https://oapi.dingtalk.com/gettoken";
+export { GATEWAY_URL, GET_TOKEN_URL };
+export { TOPIC_ROBOT, EventAck } from "./types.js";
+const defaultConfig = {
+    clientId: "",
+    clientSecret: "",
+    keepAlive: false,
+    debug: false,
+    ua: "",
+    endpoint: "",
+    access_token: "",
+    autoReconnect: true,
+    subscriptions: [{ type: "EVENT", topic: "*" }],
+};
+export class DingTalkClient extends EventEmitter {
+    debug = false;
+    connected = false;
+    registered = false;
+    reconnecting = false;
+    userDisconnect = false;
+    reconnectBaseInterval = 1000;
+    reconnectMaxInterval = 60000;
+    reconnectAttempts = 0;
+    heartbeat_interval = 8000;
+    heartbeatIntervalId;
+    reconnectTimerId;
+    isConnecting = false;
+    sslopts = { rejectUnauthorized: true };
+    config;
+    socket;
+    dw_url;
+    isAlive = false;
+    onEventReceived = () => ({
+        status: EventAck.SUCCESS,
+    });
+    constructor(opts) {
+        super();
+        this.config = {
+            ...defaultConfig,
+            ...opts,
+        };
+        if (!this.config.clientId || !this.config.clientSecret) {
+            throw new Error("clientId or clientSecret is null");
+        }
+        if (this.config.debug !== undefined) {
+            this.debug = this.config.debug;
+        }
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+    printDebug(msg) {
+        logger.debug("[opencode-dingtalk]", msg);
+    }
+    registerAllEventListener(onEventReceived) {
+        this.onEventReceived = onEventReceived;
+        return this;
+    }
+    registerCallbackListener(eventId, callback) {
+        if (!eventId || !callback) {
+            throw new Error("registerCallbackListener: eventId and callback must be defined");
+        }
+        if (!this.config.subscriptions.find((x) => x.topic === eventId && x.type === "CALLBACK")) {
+            this.config.subscriptions.push({
+                type: "CALLBACK",
+                topic: eventId,
+            });
+        }
+        this.on(eventId, callback);
+        return this;
+    }
+    async getAccessToken() {
+        const url = `${GET_TOKEN_URL}?appkey=${this.config.clientId}&appsecret=${this.config.clientSecret}`;
+        const response = await request(url, {
+            method: "GET",
+            headers: { Accept: "application/json" },
+        });
+        if (response.statusCode === 200) {
+            const data = (await response.body.json());
+            if (data.access_token) {
+                this.config.access_token = data.access_token;
+                return data.access_token;
+            }
+        }
+        throw new Error("getAccessToken: get access_token failed");
+    }
+    async getEndpoint() {
+        this.printDebug("get connect endpoint by config");
+        this.printDebug(this.config);
+        logger.log("[opencode-dingtalk] Calling DingTalk gateway:", GATEWAY_URL);
+        logger.log("[opencode-dingtalk] Request body:", JSON.stringify({
+            clientId: this.config.clientId,
+            clientSecret: this.config.clientSecret,
+            ua: this.config.ua,
+            subscriptions: this.config.subscriptions,
+        }, null, 2));
+        const response = await request(GATEWAY_URL, {
+            method: "POST",
+            headers: {
+                Accept: "application/json",
+                "Content-Type": "application/json",
+                "User-Agent": "opencode-dingtalk/0.2.0",
+            },
+            body: JSON.stringify({
+                clientId: this.config.clientId,
+                clientSecret: this.config.clientSecret,
+                ua: this.config.ua,
+                subscriptions: this.config.subscriptions,
+            }),
+        });
+        const data = (await response.body.json());
+        logger.log("[opencode-dingtalk] Gateway response status:", response.statusCode);
+        logger.log("[opencode-dingtalk] Gateway response data:", JSON.stringify(data, null, 2));
+        this.printDebug("res.data " + JSON.stringify(data));
+        if (data.endpoint && data.ticket) {
+            this.config.endpoint = data.endpoint;
+            this.dw_url = `${data.endpoint}?ticket=${data.ticket}`;
+            logger.log("[opencode-dingtalk] WebSocket URL:", this.dw_url);
+            return this;
+        }
+        else {
+            throw new Error("build: get endpoint failed");
+        }
+    }
+    cleanup() {
+        if (this.heartbeatIntervalId) {
+            clearInterval(this.heartbeatIntervalId);
+            this.heartbeatIntervalId = undefined;
+        }
+        if (this.socket) {
+            this.socket.close();
+            this.socket = undefined;
+        }
+    }
+    scheduleReconnect() {
+        if (!this.config.autoReconnect ||
+            this.userDisconnect ||
+            this.isConnecting) {
+            return;
+        }
+        const delay = Math.min(this.reconnectBaseInterval * Math.pow(2, this.reconnectAttempts) +
+            Math.random() * 1000, this.reconnectMaxInterval);
+        this.reconnecting = true;
+        this.printDebug("Reconnecting in " +
+            (delay / 1000).toFixed(1) +
+            " seconds... (attempt " +
+            (this.reconnectAttempts + 1) +
+            ")");
+        if (this.reconnectTimerId) {
+            clearTimeout(this.reconnectTimerId);
+        }
+        this.reconnectTimerId = setTimeout(() => {
+            this.reconnectTimerId = undefined;
+            this.connect();
+        }, delay);
+    }
+    async _connect() {
+        return new Promise((resolve, reject) => {
+            if (!this.dw_url) {
+                reject(new Error("dw_url is not defined"));
+                return;
+            }
+            this.printDebug("Connecting to dingtalk websocket @ " + this.dw_url);
+            try {
+                this.socket = new UndiciWebSocket(this.dw_url);
+            }
+            catch (err) {
+                this.printDebug("WebSocket constructor error");
+                logger.warn("[opencode-dingtalk] ERROR", err);
+                reject(err);
+                return;
+            }
+            let settled = false;
+            this.socket.addEventListener("open", () => {
+                this.connected = true;
+                this.reconnectAttempts = 0;
+                logger.log("[opencode-dingtalk] connect success");
+                if (this.config.keepAlive) {
+                    this.isAlive = true;
+                    this.heartbeatIntervalId = setInterval(() => {
+                        if (this.isAlive === false) {
+                            logger.error("[opencode-dingtalk] TERMINATE SOCKET: Ping Pong does not transfer heartbeat within heartbeat interval");
+                            this.socket?.close();
+                            return;
+                        }
+                        this.isAlive = false;
+                    }, this.heartbeat_interval);
+                }
+                settled = true;
+                resolve();
+            });
+            this.socket.addEventListener("pong", () => {
+                this.heartbeat();
+            });
+            this.socket.addEventListener("message", (event) => {
+                const messageStr = typeof event.data === "string" ? event.data : event.data.toString();
+                this.printDebug("[DEBUG] Raw message received: " + messageStr.slice(0, 200));
+                this.onDownStream(messageStr);
+            });
+            this.socket.addEventListener("close", () => {
+                this.printDebug("Socket closed");
+                this.connected = false;
+                this.registered = false;
+                if (this.heartbeatIntervalId) {
+                    clearInterval(this.heartbeatIntervalId);
+                    this.heartbeatIntervalId = undefined;
+                }
+                if (settled) {
+                    this.scheduleReconnect();
+                }
+            });
+            this.socket.addEventListener("error", (err) => {
+                this.printDebug("SOCKET ERROR");
+                logger.warn("[opencode-dingtalk] ERROR", err);
+                this.socket?.close();
+                if (!settled) {
+                    settled = true;
+                    reject(err);
+                }
+            });
+        });
+    }
+    async connect() {
+        logger.log("[opencode-dingtalk] connect() called");
+        if (this.isConnecting) {
+            this.printDebug("connect() already in progress, skipping");
+            return;
+        }
+        this.userDisconnect = false;
+        this.isConnecting = true;
+        try {
+            logger.log("[opencode-dingtalk] calling cleanup()");
+            this.cleanup();
+            logger.log("[opencode-dingtalk] calling getEndpoint()");
+            await this.getEndpoint();
+            logger.log("[opencode-dingtalk] getEndpoint() completed, dw_url:", this.dw_url);
+            if (this.userDisconnect)
+                return;
+            logger.log("[opencode-dingtalk] calling _connect()");
+            await this._connect();
+            logger.log("[opencode-dingtalk] _connect() completed");
+        }
+        catch (err) {
+            logger.error("[opencode-dingtalk] Connect failed:", err);
+            this.printDebug("Connect failed: " + (err instanceof Error ? err.message : String(err)));
+            if (!this.userDisconnect) {
+                this.reconnectAttempts++;
+                this.isConnecting = false;
+                this.scheduleReconnect();
+            }
+            return;
+        }
+        finally {
+            this.isConnecting = false;
+        }
+    }
+    disconnect() {
+        logger.log("[opencode-dingtalk] Disconnecting.");
+        this.userDisconnect = true;
+        if (this.reconnectTimerId) {
+            clearTimeout(this.reconnectTimerId);
+            this.reconnectTimerId = undefined;
+        }
+        this.reconnecting = false;
+        this.reconnectAttempts = 0;
+        this.cleanup();
+        this.connected = false;
+        this.registered = false;
+    }
+    heartbeat() {
+        this.isAlive = true;
+        this.printDebug("CLIENT-SIDE HEARTBEAT");
+    }
+    onDownStream(data) {
+        this.printDebug("[DEBUG] Received message from dingtalk websocket server");
+        this.printDebug("[DEBUG] Message length: " + data.length);
+        try {
+            const msg = JSON.parse(data);
+            this.printDebug("[DEBUG] Parsed message: " + JSON.stringify(msg));
+            this.printDebug("[DEBUG] Message type: " + msg.type);
+            switch (msg.type) {
+                case "SYSTEM":
+                    this.onSystem(msg);
+                    break;
+                case "EVENT":
+                    this.onEvent(msg);
+                    break;
+                case "CALLBACK":
+                    this.onCallback(msg);
+                    break;
+                default:
+                    this.printDebug("[DEBUG] Unknown message type: " + msg.type);
+            }
+        }
+        catch (err) {
+            this.printDebug("Failed to parse message: " + err);
+        }
+    }
+    onSystem(downstream) {
+        this.printDebug("[DEBUG] System message received, topic: " + downstream.headers.topic);
+        switch (downstream.headers.topic) {
+            case "CONNECTED": {
+                this.printDebug("CONNECTED");
+                this.emit("connected", downstream);
+                break;
+            }
+            case "REGISTERED": {
+                this.printDebug("REGISTERED");
+                this.registered = true;
+                this.reconnecting = false;
+                this.emit("registered", downstream);
+                break;
+            }
+            case "disconnect": {
+                this.connected = false;
+                this.registered = false;
+                this.emit("disconnected", downstream);
+                break;
+            }
+            case "KEEPALIVE": {
+                this.heartbeat();
+                break;
+            }
+            case "ping": {
+                this.printDebug("PING");
+                this.socket?.send(JSON.stringify({
+                    code: 200,
+                    headers: downstream.headers,
+                    message: "OK",
+                    data: downstream.data,
+                }));
+                break;
+            }
+        }
+    }
+    onEvent(message) {
+        this.printDebug("received event, message=" + JSON.stringify(message));
+        const ackData = this.onEventReceived(message);
+        this.socket?.send(JSON.stringify({
+            code: 200,
+            headers: {
+                contentType: "application/json",
+                messageId: message.headers.messageId,
+            },
+            message: "OK",
+            data: JSON.stringify(ackData),
+        }));
+    }
+    onCallback(message) {
+        this.printDebug("[DEBUG] Callback message received, topic: " + message.headers.topic);
+        this.printDebug("[DEBUG] Full callback message: " + JSON.stringify(message));
+        this.emit(message.headers.topic, message);
+    }
+    send(messageId, value) {
+        if (!messageId) {
+            throw new Error("send: messageId must be defined");
+        }
+        const msg = {
+            code: 200,
+            headers: {
+                contentType: "application/json",
+                messageId: messageId,
+            },
+            message: "OK",
+            data: JSON.stringify(value),
+        };
+        this.socket?.send(JSON.stringify(msg));
+    }
+    socketCallBackResponse(messageId, result) {
+        this.send(messageId, { response: result });
+    }
+    removeListener(event, handler) {
+        return super.removeListener(event, handler);
+    }
+    removeAllListeners() {
+        super.removeAllListeners();
+        return this;
+    }
+}

package/dist/dingtalk/types.js

@@ -0,0 +1,8 @@
+export var EventAck;
+(function (EventAck) {
+    EventAck["SUCCESS"] = "SUCCESS";
+    EventAck["LATER"] = "LATER";
+})(EventAck || (EventAck = {}));
+export const TOPIC_ROBOT = '/v1.0/im/bot/messages/get';
+export const TOPIC_CARD = '/v1.0/card/instances/callback';
+export const TOPIC_AI_GRAPH_API = '/v1.0/graph/api/invoke';