@alfe.ai/openclaw-google 0.0.41 → 0.0.42

package/dist/plugin2.cjs

@@ -0,0 +1,543 @@
+let node_child_process = require("node:child_process");
+let node_module = require("node:module");
+let node_os = require("node:os");
+let _sinclair_typebox = require("@sinclair/typebox");
+let _alfe_ai_config = require("@alfe.ai/config");
+let _alfe_ai_agent_api_client = require("@alfe.ai/agent-api-client");
+let _alfe_ai_openclaw_plugin_kit = require("@alfe.ai/openclaw-plugin-kit");
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+//#region src/boundary.ts
+const MAX_ACCOUNTS = 128;
+const MAX_EMAIL_CHARS = 320;
+const MAX_DISPLAY_NAME_CHARS = 512;
+const MAX_COMMAND_CHARS = 64 * 1024;
+const MAX_COMMAND_ARGS = 256;
+const MAX_FILE_PATH_CHARS = 8192;
+const MAX_TOOL_OUTPUT_BYTES = 256 * 1024;
+const EMAIL_PATTERN$1 = /^[A-Za-z0-9.!#$%&'*+/=?^_`{|}~-]+@[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?(?:\.[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?)*$/u;
+const DESTRUCTIVE_METHODS = new Set([
+	"batchclear",
+	"batchdelete",
+	"clear",
+	"delete",
+	"emptytrash",
+	"purge",
+	"remove",
+	"trash",
+	"wipe"
+]);
+const FILE_FLAGS = new Set(["--output", "--upload"]);
+const CHILD_ENV_ALLOWLIST = [
+	"HOME",
+	"HTTP_PROXY",
+	"HTTPS_PROXY",
+	"LANG",
+	"LC_ALL",
+	"LC_CTYPE",
+	"NO_PROXY",
+	"PATH",
+	"SSL_CERT_DIR",
+	"SSL_CERT_FILE",
+	"TZ"
+];
+function normalizeGoogleAccounts(value, homeDirectory = (0, node_os.homedir)()) {
+	const root = requireRecord(value, "Google accounts response");
+	if (!Array.isArray(root.accounts) || root.accounts.length > MAX_ACCOUNTS) throw new Error(`Google accounts response must contain at most ${String(MAX_ACCOUNTS)} accounts`);
+	const selectors = /* @__PURE__ */ new Set();
+	const configDirectories = /* @__PURE__ */ new Set();
+	return root.accounts.map((raw, index) => {
+		const account = requireRecord(raw, `Google account ${String(index)}`);
+		const email = validateGoogleEmail(account.email, "Google account email");
+		const selector = email.toLowerCase();
+		if (selectors.has(selector)) throw new Error("Google accounts response contains a duplicate email");
+		selectors.add(selector);
+		const configDir = resolveConfigDir(email, homeDirectory);
+		const configKey = configDir.toLowerCase();
+		if (configDirectories.has(configKey)) throw new Error("Google account emails map to an ambiguous gws config directory");
+		configDirectories.add(configKey);
+		return {
+			email,
+			displayName: optionalDisplayText(account.displayName, "Google account display name"),
+			connectedAt: optionalConnectedAt(account.connectedAt),
+			configDir
+		};
+	});
+}
+function normalizeAccountSelector(value) {
+	return validateGoogleEmail(value, "Google account selector").toLowerCase();
+}
+function sanitizeEmail(email) {
+	return validateGoogleEmail(email, "Google account email").replace(/@/gu, "-").replace(/\./gu, "-");
+}
+function resolveConfigDir(email, homeDirectory = (0, node_os.homedir)()) {
+	return (0, node_path.join)(homeDirectory, ".config", `gws-${sanitizeEmail(email)}`);
+}
+function parseGwsCommand(value, confirmation) {
+	const command = requireBoundedString(value, "command", MAX_COMMAND_CHARS).trim();
+	if (!command) throw new Error("Command cannot be empty");
+	if (hasControlCharacter(command)) throw new Error("Command cannot contain control characters");
+	const args = tokenizeCommand(command);
+	if (args.length === 0) throw new Error("Command cannot be empty");
+	if (args.length > MAX_COMMAND_ARGS) throw new Error(`Command cannot contain more than ${String(MAX_COMMAND_ARGS)} arguments`);
+	if (args[0]?.toLowerCase() === "auth") throw new Error("Authentication commands are managed by the Google integration");
+	const positional = args.slice(0, args.findIndex((arg) => arg.startsWith("--")) === -1 ? args.length : args.findIndex((arg) => arg.startsWith("--")));
+	const destructive = !args.includes("--dry-run") && positional.some((arg) => DESTRUCTIVE_METHODS.has(arg.toLowerCase()));
+	if (destructive && confirmation !== command) throw new Error("confirmCommand must exactly match command for a destructive gws operation");
+	return {
+		command,
+		args,
+		destructive
+	};
+}
+function confineGwsFileArguments(args, workspacePath) {
+	let workspaceRealPath;
+	try {
+		workspaceRealPath = (0, node_fs.realpathSync)(workspacePath);
+	} catch {
+		throw new Error("Configured workspace is unavailable");
+	}
+	if (!(0, node_fs.statSync)(workspaceRealPath).isDirectory()) throw new Error("Configured workspace path is not a directory");
+	const rewritten = [...args];
+	for (let index = 0; index < rewritten.length; index += 1) {
+		const argument = rewritten.at(index);
+		if (argument === void 0) continue;
+		const equalIndex = argument.indexOf("=");
+		const flag = equalIndex === -1 ? argument : argument.slice(0, equalIndex);
+		if (!FILE_FLAGS.has(flag)) continue;
+		const inlineValue = equalIndex === -1 ? void 0 : argument.slice(equalIndex + 1);
+		const valueIndex = inlineValue === void 0 ? index + 1 : index;
+		const rawPath = inlineValue ?? rewritten.at(valueIndex);
+		if (rawPath === void 0 || rawPath.length === 0 || rawPath.startsWith("--")) throw new Error(`${flag} requires a workspace-relative file path`);
+		const confined = flag === "--upload" ? confineUploadPath(rawPath, workspaceRealPath) : confineOutputPath(rawPath, workspaceRealPath);
+		if (inlineValue === void 0) {
+			rewritten[valueIndex] = confined;
+			index = valueIndex;
+		} else rewritten[index] = `${flag}=${confined}`;
+	}
+	return {
+		args: rewritten,
+		workspacePath: workspaceRealPath
+	};
+}
+function buildGwsEnvironment(configDir, source = process.env) {
+	const environment = Object.create(null);
+	for (const name of CHILD_ENV_ALLOWLIST) {
+		const value = source[name];
+		if (value !== void 0 && !hasControlCharacter(value)) environment[name] = value;
+	}
+	environment.GOOGLE_WORKSPACE_CLI_CONFIG_DIR = requireBoundedString(configDir, "gws config directory", MAX_FILE_PATH_CHARS);
+	if (hasControlCharacter(environment.GOOGLE_WORKSPACE_CLI_CONFIG_DIR)) throw new Error("gws config directory cannot contain control characters");
+	return environment;
+}
+function boundToolOutput(value) {
+	const buffer = Buffer.from(typeof value === "string" ? value : "", "utf8");
+	if (buffer.byteLength <= 262144) return {
+		text: buffer.toString("utf8"),
+		truncated: false
+	};
+	return {
+		text: `${buffer.subarray(0, MAX_TOOL_OUTPUT_BYTES).toString("utf8")}\n[output truncated]`,
+		truncated: true
+	};
+}
+function safeGwsDiagnostic(value, secrets = []) {
+	let redacted = value.slice(0, 4096).replace(/\b(Bearer|Basic)\s+\S+/giu, "$1 [REDACTED]").replace(/\b(api[_-]?key|access[_-]?token|refresh[_-]?token|client[_-]?secret|password)\s*[=:]\s*\S+/giu, "$1=[REDACTED]").replace(/\balfe_[A-Za-z0-9_-]{8,}/gu, "[REDACTED]");
+	for (const secret of secrets) if (secret.length >= 4) redacted = redacted.split(secret).join("[REDACTED]");
+	let flattened = "";
+	for (const character of redacted) {
+		const codePoint = character.codePointAt(0) ?? 0;
+		flattened += codePoint < 32 || codePoint === 127 ? " " : character;
+	}
+	return flattened.trim();
+}
+function tokenizeCommand(command) {
+	const args = [];
+	let current = "";
+	let tokenStarted = false;
+	let quote = null;
+	let escaped = false;
+	for (const character of command) {
+		if (escaped) {
+			current += character;
+			tokenStarted = true;
+			escaped = false;
+			continue;
+		}
+		if (quote === "single") {
+			if (character === "'") quote = null;
+			else current += character;
+			tokenStarted = true;
+			continue;
+		}
+		if (quote === "double") {
+			if (character === "\"") quote = null;
+			else if (character === "\\") escaped = true;
+			else current += character;
+			tokenStarted = true;
+			continue;
+		}
+		if (character === "'") {
+			quote = "single";
+			tokenStarted = true;
+		} else if (character === "\"") {
+			quote = "double";
+			tokenStarted = true;
+		} else if (character === "\\") {
+			escaped = true;
+			tokenStarted = true;
+		} else if (/\s/u.test(character)) {
+			if (tokenStarted) {
+				args.push(current);
+				current = "";
+				tokenStarted = false;
+			}
+		} else {
+			current += character;
+			tokenStarted = true;
+		}
+	}
+	if (quote !== null || escaped) throw new Error("Command contains an unterminated quote or escape");
+	if (tokenStarted) args.push(current);
+	return args;
+}
+function confineUploadPath(value, workspaceRealPath) {
+	const candidate = resolveCandidatePath(value, workspaceRealPath);
+	try {
+		if ((0, node_fs.lstatSync)(candidate).isSymbolicLink()) throw new Error("unsafe upload");
+		const realCandidate = (0, node_fs.realpathSync)(candidate);
+		if (!isWithin(workspaceRealPath, realCandidate) || !(0, node_fs.statSync)(realCandidate).isFile()) throw new Error("unsafe upload");
+		return realCandidate;
+	} catch {
+		throw new Error("Upload path must be a regular file inside the configured workspace");
+	}
+}
+function confineOutputPath(value, workspaceRealPath) {
+	const candidate = resolveCandidatePath(value, workspaceRealPath);
+	let parent;
+	try {
+		parent = (0, node_fs.realpathSync)((0, node_path.dirname)(candidate));
+	} catch {
+		throw new Error("Output path must have an existing directory inside the configured workspace");
+	}
+	if (!isWithin(workspaceRealPath, parent)) throw new Error("Output path must stay inside the configured workspace");
+	try {
+		const status = (0, node_fs.lstatSync)(candidate);
+		if (status.isSymbolicLink() || status.isDirectory()) throw new Error("Output path must be a non-symlink file inside the configured workspace");
+		if (!isWithin(workspaceRealPath, (0, node_fs.realpathSync)(candidate))) throw new Error("Output path must stay inside the configured workspace");
+	} catch (error) {
+		if ((isRecord(error) ? error.code : void 0) !== "ENOENT") throw new Error("Output path must be a non-symlink file inside the configured workspace");
+	}
+	return candidate;
+}
+function resolveCandidatePath(value, workspaceRealPath) {
+	const rawPath = requireBoundedString(value, "gws file path", MAX_FILE_PATH_CHARS);
+	if (hasControlCharacter(rawPath)) throw new Error("gws file path cannot contain control characters");
+	return (0, node_path.isAbsolute)(rawPath) ? (0, node_path.resolve)(rawPath) : (0, node_path.resolve)(workspaceRealPath, rawPath);
+}
+function isWithin(root, candidate) {
+	const child = (0, node_path.relative)(root, candidate);
+	return child === "" || !(0, node_path.isAbsolute)(child) && child !== ".." && !child.startsWith(`..${node_path.sep}`);
+}
+function validateGoogleEmail(value, label) {
+	const email = requireBoundedString(value, label, MAX_EMAIL_CHARS);
+	if (email !== email.trim() || email.includes("/") || email.includes("\\") || !EMAIL_PATTERN$1.test(email)) throw new Error(`${label} is invalid`);
+	return email;
+}
+function optionalDisplayText(value, label) {
+	if (value === void 0 || value === null) return void 0;
+	const text = requireBoundedString(value, label, MAX_DISPLAY_NAME_CHARS);
+	if (hasControlCharacter(text)) throw new Error(`${label} contains control characters`);
+	return text;
+}
+function optionalConnectedAt(value) {
+	if (value === void 0 || value === null) return void 0;
+	const connectedAt = requireBoundedString(value, "Google account connectedAt", 128);
+	if (Number.isNaN(Date.parse(connectedAt))) throw new Error("Google account connectedAt is invalid");
+	return connectedAt;
+}
+function requireBoundedString(value, label, maxLength) {
+	if (typeof value !== "string" || value.length < 1 || value.length > maxLength) throw new Error(`${label} must be a non-empty string of at most ${String(maxLength)} characters`);
+	return value;
+}
+function requireRecord(value, label) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error(`${label} must be an object`);
+	return value;
+}
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function hasControlCharacter(value) {
+	for (const character of value) {
+		const codePoint = character.codePointAt(0) ?? 0;
+		if (codePoint < 32 || codePoint === 127) return true;
+	}
+	return false;
+}
+const PLUGIN_VERSION = validatePackageVersion((0, node_module.createRequire)(require("url").pathToFileURL(__filename).href)("../package.json").version);
+const GOOGLE_ACTIVATION_KEY = (0, _alfe_ai_openclaw_plugin_kit.getActivationKey)("google");
+const RUNTIME_STATE_KEY = "__alfeGooglePluginRuntimeState";
+const GWS_TIMEOUT_MS = 6e4;
+const GWS_MAX_BUFFER_BYTES = 1024 * 1024;
+const EMAIL_PATTERN = "^[A-Za-z0-9.!#$%&'*+/=?^_`{|}~-]+@[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?(?:\\.[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?)*$";
+function createGooglePluginRuntimeState() {
+	return {
+		client: null,
+		workspacePath: null,
+		accounts: [],
+		refreshPromise: null,
+		generation: 0
+	};
+}
+function createGooglePlugin(dependencies = {}) {
+	const resolveRuntimeConfig = dependencies.resolveConfig ?? _alfe_ai_config.resolveConfig;
+	const createClient = dependencies.createClient ?? ((config) => new _alfe_ai_agent_api_client.AgentApiClient(config));
+	const executeGws = dependencies.executeGws ?? executeGwsCommand;
+	const installErrorCapture = dependencies.installErrorCapture ?? _alfe_ai_agent_api_client.installToolErrorCapture;
+	const homeDirectory = dependencies.homeDirectory ?? (0, node_os.homedir)();
+	const getState = () => dependencies.runtimeState ?? getGlobalRuntimeState();
+	const ensureClient = () => {
+		const state = getState();
+		if (state.client === null || state.workspacePath === null) {
+			const config = resolveRuntimeConfig();
+			state.client = createClient({
+				apiKey: config.apiKey,
+				apiUrl: config.apiUrl
+			});
+			state.workspacePath = config.workspacePath;
+		}
+		return {
+			client: state.client,
+			workspacePath: state.workspacePath
+		};
+	};
+	const refreshAccounts = async () => {
+		const state = getState();
+		if (state.refreshPromise !== null) return state.refreshPromise;
+		const { client } = ensureClient();
+		const generation = state.generation;
+		const refresh = client.getGoogleCredentials().then((value) => {
+			const accounts = normalizeGoogleAccounts(value, homeDirectory);
+			if (state.generation === generation && state.client === client) state.accounts = accounts;
+			return accounts;
+		});
+		state.refreshPromise = refresh;
+		try {
+			return await refresh;
+		} finally {
+			if (state.refreshPromise === refresh) state.refreshPromise = null;
+		}
+	};
+	const resolveAccount = async (value) => {
+		const selector = normalizeAccountSelector(value);
+		let account = getState().accounts.find((candidate) => candidate.email.toLowerCase() === selector);
+		if (account === void 0) account = (await refreshAccounts()).find((candidate) => candidate.email.toLowerCase() === selector);
+		if (account === void 0) throw (0, _alfe_ai_openclaw_plugin_kit.publicToolError)("Google account not found; call google_list_accounts first");
+		return account;
+	};
+	const tools = [
+		(0, _alfe_ai_openclaw_plugin_kit.defineTool)({
+			name: "google_list_accounts",
+			description: "List connected Google Workspace accounts. Use this before a credential-touching tool when the exact account email is not already known.",
+			parameters: _sinclair_typebox.Type.Object({}, { additionalProperties: false }),
+			handler: async () => {
+				const accounts = await refreshAccounts();
+				return {
+					accounts: accounts.map(({ email, displayName, connectedAt }) => ({
+						email,
+						displayName,
+						connectedAt
+					})),
+					count: accounts.length
+				};
+			}
+		}),
+		(0, _alfe_ai_openclaw_plugin_kit.defineTool)({
+			name: "google_run_command",
+			description: "Run a Google Workspace CLI command for one explicitly selected account. The command supports quoted JSON exactly like gws (for example: drive files list --params '{\"pageSize\": 10}'). Authentication commands are blocked. --upload and --output paths must remain inside the configured workspace. Use --dry-run to preview mutations; otherwise copy an exact destructive command into confirmCommand when requested.",
+			parameters: _sinclair_typebox.Type.Object({
+				command: _sinclair_typebox.Type.String({
+					description: "gws arguments without the leading gws executable",
+					minLength: 1,
+					maxLength: MAX_COMMAND_CHARS
+				}),
+				email: _sinclair_typebox.Type.String({
+					description: "Exact email returned by google_list_accounts",
+					minLength: 3,
+					maxLength: 320,
+					pattern: EMAIL_PATTERN
+				}),
+				confirmCommand: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String({
+					description: "Exact command, required for destructive methods unless --dry-run is present",
+					minLength: 1,
+					maxLength: MAX_COMMAND_CHARS
+				}))
+			}, { additionalProperties: false }),
+			handler: async (params) => {
+				let parsed;
+				try {
+					parsed = parseGwsCommand(params.command, params.confirmCommand);
+				} catch (error) {
+					throw (0, _alfe_ai_openclaw_plugin_kit.publicToolError)(error instanceof Error ? error.message : "Invalid Google Workspace command");
+				}
+				const account = await resolveAccount(params.email);
+				const { workspacePath } = ensureClient();
+				const result = await executeGws({
+					args: parsed.args,
+					configDir: account.configDir,
+					workspacePath
+				});
+				if (result.exitCode !== 0) {
+					const diagnostic = safeGwsDiagnostic(result.stderr || result.stdout, [account.configDir, workspacePath]);
+					return {
+						status: "error",
+						error: `gws command failed with exit code ${String(result.exitCode)}`,
+						...diagnostic ? { diagnostic } : {},
+						truncated: result.truncated
+					};
+				}
+				return {
+					account: account.email,
+					command: `gws ${parsed.command}`,
+					...result
+				};
+			}
+		}),
+		(0, _alfe_ai_openclaw_plugin_kit.defineTool)({
+			name: "google_disconnect_account",
+			description: "Permanently disconnect one Google account from this agent. Copy the exact account email into confirmEmail only after the user approves.",
+			parameters: _sinclair_typebox.Type.Object({
+				email: _sinclair_typebox.Type.String({
+					description: "Exact email returned by google_list_accounts",
+					minLength: 3,
+					maxLength: 320,
+					pattern: EMAIL_PATTERN
+				}),
+				confirmEmail: _sinclair_typebox.Type.String({
+					description: "Exact selected account email confirming permanent disconnect",
+					minLength: 3,
+					maxLength: 320,
+					pattern: EMAIL_PATTERN
+				})
+			}, { additionalProperties: false }),
+			handler: async (params) => {
+				const account = await resolveAccount(params.email);
+				if (params.confirmEmail !== account.email) throw (0, _alfe_ai_openclaw_plugin_kit.publicToolError)("confirmEmail must exactly match the selected Google account email");
+				const { client } = ensureClient();
+				const result = await client.disconnectGoogleAccount(account.email);
+				let remaining;
+				let refreshRequired = false;
+				try {
+					remaining = normalizeGoogleAccounts(result, homeDirectory);
+				} catch {
+					remaining = [];
+					refreshRequired = true;
+				}
+				getState().accounts = remaining;
+				return {
+					message: `${account.email} has been disconnected`,
+					remainingAccounts: remaining.map(({ email, displayName, connectedAt }) => ({
+						email,
+						displayName,
+						connectedAt
+					})),
+					...refreshRequired ? { refreshRequired: true } : {}
+				};
+			}
+		})
+	];
+	const stop = (log, message) => {
+		const state = getState();
+		state.generation += 1;
+		state.client = null;
+		state.workspacePath = null;
+		state.accounts = [];
+		state.refreshPromise = null;
+		(0, _alfe_ai_openclaw_plugin_kit.resetActivation)(GOOGLE_ACTIVATION_KEY);
+		log.info(message);
+	};
+	return {
+		id: "@alfe.ai/openclaw-google",
+		name: "Alfe Google Workspace Plugin",
+		description: "Multi-account Google Workspace management with an explicit account selector",
+		version: PLUGIN_VERSION,
+		activate(api) {
+			installErrorCapture(api, { plugin: "openclaw-google" });
+			for (const tool of tools) api.registerTool(tool);
+			api.logger.info(`Registered ${String(tools.length)} Google tools: ${tools.map((tool) => tool.name).join(", ")}`);
+			api.registerService?.({
+				id: "alfe-google-workspace",
+				start: () => {
+					(0, _alfe_ai_openclaw_plugin_kit.guardedStart)(GOOGLE_ACTIVATION_KEY, api.logger, async () => {
+						const state = getState();
+						state.generation += 1;
+						ensureClient();
+						try {
+							const accounts = await refreshAccounts();
+							api.logger.info(`Cached ${String(accounts.length)} Google account(s)`);
+						} catch {
+							api.logger.warn("Google account pre-cache failed; tools will retry on demand");
+						}
+						api.logger.info("Alfe Google Workspace plugin activated");
+					});
+				},
+				stop: () => {
+					stop(api.logger, "Alfe Google Workspace plugin stopped");
+				}
+			});
+		},
+		deactivate(api) {
+			stop(api.logger, "Alfe Google Workspace plugin deactivated");
+		}
+	};
+}
+async function executeGwsCommand(options) {
+	const confined = confineGwsFileArguments(options.args, options.workspacePath);
+	const environment = buildGwsEnvironment(options.configDir);
+	return new Promise((resolveResult) => {
+		(0, node_child_process.execFile)("gws", confined.args, {
+			cwd: confined.workspacePath,
+			env: environment,
+			timeout: GWS_TIMEOUT_MS,
+			maxBuffer: GWS_MAX_BUFFER_BYTES,
+			windowsHide: true
+		}, (error, stdout, stderr) => {
+			const boundedStdout = boundToolOutput(stdout);
+			const boundedStderr = boundToolOutput(stderr || (error && typeof error.code === "string" ? "gws command could not be started" : ""));
+			resolveResult({
+				stdout: boundedStdout.text,
+				stderr: boundedStderr.text,
+				exitCode: typeof error?.code === "number" ? error.code : error ? 1 : 0,
+				truncated: boundedStdout.truncated || boundedStderr.truncated
+			});
+		});
+	});
+}
+function getGlobalRuntimeState() {
+	const globalRecord = globalThis;
+	const existing = globalRecord[RUNTIME_STATE_KEY];
+	if (isRuntimeState(existing)) return existing;
+	const state = createGooglePluginRuntimeState();
+	globalRecord[RUNTIME_STATE_KEY] = state;
+	return state;
+}
+function isRuntimeState(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+	const candidate = value;
+	return (candidate.client === null || typeof candidate.client === "object") && (candidate.workspacePath === null || typeof candidate.workspacePath === "string") && Array.isArray(candidate.accounts) && (candidate.refreshPromise === null || candidate.refreshPromise instanceof Promise) && typeof candidate.generation === "number";
+}
+function validatePackageVersion(value) {
+	if (typeof value !== "string" || !/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/u.test(value)) throw new Error("openclaw-google package version is invalid");
+	return value;
+}
+//#endregion
+//#region src/plugin.ts
+/** OpenClaw extension entry: default-only to preserve plugin loader interop. */
+const plugin = createGooglePlugin();
+//#endregion
+Object.defineProperty(exports, "plugin", {
+	enumerable: true,
+	get: function() {
+		return plugin;
+	}
+});