@kodelyth/google-meet 2026.5.39 → 2026.5.42

package/dist/oauth-7_sWAae1.js

@@ -0,0 +1,141 @@
+import { fetchWithSsrFGuard } from "klaw/plugin-sdk/ssrf-runtime";
+import { generateHexPkceVerifierChallenge } from "klaw/plugin-sdk/provider-auth";
+import { generateOAuthState, parseOAuthCallbackInput, waitForLocalOAuthCallback } from "klaw/plugin-sdk/provider-auth-runtime";
+//#region extensions/google-meet/src/oauth.ts
+const GOOGLE_MEET_REDIRECT_URI = "http://localhost:8085/oauth2callback";
+const GOOGLE_MEET_AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth";
+const GOOGLE_MEET_TOKEN_URL = "https://oauth2.googleapis.com/token";
+const GOOGLE_MEET_TOKEN_HOST = "oauth2.googleapis.com";
+const GOOGLE_MEET_SCOPES = [
+	"https://www.googleapis.com/auth/meetings.space.created",
+	"https://www.googleapis.com/auth/meetings.space.readonly",
+	"https://www.googleapis.com/auth/meetings.space.settings",
+	"https://www.googleapis.com/auth/meetings.conference.media.readonly",
+	"https://www.googleapis.com/auth/calendar.events.readonly",
+	"https://www.googleapis.com/auth/drive.meet.readonly"
+];
+function buildGoogleMeetAuthUrl(params) {
+	return `${GOOGLE_MEET_AUTH_URL}?${new URLSearchParams({
+		client_id: params.clientId,
+		response_type: "code",
+		redirect_uri: params.redirectUri ?? GOOGLE_MEET_REDIRECT_URI,
+		scope: (params.scopes ?? GOOGLE_MEET_SCOPES).join(" "),
+		code_challenge: params.challenge,
+		code_challenge_method: "S256",
+		access_type: "offline",
+		prompt: "consent",
+		state: params.state
+	}).toString()}`;
+}
+async function executeGoogleTokenRequest(body) {
+	const { response, release } = await fetchWithSsrFGuard({
+		url: GOOGLE_MEET_TOKEN_URL,
+		init: {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
+				Accept: "application/json"
+			},
+			body
+		},
+		policy: { allowedHostnames: [GOOGLE_MEET_TOKEN_HOST] },
+		auditContext: "google-meet.oauth.token"
+	});
+	try {
+		if (!response.ok) {
+			const detail = await response.text();
+			throw new Error(`Google OAuth token request failed (${response.status}): ${detail}`);
+		}
+		const payload = await response.json();
+		const accessToken = payload.access_token?.trim();
+		if (!accessToken) throw new Error("Google OAuth token response was missing access_token");
+		const expiresInSeconds = typeof payload.expires_in === "number" && Number.isFinite(payload.expires_in) ? payload.expires_in : 3600;
+		return {
+			accessToken,
+			expiresAt: Date.now() + expiresInSeconds * 1e3,
+			refreshToken: payload.refresh_token?.trim() || void 0,
+			scope: payload.scope?.trim() || void 0,
+			tokenType: payload.token_type?.trim() || void 0
+		};
+	} finally {
+		await release();
+	}
+}
+function tokenRequestBody(values) {
+	const body = new URLSearchParams();
+	for (const [key, value] of Object.entries(values)) if (value?.trim()) body.set(key, value);
+	return body;
+}
+async function exchangeGoogleMeetAuthCode(params) {
+	return await executeGoogleTokenRequest(tokenRequestBody({
+		client_id: params.clientId,
+		client_secret: params.clientSecret,
+		code: params.code,
+		grant_type: "authorization_code",
+		redirect_uri: params.redirectUri ?? GOOGLE_MEET_REDIRECT_URI,
+		code_verifier: params.verifier
+	}));
+}
+async function refreshGoogleMeetAccessToken(params) {
+	return await executeGoogleTokenRequest(tokenRequestBody({
+		client_id: params.clientId,
+		client_secret: params.clientSecret,
+		grant_type: "refresh_token",
+		refresh_token: params.refreshToken
+	}));
+}
+function shouldUseCachedGoogleMeetAccessToken(params) {
+	const now = params.now ?? Date.now();
+	const safetyWindowMs = params.safetyWindowMs ?? 6e4;
+	return Boolean(params.accessToken?.trim() && typeof params.expiresAt === "number" && Number.isFinite(params.expiresAt) && params.expiresAt > now + safetyWindowMs);
+}
+async function resolveGoogleMeetAccessToken(params) {
+	if (shouldUseCachedGoogleMeetAccessToken(params)) return {
+		accessToken: params.accessToken.trim(),
+		expiresAt: params.expiresAt,
+		refreshed: false
+	};
+	if (!params.clientId?.trim() || !params.refreshToken?.trim()) throw new Error("Missing Google Meet OAuth credentials. Configure oauth.clientId and oauth.refreshToken, or pass --client-id and --refresh-token.");
+	const refreshed = await refreshGoogleMeetAccessToken({
+		clientId: params.clientId,
+		clientSecret: params.clientSecret,
+		refreshToken: params.refreshToken
+	});
+	return {
+		accessToken: refreshed.accessToken,
+		expiresAt: refreshed.expiresAt,
+		refreshed: true
+	};
+}
+function createGoogleMeetPkce() {
+	const { verifier, challenge } = generateHexPkceVerifierChallenge();
+	return {
+		verifier,
+		challenge
+	};
+}
+function createGoogleMeetOAuthState() {
+	return generateOAuthState();
+}
+async function waitForGoogleMeetAuthCode(params) {
+	params.writeLine(`Open this URL in your browser:\n\n${params.authUrl}\n`);
+	if (params.manual) {
+		const parsed = parseOAuthCallbackInput(await params.promptInput("Paste the full redirect URL here: "), {
+			missingState: "Missing 'state' parameter. Paste the full redirect URL.",
+			invalidInput: "Paste the full redirect URL, not just the code."
+		});
+		if ("error" in parsed) throw new Error(parsed.error);
+		if (parsed.state !== params.state) throw new Error("OAuth state mismatch - please try again");
+		return parsed.code;
+	}
+	return (await waitForLocalOAuthCallback({
+		expectedState: params.state,
+		timeoutMs: params.timeoutMs,
+		port: 8085,
+		callbackPath: "/oauth2callback",
+		redirectUri: GOOGLE_MEET_REDIRECT_URI,
+		successTitle: "Google Meet OAuth complete"
+	})).code;
+}
+//#endregion
+export { buildGoogleMeetAuthUrl, createGoogleMeetOAuthState, createGoogleMeetPkce, exchangeGoogleMeetAuthCode, resolveGoogleMeetAccessToken, waitForGoogleMeetAuthCode };

package/doctor-contract-api.ts

@@ -0,0 +1 @@
+export { legacyConfigRules, normalizeCompatibilityConfig } from "./src/config-compat.js";

package/google-meet.live.test.ts

@@ -0,0 +1,82 @@
+import { isLiveTestEnabled } from "klaw/plugin-sdk/test-env";
+import { describe, expect, it } from "vitest";
+import { buildGoogleMeetExportManifest, googleMeetExportFileNames } from "./src/cli.js";
+import {
+  fetchGoogleMeetArtifacts,
+  fetchGoogleMeetAttendance,
+  fetchLatestGoogleMeetConferenceRecord,
+} from "./src/meet.js";
+import { resolveGoogleMeetAccessToken } from "./src/oauth.js";
+
+const LIVE_MEETING = process.env.KLAW_GOOGLE_MEET_LIVE_MEETING?.trim() ?? "";
+const CLIENT_ID =
+  process.env.KLAW_GOOGLE_MEET_CLIENT_ID?.trim() ?? process.env.GOOGLE_MEET_CLIENT_ID?.trim() ?? "";
+const CLIENT_SECRET =
+  process.env.KLAW_GOOGLE_MEET_CLIENT_SECRET?.trim() ??
+  process.env.GOOGLE_MEET_CLIENT_SECRET?.trim();
+const REFRESH_TOKEN =
+  process.env.KLAW_GOOGLE_MEET_REFRESH_TOKEN?.trim() ??
+  process.env.GOOGLE_MEET_REFRESH_TOKEN?.trim() ??
+  "";
+const ACCESS_TOKEN =
+  process.env.KLAW_GOOGLE_MEET_ACCESS_TOKEN?.trim() ?? process.env.GOOGLE_MEET_ACCESS_TOKEN?.trim();
+const EXPIRES_AT = Number(
+  process.env.KLAW_GOOGLE_MEET_ACCESS_TOKEN_EXPIRES_AT ??
+    process.env.GOOGLE_MEET_ACCESS_TOKEN_EXPIRES_AT,
+);
+
+const LIVE =
+  isLiveTestEnabled() &&
+  LIVE_MEETING.length > 0 &&
+  ((CLIENT_ID.length > 0 && REFRESH_TOKEN.length > 0) || Boolean(ACCESS_TOKEN));
+const describeLive = LIVE ? describe : describe.skip;
+
+describeLive("google-meet live", () => {
+  it("resolves latest conference record and artifacts for a real meeting", async () => {
+    const token = await resolveGoogleMeetAccessToken({
+      clientId: CLIENT_ID,
+      clientSecret: CLIENT_SECRET,
+      refreshToken: REFRESH_TOKEN,
+      accessToken: ACCESS_TOKEN,
+      expiresAt: Number.isFinite(EXPIRES_AT) ? EXPIRES_AT : undefined,
+    });
+
+    const latest = await fetchLatestGoogleMeetConferenceRecord({
+      accessToken: token.accessToken,
+      meeting: LIVE_MEETING,
+    });
+    expect(latest.space.name).toMatch(/^spaces\//);
+
+    const artifacts = await fetchGoogleMeetArtifacts({
+      accessToken: token.accessToken,
+      meeting: LIVE_MEETING,
+      pageSize: 5,
+    });
+    expect(artifacts.conferenceRecords.length).toBeLessThanOrEqual(1);
+    expect(Array.isArray(artifacts.artifacts)).toBe(true);
+
+    const attendance = await fetchGoogleMeetAttendance({
+      accessToken: token.accessToken,
+      meeting: LIVE_MEETING,
+      pageSize: 5,
+    });
+    expect(attendance.conferenceRecords.length).toBe(artifacts.conferenceRecords.length);
+
+    const manifest = buildGoogleMeetExportManifest({
+      artifacts,
+      attendance,
+      files: googleMeetExportFileNames(),
+      request: {
+        meeting: LIVE_MEETING,
+        pageSize: 5,
+        includeTranscriptEntries: true,
+        includeDocumentBodies: false,
+        allConferenceRecords: false,
+        mergeDuplicateParticipants: true,
+      },
+      tokenSource: token.refreshed ? "refresh-token" : "cached-access-token",
+    });
+    expect(manifest.files).toContain("manifest.json");
+    expect(manifest.counts.conferenceRecords).toBe(artifacts.conferenceRecords.length);
+  }, 120_000);
+});