@gakr-gakr/google-meet 0.1.0

package/src/setup.ts

@@ -0,0 +1,285 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { isBlockedHostnameOrIp } from "autobot/plugin-sdk/ssrf-runtime";
+import type { GoogleMeetConfig, GoogleMeetMode, GoogleMeetTransport } from "./config.js";
+
+type SetupCheck = {
+  id: string;
+  ok: boolean;
+  message: string;
+};
+
+type GoogleMeetSetupStatus = {
+  ok: boolean;
+  checks: SetupCheck[];
+};
+
+function resolveUserPath(input: string): string {
+  if (input === "~") {
+    return os.homedir();
+  }
+  if (input.startsWith("~/")) {
+    return path.join(os.homedir(), input.slice(2));
+  }
+  return input;
+}
+
+function isProviderUnreachableWebhookUrl(webhookUrl: string): boolean {
+  try {
+    const parsed = new URL(webhookUrl);
+    return isBlockedHostnameOrIp(parsed.hostname);
+  } catch {
+    return false;
+  }
+}
+
+function getVoiceCallWebhookExposureCheck(voiceCallConfig: Record<string, unknown>): SetupCheck {
+  const publicUrl = normalizeOptionalString(voiceCallConfig.publicUrl);
+  const tunnel = asRecord(voiceCallConfig.tunnel);
+  const tailscale = asRecord(voiceCallConfig.tailscale);
+  const tunnelProvider = normalizeOptionalString(tunnel.provider);
+  const tailscaleMode = normalizeOptionalString(tailscale.mode);
+
+  if (publicUrl) {
+    const ok = !isProviderUnreachableWebhookUrl(publicUrl);
+    return {
+      id: "twilio-voice-call-webhook",
+      ok,
+      message: ok
+        ? `Voice-call public webhook URL configured: ${publicUrl}`
+        : `Voice-call publicUrl is local/private and cannot be reached by Twilio: ${publicUrl}`,
+    };
+  }
+
+  if (tunnelProvider && tunnelProvider !== "none") {
+    return {
+      id: "twilio-voice-call-webhook",
+      ok: true,
+      message: "Voice-call webhook exposure configured through tunnel",
+    };
+  }
+
+  if (tailscaleMode && tailscaleMode !== "off") {
+    return {
+      id: "twilio-voice-call-webhook",
+      ok: true,
+      message: "Voice-call webhook exposure configured through Tailscale",
+    };
+  }
+
+  return {
+    id: "twilio-voice-call-webhook",
+    ok: false,
+    message:
+      "Set plugins.entries.voice-call.config.publicUrl or configure voice-call tunnel/tailscale exposure for Twilio dialing",
+  };
+}
+
+export function getGoogleMeetSetupStatus(config: GoogleMeetConfig): {
+  ok: boolean;
+  checks: SetupCheck[];
+};
+export function getGoogleMeetSetupStatus(
+  config: GoogleMeetConfig,
+  options?: {
+    env?: NodeJS.ProcessEnv;
+    fullConfig?: unknown;
+    mode?: GoogleMeetMode;
+    transport?: GoogleMeetTransport;
+    twilioDialInNumber?: string;
+  },
+): {
+  ok: boolean;
+  checks: SetupCheck[];
+};
+export function getGoogleMeetSetupStatus(
+  config: GoogleMeetConfig,
+  options?: {
+    env?: NodeJS.ProcessEnv;
+    fullConfig?: unknown;
+    mode?: GoogleMeetMode;
+    transport?: GoogleMeetTransport;
+    twilioDialInNumber?: string;
+  },
+) {
+  const checks: SetupCheck[] = [];
+  const env = options?.env ?? process.env;
+  const fullConfig = asRecord(options?.fullConfig);
+  const mode = options?.mode ?? config.defaultMode;
+  const transport = options?.transport ?? config.defaultTransport;
+  const needsChromeRealtimeAudio =
+    (mode === "agent" || mode === "bidi") &&
+    (transport === "chrome" || transport === "chrome-node");
+  const pluginEntries = asRecord(asRecord(fullConfig.plugins).entries);
+  const pluginAllow = asRecord(fullConfig.plugins).allow;
+  const voiceCallEntry = asRecord(pluginEntries["voice-call"]);
+  const voiceCallConfig = asRecord(voiceCallEntry.config);
+  const voiceCallTwilioConfig = asRecord(voiceCallConfig.twilio);
+
+  if (config.auth.tokenPath) {
+    const tokenPath = resolveUserPath(config.auth.tokenPath);
+    checks.push({
+      id: "google-oauth-token",
+      ok: fs.existsSync(tokenPath),
+      message: fs.existsSync(tokenPath)
+        ? "Google OAuth token file found"
+        : `Google OAuth token file missing at ${config.auth.tokenPath}`,
+    });
+  } else {
+    checks.push({
+      id: "google-oauth-token",
+      ok: true,
+      message: "Google OAuth token path not configured; Chrome profile auth will be used",
+    });
+  }
+
+  checks.push({
+    id: "chrome-profile",
+    ok: true,
+    message: config.chrome.browserProfile
+      ? "Local Chrome uses the AutoBot browser profile; chrome.browserProfile is passed to chrome-node hosts"
+      : "Local Chrome uses the AutoBot browser profile; configure browser.defaultProfile to choose another profile",
+  });
+
+  if (needsChromeRealtimeAudio) {
+    const hasCommandPair = Boolean(
+      config.chrome.audioInputCommand && config.chrome.audioOutputCommand,
+    );
+    const hasExternalBridge = Boolean(config.chrome.audioBridgeCommand);
+    const agentModeExternalBridgeInvalid = mode === "agent" && hasExternalBridge;
+    checks.push({
+      id: "audio-bridge",
+      ok:
+        mode === "agent"
+          ? hasCommandPair && !agentModeExternalBridgeInvalid
+          : hasExternalBridge || hasCommandPair,
+      message: agentModeExternalBridgeInvalid
+        ? "Chrome agent mode requires chrome.audioInputCommand and chrome.audioOutputCommand; chrome.audioBridgeCommand is bidi-only"
+        : hasExternalBridge
+          ? "Chrome audio bridge command configured"
+          : hasCommandPair
+            ? `Chrome command-pair talk-back audio bridge configured (${config.chrome.audioFormat})`
+            : "Chrome talk-back audio bridge not configured",
+    });
+  } else if (transport === "chrome" || transport === "chrome-node") {
+    checks.push({
+      id: "audio-bridge",
+      ok: true,
+      message: "Chrome observe-only mode does not require a realtime audio bridge",
+    });
+  }
+
+  checks.push({
+    id: "guest-join-defaults",
+    ok: Boolean(
+      config.chrome.guestName && config.chrome.autoJoin && config.chrome.reuseExistingTab,
+    ),
+    message:
+      config.chrome.guestName && config.chrome.autoJoin && config.chrome.reuseExistingTab
+        ? "Guest auto-join and tab reuse defaults are enabled"
+        : "Set chrome.guestName, chrome.autoJoin, and chrome.reuseExistingTab for unattended guest joins",
+  });
+
+  checks.push({
+    id: "chrome-node-target",
+    ok: config.defaultTransport !== "chrome-node" || Boolean(config.chromeNode.node),
+    message:
+      config.defaultTransport === "chrome-node" && !config.chromeNode.node
+        ? "chrome-node default should pin chromeNode.node when multiple nodes may be connected"
+        : config.chromeNode.node
+          ? `Chrome node pinned to ${config.chromeNode.node}`
+          : "Chrome node not pinned; automatic selection works when exactly one capable node is connected",
+  });
+
+  if (needsChromeRealtimeAudio) {
+    checks.push({
+      id: "intro-after-in-call",
+      ok: config.chrome.waitForInCallMs > 0,
+      message:
+        config.chrome.waitForInCallMs > 0
+          ? `Realtime intro waits up to ${config.chrome.waitForInCallMs}ms for the Meet tab to be in-call`
+          : "Set chrome.waitForInCallMs to delay realtime intro until the Meet tab is in-call",
+    });
+  }
+
+  if (transport === "twilio") {
+    const hasRequestDialPlan = Boolean(options?.twilioDialInNumber);
+    const hasDefaultDialPlan = Boolean(config.twilio.defaultDialInNumber);
+    const hasDialPlan = hasRequestDialPlan || hasDefaultDialPlan;
+    checks.push({
+      id: "twilio-dial-plan",
+      ok: hasDialPlan,
+      message: hasRequestDialPlan
+        ? "Twilio request includes a Meet dial-in number"
+        : hasDefaultDialPlan
+          ? "Twilio default Meet dial-in number is configured"
+          : "Twilio joins require a Meet dial-in phone number; pass dialInNumber with optional pin/dtmfSequence or configure twilio.defaultDialInNumber",
+    });
+  }
+
+  const shouldCheckTwilioDelegation =
+    config.voiceCall.enabled &&
+    (transport === "twilio" ||
+      Boolean(config.twilio.defaultDialInNumber) ||
+      Object.hasOwn(pluginEntries, "voice-call"));
+  if (shouldCheckTwilioDelegation) {
+    const voiceCallAllowed = !Array.isArray(pluginAllow) || pluginAllow.includes("voice-call");
+    const hasVoiceCallEntry = Object.hasOwn(pluginEntries, "voice-call");
+    const voiceCallEnabled = hasVoiceCallEntry && voiceCallEntry.enabled !== false;
+    checks.push({
+      id: "twilio-voice-call-plugin",
+      ok: voiceCallAllowed && voiceCallEnabled,
+      message:
+        voiceCallAllowed && voiceCallEnabled
+          ? "Twilio transport can delegate dialing to the voice-call plugin"
+          : "Enable plugins.entries.voice-call and include voice-call in plugins.allow for Twilio dialing",
+    });
+
+    const provider = normalizeOptionalString(voiceCallConfig.provider) ?? "twilio";
+    if (provider === "twilio") {
+      const accountSid = normalizeOptionalString(voiceCallTwilioConfig.accountSid);
+      const authToken = normalizeOptionalString(voiceCallTwilioConfig.authToken);
+      const fromNumber = normalizeOptionalString(voiceCallConfig.fromNumber);
+      const twilioReady = Boolean(
+        (accountSid || env.TWILIO_ACCOUNT_SID) &&
+        (authToken || env.TWILIO_AUTH_TOKEN) &&
+        (fromNumber || env.TWILIO_FROM_NUMBER),
+      );
+      checks.push({
+        id: "twilio-voice-call-credentials",
+        ok: twilioReady,
+        message: twilioReady
+          ? "Twilio voice-call credentials are configured"
+          : "Set TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN, and TWILIO_FROM_NUMBER or configure voice-call Twilio credentials",
+      });
+      checks.push(getVoiceCallWebhookExposureCheck(voiceCallConfig));
+    }
+  }
+
+  return {
+    ok: checks.every((check) => check.ok),
+    checks,
+  };
+}
+
+export function addGoogleMeetSetupCheck(
+  status: GoogleMeetSetupStatus,
+  check: SetupCheck,
+): GoogleMeetSetupStatus {
+  const checks = [...status.checks, check];
+  return {
+    ok: checks.every((item) => item.ok),
+    checks,
+  };
+}
+
+function asRecord(value: unknown): Record<string, unknown> {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : {};
+}
+
+function normalizeOptionalString(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}

package/src/transports/chrome-browser-proxy.ts

@@ -0,0 +1,204 @@
+import type { PluginRuntime } from "autobot/plugin-sdk/plugin-runtime";
+
+type BrowserProxyResult = {
+  result?: unknown;
+};
+
+export type BrowserTab = {
+  targetId?: string;
+  title?: string;
+  url?: string;
+};
+
+export function normalizeMeetUrlForReuse(url: string | undefined): string | undefined {
+  if (!url) {
+    return undefined;
+  }
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol !== "https:" || parsed.hostname.toLowerCase() !== "meet.google.com") {
+      return undefined;
+    }
+    const match = parsed.pathname.match(/^\/(new|[a-z]{3}-[a-z]{4}-[a-z]{3})(?:\/)?$/i);
+    if (!match?.[1]) {
+      return undefined;
+    }
+    return `https://meet.google.com/${match[1].toLowerCase()}`;
+  } catch {
+    return undefined;
+  }
+}
+
+export function isSameMeetUrlForReuse(a: string | undefined, b: string | undefined): boolean {
+  const normalizedA = normalizeMeetUrlForReuse(a);
+  const normalizedB = normalizeMeetUrlForReuse(b);
+  return Boolean(normalizedA && normalizedB && normalizedA === normalizedB);
+}
+
+type GoogleMeetNodeInfo = {
+  caps?: string[];
+  commands?: string[];
+  connected?: boolean;
+  nodeId?: string;
+  displayName?: string;
+  remoteIp?: string;
+};
+
+function isGoogleMeetNode(node: GoogleMeetNodeInfo) {
+  const commands = Array.isArray(node.commands) ? node.commands : [];
+  const caps = Array.isArray(node.caps) ? node.caps : [];
+  return (
+    node.connected === true &&
+    commands.includes("googlemeet.chrome") &&
+    (commands.includes("browser.proxy") || caps.includes("browser"))
+  );
+}
+
+function matchesRequestedNode(node: GoogleMeetNodeInfo, requested: string): boolean {
+  return [node.nodeId, node.displayName, node.remoteIp].some((value) => value === requested);
+}
+
+function formatNodeLabel(node: GoogleMeetNodeInfo): string {
+  const parts = [node.displayName, node.nodeId, node.remoteIp].filter(Boolean);
+  return parts.length > 0 ? parts.join(" / ") : "unknown node";
+}
+
+function describeNodeUsabilityIssues(node: GoogleMeetNodeInfo): string[] {
+  const commands = Array.isArray(node.commands) ? node.commands : [];
+  const caps = Array.isArray(node.caps) ? node.caps : [];
+  const issues: string[] = [];
+  if (node.connected !== true) {
+    issues.push("offline");
+  }
+  if (!commands.includes("googlemeet.chrome")) {
+    issues.push("missing googlemeet.chrome");
+  }
+  if (!commands.includes("browser.proxy") && !caps.includes("browser")) {
+    issues.push("missing browser.proxy/browser capability");
+  }
+  return issues;
+}
+
+async function listGoogleMeetNodes(
+  runtime: PluginRuntime,
+  params?: { connected?: boolean },
+): Promise<{ nodes: GoogleMeetNodeInfo[] }> {
+  try {
+    return params ? await runtime.nodes.list(params) : await runtime.nodes.list();
+  } catch (error) {
+    throw new Error("Google Meet node inventory unavailable", {
+      cause: error,
+    });
+  }
+}
+
+export async function resolveChromeNodeInfo(params: {
+  runtime: PluginRuntime;
+  requestedNode?: string;
+}): Promise<GoogleMeetNodeInfo> {
+  const requested = params.requestedNode?.trim();
+  if (requested) {
+    const list = await listGoogleMeetNodes(params.runtime);
+    const matches = list.nodes.filter((node) => matchesRequestedNode(node, requested));
+    if (matches.length === 1) {
+      const [node] = matches;
+      if (isGoogleMeetNode(node)) {
+        return node;
+      }
+      throw new Error(
+        `Configured Google Meet node ${requested} is not usable (${formatNodeLabel(node)}): ${describeNodeUsabilityIssues(node).join("; ")}. Start or reinstall \`autobot node run\` on that Chrome host, approve pairing, and allow googlemeet.chrome plus browser.proxy.`,
+      );
+    }
+    if (matches.length > 1) {
+      throw new Error(
+        `Configured Google Meet node ${requested} is ambiguous (${matches.length} matches). Pin chromeNode.node to a unique node id, display name, or remote IP.`,
+      );
+    }
+    throw new Error(
+      `Configured Google Meet node ${requested} was not found. Run \`autobot nodes status\` and start or approve the Chrome node.`,
+    );
+  }
+
+  const list = await listGoogleMeetNodes(params.runtime, { connected: true });
+  const nodes = list.nodes.filter(isGoogleMeetNode);
+  if (nodes.length === 0) {
+    throw new Error(
+      "No connected Google Meet-capable node with browser proxy. Run `autobot node run` on the Chrome host with browser proxy enabled, approve pairing, and allow googlemeet.chrome plus browser.proxy.",
+    );
+  }
+  if (nodes.length === 1) {
+    return nodes[0];
+  }
+  throw new Error(
+    "Multiple Google Meet-capable nodes connected. Set plugins.entries.google-meet.config.chromeNode.node.",
+  );
+}
+
+export async function resolveChromeNode(params: {
+  runtime: PluginRuntime;
+  requestedNode?: string;
+}): Promise<string> {
+  const node = await resolveChromeNodeInfo(params);
+  if (!node.nodeId) {
+    throw new Error("Google Meet node did not include a node id.");
+  }
+  return node.nodeId;
+}
+
+function unwrapNodeInvokePayload(raw: unknown): unknown {
+  const record = raw && typeof raw === "object" ? (raw as Record<string, unknown>) : {};
+  if (typeof record.payloadJSON === "string" && record.payloadJSON.trim()) {
+    try {
+      return JSON.parse(record.payloadJSON);
+    } catch (error) {
+      throw new Error("Google Meet browser proxy returned malformed payloadJSON.", {
+        cause: error,
+      });
+    }
+  }
+  if ("payload" in record) {
+    return record.payload;
+  }
+  return raw;
+}
+
+function parseBrowserProxyResult(raw: unknown): unknown {
+  const payload = unwrapNodeInvokePayload(raw);
+  const proxy =
+    payload && typeof payload === "object" ? (payload as BrowserProxyResult) : undefined;
+  if (!proxy || !("result" in proxy)) {
+    throw new Error("Google Meet browser proxy returned an invalid result.");
+  }
+  return proxy.result;
+}
+
+export async function callBrowserProxyOnNode(params: {
+  runtime: PluginRuntime;
+  nodeId: string;
+  method: "GET" | "POST" | "DELETE";
+  path: string;
+  body?: unknown;
+  timeoutMs: number;
+}) {
+  const raw = await params.runtime.nodes.invoke({
+    nodeId: params.nodeId,
+    command: "browser.proxy",
+    params: {
+      method: params.method,
+      path: params.path,
+      body: params.body,
+      timeoutMs: params.timeoutMs,
+    },
+    timeoutMs: params.timeoutMs + 5_000,
+  });
+  return parseBrowserProxyResult(raw);
+}
+
+export function asBrowserTabs(result: unknown): BrowserTab[] {
+  const record = result && typeof result === "object" ? (result as Record<string, unknown>) : {};
+  return Array.isArray(record.tabs) ? (record.tabs as BrowserTab[]) : [];
+}
+
+export function readBrowserTab(result: unknown): BrowserTab | undefined {
+  return result && typeof result === "object" ? (result as BrowserTab) : undefined;
+}