hevy-mcp 1.3.0 → 1.4.0

package/README.md

@@ -1,3 +1,5 @@
+[![MseeP.ai Security Assessment Badge](https://mseep.net/pr/chrisdoc-hevy-mcp-badge.png)](https://mseep.ai/app/chrisdoc-hevy-mcp)
+
 # hevy-mcp: Model Context Protocol Server for Hevy Fitness API
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
@@ -63,9 +65,9 @@ Make sure to replace `your-api-key-here` with your actual Hevy API key.
 
 ## Configuration
 
-Create a `.env` file in the project root with the following content:
+Create a `.env` file in the project root (you can copy from [.env.sample](.env.sample)) with the following content:
 
-```
+```env
 HEVY_API_KEY=your_hevy_api_key_here
 ```
 
@@ -90,7 +92,7 @@ npm start
 
 ## Available MCP Tools
 
-The server implements the following MCP tools:
+The server implements the following MCP tools for interacting with the Hevy API:
 
 ### Workout Tools
 - `get-workouts`: Fetch and format workout data
@@ -117,7 +119,7 @@ The server implements the following MCP tools:
 
 ## Project Structure
 
-```
+```plaintext
 hevy-mcp/
 ├── .env                   # Environment variables (API keys)
 ├── src/
@@ -134,9 +136,11 @@ hevy-mcp/
 │       └── validators.ts  # Input validation helpers
 ├── scripts/               # Build and utility scripts
 └── tests/                 # Test suite
+    ├── integration/       # Integration tests with real API
+    │   └── hevy-mcp.integration.test.ts  # MCP server integration tests
 ```
 
-## Development
+## Development Guide
 
 ### Code Style
 
@@ -146,9 +150,62 @@ This project uses Biome for code formatting and linting:
 npm run check
 ```
 
+### Testing
+
+#### Run All Tests
+
+To run all tests (unit and integration), use:
+
+```bash
+npm test
+```
+
+> **Note:** If the `HEVY_API_KEY` environment variable is set, integration tests will also run. If not, only unit tests will run.
+
+#### Run Only Unit Tests
+
+To run only unit tests (excluding integration tests):
+
+```bash
+npx vitest run --exclude tests/integration/**
+```
+
+Or with coverage:
+
+```bash
+npx vitest run --coverage --exclude tests/integration/**
+```
+
+#### Run Only Integration Tests
+
+To run only the integration tests (requires a valid `HEVY_API_KEY`):
+
+```bash
+npx vitest run tests/integration
+```
+
+**Note:** The integration tests will fail if the `HEVY_API_KEY` environment variable is not set. This is by design to ensure that the tests are always run with a valid API key.
+
+##### GitHub Actions Configuration
+
+For GitHub Actions:
+
+1. Unit tests will always run on every push and pull request
+2. Integration tests will only run if the `HEVY_API_KEY` secret is set in the repository settings
+
+To set up the `HEVY_API_KEY` secret:
+
+1. Go to your GitHub repository
+2. Click on "Settings" > "Secrets and variables" > "Actions"
+3. Click on "New repository secret"
+4. Set the name to `HEVY_API_KEY` and the value to your Hevy API key
+5. Click "Add secret"
+
+If the secret is not set, the integration tests step will be skipped with a message indicating that the API key is missing.
+
 ### Generating API Client
 
-The API client is generated from the OpenAPI specification using Kiota:
+The API client is generated from the OpenAPI specification using [Kiota](https://github.com/microsoft/kiota):
 
 ```bash
 npm run export-specs
@@ -157,11 +214,11 @@ npm run build:client
 
 ## License
 
-This project is licensed under the MIT License - see the LICENSE file for details.
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
 
 ## Contributing
 
-Contributions are welcome! Please feel free to submit a Pull Request.
+Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.
 
 ## Acknowledgements
 

package/dist/index.js

@@ -72,13 +72,24 @@ function formatRoutineFolder(folder) {
 }
 function calculateDuration(startTime, endTime) {
   if (!startTime || !endTime) return "Unknown duration";
-  const start = new Date(startTime);
-  const end = new Date(endTime);
-  const durationMs = end.getTime() - start.getTime();
-  const hours = Math.floor(durationMs / (1e3 * 60 * 60));
-  const minutes = Math.floor(durationMs % (1e3 * 60 * 60) / (1e3 * 60));
-  const seconds = Math.floor(durationMs % (1e3 * 60) / 1e3);
-  return `${hours}h ${minutes}m ${seconds}s`;
+  try {
+    const start = new Date(startTime);
+    const end = new Date(endTime);
+    if (Number.isNaN(start.getTime()) || Number.isNaN(end.getTime())) {
+      return "Unknown duration";
+    }
+    const durationMs = end.getTime() - start.getTime();
+    if (durationMs < 0) {
+      return "Invalid duration (end time before start time)";
+    }
+    const hours = Math.floor(durationMs / (1e3 * 60 * 60));
+    const minutes = Math.floor(durationMs % (1e3 * 60 * 60) / (1e3 * 60));
+    const seconds = Math.floor(durationMs % (1e3 * 60) / 1e3);
+    return `${hours}h ${minutes}m ${seconds}s`;
+  } catch (error) {
+    console.error("Error calculating duration:", error);
+    return "Unknown duration";
+  }
 }
 function formatExerciseTemplate(template) {
   return {
@@ -569,6 +580,61 @@ function registerTemplateTools(server2, hevyClient2) {
 
 // src/tools/workouts.ts
 import { z as z4 } from "zod";
+
+// src/utils/error-handler.ts
+function createErrorResponse(error, context) {
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  const errorCode = error instanceof Error && "code" in error ? error.code : void 0;
+  if (errorCode) {
+    console.debug(`Error code: ${errorCode}`);
+  }
+  const contextPrefix = context ? `[${context}] ` : "";
+  const formattedMessage = `${contextPrefix}Error: ${errorMessage}`;
+  console.error(formattedMessage, error);
+  return {
+    content: [
+      {
+        type: "text",
+        text: formattedMessage
+      }
+    ],
+    isError: true
+  };
+}
+function withErrorHandling(fn, context) {
+  return async (...args) => {
+    try {
+      return await fn(...args);
+    } catch (error) {
+      return createErrorResponse(error, context);
+    }
+  };
+}
+
+// src/utils/response-formatter.ts
+function createJsonResponse(data, options = { pretty: true, indent: 2 }) {
+  const jsonString = options.pretty ? JSON.stringify(data, null, options.indent) : JSON.stringify(data);
+  return {
+    content: [
+      {
+        type: "text",
+        text: jsonString
+      }
+    ]
+  };
+}
+function createEmptyResponse(message = "No data found") {
+  return {
+    content: [
+      {
+        type: "text",
+        text: message
+      }
+    ]
+  };
+}
+
+// src/tools/workouts.ts
 function registerWorkoutTools(server2, hevyClient2) {
   server2.tool(
     "get-workouts",
@@ -577,36 +643,21 @@ function registerWorkoutTools(server2, hevyClient2) {
       page: z4.coerce.number().gte(1).default(1),
       pageSize: z4.coerce.number().int().gte(1).lte(10).default(5)
     },
-    async ({ page, pageSize }, extra) => {
-      try {
-        const data = await hevyClient2.v1.workouts.get({
-          queryParameters: {
-            page,
-            pageSize
-          }
-        });
-        const workouts = data?.workouts?.map((workout) => formatWorkout(workout)) || [];
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(workouts, null, 2)
-            }
-          ]
-        };
-      } catch (error) {
-        console.error("Error fetching workouts:", error);
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error fetching workouts: ${error instanceof Error ? error.message : String(error)}`
-            }
-          ],
-          isError: true
-        };
+    withErrorHandling(async ({ page, pageSize }) => {
+      const data = await hevyClient2.v1.workouts.get({
+        queryParameters: {
+          page,
+          pageSize
+        }
+      });
+      const workouts = data?.workouts?.map((workout) => formatWorkout(workout)) || [];
+      if (workouts.length === 0) {
+        return createEmptyResponse(
+          "No workouts found for the specified parameters"
+        );
       }
-    }
+      return createJsonResponse(workouts);
+    }, "get-workouts")
   );
   server2.tool(
     "get-workout",
@@ -614,70 +665,24 @@ function registerWorkoutTools(server2, hevyClient2) {
     {
       workoutId: z4.string().min(1)
     },
-    async ({ workoutId }, extra) => {
-      try {
-        const data = await hevyClient2.v1.workouts.byWorkoutId(workoutId).get();
-        if (!data) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Workout with ID ${workoutId} not found`
-              }
-            ]
-          };
-        }
-        const workout = formatWorkout(data);
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(workout, null, 2)
-            }
-          ]
-        };
-      } catch (error) {
-        console.error(`Error fetching workout ${workoutId}:`, error);
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error fetching workout: ${error instanceof Error ? error.message : String(error)}`
-            }
-          ],
-          isError: true
-        };
+    withErrorHandling(async ({ workoutId }) => {
+      const data = await hevyClient2.v1.workouts.byWorkoutId(workoutId).get();
+      if (!data) {
+        return createEmptyResponse(`Workout with ID ${workoutId} not found`);
       }
-    }
+      const workout = formatWorkout(data);
+      return createJsonResponse(workout);
+    }, "get-workout")
   );
   server2.tool(
     "get-workout-count",
     "Get the total number of workouts on the account. Useful for pagination or statistics.",
     {},
-    async (_, extra) => {
-      try {
-        const data = await hevyClient2.v1.workouts.count.get();
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Total workouts: ${data ? data.workoutCount || 0 : 0}`
-            }
-          ]
-        };
-      } catch (error) {
-        console.error("Error fetching workout count:", error);
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error fetching workout count: ${error instanceof Error ? error.message : String(error)}`
-            }
-          ],
-          isError: true
-        };
-      }
-    }
+    withErrorHandling(async () => {
+      const data = await hevyClient2.v1.workouts.count.get();
+      const count = data ? data.workoutCount || 0 : 0;
+      return createJsonResponse({ count });
+    }, "get-workout-count")
   );
   server2.tool(
     "get-workout-events",
@@ -687,36 +692,22 @@ function registerWorkoutTools(server2, hevyClient2) {
       pageSize: z4.coerce.number().int().gte(1).lte(10).default(5),
       since: z4.string().default("1970-01-01T00:00:00Z")
     },
-    async ({ page, pageSize, since }, extra) => {
-      try {
-        const data = await hevyClient2.v1.workouts.events.get({
-          queryParameters: {
-            page,
-            pageSize,
-            since
-          }
-        });
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(data?.events || [], null, 2)
-            }
-          ]
-        };
-      } catch (error) {
-        console.error("Error fetching workout events:", error);
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error fetching workout events: ${error instanceof Error ? error.message : String(error)}`
-            }
-          ],
-          isError: true
-        };
+    withErrorHandling(async ({ page, pageSize, since }) => {
+      const data = await hevyClient2.v1.workouts.events.get({
+        queryParameters: {
+          page,
+          pageSize,
+          since
+        }
+      });
+      const events = data?.events || [];
+      if (events.length === 0) {
+        return createEmptyResponse(
+          `No workout events found for the specified parameters since ${since}`
+        );
       }
-    }
+      return createJsonResponse(events);
+    }, "get-workout-events")
   );
   server2.tool(
     "create-workout",
@@ -746,8 +737,15 @@ function registerWorkoutTools(server2, hevyClient2) {
         })
       )
     },
-    async ({ title, description, startTime, endTime, isPrivate, exercises }, extra) => {
-      try {
+    withErrorHandling(
+      async ({
+        title,
+        description,
+        startTime,
+        endTime,
+        isPrivate,
+        exercises
+      }) => {
         const requestBody = {
           workout: {
             title,
@@ -773,38 +771,18 @@ function registerWorkoutTools(server2, hevyClient2) {
         };
         const data = await hevyClient2.v1.workouts.post(requestBody);
         if (!data) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: "Failed to create workout"
-              }
-            ]
-          };
+          return createEmptyResponse(
+            "Failed to create workout: Server returned no data"
+          );
         }
         const workout = formatWorkout(data);
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Workout created successfully:
-${JSON.stringify(workout, null, 2)}`
-            }
-          ]
-        };
-      } catch (error) {
-        console.error("Error creating workout:", error);
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error creating workout: ${error instanceof Error ? error.message : String(error)}`
-            }
-          ],
-          isError: true
-        };
-      }
-    }
+        return createJsonResponse(workout, {
+          pretty: true,
+          indent: 2
+        });
+      },
+      "create-workout"
+    )
   );
   server2.tool(
     "update-workout",
@@ -835,16 +813,16 @@ ${JSON.stringify(workout, null, 2)}`
         })
       )
     },
-    async ({
-      workoutId,
-      title,
-      description,
-      startTime,
-      endTime,
-      isPrivate,
-      exercises
-    }, extra) => {
-      try {
+    withErrorHandling(
+      async ({
+        workoutId,
+        title,
+        description,
+        startTime,
+        endTime,
+        isPrivate,
+        exercises
+      }) => {
         const requestBody = {
           workout: {
             title,
@@ -870,38 +848,18 @@ ${JSON.stringify(workout, null, 2)}`
         };
         const data = await hevyClient2.v1.workouts.byWorkoutId(workoutId).put(requestBody);
         if (!data) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Failed to update workout with ID ${workoutId}`
-              }
-            ]
-          };
+          return createEmptyResponse(
+            `Failed to update workout with ID ${workoutId}`
+          );
         }
         const workout = formatWorkout(data);
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Workout updated successfully:
-${JSON.stringify(workout, null, 2)}`
-            }
-          ]
-        };
-      } catch (error) {
-        console.error(`Error updating workout ${workoutId}:`, error);
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error updating workout: ${error instanceof Error ? error.message : String(error)}`
-            }
-          ],
-          isError: true
-        };
-      }
-    }
+        return createJsonResponse(workout, {
+          pretty: true,
+          indent: 2
+        });
+      },
+      "update-workout-operation"
+    )
   );
 }
 
@@ -2136,7 +2094,7 @@ function createClient(apiKey2, baseUrl) {
 
 // package.json
 var name = "hevy-mcp";
-var version = "1.2.2";
+var version = "1.3.1";
 
 // src/index.ts
 var HEVY_API_BASEURL = "https://api.hevyapp.com";