openclaw-groupme 0.0.1

package/src/send.test.ts

@@ -0,0 +1,153 @@
+import { describe, expect, it, vi } from "vitest";
+import type { CoreConfig } from "./types.js";
+import {
+  sendGroupMeMedia,
+  sendGroupMeMessage,
+  sendGroupMeText,
+  uploadGroupMeImage,
+} from "./send.js";
+
+describe("sendGroupMeMessage", () => {
+  it("sends text message", async () => {
+    const fetchMock = vi.fn(async () => new Response("", { status: 201, statusText: "Created" }));
+
+    await sendGroupMeMessage({
+      botId: "bot-1",
+      text: "hello",
+      fetchFn: fetchMock as unknown as typeof fetch,
+    });
+
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    const [url, options] = fetchMock.mock.calls[0] as [string, RequestInit];
+    expect(url).toBe("https://api.groupme.com/v3/bots/post");
+    const body = JSON.parse(String(options.body));
+    expect(body).toEqual({ bot_id: "bot-1", text: "hello" });
+  });
+
+  it("sends message with picture_url", async () => {
+    const fetchMock = vi.fn(async () => new Response("", { status: 202, statusText: "Accepted" }));
+
+    await sendGroupMeMessage({
+      botId: "bot-1",
+      text: "image",
+      pictureUrl: "https://i.groupme.com/abc",
+      fetchFn: fetchMock as unknown as typeof fetch,
+    });
+
+    const [, options] = fetchMock.mock.calls[0] as [string, RequestInit];
+    const body = JSON.parse(String(options.body));
+    expect(body.picture_url).toBe("https://i.groupme.com/abc");
+  });
+
+  it("throws on API error", async () => {
+    const fetchMock = vi.fn(
+      async () => new Response("bad", { status: 400, statusText: "Bad Request" }),
+    );
+
+    await expect(
+      sendGroupMeMessage({
+        botId: "bot-1",
+        text: "hello",
+        fetchFn: fetchMock as unknown as typeof fetch,
+      }),
+    ).rejects.toThrow("GroupMe API error");
+  });
+});
+
+describe("uploadGroupMeImage", () => {
+  it("uploads and returns picture_url", async () => {
+    const fetchMock = vi.fn(
+      async () =>
+        new Response(JSON.stringify({ payload: { picture_url: "https://i.groupme.com/pic" } }), {
+          status: 200,
+        }),
+    );
+
+    const result = await uploadGroupMeImage({
+      accessToken: "token",
+      imageData: Buffer.from("abc"),
+      fetchFn: fetchMock as unknown as typeof fetch,
+    });
+
+    expect(result).toBe("https://i.groupme.com/pic");
+  });
+
+  it("throws when picture_url is missing", async () => {
+    const fetchMock = vi.fn(
+      async () =>
+        new Response(JSON.stringify({ payload: {} }), {
+          status: 200,
+        }),
+    );
+
+    await expect(
+      uploadGroupMeImage({
+        accessToken: "token",
+        imageData: Buffer.from("abc"),
+        fetchFn: fetchMock as unknown as typeof fetch,
+      }),
+    ).rejects.toThrow("no picture_url");
+  });
+});
+
+describe("high-level send helpers", () => {
+  it("sends text using resolved account", async () => {
+    const cfg: CoreConfig = {
+      channels: {
+        groupme: {
+          botId: "bot-1",
+        },
+      },
+    };
+
+    const fetchMock = vi.fn(async () => new Response("", { status: 201 }));
+
+    await sendGroupMeText({
+      cfg,
+      to: "any",
+      text: "hello",
+      fetchFn: fetchMock as unknown as typeof fetch,
+    });
+
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("sends media by downloading then uploading", async () => {
+    const cfg: CoreConfig = {
+      channels: {
+        groupme: {
+          botId: "bot-1",
+          accessToken: "token-1",
+        },
+      },
+    };
+
+    const fetchMock = vi
+      .fn()
+      .mockResolvedValueOnce(
+        new Response(Buffer.from("img"), {
+          status: 200,
+          headers: { "content-type": "image/png" },
+        }),
+      )
+      .mockResolvedValueOnce(
+        new Response(JSON.stringify({ payload: { picture_url: "https://i.groupme.com/new" } }), {
+          status: 200,
+        }),
+      )
+      .mockResolvedValueOnce(new Response("", { status: 201 }));
+
+    await sendGroupMeMedia({
+      cfg,
+      to: "any",
+      text: "caption",
+      mediaUrl: "https://example.com/image.png",
+      fetchFn: fetchMock as unknown as typeof fetch,
+    });
+
+    expect(fetchMock).toHaveBeenCalledTimes(3);
+    expect(fetchMock.mock.calls[0]?.[0]).toBe("https://example.com/image.png");
+    expect(fetchMock.mock.calls[1]?.[0]).toBe("https://image.groupme.com/pictures");
+    expect(fetchMock.mock.calls[2]?.[0]).toBe("https://api.groupme.com/v3/bots/post");
+  });
+});

package/src/send.ts

@@ -0,0 +1,194 @@
+import { randomUUID } from "node:crypto";
+import type { CoreConfig } from "./types.js";
+import { resolveGroupMeAccount } from "./accounts.js";
+
+export const GROUPME_API_BASE = "https://api.groupme.com/v3";
+export const GROUPME_IMAGE_SERVICE = "https://image.groupme.com";
+export const GROUPME_MAX_TEXT_LENGTH = 1000;
+
+export type SendGroupMeResult = {
+  messageId: string;
+  timestamp: number;
+};
+
+type FetchLike = typeof fetch;
+
+type GroupMeBotPostPayload = {
+  bot_id: string;
+  text: string;
+  picture_url?: string;
+};
+
+function buildGroupMeBotPostPayload(params: {
+  botId: string;
+  text: string;
+  pictureUrl?: string;
+}): GroupMeBotPostPayload {
+  const payload: GroupMeBotPostPayload = {
+    bot_id: params.botId,
+    text: params.text,
+  };
+  if (params.pictureUrl) {
+    payload.picture_url = params.pictureUrl;
+  }
+  return payload;
+}
+
+export async function sendGroupMeMessage(params: {
+  botId: string;
+  text: string;
+  pictureUrl?: string;
+  fetchFn?: FetchLike;
+}): Promise<SendGroupMeResult> {
+  const fetchFn = params.fetchFn ?? fetch;
+  const response = await fetchFn(`${GROUPME_API_BASE}/bots/post`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(
+      buildGroupMeBotPostPayload({
+        botId: params.botId,
+        text: params.text,
+        pictureUrl: params.pictureUrl,
+      }),
+    ),
+  });
+
+  if (!response.ok) {
+    throw new Error(`GroupMe API error: ${response.status} ${response.statusText}`);
+  }
+
+  return {
+    messageId: randomUUID(),
+    timestamp: Date.now(),
+  };
+}
+
+function extractPictureUrl(value: unknown): string | null {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+
+  const payload = (value as { payload?: unknown }).payload;
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    return null;
+  }
+
+  const pictureUrl = (payload as { picture_url?: unknown }).picture_url;
+  if (typeof pictureUrl !== "string") {
+    return null;
+  }
+
+  const trimmed = pictureUrl.trim();
+  return trimmed || null;
+}
+
+export async function uploadGroupMeImage(params: {
+  accessToken: string;
+  imageData: Buffer;
+  contentType?: string;
+  fetchFn?: FetchLike;
+}): Promise<string> {
+  const fetchFn = params.fetchFn ?? fetch;
+  const response = await fetchFn(`${GROUPME_IMAGE_SERVICE}/pictures`, {
+    method: "POST",
+    headers: {
+      "X-Access-Token": params.accessToken,
+      "Content-Type": params.contentType ?? "image/jpeg",
+    },
+    body: new Uint8Array(params.imageData),
+  });
+
+  if (!response.ok) {
+    throw new Error(`GroupMe image upload failed: ${response.status}`);
+  }
+
+  const json = (await response.json()) as unknown;
+  const pictureUrl = extractPictureUrl(json);
+  if (!pictureUrl) {
+    throw new Error("GroupMe image upload: no picture_url in response");
+  }
+
+  return pictureUrl;
+}
+
+async function downloadRemoteMedia(params: {
+  mediaUrl: string;
+  fetchFn?: FetchLike;
+}): Promise<{ data: Buffer; contentType: string }> {
+  const fetchFn = params.fetchFn ?? fetch;
+  const response = await fetchFn(params.mediaUrl);
+  if (!response.ok) {
+    throw new Error(`GroupMe media download failed: ${response.status} ${response.statusText}`);
+  }
+
+  const contentType = response.headers.get("content-type") || "image/jpeg";
+  const data = Buffer.from(await response.arrayBuffer());
+
+  return { data, contentType };
+}
+
+export async function sendGroupMeText(params: {
+  cfg: CoreConfig;
+  to: string;
+  text: string;
+  accountId?: string | null;
+  fetchFn?: FetchLike;
+}): Promise<SendGroupMeResult> {
+  const account = resolveGroupMeAccount({
+    cfg: params.cfg,
+    accountId: params.accountId,
+  });
+  if (!account.botId) {
+    throw new Error(`GroupMe account "${account.accountId}" is missing botId`);
+  }
+
+  return sendGroupMeMessage({
+    botId: account.botId,
+    text: params.text,
+    fetchFn: params.fetchFn,
+  });
+}
+
+export async function sendGroupMeMedia(params: {
+  cfg: CoreConfig;
+  to: string;
+  text: string;
+  mediaUrl: string;
+  accountId?: string | null;
+  fetchFn?: FetchLike;
+}): Promise<SendGroupMeResult> {
+  const account = resolveGroupMeAccount({
+    cfg: params.cfg,
+    accountId: params.accountId,
+  });
+
+  if (!account.botId) {
+    throw new Error(`GroupMe account "${account.accountId}" is missing botId`);
+  }
+  if (!account.accessToken) {
+    throw new Error(
+      `GroupMe account "${account.accountId}" is missing accessToken required for image uploads`,
+    );
+  }
+
+  const { data, contentType } = await downloadRemoteMedia({
+    mediaUrl: params.mediaUrl,
+    fetchFn: params.fetchFn,
+  });
+
+  const pictureUrl = await uploadGroupMeImage({
+    accessToken: account.accessToken,
+    imageData: data,
+    contentType,
+    fetchFn: params.fetchFn,
+  });
+
+  return sendGroupMeMessage({
+    botId: account.botId,
+    text: params.text,
+    pictureUrl,
+    fetchFn: params.fetchFn,
+  });
+}

package/src/types.ts

@@ -0,0 +1,103 @@
+import type {
+  BlockStreamingCoalesceConfig,
+  MarkdownConfig,
+  OpenClawConfig,
+} from "openclaw/plugin-sdk";
+
+export type GroupMeAllowFromEntry = string | number;
+
+export type GroupMeAccountConfig = {
+  name?: string;
+  enabled?: boolean;
+  botId?: string;
+  accessToken?: string;
+  botName?: string;
+  callbackPath?: string;
+  mentionPatterns?: string[];
+  requireMention?: boolean;
+  allowFrom?: GroupMeAllowFromEntry[];
+  markdown?: MarkdownConfig;
+  textChunkLimit?: number;
+  blockStreaming?: boolean;
+  blockStreamingCoalesce?: BlockStreamingCoalesceConfig;
+  responsePrefix?: string;
+  mediaMaxMb?: number;
+};
+
+export type GroupMeConfig = GroupMeAccountConfig & {
+  accounts?: Record<string, GroupMeAccountConfig | undefined>;
+  defaultAccount?: string;
+};
+
+export type CoreConfig = OpenClawConfig & {
+  channels?: OpenClawConfig["channels"] & {
+    groupme?: GroupMeConfig;
+  };
+};
+
+export type ResolvedGroupMeAccount = {
+  accountId: string;
+  name?: string;
+  enabled: boolean;
+  configured: boolean;
+  botId: string;
+  accessToken: string;
+  config: GroupMeAccountConfig;
+};
+
+export type GroupMeImageAttachment = {
+  type: "image";
+  url: string;
+};
+
+export type GroupMeLocationAttachment = {
+  type: "location";
+  lat: string;
+  lng: string;
+  name: string;
+};
+
+export type GroupMeMentionsAttachment = {
+  type: "mentions";
+  user_ids: string[];
+  loci: number[][];
+};
+
+export type GroupMeEmojiAttachment = {
+  type: "emoji";
+  placeholder: string;
+  charmap: number[][];
+};
+
+export type GroupMeUnknownAttachment = {
+  type: string;
+  [key: string]: unknown;
+};
+
+export type GroupMeAttachment =
+  | GroupMeImageAttachment
+  | GroupMeLocationAttachment
+  | GroupMeMentionsAttachment
+  | GroupMeEmojiAttachment
+  | GroupMeUnknownAttachment;
+
+export type GroupMeCallbackData = {
+  id: string;
+  text: string;
+  name: string;
+  senderType: string;
+  senderId: string;
+  userId: string;
+  groupId: string;
+  sourceGuid: string;
+  createdAt: number;
+  system: boolean;
+  avatarUrl: string | null;
+  attachments: GroupMeAttachment[];
+};
+
+export type GroupMeProbe = {
+  ok: boolean;
+  botId?: string;
+  error?: string;
+};