@keyou007/agent-bot 0.1.14-alpha.0 → 0.1.14-alpha.2

package/src/feishu/FeishuConnector.ts

@@ -2,6 +2,7 @@ import type { Logger } from "pino";
 import type { AppConfig } from "../config/schema.js";
 import { threadContextKey } from "./contextKey.js";
 import { resolveFeishuBotOpenId } from "./FeishuBotIdentity.js";
+import { allowsFeishuUser } from "./ownerAccess.js";
 import type { ChatUpdatedEvent, FeishuEventHandler, IncomingMessage } from "./types.js";
 
 type BotOpenIdResolver = (appId: string, appSecret: string) => Promise<string>;
@@ -33,18 +34,31 @@ export class FeishuConnector {
         this.logger.warn({ error }, "Failed to resolve the Lark bot Open ID for the Agent environment.");
       }
     }
-    await this.startFeishuWs(appId, appSecret, respondToAllGroupMessages ? undefined : botOpenId);
+    await this.startFeishuWs(appId, appSecret, botOpenId, !respondToAllGroupMessages);
   }
 
   stop(): void {
     // SDK connector currently relies on process lifetime.
   }
 
-  private async startFeishuWs(appId: string, appSecret: string, requiredMentionOpenId?: string): Promise<void> {
+  private async startFeishuWs(
+    appId: string,
+    appSecret: string,
+    botOpenId?: string,
+    requireMention = false,
+  ): Promise<void> {
     const lark = (await import("@larksuiteoapi/node-sdk")) as Record<string, any>;
     const eventDispatcher = new lark.EventDispatcher({}).register({
       "im.message.receive_v1": async (data: unknown) => {
-        const message = toIncomingMessage(data, requiredMentionOpenId);
+        const senderOpenId = getFeishuEvent(data)?.sender?.sender_id?.open_id;
+        if (!allowsFeishuUser(this.config, senderOpenId)) {
+          this.logger.debug(
+            { messageId: getFeishuEvent(data)?.message?.message_id },
+            "Ignored a Feishu message from a non-owner.",
+          );
+          return;
+        }
+        const message = toIncomingMessage(data, botOpenId, requireMention);
         if (!message) {
           this.logger.debug({ data }, "Ignored unsupported Feishu message event.");
           return;
@@ -74,6 +88,14 @@ export class FeishuConnector {
           });
       },
       "card.action.trigger": async (data: unknown) => {
+        const operatorOpenId = getFeishuEvent(data)?.operator?.open_id;
+        if (!allowsFeishuUser(this.config, operatorOpenId)) {
+          this.logger.debug(
+            { actionId: getEventId(data) },
+            "Ignored a Feishu card action from a non-owner.",
+          );
+          return {};
+        }
         const action = toCardAction(data);
         if (!action) {
           this.logger.debug({ data }, "Ignored unsupported Feishu card action.");
@@ -115,7 +137,11 @@ function toChatUpdatedEvent(data: unknown): ChatUpdatedEvent | undefined {
   };
 }
 
-function toIncomingMessage(data: unknown, requiredMentionOpenId?: string): IncomingMessage | undefined {
+function toIncomingMessage(
+  data: unknown,
+  botOpenId?: string,
+  requireMention = false,
+): IncomingMessage | undefined {
   const event = getFeishuEvent(data);
   const message = event?.message;
   if (!message) {
@@ -128,11 +154,10 @@ function toIncomingMessage(data: unknown, requiredMentionOpenId?: string): Incom
   if (!parsed) return undefined;
   const chatId = message.chat_id;
   const chatType = message.chat_type === "group" ? "group" : "p2p";
-  if (
-    chatType === "group" &&
-    requiredMentionOpenId &&
-    !mentionsOpenId(message.mentions, requiredMentionOpenId)
-  ) {
+  const mentionedBot = chatType === "group"
+    && Boolean(botOpenId)
+    && mentionsOpenId(message.mentions, botOpenId!);
+  if (chatType === "group" && requireMention && !mentionedBot) {
     return undefined;
   }
   const threadId = typeof message.thread_id === "string" && message.thread_id ? message.thread_id : undefined;
@@ -161,6 +186,7 @@ function toIncomingMessage(data: unknown, requiredMentionOpenId?: string): Incom
     ...(threadId ? { threadId } : {}),
     ...(rootMessageId ? { rootMessageId } : {}),
     ...(parentMessageId ? { parentMessageId } : {}),
+    ...(mentionedBot ? { mentionedBot: true as const } : {}),
     text: parsed.text,
     ...(parsed.images.length > 0 ? { images: parsed.images.map((imageKey) => ({ imageKey })) } : {}),
   };
@@ -250,10 +276,18 @@ function toCardAction(data: unknown) {
     contextKey: chatId ? `chat_id:${chatId}` : `open_id:${openId}`,
     userId: openId,
     ...(typeof event.context?.open_message_id === "string" ? { messageId: event.context.open_message_id } : {}),
-    value: isRecord(event.action.value) ? event.action.value : {},
+    value: getCardActionValue(event.action),
   };
 }
 
+function getCardActionValue(action: Record<string, unknown>): Record<string, unknown> {
+  if (action.tag === "overflow" && typeof action.option === "string") {
+    const option = parseJsonObject(action.option);
+    if (Object.keys(option).length > 0) return option;
+  }
+  return isRecord(action.value) ? action.value : {};
+}
+
 function getEventId(data: unknown): string | undefined {
   const value = getNested<unknown>(data, ["header", "event_id"]) ?? getNested(data, ["data", "header", "event_id"]);
   return typeof value === "string" ? value : undefined;

package/src/feishu/FeishuMarkdown.ts

@@ -6,6 +6,8 @@ interface FenceState {
 }
 
 const FENCE_OPENER = /^([ \t]*)((?:`{3,})|(?:~{3,}))(.*)$/;
+const MARKDOWN_LINK = /(!?)\[([^\]\r\n]*)\]\((<?[^)\r\n]+>?)\)/g;
+const LOCAL_FILE_LINE_REFERENCE = /(:\d+(?::\d+)?)$/;
 
 export function normalizeFeishuMarkdown(markdown: string): string {
   const lines = markdown.match(/[^\r\n]*(?:\r\n|\n)|[^\r\n]+$/g) ?? [];
@@ -17,7 +19,7 @@ export function normalizeFeishuMarkdown(markdown: string): string {
 
     if (!fence) {
       const opener = FENCE_OPENER.exec(body);
-      if (!opener?.[2]) return line;
+      if (!opener?.[2]) return `${includeLocalFileLineReferences(body)}${ending}`;
 
       const indent = opener[1] ?? "";
       const delimiter = opener[2];
@@ -38,6 +40,30 @@ export function normalizeFeishuMarkdown(markdown: string): string {
   }).join("");
 }
 
+function includeLocalFileLineReferences(markdown: string): string {
+  return markdown.replace(MARKDOWN_LINK, (link, imageMarker: string, label: string, rawTarget: string) => {
+    if (imageMarker) return link;
+
+    const target = unwrapMarkdownTarget(rawTarget.trim());
+    if (!isLocalFileTarget(target)) return link;
+
+    const reference = LOCAL_FILE_LINE_REFERENCE.exec(target)?.[1];
+    if (!reference || label.endsWith(reference)) return link;
+    return `[${label}${reference}](${rawTarget})`;
+  });
+}
+
+function unwrapMarkdownTarget(target: string): string {
+  return target.startsWith("<") && target.endsWith(">") ? target.slice(1, -1) : target;
+}
+
+function isLocalFileTarget(target: string): boolean {
+  return /^file:\/\//i.test(target)
+    || /^\/?[a-z]:[\\/]/i.test(target)
+    || /^\\\\/.test(target)
+    || /^\/(?!\/)/.test(target);
+}
+
 function isFenceCloser(line: string, fence: FenceState): boolean {
   const match = /^[ \t]*(`+|~+)[ \t]*$/.exec(line);
   const delimiter = match?.[1];

package/src/feishu/FeishuMessageClient.ts

@@ -48,6 +48,15 @@ interface UploadImageResponse {
   error?: unknown;
 }
 
+interface UploadFileResponse {
+  code: number;
+  msg: string;
+  data?: {
+    file_key?: string;
+  };
+  error?: unknown;
+}
+
 interface ReactionResponse {
   code: number;
   msg: string;
@@ -178,6 +187,11 @@ export class FeishuMessageClient implements FeishuOutbound {
     return this.sendMessage(contextKey, "text", { text });
   }
 
+  async sendFile(contextKey: string, filePath: string): Promise<string | undefined> {
+    const fileKey = await this.uploadFile(filePath);
+    return this.sendMessage(contextKey, "file", { file_key: fileKey });
+  }
+
   async sendMarkdown(contextKey: string, markdown: string, idempotencyKey?: string): Promise<string | undefined> {
     const normalizedMarkdown = normalizeFeishuMarkdown(markdown);
     const elements = await renderMarkdownWithLocalImages(
@@ -210,6 +224,15 @@ export class FeishuMessageClient implements FeishuOutbound {
     return this.replyMessage(contextKey, target, "text", { text }, idempotencyKey);
   }
 
+  async replyFile(
+    contextKey: string,
+    target: MessageReplyTarget,
+    filePath: string,
+  ): Promise<string | undefined> {
+    const fileKey = await this.uploadFile(filePath);
+    return this.replyMessage(contextKey, target, "file", { file_key: fileKey });
+  }
+
   async replyMarkdown(
     contextKey: string,
     target: MessageReplyTarget,
@@ -554,6 +577,40 @@ export class FeishuMessageClient implements FeishuOutbound {
     }
   }
 
+  private async uploadFile(filePath: string): Promise<string> {
+    const fileName = path.basename(filePath);
+    try {
+      const fileStats = await stat(filePath);
+      if (!fileStats.isFile()) throw new Error(`Not a regular file: ${fileName}`);
+      if (fileStats.size === 0) throw new Error(`Feishu does not accept empty files: ${fileName}`);
+      if (fileStats.size > 30 * 1024 * 1024) {
+        throw new Error(`File exceeds Feishu's 30 MiB limit: ${fileName}`);
+      }
+
+      const contents = await readFile(filePath);
+      const token = await this.getTenantAccessToken();
+      const form = new FormData();
+      form.append("file_type", "stream");
+      form.append("file_name", fileName);
+      const bytes = new ArrayBuffer(contents.byteLength);
+      new Uint8Array(bytes).set(contents);
+      form.append("file", new Blob([bytes]), fileName);
+      const response = await fetch("https://open.feishu.cn/open-apis/im/v1/files", {
+        method: "POST",
+        headers: { Authorization: `Bearer ${token}` },
+        body: form,
+      });
+      const payload = (await response.json()) as UploadFileResponse;
+      const fileKey = payload.data?.file_key;
+      if (!response.ok || payload.code !== 0 || !fileKey) {
+        throw new FeishuApiError(payload.msg || response.statusText, payload.code, payload, "upload file", response.status);
+      }
+      return fileKey;
+    } catch (error) {
+      throw normalizeTransportError(error, "upload file");
+    }
+  }
+
   private async uploadImageBytes(
     contents: Uint8Array,
     imageType: "message" | "avatar",
@@ -675,6 +732,7 @@ export class FeishuApiError extends Error {
       | SendMessageResponse
       | CreateGroupResponse
       | UploadImageResponse
+      | UploadFileResponse
       | ReactionResponse
       | DownloadImageErrorResponse,
     operation = "send",

package/src/feishu/FeishuTurnPresenter.ts

@@ -116,7 +116,7 @@ export class FeishuTurnPresenter {
     taskTitle?: string,
     replyTarget?: MessageReplyTarget,
     prompt?: string,
-  ): Promise<void> {
+  ): Promise<string | undefined> {
     const existing = this.pendingEntries.get(sessionId);
     if (existing) {
       await existing.initializing;
@@ -125,7 +125,7 @@ export class FeishuTurnPresenter {
         this.store.saveTurnSnapshot(existing.state.turnId, sessionId, existing.state, existing.contextKey);
         if (!existing.historySnapshot) existing.scheduler?.update(existing.state, "critical");
       }
-      return;
+      return existing.state.turnId;
     }
     this.sessionContexts.set(sessionId, contextKey);
     if (taskTitle) this.sessionTitles.set(sessionId, taskTitle);
@@ -146,6 +146,7 @@ export class FeishuTurnPresenter {
     entry.initializing = this.initializeEntry(entry);
     try {
       await entry.initializing;
+      return state.turnId;
     } catch (error) {
       if (this.pendingEntries.get(sessionId) === entry) this.pendingEntries.delete(sessionId);
       this.entries.delete(state.turnId);
@@ -169,6 +170,34 @@ export class FeishuTurnPresenter {
     await this.syncThinkingCardReaction(entry);
   }
 
+  async interruptTurnForRecovery(
+    sessionId: string,
+    contextKey: string,
+    turnId: string,
+    message: string,
+  ): Promise<void> {
+    const snapshot = this.store.getTurnSnapshot(turnId);
+    if (!isTurnViewState(snapshot) || snapshot.sessionId !== sessionId || isTerminalViewStatus(snapshot.status)) return;
+    const state: TurnViewState = {
+      ...snapshot,
+      status: "cancelled",
+      progressText: message,
+      activeTool: undefined,
+      approval: undefined,
+      completedAt: Date.now(),
+    };
+    this.store.saveTurnSnapshot(turnId, sessionId, state, contextKey);
+    const delivery = this.store.getTurnDelivery(turnId);
+    if (delivery?.progressMessageId) {
+      await this.outbound.updateInteractiveCard(delivery.progressMessageId, this.renderer.renderTurn(state));
+    }
+    const entry = this.entries.get(turnId);
+    if (entry) {
+      this.entries.delete(turnId);
+      if (this.pendingEntries.get(sessionId) === entry) this.pendingEntries.delete(sessionId);
+    }
+  }
+
   async appendSteerMessage(
     sessionId: string,
     turnId: string,
@@ -519,6 +548,10 @@ function isTerminalEvent(event: AgentEvent): boolean {
   return event.type === "turn_completed" || event.type === "turn_cancelled" || event.type === "turn_failed";
 }
 
+function isTerminalViewStatus(status: TurnViewState["status"]): boolean {
+  return status === "completed" || status === "cancelled" || status === "failed";
+}
+
 function thinkingCardReactionForStatus(status: TurnViewState["status"]): string | undefined {
   if (status === "completed") return undefined;
   if (status === "failed") return THINKING_CARD_FAILED_REACTION;

package/src/feishu/ownerAccess.ts

@@ -0,0 +1,7 @@
+import type { AppConfig } from "../config/schema.js";
+
+export function allowsFeishuUser(config: AppConfig, userOpenId: string | undefined): boolean {
+  if (config.feishu?.respondToOwnerOnly !== true) return true;
+  const ownerOpenId = config.feishu.userOpenId?.trim();
+  return Boolean(ownerOpenId && userOpenId === ownerOpenId);
+}

package/src/feishu/types.ts

@@ -9,6 +9,7 @@ export interface IncomingMessage {
   threadId?: string;
   rootMessageId?: string;
   parentMessageId?: string;
+  mentionedBot?: true;
   text: string;
   images?: IncomingImageReference[];
 }
@@ -53,6 +54,7 @@ export interface FeishuOutbound {
   deleteReaction?(messageId: string, reactionId: string): Promise<void>;
   downloadImage?(messageId: string, imageKey: string): Promise<string>;
   sendText(contextKey: string, text: string): Promise<string | undefined>;
+  sendFile?(contextKey: string, filePath: string): Promise<string | undefined>;
   sendMarkdown(contextKey: string, markdown: string, idempotencyKey?: string): Promise<string | undefined>;
   sendInteractiveCard(contextKey: string, card: Record<string, unknown>): Promise<string | undefined>;
   replyText?(
@@ -61,6 +63,11 @@ export interface FeishuOutbound {
     text: string,
     idempotencyKey?: string,
   ): Promise<string | undefined>;
+  replyFile?(
+    contextKey: string,
+    target: MessageReplyTarget,
+    filePath: string,
+  ): Promise<string | undefined>;
   replyMarkdown?(
     contextKey: string,
     target: MessageReplyTarget,