mcp-ts-template 1.6.1 → 1.6.3

package/README.md

@@ -3,7 +3,7 @@
 [![TypeScript](https://img.shields.io/badge/TypeScript-^5.8.3-blue.svg)](https://www.typescriptlang.org/)
 [![Model Context Protocol SDK](https://img.shields.io/badge/MCP%20SDK-^1.13.0-green.svg)](https://github.com/modelcontextprotocol/typescript-sdk)
 [![MCP Spec Version](https://img.shields.io/badge/MCP%20Spec-2025--03--26-lightgrey.svg)](https://github.com/modelcontextprotocol/modelcontextprotocol/blob/main/docs/specification/2025-03-26/changelog.mdx)
-[![Version](https://img.shields.io/badge/Version-1.6.1-blue.svg)](./CHANGELOG.md)
+[![Version](https://img.shields.io/badge/Version-1.6.2-blue.svg)](./CHANGELOG.md)
 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 [![Status](https://img.shields.io/badge/Status-Stable-green.svg)](https://github.com/cyanheads/mcp-ts-template/issues)
 [![GitHub](https://img.shields.io/github/stars/cyanheads/mcp-ts-template?style=social)](https://github.com/cyanheads/mcp-ts-template)

package/dist/agent/agent-core/agent.js

@@ -177,7 +177,6 @@ Begin the task. Your response must be only the JSON object.`;
                 { role: "system", content: systemPrompt },
                 { role: "user", content: initialPrompt },
             ];
-            // eslint-disable-next-line no-constant-condition
             while (true) {
                 const llmParams = {
                     messages,
@@ -191,7 +190,7 @@ Begin the task. Your response must be only the JSON object.`;
                 try {
                     commandJson = jsonParser.parse(llmResponse);
                 }
-                catch (e) {
+                catch (_e) {
                     logger.warning("LLM response was not valid JSON. Treating as a conversational message.", { ...runContext, llmResponse });
                     if (onStreamChunk) {
                         onStreamChunk(`\n[AGENT_NOTE]: The AI responded with conversational text instead of a command. I will remind it of the protocol.\n[AI]: ${llmResponse}\n`);
@@ -205,6 +204,9 @@ Begin the task. Your response must be only the JSON object.`;
                 const { command, arguments: args } = commandJson;
                 if (command === "mcp_tool_call") {
                     const toolResult = await this._executeToolCall(args, runContext);
+                    if (typeof args.name !== "string") {
+                        throw new McpError(BaseErrorCode.VALIDATION_ERROR, "Tool call name is missing or not a string.", runContext);
+                    }
                     const toolMessage = {
                         role: "tool",
                         tool_call_id: args.name,
@@ -315,6 +317,10 @@ Begin the task. Your response must be only the JSON object.`;
                 args,
             });
             const client = await this.mcpClientManager.connectMcpClient(serverName, context);
+            if (args !== undefined &&
+                (typeof args !== "object" || args === null || Array.isArray(args))) {
+                throw new McpError(BaseErrorCode.VALIDATION_ERROR, `Tool arguments for '${toolName}' must be a plain object or undefined.`, context);
+            }
             const toolResult = await client.callTool({
                 name: toolName,
                 arguments: args,

package/dist/config/index.js

@@ -49,7 +49,8 @@ try {
     projectRoot = findProjectRoot(currentModuleDir);
 }
 catch (error) {
-    console.error(`FATAL: Error determining project root: ${error.message}`);
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`FATAL: Error determining project root: ${errorMessage}`);
     // Fallback to process.cwd() if project root cannot be determined.
     // This might happen in unusual execution environments.
     projectRoot = process.cwd();
@@ -215,7 +216,8 @@ const ensureDirectory = (dirPath, rootDir, dirName) => {
         }
         catch (statError) {
             if (process.stdout.isTTY) {
-                console.error(`Error accessing ${dirName} path ${resolvedDirPath}: ${statError.message}`);
+                const statErrorMessage = statError instanceof Error ? statError.message : String(statError);
+                console.error(`Error accessing ${dirName} path ${resolvedDirPath}: ${statErrorMessage}`);
             }
             return null;
         }

package/dist/index.js

@@ -178,7 +178,7 @@ const start = async () => {
             logger.error("FATAL: Uncaught exception detected. This indicates a bug or unexpected state. Initiating shutdown...", errorContext);
             await shutdown("uncaughtException");
         });
-        process.on("unhandledRejection", async (reason, promise) => {
+        process.on("unhandledRejection", async (reason, _promise) => {
             const rejectionContext = {
                 ...startupContext,
                 triggerEvent: "unhandledRejection",

package/dist/mcp-client/core/clientConnectionLogic.js

@@ -68,8 +68,16 @@ export async function establishNewMcpConnection(serverName, operationContext, di
     // These handlers are crucial for reacting to errors and closures.
     // They will call the main disconnectMcpClient from clientManager.ts for cleanup.
     client.onerror = (clientError) => {
-        const errorCode = clientError.code;
-        const errorData = clientError.data;
+        const errorCode = typeof clientError === "object" &&
+            clientError !== null &&
+            "code" in clientError
+            ? clientError.code
+            : "UNKNOWN";
+        const errorData = typeof clientError === "object" &&
+            clientError !== null &&
+            "data" in clientError
+            ? clientError.data
+            : undefined;
         logger.error(`MCP SDK Client error for server ${serverName}`, {
             ...operationContext,
             error: clientError.message,

package/dist/mcp-client/core/clientManager.d.ts

@@ -59,7 +59,7 @@ export declare class McpClientManager {
      * @param parentContext - The context of the calling operation.
      * @returns A promise that resolves to a map where keys are tool names and values are their definitions.
      */
-    getAllTools(parentContext?: RequestContext | null): Promise<Map<string, any>>;
+    getAllTools(parentContext?: RequestContext | null): Promise<Map<string, unknown>>;
     /**
      * Finds the server name for a given tool from the cached tool map.
      * This is a synchronous method and relies on `getAllTools` having been called first.
@@ -67,5 +67,5 @@ export declare class McpClientManager {
      * @param allTools - The map of all available tools.
      * @returns The server name, or null if the tool is not found.
      */
-    getServerForTool(toolName: string, allTools: Map<string, any>): string | null;
+    getServerForTool(toolName: string, allTools: Map<string, unknown>): string | null;
 }

package/dist/mcp-client/core/clientManager.js

@@ -166,11 +166,18 @@ export class McpClientManager {
         const toolPromises = Array.from(this.connectedClients.entries()).map(async ([serverName, client]) => {
             try {
                 const result = await client.listTools();
-                const tools = result?.tools;
+                const tools = result && typeof result === "object" && "tools" in result
+                    ? result.tools
+                    : [];
                 if (Array.isArray(tools)) {
                     logger.debug(`Successfully fetched ${tools.length} tools from server: ${serverName}`, { ...context, serverName });
                     for (const tool of tools) {
-                        allTools.set(tool.name, { ...tool, server: serverName });
+                        if (tool && typeof tool === "object" && "name" in tool) {
+                            allTools.set(tool.name, {
+                                ...tool,
+                                server: serverName,
+                            });
+                        }
                     }
                 }
                 else {
@@ -198,6 +205,9 @@ export class McpClientManager {
      */
     getServerForTool(toolName, allTools) {
         const tool = allTools.get(toolName);
-        return tool?.server || null;
+        if (tool && typeof tool === "object" && "server" in tool) {
+            return tool.server;
+        }
+        return null;
     }
 }

package/dist/mcp-server/tools/imageTest/registration.js

@@ -18,8 +18,13 @@ export function registerFetchImageTestTool(server) {
     });
     ErrorHandler.tryCatch(async () => {
         server.tool(toolName, toolDescription, FetchImageTestInputSchema.shape, async (input, mcpProvidedContext) => {
+            const parentRequestId = mcpProvidedContext &&
+                typeof mcpProvidedContext === "object" &&
+                "requestId" in mcpProvidedContext
+                ? mcpProvidedContext.requestId
+                : registrationContext.requestId;
             const handlerContext = requestContextService.createRequestContext({
-                parentRequestId: mcpProvidedContext?.requestId || registrationContext.requestId,
+                parentRequestId,
                 operation: "fetchImageTestToolHandler",
                 toolName: toolName,
                 input,

package/dist/mcp-server/transports/httpTransport.js

@@ -25,7 +25,7 @@ import { randomUUID } from "node:crypto";
 import { config } from "../../config/index.js";
 import { BaseErrorCode, McpError } from "../../types-global/errors.js";
 import { logger, rateLimiter, requestContextService, } from "../../utils/index.js";
-import { jwtAuthMiddleware, oauthMiddleware, } from "./auth/index.js";
+import { jwtAuthMiddleware, oauthMiddleware } from "./auth/index.js";
 import { httpErrorHandler } from "./httpErrorHandler.js";
 const HTTP_PORT = config.mcpHttpPort;
 const HTTP_HOST = config.mcpHttpHost;
@@ -37,13 +37,7 @@ const MAX_PORT_RETRIES = 15;
 // For a scalable deployment, this would need to be replaced with a distributed
 // store like Redis or Memcached.
 const transports = {};
-async function isPortInUse(port, host, parentContext) {
-    const checkContext = requestContextService.createRequestContext({
-        ...parentContext,
-        operation: "isPortInUse",
-        port,
-        host,
-    });
+async function isPortInUse(port, host, _parentContext) {
     return new Promise((resolve) => {
         const tempServer = http.createServer();
         tempServer
@@ -61,40 +55,48 @@ function startHttpServerWithRetry(app, initialPort, host, maxRetries, parentCont
         ...parentContext,
         operation: "startHttpServerWithRetry",
     });
-    return new Promise(async (resolve, reject) => {
-        for (let i = 0; i <= maxRetries; i++) {
-            const currentPort = initialPort + i;
-            const attemptContext = {
-                ...startContext,
-                port: currentPort,
-                attempt: i + 1,
-            };
-            if (await isPortInUse(currentPort, host, attemptContext)) {
-                logger.warning(`Port ${currentPort} is in use, retrying...`, attemptContext);
-                continue;
-            }
-            try {
-                const serverInstance = serve({ fetch: app.fetch, port: currentPort, hostname: host }, (info) => {
-                    const serverAddress = `http://${info.address}:${info.port}${MCP_ENDPOINT_PATH}`;
-                    logger.info(`HTTP transport listening at ${serverAddress}`, {
-                        ...attemptContext,
-                        address: serverAddress,
-                    });
-                    if (process.stdout.isTTY) {
-                        console.log(`\n🚀 MCP Server running at: ${serverAddress}\n`);
-                    }
-                });
-                resolve(serverInstance);
+    return new Promise((resolve, reject) => {
+        const tryBind = (port, attempt) => {
+            if (attempt > maxRetries + 1) {
+                reject(new Error("Failed to bind to any port after multiple retries."));
                 return;
             }
-            catch (err) {
-                if (err.code !== "EADDRINUSE") {
-                    reject(err);
+            const attemptContext = { ...startContext, port, attempt };
+            isPortInUse(port, host, attemptContext)
+                .then((inUse) => {
+                if (inUse) {
+                    logger.warning(`Port ${port} is in use, retrying...`, attemptContext);
+                    setTimeout(() => tryBind(port + 1, attempt + 1), 50); // Small delay
                     return;
                 }
-            }
-        }
-        reject(new Error("Failed to bind to any port after multiple retries."));
+                try {
+                    const serverInstance = serve({ fetch: app.fetch, port, hostname: host }, (info) => {
+                        const serverAddress = `http://${info.address}:${info.port}${MCP_ENDPOINT_PATH}`;
+                        logger.info(`HTTP transport listening at ${serverAddress}`, {
+                            ...attemptContext,
+                            address: serverAddress,
+                        });
+                        if (process.stdout.isTTY) {
+                            console.log(`\n🚀 MCP Server running at: ${serverAddress}\n`);
+                        }
+                    });
+                    resolve(serverInstance);
+                }
+                catch (err) {
+                    if (err &&
+                        typeof err === "object" &&
+                        "code" in err &&
+                        err.code !== "EADDRINUSE") {
+                        reject(err);
+                    }
+                    else {
+                        setTimeout(() => tryBind(port + 1, attempt + 1), 50);
+                    }
+                }
+            })
+                .catch((err) => reject(err));
+        };
+        tryBind(initialPort, 1);
     });
 }
 export async function startHttpTransport(createServerInstanceFn, parentContext) {

package/dist/services/duck-db/duckDBQueryExecutor.d.ts

@@ -7,9 +7,9 @@ import { DuckDBQueryResult } from "./types.js";
 export declare class DuckDBQueryExecutor {
     private dbConnection;
     constructor(connection: duckdb.DuckDBConnection);
-    run(sql: string, params?: duckdb.DuckDBValue[] | Record<string, duckdb.DuckDBValue>): Promise<void>;
-    query<T = Record<string, unknown>>(sql: string, params?: duckdb.DuckDBValue[] | Record<string, duckdb.DuckDBValue>): Promise<DuckDBQueryResult<T>>;
-    stream(sql: string, params?: duckdb.DuckDBValue[] | Record<string, duckdb.DuckDBValue>): Promise<duckdb.DuckDBPendingResult>;
+    run(sql: string, params?: duckdb.DuckDBValue[]): Promise<void>;
+    query<T = Record<string, unknown>>(sql: string, params?: duckdb.DuckDBValue[]): Promise<DuckDBQueryResult<T>>;
+    stream(sql: string, params?: duckdb.DuckDBValue[]): Promise<duckdb.DuckDBResult>;
     prepare(sql: string): Promise<duckdb.DuckDBPreparedStatement>;
     beginTransaction(): Promise<void>;
     commitTransaction(): Promise<void>;

package/dist/services/duck-db/duckDBQueryExecutor.js

@@ -18,11 +18,8 @@ export class DuckDBQueryExecutor {
             if (params === undefined) {
                 await this.dbConnection.run(sql);
             }
-            else if (Array.isArray(params)) {
-                await this.dbConnection.run(sql, params); // Pass array directly
-            }
             else {
-                await this.dbConnection.run(sql, params); // Cast to any for object
+                await this.dbConnection.run(sql, params);
             }
         }, {
             operation: "DuckDBQueryExecutor.run",
@@ -38,32 +35,11 @@ export class DuckDBQueryExecutor {
         });
         return ErrorHandler.tryCatch(async () => {
             logger.debug(`Executing SQL (query): ${sql}`, { ...context, params });
-            let resultObject; // Corresponds to 'result' in docs after connection.stream()
-            if (params === undefined) {
-                resultObject = await this.dbConnection.stream(sql);
-            }
-            else if (Array.isArray(params)) {
-                resultObject = await this.dbConnection.stream(sql, 
-                // According to docs, params for stream are passed as subsequent arguments
-                // However, the DuckDBConnection type definition might expect a single array/object.
-                // The original code passed `params` directly, which is typical for many drivers
-                // if the method signature is `stream(sql: string, params?: any[])`
-                // Let's stick to the original way params were passed to stream, as the docs
-                // show `connection.stream(sql, values, types)` where values could be an array/object.
-                // The most robust way for array params is often `stream(sql, ...params_array)`.
-                // Let's assume the type defs are `stream(sql: string, ...args: any[])` for array params.
-                // Or `stream(sql: string, namedParams: object)` for named.
-                // The previous code `params` directly for array, and `params as any` for object.
-                // This seems reasonable.
-                params);
-            }
-            else {
-                resultObject = await this.dbConnection.stream(sql, params); // Cast to any for object
-            }
-            const rows = (await resultObject.getRows()); // Use getRows() as per docs, and it's async
-            const columnNames = resultObject.columnNames(); // Sync as per docs
+            const resultObject = await this.stream(sql, params);
+            const rows = (await resultObject.getRows());
+            const columnNames = resultObject.columnNames();
             const columnTypes = resultObject
-                .columnTypes() // Sync as per docs
+                .columnTypes()
                 .map((ct) => ct.typeId);
             return {
                 rows: rows,
@@ -88,9 +64,6 @@ export class DuckDBQueryExecutor {
             if (params === undefined) {
                 return this.dbConnection.stream(sql);
             }
-            else if (Array.isArray(params)) {
-                return this.dbConnection.stream(sql, params);
-            }
             else {
                 return this.dbConnection.stream(sql, params);
             }

package/dist/services/duck-db/duckDBService.d.ts

@@ -11,9 +11,10 @@ export declare class DuckDBService implements IDuckDBService {
     constructor();
     initialize(config?: DuckDBServiceConfig): Promise<void>;
     private ensureInitialized;
-    run(sql: string, params?: unknown[] | Record<string, unknown>): Promise<void>;
-    query<T = Record<string, unknown>>(sql: string, params?: unknown[] | Record<string, unknown>): Promise<DuckDBQueryResult<T>>;
-    stream(sql: string, params?: unknown[] | Record<string, unknown>): Promise<duckdb.DuckDBPendingResult>;
+    private validateParams;
+    run(sql: string, params?: unknown[]): Promise<void>;
+    query<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<DuckDBQueryResult<T>>;
+    stream(sql: string, params?: unknown[]): Promise<duckdb.DuckDBResult>;
     prepare(sql: string): Promise<duckdb.DuckDBPreparedStatement>;
     beginTransaction(): Promise<void>;
     commitTransaction(): Promise<void>;

package/dist/services/duck-db/duckDBService.js

@@ -42,14 +42,23 @@ export class DuckDBService {
             throw new McpError(BaseErrorCode.SERVICE_NOT_INITIALIZED, "DuckDBQueryExecutor not available. DuckDBService may not be fully initialized.", context);
         }
     }
+    validateParams(params, context) {
+        if (params === undefined) {
+            return undefined;
+        }
+        if (Array.isArray(params)) {
+            return params;
+        }
+        throw new McpError(BaseErrorCode.INVALID_INPUT, "DuckDB service only supports array-style parameters, not named objects.", context);
+    }
     async run(sql, params) {
         const context = requestContextService.createRequestContext({
             operation: "DuckDBService.run",
             initialData: { sql, params },
         });
         this.ensureInitialized(context);
-        // Type assertion for params needed due to DuckDBQueryExecutor's specific type
-        return this.queryExecutor.run(sql, params);
+        const validatedParams = this.validateParams(params, context);
+        return this.queryExecutor.run(sql, validatedParams);
     }
     async query(sql, params) {
         const context = requestContextService.createRequestContext({
@@ -57,7 +66,8 @@ export class DuckDBService {
             initialData: { sql, params },
         });
         this.ensureInitialized(context);
-        return this.queryExecutor.query(sql, params);
+        const validatedParams = this.validateParams(params, context);
+        return this.queryExecutor.query(sql, validatedParams);
     }
     async stream(sql, params) {
         const context = requestContextService.createRequestContext({
@@ -65,7 +75,8 @@ export class DuckDBService {
             initialData: { sql, params },
         });
         this.ensureInitialized(context);
-        return this.queryExecutor.stream(sql, params);
+        const validatedParams = this.validateParams(params, context);
+        return this.queryExecutor.stream(sql, validatedParams);
     }
     async prepare(sql) {
         const context = requestContextService.createRequestContext({

package/dist/services/duck-db/types.d.ts

@@ -30,7 +30,7 @@ export interface DuckDBServiceConfig {
  */
 export interface DuckDBQuery {
     sql: string;
-    params?: unknown[] | Record<string, unknown>;
+    params?: unknown[];
 }
 /**
  * Represents the result of a query execution.
@@ -56,31 +56,31 @@ export interface IDuckDBService {
     /**
      * Executes a SQL query that does not return a large result set (e.g., CREATE, INSERT, UPDATE, DELETE).
      * @param {string} sql - The SQL query string.
-     * @param {unknown[] | Record<string, unknown>} [params] - Optional parameters for the query.
+     * @param {unknown[]} [params] - Optional parameters for the query.
      * @returns {Promise<void>}
      * @throws {McpError} If the query fails or the service is not initialized.
      */
-    run(sql: string, params?: unknown[] | Record<string, unknown>): Promise<void>;
+    run(sql: string, params?: unknown[]): Promise<void>;
     /**
      * Executes a SQL query and returns all resulting rows.
      * Suitable for queries that return a manageable number of rows.
      * @template T - The expected type of the row objects.
      * @param {string} sql - The SQL query string.
-     * @param {unknown[] | Record<string, unknown>} [params] - Optional parameters for the query.
+     * @param {unknown[]} [params] - Optional parameters for the query.
      * @returns {Promise<DuckDBQueryResult<T>>} The query result.
      * @throws {McpError} If the query fails or the service is not initialized.
      */
-    query<T = Record<string, unknown>>(sql: string, params?: unknown[] | Record<string, unknown>): Promise<DuckDBQueryResult<T>>;
+    query<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<DuckDBQueryResult<T>>;
     /**
      * Executes a SQL query and provides a streaming result reader.
      * Suitable for queries that return very large result sets.
      * The caller is responsible for closing the stream.
      * @param {string} sql - The SQL query string.
-     * @param {unknown[] | Record<string, unknown>} [params] - Optional parameters for the query.
+     * @param {unknown[]} [params] - Optional parameters for the query.
      * @returns {Promise<duckdb.DuckDBStreamingResult>} A streaming result object.
      * @throws {McpError} If the query fails or the service is not initialized.
      */
-    stream(sql: string, params?: unknown[] | Record<string, unknown>): Promise<duckdb.DuckDBPendingResult>;
+    stream(sql: string, params?: unknown[]): Promise<duckdb.DuckDBResult>;
     /**
      * Creates a prepared statement.
      * @param {string} sql - The SQL query string for the prepared statement.

package/dist/services/llm-providers/openRouterProvider.d.ts

@@ -19,7 +19,7 @@ export type OpenRouterChatParams = (ChatCompletionCreateParamsNonStreaming | Cha
     transforms?: string[];
     models?: string[];
     route?: "fallback";
-    provider?: Record<string, any>;
+    provider?: Record<string, unknown>;
 };
 declare class OpenRouterProvider {
     private client?;

package/dist/services/llm-providers/openRouterProvider.js

@@ -65,9 +65,13 @@ function _prepareApiParameters(params) {
     if (extraBody.min_p === undefined && config.llmDefaultMinP !== undefined) {
         extraBody.min_p = config.llmDefaultMinP;
     }
-    if (extraBody.provider && typeof extraBody.provider === "object") {
-        if (!extraBody.provider.sort)
-            extraBody.provider.sort = "throughput";
+    if (extraBody.provider &&
+        typeof extraBody.provider === "object" &&
+        extraBody.provider !== null) {
+        const provider = extraBody.provider;
+        if (!provider.sort) {
+            provider.sort = "throughput";
+        }
     }
     else if (extraBody.provider === undefined) {
         extraBody.provider = { sort: "throughput" };
@@ -108,7 +112,8 @@ async function _openRouterChatCompletionLogic(client, params, context) {
         });
         return response;
     }
-    catch (error) {
+    catch (e) {
+        const error = e;
         logger.logInteraction("OpenRouterError", {
             context,
             error: {
@@ -164,7 +169,8 @@ class OpenRouterProvider {
             this.status = "ready";
             logger.info("OpenRouter Service Initialized and Ready", opContext);
         }
-        catch (error) {
+        catch (e) {
+            const error = e;
             this.status = "error";
             this.initializationError = error;
             logger.error("Failed to initialize OpenRouter client", {

package/dist/services/supabase/supabaseClient.d.ts

@@ -7,7 +7,7 @@
  * @module src/services/supabase/supabaseClient
  */
 import { SupabaseClient } from "@supabase/supabase-js";
-type Database = any;
+type Database = Record<string, unknown>;
 /**
  * Returns the singleton Supabase client instance.
  * Throws an McpError if the client is not initialized.

package/dist/types-global/errors.d.ts

@@ -23,6 +23,8 @@ export declare enum BaseErrorCode {
     CONFLICT = "CONFLICT",
     /** The request failed due to invalid input parameters or data. */
     VALIDATION_ERROR = "VALIDATION_ERROR",
+    /** The provided input is invalid for the operation. */
+    INVALID_INPUT = "INVALID_INPUT",
     /** An error occurred while parsing input data (e.g., date string, JSON). */
     PARSING_ERROR = "PARSING_ERROR",
     /** The request was rejected because the client has exceeded rate limits. */

package/dist/types-global/errors.js

@@ -24,6 +24,8 @@ export var BaseErrorCode;
     BaseErrorCode["CONFLICT"] = "CONFLICT";
     /** The request failed due to invalid input parameters or data. */
     BaseErrorCode["VALIDATION_ERROR"] = "VALIDATION_ERROR";
+    /** The provided input is invalid for the operation. */
+    BaseErrorCode["INVALID_INPUT"] = "INVALID_INPUT";
     /** An error occurred while parsing input data (e.g., date string, JSON). */
     BaseErrorCode["PARSING_ERROR"] = "PARSING_ERROR";
     /** The request was rejected because the client has exceeded rate limits. */

package/dist/utils/internal/errorHandler.js

@@ -126,7 +126,7 @@ function getErrorMessage(error) {
             try {
                 return `Non-Error object encountered: ${JSON.stringify(error)}`;
             }
-            catch (stringifyError) {
+            catch {
                 return `Unstringifyable non-Error object encountered (constructor: ${error.constructor?.name || "Unknown"})`;
             }
         }

package/dist/utils/internal/logger.d.ts

@@ -17,7 +17,7 @@ export interface McpLogPayload {
         message: string;
         stack?: string;
     };
-    [key: string]: any;
+    [key: string]: unknown;
 }
 /**
  * Type for the `data` parameter of the `McpNotificationSender` function.
@@ -139,7 +139,7 @@ export declare class Logger {
      * @param interactionName - A name for the interaction type (e.g., 'OpenRouterIO').
      * @param data - The structured data to log.
      */
-    logInteraction(interactionName: string, data: Record<string, any>): void;
+    logInteraction(interactionName: string, data: Record<string, unknown>): void;
 }
 /**
  * The singleton instance of the Logger.

package/dist/utils/parsing/dateParser.d.ts

@@ -16,7 +16,7 @@ import { RequestContext } from "../index.js";
  * @throws {McpError} If an unexpected error occurs during parsing.
  * @private
  */
-declare function parseDateString(text: string, context: RequestContext, refDate?: Date): Promise<Date | null>;
+export declare function parseDateString(text: string, context: RequestContext, refDate?: Date): Promise<Date | null>;
 /**
  * Parses a natural language date string and returns detailed parsing results.
  * Provides more information than just the Date object, including matched text and components.
@@ -28,7 +28,7 @@ declare function parseDateString(text: string, context: RequestContext, refDate?
  * @throws {McpError} If an unexpected error occurs during parsing.
  * @private
  */
-declare function parseDateStringDetailed(text: string, context: RequestContext, refDate?: Date): Promise<chrono.ParsedResult[]>;
+export declare function parseDateStringDetailed(text: string, context: RequestContext, refDate?: Date): Promise<chrono.ParsedResult[]>;
 /**
  * An object providing date parsing functionalities.
  *
@@ -70,4 +70,3 @@ export declare const dateParser: {
      */
     parseDate: typeof parseDateString;
 };
-export {};

package/dist/utils/parsing/dateParser.js

@@ -17,7 +17,7 @@ import { ErrorHandler, logger } from "../index.js";
  * @throws {McpError} If an unexpected error occurs during parsing.
  * @private
  */
-async function parseDateString(text, context, refDate) {
+export async function parseDateString(text, context, refDate) {
     const operation = "parseDateString";
     const logContext = { ...context, operation, inputText: text, refDate };
     logger.debug(`Attempting to parse date string: "${text}"`, logContext);
@@ -49,7 +49,7 @@ async function parseDateString(text, context, refDate) {
  * @throws {McpError} If an unexpected error occurs during parsing.
  * @private
  */
-async function parseDateStringDetailed(text, context, refDate) {
+export async function parseDateStringDetailed(text, context, refDate) {
     const operation = "parseDateStringDetailed";
     const logContext = { ...context, operation, inputText: text, refDate };
     logger.debug(`Attempting detailed parse of date string: "${text}"`, logContext);

package/dist/utils/parsing/jsonParser.d.ts

@@ -56,7 +56,7 @@ export declare class JsonParser {
      * @returns The parsed JavaScript value.
      * @throws {McpError} If the string is empty after processing or if `partial-json` fails.
      */
-    parse<T = any>(jsonString: string, allowPartial?: number, context?: RequestContext): T;
+    parse<T = unknown>(jsonString: string, allowPartial?: number, context?: RequestContext): T;
 }
 /**
  * Singleton instance of the `JsonParser`.

package/dist/utils/parsing/jsonParser.js

@@ -83,7 +83,8 @@ export class JsonParser {
         try {
             return parsePartialJson(stringToParse, allowPartial);
         }
-        catch (error) {
+        catch (e) {
+            const error = e;
             const errorLogContext = context ||
                 requestContextService.createRequestContext({
                     operation: "JsonParser.parseError",

package/dist/utils/scheduling/scheduler.js

@@ -4,7 +4,7 @@
  * defining, starting, stopping, and listing recurring tasks within the application.
  * @module src/utils/scheduling/scheduler
  */
-import cron from "node-cron";
+import cron, { createTask } from "node-cron";
 import { logger } from "../internal/index.js";
 import { requestContextService } from "../internal/requestContext.js";
 /**
@@ -45,7 +45,7 @@ export class SchedulerService {
         if (!cron.validate(schedule)) {
             throw new Error(`Invalid cron schedule: ${schedule}`);
         }
-        const task = cron.schedule(schedule, async () => {
+        const task = createTask(schedule, async () => {
             const job = this.jobs.get(id);
             if (job && job.isRunning) {
                 logger.warning(`Job '${id}' is already running. Skipping this execution.`, {
@@ -74,8 +74,6 @@ export class SchedulerService {
                     job.isRunning = false;
                 }
             }
-        }, {
-            scheduled: false, // Do not start immediately
         });
         const newJob = {
             id,

package/dist/utils/security/sanitization.js

@@ -233,7 +233,6 @@ export class Sanitization {
             rootDir: options.rootDir ? path.resolve(options.rootDir) : undefined,
         };
         let wasAbsoluteInitially = false;
-        let convertedToRelative = false;
         try {
             if (!input || typeof input !== "string")
                 throw new Error("Invalid path input: must be a non-empty string.");
@@ -263,7 +262,6 @@ export class Sanitization {
                 if (path.isAbsolute(normalized)) {
                     if (!effectiveOptions.allowAbsolute) {
                         finalSanitizedPath = normalized.replace(/^(?:[A-Za-z]:)?[/\\]+/, "");
-                        convertedToRelative = true;
                     }
                     else {
                         finalSanitizedPath = normalized;
@@ -355,7 +353,7 @@ export class Sanitization {
             throw new McpError(BaseErrorCode.VALIDATION_ERROR, "Invalid number value (NaN or Infinity).", { input });
         }
         let clamped = false;
-        let originalValueForLog = value;
+        const originalValueForLog = value;
         if (min !== undefined && value < min) {
             value = min;
             clamped = true;
@@ -399,8 +397,8 @@ export class Sanitization {
         try {
             if (!input || typeof input !== "object")
                 return input;
-            const clonedInput = typeof structuredClone === "function"
-                ? structuredClone(input)
+            const clonedInput = typeof globalThis.structuredClone === "function"
+                ? globalThis.structuredClone(input)
                 : JSON.parse(JSON.stringify(input));
             this.redactSensitiveFields(clonedInput);
             return clonedInput;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-ts-template",
-  "version": "1.6.1",
+  "version": "1.6.3",
   "description": "Jumpstart Model Context Protocol (MCP) development with this production-ready TypeScript template. Build robust MCP servers and clients with built-in utilities, authentication, and service integrations. Agent framework utilizing MCP Client included.",
   "main": "dist/index.js",
   "files": [
@@ -29,6 +29,8 @@
     "rebuild": "ts-node --esm scripts/clean.ts && npm run build",
     "docs:generate": "typedoc --tsconfig ./tsconfig.typedoc.json",
     "depcheck": "npx depcheck",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
     "tree": "ts-node --esm scripts/tree.ts",
     "fetch-spec": "ts-node --esm scripts/fetch-openapi-spec.ts",
     "format": "prettier --write \"**/*.{ts,js,json,md,html,css}\"",
@@ -44,22 +46,24 @@
     "@types/sanitize-html": "^2.16.0",
     "@types/validator": "13.15.2",
     "chrono-node": "^2.8.0",
-    "dotenv": "^16.5.0",
+    "dotenv": "^16.6.1",
+    "eslint": "^9.30.1",
     "hono": "^4.8.4",
     "ignore": "^7.0.5",
     "jose": "^6.0.11",
+    "js-yaml": "^4.1.0",
+    "node-cron": "^4.2.0",
     "openai": "^5.8.2",
     "partial-json": "^0.1.7",
     "sanitize-html": "^2.17.0",
     "tiktoken": "^1.0.21",
     "ts-node": "^10.9.2",
     "typescript": "^5.8.3",
+    "typescript-eslint": "^8.35.1",
     "validator": "13.15.15",
     "winston": "^3.17.0",
     "winston-transport": "^4.9.0",
-    "node-cron": "^4.2.0",
-    "zod": "^3.25.74",
-    "js-yaml": "^4.1.0"
+    "zod": "^3.25.74"
   },
   "keywords": [
     "typescript",
@@ -101,10 +105,12 @@
     "node": ">=20.0.0"
   },
   "devDependencies": {
+    "@eslint/js": "^9.30.1",
     "@types/js-yaml": "^4.0.9",
     "@types/node-cron": "^3.0.11",
     "axios": "^1.10.0",
     "depcheck": "^1.4.7",
+    "globals": "^16.3.0",
     "prettier": "^3.6.2",
     "typedoc": "^0.28.7"
   }