hevy-mcp 1.11.10 → 1.12.4

package/dist/index.js

@@ -4,12 +4,14 @@
 
 // src/index.ts
 import "@dotenvx/dotenvx/config";
+import { fileURLToPath } from "url";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z as z42 } from "zod";
 
 // package.json
 var name = "hevy-mcp";
-var version = "1.11.9";
+var version = "1.12.3";
 
 // src/tools/folders.ts
 import { z } from "zod";
@@ -53,9 +55,9 @@ function determineErrorType(error, message) {
   return "UNKNOWN_ERROR" /* UNKNOWN_ERROR */;
 }
 function withErrorHandling(fn, context) {
-  return (async (...args2) => {
+  return (async (...args) => {
     try {
-      return await fn(...args2);
+      return await fn(...args);
     } catch (error) {
       return createErrorResponse(error, context);
     }
@@ -188,8 +190,8 @@ function createEmptyResponse(message = "No data found") {
 }
 
 // src/tools/folders.ts
-function registerFolderTools(server2, hevyClient2) {
-  server2.tool(
+function registerFolderTools(server, hevyClient) {
+  server.tool(
     "get-routine-folders",
     "Get a paginated list of your routine folders, including both default and custom folders. Useful for organizing and browsing your workout routines.",
     {
@@ -198,12 +200,12 @@ function registerFolderTools(server2, hevyClient2) {
     },
     withErrorHandling(
       async ({ page, pageSize }) => {
-        if (!hevyClient2) {
+        if (!hevyClient) {
           throw new Error(
             "API client not initialized. Please provide HEVY_API_KEY."
           );
         }
-        const data = await hevyClient2.getRoutineFolders({
+        const data = await hevyClient.getRoutineFolders({
           page,
           pageSize
         });
@@ -220,19 +222,19 @@ function registerFolderTools(server2, hevyClient2) {
       "get-routine-folders"
     )
   );
-  server2.tool(
+  server.tool(
     "get-routine-folder",
     "Get complete details of a specific routine folder by its ID, including name, creation date, and associated routines.",
     {
       folderId: z.string().min(1)
     },
     withErrorHandling(async ({ folderId }) => {
-      if (!hevyClient2) {
+      if (!hevyClient) {
         throw new Error(
           "API client not initialized. Please provide HEVY_API_KEY."
         );
       }
-      const data = await hevyClient2.getRoutineFolder(folderId);
+      const data = await hevyClient.getRoutineFolder(folderId);
       if (!data) {
         return createEmptyResponse(
           `Routine folder with ID ${folderId} not found`
@@ -242,19 +244,19 @@ function registerFolderTools(server2, hevyClient2) {
       return createJsonResponse(folder);
     }, "get-routine-folder")
   );
-  server2.tool(
+  server.tool(
     "create-routine-folder",
     "Create a new routine folder in your Hevy account. Requires a name for the folder. Returns the full folder details including the new folder ID.",
     {
       name: z.string().min(1)
     },
     withErrorHandling(async ({ name: name2 }) => {
-      if (!hevyClient2) {
+      if (!hevyClient) {
         throw new Error(
           "API client not initialized. Please provide HEVY_API_KEY."
         );
       }
-      const data = await hevyClient2.createRoutineFolder({
+      const data = await hevyClient.createRoutineFolder({
         routine_folder: {
           title: name2
         }
@@ -275,22 +277,22 @@ function registerFolderTools(server2, hevyClient2) {
 
 // src/tools/routines.ts
 import { z as z2 } from "zod";
-function registerRoutineTools(server2, hevyClient2) {
-  server2.tool(
+function registerRoutineTools(server, hevyClient) {
+  server.tool(
     "get-routines",
     "Get a paginated list of your workout routines, including custom and default routines. Useful for browsing or searching your available routines.",
     {
       page: z2.coerce.number().int().gte(1).default(1),
       pageSize: z2.coerce.number().int().gte(1).lte(10).default(5)
     },
-    withErrorHandling(async (args2) => {
-      if (!hevyClient2) {
+    withErrorHandling(async (args) => {
+      if (!hevyClient) {
         throw new Error(
           "API client not initialized. Please provide HEVY_API_KEY."
         );
       }
-      const { page, pageSize } = args2;
-      const data = await hevyClient2.getRoutines({
+      const { page, pageSize } = args;
+      const data = await hevyClient.getRoutines({
         page,
         pageSize
       });
@@ -303,19 +305,19 @@ function registerRoutineTools(server2, hevyClient2) {
       return createJsonResponse(routines);
     }, "get-routines")
   );
-  server2.tool(
+  server.tool(
     "get-routine",
     "Get a routine by its ID using the direct endpoint. Returns all details for the specified routine.",
     {
       routineId: z2.string().min(1)
     },
     withErrorHandling(async ({ routineId }) => {
-      if (!hevyClient2) {
+      if (!hevyClient) {
         throw new Error(
           "API client not initialized. Please provide HEVY_API_KEY."
         );
       }
-      const data = await hevyClient2.getRoutineById(String(routineId));
+      const data = await hevyClient.getRoutineById(String(routineId));
       if (!data || !data.routine) {
         return createEmptyResponse(`Routine with ID ${routineId} not found`);
       }
@@ -323,7 +325,7 @@ function registerRoutineTools(server2, hevyClient2) {
       return createJsonResponse(routine);
     }, "get-routine")
   );
-  server2.tool(
+  server.tool(
     "create-routine",
     "Create a new workout routine in your Hevy account. Requires a title and at least one exercise with sets. Optionally assign to a folder. Returns the full routine details including the new routine ID.",
     {
@@ -349,14 +351,14 @@ function registerRoutineTools(server2, hevyClient2) {
         })
       )
     },
-    withErrorHandling(async (args2) => {
-      if (!hevyClient2) {
+    withErrorHandling(async (args) => {
+      if (!hevyClient) {
         throw new Error(
           "API client not initialized. Please provide HEVY_API_KEY."
         );
       }
-      const { title, folderId, notes, exercises } = args2;
-      const data = await hevyClient2.createRoutine({
+      const { title, folderId, notes, exercises } = args;
+      const data = await hevyClient.createRoutine({
         routine: {
           title,
           folder_id: folderId ?? null,
@@ -393,7 +395,7 @@ function registerRoutineTools(server2, hevyClient2) {
       });
     }, "create-routine")
   );
-  server2.tool(
+  server.tool(
     "update-routine",
     "Update an existing routine by ID. You can modify the title, notes, and exercise configurations. Returns the updated routine with all changes applied.",
     {
@@ -419,14 +421,14 @@ function registerRoutineTools(server2, hevyClient2) {
         })
       )
     },
-    withErrorHandling(async (args2) => {
-      if (!hevyClient2) {
+    withErrorHandling(async (args) => {
+      if (!hevyClient) {
         throw new Error(
           "API client not initialized. Please provide HEVY_API_KEY."
         );
       }
-      const { routineId, title, notes, exercises } = args2;
-      const data = await hevyClient2.updateRoutine(routineId, {
+      const { routineId, title, notes, exercises } = args;
+      const data = await hevyClient.updateRoutine(routineId, {
         routine: {
           title,
           notes: notes ?? null,
@@ -466,8 +468,8 @@ function registerRoutineTools(server2, hevyClient2) {
 
 // src/tools/templates.ts
 import { z as z3 } from "zod";
-function registerTemplateTools(server2, hevyClient2) {
-  server2.tool(
+function registerTemplateTools(server, hevyClient) {
+  server.tool(
     "get-exercise-templates",
     "Get a paginated list of exercise templates (default and custom) with details like name, category, equipment, and muscle groups. Useful for browsing or searching available exercises.",
     {
@@ -476,12 +478,12 @@ function registerTemplateTools(server2, hevyClient2) {
     },
     withErrorHandling(
       async ({ page, pageSize }) => {
-        if (!hevyClient2) {
+        if (!hevyClient) {
           throw new Error(
             "API client not initialized. Please provide HEVY_API_KEY."
           );
         }
-        const data = await hevyClient2.getExerciseTemplates({
+        const data = await hevyClient.getExerciseTemplates({
           page,
           pageSize
         });
@@ -498,7 +500,7 @@ function registerTemplateTools(server2, hevyClient2) {
       "get-exercise-templates"
     )
   );
-  server2.tool(
+  server.tool(
     "get-exercise-template",
     "Get complete details of a specific exercise template by its ID, including name, category, equipment, muscle groups, and notes.",
     {
@@ -506,12 +508,12 @@ function registerTemplateTools(server2, hevyClient2) {
     },
     withErrorHandling(
       async ({ exerciseTemplateId }) => {
-        if (!hevyClient2) {
+        if (!hevyClient) {
           throw new Error(
             "API client not initialized. Please provide HEVY_API_KEY."
           );
         }
-        const data = await hevyClient2.getExerciseTemplate(exerciseTemplateId);
+        const data = await hevyClient.getExerciseTemplate(exerciseTemplateId);
         if (!data) {
           return createEmptyResponse(
             `Exercise template with ID ${exerciseTemplateId} not found`
@@ -994,18 +996,18 @@ var webhookUrlSchema = z40.string().url().refine(
     message: "Webhook URL cannot be localhost or loopback address"
   }
 );
-function registerWebhookTools(server2, hevyClient2) {
-  server2.tool(
+function registerWebhookTools(server, hevyClient) {
+  server.tool(
     "get-webhook-subscription",
     "Get the current webhook subscription for this account. Returns the webhook URL and auth token if a subscription exists.",
     {},
     withErrorHandling(async () => {
-      if (!hevyClient2) {
+      if (!hevyClient) {
         throw new Error(
           "API client not initialized. Please provide HEVY_API_KEY."
         );
       }
-      const data = await hevyClient2.getWebhookSubscription();
+      const data = await hevyClient.getWebhookSubscription();
       if (!data) {
         return createEmptyResponse(
           "No webhook subscription found for this account"
@@ -1014,7 +1016,7 @@ function registerWebhookTools(server2, hevyClient2) {
       return createJsonResponse(data);
     }, "get-webhook-subscription")
   );
-  server2.tool(
+  server.tool(
     "create-webhook-subscription",
     "Create a new webhook subscription for this account. The webhook will receive POST requests when workouts are created. Your endpoint must respond with 200 OK within 5 seconds.",
     {
@@ -1026,7 +1028,7 @@ function registerWebhookTools(server2, hevyClient2) {
       )
     },
     withErrorHandling(async ({ url, authToken }) => {
-      if (!hevyClient2) {
+      if (!hevyClient) {
         throw new Error(
           "API client not initialized. Please provide HEVY_API_KEY."
         );
@@ -1035,7 +1037,7 @@ function registerWebhookTools(server2, hevyClient2) {
         url,
         authToken
       });
-      const data = await hevyClient2.createWebhookSubscription(requestBody);
+      const data = await hevyClient.createWebhookSubscription(requestBody);
       if (!data) {
         return createEmptyResponse(
           "Failed to create webhook subscription - please check your URL and try again"
@@ -1044,17 +1046,17 @@ function registerWebhookTools(server2, hevyClient2) {
       return createJsonResponse(data);
     }, "create-webhook-subscription")
   );
-  server2.tool(
+  server.tool(
     "delete-webhook-subscription",
     "Delete the current webhook subscription for this account. This will stop all webhook notifications.",
     {},
     withErrorHandling(async () => {
-      if (!hevyClient2) {
+      if (!hevyClient) {
         throw new Error(
           "API client not initialized. Please provide HEVY_API_KEY."
         );
       }
-      const data = await hevyClient2.deleteWebhookSubscription();
+      const data = await hevyClient.deleteWebhookSubscription();
       if (!data) {
         return createEmptyResponse(
           "Failed to delete webhook subscription - no subscription may exist or there was a server error"
@@ -1067,8 +1069,8 @@ function registerWebhookTools(server2, hevyClient2) {
 
 // src/tools/workouts.ts
 import { z as z41 } from "zod";
-function registerWorkoutTools(server2, hevyClient2) {
-  server2.tool(
+function registerWorkoutTools(server, hevyClient) {
+  server.tool(
     "get-workouts",
     "Get a paginated list of workouts. Returns workout details including title, description, start/end times, and exercises performed. Results are ordered from newest to oldest.",
     {
@@ -1076,12 +1078,12 @@ function registerWorkoutTools(server2, hevyClient2) {
       pageSize: z41.coerce.number().int().gte(1).lte(10).default(5)
     },
     withErrorHandling(async ({ page, pageSize }) => {
-      if (!hevyClient2) {
+      if (!hevyClient) {
         throw new Error(
           "API client not initialized. Please provide HEVY_API_KEY."
         );
       }
-      const data = await hevyClient2.getWorkouts({
+      const data = await hevyClient.getWorkouts({
         page,
         pageSize
       });
@@ -1094,19 +1096,19 @@ function registerWorkoutTools(server2, hevyClient2) {
       return createJsonResponse(workouts);
     }, "get-workouts")
   );
-  server2.tool(
+  server.tool(
     "get-workout",
     "Get complete details of a specific workout by ID. Returns all workout information including title, description, start/end times, and detailed exercise data.",
     {
       workoutId: z41.string().min(1)
     },
     withErrorHandling(async ({ workoutId }) => {
-      if (!hevyClient2) {
+      if (!hevyClient) {
         throw new Error(
           "API client not initialized. Please provide HEVY_API_KEY."
         );
       }
-      const data = await hevyClient2.getWorkout(workoutId);
+      const data = await hevyClient.getWorkout(workoutId);
       if (!data) {
         return createEmptyResponse(`Workout with ID ${workoutId} not found`);
       }
@@ -1114,22 +1116,22 @@ function registerWorkoutTools(server2, hevyClient2) {
       return createJsonResponse(workout);
     }, "get-workout")
   );
-  server2.tool(
+  server.tool(
     "get-workout-count",
     "Get the total number of workouts on the account. Useful for pagination or statistics.",
     {},
     withErrorHandling(async () => {
-      if (!hevyClient2) {
+      if (!hevyClient) {
         throw new Error(
           "API client not initialized. Please provide HEVY_API_KEY."
         );
       }
-      const data = await hevyClient2.getWorkoutCount();
+      const data = await hevyClient.getWorkoutCount();
       const count = data ? data.workoutCount || 0 : 0;
       return createJsonResponse({ count });
     }, "get-workout-count")
   );
-  server2.tool(
+  server.tool(
     "get-workout-events",
     "Retrieve a paged list of workout events (updates or deletes) since a given date. Events are ordered from newest to oldest. The intention is to allow clients to keep their local cache of workouts up to date without having to fetch the entire list of workouts.",
     {
@@ -1138,12 +1140,12 @@ function registerWorkoutTools(server2, hevyClient2) {
       since: z41.string().default("1970-01-01T00:00:00Z")
     },
     withErrorHandling(async ({ page, pageSize, since }) => {
-      if (!hevyClient2) {
+      if (!hevyClient) {
         throw new Error(
           "API client not initialized. Please provide HEVY_API_KEY."
         );
       }
-      const data = await hevyClient2.getWorkoutEvents({
+      const data = await hevyClient.getWorkoutEvents({
         page,
         pageSize,
         since
@@ -1157,7 +1159,7 @@ function registerWorkoutTools(server2, hevyClient2) {
       return createJsonResponse(events);
     }, "get-workout-events")
   );
-  server2.tool(
+  server.tool(
     "create-workout",
     "Create a new workout in your Hevy account. Requires title, start/end times, and at least one exercise with sets. Returns the complete workout details upon successful creation including the newly assigned workout ID.",
     {
@@ -1194,7 +1196,7 @@ function registerWorkoutTools(server2, hevyClient2) {
         isPrivate,
         exercises
       }) => {
-        if (!hevyClient2) {
+        if (!hevyClient) {
           throw new Error(
             "API client not initialized. Please provide HEVY_API_KEY."
           );
@@ -1222,7 +1224,7 @@ function registerWorkoutTools(server2, hevyClient2) {
             }))
           }
         };
-        const data = await hevyClient2.createWorkout(requestBody);
+        const data = await hevyClient.createWorkout(requestBody);
         if (!data) {
           return createEmptyResponse(
             "Failed to create workout: Server returned no data"
@@ -1237,7 +1239,7 @@ function registerWorkoutTools(server2, hevyClient2) {
       "create-workout"
     )
   );
-  server2.tool(
+  server.tool(
     "update-workout",
     "Update an existing workout by ID. You can modify the title, description, start/end times, privacy setting, and exercise data. Returns the updated workout with all changes applied.",
     {
@@ -1299,7 +1301,7 @@ function registerWorkoutTools(server2, hevyClient2) {
             }))
           }
         };
-        const data = await hevyClient2.updateWorkout(workoutId, requestBody);
+        const data = await hevyClient.updateWorkout(workoutId, requestBody);
         if (!data) {
           return createEmptyResponse(
             `Failed to update workout with ID ${workoutId}`
@@ -1337,24 +1339,14 @@ function parseConfig(argv, env) {
   if (!apiKey) {
     apiKey = env.HEVY_API_KEY || "";
   }
-  const transportMode = 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
+    apiKey
   };
 }
 function assertApiKey(apiKey) {
   if (!apiKey) {
     console.error(
-      "Hevy API key is required. Provide via HEVY_API_KEY env variable, --hevy-api-key=YOUR_KEY command argument, or ?HEVY_API_KEY=YOUR_KEY query parameter."
+      "Hevy API key is required. Provide it via the HEVY_API_KEY environment variable or the --hevy-api-key=YOUR_KEY command argument."
     );
     process.exit(1);
   }
@@ -1637,202 +1629,63 @@ function createClient2(apiKey, baseUrl) {
   return createClient(apiKey, baseUrl);
 }
 
-// src/utils/httpServer.ts
-import { randomUUID } from "crypto";
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
-import express from "express";
-var transports = /* @__PURE__ */ new Map();
-var SESSION_TIMEOUT = 30 * 60 * 1e3;
-setInterval(
-  () => {
-    const now = Date.now();
-    for (const [sessionId, session] of transports) {
-      if (now - session.lastActivity > SESSION_TIMEOUT) {
-        console.log(`Cleaning up abandoned session: ${sessionId}`);
-        session.transport.close?.();
-        transports.delete(sessionId);
-      }
-    }
-  },
-  5 * 60 * 1e3
-);
-function createHttpServer(server2, options) {
-  const app = express();
-  const port = options?.port || 3e3;
-  const host = options?.host || "127.0.0.1";
-  app.use(express.json());
-  app.use("/mcp", (req, res, next) => {
-    res.setHeader("Access-Control-Allow-Origin", "*");
-    res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
-    res.setHeader(
-      "Access-Control-Allow-Headers",
-      "Content-Type, mcp-session-id"
-    );
-    res.setHeader(
-      "Access-Control-Expose-Headers",
-      "mcp-session-id, mcp-protocol-version"
-    );
-    if (req.method === "OPTIONS") {
-      res.status(204).end();
-      return;
-    }
-    next();
-  });
-  app.post("/mcp", async (req, res) => {
-    const sessionId = req.headers["mcp-session-id"];
-    let transport;
-    if (sessionId && transports.has(sessionId)) {
-      const existingSession = transports.get(sessionId);
-      if (!existingSession) {
-        res.status(400).json({
-          jsonrpc: "2.0",
-          error: {
-            code: -32e3,
-            message: "Bad Request: Session lookup failed"
-          },
-          id: null
-        });
-        return;
-      }
-      transport = existingSession.transport;
-      existingSession.lastActivity = Date.now();
-    } else if (!sessionId && isInitializeRequest(req.body)) {
-      const queryApiKey = req.query.HEVY_API_KEY;
-      if (queryApiKey && options?.onFirstRequestApiKey) {
-        options.onFirstRequestApiKey(queryApiKey);
-      }
-      transport = new StreamableHTTPServerTransport({
-        sessionIdGenerator: () => randomUUID(),
-        onsessioninitialized: (sessionId2) => {
-          transports.set(sessionId2, { transport, lastActivity: Date.now() });
-        },
-        // DNS rebinding protection configuration
-        enableDnsRebindingProtection: options?.enableDnsRebindingProtection ?? false,
-        allowedHosts: options?.allowedHosts || ["127.0.0.1"]
-      });
-      transport.onclose = () => {
-        if (transport.sessionId) {
-          transports.delete(transport.sessionId);
-        }
-      };
-      await server2.connect(transport);
-    } else {
-      res.status(400).json({
-        jsonrpc: "2.0",
-        error: {
-          code: -32e3,
-          message: "Bad Request: No valid session ID provided"
-        },
-        id: null
-      });
-      return;
-    }
-    await transport.handleRequest(req, res, req.body);
-  });
-  const handleSessionRequest = async (req, res) => {
-    const sessionId = req.headers["mcp-session-id"];
-    if (!sessionId || !transports.has(sessionId)) {
-      res.status(400).send("Invalid or missing session ID");
-      return;
-    }
-    const transport = transports.get(sessionId)?.transport;
-    if (transport) {
-      await transport.handleRequest(req, res);
-    }
-  };
-  app.get("/mcp", handleSessionRequest);
-  app.delete("/mcp", handleSessionRequest);
-  app.get("/health", (_req, res) => {
-    res.json({ status: "ok", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
-  });
-  const startServer = () => {
-    return new Promise((resolve, reject) => {
-      const httpServer = app.listen(port, host, () => {
-        console.log(`MCP HTTP server listening on http://${host}:${port}`);
-        console.log(`MCP endpoint: http://${host}:${port}/mcp`);
-        console.log(`Health check: http://${host}:${port}/health`);
-        resolve();
-      });
-      httpServer.on("error", (error) => {
-        reject(error);
-      });
-    });
-  };
-  return {
-    app,
-    startServer,
-    getActiveSessionsCount: () => transports.size,
-    closeAllSessions: () => {
-      for (const session of transports.values()) {
-        session.transport.close?.();
-      }
-      transports.clear();
-    }
-  };
-}
-
 // src/index.ts
 var HEVY_API_BASEURL = "https://api.hevyapp.com";
-var args = process.argv.slice(2);
-var cfg = parseConfig(args, process.env);
-var server = new McpServer({
-  name,
-  version
-});
-var hevyClient = null;
-function initializeClient(apiKey) {
-  if (!hevyClient) {
-    assertApiKey(apiKey);
-    hevyClient = createClient2(apiKey, HEVY_API_BASEURL);
-    console.log("Hevy client initialized with API key");
-  }
+var serverConfigSchema = z42.object({
+  apiKey: z42.string().min(1, "Hevy API key is required").describe("Your Hevy API key (available in the Hevy app settings).")
+});
+var configSchema = serverConfigSchema;
+function buildServer(apiKey) {
+  const server = new McpServer({
+    name,
+    version
+  });
+  const hevyClient = createClient2(apiKey, HEVY_API_BASEURL);
+  console.log("Hevy client initialized with API key");
+  registerWorkoutTools(server, hevyClient);
+  registerRoutineTools(server, hevyClient);
+  registerTemplateTools(server, hevyClient);
+  registerFolderTools(server, hevyClient);
+  registerWebhookTools(server, hevyClient);
+  return server;
 }
-if (cfg.transportMode === "stdio") {
-  initializeClient(cfg.apiKey);
-} else if (cfg.apiKey) {
-  initializeClient(cfg.apiKey);
-} else {
-  console.log(
-    "Starting in HTTP mode without API key. Waiting for API key via query parameter on first request."
-  );
+function createServer({ config }) {
+  const { apiKey } = serverConfigSchema.parse(config);
+  const server = buildServer(apiKey);
+  return server.server;
 }
-registerWorkoutTools(server, hevyClient);
-registerRoutineTools(server, hevyClient);
-registerTemplateTools(server, hevyClient);
-registerFolderTools(server, hevyClient);
-registerWebhookTools(server, hevyClient);
 async function runServer() {
-  if (cfg.transportMode === "http") {
-    console.log(
-      `Starting MCP server in HTTP mode on ${cfg.httpHost}:${cfg.httpPort}`
-    );
-    const httpServer = createHttpServer(server, {
-      port: cfg.httpPort,
-      host: cfg.httpHost,
-      enableDnsRebindingProtection: cfg.enableDnsRebindingProtection,
-      allowedHosts: cfg.allowedHosts,
-      // Callback to handle API key from query params
-      onFirstRequestApiKey: (apiKey) => {
-        if (!hevyClient) {
-          initializeClient(apiKey);
-          registerWorkoutTools(server, hevyClient);
-          registerRoutineTools(server, hevyClient);
-          registerTemplateTools(server, hevyClient);
-          registerFolderTools(server, hevyClient);
-          registerWebhookTools(server, hevyClient);
-        }
-      }
-    });
-    await httpServer.startServer();
-  } else {
-    console.log("Starting MCP server in stdio mode");
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
+  const args = process.argv.slice(2);
+  const cfg = parseConfig(args, process.env);
+  const apiKey = cfg.apiKey;
+  assertApiKey(apiKey);
+  const server = buildServer(apiKey);
+  console.log("Starting MCP server in stdio mode");
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+var isDirectExecution = (() => {
+  if (typeof process === "undefined" || !Array.isArray(process.argv)) {
+    return false;
   }
+  if (typeof import.meta === "undefined" || !import.meta?.url) {
+    return false;
+  }
+  try {
+    const modulePath = fileURLToPath(import.meta.url);
+    return process.argv[1] === modulePath;
+  } catch {
+    return false;
+  }
+})();
+if (isDirectExecution) {
+  runServer().catch((error) => {
+    console.error("Fatal error in main():", error);
+    process.exit(1);
+  });
 }
-runServer().catch((error) => {
-  console.error("Fatal error in main():", error);
-  process.exit(1);
-});
+export {
+  configSchema,
+  createServer as default
+};
 //# sourceMappingURL=index.js.map