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/discord/src/channel.message-adapter.test.ts

@@ -0,0 +1,269 @@
+// Discord tests cover channel.message adapter plugin behavior.
+import {
+  verifyChannelMessageAdapterCapabilityProofs,
+  verifyChannelMessageLiveCapabilityAdapterProofs,
+  verifyChannelMessageLiveFinalizerProofs,
+} from "openclaw/plugin-sdk/channel-outbound";
+import { beforeAll, beforeEach, describe, expect, it } from "vitest";
+import {
+  createDiscordOutboundHoisted,
+  installDiscordOutboundModuleSpies,
+  resetDiscordOutboundMocks,
+} from "./outbound-adapter.test-harness.js";
+
+const hoisted = createDiscordOutboundHoisted();
+await installDiscordOutboundModuleSpies(hoisted);
+
+let discordPlugin: typeof import("./channel.js").discordPlugin;
+
+beforeAll(async () => {
+  ({ discordPlugin } = await import("./channel.js"));
+});
+
+type DiscordMessageAdapter = NonNullable<typeof discordPlugin.message>;
+type DiscordMessageSender = NonNullable<DiscordMessageAdapter["send"]>;
+
+function requireDiscordMessageAdapter(): DiscordMessageAdapter {
+  const adapter = discordPlugin.message;
+  if (!adapter) {
+    throw new Error("Expected discord plugin to expose a channel message adapter");
+  }
+  return adapter;
+}
+
+function requireTextSender(
+  adapter: DiscordMessageAdapter,
+): NonNullable<DiscordMessageSender["text"]> {
+  const text = adapter.send?.text;
+  if (!text) {
+    throw new Error("Expected discord message adapter text sender");
+  }
+  return text;
+}
+
+function requireMediaSender(
+  adapter: DiscordMessageAdapter,
+): NonNullable<DiscordMessageSender["media"]> {
+  const media = adapter.send?.media;
+  if (!media) {
+    throw new Error("Expected discord message adapter media sender");
+  }
+  return media;
+}
+
+function requirePayloadSender(
+  adapter: DiscordMessageAdapter,
+): NonNullable<DiscordMessageSender["payload"]> {
+  const payload = adapter.send?.payload;
+  if (!payload) {
+    throw new Error("Expected discord message adapter payload sender");
+  }
+  return payload;
+}
+
+function requirePollSender(
+  adapter: DiscordMessageAdapter,
+): NonNullable<DiscordMessageSender["poll"]> {
+  const poll = adapter.send?.poll;
+  if (!poll) {
+    throw new Error("Expected discord message adapter poll sender");
+  }
+  return poll;
+}
+
+describe("discord channel message adapter", () => {
+  beforeEach(() => {
+    resetDiscordOutboundMocks(hoisted);
+  });
+
+  it("backs declared durable-final capabilities with outbound send proofs", async () => {
+    const adapter = requireDiscordMessageAdapter();
+    const sendText = requireTextSender(adapter);
+    const sendMedia = requireMediaSender(adapter);
+    const sendPayload = requirePayloadSender(adapter);
+    const sendPoll = requirePollSender(adapter);
+
+    const proveText = async () => {
+      resetDiscordOutboundMocks(hoisted);
+      const result = await sendText({
+        cfg: {},
+        to: "channel:123456",
+        text: "hello",
+        accountId: "default",
+      });
+      expect(hoisted.sendMessageDiscordMock).toHaveBeenLastCalledWith("channel:123456", "hello", {
+        verbose: false,
+        replyTo: undefined,
+        accountId: "default",
+        silent: undefined,
+        cfg: {},
+        textLimit: undefined,
+        maxLinesPerMessage: undefined,
+        tableMode: undefined,
+        chunkMode: undefined,
+      });
+      expect(result.receipt.platformMessageIds).toEqual(["msg-1"]);
+      expect(result.receipt.parts[0]?.kind).toBe("text");
+    };
+
+    const proveMedia = async () => {
+      resetDiscordOutboundMocks(hoisted);
+      const result = await sendMedia({
+        cfg: {},
+        to: "channel:123456",
+        text: "caption",
+        mediaUrl: "https://example.com/a.png",
+        accountId: "default",
+      });
+      expect(hoisted.sendMessageDiscordMock).toHaveBeenLastCalledWith("channel:123456", "caption", {
+        verbose: false,
+        mediaUrl: "https://example.com/a.png",
+        mediaAccess: undefined,
+        mediaLocalRoots: undefined,
+        mediaReadFile: undefined,
+        replyTo: undefined,
+        accountId: "default",
+        silent: undefined,
+        cfg: {},
+        textLimit: undefined,
+        maxLinesPerMessage: undefined,
+        tableMode: undefined,
+        chunkMode: undefined,
+      });
+      expect(result.receipt.parts[0]?.kind).toBe("media");
+    };
+
+    const provePayload = async () => {
+      resetDiscordOutboundMocks(hoisted);
+      const result = await sendPayload({
+        cfg: {},
+        to: "channel:123456",
+        text: "payload",
+        payload: { text: "payload" },
+        accountId: "default",
+      });
+      expect(hoisted.sendMessageDiscordMock).toHaveBeenLastCalledWith(
+        "channel:123456",
+        "payload",
+        expect.objectContaining({
+          verbose: false,
+          replyTo: undefined,
+          accountId: "default",
+          silent: undefined,
+          cfg: {},
+          textLimit: undefined,
+          maxLinesPerMessage: undefined,
+          tableMode: undefined,
+          chunkMode: undefined,
+          onDeliveryResult: expect.any(Function),
+        }),
+      );
+      expect(result.receipt.platformMessageIds).toEqual(["msg-1"]);
+    };
+
+    const provePoll = async () => {
+      resetDiscordOutboundMocks(hoisted);
+      const result = await sendPoll({
+        cfg: {},
+        to: "channel:123456",
+        poll: { question: "Ship?", options: ["Yes", "No"] },
+        accountId: "default",
+        silent: true,
+      });
+      expect(hoisted.sendPollDiscordMock).toHaveBeenLastCalledWith(
+        "channel:123456",
+        { question: "Ship?", options: ["Yes", "No"] },
+        {
+          accountId: "default",
+          silent: true,
+          cfg: {},
+        },
+      );
+      expect(result.receipt.parts[0]?.kind).toBe("poll");
+    };
+
+    const proveReplyThreadSilent = async () => {
+      resetDiscordOutboundMocks(hoisted);
+      const result = await sendText({
+        cfg: {},
+        to: "channel:parent-1",
+        text: "threaded",
+        accountId: "default",
+        replyToId: "reply-1",
+        threadId: "thread-1",
+        silent: true,
+      });
+      expect(hoisted.sendMessageDiscordMock).toHaveBeenLastCalledWith(
+        "channel:thread-1",
+        "threaded",
+        {
+          verbose: false,
+          accountId: "default",
+          replyTo: "reply-1",
+          silent: true,
+          cfg: {},
+          textLimit: undefined,
+          maxLinesPerMessage: undefined,
+          tableMode: undefined,
+          chunkMode: undefined,
+        },
+      );
+      expect(result.receipt.threadId).toBe("thread-1");
+      expect(result.receipt.replyToId).toBe("reply-1");
+    };
+
+    await verifyChannelMessageAdapterCapabilityProofs({
+      adapterName: "discordMessageAdapter",
+      adapter,
+      proofs: {
+        text: proveText,
+        media: proveMedia,
+        poll: provePoll,
+        payload: provePayload,
+        silent: proveReplyThreadSilent,
+        replyTo: proveReplyThreadSilent,
+        thread: proveReplyThreadSilent,
+        messageSendingHooks: () => {
+          expect(sendText).toBeTypeOf("function");
+        },
+      },
+    });
+  });
+
+  it("backs declared live preview finalizer capabilities with adapter proofs", async () => {
+    const adapter = requireDiscordMessageAdapter();
+    const sendText = requireTextSender(adapter);
+
+    await verifyChannelMessageLiveCapabilityAdapterProofs({
+      adapterName: "discordMessageAdapter",
+      adapter,
+      proofs: {
+        draftPreview: () => {
+          expect(adapter.live?.finalizer?.capabilities?.discardPending).toBe(true);
+        },
+        previewFinalization: () => {
+          expect(adapter.live?.finalizer?.capabilities?.finalEdit).toBe(true);
+        },
+        progressUpdates: () => {
+          expect(adapter.live?.capabilities?.draftPreview).toBe(true);
+        },
+      },
+    });
+
+    await verifyChannelMessageLiveFinalizerProofs({
+      adapterName: "discordMessageAdapter",
+      adapter,
+      proofs: {
+        finalEdit: () => {
+          expect(adapter.live?.capabilities?.previewFinalization).toBe(true);
+        },
+        normalFallback: () => {
+          expect(sendText).toBeTypeOf("function");
+        },
+        discardPending: () => {
+          expect(adapter.live?.capabilities?.draftPreview).toBe(true);
+        },
+      },
+    });
+  });
+});