mcp-ts-template 1.2.3 → 1.2.5

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.11.4-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.2.3-blue.svg)](./CHANGELOG.md)
+[![Version](https://img.shields.io/badge/Version-1.2.5-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/config/index.d.ts

@@ -25,6 +25,8 @@ export declare const config: {
     mcpServerVersion: string;
     /** Logging level. From `MCP_LOG_LEVEL` env var. Default: "debug". */
     logLevel: string;
+    /** Absolute path to the logs directory. From `LOGS_DIR` env var. */
+    logsPath: string;
     /** Runtime environment. From `NODE_ENV` env var. Default: "development". */
     environment: string;
     /** MCP transport type ('stdio' or 'http'). From `MCP_TRANSPORT_TYPE` env var. Default: "stdio". */

package/dist/config/index.js

@@ -15,13 +15,48 @@
  * @module src/config/index
  */
 import dotenv from "dotenv";
-import { readFileSync } from "fs";
-import { dirname, join } from "path";
+import { existsSync, mkdirSync, readFileSync, statSync } from "fs";
+import path, { dirname, join } from "path";
 import { fileURLToPath } from "url";
 import { z } from "zod";
 dotenv.config();
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const pkgPath = join(__dirname, "../../package.json");
+// --- Determine Project Root ---
+/**
+ * Finds the project root directory by searching upwards for package.json.
+ * @param startDir The directory to start searching from.
+ * @returns The absolute path to the project root, or throws an error if not found.
+ */
+const findProjectRoot = (startDir) => {
+    let currentDir = startDir;
+    while (true) {
+        const packageJsonPath = join(currentDir, 'package.json');
+        if (existsSync(packageJsonPath)) {
+            return currentDir;
+        }
+        const parentDir = dirname(currentDir);
+        if (parentDir === currentDir) {
+            // Reached the root of the filesystem without finding package.json
+            throw new Error(`Could not find project root (package.json) starting from ${startDir}`);
+        }
+        currentDir = parentDir;
+    }
+};
+let projectRoot;
+try {
+    // For ESM, __dirname is not available directly.
+    // import.meta.url gives the URL of the current module.
+    const currentModuleDir = dirname(fileURLToPath(import.meta.url));
+    projectRoot = findProjectRoot(currentModuleDir);
+}
+catch (error) {
+    console.error(`FATAL: Error determining project root: ${error.message}`);
+    // Fallback to process.cwd() if project root cannot be determined.
+    // This might happen in unusual execution environments.
+    projectRoot = process.cwd();
+    console.warn(`Warning: Using process.cwd() (${projectRoot}) as fallback project root.`);
+}
+// --- End Determine Project Root ---
+const pkgPath = join(projectRoot, "package.json"); // Use determined projectRoot
 let pkg = { name: "mcp-ts-template", version: "0.0.0" };
 try {
     pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
@@ -43,6 +78,8 @@ const EnvSchema = z.object({
     MCP_SERVER_VERSION: z.string().optional(),
     /** Minimum logging level. See `McpLogLevel` in logger utility. Default: "debug". */
     MCP_LOG_LEVEL: z.string().default("debug"),
+    /** Directory for log files. Defaults to "logs" in project root. */
+    LOGS_DIR: z.string().default(path.join(projectRoot, "logs")),
     /** Runtime environment (e.g., "development", "production"). Default: "development". */
     NODE_ENV: z.string().default("development"),
     /** MCP communication transport ("stdio" or "http"). Default: "stdio". */
@@ -117,6 +154,67 @@ if (!parsedEnv.success) {
     // Consider throwing an error in production for critical misconfigurations.
 }
 const env = parsedEnv.success ? parsedEnv.data : EnvSchema.parse({});
+// --- Directory Ensurance Function ---
+/**
+ * Ensures a directory exists and is within the project root.
+ * @param dirPath The desired path for the directory (can be relative or absolute).
+ * @param rootDir The root directory of the project to contain the directory.
+ * @param dirName The name of the directory type for logging (e.g., "logs").
+ * @returns The validated, absolute path to the directory, or null if invalid.
+ */
+const ensureDirectory = (dirPath, rootDir, dirName) => {
+    const resolvedDirPath = path.isAbsolute(dirPath) ? dirPath : path.resolve(rootDir, dirPath);
+    // Ensure the resolved path is within the project root boundary
+    if (!resolvedDirPath.startsWith(rootDir + path.sep) && resolvedDirPath !== rootDir) {
+        if (process.stdout.isTTY) {
+            console.error(`Error: ${dirName} path "${dirPath}" resolves to "${resolvedDirPath}", which is outside the project boundary "${rootDir}".`);
+        }
+        return null;
+    }
+    if (!existsSync(resolvedDirPath)) {
+        try {
+            mkdirSync(resolvedDirPath, { recursive: true });
+            if (process.stdout.isTTY) {
+                console.log(`Created ${dirName} directory: ${resolvedDirPath}`);
+            }
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            if (process.stdout.isTTY) {
+                console.error(`Error creating ${dirName} directory at ${resolvedDirPath}: ${errorMessage}`);
+            }
+            return null;
+        }
+    }
+    else {
+        try {
+            const stats = statSync(resolvedDirPath);
+            if (!stats.isDirectory()) {
+                if (process.stdout.isTTY) {
+                    console.error(`Error: ${dirName} path ${resolvedDirPath} exists but is not a directory.`);
+                }
+                return null;
+            }
+        }
+        catch (statError) {
+            if (process.stdout.isTTY) {
+                console.error(`Error accessing ${dirName} path ${resolvedDirPath}: ${statError.message}`);
+            }
+            return null;
+        }
+    }
+    return resolvedDirPath;
+};
+// --- End Directory Ensurance Function ---
+// --- Logs Directory Handling ---
+const validatedLogsPath = ensureDirectory(env.LOGS_DIR, projectRoot, "logs");
+if (!validatedLogsPath) {
+    if (process.stdout.isTTY) {
+        console.error("FATAL: Logs directory configuration is invalid or could not be created. Please check permissions and path. Exiting.");
+    }
+    process.exit(1); // Exit if logs directory is not usable
+}
+// --- End Logs Directory Handling ---
 /**
  * Main application configuration object.
  * Aggregates settings from validated environment variables and `package.json`.
@@ -128,6 +226,8 @@ export const config = {
     mcpServerVersion: env.MCP_SERVER_VERSION || pkg.version,
     /** Logging level. From `MCP_LOG_LEVEL` env var. Default: "debug". */
     logLevel: env.MCP_LOG_LEVEL,
+    /** Absolute path to the logs directory. From `LOGS_DIR` env var. */
+    logsPath: validatedLogsPath,
     /** Runtime environment. From `NODE_ENV` env var. Default: "development". */
     environment: env.NODE_ENV,
     /** MCP transport type ('stdio' or 'http'). From `MCP_TRANSPORT_TYPE` env var. Default: "stdio". */

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

@@ -406,7 +406,11 @@ export async function startHttpTransport(createServerInstanceFn, parentContext)
                 ...baseSessionReqContext,
                 sessionId,
             });
-            res.status(404).send("Session not found or expired");
+            res.status(404).json({
+                jsonrpc: "2.0",
+                error: { code: -32004, message: "Session not found or expired" },
+                id: null // Or a relevant request identifier if available from context
+            });
             return;
         }
         try {
@@ -422,7 +426,11 @@ export async function startHttpTransport(createServerInstanceFn, parentContext)
                 stack: err instanceof Error ? err.stack : undefined,
             });
             if (!res.headersSent) {
-                res.status(500).send("Internal Server Error");
+                res.status(500).json({
+                    jsonrpc: "2.0",
+                    error: { code: -32603, message: "Internal Server Error" },
+                    id: null // Or a relevant request identifier
+                });
             }
         }
     };
@@ -433,10 +441,16 @@ export async function startHttpTransport(createServerInstanceFn, parentContext)
     try {
         logger.debug("Attempting to start HTTP server with retry logic...", transportContext);
         const actualPort = await startHttpServerWithRetry(serverInstance, config.mcpHttpPort, config.mcpHttpHost, MAX_PORT_RETRIES, transportContext);
-        const protocol = config.environment === "production" ? "https" : "http";
-        const serverAddress = `${protocol}://${config.mcpHttpHost}:${actualPort}${MCP_ENDPOINT_PATH}`;
+        let serverAddressLog = `http://${config.mcpHttpHost}:${actualPort}${MCP_ENDPOINT_PATH}`;
+        let productionNote = "";
+        if (config.environment === "production") {
+            // The server itself runs HTTP, but it's expected to be behind an HTTPS proxy in production.
+            // The log reflects the effective public-facing URL.
+            serverAddressLog = `https://${config.mcpHttpHost}:${actualPort}${MCP_ENDPOINT_PATH}`;
+            productionNote = ` (via HTTPS, ensure reverse proxy is configured)`;
+        }
         if (process.stdout.isTTY) {
-            console.log(`\n🚀 MCP Server running in HTTP mode at: ${serverAddress}\n   (MCP Spec: 2025-03-26 Streamable HTTP Transport)\n`);
+            console.log(`\n🚀 MCP Server running in HTTP mode at: ${serverAddressLog}${productionNote}\n   (MCP Spec: 2025-03-26 Streamable HTTP Transport)\n`);
         }
     }
     catch (err) {

package/dist/services/index.d.ts

@@ -0,0 +1 @@
+export * from './llm-providers';

package/dist/services/index.js

@@ -0,0 +1 @@
+export * from './llm-providers';

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

@@ -0,0 +1 @@
+export * from './openRouterProvider';

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

@@ -0,0 +1 @@
+export * from './openRouterProvider';

package/dist/services/{openRouterProvider.d.ts → llm-providers/openRouterProvider.d.ts}

@@ -1,6 +1,6 @@
 import { ChatCompletion, ChatCompletionChunk, ChatCompletionCreateParamsNonStreaming, ChatCompletionCreateParamsStreaming } from "openai/resources/chat/completions";
 import { Stream } from "openai/streaming";
-import { OperationContext, RequestContext } from "../utils/internal/requestContext.js";
+import { OperationContext, RequestContext } from "../../utils/internal/requestContext.js";
 /**
  * Defines the parameters for an OpenRouter chat completion request.
  * This type extends standard OpenAI chat completion parameters and includes

package/dist/services/{openRouterProvider.js → llm-providers/openRouterProvider.js}

@@ -6,13 +6,13 @@
  * @module src/services/openRouterProvider
  */
 import OpenAI from "openai";
-import { config } from "../config/index.js";
-import { BaseErrorCode, McpError } from "../types-global/errors.js";
-import { ErrorHandler } from "../utils/internal/errorHandler.js";
-import { logger } from "../utils/internal/logger.js";
-import { requestContextService, } from "../utils/internal/requestContext.js";
-import { rateLimiter } from "../utils/security/rateLimiter.js";
-import { sanitization } from "../utils/security/sanitization.js";
+import { config } from "../../config/index.js";
+import { BaseErrorCode, McpError } from "../../types-global/errors.js";
+import { ErrorHandler } from "../../utils/internal/errorHandler.js";
+import { logger } from "../../utils/internal/logger.js";
+import { requestContextService, } from "../../utils/internal/requestContext.js";
+import { rateLimiter } from "../../utils/security/rateLimiter.js";
+import { sanitization } from "../../utils/security/sanitization.js";
 const YOUR_SITE_URL = config.openrouterAppUrl;
 const YOUR_SITE_NAME = config.openrouterAppName;
 /**

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

@@ -42,6 +42,7 @@ export declare class Logger {
     private mcpNotificationSender?;
     private currentMcpLevel;
     private currentWinstonLevel;
+    private readonly MCP_NOTIFICATION_STACK_TRACE_MAX_LENGTH;
     private readonly LOG_FILE_MAX_SIZE;
     private readonly LOG_MAX_FILES;
     /** @private */
@@ -62,6 +63,13 @@ export declare class Logger {
      * @param newLevel - The new minimum MCP log level to set.
      */
     setLevel(newLevel: McpLogLevel): void;
+    /**
+     * Configures the console transport based on the current log level and TTY status.
+     * Adds or removes the console transport as needed.
+     * @returns {{ enabled: boolean, message: string | null }} Status of console logging.
+     * @private
+     */
+    private _configureConsoleTransport;
     /**
      * Gets the singleton instance of the Logger.
      * @returns The singleton Logger instance.

package/dist/utils/internal/logger.js

@@ -36,19 +36,9 @@ const mcpToWinstonLevel = {
     alert: "error",
     emerg: "error",
 };
-const projectRoot = process.cwd(); // Use current working directory as project root
-const logsDir = path.join(projectRoot, "logs");
-// Security check for the logs directory path
-const resolvedLogsDir = path.resolve(logsDir); // Should be projectRoot/logs
-const isLogsDirSafe = resolvedLogsDir.startsWith(projectRoot + path.sep) &&
-    resolvedLogsDir !== projectRoot;
-if (!isLogsDirSafe) {
-    // This case should ideally not be hit if logsDir is simply projectRoot + /logs
-    // But it's a safeguard if path.join or path.resolve behaves unexpectedly or logsDir is manipulated.
-    if (process.stdout.isTTY) {
-        console.error(`FATAL: Resolved logs directory "${resolvedLogsDir}" is not safely within project root "${projectRoot}". File logging will be disabled.`);
-    }
-}
+// The logsPath from config is already resolved and validated by src/config/index.ts
+const resolvedLogsDir = config.logsPath;
+const isLogsDirSafe = !!resolvedLogsDir; // If logsPath is set, it's considered safe by config logic.
 /**
  * Creates the Winston console log format.
  * @returns The Winston log format for console output.
@@ -95,6 +85,7 @@ export class Logger {
         this.initialized = false;
         this.currentMcpLevel = "info";
         this.currentWinstonLevel = "info";
+        this.MCP_NOTIFICATION_STACK_TRACE_MAX_LENGTH = 1024;
         this.LOG_FILE_MAX_SIZE = 5 * 1024 * 1024; // 5MB
         this.LOG_MAX_FILES = 5;
     }
@@ -114,21 +105,27 @@ export class Logger {
         }
         this.currentMcpLevel = level;
         this.currentWinstonLevel = mcpToWinstonLevel[level];
-        let logsDirCreatedMessage = null;
+        let logsDirCreatedMessage = null; // This message is now informational as creation is handled by config
         if (isLogsDirSafe) {
-            try {
-                if (!fs.existsSync(resolvedLogsDir)) {
+            // Directory creation is handled by config/index.ts ensureDirectory.
+            // We can log if it was newly created by checking if it existed before config ran,
+            // but that's complex. For now, we assume config handled it.
+            // If resolvedLogsDir is set, config ensures it exists.
+            if (!fs.existsSync(resolvedLogsDir)) {
+                // This case should ideally not be hit if config.logsPath is correctly set up and validated.
+                // However, if it somehow occurs (e.g. dir deleted after config init but before logger init),
+                // we attempt to create it.
+                try {
                     await fs.promises.mkdir(resolvedLogsDir, { recursive: true });
-                    logsDirCreatedMessage = `Created logs directory: ${resolvedLogsDir}`;
+                    logsDirCreatedMessage = `Re-created logs directory (should have been created by config): ${resolvedLogsDir}`;
                 }
-            }
-            catch (err) {
-                if (process.stdout.isTTY) {
-                    const errorMessage = err instanceof Error ? err.message : String(err);
-                    console.error(`Error creating logs directory at ${resolvedLogsDir}: ${errorMessage}. File logging disabled.`);
+                catch (err) {
+                    if (process.stdout.isTTY) {
+                        const errorMessage = err instanceof Error ? err.message : String(err);
+                        console.error(`Error creating logs directory at ${resolvedLogsDir}: ${errorMessage}. File logging disabled.`);
+                    }
+                    throw err; // Critical if logs dir cannot be ensured
                 }
-                // Rethrow the error to ensure startup fails if logs directory cannot be created
-                throw err;
             }
         }
         const fileFormat = winston.format.combine(winston.format.timestamp(), winston.format.errors({ stack: true }), winston.format.json());
@@ -163,48 +160,33 @@ export class Logger {
         }
         else {
             if (process.stdout.isTTY) {
-                console.warn("File logging disabled due to unsafe logs directory path.");
+                console.warn("File logging disabled as logsPath is not configured or invalid.");
             }
         }
-        let consoleLoggingEnabledMessage = null;
-        let consoleLoggingSkippedMessage = null;
-        if (this.currentMcpLevel === "debug" && process.stdout.isTTY) {
-            const consoleFormat = createWinstonConsoleFormat();
-            transports.push(new winston.transports.Console({
-                level: "debug",
-                format: consoleFormat,
-            }));
-            consoleLoggingEnabledMessage =
-                "Console logging enabled at level: debug (stdout is TTY)";
-        }
-        else if (this.currentMcpLevel === "debug" && !process.stdout.isTTY) {
-            consoleLoggingSkippedMessage =
-                "Console logging skipped: Level is debug, but stdout is not a TTY (likely stdio transport).";
-        }
         this.winstonLogger = winston.createLogger({
             level: this.currentWinstonLevel,
             transports,
             exitOnError: false,
         });
+        // Configure console transport after Winston logger is created
+        const consoleStatus = this._configureConsoleTransport();
         const initialContext = {
             loggerSetup: true,
             requestId: "logger-init-deferred",
             timestamp: new Date().toISOString(),
         };
-        if (logsDirCreatedMessage) {
+        if (logsDirCreatedMessage) { // Log if we had to re-create it
             this.info(logsDirCreatedMessage, initialContext);
         }
-        if (consoleLoggingEnabledMessage) {
-            this.info(consoleLoggingEnabledMessage, initialContext);
-        }
-        if (consoleLoggingSkippedMessage) {
-            this.info(consoleLoggingSkippedMessage, initialContext);
+        if (consoleStatus.message) {
+            this.info(consoleStatus.message, initialContext);
         }
         this.initialized = true;
-        this.info(`Logger initialized. File logging level: ${this.currentWinstonLevel}. MCP logging level: ${this.currentMcpLevel}. Console logging: ${process.stdout.isTTY && this.currentMcpLevel === "debug" ? "enabled" : "disabled"}`, {
+        this.info(`Logger initialized. File logging level: ${this.currentWinstonLevel}. MCP logging level: ${this.currentMcpLevel}. Console logging: ${consoleStatus.enabled ? "enabled" : "disabled"}`, {
             loggerSetup: true,
             requestId: "logger-post-init",
             timestamp: new Date().toISOString(),
+            logsPathUsed: resolvedLogsDir,
         });
     }
     /**
@@ -243,24 +225,46 @@ export class Logger {
         const oldLevel = this.currentMcpLevel;
         this.currentMcpLevel = newLevel;
         this.currentWinstonLevel = mcpToWinstonLevel[newLevel];
-        this.winstonLogger.level = this.currentWinstonLevel;
+        if (this.winstonLogger) { // Ensure winstonLogger is defined
+            this.winstonLogger.level = this.currentWinstonLevel;
+        }
+        const consoleStatus = this._configureConsoleTransport();
+        if (oldLevel !== newLevel) {
+            this.info(`Log level changed. File logging level: ${this.currentWinstonLevel}. MCP logging level: ${this.currentMcpLevel}. Console logging: ${consoleStatus.enabled ? "enabled" : "disabled"}`, setLevelContext);
+            if (consoleStatus.message && consoleStatus.message !== "Console logging status unchanged.") {
+                this.info(consoleStatus.message, setLevelContext);
+            }
+        }
+    }
+    /**
+     * Configures the console transport based on the current log level and TTY status.
+     * Adds or removes the console transport as needed.
+     * @returns {{ enabled: boolean, message: string | null }} Status of console logging.
+     * @private
+     */
+    _configureConsoleTransport() {
+        if (!this.winstonLogger) {
+            return { enabled: false, message: "Cannot configure console: Winston logger not initialized." };
+        }
         const consoleTransport = this.winstonLogger.transports.find((t) => t instanceof winston.transports.Console);
-        const shouldHaveConsole = newLevel === "debug" && process.stdout.isTTY;
+        const shouldHaveConsole = this.currentMcpLevel === "debug" && process.stdout.isTTY;
+        let message = null;
         if (shouldHaveConsole && !consoleTransport) {
             const consoleFormat = createWinstonConsoleFormat();
             this.winstonLogger.add(new winston.transports.Console({
-                level: "debug",
+                level: "debug", // Console always logs debug if enabled
                 format: consoleFormat,
             }));
-            this.info("Console logging dynamically enabled.", setLevelContext);
+            message = "Console logging enabled (level: debug, stdout is TTY).";
         }
         else if (!shouldHaveConsole && consoleTransport) {
             this.winstonLogger.remove(consoleTransport);
-            this.info("Console logging dynamically disabled.", setLevelContext);
+            message = "Console logging disabled (level not debug or stdout not TTY).";
         }
-        if (oldLevel !== newLevel) {
-            this.info(`Log level changed. File logging level: ${this.currentWinstonLevel}. MCP logging level: ${this.currentMcpLevel}. Console logging: ${shouldHaveConsole ? "enabled" : "disabled"}`, setLevelContext);
+        else {
+            message = "Console logging status unchanged.";
         }
+        return { enabled: shouldHaveConsole, message };
     }
     /**
      * Gets the singleton instance of the Logger.
@@ -316,7 +320,7 @@ export class Logger {
                 mcpDataPayload.error = { message: error.message };
                 // Include stack trace in debug mode for MCP notifications, truncated for brevity
                 if (this.currentMcpLevel === "debug" && error.stack) {
-                    mcpDataPayload.error.stack = error.stack.substring(0, 500);
+                    mcpDataPayload.error.stack = error.stack.substring(0, this.MCP_NOTIFICATION_STACK_TRACE_MAX_LENGTH);
                 }
             }
             try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-ts-template",
-  "version": "1.2.3",
+  "version": "1.2.5",
   "description": "TypeScript template for building Model Context Protocol (MCP) servers & clients. Features production-ready utilities, stdio/HTTP transports (with JWT auth), examples, and type safety. Ideal starting point for creating MCP-based applications.",
   "main": "dist/index.js",
   "files": [
@@ -9,6 +9,7 @@
   "bin": {
     "mcp-ts-template": "./dist/index.js"
   },
+  "exports": "./dist/index.js",
   "type": "module",
   "repository": {
     "type": "git",
@@ -31,17 +32,17 @@
     "inspector": "mcp-inspector --config mcp.json --server mcp-ts-template"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.11.4",
+    "@modelcontextprotocol/sdk": "^1.11.5",
     "@types/jsonwebtoken": "^9.0.9",
-    "@types/node": "^22.15.18",
+    "@types/node": "^22.15.21",
     "@types/sanitize-html": "^2.16.0",
-    "@types/validator": "13.15.0",
+    "@types/validator": "13.15.1",
     "chrono-node": "^2.8.0",
     "dotenv": "^16.5.0",
     "express": "^5.1.0",
     "ignore": "^7.0.4",
     "jsonwebtoken": "^9.0.2",
-    "openai": "^4.100.0",
+    "openai": "^4.102.0",
     "partial-json": "^0.1.7",
     "sanitize-html": "^2.17.0",
     "tiktoken": "^1.0.21",
@@ -51,7 +52,7 @@
     "winston": "^3.17.0",
     "winston-daily-rotate-file": "^5.0.0",
     "yargs": "^17.7.2",
-    "zod": "^3.24.4"
+    "zod": "^3.25.20"
   },
   "keywords": [
     "typescript",
@@ -68,8 +69,11 @@
     "jwt",
     "authentication"
   ],
-  "author": "Casey Hand @cyanheads",
+  "author": "Casey Hand <casey@caseyjhand.com> (https://github.com/cyanheads/mcp-ts-template#readme)",
   "license": "Apache-2.0",
+  "engines": {
+    "node": ">=16.0.0"
+  },
   "devDependencies": {
     "@types/express": "^5.0.2",
     "@types/js-yaml": "^4.0.9",