openclaw-groupme 0.4.3 → 0.5.0

package/src/inbound.ts

@@ -1,37 +1,25 @@
-import type {
-  OpenClawConfig,
-  ReplyPayload,
-  RuntimeEnv,
-} from "openclaw/plugin-sdk";
+import { logInboundDrop } from "openclaw/plugin-sdk/channel-logging";
+import { resolveMentionGatingWithBypass } from "openclaw/plugin-sdk/channel-mention-gating";
+import { createReplyPrefixOptions } from "openclaw/plugin-sdk/channel-reply-options-runtime";
+import { resolveControlCommandGate } from "openclaw/plugin-sdk/command-gating";
+import type { HistoryEntry, OpenClawConfig, ReplyPayload } from "openclaw/plugin-sdk/core";
 import {
   buildPendingHistoryContextFromMap,
   clearHistoryEntriesIfEnabled,
-  createReplyPrefixOptions,
-  logInboundDrop,
   recordPendingHistoryEntryIfEnabled,
-  resolveControlCommandGate,
-  resolveMentionGatingWithBypass,
-  type HistoryEntry,
-} from "openclaw/plugin-sdk";
-import type {
-  GroupMeCallbackData,
-  ResolvedGroupMeAccount,
-  CoreConfig,
-} from "./types.js";
+} from "openclaw/plugin-sdk/reply-history";
+import type { RuntimeEnv } from "openclaw/plugin-sdk/runtime-env";
 import {
   buildGroupMeHistoryEntry,
   formatGroupMeHistoryEntry,
   resolveGroupMeBodyForAgent,
 } from "./history.js";
-import { extractImageUrls, detectGroupMeMention } from "./parse.js";
+import { detectGroupMeMention, extractImageUrls } from "./parse.js";
 import { resolveSenderAccess } from "./policy.js";
 import { getGroupMeRuntime } from "./runtime.js";
-import {
-  GROUPME_MAX_TEXT_LENGTH,
-  sendGroupMeMedia,
-  sendGroupMeText,
-} from "./send.js";
 import { resolveGroupMeSecurity } from "./security.js";
+import { GROUPME_MAX_TEXT_LENGTH, sendGroupMeMedia, sendGroupMeText } from "./send.js";
+import type { CoreConfig, GroupMeCallbackData, ResolvedGroupMeAccount } from "./types.js";
 
 const CHANNEL_ID = "groupme" as const;
 
@@ -57,9 +45,7 @@ function chunkReplyText(params: {
     return [];
   }
 
-  return params.core.channel.text
-    .chunkMarkdownText(trimmed, params.limit)
-    .filter(Boolean);
+  return params.core.channel.text.chunkMarkdownText(trimmed, params.limit).filter(Boolean);
 }
 
 async function deliverGroupMeReply(params: {
@@ -156,20 +142,9 @@ export async function handleGroupMeInbound(params: {
   runtime: RuntimeEnv;
   groupHistories: Map<string, HistoryEntry[]>;
   historyLimit: number;
-  statusSink?: (patch: {
-    lastInboundAt?: number;
-    lastOutboundAt?: number;
-  }) => void;
+  statusSink?: (patch: { lastInboundAt?: number; lastOutboundAt?: number }) => void;
 }): Promise<void> {
-  const {
-    message,
-    account,
-    config,
-    runtime,
-    groupHistories,
-    historyLimit,
-    statusSink,
-  } = params;
+  const { message, account, config, runtime, groupHistories, historyLimit, statusSink } = params;
   const core = getGroupMeRuntime();
 
   const inboundTimestamp = message.createdAt * 1000;
@@ -188,9 +163,7 @@ export async function handleGroupMeInbound(params: {
     allowFrom,
   });
   if (!senderAllowed) {
-    runtime.log?.(
-      `groupme: drop sender ${message.senderId} (not in allowFrom)`,
-    );
+    runtime.log?.(`groupme: drop sender ${message.senderId} (not in allowFrom)`);
     return;
   }
 
@@ -224,8 +197,7 @@ export async function handleGroupMeInbound(params: {
     message.text,
     config as OpenClawConfig,
   );
-  const commandBypassNeedsAllowFrom =
-    security.commandBypass.requireAllowFrom && hasControlCommand;
+  const commandBypassNeedsAllowFrom = security.commandBypass.requireAllowFrom && hasControlCommand;
   const commandBypassCanSkipMention = !(
     security.commandBypass.requireMentionForCommands &&
     requireMention &&
@@ -233,8 +205,7 @@ export async function handleGroupMeInbound(params: {
   );
 
   const commandGate = resolveControlCommandGate({
-    useAccessGroups:
-      config.commands?.useAccessGroups !== false || commandBypassNeedsAllowFrom,
+    useAccessGroups: config.commands?.useAccessGroups !== false || commandBypassNeedsAllowFrom,
     authorizers: [{ configured: allowFrom.length > 0, allowed: senderAllowed }],
     allowTextCommands,
     hasControlCommand,
@@ -257,9 +228,7 @@ export async function handleGroupMeInbound(params: {
     hasAnyMention: false,
     allowTextCommands,
     hasControlCommand: commandBypassCanSkipMention ? hasControlCommand : false,
-    commandAuthorized: commandBypassCanSkipMention
-      ? commandGate.commandAuthorized
-      : false,
+    commandAuthorized: commandBypassCanSkipMention ? commandGate.commandAuthorized : false,
   });
 
   const imageUrls = extractImageUrls(message.attachments);
@@ -291,15 +260,10 @@ export async function handleGroupMeInbound(params: {
     return;
   }
 
-  const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(
-    config as OpenClawConfig,
-  );
-  const storePath = core.channel.session.resolveStorePath(
-    config.session?.store,
-    {
-      agentId: route.agentId,
-    },
-  );
+  const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(config as OpenClawConfig);
+  const storePath = core.channel.session.resolveStorePath(config.session?.store, {
+    agentId: route.agentId,
+  });
   const previousTimestamp = core.channel.session.readSessionUpdatedAt({
     storePath,
     sessionKey: route.sessionKey,
@@ -313,6 +277,14 @@ export async function handleGroupMeInbound(params: {
     envelope: envelopeOptions,
     body: bodyForAgent,
   });
+  // Snapshot-then-clear the per-group buffer. This runs synchronously before the
+  // first `await` below, so it is atomic with respect to other inbound handlers for
+  // the same group (handlers run un-awaited and concurrently up to maxConcurrent).
+  // Accepted behavior: if two mentions for the same group arrive nearly together,
+  // the first handler consumes the buffered context and the second sees an empty
+  // buffer rather than re-reading the same entries — buffered context is consumed
+  // exactly once, never duplicated. Messages buffered while a reply is in flight are
+  // preserved because the clear happens before dispatch.
   const shouldUseHistoryBuffer = requireMention && historyLimit > 0;
   const historyEntriesForContext = shouldUseHistoryBuffer
     ? [...(groupHistories.get(message.groupId) ?? [])]
@@ -325,24 +297,22 @@ export async function handleGroupMeInbound(params: {
     });
   }
 
-  const combinedBody =
-    shouldUseHistoryBuffer
-      ? buildPendingHistoryContextFromMap({
-          historyMap: new Map([[message.groupId, historyEntriesForContext]]),
-          historyKey: message.groupId,
-          limit: historyLimit,
-          currentMessage: body,
-          formatEntry: formatGroupMeHistoryEntry,
-        })
-      : body;
-  const inboundHistory =
-    shouldUseHistoryBuffer
-      ? historyEntriesForContext.map((entry) => ({
-          sender: entry.sender,
-          body: entry.body,
-          timestamp: entry.timestamp,
-        }))
-      : undefined;
+  const combinedBody = shouldUseHistoryBuffer
+    ? buildPendingHistoryContextFromMap({
+        historyMap: new Map([[message.groupId, historyEntriesForContext]]),
+        historyKey: message.groupId,
+        limit: historyLimit,
+        currentMessage: body,
+        formatEntry: formatGroupMeHistoryEntry,
+      })
+    : body;
+  const inboundHistory = shouldUseHistoryBuffer
+    ? historyEntriesForContext.map((entry) => ({
+        sender: entry.sender,
+        body: entry.body,
+        timestamp: entry.timestamp,
+      }))
+    : undefined;
 
   const ctxPayload = core.channel.reply.finalizeInboundContext({
     Body: combinedBody,

package/src/monitor.ts

@@ -1,54 +1,47 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
-import type { HistoryEntry } from "openclaw/plugin-sdk";
-import type { RuntimeEnv } from "openclaw/plugin-sdk";
+import type { HistoryEntry } from "openclaw/plugin-sdk/core";
+import type { RuntimeEnv } from "openclaw/plugin-sdk/runtime-env";
 import {
   readJsonBodyWithLimit,
   requestBodyErrorToText,
-} from "openclaw/plugin-sdk";
+} from "openclaw/plugin-sdk/webhook-request-guards";
 import { resolveGroupMeHistoryLimit } from "./history.js";
 import { handleGroupMeInbound } from "./inbound.js";
 import { parseGroupMeCallback, shouldProcessCallback } from "./parse.js";
 import { GroupMeRateLimiter } from "./rate-limit.js";
-import { GroupMeReplayCache, buildReplayKey } from "./replay-cache.js";
+import { buildReplayKey, GroupMeReplayCache } from "./replay-cache.js";
 import {
   checkGroupBinding,
-  redactCallbackUrl,
+  type ResolvedGroupMeSecurity,
+  redactWebhookUrl,
   resolveGroupMeSecurity,
   validateProxyRequest,
-  type ResolvedGroupMeSecurity,
   verifyCallbackAuth,
 } from "./security.js";
-import type {
-  CoreConfig,
-  ResolvedGroupMeAccount,
-  WebhookDecision,
-} from "./types.js";
+import type { CoreConfig, ResolvedGroupMeAccount, WebhookDecision } from "./types.js";
 
 // GroupMe callbacks are small JSON payloads; use tighter limits than the SDK
 // defaults (DEFAULT_WEBHOOK_MAX_BODY_BYTES = 1 MB, DEFAULT_WEBHOOK_BODY_TIMEOUT_MS = 30 s).
 const GROUPME_WEBHOOK_MAX_BODY_BYTES = 64 * 1024;
 const GROUPME_WEBHOOK_BODY_TIMEOUT_MS = 15_000;
 
-export type GroupMeWebhookHandlerParams = {
+type GroupMeWebhookHandlerParams = {
   account: ResolvedGroupMeAccount;
   config: CoreConfig;
   runtime: RuntimeEnv;
-  statusSink?: (patch: {
-    lastInboundAt?: number;
-    lastOutboundAt?: number;
-  }) => void;
+  statusSink?: (patch: { lastInboundAt?: number; lastOutboundAt?: number }) => void;
 };
 
 function rejectDecision(params: {
   status: number;
   reason: string;
-  logLevel?: "debug" | "warn";
+  logLevel: "debug" | "warn";
 }): WebhookDecision {
   return {
     kind: "reject",
     status: params.status,
     reason: params.reason,
-    logLevel: params.logLevel ?? "warn",
+    logLevel: params.logLevel,
   };
 }
 
@@ -77,6 +70,9 @@ function asRequestBodyErrorCode(
   ) {
     return value;
   }
+  // Only ever called with the three codes above (INVALID_JSON returns earlier in
+  // the handler), so this null path is unreachable defense-in-depth.
+  /* v8 ignore next */
   return null;
 }
 
@@ -90,10 +86,7 @@ function logWebhookRejection(params: {
     return;
   }
   const url = params.security.logging.redactSecrets
-    ? redactCallbackUrl(
-        `${params.reqUrl.pathname}${params.reqUrl.search}`,
-        params.security,
-      )
+    ? redactWebhookUrl(`${params.reqUrl.pathname}${params.reqUrl.search}`, params.security)
     : `${params.reqUrl.pathname}${params.reqUrl.search}`;
   const line = `groupme: webhook rejected (${params.decision.reason}) status=${params.decision.status} url=${url}`;
   if (params.decision.logLevel === "warn") {
@@ -148,14 +141,13 @@ async function decideWebhookRequest(params: {
     emptyObjectOnEmpty: false,
   });
   if (!body.ok) {
-    let status: number;
-    if (body.code === "PAYLOAD_TOO_LARGE") {
-      status = 413;
-    } else if (body.code === "REQUEST_BODY_TIMEOUT") {
-      status = 408;
-    } else {
-      status = 400;
-    }
+    // Map the SDK body-error code to an HTTP status; unmapped codes (INVALID_JSON,
+    // CONNECTION_CLOSED, …) fall back to 400.
+    const bodyErrorStatus: Record<string, number | undefined> = {
+      PAYLOAD_TOO_LARGE: 413,
+      REQUEST_BODY_TIMEOUT: 408,
+    };
+    const status = bodyErrorStatus[body.code] ?? 400;
     return rejectDecision({
       status,
       reason: `body_${body.code.toLowerCase()}`,
@@ -193,19 +185,13 @@ async function decideWebhookRequest(params: {
     });
   }
 
-  if (params.security.replay.enabled) {
-    const replay = params.replayCache.checkAndRemember(buildReplayKey(message));
-    if (replay.kind === "duplicate") {
-      return rejectDecision({
-        status: 200,
-        reason: "duplicate_replay",
-        logLevel: "debug",
-      });
-    }
-  }
-
-  if (!params.security.rateLimit.enabled) {
-    return { kind: "accept", message, release: () => undefined };
+  const replay = params.replayCache.checkAndRemember(buildReplayKey(message));
+  if (replay.kind === "duplicate") {
+    return rejectDecision({
+      status: 200,
+      reason: "duplicate_replay",
+      logLevel: "debug",
+    });
   }
 
   const rate = params.rateLimiter.evaluate({
@@ -227,15 +213,18 @@ export function createGroupMeWebhookHandler(
   params: GroupMeWebhookHandlerParams,
 ): (req: IncomingMessage, res: ServerResponse) => Promise<void> {
   const groupHistories = new Map<string, HistoryEntry[]>();
-  const historyLimit = resolveGroupMeHistoryLimit(
-    params.account.config.historyLimit,
-  );
+  const historyLimit = resolveGroupMeHistoryLimit(params.account.config.historyLimit);
   const security = resolveGroupMeSecurity(params.account.config);
   if (!security.groupId) {
     params.runtime.error?.(
       "groupme: WARNING — no groupId configured; all inbound messages will be rejected. Set groupId in your account config.",
     );
   }
+  if (!security.callbackToken) {
+    params.runtime.error?.(
+      "groupme: WARNING — no callbackToken configured; inbound callbacks are not token-authenticated. Anyone who learns the webhook path and group_id can post. Set callbackToken in your account config.",
+    );
+  }
   const replayCache = new GroupMeReplayCache({
     ttlSeconds: security.replay.ttlSeconds,
     maxEntries: security.replay.maxEntries,
@@ -280,9 +269,7 @@ export function createGroupMeWebhookHandler(
         }
         const requestBodyErrorCode = asRequestBodyErrorCode(code);
         if (requestBodyErrorCode) {
-          res.end(
-            requestBodyErrorToText(requestBodyErrorCode),
-          );
+          res.end(requestBodyErrorToText(requestBodyErrorCode));
           return;
         }
       }
@@ -304,9 +291,7 @@ export function createGroupMeWebhookHandler(
       historyLimit,
     })
       .catch((err) => {
-        params.runtime.error?.(
-          `groupme: inbound processing failed: ${String(err)}`,
-        );
+        params.runtime.error?.(`groupme: inbound processing failed: ${String(err)}`);
       })
       .finally(() => {
         release();

package/src/normalize.ts

@@ -1,4 +1,10 @@
-export function normalizeStringId(raw: string | number): string | undefined {
+export function normalizeStringId(raw: unknown): string | undefined {
+  if (typeof raw !== "string" && typeof raw !== "number") {
+    return undefined;
+  }
+  if (typeof raw === "number" && !Number.isFinite(raw)) {
+    return undefined;
+  }
   const normalized = String(raw).trim();
   return normalized || undefined;
 }