openclaw-groupme 0.4.3 → 0.5.0

package/src/parse.ts

@@ -68,9 +68,7 @@ function parseStringArray(value: unknown): string[] {
     return [];
   }
 
-  return value
-    .map((entry) => readString(entry))
-    .filter((entry): entry is string => Boolean(entry));
+  return value.map((entry) => readString(entry)).filter((entry): entry is string => Boolean(entry));
 }
 
 function parseAttachment(entry: unknown): GroupMeAttachment | null {
@@ -136,9 +134,7 @@ function parseAttachments(value: unknown): GroupMeAttachment[] {
     .filter((parsed): parsed is GroupMeAttachment => parsed !== null);
 }
 
-export function parseGroupMeCallback(
-  data: unknown,
-): GroupMeCallbackData | null {
+export function parseGroupMeCallback(data: unknown): GroupMeCallbackData | null {
   if (!isRecord(data)) {
     return null;
   }
@@ -152,15 +148,7 @@ export function parseGroupMeCallback(
   const sourceGuid = readString(data.source_guid);
   const createdAt = readNumber(data.created_at);
 
-  if (
-    !id ||
-    !name ||
-    !senderType ||
-    !senderId ||
-    !userId ||
-    !groupId ||
-    !sourceGuid
-  ) {
+  if (!id || !name || !senderType || !senderId || !userId || !groupId || !sourceGuid) {
     return null;
   }
   if (typeof createdAt !== "number") {
@@ -186,7 +174,7 @@ export function parseGroupMeCallback(
   };
 }
 
-export function hasImageAttachment(attachments: GroupMeAttachment[]): boolean {
+function hasImageAttachment(attachments: GroupMeAttachment[]): boolean {
   return attachments.some((attachment) => attachment.type === "image");
 }
 
@@ -206,17 +194,12 @@ export function shouldProcessCallback(msg: GroupMeCallbackData): string | null {
 
 export function extractImageUrls(attachments: GroupMeAttachment[]): string[] {
   return attachments
-    .filter(
-      (attachment): attachment is GroupMeImageAttachment =>
-        attachment.type === "image",
-    )
+    .filter((attachment): attachment is GroupMeImageAttachment => attachment.type === "image")
     .map((attachment) => attachment.url);
 }
 
 function normalizeMentionText(text: string): string {
-  return text
-    .replace(/[\u200b-\u200f\u202a-\u202e\u2060-\u206f]/g, "")
-    .toLowerCase();
+  return text.replace(/[\u200b-\u200f\u202a-\u202e\u2060-\u206f]/g, "").toLowerCase();
 }
 
 function buildRegexes(patterns?: string[]): RegExp[] {

package/src/policy.ts

@@ -1,7 +1,4 @@
-import {
-  normalizeGroupMeAllowEntry,
-  normalizeStringId,
-} from "./normalize.js";
+import { normalizeGroupMeAllowEntry, normalizeStringId } from "./normalize.js";
 
 export function resolveSenderAccess(params: {
   senderId: string;

package/src/rate-limit.ts

@@ -1,10 +1,15 @@
-export type RateLimitCheck =
+type RateLimitCheck =
   | { kind: "accepted"; release: () => void }
   | { kind: "rejected"; scope: "ip" | "sender" | "concurrency" };
 
 type SlidingWindowState = Map<string, number[]>;
 const DEFAULT_MAX_TRACKED_KEYS = 10_000;
 
+function positiveIntegerAtLeastOne(value: number): number {
+  const normalized = Math.floor(value);
+  return Number.isFinite(normalized) ? Math.max(1, normalized) : 1;
+}
+
 function allowInWindow(params: {
   state: SlidingWindowState;
   key: string;
@@ -41,13 +46,10 @@ export class GroupMeRateLimiter {
     maxRequestsPerSender: number;
     maxConcurrent: number;
   }) {
-    this.windowMs = Math.max(1, Math.floor(params.windowMs));
-    this.maxRequestsPerIp = Math.max(1, Math.floor(params.maxRequestsPerIp));
-    this.maxRequestsPerSender = Math.max(
-      1,
-      Math.floor(params.maxRequestsPerSender),
-    );
-    this.maxConcurrent = Math.max(1, Math.floor(params.maxConcurrent));
+    this.windowMs = positiveIntegerAtLeastOne(params.windowMs);
+    this.maxRequestsPerIp = positiveIntegerAtLeastOne(params.maxRequestsPerIp);
+    this.maxRequestsPerSender = positiveIntegerAtLeastOne(params.maxRequestsPerSender);
+    this.maxConcurrent = positiveIntegerAtLeastOne(params.maxConcurrent);
     this.maxTrackedKeys = DEFAULT_MAX_TRACKED_KEYS;
   }
 
@@ -117,12 +119,13 @@ export class GroupMeRateLimiter {
   }
 
   private capStateSize(state: SlidingWindowState) {
+    // Only triggers past DEFAULT_MAX_TRACKED_KEYS (10k) distinct keys within a single
+    // window — not exercised in unit tests.
+    /* v8 ignore start */
     while (state.size > this.maxTrackedKeys) {
-      const oldest = state.keys().next().value as string | undefined;
-      if (!oldest) {
-        return;
-      }
+      const oldest = state.keys().next().value as string;
       state.delete(oldest);
     }
+    /* v8 ignore stop */
   }
 }

package/src/replay-cache.ts

@@ -44,10 +44,7 @@ export class GroupMeReplayCache {
 
   private evictOverflow() {
     while (this.entries.size > this.maxEntries) {
-      const oldest = this.entries.keys().next().value as string | undefined;
-      if (!oldest) {
-        return;
-      }
+      const oldest = this.entries.keys().next().value as string;
       this.entries.delete(oldest);
     }
   }

package/src/runtime.ts

@@ -1,4 +1,4 @@
-import type { PluginRuntime } from "openclaw/plugin-sdk";
+import type { PluginRuntime } from "openclaw/plugin-sdk/core";
 
 let runtime: PluginRuntime | null = null;
 

package/src/secret-contract.ts

@@ -0,0 +1,66 @@
+import {
+  collectSimpleChannelFieldAssignments,
+  getChannelSurface,
+  type ResolverContext,
+  type SecretDefaults,
+  type SecretTargetRegistryEntry,
+} from "openclaw/plugin-sdk/channel-secret-basic-runtime";
+
+const secretFields = ["botId", "accessToken", "callbackToken"] as const;
+
+export const secretTargetRegistryEntries: SecretTargetRegistryEntry[] = secretFields.flatMap(
+  (field) => [
+    {
+      id: `channels.groupme.accounts.*.${field}`,
+      targetType: `channels.groupme.accounts.*.${field}`,
+      configFile: "openclaw.json",
+      pathPattern: `channels.groupme.accounts.*.${field}`,
+      secretShape: "secret_input",
+      expectedResolvedValue: "string",
+      includeInPlan: true,
+      includeInConfigure: true,
+      includeInAudit: true,
+    },
+    {
+      id: `channels.groupme.${field}`,
+      targetType: `channels.groupme.${field}`,
+      configFile: "openclaw.json",
+      pathPattern: `channels.groupme.${field}`,
+      secretShape: "secret_input",
+      expectedResolvedValue: "string",
+      includeInPlan: true,
+      includeInConfigure: true,
+      includeInAudit: true,
+    },
+  ],
+);
+
+export function collectRuntimeConfigAssignments(params: {
+  config: { channels?: Record<string, unknown> };
+  defaults?: SecretDefaults;
+  context: ResolverContext;
+}): void {
+  const resolved = getChannelSurface(params.config, "groupme");
+  if (!resolved) {
+    return;
+  }
+
+  const { channel, surface } = resolved;
+  for (const field of secretFields) {
+    collectSimpleChannelFieldAssignments({
+      channelKey: "groupme",
+      field,
+      channel,
+      surface,
+      defaults: params.defaults,
+      context: params.context,
+      topInactiveReason: `no enabled account inherits this top-level GroupMe ${field}.`,
+      accountInactiveReason: "GroupMe account is disabled.",
+    });
+  }
+}
+
+export const channelSecrets = {
+  secretTargetRegistryEntries,
+  collectRuntimeConfigAssignments,
+};

package/src/security.ts

@@ -2,11 +2,7 @@ import { createHash, timingSafeEqual } from "node:crypto";
 import type { IncomingHttpHeaders } from "node:http";
 import { BlockList, isIP } from "node:net";
 import { readTrimmed } from "./accounts.js";
-import type {
-  CallbackAuthResult,
-  GroupMeAccountConfig,
-  GroupMeSecurityConfig,
-} from "./types.js";
+import type { CallbackAuthResult, GroupMeAccountConfig, GroupMeSecurityConfig } from "./types.js";
 
 type ProxyRule = {
   kind: "cidr" | "ip";
@@ -21,12 +17,10 @@ export type ResolvedGroupMeSecurity = {
   callbackRejectStatus: 404;
   groupId: string;
   replay: {
-    enabled: boolean;
     ttlSeconds: number;
     maxEntries: number;
   };
   rateLimit: {
-    enabled: boolean;
     windowMs: number;
     maxRequestsPerIp: number;
     maxRequestsPerSender: number;
@@ -56,7 +50,7 @@ export type ResolvedGroupMeSecurity = {
   };
 };
 
-export type GroupMeWebhookRequestContext = {
+type GroupMeWebhookRequestContext = {
   remoteIp: string;
   clientIp: string;
   host: string;
@@ -65,7 +59,7 @@ export type GroupMeWebhookRequestContext = {
   usingForwardedHeaders: boolean;
 };
 
-export type GroupMeProxyValidation =
+type GroupMeProxyValidation =
   | { ok: true; context: GroupMeWebhookRequestContext }
   | {
       ok: false;
@@ -86,7 +80,7 @@ function normalizeIpCandidate(raw: string): string {
     return "";
   }
   if (value.includes(",")) {
-    value = value.split(",")[0]?.trim() ?? "";
+    value = value.split(",")[0].trim();
   }
   if (value.startsWith("[")) {
     const endIndex = value.indexOf("]");
@@ -108,10 +102,10 @@ function normalizeIpCandidate(raw: string): string {
     const maybeWithPort = value.split(":");
     if (
       maybeWithPort.length === 2 &&
-      /^\d+$/.test(maybeWithPort[1] ?? "") &&
-      isIP(maybeWithPort[0] ?? "") === 4
+      /^\d+$/.test(maybeWithPort[1]) &&
+      isIP(maybeWithPort[0]) === 4
     ) {
-      value = maybeWithPort[0] ?? "";
+      value = maybeWithPort[0];
     }
   }
   return isIP(value) === 0 ? "" : value;
@@ -134,7 +128,7 @@ function normalizeHost(value: string): string {
     return "";
   }
   if (host.includes(",")) {
-    host = host.split(",")[0]?.trim() ?? "";
+    host = host.split(",")[0].trim();
   }
   if (!host) {
     return "";
@@ -150,11 +144,8 @@ function normalizeHost(value: string): string {
     return "";
   }
   const maybeWithoutPort = host.split(":");
-  if (
-    maybeWithoutPort.length === 2 &&
-    /^\d+$/.test(maybeWithoutPort[1] ?? "")
-  ) {
-    host = maybeWithoutPort[0] ?? "";
+  if (maybeWithoutPort.length === 2 && /^\d+$/.test(maybeWithoutPort[1])) {
+    host = maybeWithoutPort[0];
   }
   return host.trim();
 }
@@ -163,19 +154,22 @@ function parseProxyRules(entries: string[]): ProxyRule[] {
   const rules: ProxyRule[] = [];
   for (const entry of entries) {
     const raw = entry.trim();
+    // resolveGroupMeSecurity already trims and Boolean-filters these entries, so a
+    // blank value never reaches this guard; kept as defense in depth.
+    /* v8 ignore start */
     if (!raw) {
       continue;
     }
+    /* v8 ignore stop */
     if (raw.includes("/")) {
       const [network, prefixRaw] = raw.split("/");
-      const normalizedNetwork = normalizeIpCandidate(network ?? "");
+      const normalizedNetwork = normalizeIpCandidate(network);
       const ipVersion = isIP(normalizedNetwork);
       if (!ipVersion) {
         continue;
       }
       const prefix = Number(prefixRaw);
-      const maxPrefix =
-        ipVersion === 4 ? IPV4_MAX_CIDR_PREFIX : IPV6_MAX_CIDR_PREFIX;
+      const maxPrefix = ipVersion === 4 ? IPV4_MAX_CIDR_PREFIX : IPV6_MAX_CIDR_PREFIX;
       if (!Number.isInteger(prefix) || prefix < 0 || prefix > maxPrefix) {
         continue;
       }
@@ -229,24 +223,11 @@ function createTrustedProxyMatcher(entries: string[]): (ip: string) => boolean {
   };
 }
 
-function extractCallbackToken(callbackUrl: string | undefined): string {
-  const raw = callbackUrl?.trim() ?? "";
-  if (!raw) {
-    return "";
-  }
-  try {
-    const parsed = new URL(raw, "http://localhost");
-    return parsed.searchParams.get("k")?.trim() ?? "";
-  } catch {
-    throw new Error(`Invalid callbackUrl: unable to parse "${raw}"`);
-  }
-}
-
 export function resolveGroupMeSecurity(
   accountConfig: GroupMeAccountConfig,
 ): ResolvedGroupMeSecurity {
   const security = (accountConfig.security ?? {}) as GroupMeSecurityConfig;
-  const callbackToken = extractCallbackToken(accountConfig.callbackUrl);
+  const callbackToken = readTrimmed(accountConfig.callbackToken) ?? "";
   const groupId = readTrimmed(accountConfig.groupId) ?? "";
 
   const allowedMimePrefixes = Array.isArray(security.media?.allowedMimePrefixes)
@@ -270,12 +251,10 @@ export function resolveGroupMeSecurity(
     callbackRejectStatus: 404,
     groupId,
     replay: {
-      enabled: true,
       ttlSeconds: positiveIntOrDefault(security.replay?.ttlSeconds, 600),
       maxEntries: positiveIntOrDefault(security.replay?.maxEntries, 10_000),
     },
     rateLimit: {
-      enabled: true,
       windowMs: positiveIntOrDefault(security.rateLimit?.windowMs, 60_000),
       maxRequestsPerIp: positiveIntOrDefault(security.rateLimit?.maxRequestsPerIp, 120),
       maxRequestsPerSender: positiveIntOrDefault(security.rateLimit?.maxRequestsPerSender, 60),
@@ -285,8 +264,7 @@ export function resolveGroupMeSecurity(
       allowPrivateNetworks: security.media?.allowPrivateNetworks === true,
       maxDownloadBytes: positiveIntOrDefault(security.media?.maxDownloadBytes, 15 * 1024 * 1024),
       requestTimeoutMs: positiveIntOrDefault(security.media?.requestTimeoutMs, 10_000),
-      allowedMimePrefixes:
-        allowedMimePrefixes.length > 0 ? allowedMimePrefixes : ["image/"],
+      allowedMimePrefixes: allowedMimePrefixes.length > 0 ? allowedMimePrefixes : ["image/"],
     },
     logging: {
       redactSecrets: security.logging?.redactSecrets !== false,
@@ -294,8 +272,7 @@ export function resolveGroupMeSecurity(
     },
     commandBypass: {
       requireAllowFrom: security.commandBypass?.requireAllowFrom !== false,
-      requireMentionForCommands:
-        security.commandBypass?.requireMentionForCommands === true,
+      requireMentionForCommands: security.commandBypass?.requireMentionForCommands === true,
     },
     proxy: {
       enabled: security.proxy != null,
@@ -343,10 +320,7 @@ export function checkGroupBinding(params: {
   return { ok: true };
 }
 
-export function redactCallbackUrl(
-  raw: string,
-  security: ResolvedGroupMeSecurity,
-): string {
+export function redactWebhookUrl(raw: string, security: ResolvedGroupMeSecurity): string {
   if (!security.callbackToken) {
     return raw;
   }
@@ -371,9 +345,7 @@ export function validateProxyRequest(params: {
 }): GroupMeProxyValidation {
   const remoteIp = normalizeIpCandidate(params.remoteAddress) || "unknown";
   const proxyConfig = params.security.proxy;
-  const defaultProto: "http" | "https" = params.socketEncrypted
-    ? "https"
-    : "http";
+  const defaultProto: "http" | "https" = params.socketEncrypted ? "https" : "http";
   const hostHeader = normalizeHost(getHeaderValue(params.headers, "host"));
 
   if (!proxyConfig.enabled) {
@@ -391,32 +363,22 @@ export function validateProxyRequest(params: {
   }
 
   const fromTrustedProxy =
-    proxyConfig.trustedProxyCidrs.length > 0 &&
-    proxyConfig.isTrustedProxy(remoteIp);
+    proxyConfig.trustedProxyCidrs.length > 0 && proxyConfig.isTrustedProxy(remoteIp);
 
-  const forwardedFor = normalizeIpCandidate(
-    getHeaderValue(params.headers, "x-forwarded-for"),
-  );
-  const forwardedHost = normalizeHost(
-    getHeaderValue(params.headers, "x-forwarded-host"),
-  );
+  const forwardedFor = normalizeIpCandidate(getHeaderValue(params.headers, "x-forwarded-for"));
+  const forwardedHost = normalizeHost(getHeaderValue(params.headers, "x-forwarded-host"));
   const forwardedProtoRaw = getHeaderValue(params.headers, "x-forwarded-proto")
     .split(",")[0]
     ?.trim()
     .toLowerCase();
   const forwardedProto: "http" | "https" | null =
-    forwardedProtoRaw === "http" || forwardedProtoRaw === "https"
-      ? forwardedProtoRaw
-      : null;
+    forwardedProtoRaw === "http" || forwardedProtoRaw === "https" ? forwardedProtoRaw : null;
 
   const usingForwardedHeaders =
     fromTrustedProxy && Boolean(forwardedFor || forwardedHost || forwardedProto);
-  const effectiveClientIp =
-    usingForwardedHeaders && forwardedFor ? forwardedFor : remoteIp;
-  const effectiveHost =
-    usingForwardedHeaders && forwardedHost ? forwardedHost : hostHeader;
-  const effectiveProto =
-    usingForwardedHeaders && forwardedProto ? forwardedProto : defaultProto;
+  const effectiveClientIp = usingForwardedHeaders && forwardedFor ? forwardedFor : remoteIp;
+  const effectiveHost = usingForwardedHeaders && forwardedHost ? forwardedHost : hostHeader;
+  const effectiveProto = usingForwardedHeaders && forwardedProto ? forwardedProto : defaultProto;
 
   if (!effectiveHost) {
     return {

package/src/send.ts

@@ -1,15 +1,15 @@
 import { randomUUID } from "node:crypto";
-import { SsrFBlockedError, fetchWithSsrFGuard } from "openclaw/plugin-sdk";
-import type { CoreConfig } from "./types.js";
+import { fetchWithSsrFGuard, SsrFBlockedError } from "openclaw/plugin-sdk/infra-runtime";
 import { resolveGroupMeAccount } from "./accounts.js";
 import { getGroupMeRuntime } from "./runtime.js";
 import { resolveGroupMeSecurity } from "./security.js";
+import type { CoreConfig } from "./types.js";
 
-export const GROUPME_API_BASE = "https://api.groupme.com/v3";
-export const GROUPME_IMAGE_SERVICE = "https://image.groupme.com";
+const GROUPME_API_BASE = "https://api.groupme.com/v3";
+const GROUPME_IMAGE_SERVICE = "https://image.groupme.com";
 export const GROUPME_MAX_TEXT_LENGTH = 1000;
 
-export type SendGroupMeResult = {
+type SendGroupMeResult = {
   messageId: string;
   timestamp: number;
 };
@@ -33,8 +33,10 @@ export async function sendGroupMeMessage(params: {
   text: string;
   pictureUrl?: string;
   fetchFn?: FetchLike;
+  apiBaseUrl?: string;
 }): Promise<SendGroupMeResult> {
   const fetchFn = params.fetchFn ?? fetch;
+  const apiBaseUrl = params.apiBaseUrl ?? GROUPME_API_BASE;
   const payload: { bot_id: string; text: string; picture_url?: string } = {
     bot_id: params.botId,
     text: params.text,
@@ -42,7 +44,7 @@ export async function sendGroupMeMessage(params: {
   if (params.pictureUrl) {
     payload.picture_url = params.pictureUrl;
   }
-  const response = await fetchFn(`${GROUPME_API_BASE}/bots/post`, {
+  const response = await fetchFn(`${apiBaseUrl}/bots/post`, {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
@@ -51,9 +53,7 @@ export async function sendGroupMeMessage(params: {
   });
 
   if (!response.ok) {
-    throw new Error(
-      `GroupMe API error: ${response.status} ${response.statusText}`,
-    );
+    throw new Error(`GroupMe API error: ${response.status} ${response.statusText}`);
   }
 
   return {
@@ -63,8 +63,7 @@ export async function sendGroupMeMessage(params: {
 }
 
 function extractPictureUrl(value: unknown): string | null {
-  const url = (value as { payload?: { picture_url?: unknown } })?.payload
-    ?.picture_url;
+  const url = (value as { payload?: { picture_url?: unknown } })?.payload?.picture_url;
   if (typeof url !== "string") return null;
   return url.trim() || null;
 }
@@ -74,9 +73,11 @@ export async function uploadGroupMeImage(params: {
   imageData: Buffer;
   contentType?: string;
   fetchFn?: FetchLike;
+  imageBaseUrl?: string;
 }): Promise<string> {
   const fetchFn = params.fetchFn ?? fetch;
-  const response = await fetchFn(`${GROUPME_IMAGE_SERVICE}/pictures`, {
+  const imageBaseUrl = params.imageBaseUrl ?? GROUPME_IMAGE_SERVICE;
+  const response = await fetchFn(`${imageBaseUrl}/pictures`, {
     method: "POST",
     headers: {
       "X-Access-Token": params.accessToken,
@@ -106,10 +107,7 @@ async function downloadRemoteMedia(params: {
   allowedMimePrefixes: string[];
   fetchFn?: FetchLike;
 }): Promise<{ data: Buffer; contentType: string }> {
-  const timedFetch = wrapFetchWithTimeout(
-    params.fetchFn,
-    params.requestTimeoutMs,
-  );
+  const timedFetch = wrapFetchWithTimeout(params.fetchFn, params.requestTimeoutMs);
 
   try {
     const runtimeFetcher = getGroupMeRuntime().channel.media
@@ -152,16 +150,11 @@ async function downloadRemoteMedia(params: {
     try {
       const response = guarded.response;
       if (!response.ok) {
-        throw new Error(
-          `GroupMe media download failed: ${response.status} ${response.statusText}`,
-        );
+        throw new Error(`GroupMe media download failed: ${response.status} ${response.statusText}`);
       }
 
       const contentLength = Number(response.headers.get("content-length"));
-      if (
-        Number.isFinite(contentLength) &&
-        contentLength > params.maxDownloadBytes
-      ) {
+      if (Number.isFinite(contentLength) && contentLength > params.maxDownloadBytes) {
         throw new Error(
           `GroupMe media download exceeds maxDownloadBytes (${contentLength} > ${params.maxDownloadBytes})`,
         );
@@ -172,10 +165,7 @@ async function downloadRemoteMedia(params: {
         allowedMimePrefixes: params.allowedMimePrefixes,
       });
 
-      const data = await readResponseBodyWithLimit(
-        response,
-        params.maxDownloadBytes,
-      );
+      const data = await readResponseBodyWithLimit(response, params.maxDownloadBytes);
       return { data, contentType };
     } finally {
       await guarded.release();
@@ -188,10 +178,7 @@ async function downloadRemoteMedia(params: {
   }
 }
 
-function wrapFetchWithTimeout(
-  fetchFn: FetchLike | undefined,
-  timeoutMs: number,
-): FetchLike {
+function wrapFetchWithTimeout(fetchFn: FetchLike | undefined, timeoutMs: number): FetchLike {
   const base = fetchFn ?? fetch;
   return async (input: RequestInfo | URL, init?: RequestInit) => {
     const controller = new AbortController();
@@ -199,6 +186,9 @@ function wrapFetchWithTimeout(
       controller.abort("GroupMe media fetch timed out");
     }, timeoutMs);
 
+    // Upstream init.signal bridging: our call sites never pass one, so the abort
+    // wiring below is kept for callers that do but is not exercised by tests.
+    /* v8 ignore start */
     const upstreamSignal = init?.signal;
     const onAbort = () => controller.abort(upstreamSignal?.reason);
     if (upstreamSignal) {
@@ -208,6 +198,7 @@ function wrapFetchWithTimeout(
         upstreamSignal.addEventListener("abort", onAbort, { once: true });
       }
     }
+    /* v8 ignore stop */
 
     try {
       return await base(input, {
@@ -216,9 +207,11 @@ function wrapFetchWithTimeout(
       });
     } finally {
       clearTimeout(timeout);
+      /* v8 ignore start */
       if (upstreamSignal) {
         upstreamSignal.removeEventListener("abort", onAbort);
       }
+      /* v8 ignore stop */
     }
   };
 }
@@ -227,15 +220,10 @@ function enforceMimePolicy(params: {
   contentType: string | undefined;
   allowedMimePrefixes: string[];
 }): string {
-  const contentType = (params.contentType ?? "")
-    .split(";")[0]
-    ?.trim()
-    .toLowerCase();
+  const contentType = (params.contentType ?? "").split(";")[0]?.trim().toLowerCase();
   if (
     !contentType ||
-    !params.allowedMimePrefixes.some((prefix) =>
-      contentType.startsWith(prefix.toLowerCase()),
-    )
+    !params.allowedMimePrefixes.some((prefix) => contentType.startsWith(prefix.toLowerCase()))
   ) {
     throw new Error(
       `GroupMe media download blocked by MIME policy (${contentType || "missing content-type"})`,
@@ -316,6 +304,7 @@ export async function sendGroupMeText(params: {
   text: string;
   accountId?: string | null;
   fetchFn?: FetchLike;
+  apiBaseUrl?: string;
 }): Promise<SendGroupMeResult> {
   const account = resolveGroupMeAccount({
     cfg: params.cfg,
@@ -329,6 +318,7 @@ export async function sendGroupMeText(params: {
     botId: account.botId,
     text: params.text,
     fetchFn: params.fetchFn,
+    apiBaseUrl: params.apiBaseUrl,
   });
 }
 
@@ -339,6 +329,8 @@ export async function sendGroupMeMedia(params: {
   mediaUrl: string;
   accountId?: string | null;
   fetchFn?: FetchLike;
+  apiBaseUrl?: string;
+  imageBaseUrl?: string;
 }): Promise<SendGroupMeResult> {
   const account = resolveGroupMeAccount({
     cfg: params.cfg,
@@ -369,6 +361,7 @@ export async function sendGroupMeMedia(params: {
     imageData: data,
     contentType,
     fetchFn: params.fetchFn,
+    imageBaseUrl: params.imageBaseUrl,
   });
 
   return sendGroupMeMessage({
@@ -376,5 +369,6 @@ export async function sendGroupMeMedia(params: {
     text: params.text,
     pictureUrl,
     fetchFn: params.fetchFn,
+    apiBaseUrl: params.apiBaseUrl,
   });
 }