@huo15/dingtalk-connector-pro 1.0.4 → 1.0.7

package/src/services/messaging.ts

@@ -3,18 +3,18 @@
  * 支持 AI Card 流式响应、普通消息、主动消息
  */
 
-import type { DingtalkConfig } from "../types/index.ts";
-import { DINGTALK_API, getAccessToken, getOapiAccessToken } from "../utils/index.ts";
-import { dingtalkHttp, dingtalkOapiHttp } from "../utils/http-client.ts";
-import { MEDIA_MSG_TYPES } from "../utils/constants.ts";
-import { createLoggerFromConfig } from "../utils/logger.ts";
+import type { DingtalkConfig } from "../types/index.js";
+import { DINGTALK_API, getAccessToken, getOapiAccessToken } from "../utils/index.js";
+import { dingtalkHttp, dingtalkOapiHttp } from "../utils/http-client.js";
+import { MEDIA_MSG_TYPES } from "../utils/constants.js";
+import { createLoggerFromConfig } from "../utils/logger.js";
 import {
   processLocalImages,
   processVideoMarkers,
   processAudioMarkers,
   processFileMarkers,
   uploadMediaToDingTalk,
-} from "./media.ts";
+} from "./media.js";
 // ✅ 导入 AI Card 相关函数，避免重复实现
 import {
   createAICardForTarget,
@@ -22,7 +22,7 @@ import {
   finishAICard,
   type AICardInstance,
   type AICardTarget,
-} from "./messaging/card.ts";
+} from "./messaging/card.js";
 
 // ============ 常量 ============
 // 注意：AI Card 相关的类型和函数已移至 ./messaging/card.ts，通过上方 import 引入
@@ -762,7 +762,7 @@ export async function sendMediaToDingTalk(params: {
     };
 
     // 使用 sendFileProactive 发送文件消息
-    const { sendFileProactive } = await import("./media.ts");
+    const { sendFileProactive } = await import("./media.js");
     await sendFileProactive(config, targetParam, fileInfo, uploadResult.mediaId, log);
 
     // 返回成功结果

package/src/targets.js

@@ -0,0 +1,38 @@
+function stripProviderPrefix(raw) {
+    return raw.replace(/^(dingtalk|dd|ding):/i, "").trim();
+}
+export function normalizeDingtalkTarget(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return null;
+    }
+    const withoutProvider = stripProviderPrefix(trimmed);
+    const lowered = withoutProvider.toLowerCase();
+    if (lowered.startsWith("user:")) {
+        return withoutProvider.slice("user:".length).trim() || null;
+    }
+    if (lowered.startsWith("group:")) {
+        return withoutProvider.slice("group:".length).trim() || null;
+    }
+    return withoutProvider;
+}
+export function formatDingtalkTarget(id, type) {
+    const trimmed = id.trim();
+    if (type === "group") {
+        return `group:${trimmed}`;
+    }
+    if (type === "user") {
+        return `user:${trimmed}`;
+    }
+    return trimmed;
+}
+export function looksLikeDingtalkId(raw) {
+    const trimmed = stripProviderPrefix(raw.trim());
+    if (!trimmed) {
+        return false;
+    }
+    if (/^(user|group):/i.test(trimmed)) {
+        return true;
+    }
+    return true;
+}

package/src/targets.ts

@@ -1,4 +1,4 @@
-import type { DingtalkMessageContext } from "./types/index.ts";
+import type { DingtalkMessageContext } from "./types/index.js";
 
 function stripProviderPrefix(raw: string): string {
   return raw.replace(/^(dingtalk|dd|ding):/i, "").trim();

package/src/types/index.js

@@ -0,0 +1 @@
+export {};

package/src/types/index.ts

@@ -11,7 +11,7 @@ import type {
   DingtalkGroupSchema,
   DingtalkAccountConfigSchema,
   z,
-} from "../config/schema.ts";
+} from "../config/schema.js";
 
 export type DingtalkConfig = z.infer<typeof DingtalkConfigSchema>;
 export type DingtalkGroupConfig = z.infer<typeof DingtalkGroupSchema>;

package/src/utils/agent.js

@@ -0,0 +1,55 @@
+/**
+ * Agent 相关工具函数
+ *
+ * 提供 Agent 配置解析、工作空间路径解析等功能
+ */
+import * as os from "node:os";
+import * as path from "node:path";
+/**
+ * 解析 Agent 工作空间路径
+ *
+ * 参考 OpenClaw SDK 的 resolveAgentWorkspaceDir 实现逻辑：
+ * 1. 优先从 agents.list 中查找用户配置的 workspace
+ * 2. 如果没有配置，使用默认路径规则：
+ *    - 默认 Agent (main): ~/.openclaw/workspace
+ *    - 其他 Agent: ~/.openclaw/workspace-{agentId}
+ *
+ * @param cfg - OpenClaw 配置对象
+ * @param agentId - Agent ID
+ * @returns Agent 工作空间的绝对路径
+ *
+ * @example
+ * ```typescript
+ * // 用户自定义工作空间
+ * const cfg = {
+ *   agents: {
+ *     list: [{ id: 'bot1', workspace: '~/my-workspace' }]
+ *   }
+ * };
+ * resolveAgentWorkspaceDir(cfg, 'bot1'); // => '/Users/xxx/my-workspace'
+ *
+ * // 默认 Agent
+ * resolveAgentWorkspaceDir(cfg, 'main'); // => '/Users/xxx/.openclaw/workspace'
+ *
+ * // 其他 Agent
+ * resolveAgentWorkspaceDir(cfg, 'bot2'); // => '/Users/xxx/.openclaw/workspace-bot2'
+ * ```
+ */
+export function resolveAgentWorkspaceDir(cfg, agentId) {
+    // 1. 先从 agents.list 中查找配置的 workspace
+    const agentConfig = cfg.agents?.list?.find((a) => a.id === agentId);
+    if (agentConfig?.workspace) {
+        // 用户配置了自定义工作空间路径
+        // 支持 ~ 路径展开
+        return agentConfig.workspace.startsWith('~')
+            ? path.join(os.homedir(), agentConfig.workspace.slice(1))
+            : agentConfig.workspace;
+    }
+    // 2. 使用默认路径规则
+    if (agentId === 'main' || agentId === cfg.defaultAgent) {
+        // 默认 Agent 使用 ~/.openclaw/workspace
+        return path.join(os.homedir(), '.openclaw', 'workspace');
+    }
+    // 其他 Agent 使用 ~/.openclaw/workspace-{agentId}
+    return path.join(os.homedir(), '.openclaw', `workspace-${agentId}`);
+}

package/src/utils/async.js

@@ -0,0 +1,40 @@
+export async function raceWithTimeoutAndAbort(promise, opts) {
+    const { timeoutMs, abortSignal } = opts;
+    let timeoutId;
+    let abortHandler;
+    const timeoutOutcome = new Promise((resolve) => {
+        timeoutId = setTimeout(() => resolve({ kind: "timeout" }), timeoutMs);
+    });
+    const abortOutcome = abortSignal
+        ? new Promise((resolve) => {
+            if (abortSignal.aborted) {
+                resolve({ kind: "aborted" });
+                return;
+            }
+            abortHandler = () => resolve({ kind: "aborted" });
+            abortSignal.addEventListener("abort", abortHandler, { once: true });
+        })
+        : new Promise(() => { });
+    try {
+        const winner = await Promise.race([
+            promise.then((value) => ({ kind: "success", value })),
+            timeoutOutcome,
+            abortOutcome,
+        ]);
+        if (winner.kind === "success") {
+            return { status: "success", value: winner.value };
+        }
+        if (winner.kind === "timeout") {
+            return { status: "timeout" };
+        }
+        return { status: "aborted" };
+    }
+    finally {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+        if (abortSignal && abortHandler) {
+            abortSignal.removeEventListener("abort", abortHandler);
+        }
+    }
+}

package/src/utils/constants.js

@@ -0,0 +1,24 @@
+/**
+ * 常量定义模块
+ */
+/** 新会话触发命令 */
+export const NEW_SESSION_COMMANDS = ['/new', '/reset', '/clear', '新会话', '重新开始', '清空对话'];
+/**
+ * 媒体类消息类型集合。
+ *
+ * 这些消息类型需要通过钉钉原生消息 API 发送，不支持 AI Card 形式，
+ * 在 sendProactiveInternal 中会强制跳过 AI Card 路径。
+ */
+export const MEDIA_MSG_TYPES = new Set(['image', 'voice', 'file', 'video']);
+/**
+ * 队列繁忙时的即时 ACK 回复短语。
+ *
+ * 当消息入队时检测到上一条消息仍在处理中，立即从此列表中随机选取一条回复，
+ * 告知用户消息已收到并排队，避免用户以为 Bot 没有响应。
+ * 参考 delivery.rs 中 DINGTALK_ACK_PHRASES_BUSY_ZH_CN 的设计。
+ */
+export const QUEUE_BUSY_ACK_PHRASES = [
+    '上一条还没结束，这条我已经记下，稍后按顺序继续处理。',
+    '当前还在忙，你的新消息已经排队，上一条完成后我马上继续。',
+    '我这边还在处理上一条，这条已加入队列，完成后继续处理。',
+];

package/src/utils/http-client.js

@@ -0,0 +1,33 @@
+/**
+ * HTTP 客户端配置模块
+ *
+ * 提供统一的 axios 实例，用于钉钉 API 请求。
+ *
+ * 使用方式：
+ * ```typescript
+ * import { dingtalkHttp } from './utils/http-client.js';
+ *
+ * const response = await dingtalkHttp.post('/api/endpoint', data);
+ * ```
+ */
+import axios from 'axios';
+/** 钉钉专用 HTTP 客户端（30 秒超时） */
+export const dingtalkHttp = axios.create({
+    timeout: 30000,
+    headers: {
+        'Content-Type': 'application/json',
+    },
+});
+/** 钉钉 OAPI 专用 HTTP 客户端（60 秒超时，用于媒体上传等） */
+export const dingtalkOapiHttp = axios.create({
+    timeout: 60000,
+    headers: {
+        'Content-Type': 'application/json',
+    },
+});
+/** 文件上传专用 HTTP 客户端（120 秒超时，无 body 大小限制） */
+export const dingtalkUploadHttp = axios.create({
+    timeout: 120000,
+    maxContentLength: Infinity,
+    maxBodyLength: Infinity,
+});

package/src/utils/http-client.ts

@@ -5,7 +5,7 @@
  * 
  * 使用方式：
  * ```typescript
- * import { dingtalkHttp } from './utils/http-client.ts';
+ * import { dingtalkHttp } from './utils/http-client.js';
  * 
  * const response = await dingtalkHttp.post('/api/endpoint', data);
  * ```

package/src/utils/index.js

@@ -0,0 +1,7 @@
+/**
+ * 工具函数模块统一导出
+ */
+export * from './constants.js';
+export * from './token.js';
+export * from './session.js';
+export * from './logger.js';

package/src/utils/index.ts

@@ -2,7 +2,7 @@
  * 工具函数模块统一导出
  */
 
-export * from './constants.ts';
-export * from './token.ts';
-export * from './session.ts';
-export * from './logger.ts';
+export * from './constants.js';
+export * from './token.js';
+export * from './session.js';
+export * from './logger.js';

package/src/utils/logger.js

@@ -0,0 +1,76 @@
+/**
+ * 日志工具模块
+ * 根据 debug 配置控制日志输出
+ */
+/**
+ * 创建日志记录器
+ * @param debug - 是否启用 debug 模式
+ * @param prefix - 日志前缀
+ * @returns 日志记录器对象
+ */
+export function createLogger(debug = false, prefix = '') {
+    const logger = {
+        /**
+         * 打印 info 级别日志
+         * 仅在 debug 模式下输出
+         */
+        info(...args) {
+            if (debug) {
+                if (prefix) {
+                    console.log(`[${prefix}]`, ...args);
+                }
+                else {
+                    console.log(...args);
+                }
+            }
+        },
+        /**
+         * 打印 warn 级别日志
+         * 始终输出
+         */
+        warn(...args) {
+            if (prefix) {
+                console.warn(`[${prefix}]`, ...args);
+            }
+            else {
+                console.warn(...args);
+            }
+        },
+        /**
+         * 打印 error 级别日志
+         * 始终输出
+         */
+        error(...args) {
+            if (prefix) {
+                console.error(`[${prefix}]`, ...args);
+            }
+            else {
+                console.error(...args);
+            }
+        },
+        /**
+         * 打印 debug 级别日志
+         * 仅在 debug 模式下输出
+         */
+        debug(...args) {
+            if (debug) {
+                if (prefix) {
+                    console.log(`[DEBUG][${prefix}]`, ...args);
+                }
+                else {
+                    console.log('[DEBUG]', ...args);
+                }
+            }
+        },
+    };
+    return logger;
+}
+/**
+ * 从配置中创建日志记录器
+ * @param config - 包含 debug 配置的对象（可选）
+ * @param prefix - 日志前缀
+ * @returns 日志记录器对象
+ */
+export function createLoggerFromConfig(config, prefix = '') {
+    return createLogger(!!config?.debug, prefix);
+}

package/src/utils/session.js

@@ -0,0 +1,95 @@
+/**
+ * 会话管理模块
+ * 构建 OpenClaw 标准会话上下文
+ */
+import { NEW_SESSION_COMMANDS } from './constants.js';
+/**
+ * 构建 OpenClaw 标准会话上下文
+ * 遵循 OpenClaw session.dmScope 机制，让 Gateway 根据配置自动处理会话隔离
+ *
+ * @param sharedMemoryAcrossConversations - 是否在不同会话间共享记忆（默认 false）
+ *   - true: 所有会话共享记忆，使用 accountId 作为记忆标识
+ *   - false: 不同会话独立记忆，使用完整的 sessionContext 作为记忆标识
+ */
+export function buildSessionContext(params) {
+    const { accountId, senderId, senderName, conversationType, conversationId, groupSubject, separateSessionByConversation, groupSessionScope, sharedMemoryAcrossConversations, } = params;
+    const isDirect = conversationType === '1';
+    // peerId：真实的 peer 标识，不受任何会话隔离配置影响，专用于 bindings 路由匹配
+    // 群聊为 conversationId，单聊为 senderId，与配置中 match.peer.id 语义一致
+    const peerId = isDirect ? senderId : (conversationId || senderId);
+    // sharedMemoryAcrossConversations=true 时，所有会话共享记忆
+    // sessionPeerId 被设为 accountId 以合并记忆，peerId 仍保留真实 peer，供路由匹配使用
+    if (sharedMemoryAcrossConversations === true) {
+        return {
+            channel: 'dingtalk-connector',
+            accountId,
+            chatType: isDirect ? 'direct' : 'group',
+            peerId,
+            sessionPeerId: accountId, // 使用 accountId 作为 sessionPeerId，实现跨会话记忆共享
+            conversationId: isDirect ? undefined : conversationId,
+            senderName,
+            groupSubject: isDirect ? undefined : groupSubject,
+        };
+    }
+    // separateSessionByConversation=false 时，不区分单聊/群聊，按用户维度维护 session
+    if (separateSessionByConversation === false) {
+        return {
+            channel: 'dingtalk-connector',
+            accountId,
+            chatType: isDirect ? 'direct' : 'group',
+            peerId,
+            sessionPeerId: senderId, // 只用 senderId，不区分会话
+            conversationId: isDirect ? undefined : conversationId,
+            senderName,
+            groupSubject: isDirect ? undefined : groupSubject,
+        };
+    }
+    // 以下是 separateSessionByConversation=true（默认）的逻辑
+    if (isDirect) {
+        // 单聊：sessionPeerId 为发送者 ID，由 OpenClaw Gateway 根据 dmScope 配置处理
+        return {
+            channel: 'dingtalk-connector',
+            accountId,
+            chatType: 'direct',
+            peerId,
+            sessionPeerId: senderId,
+            senderName,
+        };
+    }
+    // 群聊：根据 groupSessionScope 配置决定会话隔离策略
+    if (groupSessionScope === 'group_sender') {
+        // 群内每个用户独立会话
+        return {
+            channel: 'dingtalk-connector',
+            accountId,
+            chatType: 'group',
+            peerId,
+            sessionPeerId: `${conversationId}:${senderId}`,
+            conversationId,
+            senderName,
+            groupSubject,
+        };
+    }
+    // 默认：整个群共享一个会话
+    return {
+        channel: 'dingtalk-connector',
+        accountId,
+        chatType: 'group',
+        peerId,
+        sessionPeerId: conversationId || senderId,
+        conversationId,
+        senderName,
+        groupSubject,
+    };
+}
+/**
+ * 检查消息是否是新会话命令
+ */
+export function normalizeSlashCommand(text) {
+    const trimmed = text.trim();
+    const lower = trimmed.toLowerCase();
+    if (NEW_SESSION_COMMANDS.some((cmd) => lower === cmd.toLowerCase())) {
+        return '/new';
+    }
+    return text;
+}

package/src/utils/session.ts

@@ -3,7 +3,7 @@
  * 构建 OpenClaw 标准会话上下文
  */
 
-import { NEW_SESSION_COMMANDS } from './constants.ts';
+import { NEW_SESSION_COMMANDS } from './constants.js';
 
 /** OpenClaw 标准会话上下文 */
 export interface SessionContext {

package/src/utils/token.js

@@ -0,0 +1,71 @@
+/**
+ * Access Token 管理模块
+ * 支持钉钉 API 和 OAPI 的 Token 获取和缓存
+ */
+import { dingtalkHttp, dingtalkOapiHttp } from './http-client.js';
+// ============ 常量 ============
+export const DINGTALK_API = 'https://api.dingtalk.com';
+export const DINGTALK_OAPI = 'https://oapi.dingtalk.com';
+/**
+ * 按 clientId 分桶缓存，避免多账号串 token。
+ */
+const apiTokenCache = new Map();
+const oapiTokenCache = new Map();
+function cacheKey(config) {
+    const clientId = String(config?.clientId ?? '').trim();
+    // 添加校验
+    if (!clientId) {
+        throw new Error('Invalid DingtalkConfig: clientId is required for token caching. ' +
+            'Please ensure your configuration includes a valid clientId.');
+    }
+    return clientId;
+}
+/**
+ * 获取钉钉 Access Token（新版 API）
+ */
+export async function getAccessToken(config) {
+    const now = Date.now();
+    const key = cacheKey(config);
+    const cached = apiTokenCache.get(key);
+    if (cached && cached.expiryMs > now + 60_000) {
+        return cached.token;
+    }
+    const response = await dingtalkHttp.post(`${DINGTALK_API}/v1.0/oauth2/accessToken`, {
+        appKey: config.clientId,
+        appSecret: config.clientSecret,
+    });
+    const token = response.data.accessToken;
+    const expireInSec = Number(response.data.expireIn ?? 0);
+    apiTokenCache.set(key, {
+        token,
+        expiryMs: now + expireInSec * 1000,
+    });
+    return token;
+}
+/**
+ * 获取钉钉 OAPI Access Token（旧版 API，用于媒体上传等）
+ */
+export async function getOapiAccessToken(config) {
+    try {
+        const now = Date.now();
+        const key = cacheKey(config);
+        const cached = oapiTokenCache.get(key);
+        if (cached && cached.expiryMs > now + 60_000) {
+            return cached.token;
+        }
+        const resp = await dingtalkOapiHttp.get(`${DINGTALK_OAPI}/gettoken`, {
+            params: { appkey: config.clientId, appsecret: config.clientSecret },
+        });
+        if (resp.data?.errcode === 0 && resp.data?.access_token) {
+            const token = String(resp.data.access_token);
+            // 钉钉返回 expires_in（秒），拿不到就按 2 小时兜底
+            const expiresInSec = Number(resp.data.expires_in ?? 7200);
+            oapiTokenCache.set(key, { token, expiryMs: now + expiresInSec * 1000 });
+            return token;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}

package/src/utils/token.ts

@@ -3,8 +3,8 @@
  * 支持钉钉 API 和 OAPI 的 Token 获取和缓存
  */
 
-import type { DingtalkConfig } from '../types/index.ts';
-import { dingtalkHttp, dingtalkOapiHttp } from './http-client.ts';
+import type { DingtalkConfig } from '../types/index.js';
+import { dingtalkHttp, dingtalkOapiHttp } from './http-client.js';
 
 // ============ 常量 ============