@trainheroic-unofficial/athlete-mcp 0.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Alan Cohen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,65 @@
+# @trainheroic-unofficial/athlete-mcp
+
+Local single-user MCP server for a TrainHeroic **athlete**. Runs on your machine over stdio; credentials come from the environment.
+
+It exposes the logged-in athlete's own training — scheduled and completed workouts, per-exercise history, PRs, working maxes, and lifetime totals — plus a confirmation-gated workout-logging write. For coaching (rosters, teams, programs, messaging), use [`@trainheroic-unofficial/coach-mcp`](../coach-mcp). For the hosted version (no install, OAuth login, both surfaces), see the [root README](../../README.md).
+
+---
+
+## Install
+
+### Claude Code
+
+```bash
+claude mcp add trainheroic-athlete \
+  -e TRAINHEROIC_EMAIL=athlete@example.com \
+  -e TRAINHEROIC_PASSWORD=yourpassword \
+  -- npx -y @trainheroic-unofficial/athlete-mcp
+```
+
+### Claude Desktop / `.mcp.json` / other stdio clients
+
+```jsonc
+{
+  "mcpServers": {
+    "trainheroic-athlete": {
+      "command": "npx",
+      "args": ["-y", "@trainheroic-unofficial/athlete-mcp"],
+      "env": {
+        "TRAINHEROIC_EMAIL": "athlete@example.com",
+        "TRAINHEROIC_PASSWORD": "yourpassword",
+      },
+    },
+  },
+}
+```
+
+A coach account works here too: a coach login also carries athlete scope, so it can read its own training through these tools.
+
+---
+
+## Tools
+
+- `athlete_whoami` — identity (id, name, roles)
+- `athlete_profile` — lifetime totals + profile
+- `athlete_prefs` — notification/display preferences
+- `athlete_workouts` — scheduled + completed workouts in a date range (flattened)
+- `athlete_exercises` — search the exercises you've logged
+- `athlete_exercise_history` — per-exercise PRs + dated session history
+- `athlete_personal_records` — exercise personal records
+- `athlete_exercise_stats` — last performance + PR as of a date
+- `athlete_working_maxes` — working max per exercise
+- `athlete_leaderboard` — benchmark/test workout leaderboard
+- `athlete_log_set` — gated: log completed set results to your (coach-visible) training log
+
+---
+
+## Develop
+
+```bash
+pnpm start       # run from source (needs TRAINHEROIC_EMAIL and TRAINHEROIC_PASSWORD)
+pnpm inspect     # MCP Inspector UI against the source server
+pnpm build       # tsdown → dist/server.mjs
+pnpm typecheck
+pnpm test
+```

package/dist/server.mjs

@@ -0,0 +1,1054 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import process from "node:process";
+import { z } from "zod";
+//#region ../dto/src/common.ts
+/** An entity id as it arrives over the wire — a number or a numeric string. */
+const idSchema = z.union([z.string(), z.number()]);
+/**
+* An id as a tool argument: a number, or a string of digits. Unlike idSchema (which
+* tolerates whatever the API sends back), this rejects non-numeric strings up front so
+* a bad argument fails validation instead of becoming NaN in a URL or a query.
+*/
+const idArgSchema = z.union([z.number().int(), z.string().regex(/^\d+$/u)]);
+//#endregion
+//#region ../dto/src/athlete.ts
+const intLike$1 = z.union([z.number(), z.string()]);
+const intLikeOrNull$1 = z.union([
+	z.number(),
+	z.string(),
+	z.null()
+]);
+const numLikeOrNull = z.union([
+	z.number(),
+	z.string(),
+	z.null()
+]);
+z.looseObject({
+	id: intLike$1,
+	roles: z.array(z.string()).optional(),
+	org_id: intLikeOrNull$1.optional()
+});
+z.looseObject({
+	reps_sum: z.number().optional(),
+	volume_sum: z.number().optional(),
+	sessions_count: z.number().optional(),
+	first_logged_date: z.string().optional(),
+	last_logged_date: z.string().optional(),
+	duration_hours: z.number().optional()
+});
+z.looseObject({
+	id: intLike$1,
+	email: z.string().optional(),
+	name_first: z.string().optional(),
+	name_last: z.string().optional(),
+	username: z.string().optional(),
+	gender: z.string().optional(),
+	date_of_birth: z.string().optional(),
+	use_metric: z.boolean().optional()
+});
+z.looseObject({ id: intLike$1 });
+/** One item of `/2.0/athlete/workingMax` — the athlete's working max for an exercise. */
+const athleteWorkingMaxSchema = z.looseObject({
+	exercise_id: intLike$1,
+	title: z.string().optional(),
+	param_type: intLikeOrNull$1.optional(),
+	value: numLikeOrNull.optional(),
+	type_suffix: z.string().optional(),
+	working_max_id: intLikeOrNull$1.optional()
+});
+z.array(athleteWorkingMaxSchema);
+/** One item of `/v5/users/exercises/history` — an exercise the athlete has logged. */
+const exerciseHistoryListItemSchema = z.looseObject({
+	id: intLike$1,
+	title: z.string(),
+	isCircuit: z.boolean().optional(),
+	prescription: z.string().optional(),
+	param1Type: intLikeOrNull$1.optional(),
+	param2Type: intLikeOrNull$1.optional()
+});
+z.array(exerciseHistoryListItemSchema);
+/** A single completed set inside a history entry (`/v5/exercises/{id}/history`). */
+const historySetSchema = z.looseObject({
+	setNumber: z.number(),
+	formattedValue: z.string().optional(),
+	rawValue1: numLikeOrNull.optional(),
+	rawValue2: numLikeOrNull.optional(),
+	savedWorkoutSetExerciseId: intLike$1.optional()
+});
+/** A best rep-max derived for a history entry. */
+const repMaxSchema = z.looseObject({
+	reps: z.number(),
+	weight: z.number()
+});
+/** One performed session of an exercise (`/v5/exercises/{id}/history` → `history[]`). */
+const historyEntrySchema = z.looseObject({
+	dateCompleted: z.string(),
+	notes: z.string().nullable().optional(),
+	isLift: z.boolean().optional(),
+	param1Type: intLikeOrNull$1.optional(),
+	param2Type: intLikeOrNull$1.optional(),
+	savedWorkoutSetExerciseId: intLike$1.optional(),
+	teamId: intLikeOrNull$1.optional(),
+	programWorkoutId: intLikeOrNull$1.optional(),
+	abr: z.string().optional(),
+	bestEstimated1RM: z.number().optional(),
+	repMaxes: z.array(repMaxSchema).optional(),
+	sets: z.array(historySetSchema).optional()
+});
+/** A lifetime PR row from `/v5/exercises/{id}/history` → `liftPRs[]`. */
+const liftPRSchema = z.looseObject({
+	weight: z.number().optional(),
+	savedWorkoutSetExerciseId: intLike$1.optional(),
+	setNumber: z.number().optional(),
+	dateCompleted: z.string().optional(),
+	reps: z.number().optional(),
+	units: z.string().optional(),
+	isMetric: z.boolean().optional(),
+	description: z.string().optional()
+});
+z.looseObject({
+	liftPRs: z.array(liftPRSchema).optional(),
+	singleParamPRs: z.array(z.unknown()).optional(),
+	history: z.array(historyEntrySchema).optional()
+});
+/** One item of `/v5/exercises/{id}/personalRecords` — a standards-filtered PR. */
+const personalRecordSchema = z.looseObject({
+	id: intLike$1.optional(),
+	savedWorkoutSetExerciseId: intLike$1.optional(),
+	setNumber: z.number().optional(),
+	reps: z.number().optional(),
+	weight: z.number().optional(),
+	scaledWeight: z.number().optional(),
+	units: z.string().optional(),
+	isMetric: z.boolean().optional()
+});
+z.array(personalRecordSchema);
+z.looseObject({
+	isLift: z.boolean().optional(),
+	lastPerformance: z.unknown().optional(),
+	personalRecord: z.unknown().optional()
+});
+/**
+* One item of `/3.0/athlete/programworkout/range` — a scheduled/completed workout. The deep
+* `summarizedSavedWorkout` tree is left loose: the presenter in `js` flattens it, so dto only
+* pins the top-level fields the warehouse and presenter key off.
+*/
+const programWorkoutSchema = z.looseObject({
+	id: intLike$1,
+	date: z.string().optional(),
+	workout_title: z.string().optional(),
+	program_id: intLikeOrNull$1.optional(),
+	program_title: z.string().optional(),
+	team_id: intLikeOrNull$1.optional(),
+	team_title: z.string().optional(),
+	summarizedSavedWorkout: z.unknown().optional()
+});
+z.array(programWorkoutSchema);
+/** A `YYYY-MM-DD` date argument. The single definition reused across athlete tool inputs. */
+const dateString = z.string().regex(/^\d{4}-\d{2}-\d{2}$/u, "expected YYYY-MM-DD");
+z.object({
+	startDate: dateString,
+	endDate: dateString
+});
+/**
+* Args for the set-logging write. `date` (the workout's day) locates the saved
+* workout via the range endpoint; `savedWorkoutSetId` picks the set to complete; `results`
+* gives, per exercise in it, the entered value of each set (param 1 / param 2 by entry slot).
+*/
+const logSetArgsSchema = z.object({
+	date: dateString,
+	savedWorkoutSetId: idArgSchema,
+	results: z.array(z.object({
+		savedWorkoutSetExerciseId: idArgSchema,
+		sets: z.array(z.object({
+			param1: z.union([z.number(), z.string()]).optional(),
+			param2: z.union([z.number(), z.string()]).optional()
+		})).min(1)
+	})).min(1)
+});
+z.looseObject({
+	title: z.string().min(1),
+	param_1_type: z.number().optional(),
+	param_2_type: z.number().optional()
+});
+z.object({
+	streamId: idSchema,
+	text: z.string().min(1),
+	replyTo: idSchema.optional()
+});
+//#endregion
+//#region ../dto/src/responses.ts
+const intLike = z.union([z.number(), z.string()]);
+const intLikeOrNull = z.union([
+	z.number(),
+	z.string(),
+	z.null()
+]);
+/** An exercise as the library + create endpoints return it (only the fields we read). */
+const exerciseResponseSchema = z.looseObject({
+	id: intLike,
+	title: z.string(),
+	param_1_type: intLikeOrNull.optional(),
+	param_2_type: intLikeOrNull.optional()
+});
+z.array(exerciseResponseSchema);
+z.looseObject({
+	workout_id: intLike,
+	id: intLike
+});
+/** A programWorkout from the calendar edit view (we match by id and walk sets). */
+const programWorkoutResponseSchema = z.looseObject({
+	id: intLike,
+	sets: z.record(z.string(), z.unknown()).optional()
+});
+z.looseObject({ programWorkouts: z.array(programWorkoutResponseSchema).optional() });
+//#endregion
+//#region ../dto/src/workout.ts
+/** A single exercise prescription inside a block. */
+const exerciseSpecSchema = z.object({
+	id: z.union([z.number(), z.string()]),
+	title: z.string().optional(),
+	reps: z.union([
+		z.number(),
+		z.string(),
+		z.array(z.union([z.number(), z.string()]))
+	]).optional(),
+	sets: z.number().optional(),
+	weight: z.union([z.number(), z.array(z.number())]).optional(),
+	rpe: z.union([z.number(), z.string()]).optional(),
+	instr: z.string().optional(),
+	param_1_type: z.number().optional(),
+	param_2_type: z.number().optional()
+});
+/** A block's Red-Zone leaderboard: a unit string/number, or an object with options. */
+const leaderboardSpecSchema = z.union([
+	z.string(),
+	z.number(),
+	z.object({
+		unit: z.union([z.string(), z.number()]).optional(),
+		type: z.union([z.string(), z.number()]).optional(),
+		lowest_wins: z.boolean().optional(),
+		instruction: z.string().optional()
+	})
+]);
+/** A block (group of exercises); two exercises render as a superset. */
+const blockSpecSchema = z.object({
+	title: z.string(),
+	type: z.number().optional(),
+	instruction: z.string().optional(),
+	leaderboard: leaderboardSpecSchema.optional(),
+	exercises: z.array(exerciseSpecSchema)
+});
+z.object({
+	blocks: z.array(blockSpecSchema),
+	instruction: z.string().optional()
+});
+//#endregion
+//#region ../core/src/context.ts
+/** A tool argument that accepts a numeric id as a number or a string of digits. */
+const idParam = idArgSchema;
+function toId(value) {
+	return typeof value === "number" ? value : Number(value);
+}
+const READ = {
+	readOnlyHint: true,
+	openWorldHint: true
+};
+const DESTRUCTIVE = {
+	readOnlyHint: false,
+	destructiveHint: true,
+	openWorldHint: true
+};
+/** Run a tool body, converting thrown errors into an in-band tool error. */
+async function attempt(fn) {
+	try {
+		return await fn();
+	} catch (err) {
+		return errorResult(err instanceof Error ? err.message : String(err));
+	}
+}
+/** Conservative per-result character cap, below the smallest host cap. */
+const DEFAULT_RESULT_BUDGET = 6e4;
+/** Reserve for the `__truncated` marker so wrapping cannot push back over budget. */
+const MARKER_RESERVE = 300;
+const DEFAULT_ARRAY_HINT = "Result was truncated to fit the size budget. Narrow it with a filter/search argument or paginate to see the rest.";
+const DEFAULT_OBJECT_HINT = "Result was truncated to fit the size budget. Request a more specific id or sub-resource.";
+/** Active budget. Overridable via TH_MCP_RESULT_BUDGET on Node; the default on workerd. */
+function resultBudget() {
+	const raw = (globalThis.process?.env)?.TH_MCP_RESULT_BUDGET;
+	const n = raw ? Number(raw) : NaN;
+	return Number.isFinite(n) && n > 0 ? n : DEFAULT_RESULT_BUDGET;
+}
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Largest count k such that the JSON of the first k pre-serialized pieces fits. O(n). */
+function largestPrefixCount(pieces, charBudget) {
+	let used = 2;
+	let k = 0;
+	for (const piece of pieces) {
+		const add = piece.length + (k > 0 ? 1 : 0);
+		if (used + add > charBudget) break;
+		used += add;
+		k += 1;
+	}
+	return k;
+}
+/** Last resort: cap a string at the budget and label it as truncated, non-JSON output. */
+function hardCap(text, budget, hint) {
+	if (text.length <= budget) return text;
+	const note = `\n\n[TRUNCATED: output exceeded ${budget} chars and is NOT valid JSON. ${hint ?? "Narrow the query (filter, paginate, or fetch a specific id)."}]`;
+	const keep = Math.max(0, budget - note.length);
+	return text.slice(0, keep) + note;
+}
+function largestArrayValuedKey(obj) {
+	let best = null;
+	let bestLen = -1;
+	for (const [key, value] of Object.entries(obj)) {
+		if (!Array.isArray(value)) continue;
+		const len = (JSON.stringify(value) ?? "[]").length;
+		if (len > bestLen) {
+			best = key;
+			bestLen = len;
+		}
+	}
+	return best;
+}
+/**
+* Serialize `data` as JSON within `budget` characters. Small results are pretty-printed.
+* Oversized results degrade in order: trim a top-level array (wrapping it as
+* `{ items, __truncated }`), then a top-level object's largest array property (annotated
+* with `__truncated`), then a last-resort hard character cap. Pure and side-effect free.
+*/
+function boundedSerialize(data, budget, hint) {
+	if (typeof data === "string") return hardCap(data, budget, hint);
+	const compact = JSON.stringify(data) ?? "null";
+	if (compact.length <= budget) {
+		const pretty = JSON.stringify(data, null, 2) ?? "null";
+		return pretty.length <= budget ? pretty : compact;
+	}
+	if (Array.isArray(data)) {
+		const k = largestPrefixCount(data.map((el) => JSON.stringify(el) ?? "null"), budget - MARKER_RESERVE);
+		const wrapped = {
+			items: data.slice(0, k),
+			__truncated: {
+				returned: k,
+				total: data.length,
+				omitted: data.length - k,
+				hint: hint ?? DEFAULT_ARRAY_HINT
+			}
+		};
+		const out = JSON.stringify(wrapped);
+		if (out.length <= budget) return out;
+	} else if (isPlainObject(data)) {
+		const key = largestArrayValuedKey(data);
+		if (key !== null) {
+			const arr = data[key];
+			const pieces = arr.map((el) => JSON.stringify(el) ?? "null");
+			const restLen = (JSON.stringify({
+				...data,
+				[key]: []
+			}) ?? "{}").length;
+			const k = largestPrefixCount(pieces, Math.max(0, budget - MARKER_RESERVE - restLen));
+			const clone = {
+				...data,
+				[key]: arr.slice(0, k),
+				__truncated: {
+					field: key,
+					returned: k,
+					total: arr.length,
+					omitted: arr.length - k,
+					hint: hint ?? DEFAULT_OBJECT_HINT
+				}
+			};
+			const out = JSON.stringify(clone);
+			if (out.length <= budget) return out;
+		}
+	}
+	return hardCap(compact, budget, hint);
+}
+/** A successful tool result carrying JSON (or text) for the model, size-bounded. */
+function jsonResult(data, opts) {
+	return { content: [{
+		type: "text",
+		text: boundedSerialize(data, resultBudget(), opts?.hint)
+	}] };
+}
+/** A tool-level error: returned in-band (isError) so the model can self-correct. */
+function errorResult(message) {
+	return {
+		isError: true,
+		content: [{
+			type: "text",
+			text: message
+		}]
+	};
+}
+//#endregion
+//#region ../core/src/confirm.ts
+const NOT_CONFIRMED = "Not confirmed. Re-run with confirm:true, or connect a client that supports MCP elicitation.";
+/**
+* Confirm a destructive/athlete-facing action. Prefers MCP elicitation (an
+* in-the-moment user prompt); falls back to an explicit confirm:true argument when
+* the client does not support elicitation. Never proceeds without one of the two.
+*/
+async function confirmGate(server, requestId, message, confirmArg) {
+	if (confirmArg === true) return true;
+	try {
+		const result = await server.server.elicitInput({
+			message,
+			requestedSchema: {
+				type: "object",
+				properties: { confirm: {
+					type: "boolean",
+					title: "Confirm",
+					description: message
+				} },
+				required: ["confirm"]
+			}
+		}, requestId === void 0 ? void 0 : { relatedRequestId: requestId });
+		return result.action === "accept" && result.content?.confirm === true;
+	} catch (err) {
+		console.warn("MCP elicitation unavailable; treating as not confirmed", err);
+		return false;
+	}
+}
+//#endregion
+//#region ../js/src/auth.ts
+const AUTH_URL = "https://apis.trainheroic.com/auth";
+/**
+* Authenticate against TrainHeroic. Returns the session bundle, or null on bad
+* credentials. TrainHeroic returns only { id, scope, role, session_id } (verified in
+* the Phase 0 spike: no refresh_token, no api_token, no TTL). The 48-char session_id
+* is sent as the `session-token` header and works against both API hosts.
+*/
+async function loginTrainHeroic(email, password) {
+	const res = await fetch(AUTH_URL, {
+		method: "POST",
+		headers: {
+			"content-type": "application/x-www-form-urlencoded",
+			accept: "application/json"
+		},
+		body: new URLSearchParams({
+			email,
+			password
+		}).toString()
+	});
+	if (!res.ok) return null;
+	const data = await res.json().catch(() => null);
+	if (!data || typeof data.id !== "number" || !data.session_id) return null;
+	return {
+		thUserId: data.id,
+		sessionId: data.session_id,
+		scope: data.scope ?? "",
+		role: data.role ?? ""
+	};
+}
+//#endregion
+//#region ../js/src/client.ts
+const COACH_BASE = "https://api.trainheroic.com";
+const APIS_BASE = "https://apis.trainheroic.com";
+var TrainHeroicAuthError = class extends Error {
+	name = "TrainHeroicAuthError";
+};
+/**
+* Authenticated TrainHeroic API client. Holds the coach credentials (from the grant's
+* encrypted props) and a lazily-acquired session token cached in memory for the life
+* of the Durable Object instance. On a 401/403 it re-logs in once and retries, since
+* TrainHeroic has no refresh token and sessions expire after ~1-2h.
+*/
+var TrainHeroicClient = class {
+	#email;
+	#password;
+	#sessionId;
+	#loginInFlight = null;
+	constructor(email, password, sessionId = null) {
+		this.#email = email;
+		this.#password = password;
+		this.#sessionId = sessionId;
+	}
+	get sessionId() {
+		return this.#sessionId;
+	}
+	async #ensureSession() {
+		if (this.#sessionId) return this.#sessionId;
+		this.#loginInFlight ??= this.#login();
+		try {
+			return await this.#loginInFlight;
+		} finally {
+			this.#loginInFlight = null;
+		}
+	}
+	async #login() {
+		const session = await loginTrainHeroic(this.#email, this.#password);
+		if (!session) throw new TrainHeroicAuthError("TrainHeroic login failed");
+		this.#sessionId = session.sessionId;
+		return this.#sessionId;
+	}
+	async request(method, path, options = {}) {
+		const url = `${options.base === "apis" ? APIS_BASE : COACH_BASE}/${path.replace(/^\//, "")}`;
+		let session = await this.#ensureSession();
+		let res = await this.#send(method, url, session, options.body);
+		if (res.status === 401 || res.status === 403) {
+			if (this.#sessionId === session) this.#sessionId = null;
+			session = await this.#ensureSession();
+			res = await this.#send(method, url, session, options.body);
+		}
+		const text = await res.text();
+		let data = text;
+		if (text.length > 0) try {
+			data = JSON.parse(text);
+		} catch {
+			data = text;
+		}
+		return {
+			status: res.status,
+			ok: res.ok,
+			data
+		};
+	}
+	#send(method, url, session, body) {
+		const upper = method.toUpperCase();
+		const headers = {
+			accept: "application/json",
+			"session-token": session
+		};
+		const init = {
+			method: upper,
+			headers
+		};
+		if (body !== void 0 && upper !== "GET" && upper !== "DELETE") {
+			headers["content-type"] = "application/json";
+			init.body = JSON.stringify(body);
+		}
+		return fetch(url, init);
+	}
+};
+//#endregion
+//#region ../js/src/exercise-util.ts
+/**
+* Display labels for TrainHeroic parameter types. The unit is FIXED PER EXERCISE
+* (the API forces param_1_type/param_2_type back to the library default on save), so
+* resolve/search surface it to stop callers picking, say, the miles "Run" for a
+* metric workout. Keep in sync with the workout builder's unit table.
+*/
+const PARAM_UNIT = {
+	0: null,
+	1: "lb",
+	2: "%max",
+	3: "reps",
+	4: "sec",
+	5: "yd",
+	6: "m",
+	7: "in",
+	10: "mi",
+	11: "ft",
+	12: "in",
+	13: "bpm",
+	14: "RPE",
+	18: "sec"
+};
+function coerceInt(value) {
+	if (typeof value === "boolean") return value ? 1 : 0;
+	if (typeof value === "number") return Number.isFinite(value) ? Math.trunc(value) : null;
+	if (typeof value === "string" && value.trim() !== "") {
+		const n = Number(value);
+		return Number.isFinite(n) ? Math.trunc(n) : null;
+	}
+	return null;
+}
+function unitLabel(paramType) {
+	const t = coerceInt(paramType);
+	if (t === null) return null;
+	return PARAM_UNIT[t] ?? null;
+}
+/**
+* Fixed measurement units for an exercise, ordered by entry slot (param 1, then param 2).
+* Positional, not semantic: some exercises reverse the slots, so the array is not labelled
+* by role. A null entry is an unset slot.
+*/
+function exerciseUnits(param1, param2) {
+	return [unitLabel(param1), unitLabel(param2)];
+}
+function isRecord(x) {
+	return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+/**
+* Rank candidate rows for a free-text query (FTS5 replacement). Higher is better:
+* exact title, then prefix, then count of matched tokens, with shorter titles and
+* standard (non-custom) exercises preferred on ties.
+*/
+function rankSearch(rows, query, limit) {
+	const q = query.trim().toLowerCase();
+	const tokens = q.split(/\s+/u).filter((t) => t.length > 0);
+	return rows.map((row) => {
+		const title = row.title.toLowerCase();
+		let score = 0;
+		if (title === q) score += 1e3;
+		if (title.startsWith(q)) score += 100;
+		for (const tok of tokens) if (title.includes(tok)) score += 10;
+		score -= title.length * .05;
+		if ((row.can_edit ?? 0) === 0) score += 1;
+		return {
+			row,
+			score
+		};
+	}).sort((a, b) => b.score - a.score).slice(0, limit).map((s) => s.row);
+}
+//#endregion
+//#region ../js/src/athlete.ts
+async function getJson(client, path, label) {
+	const res = await client.request("GET", path);
+	if (!res.ok) throw new Error(`${label} failed (HTTP ${res.status}).`);
+	return res.data;
+}
+async function getArray(client, path, label) {
+	const res = await client.request("GET", path);
+	if (!res.ok || !Array.isArray(res.data)) throw new Error(`${label} failed (HTTP ${res.status}).`);
+	return res.data;
+}
+/** Lifetime training totals. `use_metric` is required by the API (omitting it 400s). */
+function fetchAthleteProfileSummary(client, userId, useMetric = false) {
+	return getJson(client, `/v5/athleteProfile/summary?user_id=${userId}&use_metric=${useMetric ? 1 : 0}`, "athlete profile summary");
+}
+function fetchAthleteUser(client, userId) {
+	return getJson(client, `/v5/users/${userId}`, "athlete user");
+}
+function fetchAthletePrefs(client) {
+	return getJson(client, "/1.0/athlete/prefs", "athlete prefs");
+}
+function fetchWorkingMaxes(client) {
+	return getArray(client, "/2.0/athlete/workingMax", "athlete working maxes");
+}
+function fetchExerciseHistoryList(client) {
+	return getArray(client, "/v5/users/exercises/history", "athlete exercise history list");
+}
+/** Free-text search over the athlete's logged exercises (FTS replacement via rankSearch). */
+async function searchExerciseHistory(client, query, limit = 20) {
+	return rankSearch(await fetchExerciseHistoryList(client), query, limit);
+}
+function fetchExerciseHistoryDetail(client, exerciseId, userId) {
+	return getJson(client, `/v5/exercises/${exerciseId}/history?userId=${userId}`, "athlete exercise history");
+}
+function fetchPersonalRecords(client, exerciseId) {
+	return getArray(client, `/v5/exercises/${exerciseId}/personalRecords`, "athlete personal records");
+}
+/** Last performance + PR for an exercise. `date` (YYYY-MM-DD) is required by the API. */
+function fetchExerciseStats(client, exerciseId, userId, date) {
+	return getJson(client, `/v5/exercises/${exerciseId}/stats?userId=${userId}&date=${date}`, "athlete exercise stats");
+}
+/** Scheduled + completed workouts in an inclusive YYYY-MM-DD window. */
+function fetchAthleteWorkouts(client, startDate, endDate) {
+	return getArray(client, `/3.0/athlete/programworkout/range?startDate=${startDate}&endDate=${endDate}`, "athlete workouts");
+}
+function fetchLeaderboard(client, workoutId, opts = {}) {
+	const qs = new URLSearchParams();
+	if (opts.page !== void 0) qs.set("page", String(opts.page));
+	if (opts.pageSize !== void 0) qs.set("pageSize", String(opts.pageSize));
+	if (opts.gender !== void 0) qs.set("gender", String(opts.gender));
+	const query = qs.toString();
+	return getJson(client, `/3.0/athlete/leaderboard/${workoutId}${query ? `?${query}` : ""}`, "athlete leaderboard");
+}
+const SLOTS = 10;
+function nonEmpty(value) {
+	return value !== void 0 && value !== null && String(value).trim() !== "";
+}
+/**
+* Per-set prescriptions from the param_N_data slots, e.g. ["5 @ 225", "3 @ 245"] or ["AMRAP"].
+* Values are kept raw (a non-numeric prescription like "AMRAP" or "8-12" must survive); the
+* positional units come from the exercise's param types, mirroring the coach presenter.
+*/
+function prescribedSets(ex) {
+	const out = [];
+	for (let i = 1; i <= SLOTS; i += 1) {
+		const p1 = ex[`param_1_data_${i}`];
+		const p2 = ex[`param_2_data_${i}`];
+		const has1 = nonEmpty(p1);
+		const has2 = nonEmpty(p2);
+		if (!has1 && !has2) continue;
+		if (has1 && has2) out.push(`${p1} @ ${p2}`);
+		else if (has1) out.push(String(p1));
+		else out.push(`@ ${p2}`);
+	}
+	return out;
+}
+function presentExercise(ex) {
+	const instruction = typeof ex.instruction === "string" && ex.instruction !== "" ? ex.instruction : null;
+	return {
+		exerciseId: coerceInt(ex.exercise_id),
+		title: typeof ex.title === "string" ? ex.title : "",
+		instruction,
+		units: exerciseUnits(ex.param_1_type, ex.param_2_type),
+		prescribed: prescribedSets(ex)
+	};
+}
+function presentBlock(set) {
+	const exercises = Array.isArray(set.workoutSetExercises) ? set.workoutSetExercises : [];
+	return {
+		order: coerceInt(set.order) ?? 0,
+		title: typeof set.title === "string" && set.title !== "" ? set.title : null,
+		instruction: typeof set.instruction === "string" && set.instruction !== "" ? set.instruction : null,
+		isTest: coerceInt(set.is_test) === 1,
+		exercises: exercises.filter(isRecord).map(presentExercise)
+	};
+}
+function str(v) {
+	return typeof v === "string" && v !== "" ? v : null;
+}
+/** Flatten one `/3.0/athlete/programworkout/range` item into a readable workout. */
+function presentAthleteWorkout(raw) {
+	const rec = raw;
+	const ssw = isRecord(rec.summarizedSavedWorkout) ? rec.summarizedSavedWorkout : {};
+	const workout = isRecord(ssw.workout) ? ssw.workout : {};
+	const sets = Array.isArray(workout.workoutSets) ? workout.workoutSets : [];
+	return {
+		id: coerceInt(rec.id),
+		date: str(rec.date) ?? "",
+		title: str(rec.workout_title) ?? "",
+		program: str(rec.program_title),
+		team: str(rec.team_title),
+		instruction: str(workout.instruction),
+		blocks: sets.filter(isRecord).map(presentBlock).sort((a, b) => a.order - b.order)
+	};
+}
+function presentAthleteWorkouts(list) {
+	return list.map(presentAthleteWorkout);
+}
+const MAX_PARAM_SLOTS = 10;
+/**
+* Build the body for `PUT /1.0/athlete/savedworkoutsetexercise/{id}`. The body uses
+* snake_case keys matching the live API response shape. Each set slot (1-10) gets a
+* `param_N_made` flag (1 if data is present, 0 otherwise) and `param_1_data_N` /
+* `param_2_data_N` string values.
+*
+* Only `savedWorkoutSetExerciseId`, `savedWorkoutSetId`, and `workoutSetExerciseId` are
+* required from the live exercise record; everything else is derived from `results`.
+*
+* Exported for unit testing — callers should use `logAthleteSet` instead.
+*/
+function buildExerciseLogPayload(savedWorkoutSetExerciseId, savedWorkoutSetId, workoutSetExerciseId, results) {
+	if (results.length > MAX_PARAM_SLOTS) throw new Error(`At most ${MAX_PARAM_SLOTS} sets are supported per exercise; got ${results.length}.`);
+	const body = {
+		id: savedWorkoutSetExerciseId,
+		saved_workout_set_id: savedWorkoutSetId,
+		workout_set_exercise_id: workoutSetExerciseId,
+		completed: results.some((s) => s.param1 !== void 0 || s.param2 !== void 0) ? 1 : 0
+	};
+	for (let i = 1; i <= MAX_PARAM_SLOTS; i += 1) {
+		const slot = results[i - 1];
+		const p1 = slot?.param1 !== void 0 ? String(slot.param1) : "";
+		const p2 = slot?.param2 !== void 0 ? String(slot.param2) : "";
+		body[`param_${i}_made`] = p1 !== "" || p2 !== "" ? 1 : 0;
+		body[`param_1_data_${i}`] = p1;
+		body[`param_2_data_${i}`] = p2;
+	}
+	return body;
+}
+/**
+* Locate the target saved workout set across all program workouts on the given day.
+* Returns the `savedWorkoutId`, the matching set's `workoutSetExercises` array so callers
+* can look up `workout_set_exercise_id` by `savedWorkoutSetExerciseId`, and the raw set
+* record so callers can build the set-completion PUT body via `buildSetCompletePayload`.
+*/
+function findSavedWorkoutSet(workouts, savedWorkoutSetId) {
+	for (const pw of workouts) {
+		const rec = pw;
+		const ssw = isRecord(rec.summarizedSavedWorkout) ? rec.summarizedSavedWorkout : {};
+		const sw = isRecord(ssw.saved_workout) ? ssw.saved_workout : null;
+		if (!sw) continue;
+		const sets = Array.isArray(sw.workoutSets) ? sw.workoutSets : [];
+		for (const s of sets) {
+			if (!isRecord(s)) continue;
+			if (coerceInt(s.id) === savedWorkoutSetId) {
+				const savedWorkoutId = coerceInt(sw.id);
+				if (!savedWorkoutId) continue;
+				return {
+					savedWorkoutId,
+					exercises: Array.isArray(s.workoutSetExercises) ? s.workoutSetExercises.filter(isRecord) : [],
+					rawSet: s
+				};
+			}
+		}
+	}
+	throw new Error(`Saved workout set ${savedWorkoutSetId} not found on this date.`);
+}
+/**
+* Build the body for `PUT /1.0/athlete/savedworkoutset/{id}` that marks the set completed.
+*
+* The API requires the **app's camelCase in-memory model**, not the snake_case shape the
+* GET endpoints return. Key field mappings from the raw set record:
+*   saved_workout_id   → sessionId
+*   workout_set_id     → workoutSetId
+*   is_super_set (0/1) → isSuperSet (boolean)
+*   plain_text (0/1)   → isPlainText (boolean)
+*   unit ("lb"/"kg")   → isMetric (boolean)
+*   workoutSetExercises[].id → exercises (array of IDs)
+*
+* `exerciseIds` must be the savedWorkoutSetExercise IDs (not workout_set_exercise_ids).
+*
+* Exported for unit testing — callers should use `logAthleteSet` instead.
+*/
+function buildSetCompletePayload(rawSet, exerciseIds, complete) {
+	const id = coerceInt(rawSet.id);
+	const sessionId = coerceInt(rawSet.saved_workout_id);
+	const workoutSetId = coerceInt(rawSet.workout_set_id);
+	if (!id || !sessionId || !workoutSetId) throw new Error("Raw set is missing required id / saved_workout_id / workout_set_id.");
+	const unit = typeof rawSet.unit === "string" ? rawSet.unit : "";
+	return {
+		id,
+		sessionId,
+		workoutSetId,
+		completed: complete ? "1" : "0",
+		rx: coerceInt(rawSet.rx) ?? 0,
+		version: coerceInt(rawSet.version) ?? 0,
+		isMetric: unit.toLowerCase() === "kg",
+		isSuperSet: rawSet.is_super_set === 1 || rawSet.is_super_set === true,
+		isPlainText: rawSet.plain_text === 1 || rawSet.plain_text === true,
+		title: typeof rawSet.title === "string" ? rawSet.title : "",
+		instruction: typeof rawSet.instruction === "string" ? rawSet.instruction : "",
+		notes: rawSet.notes ?? null,
+		exercises: [...exerciseIds]
+	};
+}
+/**
+* Record entered set results for one saved workout set.
+*
+* **Two-step write (both required for data to persist):**
+* 1. For each exercise in `results`:
+*    `PUT /1.0/athlete/savedworkoutsetexercise/{savedWorkoutSetExerciseId}` with the
+*    per-slot `param_N_data_M` values. This is the only path that actually stores reps
+*    and weight — the `savedworkoutset` PUT accepts the same fields but silently discards
+*    them.
+* 2. `PUT /1.0/athlete/savedworkoutset/{savedWorkoutSetId}` with `completed:"1"` to
+*    mark the block done and make the entry visible as a logged set in history.
+*
+* The date is used to locate the saved workout (via the range endpoint) so we can resolve
+* `saved_workout_id` and `workout_set_exercise_id` for each exercise. Both are required
+* by the respective PUT bodies.
+*/
+async function logAthleteSet(client, args) {
+	const { exercises, rawSet } = findSavedWorkoutSet(await fetchAthleteWorkouts(client, args.date, args.date), args.savedWorkoutSetId);
+	let exercisesLogged = 0;
+	for (const result of args.results) {
+		const ex = exercises.find((e) => coerceInt(e.id) === result.savedWorkoutSetExerciseId);
+		if (!ex) throw new Error(`savedWorkoutSetExerciseId ${result.savedWorkoutSetExerciseId} not found in saved workout set ${args.savedWorkoutSetId}.`);
+		const workoutSetExerciseId = coerceInt(ex.workout_set_exercise_id);
+		if (!workoutSetExerciseId) throw new Error(`Could not resolve workout_set_exercise_id for exercise ${result.savedWorkoutSetExerciseId}.`);
+		const body = buildExerciseLogPayload(result.savedWorkoutSetExerciseId, args.savedWorkoutSetId, workoutSetExerciseId, result.sets);
+		const res = await client.request("PUT", `/1.0/athlete/savedworkoutsetexercise/${result.savedWorkoutSetExerciseId}`, { body });
+		if (!res.ok) throw new Error(`Failed to log exercise ${result.savedWorkoutSetExerciseId} (HTTP ${res.status}).`);
+		exercisesLogged += 1;
+	}
+	const setBody = buildSetCompletePayload(rawSet, exercises.map((e) => coerceInt(e.id)).filter((n) => n !== null), true);
+	const setRes = await client.request("PUT", `/1.0/athlete/savedworkoutset/${args.savedWorkoutSetId}`, { body: setBody });
+	if (!setRes.ok) throw new Error(`Failed to mark workout set ${args.savedWorkoutSetId} completed (HTTP ${setRes.status}).`);
+	return {
+		savedWorkoutSetId: args.savedWorkoutSetId,
+		exercisesLogged
+	};
+}
+/** Flatten `/v5/exercises/{id}/history` into PRs + a session time-series. */
+function presentExerciseHistory(detail) {
+	return {
+		liftPRs: (detail.liftPRs ?? []).map((p) => ({
+			description: p.description ?? null,
+			reps: p.reps ?? null,
+			weight: p.weight ?? null,
+			date: p.dateCompleted ?? null
+		})),
+		sessions: (detail.history ?? []).map((h) => ({
+			date: h.dateCompleted,
+			abr: h.abr ?? null,
+			estimated1RM: h.bestEstimated1RM ?? null,
+			sets: (h.sets ?? []).map((s) => ({
+				setNumber: s.setNumber,
+				value: s.formattedValue ?? null
+			}))
+		}))
+	};
+}
+//#endregion
+//#region ../core/src/tools/athlete-training.ts
+/** Identity, profile, prefs, working maxes, leaderboard. */
+function registerProfileTools(server, ctx, whoami, userId) {
+	server.registerTool("athlete_whoami", {
+		title: "Who am I (athlete)",
+		description: "The logged-in account's identity (id, name, roles) from /user/simple.",
+		inputSchema: {},
+		annotations: READ
+	}, () => attempt(async () => jsonResult(await whoami())));
+	server.registerTool("athlete_profile", {
+		title: "Athlete profile + lifetime totals",
+		description: "Lifetime training totals (reps, volume, sessions, first/last logged) plus the profile (name, units, dob). Set useMetric for kg/metric totals.",
+		inputSchema: { useMetric: z.boolean().optional() },
+		annotations: READ
+	}, ({ useMetric }) => attempt(async () => {
+		const id = await userId();
+		const [summary, user] = await Promise.all([fetchAthleteProfileSummary(ctx.client, id, useMetric ?? false), fetchAthleteUser(ctx.client, id)]);
+		return jsonResult({
+			summary,
+			user
+		});
+	}));
+	server.registerTool("athlete_prefs", {
+		title: "Athlete preferences",
+		description: "Notification and display preference flags for the athlete account.",
+		inputSchema: {},
+		annotations: READ
+	}, () => attempt(async () => jsonResult(await fetchAthletePrefs(ctx.client))));
+	server.registerTool("athlete_working_maxes", {
+		title: "Working maxes",
+		description: "The athlete's working max per exercise (drives % prescriptions).",
+		inputSchema: {},
+		annotations: READ
+	}, () => attempt(async () => jsonResult(await fetchWorkingMaxes(ctx.client))));
+	server.registerTool("athlete_leaderboard", {
+		title: "Benchmark leaderboard",
+		description: "Leaderboard for a benchmark/test workout by its workout id.",
+		inputSchema: {
+			workoutId: idParam,
+			page: z.number().int().positive().optional(),
+			pageSize: z.number().int().positive().max(200).optional(),
+			gender: z.number().int().optional()
+		},
+		annotations: READ
+	}, ({ workoutId, page, pageSize, gender }) => attempt(async () => {
+		const opts = {};
+		if (page !== void 0) opts.page = page;
+		if (pageSize !== void 0) opts.pageSize = pageSize;
+		if (gender !== void 0) opts.gender = gender;
+		return jsonResult(await fetchLeaderboard(ctx.client, toId(workoutId), opts));
+	}));
+}
+/** Workouts, exercise catalog, per-exercise history/PRs/stats. */
+function registerExerciseTools(server, ctx, userId) {
+	server.registerTool("athlete_workouts", {
+		title: "Workouts in a date range",
+		description: "Scheduled + completed workouts in an inclusive YYYY-MM-DD window, flattened to blocks/exercises with per-set prescriptions and positional units. Set raw:true for the untouched API objects. Narrow the window if the result is truncated.",
+		inputSchema: {
+			startDate: dateString,
+			endDate: dateString,
+			raw: z.boolean().optional()
+		},
+		annotations: READ
+	}, ({ startDate, endDate, raw }) => attempt(async () => {
+		const workouts = await fetchAthleteWorkouts(ctx.client, startDate, endDate);
+		return jsonResult(raw === true ? workouts : presentAthleteWorkouts(workouts), { hint: "Narrow startDate/endDate to shrink this result." });
+	}));
+	server.registerTool("athlete_exercises", {
+		title: "Search logged exercises",
+		description: "The exercises the athlete has logged (id + title + positional units). Pass q to free-text search by name; use the returned id with athlete_exercise_history / _stats.",
+		inputSchema: {
+			q: z.string().optional(),
+			limit: z.number().int().positive().max(200).optional()
+		},
+		annotations: READ
+	}, ({ q, limit }) => attempt(async () => {
+		return jsonResult((q !== void 0 && q.trim() !== "" ? await searchExerciseHistory(ctx.client, q, limit ?? 20) : await fetchExerciseHistoryList(ctx.client)).map((r) => ({
+			id: r.id,
+			title: r.title,
+			isCircuit: r.isCircuit ?? false,
+			units: exerciseUnits(r.param1Type, r.param2Type)
+		})), { hint: "Pass q to search by name, or limit to cap the list." });
+	}));
+	server.registerTool("athlete_exercise_history", {
+		title: "Exercise history + PRs",
+		description: "Per-exercise PRs and the dated session time-series (sets performed, estimated 1RM). Set raw:true for the untouched API object. Get the exercise id from athlete_exercises.",
+		inputSchema: {
+			exerciseId: idParam,
+			raw: z.boolean().optional()
+		},
+		annotations: READ
+	}, ({ exerciseId, raw }) => attempt(async () => {
+		const detail = await fetchExerciseHistoryDetail(ctx.client, toId(exerciseId), await userId());
+		return jsonResult(raw === true ? detail : presentExerciseHistory(detail));
+	}));
+	server.registerTool("athlete_personal_records", {
+		title: "Exercise personal records",
+		description: "Personal records for an exercise (reps/weight, strength-standard filters).",
+		inputSchema: { exerciseId: idParam },
+		annotations: READ
+	}, ({ exerciseId }) => attempt(async () => jsonResult(await fetchPersonalRecords(ctx.client, toId(exerciseId)))));
+	server.registerTool("athlete_exercise_stats", {
+		title: "Exercise stats (last performance + PR)",
+		description: "Last performance and PR for an exercise as of a date (YYYY-MM-DD, required by the API).",
+		inputSchema: {
+			exerciseId: idParam,
+			date: dateString
+		},
+		annotations: READ
+	}, ({ exerciseId, date }) => attempt(async () => jsonResult(await fetchExerciseStats(ctx.client, toId(exerciseId), await userId(), date))));
+}
+/** The gated set-logging write. */
+function registerLogTool(server, ctx) {
+	server.registerTool("athlete_log_set", {
+		title: "Log completed set results",
+		description: "Athlete-facing write: record entered results (reps/weight per set) for a saved workout set on a given day, marking the set completed. Writes to the athlete's (coach-visible) training log and shows in exercise history. Get savedWorkoutSetId + savedWorkoutSetExerciseId from athlete_workouts (raw:true). Requires confirmation (elicitation or confirm:true).",
+		inputSchema: {
+			...logSetArgsSchema.shape,
+			confirm: z.boolean().optional()
+		},
+		annotations: DESTRUCTIVE
+	}, ({ date, savedWorkoutSetId, results, confirm }, extra) => attempt(async () => {
+		if (!await confirmGate(server, extra.requestId, `Log results to saved workout set ${toId(savedWorkoutSetId)} on ${date}? This writes to your coach-visible training log.`, confirm)) return errorResult(NOT_CONFIRMED);
+		const mapped = results.map((r) => ({
+			savedWorkoutSetExerciseId: toId(r.savedWorkoutSetExerciseId),
+			sets: r.sets.map((s) => {
+				const slot = {};
+				if (s.param1 !== void 0) slot.param1 = s.param1;
+				if (s.param2 !== void 0) slot.param2 = s.param2;
+				return slot;
+			})
+		}));
+		return jsonResult(await logAthleteSet(ctx.client, {
+			date,
+			savedWorkoutSetId: toId(savedWorkoutSetId),
+			results: mapped
+		}));
+	}));
+}
+/**
+* Live tools over the logged-in user's own training (history, scheduled/completed workouts,
+* PRs, working maxes), plus a gated set-logging write. The athlete user id is
+* resolved once from /user/simple and reused across tools.
+*/
+function registerAthleteTrainingTools(server, ctx) {
+	let whoamiCache = null;
+	const whoami = async () => {
+		if (whoamiCache === null) {
+			const res = await ctx.client.request("GET", "/user/simple");
+			if (!res.ok || !isRecord(res.data)) throw new Error("Could not load /user/simple.");
+			whoamiCache = res.data;
+		}
+		return whoamiCache;
+	};
+	const userId = async () => {
+		const id = coerceInt((await whoami()).id);
+		if (id === null || id <= 0) throw new Error("Could not resolve athlete user id from /user/simple.");
+		return id;
+	};
+	registerProfileTools(server, ctx, whoami, userId);
+	registerExerciseTools(server, ctx, userId);
+	registerLogTool(server, ctx);
+}
+//#endregion
+//#region src/server.ts
+async function main() {
+	const email = process.env.TRAINHEROIC_EMAIL;
+	const password = process.env.TRAINHEROIC_PASSWORD;
+	if (!email || !password) {
+		process.stderr.write("Set TRAINHEROIC_EMAIL and TRAINHEROIC_PASSWORD in the environment.\n");
+		process.exit(1);
+	}
+	const client = new TrainHeroicClient(email, password);
+	const server = new McpServer({
+		name: "trainheroic-athlete",
+		version: "0.1.0"
+	});
+	registerAthleteTrainingTools(server, { client });
+	await server.connect(new StdioServerTransport());
+}
+await main();
+//#endregion
+export {};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@trainheroic-unofficial/athlete-mcp",
+  "version": "0.4.0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/alandotcom/trainheroic-unofficial.git",
+    "directory": "packages/athlete-mcp"
+  },
+  "description": "Local single-user MCP server for a TrainHeroic athlete. No database, no Cloudflare deps.",
+  "type": "module",
+  "bin": {
+    "trainheroic-athlete-mcp": "./dist/server.mjs"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^4.4.3",
+    "@trainheroic-unofficial/core": "0.4.0",
+    "@trainheroic-unofficial/js": "0.4.0"
+  },
+  "devDependencies": {
+    "@types/node": "^26.0.0",
+    "tsdown": "^0.22.3",
+    "tsx": "^4.22.4",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.9"
+  },
+  "scripts": {
+    "start": "tsx src/server.ts",
+    "inspect": "npx @modelcontextprotocol/inspector -e TRAINHEROIC_EMAIL=\"$TRAINHEROIC_EMAIL\" -e TRAINHEROIC_PASSWORD=\"$TRAINHEROIC_PASSWORD\" tsx src/server.ts",
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --passWithNoTests"
+  }
+}