openclaw-groupme 0.4.2 → 0.4.3

package/dist/src/onboarding.js

@@ -0,0 +1,422 @@
+import { randomBytes } from "node:crypto";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk";
+import { resolveGroupMeAccount } from "./accounts.js";
+import { createBot, fetchGroups } from "./groupme-api.js";
+function applyGroupMeConfig(params) {
+    const { cfg, accountId, updates } = params;
+    const section = (cfg.channels?.groupme ?? {});
+    if (accountId === DEFAULT_ACCOUNT_ID) {
+        return {
+            ...cfg,
+            channels: {
+                ...cfg.channels,
+                groupme: {
+                    ...section,
+                    ...updates,
+                    enabled: true,
+                },
+            },
+        };
+    }
+    return {
+        ...cfg,
+        channels: {
+            ...cfg.channels,
+            groupme: {
+                ...section,
+                enabled: true,
+                accounts: {
+                    ...(section.accounts ?? {}),
+                    [accountId]: {
+                        ...(section.accounts?.[accountId] ?? {}),
+                        ...updates,
+                        enabled: true,
+                    },
+                },
+            },
+        },
+    };
+}
+function parsePublicDomain(raw) {
+    const trimmed = raw.trim();
+    try {
+        if (/^https?:\/\//i.test(trimmed)) {
+            const url = new URL(trimmed);
+            return url.port ? `${url.hostname}:${url.port}` : url.hostname;
+        }
+        const withoutLeadingSlashes = trimmed.replace(/^\/+/, "");
+        return withoutLeadingSlashes.split(/[\/?#]/, 1)[0];
+    }
+    catch {
+        const noScheme = trimmed.replace(/^https?:\/\//i, "");
+        return noScheme.split(/[\/?#]/, 1)[0];
+    }
+}
+function generateCallbackUrl() {
+    const pathSegment = randomBytes(8).toString("hex");
+    const callbackToken = randomBytes(32).toString("hex");
+    return `/groupme/${pathSegment}?k=${callbackToken}`;
+}
+function redactMiddle(value) {
+    if (value.length <= 10) {
+        return value;
+    }
+    return `${value.slice(0, 6)}...${value.slice(-3)}`;
+}
+export const groupmeOnboardingAdapter = {
+    channel: "groupme",
+    getStatus: async ({ cfg, accountOverrides }) => {
+        const accountId = accountOverrides.groupme ?? DEFAULT_ACCOUNT_ID;
+        const account = resolveGroupMeAccount({
+            cfg: cfg,
+            accountId,
+        });
+        const configured = account.configured;
+        const callbackUrlConfigured = Boolean(account.config.callbackUrl?.trim());
+        const groupIdConfigured = Boolean(account.config.groupId?.trim());
+        const publicDomainConfigured = Boolean(account.config.publicDomain?.trim());
+        return {
+            channel: "groupme",
+            configured,
+            statusLines: [
+                `GroupMe (${accountId}): ${configured ? "configured" : "needs access token"}`,
+                account.config.accessToken?.trim()
+                    ? "Access token configured"
+                    : "Access token missing",
+                callbackUrlConfigured
+                    ? "Webhook callback URL configured"
+                    : "Webhook callback URL missing",
+                publicDomainConfigured
+                    ? "Public domain configured"
+                    : "Public domain missing",
+                groupIdConfigured ? "Group ID configured" : "Group ID missing",
+            ],
+            selectionHint: configured ? "configured" : "needs access token",
+            quickstartScore: configured ? 1 : 0,
+        };
+    },
+    configure: async ({ cfg, prompter, accountOverrides }) => {
+        const accountId = accountOverrides.groupme ?? DEFAULT_ACCOUNT_ID;
+        const botNameInput = (await prompter.text({
+            message: "Bot name",
+            initialValue: "openclaw",
+        })).trim();
+        const botName = botNameInput || "openclaw";
+        const accessToken = (await prompter.text({
+            message: "GroupMe access token",
+            validate: (value) => value.trim() ? undefined : "Access token is required",
+        })).trim();
+        const groupsSpin = prompter.progress("Fetching your GroupMe groups...");
+        let groups;
+        try {
+            groups = await fetchGroups(accessToken);
+        }
+        catch {
+            groupsSpin.stop("Failed");
+            await prompter.note("Could not fetch groups. Check your access token and try again.", "GroupMe setup failed");
+            throw new Error("Could not fetch groups");
+        }
+        if (groups.length === 0) {
+            groupsSpin.stop("No groups found");
+            await prompter.note("No groups found. Create or join a GroupMe group first.", "GroupMe setup failed");
+            throw new Error("No GroupMe groups found");
+        }
+        groupsSpin.stop(`Found ${groups.length} groups`);
+        const groupId = await prompter.select({
+            message: "Select a GroupMe group",
+            options: groups.map((group) => ({
+                value: group.id,
+                label: group.name || group.id,
+                hint: group.id,
+            })),
+        });
+        const selectedGroup = groups.find((group) => group.id === groupId);
+        const requireMention = await prompter.confirm({
+            message: "Require mention to respond?",
+            initialValue: true,
+        });
+        const publicDomainRaw = (await prompter.text({
+            message: "Public domain (must be reachable — GroupMe will ping it)",
+            validate: (value) => {
+                const trimmed = value.trim();
+                if (!trimmed) {
+                    return "Public domain is required";
+                }
+                const normalized = trimmed
+                    .replace(/^https?:\/\//, "")
+                    .replace(/\/+$/, "");
+                if (!normalized) {
+                    return "Public domain is required";
+                }
+                const parsed = parsePublicDomain(trimmed);
+                if (!parsed) {
+                    return "Public domain is required";
+                }
+                return undefined;
+            },
+        })).trim();
+        const publicDomain = parsePublicDomain(publicDomainRaw);
+        const callbackUrl = generateCallbackUrl();
+        const pathSegment = callbackUrl.split("?")[0].split("/").pop();
+        await prompter.note(`Generated webhook callback URL: /groupme/${pathSegment}?k=***`, "Generated callback URL");
+        const botSpin = prompter.progress("Registering bot with GroupMe...");
+        let botId = "";
+        try {
+            const bot = await createBot({
+                accessToken,
+                name: botName,
+                groupId,
+                callbackUrl: `https://${publicDomain}${callbackUrl}`,
+            });
+            botId = bot.bot_id;
+            botSpin.stop("Bot registered");
+        }
+        catch (error) {
+            botSpin.stop("Failed");
+            const detail = error instanceof Error ? `\n\nDetails: ${error.message}` : "";
+            await prompter.note(`Failed to register bot with GroupMe. Check your access token and try again.${detail}`, "GroupMe setup failed");
+            throw new Error("Failed to register GroupMe bot", {
+                cause: error instanceof Error ? error : undefined,
+            });
+        }
+        await prompter.note(`Bot "${botName}" registered in group "${selectedGroup?.name ?? groupId}" (bot ID: ${redactMiddle(botId)})`, "GroupMe bot registered");
+        const next = applyGroupMeConfig({
+            cfg,
+            accountId,
+            updates: {
+                botName,
+                accessToken,
+                botId,
+                groupId,
+                publicDomain,
+                callbackUrl,
+                requireMention,
+            },
+        });
+        await prompter.note([
+            "Next steps:",
+            "1. Restart the gateway: openclaw gateway restart",
+            "2. Send a message in the group to test",
+        ].join("\n"), "GroupMe next steps");
+        return {
+            cfg: next,
+            accountId,
+        };
+    },
+    configureWhenConfigured: async ({ cfg, prompter, runtime, accountOverrides, }) => {
+        const accountId = accountOverrides.groupme ?? DEFAULT_ACCOUNT_ID;
+        const account = resolveGroupMeAccount({
+            cfg: cfg,
+            accountId,
+        });
+        const action = await prompter.select({
+            message: "GroupMe is already configured. What would you like to do?",
+            options: [
+                { value: "skip", label: "Skip", hint: "no changes" },
+                { value: "rotate_token", label: "Rotate access token" },
+                { value: "change_group", label: "Change group" },
+                { value: "regen_callback", label: "Regenerate callback URL" },
+                { value: "toggle_mention", label: "Toggle requireMention" },
+                { value: "update_domain", label: "Update public domain" },
+                { value: "full_setup", label: "Full re-setup", hint: "start from scratch" },
+            ],
+        });
+        if (action === "skip") {
+            return "skip";
+        }
+        if (action === "full_setup") {
+            return groupmeOnboardingAdapter.configure({
+                cfg,
+                prompter,
+                runtime,
+                accountOverrides,
+                options: {},
+                shouldPromptAccountIds: false,
+                forceAllowFrom: false,
+            });
+        }
+        if (action === "rotate_token") {
+            const newToken = (await prompter.text({
+                message: "New GroupMe access token",
+                validate: (value) => value.trim() ? undefined : "Access token is required",
+            })).trim();
+            const spin = prompter.progress("Validating access token...");
+            try {
+                await fetchGroups(newToken);
+                spin.stop("Token validated");
+            }
+            catch {
+                spin.stop("Failed");
+                await prompter.note("Could not validate token. Check your access token and try again.", "Validation failed");
+                throw new Error("Could not validate access token");
+            }
+            const next = applyGroupMeConfig({
+                cfg,
+                accountId,
+                updates: { accessToken: newToken },
+            });
+            await prompter.note("Access token updated.", "Token rotated");
+            return { cfg: next, accountId };
+        }
+        if (action === "change_group") {
+            const existingToken = account.accessToken;
+            if (!existingToken) {
+                await prompter.note("No access token configured. Use \"Rotate access token\" first.", "Missing token");
+                return "skip";
+            }
+            const spin = prompter.progress("Fetching your GroupMe groups...");
+            let groups;
+            try {
+                groups = await fetchGroups(existingToken);
+            }
+            catch {
+                spin.stop("Failed");
+                await prompter.note("Could not fetch groups. Check your access token and try again.", "GroupMe error");
+                throw new Error("Could not fetch groups");
+            }
+            if (groups.length === 0) {
+                spin.stop("No groups found");
+                await prompter.note("No groups found. Create or join a GroupMe group first.", "No groups");
+                return "skip";
+            }
+            spin.stop(`Found ${groups.length} groups`);
+            const newGroupId = await prompter.select({
+                message: "Select a GroupMe group",
+                options: groups.map((group) => ({
+                    value: group.id,
+                    label: group.name || group.id,
+                    hint: group.id === account.config.groupId ? "current" : group.id,
+                })),
+            });
+            const selectedGroup = groups.find((g) => g.id === newGroupId);
+            const updates = { groupId: newGroupId };
+            const registerNew = await prompter.confirm({
+                message: "Register a new bot in this group?",
+                initialValue: true,
+            });
+            if (!registerNew) {
+                const newBotId = (await prompter.text({
+                    message: "Bot ID for the new group (existing bot won't work in a different group)",
+                    validate: (value) => value.trim() ? undefined : "Bot ID is required",
+                })).trim();
+                updates.botId = newBotId;
+            }
+            if (registerNew) {
+                const botName = account.config.botName || "openclaw";
+                let publicDomain = account.config.publicDomain;
+                if (!publicDomain) {
+                    const domainRaw = (await prompter.text({
+                        message: "Public domain (required for bot registration)",
+                        validate: (value) => {
+                            const trimmed = value.trim();
+                            if (!trimmed)
+                                return "Public domain is required";
+                            const normalized = trimmed
+                                .replace(/^https?:\/\//, "")
+                                .replace(/\/+$/, "");
+                            if (!normalized)
+                                return "Public domain is required";
+                            const parsed = parsePublicDomain(trimmed);
+                            if (!parsed)
+                                return "Public domain is required";
+                            return undefined;
+                        },
+                    })).trim();
+                    publicDomain = parsePublicDomain(domainRaw);
+                    updates.publicDomain = publicDomain;
+                }
+                let rawCallbackUrl = account.config.callbackUrl;
+                if (!rawCallbackUrl) {
+                    rawCallbackUrl = generateCallbackUrl();
+                    updates.callbackUrl = rawCallbackUrl;
+                }
+                const parsedCallback = new URL(rawCallbackUrl, "http://localhost");
+                const callbackPath = `${parsedCallback.pathname}${parsedCallback.search}`;
+                const botSpin = prompter.progress("Registering bot with GroupMe...");
+                try {
+                    const bot = await createBot({
+                        accessToken: existingToken,
+                        name: botName,
+                        groupId: newGroupId,
+                        callbackUrl: `https://${publicDomain}${callbackPath}`,
+                    });
+                    updates.botId = bot.bot_id;
+                    botSpin.stop("Bot registered");
+                }
+                catch (error) {
+                    botSpin.stop("Failed");
+                    const detail = error instanceof Error ? `\n\nDetails: ${error.message}` : "";
+                    await prompter.note(`Failed to register bot.${detail}`, "Bot registration failed");
+                    throw new Error("Failed to register GroupMe bot", {
+                        cause: error instanceof Error ? error : undefined,
+                    });
+                }
+            }
+            const next = applyGroupMeConfig({ cfg, accountId, updates });
+            await prompter.note(`Group changed to "${selectedGroup?.name ?? newGroupId}".`, "Group updated");
+            return { cfg: next, accountId };
+        }
+        if (action === "regen_callback") {
+            const callbackUrl = generateCallbackUrl();
+            const next = applyGroupMeConfig({
+                cfg,
+                accountId,
+                updates: { callbackUrl },
+            });
+            await prompter.note([
+                "Callback URL regenerated.",
+                "Remember to update your GroupMe bot settings or re-register the bot.",
+            ].join("\n"), "Callback URL updated");
+            return { cfg: next, accountId };
+        }
+        if (action === "toggle_mention") {
+            const current = account.config.requireMention ?? true;
+            const next = applyGroupMeConfig({
+                cfg,
+                accountId,
+                updates: { requireMention: !current },
+            });
+            await prompter.note(`requireMention changed from ${current} to ${!current}.`, "Mention setting updated");
+            return { cfg: next, accountId };
+        }
+        if (action === "update_domain") {
+            const newDomainRaw = (await prompter.text({
+                message: "New public domain",
+                initialValue: account.config.publicDomain ?? "",
+                validate: (value) => {
+                    const trimmed = value.trim();
+                    if (!trimmed)
+                        return "Public domain is required";
+                    const normalized = trimmed
+                        .replace(/^https?:\/\//, "")
+                        .replace(/\/+$/, "");
+                    if (!normalized)
+                        return "Public domain is required";
+                    const parsed = parsePublicDomain(trimmed);
+                    if (!parsed)
+                        return "Public domain is required";
+                    return undefined;
+                },
+            })).trim();
+            const publicDomain = parsePublicDomain(newDomainRaw);
+            const next = applyGroupMeConfig({
+                cfg,
+                accountId,
+                updates: { publicDomain },
+            });
+            await prompter.note(`Public domain updated to "${publicDomain}".`, "Domain updated");
+            return { cfg: next, accountId };
+        }
+        return "skip";
+    },
+    disable: (cfg) => ({
+        ...cfg,
+        channels: {
+            ...cfg.channels,
+            groupme: {
+                ...(cfg.channels?.groupme ?? {}),
+                enabled: false,
+            },
+        },
+    }),
+};

package/dist/src/parse.js

@@ -0,0 +1,217 @@
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readString(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed || undefined;
+}
+function readBoolean(value) {
+    return typeof value === "boolean" ? value : undefined;
+}
+function readNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === "string") {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return undefined;
+}
+function parseNumberMatrix(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const rows = [];
+    for (const row of value) {
+        if (!Array.isArray(row)) {
+            continue;
+        }
+        const parsedRow = [];
+        for (const cell of row) {
+            const num = readNumber(cell);
+            if (num === undefined) {
+                continue;
+            }
+            parsedRow.push(num);
+        }
+        if (parsedRow.length > 0) {
+            rows.push(parsedRow);
+        }
+    }
+    return rows;
+}
+function parseStringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .map((entry) => readString(entry))
+        .filter((entry) => Boolean(entry));
+}
+function parseAttachment(entry) {
+    if (!isRecord(entry)) {
+        return null;
+    }
+    const type = readString(entry.type);
+    if (!type) {
+        return null;
+    }
+    if (type === "image") {
+        const url = readString(entry.url);
+        if (!url) {
+            return null;
+        }
+        return { type, url };
+    }
+    if (type === "location") {
+        const lat = readString(entry.lat);
+        const lng = readString(entry.lng);
+        const name = readString(entry.name);
+        if (!lat || !lng || !name) {
+            return null;
+        }
+        return { type, lat, lng, name };
+    }
+    if (type === "mentions") {
+        return {
+            type,
+            user_ids: parseStringArray(entry.user_ids),
+            loci: parseNumberMatrix(entry.loci),
+        };
+    }
+    if (type === "emoji") {
+        const placeholder = readString(entry.placeholder);
+        if (!placeholder) {
+            return null;
+        }
+        return {
+            type,
+            placeholder,
+            charmap: parseNumberMatrix(entry.charmap),
+        };
+    }
+    return {
+        ...entry,
+        type,
+    };
+}
+function parseAttachments(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .map((entry) => parseAttachment(entry))
+        .filter((parsed) => parsed !== null);
+}
+export function parseGroupMeCallback(data) {
+    if (!isRecord(data)) {
+        return null;
+    }
+    const id = readString(data.id);
+    const name = readString(data.name);
+    const senderType = readString(data.sender_type);
+    const senderId = readString(data.sender_id);
+    const userId = readString(data.user_id);
+    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) {
+        return null;
+    }
+    if (typeof createdAt !== "number") {
+        return null;
+    }
+    const avatarUrl = readString(data.avatar_url) ?? null;
+    const text = typeof data.text === "string" ? data.text : "";
+    return {
+        id,
+        text,
+        name,
+        senderType,
+        senderId,
+        userId,
+        groupId,
+        sourceGuid,
+        createdAt,
+        system: readBoolean(data.system) ?? false,
+        avatarUrl,
+        attachments: parseAttachments(data.attachments),
+    };
+}
+export function hasImageAttachment(attachments) {
+    return attachments.some((attachment) => attachment.type === "image");
+}
+export function shouldProcessCallback(msg) {
+    if (msg.senderType !== "user") {
+        return "non-user message";
+    }
+    if (msg.system) {
+        return "system message";
+    }
+    if (!msg.text.trim() && !hasImageAttachment(msg.attachments)) {
+        return "empty message";
+    }
+    return null;
+}
+export function extractImageUrls(attachments) {
+    return attachments
+        .filter((attachment) => attachment.type === "image")
+        .map((attachment) => attachment.url);
+}
+function normalizeMentionText(text) {
+    return text
+        .replace(/[\u200b-\u200f\u202a-\u202e\u2060-\u206f]/g, "")
+        .toLowerCase();
+}
+function buildRegexes(patterns) {
+    if (!patterns || patterns.length === 0) {
+        return [];
+    }
+    return patterns
+        .map((pattern) => {
+        try {
+            return new RegExp(pattern, "i");
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((entry) => Boolean(entry));
+}
+function escapeRegexLiteral(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+export function detectGroupMeMention(params) {
+    const text = params.text?.trim() ?? "";
+    if (!text) {
+        return false;
+    }
+    const normalizedText = normalizeMentionText(text);
+    const channelRegexes = buildRegexes(params.channelMentionPatterns);
+    if (channelRegexes.some((regex) => regex.test(text))) {
+        return true;
+    }
+    const mentionRegexes = params.mentionRegexes ?? [];
+    if (mentionRegexes.some((regex) => regex.test(normalizedText))) {
+        return true;
+    }
+    const botName = params.botName?.trim();
+    if (!botName) {
+        return false;
+    }
+    const escaped = escapeRegexLiteral(botName);
+    const botRegex = new RegExp(`\\b@?${escaped}\\b`, "i");
+    return botRegex.test(text);
+}

package/dist/src/policy.js

@@ -0,0 +1,18 @@
+import { normalizeGroupMeAllowEntry, normalizeStringId, } from "./normalize.js";
+export function resolveSenderAccess(params) {
+    const senderId = normalizeStringId(params.senderId);
+    if (!senderId) {
+        return false;
+    }
+    const allowFrom = params.allowFrom ?? [];
+    if (allowFrom.length === 0) {
+        return true;
+    }
+    const normalizedAllow = allowFrom
+        .map((entry) => normalizeGroupMeAllowEntry(String(entry)))
+        .filter((entry) => Boolean(entry));
+    if (normalizedAllow.includes("*")) {
+        return true;
+    }
+    return normalizedAllow.includes(senderId);
+}