@einlogic/mcp-fitbit 1.0.1 → 2.1.0

package/build/compat/tools.js

@@ -0,0 +1,432 @@
+/**
+ * Fitbit-compatible tool set.
+ *
+ * Enabled with GOOGLE_HEALTH_OUTPUT_MODE=fitbit. These tools keep the legacy Fitbit tool
+ * names, parameters (period / inclusive end dates) and response shapes/units, but are
+ * served from the Google Health API. They deliberately deviate from the 1:1 proxy
+ * philosophy of the default mode so that consumers written against the Fitbit Web API
+ * (such as the "Heather's Coach" Claude project) need no changes.
+ *
+ * Differences that cannot be hidden are reported in a top-level `_compat.notes` array.
+ */
+import { z } from 'zod';
+import { registerTool, CommonSchemas, buildRangeFilter, createSuccessResponse, createErrorResponse, createNoDataResponse, } from '../utils.js';
+import { DATE_REGEX, VALIDATION_MESSAGES } from '../config.js';
+import { guard, listAll, rollUpAll, getUserContext, getZonesForRange, } from './api.js';
+import { addDays, convertDistance, convertWater, eachDate, inclusiveDays, mapHrv, mapSleep, mapWeight, num, nutritionSummary, periodStartDate, restingHeartRateByDate, rollupDate, round, todayInZone, zonedMidnightIso, activityLevelMinutes, } from './convert.js';
+// === Shared helpers ===
+const dateSchema = z
+    .string()
+    .regex(DATE_REGEX, VALIDATION_MESSAGES.DATE_FORMAT);
+const startDateSchema = dateSchema.describe('The start date of the range, inclusive (YYYY-MM-DD)');
+const endDateSchema = dateSchema.describe('The end date of the range, INCLUSIVE (YYYY-MM-DD), as in the Fitbit API');
+const optionalDateSchema = dateSchema
+    .optional()
+    .describe('Optional end date of the period (YYYY-MM-DD). Defaults to today');
+function withNotes(body, notes) {
+    return notes.length > 0 ? { ...body, _compat: { notes } } : body;
+}
+function checkRange(start, end, maxDays) {
+    if (end < start)
+        return `endDate ${end} is before startDate ${start}.`;
+    if (inclusiveDays(start, end) > maxDays) {
+        return `The date range is limited to ${maxDays} days.`;
+    }
+    return null;
+}
+const rangeParams = { startDate: startDateSchema, endDate: endDateSchema };
+// === Tools ===
+/**
+ * Registers the Fitbit-compatible tools. Names, parameters and response shapes follow the
+ * legacy Fitbit tools of this server.
+ */
+export function registerCompatTools(server, getToken) {
+    registerWeight(server, getToken);
+    registerSleep(server, getToken);
+    registerDailySummary(server, getToken);
+    registerHeartRate(server, getToken);
+    registerHrv(server, getToken);
+    registerActivityTimeSeries(server, getToken);
+    registerAzm(server, getToken);
+    registerNutrition(server, getToken);
+}
+// --- Weight ---
+function registerWeight(server, t) {
+    registerTool(server, {
+        name: 'get_weight',
+        description: "Fitbit-compatible weight log for a period ending today (or on 'date'). Returns { weight: [{ date, time, logId, source, weight }] } with weight in the account's unit (pounds by default), as the Fitbit API did. period is one of 1d, 7d, 30d, 3m, 6m, 1y.",
+        parametersSchema: {
+            period: z.enum(['1d', '7d', '30d', '3m', '6m', '1y']).describe('Period ending on date (default today)'),
+            date: optionalDateSchema,
+        },
+        handler: async ({ period, date }) => guard(`weight for period '${period}'`, async () => {
+            const ctx = await getUserContext(t);
+            const end = date ?? todayInZone(ctx.timeZone);
+            const start = periodStartDate(end, period);
+            const points = await listAll('weight', t, {
+                filter: buildRangeFilter('weight.sample_time.physical_time', zonedMidnightIso(start, ctx.timeZone), zonedMidnightIso(addDays(end, 1), ctx.timeZone)),
+                pageSize: 10000,
+            });
+            const body = mapWeight(points, ctx.weightUnit);
+            if (body.weight.length === 0) {
+                return createNoDataResponse(`weight for ${start} to ${end}`);
+            }
+            return createSuccessResponse(withNotes(body, ['bmi and body fat are not included.']));
+        }),
+    });
+}
+// --- Sleep ---
+function registerSleep(server, t) {
+    registerTool(server, {
+        name: 'get_sleep_by_date_range',
+        description: "Fitbit-compatible sleep logs by date of sleep (the wake date), start and end INCLUSIVE, max 100 days. Returns { sleep: [{ dateOfSleep, startTime, endTime, duration(ms), minutesAsleep, minutesAwake, timeInBed, isMainSleep, type, levels: { summary: { deep, light, rem, wake: { count, minutes } }, data } }] }. There is no sleep score or efficiency.",
+        parametersSchema: rangeParams,
+        handler: async ({ startDate, endDate }) => guard(`sleep from ${startDate} to ${endDate}`, async () => {
+            const problem = checkRange(startDate, endDate, 100);
+            if (problem)
+                return createErrorResponse(problem);
+            const points = await listAll('sleep', t, {
+                filter: buildRangeFilter('sleep.interval.civil_end_time', startDate, addDays(endDate, 1)),
+                pageSize: 25,
+                maxPages: 20,
+            });
+            const body = mapSleep(points);
+            if (body.sleep.length === 0) {
+                return createNoDataResponse(`sleep from ${startDate} to ${endDate}`);
+            }
+            return createSuccessResponse(body);
+        }),
+    });
+}
+// --- Daily summary ---
+function registerDailySummary(server, t) {
+    registerTool(server, {
+        name: 'get_daily_activity_summary',
+        description: "Fitbit-compatible daily activity summary for one date: { activities: [], goals: {}, summary: { caloriesOut, steps, distances, floors, sedentary/lightlyActive/fairlyActive/veryActiveMinutes, restingHeartRate, heartRateZones } }. Distance uses the account's unit (miles by default). heartRateZones are Fitbit's Out of Range / Fat Burn / Cardio / Peak zones with minutes and calories (Google's Light / Moderate / Vigorous / Peak). Exercise sessions and goals are not included.",
+        parametersSchema: { date: CommonSchemas.date },
+        handler: async ({ date }) => guard(`daily summary for ${date}`, async () => {
+            const next = addDays(date, 1);
+            const ctx = await getUserContext(t);
+            const notes = [];
+            const [steps, distance, calories] = await Promise.all([
+                rollUpAll('steps', t, date, next),
+                rollUpAll('distance', t, date, next),
+                rollUpAll('total-calories', t, date, next),
+            ]);
+            if (!steps.length && !distance.length && !calories.length) {
+                return createNoDataResponse(`daily activity for ${date}`);
+            }
+            const [floors, level, resting, zoneResult] = await Promise.all([
+                rollUpAll('floors', t, date, next).catch(() => []),
+                // activity-level has no dailyRollUp (list/reconcile only): sum the minute points
+                listAll('activity-level', t, {
+                    filter: buildRangeFilter('activity_level.interval.civil_start_time', `${date}T00:00:00`, `${next}T00:00:00`),
+                    pageSize: 10000,
+                }).catch((error) => {
+                    notes.push(`activity minutes unavailable: ${error instanceof Error ? error.message : String(error)}`);
+                    return [];
+                }),
+                listAll('daily-resting-heart-rate', t, {
+                    filter: buildRangeFilter('daily_resting_heart_rate.date', date, next),
+                }).catch(() => []),
+                getZonesForRange(t, date, next).catch((error) => {
+                    notes.push(`heartRateZones unavailable: ${error instanceof Error ? error.message : String(error)}`);
+                    return null;
+                }),
+            ]);
+            const zones = zoneResult?.zones.get(date);
+            notes.push(...(zoneResult?.notes ?? []));
+            const summary = {
+                caloriesOut: Math.round(calories[0]?.totalCalories?.kcalSum ?? 0),
+                steps: num(steps[0]?.steps?.countSum),
+                distances: [
+                    {
+                        activity: 'total',
+                        distance: convertDistance(num(distance[0]?.distance?.millimetersSum), ctx.distanceUnit),
+                    },
+                ],
+                floors: num(floors[0]?.floors?.countSum),
+                ...(activityLevelMinutes(level) ?? {}),
+            };
+            const restingHr = restingHeartRateByDate(resting).get(date);
+            if (restingHr !== undefined)
+                summary.restingHeartRate = restingHr;
+            if (zones)
+                summary.heartRateZones = zones;
+            return createSuccessResponse(withNotes({ activities: [], goals: {}, summary }, notes));
+        }),
+    });
+}
+// --- Heart rate ---
+async function buildHeartDays(t, start, end) {
+    const notes = [];
+    const next = addDays(end, 1);
+    const [restingPoints, zoneResult] = await Promise.all([
+        listAll('daily-resting-heart-rate', t, {
+            filter: buildRangeFilter('daily_resting_heart_rate.date', start, next),
+            pageSize: 10000,
+        }),
+        getZonesForRange(t, start, next).catch((error) => {
+            notes.push(`heartRateZones unavailable: ${error instanceof Error ? error.message : String(error)}`);
+            return null;
+        }),
+    ]);
+    const resting = restingHeartRateByDate(restingPoints);
+    const zoneByDate = zoneResult?.zones ?? new Map();
+    notes.push(...(zoneResult?.notes ?? []));
+    const days = eachDate(start, end)
+        .filter((d) => resting.has(d) || zoneByDate.has(d))
+        .map((d) => ({
+        dateTime: d,
+        value: {
+            customHeartRateZones: [],
+            ...(zoneByDate.has(d) ? { heartRateZones: zoneByDate.get(d) } : {}),
+            ...(resting.has(d) ? { restingHeartRate: resting.get(d) } : {}),
+        },
+    }));
+    if (days.length === 0) {
+        return createNoDataResponse(`heart rate from ${start} to ${end}`);
+    }
+    return createSuccessResponse(withNotes({ 'activities-heart': days }, notes));
+}
+function registerHeartRate(server, t) {
+    registerTool(server, {
+        name: 'get_heart_rate',
+        description: "Fitbit-compatible daily heart rate for a period ending today (or on 'date'): { 'activities-heart': [{ dateTime, value: { restingHeartRate, heartRateZones: [{ name, min, max, minutes, caloriesOut }] } }] }. Zones are Fitbit's Out of Range / Fat Burn / Cardio / Peak (Google's Light / Moderate / Vigorous / Peak) with the account's own bpm bounds. period is one of 1d, 7d, 30d, 1w, 1m.",
+        parametersSchema: {
+            period: z.enum(['1d', '7d', '30d', '1w', '1m']).describe('Period ending on date (default today)'),
+            date: optionalDateSchema,
+        },
+        handler: async ({ period, date }) => guard(`heart rate for period '${period}'`, async () => {
+            const ctx = await getUserContext(t);
+            const end = date ?? todayInZone(ctx.timeZone);
+            return buildHeartDays(t, periodStartDate(end, period), end);
+        }),
+    });
+    registerTool(server, {
+        name: 'get_heart_rate_by_date_range',
+        description: 'Fitbit-compatible daily heart rate for a date range, start and end INCLUSIVE, max 365 days. Same shape as get_heart_rate.',
+        parametersSchema: rangeParams,
+        handler: async ({ startDate, endDate }) => guard(`heart rate from ${startDate} to ${endDate}`, async () => {
+            const problem = checkRange(startDate, endDate, 365);
+            if (problem)
+                return createErrorResponse(problem);
+            return buildHeartDays(t, startDate, endDate);
+        }),
+    });
+}
+// --- HRV ---
+function registerHrv(server, t) {
+    const fetchHrv = async (start, end) => {
+        const points = await listAll('daily-heart-rate-variability', t, {
+            filter: buildRangeFilter('daily_heart_rate_variability.date', start, addDays(end, 1)),
+            pageSize: 10000,
+        });
+        const body = mapHrv(points);
+        if (body.hrv.length === 0)
+            return createNoDataResponse(`HRV from ${start} to ${end}`);
+        return createSuccessResponse(body);
+    };
+    registerTool(server, {
+        name: 'get_hrv',
+        description: 'Fitbit-compatible daily HRV for one date: { hrv: [{ dateTime, value: { dailyRmssd, deepRmssd } }] } in milliseconds.',
+        parametersSchema: { date: CommonSchemas.date },
+        handler: async ({ date }) => guard(`HRV for ${date}`, () => fetchHrv(date, date)),
+    });
+    registerTool(server, {
+        name: 'get_hrv_by_date_range',
+        description: 'Fitbit-compatible daily HRV for a date range, start and end INCLUSIVE, max 30 days. Same shape as get_hrv.',
+        parametersSchema: rangeParams,
+        handler: async ({ startDate, endDate }) => guard(`HRV from ${startDate} to ${endDate}`, async () => {
+            const problem = checkRange(startDate, endDate, 30);
+            if (problem)
+                return createErrorResponse(problem);
+            return fetchHrv(startDate, endDate);
+        }),
+    });
+}
+// --- Activity time series ---
+const ACTIVITY_RESOURCES = [
+    'steps',
+    'distance',
+    'calories',
+    'activityCalories',
+    'caloriesBMR',
+    'tracker/activityCalories',
+    'tracker/calories',
+    'tracker/distance',
+];
+function registerActivityTimeSeries(server, t) {
+    registerTool(server, {
+        name: 'get_activity_timeseries',
+        description: "Fitbit-compatible daily activity time series over a date range (start and end INCLUSIVE, max 30 days): { 'activities-<resource>': [{ dateTime, value: '<string>' }] }. Supports steps, distance (account unit, miles by default), calories (total kcal), activityCalories (active kcal) and the tracker/ variants. caloriesBMR is not available.",
+        parametersSchema: {
+            resourcePath: z.enum(ACTIVITY_RESOURCES).describe("Activity resource to retrieve (e.g. 'steps', 'distance', 'calories')"),
+            ...rangeParams,
+        },
+        handler: async ({ resourcePath, startDate, endDate, }) => guard(`${resourcePath} from ${startDate} to ${endDate}`, async () => {
+            const problem = checkRange(startDate, endDate, 30);
+            if (problem)
+                return createErrorResponse(problem);
+            const resource = resourcePath.replace('tracker/', '');
+            if (resource === 'caloriesBMR') {
+                return createErrorResponse('caloriesBMR is not available from the Google Health API.');
+            }
+            const ctx = await getUserContext(t);
+            const dataType = resource === 'steps'
+                ? 'steps'
+                : resource === 'distance'
+                    ? 'distance'
+                    : resource === 'calories'
+                        ? 'total-calories'
+                        : 'active-energy-burned';
+            const extract = (p) => {
+                switch (dataType) {
+                    case 'steps':
+                        return p.steps ? num(p.steps.countSum) : undefined;
+                    case 'distance':
+                        return p.distance
+                            ? convertDistance(num(p.distance.millimetersSum), ctx.distanceUnit)
+                            : undefined;
+                    case 'total-calories':
+                        return p.totalCalories ? Math.round(p.totalCalories.kcalSum ?? 0) : undefined;
+                    default:
+                        return p.activeEnergyBurned ? Math.round(p.activeEnergyBurned.kcalSum ?? 0) : undefined;
+                }
+            };
+            const points = await rollUpAll(dataType, t, startDate, addDays(endDate, 1));
+            const byDate = new Map();
+            for (const p of points) {
+                const d = rollupDate(p);
+                const v = extract(p);
+                if (d && v !== undefined)
+                    byDate.set(d, v);
+            }
+            if (byDate.size === 0) {
+                return createNoDataResponse(`${resourcePath} from ${startDate} to ${endDate}`);
+            }
+            const series = eachDate(startDate, endDate).map((d) => ({
+                dateTime: d,
+                value: String(byDate.get(d) ?? 0),
+            }));
+            return createSuccessResponse({
+                [`activities-${resourcePath.replace('/', '-')}`]: series,
+            });
+        }),
+    });
+}
+// --- Active Zone Minutes ---
+function registerAzm(server, t) {
+    registerTool(server, {
+        name: 'get_azm_timeseries',
+        description: "Fitbit-compatible Active Zone Minutes by day (start and end INCLUSIVE, max 1095 days): { 'activities-active-zone-minutes': [{ dateTime, value: { activeZoneMinutes, fatBurnActiveZoneMinutes, cardioActiveZoneMinutes, peakActiveZoneMinutes } }] }. Only days with data are returned.",
+        parametersSchema: rangeParams,
+        handler: async ({ startDate, endDate }) => guard(`active zone minutes from ${startDate} to ${endDate}`, async () => {
+            const problem = checkRange(startDate, endDate, 1095);
+            if (problem)
+                return createErrorResponse(problem);
+            const points = await rollUpAll('active-zone-minutes', t, startDate, addDays(endDate, 1), 60);
+            const series = points
+                .map((p) => {
+                const date = rollupDate(p);
+                const azm = p.activeZoneMinutes;
+                if (!date || !azm)
+                    return null;
+                const fat = num(azm.sumInFatBurnHeartZone);
+                const cardio = num(azm.sumInCardioHeartZone);
+                const peak = num(azm.sumInPeakHeartZone);
+                return {
+                    dateTime: date,
+                    value: {
+                        activeZoneMinutes: fat + cardio + peak,
+                        fatBurnActiveZoneMinutes: fat,
+                        cardioActiveZoneMinutes: cardio,
+                        peakActiveZoneMinutes: peak,
+                    },
+                };
+            })
+                .filter((r) => r !== null)
+                .sort((a, b) => a.dateTime.localeCompare(b.dateTime));
+            if (series.length === 0) {
+                return createNoDataResponse(`active zone minutes from ${startDate} to ${endDate}`);
+            }
+            return createSuccessResponse({ 'activities-active-zone-minutes': series });
+        }),
+    });
+}
+// --- Nutrition ---
+const NUTRITION_RESOURCES = ['caloriesIn', 'water'];
+function registerNutrition(server, t) {
+    registerTool(server, {
+        name: 'get_food_log',
+        description: "Fitbit-compatible food log summary for one date: { foods: [], goals: {}, summary: { calories, carbs, fat, fiber, protein, sodium, water } } (kcal; g; sodium in mg; water in the account's unit). Individual food entries and goals are not included.",
+        parametersSchema: { date: CommonSchemas.date },
+        handler: async ({ date }) => guard(`food log for ${date}`, async () => {
+            const next = addDays(date, 1);
+            const ctx = await getUserContext(t);
+            const [nutrition, hydration] = await Promise.all([
+                rollUpAll('nutrition-log', t, date, next),
+                rollUpAll('hydration-log', t, date, next).catch(() => []),
+            ]);
+            const summary = nutritionSummary(nutrition[0]);
+            if (!summary)
+                return createNoDataResponse(`food log for ${date}`);
+            const water = convertWater(hydration[0]?.hydrationLog?.amountConsumed?.millilitersSum ?? 0, ctx.waterUnit);
+            return createSuccessResponse(withNotes({ foods: [], goals: {}, summary: { ...summary, water } }, [
+                'Individual foods and goals are not included.',
+            ]));
+        }),
+    });
+    const fetchSeries = async (resource, start, end) => {
+        const problem = checkRange(start, end, 1095);
+        if (problem)
+            return createErrorResponse(problem);
+        const ctx = await getUserContext(t);
+        const dataType = resource === 'caloriesIn' ? 'nutrition-log' : 'hydration-log';
+        const points = await rollUpAll(dataType, t, start, addDays(end, 1), 60);
+        const byDate = new Map();
+        for (const p of points) {
+            const d = rollupDate(p);
+            if (!d)
+                continue;
+            if (resource === 'caloriesIn' && p.nutritionLog) {
+                byDate.set(d, Math.round(p.nutritionLog.energy?.kcalSum ?? 0));
+            }
+            else if (resource === 'water' && p.hydrationLog) {
+                byDate.set(d, convertWater(p.hydrationLog.amountConsumed?.millilitersSum ?? 0, ctx.waterUnit));
+            }
+        }
+        if (byDate.size === 0) {
+            return createNoDataResponse(`${resource} from ${start} to ${end}`);
+        }
+        return createSuccessResponse({
+            [`foods-log-${resource}`]: eachDate(start, end).map((d) => ({
+                dateTime: d,
+                value: String(round(byDate.get(d) ?? 0, 1)),
+            })),
+        });
+    };
+    registerTool(server, {
+        name: 'get_nutrition',
+        description: "Fitbit-compatible nutrition time series for a period ending today (or on 'date'): { 'foods-log-<resource>': [{ dateTime, value: '<string>' }] }. resource is caloriesIn (kcal) or water (account unit). period is one of 1d, 7d, 30d, 1w, 1m, 3m, 6m, 1y.",
+        parametersSchema: {
+            resource: z.enum(NUTRITION_RESOURCES).describe('The nutrition resource to retrieve'),
+            period: z.enum(['1d', '7d', '30d', '1w', '1m', '3m', '6m', '1y']).describe('Period ending on date (default today)'),
+            date: optionalDateSchema,
+        },
+        handler: async ({ resource, period, date, }) => guard(`${resource} for period '${period}'`, async () => {
+            const ctx = await getUserContext(t);
+            const end = date ?? todayInZone(ctx.timeZone);
+            return fetchSeries(resource, periodStartDate(end, period), end);
+        }),
+    });
+    registerTool(server, {
+        name: 'get_nutrition_by_date_range',
+        description: "Fitbit-compatible nutrition time series for a date range (start and end INCLUSIVE, max 1095 days). resource is caloriesIn (kcal) or water (account unit). Same shape as get_nutrition.",
+        parametersSchema: {
+            resource: z.enum(NUTRITION_RESOURCES).describe('The nutrition resource to retrieve'),
+            ...rangeParams,
+        },
+        handler: async ({ resource, startDate, endDate, }) => guard(`${resource} from ${startDate} to ${endDate}`, () => fetchSeries(resource, startDate, endDate)),
+    });
+}

package/build/config.js

@@ -1,56 +1,126 @@
 /**
- * Centralized configuration for the MCP Fitbit server
+ * Centralized configuration for the Google Health MCP server
  * Contains all constants, API URLs, and shared configurations
  */
 // === API Configuration ===
-export const FITBIT_API_VERSIONS = {
-    V1: 'https://api.fitbit.com/1',
-    V1_2: 'https://api.fitbit.com/1.2',
-};
-export const FITBIT_OAUTH_CONFIG = {
-    AUTHORIZE_URL: 'https://www.fitbit.com/oauth2/authorize',
-    TOKEN_URL: 'https://api.fitbit.com/oauth2/token',
+export const GOOGLE_HEALTH_API_BASE = 'https://health.googleapis.com/v4';
+const SCOPE_PREFIX = 'https://www.googleapis.com/auth/googlehealth';
+export const GOOGLE_OAUTH_CONFIG = {
+    TOKEN_HOST: 'https://oauth2.googleapis.com',
+    TOKEN_PATH: '/token',
+    AUTHORIZE_HOST: 'https://accounts.google.com',
+    AUTHORIZE_PATH: '/o/oauth2/v2/auth',
     CALLBACK_URI: 'http://localhost:3000/callback',
     SCOPES: [
-        'weight',
-        'sleep',
-        'profile',
-        'activity',
-        'heartrate',
-        'nutrition'
-    ].join(' ')
+        `${SCOPE_PREFIX}.activity_and_fitness.readonly`,
+        `${SCOPE_PREFIX}.health_metrics_and_measurements.readonly`,
+        `${SCOPE_PREFIX}.sleep.readonly`,
+        `${SCOPE_PREFIX}.nutrition.readonly`,
+        `${SCOPE_PREFIX}.profile.readonly`,
+        `${SCOPE_PREFIX}.settings.readonly`,
+    ].join(' '),
 };
-// === Tool Configuration ===
-// === Common Parameter Types ===
-export const TIME_PERIODS = ['1d', '7d', '30d', '3m', '6m', '1y'];
+/**
+ * Resolves OAuth client credentials from the environment.
+ * GOOGLE_HEALTH_* is preferred; the legacy FITBIT_* names are accepted as a fallback.
+ */
+export function resolveClientCredentials() {
+    return {
+        id: process.env.GOOGLE_HEALTH_CLIENT_ID || process.env.FITBIT_CLIENT_ID || '',
+        secret: process.env.GOOGLE_HEALTH_CLIENT_SECRET ||
+            process.env.FITBIT_CLIENT_SECRET ||
+            '',
+    };
+}
+export function resolveOutputMode() {
+    const value = (process.env.GOOGLE_HEALTH_OUTPUT_MODE || 'google').toLowerCase();
+    return value === 'fitbit' ? 'fitbit' : 'google';
+}
+// === Data Types ===
+// All data types exposed by the Google Health API (kebab-case, as used in URL paths)
+export const DATA_TYPES = [
+    'active-energy-burned',
+    'active-minutes',
+    'active-zone-minutes',
+    'activity-level',
+    'altitude',
+    'blood-glucose',
+    'body-fat',
+    'calories-in-heart-rate-zone',
+    'core-body-temperature',
+    'daily-heart-rate-variability',
+    'daily-heart-rate-zones',
+    'daily-oxygen-saturation',
+    'daily-respiratory-rate',
+    'daily-resting-heart-rate',
+    'daily-sleep-temperature-derivations',
+    'daily-vo2-max',
+    'distance',
+    'electrocardiogram',
+    'exercise',
+    'floors',
+    'food',
+    'food-measurement-unit',
+    'heart-rate',
+    'heart-rate-variability',
+    'height',
+    'hydration-log',
+    'irregular-rhythm-notification',
+    'nutrition-log',
+    'oxygen-saturation',
+    'respiratory-rate-sleep-summary',
+    'run-vo2-max',
+    'sedentary-period',
+    'sleep',
+    'steps',
+    'swim-lengths-data',
+    'time-in-heart-rate-zone',
+    'total-calories',
+    'vo2-max',
+    'weight',
+];
+export const DATA_SOURCE_FAMILIES = [
+    'users/me/dataSourceFamilies/all-sources',
+    'users/me/dataSourceFamilies/google-wearables',
+    'users/me/dataSourceFamilies/google-sources',
+];
+// === Common Validation ===
+// YYYY-MM-DD
 export const DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/;
 export const DATE_FORMAT_ERROR = 'Date must be in YYYY-MM-DD format';
-export const HEART_RATE_DETAIL_LEVELS = ['1sec', '1min', '15min'];
-// === Common Validation Messages ===
+// Civil time: YYYY-MM-DD or YYYY-MM-DDTHH:MM:SS (no UTC offset)
+export const CIVIL_TIME_REGEX = /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2})?$/;
+export const CIVIL_TIME_FORMAT_ERROR = "Must be a civil time: 'YYYY-MM-DD' or 'YYYY-MM-DDTHH:MM:SS' (no UTC offset)";
+// RFC 3339 timestamp with offset, e.g. 2026-03-04T00:00:00Z
+export const RFC3339_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$/;
+export const RFC3339_FORMAT_ERROR = "Must be an RFC 3339 timestamp, e.g. '2026-03-04T00:00:00Z'";
 export const VALIDATION_MESSAGES = {
     DATE_FORMAT: DATE_FORMAT_ERROR,
-    PERIOD_REQUIRED: 'The time period for which to retrieve data',
-    START_DATE_REQUIRED: 'The start date for which to retrieve data (YYYY-MM-DD)',
-    END_DATE_REQUIRED: 'The end date for which to retrieve data (YYYY-MM-DD)',
-    DETAIL_LEVEL_REQUIRED: 'The granularity level of the data',
-    MAX_RANGE_100_DAYS: 'Note: The API enforces a maximum range of 100 days',
-    MAX_RANGE_31_DAYS: 'Note: The API enforces a maximum range of 31 days'
+    START_DATE_REQUIRED: 'The first date of the range, inclusive (YYYY-MM-DD)',
+    END_DATE_REQUIRED: 'The end of the range, EXCLUSIVE (YYYY-MM-DD). To include a day, pass the following day',
+    MAX_RANGE_90_DAYS: 'Note: The API allows at most 90 days per request',
+    MAX_RANGE_14_DAYS: 'Note: The API allows at most 14 days per request for this data type',
+    PAGINATION: 'Use nextPageToken from the response as pageToken to fetch the next page',
 };
 // === HTTP Configuration ===
 export const HTTP_CONFIG = {
-    USER_AGENT: 'mcp-fitbit-server/1.0',
+    USER_AGENT: 'mcp-google-health-server/2.0',
     TIMEOUT_MS: 30000,
-    MAX_RETRIES: 3
+    MAX_RETRIES: 3,
+    RETRY_BASE_DELAY_MS: 500,
+    // Status codes the Google Health docs recommend retrying with exponential backoff
+    RETRYABLE_STATUSES: [429, 504],
 };
 // === File Paths ===
 export const FILE_PATHS = {
-    TOKEN_STORAGE: '.fitbit-token.json'
+    TOKEN_STORAGE: '.google-health-token.json',
 };
 // === Error Messages ===
 export const ERROR_MESSAGES = {
-    NO_ACCESS_TOKEN: 'No Fitbit Access Token available. Please authorize first.',
-    API_REQUEST_FAILED: 'Failed to retrieve data from Fitbit API',
+    NO_ACCESS_TOKEN: 'No Google Health access token available. Please authorize first.',
+    API_REQUEST_FAILED: 'Failed to retrieve data from Google Health API',
     TOKEN_EXPIRED: 'Access token might be expired or invalid. Re-authorization may be needed.',
     NO_DATA_FOUND: 'No data found for the specified period/range',
-    CHECK_TOKEN_PERMISSIONS: 'Check token and permissions'
+    CHECK_TOKEN_PERMISSIONS: 'Check token and permissions',
+    ACCOUNT_NOT_LINKED: 'This Google Account is not linked to Google Health. Open the Google Health mobile app, choose "Sign in with Google" with this account, then authorize again.',
 };

package/build/daily-activity.js

@@ -1,4 +1,14 @@
-import { registerTool, CommonSchemas, handleFitbitApiCall } from './utils.js';
+import { registerTool, CommonSchemas, createErrorResponse, createSuccessResponse, makeGoogleHealthRequest, dataPointsPath, buildDailyRollUpBody, nextDate, GoogleHealthApiError, } from './utils.js';
+import { ERROR_MESSAGES } from './config.js';
+// The Google Health API has no single "daily summary" endpoint, so the summary
+// is the daily roll-up of each of these data types for the requested date.
+export const DAILY_SUMMARY_DATA_TYPES = [
+    'steps',
+    'distance',
+    'total-calories',
+    'active-zone-minutes',
+    'floors',
+];
 /**
  * Registers a daily activity summary tool with the MCP server.
  * @param server The McpServer instance.
@@ -7,15 +17,33 @@ import { registerTool, CommonSchemas, handleFitbitApiCall } from './utils.js';
 export function registerDailyActivityTool(server, getAccessTokenFn) {
     registerTool(server, {
         name: 'get_daily_activity_summary',
-        description: "Get the raw JSON response for daily activity summary from Fitbit for a specific date. Includes goals, steps, calories, distances, and heart rate zones. Requires a 'date' parameter in YYYY-MM-DD format.",
+        description: `Get the raw JSON daily roll-ups from the Google Health API for a single date, one dailyRollUp call per data type (${DAILY_SUMMARY_DATA_TYPES.join(', ')}), returned together keyed by data type. A data type that fails is reported under its key as an error.`,
         parametersSchema: {
             date: CommonSchemas.date,
         },
         handler: async ({ date }) => {
-            const endpoint = `activities/date/${date}.json`;
-            return handleFitbitApiCall(endpoint, { date }, getAccessTokenFn, {
-                errorContext: `date '${date}'`
-            });
-        }
+            const body = buildDailyRollUpBody(date, nextDate(date));
+            const entries = await Promise.all(DAILY_SUMMARY_DATA_TYPES.map(async (dataType) => {
+                try {
+                    const result = await makeGoogleHealthRequest(dataPointsPath(dataType, ':dailyRollUp'), getAccessTokenFn, { method: 'POST', body });
+                    return [
+                        dataType,
+                        result ?? { error: ERROR_MESSAGES.NO_ACCESS_TOKEN },
+                    ];
+                }
+                catch (error) {
+                    const message = error instanceof GoogleHealthApiError
+                        ? `HTTP ${error.status}: ${error.body}`
+                        : String(error);
+                    return [dataType, { error: message }];
+                }
+            }));
+            const summary = Object.fromEntries(entries);
+            const allFailed = entries.every(([, value]) => 'error' in value);
+            if (allFailed) {
+                return createErrorResponse(`${ERROR_MESSAGES.API_REQUEST_FAILED} for date '${date}': ${JSON.stringify(summary)}`);
+            }
+            return createSuccessResponse(summary);
+        },
     });
 }