@huo15/dingtalk-connector-pro 1.0.0 → 1.0.2

package/src/targets.ts

@@ -1,45 +0,0 @@
-import type { DingtalkMessageContext } from "./types/index.ts";
-
-function stripProviderPrefix(raw: string): string {
-  return raw.replace(/^(dingtalk|dd|ding):/i, "").trim();
-}
-
-export function normalizeDingtalkTarget(raw: string): string | null {
-  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: string, type?: "user" | "group"): string {
-  const trimmed = id.trim();
-  if (type === "group") {
-    return `group:${trimmed}`;
-  }
-  if (type === "user") {
-    return `user:${trimmed}`;
-  }
-  return trimmed;
-}
-
-export function looksLikeDingtalkId(raw: string): boolean {
-  const trimmed = stripProviderPrefix(raw.trim());
-  if (!trimmed) {
-    return false;
-  }
-  if (/^(user|group):/i.test(trimmed)) {
-    return true;
-  }
-  return true;
-}

package/src/types/index.ts

@@ -1,59 +0,0 @@
-// 本地类型定义
-interface BaseProbeResult<T = any> {
-  ok: boolean;
-  error?: string;
-  data?: T;
-  [key: string]: any;
-}
-
-import type {
-  DingtalkConfigSchema,
-  DingtalkGroupSchema,
-  DingtalkAccountConfigSchema,
-  z,
-} from "../config/schema.ts";
-
-export type DingtalkConfig = z.infer<typeof DingtalkConfigSchema>;
-export type DingtalkGroupConfig = z.infer<typeof DingtalkGroupSchema>;
-export type DingtalkAccountConfig = z.infer<typeof DingtalkAccountConfigSchema>;
-
-export type DingtalkConnectionMode = "stream";
-
-export type DingtalkDefaultAccountSelectionSource =
-  | "explicit-default"
-  | "mapped-default"
-  | "fallback";
-export type DingtalkAccountSelectionSource = "explicit" | DingtalkDefaultAccountSelectionSource;
-
-export type ResolvedDingtalkAccount = {
-  accountId: string;
-  selectionSource: DingtalkAccountSelectionSource;
-  enabled: boolean;
-  configured: boolean;
-  name?: string;
-  clientId?: string;
-  clientSecret?: string;
-  /** Merged config (top-level defaults + account-specific overrides) */
-  config: DingtalkConfig;
-};
-
-export type DingtalkMessageContext = {
-  conversationId: string;
-  messageId: string;
-  senderId: string;
-  senderName?: string;
-  conversationType: "1" | "2"; // 1=单聊, 2=群聊
-  content: string;
-  contentType: string;
-  groupSubject?: string;
-};
-
-export type DingtalkSendResult = {
-  messageId: string;
-  conversationId: string;
-};
-
-export type DingtalkProbeResult = BaseProbeResult<string> & {
-  clientId?: string;
-  botName?: string;
-};

package/src/utils/agent.ts

@@ -1,63 +0,0 @@
-/**
- * Agent 相关工具函数
- * 
- * 提供 Agent 配置解析、工作空间路径解析等功能
- */
-import * as os from "node:os";
-import * as path from "node:path";
-import type { ClawdbotConfig } from "openclaw/plugin-sdk";
-
-/**
- * 解析 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: ClawdbotConfig,
-  agentId: string,
-): string {
-  // 1. 先从 agents.list 中查找配置的 workspace
-  const agentConfig = cfg.agents?.list?.find((a: any) => 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.ts

@@ -1,51 +0,0 @@
-export type RaceResult<T> =
-  | { status: "success"; value: T }
-  | { status: "timeout" }
-  | { status: "aborted" };
-
-export async function raceWithTimeoutAndAbort<T>(
-  promise: Promise<T>,
-  opts: { timeoutMs: number; abortSignal?: AbortSignal },
-): Promise<RaceResult<T>> {
-  const { timeoutMs, abortSignal } = opts;
-  let timeoutId: ReturnType<typeof setTimeout> | undefined;
-  let abortHandler: (() => void) | undefined;
-
-  const timeoutOutcome = new Promise<{ kind: "timeout" }>((resolve) => {
-    timeoutId = setTimeout(() => resolve({ kind: "timeout" }), timeoutMs);
-  });
-
-  const abortOutcome: Promise<{ kind: "aborted" }> | Promise<never> = abortSignal
-    ? new Promise<{ kind: "aborted" }>((resolve) => {
-        if (abortSignal.aborted) {
-          resolve({ kind: "aborted" });
-          return;
-        }
-        abortHandler = () => resolve({ kind: "aborted" });
-        abortSignal.addEventListener("abort", abortHandler, { once: true });
-      })
-    : new Promise<never>(() => {});
-
-  try {
-    const winner = await Promise.race([
-      promise.then((value) => ({ kind: "success" as const, 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.ts

@@ -1,27 +0,0 @@
-/**
- * 常量定义模块
- */
-
-/** 新会话触发命令 */
-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'] as const);
-
-/**
- * 队列繁忙时的即时 ACK 回复短语。
- *
- * 当消息入队时检测到上一条消息仍在处理中，立即从此列表中随机选取一条回复，
- * 告知用户消息已收到并排队，避免用户以为 Bot 没有响应。
- * 参考 delivery.rs 中 DINGTALK_ACK_PHRASES_BUSY_ZH_CN 的设计。
- */
-export const QUEUE_BUSY_ACK_PHRASES = [
-  '上一条还没结束，这条我已经记下，稍后按顺序继续处理。',
-  '当前还在忙，你的新消息已经排队，上一条完成后我马上继续。',
-  '我这边还在处理上一条，这条已加入队列，完成后继续处理。',
-] as const;

package/src/utils/http-client.ts

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

package/src/utils/index.ts

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

package/src/utils/logger.ts

@@ -1,78 +0,0 @@
-/**
- * 日志工具模块
- * 根据 debug 配置控制日志输出
- */
-
-/**
- * 创建日志记录器
- * @param debug - 是否启用 debug 模式
- * @param prefix - 日志前缀
- * @returns 日志记录器对象
- */
-export function createLogger(debug: boolean = false, prefix: string = '') {
-  const logger = {
-    /**
-     * 打印 info 级别日志
-     * 仅在 debug 模式下输出
-     */
-    info(...args: any[]) {
-      if (debug) {
-        if (prefix) {
-          console.log(`[${prefix}]`, ...args);
-        } else {
-          console.log(...args);
-        }
-      }
-    },
-
-    /**
-     * 打印 warn 级别日志
-     * 始终输出
-     */
-    warn(...args: any[]) {
-      if (prefix) {
-        console.warn(`[${prefix}]`, ...args);
-      } else {
-        console.warn(...args);
-      }
-    },
-
-    /**
-     * 打印 error 级别日志
-     * 始终输出
-     */
-    error(...args: any[]) {
-      if (prefix) {
-        console.error(`[${prefix}]`, ...args);
-      } else {
-        console.error(...args);
-      }
-    },
-
-    /**
-     * 打印 debug 级别日志
-     * 仅在 debug 模式下输出
-     */
-    debug(...args: any[]) {
-      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: { debug?: boolean } | undefined | null, prefix: string = '') {
-  return createLogger(!!config?.debug, prefix);
-}

package/src/utils/session.ts

@@ -1,147 +0,0 @@
-/**
- * 会话管理模块
- * 构建 OpenClaw 标准会话上下文
- */
-
-import { NEW_SESSION_COMMANDS } from './constants.ts';
-
-/** OpenClaw 标准会话上下文 */
-export interface SessionContext {
-  channel: 'dingtalk-connector';
-  accountId: string;
-  chatType: 'direct' | 'group';
-  /**
-   * 真实的 peer 标识，不受任何会话隔离配置影响。
-   * 群聊为 conversationId，单聊为 senderId。
-   * 与配置中 match.peer.id 语义一致，专用于 bindings 路由匹配。
-   */
-  peerId: string;
-  /**
-   * 用于 session/memory 隔离的 peer 标识（session 键的一部分）。
-   * 受 sharedMemoryAcrossConversations、separateSessionByConversation、groupSessionScope 等配置影响，
-   * 可能与 peerId 不同（如 sharedMemoryAcrossConversations=true 时被设为 accountId）。
-   * 注意：不要用此字段做 binding 路由匹配，应使用 peerId。
-   */
-  sessionPeerId: string;
-  conversationId?: string;
-  senderName?: string;
-  groupSubject?: string;
-}
-
-/**
- * 构建 OpenClaw 标准会话上下文
- * 遵循 OpenClaw session.dmScope 机制，让 Gateway 根据配置自动处理会话隔离
- * 
- * @param sharedMemoryAcrossConversations - 是否在不同会话间共享记忆（默认 false）
- *   - true: 所有会话共享记忆，使用 accountId 作为记忆标识
- *   - false: 不同会话独立记忆，使用完整的 sessionContext 作为记忆标识
- */
-export function buildSessionContext(params: {
-  accountId: string;
-  senderId: string;
-  senderName?: string
-  conversationType: string;
-  conversationId?: string;
-  groupSubject?: string;
-  separateSessionByConversation?: boolean;
-  groupSessionScope?: 'group' | 'group_sender';
-  sharedMemoryAcrossConversations?: boolean;
-}): SessionContext {
-  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: string): string {
-  const trimmed = text.trim();
-  const lower = trimmed.toLowerCase();
-  if (NEW_SESSION_COMMANDS.some((cmd) => lower === cmd.toLowerCase())) {
-    return '/new';
-  }
-  return text;
-}

package/src/utils/token.ts

@@ -1,93 +0,0 @@
-/**
- * Access Token 管理模块
- * 支持钉钉 API 和 OAPI 的 Token 获取和缓存
- */
-
-import type { DingtalkConfig } from '../types/index.ts';
-import { dingtalkHttp, dingtalkOapiHttp } from './http-client.ts';
-
-// ============ 常量 ============
-
-export const DINGTALK_API = 'https://api.dingtalk.com';
-export const DINGTALK_OAPI = 'https://oapi.dingtalk.com';
-
-// ============ Access Token 缓存 ============
-
-type CachedToken = {
-  token: string;
-  expiryMs: number;
-};
-
-/**
- * 按 clientId 分桶缓存，避免多账号串 token。
- */
-const apiTokenCache = new Map<string, CachedToken>();
-const oapiTokenCache = new Map<string, CachedToken>();
-
-function cacheKey(config: DingtalkConfig): string {
-  const clientId = String((config as any)?.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: DingtalkConfig): Promise<string> {
-  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 as string;
-  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: DingtalkConfig): Promise<string | null> {
-  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;
-  }
-}