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

@@ -0,0 +1,441 @@
+// Discord tests cover accounts plugin behavior.
+import type { OpenClawConfig } from "openclaw/plugin-sdk/config-contracts";
+import {
+  clearRuntimeConfigSnapshot,
+  setRuntimeConfigSnapshot,
+} from "openclaw/plugin-sdk/runtime-config-snapshot";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+  createDiscordActionGate,
+  isDiscordAccountEnabledForRuntime,
+  listDiscordAccountIds,
+  listEnabledDiscordAccounts,
+  resolveDefaultDiscordAccountId,
+  resolveDiscordAccount,
+  resolveDiscordAccountDisabledReason,
+  resolveDiscordMaxLinesPerMessage,
+} from "./accounts.js";
+
+afterEach(() => {
+  clearRuntimeConfigSnapshot();
+  vi.unstubAllEnvs();
+});
+
+const defaultAccountOmissionCases = [
+  {
+    name: "resolveDiscordAccount",
+    assert: () => {
+      const resolved = resolveDiscordAccount({
+        cfg: {
+          channels: {
+            discord: {
+              defaultAccount: "work",
+              accounts: {
+                work: { token: "token-work", name: "Work" },
+              },
+            },
+          },
+        },
+      });
+
+      expect(resolved.accountId).toBe("work");
+      expect(resolved.name).toBe("Work");
+      expect(resolved.token).toBe("token-work");
+    },
+  },
+  {
+    name: "createDiscordActionGate",
+    assert: () => {
+      const gate = createDiscordActionGate({
+        cfg: {
+          channels: {
+            discord: {
+              actions: { reactions: false },
+              defaultAccount: "work",
+              accounts: {
+                work: {
+                  token: "token-work",
+                  actions: { reactions: true },
+                },
+              },
+            },
+          },
+        },
+      });
+
+      expect(gate("reactions")).toBe(true);
+    },
+  },
+];
+
+describe("Discord defaultAccount omission contract", () => {
+  it.each(defaultAccountOmissionCases)(
+    "$name uses configured defaultAccount when accountId is omitted",
+    ({ assert }) => {
+      assert();
+    },
+  );
+
+  it("keeps the implicit default account when named accounts are added to top-level credentials", () => {
+    const cfg = {
+      channels: {
+        discord: {
+          token: "token-default",
+          accounts: {
+            work: {
+              enabled: false,
+              token: "token-work",
+            },
+          },
+        },
+      },
+    } as OpenClawConfig;
+
+    expect(listDiscordAccountIds(cfg)).toEqual(["default", "work"]);
+    expect(resolveDefaultDiscordAccountId(cfg)).toBe("default");
+    expect(listEnabledDiscordAccounts(cfg).map((account) => account.accountId)).toEqual([
+      "default",
+    ]);
+  });
+});
+
+describe("resolveDiscordAccount allowFrom precedence", () => {
+  it("prefers accounts.default.allowFrom over top-level for default account", () => {
+    const resolved = resolveDiscordAccount({
+      cfg: {
+        channels: {
+          discord: {
+            allowFrom: ["top"],
+            accounts: {
+              default: { allowFrom: ["default"], token: "token-default" },
+            },
+          },
+        },
+      },
+      accountId: "default",
+    });
+
+    expect(resolved.config.allowFrom).toEqual(["default"]);
+  });
+
+  it("falls back to top-level allowFrom for named account without override", () => {
+    const resolved = resolveDiscordAccount({
+      cfg: {
+        channels: {
+          discord: {
+            allowFrom: ["top"],
+            accounts: {
+              work: { token: "token-work" },
+            },
+          },
+        },
+      },
+      accountId: "work",
+    });
+
+    expect(resolved.config.allowFrom).toEqual(["top"]);
+  });
+
+  it("does not inherit default account allowFrom for named account when top-level is absent", () => {
+    const resolved = resolveDiscordAccount({
+      cfg: {
+        channels: {
+          discord: {
+            accounts: {
+              default: { allowFrom: ["default"], token: "token-default" },
+              work: { token: "token-work" },
+            },
+          },
+        },
+      },
+      accountId: "work",
+    });
+
+    expect(resolved.config.allowFrom).toBeUndefined();
+  });
+});
+
+describe("resolveDiscordAccount botLoopProtection precedence", () => {
+  it("merges account overrides over Discord channel defaults field-by-field", () => {
+    const resolved = resolveDiscordAccount({
+      cfg: {
+        channels: {
+          discord: {
+            botLoopProtection: {
+              maxEventsPerWindow: 4,
+              windowSeconds: 60,
+              cooldownSeconds: 30,
+            },
+            accounts: {
+              work: {
+                token: "token-work",
+                botLoopProtection: {
+                  windowSeconds: 10,
+                },
+              },
+            },
+          },
+        },
+      },
+      accountId: "work",
+    });
+
+    expect(resolved.config.botLoopProtection).toEqual({
+      maxEventsPerWindow: 4,
+      windowSeconds: 10,
+      cooldownSeconds: 30,
+    });
+  });
+});
+
+describe("resolveDiscordAccount agentComponents precedence", () => {
+  it("preserves a disabled channel default when an account only overrides ttlMs", () => {
+    const resolved = resolveDiscordAccount({
+      cfg: {
+        channels: {
+          discord: {
+            agentComponents: {
+              enabled: false,
+            },
+            accounts: {
+              work: {
+                token: "token-work",
+                agentComponents: {
+                  ttlMs: 120_000,
+                },
+              },
+            },
+          },
+        },
+      },
+      accountId: "work",
+    });
+
+    expect(resolved.config.agentComponents).toEqual({
+      enabled: false,
+      ttlMs: 120_000,
+    });
+  });
+
+  it("preserves channel ttlMs when an account only overrides enabled", () => {
+    const resolved = resolveDiscordAccount({
+      cfg: {
+        channels: {
+          discord: {
+            agentComponents: {
+              enabled: false,
+              ttlMs: 180_000,
+            },
+            accounts: {
+              work: {
+                token: "token-work",
+                agentComponents: {
+                  enabled: true,
+                },
+              },
+            },
+          },
+        },
+      },
+      accountId: "work",
+    });
+
+    expect(resolved.config.agentComponents).toEqual({
+      enabled: true,
+      ttlMs: 180_000,
+    });
+  });
+});
+
+describe("resolveDiscordMaxLinesPerMessage", () => {
+  it("falls back to merged root discord maxLinesPerMessage when runtime config omits it", () => {
+    const resolved = resolveDiscordMaxLinesPerMessage({
+      cfg: {
+        channels: {
+          discord: {
+            maxLinesPerMessage: 120,
+            accounts: {
+              default: { token: "token-default" },
+            },
+          },
+        },
+      },
+      discordConfig: {},
+      accountId: "default",
+    });
+
+    expect(resolved).toBe(120);
+  });
+
+  it("prefers explicit runtime discord maxLinesPerMessage over merged config", () => {
+    const resolved = resolveDiscordMaxLinesPerMessage({
+      cfg: {
+        channels: {
+          discord: {
+            maxLinesPerMessage: 120,
+            accounts: {
+              default: { token: "token-default", maxLinesPerMessage: 80 },
+            },
+          },
+        },
+      },
+      discordConfig: { maxLinesPerMessage: 55 },
+      accountId: "default",
+    });
+
+    expect(resolved).toBe(55);
+  });
+
+  it("uses per-account discord maxLinesPerMessage over the root value when runtime config omits it", () => {
+    const resolved = resolveDiscordMaxLinesPerMessage({
+      cfg: {
+        channels: {
+          discord: {
+            maxLinesPerMessage: 120,
+            accounts: {
+              work: { token: "token-work", maxLinesPerMessage: 80 },
+            },
+          },
+        },
+      },
+      discordConfig: {},
+      accountId: "work",
+    });
+
+    expect(resolved).toBe(80);
+  });
+});
+
+describe("Discord duplicate-token account filtering", () => {
+  it("keeps the config-token account over default env fallback when tokens collide", () => {
+    vi.stubEnv("DISCORD_BOT_TOKEN", "same-token");
+    const cfg = {
+      channels: {
+        discord: {
+          accounts: {
+            work: {
+              token: "same-token",
+            },
+          },
+        },
+      },
+    };
+
+    const defaultAccount = resolveDiscordAccount({ cfg, accountId: "default" });
+    const workAccount = resolveDiscordAccount({ cfg, accountId: "work" });
+
+    expect(isDiscordAccountEnabledForRuntime(defaultAccount, cfg)).toBe(false);
+    expect(resolveDiscordAccountDisabledReason(defaultAccount, cfg)).toBe(
+      'duplicate bot token; using account "work"',
+    );
+    expect(isDiscordAccountEnabledForRuntime(workAccount, cfg)).toBe(true);
+    expect(listEnabledDiscordAccounts(cfg).map((account) => account.accountId)).toEqual(["work"]);
+  });
+
+  it("keeps the first enabled account when duplicate tokens have the same source", () => {
+    const cfg = {
+      channels: {
+        discord: {
+          accounts: {
+            first: {
+              token: "same-token",
+            },
+            second: {
+              token: "same-token",
+            },
+          },
+        },
+      },
+    };
+
+    const firstAccount = resolveDiscordAccount({ cfg, accountId: "first" });
+    const secondAccount = resolveDiscordAccount({ cfg, accountId: "second" });
+
+    expect(isDiscordAccountEnabledForRuntime(firstAccount, cfg)).toBe(true);
+    expect(isDiscordAccountEnabledForRuntime(secondAccount, cfg)).toBe(false);
+    expect(resolveDiscordAccountDisabledReason(secondAccount, cfg)).toBe(
+      'duplicate bot token; using account "first"',
+    );
+    expect(listEnabledDiscordAccounts(cfg).map((account) => account.accountId)).toEqual(["first"]);
+  });
+
+  it("does not let disabled duplicate-token accounts suppress enabled accounts", () => {
+    const cfg = {
+      channels: {
+        discord: {
+          accounts: {
+            disabled: {
+              enabled: false,
+              token: "same-token",
+            },
+            active: {
+              token: "same-token",
+            },
+          },
+        },
+      },
+    };
+
+    const activeAccount = resolveDiscordAccount({ cfg, accountId: "active" });
+
+    expect(isDiscordAccountEnabledForRuntime(activeAccount, cfg)).toBe(true);
+    expect(listEnabledDiscordAccounts(cfg).map((account) => account.accountId)).toEqual(["active"]);
+  });
+});
+
+describe("resolveDiscordAccount runtime config selection", () => {
+  it("resolves named account SecretRefs from the active runtime snapshot", () => {
+    const sourceCfg = {
+      channels: {
+        discord: {
+          defaultAccount: "work",
+          accounts: {
+            work: {
+              name: "Work",
+              token: { source: "env", provider: "default", id: "DISCORD_WORK_TOKEN" },
+            },
+          },
+        },
+      },
+    } as unknown as OpenClawConfig;
+    const runtimeCfg = {
+      channels: {
+        discord: {
+          defaultAccount: "work",
+          accounts: {
+            work: {
+              name: "Work",
+              token: "Bot runtime-work-token",
+            },
+          },
+        },
+      },
+    } as OpenClawConfig;
+    setRuntimeConfigSnapshot(runtimeCfg, sourceCfg);
+
+    const resolved = resolveDiscordAccount({ cfg: sourceCfg });
+
+    expect(resolved.accountId).toBe("work");
+    expect(resolved.token).toBe("runtime-work-token");
+    expect(resolved.tokenSource).toBe("config");
+    expect(resolved.tokenStatus).toBe("available");
+  });
+
+  it("preserves configured unavailable tokens without falling through to env", () => {
+    vi.stubEnv("DISCORD_BOT_TOKEN", "env-token");
+    const resolved = resolveDiscordAccount({
+      cfg: {
+        channels: {
+          discord: {
+            token: { source: "env", provider: "default", id: "DISCORD_BOT_TOKEN" },
+          },
+        },
+      } as unknown as OpenClawConfig,
+      accountId: "default",
+    });
+
+    expect(resolved.token).toBe("");
+    expect(resolved.tokenSource).toBe("config");
+    expect(resolved.tokenStatus).toBe("configured_unavailable");
+  });
+});