chia-agent 15.0.0 → 16.0.1

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # Changelog
 
+## [16.0.1]
+### Fixed
+- Fixed an issue where it exhausts heap when logging an object with circular references
+
+## [16.0.0]
+### Breaking change
+- Changed `daemon.connect()` API signature from `connect(url?, timeoutMs?)` to `connect(url?, options?)`
+  - All connection options are now consolidated into a single `options` parameter
+  - Existing code calling `connect()` without parameters remains compatible
+### Changed
+- Improved logger system
+  - Added logger instance caching
+  - Added support for multiple loggers with per-instance configuration
+  - Added `NullWriter` for complete log suppression
+  - Updated `ConsoleWriter` to use proper console methods
+  - Added `trace` log level
+  - Added environment variable support: `LOG_LEVEL` and `LOG_SUPPRESS`
+  - Refactored API to use named loggers
+  - Added customizable log formatting with built-in formatters
+- Auto-reconnection is now enabled by default
+### Fixed
+- Fixed WebSocket message handling issues
+  - Added timeout handling for sent messages (default 30s)
+  - Fixed connection state check to use actual WebSocket readyState
+  - Preserved event listeners on connection close for reconnection support
+  - Added proper cleanup of message timeouts on response
+- Fixed RPC agent to properly handle HTTP connections with explicit host/port
+### Added
+- Added automatic retry/reconnection mechanism for WebSocket connection attempts
+  - Exponential backoff with configurable parameters
+  - Configurable retry parameters (maxAttempts, initialDelay, maxDelay, backoffMultiplier)
+  - Automatic re-subscription to services after reconnection
+  - Same retry configuration applies to both initial connection and reconnection
+### Internal change
+- Removed `TDestination` type in favor of Writer-based approach
+
 ## [15.0.0]
 ### Breaking change
 - The following Wallet RPC APIs for DAO were removed
@@ -1850,6 +1886,8 @@ daemon.sendMessage(destination, get_block_record_by_height_command, data);
 Initial release.
 
 <!-- [Unreleased]: https://github.com/Chia-Mine/chia-agent/compare/v0.0.1...v0.0.2 -->
+[16.0.1]: https://github.com/Chia-Mine/chia-agent/compare/v16.0.0...v16.0.1
+[16.0.0]: https://github.com/Chia-Mine/chia-agent/compare/v15.0.0...v16.0.0
 [15.0.0]: https://github.com/Chia-Mine/chia-agent/compare/v14.5.0...v15.0.0
 [14.5.0]: https://github.com/Chia-Mine/chia-agent/compare/v14.4.0...v14.5.0
 [14.4.0]: https://github.com/Chia-Mine/chia-agent/compare/v14.3.3...v14.4.0

package/README.md

@@ -113,6 +113,33 @@ setTimeout(async () => {
  */
 ```
 
+## Logging
+The logger system supports multiple log levels and formatters:
+
+```js
+const {setLogLevel, getLogger, setDefaultFormatter, simpleLogFormatter} = require("chia-agent");
+
+// Set log level (case-insensitive)
+setLogLevel("DEBUG"); // "error", "warning", "info", "debug", "trace", "none"
+
+// Use built-in formatters
+setDefaultFormatter(simpleLogFormatter); // Simple format without timestamp
+
+// Custom formatter
+const myFormatter = (context) => {
+  return `[${context.level}] ${context.message}`;
+};
+setDefaultFormatter(myFormatter);
+
+// Named loggers
+const logger = getLogger("MyModule");
+logger.info("Module initialized");
+
+// Per-logger configuration
+logger.setLogLevel("debug");
+logger.setFormatter(myFormatter);
+```
+
 ## API Reference
 [See Documentation here](https://github.com/Chia-Mine/chia-agent/blob/main/src/api/README.md)
 

package/daemon/index.d.ts

@@ -7,12 +7,27 @@ export type WsEvent = Event | MessageEvent | ErrorEvent | CloseEvent;
 export type EventListener<T = WsEvent> = (ev: T) => unknown;
 type EventListenerOf<T> = T extends "open" ? EventListener<Event> : T extends "message" ? EventListener<MessageEvent> : T extends "error" ? EventListener<ErrorEvent> : T extends "close" ? EventListener<CloseEvent> : never;
 export type MessageListener<D extends WsMessage> = (msg: D) => unknown;
+export interface RetryOptions {
+    maxAttempts?: number;
+    initialDelay?: number;
+    maxDelay?: number;
+    backoffMultiplier?: number;
+}
+export interface ConnectOptions {
+    timeoutMs?: number;
+    autoReconnect?: boolean;
+    retryOptions?: RetryOptions;
+}
 export declare function getDaemon(serviceName?: string): Daemon;
 declare class Daemon {
     protected _socket: WS | null;
     protected _connectedUrl: string;
     protected _responseQueue: {
-        [request_id: string]: (value: unknown) => void;
+        [request_id: string]: {
+            resolver: (value: unknown) => void;
+            rejecter: (error: unknown) => void;
+            timeout: NodeJS.Timeout;
+        };
     };
     protected _openEventListeners: Array<(e: Event) => unknown>;
     protected _messageEventListeners: Array<(e: MessageEvent) => unknown>;
@@ -23,18 +38,25 @@ declare class Daemon {
     protected _onClosePromise: (() => unknown) | undefined;
     protected _subscriptions: string[];
     protected _serviceName: string;
+    protected _autoReconnect: boolean;
+    protected _retryOptions: Required<RetryOptions>;
+    protected _timeoutMs: number;
+    protected _reconnectAttempts: number;
+    protected _reconnectTimer: NodeJS.Timeout | null;
+    protected _lastConnectionUrl: string;
+    protected _isReconnecting: boolean;
     get connected(): boolean;
     get closing(): boolean;
     constructor(serviceName?: string);
     protected onRejection(e: unknown): null;
     /**
      * Connect to local daemon via websocket.
-     * @param daemonServerURL
-     * @param timeoutMs
+     * @param daemonServerURL - The websocket URL to connect to. If not provided, uses config values.
+     * @param options - Connection options including timeout, reconnect settings, and retry settings
      */
-    connect(daemonServerURL?: string, timeoutMs?: number): Promise<boolean>;
+    connect(daemonServerURL?: string, options?: ConnectOptions): Promise<boolean>;
     close(): Promise<unknown>;
-    sendMessage<M = unknown>(destination: string, command: string, data?: Record<string, unknown>): Promise<M>;
+    sendMessage<M = unknown>(destination: string, command: string, data?: Record<string, unknown>, timeoutMs?: number): Promise<M>;
     createMessageTemplate(command: string, destination: string, data: Record<string, unknown>): {
         command: string;
         data: Record<string, unknown>;
@@ -61,6 +83,7 @@ declare class Daemon {
     protected onClose(event: CloseEvent): void;
     protected onPing(): void;
     protected onPong(): void;
+    protected _attemptReconnection(previousSubscriptions: string[]): void;
 }
 export type TDaemon = InstanceType<typeof Daemon>;
 export {};

package/daemon/index.js

@@ -1,11 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDaemon = getDaemon;
+const WS = require("ws");
 const crypto_1 = require("crypto");
 const logger_1 = require("../logger");
 const connection_1 = require("./connection");
 const index_1 = require("../config/index");
 const DEFAULT_SERVICE_NAME = "wallet_ui";
+const DEFAULT_AUTO_RECONNECT = true;
+const DEFAULT_TIMEOUT_MS = 30000;
+const DEFAULT_RETRY_OPTIONS = {
+    maxAttempts: 5,
+    initialDelay: 1000,
+    maxDelay: 30000,
+    backoffMultiplier: 1.5,
+};
 let daemon = null;
 function getDaemon(serviceName) {
     if (daemon) {
@@ -38,7 +47,9 @@ const onProcessExit = () => {
 process.addListener("SIGINT", onProcessExit);
 class Daemon {
     get connected() {
-        return Boolean(this._connectedUrl);
+        return (Boolean(this._connectedUrl) &&
+            this._socket !== null &&
+            this._socket.readyState === WS.OPEN);
     }
     get closing() {
         return this._closing;
@@ -55,6 +66,13 @@ class Daemon {
         this._closing = false;
         this._subscriptions = [];
         this._serviceName = DEFAULT_SERVICE_NAME;
+        this._autoReconnect = DEFAULT_AUTO_RECONNECT;
+        this._retryOptions = DEFAULT_RETRY_OPTIONS;
+        this._timeoutMs = DEFAULT_TIMEOUT_MS;
+        this._reconnectAttempts = 0;
+        this._reconnectTimer = null;
+        this._lastConnectionUrl = "";
+        this._isReconnecting = false;
         this.onOpen = this.onOpen.bind(this);
         this.onError = this.onError.bind(this);
         this.onMessage = this.onMessage.bind(this);
@@ -88,16 +106,32 @@ class Daemon {
     }
     /**
      * Connect to local daemon via websocket.
-     * @param daemonServerURL
-     * @param timeoutMs
+     * @param daemonServerURL - The websocket URL to connect to. If not provided, uses config values.
+     * @param options - Connection options including timeout, reconnect settings, and retry settings
      */
-    async connect(daemonServerURL, timeoutMs) {
+    async connect(daemonServerURL, options) {
         if (!daemonServerURL) {
             const config = (0, index_1.getConfig)();
             const daemonHost = config["/ui/daemon_host"];
             const daemonPort = config["/ui/daemon_port"];
             daemonServerURL = `wss://${daemonHost}:${daemonPort}`;
         }
+        // Extract options with defaults
+        const timeoutMs = options?.timeoutMs || this._timeoutMs;
+        // Store timeout for reconnection attempts
+        if (options?.timeoutMs !== undefined) {
+            this._timeoutMs = options.timeoutMs;
+        }
+        // Update settings from options
+        if (options?.autoReconnect !== undefined) {
+            this._autoReconnect = options.autoReconnect;
+        }
+        if (options?.retryOptions !== undefined) {
+            this._retryOptions = {
+                ...DEFAULT_RETRY_OPTIONS,
+                ...options.retryOptions,
+            };
+        }
         if (this._connectedUrl === daemonServerURL) {
             return true;
         }
@@ -105,25 +139,53 @@ class Daemon {
             (0, logger_1.getLogger)().error("Connection is still active. Please close living connection first");
             return false;
         }
-        (0, logger_1.getLogger)().debug(`Opening websocket connection to ${daemonServerURL}`);
-        const result = await (0, connection_1.open)(daemonServerURL, timeoutMs).catch(this.onRejection);
-        if (!result) {
-            return false;
+        // Store URL for reconnection
+        this._lastConnectionUrl = daemonServerURL;
+        // Attempt connection with retry logic
+        let lastError;
+        for (let attempt = 1; attempt <= this._retryOptions.maxAttempts; attempt++) {
+            (0, logger_1.getLogger)().debug(`Opening websocket connection to ${daemonServerURL} (attempt ${attempt}/${this._retryOptions.maxAttempts})`);
+            const result = await (0, connection_1.open)(daemonServerURL, timeoutMs).catch((error) => {
+                lastError = error;
+                return null;
+            });
+            if (result) {
+                this._socket = result.ws;
+                this._socket.on("error", this.onError);
+                this._socket.addEventListener("message", this.onMessage);
+                this._socket.on("close", this.onClose);
+                this._socket.on("ping", this.onPing);
+                this._socket.on("pong", this.onPong);
+                // Call onOpen but don't check result (maintain original behavior)
+                await this.onOpen(result.openEvent, daemonServerURL).catch(this.onRejection);
+                return true;
+            }
+            // If not the last attempt, wait before retrying
+            if (attempt < this._retryOptions.maxAttempts) {
+                const delay = Math.min(this._retryOptions.initialDelay *
+                    Math.pow(this._retryOptions.backoffMultiplier, attempt - 1), this._retryOptions.maxDelay);
+                (0, logger_1.getLogger)().info(`Connection attempt ${attempt} failed. Retrying in ${delay}ms...`);
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
         }
-        this._socket = result.ws;
-        this._socket.on("error", this.onError);
-        this._socket.addEventListener("message", this.onMessage);
-        this._socket.on("close", this.onClose);
-        this._socket.on("ping", this.onPing);
-        this._socket.on("pong", this.onPong);
-        await this.onOpen(result.openEvent, daemonServerURL).catch(this.onRejection);
-        return true;
+        // All attempts failed
+        (0, logger_1.getLogger)().error(`Failed to connect after ${this._retryOptions.maxAttempts} attempts`);
+        this.onRejection(lastError);
+        return false;
     }
     async close() {
         return new Promise((resolve) => {
             if (this._closing || !this._socket) {
                 return;
             }
+            // Cancel any pending reconnection
+            if (this._reconnectTimer) {
+                clearTimeout(this._reconnectTimer);
+                this._reconnectTimer = null;
+            }
+            // Disable reconnection for manual close
+            this._autoReconnect = false;
+            this._isReconnecting = false;
             (0, logger_1.getLogger)().debug("Closing web socket connection");
             this._socket.close();
             this._closing = true;
@@ -131,7 +193,7 @@ class Daemon {
             this._onClosePromise = resolve; // Resolved in onClose function.
         });
     }
-    async sendMessage(destination, command, data) {
+    async sendMessage(destination, command, data, timeoutMs = 30000) {
         return new Promise((resolve, reject) => {
             if (!this.connected || !this._socket) {
                 (0, logger_1.getLogger)().error("Tried to send message without active connection");
@@ -140,13 +202,32 @@ class Daemon {
             }
             const message = this.createMessageTemplate(command, destination, data || {});
             const reqId = message.request_id;
-            this._responseQueue[reqId] = resolve;
-            (0, logger_1.getLogger)().debug(`Sending message. dest=${destination} command=${command} reqId=${reqId}`);
+            // Set up timeout
+            const timeout = setTimeout(() => {
+                const entry = this._responseQueue[reqId];
+                if (entry) {
+                    delete this._responseQueue[reqId];
+                    entry.rejecter(new Error(`Message timeout after ${timeoutMs}ms. dest=${destination} command=${command} reqId=${reqId}`));
+                }
+            }, timeoutMs);
+            this._responseQueue[reqId] = {
+                resolver: resolve,
+                rejecter: reject,
+                timeout,
+            };
+            (0, logger_1.getLogger)().debug(`Sending Ws message. dest=${destination} command=${command} reqId=${reqId}`);
             const messageStr = JSON.stringify(message);
             this._socket.send(messageStr, (err) => {
                 if (err) {
                     (0, logger_1.getLogger)().error(`Error while sending message: ${messageStr}`);
                     (0, logger_1.getLogger)().error(JSON.stringify(err));
+                    // Clean up on send error
+                    const entry = this._responseQueue[reqId];
+                    if (entry) {
+                        clearTimeout(entry.timeout);
+                        delete this._responseQueue[reqId];
+                        reject(err);
+                    }
                 }
             });
         });
@@ -272,7 +353,7 @@ class Daemon {
         return this.subscribe(this._serviceName);
     }
     onError(error) {
-        (0, logger_1.getLogger)().error(`ws connection error: ${error.message}`);
+        (0, logger_1.getLogger)().error(`ws connection error: ${error.type} ${error.target} ${error.error} ${error.message}`);
         this._errorEventListeners.forEach((l) => l(error));
     }
     onMessage(event) {
@@ -285,16 +366,21 @@ class Daemon {
             ({ request_id, origin, command } = payload);
         }
         catch (err) {
-            (0, logger_1.getLogger)().error(`Failed to parse message data: ${JSON.stringify(err)}`);
-            (0, logger_1.getLogger)().error(`payload: ${event.data}`);
+            (0, logger_1.getLogger)().error(`Failed to parse ws message data: ${JSON.stringify(err)}`);
+            (0, logger_1.getLogger)().error(`ws payload: ${event.data}`);
             return;
         }
-        (0, logger_1.getLogger)().debug(`Arrived message. origin=${origin} command=${command} reqId=${request_id}`);
-        const resolver = this._responseQueue[request_id];
-        if (resolver) {
+        const entry = this._responseQueue[request_id];
+        if (entry) {
+            clearTimeout(entry.timeout);
             delete this._responseQueue[request_id];
-            resolver(payload);
+            (0, logger_1.getLogger)().debug(`Ws response received. origin=${origin} command=${command} reqId=${request_id}`);
+            entry.resolver(payload);
         }
+        else {
+            (0, logger_1.getLogger)().debug(`Ws message arrived. origin=${origin} command=${command} reqId=${request_id}`);
+        }
+        (0, logger_1.getLogger)().trace(`Ws message: ${JSON.stringify(payload)}`);
         this._messageEventListeners.forEach((l) => l(event));
         for (const o in this._messageListeners) {
             if (!Object.prototype.hasOwnProperty.call(this._messageListeners, o)) {
@@ -307,6 +393,7 @@ class Daemon {
         }
     }
     onClose(event) {
+        const previousSubscriptions = [...this._subscriptions];
         if (this._socket) {
             this._socket.off("error", this.onError);
             this._socket.removeEventListener("message", this.onMessage);
@@ -319,12 +406,22 @@ class Daemon {
         this._connectedUrl = "";
         this._subscriptions = [];
         this._closeEventListeners.forEach((l) => l(event));
-        this.clearAllEventListeners();
+        // Don't clear event listeners - preserve them for reconnection
+        // this.clearAllEventListeners();
         (0, logger_1.getLogger)().info(`Closed ws connection. code:${event.code} wasClean:${event.wasClean} reason:${event.reason}`);
         if (this._onClosePromise) {
             this._onClosePromise();
             this._onClosePromise = undefined;
         }
+        // Attempt reconnection if enabled and not manually closed
+        if (this._autoReconnect &&
+            this._lastConnectionUrl &&
+            !this._isReconnecting &&
+            event.code !== 1000 // 1000 = normal closure
+        ) {
+            this._isReconnecting = true;
+            this._attemptReconnection(previousSubscriptions);
+        }
     }
     onPing() {
         (0, logger_1.getLogger)().debug("Received ping");
@@ -332,4 +429,63 @@ class Daemon {
     onPong() {
         (0, logger_1.getLogger)().debug("Received pong");
     }
+    _attemptReconnection(previousSubscriptions) {
+        if (this._reconnectAttempts >= this._retryOptions.maxAttempts) {
+            (0, logger_1.getLogger)().error(`Max reconnection attempts (${this._retryOptions.maxAttempts}) reached. Giving up.`);
+            this._isReconnecting = false;
+            this._reconnectAttempts = 0;
+            // Emit a custom event for max retries reached
+            const errorEvent = {
+                type: "error",
+                message: "Max reconnection attempts reached",
+                error: new Error("Max reconnection attempts reached"),
+                target: this._socket,
+            };
+            this._errorEventListeners.forEach((l) => l(errorEvent));
+            return;
+        }
+        const delay = Math.min(this._retryOptions.initialDelay *
+            Math.pow(this._retryOptions.backoffMultiplier, this._reconnectAttempts), this._retryOptions.maxDelay);
+        this._reconnectAttempts++;
+        (0, logger_1.getLogger)().info(`Attempting reconnection ${this._reconnectAttempts}/${this._retryOptions.maxAttempts} in ${delay}ms...`);
+        this._reconnectTimer = setTimeout(async () => {
+            this._reconnectTimer = null;
+            try {
+                const connected = await this.connect(this._lastConnectionUrl, {
+                    timeoutMs: this._timeoutMs,
+                    autoReconnect: this._autoReconnect,
+                    retryOptions: this._retryOptions,
+                });
+                if (connected) {
+                    (0, logger_1.getLogger)().info("Reconnection successful");
+                    this._reconnectAttempts = 0;
+                    this._isReconnecting = false;
+                    // Re-establish previous subscriptions
+                    for (const service of previousSubscriptions) {
+                        try {
+                            await this.subscribe(service);
+                            (0, logger_1.getLogger)().debug(`Re-subscribed to ${service}`);
+                        }
+                        catch (e) {
+                            (0, logger_1.getLogger)().error(`Failed to re-subscribe to ${service}: ${e}`);
+                        }
+                    }
+                    // Emit successful reconnection event
+                    const reconnectedEvent = {
+                        type: "reconnected",
+                        target: this._socket,
+                    };
+                    this._openEventListeners.forEach((l) => l(reconnectedEvent));
+                }
+                else {
+                    // Connection failed, try again
+                    this._attemptReconnection(previousSubscriptions);
+                }
+            }
+            catch (error) {
+                (0, logger_1.getLogger)().error(`Reconnection attempt failed: ${error}`);
+                this._attemptReconnection(previousSubscriptions);
+            }
+        }, delay);
+    }
 }

package/logger.d.ts

@@ -1,22 +1,49 @@
-export type TLogLevel = "error" | "warning" | "info" | "debug" | "none";
-export type TDestination = "console";
-export type Writer = {
-    write: (message: string) => void;
-};
-export declare function getLogLevel(): TLogLevel;
-export declare function setLogLevel(logLevel: TLogLevel): TLogLevel;
-export declare function getLogger(writer?: TDestination): Logger;
-declare class Logger {
-    loglevel: TLogLevel;
-    protected _writer: Writer;
-    protected constructor(logLevel: TLogLevel, writer?: TDestination | Writer);
-    static getLogger(logLevel: TLogLevel, writer?: TDestination): Logger;
+export type TLogLevel = "error" | "warning" | "info" | "debug" | "trace" | "none";
+export declare function isValidLogLevel(level: string): level is TLogLevel;
+export declare function normalizeLogLevel(level: string): TLogLevel | null;
+export interface Writer {
+    write: (message: string, level?: TLogLevel) => void;
+}
+export interface LogContext {
+    timestamp: Date;
+    level: TLogLevel;
+    loggerName: string;
+    message: string;
+}
+export type LogFormatter = (context: LogContext) => string;
+export declare function setDefaultLogLevel(level: TLogLevel): void;
+export declare function getDefaultLogLevel(): TLogLevel;
+export declare function setDefaultWriter(writer: Writer): void;
+export declare function setDefaultFormatter(formatter: LogFormatter): void;
+export declare function getDefaultFormatter(): LogFormatter;
+export declare const DEFAULT_LOGGER_NAME = "default";
+export declare const defaultLogFormatter: LogFormatter;
+export declare const simpleLogFormatter: LogFormatter;
+export declare const jsonLogFormatter: LogFormatter;
+export declare function getLogger(name?: string): Logger;
+export declare function clearLoggerCache(): void;
+export declare function createConsoleWriter(): Writer;
+export declare function createNullWriter(): Writer;
+export declare class Logger {
+    private _name;
+    private _logLevel;
+    private _writer;
+    private _formatter;
+    constructor(name: string, logLevel: TLogLevel, writer: Writer, formatter?: LogFormatter);
     setLogLevel(level: TLogLevel): void;
-    shouldWrite(logLevel: TLogLevel): boolean;
-    formatMessage(level: TLogLevel, body: string): string;
+    getLogLevel(): TLogLevel;
+    setWriter(writer: Writer): void;
+    getWriter(): Writer;
+    getName(): string;
+    setFormatter(formatter: LogFormatter): void;
+    getFormatter(): LogFormatter;
+    private _shouldWrite;
+    private _formatMessage;
+    trace(msg: any): void;
     debug(msg: any): void;
     info(msg: any): void;
     warning(msg: any): void;
     error(msg: any): void;
 }
-export {};
+export declare function getLogLevel(): TLogLevel;
+export declare function setLogLevel(level: TLogLevel): void;

package/logger.js

@@ -1,26 +1,158 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = exports.jsonLogFormatter = exports.simpleLogFormatter = exports.defaultLogFormatter = exports.DEFAULT_LOGGER_NAME = void 0;
+exports.isValidLogLevel = isValidLogLevel;
+exports.normalizeLogLevel = normalizeLogLevel;
+exports.setDefaultLogLevel = setDefaultLogLevel;
+exports.getDefaultLogLevel = getDefaultLogLevel;
+exports.setDefaultWriter = setDefaultWriter;
+exports.setDefaultFormatter = setDefaultFormatter;
+exports.getDefaultFormatter = getDefaultFormatter;
+exports.getLogger = getLogger;
+exports.clearLoggerCache = clearLoggerCache;
+exports.createConsoleWriter = createConsoleWriter;
+exports.createNullWriter = createNullWriter;
 exports.getLogLevel = getLogLevel;
 exports.setLogLevel = setLogLevel;
-exports.getLogger = getLogger;
+const LOG_LEVELS = [
+    "error",
+    "warning",
+    "info",
+    "debug",
+    "trace",
+    "none",
+];
+function isValidLogLevel(level) {
+    return LOG_LEVELS.includes(level.toLowerCase());
+}
+function normalizeLogLevel(level) {
+    const normalized = level.toLowerCase();
+    if (isValidLogLevel(normalized)) {
+        return normalized;
+    }
+    return null;
+}
 const logPriority = {
     none: 9999,
-    error: 4,
-    warning: 3,
-    info: 2,
-    debug: 1,
+    error: 5,
+    warning: 4,
+    info: 3,
+    debug: 2,
+    trace: 1,
 };
 class ConsoleWriter {
-    write(message) {
-        console.log(message);
+    write(message, level) {
+        switch (level) {
+            case "error":
+                console.error(message);
+                break;
+            case "warning":
+                console.warn(message);
+                break;
+            case "info":
+                console.info(message);
+                break;
+            case "debug":
+                console.debug(message);
+                break;
+            case "trace":
+                console.trace(message);
+                break;
+            default:
+                console.log(message);
+        }
     }
 }
-let currentLogLevel = "error";
-function getLogLevel() {
-    return currentLogLevel;
+class NullWriter {
+    write(_message, _level) {
+        // Suppress all output
+    }
+}
+// Global defaults
+let defaultLogLevel = "error";
+if (process.env.LOG_LEVEL) {
+    const normalizedLevel = normalizeLogLevel(process.env.LOG_LEVEL);
+    if (normalizedLevel) {
+        defaultLogLevel = normalizedLevel;
+    }
+    else {
+        console.warn(`Invalid LOG_LEVEL environment variable: ${process.env.LOG_LEVEL}. Using default: error`);
+    }
+}
+let defaultWriter = process.env.LOG_SUPPRESS === "true" ? new NullWriter() : new ConsoleWriter();
+// Logger instance cache
+const loggerCache = new Map();
+// Configuration functions for global defaults
+function setDefaultLogLevel(level) {
+    // Normalize for JavaScript users who might pass uppercase
+    const normalized = normalizeLogLevel(level);
+    if (!normalized) {
+        throw new Error(`Invalid log level: ${level}. Valid levels are: ${LOG_LEVELS.join(", ")}`);
+    }
+    defaultLogLevel = normalized;
+}
+function getDefaultLogLevel() {
+    return defaultLogLevel;
+}
+function setDefaultWriter(writer) {
+    defaultWriter = writer;
+}
+function setDefaultFormatter(formatter) {
+    defaultFormatter = formatter;
+}
+function getDefaultFormatter() {
+    return defaultFormatter;
+}
+exports.DEFAULT_LOGGER_NAME = "default";
+// Default formatter
+const defaultLogFormatter = (context) => {
+    const timestamp = context.timestamp.toISOString();
+    const levelStr = context.level.toUpperCase();
+    const nameStr = context.loggerName === exports.DEFAULT_LOGGER_NAME
+        ? ""
+        : ` [${context.loggerName}]`;
+    return `${timestamp} [${levelStr}]${nameStr} - ${context.message}`;
+};
+exports.defaultLogFormatter = defaultLogFormatter;
+// Simple formatter without timestamp
+const simpleLogFormatter = (context) => {
+    const levelStr = context.level.toUpperCase();
+    const nameStr = context.loggerName === exports.DEFAULT_LOGGER_NAME
+        ? ""
+        : `[${context.loggerName}] `;
+    return `[${levelStr}] ${nameStr}${context.message}`;
+};
+exports.simpleLogFormatter = simpleLogFormatter;
+// JSON formatter
+const jsonLogFormatter = (context) => {
+    return JSON.stringify({
+        timestamp: context.timestamp.toISOString(),
+        level: context.level,
+        logger: context.loggerName,
+        message: context.message,
+    });
+};
+exports.jsonLogFormatter = jsonLogFormatter;
+let defaultFormatter = exports.defaultLogFormatter;
+// Factory function with caching
+function getLogger(name = exports.DEFAULT_LOGGER_NAME) {
+    let logger = loggerCache.get(name);
+    if (!logger) {
+        logger = new Logger(name, defaultLogLevel, defaultWriter, defaultFormatter);
+        loggerCache.set(name, logger);
+    }
+    return logger;
 }
-function setLogLevel(logLevel) {
-    return (currentLogLevel = logLevel);
+// Clear logger cache (useful for testing)
+function clearLoggerCache() {
+    loggerCache.clear();
+}
+// Helper to create writers
+function createConsoleWriter() {
+    return new ConsoleWriter();
+}
+function createNullWriter() {
+    return new NullWriter();
 }
 function stringify(obj, indent) {
     if (typeof obj === "string") {
@@ -44,73 +176,129 @@ function stringify(obj, indent) {
     else if (typeof obj === "function") {
         return "[Function]";
     }
-    const seen = new WeakSet();
-    return JSON.stringify(obj, (k, v) => {
-        if (typeof v === "object" && v !== null) {
-            if (seen.has(v)) {
-                return undefined;
-            }
-            seen.add(v);
-        }
-        else if (typeof v === "bigint") {
-            return `${v}n`;
-        }
-        return v;
-    }, indent);
-}
-const loggers = {};
-function getLogger(writer) {
-    const w = writer || "console";
-    const logger = loggers[w];
-    if (logger && logger.loglevel === currentLogLevel) {
-        return logger;
+    else if (obj === null) {
+        return "null";
+    }
+    try {
+        // Custom replacer for circular references
+        const getCircularReplacer = () => {
+            const seen = new WeakSet();
+            return (_key, value) => {
+                if (typeof value === "object" && value !== null) {
+                    if (seen.has(value)) {
+                        return "[Circular]";
+                    }
+                    seen.add(value);
+                }
+                else if (typeof value === "bigint") {
+                    return `${value}n`;
+                }
+                else if (typeof value === "function") {
+                    return "[Function]";
+                }
+                else if (typeof value === "symbol") {
+                    return value.toString();
+                }
+                return value;
+            };
+        };
+        return JSON.stringify(obj, getCircularReplacer(), indent);
+    }
+    catch (error) {
+        const msg = error && typeof error === "object" && "message" in error
+            ? error.message
+            : "Unknown error";
+        return `[Error stringifying object: ${msg}]`;
     }
-    return (loggers[w] = Logger.getLogger(currentLogLevel, w));
 }
 class Logger {
-    constructor(logLevel, writer) {
-        this.loglevel = "error";
-        if (writer === "console") {
-            this._writer = new ConsoleWriter();
-        }
-        else if (writer) {
-            this._writer = writer;
+    constructor(name, logLevel, writer, formatter) {
+        // Normalize for JavaScript users who might pass uppercase
+        const normalized = normalizeLogLevel(logLevel);
+        if (!normalized) {
+            throw new Error(`Invalid log level: ${logLevel}. Valid levels are: ${LOG_LEVELS.join(", ")}`);
         }
-        else {
-            this._writer = new ConsoleWriter();
+        this._name = name;
+        this._logLevel = normalized;
+        this._writer = writer;
+        this._formatter = formatter || defaultFormatter;
+    }
+    // Allow changing log level for this specific logger
+    setLogLevel(level) {
+        // Normalize for JavaScript users who might pass uppercase
+        const normalized = normalizeLogLevel(level);
+        if (!normalized) {
+            throw new Error(`Invalid log level: ${level}. Valid levels are: ${LOG_LEVELS.join(", ")}`);
         }
-        this.loglevel = logLevel;
+        this._logLevel = normalized;
     }
-    static getLogger(logLevel, writer) {
-        return new Logger(logLevel, writer);
+    getLogLevel() {
+        return this._logLevel;
     }
-    setLogLevel(level) {
-        this.loglevel = level;
+    // Allow changing writer for this specific logger
+    setWriter(writer) {
+        this._writer = writer;
     }
-    shouldWrite(logLevel) {
-        return logPriority[this.loglevel] <= logPriority[logLevel];
+    getWriter() {
+        return this._writer;
     }
-    formatMessage(level, body) {
-        return `${new Date().toLocaleString()} [${level.toUpperCase()}] ${body}`;
+    getName() {
+        return this._name;
+    }
+    setFormatter(formatter) {
+        this._formatter = formatter;
+    }
+    getFormatter() {
+        return this._formatter;
+    }
+    _shouldWrite(logLevel) {
+        return logPriority[this._logLevel] <= logPriority[logLevel];
+    }
+    _formatMessage(level, body) {
+        const context = {
+            timestamp: new Date(),
+            level,
+            loggerName: this._name,
+            message: body,
+        };
+        return this._formatter(context);
+    }
+    trace(msg) {
+        if (this._shouldWrite("trace")) {
+            this._writer.write(this._formatMessage("trace", stringify(msg)), "trace");
+        }
     }
     debug(msg) {
-        if (this.shouldWrite("debug")) {
-            this._writer.write(this.formatMessage("debug", stringify(msg)));
+        if (this._shouldWrite("debug")) {
+            this._writer.write(this._formatMessage("debug", stringify(msg)), "debug");
         }
     }
     info(msg) {
-        if (this.shouldWrite("info")) {
-            this._writer.write(this.formatMessage("info", stringify(msg)));
+        if (this._shouldWrite("info")) {
+            this._writer.write(this._formatMessage("info", stringify(msg)), "info");
         }
     }
     warning(msg) {
-        if (this.shouldWrite("warning")) {
-            this._writer.write(this.formatMessage("warning", stringify(msg)));
+        if (this._shouldWrite("warning")) {
+            this._writer.write(this._formatMessage("warning", stringify(msg)), "warning");
         }
     }
     error(msg) {
-        if (this.shouldWrite("error")) {
-            this._writer.write(this.formatMessage("error", stringify(msg)));
+        if (this._shouldWrite("error")) {
+            this._writer.write(this._formatMessage("error", stringify(msg)), "error");
         }
     }
 }
+exports.Logger = Logger;
+// For backward compatibility
+function getLogLevel() {
+    return getDefaultLogLevel();
+}
+function setLogLevel(level) {
+    // Normalize for JavaScript users who might pass uppercase
+    const normalized = normalizeLogLevel(level);
+    if (!normalized) {
+        throw new Error(`Invalid log level: ${level}. Valid levels are: ${LOG_LEVELS.join(", ")}`);
+    }
+    setDefaultLogLevel(normalized);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chia-agent",
-  "version": "15.0.0",
+  "version": "16.0.1",
   "author": "ChiaMineJP <admin@chiamine.jp>",
   "description": "chia rpc/websocket client library",
   "license": "MIT",
@@ -10,6 +10,7 @@
   },
   "bugs": "https://github.com/Chia-Mine/chia-agent/issues",
   "main": "./index.js",
+  "types": "./index.d.ts",
   "bin": {
     "chia-agent": "./bin/cli.js"
   },

package/rpc/index.d.ts

@@ -58,12 +58,16 @@ export type TRPCAgentProps = {
     skip_hostname_verification?: boolean;
 } | {
     httpAgent: HttpAgent;
+    host: string;
+    port: number;
     skip_hostname_verification?: boolean;
 };
 export declare class RPCAgent implements APIAgent {
     protected _protocol: "http" | "https";
     protected _agent: HttpsAgent | HttpAgent;
     protected _skip_hostname_verification: boolean;
+    protected _host: string;
+    protected _port: number;
     constructor(props: TRPCAgentProps);
     sendMessage<M>(destination: string, command: string, data?: Record<string, unknown>): Promise<M>;
     request<R>(method: string, path: string, data?: any): Promise<R>;

package/rpc/index.js

@@ -90,15 +90,31 @@ const userAgent = "chia-agent/1.0.0";
 class RPCAgent {
     constructor(props) {
         this._skip_hostname_verification = false;
+        this._host = "";
+        this._port = 0;
         if ("httpsAgent" in props) {
             this._protocol = "https";
             this._agent = props.httpsAgent;
             this._skip_hostname_verification = Boolean(props.skip_hostname_verification);
+            // Extract host/port from httpsAgent options
+            // Note: TypeScript doesn't expose options property, but it exists at runtime
+            const agent = this._agent;
+            if (agent.options && agent.options.host && agent.options.port) {
+                this._host = agent.options.host;
+                this._port = agent.options.port;
+                (0, logger_1.getLogger)().debug(`Constructing RPCAgent with httpsAgent: ${this._host}:${this._port}`);
+            }
+            else {
+                (0, logger_1.getLogger)().debug("Constructing RPCAgent with httpsAgent (host/port not available in agent options)");
+            }
         }
         else if ("httpAgent" in props) {
             this._protocol = "http";
             this._agent = props.httpAgent;
+            this._host = props.host;
+            this._port = props.port;
             this._skip_hostname_verification = Boolean(props.skip_hostname_verification);
+            (0, logger_1.getLogger)().debug(`Constructing RPCAgent with httpAgent: ${this._host}:${this._port}`);
         }
         else if ("protocol" in props) {
             this._protocol = props.protocol;
@@ -116,6 +132,8 @@ class RPCAgent {
             const timeout = typeof props.timeout === "number" && props.timeout > 0
                 ? props.timeout
                 : undefined;
+            this._host = host;
+            this._port = port;
             if (props.protocol === "https") {
                 if ("configPath" in props) {
                     const config = getConf(props.configPath);
@@ -145,6 +163,7 @@ class RPCAgent {
                     maxSockets,
                     timeout,
                 });
+                (0, logger_1.getLogger)().debug(`Constructed RPCAgent with httpsAgent: ${host}:${port}`);
             }
             else {
                 this._agent = new http_1.Agent({
@@ -182,6 +201,8 @@ class RPCAgent {
             const certs = loadCertFilesFromConfig(config);
             const { clientCert, clientKey, caCert } = certs;
             this._skip_hostname_verification = Boolean(props.skip_hostname_verification);
+            this._host = host;
+            this._port = port;
             this._agent = new https_1.Agent({
                 host: host,
                 port: port,
@@ -198,7 +219,7 @@ class RPCAgent {
     }
     async sendMessage(destination, command, data) {
         // parameter `destination` is not used because target rpc server is determined by url.
-        (0, logger_1.getLogger)().debug(`Sending message. dest=${destination} command=${command}`);
+        (0, logger_1.getLogger)().debug(`Sending RPC message. dest=${destination} command=${command}`);
         return this.request("POST", command, data);
     }
     async request(method, path, data) {
@@ -210,10 +231,8 @@ class RPCAgent {
                 Accept: "application/json, text/plain, */*",
                 "User-Agent": userAgent,
             };
-            if ("options" in this._agent &&
-                typeof this._agent.options.host === "string") {
-                // Assuming `this._agent instanceof HttpsAgent` is true.
-                headers.Host = this._agent.options.host;
+            if (this._host) {
+                headers.Host = this._host;
             }
             const options = {
                 path: pathname,
@@ -221,6 +240,11 @@ class RPCAgent {
                 agent: this._agent,
                 headers,
             };
+            // For HTTP protocol, we need to explicitly set hostname and port
+            if (this._protocol === "http") {
+                options.hostname = this._host;
+                options.port = this._port;
+            }
             if (this._skip_hostname_verification) {
                 options.checkServerIdentity = () => {
                     return undefined;
@@ -252,7 +276,9 @@ class RPCAgent {
                 }
             }
             const transporter = this._protocol === "https" ? https_1.request : http_1.request;
-            (0, logger_1.getLogger)().debug(`Requesting to ${options.protocol}//${options.hostname}:${options.port}${options.path}`);
+            (0, logger_1.getLogger)().debug(`Dispatching RPC ${METHOD} request to ${this._protocol}//${this._host}:${this._port}${options.path}`);
+            (0, logger_1.getLogger)().trace(`Request options: ${JSON.stringify(options)}`);
+            (0, logger_1.getLogger)().trace(`Request body: ${body}`);
             const req = transporter(options, (res) => {
                 if (!res.statusCode || res.statusCode < 200 || res.statusCode >= 300) {
                     (0, logger_1.getLogger)().error(`Status not ok: ${res.statusCode}`);
@@ -270,6 +296,7 @@ class RPCAgent {
                     if (chunks.length === 0) {
                         (0, logger_1.getLogger)().debug("The first response chunk data arrived");
                     }
+                    (0, logger_1.getLogger)().trace(`Response chunk #${chunks.length} - ${chunk.length} bytes: ${chunk.toString()}`);
                 });
                 res.on("end", () => {
                     try {
@@ -289,6 +316,8 @@ class RPCAgent {
                                 (0, logger_1.getLogger)().info(`API failure: ${d.error}`);
                                 return reject(d);
                             }
+                            (0, logger_1.getLogger)().debug(`RPC response received from ${this._protocol}//${this._host}:${this._port}${options.path}`);
+                            (0, logger_1.getLogger)().trace(`RPC response data: ${JSON.stringify(d)}`);
                             return resolve(d);
                         }
                         // RPC Server should return response like
@@ -297,8 +326,8 @@ class RPCAgent {
                         (0, logger_1.getLogger)().error("RPC Server returned no data. This is not expected.");
                         reject(new Error("Server responded without expected data"));
                     }
-                    catch (_e) {
-                        (0, logger_1.getLogger)().error("Failed to parse response data");
+                    catch (e) {
+                        (0, logger_1.getLogger)().error(`Failed to parse response data: ${JSON.stringify(e)}`);
                         try {
                             (0, logger_1.getLogger)().error(Buffer.concat(chunks).toString());
                         }