@kodelyth/googlechat 2026.5.39 → 2026.5.42

package/dist/setup-surface-B3Fa7XRx.js

@@ -0,0 +1,321 @@
+import { safeParseJsonWithSchema, safeParseWithSchema } from "klaw/plugin-sdk/extension-shared";
+import { normalizeOptionalString, normalizeStringifiedOptionalString } from "klaw/plugin-sdk/string-coerce-runtime";
+import { DEFAULT_ACCOUNT_ID, createAccountListHelpers, normalizeAccountId, resolveAccountEntry, resolveMergedAccountConfig } from "klaw/plugin-sdk/account-resolution";
+import { mergePairLoopGuardConfig } from "klaw/plugin-sdk/pair-loop-guard-runtime";
+import { isSecretRef } from "klaw/plugin-sdk/secret-input";
+import { z } from "zod";
+import { createPatchedAccountSetupAdapter, createSetupInputPresenceValidator } from "klaw/plugin-sdk/setup-runtime";
+import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1, addWildcardAllowFrom, applySetupAccountConfigPatch, createPromptParsedAllowFromForAccount, createSetupTranslator, createStandardChannelSetupStatus, formatDocsLink, mergeAllowFromEntries, migrateBaseNameToDefaultAccount, splitSetupEntries } from "klaw/plugin-sdk/setup";
+//#region extensions/googlechat/src/accounts.ts
+const ENV_SERVICE_ACCOUNT$1 = "GOOGLE_CHAT_SERVICE_ACCOUNT";
+const ENV_SERVICE_ACCOUNT_FILE$1 = "GOOGLE_CHAT_SERVICE_ACCOUNT_FILE";
+const JsonRecordSchema = z.record(z.string(), z.unknown());
+const { listAccountIds: listGoogleChatAccountIds, resolveDefaultAccountId: resolveDefaultGoogleChatAccountId } = createAccountListHelpers("googlechat", { implicitDefaultAccount: {
+	channelKeys: [
+		"serviceAccount",
+		"serviceAccountRef",
+		"serviceAccountFile"
+	],
+	envVars: [ENV_SERVICE_ACCOUNT$1, ENV_SERVICE_ACCOUNT_FILE$1]
+} });
+function mergeGoogleChatAccountConfig(cfg, accountId) {
+	const raw = cfg.channels?.["googlechat"] ?? {};
+	const base = resolveMergedAccountConfig({
+		channelConfig: raw,
+		accounts: raw.accounts,
+		accountId,
+		omitKeys: ["defaultAccount"],
+		nestedObjectKeys: ["botLoopProtection"]
+	});
+	const defaultAccountConfig = resolveAccountEntry(raw.accounts, DEFAULT_ACCOUNT_ID) ?? {};
+	if (accountId === DEFAULT_ACCOUNT_ID) return base;
+	const { enabled: _ignoredEnabled, dangerouslyAllowNameMatching: _ignoredDangerouslyAllowNameMatching, serviceAccount: _ignoredServiceAccount, serviceAccountRef: _ignoredServiceAccountRef, serviceAccountFile: _ignoredServiceAccountFile, ...defaultAccountShared } = defaultAccountConfig;
+	const botLoopProtection = mergePairLoopGuardConfig(defaultAccountShared.botLoopProtection, base.botLoopProtection);
+	return {
+		...defaultAccountShared,
+		...base,
+		...botLoopProtection ? { botLoopProtection } : {}
+	};
+}
+function resolveGoogleChatConfigAccessorAccount(params) {
+	const accountId = normalizeAccountId(params.accountId ?? params.cfg.channels?.googlechat?.defaultAccount);
+	return { config: mergeGoogleChatAccountConfig(params.cfg, accountId) };
+}
+function parseServiceAccount(value) {
+	if (isSecretRef(value)) return null;
+	if (typeof value === "string") {
+		const trimmed = value.trim();
+		if (!trimmed) return null;
+		return safeParseJsonWithSchema(JsonRecordSchema, trimmed);
+	}
+	return safeParseWithSchema(JsonRecordSchema, value);
+}
+function resolveCredentialsFromConfig(params) {
+	const { account, accountId } = params;
+	const inline = parseServiceAccount(account.serviceAccount);
+	if (inline) return {
+		credentials: inline,
+		source: "inline"
+	};
+	if (isSecretRef(account.serviceAccount)) throw new Error(`channels.googlechat.accounts.${accountId}.serviceAccount: unresolved SecretRef "${account.serviceAccount.source}:${account.serviceAccount.provider}:${account.serviceAccount.id}". Resolve this command against an active gateway runtime snapshot before reading it.`);
+	if (isSecretRef(account.serviceAccountRef)) throw new Error(`channels.googlechat.accounts.${accountId}.serviceAccount: unresolved SecretRef "${account.serviceAccountRef.source}:${account.serviceAccountRef.provider}:${account.serviceAccountRef.id}". Resolve this command against an active gateway runtime snapshot before reading it.`);
+	const file = normalizeOptionalString(account.serviceAccountFile);
+	if (file) return {
+		credentialsFile: file,
+		source: "file"
+	};
+	if (accountId === DEFAULT_ACCOUNT_ID) {
+		const envJson = process.env[ENV_SERVICE_ACCOUNT$1];
+		const envInline = parseServiceAccount(envJson);
+		if (envInline) return {
+			credentials: envInline,
+			source: "env"
+		};
+		const envFile = normalizeOptionalString(process.env[ENV_SERVICE_ACCOUNT_FILE$1]);
+		if (envFile) return {
+			credentialsFile: envFile,
+			source: "env"
+		};
+	}
+	return { source: "none" };
+}
+function resolveGoogleChatAccount(params) {
+	const accountId = normalizeAccountId(params.accountId ?? params.cfg.channels?.["googlechat"]?.defaultAccount);
+	const baseEnabled = params.cfg.channels?.["googlechat"]?.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: normalizeOptionalString(merged.name),
+		enabled,
+		config: merged,
+		credentialSource: credentials.source,
+		credentials: credentials.credentials,
+		credentialsFile: credentials.credentialsFile
+	};
+}
+function listEnabledGoogleChatAccounts(cfg) {
+	return listGoogleChatAccountIds(cfg).map((accountId) => resolveGoogleChatAccount({
+		cfg,
+		accountId
+	})).filter((account) => account.enabled);
+}
+const googlechatSetupAdapter = createPatchedAccountSetupAdapter({
+	channelKey: "googlechat",
+	validateInput: createSetupInputPresenceValidator({
+		defaultAccountOnlyEnvError: "GOOGLE_CHAT_SERVICE_ACCOUNT env vars can only be used for the default account.",
+		whenNotUseEnv: [{
+			someOf: ["token", "tokenFile"],
+			message: "Google Chat requires --token (service account JSON) or --token-file."
+		}]
+	}),
+	buildPatch: (input) => {
+		const patch = input.useEnv ? {} : input.tokenFile ? { serviceAccountFile: input.tokenFile } : input.token ? { serviceAccount: input.token } : {};
+		const audienceType = input.audienceType?.trim();
+		const audience = input.audience?.trim();
+		const webhookPath = input.webhookPath?.trim();
+		const webhookUrl = input.webhookUrl?.trim();
+		return {
+			...patch,
+			...audienceType ? { audienceType } : {},
+			...audience ? { audience } : {},
+			...webhookPath ? { webhookPath } : {},
+			...webhookUrl ? { webhookUrl } : {}
+		};
+	}
+});
+//#endregion
+//#region extensions/googlechat/src/setup-surface.ts
+const t = createSetupTranslator();
+const channel = "googlechat";
+const ENV_SERVICE_ACCOUNT = "GOOGLE_CHAT_SERVICE_ACCOUNT";
+const ENV_SERVICE_ACCOUNT_FILE = "GOOGLE_CHAT_SERVICE_ACCOUNT_FILE";
+const USE_ENV_FLAG = "__googlechatUseEnv";
+const AUTH_METHOD_FLAG = "__googlechatAuthMethod";
+const googlechatDmPolicy = {
+	label: "Google Chat",
+	channel,
+	policyKey: "channels.googlechat.dm.policy",
+	allowFromKey: "channels.googlechat.dm.allowFrom",
+	resolveConfigKeys: (cfg, accountId) => (accountId ?? resolveDefaultGoogleChatAccountId(cfg)) !== DEFAULT_ACCOUNT_ID$1 ? {
+		policyKey: `channels.googlechat.accounts.${accountId ?? resolveDefaultGoogleChatAccountId(cfg)}.dm.policy`,
+		allowFromKey: `channels.googlechat.accounts.${accountId ?? resolveDefaultGoogleChatAccountId(cfg)}.dm.allowFrom`
+	} : {
+		policyKey: "channels.googlechat.dm.policy",
+		allowFromKey: "channels.googlechat.dm.allowFrom"
+	},
+	getCurrent: (cfg, accountId) => resolveGoogleChatAccount({
+		cfg,
+		accountId: accountId ?? resolveDefaultGoogleChatAccountId(cfg)
+	}).config.dm?.policy ?? "pairing",
+	setPolicy: (cfg, policy, accountId) => {
+		const resolvedAccountId = accountId ?? resolveDefaultGoogleChatAccountId(cfg);
+		const currentDm = resolveGoogleChatAccount({
+			cfg,
+			accountId: resolvedAccountId
+		}).config.dm;
+		return applySetupAccountConfigPatch({
+			cfg,
+			channelKey: channel,
+			accountId: resolvedAccountId,
+			patch: { dm: {
+				...currentDm,
+				policy,
+				...policy === "open" ? { allowFrom: addWildcardAllowFrom(currentDm?.allowFrom) } : {}
+			} }
+		});
+	},
+	promptAllowFrom: createPromptParsedAllowFromForAccount({
+		defaultAccountId: resolveDefaultGoogleChatAccountId,
+		message: t("wizard.googlechat.allowFromPrompt"),
+		placeholder: "users/123456789, name@example.com",
+		parseEntries: (raw) => ({ entries: mergeAllowFromEntries(void 0, splitSetupEntries(raw)) }),
+		getExistingAllowFrom: ({ cfg, accountId }) => resolveGoogleChatAccount({
+			cfg,
+			accountId
+		}).config.dm?.allowFrom ?? [],
+		applyAllowFrom: ({ cfg, accountId, allowFrom }) => applySetupAccountConfigPatch({
+			cfg,
+			channelKey: channel,
+			accountId,
+			patch: { dm: {
+				...resolveGoogleChatAccount({
+					cfg,
+					accountId
+				}).config.dm,
+				allowFrom
+			} }
+		})
+	})
+};
+function createServiceAccountTextInput(params) {
+	return {
+		inputKey: params.inputKey,
+		message: params.message,
+		placeholder: params.placeholder,
+		shouldPrompt: ({ credentialValues }) => credentialValues[USE_ENV_FLAG] !== "1" && credentialValues[AUTH_METHOD_FLAG] === params.authMethod,
+		validate: ({ value }) => normalizeStringifiedOptionalString(value) ? void 0 : "Required",
+		normalizeValue: ({ value }) => normalizeStringifiedOptionalString(value) ?? "",
+		applySet: async ({ cfg, accountId, value }) => applySetupAccountConfigPatch({
+			cfg,
+			channelKey: channel,
+			accountId,
+			patch: { [params.patchKey]: value }
+		})
+	};
+}
+const googlechatSetupWizard = {
+	channel,
+	status: createStandardChannelSetupStatus({
+		channelLabel: "Google Chat",
+		configuredLabel: t("wizard.channels.statusConfigured"),
+		unconfiguredLabel: t("wizard.channels.statusNeedsServiceAccount"),
+		configuredHint: t("wizard.channels.statusConfigured"),
+		unconfiguredHint: t("wizard.channels.statusNeedsAuth"),
+		includeStatusLine: true,
+		resolveConfigured: ({ cfg, accountId }) => resolveGoogleChatAccount({
+			cfg,
+			accountId
+		}).credentialSource !== "none"
+	}),
+	introNote: {
+		title: t("wizard.googlechat.setupTitle"),
+		lines: [
+			t("wizard.googlechat.setupServiceAccount"),
+			t("wizard.googlechat.setupScopes"),
+			t("wizard.googlechat.setupAudience"),
+			t("wizard.channels.docs", { link: formatDocsLink("/channels/googlechat", "googlechat") })
+		]
+	},
+	prepare: async ({ cfg, accountId, credentialValues, prompter }) => {
+		if (accountId === DEFAULT_ACCOUNT_ID$1 && (Boolean(process.env[ENV_SERVICE_ACCOUNT]) || Boolean(process.env[ENV_SERVICE_ACCOUNT_FILE]))) {
+			if (await prompter.confirm({
+				message: t("wizard.googlechat.useEnvPrompt"),
+				initialValue: true
+			})) return {
+				cfg: applySetupAccountConfigPatch({
+					cfg,
+					channelKey: channel,
+					accountId,
+					patch: {}
+				}),
+				credentialValues: {
+					...credentialValues,
+					[USE_ENV_FLAG]: "1"
+				}
+			};
+		}
+		const method = await prompter.select({
+			message: t("wizard.googlechat.authMethod"),
+			options: [{
+				value: "file",
+				label: t("wizard.googlechat.serviceAccountFile")
+			}, {
+				value: "inline",
+				label: t("wizard.googlechat.serviceAccountInline")
+			}],
+			initialValue: "file"
+		});
+		return { credentialValues: {
+			...credentialValues,
+			[USE_ENV_FLAG]: "0",
+			[AUTH_METHOD_FLAG]: method
+		} };
+	},
+	credentials: [],
+	textInputs: [createServiceAccountTextInput({
+		inputKey: "tokenFile",
+		message: t("wizard.googlechat.serviceAccountPath"),
+		placeholder: "/path/to/service-account.json",
+		authMethod: "file",
+		patchKey: "serviceAccountFile"
+	}), createServiceAccountTextInput({
+		inputKey: "token",
+		message: t("wizard.googlechat.serviceAccountJson"),
+		placeholder: "{\"type\":\"service_account\", ... }",
+		authMethod: "inline",
+		patchKey: "serviceAccount"
+	})],
+	finalize: async ({ cfg, accountId, prompter }) => {
+		const account = resolveGoogleChatAccount({
+			cfg,
+			accountId
+		});
+		const audienceType = await prompter.select({
+			message: t("wizard.googlechat.webhookAudienceType"),
+			options: [{
+				value: "app-url",
+				label: t("wizard.googlechat.appUrlRecommended")
+			}, {
+				value: "project-number",
+				label: t("wizard.googlechat.projectNumber")
+			}],
+			initialValue: account.config.audienceType === "project-number" ? "project-number" : "app-url"
+		});
+		return { cfg: migrateBaseNameToDefaultAccount({
+			cfg: applySetupAccountConfigPatch({
+				cfg,
+				channelKey: channel,
+				accountId,
+				patch: {
+					audienceType,
+					audience: normalizeOptionalString(await prompter.text({
+						message: audienceType === "project-number" ? t("wizard.googlechat.projectNumber") : t("wizard.googlechat.appUrl"),
+						placeholder: audienceType === "project-number" ? "1234567890" : "https://your.host/googlechat",
+						initialValue: account.config.audience || void 0,
+						validate: (value) => normalizeStringifiedOptionalString(value) ? void 0 : t("common.required")
+					})) ?? ""
+				}
+			}),
+			channelKey: channel
+		}) };
+	},
+	dmPolicy: googlechatDmPolicy
+};
+//#endregion
+export { resolveDefaultGoogleChatAccountId as a, listGoogleChatAccountIds as i, googlechatSetupAdapter as n, resolveGoogleChatAccount as o, listEnabledGoogleChatAccounts as r, resolveGoogleChatConfigAccessorAccount as s, googlechatSetupWizard as t };

package/dist/test-api.js

@@ -0,0 +1,3 @@
+import { F as setGoogleChatRuntime } from "./runtime-api-DUH2Cg-0.js";
+import { t as googlechatPlugin } from "./channel-DFZdjXD6.js";
+export { googlechatPlugin, setGoogleChatRuntime };

package/doctor-contract-api.ts

@@ -0,0 +1 @@
+export { normalizeCompatibilityConfig, legacyConfigRules } from "./src/doctor-contract.js";

package/index.ts

@@ -0,0 +1,20 @@
+import { defineBundledChannelEntry } from "klaw/plugin-sdk/channel-entry-contract";
+
+export default defineBundledChannelEntry({
+  id: "googlechat",
+  name: "Google Chat",
+  description: "Klaw Google Chat channel plugin",
+  importMetaUrl: import.meta.url,
+  plugin: {
+    specifier: "./channel-plugin-api.js",
+    exportName: "googlechatPlugin",
+  },
+  secrets: {
+    specifier: "./secret-contract-api.js",
+    exportName: "channelSecrets",
+  },
+  runtime: {
+    specifier: "./runtime-api.js",
+    exportName: "setGoogleChatRuntime",
+  },
+});