intervals-mcp-server 1.0.0

package/dist/index.js

@@ -0,0 +1,2345 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/config.ts
+import { readFileSync, writeFileSync, mkdirSync, chmodSync, existsSync } from "fs";
+import { homedir } from "os";
+import path from "path";
+
+// src/utils/dates.ts
+function toLocalDateString(date) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function getDefaultEndDate() {
+  return toLocalDateString(/* @__PURE__ */ new Date());
+}
+function getDefaultStartDate(daysAgo = 30) {
+  const d = /* @__PURE__ */ new Date();
+  d.setDate(d.getDate() - daysAgo);
+  return toLocalDateString(d);
+}
+function getDefaultFutureEndDate(daysAhead = 30) {
+  const d = /* @__PURE__ */ new Date();
+  d.setDate(d.getDate() + daysAhead);
+  return toLocalDateString(d);
+}
+function parseDateRange(startDate, endDate, defaultStartDaysAgo = 30) {
+  const start = startDate || getDefaultStartDate(defaultStartDaysAgo);
+  const end = endDate || getDefaultEndDate();
+  return [start, end];
+}
+function formatIsoDateTime(value) {
+  const match = /^(\d{4}-\d{2}-\d{2})[T ](\d{2}:\d{2}:\d{2})/.exec(value);
+  return match ? `${match[1]} ${match[2]}` : value;
+}
+
+// src/utils/validation.ts
+var ATHLETE_ID_PATTERN = /^i?\d+$/;
+function validateAthleteId(athleteId) {
+  if (athleteId && !ATHLETE_ID_PATTERN.test(athleteId)) {
+    throw new Error(
+      "ATHLETE_ID must be all digits (e.g. 123456) or start with 'i' followed by digits (e.g. i123456)"
+    );
+  }
+}
+function validateDate(dateStr) {
+  if (/^\d{4}-\d{2}-\d{2}$/.test(dateStr)) {
+    const [y, m, d] = dateStr.split("-").map(Number);
+    const parsed = new Date(y, m - 1, d);
+    if (parsed.getFullYear() === y && parsed.getMonth() === m - 1 && parsed.getDate() === d) {
+      return dateStr;
+    }
+  }
+  throw new Error("Invalid date format. Please use YYYY-MM-DD.");
+}
+function resolveAthleteId(athleteId, defaultAthleteId) {
+  const idToUse = athleteId ?? defaultAthleteId;
+  if (!idToUse) {
+    return {
+      athleteId: "",
+      error: "Error: No athlete ID provided and no default ATHLETE_ID found. Run `npx intervals-mcp-server auth` to configure your credentials."
+    };
+  }
+  return { athleteId: idToUse, error: null };
+}
+function resolveActivityType(name, activityType) {
+  if (activityType) return activityType;
+  const nameLower = name?.toLowerCase() ?? "";
+  const mapping = [
+    ["Ride", ["bike", "cycle", "cycling", "ride"]],
+    ["Run", ["run", "running", "jog", "jogging"]],
+    ["Swim", ["swim", "swimming", "pool"]],
+    ["Walk", ["walk", "walking", "hike", "hiking"]],
+    ["Row", ["row", "rowing"]]
+  ];
+  for (const [workout, keywords] of mapping) {
+    if (keywords.some((keyword) => nameLower.includes(keyword))) {
+      return workout;
+    }
+  }
+  return "Ride";
+}
+function resolveDateParams(startDate, endDate, defaultStartDaysAgo = 30) {
+  return parseDateRange(startDate, endDate, defaultStartDaysAgo);
+}
+
+// src/config.ts
+var DEFAULT_API_BASE_URL = "https://intervals.icu/api/v1";
+function readPackageVersion() {
+  try {
+    const pkgUrl = new URL("../package.json", import.meta.url);
+    const pkg = JSON.parse(readFileSync(pkgUrl, "utf8"));
+    return pkg.version ?? "1.0.0";
+  } catch {
+    return "1.0.0";
+  }
+}
+function configDir() {
+  const xdg = process.env.XDG_CONFIG_HOME;
+  const base = xdg && path.isAbsolute(xdg) ? xdg : path.join(homedir(), ".config");
+  return path.join(base, "intervals-mcp-server");
+}
+function configFilePath() {
+  return path.join(configDir(), "config.json");
+}
+function readStoredCredentials() {
+  const file = configFilePath();
+  if (!existsSync(file)) return null;
+  try {
+    const raw = JSON.parse(readFileSync(file, "utf8"));
+    if (typeof raw.apiKey === "string" && typeof raw.athleteId === "string") {
+      return { apiKey: raw.apiKey, athleteId: raw.athleteId };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function saveStoredCredentials(creds) {
+  validateAthleteId(creds.athleteId);
+  mkdirSync(configDir(), { recursive: true });
+  const file = configFilePath();
+  writeFileSync(file, JSON.stringify(creds, null, 2) + "\n", { mode: 384 });
+  try {
+    chmodSync(file, 384);
+  } catch {
+  }
+}
+function getConfig() {
+  const stored = readStoredCredentials();
+  const apiKey = process.env.API_KEY || stored?.apiKey || "";
+  const athleteId = process.env.ATHLETE_ID || stored?.athleteId || "";
+  if (athleteId) validateAthleteId(athleteId);
+  return {
+    apiKey,
+    athleteId,
+    apiBaseUrl: process.env.INTERVALS_API_BASE_URL || DEFAULT_API_BASE_URL,
+    userAgent: `intervalsicu-mcp-server-ts/${readPackageVersion()}`
+  };
+}
+function hasCredentials() {
+  const cfg = getConfig();
+  return Boolean(cfg.apiKey && cfg.athleteId);
+}
+
+// src/auth.ts
+import * as p from "@clack/prompts";
+
+// src/api/client.ts
+function isApiError(result) {
+  return typeof result === "object" && result !== null && !Array.isArray(result) && result["error"] === true;
+}
+function isEmptyResult(result) {
+  if (result == null) return true;
+  if (Array.isArray(result)) return result.length === 0;
+  return Object.keys(result).length === 0;
+}
+function buildSearchString(params) {
+  if (!params) return "";
+  const search = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (Array.isArray(value)) {
+      for (const item of value) search.append(key, String(item));
+    } else {
+      search.append(key, String(value));
+    }
+  }
+  const s = search.toString();
+  return s ? `?${s}` : "";
+}
+function basicAuthHeader(apiKey) {
+  return `Basic ${Buffer.from(`API_KEY:${apiKey}`).toString("base64")}`;
+}
+function statusErrorMessage(status) {
+  switch (status) {
+    case 401:
+      return "401 Unauthorized: Please check your API key.";
+    case 403:
+      return "403 Forbidden: You may not have permission to access this resource.";
+    case 404:
+      return "404 Not Found: The requested endpoint or ID doesn't exist.";
+    case 422:
+      return "422 Unprocessable Entity: The server couldn't process the request (invalid parameters or unsupported operation).";
+    case 429:
+      return "429 Too Many Requests: Too many requests in a short time period.";
+    case 500:
+      return "500 Internal Server Error: The Intervals.icu server encountered an internal error.";
+    case 503:
+      return "503 Service Unavailable: The Intervals.icu server might be down or undergoing maintenance.";
+    default:
+      return null;
+  }
+}
+async function makeIntervalsRequest(url, options = {}) {
+  const { apiKey, params, method = "GET", data, timeoutMs = 3e4 } = options;
+  const config = getConfig();
+  const keyToUse = apiKey ?? config.apiKey;
+  if (!keyToUse) {
+    return {
+      error: true,
+      message: "API key is required. Run `npx intervals-mcp-server auth` or set the API_KEY environment variable."
+    };
+  }
+  const headers = {
+    "User-Agent": config.userAgent,
+    Accept: "application/json",
+    Authorization: basicAuthHeader(keyToUse)
+  };
+  if (method === "POST" || method === "PUT") {
+    headers["Content-Type"] = "application/json";
+  }
+  const fullUrl = `${config.apiBaseUrl}${url}${buildSearchString(params)}`;
+  try {
+    const response = await fetch(fullUrl, {
+      method,
+      headers,
+      body: method === "POST" || method === "PUT" ? JSON.stringify(data ?? null) : void 0,
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    const text2 = await response.text();
+    if (!response.ok) {
+      const friendly = statusErrorMessage(response.status);
+      return {
+        error: true,
+        status_code: response.status,
+        message: friendly ?? (text2 || `HTTP ${response.status}`)
+      };
+    }
+    let responseData;
+    try {
+      responseData = text2 ? JSON.parse(text2) : {};
+    } catch {
+      return { error: true, message: "Invalid JSON in response" };
+    }
+    return responseData;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { error: true, message: `Request error: ${message}` };
+  }
+}
+
+// src/openUrl.ts
+import { spawn } from "child_process";
+function openUrl(url) {
+  try {
+    let command;
+    let args;
+    switch (process.platform) {
+      case "darwin":
+        command = "open";
+        args = [url];
+        break;
+      case "win32":
+        command = "cmd";
+        args = ["/c", "start", "", url];
+        break;
+      default:
+        command = "xdg-open";
+        args = [url];
+    }
+    const child = spawn(command, args, { detached: true, stdio: "ignore" });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function terminalLink(url, label = url) {
+  const esc = "\x1B";
+  return `${esc}]8;;${url}${esc}\\${label}${esc}]8;;${esc}\\`;
+}
+
+// src/auth.ts
+var SETTINGS_URL = "https://intervals.icu/settings";
+var CLIENT_SNIPPETS = `
+Add the server to your MCP client (pick one):
+
+  Claude Code
+    claude mcp add intervals -s user -- npx intervals-mcp-server
+
+  Claude Desktop (~/Library/Application Support/Claude/claude_desktop_config.json)
+    {
+      "mcpServers": {
+        "intervals": { "command": "npx", "args": ["intervals-mcp-server"] }
+      }
+    }
+
+  Cursor (~/.cursor/mcp.json)
+    {
+      "mcpServers": {
+        "intervals": { "command": "npx", "args": ["intervals-mcp-server"] }
+      }
+    }`;
+function cancel2() {
+  p.cancel("Setup cancelled \u2014 nothing was saved.");
+  process.exit(0);
+}
+async function verifyCredentials(apiKey, athleteId) {
+  const today = getDefaultEndDate();
+  const result = await makeIntervalsRequest(`/athlete/${athleteId}/wellness`, {
+    apiKey,
+    params: { oldest: today, newest: today }
+  });
+  if (isApiError(result)) {
+    if (result.status_code === 401) return "The API key was rejected (401). Please re-check it.";
+    if (result.status_code === 404) return `Athlete ID "${athleteId}" was not found (404).`;
+    return result.message;
+  }
+  return null;
+}
+async function runOnboarding() {
+  const existing = readStoredCredentials();
+  console.log("");
+  p.intro("Intervals.icu MCP server \u2014 first-time setup");
+  p.log.message(
+    `This server needs your Intervals.icu  ${terminalLink("API Key", SETTINGS_URL)}  and  Athlete ID.`
+  );
+  p.log.step("Step 1 \u2014 opening the Intervals.icu settings page in your browser");
+  const opened = openUrl(SETTINGS_URL);
+  if (!opened) {
+    p.log.warn("Could not open a browser automatically \u2014 open this URL manually:");
+    console.log(`    ${SETTINGS_URL}`);
+  } else {
+    console.log(`    ${SETTINGS_URL}`);
+  }
+  p.log.step("Step 2 \u2014 copy your credentials from that page");
+  console.log(
+    [
+      "    \u2022 API Key:    find the \u201CAPI Key\u201D row and click Show, then copy the value",
+      "    \u2022 Athlete ID: shown on the same settings page (all digits, e.g. 123456,",
+      "                  sometimes prefixed with \u201Ci\u201D, e.g. i12345)"
+    ].join("\n")
+  );
+  let apiKey = existing?.apiKey ?? "";
+  let athleteId = existing?.athleteId ?? "";
+  let verified = false;
+  for (let attempt = 1; attempt <= 3 && !verified; attempt++) {
+    p.log.step(`Step 3 \u2014 enter your credentials (attempt ${attempt}/3)`);
+    const keyAnswer = await p.password({
+      message: "Paste your Intervals.icu API Key:",
+      validate: (value) => {
+        if (!value || value.trim().length < 8) return "The API key looks too short \u2014 please re-paste it.";
+      }
+    });
+    if (p.isCancel(keyAnswer)) cancel2();
+    apiKey = keyAnswer.trim();
+    const idAnswer = await p.text({
+      message: "Enter your Athlete ID:",
+      placeholder: "e.g. 123456 or i12345",
+      initialValue: athleteId,
+      validate: (value) => {
+        if (!value) return "Athlete ID is required.";
+        try {
+          validateAthleteId(value.trim());
+        } catch {
+          return "Athlete ID must be all digits or \u201Ci\u201D followed by digits.";
+        }
+      }
+    });
+    if (p.isCancel(idAnswer)) cancel2();
+    athleteId = idAnswer.trim();
+    const spinner2 = p.spinner();
+    spinner2.start("Verifying credentials against intervals.icu\u2026");
+    const problem = await verifyCredentials(apiKey, athleteId);
+    if (problem == null) {
+      spinner2.stop("Credentials verified \u2713");
+      verified = true;
+    } else {
+      spinner2.stop("Verification failed");
+      p.log.error(problem);
+    }
+  }
+  if (!verified) {
+    p.log.warn("Saving the credentials without live verification.");
+    const saveAnyway = await p.confirm({
+      message: "Save them anyway?",
+      initialValue: false
+    });
+    if (p.isCancel(saveAnyway) || !saveAnyway) cancel2();
+  }
+  try {
+    saveStoredCredentials({ apiKey, athleteId });
+  } catch (e) {
+    p.log.error(`Could not save the config file: ${e.message}`);
+    p.outro("Setup failed. Try again with `npx intervals-mcp-server auth`.");
+    return false;
+  }
+  p.log.success(`Credentials saved to ${configFilePath()} (readable only by you)`);
+  if (hasCredentials()) {
+    p.log.success("Configuration complete \u2014 the server is ready.");
+  }
+  console.log(CLIENT_SNIPPETS);
+  p.outro("Done! Re-run `npx intervals-mcp-server auth` any time to change credentials.");
+  return true;
+}
+
+// src/server.ts
+import http from "http";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+
+// src/tools/activities.ts
+import { z as z2 } from "zod";
+
+// src/utils/formatting.ts
+function formatActivitySummary(activity) {
+  let startTime = activity["startTime"] ?? activity["start_date"] ?? "Unknown";
+  if (typeof startTime === "string" && startTime.length > 10) {
+    startTime = formatIsoDateTime(startTime);
+  }
+  let rpe = activity["perceived_exertion"] ?? activity["icu_rpe"] ?? "N/A";
+  if (typeof rpe === "number") rpe = `${rpe}/10`;
+  let feel = activity["feel"] ?? "N/A";
+  if (typeof feel === "number") feel = `${feel}/5`;
+  const resolvedName = activity["_resolved_gear_name"];
+  const gearRaw = activity["gear"];
+  let gearName;
+  let gearId;
+  if (resolvedName) {
+    gearName = resolvedName;
+    gearId = typeof gearRaw === "object" && gearRaw !== null ? gearRaw["id"] ?? activity["gear_id"] ?? "N/A" : activity["gear_id"] ?? "N/A";
+  } else if (typeof gearRaw === "object" && gearRaw !== null) {
+    gearName = gearRaw["name"] || gearRaw["display_name"] || "N/A";
+    gearId = gearRaw["id"] ?? "N/A";
+  } else {
+    gearName = activity["gear_name"] ?? "N/A";
+    gearId = activity["gear_id"] ?? "N/A";
+  }
+  return `Activity: ${activity["name"] ?? "Unnamed"}
+ID: ${activity["id"] ?? "N/A"}
+Type: ${activity["type"] ?? "Unknown"}
+Date: ${startTime}
+Description: ${activity["description"] ?? "N/A"}
+Distance: ${activity["distance"] ?? 0} meters
+Duration: ${activity["duration"] ?? activity["elapsed_time"] ?? 0} seconds
+Moving Time: ${activity["moving_time"] ?? "N/A"} seconds
+Elevation Gain: ${activity["elevationGain"] ?? activity["total_elevation_gain"] ?? 0} meters
+Elevation Loss: ${activity["total_elevation_loss"] ?? "N/A"} meters
+
+Power Data:
+Average Power: ${activity["avgPower"] ?? activity["icu_average_watts"] ?? activity["average_watts"] ?? "N/A"} watts
+Weighted Avg Power: ${activity["icu_weighted_avg_watts"] ?? "N/A"} watts
+Training Load: ${activity["trainingLoad"] ?? activity["icu_training_load"] ?? "N/A"}
+FTP: ${activity["icu_ftp"] ?? "N/A"} watts
+Kilojoules: ${activity["icu_joules"] ?? "N/A"}
+Intensity: ${activity["icu_intensity"] ?? "N/A"}
+Power:HR Ratio: ${activity["icu_power_hr"] ?? "N/A"}
+Variability Index: ${activity["icu_variability_index"] ?? "N/A"}
+
+Heart Rate Data:
+Average Heart Rate: ${activity["avgHr"] ?? activity["average_heartrate"] ?? "N/A"} bpm
+Max Heart Rate: ${activity["max_heartrate"] ?? "N/A"} bpm
+LTHR: ${activity["lthr"] ?? "N/A"} bpm
+Resting HR: ${activity["icu_resting_hr"] ?? "N/A"} bpm
+Decoupling: ${activity["decoupling"] ?? "N/A"}
+
+Other Metrics:
+Cadence: ${activity["average_cadence"] ?? "N/A"} rpm
+Calories burned: ${activity["calories"] ?? "N/A"} kcal
+Average Speed: ${activity["average_speed"] ?? "N/A"} m/s
+Max Speed: ${activity["max_speed"] ?? "N/A"} m/s
+Average Stride: ${activity["average_stride"] ?? "N/A"}
+L/R Balance: ${activity["avg_lr_balance"] ?? "N/A"}
+Weight: ${activity["icu_weight"] ?? "N/A"} kg
+RPE: ${rpe}
+Session RPE: ${activity["session_rpe"] ?? "N/A"}
+Feel: ${feel}
+
+Environment:
+Trainer: ${activity["trainer"] ?? "N/A"}
+Average Temp: ${activity["average_temp"] ?? "N/A"}\xB0C
+Min Temp: ${activity["min_temp"] ?? "N/A"}\xB0C
+Max Temp: ${activity["max_temp"] ?? "N/A"}\xB0C
+Avg Wind Speed: ${activity["average_wind_speed"] ?? "N/A"} km/h
+Headwind %: ${activity["headwind_percent"] ?? "N/A"}%
+Tailwind %: ${activity["tailwind_percent"] ?? "N/A"}%
+
+Training Metrics:
+Fitness (CTL): ${activity["icu_ctl"] ?? "N/A"}
+Fatigue (ATL): ${activity["icu_atl"] ?? "N/A"}
+TRIMP: ${activity["trimp"] ?? "N/A"}
+Polarization Index: ${activity["polarization_index"] ?? "N/A"}
+Power Load: ${activity["power_load"] ?? "N/A"}
+HR Load: ${activity["hr_load"] ?? "N/A"}
+Pace Load: ${activity["pace_load"] ?? "N/A"}
+Efficiency Factor: ${activity["icu_efficiency_factor"] ?? "N/A"}
+
+Device Info:
+Device: ${activity["device_name"] ?? "N/A"}
+Power Meter: ${activity["power_meter"] ?? "N/A"}
+File Type: ${activity["file_type"] ?? "N/A"}
+
+Gear:
+Name: ${gearName}
+ID: ${gearId}`;
+}
+function formatActivityMessage(message) {
+  let created = message["created"] ?? "Unknown";
+  if (typeof created === "string" && created.length > 10) {
+    created = formatIsoDateTime(created);
+  }
+  return `Author: ${message["name"] ?? "Unknown"}
+Date: ${created}
+Type: ${message["type"] ?? "TEXT"}
+Content: ${message["content"] ?? ""}`;
+}
+function formatTrainingMetrics(get) {
+  const rows = [
+    ["ctl", "Fitness (CTL)"],
+    ["atl", "Fatigue (ATL)"],
+    ["rampRate", "Ramp Rate"],
+    ["ctlLoad", "CTL Load"],
+    ["atlLoad", "ATL Load"]
+  ];
+  const lines = [];
+  for (const [k, label] of rows) {
+    if (get(k) != null) lines.push(`- ${label}: ${get(k)}`);
+  }
+  return lines;
+}
+function formatSportInfo(get) {
+  const lines = [];
+  const sportInfo = get("sportInfo");
+  if (Array.isArray(sportInfo)) {
+    for (const sport of sportInfo) {
+      if (typeof sport === "object" && sport !== null && sport["eftp"] != null) {
+        lines.push(`- ${sport["type"]}: eFTP = ${sport["eftp"]}`);
+      }
+    }
+  }
+  return lines;
+}
+function formatVitalSigns(get) {
+  const rows = [
+    ["weight", "Weight", "kg"],
+    ["restingHR", "Resting HR", "bpm"],
+    ["hrv", "HRV", ""],
+    ["hrvSDNN", "HRV SDNN", ""],
+    ["avgSleepingHR", "Average Sleeping HR", "bpm"],
+    ["spO2", "SpO2", "%"],
+    ["systolic", "Systolic BP", ""],
+    ["diastolic", "Diastolic BP", ""],
+    ["respiration", "Respiration", "breaths/min"],
+    ["bloodGlucose", "Blood Glucose", "mmol/L"],
+    ["lactate", "Lactate", "mmol/L"],
+    ["vo2max", "VO2 Max", "ml/kg/min"],
+    ["bodyFat", "Body Fat", "%"],
+    ["abdomen", "Abdomen", "cm"],
+    ["baevskySI", "Baevsky Stress Index", ""]
+  ];
+  const lines = [];
+  for (const [k, label, unit] of rows) {
+    if (get(k) == null) continue;
+    if (k === "systolic" && get("diastolic") != null) {
+      lines.push(`- Blood Pressure: ${get("systolic")}/${get("diastolic")} mmHg`);
+    } else if (k !== "systolic" && k !== "diastolic") {
+      lines.push(`- ${label}: ${get(k)}${unit ? ` ${unit}` : ""}`);
+    }
+  }
+  return lines;
+}
+var SLEEP_QUALITY_LABELS = {
+  1: "Great",
+  2: "Good",
+  3: "Average",
+  4: "Poor"
+};
+function formatSleepRecovery(get) {
+  const lines = [];
+  let sleepHours = null;
+  if (get("sleepSecs") != null) {
+    const secs = get("sleepSecs");
+    sleepHours = (secs / 3600).toFixed(2);
+  } else if (get("sleepHours") != null) {
+    sleepHours = `${get("sleepHours")}`;
+  }
+  if (sleepHours !== null) lines.push(`  Sleep: ${sleepHours} hours`);
+  if (get("sleepQuality") != null) {
+    const quality = get("sleepQuality");
+    lines.push(`  Sleep Quality: ${quality} (${SLEEP_QUALITY_LABELS[quality] ?? String(quality)})`);
+  }
+  if (get("sleepScore") != null) lines.push(`  Device Sleep Score: ${get("sleepScore")}/100`);
+  if (get("readiness") != null) lines.push(`  Readiness: ${get("readiness")}/10`);
+  return lines;
+}
+function formatMenstrualTracking(get) {
+  const lines = [];
+  if (get("menstrualPhase") != null) {
+    const phase = String(get("menstrualPhase"));
+    lines.push(`  Menstrual Phase: ${phase.charAt(0).toUpperCase()}${phase.slice(1)}`);
+  }
+  if (get("menstrualPhasePredicted") != null) {
+    const phase = String(get("menstrualPhasePredicted"));
+    lines.push(`  Predicted Phase: ${phase.charAt(0).toUpperCase()}${phase.slice(1)}`);
+  }
+  return lines;
+}
+function formatSubjectiveFeelings(get) {
+  const rows = [
+    ["soreness", "Soreness"],
+    ["fatigue", "Fatigue"],
+    ["stress", "Stress"],
+    ["mood", "Mood"],
+    ["motivation", "Motivation"],
+    ["injury", "Injury Level"]
+  ];
+  const lines = [];
+  for (const [k, label] of rows) {
+    if (get(k) != null) lines.push(`  ${label}: ${get(k)}/10`);
+  }
+  return lines;
+}
+function formatNutritionHydration(get) {
+  const rows = [
+    ["kcalConsumed", "Calories Consumed", ""],
+    ["carbohydrates", "Carbohydrates", "g"],
+    ["protein", "Protein", "g"],
+    ["fatTotal", "Fat", "g"],
+    ["hydrationVolume", "Hydration Volume", ""]
+  ];
+  const lines = [];
+  for (const [k, label, unit] of rows) {
+    if (get(k) != null) lines.push(`- ${label}: ${get(k)}${unit ? ` ${unit}` : ""}`);
+  }
+  if (get("hydration") != null) lines.push(`  Hydration Score: ${get("hydration")}/10`);
+  return lines;
+}
+function formatWellnessEntry(entries, includeAllFields = false) {
+  const accessed = /* @__PURE__ */ new Set();
+  const get = (k) => {
+    accessed.add(k);
+    return entries[k];
+  };
+  if (includeAllFields) {
+    for (const k of ["date", "updated", "tempWeight", "tempRestingHR"]) accessed.add(k);
+  }
+  const lines = ["Wellness Data:"];
+  lines.push(`Date: ${get("id") ?? "N/A"}`);
+  lines.push("");
+  const trainingMetrics = formatTrainingMetrics(get);
+  if (trainingMetrics.length) {
+    lines.push("Training Metrics:");
+    lines.push(...trainingMetrics);
+    lines.push("");
+  }
+  const sportInfo = formatSportInfo(get);
+  if (sportInfo.length) {
+    lines.push("Sport-Specific Info:");
+    lines.push(...sportInfo);
+    lines.push("");
+  }
+  const vitalSigns = formatVitalSigns(get);
+  if (vitalSigns.length) {
+    lines.push("Vital Signs:");
+    lines.push(...vitalSigns);
+    lines.push("");
+  }
+  const sleepLines = formatSleepRecovery(get);
+  if (sleepLines.length) {
+    lines.push("Sleep & Recovery:");
+    lines.push(...sleepLines);
+    lines.push("");
+  }
+  const menstrualLines = formatMenstrualTracking(get);
+  if (menstrualLines.length) {
+    lines.push("Menstrual Tracking:");
+    lines.push(...menstrualLines);
+    lines.push("");
+  }
+  const subjectiveLines = formatSubjectiveFeelings(get);
+  if (subjectiveLines.length) {
+    lines.push("Subjective Feelings:");
+    lines.push(...subjectiveLines);
+    lines.push("");
+  }
+  const nutritionLines = formatNutritionHydration(get);
+  if (nutritionLines.length) {
+    lines.push("Nutrition & Hydration:");
+    lines.push(...nutritionLines);
+    lines.push("");
+  }
+  if (get("steps") != null) {
+    lines.push("Activity:");
+    lines.push(`- Steps: ${get("steps")}`);
+    lines.push("");
+  }
+  if (get("comments")) lines.push(`Comments: ${get("comments")}`);
+  if (accessed.has("locked")) {
+    lines.push(`Status: ${get("locked") ? "Locked" : "Unlocked"}`);
+  }
+  if (includeAllFields) {
+    const otherLines = [];
+    for (const [key, value] of Object.entries(entries)) {
+      if (!accessed.has(key) && value != null) {
+        otherLines.push(
+          `- ${key}: ${typeof value === "object" ? JSON.stringify(value) : value}`
+        );
+      }
+    }
+    if (otherLines.length) {
+      lines.push("");
+      lines.push("Other Fields:");
+      lines.push(...otherLines);
+    }
+  }
+  return lines.join("\n");
+}
+function formatEventSummary(event) {
+  const eventDate = event["start_date_local"] ?? event["date"] ?? "Unknown";
+  const eventType = event["workout"] ? "Workout" : event["race"] ? "Race" : "Other";
+  return `Date: ${eventDate}
+ID: ${event["id"] ?? "N/A"}
+Type: ${eventType}
+Name: ${event["name"] ?? "Unnamed"}
+Description: ${event["description"] ?? "No description"}`;
+}
+function formatEventDetails(event) {
+  let details = `Event Details:
+
+ID: ${event["id"] ?? "N/A"}
+Date: ${event["date"] ?? "Unknown"}
+Name: ${event["name"] ?? "Unnamed"}
+Description: ${event["description"] ?? "No description"}`;
+  const workout = event["workout"];
+  if (typeof workout === "object" && workout !== null) {
+    details += `
+
+Workout Information:
+Workout ID: ${workout["id"] ?? "N/A"}
+Sport: ${workout["sport"] ?? "Unknown"}
+Duration: ${workout["duration"] ?? 0} seconds
+TSS: ${workout["tss"] ?? "N/A"}`;
+    if (Array.isArray(workout["intervals"])) {
+      details += `
+Intervals: ${workout["intervals"].length}`;
+    }
+  }
+  if (event["race"]) {
+    details += `
+
+Race Information:
+Priority: ${event["priority"] ?? "N/A"}
+Result: ${event["result"] ?? "N/A"}`;
+  }
+  const cal = event["calendar"];
+  if (typeof cal === "object" && cal !== null) {
+    details += `
+
+Calendar: ${cal["name"] ?? "N/A"}`;
+  }
+  return details;
+}
+function formatCustomItemDetails(item) {
+  const lines = ["Custom Item Details:", ""];
+  lines.push(`ID: ${item["id"] ?? "N/A"}`);
+  lines.push(`Name: ${item["name"] ?? "N/A"}`);
+  lines.push(`Type: ${item["type"] ?? "N/A"}`);
+  if (item["description"]) lines.push(`Description: ${item["description"]}`);
+  if (item["visibility"]) lines.push(`Visibility: ${item["visibility"]}`);
+  if (item["index"] != null) lines.push(`Index: ${item["index"]}`);
+  if (item["hide_script"] != null) lines.push(`Hide Script: ${item["hide_script"]}`);
+  if (item["content"]) lines.push(`Content: ${JSON.stringify(item["content"], null, 2)}`);
+  return lines.join("\n");
+}
+function formatIntervals(intervalsData) {
+  let result = `Intervals Analysis:
+
+ID: ${intervalsData["id"] ?? "N/A"}
+Analyzed: ${intervalsData["analyzed"] ?? "N/A"}
+
+`;
+  const intervals = intervalsData["icu_intervals"];
+  if (Array.isArray(intervals) && intervals.length > 0) {
+    result += "Individual Intervals:\n\n";
+    intervals.forEach((interval, i) => {
+      result += `[${i + 1}] ${interval["label"] ?? `Interval ${i + 1}`} (${interval["type"] ?? "Unknown"})
+Duration: ${interval["elapsed_time"] ?? 0} seconds (moving: ${interval["moving_time"] ?? 0} seconds)
+Distance: ${interval["distance"] ?? 0} meters
+Start-End Indices: ${interval["start_index"] ?? 0}-${interval["end_index"] ?? 0}
+
+Power Metrics:
+  Average Power: ${interval["average_watts"] ?? 0} watts (${interval["average_watts_kg"] ?? 0} W/kg)
+  Max Power: ${interval["max_watts"] ?? 0} watts (${interval["max_watts_kg"] ?? 0} W/kg)
+  Weighted Avg Power: ${interval["weighted_average_watts"] ?? 0} watts
+  Intensity: ${interval["intensity"] ?? 0}
+  Training Load: ${interval["training_load"] ?? 0}
+  Joules: ${interval["joules"] ?? 0}
+  Joules > FTP: ${interval["joules_above_ftp"] ?? 0}
+  Power Zone: ${interval["zone"] ?? "N/A"} (${interval["zone_min_watts"] ?? 0}-${interval["zone_max_watts"] ?? 0} watts)
+  W' Balance: Start ${interval["wbal_start"] ?? 0}, End ${interval["wbal_end"] ?? 0}
+  L/R Balance: ${interval["avg_lr_balance"] ?? 0}
+  Variability: ${interval["w5s_variability"] ?? 0}
+  Torque: Avg ${interval["average_torque"] ?? 0}, Min ${interval["min_torque"] ?? 0}, Max ${interval["max_torque"] ?? 0}
+
+Heart Rate & Metabolic:
+  Heart Rate: Avg ${interval["average_heartrate"] ?? 0}, Min ${interval["min_heartrate"] ?? 0}, Max ${interval["max_heartrate"] ?? 0} bpm
+  Decoupling: ${interval["decoupling"] ?? 0}
+  DFA \u03B11: ${interval["average_dfa_a1"] ?? 0}
+  Respiration: ${interval["average_respiration"] ?? 0} breaths/min
+  EPOC: ${interval["average_epoc"] ?? 0}
+  SmO2: ${interval["average_smo2"] ?? 0}% / ${interval["average_smo2_2"] ?? 0}%
+  THb: ${interval["average_thb"] ?? 0} / ${interval["average_thb_2"] ?? 0}
+
+Speed & Cadence:
+  Speed: Avg ${interval["average_speed"] ?? 0}, Min ${interval["min_speed"] ?? 0}, Max ${interval["max_speed"] ?? 0} m/s
+  GAP: ${interval["gap"] ?? 0} m/s
+  Cadence: Avg ${interval["average_cadence"] ?? 0}, Min ${interval["min_cadence"] ?? 0}, Max ${interval["max_cadence"] ?? 0} rpm
+  Stride: ${interval["average_stride"] ?? 0}
+
+Elevation & Environment:
+  Elevation Gain: ${interval["total_elevation_gain"] ?? 0} meters
+  Altitude: Min ${interval["min_altitude"] ?? 0}, Max ${interval["max_altitude"] ?? 0} meters
+  Gradient: ${interval["average_gradient"] ?? 0}%
+  Temperature: ${interval["average_temp"] ?? 0}\xB0C (Weather: ${interval["average_weather_temp"] ?? 0}\xB0C, Feels like: ${interval["average_feels_like"] ?? 0}\xB0C)
+  Wind: Speed ${interval["average_wind_speed"] ?? 0} km/h, Gust ${interval["average_wind_gust"] ?? 0} km/h, Direction ${interval["prevailing_wind_deg"] ?? 0}\xB0
+  Headwind: ${interval["headwind_percent"] ?? 0}%, Tailwind: ${interval["tailwind_percent"] ?? 0}%
+
+`;
+    });
+  }
+  const groups = intervalsData["icu_groups"];
+  if (Array.isArray(groups) && groups.length > 0) {
+    result += "Interval Groups:\n\n";
+    groups.forEach((group, i) => {
+      result += `Group: ${group["id"] ?? `Group ${i + 1}`} (Contains ${group["count"] ?? 0} intervals)
+Duration: ${group["elapsed_time"] ?? 0} seconds (moving: ${group["moving_time"] ?? 0} seconds)
+Distance: ${group["distance"] ?? 0} meters
+Start-End Indices: ${group["start_index"] ?? 0}-N/A
+
+Power: Avg ${group["average_watts"] ?? 0} watts (${group["average_watts_kg"] ?? 0} W/kg), Max ${group["max_watts"] ?? 0} watts
+W. Avg Power: ${group["weighted_average_watts"] ?? 0} watts, Intensity: ${group["intensity"] ?? 0}
+Heart Rate: Avg ${group["average_heartrate"] ?? 0}, Max ${group["max_heartrate"] ?? 0} bpm
+Speed: Avg ${group["average_speed"] ?? 0}, Max ${group["max_speed"] ?? 0} m/s
+Cadence: Avg ${group["average_cadence"] ?? 0}, Max ${group["max_cadence"] ?? 0} rpm
+
+`;
+    });
+  }
+  return result;
+}
+function formatDurationLabel(secs) {
+  if (secs < 60) return `${secs}s`;
+  if (secs < 3600) {
+    const mins = Math.floor(secs / 60);
+    const remainder2 = secs % 60;
+    return remainder2 ? `${mins}m${remainder2}s` : `${mins}m`;
+  }
+  const hours = Math.floor(secs / 3600);
+  const remainder = Math.floor(secs % 3600 / 60);
+  return remainder ? `${hours}h${remainder}m` : `${hours}h`;
+}
+function formatPowerCurves(curves, activityType, includeNormalised) {
+  const lines = [`Power Curves (${activityType}):`, ""];
+  for (const curve of curves) {
+    const label = curve.label || curve.id || "Unknown";
+    let dateRange = "";
+    if (curve.start && curve.end) {
+      const startShort = curve.start.length > 10 ? curve.start.slice(0, 10) : curve.start;
+      const endShort = curve.end.length > 10 ? curve.end.slice(0, 10) : curve.end;
+      dateRange = ` (${startShort} to ${endShort})`;
+    }
+    lines.push(`${label}${dateRange}:`);
+    const dataPoints = curve.data_points ?? [];
+    if (!dataPoints.length) {
+      lines.push("  No data available for requested durations.");
+      lines.push("");
+      continue;
+    }
+    for (const point of dataPoints) {
+      const durLabel = formatDurationLabel(point.secs);
+      const aid = point.activity_id ?? "";
+      const parts = [`  ${durLabel}: ${point.watts ?? "N/A"}W`];
+      if (includeNormalised && point.watts_per_kg != null) {
+        parts.push(`${point.watts_per_kg.toFixed(2)}W/kg`);
+        const wkgAid = point.wkg_activity_id ?? "";
+        if (wkgAid && wkgAid !== aid) parts.push(`[${aid}|wkg:${wkgAid}]`);
+        else parts.push(`[${aid}]`);
+      } else {
+        parts.push(`[${aid}]`);
+      }
+      lines.push(parts.join(" "));
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/tools/gear.ts
+import { z } from "zod";
+
+// src/tools/shared.ts
+function textResult(text2) {
+  return { content: [{ type: "text", text: text2 }] };
+}
+function apiErrorMessage(result) {
+  return typeof result["message"] === "string" ? result["message"] : "Unknown error";
+}
+
+// src/tools/gear.ts
+var gearRawCache = /* @__PURE__ */ new Map();
+function extractGearId(activity) {
+  const gearRaw = activity["gear"];
+  if (typeof gearRaw === "object" && gearRaw !== null) {
+    const id = gearRaw["id"];
+    if (id) return String(id);
+  }
+  const gearId = activity["gear_id"];
+  if (gearId) return String(gearId);
+  return null;
+}
+function itemsFromResponse(result) {
+  if (Array.isArray(result)) return result.filter((i) => typeof i === "object" && i !== null);
+  if (typeof result === "object" && result !== null) {
+    for (const value of Object.values(result)) {
+      if (Array.isArray(value)) {
+        return value.filter((i) => typeof i === "object" && i !== null);
+      }
+    }
+  }
+  return [];
+}
+function deriveGearMap(items) {
+  const map = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const gid = item["id"];
+    const name = item["name"] || item["display_name"];
+    if (gid && name) map.set(String(gid), String(name));
+  }
+  return map;
+}
+async function getGearRaw(opts = {}) {
+  const config = getConfig();
+  const { athleteId, error } = resolveAthleteId(opts.athleteId, config.athleteId);
+  if (error || !athleteId) return [];
+  if (!opts.refresh && gearRawCache.has(athleteId)) {
+    return gearRawCache.get(athleteId);
+  }
+  const result = await makeIntervalsRequest(`/athlete/${athleteId}/gear`, {
+    apiKey: opts.apiKey
+  });
+  const items = itemsFromResponse(result);
+  gearRawCache.set(athleteId, items);
+  return items;
+}
+async function getGearMap(opts = {}) {
+  const items = await getGearRaw(opts);
+  return deriveGearMap(items);
+}
+async function resolveGearForActivity(activity, opts = {}) {
+  const gearId = extractGearId(activity);
+  if (!gearId) return;
+  const gearMap = await getGearMap(opts);
+  const name = gearMap.get(gearId);
+  if (name) activity["_resolved_gear_name"] = name;
+}
+async function resolveGearForActivities(activities, opts = {}) {
+  if (!activities.length) return;
+  await getGearMap(opts);
+  for (const activity of activities) {
+    if (typeof activity === "object" && activity !== null) {
+      await resolveGearForActivity(activity, opts);
+    }
+  }
+}
+var registerGearTools = (server) => {
+  server.registerTool(
+    "get_gear_list",
+    {
+      title: "Get Gear List",
+      description: "Get the gear catalog (bikes, shoes, etc.) for an athlete from Intervals.icu.\n\nReturns one line per gear item with id, type, name, and basic stats.\nThe result is cached for the MCP process lifetime; pass refresh=true to re-fetch.",
+      inputSchema: {
+        athlete_id: z.string().optional().describe("Intervals.icu athlete ID (defaults to configured ATHLETE_ID)"),
+        api_key: z.string().optional().describe("Intervals.icu API key (defaults to configured API_KEY)"),
+        refresh: z.boolean().default(false).describe("Bypass the cache and re-fetch from the API")
+      }
+    },
+    async ({ athlete_id, api_key, refresh }) => {
+      const config = getConfig();
+      const { athleteId, error } = resolveAthleteId(athlete_id, config.athleteId);
+      if (error) return textResult(error);
+      if (!athleteId) {
+        return textResult(
+          "Error: athlete_id is required (either as argument or via ATHLETE_ID)."
+        );
+      }
+      const items = await getGearRaw({ athleteId, apiKey: api_key, refresh });
+      if (!items.length) return textResult(`No gear found for athlete ${athleteId}.`);
+      let output = `Gear catalog for athlete ${athleteId}:
+
+`;
+      output += `${"ID".padEnd(14)} ${"Type".padEnd(8)} ${"Name".padEnd(32)} ${"Default".padEnd(8)} ${"Acts".padEnd(6)} ${"Dist (km)".padEnd(10)} ${"Retired".padEnd(8)}
+`;
+      output += `${"-".repeat(14)} ${"-".repeat(8)} ${"-".repeat(32)} ${"-".repeat(8)} ${"-".repeat(6)} ${"-".repeat(10)} ${"-".repeat(8)}
+`;
+      for (const it of items) {
+        const gid = String(it["id"] ?? "?");
+        const gtype = String(it["component_type"] ?? it["type"] ?? "?");
+        const name = String(it["name"] ?? "?").slice(0, 32);
+        const defaultFor = String(it["default_for_type"] || it["default_for"] || "");
+        const acts = String(it["activities"] ?? it["activity_count"] ?? "?");
+        const distM = it["distance"] ?? 0;
+        const distKm = typeof distM === "number" ? (distM / 1e3).toFixed(1) : "?";
+        const retired = it["retired"] ? "yes" : "";
+        output += `${gid.padEnd(14)} ${gtype.padEnd(8)} ${name.padEnd(32)} ${defaultFor.padEnd(8)} ${acts.padEnd(6)} ${distKm.padEnd(10)} ${retired.padEnd(8)}
+`;
+      }
+      return textResult(output);
+    }
+  );
+};
+
+// src/tools/activities.ts
+function parseActivitiesFromResult(result) {
+  if (Array.isArray(result)) {
+    return result.filter((item) => typeof item === "object" && item !== null);
+  }
+  if (typeof result === "object" && result !== null) {
+    const obj = result;
+    for (const value of Object.values(obj)) {
+      if (Array.isArray(value)) {
+        return value.filter((item) => typeof item === "object" && item !== null);
+      }
+    }
+    if (["name", "startTime", "distance"].some((key) => key in obj)) return [obj];
+  }
+  return [];
+}
+function filterNamedActivities(activities) {
+  return activities.filter(
+    (activity) => activity["name"] && activity["name"] !== "Unnamed"
+  );
+}
+async function fetchMoreActivities(athleteId, startDate, apiKey, apiLimit) {
+  const oldest = /* @__PURE__ */ new Date(`${startDate}T00:00:00`);
+  const olderStart = new Date(oldest);
+  olderStart.setDate(olderStart.getDate() - 60);
+  const olderEnd = new Date(oldest);
+  olderEnd.setDate(olderEnd.getDate() - 1);
+  const olderStartDate = toLocalDateString(olderStart);
+  const olderEndDate = toLocalDateString(olderEnd);
+  if (olderStartDate >= olderEndDate) return [];
+  const moreResult = await makeIntervalsRequest(`/athlete/${athleteId}/activities`, {
+    apiKey,
+    params: { oldest: olderStartDate, newest: olderEndDate, limit: apiLimit }
+  });
+  if (Array.isArray(moreResult)) return filterNamedActivities(moreResult);
+  return [];
+}
+function formatActivitiesResponse(activities, athleteId, includeUnnamed) {
+  if (!activities.length) {
+    if (includeUnnamed) {
+      return `No valid activities found for athlete ${athleteId} in the specified date range.`;
+    }
+    return `No named activities found for athlete ${athleteId} in the specified date range. Try with include_unnamed=true to see all activities.`;
+  }
+  let summary = "Activities:\n\n";
+  for (const activity of activities) {
+    summary += `${formatActivitySummary(activity)}
+`;
+  }
+  return summary;
+}
+var DEFAULT_STREAM_TYPES = "time,watts,heartrate,cadence,altitude,distance,velocity_smooth";
+var registerActivityTools = (server) => {
+  server.registerTool(
+    "get_activities",
+    {
+      title: "Get Activities",
+      description: "Get a list of activities for an athlete from Intervals.icu.\n\nArgs:\n    athlete_id: The Intervals.icu athlete ID (optional, uses the configured default)\n    api_key: The Intervals.icu API key (optional, uses the configured default)\n    start_date: Start date in YYYY-MM-DD format (optional, defaults to 30 days ago)\n    end_date: End date in YYYY-MM-DD format (optional, defaults to today)\n    limit: Maximum number of activities to return (optional, defaults to 10)\n    include_unnamed: Whether to include unnamed activities (optional, defaults to false)",
+      inputSchema: {
+        athlete_id: z2.string().optional(),
+        api_key: z2.string().optional(),
+        start_date: z2.string().optional(),
+        end_date: z2.string().optional(),
+        limit: z2.number().int().positive().default(10),
+        include_unnamed: z2.boolean().default(false)
+      }
+    },
+    async ({ athlete_id, api_key, start_date, end_date, limit, include_unnamed }) => {
+      const config = getConfig();
+      const { athleteId, error } = resolveAthleteId(athlete_id, config.athleteId);
+      if (error) return textResult(error);
+      const [startDate, endDate] = resolveDateParams(start_date, end_date);
+      const apiLimit = !include_unnamed ? limit * 3 : limit;
+      const result = await makeIntervalsRequest(`/athlete/${athleteId}/activities`, {
+        apiKey: api_key,
+        params: { oldest: startDate, newest: endDate, limit: apiLimit }
+      });
+      if (isApiError(result)) {
+        return textResult(`Error fetching activities: ${apiErrorMessage(result)}`);
+      }
+      if (isEmptyResult(result)) {
+        return textResult(
+          `No activities found for athlete ${athleteId} in the specified date range.`
+        );
+      }
+      let activities = parseActivitiesFromResult(result);
+      if (!activities.length) {
+        return textResult(
+          `No valid activities found for athlete ${athleteId} in the specified date range.`
+        );
+      }
+      if (!include_unnamed) {
+        activities = filterNamedActivities(activities);
+        if (activities.length < limit) {
+          const more = await fetchMoreActivities(athleteId, startDate, api_key, apiLimit);
+          activities.push(...more);
+        }
+      }
+      activities = activities.slice(0, limit);
+      await resolveGearForActivities(activities, { athleteId, apiKey: api_key });
+      return textResult(formatActivitiesResponse(activities, athleteId, include_unnamed));
+    }
+  );
+  server.registerTool(
+    "get_activity_details",
+    {
+      title: "Get Activity Details",
+      description: "Get detailed information for a specific activity from Intervals.icu.",
+      inputSchema: {
+        activity_id: z2.string().describe("The Intervals.icu activity ID"),
+        api_key: z2.string().optional()
+      }
+    },
+    async ({ activity_id, api_key }) => {
+      const result = await makeIntervalsRequest(`/activity/${activity_id}`, {
+        apiKey: api_key
+      });
+      if (isApiError(result)) {
+        return textResult(`Error fetching activity details: ${apiErrorMessage(result)}`);
+      }
+      if (isEmptyResult(result)) {
+        return textResult(`No details found for activity ${activity_id}.`);
+      }
+      const activityData = Array.isArray(result) ? result[0] : result;
+      if (typeof activityData !== "object" || activityData === null) {
+        return textResult(`Invalid activity format for activity ${activity_id}.`);
+      }
+      await resolveGearForActivity(activityData, { apiKey: api_key });
+      let detailedView = formatActivitySummary(activityData);
+      const zones = activityData["zones"];
+      if (typeof zones === "object" && zones !== null) {
+        detailedView += "\nPower Zones:\n";
+        for (const zone of zones["power"] ?? []) {
+          detailedView += `Zone ${zone["number"]}: ${zone["secondsInZone"]} seconds
+`;
+        }
+        detailedView += "\nHeart Rate Zones:\n";
+        for (const zone of zones["hr"] ?? []) {
+          detailedView += `Zone ${zone["number"]}: ${zone["secondsInZone"]} seconds
+`;
+        }
+      }
+      return textResult(detailedView);
+    }
+  );
+  server.registerTool(
+    "get_activity_intervals",
+    {
+      title: "Get Activity Intervals",
+      description: "Get interval data for a specific activity from Intervals.icu.\n\nThis endpoint returns detailed metrics for each interval in an activity, including power, heart rate,\ncadence, speed, and environmental data. It also includes grouped intervals if applicable.",
+      inputSchema: {
+        activity_id: z2.string().describe("The Intervals.icu activity ID"),
+        api_key: z2.string().optional()
+      }
+    },
+    async ({ activity_id, api_key }) => {
+      const result = await makeIntervalsRequest(`/activity/${activity_id}/intervals`, {
+        apiKey: api_key
+      });
+      if (isApiError(result)) {
+        return textResult(`Error fetching intervals: ${apiErrorMessage(result)}`);
+      }
+      if (isEmptyResult(result)) {
+        return textResult(`No interval data found for activity ${activity_id}.`);
+      }
+      if (typeof result !== "object" || Array.isArray(result) || !("icu_intervals" in result || "icu_groups" in result)) {
+        return textResult(`No interval data or unrecognized format for activity ${activity_id}.`);
+      }
+      return textResult(formatIntervals(result));
+    }
+  );
+  server.registerTool(
+    "get_activity_streams",
+    {
+      title: "Get Activity Streams",
+      description: "Get stream data for a specific activity from Intervals.icu.\n\nThis endpoint returns time-series data for an activity, including metrics like power, heart rate,\ncadence, altitude, distance, temperature, and velocity data.\n\nAvailable stream types: time, watts, heartrate, cadence, altitude, distance,\ncore_temperature, skin_temperature, velocity_smooth",
+      inputSchema: {
+        activity_id: z2.string().describe("The Intervals.icu activity ID"),
+        api_key: z2.string().optional(),
+        stream_types: z2.string().optional().describe(
+          "Comma-separated list of stream types to retrieve (optional, defaults to common types)"
+        )
+      }
+    },
+    async ({ activity_id, api_key, stream_types }) => {
+      const result = await makeIntervalsRequest(`/activity/${activity_id}/streams`, {
+        apiKey: api_key,
+        params: { types: stream_types || DEFAULT_STREAM_TYPES }
+      });
+      if (isApiError(result)) {
+        return textResult(`Error fetching activity streams: ${apiErrorMessage(result)}`);
+      }
+      const streams = Array.isArray(result) ? result : [];
+      if (!streams.length) {
+        return textResult(`No stream data found for activity ${activity_id}.`);
+      }
+      let summary = `Activity Streams for ${activity_id}:
+
+`;
+      for (const stream of streams) {
+        const streamType = stream["type"] ?? "unknown";
+        const streamName = stream["name"] ?? streamType;
+        const data = stream["data"] ?? [];
+        const valueType = stream["valueType"] ?? "";
+        summary += `Stream: ${streamName} (${streamType})
+`;
+        summary += `  Value Type: ${valueType}
+`;
+        summary += `  Data Points: ${data.length}
+`;
+        if (data.length > 0) {
+          if (data.length <= 10) {
+            summary += `  Values: ${JSON.stringify(data)}
+`;
+          } else {
+            summary += `  First 5 values: ${JSON.stringify(data.slice(0, 5))}
+`;
+            summary += `  Last 5 values: ${JSON.stringify(data.slice(-5))}
+`;
+          }
+        }
+        summary += "\n";
+      }
+      return textResult(summary);
+    }
+  );
+  server.registerTool(
+    "get_activity_messages",
+    {
+      title: "Get Activity Messages",
+      description: "Get messages (notes/comments) for a specific activity from Intervals.icu.",
+      inputSchema: {
+        activity_id: z2.string().describe("The Intervals.icu activity ID"),
+        api_key: z2.string().optional()
+      }
+    },
+    async ({ activity_id, api_key }) => {
+      const result = await makeIntervalsRequest(`/activity/${activity_id}/messages`, {
+        apiKey: api_key
+      });
+      if (isApiError(result)) {
+        return textResult(`Error fetching activity messages: ${apiErrorMessage(result)}`);
+      }
+      const messages = Array.isArray(result) ? result : [];
+      if (!messages.length) {
+        return textResult(`No messages found for activity ${activity_id}.`);
+      }
+      let output = `Messages for activity ${activity_id}:
+
+`;
+      for (const msg of messages) {
+        output += `${formatActivityMessage(msg)}
+
+`;
+      }
+      return textResult(output);
+    }
+  );
+  server.registerTool(
+    "add_activity_message",
+    {
+      title: "Add Activity Message",
+      description: "Add a message (note/comment) to an activity on Intervals.icu.",
+      inputSchema: {
+        activity_id: z2.string().describe("The Intervals.icu activity ID"),
+        content: z2.string().describe("The message text to add"),
+        api_key: z2.string().optional()
+      }
+    },
+    async ({ activity_id, content, api_key }) => {
+      const result = await makeIntervalsRequest(`/activity/${activity_id}/messages`, {
+        apiKey: api_key,
+        method: "POST",
+        data: { content }
+      });
+      if (isApiError(result)) {
+        return textResult(`Error adding message to activity: ${apiErrorMessage(result)}`);
+      }
+      if (typeof result !== "object" || result === null || Array.isArray(result)) {
+        return textResult("Error: Unexpected response when adding message.");
+      }
+      const msgId = result["id"];
+      if (msgId != null) {
+        return textResult(
+          `Successfully added message (ID: ${msgId}) to activity ${activity_id}.`
+        );
+      }
+      return textResult(
+        `Message appears to have been added to activity ${activity_id}, but no ID was returned. Please verify manually.`
+      );
+    }
+  );
+};
+
+// src/tools/customItems.ts
+import { z as z3 } from "zod";
+var ContentSchema = z3.union([z3.record(z3.unknown()), z3.string()]).optional().transform((val, ctx) => {
+  if (val == null) return null;
+  if (typeof val !== "string") return val;
+  try {
+    return JSON.parse(val);
+  } catch {
+    ctx.addIssue({ code: z3.ZodIssueCode.custom, message: "content must be valid JSON when passed as a string." });
+    return z3.NEVER;
+  }
+});
+var ITEM_TYPE_DESCRIPTION = "Type of custom item (e.g. FITNESS_CHART, TRACE_CHART, INPUT_FIELD, ACTIVITY_FIELD, INTERVAL_FIELD, ACTIVITY_STREAM, ACTIVITY_CHART, ACTIVITY_HISTOGRAM, ACTIVITY_HEATMAP, ACTIVITY_MAP, ACTIVITY_PANEL, ZONES)";
+var CONTENT_DESCRIPTION = 'Configuration content for the custom item as an object (optional). Important enum values:\n- "type" field for INPUT_FIELD/ACTIVITY_FIELD: must be "numeric", "text", or "select" (NOT "number")\n- "aggregate" field: must be "MIN", "SUM", "MAX", or "AVERAGE" (NOT "AVG")';
+var registerCustomItemTools = (server) => {
+  server.registerTool(
+    "get_custom_items",
+    {
+      title: "Get Custom Items",
+      description: "Get custom items (charts, custom fields, zones, etc.) for an athlete from Intervals.icu.",
+      inputSchema: {
+        athlete_id: z3.string().optional(),
+        api_key: z3.string().optional()
+      }
+    },
+    async ({ athlete_id, api_key }) => {
+      const config = getConfig();
+      const { athleteId, error } = resolveAthleteId(athlete_id, config.athleteId);
+      if (error) return textResult(error);
+      const result = await makeIntervalsRequest(`/athlete/${athleteId}/custom-item`, {
+        apiKey: api_key
+      });
+      if (isApiError(result)) {
+        return textResult(`Error fetching custom items: ${apiErrorMessage(result)}`);
+      }
+      if (result == null || Array.isArray(result) && result.length === 0) {
+        return textResult(`No custom items found for athlete ${athleteId}.`);
+      }
+      let output = "Custom Items:\n\n";
+      for (const item of result) {
+        if (typeof item !== "object" || item === null) continue;
+        output += `- ID: ${item["id"]}
+`;
+        output += `  Name: ${item["name"] ?? "N/A"}
+`;
+        output += `  Type: ${item["type"] ?? "N/A"}
+`;
+        if (item["description"]) output += `  Description: ${item["description"]}
+`;
+        output += "\n";
+      }
+      return textResult(output);
+    }
+  );
+  server.registerTool(
+    "get_custom_item_by_id",
+    {
+      title: "Get Custom Item By ID",
+      description: "Get detailed information for a specific custom item from Intervals.icu.",
+      inputSchema: {
+        item_id: z3.number().int().describe("The custom item ID"),
+        athlete_id: z3.string().optional(),
+        api_key: z3.string().optional()
+      }
+    },
+    async ({ item_id, athlete_id, api_key }) => {
+      const config = getConfig();
+      const { athleteId, error } = resolveAthleteId(athlete_id, config.athleteId);
+      if (error) return textResult(error);
+      const result = await makeIntervalsRequest(`/athlete/${athleteId}/custom-item/${item_id}`, {
+        apiKey: api_key
+      });
+      if (isApiError(result)) {
+        return textResult(`Error fetching custom item: ${apiErrorMessage(result)}`);
+      }
+      if (typeof result !== "object" || result === null || Array.isArray(result)) {
+        return textResult(`No custom item found with ID ${item_id}.`);
+      }
+      return textResult(formatCustomItemDetails(result));
+    }
+  );
+  server.registerTool(
+    "create_custom_item",
+    {
+      title: "Create Custom Item",
+      description: "Create a new custom item for an athlete on Intervals.icu.",
+      inputSchema: {
+        name: z3.string().describe("Name of the custom item"),
+        item_type: z3.string().describe(ITEM_TYPE_DESCRIPTION),
+        athlete_id: z3.string().optional(),
+        api_key: z3.string().optional(),
+        description: z3.string().optional().describe("Description of the custom item (optional)"),
+        content: ContentSchema.describe(CONTENT_DESCRIPTION),
+        visibility: z3.string().optional().describe("Visibility setting: PRIVATE, FOLLOWERS, or PUBLIC (optional)")
+      }
+    },
+    async ({ name, item_type, athlete_id, api_key, description, content, visibility }) => {
+      const config = getConfig();
+      const { athleteId, error } = resolveAthleteId(athlete_id, config.athleteId);
+      if (error) return textResult(error);
+      const data = { name, type: item_type };
+      if (description != null) data["description"] = description;
+      if (content != null) data["content"] = content;
+      if (visibility != null) data["visibility"] = visibility;
+      const result = await makeIntervalsRequest(`/athlete/${athleteId}/custom-item`, {
+        apiKey: api_key,
+        data,
+        method: "POST"
+      });
+      if (isApiError(result)) {
+        return textResult(`Error creating custom item: ${apiErrorMessage(result)}`);
+      }
+      if (typeof result !== "object" || result === null || Array.isArray(result)) {
+        return textResult("Error: Unexpected response when creating custom item.");
+      }
+      return textResult(
+        `Successfully created custom item:
+
+${formatCustomItemDetails(result)}`
+      );
+    }
+  );
+  server.registerTool(
+    "update_custom_item",
+    {
+      title: "Update Custom Item",
+      description: "Update an existing custom item for an athlete on Intervals.icu.",
+      inputSchema: {
+        item_id: z3.number().int().describe("The custom item ID to update"),
+        athlete_id: z3.string().optional(),
+        api_key: z3.string().optional(),
+        name: z3.string().optional().describe("New name for the custom item (optional)"),
+        item_type: z3.string().optional().describe("New type for the custom item (optional)"),
+        description: z3.string().optional().describe("New description for the custom item (optional)"),
+        content: ContentSchema.describe(CONTENT_DESCRIPTION),
+        visibility: z3.string().optional().describe("New visibility setting: PRIVATE, FOLLOWERS, or PUBLIC (optional)")
+      }
+    },
+    async ({ item_id, athlete_id, api_key, name, item_type, description, content, visibility }) => {
+      const config = getConfig();
+      const { athleteId, error } = resolveAthleteId(athlete_id, config.athleteId);
+      if (error) return textResult(error);
+      const data = {};
+      if (name != null) data["name"] = name;
+      if (item_type != null) data["type"] = item_type;
+      if (description != null) data["description"] = description;
+      if (content != null) data["content"] = content;
+      if (visibility != null) data["visibility"] = visibility;
+      const result = await makeIntervalsRequest(`/athlete/${athleteId}/custom-item/${item_id}`, {
+        apiKey: api_key,
+        data,
+        method: "PUT"
+      });
+      if (isApiError(result)) {
+        return textResult(`Error updating custom item: ${apiErrorMessage(result)}`);
+      }
+      if (typeof result !== "object" || result === null || Array.isArray(result)) {
+        return textResult("Error: Unexpected response when updating custom item.");
+      }
+      return textResult(
+        `Successfully updated custom item:
+
+${formatCustomItemDetails(result)}`
+      );
+    }
+  );
+  server.registerTool(
+    "delete_custom_item",
+    {
+      title: "Delete Custom Item",
+      description: "Delete a custom item for an athlete from Intervals.icu.",
+      inputSchema: {
+        item_id: z3.number().int().describe("The custom item ID to delete"),
+        athlete_id: z3.string().optional(),
+        api_key: z3.string().optional()
+      }
+    },
+    async ({ item_id, athlete_id, api_key }) => {
+      const config = getConfig();
+      const { athleteId, error } = resolveAthleteId(athlete_id, config.athleteId);
+      if (error) return textResult(error);
+      const result = await makeIntervalsRequest(`/athlete/${athleteId}/custom-item/${item_id}`, {
+        apiKey: api_key,
+        method: "DELETE"
+      });
+      if (isApiError(result)) {
+        return textResult(`Error deleting custom item: ${apiErrorMessage(result)}`);
+      }
+      return textResult(`Successfully deleted custom item ${item_id}.`);
+    }
+  );
+};
+
+// src/tools/events.ts
+import { z as z5 } from "zod";
+
+// src/utils/types.ts
+import { z as z4 } from "zod";
+var WorkoutTargetSchema = z4.enum(["AUTO", "POWER", "HR", "PACE"]);
+var HrTargetSchema = z4.enum(["lap", "1s", "3s", "10s", "30s"]);
+var IntensitySchema = z4.enum([
+  "active",
+  "rest",
+  "warmup",
+  "cooldown",
+  "recovery",
+  "interval",
+  "other"
+]);
+var PaceUnitsSchema = z4.enum([
+  "SECS_100M",
+  "SECS_100Y",
+  "MINS_KM",
+  "MINS_MILE",
+  "SECS_500M"
+]);
+var ValueUnitsSchema = z4.enum([
+  "%mmp",
+  "%hr",
+  "%lthr",
+  "%pace",
+  "power_zone",
+  "hr_zone",
+  "pace_zone",
+  "w",
+  "%ftp",
+  "cadence",
+  "MINS_KM",
+  "MINS_MILE",
+  "SECS_100M",
+  "SECS_500M"
+]);
+var ValueSchema = z4.object({
+  value: z4.number().optional(),
+  start: z4.number().optional(),
+  end: z4.number().optional(),
+  units: ValueUnitsSchema.optional(),
+  target: HrTargetSchema.optional()
+});
+var StepSchema = z4.lazy(
+  () => z4.object({
+    text: z4.string().optional(),
+    text_locale: z4.record(z4.string()).optional(),
+    duration: z4.number().optional(),
+    distance: z4.number().optional(),
+    until_lap_press: z4.boolean().optional(),
+    reps: z4.number().optional(),
+    warmup: z4.boolean().optional(),
+    cooldown: z4.boolean().optional(),
+    intensity: IntensitySchema.optional(),
+    steps: z4.array(StepSchema).optional(),
+    ramp: z4.boolean().optional(),
+    freeride: z4.boolean().optional(),
+    maxeffort: z4.boolean().optional(),
+    power: ValueSchema.optional(),
+    hr: ValueSchema.optional(),
+    pace: ValueSchema.optional(),
+    cadence: ValueSchema.optional(),
+    hidepower: z4.boolean().optional(),
+    _power: ValueSchema.optional(),
+    _hr: ValueSchema.optional(),
+    _pace: ValueSchema.optional(),
+    _distance: z4.number().optional()
+  })
+);
+var WorkoutDocSchema = z4.object({
+  description: z4.string().optional(),
+  description_locale: z4.record(z4.string()).optional(),
+  duration: z4.number().optional(),
+  distance: z4.number().optional(),
+  ftp: z4.number().optional(),
+  lthr: z4.number().optional(),
+  threshold_pace: z4.number().optional(),
+  // meters/sec
+  pace_units: PaceUnitsSchema.optional(),
+  sport_settings: z4.record(z4.unknown()).optional(),
+  category: z4.string().optional(),
+  target: WorkoutTargetSchema.optional(),
+  steps: z4.array(StepSchema).optional(),
+  zone_times: z4.array(z4.union([z4.number(), z4.unknown()])).optional(),
+  options: z4.record(z4.string()).optional(),
+  locales: z4.array(z4.string()).optional()
+});
+function floatToStr(value) {
+  return Number.isInteger(value) ? String(value) : String(value);
+}
+var PERCENT_UNITS = /* @__PURE__ */ new Set(["%hr", "%mmp", "%lthr", "%pace", "%ftp"]);
+var ZONE_UNITS = /* @__PURE__ */ new Set(["power_zone", "hr_zone", "pace_zone"]);
+var UNITS_LABEL = {
+  "%hr": "HR",
+  hr_zone: "HR",
+  "%mmp": "MMP",
+  "%lthr": "LTHR",
+  "%pace": "Pace",
+  pace_zone: "Pace",
+  "%ftp": "ftp",
+  power_zone: "W",
+  cadence: "Cadence"
+};
+function formatScalar(value, units) {
+  if (units && PERCENT_UNITS.has(units)) return `${floatToStr(value)}%`;
+  if (units && ZONE_UNITS.has(units)) return `Z${floatToStr(value)}`;
+  if (units === "w") return `${floatToStr(value)}W`;
+  if (units === "cadence") return `${floatToStr(value)}rpm`;
+  return floatToStr(value);
+}
+function formatValue(v) {
+  let val = "";
+  if (v.start != null && v.end != null) {
+    val += `${formatScalar(v.start, v.units)}-${formatScalar(v.end, v.units)} `;
+  }
+  if (v.value != null) {
+    val += `${formatScalar(v.value, v.units)} `;
+  }
+  if (v.units != null) {
+    const label = UNITS_LABEL[v.units] ?? "";
+    if (label) val += `${label} `;
+  }
+  if (v.target != null) {
+    val += `hr=${v.target} `;
+  }
+  return val.trim();
+}
+function formatDuration(durationSecs) {
+  let remaining = durationSecs;
+  let val = "";
+  if (remaining >= 3600) {
+    val += `${Math.floor(remaining / 3600)}h`;
+    remaining %= 3600;
+  }
+  if (remaining > 100 || remaining === 60) {
+    val += `${Math.floor(remaining / 60)}m`;
+    remaining %= 60;
+  }
+  if (remaining > 0) {
+    val += `${remaining}s`;
+  }
+  return val;
+}
+function formatDistance(distance) {
+  if (distance < 1e3) return `${floatToStr(distance)}mtr`;
+  return `${floatToStr(distance / 1e3)}km`;
+}
+function formatStep(step, nested = false) {
+  let val = "";
+  if (step.reps != null) {
+    val += `
+${step.reps}x `;
+  } else {
+    if (!nested && step.warmup) val += "\nWarmup\n";
+    if (!nested && step.cooldown) val += "\nCooldown\n";
+    if (step.duration != null) {
+      val += `- ${formatDuration(step.duration)} `;
+    } else if (step.distance != null) {
+      val += `- ${formatDistance(step.distance)} `;
+    }
+    if (step.freeride) val += "freeride ";
+    if (step.maxeffort) val += "maxeffort ";
+    if (step.ramp) val += "ramp ";
+    if (step.hidepower) val += "hidepower ";
+    if (step.intensity != null) val += `intensity=${step.intensity} `;
+    if (step.power) val += `${formatValue(step.power)} `;
+    if (step.hr) val += `${formatValue(step.hr)} `;
+    if (step.pace) val += `${formatValue(step.pace)} `;
+    if (step.cadence) val += `${formatValue(step.cadence)} `;
+  }
+  if (step.text != null) {
+    val += `${step.text} `;
+  }
+  if (step.reps != null && step.steps != null) {
+    for (const child of step.steps) {
+      val += `
+${formatStep(child, true)}`;
+    }
+    val += "\n";
+  } else if (!nested && (step.warmup || step.cooldown)) {
+    val += "\n";
+  }
+  return val;
+}
+function formatWorkoutDoc(doc) {
+  let val = "";
+  if (doc.description != null) {
+    val += `${doc.description}
+`;
+  }
+  if (doc.steps != null) {
+    for (const step of doc.steps) {
+      val += `${formatStep(step)}
+`;
+    }
+  }
+  return val;
+}
+
+// src/tools/events.ts
+var WORKOUT_DOC_HELP = `Post event for an athlete to Intervals.icu. If event_id is provided, the event will be updated instead of created.
+
+Example:
+    "workout_doc": {
+        "description": "High-intensity workout for increasing VO2 max",
+        "steps": [
+            {"power": {"value": 80, "units": "%ftp"}, "duration": 900, "warmup": true},
+            {"reps": 2, "text": "High-intensity intervals", "steps": [
+                {"power": {"value": 110, "units": "%ftp"}, "distance": 500, "text": "High-intensity"},
+                {"power": {"value": 80, "units": "%ftp"}, "duration": 90, "text": "Recovery"}
+            ]},
+            {"power": {"value": 80, "units": "%ftp"}, "duration": 600, "cooldown": true},
+            {"text": ""}
+        ]
+    }
+
+Step properties:
+    distance: Distance of step in meters
+        {"distance": 5000}
+    duration: Duration of step in seconds
+        {"duration": 1800}
+    power/hr/pace/cadence: Define step intensity
+        Percentage of FTP: {"power": {"value": 80, "units": "%ftp"}}
+        Absolute power: {"power": {"value": 200, "units": "w"}}
+        Heart rate: {"hr": {"value": 75, "units": "%hr"}}
+        Heart rate (LTHR): {"hr": {"value": 85, "units": "%lthr"}}
+        Cadence: {"cadence": {"value": 90, "units": "cadence"}}
+        Pace by ftp: {"pace": {"value": 80, "units": "%pace"}}
+        Pace by zone: {"pace": {"value": 2, "units": "pace_zone"}}
+        Zone by power: {"power": {"value": 2, "units": "power_zone"}}
+        Zone by heart rate: {"hr": {"value": 2, "units": "hr_zone"}}
+    Ranges: Specify ranges for power, heart rate, or cadence:
+        {"power": {"start": 80, "end": 90, "units": "%ftp"}}
+    Ramps: Instead of a range, indicate a gradual change in intensity (useful for ERG workouts):
+        {"ramp": true, "power": {"start": 80, "end": 90, "units": "%ftp"}}
+    Repeats: include the reps property and add nested steps
+        {"reps": 3,
+         "steps": [
+            {"power": {"value": 110, "units": "%ftp"}, "distance": 500, "text": "High-intensity"},
+            {"power": {"value": 80, "units": "%ftp"}, "duration": 90, "text": "Recovery"}
+        ]}
+    Free Ride: Include freeride to indicate a segment without ERG control, optionally with a suggested power range:
+        {"freeride": true, "power": {"value": 80, "units": "%ftp"}}
+    Comments and Labels: Add descriptive text to label steps:
+        {"text": "Warmup"}
+
+How to use steps:
+- Set distance or duration as appropriate for step
+- Use "reps" with nested steps to define repeat intervals (as in example above)
+- Define one of "power", "hr" or "pace" to define step intensity`;
+function prepareEventData(name, workoutType, startDate, workoutDoc, movingTime, distance) {
+  const resolvedWorkoutType = resolveActivityType(name, workoutType);
+  return {
+    start_date_local: `${startDate}T00:00:00`,
+    category: "WORKOUT",
+    name,
+    description: workoutDoc ? formatWorkoutDoc(workoutDoc) : null,
+    type: resolvedWorkoutType,
+    moving_time: movingTime,
+    distance
+  };
+}
+async function handleEventResponse(result, action, athleteId, startDate) {
+  if (isApiError(result)) {
+    return `Error ${action} event: ${apiErrorMessage(result)}`;
+  }
+  if (result == null || typeof result === "object" && !Array.isArray(result) && Object.keys(result).length === 0) {
+    return `No events ${action} for athlete ${athleteId}.`;
+  }
+  if (typeof result === "object" && !Array.isArray(result)) {
+    return `Successfully ${action} event id: ${result["id"]}`;
+  }
+  return `Event ${action} successfully at ${startDate}`;
+}
+async function createOrUpdateEventRequest(athleteId, apiKey, eventData, startDate, eventId) {
+  let url = `/athlete/${athleteId}/events`;
+  if (eventId) url += `/${eventId}`;
+  const result = await makeIntervalsRequest(url, {
+    apiKey,
+    data: eventData,
+    method: eventId ? "PUT" : "POST"
+  });
+  const action = eventId ? "updated" : "created";
+  return handleEventResponse(result, action, athleteId, startDate);
+}
+var registerEventTools = (server) => {
+  server.registerTool(
+    "get_events",
+    {
+      title: "Get Events",
+      description: "Get events for an athlete from Intervals.icu.\n\nArgs:\n    athlete_id: The Intervals.icu athlete ID (optional, uses the configured default)\n    api_key: The Intervals.icu API key (optional, uses the configured default)\n    start_date: Start date in YYYY-MM-DD format (optional, defaults to today)\n    end_date: End date in YYYY-MM-DD format (optional, defaults to 30 days from today)",
+      inputSchema: {
+        athlete_id: z5.string().optional(),
+        api_key: z5.string().optional(),
+        start_date: z5.string().optional(),
+        end_date: z5.string().optional()
+      }
+    },
+    async ({ athlete_id, api_key, start_date, end_date }) => {
+      const config = getConfig();
+      const { athleteId, error } = resolveAthleteId(athlete_id, config.athleteId);
+      if (error) return textResult(error);
+      const oldest = start_date || getDefaultEndDate();
+      const newest = end_date || getDefaultFutureEndDate();
+      const result = await makeIntervalsRequest(`/athlete/${athleteId}/events`, {
+        apiKey: api_key,
+        params: { oldest, newest }
+      });
+      if (isApiError(result)) {
+        return textResult(`Error fetching events: ${apiErrorMessage(result)}`);
+      }
+      const events = Array.isArray(result) ? result : [];
+      if (!events.length) {
+        return textResult(
+          `No events found for athlete ${athleteId} in the specified date range.`
+        );
+      }
+      let summary = "Events:\n\n";
+      for (const event of events) {
+        if (typeof event !== "object" || event === null) continue;
+        summary += `${formatEventSummary(event)}
+
+`;
+      }
+      return textResult(summary);
+    }
+  );
+  server.registerTool(
+    "get_event_by_id",
+    {
+      title: "Get Event By ID",
+      description: "Get detailed information for a specific event from Intervals.icu.",
+      inputSchema: {
+        event_id: z5.string().describe("The Intervals.icu event ID"),
+        athlete_id: z5.string().optional(),
+        api_key: z5.string().optional()
+      }
+    },
+    async ({ event_id, athlete_id, api_key }) => {
+      const config = getConfig();
+      const { athleteId, error } = resolveAthleteId(athlete_id, config.athleteId);
+      if (error) return textResult(error);
+      const result = await makeIntervalsRequest(`/athlete/${athleteId}/event/${event_id}`, {
+        apiKey: api_key
+      });
+      if (isApiError(result)) {
+        return textResult(`Error fetching event details: ${apiErrorMessage(result)}`);
+      }
+      if (result == null || Array.isArray(result) || Object.keys(result).length === 0) {
+        return textResult(`No details found for event ${event_id}.`);
+      }
+      return textResult(formatEventDetails(result));
+    }
+  );
+  server.registerTool(
+    "delete_event",
+    {
+      title: "Delete Event",
+      description: "Delete an event for an athlete from Intervals.icu.",
+      inputSchema: {
+        event_id: z5.string().describe("The Intervals.icu event ID"),
+        athlete_id: z5.string().optional(),
+        api_key: z5.string().optional()
+      }
+    },
+    async ({ event_id, athlete_id, api_key }) => {
+      const config = getConfig();
+      const { athleteId, error } = resolveAthleteId(athlete_id, config.athleteId);
+      if (error) return textResult(error);
+      if (!event_id) return textResult("Error: No event ID provided.");
+      const result = await makeIntervalsRequest(`/athlete/${athleteId}/events/${event_id}`, {
+        apiKey: api_key,
+        method: "DELETE"
+      });
+      if (isApiError(result)) {
+        return textResult(`Error deleting event: ${apiErrorMessage(result)}`);
+      }
+      return textResult(JSON.stringify(result, null, 2));
+    }
+  );
+  server.registerTool(
+    "delete_events_by_date_range",
+    {
+      title: "Delete Events By Date Range",
+      description: "Delete events for an athlete from Intervals.icu in the specified date range.",
+      inputSchema: {
+        start_date: z5.string().describe("Start date in YYYY-MM-DD format"),
+        end_date: z5.string().describe("End date in YYYY-MM-DD format"),
+        athlete_id: z5.string().optional(),
+        api_key: z5.string().optional()
+      }
+    },
+    async ({ start_date, end_date, athlete_id, api_key }) => {
+      const config = getConfig();
+      const { athleteId, error } = resolveAthleteId(athlete_id, config.athleteId);
+      if (error) return textResult(error);
+      let oldest, newest;
+      try {
+        oldest = validateDate(start_date);
+        newest = validateDate(end_date);
+      } catch (e) {
+        return textResult(`Error deleting events: ${e.message}`);
+      }
+      const fetchResult = await makeIntervalsRequest(`/athlete/${athleteId}/events`, {
+        apiKey: api_key,
+        params: { oldest, newest }
+      });
+      if (isApiError(fetchResult)) {
+        return textResult(`Error deleting events: ${apiErrorMessage(fetchResult)}`);
+      }
+      const events = Array.isArray(fetchResult) ? fetchResult : [];
+      const failedEvents = [];
+      for (const event of events) {
+        const deleteResult = await makeIntervalsRequest(
+          `/athlete/${athleteId}/events/${event["id"]}`,
+          { apiKey: api_key, method: "DELETE" }
+        );
+        if (isApiError(deleteResult)) failedEvents.push(event["id"]);
+      }
+      const deletedCount = events.length - failedEvents.length;
+      return textResult(
+        `Deleted ${deletedCount} events. Failed to delete ${failedEvents.length} events: ${JSON.stringify(failedEvents)}`
+      );
+    }
+  );
+  server.registerTool(
+    "add_or_update_event",
+    {
+      title: "Add Or Update Event",
+      description: WORKOUT_DOC_HELP,
+      inputSchema: {
+        workout_type: z5.string().describe("Workout type (e.g. Ride, Run, Swim, Walk, Row)"),
+        name: z5.string().describe("Name of the activity"),
+        athlete_id: z5.string().optional(),
+        api_key: z5.string().optional(),
+        event_id: z5.string().optional().describe("The Intervals.icu event ID (optional; if set the event is updated)"),
+        start_date: z5.string().optional().describe("Start date in YYYY-MM-DD format (optional, defaults to today)"),
+        workout_doc: WorkoutDocSchema.optional().describe(
+          "Steps as a list of step objects (optional, needed to define workout steps)"
+        ),
+        moving_time: z5.number().nullable().optional().describe("Total expected moving time of the workout in seconds (optional)"),
+        distance: z5.number().nullable().optional().describe("Total expected distance of the workout in meters (optional)")
+      }
+    },
+    async ({
+      workout_type,
+      name,
+      athlete_id,
+      api_key,
+      event_id,
+      start_date,
+      workout_doc,
+      moving_time,
+      distance
+    }) => {
+      const config = getConfig();
+      const { athleteId, error } = resolveAthleteId(athlete_id, config.athleteId);
+      if (error) return textResult(error);
+      const startDate = start_date || getDefaultEndDate();
+      try {
+        const validatedDate = validateDate(startDate);
+        const eventData = prepareEventData(
+          name,
+          workout_type,
+          validatedDate,
+          workout_doc,
+          moving_time ?? null,
+          distance ?? null
+        );
+        return textResult(
+          await createOrUpdateEventRequest(
+            athleteId,
+            api_key,
+            eventData,
+            validatedDate,
+            event_id
+          )
+        );
+      } catch (e) {
+        return textResult(`Error: ${e.message}`);
+      }
+    }
+  );
+  server.registerTool(
+    "add_or_update_note",
+    {
+      title: "Add Or Update Note",
+      description: "Add or update a plain text note (category NOTE) on the Intervals.icu calendar.",
+      inputSchema: {
+        name: z5.string().describe("Title of the note"),
+        description: z5.string().describe("Plain text content of the note"),
+        start_date: z5.string().optional().describe("Date in YYYY-MM-DD format (optional, defaults to today)"),
+        color: z5.string().optional().describe("Color of the note (e.g. green, orange, red, blue)"),
+        athlete_id: z5.string().optional(),
+        api_key: z5.string().optional(),
+        event_id: z5.string().optional().describe("The Intervals.icu event ID (optional, for updates)")
+      }
+    },
+    async ({ name, description, start_date, color, athlete_id, api_key, event_id }) => {
+      const config = getConfig();
+      const { athleteId, error } = resolveAthleteId(athlete_id, config.athleteId);
+      if (error) return textResult(error);
+      const startDate = start_date || getDefaultEndDate();
+      try {
+        const validatedDate = validateDate(startDate);
+        const eventData = {
+          category: "NOTE",
+          name,
+          description,
+          start_date_local: `${validatedDate}T00:00:00`,
+          color: color ?? "green"
+        };
+        return textResult(
+          await createOrUpdateEventRequest(
+            athleteId,
+            api_key,
+            eventData,
+            validatedDate,
+            event_id
+          )
+        );
+      } catch (e) {
+        return textResult(`Error: ${e.message}`);
+      }
+    }
+  );
+};
+
+// src/tools/powerCurves.ts
+import { z as z6 } from "zod";
+var DEFAULT_DURATIONS = [5, 15, 30, 60, 120, 300, 600, 1200, 3600];
+function buildCurvesParam(thisSeason, lastSeason, startDate, endDate) {
+  const curves = [];
+  if (thisSeason) curves.push("s0");
+  if (lastSeason) curves.push("s1");
+  if (startDate && endDate) curves.push(`r.${startDate}.${endDate}`);
+  return curves;
+}
+function validateDates(startDate, endDate) {
+  if (!startDate !== !endDate) {
+    return "Error: Both start_date and end_date must be provided together for a custom date range.";
+  }
+  if (startDate && endDate) {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(startDate) || !/^\d{4}-\d{2}-\d{2}$/.test(endDate)) {
+      return "Error: Dates must be in YYYY-MM-DD format.";
+    }
+    if (startDate >= endDate) return "Error: start_date must be before end_date.";
+  }
+  return null;
+}
+function extractCurveData(curve, durations, includeNormalised) {
+  const secs = curve["secs"] ?? [];
+  const values = curve["values"] ?? [];
+  const activityIds = curve["activity_id"] ?? [];
+  const wattsPerKg = curve["watts_per_kg"] ?? [];
+  const wkgActivityIds = curve["wkg_activity_id"] ?? [];
+  const secToIdx = /* @__PURE__ */ new Map();
+  secs.forEach((s, i) => secToIdx.set(s, i));
+  const dataPoints = [];
+  for (const dur of durations) {
+    const idx = secToIdx.get(dur);
+    if (idx === void 0 || idx >= values.length) continue;
+    const point = {
+      secs: dur,
+      watts: values[idx] ?? null,
+      activity_id: idx < activityIds.length && activityIds[idx] != null ? activityIds[idx] : ""
+    };
+    if (includeNormalised && idx < wattsPerKg.length) {
+      point.watts_per_kg = wattsPerKg[idx] != null ? Math.round(wattsPerKg[idx] * 100) / 100 : void 0;
+      point.wkg_activity_id = idx < wkgActivityIds.length && wkgActivityIds[idx] != null ? wkgActivityIds[idx] : "";
+    }
+    dataPoints.push(point);
+  }
+  return {
+    id: String(curve["id"] ?? ""),
+    label: String(curve["label"] ?? curve["id"] ?? ""),
+    start: String(curve["start_date_local"] ?? ""),
+    end: String(curve["end_date_local"] ?? ""),
+    data_points: dataPoints
+  };
+}
+var registerPowerCurveTools = (server) => {
+  server.registerTool(
+    "get_athlete_power_curves",
+    {
+      title: "Get Athlete Power Curves",
+      description: "Get power curves for an athlete from Intervals.icu.\n\nReturns best power output for selected durations across specified time periods.\nUses FFT power computation. Power values are in watts.",
+      inputSchema: {
+        activity_type: z6.string().default("Ride").describe('Activity type (e.g. "Ride", "Run", "VirtualRide")'),
+        durations: z6.array(z6.number().int()).optional().describe("Durations in seconds to include (defaults to [5, 15, 30, 60, 120, 300, 600, 1200, 3600])"),
+        indoor_outdoor: z6.string().optional().describe('Filter by location \u2014 "indoor" or "outdoor". Omit for no filtering.'),
+        start_date: z6.string().optional().describe("Start date (YYYY-MM-DD) for custom date range curve. Must be used with end_date."),
+        end_date: z6.string().optional().describe("End date (YYYY-MM-DD) for custom date range curve. Must be used with start_date."),
+        this_season: z6.boolean().default(true).describe("Include this season's curve"),
+        last_season: z6.boolean().default(true).describe("Include last season's curve"),
+        include_normalised: z6.boolean().default(true).describe("Include weight-normalised W/kg values"),
+        athlete_id: z6.string().optional(),
+        api_key: z6.string().optional()
+      }
+    },
+    async ({
+      activity_type,
+      durations,
+      indoor_outdoor,
+      start_date,
+      end_date,
+      this_season,
+      last_season,
+      include_normalised,
+      athlete_id,
+      api_key
+    }) => {
+      const config = getConfig();
+      const { athleteId, error } = resolveAthleteId(athlete_id, config.athleteId);
+      if (error) return textResult(error);
+      const durs = durations ?? DEFAULT_DURATIONS;
+      if (indoor_outdoor && !["indoor", "outdoor"].includes(indoor_outdoor)) {
+        return textResult("Error: indoor_outdoor must be 'indoor', 'outdoor', or omitted.");
+      }
+      const dateError = validateDates(start_date, end_date);
+      if (dateError) return textResult(dateError);
+      const curves = buildCurvesParam(this_season, last_season, start_date, end_date);
+      if (!curves.length) {
+        return textResult(
+          "Error: At least one curve must be selected (this_season, last_season, or a date range)."
+        );
+      }
+      const params = {
+        curves,
+        type: activity_type,
+        includeRanks: false
+      };
+      if (indoor_outdoor) {
+        params["filters"] = JSON.stringify([
+          { field_id: "indoor", value: indoor_outdoor, id: 1 }
+        ]);
+      }
+      const result = await makeIntervalsRequest(`/athlete/${athleteId}/power-curves`, {
+        apiKey: api_key,
+        params
+      });
+      if (isApiError(result)) {
+        return textResult(`Error fetching power curves: ${apiErrorMessage(result)}`);
+      }
+      let curveList = [];
+      if (typeof result === "object" && result !== null && !Array.isArray(result)) {
+        curveList = result["list"] ?? [];
+      } else if (Array.isArray(result)) {
+        curveList = result;
+      }
+      if (!curveList.length) {
+        return textResult(`No power curve data found for athlete ${athleteId} (${activity_type}).`);
+      }
+      const extracted = curveList.filter((c) => typeof c === "object" && c !== null).map((c) => extractCurveData(c, durs, include_normalised));
+      if (!extracted.length) {
+        return textResult(`No power curve data found for athlete ${athleteId} (${activity_type}).`);
+      }
+      return textResult(formatPowerCurves(extracted, activity_type, include_normalised));
+    }
+  );
+};
+
+// src/tools/wellness.ts
+import { z as z7 } from "zod";
+var registerWellnessTools = (server) => {
+  server.registerTool(
+    "get_wellness_data",
+    {
+      title: "Get Wellness Data",
+      description: "Get wellness data for an athlete from Intervals.icu.\n\nBy default returns standard wellness fields (training metrics, vitals, sleep,\nsubjective scores, etc.). Set include_all_fields=true to also include any\nadditional or custom fields configured by the user in Intervals.icu.",
+      inputSchema: {
+        athlete_id: z7.string().optional(),
+        api_key: z7.string().optional(),
+        start_date: z7.string().optional().describe("Start date in YYYY-MM-DD format (defaults to 30 days ago)"),
+        end_date: z7.string().optional().describe("End date in YYYY-MM-DD format (defaults to today)"),
+        include_all_fields: z7.boolean().default(false).describe("Include additional and custom fields beyond the standard set")
+      }
+    },
+    async ({ athlete_id, api_key, start_date, end_date, include_all_fields }) => {
+      const config = getConfig();
+      const { athleteId, error } = resolveAthleteId(athlete_id, config.athleteId);
+      if (error) return textResult(error);
+      const [oldest, newest] = resolveDateParams(start_date, end_date);
+      const result = await makeIntervalsRequest(`/athlete/${athleteId}/wellness`, {
+        apiKey: api_key,
+        params: { oldest, newest }
+      });
+      if (isApiError(result)) {
+        return textResult(`Error fetching wellness data: ${apiErrorMessage(result)}`);
+      }
+      if (result == null || typeof result === "object" && !Array.isArray(result) && Object.keys(result).length === 0) {
+        return textResult(
+          `No wellness data found for athlete ${athleteId} in the specified date range.`
+        );
+      }
+      let summary = "Wellness Data:\n\n";
+      if (typeof result === "object" && !Array.isArray(result)) {
+        for (const [dateStr, data] of Object.entries(result)) {
+          if (typeof data === "object" && data !== null && !("date" in data)) {
+            data["date"] = dateStr;
+          }
+          summary += `${formatWellnessEntry(data, include_all_fields)}
+
+`;
+        }
+      } else if (Array.isArray(result)) {
+        for (const entry of result) {
+          if (typeof entry === "object" && entry !== null) {
+            summary += `${formatWellnessEntry(entry, include_all_fields)}
+
+`;
+          }
+        }
+      }
+      return textResult(summary);
+    }
+  );
+};
+
+// src/server.ts
+var MCP_PATH = "/mcp";
+function createServer() {
+  const server = new McpServer({
+    name: "intervals-icu",
+    version: readPackageVersion()
+  });
+  registerActivityTools(server);
+  registerEventTools(server);
+  registerWellnessTools(server);
+  registerGearTools(server);
+  registerPowerCurveTools(server);
+  registerCustomItemTools(server);
+  return server;
+}
+async function serveStdio() {
+  const server = createServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+async function serveStreamableHttp(host, port) {
+  const httpServer = http.createServer(async (req, res) => {
+    const url = req.url ?? "/";
+    const isMcpPath = url === MCP_PATH || url.startsWith(`${MCP_PATH}/`);
+    if (!isMcpPath) {
+      res.writeHead(404).end("Not found");
+      return;
+    }
+    if (req.method !== "POST") {
+      res.writeHead(405, { Allow: "POST" }).end("Method Not Allowed");
+      return;
+    }
+    try {
+      const server = createServer();
+      const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: void 0,
+        enableJsonResponse: true
+      });
+      res.on("close", () => {
+        transport.close();
+        void server.close();
+      });
+      await server.connect(transport);
+      await transport.handleRequest(req, res);
+    } catch (err) {
+      console.error("[intervals-mcp-server] error handling MCP request:", err);
+      if (!res.headersSent) {
+        res.writeHead(500).end("Internal Server Error");
+      }
+    }
+  });
+  await new Promise((resolve) => {
+    httpServer.listen(port, host, () => resolve());
+  });
+  console.error(
+    `[intervals-mcp-server] Streamable HTTP transport listening at http://${host}:${port}${MCP_PATH}`
+  );
+}
+
+// src/index.ts
+var NO_CREDENTIALS_HINT = `No Intervals.icu credentials found.
+
+  Run the interactive setup once in your terminal:
+
+      npx intervals-mcp-server auth
+
+  It opens https://intervals.icu/settings where you can copy your API Key
+  and Athlete ID, verifies them, and saves them for future runs.
+
+  Alternatively set the API_KEY and ATHLETE_ID environment variables in your
+  MCP client configuration.`;
+function isInteractive() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+async function startServer(opts) {
+  const transport = opts.transport.toLowerCase();
+  if (transport === "stdio") {
+    await serveStdio();
+    return;
+  }
+  if (transport === "streamable-http" || transport === "http") {
+    const port = Number.parseInt(opts.port, 10);
+    if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+      console.error(`Invalid port: ${opts.port}`);
+      process.exit(1);
+    }
+    await serveStreamableHttp(opts.host, port);
+    return;
+  }
+  console.error(`Unsupported transport "${opts.transport}". Use "stdio" or "streamable-http".`);
+  process.exit(1);
+}
+var program = new Command();
+program.name("intervals-mcp-server").description("Model Context Protocol server for the Intervals.icu API").version(readPackageVersion()).option("--transport <type>", "transport: stdio or streamable-http", "stdio").option("--host <host>", "HTTP host when using streamable-http", "127.0.0.1").option("--port <port>", "HTTP port when using streamable-http", "8765").action(async (opts) => {
+  if (!hasCredentials()) {
+    if (!isInteractive()) {
+      console.error(NO_CREDENTIALS_HINT);
+      process.exit(1);
+    }
+    const ok = await runOnboarding();
+    process.exit(ok ? 0 : 1);
+  }
+  await startServer(opts);
+});
+program.command("auth").description("Run (or re-run) the interactive credential setup wizard").action(async () => {
+  if (!isInteractive()) {
+    console.error("The auth wizard needs an interactive terminal. Run it directly in your shell:\n\n  npx intervals-mcp-server auth\n");
+    process.exit(1);
+  }
+  const ok = await runOnboarding();
+  process.exit(ok ? 0 : 1);
+});
+program.command("serve").description("Start the MCP server (skips the onboarding check)").option("--transport <type>", "transport: stdio or streamable-http", "stdio").option("--host <host>", "HTTP host when using streamable-http", "127.0.0.1").option("--port <port>", "HTTP port when using streamable-http", "8765").action(async (opts) => {
+  await startServer(opts);
+});
+program.parseAsync(process.argv).catch((err) => {
+  console.error("[intervals-mcp-server] fatal:", err);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map