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/clickclack/src/gateway.test.ts

@@ -0,0 +1,295 @@
+// Clickclack tests cover gateway plugin behavior.
+import { EventEmitter } from "node:events";
+import type { ChannelGatewayContext } from "openclaw/plugin-sdk/channel-contract";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { ResolvedClickClackAccount } from "./types.js";
+
+class FakeSocket extends EventEmitter {
+  emitErrorOnClose = false;
+
+  close = vi.fn(() => {
+    if (this.emitErrorOnClose) {
+      this.emit("error", new Error("socket closed while connecting"));
+    }
+    this.emit("close");
+  });
+}
+
+const mocks = vi.hoisted(() => ({
+  client: {
+    me: vi.fn(),
+    events: vi.fn(),
+    websocket: vi.fn(),
+    channelMessages: vi.fn(),
+    directMessages: vi.fn(),
+    thread: vi.fn(),
+  },
+  handleClickClackInbound: vi.fn(),
+  resolveClickClackInboundAccess: vi.fn(),
+  resolveWorkspaceId: vi.fn(),
+}));
+
+vi.mock("./access.js", () => ({
+  resolveClickClackInboundAccess: mocks.resolveClickClackInboundAccess,
+}));
+
+vi.mock("./http-client.js", () => ({
+  createClickClackClient: vi.fn(() => mocks.client),
+}));
+
+vi.mock("./inbound.js", () => ({
+  handleClickClackInbound: mocks.handleClickClackInbound,
+}));
+
+vi.mock("./resolve.js", () => ({
+  resolveWorkspaceId: mocks.resolveWorkspaceId,
+}));
+
+import { startClickClackGatewayAccount } from "./gateway.js";
+
+function createGatewayContext(
+  abortSignal: AbortSignal,
+): ChannelGatewayContext<ResolvedClickClackAccount> {
+  const setStatus = vi.fn();
+  const log = { warn: vi.fn(), info: vi.fn(), error: vi.fn(), debug: vi.fn() };
+  return {
+    cfg: {
+      channels: {
+        clickclack: {
+          baseUrl: "https://clickclack.example",
+          token: "test-token",
+          workspace: "main",
+          reconnectMs: 1,
+        },
+      },
+    } as ChannelGatewayContext<ResolvedClickClackAccount>["cfg"],
+    accountId: "default",
+    account: {} as ResolvedClickClackAccount,
+    runtime: {} as ChannelGatewayContext<ResolvedClickClackAccount>["runtime"],
+    abortSignal,
+    log,
+    getStatus: () =>
+      ({ accountId: "default" }) as ReturnType<
+        ChannelGatewayContext<ResolvedClickClackAccount>["getStatus"]
+      >,
+    setStatus,
+  };
+}
+
+describe("ClickClack gateway", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.client.me.mockResolvedValue({
+      id: "bot-user",
+      display_name: "Bot",
+      handle: "bot",
+      avatar_url: "",
+      created_at: "2026-01-01T00:00:00.000Z",
+    });
+    mocks.client.events.mockResolvedValue([]);
+    mocks.resolveClickClackInboundAccess.mockResolvedValue({
+      shouldDispatch: true,
+      commandAuthorized: true,
+    });
+    mocks.resolveWorkspaceId.mockResolvedValue("workspace-1");
+    mocks.client.channelMessages.mockResolvedValue([
+      {
+        id: "msg-1",
+        workspace_id: "workspace-1",
+        channel_id: "chan-1",
+        author_id: "human-1",
+        thread_root_id: "msg-1",
+        body: "hello",
+        body_format: "markdown",
+        created_at: "2026-01-01T00:00:00.000Z",
+        author: {
+          id: "human-1",
+          kind: "human",
+          display_name: "Human",
+          handle: "human",
+          avatar_url: "",
+          created_at: "2026-01-01T00:00:00.000Z",
+        },
+      },
+    ]);
+  });
+
+  it("skips malformed websocket frames without stopping the monitor", async () => {
+    const socket = new FakeSocket();
+    mocks.client.websocket.mockReturnValue(socket);
+    const abort = new AbortController();
+    const ctx = createGatewayContext(abort.signal);
+    let runError: unknown;
+    const run = startClickClackGatewayAccount(ctx).catch((error: unknown) => {
+      runError = error;
+    });
+
+    await vi.waitFor(() => expect(mocks.client.websocket).toHaveBeenCalledTimes(1));
+
+    socket.emit("message", Buffer.from("{not json"));
+    await new Promise((resolve) => {
+      setImmediate(resolve);
+    });
+    expect(runError).toBeUndefined();
+    expect(ctx.log?.warn).toHaveBeenCalledWith(
+      "[default] skipped malformed ClickClack websocket event",
+    );
+
+    socket.emit(
+      "message",
+      Buffer.from(
+        JSON.stringify({
+          id: "evt-1",
+          cursor: "cursor-1",
+          type: "message.created",
+          workspace_id: "workspace-1",
+          channel_id: "chan-1",
+          seq: 2,
+          created_at: "2026-01-01T00:00:00.000Z",
+          payload: { message_id: "msg-1", author_id: "human-1" },
+        }),
+      ),
+    );
+
+    await vi.waitFor(() => expect(mocks.handleClickClackInbound).toHaveBeenCalledTimes(1));
+    expect(mocks.handleClickClackInbound.mock.calls[0]?.[0].access).toEqual({
+      shouldDispatch: true,
+      commandAuthorized: true,
+    });
+    abort.abort();
+    await run;
+    expect(runError).toBeUndefined();
+  });
+
+  it("drops messages denied by ClickClack sender access before inbound handling", async () => {
+    const socket = new FakeSocket();
+    mocks.client.websocket.mockReturnValue(socket);
+    mocks.resolveClickClackInboundAccess.mockResolvedValue({
+      shouldDispatch: false,
+      commandAuthorized: false,
+    });
+    const abort = new AbortController();
+    const ctx = createGatewayContext(abort.signal);
+    const run = startClickClackGatewayAccount(ctx);
+
+    await vi.waitFor(() => expect(mocks.client.websocket).toHaveBeenCalledTimes(1));
+
+    socket.emit(
+      "message",
+      Buffer.from(
+        JSON.stringify({
+          id: "evt-1",
+          cursor: "cursor-1",
+          type: "message.created",
+          workspace_id: "workspace-1",
+          channel_id: "chan-1",
+          seq: 2,
+          created_at: "2026-01-01T00:00:00.000Z",
+          payload: { message_id: "msg-1", author_id: "human-1" },
+        }),
+      ),
+    );
+
+    await vi.waitFor(() => expect(mocks.resolveClickClackInboundAccess).toHaveBeenCalledTimes(1));
+    expect(mocks.handleClickClackInbound).not.toHaveBeenCalled();
+    abort.abort();
+    await run;
+  });
+
+  it("reconnects after ClickClack websocket errors", async () => {
+    const firstSocket = new FakeSocket();
+    firstSocket.emitErrorOnClose = true;
+    const secondSocket = new FakeSocket();
+    mocks.client.websocket.mockReturnValueOnce(firstSocket).mockReturnValueOnce(secondSocket);
+    const abort = new AbortController();
+    const ctx = createGatewayContext(abort.signal);
+    const run = startClickClackGatewayAccount(ctx);
+
+    await vi.waitFor(() => expect(mocks.client.websocket).toHaveBeenCalledTimes(1));
+
+    firstSocket.emit("error", new Error("gateway dropped"));
+
+    await vi.waitFor(() => expect(mocks.client.websocket).toHaveBeenCalledTimes(2));
+    expect(ctx.log?.warn).toHaveBeenCalledWith(
+      "[default] ClickClack websocket error; reconnecting: gateway dropped",
+    );
+    abort.abort();
+    await run;
+  });
+
+  it("does not log reconnect warnings when abort closes a connecting websocket", async () => {
+    const socket = new FakeSocket();
+    socket.emitErrorOnClose = true;
+    mocks.client.websocket.mockReturnValue(socket);
+    const abort = new AbortController();
+    const ctx = createGatewayContext(abort.signal);
+    const run = startClickClackGatewayAccount(ctx);
+
+    await vi.waitFor(() => expect(mocks.client.websocket).toHaveBeenCalledTimes(1));
+
+    abort.abort();
+    await run;
+
+    expect(ctx.log?.warn).not.toHaveBeenCalledWith(
+      "[default] ClickClack websocket error; reconnecting: socket closed while connecting",
+    );
+    expect(mocks.client.websocket).toHaveBeenCalledTimes(1);
+  });
+
+  it("clears running status when backlog polling fails", async () => {
+    mocks.client.events.mockRejectedValue(new Error("clickclack unavailable"));
+    const abort = new AbortController();
+    const ctx = createGatewayContext(abort.signal);
+
+    await expect(startClickClackGatewayAccount(ctx)).rejects.toThrow("clickclack unavailable");
+
+    expect(ctx.setStatus).toHaveBeenCalledWith({
+      accountId: "default",
+      running: true,
+      configured: true,
+      enabled: true,
+      baseUrl: "https://clickclack.example",
+    });
+    expect(ctx.setStatus).toHaveBeenLastCalledWith({
+      accountId: "default",
+      running: false,
+    });
+  });
+
+  it("wraps non-Error ws message rejections with the original value in the message", async () => {
+    const socket = new FakeSocket();
+    mocks.client.websocket.mockReturnValue(socket);
+    const rejection = { code: "ECONNRESET", retryable: true };
+    mocks.resolveClickClackInboundAccess.mockRejectedValue(rejection);
+    const abort = new AbortController();
+    const ctx = createGatewayContext(abort.signal);
+    const run = startClickClackGatewayAccount(ctx);
+
+    await vi.waitFor(() => expect(mocks.client.websocket).toHaveBeenCalledTimes(1));
+
+    socket.emit(
+      "message",
+      Buffer.from(
+        JSON.stringify({
+          id: "evt-1",
+          cursor: "cursor-1",
+          type: "message.created",
+          workspace_id: "workspace-1",
+          channel_id: "chan-1",
+          seq: 2,
+          created_at: "2026-01-01T00:00:00.000Z",
+          payload: { message_id: "msg-1", author_id: "human-1" },
+        }),
+      ),
+    );
+
+    await expect(run).rejects.toMatchObject({
+      message: 'ClickClack ws message failed: {"code":"ECONNRESET","retryable":true}',
+      cause: rejection,
+    });
+    expect(ctx.setStatus).toHaveBeenLastCalledWith({
+      accountId: "default",
+      running: false,
+    });
+  });
+});