@openclaw/feishu 2026.9.8 → 2026.10.1-beta.1

package/dist/.setup/{chat-D8MlFAZi.mjs → chat-BdyvImsY.mjs}

@@ -1,5 +1,5 @@
-import { Ct as resolveFeishuChatReadPreliminaryAuthorization, J as feishuExternalToolResult, Nt as resolveFeishuChatType, Q as assertFeishuApiSuccess, St as readFeishuChatInfoWithAuthorization, Z as resolveFeishuToolAccount, _t as authorizeFeishuChatMemberRead, gt as assertFeishuChatReadAllowed, q as registerFeishuTool, rt as formatFeishuApiError } from "./reply-delivery-result-COAjaukc.mjs";
-import { r as createFeishuClient } from "./client-BYG-_IZl.mjs";
+import { Ct as readFeishuChatInfoWithAuthorization, J as feishuExternalToolResult, Pt as resolveFeishuChatType, Q as assertFeishuApiSuccess, Z as resolveFeishuToolAccount, _t as assertFeishuChatReadAllowed, q as registerFeishuTool, rt as formatFeishuApiError, vt as authorizeFeishuChatMemberRead, wt as resolveFeishuChatReadPreliminaryAuthorization } from "./reply-delivery-result-Bt-BWBEA.mjs";
+import { r as createFeishuClient } from "./client-BsBVWJzN.mjs";
 import { optionalPositiveIntegerSchema } from "openclaw/plugin-sdk/channel-actions";
 import { readPositiveIntegerParam } from "openclaw/plugin-sdk/param-readers";
 import { Type } from "typebox";
@@ -30,12 +30,6 @@ const FeishuChatSchema = Type.Object({
 });
 //#endregion
 //#region extensions/feishu/src/chat.ts
-function readChatPageSize(params) {
-	return readPositiveIntegerParam(params, "page_size", {
-		max: 100,
-		message: "page_size must be a positive integer between 1 and 100"
-	});
-}
 function buildFeishuDirectChatMembers(authorization) {
 	return {
 		chat_id: authorization.chatId,
@@ -208,7 +202,10 @@ function registerFeishuChatTools(api) {
 					memberId: p.action === "member_info" ? p.member_id : void 0,
 					memberIdType: p.member_id_type
 				});
-				if (p.action === "members") return feishuExternalToolResult(authorization.kind === "direct" ? buildFeishuDirectChatMembers(authorization) : await getChatMembers(client, p.chat_id, readChatPageSize(p), p.page_token, p.member_id_type));
+				if (p.action === "members") return feishuExternalToolResult(authorization.kind === "direct" ? buildFeishuDirectChatMembers(authorization) : await getChatMembers(client, p.chat_id, readPositiveIntegerParam(p, "page_size", {
+					max: 100,
+					message: "page_size must be a positive integer between 1 and 100"
+				}), p.page_token, p.member_id_type));
 				if (authorization.kind === "group") {
 					const memberIdType = p.member_id_type ?? "open_id";
 					await assertFeishuChatMember(client, p.chat_id, p.member_id, memberIdType);

package/dist/.setup/{client-BYG-_IZl.mjs → client-BsBVWJzN.mjs}

@@ -1,4 +1,4 @@
-import { s as __exportAll } from "./doctor-contract-3XC0vbIw.mjs";
+import { g as __exportAll } from "./doctor-contract-B1B9ogdd.mjs";
 import { createRequire } from "node:module";
 import { PlatformMessageNotDispatchedError } from "openclaw/plugin-sdk/error-runtime";
 import { parseStrictPositiveInteger } from "openclaw/plugin-sdk/number-runtime";

package/dist/.setup/{doctor-contract-3XC0vbIw.mjs → doctor-contract-B1B9ogdd.mjs}

@@ -1,7 +1,10 @@
 import "node:module";
-import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
-import { ContextVisibilityModeSchema, DmPolicySchema, GroupPolicySchema, ReplyToModeSchema, buildChannelConfigSchema, buildGroupEntrySchema, buildMultiAccountChannelSchema } from "openclaw/plugin-sdk/channel-config-schema";
-import { buildSecretInputSchema, hasConfiguredSecretInput } from "openclaw/plugin-sdk/secret-input";
+import { DEFAULT_ACCOUNT_ID, createAccountListHelpers, hasConfiguredAccountValue, normalizeAccountId, normalizeOptionalAccountId } from "openclaw/plugin-sdk/account-resolution";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { buildSecretInputSchema, coerceSecretRef, hasConfiguredSecretInput } from "openclaw/plugin-sdk/secret-input";
+import { canResolveEnvSecretRefInReadOnlyPath } from "openclaw/plugin-sdk/secret-ref-readonly";
+import { normalizeAccountId as normalizeAccountId$1 } from "openclaw/plugin-sdk/account-id";
+import { ChannelDeliveryStreamingConfigSchema, ContextVisibilityModeSchema, DmPolicySchema, GroupPolicySchema, ReplyToModeSchema, buildChannelConfigSchema, buildGroupEntrySchema, buildMultiAccountChannelSchema } from "openclaw/plugin-sdk/channel-config-schema";
 import { z } from "zod";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
@@ -29,6 +32,186 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 //#endregion
+//#region extensions/feishu/src/accounts.ts
+var accounts_exports = /* @__PURE__ */ __exportAll({
+	FeishuSecretRefUnavailableError: () => FeishuSecretRefUnavailableError,
+	inspectFeishuCredentials: () => inspectFeishuCredentials,
+	listEnabledFeishuAccounts: () => listEnabledFeishuAccounts,
+	listFeishuAccountIds: () => listFeishuAccountIds,
+	mergeFeishuAccountConfig: () => mergeFeishuAccountConfig,
+	resolveDefaultFeishuAccountId: () => resolveDefaultFeishuAccountId,
+	resolveDefaultFeishuAccountSelection: () => resolveDefaultFeishuAccountSelection,
+	resolveFeishuAccount: () => resolveFeishuAccount,
+	resolveFeishuCredentials: () => resolveFeishuCredentials,
+	resolveFeishuRuntimeAccount: () => resolveFeishuRuntimeAccount
+});
+const { listAccountIds: listFeishuAccountIds, resolveDefaultAccountId: resolveDefaultFeishuAccountId, resolveAccountConfig: resolveMergedFeishuAccountConfig } = createAccountListHelpers("feishu", {
+	allowUnlistedDefaultAccount: true,
+	omitKeys: ["defaultAccount"],
+	nestedObjectKeys: ["tools"],
+	hasImplicitDefaultAccount: (cfg) => {
+		const feishu = cfg.channels?.feishu;
+		return hasConfiguredAccountValue(feishu?.appId) && hasConfiguredAccountValue(feishu?.appSecret);
+	}
+});
+var FeishuSecretRefUnavailableError = class extends Error {
+	constructor(path, ref) {
+		super(`${path}: unresolved SecretRef "${ref.source}:${ref.provider}:${ref.id}". Resolve this command against an active gateway runtime snapshot before reading it.`);
+		this.name = "FeishuSecretRefUnavailableError";
+		this.path = path;
+	}
+};
+function resolveFeishuSecretLike(params) {
+	const asString = normalizeOptionalString(params.value);
+	if (asString) return asString;
+	const ref = coerceSecretRef(params.value, params.cfg?.secrets?.defaults);
+	if (!ref) return;
+	if (params.mode === "inspect") {
+		if (ref.source === "env" && canResolveEnvSecretRefInReadOnlyPath({
+			cfg: params.cfg,
+			provider: ref.provider,
+			id: ref.id
+		})) return normalizeOptionalString(process.env[ref.id]);
+		return;
+	}
+	throw new FeishuSecretRefUnavailableError(params.path, ref);
+}
+function resolveFeishuBaseCredentials(cfg, mode, rootConfig) {
+	const appId = resolveFeishuSecretLike({
+		cfg: rootConfig,
+		value: cfg?.appId,
+		path: "channels.feishu.appId",
+		mode
+	});
+	const appSecret = resolveFeishuSecretLike({
+		cfg: rootConfig,
+		value: cfg?.appSecret,
+		path: "channels.feishu.appSecret",
+		mode
+	});
+	if (!appId || !appSecret) return null;
+	return {
+		appId,
+		appSecret,
+		domain: cfg?.domain?.replace(/^https:/i, "https:") ?? "feishu"
+	};
+}
+function resolveFeishuEventSecrets(cfg, mode, rootConfig) {
+	return {
+		encryptKey: (cfg?.connectionMode ?? "websocket") === "webhook" ? resolveFeishuSecretLike({
+			cfg: rootConfig,
+			value: cfg?.encryptKey,
+			path: "channels.feishu.encryptKey",
+			mode
+		}) : normalizeOptionalString(cfg?.encryptKey),
+		verificationToken: resolveFeishuSecretLike({
+			cfg: rootConfig,
+			value: cfg?.verificationToken,
+			path: "channels.feishu.verificationToken",
+			mode
+		})
+	};
+}
+function resolveDefaultFeishuAccountSelection(cfg) {
+	const preferred = normalizeOptionalAccountId((cfg.channels?.feishu)?.defaultAccount);
+	if (preferred) return {
+		accountId: preferred,
+		source: "explicit-default"
+	};
+	const ids = listFeishuAccountIds(cfg);
+	if (ids.includes(DEFAULT_ACCOUNT_ID)) return {
+		accountId: DEFAULT_ACCOUNT_ID,
+		source: "mapped-default"
+	};
+	return {
+		accountId: ids[0] ?? DEFAULT_ACCOUNT_ID,
+		source: "fallback"
+	};
+}
+function mergeFeishuAccountConfig(cfg, accountId) {
+	const feishuCfg = cfg.channels?.feishu;
+	const merged = resolveMergedFeishuAccountConfig(cfg, accountId);
+	const topTools = feishuCfg?.tools;
+	if (merged.tools === void 0 && topTools !== void 0) return {
+		...merged,
+		tools: topTools
+	};
+	if (topTools?.bitable === false) return {
+		...merged,
+		tools: {
+			...merged.tools,
+			bitable: false
+		}
+	};
+	return merged;
+}
+function resolveFeishuCredentials(cfg, options) {
+	const mode = options?.mode ?? "strict";
+	const base = resolveFeishuBaseCredentials(cfg, mode, options?.rootConfig);
+	if (!base) return null;
+	return {
+		...base,
+		...resolveFeishuEventSecrets(cfg, mode, options?.rootConfig)
+	};
+}
+function inspectFeishuCredentials(cfg, rootConfig) {
+	return resolveFeishuCredentials(cfg, {
+		mode: "inspect",
+		rootConfig
+	});
+}
+function buildResolvedFeishuAccount(params) {
+	const hasExplicitAccountId = typeof params.accountId === "string" && params.accountId.trim() !== "";
+	const defaultSelection = hasExplicitAccountId ? null : resolveDefaultFeishuAccountSelection(params.cfg);
+	const accountId = hasExplicitAccountId ? normalizeAccountId(params.accountId) : defaultSelection?.accountId ?? DEFAULT_ACCOUNT_ID;
+	const selectionSource = hasExplicitAccountId ? "explicit" : defaultSelection?.source ?? "fallback";
+	const feishuCfg = params.cfg.channels?.feishu;
+	const merged = mergeFeishuAccountConfig(params.cfg, accountId);
+	const baseCreds = resolveFeishuBaseCredentials(merged, params.baseMode, params.cfg);
+	const eventSecrets = resolveFeishuEventSecrets(merged, params.eventSecretMode, params.cfg);
+	return {
+		accountId,
+		selectionSource,
+		enabled: feishuCfg?.enabled !== false && merged.enabled !== false,
+		configured: Boolean(baseCreds),
+		name: normalizeOptionalString(merged.name),
+		appId: baseCreds?.appId,
+		appSecret: baseCreds?.appSecret,
+		encryptKey: eventSecrets.encryptKey,
+		verificationToken: eventSecrets.verificationToken,
+		domain: baseCreds?.domain ?? "feishu",
+		config: merged
+	};
+}
+/**
+* Resolve a read-only Feishu account snapshot for CLI/config surfaces.
+* Unresolved SecretRefs are treated as unavailable instead of throwing.
+*/
+function resolveFeishuAccount(params) {
+	return buildResolvedFeishuAccount({
+		...params,
+		baseMode: "inspect",
+		eventSecretMode: "inspect"
+	});
+}
+/**
+* Resolve a runtime Feishu account.
+* Required app credentials stay strict; event-only secrets can be required by callers.
+*/
+function resolveFeishuRuntimeAccount(params, options) {
+	return buildResolvedFeishuAccount({
+		...params,
+		baseMode: "strict",
+		eventSecretMode: options?.requireEventSecrets ? "strict" : "inspect"
+	});
+}
+function listEnabledFeishuAccounts(cfg) {
+	return listFeishuAccountIds(cfg).map((accountId) => resolveFeishuAccount({
+		cfg,
+		accountId
+	})).filter((account) => account.enabled && account.configured);
+}
+//#endregion
 //#region extensions/feishu/src/external-keys.ts
 const FEISHU_EXTERNAL_KEY_PATTERN = /^(?!\s)(?![\s\S]*\s$)(?![\s\S]*\.\.)[^\p{Cc}\p{Cs}/\\]{1,512}$/u;
 function normalizeFeishuExternalKey(value) {
@@ -113,18 +296,9 @@ const RenderModeSchema = z.enum([
 	"raw",
 	"card"
 ]).optional();
-const BlockStreamingCoalesceSchema = z.object({
-	minChars: z.number().int().positive().optional(),
-	maxChars: z.number().int().positive().optional(),
-	idleMs: z.number().int().nonnegative().optional()
-}).strict().optional();
 const FeishuStreamingSchema = z.object({
 	mode: z.enum(["off", "partial"]).optional(),
-	chunkMode: z.enum(["length", "newline"]).optional(),
-	block: z.object({
-		enabled: z.boolean().optional(),
-		coalesce: BlockStreamingCoalesceSchema
-	}).strict().optional()
+	...ChannelDeliveryStreamingConfigSchema.shape
 }).strict().optional();
 const ChannelHeartbeatVisibilitySchema = z.object({
 	visibility: z.enum(["visible", "hidden"]).optional(),
@@ -289,7 +463,7 @@ const FeishuConfigSchema = buildMultiAccountChannelSchema(FeishuConfigSchemaBase
 }).superRefine((value, ctx) => {
 	const defaultAccount = value.defaultAccount?.trim();
 	if (defaultAccount && value.accounts && Object.keys(value.accounts).length > 0) {
-		const normalizedDefaultAccount = normalizeAccountId(defaultAccount);
+		const normalizedDefaultAccount = normalizeAccountId$1(defaultAccount);
 		if (!Object.hasOwn(value.accounts, normalizedDefaultAccount)) ctx.addIssue({
 			code: z.ZodIssueCode.custom,
 			path: ["defaultAccount"],
@@ -347,18 +521,18 @@ const FeishuChannelConfigSchema = buildChannelConfigSchema(FeishuConfigSchema, {
 //#endregion
 //#region packages/normalization-core/src/record-coerce.ts
 /** Type guard for non-array object records at browser-safe boundaries. */
-function isRecord(value) {
+function isRecord$1(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 /** Returns a non-array record or null. */
-function asNullableRecord(value) {
-	return isRecord(value) ? value : null;
+function asNullableRecord$1(value) {
+	return isRecord$1(value) ? value : null;
 }
 //#endregion
 //#region src/config/channel-config-normalization.ts
 /** Applies one channel-specific doctor migration to every object-shaped account. */
 function normalizeChannelAccounts(params) {
-	const rawAccounts = asNullableRecord(params.entry.accounts);
+	const rawAccounts = asNullableRecord$1(params.entry.accounts);
 	if (!rawAccounts) return {
 		entry: params.entry,
 		changed: false
@@ -366,7 +540,7 @@ function normalizeChannelAccounts(params) {
 	let changed = false;
 	const accounts = { ...rawAccounts };
 	for (const [accountId, value] of Object.entries(rawAccounts)) {
-		const account = asNullableRecord(value);
+		const account = asNullableRecord$1(value);
 		if (!account) continue;
 		const normalized = params.normalizeAccount({
 			account,
@@ -394,7 +568,7 @@ function normalizeChannelAccounts(params) {
 function normalizeChannelConfigEntries$1(params) {
 	const changes = params.changes ?? [];
 	const channels = params.cfg.channels;
-	const entry = asNullableRecord(channels?.[params.channelId]);
+	const entry = asNullableRecord$1(channels?.[params.channelId]);
 	if (!entry) return {
 		config: params.cfg,
 		changes
@@ -437,26 +611,32 @@ function normalizeChannelConfigEntries$1(params) {
 function createLegacyWebhookListenerDoctorContract(params) {
 	const portKey = params.portKey ?? "webhookPort";
 	const hostKey = params.hostKey === void 0 ? "webhookHost" : params.hostKey;
-	const source = (entry) => params.webhookKey ? asNullableRecord(entry[params.webhookKey]) : entry;
+	const source = (entry) => params.webhookKey ? asNullableRecord$1(entry[params.webhookKey]) : entry;
 	const hasLegacy = (value) => {
-		const entry = asNullableRecord(value);
+		const entry = asNullableRecord$1(value);
 		const listener = entry && source(entry);
 		return Boolean(listener && (Object.hasOwn(listener, portKey) || hostKey && Object.hasOwn(listener, hostKey)));
 	};
 	const prefix = `channels.${params.channelKey}`;
 	return {
+		historicalWebhookListener: {
+			channelId: params.channelKey,
+			port: params.defaultPort,
+			preserveAuthoredActivation: params.preserveAuthoredActivation,
+			...params.defaultHost === void 0 ? {} : { host: params.defaultHost }
+		},
 		legacyConfigRules: [{
 			path: ["channels", params.channelKey],
 			message: `${prefix} webhook listeners moved to Gateway routes. Run "openclaw doctor --fix" to preserve explicitly configured listener settings as legacyWebhook.`,
 			match: (value) => {
-				const accounts = asNullableRecord(asNullableRecord(value)?.accounts);
+				const accounts = asNullableRecord$1(asNullableRecord$1(value)?.accounts);
 				return hasLegacy(value) || Object.values(accounts ?? {}).some(hasLegacy);
 			}
 		}],
 		normalizeCompatibilityConfig: ({ cfg }) => {
-			const root = asNullableRecord(asNullableRecord(cfg.channels)?.[params.channelKey]);
+			const root = asNullableRecord$1(asNullableRecord$1(cfg.channels)?.[params.channelKey]);
 			const inherited = root && source(root);
-			const canonicalRoot = asNullableRecord(root?.legacyWebhook);
+			const canonicalRoot = asNullableRecord$1(root?.legacyWebhook);
 			return normalizeChannelConfigEntries$1({
 				cfg,
 				channelId: params.channelKey,
@@ -508,6 +688,7 @@ const webhookListenerMigration = createLegacyWebhookListenerDoctorContract({
 	defaultPort: 3e3,
 	defaultHost: "127.0.0.1"
 });
+const { historicalWebhookListener } = webhookListenerMigration;
 const streamingAliasMigration = (0, runtime_doctor_migrations_exports.defineChannelAliasMigration)({
 	channelId: "feishu",
 	streaming: { defaultMode: "partial" },
@@ -654,8 +835,12 @@ function normalizeCompatibilityConfig({ cfg }) {
 	const stray = feishuStrayEntryConfigMigration.normalizeConfig({ cfg: entries });
 	return {
 		config: stray.config,
-		changes: [...changes, ...stray.changes]
+		changes: [...changes, ...stray.changes],
+		historicalWebhookAccountIds: stray.config.channels?.feishu?.enabled === false ? [] : listFeishuAccountIds(stray.config).filter((accountId) => {
+			const account = mergeFeishuAccountConfig(stray.config, accountId);
+			return account.enabled !== false && account.connectionMode === "webhook";
+		})
 	};
 }
 //#endregion
-export { normalizeFeishuWebhookPath as a, __reExport as c, DEFAULT_FEISHU_WEBHOOK_PATH as i, normalizeCompatibilityConfig as n, normalizeFeishuExternalKey as o, FeishuChannelConfigSchema as r, __exportAll as s, legacyConfigRules as t };
+export { __reExport as _, DEFAULT_FEISHU_WEBHOOK_PATH as a, accounts_exports as c, listFeishuAccountIds as d, mergeFeishuAccountConfig as f, __exportAll as g, resolveFeishuRuntimeAccount as h, FeishuChannelConfigSchema as i, inspectFeishuCredentials as l, resolveFeishuAccount as m, legacyConfigRules as n, normalizeFeishuWebhookPath as o, resolveDefaultFeishuAccountId as p, normalizeCompatibilityConfig as r, normalizeFeishuExternalKey as s, historicalWebhookListener as t, listEnabledFeishuAccounts as u };

package/dist/.setup/{monitor-D_rsHBZ6.mjs → monitor-7DvwUs4Y.mjs}

@@ -1,6 +1,6 @@
-import { c as resolveFeishuRuntimeAccount, r as listEnabledFeishuAccounts } from "./accounts-wRqItHug.mjs";
+import { h as resolveFeishuRuntimeAccount, u as listEnabledFeishuAccounts } from "./doctor-contract-B1B9ogdd.mjs";
 import { t as getFeishuRuntime } from "./runtime-C5JxBWZp.mjs";
-import { r as registerFeishuAiAgent, t as probeFeishu } from "./probe-_ViqSi0j.mjs";
+import { r as registerFeishuAiAgent, t as probeFeishu } from "./probe-B9o7iey6.mjs";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
 import { clampTimerTimeoutMs, parseStrictPositiveInteger } from "openclaw/plugin-sdk/number-runtime";
@@ -108,7 +108,7 @@ async function readProviderBotIdentityCache(params) {
 }
 async function fetchBotIdentityForMonitor(account, options = {}) {
 	if (options.abortSignal?.aborted) return {};
-	const timeoutMs = options.timeoutMs ?? FEISHU_STARTUP_BOT_INFO_TIMEOUT_MS;
+	const timeoutMs = FEISHU_STARTUP_BOT_INFO_TIMEOUT_MS;
 	const result = await probeFeishu(account, {
 		timeoutMs,
 		abortSignal: options.abortSignal
@@ -144,7 +144,7 @@ async function fetchBotIdentityForMonitor(account, options = {}) {
 }
 //#endregion
 //#region extensions/feishu/src/monitor.ts
-const loadMonitorAccountRuntime = createLazyRuntimeModule(() => import("./monitor.account-DvvY7i6k.mjs"));
+const loadMonitorAccountRuntime = createLazyRuntimeModule(() => import("./monitor.account-7xVu7XWY.mjs"));
 async function monitorFeishuProvider(opts = {}) {
 	const cfg = opts.config;
 	if (!cfg) throw new Error("Config is required for Feishu monitor");
@@ -175,7 +175,7 @@ async function monitorFeishuProvider(opts = {}) {
 			log("feishu: abort signal received during startup preflight; stopping startup");
 			break;
 		}
-		const { botOpenId, botName, source } = await fetchBotIdentityForMonitor(account, {
+		const { botOpenId, source } = await fetchBotIdentityForMonitor(account, {
 			runtime: opts.runtime,
 			abortSignal: opts.abortSignal
 		});
@@ -192,7 +192,6 @@ async function monitorFeishuProvider(opts = {}) {
 			botOpenIdSource: {
 				kind: "prefetched",
 				botOpenId,
-				botName,
 				source
 			},
 			...opts.statusSink ? { statusSink: opts.statusSink } : {}