openclaw-groupme 0.4.3 → 0.5.0

package/dist/src/parse.js

@@ -50,9 +50,7 @@ function parseStringArray(value) {
     if (!Array.isArray(value)) {
         return [];
     }
-    return value
-        .map((entry) => readString(entry))
-        .filter((entry) => Boolean(entry));
+    return value.map((entry) => readString(entry)).filter((entry) => Boolean(entry));
 }
 function parseAttachment(entry) {
     if (!isRecord(entry)) {
@@ -121,13 +119,7 @@ export function parseGroupMeCallback(data) {
     const groupId = readString(data.group_id);
     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") {
@@ -150,7 +142,7 @@ export function parseGroupMeCallback(data) {
         attachments: parseAttachments(data.attachments),
     };
 }
-export function hasImageAttachment(attachments) {
+function hasImageAttachment(attachments) {
     return attachments.some((attachment) => attachment.type === "image");
 }
 export function shouldProcessCallback(msg) {
@@ -171,9 +163,7 @@ export function extractImageUrls(attachments) {
         .map((attachment) => attachment.url);
 }
 function normalizeMentionText(text) {
-    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) {
     if (!patterns || patterns.length === 0) {

package/dist/src/policy.js

@@ -1,4 +1,4 @@
-import { normalizeGroupMeAllowEntry, normalizeStringId, } from "./normalize.js";
+import { normalizeGroupMeAllowEntry, normalizeStringId } from "./normalize.js";
 export function resolveSenderAccess(params) {
     const senderId = normalizeStringId(params.senderId);
     if (!senderId) {

package/dist/src/rate-limit.js

@@ -1,4 +1,8 @@
 const DEFAULT_MAX_TRACKED_KEYS = 10_000;
+function positiveIntegerAtLeastOne(value) {
+    const normalized = Math.floor(value);
+    return Number.isFinite(normalized) ? Math.max(1, normalized) : 1;
+}
 function allowInWindow(params) {
     const { state, key, limit, windowMs, now } = params;
     const current = state.get(key) ?? [];
@@ -22,10 +26,10 @@ export class GroupMeRateLimiter {
     bySender = new Map();
     inFlight = 0;
     constructor(params) {
-        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;
     }
     evaluate(params, now = Date.now()) {
@@ -84,12 +88,13 @@ export class GroupMeRateLimiter {
         }
     }
     capStateSize(state) {
+        // 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;
-            if (!oldest) {
-                return;
-            }
             state.delete(oldest);
         }
+        /* v8 ignore stop */
     }
 }

package/dist/src/replay-cache.js

@@ -32,9 +32,6 @@ export class GroupMeReplayCache {
     evictOverflow() {
         while (this.entries.size > this.maxEntries) {
             const oldest = this.entries.keys().next().value;
-            if (!oldest) {
-                return;
-            }
             this.entries.delete(oldest);
         }
     }

package/dist/src/secret-contract.js

@@ -0,0 +1,49 @@
+import { collectSimpleChannelFieldAssignments, getChannelSurface, } from "openclaw/plugin-sdk/channel-secret-basic-runtime";
+const secretFields = ["botId", "accessToken", "callbackToken"];
+export const secretTargetRegistryEntries = 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) {
+    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/dist/src/security.js

@@ -15,7 +15,7 @@ function normalizeIpCandidate(raw) {
         return "";
     }
     if (value.includes(",")) {
-        value = value.split(",")[0]?.trim() ?? "";
+        value = value.split(",")[0].trim();
     }
     if (value.startsWith("[")) {
         const endIndex = value.indexOf("]");
@@ -36,9 +36,9 @@ function normalizeIpCandidate(raw) {
     if (isIP(value) === 0) {
         const maybeWithPort = value.split(":");
         if (maybeWithPort.length === 2 &&
-            /^\d+$/.test(maybeWithPort[1] ?? "") &&
-            isIP(maybeWithPort[0] ?? "") === 4) {
-            value = maybeWithPort[0] ?? "";
+            /^\d+$/.test(maybeWithPort[1]) &&
+            isIP(maybeWithPort[0]) === 4) {
+            value = maybeWithPort[0];
         }
     }
     return isIP(value) === 0 ? "" : value;
@@ -59,7 +59,7 @@ function normalizeHost(value) {
         return "";
     }
     if (host.includes(",")) {
-        host = host.split(",")[0]?.trim() ?? "";
+        host = host.split(",")[0].trim();
     }
     if (!host) {
         return "";
@@ -75,9 +75,8 @@ function normalizeHost(value) {
         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();
 }
@@ -85,12 +84,16 @@ function parseProxyRules(entries) {
     const rules = [];
     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;
@@ -148,22 +151,9 @@ function createTrustedProxyMatcher(entries) {
         return blockList.check(normalized, "ipv6");
     };
 }
-function extractCallbackToken(callbackUrl) {
-    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) {
     const security = (accountConfig.security ?? {});
-    const callbackToken = extractCallbackToken(accountConfig.callbackUrl);
+    const callbackToken = readTrimmed(accountConfig.callbackToken) ?? "";
     const groupId = readTrimmed(accountConfig.groupId) ?? "";
     const allowedMimePrefixes = Array.isArray(security.media?.allowedMimePrefixes)
         ? security.media.allowedMimePrefixes
@@ -185,12 +175,10 @@ export function resolveGroupMeSecurity(accountConfig) {
         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),
@@ -245,7 +233,7 @@ export function checkGroupBinding(params) {
     }
     return { ok: true };
 }
-export function redactCallbackUrl(raw, security) {
+export function redactWebhookUrl(raw, security) {
     if (!security.callbackToken) {
         return raw;
     }
@@ -264,9 +252,7 @@ export function redactCallbackUrl(raw, security) {
 export function validateProxyRequest(params) {
     const remoteIp = normalizeIpCandidate(params.remoteAddress) || "unknown";
     const proxyConfig = params.security.proxy;
-    const defaultProto = params.socketEncrypted
-        ? "https"
-        : "http";
+    const defaultProto = params.socketEncrypted ? "https" : "http";
     const hostHeader = normalizeHost(getHeaderValue(params.headers, "host"));
     if (!proxyConfig.enabled) {
         return {
@@ -281,17 +267,14 @@ export function validateProxyRequest(params) {
             },
         };
     }
-    const fromTrustedProxy = proxyConfig.trustedProxyCidrs.length > 0 &&
-        proxyConfig.isTrustedProxy(remoteIp);
+    const fromTrustedProxy = 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 forwardedProtoRaw = getHeaderValue(params.headers, "x-forwarded-proto")
         .split(",")[0]
         ?.trim()
         .toLowerCase();
-    const forwardedProto = forwardedProtoRaw === "http" || forwardedProtoRaw === "https"
-        ? forwardedProtoRaw
-        : null;
+    const forwardedProto = 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;

package/dist/src/send.js

@@ -1,13 +1,14 @@
 import { randomUUID } from "node:crypto";
-import { SsrFBlockedError, fetchWithSsrFGuard } from "openclaw/plugin-sdk";
+import { fetchWithSsrFGuard, SsrFBlockedError } from "openclaw/plugin-sdk/infra-runtime";
 import { resolveGroupMeAccount } from "./accounts.js";
 import { getGroupMeRuntime } from "./runtime.js";
 import { resolveGroupMeSecurity } from "./security.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 async function sendGroupMeMessage(params) {
     const fetchFn = params.fetchFn ?? fetch;
+    const apiBaseUrl = params.apiBaseUrl ?? GROUPME_API_BASE;
     const payload = {
         bot_id: params.botId,
         text: params.text,
@@ -15,7 +16,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",
@@ -31,15 +32,15 @@ export async function sendGroupMeMessage(params) {
     };
 }
 function extractPictureUrl(value) {
-    const url = value?.payload
-        ?.picture_url;
+    const url = value?.payload?.picture_url;
     if (typeof url !== "string")
         return null;
     return url.trim() || null;
 }
 export async function uploadGroupMeImage(params) {
     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,
@@ -101,8 +102,7 @@ async function downloadRemoteMedia(params) {
                 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})`);
             }
             const contentType = enforceMimePolicy({
@@ -130,6 +130,9 @@ function wrapFetchWithTimeout(fetchFn, timeoutMs) {
         const timeout = setTimeout(() => {
             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) {
@@ -140,6 +143,7 @@ function wrapFetchWithTimeout(fetchFn, timeoutMs) {
                 upstreamSignal.addEventListener("abort", onAbort, { once: true });
             }
         }
+        /* v8 ignore stop */
         try {
             return await base(input, {
                 ...init,
@@ -148,17 +152,16 @@ function wrapFetchWithTimeout(fetchFn, timeoutMs) {
         }
         finally {
             clearTimeout(timeout);
+            /* v8 ignore start */
             if (upstreamSignal) {
                 upstreamSignal.removeEventListener("abort", onAbort);
             }
+            /* v8 ignore stop */
         }
     };
 }
 function enforceMimePolicy(params) {
-    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()))) {
         throw new Error(`GroupMe media download blocked by MIME policy (${contentType || "missing content-type"})`);
@@ -234,6 +237,7 @@ export async function sendGroupMeText(params) {
         botId: account.botId,
         text: params.text,
         fetchFn: params.fetchFn,
+        apiBaseUrl: params.apiBaseUrl,
     });
 }
 export async function sendGroupMeMedia(params) {
@@ -261,11 +265,13 @@ export async function sendGroupMeMedia(params) {
         imageData: data,
         contentType,
         fetchFn: params.fetchFn,
+        imageBaseUrl: params.imageBaseUrl,
     });
     return sendGroupMeMessage({
         botId: account.botId,
         text: params.text,
         pictureUrl,
         fetchFn: params.fetchFn,
+        apiBaseUrl: params.apiBaseUrl,
     });
 }

package/index.ts

@@ -1,17 +1,22 @@
-import type { ChannelPlugin, OpenClawPluginApi } from "openclaw/plugin-sdk";
-import { emptyPluginConfigSchema } from "openclaw/plugin-sdk";
-import { groupmePlugin } from "./src/channel.js";
-import { setGroupMeRuntime } from "./src/runtime.js";
+import { defineBundledChannelEntry } from "openclaw/plugin-sdk/channel-entry-contract";
 
-const plugin = {
+const plugin = defineBundledChannelEntry({
   id: "groupme",
   name: "GroupMe",
   description: "GroupMe channel plugin",
-  configSchema: emptyPluginConfigSchema(),
-  register(api: OpenClawPluginApi) {
-    setGroupMeRuntime(api.runtime);
-    api.registerChannel({ plugin: groupmePlugin as ChannelPlugin });
+  importMetaUrl: import.meta.url,
+  plugin: {
+    specifier: "./channel-plugin-api.js",
+    exportName: "groupmePlugin",
   },
-};
+  secrets: {
+    specifier: "./secret-contract-api.js",
+    exportName: "channelSecrets",
+  },
+  runtime: {
+    specifier: "./runtime-setter-api.js",
+    exportName: "setGroupMeRuntime",
+  },
+});
 
 export default plugin;

package/openclaw.plugin.json

@@ -2,24 +2,23 @@
   "id": "groupme",
   "name": "GroupMe",
   "description": "GroupMe channel plugin for OpenClaw.",
-  "channels": [
-    "groupme"
-  ],
+  "channels": ["groupme"],
   "activation": {
-    "onStartup": true,
-    "onChannels": [
-      "groupme"
-    ]
+    "onStartup": false,
+    "onChannels": ["groupme"]
+  },
+  "channelConfigs": {
+    "groupme": {
+      "label": "GroupMe",
+      "description": "GroupMe Bot API webhook integration for group chats.",
+      "schema": {
+        "type": "object",
+        "additionalProperties": true
+      }
+    }
   },
   "channelEnvVars": {
-    "groupme": [
-      "GROUPME_BOT_ID",
-      "GROUPME_ACCESS_TOKEN",
-      "GROUPME_BOT_NAME",
-      "GROUPME_GROUP_ID",
-      "GROUPME_PUBLIC_DOMAIN",
-      "GROUPME_CALLBACK_URL"
-    ]
+    "groupme": ["GROUPME_BOT_ID", "GROUPME_ACCESS_TOKEN", "GROUPME_CALLBACK_TOKEN"]
   },
   "configSchema": {
     "type": "object",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-groupme",
-  "version": "0.4.3",
+  "version": "0.5.0",
   "description": "OpenClaw GroupMe channel plugin",
   "license": "MIT",
   "keywords": [
@@ -20,33 +20,59 @@
   },
   "type": "module",
   "engines": {
-    "node": ">=18"
+    "node": ">=22.19.0"
   },
   "files": [
     "openclaw.plugin.json",
     "dist/**/*.js",
     "index.ts",
+    "channel-plugin-api.ts",
+    "runtime-setter-api.ts",
+    "secret-contract-api.ts",
+    "setup-entry.ts",
+    "setup-plugin-api.ts",
     "src/**/*.ts",
     "LICENSE",
     "README.md"
   ],
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
+    "check": "npm run lint && npm run typecheck && npm run test:unit && npm run test:integration && npm run build && npm run knip",
+    "commitlint": "commitlint --edit",
+    "format": "biome format --write .",
+    "format:check": "biome format .",
+    "knip": "knip",
+    "lint": "biome check .",
+    "lint:fix": "biome check --write .",
     "prepack": "npm run build",
-    "test": "vitest run",
+    "prepare": "lefthook install",
+    "test": "npm run test:unit",
+    "test:coverage": "vitest run tests/unit tests/integration --coverage --no-file-parallelism",
+    "test:integration": "vitest run tests/integration --no-file-parallelism",
+    "test:live": "vitest run tests/live",
+    "test:live:api": "vitest run tests/live/groupme-api-live.test.ts",
+    "test:live:plugin-outbound": "vitest run tests/live/groupme-plugin-outbound-live.test.ts",
+    "test:unit": "vitest run tests/unit",
+    "test:watch": "vitest tests/unit tests/integration",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
     "zod": ">=4.3.6 <5"
   },
   "devDependencies": {
-    "@types/node": "20.19.41",
-    "openclaw": "2026.2.26",
+    "@biomejs/biome": "^2.4.16",
+    "@commitlint/cli": "^20.2.0",
+    "@commitlint/config-conventional": "^20.0.0",
+    "@types/node": "^22.19.20",
+    "@vitest/coverage-v8": "^4.1.8",
+    "knip": "^5.71.0",
+    "lefthook": "^2.1.9",
+    "openclaw": "2026.6.1",
     "typescript": "^6.0.3",
     "vitest": "^4.0.18"
   },
   "peerDependencies": {
-    "openclaw": ">=2026.2.26 <2026.6.0"
+    "openclaw": ">=2026.6.1"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -57,17 +83,25 @@
     "extensions": [
       "./dist/index.js"
     ],
+    "setupEntry": "./dist/setup-entry.js",
     "compat": {
-      "pluginApi": ">=2026.2.26 <2026.6.0"
+      "pluginApi": ">=2026.6.1"
     },
     "build": {
-      "openclawVersion": "2026.2.26"
+      "openclawVersion": "2026.6.1"
     },
     "channel": {
       "id": "groupme",
       "label": "GroupMe",
       "selectionLabel": "GroupMe (Bot API)",
-      "blurb": "GroupMe bot webhook integration (group chats only)."
+      "blurb": "GroupMe bot webhook integration (group chats only).",
+      "doctorCapabilities": {
+        "groupModel": "sender",
+        "groupAllowFromFallbackToAllowFrom": false
+      }
+    },
+    "startup": {
+      "deferConfiguredChannelFullLoadUntilAfterListen": true
     },
     "install": {
       "npmSpec": "openclaw-groupme"

package/runtime-setter-api.ts

@@ -0,0 +1 @@
+export { setGroupMeRuntime } from "./src/runtime.js";

package/secret-contract-api.ts

@@ -0,0 +1,5 @@
+export {
+  channelSecrets,
+  collectRuntimeConfigAssignments,
+  secretTargetRegistryEntries,
+} from "./src/secret-contract.js";

package/setup-entry.ts

@@ -0,0 +1,17 @@
+import { defineBundledChannelSetupEntry } from "openclaw/plugin-sdk/channel-entry-contract";
+
+export default defineBundledChannelSetupEntry({
+  importMetaUrl: import.meta.url,
+  plugin: {
+    specifier: "./setup-plugin-api.js",
+    exportName: "groupmeSetupPlugin",
+  },
+  secrets: {
+    specifier: "./secret-contract-api.js",
+    exportName: "channelSecrets",
+  },
+  runtime: {
+    specifier: "./runtime-setter-api.js",
+    exportName: "setGroupMeRuntime",
+  },
+});

package/setup-plugin-api.ts

@@ -0,0 +1,3 @@
+// Keep setup entry imports narrow while reusing the same channel plugin setup
+// adapter until GroupMe grows a separate setup-only surface.
+export { groupmePlugin as groupmeSetupPlugin } from "./src/channel.js";