@openclaw/googlechat 2026.5.20 → 2026.5.22

package/node_modules/gcp-metadata/README.md

@@ -0,0 +1,235 @@
+[//]: # "This README.md file is auto-generated, all changes to this file will be lost."
+[//]: # "To regenerate it, use `python -m synthtool`."
+<img src="https://avatars2.githubusercontent.com/u/2810941?v=3&s=96" alt="Google Cloud Platform logo" title="Google Cloud Platform" align="right" height="96" width="96"/>
+
+# [GCP Metadata: Node.js Client](https://github.com/googleapis/gcp-metadata)
+
+[![release level](https://img.shields.io/badge/release%20level-stable-brightgreen.svg?style=flat)](https://cloud.google.com/terms/launch-stages)
+[![npm version](https://img.shields.io/npm/v/gcp-metadata.svg)](https://www.npmjs.com/package/gcp-metadata)
+
+
+
+
+Get the metadata from a Google Cloud Platform environment
+
+
+A comprehensive list of changes in each version may be found in
+[the CHANGELOG](https://github.com/googleapis/gcp-metadata/blob/main/CHANGELOG.md).
+
+* [GCP Metadata Node.js Client API Reference][client-docs]
+* [GCP Metadata Documentation][product-docs]
+* [github.com/googleapis/gcp-metadata](https://github.com/googleapis/gcp-metadata)
+
+Read more about the client libraries for Cloud APIs, including the older
+Google APIs Client Libraries, in [Client Libraries Explained][explained].
+
+[explained]: https://cloud.google.com/apis/docs/client-libraries-explained
+
+**Table of contents:**
+
+
+* [Quickstart](#quickstart)
+
+  * [Installing the client library](#installing-the-client-library)
+  * [Using the client library](#using-the-client-library)
+* [Samples](#samples)
+* [Versioning](#versioning)
+* [Contributing](#contributing)
+* [License](#license)
+
+## Quickstart
+
+### Installing the client library
+
+```bash
+npm install gcp-metadata
+```
+
+
+### Using the client library
+
+```javascript
+const gcpMetadata = require('gcp-metadata');
+
+async function quickstart() {
+  // check to see if this code can access a metadata server
+  const isAvailable = await gcpMetadata.isAvailable();
+  console.log(`Is available: ${isAvailable}`);
+
+  // Instance and Project level metadata will only be available if
+  // running inside of a Google Cloud compute environment such as
+  // Cloud Functions, App Engine, Kubernetes Engine, or Compute Engine.
+  // To learn more about the differences between instance and project
+  // level metadata, see:
+  // https://cloud.google.com/compute/docs/storing-retrieving-metadata#project-instance-metadata
+  if (isAvailable) {
+    // grab all top level metadata from the service
+    const instanceMetadata = await gcpMetadata.instance();
+    console.log('Instance metadata:');
+    console.log(instanceMetadata);
+
+    // get all project level metadata
+    const projectMetadata = await gcpMetadata.project();
+    console.log('Project metadata:');
+    console.log(projectMetadata);
+  }
+}
+
+quickstart();
+
+```
+
+#### Check to see if the metadata server is available
+```js
+const isAvailable = await gcpMetadata.isAvailable();
+```
+
+#### Access all metadata
+
+```js
+const data = await gcpMetadata.instance();
+console.log(data); // ... All metadata properties
+```
+
+#### Access specific properties
+```js
+const data = await gcpMetadata.instance('hostname');
+console.log(data); // ...Instance hostname
+const projectId = await gcpMetadata.project('project-id');
+console.log(projectId); // ...Project ID of the running instance
+```
+
+#### Access nested properties with the relative path
+```js
+const data = await gcpMetadata.instance('service-accounts/default/email');
+console.log(data); // ...Email address of the Compute identity service account
+```
+
+#### Access specific properties with query parameters
+```js
+const data = await gcpMetadata.instance({
+  property: 'tags',
+  params: { alt: 'text' }
+});
+console.log(data) // ...Tags as newline-delimited list
+```
+
+#### Access with custom headers
+```js
+await gcpMetadata.instance({
+  headers: { 'no-trace': '1' }
+}); // ...Request is untraced
+```
+
+### Take care with large number valued properties
+
+In some cases number valued properties returned by the Metadata Service may be
+too large to be representable as JavaScript numbers. In such cases we return
+those values as `BigNumber` objects (from the [bignumber.js](https://github.com/MikeMcl/bignumber.js) library). Numbers
+that fit within the JavaScript number range will be returned as normal number
+values.
+
+```js
+const id = await gcpMetadata.instance('id');
+console.log(id)  // ... BigNumber { s: 1, e: 18, c: [ 45200, 31799277581759 ] }
+console.log(id.toString()) // ... 4520031799277581759
+```
+
+### Environment variables
+
+* `GCE_METADATA_HOST`: provide an alternate host or IP to perform lookup against (useful, for example, you're connecting through a custom proxy server).
+
+  For example:
+  ```
+  export GCE_METADATA_HOST='169.254.169.254'
+  ```
+
+* `DETECT_GCP_RETRIES`: number representing number of retries that should be attempted on metadata lookup.
+
+* `DEBUG_AUTH`: emit debugging logs
+
+* `METADATA_SERVER_DETECTION`: configure desired metadata server availability check behavior.
+
+  * `assume-present`: don't try to ping the metadata server, but assume it's present
+  * `none`: don't try to ping the metadata server, but don't try to use it either
+  * `bios-only`: treat the result of a BIOS probe as canonical (don't fall back to pinging)
+  * `ping-only`: skip the BIOS probe, and go straight to pinging
+
+
+## Samples
+
+Samples are in the [`samples/`](https://github.com/googleapis/gcp-metadata/tree/main/samples) directory. Each sample's `README.md` has instructions for running its sample.
+
+| Sample                      | Source Code                       | Try it |
+| --------------------------- | --------------------------------- | ------ |
+| Quickstart | [source code](https://github.com/googleapis/gcp-metadata/blob/main/samples/quickstart.js) | [![Open in Cloud Shell][shell_img]](https://console.cloud.google.com/cloudshell/open?git_repo=https://github.com/googleapis/gcp-metadata&page=editor&open_in_editor=samples/quickstart.js,samples/README.md) |
+
+
+
+The [GCP Metadata Node.js Client API Reference][client-docs] documentation
+also contains samples.
+
+## Supported Node.js Versions
+
+Our client libraries follow the [Node.js release schedule](https://github.com/nodejs/release#release-schedule).
+Libraries are compatible with all current _active_ and _maintenance_ versions of
+Node.js.
+If you are using an end-of-life version of Node.js, we recommend that you update
+as soon as possible to an actively supported LTS version.
+
+Google's client libraries support legacy versions of Node.js runtimes on a
+best-efforts basis with the following warnings:
+
+* Legacy versions are not tested in continuous integration.
+* Some security patches and features cannot be backported.
+* Dependencies cannot be kept up-to-date.
+
+Client libraries targeting some end-of-life versions of Node.js are available, and
+can be installed through npm [dist-tags](https://docs.npmjs.com/cli/dist-tag).
+The dist-tags follow the naming convention `legacy-(version)`.
+For example, `npm install gcp-metadata@legacy-8` installs client libraries
+for versions compatible with Node.js 8.
+
+## Versioning
+
+This library follows [Semantic Versioning](http://semver.org/).
+
+
+
+This library is considered to be **stable**. The code surface will not change in backwards-incompatible ways
+unless absolutely necessary (e.g. because of critical security issues) or with
+an extensive deprecation period. Issues and requests against **stable** libraries
+are addressed with the highest priority.
+
+
+
+
+
+
+More Information: [Google Cloud Platform Launch Stages][launch_stages]
+
+[launch_stages]: https://cloud.google.com/terms/launch-stages
+
+## Contributing
+
+Contributions welcome! See the [Contributing Guide](https://github.com/googleapis/gcp-metadata/blob/main/CONTRIBUTING.md).
+
+Please note that this `README.md`, the `samples/README.md`,
+and a variety of configuration files in this repository (including `.nycrc` and `tsconfig.json`)
+are generated from a central template. To edit one of these files, make an edit
+to its templates in
+[directory](https://github.com/googleapis/synthtool).
+
+## License
+
+Apache Version 2.0
+
+See [LICENSE](https://github.com/googleapis/gcp-metadata/blob/main/LICENSE)
+
+[client-docs]: https://cloud.google.com/nodejs/docs/reference/gcp-metadata/latest
+[product-docs]: https://cloud.google.com/compute/docs/storing-retrieving-metadata
+[shell_img]: https://gstatic.com/cloudssh/images/open-btn.png
+[projects]: https://console.cloud.google.com/project
+[billing]: https://support.google.com/cloud/answer/6293499#enable-billing
+
+[auth]: https://cloud.google.com/docs/authentication/external/set-up-adc-local

package/node_modules/gcp-metadata/build/src/gcp-residency.d.ts

@@ -0,0 +1,57 @@
+/**
+ * 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.
+ */
+/**
+ * Known paths unique to Google Compute Engine Linux instances
+ */
+export declare const GCE_LINUX_BIOS_PATHS: {
+    BIOS_DATE: string;
+    BIOS_VENDOR: string;
+};
+/**
+ * Determines if the process is running on a Google Cloud Serverless environment (Cloud Run or Cloud Functions instance).
+ *
+ * Uses the:
+ * - {@link https://cloud.google.com/run/docs/container-contract#env-vars Cloud Run environment variables}.
+ * - {@link https://cloud.google.com/functions/docs/env-var Cloud Functions environment variables}.
+ *
+ * @returns {boolean} `true` if the process is running on GCP serverless, `false` otherwise.
+ */
+export declare function isGoogleCloudServerless(): boolean;
+/**
+ * Determines if the process is running on a Linux Google Compute Engine instance.
+ *
+ * @returns {boolean} `true` if the process is running on Linux GCE, `false` otherwise.
+ */
+export declare function isGoogleComputeEngineLinux(): boolean;
+/**
+ * Determines if the process is running on a Google Compute Engine instance with a known
+ * MAC address.
+ *
+ * @returns {boolean} `true` if the process is running on GCE (as determined by MAC address), `false` otherwise.
+ */
+export declare function isGoogleComputeEngineMACAddress(): boolean;
+/**
+ * Determines if the process is running on a Google Compute Engine instance.
+ *
+ * @returns {boolean} `true` if the process is running on GCE, `false` otherwise.
+ */
+export declare function isGoogleComputeEngine(): boolean;
+/**
+ * Determines if the process is running on Google Cloud Platform.
+ *
+ * @returns {boolean} `true` if the process is running on GCP, `false` otherwise.
+ */
+export declare function detectGCPResidency(): boolean;

package/node_modules/gcp-metadata/build/src/gcp-residency.js

@@ -0,0 +1,114 @@
+"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.GCE_LINUX_BIOS_PATHS = void 0;
+exports.isGoogleCloudServerless = isGoogleCloudServerless;
+exports.isGoogleComputeEngineLinux = isGoogleComputeEngineLinux;
+exports.isGoogleComputeEngineMACAddress = isGoogleComputeEngineMACAddress;
+exports.isGoogleComputeEngine = isGoogleComputeEngine;
+exports.detectGCPResidency = detectGCPResidency;
+const fs_1 = require("fs");
+const os_1 = require("os");
+/**
+ * Known paths unique to Google Compute Engine Linux instances
+ */
+exports.GCE_LINUX_BIOS_PATHS = {
+    BIOS_DATE: '/sys/class/dmi/id/bios_date',
+    BIOS_VENDOR: '/sys/class/dmi/id/bios_vendor',
+};
+const GCE_MAC_ADDRESS_REGEX = /^42:01/;
+/**
+ * Determines if the process is running on a Google Cloud Serverless environment (Cloud Run or Cloud Functions instance).
+ *
+ * Uses the:
+ * - {@link https://cloud.google.com/run/docs/container-contract#env-vars Cloud Run environment variables}.
+ * - {@link https://cloud.google.com/functions/docs/env-var Cloud Functions environment variables}.
+ *
+ * @returns {boolean} `true` if the process is running on GCP serverless, `false` otherwise.
+ */
+function isGoogleCloudServerless() {
+    /**
+     * `CLOUD_RUN_JOB` is used for Cloud Run Jobs
+     * - See {@link https://cloud.google.com/run/docs/container-contract#env-vars Cloud Run environment variables}.
+     *
+     * `FUNCTION_NAME` is used in older Cloud Functions environments:
+     * - See {@link https://cloud.google.com/functions/docs/env-var Python 3.7 and Go 1.11}.
+     *
+     * `K_SERVICE` is used in Cloud Run and newer Cloud Functions environments:
+     * - See {@link https://cloud.google.com/run/docs/container-contract#env-vars Cloud Run environment variables}.
+     * - See {@link https://cloud.google.com/functions/docs/env-var Cloud Functions newer runtimes}.
+     */
+    const isGFEnvironment = process.env.CLOUD_RUN_JOB ||
+        process.env.FUNCTION_NAME ||
+        process.env.K_SERVICE;
+    return !!isGFEnvironment;
+}
+/**
+ * Determines if the process is running on a Linux Google Compute Engine instance.
+ *
+ * @returns {boolean} `true` if the process is running on Linux GCE, `false` otherwise.
+ */
+function isGoogleComputeEngineLinux() {
+    if ((0, os_1.platform)() !== 'linux')
+        return false;
+    try {
+        // ensure this file exist
+        (0, fs_1.statSync)(exports.GCE_LINUX_BIOS_PATHS.BIOS_DATE);
+        // ensure this file exist and matches
+        const biosVendor = (0, fs_1.readFileSync)(exports.GCE_LINUX_BIOS_PATHS.BIOS_VENDOR, 'utf8');
+        return /Google/.test(biosVendor);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Determines if the process is running on a Google Compute Engine instance with a known
+ * MAC address.
+ *
+ * @returns {boolean} `true` if the process is running on GCE (as determined by MAC address), `false` otherwise.
+ */
+function isGoogleComputeEngineMACAddress() {
+    const interfaces = (0, os_1.networkInterfaces)();
+    for (const item of Object.values(interfaces)) {
+        if (!item)
+            continue;
+        for (const { mac } of item) {
+            if (GCE_MAC_ADDRESS_REGEX.test(mac)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Determines if the process is running on a Google Compute Engine instance.
+ *
+ * @returns {boolean} `true` if the process is running on GCE, `false` otherwise.
+ */
+function isGoogleComputeEngine() {
+    return isGoogleComputeEngineLinux() || isGoogleComputeEngineMACAddress();
+}
+/**
+ * Determines if the process is running on Google Cloud Platform.
+ *
+ * @returns {boolean} `true` if the process is running on GCP, `false` otherwise.
+ */
+function detectGCPResidency() {
+    return isGoogleCloudServerless() || isGoogleComputeEngine();
+}
+//# sourceMappingURL=gcp-residency.js.map

package/node_modules/gcp-metadata/build/src/gcp-residency.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gcp-residency.js","sourceRoot":"","sources":["../../src/gcp-residency.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAwBH,0DAkBC;AAOD,gEAcC;AAQD,0EAcC;AAOD,sDAEC;AAOD,gDAEC;AArGD,2BAA0C;AAC1C,2BAA+C;AAE/C;;GAEG;AACU,QAAA,oBAAoB,GAAG;IAClC,SAAS,EAAE,6BAA6B;IACxC,WAAW,EAAE,+BAA+B;CAC7C,CAAC;AAEF,MAAM,qBAAqB,GAAG,QAAQ,CAAC;AAEvC;;;;;;;;GAQG;AACH,SAAgB,uBAAuB;IACrC;;;;;;;;;;OAUG;IACH,MAAM,eAAe,GACnB,OAAO,CAAC,GAAG,CAAC,aAAa;QACzB,OAAO,CAAC,GAAG,CAAC,aAAa;QACzB,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC;IAExB,OAAO,CAAC,CAAC,eAAe,CAAC;AAC3B,CAAC;AAED;;;;GAIG;AACH,SAAgB,0BAA0B;IACxC,IAAI,IAAA,aAAQ,GAAE,KAAK,OAAO;QAAE,OAAO,KAAK,CAAC;IAEzC,IAAI,CAAC;QACH,yBAAyB;QACzB,IAAA,aAAQ,EAAC,4BAAoB,CAAC,SAAS,CAAC,CAAC;QAEzC,qCAAqC;QACrC,MAAM,UAAU,GAAG,IAAA,iBAAY,EAAC,4BAAoB,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;QAE1E,OAAO,QAAQ,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IACnC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,SAAgB,+BAA+B;IAC7C,MAAM,UAAU,GAAG,IAAA,sBAAiB,GAAE,CAAC;IAEvC,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE,CAAC;QAC7C,IAAI,CAAC,IAAI;YAAE,SAAS;QAEpB,KAAK,MAAM,EAAC,GAAG,EAAC,IAAI,IAAI,EAAE,CAAC;YACzB,IAAI,qBAAqB,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;gBACpC,OAAO,IAAI,CAAC;YACd,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;GAIG;AACH,SAAgB,qBAAqB;IACnC,OAAO,0BAA0B,EAAE,IAAI,+BAA+B,EAAE,CAAC;AAC3E,CAAC;AAED;;;;GAIG;AACH,SAAgB,kBAAkB;IAChC,OAAO,uBAAuB,EAAE,IAAI,qBAAqB,EAAE,CAAC;AAC9D,CAAC"}

package/node_modules/gcp-metadata/build/src/index.d.ts

@@ -0,0 +1,141 @@
+export declare const BASE_PATH = "/computeMetadata/v1";
+export declare const HOST_ADDRESS = "http://169.254.169.254";
+export declare const SECONDARY_HOST_ADDRESS = "http://metadata.google.internal.";
+export declare const HEADER_NAME = "Metadata-Flavor";
+export declare const HEADER_VALUE = "Google";
+export declare const HEADERS: Readonly<{
+    "Metadata-Flavor": "Google";
+}>;
+/**
+ * Metadata server detection override options.
+ *
+ * Available via `process.env.METADATA_SERVER_DETECTION`.
+ */
+export declare const METADATA_SERVER_DETECTION: Readonly<{
+    'assume-present': "don't try to ping the metadata server, but assume it's present";
+    none: "don't try to ping the metadata server, but don't try to use it either";
+    'bios-only': "treat the result of a BIOS probe as canonical (don't fall back to pinging)";
+    'ping-only': "skip the BIOS probe, and go straight to pinging";
+}>;
+type HeadersInit = ConstructorParameters<typeof Headers>[0];
+export interface Options {
+    params?: {
+        [index: string]: string;
+    };
+    property?: string;
+    headers?: HeadersInit;
+}
+export interface MetadataAccessor {
+    /**
+     *
+     * @example
+     *
+     * // equivalent to `project('project-id')`;
+     * const metadataKey = 'project/project-id';
+     */
+    metadataKey: string;
+    params?: Options['params'];
+    headers?: Options['headers'];
+    noResponseRetries?: number;
+    fastFail?: boolean;
+}
+export type BulkResults<T extends readonly MetadataAccessor[]> = {
+    [key in T[number]['metadataKey']]: ReturnType<JSON['parse']>;
+};
+/**
+ * Obtain metadata for the current GCE instance.
+ *
+ * @see {@link https://cloud.google.com/compute/docs/metadata/predefined-metadata-keys}
+ *
+ * @example
+ * ```
+ * const serviceAccount: {} = await instance('service-accounts/');
+ * const serviceAccountEmail: string = await instance('service-accounts/default/email');
+ * ```
+ */
+export declare function instance<T = any>(options?: string | Options): Promise<T>;
+/**
+ * Obtain metadata for the current GCP project.
+ *
+ * @see {@link https://cloud.google.com/compute/docs/metadata/predefined-metadata-keys}
+ *
+ * @example
+ * ```
+ * const projectId: string = await project('project-id');
+ * const numericProjectId: number = await project('numeric-project-id');
+ * ```
+ */
+export declare function project<T = any>(options?: string | Options): Promise<T>;
+/**
+ * Obtain metadata for the current universe.
+ *
+ * @see {@link https://cloud.google.com/compute/docs/metadata/predefined-metadata-keys}
+ *
+ * @example
+ * ```
+ * const universeDomain: string = await universe('universe-domain');
+ * ```
+ */
+export declare function universe<T>(options?: string | Options): Promise<T>;
+/**
+ * Retrieve metadata items in parallel.
+ *
+ * @see {@link https://cloud.google.com/compute/docs/metadata/predefined-metadata-keys}
+ *
+ * @example
+ * ```
+ * const data = await bulk([
+ *   {
+ *     metadataKey: 'instance',
+ *   },
+ *   {
+ *     metadataKey: 'project/project-id',
+ *   },
+ * ] as const);
+ *
+ * // data.instance;
+ * // data['project/project-id'];
+ * ```
+ *
+ * @param properties The metadata properties to retrieve
+ * @returns The metadata in `metadatakey:value` format
+ */
+export declare function bulk<T extends readonly Readonly<MetadataAccessor>[], R extends BulkResults<T> = BulkResults<T>>(properties: T): Promise<R>;
+/**
+ * Determine if the metadata server is currently available.
+ */
+export declare function isAvailable(): Promise<boolean>;
+/**
+ * reset the memoized isAvailable() lookup.
+ */
+export declare function resetIsAvailableCache(): void;
+/**
+ * A cache for the detected GCP Residency.
+ */
+export declare let gcpResidencyCache: boolean | null;
+/**
+ * Detects GCP Residency.
+ * Caches results to reduce costs for subsequent calls.
+ *
+ * @see setGCPResidency for setting
+ */
+export declare function getGCPResidency(): boolean;
+/**
+ * Sets the detected GCP Residency.
+ * Useful for forcing metadata server detection behavior.
+ *
+ * Set `null` to autodetect the environment (default behavior).
+ * @see getGCPResidency for getting
+ */
+export declare function setGCPResidency(value?: boolean | null): void;
+/**
+ * Obtain the timeout for requests to the metadata server.
+ *
+ * In certain environments and conditions requests can take longer than
+ * the default timeout to complete. This function will determine the
+ * appropriate timeout based on the environment.
+ *
+ * @returns {number} a request timeout duration in milliseconds.
+ */
+export declare function requestTimeout(): number;
+export * from './gcp-residency';