Vendor OpenClaw source as Adolf fork baseline

Adolf is a fork/vendored clone of github.com/openclaw/openclaw (v2026.6.11),
free to diverge. Tree copied sans upstream .git; upstream remote added for
future syncs. Node pinned to 24 (.nvmrc); engines already require >=22.19.
Preserves docs/ARCHITECTURE.md.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LeqyaxJF2nbRXJtae2kNB2

extensions/google-meet/src/transports/chrome-browser-proxy.ts

@@ -0,0 +1,220 @@
+// Google Meet plugin module implements chrome browser proxy behavior.
+import { addTimerTimeoutGraceMs } from "openclaw/plugin-sdk/number-runtime";
+import type { PluginRuntime } from "openclaw/plugin-sdk/plugin-runtime";
+
+type BrowserProxyResult = {
+  result?: unknown;
+};
+
+export type BrowserTab = {
+  targetId?: string;
+  title?: string;
+  url?: string;
+};
+
+// Meet automation scripts match English UI labels ("Join now", "Turn off microphone").
+// hl=en pins the Meet page language regardless of account/browser locale; without it,
+// non-English profiles render localized labels and every DOM matcher goes blind.
+export function forceMeetEnglishUi(url: string): string {
+  try {
+    const parsed = new URL(url);
+    parsed.searchParams.set("hl", "en");
+    return parsed.toString();
+  } catch {
+    return url;
+  }
+}
+
+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 \`openclaw 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 \`openclaw 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 `openclaw 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: addTimerTimeoutGraceMs(params.timeoutMs) ?? 1,
+    scopes: ["operator.admin"],
+  });
+  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;
+}