@openclaw/feishu 2026.7.2-beta.7 → 2026.8.1-beta.2

package/dist/accounts-u9X5Wsan.js

@@ -1,469 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { isRecord, normalizeOptionalString, normalizeStringEntries, readStringValue } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { DEFAULT_ACCOUNT_ID, createAccountListHelpers, hasConfiguredAccountValue, normalizeAccountId, normalizeOptionalAccountId } from "openclaw/plugin-sdk/account-resolution";
-import { coerceSecretRef } from "openclaw/plugin-sdk/provider-auth";
-import { retryAsync } from "openclaw/plugin-sdk/retry-runtime";
-//#region extensions/feishu/src/comment-target.ts
-const FEISHU_COMMENT_FILE_TYPES = [
-	"doc",
-	"docx",
-	"file",
-	"sheet",
-	"slides"
-];
-function normalizeCommentFileType(value) {
-	return typeof value === "string" && FEISHU_COMMENT_FILE_TYPES.includes(value) ? value : void 0;
-}
-function buildFeishuCommentTarget(params) {
-	return `comment:${params.fileType}:${params.fileToken}:${params.commentId}`;
-}
-function parseFeishuCommentTarget(raw) {
-	const trimmed = raw?.trim();
-	if (!trimmed?.startsWith("comment:")) return null;
-	const parts = trimmed.split(":");
-	if (parts.length !== 4) return null;
-	const fileType = normalizeCommentFileType(parts[1]);
-	const fileToken = parts[2]?.trim();
-	const commentId = parts[3]?.trim();
-	if (!fileType || !fileToken || !commentId) return null;
-	return {
-		fileType,
-		fileToken,
-		commentId
-	};
-}
-//#endregion
-//#region extensions/feishu/src/send-rate-limit.ts
-const FEISHU_SEND_RATE_LIMIT_CODES = /* @__PURE__ */ new Set([230020, 11232]);
-function getFeishuSendRateLimitCode(error) {
-	if (!isRecord(error)) return;
-	const response = isRecord(error.response) ? error.response : void 0;
-	if (response?.status === 429) return 429;
-	const code = (isRecord(response?.data) ? response.data : void 0)?.code;
-	return typeof code === "number" && FEISHU_SEND_RATE_LIMIT_CODES.has(code) ? code : void 0;
-}
-function getFeishuSendRateLimitCodeFromResponse(response) {
-	if (!isRecord(response)) return;
-	const code = response.code;
-	return typeof code === "number" && FEISHU_SEND_RATE_LIMIT_CODES.has(code) ? code : void 0;
-}
-//#endregion
-//#region extensions/feishu/src/comment-shared.ts
-function encodeQuery(params) {
-	const query = new URLSearchParams();
-	for (const [key, value] of Object.entries(params)) {
-		const trimmed = value?.trim();
-		if (trimmed) query.set(key, trimmed);
-	}
-	const queryString = query.toString();
-	return queryString ? `?${queryString}` : "";
-}
-const readString = readStringValue;
-const normalizeString = normalizeOptionalString;
-const isRecord$1 = isRecord;
-function formatFeishuApiError(error, options = {}) {
-	if (!isRecord$1(error)) return typeof error === "string" ? error : JSON.stringify(error);
-	const config = isRecord$1(error.config) ? error.config : void 0;
-	const response = isRecord$1(error.response) ? error.response : void 0;
-	const responseData = isRecord$1(response?.data) ? response?.data : void 0;
-	const feishuLogId = readString(responseData?.log_id) || (options.includeNestedErrorLogId ? readString(isRecord$1(responseData?.error) ? responseData.error.log_id : void 0) : void 0);
-	const nestedError = isRecord$1(responseData?.error) ? responseData.error : void 0;
-	return JSON.stringify({
-		message: typeof error.message === "string" ? error.message : typeof error === "string" ? error : JSON.stringify(error),
-		code: readString(error.code),
-		method: readString(config?.method),
-		url: readString(config?.url),
-		...options.includeConfigParams ? { params: config?.params } : {},
-		http_status: typeof response?.status === "number" ? response.status : void 0,
-		feishu_code: typeof responseData?.code === "number" ? responseData.code : readString(responseData?.code),
-		feishu_msg: readString(responseData?.msg),
-		feishu_log_id: feishuLogId,
-		feishu_troubleshooter: readString(responseData?.troubleshooter) || readString(nestedError?.troubleshooter)
-	});
-}
-function formatFeishuApiFailure(error, errorPrefix, options = {}) {
-	return `${errorPrefix}: ${formatFeishuApiError(error, options) || "unknown error"}`;
-}
-function createFeishuApiError(error, errorPrefix, options = {}) {
-	return new Error(formatFeishuApiFailure(error, errorPrefix, options), { cause: error });
-}
-const FEISHU_SEND_RETRY_BASE_MS = 500;
-async function requestFeishuApi(request, errorPrefix, options = {}) {
-	try {
-		return await retryAsync(async () => {
-			const result = await request();
-			const fulfilledRateLimit = getFeishuSendRateLimitCodeFromResponse(result);
-			if (fulfilledRateLimit !== void 0) throw Object.assign(/* @__PURE__ */ new Error(`Request fulfilled with rate-limit code ${fulfilledRateLimit}`), { response: {
-				status: 200,
-				data: result
-			} });
-			return result;
-		}, {
-			attempts: 3,
-			minDelayMs: options.retryDelayMs ?? FEISHU_SEND_RETRY_BASE_MS,
-			shouldRetry: (error) => getFeishuSendRateLimitCode(error) !== void 0
-		});
-	} catch (error) {
-		throw createFeishuApiError(error, errorPrefix, options);
-	}
-}
-function readDocsLinkUrl(element) {
-	const docsLink = isRecord$1(element.docs_link) ? element.docs_link : void 0;
-	return normalizeString(docsLink?.url) || normalizeString(docsLink?.link) || normalizeString(element.url) || normalizeString(element.link) || void 0;
-}
-function readMentionUserId(element) {
-	const mention = isRecord$1(element.mention) ? element.mention : void 0;
-	const person = isRecord$1(element.person) ? element.person : void 0;
-	return normalizeString(person?.user_id) || normalizeString(mention?.user_id) || normalizeString(mention?.open_id) || normalizeString(element.mention_user) || normalizeString(element.user_id) || void 0;
-}
-function readMentionDisplayText(element, userId) {
-	const mention = isRecord$1(element.mention) ? element.mention : void 0;
-	const mentionName = normalizeString(mention?.name) || normalizeString(mention?.display_name) || normalizeString(element.name);
-	return mentionName ? `@${mentionName}` : `@${userId}`;
-}
-function normalizeCommentText(parts) {
-	return parts.join("").trim() || void 0;
-}
-function normalizeCommentSemanticText(parts) {
-	return parts.join("").replace(/\s+/g, " ").trim() || void 0;
-}
-function readElementTextPreservingWhitespace(element) {
-	return (isRecord$1(element.text_run) ? readString(element.text_run.content) || readString(element.text_run.text) : void 0) || readString(element.text) || readString(element.content) || readString(element.name) || void 0;
-}
-const FEISHU_LINK_TOKEN_MIN_LENGTH = 22;
-const FEISHU_LINK_TOKEN_MAX_LENGTH = 28;
-const COMMENT_LINK_KIND_ALIASES = /* @__PURE__ */ new Map([
-	["doc", "doc"],
-	["docs", "doc"],
-	["docx", "docx"],
-	["sheet", "sheet"],
-	["sheets", "sheet"],
-	["slide", "slides"],
-	["slides", "slides"],
-	["file", "file"],
-	["files", "file"],
-	["wiki", "wiki"],
-	["mindnote", "mindnote"],
-	["mindnotes", "mindnote"],
-	["bitable", "bitable"],
-	["base", "base"]
-]);
-function isCommentFileType(value) {
-	return typeof value === "string" && FEISHU_COMMENT_FILE_TYPES.includes(value);
-}
-function isReasonableFeishuLinkToken(token) {
-	return typeof token === "string" && token.length >= FEISHU_LINK_TOKEN_MIN_LENGTH && token.length <= FEISHU_LINK_TOKEN_MAX_LENGTH;
-}
-function parseCommentLinkedDocumentPath(pathname) {
-	const segments = normalizeStringEntries(pathname.split("/"));
-	const offset = segments[0]?.toLowerCase() === "space" ? 1 : 0;
-	const kind = COMMENT_LINK_KIND_ALIASES.get(segments[offset]?.toLowerCase() ?? "");
-	const token = normalizeString(segments[offset + 1]);
-	if (!kind || !isReasonableFeishuLinkToken(token)) return null;
-	return {
-		urlKind: kind,
-		token
-	};
-}
-function hasResolvedLinkedDocumentReference(link) {
-	return link.urlKind !== "unknown" && (Boolean(link.resolvedObjToken) || Boolean(link.wikiNodeToken));
-}
-function resolveCommentLinkedDocumentFromUrl(params) {
-	const link = {
-		rawUrl: params.rawUrl,
-		urlKind: "unknown"
-	};
-	try {
-		const parsedPath = parseCommentLinkedDocumentPath(new URL(params.rawUrl).pathname);
-		if (!parsedPath) return link;
-		const { urlKind, token } = parsedPath;
-		link.urlKind = urlKind;
-		if (urlKind === "wiki") {
-			link.urlKind = "wiki";
-			link.wikiNodeToken = token;
-		} else {
-			link.resolvedObjType = urlKind;
-			link.resolvedObjToken = token;
-		}
-		if (link.resolvedObjType && link.resolvedObjToken && isCommentFileType(link.resolvedObjType) && params.currentDocument?.fileType === link.resolvedObjType && params.currentDocument.fileToken === link.resolvedObjToken) link.isCurrentDocument = true;
-		else if (link.resolvedObjType && link.resolvedObjToken && isCommentFileType(link.resolvedObjType)) link.isCurrentDocument = false;
-	} catch {
-		return link;
-	}
-	return link;
-}
-function parseCommentContentElements(params) {
-	const elements = Array.isArray(params.elements) ? params.elements : [];
-	const plainTextParts = [];
-	const semanticTextParts = [];
-	const mentions = [];
-	const linkedDocuments = [];
-	const botIds = new Set(Array.from(params.botOpenIds ?? []).map((value) => normalizeString(value)).filter((value) => Boolean(value)));
-	const linkedDocumentKeys = /* @__PURE__ */ new Set();
-	let botMentioned = false;
-	for (const rawElement of elements) {
-		if (!isRecord$1(rawElement)) continue;
-		const element = rawElement;
-		const type = normalizeString(element.type);
-		const text = (type === "text_run" ? readElementTextPreservingWhitespace(element) : void 0) || (type === "text" ? readElementTextPreservingWhitespace(element) : void 0) || (type === "docs_link" || type === "link" ? readDocsLinkUrl(element) : void 0) || (type === "mention" || type === "mention_user" || type === "person" ? (() => {
-			const userId = readMentionUserId(element);
-			return userId ? readMentionDisplayText(element, userId) : void 0;
-		})() : void 0) || readElementTextPreservingWhitespace(element) || void 0;
-		if (type === "mention" || type === "mention_user" || type === "person") {
-			const userId = readMentionUserId(element);
-			if (userId) {
-				const displayText = readMentionDisplayText(element, userId);
-				const isBotMention = botIds.has(userId);
-				mentions.push({
-					userId,
-					displayText,
-					isBotMention
-				});
-				plainTextParts.push(displayText);
-				if (!isBotMention) semanticTextParts.push(displayText);
-				else botMentioned = true;
-				continue;
-			}
-		}
-		if (type === "docs_link" || type === "link") {
-			const rawUrl = readDocsLinkUrl(element);
-			if (rawUrl) {
-				plainTextParts.push(rawUrl);
-				semanticTextParts.push(rawUrl);
-				const linkedDocument = resolveCommentLinkedDocumentFromUrl({
-					rawUrl,
-					currentDocument: params.currentDocument
-				});
-				if (hasResolvedLinkedDocumentReference(linkedDocument)) {
-					const key = [
-						linkedDocument.rawUrl,
-						linkedDocument.urlKind,
-						linkedDocument.resolvedObjType,
-						linkedDocument.resolvedObjToken,
-						linkedDocument.wikiNodeToken
-					].join(":");
-					if (!linkedDocumentKeys.has(key)) {
-						linkedDocumentKeys.add(key);
-						linkedDocuments.push(linkedDocument);
-					}
-				}
-				continue;
-			}
-		}
-		if (text) {
-			plainTextParts.push(text);
-			semanticTextParts.push(text);
-		}
-	}
-	return {
-		plainText: normalizeCommentText(plainTextParts),
-		semanticText: normalizeCommentSemanticText(semanticTextParts),
-		mentions,
-		linkedDocuments,
-		botMentioned
-	};
-}
-function extractReplyText(reply) {
-	if (!reply || !isRecord$1(reply.content)) return;
-	return parseCommentContentElements({ elements: Array.isArray(reply.content.elements) ? reply.content.elements : [] }).plainText;
-}
-//#endregion
-//#region extensions/feishu/src/accounts.ts
-var accounts_exports = /* @__PURE__ */ __exportAll({
-	FeishuSecretRefUnavailableError: () => FeishuSecretRefUnavailableError,
-	inspectFeishuCredentials: () => inspectFeishuCredentials,
-	listEnabledFeishuAccounts: () => listEnabledFeishuAccounts,
-	listFeishuAccountIds: () => listFeishuAccountIds,
-	resolveDefaultFeishuAccountId: () => resolveDefaultFeishuAccountId,
-	resolveDefaultFeishuAccountSelection: () => resolveDefaultFeishuAccountSelection,
-	resolveFeishuAccount: () => resolveFeishuAccount,
-	resolveFeishuCredentials: () => resolveFeishuCredentials,
-	resolveFeishuRuntimeAccount: () => resolveFeishuRuntimeAccount
-});
-const { listAccountIds: listFeishuAccountIds, resolveDefaultAccountId, resolveAccountConfig: resolveMergedFeishuAccountConfig } = createAccountListHelpers("feishu", {
-	allowUnlistedDefaultAccount: true,
-	omitKeys: ["defaultAccount"],
-	nestedObjectKeys: ["tools"],
-	hasImplicitDefaultAccount: (cfg) => {
-		const feishu = cfg.channels?.feishu;
-		return hasConfiguredAccountValue(feishu?.appId) && hasConfiguredAccountValue(feishu?.appSecret);
-	}
-});
-function formatSecretRefLabel(ref) {
-	return `${ref.source}:${ref.provider}:${ref.id}`;
-}
-var FeishuSecretRefUnavailableError = class extends Error {
-	constructor(path, ref) {
-		super(`${path}: unresolved SecretRef "${formatSecretRefLabel(ref)}". Resolve this command against an active gateway runtime snapshot before reading it.`);
-		this.name = "FeishuSecretRefUnavailableError";
-		this.path = path;
-	}
-};
-function resolveFeishuSecretLike(params) {
-	const asString = normalizeString(params.value);
-	if (asString) return asString;
-	const ref = coerceSecretRef(params.value);
-	if (!ref) return;
-	if (params.mode === "inspect") {
-		if (params.allowEnvSecretRefRead && ref.source === "env") {
-			const envValue = normalizeString(process.env[ref.id]);
-			if (envValue) return envValue;
-		}
-		return;
-	}
-	throw new FeishuSecretRefUnavailableError(params.path, ref);
-}
-function resolveFeishuBaseCredentials(cfg, mode) {
-	const appId = resolveFeishuSecretLike({
-		value: cfg?.appId,
-		path: "channels.feishu.appId",
-		mode,
-		allowEnvSecretRefRead: true
-	});
-	const appSecret = resolveFeishuSecretLike({
-		value: cfg?.appSecret,
-		path: "channels.feishu.appSecret",
-		mode,
-		allowEnvSecretRefRead: true
-	});
-	if (!appId || !appSecret) return null;
-	return {
-		appId,
-		appSecret,
-		domain: cfg?.domain ?? "feishu"
-	};
-}
-function resolveFeishuEventSecrets(cfg, mode) {
-	return {
-		encryptKey: (cfg?.connectionMode ?? "websocket") === "webhook" ? resolveFeishuSecretLike({
-			value: cfg?.encryptKey,
-			path: "channels.feishu.encryptKey",
-			mode,
-			allowEnvSecretRefRead: true
-		}) : normalizeString(cfg?.encryptKey),
-		verificationToken: resolveFeishuSecretLike({
-			value: cfg?.verificationToken,
-			path: "channels.feishu.verificationToken",
-			mode,
-			allowEnvSecretRefRead: true
-		})
-	};
-}
-/**
-* Resolve the default account selection and its source.
-*/
-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"
-	};
-}
-/**
-* Resolve the default account ID.
-*/
-function resolveDefaultFeishuAccountId(cfg) {
-	return resolveDefaultAccountId(cfg);
-}
-/**
-* Merge top-level config with account-specific config.
-* Account-specific fields override top-level fields.
-*/
-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 ?? (options?.allowUnresolvedSecretRef ? "inspect" : "strict");
-	const base = resolveFeishuBaseCredentials(cfg, mode);
-	if (!base) return null;
-	const eventSecrets = resolveFeishuEventSecrets(cfg, mode);
-	return {
-		...base,
-		...eventSecrets
-	};
-}
-function inspectFeishuCredentials(cfg) {
-	return resolveFeishuCredentials(cfg, { mode: "inspect" });
-}
-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 baseEnabled = (params.cfg.channels?.feishu)?.enabled !== false;
-	const merged = mergeFeishuAccountConfig(params.cfg, accountId);
-	const accountEnabled = merged.enabled !== false;
-	const enabled = baseEnabled && accountEnabled;
-	const baseCreds = resolveFeishuBaseCredentials(merged, params.baseMode);
-	const eventSecrets = resolveFeishuEventSecrets(merged, params.eventSecretMode);
-	const accountName = merged.name;
-	return {
-		accountId,
-		selectionSource,
-		enabled,
-		configured: Boolean(baseCreds),
-		name: typeof accountName === "string" ? accountName.trim() || void 0 : void 0,
-		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"
-	});
-}
-/**
-* List all enabled and configured accounts.
-*/
-function listEnabledFeishuAccounts(cfg) {
-	return listFeishuAccountIds(cfg).map((accountId) => resolveFeishuAccount({
-		cfg,
-		accountId
-	})).filter((account) => account.enabled && account.configured);
-}
-//#endregion
-export { normalizeCommentFileType as _, resolveDefaultFeishuAccountId as a, encodeQuery as c, isRecord$1 as d, normalizeString as f, buildFeishuCommentTarget as g, requestFeishuApi as h, listFeishuAccountIds as i, extractReplyText as l, readString as m, inspectFeishuCredentials as n, resolveFeishuAccount as o, parseCommentContentElements as p, listEnabledFeishuAccounts as r, resolveFeishuRuntimeAccount as s, accounts_exports as t, formatFeishuApiError as u, parseFeishuCommentTarget as v };

package/dist/doctor-contract-BiD9tyIv.js

@@ -1,102 +0,0 @@
-import { asObjectRecord, defineChannelAliasMigration, defineKeyMoveMigration, hasLegacyAccountStreamingAliases, normalizeChannelConfigEntries } from "openclaw/plugin-sdk/runtime-doctor";
-//#region extensions/feishu/src/doctor-contract.ts
-const streamingAliasMigration = defineChannelAliasMigration({
-	channelId: "feishu",
-	streaming: { defaultMode: "partial" },
-	accountStreamingReplacesRoot: true
-});
-const LEGACY_COALESCE_FIELDS = [
-	"enabled",
-	"minDelayMs",
-	"maxDelayMs"
-];
-const LEGACY_HEARTBEAT_FIELDS = ["visibility", "intervalMs"];
-const toolsBaseMigration = defineKeyMoveMigration({
-	from: ["tools", "base"],
-	to: ["tools", "bitable"],
-	match: (value) => typeof value === "boolean",
-	sourceOwn: false
-});
-function sanitizeLegacyHeartbeatFields(params) {
-	const heartbeat = asObjectRecord(params.entry.heartbeat);
-	if (!heartbeat || Object.keys(heartbeat).length > 0 && !LEGACY_HEARTBEAT_FIELDS.some((field) => Object.hasOwn(heartbeat, field))) return {
-		entry: params.entry,
-		changed: false
-	};
-	const next = { ...params.entry };
-	delete next.heartbeat;
-	params.changes.push(`Removed ${params.pathPrefix}.heartbeat (legacy Feishu fields were never read by runtime).`);
-	return {
-		entry: next,
-		changed: true
-	};
-}
-function sanitizeLegacyCoalesceFields(params) {
-	const streaming = asObjectRecord(params.entry.streaming);
-	const block = asObjectRecord(streaming?.block);
-	const coalesce = asObjectRecord(block?.coalesce);
-	if (!streaming || !block || !coalesce) return {
-		entry: params.entry,
-		changed: false
-	};
-	const removed = LEGACY_COALESCE_FIELDS.filter((field) => coalesce[field] !== void 0);
-	if (removed.length === 0) return {
-		entry: params.entry,
-		changed: false
-	};
-	const nextCoalesce = { ...coalesce };
-	for (const field of removed) delete nextCoalesce[field];
-	params.changes.push(`Removed ${params.pathPrefix}.streaming.block.coalesce.{${removed.join(",")}} (legacy Feishu-only fields; block delivery reads minChars/maxChars/idleMs).`);
-	return {
-		entry: {
-			...params.entry,
-			streaming: {
-				...streaming,
-				block: {
-					...block,
-					coalesce: nextCoalesce
-				}
-			}
-		},
-		changed: true
-	};
-}
-function sanitizeFeishuCoalesce(cfg, changes) {
-	return normalizeChannelConfigEntries({
-		cfg,
-		channelId: "feishu",
-		changes,
-		normalizeEntry: (params) => {
-			const tools = toolsBaseMigration.normalize(params);
-			const coalesce = sanitizeLegacyCoalesceFields({
-				...params,
-				entry: tools.entry
-			});
-			const heartbeat = sanitizeLegacyHeartbeatFields({
-				...params,
-				entry: coalesce.entry
-			});
-			return {
-				entry: heartbeat.entry,
-				changed: tools.changed || coalesce.changed || heartbeat.changed
-			};
-		}
-	}).config;
-}
-const legacyConfigRules = [...streamingAliasMigration.legacyConfigRules, {
-	path: ["channels", "feishu"],
-	message: "channels.feishu[.accounts.<id>].tools.base is legacy; use tools.bitable. Run \"openclaw doctor --fix\".",
-	match: (value) => {
-		const entry = asObjectRecord(value);
-		return toolsBaseMigration.hasLegacy(entry) || hasLegacyAccountStreamingAliases(entry?.accounts, toolsBaseMigration.hasLegacy);
-	}
-}];
-function normalizeCompatibilityConfig({ cfg }) {
-	const aliases = streamingAliasMigration.normalizeChannelConfig({ cfg });
-	return {
-		config: sanitizeFeishuCoalesce(aliases.config, aliases.changes),
-		changes: aliases.changes
-	};
-}
-//#endregion
-export { normalizeCompatibilityConfig as n, legacyConfigRules as t };

package/dist/security-audit-D7WK_BHh.js

@@ -1,11 +0,0 @@
-import "./security-audit-shared-BgpY7AiJ.js";
-//#region extensions/feishu/src/message-action-contract.ts
-const messageActionTargetAliases = {
-	read: { aliases: ["messageId"] },
-	pin: { aliases: ["messageId"] },
-	unpin: { aliases: ["messageId"] },
-	"list-pins": { aliases: ["chatId"] },
-	"channel-info": { aliases: ["chatId"] }
-};
-//#endregion
-export { messageActionTargetAliases as t };