@openclaw/msteams 2026.5.28 → 2026.5.31-beta.1

package/dist/{probe-BoUA5GpA.js → probe-DMNefdBZ.js}

@@ -1,7 +1,7 @@
 import { C as normalizeStringEntries$1, E as resolveChannelMediaMaxBytes, M as getMSTeamsRuntime, d as detectMime, g as getFileExtension, m as extractOriginalFilename, p as extensionForMime, y as loadOutboundMediaFromUrl } from "./runtime-api-BlvMnDKz.js";
-import { A as isAllowedBotFrameworkServiceUrl, C as readAccessToken, D as buildUserAgent, E as loadMSTeamsSdkWithAuth, N as resolveMSTeamsSdkCloudOptions, P as validateMSTeamsProactiveServiceUrlBoundary, T as createMSTeamsTokenProvider, i as isRevokedProxyError, j as normalizeBotFrameworkServiceUrl, k as describeBotFrameworkServiceUrlHost, n as formatMSTeamsSendErrorHint, r as formatUnknownError, t as classifyMSTeamsSendError, v as loadDelegatedTokens, x as resolveMSTeamsStorePath, y as resolveMSTeamsCredentials } from "./errors-DZGI_mqq.js";
+import { A as isAllowedBotFrameworkServiceUrl, C as readAccessToken, D as buildUserAgent, E as loadMSTeamsSdkWithAuth, N as resolveMSTeamsSdkCloudOptions, P as validateMSTeamsProactiveServiceUrlBoundary, T as createMSTeamsTokenProvider, i as isRevokedProxyError, j as normalizeBotFrameworkServiceUrl, k as describeBotFrameworkServiceUrlHost, n as formatMSTeamsSendErrorHint, r as formatUnknownError, t as classifyMSTeamsSendError, v as loadDelegatedTokens, x as resolveMSTeamsStorePath, y as resolveMSTeamsCredentials } from "./errors-Dpn8B05h.js";
 import { c as createMSTeamsHttpError } from "./oauth.token-BKzEFepQ.js";
-import { a as resolveMSTeamsReplyPolicy, o as resolveMSTeamsRouteConfig } from "./channel-2_L55KDI.js";
+import { a as resolveMSTeamsReplyPolicy, o as resolveMSTeamsRouteConfig } from "./channel-CqRTzeBc.js";
 import { createMessageReceiptFromOutboundResults } from "openclaw/plugin-sdk/channel-outbound";
 import { isRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, normalizeStringEntries, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { withFileLock } from "openclaw/plugin-sdk/file-lock";
@@ -10,10 +10,11 @@ import { convertMarkdownTables } from "openclaw/plugin-sdk/text-chunking";
 import { lookup } from "node:dns/promises";
 import { isPrivateIpAddress } from "openclaw/plugin-sdk/ssrf-policy";
 import path from "node:path";
+import { isFutureDateTimestampMs, parseStrictNonNegativeInteger } from "openclaw/plugin-sdk/number-runtime";
 import { pathExists } from "openclaw/plugin-sdk/security-runtime";
-import { parseStrictNonNegativeInteger } from "openclaw/plugin-sdk/number-runtime";
+import crypto, { createHash } from "node:crypto";
+import fs from "node:fs/promises";
 import { readJsonFileWithFallback, writeJsonFileAtomically } from "openclaw/plugin-sdk/json-store";
-import crypto from "node:crypto";
 import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
 import { SILENT_REPLY_TOKEN, isSilentReplyText } from "openclaw/plugin-sdk/reply-chunking";
 import { sleep } from "openclaw/plugin-sdk/text-utility-runtime";
@@ -88,87 +89,213 @@ async function withFileLock$1(filePath, fallback, fn) {
 	});
 }
 //#endregion
-//#region extensions/msteams/src/conversation-store-fs.ts
+//#region extensions/msteams/src/sqlite-state.ts
+function resolveStateDirOverride(options) {
+	if (!options) return;
+	if (options.stateDir) return options.stateDir;
+	if (options.storePath) return path.dirname(options.storePath);
+	if (options.homedir) return getMSTeamsRuntime().state.resolveStateDir(options.env ?? process.env, options.homedir);
+	return options.env?.OPENCLAW_STATE_DIR?.trim() || void 0;
+}
+function resolveMSTeamsSqliteStateEnv(options) {
+	const stateDir = resolveStateDirOverride(options);
+	if (!stateDir) return options?.env;
+	return {
+		...options?.env ?? process.env,
+		OPENCLAW_STATE_DIR: stateDir
+	};
+}
+function toPluginJsonValue(value) {
+	const serialized = JSON.stringify(value);
+	return JSON.parse(serialized);
+}
+function resolveMSTeamsSqliteStateDir(options) {
+	return resolveStateDirOverride(options) ?? getMSTeamsRuntime().state.resolveStateDir(options?.env ?? process.env, options?.homedir);
+}
+const sqliteMutationLocks = /* @__PURE__ */ new Map();
+async function withProcessMutationLock(lockPath, fn) {
+	const previous = sqliteMutationLocks.get(lockPath) ?? Promise.resolve();
+	let release = () => {};
+	const next = new Promise((resolve) => {
+		release = resolve;
+	});
+	const chained = previous.then(() => next, () => next);
+	sqliteMutationLocks.set(lockPath, chained);
+	await previous.catch(() => void 0);
+	try {
+		return await fn();
+	} finally {
+		release();
+		if (sqliteMutationLocks.get(lockPath) === chained) sqliteMutationLocks.delete(lockPath);
+	}
+}
+async function withMSTeamsSqliteMutationLock(options, lockFilename, fn) {
+	const lockPath = path.join(resolveMSTeamsSqliteStateDir(options), lockFilename);
+	return await withProcessMutationLock(lockPath, async () => {
+		return await withFileLock$1(lockPath, { version: 1 }, fn);
+	});
+}
+//#endregion
+//#region extensions/msteams/src/conversation-store-state.ts
 const STORE_FILENAME$2 = "msteams-conversations.json";
+const CONVERSATIONS_NAMESPACE = "conversations";
+const CONVERSATION_MIGRATIONS_NAMESPACE = "conversation-migrations";
+const LEGACY_JSON_MIGRATION_KEY = "msteams-conversations-json-v1";
 const MAX_CONVERSATIONS = 1e3;
+const SQLITE_MAX_CONVERSATION_ROWS = 2e3;
 const CONVERSATION_TTL_MS = 365 * 24 * 60 * 60 * 1e3;
-function pruneToLimit$2(conversations) {
-	const entries = Object.entries(conversations);
-	if (entries.length <= MAX_CONVERSATIONS) return conversations;
-	entries.sort((a, b) => {
-		return (parseStoredConversationTimestamp(a[1].lastSeenAt) ?? 0) - (parseStoredConversationTimestamp(b[1].lastSeenAt) ?? 0);
+const CONVERSATION_LOCK_FILENAME = "msteams-conversations.sqlite.lock";
+function createConversationStateStore(params) {
+	return getMSTeamsRuntime().state.openKeyedStore({
+		namespace: CONVERSATIONS_NAMESPACE,
+		maxEntries: SQLITE_MAX_CONVERSATION_ROWS,
+		env: resolveMSTeamsSqliteStateEnv(params)
 	});
-	const keep = entries.slice(entries.length - MAX_CONVERSATIONS);
-	return Object.fromEntries(keep);
 }
-function pruneExpired$2(conversations, nowMs, ttlMs) {
-	let removed = false;
-	const kept = {};
-	for (const [conversationId, reference] of Object.entries(conversations)) {
-		const lastSeenAt = parseStoredConversationTimestamp(reference.lastSeenAt);
-		if (lastSeenAt != null && nowMs - lastSeenAt > ttlMs) {
-			removed = true;
-			continue;
-		}
-		kept[conversationId] = reference;
-	}
-	return {
-		conversations: kept,
-		removed
-	};
+function createConversationMigrationStore(params) {
+	return getMSTeamsRuntime().state.openKeyedStore({
+		namespace: CONVERSATION_MIGRATIONS_NAMESPACE,
+		maxEntries: 100,
+		env: resolveMSTeamsSqliteStateEnv(params)
+	});
 }
-function createMSTeamsConversationStoreFs(params) {
-	const ttlMs = params?.ttlMs ?? CONVERSATION_TTL_MS;
-	const filePath = resolveMSTeamsStorePath({
+function resolveLegacyStorePath(params) {
+	return resolveMSTeamsStorePath({
 		filename: STORE_FILENAME$2,
 		env: params?.env,
 		homedir: params?.homedir,
 		stateDir: params?.stateDir,
 		storePath: params?.storePath
 	});
-	const empty = {
+}
+function normalizeLegacyStore(value) {
+	if (value.version !== 1 || !value.conversations || typeof value.conversations !== "object" || Array.isArray(value.conversations)) return {
 		version: 1,
 		conversations: {}
 	};
-	const readStore = async () => {
-		const { value } = await readJsonFile(filePath, empty);
-		if (value.version !== 1 || !value.conversations || typeof value.conversations !== "object" || Array.isArray(value.conversations)) return empty;
-		const nowMs = Date.now();
-		const pruned = pruneExpired$2(value.conversations, nowMs, ttlMs).conversations;
-		return {
+	return value;
+}
+function buildConversationStateKey(conversationId) {
+	return crypto.createHash("sha256").update(conversationId).digest("hex");
+}
+function prepareConversationReferenceForStorage(conversationId, reference) {
+	return {
+		...reference,
+		conversation: {
+			...reference.conversation,
+			id: conversationId
+		}
+	};
+}
+function getStoredConversationId(reference) {
+	const rawId = reference.conversation?.id;
+	return rawId ? normalizeStoredConversationId(rawId) : null;
+}
+function createMSTeamsConversationStoreState(params) {
+	const ttlMs = params?.ttlMs ?? CONVERSATION_TTL_MS;
+	const conversationStore = createConversationStateStore(params);
+	const migrationStore = createConversationMigrationStore(params);
+	const legacyStorePath = resolveLegacyStorePath(params);
+	let legacyImportPromise = null;
+	const isExpired = (reference) => {
+		const lastSeenAt = parseStoredConversationTimestamp(reference.lastSeenAt);
+		return lastSeenAt != null && Date.now() - lastSeenAt > ttlMs;
+	};
+	const selectRetainedConversations = (conversations) => {
+		const retained = Object.entries(conversations).filter(([, reference]) => !isExpired(reference));
+		if (retained.length <= MAX_CONVERSATIONS) return retained;
+		retained.sort((a, b) => {
+			return (parseStoredConversationTimestamp(a[1].lastSeenAt) ?? 0) - (parseStoredConversationTimestamp(b[1].lastSeenAt) ?? 0) || a[0].localeCompare(b[0]);
+		});
+		return retained.slice(retained.length - MAX_CONVERSATIONS);
+	};
+	const importLegacyStore = async () => {
+		if (await migrationStore.lookup(LEGACY_JSON_MIGRATION_KEY)) return;
+		const { value, exists } = await readJsonFile(legacyStorePath, {
 			version: 1,
-			conversations: pruneToLimit$2(pruned)
-		};
+			conversations: {}
+		});
+		if (!exists) {
+			await migrationStore.register(LEGACY_JSON_MIGRATION_KEY, { importedAt: (/* @__PURE__ */ new Date()).toISOString() });
+			return;
+		}
+		const legacy = normalizeLegacyStore(value);
+		for (const [rawConversationId, reference] of selectRetainedConversations(legacy.conversations)) {
+			const conversationId = normalizeStoredConversationId(rawConversationId);
+			if (!conversationId) continue;
+			await conversationStore.registerIfAbsent(buildConversationStateKey(conversationId), toPluginJsonValue(prepareConversationReferenceForStorage(conversationId, reference)));
+		}
+		await migrationStore.register(LEGACY_JSON_MIGRATION_KEY, { importedAt: (/* @__PURE__ */ new Date()).toISOString() });
+		await fs.rm(legacyStorePath, { force: true }).catch(() => {});
+	};
+	const ensureLegacyImported = async () => {
+		legacyImportPromise ??= withMSTeamsSqliteMutationLock(params, CONVERSATION_LOCK_FILENAME, importLegacyStore);
+		await legacyImportPromise;
+	};
+	const lookupStored = async (conversationId) => {
+		const normalizedId = normalizeStoredConversationId(conversationId);
+		const value = await conversationStore.lookup(buildConversationStateKey(normalizedId));
+		if (!value) return null;
+		if (isExpired(value)) return null;
+		return value;
+	};
+	const entries = async () => {
+		await ensureLegacyImported();
+		const rows = await conversationStore.entries();
+		const kept = [];
+		for (const row of rows) {
+			if (isExpired(row.value)) continue;
+			const conversationId = getStoredConversationId(row.value);
+			if (conversationId) kept.push([conversationId, row.value]);
+		}
+		return kept;
+	};
+	const lookup = async (conversationId) => {
+		await ensureLegacyImported();
+		return await lookupStored(conversationId);
+	};
+	const register = async (conversationId, reference) => {
+		const normalizedId = normalizeStoredConversationId(conversationId);
+		await conversationStore.register(buildConversationStateKey(normalizedId), toPluginJsonValue(prepareConversationReferenceForStorage(normalizedId, reference)));
+		const rows = [];
+		for (const row of await conversationStore.entries()) {
+			if (isExpired(row.value)) {
+				await conversationStore.delete(row.key);
+				continue;
+			}
+			rows.push(row);
+		}
+		if (rows.length <= MAX_CONVERSATIONS) return;
+		const sorted = rows.toSorted((a, b) => {
+			const aTs = parseStoredConversationTimestamp(a.value.lastSeenAt) ?? 0;
+			const bTs = parseStoredConversationTimestamp(b.value.lastSeenAt) ?? 0;
+			const aId = getStoredConversationId(a.value) ?? a.key;
+			const bId = getStoredConversationId(b.value) ?? b.key;
+			return aTs - bTs || aId.localeCompare(bId);
+		});
+		for (const row of sorted.slice(0, rows.length - MAX_CONVERSATIONS)) await conversationStore.delete(row.key);
 	};
 	const list = async () => {
-		const store = await readStore();
-		return toConversationStoreEntries(Object.entries(store.conversations));
+		return toConversationStoreEntries(await entries());
 	};
 	const get = async (conversationId) => {
-		return (await readStore()).conversations[normalizeStoredConversationId(conversationId)] ?? null;
+		return await lookup(conversationId);
 	};
 	const findPreferredDmByUserId = async (id) => {
 		return findPreferredDmConversationByUserId(await list(), id);
 	};
 	const upsert = async (conversationId, reference) => {
 		const normalizedId = normalizeStoredConversationId(conversationId);
-		await withFileLock$1(filePath, empty, async () => {
-			const store = await readStore();
-			store.conversations[normalizedId] = mergeStoredConversationReference(store.conversations[normalizedId], reference, (/* @__PURE__ */ new Date()).toISOString());
-			const nowMs = Date.now();
-			store.conversations = pruneExpired$2(store.conversations, nowMs, ttlMs).conversations;
-			store.conversations = pruneToLimit$2(store.conversations);
-			await writeJsonFile(filePath, store);
+		await withMSTeamsSqliteMutationLock(params, CONVERSATION_LOCK_FILENAME, async () => {
+			await importLegacyStore();
+			await register(normalizedId, mergeStoredConversationReference(await lookupStored(normalizedId) ?? void 0, reference, (/* @__PURE__ */ new Date()).toISOString()));
 		});
 	};
 	const remove = async (conversationId) => {
 		const normalizedId = normalizeStoredConversationId(conversationId);
-		return await withFileLock$1(filePath, empty, async () => {
-			const store = await readStore();
-			if (!(normalizedId in store.conversations)) return false;
-			delete store.conversations[normalizedId];
-			await writeJsonFile(filePath, store);
-			return true;
+		return await withMSTeamsSqliteMutationLock(params, CONVERSATION_LOCK_FILENAME, async () => {
+			await importLegacyStore();
+			return await conversationStore.delete(buildConversationStateKey(normalizedId));
 		});
 	};
 	return {
@@ -183,8 +310,16 @@ function createMSTeamsConversationStoreFs(params) {
 //#endregion
 //#region extensions/msteams/src/polls.ts
 const STORE_FILENAME$1 = "msteams-polls.json";
+const POLLS_NAMESPACE = "polls";
+const POLL_VOTE_BUCKETS_NAMESPACE = "poll-vote-buckets";
+const POLL_MIGRATIONS_NAMESPACE = "poll-migrations";
+const LEGACY_POLLS_MIGRATION_KEY = "msteams-polls-json-v1";
 const MAX_POLLS = 1e3;
+const SQLITE_MAX_POLL_ROWS = 2e3;
+const POLL_VOTE_BUCKET_COUNT = 32;
+const MAX_POLL_VOTE_BUCKET_ROWS = 1001 * POLL_VOTE_BUCKET_COUNT;
 const POLL_TTL_MS = 720 * 60 * 60 * 1e3;
+const POLL_LOCK_FILENAME = "msteams-polls.sqlite.lock";
 function normalizeChoiceValue(value) {
 	if (typeof value === "string") {
 		const trimmed = value.trim();
@@ -302,6 +437,27 @@ function buildMSTeamsPollCard(params) {
 		fallbackText: fallbackLines.join("\n")
 	};
 }
+function createPollStateStore(params) {
+	return getMSTeamsRuntime().state.openKeyedStore({
+		namespace: POLLS_NAMESPACE,
+		maxEntries: SQLITE_MAX_POLL_ROWS,
+		env: resolveMSTeamsSqliteStateEnv(params)
+	});
+}
+function createPollVoteBucketStateStore(params) {
+	return getMSTeamsRuntime().state.openKeyedStore({
+		namespace: POLL_VOTE_BUCKETS_NAMESPACE,
+		maxEntries: MAX_POLL_VOTE_BUCKET_ROWS,
+		env: resolveMSTeamsSqliteStateEnv(params)
+	});
+}
+function createPollMigrationStore(params) {
+	return getMSTeamsRuntime().state.openKeyedStore({
+		namespace: POLL_MIGRATIONS_NAMESPACE,
+		maxEntries: 100,
+		env: resolveMSTeamsSqliteStateEnv(params)
+	});
+}
 function parseTimestamp(value) {
 	if (!value) return null;
 	const parsed = Date.parse(value);
@@ -314,69 +470,181 @@ function pruneExpired$1(polls) {
 	});
 	return Object.fromEntries(entries);
 }
-function pruneToLimit$1(polls) {
-	const entries = Object.entries(polls);
-	if (entries.length <= MAX_POLLS) return polls;
-	entries.sort((a, b) => {
-		return (parseTimestamp(a[1].updatedAt ?? a[1].createdAt) ?? 0) - (parseTimestamp(b[1].updatedAt ?? b[1].createdAt) ?? 0);
+function selectRetainedPolls(polls) {
+	const retained = Object.entries(pruneExpired$1(polls));
+	if (retained.length <= MAX_POLLS) return retained;
+	retained.sort((a, b) => {
+		return (parseTimestamp(a[1].updatedAt ?? a[1].createdAt) ?? 0) - (parseTimestamp(b[1].updatedAt ?? b[1].createdAt) ?? 0) || a[0].localeCompare(b[0]);
 	});
-	const keep = entries.slice(entries.length - MAX_POLLS);
-	return Object.fromEntries(keep);
+	return retained.slice(retained.length - MAX_POLLS);
 }
 function normalizeMSTeamsPollSelections(poll, selections) {
 	const maxSelections = Math.max(1, poll.maxSelections);
 	const mapped = selections.map((entry) => parseStrictNonNegativeInteger(entry)).filter((value) => value !== void 0).filter((value) => value >= 0 && value < poll.options.length).map((value) => String(value));
 	return uniqueStrings(maxSelections > 1 ? mapped.slice(0, maxSelections) : mapped.slice(0, 1));
 }
-function createMSTeamsPollStoreFs(params) {
-	const filePath = resolveMSTeamsStorePath({
+function createMSTeamsPollStoreState(params) {
+	const pollStore = createPollStateStore(params);
+	const voteBucketStore = createPollVoteBucketStateStore(params);
+	const migrationStore = createPollMigrationStore(params);
+	const legacyStorePath = resolveMSTeamsStorePath({
 		filename: STORE_FILENAME$1,
 		env: params?.env,
 		homedir: params?.homedir,
 		stateDir: params?.stateDir,
 		storePath: params?.storePath
 	});
-	const empty = {
-		version: 1,
-		polls: {}
+	let legacyImportPromise = null;
+	const splitPoll = (poll) => {
+		const { votes, ...metadata } = poll;
+		return {
+			metadata,
+			votes
+		};
+	};
+	const hashVote = (pollId, voterId) => {
+		return crypto.createHash("sha256").update(pollId).update("\0").update(voterId).digest("hex");
+	};
+	const buildPollStateKey = (pollId) => {
+		return crypto.createHash("sha256").update(pollId).digest("hex");
+	};
+	const selectVoteBucket = (pollId, voterId) => {
+		const bucket = Number.parseInt(hashVote(pollId, voterId).slice(0, 8), 16);
+		return String(bucket % POLL_VOTE_BUCKET_COUNT).padStart(4, "0");
+	};
+	const buildVoteBucketKey = (pollId, bucket) => {
+		return `${crypto.createHash("sha256").update(pollId).digest("hex")}:${bucket}`;
 	};
-	const readStore = async () => {
-		const { value } = await readJsonFile(filePath, empty);
+	const readPollVotes = async (pollId) => {
+		const votes = {};
+		for (const row of await voteBucketStore.entries()) if (row.value.pollId === pollId) Object.assign(votes, row.value.votes);
+		return votes;
+	};
+	const deletePollVotes = async (pollId) => {
+		for (const row of await voteBucketStore.entries()) if (row.value.pollId === pollId) await voteBucketStore.delete(row.key);
+	};
+	const registerPollVotes = async (pollId, votes, updatedAt) => {
+		const buckets = /* @__PURE__ */ new Map();
+		for (const [voterId, selections] of Object.entries(votes)) {
+			const bucket = selectVoteBucket(pollId, voterId);
+			const bucketVotes = buckets.get(bucket) ?? {};
+			bucketVotes[voterId] = selections;
+			buckets.set(bucket, bucketVotes);
+		}
+		for (const [bucket, bucketVotes] of buckets) {
+			const key = buildVoteBucketKey(pollId, bucket);
+			const existing = await voteBucketStore.lookup(key);
+			await voteBucketStore.register(key, toPluginJsonValue({
+				pollId,
+				bucket,
+				votes: {
+					...bucketVotes,
+					...existing?.votes
+				},
+				updatedAt
+			}));
+		}
+	};
+	const registerPollVote = async (pollId, voterId, selections, updatedAt) => {
+		const bucket = selectVoteBucket(pollId, voterId);
+		const key = buildVoteBucketKey(pollId, bucket);
+		const existing = await voteBucketStore.lookup(key);
+		await voteBucketStore.register(key, toPluginJsonValue({
+			pollId,
+			bucket,
+			votes: {
+				...existing?.votes,
+				[voterId]: selections
+			},
+			updatedAt
+		}));
+	};
+	const reconstructPoll = async (metadata) => {
 		return {
-			version: 1,
-			polls: pruneToLimit$1(pruneExpired$1(value.polls ?? {}))
+			...metadata,
+			votes: await readPollVotes(metadata.id)
 		};
 	};
-	const writeStore = async (data) => {
-		await writeJsonFile(filePath, data);
+	const importLegacyStore = async () => {
+		if (await migrationStore.lookup(LEGACY_POLLS_MIGRATION_KEY)) return;
+		const { value, exists } = await readJsonFile(legacyStorePath, {
+			version: 1,
+			polls: {}
+		});
+		if (!exists) {
+			await migrationStore.register(LEGACY_POLLS_MIGRATION_KEY, { importedAt: (/* @__PURE__ */ new Date()).toISOString() });
+			return;
+		}
+		const legacyPolls = value.version === 1 && value.polls && typeof value.polls === "object" && !Array.isArray(value.polls) ? value.polls : {};
+		for (const [pollId, poll] of selectRetainedPolls(legacyPolls)) {
+			if (!pollId) continue;
+			const { metadata, votes } = splitPoll(poll);
+			await pollStore.registerIfAbsent(buildPollStateKey(pollId), toPluginJsonValue(metadata));
+			await registerPollVotes(pollId, votes, poll.updatedAt ?? poll.createdAt);
+		}
+		await migrationStore.register(LEGACY_POLLS_MIGRATION_KEY, { importedAt: (/* @__PURE__ */ new Date()).toISOString() });
+		await fs.rm(legacyStorePath, { force: true }).catch(() => {});
+	};
+	const ensureLegacyImported = async () => {
+		legacyImportPromise ??= withMSTeamsSqliteMutationLock(params, POLL_LOCK_FILENAME, importLegacyStore);
+		await legacyImportPromise;
+	};
+	const prunePollStoreToLimit = async () => {
+		const rows = [];
+		for (const row of await pollStore.entries()) {
+			if (!pruneExpired$1({ [row.key]: row.value })[row.key]) {
+				await pollStore.delete(row.key);
+				await deletePollVotes(row.value.id);
+				continue;
+			}
+			rows.push(row);
+		}
+		if (rows.length <= MAX_POLLS) return;
+		const sorted = rows.toSorted((a, b) => {
+			return (parseTimestamp(a.value.updatedAt ?? a.value.createdAt) ?? 0) - (parseTimestamp(b.value.updatedAt ?? b.value.createdAt) ?? 0) || a.key.localeCompare(b.key);
+		});
+		for (const row of sorted.slice(0, rows.length - MAX_POLLS)) {
+			await pollStore.delete(row.key);
+			await deletePollVotes(row.value.id);
+		}
 	};
 	const createPoll = async (poll) => {
-		await withFileLock$1(filePath, empty, async () => {
-			const data = await readStore();
-			data.polls[poll.id] = poll;
-			await writeStore({
-				version: 1,
-				polls: pruneToLimit$1(data.polls)
-			});
+		await withMSTeamsSqliteMutationLock(params, POLL_LOCK_FILENAME, async () => {
+			await importLegacyStore();
+			const { metadata, votes } = splitPoll(poll);
+			await pollStore.register(buildPollStateKey(poll.id), toPluginJsonValue(metadata));
+			await deletePollVotes(poll.id);
+			await registerPollVotes(poll.id, votes, poll.updatedAt ?? poll.createdAt);
+			await prunePollStoreToLimit();
 		});
 	};
-	const getPoll = async (pollId) => await withFileLock$1(filePath, empty, async () => {
-		return (await readStore()).polls[pollId] ?? null;
-	});
-	const recordVote = async (params) => await withFileLock$1(filePath, empty, async () => {
-		const data = await readStore();
-		const poll = data.polls[params.pollId];
+	const getPoll = async (pollId) => {
+		await ensureLegacyImported();
+		const poll = await pollStore.lookup(buildPollStateKey(pollId));
 		if (!poll) return null;
-		const normalized = normalizeMSTeamsPollSelections(poll, params.selections);
-		poll.votes[params.voterId] = normalized;
-		poll.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-		data.polls[poll.id] = poll;
-		await writeStore({
-			version: 1,
-			polls: pruneToLimit$1(data.polls)
+		if (!pruneExpired$1({ [pollId]: poll })[pollId]) return null;
+		return await reconstructPoll(poll);
+	};
+	const recordVote = async (vote) => {
+		return await withMSTeamsSqliteMutationLock(params, POLL_LOCK_FILENAME, async () => {
+			await importLegacyStore();
+			const pollKey = buildPollStateKey(vote.pollId);
+			const poll = await pollStore.lookup(pollKey);
+			if (!poll) return null;
+			if (!pruneExpired$1({ [vote.pollId]: poll })[vote.pollId]) {
+				await pollStore.delete(pollKey);
+				await deletePollVotes(vote.pollId);
+				return null;
+			}
+			const normalized = normalizeMSTeamsPollSelections(await reconstructPoll(poll), vote.selections);
+			const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+			poll.updatedAt = updatedAt;
+			await pollStore.register(pollKey, toPluginJsonValue(poll));
+			await registerPollVote(vote.pollId, vote.voterId, normalized, updatedAt);
+			await prunePollStoreToLimit();
+			return await reconstructPoll(poll);
 		});
-		return poll;
-	});
+	};
 	return {
 		createPoll,
 		getPoll,
@@ -519,31 +787,24 @@ async function uploadToConsentUrl(params) {
 }
 //#endregion
 //#region extensions/msteams/src/pending-uploads-fs.ts
-/**
-* Filesystem-backed pending upload store for the FileConsentCard flow.
-*
-* The CLI `message send --media` path runs in a different process from the
-* gateway's bot monitor that receives the `fileConsent/invoke` callback.
-* An in-memory `pending-uploads.ts` store cannot bridge those processes, so
-* when the user clicks "Allow" the monitor handler's lookup misses and the
-* user sees "card action not supported".
-*
-* This FS store persists pending uploads to a JSON file (with the file buffer
-* base64-encoded) so any process that shares the OpenClaw state dir can read
-* them back. The in-memory store in `pending-uploads.ts` is still the fast
-* path for same-process flows (for example the messenger reply path); this FS
-* store is a cross-process fallback.
-*/
 /** TTL for persisted pending uploads (matches in-memory store). */
 const PENDING_UPLOAD_TTL_MS$1 = 300 * 1e3;
 /** Cap to avoid unbounded growth if a process crashes mid-flow. */
 const MAX_PENDING_UPLOADS = 100;
+const MAX_CHUNKS_PER_UPLOAD = 3072;
+const MAX_PENDING_UPLOAD_CHUNK_ROWS = 45e3;
+const RAW_CHUNK_BYTES = 36 * 1024;
+const PENDING_UPLOAD_META_MAX_ENTRIES = 200;
 const STORE_FILENAME = "msteams-pending-uploads.json";
+const PENDING_UPLOAD_META_NAMESPACE = "pending-uploads";
+const PENDING_UPLOAD_CHUNKS_NAMESPACE = "pending-upload-chunks";
+const PENDING_UPLOAD_MIGRATIONS_NAMESPACE = "pending-upload-migrations";
+const PENDING_UPLOAD_LOCK_FILENAME = "msteams-pending-uploads.sqlite.lock";
 const empty = {
 	version: 1,
 	uploads: {}
 };
-function resolveFilePath(options) {
+function resolveLegacyFilePath(options) {
 	return resolveMSTeamsStorePath({
 		filename: STORE_FILENAME,
 		env: options?.env,
@@ -552,6 +813,42 @@ function resolveFilePath(options) {
 		storePath: options?.storePath
 	});
 }
+function createMetaStore(options) {
+	return getMSTeamsRuntime().state.openKeyedStore({
+		namespace: PENDING_UPLOAD_META_NAMESPACE,
+		maxEntries: PENDING_UPLOAD_META_MAX_ENTRIES,
+		env: resolveMSTeamsSqliteStateEnv(options)
+	});
+}
+function createChunkStore(options) {
+	return getMSTeamsRuntime().state.openKeyedStore({
+		namespace: PENDING_UPLOAD_CHUNKS_NAMESPACE,
+		maxEntries: MAX_PENDING_UPLOAD_CHUNK_ROWS,
+		env: resolveMSTeamsSqliteStateEnv(options)
+	});
+}
+function createMigrationStore(options) {
+	return getMSTeamsRuntime().state.openKeyedStore({
+		namespace: PENDING_UPLOAD_MIGRATIONS_NAMESPACE,
+		maxEntries: 100,
+		env: resolveMSTeamsSqliteStateEnv(options)
+	});
+}
+function buildUploadKey(id) {
+	return `upload:${createHash("sha256").update(id).digest("hex")}`;
+}
+function buildMetaKey(id) {
+	return `${buildUploadKey(id)}:meta`;
+}
+function buildChunkKey(id, index) {
+	return `${buildUploadKey(id)}:chunk:${String(index).padStart(4, "0")}`;
+}
+function buildMigrationKey(filePath) {
+	return `legacy-json:${createHash("sha256").update(filePath).digest("hex")}`;
+}
+function buildMigrationContentKey(filePath, value) {
+	return `legacy-json-content:${createHash("sha256").update(filePath).update("\0").update(JSON.stringify(value) ?? "undefined").digest("hex")}`;
+}
 function pruneExpired(uploads, nowMs, ttlMs) {
 	const kept = {};
 	for (const [id, record] of Object.entries(uploads)) if (nowMs - record.createdAt <= ttlMs) kept[id] = record;
@@ -564,10 +861,10 @@ function pruneToLimit(uploads) {
 	const keep = entries.slice(entries.length - MAX_PENDING_UPLOADS);
 	return Object.fromEntries(keep);
 }
-function recordToUpload(record) {
+function recordToUpload(record, buffer) {
 	return {
 		id: record.id,
-		buffer: Buffer.from(record.bufferBase64, "base64"),
+		buffer,
 		filename: record.filename,
 		contentType: record.contentType,
 		conversationId: record.conversationId,
@@ -580,17 +877,119 @@ function isValidStore(value) {
 	const candidate = value;
 	return candidate.version === 1 && typeof candidate.uploads === "object" && candidate.uploads !== null && !Array.isArray(candidate.uploads);
 }
-async function readStore(filePath, ttlMs) {
-	const { value } = await readJsonFile(filePath, empty);
-	if (!isValidStore(value)) return {
-		version: 1,
-		uploads: {}
-	};
+function normalizeLegacyUploadRecord(value) {
+	if (!value || typeof value !== "object") return null;
+	const record = value;
+	if (typeof record.id !== "string" || !record.id || typeof record.bufferBase64 !== "string" || typeof record.filename !== "string" || !record.filename || typeof record.conversationId !== "string" || !record.conversationId || typeof record.createdAt !== "number" || !Number.isFinite(record.createdAt)) return null;
 	return {
-		version: 1,
-		uploads: pruneToLimit(pruneExpired(value.uploads, Date.now(), ttlMs))
+		id: record.id,
+		bufferBase64: record.bufferBase64,
+		filename: record.filename,
+		contentType: typeof record.contentType === "string" ? record.contentType : void 0,
+		conversationId: record.conversationId,
+		consentCardActivityId: typeof record.consentCardActivityId === "string" ? record.consentCardActivityId : void 0,
+		createdAt: record.createdAt
 	};
 }
+function normalizeLegacyUploads(value) {
+	if (!isValidStore(value)) return {};
+	const uploads = {};
+	for (const record of Object.values(value.uploads)) {
+		const normalized = normalizeLegacyUploadRecord(record);
+		if (normalized) uploads[normalized.id] = normalized;
+	}
+	return uploads;
+}
+async function deleteUploadRows(id, metaStore, chunkStore) {
+	const existing = await metaStore.lookup(buildMetaKey(id));
+	await metaStore.delete(buildMetaKey(id));
+	if (!existing) return;
+	const chunkCount = existing.chunkCount;
+	for (let index = 0; index < chunkCount; index += 1) await chunkStore.delete(buildChunkKey(id, index));
+}
+async function registerUploadRows(record, metaStore, chunkStore, ttlMs, overwrite) {
+	const buffer = Buffer.from(record.bufferBase64, "base64");
+	const chunkCount = Math.max(1, Math.ceil(buffer.byteLength / RAW_CHUNK_BYTES));
+	if (chunkCount > MAX_CHUNKS_PER_UPLOAD) throw new Error(`Microsoft Teams pending upload ${record.id} exceeds SQLite chunk limit (${chunkCount}/${MAX_CHUNKS_PER_UPLOAD})`);
+	if (overwrite) await deleteUploadRows(record.id, metaStore, chunkStore);
+	else if (await metaStore.lookup(buildMetaKey(record.id))) return;
+	await pruneUploadStore(metaStore, chunkStore, ttlMs, chunkCount);
+	for (let index = 0; index < chunkCount; index += 1) {
+		const chunk = buffer.subarray(index * RAW_CHUNK_BYTES, (index + 1) * RAW_CHUNK_BYTES);
+		await chunkStore.register(buildChunkKey(record.id, index), toPluginJsonValue({
+			id: record.id,
+			index,
+			dataBase64: chunk.toString("base64")
+		}));
+	}
+	await metaStore.register(buildMetaKey(record.id), toPluginJsonValue({
+		id: record.id,
+		filename: record.filename,
+		contentType: record.contentType,
+		conversationId: record.conversationId,
+		consentCardActivityId: record.consentCardActivityId,
+		createdAt: record.createdAt,
+		chunkCount,
+		byteLength: buffer.byteLength
+	}));
+}
+async function importLegacyStore(options, metaStore, chunkStore, ttlMs) {
+	const legacyFilePath = resolveLegacyFilePath(options);
+	const migrationStore = createMigrationStore(options);
+	const migrationKey = buildMigrationKey(legacyFilePath);
+	const imported = await migrationStore.lookup(migrationKey) !== void 0;
+	const { value, exists } = await readJsonFile(legacyFilePath, empty);
+	if (!exists) {
+		if (!imported) await migrationStore.register(migrationKey, { importedAt: (/* @__PURE__ */ new Date()).toISOString() });
+		return;
+	}
+	const contentKey = buildMigrationContentKey(legacyFilePath, value);
+	if (await migrationStore.lookup(contentKey)) return;
+	const legacy = pruneToLimit(pruneExpired(normalizeLegacyUploads(value), Date.now(), ttlMs));
+	for (const record of Object.values(legacy)) await registerUploadRows(record, metaStore, chunkStore, ttlMs, false);
+	await migrationStore.register(contentKey, { importedAt: (/* @__PURE__ */ new Date()).toISOString() });
+	if (!imported) await migrationStore.register(migrationKey, { importedAt: (/* @__PURE__ */ new Date()).toISOString() });
+	await fs.rm(legacyFilePath, { force: true }).catch(() => {});
+}
+async function withPendingUploadLock(options, run) {
+	return await withMSTeamsSqliteMutationLock(options, PENDING_UPLOAD_LOCK_FILENAME, run);
+}
+async function ensureLegacyImported(options, metaStore, chunkStore, ttlMs) {
+	await withPendingUploadLock(options, () => importLegacyStore(options, metaStore, chunkStore, ttlMs));
+}
+async function readUploadRows(id, metaStore, chunkStore) {
+	const meta = await metaStore.lookup(buildMetaKey(id));
+	if (!meta) return;
+	const chunks = [];
+	for (let index = 0; index < meta.chunkCount; index += 1) {
+		const chunk = await chunkStore.lookup(buildChunkKey(id, index));
+		if (!chunk || chunk.id !== id || chunk.index !== index) return;
+		chunks.push(Buffer.from(chunk.dataBase64, "base64"));
+	}
+	return recordToUpload(meta, Buffer.concat(chunks, meta.byteLength));
+}
+async function pruneUploadStore(metaStore, chunkStore, ttlMs, extraChunkRows = 0) {
+	const rows = await metaStore.entries();
+	const liveRows = [];
+	const now = Date.now();
+	let liveChunkRows = 0;
+	for (const row of rows) {
+		if (now - row.value.createdAt > ttlMs) {
+			await deleteUploadRows(row.value.id, metaStore, chunkStore);
+			continue;
+		}
+		liveChunkRows += row.value.chunkCount;
+		liveRows.push(row);
+	}
+	if (liveRows.length <= MAX_PENDING_UPLOADS && liveChunkRows + extraChunkRows <= MAX_PENDING_UPLOAD_CHUNK_ROWS) return;
+	const sorted = liveRows.toSorted((a, b) => a.value.createdAt - b.value.createdAt || a.value.id.localeCompare(b.value.id));
+	for (const row of sorted) {
+		if (liveRows.length <= MAX_PENDING_UPLOADS && liveChunkRows + extraChunkRows <= MAX_PENDING_UPLOAD_CHUNK_ROWS) break;
+		await deleteUploadRows(row.value.id, metaStore, chunkStore);
+		liveChunkRows -= row.value.chunkCount;
+		liveRows.pop();
+	}
+}
 /**
 * Persist a pending upload record so another process can read it back.
 * Pass in the pre-generated id (same as the one placed in the consent card
@@ -598,10 +997,11 @@ async function readStore(filePath, ttlMs) {
 */
 async function storePendingUploadFs(upload, options) {
 	const ttlMs = options?.ttlMs ?? PENDING_UPLOAD_TTL_MS$1;
-	const filePath = resolveFilePath(options);
-	await withFileLock$1(filePath, empty, async () => {
-		const store = await readStore(filePath, ttlMs);
-		store.uploads[upload.id] = {
+	const metaStore = createMetaStore(options);
+	const chunkStore = createChunkStore(options);
+	await withPendingUploadLock(options, async () => {
+		await importLegacyStore(options, metaStore, chunkStore, ttlMs);
+		await registerUploadRows({
 			id: upload.id,
 			bufferBase64: upload.buffer.toString("base64"),
 			filename: upload.filename,
@@ -609,9 +1009,8 @@ async function storePendingUploadFs(upload, options) {
 			conversationId: upload.conversationId,
 			consentCardActivityId: upload.consentCardActivityId,
 			createdAt: Date.now()
-		};
-		store.uploads = pruneToLimit(pruneExpired(store.uploads, Date.now(), ttlMs));
-		await writeJsonFile(filePath, store);
+		}, metaStore, chunkStore, ttlMs, true);
+		await pruneUploadStore(metaStore, chunkStore, ttlMs);
 	});
 }
 /**
@@ -620,10 +1019,16 @@ async function storePendingUploadFs(upload, options) {
 async function getPendingUploadFs(id, options) {
 	if (!id) return;
 	const ttlMs = options?.ttlMs ?? PENDING_UPLOAD_TTL_MS$1;
-	const record = (await readStore(resolveFilePath(options), ttlMs)).uploads[id];
-	if (!record) return;
-	if (Date.now() - record.createdAt > ttlMs) return;
-	return recordToUpload(record);
+	const metaStore = createMetaStore(options);
+	const chunkStore = createChunkStore(options);
+	await ensureLegacyImported(options, metaStore, chunkStore, ttlMs);
+	const upload = await readUploadRows(id, metaStore, chunkStore);
+	if (!upload) return;
+	if (Date.now() - upload.createdAt > ttlMs) {
+		await removePendingUploadFs(id, options);
+		return;
+	}
+	return upload;
 }
 /**
 * Remove a persisted pending upload (after successful upload or decline).
@@ -632,12 +1037,11 @@ async function getPendingUploadFs(id, options) {
 async function removePendingUploadFs(id, options) {
 	if (!id) return;
 	const ttlMs = options?.ttlMs ?? PENDING_UPLOAD_TTL_MS$1;
-	const filePath = resolveFilePath(options);
-	await withFileLock$1(filePath, empty, async () => {
-		const store = await readStore(filePath, ttlMs);
-		if (!(id in store.uploads)) return;
-		delete store.uploads[id];
-		await writeJsonFile(filePath, store);
+	const metaStore = createMetaStore(options);
+	const chunkStore = createChunkStore(options);
+	await withPendingUploadLock(options, async () => {
+		await importLegacyStore(options, metaStore, chunkStore, ttlMs);
+		await deleteUploadRows(id, metaStore, chunkStore);
 	});
 }
 /**
@@ -646,13 +1050,16 @@ async function removePendingUploadFs(id, options) {
 */
 async function setPendingUploadActivityIdFs(id, activityId, options) {
 	const ttlMs = options?.ttlMs ?? PENDING_UPLOAD_TTL_MS$1;
-	const filePath = resolveFilePath(options);
-	await withFileLock$1(filePath, empty, async () => {
-		const store = await readStore(filePath, ttlMs);
-		const record = store.uploads[id];
-		if (!record) return;
-		record.consentCardActivityId = activityId;
-		await writeJsonFile(filePath, store);
+	const metaStore = createMetaStore(options);
+	const chunkStore = createChunkStore(options);
+	await withPendingUploadLock(options, async () => {
+		await importLegacyStore(options, metaStore, chunkStore, ttlMs);
+		const record = await metaStore.lookup(buildMetaKey(id));
+		if (!record || Date.now() - record.createdAt > ttlMs) return;
+		await metaStore.register(buildMetaKey(id), toPluginJsonValue({
+			...record,
+			consentCardActivityId: activityId
+		}));
 	});
 }
 //#endregion
@@ -1693,7 +2100,7 @@ async function resolveMSTeamsSendContext(params) {
 	if (!msteamsCfg?.enabled) throw new Error("msteams provider is not enabled");
 	const creds = resolveMSTeamsCredentials(msteamsCfg);
 	if (!creds) throw new Error("msteams credentials not configured");
-	const store = createMSTeamsConversationStoreFs();
+	const store = createMSTeamsConversationStoreState();
 	const recipient = parseRecipient(params.to);
 	const found = await findConversationReference({
 		...recipient,
@@ -2268,7 +2675,7 @@ async function probeMSTeams(cfg) {
 		if (cfg?.delegatedAuth?.enabled) try {
 			const tokens = loadDelegatedTokens();
 			if (tokens) {
-				const isExpired = tokens.expiresAt <= Date.now();
+				const isExpired = !isFutureDateTimestampMs(tokens.expiresAt);
 				delegatedAuth = {
 					ok: !isExpired,
 					scopes: tokens.scopes,
@@ -2300,4 +2707,4 @@ async function probeMSTeams(cfg) {
 	}
 }
 //#endregion
-export { readJsonFile as C, createMSTeamsConversationStoreFs as S, writeJsonFile as T, buildFileInfoCard as _, sendMessageMSTeams as a, createMSTeamsPollStoreFs as b, renderReplyPayloadsToMessages as c, withRevokedProxyFallback as d, resolveGraphChatId as f, removePendingUploadFs as g, getPendingUploadFs as h, sendAdaptiveCardMSTeams as i, sendMSTeamsMessages as l, removePendingUpload as m, deleteMessageMSTeams as n, sendPollMSTeams as o, getPendingUpload as p, editMessageMSTeams as r, buildConversationReference as s, probeMSTeams as t, sendMSTeamsActivityWithReference as u, parseFileConsentInvoke as v, withFileLock$1 as w, extractMSTeamsPollVote as x, uploadToConsentUrl as y };
+export { resolveMSTeamsSqliteStateEnv as C, readJsonFile as E, createMSTeamsConversationStoreState as S, withMSTeamsSqliteMutationLock as T, buildFileInfoCard as _, sendMessageMSTeams as a, createMSTeamsPollStoreState as b, renderReplyPayloadsToMessages as c, withRevokedProxyFallback as d, resolveGraphChatId as f, removePendingUploadFs as g, getPendingUploadFs as h, sendAdaptiveCardMSTeams as i, sendMSTeamsMessages as l, removePendingUpload as m, deleteMessageMSTeams as n, sendPollMSTeams as o, getPendingUpload as p, editMessageMSTeams as r, buildConversationReference as s, probeMSTeams as t, sendMSTeamsActivityWithReference as u, parseFileConsentInvoke as v, toPluginJsonValue as w, extractMSTeamsPollVote as x, uploadToConsentUrl as y };