@einlogic/mcp-fitbit 1.0.1 → 2.1.0

package/build/utils.js

@@ -1,60 +1,140 @@
 /**
- * Shared utility functions for Fitbit API integration
+ * Shared utility functions for Google Health API integration
  */
 import { z } from 'zod';
-import { HTTP_CONFIG, ERROR_MESSAGES, FITBIT_API_VERSIONS, DATE_REGEX, VALIDATION_MESSAGES, TIME_PERIODS, HEART_RATE_DETAIL_LEVELS } from './config.js';
+import { HTTP_CONFIG, ERROR_MESSAGES, GOOGLE_HEALTH_API_BASE, DATE_REGEX, CIVIL_TIME_REGEX, CIVIL_TIME_FORMAT_ERROR, RFC3339_REGEX, RFC3339_FORMAT_ERROR, VALIDATION_MESSAGES, DATA_SOURCE_FAMILIES, } from './config.js';
 /**
- * Makes a generic request to the Fitbit API.
- * Handles adding the base URL, authorization header, and basic error handling.
- * @param endpoint The specific API endpoint path (e.g., '/body/weight/date/today/30d.json').
+ * Error thrown when the Google Health API returns a non-success status.
+ */
+export class GoogleHealthApiError extends Error {
+    status;
+    body;
+    constructor(status, body, url) {
+        super(`Google Health API Error! Status: ${status}, URL: ${url}, Body: ${body}`);
+        this.name = 'GoogleHealthApiError';
+        this.status = status;
+        this.body = body;
+    }
+}
+function buildQueryString(query) {
+    if (!query)
+        return '';
+    const parts = Object.entries(query)
+        .filter(([, value]) => value !== undefined && value !== '')
+        .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+    return parts.length > 0 ? `?${parts.join('&')}` : '';
+}
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+ * Makes a request to the Google Health API.
+ * @param path Path relative to the API base, e.g. 'users/me/dataTypes/steps/dataPoints'
  * @param getAccessTokenFn A function that returns the current valid access token or null.
- * @param apiBase The base URL for the API (defaults to v1, can be overridden for different API versions)
- * @returns A promise resolving to the parsed JSON response (type T) or null if the request fails.
+ * @param options Method, query parameters and JSON body.
+ * @returns The parsed JSON response, or null when no access token is available.
+ * @throws GoogleHealthApiError for non-success responses (after retrying 429/504),
+ *         or the underlying error for network failures.
  */
-export async function makeFitbitRequest(endpoint, getAccessTokenFn, apiBase = FITBIT_API_VERSIONS.V1) {
+export async function makeGoogleHealthRequest(path, getAccessTokenFn, options = {}) {
     const currentAccessToken = await getAccessTokenFn();
     if (!currentAccessToken) {
         console.error(`Error: ${ERROR_MESSAGES.NO_ACCESS_TOKEN}`);
         return null;
     }
-    // Ensure endpoint starts correctly relative to the user path
-    const cleanEndpoint = endpoint.startsWith('/')
-        ? endpoint.substring(1)
-        : endpoint;
-    // Construct the full URL including the user scope '-'.
-    const url = `${apiBase}/user/-/${cleanEndpoint}`;
-    console.error(`Attempting Fitbit API request to: ${url}`);
+    const { method = 'GET', query, body } = options;
+    const retryBaseDelayMs = options.retryBaseDelayMs ?? HTTP_CONFIG.RETRY_BASE_DELAY_MS;
+    const cleanPath = path.startsWith('/') ? path.substring(1) : path;
+    const url = `${GOOGLE_HEALTH_API_BASE}/${cleanPath}${buildQueryString(query)}`;
+    console.error(`Attempting Google Health API request: ${method} ${url}`);
     const headers = {
         'User-Agent': HTTP_CONFIG.USER_AGENT,
         Authorization: `Bearer ${currentAccessToken}`,
         Accept: 'application/json',
     };
-    try {
-        const response = await fetch(url, { headers });
-        if (!response.ok) {
-            const errorBody = await response.text();
-            console.error(`Fitbit API Error! Status: ${response.status}, URL: ${url}, Body: ${errorBody}`);
-            if (response.status === 401) {
-                console.error(ERROR_MESSAGES.TOKEN_EXPIRED);
+    if (body !== undefined) {
+        headers['Content-Type'] = 'application/json';
+    }
+    for (let attempt = 0;; attempt++) {
+        let response;
+        try {
+            response = await fetch(url, {
+                method,
+                headers,
+                body: body !== undefined ? JSON.stringify(body) : undefined,
+            });
+        }
+        catch (error) {
+            console.error(`Error making Google Health request to ${url}:`, error);
+            throw error;
+        }
+        if (response.ok) {
+            // Handle potential empty response body (e.g., 204 No Content)
+            if (response.status === 204) {
+                return {};
             }
-            return null;
+            return (await response.json());
+        }
+        const errorBody = await response.text();
+        const retryable = HTTP_CONFIG.RETRYABLE_STATUSES.includes(response.status);
+        if (retryable && attempt < HTTP_CONFIG.MAX_RETRIES) {
+            await sleep(retryBaseDelayMs * 2 ** attempt);
+            continue;
         }
-        // Handle potential empty response body for certain success statuses (e.g., 204 No Content)
-        if (response.status === 204) {
-            return {}; // Return an empty object or appropriate type for no content
+        console.error(`Google Health API Error! Status: ${response.status}, URL: ${url}, Body: ${errorBody}`);
+        if (response.status === 401) {
+            console.error(ERROR_MESSAGES.TOKEN_EXPIRED);
         }
-        return (await response.json());
+        throw new GoogleHealthApiError(response.status, errorBody, url);
     }
-    catch (error) {
-        console.error(`Error making Fitbit request to ${url}:`, error);
-        return null;
+}
+// === Filter / path / range helpers ===
+/** Path for the data points collection of a data type (kebab-case). */
+export function dataPointsPath(dataType, suffix = '') {
+    return `users/me/dataTypes/${dataType}/dataPoints${suffix}`;
+}
+/** Filters use snake_case data type names, URLs use kebab-case. */
+export function toFilterName(dataType) {
+    return dataType.replace(/-/g, '_');
+}
+/**
+ * Builds an AIP-160 style range filter on a field.
+ * Start is inclusive; end (optional) is exclusive.
+ */
+export function buildRangeFilter(field, start, end) {
+    const clauses = [`${field} >= "${start}"`];
+    if (end) {
+        clauses.push(`${field} < "${end}"`);
     }
+    return clauses.join(' AND ');
+}
+/** Returns the calendar day after a YYYY-MM-DD date. */
+export function nextDate(date) {
+    const d = new Date(`${date}T00:00:00Z`);
+    d.setUTCDate(d.getUTCDate() + 1);
+    return d.toISOString().substring(0, 10);
+}
+function toCivilDateTime(date) {
+    const [year, month, day] = date.split('-').map(Number);
+    return { date: { year, month, day }, time: {} };
+}
+/** Body for POST dataPoints:dailyRollUp over a closed-open civil date range. */
+export function buildDailyRollUpBody(startDate, endDate, extra = {}) {
+    return {
+        range: {
+            start: toCivilDateTime(startDate),
+            end: toCivilDateTime(endDate),
+        },
+        windowSizeDays: extra.windowSizeDays ?? 1,
+        ...(extra.dataSourceFamily
+            ? { dataSourceFamily: extra.dataSourceFamily }
+            : {}),
+    };
 }
 // === Parameter Validation Schemas ===
 export const CommonSchemas = {
-    period: z
-        .enum(TIME_PERIODS)
-        .describe(VALIDATION_MESSAGES.PERIOD_REQUIRED),
+    date: z
+        .string()
+        .regex(DATE_REGEX, VALIDATION_MESSAGES.DATE_FORMAT)
+        .describe('The date for which to retrieve data (YYYY-MM-DD)'),
     startDate: z
         .string()
         .regex(DATE_REGEX, VALIDATION_MESSAGES.DATE_FORMAT)
@@ -63,23 +143,39 @@ export const CommonSchemas = {
         .string()
         .regex(DATE_REGEX, VALIDATION_MESSAGES.DATE_FORMAT)
         .describe(VALIDATION_MESSAGES.END_DATE_REQUIRED),
-    detailLevel: z
-        .enum(HEART_RATE_DETAIL_LEVELS)
-        .describe(VALIDATION_MESSAGES.DETAIL_LEVEL_REQUIRED),
-    date: z
+    civilStartTime: z
         .string()
-        .regex(DATE_REGEX, VALIDATION_MESSAGES.DATE_FORMAT)
-        .describe('The date for which to retrieve data (YYYY-MM-DD)'),
-    afterDate: z
+        .regex(CIVIL_TIME_REGEX, CIVIL_TIME_FORMAT_ERROR)
+        .describe("Start of the range, inclusive, as civil time ('YYYY-MM-DD' or 'YYYY-MM-DDTHH:MM:SS', user's local time)"),
+    civilEndTime: z
         .string()
-        .regex(DATE_REGEX, VALIDATION_MESSAGES.DATE_FORMAT)
-        .describe('Retrieve activities after this date (YYYY-MM-DD)'),
-    limit: z
+        .regex(CIVIL_TIME_REGEX, CIVIL_TIME_FORMAT_ERROR)
+        .optional()
+        .describe("Optional end of the range, EXCLUSIVE, as civil time ('YYYY-MM-DD' or 'YYYY-MM-DDTHH:MM:SS')"),
+    physicalStartTime: z
+        .string()
+        .regex(RFC3339_REGEX, RFC3339_FORMAT_ERROR)
+        .describe("Start of the range, inclusive, as an RFC 3339 timestamp (e.g. '2026-03-04T00:00:00Z')"),
+    physicalEndTime: z
+        .string()
+        .regex(RFC3339_REGEX, RFC3339_FORMAT_ERROR)
+        .optional()
+        .describe("Optional end of the range, EXCLUSIVE, as an RFC 3339 timestamp (e.g. '2026-03-05T00:00:00Z')"),
+    pageSize: z
         .number()
+        .int()
         .min(1)
-        .max(100)
+        .max(10000)
+        .optional()
+        .describe('Maximum number of data points to return. Most data types allow up to 10000; sleep and exercise are capped at 25'),
+    pageToken: z
+        .string()
+        .optional()
+        .describe(`Page token for pagination. ${VALIDATION_MESSAGES.PAGINATION}`),
+    dataSourceFamily: z
+        .enum(DATA_SOURCE_FAMILIES)
         .optional()
-        .describe('Maximum number of items to return (1-100, default: 20)')
+        .describe('Optional data source family. Defaults to all sources (Google/Fitbit wearables plus third-party)'),
 };
 // === Tool Response Helpers ===
 export function createErrorResponse(message) {
@@ -96,16 +192,30 @@ export function createSuccessResponse(data) {
 }
 export function createNoDataResponse(context) {
     return {
-        content: [{ type: 'text', text: `${ERROR_MESSAGES.NO_DATA_FOUND} ${context}.` }],
+        content: [
+            { type: 'text', text: `${ERROR_MESSAGES.NO_DATA_FOUND} ${context}.` },
+        ],
     };
 }
 export function registerTool(server, config) {
     server.tool(config.name, config.description, config.parametersSchema, config.handler);
 }
-// === Fitbit-Specific Tool Helpers ===
-export async function handleFitbitApiCall(endpoint, params, getAccessTokenFn, options = {}) {
-    const { apiBase = FITBIT_API_VERSIONS.V1, successDataExtractor, noDataMessage, errorContext = JSON.stringify(params) } = options;
-    const responseData = await makeFitbitRequest(endpoint, getAccessTokenFn, apiBase);
+// === Google Health-Specific Tool Helpers ===
+export async function handleGoogleHealthCall(path, getAccessTokenFn, options = {}) {
+    const { successDataExtractor, noDataMessage, errorContext = path, ...requestOptions } = options;
+    let responseData;
+    try {
+        responseData = await makeGoogleHealthRequest(path, getAccessTokenFn, requestOptions);
+    }
+    catch (error) {
+        if (error instanceof GoogleHealthApiError) {
+            if (error.status === 400 && error.body.includes('ACCOUNT_NOT_LINKED')) {
+                return createErrorResponse(ERROR_MESSAGES.ACCOUNT_NOT_LINKED);
+            }
+            return createErrorResponse(`${ERROR_MESSAGES.API_REQUEST_FAILED} for ${errorContext} (HTTP ${error.status}): ${error.body}`);
+        }
+        return createErrorResponse(`${ERROR_MESSAGES.API_REQUEST_FAILED} for ${errorContext}: ${error instanceof Error ? error.message : String(error)}`);
+    }
     if (!responseData) {
         return createErrorResponse(`${ERROR_MESSAGES.API_REQUEST_FAILED} for ${errorContext}. ${ERROR_MESSAGES.CHECK_TOKEN_PERMISSIONS}.`);
     }
@@ -118,3 +228,36 @@ export async function handleFitbitApiCall(endpoint, params, getAccessTokenFn, op
     }
     return createSuccessResponse(responseData);
 }
+/**
+ * Lists data points of a data type with a filter (GET .../dataPoints).
+ */
+export function listDataPoints(dataType, getAccessTokenFn, params, errorContext, suffix = '') {
+    return handleGoogleHealthCall(dataPointsPath(dataType, suffix), getAccessTokenFn, {
+        query: {
+            filter: params.filter,
+            pageSize: params.pageSize,
+            pageToken: params.pageToken,
+        },
+        successDataExtractor: (data) => data.dataPoints,
+        errorContext,
+    });
+}
+/**
+ * Rolls up data points of a data type per civil day (POST .../dataPoints:dailyRollUp).
+ * endDate is exclusive (closed-open range), as in the Google Health API.
+ */
+export function dailyRollUp(dataType, getAccessTokenFn, params, errorContext) {
+    const body = {
+        ...buildDailyRollUpBody(params.startDate, params.endDate, {
+            dataSourceFamily: params.dataSourceFamily,
+        }),
+        ...(params.pageSize ? { pageSize: params.pageSize } : {}),
+        ...(params.pageToken ? { pageToken: params.pageToken } : {}),
+    };
+    return handleGoogleHealthCall(dataPointsPath(dataType, ':dailyRollUp'), getAccessTokenFn, {
+        method: 'POST',
+        body,
+        successDataExtractor: (data) => data.rollupDataPoints,
+        errorContext,
+    });
+}

package/build/weight.js

@@ -1,24 +1,23 @@
-import { registerTool, CommonSchemas, handleFitbitApiCall } from './utils.js';
-// --- Tool Registration ---
+import { registerTool, CommonSchemas, listDataPoints, buildRangeFilter, } from './utils.js';
 /**
- * Registers a single, parameterized Fitbit weight tool with the MCP server.
+ * Registers the weight tool with the MCP server (Google Health `weight` data type).
  * @param server The McpServer instance.
  * @param getAccessTokenFn Function to retrieve the current access token.
  */
 export function registerWeightTool(server, getAccessTokenFn) {
     registerTool(server, {
         name: 'get_weight',
-        description: "Get the raw JSON response for weight entries from Fitbit for a specified period ending today. Requires a 'period' parameter such as '1d', '7d', '30d', '3m', '6m', '1y'",
+        description: 'Get the raw JSON response for weight data points from the Google Health API (data type "weight"), filtered by sample time. Requires a start timestamp (RFC 3339); the end is optional and exclusive. Supports pagination via pageToken.',
         parametersSchema: {
-            period: CommonSchemas.period,
+            startTime: CommonSchemas.physicalStartTime,
+            endTime: CommonSchemas.physicalEndTime,
+            pageSize: CommonSchemas.pageSize,
+            pageToken: CommonSchemas.pageToken,
         },
-        handler: async ({ period }) => {
-            const endpoint = `/body/weight/date/today/${period}.json`;
-            return handleFitbitApiCall(endpoint, { period }, getAccessTokenFn, {
-                successDataExtractor: (data) => data['body-weight'] || [],
-                noDataMessage: `the period '${period}'`,
-                errorContext: `period '${period}'`
-            });
-        }
+        handler: async ({ startTime, endTime, pageSize, pageToken, }) => listDataPoints('weight', getAccessTokenFn, {
+            filter: buildRangeFilter('weight.sample_time.physical_time', startTime, endTime),
+            pageSize,
+            pageToken,
+        }, `weight from '${startTime}'${endTime ? ` to '${endTime}'` : ''}`),
     });
 }

package/package.json

@@ -1,74 +1,74 @@
-{
-  "name": "@einlogic/mcp-fitbit",
-  "version": "1.0.1",
-  "type": "module",
-  "main": "./build/index.js",
-  "bin": {
-    "mcp-fitbit": "./build/index.js",
-    "mkoziel2000-mcp-fitbit": "./build/index.js"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/mkoziel2000/mcp-fitbit.git"
-  },
-  "homepage": "https://github.com/mkoziel2000/mcp-fitbit",
-  "bugs": {
-    "url": "https://github.com/mkoziel2000/mcp-fitbit/issues"
-  },
-  "scripts": {
-    "test": "vitest run",
-    "test:ui": "vitest --ui",
-    "test:coverage": "vitest run --coverage",
-    "build": "tsc",
-    "start": "node build/index.js",
-    "dev": "npm run build && npx @modelcontextprotocol/inspector node build/index.js",
-    "lint": "eslint src/**/*.ts --ignore-pattern src/**/*.test.ts",
-    "lint:fix": "eslint src/**/*.ts --fix",
-    "format": "prettier --write src/**/*.ts",
-    "format:check": "prettier --check src/**/*.ts",
-    "prepublishOnly": "npm run build && npm run test && npm run lint",
-    "prepack": "npm run build"
-  },
-  "keywords": [
-    "mcp",
-    "fitbit",
-    "fitbit-api",
-    "mcp-server",
-    "claude",
-    "model-context-protocol",
-    "health-data",
-    "fitness-tracking",
-    "ai-assistant",
-    "typescript"
-  ],
-  "author": "mkoziel2000",
-  "license": "MIT",
-  "description": "Fork of TheDigitalNinja's mcp-fitbit with the addition of the Heart Rate Variability (HRV) tool. MCP server for accessing Fitbit health and fitness data. Connect AI assistants like Claude to your Fitbit data for personalized health insights.",
-  "files": [
-    "build/",
-    "README.md",
-    "LICENSE"
-  ],
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.11.0",
-    "@types/express": "^5.0.1",
-    "dotenv": "^16.5.0",
-    "express": "^5.1.0",
-    "open": "^10.1.2",
-    "simple-oauth2": "^5.1.0",
-    "zod": "^3.24.3"
-  },
-  "devDependencies": {
-    "@eslint/js": "^9.27.0",
-    "@types/node": "^22.15.3",
-    "@types/simple-oauth2": "^5.0.7",
-    "@typescript-eslint/eslint-plugin": "^8.32.1",
-    "@typescript-eslint/parser": "^8.32.1",
-    "@vitest/coverage-v8": "^3.1.4",
-    "@vitest/ui": "^3.1.4",
-    "eslint": "^9.27.0",
-    "prettier": "^3.5.3",
-    "typescript": "^5.8.3",
-    "vitest": "^3.1.4"
-  }
-}
+{
+  "name": "@einlogic/mcp-fitbit",
+  "version": "2.1.0",
+  "type": "module",
+  "main": "./build/index.js",
+  "bin": {
+    "mcp-fitbit": "./build/index.js",
+    "mkoziel2000-mcp-fitbit": "./build/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mkoziel2000/mcp-fitbit.git"
+  },
+  "homepage": "https://github.com/mkoziel2000/mcp-fitbit",
+  "bugs": {
+    "url": "https://github.com/mkoziel2000/mcp-fitbit/issues"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest run --coverage",
+    "build": "tsc",
+    "start": "node build/index.js",
+    "dev": "npm run build && npx @modelcontextprotocol/inspector node build/index.js",
+    "lint": "eslint src/**/*.ts --ignore-pattern src/**/*.test.ts",
+    "lint:fix": "eslint src/**/*.ts --fix",
+    "format": "prettier --write src/**/*.ts",
+    "format:check": "prettier --check src/**/*.ts",
+    "prepublishOnly": "npm run build && npm run test && npm run lint",
+    "prepack": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "fitbit",
+    "google-health-api",
+    "mcp-server",
+    "claude",
+    "model-context-protocol",
+    "health-data",
+    "fitness-tracking",
+    "ai-assistant",
+    "typescript"
+  ],
+  "author": "mkoziel2000",
+  "license": "MIT",
+  "description": "MCP server for accessing Fitbit / Pixel Watch health and fitness data through the Google Health API. Connect AI assistants like Claude to your data for personalized health insights.",
+  "files": [
+    "build/",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.11.0",
+    "@types/express": "^5.0.1",
+    "dotenv": "^16.5.0",
+    "express": "^5.1.0",
+    "open": "^10.1.2",
+    "simple-oauth2": "^5.1.0",
+    "zod": "^3.24.3"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.27.0",
+    "@types/node": "^22.15.3",
+    "@types/simple-oauth2": "^5.0.7",
+    "@typescript-eslint/eslint-plugin": "^8.32.1",
+    "@typescript-eslint/parser": "^8.32.1",
+    "@vitest/coverage-v8": "^3.1.4",
+    "@vitest/ui": "^3.1.4",
+    "eslint": "^9.27.0",
+    "prettier": "^3.5.3",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.4"
+  }
+}