@openclaw/google-meet 2026.5.2 → 2026.5.3-beta.2

package/src/oauth.ts

@@ -1,229 +0,0 @@
-import { generateHexPkceVerifierChallenge } from "openclaw/plugin-sdk/provider-auth";
-import {
-  generateOAuthState,
-  parseOAuthCallbackInput,
-  waitForLocalOAuthCallback,
-} from "openclaw/plugin-sdk/provider-auth-runtime";
-import { fetchWithSsrFGuard } from "openclaw/plugin-sdk/ssrf-runtime";
-
-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",
-] as const;
-
-export type GoogleMeetOAuthTokens = {
-  accessToken: string;
-  expiresAt: number;
-  refreshToken?: string;
-  scope?: string;
-  tokenType?: string;
-};
-
-export function buildGoogleMeetAuthUrl(params: {
-  clientId: string;
-  challenge: string;
-  state: string;
-  redirectUri?: string;
-  scopes?: readonly string[];
-}): string {
-  const search = 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,
-  });
-  return `${GOOGLE_MEET_AUTH_URL}?${search.toString()}`;
-}
-
-async function executeGoogleTokenRequest(body: URLSearchParams): Promise<GoogleMeetOAuthTokens> {
-  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()) as {
-      access_token?: string;
-      expires_in?: number;
-      refresh_token?: string;
-      scope?: string;
-      token_type?: string;
-    };
-    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 * 1000,
-      refreshToken: payload.refresh_token?.trim() || undefined,
-      scope: payload.scope?.trim() || undefined,
-      tokenType: payload.token_type?.trim() || undefined,
-    };
-  } finally {
-    await release();
-  }
-}
-
-function tokenRequestBody(values: Record<string, string | undefined>): URLSearchParams {
-  const body = new URLSearchParams();
-  for (const [key, value] of Object.entries(values)) {
-    if (value?.trim()) {
-      body.set(key, value);
-    }
-  }
-  return body;
-}
-
-export async function exchangeGoogleMeetAuthCode(params: {
-  clientId: string;
-  clientSecret?: string;
-  code: string;
-  verifier: string;
-  redirectUri?: string;
-}): Promise<GoogleMeetOAuthTokens> {
-  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,
-    }),
-  );
-}
-
-export async function refreshGoogleMeetAccessToken(params: {
-  clientId: string;
-  clientSecret?: string;
-  refreshToken: string;
-}): Promise<GoogleMeetOAuthTokens> {
-  return await executeGoogleTokenRequest(
-    tokenRequestBody({
-      client_id: params.clientId,
-      client_secret: params.clientSecret,
-      grant_type: "refresh_token",
-      refresh_token: params.refreshToken,
-    }),
-  );
-}
-
-function shouldUseCachedGoogleMeetAccessToken(params: {
-  accessToken?: string;
-  expiresAt?: number;
-  now?: number;
-  safetyWindowMs?: number;
-}): boolean {
-  const now = params.now ?? Date.now();
-  const safetyWindowMs = params.safetyWindowMs ?? 60_000;
-  return Boolean(
-    params.accessToken?.trim() &&
-    typeof params.expiresAt === "number" &&
-    Number.isFinite(params.expiresAt) &&
-    params.expiresAt > now + safetyWindowMs,
-  );
-}
-
-export async function resolveGoogleMeetAccessToken(params: {
-  clientId?: string;
-  clientSecret?: string;
-  refreshToken?: string;
-  accessToken?: string;
-  expiresAt?: number;
-}): Promise<{ accessToken: string; expiresAt?: number; refreshed: boolean }> {
-  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,
-  };
-}
-
-export function createGoogleMeetPkce() {
-  const { verifier, challenge } = generateHexPkceVerifierChallenge();
-  return { verifier, challenge };
-}
-
-export function createGoogleMeetOAuthState(): string {
-  return generateOAuthState();
-}
-
-export async function waitForGoogleMeetAuthCode(params: {
-  state: string;
-  manual: boolean;
-  timeoutMs: number;
-  authUrl: string;
-  promptInput: (message: string) => Promise<string>;
-  writeLine: (message: string) => void;
-}): Promise<string> {
-  params.writeLine(`Open this URL in your browser:\n\n${params.authUrl}\n`);
-  if (params.manual) {
-    const input = await params.promptInput("Paste the full redirect URL here: ");
-    const parsed = parseOAuthCallbackInput(input, {
-      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;
-  }
-  const callback = await waitForLocalOAuthCallback({
-    expectedState: params.state,
-    timeoutMs: params.timeoutMs,
-    port: 8085,
-    callbackPath: "/oauth2callback",
-    redirectUri: GOOGLE_MEET_REDIRECT_URI,
-    successTitle: "Google Meet OAuth complete",
-  });
-  return callback.code;
-}

package/src/realtime-node.ts

@@ -1,271 +0,0 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
-import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
-import type { PluginRuntime, RuntimeLogger } from "openclaw/plugin-sdk/plugin-runtime";
-import {
-  createRealtimeVoiceBridgeSession,
-  type RealtimeVoiceBridgeSession,
-  type RealtimeVoiceProviderPlugin,
-} from "openclaw/plugin-sdk/realtime-voice";
-import {
-  consultOpenClawAgentForGoogleMeet,
-  GOOGLE_MEET_AGENT_CONSULT_TOOL_NAME,
-  resolveGoogleMeetRealtimeTools,
-  submitGoogleMeetConsultWorkingResponse,
-} from "./agent-consult.js";
-import type { GoogleMeetConfig } from "./config.js";
-import {
-  resolveGoogleMeetRealtimeAudioFormat,
-  resolveGoogleMeetRealtimeProvider,
-} from "./realtime.js";
-import type { GoogleMeetChromeHealth } from "./transports/types.js";
-
-export type ChromeNodeRealtimeAudioBridgeHandle = {
-  type: "node-command-pair";
-  providerId: string;
-  nodeId: string;
-  bridgeId: string;
-  speak: (instructions?: string) => void;
-  getHealth: () => GoogleMeetChromeHealth;
-  stop: () => Promise<void>;
-};
-
-function asRecord(value: unknown): Record<string, unknown> {
-  return value && typeof value === "object" && !Array.isArray(value)
-    ? (value as Record<string, unknown>)
-    : {};
-}
-
-function readString(value: unknown): string | undefined {
-  return typeof value === "string" && value.trim() ? value : undefined;
-}
-
-export async function startNodeRealtimeAudioBridge(params: {
-  config: GoogleMeetConfig;
-  fullConfig: OpenClawConfig;
-  runtime: PluginRuntime;
-  meetingSessionId: string;
-  nodeId: string;
-  bridgeId: string;
-  logger: RuntimeLogger;
-  providers?: RealtimeVoiceProviderPlugin[];
-}): Promise<ChromeNodeRealtimeAudioBridgeHandle> {
-  let stopped = false;
-  let bridge: RealtimeVoiceBridgeSession | null = null;
-  let realtimeReady = false;
-  let lastInputAt: string | undefined;
-  let lastOutputAt: string | undefined;
-  let lastClearAt: string | undefined;
-  let lastInputBytes = 0;
-  let lastOutputBytes = 0;
-  let consecutiveInputErrors = 0;
-  let lastInputError: string | undefined;
-  let clearCount = 0;
-  const resolved = resolveGoogleMeetRealtimeProvider({
-    config: params.config,
-    fullConfig: params.fullConfig,
-    providers: params.providers,
-  });
-  const transcript: Array<{ role: "user" | "assistant"; text: string }> = [];
-
-  const stop = async () => {
-    if (stopped) {
-      return;
-    }
-    stopped = true;
-    try {
-      bridge?.close();
-    } catch (error) {
-      params.logger.debug?.(
-        `[google-meet] node realtime bridge close ignored: ${formatErrorMessage(error)}`,
-      );
-    }
-    try {
-      await params.runtime.nodes.invoke({
-        nodeId: params.nodeId,
-        command: "googlemeet.chrome",
-        params: { action: "stop", bridgeId: params.bridgeId },
-        timeoutMs: 5_000,
-      });
-    } catch (error) {
-      params.logger.debug?.(
-        `[google-meet] node audio bridge stop ignored: ${formatErrorMessage(error)}`,
-      );
-    }
-  };
-
-  bridge = createRealtimeVoiceBridgeSession({
-    provider: resolved.provider,
-    providerConfig: resolved.providerConfig,
-    audioFormat: resolveGoogleMeetRealtimeAudioFormat(params.config),
-    instructions: params.config.realtime.instructions,
-    initialGreetingInstructions: params.config.realtime.introMessage,
-    triggerGreetingOnReady: false,
-    markStrategy: "ack-immediately",
-    tools: resolveGoogleMeetRealtimeTools(params.config.realtime.toolPolicy),
-    audioSink: {
-      isOpen: () => !stopped,
-      sendAudio: (audio) => {
-        lastOutputAt = new Date().toISOString();
-        lastOutputBytes += audio.byteLength;
-        void params.runtime.nodes
-          .invoke({
-            nodeId: params.nodeId,
-            command: "googlemeet.chrome",
-            params: {
-              action: "pushAudio",
-              bridgeId: params.bridgeId,
-              base64: Buffer.from(audio).toString("base64"),
-            },
-            timeoutMs: 5_000,
-          })
-          .catch((error) => {
-            params.logger.warn(
-              `[google-meet] node audio output failed: ${formatErrorMessage(error)}`,
-            );
-            void stop();
-          });
-      },
-      clearAudio: () => {
-        lastClearAt = new Date().toISOString();
-        clearCount += 1;
-        void params.runtime.nodes
-          .invoke({
-            nodeId: params.nodeId,
-            command: "googlemeet.chrome",
-            params: {
-              action: "clearAudio",
-              bridgeId: params.bridgeId,
-            },
-            timeoutMs: 5_000,
-          })
-          .catch((error) => {
-            params.logger.warn(
-              `[google-meet] node audio clear failed: ${formatErrorMessage(error)}`,
-            );
-            void stop();
-          });
-      },
-    },
-    onTranscript: (role, text, isFinal) => {
-      if (isFinal) {
-        transcript.push({ role, text });
-        if (transcript.length > 40) {
-          transcript.splice(0, transcript.length - 40);
-        }
-        params.logger.debug?.(`[google-meet] ${role}: ${text}`);
-      }
-    },
-    onToolCall: (event, session) => {
-      if (event.name !== GOOGLE_MEET_AGENT_CONSULT_TOOL_NAME) {
-        session.submitToolResult(event.callId || event.itemId, {
-          error: `Tool "${event.name}" not available`,
-        });
-        return;
-      }
-      submitGoogleMeetConsultWorkingResponse(session, event.callId || event.itemId);
-      void consultOpenClawAgentForGoogleMeet({
-        config: params.config,
-        fullConfig: params.fullConfig,
-        runtime: params.runtime,
-        logger: params.logger,
-        meetingSessionId: params.meetingSessionId,
-        args: event.args,
-        transcript,
-      })
-        .then((result) => {
-          session.submitToolResult(event.callId || event.itemId, result);
-        })
-        .catch((error: Error) => {
-          session.submitToolResult(event.callId || event.itemId, {
-            error: formatErrorMessage(error),
-          });
-        });
-    },
-    onError: (error) => {
-      params.logger.warn(
-        `[google-meet] node realtime voice bridge failed: ${formatErrorMessage(error)}`,
-      );
-      void stop();
-    },
-    onClose: (reason) => {
-      realtimeReady = false;
-      if (reason === "error") {
-        void stop();
-      }
-    },
-    onReady: () => {
-      realtimeReady = true;
-    },
-  });
-
-  await bridge.connect();
-
-  void (async () => {
-    for (;;) {
-      if (stopped) {
-        break;
-      }
-      try {
-        const raw = await params.runtime.nodes.invoke({
-          nodeId: params.nodeId,
-          command: "googlemeet.chrome",
-          params: { action: "pullAudio", bridgeId: params.bridgeId, timeoutMs: 250 },
-          timeoutMs: 2_000,
-        });
-        const result = asRecord(asRecord(raw).payload ?? raw);
-        consecutiveInputErrors = 0;
-        lastInputError = undefined;
-        const base64 = readString(result.base64);
-        if (base64) {
-          const audio = Buffer.from(base64, "base64");
-          lastInputAt = new Date().toISOString();
-          lastInputBytes += audio.byteLength;
-          bridge?.sendAudio(audio);
-        }
-        if (result.closed === true) {
-          await stop();
-        }
-      } catch (error) {
-        if (!stopped) {
-          const message = formatErrorMessage(error);
-          consecutiveInputErrors += 1;
-          lastInputError = message;
-          params.logger.warn(
-            `[google-meet] node audio input failed (${consecutiveInputErrors}/5): ${message}`,
-          );
-          if (consecutiveInputErrors >= 5 || /unknown bridgeId|bridge is not open/i.test(message)) {
-            await stop();
-          } else {
-            await new Promise((resolve) => setTimeout(resolve, 250));
-          }
-        }
-      }
-    }
-  })();
-
-  return {
-    type: "node-command-pair",
-    providerId: resolved.provider.id,
-    nodeId: params.nodeId,
-    bridgeId: params.bridgeId,
-    speak: (instructions) => {
-      bridge?.triggerGreeting(instructions);
-    },
-    getHealth: () => ({
-      providerConnected: bridge?.bridge.isConnected() ?? false,
-      realtimeReady,
-      audioInputActive: lastInputBytes > 0,
-      audioOutputActive: lastOutputBytes > 0,
-      lastInputAt,
-      lastOutputAt,
-      lastClearAt,
-      lastInputBytes,
-      lastOutputBytes,
-      consecutiveInputErrors,
-      lastInputError,
-      clearCount,
-      bridgeClosed: stopped,
-    }),
-    stop,
-  };
-}