loudmouth-ai 0.1.0 → 0.2.0

package/extensions/googlechat/src/accounts.ts

@@ -1,133 +0,0 @@
-import type { ClawdbotConfig } from "clawdbot/plugin-sdk";
-import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "clawdbot/plugin-sdk";
-
-import type { GoogleChatAccountConfig, GoogleChatConfig } from "./types.config.js";
-
-export type GoogleChatCredentialSource = "file" | "inline" | "env" | "none";
-
-export type ResolvedGoogleChatAccount = {
-  accountId: string;
-  name?: string;
-  enabled: boolean;
-  config: GoogleChatAccountConfig;
-  credentialSource: GoogleChatCredentialSource;
-  credentials?: Record<string, unknown>;
-  credentialsFile?: string;
-};
-
-const ENV_SERVICE_ACCOUNT = "GOOGLE_CHAT_SERVICE_ACCOUNT";
-const ENV_SERVICE_ACCOUNT_FILE = "GOOGLE_CHAT_SERVICE_ACCOUNT_FILE";
-
-function listConfiguredAccountIds(cfg: ClawdbotConfig): string[] {
-  const accounts = (cfg.channels?.["googlechat"] as GoogleChatConfig | undefined)?.accounts;
-  if (!accounts || typeof accounts !== "object") return [];
-  return Object.keys(accounts).filter(Boolean);
-}
-
-export function listGoogleChatAccountIds(cfg: ClawdbotConfig): string[] {
-  const ids = listConfiguredAccountIds(cfg);
-  if (ids.length === 0) return [DEFAULT_ACCOUNT_ID];
-  return ids.sort((a, b) => a.localeCompare(b));
-}
-
-export function resolveDefaultGoogleChatAccountId(cfg: ClawdbotConfig): string {
-  const channel = cfg.channels?.["googlechat"] as GoogleChatConfig | undefined;
-  if (channel?.defaultAccount?.trim()) return channel.defaultAccount.trim();
-  const ids = listGoogleChatAccountIds(cfg);
-  if (ids.includes(DEFAULT_ACCOUNT_ID)) return DEFAULT_ACCOUNT_ID;
-  return ids[0] ?? DEFAULT_ACCOUNT_ID;
-}
-
-function resolveAccountConfig(
-  cfg: ClawdbotConfig,
-  accountId: string,
-): GoogleChatAccountConfig | undefined {
-  const accounts = (cfg.channels?.["googlechat"] as GoogleChatConfig | undefined)?.accounts;
-  if (!accounts || typeof accounts !== "object") return undefined;
-  return accounts[accountId] as GoogleChatAccountConfig | undefined;
-}
-
-function mergeGoogleChatAccountConfig(
-  cfg: ClawdbotConfig,
-  accountId: string,
-): GoogleChatAccountConfig {
-  const raw = (cfg.channels?.["googlechat"] ?? {}) as GoogleChatConfig;
-  const { accounts: _ignored, defaultAccount: _ignored2, ...base } = raw;
-  const account = resolveAccountConfig(cfg, accountId) ?? {};
-  return { ...base, ...account } as GoogleChatAccountConfig;
-}
-
-function parseServiceAccount(value: unknown): Record<string, unknown> | null {
-  if (value && typeof value === "object") return value as Record<string, unknown>;
-  if (typeof value !== "string") return null;
-  const trimmed = value.trim();
-  if (!trimmed) return null;
-  try {
-    return JSON.parse(trimmed) as Record<string, unknown>;
-  } catch {
-    return null;
-  }
-}
-
-function resolveCredentialsFromConfig(params: {
-  accountId: string;
-  account: GoogleChatAccountConfig;
-}): {
-  credentials?: Record<string, unknown>;
-  credentialsFile?: string;
-  source: GoogleChatCredentialSource;
-} {
-  const { account, accountId } = params;
-  const inline = parseServiceAccount(account.serviceAccount);
-  if (inline) {
-    return { credentials: inline, source: "inline" };
-  }
-
-  const file = account.serviceAccountFile?.trim();
-  if (file) {
-    return { credentialsFile: file, source: "file" };
-  }
-
-  if (accountId === DEFAULT_ACCOUNT_ID) {
-    const envJson = process.env[ENV_SERVICE_ACCOUNT];
-    const envInline = parseServiceAccount(envJson);
-    if (envInline) {
-      return { credentials: envInline, source: "env" };
-    }
-    const envFile = process.env[ENV_SERVICE_ACCOUNT_FILE]?.trim();
-    if (envFile) {
-      return { credentialsFile: envFile, source: "env" };
-    }
-  }
-
-  return { source: "none" };
-}
-
-export function resolveGoogleChatAccount(params: {
-  cfg: ClawdbotConfig;
-  accountId?: string | null;
-}): ResolvedGoogleChatAccount {
-  const accountId = normalizeAccountId(params.accountId);
-  const baseEnabled =
-    (params.cfg.channels?.["googlechat"] as GoogleChatConfig | undefined)?.enabled !== false;
-  const merged = mergeGoogleChatAccountConfig(params.cfg, accountId);
-  const accountEnabled = merged.enabled !== false;
-  const enabled = baseEnabled && accountEnabled;
-  const credentials = resolveCredentialsFromConfig({ accountId, account: merged });
-
-  return {
-    accountId,
-    name: merged.name?.trim() || undefined,
-    enabled,
-    config: merged,
-    credentialSource: credentials.source,
-    credentials: credentials.credentials,
-    credentialsFile: credentials.credentialsFile,
-  };
-}
-
-export function listEnabledGoogleChatAccounts(cfg: ClawdbotConfig): ResolvedGoogleChatAccount[] {
-  return listGoogleChatAccountIds(cfg)
-    .map((accountId) => resolveGoogleChatAccount({ cfg, accountId }))
-    .filter((account) => account.enabled);
-}

package/extensions/googlechat/src/actions.ts

@@ -1,162 +0,0 @@
-import type {
-  ChannelMessageActionAdapter,
-  ChannelMessageActionName,
-  ClawdbotConfig,
-} from "clawdbot/plugin-sdk";
-import {
-  createActionGate,
-  jsonResult,
-  readNumberParam,
-  readReactionParams,
-  readStringParam,
-} from "clawdbot/plugin-sdk";
-
-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: ClawdbotConfig) {
-  return listEnabledGoogleChatAccounts(cfg).filter(
-    (account) => account.enabled && account.credentialSource !== "none",
-  );
-}
-
-function isReactionsEnabled(accounts: ReturnType<typeof listEnabledAccounts>, cfg: ClawdbotConfig) {
-  for (const account of accounts) {
-    const gate = createActionGate(
-      (account.config.actions ?? (cfg.channels?.["googlechat"] as { actions?: unknown })?.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[]);
-}
-
-export const googlechatMessageActions: ChannelMessageActionAdapter = {
-  listActions: ({ cfg }) => {
-    const accounts = listEnabledAccounts(cfg as ClawdbotConfig);
-    if (accounts.length === 0) return [];
-    const actions = new Set<ChannelMessageActionName>([]);
-    actions.add("send");
-    if (isReactionsEnabled(accounts, cfg as ClawdbotConfig)) {
-      actions.add("react");
-      actions.add("reactions");
-    }
-    return Array.from(actions);
-  },
-  extractToolSend: ({ args }) => {
-    const action = typeof args.action === "string" ? args.action.trim() : "";
-    if (action !== "sendMessage") return null;
-    const to = typeof args.to === "string" ? args.to : undefined;
-    if (!to) return null;
-    const accountId = typeof args.accountId === "string" ? args.accountId.trim() : undefined;
-    return { to, accountId };
-  },
-  handleAction: async ({ action, params, cfg, accountId }) => {
-    const account = resolveGoogleChatAccount({
-      cfg: cfg as ClawdbotConfig,
-      accountId,
-    });
-    if (account.credentialSource === "none") {
-      throw new Error("Google Chat credentials are missing.");
-    }
-
-    if (action === "send") {
-      const to = readStringParam(params, "to", { required: true });
-      const content = readStringParam(params, "message", {
-        required: true,
-        allowEmpty: true,
-      });
-      const mediaUrl = readStringParam(params, "media", { trim: false });
-      const threadId = readStringParam(params, "threadId") ?? readStringParam(params, "replyTo");
-      const space = await resolveGoogleChatOutboundSpace({ account, target: to });
-
-      if (mediaUrl) {
-        const core = getGoogleChatRuntime();
-        const maxBytes = (account.config.mediaMaxMb ?? 20) * 1024 * 1024;
-        const loaded = await core.channel.media.fetchRemoteMedia(mediaUrl, { maxBytes });
-        const upload = await uploadGoogleChatAttachment({
-          account,
-          space,
-          filename: loaded.filename ?? "attachment",
-          buffer: loaded.buffer,
-          contentType: loaded.contentType,
-        });
-        await sendGoogleChatMessage({
-          account,
-          space,
-          text: content,
-          thread: threadId ?? undefined,
-          attachments: upload.attachmentUploadToken
-            ? [{ attachmentUploadToken: upload.attachmentUploadToken, contentName: loaded.filename }]
-            : undefined,
-        });
-        return jsonResult({ ok: true, to: space });
-      }
-
-      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/extensions/googlechat/src/api.test.ts

@@ -1,62 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import type { ResolvedGoogleChatAccount } from "./accounts.js";
-import { downloadGoogleChatMedia } from "./api.js";
-
-vi.mock("./auth.js", () => ({
-  getGoogleChatAccessToken: vi.fn().mockResolvedValue("token"),
-}));
-
-const account = {
-  accountId: "default",
-  enabled: true,
-  credentialSource: "inline",
-  config: {},
-} as ResolvedGoogleChatAccount;
-
-describe("downloadGoogleChatMedia", () => {
-  afterEach(() => {
-    vi.unstubAllGlobals();
-  });
-
-  it("rejects when content-length exceeds max bytes", async () => {
-    const body = new ReadableStream({
-      start(controller) {
-        controller.enqueue(new Uint8Array([1, 2, 3]));
-        controller.close();
-      },
-    });
-    const response = new Response(body, {
-      status: 200,
-      headers: { "content-length": "50", "content-type": "application/octet-stream" },
-    });
-    vi.stubGlobal("fetch", vi.fn().mockResolvedValue(response));
-
-    await expect(
-      downloadGoogleChatMedia({ account, resourceName: "media/123", maxBytes: 10 }),
-    ).rejects.toThrow(/max bytes/i);
-  });
-
-  it("rejects when streamed payload exceeds max bytes", async () => {
-    const chunks = [new Uint8Array(6), new Uint8Array(6)];
-    let index = 0;
-    const body = new ReadableStream({
-      pull(controller) {
-        if (index < chunks.length) {
-          controller.enqueue(chunks[index++]);
-        } else {
-          controller.close();
-        }
-      },
-    });
-    const response = new Response(body, {
-      status: 200,
-      headers: { "content-type": "application/octet-stream" },
-    });
-    vi.stubGlobal("fetch", vi.fn().mockResolvedValue(response));
-
-    await expect(
-      downloadGoogleChatMedia({ account, resourceName: "media/123", maxBytes: 10 }),
-    ).rejects.toThrow(/max bytes/i);
-  });
-});

package/extensions/googlechat/src/api.ts

@@ -1,259 +0,0 @@
-import crypto from "node:crypto";
-
-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 fetchJson<T>(
-  account: ResolvedGoogleChatAccount,
-  url: string,
-  init: RequestInit,
-): Promise<T> {
-  const token = await getGoogleChatAccessToken(account);
-  const res = await fetch(url, {
-    ...init,
-    headers: {
-      Authorization: `Bearer ${token}`,
-      "Content-Type": "application/json",
-      ...(init.headers ?? {}),
-    },
-  });
-  if (!res.ok) {
-    const text = await res.text().catch(() => "");
-    throw new Error(`Google Chat API ${res.status}: ${text || res.statusText}`);
-  }
-  return (await res.json()) as T;
-}
-
-async function fetchOk(
-  account: ResolvedGoogleChatAccount,
-  url: string,
-  init: RequestInit,
-): Promise<void> {
-  const token = await getGoogleChatAccessToken(account);
-  const res = await fetch(url, {
-    ...init,
-    headers: {
-      Authorization: `Bearer ${token}`,
-      ...(init.headers ?? {}),
-    },
-  });
-  if (!res.ok) {
-    const text = await res.text().catch(() => "");
-    throw new Error(`Google Chat API ${res.status}: ${text || res.statusText}`);
-  }
-}
-
-async function fetchBuffer(
-  account: ResolvedGoogleChatAccount,
-  url: string,
-  init?: RequestInit,
-  options?: { maxBytes?: number },
-): Promise<{ buffer: Buffer; contentType?: string }> {
-  const token = await getGoogleChatAccessToken(account);
-  const res = await fetch(url, {
-    ...init,
-    headers: {
-      Authorization: `Bearer ${token}`,
-      ...(init?.headers ?? {}),
-    },
-  });
-  if (!res.ok) {
-    const text = await res.text().catch(() => "");
-    throw new Error(`Google Chat API ${res.status}: ${text || res.statusText}`);
-  }
-  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 || !res.body) {
-    const buffer = Buffer.from(await res.arrayBuffer());
-    const contentType = res.headers.get("content-type") ?? undefined;
-    return { buffer, contentType };
-  }
-  const reader = res.body.getReader();
-  const chunks: Buffer[] = [];
-  let total = 0;
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    if (!value) continue;
-    total += value.length;
-    if (total > maxBytes) {
-      await reader.cancel();
-      throw new Error(`Google Chat media exceeds max bytes (${maxBytes})`);
-    }
-    chunks.push(Buffer.from(value));
-  }
-  const buffer = Buffer.concat(chunks, total);
-  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) => ({
-      attachmentDataRef: { attachmentUploadToken: item.attachmentUploadToken },
-      ...(item.contentName ? { contentName: item.contentName } : {}),
-    }));
-  }
-  const url = `${CHAT_API_BASE}/${space}/messages`;
-  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 = `clawdbot-${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 token = await getGoogleChatAccessToken(account);
-  const url = `${CHAT_UPLOAD_BASE}/${space}/attachments:upload?uploadType=multipart`;
-  const res = await fetch(url, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${token}`,
-      "Content-Type": `multipart/related; boundary=${boundary}`,
-    },
-    body,
-  });
-  if (!res.ok) {
-    const text = await res.text().catch(() => "");
-    throw new Error(`Google Chat upload ${res.status}: ${text || res.statusText}`);
-  }
-  const payload = (await res.json()) as {
-    attachmentDataRef?: { attachmentUploadToken?: string };
-  };
-  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: err instanceof Error ? err.message : String(err) };
-  }
-}