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/slack/src/monitor.test-helpers.ts

@@ -0,0 +1,374 @@
+// Slack helper module supports monitor helpers behavior.
+import type { ChannelRuntimeSurface } from "openclaw/plugin-sdk/channel-contract";
+import type { RuntimeEnv } from "openclaw/plugin-sdk/runtime-env";
+import { vi } from "vitest";
+import type { Mock } from "vitest";
+import { clearSlackInboundDeliveryStateForTest } from "./monitor/inbound-delivery-state.js";
+
+type SlackHandler = (args: unknown) => Promise<void>;
+type SlackMiddleware = (args: { next: () => Promise<void> } & Record<string, unknown>) => unknown;
+type SlackProviderMonitor = (params: {
+  botToken: string;
+  appToken: string;
+  abortSignal: AbortSignal;
+  config?: Record<string, unknown>;
+  channelRuntime?: ChannelRuntimeSurface;
+  runtime?: RuntimeEnv;
+}) => Promise<unknown>;
+
+type SlackTestState = {
+  config: Record<string, unknown>;
+  appStartMock: Mock<(...args: unknown[]) => Promise<unknown>>;
+  appStopMock: Mock<(...args: unknown[]) => Promise<unknown>>;
+  sendMock: Mock<(...args: unknown[]) => Promise<unknown>>;
+  replyMock: Mock<(...args: unknown[]) => unknown>;
+  updateLastRouteMock: Mock<(...args: unknown[]) => unknown>;
+  reactMock: Mock<(...args: unknown[]) => unknown>;
+  reactionAddMock: Mock<(...args: unknown[]) => unknown>;
+  reactionRemoveMock: Mock<(...args: unknown[]) => unknown>;
+  readAllowFromStoreMock: Mock<(...args: unknown[]) => Promise<unknown>>;
+  upsertPairingRequestMock: Mock<(...args: unknown[]) => Promise<unknown>>;
+  resolveSlackUserAllowlistMock: Mock<
+    (params: { entries: string[] }) => Promise<Array<{ input: string; resolved: boolean }>>
+  >;
+};
+
+const slackTestState: SlackTestState = vi.hoisted(() => ({
+  config: {} as Record<string, unknown>,
+  appStartMock: vi.fn(),
+  appStopMock: vi.fn(),
+  sendMock: vi.fn(),
+  replyMock: vi.fn(),
+  updateLastRouteMock: vi.fn(),
+  reactMock: vi.fn(),
+  reactionAddMock: vi.fn(),
+  reactionRemoveMock: vi.fn(),
+  readAllowFromStoreMock: vi.fn(),
+  upsertPairingRequestMock: vi.fn(),
+  resolveSlackUserAllowlistMock: vi.fn(),
+}));
+
+export const getSlackTestState = (): SlackTestState => slackTestState;
+
+type SlackClient = {
+  auth: { test: Mock<(...args: unknown[]) => Promise<Record<string, unknown>>> };
+  conversations: {
+    info: Mock<(...args: unknown[]) => Promise<Record<string, unknown>>>;
+    replies: Mock<(...args: unknown[]) => Promise<Record<string, unknown>>>;
+    history: Mock<(...args: unknown[]) => Promise<Record<string, unknown>>>;
+  };
+  users: {
+    info: Mock<(...args: unknown[]) => Promise<{ user: { profile: { display_name: string } } }>>;
+  };
+  assistant: {
+    threads: {
+      setStatus: Mock<(...args: unknown[]) => Promise<{ ok: boolean }>>;
+    };
+  };
+  reactions: {
+    add: (...args: unknown[]) => unknown;
+    remove: (...args: unknown[]) => unknown;
+  };
+};
+
+export const getSlackHandlers = () => ensureSlackTestRuntime().handlers;
+
+export const getSlackClient = () => ensureSlackTestRuntime().client;
+
+function ensureSlackTestRuntime(): {
+  handlers: Map<string, SlackHandler>;
+  client: SlackClient;
+} {
+  const globalState = globalThis as {
+    __slackHandlers?: Map<string, SlackHandler>;
+    __slackClient?: SlackClient;
+  };
+  if (!globalState["__slackHandlers"]) {
+    globalState["__slackHandlers"] = new Map<string, SlackHandler>();
+  }
+  if (!globalState["__slackClient"]) {
+    globalState["__slackClient"] = {
+      auth: { test: vi.fn().mockResolvedValue({ user_id: "bot-user", bot_id: "bot-id" }) },
+      conversations: {
+        info: vi.fn().mockResolvedValue({
+          channel: { name: "dm", is_im: true },
+        }),
+        replies: vi.fn().mockResolvedValue({ messages: [] }),
+        history: vi.fn().mockResolvedValue({ messages: [] }),
+      },
+      users: {
+        info: vi.fn().mockResolvedValue({
+          user: { profile: { display_name: "Ada" } },
+        }),
+      },
+      assistant: {
+        threads: {
+          setStatus: vi.fn().mockResolvedValue({ ok: true }),
+        },
+      },
+      reactions: {
+        add: (...args: unknown[]) => {
+          slackTestState.reactionAddMock(...args);
+          return slackTestState.reactMock(...args);
+        },
+        remove: (...args: unknown[]) => {
+          slackTestState.reactionRemoveMock(...args);
+          return slackTestState.reactMock(...args);
+        },
+      },
+    };
+  }
+  return {
+    handlers: globalState["__slackHandlers"],
+    client: globalState["__slackClient"],
+  };
+}
+
+export const flush = () =>
+  new Promise((resolve) => {
+    setTimeout(resolve, 0);
+  });
+
+async function waitForSlackEvent(name: string) {
+  for (let i = 0; i < 10; i += 1) {
+    if (getSlackHandlers()?.has(name)) {
+      return;
+    }
+    await flush();
+  }
+}
+
+export function startSlackMonitor(
+  monitorSlackProvider: SlackProviderMonitor,
+  opts?: {
+    botToken?: string;
+    appToken?: string;
+    channelRuntime?: ChannelRuntimeSurface;
+    runtime?: RuntimeEnv;
+  },
+) {
+  const controller = new AbortController();
+  const run = monitorSlackProvider({
+    botToken: opts?.botToken ?? "bot-token",
+    appToken: opts?.appToken ?? "app-token",
+    abortSignal: controller.signal,
+    config: slackTestState.config,
+    channelRuntime: opts?.channelRuntime,
+    runtime: opts?.runtime,
+  });
+  return { controller, run };
+}
+
+export async function getSlackHandlerOrThrow(name: string) {
+  await waitForSlackEvent(name);
+  const handler = getSlackHandlers()?.get(name);
+  if (!handler) {
+    throw new Error(`Slack ${name} handler not registered`);
+  }
+  return handler;
+}
+
+export async function stopSlackMonitor(params: {
+  controller: AbortController;
+  run: Promise<unknown>;
+}) {
+  await flush();
+  params.controller.abort();
+  await params.run;
+}
+
+async function runSlackEventOnce(
+  monitorSlackProvider: SlackProviderMonitor,
+  name: string,
+  args: unknown,
+  opts?: { botToken?: string; appToken?: string },
+) {
+  const { controller, run } = startSlackMonitor(monitorSlackProvider, opts);
+  const handler = await getSlackHandlerOrThrow(name);
+  await handler(args);
+  await stopSlackMonitor({ controller, run });
+}
+
+export async function runSlackMessageOnce(
+  monitorSlackProvider: SlackProviderMonitor,
+  args: unknown,
+  opts?: { botToken?: string; appToken?: string },
+) {
+  await runSlackEventOnce(monitorSlackProvider, "message", args, opts);
+}
+
+export const defaultSlackTestConfig = () => ({
+  messages: {
+    responsePrefix: "PFX",
+    ackReaction: "👀",
+    ackReactionScope: "group-mentions",
+  },
+  channels: {
+    slack: {
+      dm: { enabled: true, policy: "open", allowFrom: ["*"] },
+      groupPolicy: "open",
+    },
+  },
+});
+
+export function resetSlackTestState(config: Record<string, unknown> = defaultSlackTestConfig()) {
+  clearSlackInboundDeliveryStateForTest();
+  slackTestState.config = config;
+  slackTestState.appStartMock.mockReset().mockResolvedValue(undefined);
+  slackTestState.appStopMock.mockReset().mockResolvedValue(undefined);
+  slackTestState.sendMock.mockReset().mockResolvedValue(undefined);
+  slackTestState.replyMock.mockReset();
+  slackTestState.updateLastRouteMock.mockReset();
+  slackTestState.reactMock.mockReset();
+  slackTestState.reactionAddMock.mockReset();
+  slackTestState.reactionRemoveMock.mockReset();
+  slackTestState.readAllowFromStoreMock.mockReset().mockResolvedValue([]);
+  slackTestState.upsertPairingRequestMock.mockReset().mockResolvedValue({
+    code: "PAIRCODE",
+    created: true,
+  });
+  slackTestState.resolveSlackUserAllowlistMock
+    .mockReset()
+    .mockImplementation(async ({ entries }) =>
+      entries.map((input) => ({ input, resolved: false })),
+    );
+  const client = getSlackClient();
+  client.auth.test.mockReset().mockResolvedValue({ user_id: "bot-user", bot_id: "bot-id" });
+  client.conversations.info.mockReset().mockResolvedValue({
+    channel: { name: "dm", is_im: true },
+  });
+  client.conversations.replies.mockReset().mockResolvedValue({ messages: [] });
+  client.conversations.history.mockReset().mockResolvedValue({ messages: [] });
+  client.users.info.mockReset().mockResolvedValue({
+    user: { profile: { display_name: "Ada" } },
+  });
+  client.assistant.threads.setStatus.mockReset().mockResolvedValue({ ok: true });
+  getSlackHandlers()?.clear();
+}
+
+vi.mock("./monitor/config.runtime.js", async () => {
+  const actual = await vi.importActual<typeof import("./monitor/config.runtime.js")>(
+    "./monitor/config.runtime.js",
+  );
+  return {
+    ...actual,
+    loadConfig: () => slackTestState.config,
+    readSessionUpdatedAt: vi.fn(() => undefined),
+    recordSessionMetaFromInbound: vi.fn().mockResolvedValue(undefined),
+    resolveStorePath: vi.fn(() => "/tmp/openclaw-sessions.json"),
+    updateLastRoute: (...args: unknown[]) => slackTestState.updateLastRouteMock(...args),
+  };
+});
+
+vi.mock("./monitor/reply.runtime.js", async () => {
+  const actual = await vi.importActual<typeof import("./monitor/reply.runtime.js")>(
+    "./monitor/reply.runtime.js",
+  );
+  type DispatchParams = Parameters<typeof actual.dispatchInboundMessage>[0];
+  type BufferedDispatchParams = Parameters<
+    typeof actual.dispatchReplyWithBufferedBlockDispatcher
+  >[0];
+  type ReplyResolver = NonNullable<DispatchParams["replyResolver"]>;
+  const replyResolver: ReplyResolver = (...args) =>
+    slackTestState.replyMock(...args) as ReturnType<ReplyResolver>;
+  return {
+    ...actual,
+    dispatchInboundMessage: (params: Parameters<typeof actual.dispatchInboundMessage>[0]) =>
+      actual.dispatchInboundMessage({
+        ...params,
+        replyResolver,
+      }),
+    dispatchReplyWithBufferedBlockDispatcher: (params: BufferedDispatchParams) =>
+      actual.dispatchReplyWithBufferedBlockDispatcher({
+        ...params,
+        replyResolver,
+      }),
+  };
+});
+
+vi.mock("./resolve-channels.js", () => ({
+  resolveSlackChannelAllowlist: async ({ entries }: { entries: string[] }) =>
+    entries.map((input) => ({ input, resolved: false })),
+}));
+
+vi.mock("./resolve-users.js", () => ({
+  resolveSlackUserAllowlist: (params: { entries: string[] }) =>
+    slackTestState.resolveSlackUserAllowlistMock(params),
+}));
+
+vi.mock("./monitor/send.runtime.js", () => {
+  return {
+    sendMessageSlack: (...args: unknown[]) => slackTestState.sendMock(...args),
+  };
+});
+
+vi.mock("./monitor/conversation.runtime.js", async () => {
+  const actual = await vi.importActual<typeof import("./monitor/conversation.runtime.js")>(
+    "./monitor/conversation.runtime.js",
+  );
+  return {
+    ...actual,
+    readChannelAllowFromStore: (...args: unknown[]) =>
+      slackTestState.readAllowFromStoreMock(...args),
+    recordInboundSession: vi.fn().mockResolvedValue(undefined),
+    upsertChannelPairingRequest: (...args: unknown[]) =>
+      slackTestState.upsertPairingRequestMock(...args),
+  };
+});
+
+vi.mock("@slack/bolt", () => {
+  const { handlers, client: slackClient } = ensureSlackTestRuntime();
+  class App {
+    client = slackClient;
+    receiver: unknown;
+    middlewares: SlackMiddleware[] = [];
+
+    constructor(args?: { receiver?: unknown }) {
+      this.receiver = args?.receiver;
+    }
+    use(middleware: SlackMiddleware) {
+      this.middlewares.push(middleware);
+    }
+    event(name: string, handler: SlackHandler) {
+      handlers.set(name, async (args: unknown) => {
+        const eventArgs =
+          args && typeof args === "object" && !Array.isArray(args)
+            ? (args as Record<string, unknown>)
+            : {};
+        const run = async (index: number): Promise<void> => {
+          const middleware = this.middlewares[index];
+          if (!middleware) {
+            await handler(args);
+            return;
+          }
+          await middleware({
+            ...eventArgs,
+            next: () => run(index + 1),
+          });
+        };
+        await run(0);
+      });
+    }
+    command() {
+      /* no-op */
+    }
+    start = (...args: unknown[]) => slackTestState.appStartMock(...args);
+    stop = (...args: unknown[]) => slackTestState.appStopMock(...args);
+  }
+  class HTTPReceiver {
+    requestListener = vi.fn();
+  }
+  class SocketModeReceiver {
+    client = {
+      ...slackClient,
+      on: vi.fn(),
+      off: vi.fn(),
+    };
+  }
+  return {
+    App,
+    HTTPReceiver,
+    SocketModeReceiver,
+    default: { App, HTTPReceiver, SocketModeReceiver },
+  };
+});