@alfe.ai/openclaw-google-chat 0.0.3 → 0.0.4

package/dist/plugin2.js

@@ -0,0 +1,578 @@
+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 { 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.
+*/
+const STATE_DIR = join(homedir(), ".alfe", "state");
+const STATE_FILE = join(STATE_DIR, "google-chat-poller.json");
+const SAVE_INTERVAL_MS = 3e4;
+var StateManager = class {
+	state = { spaces: {} };
+	dirty = false;
+	saveTimer = null;
+	log;
+	constructor(log) {
+		this.log = log;
+	}
+	/** 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);
+			this.log.info(`Loaded state: ${String(Object.keys(this.state.spaces).length)} known spaces`);
+		} catch {
+			this.log.debug("No existing state file — starting fresh");
+			this.state = { spaces: {} };
+		}
+		return this.state;
+	}
+	/** Start the periodic save timer. */
+	startAutoSave() {
+		if (this.saveTimer) return;
+		this.saveTimer = setInterval(() => {
+			if (this.dirty) this.flush().catch((err) => {
+				this.log.error(`State save failed: ${err instanceof Error ? err.message : String(err)}`);
+			});
+		}, SAVE_INTERVAL_MS);
+	}
+	/** Stop the periodic save timer and flush any pending state. */
+	async stop() {
+		if (this.saveTimer) {
+			clearInterval(this.saveTimer);
+			this.saveTimer = null;
+		}
+		if (this.dirty) await this.flush();
+	}
+	/** Get the last-seen timestamp for a space, or a default 5min ago. */
+	getLastSeenTimestamp(spaceName) {
+		return this.state.spaces[spaceName]?.lastSeenTimestamp ?? (/* @__PURE__ */ new Date(Date.now() - 300 * 1e3)).toISOString();
+	}
+	/** Get the agent's userId for a space (if previously resolved). */
+	getAgentUserId(spaceName) {
+		return this.state.spaces[spaceName]?.agentUserId;
+	}
+	/** Get the peer's userId for a space (if previously resolved). */
+	getPeerUserId(spaceName) {
+		return this.state.spaces[spaceName]?.peerUserId;
+	}
+	/** Update state for a space. */
+	updateSpace(spaceName, data) {
+		const existing = this.state.spaces[spaceName] ?? {
+			lastSeenTimestamp: (/* @__PURE__ */ new Date(Date.now() - 300 * 1e3)).toISOString(),
+			agentUserId: "",
+			peerUserId: ""
+		};
+		this.state.spaces[spaceName] = {
+			...existing,
+			...data
+		};
+		this.dirty = true;
+	}
+	/** Remove a space from tracked state. */
+	removeSpace(spaceName) {
+		delete this.state.spaces[spaceName];
+		this.dirty = true;
+	}
+	/** 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)}`);
+		}
+	}
+};
+//#endregion
+//#region src/gchat-api.ts
+const CHAT_API = "https://chat.googleapis.com/v1";
+async function request(token, path, options) {
+	const url = `${CHAT_API}${path}`;
+	const headers = new Headers(options?.headers);
+	headers.set("Authorization", `Bearer ${token}`);
+	headers.set("Content-Type", "application/json");
+	const res = await fetch(url, {
+		...options,
+		headers
+	});
+	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 });
+	}
+	return await res.json();
+}
+/** List all spaces the user is a member of. */
+async function listSpaces(token, log) {
+	const allSpaces = [];
+	let pageToken;
+	do {
+		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;
+	} 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`);
+	return dms;
+}
+/** List messages in a space after a given timestamp. */
+async function listMessages(token, spaceName, afterTimestamp, log) {
+	const filter = `createTime > "${afterTimestamp}"`;
+	const messages = (await request(token, `/${spaceName}/messages?${new URLSearchParams({
+		filter,
+		orderBy: "createTime asc",
+		pageSize: "50"
+	}).toString()}`)).messages ?? [];
+	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`, {
+		method: "POST",
+		body: JSON.stringify({ text })
+	});
+}
+/** List members of a space. */
+async function listMembers(token, spaceName) {
+	const allMembers = [];
+	let pageToken;
+	do {
+		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;
+	} while (pageToken);
+	return allMembers;
+}
+/** Fetch the last N messages from a space (for backfill on new space discovery). */
+async function listRecentMessages(token, spaceName, limit) {
+	return (await request(token, `/${spaceName}/messages?${new URLSearchParams({ pageSize: String(limit) }).toString()}`)).messages ?? [];
+}
+//#endregion
+//#region src/gchat-poller.ts
+const INTERVAL_ACTIVE_MS = 1e3;
+const INTERVAL_WARM_MS = 5e3;
+const INTERVAL_IDLE_MS = 15e3;
+const INTERVAL_DORMANT_MS = 3e4;
+const ACTIVE_THRESHOLD_MS = 300 * 1e3;
+const WARM_THRESHOLD_MS = 1800 * 1e3;
+const DORMANT_THRESHOLD_MS = 7200 * 1e3;
+const DISCOVERY_INTERVAL_MS = 3e4;
+const DEDUP_SIZE = 100;
+const BACKFILL_COUNT = 20;
+const MAX_RETRY_DELAY_MS = 6e4;
+const BASE_RETRY_DELAY_MS = 2e3;
+var GChatPoller = class {
+	tokenManager;
+	dispatchInbound;
+	runtime;
+	log;
+	stateManager;
+	agentEmail;
+	spaces = /* @__PURE__ */ new Map();
+	seenMessages = /* @__PURE__ */ new Map();
+	discoveryTimer = null;
+	running = false;
+	constructor(init) {
+		this.tokenManager = init.tokenManager;
+		this.dispatchInbound = init.dispatchInbound;
+		this.runtime = init.runtime;
+		this.log = init.log;
+		this.agentEmail = init.agentEmail;
+		this.stateManager = new StateManager(init.log);
+	}
+	/** Start the polling engine. */
+	async start() {
+		this.running = true;
+		await this.stateManager.load();
+		this.stateManager.startAutoSave();
+		await this.discover();
+		this.scheduleDiscovery();
+	}
+	/** Stop all polling. */
+	stop() {
+		this.running = false;
+		if (this.discoveryTimer) {
+			clearTimeout(this.discoveryTimer);
+			this.discoveryTimer = null;
+		}
+		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)}`);
+		});
+	}
+	scheduleDiscovery() {
+		if (!this.running) return;
+		this.discoveryTimer = setTimeout(() => {
+			this.discover().catch((err) => {
+				this.handleApiError(err, "space-discovery");
+			}).finally(() => {
+				this.scheduleDiscovery();
+			});
+		}, DISCOVERY_INTERVAL_MS);
+	}
+	async discover() {
+		if (!this.running) return;
+		const token = await this.tokenManager.getAccessToken();
+		const dmSpaces = await listSpaces(token, this.log);
+		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)) {
+			this.log.info(`Space removed: ${name}`);
+			if (state.pollTimer) clearTimeout(state.pollTimer);
+			this.spaces.delete(name);
+			this.seenMessages.delete(name);
+			this.stateManager.removeSpace(name);
+		}
+		this.log.debug(`Discovery complete: ${String(this.spaces.size)} active DM spaces`);
+	}
+	async initSpace(spaceName, token) {
+		this.log.info(`New DM space discovered: ${spaceName}`);
+		let agentUserId = this.stateManager.getAgentUserId(spaceName) ?? "";
+		let peerUserId = this.stateManager.getPeerUserId(spaceName) ?? "";
+		let peerDisplayName = null;
+		if (!agentUserId || !peerUserId) try {
+			const members = await listMembers(token, spaceName);
+			const resolved = this.resolveMembers(members);
+			agentUserId = resolved.agentUserId;
+			peerUserId = resolved.peerUserId;
+			peerDisplayName = resolved.peerDisplayName;
+		} catch (err) {
+			this.log.warn(`Failed to resolve members for ${spaceName}: ${err instanceof Error ? err.message : String(err)}`);
+		}
+		let lastSeenTimestamp = this.stateManager.getLastSeenTimestamp(spaceName);
+		try {
+			const recent = await listRecentMessages(token, spaceName, BACKFILL_COUNT);
+			if (recent.length > 0) lastSeenTimestamp = recent[recent.length - 1].createTime;
+		} catch (err) {
+			this.log.warn(`Backfill failed for ${spaceName}: ${err instanceof Error ? err.message : String(err)}`);
+		}
+		this.stateManager.updateSpace(spaceName, {
+			lastSeenTimestamp,
+			agentUserId,
+			peerUserId
+		});
+		const state = {
+			spaceName,
+			lastSeenTimestamp,
+			lastMessageAt: 0,
+			agentUserId,
+			peerUserId,
+			peerDisplayName,
+			pollTimer: null
+		};
+		this.spaces.set(spaceName, state);
+		this.seenMessages.set(spaceName, /* @__PURE__ */ new Set());
+		this.scheduleSpacePoll(state);
+	}
+	resolveMembers(members) {
+		let agentUserId = "";
+		let peerUserId = "";
+		let peerDisplayName = null;
+		for (const m of members) {
+			if (m.member.type !== "HUMAN") continue;
+			if (this.agentEmail && m.member.displayName.toLowerCase().includes(this.agentEmail.split("@")[0].toLowerCase())) agentUserId = m.member.name;
+			else {
+				peerUserId = m.member.name;
+				peerDisplayName = m.member.displayName || null;
+			}
+		}
+		if (!agentUserId && members.length >= 2) {
+			agentUserId = members[0].member.name;
+			peerUserId = members[1].member.name;
+			peerDisplayName = members[1].member.displayName || null;
+		}
+		return {
+			agentUserId,
+			peerUserId,
+			peerDisplayName
+		};
+	}
+	scheduleSpacePoll(state) {
+		if (!this.running) return;
+		const interval = this.computeInterval(state);
+		state.pollTimer = setTimeout(() => {
+			this.pollSpace(state).catch((err) => {
+				this.handleApiError(err, `poll:${state.spaceName}`);
+			}).finally(() => {
+				this.scheduleSpacePoll(state);
+			});
+		}, interval);
+	}
+	async pollSpace(state) {
+		if (!this.running) return;
+		const token = await this.tokenManager.getAccessToken();
+		let messages;
+		try {
+			messages = await listMessages(token, state.spaceName, state.lastSeenTimestamp, this.log);
+		} catch (err) {
+			if (isHttpStatus(err, 401)) {
+				this.tokenManager.invalidate();
+				let freshToken;
+				try {
+					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();
+					return;
+				}
+				messages = await listMessages(freshToken, state.spaceName, state.lastSeenTimestamp, this.log);
+			} else throw err;
+		}
+		const seenSet = this.seenMessages.get(state.spaceName) ?? /* @__PURE__ */ new Set();
+		for (const msg of messages) {
+			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);
+			}
+			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);
+		}
+	}
+	async dispatchMessage(message, state) {
+		if (!this.dispatchInbound || !this.runtime) {
+			this.log.warn("Cannot dispatch — SDK or runtime not available");
+			return;
+		}
+		const conversationId = `alfe:gchat:${state.spaceName}`;
+		const peerLabel = state.peerDisplayName ?? "User";
+		this.log.info(`Dispatching message from ${peerLabel} in ${state.spaceName}`);
+		try {
+			const cfg = this.runtime.config.loadConfig();
+			await this.dispatchInbound({
+				cfg,
+				runtime: { channel: this.runtime.channel },
+				channel: "alfe",
+				channelLabel: "Google Chat",
+				accountId: "default",
+				peer: {
+					kind: "direct",
+					id: `gchat:${state.peerUserId}:conv:${conversationId}`
+				},
+				senderId: `gchat:${state.peerUserId}`,
+				senderAddress: `user:gchat:${state.peerUserId}`,
+				recipientAddress: "agent",
+				conversationLabel: `[Google Chat] ${peerLabel}`,
+				rawBody: message.text,
+				messageId: message.name,
+				timestamp: new Date(message.createTime).getTime(),
+				extraContext: {
+					ChannelMode: "gchat",
+					ConversationId: conversationId,
+					...state.peerDisplayName ? { SenderName: state.peerDisplayName } : {}
+				},
+				deliver: async (payload) => {
+					const text = payload.text ?? "";
+					if (!text) return;
+					try {
+						await sendMessage(await this.tokenManager.getAccessToken(), state.spaceName, text);
+					} catch (err) {
+						if (isHttpStatus(err, 401)) {
+							this.tokenManager.invalidate();
+							try {
+								await sendMessage(await this.tokenManager.getAccessToken(), state.spaceName, text);
+							} catch (refreshErr) {
+								this.log.error(`Token refresh failed during reply: ${refreshErr instanceof Error ? refreshErr.message : String(refreshErr)}`);
+								throw refreshErr;
+							}
+						} else throw err;
+					}
+				},
+				onRecordError: (err) => {
+					this.log.error(`Session error: ${err instanceof Error ? err.message : String(err)}`);
+				},
+				onDispatchError: (err, info) => {
+					this.log.error(`Dispatch error (${info.kind}): ${err instanceof Error ? err.message : String(err)}`);
+				}
+			});
+		} catch (err) {
+			this.log.error(`Failed to dispatch message: ${err instanceof Error ? err.message : String(err)}`);
+		}
+	}
+	computeInterval(state) {
+		if (state.lastMessageAt === 0) return INTERVAL_IDLE_MS;
+		const elapsed = Date.now() - state.lastMessageAt;
+		if (elapsed < ACTIVE_THRESHOLD_MS) return INTERVAL_ACTIVE_MS;
+		if (elapsed < WARM_THRESHOLD_MS) return INTERVAL_WARM_MS;
+		if (elapsed < DORMANT_THRESHOLD_MS) return INTERVAL_IDLE_MS;
+		return INTERVAL_DORMANT_MS;
+	}
+	retryCount = 0;
+	handleApiError(err, context) {
+		if (isHttpStatus(err, 403) || isTokenRevokedError(err)) {
+			this.log.error(`Token revoked or forbidden (${context}) — stopping poller`);
+			this.stop();
+			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.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();
+			return;
+		}
+		this.retryCount = 0;
+		this.log.error(`API error in ${context}: ${err instanceof Error ? err.message : String(err)}`);
+	}
+};
+function isHttpStatus(err, status) {
+	return typeof err === "object" && err !== null && "status" in err && err.status === status;
+}
+function isTokenRevokedError(err) {
+	if (!(err instanceof Error)) return false;
+	return err.message.includes("invalid_grant") || err.message.includes("Token has been revoked");
+}
+//#endregion
+//#region src/plugin.ts
+/**
+* @alfe.ai/openclaw-google-chat — OpenClaw Google Chat channel plugin.
+*
+* Polls Google Chat DM spaces and dispatches user messages through
+* OpenClaw's auto-reply pipeline via dispatchInboundDirectDmWithRuntime().
+* Replies are sent back to Google Chat as the connected user.
+*
+* Architecture:
+*   Google Chat API (poll every 1-30s)
+*     → GChatPoller
+*       → 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;
+let poller = null;
+const plugin = {
+	id: "@alfe.ai/openclaw-google-chat",
+	name: "Google Chat",
+	description: "Google Chat DM polling — receive and reply via connected Google account",
+	version: pkg.version,
+	activate(api) {
+		const log = api.logger;
+		if (globalThis.__alfeGoogleChatActivated) return;
+		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) {
+				log.error(`Failed to resolve config: ${err instanceof Error ? err.message : String(err)}`);
+				return;
+			}
+			let creds;
+			try {
+				creds = await client.getGoogleChatCredentials();
+			} catch {
+				log.info("Google Chat not connected — polling disabled");
+				return;
+			}
+			poller = new GChatPoller({
+				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
+			});
+			await poller.start();
+			log.info(`Google Chat poller started (account: ${creds.email})`);
+		};
+		const stopService = () => {
+			globalThis.__alfeGoogleChatActivated = false;
+			poller?.stop();
+			poller = null;
+			pluginRuntime = null;
+			dispatchInbound = null;
+			log.info("Google Chat plugin stopped");
+		};
+		if (api.registerService) api.registerService({
+			id: "google-chat-poller",
+			start: () => {
+				startService().catch((err) => {
+					log.error(`Google Chat service start failed: ${err instanceof Error ? err.message : String(err)}`);
+				});
+			},
+			stop: () => {
+				stopService();
+			}
+		});
+		else startService().catch((err) => {
+			log.error(`Failed to start: ${err instanceof Error ? err.message : String(err)}`);
+		});
+		log.info("Google Chat plugin registered");
+	},
+	deactivate(api) {
+		globalThis.__alfeGoogleChatActivated = false;
+		const log = api.logger;
+		poller?.stop();
+		poller = null;
+		pluginRuntime = null;
+		dispatchInbound = null;
+		log.info("Google Chat plugin deactivated");
+	}
+};
+//#endregion
+export { plugin as t };

package/openclaw.plugin.json

@@ -1,18 +1,11 @@
 {
   "id": "@alfe.ai/openclaw-google-chat",
-  "channels": ["google-chat"],
+  "name": "Google Chat",
+  "description": "Google Chat DM polling — receive and reply to direct messages via connected Google account",
+  "entry": "./dist/plugin.js",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,
-    "properties": {
-      "workspaceDomain": {
-        "type": "string",
-        "description": "Connected Google Workspace domain"
-      },
-      "email": {
-        "type": "string",
-        "description": "Google account email for this agent"
-      }
-    }
+    "properties": {}
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@alfe.ai/openclaw-google-chat",
-  "version": "0.0.3",
-  "description": "OpenClaw Google Chat channel plugin — registers Google Chat as a messaging channel",
+  "version": "0.0.4",
+  "description": "OpenClaw Google Chat plugin — DM polling and auto-reply via connected Google account",
   "type": "module",
   "main": "./dist/plugin.js",
   "types": "./dist/index.d.ts",
@@ -26,6 +26,10 @@
     "dist",
     "openclaw.plugin.json"
   ],
+  "dependencies": {
+    "@alfe.ai/agent-api-client": "^0.0.12",
+    "@alfe.ai/config": "^0.0.8"
+  },
   "peerDependencies": {
     "openclaw": ">=2026.3.0"
   },
@@ -38,6 +42,7 @@
   "scripts": {
     "build": "tsdown",
     "dev": "tsdown --watch",
+    "test": "vitest run --passWithNoTests",
     "typecheck": "tsc --noEmit",
     "lint": "eslint ."
   }

package/dist/google-chat-channel.cjs

@@ -1,81 +0,0 @@
-//#region src/google-chat-channel.ts
-/**
-* Google Chat channel registration for OpenClaw.
-*
-* Follows the same ChannelPlugin shape as alfe-channel.ts in openclaw-chat.
-* This is metadata-only — no transport. The backend service handles all messaging.
-*
-* All config methods return sensible defaults because Google Chat is entirely
-* backend-managed — there is no local openclaw.yaml config for this channel.
-*/
-const DEFAULT_ACCOUNT_ID = "default";
-function createGoogleChatChannelPlugin() {
-	return {
-		id: "google-chat",
-		meta: {
-			id: "google-chat",
-			label: "Google Chat",
-			description: "Google Workspace Chat — spaces, DMs, and threads",
-			systemImage: "google-chat"
-		},
-		capabilities: {
-			chatTypes: ["direct", "group"],
-			threads: true,
-			reactions: true,
-			edit: false,
-			unsend: false,
-			reply: true,
-			media: false,
-			nativeCommands: false
-		},
-		outbound: { deliveryMode: "gateway" },
-		config: {
-			listAccountIds() {
-				return [DEFAULT_ACCOUNT_ID];
-			},
-			resolveAccount(_cfg, accountId) {
-				return {
-					accountId: accountId ?? DEFAULT_ACCOUNT_ID,
-					enabled: true,
-					allowFrom: []
-				};
-			},
-			defaultAccountId() {
-				return DEFAULT_ACCOUNT_ID;
-			},
-			isEnabled(account) {
-				return account.enabled;
-			},
-			isConfigured() {
-				return true;
-			},
-			describeAccount(account) {
-				return {
-					accountId: account.accountId,
-					enabled: account.enabled,
-					configured: true,
-					dmPolicy: account.dmPolicy
-				};
-			},
-			resolveAllowFrom() {
-				return [];
-			},
-			resolveDefaultTo() {}
-		},
-		setup: {
-			resolveAccountId(params) {
-				return params.accountId ?? DEFAULT_ACCOUNT_ID;
-			},
-			applyAccountConfig(params) {
-				return params.cfg;
-			}
-		}
-	};
-}
-//#endregion
-Object.defineProperty(exports, "createGoogleChatChannelPlugin", {
-	enumerable: true,
-	get: function() {
-		return createGoogleChatChannelPlugin;
-	}
-});