clawmini 0.0.3 → 0.0.5

package/dist/adapter-google-chat/index.mjs

@@ -0,0 +1,1077 @@
+#!/usr/bin/env node
+import { c as getClawminiDir, d as getSocketPath, f as getWorkspaceRoot } from "../workspace-BJmJBfKi.mjs";
+import { t as createUnixSocketFetch } from "../fetch-Cn1XNyiO.mjs";
+import { a as createUnixSocketEventSource, i as shouldDisplayMessage, n as handleAdapterCommand, r as formatMessage, t as handleRoutingCommand } from "../routing-D8rTxtaV.mjs";
+import fs from "node:fs";
+import path from "node:path";
+import fs$1 from "node:fs/promises";
+import { z } from "zod";
+import { createTRPCClient, httpLink, httpSubscriptionLink, splitLink } from "@trpc/client";
+import http from "node:http";
+import crypto from "node:crypto";
+import { PubSub } from "@google-cloud/pubsub";
+import { google } from "googleapis";
+import mime from "mime-types";
+
+//#region src/adapter-google-chat/config.ts
+const GoogleChatConfigSchema = z.looseObject({
+	projectId: z.string().min(1, "GCP Project ID is required."),
+	subscriptionName: z.string().min(1, "Pub/Sub Subscription Name is required."),
+	topicName: z.string().min(1, "Pub/Sub Topic Name is required."),
+	authorizedUsers: z.array(z.string()).min(1, "At least one Authorized User is required."),
+	maxAttachmentSizeMB: z.number().default(25).optional(),
+	chatId: z.string().default("default").optional(),
+	directMessageName: z.string().optional(),
+	driveUploadEnabled: z.boolean().default(true).optional(),
+	requireMention: z.boolean().default(false),
+	oauthClientId: z.string().optional(),
+	oauthClientSecret: z.string().optional()
+});
+function getGoogleChatConfigPath(startDir = process.cwd()) {
+	return path.join(getClawminiDir(startDir), "adapters", "google-chat", "config.json");
+}
+async function readGoogleChatConfig(startDir = process.cwd()) {
+	const configPath = getGoogleChatConfigPath(startDir);
+	try {
+		const data = await fs$1.readFile(configPath, "utf-8");
+		const parsed = JSON.parse(data);
+		return GoogleChatConfigSchema.parse(parsed);
+	} catch (err) {
+		if (err.code === "ENOENT") return null;
+		throw err;
+	}
+}
+async function updateGoogleChatConfig(config, startDir = process.cwd()) {
+	const configPath = getGoogleChatConfigPath(startDir);
+	await fs$1.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
+}
+async function initGoogleChatConfig(startDir = process.cwd()) {
+	const configPath = getGoogleChatConfigPath(startDir);
+	const configDir = path.dirname(configPath);
+	await fs$1.mkdir(configDir, { recursive: true });
+	if (fs.existsSync(configPath)) {
+		console.log(`Config file already exists at ${configPath}`);
+		return;
+	}
+	await fs$1.writeFile(configPath, JSON.stringify({
+		projectId: "YOUR_PROJECT_ID",
+		topicName: "YOUR_TOPIC_NAME",
+		subscriptionName: "YOUR_SUBSCRIPTION_NAME",
+		authorizedUsers: ["user@example.com"],
+		chatId: "default",
+		requireMention: false,
+		oauthClientId: "YOUR_OAUTH_CLIENT_ID",
+		oauthClientSecret: "YOUR_OAUTH_CLIENT_SECRET"
+	}, null, 2), "utf-8");
+	console.log(`Created template configuration file at ${configPath}`);
+	console.log("Please update it with your actual GCP Project ID, Pub/Sub Topic Name, Pub/Sub Subscription Name, and Authorized Users.");
+}
+function isAuthorized(userIdOrEmail, authorizedUsers) {
+	return authorizedUsers.some((u) => u.toLowerCase() === userIdOrEmail.toLowerCase());
+}
+
+//#endregion
+//#region src/adapter-google-chat/state.ts
+const GoogleChatStateSchema = z.object({
+	lastSyncedMessageIds: z.record(z.string(), z.string()).optional(),
+	channelChatMap: z.record(z.string(), z.object({
+		chatId: z.string().nullable().optional(),
+		subscriptionId: z.string().optional(),
+		expirationDate: z.string().optional(),
+		requireMention: z.boolean().optional()
+	})).optional(),
+	oauthTokens: z.any().optional(),
+	filters: z.record(z.string(), z.boolean()).optional()
+});
+function getGoogleChatStatePath(startDir = process.cwd()) {
+	return path.join(getClawminiDir(startDir), "adapters", "google-chat", "state.json");
+}
+async function readGoogleChatState(startDir = process.cwd()) {
+	const statePath = getGoogleChatStatePath(startDir);
+	try {
+		const data = await fs$1.readFile(statePath, "utf-8");
+		const parsed = JSON.parse(data);
+		if (parsed.lastSyncedMessageId && !parsed.lastSyncedMessageIds) parsed.lastSyncedMessageIds = { default: parsed.lastSyncedMessageId };
+		if (parsed.driveOauthTokens && !parsed.oauthTokens) {
+			parsed.oauthTokens = parsed.driveOauthTokens;
+			delete parsed.driveOauthTokens;
+		}
+		if (parsed.channelChatMap) {
+			for (const [key, value] of Object.entries(parsed.channelChatMap)) if (typeof value === "string") parsed.channelChatMap[key] = { chatId: value };
+		}
+		return GoogleChatStateSchema.parse(parsed);
+	} catch (err) {
+		if (err.code === "ENOENT") return { oauthTokens: void 0 };
+		throw err;
+	}
+}
+let stateUpdatePromise = Promise.resolve();
+function updateGoogleChatState(updates, startDir = process.cwd()) {
+	return new Promise((resolve, reject) => {
+		stateUpdatePromise = stateUpdatePromise.then(async () => {
+			try {
+				const currentState = await readGoogleChatState(startDir);
+				const resolvedUpdates = typeof updates === "function" ? updates(currentState) : updates;
+				const newState = {
+					...currentState,
+					...resolvedUpdates
+				};
+				const statePath = getGoogleChatStatePath(startDir);
+				const dir = path.dirname(statePath);
+				await fs$1.mkdir(dir, { recursive: true });
+				await fs$1.writeFile(statePath, JSON.stringify(newState, null, 2), "utf-8");
+				resolve(newState);
+			} catch (err) {
+				console.error(`Failed to write Google Chat state:`, err);
+				reject(err);
+			}
+		});
+	});
+}
+
+//#endregion
+//#region src/adapter-google-chat/utils.ts
+let authClient$1 = null;
+function buildPolicyCard(logMessage) {
+	const policyId = "requestId" in logMessage && logMessage.requestId || logMessage.id;
+	return [{
+		cardId: logMessage.id,
+		card: {
+			header: {
+				title: "Action Required: Policy Approval",
+				subtitle: "A request needs your review."
+			},
+			sections: [{ widgets: [{ textParagraph: { text: logMessage.content || "Please review this request." } }, { buttonList: { buttons: [{
+				text: "Approve",
+				color: {
+					red: 0,
+					green: .5,
+					blue: 0,
+					alpha: 1
+				},
+				onClick: { action: {
+					function: "approve",
+					parameters: [{
+						key: "policyId",
+						value: policyId
+					}]
+				} }
+			}, {
+				text: "Reject",
+				color: {
+					red: .8,
+					green: 0,
+					blue: 0,
+					alpha: 1
+				},
+				onClick: { action: {
+					function: "reject",
+					parameters: [{
+						key: "policyId",
+						value: policyId
+					}]
+				} }
+			}] } }] }]
+		}
+	}];
+}
+function chunkString(str, size) {
+	const chunks = [];
+	const chars = Array.from(str);
+	for (let i = 0; i < chars.length; i += size) chunks.push(chars.slice(i, i + size).join(""));
+	return chunks;
+}
+/**
+* Downloads a file attachment securely using Application Default Credentials (ADC).
+* @param resourceName The resourceName of the attachment data to download.
+* @param maxAttachmentSizeMB The maximum allowed attachment size in MB (defaults to 25).
+* @returns A Buffer containing the file data.
+*/
+async function downloadAttachment(resourceName, maxAttachmentSizeMB = 25) {
+	if (!authClient$1) authClient$1 = await google.auth.getClient({ scopes: ["https://www.googleapis.com/auth/chat.bot"] });
+	const client = authClient$1;
+	const url = `https://chat.googleapis.com/v1/media/${resourceName}?alt=media`;
+	const response = await client.request({
+		url,
+		method: "GET",
+		responseType: "stream"
+	});
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		let totalBytes = 0;
+		const maxSizeBytes = maxAttachmentSizeMB * 1024 * 1024;
+		response.data.on("data", (chunk) => {
+			totalBytes += chunk.length;
+			if (totalBytes > maxSizeBytes) {
+				response.data.destroy();
+				reject(/* @__PURE__ */ new Error(`Attachment exceeds maximum size of ${maxSizeBytes} bytes: ${totalBytes} bytes`));
+			} else chunks.push(chunk);
+		});
+		response.data.on("end", () => {
+			resolve(Buffer.concat(chunks));
+		});
+		response.data.on("error", (err) => {
+			reject(err);
+		});
+	});
+}
+
+//#endregion
+//#region src/adapter-google-chat/auth.ts
+let authClient = null;
+async function getAuthClient() {
+	if (!authClient) authClient = await google.auth.getClient({ scopes: ["https://www.googleapis.com/auth/chat.bot"] });
+	return authClient;
+}
+let userAuthClient = null;
+let userAuthPromise = null;
+async function getUserAuthClient(config) {
+	if (userAuthClient) return userAuthClient;
+	if (userAuthPromise) return userAuthPromise;
+	if (!config.oauthClientId || !config.oauthClientSecret) {
+		console.error("DEBUG config:", config);
+		throw new Error("oauthClientId and oauthClientSecret are required in config.json for user authentication.");
+	}
+	userAuthPromise = (async () => {
+		const oauth2Client = new google.auth.OAuth2(config.oauthClientId, config.oauthClientSecret, "http://localhost:31338/oauth2callback");
+		oauth2Client.on("tokens", async (tokens) => {
+			try {
+				await updateGoogleChatState({ oauthTokens: {
+					...(await readGoogleChatState()).oauthTokens,
+					...tokens
+				} });
+			} catch (err) {
+				console.error("Failed to save refreshed Google User tokens", err);
+			}
+		});
+		const state = await readGoogleChatState();
+		if (state.oauthTokens) {
+			oauth2Client.setCredentials(state.oauthTokens);
+			userAuthClient = oauth2Client;
+			userAuthPromise = null;
+			return oauth2Client;
+		}
+		const authUrl = oauth2Client.generateAuthUrl({
+			access_type: "offline",
+			scope: ["https://www.googleapis.com/auth/drive.file", "https://www.googleapis.com/auth/chat.messages.readonly"],
+			prompt: "consent"
+		});
+		console.log("\n======================================================");
+		console.log("Google User Authorization Required!");
+		console.log("Please visit the following URL to authorize this bot:");
+		console.log(authUrl);
+		console.log("======================================================\n");
+		return new Promise((resolve, reject) => {
+			let timeoutId;
+			const server = http.createServer(async (req, res) => {
+				if (req.url?.startsWith("/oauth2callback")) {
+					const code = new URL(req.url, "http://localhost:31338").searchParams.get("code");
+					if (code) {
+						res.end("Authentication successful! You can close this window.");
+						clearTimeout(timeoutId);
+						server.close();
+						try {
+							const { tokens } = await oauth2Client.getToken(code);
+							oauth2Client.setCredentials(tokens);
+							await updateGoogleChatState({ oauthTokens: tokens });
+							console.log("Google User authorization successful!");
+							userAuthClient = oauth2Client;
+							userAuthPromise = null;
+							resolve(oauth2Client);
+						} catch (err) {
+							console.error("Failed to get token", err);
+							userAuthPromise = null;
+							reject(err);
+						}
+					} else {
+						res.end("Authentication failed!");
+						clearTimeout(timeoutId);
+						server.close();
+						userAuthPromise = null;
+						reject(/* @__PURE__ */ new Error("No code provided in OAuth callback"));
+					}
+				}
+			});
+			server.on("error", (err) => {
+				console.error("Failed to start local OAuth server on port 31338", err);
+				clearTimeout(timeoutId);
+				userAuthPromise = null;
+				reject(err);
+			});
+			server.listen(31338, "127.0.0.1", () => {
+				timeoutId = setTimeout(() => {
+					server.close();
+					userAuthPromise = null;
+					console.error("Google User authorization timed out after 5 minutes.");
+					reject(/* @__PURE__ */ new Error("Google User authorization timed out."));
+				}, 300 * 1e3);
+			});
+		});
+	})();
+	return userAuthPromise;
+}
+
+//#endregion
+//#region src/adapter-google-chat/subscriptions.ts
+async function handleAddedToSpace(spaceName, externalContextId, spaceType, targetChatId, mappedChatId, config) {
+	if (spaceType !== "DIRECT_MESSAGE") try {
+		const token = (await (await getUserAuthClient(config)).getAccessToken()).token;
+		if (token) {
+			const res = await fetch("https://workspaceevents.googleapis.com/v1/subscriptions", {
+				method: "POST",
+				headers: {
+					Authorization: `Bearer ${token}`,
+					"Content-Type": "application/json"
+				},
+				body: JSON.stringify({
+					targetResource: `//chat.googleapis.com/${spaceName}`,
+					eventTypes: ["google.workspace.chat.message.v1.created"],
+					payloadOptions: { includeResource: true },
+					notificationEndpoint: { pubsubTopic: `projects/${config.projectId}/topics/${config.topicName}` }
+				})
+			});
+			if (res.ok) {
+				const subData = await res.json();
+				await updateGoogleChatState((latestState) => {
+					const currentMap = latestState.channelChatMap || {};
+					return { channelChatMap: {
+						...currentMap,
+						[externalContextId]: {
+							...currentMap[externalContextId] || {},
+							subscriptionId: subData.name,
+							expirationDate: subData.expireTime
+						}
+					} };
+				});
+				console.log(`Created subscription ${subData.name} for space ${externalContextId}`);
+			} else {
+				const errText = await res.text();
+				console.error(`Failed to create subscription for space ${externalContextId}:`, errText);
+			}
+		}
+	} catch (err) {
+		console.error("Error setting up subscription on ADDED_TO_SPACE:", err);
+	}
+	if (targetChatId && mappedChatId) try {
+		const authClient = await getAuthClient();
+		await google.chat({
+			version: "v1",
+			auth: authClient
+		}).spaces.messages.create({
+			parent: externalContextId,
+			requestBody: { text: `Hello! I am currently mapped to chat \`${targetChatId}\`.` }
+		});
+	} catch (err) {
+		console.error("Failed to send greeting on ADDED_TO_SPACE:", err);
+	}
+}
+async function handleRemovedFromSpace(externalContextId, currentState, config) {
+	const subId = currentState.channelChatMap?.[externalContextId]?.subscriptionId;
+	if (subId) try {
+		const token = (await (await getUserAuthClient(config)).getAccessToken()).token;
+		if (token) {
+			const res = await fetch(`https://workspaceevents.googleapis.com/v1/${subId}`, {
+				method: "DELETE",
+				headers: { Authorization: `Bearer ${token}` }
+			});
+			if (res.ok) console.log(`Deleted subscription ${subId}`);
+			else {
+				const errText = await res.text();
+				console.error(`Failed to delete subscription ${subId}:`, errText);
+			}
+		}
+	} catch (err) {
+		console.error("Error tearing down subscription on REMOVED_FROM_SPACE:", err);
+	}
+	await updateGoogleChatState((latestState) => {
+		const map = { ...latestState.channelChatMap || {} };
+		const entry = map[externalContextId];
+		if (entry) if (!entry.chatId) delete map[externalContextId];
+		else {
+			delete entry.subscriptionId;
+			delete entry.expirationDate;
+		}
+		return { channelChatMap: map };
+	});
+}
+
+//#endregion
+//#region src/adapter-google-chat/cards.ts
+async function handleCardClicked(event, targetChatId, trpc) {
+	const action = event.action;
+	if (!action) return;
+	const methodName = action.actionMethodName;
+	const policyId = (action.parameters || []).find((p) => p.key === "policyId")?.value;
+	if (policyId && (methodName === "approve" || methodName === "reject")) {
+		const cmd = methodName === "approve" ? `/approve ${policyId}` : `/reject ${policyId}`;
+		if (event.message?.name) try {
+			const chatApi = google.chat({
+				version: "v1",
+				auth: await getAuthClient()
+			});
+			const updatedCards = (event.message.cardsV2 || []).map((c) => {
+				if (c.card?.sections) c.card.sections = c.card.sections.map((s) => {
+					if (s.widgets) s.widgets = s.widgets.filter((w) => !w.buttonList);
+					return s;
+				});
+				if (c.card?.header) {
+					const statusText = methodName === "approve" ? "Approved" : "Rejected";
+					c.card.header.subtitle = `Policy ${statusText}`;
+				}
+				return c;
+			});
+			await chatApi.spaces.messages.update({
+				name: event.message.name,
+				updateMask: "cardsV2",
+				requestBody: { cardsV2: updatedCards }
+			});
+		} catch (updateErr) {
+			console.error(`Failed to update card for policy ${policyId}:`, updateErr);
+		}
+		await trpc.sendMessage.mutate({
+			type: "send-message",
+			client: "cli",
+			data: {
+				message: cmd,
+				chatId: targetChatId,
+				adapter: "google-chat",
+				noWait: true
+			}
+		});
+		console.log(`Forwarded ${methodName} for policy ${policyId} to daemon.`);
+	}
+}
+
+//#endregion
+//#region src/adapter-google-chat/client.ts
+function getTRPCClient(options = {}) {
+	const socketPath = options.socketPath ?? getSocketPath();
+	if (!fs.existsSync(socketPath)) throw new Error(`Daemon not running. Socket not found at ${socketPath}`);
+	const customFetch = createUnixSocketFetch(socketPath);
+	return createTRPCClient({ links: [splitLink({
+		condition(op) {
+			return op.type === "subscription";
+		},
+		true: httpSubscriptionLink({
+			url: "http://localhost",
+			EventSource: createUnixSocketEventSource(socketPath)
+		}),
+		false: httpLink({
+			url: "http://localhost",
+			fetch: customFetch
+		})
+	})] });
+}
+function startGoogleChatIngestion(config, trpc, filteringConfig) {
+	const subscription = new PubSub({ projectId: config.projectId }).subscription(config.subscriptionName);
+	const seenMessageIds = /* @__PURE__ */ new Map();
+	setInterval(() => {
+		const now = Date.now();
+		for (const [id, ts] of seenMessageIds.entries()) if (now - ts > 600 * 1e3) seenMessageIds.delete(id);
+	}, 300 * 1e3).unref();
+	subscription.on("message", async (message) => {
+		const downloadedFiles = [];
+		try {
+			const dataString = message.data.toString("utf8");
+			const parsedData = JSON.parse(dataString);
+			const isWorkspaceEvent = message.attributes && message.attributes["ce-type"] === "google.workspace.chat.message.v1.created";
+			const eventType = isWorkspaceEvent ? "MESSAGE" : parsedData.type;
+			const eventMessage = isWorkspaceEvent ? parsedData.message || parsedData : parsedData.message;
+			const email = (isWorkspaceEvent ? eventMessage?.sender?.email : parsedData.user?.email || eventMessage?.sender?.email) || "";
+			const senderName = eventMessage?.sender?.name || parsedData.user?.name || "";
+			const space = isWorkspaceEvent ? eventMessage?.space : parsedData.space || eventMessage?.space;
+			const senderType = eventMessage?.sender?.type || "";
+			const messageId = eventMessage?.name || "";
+			const text = (eventMessage?.argumentText || eventMessage?.text || "").trim();
+			if (senderType === "BOT") return void message.ack();
+			if (messageId) {
+				if (seenMessageIds.has(messageId)) return void message.ack();
+				seenMessageIds.set(messageId, Date.now());
+			}
+			if (eventType !== "MESSAGE" && eventType !== "CARD_CLICKED" && eventType !== "ADDED_TO_SPACE" && eventType !== "REMOVED_FROM_SPACE") {
+				message.ack();
+				return;
+			}
+			let isUserAuthorized = false;
+			let authorizedByEmail = false;
+			if (email && isAuthorized(email, config.authorizedUsers)) {
+				isUserAuthorized = true;
+				authorizedByEmail = true;
+			} else if (senderName && isAuthorized(senderName, config.authorizedUsers)) isUserAuthorized = true;
+			if (!isUserAuthorized) {
+				console.log(`Unauthorized or missing identifier: email=${email}, name=${senderName}`);
+				console.log("DEBUG missing identifier parsedData:", JSON.stringify(parsedData, null, 2));
+				message.ack();
+				return;
+			}
+			if (authorizedByEmail && senderName && !isAuthorized(senderName, config.authorizedUsers)) {
+				console.log(`Automatically authorizing user ID ${senderName} based on authorized email ${email}`);
+				config.authorizedUsers.push(senderName);
+				updateGoogleChatConfig(config).catch((err) => console.error("Failed to update config with new user ID:", err));
+			}
+			const identifier = email || senderName;
+			const spaceName = space?.name;
+			if (!spaceName) {
+				console.log("Ignoring message: Could not determine space name.");
+				message.ack();
+				return;
+			}
+			const currentState = await readGoogleChatState();
+			const externalContextId = spaceName;
+			const mappedChatId = currentState.channelChatMap?.[externalContextId]?.chatId;
+			const isRoutingCommand = text.startsWith("/chat") || text.startsWith("/agent");
+			if (eventType === "ADDED_TO_SPACE") {
+				await handleAddedToSpace(spaceName, externalContextId, space?.type, mappedChatId, mappedChatId, config);
+				if (!text) {
+					message.ack();
+					return;
+				}
+			}
+			if (eventType === "REMOVED_FROM_SPACE") {
+				await handleRemovedFromSpace(externalContextId, currentState, config);
+				message.ack();
+				return;
+			}
+			if (isRoutingCommand) {
+				const routingResult = await handleRoutingCommand(text, externalContextId, Object.fromEntries(Object.entries(currentState.channelChatMap || {}).map(([k, v]) => [k, v.chatId || ""])), "google-chat", trpc);
+				if (routingResult) {
+					if (routingResult.type === "mapped") await updateGoogleChatState((latestState) => ({ channelChatMap: {
+						...latestState.channelChatMap || {},
+						[externalContextId]: {
+							...latestState.channelChatMap?.[externalContextId] || {},
+							chatId: routingResult.newChatId
+						}
+					} }));
+					try {
+						const authClient = await getAuthClient();
+						await google.chat({
+							version: "v1",
+							auth: authClient
+						}).spaces.messages.create({
+							parent: externalContextId,
+							requestBody: { text: routingResult.text }
+						});
+					} catch (err) {
+						console.error("Failed to send routing command reply:", err);
+					}
+					message.ack();
+					return;
+				}
+			}
+			let targetChatId = mappedChatId;
+			if (!targetChatId && !isRoutingCommand) if (!currentState.channelChatMap || Object.values(currentState.channelChatMap).every((entry) => !entry.chatId)) {
+				targetChatId = config.chatId || "default";
+				console.log(`First contact detected. Automatically mapping space ${externalContextId} to chat ${targetChatId}.`);
+				await updateGoogleChatState((latestState) => ({ channelChatMap: {
+					...latestState.channelChatMap || {},
+					[externalContextId]: {
+						...latestState.channelChatMap?.[externalContextId] || {},
+						chatId: targetChatId
+					}
+				} }));
+			} else {
+				const isDirectMessage = space?.type === "DIRECT_MESSAGE" || space?.singleUserBotDm === true;
+				const isMentioned = Array.isArray(eventMessage?.annotations) && eventMessage.annotations.some((a) => a.type === "USER_MENTION");
+				const isSlashCommand = text.startsWith("/");
+				if (isDirectMessage || isMentioned || isSlashCommand) {
+					console.log(`Unmapped space ${externalContextId}, sending first contact warning.`);
+					try {
+						const authClient = await getAuthClient();
+						await google.chat({
+							version: "v1",
+							auth: authClient
+						}).spaces.messages.create({
+							parent: externalContextId,
+							requestBody: { text: "This channel/space is not currently mapped to a daemon chat. Please use `/chat [chat-id]` or `/agent [agent-id]` to map it." }
+						});
+					} catch (err) {
+						console.error("Failed to send first contact warning:", err);
+					}
+				} else console.log(`Unmapped space ${externalContextId}, silently ignoring background message.`);
+				message.ack();
+				return;
+			}
+			if (!targetChatId) targetChatId = config.chatId || "default";
+			if (!(space?.type === "DIRECT_MESSAGE" || space?.singleUserBotDm === true) && eventType === "MESSAGE") {
+				const channelConfig = currentState.channelChatMap?.[externalContextId];
+				if ((channelConfig?.requireMention !== void 0 ? channelConfig.requireMention : config.requireMention) && !isRoutingCommand) {
+					const isMentioned = Array.isArray(eventMessage?.annotations) && eventMessage.annotations.some((a) => a.type === "USER_MENTION" && a.userMention?.user?.type === "BOT");
+					let isReplyToBot = false;
+					if (eventMessage?.threadReply && eventMessage.thread?.name) try {
+						const authClient = await getAuthClient();
+						isReplyToBot = (await google.chat({
+							version: "v1",
+							auth: authClient
+						}).spaces.messages.list({
+							parent: externalContextId,
+							filter: `thread.name="${eventMessage.thread.name}"`
+						})).data.messages?.some((m) => m.sender?.type === "BOT" || m.annotations?.some((a) => a.type === "USER_MENTION" && a.userMention?.user?.type === "BOT")) ?? false;
+					} catch (err) {
+						console.error("Failed to fetch thread messages for mention check:", err);
+					}
+					if (!isMentioned && !isReplyToBot) {
+						message.ack();
+						return;
+					}
+				}
+			}
+			if (eventType === "CARD_CLICKED") {
+				await handleCardClicked(parsedData, targetChatId, trpc);
+				message.ack();
+				return;
+			}
+			const commandResult = await handleAdapterCommand(text, filteringConfig, trpc, targetChatId);
+			if (commandResult) {
+				let resultText = "";
+				if (commandResult.type === "text") {
+					if (commandResult.newConfig) {
+						filteringConfig.filters = commandResult.newConfig.filters;
+						await updateGoogleChatState({ filters: filteringConfig.filters });
+					}
+					resultText = commandResult.text;
+				} else if (commandResult.type === "debug") resultText = commandResult.messages.length === 0 ? "No ignored background messages found." : `**Debug Output (${commandResult.messages.length} ignored messages):**\n\n` + commandResult.messages.map((msg) => formatMessage(msg)).join("\n\n---\n\n");
+				const authClient = await getAuthClient();
+				await google.chat({
+					version: "v1",
+					auth: authClient
+				}).spaces.messages.create({
+					parent: spaceName,
+					requestBody: { text: resultText }
+				});
+				message.ack();
+				return;
+			}
+			const attachments = eventMessage?.attachment || [];
+			if (attachments.length > 0) {
+				const tmpDir = path.join(getClawminiDir(process.cwd()), "tmp", "google-chat");
+				await fs$1.mkdir(tmpDir, { recursive: true });
+				for (const att of attachments) {
+					const resourceName = att.attachmentDataRef?.resourceName;
+					if (resourceName) try {
+						const buffer = await downloadAttachment(resourceName, config.maxAttachmentSizeMB);
+						const uniqueName = `${crypto.randomUUID()}-${att.contentName || "attachment"}`;
+						const filePath = path.join(tmpDir, uniqueName);
+						await fs$1.writeFile(filePath, buffer);
+						downloadedFiles.push(filePath);
+					} catch (err) {
+						console.error(`Error downloading attachment:`, err);
+					}
+				}
+			}
+			await trpc.sendMessage.mutate({
+				type: "send-message",
+				client: "cli",
+				data: {
+					message: text,
+					chatId: targetChatId,
+					files: downloadedFiles.length > 0 ? downloadedFiles : void 0,
+					adapter: "google-chat",
+					noWait: true
+				}
+			});
+			console.log(`Forwarded message from ${identifier} to daemon.`);
+			message.ack();
+		} catch (error) {
+			console.error("Error processing Pub/Sub message:", error);
+			for (const file of downloadedFiles) try {
+				await fs$1.unlink(file);
+			} catch (unlinkErr) {
+				console.error(`Failed to delete downloaded file ${file} after error:`, unlinkErr);
+			}
+			await new Promise((resolve) => setTimeout(resolve, 2e3));
+			message.nack();
+		}
+	});
+	subscription.on("error", (error) => {
+		console.error("Pub/Sub subscription error:", error);
+	});
+	return subscription;
+}
+
+//#endregion
+//#region src/adapter-google-chat/upload.ts
+async function uploadFilesToDrive(files, config) {
+	const driveClient = await getUserAuthClient(config);
+	const driveApi = google.drive({
+		version: "v3",
+		auth: driveClient
+	});
+	const workspaceRoot = getWorkspaceRoot(process.cwd());
+	let folderId;
+	try {
+		const queryRes = await driveApi.files.list({
+			q: "mimeType='application/vnd.google-apps.folder' and name='Clawmini Uploads' and trashed=false",
+			fields: "files(id)"
+		});
+		if (queryRes.data.files && queryRes.data.files.length > 0) folderId = queryRes.data.files[0].id;
+		else {
+			const folderRes = await driveApi.files.create({
+				requestBody: {
+					name: "Clawmini Uploads",
+					mimeType: "application/vnd.google-apps.folder"
+				},
+				fields: "id"
+			});
+			if (folderRes.data.id) folderId = folderRes.data.id;
+		}
+	} catch (err) {
+		console.error("Failed to create or find Clawmini Uploads folder", err);
+	}
+	const uploadPromises = files.map(async (fileRelPath) => {
+		const filePath = path.resolve(workspaceRoot, fileRelPath);
+		if (!fs.existsSync(filePath)) return null;
+		const fileName = path.basename(filePath);
+		const mimeType = mime.lookup(filePath) || "application/octet-stream";
+		try {
+			const driveRes = await driveApi.files.create({
+				requestBody: {
+					name: fileName,
+					...folderId ? { parents: [folderId] } : {}
+				},
+				media: {
+					mimeType,
+					body: fs.createReadStream(filePath)
+				},
+				fields: "id, webViewLink"
+			});
+			if (driveRes.data.id && driveRes.data.webViewLink) {
+				const fileId = driveRes.data.id;
+				try {
+					await Promise.all(config.authorizedUsers.map((email) => driveApi.permissions.create({
+						fileId,
+						requestBody: {
+							type: "user",
+							role: "reader",
+							emailAddress: email
+						},
+						sendNotificationEmail: false
+					})));
+				} catch (err) {
+					console.error(`Failed to grant permissions for ${fileName}`, err);
+				}
+				return driveRes.data.webViewLink;
+			}
+			return null;
+		} catch (err) {
+			console.error(`Failed to upload file ${fileName} to Google Drive`, err);
+			return `*(Failed to upload to Drive: ${fileName})*`;
+		}
+	});
+	return (await Promise.all(uploadPromises)).filter((r) => r !== null);
+}
+
+//#endregion
+//#region src/adapter-google-chat/forwarder.ts
+async function startDaemonToGoogleChatForwarder(trpc, config, filteringConfig, signal) {
+	const defaultChatId = config.chatId || "default";
+	const activeSubscriptions = /* @__PURE__ */ new Map();
+	let currentLastSyncedMessageIds = (await readGoogleChatState()).lastSyncedMessageIds || {};
+	const saveLastMessageId = async (chatId, id) => {
+		currentLastSyncedMessageIds = {
+			...currentLastSyncedMessageIds,
+			[chatId]: id
+		};
+		return updateGoogleChatState((state) => ({ lastSyncedMessageIds: {
+			...state.lastSyncedMessageIds,
+			...currentLastSyncedMessageIds
+		} }));
+	};
+	const startSubscriptionForChat = async (chatId) => {
+		if (activeSubscriptions.has(chatId)) return;
+		if (signal?.aborted) return;
+		let lastMessageId = currentLastSyncedMessageIds[chatId];
+		if (!lastMessageId) try {
+			const messages = await trpc.getMessages.query({
+				chatId,
+				limit: 1
+			});
+			if (Array.isArray(messages) && messages.length > 0) {
+				const lastMsg = messages[messages.length - 1];
+				if (lastMsg) {
+					await saveLastMessageId(chatId, lastMsg.id);
+					lastMessageId = lastMsg.id;
+				}
+			}
+		} catch (error) {
+			if (signal?.aborted) return;
+			console.error(`Failed to fetch initial messages from daemon for ${chatId}:`, error);
+		}
+		console.log(`Starting daemon-to-google-chat forwarder for chat ${chatId}, lastMessageId: ${lastMessageId}`);
+		let retryDelay = 1e3;
+		const maxRetryDelay = 3e4;
+		let subscription = null;
+		let messageQueue = Promise.resolve();
+		const connect = () => {
+			if (signal?.aborted || !activeSubscriptions.has(chatId)) return;
+			subscription = trpc.waitForMessages.subscribe({
+				chatId,
+				lastMessageId
+			}, {
+				onData: (messages) => {
+					retryDelay = 1e3;
+					if (!Array.isArray(messages) || messages.length === 0) return;
+					messageQueue = messageQueue.then(async () => {
+						for (const rawMessage of messages) {
+							if (signal?.aborted || !activeSubscriptions.has(chatId)) break;
+							const message = rawMessage;
+							if (shouldDisplayMessage(message, filteringConfig)) {
+								const logMessage = message;
+								const currentState = await readGoogleChatState();
+								let activeSpaceName;
+								if (!activeSpaceName && currentState.channelChatMap) {
+									const entry = Object.entries(currentState.channelChatMap).find(([_, mapChatId]) => mapChatId?.chatId === chatId);
+									if (entry) activeSpaceName = entry[0];
+								}
+								if (logMessage.role === "policy" && logMessage.status === "pending") {
+									if (!activeSpaceName) {
+										console.warn("No active Google Chat space to reply to. Ignoring policy request:", logMessage.content);
+										await saveLastMessageId(chatId, logMessage.id).catch(console.error);
+										lastMessageId = logMessage.id;
+										continue;
+									}
+									try {
+										const client = await getAuthClient();
+										const chatApi = google.chat({
+											version: "v1",
+											auth: client
+										});
+										try {
+											await chatApi.spaces.messages.create({
+												parent: activeSpaceName,
+												requestBody: {
+													text: "",
+													cardsV2: buildPolicyCard(logMessage)
+												}
+											});
+										} catch (richError) {
+											console.warn("Failed to send rich policy request to Google Chat, falling back to plain text:", richError);
+											const policyId = "requestId" in logMessage && logMessage.requestId || logMessage.id;
+											await chatApi.spaces.messages.create({
+												parent: activeSpaceName,
+												requestBody: { text: `Action Required: Policy Request\n\n${logMessage.content || "A pending policy request requires your attention."}\n\nApprove: \`/approve ${policyId}\`\nReject: \`/reject ${policyId} <optional_rationale>\`` }
+											});
+										}
+									} catch (error) {
+										console.error("Failed to send policy request to Google Chat:", error);
+									}
+									await saveLastMessageId(chatId, logMessage.id).catch(console.error);
+									lastMessageId = logMessage.id;
+									continue;
+								}
+								const hasContent = !!logMessage.content?.trim();
+								const files = "files" in logMessage ? logMessage.files : void 0;
+								const hasFiles = Array.isArray(files) && files.length > 0;
+								if ("level" in logMessage && logMessage.level === "verbose" || !hasContent && !hasFiles) {
+									await saveLastMessageId(chatId, logMessage.id).catch(console.error);
+									lastMessageId = logMessage.id;
+									continue;
+								}
+								if (!activeSpaceName) {
+									console.warn("No active Google Chat space to reply to. Ignoring message:", logMessage.content);
+									await saveLastMessageId(chatId, logMessage.id).catch(console.error);
+									lastMessageId = logMessage.id;
+									continue;
+								}
+								try {
+									const client = await getAuthClient();
+									const chatApi = google.chat({
+										version: "v1",
+										auth: client
+									});
+									let text = formatMessage(logMessage) || "";
+									if (hasFiles && files) {
+										const fileNames = files.map((f) => path.basename(f)).join(", ");
+										if (config.driveUploadEnabled !== false && config.oauthClientId && config.oauthClientSecret) {
+											text += `\n\n`;
+											try {
+												const uploadResults = await uploadFilesToDrive(files, config);
+												for (const result of uploadResults) text += `${result}\n`;
+											} catch (driveAuthErr) {
+												console.error("Drive API/Auth Failed, degrading to local files output:", driveAuthErr);
+												text += `*(Files generated: ${fileNames})*`;
+											}
+										} else text += `\n\n*(Files generated: ${fileNames})*`;
+									}
+									if (text.length > 4e3) {
+										const chunks = chunkString(text, 4e3);
+										for (let i = 0; i < chunks.length; i++) {
+											if (signal?.aborted || !activeSubscriptions.has(chatId)) break;
+											await chatApi.spaces.messages.create({
+												parent: activeSpaceName,
+												requestBody: { text: chunks[i] }
+											});
+										}
+									} else await chatApi.spaces.messages.create({
+										parent: activeSpaceName,
+										requestBody: { text }
+									});
+								} catch (error) {
+									console.error("Failed to send message to Google Chat:", error);
+								}
+							}
+							await saveLastMessageId(chatId, message.id).catch(console.error);
+							lastMessageId = message.id;
+						}
+					}).catch((error) => {
+						console.error("Message queue failed, forcing reconnect...", error);
+						subscription?.unsubscribe();
+						subscription = null;
+						if (signal?.aborted || !activeSubscriptions.has(chatId)) return;
+						setTimeout(() => {
+							retryDelay = Math.min(retryDelay * 2, maxRetryDelay);
+							connect();
+						}, retryDelay);
+					});
+				},
+				onError: (error) => {
+					console.error(`Error in daemon-to-google-chat forwarder subscription for ${chatId}. Retrying in ${retryDelay}ms.`, error);
+					subscription?.unsubscribe();
+					subscription = null;
+					if (signal?.aborted || !activeSubscriptions.has(chatId)) return;
+					setTimeout(() => {
+						retryDelay = Math.min(retryDelay * 2, maxRetryDelay);
+						connect();
+					}, retryDelay);
+				},
+				onComplete: () => {
+					subscription = null;
+					if (!signal?.aborted && activeSubscriptions.has(chatId)) setTimeout(() => connect(), retryDelay);
+				}
+			});
+		};
+		activeSubscriptions.set(chatId, { unsubscribe: () => subscription?.unsubscribe() });
+		connect();
+	};
+	const syncSubscriptions = async () => {
+		if (signal?.aborted) return;
+		const state = await readGoogleChatState();
+		if (state.lastSyncedMessageIds) currentLastSyncedMessageIds = {
+			...state.lastSyncedMessageIds,
+			...currentLastSyncedMessageIds
+		};
+		const targetChatIds = /* @__PURE__ */ new Set();
+		targetChatIds.add(defaultChatId);
+		if (state.channelChatMap) {
+			for (const mappedEntry of Object.values(state.channelChatMap)) if (mappedEntry.chatId) targetChatIds.add(mappedEntry.chatId);
+		}
+		for (const targetChatId of targetChatIds) if (!activeSubscriptions.has(targetChatId)) startSubscriptionForChat(targetChatId);
+		for (const [activeChatId, sub] of activeSubscriptions.entries()) if (!targetChatIds.has(activeChatId)) {
+			sub.unsubscribe();
+			activeSubscriptions.delete(activeChatId);
+		}
+	};
+	return new Promise((resolve) => {
+		syncSubscriptions().catch(console.error);
+		const statePath = getGoogleChatStatePath();
+		const stateDir = path.dirname(statePath);
+		if (!fs.existsSync(stateDir)) fs.mkdirSync(stateDir, { recursive: true });
+		let debounceTimer = null;
+		const watcher = fs.watch(stateDir, (eventType, filename) => {
+			if (filename === path.basename(statePath)) {
+				if (debounceTimer) clearTimeout(debounceTimer);
+				debounceTimer = setTimeout(() => {
+					syncSubscriptions().catch(console.error);
+				}, 200);
+			}
+		});
+		signal?.addEventListener("abort", () => {
+			if (debounceTimer) clearTimeout(debounceTimer);
+			watcher.close();
+			for (const sub of activeSubscriptions.values()) sub.unsubscribe();
+			resolve();
+		});
+	});
+}
+
+//#endregion
+//#region src/adapter-google-chat/cron.ts
+function startSubscriptionRenewalCron(config) {
+	return setInterval(async () => {
+		try {
+			await renewExpiringSubscriptions(config);
+		} catch (err) {
+			console.error("Error in subscription renewal cron:", err);
+		}
+	}, 1e3 * 60 * 60);
+}
+async function renewExpiringSubscriptions(config) {
+	const state = await readGoogleChatState();
+	if (!state.channelChatMap) return;
+	const now = Date.now();
+	const FORTY_EIGHT_HOURS_MS = 2880 * 60 * 1e3;
+	for (const [externalContextId, entry] of Object.entries(state.channelChatMap)) if (entry.subscriptionId && entry.expirationDate) {
+		if (new Date(entry.expirationDate).getTime() - now < FORTY_EIGHT_HOURS_MS) {
+			console.log(`Renewing expiring subscription ${entry.subscriptionId} for space ${externalContextId}`);
+			try {
+				const token = (await (await getUserAuthClient(config)).getAccessToken()).token;
+				if (token) {
+					const res = await fetch(`https://workspaceevents.googleapis.com/v1/${entry.subscriptionId}?updateMask=ttl`, {
+						method: "PATCH",
+						headers: {
+							Authorization: `Bearer ${token}`,
+							"Content-Type": "application/json"
+						},
+						body: JSON.stringify({ ttl: "604800s" })
+					});
+					if (res.ok) {
+						const subData = await res.json();
+						await updateGoogleChatState((latestState) => {
+							const currentMap = latestState.channelChatMap || {};
+							return { channelChatMap: {
+								...currentMap,
+								[externalContextId]: {
+									...currentMap[externalContextId] || {},
+									expirationDate: subData.expireTime
+								}
+							} };
+						});
+						console.log(`Successfully renewed subscription ${entry.subscriptionId}`);
+					} else {
+						const errText = await res.text();
+						console.error(`Failed to renew subscription ${entry.subscriptionId}:`, errText);
+					}
+				}
+			} catch (err) {
+				console.error(`Error renewing subscription ${entry.subscriptionId}:`, err);
+			}
+		}
+	}
+}
+
+//#endregion
+//#region src/adapter-google-chat/index.ts
+async function main() {
+	if (process.argv.slice(2)[0] === "init") {
+		await initGoogleChatConfig();
+		return;
+	}
+	console.log("Google Chat Adapter starting...");
+	const config = await readGoogleChatConfig();
+	if (!config) {
+		console.error("Failed to load Google Chat configuration. Please ensure .clawmini/adapters/google-chat/config.json exists and is valid.");
+		process.exit(1);
+	}
+	if (config.oauthClientId && config.oauthClientSecret) try {
+		console.log("Initializing Google User Authentication...");
+		await getUserAuthClient(config);
+	} catch (err) {
+		console.error("Failed to initialize Google User authentication:", err);
+		process.exit(1);
+	}
+	const trpc = getTRPCClient();
+	const filteringConfig = { filters: (await readGoogleChatState()).filters };
+	startGoogleChatIngestion(config, trpc, filteringConfig);
+	console.log(`Listening to Pub/Sub subscription: ${config.subscriptionName}`);
+	startDaemonToGoogleChatForwarder(trpc, config, filteringConfig).catch((error) => {
+		console.error("Error in daemon-to-google-chat forwarder:", error);
+	});
+	startSubscriptionRenewalCron(config);
+}
+if (process.env.NODE_ENV !== "test") main().catch((error) => {
+	console.error("Unhandled error in Google Chat Adapter:", error);
+	process.exit(1);
+});
+
+//#endregion
+export { main };
+//# sourceMappingURL=index.mjs.map