@openclaw/feishu 2026.5.2 → 2026.5.3-beta.2

package/src/card-interaction.ts

@@ -1,159 +0,0 @@
-import { isRecord } from "./comment-shared.js";
-
-export const FEISHU_CARD_INTERACTION_VERSION = "ocf1";
-
-type FeishuCardInteractionKind = "button" | "quick" | "meta";
-type FeishuCardInteractionReason = "malformed" | "stale" | "wrong_user" | "wrong_conversation";
-
-type FeishuCardInteractionMetadata = Record<string, string | number | boolean | null | undefined>;
-
-export type FeishuCardInteractionEnvelope = {
-  oc: typeof FEISHU_CARD_INTERACTION_VERSION;
-  k: FeishuCardInteractionKind;
-  a: string;
-  q?: string;
-  m?: FeishuCardInteractionMetadata;
-  c?: {
-    u?: string;
-    h?: string;
-    s?: string;
-    e?: number;
-    t?: "p2p" | "group";
-  };
-};
-
-type FeishuCardActionEventLike = {
-  operator: {
-    open_id?: string;
-  };
-  action: {
-    value: unknown;
-  };
-  context: {
-    chat_id?: string;
-  };
-};
-
-type DecodedFeishuCardAction =
-  | {
-      kind: "structured";
-      envelope: FeishuCardInteractionEnvelope;
-    }
-  | {
-      kind: "legacy";
-      text: string;
-    }
-  | {
-      kind: "invalid";
-      reason: FeishuCardInteractionReason;
-    };
-
-function isInteractionKind(value: unknown): value is FeishuCardInteractionKind {
-  return value === "button" || value === "quick" || value === "meta";
-}
-
-function isMetadataValue(value: unknown): value is string | number | boolean | null | undefined {
-  return (
-    value === null ||
-    value === undefined ||
-    typeof value === "string" ||
-    typeof value === "number" ||
-    typeof value === "boolean"
-  );
-}
-
-export function createFeishuCardInteractionEnvelope(
-  envelope: Omit<FeishuCardInteractionEnvelope, "oc">,
-): FeishuCardInteractionEnvelope {
-  return {
-    oc: FEISHU_CARD_INTERACTION_VERSION,
-    ...envelope,
-  };
-}
-
-export function buildFeishuCardActionTextFallback(event: FeishuCardActionEventLike): string {
-  const actionValue = event.action.value;
-  if (isRecord(actionValue)) {
-    if (typeof actionValue.text === "string") {
-      return actionValue.text;
-    }
-    if (typeof actionValue.command === "string") {
-      return actionValue.command;
-    }
-    return JSON.stringify(actionValue);
-  }
-  return String(actionValue);
-}
-
-export function decodeFeishuCardAction(params: {
-  event: FeishuCardActionEventLike;
-  now?: number;
-}): DecodedFeishuCardAction {
-  const { event, now = Date.now() } = params;
-  const actionValue = event.action.value;
-  if (!isRecord(actionValue) || actionValue.oc !== FEISHU_CARD_INTERACTION_VERSION) {
-    return {
-      kind: "legacy",
-      text: buildFeishuCardActionTextFallback(event),
-    };
-  }
-
-  if (!isInteractionKind(actionValue.k) || typeof actionValue.a !== "string" || !actionValue.a) {
-    return { kind: "invalid", reason: "malformed" };
-  }
-
-  if (actionValue.q !== undefined && typeof actionValue.q !== "string") {
-    return { kind: "invalid", reason: "malformed" };
-  }
-
-  if (actionValue.m !== undefined) {
-    if (!isRecord(actionValue.m)) {
-      return { kind: "invalid", reason: "malformed" };
-    }
-    for (const value of Object.values(actionValue.m)) {
-      if (!isMetadataValue(value)) {
-        return { kind: "invalid", reason: "malformed" };
-      }
-    }
-  }
-
-  if (actionValue.c !== undefined) {
-    if (!isRecord(actionValue.c)) {
-      return { kind: "invalid", reason: "malformed" };
-    }
-    if (actionValue.c.u !== undefined && typeof actionValue.c.u !== "string") {
-      return { kind: "invalid", reason: "malformed" };
-    }
-    if (actionValue.c.h !== undefined && typeof actionValue.c.h !== "string") {
-      return { kind: "invalid", reason: "malformed" };
-    }
-    if (actionValue.c.s !== undefined && typeof actionValue.c.s !== "string") {
-      return { kind: "invalid", reason: "malformed" };
-    }
-    if (actionValue.c.e !== undefined && !Number.isFinite(actionValue.c.e)) {
-      return { kind: "invalid", reason: "malformed" };
-    }
-    if (actionValue.c.t !== undefined && actionValue.c.t !== "p2p" && actionValue.c.t !== "group") {
-      return { kind: "invalid", reason: "malformed" };
-    }
-
-    if (typeof actionValue.c.e === "number" && actionValue.c.e < now) {
-      return { kind: "invalid", reason: "stale" };
-    }
-
-    const expectedUser = actionValue.c.u?.trim();
-    if (expectedUser && expectedUser !== (event.operator.open_id ?? "").trim()) {
-      return { kind: "invalid", reason: "wrong_user" };
-    }
-
-    const expectedChat = actionValue.c.h?.trim();
-    if (expectedChat && expectedChat !== (event.context.chat_id ?? "").trim()) {
-      return { kind: "invalid", reason: "wrong_conversation" };
-    }
-  }
-
-  return {
-    kind: "structured",
-    envelope: actionValue as FeishuCardInteractionEnvelope,
-  };
-}

package/src/card-test-helpers.ts

@@ -1,47 +0,0 @@
-import { expect } from "vitest";
-
-export function expectFirstSentCardUsesFillWidthOnly(sendCardMock: {
-  mock: { calls: unknown[][] };
-}) {
-  const firstSendArg = sendCardMock.mock.calls.at(0)?.[0] as
-    | {
-        card?: {
-          config?: {
-            width_mode?: string;
-            wide_screen_mode?: boolean;
-            enable_forward?: boolean;
-          };
-        };
-      }
-    | undefined;
-  const sentCard = firstSendArg?.card;
-  expect(sentCard).toBeDefined();
-  expect(sentCard?.config?.width_mode).toBe("fill");
-  expect(sentCard?.config?.wide_screen_mode).toBeUndefined();
-  expect(sentCard?.config?.enable_forward).toBeUndefined();
-}
-
-export function expectSentCardHasP2pAction(sendCardMock: unknown) {
-  expect(sendCardMock).toHaveBeenCalledWith(
-    expect.objectContaining({
-      card: expect.objectContaining({
-        body: expect.objectContaining({
-          elements: expect.arrayContaining([
-            expect.objectContaining({
-              tag: "action",
-              actions: expect.arrayContaining([
-                expect.objectContaining({
-                  value: expect.objectContaining({
-                    c: expect.objectContaining({
-                      t: "p2p",
-                    }),
-                  }),
-                }),
-              ]),
-            }),
-          ]),
-        }),
-      }),
-    }),
-  );
-}

package/src/card-ux-approval.ts

@@ -1,65 +0,0 @@
-import { createFeishuCardInteractionEnvelope } from "./card-interaction.js";
-import { buildFeishuCardButton, buildFeishuCardInteractionContext } from "./card-ux-shared.js";
-
-export const FEISHU_APPROVAL_REQUEST_ACTION = "feishu.quick_actions.request_approval";
-export const FEISHU_APPROVAL_CONFIRM_ACTION = "feishu.approval.confirm";
-export const FEISHU_APPROVAL_CANCEL_ACTION = "feishu.approval.cancel";
-
-export function createApprovalCard(params: {
-  operatorOpenId: string;
-  chatId?: string;
-  command: string;
-  prompt: string;
-  expiresAt: number;
-  chatType?: "p2p" | "group";
-  sessionKey?: string;
-  confirmLabel?: string;
-  cancelLabel?: string;
-}): Record<string, unknown> {
-  const context = buildFeishuCardInteractionContext(params);
-
-  return {
-    schema: "2.0",
-    config: {
-      width_mode: "fill",
-    },
-    header: {
-      title: {
-        tag: "plain_text",
-        content: "Confirm action",
-      },
-      template: "orange",
-    },
-    body: {
-      elements: [
-        {
-          tag: "markdown",
-          content: params.prompt,
-        },
-        {
-          tag: "action",
-          actions: [
-            buildFeishuCardButton({
-              label: params.confirmLabel ?? "Confirm",
-              type: "primary",
-              value: createFeishuCardInteractionEnvelope({
-                k: "quick",
-                a: FEISHU_APPROVAL_CONFIRM_ACTION,
-                q: params.command,
-                c: context,
-              }),
-            }),
-            buildFeishuCardButton({
-              label: params.cancelLabel ?? "Cancel",
-              value: createFeishuCardInteractionEnvelope({
-                k: "button",
-                a: FEISHU_APPROVAL_CANCEL_ACTION,
-                c: context,
-              }),
-            }),
-          ],
-        },
-      ],
-    },
-  };
-}

package/src/card-ux-launcher.test.ts

@@ -1,99 +0,0 @@
-import { createRuntimeEnv } from "openclaw/plugin-sdk/plugin-test-runtime";
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import type { ClawdbotConfig, RuntimeEnv } from "../runtime-api.js";
-import {
-  expectFirstSentCardUsesFillWidthOnly,
-  expectSentCardHasP2pAction,
-} from "./card-test-helpers.js";
-import {
-  createQuickActionLauncherCard,
-  isFeishuQuickActionMenuEventKey,
-  maybeHandleFeishuQuickActionMenu,
-} from "./card-ux-launcher.js";
-
-const sendCardFeishuMock = vi.hoisted(() => vi.fn());
-
-vi.mock("./send.js", () => ({
-  sendCardFeishu: sendCardFeishuMock,
-}));
-
-describe("feishu quick-action launcher", () => {
-  const cfg: ClawdbotConfig = {};
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("recognizes the quick-actions bot menu key", () => {
-    expect(isFeishuQuickActionMenuEventKey("quick-actions")).toBe(true);
-    expect(isFeishuQuickActionMenuEventKey("other")).toBe(false);
-  });
-
-  it("builds a launcher card with interactive actions", () => {
-    const card = createQuickActionLauncherCard({
-      operatorOpenId: "u123",
-      chatId: "chat1",
-      expiresAt: 123,
-      sessionKey: "agent:codex:feishu:chat:chat1",
-    }) as {
-      config: {
-        width_mode?: string;
-        enable_forward?: boolean;
-        wide_screen_mode?: boolean;
-      };
-      body: {
-        elements: Array<{
-          tag: string;
-          actions?: Array<{ value?: { oc?: string; c?: { s?: string; t?: string } } }>;
-        }>;
-      };
-    };
-
-    expect(card.config.width_mode).toBe("fill");
-    expect(card.config.enable_forward).toBeUndefined();
-    expect(card.config.wide_screen_mode).toBeUndefined();
-    const actionBlock = card.body.elements.find((entry) => entry.tag === "action");
-    expect(actionBlock?.actions).toHaveLength(3);
-    expect(actionBlock?.actions?.[0]?.value?.oc).toBe("ocf1");
-    expect(actionBlock?.actions?.[0]?.value?.c?.s).toBe("agent:codex:feishu:chat:chat1");
-    expect(actionBlock?.actions?.[0]?.value?.c?.t).toBeUndefined();
-  });
-
-  it("opens the launcher from a supported bot menu event", async () => {
-    sendCardFeishuMock.mockResolvedValue({ messageId: "m1", chatId: "c1" });
-
-    const handled = await maybeHandleFeishuQuickActionMenu({
-      cfg,
-      eventKey: "quick-actions",
-      operatorOpenId: "u123",
-      accountId: "main",
-      now: 100,
-    });
-
-    expect(handled).toBe(true);
-    expect(sendCardFeishuMock).toHaveBeenCalledWith(
-      expect.objectContaining({
-        to: "user:u123",
-        accountId: "main",
-      }),
-    );
-    expectSentCardHasP2pAction(sendCardFeishuMock);
-    expectFirstSentCardUsesFillWidthOnly(sendCardFeishuMock);
-  });
-
-  it("falls back to legacy menu handling when launcher send fails", async () => {
-    sendCardFeishuMock.mockRejectedValueOnce(new Error("network"));
-    const runtime: RuntimeEnv = createRuntimeEnv();
-
-    const handled = await maybeHandleFeishuQuickActionMenu({
-      cfg,
-      eventKey: "quick-actions",
-      operatorOpenId: "u123",
-      accountId: "main",
-      runtime,
-      now: 100,
-    });
-
-    expect(handled).toBe(false);
-  });
-});

package/src/card-ux-launcher.ts

@@ -1,121 +0,0 @@
-import { normalizeOptionalLowercaseString } from "openclaw/plugin-sdk/text-runtime";
-import type { ClawdbotConfig, RuntimeEnv } from "../runtime-api.js";
-import { createFeishuCardInteractionEnvelope } from "./card-interaction.js";
-import { FEISHU_APPROVAL_REQUEST_ACTION } from "./card-ux-approval.js";
-import { buildFeishuCardButton, buildFeishuCardInteractionContext } from "./card-ux-shared.js";
-import { sendCardFeishu } from "./send.js";
-
-const FEISHU_QUICK_ACTION_CARD_TTL_MS = 10 * 60_000;
-
-const QUICK_ACTION_MENU_KEYS = new Set(["quick-actions", "quick_actions", "launcher"]);
-
-export function isFeishuQuickActionMenuEventKey(eventKey: string): boolean {
-  return QUICK_ACTION_MENU_KEYS.has(normalizeOptionalLowercaseString(eventKey) ?? "");
-}
-
-export function createQuickActionLauncherCard(params: {
-  operatorOpenId: string;
-  chatId?: string;
-  expiresAt: number;
-  chatType?: "p2p" | "group";
-  sessionKey?: string;
-}): Record<string, unknown> {
-  const context = buildFeishuCardInteractionContext(params);
-  return {
-    schema: "2.0",
-    config: {
-      width_mode: "fill",
-    },
-    header: {
-      title: {
-        tag: "plain_text",
-        content: "Quick actions",
-      },
-      template: "indigo",
-    },
-    body: {
-      elements: [
-        {
-          tag: "markdown",
-          content: "Run common actions without typing raw commands.",
-        },
-        {
-          tag: "action",
-          actions: [
-            buildFeishuCardButton({
-              label: "Help",
-              value: createFeishuCardInteractionEnvelope({
-                k: "quick",
-                a: "feishu.quick_actions.help",
-                q: "/help",
-                c: context,
-              }),
-            }),
-            buildFeishuCardButton({
-              label: "New session",
-              type: "primary",
-              value: createFeishuCardInteractionEnvelope({
-                k: "meta",
-                a: FEISHU_APPROVAL_REQUEST_ACTION,
-                m: {
-                  command: "/new",
-                  prompt: "Start a fresh session? This will reset the current chat context.",
-                },
-                c: context,
-              }),
-            }),
-            buildFeishuCardButton({
-              label: "Reset",
-              type: "danger",
-              value: createFeishuCardInteractionEnvelope({
-                k: "meta",
-                a: FEISHU_APPROVAL_REQUEST_ACTION,
-                m: {
-                  command: "/reset",
-                  prompt: "Reset this session now? Any active conversation state will be cleared.",
-                },
-                c: context,
-              }),
-            }),
-          ],
-        },
-      ],
-    },
-  };
-}
-
-export async function maybeHandleFeishuQuickActionMenu(params: {
-  cfg: ClawdbotConfig;
-  eventKey: string;
-  operatorOpenId: string;
-  runtime?: RuntimeEnv;
-  accountId?: string;
-  now?: number;
-}): Promise<boolean> {
-  if (!isFeishuQuickActionMenuEventKey(params.eventKey)) {
-    return false;
-  }
-
-  const expiresAt = (params.now ?? Date.now()) + FEISHU_QUICK_ACTION_CARD_TTL_MS;
-  try {
-    await sendCardFeishu({
-      cfg: params.cfg,
-      to: `user:${params.operatorOpenId}`,
-      card: createQuickActionLauncherCard({
-        operatorOpenId: params.operatorOpenId,
-        expiresAt,
-        chatType: "p2p",
-      }),
-      accountId: params.accountId,
-    });
-  } catch (err) {
-    params.runtime?.log?.(
-      `feishu[${params.accountId ?? "default"}]: failed to open quick-action launcher for ${params.operatorOpenId}: ${String(err)}`,
-    );
-    return false;
-  }
-  params.runtime?.log?.(
-    `feishu[${params.accountId ?? "default"}]: opened quick-action launcher for ${params.operatorOpenId}`,
-  );
-  return true;
-}

package/src/card-ux-shared.ts

@@ -1,33 +0,0 @@
-import type { FeishuCardInteractionEnvelope } from "./card-interaction.js";
-
-export function buildFeishuCardButton(params: {
-  label: string;
-  value: FeishuCardInteractionEnvelope;
-  type?: "default" | "primary" | "danger";
-}) {
-  return {
-    tag: "button",
-    text: {
-      tag: "plain_text",
-      content: params.label,
-    },
-    type: params.type ?? "default",
-    value: params.value,
-  };
-}
-
-export function buildFeishuCardInteractionContext(params: {
-  operatorOpenId: string;
-  chatId?: string;
-  expiresAt: number;
-  chatType?: "p2p" | "group";
-  sessionKey?: string;
-}) {
-  return {
-    u: params.operatorOpenId,
-    ...(params.chatId ? { h: params.chatId } : {}),
-    ...(params.sessionKey ? { s: params.sessionKey } : {}),
-    e: params.expiresAt,
-    ...(params.chatType ? { t: params.chatType } : {}),
-  };
-}

package/src/channel-runtime-api.ts

@@ -1,16 +0,0 @@
-export type {
-  ChannelMessageActionName,
-  ChannelMeta,
-  ChannelPlugin,
-  ClawdbotConfig,
-} from "../runtime-api.js";
-
-export { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-resolution";
-export { createActionGate } from "openclaw/plugin-sdk/channel-actions";
-export { buildChannelConfigSchema } from "openclaw/plugin-sdk/channel-config-primitives";
-export {
-  buildProbeChannelStatusSummary,
-  createDefaultChannelRuntimeState,
-} from "openclaw/plugin-sdk/status-helpers";
-export { PAIRING_APPROVED_MESSAGE } from "openclaw/plugin-sdk/channel-status";
-export { chunkTextForOutbound } from "openclaw/plugin-sdk/text-chunking";

package/src/channel.runtime.ts

@@ -1,47 +0,0 @@
-import {
-  getChatInfo as getChatInfoImpl,
-  getChatMembers as getChatMembersImpl,
-  getFeishuMemberInfo as getFeishuMemberInfoImpl,
-} from "./chat.js";
-import {
-  listFeishuDirectoryGroupsLive as listFeishuDirectoryGroupsLiveImpl,
-  listFeishuDirectoryPeersLive as listFeishuDirectoryPeersLiveImpl,
-} from "./directory.js";
-import { feishuOutbound as feishuOutboundImpl } from "./outbound.js";
-import {
-  createPinFeishu as createPinFeishuImpl,
-  listPinsFeishu as listPinsFeishuImpl,
-  removePinFeishu as removePinFeishuImpl,
-} from "./pins.js";
-import { probeFeishu as probeFeishuImpl } from "./probe.js";
-import {
-  addReactionFeishu as addReactionFeishuImpl,
-  listReactionsFeishu as listReactionsFeishuImpl,
-  removeReactionFeishu as removeReactionFeishuImpl,
-} from "./reactions.js";
-import {
-  editMessageFeishu as editMessageFeishuImpl,
-  getMessageFeishu as getMessageFeishuImpl,
-  sendCardFeishu as sendCardFeishuImpl,
-  sendMessageFeishu as sendMessageFeishuImpl,
-} from "./send.js";
-
-export const feishuChannelRuntime = {
-  listFeishuDirectoryGroupsLive: listFeishuDirectoryGroupsLiveImpl,
-  listFeishuDirectoryPeersLive: listFeishuDirectoryPeersLiveImpl,
-  feishuOutbound: { ...feishuOutboundImpl },
-  createPinFeishu: createPinFeishuImpl,
-  listPinsFeishu: listPinsFeishuImpl,
-  removePinFeishu: removePinFeishuImpl,
-  probeFeishu: probeFeishuImpl,
-  addReactionFeishu: addReactionFeishuImpl,
-  listReactionsFeishu: listReactionsFeishuImpl,
-  removeReactionFeishu: removeReactionFeishuImpl,
-  getChatInfo: getChatInfoImpl,
-  getChatMembers: getChatMembersImpl,
-  getFeishuMemberInfo: getFeishuMemberInfoImpl,
-  editMessageFeishu: editMessageFeishuImpl,
-  getMessageFeishu: getMessageFeishuImpl,
-  sendCardFeishu: sendCardFeishuImpl,
-  sendMessageFeishu: sendMessageFeishuImpl,
-};