@openclaw/googlechat 2026.5.20 → 2026.5.22

package/node_modules/google-auth-library/build/src/crypto/crypto.d.ts

@@ -0,0 +1,8 @@
+import { Crypto } from './shared';
+export * from './shared';
+export interface CryptoSigner {
+    update(data: string): void;
+    sign(key: string, outputFormat: string): string;
+}
+export declare function createCrypto(): Crypto;
+export declare function hasBrowserCrypto(): boolean;

package/node_modules/google-auth-library/build/src/crypto/crypto.js

@@ -0,0 +1,54 @@
+"use strict";
+// Copyright 2019 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+/* global window */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCrypto = createCrypto;
+exports.hasBrowserCrypto = hasBrowserCrypto;
+const crypto_1 = require("./browser/crypto");
+const crypto_2 = require("./node/crypto");
+__exportStar(require("./shared"), exports);
+// Crypto interface will provide required crypto functions.
+// Use `createCrypto()` factory function to create an instance
+// of Crypto. It will either use Node.js `crypto` module, or
+// use browser's SubtleCrypto interface. Since most of the
+// SubtleCrypto methods return promises, we must make those
+// methods return promises here as well, even though in Node.js
+// they are synchronous.
+function createCrypto() {
+    if (hasBrowserCrypto()) {
+        return new crypto_1.BrowserCrypto();
+    }
+    return new crypto_2.NodeCrypto();
+}
+function hasBrowserCrypto() {
+    return (typeof window !== 'undefined' &&
+        typeof window.crypto !== 'undefined' &&
+        typeof window.crypto.subtle !== 'undefined');
+}
+//# sourceMappingURL=crypto.js.map

package/node_modules/google-auth-library/build/src/crypto/node/crypto.d.ts

@@ -0,0 +1,25 @@
+import { Crypto } from '../shared';
+export declare class NodeCrypto implements Crypto {
+    sha256DigestBase64(str: string): Promise<string>;
+    randomBytesBase64(count: number): string;
+    verify(pubkey: string, data: string | Buffer, signature: string): Promise<boolean>;
+    sign(privateKey: string, data: string | Buffer): Promise<string>;
+    decodeBase64StringUtf8(base64: string): string;
+    encodeBase64StringUtf8(text: string): string;
+    /**
+     * Computes the SHA-256 hash of the provided string.
+     * @param str The plain text string to hash.
+     * @return A promise that resolves with the SHA-256 hash of the provided
+     *   string in hexadecimal encoding.
+     */
+    sha256DigestHex(str: string): Promise<string>;
+    /**
+     * Computes the HMAC hash of a message using the provided crypto key and the
+     * SHA-256 algorithm.
+     * @param key The secret crypto key in utf-8 or ArrayBuffer format.
+     * @param msg The plain text message.
+     * @return A promise that resolves with the HMAC-SHA256 hash in ArrayBuffer
+     *   format.
+     */
+    signWithHmacSha256(key: string | ArrayBuffer, msg: string): Promise<ArrayBuffer>;
+}

package/node_modules/google-auth-library/build/src/crypto/node/crypto.js

@@ -0,0 +1,88 @@
+"use strict";
+// Copyright 2019 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeCrypto = void 0;
+const crypto = require("crypto");
+class NodeCrypto {
+    async sha256DigestBase64(str) {
+        return crypto.createHash('sha256').update(str).digest('base64');
+    }
+    randomBytesBase64(count) {
+        return crypto.randomBytes(count).toString('base64');
+    }
+    async verify(pubkey, data, signature) {
+        const verifier = crypto.createVerify('RSA-SHA256');
+        verifier.update(data);
+        verifier.end();
+        return verifier.verify(pubkey, signature, 'base64');
+    }
+    async sign(privateKey, data) {
+        const signer = crypto.createSign('RSA-SHA256');
+        signer.update(data);
+        signer.end();
+        return signer.sign(privateKey, 'base64');
+    }
+    decodeBase64StringUtf8(base64) {
+        return Buffer.from(base64, 'base64').toString('utf-8');
+    }
+    encodeBase64StringUtf8(text) {
+        return Buffer.from(text, 'utf-8').toString('base64');
+    }
+    /**
+     * Computes the SHA-256 hash of the provided string.
+     * @param str The plain text string to hash.
+     * @return A promise that resolves with the SHA-256 hash of the provided
+     *   string in hexadecimal encoding.
+     */
+    async sha256DigestHex(str) {
+        return crypto.createHash('sha256').update(str).digest('hex');
+    }
+    /**
+     * Computes the HMAC hash of a message using the provided crypto key and the
+     * SHA-256 algorithm.
+     * @param key The secret crypto key in utf-8 or ArrayBuffer format.
+     * @param msg The plain text message.
+     * @return A promise that resolves with the HMAC-SHA256 hash in ArrayBuffer
+     *   format.
+     */
+    async signWithHmacSha256(key, msg) {
+        const cryptoKey = typeof key === 'string' ? key : toBuffer(key);
+        return toArrayBuffer(crypto.createHmac('sha256', cryptoKey).update(msg).digest());
+    }
+}
+exports.NodeCrypto = NodeCrypto;
+/**
+ * Converts a Node.js Buffer to an ArrayBuffer.
+ * https://stackoverflow.com/questions/8609289/convert-a-binary-nodejs-buffer-to-javascript-arraybuffer
+ * @param buffer The Buffer input to covert.
+ * @return The ArrayBuffer representation of the input.
+ */
+function toArrayBuffer(buffer) {
+    const ab = new ArrayBuffer(buffer.length);
+    const view = new Uint8Array(ab);
+    for (let i = 0; i < buffer.length; ++i) {
+        view[i] = buffer[i];
+    }
+    return ab;
+}
+/**
+ * Converts an ArrayBuffer to a Node.js Buffer.
+ * @param arrayBuffer The ArrayBuffer input to covert.
+ * @return The Buffer representation of the input.
+ */
+function toBuffer(arrayBuffer) {
+    return Buffer.from(arrayBuffer);
+}
+//# sourceMappingURL=crypto.js.map

package/node_modules/google-auth-library/build/src/crypto/shared.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Crypto interface will provide required crypto functions.
+ * Use `createCrypto()` factory function to create an instance
+ * of Crypto. It will either use Node.js `crypto` module, or
+ * use browser's SubtleCrypto interface. Since most of the
+ * SubtleCrypto methods return promises, we must make those
+ * methods return promises here as well, even though in Node.js
+ * they are synchronous.
+ */
+export interface Crypto {
+    sha256DigestBase64(str: string): Promise<string>;
+    randomBytesBase64(n: number): string;
+    verify(pubkey: string | JwkCertificate, data: string | Buffer, signature: string): Promise<boolean>;
+    sign(privateKey: string | JwkCertificate, data: string | Buffer): Promise<string>;
+    decodeBase64StringUtf8(base64: string): string;
+    encodeBase64StringUtf8(text: string): string;
+    /**
+     * Computes the SHA-256 hash of the provided string.
+     * @param str The plain text string to hash.
+     * @return A promise that resolves with the SHA-256 hash of the provided
+     *   string in hexadecimal encoding.
+     */
+    sha256DigestHex(str: string): Promise<string>;
+    /**
+     * Computes the HMAC hash of a message using the provided crypto key and the
+     * SHA-256 algorithm.
+     * @param key The secret crypto key in utf-8 or ArrayBuffer format.
+     * @param msg The plain text message.
+     * @return A promise that resolves with the HMAC-SHA256 hash in ArrayBuffer
+     *   format.
+     */
+    signWithHmacSha256(key: string | ArrayBuffer, msg: string): Promise<ArrayBuffer>;
+}
+export interface JwkCertificate {
+    kty: string;
+    alg: string;
+    use?: string;
+    kid: string;
+    n: string;
+    e: string;
+}
+/**
+ * Converts an ArrayBuffer to a hexadecimal string.
+ * @param arrayBuffer The ArrayBuffer to convert to hexadecimal string.
+ * @return The hexadecimal encoding of the ArrayBuffer.
+ */
+export declare function fromArrayBufferToHex(arrayBuffer: ArrayBuffer): string;

package/node_modules/google-auth-library/build/src/crypto/shared.js

@@ -0,0 +1,32 @@
+"use strict";
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromArrayBufferToHex = fromArrayBufferToHex;
+/**
+ * Converts an ArrayBuffer to a hexadecimal string.
+ * @param arrayBuffer The ArrayBuffer to convert to hexadecimal string.
+ * @return The hexadecimal encoding of the ArrayBuffer.
+ */
+function fromArrayBufferToHex(arrayBuffer) {
+    // Convert buffer to byte array.
+    const byteArray = Array.from(new Uint8Array(arrayBuffer));
+    // Convert bytes to hex string.
+    return byteArray
+        .map(byte => {
+        return byte.toString(16).padStart(2, '0');
+    })
+        .join('');
+}
+//# sourceMappingURL=shared.js.map

package/node_modules/google-auth-library/build/src/gtoken/errorWithCode.d.ts

@@ -0,0 +1,5 @@
+declare class ErrorWithCode extends Error {
+    code: string;
+    constructor(message: string, code: string);
+}
+export { ErrorWithCode };

package/node_modules/google-auth-library/build/src/gtoken/errorWithCode.js

@@ -0,0 +1,25 @@
+"use strict";
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorWithCode = void 0;
+class ErrorWithCode extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+    }
+}
+exports.ErrorWithCode = ErrorWithCode;
+//# sourceMappingURL=errorWithCode.js.map

package/node_modules/google-auth-library/build/src/gtoken/getCredentials.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Credentials object.
+ */
+interface Credentials {
+    privateKey: string;
+    clientEmail?: string;
+}
+/**
+ * Given a keyFile, extract the key and client email if available
+ * @param keyFile Path to a json, pem, or p12 file that contains the key.
+ * @returns an object with privateKey and clientEmail properties
+ */
+declare function getCredentials(keyFilePath: string): Promise<Credentials>;
+export { getCredentials, Credentials };

package/node_modules/google-auth-library/build/src/gtoken/getCredentials.js

@@ -0,0 +1,132 @@
+"use strict";
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCredentials = getCredentials;
+const path = require("path");
+const fs = require("fs");
+const util_1 = require("util");
+const errorWithCode_1 = require("./errorWithCode");
+const readFile = fs.readFile
+    ? (0, util_1.promisify)(fs.readFile)
+    : async () => {
+        // if running in the web-browser, fs.readFile may not have been shimmed.
+        throw new errorWithCode_1.ErrorWithCode('use key rather than keyFile.', 'MISSING_CREDENTIALS');
+    };
+var ExtensionFiles;
+(function (ExtensionFiles) {
+    ExtensionFiles["JSON"] = ".json";
+    ExtensionFiles["DER"] = ".der";
+    ExtensionFiles["CRT"] = ".crt";
+    ExtensionFiles["PEM"] = ".pem";
+    ExtensionFiles["P12"] = ".p12";
+    ExtensionFiles["PFX"] = ".pfx";
+})(ExtensionFiles || (ExtensionFiles = {}));
+/**
+ * Provides credentials from a JSON key file.
+ */
+class JsonCredentialsProvider {
+    keyFilePath;
+    constructor(keyFilePath) {
+        this.keyFilePath = keyFilePath;
+    }
+    /**
+     * Reads a JSON key file and extracts the private key and client email.
+     * @returns A promise that resolves with the credentials.
+     */
+    async getCredentials() {
+        const key = await readFile(this.keyFilePath, 'utf8');
+        let body;
+        try {
+            body = JSON.parse(key);
+        }
+        catch (error) {
+            const err = error;
+            throw new Error(`Invalid JSON key file: ${err.message}`);
+        }
+        const privateKey = body.private_key;
+        const clientEmail = body.client_email;
+        if (!privateKey || !clientEmail) {
+            throw new errorWithCode_1.ErrorWithCode('private_key and client_email are required.', 'MISSING_CREDENTIALS');
+        }
+        return { privateKey, clientEmail };
+    }
+}
+/**
+ * Provides credentials from a PEM-like key file.
+ */
+class PemCredentialsProvider {
+    keyFilePath;
+    constructor(keyFilePath) {
+        this.keyFilePath = keyFilePath;
+    }
+    /**
+     * Reads a PEM-like key file.
+     * @returns A promise that resolves with the private key.
+     */
+    async getCredentials() {
+        const privateKey = await readFile(this.keyFilePath, 'utf8');
+        return { privateKey };
+    }
+}
+/**
+ * Handles unsupported P12/PFX certificate types.
+ */
+class P12CredentialsProvider {
+    /**
+     * Throws an error as P12/PFX certificates are not supported.
+     * @returns A promise that rejects with an error.
+     */
+    async getCredentials() {
+        throw new errorWithCode_1.ErrorWithCode('*.p12 certificates are not supported after v6.1.2. ' +
+            'Consider utilizing *.json format or converting *.p12 to *.pem using the OpenSSL CLI.', 'UNKNOWN_CERTIFICATE_TYPE');
+    }
+}
+/**
+ * Factory class to create the appropriate credentials provider.
+ */
+class CredentialsProviderFactory {
+    /**
+     * Creates a credential provider based on the key file extension.
+     * @param keyFilePath The path to the key file.
+     * @returns An instance of a class that implements ICredentialsProvider.
+     */
+    static create(keyFilePath) {
+        const keyFileExtension = path.extname(keyFilePath);
+        switch (keyFileExtension) {
+            case ExtensionFiles.JSON:
+                return new JsonCredentialsProvider(keyFilePath);
+            case ExtensionFiles.DER:
+            case ExtensionFiles.CRT:
+            case ExtensionFiles.PEM:
+                return new PemCredentialsProvider(keyFilePath);
+            case ExtensionFiles.P12:
+            case ExtensionFiles.PFX:
+                return new P12CredentialsProvider();
+            default:
+                throw new errorWithCode_1.ErrorWithCode('Unknown certificate type. Type is determined based on file extension. ' +
+                    'Current supported extensions are *.json, and *.pem.', 'UNKNOWN_CERTIFICATE_TYPE');
+        }
+    }
+}
+/**
+ * Given a keyFile, extract the key and client email if available
+ * @param keyFile Path to a json, pem, or p12 file that contains the key.
+ * @returns an object with privateKey and clientEmail properties
+ */
+async function getCredentials(keyFilePath) {
+    const provider = CredentialsProviderFactory.create(keyFilePath);
+    return provider.getCredentials();
+}
+//# sourceMappingURL=getCredentials.js.map

package/node_modules/google-auth-library/build/src/gtoken/getToken.d.ts

@@ -0,0 +1,23 @@
+import { TokenOptions } from './tokenOptions';
+/**
+ * Interface for the data returned from the token endpoint.
+ */
+interface TokenData {
+    /** An optional refresh token. */
+    refresh_token?: string;
+    /** The duration of the token in seconds. */
+    expires_in?: number;
+    /** The access token. */
+    access_token?: string;
+    /** The type of token, e.g., "Bearer". */
+    token_type?: string;
+    /** An optional ID token. */
+    id_token?: string;
+}
+/**
+ * Fetches an access token.
+ * @param tokenOptions The options for the token.
+ * @returns A promise that resolves with the token data.
+ */
+declare function getToken(tokenOptions: TokenOptions): Promise<TokenData>;
+export { getToken, TokenData };

package/node_modules/google-auth-library/build/src/gtoken/getToken.js

@@ -0,0 +1,66 @@
+"use strict";
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getToken = getToken;
+const jwsSign_1 = require("./jwsSign");
+/** The URL for Google's OAuth 2.0 token endpoint. */
+const GOOGLE_TOKEN_URL = 'https://oauth2.googleapis.com/token';
+/** The grant type for JWT-based authorization. */
+const GOOGLE_GRANT_TYPE = 'urn:ietf:params:oauth:grant-type:jwt-bearer';
+/**
+ * Generates the request options for fetching a token.
+ * @param tokenOptions The options for the token.
+ * @returns The Gaxios options for the request.
+ */
+const generateRequestOptions = (tokenOptions) => {
+    return {
+        method: 'POST',
+        url: GOOGLE_TOKEN_URL,
+        data: new URLSearchParams({
+            grant_type: GOOGLE_GRANT_TYPE, // Grant type for JWT
+            assertion: (0, jwsSign_1.getJwsSign)(tokenOptions),
+        }),
+        responseType: 'json',
+        retryConfig: {
+            httpMethodsToRetry: ['POST'],
+        },
+    };
+};
+/**
+ * Fetches an access token.
+ * @param tokenOptions The options for the token.
+ * @returns A promise that resolves with the token data.
+ */
+async function getToken(tokenOptions) {
+    if (!tokenOptions.transporter) {
+        throw new Error('No transporter set.');
+    }
+    try {
+        const gaxiosOptions = generateRequestOptions(tokenOptions);
+        const response = await tokenOptions.transporter.request(gaxiosOptions);
+        return response.data;
+    }
+    catch (e) {
+        // The error is re-thrown, but we want to format it to be more
+        // informative.
+        const err = e;
+        const errorData = err.response?.data;
+        if (errorData?.error) {
+            err.message = `${errorData.error}: ${errorData.error_description}`;
+        }
+        throw err;
+    }
+}
+//# sourceMappingURL=getToken.js.map

package/node_modules/google-auth-library/build/src/gtoken/googleToken.d.ts

@@ -0,0 +1,73 @@
+import { TokenOptions, Transporter } from './tokenOptions';
+import { TokenData } from './getToken';
+/**
+ * Options for fetching an access token.
+ */
+export interface GetTokenOptions {
+    /**
+     * If true, a new token will be fetched, ignoring any cached token.
+     */
+    forceRefresh?: boolean;
+}
+/**
+ * Callback type for the `getToken` method.
+ */
+export type GetTokenCallback = (err: Error | null, token?: TokenData) => void;
+/**
+ * The GoogleToken class is used to manage authentication with Google's OAuth 2.0 authorization server.
+ * It handles fetching, caching, and refreshing of access tokens.
+ */
+declare class GoogleToken {
+    /** The configuration options for this token instance. */
+    private tokenOptions;
+    /** The handler for token fetching and caching logic. */
+    private tokenHandler;
+    /**
+     * Create a GoogleToken.
+     *
+     * @param options  Configuration object.
+     */
+    constructor(options?: TokenOptions);
+    get expiresAt(): number | undefined;
+    /**
+     * The most recent access token obtained by this client.
+     */
+    get accessToken(): string | undefined;
+    /**
+     * The most recent ID token obtained by this client.
+     */
+    get idToken(): string | undefined;
+    /**
+     * The token type of the most recent access token.
+     */
+    get tokenType(): string | undefined;
+    /**
+     * The refresh token for the current credentials.
+     */
+    get refreshToken(): string | undefined;
+    /**
+     * A boolean indicating if the current token has expired.
+     */
+    hasExpired(): boolean;
+    /**
+     * A boolean indicating if the current token is expiring soon,
+     * based on the `eagerRefreshThresholdMillis` option.
+     */
+    isTokenExpiring(): boolean;
+    /**
+     * Fetches a new access token and returns it.
+     * @param opts Options for fetching the token.
+     */
+    getToken(opts?: GetTokenOptions): Promise<TokenData>;
+    getToken(callback: GetTokenCallback, opts?: GetTokenOptions): void;
+    /**
+     * Revokes the current access token and resets the token handler.
+     */
+    revokeToken(): Promise<void>;
+    revokeToken(callback: (err?: Error) => void): void;
+    /**
+     * Returns the configuration options for this token instance.
+     */
+    get googleTokenOptions(): TokenOptions;
+}
+export { GoogleToken, Transporter, TokenOptions, TokenData };