@axhub/genie 0.1.7 → 0.1.9

package/server/channels/plugins/lark/LarkCards.js

@@ -0,0 +1,43 @@
+import { truncateLarkText } from './LarkAdapter.js';
+
+export function createTextCard(text, title = null, template = 'blue') {
+  const normalized = truncateLarkText(text || '');
+
+  const card = {
+    config: {
+      wide_screen_mode: true,
+    },
+    elements: [
+      {
+        tag: 'markdown',
+        content: normalized || ' ',
+      },
+    ],
+  };
+
+  if (title) {
+    card.header = {
+      title: {
+        tag: 'plain_text',
+        content: title,
+      },
+      template,
+    };
+  }
+
+  return card;
+}
+
+export function createUnknownUserIdCard() {
+  return createTextCard('无法识别你的飞书用户ID，请联系管理员检查机器人事件权限。', '访问受限', 'orange');
+}
+
+export function createUnauthorizedUserCard(userId) {
+  const text = [
+    `你的飞书用户ID: ${userId}`,
+    '',
+    '请将此 ID 添加到 AxHub 设置 > Channels > Lark 的允许用户列表。',
+  ].join('\n');
+
+  return createTextCard(text, '访问受限', 'orange');
+}

package/server/channels/plugins/lark/LarkPlugin.js

@@ -0,0 +1,260 @@
+import * as lark from '@larksuiteoapi/node-sdk';
+
+import { BasePlugin } from '../BasePlugin.js';
+import { toIncomingMessage, truncateLarkText } from './LarkAdapter.js';
+import { createTextCard } from './LarkCards.js';
+
+const EVENT_CACHE_TTL = 5 * 60 * 1000;
+const EVENT_CACHE_CLEANUP_INTERVAL = 60 * 1000;
+
+export class LarkPlugin extends BasePlugin {
+  constructor() {
+    super('lark');
+    this.client = null;
+    this.wsClient = null;
+    this.eventDispatcher = null;
+    this.processedEvents = new Map();
+    this.cleanupTimer = null;
+  }
+
+  async onInitialize(config) {
+    const appId = config?.appId;
+    const appSecret = config?.appSecret;
+
+    if (!appId || !appSecret) {
+      throw new Error('Lark App ID and App Secret are required');
+    }
+
+    this.client = new lark.Client({
+      appId,
+      appSecret,
+      appType: lark.AppType.SelfBuild,
+      domain: lark.Domain.Feishu,
+    });
+  }
+
+  async onStart() {
+    if (!this.client) {
+      throw new Error('Lark client is not initialized');
+    }
+
+    const appId = this.config?.appId;
+    const appSecret = this.config?.appSecret;
+    if (!appId || !appSecret) {
+      throw new Error('Lark credentials are missing');
+    }
+
+    this.eventDispatcher = new lark.EventDispatcher({
+      encryptKey: this.config?.encryptKey || '',
+      verificationToken: this.config?.verificationToken || '',
+    });
+
+    this.eventDispatcher.register({
+      'im.message.receive_v1': async (payload) => {
+        await this.handleMessageEvent(payload);
+      },
+    });
+
+    this.wsClient = new lark.WSClient({
+      appId,
+      appSecret,
+      domain: lark.Domain.Feishu,
+      loggerLevel: lark.LoggerLevel.info,
+    });
+
+    this.wsClient.start({ eventDispatcher: this.eventDispatcher }).catch((error) => {
+      console.error('[LarkPlugin] WebSocket error:', error);
+    });
+
+    this.startCleanupTimer();
+  }
+
+  async onStop() {
+    this.stopCleanupTimer();
+    if (this.wsClient?.stop && typeof this.wsClient.stop === 'function') {
+      try {
+        await this.wsClient.stop();
+      } catch (error) {
+        console.warn('[LarkPlugin] Failed to stop WebSocket client cleanly:', error?.message || error);
+      }
+    }
+    this.wsClient = null;
+    this.eventDispatcher = null;
+    this.client = null;
+    this.processedEvents.clear();
+  }
+
+  async sendText(chatId, text) {
+    if (!this.client) {
+      throw new Error('Lark client not initialized');
+    }
+
+    const receiveIdType = this.getReceiveIdType(chatId);
+    const content = {
+      text: truncateLarkText(text || ''),
+    };
+
+    const response = await this.client.im.message.create({
+      params: {
+        receive_id_type: receiveIdType,
+      },
+      data: {
+        receive_id: chatId,
+        msg_type: 'text',
+        content: JSON.stringify(content),
+      },
+    });
+
+    return response.data?.message_id || '';
+  }
+
+  async sendCard(chatId, card) {
+    if (!this.client) {
+      throw new Error('Lark client not initialized');
+    }
+
+    const receiveIdType = this.getReceiveIdType(chatId);
+    const response = await this.client.im.message.create({
+      params: {
+        receive_id_type: receiveIdType,
+      },
+      data: {
+        receive_id: chatId,
+        msg_type: 'interactive',
+        content: JSON.stringify(card),
+      },
+    });
+
+    return response.data?.message_id || '';
+  }
+
+  async editCard(_chatId, messageId, card) {
+    if (!this.client) {
+      throw new Error('Lark client not initialized');
+    }
+
+    try {
+      await this.client.im.message.patch({
+        path: {
+          message_id: messageId,
+        },
+        data: {
+          content: JSON.stringify(card),
+        },
+      });
+    } catch (error) {
+      const errorCode = error?.response?.data?.code || error?.code;
+      const errorMessage = error?.response?.data?.msg || error?.message || '';
+
+      if (errorCode === 230002 || String(errorMessage).includes('not modified')) {
+        return;
+      }
+
+      if (String(errorMessage).includes('NOT a card')) {
+        return;
+      }
+
+      throw error;
+    }
+  }
+
+  buildStreamingCard(text) {
+    return createTextCard(text);
+  }
+
+  getReceiveIdType(receiveId) {
+    if (receiveId.startsWith('ou_')) return 'open_id';
+    if (receiveId.startsWith('oc_')) return 'chat_id';
+    if (receiveId.startsWith('on_')) return 'union_id';
+    return 'user_id';
+  }
+
+  async handleMessageEvent(payload) {
+    const eventData = payload?.event || payload;
+    if (!eventData?.message) {
+      return;
+    }
+
+    const eventId = eventData.message?.message_id;
+    if (eventId && this.isProcessed(eventId)) {
+      return;
+    }
+    if (eventId) {
+      this.markProcessed(eventId);
+    }
+
+    const incoming = toIncomingMessage(eventData);
+    if (!incoming || !this.messageHandler) {
+      return;
+    }
+
+    try {
+      await this.messageHandler(incoming);
+    } catch (error) {
+      console.error('[LarkPlugin] Failed to process incoming message:', error);
+    }
+  }
+
+  isProcessed(eventId) {
+    return this.processedEvents.has(eventId);
+  }
+
+  markProcessed(eventId) {
+    this.processedEvents.set(eventId, Date.now());
+  }
+
+  startCleanupTimer() {
+    if (this.cleanupTimer) {
+      return;
+    }
+
+    this.cleanupTimer = setInterval(() => {
+      const now = Date.now();
+      for (const [eventId, timestamp] of this.processedEvents.entries()) {
+        if (now - timestamp > EVENT_CACHE_TTL) {
+          this.processedEvents.delete(eventId);
+        }
+      }
+    }, EVENT_CACHE_CLEANUP_INTERVAL);
+  }
+
+  stopCleanupTimer() {
+    if (!this.cleanupTimer) {
+      return;
+    }
+
+    clearInterval(this.cleanupTimer);
+    this.cleanupTimer = null;
+  }
+
+  static async testConnection(appId, appSecret) {
+    if (!appId || !appSecret) {
+      return { success: false, error: 'App ID and App Secret are required' };
+    }
+
+    try {
+      const client = new lark.Client({
+        appId,
+        appSecret,
+        appType: lark.AppType.SelfBuild,
+        domain: lark.Domain.Feishu,
+      });
+
+      await client.auth.tenantAccessToken.internal({
+        data: {
+          app_id: appId,
+          app_secret: appSecret,
+        },
+      });
+
+      return {
+        success: true,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error?.message || 'Failed to connect to Lark',
+      };
+    }
+  }
+}

package/server/channels/runtime/AgentRuntimeAdapter.js

@@ -0,0 +1,176 @@
+import { queryClaudeSDK } from '../../claude-sdk.js';
+import { queryCodex } from '../../openai-codex.js';
+import { queryGemini } from '../../gemini-cli.js';
+import { queryOpencode } from '../../opencode-cli.js';
+import { CODEX_MODELS, GEMINI_MODELS, OPENCODE_MODELS } from '../../../shared/modelConstants.js';
+
+function normalizeBackend(backend) {
+  const normalized = String(backend || '').trim().toLowerCase();
+  if (['claude', 'codex', 'gemini', 'opencode'].includes(normalized)) {
+    return normalized;
+  }
+  return 'codex';
+}
+
+function getDefaultModel(backend) {
+  if (backend === 'codex') return CODEX_MODELS.DEFAULT;
+  if (backend === 'gemini') return GEMINI_MODELS.DEFAULT;
+  if (backend === 'opencode') return OPENCODE_MODELS.DEFAULT;
+  return undefined;
+}
+
+function createWriter(callbacks) {
+  const state = {
+    sessionId: null,
+    done: false,
+    failed: false,
+    codexDeltaItems: new Set(),
+  };
+
+  const ensureSessionId = (sessionId) => {
+    if (!sessionId || state.sessionId === sessionId) {
+      return;
+    }
+
+    state.sessionId = sessionId;
+    callbacks.onSessionId?.(sessionId);
+  };
+
+  return {
+    isSSEStreamWriter: true,
+
+    setSessionId(sessionId) {
+      ensureSessionId(sessionId);
+    },
+
+    send(payload) {
+      if (!payload || typeof payload !== 'object') {
+        return;
+      }
+
+      ensureSessionId(payload.sessionId);
+
+      if (payload.type === 'session-created') {
+        ensureSessionId(payload.sessionId);
+        return;
+      }
+
+      if (payload.type === 'claude-response') {
+        const delta = payload?.data?.delta?.text;
+        if (payload?.data?.type === 'content_block_delta' && typeof delta === 'string' && delta.length > 0) {
+          callbacks.onDelta?.(delta);
+          return;
+        }
+
+        if (payload?.data?.type === 'content_block_stop') {
+          state.done = true;
+        }
+
+        return;
+      }
+
+      if (payload.type === 'codex-response') {
+        if (payload?.data?.type === 'item_delta' && typeof payload?.data?.delta === 'string' && payload.data.delta.length > 0) {
+          const itemId = payload?.data?.itemId ? String(payload.data.itemId) : null;
+          const isReasoning = !!payload?.data?.isReasoning || payload?.data?.itemType === 'reasoning';
+
+          // Feishu channel does not output model reasoning/thinking content.
+          if (isReasoning) {
+            return;
+          }
+
+          if (itemId) {
+            state.codexDeltaItems.add(itemId);
+          }
+
+          callbacks.onDelta?.(payload.data.delta);
+          return;
+        }
+
+        if (payload?.data?.type === 'item_done' && typeof payload?.data?.content === 'string' && payload.data.content.length > 0) {
+          const itemId = payload?.data?.itemId ? String(payload.data.itemId) : null;
+          const isReasoning = !!payload?.data?.isReasoning || payload?.data?.itemType === 'reasoning';
+          const hasDeltaStreamed = !!(itemId && state.codexDeltaItems.has(itemId));
+
+          // Feishu channel does not output model reasoning/thinking content.
+          if (isReasoning) {
+            if (itemId) {
+              state.codexDeltaItems.delete(itemId);
+            }
+            return;
+          }
+
+          if (!hasDeltaStreamed) {
+            callbacks.onDelta?.(payload.data.content);
+          }
+
+          if (itemId) {
+            state.codexDeltaItems.delete(itemId);
+          }
+        }
+
+        return;
+      }
+
+      if (payload.type === 'claude-complete' || payload.type === 'codex-complete') {
+        state.done = true;
+        return;
+      }
+
+      if (payload.type === 'claude-error' || payload.type === 'codex-error') {
+        state.failed = true;
+        callbacks.onError?.(new Error(payload.error || 'Agent runtime error'));
+      }
+    },
+
+    getState() {
+      return state;
+    },
+  };
+}
+
+export async function runBackendSession({
+  backend,
+  message,
+  projectPath,
+  sessionId,
+  model,
+  onSessionId,
+  onDelta,
+  onError,
+}) {
+  const resolvedBackend = normalizeBackend(backend);
+  const resolvedModel = model || getDefaultModel(resolvedBackend);
+
+  const writer = createWriter({
+    onSessionId,
+    onDelta,
+    onError,
+  });
+
+  const options = {
+    projectPath,
+    cwd: projectPath,
+    sessionId: sessionId || undefined,
+    model: resolvedModel,
+    permissionMode: 'bypassPermissions',
+    resume: !!sessionId,
+    skipPermissions: true,
+  };
+
+  if (resolvedBackend === 'claude') {
+    await queryClaudeSDK(message, options, writer);
+  } else if (resolvedBackend === 'codex') {
+    await queryCodex(message, options, writer);
+  } else if (resolvedBackend === 'gemini') {
+    await queryGemini(message, options, writer);
+  } else if (resolvedBackend === 'opencode') {
+    await queryOpencode(message, options, writer);
+  } else {
+    throw new Error(`Unsupported backend: ${resolvedBackend}`);
+  }
+
+  return {
+    sessionId: writer.getState().sessionId || sessionId || null,
+  };
+}

package/server/channels/runtime/DingTalkStreamWriter.js

@@ -0,0 +1,105 @@
+import { convertHtmlToDingTalkMarkdown, truncateDingTalkText } from '../plugins/dingtalk/DingTalkAdapter.js';
+
+const UPDATE_THROTTLE_MS = 500;
+
+export class DingTalkStreamWriter {
+  constructor(plugin, chatId) {
+    this.plugin = plugin;
+    this.chatId = chatId;
+    this.messageId = null;
+    this.buffer = '';
+    this.lastContent = null;
+    this.lastUpdateAt = 0;
+    this.pendingTimer = null;
+  }
+
+  async start(initialText = '⏳ Thinking...') {
+    this.buffer = initialText;
+    this.messageId = await this.plugin.sendMessage(this.chatId, {
+      type: 'text',
+      text: this.formatText(this.buffer),
+    });
+    this.lastContent = this.formatText(this.buffer);
+    this.lastUpdateAt = Date.now();
+    return this.messageId;
+  }
+
+  append(delta) {
+    if (!delta) {
+      return;
+    }
+
+    this.buffer += delta;
+    this.scheduleFlush();
+  }
+
+  async finish() {
+    await this.flushNow(true);
+    this.clearTimer();
+  }
+
+  async fail(errorMessage) {
+    this.buffer = `❌ ${errorMessage || '处理失败，请稍后重试。'}`;
+    await this.flushNow(true);
+    this.clearTimer();
+  }
+
+  async flushNow(isFinal = false) {
+    if (!this.messageId) {
+      return;
+    }
+
+    this.clearTimer();
+    await this.applyEdit(isFinal);
+  }
+
+  scheduleFlush() {
+    const elapsed = Date.now() - this.lastUpdateAt;
+    if (elapsed >= UPDATE_THROTTLE_MS) {
+      void this.applyEdit(false).catch((error) => {
+        console.warn('[DingTalkStreamWriter] Failed to update streaming card:', error?.message || error);
+      });
+      return;
+    }
+
+    this.clearTimer();
+    this.pendingTimer = setTimeout(() => {
+      void this.applyEdit(false).catch((error) => {
+        console.warn('[DingTalkStreamWriter] Failed to update streaming card:', error?.message || error);
+      });
+    }, UPDATE_THROTTLE_MS - elapsed);
+  }
+
+  clearTimer() {
+    if (!this.pendingTimer) {
+      return;
+    }
+
+    clearTimeout(this.pendingTimer);
+    this.pendingTimer = null;
+  }
+
+  formatText(text) {
+    return truncateDingTalkText(convertHtmlToDingTalkMarkdown(text || ''), 3900);
+  }
+
+  async applyEdit(isFinal = false) {
+    if (!this.messageId) {
+      return;
+    }
+
+    const normalized = this.formatText(this.buffer) || ' ';
+    if (!isFinal && this.lastContent === normalized) {
+      return;
+    }
+
+    await this.plugin.editMessage(this.chatId, this.messageId, {
+      type: 'text',
+      text: normalized,
+      isFinal,
+    });
+
+    this.lastContent = normalized;
+    this.lastUpdateAt = Date.now();
+  }
+}

package/server/channels/runtime/LarkStreamWriter.js

@@ -0,0 +1,99 @@
+import { convertHtmlToLarkMarkdown, truncateLarkText } from '../plugins/lark/LarkAdapter.js';
+
+const UPDATE_THROTTLE_MS = 500;
+
+export class LarkStreamWriter {
+  constructor(plugin, chatId) {
+    this.plugin = plugin;
+    this.chatId = chatId;
+    this.messageId = null;
+    this.buffer = '';
+    this.lastContent = null;
+    this.lastUpdateAt = 0;
+    this.pendingTimer = null;
+  }
+
+  async start(initialText = '⏳ Thinking...') {
+    this.buffer = initialText;
+    const card = this.plugin.buildStreamingCard(this.formatText(this.buffer));
+    this.messageId = await this.plugin.sendCard(this.chatId, card);
+    this.lastContent = this.buffer;
+    this.lastUpdateAt = Date.now();
+    return this.messageId;
+  }
+
+  append(delta) {
+    if (!delta) {
+      return;
+    }
+
+    this.buffer += delta;
+    this.scheduleFlush();
+  }
+
+  async finish() {
+    await this.flushNow();
+    this.clearTimer();
+  }
+
+  async fail(errorMessage) {
+    this.buffer = `❌ ${errorMessage || '处理失败，请稍后重试。'}`;
+    await this.flushNow();
+    this.clearTimer();
+  }
+
+  async flushNow() {
+    if (!this.messageId) {
+      return;
+    }
+
+    this.clearTimer();
+    await this.applyEdit();
+  }
+
+  scheduleFlush() {
+    const elapsed = Date.now() - this.lastUpdateAt;
+    if (elapsed >= UPDATE_THROTTLE_MS) {
+      void this.applyEdit().catch((error) => {
+        console.warn('[LarkStreamWriter] Failed to update streaming card:', error?.message || error);
+      });
+      return;
+    }
+
+    this.clearTimer();
+    this.pendingTimer = setTimeout(() => {
+      void this.applyEdit().catch((error) => {
+        console.warn('[LarkStreamWriter] Failed to update streaming card:', error?.message || error);
+      });
+    }, UPDATE_THROTTLE_MS - elapsed);
+  }
+
+  clearTimer() {
+    if (!this.pendingTimer) {
+      return;
+    }
+
+    clearTimeout(this.pendingTimer);
+    this.pendingTimer = null;
+  }
+
+  formatText(text) {
+    return truncateLarkText(convertHtmlToLarkMarkdown(text || ''), 3900);
+  }
+
+  async applyEdit() {
+    if (!this.messageId) {
+      return;
+    }
+
+    const normalized = this.formatText(this.buffer);
+    if (this.lastContent === normalized) {
+      return;
+    }
+
+    const card = this.plugin.buildStreamingCard(normalized || ' ');
+    await this.plugin.editCard(this.chatId, this.messageId, card);
+    this.lastContent = normalized;
+    this.lastUpdateAt = Date.now();
+  }
+}