@mcp-abap-adt/logger 0.1.1 → 0.1.3

package/CHANGELOG.md

@@ -7,6 +7,40 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.3] - 2025-12-13
+
+### Changed
+- Dependency bump: `@mcp-abap-adt/interfaces` to `^0.1.16` (timeout docs) to align with latest interfaces release
+
+## [0.1.2] - 2025-12-19
+
+### Added
+- **PinoLogger Implementation**: Added `PinoLogger` class for structured logging using Pino
+  - Async logger for server use with pino-pretty formatting
+  - Falls back to `DefaultLogger` if pino is not installed
+  - Includes icons in log messages (ℹ️ info, 🐛 debug, ⚠️ warn, 💥 error)
+  - Optional peer dependencies: `pino@^10.1.0` and `pino-pretty@^13.1.3`
+  - **Usage**: `import { PinoLogger } from '@mcp-abap-adt/logger'; const logger = new PinoLogger();`
+- **LogLevel from Interfaces**: Now uses `LogLevel` enum from `@mcp-abap-adt/interfaces` package
+  - Standardized log level constants across all packages
+  - **Migration**: Import `LogLevel` from `@mcp-abap-adt/interfaces` instead of local enum
+
+### Changed
+- **Package Structure Refactoring**: Reorganized code into separate files
+  - `default-logger.ts`: `DefaultLogger` implementation with icons and prefixes
+  - `pino-logger.ts`: `PinoLogger` implementation
+  - `types.ts`: Type definitions and utility functions (`getLogLevel`, `Logger` type)
+  - `index.ts`: Main entry point with all exports
+- **DefaultLogger Enhancement**: Added icons to log messages
+  - Format: `[LEVEL] icon message` (e.g., `[INFO] ℹ️ Test message`)
+  - Icons: ℹ️ (info), 🐛 (debug), ⚠️ (warn), 💥 (error)
+- **Dependency Update**: Updated `@mcp-abap-adt/interfaces` to `^0.1.14` (requires LogLevel export)
+
+### Removed
+- **Local LogLevel Enum**: Removed duplicate `LogLevel` enum from logger package
+  - Now imported from `@mcp-abap-adt/interfaces`
+  - **Migration**: Update imports: `import { LogLevel } from '@mcp-abap-adt/interfaces';`
+
 ## [0.1.1] - 2025-12-05
 
 ### Changed
@@ -34,4 +68,3 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - TestLogger implementation
 - Log level support (ERROR, WARN, INFO, DEBUG)
 - Environment variable configuration (AUTH_LOG_LEVEL)
-

package/README.md

@@ -8,32 +8,65 @@ Logger interface and implementations for MCP ABAP ADT packages.
 npm install @mcp-abap-adt/logger
 ```
 
+For structured logging with Pino (optional):
+
+```bash
+npm install pino pino-pretty
+```
+
 ## Usage
 
-### Basic Usage
+### DefaultLogger (Synchronous)
+
+`DefaultLogger` provides synchronous logging with icons and level prefixes, ideal for tests and CLI tools:
 
 ```typescript
-import { Logger, defaultLogger, LogLevel } from '@mcp-abap-adt/logger';
+import { defaultLogger, DefaultLogger, LogLevel } from '@mcp-abap-adt/logger';
 
-// Use default logger
+// Use default logger singleton
 defaultLogger.info('Hello, world!');
 defaultLogger.debug('Debug message');
 defaultLogger.error('Error message');
 defaultLogger.warn('Warning message');
 
-// Specialized logging methods
-defaultLogger.browserAuth('Starting browser authentication...');
-defaultLogger.refresh('Refreshing token...');
-defaultLogger.success('Operation completed successfully');
-defaultLogger.browserUrl('https://example.com/auth');
-defaultLogger.browserOpening();
-defaultLogger.testSkip('Test skipped');
+// Create custom logger instance with specific log level
+const logger = new DefaultLogger(LogLevel.DEBUG);
+logger.info('Test info');  // Output: [INFO] ℹ️ Test info
+logger.debug('Test debug'); // Output: [DEBUG] 🐛 Test debug
 ```
 
+### PinoLogger (Asynchronous)
+
+`PinoLogger` provides structured logging using Pino, ideal for server applications:
+
+```typescript
+import { PinoLogger, LogLevel } from '@mcp-abap-adt/logger';
+
+// Create Pino logger (falls back to DefaultLogger if pino is not installed)
+const logger = new PinoLogger(LogLevel.DEBUG);
+logger.info('Server started');  // Output: ℹ️ Server started (with pino-pretty formatting)
+logger.debug('Debug info');
+logger.error('Error occurred');
+logger.warn('Warning message');
+```
+
+**Note**: `PinoLogger` uses async transport, so logs may appear after test completion in Jest. This is expected behavior for server use.
+
 ### Log Levels
 
-Logger supports four log levels controlled by `AUTH_LOG_LEVEL` environment variable:
+Log levels are defined in `@mcp-abap-adt/interfaces` and controlled by `AUTH_LOG_LEVEL` environment variable:
+
+```typescript
+import { LogLevel } from '@mcp-abap-adt/interfaces';
+
+// LogLevel enum values:
+// LogLevel.ERROR = 0
+// LogLevel.WARN = 1
+// LogLevel.INFO = 2
+// LogLevel.DEBUG = 3
+```
 
+Environment variable values:
 - `error` - only errors
 - `warn` - errors and warnings
 - `info` - errors, warnings, and info (default)
@@ -47,55 +80,46 @@ For backward compatibility, `DEBUG_AUTH_LOG=true` also sets level to debug.
 
 ### Logger Interface
 
+All logger implementations implement the `ILogger` interface from `@mcp-abap-adt/interfaces`:
+
 ```typescript
-import type { Logger } from '@mcp-abap-adt/logger';
+import type { ILogger } from '@mcp-abap-adt/interfaces';
 
-class MyCustomLogger implements Logger {
-  info(message: string): void {
-    // Custom implementation
-  }
-  debug(message: string): void {
-    // Custom implementation
-  }
-  error(message: string): void {
-    // Custom implementation
-  }
-  warn(message: string): void {
-    // Custom implementation
-  }
-  browserAuth(message: string): void {
-    // Custom implementation
-  }
-  refresh(message: string): void {
-    // Custom implementation
-  }
-  success(message: string): void {
+interface ILogger {
+  info(message: string, meta?: any): void;
+  debug(message: string, meta?: any): void;
+  error(message: string, meta?: any): void;
+  warn(message: string, meta?: any): void;
+}
+
+// Create custom logger
+class MyCustomLogger implements ILogger {
+  info(message: string, meta?: any): void {
     // Custom implementation
   }
-  browserUrl(url: string): void {
+  debug(message: string, meta?: any): void {
     // Custom implementation
   }
-  browserOpening(): void {
+  error(message: string, meta?: any): void {
     // Custom implementation
   }
-  testSkip(message: string): void {
+  warn(message: string, meta?: any): void {
     // Custom implementation
   }
 }
 ```
 
-### Convenience Functions
-
-For backward compatibility, convenience functions are also exported:
+### Output Format
 
-```typescript
-import { info, debug, error, warn, browserAuth, refresh, success, browserUrl, browserOpening, testSkip } from '@mcp-abap-adt/logger';
+**DefaultLogger** output format:
+- `[INFO] ℹ️ message`
+- `[DEBUG] 🐛 message`
+- `[ERROR] 💥 message`
+- `[WARN] ⚠️ message`
 
-info('Info message');
-debug('Debug message');
-error('Error message');
-warn('Warning message');
-```
+**PinoLogger** output format (with pino-pretty):
+- Structured JSON in production
+- Pretty formatted with colors and icons in development (NODE_ENV !== 'production')
 
 ## License
 

package/dist/default-logger.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Default logger implementation
+ * Controls output based on AUTH_LOG_LEVEL environment variable:
+ * - error: only errors
+ * - warn: errors and warnings
+ * - info: errors, warnings, and info (default)
+ * - debug: all messages
+ *
+ * Uses process.stdout/stderr for clean output without stack traces
+ */
+import type { ILogger } from '@mcp-abap-adt/interfaces';
+import { LogLevel } from '@mcp-abap-adt/interfaces';
+export declare class DefaultLogger implements ILogger {
+    private readonly logLevel;
+    constructor(logLevel?: LogLevel);
+    info(message: string, meta?: any): void;
+    debug(message: string, meta?: any): void;
+    error(message: string, meta?: any): void;
+    warn(message: string, meta?: any): void;
+}

package/dist/default-logger.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * Default logger implementation
+ * Controls output based on AUTH_LOG_LEVEL environment variable:
+ * - error: only errors
+ * - warn: errors and warnings
+ * - info: errors, warnings, and info (default)
+ * - debug: all messages
+ *
+ * Uses process.stdout/stderr for clean output without stack traces
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultLogger = void 0;
+const interfaces_1 = require("@mcp-abap-adt/interfaces");
+const types_1 = require("./types");
+class DefaultLogger {
+    logLevel;
+    constructor(logLevel) {
+        this.logLevel = logLevel ?? (0, types_1.getLogLevel)();
+    }
+    info(message, meta) {
+        if (this.logLevel >= interfaces_1.LogLevel.INFO) {
+            const icon = 'ℹ️';
+            if (meta) {
+                process.stdout.write(`[INFO] ${icon} ${message}\n`);
+                process.stdout.write(`${JSON.stringify(meta)}\n`);
+            }
+            else {
+                process.stdout.write(`[INFO] ${icon} ${message}\n`);
+            }
+        }
+    }
+    debug(message, meta) {
+        if (this.logLevel >= interfaces_1.LogLevel.DEBUG) {
+            const icon = '🐛';
+            if (meta) {
+                process.stdout.write(`[DEBUG] ${icon} ${message}\n`);
+                process.stdout.write(`${JSON.stringify(meta)}\n`);
+            }
+            else {
+                process.stdout.write(`[DEBUG] ${icon} ${message}\n`);
+            }
+        }
+    }
+    error(message, meta) {
+        if (this.logLevel >= interfaces_1.LogLevel.ERROR) {
+            const icon = '💥';
+            if (meta) {
+                process.stderr.write(`[ERROR] ${icon} ${message}\n`);
+                process.stderr.write(`${JSON.stringify(meta)}\n`);
+            }
+            else {
+                process.stderr.write(`[ERROR] ${icon} ${message}\n`);
+            }
+        }
+    }
+    warn(message, meta) {
+        if (this.logLevel >= interfaces_1.LogLevel.WARN) {
+            const icon = '⚠️';
+            if (meta) {
+                process.stderr.write(`[WARN] ${icon} ${message}\n`);
+                process.stderr.write(`${JSON.stringify(meta)}\n`);
+            }
+            else {
+                process.stderr.write(`[WARN] ${icon} ${message}\n`);
+            }
+        }
+    }
+}
+exports.DefaultLogger = DefaultLogger;

package/dist/index.d.ts

@@ -2,7 +2,14 @@
  * @mcp-abap-adt/logger
  * Logger interface and implementations for MCP ABAP ADT packages
  */
-export { LogLevel, defaultLogger, testLogger } from './logger';
-export type { Logger } from './logger';
+import type { ILogger } from '@mcp-abap-adt/interfaces';
+import { LogLevel } from '@mcp-abap-adt/interfaces';
+import { DefaultLogger } from './default-logger';
+import { PinoLogger } from './pino-logger';
+export type { Logger } from './types';
+export { getLogLevel } from './types';
+export { LogLevel };
+export declare const defaultLogger: ILogger;
+export declare const pinoLogger: ILogger;
+export { DefaultLogger, PinoLogger };
 export type { ILogger } from '@mcp-abap-adt/interfaces';
-export { info, debug, error, warn, } from './logger';

package/dist/index.js

@@ -1,16 +1,20 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.warn = exports.error = exports.debug = exports.info = exports.testLogger = exports.defaultLogger = exports.LogLevel = void 0;
 /**
  * @mcp-abap-adt/logger
  * Logger interface and implementations for MCP ABAP ADT packages
  */
-var logger_1 = require("./logger");
-Object.defineProperty(exports, "LogLevel", { enumerable: true, get: function () { return logger_1.LogLevel; } });
-Object.defineProperty(exports, "defaultLogger", { enumerable: true, get: function () { return logger_1.defaultLogger; } });
-Object.defineProperty(exports, "testLogger", { enumerable: true, get: function () { return logger_1.testLogger; } });
-var logger_2 = require("./logger");
-Object.defineProperty(exports, "info", { enumerable: true, get: function () { return logger_2.info; } });
-Object.defineProperty(exports, "debug", { enumerable: true, get: function () { return logger_2.debug; } });
-Object.defineProperty(exports, "error", { enumerable: true, get: function () { return logger_2.error; } });
-Object.defineProperty(exports, "warn", { enumerable: true, get: function () { return logger_2.warn; } });
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PinoLogger = exports.DefaultLogger = exports.pinoLogger = exports.defaultLogger = exports.LogLevel = exports.getLogLevel = void 0;
+const interfaces_1 = require("@mcp-abap-adt/interfaces");
+Object.defineProperty(exports, "LogLevel", { enumerable: true, get: function () { return interfaces_1.LogLevel; } });
+const default_logger_1 = require("./default-logger");
+Object.defineProperty(exports, "DefaultLogger", { enumerable: true, get: function () { return default_logger_1.DefaultLogger; } });
+const pino_logger_1 = require("./pino-logger");
+Object.defineProperty(exports, "PinoLogger", { enumerable: true, get: function () { return pino_logger_1.PinoLogger; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "getLogLevel", { enumerable: true, get: function () { return types_1.getLogLevel; } });
+// Default logger instance (singleton)
+exports.defaultLogger = new default_logger_1.DefaultLogger();
+// Pino logger instance (falls back to DefaultLogger if pino is not installed)
+// Async logger for server use
+exports.pinoLogger = new pino_logger_1.PinoLogger();

package/dist/pino-logger.d.ts

@@ -0,0 +1,27 @@
+/**
+ * PinoLogger - Structured logging using Pino (optional dependency)
+ *
+ * If pino is not installed, falls back to DefaultLogger behavior.
+ *
+ * Install pino: npm install pino pino-pretty
+ *
+ * Usage:
+ * ```typescript
+ * import { PinoLogger } from '@mcp-abap-adt/logger';
+ * const logger = new PinoLogger();
+ * logger.info('Test message');
+ * ```
+ */
+import type { ILogger } from '@mcp-abap-adt/interfaces';
+import { LogLevel } from '@mcp-abap-adt/interfaces';
+export declare class PinoLogger implements ILogger {
+    private pinoLogger;
+    private logLevel;
+    private fallbackLogger;
+    constructor(logLevel?: LogLevel);
+    private logLevelToPinoLevel;
+    info(message: string, meta?: any): void;
+    debug(message: string, meta?: any): void;
+    warn(message: string, meta?: any): void;
+    error(message: string, meta?: any): void;
+}

package/dist/pino-logger.js

@@ -0,0 +1,127 @@
+"use strict";
+/**
+ * PinoLogger - Structured logging using Pino (optional dependency)
+ *
+ * If pino is not installed, falls back to DefaultLogger behavior.
+ *
+ * Install pino: npm install pino pino-pretty
+ *
+ * Usage:
+ * ```typescript
+ * import { PinoLogger } from '@mcp-abap-adt/logger';
+ * const logger = new PinoLogger();
+ * logger.info('Test message');
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PinoLogger = void 0;
+const interfaces_1 = require("@mcp-abap-adt/interfaces");
+const default_logger_1 = require("./default-logger");
+const types_1 = require("./types");
+class PinoLogger {
+    pinoLogger;
+    logLevel;
+    fallbackLogger;
+    constructor(logLevel) {
+        this.logLevel = logLevel ?? (0, types_1.getLogLevel)();
+        this.fallbackLogger = new default_logger_1.DefaultLogger(this.logLevel);
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const pino = require('pino');
+            const isDev = process.env.NODE_ENV !== 'production';
+            this.pinoLogger = pino({
+                level: this.logLevelToPinoLevel(this.logLevel),
+                redact: ['password', 'token', 'headers.authorization'],
+                transport: isDev
+                    ? {
+                        target: 'pino-pretty',
+                        options: {
+                            colorize: true,
+                        },
+                    }
+                    : undefined,
+            });
+        }
+        catch (error) {
+            this.pinoLogger = null;
+            // Log error in development for debugging
+            if (process.env.NODE_ENV !== 'production') {
+                console.error('PinoLogger initialization error:', error?.message || error);
+            }
+        }
+    }
+    logLevelToPinoLevel(level) {
+        switch (level) {
+            case interfaces_1.LogLevel.ERROR: return 'error';
+            case interfaces_1.LogLevel.WARN: return 'warn';
+            case interfaces_1.LogLevel.INFO: return 'info';
+            case interfaces_1.LogLevel.DEBUG: return 'debug';
+            default: return 'info';
+        }
+    }
+    info(message, meta) {
+        if (this.logLevel < interfaces_1.LogLevel.INFO)
+            return;
+        if (this.pinoLogger) {
+            const iconMessage = `ℹ️ ${message}`;
+            if (meta) {
+                this.pinoLogger.info(meta, iconMessage);
+            }
+            else {
+                this.pinoLogger.info(iconMessage);
+            }
+        }
+        else {
+            this.fallbackLogger.info(message, meta);
+        }
+    }
+    debug(message, meta) {
+        if (this.logLevel < interfaces_1.LogLevel.DEBUG)
+            return;
+        if (this.pinoLogger) {
+            const iconMessage = `🐛 ${message}`;
+            if (meta) {
+                this.pinoLogger.debug(meta, iconMessage);
+            }
+            else {
+                this.pinoLogger.debug(iconMessage);
+            }
+        }
+        else {
+            this.fallbackLogger.debug(message, meta);
+        }
+    }
+    warn(message, meta) {
+        if (this.logLevel < interfaces_1.LogLevel.WARN)
+            return;
+        if (this.pinoLogger) {
+            const iconMessage = `⚠️ ${message}`;
+            if (meta) {
+                this.pinoLogger.warn(meta, iconMessage);
+            }
+            else {
+                this.pinoLogger.warn(iconMessage);
+            }
+        }
+        else {
+            this.fallbackLogger.warn(message, meta);
+        }
+    }
+    error(message, meta) {
+        if (this.logLevel < interfaces_1.LogLevel.ERROR)
+            return;
+        if (this.pinoLogger) {
+            const iconMessage = `💥 ${message}`;
+            if (meta) {
+                this.pinoLogger.error(meta, iconMessage);
+            }
+            else {
+                this.pinoLogger.error(iconMessage);
+            }
+        }
+        else {
+            this.fallbackLogger.error(message, meta);
+        }
+    }
+}
+exports.PinoLogger = PinoLogger;

package/dist/types.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Types and utilities for logger
+ */
+import { LogLevel } from '@mcp-abap-adt/interfaces';
+/**
+ * Logger interface - re-exported from @mcp-abap-adt/interfaces for backward compatibility
+ * @deprecated Use ILogger from @mcp-abap-adt/interfaces for new code
+ */
+export type Logger = import('@mcp-abap-adt/interfaces').ILogger;
+/**
+ * Get log level from environment variable
+ * AUTH_LOG_LEVEL can be: error, warn, info, debug
+ * DEBUG_AUTH_LOG=true is also supported for backward compatibility (sets level to debug)
+ */
+export declare function getLogLevel(): LogLevel;

package/dist/types.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * Types and utilities for logger
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLogLevel = getLogLevel;
+const interfaces_1 = require("@mcp-abap-adt/interfaces");
+/**
+ * Get log level from environment variable
+ * AUTH_LOG_LEVEL can be: error, warn, info, debug
+ * DEBUG_AUTH_LOG=true is also supported for backward compatibility (sets level to debug)
+ */
+function getLogLevel() {
+    const level = process.env.AUTH_LOG_LEVEL?.toLowerCase();
+    if (level === 'error')
+        return interfaces_1.LogLevel.ERROR;
+    if (level === 'warn')
+        return interfaces_1.LogLevel.WARN;
+    if (level === 'info')
+        return interfaces_1.LogLevel.INFO;
+    if (level === 'debug')
+        return interfaces_1.LogLevel.DEBUG;
+    // Backward compatibility
+    if (process.env.DEBUG_AUTH_LOG === 'true')
+        return interfaces_1.LogLevel.DEBUG;
+    // Default: info level
+    return interfaces_1.LogLevel.INFO;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcp-abap-adt/logger",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Logger interface and implementations for MCP ABAP ADT packages",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -44,12 +44,26 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
-    "@mcp-abap-adt/interfaces": "^0.1.1"
+    "@mcp-abap-adt/interfaces": "^0.1.16"
+  },
+  "peerDependencies": {
+    "pino": "^10.1.0",
+    "pino-pretty": "^13.1.3"
+  },
+  "peerDependenciesMeta": {
+    "pino": {
+      "optional": true
+    },
+    "pino-pretty": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",
     "@types/node": "^24.2.1",
     "jest": "^30.2.0",
+    "pino": "^10.1.0",
+    "pino-pretty": "^13.1.3",
     "ts-jest": "^29.2.5",
     "typescript": "^5.9.2"
   }

package/dist/logger.d.ts

@@ -1,24 +0,0 @@
-/**
- * Logger interface and implementations for MCP ABAP ADT packages
- */
-import type { ILogger } from '@mcp-abap-adt/interfaces';
-/**
- * Log levels
- */
-export declare enum LogLevel {
-    ERROR = 0,
-    WARN = 1,
-    INFO = 2,
-    DEBUG = 3
-}
-/**
- * Logger interface - re-exported from @mcp-abap-adt/interfaces for backward compatibility
- * @deprecated Use ILogger from @mcp-abap-adt/interfaces for new code
- */
-export type Logger = ILogger;
-export declare const defaultLogger: ILogger;
-export declare const testLogger: ILogger;
-export declare function info(message: string, meta?: any): void;
-export declare function debug(message: string, meta?: any): void;
-export declare function error(message: string, meta?: any): void;
-export declare function warn(message: string, meta?: any): void;

package/dist/logger.js

@@ -1,202 +0,0 @@
-"use strict";
-/**
- * Logger interface and implementations for MCP ABAP ADT packages
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.testLogger = exports.defaultLogger = exports.LogLevel = void 0;
-exports.info = info;
-exports.debug = debug;
-exports.error = error;
-exports.warn = warn;
-/**
- * Log levels
- */
-var LogLevel;
-(function (LogLevel) {
-    LogLevel[LogLevel["ERROR"] = 0] = "ERROR";
-    LogLevel[LogLevel["WARN"] = 1] = "WARN";
-    LogLevel[LogLevel["INFO"] = 2] = "INFO";
-    LogLevel[LogLevel["DEBUG"] = 3] = "DEBUG";
-})(LogLevel || (exports.LogLevel = LogLevel = {}));
-/**
- * Get log level from environment variable
- * AUTH_LOG_LEVEL can be: error, warn, info, debug
- * DEBUG_AUTH_LOG=true is also supported for backward compatibility (sets level to debug)
- */
-function getLogLevel() {
-    const level = process.env.AUTH_LOG_LEVEL?.toLowerCase();
-    if (level === 'error')
-        return LogLevel.ERROR;
-    if (level === 'warn')
-        return LogLevel.WARN;
-    if (level === 'info')
-        return LogLevel.INFO;
-    if (level === 'debug')
-        return LogLevel.DEBUG;
-    // Backward compatibility
-    if (process.env.DEBUG_AUTH_LOG === 'true')
-        return LogLevel.DEBUG;
-    // Default: info level
-    return LogLevel.INFO;
-}
-/**
- * Default logger implementation
- * Controls output based on AUTH_LOG_LEVEL environment variable:
- * - error: only errors
- * - warn: errors and warnings
- * - info: errors, warnings, and info (default)
- * - debug: all messages
- */
-class DefaultLogger {
-    logLevel;
-    constructor(logLevel) {
-        this.logLevel = logLevel ?? getLogLevel();
-    }
-    info(message, meta) {
-        if (this.logLevel >= LogLevel.INFO) {
-            if (meta) {
-                console.info(message, meta);
-            }
-            else {
-                console.info(message);
-            }
-        }
-    }
-    debug(message, meta) {
-        if (this.logLevel >= LogLevel.DEBUG) {
-            if (meta) {
-                console.debug(`[DEBUG] ${message}`, meta);
-            }
-            else {
-                console.debug(`[DEBUG] ${message}`);
-            }
-        }
-    }
-    error(message, meta) {
-        if (this.logLevel >= LogLevel.ERROR) {
-            if (meta) {
-                console.error(message, meta);
-            }
-            else {
-                console.error(message);
-            }
-        }
-    }
-    warn(message, meta) {
-        if (this.logLevel >= LogLevel.WARN) {
-            if (meta) {
-                console.warn(`[WARN] ${message}`, meta);
-            }
-            else {
-                console.warn(`[WARN] ${message}`);
-            }
-        }
-    }
-    browserAuth(message) {
-        this.info(`🌐 ${message}`);
-    }
-    refresh(message) {
-        this.info(`🔄 ${message}`);
-    }
-    success(message) {
-        this.info(`✅ ${message}`);
-    }
-    browserUrl(url) {
-        // Always show URL when browser is not opened automatically (user needs to open manually)
-        this.info(`🔗 Open in browser: ${url}`);
-    }
-    browserOpening() {
-        // Only show when debug is enabled (browser opens automatically)
-        this.debug(`🌐 Opening browser for authentication...`);
-    }
-    testSkip(message) {
-        this.info(`⏭️  ${message}`);
-    }
-}
-/**
- * Test logger implementation
- * Uses same log levels as DefaultLogger
- */
-class TestLogger {
-    logLevel;
-    constructor(logLevel) {
-        this.logLevel = logLevel ?? getLogLevel();
-    }
-    info(message, meta) {
-        if (this.logLevel >= LogLevel.INFO) {
-            if (meta) {
-                console.info(message, meta);
-            }
-            else {
-                console.info(message);
-            }
-        }
-    }
-    debug(message, meta) {
-        if (this.logLevel >= LogLevel.DEBUG) {
-            if (meta) {
-                console.info(`[DEBUG] ${message}`, meta);
-            }
-            else {
-                console.info(`[DEBUG] ${message}`);
-            }
-        }
-    }
-    error(message, meta) {
-        if (this.logLevel >= LogLevel.ERROR) {
-            if (meta) {
-                console.error(message, meta);
-            }
-            else {
-                console.error(message);
-            }
-        }
-    }
-    warn(message, meta) {
-        if (this.logLevel >= LogLevel.WARN) {
-            if (meta) {
-                console.warn(`[WARN] ${message}`, meta);
-            }
-            else {
-                console.warn(`[WARN] ${message}`);
-            }
-        }
-    }
-    browserAuth(message) {
-        this.info(`🌐 ${message}`);
-    }
-    refresh(message) {
-        this.info(`🔄 ${message}`);
-    }
-    success(message) {
-        this.info(`✅ ${message}`);
-    }
-    browserUrl(url) {
-        // Always show URL when browser is not opened automatically (user needs to open manually)
-        this.info(`🔗 Open in browser: ${url}`);
-    }
-    browserOpening() {
-        // Only show when debug is enabled (browser opens automatically)
-        this.debug(`🌐 Opening browser for authentication...`);
-    }
-    testSkip(message) {
-        this.info(`⏭️  ${message}`);
-    }
-}
-// Default logger instance (singleton)
-exports.defaultLogger = new DefaultLogger();
-// Test logger instance
-exports.testLogger = new TestLogger();
-// Export convenience functions that use default logger (for backward compatibility)
-function info(message, meta) {
-    exports.defaultLogger.info(message, meta);
-}
-function debug(message, meta) {
-    exports.defaultLogger.debug(message, meta);
-}
-function error(message, meta) {
-    exports.defaultLogger.error(message, meta);
-}
-function warn(message, meta) {
-    exports.defaultLogger.warn(message, meta);
-}