@openclaw/googlechat 2026.5.20 → 2026.5.22

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

@@ -0,0 +1,97 @@
+"use strict";
+// Copyright 2018 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.GCPEnv = void 0;
+exports.clear = clear;
+exports.getEnv = getEnv;
+const gcpMetadata = require("gcp-metadata");
+var GCPEnv;
+(function (GCPEnv) {
+    GCPEnv["APP_ENGINE"] = "APP_ENGINE";
+    GCPEnv["KUBERNETES_ENGINE"] = "KUBERNETES_ENGINE";
+    GCPEnv["CLOUD_FUNCTIONS"] = "CLOUD_FUNCTIONS";
+    GCPEnv["COMPUTE_ENGINE"] = "COMPUTE_ENGINE";
+    GCPEnv["CLOUD_RUN"] = "CLOUD_RUN";
+    GCPEnv["CLOUD_RUN_JOBS"] = "CLOUD_RUN_JOBS";
+    GCPEnv["NONE"] = "NONE";
+})(GCPEnv || (exports.GCPEnv = GCPEnv = {}));
+let envPromise;
+function clear() {
+    envPromise = undefined;
+}
+async function getEnv() {
+    if (envPromise) {
+        return envPromise;
+    }
+    envPromise = getEnvMemoized();
+    return envPromise;
+}
+async function getEnvMemoized() {
+    let env = GCPEnv.NONE;
+    if (isAppEngine()) {
+        env = GCPEnv.APP_ENGINE;
+    }
+    else if (isCloudFunction()) {
+        env = GCPEnv.CLOUD_FUNCTIONS;
+    }
+    else if (await isComputeEngine()) {
+        if (await isKubernetesEngine()) {
+            env = GCPEnv.KUBERNETES_ENGINE;
+        }
+        else if (isCloudRun()) {
+            env = GCPEnv.CLOUD_RUN;
+        }
+        else if (isCloudRunJob()) {
+            env = GCPEnv.CLOUD_RUN_JOBS;
+        }
+        else {
+            env = GCPEnv.COMPUTE_ENGINE;
+        }
+    }
+    else {
+        env = GCPEnv.NONE;
+    }
+    return env;
+}
+function isAppEngine() {
+    return !!(process.env.GAE_SERVICE || process.env.GAE_MODULE_NAME);
+}
+function isCloudFunction() {
+    return !!(process.env.FUNCTION_NAME || process.env.FUNCTION_TARGET);
+}
+/**
+ * This check only verifies that the environment is running knative.
+ * This must be run *after* checking for Kubernetes, otherwise it will
+ * return a false positive.
+ */
+function isCloudRun() {
+    return !!process.env.K_CONFIGURATION;
+}
+function isCloudRunJob() {
+    return !!process.env.CLOUD_RUN_JOB;
+}
+async function isKubernetesEngine() {
+    try {
+        await gcpMetadata.instance('attributes/cluster-name');
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+async function isComputeEngine() {
+    return gcpMetadata.isAvailable();
+}
+//# sourceMappingURL=envDetect.js.map

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

@@ -0,0 +1,137 @@
+/**
+ * Interface defining the JSON formatted response of a 3rd party executable
+ * used by the pluggable auth client.
+ */
+export interface ExecutableResponseJson {
+    /**
+     * The version of the JSON response. Only version 1 is currently supported.
+     * Always required.
+     */
+    version: number;
+    /**
+     * Whether the executable ran successfully. Always required.
+     */
+    success: boolean;
+    /**
+     * The epoch time for expiration of the token in seconds, required for
+     * successful responses.
+     */
+    expiration_time?: number;
+    /**
+     * The type of subject token in the response, currently supported values are:
+     * urn:ietf:params:oauth:token-type:saml2
+     * urn:ietf:params:oauth:token-type:id_token
+     * urn:ietf:params:oauth:token-type:jwt
+     */
+    token_type?: string;
+    /**
+     * The error code from the executable, required when unsuccessful.
+     */
+    code?: string;
+    /**
+     * The error message from the executable, required when unsuccessful.
+     */
+    message?: string;
+    /**
+     * The ID token to be used as a subject token when token_type is id_token or jwt.
+     */
+    id_token?: string;
+    /**
+     * The response to be used as a subject token when token_type is saml2.
+     */
+    saml_response?: string;
+}
+/**
+ * Defines the response of a 3rd party executable run by the pluggable auth client.
+ */
+export declare class ExecutableResponse {
+    /**
+     * The version of the Executable response. Only version 1 is currently supported.
+     */
+    readonly version: number;
+    /**
+     * Whether the executable ran successfully.
+     */
+    readonly success: boolean;
+    /**
+     * The epoch time for expiration of the token in seconds.
+     */
+    readonly expirationTime?: number;
+    /**
+     * The type of subject token in the response, currently supported values are:
+     * urn:ietf:params:oauth:token-type:saml2
+     * urn:ietf:params:oauth:token-type:id_token
+     * urn:ietf:params:oauth:token-type:jwt
+     */
+    readonly tokenType?: string;
+    /**
+     * The error code from the executable.
+     */
+    readonly errorCode?: string;
+    /**
+     * The error message from the executable.
+     */
+    readonly errorMessage?: string;
+    /**
+     * The subject token from the executable, format depends on tokenType.
+     */
+    readonly subjectToken?: string;
+    /**
+     * Instantiates an ExecutableResponse instance using the provided JSON object
+     * from the output of the executable.
+     * @param responseJson Response from a 3rd party executable, loaded from a
+     * run of the executable or a cached output file.
+     */
+    constructor(responseJson: ExecutableResponseJson);
+    /**
+     * @return A boolean representing if the response has a valid token. Returns
+     * true when the response was successful and the token is not expired.
+     */
+    isValid(): boolean;
+    /**
+     * @return A boolean representing if the response is expired. Returns true if the
+     * provided timeout has passed.
+     */
+    isExpired(): boolean;
+}
+/**
+ * An error thrown by the ExecutableResponse class.
+ */
+export declare class ExecutableResponseError extends Error {
+    constructor(message: string);
+}
+/**
+ * An error thrown when the 'version' field in an executable response is missing or invalid.
+ */
+export declare class InvalidVersionFieldError extends ExecutableResponseError {
+}
+/**
+ * An error thrown when the 'success' field in an executable response is missing or invalid.
+ */
+export declare class InvalidSuccessFieldError extends ExecutableResponseError {
+}
+/**
+ * An error thrown when the 'expiration_time' field in an executable response is missing or invalid.
+ */
+export declare class InvalidExpirationTimeFieldError extends ExecutableResponseError {
+}
+/**
+ * An error thrown when the 'token_type' field in an executable response is missing or invalid.
+ */
+export declare class InvalidTokenTypeFieldError extends ExecutableResponseError {
+}
+/**
+ * An error thrown when the 'code' field in an executable response is missing or invalid.
+ */
+export declare class InvalidCodeFieldError extends ExecutableResponseError {
+}
+/**
+ * An error thrown when the 'message' field in an executable response is missing or invalid.
+ */
+export declare class InvalidMessageFieldError extends ExecutableResponseError {
+}
+/**
+ * An error thrown when the subject token in an executable response is missing or invalid.
+ */
+export declare class InvalidSubjectTokenError extends ExecutableResponseError {
+}

package/node_modules/google-auth-library/build/src/auth/executable-response.js

@@ -0,0 +1,178 @@
+"use strict";
+// Copyright 2022 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.InvalidSubjectTokenError = exports.InvalidMessageFieldError = exports.InvalidCodeFieldError = exports.InvalidTokenTypeFieldError = exports.InvalidExpirationTimeFieldError = exports.InvalidSuccessFieldError = exports.InvalidVersionFieldError = exports.ExecutableResponseError = exports.ExecutableResponse = void 0;
+const SAML_SUBJECT_TOKEN_TYPE = 'urn:ietf:params:oauth:token-type:saml2';
+const OIDC_SUBJECT_TOKEN_TYPE1 = 'urn:ietf:params:oauth:token-type:id_token';
+const OIDC_SUBJECT_TOKEN_TYPE2 = 'urn:ietf:params:oauth:token-type:jwt';
+/**
+ * Defines the response of a 3rd party executable run by the pluggable auth client.
+ */
+class ExecutableResponse {
+    /**
+     * The version of the Executable response. Only version 1 is currently supported.
+     */
+    version;
+    /**
+     * Whether the executable ran successfully.
+     */
+    success;
+    /**
+     * The epoch time for expiration of the token in seconds.
+     */
+    expirationTime;
+    /**
+     * The type of subject token in the response, currently supported values are:
+     * urn:ietf:params:oauth:token-type:saml2
+     * urn:ietf:params:oauth:token-type:id_token
+     * urn:ietf:params:oauth:token-type:jwt
+     */
+    tokenType;
+    /**
+     * The error code from the executable.
+     */
+    errorCode;
+    /**
+     * The error message from the executable.
+     */
+    errorMessage;
+    /**
+     * The subject token from the executable, format depends on tokenType.
+     */
+    subjectToken;
+    /**
+     * Instantiates an ExecutableResponse instance using the provided JSON object
+     * from the output of the executable.
+     * @param responseJson Response from a 3rd party executable, loaded from a
+     * run of the executable or a cached output file.
+     */
+    constructor(responseJson) {
+        // Check that the required fields exist in the json response.
+        if (!responseJson.version) {
+            throw new InvalidVersionFieldError("Executable response must contain a 'version' field.");
+        }
+        if (responseJson.success === undefined) {
+            throw new InvalidSuccessFieldError("Executable response must contain a 'success' field.");
+        }
+        this.version = responseJson.version;
+        this.success = responseJson.success;
+        // Validate required fields for a successful response.
+        if (this.success) {
+            this.expirationTime = responseJson.expiration_time;
+            this.tokenType = responseJson.token_type;
+            // Validate token type field.
+            if (this.tokenType !== SAML_SUBJECT_TOKEN_TYPE &&
+                this.tokenType !== OIDC_SUBJECT_TOKEN_TYPE1 &&
+                this.tokenType !== OIDC_SUBJECT_TOKEN_TYPE2) {
+                throw new InvalidTokenTypeFieldError("Executable response must contain a 'token_type' field when successful " +
+                    `and it must be one of ${OIDC_SUBJECT_TOKEN_TYPE1}, ${OIDC_SUBJECT_TOKEN_TYPE2}, or ${SAML_SUBJECT_TOKEN_TYPE}.`);
+            }
+            // Validate subject token.
+            if (this.tokenType === SAML_SUBJECT_TOKEN_TYPE) {
+                if (!responseJson.saml_response) {
+                    throw new InvalidSubjectTokenError(`Executable response must contain a 'saml_response' field when token_type=${SAML_SUBJECT_TOKEN_TYPE}.`);
+                }
+                this.subjectToken = responseJson.saml_response;
+            }
+            else {
+                if (!responseJson.id_token) {
+                    throw new InvalidSubjectTokenError("Executable response must contain a 'id_token' field when " +
+                        `token_type=${OIDC_SUBJECT_TOKEN_TYPE1} or ${OIDC_SUBJECT_TOKEN_TYPE2}.`);
+                }
+                this.subjectToken = responseJson.id_token;
+            }
+        }
+        else {
+            // Both code and message must be provided for unsuccessful responses.
+            if (!responseJson.code) {
+                throw new InvalidCodeFieldError("Executable response must contain a 'code' field when unsuccessful.");
+            }
+            if (!responseJson.message) {
+                throw new InvalidMessageFieldError("Executable response must contain a 'message' field when unsuccessful.");
+            }
+            this.errorCode = responseJson.code;
+            this.errorMessage = responseJson.message;
+        }
+    }
+    /**
+     * @return A boolean representing if the response has a valid token. Returns
+     * true when the response was successful and the token is not expired.
+     */
+    isValid() {
+        return !this.isExpired() && this.success;
+    }
+    /**
+     * @return A boolean representing if the response is expired. Returns true if the
+     * provided timeout has passed.
+     */
+    isExpired() {
+        return (this.expirationTime !== undefined &&
+            this.expirationTime < Math.round(Date.now() / 1000));
+    }
+}
+exports.ExecutableResponse = ExecutableResponse;
+/**
+ * An error thrown by the ExecutableResponse class.
+ */
+class ExecutableResponseError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.ExecutableResponseError = ExecutableResponseError;
+/**
+ * An error thrown when the 'version' field in an executable response is missing or invalid.
+ */
+class InvalidVersionFieldError extends ExecutableResponseError {
+}
+exports.InvalidVersionFieldError = InvalidVersionFieldError;
+/**
+ * An error thrown when the 'success' field in an executable response is missing or invalid.
+ */
+class InvalidSuccessFieldError extends ExecutableResponseError {
+}
+exports.InvalidSuccessFieldError = InvalidSuccessFieldError;
+/**
+ * An error thrown when the 'expiration_time' field in an executable response is missing or invalid.
+ */
+class InvalidExpirationTimeFieldError extends ExecutableResponseError {
+}
+exports.InvalidExpirationTimeFieldError = InvalidExpirationTimeFieldError;
+/**
+ * An error thrown when the 'token_type' field in an executable response is missing or invalid.
+ */
+class InvalidTokenTypeFieldError extends ExecutableResponseError {
+}
+exports.InvalidTokenTypeFieldError = InvalidTokenTypeFieldError;
+/**
+ * An error thrown when the 'code' field in an executable response is missing or invalid.
+ */
+class InvalidCodeFieldError extends ExecutableResponseError {
+}
+exports.InvalidCodeFieldError = InvalidCodeFieldError;
+/**
+ * An error thrown when the 'message' field in an executable response is missing or invalid.
+ */
+class InvalidMessageFieldError extends ExecutableResponseError {
+}
+exports.InvalidMessageFieldError = InvalidMessageFieldError;
+/**
+ * An error thrown when the subject token in an executable response is missing or invalid.
+ */
+class InvalidSubjectTokenError extends ExecutableResponseError {
+}
+exports.InvalidSubjectTokenError = InvalidSubjectTokenError;
+//# sourceMappingURL=executable-response.js.map

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

@@ -0,0 +1,72 @@
+import { AuthClient, BodyResponseCallback } from './authclient';
+import { GaxiosOptions, GaxiosPromise, GaxiosResponse } from 'gaxios';
+import { Credentials } from './credentials';
+import { SharedExternalAccountClientOptions } from './baseexternalclient';
+/**
+ * The credentials JSON file type for external account authorized user clients.
+ */
+export declare const EXTERNAL_ACCOUNT_AUTHORIZED_USER_TYPE = "external_account_authorized_user";
+/**
+ * External Account Authorized User Credentials JSON interface.
+ */
+export interface ExternalAccountAuthorizedUserClientOptions extends SharedExternalAccountClientOptions {
+    type: typeof EXTERNAL_ACCOUNT_AUTHORIZED_USER_TYPE;
+    client_id: string;
+    client_secret: string;
+    refresh_token: string;
+    token_info_url: string;
+    revoke_url?: string;
+}
+/**
+ * Internal interface for tracking the access token expiration time.
+ */
+interface CredentialsWithResponse extends Credentials {
+    res?: GaxiosResponse | null;
+}
+/**
+ * External Account Authorized User Client. This is used for OAuth2 credentials
+ * sourced using external identities through Workforce Identity Federation.
+ * Obtaining the initial access and refresh token can be done through the
+ * Google Cloud CLI.
+ */
+export declare class ExternalAccountAuthorizedUserClient extends AuthClient {
+    private cachedAccessToken;
+    private readonly externalAccountAuthorizedUserHandler;
+    private refreshToken;
+    /**
+     * Instantiates an ExternalAccountAuthorizedUserClient instances using the
+     * provided JSON object loaded from a credentials files.
+     * An error is throws if the credential is not valid.
+     * @param options The external account authorized user option object typically
+     *   from the external accoutn authorized user JSON credential file.
+     */
+    constructor(options: ExternalAccountAuthorizedUserClientOptions);
+    getAccessToken(): Promise<{
+        token?: string | null;
+        res?: GaxiosResponse | null;
+    }>;
+    getRequestHeaders(): Promise<Headers>;
+    request<T>(opts: GaxiosOptions): GaxiosPromise<T>;
+    request<T>(opts: GaxiosOptions, callback: BodyResponseCallback<T>): void;
+    /**
+     * Authenticates the provided HTTP request, processes it and resolves with the
+     * returned response.
+     * @param opts The HTTP request options.
+     * @param reAuthRetried Whether the current attempt is a retry after a failed attempt due to an auth failure.
+     * @return A promise that resolves with the successful response.
+     */
+    protected requestAsync<T>(opts: GaxiosOptions, reAuthRetried?: boolean): Promise<GaxiosResponse<T>>;
+    /**
+     * Forces token refresh, even if unexpired tokens are currently cached.
+     * @return A promise that resolves with the refreshed credential.
+     */
+    protected refreshAccessTokenAsync(): Promise<CredentialsWithResponse>;
+    /**
+     * Returns whether the provided credentials are expired or not.
+     * If there is no expiry time, assumes the token is not expired or expiring.
+     * @param credentials The credentials to check for expiration.
+     * @return Whether the credentials are expired or not.
+     */
+    private isExpired;
+}
+export {};