@openclaw/google-meet 2026.7.2-beta.5 → 2026.8.1-beta.2

package/dist/{chrome-create-DMKruRFW.js → plugin-helpers-CfeT1SYY.js}

@@ -1,9 +1,174 @@
+import { c as loadGoogleMeetCliModule, p as resolveMeetingInput } from "./plugin-registration-rSOssQmm.js";
 import { t as googleApiError } from "./google-api-errors-CDUYkIcK.js";
-import { uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { t as normalizeMeetUrl } from "./meet-url-BP2Jlvjs.js";
+import { normalizeOptionalString, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
+import { parseDateStringTimestampMs } from "openclaw/plugin-sdk/number-runtime";
+import { readPositiveIntegerParam } from "openclaw/plugin-sdk/channel-actions";
 import { readProviderJsonResponse, readProviderTextResponse } from "openclaw/plugin-sdk/provider-http";
 import { fetchWithSsrFGuard } from "openclaw/plugin-sdk/ssrf-runtime";
-import { asMeetingBrowserTabs, callMeetingBrowserProxyOnNode, readMeetingBrowserTab, resolveMeetingBrowserNode, resolveMeetingBrowserNodeInfo } from "openclaw/plugin-sdk/meeting-runtime";
-import { sleep } from "openclaw/plugin-sdk/runtime-env";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region extensions/google-meet/src/calendar.ts
+const GOOGLE_CALENDAR_API_BASE_URL = "https://www.googleapis.com/calendar/v3";
+const GOOGLE_CALENDAR_API_HOST = "www.googleapis.com";
+const GOOGLE_CALENDAR_EVENTS_SCOPE = "https://www.googleapis.com/auth/calendar.events.readonly";
+const GOOGLE_CALENDAR_REQUEST_TIMEOUT_MS = 3e4;
+function appendQuery$2(url, query) {
+	const parsed = new URL(url);
+	for (const [key, value] of Object.entries(query)) if (value !== void 0) parsed.searchParams.set(key, String(value));
+	return parsed.toString();
+}
+function normalizeGoogleMeetCalendarUri(value) {
+	if (!value?.trim()) return;
+	try {
+		const url = new URL(value);
+		if (url.protocol !== "http:" && url.protocol !== "https:") return;
+		if (url.hostname.toLowerCase() !== "meet.google.com" || url.port || url.username || url.password) return;
+		url.protocol = "https:";
+		return normalizeMeetUrl(url.toString());
+	} catch {
+		return;
+	}
+}
+function extractGoogleMeetUriFromText(value) {
+	const matches = value?.matchAll(/https:\/\/meet\.google\.com\/[a-z0-9-]+/gi);
+	for (const match of matches ?? []) {
+		const uri = normalizeGoogleMeetCalendarUri(match[0]);
+		if (uri) return uri;
+	}
+}
+function findFirstGoogleMeetCalendarUri(entryPoints, predicate = () => true) {
+	for (const entry of entryPoints) {
+		if (!predicate(entry)) continue;
+		const uri = normalizeGoogleMeetCalendarUri(entry.uri);
+		if (uri) return uri;
+	}
+}
+function extractGoogleMeetUriFromCalendarEvent(event) {
+	const hangoutLink = normalizeGoogleMeetCalendarUri(event.hangoutLink);
+	if (hangoutLink) return hangoutLink;
+	const entryPoints = event.conferenceData?.entryPoints ?? [];
+	const videoEntryUri = findFirstGoogleMeetCalendarUri(entryPoints, (entry) => entry.entryPointType === "video");
+	if (videoEntryUri) return videoEntryUri;
+	const meetEntryUri = findFirstGoogleMeetCalendarUri(entryPoints);
+	if (meetEntryUri) return meetEntryUri;
+	return extractGoogleMeetUriFromText(event.location) ?? extractGoogleMeetUriFromText(event.description);
+}
+function buildGoogleMeetCalendarDayWindow(now = /* @__PURE__ */ new Date()) {
+	const start = new Date(now);
+	start.setHours(0, 0, 0, 0);
+	const end = new Date(start);
+	end.setDate(start.getDate() + 1);
+	return {
+		timeMin: start.toISOString(),
+		timeMax: end.toISOString()
+	};
+}
+function parseCalendarEventTime(value) {
+	const raw = value?.dateTime ?? value?.date;
+	if (!raw) return;
+	const parsed = Date.parse(raw);
+	return Number.isFinite(parsed) ? parsed : void 0;
+}
+function rankCalendarEvent(event, nowMs) {
+	const startMs = parseCalendarEventTime(event.start) ?? Number.POSITIVE_INFINITY;
+	const endMs = parseCalendarEventTime(event.end) ?? startMs;
+	if (startMs <= nowMs && endMs >= nowMs) return 0;
+	if (startMs > nowMs) return startMs - nowMs;
+	return nowMs - startMs + 720 * 60 * 60 * 1e3;
+}
+function chooseBestMeetCalendarEvent(events, now) {
+	const nowMs = now.getTime();
+	let selected;
+	let selectedRank = Number.POSITIVE_INFINITY;
+	for (const event of events) {
+		if (event.status === "cancelled" || !extractGoogleMeetUriFromCalendarEvent(event)) continue;
+		const rank = rankCalendarEvent(event, nowMs);
+		if (!selected || rank < selectedRank) {
+			selected = event;
+			selectedRank = rank;
+		}
+	}
+	return selected;
+}
+async function fetchGoogleCalendarEvents(params) {
+	const calendarId = params.calendarId?.trim() || "primary";
+	const now = params.now ?? /* @__PURE__ */ new Date();
+	const defaultTimeMax = new Date(now);
+	defaultTimeMax.setDate(defaultTimeMax.getDate() + 7);
+	const { response, release } = await fetchWithSsrFGuard({
+		url: appendQuery$2(`${GOOGLE_CALENDAR_API_BASE_URL}/calendars/${encodeURIComponent(calendarId)}/events`, {
+			maxResults: params.maxResults ?? 50,
+			orderBy: "startTime",
+			q: params.eventQuery?.trim() || void 0,
+			showDeleted: false,
+			singleEvents: true,
+			timeMin: params.timeMin ?? now.toISOString(),
+			timeMax: params.timeMax ?? defaultTimeMax.toISOString()
+		}),
+		init: { headers: {
+			Authorization: `Bearer ${params.accessToken}`,
+			Accept: "application/json"
+		} },
+		policy: { allowedHostnames: [GOOGLE_CALENDAR_API_HOST] },
+		auditContext: "google-meet.calendar.events.list",
+		timeoutMs: GOOGLE_CALENDAR_REQUEST_TIMEOUT_MS
+	});
+	try {
+		if (!response.ok) throw await googleApiError({
+			response,
+			prefix: "Google Calendar events.list",
+			scopes: [GOOGLE_CALENDAR_EVENTS_SCOPE]
+		});
+		const payload = await readProviderJsonResponse(response, "Google Calendar events.list");
+		if (payload.items !== void 0 && !Array.isArray(payload.items)) throw new Error("Google Calendar events.list response had non-array items");
+		return {
+			calendarId,
+			events: payload.items ?? [],
+			now
+		};
+	} finally {
+		await release();
+	}
+}
+async function listGoogleMeetCalendarEvents(params) {
+	const { calendarId, events, now } = await fetchGoogleCalendarEvents(params);
+	const best = chooseBestMeetCalendarEvent(events, now);
+	return {
+		calendarId,
+		events: events.map((event) => {
+			const meetingUri = extractGoogleMeetUriFromCalendarEvent(event);
+			return meetingUri ? {
+				event,
+				meetingUri,
+				selected: event === best
+			} : void 0;
+		}).filter((event) => Boolean(event))
+	};
+}
+async function findGoogleMeetCalendarEvent(params) {
+	const result = await listGoogleMeetCalendarEvents(params);
+	const selected = result.events.find((event) => event.selected) ?? result.events[0];
+	if (!selected) throw new Error("No Google Calendar event with a Google Meet link matched the query");
+	return {
+		calendarId: result.calendarId,
+		event: selected.event,
+		meetingUri: selected.meetingUri
+	};
+}
+//#endregion
 //#region extensions/google-meet/src/drive.ts
 const GOOGLE_DRIVE_API_BASE_URL = "https://www.googleapis.com/drive/v3";
 const GOOGLE_DRIVE_API_HOST = "www.googleapis.com";
@@ -101,9 +266,6 @@ function assertResourceArray(value, key, context) {
 	for (const resource of resources) if (!resource.name?.trim()) throw new Error(`Google Meet ${context} response included a resource without name`);
 	return resources;
 }
-function getErrorMessage(error) {
-	return error instanceof Error ? error.message : String(error);
-}
 async function requestGoogleMeetApi(params) {
 	return await fetchWithSsrFGuard({
 		url: appendQuery(`${GOOGLE_MEET_API_BASE_URL}/${params.path}`, params.query),
@@ -394,52 +556,47 @@ async function attachDocumentText(params) {
 	} catch (error) {
 		return {
 			...params.resource,
-			documentTextError: getErrorMessage(error)
+			documentTextError: formatErrorMessage(error)
 		};
 	}
 }
-function parseGoogleMeetTimestamp(value) {
-	if (!value?.trim()) return;
-	const parsed = Date.parse(value);
-	return Number.isFinite(parsed) ? parsed : void 0;
-}
 function isoFromMs(value) {
 	return typeof value === "number" && Number.isFinite(value) ? new Date(value).toISOString() : void 0;
 }
 function minTimestamp(values) {
-	const parsed = values.map(parseGoogleMeetTimestamp).filter((value) => typeof value === "number");
+	const parsed = values.map(parseDateStringTimestampMs).filter((value) => typeof value === "number");
 	return parsed.length > 0 ? isoFromMs(Math.min(...parsed)) : void 0;
 }
 function maxTimestamp(values) {
-	const parsed = values.map(parseGoogleMeetTimestamp).filter((value) => typeof value === "number");
+	const parsed = values.map(parseDateStringTimestampMs).filter((value) => typeof value === "number");
 	return parsed.length > 0 ? isoFromMs(Math.max(...parsed)) : void 0;
 }
 function sumSessionDurationMs(sessions, fallbackStart, fallbackEnd) {
 	const sessionTotal = sessions.reduce((total, session) => {
-		const startMs = parseGoogleMeetTimestamp(session.startTime);
-		const endMs = parseGoogleMeetTimestamp(session.endTime);
+		const startMs = parseDateStringTimestampMs(session.startTime);
+		const endMs = parseDateStringTimestampMs(session.endTime);
 		return startMs !== void 0 && endMs !== void 0 && endMs > startMs ? total + (endMs - startMs) : total;
 	}, 0);
 	if (sessionTotal > 0) return sessionTotal;
-	const startMs = parseGoogleMeetTimestamp(fallbackStart);
-	const endMs = parseGoogleMeetTimestamp(fallbackEnd);
+	const startMs = parseDateStringTimestampMs(fallbackStart);
+	const endMs = parseDateStringTimestampMs(fallbackEnd);
 	return startMs !== void 0 && endMs !== void 0 && endMs > startMs ? endMs - startMs : void 0;
 }
 function attendanceMergeKey(row) {
 	return (row.user ?? row.displayName ?? row.participant).trim().toLocaleLowerCase();
 }
 function sortSessions(sessions) {
-	return sessions.toSorted((left, right) => (parseGoogleMeetTimestamp(left.startTime) ?? 0) - (parseGoogleMeetTimestamp(right.startTime) ?? 0));
+	return sessions.toSorted((left, right) => (parseDateStringTimestampMs(left.startTime) ?? 0) - (parseDateStringTimestampMs(right.startTime) ?? 0));
 }
 function decorateAttendanceRow(row, conferenceRecord, params) {
 	const sessions = sortSessions(row.sessions);
 	const firstJoinTime = minTimestamp([row.earliestStartTime, ...sessions.map((session) => session.startTime)]);
 	const lastLeaveTime = maxTimestamp([row.latestEndTime, ...sessions.map((session) => session.endTime)]);
 	const durationMs = sumSessionDurationMs(sessions, firstJoinTime, lastLeaveTime);
-	const conferenceStartMs = parseGoogleMeetTimestamp(conferenceRecord.startTime);
-	const conferenceEndMs = parseGoogleMeetTimestamp(conferenceRecord.endTime);
-	const firstJoinMs = parseGoogleMeetTimestamp(firstJoinTime);
-	const lastLeaveMs = parseGoogleMeetTimestamp(lastLeaveTime);
+	const conferenceStartMs = parseDateStringTimestampMs(conferenceRecord.startTime);
+	const conferenceEndMs = parseDateStringTimestampMs(conferenceRecord.endTime);
+	const firstJoinMs = parseDateStringTimestampMs(firstJoinTime);
+	const lastLeaveMs = parseDateStringTimestampMs(lastLeaveTime);
 	const lateGraceMs = (params.lateAfterMinutes ?? 5) * 6e4;
 	const earlyGraceMs = (params.earlyBeforeMinutes ?? 5) * 6e4;
 	const lateByMs = conferenceStartMs !== void 0 && firstJoinMs !== void 0 ? Math.max(firstJoinMs - conferenceStartMs, 0) : void 0;
@@ -511,7 +668,7 @@ async function fetchGoogleMeetArtifacts(params) {
 				pageSize: params.pageSize
 			}).then((smartNotes) => ({ smartNotes })).catch((error) => ({
 				smartNotes: [],
-				smartNotesError: getErrorMessage(error)
+				smartNotesError: formatErrorMessage(error)
 			}))
 		]);
 		const transcriptEntries = params.includeTranscriptEntries === false ? [] : await Promise.all(transcripts.map(async (transcript) => {
@@ -528,7 +685,7 @@ async function fetchGoogleMeetArtifacts(params) {
 				return {
 					transcript: transcript.name,
 					entries: [],
-					entriesError: getErrorMessage(error)
+					entriesError: formatErrorMessage(error)
 				};
 			}
 		}));
@@ -599,347 +756,170 @@ function buildGoogleMeetPreflightReport(params) {
 	};
 }
 //#endregion
-//#region extensions/google-meet/src/transports/google-meet-platform-constants.ts
-const GOOGLE_MEET_NODE_COMMAND = "googlemeet.chrome";
-const GOOGLE_MEET_BROWSER_NODE_ADAPTER = {
-	displayName: "Google Meet",
-	nodeCommandName: GOOGLE_MEET_NODE_COMMAND,
-	nodeConfigPath: "plugins.entries.google-meet.config.chromeNode.node"
-};
-//#endregion
-//#region extensions/google-meet/src/transports/chrome-browser-proxy.ts
-async function resolveChromeNodeInfo(params) {
-	return await resolveMeetingBrowserNodeInfo({
-		...params,
-		adapter: GOOGLE_MEET_BROWSER_NODE_ADAPTER
+//#region extensions/google-meet/src/plugin-helpers.ts
+var plugin_helpers_exports = /* @__PURE__ */ __exportAll({
+	buildGoogleMeetCalendarDayWindow: () => buildGoogleMeetCalendarDayWindow,
+	buildGoogleMeetPreflightReport: () => buildGoogleMeetPreflightReport,
+	createAndJoinMeetFromParams: () => createAndJoinMeetFromParams,
+	createMeetFromParams: () => createMeetFromParams,
+	endGoogleMeetActiveConference: () => endGoogleMeetActiveConference,
+	exportGoogleMeetBundleFromParams: () => exportGoogleMeetBundleFromParams,
+	fetchLatestGoogleMeetConferenceRecord: () => fetchLatestGoogleMeetConferenceRecord,
+	fetchResolvedGoogleMeetArtifacts: () => fetchResolvedGoogleMeetArtifacts,
+	fetchResolvedGoogleMeetAttendance: () => fetchResolvedGoogleMeetAttendance,
+	listGoogleMeetCalendarEvents: () => listGoogleMeetCalendarEvents,
+	resolveArtifactQueryFromParams: () => resolveArtifactQueryFromParams,
+	resolveGoogleMeetTokenFromParams: () => resolveGoogleMeetTokenFromParams,
+	resolveMeetingFromParams: () => resolveMeetingFromParams,
+	resolveSpaceFromParams: () => resolveSpaceFromParams
+});
+const loadGoogleMeetCreateModule = createLazyRuntimeModule(() => import("./create-UHeaRzsH.js").then((n) => n.t));
+async function createMeetFromParams(params) {
+	return (await loadGoogleMeetCreateModule()).createMeetFromParams(params);
+}
+async function createAndJoinMeetFromParams(params) {
+	return (await loadGoogleMeetCreateModule()).createAndJoinMeetFromParams(params);
+}
+async function resolveGoogleMeetTokenFromParams(config, raw) {
+	const { resolveGoogleMeetAccessToken } = await import("./oauth-9sUJ68Mw.js");
+	return resolveGoogleMeetAccessToken({
+		clientId: normalizeOptionalString(raw.clientId) ?? config.oauth.clientId,
+		clientSecret: normalizeOptionalString(raw.clientSecret) ?? config.oauth.clientSecret,
+		refreshToken: normalizeOptionalString(raw.refreshToken) ?? config.oauth.refreshToken,
+		accessToken: normalizeOptionalString(raw.accessToken) ?? config.oauth.accessToken,
+		expiresAt: typeof raw.expiresAt === "number" ? raw.expiresAt : config.oauth.expiresAt
 	});
 }
-async function resolveChromeNode(params) {
-	return await resolveMeetingBrowserNode({
-		...params,
-		adapter: GOOGLE_MEET_BROWSER_NODE_ADAPTER
-	});
+function wantsCalendarLookup(raw) {
+	return raw.today === true || Boolean(normalizeOptionalString(raw.event));
 }
-async function callBrowserProxyOnNode(params) {
-	return await callMeetingBrowserProxyOnNode({
-		...params,
-		adapter: GOOGLE_MEET_BROWSER_NODE_ADAPTER
-	});
-}
-const asBrowserTabs = asMeetingBrowserTabs;
-const readBrowserTab = readMeetingBrowserTab;
-//#endregion
-//#region extensions/google-meet/src/transports/google-meet-urls.ts
-function forceMeetEnglishUi(url) {
-	try {
-		const parsed = new URL(url);
-		parsed.searchParams.set("hl", "en");
-		return parsed.toString();
-	} catch {
-		return url;
-	}
-}
-function normalizeMeetUrlForReuse(url) {
-	if (!url) return;
-	try {
-		const parsed = new URL(url);
-		if (parsed.protocol !== "https:" || parsed.hostname.toLowerCase() !== "meet.google.com") return;
-		const match = parsed.pathname.match(/^\/([a-z]{3}-[a-z]{4}-[a-z]{3})(?:\/)?$/i);
-		if (!match?.[1]) return;
-		return `https://meet.google.com/${match[1].toLowerCase()}`;
-	} catch {
-		return;
-	}
-}
-function isSameMeetUrlForReuse(a, b) {
-	const normalizedA = normalizeMeetUrlForReuse(a);
-	const normalizedB = normalizeMeetUrlForReuse(b);
-	return Boolean(normalizedA && normalizedB && normalizedA === normalizedB);
-}
-function isEnglishMeetTab(url) {
-	if (!url) return false;
-	try {
-		const parsed = new URL(url);
-		return parsed.protocol === "https:" && parsed.hostname.toLowerCase() === "meet.google.com" && parsed.searchParams.get("hl")?.toLowerCase() === "en";
-	} catch {
-		return false;
-	}
-}
-function readMeetAuthUser(url) {
-	if (!url) return;
-	try {
-		return new URL(url).searchParams.get("authuser") ?? void 0;
-	} catch {
-		return;
-	}
-}
-function isRecoverableMeetTab(tab, url) {
-	if (url) return isSameMeetUrlForReuse(tab.url, url);
-	if (normalizeMeetUrlForReuse(tab.url)) return true;
-	return (tab.url ?? "").startsWith("https://accounts.google.com/") && /sign in|google accounts|meet/i.test(tab.title ?? "");
-}
-//#endregion
-//#region extensions/google-meet/src/transports/chrome-create.ts
-const GOOGLE_MEET_NEW_URL = "https://meet.google.com/new";
-const GOOGLE_MEET_BROWSER_CREATE_TIMEOUT_MS = 6e4;
-const GOOGLE_MEET_BROWSER_STEP_TIMEOUT_MS = 1e4;
-const GOOGLE_MEET_BROWSER_NAVIGATION_RETRY_MS = 1e3;
-const GOOGLE_MEET_BROWSER_POLL_MS = 500;
-var GoogleMeetBrowserManualActionError = class extends Error {
-	constructor(payload) {
-		super(`${payload.manualAction.reason}: ${payload.manualAction.message}`);
-		this.name = "GoogleMeetBrowserManualActionError";
-		this.payload = {
-			source: "browser",
-			error: this.message,
-			...payload
+async function resolveMeetingFromParams(params) {
+	if (wantsCalendarLookup(params.raw)) {
+		const window = params.raw.today === true ? buildGoogleMeetCalendarDayWindow() : {};
+		const calendarEvent = await findGoogleMeetCalendarEvent({
+			accessToken: params.accessToken,
+			calendarId: normalizeOptionalString(params.raw.calendarId),
+			eventQuery: normalizeOptionalString(params.raw.event),
+			...window
+		});
+		return {
+			meeting: calendarEvent.meetingUri,
+			calendarEvent
 		};
 	}
-};
-function isGoogleMeetBrowserManualActionError(error) {
-	return error instanceof GoogleMeetBrowserManualActionError;
-}
-function formatBrowserAutomationError(error) {
-	if (error instanceof Error) return error.message;
-	try {
-		return JSON.stringify(error);
-	} catch {
-		return "unknown error";
-	}
-}
-function isBrowserNavigationInterruption(error) {
-	return /execution context was destroyed|navigation|target closed/i.test(formatBrowserAutomationError(error));
-}
-function isGoogleMeetCreateTab(tab) {
-	const url = tab.url ?? "";
-	if (/^https:\/\/meet\.google\.com\/(?:new|[a-z]{3}-[a-z]{4}-[a-z]{3})(?:$|[/?#])/i.test(url)) return true;
-	return url.startsWith("https://accounts.google.com/") && /sign in|google accounts|meet/i.test(tab.title ?? "");
-}
-async function findGoogleMeetCreateTab(params) {
-	return asBrowserTabs(await callBrowserProxyOnNode({
-		runtime: params.runtime,
-		nodeId: params.nodeId,
-		method: "GET",
-		path: "/tabs",
-		timeoutMs: params.timeoutMs
-	})).find(isGoogleMeetCreateTab);
-}
-async function focusBrowserTab(params) {
-	await callBrowserProxyOnNode({
-		runtime: params.runtime,
-		nodeId: params.nodeId,
-		method: "POST",
-		path: "/tabs/focus",
-		body: { targetId: params.targetId },
-		timeoutMs: params.timeoutMs
+	return { meeting: resolveMeetingInput(params.config, params.raw.meeting) };
+}
+async function resolveSpaceFromParams(config, raw) {
+	const token = await resolveGoogleMeetTokenFromParams(config, raw);
+	const { meeting, calendarEvent } = await resolveMeetingFromParams({
+		config,
+		raw,
+		accessToken: token.accessToken
 	});
+	return {
+		meeting,
+		token,
+		space: await fetchGoogleMeetSpace({
+			accessToken: token.accessToken,
+			meeting
+		}),
+		calendarEvent
+	};
 }
-function readStringArray(value) {
-	return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : void 0;
-}
-function readBrowserManualAction(value) {
-	if (!value || typeof value !== "object") return;
-	const action = value;
-	return typeof action.reason === "string" && typeof action.message === "string" ? {
-		reason: action.reason,
-		message: action.message
-	} : void 0;
-}
-function readBrowserCreateResult(result) {
-	const record = result && typeof result === "object" ? result : {};
-	const nested = record.result && typeof record.result === "object" ? record.result : record;
+async function resolveArtifactQueryFromParams(config, raw) {
+	const meeting = normalizeOptionalString(raw.meeting) ?? config.defaults.meeting;
+	const conferenceRecord = normalizeOptionalString(raw.conferenceRecord);
+	const token = await resolveGoogleMeetTokenFromParams(config, raw);
+	const resolvedMeeting = conferenceRecord ? { meeting } : wantsCalendarLookup(raw) ? await resolveMeetingFromParams({
+		config,
+		raw,
+		accessToken: token.accessToken
+	}) : { meeting };
+	if (!resolvedMeeting.meeting && !conferenceRecord) throw new Error("Meeting input, calendar lookup, or conferenceRecord required");
 	return {
-		meetingUri: typeof nested.meetingUri === "string" ? nested.meetingUri : void 0,
-		browserUrl: typeof nested.browserUrl === "string" ? nested.browserUrl : void 0,
-		browserTitle: typeof nested.browserTitle === "string" ? nested.browserTitle : void 0,
-		manualAction: readBrowserManualAction(nested.manualAction),
-		notes: readStringArray(nested.notes),
-		retryAfterMs: typeof nested.retryAfterMs === "number" && Number.isFinite(nested.retryAfterMs) ? nested.retryAfterMs : void 0
+		token,
+		meeting: resolvedMeeting.meeting,
+		calendarEvent: resolvedMeeting.calendarEvent,
+		conferenceRecord,
+		pageSize: readPositiveIntegerParam(raw, "pageSize"),
+		includeTranscriptEntries: raw.includeTranscriptEntries !== false,
+		includeDocumentBodies: raw.includeDocumentBodies === true,
+		allConferenceRecords: raw.includeAllConferenceRecords === true,
+		mergeDuplicateParticipants: raw.mergeDuplicateParticipants !== false,
+		lateAfterMinutes: readPositiveIntegerParam(raw, "lateAfterMinutes"),
+		earlyBeforeMinutes: readPositiveIntegerParam(raw, "earlyBeforeMinutes")
 	};
 }
-const CREATE_MEET_FROM_BROWSER_SCRIPT = `async () => {
-  const meetUrlPattern = /^https:\\/\\/meet\\.google\\.com\\/[a-z]{3}-[a-z]{4}-[a-z]{3}(?:$|[/?#])/i;
-  const text = (node) => (node?.innerText || node?.textContent || "").trim();
-  const current = () => location.href;
-  const manualActionFor = (reason, message) => ({ reason, message });
-  const notes = [];
-  const findButton = (pattern) =>
-    [...document.querySelectorAll("button")].find((button) => {
-      const label = [
-        button.getAttribute("aria-label"),
-        button.getAttribute("data-tooltip"),
-        text(button),
-      ]
-        .filter(Boolean)
-        .join(" ");
-      return pattern.test(label) && !button.disabled;
-    });
-  const clickButton = (pattern, note) => {
-    const button = findButton(pattern);
-    if (!button) {
-      return false;
-    }
-    button.click();
-    notes.push(note);
-    return true;
-  };
-  if (!current().startsWith("https://meet.google.com/")) {
-    return {
-      manualAction: manualActionFor("google-login-required", "Sign in to Google in the OpenClaw browser profile, then retry meeting creation."),
-      browserUrl: current(),
-      browserTitle: document.title,
-      notes,
-    };
-  }
-  const href = current();
-  if (meetUrlPattern.test(href)) {
-    // The /new redirect keeps the hl=en param we open with; strip query/hash so the
-    // meeting link handed to users stays canonical instead of forcing English on them.
-    return { meetingUri: href.split(/[?#]/)[0], browserUrl: href, browserTitle: document.title, notes };
-  }
-  const pageText = text(document.body);
-  if (clickButton(/\\buse microphone\\b/i, "Accepted Meet microphone prompt with browser automation.")) {
-    return { browserUrl: href, browserTitle: document.title, notes, retryAfterMs: 1000 };
-  }
-  if (
-    clickButton(
-      /continue without microphone/i,
-      "Continued through Meet microphone prompt with browser automation.",
-    )
-  ) {
-    return { browserUrl: href, browserTitle: document.title, notes, retryAfterMs: 1000 };
-  }
-  if (/do you want people to hear you in the meeting/i.test(pageText)) {
-    return {
-      manualAction: manualActionFor("meet-audio-choice-required", "Meet is showing the microphone choice. Click Use microphone in the OpenClaw browser profile, then retry meeting creation."),
-      browserUrl: href,
-      browserTitle: document.title,
-      notes,
-    };
-  }
-  if (/allow.*(microphone|camera)|blocked.*(microphone|camera)|permission.*(microphone|camera)/i.test(pageText)) {
-    return {
-      manualAction: manualActionFor("meet-permission-required", "Allow microphone/camera permissions for Meet in the OpenClaw browser profile, then retry meeting creation."),
-      browserUrl: href,
-      browserTitle: document.title,
-      notes,
-    };
-  }
-  if (/couldn't create|unable to create/i.test(pageText)) {
-    return {
-      manualAction: manualActionFor("browser-control-unavailable", "Resolve the Google Meet page prompt in the OpenClaw browser profile, then retry meeting creation."),
-      browserUrl: href,
-      browserTitle: document.title,
-      notes,
-    };
-  }
-  if (location.hostname.toLowerCase() === "accounts.google.com" || /use your google account|to continue to google meet|choose an account|sign in to (join|continue)/i.test(pageText)) {
-    return {
-      manualAction: manualActionFor("google-login-required", "Sign in to Google in the OpenClaw browser profile, then retry meeting creation."),
-      browserUrl: href,
-      browserTitle: document.title,
-      notes,
-    };
-  }
-  return {
-    retryAfterMs: 500,
-    browserUrl: current(),
-    browserTitle: document.title,
-    notes,
-  };
-}`;
-async function createMeetWithBrowserProxyOnNode(params) {
-	const nodeId = await resolveChromeNode({
-		runtime: params.runtime,
-		requestedNode: params.config.chromeNode.node
+function fetchResolvedGoogleMeetArtifacts(query) {
+	return fetchGoogleMeetArtifacts({
+		accessToken: query.token.accessToken,
+		meeting: query.meeting,
+		conferenceRecord: query.conferenceRecord,
+		pageSize: query.pageSize,
+		includeTranscriptEntries: query.includeTranscriptEntries,
+		includeDocumentBodies: query.includeDocumentBodies,
+		allConferenceRecords: query.allConferenceRecords
 	});
-	const timeoutMs = Math.max(GOOGLE_MEET_BROWSER_CREATE_TIMEOUT_MS, params.config.chrome.joinTimeoutMs);
-	const stepTimeoutMs = Math.min(timeoutMs, GOOGLE_MEET_BROWSER_STEP_TIMEOUT_MS);
-	let openedByPlugin = false;
-	let tab = await findGoogleMeetCreateTab({
-		runtime: params.runtime,
-		nodeId,
-		timeoutMs: stepTimeoutMs
+}
+function fetchResolvedGoogleMeetAttendance(query) {
+	return fetchGoogleMeetAttendance({
+		accessToken: query.token.accessToken,
+		meeting: query.meeting,
+		conferenceRecord: query.conferenceRecord,
+		pageSize: query.pageSize,
+		allConferenceRecords: query.allConferenceRecords,
+		mergeDuplicateParticipants: query.mergeDuplicateParticipants,
+		lateAfterMinutes: query.lateAfterMinutes,
+		earlyBeforeMinutes: query.earlyBeforeMinutes
 	});
-	if (tab?.targetId) {
-		await focusBrowserTab({
-			runtime: params.runtime,
-			nodeId,
-			targetId: tab.targetId,
-			timeoutMs: stepTimeoutMs
-		});
-		const reusedUrl = tab.url ?? "";
-		const englishUrl = (/^https:\/\/meet\.google\.com\/new(?:$|[/?#])/i.test(reusedUrl) || reusedUrl.startsWith("https://accounts.google.com/")) && reusedUrl ? forceMeetEnglishUi(reusedUrl) : void 0;
-		if (englishUrl && englishUrl !== reusedUrl) tab = readBrowserTab(await callBrowserProxyOnNode({
-			runtime: params.runtime,
-			nodeId,
-			method: "POST",
-			path: "/navigate",
-			body: {
-				targetId: tab.targetId,
-				url: englishUrl
-			},
-			timeoutMs: stepTimeoutMs
-		})) ?? tab;
-	} else {
-		tab = readBrowserTab(await callBrowserProxyOnNode({
-			runtime: params.runtime,
-			nodeId,
-			method: "POST",
-			path: "/tabs/open",
-			body: { url: forceMeetEnglishUi(GOOGLE_MEET_NEW_URL) },
-			timeoutMs: stepTimeoutMs
-		}));
-		openedByPlugin = Boolean(tab?.targetId);
-	}
-	const targetId = tab?.targetId;
-	if (!targetId) throw new Error("Browser fallback opened Google Meet but did not return a targetId.");
-	const notes = /* @__PURE__ */ new Set();
-	let lastResult;
-	let lastError;
-	const deadline = Date.now() + timeoutMs;
-	while (Date.now() <= deadline) try {
-		const result = readBrowserCreateResult(await callBrowserProxyOnNode({
-			runtime: params.runtime,
-			nodeId,
-			method: "POST",
-			path: "/act",
-			body: {
-				kind: "evaluate",
-				targetId,
-				fn: CREATE_MEET_FROM_BROWSER_SCRIPT
-			},
-			timeoutMs: stepTimeoutMs
-		}));
-		lastResult = result;
-		for (const note of result.notes ?? []) notes.add(note);
-		if (result.meetingUri) return {
-			source: "browser",
-			nodeId,
-			targetId,
-			openedByPlugin,
-			meetingUri: result.meetingUri,
-			browserUrl: result.browserUrl,
-			browserTitle: result.browserTitle,
-			notes: [...notes]
-		};
-		if (result.manualAction) throw new GoogleMeetBrowserManualActionError({
-			manualAction: result.manualAction,
-			browser: {
-				nodeId,
-				targetId,
-				browserUrl: result.browserUrl,
-				browserTitle: result.browserTitle,
-				notes: [...notes]
-			}
-		});
-		await sleep(result.retryAfterMs ?? GOOGLE_MEET_BROWSER_POLL_MS);
-	} catch (error) {
-		lastError = error;
-		if (!isBrowserNavigationInterruption(error)) throw error;
-		await sleep(GOOGLE_MEET_BROWSER_NAVIGATION_RETRY_MS);
-	}
-	throw new Error(lastResult?.manualAction?.message ?? `Google Meet did not return a meeting URL from the browser create flow before timeout.${lastError ? ` Last browser automation error: ${formatBrowserAutomationError(lastError)}` : ""}`);
+}
+async function exportGoogleMeetBundleFromParams(config, raw) {
+	const resolved = await resolveArtifactQueryFromParams(config, raw);
+	const [artifacts, attendance] = await Promise.all([fetchResolvedGoogleMeetArtifacts(resolved), fetchResolvedGoogleMeetAttendance(resolved)]);
+	const { buildGoogleMeetExportManifest, googleMeetExportFileNames, writeMeetExportBundle } = await loadGoogleMeetCliModule();
+	const calendarId = normalizeOptionalString(raw.calendarId);
+	const request = {
+		...resolved.meeting ? { meeting: resolved.meeting } : {},
+		...resolved.conferenceRecord ? { conferenceRecord: resolved.conferenceRecord } : {},
+		...resolved.calendarEvent?.event.id ? { calendarEventId: resolved.calendarEvent.event.id } : {},
+		...resolved.calendarEvent?.event.summary ? { calendarEventSummary: resolved.calendarEvent.event.summary } : {},
+		...calendarId ? { calendarId } : {},
+		...resolved.pageSize !== void 0 ? { pageSize: resolved.pageSize } : {},
+		includeTranscriptEntries: resolved.includeTranscriptEntries,
+		includeDocumentBodies: resolved.includeDocumentBodies,
+		allConferenceRecords: resolved.allConferenceRecords,
+		mergeDuplicateParticipants: resolved.mergeDuplicateParticipants,
+		...resolved.lateAfterMinutes !== void 0 ? { lateAfterMinutes: resolved.lateAfterMinutes } : {},
+		...resolved.earlyBeforeMinutes !== void 0 ? { earlyBeforeMinutes: resolved.earlyBeforeMinutes } : {}
+	};
+	const tokenSource = resolved.token.refreshed ? "refresh-token" : "cached-access-token";
+	if (raw.dryRun === true) return {
+		dryRun: true,
+		manifest: buildGoogleMeetExportManifest({
+			artifacts,
+			attendance,
+			files: googleMeetExportFileNames(),
+			request,
+			tokenSource,
+			...resolved.calendarEvent ? { calendarEvent: resolved.calendarEvent } : {}
+		}),
+		...resolved.calendarEvent ? { calendarEvent: resolved.calendarEvent } : {},
+		tokenSource
+	};
+	const outputDir = normalizeOptionalString(raw.outputDir) ?? normalizeOptionalString(raw.output);
+	return {
+		...await writeMeetExportBundle({
+			...outputDir ? { outputDir } : {},
+			artifacts,
+			attendance,
+			zip: raw.zip === true,
+			request,
+			tokenSource,
+			...resolved.calendarEvent ? { calendarEvent: resolved.calendarEvent } : {}
+		}),
+		...resolved.calendarEvent ? { calendarEvent: resolved.calendarEvent } : {},
+		tokenSource
+	};
 }
 //#endregion
-export { endGoogleMeetActiveConference as _, isRecoverableMeetTab as a, readMeetAuthUser as c, resolveChromeNodeInfo as d, GOOGLE_MEET_NODE_COMMAND as f, createGoogleMeetSpace as g, fetchGoogleMeetAttendance as h, isEnglishMeetTab as i, callBrowserProxyOnNode as l, fetchGoogleMeetArtifacts as m, isGoogleMeetBrowserManualActionError as n, isSameMeetUrlForReuse as o, buildGoogleMeetPreflightReport as p, forceMeetEnglishUi as r, normalizeMeetUrlForReuse as s, createMeetWithBrowserProxyOnNode as t, resolveChromeNode as u, fetchGoogleMeetSpace as v, fetchLatestGoogleMeetConferenceRecord as y };
+export { resolveGoogleMeetTokenFromParams as a, buildGoogleMeetPreflightReport as c, fetchGoogleMeetSpace as d, fetchLatestGoogleMeetConferenceRecord as f, __exportAll as h, resolveArtifactQueryFromParams as i, createGoogleMeetSpace as l, listGoogleMeetCalendarEvents as m, fetchResolvedGoogleMeetAttendance as n, resolveMeetingFromParams as o, buildGoogleMeetCalendarDayWindow as p, plugin_helpers_exports as r, resolveSpaceFromParams as s, fetchResolvedGoogleMeetArtifacts as t, endGoogleMeetActiveConference as u };