@openclaw/feishu 2026.5.2 → 2026.5.3-beta.2

package/src/thread-bindings.ts

@@ -1,330 +0,0 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
-import {
-  resolveThreadBindingIdleTimeoutMsForChannel,
-  resolveThreadBindingMaxAgeMsForChannel,
-  registerSessionBindingAdapter,
-  resolveThreadBindingConversationIdFromBindingId,
-  unregisterSessionBindingAdapter,
-  type BindingTargetKind,
-  type SessionBindingAdapter,
-  type SessionBindingRecord,
-} from "openclaw/plugin-sdk/conversation-runtime";
-import { normalizeAccountId, resolveAgentIdFromSessionKey } from "openclaw/plugin-sdk/routing";
-import { normalizeOptionalString } from "openclaw/plugin-sdk/text-runtime";
-
-type FeishuBindingTargetKind = "subagent" | "acp";
-
-type FeishuThreadBindingRecord = {
-  accountId: string;
-  conversationId: string;
-  parentConversationId?: string;
-  deliveryTo?: string;
-  deliveryThreadId?: string;
-  targetKind: FeishuBindingTargetKind;
-  targetSessionKey: string;
-  agentId?: string;
-  label?: string;
-  boundBy?: string;
-  boundAt: number;
-  lastActivityAt: number;
-};
-
-type FeishuThreadBindingManager = {
-  accountId: string;
-  getByConversationId: (conversationId: string) => FeishuThreadBindingRecord | undefined;
-  listBySessionKey: (targetSessionKey: string) => FeishuThreadBindingRecord[];
-  bindConversation: (params: {
-    conversationId: string;
-    parentConversationId?: string;
-    targetKind: BindingTargetKind;
-    targetSessionKey: string;
-    metadata?: Record<string, unknown>;
-  }) => FeishuThreadBindingRecord | null;
-  touchConversation: (conversationId: string, at?: number) => FeishuThreadBindingRecord | null;
-  unbindConversation: (conversationId: string) => FeishuThreadBindingRecord | null;
-  unbindBySessionKey: (targetSessionKey: string) => FeishuThreadBindingRecord[];
-  stop: () => void;
-};
-
-type FeishuThreadBindingsState = {
-  managersByAccountId: Map<string, FeishuThreadBindingManager>;
-  bindingsByAccountConversation: Map<string, FeishuThreadBindingRecord>;
-};
-
-const FEISHU_THREAD_BINDINGS_STATE_KEY = Symbol.for("openclaw.feishuThreadBindingsState");
-let state: FeishuThreadBindingsState | undefined;
-
-function getState(): FeishuThreadBindingsState {
-  if (!state) {
-    const globalStore = globalThis as Record<PropertyKey, unknown>;
-    state = (globalStore[FEISHU_THREAD_BINDINGS_STATE_KEY] as
-      | FeishuThreadBindingsState
-      | undefined) ?? {
-      managersByAccountId: new Map(),
-      bindingsByAccountConversation: new Map(),
-    };
-    globalStore[FEISHU_THREAD_BINDINGS_STATE_KEY] = state;
-  }
-  return state;
-}
-
-function resolveBindingKey(params: { accountId: string; conversationId: string }): string {
-  return `${params.accountId}:${params.conversationId}`;
-}
-
-function toSessionBindingTargetKind(raw: FeishuBindingTargetKind): BindingTargetKind {
-  return raw === "subagent" ? "subagent" : "session";
-}
-
-function toFeishuTargetKind(raw: BindingTargetKind): FeishuBindingTargetKind {
-  return raw === "subagent" ? "subagent" : "acp";
-}
-
-function toSessionBindingRecord(
-  record: FeishuThreadBindingRecord,
-  defaults: { idleTimeoutMs: number; maxAgeMs: number },
-): SessionBindingRecord {
-  const idleExpiresAt =
-    defaults.idleTimeoutMs > 0 ? record.lastActivityAt + defaults.idleTimeoutMs : undefined;
-  const maxAgeExpiresAt = defaults.maxAgeMs > 0 ? record.boundAt + defaults.maxAgeMs : undefined;
-  const expiresAt =
-    idleExpiresAt != null && maxAgeExpiresAt != null
-      ? Math.min(idleExpiresAt, maxAgeExpiresAt)
-      : (idleExpiresAt ?? maxAgeExpiresAt);
-  return {
-    bindingId: resolveBindingKey({
-      accountId: record.accountId,
-      conversationId: record.conversationId,
-    }),
-    targetSessionKey: record.targetSessionKey,
-    targetKind: toSessionBindingTargetKind(record.targetKind),
-    conversation: {
-      channel: "feishu",
-      accountId: record.accountId,
-      conversationId: record.conversationId,
-      parentConversationId: record.parentConversationId,
-    },
-    status: "active",
-    boundAt: record.boundAt,
-    expiresAt,
-    metadata: {
-      agentId: record.agentId,
-      label: record.label,
-      boundBy: record.boundBy,
-      deliveryTo: record.deliveryTo,
-      deliveryThreadId: record.deliveryThreadId,
-      lastActivityAt: record.lastActivityAt,
-      idleTimeoutMs: defaults.idleTimeoutMs,
-      maxAgeMs: defaults.maxAgeMs,
-    },
-  };
-}
-
-export function createFeishuThreadBindingManager(params: {
-  accountId?: string;
-  cfg: OpenClawConfig;
-}): FeishuThreadBindingManager {
-  const accountId = normalizeAccountId(params.accountId);
-  const existing = getState().managersByAccountId.get(accountId);
-  if (existing) {
-    return existing;
-  }
-
-  const idleTimeoutMs = resolveThreadBindingIdleTimeoutMsForChannel({
-    cfg: params.cfg,
-    channel: "feishu",
-    accountId,
-  });
-  const maxAgeMs = resolveThreadBindingMaxAgeMsForChannel({
-    cfg: params.cfg,
-    channel: "feishu",
-    accountId,
-  });
-
-  const manager: FeishuThreadBindingManager = {
-    accountId,
-    getByConversationId: (conversationId) =>
-      getState().bindingsByAccountConversation.get(
-        resolveBindingKey({ accountId, conversationId }),
-      ),
-    listBySessionKey: (targetSessionKey) =>
-      [...getState().bindingsByAccountConversation.values()].filter(
-        (record) => record.accountId === accountId && record.targetSessionKey === targetSessionKey,
-      ),
-    bindConversation: ({
-      conversationId,
-      parentConversationId,
-      targetKind,
-      targetSessionKey,
-      metadata,
-    }) => {
-      const normalizedConversationId = conversationId.trim();
-      const normalizedTargetSessionKey = targetSessionKey.trim();
-      if (!normalizedConversationId || !normalizedTargetSessionKey) {
-        return null;
-      }
-      const existing = getState().bindingsByAccountConversation.get(
-        resolveBindingKey({ accountId, conversationId: normalizedConversationId }),
-      );
-      const now = Date.now();
-      const record: FeishuThreadBindingRecord = {
-        accountId,
-        conversationId: normalizedConversationId,
-        parentConversationId:
-          normalizeOptionalString(parentConversationId) ?? existing?.parentConversationId,
-        deliveryTo:
-          typeof metadata?.deliveryTo === "string" && metadata.deliveryTo.trim()
-            ? metadata.deliveryTo.trim()
-            : existing?.deliveryTo,
-        deliveryThreadId:
-          typeof metadata?.deliveryThreadId === "string" && metadata.deliveryThreadId.trim()
-            ? metadata.deliveryThreadId.trim()
-            : existing?.deliveryThreadId,
-        targetKind: toFeishuTargetKind(targetKind),
-        targetSessionKey: normalizedTargetSessionKey,
-        agentId:
-          typeof metadata?.agentId === "string" && metadata.agentId.trim()
-            ? metadata.agentId.trim()
-            : (existing?.agentId ?? resolveAgentIdFromSessionKey(normalizedTargetSessionKey)),
-        label:
-          typeof metadata?.label === "string" && metadata.label.trim()
-            ? metadata.label.trim()
-            : existing?.label,
-        boundBy:
-          typeof metadata?.boundBy === "string" && metadata.boundBy.trim()
-            ? metadata.boundBy.trim()
-            : existing?.boundBy,
-        boundAt: now,
-        lastActivityAt: now,
-      };
-      getState().bindingsByAccountConversation.set(
-        resolveBindingKey({ accountId, conversationId: normalizedConversationId }),
-        record,
-      );
-      return record;
-    },
-    touchConversation: (conversationId, at = Date.now()) => {
-      const key = resolveBindingKey({ accountId, conversationId });
-      const existingRecord = getState().bindingsByAccountConversation.get(key);
-      if (!existingRecord) {
-        return null;
-      }
-      const updated = { ...existingRecord, lastActivityAt: at };
-      getState().bindingsByAccountConversation.set(key, updated);
-      return updated;
-    },
-    unbindConversation: (conversationId) => {
-      const key = resolveBindingKey({ accountId, conversationId });
-      const existingRecord = getState().bindingsByAccountConversation.get(key);
-      if (!existingRecord) {
-        return null;
-      }
-      getState().bindingsByAccountConversation.delete(key);
-      return existingRecord;
-    },
-    unbindBySessionKey: (targetSessionKey) => {
-      const removed: FeishuThreadBindingRecord[] = [];
-      for (const record of getState().bindingsByAccountConversation.values()) {
-        if (record.accountId !== accountId || record.targetSessionKey !== targetSessionKey) {
-          continue;
-        }
-        getState().bindingsByAccountConversation.delete(
-          resolveBindingKey({ accountId, conversationId: record.conversationId }),
-        );
-        removed.push(record);
-      }
-      return removed;
-    },
-    stop: () => {
-      for (const key of getState().bindingsByAccountConversation.keys()) {
-        if (key.startsWith(`${accountId}:`)) {
-          getState().bindingsByAccountConversation.delete(key);
-        }
-      }
-      getState().managersByAccountId.delete(accountId);
-      unregisterSessionBindingAdapter({
-        channel: "feishu",
-        accountId,
-        adapter: sessionBindingAdapter,
-      });
-    },
-  };
-
-  const sessionBindingAdapter: SessionBindingAdapter = {
-    channel: "feishu",
-    accountId,
-    capabilities: {
-      placements: ["current"],
-    },
-    bind: async (input) => {
-      if (input.conversation.channel !== "feishu" || input.placement === "child") {
-        return null;
-      }
-      const bound = manager.bindConversation({
-        conversationId: input.conversation.conversationId,
-        parentConversationId: input.conversation.parentConversationId,
-        targetKind: input.targetKind,
-        targetSessionKey: input.targetSessionKey,
-        metadata: input.metadata,
-      });
-      return bound ? toSessionBindingRecord(bound, { idleTimeoutMs, maxAgeMs }) : null;
-    },
-    listBySession: (targetSessionKey) =>
-      manager
-        .listBySessionKey(targetSessionKey)
-        .map((entry) => toSessionBindingRecord(entry, { idleTimeoutMs, maxAgeMs })),
-    resolveByConversation: (ref) => {
-      if (ref.channel !== "feishu") {
-        return null;
-      }
-      const found = manager.getByConversationId(ref.conversationId);
-      return found ? toSessionBindingRecord(found, { idleTimeoutMs, maxAgeMs }) : null;
-    },
-    touch: (bindingId, at) => {
-      const conversationId = resolveThreadBindingConversationIdFromBindingId({
-        accountId,
-        bindingId,
-      });
-      if (conversationId) {
-        manager.touchConversation(conversationId, at);
-      }
-    },
-    unbind: async (input) => {
-      if (input.targetSessionKey?.trim()) {
-        return manager
-          .unbindBySessionKey(input.targetSessionKey.trim())
-          .map((entry) => toSessionBindingRecord(entry, { idleTimeoutMs, maxAgeMs }));
-      }
-      const conversationId = resolveThreadBindingConversationIdFromBindingId({
-        accountId,
-        bindingId: input.bindingId,
-      });
-      if (!conversationId) {
-        return [];
-      }
-      const removed = manager.unbindConversation(conversationId);
-      return removed ? [toSessionBindingRecord(removed, { idleTimeoutMs, maxAgeMs })] : [];
-    },
-  };
-
-  registerSessionBindingAdapter(sessionBindingAdapter);
-
-  getState().managersByAccountId.set(accountId, manager);
-  return manager;
-}
-
-export function getFeishuThreadBindingManager(
-  accountId?: string,
-): FeishuThreadBindingManager | null {
-  return getState().managersByAccountId.get(normalizeAccountId(accountId)) ?? null;
-}
-
-export const __testing = {
-  resetFeishuThreadBindingsForTests() {
-    for (const manager of getState().managersByAccountId.values()) {
-      manager.stop();
-    }
-    getState().managersByAccountId.clear();
-    getState().bindingsByAccountConversation.clear();
-  },
-};

package/src/tool-account-routing.test.ts

@@ -1,187 +0,0 @@
-import { beforeAll, beforeEach, describe, expect, test, vi } from "vitest";
-import type { OpenClawPluginApi } from "../runtime-api.js";
-import { createToolFactoryHarness } from "./tool-factory-test-harness.js";
-
-const createFeishuClientMock = vi.fn((account: { appId?: string } | undefined) => ({
-  __appId: account?.appId,
-}));
-
-vi.mock("./client.js", () => ({
-  createFeishuClient: (account: { appId?: string } | undefined) => createFeishuClientMock(account),
-}));
-
-let registerFeishuBitableTools: typeof import("./bitable.js").registerFeishuBitableTools;
-let registerFeishuDriveTools: typeof import("./drive.js").registerFeishuDriveTools;
-let registerFeishuPermTools: typeof import("./perm.js").registerFeishuPermTools;
-let registerFeishuWikiTools: typeof import("./wiki.js").registerFeishuWikiTools;
-
-function createConfig(params: {
-  toolsA?: {
-    wiki?: boolean;
-    drive?: boolean;
-    perm?: boolean;
-  };
-  toolsB?: {
-    wiki?: boolean;
-    drive?: boolean;
-    perm?: boolean;
-  };
-  defaultAccount?: string;
-}): OpenClawPluginApi["config"] {
-  return {
-    channels: {
-      feishu: {
-        enabled: true,
-        defaultAccount: params.defaultAccount,
-        accounts: {
-          a: {
-            appId: "app-a",
-            appSecret: "sec-a", // pragma: allowlist secret
-            tools: params.toolsA,
-          },
-          b: {
-            appId: "app-b",
-            appSecret: "sec-b", // pragma: allowlist secret
-            tools: params.toolsB,
-          },
-        },
-      },
-    },
-  } as OpenClawPluginApi["config"];
-}
-
-describe("feishu tool account routing", () => {
-  beforeAll(async () => {
-    ({ registerFeishuBitableTools, registerFeishuDriveTools, registerFeishuPermTools } =
-      await import("./bitable.js").then(async ({ registerFeishuBitableTools }) => ({
-        registerFeishuBitableTools,
-        ...(await import("./drive.js")),
-        ...(await import("./perm.js")),
-        ...(await import("./wiki.js")),
-      })));
-    ({ registerFeishuWikiTools } = await import("./wiki.js"));
-  });
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  test("wiki tool registers when first account disables it and routes to agentAccountId", async () => {
-    const { api, resolveTool } = createToolFactoryHarness(
-      createConfig({
-        toolsA: { wiki: false },
-        toolsB: { wiki: true },
-      }),
-    );
-    registerFeishuWikiTools(api);
-
-    const tool = resolveTool("feishu_wiki", { agentAccountId: "b" });
-    await tool.execute("call", { action: "search" });
-
-    expect(createFeishuClientMock.mock.calls.at(-1)?.[0]?.appId).toBe("app-b");
-  });
-
-  test("wiki tool prefers the active contextual account over configured defaultAccount", async () => {
-    const { api, resolveTool } = createToolFactoryHarness(
-      createConfig({
-        defaultAccount: "b",
-        toolsA: { wiki: true },
-        toolsB: { wiki: true },
-      }),
-    );
-    registerFeishuWikiTools(api);
-
-    const tool = resolveTool("feishu_wiki", { agentAccountId: "a" });
-    await tool.execute("call", { action: "search" });
-
-    expect(createFeishuClientMock.mock.calls.at(-1)?.[0]?.appId).toBe("app-a");
-  });
-
-  test("drive tool registers when first account disables it and routes to agentAccountId", async () => {
-    const { api, resolveTool } = createToolFactoryHarness(
-      createConfig({
-        toolsA: { drive: false },
-        toolsB: { drive: true },
-      }),
-    );
-    registerFeishuDriveTools(api);
-
-    const tool = resolveTool("feishu_drive", { agentAccountId: "b" });
-    await tool.execute("call", { action: "unknown_action" });
-
-    expect(createFeishuClientMock.mock.calls.at(-1)?.[0]?.appId).toBe("app-b");
-  });
-
-  test("perm tool registers when only second account enables it and routes to agentAccountId", async () => {
-    const { api, resolveTool } = createToolFactoryHarness(
-      createConfig({
-        toolsA: { perm: false },
-        toolsB: { perm: true },
-      }),
-    );
-    registerFeishuPermTools(api);
-
-    const tool = resolveTool("feishu_perm", { agentAccountId: "b" });
-    await tool.execute("call", { action: "unknown_action" });
-
-    expect(createFeishuClientMock.mock.calls.at(-1)?.[0]?.appId).toBe("app-b");
-  });
-
-  test("bitable tool routes to agentAccountId and allows explicit accountId override", async () => {
-    const { api, resolveTool } = createToolFactoryHarness(createConfig({}));
-    registerFeishuBitableTools(api);
-
-    const tool = resolveTool("feishu_bitable_get_meta", { agentAccountId: "b" });
-    await tool.execute("call-ctx", { url: "invalid-url" });
-    await tool.execute("call-override", { url: "invalid-url", accountId: "a" });
-
-    expect(createFeishuClientMock.mock.calls[0]?.[0]?.appId).toBe("app-b");
-    expect(createFeishuClientMock.mock.calls[1]?.[0]?.appId).toBe("app-a");
-  });
-
-  test("falls back to the configured Feishu default selection when agentAccountId is not a real account", async () => {
-    const { api, resolveTool } = createToolFactoryHarness(
-      createConfig({
-        toolsA: { wiki: true },
-        toolsB: { wiki: true },
-      }),
-    );
-    registerFeishuWikiTools(api);
-
-    const tool = resolveTool("feishu_wiki", { agentAccountId: "agent-spawner" });
-    await tool.execute("call", { action: "search" });
-
-    expect(createFeishuClientMock.mock.calls.at(-1)?.[0]?.appId).toBe("app-a");
-  });
-
-  test("does not silently fall back when the contextual account is real but uses non-env SecretRefs", async () => {
-    const { api, resolveTool } = createToolFactoryHarness({
-      channels: {
-        feishu: {
-          enabled: true,
-          accounts: {
-            a: {
-              appId: "app-a",
-              appSecret: "sec-a", // pragma: allowlist secret
-              tools: { wiki: true },
-            },
-            b: {
-              appId: "app-b",
-              appSecret: { source: "file", provider: "default", id: "feishu/b-secret" },
-              tools: { wiki: true },
-            } as never,
-          },
-        },
-      },
-    } as OpenClawPluginApi["config"]);
-    registerFeishuWikiTools(api);
-
-    const tool = resolveTool("feishu_wiki", { agentAccountId: "b" });
-    const result = await tool.execute("call", { action: "search" });
-
-    expect(createFeishuClientMock).not.toHaveBeenCalled();
-    expect(typeof result.details.error === "string" ? result.details.error : "").toContain(
-      "Resolve this command against an active gateway runtime snapshot before reading it.",
-    );
-  });
-});

package/src/tool-account.test.ts

@@ -1,44 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { resolveFeishuToolAccount } from "./tool-account.js";
-
-describe("resolveFeishuToolAccount", () => {
-  const cfg = {
-    channels: {
-      feishu: {
-        enabled: true,
-        defaultAccount: "ops",
-        appId: "base-app-id",
-        appSecret: "base-app-secret", // pragma: allowlist secret
-        accounts: {
-          ops: {
-            enabled: true,
-            appId: "ops-app-id",
-            appSecret: "ops-app-secret", // pragma: allowlist secret
-          },
-          work: {
-            enabled: true,
-            appId: "work-app-id",
-            appSecret: "work-app-secret", // pragma: allowlist secret
-          },
-        },
-      },
-    },
-  };
-
-  it("prefers the active contextual account over configured defaultAccount", () => {
-    const resolved = resolveFeishuToolAccount({
-      api: { config: cfg },
-      defaultAccountId: "work",
-    });
-
-    expect(resolved.accountId).toBe("work");
-  });
-
-  it("falls back to configured defaultAccount when there is no contextual account", () => {
-    const resolved = resolveFeishuToolAccount({
-      api: { config: cfg },
-    });
-
-    expect(resolved.accountId).toBe("ops");
-  });
-});

package/src/tool-account.ts

@@ -1,93 +0,0 @@
-import type * as Lark from "@larksuiteoapi/node-sdk";
-import { normalizeOptionalString } from "openclaw/plugin-sdk/text-runtime";
-import type { OpenClawPluginApi } from "../runtime-api.js";
-import {
-  listFeishuAccountIds,
-  resolveFeishuAccount,
-  resolveFeishuRuntimeAccount,
-} from "./accounts.js";
-import { createFeishuClient } from "./client.js";
-import { resolveToolsConfig } from "./tools-config.js";
-import type { FeishuToolsConfig, ResolvedFeishuAccount } from "./types.js";
-
-type AccountAwareParams = { accountId?: string };
-
-function resolveImplicitToolAccountId(params: {
-  api: Pick<OpenClawPluginApi, "config">;
-  executeParams?: AccountAwareParams;
-  defaultAccountId?: string;
-}): string | undefined {
-  const explicitAccountId = normalizeOptionalString(params.executeParams?.accountId);
-  if (explicitAccountId) {
-    return explicitAccountId;
-  }
-
-  const contextualAccountId = normalizeOptionalString(params.defaultAccountId);
-  if (
-    contextualAccountId &&
-    listFeishuAccountIds(params.api.config).includes(contextualAccountId)
-  ) {
-    const contextualAccount = resolveFeishuAccount({
-      cfg: params.api.config,
-      accountId: contextualAccountId,
-    });
-    if (contextualAccount.enabled) {
-      return contextualAccountId;
-    }
-  }
-
-  const configuredDefaultAccountId = normalizeOptionalString(
-    (params.api.config?.channels?.feishu as { defaultAccount?: unknown } | undefined)
-      ?.defaultAccount,
-  );
-  if (configuredDefaultAccountId) {
-    return configuredDefaultAccountId;
-  }
-
-  return undefined;
-}
-
-export function resolveFeishuToolAccount(params: {
-  api: Pick<OpenClawPluginApi, "config">;
-  executeParams?: AccountAwareParams;
-  defaultAccountId?: string;
-}): ResolvedFeishuAccount {
-  if (!params.api.config) {
-    throw new Error("Feishu config unavailable");
-  }
-  return resolveFeishuRuntimeAccount({
-    cfg: params.api.config,
-    accountId: resolveImplicitToolAccountId(params),
-  });
-}
-
-export function createFeishuToolClient(params: {
-  api: Pick<OpenClawPluginApi, "config">;
-  executeParams?: AccountAwareParams;
-  defaultAccountId?: string;
-}): Lark.Client {
-  return createFeishuClient(resolveFeishuToolAccount(params));
-}
-
-export function resolveAnyEnabledFeishuToolsConfig(
-  accounts: ResolvedFeishuAccount[],
-): Required<FeishuToolsConfig> {
-  const merged: Required<FeishuToolsConfig> = {
-    doc: false,
-    chat: false,
-    wiki: false,
-    drive: false,
-    perm: false,
-    scopes: false,
-  };
-  for (const account of accounts) {
-    const cfg = resolveToolsConfig(account.config.tools);
-    merged.doc = merged.doc || cfg.doc;
-    merged.chat = merged.chat || cfg.chat;
-    merged.wiki = merged.wiki || cfg.wiki;
-    merged.drive = merged.drive || cfg.drive;
-    merged.perm = merged.perm || cfg.perm;
-    merged.scopes = merged.scopes || cfg.scopes;
-  }
-  return merged;
-}