@eko-ai/eko 1.2.0 → 1.2.2

package/dist/extension.cjs.js

@@ -1,5 +1,633 @@
 'use strict';
 
+var os = require('os');
+var path = require('path');
+var util = require('util');
+
+const prettyLogStyles = {
+    reset: [0, 0],
+    bold: [1, 22],
+    dim: [2, 22],
+    italic: [3, 23],
+    underline: [4, 24],
+    overline: [53, 55],
+    inverse: [7, 27],
+    hidden: [8, 28],
+    strikethrough: [9, 29],
+    black: [30, 39],
+    red: [31, 39],
+    green: [32, 39],
+    yellow: [33, 39],
+    blue: [34, 39],
+    magenta: [35, 39],
+    cyan: [36, 39],
+    white: [37, 39],
+    blackBright: [90, 39],
+    redBright: [91, 39],
+    greenBright: [92, 39],
+    yellowBright: [93, 39],
+    blueBright: [94, 39],
+    magentaBright: [95, 39],
+    cyanBright: [96, 39],
+    whiteBright: [97, 39],
+    bgBlack: [40, 49],
+    bgRed: [41, 49],
+    bgGreen: [42, 49],
+    bgYellow: [43, 49],
+    bgBlue: [44, 49],
+    bgMagenta: [45, 49],
+    bgCyan: [46, 49],
+    bgWhite: [47, 49],
+    bgBlackBright: [100, 49],
+    bgRedBright: [101, 49],
+    bgGreenBright: [102, 49],
+    bgYellowBright: [103, 49],
+    bgBlueBright: [104, 49],
+    bgMagentaBright: [105, 49],
+    bgCyanBright: [106, 49],
+    bgWhiteBright: [107, 49],
+};
+
+function formatTemplate(settings, template, values, hideUnsetPlaceholder = false) {
+    const templateString = String(template);
+    const ansiColorWrap = (placeholderValue, code) => `\u001b[${code[0]}m${placeholderValue}\u001b[${code[1]}m`;
+    const styleWrap = (value, style) => {
+        if (style != null && typeof style === "string") {
+            return ansiColorWrap(value, prettyLogStyles[style]);
+        }
+        else if (style != null && Array.isArray(style)) {
+            return style.reduce((prevValue, thisStyle) => styleWrap(prevValue, thisStyle), value);
+        }
+        else {
+            if (style != null && style[value.trim()] != null) {
+                return styleWrap(value, style[value.trim()]);
+            }
+            else if (style != null && style["*"] != null) {
+                return styleWrap(value, style["*"]);
+            }
+            else {
+                return value;
+            }
+        }
+    };
+    const defaultStyle = null;
+    return templateString.replace(/{{(.+?)}}/g, (_, placeholder) => {
+        const value = values[placeholder] != null ? String(values[placeholder]) : hideUnsetPlaceholder ? "" : _;
+        return settings.stylePrettyLogs
+            ? styleWrap(value, settings?.prettyLogStyles?.[placeholder] ?? defaultStyle) + ansiColorWrap("", prettyLogStyles.reset)
+            : value;
+    });
+}
+
+function formatNumberAddZeros(value, digits = 2, addNumber = 0) {
+    if (value != null && isNaN(value)) {
+        return "";
+    }
+    value = value != null ? value + addNumber : value;
+    return digits === 2
+        ? value == null
+            ? "--"
+            : value < 10
+                ? "0" + value
+                : value.toString()
+        : value == null
+            ? "---"
+            : value < 10
+                ? "00" + value
+                : value < 100
+                    ? "0" + value
+                    : value.toString();
+}
+
+function urlToObject(url) {
+    return {
+        href: url.href,
+        protocol: url.protocol,
+        username: url.username,
+        password: url.password,
+        host: url.host,
+        hostname: url.hostname,
+        port: url.port,
+        pathname: url.pathname,
+        search: url.search,
+        searchParams: [...url.searchParams].map(([key, value]) => ({ key, value })),
+        hash: url.hash,
+        origin: url.origin,
+    };
+}
+
+var Runtime = {
+    getCallerStackFrame,
+    getErrorTrace,
+    getMeta,
+    transportJSON,
+    transportFormatted: transportFormatted$1,
+    isBuffer,
+    isError,
+    prettyFormatLogObj,
+    prettyFormatErrorObj,
+};
+const meta = {
+    runtime: "Nodejs",
+    runtimeVersion: process?.version,
+    hostname: os.hostname ? os.hostname() : undefined,
+};
+function getMeta(logLevelId, logLevelName, stackDepthLevel, hideLogPositionForPerformance, name, parentNames) {
+    return Object.assign({}, meta, {
+        name,
+        parentNames,
+        date: new Date(),
+        logLevelId,
+        logLevelName,
+        path: !hideLogPositionForPerformance ? getCallerStackFrame(stackDepthLevel) : undefined,
+    });
+}
+function getCallerStackFrame(stackDepthLevel, error = Error()) {
+    return stackLineToStackFrame(error?.stack?.split("\n")?.filter((thisLine) => thisLine.includes("    at "))?.[stackDepthLevel]);
+}
+function getErrorTrace(error) {
+    return error?.stack?.split("\n")?.reduce((result, line) => {
+        if (line.includes("    at ")) {
+            result.push(stackLineToStackFrame(line));
+        }
+        return result;
+    }, []);
+}
+function stackLineToStackFrame(line) {
+    const pathResult = {
+        fullFilePath: undefined,
+        fileName: undefined,
+        fileNameWithLine: undefined,
+        fileColumn: undefined,
+        fileLine: undefined,
+        filePath: undefined,
+        filePathWithLine: undefined,
+        method: undefined,
+    };
+    if (line != null && line.includes("    at ")) {
+        line = line.replace(/^\s+at\s+/gm, "");
+        const errorStackLine = line.split(" (");
+        const fullFilePath = line?.slice(-1) === ")" ? line?.match(/\(([^)]+)\)/)?.[1] : line;
+        const pathArray = fullFilePath?.includes(":") ? fullFilePath?.replace("file://", "")?.replace(process.cwd(), "")?.split(":") : undefined;
+        const fileColumn = pathArray?.pop();
+        const fileLine = pathArray?.pop();
+        const filePath = pathArray?.pop();
+        const filePathWithLine = path.normalize(`${filePath}:${fileLine}`);
+        const fileName = filePath?.split("/")?.pop();
+        const fileNameWithLine = `${fileName}:${fileLine}`;
+        if (filePath != null && filePath.length > 0) {
+            pathResult.fullFilePath = fullFilePath;
+            pathResult.fileName = fileName;
+            pathResult.fileNameWithLine = fileNameWithLine;
+            pathResult.fileColumn = fileColumn;
+            pathResult.fileLine = fileLine;
+            pathResult.filePath = filePath;
+            pathResult.filePathWithLine = filePathWithLine;
+            pathResult.method = errorStackLine?.[1] != null ? errorStackLine?.[0] : undefined;
+        }
+    }
+    return pathResult;
+}
+function isError(e) {
+    return util.types?.isNativeError != null ? util.types.isNativeError(e) : e instanceof Error;
+}
+function prettyFormatLogObj(maskedArgs, settings) {
+    return maskedArgs.reduce((result, arg) => {
+        isError(arg) ? result.errors.push(prettyFormatErrorObj(arg, settings)) : result.args.push(arg);
+        return result;
+    }, { args: [], errors: [] });
+}
+function prettyFormatErrorObj(error, settings) {
+    const errorStackStr = getErrorTrace(error).map((stackFrame) => {
+        return formatTemplate(settings, settings.prettyErrorStackTemplate, { ...stackFrame }, true);
+    });
+    const placeholderValuesError = {
+        errorName: ` ${error.name} `,
+        errorMessage: Object.getOwnPropertyNames(error)
+            .reduce((result, key) => {
+            if (key !== "stack") {
+                result.push(error[key]);
+            }
+            return result;
+        }, [])
+            .join(", "),
+        errorStack: errorStackStr.join("\n"),
+    };
+    return formatTemplate(settings, settings.prettyErrorTemplate, placeholderValuesError);
+}
+function transportFormatted$1(logMetaMarkup, logArgs, logErrors, settings) {
+    const logErrorsStr = (logErrors.length > 0 && logArgs.length > 0 ? "\n" : "") + logErrors.join("\n");
+    settings.prettyInspectOptions.colors = settings.stylePrettyLogs;
+    console.log(logMetaMarkup + util.formatWithOptions(settings.prettyInspectOptions, ...logArgs) + logErrorsStr);
+}
+function transportJSON(json) {
+    console.log(jsonStringifyRecursive(json));
+    function jsonStringifyRecursive(obj) {
+        const cache = new Set();
+        return JSON.stringify(obj, (key, value) => {
+            if (typeof value === "object" && value !== null) {
+                if (cache.has(value)) {
+                    return "[Circular]";
+                }
+                cache.add(value);
+            }
+            if (typeof value === "bigint") {
+                return `${value}`;
+            }
+            if (typeof value === "undefined") {
+                return "[undefined]";
+            }
+            return value;
+        });
+    }
+}
+function isBuffer(arg) {
+    return Buffer.isBuffer(arg);
+}
+
+class BaseLogger {
+    constructor(settings, logObj, stackDepthLevel = 4) {
+        this.logObj = logObj;
+        this.stackDepthLevel = stackDepthLevel;
+        this.runtime = Runtime;
+        this.settings = {
+            type: settings?.type ?? "pretty",
+            name: settings?.name,
+            parentNames: settings?.parentNames,
+            minLevel: settings?.minLevel ?? 0,
+            argumentsArrayName: settings?.argumentsArrayName,
+            hideLogPositionForProduction: settings?.hideLogPositionForProduction ?? false,
+            prettyLogTemplate: settings?.prettyLogTemplate ??
+                "{{yyyy}}.{{mm}}.{{dd}} {{hh}}:{{MM}}:{{ss}}:{{ms}}\t{{logLevelName}}\t{{filePathWithLine}}{{nameWithDelimiterPrefix}}\t",
+            prettyErrorTemplate: settings?.prettyErrorTemplate ?? "\n{{errorName}} {{errorMessage}}\nerror stack:\n{{errorStack}}",
+            prettyErrorStackTemplate: settings?.prettyErrorStackTemplate ?? "  • {{fileName}}\t{{method}}\n\t{{filePathWithLine}}",
+            prettyErrorParentNamesSeparator: settings?.prettyErrorParentNamesSeparator ?? ":",
+            prettyErrorLoggerNameDelimiter: settings?.prettyErrorLoggerNameDelimiter ?? "\t",
+            stylePrettyLogs: settings?.stylePrettyLogs ?? true,
+            prettyLogTimeZone: settings?.prettyLogTimeZone ?? "UTC",
+            prettyLogStyles: settings?.prettyLogStyles ?? {
+                logLevelName: {
+                    "*": ["bold", "black", "bgWhiteBright", "dim"],
+                    SILLY: ["bold", "white"],
+                    TRACE: ["bold", "whiteBright"],
+                    DEBUG: ["bold", "green"],
+                    INFO: ["bold", "blue"],
+                    WARN: ["bold", "yellow"],
+                    ERROR: ["bold", "red"],
+                    FATAL: ["bold", "redBright"],
+                },
+                dateIsoStr: "white",
+                filePathWithLine: "white",
+                name: ["white", "bold"],
+                nameWithDelimiterPrefix: ["white", "bold"],
+                nameWithDelimiterSuffix: ["white", "bold"],
+                errorName: ["bold", "bgRedBright", "whiteBright"],
+                fileName: ["yellow"],
+                fileNameWithLine: "white",
+            },
+            prettyInspectOptions: settings?.prettyInspectOptions ?? {
+                colors: true,
+                compact: false,
+                depth: Infinity,
+            },
+            metaProperty: settings?.metaProperty ?? "_meta",
+            maskPlaceholder: settings?.maskPlaceholder ?? "[***]",
+            maskValuesOfKeys: settings?.maskValuesOfKeys ?? ["password"],
+            maskValuesOfKeysCaseInsensitive: settings?.maskValuesOfKeysCaseInsensitive ?? false,
+            maskValuesRegEx: settings?.maskValuesRegEx,
+            prefix: [...(settings?.prefix ?? [])],
+            attachedTransports: [...(settings?.attachedTransports ?? [])],
+            overwrite: {
+                mask: settings?.overwrite?.mask,
+                toLogObj: settings?.overwrite?.toLogObj,
+                addMeta: settings?.overwrite?.addMeta,
+                addPlaceholders: settings?.overwrite?.addPlaceholders,
+                formatMeta: settings?.overwrite?.formatMeta,
+                formatLogObj: settings?.overwrite?.formatLogObj,
+                transportFormatted: settings?.overwrite?.transportFormatted,
+                transportJSON: settings?.overwrite?.transportJSON,
+            },
+        };
+    }
+    log(logLevelId, logLevelName, ...args) {
+        if (logLevelId < this.settings.minLevel) {
+            return;
+        }
+        const logArgs = [...this.settings.prefix, ...args];
+        const maskedArgs = this.settings.overwrite?.mask != null
+            ? this.settings.overwrite?.mask(logArgs)
+            : this.settings.maskValuesOfKeys != null && this.settings.maskValuesOfKeys.length > 0
+                ? this._mask(logArgs)
+                : logArgs;
+        const thisLogObj = this.logObj != null ? this._recursiveCloneAndExecuteFunctions(this.logObj) : undefined;
+        const logObj = this.settings.overwrite?.toLogObj != null ? this.settings.overwrite?.toLogObj(maskedArgs, thisLogObj) : this._toLogObj(maskedArgs, thisLogObj);
+        const logObjWithMeta = this.settings.overwrite?.addMeta != null
+            ? this.settings.overwrite?.addMeta(logObj, logLevelId, logLevelName)
+            : this._addMetaToLogObj(logObj, logLevelId, logLevelName);
+        let logMetaMarkup;
+        let logArgsAndErrorsMarkup = undefined;
+        if (this.settings.overwrite?.formatMeta != null) {
+            logMetaMarkup = this.settings.overwrite?.formatMeta(logObjWithMeta?.[this.settings.metaProperty]);
+        }
+        if (this.settings.overwrite?.formatLogObj != null) {
+            logArgsAndErrorsMarkup = this.settings.overwrite?.formatLogObj(maskedArgs, this.settings);
+        }
+        if (this.settings.type === "pretty") {
+            logMetaMarkup = logMetaMarkup ?? this._prettyFormatLogObjMeta(logObjWithMeta?.[this.settings.metaProperty]);
+            logArgsAndErrorsMarkup = logArgsAndErrorsMarkup ?? this.runtime.prettyFormatLogObj(maskedArgs, this.settings);
+        }
+        if (logMetaMarkup != null && logArgsAndErrorsMarkup != null) {
+            this.settings.overwrite?.transportFormatted != null
+                ? this.settings.overwrite?.transportFormatted(logMetaMarkup, logArgsAndErrorsMarkup.args, logArgsAndErrorsMarkup.errors, this.settings)
+                : this.runtime.transportFormatted(logMetaMarkup, logArgsAndErrorsMarkup.args, logArgsAndErrorsMarkup.errors, this.settings);
+        }
+        else {
+            this.settings.overwrite?.transportJSON != null
+                ? this.settings.overwrite?.transportJSON(logObjWithMeta)
+                : this.settings.type !== "hidden"
+                    ? this.runtime.transportJSON(logObjWithMeta)
+                    : undefined;
+        }
+        if (this.settings.attachedTransports != null && this.settings.attachedTransports.length > 0) {
+            this.settings.attachedTransports.forEach((transportLogger) => {
+                transportLogger(logObjWithMeta);
+            });
+        }
+        return logObjWithMeta;
+    }
+    attachTransport(transportLogger) {
+        this.settings.attachedTransports.push(transportLogger);
+    }
+    getSubLogger(settings, logObj) {
+        const subLoggerSettings = {
+            ...this.settings,
+            ...settings,
+            parentNames: this.settings?.parentNames != null && this.settings?.name != null
+                ? [...this.settings.parentNames, this.settings.name]
+                : this.settings?.name != null
+                    ? [this.settings.name]
+                    : undefined,
+            prefix: [...this.settings.prefix, ...(settings?.prefix ?? [])],
+        };
+        const subLogger = new this.constructor(subLoggerSettings, logObj ?? this.logObj, this.stackDepthLevel);
+        return subLogger;
+    }
+    _mask(args) {
+        const maskValuesOfKeys = this.settings.maskValuesOfKeysCaseInsensitive !== true ? this.settings.maskValuesOfKeys : this.settings.maskValuesOfKeys.map((key) => key.toLowerCase());
+        return args?.map((arg) => {
+            return this._recursiveCloneAndMaskValuesOfKeys(arg, maskValuesOfKeys);
+        });
+    }
+    _recursiveCloneAndMaskValuesOfKeys(source, keys, seen = []) {
+        if (seen.includes(source)) {
+            return { ...source };
+        }
+        if (typeof source === "object" && source !== null) {
+            seen.push(source);
+        }
+        if (this.runtime.isError(source) || this.runtime.isBuffer(source)) {
+            return source;
+        }
+        else if (source instanceof Map) {
+            return new Map(source);
+        }
+        else if (source instanceof Set) {
+            return new Set(source);
+        }
+        else if (Array.isArray(source)) {
+            return source.map((item) => this._recursiveCloneAndMaskValuesOfKeys(item, keys, seen));
+        }
+        else if (source instanceof Date) {
+            return new Date(source.getTime());
+        }
+        else if (source instanceof URL) {
+            return urlToObject(source);
+        }
+        else if (source !== null && typeof source === "object") {
+            const baseObject = this.runtime.isError(source) ? this._cloneError(source) : Object.create(Object.getPrototypeOf(source));
+            return Object.getOwnPropertyNames(source).reduce((o, prop) => {
+                o[prop] = keys.includes(this.settings?.maskValuesOfKeysCaseInsensitive !== true ? prop : prop.toLowerCase())
+                    ? this.settings.maskPlaceholder
+                    : (() => {
+                        try {
+                            return this._recursiveCloneAndMaskValuesOfKeys(source[prop], keys, seen);
+                        }
+                        catch (e) {
+                            return null;
+                        }
+                    })();
+                return o;
+            }, baseObject);
+        }
+        else {
+            if (typeof source === "string") {
+                let modifiedSource = source;
+                for (const regEx of this.settings?.maskValuesRegEx || []) {
+                    modifiedSource = modifiedSource.replace(regEx, this.settings?.maskPlaceholder || "");
+                }
+                return modifiedSource;
+            }
+            return source;
+        }
+    }
+    _recursiveCloneAndExecuteFunctions(source, seen = []) {
+        if (this.isObjectOrArray(source) && seen.includes(source)) {
+            return this.shallowCopy(source);
+        }
+        if (this.isObjectOrArray(source)) {
+            seen.push(source);
+        }
+        if (Array.isArray(source)) {
+            return source.map((item) => this._recursiveCloneAndExecuteFunctions(item, seen));
+        }
+        else if (source instanceof Date) {
+            return new Date(source.getTime());
+        }
+        else if (this.isObject(source)) {
+            return Object.getOwnPropertyNames(source).reduce((o, prop) => {
+                const descriptor = Object.getOwnPropertyDescriptor(source, prop);
+                if (descriptor) {
+                    Object.defineProperty(o, prop, descriptor);
+                    const value = source[prop];
+                    o[prop] = typeof value === "function" ? value() : this._recursiveCloneAndExecuteFunctions(value, seen);
+                }
+                return o;
+            }, Object.create(Object.getPrototypeOf(source)));
+        }
+        else {
+            return source;
+        }
+    }
+    isObjectOrArray(value) {
+        return typeof value === "object" && value !== null;
+    }
+    isObject(value) {
+        return typeof value === "object" && !Array.isArray(value) && value !== null;
+    }
+    shallowCopy(source) {
+        if (Array.isArray(source)) {
+            return [...source];
+        }
+        else {
+            return { ...source };
+        }
+    }
+    _toLogObj(args, clonedLogObj = {}) {
+        args = args?.map((arg) => (this.runtime.isError(arg) ? this._toErrorObject(arg) : arg));
+        if (this.settings.argumentsArrayName == null) {
+            if (args.length === 1 && !Array.isArray(args[0]) && this.runtime.isBuffer(args[0]) !== true && !(args[0] instanceof Date)) {
+                clonedLogObj = typeof args[0] === "object" && args[0] != null ? { ...args[0], ...clonedLogObj } : { 0: args[0], ...clonedLogObj };
+            }
+            else {
+                clonedLogObj = { ...clonedLogObj, ...args };
+            }
+        }
+        else {
+            clonedLogObj = {
+                ...clonedLogObj,
+                [this.settings.argumentsArrayName]: args,
+            };
+        }
+        return clonedLogObj;
+    }
+    _cloneError(error) {
+        const cloned = new error.constructor();
+        Object.getOwnPropertyNames(error).forEach((key) => {
+            cloned[key] = error[key];
+        });
+        return cloned;
+    }
+    _toErrorObject(error) {
+        return {
+            nativeError: error,
+            name: error.name ?? "Error",
+            message: error.message,
+            stack: this.runtime.getErrorTrace(error),
+        };
+    }
+    _addMetaToLogObj(logObj, logLevelId, logLevelName) {
+        return {
+            ...logObj,
+            [this.settings.metaProperty]: this.runtime.getMeta(logLevelId, logLevelName, this.stackDepthLevel, this.settings.hideLogPositionForProduction, this.settings.name, this.settings.parentNames),
+        };
+    }
+    _prettyFormatLogObjMeta(logObjMeta) {
+        if (logObjMeta == null) {
+            return "";
+        }
+        let template = this.settings.prettyLogTemplate;
+        const placeholderValues = {};
+        if (template.includes("{{yyyy}}.{{mm}}.{{dd}} {{hh}}:{{MM}}:{{ss}}:{{ms}}")) {
+            template = template.replace("{{yyyy}}.{{mm}}.{{dd}} {{hh}}:{{MM}}:{{ss}}:{{ms}}", "{{dateIsoStr}}");
+        }
+        else {
+            if (this.settings.prettyLogTimeZone === "UTC") {
+                placeholderValues["yyyy"] = logObjMeta?.date?.getUTCFullYear() ?? "----";
+                placeholderValues["mm"] = formatNumberAddZeros(logObjMeta?.date?.getUTCMonth(), 2, 1);
+                placeholderValues["dd"] = formatNumberAddZeros(logObjMeta?.date?.getUTCDate(), 2);
+                placeholderValues["hh"] = formatNumberAddZeros(logObjMeta?.date?.getUTCHours(), 2);
+                placeholderValues["MM"] = formatNumberAddZeros(logObjMeta?.date?.getUTCMinutes(), 2);
+                placeholderValues["ss"] = formatNumberAddZeros(logObjMeta?.date?.getUTCSeconds(), 2);
+                placeholderValues["ms"] = formatNumberAddZeros(logObjMeta?.date?.getUTCMilliseconds(), 3);
+            }
+            else {
+                placeholderValues["yyyy"] = logObjMeta?.date?.getFullYear() ?? "----";
+                placeholderValues["mm"] = formatNumberAddZeros(logObjMeta?.date?.getMonth(), 2, 1);
+                placeholderValues["dd"] = formatNumberAddZeros(logObjMeta?.date?.getDate(), 2);
+                placeholderValues["hh"] = formatNumberAddZeros(logObjMeta?.date?.getHours(), 2);
+                placeholderValues["MM"] = formatNumberAddZeros(logObjMeta?.date?.getMinutes(), 2);
+                placeholderValues["ss"] = formatNumberAddZeros(logObjMeta?.date?.getSeconds(), 2);
+                placeholderValues["ms"] = formatNumberAddZeros(logObjMeta?.date?.getMilliseconds(), 3);
+            }
+        }
+        const dateInSettingsTimeZone = this.settings.prettyLogTimeZone === "UTC" ? logObjMeta?.date : new Date(logObjMeta?.date?.getTime() - logObjMeta?.date?.getTimezoneOffset() * 60000);
+        placeholderValues["rawIsoStr"] = dateInSettingsTimeZone?.toISOString();
+        placeholderValues["dateIsoStr"] = dateInSettingsTimeZone?.toISOString().replace("T", " ").replace("Z", "");
+        placeholderValues["logLevelName"] = logObjMeta?.logLevelName;
+        placeholderValues["fileNameWithLine"] = logObjMeta?.path?.fileNameWithLine ?? "";
+        placeholderValues["filePathWithLine"] = logObjMeta?.path?.filePathWithLine ?? "";
+        placeholderValues["fullFilePath"] = logObjMeta?.path?.fullFilePath ?? "";
+        let parentNamesString = this.settings.parentNames?.join(this.settings.prettyErrorParentNamesSeparator);
+        parentNamesString = parentNamesString != null && logObjMeta?.name != null ? parentNamesString + this.settings.prettyErrorParentNamesSeparator : undefined;
+        placeholderValues["name"] = logObjMeta?.name != null || parentNamesString != null ? (parentNamesString ?? "") + logObjMeta?.name ?? "" : "";
+        placeholderValues["nameWithDelimiterPrefix"] =
+            placeholderValues["name"].length > 0 ? this.settings.prettyErrorLoggerNameDelimiter + placeholderValues["name"] : "";
+        placeholderValues["nameWithDelimiterSuffix"] =
+            placeholderValues["name"].length > 0 ? placeholderValues["name"] + this.settings.prettyErrorLoggerNameDelimiter : "";
+        if (this.settings.overwrite?.addPlaceholders != null) {
+            this.settings.overwrite?.addPlaceholders(logObjMeta, placeholderValues);
+        }
+        return formatTemplate(this.settings, template, placeholderValues);
+    }
+}
+
+class Logger extends BaseLogger {
+    constructor(settings, logObj) {
+        const isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
+        const isBrowserBlinkEngine = isBrowser ? window.chrome !== undefined && window.CSS !== undefined && window.CSS.supports("color", "green") : false;
+        const isSafari = isBrowser ? /^((?!chrome|android).)*safari/i.test(navigator.userAgent) : false;
+        settings = settings || {};
+        settings.stylePrettyLogs = settings.stylePrettyLogs && isBrowser && !isBrowserBlinkEngine ? false : settings.stylePrettyLogs;
+        super(settings, logObj, isSafari ? 4 : 5);
+    }
+    log(logLevelId, logLevelName, ...args) {
+        return super.log(logLevelId, logLevelName, ...args);
+    }
+    silly(...args) {
+        return super.log(0, "SILLY", ...args);
+    }
+    trace(...args) {
+        return super.log(1, "TRACE", ...args);
+    }
+    debug(...args) {
+        return super.log(2, "DEBUG", ...args);
+    }
+    info(...args) {
+        return super.log(3, "INFO", ...args);
+    }
+    warn(...args) {
+        return super.log(4, "WARN", ...args);
+    }
+    error(...args) {
+        return super.log(5, "ERROR", ...args);
+    }
+    fatal(...args) {
+        return super.log(6, "FATAL", ...args);
+    }
+    getSubLogger(settings, logObj) {
+        return super.getSubLogger(settings, logObj);
+    }
+}
+
+function transportFormatted(logMetaMarkup, logArgs, logErrors, settings) {
+    const logErrorsStr = (logErrors.length > 0 && logArgs.length > 0 ? "\n" : "") + logErrors.join("\n");
+    settings.prettyInspectOptions.colors = settings.stylePrettyLogs;
+    console.log(logMetaMarkup, ...logArgs, logErrorsStr);
+}
+function formatMeta(logObjMeta) {
+    if (!logObjMeta) {
+        return '';
+    }
+    const { date, logLevelName } = logObjMeta;
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    const hours = String(date.getHours()).padStart(2, '0');
+    const minutes = String(date.getMinutes()).padStart(2, '0');
+    const seconds = String(date.getSeconds()).padStart(2, '0');
+    const milliseconds = String(date.getMilliseconds()).padStart(3, '0');
+    const formattedDate = `${year}-${month}-${day} ${hours}:${minutes}:${seconds}.${milliseconds}`;
+    const loggerName = logObjMeta.name;
+    return `${formattedDate} ${logLevelName} ${loggerName}`;
+}
+const logger = new Logger({
+    name: "ekoLogger",
+    overwrite: {
+        transportFormatted,
+        formatMeta,
+    }
+});
+
 async function getWindowId(context) {
     let windowId = context.variables.get('windowId');
     if (windowId) {
@@ -30,11 +658,12 @@ async function getWindowId(context) {
         windowId = window.FELLOU_WINDOW_ID;
     }
     if (!windowId) {
-        console.warn("`getWindowId()` returns " + windowId);
+        logger.warn("`getWindowId()` returns " + windowId);
     }
     return windowId;
 }
 async function getTabId(context) {
+    logger.debug("debug the getTabId()...");
     let tabId = context.variables.get('tabId');
     if (tabId) {
         try {
@@ -46,56 +675,58 @@ async function getTabId(context) {
         }
     }
     if (!tabId) {
-        console.log("tabId is empty");
+        logger.debug("tabId is empty");
         let windowId = await getWindowId(context);
-        console.log(`windowId=${windowId}`);
+        logger.debug(`windowId=${windowId}`);
         if (windowId) {
             try {
                 tabId = await getCurrentTabId(context.ekoConfig.chromeProxy, windowId);
-                console.log("getCurrentTabId(context.ekoConfig.chromeProxy, windowId) returns " + tabId);
+                logger.debug("getCurrentTabId(context.ekoConfig.chromeProxy, windowId) returns " + tabId);
             }
             catch (e) {
                 tabId = await getCurrentTabId(context.ekoConfig.chromeProxy);
-                console.log("getCurrentTabId(context.ekoConfig.chromeProxy, windowId) throws an error");
-                console.log("getCurrentTabId(context.ekoConfig.chromeProxy) returns " + tabId);
+                logger.debug("getCurrentTabId(context.ekoConfig.chromeProxy, windowId) throws an error");
+                logger.debug("getCurrentTabId(context.ekoConfig.chromeProxy) returns " + tabId);
                 context.variables.delete('windowId');
             }
         }
         else {
             tabId = await getCurrentTabId(context.ekoConfig.chromeProxy);
-            console.log("getCurrentTabId(context.ekoConfig.chromeProxy) #2 returns " + tabId);
+            logger.debug("getCurrentTabId(context.ekoConfig.chromeProxy) #2 returns " + tabId);
         }
         if (!tabId) {
             throw new Error('Could not find a valid tab');
         }
         context.variables.set('tabId', tabId);
     }
+    logger.debug(`debug the getTabId()...returns ${tabId}`);
     return tabId;
 }
 function getCurrentTabId(chromeProxy, windowId) {
     return new Promise((resolve, reject) => {
-        console.debug("[getCurrentTabId] get the active tabId on: ", { windowId });
+        logger.debug("debug the Promise in getCurrentTabId()...");
+        logger.debug("get the active tabId on: ", { windowId });
         let queryInfo;
         if (windowId !== undefined) {
-            console.debug(`[getCurrentTabId] get the active tab in window (windowId=${windowId})...`);
+            logger.debug(`get the active tab in window (windowId=${windowId})...`);
             queryInfo = { windowId, active: true };
         }
         else {
-            console.debug(`[getCurrentTabId] get the active tabId on current window`);
+            logger.debug(`get the active tabId on current window`);
             queryInfo = { active: true, currentWindow: true };
         }
         chrome.tabs.query(queryInfo, (tabs) => {
             if (chromeProxy.runtime.lastError) {
-                console.error(`[getCurrentTabId] failed to get: `, chromeProxy.runtime.lastError);
+                logger.error(`failed to get: `, chromeProxy.runtime.lastError);
                 reject(chromeProxy.runtime.lastError);
                 return;
             }
             if (tabs.length > 0) {
-                console.debug(`[getCurrentTabId] found the tab, ID=${tabs[0].id}`);
+                logger.debug(`found the tab, ID=${tabs[0].id}`);
                 resolve(tabs[0].id);
             }
             else {
-                console.debug(`[getCurrentTabId] cannot find the tab, returns undefined`);
+                logger.debug(`cannot find the tab, returns undefined`);
                 resolve(undefined);
             }
         });
@@ -106,17 +737,17 @@ async function open_new_tab(chromeProxy, url, windowId) {
         const window = await chromeProxy.windows.getCurrent();
         windowId = window.id;
     }
-    console.log("windowId: " + windowId);
+    logger.debug("windowId: " + windowId);
     let tab = await chromeProxy.tabs.create({
         url: url,
         windowId: windowId,
     });
-    console.log("chromeProxy.tabs.create() done");
+    logger.debug("chromeProxy.tabs.create() done");
     let tabId = tab.id;
     let completedTab = await waitForTabComplete(chromeProxy, tabId);
-    console.log("waitForTabComplete() done");
+    logger.debug("waitForTabComplete() done");
     await sleep(200);
-    console.log("sleep() done");
+    logger.debug("sleep() done");
     return completedTab;
 }
 async function executeScript(chromeProxy, tabId, func, args) {
@@ -129,41 +760,43 @@ async function executeScript(chromeProxy, tabId, func, args) {
 }
 async function waitForTabComplete(chromeProxy, tabId, timeout = 30000) {
     return new Promise(async (resolve, reject) => {
+        logger.debug("debug waitForTabComplete()...");
         const time = setTimeout(async () => {
-            console.log("listener(#1)=", listener);
+            logger.debug("listener(#1)=", listener);
             chromeProxy.tabs.onUpdated.removeListener(listener);
-            console.log("tabId(#1)=", tabId);
+            logger.debug("tabId(#1)=", tabId);
             let tab = await chromeProxy.tabs.get(tabId);
-            console.log("tab(#1)=", tab);
+            logger.debug("tab(#1)=", tab);
             if (tab.status === 'complete') {
-                console.warn('Timeout: waitForTabComplete, but tab is already complete.');
+                logger.warn('Timeout: waitForTabComplete, but tab is already complete.');
                 resolve(tab);
             }
             else {
-                console.warn("Timeout: waitForTabComplete, and tab is not complete");
+                logger.warn("Timeout: waitForTabComplete, and tab is not complete");
                 resolve(tab);
             }
         }, timeout);
-        console.log("setTimeout done");
+        logger.debug("setTimeout done");
         const listener = async (updatedTabId, changeInfo, tab) => {
-            console.log("listener start...");
+            logger.debug("listener start...");
             if (updatedTabId === tabId && changeInfo.status === 'complete') {
-                console.log("listener(#2)=", listener);
+                logger.debug("listener(#2)=", listener);
                 chromeProxy.tabs.onUpdated.removeListener(listener);
                 clearTimeout(time);
                 resolve(tab);
             }
         };
-        console.log("tabId(#2)=", tabId);
+        logger.debug("tabId(#2)=", tabId);
         let tab = await chromeProxy.tabs.get(tabId);
-        console.log("tab(#2)=", tab);
+        logger.debug("tab(#2)=", tab);
         if (tab.status === 'complete') {
             resolve(tab);
             clearTimeout(time);
             return;
         }
-        console.log("listener(#3)=", listener);
+        logger.debug("listener(#3)=", listener);
         chromeProxy.tabs.onUpdated.addListener(listener);
+        logger.debug("debug waitForTabComplete()...done");
     });
 }
 async function doesTabExists(chromeProxy, tabId) {
@@ -229,7 +862,7 @@ class MsgEvent {
                 }
             }
             catch (e) {
-                console.error(e);
+                logger.error(e);
             }
         }
     }
@@ -291,12 +924,12 @@ var utils = /*#__PURE__*/Object.freeze({
 
 function isFellouBrowser(chromeProxy) {
     const result = typeof chromeProxy.browseruse == 'object';
-    console.log("isFellouBrowser", result);
+    logger.debug("isFellouBrowser", result);
     return result;
 }
 async function type(chromeProxy, tabId, text, coordinate) {
     const isFellou = isFellouBrowser(chromeProxy);
-    console.log('Sending type message to tab:', tabId, { text, coordinate }, isFellou ? ' > fellou' : '');
+    logger.debug('Sending type message to tab:', tabId, { text, coordinate }, isFellou ? ' > fellou' : '');
     try {
         if (!coordinate) {
             coordinate = (await cursor_position(chromeProxy, tabId)).coordinate;
@@ -321,17 +954,17 @@ async function type(chromeProxy, tabId, text, coordinate) {
                 coordinate,
             });
         }
-        console.log('type Got response:', response);
+        logger.debug('type Got response:', response);
         return response;
     }
     catch (e) {
-        console.error('Failed to send type message:', e);
+        logger.error('Failed to send type message:', e);
         throw e;
     }
 }
 async function type_by(chromeProxy, tabId, text, xpath, highlightIndex) {
     const isFellou = isFellouBrowser(chromeProxy);
-    console.log('Sending type_by message to tab:', tabId, { text, xpath, highlightIndex }, isFellou ? ' > fellou' : '');
+    logger.debug('Sending type_by message to tab:', tabId, { text, xpath, highlightIndex }, isFellou ? ' > fellou' : '');
     try {
         let response;
         if (isFellou) {
@@ -353,17 +986,17 @@ async function type_by(chromeProxy, tabId, text, xpath, highlightIndex) {
                 highlightIndex,
             });
         }
-        console.log('type_by Got response:', response);
+        logger.debug('type_by Got response:', response);
         return response;
     }
     catch (e) {
-        console.error('Failed to send type message:', e);
+        logger.error('Failed to send type message:', e);
         throw e;
     }
 }
 async function enter_by(chromeProxy, tabId, xpath, highlightIndex) {
     const isFellou = isFellouBrowser(chromeProxy);
-    console.log('Sending enter_by message to tab:', tabId, { xpath, highlightIndex }, isFellou ? ' > fellou' : '');
+    logger.debug('Sending enter_by message to tab:', tabId, { xpath, highlightIndex }, isFellou ? ' > fellou' : '');
     try {
         let response;
         if (isFellou) {
@@ -377,17 +1010,17 @@ async function enter_by(chromeProxy, tabId, xpath, highlightIndex) {
                 highlightIndex,
             });
         }
-        console.log('enter_by Got response:', response);
+        logger.debug('enter_by Got response:', response);
         return response;
     }
     catch (e) {
-        console.error('Failed to send enter_by message:', e);
+        logger.error('Failed to send enter_by message:', e);
         throw e;
     }
 }
 async function clear_input(chromeProxy, tabId, coordinate) {
     const isFellou = isFellouBrowser(chromeProxy);
-    console.log('Sending clear_input message to tab:', tabId, { coordinate }, isFellou ? ' > fellou' : '');
+    logger.debug('Sending clear_input message to tab:', tabId, { coordinate }, isFellou ? ' > fellou' : '');
     try {
         if (!coordinate) {
             coordinate = (await cursor_position(chromeProxy, tabId)).coordinate;
@@ -405,17 +1038,17 @@ async function clear_input(chromeProxy, tabId, coordinate) {
                 coordinate,
             });
         }
-        console.log('clear_input Got response:', response);
+        logger.debug('clear_input Got response:', response);
         return response;
     }
     catch (e) {
-        console.error('Failed to send clear_input message:', e);
+        logger.error('Failed to send clear_input message:', e);
         throw e;
     }
 }
 async function clear_input_by(chromeProxy, tabId, xpath, highlightIndex) {
     const isFellou = isFellouBrowser(chromeProxy);
-    console.log('Sending clear_input_by message to tab:', tabId, { xpath, highlightIndex }, isFellou ? ' > fellou' : '');
+    logger.debug('Sending clear_input_by message to tab:', tabId, { xpath, highlightIndex }, isFellou ? ' > fellou' : '');
     try {
         let response;
         if (isFellou) {
@@ -430,17 +1063,17 @@ async function clear_input_by(chromeProxy, tabId, xpath, highlightIndex) {
                 highlightIndex,
             });
         }
-        console.log('clear_input_by Got response:', response);
+        logger.debug('clear_input_by Got response:', response);
         return response;
     }
     catch (e) {
-        console.error('Failed to send clear_input_by message:', e);
+        logger.error('Failed to send clear_input_by message:', e);
         throw e;
     }
 }
 async function mouse_move(chromeProxy, tabId, coordinate) {
     const isFellou = isFellouBrowser(chromeProxy);
-    console.log('Sending mouse_move message to tab:', tabId, { coordinate }, isFellou ? ' > fellou' : '');
+    logger.debug('Sending mouse_move message to tab:', tabId, { coordinate }, isFellou ? ' > fellou' : '');
     let response;
     if (isFellou) {
         response = await chromeProxy.browseruse.mouse.move(tabId, coordinate[0], coordinate[1]);
@@ -451,12 +1084,12 @@ async function mouse_move(chromeProxy, tabId, coordinate) {
             coordinate,
         });
     }
-    console.log('mouse_move Got response:', response);
+    logger.debug('mouse_move Got response:', response);
     return response;
 }
 async function left_click(chromeProxy, tabId, coordinate) {
     const isFellou = isFellouBrowser(chromeProxy);
-    console.log('Sending left_click message to tab:', tabId, { coordinate }, isFellou ? ' > fellou' : '');
+    logger.debug('Sending left_click message to tab:', tabId, { coordinate }, isFellou ? ' > fellou' : '');
     if (!coordinate) {
         coordinate = (await cursor_position(chromeProxy, tabId)).coordinate;
     }
@@ -470,12 +1103,12 @@ async function left_click(chromeProxy, tabId, coordinate) {
             coordinate,
         });
     }
-    console.log('left_click Got response:', response);
+    logger.debug('left_click Got response:', response);
     return response;
 }
 async function left_click_by(chromeProxy, tabId, xpath, highlightIndex) {
     const isFellou = isFellouBrowser(chromeProxy);
-    console.log('Sending left_click_by message to tab:', tabId, { xpath, highlightIndex }, isFellou ? ' > fellou' : '');
+    logger.debug('Sending left_click_by message to tab:', tabId, { xpath, highlightIndex }, isFellou ? ' > fellou' : '');
     let response;
     if (isFellou) {
         response = await chromeProxy.browseruse.handle.click(tabId, build_fellou_handle_js(xpath, highlightIndex));
@@ -487,12 +1120,12 @@ async function left_click_by(chromeProxy, tabId, xpath, highlightIndex) {
             highlightIndex,
         });
     }
-    console.log('left_click_by Got response:', response);
+    logger.debug('left_click_by Got response:', response);
     return response;
 }
 async function right_click(chromeProxy, tabId, coordinate) {
     const isFellou = isFellouBrowser(chromeProxy);
-    console.log('Sending right_click message to tab:', tabId, { coordinate }, isFellou ? ' > fellou' : '');
+    logger.debug('Sending right_click message to tab:', tabId, { coordinate }, isFellou ? ' > fellou' : '');
     if (!coordinate) {
         coordinate = (await cursor_position(chromeProxy, tabId)).coordinate;
     }
@@ -506,12 +1139,12 @@ async function right_click(chromeProxy, tabId, coordinate) {
             coordinate,
         });
     }
-    console.log('right_click Got response:', response);
+    logger.debug('right_click Got response:', response);
     return response;
 }
 async function right_click_by(chromeProxy, tabId, xpath, highlightIndex) {
     const isFellou = isFellouBrowser(chromeProxy);
-    console.log('Sending right_click_by message to tab:', tabId, { xpath, highlightIndex }, isFellou ? ' > fellou' : '');
+    logger.debug('Sending right_click_by message to tab:', tabId, { xpath, highlightIndex }, isFellou ? ' > fellou' : '');
     let response;
     if (isFellou) {
         response = await chromeProxy.browseruse.handle.click(tabId, build_fellou_handle_js(xpath, highlightIndex), { button: 'right' });
@@ -523,12 +1156,12 @@ async function right_click_by(chromeProxy, tabId, xpath, highlightIndex) {
             highlightIndex,
         });
     }
-    console.log('right_click_by Got response:', response);
+    logger.debug('right_click_by Got response:', response);
     return response;
 }
 async function double_click(chromeProxy, tabId, coordinate) {
     const isFellou = isFellouBrowser(chromeProxy);
-    console.log('Sending double_click message to tab:', tabId, { coordinate }, isFellou ? ' > fellou' : '');
+    logger.debug('Sending double_click message to tab:', tabId, { coordinate }, isFellou ? ' > fellou' : '');
     if (!coordinate) {
         coordinate = (await cursor_position(chromeProxy, tabId)).coordinate;
     }
@@ -542,12 +1175,12 @@ async function double_click(chromeProxy, tabId, coordinate) {
             coordinate,
         });
     }
-    console.log('double_click Got response:', response);
+    logger.debug('double_click Got response:', response);
     return response;
 }
 async function double_click_by(chromeProxy, tabId, xpath, highlightIndex) {
     const isFellou = isFellouBrowser(chromeProxy);
-    console.log('Sending double_click_by message to tab:', tabId, { xpath, highlightIndex }, isFellou ? ' > fellou' : '');
+    logger.debug('Sending double_click_by message to tab:', tabId, { xpath, highlightIndex }, isFellou ? ' > fellou' : '');
     let response;
     if (isFellou) {
         response = await chromeProxy.browseruse.mouse.click(tabId, build_fellou_handle_js(xpath, highlightIndex), { count: 2 });
@@ -559,11 +1192,11 @@ async function double_click_by(chromeProxy, tabId, xpath, highlightIndex) {
             highlightIndex,
         });
     }
-    console.log('double_click_by Got response:', response);
+    logger.debug('double_click_by Got response:', response);
     return response;
 }
 async function screenshot(chromeProxy, windowId, compress) {
-    console.log('Taking screenshot of window:', windowId, { compress });
+    logger.debug('Taking screenshot of window:', windowId, { compress });
     try {
         let dataUrl;
         if (compress) {
@@ -587,12 +1220,12 @@ async function screenshot(chromeProxy, windowId, compress) {
                 data: data,
             },
         };
-        console.log('screenshot Got screenshot result:', result);
+        logger.debug('screenshot Got screenshot result:', result);
         return result;
     }
     catch (e) {
         if (isFellouBrowser(chromeProxy)) {
-            console.log('Failed to take screenshot, try fellou...');
+            logger.debug('Failed to take screenshot, try fellou...');
             const tabId = await getCurrentTabId(chromeProxy, windowId);
             const base64 = await chromeProxy.browseruse.screenshot(tabId, {
                 type: 'jpeg',
@@ -606,15 +1239,15 @@ async function screenshot(chromeProxy, windowId, compress) {
                     data: base64,
                 },
             };
-            console.log('screenshot Got screenshot result, try fellou:', result);
+            logger.debug('screenshot Got screenshot result, try fellou:', result);
             return result;
         }
-        console.error('Failed to take screenshot:', e);
+        logger.error('Failed to take screenshot:', e);
         throw e;
     }
 }
 async function compress_image(dataUrl, scale = 0.8, quality = 0.8) {
-    console.log('Compressing image', { scale, quality });
+    logger.debug('Compressing image', { scale, quality });
     try {
         const bitmap = await createImageBitmap(await (await fetch(dataUrl)).blob());
         let width = bitmap.width * scale;
@@ -630,56 +1263,56 @@ async function compress_image(dataUrl, scale = 0.8, quality = 0.8) {
             const reader = new FileReader();
             reader.onloadend = () => {
                 const result = reader.result;
-                console.log('Got compressed image result:', result);
+                logger.debug('Got compressed image result (sliced):', result.slice(0, 200));
                 resolve(result);
             };
             reader.readAsDataURL(blob);
         });
     }
     catch (e) {
-        console.error('Failed to compress image:', e);
+        logger.error('Failed to compress image:', e);
         return dataUrl;
     }
 }
 async function scroll_to(chromeProxy, tabId, coordinate) {
-    console.log('Sending scroll_to message to tab:', tabId, { coordinate });
+    logger.debug('Sending scroll_to message to tab:', tabId, { coordinate });
     let from_coordinate = (await cursor_position(chromeProxy, tabId)).coordinate;
     const response = await chromeProxy.tabs.sendMessage(tabId, {
         type: 'computer:scroll_to',
         from_coordinate,
         to_coordinate: coordinate,
     });
-    console.log('scroll_to Got response:', response);
+    logger.debug('scroll_to Got response:', response);
     return response;
 }
 async function scroll_to_by(chromeProxy, tabId, xpath, highlightIndex) {
-    console.log('Sending scroll_to_by message to tab:', tabId, { xpath, highlightIndex });
+    logger.debug('Sending scroll_to_by message to tab:', tabId, { xpath, highlightIndex });
     const response = await chromeProxy.tabs.sendMessage(tabId, {
         type: 'computer:scroll_to',
         xpath,
         highlightIndex,
     });
-    console.log('scroll_to_by Got response:', response);
+    logger.debug('scroll_to_by Got response:', response);
     return response;
 }
 async function get_dropdown_options(chromeProxy, tabId, xpath, highlightIndex) {
-    console.log('Sending get_dropdown_options message to tab:', tabId, { xpath, highlightIndex });
+    logger.debug('Sending get_dropdown_options message to tab:', tabId, { xpath, highlightIndex });
     try {
         const response = await chromeProxy.tabs.sendMessage(tabId, {
             type: 'computer:get_dropdown_options',
             xpath,
             highlightIndex,
         });
-        console.log('get_dropdown_options Got response:', response);
+        logger.debug('get_dropdown_options Got response:', response);
         return response;
     }
     catch (e) {
-        console.error('Failed to send get_dropdown_options message:', e);
+        logger.error('Failed to send get_dropdown_options message:', e);
         throw e;
     }
 }
 async function select_dropdown_option(chromeProxy, tabId, text, xpath, highlightIndex) {
-    console.log('Sending select_dropdown_option message to tab:', tabId, { text, xpath, highlightIndex });
+    logger.debug('Sending select_dropdown_option message to tab:', tabId, { text, xpath, highlightIndex });
     try {
         const response = await chromeProxy.tabs.sendMessage(tabId, {
             type: 'computer:select_dropdown_option',
@@ -687,37 +1320,37 @@ async function select_dropdown_option(chromeProxy, tabId, text, xpath, highlight
             xpath,
             highlightIndex,
         });
-        console.log('select_dropdown_option Got response:', response);
+        logger.debug('select_dropdown_option Got response:', response);
         return response;
     }
     catch (e) {
-        console.error('Failed to send select_dropdown_option message:', e);
+        logger.error('Failed to send select_dropdown_option message:', e);
         throw e;
     }
 }
 async function cursor_position(chromeProxy, tabId) {
-    console.log('Sending cursor_position message to tab:', tabId);
+    logger.debug('Sending cursor_position message to tab:', tabId);
     try {
         let result = await chromeProxy.tabs.sendMessage(tabId, {
             type: 'computer:cursor_position',
         });
-        console.log('Got cursor position:', result.coordinate);
+        logger.debug('Got cursor position:', result.coordinate);
         return { coordinate: result.coordinate };
     }
     catch (e) {
-        console.error('Failed to send cursor_position message:', e);
+        logger.error('Failed to send cursor_position message:', e);
         throw e;
     }
 }
 async function size(chromeProxy, tabId) {
-    console.log('Getting page size for tab:', tabId);
+    logger.debug('Getting page size for tab:', tabId);
     try {
         const pageSize = await getPageSize(chromeProxy, tabId);
-        console.log('Got page size:', pageSize);
+        logger.debug('Got page size:', pageSize);
         return pageSize;
     }
     catch (e) {
-        console.error('Failed to get page size:', e);
+        logger.error('Failed to get page size:', e);
         throw e;
     }
 }
@@ -757,7 +1390,8 @@ var browser = /*#__PURE__*/Object.freeze({
 class ToolReturnsScreenshot {
     async execute(context, params) {
         const realResult = await this.realExecute(context, params);
-        console.log("debug realResult...", realResult);
+        logger.debug("debug realResult...");
+        logger.debug(realResult);
         let instance = new BrowserUse();
         const image = await instance.realExecute(context, { action: "screenshot_extract_element" });
         return image;
@@ -834,22 +1468,22 @@ class BrowserUse extends ToolReturnsScreenshot {
      */
     async realExecute(context, params) {
         var _a;
-        console.log("execute 'browser_use'...");
+        logger.debug("debug 'browser_use'...");
+        logger.debug(params);
         try {
             if (params === null || !params.action) {
                 throw new Error('Invalid parameters. Expected an object with a "action" property.');
             }
             let tabId;
             try {
-                console.log("getTabId(context)...");
                 tabId = await getTabId(context);
-                console.log("getTabId(context)...done");
+                logger.debug(tabId);
                 if (!tabId || !Number.isInteger(tabId)) {
                     throw new Error('Could not get valid tab ID');
                 }
             }
             catch (e) {
-                console.error('Tab ID error:', e);
+                logger.error('Tab ID error:', e);
                 return { success: false, error: 'Could not access browser tab' };
             }
             let windowId = await getWindowId(context);
@@ -862,7 +1496,7 @@ class BrowserUse extends ToolReturnsScreenshot {
                 }
             }
             let result;
-            console.log("switch cases...");
+            logger.debug("switch cases...");
             switch (params.action) {
                 case 'input_text':
                     if (params.index == null) {
@@ -932,38 +1566,37 @@ class BrowserUse extends ToolReturnsScreenshot {
                     result = await select_dropdown_option(context.ekoConfig.chromeProxy, tabId, params.text, selector_xpath, params.index);
                     break;
                 case 'screenshot_extract_element':
-                    console.log("execute 'screenshot_extract_element'...");
+                    logger.debug("execute 'screenshot_extract_element'...");
                     await sleep(100);
-                    console.log("injectScript...");
+                    logger.debug("injectScript...");
                     await injectScript(context.ekoConfig.chromeProxy, tabId, 'build_dom_tree.js');
                     await sleep(100);
                     try {
-                        console.log("executeScript...");
+                        logger.debug("executeScript...");
                         let element_result = await executeScript(context.ekoConfig.chromeProxy, tabId, () => {
                             return window.get_clickable_elements(true);
                         }, []);
                         context.selector_map = element_result.selector_map;
-                        console.log("browser.screenshot...");
+                        logger.debug("browser.screenshot...");
                         let screenshot$1 = await screenshot(context.ekoConfig.chromeProxy, windowId, true);
                         result = { image: screenshot$1.image, text: element_result.element_str };
                     }
                     finally {
-                        console.log("executeScript #2...");
+                        logger.debug("executeScript #2...");
                         await executeScript(context.ekoConfig.chromeProxy, tabId, () => {
                             return window.remove_highlight();
                         }, []);
                     }
-                    console.log("execute 'screenshot_extract_element'...done");
+                    logger.debug("execute 'screenshot_extract_element'...done");
                     break;
                 default:
                     throw Error(`Invalid parameters. The "${params.action}" value is not included in the "action" enumeration.`);
             }
-            console.log("execute 'browser_use'...done, result=");
-            console.log(result);
+            logger.debug(`execute 'browser_use'...done, result=${result}`);
             return result;
         }
         catch (e) {
-            console.error('Browser use error:', e);
+            logger.error('Browser use error:', e);
             return { success: false, error: e === null || e === void 0 ? void 0 : e.message };
         }
     }
@@ -1137,7 +1770,7 @@ class GetAllTabs {
         const tabsInfo = [];
         for (const tab of tabs) {
             if (tab.id === undefined) {
-                console.warn(`Tab ID is undefined for tab with URL: ${tab.url}`);
+                logger.warn(`Tab ID is undefined for tab with URL: ${tab.url}`);
                 continue;
             }
             await injectScript(context.ekoConfig.chromeProxy, tab.id);
@@ -1154,9 +1787,7 @@ class GetAllTabs {
                 content: content,
                 description: description,
             };
-            console.log("url: " + tab.url);
-            console.log("title: " + tab.title);
-            console.log("description: " + description);
+            logger.debug(tabInfo);
             tabsInfo.push(tabInfo);
         }
         return tabsInfo;
@@ -1194,69 +1825,67 @@ class OpenUrl extends ToolReturnsScreenshot {
      */
     async realExecute(context, params) {
         var _a, _b, _c, _d, _e, _f;
-        console.log('Starting execute function with context:', context, 'and params:', params);
         // 参数验证
         if (typeof params !== 'object' || params === null || !params.url) {
-            console.error('Invalid parameters. Expected an object with a "url" property.');
+            logger.error('Invalid parameters. Expected an object with a "url" property.');
             throw new Error('Invalid parameters. Expected an object with a "url" property.');
         }
         // 提取参数
         let url = params.url.trim();
         let newWindow = params.newWindow;
-        console.log('URL to open:', url);
-        console.log('Initial newWindow value:', newWindow);
+        logger.debug('URL to open:', url);
+        logger.debug('Initial newWindow value:', newWindow);
         // 根据上下文调整 newWindow 的值
         if (context.ekoConfig.workingWindowId) {
-            console.log('Working window ID exists in context, setting newWindow to false.');
+            logger.debug('Working window ID exists in context, setting newWindow to false.');
             newWindow = false;
         }
         else if (!newWindow && !context.variables.get('windowId') && !context.variables.get('tabId')) {
             // First mandatory opening of a new window
-            console.log('No existing window or tab ID found, forcing newWindow to true.');
+            logger.debug('No existing window or tab ID found, forcing newWindow to true.');
             newWindow = true;
         }
-        console.log('Final newWindow value:', newWindow);
+        logger.debug('Final newWindow value:', newWindow);
         // 打开新标签页
         let tab;
         if (newWindow) {
-            console.log('Opening new tab in a new window.');
+            logger.debug('Opening new tab in a new window.');
             tab = await open_new_tab(context.ekoConfig.chromeProxy, url);
             (_c = (_b = (_a = context.callback) === null || _a === void 0 ? void 0 : _a.hooks) === null || _b === void 0 ? void 0 : _b.onTabCreated) === null || _c === void 0 ? void 0 : _c.call(_b, tab.id);
-            console.log('New tab created in a new window:', tab);
+            logger.debug('New tab created in a new window:', tab.id);
         }
         else {
             let windowId = context.ekoConfig.workingWindowId ? context.ekoConfig.workingWindowId : await getWindowId(context);
-            console.log('Using existing window with ID:', windowId);
+            logger.debug('Using existing window with ID:', windowId);
             try {
                 tab = await open_new_tab(context.ekoConfig.chromeProxy, url, windowId);
-                console.log("Calling hook...");
+                logger.debug("Calling hook...");
                 (_f = (_e = (_d = context.callback) === null || _d === void 0 ? void 0 : _d.hooks) === null || _e === void 0 ? void 0 : _e.onTabCreated) === null || _f === void 0 ? void 0 : _f.call(_e, tab.id);
-                console.log('New tab created in existing window:', tab);
+                logger.debug('New tab created in existing window:', tab.id);
             }
             catch (e) {
-                console.error("An error occurs when `open_url`");
-                console.error(e);
+                logger.error("An error occurs when `open_url`", e);
                 throw e;
             }
         }
         // 获取窗口和标签 ID
         let windowId = tab.windowId;
         let tabId = tab.id;
-        console.log('Tab ID:', tabId, 'Window ID:', windowId);
+        logger.debug('Tab ID:', tabId, 'Window ID:', windowId);
         // 更新上下文变量
         context.variables.set('windowId', windowId);
         context.variables.set('tabId', tabId);
-        console.log('Updated context variables:', context.variables);
+        logger.debug('Updated context variables:', context.variables);
         // 处理新窗口的 windowIds
         if (newWindow) {
             let windowIds = context.variables.get('windowIds');
             if (windowIds) {
-                console.log('Existing window IDs:', windowIds);
+                logger.debug('Existing window IDs:', windowIds);
                 windowIds.push(windowId);
-                console.log('Updated window IDs:', windowIds);
+                logger.debug('Updated window IDs:', windowIds);
             }
             else {
-                console.log('No existing window IDs found, creating new array.');
+                logger.debug('No existing window IDs found, creating new array.');
                 context.variables.set('windowIds', [windowId]);
             }
         }
@@ -1266,7 +1895,7 @@ class OpenUrl extends ToolReturnsScreenshot {
             windowId,
             title: tab.title,
         };
-        console.log('Returning result:', result);
+        logger.debug('Returning result:', result);
         return result;
     }
 }
@@ -1565,7 +2194,7 @@ async function deepSearch(context, taskId, searchs, detailsMaxNum, windowId) {
     let detailLinkGroups = await doDetailLinkGroups(context, taskId, searchs, detailsMaxNum, windowId);
     // crawler all details page content and comments
     let searchInfo = await doPageContent(context, taskId, detailLinkGroups, windowId);
-    console.log('searchInfo: ', searchInfo);
+    logger.debug('searchInfo: ', searchInfo);
     // close window
     closeWindow && context.ekoConfig.chromeProxy.windows.remove(windowId);
     return searchInfo;
@@ -1610,9 +2239,9 @@ async function doDetailLinkGroups(context, taskId, searchs, detailsMaxNum, windo
                         type: 'page:getDetailLinks',
                         keyword: searchs[i].keyword,
                     });
-                    console.log('detailLinks: ', detailLinks);
+                    logger.debug('detailLinks: ', detailLinks);
                     if (!detailLinks || !detailLinks.links) {
-                        console.error("detailLinks is empty");
+                        logger.error("detailLinks is empty");
                         throw new Error("An error occurs when calling `web_search`, please try again.");
                     }
                     let links = detailLinks.links.slice(0, detailsMaxNum);
@@ -1628,7 +2257,7 @@ async function doDetailLinkGroups(context, taskId, searchs, detailsMaxNum, windo
             }, eventId);
         }
         catch (e) {
-            console.error(e);
+            logger.error(e);
             countDownLatch.countDown();
         }
     }
@@ -1722,7 +2351,7 @@ async function doPageContent(context, taskId, detailLinkGroups, windowId) {
                 await Promise.race([monitorTabPromise, timeoutPromise]);
             }
             catch (e) {
-                console.error(`${link.title} failed:`, e);
+                logger.error(`${link.title} failed:`, e);
                 searchInfo.running--;
                 searchInfo.failed++;
                 searchInfo.failedLinks.push(link);
@@ -1841,7 +2470,7 @@ class CancelWorkflow {
             throw new Error('Invalid parameters. Expected an object with a "reason" property.');
         }
         const reason = params.reason;
-        console.log("The workflow has been cancelled because: " + reason);
+        logger.info("The workflow has been cancelled because: " + reason);
         await ((_a = context.workflow) === null || _a === void 0 ? void 0 : _a.cancel());
         return;
     }
@@ -1868,7 +2497,7 @@ class HumanInputText {
             throw new Error('Invalid parameters. Expected an object with a "question" property.');
         }
         const question = params.question;
-        console.log("question: " + question);
+        logger.debug("question: " + question);
         let onHumanInputText = (_a = context.callback) === null || _a === void 0 ? void 0 : _a.hooks.onHumanInputText;
         if (onHumanInputText) {
             let answer;
@@ -1876,14 +2505,14 @@ class HumanInputText {
                 answer = await onHumanInputText(question);
             }
             catch (e) {
-                console.error(e);
+                logger.warn(e);
                 return { status: "Error: Cannot get user's answer.", answer: "" };
             }
-            console.log("answer: " + answer);
+            logger.debug("answer: " + answer);
             return { status: "OK", answer: answer };
         }
         else {
-            console.error("`onHumanInputText` not implemented");
+            logger.error("`onHumanInputText` not implemented");
             return { status: "Error: Cannot get user's answer.", answer: "" };
         }
     }
@@ -1922,8 +2551,8 @@ class HumanInputSingleChoice {
         }
         const question = params.question;
         const choices = params.choices.map((e) => e.choice);
-        console.log("question: " + question);
-        console.log("choices: " + choices);
+        logger.debug("question: " + question);
+        logger.debug("choices: " + choices);
         let onHumanInputSingleChoice = (_a = context.callback) === null || _a === void 0 ? void 0 : _a.hooks.onHumanInputSingleChoice;
         if (onHumanInputSingleChoice) {
             let answer;
@@ -1931,14 +2560,14 @@ class HumanInputSingleChoice {
                 answer = await onHumanInputSingleChoice(question, choices);
             }
             catch (e) {
-                console.error(e);
+                logger.warn(e);
                 return { status: "Error: Cannot get user's answer.", answer: "" };
             }
-            console.log("answer: " + answer);
+            logger.debug("answer: " + answer);
             return { status: "OK", answer: answer };
         }
         else {
-            console.error("`onHumanInputSingleChoice` not implemented");
+            logger.error("`onHumanInputSingleChoice` not implemented");
             return { status: "Error: Cannot get user's answer.", answer: "" };
         }
     }
@@ -1977,8 +2606,8 @@ class HumanInputMultipleChoice {
         }
         const question = params.question;
         const choices = params.choices.map((e) => e.choice);
-        console.log("question: " + question);
-        console.log("choices: " + choices);
+        logger.debug("question: " + question);
+        logger.debug("choices: " + choices);
         let onHumanInputMultipleChoice = (_a = context.callback) === null || _a === void 0 ? void 0 : _a.hooks.onHumanInputMultipleChoice;
         if (onHumanInputMultipleChoice) {
             let answer;
@@ -1986,14 +2615,14 @@ class HumanInputMultipleChoice {
                 answer = await onHumanInputMultipleChoice(question, choices);
             }
             catch (e) {
-                console.error(e);
-                return { status: "`onHumanInputMultipleChoice` not implemented", answer: [] };
+                logger.warn(e);
+                return { status: "Error: Cannot get user's answer.", answer: [] };
             }
-            console.log("answer: " + answer);
+            logger.debug("answer: " + answer);
             return { status: "OK", answer: answer };
         }
         else {
-            console.error("Cannot get user's answer.");
+            logger.error("`onHumanInputMultipleChoice` not implemented");
             return { status: "Error: Cannot get user's answer.", answer: [] };
         }
     }
@@ -2027,7 +2656,7 @@ When calling this tool to transfer control to the user, please explain in detail
             throw new Error('Invalid parameters. Expected an object with a "reason" property.');
         }
         const reason = params.reason;
-        console.log("reason: " + reason);
+        logger.debug("reason: " + reason);
         let onHumanOperate = (_a = context.callback) === null || _a === void 0 ? void 0 : _a.hooks.onHumanOperate;
         if (onHumanOperate) {
             let userOperation;
@@ -2035,10 +2664,10 @@ When calling this tool to transfer control to the user, please explain in detail
                 userOperation = await onHumanOperate(reason);
             }
             catch (e) {
-                console.error(e);
-                return { status: "`onHumanOperate` not implemented", userOperation: "" };
+                logger.warn(e);
+                return { status: "Error: Cannot get user's operation.", userOperation: "" };
             }
-            console.log("userOperation: " + userOperation);
+            logger.debug("userOperation: " + userOperation);
             if (userOperation == "") {
                 return { status: "OK", userOperation: "Done. Please take a screenshot to ensure the result." };
             }
@@ -2047,7 +2676,7 @@ When calling this tool to transfer control to the user, please explain in detail
             }
         }
         else {
-            console.error("Cannot get user's operation.");
+            logger.error("`onHumanOperate` not implemented");
             return { status: "Error: Cannot get user's operation.", userOperation: "" };
         }
     }
@@ -2144,7 +2773,7 @@ function loadTools() {
                 toolsMap.set(instance.name || key, instance);
             }
             catch (e) {
-                console.error(`Failed to instantiate ${key}:`, e);
+                logger.error(`Failed to instantiate ${key}:`, e);
             }
         }
     }