@openclaw/googlechat 2026.5.2-beta.2 → 2026.5.3-beta.1

package/src/actions.test.ts

@@ -1,265 +0,0 @@
-import path from "node:path";
-import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-
-const listEnabledGoogleChatAccounts = vi.hoisted(() => vi.fn());
-const resolveGoogleChatAccount = vi.hoisted(() => vi.fn());
-const createGoogleChatReaction = vi.hoisted(() => vi.fn());
-const deleteGoogleChatReaction = vi.hoisted(() => vi.fn());
-const listGoogleChatReactions = vi.hoisted(() => vi.fn());
-const sendGoogleChatMessage = vi.hoisted(() => vi.fn());
-const uploadGoogleChatAttachment = vi.hoisted(() => vi.fn());
-const resolveGoogleChatOutboundSpace = vi.hoisted(() => vi.fn());
-const getGoogleChatRuntime = vi.hoisted(() => vi.fn());
-
-vi.mock("./accounts.js", () => ({
-  listEnabledGoogleChatAccounts,
-  resolveGoogleChatAccount,
-}));
-
-vi.mock("./api.js", () => ({
-  createGoogleChatReaction,
-  deleteGoogleChatReaction,
-  listGoogleChatReactions,
-  sendGoogleChatMessage,
-  uploadGoogleChatAttachment,
-}));
-
-vi.mock("./runtime.js", () => ({
-  getGoogleChatRuntime,
-}));
-
-vi.mock("./targets.js", () => ({
-  resolveGoogleChatOutboundSpace,
-}));
-
-let googlechatMessageActions: typeof import("./actions.js").googlechatMessageActions;
-
-describe("googlechat message actions", () => {
-  beforeAll(async () => {
-    ({ googlechatMessageActions } = await import("./actions.js"));
-  });
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("describes send and reaction actions only when enabled accounts exist", async () => {
-    listEnabledGoogleChatAccounts.mockReturnValueOnce([]);
-    expect(googlechatMessageActions.describeMessageTool?.({ cfg: {} as never })).toBeNull();
-
-    listEnabledGoogleChatAccounts.mockReturnValueOnce([
-      {
-        enabled: true,
-        credentialSource: "service-account",
-        config: { actions: { reactions: true } },
-      },
-    ]);
-
-    expect(googlechatMessageActions.describeMessageTool?.({ cfg: {} as never })).toEqual({
-      actions: ["send", "upload-file", "react", "reactions"],
-    });
-  });
-
-  it("honors account-scoped reaction gates during discovery", () => {
-    resolveGoogleChatAccount.mockImplementation(({ accountId }: { accountId?: string | null }) => ({
-      enabled: true,
-      credentialSource: "service-account",
-      config: {
-        actions: { reactions: accountId === "work" },
-      },
-    }));
-
-    expect(
-      googlechatMessageActions.describeMessageTool?.({ cfg: {} as never, accountId: "default" }),
-    ).toEqual({
-      actions: ["send", "upload-file"],
-    });
-    expect(
-      googlechatMessageActions.describeMessageTool?.({ cfg: {} as never, accountId: "work" }),
-    ).toEqual({
-      actions: ["send", "upload-file", "react", "reactions"],
-    });
-  });
-
-  it("sends messages with uploaded media through the resolved space", async () => {
-    resolveGoogleChatAccount.mockReturnValue({
-      credentialSource: "service-account",
-      config: { mediaMaxMb: 5 },
-    });
-    resolveGoogleChatOutboundSpace.mockResolvedValue("spaces/AAA");
-    getGoogleChatRuntime.mockReturnValue({
-      channel: {
-        media: {
-          fetchRemoteMedia: vi.fn(async () => ({
-            buffer: Buffer.from("remote-bytes"),
-            fileName: "remote.png",
-            contentType: "image/png",
-          })),
-        },
-      },
-    });
-    uploadGoogleChatAttachment.mockResolvedValue({
-      attachmentUploadToken: "token-1",
-    });
-    sendGoogleChatMessage.mockResolvedValue({
-      messageName: "spaces/AAA/messages/msg-1",
-    });
-
-    if (!googlechatMessageActions.handleAction) {
-      throw new Error("Expected googlechatMessageActions.handleAction to be defined");
-    }
-    const result = await googlechatMessageActions.handleAction({
-      action: "send",
-      params: {
-        to: "spaces/AAA",
-        message: "caption",
-        media: "https://example.com/file.png",
-        threadId: "thread-1",
-      },
-      cfg: {},
-      accountId: "default",
-    } as never);
-
-    expect(resolveGoogleChatOutboundSpace).toHaveBeenCalledWith(
-      expect.objectContaining({
-        target: "spaces/AAA",
-      }),
-    );
-    expect(uploadGoogleChatAttachment).toHaveBeenCalledWith(
-      expect.objectContaining({
-        space: "spaces/AAA",
-        filename: "remote.png",
-      }),
-    );
-    expect(sendGoogleChatMessage).toHaveBeenCalledWith(
-      expect.objectContaining({
-        space: "spaces/AAA",
-        text: "caption",
-        thread: "thread-1",
-      }),
-    );
-    expect(result).toMatchObject({
-      details: {
-        ok: true,
-        to: "spaces/AAA",
-      },
-    });
-  });
-
-  it("routes upload-file through the same attachment upload path with filename override", async () => {
-    resolveGoogleChatAccount.mockReturnValue({
-      credentialSource: "service-account",
-      config: { mediaMaxMb: 5 },
-    });
-    resolveGoogleChatOutboundSpace.mockResolvedValue("spaces/BBB");
-    const localRoot = "/tmp/googlechat-action-test";
-    const localPath = path.join(localRoot, "local.md");
-    const readFile = vi.fn(async () => Buffer.from("local-bytes"));
-    getGoogleChatRuntime.mockReturnValue({
-      channel: {
-        media: {
-          fetchRemoteMedia: vi.fn(),
-        },
-      },
-    });
-    uploadGoogleChatAttachment.mockResolvedValue({
-      attachmentUploadToken: "token-2",
-    });
-    sendGoogleChatMessage.mockResolvedValue({
-      messageName: "spaces/BBB/messages/msg-2",
-    });
-
-    if (!googlechatMessageActions.handleAction) {
-      throw new Error("Expected googlechatMessageActions.handleAction to be defined");
-    }
-    const result = await googlechatMessageActions.handleAction({
-      action: "upload-file",
-      params: {
-        to: "spaces/BBB",
-        path: localPath,
-        message: "notes",
-        filename: "renamed.txt",
-      },
-      cfg: {},
-      accountId: "default",
-      mediaLocalRoots: [localRoot],
-      mediaReadFile: readFile,
-    } as never);
-
-    expect(readFile).toHaveBeenCalledWith(localPath);
-    expect(uploadGoogleChatAttachment).toHaveBeenCalledWith(
-      expect.objectContaining({
-        space: "spaces/BBB",
-        filename: "renamed.txt",
-        buffer: Buffer.from("local-bytes"),
-      }),
-    );
-    expect(sendGoogleChatMessage).toHaveBeenCalledWith(
-      expect.objectContaining({
-        space: "spaces/BBB",
-        text: "notes",
-        attachments: [{ attachmentUploadToken: "token-2", contentName: "renamed.txt" }],
-      }),
-    );
-    expect(result).toMatchObject({
-      details: {
-        ok: true,
-        to: "spaces/BBB",
-      },
-    });
-  });
-
-  it("removes only matching app reactions on react remove", async () => {
-    resolveGoogleChatAccount.mockReturnValue({
-      credentialSource: "service-account",
-      config: { botUser: "users/app-bot" },
-    });
-    listGoogleChatReactions.mockResolvedValue([
-      {
-        name: "reactions/1",
-        emoji: { unicode: "👍" },
-        user: { name: "users/app" },
-      },
-      {
-        name: "reactions/2",
-        emoji: { unicode: "👍" },
-        user: { name: "users/app-bot" },
-      },
-      {
-        name: "reactions/3",
-        emoji: { unicode: "👍" },
-        user: { name: "users/other" },
-      },
-    ]);
-
-    if (!googlechatMessageActions.handleAction) {
-      throw new Error("Expected googlechatMessageActions.handleAction to be defined");
-    }
-    const result = await googlechatMessageActions.handleAction({
-      action: "react",
-      params: {
-        messageId: "spaces/AAA/messages/msg-1",
-        emoji: "👍",
-        remove: true,
-      },
-      cfg: {},
-      accountId: "default",
-    } as never);
-
-    expect(deleteGoogleChatReaction).toHaveBeenCalledTimes(2);
-    expect(deleteGoogleChatReaction).toHaveBeenNthCalledWith(1, {
-      account: expect.anything(),
-      reactionName: "reactions/1",
-    });
-    expect(deleteGoogleChatReaction).toHaveBeenNthCalledWith(2, {
-      account: expect.anything(),
-      reactionName: "reactions/2",
-    });
-    expect(result).toMatchObject({
-      details: {
-        ok: true,
-        removed: 2,
-      },
-    });
-  });
-});

package/src/actions.ts

@@ -1,227 +0,0 @@
-import {
-  createActionGate,
-  jsonResult,
-  readNumberParam,
-  readReactionParams,
-  readStringParam,
-} from "openclaw/plugin-sdk/channel-actions";
-import type {
-  ChannelMessageActionAdapter,
-  ChannelMessageActionName,
-} from "openclaw/plugin-sdk/channel-contract";
-import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
-import { loadOutboundMediaFromUrl } from "openclaw/plugin-sdk/outbound-media";
-import { extractToolSend } from "openclaw/plugin-sdk/tool-send";
-import { listEnabledGoogleChatAccounts, resolveGoogleChatAccount } from "./accounts.js";
-import {
-  createGoogleChatReaction,
-  deleteGoogleChatReaction,
-  listGoogleChatReactions,
-  sendGoogleChatMessage,
-  uploadGoogleChatAttachment,
-} from "./api.js";
-import { getGoogleChatRuntime } from "./runtime.js";
-import { resolveGoogleChatOutboundSpace } from "./targets.js";
-
-const providerId = "googlechat";
-
-function listEnabledAccounts(cfg: OpenClawConfig) {
-  return listEnabledGoogleChatAccounts(cfg).filter(
-    (account) => account.enabled && account.credentialSource !== "none",
-  );
-}
-
-function isReactionsEnabled(accounts: Array<{ config: { actions?: unknown } }>) {
-  for (const account of accounts) {
-    const gate = createActionGate(account.config.actions as Record<string, boolean | undefined>);
-    if (gate("reactions")) {
-      return true;
-    }
-  }
-  return false;
-}
-
-function resolveAppUserNames(account: { config: { botUser?: string | null } }) {
-  return new Set(["users/app", account.config.botUser?.trim()].filter(Boolean) as string[]);
-}
-
-async function loadGoogleChatActionMedia(params: {
-  mediaUrl: string;
-  maxBytes: number;
-  mediaAccess?: {
-    localRoots?: readonly string[];
-    readFile?: (filePath: string) => Promise<Buffer>;
-  };
-  mediaLocalRoots?: readonly string[];
-  mediaReadFile?: (filePath: string) => Promise<Buffer>;
-}) {
-  const runtime = getGoogleChatRuntime();
-  return /^https?:\/\//i.test(params.mediaUrl)
-    ? await runtime.channel.media.fetchRemoteMedia({
-        url: params.mediaUrl,
-        maxBytes: params.maxBytes,
-      })
-    : await loadOutboundMediaFromUrl(params.mediaUrl, {
-        maxBytes: params.maxBytes,
-        mediaAccess: params.mediaAccess,
-        mediaLocalRoots: params.mediaLocalRoots,
-        mediaReadFile: params.mediaReadFile,
-      });
-}
-
-export const googlechatMessageActions: ChannelMessageActionAdapter = {
-  describeMessageTool: ({ cfg, accountId }) => {
-    const accounts = accountId
-      ? [resolveGoogleChatAccount({ cfg, accountId })].filter(
-          (account) => account.enabled && account.credentialSource !== "none",
-        )
-      : listEnabledAccounts(cfg);
-    if (accounts.length === 0) {
-      return null;
-    }
-    const actions = new Set<ChannelMessageActionName>([]);
-    actions.add("send");
-    actions.add("upload-file");
-    if (isReactionsEnabled(accounts)) {
-      actions.add("react");
-      actions.add("reactions");
-    }
-    return { actions: Array.from(actions) };
-  },
-  extractToolSend: ({ args }) => {
-    return extractToolSend(args, "sendMessage");
-  },
-  handleAction: async ({
-    action,
-    params,
-    cfg,
-    accountId,
-    mediaAccess,
-    mediaLocalRoots,
-    mediaReadFile,
-  }) => {
-    const account = resolveGoogleChatAccount({
-      cfg: cfg,
-      accountId,
-    });
-    if (account.credentialSource === "none") {
-      throw new Error("Google Chat credentials are missing.");
-    }
-
-    if (action === "send" || action === "upload-file") {
-      const to = readStringParam(params, "to", { required: true });
-      const content =
-        readStringParam(params, "message", {
-          required: action === "send",
-          allowEmpty: true,
-        }) ??
-        readStringParam(params, "initialComment", {
-          allowEmpty: true,
-        }) ??
-        "";
-      const mediaUrl =
-        readStringParam(params, "media", { trim: false }) ??
-        readStringParam(params, "filePath", { trim: false }) ??
-        readStringParam(params, "path", { trim: false });
-      const threadId = readStringParam(params, "threadId") ?? readStringParam(params, "replyTo");
-      const space = await resolveGoogleChatOutboundSpace({ account, target: to });
-
-      if (mediaUrl) {
-        const maxBytes = (account.config.mediaMaxMb ?? 20) * 1024 * 1024;
-        const loaded = await loadGoogleChatActionMedia({
-          mediaUrl,
-          maxBytes,
-          mediaAccess,
-          mediaLocalRoots,
-          mediaReadFile,
-        });
-        const uploadFileName =
-          readStringParam(params, "filename") ??
-          readStringParam(params, "title") ??
-          loaded.fileName ??
-          "attachment";
-        const upload = await uploadGoogleChatAttachment({
-          account,
-          space,
-          filename: uploadFileName,
-          buffer: loaded.buffer,
-          contentType: loaded.contentType,
-        });
-        await sendGoogleChatMessage({
-          account,
-          space,
-          text: content,
-          thread: threadId ?? undefined,
-          attachments: upload.attachmentUploadToken
-            ? [
-                {
-                  attachmentUploadToken: upload.attachmentUploadToken,
-                  contentName: uploadFileName,
-                },
-              ]
-            : undefined,
-        });
-        return jsonResult({ ok: true, to: space });
-      }
-
-      if (action === "upload-file") {
-        throw new Error("upload-file requires media, filePath, or path");
-      }
-
-      await sendGoogleChatMessage({
-        account,
-        space,
-        text: content,
-        thread: threadId ?? undefined,
-      });
-      return jsonResult({ ok: true, to: space });
-    }
-
-    if (action === "react") {
-      const messageName = readStringParam(params, "messageId", { required: true });
-      const { emoji, remove, isEmpty } = readReactionParams(params, {
-        removeErrorMessage: "Emoji is required to remove a Google Chat reaction.",
-      });
-      if (remove || isEmpty) {
-        const reactions = await listGoogleChatReactions({ account, messageName });
-        const appUsers = resolveAppUserNames(account);
-        const toRemove = reactions.filter((reaction) => {
-          const userName = reaction.user?.name?.trim();
-          if (appUsers.size > 0 && !appUsers.has(userName ?? "")) {
-            return false;
-          }
-          if (emoji) {
-            return reaction.emoji?.unicode === emoji;
-          }
-          return true;
-        });
-        for (const reaction of toRemove) {
-          if (!reaction.name) {
-            continue;
-          }
-          await deleteGoogleChatReaction({ account, reactionName: reaction.name });
-        }
-        return jsonResult({ ok: true, removed: toRemove.length });
-      }
-      const reaction = await createGoogleChatReaction({
-        account,
-        messageName,
-        emoji,
-      });
-      return jsonResult({ ok: true, reaction });
-    }
-
-    if (action === "reactions") {
-      const messageName = readStringParam(params, "messageId", { required: true });
-      const limit = readNumberParam(params, "limit", { integer: true });
-      const reactions = await listGoogleChatReactions({
-        account,
-        messageName,
-        limit: limit ?? undefined,
-      });
-      return jsonResult({ ok: true, reactions });
-    }
-
-    throw new Error(`Action ${action} is not supported for provider ${providerId}.`);
-  },
-};