@gakr-gakr/google-meet 0.1.0

package/src/transports/twilio.ts

@@ -0,0 +1,57 @@
+import { normalizeOptionalString } from "autobot/plugin-sdk/string-coerce-runtime";
+
+const DTMF_PATTERN = /^[0-9*#wWpP,]+$/;
+
+export function normalizeDialInNumber(value: unknown): string | undefined {
+  const normalized = normalizeOptionalString(value);
+  if (!normalized) {
+    return undefined;
+  }
+  const compact = normalized.replace(/[()\s.-]/g, "");
+  if (!/^\+?[0-9]{5,20}$/.test(compact)) {
+    throw new Error("dialInNumber must be a phone number");
+  }
+  return compact;
+}
+
+function normalizeDtmfSequence(value: unknown): string | undefined {
+  const normalized = normalizeOptionalString(value);
+  if (!normalized) {
+    return undefined;
+  }
+  const compact = normalized.replace(/\s+/g, "");
+  if (!DTMF_PATTERN.test(compact)) {
+    throw new Error("dtmfSequence may only contain digits, *, #, comma, w, p");
+  }
+  return compact;
+}
+
+export function buildMeetDtmfSequence(params: {
+  pin?: string;
+  dtmfSequence?: string;
+}): string | undefined {
+  const explicit = normalizeDtmfSequence(params.dtmfSequence);
+  if (explicit) {
+    return explicit;
+  }
+  const pin = normalizeOptionalString(params.pin);
+  if (!pin) {
+    return undefined;
+  }
+  const compactPin = pin.replace(/\s+/g, "");
+  if (!/^[0-9]+#?$/.test(compactPin)) {
+    throw new Error("pin may only contain digits and an optional trailing #");
+  }
+  return compactPin.endsWith("#") ? compactPin : `${compactPin}#`;
+}
+
+export function prefixDtmfWait(sequence: string | undefined, delayMs: number): string | undefined {
+  if (!sequence || delayMs <= 0) {
+    return sequence;
+  }
+  const waitCount = Math.ceil(delayMs / 500);
+  if (waitCount <= 0) {
+    return sequence;
+  }
+  return `${"w".repeat(waitCount)}${sequence}`;
+}

package/src/transports/types.ts

@@ -0,0 +1,147 @@
+import type { GoogleMeetMode, GoogleMeetModeInput, GoogleMeetTransport } from "../config.js";
+
+type GoogleMeetSessionState = "active" | "ended";
+
+export type GoogleMeetJoinRequest = {
+  url: string;
+  transport?: GoogleMeetTransport;
+  mode?: GoogleMeetModeInput;
+  message?: string;
+  requesterSessionKey?: string;
+  timeoutMs?: number;
+  dialInNumber?: string;
+  pin?: string;
+  dtmfSequence?: string;
+};
+
+type GoogleMeetManualActionReason =
+  | "google-login-required"
+  | "meet-admission-required"
+  | "meet-permission-required"
+  | "meet-audio-choice-required"
+  | "browser-control-unavailable";
+
+type GoogleMeetSpeechBlockedReason =
+  | GoogleMeetManualActionReason
+  | "not-in-call"
+  | "browser-unverified"
+  | "audio-bridge-unavailable"
+  | "meet-microphone-muted";
+
+export type GoogleMeetChromeHealth = {
+  inCall?: boolean;
+  micMuted?: boolean;
+  lobbyWaiting?: boolean;
+  leaveReason?: string;
+  captioning?: boolean;
+  captionsEnabledAttempted?: boolean;
+  transcriptLines?: number;
+  lastCaptionAt?: string;
+  lastCaptionSpeaker?: string;
+  lastCaptionText?: string;
+  recentTranscript?: Array<{
+    at?: string;
+    speaker?: string;
+    text: string;
+  }>;
+  realtimeTranscriptLines?: number;
+  lastRealtimeTranscriptAt?: string;
+  lastRealtimeTranscriptRole?: "user" | "assistant";
+  lastRealtimeTranscriptText?: string;
+  recentRealtimeTranscript?: Array<{
+    at: string;
+    role: "user" | "assistant";
+    text: string;
+  }>;
+  lastRealtimeEventAt?: string;
+  lastRealtimeEventType?: string;
+  lastRealtimeEventDetail?: string;
+  recentRealtimeEvents?: Array<{
+    at: string;
+    direction: "client" | "server";
+    type: string;
+    detail?: string;
+  }>;
+  recentTalkEvents?: Array<{
+    id: string;
+    type: string;
+    sessionId: string;
+    turnId?: string;
+    seq: number;
+    timestamp: string;
+    final?: boolean;
+  }>;
+  manualActionRequired?: boolean;
+  manualActionReason?: GoogleMeetManualActionReason;
+  manualActionMessage?: string;
+  speechReady?: boolean;
+  speechBlockedReason?: GoogleMeetSpeechBlockedReason;
+  speechBlockedMessage?: string;
+  providerConnected?: boolean;
+  realtimeReady?: boolean;
+  audioInputActive?: boolean;
+  audioOutputActive?: boolean;
+  audioOutputRouted?: boolean;
+  audioOutputDeviceLabel?: string;
+  audioOutputRouteError?: string;
+  lastInputAt?: string;
+  lastOutputAt?: string;
+  lastSuppressedInputAt?: string;
+  lastClearAt?: string;
+  lastInputBytes?: number;
+  lastOutputBytes?: number;
+  suppressedInputBytes?: number;
+  consecutiveInputErrors?: number;
+  lastInputError?: string;
+  clearCount?: number;
+  queuedInputChunks?: number;
+  browserUrl?: string;
+  browserTitle?: string;
+  bridgeClosed?: boolean;
+  status?: string;
+  notes?: string[];
+};
+
+export type GoogleMeetSession = {
+  id: string;
+  url: string;
+  transport: GoogleMeetTransport;
+  mode: GoogleMeetMode;
+  state: GoogleMeetSessionState;
+  createdAt: string;
+  updatedAt: string;
+  participantIdentity: string;
+  realtime: {
+    enabled: boolean;
+    strategy?: string;
+    provider?: string;
+    model?: string;
+    transcriptionProvider?: string;
+    toolPolicy: string;
+  };
+  chrome?: {
+    audioBackend: "blackhole-2ch";
+    launched: boolean;
+    nodeId?: string;
+    browserProfile?: string;
+    audioBridge?: {
+      type: "command-pair" | "node-command-pair" | "external-command";
+      provider?: string;
+    };
+    health?: GoogleMeetChromeHealth;
+  };
+  twilio?: {
+    dialInNumber: string;
+    pinProvided: boolean;
+    dtmfSequence?: string;
+    voiceCallId?: string;
+    dtmfSent?: boolean;
+    introSent?: boolean;
+  };
+  notes: string[];
+};
+
+export type GoogleMeetJoinResult = {
+  session: GoogleMeetSession;
+  spoken?: boolean;
+};

package/src/voice-call-gateway.ts

@@ -0,0 +1,241 @@
+import { formatErrorMessage } from "autobot/plugin-sdk/error-runtime";
+import {
+  GatewayClient,
+  startGatewayClientWhenEventLoopReady,
+} from "autobot/plugin-sdk/gateway-runtime";
+import type { RuntimeLogger } from "autobot/plugin-sdk/plugin-runtime";
+import { sleep } from "autobot/plugin-sdk/runtime-env";
+import type { GoogleMeetConfig } from "./config.js";
+
+type VoiceCallGatewayClient = InstanceType<typeof GatewayClient>;
+
+type VoiceCallStartResult = {
+  callId?: string;
+  initiated?: boolean;
+  error?: string;
+};
+
+type VoiceCallSpeakResult = {
+  success?: boolean;
+  error?: string;
+};
+
+type VoiceCallStatusResult = {
+  found?: boolean;
+  call?: unknown;
+};
+
+type VoiceCallMeetJoinResult = {
+  callId: string;
+  dtmfSent: boolean;
+  introSent: boolean;
+};
+
+async function createConnectedGatewayClient(
+  config: GoogleMeetConfig,
+): Promise<VoiceCallGatewayClient> {
+  let client: VoiceCallGatewayClient;
+  await new Promise<void>((resolve, reject) => {
+    const abortStart = new AbortController();
+    const timer = setTimeout(() => {
+      abortStart.abort();
+      reject(new Error("gateway connect timeout"));
+    }, config.voiceCall.requestTimeoutMs);
+    client = new GatewayClient({
+      url: config.voiceCall.gatewayUrl,
+      token: config.voiceCall.token,
+      requestTimeoutMs: config.voiceCall.requestTimeoutMs,
+      clientName: "cli",
+      clientDisplayName: "Google Meet plugin",
+      scopes: ["operator.write"],
+      onHelloOk: () => {
+        clearTimeout(timer);
+        resolve();
+      },
+      onConnectError: (err) => {
+        clearTimeout(timer);
+        abortStart.abort();
+        reject(err);
+      },
+    });
+    void startGatewayClientWhenEventLoopReady(client, {
+      timeoutMs: config.voiceCall.requestTimeoutMs,
+      signal: abortStart.signal,
+    })
+      .then((readiness) => {
+        if (!readiness.ready && !readiness.aborted) {
+          clearTimeout(timer);
+          reject(new Error("gateway event loop readiness timeout"));
+        }
+      })
+      .catch((err) => {
+        clearTimeout(timer);
+        reject(err instanceof Error ? err : new Error(String(err)));
+      });
+  });
+  return client!;
+}
+
+export function isVoiceCallMissingError(error: unknown): boolean {
+  const message = formatErrorMessage(error).toLowerCase();
+  return message.includes("call not found") || message.includes("call is not active");
+}
+
+export async function joinMeetViaVoiceCallGateway(params: {
+  config: GoogleMeetConfig;
+  dialInNumber: string;
+  dtmfSequence?: string;
+  logger?: RuntimeLogger;
+  message?: string;
+  requesterSessionKey?: string;
+  sessionKey?: string;
+}): Promise<VoiceCallMeetJoinResult> {
+  let client: VoiceCallGatewayClient | undefined;
+
+  try {
+    client = await createConnectedGatewayClient(params.config);
+    params.logger?.info(
+      `[google-meet] Delegating Twilio join to Voice Call (dtmf=${params.dtmfSequence ? "pre-connect" : "none"}, intro=${params.message ? "delayed" : "none"})`,
+    );
+    const start = (await client.request(
+      "voicecall.start",
+      {
+        to: params.dialInNumber,
+        mode: "conversation",
+        ...(params.dtmfSequence ? { dtmfSequence: params.dtmfSequence } : {}),
+        ...(params.requesterSessionKey ? { requesterSessionKey: params.requesterSessionKey } : {}),
+        ...(params.sessionKey ? { sessionKey: params.sessionKey } : {}),
+      },
+      { timeoutMs: params.config.voiceCall.requestTimeoutMs },
+    )) as VoiceCallStartResult;
+    if (!start.callId) {
+      throw new Error(start.error || "voicecall.start did not return callId");
+    }
+    params.logger?.info(
+      `[google-meet] Voice Call Twilio phone leg started: callId=${start.callId}`,
+    );
+    const dtmfSent = Boolean(params.dtmfSequence);
+    if (dtmfSent) {
+      params.logger?.info(
+        `[google-meet] Meet DTMF queued before realtime connect: callId=${start.callId} digits=${params.dtmfSequence?.length ?? 0}`,
+      );
+    }
+    let introSent = false;
+    if (params.message) {
+      const delayMs = params.dtmfSequence ? params.config.voiceCall.postDtmfSpeechDelayMs : 0;
+      if (delayMs > 0) {
+        params.logger?.info(
+          `[google-meet] Waiting ${delayMs}ms after Meet DTMF before speaking intro for callId=${start.callId}`,
+        );
+        await sleep(delayMs);
+      }
+      let spoken: VoiceCallSpeakResult;
+      try {
+        spoken = (await client.request(
+          "voicecall.speak",
+          {
+            callId: start.callId,
+            allowTwimlFallback: false,
+            message: params.message,
+          },
+          { timeoutMs: params.config.voiceCall.requestTimeoutMs },
+        )) as VoiceCallSpeakResult;
+      } catch (err) {
+        params.logger?.warn?.(
+          `[google-meet] Skipped intro speech because realtime bridge was not ready: ${formatErrorMessage(err)}`,
+        );
+        spoken = { success: false };
+      }
+      if (spoken.success === false) {
+        params.logger?.warn?.(
+          `[google-meet] Skipped intro speech because realtime bridge was not ready: ${
+            spoken.error || "voicecall.speak failed"
+          }`,
+        );
+      } else {
+        introSent = true;
+        params.logger?.info(
+          `[google-meet] Intro speech requested after Meet dial sequence: callId=${start.callId}`,
+        );
+      }
+    }
+    return {
+      callId: start.callId,
+      dtmfSent,
+      introSent,
+    };
+  } finally {
+    await client?.stopAndWait({ timeoutMs: 1_000 });
+  }
+}
+
+export async function endMeetVoiceCallGatewayCall(params: {
+  config: GoogleMeetConfig;
+  callId: string;
+}): Promise<void> {
+  let client: VoiceCallGatewayClient | undefined;
+
+  try {
+    client = await createConnectedGatewayClient(params.config);
+    try {
+      await client.request(
+        "voicecall.end",
+        {
+          callId: params.callId,
+        },
+        { timeoutMs: params.config.voiceCall.requestTimeoutMs },
+      );
+    } catch (err) {
+      if (!isVoiceCallMissingError(err)) {
+        throw err;
+      }
+    }
+  } finally {
+    await client?.stopAndWait({ timeoutMs: 1_000 });
+  }
+}
+
+export async function getMeetVoiceCallGatewayCall(params: {
+  config: GoogleMeetConfig;
+  callId: string;
+}): Promise<VoiceCallStatusResult> {
+  let client: VoiceCallGatewayClient | undefined;
+
+  try {
+    client = await createConnectedGatewayClient(params.config);
+    return (await client.request(
+      "voicecall.status",
+      {
+        callId: params.callId,
+      },
+      { timeoutMs: params.config.voiceCall.requestTimeoutMs },
+    )) as VoiceCallStatusResult;
+  } finally {
+    await client?.stopAndWait({ timeoutMs: 1_000 });
+  }
+}
+
+export async function speakMeetViaVoiceCallGateway(params: {
+  config: GoogleMeetConfig;
+  callId: string;
+  message: string;
+}): Promise<void> {
+  let client: VoiceCallGatewayClient | undefined;
+
+  try {
+    client = await createConnectedGatewayClient(params.config);
+    const spoken = (await client.request(
+      "voicecall.speak",
+      {
+        callId: params.callId,
+        message: params.message,
+      },
+      { timeoutMs: params.config.voiceCall.requestTimeoutMs },
+    )) as VoiceCallSpeakResult;
+    if (spoken.success === false) {
+      throw new Error(spoken.error || "voicecall.speak failed");
+    }
+  } finally {
+    await client?.stopAndWait({ timeoutMs: 1_000 });
+  }
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": "../tsconfig.package-boundary.base.json",
+  "compilerOptions": {
+    "rootDir": "."
+  },
+  "include": ["./*.ts", "./src/**/*.ts"],
+  "exclude": [
+    "./**/*.test.ts",
+    "./dist/**",
+    "./node_modules/**",
+    "./src/test-support/**",
+    "./src/**/*test-helpers.ts",
+    "./src/**/*test-harness.ts",
+    "./src/**/*test-support.ts"
+  ]
+}