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

package/dist/{conversation-id-BeJL-wq7.js → conversation-id-VYgGQ-GX.js}

@@ -1,17 +1,13 @@
-import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/feishu/src/conversation-id.ts
 function resolveConfiguredFeishuGroupSessionScope(params) {
 	const legacyTopicSessionMode = params.groupConfig?.topicSessionMode ?? params.feishuCfg?.topicSessionMode ?? "disabled";
 	return params.groupConfig?.groupSessionScope ?? params.feishuCfg?.groupSessionScope ?? (legacyTopicSessionMode === "enabled" ? "group_topic" : "group");
 }
-function normalizeText(value) {
-	if (typeof value !== "string") return;
-	return value.trim() || void 0;
-}
 function buildFeishuConversationId(params) {
-	const chatId = normalizeText(params.chatId) ?? "unknown";
-	const senderOpenId = normalizeText(params.senderOpenId);
-	const topicId = normalizeText(params.topicId);
+	const chatId = normalizeOptionalString(params.chatId) ?? "unknown";
+	const senderOpenId = normalizeOptionalString(params.senderOpenId);
+	const topicId = normalizeOptionalString(params.topicId);
 	switch (params.scope) {
 		case "group_sender": return senderOpenId ? `${chatId}:sender:${senderOpenId}` : chatId;
 		case "group_topic": return topicId ? `${chatId}:topic:${topicId}` : chatId;
@@ -23,7 +19,7 @@ function buildFeishuConversationId(params) {
 	}
 }
 function parseFeishuTargetId(raw) {
-	const target = normalizeText(raw);
+	const target = normalizeOptionalString(raw);
 	if (!target) return;
 	const withoutProvider = target.replace(/^(feishu|lark):/i, "").trim();
 	if (!withoutProvider) return;
@@ -35,11 +31,11 @@ function parseFeishuTargetId(raw) {
 		"user:",
 		"dm:",
 		"open_id:"
-	]) if (lowered.startsWith(prefix)) return normalizeText(withoutProvider.slice(prefix.length));
+	]) if (lowered.startsWith(prefix)) return normalizeOptionalString(withoutProvider.slice(prefix.length));
 	return withoutProvider;
 }
 function parseFeishuDirectConversationId(raw) {
-	const target = normalizeText(raw);
+	const target = normalizeOptionalString(raw);
 	if (!target) return;
 	const withoutProvider = target.replace(/^(feishu|lark):/i, "").trim();
 	if (!withoutProvider) return;
@@ -48,14 +44,14 @@ function parseFeishuDirectConversationId(raw) {
 		"user:",
 		"dm:",
 		"open_id:"
-	]) if (lowered.startsWith(prefix)) return normalizeText(withoutProvider.slice(prefix.length));
+	]) if (lowered.startsWith(prefix)) return normalizeOptionalString(withoutProvider.slice(prefix.length));
 	const id = parseFeishuTargetId(target);
 	if (!id) return;
 	if (id.startsWith("ou_") || id.startsWith("on_")) return id;
 }
 function parseFeishuConversationId(params) {
-	const conversationId = normalizeText(params.conversationId);
-	const parentConversationId = normalizeText(params.parentConversationId);
+	const conversationId = normalizeOptionalString(params.conversationId);
+	const parentConversationId = normalizeOptionalString(params.parentConversationId);
 	if (!conversationId) return null;
 	const topicSenderMatch = conversationId.match(/^(.+):topic:([^:]+):sender:([^:]+)$/i);
 	if (topicSenderMatch) {
@@ -121,7 +117,7 @@ function parseFeishuConversationId(params) {
 	};
 }
 function buildFeishuModelOverrideParentCandidates(parentConversationId) {
-	const rawId = normalizeText(parentConversationId);
+	const rawId = normalizeOptionalString(parentConversationId);
 	if (!rawId) return [];
 	const topicSenderMatch = rawId.match(/^(.+):topic:([^:]+):sender:([^:]+)$/i);
 	if (topicSenderMatch) {

package/dist/doctor-contract-api.js

@@ -1,2 +1,2 @@
-import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-BiD9tyIv.js";
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-bEQXIXyP.js";
 export { legacyConfigRules, normalizeCompatibilityConfig };

package/dist/doctor-contract-bEQXIXyP.js

@@ -0,0 +1,158 @@
+import { asObjectRecord, defineChannelAliasMigration, defineKeyMoveMigration, hasLegacyAccountStreamingAliases, normalizeChannelConfigEntries } from "openclaw/plugin-sdk/runtime-doctor-migrations";
+//#region extensions/feishu/src/webhook-path.ts
+const DEFAULT_FEISHU_WEBHOOK_PATH = "/feishu/events";
+/** Normalize trusted configuration only; incoming request targets must remain unmodified. */
+function normalizeFeishuWebhookPath(value) {
+	const configured = value?.trim();
+	if (!configured) return DEFAULT_FEISHU_WEBHOOK_PATH;
+	try {
+		const parsed = new URL(configured, "http://localhost");
+		if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return null;
+		const emptyQuery = !parsed.search && parsed.href.endsWith("?") && !configured.includes("#") ? "?" : "";
+		return `${parsed.pathname}${parsed.search}${emptyQuery}`;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#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 hasLegacyWebhookPath(value) {
+	const path = asObjectRecord(value)?.webhookPath;
+	return typeof path === "string" && normalizeFeishuWebhookPath(path) !== path;
+}
+function normalizeLegacyWebhookPath(params) {
+	const path = params.entry.webhookPath;
+	if (typeof path !== "string") return {
+		entry: params.entry,
+		changed: false
+	};
+	const normalized = normalizeFeishuWebhookPath(path);
+	const canonical = normalized ?? "/feishu/events";
+	if (canonical === path) return {
+		entry: params.entry,
+		changed: false
+	};
+	params.changes.push(normalized === null ? `Reset invalid ${params.pathPrefix}.webhookPath to ${DEFAULT_FEISHU_WEBHOOK_PATH}.` : `Normalized ${params.pathPrefix}.webhookPath to its HTTP request path.`);
+	return {
+		entry: {
+			...params.entry,
+			webhookPath: canonical
+		},
+		changed: true
+	};
+}
+function normalizeFeishuLegacyConfigEntries(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
+			});
+			const webhook = normalizeLegacyWebhookPath({
+				...params,
+				entry: heartbeat.entry
+			});
+			return {
+				entry: webhook.entry,
+				changed: tools.changed || coalesce.changed || heartbeat.changed || webhook.changed
+			};
+		}
+	}).config;
+}
+const legacyConfigRules = [
+	...streamingAliasMigration.legacyConfigRules,
+	{
+		path: ["channels", "feishu"],
+		message: "channels.feishu[.accounts.<id>].webhookPath must be a canonical HTTP request path; run \"openclaw doctor --fix\".",
+		match: (value) => {
+			const entry = asObjectRecord(value);
+			return hasLegacyWebhookPath(entry) || hasLegacyAccountStreamingAliases(entry?.accounts, hasLegacyWebhookPath);
+		}
+	},
+	{
+		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: normalizeFeishuLegacyConfigEntries(aliases.config, aliases.changes),
+		changes: aliases.changes
+	};
+}
+//#endregion
+export { normalizeFeishuWebhookPath as i, normalizeCompatibilityConfig as n, DEFAULT_FEISHU_WEBHOOK_PATH as r, legacyConfigRules as t };