@dexto/core 1.1.4 → 1.1.6

package/dist/logger/index.cjs

@@ -0,0 +1,22 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var logger_exports = {};
+module.exports = __toCommonJS(logger_exports);
+__reExport(logger_exports, require("./logger.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./logger.js")
+});

package/dist/logger/index.d.cts

@@ -0,0 +1 @@
+export { Logger, LoggerOptions, logger } from './logger.cjs';

package/dist/logger/index.d.ts

@@ -0,0 +1 @@
+export { Logger, LoggerOptions, logger } from './logger.js';

package/dist/logger/index.js

@@ -0,0 +1 @@
+export * from "./logger.js";

package/dist/logger/logger.cjs

@@ -0,0 +1,362 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var logger_exports = {};
+__export(logger_exports, {
+  Logger: () => Logger,
+  logger: () => logger
+});
+module.exports = __toCommonJS(logger_exports);
+var winston = __toESM(require("winston"), 1);
+var import_chalk = __toESM(require("chalk"), 1);
+var import_boxen = __toESM(require("boxen"), 1);
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var import_path = require("../utils/path.js");
+const logLevels = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  http: 3,
+  verbose: 4,
+  debug: 5,
+  silly: 6
+};
+const consoleFormat = winston.format.printf(({ level, message, timestamp, color }) => {
+  const levelColorMap = {
+    error: import_chalk.default.red,
+    warn: import_chalk.default.yellow,
+    info: import_chalk.default.blue,
+    http: import_chalk.default.cyan,
+    verbose: import_chalk.default.magenta,
+    debug: import_chalk.default.gray,
+    silly: import_chalk.default.gray.dim
+  };
+  const colorize = levelColorMap[level] || import_chalk.default.white;
+  const formattedMessage = color && typeof color === "string" && import_chalk.default[color] ? import_chalk.default[color](message) : message;
+  return `${import_chalk.default.dim(timestamp)} ${colorize(level.toUpperCase())}: ${formattedMessage}`;
+});
+const SHOULD_REDACT = process.env.REDACT_SECRETS !== "false";
+const SENSITIVE_KEYS = ["apiKey", "password", "secret", "token"];
+const MASK_REGEX = new RegExp(
+  `(${SENSITIVE_KEYS.join("|")})(["']?\\s*[:=]\\s*)(["'])?.*?\\3`,
+  "gi"
+);
+const maskFormat = winston.format((info) => {
+  if (SHOULD_REDACT && typeof info.message === "string") {
+    info.message = info.message.replace(MASK_REGEX, "$1$2$3[REDACTED]$3");
+  }
+  return info;
+});
+const getDefaultLogLevel = () => {
+  const envLevel = process.env.DEXTO_LOG_LEVEL;
+  if (envLevel && Object.keys(logLevels).includes(envLevel.toLowerCase())) {
+    return envLevel.toLowerCase();
+  }
+  return "info";
+};
+class Logger {
+  logger;
+  isSilent = false;
+  logFilePath = null;
+  logToConsole = false;
+  constructor(options = {}) {
+    this.isSilent = options.silent || false;
+    this.initializeTransports(options);
+    this.logger = winston.createLogger({
+      levels: logLevels,
+      level: options.level || getDefaultLogLevel(),
+      silent: options.silent || false,
+      format: winston.format.combine(
+        winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
+        maskFormat(),
+        winston.format.errors({ stack: true }),
+        winston.format.splat(),
+        winston.format.json()
+      ),
+      transports: this.createTransports(options)
+    });
+  }
+  initializeTransports(options) {
+    const logToConsole = options.logToConsole ?? process.env.DEXTO_LOG_TO_CONSOLE === "true";
+    this.logToConsole = logToConsole;
+    if (options.customLogPath) {
+      this.logFilePath = options.customLogPath;
+    } else {
+      this.logFilePath = (0, import_path.getDextoPath)("logs", "dexto.log");
+    }
+  }
+  createTransports(_options) {
+    const transports = [];
+    if (this.logToConsole) {
+      transports.push(
+        new winston.transports.Console({
+          format: winston.format.combine(
+            winston.format.timestamp({ format: "HH:mm:ss" }),
+            maskFormat(),
+            consoleFormat
+          )
+        })
+      );
+    }
+    try {
+      if (this.logFilePath) {
+        const logDir = path.dirname(this.logFilePath);
+        fs.mkdirSync(logDir, { recursive: true });
+        transports.push(
+          new winston.transports.File({
+            filename: this.logFilePath,
+            format: winston.format.combine(
+              winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
+              maskFormat(),
+              winston.format.errors({ stack: true }),
+              winston.format.json()
+            ),
+            // Add daily rotation
+            maxsize: 10 * 1024 * 1024,
+            // 10MB
+            maxFiles: 7,
+            // Keep 7 files
+            tailable: true
+          })
+        );
+      }
+    } catch (error) {
+      console.error(`Failed to initialize file logging: ${error}. Falling back to console.`);
+      if (!this.logToConsole) {
+        this.logToConsole = true;
+        transports.push(
+          new winston.transports.Console({
+            format: winston.format.combine(
+              winston.format.timestamp({ format: "HH:mm:ss" }),
+              maskFormat(),
+              consoleFormat
+            )
+          })
+        );
+      }
+    }
+    return transports;
+  }
+  // General logging methods with optional color parameter
+  error(message, meta, color) {
+    this.logger.error(message, { ...meta, color });
+  }
+  warn(message, meta, color) {
+    this.logger.warn(message, { ...meta, color });
+  }
+  info(message, meta, color) {
+    this.logger.info(message, { ...meta, color });
+  }
+  http(message, meta, color) {
+    this.logger.http(message, { ...meta, color });
+  }
+  verbose(message, meta, color) {
+    this.logger.verbose(message, { ...meta, color });
+  }
+  debug(message, meta, color) {
+    const formattedMessage = typeof message === "string" ? message : JSON.stringify(message, null, 2);
+    this.logger.debug(formattedMessage, { ...meta, color });
+  }
+  silly(message, meta, color) {
+    this.logger.silly(message, { ...meta, color });
+  }
+  // Display AI response in a box
+  displayAIResponse(response) {
+    if (this.isSilent) return;
+    if (response.content) {
+      console.log(
+        (0, import_boxen.default)(import_chalk.default.white(response.content), {
+          padding: 1,
+          borderColor: "yellow",
+          title: "\u{1F916} AI Response",
+          titleAlignment: "center"
+        })
+      );
+    } else {
+      console.log(import_chalk.default.yellow("AI is thinking..."));
+    }
+  }
+  // Tool-related logging
+  toolCall(toolName, args) {
+    if (this.isSilent) return;
+    console.log(
+      (0, import_boxen.default)(
+        `${import_chalk.default.cyan("Tool Call")}: ${import_chalk.default.yellow(toolName)}
+${import_chalk.default.dim("Arguments")}:
+${import_chalk.default.white(JSON.stringify(args, null, 2))}`,
+        { padding: 1, borderColor: "blue", title: "\u{1F527} Tool Call", titleAlignment: "center" }
+      )
+    );
+  }
+  toolResult(result) {
+    if (this.isSilent) return;
+    let displayText = "";
+    let isError = false;
+    let borderColor = "green";
+    let title = "\u2705 Tool Result";
+    if (result?.error || result?.isError) {
+      isError = true;
+      borderColor = "yellow";
+      title = "\u26A0\uFE0F Tool Result (Error)";
+    }
+    if (result?.content && Array.isArray(result.content)) {
+      result.content.forEach((item) => {
+        if (item.type === "text") {
+          displayText += item.text;
+        } else if (item.type === "image" && item.url) {
+          displayText += `[Image URL: ${item.url}]`;
+        } else if (item.type === "image") {
+          displayText += `[Image Data: ${item.mimeType || "unknown type"}]`;
+        } else if (item.type === "markdown") {
+          displayText += item.markdown;
+        } else {
+          displayText += `[Unsupported content type: ${item.type}]`;
+        }
+        displayText += "\n";
+      });
+    } else if (result?.message) {
+      displayText = result.message;
+      isError = true;
+      borderColor = "red";
+      title = "\u274C Tool Error";
+    } else if (typeof result === "string") {
+      if (result.length > 1e3) {
+        displayText = `${result.slice(0, 500)}... [${result.length - 500} chars omitted]`;
+      } else {
+        displayText = result;
+      }
+    } else {
+      try {
+        const resultStr = JSON.stringify(result, null, 2);
+        if (resultStr.length > 2e3) {
+          displayText = `${resultStr.slice(0, 1e3)}... [${resultStr.length - 1e3} chars omitted]`;
+        } else {
+          displayText = resultStr;
+        }
+      } catch {
+        displayText = `[Unparseable result: ${typeof result}]`;
+      }
+    }
+    if (!displayText || displayText.trim() === "") {
+      displayText = "[Empty result]";
+    }
+    const textColor = isError ? import_chalk.default.yellow : import_chalk.default.green;
+    console.log(
+      (0, import_boxen.default)(textColor(displayText), {
+        padding: 1,
+        borderColor,
+        title,
+        titleAlignment: "center"
+      })
+    );
+  }
+  // Configuration
+  setLevel(level) {
+    if (Object.keys(logLevels).includes(level.toLowerCase())) {
+      this.logger.level = level.toLowerCase();
+      if (!this.isSilent) {
+        console.log(`Log level set to: ${level}`);
+      }
+    } else {
+      this.error(`Invalid log level: ${level}. Using current level: ${this.logger.level}`);
+    }
+  }
+  // Get the current log file path
+  getLogFilePath() {
+    return this.logFilePath;
+  }
+  // Get current log level
+  getLevel() {
+    return this.logger.level;
+  }
+  // CLI startup information display methods
+  displayStartupInfo(info) {
+    if (this.isSilent) return;
+    console.log("");
+    if (info.model && info.provider) {
+      console.log(
+        `\u{1F916} ${import_chalk.default.bold("Current Model:")} ${import_chalk.default.cyan(info.model)} ${import_chalk.default.dim(`(${info.provider})`)}`
+      );
+    }
+    if (info.connectedServers) {
+      if (info.connectedServers.count > 0) {
+        const serverNames = info.connectedServers.names.join(", ");
+        console.log(
+          `\u{1F517} ${import_chalk.default.bold("Connected Servers:")} ${import_chalk.default.green(info.connectedServers.count)} ${import_chalk.default.dim(`(${serverNames})`)}`
+        );
+      } else {
+        console.log(
+          `\u{1F517} ${import_chalk.default.bold("Connected Servers:")} ${import_chalk.default.yellow("0")} ${import_chalk.default.dim("(no MCP servers connected)")}`
+        );
+      }
+    }
+    if (info.failedConnections && Object.keys(info.failedConnections).length > 0) {
+      const failedNames = Object.keys(info.failedConnections);
+      console.log(
+        `\u274C ${import_chalk.default.bold("Failed Connections:")} ${import_chalk.default.red(failedNames.length)} ${import_chalk.default.dim(`(${failedNames.join(", ")})`)}`
+      );
+      for (const [serverName, error] of Object.entries(info.failedConnections)) {
+        console.log(`   ${import_chalk.default.red("\u2022")} ${import_chalk.default.dim(serverName)}: ${import_chalk.default.red(error)}`);
+      }
+    }
+    if (info.toolStats) {
+      console.log(
+        `\u{1F6E0}\uFE0F  ${import_chalk.default.bold("Available Tools:")} ${import_chalk.default.green(info.toolStats.total)} total ${import_chalk.default.dim(`(${info.toolStats.mcp} MCP, ${info.toolStats.internal} internal)`)}`
+      );
+    }
+    if (info.sessionId) {
+      console.log(`\u{1F4AC} ${import_chalk.default.bold("Session:")} ${import_chalk.default.blue(info.sessionId)}`);
+    }
+    if (info.logLevel && info.logFile) {
+      console.log(
+        `\u{1F4CB} ${import_chalk.default.bold("Log Level:")} ${import_chalk.default.cyan(info.logLevel)} ${import_chalk.default.dim(`(file: ${info.logFile})`)}`
+      );
+    }
+  }
+  displayError(message, error) {
+    if (this.isSilent) return;
+    const showStack = this.getLevel() === "debug";
+    const errorContent = error?.stack && showStack ? `${import_chalk.default.red("Error")}: ${import_chalk.default.red(message)}
+${import_chalk.default.dim(error.stack)}` : `${import_chalk.default.red("Error")}: ${import_chalk.default.red(message)}`;
+    console.log(
+      (0, import_boxen.default)(errorContent, {
+        padding: 1,
+        borderColor: "red",
+        title: "\u274C Error",
+        titleAlignment: "center"
+      })
+    );
+  }
+}
+const logger = new Logger();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Logger,
+  logger
+});

package/dist/logger/logger.d.cts

@@ -0,0 +1,52 @@
+type ChalkColor = 'black' | 'red' | 'green' | 'yellow' | 'blue' | 'magenta' | 'cyan' | 'white' | 'gray' | 'grey' | 'blackBright' | 'redBright' | 'greenBright' | 'yellowBright' | 'blueBright' | 'magentaBright' | 'cyanBright' | 'whiteBright';
+interface LoggerOptions {
+    level?: string;
+    silent?: boolean;
+    logToConsole?: boolean;
+    customLogPath?: string;
+}
+declare class Logger {
+    private logger;
+    private isSilent;
+    private logFilePath;
+    private logToConsole;
+    constructor(options?: LoggerOptions);
+    private initializeTransports;
+    private createTransports;
+    error(message: string, meta?: any, color?: ChalkColor): void;
+    warn(message: string, meta?: any, color?: ChalkColor): void;
+    info(message: string, meta?: any, color?: ChalkColor): void;
+    http(message: string, meta?: any, color?: ChalkColor): void;
+    verbose(message: string, meta?: any, color?: ChalkColor): void;
+    debug(message: string | object, meta?: any, color?: ChalkColor): void;
+    silly(message: string, meta?: any, color?: ChalkColor): void;
+    displayAIResponse(response: any): void;
+    toolCall(toolName: string, args: any): void;
+    toolResult(result: any): void;
+    setLevel(level: string): void;
+    getLogFilePath(): string | null;
+    getLevel(): string;
+    displayStartupInfo(info: {
+        model?: string;
+        provider?: string;
+        connectedServers?: {
+            count: number;
+            names: string[];
+        };
+        failedConnections?: {
+            [key: string]: string;
+        };
+        toolStats?: {
+            total: number;
+            mcp: number;
+            internal: number;
+        };
+        sessionId?: string;
+        logLevel?: string;
+        logFile?: string;
+    }): void;
+    displayError(message: string, error?: Error): void;
+}
+declare const logger: Logger;
+
+export { Logger, type LoggerOptions, logger };

package/dist/logger/logger.d.ts

@@ -0,0 +1,52 @@
+type ChalkColor = 'black' | 'red' | 'green' | 'yellow' | 'blue' | 'magenta' | 'cyan' | 'white' | 'gray' | 'grey' | 'blackBright' | 'redBright' | 'greenBright' | 'yellowBright' | 'blueBright' | 'magentaBright' | 'cyanBright' | 'whiteBright';
+interface LoggerOptions {
+    level?: string;
+    silent?: boolean;
+    logToConsole?: boolean;
+    customLogPath?: string;
+}
+declare class Logger {
+    private logger;
+    private isSilent;
+    private logFilePath;
+    private logToConsole;
+    constructor(options?: LoggerOptions);
+    private initializeTransports;
+    private createTransports;
+    error(message: string, meta?: any, color?: ChalkColor): void;
+    warn(message: string, meta?: any, color?: ChalkColor): void;
+    info(message: string, meta?: any, color?: ChalkColor): void;
+    http(message: string, meta?: any, color?: ChalkColor): void;
+    verbose(message: string, meta?: any, color?: ChalkColor): void;
+    debug(message: string | object, meta?: any, color?: ChalkColor): void;
+    silly(message: string, meta?: any, color?: ChalkColor): void;
+    displayAIResponse(response: any): void;
+    toolCall(toolName: string, args: any): void;
+    toolResult(result: any): void;
+    setLevel(level: string): void;
+    getLogFilePath(): string | null;
+    getLevel(): string;
+    displayStartupInfo(info: {
+        model?: string;
+        provider?: string;
+        connectedServers?: {
+            count: number;
+            names: string[];
+        };
+        failedConnections?: {
+            [key: string]: string;
+        };
+        toolStats?: {
+            total: number;
+            mcp: number;
+            internal: number;
+        };
+        sessionId?: string;
+        logLevel?: string;
+        logFile?: string;
+    }): void;
+    displayError(message: string, error?: Error): void;
+}
+declare const logger: Logger;
+
+export { Logger, type LoggerOptions, logger };