@kodelyth/google-meet 2026.5.42 → 2026.6.1

package/src/setup.ts

@@ -1,285 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { isBlockedHostnameOrIp } from "klaw/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 Klaw browser profile; chrome.browserProfile is passed to chrome-node hosts"
-      : "Local Chrome uses the Klaw 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/test-support/plugin-harness.ts

@@ -1,232 +0,0 @@
-import type { KlawPluginApi } from "klaw/plugin-sdk/plugin-entry";
-import { createTestPluginApi } from "klaw/plugin-sdk/plugin-test-api";
-import { vi } from "vitest";
-
-type GoogleMeetTestPluginEntry = {
-  register(api: KlawPluginApi): void;
-};
-
-export const noopLogger = {
-  info: vi.fn(),
-  warn: vi.fn(),
-  error: vi.fn(),
-  debug: vi.fn(),
-};
-
-type GoogleMeetTestNodeListResult = {
-  nodes: Array<{
-    nodeId: string;
-    displayName?: string;
-    connected?: boolean;
-    commands?: string[];
-    caps?: string[];
-    remoteIp?: string;
-  }>;
-};
-
-type CommandResult = {
-  code: number;
-  stdout?: string;
-  stderr?: string;
-};
-
-export function captureStdout() {
-  let output = "";
-  const writeSpy = vi.spyOn(process.stdout, "write").mockImplementation(((chunk: unknown) => {
-    output += String(chunk);
-    return true;
-  }) as typeof process.stdout.write);
-  return {
-    output: () => output,
-    restore: () => writeSpy.mockRestore(),
-  };
-}
-
-export function setupGoogleMeetPlugin(
-  plugin: GoogleMeetTestPluginEntry,
-  config: Record<string, unknown> = {},
-  options: {
-    fullConfig?: Record<string, unknown>;
-    nodesListResult?: GoogleMeetTestNodeListResult;
-    nodesInvokeResult?: unknown;
-    browserActResult?: Record<string, unknown>;
-    nodesInvokeHandler?: (params: {
-      nodeId: string;
-      command: string;
-      params?: unknown;
-      timeoutMs?: number;
-    }) => Promise<unknown>;
-    runCommandWithTimeoutHandler?: (
-      argv: string[],
-      options?: { timeoutMs?: number },
-    ) => Promise<CommandResult>;
-    registerPlatform?: NodeJS.Platform;
-    toolContext?: Record<string, unknown>;
-  } = {},
-) {
-  const methods = new Map<string, unknown>();
-  const tools: unknown[] = [];
-  const cliRegistrations: unknown[] = [];
-  const nodeHostCommands: unknown[] = [];
-  const nodesList = vi.fn(
-    async () =>
-      options.nodesListResult ?? {
-        nodes: [
-          {
-            nodeId: "node-1",
-            displayName: "parallels-macos",
-            connected: true,
-            caps: ["browser"],
-            commands: ["browser.proxy", "googlemeet.chrome"],
-          },
-        ],
-      },
-  );
-  const nodesInvoke = vi.fn(async (params) => {
-    if (options.nodesInvokeHandler) {
-      return options.nodesInvokeHandler(params);
-    }
-    if (params.command === "browser.proxy") {
-      const proxy = params.params as { path?: string; body?: { url?: string; targetId?: string } };
-      if (proxy.path === "/tabs") {
-        return { payload: { result: { running: true, tabs: [] } } };
-      }
-      if (proxy.path === "/tabs/open") {
-        return {
-          payload: {
-            result: {
-              targetId: "tab-1",
-              title: "Meet",
-              url: proxy.body?.url ?? "https://meet.google.com/abc-defg-hij",
-            },
-          },
-        };
-      }
-      if (proxy.path === "/act") {
-        return {
-          payload: {
-            result: {
-              ok: true,
-              targetId: proxy.body?.targetId ?? "tab-1",
-              result: JSON.stringify(
-                options.browserActResult ?? {
-                  inCall: true,
-                  micMuted: false,
-                  title: "Meet call",
-                  url: "https://meet.google.com/abc-defg-hij",
-                },
-              ),
-            },
-          },
-        };
-      }
-      return { payload: { result: { ok: true } } };
-    }
-    return options.nodesInvokeResult ?? { launched: true };
-  });
-  const runCommandWithTimeout = vi.fn(
-    async (argv: string[], runOptions?: { timeoutMs?: number }) => {
-      if (options.runCommandWithTimeoutHandler) {
-        return options.runCommandWithTimeoutHandler(argv, runOptions);
-      }
-      if (argv[0] === "/usr/sbin/system_profiler") {
-        return { code: 0, stdout: "BlackHole 2ch", stderr: "" };
-      }
-      return { code: 0, stdout: "", stderr: "" };
-    },
-  );
-  const api = createTestPluginApi({
-    id: "google-meet",
-    name: "Google Meet",
-    description: "test",
-    version: "0",
-    source: "test",
-    config: options.fullConfig ?? {},
-    pluginConfig: config,
-    runtime: {
-      system: {
-        runCommandWithTimeout,
-        formatNativeDependencyHint: vi.fn(() => "Install with brew install blackhole-2ch."),
-      },
-      nodes: {
-        list: nodesList,
-        invoke: nodesInvoke,
-      },
-    } as unknown as KlawPluginApi["runtime"],
-    logger: noopLogger,
-    registerGatewayMethod: (method: string, handler: unknown) => methods.set(method, handler),
-    registerTool: (tool: unknown) => {
-      tools.push(
-        typeof tool === "function"
-          ? (tool as (ctx: Record<string, unknown>) => unknown)(options.toolContext ?? {})
-          : tool,
-      );
-    },
-    registerCli: (_registrar: unknown, opts: unknown) => cliRegistrations.push(opts),
-    registerNodeHostCommand: (command: unknown) => nodeHostCommands.push(command),
-  });
-  const originalPlatform = process.platform;
-  Object.defineProperty(process, "platform", {
-    configurable: true,
-    value: options.registerPlatform ?? "darwin",
-  });
-  try {
-    plugin.register(api);
-  } finally {
-    Object.defineProperty(process, "platform", { configurable: true, value: originalPlatform });
-  }
-  return {
-    cliRegistrations,
-    methods,
-    tools,
-    runCommandWithTimeout,
-    nodesList,
-    nodesInvoke,
-    nodeHostCommands,
-  };
-}
-
-export async function invokeGoogleMeetGatewayMethodForTest(
-  methods: Map<string, unknown>,
-  method: string,
-  params?: unknown,
-): Promise<unknown> {
-  const handler = methods.get(method) as
-    | ((opts: {
-        params: Record<string, unknown>;
-        respond: (
-          ok: boolean,
-          payload?: unknown,
-          error?: { message?: string; details?: unknown },
-        ) => void;
-      }) => Promise<void> | void)
-    | undefined;
-  if (!handler) {
-    throw new Error(`gateway method not registered: ${method}`);
-  }
-  return await new Promise((resolve, reject) => {
-    const respond = (
-      ok: boolean,
-      payload?: unknown,
-      error?: { message?: string; details?: unknown },
-    ) => {
-      if (ok) {
-        resolve(payload);
-        return;
-      }
-      const err = new Error(error?.message ?? "gateway request failed") as Error & {
-        details?: unknown;
-      };
-      err.details = error?.details ?? payload;
-      reject(err);
-    };
-    void Promise.resolve(
-      handler({
-        params: (params && typeof params === "object" && !Array.isArray(params)
-          ? params
-          : {}) as Record<string, unknown>,
-        respond,
-      }),
-    ).catch(reject);
-  });
-}

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

@@ -1,39 +0,0 @@
-import type { PluginRuntime } from "klaw/plugin-sdk/plugin-runtime";
-import { describe, expect, it, vi } from "vitest";
-import { callBrowserProxyOnNode } from "./chrome-browser-proxy.js";
-
-describe("Google Meet Chrome browser proxy", () => {
-  it("reports malformed node proxy payloadJSON with an owned error", async () => {
-    const invoke = vi.fn(async () => ({
-      ok: true,
-      payloadJSON: "{not json",
-    }));
-    const runtime = {
-      nodes: {
-        invoke,
-      },
-    } as unknown as PluginRuntime;
-
-    await expect(
-      callBrowserProxyOnNode({
-        runtime,
-        nodeId: "node-1",
-        method: "GET",
-        path: "/tabs",
-        timeoutMs: 100,
-      }),
-    ).rejects.toThrow("Google Meet browser proxy returned malformed payloadJSON.");
-
-    expect(invoke).toHaveBeenCalledWith({
-      nodeId: "node-1",
-      command: "browser.proxy",
-      params: {
-        method: "GET",
-        path: "/tabs",
-        body: undefined,
-        timeoutMs: 100,
-      },
-      timeoutMs: 5_100,
-    });
-  });
-});