@kodelyth/googlechat 2026.5.42 → 2026.6.1

package/src/actions.ts

@@ -1,227 +0,0 @@
-import {
-  createActionGate,
-  jsonResult,
-  readNumberParam,
-  readReactionParams,
-  readStringParam,
-} from "klaw/plugin-sdk/channel-actions";
-import type {
-  ChannelMessageActionAdapter,
-  ChannelMessageActionName,
-} from "klaw/plugin-sdk/channel-contract";
-import type { KlawConfig } from "klaw/plugin-sdk/config-contracts";
-import { loadOutboundMediaFromUrl } from "klaw/plugin-sdk/outbound-media";
-import { extractToolSend } from "klaw/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: KlawConfig) {
-  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.readRemoteMediaBuffer({
-        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}.`);
-  },
-};

package/src/api.ts

@@ -1,316 +0,0 @@
-import crypto from "node:crypto";
-import { formatErrorMessage } from "klaw/plugin-sdk/error-runtime";
-import { readResponseWithLimit } from "klaw/plugin-sdk/response-limit-runtime";
-import { fetchWithSsrFGuard } from "klaw/plugin-sdk/ssrf-runtime";
-import type { ResolvedGoogleChatAccount } from "./accounts.js";
-import { getGoogleChatAccessToken } from "./auth.js";
-import type { GoogleChatReaction } from "./types.js";
-
-const CHAT_API_BASE = "https://chat.googleapis.com/v1";
-const CHAT_UPLOAD_BASE = "https://chat.googleapis.com/upload/v1";
-
-async function readGoogleChatJsonResponse<T>(response: Response, label: string): Promise<T> {
-  try {
-    return (await response.json()) as T;
-  } catch (cause) {
-    throw new Error(`${label}: malformed JSON response`, { cause });
-  }
-}
-
-const headersToObject = (headers?: HeadersInit): Record<string, string> =>
-  headers instanceof Headers
-    ? Object.fromEntries(headers.entries())
-    : Array.isArray(headers)
-      ? Object.fromEntries(headers)
-      : headers || {};
-
-async function withGoogleChatResponse<T>(params: {
-  account: ResolvedGoogleChatAccount;
-  url: string;
-  init?: RequestInit;
-  auditContext: string;
-  errorPrefix?: string;
-  handleResponse: (response: Response) => Promise<T>;
-}): Promise<T> {
-  const {
-    account,
-    url,
-    init,
-    auditContext,
-    errorPrefix = "Google Chat API",
-    handleResponse,
-  } = params;
-  const token = await getGoogleChatAccessToken(account);
-  const { response, release } = await fetchWithSsrFGuard({
-    url,
-    init: {
-      ...init,
-      headers: {
-        ...headersToObject(init?.headers),
-        Authorization: `Bearer ${token}`,
-      },
-    },
-    auditContext,
-  });
-  try {
-    if (!response.ok) {
-      const text = await response.text().catch(() => "");
-      throw new Error(`${errorPrefix} ${response.status}: ${text || response.statusText}`);
-    }
-    return await handleResponse(response);
-  } finally {
-    await release();
-  }
-}
-
-async function fetchJson<T>(
-  account: ResolvedGoogleChatAccount,
-  url: string,
-  init: RequestInit,
-): Promise<T> {
-  return await withGoogleChatResponse({
-    account,
-    url,
-    init: {
-      ...init,
-      headers: {
-        ...headersToObject(init.headers),
-        "Content-Type": "application/json",
-      },
-    },
-    auditContext: "googlechat.api.json",
-    handleResponse: async (response) =>
-      await readGoogleChatJsonResponse<T>(response, "Google Chat API request failed"),
-  });
-}
-
-async function fetchOk(
-  account: ResolvedGoogleChatAccount,
-  url: string,
-  init: RequestInit,
-): Promise<void> {
-  await withGoogleChatResponse({
-    account,
-    url,
-    init,
-    auditContext: "googlechat.api.ok",
-    handleResponse: async () => undefined,
-  });
-}
-
-async function fetchBuffer(
-  account: ResolvedGoogleChatAccount,
-  url: string,
-  init?: RequestInit,
-  options?: { maxBytes?: number },
-): Promise<{ buffer: Buffer; contentType?: string }> {
-  return await withGoogleChatResponse({
-    account,
-    url,
-    init,
-    auditContext: "googlechat.api.buffer",
-    handleResponse: async (res) => {
-      const maxBytes = options?.maxBytes;
-      const lengthHeader = res.headers.get("content-length");
-      if (maxBytes && lengthHeader) {
-        const length = Number(lengthHeader);
-        if (Number.isFinite(length) && length > maxBytes) {
-          throw new Error(`Google Chat media exceeds max bytes (${maxBytes})`);
-        }
-      }
-      if (!maxBytes) {
-        const buffer = Buffer.from(await res.arrayBuffer());
-        const contentType = res.headers.get("content-type") ?? undefined;
-        return { buffer, contentType };
-      }
-      const buffer = await readResponseWithLimit(res, maxBytes, {
-        onOverflow: () => new Error(`Google Chat media exceeds max bytes (${maxBytes})`),
-      });
-      const contentType = res.headers.get("content-type") ?? undefined;
-      return { buffer, contentType };
-    },
-  });
-}
-
-export async function sendGoogleChatMessage(params: {
-  account: ResolvedGoogleChatAccount;
-  space: string;
-  text?: string;
-  thread?: string;
-  attachments?: Array<{ attachmentUploadToken: string; contentName?: string }>;
-}): Promise<{ messageName?: string } | null> {
-  const { account, space, text, thread, attachments } = params;
-  const body: Record<string, unknown> = {};
-  if (text) {
-    body.text = text;
-  }
-  if (thread) {
-    body.thread = { name: thread };
-  }
-  if (attachments && attachments.length > 0) {
-    body.attachment = attachments.map((item) =>
-      Object.assign(
-        { attachmentDataRef: { attachmentUploadToken: item.attachmentUploadToken } },
-        item.contentName ? { contentName: item.contentName } : {},
-      ),
-    );
-  }
-  const urlObj = new URL(`${CHAT_API_BASE}/${space}/messages`);
-  if (thread) {
-    urlObj.searchParams.set("messageReplyOption", "REPLY_MESSAGE_FALLBACK_TO_NEW_THREAD");
-  }
-  const url = urlObj.toString();
-  const result = await fetchJson<{ name?: string }>(account, url, {
-    method: "POST",
-    body: JSON.stringify(body),
-  });
-  return result ? { messageName: result.name } : null;
-}
-
-export async function updateGoogleChatMessage(params: {
-  account: ResolvedGoogleChatAccount;
-  messageName: string;
-  text: string;
-}): Promise<{ messageName?: string }> {
-  const { account, messageName, text } = params;
-  const url = `${CHAT_API_BASE}/${messageName}?updateMask=text`;
-  const result = await fetchJson<{ name?: string }>(account, url, {
-    method: "PATCH",
-    body: JSON.stringify({ text }),
-  });
-  return { messageName: result.name };
-}
-
-export async function deleteGoogleChatMessage(params: {
-  account: ResolvedGoogleChatAccount;
-  messageName: string;
-}): Promise<void> {
-  const { account, messageName } = params;
-  const url = `${CHAT_API_BASE}/${messageName}`;
-  await fetchOk(account, url, { method: "DELETE" });
-}
-
-export async function uploadGoogleChatAttachment(params: {
-  account: ResolvedGoogleChatAccount;
-  space: string;
-  filename: string;
-  buffer: Buffer;
-  contentType?: string;
-}): Promise<{ attachmentUploadToken?: string }> {
-  const { account, space, filename, buffer, contentType } = params;
-  const boundary = `klaw-${crypto.randomUUID()}`;
-  const metadata = JSON.stringify({ filename });
-  const header = `--${boundary}\r\nContent-Type: application/json; charset=UTF-8\r\n\r\n${metadata}\r\n`;
-  const mediaHeader = `--${boundary}\r\nContent-Type: ${contentType ?? "application/octet-stream"}\r\n\r\n`;
-  const footer = `\r\n--${boundary}--\r\n`;
-  const body = Buffer.concat([
-    Buffer.from(header, "utf8"),
-    Buffer.from(mediaHeader, "utf8"),
-    buffer,
-    Buffer.from(footer, "utf8"),
-  ]);
-
-  const url = `${CHAT_UPLOAD_BASE}/${space}/attachments:upload?uploadType=multipart`;
-  const payload = await withGoogleChatResponse<{
-    attachmentDataRef?: { attachmentUploadToken?: string };
-  }>({
-    account,
-    url,
-    init: {
-      method: "POST",
-      headers: {
-        "Content-Type": `multipart/related; boundary=${boundary}`,
-      },
-      body,
-    },
-    auditContext: "googlechat.upload",
-    errorPrefix: "Google Chat upload",
-    handleResponse: async (response) =>
-      await readGoogleChatJsonResponse<{
-        attachmentDataRef?: { attachmentUploadToken?: string };
-      }>(response, "Google Chat upload failed"),
-  });
-  return {
-    attachmentUploadToken: payload.attachmentDataRef?.attachmentUploadToken,
-  };
-}
-
-export async function downloadGoogleChatMedia(params: {
-  account: ResolvedGoogleChatAccount;
-  resourceName: string;
-  maxBytes?: number;
-}): Promise<{ buffer: Buffer; contentType?: string }> {
-  const { account, resourceName, maxBytes } = params;
-  const url = `${CHAT_API_BASE}/media/${resourceName}?alt=media`;
-  return await fetchBuffer(account, url, undefined, { maxBytes });
-}
-
-export async function createGoogleChatReaction(params: {
-  account: ResolvedGoogleChatAccount;
-  messageName: string;
-  emoji: string;
-}): Promise<GoogleChatReaction> {
-  const { account, messageName, emoji } = params;
-  const url = `${CHAT_API_BASE}/${messageName}/reactions`;
-  return await fetchJson<GoogleChatReaction>(account, url, {
-    method: "POST",
-    body: JSON.stringify({ emoji: { unicode: emoji } }),
-  });
-}
-
-export async function listGoogleChatReactions(params: {
-  account: ResolvedGoogleChatAccount;
-  messageName: string;
-  limit?: number;
-}): Promise<GoogleChatReaction[]> {
-  const { account, messageName, limit } = params;
-  const url = new URL(`${CHAT_API_BASE}/${messageName}/reactions`);
-  if (limit && limit > 0) {
-    url.searchParams.set("pageSize", String(limit));
-  }
-  const result = await fetchJson<{ reactions?: GoogleChatReaction[] }>(account, url.toString(), {
-    method: "GET",
-  });
-  return result.reactions ?? [];
-}
-
-export async function deleteGoogleChatReaction(params: {
-  account: ResolvedGoogleChatAccount;
-  reactionName: string;
-}): Promise<void> {
-  const { account, reactionName } = params;
-  const url = `${CHAT_API_BASE}/${reactionName}`;
-  await fetchOk(account, url, { method: "DELETE" });
-}
-
-export async function findGoogleChatDirectMessage(params: {
-  account: ResolvedGoogleChatAccount;
-  userName: string;
-}): Promise<{ name?: string; displayName?: string } | null> {
-  const { account, userName } = params;
-  const url = new URL(`${CHAT_API_BASE}/spaces:findDirectMessage`);
-  url.searchParams.set("name", userName);
-  return await fetchJson<{ name?: string; displayName?: string }>(account, url.toString(), {
-    method: "GET",
-  });
-}
-
-export async function probeGoogleChat(account: ResolvedGoogleChatAccount): Promise<{
-  ok: boolean;
-  status?: number;
-  error?: string;
-}> {
-  try {
-    const url = new URL(`${CHAT_API_BASE}/spaces`);
-    url.searchParams.set("pageSize", "1");
-    await fetchJson<Record<string, unknown>>(account, url.toString(), {
-      method: "GET",
-    });
-    return { ok: true };
-  } catch (err) {
-    return {
-      ok: false,
-      error: formatErrorMessage(err),
-    };
-  }
-}

package/src/approval-auth.test.ts

@@ -1,24 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { googleChatApprovalAuth } from "./approval-auth.js";
-
-describe("googleChatApprovalAuth", () => {
-  it("authorizes stable users/* ids and ignores email-style approvers", () => {
-    expect(
-      googleChatApprovalAuth.authorizeActorAction({
-        cfg: { channels: { googlechat: { dm: { allowFrom: ["users/123"] } } } },
-        senderId: "users/123",
-        action: "approve",
-        approvalKind: "exec",
-      }),
-    ).toEqual({ authorized: true });
-
-    expect(
-      googleChatApprovalAuth.authorizeActorAction({
-        cfg: { channels: { googlechat: { dm: { allowFrom: ["owner@example.com"] } } } },
-        senderId: "users/attacker",
-        action: "approve",
-        approvalKind: "exec",
-      }),
-    ).toEqual({ authorized: true });
-  });
-});

package/src/approval-auth.ts

@@ -1,32 +0,0 @@
-import {
-  createResolvedApproverActionAuthAdapter,
-  resolveApprovalApprovers,
-} from "klaw/plugin-sdk/approval-auth-runtime";
-import { normalizeLowercaseStringOrEmpty } from "klaw/plugin-sdk/string-coerce-runtime";
-import { resolveGoogleChatAccount } from "./accounts.js";
-import { isGoogleChatUserTarget, normalizeGoogleChatTarget } from "./targets.js";
-
-function normalizeGoogleChatApproverId(value: string | number): string | undefined {
-  const normalized = normalizeGoogleChatTarget(String(value));
-  if (!normalized || !isGoogleChatUserTarget(normalized)) {
-    return undefined;
-  }
-  const suffix = normalizeLowercaseStringOrEmpty(normalized.slice("users/".length));
-  if (!suffix || suffix.includes("@")) {
-    return undefined;
-  }
-  return `users/${suffix}`;
-}
-
-export const googleChatApprovalAuth = createResolvedApproverActionAuthAdapter({
-  channelLabel: "Google Chat",
-  resolveApprovers: ({ cfg, accountId }) => {
-    const account = resolveGoogleChatAccount({ cfg, accountId }).config;
-    return resolveApprovalApprovers({
-      allowFrom: account.dm?.allowFrom,
-      defaultTo: account.defaultTo,
-      normalizeApprover: normalizeGoogleChatApproverId,
-    });
-  },
-  normalizeSenderId: (value) => normalizeGoogleChatApproverId(value),
-});