gewe-openclaw 2026.1.29

package/src/media-server.ts

@@ -0,0 +1,154 @@
+import { createReadStream, existsSync } from "node:fs";
+import fs from "node:fs/promises";
+import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
+import os from "node:os";
+import path from "node:path";
+
+import { detectMime } from "openclaw/plugin-sdk";
+
+export const DEFAULT_MEDIA_HOST = "0.0.0.0";
+export const DEFAULT_MEDIA_PORT = 18787;
+export const DEFAULT_MEDIA_PATH = "/gewe-media";
+
+function normalizePath(value: string): string {
+  const trimmed = value.trim() || "/";
+  if (trimmed === "/") return "/";
+  return trimmed.startsWith("/") ? trimmed.replace(/\/+$/, "") : `/${trimmed.replace(/\/+$/, "")}`;
+}
+
+function resolveUserPath(input: string): string {
+  const trimmed = input.trim();
+  if (!trimmed) return trimmed;
+  if (trimmed.startsWith("~")) {
+    const expanded = trimmed.replace(/^~(?=$|[\\/])/, os.homedir());
+    return path.resolve(expanded);
+  }
+  return path.resolve(trimmed);
+}
+
+function resolveConfigDir(
+  env: NodeJS.ProcessEnv = process.env,
+  homedir: () => string = os.homedir,
+): string {
+  const override = env.OPENCLAW_STATE_DIR?.trim() || env.CLAWDBOT_STATE_DIR?.trim();
+  if (override) return resolveUserPath(override);
+  const legacyDirs = [".clawdbot", ".moltbot", ".moldbot"].map((dir) =>
+    path.join(homedir(), dir),
+  );
+  const newDir = path.join(homedir(), ".openclaw");
+  try {
+    if (existsSync(newDir)) return newDir;
+    const existingLegacy = legacyDirs.find((dir) => {
+      try {
+        return existsSync(dir);
+      } catch {
+        return false;
+      }
+    });
+    if (existingLegacy) return existingLegacy;
+  } catch {
+    // best-effort
+  }
+  return newDir;
+}
+
+function resolveMediaDir() {
+  return path.join(resolveConfigDir(), "media");
+}
+
+function resolveBaseUrl(req: IncomingMessage): string {
+  const host = req.headers.host || "localhost";
+  return `http://${host}`;
+}
+
+function isSafeMediaId(id: string): boolean {
+  if (!id) return false;
+  if (id.includes("..")) return false;
+  return !id.includes("/") && !id.includes("\\");
+}
+
+export type GeweMediaServerOptions = {
+  host?: string;
+  port?: number;
+  path?: string;
+  abortSignal?: AbortSignal;
+};
+
+export function createGeweMediaServer(
+  opts: GeweMediaServerOptions,
+): { server: Server; start: () => Promise<void>; stop: () => void } {
+  const host = opts.host ?? DEFAULT_MEDIA_HOST;
+  const port = opts.port ?? DEFAULT_MEDIA_PORT;
+  const basePath = normalizePath(opts.path ?? DEFAULT_MEDIA_PATH);
+  const mediaBaseDir = path.join(resolveMediaDir(), "outbound");
+
+  const server = createServer(async (req: IncomingMessage, res: ServerResponse) => {
+    if (!req.url) {
+      res.writeHead(404);
+      res.end();
+      return;
+    }
+    if (req.method !== "GET" && req.method !== "HEAD") {
+      res.writeHead(405);
+      res.end();
+      return;
+    }
+
+    const url = new URL(req.url, resolveBaseUrl(req));
+    if (!url.pathname.startsWith(`${basePath}/`)) {
+      res.writeHead(404);
+      res.end();
+      return;
+    }
+
+    const id = decodeURIComponent(url.pathname.slice(basePath.length + 1));
+    if (!isSafeMediaId(id)) {
+      res.writeHead(400);
+      res.end();
+      return;
+    }
+
+    const filePath = path.join(mediaBaseDir, id);
+    const stat = await fs.stat(filePath).catch(() => null);
+    if (!stat || !stat.isFile()) {
+      res.writeHead(404);
+      res.end();
+      return;
+    }
+
+    const contentType = await detectMime({ filePath }).catch(() => undefined);
+    const headers: Record<string, string> = {
+      "Content-Length": String(stat.size),
+      "Cache-Control": "private, max-age=60",
+    };
+    if (contentType) headers["Content-Type"] = contentType;
+
+    res.writeHead(200, headers);
+    if (req.method === "HEAD") {
+      res.end();
+      return;
+    }
+
+    const stream = createReadStream(filePath);
+    stream.on("error", () => {
+      if (!res.headersSent) res.writeHead(500);
+      res.end();
+    });
+    stream.pipe(res);
+  });
+
+  const start = (): Promise<void> =>
+    new Promise((resolve) => {
+      server.listen(port, host, () => resolve());
+    });
+
+  const stop = () => {
+    server.close();
+  };
+
+  if (opts.abortSignal) {
+    opts.abortSignal.addEventListener("abort", stop, { once: true });
+  }
+
+  return { server, start, stop };
+}

package/src/monitor.ts

@@ -0,0 +1,351 @@
+import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
+
+import type { RuntimeEnv } from "openclaw/plugin-sdk";
+
+import { resolveGeweAccount } from "./accounts.js";
+import { GeweDownloadQueue } from "./download-queue.js";
+import { handleGeweInbound } from "./inbound.js";
+import { createGeweMediaServer, DEFAULT_MEDIA_HOST, DEFAULT_MEDIA_PATH, DEFAULT_MEDIA_PORT } from "./media-server.js";
+import { getGeweRuntime } from "./runtime.js";
+import type {
+  CoreConfig,
+  GeweCallbackPayload,
+  GeweInboundMessage,
+  GeweWebhookServerOptions,
+  ResolvedGeweAccount,
+} from "./types.js";
+
+const DEFAULT_WEBHOOK_PORT = 18786;
+const DEFAULT_WEBHOOK_HOST = "0.0.0.0";
+const DEFAULT_WEBHOOK_PATH = "/gewe-webhook";
+const HEALTH_PATH = "/healthz";
+const DEDUPE_TTL_MS = 12 * 60 * 60 * 1000;
+
+const SEEN_MESSAGES = new Map<string, number>();
+
+function cleanupSeen() {
+  const now = Date.now();
+  for (const [key, ts] of SEEN_MESSAGES.entries()) {
+    if (now - ts > DEDUPE_TTL_MS) {
+      SEEN_MESSAGES.delete(key);
+    }
+  }
+}
+
+function isDuplicate(key: string): boolean {
+  cleanupSeen();
+  if (SEEN_MESSAGES.has(key)) return true;
+  SEEN_MESSAGES.set(key, Date.now());
+  return false;
+}
+
+function formatError(err: unknown): string {
+  if (err instanceof Error) return err.message;
+  return typeof err === "string" ? err : JSON.stringify(err);
+}
+
+function readBody(req: IncomingMessage): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    req.on("data", (chunk: Buffer) => chunks.push(chunk));
+    req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+    req.on("error", reject);
+  });
+}
+
+function resolveWebhookToken(req: IncomingMessage): string | undefined {
+  const headers = req.headers as Record<string, string | string[] | undefined>;
+  const candidates = [
+    headers["x-gewe-callback-token"],
+    headers["x-webhook-token"],
+    headers["x-gewe-token"],
+  ];
+  for (const value of candidates) {
+    if (!value) continue;
+    if (Array.isArray(value)) {
+      const first = value[0]?.trim();
+      if (first) return first;
+      continue;
+    }
+    const trimmed = value.trim();
+    if (trimmed) return trimmed;
+  }
+  return undefined;
+}
+
+function validateWebhookSecret(
+  req: IncomingMessage,
+  path: string,
+  secret?: string,
+): { ok: boolean; reason?: string } {
+  if (!secret) return { ok: true };
+  const headerToken = resolveWebhookToken(req);
+  if (headerToken && headerToken === secret) return { ok: true };
+  try {
+    const url = new URL(req.url ?? "", `http://${req.headers.host || "localhost"}`);
+    const token = url.searchParams.get("token");
+    if (token && token === secret) return { ok: true };
+  } catch {
+    // ignore URL parse errors
+  }
+  return {
+    ok: false,
+    reason: `Missing or invalid webhook token for ${path}`,
+  };
+}
+
+function splitGroupContent(raw: string): { senderId?: string; body: string } {
+  const marker = ":\n";
+  const index = raw.indexOf(marker);
+  if (index > 0) {
+    const sender = raw.slice(0, index).trim();
+    const body = raw.slice(index + marker.length);
+    if (sender) return { senderId: sender, body };
+  }
+  return { body: raw };
+}
+
+function resolveSenderName(pushContent?: string): string | undefined {
+  const value = pushContent?.trim();
+  if (!value) return undefined;
+  const index = value.indexOf(" : ");
+  if (index > 0) {
+    return value.slice(0, index).trim() || undefined;
+  }
+  const altIndex = value.indexOf(": ");
+  if (altIndex > 0) {
+    return value.slice(0, altIndex).trim() || undefined;
+  }
+  return undefined;
+}
+
+function parseWebhookPayload(body: string): GeweCallbackPayload | null {
+  try {
+    const data = JSON.parse(body);
+    return data as GeweCallbackPayload;
+  } catch {
+    return null;
+  }
+}
+
+function payloadToInboundMessage(payload: GeweCallbackPayload): GeweInboundMessage | null {
+  const appId = payload.Appid?.trim() ?? "";
+  const botWxid = payload.Wxid?.trim() ?? "";
+  const data = payload.Data;
+  if (!data || !appId || !botWxid) return null;
+
+  const fromId = data.FromUserName?.string?.trim() ?? "";
+  const toId = data.ToUserName?.string?.trim() ?? "";
+  const msgType = typeof data.MsgType === "number" ? data.MsgType : -1;
+  const content = data.Content?.string ?? "";
+  const msgId = data.MsgId ?? data.NewMsgId ?? 0;
+  const newMsgId = data.NewMsgId ?? data.MsgId ?? 0;
+  const createTime = data.CreateTime ?? 0;
+  const timestamp = createTime ? createTime * 1000 : Date.now();
+  if (!fromId || !toId || msgType < 0) return null;
+
+  const isGroupChat = fromId.endsWith("@chatroom") || toId.endsWith("@chatroom");
+  const groupParsed = isGroupChat ? splitGroupContent(content) : { body: content };
+  const senderId = (isGroupChat ? groupParsed.senderId : fromId) ?? fromId;
+  const text = groupParsed.body?.trim() ?? "";
+
+  return {
+    messageId: String(msgId),
+    newMessageId: String(newMsgId),
+    appId,
+    botWxid,
+    fromId,
+    toId,
+    senderId,
+    senderName: resolveSenderName(data.PushContent),
+    text,
+    msgType,
+    xml: text,
+    timestamp,
+    isGroupChat,
+  };
+}
+
+export function createGeweWebhookServer(opts: GeweWebhookServerOptions): {
+  server: Server;
+  start: () => Promise<void>;
+  stop: () => void;
+} {
+  const { port, host, path, secret, onMessage, onError, abortSignal } = opts;
+
+  const server = createServer(async (req: IncomingMessage, res: ServerResponse) => {
+    if (req.url === HEALTH_PATH) {
+      res.writeHead(200, { "Content-Type": "text/plain" });
+      res.end("ok");
+      return;
+    }
+
+    if (req.url?.split("?")[0] !== path || req.method !== "POST") {
+      res.writeHead(404);
+      res.end();
+      return;
+    }
+
+    const auth = validateWebhookSecret(req, path, secret);
+    if (!auth.ok) {
+      res.writeHead(401, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: auth.reason || "Unauthorized" }));
+      return;
+    }
+
+    try {
+      const body = await readBody(req);
+      const payload = parseWebhookPayload(body);
+      if (!payload) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Invalid JSON payload" }));
+        return;
+      }
+      const message = payloadToInboundMessage(payload);
+      if (!message) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Invalid webhook payload" }));
+        return;
+      }
+
+      res.writeHead(200);
+      res.end();
+
+      try {
+        await onMessage(message);
+      } catch (err) {
+        onError?.(err instanceof Error ? err : new Error(formatError(err)));
+      }
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(formatError(err));
+      onError?.(error);
+      if (!res.headersSent) {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Internal server error" }));
+      }
+    }
+  });
+
+  const start = (): Promise<void> => {
+    return new Promise((resolve) => {
+      server.listen(port, host, () => resolve());
+    });
+  };
+
+  const stop = () => {
+    server.close();
+  };
+
+  if (abortSignal) {
+    abortSignal.addEventListener("abort", stop, { once: true });
+  }
+
+  return { server, start, stop };
+}
+
+export type GeweMonitorOptions = {
+  accountId?: string;
+  account?: ResolvedGeweAccount;
+  config?: CoreConfig;
+  runtime?: RuntimeEnv;
+  abortSignal?: AbortSignal;
+  statusSink?: (patch: { lastInboundAt?: number; lastOutboundAt?: number }) => void;
+};
+
+export async function monitorGeweProvider(
+  opts: GeweMonitorOptions,
+): Promise<{ stop: () => void }> {
+  const core = getGeweRuntime();
+  const cfg = opts.config ?? (core.config.loadConfig() as CoreConfig);
+  const account = opts.account ?? resolveGeweAccount({ cfg, accountId: opts.accountId });
+  const runtime: RuntimeEnv = opts.runtime ?? {
+    log: (message: string) => core.logging.getChildLogger().info(message),
+    error: (message: string) => core.logging.getChildLogger().error(message),
+    exit: () => {
+      throw new Error("Runtime exit not available");
+    },
+  };
+
+  if (!account.token || !account.appId) {
+    throw new Error(`GeWe not configured for account "${account.accountId}" (token/appId missing)`);
+  }
+
+  const port = account.config.webhookPort ?? DEFAULT_WEBHOOK_PORT;
+  const host = account.config.webhookHost ?? DEFAULT_WEBHOOK_HOST;
+  const rawPath = account.config.webhookPath?.trim() || DEFAULT_WEBHOOK_PATH;
+  const path = rawPath.startsWith("/") ? rawPath : `/${rawPath}`;
+  const secret = account.config.webhookSecret?.trim() || undefined;
+
+  const downloadQueue = new GeweDownloadQueue({
+    minDelayMs: account.config.downloadMinDelayMs,
+    maxDelayMs: account.config.downloadMaxDelayMs,
+  });
+
+  const webhookServer = createGeweWebhookServer({
+    port,
+    host,
+    path,
+    secret,
+    onMessage: async (message) => {
+      const isSelf = message.fromId === message.botWxid || message.senderId === message.botWxid;
+      if (isSelf) return;
+
+      const dedupeKey = `${message.appId}:${message.newMessageId}`;
+      if (isDuplicate(dedupeKey)) return;
+
+      await handleGeweInbound({
+        message,
+        account,
+        config: cfg,
+        runtime,
+        downloadQueue,
+        statusSink: opts.statusSink,
+      });
+    },
+    onError: (err) => runtime.error?.(`gewe webhook error: ${String(err)}`),
+    abortSignal: opts.abortSignal,
+  });
+
+  await webhookServer.start();
+  runtime.log?.(`[${account.accountId}] GeWe webhook server listening on ${host}:${port}${path}`);
+
+  let mediaStop: (() => void) | undefined;
+  const shouldStartMedia =
+    Boolean(account.config.mediaPublicUrl) ||
+    Boolean(account.config.mediaPort || account.config.mediaHost || account.config.mediaPath);
+
+  if (shouldStartMedia) {
+    const mediaServer = createGeweMediaServer({
+      host: account.config.mediaHost ?? DEFAULT_MEDIA_HOST,
+      port: account.config.mediaPort ?? DEFAULT_MEDIA_PORT,
+      path: account.config.mediaPath ?? DEFAULT_MEDIA_PATH,
+      abortSignal: opts.abortSignal,
+    });
+    await mediaServer.start();
+    mediaStop = mediaServer.stop;
+    runtime.log?.(
+      `[${account.accountId}] GeWe media server listening on ${account.config.mediaHost ?? DEFAULT_MEDIA_HOST}:${account.config.mediaPort ?? DEFAULT_MEDIA_PORT}${account.config.mediaPath ?? DEFAULT_MEDIA_PATH}`,
+    );
+  }
+
+  let resolveRunning: (() => void) | undefined;
+  const runningPromise = new Promise<void>((resolve) => {
+    resolveRunning = resolve;
+    if (!opts.abortSignal) return;
+    if (opts.abortSignal.aborted) {
+      resolve();
+      return;
+    }
+    opts.abortSignal.addEventListener("abort", () => resolve(), { once: true });
+  });
+
+  const stop = () => {
+    webhookServer.stop();
+    if (mediaStop) mediaStop();
+    resolveRunning?.();
+  };
+
+  await runningPromise;
+
+  return { stop };
+}

package/src/normalize.ts

@@ -0,0 +1,19 @@
+export function normalizeGeweMessagingTarget(target: string): string | null {
+  const trimmed = target.trim();
+  if (!trimmed) return null;
+  return trimmed
+    .replace(/^gewe:(group:|user:)?/i, "")
+    .replace(/^wechat:(group:|user:)?/i, "")
+    .replace(/^wx:/i, "")
+    .trim();
+}
+
+export function looksLikeGeweTargetId(id: string): boolean {
+  const trimmed = id?.trim();
+  if (!trimmed) return false;
+  if (/^gewe:/i.test(trimmed)) return true;
+  if (/@chatroom$/i.test(trimmed)) return true;
+  if (/^wxid_/i.test(trimmed)) return true;
+  if (/^gh_/i.test(trimmed)) return true;
+  return trimmed.length >= 3;
+}

package/src/policy.ts

@@ -0,0 +1,185 @@
+import type { AllowlistMatch, ChannelGroupContext, GroupPolicy } from "openclaw/plugin-sdk";
+import {
+  buildChannelKeyCandidates,
+  normalizeChannelSlug,
+  resolveChannelEntryMatchWithFallback,
+  resolveMentionGatingWithBypass,
+  resolveNestedAllowlistDecision,
+} from "openclaw/plugin-sdk";
+
+import type { GeweGroupConfig } from "./types.js";
+
+function normalizeAllowEntry(raw: string): string {
+  return raw.trim().toLowerCase().replace(/^(gewe|wechat|wx):/i, "");
+}
+
+export function normalizeGeweAllowlist(values: Array<string | number> | undefined): string[] {
+  return (values ?? []).map((value) => normalizeAllowEntry(String(value))).filter(Boolean);
+}
+
+export function resolveGeweAllowlistMatch(params: {
+  allowFrom: Array<string | number> | undefined;
+  senderId: string;
+  senderName?: string | null;
+}): AllowlistMatch<"wildcard" | "id" | "name"> {
+  const allowFrom = normalizeGeweAllowlist(params.allowFrom);
+  if (allowFrom.length === 0) return { allowed: false };
+  if (allowFrom.includes("*")) {
+    return { allowed: true, matchKey: "*", matchSource: "wildcard" };
+  }
+  const senderId = normalizeAllowEntry(params.senderId);
+  if (allowFrom.includes(senderId)) {
+    return { allowed: true, matchKey: senderId, matchSource: "id" };
+  }
+  const senderName = params.senderName ? normalizeAllowEntry(params.senderName) : "";
+  if (senderName && allowFrom.includes(senderName)) {
+    return { allowed: true, matchKey: senderName, matchSource: "name" };
+  }
+  return { allowed: false };
+}
+
+export type GeweGroupMatch = {
+  groupConfig?: GeweGroupConfig;
+  wildcardConfig?: GeweGroupConfig;
+  groupKey?: string;
+  matchSource?: "direct" | "parent" | "wildcard";
+  allowed: boolean;
+  allowlistConfigured: boolean;
+};
+
+export function resolveGeweGroupMatch(params: {
+  groups?: Record<string, GeweGroupConfig>;
+  groupId: string;
+  groupName?: string | null;
+}): GeweGroupMatch {
+  const groups = params.groups ?? {};
+  const allowlistConfigured = Object.keys(groups).length > 0;
+  const groupName = params.groupName?.trim() || undefined;
+  const candidates = buildChannelKeyCandidates(
+    params.groupId,
+    groupName,
+    groupName ? normalizeChannelSlug(groupName) : undefined,
+  );
+  const match = resolveChannelEntryMatchWithFallback({
+    entries: groups,
+    keys: candidates,
+    wildcardKey: "*",
+    normalizeKey: normalizeChannelSlug,
+  });
+  const groupConfig = match.entry;
+  const allowed = resolveNestedAllowlistDecision({
+    outerConfigured: allowlistConfigured,
+    outerMatched: Boolean(groupConfig),
+    innerConfigured: false,
+    innerMatched: false,
+  });
+
+  return {
+    groupConfig,
+    wildcardConfig: match.wildcardEntry,
+    groupKey: match.matchKey ?? match.key,
+    matchSource: match.matchSource,
+    allowed,
+    allowlistConfigured,
+  };
+}
+
+export function resolveGeweGroupToolPolicy(
+  params: ChannelGroupContext,
+): GeweGroupConfig["tools"] | undefined {
+  const cfg = params.cfg as {
+    channels?: {
+      gewe?: {
+        groups?: Record<string, GeweGroupConfig>;
+        accounts?: Record<string, { groups?: Record<string, GeweGroupConfig> }>;
+      };
+    };
+  };
+  const groupId = params.groupId?.trim();
+  if (!groupId) return undefined;
+  const groupName = params.groupChannel?.trim() || undefined;
+  const accountGroups =
+    params.accountId && cfg.channels?.gewe?.accounts?.[params.accountId]?.groups
+      ? cfg.channels?.gewe?.accounts?.[params.accountId]?.groups
+      : undefined;
+  const groups = accountGroups ?? cfg.channels?.gewe?.groups;
+  const match = resolveGeweGroupMatch({
+    groups,
+    groupId,
+    groupName,
+  });
+  return match.groupConfig?.tools ?? match.wildcardConfig?.tools;
+}
+
+export function resolveGeweRequireMention(params: {
+  groupConfig?: GeweGroupConfig;
+  wildcardConfig?: GeweGroupConfig;
+}): boolean {
+  if (typeof params.groupConfig?.requireMention === "boolean") {
+    return params.groupConfig.requireMention;
+  }
+  if (typeof params.wildcardConfig?.requireMention === "boolean") {
+    return params.wildcardConfig.requireMention;
+  }
+  return true;
+}
+
+export function resolveGeweGroupAllow(params: {
+  groupPolicy: GroupPolicy;
+  outerAllowFrom: Array<string | number> | undefined;
+  innerAllowFrom: Array<string | number> | undefined;
+  senderId: string;
+  senderName?: string | null;
+}): { allowed: boolean; outerMatch: AllowlistMatch; innerMatch: AllowlistMatch } {
+  if (params.groupPolicy === "disabled") {
+    return { allowed: false, outerMatch: { allowed: false }, innerMatch: { allowed: false } };
+  }
+  if (params.groupPolicy === "open") {
+    return { allowed: true, outerMatch: { allowed: true }, innerMatch: { allowed: true } };
+  }
+
+  const outerAllow = normalizeGeweAllowlist(params.outerAllowFrom);
+  const innerAllow = normalizeGeweAllowlist(params.innerAllowFrom);
+  if (outerAllow.length === 0 && innerAllow.length === 0) {
+    return { allowed: false, outerMatch: { allowed: false }, innerMatch: { allowed: false } };
+  }
+
+  const outerMatch = resolveGeweAllowlistMatch({
+    allowFrom: params.outerAllowFrom,
+    senderId: params.senderId,
+    senderName: params.senderName,
+  });
+  const innerMatch = resolveGeweAllowlistMatch({
+    allowFrom: params.innerAllowFrom,
+    senderId: params.senderId,
+    senderName: params.senderName,
+  });
+  const allowed = resolveNestedAllowlistDecision({
+    outerConfigured: outerAllow.length > 0 || innerAllow.length > 0,
+    outerMatched: outerAllow.length > 0 ? outerMatch.allowed : true,
+    innerConfigured: innerAllow.length > 0,
+    innerMatched: innerMatch.allowed,
+  });
+
+  return { allowed, outerMatch, innerMatch };
+}
+
+export function resolveGeweMentionGate(params: {
+  isGroup: boolean;
+  requireMention: boolean;
+  wasMentioned: boolean;
+  allowTextCommands: boolean;
+  hasControlCommand: boolean;
+  commandAuthorized: boolean;
+}): { shouldSkip: boolean; shouldBypassMention: boolean } {
+  const result = resolveMentionGatingWithBypass({
+    isGroup: params.isGroup,
+    requireMention: params.requireMention,
+    canDetectMention: true,
+    wasMentioned: params.wasMentioned,
+    allowTextCommands: params.allowTextCommands,
+    hasControlCommand: params.hasControlCommand,
+    commandAuthorized: params.commandAuthorized,
+  });
+  return { shouldSkip: result.shouldSkip, shouldBypassMention: result.shouldBypassMention };
+}