@aashari/boilerplate-mcp-server 1.1.2 → 1.2.0

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [1.2.0](https://github.com/aashari/boilerplate-mcp-server/compare/v1.1.3...v1.2.0) (2025-04-03)
+
+
+### Features
+
+* **boilerplate:** improve version handling and module exports ([faa1713](https://github.com/aashari/boilerplate-mcp-server/commit/faa17138ccb1b943197ae91b37a54527481ffbca))
+
+## [1.1.3](https://github.com/aashari/boilerplate-mcp-server/compare/v1.1.2...v1.1.3) (2025-03-28)
+
+
+### Bug Fixes
+
+* correct TypeScript errors in transport utility ([573a7e6](https://github.com/aashari/boilerplate-mcp-server/commit/573a7e63e1985aa5aefd806c0902462fa34c14d7))
+
 ## [1.1.2](https://github.com/aashari/boilerplate-mcp-server/compare/v1.1.1...v1.1.2) (2025-03-28)
 
 

package/dist/cli/index.d.ts

@@ -1 +1,7 @@
+/**
+ * Run the CLI with the provided arguments
+ *
+ * @param args Command line arguments to process
+ * @returns Promise that resolves when CLI command execution completes
+ */
 export declare function runCli(args: string[]): Promise<void>;

package/dist/cli/index.js

@@ -6,26 +6,38 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCli = runCli;
 const commander_1 = require("commander");
 const logger_util_js_1 = require("../utils/logger.util.js");
+const constants_util_js_1 = require("../utils/constants.util.js");
 const ipaddress_cli_js_1 = __importDefault(require("./ipaddress.cli.js"));
-// Get the version from package.json
-const VERSION = '1.1.2'; // This should match the version in src/index.ts
-const NAME = '@aashari/boilerplate-mcp-server';
+/**
+ * CLI entry point for the Boilerplate MCP Server
+ * Handles command registration, parsing, and execution
+ */
+// Package description
 const DESCRIPTION = 'A boilerplate Model Context Protocol (MCP) server implementation using TypeScript';
+/**
+ * Run the CLI with the provided arguments
+ *
+ * @param args Command line arguments to process
+ * @returns Promise that resolves when CLI command execution completes
+ */
 async function runCli(args) {
-    const methodLogger = logger_util_js_1.Logger.forContext('cli/index.ts', 'runCli');
-    methodLogger.debug('Processing CLI arguments', args);
+    const cliLogger = logger_util_js_1.Logger.forContext('cli/index.ts', 'runCli');
+    cliLogger.debug('Initializing CLI with arguments', args);
     const program = new commander_1.Command();
-    program.name(NAME).description(DESCRIPTION).version(VERSION);
+    program.name(constants_util_js_1.CLI_NAME).description(DESCRIPTION).version(constants_util_js_1.VERSION);
     // Register CLI commands
+    cliLogger.debug('Registering CLI commands...');
     ipaddress_cli_js_1.default.register(program);
+    cliLogger.debug('CLI commands registered successfully');
     // Handle unknown commands
     program.on('command:*', (operands) => {
-        methodLogger.error(`Unknown command: ${operands[0]}`);
+        cliLogger.error(`Unknown command: ${operands[0]}`);
         console.log('');
         program.help();
         process.exit(1);
     });
     // Parse arguments; default to help if no command provided
+    cliLogger.debug('Parsing CLI arguments');
     await program.parseAsync(args.length ? args : ['--help'], { from: 'user' });
-    methodLogger.debug('CLI command execution completed');
+    cliLogger.debug('CLI command execution completed');
 }

package/dist/cli/ipaddress.cli.js

@@ -11,8 +11,8 @@ const ipaddress_controller_js_1 = __importDefault(require("../controllers/ipaddr
  * @param program The Commander program instance
  */
 function register(program) {
-    const methodLogger = logger_util_js_1.Logger.forContext('cli/ipaddress.cli.ts', 'register');
-    methodLogger.debug(`Registering IP address CLI commands...`);
+    const cliLogger = logger_util_js_1.Logger.forContext('cli/ipaddress.cli.ts', 'register');
+    cliLogger.debug(`Registering IP address CLI commands...`);
     program
         .command('get-ip-details')
         .description(`Get geolocation and network details about an IP address or the current device.
@@ -31,21 +31,23 @@ function register(program) {
         .option('--extended', 'Include extended data like ASN, mobile and proxy detection')
         .option('--https', 'Use HTTPS for API requests (may require paid API key)')
         .action(async (ipAddress, cmdOptions) => {
-        const actionLogger = logger_util_js_1.Logger.forContext('cli/ipaddress.cli.ts', 'get-ip-details');
+        const commandLogger = logger_util_js_1.Logger.forContext('cli/ipaddress.cli.ts', 'get-ip-details');
         try {
-            actionLogger.debug(`Fetching IP details for ${ipAddress || 'current device'}...`, cmdOptions);
+            commandLogger.debug(`Processing IP details request for ${ipAddress || 'current device'}`, cmdOptions);
             // Map CLI options to controller options
             const controllerOptions = {
                 includeExtendedData: cmdOptions?.extended || false,
                 useHttps: cmdOptions?.https || false,
             };
+            commandLogger.debug('Calling controller with options', controllerOptions);
             const result = await ipaddress_controller_js_1.default.get(ipAddress, controllerOptions);
-            actionLogger.debug(`IP details fetched successfully`, result);
+            commandLogger.debug(`IP details retrieved successfully`);
             console.log(result.content);
         }
         catch (error) {
             (0, error_util_js_1.handleCliError)(error);
         }
     });
+    cliLogger.debug('IP address CLI commands registered successfully');
 }
 exports.default = { register };

package/dist/controllers/ipaddress.controller.d.ts

@@ -1,10 +1,20 @@
 import { ControllerResponse } from '../types/common.types.js';
 import { GetIpOptions } from './ipaddress.types.js';
 /**
- * Get IP address details from the IP API.
- * @param ipAddress Optional IP address to lookup (omit for current IP)
- * @param options Optional configuration for the request
- * @returns Controller response with formatted content
+ * @namespace IpAddressController
+ * @description Controller responsible for handling IP address lookup logic.
+ *              It orchestrates calls to the ip-api.com service, applies defaults,
+ *              maps options, and formats the response using the formatter.
+ */
+/**
+ * @function get
+ * @description Fetches details for a specific IP address or the current device's IP.
+ *              Handles mapping controller options (like includeExtendedData) to service parameters (fields).
+ * @memberof IpAddressController
+ * @param {string} [ipAddress] - Optional IP address to look up. If omitted, the service will fetch the current device's public IP.
+ * @param {GetIpOptions} [options={}] - Optional configuration for the request, such as `includeExtendedData` and `useHttps`.
+ * @returns {Promise<ControllerResponse>} A promise that resolves to the standard controller response containing the formatted IP details in Markdown.
+ * @throws {McpError} Throws an McpError (handled by `handleControllerError`) if the service call fails or returns an error.
  */
 declare function get(ipAddress?: string, options?: GetIpOptions): Promise<ControllerResponse>;
 declare const _default: {

package/dist/controllers/ipaddress.controller.js

@@ -9,10 +9,20 @@ const ipaddress_formatter_js_1 = require("./ipaddress.formatter.js");
 const error_handler_util_js_1 = require("../utils/error-handler.util.js");
 const defaults_util_js_1 = require("../utils/defaults.util.js");
 /**
- * Get IP address details from the IP API.
- * @param ipAddress Optional IP address to lookup (omit for current IP)
- * @param options Optional configuration for the request
- * @returns Controller response with formatted content
+ * @namespace IpAddressController
+ * @description Controller responsible for handling IP address lookup logic.
+ *              It orchestrates calls to the ip-api.com service, applies defaults,
+ *              maps options, and formats the response using the formatter.
+ */
+/**
+ * @function get
+ * @description Fetches details for a specific IP address or the current device's IP.
+ *              Handles mapping controller options (like includeExtendedData) to service parameters (fields).
+ * @memberof IpAddressController
+ * @param {string} [ipAddress] - Optional IP address to look up. If omitted, the service will fetch the current device's public IP.
+ * @param {GetIpOptions} [options={}] - Optional configuration for the request, such as `includeExtendedData` and `useHttps`.
+ * @returns {Promise<ControllerResponse>} A promise that resolves to the standard controller response containing the formatted IP details in Markdown.
+ * @throws {McpError} Throws an McpError (handled by `handleControllerError`) if the service call fails or returns an error.
  */
 async function get(ipAddress, options = {}) {
     const methodLogger = logger_util_js_1.Logger.forContext('controllers/ipaddress.controller.ts', 'get');

package/dist/index.d.ts

@@ -1,6 +1,14 @@
 #!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { Logger } from './utils/logger.util.js';
 import { config } from './utils/config.util.js';
-export declare function startServer(mode?: 'stdio' | 'sse'): Promise<void>;
+/**
+ * Start the MCP server with the specified transport mode
+ *
+ * @param mode The transport mode to use (stdio or sse)
+ * @returns Promise that resolves to the server instance when started successfully
+ */
+export declare function startServer(mode?: 'stdio' | 'sse'): Promise<McpServer>;
 export { config };
 export { Logger };
+export { VERSION, PACKAGE_NAME } from './utils/constants.util.js';

package/dist/index.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Logger = exports.config = void 0;
+exports.PACKAGE_NAME = exports.VERSION = exports.Logger = exports.config = void 0;
 exports.startServer = startServer;
 const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
@@ -13,70 +13,97 @@ Object.defineProperty(exports, "Logger", { enumerable: true, get: function () {
 const config_util_js_1 = require("./utils/config.util.js");
 Object.defineProperty(exports, "config", { enumerable: true, get: function () { return config_util_js_1.config; } });
 const error_util_js_1 = require("./utils/error.util.js");
+const constants_util_js_1 = require("./utils/constants.util.js");
 const index_js_1 = require("./cli/index.js");
+// Import tools and resources
 const ipaddress_tool_js_1 = __importDefault(require("./tools/ipaddress.tool.js"));
 const ipaddress_resource_js_1 = __importDefault(require("./resources/ipaddress.resource.js"));
+/**
+ * Boilerplate MCP Server
+ *
+ * A template project for building MCP servers that follow best practices.
+ * Demonstrates proper structure, logging, error handling, and MCP protocol integration.
+ */
 // Create file-level logger
 const indexLogger = logger_util_js_1.Logger.forContext('index.ts');
-// Define version constant for easier management and consistent versioning
-const VERSION = '1.1.2';
+// Log initialization at debug level
+indexLogger.debug('Boilerplate MCP server module loaded');
 let serverInstance = null;
 let transportInstance = null;
+/**
+ * Start the MCP server with the specified transport mode
+ *
+ * @param mode The transport mode to use (stdio or sse)
+ * @returns Promise that resolves to the server instance when started successfully
+ */
 async function startServer(mode = 'stdio') {
-    const methodLogger = logger_util_js_1.Logger.forContext('index.ts', 'startServer');
+    const serverLogger = logger_util_js_1.Logger.forContext('index.ts', 'startServer');
     // Load configuration
+    serverLogger.info('Starting MCP server initialization...');
     config_util_js_1.config.load();
+    serverLogger.info('Configuration loaded successfully');
     // Enable debug logging if DEBUG is set to true
     if (config_util_js_1.config.getBoolean('DEBUG')) {
-        methodLogger.debug('Debug mode enabled');
+        serverLogger.debug('Debug mode enabled');
     }
     // Log the DEBUG value to verify configuration loading
-    methodLogger.info(`DEBUG value: ${process.env.DEBUG}`);
-    methodLogger.info(`IPAPI_API_TOKEN value exists: ${Boolean(process.env.IPAPI_API_TOKEN)}`);
-    methodLogger.info(`Config DEBUG value: ${config_util_js_1.config.get('DEBUG')}`);
+    serverLogger.debug(`DEBUG environment variable: ${process.env.DEBUG}`);
+    serverLogger.debug(`IPAPI_API_TOKEN value exists: ${Boolean(process.env.IPAPI_API_TOKEN)}`);
+    serverLogger.debug(`Config DEBUG value: ${config_util_js_1.config.get('DEBUG')}`);
+    serverLogger.info(`Initializing Boilerplate MCP server v${constants_util_js_1.VERSION}`);
     serverInstance = new mcp_js_1.McpServer({
-        name: '@aashari/boilerplate-mcp-server',
-        version: VERSION,
+        name: constants_util_js_1.PACKAGE_NAME,
+        version: constants_util_js_1.VERSION,
     });
     if (mode === 'stdio') {
+        serverLogger.info('Using STDIO transport for MCP communication');
         transportInstance = new stdio_js_1.StdioServerTransport();
     }
     else {
         throw (0, error_util_js_1.createUnexpectedError)('SSE mode is not supported yet');
     }
-    methodLogger.info(`Starting server with ${mode.toUpperCase()} transport...`);
-    // register tools
+    // Register tools and resources
+    serverLogger.info('Registering MCP tools and resources...');
     ipaddress_tool_js_1.default.register(serverInstance);
-    methodLogger.debug('Registered IP address tools');
-    // register resources
+    serverLogger.debug('Registered IP address tools');
     ipaddress_resource_js_1.default.register(serverInstance);
-    methodLogger.debug('Registered IP lookup resources');
-    return serverInstance.connect(transportInstance).catch((err) => {
-        methodLogger.error(`Failed to start server`, err);
+    serverLogger.debug('Registered IP lookup resources');
+    serverLogger.info('All tools and resources registered successfully');
+    try {
+        serverLogger.info(`Connecting to ${mode.toUpperCase()} transport...`);
+        await serverInstance.connect(transportInstance);
+        serverLogger.info('MCP server started successfully and ready to process requests');
+        return serverInstance;
+    }
+    catch (err) {
+        serverLogger.error(`Failed to start server`, err);
         process.exit(1);
-    });
+    }
 }
-// Main entry point - this will run when executed directly
+/**
+ * Main entry point - this will run when executed directly
+ * Determines whether to run in CLI or server mode based on command-line arguments
+ */
 async function main() {
-    const methodLogger = logger_util_js_1.Logger.forContext('index.ts', 'main');
+    const mainLogger = logger_util_js_1.Logger.forContext('index.ts', 'main');
     // Load configuration
     config_util_js_1.config.load();
     // Log the DEBUG value to verify configuration loading
-    methodLogger.info(`DEBUG value: ${process.env.DEBUG}`);
-    methodLogger.info(`IPAPI_API_TOKEN value exists: ${Boolean(process.env.IPAPI_API_TOKEN)}`);
-    methodLogger.info(`Config DEBUG value: ${config_util_js_1.config.get('DEBUG')}`);
+    mainLogger.debug(`DEBUG environment variable: ${process.env.DEBUG}`);
+    mainLogger.debug(`IPAPI_API_TOKEN value exists: ${Boolean(process.env.IPAPI_API_TOKEN)}`);
+    mainLogger.debug(`Config DEBUG value: ${config_util_js_1.config.get('DEBUG')}`);
     // Check if arguments are provided (CLI mode)
     if (process.argv.length > 2) {
         // CLI mode: Pass arguments to CLI runner
-        methodLogger.info('Starting in CLI mode');
+        mainLogger.info('Starting in CLI mode');
         await (0, index_js_1.runCli)(process.argv.slice(2));
-        methodLogger.info('CLI execution completed');
+        mainLogger.info('CLI execution completed');
     }
     else {
         // MCP Server mode: Start server with default STDIO
-        methodLogger.info('Starting in server mode');
+        mainLogger.info('Starting in server mode');
         await startServer();
-        methodLogger.info('Server is now running');
+        mainLogger.info('Server is now running');
     }
 }
 // If this file is being executed directly (not imported), run the main function
@@ -86,3 +113,6 @@ if (require.main === module) {
         process.exit(1);
     });
 }
+var constants_util_js_2 = require("./utils/constants.util.js");
+Object.defineProperty(exports, "VERSION", { enumerable: true, get: function () { return constants_util_js_2.VERSION; } });
+Object.defineProperty(exports, "PACKAGE_NAME", { enumerable: true, get: function () { return constants_util_js_2.PACKAGE_NAME; } });

package/dist/services/vendor.ip-api.com.service.d.ts

@@ -1,10 +1,27 @@
 import { IPDetail, IPApiRequestOptions } from './vendor.ip-api.com.types.js';
 /**
- * Get details for an IP address
- * @param ipAddress Optional IP address to lookup (omit for current IP)
- * @param options Optional request options
- * @returns Promise containing the IP details
- * @throws {McpError} If the request fails or the API returns an error
+ * @namespace VendorIpApiService
+ * @description Service layer for interacting directly with the ip-api.com vendor API.
+ *              Responsible for constructing API requests based on provided parameters
+ *              and handling the raw response from the `fetchIpApi` utility.
+ */
+/**
+ * @function get
+ * @description Fetches details for a specific IP address or the current device's IP from ip-api.com.
+ *              It uses the `fetchIpApi` utility and handles the specific success/failure status returned by ip-api.com.
+ * @memberof VendorIpApiService
+ * @param {string} [ipAddress] - Optional IP address to look up. If omitted, fetches details for the current device's public IP.
+ * @param {IPApiRequestOptions} [options={}] - Optional request options for the ip-api.com service, such as `useHttps`, `fields`, and `lang`.
+ * @returns {Promise<IPDetail>} A promise that resolves to the detailed IP information if the API call is successful.
+ * @throws {McpError} Throws an `McpError` (specifically `ApiError` or `UnexpectedError`) if:
+ *  - The `fetchIpApi` call fails (network error, non-2xx response).
+ *  - The ip-api.com response status is not 'success'.
+ *  - An unexpected error occurs during processing.
+ * @example
+ * // Get basic details for 8.8.8.8
+ * const details = await get('8.8.8.8');
+ * // Get extended details using HTTPS
+ * const extendedDetails = await get('1.1.1.1', { useHttps: true, fields: [...] });
  */
 declare function get(ipAddress?: string, options?: IPApiRequestOptions): Promise<IPDetail>;
 declare const _default: {

package/dist/services/vendor.ip-api.com.service.js

@@ -8,11 +8,28 @@ const serviceLogger = logger_util_js_1.Logger.forContext('services/vendor.ip-api
 // Log service initialization
 serviceLogger.debug('IP API service initialized');
 /**
- * Get details for an IP address
- * @param ipAddress Optional IP address to lookup (omit for current IP)
- * @param options Optional request options
- * @returns Promise containing the IP details
- * @throws {McpError} If the request fails or the API returns an error
+ * @namespace VendorIpApiService
+ * @description Service layer for interacting directly with the ip-api.com vendor API.
+ *              Responsible for constructing API requests based on provided parameters
+ *              and handling the raw response from the `fetchIpApi` utility.
+ */
+/**
+ * @function get
+ * @description Fetches details for a specific IP address or the current device's IP from ip-api.com.
+ *              It uses the `fetchIpApi` utility and handles the specific success/failure status returned by ip-api.com.
+ * @memberof VendorIpApiService
+ * @param {string} [ipAddress] - Optional IP address to look up. If omitted, fetches details for the current device's public IP.
+ * @param {IPApiRequestOptions} [options={}] - Optional request options for the ip-api.com service, such as `useHttps`, `fields`, and `lang`.
+ * @returns {Promise<IPDetail>} A promise that resolves to the detailed IP information if the API call is successful.
+ * @throws {McpError} Throws an `McpError` (specifically `ApiError` or `UnexpectedError`) if:
+ *  - The `fetchIpApi` call fails (network error, non-2xx response).
+ *  - The ip-api.com response status is not 'success'.
+ *  - An unexpected error occurs during processing.
+ * @example
+ * // Get basic details for 8.8.8.8
+ * const details = await get('8.8.8.8');
+ * // Get extended details using HTTPS
+ * const extendedDetails = await get('1.1.1.1', { useHttps: true, fields: [...] });
  */
 async function get(ipAddress, options = {}) {
     const methodLogger = logger_util_js_1.Logger.forContext('services/vendor.ip-api.com.service.ts', 'get');

package/dist/tools/ipaddress.tool.d.ts

@@ -1,6 +1,9 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 /**
- * Register IP address tools with the MCP server
+ * @function register
+ * @description Registers the IP address lookup tool ('get-ip-details') with the MCP server.
+ *
+ * @param {McpServer} server - The MCP server instance.
  */
 declare function register(server: McpServer): void;
 declare const _default: {

package/dist/tools/ipaddress.tool.js

@@ -8,8 +8,14 @@ const ipaddress_types_js_1 = require("./ipaddress.types.js");
 const error_util_js_1 = require("../utils/error.util.js");
 const ipaddress_controller_js_1 = __importDefault(require("../controllers/ipaddress.controller.js"));
 /**
- * Get IP Address details using the controller.
- * Maps tool arguments to controller options and formats the response.
+ * @function getIpAddressDetails
+ * @description MCP Tool handler to retrieve details for a given IP address (or the current IP).
+ *              It calls the ipAddressController to fetch the data and formats the response for the MCP.
+ *
+ * @param {IpAddressToolArgsType} args - Arguments provided to the tool, including the optional IP address and options.
+ * @param {RequestHandlerExtra} _extra - Additional request context (unused).
+ * @returns {Promise<{ content: Array<{ type: 'text', text: string }> }>} Formatted response for the MCP.
+ * @throws {McpError} Formatted error if the controller or service layer encounters an issue.
  */
 async function getIpAddressDetails(args, _extra) {
     const methodLogger = logger_util_js_1.Logger.forContext('tools/ipaddress.tool.ts', 'getIpAddressDetails');
@@ -39,14 +45,18 @@ async function getIpAddressDetails(args, _extra) {
     }
 }
 /**
- * Register IP address tools with the MCP server
+ * @function register
+ * @description Registers the IP address lookup tool ('get-ip-details') with the MCP server.
+ *
+ * @param {McpServer} server - The MCP server instance.
  */
 function register(server) {
     const methodLogger = logger_util_js_1.Logger.forContext('tools/ipaddress.tool.ts', 'register');
     methodLogger.debug(`Registering IP address tools...`);
     server.tool('get-ip-details', `Get details about a specific IP address or the current device's public IP address.
 
-            PURPOSE: Retrieves geolocation information (country, city, region, coordinates), ISP, and organization details associated with an IP address. Provides network and geographical context for an IP, which is useful for security analysis, debugging, or location verification.
+            PURPOSE:
+            Retrieves geolocation information (country, city, region, coordinates), ISP, and organization details associated with an IP address. Provides network and geographical context for an IP, which is useful for security analysis, debugging, or location verification.
 
             WHEN TO USE:
             - To find the geographical location of a given IP address (country, region, city, coordinates).
@@ -57,34 +67,33 @@ function register(server) {
             - When investigating suspicious IP addresses in logs.
 
             WHEN NOT TO USE:
-            - For internal/private IP addresses (10.x.x.x, 192.168.x.x, etc.) as this tool queries a public database.
+            - For internal/private IP addresses (e.g., 10.x.x.x, 192.168.x.x) as this tool queries a public database.
             - When you need historical IP data (this provides current lookup only).
-            - For precise geolocation (IP geolocation has limited accuracy, especially in rural areas).
+            - For precise geolocation (IP geolocation accuracy is limited).
             - For operations other than retrieving IP geolocation details.
-            - When you need to process large batches of IPs (use appropriate rate limiting).
+            - When processing large batches of IPs without considering rate limits.
 
-            RETURNS: Formatted Markdown containing:
+            RETURNS:
+            Formatted Markdown containing:
             - Location information (country, region, city, postal code, coordinates)
-            - Network details (ISP, organization, AS number)
-            - A link to view the location on a map
-            - Timestamp of when the information was retrieved
-
-            With extended data (when includeExtendedData=true), additional information may include:
-            - Mobile network detection
-            - Proxy/VPN detection
-            - Hosting provider detection
-            - Reverse DNS information
+            - Network details (ISP, organization, AS number/name)
+            - A link to view the location on a map.
+            - Timestamp of when the information was retrieved.
+            - With 'includeExtendedData=true', additional details like reverse DNS, mobile/proxy/hosting detection may be included.
 
             EXAMPLES:
             - Get details for a specific IP: { ipAddress: "8.8.8.8" }
-            - Get details with extended data: { ipAddress: "8.8.8.8", includeExtendedData: true }
-            - Get details for current device with HTTPS: { useHttps: true }
+            - Get details with extended data: { ipAddress: "1.1.1.1", includeExtendedData: true }
+            - Get details for current device using HTTPS: { useHttps: true }
             - Get basic details for current device: {}
 
             ERRORS:
-            - Invalid IP format: If the provided 'ipAddress' is not a valid IP address format.
-            - Private/Reserved IP: If the IP address is in a private or reserved range.
-            - API errors: If the external ip-api.com service fails or rejects the request.
-            - Rate limiting: If too many requests are made in a short period.`, ipaddress_types_js_1.IpAddressToolArgs.shape, getIpAddressDetails);
+            - Invalid IP format: If 'ipAddress' is not a valid IPv4 or IPv6 format.
+            - Private/Reserved IP: If the IP address is in a private or reserved range (per ip-api.com rules).
+            - API errors: If the external ip-api.com service fails, rejects the request (e.g., bad token), or returns an error status.
+            - Rate limiting: If the ip-api.com service rate limits the request.
+            - Network errors: If the request to ip-api.com fails due to network issues.`, // Keep Zod schema reference
+    ipaddress_types_js_1.IpAddressToolArgs.shape, getIpAddressDetails);
+    methodLogger.debug('Successfully registered get-ip-details tool.');
 }
 exports.default = { register };

package/dist/utils/constants.util.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Application constants
+ *
+ * This file contains constants used throughout the application.
+ * Centralizing these values makes them easier to maintain and update.
+ */
+/**
+ * Current application version
+ * This should match the version in package.json
+ */
+export declare const VERSION = "1.2.0";
+/**
+ * Package name with scope
+ * Used for initialization and identification
+ */
+export declare const PACKAGE_NAME = "@aashari/boilerplate-mcp-server";
+/**
+ * CLI command name
+ * Used for binary name and CLI help text
+ */
+export declare const CLI_NAME = "mcp-boilerplate";

package/dist/utils/constants.util.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * Application constants
+ *
+ * This file contains constants used throughout the application.
+ * Centralizing these values makes them easier to maintain and update.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLI_NAME = exports.PACKAGE_NAME = exports.VERSION = void 0;
+/**
+ * Current application version
+ * This should match the version in package.json
+ */
+exports.VERSION = '1.2.0';
+/**
+ * Package name with scope
+ * Used for initialization and identification
+ */
+exports.PACKAGE_NAME = '@aashari/boilerplate-mcp-server';
+/**
+ * CLI command name
+ * Used for binary name and CLI help text
+ */
+exports.CLI_NAME = 'mcp-boilerplate';

package/dist/utils/constants.util.js.bak

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * Application constants
+ *
+ * This file contains constants used throughout the application.
+ * Centralizing these values makes them easier to maintain and update.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLI_NAME = exports.PACKAGE_NAME = exports.VERSION = void 0;
+/**
+ * Current application version
+ * This should match the version in package.json
+ */
+exports.VERSION = '1.1.3';
+/**
+ * Package name with scope
+ * Used for initialization and identification
+ */
+exports.PACKAGE_NAME = '@aashari/boilerplate-mcp-server';
+/**
+ * CLI command name
+ * Used for binary name and CLI help text
+ */
+exports.CLI_NAME = 'mcp-boilerplate';

package/dist/utils/transport.util.d.ts

@@ -1,8 +1,9 @@
 /**
- * Interface for IP API credentials
+ * Interface for IP API credentials.
+ * Note: API token is optional for the free tier.
  */
 export interface IpApiCredentials {
-    apiToken: string | undefined;
+    apiToken?: string;
 }
 /**
  * Interface for HTTP request options
@@ -13,16 +14,23 @@ export interface RequestOptions {
     body?: unknown;
 }
 /**
- * Get IP API credentials from environment variables
- * @returns IpApiCredentials object containing the API token (which may be undefined if not set)
+ * Retrieves IP API credentials from configuration.
+ * Specifically checks for IPAPI_API_TOKEN.
+ * @returns IpApiCredentials object containing the API token if found.
  */
 export declare function getIpApiCredentials(): IpApiCredentials;
 /**
- * Fetch data from IP API
- * @param path The path/IP address to fetch data for
- * @param options Request options (method, headers, body, useHttps, fields, lang)
- * @returns Response data as type T
- * @throws {McpError} If the fetch fails or the response is not ok
+ * Fetches data specifically from the ip-api.com endpoint.
+ * Handles URL construction, authentication (if token provided), and query parameters.
+ * Relies on the generic fetchApi function for the actual HTTP request.
+ *
+ * @param path The specific IP address or path component (e.g., "8.8.8.8"). Empty string for current IP.
+ * @param options Additional options like HTTP method, headers, body, and ip-api specific params.
+ * @param options.useHttps - Use HTTPS (requires paid plan for ip-api.com). Defaults to false.
+ * @param options.fields - Specific fields to request from ip-api.com.
+ * @param options.lang - Language code for response data.
+ * @returns The response data parsed as type T.
+ * @throws {McpError} If the request fails, including network errors, API errors, or parsing issues.
  */
 export declare function fetchIpApi<T>(path: string, options?: RequestOptions & {
     useHttps?: boolean;
@@ -30,11 +38,12 @@ export declare function fetchIpApi<T>(path: string, options?: RequestOptions & {
     lang?: string;
 }): Promise<T>;
 /**
- * Generic function to fetch data from an API endpoint.
- * Handles basic HTTP error checking and logging.
+ * Generic and reusable function to fetch data from any API endpoint.
+ * Handles standard HTTP request setup, response checking, basic error handling, and logging.
+ *
  * @param url The full URL to fetch data from.
- * @param options Request options (method, headers, body).
- * @returns Response data as type T.
- * @throws {McpError} If the fetch fails or the response is not ok.
+ * @param options Request options including method, headers, and body.
+ * @returns The response data parsed as type T.
+ * @throws {McpError} If the request fails, including network errors, non-OK HTTP status, or JSON parsing issues.
  */
 export declare function fetchApi<T>(url: string, options?: RequestOptions): Promise<T>;

package/dist/utils/transport.util.js

@@ -11,64 +11,69 @@ const transportLogger = logger_util_js_1.Logger.forContext('utils/transport.util
 // Log transport utility initialization
 transportLogger.debug('Transport utility initialized');
 /**
- * Get IP API credentials from environment variables
- * @returns IpApiCredentials object containing the API token (which may be undefined if not set)
+ * Retrieves IP API credentials from configuration.
+ * Specifically checks for IPAPI_API_TOKEN.
+ * @returns IpApiCredentials object containing the API token if found.
  */
 function getIpApiCredentials() {
     const methodLogger = logger_util_js_1.Logger.forContext('utils/transport.util.ts', 'getIpApiCredentials');
     const apiToken = config_util_js_1.config.get('IPAPI_API_TOKEN');
     if (!apiToken) {
-        methodLogger.debug('No IP API token found. The API will be used in free tier mode.');
+        methodLogger.debug('No IP API token found (IPAPI_API_TOKEN). Using free tier.');
+        return {}; // Return empty object if no token
     }
     else {
-        methodLogger.debug('Using IP API token from configuration');
+        methodLogger.debug('Using IP API token from configuration.');
+        return { apiToken };
     }
-    return {
-        apiToken,
-    };
 }
 /**
- * Fetch data from IP API
- * @param path The path/IP address to fetch data for
- * @param options Request options (method, headers, body, useHttps, fields, lang)
- * @returns Response data as type T
- * @throws {McpError} If the fetch fails or the response is not ok
+ * Fetches data specifically from the ip-api.com endpoint.
+ * Handles URL construction, authentication (if token provided), and query parameters.
+ * Relies on the generic fetchApi function for the actual HTTP request.
+ *
+ * @param path The specific IP address or path component (e.g., "8.8.8.8"). Empty string for current IP.
+ * @param options Additional options like HTTP method, headers, body, and ip-api specific params.
+ * @param options.useHttps - Use HTTPS (requires paid plan for ip-api.com). Defaults to false.
+ * @param options.fields - Specific fields to request from ip-api.com.
+ * @param options.lang - Language code for response data.
+ * @returns The response data parsed as type T.
+ * @throws {McpError} If the request fails, including network errors, API errors, or parsing issues.
  */
 async function fetchIpApi(path, options = {}) {
     const methodLogger = logger_util_js_1.Logger.forContext('utils/transport.util.ts', 'fetchIpApi');
-    // Get credentials
+    // Get credentials (token might be undefined)
     const credentials = getIpApiCredentials();
-    // Construct the full URL
-    // Use https if explicitly requested
+    // Determine protocol based on options
     const protocol = options.useHttps ? 'https' : 'http';
     const baseUrl = `${protocol}://ip-api.com/json`;
-    // Ensure path is formatted correctly
+    // Format path for URL
     const normalizedPath = path ? `/${path}` : '';
     let url = `${baseUrl}${normalizedPath}`;
-    // Prepare query parameters
+    // Build query parameters
     const queryParams = new URLSearchParams();
-    // Add API token if available
+    // Add API token if present
     if (credentials.apiToken) {
         queryParams.set('key', credentials.apiToken);
-        methodLogger.debug('Added API token to request');
+        methodLogger.debug('API token added to query parameters.');
     }
-    // Add fields if specified
-    if (options.fields && options.fields.length > 0) {
+    // Add fields parameter
+    if (options.fields?.length) {
         queryParams.set('fields', options.fields.join(','));
-        methodLogger.debug(`Set fields to: ${options.fields.join(',')}`);
+        methodLogger.debug(`Requesting fields: ${options.fields.join(',')}`);
     }
-    // Add language if specified
+    // Add language parameter
     if (options.lang) {
         queryParams.set('lang', options.lang);
-        methodLogger.debug(`Set language to: ${options.lang}`);
+        methodLogger.debug(`Requesting language: ${options.lang}`);
     }
-    // Append query parameters if any
+    // Append query string if needed
     const queryString = queryParams.toString();
     if (queryString) {
         url += `?${queryString}`;
     }
-    methodLogger.debug(`Calling IP API: ${url}`);
-    // Use the generic fetchApi function with the constructed URL
+    methodLogger.debug(`Constructed URL: ${url}`);
+    // Delegate the actual fetch call to the generic fetchApi
     return fetchApi(url, {
         method: options.method,
         headers: options.headers,
@@ -76,68 +81,83 @@ async function fetchIpApi(path, options = {}) {
     });
 }
 /**
- * Generic function to fetch data from an API endpoint.
- * Handles basic HTTP error checking and logging.
+ * Generic and reusable function to fetch data from any API endpoint.
+ * Handles standard HTTP request setup, response checking, basic error handling, and logging.
+ *
  * @param url The full URL to fetch data from.
- * @param options Request options (method, headers, body).
- * @returns Response data as type T.
- * @throws {McpError} If the fetch fails or the response is not ok.
+ * @param options Request options including method, headers, and body.
+ * @returns The response data parsed as type T.
+ * @throws {McpError} If the request fails, including network errors, non-OK HTTP status, or JSON parsing issues.
  */
 async function fetchApi(url, options = {}) {
     const methodLogger = logger_util_js_1.Logger.forContext('utils/transport.util.ts', 'fetchApi');
-    // Prepare request options
+    // Prepare standard request options
     const requestOptions = {
         method: options.method || 'GET',
         headers: {
+            // Standard headers, allow overrides via options.headers
             'Content-Type': 'application/json',
             Accept: 'application/json',
-            ...options.headers, // Allow overriding default headers
+            ...options.headers,
         },
         body: options.body ? JSON.stringify(options.body) : undefined,
     };
-    methodLogger.debug(`Calling API: ${requestOptions.method} ${url}`);
+    methodLogger.debug(`Executing API call: ${requestOptions.method} ${url}`);
+    const startTime = performance.now(); // Track performance
     try {
         const response = await fetch(url, requestOptions);
-        // Log the raw response status and headers
-        methodLogger.debug(`Raw response received: ${response.status} ${response.statusText}`, {
-            url,
-            status: response.status,
-            statusText: response.statusText,
-            headers: {
-                // Log simplified headers
-                contentType: response.headers.get('content-type'),
-                contentLength: response.headers.get('content-length'),
-            },
-        });
+        const endTime = performance.now();
+        const duration = (endTime - startTime).toFixed(2);
+        methodLogger.debug(`API call completed in ${duration}ms with status: ${response.status} ${response.statusText}`, { url, status: response.status });
+        // Check if the response status is OK (2xx)
         if (!response.ok) {
-            const errorText = await response.text();
-            methodLogger.error(`API error: ${response.status} ${response.statusText}`, errorText);
-            // Create a generic API error
-            throw (0, error_util_js_1.createApiError)(`API request failed: ${response.status} ${response.statusText}`, response.status, errorText);
+            const errorText = await response.text(); // Get error body for context
+            methodLogger.error(`API error response (${response.status}):`, errorText);
+            // Classify standard HTTP errors
+            if (response.status === 401) {
+                // Use createAuthInvalidError for consistency, even if ip-api uses keys
+                throw (0, error_util_js_1.createAuthInvalidError)('Authentication failed. Check API token if required.');
+            }
+            else if (response.status === 403) {
+                // Use createAuthInvalidError or a more specific permission error if needed
+                throw (0, error_util_js_1.createAuthInvalidError)('Permission denied for the requested resource.');
+            }
+            else if (response.status === 404) {
+                throw (0, error_util_js_1.createApiError)('Resource not found at the specified URL.', response.status, errorText);
+            }
+            else {
+                // Generic API error for other non-2xx statuses
+                throw (0, error_util_js_1.createApiError)(`API request failed with status ${response.status}: ${response.statusText}`, response.status, errorText);
+            }
+        }
+        // Attempt to parse the response body as JSON
+        try {
+            const responseData = await response.json();
+            methodLogger.debug('Response body successfully parsed as JSON.');
+            // methodLogger.debug('Response Data:', responseData); // Uncomment for full response logging
+            return responseData;
+        }
+        catch (parseError) {
+            methodLogger.error('Failed to parse API response JSON:', parseError);
+            // Throw a specific error for JSON parsing failure
+            throw (0, error_util_js_1.createApiError)(`Failed to parse API response JSON: ${parseError instanceof Error ? parseError.message : String(parseError)}`, response.status, // Include original status for context
+            parseError);
         }
-        // Attempt to parse JSON
-        const responseData = await response.json();
-        methodLogger.debug(`Response body parsed successfully.`);
-        // methodLogger.debug(`Response body:`, responseData); // Optionally log full body
-        return responseData;
     }
     catch (error) {
-        methodLogger.error(`Request failed for ${url}`, error);
-        // Rethrow known McpErrors (like the one from createApiError)
+        const endTime = performance.now();
+        const duration = (endTime - startTime).toFixed(2);
+        methodLogger.error(`API call failed after ${duration}ms for ${url}:`, error);
+        // Rethrow if it's already an McpError (e.g., from status checks or parsing)
         if (error instanceof error_util_js_1.McpError) {
             throw error;
         }
-        // Handle network or fetch-specific errors
+        // Handle potential network errors (TypeError in fetch)
         if (error instanceof TypeError) {
             throw (0, error_util_js_1.createApiError)(`Network error during API call: ${error.message}`, undefined, // No specific HTTP status for network errors
             error);
         }
-        // Handle JSON parsing errors
-        if (error instanceof SyntaxError) {
-            throw (0, error_util_js_1.createApiError)(`Failed to parse API response JSON: ${error.message}`, undefined, // No specific HTTP status for parsing errors
-            error);
-        }
-        // Wrap unknown errors
+        // Wrap any other unexpected errors
         throw (0, error_util_js_1.createUnexpectedError)(`Unexpected error during API call: ${error instanceof Error ? error.message : String(error)}`, error);
     }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@aashari/boilerplate-mcp-server",
-	"version": "1.1.2",
-	"description": "A TypeScript-based Model Context Protocol (MCP) server boilerplate for building AI-connected tools. Features IP lookup tools, CLI support, MCP Inspector integration, and extensible architecture for connecting Claude/Anthropic AI systems to external data sources.",
+	"version": "1.2.0",
+	"description": "TypeScript Model Context Protocol (MCP) server boilerplate providing IP lookup tools/resources. Includes CLI support and extensible structure for connecting AI systems (LLMs) to external data sources like ip-api.com. Ideal template for creating new MCP integrations via Node.js.",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"_moduleNotes": "Although source code uses ESM syntax, the build output target is CommonJS to align with Node.js compatibility and patterns seen in related MCP servers. tsconfig.json's 'module': 'NodeNext' handles the input syntax, while tsc outputs CJS.",

package/package.json.bak

@@ -1,7 +1,7 @@
 {
 	"name": "@aashari/boilerplate-mcp-server",
-	"version": "1.1.1",
-	"description": "A TypeScript-based Model Context Protocol (MCP) server boilerplate for building AI-connected tools. Features IP lookup tools, CLI support, MCP Inspector integration, and extensible architecture for connecting Claude/Anthropic AI systems to external data sources.",
+	"version": "1.1.3",
+	"description": "TypeScript Model Context Protocol (MCP) server boilerplate providing IP lookup tools/resources. Includes CLI support and extensible structure for connecting AI systems (LLMs) to external data sources like ip-api.com. Ideal template for creating new MCP integrations via Node.js.",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"_moduleNotes": "Although source code uses ESM syntax, the build output target is CommonJS to align with Node.js compatibility and patterns seen in related MCP servers. tsconfig.json's 'module': 'NodeNext' handles the input syntax, while tsc outputs CJS.",

package/scripts/update-version.js

@@ -45,28 +45,15 @@ const versionFiles = [
 			match.replace(currentVersion, newVersion),
 	},
 	{
-		path: path.join(rootDir, 'src', 'cli', 'index.ts'),
-		pattern: /const VERSION = ['"]([^'"]*)['"]/,
-		replacement: (match, currentVersion) =>
-			match.replace(currentVersion, newVersion),
-	},
-	{
-		path: path.join(rootDir, 'src', 'index.ts'),
-		pattern: /const VERSION = ['"]([^'"]*)['"]/,
+		path: path.join(rootDir, 'src', 'utils', 'constants.util.ts'),
+		pattern: /export const VERSION = ['"]([^'"]*)['"]/,
 		replacement: (match, currentVersion) =>
 			match.replace(currentVersion, newVersion),
 	},
 	// Also update the compiled JavaScript files if they exist
 	{
-		path: path.join(rootDir, 'dist', 'cli', 'index.js'),
-		pattern: /const VERSION = ['"]([^'"]*)['"]/,
-		replacement: (match, currentVersion) =>
-			match.replace(currentVersion, newVersion),
-		optional: true, // Mark this file as optional
-	},
-	{
-		path: path.join(rootDir, 'dist', 'index.js'),
-		pattern: /const VERSION = ['"]([^'"]*)['"]/,
+		path: path.join(rootDir, 'dist', 'utils', 'constants.util.js'),
+		pattern: /exports.VERSION = ['"]([^'"]*)['"]/,
 		replacement: (match, currentVersion) =>
 			match.replace(currentVersion, newVersion),
 		optional: true, // Mark this file as optional

package/dist/cli/index.js.bak

@@ -1,31 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runCli = runCli;
-const commander_1 = require("commander");
-const logger_util_js_1 = require("../utils/logger.util.js");
-const ipaddress_cli_js_1 = __importDefault(require("./ipaddress.cli.js"));
-// Get the version from package.json
-const VERSION = '1.1.1'; // This should match the version in src/index.ts
-const NAME = '@aashari/boilerplate-mcp-server';
-const DESCRIPTION = 'A boilerplate Model Context Protocol (MCP) server implementation using TypeScript';
-async function runCli(args) {
-    const methodLogger = logger_util_js_1.Logger.forContext('cli/index.ts', 'runCli');
-    methodLogger.debug('Processing CLI arguments', args);
-    const program = new commander_1.Command();
-    program.name(NAME).description(DESCRIPTION).version(VERSION);
-    // Register CLI commands
-    ipaddress_cli_js_1.default.register(program);
-    // Handle unknown commands
-    program.on('command:*', (operands) => {
-        methodLogger.error(`Unknown command: ${operands[0]}`);
-        console.log('');
-        program.help();
-        process.exit(1);
-    });
-    // Parse arguments; default to help if no command provided
-    await program.parseAsync(args.length ? args : ['--help'], { from: 'user' });
-    methodLogger.debug('CLI command execution completed');
-}

package/dist/index.js.bak

@@ -1,88 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Logger = exports.config = void 0;
-exports.startServer = startServer;
-const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
-const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
-const logger_util_js_1 = require("./utils/logger.util.js");
-Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return logger_util_js_1.Logger; } });
-const config_util_js_1 = require("./utils/config.util.js");
-Object.defineProperty(exports, "config", { enumerable: true, get: function () { return config_util_js_1.config; } });
-const error_util_js_1 = require("./utils/error.util.js");
-const index_js_1 = require("./cli/index.js");
-const ipaddress_tool_js_1 = __importDefault(require("./tools/ipaddress.tool.js"));
-const ipaddress_resource_js_1 = __importDefault(require("./resources/ipaddress.resource.js"));
-// Create file-level logger
-const indexLogger = logger_util_js_1.Logger.forContext('index.ts');
-// Define version constant for easier management and consistent versioning
-const VERSION = '1.1.1';
-let serverInstance = null;
-let transportInstance = null;
-async function startServer(mode = 'stdio') {
-    const methodLogger = logger_util_js_1.Logger.forContext('index.ts', 'startServer');
-    // Load configuration
-    config_util_js_1.config.load();
-    // Enable debug logging if DEBUG is set to true
-    if (config_util_js_1.config.getBoolean('DEBUG')) {
-        methodLogger.debug('Debug mode enabled');
-    }
-    // Log the DEBUG value to verify configuration loading
-    methodLogger.info(`DEBUG value: ${process.env.DEBUG}`);
-    methodLogger.info(`IPAPI_API_TOKEN value exists: ${Boolean(process.env.IPAPI_API_TOKEN)}`);
-    methodLogger.info(`Config DEBUG value: ${config_util_js_1.config.get('DEBUG')}`);
-    serverInstance = new mcp_js_1.McpServer({
-        name: '@aashari/boilerplate-mcp-server',
-        version: VERSION,
-    });
-    if (mode === 'stdio') {
-        transportInstance = new stdio_js_1.StdioServerTransport();
-    }
-    else {
-        throw (0, error_util_js_1.createUnexpectedError)('SSE mode is not supported yet');
-    }
-    methodLogger.info(`Starting server with ${mode.toUpperCase()} transport...`);
-    // register tools
-    ipaddress_tool_js_1.default.register(serverInstance);
-    methodLogger.debug('Registered IP address tools');
-    // register resources
-    ipaddress_resource_js_1.default.register(serverInstance);
-    methodLogger.debug('Registered IP lookup resources');
-    return serverInstance.connect(transportInstance).catch((err) => {
-        methodLogger.error(`Failed to start server`, err);
-        process.exit(1);
-    });
-}
-// Main entry point - this will run when executed directly
-async function main() {
-    const methodLogger = logger_util_js_1.Logger.forContext('index.ts', 'main');
-    // Load configuration
-    config_util_js_1.config.load();
-    // Log the DEBUG value to verify configuration loading
-    methodLogger.info(`DEBUG value: ${process.env.DEBUG}`);
-    methodLogger.info(`IPAPI_API_TOKEN value exists: ${Boolean(process.env.IPAPI_API_TOKEN)}`);
-    methodLogger.info(`Config DEBUG value: ${config_util_js_1.config.get('DEBUG')}`);
-    // Check if arguments are provided (CLI mode)
-    if (process.argv.length > 2) {
-        // CLI mode: Pass arguments to CLI runner
-        methodLogger.info('Starting in CLI mode');
-        await (0, index_js_1.runCli)(process.argv.slice(2));
-        methodLogger.info('CLI execution completed');
-    }
-    else {
-        // MCP Server mode: Start server with default STDIO
-        methodLogger.info('Starting in server mode');
-        await startServer();
-        methodLogger.info('Server is now running');
-    }
-}
-// If this file is being executed directly (not imported), run the main function
-if (require.main === module) {
-    main().catch((err) => {
-        indexLogger.error('Unhandled error in main process', err);
-        process.exit(1);
-    });
-}