@xmanrui/dsh-im 0.1.0

package/src/channels/feishu/config.mjs

@@ -0,0 +1,71 @@
+import { execFileSync } from 'node:child_process';
+import { resolve } from 'node:path';
+
+function required(name, value) {
+  if (typeof value !== 'string' || value.trim() === '') {
+    throw new Error(`Missing required configuration: ${name}`);
+  }
+  return value.trim();
+}
+
+function readSecret(appId) {
+  if (process.env.FEISHU_APP_SECRET?.trim()) return process.env.FEISHU_APP_SECRET.trim();
+
+  const service = process.env.FEISHU_SECRET_SERVICE?.trim();
+  if (!service) throw new Error('Missing FEISHU_APP_SECRET or FEISHU_SECRET_SERVICE');
+
+  try {
+    return execFileSync('/usr/bin/security', [
+      'find-generic-password',
+      '-a',
+      appId,
+      '-s',
+      service,
+      '-w',
+    ], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+  } catch {
+    throw new Error(`Unable to read Feishu app secret from macOS Keychain service ${service}`);
+  }
+}
+
+function bool(name, fallback) {
+  const raw = process.env[name];
+  if (raw === undefined) return fallback;
+  return !['0', 'false', 'no', 'off'].includes(raw.trim().toLowerCase());
+}
+
+function csvSet(value) {
+  return new Set((value ?? '')
+    .split(',')
+    .map((item) => item.trim())
+    .filter(Boolean));
+}
+
+function requiredCsvSet(name, value) {
+  const items = csvSet(value);
+  if (items.size === 0) throw new Error(`Missing required configuration: ${name}`);
+  return items;
+}
+
+export function loadConfig() {
+  const appId = required('FEISHU_APP_ID', process.env.FEISHU_APP_ID);
+  const appSecret = required('FEISHU_APP_SECRET', readSecret(appId));
+  const workspace = required('HARNESS_WORKSPACE', process.env.HARNESS_WORKSPACE);
+
+  return Object.freeze({
+    appId,
+    appSecret,
+    harnessBaseUrl: new URL(process.env.HARNESS_BASE_URL ?? 'http://127.0.0.1:3080'),
+    harnessWorkspace: resolve(workspace),
+    harnessAgentPreset: process.env.HARNESS_AGENT_PRESET?.trim() || 'standard',
+    harnessAutostart: bool('HARNESS_AUTOSTART', true),
+    dshBin: process.env.DSH_BIN?.trim() || 'dsh',
+    healthPort: Number.parseInt(process.env.BRIDGE_HEALTH_PORT ?? '3091', 10),
+    statePath: resolve(process.env.BRIDGE_STATE_PATH ?? './data/state.json'),
+    replyTimeoutMs: Number.parseInt(process.env.HARNESS_REPLY_TIMEOUT_MS ?? '600000', 10),
+    allowedSenderOpenIds: requiredCsvSet(
+      'FEISHU_ALLOWED_OPEN_IDS',
+      process.env.FEISHU_ALLOWED_OPEN_IDS,
+    ),
+  });
+}

package/src/channels/feishu/feishu-app.mjs

@@ -0,0 +1,51 @@
+function endpointFor(domain, path) {
+  const origin = domain === 'lark' ? 'https://open.larksuite.com' : 'https://open.feishu.cn';
+  return new URL(path, origin);
+}
+
+async function jsonResponse(response, operation) {
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    throw new Error(`${operation} returned a non-JSON response`);
+  }
+  if (!response.ok || body?.code !== 0) {
+    throw new Error(`${operation} failed: ${body?.msg || `HTTP ${response.status}`}`);
+  }
+  return body;
+}
+
+/** Validate freshly provisioned credentials and read the bot identity. */
+export async function verifyFeishuApp({
+  appId,
+  appSecret,
+  domain = 'feishu',
+  fetchImpl = fetch,
+  timeoutMs = 15000,
+}) {
+  if (!appId || !appSecret) throw new Error('Feishu credentials are incomplete');
+  const tokenResponse = await fetchImpl(endpointFor(domain, '/open-apis/auth/v3/tenant_access_token/internal'), {
+    method: 'POST',
+    headers: { 'content-type': 'application/json; charset=utf-8' },
+    body: JSON.stringify({ app_id: appId, app_secret: appSecret }),
+    signal: AbortSignal.timeout(timeoutMs),
+  });
+  const tokenBody = await jsonResponse(tokenResponse, 'Feishu authentication');
+  if (!tokenBody.tenant_access_token) {
+    throw new Error('Feishu authentication returned no tenant access token');
+  }
+
+  const botResponse = await fetchImpl(endpointFor(domain, '/open-apis/bot/v3/info/'), {
+    headers: { authorization: `Bearer ${tokenBody.tenant_access_token}` },
+    signal: AbortSignal.timeout(timeoutMs),
+  });
+  const botBody = await jsonResponse(botResponse, 'Feishu bot verification');
+  const bot = botBody.bot ?? {};
+  return Object.freeze({
+    appId,
+    name: bot.app_name ?? bot.bot_name ?? null,
+    openId: bot.open_id ?? null,
+    activated: bot.activate_status ?? null,
+  });
+}

package/src/channels/feishu/feishu-channel.mjs

@@ -0,0 +1,153 @@
+const STREAM_ELEMENT_ID = 'stream_md';
+const DEFAULT_INITIAL_TEXT = '已连接 DeepSeek Harness，正在思考…';
+const MAX_STREAM_CHARS = 28000;
+
+function assertApiSuccess(operation, response) {
+  if (response?.code && response.code !== 0) {
+    throw new Error(`${operation} failed: ${response.msg || response.code}`);
+  }
+  return response;
+}
+
+function summaryOf(text) {
+  const summary = String(text ?? '').replace(/\s+/g, ' ').trim();
+  return summary.length <= 50 ? summary : `${summary.slice(0, 49)}…`;
+}
+
+function streamingCard(initialText) {
+  return {
+    schema: '2.0',
+    config: {
+      streaming_mode: true,
+      summary: { content: '正在生成…' },
+      streaming_config: {
+        print_frequency_ms: { default: 70 },
+        print_step: { default: 1 },
+        print_strategy: 'fast',
+      },
+    },
+    body: {
+      elements: [{
+        tag: 'markdown',
+        element_id: STREAM_ELEMENT_ID,
+        content: initialText,
+      }],
+    },
+  };
+}
+
+export class VerifiedFeishuChannel {
+  #client;
+  #initialText;
+
+  constructor({ client, initialText = DEFAULT_INITIAL_TEXT }) {
+    this.#client = client;
+    this.#initialText = initialText;
+  }
+
+  async stream(chatId, input, options = {}) {
+    if (typeof input?.markdown !== 'function') {
+      throw new Error('Feishu stream requires a markdown producer');
+    }
+
+    let messageId = null;
+    const cardResponse = assertApiSuccess('Feishu card.create', await this.#client.cardkit.v1.card.create({
+      data: {
+        type: 'card_json',
+        data: JSON.stringify(streamingCard(this.#initialText)),
+      },
+    }));
+    const cardId = cardResponse?.data?.card_id;
+    if (!cardId) throw new Error('Feishu card.create returned no card_id');
+
+    try {
+      messageId = await this.#sendCard(chatId, cardId, options.replyTo);
+      let sequence = 0;
+      let lastContent = this.#initialText;
+      const controller = {
+        messageId,
+        setContent: async (content) => {
+          const next = String(content ?? '') || '…';
+          if (next === lastContent) return;
+          if (next.length > MAX_STREAM_CHARS) {
+            throw new Error(`Feishu stream content exceeds ${MAX_STREAM_CHARS} characters`);
+          }
+          const response = await this.#client.cardkit.v1.cardElement.content({
+            path: { card_id: cardId, element_id: STREAM_ELEMENT_ID },
+            data: {
+              content: next,
+              sequence: ++sequence,
+              uuid: `content_${cardId}_${sequence}`,
+            },
+          });
+          assertApiSuccess('Feishu cardElement.content', response);
+          lastContent = next;
+        },
+      };
+
+      await input.markdown(controller);
+      const finishResponse = await this.#client.cardkit.v1.card.settings({
+        path: { card_id: cardId },
+        data: {
+          settings: JSON.stringify({
+            config: {
+              streaming_mode: false,
+              summary: { content: summaryOf(lastContent) || '回答完成' },
+            },
+          }),
+          sequence: ++sequence,
+          uuid: `settings_${cardId}_${sequence}`,
+        },
+      });
+      assertApiSuccess('Feishu card.settings', finishResponse);
+      return { messageId };
+    } catch (error) {
+      if (messageId) await this.#recall(messageId);
+      throw error;
+    }
+  }
+
+  async #sendCard(chatId, cardId, replyTo) {
+    const content = JSON.stringify({ type: 'card', data: { card_id: cardId } });
+    const response = replyTo
+      ? await this.#client.im.v1.message.reply({
+        path: { message_id: replyTo },
+        data: { msg_type: 'interactive', content },
+      })
+      : await this.#client.im.v1.message.create({
+        params: { receive_id_type: 'chat_id' },
+        data: { receive_id: chatId, msg_type: 'interactive', content },
+      });
+    assertApiSuccess('Feishu message send', response);
+    const messageId = response?.data?.message_id;
+    if (!messageId) throw new Error('Feishu message send returned no message_id');
+    return messageId;
+  }
+
+  async #recall(messageId) {
+    try {
+      const response = await this.#client.im.v1.message.delete({
+        path: { message_id: messageId },
+      });
+      assertApiSuccess('Feishu message delete', response);
+    } catch (error) {
+      console.warn('[bridge] unable to recall a failed streaming card:', error.message);
+    }
+  }
+
+  async addReaction(messageId, emojiType) {
+    const response = assertApiSuccess('Feishu reaction.create', await this.#client.im.v1.messageReaction.create({
+      path: { message_id: messageId },
+      data: { reaction_type: { emoji_type: emojiType } },
+    }));
+    const reactionId = response?.data?.reaction_id;
+    if (!reactionId) throw new Error('Feishu reaction.create returned no reaction_id');
+    return reactionId;
+  }
+
+  async removeReaction(messageId, reactionId) {
+    assertApiSuccess('Feishu reaction.delete', await this.#client.im.v1.messageReaction.delete({
+      path: { message_id: messageId, reaction_id: reactionId },
+    }));
+  }
+}

package/src/channels/feishu/feishu-runtime.mjs

@@ -0,0 +1,222 @@
+import { FeishuHarnessBridge } from './bridge.mjs';
+import { VerifiedFeishuChannel } from './feishu-channel.mjs';
+
+export function createBridgeStatus({ allowedSenderCount = 1 } = {}) {
+  return {
+    startedAt: null,
+    ready: false,
+    feishuLongConnectionState: 'idle',
+    harnessReachable: false,
+    messagesReceived: 0,
+    messagesReplied: 0,
+    messagesRejected: 0,
+    reactionsAdded: 0,
+    reactionsRemoved: 0,
+    reactionErrors: 0,
+    streamResponses: 0,
+    streamUpdates: 0,
+    streamFallbacks: 0,
+    streamErrors: 0,
+    lastMessageAt: null,
+    lastReplyAt: null,
+    lastRejectedAt: null,
+    lastError: null,
+    agentPreset: 'standard',
+    authorizationMode: 'sender-open-id-allowlist',
+    allowedSenderCount,
+  };
+}
+
+/**
+ * Owns one live Feishu long connection and the already-tested bridge stack.
+ * The class intentionally receives the SDK and Harness dependencies so the
+ * plugin can run it in-process while tests exercise the lifecycle without a
+ * real Feishu tenant.
+ */
+export class FeishuRuntime {
+  #lark;
+  #appId;
+  #appSecret;
+  #domain;
+  #ownerOpenIds;
+  #harness;
+  #state;
+  #replyTimeoutMs;
+  #connectTimeoutMs;
+  #logger;
+  #client = null;
+  #bridge = null;
+  #wsClient = null;
+  #starting = null;
+  #status;
+
+  constructor({
+    lark,
+    appId,
+    appSecret,
+    domain = 'feishu',
+    ownerOpenId,
+    ownerOpenIds,
+    harness,
+    state,
+    replyTimeoutMs = 600000,
+    connectTimeoutMs = 15000,
+    logger = console,
+  }) {
+    if (!lark) throw new Error('FeishuRuntime requires the Feishu SDK');
+    if (!appId || !appSecret) throw new Error('FeishuRuntime requires app credentials');
+    const allowedOwners = Array.isArray(ownerOpenIds) ? ownerOpenIds : [ownerOpenId];
+    const normalizedOwners = [...new Set(allowedOwners.filter((value) => typeof value === 'string' && value))];
+    if (normalizedOwners.length === 0) throw new Error('FeishuRuntime requires at least one owner open_id');
+    if (!harness) throw new Error('FeishuRuntime requires a Harness client');
+    if (!state) throw new Error('FeishuRuntime requires a state store');
+
+    this.#lark = lark;
+    this.#appId = appId;
+    this.#appSecret = appSecret;
+    this.#domain = domain;
+    this.#ownerOpenIds = normalizedOwners;
+    this.#harness = harness;
+    this.#state = state;
+    this.#replyTimeoutMs = replyTimeoutMs;
+    this.#connectTimeoutMs = connectTimeoutMs;
+    this.#logger = logger;
+    this.#status = createBridgeStatus({ allowedSenderCount: normalizedOwners.length });
+  }
+
+  get status() {
+    return structuredClone(this.#status);
+  }
+
+  async start() {
+    if (this.#wsClient && this.#status.ready) return this.status;
+    if (this.#starting) return this.#starting;
+
+    this.#starting = this.#start().finally(() => {
+      this.#starting = null;
+    });
+    return this.#starting;
+  }
+
+  async #start() {
+    this.#status.startedAt = new Date().toISOString();
+    this.#status.feishuLongConnectionState = 'connecting';
+    this.#status.lastError = null;
+
+    try {
+      await this.#harness.ensureRunning();
+      this.#status.harnessReachable = true;
+
+      const sdkDomain = this.#domain === 'lark'
+        ? this.#lark.Domain.Lark
+        : this.#lark.Domain.Feishu;
+      const larkConfig = {
+        appId: this.#appId,
+        appSecret: this.#appSecret,
+        domain: sdkDomain,
+      };
+      this.#client = new this.#lark.Client(larkConfig);
+      const channel = new VerifiedFeishuChannel({
+        client: this.#client,
+        initialText: '已连接 DeepSeek Harness，正在思考…',
+      });
+      this.#bridge = new FeishuHarnessBridge({
+        client: this.#client,
+        channel,
+        harness: this.#harness,
+        state: this.#state,
+        status: this.#status,
+        allowedSenderOpenIds: new Set(this.#ownerOpenIds),
+        replyTimeoutMs: this.#replyTimeoutMs,
+      });
+
+      const dispatcher = new this.#lark.EventDispatcher({}).register({
+        'im.message.receive_v1': (event) => {
+          this.#bridge.accept(event);
+          return {};
+        },
+        'im.message.reaction.created_v1': () => ({}),
+        'im.message.reaction.deleted_v1': () => ({}),
+      });
+
+      let settleReady;
+      let settleError;
+      const ready = new Promise((resolve, reject) => {
+        let settled = false;
+        const timer = setTimeout(() => {
+          if (settled) return;
+          settled = true;
+          reject(new Error(`Feishu WebSocket handshake timed out after ${this.#connectTimeoutMs}ms`));
+        }, this.#connectTimeoutMs);
+        settleReady = () => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timer);
+          resolve();
+        };
+        settleError = (error) => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timer);
+          reject(error);
+        };
+      });
+
+      this.#wsClient = new this.#lark.WSClient({
+        ...larkConfig,
+        loggerLevel: this.#lark.LoggerLevel.info,
+        handshakeTimeoutMs: 15000,
+        onReady: () => {
+          this.#status.feishuLongConnectionState = 'connected';
+          this.#status.ready = true;
+          this.#status.lastError = null;
+          settleReady();
+        },
+        onError: (error) => {
+          this.#status.feishuLongConnectionState = 'failed';
+          this.#status.ready = false;
+          this.#status.lastError = error?.message ?? String(error);
+          this.#logger.error('[dsh-feishu] Feishu long connection failed:', this.#status.lastError);
+          settleError(error);
+        },
+        onReconnecting: () => {
+          this.#status.feishuLongConnectionState = 'reconnecting';
+          this.#status.ready = false;
+        },
+        onReconnected: () => {
+          this.#status.feishuLongConnectionState = 'connected';
+          this.#status.ready = true;
+          this.#status.lastError = null;
+        },
+      });
+      await this.#wsClient.start({ eventDispatcher: dispatcher }).catch((error) => {
+        settleError(error);
+      });
+      await ready;
+      return this.status;
+    } catch (error) {
+      this.#status.ready = false;
+      this.#status.feishuLongConnectionState = 'failed';
+      this.#status.lastError = error?.message ?? String(error);
+      await this.stop({ preserveError: true });
+      throw error;
+    }
+  }
+
+  async stop({ preserveError = false } = {}) {
+    const error = preserveError ? this.#status.lastError : null;
+    this.#status.ready = false;
+    if (this.#wsClient) {
+      this.#wsClient.close({ force: true });
+      this.#wsClient = null;
+    }
+    if (this.#bridge) {
+      await this.#bridge.waitForIdle();
+      this.#bridge = null;
+    }
+    this.#client = null;
+    this.#status.feishuLongConnectionState = preserveError ? 'failed' : 'idle';
+    this.#status.lastError = error;
+    return this.status;
+  }
+}