@striderlabs/mcp-orangetheory 1.0.0

package/src/index.ts

@@ -0,0 +1,603 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+import {
+  checkLoginStatus,
+  initiateLogin,
+  performLogin,
+  logout,
+  findStudios,
+  getClassSchedule,
+  bookClass,
+  cancelBooking,
+  getWorkoutHistory,
+  getMembershipStatus,
+  getPerformanceSummary,
+  getUpcomingClasses,
+  closeBrowser,
+} from "./browser.js";
+import { getConfigDir } from "./auth.js";
+
+const server = new Server(
+  {
+    name: "striderlabs-mcp-orangetheory",
+    version: "1.0.0",
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      {
+        name: "orangetheory_status",
+        description:
+          "Check Orangetheory login status and current session information including member name, email, and home studio.",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          required: [],
+        },
+      },
+      {
+        name: "orangetheory_login",
+        description:
+          "Log in to Orangetheory with email and password. Returns login instructions or performs automated login. Session is saved for future use.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            email: {
+              type: "string",
+              description: "Orangetheory account email address",
+            },
+            password: {
+              type: "string",
+              description: "Orangetheory account password",
+            },
+          },
+          required: [],
+        },
+      },
+      {
+        name: "orangetheory_logout",
+        description:
+          "Log out of Orangetheory and clear all saved session data and cookies.",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          required: [],
+        },
+      },
+      {
+        name: "orangetheory_find_studios",
+        description:
+          "Find Orangetheory Fitness studios near a given location. Returns studio names, addresses, phone numbers, and distances.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            location: {
+              type: "string",
+              description:
+                "Location to search near — city name, zip code, or full address (e.g., 'Austin, TX', '78701', '123 Main St, Boston MA')",
+            },
+            radius: {
+              type: "number",
+              description:
+                "Search radius in miles (default: 25). Use smaller values for dense urban areas.",
+            },
+          },
+          required: ["location"],
+        },
+      },
+      {
+        name: "orangetheory_class_schedule",
+        description:
+          "View class schedule for an Orangetheory studio. Shows available classes with times, coaches, class types, and available spots.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            studio_id: {
+              type: "string",
+              description:
+                "Studio ID from orangetheory_find_studios, or the studio location name",
+            },
+            date: {
+              type: "string",
+              description:
+                "Start date in YYYY-MM-DD format (default: today). Classes from this date will be shown.",
+            },
+            days: {
+              type: "number",
+              description:
+                "Number of days to show schedule for (default: 7, max: 14)",
+            },
+          },
+          required: ["studio_id"],
+        },
+      },
+      {
+        name: "orangetheory_book_class",
+        description:
+          "Book an Orangetheory class. Requires confirmation to prevent accidental bookings. Must be logged in.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            class_id: {
+              type: "string",
+              description:
+                "Class ID from orangetheory_class_schedule to book",
+            },
+            confirm: {
+              type: "boolean",
+              description:
+                "Must be set to true to confirm the booking. This reserves your spot and may count against your monthly class allowance.",
+            },
+          },
+          required: ["class_id", "confirm"],
+        },
+      },
+      {
+        name: "orangetheory_cancel_booking",
+        description:
+          "Cancel an Orangetheory class booking. Requires confirmation. Note: cancellations within 8 hours of class start may incur a late cancel fee.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            booking_id: {
+              type: "string",
+              description:
+                "Booking ID from orangetheory_upcoming_classes or orangetheory_class_schedule",
+            },
+            confirm: {
+              type: "boolean",
+              description:
+                "Must be set to true to confirm cancellation. Late cancellations (within 8 hours) may incur a fee.",
+            },
+          },
+          required: ["booking_id", "confirm"],
+        },
+      },
+      {
+        name: "orangetheory_workout_history",
+        description:
+          "View past workout history with detailed stats including splat points, calories burned, heart rate zones, and coach information.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            limit: {
+              type: "number",
+              description:
+                "Maximum number of workout records to return (default: 20, max: 100)",
+            },
+            start_date: {
+              type: "string",
+              description:
+                "Filter workouts from this date (YYYY-MM-DD format)",
+            },
+            end_date: {
+              type: "string",
+              description:
+                "Filter workouts up to this date (YYYY-MM-DD format)",
+            },
+          },
+          required: [],
+        },
+      },
+      {
+        name: "orangetheory_membership_status",
+        description:
+          "Check Orangetheory membership status including membership type, home studio, classes remaining, billing info, and member ID.",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          required: [],
+        },
+      },
+      {
+        name: "orangetheory_performance_summary",
+        description:
+          "Get aggregated performance statistics over a time period including total workouts, average splat points, calories, heart rate trends, and workout streaks.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            period: {
+              type: "string",
+              description:
+                "Time period for summary: 'week', 'month', '3months', '6months', 'year', or 'all' (default: 'month')",
+              enum: ["week", "month", "3months", "6months", "year", "all"],
+            },
+          },
+          required: [],
+        },
+      },
+      {
+        name: "orangetheory_upcoming_classes",
+        description:
+          "View upcoming booked Orangetheory classes with dates, times, coaches, and studio locations. Use this to check your schedule and get booking IDs for cancellation.",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          required: [],
+        },
+      },
+    ],
+  };
+});
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  try {
+    switch (name) {
+      case "orangetheory_status": {
+        const session = await checkLoginStatus();
+        if (session.isLoggedIn) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Logged in to Orangetheory Fitness
+Member: ${session.userName || "Unknown"}
+Email: ${session.userEmail || "Unknown"}
+Member ID: ${session.memberId || "Unknown"}
+Home Studio: ${session.homeStudio || "Unknown"}
+Last updated: ${session.lastUpdated}
+Config directory: ${getConfigDir()}`,
+              },
+            ],
+          };
+        } else {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Not logged in to Orangetheory Fitness. Use orangetheory_login to authenticate.
+Config directory: ${getConfigDir()}`,
+              },
+            ],
+          };
+        }
+      }
+
+      case "orangetheory_login": {
+        const email = args?.email as string | undefined;
+        const password = args?.password as string | undefined;
+
+        if (email && password) {
+          const result = await performLogin(email, password);
+          return {
+            content: [{ type: "text", text: result.message }],
+          };
+        } else {
+          const instructions = await initiateLogin();
+          return {
+            content: [{ type: "text", text: instructions }],
+          };
+        }
+      }
+
+      case "orangetheory_logout": {
+        await logout();
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Successfully logged out. All saved session data and cookies have been cleared.",
+            },
+          ],
+        };
+      }
+
+      case "orangetheory_find_studios": {
+        const location = args?.location as string;
+        const radius = args?.radius as number | undefined;
+
+        if (!location) {
+          throw new Error("location is required");
+        }
+
+        const studios = await findStudios(location, radius);
+
+        if (studios.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `No Orangetheory studios found near "${location}" within ${radius || 25} miles. Try a different location or increase the search radius.`,
+              },
+            ],
+          };
+        }
+
+        const studioList = studios
+          .map((s, i) => {
+            const parts = [
+              `${i + 1}. ${s.name}`,
+              `   Address: ${s.address}${s.city ? `, ${s.city}` : ""}${s.state ? `, ${s.state}` : ""}${s.zip ? ` ${s.zip}` : ""}`,
+            ];
+            if (s.phone) parts.push(`   Phone: ${s.phone}`);
+            if (s.distance) parts.push(`   Distance: ${s.distance}`);
+            if (s.hours) parts.push(`   Hours: ${s.hours}`);
+            if (s.id) parts.push(`   Studio ID: ${s.id}`);
+            return parts.join("\n");
+          })
+          .join("\n\n");
+
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Found ${studios.length} Orangetheory studio(s) near "${location}":\n\n${studioList}`,
+            },
+          ],
+        };
+      }
+
+      case "orangetheory_class_schedule": {
+        const studioId = args?.studio_id as string;
+        const date = args?.date as string | undefined;
+        const days = args?.days as number | undefined;
+
+        if (!studioId) {
+          throw new Error("studio_id is required");
+        }
+
+        const classes = await getClassSchedule(studioId, date, days);
+
+        if (classes.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `No classes found for studio "${studioId}"${date ? ` starting ${date}` : ""}. The studio may be closed or classes may be fully booked.`,
+              },
+            ],
+          };
+        }
+
+        const classList = classes
+          .map((c, i) => {
+            const parts = [
+              `${i + 1}. ${c.classType} — ${c.date} at ${c.time}`,
+              `   Studio: ${c.studioName}`,
+            ];
+            if (c.coach) parts.push(`   Coach: ${c.coach}`);
+            if (c.spotsAvailable !== undefined)
+              parts.push(`   Spots Available: ${c.spotsAvailable}${c.totalSpots ? `/${c.totalSpots}` : ""}`);
+            if (c.isBooked) parts.push(`   Status: BOOKED`);
+            if (c.id) parts.push(`   Class ID: ${c.id}`);
+            if (c.bookingId) parts.push(`   Booking ID: ${c.bookingId}`);
+            return parts.join("\n");
+          })
+          .join("\n\n");
+
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Class schedule for ${studioId}${date ? ` starting ${date}` : ""}:\n\n${classList}`,
+            },
+          ],
+        };
+      }
+
+      case "orangetheory_book_class": {
+        const classId = args?.class_id as string;
+        const confirm = args?.confirm as boolean;
+
+        if (!classId) {
+          throw new Error("class_id is required");
+        }
+
+        const result = await bookClass(classId, confirm);
+        return {
+          content: [{ type: "text", text: result.message }],
+        };
+      }
+
+      case "orangetheory_cancel_booking": {
+        const bookingId = args?.booking_id as string;
+        const confirm = args?.confirm as boolean;
+
+        if (!bookingId) {
+          throw new Error("booking_id is required");
+        }
+
+        const result = await cancelBooking(bookingId, confirm);
+        return {
+          content: [{ type: "text", text: result.message }],
+        };
+      }
+
+      case "orangetheory_workout_history": {
+        const limit = args?.limit as number | undefined;
+        const startDate = args?.start_date as string | undefined;
+        const endDate = args?.end_date as string | undefined;
+
+        const records = await getWorkoutHistory(limit, startDate, endDate);
+
+        if (records.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "No workout history found. Make sure you are logged in and have completed classes.",
+              },
+            ],
+          };
+        }
+
+        const historyList = records
+          .map((r, i) => {
+            const parts = [`${i + 1}. ${r.date} — ${r.classType || "OTF Class"}`];
+            if (r.studioName) parts.push(`   Studio: ${r.studioName}`);
+            if (r.coach) parts.push(`   Coach: ${r.coach}`);
+            if (r.splatPoints !== undefined)
+              parts.push(`   Splat Points: ${r.splatPoints}`);
+            if (r.calories !== undefined)
+              parts.push(`   Calories: ${r.calories} kcal`);
+            if (r.avgHeartRate !== undefined)
+              parts.push(`   Avg Heart Rate: ${r.avgHeartRate} bpm`);
+            if (r.maxHeartRate !== undefined)
+              parts.push(`   Max Heart Rate: ${r.maxHeartRate} bpm`);
+            if (r.activeTime) parts.push(`   Active Time: ${r.activeTime}`);
+            if (r.totalTime) parts.push(`   Total Time: ${r.totalTime}`);
+            if (r.zones) {
+              const zones = r.zones;
+              const zoneStr = Object.entries(zones)
+                .filter(([, v]) => v !== undefined)
+                .map(([k, v]) => `${k}: ${v}min`)
+                .join(", ");
+              if (zoneStr) parts.push(`   Heart Rate Zones: ${zoneStr}`);
+            }
+            return parts.join("\n");
+          })
+          .join("\n\n");
+
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Workout history (${records.length} records):\n\n${historyList}`,
+            },
+          ],
+        };
+      }
+
+      case "orangetheory_membership_status": {
+        const info = await getMembershipStatus();
+
+        const parts = [
+          `Orangetheory Membership Status`,
+          `Status: ${info.status}`,
+        ];
+        if (info.memberName) parts.push(`Member: ${info.memberName}`);
+        if (info.memberId) parts.push(`Member ID: ${info.memberId}`);
+        if (info.membershipType)
+          parts.push(`Membership Type: ${info.membershipType}`);
+        if (info.homeStudio) parts.push(`Home Studio: ${info.homeStudio}`);
+        if (info.startDate) parts.push(`Member Since: ${info.startDate}`);
+        if (info.nextBillingDate)
+          parts.push(`Next Billing Date: ${info.nextBillingDate}`);
+        if (info.monthlyRate) parts.push(`Monthly Rate: ${info.monthlyRate}`);
+        if (info.classesRemaining !== undefined)
+          parts.push(`Classes Remaining: ${info.classesRemaining}`);
+        if (info.classesUsed !== undefined)
+          parts.push(`Classes Used This Period: ${info.classesUsed}`);
+
+        return {
+          content: [{ type: "text", text: parts.join("\n") }],
+        };
+      }
+
+      case "orangetheory_performance_summary": {
+        const period = (args?.period as string) || "month";
+
+        const summary = await getPerformanceSummary(period);
+
+        const parts = [
+          `Performance Summary (${period})`,
+          `Total Workouts: ${summary.totalWorkouts}`,
+        ];
+        if (summary.totalCalories !== undefined)
+          parts.push(`Total Calories Burned: ${summary.totalCalories.toLocaleString()} kcal`);
+        if (summary.totalSplatPoints !== undefined)
+          parts.push(`Total Splat Points: ${summary.totalSplatPoints.toLocaleString()}`);
+        if (summary.avgSplatPoints !== undefined)
+          parts.push(`Avg Splat Points/Workout: ${summary.avgSplatPoints}`);
+        if (summary.avgCalories !== undefined)
+          parts.push(`Avg Calories/Workout: ${summary.avgCalories} kcal`);
+        if (summary.avgHeartRate !== undefined)
+          parts.push(`Avg Heart Rate: ${summary.avgHeartRate} bpm`);
+        if (summary.currentStreak !== undefined)
+          parts.push(`Current Streak: ${summary.currentStreak} workouts`);
+        if (summary.longestStreak !== undefined)
+          parts.push(`Longest Streak: ${summary.longestStreak} workouts`);
+        if (summary.recentTrend) parts.push(`Trend: ${summary.recentTrend}`);
+
+        return {
+          content: [{ type: "text", text: parts.join("\n") }],
+        };
+      }
+
+      case "orangetheory_upcoming_classes": {
+        const classes = await getUpcomingClasses();
+
+        if (classes.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "No upcoming classes booked. Use orangetheory_class_schedule to find and book classes.",
+              },
+            ],
+          };
+        }
+
+        const classList = classes
+          .map((c, i) => {
+            const parts = [
+              `${i + 1}. ${c.classType} — ${c.date} at ${c.time}`,
+              `   Studio: ${c.studioName}`,
+            ];
+            if (c.coach) parts.push(`   Coach: ${c.coach}`);
+            if (c.bookingId) parts.push(`   Booking ID: ${c.bookingId}`);
+            return parts.join("\n");
+          })
+          .join("\n\n");
+
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Upcoming booked classes (${classes.length}):\n\n${classList}`,
+            },
+          ],
+        };
+      }
+
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${message}`,
+        },
+      ],
+      isError: true,
+    };
+  }
+});
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("Strider Orangetheory MCP server running");
+  console.error(`Config directory: ${getConfigDir()}`);
+}
+
+main().catch((error) => {
+  console.error("Failed to start server:", error);
+  process.exit(1);
+});
+
+process.on("SIGINT", async () => {
+  await closeBrowser();
+  process.exit(0);
+});
+
+process.on("SIGTERM", async () => {
+  await closeBrowser();
+  process.exit(0);
+});

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true
+  },
+  "include": ["src/**/*"]
+}