feat: add logger using winston

Author: pyadav

package-lock.json

@@ -68,7 +68,8 @@
     "prettier": "^3.6.2",
     "tsx": "^4.20.5",
     "typescript": "^5.9.2",
-    "vitest": "^3.2.4"
+    "vitest": "^3.2.4",
+    "winston": "^3.17.0"
   },
   "publishConfig": {
     "access": "public"

package.json

@@ -10,6 +10,7 @@ import { parseKeyValue } from "../mcp/utils.js";
 import { addMCPServer, removeMCPServer } from "../mcp/config.js";
 import { getMCPClientManager } from "../mcp/manager.js";
 import type { MCPServerConfig, TransportType } from "../mcp/types.js";
+import { createLogger } from "../logger/index.js";
 
 export function createMCPCommand(): Command {
   const mcp = new Command("mcp");
@@ -102,8 +103,14 @@ export function createMCPCommand(): Command {
   mcp
     .command("remove <name>")
     .description("Remove an MCP server")
-    .action(async (name: string) => {
+    .action(async function (this: Command, name: string) {
+      const program = this.parent?.parent;
+      const verbose = program?.opts<{ verbose?: boolean }>().verbose ?? false;
+      const logger = createLogger({ silent: !verbose, level: "info" });
+
       const mcpClientManager = getMCPClientManager();
+      mcpClientManager.setLogger(logger);
+
       await mcpClientManager.removeClient(name);
 
       await removeMCPServer(name);

src/commands/mcp.ts

@@ -8,7 +8,7 @@ import Table from "../ink-table.js";
 
 export function MCPList({ verbose = false }: { verbose?: boolean }) {
   const { exit } = useApp();
-  const { loading, rows, summary, error } = useMCPServers(exit);
+  const { loading, rows, summary, error } = useMCPServers(exit, verbose);
 
   // After data is ready and rendered, politely exit to finalize output
   useEffect(() => {

src/components/mcp/mcp-list.tsx

@@ -2,8 +2,9 @@ import { useEffect, useState } from "react";
 import type { Row, Summary } from "./types.js";
 import { loadMCPConfig } from "../../mcp/config.js";
 import { getMCPClientManager } from "../../mcp/manager.js";
+import { createLogger } from "../../logger/index.js";
 
-export function useMCPServers(exit: () => void) {
+export function useMCPServers(exit: () => void, verbose: boolean) {
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState<string | null>(null);
   const [rows, setRows] = useState<Row[]>([]);
@@ -17,8 +18,12 @@ export function useMCPServers(exit: () => void) {
   useEffect(() => {
     (async () => {
       try {
+        const logger = createLogger({ silent: !verbose, level: "info" });
         const config = loadMCPConfig();
+
         const manager = getMCPClientManager();
+        manager.setLogger(logger);
+
         const servers = Object.entries(config.servers || {});
 
         if (servers.length === 0) return;

src/components/mcp/useMCPServers.ts

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

src/logger/index.ts

@@ -0,0 +1,198 @@
+import fs from "node:fs";
+import winston from "winston";
+import { redactSensitiveData } from "../utils/masking.js";
+import path from "node:path";
+import chalk from "chalk";
+
+const logLevels = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  http: 3,
+  verbose: 4,
+  debug: 5,
+  silly: 6,
+};
+
+export interface LoggerOptions {
+  level?: string;
+  silent?: boolean;
+  file?: string;
+}
+
+type ChalkColor =
+  | "red"
+  | "green"
+  | "yellow"
+  | "blue"
+  | "magenta"
+  | "cyan"
+  | "white"
+  | "gray"
+  | "redBright"
+  | "greenBright"
+  | "yellowBright"
+  | "blueBright"
+  | "magentaBright"
+  | "cyanBright"
+  | "whiteBright";
+
+const levelColorMap: Record<string, (text: string) => string> = {
+  error: chalk.red,
+  warn: chalk.yellow,
+  info: chalk.blue,
+  http: chalk.cyan,
+  verbose: chalk.magenta,
+  debug: chalk.gray,
+  silly: chalk.gray.dim,
+};
+
+const maskFormat = winston.format((info) => {
+  if (typeof info.message === "string") {
+    info.message = redactSensitiveData(info.message);
+  }
+  return info;
+});
+
+const fileFormat = winston.format.printf((info) => {
+  const { level, message, timestamp, color, ...meta } = info as any;
+  const metaKeys = Object.keys(meta || {});
+  const metaStr = metaKeys.length ? ` ${JSON.stringify(meta)}` : "";
+  return `${timestamp} [${String(level).toUpperCase()}]: ${message}${metaStr}`;
+});
+
+const consoleFormat = winston.format.printf((info) => {
+  const { level, message, timestamp, color, ...meta } = info as any;
+  const colorize = levelColorMap[level] || chalk.white;
+  let formattedMessage = message;
+
+  // Apply custom color if specified
+  if (color && chalk[color as ChalkColor]) {
+    formattedMessage = (chalk[color as ChalkColor] as any)(message);
+  }
+
+  const metaKeys = Object.keys(meta || {});
+  const metaStr = metaKeys.length ? ` ${JSON.stringify(meta)}` : "";
+
+  return `${chalk.dim(timestamp)} ${colorize(String(level).toUpperCase())}: ${formattedMessage}${metaStr}`;
+});
+
+export class Logger {
+  private logger: winston.Logger;
+  private isSilent: boolean = false;
+
+  constructor(options: LoggerOptions = {}) {
+    const level = options.level || "info";
+    this.isSilent = options.silent || false;
+
+    const errorFormat = winston.format((info) => {
+      if (info instanceof Error) {
+        return Object.assign({}, info, {
+          message: info.message,
+          stack: info.stack,
+        });
+      }
+      if (info.error instanceof Error) {
+        info.message += `\n${info.error.stack}`;
+      }
+      return info;
+    });
+
+    this.logger = winston.createLogger({
+      levels: logLevels,
+      level: level,
+      format: winston.format.combine(
+        errorFormat(),
+        winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
+        maskFormat(),
+      ),
+      transports: this.createTransports(options.file),
+      silent: this.isSilent,
+    });
+
+    // Add colors to winston
+    winston.addColors({
+      error: "red",
+      warn: "yellow",
+      info: "blue",
+      http: "cyan",
+      verbose: "magenta",
+      debug: "gray",
+      silly: "gray",
+    });
+  }
+
+  error(message: string, meta?: any, color?: ChalkColor): void {
+    this.logger.error(message, { ...meta, color });
+  }
+
+  warn(message: string, meta?: any, color?: ChalkColor): void {
+    this.logger.warn(message, { ...meta, color });
+  }
+
+  info(message: string, meta?: any, color?: ChalkColor): void {
+    this.logger.info(message, { ...meta, color });
+  }
+
+  http(message: string, meta?: any, color?: ChalkColor): void {
+    this.logger.http(message, { ...meta, color });
+  }
+
+  verbose(message: string, meta?: any, color?: ChalkColor): void {
+    this.logger.verbose(message, { ...meta, color });
+  }
+
+  debug(message: string, meta?: any, color?: ChalkColor): void {
+    this.logger.debug(message, { ...meta, color });
+  }
+
+  silly(message: string, meta?: any, color?: ChalkColor): void {
+    this.logger.silly(message, { ...meta, color });
+  }
+
+  setSilent(silent: boolean): void {
+    this.isSilent = silent;
+    this.logger.silent = silent;
+  }
+
+  getWinstonLogger(): winston.Logger {
+    return this.logger;
+  }
+
+  private createTransports(filePath?: string): winston.transport[] {
+    const transports: winston.transport[] = [];
+
+    if (filePath) {
+      // File transport
+      fs.mkdirSync(path.dirname(filePath), { recursive: true });
+      transports.push(
+        new winston.transports.File({
+          filename: filePath,
+          format: winston.format.combine(
+            winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
+            maskFormat(),
+            fileFormat,
+          ),
+        }),
+      );
+    } else {
+      // Console transport
+      transports.push(
+        new winston.transports.Console({
+          format: winston.format.combine(
+            winston.format.timestamp({ format: "HH:mm:ss" }),
+            maskFormat(),
+            consoleFormat,
+          ),
+          stderrLevels: Object.keys(logLevels), // Redirect all log levels to stderr
+        }),
+      );
+    }
+
+    return transports;
+  }
+}
+
+export const createLogger = (options: LoggerOptions = {}): Logger => {
+  return new Logger(options);
+};