@alfe.ai/openclaw-google-chat 0.0.28 → 0.0.30

package/dist/plugin2.js

@@ -1,35 +1,42 @@
 import { createRequire } from "node:module";
-import { dirname, join, resolve } from "node:path";
 import { resolveConfig } from "@alfe.ai/config";
 import { AgentApiClient } from "@alfe.ai/agent-api-client";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { getActivationKey, guardedStart, resetActivation, resolveOpenClawSdk } from "@alfe.ai/openclaw-plugin-kit";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
 import { homedir } from "node:os";
 //#region src/gchat-state.ts
 /**
 * State persistence — saves poller state to ~/.alfe/state/google-chat-poller.json.
 *
-* Written every 30s (debounced). Read on startup. Defaults to now-5min if
-* no state file exists.
+* Written atomically every 30s when dirty and flushed on shutdown. Read and
+* runtime-validated on startup; missing or invalid state starts fresh.
 */
-const STATE_DIR = join(homedir(), ".alfe", "state");
-const STATE_FILE = join(STATE_DIR, "google-chat-poller.json");
+const STATE_FILE = join(join(homedir(), ".alfe", "state"), "google-chat-poller.json");
 const SAVE_INTERVAL_MS = 3e4;
 var StateManager = class {
 	state = { spaces: {} };
 	dirty = false;
+	revision = 0;
+	flushPromise = null;
 	saveTimer = null;
 	log;
-	constructor(log) {
+	stateFile;
+	constructor(log, stateFile = STATE_FILE) {
 		this.log = log;
+		this.stateFile = stateFile;
 	}
 	/** Load state from disk. Returns default state if file doesn't exist. */
 	async load() {
 		try {
-			const raw = await readFile(STATE_FILE, "utf-8");
-			this.state = JSON.parse(raw);
+			const raw = await readFile(this.stateFile, "utf-8");
+			const parsed = JSON.parse(raw);
+			if (!isPersistedState(parsed)) throw new Error("invalid state shape");
+			this.state = parsed;
 			this.log.info(`Loaded state: ${String(Object.keys(this.state.spaces).length)} known spaces`);
-		} catch {
-			this.log.debug("No existing state file — starting fresh");
+		} catch (err) {
+			if (isMissingFileError(err)) this.log.debug("No existing state file — starting fresh");
+			else this.log.warn(`Ignoring unreadable Google Chat state: ${err instanceof Error ? err.message : String(err)}`);
 			this.state = { spaces: {} };
 		}
 		return this.state;
@@ -49,7 +56,8 @@ var StateManager = class {
 			clearInterval(this.saveTimer);
 			this.saveTimer = null;
 		}
-		if (this.dirty) await this.flush();
+		while (this.dirty || this.flushPromise) if (this.flushPromise) await this.flushPromise;
+		else await this.flush();
 	}
 	/** Get the last-seen timestamp for a space, or undefined if not yet tracked. */
 	getLastSeenTimestamp(spaceName) {
@@ -64,7 +72,7 @@ var StateManager = class {
 	setAgentIdentity(userId, email) {
 		this.state.agentUserId = userId;
 		this.state.agentEmail = email;
-		this.dirty = true;
+		this.markDirty();
 	}
 	/** Get the agent's userId for a space (if previously resolved). */
 	getAgentUserId(spaceName) {
@@ -85,27 +93,75 @@ var StateManager = class {
 			...existing,
 			...data
 		};
-		this.dirty = true;
+		this.markDirty();
 	}
 	/** Remove a space from tracked state. */
 	removeSpace(spaceName) {
 		delete this.state.spaces[spaceName];
-		this.dirty = true;
+		this.markDirty();
 	}
 	/** Write state to disk immediately. */
-	async flush() {
-		try {
-			await mkdir(STATE_DIR, { recursive: true });
-			await writeFile(STATE_FILE, JSON.stringify(this.state, null, 2));
-			this.dirty = false;
-		} catch (err) {
-			this.log.error(`Failed to write state: ${err instanceof Error ? err.message : String(err)}`);
-		}
+	flush() {
+		if (this.flushPromise) return this.flushPromise;
+		if (!this.dirty) return Promise.resolve();
+		const revision = this.revision;
+		const contents = JSON.stringify(this.state, null, 2);
+		const stateDir = dirname(this.stateFile);
+		const temporaryFile = `${this.stateFile}.${String(process.pid)}.tmp`;
+		this.flushPromise = (async () => {
+			try {
+				await mkdir(stateDir, {
+					recursive: true,
+					mode: 448
+				});
+				await writeFile(temporaryFile, contents, { mode: 384 });
+				await rename(temporaryFile, this.stateFile);
+				if (this.revision === revision) this.dirty = false;
+			} catch (err) {
+				await rm(temporaryFile, { force: true }).catch(() => void 0);
+				this.log.error(`Failed to write state: ${err instanceof Error ? err.message : String(err)}`);
+				throw err;
+			} finally {
+				this.flushPromise = null;
+			}
+		})();
+		return this.flushPromise;
+	}
+	markDirty() {
+		this.revision += 1;
+		this.dirty = true;
 	}
 };
+function isMissingFileError(err) {
+	return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
+}
+function isPersistedState(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const record = value;
+	if (typeof record.spaces !== "object" || record.spaces === null || Array.isArray(record.spaces)) return false;
+	if (record.agentUserId !== void 0 && typeof record.agentUserId !== "string") return false;
+	if (record.agentEmail !== void 0 && typeof record.agentEmail !== "string") return false;
+	for (const entry of Object.values(record.spaces)) {
+		if (typeof entry !== "object" || entry === null || Array.isArray(entry)) return false;
+		const space = entry;
+		if (typeof space.lastSeenTimestamp !== "string" || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?Z$/.test(space.lastSeenTimestamp) || !Number.isFinite(Date.parse(space.lastSeenTimestamp)) || typeof space.agentUserId !== "string" || typeof space.peerUserId !== "string") return false;
+	}
+	return true;
+}
 //#endregion
 //#region src/gchat-api.ts
 const CHAT_API = "https://chat.googleapis.com/v1";
+const REQUEST_TIMEOUT_MS = 2e4;
+const MAX_RESPONSE_BYTES = 1048576;
+const MAX_PAGES = 100;
+const MAX_ITEMS = 1e4;
+var GoogleChatApiError = class extends Error {
+	constructor(message, status) {
+		super(message);
+		this.status = status;
+		this.name = "GoogleChatApiError";
+	}
+};
 async function request(token, path, options) {
 	const url = `${CHAT_API}${path}`;
 	const headers = new Headers(options?.headers);
@@ -113,24 +169,158 @@ async function request(token, path, options) {
 	headers.set("Content-Type", "application/json");
 	const res = await fetch(url, {
 		...options,
-		headers
+		headers,
+		signal: options?.signal ?? AbortSignal.timeout(REQUEST_TIMEOUT_MS)
 	});
 	if (!res.ok) {
-		const body = await res.text().catch(() => "");
-		throw Object.assign(/* @__PURE__ */ new Error(`Google Chat API error ${String(res.status)}: ${body}`), { status: res.status });
+		await res.body?.cancel().catch(() => void 0);
+		throw new GoogleChatApiError(`Google Chat API error ${String(res.status)}`, res.status);
+	}
+	const raw = await readBoundedBody(res);
+	try {
+		return JSON.parse(raw);
+	} catch {
+		throw new GoogleChatApiError("Google Chat API returned invalid JSON");
+	}
+}
+async function readBoundedBody(response) {
+	const declaredLength = response.headers.get("content-length");
+	if (declaredLength) {
+		const length = Number(declaredLength);
+		if (!Number.isFinite(length) || length < 0 || length > MAX_RESPONSE_BYTES) {
+			await response.body?.cancel().catch(() => void 0);
+			throw new GoogleChatApiError("Google Chat API response exceeded the size limit");
+		}
+	}
+	if (!response.body) return "";
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+	let total = 0;
+	let result = "";
+	let chunk = await reader.read();
+	while (!chunk.done) {
+		total += chunk.value.byteLength;
+		if (total > MAX_RESPONSE_BYTES) {
+			await reader.cancel().catch(() => void 0);
+			throw new GoogleChatApiError("Google Chat API response exceeded the size limit");
+		}
+		result += decoder.decode(chunk.value, { stream: true });
+		chunk = await reader.read();
+	}
+	return result + decoder.decode();
+}
+function asRecord(value, label) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new GoogleChatApiError(`Google Chat API returned an invalid ${label}`);
+	return value;
+}
+function readOptionalString(record, key) {
+	const value = record[key];
+	if (value === void 0) return void 0;
+	if (typeof value !== "string") throw new GoogleChatApiError(`Google Chat API returned an invalid ${key}`);
+	return value;
+}
+function readPageToken(record) {
+	const token = readOptionalString(record, "nextPageToken");
+	return token === "" ? void 0 : token;
+}
+function readArray(record, key, parse) {
+	const value = record[key];
+	if (value === void 0) return [];
+	if (!Array.isArray(value) || value.length > MAX_ITEMS) throw new GoogleChatApiError(`Google Chat API returned an invalid ${key}`);
+	return value.map(parse);
+}
+function parseUser(value) {
+	const user = asRecord(value, "user");
+	const name = readOptionalString(user, "name");
+	const type = readOptionalString(user, "type");
+	const displayName = readOptionalString(user, "displayName");
+	if (!name || !type) throw new GoogleChatApiError("Google Chat API returned an invalid user");
+	try {
+		userResource(name);
+	} catch {
+		throw new GoogleChatApiError("Google Chat API returned an invalid user");
 	}
-	return await res.json();
+	return {
+		name,
+		type,
+		...displayName !== void 0 ? { displayName } : {}
+	};
+}
+function parseSpace(value) {
+	const space = asRecord(value, "space");
+	const name = readOptionalString(space, "name");
+	const type = readOptionalString(space, "type");
+	const spaceType = readOptionalString(space, "spaceType");
+	const singleUserBotDm = space.singleUserBotDm;
+	if (!name || !spaceType || type !== void 0 && !type || singleUserBotDm !== void 0 && typeof singleUserBotDm !== "boolean") throw new GoogleChatApiError("Google Chat API returned an invalid space");
+	try {
+		spaceResource(name);
+	} catch {
+		throw new GoogleChatApiError("Google Chat API returned an invalid space");
+	}
+	return {
+		name,
+		displayName: readOptionalString(space, "displayName") ?? "",
+		type: type ?? spaceType,
+		spaceType,
+		singleUserBotDm: singleUserBotDm ?? false
+	};
+}
+function parseMessage(value) {
+	const message = asRecord(value, "message");
+	const name = readOptionalString(message, "name");
+	const createTime = readOptionalString(message, "createTime");
+	if (!name || !/^spaces\/[A-Za-z0-9_-]+\/messages\/[A-Za-z0-9_.-]+$/.test(name) || !createTime || !isRfc3339(createTime) || message.sender === void 0) throw new GoogleChatApiError("Google Chat API returned an invalid message");
+	return {
+		name,
+		sender: parseUser(message.sender),
+		createTime,
+		text: readOptionalString(message, "text") ?? ""
+	};
+}
+function isRfc3339(value) {
+	return /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?Z$/.test(value) && Number.isFinite(Date.parse(value));
+}
+function parseMembership(value) {
+	const membership = asRecord(value, "membership");
+	const name = readOptionalString(membership, "name");
+	const role = readOptionalString(membership, "role");
+	const state = readOptionalString(membership, "state");
+	if (!name || !/^spaces\/[A-Za-z0-9_-]+\/members\/[A-Za-z0-9_.-]+$/.test(name) || !role || !state || membership.member === void 0) throw new GoogleChatApiError("Google Chat API returned an invalid membership");
+	return {
+		name,
+		member: parseUser(membership.member),
+		role,
+		state
+	};
+}
+function spaceResource(value) {
+	const match = /^spaces\/([A-Za-z0-9_-]+)$/.exec(value);
+	if (!match) throw new Error("Invalid Google Chat space resource name");
+	return `spaces/${encodeURIComponent(match[1])}`;
+}
+function userResource(value) {
+	const match = /^users\/([A-Za-z0-9._+@-]+)$/.exec(value);
+	if (!match) throw new Error("Invalid Google Chat user resource name");
+	return `users/${encodeURIComponent(match[1])}`;
 }
 /** List all spaces the user is a member of. */
 async function listSpaces(token, log) {
 	const allSpaces = [];
 	let pageToken;
+	const seenPageTokens = /* @__PURE__ */ new Set();
+	let pageCount = 0;
 	do {
+		pageCount += 1;
+		if (pageCount > MAX_PAGES) throw new GoogleChatApiError("Google Chat spaces pagination exceeded the page limit");
 		const params = new URLSearchParams({ pageSize: "100" });
 		if (pageToken) params.set("pageToken", pageToken);
-		const data = await request(token, `/spaces?${params.toString()}`);
-		if (data.spaces) allSpaces.push(...data.spaces);
-		pageToken = data.nextPageToken;
+		const data = asRecord(await request(token, `/spaces?${params.toString()}`), "spaces page");
+		allSpaces.push(...readArray(data, "spaces", parseSpace));
+		if (allSpaces.length > MAX_ITEMS) throw new GoogleChatApiError("Google Chat spaces exceeded the item limit");
+		pageToken = readPageToken(data);
+		if (pageToken && seenPageTokens.has(pageToken)) throw new GoogleChatApiError("Google Chat spaces pagination repeated a page token");
+		if (pageToken) seenPageTokens.add(pageToken);
 	} while (pageToken);
 	const dms = allSpaces.filter((s) => s.spaceType === "DIRECT_MESSAGE" && !s.singleUserBotDm);
 	log.debug(`Listed ${String(allSpaces.length)} spaces, ${String(dms.length)} are DMs`);
@@ -138,36 +328,59 @@ async function listSpaces(token, log) {
 }
 /** List messages in a space after a given timestamp. */
 async function listMessages(token, spaceName, afterTimestamp, log) {
+	if (!isRfc3339(afterTimestamp)) throw new Error("Invalid Google Chat message timestamp");
 	const filter = `createTime > "${afterTimestamp}"`;
-	const messages = (await request(token, `/${spaceName}/messages?${new URLSearchParams({
-		filter,
-		orderBy: "createTime asc",
-		pageSize: "50"
-	}).toString()}`)).messages ?? [];
+	const messages = [];
+	const seenPageTokens = /* @__PURE__ */ new Set();
+	let pageToken;
+	let pageCount = 0;
+	do {
+		pageCount += 1;
+		if (pageCount > MAX_PAGES) throw new GoogleChatApiError("Google Chat messages pagination exceeded the page limit");
+		const params = new URLSearchParams({
+			filter,
+			orderBy: "createTime asc",
+			pageSize: "100"
+		});
+		if (pageToken) params.set("pageToken", pageToken);
+		const data = asRecord(await request(token, `/${spaceResource(spaceName)}/messages?${params.toString()}`), "messages page");
+		messages.push(...readArray(data, "messages", parseMessage));
+		if (messages.length > MAX_ITEMS) throw new GoogleChatApiError("Google Chat messages exceeded the item limit");
+		pageToken = readPageToken(data);
+		if (pageToken && seenPageTokens.has(pageToken)) throw new GoogleChatApiError("Google Chat messages pagination repeated a page token");
+		if (pageToken) seenPageTokens.add(pageToken);
+	} while (pageToken);
 	if (messages.length > 0) log.debug(`Fetched ${String(messages.length)} new messages from ${spaceName}`);
 	return messages;
 }
 /** Send a text message to a space. */
 async function sendMessage(token, spaceName, text) {
-	return request(token, `/${spaceName}/messages`, {
+	return parseMessage(await request(token, `/${spaceResource(spaceName)}/messages`, {
 		method: "POST",
 		body: JSON.stringify({ text })
-	});
+	}));
 }
 /** Get a specific member of a space by user resource name or email alias. */
 async function getMember(token, spaceName, userId) {
-	return request(token, `/${spaceName}/members/${userId}`);
+	return parseMembership(await request(token, `/${spaceResource(spaceName)}/members/${userResource(userId)}`));
 }
 /** List members of a space. */
 async function listMembers(token, spaceName) {
 	const allMembers = [];
 	let pageToken;
+	const seenPageTokens = /* @__PURE__ */ new Set();
+	let pageCount = 0;
 	do {
+		pageCount += 1;
+		if (pageCount > MAX_PAGES) throw new GoogleChatApiError("Google Chat members pagination exceeded the page limit");
 		const params = new URLSearchParams({ pageSize: "100" });
 		if (pageToken) params.set("pageToken", pageToken);
-		const data = await request(token, `/${spaceName}/members?${params.toString()}`);
-		if (data.memberships) allMembers.push(...data.memberships);
-		pageToken = data.nextPageToken;
+		const data = asRecord(await request(token, `/${spaceResource(spaceName)}/members?${params.toString()}`), "members page");
+		allMembers.push(...readArray(data, "memberships", parseMembership));
+		if (allMembers.length > MAX_ITEMS) throw new GoogleChatApiError("Google Chat members exceeded the item limit");
+		pageToken = readPageToken(data);
+		if (pageToken && seenPageTokens.has(pageToken)) throw new GoogleChatApiError("Google Chat members pagination repeated a page token");
+		if (pageToken) seenPageTokens.add(pageToken);
 	} while (pageToken);
 	return allMembers;
 }
@@ -184,7 +397,9 @@ const CODE_BLOCK_RE = /```[\s\S]*?```/g;
 const INLINE_CODE_RE = /`[^`]+`/g;
 function markdownToGChat(text) {
 	const preserved = [];
-	const placeholder = (i) => `\x00CODE${String(i)}\x00`;
+	let sentinel = "\0ALFE_GCHAT_CODE_";
+	while (text.includes(sentinel)) sentinel += "_";
+	const placeholder = (i) => `${sentinel}${String(i)}\x00`;
 	let result = text.replace(CODE_BLOCK_RE, (match) => {
 		preserved.push(match);
 		return placeholder(preserved.length - 1);
@@ -244,8 +459,8 @@ var GChatPoller = class {
 		await this.discover();
 		this.scheduleDiscovery();
 	}
-	/** Stop all polling. */
-	stop() {
+	/** Stop all polling and durably flush the last checkpoint. */
+	async stop() {
 		this.running = false;
 		if (this.discoveryTimer) {
 			clearTimeout(this.discoveryTimer);
@@ -254,9 +469,7 @@ var GChatPoller = class {
 		for (const state of this.spaces.values()) if (state.pollTimer) clearTimeout(state.pollTimer);
 		this.spaces.clear();
 		this.seenMessages.clear();
-		this.stateManager.stop().catch((err) => {
-			this.log.error(`State save on stop failed: ${err instanceof Error ? err.message : String(err)}`);
-		});
+		await this.stateManager.stop();
 	}
 	scheduleDiscovery() {
 		if (!this.running) return;
@@ -266,12 +479,14 @@ var GChatPoller = class {
 			}).finally(() => {
 				this.scheduleDiscovery();
 			});
-		}, DISCOVERY_INTERVAL_MS);
+		}, this.applyApiBackoff(DISCOVERY_INTERVAL_MS));
 	}
 	async discover() {
 		if (!this.running) return;
+		if (this.apiBackoffUntil > Date.now()) return;
 		const token = await this.tokenManager.getAccessToken();
 		const dmSpaces = await listSpaces(token, this.log);
+		this.recordApiSuccess();
 		const currentNames = new Set(dmSpaces.map((s) => s.name));
 		for (const space of dmSpaces) if (!this.spaces.has(space.name)) await this.initSpace(space.name, token);
 		for (const [name, state] of this.spaces) if (!currentNames.has(name)) {
@@ -359,7 +574,7 @@ var GChatPoller = class {
 	}
 	scheduleSpacePoll(state) {
 		if (!this.running) return;
-		const interval = this.computeInterval(state);
+		const interval = this.applyApiBackoff(this.computeInterval(state));
 		state.pollTimer = setTimeout(() => {
 			this.pollSpace(state).catch((err) => {
 				this.handleApiError(err, `poll:${state.spaceName}`);
@@ -370,6 +585,7 @@ var GChatPoller = class {
 	}
 	async pollSpace(state) {
 		if (!this.running) return;
+		if (this.apiBackoffUntil > Date.now()) return;
 		const token = await this.tokenManager.getAccessToken();
 		let messages;
 		try {
@@ -382,38 +598,59 @@ var GChatPoller = class {
 					freshToken = await this.tokenManager.getAccessToken();
 				} catch (refreshErr) {
 					this.log.error(`Token refresh failed after 401 — stopping poller: ${refreshErr instanceof Error ? refreshErr.message : String(refreshErr)}`);
-					this.stop();
+					await this.stop();
 					return;
 				}
 				messages = await listMessages(freshToken, state.spaceName, state.lastSeenTimestamp, this.log);
 			} else throw err;
 		}
+		this.recordApiSuccess();
 		const seenSet = this.seenMessages.get(state.spaceName) ?? /* @__PURE__ */ new Set();
+		this.seenMessages.set(state.spaceName, seenSet);
+		let cohortTimestamp = null;
+		let cohortFailed = false;
 		for (const msg of messages) {
+			if (cohortTimestamp !== null && msg.createTime !== cohortTimestamp) this.commitTimestamp(cohortTimestamp, state);
+			cohortTimestamp = msg.createTime;
 			if (seenSet.has(msg.name)) continue;
-			seenSet.add(msg.name);
-			if (seenSet.size > DEDUP_SIZE) {
-				const iter = seenSet.values().next();
-				if (!iter.done) seenSet.delete(iter.value);
+			if (msg.sender.name === state.agentUserId) {
+				this.rememberMessage(msg, seenSet);
+				continue;
+			}
+			if (!msg.text) {
+				this.rememberMessage(msg, seenSet);
+				continue;
 			}
-			state.lastSeenTimestamp = msg.createTime;
-			this.stateManager.updateSpace(state.spaceName, { lastSeenTimestamp: msg.createTime });
-			if (msg.sender.name === state.agentUserId) continue;
-			if (!msg.text) continue;
 			state.lastMessageAt = Date.now();
-			await this.dispatchMessage(msg, state);
+			if (!await this.dispatchMessage(msg, state)) {
+				cohortFailed = true;
+				break;
+			}
+			this.rememberMessage(msg, seenSet);
 		}
+		if (!cohortFailed && cohortTimestamp !== null) this.commitTimestamp(cohortTimestamp, state);
+	}
+	rememberMessage(message, seenSet) {
+		seenSet.add(message.name);
+		if (seenSet.size > DEDUP_SIZE) {
+			const oldest = seenSet.values().next();
+			if (!oldest.done) seenSet.delete(oldest.value);
+		}
+	}
+	commitTimestamp(timestamp, state) {
+		state.lastSeenTimestamp = timestamp;
+		this.stateManager.updateSpace(state.spaceName, { lastSeenTimestamp: timestamp });
 	}
 	async dispatchMessage(message, state) {
 		if (!this.dispatchInbound || !this.runtime) {
 			this.log.warn("Cannot dispatch — SDK or runtime not available");
-			return;
+			return false;
 		}
 		const conversationId = `alfe:gchat:${state.spaceName}`;
 		const senderName = message.sender.name || state.peerUserId;
 		const senderDisplayName = message.sender.displayName;
 		const peerLabel = senderDisplayName || state.peerDisplayName || "User";
-		this.log.info(`Dispatching message from ${peerLabel} in ${state.spaceName}`);
+		this.log.info(`Dispatching Google Chat DM in ${state.spaceName}`);
 		let resolvedIdentityId;
 		if (this.agentClient) try {
 			const senderUserId = senderName.startsWith("users/") ? senderName.slice(6) : senderName;
@@ -426,6 +663,7 @@ var GChatPoller = class {
 		}
 		try {
 			const cfg = this.runtime.config.loadConfig();
+			let callbackFailed = false;
 			await this.dispatchInbound({
 				cfg,
 				runtime: { channel: this.runtime.channel },
@@ -470,14 +708,18 @@ var GChatPoller = class {
 					}
 				},
 				onRecordError: (err) => {
+					callbackFailed = true;
 					this.log.error(`Session error: ${err instanceof Error ? err.message : String(err)}`);
 				},
 				onDispatchError: (err, info) => {
+					callbackFailed = true;
 					this.log.error(`Dispatch error (${info.kind}): ${err instanceof Error ? err.message : String(err)}`);
 				}
 			});
+			return !callbackFailed;
 		} catch (err) {
 			this.log.error(`Failed to dispatch message: ${err instanceof Error ? err.message : String(err)}`);
+			return false;
 		}
 	}
 	computeInterval(state) {
@@ -489,26 +731,40 @@ var GChatPoller = class {
 		return INTERVAL_DORMANT_MS;
 	}
 	retryCount = 0;
+	apiBackoffUntil = 0;
 	handleApiError(err, context) {
 		if (isHttpStatus(err, 403) || isTokenRevokedError(err)) {
 			this.log.error(`Token revoked or forbidden (${context}) — stopping poller`);
-			this.stop();
+			this.stop().catch((stopErr) => {
+				this.log.error(`Poller stop failed: ${stopErr instanceof Error ? stopErr.message : String(stopErr)}`);
+			});
 			return;
 		}
 		if (isHttpStatus(err, 429)) {
 			this.retryCount = Math.min(this.retryCount + 1, 5);
 			const delay = Math.min(BASE_RETRY_DELAY_MS * Math.pow(2, this.retryCount), MAX_RETRY_DELAY_MS);
+			this.apiBackoffUntil = Math.max(this.apiBackoffUntil, Date.now() + delay);
 			this.log.warn(`Rate limited (${context}) — backing off ${String(delay)}ms`);
 			return;
 		}
 		if (isHttpStatus(err, 404)) {
 			this.log.error(`Google Chat API returned 404 (${context}) — verify the Chat app is configured in the GCP Console: https://console.cloud.google.com/apis/api/chat.googleapis.com/hangouts-chat`);
-			this.stop();
+			this.stop().catch((stopErr) => {
+				this.log.error(`Poller stop failed: ${stopErr instanceof Error ? stopErr.message : String(stopErr)}`);
+			});
 			return;
 		}
-		this.retryCount = 0;
 		this.log.error(`API error in ${context}: ${err instanceof Error ? err.message : String(err)}`);
 	}
+	applyApiBackoff(baseDelay) {
+		return Math.max(baseDelay, this.apiBackoffUntil - Date.now(), 0);
+	}
+	recordApiSuccess() {
+		if (Date.now() >= this.apiBackoffUntil) {
+			this.retryCount = 0;
+			this.apiBackoffUntil = 0;
+		}
+	}
 };
 function isHttpStatus(err, status) {
 	return typeof err === "object" && err !== null && "status" in err && err.status === status;
@@ -532,36 +788,10 @@ function isTokenRevokedError(err) {
 *       → dispatchInboundDirectDmWithRuntime() → Agent pipeline
 *       ← deliver() callback → Google Chat API (reply as user)
 */
-const require = createRequire(import.meta.url);
-const pkg = require("../package.json");
-let dispatchInbound = null;
-/**
-* Resolve OpenClaw SDK from the running process.
-* Copied from @alfe.ai/openclaw-chat's resolution strategy.
-*/
-function resolveOpenClawSdk(log) {
-	const anchors = [require.main?.filename, process.argv[1]].filter(Boolean);
-	for (const anchor of anchors) try {
-		const channelInbound = createRequire(anchor)("openclaw/plugin-sdk/channel-inbound");
-		if (channelInbound.dispatchInboundDirectDmWithRuntime) {
-			dispatchInbound = channelInbound.dispatchInboundDirectDmWithRuntime;
-			log.info(`Resolved OpenClaw SDK from ${anchor}`);
-			return;
-		}
-	} catch {}
-	try {
-		const derivedPath = join(resolve(dirname(process.execPath), ".."), "lib", "node_modules", "openclaw", "package.json");
-		const channelInbound = createRequire(derivedPath)("openclaw/plugin-sdk/channel-inbound");
-		if (channelInbound.dispatchInboundDirectDmWithRuntime) {
-			dispatchInbound = channelInbound.dispatchInboundDirectDmWithRuntime;
-			log.info(`Resolved OpenClaw SDK from ${derivedPath}`);
-			return;
-		}
-	} catch {}
-	log.warn("OpenClaw SDK not resolvable — Google Chat dispatch will not work");
-}
-let pluginRuntime = null;
+const pkg = createRequire(import.meta.url)("../package.json");
+const GCHAT_ACTIVATION_KEY = getActivationKey("google-chat");
 let poller = null;
+let serviceGeneration = 0;
 const plugin = {
 	id: "@alfe.ai/openclaw-google-chat",
 	name: "Google Chat",
@@ -569,80 +799,78 @@ const plugin = {
 	version: pkg.version,
 	activate(api) {
 		const log = api.logger;
-		const startService = async () => {
-			if (globalThis.__alfeGoogleChatActivated) {
-				log.debug("Google Chat plugin already activated — skipping duplicate");
-				return;
-			}
-			globalThis.__alfeGoogleChatActivated = true;
-			log.info("Google Chat plugin starting...");
-			resolveOpenClawSdk(log);
-			pluginRuntime = api.runtime ?? null;
-			let client;
-			try {
-				const cfg = resolveConfig();
-				client = new AgentApiClient({
-					apiKey: cfg.apiKey,
-					apiUrl: cfg.apiUrl
-				});
-			} catch (err) {
-				globalThis.__alfeGoogleChatActivated = false;
-				log.error(`Failed to resolve config: ${err instanceof Error ? err.message : String(err)}`);
-				return;
-			}
-			let creds;
-			try {
-				creds = await client.getGoogleChatCredentials();
-			} catch (err) {
-				globalThis.__alfeGoogleChatActivated = false;
-				log.info(`Google Chat not connected — polling disabled (${err instanceof Error ? err.message : String(err)})`);
-				return;
-			}
-			const init = {
-				tokenManager: new (await (import("./gchat-token.js"))).TokenManager({
-					refreshToken: creds.refreshToken,
-					clientId: creds.clientId,
-					clientSecret: creds.clientSecret
-				}, log),
-				dispatchInbound,
-				runtime: pluginRuntime,
-				log,
-				agentEmail: creds.email
-			};
-			init.agentClient = client;
-			poller = new GChatPoller(init);
-			await poller.start();
-			log.info(`Google Chat poller started (account: ${creds.email})`);
+		const startService = () => {
+			guardedStart(GCHAT_ACTIVATION_KEY, log, async () => {
+				const generation = ++serviceGeneration;
+				let nextPoller = null;
+				try {
+					log.info("Google Chat plugin starting...");
+					const resolvedDispatch = resolveOpenClawSdk(log, { unresolvableNote: "OpenClaw SDK not resolvable — Google Chat dispatch will not work" });
+					const resolvedRuntime = api.runtime ?? null;
+					if (!resolvedDispatch || !resolvedRuntime) {
+						if (generation === serviceGeneration) resetActivation(GCHAT_ACTIVATION_KEY);
+						log.error("Google Chat runtime prerequisites unavailable — polling disabled");
+						return;
+					}
+					const cfg = resolveConfig();
+					const client = new AgentApiClient({
+						apiKey: cfg.apiKey,
+						apiUrl: cfg.apiUrl
+					});
+					const creds = await client.getGoogleChatCredentials();
+					if (generation !== serviceGeneration) return;
+					nextPoller = new GChatPoller({
+						tokenManager: new (await (import("./gchat-token.js"))).TokenManager({
+							refreshToken: creds.refreshToken,
+							clientId: creds.clientId,
+							clientSecret: creds.clientSecret
+						}, log),
+						dispatchInbound: resolvedDispatch,
+						runtime: resolvedRuntime,
+						log,
+						agentEmail: creds.email,
+						agentClient: client
+					});
+					await nextPoller.start();
+					if (generation !== serviceGeneration) {
+						await nextPoller.stop();
+						return;
+					}
+					poller = nextPoller;
+					log.info("Google Chat poller started");
+				} catch (err) {
+					await nextPoller?.stop().catch(() => void 0);
+					if (generation === serviceGeneration) {
+						resetActivation(GCHAT_ACTIVATION_KEY);
+						log.info(`Google Chat unavailable — polling disabled (${err instanceof Error ? err.message : String(err)})`);
+					}
+				}
+			});
 		};
-		const stopService = () => {
-			globalThis.__alfeGoogleChatActivated = false;
-			poller?.stop();
+		const stopService = async () => {
+			serviceGeneration += 1;
+			const currentPoller = poller;
 			poller = null;
-			pluginRuntime = null;
-			dispatchInbound = null;
+			await currentPoller?.stop();
+			resetActivation(GCHAT_ACTIVATION_KEY);
 			log.info("Google Chat plugin stopped");
 		};
 		api.registerService({
 			id: "google-chat-poller",
 			start: () => {
-				startService().catch((err) => {
-					globalThis.__alfeGoogleChatActivated = false;
-					log.error(`Google Chat service start failed: ${err instanceof Error ? err.message : String(err)}`);
-				});
+				startService();
 			},
-			stop: () => {
-				stopService();
-			}
+			stop: stopService
 		});
 		log.info("Google Chat plugin registered");
 	},
-	deactivate(api) {
-		globalThis.__alfeGoogleChatActivated = false;
+	async deactivate(api) {
 		const log = api.logger;
-		poller?.stop();
+		serviceGeneration += 1;
+		const currentPoller = poller;
 		poller = null;
-		pluginRuntime = null;
-		dispatchInbound = null;
+		await currentPoller?.stop();
+		resetActivation(GCHAT_ACTIVATION_KEY);
 		log.info("Google Chat plugin deactivated");
 	}
 };