@openclaw/googlechat 2026.5.20 → 2026.5.22

package/node_modules/google-logging-utils/README.md

@@ -0,0 +1,73 @@
+# Google Logging Tools
+
+## About
+This package defines an ad-hoc debug logger utility that can be used as a lightweight alternative to "printf debugging" via `console.log`, and provides more, and more structured information. It is based largely on the ideas of the Node `util.debuglog` function, and the `debug` npm package.
+
+## Contracts
+These are logging utilities meant primarily for use as an "adhoc debug logger" inside Google libraries. It's possible to use this outside of that context, but it is currently not supported. (You're on your own.)
+
+Additionally, everything about the debug logging is not intended to be a stable interface - you can't rely on messages to remain the same, or to continue to exist from one version to the next. For now, it is meant to be a tool for local usage by users, to get the equivalent of "printf debugging" output. In the future, it may tie into more things (OpenTelemetry Logging, etc). Structured log output is possible for vacuuming into Cloud Logging.
+
+This npm package itself is intended to follow semver standards for its own interfaces, but no guarantees are made for supported time windows, etc.
+
+## Usage
+The user interface for this logging is very similar to Node's built-in logging. The primary unit of logging is called a "system", and some libraries may have sub-units called "subsystems". You separate the system and subsystem with a colon, like "pubsub:leasing" or similar. Wildcards may be used (e.g. "pubsub:*"), and multiple of these system/system:subsystem pairs may be listed out, separated by commas. For generated GAPIC libraries, the "system" will generally be the part of the package name specific to the library (e.g. `@google-cloud/translate` will be `translate`).
+
+The environment variable for activating logging is `GOOGLE_SDK_NODE_LOGGING`. So you could run your application similarly to this:
+
+```
+GOOGLE_SDK_NODE_LOGGING=translate node yourApp.js
+```
+
+Or even enable everything, though you might end up with a firehose if you have multiple libraries as dependencies:
+
+```
+GOOGLE_SDK_NODE_LOGGING=* node yourApp.js
+```
+
+## Logging
+Logging functions are created by calling the `log()` function. You pass a system or system:subsystem identifier, and a function is returned. This function may be called directly:
+
+```
+const logger = log('test');
+logger({other:{metadata: 'foo'}}, 'format string %j', {formatted: 'parameter'});
+```
+
+You may also call shorthands that set the `severity` metadata field, and use defaults for the metadata object generally:
+
+```
+logger.debug('format string %s', 'string');
+logger.info('format string %s', 'string');
+logger.warn('format string %s', 'string');
+logger.error('format string %s', 'string');
+```
+
+Finally, the logger function may be used to create a "sub-log", i.e. adding a sub-system to a system:
+
+```
+const sublogger = logger.sublog('specific');
+logger.info('big one');
+sublogger.info('specific!');
+```
+
+This will output two logs, filed under `test` and `test:specific`, respectively.
+
+## Backends
+Additionally, there is a concept of a logging backend. You can manually set where you want logs to go, by default, and how you want them processed. The `setBackend()` function lets you set a backend manually. `undefined` (reset to defaults) and `null` (disable logging) are also possible options.
+
+The package provides several built-in options:
+
+* `getNodeBackend()` This is the default that comes with setting the environment variable. It detects the possibility of coloration in the terminal and formats outputs using `util.format()`.
+* `getDebugBackend(debugpkg)` This interfaces with the `debug` npm package. You'd essentially do something like `setBackend(getDebugBackend(require('debug')))`.
+* `getStructuredBackend(upstream?)`. This converts log output into structured log JSON objects, suitable for feeding into Cloud Logging. An optional `upstream` parameter lets you funnel the output through another backend instead of `console.log`.
+
+## Hooking logs
+The log objects you receive from calling `log()` can be hooked as event emitters, like so:
+
+```
+loggingFunc.on('log', (fields: LogFields, args: unknown[]) => {
+  // Process logs as you like.
+});
+```
+
+This will not prevent normal log output, and system/system:subsystem identifiers will be cached to make sure that all logs of the same name will output to the same event handlers.

package/node_modules/google-logging-utils/build/src/colours.d.ts

@@ -0,0 +1,29 @@
+import * as tty from 'tty';
+/**
+ * Handles figuring out if we can use ANSI colours and handing out the escape codes.
+ *
+ * This is for package-internal use only, and may change at any time.
+ *
+ * @private
+ * @internal
+ */
+export declare class Colours {
+    static enabled: boolean;
+    static reset: string;
+    static bright: string;
+    static dim: string;
+    static red: string;
+    static green: string;
+    static yellow: string;
+    static blue: string;
+    static magenta: string;
+    static cyan: string;
+    static white: string;
+    static grey: string;
+    /**
+     * @param stream The stream (e.g. process.stderr)
+     * @returns true if the stream should have colourization enabled
+     */
+    static isEnabled(stream: tty.WriteStream): boolean;
+    static refresh(): void;
+}

package/node_modules/google-logging-utils/build/src/colours.js

@@ -0,0 +1,81 @@
+"use strict";
+// Copyright 2024 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
+//
+//     https://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.Colours = void 0;
+/**
+ * Handles figuring out if we can use ANSI colours and handing out the escape codes.
+ *
+ * This is for package-internal use only, and may change at any time.
+ *
+ * @private
+ * @internal
+ */
+class Colours {
+    /**
+     * @param stream The stream (e.g. process.stderr)
+     * @returns true if the stream should have colourization enabled
+     */
+    static isEnabled(stream) {
+        return (stream && // May happen in browsers.
+            stream.isTTY &&
+            (typeof stream.getColorDepth === 'function'
+                ? stream.getColorDepth() > 2
+                : true));
+    }
+    static refresh() {
+        Colours.enabled = Colours.isEnabled(process === null || process === void 0 ? void 0 : process.stderr);
+        if (!this.enabled) {
+            Colours.reset = '';
+            Colours.bright = '';
+            Colours.dim = '';
+            Colours.red = '';
+            Colours.green = '';
+            Colours.yellow = '';
+            Colours.blue = '';
+            Colours.magenta = '';
+            Colours.cyan = '';
+            Colours.white = '';
+            Colours.grey = '';
+        }
+        else {
+            Colours.reset = '\u001b[0m';
+            Colours.bright = '\u001b[1m';
+            Colours.dim = '\u001b[2m';
+            Colours.red = '\u001b[31m';
+            Colours.green = '\u001b[32m';
+            Colours.yellow = '\u001b[33m';
+            Colours.blue = '\u001b[34m';
+            Colours.magenta = '\u001b[35m';
+            Colours.cyan = '\u001b[36m';
+            Colours.white = '\u001b[37m';
+            Colours.grey = '\u001b[90m';
+        }
+    }
+}
+exports.Colours = Colours;
+Colours.enabled = false;
+Colours.reset = '';
+Colours.bright = '';
+Colours.dim = '';
+Colours.red = '';
+Colours.green = '';
+Colours.yellow = '';
+Colours.blue = '';
+Colours.magenta = '';
+Colours.cyan = '';
+Colours.white = '';
+Colours.grey = '';
+Colours.refresh();
+//# sourceMappingURL=colours.js.map

package/node_modules/google-logging-utils/build/src/colours.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"colours.js","sourceRoot":"","sources":["../../src/colours.ts"],"names":[],"mappings":";AAAA,4BAA4B;AAC5B,EAAE;AACF,kEAAkE;AAClE,mEAAmE;AACnE,0CAA0C;AAC1C,EAAE;AACF,kDAAkD;AAClD,EAAE;AACF,sEAAsE;AACtE,oEAAoE;AACpE,2EAA2E;AAC3E,sEAAsE;AACtE,iCAAiC;;;AAUjC;;;;;;;GAOG;AACH,MAAa,OAAO;IAelB;;;OAGG;IACH,MAAM,CAAC,SAAS,CAAC,MAAuB;QACtC,OAAO,CACL,MAAM,IAAI,0BAA0B;YACpC,MAAM,CAAC,KAAK;YACZ,CAAC,OAAO,MAAM,CAAC,aAAa,KAAK,UAAU;gBACzC,CAAC,CAAC,MAAM,CAAC,aAAa,EAAE,GAAG,CAAC;gBAC5B,CAAC,CAAC,IAAI,CAAC,CACV,CAAC;IACJ,CAAC;IAED,MAAM,CAAC,OAAO;QACZ,OAAO,CAAC,OAAO,GAAG,OAAO,CAAC,SAAS,CAAC,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,MAAM,CAAC,CAAC;QACrD,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;YAClB,OAAO,CAAC,KAAK,GAAG,EAAE,CAAC;YACnB,OAAO,CAAC,MAAM,GAAG,EAAE,CAAC;YACpB,OAAO,CAAC,GAAG,GAAG,EAAE,CAAC;YACjB,OAAO,CAAC,GAAG,GAAG,EAAE,CAAC;YACjB,OAAO,CAAC,KAAK,GAAG,EAAE,CAAC;YACnB,OAAO,CAAC,MAAM,GAAG,EAAE,CAAC;YACpB,OAAO,CAAC,IAAI,GAAG,EAAE,CAAC;YAClB,OAAO,CAAC,OAAO,GAAG,EAAE,CAAC;YACrB,OAAO,CAAC,IAAI,GAAG,EAAE,CAAC;YAClB,OAAO,CAAC,KAAK,GAAG,EAAE,CAAC;YACnB,OAAO,CAAC,IAAI,GAAG,EAAE,CAAC;QACpB,CAAC;aAAM,CAAC;YACN,OAAO,CAAC,KAAK,GAAG,WAAW,CAAC;YAC5B,OAAO,CAAC,MAAM,GAAG,WAAW,CAAC;YAC7B,OAAO,CAAC,GAAG,GAAG,WAAW,CAAC;YAC1B,OAAO,CAAC,GAAG,GAAG,YAAY,CAAC;YAC3B,OAAO,CAAC,KAAK,GAAG,YAAY,CAAC;YAC7B,OAAO,CAAC,MAAM,GAAG,YAAY,CAAC;YAC9B,OAAO,CAAC,IAAI,GAAG,YAAY,CAAC;YAC5B,OAAO,CAAC,OAAO,GAAG,YAAY,CAAC;YAC/B,OAAO,CAAC,IAAI,GAAG,YAAY,CAAC;YAC5B,OAAO,CAAC,KAAK,GAAG,YAAY,CAAC;YAC7B,OAAO,CAAC,IAAI,GAAG,YAAY,CAAC;QAC9B,CAAC;IACH,CAAC;;AAxDH,0BAyDC;AAxDQ,eAAO,GAAG,KAAK,CAAC;AAChB,aAAK,GAAG,EAAE,CAAC;AACX,cAAM,GAAG,EAAE,CAAC;AACZ,WAAG,GAAG,EAAE,CAAC;AAET,WAAG,GAAG,EAAE,CAAC;AACT,aAAK,GAAG,EAAE,CAAC;AACX,cAAM,GAAG,EAAE,CAAC;AACZ,YAAI,GAAG,EAAE,CAAC;AACV,eAAO,GAAG,EAAE,CAAC;AACb,YAAI,GAAG,EAAE,CAAC;AACV,aAAK,GAAG,EAAE,CAAC;AACX,YAAI,GAAG,EAAE,CAAC;AA8CnB,OAAO,CAAC,OAAO,EAAE,CAAC"}

package/node_modules/google-logging-utils/build/src/index.d.ts

@@ -0,0 +1 @@
+export * from './logging-utils';

package/node_modules/google-logging-utils/build/src/index.js

@@ -0,0 +1,31 @@
+"use strict";
+// Copyright 2024 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
+//
+//     https://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.
+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 });
+__exportStar(require("./logging-utils"), exports);
+//# sourceMappingURL=index.js.map

package/node_modules/google-logging-utils/build/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";AAAA,4BAA4B;AAC5B,EAAE;AACF,kEAAkE;AAClE,mEAAmE;AACnE,0CAA0C;AAC1C,EAAE;AACF,kDAAkD;AAClD,EAAE;AACF,sEAAsE;AACtE,oEAAoE;AACpE,2EAA2E;AAC3E,sEAAsE;AACtE,iCAAiC;;;;;;;;;;;;;;;;AAEjC,kDAAgC"}

package/node_modules/google-logging-utils/build/src/logging-utils.d.ts

@@ -0,0 +1,222 @@
+import { EventEmitter } from 'events';
+/**
+ * This module defines an ad-hoc debug logger for Google Cloud Platform
+ * client libraries in Node. An ad-hoc debug logger is a tool which lets
+ * users use an external, unified interface (in this case, environment
+ * variables) to determine what logging they want to see at runtime. This
+ * isn't necessarily fed into the console, but is meant to be under the
+ * control of the user. The kind of logging that will be produced by this
+ * is more like "call retry happened", not "events you'd want to record
+ * in Cloud Logger".
+ *
+ * More for Googlers implementing libraries with it:
+ * go/cloud-client-logging-design
+ */
+/**
+ * Possible log levels. These are a subset of Cloud Observability levels.
+ * https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry#LogSeverity
+ */
+export declare enum LogSeverity {
+    DEFAULT = "DEFAULT",
+    DEBUG = "DEBUG",
+    INFO = "INFO",
+    WARNING = "WARNING",
+    ERROR = "ERROR"
+}
+/**
+ * A set of suggested log metadata fields.
+ */
+export interface LogFields {
+    /**
+     * Log level - undefined/null === DEFAULT.
+     */
+    severity?: LogSeverity;
+    /**
+     * If this log is associated with an OpenTelemetry trace, you can put the
+     * trace ID here to pass on that association.
+     */
+    telemetryTraceId?: string;
+    /**
+     * If this log is associated with an OpenTelemetry trace, you can put the
+     * span ID here to pass on that association.
+     */
+    telemetrySpanId?: string;
+    /**
+     * This is a catch-all for any other items you might want to go into
+     * structured logs. Library implementers, please see the spec docs above
+     * for the items envisioned to go here.
+     */
+    other?: unknown;
+}
+/**
+ * Adds typings for event sinks.
+ */
+export declare interface AdhocDebugLogger {
+    on(event: 'log', listener: (fields: LogFields, args: unknown[]) => void): this;
+    on(event: string, listener: Function): this;
+}
+/**
+ * Our logger instance. This actually contains the meat of dealing
+ * with log lines, including EventEmitter. This contains the function
+ * that will be passed back to users of the package.
+ */
+export declare class AdhocDebugLogger extends EventEmitter {
+    namespace: string;
+    upstream: AdhocDebugLogCallable;
+    func: AdhocDebugLogFunction;
+    /**
+     * @param upstream The backend will pass a function that will be
+     *   called whenever our logger function is invoked.
+     */
+    constructor(namespace: string, upstream: AdhocDebugLogCallable);
+    invoke(fields: LogFields, ...args: unknown[]): void;
+    invokeSeverity(severity: LogSeverity, ...args: unknown[]): void;
+}
+/**
+ * This can be used in place of a real logger while waiting for Promises or disabling logging.
+ */
+export declare const placeholder: AdhocDebugLogFunction;
+/**
+ * When the user receives a log function (below), this will be the basic function
+ * call interface for it.
+ */
+export interface AdhocDebugLogCallable {
+    (fields: LogFields, ...args: unknown[]): void;
+}
+/**
+ * Adds typing info for the EventEmitter we're adding to the returned function.
+ *
+ * Note that this interface may change at any time, as we're reserving the
+ * right to add new backends at the logger level.
+ *
+ * @private
+ * @internal
+ */
+export interface AdhocDebugLogFunction extends AdhocDebugLogCallable {
+    instance: AdhocDebugLogger;
+    on(event: 'log', listener: (fields: LogFields, args: unknown[]) => void): this;
+    debug(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+    sublog(namespace: string): AdhocDebugLogFunction;
+}
+/**
+ * One of these can be passed to support a third-party backend, like "debug".
+ * We're splitting this out because ESM can complicate optional module loading.
+ *
+ * Note that this interface may change at any time, as we're reserving the
+ * right to add new backends at the logger level.
+ *
+ * @private
+ * @internal
+ */
+export interface DebugLogBackend {
+    /**
+     * Outputs a log to this backend.
+     *
+     * @param namespace The "system" that will be used for filtering. This may also
+     *   include a "subsystem" in the form "system:subsystem".
+     * @param fields Logging fields to be included as metadata.
+     * @param args Any parameters to passed to a utils.format() type formatter.
+     */
+    log(namespace: string, fields: LogFields, ...args: unknown[]): void;
+    /**
+     * Passes in the system/subsystem filters from the global environment variables.
+     * This lets the backend merge with any native ones.
+     *
+     * @param filters A list of wildcards matching systems or system:subsystem pairs.
+     */
+    setFilters(filters: string[]): void;
+}
+/**
+ * The base class for debug logging backends. It's possible to use this, but the
+ * same non-guarantees above still apply (unstable interface, etc).
+ *
+ * @private
+ * @internal
+ */
+export declare abstract class DebugLogBackendBase implements DebugLogBackend {
+    cached: Map<string, AdhocDebugLogCallable>;
+    filters: string[];
+    filtersSet: boolean;
+    constructor();
+    /**
+     * Creates a callback function that we can call to send log lines out.
+     *
+     * @param namespace The system/subsystem namespace.
+     */
+    abstract makeLogger(namespace: string): AdhocDebugLogCallable;
+    /**
+     * Provides a callback for the subclass to hook if it needs to do something
+     * specific with `this.filters`.
+     */
+    abstract setFilters(): void;
+    log(namespace: string, fields: LogFields, ...args: unknown[]): void;
+}
+/**
+ * @returns A backend based on Node util.debuglog; this is the default.
+ */
+export declare function getNodeBackend(): DebugLogBackend;
+type DebugPackage = any;
+/**
+ * Creates a "debug" package backend. The user must call require('debug') and pass
+ * the resulting object to this function.
+ *
+ * ```
+ *  setBackend(getDebugBackend(require('debug')))
+ * ```
+ *
+ * https://www.npmjs.com/package/debug
+ *
+ * Note: Google does not explicitly endorse or recommend this package; it's just
+ * being provided as an option.
+ *
+ * @returns A backend based on the npm "debug" package.
+ */
+export declare function getDebugBackend(debugPkg: DebugPackage): DebugLogBackend;
+/**
+ * Creates a "structured logging" backend. This pretty much works like the
+ * Node logger, but it outputs structured logging JSON matching Google
+ * Cloud's ingestion specs instead of plain text.
+ *
+ * ```
+ *  setBackend(getStructuredBackend())
+ * ```
+ *
+ * @param upstream If you want to use something besides the Node backend to
+ *   write the actual log lines into, pass that here.
+ * @returns A backend based on Google Cloud structured logging.
+ */
+export declare function getStructuredBackend(upstream?: DebugLogBackend): DebugLogBackend;
+/**
+ * The environment variables that we standardized on, for all ad-hoc logging.
+ */
+export declare const env: {
+    /**
+     * Filter wildcards specific to the Node syntax, and similar to the built-in
+     * utils.debuglog() environment variable. If missing, disables logging.
+     */
+    nodeEnables: string;
+};
+/**
+ * Set the backend to use for our log output.
+ * - A backend object
+ * - null to disable logging
+ * - undefined for "nothing yet", defaults to the Node backend
+ *
+ * @param backend Results from one of the get*Backend() functions.
+ */
+export declare function setBackend(backend: DebugLogBackend | null | undefined): void;
+/**
+ * Creates a logging function. Multiple calls to this with the same namespace
+ * will produce the same logger, with the same event emitter hooks.
+ *
+ * Namespaces can be a simple string ("system" name), or a qualified string
+ * (system:subsystem), which can be used for filtering, or for "system:*".
+ *
+ * @param namespace The namespace, a descriptive text string.
+ * @returns A function you can call that works similar to console.log().
+ */
+export declare function log(namespace: string, parent?: AdhocDebugLogFunction): AdhocDebugLogFunction;
+export {};