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

package/src/channel.ts

@@ -1,256 +0,0 @@
-import { describeAccountSnapshot } from "openclaw/plugin-sdk/account-helpers";
-import { formatNormalizedAllowFromEntries } from "openclaw/plugin-sdk/allow-from";
-import {
-  adaptScopedAccountAccessor,
-  createScopedChannelConfigAdapter,
-} from "openclaw/plugin-sdk/channel-config-helpers";
-import { createChatChannelPlugin } from "openclaw/plugin-sdk/channel-core";
-import { buildPassiveProbedChannelStatusSummary } from "openclaw/plugin-sdk/extension-shared";
-import { createLazyRuntimeNamedExport } from "openclaw/plugin-sdk/lazy-runtime";
-import {
-  createComputedAccountStatusAdapter,
-  createDefaultChannelRuntimeState,
-} from "openclaw/plugin-sdk/status-helpers";
-import { googlechatMessageActions } from "./actions.js";
-import { googleChatApprovalAuth } from "./approval-auth.js";
-import {
-  formatAllowFromEntry,
-  googlechatDirectoryAdapter,
-  googlechatGroupsAdapter,
-  googlechatOutboundAdapter,
-  googlechatPairingTextAdapter,
-  googlechatSecurityAdapter,
-  googlechatThreadingAdapter,
-} from "./channel.adapters.js";
-import {
-  buildChannelConfigSchema,
-  DEFAULT_ACCOUNT_ID,
-  GoogleChatConfigSchema,
-  isGoogleChatSpaceTarget,
-  isGoogleChatUserTarget,
-  listGoogleChatAccountIds,
-  normalizeGoogleChatTarget,
-  type GoogleChatConfigAccessorAccount,
-  resolveGoogleChatConfigAccessorAccount,
-  resolveDefaultGoogleChatAccountId,
-  resolveGoogleChatAccount,
-  type ChannelMessageActionAdapter,
-  type ChannelStatusIssue,
-  type ResolvedGoogleChatAccount,
-} from "./channel.deps.runtime.js";
-import {
-  legacyConfigRules as GOOGLECHAT_LEGACY_CONFIG_RULES,
-  normalizeCompatibilityConfig as normalizeGoogleChatCompatibilityConfig,
-} from "./doctor-contract.js";
-import { collectGoogleChatMutableAllowlistWarnings } from "./doctor.js";
-import { startGoogleChatGatewayAccount } from "./gateway.js";
-import { collectRuntimeConfigAssignments, secretTargetRegistryEntries } from "./secret-contract.js";
-import { googlechatSetupAdapter } from "./setup-core.js";
-import { googlechatSetupWizard } from "./setup-surface.js";
-
-const loadGoogleChatChannelRuntime = createLazyRuntimeNamedExport(
-  () => import("./channel.runtime.js"),
-  "googleChatChannelRuntime",
-);
-
-const meta = {
-  id: "googlechat",
-  label: "Google Chat",
-  selectionLabel: "Google Chat (Chat API)",
-  docsPath: "/channels/googlechat",
-  docsLabel: "googlechat",
-  blurb: "Google Workspace Chat app with HTTP webhook.",
-  aliases: ["gchat", "google-chat"],
-  order: 55,
-  detailLabel: "Google Chat",
-  systemImage: "message.badge",
-  markdownCapable: true,
-};
-
-const googleChatConfigAdapter = createScopedChannelConfigAdapter<
-  ResolvedGoogleChatAccount,
-  GoogleChatConfigAccessorAccount
->({
-  sectionKey: "googlechat",
-  listAccountIds: listGoogleChatAccountIds,
-  resolveAccount: adaptScopedAccountAccessor(resolveGoogleChatAccount),
-  resolveAccessorAccount: resolveGoogleChatConfigAccessorAccount,
-  defaultAccountId: resolveDefaultGoogleChatAccountId,
-  clearBaseFields: [
-    "serviceAccount",
-    "serviceAccountFile",
-    "audienceType",
-    "audience",
-    "webhookPath",
-    "webhookUrl",
-    "botUser",
-    "name",
-  ],
-  resolveAllowFrom: (account) => account.config.dm?.allowFrom,
-  formatAllowFrom: (allowFrom) =>
-    formatNormalizedAllowFromEntries({
-      allowFrom,
-      normalizeEntry: formatAllowFromEntry,
-    }),
-  resolveDefaultTo: (account) => account.config.defaultTo,
-});
-
-const googlechatActions: ChannelMessageActionAdapter = {
-  describeMessageTool: (ctx) => googlechatMessageActions.describeMessageTool?.(ctx) ?? null,
-  extractToolSend: (ctx) => googlechatMessageActions.extractToolSend?.(ctx) ?? null,
-  handleAction: async (ctx) => {
-    if (!googlechatMessageActions.handleAction) {
-      throw new Error("Google Chat actions are not available.");
-    }
-    return await googlechatMessageActions.handleAction(ctx);
-  },
-};
-
-export const googlechatPlugin = createChatChannelPlugin({
-  base: {
-    id: "googlechat",
-    meta: { ...meta },
-    setup: googlechatSetupAdapter,
-    setupWizard: googlechatSetupWizard,
-    capabilities: {
-      chatTypes: ["direct", "group", "thread"],
-      reactions: true,
-      threads: true,
-      media: true,
-      nativeCommands: false,
-      blockStreaming: true,
-    },
-    streaming: {
-      blockStreamingCoalesceDefaults: { minChars: 1500, idleMs: 1000 },
-    },
-    reload: { configPrefixes: ["channels.googlechat"] },
-    configSchema: buildChannelConfigSchema(GoogleChatConfigSchema),
-    config: {
-      ...googleChatConfigAdapter,
-      isConfigured: (account) => account.credentialSource !== "none",
-      describeAccount: (account) =>
-        describeAccountSnapshot({
-          account,
-          configured: account.credentialSource !== "none",
-          extra: {
-            credentialSource: account.credentialSource,
-          },
-        }),
-    },
-    approvalCapability: googleChatApprovalAuth,
-    secrets: {
-      secretTargetRegistryEntries,
-      collectRuntimeConfigAssignments,
-    },
-    groups: googlechatGroupsAdapter,
-    messaging: {
-      targetPrefixes: ["googlechat", "google-chat", "gchat"],
-      normalizeTarget: normalizeGoogleChatTarget,
-      targetResolver: {
-        looksLikeId: (raw, normalized) => {
-          const value = normalized ?? raw.trim();
-          return isGoogleChatSpaceTarget(value) || isGoogleChatUserTarget(value);
-        },
-        hint: "<spaces/{space}|users/{user}>",
-      },
-    },
-    directory: googlechatDirectoryAdapter,
-    resolver: {
-      resolveTargets: async ({ inputs, kind }) => {
-        const resolved = inputs.map((input) => {
-          const normalized = normalizeGoogleChatTarget(input);
-          if (!normalized) {
-            return { input, resolved: false, note: "empty target" };
-          }
-          if (kind === "user" && isGoogleChatUserTarget(normalized)) {
-            return { input, resolved: true, id: normalized };
-          }
-          if (kind === "group" && isGoogleChatSpaceTarget(normalized)) {
-            return { input, resolved: true, id: normalized };
-          }
-          return {
-            input,
-            resolved: false,
-            note: "use spaces/{space} or users/{user}",
-          };
-        });
-        return resolved;
-      },
-    },
-    actions: googlechatActions,
-    doctor: {
-      dmAllowFromMode: "nestedOnly",
-      groupModel: "route",
-      groupAllowFromFallbackToAllowFrom: false,
-      warnOnEmptyGroupSenderAllowlist: false,
-      legacyConfigRules: GOOGLECHAT_LEGACY_CONFIG_RULES,
-      normalizeCompatibilityConfig: normalizeGoogleChatCompatibilityConfig,
-      collectMutableAllowlistWarnings: collectGoogleChatMutableAllowlistWarnings,
-    },
-    status: createComputedAccountStatusAdapter<ResolvedGoogleChatAccount>({
-      defaultRuntime: createDefaultChannelRuntimeState(DEFAULT_ACCOUNT_ID),
-      collectStatusIssues: (accounts): ChannelStatusIssue[] =>
-        accounts.flatMap((entry) => {
-          const accountId = entry.accountId ?? DEFAULT_ACCOUNT_ID;
-          const enabled = entry.enabled !== false;
-          const configured = entry.configured === true;
-          if (!enabled || !configured) {
-            return [];
-          }
-          const issues: ChannelStatusIssue[] = [];
-          if (!entry.audience) {
-            issues.push({
-              channel: "googlechat",
-              accountId,
-              kind: "config",
-              message: "Google Chat audience is missing (set channels.googlechat.audience).",
-              fix: "Set channels.googlechat.audienceType and channels.googlechat.audience.",
-            });
-          }
-          if (!entry.audienceType) {
-            issues.push({
-              channel: "googlechat",
-              accountId,
-              kind: "config",
-              message: "Google Chat audienceType is missing (app-url or project-number).",
-              fix: "Set channels.googlechat.audienceType and channels.googlechat.audience.",
-            });
-          }
-          return issues;
-        }),
-      buildChannelSummary: ({ snapshot }) =>
-        buildPassiveProbedChannelStatusSummary(snapshot, {
-          credentialSource: snapshot.credentialSource ?? "none",
-          audienceType: snapshot.audienceType ?? null,
-          audience: snapshot.audience ?? null,
-          webhookPath: snapshot.webhookPath ?? null,
-          webhookUrl: snapshot.webhookUrl ?? null,
-        }),
-      probeAccount: async ({ account }) =>
-        (await loadGoogleChatChannelRuntime()).probeGoogleChat(account),
-      resolveAccountSnapshot: ({ account }) => ({
-        accountId: account.accountId,
-        name: account.name,
-        enabled: account.enabled,
-        configured: account.credentialSource !== "none",
-        extra: {
-          credentialSource: account.credentialSource,
-          audienceType: account.config.audienceType,
-          audience: account.config.audience,
-          webhookPath: account.config.webhookPath,
-          webhookUrl: account.config.webhookUrl,
-          dmPolicy: account.config.dm?.policy ?? "pairing",
-        },
-      }),
-    }),
-    gateway: {
-      startAccount: startGoogleChatGatewayAccount,
-    },
-  },
-  pairing: {
-    text: googlechatPairingTextAdapter,
-  },
-  security: googlechatSecurityAdapter,
-  threading: googlechatThreadingAdapter,
-  outbound: googlechatOutboundAdapter,
-});

package/src/config-schema.test.ts

@@ -1,16 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { GoogleChatConfigSchema } from "../runtime-api.js";
-
-describe("googlechat config schema", () => {
-  it("accepts serviceAccount refs", () => {
-    const result = GoogleChatConfigSchema.safeParse({
-      serviceAccountRef: {
-        source: "file",
-        provider: "filemain",
-        id: "/channels/googlechat/serviceAccount",
-      },
-    });
-
-    expect(result.success).toBe(true);
-  });
-});

package/src/config-schema.ts

@@ -1,3 +0,0 @@
-import { buildChannelConfigSchema, GoogleChatConfigSchema } from "../runtime-api.js";
-
-export const GoogleChatChannelConfigSchema = buildChannelConfigSchema(GoogleChatConfigSchema);

package/src/doctor-contract.test.ts

@@ -1,75 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { normalizeCompatibilityConfig } from "./doctor-contract.js";
-
-describe("googlechat doctor contract", () => {
-  it("removes legacy streamMode keys", () => {
-    const result = normalizeCompatibilityConfig({
-      cfg: {
-        channels: {
-          googlechat: {
-            streamMode: "append",
-            accounts: {
-              work: {
-                streamMode: "replace",
-              },
-            },
-          },
-        },
-      } as never,
-    });
-
-    expect(result.changes).toEqual([
-      "Removed channels.googlechat.streamMode (legacy key no longer used).",
-      "Removed channels.googlechat.accounts.work.streamMode (legacy key no longer used).",
-    ]);
-    expect(result.config.channels?.googlechat).toEqual({
-      accounts: {
-        work: {},
-      },
-    });
-  });
-
-  it("moves legacy group allow toggles into enabled", () => {
-    const result = normalizeCompatibilityConfig({
-      cfg: {
-        channels: {
-          googlechat: {
-            groups: {
-              "spaces/aaa": {
-                allow: false,
-              },
-              "spaces/bbb": {
-                allow: true,
-                enabled: false,
-              },
-            },
-            accounts: {
-              work: {
-                groups: {
-                  "spaces/ccc": {
-                    allow: true,
-                  },
-                },
-              },
-            },
-          },
-        },
-      } as never,
-    });
-
-    expect(result.changes).toEqual([
-      "Moved channels.googlechat.groups.spaces/aaa.allow → channels.googlechat.groups.spaces/aaa.enabled.",
-      "Removed channels.googlechat.groups.spaces/bbb.allow (channels.googlechat.groups.spaces/bbb.enabled already set).",
-      "Moved channels.googlechat.accounts.work.groups.spaces/ccc.allow → channels.googlechat.accounts.work.groups.spaces/ccc.enabled.",
-    ]);
-    expect(result.config.channels?.googlechat?.groups?.["spaces/aaa"]).toEqual({
-      enabled: false,
-    });
-    expect(result.config.channels?.googlechat?.groups?.["spaces/bbb"]).toEqual({
-      enabled: false,
-    });
-    expect(result.config.channels?.googlechat?.accounts?.work?.groups?.["spaces/ccc"]).toEqual({
-      enabled: true,
-    });
-  });
-});

package/src/doctor-contract.ts

@@ -1,182 +0,0 @@
-import type {
-  ChannelDoctorConfigMutation,
-  ChannelDoctorLegacyConfigRule,
-} from "openclaw/plugin-sdk/channel-contract";
-import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
-import { asObjectRecord } from "openclaw/plugin-sdk/runtime-doctor";
-
-type GoogleChatChannelsConfig = NonNullable<OpenClawConfig["channels"]>;
-
-function hasLegacyGoogleChatStreamMode(value: unknown): boolean {
-  return asObjectRecord(value)?.streamMode !== undefined;
-}
-
-function hasLegacyGoogleChatGroupAllowAlias(value: unknown): boolean {
-  const groups = asObjectRecord(asObjectRecord(value)?.groups);
-  if (!groups) {
-    return false;
-  }
-  return Object.values(groups).some((group) =>
-    Object.prototype.hasOwnProperty.call(asObjectRecord(group) ?? {}, "allow"),
-  );
-}
-
-function hasLegacyAccountAliases(value: unknown, match: (entry: unknown) => boolean): boolean {
-  const accounts = asObjectRecord(value);
-  if (!accounts) {
-    return false;
-  }
-  return Object.values(accounts).some((account) => match(account));
-}
-
-function normalizeGoogleChatGroups(params: {
-  groups: Record<string, unknown>;
-  pathPrefix: string;
-  changes: string[];
-}): { groups: Record<string, unknown>; changed: boolean } {
-  let changed = false;
-  const nextGroups = { ...params.groups };
-  for (const [groupId, groupValue] of Object.entries(params.groups)) {
-    const group = asObjectRecord(groupValue);
-    if (!group || !Object.prototype.hasOwnProperty.call(group, "allow")) {
-      continue;
-    }
-    const nextGroup = { ...group };
-    if (nextGroup.enabled === undefined) {
-      nextGroup.enabled = group.allow;
-      params.changes.push(
-        `Moved ${params.pathPrefix}.${groupId}.allow → ${params.pathPrefix}.${groupId}.enabled.`,
-      );
-    } else {
-      params.changes.push(
-        `Removed ${params.pathPrefix}.${groupId}.allow (${params.pathPrefix}.${groupId}.enabled already set).`,
-      );
-    }
-    delete nextGroup.allow;
-    nextGroups[groupId] = nextGroup;
-    changed = true;
-  }
-  return { groups: nextGroups, changed };
-}
-
-function normalizeGoogleChatEntry(params: {
-  entry: Record<string, unknown>;
-  pathPrefix: string;
-  changes: string[];
-}): { entry: Record<string, unknown>; changed: boolean } {
-  let updated = params.entry;
-  let changed = false;
-
-  if (updated.streamMode !== undefined) {
-    updated = { ...updated };
-    delete updated.streamMode;
-    params.changes.push(`Removed ${params.pathPrefix}.streamMode (legacy key no longer used).`);
-    changed = true;
-  }
-
-  const groups = asObjectRecord(updated.groups);
-  if (groups) {
-    const normalized = normalizeGoogleChatGroups({
-      groups,
-      pathPrefix: `${params.pathPrefix}.groups`,
-      changes: params.changes,
-    });
-    if (normalized.changed) {
-      updated = { ...updated, groups: normalized.groups };
-      changed = true;
-    }
-  }
-
-  return { entry: updated, changed };
-}
-
-export const legacyConfigRules: ChannelDoctorLegacyConfigRule[] = [
-  {
-    path: ["channels", "googlechat"],
-    message: "channels.googlechat.streamMode is legacy and no longer used; it is removed on load.",
-    match: hasLegacyGoogleChatStreamMode,
-  },
-  {
-    path: ["channels", "googlechat", "accounts"],
-    message:
-      "channels.googlechat.accounts.<id>.streamMode is legacy and no longer used; it is removed on load.",
-    match: (value) => hasLegacyAccountAliases(value, hasLegacyGoogleChatStreamMode),
-  },
-  {
-    path: ["channels", "googlechat"],
-    message:
-      'channels.googlechat.groups.<id>.allow is legacy; use channels.googlechat.groups.<id>.enabled instead. Run "openclaw doctor --fix".',
-    match: hasLegacyGoogleChatGroupAllowAlias,
-  },
-  {
-    path: ["channels", "googlechat", "accounts"],
-    message:
-      'channels.googlechat.accounts.<id>.groups.<id>.allow is legacy; use channels.googlechat.accounts.<id>.groups.<id>.enabled instead. Run "openclaw doctor --fix".',
-    match: (value) => hasLegacyAccountAliases(value, hasLegacyGoogleChatGroupAllowAlias),
-  },
-];
-
-export function normalizeCompatibilityConfig({
-  cfg,
-}: {
-  cfg: OpenClawConfig;
-}): ChannelDoctorConfigMutation {
-  const rawEntry = asObjectRecord(
-    (cfg.channels as Record<string, unknown> | undefined)?.googlechat,
-  );
-  if (!rawEntry) {
-    return { config: cfg, changes: [] };
-  }
-
-  const changes: string[] = [];
-  let updated = rawEntry;
-  let changed = false;
-
-  const root = normalizeGoogleChatEntry({
-    entry: updated,
-    pathPrefix: "channels.googlechat",
-    changes,
-  });
-  updated = root.entry;
-  changed = root.changed;
-
-  const accounts = asObjectRecord(updated.accounts);
-  if (accounts) {
-    let accountsChanged = false;
-    const nextAccounts = { ...accounts };
-    for (const [accountId, accountValue] of Object.entries(accounts)) {
-      const account = asObjectRecord(accountValue);
-      if (!account) {
-        continue;
-      }
-      const normalized = normalizeGoogleChatEntry({
-        entry: account,
-        pathPrefix: `channels.googlechat.accounts.${accountId}`,
-        changes,
-      });
-      if (!normalized.changed) {
-        continue;
-      }
-      nextAccounts[accountId] = normalized.entry;
-      accountsChanged = true;
-    }
-    if (accountsChanged) {
-      updated = { ...updated, accounts: nextAccounts };
-      changed = true;
-    }
-  }
-
-  if (!changed) {
-    return { config: cfg, changes: [] };
-  }
-  return {
-    config: {
-      ...cfg,
-      channels: {
-        ...cfg.channels,
-        googlechat: updated as GoogleChatChannelsConfig["googlechat"],
-      },
-    },
-    changes,
-  };
-}

package/src/doctor.ts

@@ -1,57 +0,0 @@
-import { createDangerousNameMatchingMutableAllowlistWarningCollector } from "openclaw/plugin-sdk/channel-policy";
-
-function asObjectRecord(value: unknown): Record<string, unknown> | null {
-  return value && typeof value === "object" && !Array.isArray(value)
-    ? (value as Record<string, unknown>)
-    : null;
-}
-
-function isGoogleChatMutableAllowEntry(raw: string): boolean {
-  const text = raw.trim();
-  if (!text || text === "*") {
-    return false;
-  }
-
-  const withoutPrefix = text.replace(/^(googlechat|google-chat|gchat):/i, "").trim();
-  if (!withoutPrefix) {
-    return false;
-  }
-
-  const withoutUsers = withoutPrefix.replace(/^users\//i, "");
-  return withoutUsers.includes("@");
-}
-
-export const collectGoogleChatMutableAllowlistWarnings =
-  createDangerousNameMatchingMutableAllowlistWarningCollector({
-    channel: "googlechat",
-    detector: isGoogleChatMutableAllowEntry,
-    collectLists: (scope) => {
-      const lists = [
-        {
-          pathLabel: `${scope.prefix}.groupAllowFrom`,
-          list: scope.account.groupAllowFrom,
-        },
-      ];
-      const dm = asObjectRecord(scope.account.dm);
-      if (dm) {
-        lists.push({
-          pathLabel: `${scope.prefix}.dm.allowFrom`,
-          list: dm.allowFrom,
-        });
-      }
-      const groups = asObjectRecord(scope.account.groups);
-      if (groups) {
-        for (const [groupKey, groupRaw] of Object.entries(groups)) {
-          const group = asObjectRecord(groupRaw);
-          if (!group) {
-            continue;
-          }
-          lists.push({
-            pathLabel: `${scope.prefix}.groups.${groupKey}.users`,
-            list: group.users,
-          });
-        }
-      }
-      return lists;
-    },
-  });

package/src/gateway.ts

@@ -1,63 +0,0 @@
-import {
-  createAccountStatusSink,
-  runPassiveAccountLifecycle,
-} from "openclaw/plugin-sdk/channel-lifecycle";
-import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
-import { createLazyRuntimeNamedExport } from "openclaw/plugin-sdk/lazy-runtime";
-import type { ChannelAccountSnapshot } from "openclaw/plugin-sdk/status-helpers";
-import type { ResolvedGoogleChatAccount } from "./accounts.js";
-import type { GoogleChatRuntimeEnv } from "./monitor-types.js";
-
-const loadGoogleChatChannelRuntime = createLazyRuntimeNamedExport(
-  () => import("./channel.runtime.js"),
-  "googleChatChannelRuntime",
-);
-
-export async function startGoogleChatGatewayAccount(ctx: {
-  account: ResolvedGoogleChatAccount;
-  cfg: OpenClawConfig;
-  runtime: GoogleChatRuntimeEnv;
-  abortSignal: AbortSignal;
-  setStatus: (next: ChannelAccountSnapshot) => void;
-  log?: {
-    info?: (message: string) => void;
-  };
-}): Promise<void> {
-  const account = ctx.account;
-  const statusSink = createAccountStatusSink({
-    accountId: account.accountId,
-    setStatus: ctx.setStatus,
-  });
-  ctx.log?.info?.(`[${account.accountId}] starting Google Chat webhook`);
-  const { resolveGoogleChatWebhookPath, startGoogleChatMonitor } =
-    await loadGoogleChatChannelRuntime();
-  statusSink({
-    running: true,
-    lastStartAt: Date.now(),
-    webhookPath: resolveGoogleChatWebhookPath({ account }),
-    audienceType: account.config.audienceType,
-    audience: account.config.audience,
-  });
-  await runPassiveAccountLifecycle({
-    abortSignal: ctx.abortSignal,
-    start: async () =>
-      await startGoogleChatMonitor({
-        account,
-        config: ctx.cfg,
-        runtime: ctx.runtime,
-        abortSignal: ctx.abortSignal,
-        webhookPath: account.config.webhookPath,
-        webhookUrl: account.config.webhookUrl,
-        statusSink,
-      }),
-    stop: async (unregister) => {
-      unregister?.();
-    },
-    onStop: async () => {
-      statusSink({
-        running: false,
-        lastStopAt: Date.now(),
-      });
-    },
-  });
-}