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/node-host.test.ts

@@ -0,0 +1,277 @@
+// Google Meet tests cover node host plugin behavior.
+import { spawnSync } from "node:child_process";
+import { EventEmitter } from "node:events";
+import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from "vitest";
+
+type MockChild = EventEmitter & {
+  exitCode: number | null;
+  signalCode: NodeJS.Signals | null;
+  kill: ReturnType<typeof vi.fn>;
+  stdout?: EventEmitter;
+  stderr?: EventEmitter;
+  stdin?: { write: ReturnType<typeof vi.fn> };
+};
+
+const children: MockChild[] = [];
+let handleGoogleMeetNodeHostCommand: typeof import("./src/node-host.js").handleGoogleMeetNodeHostCommand;
+
+vi.mock("node:child_process", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("node:child_process")>();
+  return {
+    ...actual,
+    spawnSync: vi.fn(() => ({
+      status: 0,
+      stdout: "BlackHole 2ch",
+      stderr: "",
+    })),
+    spawn: vi.fn(() => {
+      const child = Object.assign(new EventEmitter(), {
+        exitCode: null,
+        signalCode: null,
+        kill: vi.fn((signal?: NodeJS.Signals) => {
+          child.signalCode = signal ?? "SIGTERM";
+          return true;
+        }),
+        stdout: new EventEmitter(),
+        stderr: new EventEmitter(),
+        stdin: { write: vi.fn() },
+      }) as MockChild;
+      children.push(child);
+      return child;
+    }),
+  };
+});
+
+describe("google-meet node host bridge sessions", () => {
+  beforeAll(async () => {
+    ({ handleGoogleMeetNodeHostCommand } = await import("./src/node-host.js"));
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    children.length = 0;
+  });
+
+  afterAll(() => {
+    vi.doUnmock("node:child_process");
+    vi.resetModules();
+  });
+
+  it("reports malformed params JSON with an owned error", async () => {
+    await expect(handleGoogleMeetNodeHostCommand("{not json")).rejects.toThrow(
+      "Google Meet node host received malformed params JSON.",
+    );
+  });
+
+  it("starts observe-only Chrome without BlackHole or bridge processes", async () => {
+    const originalPlatform = process.platform;
+    children.length = 0;
+    vi.mocked(spawnSync).mockClear();
+
+    Object.defineProperty(process, "platform", { configurable: true, value: "darwin" });
+    try {
+      const start = JSON.parse(
+        await handleGoogleMeetNodeHostCommand(
+          JSON.stringify({
+            action: "start",
+            url: "https://meet.google.com/xyz-abcd-uvw",
+            mode: "transcribe",
+            launch: false,
+            audioInputCommand: ["mock-rec"],
+            audioOutputCommand: ["mock-play"],
+          }),
+        ),
+      );
+
+      expect(start).toEqual({ launched: false });
+      expect(spawnSync).not.toHaveBeenCalled();
+      expect(children).toHaveLength(0);
+    } finally {
+      Object.defineProperty(process, "platform", { configurable: true, value: originalPlatform });
+    }
+  });
+
+  it("passes the Meet URL before Chrome profile args when launching a profiled browser", async () => {
+    const originalPlatform = process.platform;
+    children.length = 0;
+    vi.mocked(spawnSync).mockClear();
+
+    Object.defineProperty(process, "platform", { configurable: true, value: "darwin" });
+    try {
+      const start = JSON.parse(
+        await handleGoogleMeetNodeHostCommand(
+          JSON.stringify({
+            action: "start",
+            url: "https://meet.google.com/xyz-abcd-uvw",
+            mode: "transcribe",
+            browserProfile: "Profile 2",
+          }),
+        ),
+      );
+
+      expect(start.launched).toBe(true);
+      expect(spawnSync).toHaveBeenCalledWith(
+        "open",
+        [
+          "-a",
+          "Google Chrome",
+          "https://meet.google.com/xyz-abcd-uvw",
+          "--args",
+          "--profile-directory=Profile 2",
+        ],
+        expect.objectContaining({ encoding: "utf8" }),
+      );
+    } finally {
+      Object.defineProperty(process, "platform", { configurable: true, value: originalPlatform });
+    }
+  });
+
+  it("clears output playback without closing the active bridge when the old output exits", async () => {
+    const originalPlatform = process.platform;
+    children.length = 0;
+
+    Object.defineProperty(process, "platform", { configurable: true, value: "darwin" });
+    try {
+      const start = JSON.parse(
+        await handleGoogleMeetNodeHostCommand(
+          JSON.stringify({
+            action: "start",
+            url: "https://meet.google.com/xyz-abcd-uvw",
+            mode: "realtime",
+            launch: false,
+            audioInputCommand: ["mock-rec"],
+            audioOutputCommand: ["mock-play"],
+          }),
+        ),
+      );
+
+      expect(children).toHaveLength(2);
+      const firstOutput = children[0];
+
+      const cleared = JSON.parse(
+        await handleGoogleMeetNodeHostCommand(
+          JSON.stringify({
+            action: "clearAudio",
+            bridgeId: start.bridgeId,
+          }),
+        ),
+      );
+
+      expect(cleared).toEqual({ bridgeId: start.bridgeId, ok: true, clearCount: 1 });
+      expect(children).toHaveLength(3);
+      expect(firstOutput?.kill).toHaveBeenCalledWith("SIGTERM");
+
+      firstOutput?.emit("error", new Error("stale output failed after clear"));
+      firstOutput?.emit("exit", 0, "SIGTERM");
+
+      const status = JSON.parse(
+        await handleGoogleMeetNodeHostCommand(
+          JSON.stringify({
+            action: "status",
+            bridgeId: start.bridgeId,
+          }),
+        ),
+      );
+
+      expect(status.bridge.bridgeId).toBe(start.bridgeId);
+      expect(status.bridge.closed).toBe(false);
+      expect(status.bridge.clearCount).toBe(1);
+      expect(typeof status.bridge.createdAt).toBe("string");
+
+      const audio = Buffer.from([1, 2, 3]);
+      await handleGoogleMeetNodeHostCommand(
+        JSON.stringify({
+          action: "pushAudio",
+          bridgeId: start.bridgeId,
+          base64: audio.toString("base64"),
+        }),
+      );
+
+      expect(children[2]?.stdin?.write).toHaveBeenCalledWith(audio);
+      expect(firstOutput?.stdin?.write).not.toHaveBeenCalled();
+
+      await handleGoogleMeetNodeHostCommand(
+        JSON.stringify({
+          action: "stop",
+          bridgeId: start.bridgeId,
+        }),
+      );
+    } finally {
+      Object.defineProperty(process, "platform", { configurable: true, value: originalPlatform });
+    }
+  });
+
+  it("lists active bridge sessions and hides closed sessions", async () => {
+    const originalPlatform = process.platform;
+    children.length = 0;
+
+    Object.defineProperty(process, "platform", { configurable: true, value: "darwin" });
+    try {
+      const start = JSON.parse(
+        await handleGoogleMeetNodeHostCommand(
+          JSON.stringify({
+            action: "start",
+            url: "https://meet.google.com/abc-defg-hij?authuser=1",
+            mode: "realtime",
+            launch: false,
+            audioInputCommand: ["mock-rec"],
+            audioOutputCommand: ["mock-play"],
+          }),
+        ),
+      );
+
+      expect(typeof start.bridgeId).toBe("string");
+      expect(start.bridgeId.length).toBeGreaterThan(0);
+      expect(start).toEqual({
+        audioBridge: { type: "node-command-pair" },
+        bridgeId: start.bridgeId,
+        launched: false,
+      });
+
+      const activeList = JSON.parse(
+        await handleGoogleMeetNodeHostCommand(
+          JSON.stringify({
+            action: "list",
+            url: "https://meet.google.com/abc-defg-hij",
+            mode: "realtime",
+          }),
+        ),
+      );
+
+      expect(activeList.bridges).toHaveLength(1);
+      expect(activeList.bridges[0]?.bridgeId).toBe(start.bridgeId);
+      expect(activeList.bridges[0]?.closed).toBe(false);
+      expect(activeList.bridges[0]?.mode).toBe("realtime");
+      expect(activeList.bridges[0]?.url).toBe("https://meet.google.com/abc-defg-hij?authuser=1");
+      expect(typeof activeList.bridges[0]?.createdAt).toBe("string");
+
+      children[1]?.emit("exit", 0, null);
+
+      const afterExitList = JSON.parse(
+        await handleGoogleMeetNodeHostCommand(
+          JSON.stringify({
+            action: "list",
+            url: "https://meet.google.com/abc-defg-hij",
+            mode: "realtime",
+          }),
+        ),
+      );
+
+      expect(afterExitList).toEqual({ bridges: [] });
+
+      const stopped = JSON.parse(
+        await handleGoogleMeetNodeHostCommand(
+          JSON.stringify({
+            action: "stopByUrl",
+            url: "https://meet.google.com/abc-defg-hij",
+            mode: "realtime",
+          }),
+        ),
+      );
+
+      expect(stopped).toEqual({ ok: true, stopped: 0 });
+    } finally {
+      Object.defineProperty(process, "platform", { configurable: true, value: originalPlatform });
+    }
+  });
+});