@gakr-gakr/google-meet 0.1.0

package/src/create.ts

@@ -0,0 +1,157 @@
+import type { AutoBotPluginApi } from "autobot/plugin-sdk/plugin-entry";
+import { normalizeOptionalString } from "autobot/plugin-sdk/string-coerce-runtime";
+import type { GoogleMeetConfig, GoogleMeetMode, GoogleMeetTransport } from "./config.js";
+import {
+  createGoogleMeetSpace,
+  type GoogleMeetAccessType,
+  type GoogleMeetEntryPointAccess,
+  type GoogleMeetSpaceConfig,
+} from "./meet.js";
+import { resolveGoogleMeetAccessToken } from "./oauth.js";
+import type { GoogleMeetRuntime } from "./runtime.js";
+import { createMeetWithBrowserProxyOnNode } from "./transports/chrome-create.js";
+
+function normalizeTransport(value: unknown): GoogleMeetTransport | undefined {
+  return value === "chrome" || value === "chrome-node" || value === "twilio" ? value : undefined;
+}
+
+function normalizeMode(value: unknown): GoogleMeetMode | undefined {
+  if (value === "realtime") {
+    return "agent";
+  }
+  return value === "agent" || value === "bidi" || value === "transcribe" ? value : undefined;
+}
+
+function normalizeGoogleMeetAccessType(value: unknown): GoogleMeetAccessType | undefined {
+  const normalized = normalizeOptionalString(value)?.toUpperCase().replaceAll("-", "_");
+  return normalized === "OPEN" || normalized === "TRUSTED" || normalized === "RESTRICTED"
+    ? normalized
+    : undefined;
+}
+
+function normalizeGoogleMeetEntryPointAccess(
+  value: unknown,
+): GoogleMeetEntryPointAccess | undefined {
+  const normalized = normalizeOptionalString(value)?.toUpperCase().replaceAll("-", "_");
+  return normalized === "ALL" || normalized === "CREATOR_APP_ONLY" ? normalized : undefined;
+}
+
+export function resolveCreateSpaceConfig(
+  raw: Record<string, unknown>,
+): GoogleMeetSpaceConfig | undefined {
+  const rawAccessType = normalizeOptionalString(raw.accessType);
+  const rawEntryPointAccess = normalizeOptionalString(raw.entryPointAccess);
+  const accessType = normalizeGoogleMeetAccessType(raw.accessType);
+  const entryPointAccess = normalizeGoogleMeetEntryPointAccess(raw.entryPointAccess);
+  if (rawAccessType !== undefined && !accessType) {
+    throw new Error("Invalid Google Meet accessType. Expected OPEN, TRUSTED, or RESTRICTED.");
+  }
+  if (rawEntryPointAccess !== undefined && !entryPointAccess) {
+    throw new Error("Invalid Google Meet entryPointAccess. Expected ALL or CREATOR_APP_ONLY.");
+  }
+  const config = {
+    ...(accessType ? { accessType } : {}),
+    ...(entryPointAccess ? { entryPointAccess } : {}),
+  };
+  return Object.keys(config).length > 0 ? config : undefined;
+}
+
+export function hasCreateSpaceConfigInput(raw: Record<string, unknown>): boolean {
+  return (
+    normalizeOptionalString(raw.accessType) !== undefined ||
+    normalizeOptionalString(raw.entryPointAccess) !== undefined
+  );
+}
+
+async function createSpaceFromParams(config: GoogleMeetConfig, raw: Record<string, unknown>) {
+  const token = await 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,
+  });
+  const result = await createGoogleMeetSpace({
+    accessToken: token.accessToken,
+    config: resolveCreateSpaceConfig(raw),
+  });
+  return { source: "api" as const, token, ...result };
+}
+
+function hasGoogleMeetOAuth(config: GoogleMeetConfig, raw: Record<string, unknown>): boolean {
+  return Boolean(
+    normalizeOptionalString(raw.accessToken) ??
+    normalizeOptionalString(raw.refreshToken) ??
+    config.oauth.accessToken ??
+    config.oauth.refreshToken,
+  );
+}
+
+export async function createMeetFromParams(params: {
+  config: GoogleMeetConfig;
+  runtime: AutoBotPluginApi["runtime"];
+  raw: Record<string, unknown>;
+}) {
+  if (hasGoogleMeetOAuth(params.config, params.raw)) {
+    const { token: _token, ...result } = await createSpaceFromParams(params.config, params.raw);
+    return {
+      ...result,
+      joined: false,
+      nextAction:
+        "URL-only creation was requested. Call google_meet with action=join and url=meetingUri to enter the meeting.",
+    };
+  }
+  if (hasCreateSpaceConfigInput(params.raw)) {
+    throw new Error(
+      "Google Meet access policy options require OAuth/API room creation. Configure Google Meet OAuth or remove accessType/entryPointAccess.",
+    );
+  }
+  const browser = await createMeetWithBrowserProxyOnNode({
+    runtime: params.runtime,
+    config: params.config,
+  });
+  return {
+    source: browser.source,
+    meetingUri: browser.meetingUri,
+    joined: false,
+    nextAction:
+      "URL-only creation was requested. Call google_meet with action=join and url=meetingUri to enter the meeting.",
+    space: {
+      name: `browser/${browser.meetingUri.split("/").pop()}`,
+      meetingUri: browser.meetingUri,
+    },
+    browser: {
+      nodeId: browser.nodeId,
+      targetId: browser.targetId,
+      browserUrl: browser.browserUrl,
+      browserTitle: browser.browserTitle,
+      notes: browser.notes,
+    },
+  };
+}
+
+export async function createAndJoinMeetFromParams(params: {
+  config: GoogleMeetConfig;
+  runtime: AutoBotPluginApi["runtime"];
+  raw: Record<string, unknown>;
+  ensureRuntime: () => Promise<GoogleMeetRuntime>;
+}) {
+  const created = await createMeetFromParams(params);
+  const rt = await params.ensureRuntime();
+  const join = await rt.join({
+    url: created.meetingUri,
+    transport: normalizeTransport(params.raw.transport),
+    mode: normalizeMode(params.raw.mode),
+    dialInNumber: normalizeOptionalString(params.raw.dialInNumber),
+    pin: normalizeOptionalString(params.raw.pin),
+    dtmfSequence: normalizeOptionalString(params.raw.dtmfSequence),
+    message: normalizeOptionalString(params.raw.message),
+    requesterSessionKey: normalizeOptionalString(params.raw.requesterSessionKey),
+  });
+  return {
+    ...created,
+    joined: true,
+    nextAction: "Share meetingUri with participants; the AutoBot agent has started the join flow.",
+    join,
+  };
+}

package/src/drive.ts

@@ -0,0 +1,72 @@
+import { fetchWithSsrFGuard } from "autobot/plugin-sdk/ssrf-runtime";
+import { googleApiError } from "./google-api-errors.js";
+
+const GOOGLE_DRIVE_API_BASE_URL = "https://www.googleapis.com/drive/v3";
+const GOOGLE_DRIVE_API_HOST = "www.googleapis.com";
+const GOOGLE_DRIVE_MEET_SCOPE = "https://www.googleapis.com/auth/drive.meet.readonly";
+const TEXT_PLAIN_MIME = "text/plain";
+
+function appendQuery(url: string, query: Record<string, string | undefined>) {
+  const parsed = new URL(url);
+  for (const [key, value] of Object.entries(query)) {
+    if (value !== undefined) {
+      parsed.searchParams.set(key, value);
+    }
+  }
+  return parsed.toString();
+}
+
+export function extractGoogleDriveDocumentId(value: unknown): string | undefined {
+  if (typeof value !== "string") {
+    return undefined;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return undefined;
+  }
+  if (/^https?:\/\//i.test(trimmed)) {
+    try {
+      const url = new URL(trimmed);
+      const documentMatch = url.pathname.match(/\/document\/d\/([^/]+)/);
+      return documentMatch?.[1];
+    } catch {
+      return undefined;
+    }
+  }
+  const segments = trimmed.split("/").filter(Boolean);
+  return segments.at(-1);
+}
+
+export async function exportGoogleDriveDocumentText(params: {
+  accessToken: string;
+  documentId: string;
+}): Promise<string> {
+  const { response, release } = await fetchWithSsrFGuard({
+    url: appendQuery(
+      `${GOOGLE_DRIVE_API_BASE_URL}/files/${encodeURIComponent(params.documentId)}/export`,
+      { mimeType: TEXT_PLAIN_MIME },
+    ),
+    init: {
+      headers: {
+        Authorization: `Bearer ${params.accessToken}`,
+        Accept: TEXT_PLAIN_MIME,
+      },
+    },
+    policy: { allowedHostnames: [GOOGLE_DRIVE_API_HOST] },
+    auditContext: "google-meet.drive.files.export",
+  });
+  try {
+    if (!response.ok) {
+      const detail = await response.text();
+      throw await googleApiError({
+        response,
+        detail,
+        prefix: "Google Drive files.export",
+        scopes: [GOOGLE_DRIVE_MEET_SCOPE],
+      });
+    }
+    return await response.text();
+  } finally {
+    await release();
+  }
+}

package/src/google-api-errors.ts

@@ -0,0 +1,20 @@
+const REAUTH_HINT = "Re-run `autobot googlemeet auth login` and store the refreshed oauth block.";
+
+function scopeText(scopes: readonly string[]): string {
+  return scopes.map((scope) => `\`${scope}\``).join(", ");
+}
+
+export async function googleApiError(params: {
+  response: Response;
+  detail: string;
+  prefix: string;
+  scopes?: readonly string[];
+}): Promise<Error> {
+  const scopeHint =
+    params.scopes && params.scopes.length > 0
+      ? ` Required OAuth scope: ${scopeText(params.scopes)}. ${REAUTH_HINT}`
+      : "";
+  return new Error(
+    `${params.prefix} failed (${params.response.status}): ${params.detail}${scopeHint}`,
+  );
+}