feat(arguments): add possibility to provide key as argument

Author: chrisdoc

Dockerfile

@@ -35,4 +35,4 @@ USER nodejs
 
 ENV NODE_ENV=production
 
-CMD [ "npm", "run", "start:http" ]
+CMD [ "npm", "start", "--", "--http" ]

README.md

@@ -64,13 +64,28 @@ Make sure to replace `your-api-key-here` with your actual Hevy API key.
 
 ## Configuration
 
-Create a `.env` file in the project root (you can copy from [.env.sample](.env.sample)) with the following content:
+You can supply your Hevy API key in two ways:
+
+1. Environment variable (`HEVY_API_KEY`)
+2. Command-line argument (`--hevy-api-key=your_key` or `hevy-api-key=your_key` after `--` when using npm scripts)
+
+Create a `.env` file in the project root (you can copy from [.env.sample](.env.sample)) with the following content if using the environment variable approach:
 
 ```env
 HEVY_API_KEY=your_hevy_api_key_here
 ```
 
-Replace `your_hevy_api_key_here` with your actual Hevy API key.
+Replace `your_hevy_api_key_here` with your actual Hevy API key. If you prefer the command argument approach you can skip setting the environment variable and start the server with for example:
+
+```bash
+npm start -- --hevy-api-key=your_hevy_api_key_here
+```
+
+Or in HTTP mode:
+
+```bash
+npm start -- --http --hevy-api-key=your_hevy_api_key_here
+```
 
 ## Transport Modes
 
@@ -91,10 +106,12 @@ node dist/index.js
 The server can also run in HTTP mode for remote access or web-based integrations:
 
 ```bash
-# Start in HTTP mode
+# Start in HTTP mode (env var)
 npm start -- --http
-# or
-node dist/index.js --http
+# Start in HTTP mode (CLI arg)
+npm start -- --http --hevy-api-key=your_hevy_api_key_here
+# Or using node directly
+node dist/index.js --http --hevy-api-key=your_hevy_api_key_here
 
 # Using environment variable
 MCP_TRANSPORT=http npm start
@@ -161,6 +178,13 @@ docker run -d \
   -e HEVY_API_KEY=your_api_key_here \
   -p 3000:3000 \
   ghcr.io/chrisdoc/hevy-mcp:latest
+
+# Or using CLI argument for the key (omit env var)
+docker run -d \
+  --name hevy-mcp \
+  -p 3000:3000 \
+  ghcr.io/chrisdoc/hevy-mcp:latest \
+  hevy-api-key=your_api_key_here
 ```
 
 #### Building Locally
@@ -175,6 +199,13 @@ docker run -d \
   -e HEVY_API_KEY=your_api_key_here \
   -p 3000:3000 \
   hevy-mcp
+
+# Or with CLI argument
+docker run -d \
+  --name hevy-mcp \
+  -p 3000:3000 \
+  hevy-mcp \
+  hevy-api-key=your_api_key_here
 ```
 
 #### Docker Compose Example

smithery.yaml

@@ -8,14 +8,13 @@ startCommand:
   configSchema:
     # JSON Schema defining the configuration options for the MCP.
     type: object
-    required:
-      - hevyApiKey
+    required: ["hevy-api-key"]
     properties:
-      hevyApiKey:
+      hevy-api-key:
         type: string
         description: Your Hevy API key to authenticate with the Hevy Fitness API.
   exampleConfig:
-    hevyApiKey: "your-hevy-api-key-here"
+    hevy-api-key: "your-hevy-api-key-here"
 build:
   dockerfile: "Dockerfile"
   dockerBuildPath: "."

src/index.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import "@dotenvx/dotenvx/config";
+// Import tool registration functions
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { name, version } from "../package.json";
@@ -9,38 +10,27 @@ import { registerTemplateTools } from "./tools/templates.js";
 import { registerWebhookTools } from "./tools/webhooks.js";
 // Import tool registration functions
 import { registerWorkoutTools } from "./tools/workouts.js";
+import { assertApiKey, parseConfig } from "./utils/config.js";
 import { createClient } from "./utils/hevyClient.js";
 import { createHttpServer } from "./utils/httpServer.js";
 
 const HEVY_API_BASEURL = "https://api.hevyapp.com";
 
-// Parse command line arguments
+// Parse config (CLI args + env)
 const args = process.argv.slice(2);
-const transportMode =
-	args.includes("--http") || process.env.MCP_TRANSPORT === "http"
-		? "http"
-		: "stdio";
-const httpPort = Number.parseInt(process.env.PORT || "3000", 10);
-const httpHost = process.env.MCP_HTTP_HOST || "127.0.0.1";
-const enableDnsRebindingProtection =
-	process.env.MCP_DNS_REBINDING_PROTECTION === "true";
-const allowedHosts = process.env.MCP_ALLOWED_HOSTS?.split(",") || ["127.0.0.1"];
+const cfg = parseConfig(args, process.env);
 
 // Create server instance
 const server = new McpServer({
 	name,
 	version,
 });
 
-// Check for API key
-if (!process.env.HEVY_API_KEY) {
-	console.error("HEVY_API_KEY environment variable is not set");
-	process.exit(1);
-}
+// Validate API key presence
+assertApiKey(cfg.apiKey);
 
 // Configure client
-// We've already checked for HEVY_API_KEY existence above, so it's safe to use here
-const apiKey = process.env.HEVY_API_KEY || "";
+const apiKey = cfg.apiKey;
 const hevyClient = createClient(apiKey, HEVY_API_BASEURL);
 
 // Register all tools
@@ -52,13 +42,15 @@ registerWebhookTools(server, hevyClient);
 
 // Start the server
 async function runServer() {
-	if (transportMode === "http") {
-		console.log(`Starting MCP server in HTTP mode on ${httpHost}:${httpPort}`);
+	if (cfg.transportMode === "http") {
+		console.log(
+			`Starting MCP server in HTTP mode on ${cfg.httpHost}:${cfg.httpPort}`,
+		);
 		const httpServer = createHttpServer(server, {
-			port: httpPort,
-			host: httpHost,
-			enableDnsRebindingProtection,
-			allowedHosts,
+			port: cfg.httpPort,
+			host: cfg.httpHost,
+			enableDnsRebindingProtection: cfg.enableDnsRebindingProtection,
+			allowedHosts: cfg.allowedHosts,
 		});
 		await httpServer.startServer();
 	} else {

src/utils/config.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest";
+import { parseConfig } from "./config.js";
+
+function env(vars: Record<string, string | undefined>): NodeJS.ProcessEnv {
+	return { ...process.env, ...vars } as NodeJS.ProcessEnv;
+}
+
+describe("parseConfig", () => {
+	it("prefers --hevy-api-key= over env", () => {
+		const cfg = parseConfig(
+			["--hevy-api-key=cliKey"],
+			env({ HEVY_API_KEY: "envKey" }),
+		);
+		expect(cfg.apiKey).toBe("cliKey");
+	});
+
+	it("supports bare hevy-api-key= form", () => {
+		const cfg = parseConfig(["hevy-api-key=bareKey"], env({}));
+		expect(cfg.apiKey).toBe("bareKey");
+	});
+
+	it("falls back to env HEVY_API_KEY", () => {
+		const cfg = parseConfig([], env({ HEVY_API_KEY: "envOnly" }));
+		expect(cfg.apiKey).toBe("envOnly");
+	});
+
+	it("detects http transport via --http", () => {
+		const cfg = parseConfig(["--http"], env({ HEVY_API_KEY: "k" }));
+		expect(cfg.transportMode).toBe("http");
+	});
+
+	it("detects http transport via env", () => {
+		const cfg = parseConfig(
+			[],
+			env({ MCP_TRANSPORT: "http", HEVY_API_KEY: "k" }),
+		);
+		expect(cfg.transportMode).toBe("http");
+	});
+});

src/utils/config.ts

@@ -0,0 +1,69 @@
+export interface HevyConfig {
+	apiKey: string;
+	transportMode: "http" | "stdio";
+	httpHost: string;
+	httpPort: number;
+	enableDnsRebindingProtection: boolean;
+	allowedHosts: string[];
+}
+
+/**
+ * Parse CLI arguments and environment to derive configuration.
+ * Priority order for API key: CLI flag forms > environment variable.
+ * Supported CLI arg forms:
+ *   --hevy-api-key=KEY
+ *   --hevyApiKey=KEY
+ *   hevy-api-key=KEY (bare, e.g. when passed after npm start -- )
+ */
+export function parseConfig(
+	argv: string[],
+	env: NodeJS.ProcessEnv,
+): HevyConfig {
+	let apiKey = "";
+	const apiKeyArgPatterns = [
+		/^--hevy-api-key=(.+)$/i,
+		/^--hevyApiKey=(.+)$/i,
+		/^hevy-api-key=(.+)$/i,
+	];
+	for (const raw of argv) {
+		for (const pattern of apiKeyArgPatterns) {
+			const m = raw.match(pattern);
+			if (m) {
+				apiKey = m[1];
+				break;
+			}
+		}
+		if (apiKey) break;
+	}
+	if (!apiKey) {
+		apiKey = env.HEVY_API_KEY || "";
+	}
+
+	const transportMode: "http" | "stdio" =
+		argv.includes("--http") || env.MCP_TRANSPORT === "http" ? "http" : "stdio";
+	const httpPort = Number.parseInt(env.MCP_HTTP_PORT || "3000", 10);
+	const httpHost = env.MCP_HTTP_HOST || "127.0.0.1";
+	const enableDnsRebindingProtection =
+		env.MCP_DNS_REBINDING_PROTECTION === "true";
+	const allowedHosts = env.MCP_ALLOWED_HOSTS?.split(",")
+		.map((h) => h.trim())
+		.filter(Boolean) || ["127.0.0.1"];
+
+	return {
+		apiKey,
+		transportMode,
+		httpHost,
+		httpPort,
+		enableDnsRebindingProtection,
+		allowedHosts,
+	};
+}
+
+export function assertApiKey(apiKey: string) {
+	if (!apiKey) {
+		console.error(
+			"Hevy API key is required. Provide via HEVY_API_KEY env variable or --hevy-api-key=YOUR_KEY command argument.",
+		);
+		process.exit(1);
+	}
+}