sunderos-mcp 0.2.0

package/README.md

@@ -0,0 +1,56 @@
+# sunderos-mcp
+
+MCP server for Sunderos— a fitness tracking app with AI integration.
+
+Connect your AI assistant to your Sunderos instance and manage workouts, programs, and exercises through natural language.
+
+## Setup
+
+Add this to your `.mcp.json` (Claude Code, Gemini CLI, or any MCP client):
+
+```json
+{
+  "mcpServers": {
+    "sunderos": {
+      "command": "npx",
+      "args": ["-y", "sunderos-mcp"],
+      "env": {
+        "SUNDEROS_API_URL": "https://your-instance.example.com",
+        "SUNDEROS_API_KEY": "so_xxx"
+      }
+    }
+  }
+}
+```
+
+### Getting an API Key
+
+1. Log in to your Sunderos instance
+2. Go to **Settings > API Keys**
+3. Create a new key and copy the `so_xxx` value
+
+### Environment Variables
+
+| Variable | Required | Default | Description |
+|----------|----------|---------|-------------|
+| `SUNDEROS_API_KEY` | Yes | — | Your API key (`so_xxx`) |
+| `SUNDEROS_API_URL` | Yes | — | Base URL of your Sunderos instance |
+
+## What You Can Do
+
+Talk to your AI naturally — the MCP tools handle the rest:
+
+- "Show me my workout history for this week"
+- "Create a 4-week upper/lower program"
+- "What's my bench press PR?"
+- "Log my body weight at 185 lbs"
+- "Suggest weight adjustments based on my recent RPE"
+- "Build me a push day template with 4 exercises"
+- "How has my squat progressed over the last month?"
+
+23 tools are available covering exercises, templates, programs, workout history, stats, body weight, and more.
+
+## Requirements
+
+- Node.js 22+
+- A running Sunderos instance with an API key

package/dist/api-client.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Simple HTTP client for the Sunderos REST API.
+ * Authenticates via API key (Bearer token).
+ */
+export declare class ApiError extends Error {
+    status: number;
+    constructor(status: number, message: string);
+}
+export declare const api: {
+    get: <T = unknown>(path: string) => Promise<T>;
+    post: <T = unknown>(path: string, body?: unknown) => Promise<T>;
+    put: <T = unknown>(path: string, body?: unknown) => Promise<T>;
+    delete: <T = unknown>(path: string) => Promise<T>;
+};
+//# sourceMappingURL=api-client.d.ts.map

package/dist/api-client.js

@@ -0,0 +1,60 @@
+/**
+ * Simple HTTP client for the Sunderos REST API.
+ * Authenticates via API key (Bearer token).
+ */
+const API_URL = process.env.SUNDEROS_API_URL || '';
+if (!API_URL) {
+    console.error('Warning: SUNDEROS_API_URL not set. API requests will fail.');
+}
+const API_KEY = process.env.SUNDEROS_API_KEY || '';
+if (!API_KEY) {
+    console.error('Warning: SUNDEROS_API_KEY not set. API requests will fail authentication.');
+}
+export class ApiError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = 'ApiError';
+    }
+}
+async function request(method, path, body) {
+    const url = `${API_URL}${path}`;
+    const headers = {
+        Authorization: `Bearer ${API_KEY}`,
+    };
+    if (body) {
+        headers['Content-Type'] = 'application/json';
+    }
+    const res = await fetch(url, {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : undefined,
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        let message = `API ${method} ${path} failed with status ${res.status}`;
+        try {
+            const json = JSON.parse(text);
+            if (json.error)
+                message = json.error;
+        }
+        catch {
+            if (text)
+                message = text;
+        }
+        throw new ApiError(res.status, message);
+    }
+    const contentType = res.headers.get('content-type') || '';
+    if (contentType.includes('application/json')) {
+        return res.json();
+    }
+    return res.text();
+}
+export const api = {
+    get: (path) => request('GET', path),
+    post: (path, body) => request('POST', path, body),
+    put: (path, body) => request('PUT', path, body),
+    delete: (path) => request('DELETE', path),
+};
+//# sourceMappingURL=api-client.js.map

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,720 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { createMcpExpressApp } from '@modelcontextprotocol/sdk/server/express.js';
+import { z } from 'zod';
+import { api } from './api-client.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function formatDate(d) {
+    if (!d)
+        return '—';
+    return new Date(d).toLocaleDateString('en-US', { weekday: 'short', year: 'numeric', month: 'short', day: 'numeric' });
+}
+function getErrorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+// ---------------------------------------------------------------------------
+// MCP Server
+// ---------------------------------------------------------------------------
+const server = new McpServer({
+    name: 'sunderos',
+    version: '0.2.0',
+});
+// ===========================
+// EXERCISES
+// ===========================
+server.tool('list_exercises', 'List available exercises, optionally filtered by muscle group, equipment, or name search', {
+    search: z.string().optional().describe('Search exercises by name (partial match)'),
+    muscle_group: z.enum(['chest', 'back', 'shoulders', 'biceps', 'triceps', 'forearms', 'legs', 'glutes', 'core', 'full_body']).optional(),
+    equipment: z.enum(['barbell', 'dumbbell', 'machine', 'bodyweight', 'cable', 'kettlebell', 'band', 'other']).optional(),
+    limit: z.number().min(1).max(100).default(50).optional(),
+}, async ({ search, muscle_group, equipment }) => {
+    const params = new URLSearchParams();
+    if (search)
+        params.set('search', search);
+    if (muscle_group)
+        params.set('muscleGroup', muscle_group);
+    if (equipment)
+        params.set('equipment', equipment);
+    const rows = await api.get(`/api/exercises?${params}`);
+    const text = rows.length === 0
+        ? 'No exercises found.'
+        : rows.map((e) => `• **${e.name}** — ${e.muscleGroup || '?'} / ${e.equipment || '?'} (ID: ${e.id})`).join('\n');
+    return { content: [{ type: 'text', text: `Found ${rows.length} exercise(s):\n\n${text}` }] };
+});
+server.tool('create_exercise', 'Create a new exercise in the database', {
+    name: z.string().describe('Exercise name'),
+    muscle_group: z.enum(['chest', 'back', 'shoulders', 'biceps', 'triceps', 'forearms', 'legs', 'glutes', 'core', 'full_body']),
+    equipment: z.enum(['barbell', 'dumbbell', 'machine', 'bodyweight', 'cable', 'kettlebell', 'band', 'other']),
+    notes: z.string().optional().describe('Notes or cues for the exercise'),
+}, async ({ name, muscle_group, equipment, notes }) => {
+    const ex = await api.post('/api/exercises', {
+        name,
+        muscleGroup: muscle_group,
+        equipment,
+        notes: notes || undefined,
+    });
+    return { content: [{ type: 'text', text: `Created exercise "${ex.name}" (ID: ${ex.id})` }] };
+});
+server.tool('delete_exercise', 'Delete a custom exercise by ID', {
+    exercise_id: z.string().uuid().describe('Exercise ID to delete'),
+}, async ({ exercise_id }) => {
+    try {
+        await api.delete(`/api/exercises/${exercise_id}`);
+        return { content: [{ type: 'text', text: `Deleted exercise.` }] };
+    }
+    catch (err) {
+        return { content: [{ type: 'text', text: `Error: ${getErrorMessage(err)}` }] };
+    }
+});
+// ===========================
+// TEMPLATES
+// ===========================
+server.tool('list_templates', 'List workout templates for the user', {
+    search: z.string().optional().describe('Search templates by name'),
+}, async ({ search }) => {
+    const params = new URLSearchParams();
+    if (search)
+        params.set('search', search);
+    const rows = await api.get(`/api/templates?${params}`);
+    if (rows.length === 0)
+        return { content: [{ type: 'text', text: 'No templates found.' }] };
+    const text = rows
+        .map((t) => {
+        const prefix = t.userId === null ? '[Built-in] ' : '';
+        const cat = t.category ? ` [${t.category}]` : '';
+        const tags = t.tags && t.tags.length > 0 ? ` (${t.tags.join(', ')})` : '';
+        return `• ${prefix}**${t.name}**${cat}${tags} — ${t.description || 'No description'} (ID: ${t.id})`;
+    })
+        .join('\n');
+    return { content: [{ type: 'text', text: `${rows.length} template(s):\n\n${text}` }] };
+});
+server.tool('get_template', 'Get full details of a workout template including its exercises and set schemes', {
+    template_id: z.string().uuid().describe('Template ID'),
+}, async ({ template_id }) => {
+    try {
+        const tmpl = await api.get(`/api/templates/${template_id}`);
+        const exText = (tmpl.exercises || []).map((e, i) => {
+            const scheme = (e.setScheme || [])
+                .map((s) => `${s.sets}×${s.reps_min}${s.reps_max !== s.reps_min ? '-' + s.reps_max : ''} ${s.type}`)
+                .join(', ');
+            return `  ${i + 1}. **${e.exerciseName || e.name}** (${e.muscleGroup} / ${e.equipment}) — ${scheme} | Rest: ${e.restSeconds ?? 90}s${e.notes ? ' | Notes: ' + e.notes : ''}`;
+        }).join('\n');
+        const cat = tmpl.category ? `\nCategory: ${tmpl.category}` : '';
+        return {
+            content: [{
+                    type: 'text',
+                    text: `**${tmpl.name}**\n${tmpl.description || ''}${cat}\nTags: ${tmpl.tags?.join(', ') || 'none'}\n\nExercises:\n${exText || '  (none)'}`,
+                }],
+        };
+    }
+    catch (err) {
+        return { content: [{ type: 'text', text: `Error: ${getErrorMessage(err)}` }] };
+    }
+});
+server.tool('create_template', 'Create a new workout template with exercises and set schemes', {
+    name: z.string().describe('Template name'),
+    description: z.string().optional(),
+    category: z.string().optional().describe('Category/folder (e.g., "Push", "Pull", "Legs", "Full Body")'),
+    exercises: z.array(z.object({
+        exercise_id: z.string().uuid().describe('Exercise ID'),
+        set_scheme: z.array(z.object({
+            sets: z.number().min(1).describe('Number of sets of this type'),
+            reps_min: z.number().min(1),
+            reps_max: z.number().min(1),
+            rpe_target: z.number().min(1).max(10).optional().describe('Target RPE (1-10)'),
+            type: z.enum(['warmup', 'working', 'backoff', 'drop', 'amrap']).default('working'),
+        })).describe('Set groups for this exercise'),
+        rest_seconds: z.number().optional().describe('Rest between sets (seconds)'),
+        superset_group: z.number().optional().describe('Group number to superset exercises together'),
+        notes: z.string().optional(),
+    })).describe('Exercises with set schemes'),
+}, async ({ name, description, category, exercises: exList }) => {
+    const tmpl = await api.post('/api/templates', {
+        name,
+        description: description || undefined,
+        category: category || undefined,
+        exercises: exList.map((ex, i) => ({
+            exerciseId: ex.exercise_id,
+            orderIndex: i,
+            setScheme: ex.set_scheme.map(s => ({
+                sets: s.sets,
+                reps_min: s.reps_min,
+                reps_max: s.reps_max,
+                rpe_target: s.rpe_target,
+                type: s.type,
+            })),
+            restSeconds: ex.rest_seconds ?? 90,
+            supersetGroup: ex.superset_group ?? null,
+            notes: ex.notes || null,
+        })),
+    });
+    const totalSets = exList.reduce((sum, ex) => sum + ex.set_scheme.reduce((s, g) => s + g.sets, 0), 0);
+    return { content: [{ type: 'text', text: `Created template "${tmpl.name}" with ${exList.length} exercise(s), ${totalSets} total sets (ID: ${tmpl.id})` }] };
+});
+server.tool('update_template', 'Update an existing workout template (name, description, category, and/or exercises). Only provided fields are changed. If exercises are provided, they fully replace the existing list.', {
+    template_id: z.string().uuid().describe('Template ID to update'),
+    name: z.string().optional().describe('New template name'),
+    description: z.string().optional().describe('New description'),
+    category: z.string().optional().describe('New category'),
+    exercises: z.array(z.object({
+        exercise_id: z.string().uuid().describe('Exercise ID'),
+        set_scheme: z.array(z.object({
+            sets: z.number().min(1).describe('Number of sets of this type'),
+            reps_min: z.number().min(1),
+            reps_max: z.number().min(1),
+            rpe_target: z.number().min(1).max(10).optional().describe('Target RPE (1-10)'),
+            type: z.enum(['warmup', 'working', 'backoff', 'drop', 'amrap']).default('working'),
+        })).describe('Set groups for this exercise'),
+        rest_seconds: z.number().optional().describe('Rest between sets (seconds)'),
+        superset_group: z.number().optional().describe('Group number to superset exercises together'),
+        notes: z.string().optional(),
+    })).optional().describe('Full replacement exercise list (omit to keep existing exercises)'),
+}, async ({ template_id, name, description, category, exercises: exList }) => {
+    try {
+        const body = {};
+        if (name !== undefined)
+            body.name = name;
+        if (description !== undefined)
+            body.description = description;
+        if (category !== undefined)
+            body.category = category;
+        if (exList !== undefined) {
+            body.exercises = exList.map((ex, i) => ({
+                exerciseId: ex.exercise_id,
+                orderIndex: i,
+                setScheme: ex.set_scheme.map(s => ({
+                    sets: s.sets,
+                    reps_min: s.reps_min,
+                    reps_max: s.reps_max,
+                    rpe_target: s.rpe_target,
+                    type: s.type,
+                })),
+                restSeconds: ex.rest_seconds ?? 90,
+                supersetGroup: ex.superset_group ?? null,
+                notes: ex.notes || null,
+            }));
+        }
+        const tmpl = await api.put(`/api/templates/${template_id}`, body);
+        const parts = [`Updated template "${tmpl.name}" (ID: ${tmpl.id})`];
+        if (exList !== undefined) {
+            const totalSets = exList.reduce((sum, ex) => sum + ex.set_scheme.reduce((s, g) => s + g.sets, 0), 0);
+            parts.push(`${exList.length} exercise(s), ${totalSets} total sets`);
+        }
+        return { content: [{ type: 'text', text: parts.join(' — ') }] };
+    }
+    catch (err) {
+        return { content: [{ type: 'text', text: `Error: ${getErrorMessage(err)}` }] };
+    }
+});
+server.tool('delete_template', 'Delete a workout template by ID', {
+    template_id: z.string().uuid(),
+}, async ({ template_id }) => {
+    try {
+        await api.delete(`/api/templates/${template_id}`);
+        return { content: [{ type: 'text', text: `Deleted template.` }] };
+    }
+    catch (err) {
+        return { content: [{ type: 'text', text: `Error: ${getErrorMessage(err)}` }] };
+    }
+});
+// ===========================
+// PROGRAMS
+// ===========================
+server.tool('list_programs', 'List training programs. Shows which program is active.', {}, async () => {
+    const rows = await api.get('/api/programs');
+    if (rows.length === 0)
+        return { content: [{ type: 'text', text: 'No programs found.' }] };
+    const text = rows
+        .map((p) => {
+        const prefix = p.userId === null ? '[Built-in] ' : '';
+        return `• ${p.isActive ? '✅ ' : ''}${prefix}**${p.name}** — ${p.weeks} week(s), ${p.mode} mode (ID: ${p.id})${p.description ? '\n  ' + p.description : ''}`;
+    })
+        .join('\n');
+    return { content: [{ type: 'text', text: `${rows.length} program(s):\n\n${text}` }] };
+});
+server.tool('get_program', 'Get full details of a program including its schedule (days/weeks/templates)', {
+    program_id: z.string().uuid(),
+}, async ({ program_id }) => {
+    try {
+        const prog = await api.get(`/api/programs/${program_id}`);
+        const DAY_NAMES = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+        const dayText = (prog.days || []).map((d) => {
+            const dayLabel = prog.mode === 'sequential' ? `Day ${d.dayOfWeek + 1}` : DAY_NAMES[d.dayOfWeek];
+            if (d.isRestDay)
+                return `  W${d.weekNumber} ${dayLabel}: Rest`;
+            return `  W${d.weekNumber} ${dayLabel}: ${d.templateName || d.label || '(no template)'}`;
+        }).join('\n');
+        return {
+            content: [{
+                    type: 'text',
+                    text: `**${prog.name}**${prog.isActive ? ' ✅ Active' : ''}\n${prog.description || ''}\nMode: ${prog.mode} | Weeks: ${prog.weeks} | Progress: Day ${(prog.currentDayIndex || 0) + 1}\n\nSchedule:\n${dayText || '  (empty)'}`,
+                }],
+        };
+    }
+    catch (err) {
+        return { content: [{ type: 'text', text: `Error: ${getErrorMessage(err)}` }] };
+    }
+});
+server.tool('create_program', 'Create a training program with a weekly or sequential schedule', {
+    name: z.string(),
+    description: z.string().optional(),
+    mode: z.enum(['weekly', 'sequential']).default('weekly'),
+    weeks: z.number().min(1).max(52).default(4),
+    days: z.array(z.object({
+        week_number: z.number().min(1),
+        day_of_week: z.number().min(0).max(6).describe('0=Sun .. 6=Sat (weekly), or 0-based index (sequential)'),
+        template_id: z.string().uuid().optional().describe('Template to assign (omit for rest day)'),
+        label: z.string().optional(),
+        is_rest_day: z.boolean().default(false),
+    })).describe('Schedule entries'),
+    activate: z.boolean().default(false).describe('Set this program as the active program'),
+}, async ({ name, description, mode, weeks, days: dayList, activate }) => {
+    const prog = await api.post('/api/programs', {
+        name,
+        description: description || undefined,
+        mode,
+        weeks,
+        days: dayList.map(d => ({
+            weekNumber: d.week_number,
+            dayOfWeek: d.day_of_week,
+            templateId: d.template_id || null,
+            label: d.label || null,
+            isRestDay: d.is_rest_day,
+        })),
+    });
+    if (activate && prog.id) {
+        await api.post(`/api/programs/${prog.id}/activate`);
+    }
+    return { content: [{ type: 'text', text: `Created program "${prog.name}" with ${dayList.length} scheduled day(s) (ID: ${prog.id})${activate ? ' — set as active' : ''}` }] };
+});
+server.tool('activate_program', 'Set a program as the active training program (deactivates others)', {
+    program_id: z.string().uuid(),
+}, async ({ program_id }) => {
+    try {
+        const result = await api.post(`/api/programs/${program_id}/activate`);
+        return { content: [{ type: 'text', text: `Activated program "${result.name || program_id}".` }] };
+    }
+    catch (err) {
+        return { content: [{ type: 'text', text: `Error: ${getErrorMessage(err)}` }] };
+    }
+});
+server.tool('update_program', 'Update an existing training program (name, description, weeks, mode, and/or schedule). If days are provided, they fully replace the existing schedule.', {
+    program_id: z.string().uuid().describe('Program ID to update'),
+    name: z.string().describe('Program name'),
+    description: z.string().optional(),
+    mode: z.enum(['weekly', 'sequential']).default('weekly'),
+    weeks: z.number().min(1).max(52).default(4),
+    days: z.array(z.object({
+        week_number: z.number().min(1),
+        day_of_week: z.number().min(0).max(6).describe('0=Sun .. 6=Sat (weekly), or 0-based index (sequential)'),
+        template_id: z.string().uuid().optional().describe('Template to assign (omit for rest day)'),
+        label: z.string().optional(),
+        is_rest_day: z.boolean().default(false),
+    })).describe('Schedule entries (replaces existing schedule)'),
+}, async ({ program_id, name, description, mode, weeks, days: dayList }) => {
+    try {
+        const prog = await api.put(`/api/programs/${program_id}`, {
+            name,
+            description: description || undefined,
+            mode,
+            weeks,
+            days: dayList.map(d => ({
+                weekNumber: d.week_number,
+                dayOfWeek: d.day_of_week,
+                templateId: d.template_id || null,
+                label: d.label || null,
+                isRestDay: d.is_rest_day,
+            })),
+        });
+        return { content: [{ type: 'text', text: `Updated program "${prog.name}" with ${dayList.length} scheduled day(s) (ID: ${prog.id})` }] };
+    }
+    catch (err) {
+        return { content: [{ type: 'text', text: `Error: ${getErrorMessage(err)}` }] };
+    }
+});
+server.tool('delete_program', 'Delete a training program and all its scheduled days', {
+    program_id: z.string().uuid().describe('Program ID to delete'),
+}, async ({ program_id }) => {
+    try {
+        await api.delete(`/api/programs/${program_id}`);
+        return { content: [{ type: 'text', text: `Deleted program.` }] };
+    }
+    catch (err) {
+        return { content: [{ type: 'text', text: `Error: ${getErrorMessage(err)}` }] };
+    }
+});
+// ===========================
+// WORKOUT HISTORY & STATS
+// ===========================
+server.tool('get_workout_history', 'Get recent workout sessions with stats (duration, volume, exercise count)', {
+    limit: z.number().min(1).max(50).default(10).optional(),
+}, async ({ limit }) => {
+    const sessions = await api.get(`/api/sessions?limit=${limit ?? 10}`);
+    if (sessions.length === 0)
+        return { content: [{ type: 'text', text: 'No completed workouts yet.' }] };
+    const text = sessions.map((s) => {
+        const dur = s.finishedAt && s.startedAt
+            ? Math.round((new Date(s.finishedAt).getTime() - new Date(s.startedAt).getTime()) / 60000)
+            : '?';
+        const tags = s.tags && s.tags.length > 0 ? ` [${s.tags.join(', ')}]` : '';
+        const vol = s.totalVolume || s.volume || 0;
+        const exCount = s.exerciseCount || s.exercises?.length || 0;
+        const setCount = s.totalSets || s.setCount || 0;
+        return `• **${formatDate(s.startedAt)}** — ${s.templateName || s.name || 'Quick Workout'}${tags}\n  ${exCount} exercises, ${setCount} sets, ${Math.round(vol).toLocaleString()} lb volume, ${dur} min${s.notes ? '\n  Notes: ' + s.notes : ''}`;
+    }).join('\n');
+    return { content: [{ type: 'text', text: `Last ${sessions.length} workout(s):\n\n${text}` }] };
+});
+server.tool('get_workout_details', 'Get detailed breakdown of a specific workout session (every set logged)', {
+    session_id: z.string().uuid(),
+}, async ({ session_id }) => {
+    try {
+        const session = await api.get(`/api/sessions/${session_id}`);
+        const sets = session.sets || [];
+        const grouped = {};
+        sets.forEach((s) => {
+            const name = s.exerciseName || s.exercise?.name || 'Unknown';
+            if (!grouped[name])
+                grouped[name] = [];
+            grouped[name].push(s);
+        });
+        const text = Object.entries(grouped).map(([name, exSets]) => {
+            const setLines = exSets.map((s) => `    Set ${(s.setIndex || 0) + 1} (${s.setType || 'working'}): ${s.weight || 0}lb × ${s.reps || 0}${s.rpe ? ` @RPE ${s.rpe}` : ''}`).join('\n');
+            return `  **${name}**\n${setLines}`;
+        }).join('\n\n');
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Workout on ${formatDate(session.startedAt)}:\n\n${text || '  (no sets logged)'}`,
+                }],
+        };
+    }
+    catch (err) {
+        return { content: [{ type: 'text', text: `Error: ${getErrorMessage(err)}` }] };
+    }
+});
+server.tool('get_exercise_stats', 'Get stats and PR history for a specific exercise (best weight, est. 1RM, volume trends)', {
+    exercise_id: z.string().uuid().optional().describe('Exercise ID (provide this or exercise_name)'),
+    exercise_name: z.string().optional().describe('Exercise name (partial match, used if exercise_id not provided)'),
+}, async ({ exercise_id, exercise_name }) => {
+    let exId = exercise_id;
+    let exName = '';
+    if (!exId && exercise_name) {
+        const results = await api.get(`/api/exercises?search=${encodeURIComponent(exercise_name)}`);
+        if (results.length === 0)
+            return { content: [{ type: 'text', text: `No exercise found matching "${exercise_name}".` }] };
+        exId = results[0].id;
+        exName = results[0].name;
+    }
+    else if (exId) {
+        try {
+            const ex = await api.get(`/api/exercises/${exId}`);
+            exName = ex.name || 'Unknown';
+        }
+        catch {
+            exName = 'Unknown';
+        }
+    }
+    if (!exId)
+        return { content: [{ type: 'text', text: 'Provide exercise_id or exercise_name.' }] };
+    try {
+        const stats = await api.get(`/api/prs/exercise/${exId}`);
+        const lines = [
+            `**${exName}** — Stats`,
+            '',
+            `Best Weight: ${stats.bestWeight || 0}lb × ${stats.bestWeightReps || 0}`,
+            `Est. 1RM: ${stats.estimated1RM || 0}lb`,
+            `Total Volume: ${Math.round(stats.totalVolume || 0).toLocaleString()}lb`,
+        ];
+        if (stats.recentSessions && stats.recentSessions.length > 0) {
+            lines.push('', 'Recent sessions:');
+            stats.recentSessions.forEach((s) => {
+                lines.push(`  ${formatDate(s.date ?? s.startedAt ?? null)}: ${s.sets || 0} sets, max ${s.maxWeight || 0}lb, ${Math.round(s.totalVolume || 0).toLocaleString()}lb vol`);
+            });
+        }
+        return { content: [{ type: 'text', text: lines.join('\n') }] };
+    }
+    catch (err) {
+        return { content: [{ type: 'text', text: `No stats found for "${exName}": ${getErrorMessage(err)}` }] };
+    }
+});
+server.tool('get_prs', 'Get personal records across all exercises (highest weight for each exercise)', {}, async () => {
+    try {
+        const rows = await api.get('/api/prs/recent');
+        if (rows.length === 0)
+            return { content: [{ type: 'text', text: 'No PRs recorded yet.' }] };
+        const text = rows.map((r) => `• **${r.exerciseName || r.name}**: ${r.weight || r.maxWeight}lb × ${r.reps || '?'}`).join('\n');
+        return { content: [{ type: 'text', text: `Personal Records:\n\n${text}` }] };
+    }
+    catch (err) {
+        return { content: [{ type: 'text', text: `Error: ${getErrorMessage(err)}` }] };
+    }
+});
+// ===========================
+// BODY WEIGHT
+// ===========================
+server.tool('log_body_weight', 'Log a body weight measurement for a specific date', {
+    weight: z.number().positive().describe('Body weight value'),
+    date: z.string().optional().describe('Date in YYYY-MM-DD format (defaults to today)'),
+    unit: z.enum(['lb', 'kg']).default('lb').optional(),
+    notes: z.string().optional(),
+}, async ({ weight, date, unit, notes }) => {
+    const dateStr = date || new Date().toISOString().split('T')[0];
+    await api.post('/api/bodyweight', {
+        weight,
+        date: dateStr,
+        unit: unit || 'lb',
+        notes: notes || undefined,
+    });
+    return { content: [{ type: 'text', text: `Logged body weight: ${weight} ${unit || 'lb'} on ${dateStr}` }] };
+});
+server.tool('get_body_weight_history', 'Get body weight history (recent entries and trend)', {
+    limit: z.number().min(1).max(100).default(30).optional(),
+}, async ({ limit }) => {
+    const res = await api.get(`/api/bodyweight?limit=${limit ?? 30}`);
+    const rows = res.entries;
+    if (rows.length === 0)
+        return { content: [{ type: 'text', text: 'No body weight entries yet.' }] };
+    const weights = rows.map((r) => Number(r.weight));
+    const latest = weights[0];
+    const oldest = weights[weights.length - 1];
+    const change = latest - oldest;
+    const avg = (weights.reduce((a, b) => a + b, 0) / weights.length).toFixed(1);
+    const text = rows.slice(0, 15).map((r) => `  ${r.date}: **${Number(r.weight)}** ${r.unit}${r.notes ? ' — ' + r.notes : ''}`).join('\n');
+    return {
+        content: [{
+                type: 'text',
+                text: [
+                    `Body Weight (last ${rows.length} entries):`,
+                    '',
+                    `Current: ${latest} lb | Average: ${avg} lb | Change: ${change >= 0 ? '+' : ''}${change.toFixed(1)} lb`,
+                    '',
+                    text,
+                    rows.length > 15 ? `  ... and ${rows.length - 15} more` : '',
+                ].join('\n'),
+            }],
+    };
+});
+// ===========================
+// RPE AUTOREGULATION
+// ===========================
+server.tool('suggest_weight_adjustments', 'Analyze recent RPE data for an exercise and suggest weight adjustments. Uses RPE-based autoregulation.', {
+    exercise_id: z.string().uuid().optional(),
+    exercise_name: z.string().optional().describe('Exercise name (partial match)'),
+    target_rpe: z.number().min(1).max(10).default(8).optional().describe('Target RPE for working sets (default: 8)'),
+}, async ({ exercise_id, exercise_name, target_rpe }) => {
+    let exId = exercise_id;
+    let exName = '';
+    if (!exId && exercise_name) {
+        const results = await api.get(`/api/exercises?search=${encodeURIComponent(exercise_name)}`);
+        if (results.length === 0)
+            return { content: [{ type: 'text', text: `No exercise found matching "${exercise_name}".` }] };
+        exId = results[0].id;
+        exName = results[0].name;
+    }
+    else if (exId) {
+        try {
+            const ex = await api.get(`/api/exercises/${exId}`);
+            exName = ex.name || 'Unknown';
+        }
+        catch {
+            exName = 'Unknown';
+        }
+    }
+    if (!exId)
+        return { content: [{ type: 'text', text: 'Provide exercise_id or exercise_name.' }] };
+    const tRpe = target_rpe ?? 8;
+    try {
+        const stats = await api.get(`/api/prs/exercise/${exId}`);
+        if (!stats.recentSessions || stats.recentSessions.length === 0) {
+            return { content: [{ type: 'text', text: `No session data found for "${exName}". Log sets with RPE to get weight suggestions.` }] };
+        }
+        const lastSession = stats.recentSessions[0];
+        const lastWeight = lastSession.maxWeight || 0;
+        const avgRpe = lastSession.avgRpe || 0;
+        if (avgRpe === 0) {
+            return { content: [{ type: 'text', text: `No RPE data found for "${exName}". Log sets with RPE to get weight suggestions.` }] };
+        }
+        const rpeDiff = avgRpe - tRpe;
+        let suggestion = '';
+        let newWeight = lastWeight;
+        if (rpeDiff <= -2) {
+            const bump = lastWeight >= 100 ? 10 : 5;
+            newWeight = lastWeight + bump;
+            suggestion = `RPE was well below target (avg ${avgRpe.toFixed(1)} vs target ${tRpe}). **Increase weight by ${bump}lb to ${newWeight}lb.**`;
+        }
+        else if (rpeDiff <= -0.5) {
+            const bump = lastWeight >= 100 ? 5 : 2.5;
+            newWeight = lastWeight + bump;
+            suggestion = `RPE slightly below target (avg ${avgRpe.toFixed(1)} vs target ${tRpe}). **Increase weight by ${bump}lb to ${newWeight}lb.**`;
+        }
+        else if (rpeDiff <= 0.5) {
+            suggestion = `RPE is on target (avg ${avgRpe.toFixed(1)} vs target ${tRpe}). **Keep weight at ${lastWeight}lb.** Good work.`;
+        }
+        else if (rpeDiff <= 1.5) {
+            suggestion = `RPE slightly above target (avg ${avgRpe.toFixed(1)} vs target ${tRpe}). **Keep weight at ${lastWeight}lb** but monitor fatigue.`;
+        }
+        else {
+            const drop = lastWeight >= 100 ? 10 : 5;
+            newWeight = lastWeight - drop;
+            suggestion = `RPE well above target (avg ${avgRpe.toFixed(1)} vs target ${tRpe}). **Decrease weight by ${drop}lb to ${newWeight}lb.**`;
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: [
+                        `**${exName}** — Weight Suggestion`,
+                        '',
+                        suggestion,
+                        '',
+                        `Last session (${formatDate(lastSession.date ?? lastSession.startedAt ?? null)}):`,
+                        `  ${lastSession.sets || 0} sets, max ${lastWeight}lb, avg RPE ${avgRpe.toFixed(1)}`,
+                    ].join('\n'),
+                }],
+        };
+    }
+    catch (err) {
+        return { content: [{ type: 'text', text: `Error getting stats for "${exName}": ${getErrorMessage(err)}` }] };
+    }
+});
+// ===========================
+// DATA EXPORT
+// ===========================
+server.tool('export_data', 'Export all user data as JSON (exercises, templates, programs, sessions, body weight)', {}, async () => {
+    try {
+        const data = await api.get('/api/settings/export');
+        const summary = {
+            exercises: data.exercises?.length || 0,
+            templates: data.templates?.length || 0,
+            programs: data.programs?.length || 0,
+            sessions: data.sessions?.length || 0,
+            bodyWeightEntries: data.bodyWeights?.length || 0,
+        };
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Data export summary:\n• ${summary.exercises} exercises\n• ${summary.templates} templates\n• ${summary.programs} programs\n• ${summary.sessions} completed sessions\n• ${summary.bodyWeightEntries} body weight entries\n\nUse the app's Settings > Export feature to download a full JSON backup.`,
+                }],
+        };
+    }
+    catch (err) {
+        return { content: [{ type: 'text', text: `Export error: ${getErrorMessage(err)}` }] };
+    }
+});
+// ===========================
+// QUICK STATUS
+// ===========================
+server.tool('get_training_summary', 'Get a high-level summary of current training status: active program, recent workouts, body weight trend', {}, async () => {
+    try {
+        const [stats, programs, bodyWeights] = await Promise.all([
+            api.get('/api/dashboard/stats').catch(() => null),
+            api.get('/api/programs').catch(() => []),
+            api.get('/api/bodyweight?limit=1').then((r) => r.entries).catch(() => []),
+        ]);
+        const activeProg = programs.find((p) => p.isActive);
+        const latestBw = bodyWeights[0];
+        const lines = [
+            '**Training Summary**',
+            '',
+            `Active Program: ${activeProg ? activeProg.name + ' (' + activeProg.mode + ')' : 'None'}`,
+            `This Week: ${stats?.weeklyWorkouts || 0} workout(s), ${Math.round(stats?.weeklyVolume || 0).toLocaleString()}lb total volume`,
+            `All Time: ${stats?.totalSessions || 0} completed sessions`,
+            latestBw ? `Body Weight: ${Number(latestBw.weight)} ${latestBw.unit} (${latestBw.date})` : 'Body Weight: Not tracked yet',
+        ];
+        return { content: [{ type: 'text', text: lines.join('\n') }] };
+    }
+    catch (err) {
+        return { content: [{ type: 'text', text: `Error: ${getErrorMessage(err)}` }] };
+    }
+});
+// ---------------------------------------------------------------------------
+// Transport: stdio (Claude Code, Cursor) or HTTP (ChatGPT, remote clients)
+// ---------------------------------------------------------------------------
+async function main() {
+    const transport = process.env.MCP_TRANSPORT || 'stdio';
+    if (transport === 'http' || transport === 'sse') {
+        // HTTP mode for remote clients (ChatGPT, etc.)
+        const port = parseInt(process.env.MCP_PORT || '3001', 10);
+        const host = process.env.MCP_HOST || '0.0.0.0';
+        const app = createMcpExpressApp({ host });
+        // Require API key for HTTP transport — reject unauthenticated MCP sessions
+        const MCP_API_KEY = process.env.MCP_API_KEY || process.env.SUNDEROS_API_KEY || '';
+        if (!MCP_API_KEY) {
+            console.error('Warning: No MCP_API_KEY or SUNDEROS_API_KEY set. HTTP transport will reject all requests.');
+        }
+        function requireApiKey(req, res, next) {
+            // Skip auth for health check
+            if (req.path === '/health')
+                return next();
+            const authHeader = req.headers.authorization;
+            if (!authHeader || !authHeader.startsWith('Bearer ')) {
+                res.status(401).json({ error: 'Missing Authorization header. Use: Bearer <api-key>' });
+                return;
+            }
+            const providedKey = authHeader.slice(7);
+            if (providedKey !== MCP_API_KEY) {
+                res.status(403).json({ error: 'Invalid API key' });
+                return;
+            }
+            next();
+        }
+        app.use(requireApiKey);
+        const transports = {};
+        app.post('/mcp', async (req, res) => {
+            const sessionId = req.headers['mcp-session-id'];
+            if (sessionId && transports[sessionId]) {
+                await transports[sessionId].handleRequest(req, res);
+            }
+            else {
+                const newTransport = new StreamableHTTPServerTransport({
+                    sessionIdGenerator: () => crypto.randomUUID(),
+                });
+                await server.connect(newTransport);
+                const id = await newTransport.sessionId;
+                if (id)
+                    transports[id] = newTransport;
+                await newTransport.handleRequest(req, res);
+            }
+        });
+        app.get('/mcp', async (req, res) => {
+            const sessionId = req.headers['mcp-session-id'];
+            if (sessionId && transports[sessionId]) {
+                await transports[sessionId].handleRequest(req, res);
+            }
+            else {
+                res.status(400).json({ error: 'Missing or invalid session ID' });
+            }
+        });
+        app.delete('/mcp', async (req, res) => {
+            const sessionId = req.headers['mcp-session-id'];
+            if (sessionId && transports[sessionId]) {
+                await transports[sessionId].handleRequest(req, res);
+                delete transports[sessionId];
+            }
+            else {
+                res.status(400).json({ error: 'Missing or invalid session ID' });
+            }
+        });
+        app.get('/health', (_req, res) => {
+            res.json({ status: 'ok', transport: 'http', tools: 23 });
+        });
+        app.listen(port, host, () => {
+            console.error(`Sunderos MCP Server running on http://${host}:${port}/mcp`);
+            console.error(`Health check: http://${host}:${port}/health`);
+        });
+    }
+    else {
+        // stdio mode for local clients (Claude Code, Cursor)
+        const stdioTransport = new StdioServerTransport();
+        await server.connect(stdioTransport);
+        console.error('Sunderos MCP Server running on stdio');
+    }
+}
+main().catch((err) => {
+    console.error('Fatal error:', err);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "sunderos-mcp",
+  "version": "0.2.0",
+  "description": "MCP server for Sunderos fitness tracking — use with Claude Code, Gemini CLI, or any MCP client",
+  "type": "module",
+  "bin": {
+    "sunderos-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist/index.js",
+    "dist/api-client.js",
+    "dist/*.d.ts"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "build": "tsc",
+    "lint": "eslint src/",
+    "test": "vitest run",
+    "start": "node dist/index.js",
+    "prepublishOnly": "pnpm build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "express": "^4.21.0",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.0",
+    "@types/node": "^22.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  }
+}