@openclaw/feishu 2026.5.25-beta.1 → 2026.5.26-beta.2

package/dist/api.js

@@ -2,7 +2,7 @@ import { a as parseFeishuTargetId, i as parseFeishuDirectConversationId, n as bu
 import { n as getFeishuThreadBindingManager, r as testing, t as createFeishuThreadBindingManager } from "./thread-bindings-D24m3Cjy.js";
 import { n as handleFeishuSubagentEnded, r as handleFeishuSubagentSpawning, t as handleFeishuSubagentDeliveryTarget } from "./subagent-hooks-fuyBHOVu.js";
 import { r as listEnabledFeishuAccounts } from "./accounts-CXnY5H8g.js";
-import { a as setFeishuNamedAccountEnabled, i as feishuSetupAdapter, n as feishuSetupWizard, r as runFeishuLogin, t as feishuPlugin } from "./channel-CBVi0Pse.js";
+import { a as setFeishuNamedAccountEnabled, i as feishuSetupAdapter, n as feishuSetupWizard, r as runFeishuLogin, t as feishuPlugin } from "./channel-DavfT_AA.js";
 import { t as getFeishuRuntime } from "./runtime-C5JxBWZp.js";
 import { a as jsonToolResult, d as registerFeishuChatTools, f as createFeishuToolClient, m as resolveFeishuToolAccount, n as registerFeishuDriveTools, o as toolExecutionErrorResult, p as resolveAnyEnabledFeishuToolsConfig, s as unknownToolActionResult } from "./drive-DwgWWkJi.js";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString, readStringValue, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";

package/dist/{channel-CBVi0Pse.js → channel-DavfT_AA.js}

@@ -1,6 +1,6 @@
 import { a as parseFeishuTargetId, i as parseFeishuDirectConversationId, n as buildFeishuModelOverrideParentCandidates, r as parseFeishuConversationId, t as buildFeishuConversationId } from "./conversation-id-DuL575sn.js";
 import { n as looksLikeFeishuId, r as normalizeFeishuTarget, t as detectIdType } from "./targets-BUjQ1TcA.js";
-import { a as resolveDefaultFeishuAccountId, f as isRecord$1, i as listFeishuAccountIds, n as inspectFeishuCredentials, o as resolveFeishuAccount, r as listEnabledFeishuAccounts, s as resolveFeishuRuntimeAccount } from "./accounts-CXnY5H8g.js";
+import { a as resolveDefaultFeishuAccountId, f as isRecord$2, i as listFeishuAccountIds, n as inspectFeishuCredentials, o as resolveFeishuAccount, r as listEnabledFeishuAccounts, s as resolveFeishuRuntimeAccount } from "./accounts-CXnY5H8g.js";
 import { n as createFeishuSendReceipt, s as createFeishuCardInteractionEnvelope } from "./send-result-CHvu8Rr7.js";
 import { t as messageActionTargetAliases } from "./security-audit-BIeA3W3Q.js";
 import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries } from "./secret-contract-ChjJKAJ9.js";
@@ -8,6 +8,7 @@ import { t as collectFeishuSecurityAuditFindings } from "./security-audit-shared
 import { t as resolveFeishuSessionConversation } from "./session-conversation-CZSMgac-.js";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { getSessionBindingService } from "openclaw/plugin-sdk/conversation-runtime";
+import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
 import { describeAccountSnapshot } from "openclaw/plugin-sdk/account-helpers";
 import { formatAllowFromLowercase } from "openclaw/plugin-sdk/allow-from";
 import { adaptScopedAccountAccessor, createHybridChannelConfigAdapter } from "openclaw/plugin-sdk/channel-config-helpers";
@@ -20,15 +21,20 @@ import { normalizeMessagePresentation, renderMessagePresentationFallbackText } f
 import { createLazyRuntimeNamedExport } from "openclaw/plugin-sdk/lazy-runtime";
 import { createRuntimeOutboundDelegates } from "openclaw/plugin-sdk/outbound-runtime";
 import { buildProbeChannelStatusSummary, createComputedAccountStatusAdapter, createDefaultChannelRuntimeState } from "openclaw/plugin-sdk/status-helpers";
-import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$2, normalizeAccountId, resolveMergedAccountConfig } from "openclaw/plugin-sdk/account-resolution";
+import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$2, normalizeAccountId as normalizeAccountId$1, resolveMergedAccountConfig } from "openclaw/plugin-sdk/account-resolution";
 import { createResolvedApproverActionAuthAdapter, resolveApprovalApprovers } from "openclaw/plugin-sdk/approval-auth-runtime";
 import { createActionGate } from "openclaw/plugin-sdk/channel-actions";
 import { buildChannelConfigSchema } from "openclaw/plugin-sdk/channel-config-primitives";
 import { PAIRING_APPROVED_MESSAGE } from "openclaw/plugin-sdk/channel-status";
 import { chunkTextForOutbound } from "openclaw/plugin-sdk/text-chunking";
-import { normalizeAccountId as normalizeAccountId$1 } from "openclaw/plugin-sdk/account-id";
+import { normalizeAccountId as normalizeAccountId$2 } from "openclaw/plugin-sdk/account-id";
 import { z } from "zod";
 import { buildSecretInputSchema, hasConfiguredSecretInput as hasConfiguredSecretInput$2 } from "openclaw/plugin-sdk/secret-input";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { loadSessionStore, resolveSessionFilePath, resolveStorePath, updateSessionStore } from "openclaw/plugin-sdk/session-store-runtime";
+import { resolveStateDir } from "openclaw/plugin-sdk/state-paths";
 import { createChannelIngressResolver, defineStableChannelIngressIdentity } from "openclaw/plugin-sdk/channel-ingress-runtime";
 import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1, createSetupTranslator, formatDocsLink, hasConfiguredSecretInput as hasConfiguredSecretInput$1, mergeAllowFromEntries, patchTopLevelChannelConfigSection, promptSingleChannelSecretInput, splitSetupEntries } from "openclaw/plugin-sdk/setup";
 //#region extensions/feishu/src/approval-auth.ts
@@ -272,7 +278,7 @@ const FeishuConfigSchema = z.object({
 }).strict().superRefine((value, ctx) => {
 	const defaultAccount = value.defaultAccount?.trim();
 	if (defaultAccount && value.accounts && Object.keys(value.accounts).length > 0) {
-		const normalizedDefaultAccount = normalizeAccountId$1(defaultAccount);
+		const normalizedDefaultAccount = normalizeAccountId$2(defaultAccount);
 		if (!Object.prototype.hasOwnProperty.call(value.accounts, normalizedDefaultAccount)) ctx.addIssue({
 			code: z.ZodIssueCode.custom,
 			path: ["defaultAccount"],
@@ -367,6 +373,556 @@ async function listFeishuDirectoryGroups(params) {
 	}).map((entry) => entry.id));
 }
 //#endregion
+//#region extensions/feishu/src/doctor.ts
+const FEISHU_STATE_DIR = "feishu";
+const BACKUP_PREFIX = "feishu-state-repair";
+const BLANK_USER_MESSAGE_REPAIR_THRESHOLD = 3;
+const SESSION_FILE_INSPECTION_MAX_BYTES = 16 * 1024 * 1024;
+function timestampForPath(now = /* @__PURE__ */ new Date()) {
+	return now.toISOString().replaceAll(":", "-");
+}
+function isRecord$1(value) {
+	return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function toFeishuSessionEntry(value) {
+	if (!isRecord$1(value)) return {};
+	return {
+		sessionId: value.sessionId,
+		sessionFile: value.sessionFile
+	};
+}
+function countLabel(count, singular, plural = `${singular}s`) {
+	return `${count} ${count === 1 ? singular : plural}`;
+}
+function existsDir(dir) {
+	try {
+		return fs.statSync(dir).isDirectory();
+	} catch {
+		return false;
+	}
+}
+function existsFile(filePath) {
+	try {
+		return fs.statSync(filePath).isFile();
+	} catch {
+		return false;
+	}
+}
+function safeReadDir(dir) {
+	try {
+		return fs.readdirSync(dir, { withFileTypes: true });
+	} catch {
+		return [];
+	}
+}
+function isPathWithinRoot(targetPath, rootPath) {
+	const resolvedTarget = path.resolve(targetPath);
+	const resolvedRoot = path.resolve(rootPath);
+	const relative = path.relative(resolvedRoot, resolvedTarget);
+	return Boolean(relative) && !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function formatDisplayPath(filePath) {
+	const home = os.homedir();
+	const resolved = path.resolve(filePath);
+	return resolved === home || resolved.startsWith(`${home}${path.sep}`) ? `~${resolved.slice(home.length)}` : resolved;
+}
+function formatFinding(finding) {
+	switch (finding.kind) {
+		case "corrupt-state-json": return `- Feishu local JSON state is corrupt: ${formatDisplayPath(finding.path)}`;
+		case "missing-session-transcript": return `- Feishu session ${finding.sessionKey} points to a missing transcript in ${formatDisplayPath(finding.storePath)}`;
+		case "invalid-session-transcript": return `- Feishu session ${finding.sessionKey} has an invalid transcript (${finding.reason}): ${formatDisplayPath(finding.path)}`;
+		case "blank-user-message-run": return `- Feishu session ${finding.sessionKey} contains ${finding.count} blank user messages: ${formatDisplayPath(finding.path)}`;
+	}
+	return finding;
+}
+function isFeishuSessionStoreKey(key) {
+	const normalized = key.trim().toLowerCase();
+	return /^agent:[^:]+:feishu(?::|$)/.test(normalized) || /^feishu(?::|$)/.test(normalized);
+}
+function isFeishuAcpBindingSessionKey(key) {
+	return /^agent:[^:]+:acp:binding:feishu(?::|$)/.test(key.trim().toLowerCase());
+}
+function normalizeMetadataString(value) {
+	return typeof value === "string" ? value.trim().toLowerCase() : "";
+}
+function isFeishuSessionEntry(key, value) {
+	if (isFeishuAcpBindingSessionKey(key)) return false;
+	if (isFeishuSessionStoreKey(key)) return true;
+	if (!isRecord$1(value)) return false;
+	if (normalizeMetadataString(value.channel) === "feishu" || normalizeMetadataString(value.lastChannel) === "feishu") return true;
+	if (normalizeMetadataString((isRecord$1(value.route) ? value.route : null)?.channel) === "feishu") return true;
+	if (normalizeMetadataString((isRecord$1(value.deliveryContext) ? value.deliveryContext : null)?.channel) === "feishu") return true;
+	if (normalizeMetadataString((isRecord$1(value.pendingFinalDeliveryContext) ? value.pendingFinalDeliveryContext : null)?.channel) === "feishu") return true;
+	const origin = isRecord$1(value.origin) ? value.origin : null;
+	const originProvider = normalizeMetadataString(origin?.provider);
+	const originSurface = normalizeMetadataString(origin?.surface);
+	const originFrom = normalizeMetadataString(origin?.from);
+	return originProvider === "feishu" || originSurface.startsWith("feishu") || originFrom.startsWith("feishu:");
+}
+function collectConfiguredAgentIds(cfg) {
+	const ids = /* @__PURE__ */ new Set();
+	ids.add(resolveConfiguredDefaultAgentId(cfg));
+	for (const agent of cfg.agents?.list ?? []) if (typeof agent.id === "string" && agent.id.trim()) ids.add(normalizeAgentId(agent.id));
+	return [...ids].toSorted();
+}
+function resolveConfiguredDefaultAgentId(cfg) {
+	const agents = cfg.agents?.list ?? [];
+	const chosen = agents.find((agent) => agent?.default) ?? agents[0];
+	return normalizeAgentId(typeof chosen?.id === "string" && chosen.id.trim() ? chosen.id : "main");
+}
+function collectFeishuSessionTargets(params) {
+	const byStorePath = /* @__PURE__ */ new Map();
+	const addTarget = (target) => {
+		byStorePath.set(path.resolve(target.storePath), {
+			...target,
+			storePath: path.resolve(target.storePath)
+		});
+	};
+	for (const agentId of collectConfiguredAgentIds(params.cfg)) addTarget({
+		agentId,
+		storePath: resolveStorePath(params.cfg.session?.store, {
+			agentId,
+			env: params.env
+		})
+	});
+	const agentsDir = path.join(params.stateDir, "agents");
+	for (const agentDir of safeReadDir(agentsDir)) {
+		if (!agentDir.isDirectory()) continue;
+		const agentId = normalizeAgentId(agentDir.name);
+		const storePath = path.join(agentsDir, agentDir.name, "sessions", "sessions.json");
+		if (existsFile(storePath)) addTarget({
+			agentId,
+			storePath
+		});
+	}
+	return [...byStorePath.values()].toSorted((left, right) => left.storePath.localeCompare(right.storePath));
+}
+function collectJsonFiles(rootDir, limit = 200) {
+	const files = [];
+	const visit = (dir) => {
+		if (files.length >= limit) return;
+		for (const entry of safeReadDir(dir).toSorted((left, right) => left.name.localeCompare(right.name))) {
+			const fullPath = path.join(dir, entry.name);
+			if (entry.isDirectory()) {
+				visit(fullPath);
+				continue;
+			}
+			if (entry.isFile() && entry.name.endsWith(".json")) files.push(fullPath);
+			if (files.length >= limit) return;
+		}
+	};
+	if (existsDir(rootDir)) visit(rootDir);
+	return files;
+}
+function collectCorruptFeishuStateJsonFindings(feishuStateDir) {
+	const findings = [];
+	for (const filePath of collectJsonFiles(feishuStateDir)) try {
+		JSON.parse(fs.readFileSync(filePath, "utf-8"));
+	} catch {
+		findings.push({
+			kind: "corrupt-state-json",
+			path: filePath
+		});
+	}
+	return findings;
+}
+function resolveSessionTranscriptCandidates(params) {
+	const candidates = /* @__PURE__ */ new Set();
+	const sessionsDir = path.dirname(params.storePath);
+	const addSafeCandidate = (candidate) => {
+		const resolved = path.isAbsolute(candidate) ? path.resolve(candidate) : path.resolve(sessionsDir, candidate);
+		if (resolved === sessionsDir || !isPathWithinRoot(resolved, sessionsDir)) return;
+		candidates.add(resolved);
+	};
+	if (typeof params.entry.sessionId === "string" && /^[a-z0-9][a-z0-9._-]{0,127}$/i.test(params.entry.sessionId)) {
+		candidates.add(resolveSessionFilePath(params.entry.sessionId, typeof params.entry.sessionFile === "string" ? { sessionFile: params.entry.sessionFile } : void 0, {
+			agentId: params.agentId,
+			sessionsDir
+		}));
+		return [...candidates].toSorted();
+	}
+	if (typeof params.entry.sessionFile === "string" && params.entry.sessionFile.trim()) addSafeCandidate(params.entry.sessionFile.trim());
+	return [...candidates].toSorted();
+}
+function isSessionHeader(value) {
+	return isRecord$1(value) && value.type === "session" && typeof value.id === "string";
+}
+function isBlankUserMessage(value) {
+	if (!isRecord$1(value) || value.type !== "message" || !isRecord$1(value.message)) return false;
+	if (value.message.role !== "user") return false;
+	const content = value.message.content;
+	if (typeof content === "string") return content.trim().length === 0;
+	return Array.isArray(content) && content.length === 0;
+}
+function isUserMessage(value) {
+	return isRecord$1(value) && value.type === "message" && isRecord$1(value.message) && value.message.role === "user";
+}
+function inspectSessionTranscript(params) {
+	let stat;
+	try {
+		stat = fs.statSync(params.transcriptPath);
+	} catch {
+		return null;
+	}
+	if (!stat.isFile()) return {
+		kind: "invalid-session-transcript",
+		sessionKey: params.sessionKey,
+		storePath: params.storePath,
+		path: params.transcriptPath,
+		reason: "not a file"
+	};
+	if (stat.size > SESSION_FILE_INSPECTION_MAX_BYTES) return null;
+	let raw = "";
+	try {
+		raw = fs.readFileSync(params.transcriptPath, "utf-8");
+	} catch {
+		return {
+			kind: "invalid-session-transcript",
+			sessionKey: params.sessionKey,
+			storePath: params.storePath,
+			path: params.transcriptPath,
+			reason: "unreadable"
+		};
+	}
+	const entries = [];
+	let malformedLines = 0;
+	let blankUserMessageRun = 0;
+	let maxBlankUserMessageRun = 0;
+	for (const line of raw.split(/\r?\n/)) {
+		if (!line.trim()) continue;
+		try {
+			const entry = JSON.parse(line);
+			entries.push(entry);
+			if (isBlankUserMessage(entry)) {
+				blankUserMessageRun += 1;
+				maxBlankUserMessageRun = Math.max(maxBlankUserMessageRun, blankUserMessageRun);
+			} else if (isUserMessage(entry)) blankUserMessageRun = 0;
+		} catch {
+			malformedLines += 1;
+		}
+	}
+	if (entries.length === 0) return {
+		kind: "invalid-session-transcript",
+		sessionKey: params.sessionKey,
+		storePath: params.storePath,
+		path: params.transcriptPath,
+		reason: "empty transcript"
+	};
+	if (!isSessionHeader(entries[0])) return {
+		kind: "invalid-session-transcript",
+		sessionKey: params.sessionKey,
+		storePath: params.storePath,
+		path: params.transcriptPath,
+		reason: "invalid session header"
+	};
+	if (malformedLines > 0) return {
+		kind: "invalid-session-transcript",
+		sessionKey: params.sessionKey,
+		storePath: params.storePath,
+		path: params.transcriptPath,
+		reason: `${malformedLines} malformed JSONL line(s)`
+	};
+	if (maxBlankUserMessageRun >= BLANK_USER_MESSAGE_REPAIR_THRESHOLD) return {
+		kind: "blank-user-message-run",
+		sessionKey: params.sessionKey,
+		storePath: params.storePath,
+		path: params.transcriptPath,
+		count: maxBlankUserMessageRun
+	};
+	return null;
+}
+function collectFeishuSessionFindings(params) {
+	const transcriptCandidates = resolveSessionTranscriptCandidates(params);
+	const existing = transcriptCandidates.filter(existsFile);
+	if (transcriptCandidates.length > 0 && existing.length === 0) return [{
+		kind: "missing-session-transcript",
+		sessionKey: params.sessionKey,
+		storePath: params.storePath
+	}];
+	const findings = [];
+	for (const transcriptPath of existing) {
+		const finding = inspectSessionTranscript({
+			sessionKey: params.sessionKey,
+			storePath: params.storePath,
+			transcriptPath
+		});
+		if (finding) findings.push(finding);
+	}
+	return findings;
+}
+function hasCorruptFeishuStateJsonFinding(inspection) {
+	return inspection.findings.some((finding) => finding.kind === "corrupt-state-json");
+}
+function sessionEntryId(storePath, key) {
+	return `${path.resolve(storePath)}\0${key}`;
+}
+function collectRepairSessionEntries(inspection) {
+	const entriesById = /* @__PURE__ */ new Map();
+	for (const entry of inspection.sessionEntries) entriesById.set(sessionEntryId(entry.storePath, entry.key), entry);
+	const repairEntries = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const finding of inspection.findings) {
+		if (finding.kind === "corrupt-state-json") continue;
+		const id = sessionEntryId(finding.storePath, finding.sessionKey);
+		if (seen.has(id)) continue;
+		const entry = entriesById.get(id);
+		if (entry) {
+			repairEntries.push(entry);
+			seen.add(id);
+		}
+	}
+	return repairEntries.toSorted((left, right) => left.storePath.localeCompare(right.storePath) || left.key.localeCompare(right.key));
+}
+function inspectFeishuDoctorState(params) {
+	const env = params.env ?? process.env;
+	const stateDir = resolveStateDir(env, os.homedir);
+	const feishuStateDir = path.join(stateDir, FEISHU_STATE_DIR);
+	const findings = collectCorruptFeishuStateJsonFindings(feishuStateDir);
+	const sessionEntries = [];
+	for (const target of collectFeishuSessionTargets({
+		cfg: params.cfg,
+		env,
+		stateDir
+	})) {
+		const store = loadSessionStore(target.storePath, { skipCache: true });
+		for (const [key, entry] of Object.entries(store).toSorted(([left], [right]) => left.localeCompare(right))) {
+			if (!isFeishuSessionEntry(key, entry)) continue;
+			const sessionEntry = toFeishuSessionEntry(entry);
+			sessionEntries.push({
+				key,
+				storePath: target.storePath,
+				agentId: target.agentId,
+				entry: sessionEntry
+			});
+			findings.push(...collectFeishuSessionFindings({
+				sessionKey: key,
+				storePath: target.storePath,
+				agentId: target.agentId,
+				entry: sessionEntry
+			}));
+		}
+	}
+	return {
+		stateDir,
+		feishuStateDir,
+		findings,
+		sessionEntries
+	};
+}
+function ensureBackupDir(stateDir, now) {
+	const backupDir = path.join(stateDir, "backups", `${BACKUP_PREFIX}-${timestampForPath(now)}`);
+	fs.mkdirSync(backupDir, {
+		recursive: true,
+		mode: 448
+	});
+	return backupDir;
+}
+function resolveUniquePath(candidate) {
+	if (!fs.existsSync(candidate)) return candidate;
+	for (let index = 1; index < 1e3; index += 1) {
+		const next = `${candidate}.${index}`;
+		if (!fs.existsSync(next)) return next;
+	}
+	throw new Error(`Unable to resolve unique path for ${candidate}`);
+}
+function movePathToBackup(params) {
+	if (!fs.existsSync(params.sourcePath)) return false;
+	const targetPath = resolveUniquePath(path.join(params.backupDir, params.relativeTarget));
+	fs.mkdirSync(path.dirname(targetPath), {
+		recursive: true,
+		mode: 448
+	});
+	fs.renameSync(params.sourcePath, targetPath);
+	return true;
+}
+function copyStoreBackup(params) {
+	if (!existsFile(params.storePath)) return;
+	const targetPath = path.join(params.backupDir, "session-stores", params.agentId, path.basename(params.storePath));
+	fs.mkdirSync(path.dirname(targetPath), {
+		recursive: true,
+		mode: 448
+	});
+	fs.copyFileSync(params.storePath, resolveUniquePath(targetPath));
+}
+function collectSessionArtifactPaths(params) {
+	const artifacts = /* @__PURE__ */ new Set();
+	for (const transcriptPath of resolveSessionTranscriptCandidates(params)) {
+		artifacts.add(transcriptPath);
+		if (transcriptPath.endsWith(".jsonl")) {
+			const base = transcriptPath.slice(0, -6);
+			artifacts.add(`${base}.trajectory.jsonl`);
+			artifacts.add(`${base}.trajectory-path.json`);
+		}
+	}
+	return [...artifacts].toSorted();
+}
+function archiveSessionArtifacts(params) {
+	const seen = /* @__PURE__ */ new Set();
+	let archived = 0;
+	for (const entry of params.entries) for (const artifactPath of collectSessionArtifactPaths({
+		storePath: params.storePath,
+		agentId: entry.agentId,
+		entry: entry.entry
+	})) {
+		if (seen.has(artifactPath) || !existsFile(artifactPath)) continue;
+		seen.add(artifactPath);
+		const archivedPath = resolveUniquePath(`${artifactPath}.deleted.${params.archiveTimestamp}`);
+		fs.renameSync(artifactPath, archivedPath);
+		archived += 1;
+	}
+	return archived;
+}
+async function repairFeishuDoctorState(params) {
+	const env = params.env ?? process.env;
+	const now = params.now ?? /* @__PURE__ */ new Date();
+	const inspection = params.inspection ?? inspectFeishuDoctorState({
+		cfg: params.cfg,
+		env
+	});
+	const backupDir = ensureBackupDir(inspection.stateDir, now);
+	const archiveTimestamp = timestampForPath(now);
+	const warnings = [];
+	const stateDirRepairAttempted = hasCorruptFeishuStateJsonFinding(inspection);
+	let rebuiltStateDir = false;
+	if (stateDirRepairAttempted) try {
+		rebuiltStateDir = movePathToBackup({
+			sourcePath: inspection.feishuStateDir,
+			backupDir,
+			relativeTarget: FEISHU_STATE_DIR
+		});
+		fs.mkdirSync(inspection.feishuStateDir, {
+			recursive: true,
+			mode: 448
+		});
+	} catch (error) {
+		warnings.push(`- Failed to rebuild Feishu local state: ${String(error)}`);
+	}
+	const entriesByStore = /* @__PURE__ */ new Map();
+	for (const entry of collectRepairSessionEntries(inspection)) {
+		const existing = entriesByStore.get(entry.storePath);
+		if (existing) existing.entries.push({
+			key: entry.key,
+			entry: entry.entry
+		});
+		else entriesByStore.set(entry.storePath, {
+			agentId: entry.agentId,
+			entries: [{
+				key: entry.key,
+				entry: entry.entry
+			}]
+		});
+	}
+	let removedSessionEntries = 0;
+	let touchedSessionStores = 0;
+	let archivedSessionArtifacts = 0;
+	for (const [storePath, group] of [...entriesByStore.entries()].toSorted(([left], [right]) => left.localeCompare(right))) try {
+		copyStoreBackup({
+			storePath,
+			backupDir,
+			agentId: group.agentId
+		});
+		const keys = new Set(group.entries.map((entry) => entry.key));
+		const removedEntries = await updateSessionStore(storePath, (store) => {
+			const removed = [];
+			for (const key of keys) if (Object.prototype.hasOwnProperty.call(store, key)) {
+				delete store[key];
+				const entry = group.entries.find((candidate) => candidate.key === key);
+				if (entry) removed.push(entry);
+			}
+			return removed;
+		}, {
+			skipMaintenance: true,
+			allowDropAcpMetaSessionKeys: [...keys]
+		});
+		const removed = removedEntries.length;
+		removedSessionEntries += removed;
+		if (removed > 0) {
+			touchedSessionStores += 1;
+			archivedSessionArtifacts += archiveSessionArtifacts({
+				storePath,
+				entries: removedEntries.map((entry) => ({
+					agentId: group.agentId,
+					entry: entry.entry
+				})),
+				archiveTimestamp
+			});
+		}
+	} catch (error) {
+		warnings.push(`- Failed to archive Feishu sessions in ${formatDisplayPath(storePath)}: ${String(error)}`);
+	}
+	return {
+		backupDir,
+		stateDirRepairAttempted,
+		rebuiltStateDir,
+		removedSessionEntries,
+		touchedSessionStores,
+		archivedSessionArtifacts,
+		warnings
+	};
+}
+function formatPreviewWarning(inspection) {
+	const previewFindings = inspection.findings.slice(0, 5).map(formatFinding);
+	const remaining = inspection.findings.length - previewFindings.length;
+	const repairActions = [];
+	if (hasCorruptFeishuStateJsonFinding(inspection)) repairActions.push(`archive ${formatDisplayPath(inspection.feishuStateDir)}`);
+	const repairSessionEntries = collectRepairSessionEntries(inspection);
+	if (repairSessionEntries.length > 0) repairActions.push(`archive artifacts and remove ${countLabel(repairSessionEntries.length, "flagged Feishu-scoped session entry", "flagged Feishu-scoped session entries")}`);
+	const repairSummary = repairActions.length > 0 ? repairActions.join(" and ") : "apply targeted Feishu state cleanup";
+	return [
+		"- Feishu local channel state may need repair.",
+		...previewFindings,
+		...remaining > 0 ? [`- ...and ${remaining} more Feishu state finding(s).`] : [],
+		`- Repair will ${repairSummary}, while preserving Feishu App ID/secret config and healthy session entries.`,
+		"- Run \"openclaw doctor --fix\" to rebuild Feishu local state."
+	].join("\n");
+}
+function formatRepairChange(report) {
+	const stateRepairStatus = report.stateDirRepairAttempted ? report.rebuiltStateDir ? "yes" : "no existing state" : "not needed";
+	return [
+		"Feishu local state repaired.",
+		`- Backup dir: ${formatDisplayPath(report.backupDir)}`,
+		`- Rebuilt Feishu runtime state: ${stateRepairStatus}`,
+		`- Removed ${countLabel(report.removedSessionEntries, "Feishu-scoped session entry", "Feishu-scoped session entries")} from ${countLabel(report.touchedSessionStores, "session store")}.`,
+		`- Archived ${countLabel(report.archivedSessionArtifacts, "session artifact file")}.`,
+		"- Preserved Feishu App ID/secret config."
+	].join("\n");
+}
+function hasConfiguredFeishuChannel(cfg) {
+	return Boolean(cfg.channels?.feishu);
+}
+async function runFeishuDoctorSequence(params) {
+	if (!hasConfiguredFeishuChannel(params.cfg)) return {
+		changeNotes: [],
+		warningNotes: []
+	};
+	const inspection = inspectFeishuDoctorState({
+		cfg: params.cfg,
+		env: params.env
+	});
+	if (inspection.findings.length === 0) return {
+		changeNotes: [],
+		warningNotes: []
+	};
+	if (!params.shouldRepair) return {
+		changeNotes: [],
+		warningNotes: [formatPreviewWarning(inspection)]
+	};
+	const report = await repairFeishuDoctorState({
+		cfg: params.cfg,
+		env: params.env,
+		inspection
+	});
+	return {
+		changeNotes: [formatRepairChange(report)],
+		warningNotes: report.warnings
+	};
+}
+const feishuDoctor = { runConfigSequence: async ({ cfg, env, shouldRepair }) => await runFeishuDoctorSequence({
+	cfg,
+	env,
+	shouldRepair
+}) };
+//#endregion
 //#region extensions/feishu/src/policy.ts
 const FEISHU_PROVIDER_PREFIX_RE = /^(feishu|lark):/i;
 const FEISHU_TYPED_PREFIX_RE = /^(chat|group|channel|user|dm|open_id):/i;
@@ -426,7 +982,7 @@ function createFeishuIngressSubject(params) {
 function createFeishuIngressResolver(params) {
 	return createChannelIngressResolver({
 		channelId: "feishu",
-		accountId: normalizeAccountId(params.accountId) ?? "default",
+		accountId: normalizeAccountId$1(params.accountId) ?? "default",
 		identity: feishuIngressIdentity,
 		cfg: params.cfg,
 		...params.readAllowFromStore ? { readStoreAllowFrom: params.readAllowFromStore } : {}
@@ -532,8 +1088,8 @@ function resolveFeishuReplyPolicy(params) {
 	const resolvedCfg = resolveMergedAccountConfig({
 		channelConfig: feishuCfg,
 		accounts: feishuCfg?.accounts,
-		accountId: normalizeAccountId(params.accountId),
-		normalizeAccountId,
+		accountId: normalizeAccountId$1(params.accountId),
+		normalizeAccountId: normalizeAccountId$1,
 		omitKeys: ["defaultAccount"]
 	});
 	const groupRequireMention = resolveFeishuGroupConfig({
@@ -1148,13 +1704,13 @@ function readBooleanParam(params, keys) {
 	}
 }
 function hasLegacyFeishuCardCommandValue(actionValue) {
-	return isRecord$1(actionValue) && actionValue.oc !== "ocf1" && (Boolean(typeof actionValue.command === "string" && actionValue.command.trim()) || Boolean(typeof actionValue.text === "string" && actionValue.text.trim()));
+	return isRecord$2(actionValue) && actionValue.oc !== "ocf1" && (Boolean(typeof actionValue.command === "string" && actionValue.command.trim()) || Boolean(typeof actionValue.text === "string" && actionValue.text.trim()));
 }
 function containsLegacyFeishuCardCommandValue(node) {
 	if (Array.isArray(node)) return node.some((item) => containsLegacyFeishuCardCommandValue(item));
-	if (!isRecord$1(node)) return false;
+	if (!isRecord$2(node)) return false;
 	if (node.tag === "button" && hasLegacyFeishuCardCommandValue(node.value)) return true;
-	if (node.tag === "button" && Array.isArray(node.behaviors) && node.behaviors.some((behavior) => isRecord$1(behavior) && hasLegacyFeishuCardCommandValue(behavior.value))) return true;
+	if (node.tag === "button" && Array.isArray(node.behaviors) && node.behaviors.some((behavior) => isRecord$2(behavior) && hasLegacyFeishuCardCommandValue(behavior.value))) return true;
 	return Object.values(node).some((value) => containsLegacyFeishuCardCommandValue(value));
 }
 const meta = {
@@ -1167,7 +1723,7 @@ const meta = {
 	aliases: ["lark"],
 	order: 70
 };
-const loadFeishuChannelRuntime = createLazyRuntimeNamedExport(() => import("./channel.runtime-qTiXSDEF.js"), "feishuChannelRuntime");
+const loadFeishuChannelRuntime = createLazyRuntimeNamedExport(() => import("./channel.runtime-ItBg9SfS.js"), "feishuChannelRuntime");
 function toFeishuMessageSendResult(result, kind) {
 	const receipt = result.receipt ?? createFeishuSendReceipt({
 		messageId: result.messageId,
@@ -1498,6 +2054,7 @@ const feishuPlugin = createChatChannelPlugin({
 		},
 		mentions: { stripPatterns: () => ["<at user_id=\"[^\"]*\">[^<]*</at>"] },
 		reload: { configPrefixes: ["channels.feishu"] },
+		doctor: feishuDoctor,
 		configSchema: buildChannelConfigSchema(FeishuConfigSchema),
 		config: {
 			...feishuConfigAdapter,
@@ -1986,7 +2543,7 @@ const feishuPlugin = createChatChannelPlugin({
 			})
 		}),
 		gateway: { startAccount: async (ctx) => {
-			const { monitorFeishuProvider } = await import("./monitor-OdRQj8yf.js");
+			const { monitorFeishuProvider } = await import("./monitor-gFxvkDyO.js");
 			const account = resolveFeishuRuntimeAccount({
 				cfg: ctx.cfg,
 				accountId: ctx.accountId

package/dist/channel-plugin-api.js

@@ -1,2 +1,2 @@
-import { t as feishuPlugin } from "./channel-CBVi0Pse.js";
+import { t as feishuPlugin } from "./channel-DavfT_AA.js";
 export { feishuPlugin };

package/dist/{channel.runtime-qTiXSDEF.js → channel.runtime-ItBg9SfS.js}

@@ -1,5 +1,5 @@
 import { o as resolveFeishuAccount, s as resolveFeishuRuntimeAccount, y as parseFeishuCommentTarget } from "./accounts-CXnY5H8g.js";
-import { h as listFeishuDirectoryPeers, m as listFeishuDirectoryGroups, o as buildFeishuPresentationCardElements } from "./channel-CBVi0Pse.js";
+import { h as listFeishuDirectoryPeers, m as listFeishuDirectoryGroups, o as buildFeishuPresentationCardElements } from "./channel-DavfT_AA.js";
 import { r as createFeishuClient } from "./client-BnH2fRL2.js";
 import { c as getChatInfo, l as getChatMembers, r as cleanupAmbientCommentTypingReaction, t as deliverCommentThreadText, u as getFeishuMemberInfo } from "./drive-DwgWWkJi.js";
 import { chunkTextForOutbound } from "./runtime-api.js";

package/dist/{monitor-OdRQj8yf.js → monitor-gFxvkDyO.js}

@@ -3,7 +3,7 @@ import { l as fetchBotIdentityForMonitor } from "./monitor.state-CxrHFQX2.js";
 //#region extensions/feishu/src/monitor.ts
 let monitorAccountRuntimePromise;
 async function loadMonitorAccountRuntime() {
-	monitorAccountRuntimePromise ??= import("./monitor.account-DilSvSo7.js");
+	monitorAccountRuntimePromise ??= import("./monitor.account-CmXHWuwG.js");
 	return await monitorAccountRuntimePromise;
 }
 async function monitorFeishuProvider(opts = {}) {

package/dist/{monitor.account-DilSvSo7.js → monitor.account-CmXHWuwG.js}

@@ -2,12 +2,12 @@ import { t as buildFeishuConversationId } from "./conversation-id-DuL575sn.js";
 import { i as resolveReceiveIdType } from "./targets-BUjQ1TcA.js";
 import { t as createFeishuThreadBindingManager } from "./thread-bindings-D24m3Cjy.js";
 import { _ as buildFeishuCommentTarget, f as isRecord$1, h as readString, l as encodeQuery, m as parseCommentContentElements, p as normalizeString, s as resolveFeishuRuntimeAccount, u as extractReplyText, v as normalizeCommentFileType } from "./accounts-CXnY5H8g.js";
-import { c as normalizeFeishuAllowEntry, d as resolveFeishuGroupConversationIngressAccess, f as resolveFeishuGroupSenderActivationIngressAccess, l as resolveFeishuDmIngressAccess, p as resolveFeishuReplyPolicy, s as hasExplicitFeishuGroupConfig, u as resolveFeishuGroupConfig } from "./channel-CBVi0Pse.js";
+import { c as normalizeFeishuAllowEntry, d as resolveFeishuGroupConversationIngressAccess, f as resolveFeishuGroupSenderActivationIngressAccess, l as resolveFeishuDmIngressAccess, p as resolveFeishuReplyPolicy, s as hasExplicitFeishuGroupConfig, u as resolveFeishuGroupConfig } from "./channel-DavfT_AA.js";
 import { c as decodeFeishuCardAction, o as buildFeishuCardActionTextFallback, s as createFeishuCardInteractionEnvelope } from "./send-result-CHvu8Rr7.js";
 import { t as getFeishuRuntime } from "./runtime-C5JxBWZp.js";
 import { a as getFeishuUserAgent, i as createFeishuWSClient, n as createEventDispatcher, r as createFeishuClient } from "./client-BnH2fRL2.js";
 import { c as getChatInfo, i as createCommentTypingReactionLifecycle, t as deliverCommentThreadText } from "./drive-DwgWWkJi.js";
-import { buildAgentMediaPayload, createReplyPrefixContext, evaluateSupplementalContextVisibility, loadSessionStore, normalizeAgentId as normalizeAgentId$1, resolveChannelContextVisibilityMode, resolveSessionStoreEntry } from "./runtime-api.js";
+import { buildAgentMediaPayload, createReplyPrefixContext, evaluateSupplementalContextVisibility, loadSessionStore, normalizeAgentId as normalizeAgentId$2, resolveChannelContextVisibilityMode, resolveSessionStoreEntry } from "./runtime-api.js";
 import { _ as normalizeFeishuExternalKey, a as sendCardFeishu, c as sendStructuredCardFeishu, d as isFeishuBroadcastMention, f as isMentionForwardRequest, g as shouldSuppressFeishuTextForVoiceMedia, h as sendMediaFeishu, i as resolveFeishuCardTemplate, l as parsePostContent, m as saveMessageResourceFeishu, n as getMessageFeishu, p as isFeishuGroupChatType, r as listFeishuThreadMessages, s as sendMessageFeishu, u as extractMentionTargets } from "./send-DQClIwTI.js";
 import { i as waitForAbortableDelay, r as raceWithTimeoutAndAbort } from "./probe-Da81t6a5.js";
 import { a as feishuWebhookRateLimiter, c as wsClients, i as botOpenIds, l as fetchBotIdentityForMonitor, n as FEISHU_WEBHOOK_MAX_BODY_BYTES, o as httpServers, r as botNames, s as recordWebhookStatus, t as FEISHU_WEBHOOK_BODY_TIMEOUT_MS } from "./monitor.state-CxrHFQX2.js";
@@ -664,12 +664,12 @@ function resolveUserPath(p) {
 //#endregion
 //#region extensions/feishu/src/agent-config.ts
 const DEFAULT_AGENT_ID = "main";
-function normalizeAgentId(value) {
+function normalizeAgentId$1(value) {
 	return (value ?? "").trim().toLowerCase() || DEFAULT_AGENT_ID;
 }
 function resolveFeishuConfigReasoningDefault(cfg, agentId) {
-	const id = normalizeAgentId(agentId);
-	return cfg.agents?.list?.find((entry) => normalizeAgentId(entry?.id) === id)?.reasoningDefault ?? cfg.agents?.defaults?.reasoningDefault ?? "off";
+	const id = normalizeAgentId$1(agentId);
+	return cfg.agents?.list?.find((entry) => normalizeAgentId$1(entry?.id) === id)?.reasoningDefault ?? cfg.agents?.defaults?.reasoningDefault ?? "off";
 }
 //#endregion
 //#region extensions/feishu/src/reasoning-preview.ts
@@ -1974,7 +1974,7 @@ async function handleFeishuMessage(params) {
 	const dmPolicy = feishuCfg?.dmPolicy ?? "pairing";
 	const configAllowFrom = feishuCfg?.allowFrom ?? [];
 	const rawBroadcastAgents = isGroup ? resolveBroadcastAgents(cfg, ctx.chatId) : null;
-	const broadcastAgents = rawBroadcastAgents ? uniqueStrings(rawBroadcastAgents.map((id) => normalizeAgentId$1(id))) : null;
+	const broadcastAgents = rawBroadcastAgents ? uniqueStrings(rawBroadcastAgents.map((id) => normalizeAgentId$2(id))) : null;
 	const messageCreateTimeMs = event.message.create_time ? Number.parseInt(event.message.create_time, 10) : Date.now();
 	let requireMention = false;
 	if (isGroup) {
@@ -2498,12 +2498,12 @@ async function handleFeishuMessage(params) {
 				return;
 			}
 			const strategy = cfg.broadcast?.strategy === "sequential" ? "sequential" : "parallel";
-			const activeAgentId = ctx.mentionedBot || !requireMention ? normalizeAgentId$1(route.agentId) : null;
-			const agentIds = (cfg.agents?.list ?? []).map((a) => normalizeAgentId$1(a.id));
+			const activeAgentId = ctx.mentionedBot || !requireMention ? normalizeAgentId$2(route.agentId) : null;
+			const agentIds = (cfg.agents?.list ?? []).map((a) => normalizeAgentId$2(a.id));
 			const hasKnownAgents = agentIds.length > 0;
 			log(`feishu[${account.accountId}]: broadcasting to ${broadcastAgents.length} agents (strategy=${strategy}, active=${activeAgentId ?? "none"})`);
 			const dispatchForAgent = async (agentId) => {
-				if (hasKnownAgents && !agentIds.includes(normalizeAgentId$1(agentId))) {
+				if (hasKnownAgents && !agentIds.includes(normalizeAgentId$2(agentId))) {
 					log(`feishu[${account.accountId}]: broadcast agent ${agentId} not found in agents.list; skipping`);
 					return;
 				}

package/dist/runtime-api.js

@@ -4,10 +4,10 @@ import { createReplyPrefixContext } from "openclaw/plugin-sdk/channel-message";
 import { createChannelPairingController } from "openclaw/plugin-sdk/channel-pairing";
 import { PAIRING_APPROVED_MESSAGE, buildProbeChannelStatusSummary, createDefaultChannelRuntimeState } from "openclaw/plugin-sdk/channel-status";
 import { chunkTextForOutbound } from "openclaw/plugin-sdk/text-chunking";
+import { loadSessionStore, resolveSessionStoreEntry } from "openclaw/plugin-sdk/session-store-runtime";
 import { DEFAULT_ACCOUNT_ID, buildChannelConfigSchema, createActionGate, createDedupeCache } from "openclaw/plugin-sdk/core";
 import { buildAgentMediaPayload } from "openclaw/plugin-sdk/agent-media-payload";
 import { evaluateSupplementalContextVisibility, filterSupplementalContextItems, resolveChannelContextVisibilityMode } from "openclaw/plugin-sdk/context-visibility-runtime";
-import { loadSessionStore, resolveSessionStoreEntry } from "openclaw/plugin-sdk/session-store-runtime";
 import { readJsonFileWithFallback } from "openclaw/plugin-sdk/json-store";
 import { createPersistentDedupe } from "openclaw/plugin-sdk/persistent-dedupe";
 import { isRequestBodyLimitError, readRequestBodyWithLimit, requestBodyErrorToText } from "openclaw/plugin-sdk/webhook-ingress";

package/dist/setup-api.js

@@ -1,2 +1,2 @@
-import { i as feishuSetupAdapter, n as feishuSetupWizard, t as feishuPlugin } from "./channel-CBVi0Pse.js";
+import { i as feishuSetupAdapter, n as feishuSetupWizard, t as feishuPlugin } from "./channel-DavfT_AA.js";
 export { feishuPlugin, feishuSetupAdapter, feishuSetupWizard };

package/npm-shrinkwrap.json

@@ -1,19 +1,19 @@
 {
   "name": "@openclaw/feishu",
-  "version": "2026.5.25-beta.1",
+  "version": "2026.5.26-beta.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@openclaw/feishu",
-      "version": "2026.5.25-beta.1",
+      "version": "2026.5.26-beta.2",
       "dependencies": {
         "@larksuiteoapi/node-sdk": "1.65.0",
         "typebox": "1.1.38",
         "zod": "4.4.3"
       },
       "peerDependencies": {
-        "openclaw": ">=2026.5.25-beta.1"
+        "openclaw": ">=2026.5.26-beta.2"
       },
       "peerDependenciesMeta": {
         "openclaw": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/feishu",
-  "version": "2026.5.25-beta.1",
+  "version": "2026.5.26-beta.2",
   "description": "OpenClaw Feishu/Lark channel plugin (community maintained by @m1heng)",
   "repository": {
     "type": "git",
@@ -13,7 +13,7 @@
     "zod": "4.4.3"
   },
   "peerDependencies": {
-    "openclaw": ">=2026.5.25-beta.1"
+    "openclaw": ">=2026.5.26-beta.2"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -44,10 +44,10 @@
       "minHostVersion": ">=2026.4.25"
     },
     "compat": {
-      "pluginApi": ">=2026.5.25-beta.1"
+      "pluginApi": ">=2026.5.26-beta.2"
     },
     "build": {
-      "openclawVersion": "2026.5.25-beta.1"
+      "openclawVersion": "2026.5.26-beta.2"
     },
     "release": {
       "publishToClawHub": true,