@kodelyth/googlechat 2026.5.39 → 2026.5.42

package/dist/contract-api.js

@@ -0,0 +1,3 @@
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-8SF6XoKj.js";
+import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries } from "./secret-contract-DWX4ikgT.js";
+export { collectRuntimeConfigAssignments, legacyConfigRules, normalizeCompatibilityConfig, secretTargetRegistryEntries };

package/dist/doctor-contract-8SF6XoKj.js

@@ -0,0 +1,151 @@
+import { asObjectRecord } from "klaw/plugin-sdk/runtime-doctor";
+//#region extensions/googlechat/src/doctor-contract.ts
+function hasLegacyGoogleChatStreamMode(value) {
+	return asObjectRecord(value)?.streamMode !== void 0;
+}
+function hasLegacyGoogleChatGroupAllowAlias(value) {
+	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, match) {
+	const accounts = asObjectRecord(value);
+	if (!accounts) return false;
+	return Object.values(accounts).some((account) => match(account));
+}
+function normalizeGoogleChatGroups(params) {
+	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 === void 0) {
+			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) {
+	let updated = params.entry;
+	let changed = false;
+	if (updated.streamMode !== void 0) {
+		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
+	};
+}
+const legacyConfigRules = [
+	{
+		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 \"klaw 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 \"klaw doctor --fix\".",
+		match: (value) => hasLegacyAccountAliases(value, hasLegacyGoogleChatGroupAllowAlias)
+	}
+];
+function normalizeCompatibilityConfig({ cfg }) {
+	const rawEntry = asObjectRecord(cfg.channels?.googlechat);
+	if (!rawEntry) return {
+		config: cfg,
+		changes: []
+	};
+	const changes = [];
+	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
+			}
+		},
+		changes
+	};
+}
+//#endregion
+export { normalizeCompatibilityConfig as n, legacyConfigRules as t };

package/dist/doctor-contract-api.js

@@ -0,0 +1,2 @@
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-8SF6XoKj.js";
+export { legacyConfigRules, normalizeCompatibilityConfig };

package/dist/index.js

@@ -0,0 +1,22 @@
+import { defineBundledChannelEntry } from "klaw/plugin-sdk/channel-entry-contract";
+//#region extensions/googlechat/index.ts
+var googlechat_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"
+	}
+});
+//#endregion
+export { googlechat_default as default };

package/dist/runtime-api-DUH2Cg-0.js

@@ -0,0 +1,29 @@
+import { extractToolSend as extractToolSend$1 } from "klaw/plugin-sdk/tool-send";
+import { fetchWithSsrFGuard as fetchWithSsrFGuard$1 } from "klaw/plugin-sdk/ssrf-runtime";
+import { DEFAULT_ACCOUNT_ID } from "klaw/plugin-sdk/account-id";
+import { createActionGate as createActionGate$1, jsonResult as jsonResult$1, readNumberParam as readNumberParam$1, readReactionParams as readReactionParams$1, readStringParam as readStringParam$1 } from "klaw/plugin-sdk/channel-actions";
+import { buildChannelConfigSchema } from "klaw/plugin-sdk/channel-config-primitives";
+import { missingTargetError } from "klaw/plugin-sdk/channel-feedback";
+import { createAccountStatusSink as createAccountStatusSink$1, runPassiveAccountLifecycle as runPassiveAccountLifecycle$1 } from "klaw/plugin-sdk/channel-lifecycle";
+import { createChannelPairingController } from "klaw/plugin-sdk/channel-pairing";
+import { createChannelMessageReplyPipeline } from "klaw/plugin-sdk/channel-message";
+import { PAIRING_APPROVED_MESSAGE } from "klaw/plugin-sdk/channel-status";
+import { chunkTextForOutbound } from "klaw/plugin-sdk/text-chunking";
+import { GoogleChatConfigSchema } from "klaw/plugin-sdk/bundled-channel-config-schema";
+import { GROUP_POLICY_BLOCKED_LABEL, resolveAllowlistProviderRuntimeGroupPolicy, resolveDefaultGroupPolicy, warnMissingProviderGroupPolicyFallbackOnce } from "klaw/plugin-sdk/runtime-group-policy";
+import { isDangerousNameMatchingEnabled } from "klaw/plugin-sdk/dangerous-name-runtime";
+import { readRemoteMediaBuffer, resolveChannelMediaMaxBytes } from "klaw/plugin-sdk/media-runtime";
+import { loadOutboundMediaFromUrl as loadOutboundMediaFromUrl$1 } from "klaw/plugin-sdk/outbound-media";
+import { resolveInboundMentionDecision } from "klaw/plugin-sdk/channel-inbound";
+import { resolveInboundRouteEnvelopeBuilderWithRuntime } from "klaw/plugin-sdk/inbound-envelope";
+import { resolveWebhookPath } from "klaw/plugin-sdk/webhook-ingress";
+import { registerWebhookTargetWithPluginRoute as registerWebhookTargetWithPluginRoute$1, resolveWebhookTargetWithAuthOrReject as resolveWebhookTargetWithAuthOrReject$1, withResolvedWebhookRequestPipeline as withResolvedWebhookRequestPipeline$1 } from "klaw/plugin-sdk/webhook-targets";
+import { createWebhookInFlightLimiter as createWebhookInFlightLimiter$1, readJsonWebhookBodyOrReject as readJsonWebhookBodyOrReject$1 } from "klaw/plugin-sdk/webhook-request-guards";
+import { createPluginRuntimeStore } from "klaw/plugin-sdk/runtime-store";
+//#region extensions/googlechat/src/runtime.ts
+const { setRuntime: setGoogleChatRuntime, getRuntime: getGoogleChatRuntime } = createPluginRuntimeStore({
+	pluginId: "googlechat",
+	errorMessage: "Google Chat runtime not initialized"
+});
+//#endregion
+export { resolveWebhookTargetWithAuthOrReject$1 as A, registerWebhookTargetWithPluginRoute$1 as C, resolveInboundMentionDecision as D, resolveDefaultGroupPolicy as E, setGoogleChatRuntime as F, warnMissingProviderGroupPolicyFallbackOnce as M, withResolvedWebhookRequestPipeline$1 as N, resolveInboundRouteEnvelopeBuilderWithRuntime as O, getGoogleChatRuntime as P, readStringParam$1 as S, resolveChannelMediaMaxBytes as T, missingTargetError as _, buildChannelConfigSchema as a, readReactionParams$1 as b, createActionGate$1 as c, createWebhookInFlightLimiter$1 as d, extractToolSend$1 as f, loadOutboundMediaFromUrl$1 as g, jsonResult$1 as h, PAIRING_APPROVED_MESSAGE as i, runPassiveAccountLifecycle$1 as j, resolveWebhookPath as k, createChannelMessageReplyPipeline as l, isDangerousNameMatchingEnabled as m, GROUP_POLICY_BLOCKED_LABEL as n, chunkTextForOutbound as o, fetchWithSsrFGuard$1 as p, GoogleChatConfigSchema as r, createAccountStatusSink$1 as s, DEFAULT_ACCOUNT_ID as t, createChannelPairingController as u, readJsonWebhookBodyOrReject$1 as v, resolveAllowlistProviderRuntimeGroupPolicy as w, readRemoteMediaBuffer as x, readNumberParam$1 as y };

package/dist/runtime-api.js

@@ -0,0 +1,2 @@
+import { A as resolveWebhookTargetWithAuthOrReject, C as registerWebhookTargetWithPluginRoute, D as resolveInboundMentionDecision, E as resolveDefaultGroupPolicy, F as setGoogleChatRuntime, M as warnMissingProviderGroupPolicyFallbackOnce, N as withResolvedWebhookRequestPipeline, O as resolveInboundRouteEnvelopeBuilderWithRuntime, S as readStringParam, T as resolveChannelMediaMaxBytes, _ as missingTargetError, a as buildChannelConfigSchema, b as readReactionParams, c as createActionGate, d as createWebhookInFlightLimiter, f as extractToolSend, g as loadOutboundMediaFromUrl, h as jsonResult, i as PAIRING_APPROVED_MESSAGE, j as runPassiveAccountLifecycle, k as resolveWebhookPath, l as createChannelMessageReplyPipeline, m as isDangerousNameMatchingEnabled, n as GROUP_POLICY_BLOCKED_LABEL, o as chunkTextForOutbound, p as fetchWithSsrFGuard, r as GoogleChatConfigSchema, s as createAccountStatusSink, t as DEFAULT_ACCOUNT_ID, u as createChannelPairingController, v as readJsonWebhookBodyOrReject, w as resolveAllowlistProviderRuntimeGroupPolicy, x as readRemoteMediaBuffer, y as readNumberParam } from "./runtime-api-DUH2Cg-0.js";
+export { DEFAULT_ACCOUNT_ID, GROUP_POLICY_BLOCKED_LABEL, GoogleChatConfigSchema, PAIRING_APPROVED_MESSAGE, buildChannelConfigSchema, chunkTextForOutbound, createAccountStatusSink, createActionGate, createChannelMessageReplyPipeline, createChannelPairingController, createWebhookInFlightLimiter, extractToolSend, fetchWithSsrFGuard, isDangerousNameMatchingEnabled, jsonResult, loadOutboundMediaFromUrl, missingTargetError, readJsonWebhookBodyOrReject, readNumberParam, readReactionParams, readRemoteMediaBuffer, readStringParam, registerWebhookTargetWithPluginRoute, resolveAllowlistProviderRuntimeGroupPolicy, resolveChannelMediaMaxBytes, resolveDefaultGroupPolicy, resolveInboundMentionDecision, resolveInboundRouteEnvelopeBuilderWithRuntime, resolveWebhookPath, resolveWebhookTargetWithAuthOrReject, runPassiveAccountLifecycle, setGoogleChatRuntime, warnMissingProviderGroupPolicyFallbackOnce, withResolvedWebhookRequestPipeline };

package/dist/secret-contract-DWX4ikgT.js

@@ -0,0 +1,99 @@
+import { getChannelSurface, hasOwnProperty, pushAssignment, pushInactiveSurfaceWarning, pushWarning, resolveChannelAccountSurface } from "klaw/plugin-sdk/channel-secret-basic-runtime";
+import { coerceSecretRef } from "klaw/plugin-sdk/secret-ref-runtime";
+//#region extensions/googlechat/src/secret-contract.ts
+const secretTargetRegistryEntries = [{
+	id: "channels.googlechat.accounts.*.serviceAccount",
+	targetType: "channels.googlechat.serviceAccount",
+	targetTypeAliases: ["channels.googlechat.accounts.*.serviceAccount"],
+	configFile: "klaw.json",
+	pathPattern: "channels.googlechat.accounts.*.serviceAccount",
+	refPathPattern: "channels.googlechat.accounts.*.serviceAccountRef",
+	secretShape: "sibling_ref",
+	expectedResolvedValue: "string-or-object",
+	includeInPlan: true,
+	includeInConfigure: true,
+	includeInAudit: true,
+	accountIdPathSegmentIndex: 3
+}, {
+	id: "channels.googlechat.serviceAccount",
+	targetType: "channels.googlechat.serviceAccount",
+	configFile: "klaw.json",
+	pathPattern: "channels.googlechat.serviceAccount",
+	refPathPattern: "channels.googlechat.serviceAccountRef",
+	secretShape: "sibling_ref",
+	expectedResolvedValue: "string-or-object",
+	includeInPlan: true,
+	includeInConfigure: true,
+	includeInAudit: true
+}];
+function resolveSecretInputRef(params) {
+	const explicitRef = coerceSecretRef(params.refValue, params.defaults);
+	const inlineRef = explicitRef ? null : coerceSecretRef(params.value, params.defaults);
+	return {
+		explicitRef,
+		inlineRef,
+		ref: explicitRef ?? inlineRef
+	};
+}
+function collectGoogleChatAccountAssignment(params) {
+	const { explicitRef, ref } = resolveSecretInputRef({
+		value: params.target.serviceAccount,
+		refValue: params.target.serviceAccountRef,
+		defaults: params.defaults
+	});
+	if (!ref) return;
+	if (params.active === false) {
+		pushInactiveSurfaceWarning({
+			context: params.context,
+			path: `${params.path}.serviceAccount`,
+			details: params.inactiveReason
+		});
+		return;
+	}
+	if (explicitRef && params.target.serviceAccount !== void 0 && !coerceSecretRef(params.target.serviceAccount, params.defaults)) pushWarning(params.context, {
+		code: "SECRETS_REF_OVERRIDES_PLAINTEXT",
+		path: params.path,
+		message: `${params.path}: serviceAccountRef is set; runtime will ignore plaintext serviceAccount.`
+	});
+	pushAssignment(params.context, {
+		ref,
+		path: `${params.path}.serviceAccount`,
+		expected: "string-or-object",
+		apply: (value) => {
+			params.target.serviceAccount = value;
+		}
+	});
+}
+function collectRuntimeConfigAssignments(params) {
+	const resolved = getChannelSurface(params.config, "googlechat");
+	if (!resolved) return;
+	const googleChat = resolved.channel;
+	const surface = resolveChannelAccountSurface(googleChat);
+	const topLevelServiceAccountActive = !surface.channelEnabled ? false : !surface.hasExplicitAccounts ? true : surface.accounts.some(({ account, enabled }) => enabled && !hasOwnProperty(account, "serviceAccount") && !hasOwnProperty(account, "serviceAccountRef"));
+	collectGoogleChatAccountAssignment({
+		target: googleChat,
+		path: "channels.googlechat",
+		defaults: params.defaults,
+		context: params.context,
+		active: topLevelServiceAccountActive,
+		inactiveReason: "no enabled account inherits this top-level Google Chat serviceAccount."
+	});
+	if (!surface.hasExplicitAccounts) return;
+	for (const { accountId, account, enabled } of surface.accounts) {
+		if (!hasOwnProperty(account, "serviceAccount") && !hasOwnProperty(account, "serviceAccountRef")) continue;
+		collectGoogleChatAccountAssignment({
+			target: account,
+			path: `channels.googlechat.accounts.${accountId}`,
+			defaults: params.defaults,
+			context: params.context,
+			active: enabled,
+			inactiveReason: "Google Chat account is disabled."
+		});
+	}
+}
+const channelSecrets = {
+	secretTargetRegistryEntries,
+	collectRuntimeConfigAssignments
+};
+//#endregion
+export { collectRuntimeConfigAssignments as n, secretTargetRegistryEntries as r, channelSecrets as t };

package/dist/secret-contract-api.js

@@ -0,0 +1,2 @@
+import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries, t as channelSecrets } from "./secret-contract-DWX4ikgT.js";
+export { channelSecrets, collectRuntimeConfigAssignments, secretTargetRegistryEntries };

package/dist/setup-entry.js

@@ -0,0 +1,15 @@
+import { defineBundledChannelSetupEntry } from "klaw/plugin-sdk/channel-entry-contract";
+//#region extensions/googlechat/setup-entry.ts
+var setup_entry_default = defineBundledChannelSetupEntry({
+	importMetaUrl: import.meta.url,
+	plugin: {
+		specifier: "./setup-plugin-api.js",
+		exportName: "googlechatSetupPlugin"
+	},
+	secrets: {
+		specifier: "./secret-contract-api.js",
+		exportName: "channelSecrets"
+	}
+});
+//#endregion
+export { setup_entry_default as default };

package/dist/setup-plugin-api.js

@@ -0,0 +1,75 @@
+import { a as resolveDefaultGoogleChatAccountId, i as listGoogleChatAccountIds, n as googlechatSetupAdapter, o as resolveGoogleChatAccount, s as resolveGoogleChatConfigAccessorAccount, t as googlechatSetupWizard } from "./setup-surface-B3Fa7XRx.js";
+import { describeAccountSnapshot } from "klaw/plugin-sdk/account-helpers";
+import { formatNormalizedAllowFromEntries } from "klaw/plugin-sdk/allow-from";
+import { adaptScopedAccountAccessor, createScopedChannelConfigAdapter } from "klaw/plugin-sdk/channel-config-helpers";
+import { normalizeLowercaseStringOrEmpty } from "klaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/googlechat/src/channel.setup.ts
+const formatGoogleChatAllowFromEntry = (entry) => normalizeLowercaseStringOrEmpty(entry.trim().replace(/^(googlechat|google-chat|gchat):/i, "").replace(/^user:/i, "").replace(/^users\//i, ""));
+const googlechatSetupPlugin = {
+	id: "googlechat",
+	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
+	},
+	setup: googlechatSetupAdapter,
+	setupWizard: googlechatSetupWizard,
+	capabilities: {
+		chatTypes: [
+			"direct",
+			"group",
+			"thread"
+		],
+		reactions: true,
+		threads: true,
+		media: true,
+		nativeCommands: false,
+		blockStreaming: true
+	},
+	streaming: { blockStreamingCoalesceDefaults: {
+		minChars: 1500,
+		idleMs: 1e3
+	} },
+	reload: { configPrefixes: ["channels.googlechat"] },
+	config: {
+		...createScopedChannelConfigAdapter({
+			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: formatGoogleChatAllowFromEntry
+			}),
+			resolveDefaultTo: (account) => account.config.defaultTo
+		}),
+		isConfigured: (account) => account.credentialSource !== "none",
+		describeAccount: (account) => describeAccountSnapshot({
+			account,
+			configured: account.credentialSource !== "none",
+			extra: { credentialSource: account.credentialSource }
+		})
+	}
+};
+//#endregion
+export { googlechatSetupPlugin };