@axhub/genie 0.1.6 → 0.1.8

package/server/channels/core/ChannelManager.js

@@ -0,0 +1,399 @@
+import { PluginManager } from './PluginManager.js';
+import { LarkPlugin } from '../plugins/lark/LarkPlugin.js';
+import { DingTalkPlugin } from '../plugins/dingtalk/DingTalkPlugin.js';
+import { createUnauthorizedUserCard, createUnknownUserIdCard } from '../plugins/lark/LarkCards.js';
+import { ChannelStore } from '../store/ChannelStore.js';
+import { runBackendSession } from '../runtime/AgentRuntimeAdapter.js';
+import { LarkStreamWriter } from '../runtime/LarkStreamWriter.js';
+import { DingTalkStreamWriter } from '../runtime/DingTalkStreamWriter.js';
+
+const SUPPORTED_PLATFORMS = ['lark', 'dingtalk'];
+
+function normalizePlatform(platform) {
+  const normalized = String(platform || '').trim().toLowerCase();
+  return normalized === 'dingtalk' ? 'dingtalk' : 'lark';
+}
+
+function toPluginId(platform) {
+  return normalizePlatform(platform) === 'dingtalk' ? 'dingtalk_default' : 'lark_default';
+}
+
+function isTextMessage(messageType) {
+  const normalized = String(messageType || '').trim().toLowerCase();
+  return normalized === 'text' || normalized === 'richtext';
+}
+
+export class ChannelManager {
+  constructor() {
+    this.store = new ChannelStore();
+    this.pluginManager = new PluginManager();
+    this.pluginManager.register('lark', LarkPlugin);
+    this.pluginManager.register('dingtalk', DingTalkPlugin);
+    this.initialized = false;
+    this.runtimeErrors = {
+      lark: null,
+      dingtalk: null,
+    };
+    this.processingQueues = new Map();
+  }
+
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+
+    for (const platform of SUPPORTED_PLATFORMS) {
+      const pluginId = toPluginId(platform);
+      this.store.upsertPluginConfig(pluginId, {});
+      this.store.updatePluginRuntimeStatus(pluginId, false, 'stopped');
+      this.runtimeErrors[platform] = null;
+    }
+
+    this.initialized = true;
+  }
+
+  async shutdown() {
+    await this.pluginManager.stopAll();
+  }
+
+  getConfig(platform = 'lark') {
+    const normalizedPlatform = normalizePlatform(platform);
+    const pluginId = toPluginId(normalizedPlatform);
+    const stored = this.store.getPluginConfig(pluginId);
+    const config = stored.config || {};
+
+    if (normalizedPlatform === 'dingtalk') {
+      return {
+        clientId: config.clientId || '',
+        clientSecret: '',
+        hasClientSecret: !!config.clientSecret,
+        defaultBackend: config.defaultBackend || 'codex',
+        defaultModel: config.defaultModel || '',
+        defaultProjectPath: config.defaultProjectPath || '',
+      };
+    }
+
+    return {
+      appId: config.appId || '',
+      appSecret: '',
+      hasAppSecret: !!config.appSecret,
+      encryptKey: '',
+      hasEncryptKey: !!config.encryptKey,
+      verificationToken: '',
+      hasVerificationToken: !!config.verificationToken,
+      defaultBackend: config.defaultBackend || 'codex',
+      defaultModel: config.defaultModel || '',
+      defaultProjectPath: config.defaultProjectPath || '',
+    };
+  }
+
+  updateConfig(platform = 'lark', payload = {}) {
+    const normalizedPlatform = normalizePlatform(platform);
+    const pluginId = toPluginId(normalizedPlatform);
+    const current = this.store.getPluginConfig(pluginId).config;
+
+    const normalize = (value) => (typeof value === 'string' ? value.trim() : '');
+
+    if (normalizedPlatform === 'dingtalk') {
+      const nextDingTalkConfig = {
+        ...current,
+        clientId: normalize(payload.clientId) || current.clientId || '',
+        clientSecret: normalize(payload.clientSecret) || current.clientSecret || '',
+        defaultBackend: normalize(payload.defaultBackend) || current.defaultBackend || 'codex',
+        defaultModel: normalize(payload.defaultModel) || current.defaultModel || '',
+        defaultProjectPath: normalize(payload.defaultProjectPath) || current.defaultProjectPath || '',
+      };
+
+      this.store.upsertPluginConfig(pluginId, nextDingTalkConfig);
+      return this.getConfig(normalizedPlatform);
+    }
+
+    const nextLarkConfig = {
+      ...current,
+      appId: normalize(payload.appId) || current.appId || '',
+      appSecret: normalize(payload.appSecret) || current.appSecret || '',
+      encryptKey: normalize(payload.encryptKey) || current.encryptKey || '',
+      verificationToken: normalize(payload.verificationToken) || current.verificationToken || '',
+      defaultBackend: normalize(payload.defaultBackend) || current.defaultBackend || 'codex',
+      defaultModel: normalize(payload.defaultModel) || current.defaultModel || '',
+      defaultProjectPath: normalize(payload.defaultProjectPath) || current.defaultProjectPath || '',
+    };
+
+    this.store.upsertPluginConfig(pluginId, nextLarkConfig);
+    return this.getConfig(normalizedPlatform);
+  }
+
+  async testConnection(platform = 'lark', credentials = {}) {
+    const normalizedPlatform = normalizePlatform(platform);
+    const pluginId = toPluginId(normalizedPlatform);
+    const stored = this.store.getPluginConfig(pluginId);
+    const config = stored.config || {};
+
+    if (normalizedPlatform === 'dingtalk') {
+      const resolvedClientId = String(credentials.clientId || '').trim() || String(config.clientId || '').trim();
+      const resolvedClientSecret = String(credentials.clientSecret || '').trim() || String(config.clientSecret || '').trim();
+
+      if (!resolvedClientId || !resolvedClientSecret) {
+        return { success: false, error: '测试连接需要填写 Client ID 和 Client Secret' };
+      }
+
+      return DingTalkPlugin.testConnection(resolvedClientId, resolvedClientSecret);
+    }
+
+    const resolvedAppId = String(credentials.appId || '').trim() || String(config.appId || '').trim();
+    const resolvedAppSecret = String(credentials.appSecret || '').trim() || String(config.appSecret || '').trim();
+
+    if (!resolvedAppId || !resolvedAppSecret) {
+      return { success: false, error: '测试连接需要填写 App ID 和 App Secret' };
+    }
+
+    return LarkPlugin.testConnection(resolvedAppId, resolvedAppSecret);
+  }
+
+  getStatus(platform = 'lark') {
+    const normalizedPlatform = normalizePlatform(platform);
+    const pluginId = toPluginId(normalizedPlatform);
+    const stored = this.store.getPluginConfig(pluginId);
+    const plugin = this.pluginManager.getInstance(normalizedPlatform);
+
+    const status = plugin?.status || stored.status || 'stopped';
+    const running = status === 'running';
+
+    return {
+      id: pluginId,
+      type: normalizedPlatform,
+      enabled: !!stored.enabled,
+      running,
+      status,
+      error: this.runtimeErrors[normalizedPlatform],
+    };
+  }
+
+  async startPlugin(platform = 'lark') {
+    const normalizedPlatform = normalizePlatform(platform);
+    const pluginId = toPluginId(normalizedPlatform);
+    const stored = this.store.getPluginConfig(pluginId);
+    const config = stored.config || {};
+
+    if (normalizedPlatform === 'dingtalk') {
+      if (!config.clientId || !config.clientSecret) {
+        throw new Error('请先配置 Client ID 和 Client Secret');
+      }
+    } else if (!config.appId || !config.appSecret) {
+      throw new Error('请先配置 App ID 和 App Secret');
+    }
+
+    this.runtimeErrors[normalizedPlatform] = null;
+
+    try {
+      await this.pluginManager.start(normalizedPlatform, config, this.handleIncomingMessage.bind(this));
+      this.store.updatePluginRuntimeStatus(pluginId, true, 'running');
+      return this.getStatus(normalizedPlatform);
+    } catch (error) {
+      const defaultError = normalizedPlatform === 'dingtalk' ? 'DingTalk 启动失败' : 'Lark 启动失败';
+      this.runtimeErrors[normalizedPlatform] = error?.message || defaultError;
+      this.store.updatePluginRuntimeStatus(pluginId, false, 'error');
+      throw error;
+    }
+  }
+
+  async stopPlugin(platform = 'lark') {
+    const normalizedPlatform = normalizePlatform(platform);
+    const pluginId = toPluginId(normalizedPlatform);
+
+    await this.pluginManager.stop(normalizedPlatform);
+    this.store.updatePluginRuntimeStatus(pluginId, false, 'stopped');
+    this.runtimeErrors[normalizedPlatform] = null;
+    return this.getStatus(normalizedPlatform);
+  }
+
+  listAllowedUsers(platform = 'lark') {
+    return this.store.listAllowedUsers(normalizePlatform(platform));
+  }
+
+  addAllowedUser(platform = 'lark', payload) {
+    return this.store.addAllowedUser(normalizePlatform(platform), payload);
+  }
+
+  toggleAllowedUser(platform = 'lark', id, isActive) {
+    return this.store.toggleAllowedUser(normalizePlatform(platform), id, isActive);
+  }
+
+  removeAllowedUser(platform = 'lark', id) {
+    return this.store.removeAllowedUser(normalizePlatform(platform), id);
+  }
+
+  async handleIncomingMessage(incoming) {
+    const platform = normalizePlatform(incoming?.platform);
+    const queueKey = `${platform}:${incoming?.effectiveUserId || 'unknown'}:${incoming?.chatId || 'unknown'}`;
+
+    return this.enqueue(queueKey, async () => {
+      await this.processIncomingMessage({ ...incoming, platform });
+    });
+  }
+
+  enqueue(key, task) {
+    const previous = this.processingQueues.get(key) || Promise.resolve();
+
+    const next = previous
+      .catch(() => {})
+      .then(task)
+      .finally(() => {
+        if (this.processingQueues.get(key) === next) {
+          this.processingQueues.delete(key);
+        }
+      });
+
+    this.processingQueues.set(key, next);
+    return next;
+  }
+
+  async sendUnknownUserMessage(plugin, platform, chatId) {
+    if (platform === 'lark') {
+      await plugin.sendCard(chatId, createUnknownUserIdCard());
+      return;
+    }
+
+    await plugin.sendText(chatId, '无法识别你的钉钉用户ID，请联系管理员检查机器人事件权限。');
+  }
+
+  async sendUnauthorizedMessage(plugin, platform, chatId, effectiveUserId) {
+    if (platform === 'lark') {
+      await plugin.sendCard(chatId, createUnauthorizedUserCard(effectiveUserId));
+      return;
+    }
+
+    const message = [
+      `你的钉钉用户ID: ${effectiveUserId}`,
+      '',
+      '请将此 ID 添加到 AxHub 设置 > Channels > DingTalk 的允许用户列表。',
+    ].join('\n');
+
+    await plugin.sendText(chatId, message);
+  }
+
+  async processIncomingMessage(incoming) {
+    const platform = normalizePlatform(incoming?.platform);
+    const plugin = this.pluginManager.getInstance(platform);
+    if (!plugin) {
+      return;
+    }
+
+    const chatId = incoming?.chatId;
+    const effectiveUserId = incoming?.effectiveUserId;
+
+    if (!chatId) {
+      return;
+    }
+
+    if (!effectiveUserId) {
+      await this.sendUnknownUserMessage(plugin, platform, chatId);
+      return;
+    }
+
+    if (!this.store.isAllowedUser(platform, effectiveUserId)) {
+      await this.sendUnauthorizedMessage(plugin, platform, chatId, effectiveUserId);
+      return;
+    }
+
+    if (!isTextMessage(incoming?.messageType)) {
+      await plugin.sendText(chatId, '目前仅支持文本消息。');
+      return;
+    }
+
+    const text = String(incoming?.text || '').trim();
+    if (!text) {
+      await plugin.sendText(chatId, '请输入消息内容。');
+      return;
+    }
+
+    const config = this.store.getPluginConfig(toPluginId(platform)).config || {};
+    const backend = config.defaultBackend || 'codex';
+    const model = config.defaultModel || undefined;
+    const projectPath = config.defaultProjectPath || '';
+
+    if (!projectPath) {
+      const platformName = platform === 'dingtalk' ? 'DingTalk' : 'Lark';
+      await plugin.sendText(chatId, `请先在设置中配置默认项目路径（Channels > ${platformName} > 默认项目）。`);
+      return;
+    }
+
+    const existingSession = this.store.getChannelSession({
+      platform,
+      userId: effectiveUserId,
+      chatId,
+      backend,
+    });
+
+    const writer =
+      platform === 'dingtalk'
+        ? new DingTalkStreamWriter(plugin, chatId)
+        : new LarkStreamWriter(plugin, chatId);
+
+    let resolvedSessionId = existingSession?.providerSessionId || null;
+
+    try {
+      await writer.start('⏳ Thinking...');
+
+      const result = await runBackendSession({
+        backend,
+        message: text,
+        projectPath,
+        sessionId: resolvedSessionId,
+        model,
+        onSessionId: (sessionId) => {
+          resolvedSessionId = sessionId;
+          this.store.upsertChannelSession({
+            platform,
+            userId: effectiveUserId,
+            chatId,
+            backend,
+            providerSessionId: resolvedSessionId,
+            projectPath,
+          });
+        },
+        onDelta: (delta) => {
+          writer.append(delta);
+        },
+      });
+
+      if (result?.sessionId && !resolvedSessionId) {
+        resolvedSessionId = result.sessionId;
+      }
+
+      if (resolvedSessionId) {
+        this.store.upsertChannelSession({
+          platform,
+          userId: effectiveUserId,
+          chatId,
+          backend,
+          providerSessionId: resolvedSessionId,
+          projectPath,
+        });
+      }
+
+      await writer.finish();
+    } catch (error) {
+      await writer.fail(error?.message || '处理失败，请稍后重试。');
+    }
+  }
+
+  // Compatibility wrappers for legacy callers
+  async startLark() {
+    return this.startPlugin('lark');
+  }
+
+  async stopLark() {
+    return this.stopPlugin('lark');
+  }
+}
+
+let manager = null;
+
+export function getChannelManager() {
+  if (!manager) {
+    manager = new ChannelManager();
+  }
+
+  return manager;
+}

package/server/channels/core/PluginManager.js

@@ -0,0 +1,59 @@
+export class PluginManager {
+  constructor() {
+    this.registry = new Map();
+    this.instances = new Map();
+  }
+
+  register(type, PluginClass) {
+    this.registry.set(type, PluginClass);
+  }
+
+  getInstance(type) {
+    return this.instances.get(type) || null;
+  }
+
+  async start(type, config, messageHandler) {
+    if (this.instances.has(type)) {
+      return this.instances.get(type);
+    }
+
+    const PluginClass = this.registry.get(type);
+    if (!PluginClass) {
+      throw new Error(`Unknown plugin type: ${type}`);
+    }
+
+    const plugin = new PluginClass();
+    if (messageHandler) {
+      plugin.onMessage(messageHandler);
+    }
+
+    await plugin.initialize(config);
+    await plugin.start();
+    this.instances.set(type, plugin);
+    return plugin;
+  }
+
+  async stop(type) {
+    const plugin = this.instances.get(type);
+    if (!plugin) {
+      return;
+    }
+
+    await plugin.stop();
+    this.instances.delete(type);
+  }
+
+  async stopAll() {
+    const stops = [];
+    for (const [type, plugin] of this.instances.entries()) {
+      stops.push(
+        plugin.stop().catch((error) => {
+          console.error(`[PluginManager] Failed to stop plugin ${type}:`, error);
+        })
+      );
+    }
+
+    await Promise.allSettled(stops);
+    this.instances.clear();
+  }
+}

package/server/channels/index.js

@@ -0,0 +1,3 @@
+export { getChannelManager, ChannelManager } from './core/ChannelManager.js';
+export { LarkPlugin } from './plugins/lark/LarkPlugin.js';
+export { DingTalkPlugin } from './plugins/dingtalk/DingTalkPlugin.js';

package/server/channels/plugins/BasePlugin.js

@@ -0,0 +1,46 @@
+export class BasePlugin {
+  constructor(type) {
+    this.type = type;
+    this.status = 'created';
+    this.config = null;
+    this.messageHandler = null;
+  }
+
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+
+  async initialize(config) {
+    this.config = config;
+    this.status = 'initializing';
+    await this.onInitialize(config);
+    this.status = 'ready';
+  }
+
+  async start() {
+    if (this.status !== 'ready' && this.status !== 'stopped') {
+      return;
+    }
+
+    this.status = 'starting';
+    await this.onStart();
+    this.status = 'running';
+  }
+
+  async stop() {
+    if (this.status !== 'running' && this.status !== 'starting') {
+      return;
+    }
+
+    this.status = 'stopping';
+    await this.onStop();
+    this.status = 'stopped';
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  async onInitialize(_config) {}
+
+  async onStart() {}
+
+  async onStop() {}
+}

package/server/channels/plugins/dingtalk/DingTalkAdapter.js

@@ -0,0 +1,156 @@
+export const DINGTALK_MESSAGE_LIMIT = 4000;
+
+export function encodeChatId(data = {}) {
+  if (String(data.conversationType || '') === '1') {
+    return `user:${data.senderStaffId || data.chatbotUserId || ''}`;
+  }
+  return `group:${data.conversationId || ''}`;
+}
+
+export function parseChatId(chatId = '') {
+  if (chatId.startsWith('user:')) {
+    return { type: 'user', id: chatId.slice(5) };
+  }
+  if (chatId.startsWith('group:')) {
+    return { type: 'group', id: chatId.slice(6) };
+  }
+  return { type: 'user', id: chatId };
+}
+
+function normalizeText(text, conversationType) {
+  let result = String(text || '');
+  if (String(conversationType || '') === '2') {
+    result = result.replace(/@\S+\s*/g, '').trim();
+  }
+  return result;
+}
+
+function extractTextContent(data = {}) {
+  const msgType = String(data.msgtype || '');
+
+  if (msgType === 'text') {
+    return normalizeText(data.text?.content || '', data.conversationType);
+  }
+
+  if (msgType === 'richText') {
+    const text = (data.richText?.richTextList || [])
+      .filter((item) => item?.type === 'text')
+      .map((item) => item?.text || '')
+      .join('');
+    return normalizeText(text, data.conversationType);
+  }
+
+  return '';
+}
+
+export function toIncomingMessage(data = {}) {
+  const effectiveUserId = String(data.senderStaffId || '').trim();
+  const chatId = encodeChatId(data);
+  const messageType = String(data.msgtype || 'text');
+  const text = extractTextContent(data);
+
+  if (!effectiveUserId || !chatId) {
+    return null;
+  }
+
+  return {
+    id: data.msgId || `${Date.now()}`,
+    platform: 'dingtalk',
+    chatId,
+    effectiveUserId,
+    text,
+    messageType,
+    displayName: data.senderNick || `User ${effectiveUserId.slice(-6)}`,
+    raw: data,
+  };
+}
+
+export function toDingTalkSendParams(message = {}) {
+  if (message.replyMarkup && typeof message.replyMarkup === 'object') {
+    return {
+      contentType: 'actionCard',
+      content: message.replyMarkup,
+    };
+  }
+
+  if (Array.isArray(message.buttons) && message.buttons.length > 0) {
+    const card = buildActionCard(message.text || '', message.buttons);
+    return {
+      contentType: 'actionCard',
+      content: card,
+    };
+  }
+
+  const text = String(message.text || '');
+  return {
+    contentType: 'markdown',
+    content: {
+      title: 'Message',
+      text,
+    },
+    rawText: text,
+  };
+}
+
+function buildActionCard(text, buttons = []) {
+  const markdownText = convertHtmlToDingTalkMarkdown(text);
+  const btns = [];
+
+  for (const row of buttons) {
+    for (const button of row || []) {
+      btns.push({
+        title: button.label,
+        actionURL: `dingtalk://dingtalkclient/action/openAppAction?action=${encodeURIComponent(button.action || '')}&params=${encodeURIComponent(JSON.stringify(button.params || {}))}`,
+      });
+    }
+  }
+
+  return {
+    title: 'Message',
+    text: markdownText,
+    btnOrientation: '1',
+    btns,
+  };
+}
+
+export function convertHtmlToDingTalkMarkdown(input) {
+  if (!input) return '';
+
+  let text = String(input);
+
+  text = text
+    .replace(/"/gi, '"')
+    .replace(/'|'/gi, "'")
+    .replace(/&#x([0-9a-f]+);/gi, (_, hex) => String.fromCharCode(parseInt(hex, 16)))
+    .replace(/&#(\d+);/g, (_, dec) => String.fromCharCode(parseInt(dec, 10)));
+
+  text = text.replace(/<b>(.+?)<\/b>/gi, '**$1**');
+  text = text.replace(/<strong>(.+?)<\/strong>/gi, '**$1**');
+  text = text.replace(/<i>(.+?)<\/i>/gi, '*$1*');
+  text = text.replace(/<em>(.+?)<\/em>/gi, '*$1*');
+  text = text.replace(/<code>(.+?)<\/code>/gi, '`$1`');
+  text = text.replace(/<pre><code>([\s\S]+?)<\/code><\/pre>/gi, '```\n$1\n```');
+
+  text = text.replace(/<a href="([^"]+)">(.+?)<\/a>/gi, (_, url, label) => {
+    const normalized = String(url || '').trim().toLowerCase();
+    const safe = /^(https?:\/\/|mailto:|\/)|^[^:]*$/.test(normalized);
+    if (!safe) return label;
+    return `[${label}](${url})`;
+  });
+
+  let prev = '';
+  while (prev !== text) {
+    prev = text;
+    text = text.replace(/<[^>]+>/g, '');
+  }
+
+  return text;
+}
+
+export function truncateDingTalkText(text, maxLength = DINGTALK_MESSAGE_LIMIT) {
+  const normalized = String(text || '');
+  if (normalized.length <= maxLength) {
+    return normalized;
+  }
+  return `${normalized.slice(0, maxLength - 3)}...`;
+}