openclaw-groupme 0.0.3 → 0.3.0

package/src/normalize.test.ts

@@ -1,43 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  looksLikeGroupMeTargetId,
-  normalizeGroupMeAllowEntry,
-  normalizeGroupMeGroupId,
-  normalizeGroupMeTarget,
-  normalizeGroupMeUserId,
-} from "./normalize.js";
-
-describe("groupme normalize", () => {
-  it("normalizes user and group ids", () => {
-    expect(normalizeGroupMeUserId(" 123 ")).toBe("123");
-    expect(normalizeGroupMeGroupId(456)).toBe("456");
-  });
-
-  it("returns undefined for empty IDs", () => {
-    expect(normalizeGroupMeUserId("   ")).toBeUndefined();
-    expect(normalizeGroupMeGroupId("")).toBeUndefined();
-  });
-
-  it("normalizes prefixed targets", () => {
-    expect(normalizeGroupMeTarget("groupme:group:12345")).toBe("12345");
-    expect(normalizeGroupMeTarget("groupme:user:54321")).toBe("54321");
-    expect(normalizeGroupMeTarget("group:abc")).toBe("abc");
-    expect(normalizeGroupMeTarget("12345")).toBe("12345");
-  });
-
-  it("returns undefined for empty target", () => {
-    expect(normalizeGroupMeTarget("  ")).toBeUndefined();
-  });
-
-  it("normalizes allow entries and keeps wildcard", () => {
-    expect(normalizeGroupMeAllowEntry("groupme:user:123")).toBe("123");
-    expect(normalizeGroupMeAllowEntry("*")).toBe("*");
-  });
-
-  it("validates likely target IDs", () => {
-    expect(looksLikeGroupMeTargetId("groupme:group:123")).toBe(true);
-    expect(looksLikeGroupMeTargetId("abc-123")).toBe(true);
-    expect(looksLikeGroupMeTargetId("has spaces")).toBe(false);
-    expect(looksLikeGroupMeTargetId(" ")).toBe(false);
-  });
-});

package/src/parse.test.ts

@@ -1,162 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  detectGroupMeMention,
-  extractImageUrls,
-  parseGroupMeCallback,
-  shouldProcessCallback,
-} from "./parse.js";
-
-const validPayload = {
-  id: "msg-1",
-  text: "hello @oddclaw",
-  name: "Alice",
-  sender_type: "user",
-  sender_id: "123",
-  user_id: "123",
-  group_id: "999",
-  source_guid: "src-1",
-  created_at: 1_700_000_000,
-  system: false,
-  avatar_url: "https://i.groupme.com/a.png",
-  attachments: [{ type: "image", url: "https://i.groupme.com/img" }],
-};
-
-describe("parseGroupMeCallback", () => {
-  it("parses a valid callback payload", () => {
-    const parsed = parseGroupMeCallback(validPayload);
-    expect(parsed).not.toBeNull();
-    expect(parsed?.id).toBe("msg-1");
-    expect(parsed?.senderType).toBe("user");
-    expect(parsed?.attachments).toHaveLength(1);
-  });
-
-  it("returns null for invalid payload", () => {
-    expect(parseGroupMeCallback(null)).toBeNull();
-    expect(parseGroupMeCallback({})).toBeNull();
-    expect(
-      parseGroupMeCallback({
-        ...validPayload,
-        sender_id: null,
-      }),
-    ).toBeNull();
-  });
-
-  it("handles missing text field by normalizing to empty string", () => {
-    const parsed = parseGroupMeCallback({
-      ...validPayload,
-      text: null,
-    });
-    expect(parsed?.text).toBe("");
-  });
-
-  it("extracts image URLs from attachments", () => {
-    const parsed = parseGroupMeCallback({
-      ...validPayload,
-      attachments: [
-        { type: "image", url: "https://i.groupme.com/one" },
-        { type: "emoji", placeholder: "x", charmap: [[1, 2]] },
-        { type: "image", url: "https://i.groupme.com/two" },
-      ],
-    });
-    expect(extractImageUrls(parsed?.attachments ?? [])).toEqual([
-      "https://i.groupme.com/one",
-      "https://i.groupme.com/two",
-    ]);
-  });
-});
-
-describe("shouldProcessCallback", () => {
-  it("accepts user messages", () => {
-    const parsed = parseGroupMeCallback(validPayload);
-    expect(parsed).not.toBeNull();
-    expect(shouldProcessCallback(parsed!)).toBeNull();
-  });
-
-  it("rejects bot messages", () => {
-    const parsed = parseGroupMeCallback({
-      ...validPayload,
-      sender_type: "bot",
-    });
-    expect(parsed).not.toBeNull();
-    expect(shouldProcessCallback(parsed!)).toBe("non-user message");
-  });
-
-  it("rejects system messages", () => {
-    const parsed = parseGroupMeCallback({
-      ...validPayload,
-      system: true,
-    });
-    expect(parsed).not.toBeNull();
-    expect(shouldProcessCallback(parsed!)).toBe("system message");
-  });
-
-  it("rejects empty messages with no attachments", () => {
-    const parsed = parseGroupMeCallback({
-      ...validPayload,
-      text: "  ",
-      attachments: [],
-    });
-    expect(parsed).not.toBeNull();
-    expect(shouldProcessCallback(parsed!)).toBe("empty message");
-  });
-
-  it("accepts image-only messages", () => {
-    const parsed = parseGroupMeCallback({
-      ...validPayload,
-      text: "",
-      attachments: [{ type: "image", url: "https://i.groupme.com/only" }],
-    });
-    expect(parsed).not.toBeNull();
-    expect(shouldProcessCallback(parsed!)).toBeNull();
-  });
-});
-
-describe("detectGroupMeMention", () => {
-  it("detects exact bot name mention", () => {
-    expect(detectGroupMeMention({ text: "oddclaw help", botName: "oddclaw" })).toBe(true);
-  });
-
-  it("detects @botname mention", () => {
-    expect(detectGroupMeMention({ text: "@oddclaw help", botName: "oddclaw" })).toBe(true);
-  });
-
-  it("is case-insensitive", () => {
-    expect(detectGroupMeMention({ text: "ODDCLAW", botName: "oddclaw" })).toBe(true);
-  });
-
-  it("uses mentionPatterns regex", () => {
-    expect(
-      detectGroupMeMention({
-        text: "hey there",
-        channelMentionPatterns: ["hey\\s+there"],
-      }),
-    ).toBe(true);
-  });
-
-  it("uses agent mention regexes", () => {
-    expect(
-      detectGroupMeMention({
-        text: "Need oddclaw now",
-        mentionRegexes: [/\boddclaw\b/i],
-      }),
-    ).toBe(true);
-  });
-
-  it("returns false for unrelated messages", () => {
-    expect(detectGroupMeMention({ text: "random chat", botName: "oddclaw" })).toBe(false);
-  });
-
-  it("handles empty text", () => {
-    expect(detectGroupMeMention({ text: "", botName: "oddclaw" })).toBe(false);
-  });
-
-  it("ignores invalid regex patterns", () => {
-    expect(
-      detectGroupMeMention({
-        text: "oddclaw",
-        botName: "oddclaw",
-        channelMentionPatterns: ["[(invalid"],
-      }),
-    ).toBe(true);
-  });
-});

package/src/policy.test.ts

@@ -1,23 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { resolveSenderAccess } from "./policy.js";
-
-describe("resolveSenderAccess", () => {
-  it("allows all when allowFrom is empty", () => {
-    expect(resolveSenderAccess({ senderId: "123", allowFrom: [] })).toBe(true);
-    expect(resolveSenderAccess({ senderId: "123" })).toBe(true);
-  });
-
-  it("allows wildcard", () => {
-    expect(resolveSenderAccess({ senderId: "123", allowFrom: ["*"] })).toBe(true);
-  });
-
-  it("allows listed sender", () => {
-    expect(resolveSenderAccess({ senderId: "123", allowFrom: ["123"] })).toBe(true);
-    expect(resolveSenderAccess({ senderId: "123", allowFrom: [123] })).toBe(true);
-    expect(resolveSenderAccess({ senderId: "123", allowFrom: ["groupme:user:123"] })).toBe(true);
-  });
-
-  it("blocks unlisted sender", () => {
-    expect(resolveSenderAccess({ senderId: "999", allowFrom: ["123", "456"] })).toBe(false);
-  });
-});

package/src/send.test.ts

@@ -1,153 +0,0 @@
-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");
-  });
-});