@openclaw/mattermost 2026.2.21 → 2026.6.11-beta.2

package/src/mattermost/probe.ts

@@ -1,73 +0,0 @@
-import type { BaseProbeResult } from "openclaw/plugin-sdk";
-import { normalizeMattermostBaseUrl, type MattermostUser } from "./client.js";
-
-export type MattermostProbe = BaseProbeResult & {
-  status?: number | null;
-  elapsedMs?: number | null;
-  bot?: MattermostUser;
-};
-
-async function readMattermostError(res: Response): Promise<string> {
-  const contentType = res.headers.get("content-type") ?? "";
-  if (contentType.includes("application/json")) {
-    const data = (await res.json()) as { message?: string } | undefined;
-    if (data?.message) {
-      return data.message;
-    }
-    return JSON.stringify(data);
-  }
-  return await res.text();
-}
-
-export async function probeMattermost(
-  baseUrl: string,
-  botToken: string,
-  timeoutMs = 2500,
-): Promise<MattermostProbe> {
-  const normalized = normalizeMattermostBaseUrl(baseUrl);
-  if (!normalized) {
-    return { ok: false, error: "baseUrl missing" };
-  }
-  const url = `${normalized}/api/v4/users/me`;
-  const start = Date.now();
-  const controller = timeoutMs > 0 ? new AbortController() : undefined;
-  let timer: NodeJS.Timeout | null = null;
-  if (controller) {
-    timer = setTimeout(() => controller.abort(), timeoutMs);
-  }
-  try {
-    const res = await fetch(url, {
-      headers: { Authorization: `Bearer ${botToken}` },
-      signal: controller?.signal,
-    });
-    const elapsedMs = Date.now() - start;
-    if (!res.ok) {
-      const detail = await readMattermostError(res);
-      return {
-        ok: false,
-        status: res.status,
-        error: detail || res.statusText,
-        elapsedMs,
-      };
-    }
-    const bot = (await res.json()) as MattermostUser;
-    return {
-      ok: true,
-      status: res.status,
-      elapsedMs,
-      bot,
-    };
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return {
-      ok: false,
-      status: null,
-      error: message,
-      elapsedMs: Date.now() - start,
-    };
-  } finally {
-    if (timer) {
-      clearTimeout(timer);
-    }
-  }
-}

package/src/mattermost/reactions.test-helpers.ts

@@ -1,83 +0,0 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk";
-import { expect, vi } from "vitest";
-
-export function createMattermostTestConfig(): OpenClawConfig {
-  return {
-    channels: {
-      mattermost: {
-        enabled: true,
-        botToken: "test-token",
-        baseUrl: "https://chat.example.com",
-      },
-    },
-  };
-}
-
-export function createMattermostReactionFetchMock(params: {
-  postId: string;
-  emojiName: string;
-  mode: "add" | "remove" | "both";
-  userId?: string;
-  status?: number;
-  body?: unknown;
-}) {
-  const userId = params.userId ?? "BOT123";
-  const mode = params.mode;
-  const allowAdd = mode === "add" || mode === "both";
-  const allowRemove = mode === "remove" || mode === "both";
-  const addStatus = params.status ?? 201;
-  const removeStatus = params.status ?? 204;
-  const removePath = `/api/v4/users/${userId}/posts/${params.postId}/reactions/${encodeURIComponent(params.emojiName)}`;
-
-  return vi.fn(async (url: any, init?: any) => {
-    if (String(url).endsWith("/api/v4/users/me")) {
-      return new Response(JSON.stringify({ id: userId }), {
-        status: 200,
-        headers: { "content-type": "application/json" },
-      });
-    }
-
-    if (allowAdd && String(url).endsWith("/api/v4/reactions")) {
-      expect(init?.method).toBe("POST");
-      expect(JSON.parse(init?.body)).toEqual({
-        user_id: userId,
-        post_id: params.postId,
-        emoji_name: params.emojiName,
-      });
-
-      const responseBody = params.body === undefined ? { ok: true } : params.body;
-      return new Response(
-        responseBody === null ? null : JSON.stringify(responseBody),
-        responseBody === null
-          ? { status: addStatus, headers: { "content-type": "text/plain" } }
-          : { status: addStatus, headers: { "content-type": "application/json" } },
-      );
-    }
-
-    if (allowRemove && String(url).endsWith(removePath)) {
-      expect(init?.method).toBe("DELETE");
-      const responseBody = params.body === undefined ? null : params.body;
-      return new Response(
-        responseBody === null ? null : JSON.stringify(responseBody),
-        responseBody === null
-          ? { status: removeStatus, headers: { "content-type": "text/plain" } }
-          : { status: removeStatus, headers: { "content-type": "application/json" } },
-      );
-    }
-
-    throw new Error(`unexpected url: ${url}`);
-  });
-}
-
-export async function withMockedGlobalFetch<T>(
-  fetchImpl: typeof fetch,
-  run: () => Promise<T>,
-): Promise<T> {
-  const prevFetch = globalThis.fetch;
-  (globalThis as any).fetch = fetchImpl;
-  try {
-    return await run();
-  } finally {
-    (globalThis as any).fetch = prevFetch;
-  }
-}

package/src/mattermost/reactions.test.ts

@@ -1,103 +0,0 @@
-import { beforeEach, describe, expect, it } from "vitest";
-import {
-  addMattermostReaction,
-  removeMattermostReaction,
-  resetMattermostReactionBotUserCacheForTests,
-} from "./reactions.js";
-import {
-  createMattermostReactionFetchMock,
-  createMattermostTestConfig,
-} from "./reactions.test-helpers.js";
-
-describe("mattermost reactions", () => {
-  beforeEach(() => {
-    resetMattermostReactionBotUserCacheForTests();
-  });
-
-  it("adds reactions by calling /users/me then POST /reactions", async () => {
-    const fetchMock = createMattermostReactionFetchMock({
-      mode: "add",
-      postId: "POST1",
-      emojiName: "thumbsup",
-    });
-
-    const result = await addMattermostReaction({
-      cfg: createMattermostTestConfig(),
-      postId: "POST1",
-      emojiName: "thumbsup",
-      fetchImpl: fetchMock as unknown as typeof fetch,
-    });
-
-    expect(result).toEqual({ ok: true });
-    expect(fetchMock).toHaveBeenCalled();
-  });
-
-  it("returns a Result error when add reaction API call fails", async () => {
-    const fetchMock = createMattermostReactionFetchMock({
-      mode: "add",
-      postId: "POST1",
-      emojiName: "thumbsup",
-      status: 500,
-      body: { id: "err", message: "boom" },
-    });
-
-    const result = await addMattermostReaction({
-      cfg: createMattermostTestConfig(),
-      postId: "POST1",
-      emojiName: "thumbsup",
-      fetchImpl: fetchMock as unknown as typeof fetch,
-    });
-
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.error).toContain("Mattermost add reaction failed");
-    }
-  });
-
-  it("removes reactions by calling /users/me then DELETE /users/:id/posts/:postId/reactions/:emoji", async () => {
-    const fetchMock = createMattermostReactionFetchMock({
-      mode: "remove",
-      postId: "POST1",
-      emojiName: "thumbsup",
-    });
-
-    const result = await removeMattermostReaction({
-      cfg: createMattermostTestConfig(),
-      postId: "POST1",
-      emojiName: "thumbsup",
-      fetchImpl: fetchMock as unknown as typeof fetch,
-    });
-
-    expect(result).toEqual({ ok: true });
-    expect(fetchMock).toHaveBeenCalled();
-  });
-
-  it("caches the bot user id across reaction mutations", async () => {
-    const fetchMock = createMattermostReactionFetchMock({
-      mode: "both",
-      postId: "POST1",
-      emojiName: "thumbsup",
-    });
-
-    const cfg = createMattermostTestConfig();
-    const addResult = await addMattermostReaction({
-      cfg,
-      postId: "POST1",
-      emojiName: "thumbsup",
-      fetchImpl: fetchMock as unknown as typeof fetch,
-    });
-    const removeResult = await removeMattermostReaction({
-      cfg,
-      postId: "POST1",
-      emojiName: "thumbsup",
-      fetchImpl: fetchMock as unknown as typeof fetch,
-    });
-
-    const usersMeCalls = fetchMock.mock.calls.filter((call) =>
-      String(call[0]).endsWith("/api/v4/users/me"),
-    );
-    expect(addResult).toEqual({ ok: true });
-    expect(removeResult).toEqual({ ok: true });
-    expect(usersMeCalls).toHaveLength(1);
-  });
-});

package/src/mattermost/reactions.ts

@@ -1,124 +0,0 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk";
-import { resolveMattermostAccount } from "./accounts.js";
-import { createMattermostClient, fetchMattermostMe, type MattermostClient } from "./client.js";
-
-type Result = { ok: true } | { ok: false; error: string };
-type ReactionParams = {
-  cfg: OpenClawConfig;
-  postId: string;
-  emojiName: string;
-  accountId?: string | null;
-  fetchImpl?: typeof fetch;
-};
-type ReactionMutation = (client: MattermostClient, params: MutationPayload) => Promise<void>;
-type MutationPayload = { userId: string; postId: string; emojiName: string };
-
-const BOT_USER_CACHE_TTL_MS = 10 * 60_000;
-const botUserIdCache = new Map<string, { userId: string; expiresAt: number }>();
-
-async function resolveBotUserId(
-  client: MattermostClient,
-  cacheKey: string,
-): Promise<string | null> {
-  const cached = botUserIdCache.get(cacheKey);
-  if (cached && cached.expiresAt > Date.now()) {
-    return cached.userId;
-  }
-  const me = await fetchMattermostMe(client);
-  const userId = me?.id?.trim();
-  if (!userId) {
-    return null;
-  }
-  botUserIdCache.set(cacheKey, { userId, expiresAt: Date.now() + BOT_USER_CACHE_TTL_MS });
-  return userId;
-}
-
-export async function addMattermostReaction(params: {
-  cfg: OpenClawConfig;
-  postId: string;
-  emojiName: string;
-  accountId?: string | null;
-  fetchImpl?: typeof fetch;
-}): Promise<Result> {
-  return runMattermostReaction(params, {
-    action: "add",
-    mutation: createReaction,
-  });
-}
-
-export async function removeMattermostReaction(params: {
-  cfg: OpenClawConfig;
-  postId: string;
-  emojiName: string;
-  accountId?: string | null;
-  fetchImpl?: typeof fetch;
-}): Promise<Result> {
-  return runMattermostReaction(params, {
-    action: "remove",
-    mutation: deleteReaction,
-  });
-}
-
-export function resetMattermostReactionBotUserCacheForTests(): void {
-  botUserIdCache.clear();
-}
-
-async function runMattermostReaction(
-  params: ReactionParams,
-  options: {
-    action: "add" | "remove";
-    mutation: ReactionMutation;
-  },
-): Promise<Result> {
-  const resolved = resolveMattermostAccount({ cfg: params.cfg, accountId: params.accountId });
-  const baseUrl = resolved.baseUrl?.trim();
-  const botToken = resolved.botToken?.trim();
-  if (!baseUrl || !botToken) {
-    return { ok: false, error: "Mattermost botToken/baseUrl missing." };
-  }
-
-  const client = createMattermostClient({
-    baseUrl,
-    botToken,
-    fetchImpl: params.fetchImpl,
-  });
-
-  const cacheKey = `${baseUrl}:${botToken}`;
-  const userId = await resolveBotUserId(client, cacheKey);
-  if (!userId) {
-    return { ok: false, error: "Mattermost reactions failed: could not resolve bot user id." };
-  }
-
-  try {
-    await options.mutation(client, {
-      userId,
-      postId: params.postId,
-      emojiName: params.emojiName,
-    });
-  } catch (err) {
-    return { ok: false, error: `Mattermost ${options.action} reaction failed: ${String(err)}` };
-  }
-
-  return { ok: true };
-}
-
-async function createReaction(client: MattermostClient, params: MutationPayload): Promise<void> {
-  await client.request<Record<string, unknown>>("/reactions", {
-    method: "POST",
-    body: JSON.stringify({
-      user_id: params.userId,
-      post_id: params.postId,
-      emoji_name: params.emojiName,
-    }),
-  });
-}
-
-async function deleteReaction(client: MattermostClient, params: MutationPayload): Promise<void> {
-  const emoji = encodeURIComponent(params.emojiName);
-  await client.request<unknown>(
-    `/users/${params.userId}/posts/${params.postId}/reactions/${emoji}`,
-    {
-      method: "DELETE",
-    },
-  );
-}

package/src/mattermost/reconnect.test.ts

@@ -1,192 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { runWithReconnect } from "./reconnect.js";
-
-beforeEach(() => {
-  vi.clearAllMocks();
-});
-
-describe("runWithReconnect", () => {
-  it("retries after connectFn resolves (normal close)", async () => {
-    let callCount = 0;
-    const abort = new AbortController();
-    const connectFn = vi.fn(async () => {
-      callCount++;
-      if (callCount >= 3) {
-        abort.abort();
-      }
-    });
-
-    await runWithReconnect(connectFn, {
-      abortSignal: abort.signal,
-      initialDelayMs: 1,
-    });
-
-    expect(connectFn).toHaveBeenCalledTimes(3);
-  });
-
-  it("retries after connectFn throws (connection error)", async () => {
-    let callCount = 0;
-    const abort = new AbortController();
-    const onError = vi.fn();
-    const connectFn = vi.fn(async () => {
-      callCount++;
-      if (callCount < 3) {
-        throw new Error("fetch failed");
-      }
-      abort.abort();
-    });
-
-    await runWithReconnect(connectFn, {
-      abortSignal: abort.signal,
-      onError,
-      initialDelayMs: 1,
-    });
-
-    expect(connectFn).toHaveBeenCalledTimes(3);
-    expect(onError).toHaveBeenCalledTimes(2);
-    expect(onError).toHaveBeenCalledWith(expect.objectContaining({ message: "fetch failed" }));
-  });
-
-  it("uses exponential backoff on consecutive errors, capped at maxDelayMs", async () => {
-    const abort = new AbortController();
-    const delays: number[] = [];
-    let callCount = 0;
-    const connectFn = vi.fn(async () => {
-      callCount++;
-      if (callCount >= 6) {
-        abort.abort();
-        return;
-      }
-      throw new Error("connection refused");
-    });
-
-    await runWithReconnect(connectFn, {
-      abortSignal: abort.signal,
-      onReconnect: (delayMs) => delays.push(delayMs),
-      // Keep this test fast: validate the exponential pattern, not real-time waiting.
-      initialDelayMs: 1,
-      maxDelayMs: 10,
-    });
-
-    expect(connectFn).toHaveBeenCalledTimes(6);
-    // 5 errors produce delays: 1, 2, 4, 8, 10(cap)
-    // 6th succeeds -> delay resets to 100
-    // But 6th also aborts → onReconnect NOT called (abort check fires first)
-    expect(delays).toEqual([1, 2, 4, 8, 10]);
-  });
-
-  it("resets backoff after successful connection", async () => {
-    const abort = new AbortController();
-    const delays: number[] = [];
-    let callCount = 0;
-    const connectFn = vi.fn(async () => {
-      callCount++;
-      if (callCount === 1) {
-        throw new Error("first failure");
-      }
-      if (callCount === 2) {
-        return; // success
-      }
-      if (callCount === 3) {
-        throw new Error("second failure");
-      }
-      abort.abort();
-    });
-
-    await runWithReconnect(connectFn, {
-      abortSignal: abort.signal,
-      onReconnect: (delayMs) => delays.push(delayMs),
-      initialDelayMs: 1,
-      maxDelayMs: 60_000,
-    });
-
-    expect(connectFn).toHaveBeenCalledTimes(4);
-    // call 1: fail -> delay 1
-    // call 2: success → delay resets to 1
-    // call 3: fail -> delay 1 (reset held)
-    // call 4: success + abort → no onReconnect
-    expect(delays).toEqual([1, 1, 1]);
-  });
-
-  it("stops immediately when abort signal is pre-fired", async () => {
-    const abort = new AbortController();
-    abort.abort();
-    const connectFn = vi.fn(async () => {});
-
-    await runWithReconnect(connectFn, { abortSignal: abort.signal });
-
-    expect(connectFn).not.toHaveBeenCalled();
-  });
-
-  it("stops after current connection when abort fires mid-connection", async () => {
-    const abort = new AbortController();
-    const connectFn = vi.fn(async () => {
-      abort.abort();
-    });
-
-    await runWithReconnect(connectFn, {
-      abortSignal: abort.signal,
-      initialDelayMs: 1,
-    });
-
-    expect(connectFn).toHaveBeenCalledTimes(1);
-  });
-
-  it("abort signal interrupts backoff sleep immediately", async () => {
-    const abort = new AbortController();
-    const connectFn = vi.fn(async () => {
-      // Schedule abort to fire 10ms into the 60s sleep
-      setTimeout(() => abort.abort(), 10);
-    });
-
-    const start = Date.now();
-    await runWithReconnect(connectFn, {
-      abortSignal: abort.signal,
-      initialDelayMs: 60_000,
-    });
-    const elapsed = Date.now() - start;
-
-    expect(connectFn).toHaveBeenCalledTimes(1);
-    expect(elapsed).toBeLessThan(5000);
-  });
-
-  it("applies jitter to reconnect delay when configured", async () => {
-    const abort = new AbortController();
-    const delays: number[] = [];
-    let callCount = 0;
-    const connectFn = vi.fn(async () => {
-      callCount++;
-      if (callCount === 1) {
-        throw new Error("connection refused");
-      }
-      abort.abort();
-    });
-
-    await runWithReconnect(connectFn, {
-      abortSignal: abort.signal,
-      onReconnect: (delayMs) => delays.push(delayMs),
-      initialDelayMs: 10,
-      jitterRatio: 0.5,
-      random: () => 1,
-    });
-
-    expect(connectFn).toHaveBeenCalledTimes(2);
-    expect(delays).toEqual([15]);
-  });
-
-  it("supports strategy hook to stop reconnecting after failure", async () => {
-    const onReconnect = vi.fn();
-    const connectFn = vi.fn(async () => {
-      throw new Error("fatal");
-    });
-
-    await runWithReconnect(connectFn, {
-      initialDelayMs: 1,
-      onReconnect,
-      shouldReconnect: (params) => params.outcome !== "rejected",
-    });
-
-    expect(connectFn).toHaveBeenCalledTimes(1);
-    expect(onReconnect).not.toHaveBeenCalled();
-  });
-});

package/src/mattermost/reconnect.ts

@@ -1,103 +0,0 @@
-export type ReconnectOutcome = "resolved" | "rejected";
-
-export type ShouldReconnectParams = {
-  attempt: number;
-  delayMs: number;
-  outcome: ReconnectOutcome;
-  error?: unknown;
-};
-
-export type RunWithReconnectOpts = {
-  abortSignal?: AbortSignal;
-  onError?: (err: unknown) => void;
-  onReconnect?: (delayMs: number) => void;
-  initialDelayMs?: number;
-  maxDelayMs?: number;
-  jitterRatio?: number;
-  random?: () => number;
-  shouldReconnect?: (params: ShouldReconnectParams) => boolean;
-};
-
-/**
- * Reconnection loop with exponential backoff.
- *
- * Calls `connectFn` in a while loop. On normal resolve (connection closed),
- * the backoff resets. On thrown error (connection failed), the current delay is
- * used, then doubled for the next retry.
- * The loop exits when `abortSignal` fires.
- */
-export async function runWithReconnect(
-  connectFn: () => Promise<void>,
-  opts: RunWithReconnectOpts = {},
-): Promise<void> {
-  const { initialDelayMs = 2000, maxDelayMs = 60_000 } = opts;
-  const jitterRatio = Math.max(0, opts.jitterRatio ?? 0);
-  const random = opts.random ?? Math.random;
-  let retryDelay = initialDelayMs;
-  let attempt = 0;
-
-  while (!opts.abortSignal?.aborted) {
-    let shouldIncreaseDelay = false;
-    let outcome: ReconnectOutcome = "resolved";
-    let error: unknown;
-    try {
-      await connectFn();
-      retryDelay = initialDelayMs;
-    } catch (err) {
-      if (opts.abortSignal?.aborted) {
-        return;
-      }
-      outcome = "rejected";
-      error = err;
-      opts.onError?.(err);
-      shouldIncreaseDelay = true;
-    }
-    if (opts.abortSignal?.aborted) {
-      return;
-    }
-    const delayMs = withJitter(retryDelay, jitterRatio, random);
-    const shouldReconnect =
-      opts.shouldReconnect?.({
-        attempt,
-        delayMs,
-        outcome,
-        error,
-      }) ?? true;
-    if (!shouldReconnect) {
-      return;
-    }
-    opts.onReconnect?.(delayMs);
-    await sleepAbortable(delayMs, opts.abortSignal);
-    if (shouldIncreaseDelay) {
-      retryDelay = Math.min(retryDelay * 2, maxDelayMs);
-    }
-    attempt++;
-  }
-}
-
-function withJitter(baseMs: number, jitterRatio: number, random: () => number): number {
-  if (jitterRatio <= 0) {
-    return baseMs;
-  }
-  const normalized = Math.max(0, Math.min(1, random()));
-  const spread = baseMs * jitterRatio;
-  return Math.max(1, Math.round(baseMs - spread + normalized * spread * 2));
-}
-
-function sleepAbortable(ms: number, signal?: AbortSignal): Promise<void> {
-  return new Promise((resolve) => {
-    if (signal?.aborted) {
-      resolve();
-      return;
-    }
-    const onAbort = () => {
-      clearTimeout(timer);
-      resolve();
-    };
-    const timer = setTimeout(() => {
-      signal?.removeEventListener("abort", onAbort);
-      resolve();
-    }, ms);
-    signal?.addEventListener("abort", onAbort, { once: true });
-  });
-}