@einlogic/mcp-fitbit 1.0.1

package/LICENSE

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

package/README.md

@@ -0,0 +1,209 @@
+# Fitbit MCP Connector for AI
+
+[![Fitbit API](https://img.shields.io/badge/Fitbit-00B0B9?logo=fitbit&logoColor=white)](https://dev.fitbit.com/)
+[![CI](https://github.com/TheDigitalNinja/mcp-fitbit/actions/workflows/ci.yml/badge.svg)](https://github.com/TheDigitalNinja/mcp-fitbit/actions/workflows/ci.yml)
+[![Coverage Status](https://coveralls.io/repos/github/TheDigitalNinja/mcp-fitbit/badge.svg?branch=main)](https://coveralls.io/github/TheDigitalNinja/mcp-fitbit?branch=main)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![npm version](https://badge.fury.io/js/mcp-fitbit.svg)](https://badge.fury.io/js/mcp-fitbit)
+[![npm downloads](https://img.shields.io/npm/dm/mcp-fitbit.svg)](https://www.npmjs.com/package/mcp-fitbit)
+
+> Connect AI assistants to your Fitbit health data
+
+Give your AI assistant access to your Fitbit data for personalized health insights, trend analysis, and automated tracking. Works with Claude Desktop and other MCP-compatible AI tools.
+
+## What it does
+
+🏃 **Exercise & Activities** - Get detailed workout logs and activity data  
+😴 **Sleep Analysis** - Retrieve sleep patterns and quality metrics  
+⚖️ **Weight Tracking** - Access weight trends over time  
+❤️ **Heart Rate Data** - Monitor heart rate patterns and zones  
+🍎 **Nutrition Logs** - Review food intake, calories, and macros  
+👤 **Profile Info** - Access basic Fitbit profile details
+
+*Ask your AI things like: "Show me my sleep patterns this week" or "What's my average heart rate during workouts?"*
+
+## Quick Start
+
+**🚀 Want to test the tools right away?**
+
+### Option 1: Install from npm (Recommended)
+1. [Get Fitbit API credentials](https://dev.fitbit.com/)
+   - Create an app with OAuth 2.0 Application Type: `Personal`
+   - Set Callback URL: `http://localhost:3000/callback`
+   - Note your **Client ID** and **Client Secret**
+
+2. Install the package globally:
+```bash
+npm install -g mcp-fitbit
+```
+
+3. Add to your Claude Desktop config file:
+```json
+{
+  "mcpServers": {
+    "fitbit": {
+      "command": "mcp-fitbit",
+      "args": [],
+      "env": {
+        "FITBIT_CLIENT_ID": "your_client_id_here",
+        "FITBIT_CLIENT_SECRET": "your_client_secret_here"
+      }
+    }
+  }
+}
+```
+ - Config file location:
+   - Windows: %AppData%\Claude\claude_desktop_config.json
+   - macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
+   - Linux: ~/.config/Claude/claude_desktop_config.json
+
+4. Restart Claude Desktop and ask about your Fitbit data!
+
+
+
+### Option 2: Development Setup
+1. [Get Fitbit API credentials](https://dev.fitbit.com/) (see Installation below)
+2. Then run:
+
+```bash
+git clone https://github.com/TheDigitalNinja/mcp-fitbit
+cd mcp-fitbit
+npm install
+# Create .env with your Fitbit credentials
+npm run dev
+```
+
+Both options open the **MCP Inspector** at `http://localhost:5173` where you can test all tools interactively and handle the OAuth flow.
+
+## Installation
+
+### For End Users (npm package)
+
+1. **Get Fitbit API credentials** at [dev.fitbit.com](https://dev.fitbit.com/)
+   - Set **OAuth 2.0 Application Type** to `Personal`  
+   - Set **Callback URL** to `http://localhost:3000/callback`
+
+2. **Install the package:**
+   ```bash
+   npm install -g mcp-fitbit
+   ```
+
+3. **Create `.env` file in the package directory:**
+   
+   When you run `mcp-fitbit` for the first time, it will tell you exactly where to create the `.env` file. It will look something like:
+   ```
+   C:\Users\YourName\AppData\Roaming\npm\node_modules\mcp-fitbit\.env
+   ```
+
+4. **Add your credentials to the `.env` file:**
+   ```bash
+   FITBIT_CLIENT_ID=your_client_id_here
+   FITBIT_CLIENT_SECRET=your_client_secret_here
+   ```
+
+5. **Run the server:**
+   ```bash
+   mcp-fitbit
+   ```
+
+### For Developers (from source)
+
+1. **Get Fitbit API credentials** at [dev.fitbit.com](https://dev.fitbit.com/)
+   - Set **OAuth 2.0 Application Type** to `Personal`
+   - Set **Callback URL** to `http://localhost:3000/callback`
+
+2. **Clone and setup:**
+   ```bash
+   git clone https://github.com/TheDigitalNinja/mcp-fitbit
+   cd mcp-fitbit
+   npm install
+   ```
+
+3. **Create `.env` file:**
+   ```bash
+   FITBIT_CLIENT_ID=your_client_id_here
+   FITBIT_CLIENT_SECRET=your_client_secret_here
+   ```
+
+4. **Build the server:**
+   ```bash
+   npm run build
+   ```
+
+
+## Available Tools
+
+| Tool | Description | Parameters |
+|------|-------------|------------|
+| `get_weight` | Weight data over time periods | `period`: `1d`, `7d`, `30d`, `3m`, `6m`, `1y` |
+| `get_sleep_by_date_range` | Sleep logs for date range (max 100 days) | `startDate`, `endDate` (YYYY-MM-DD) |
+| `get_exercises` | Activity/exercise logs after date | `afterDate` (YYYY-MM-DD), `limit` (1-100) |
+| `get_daily_activity_summary` | Daily activity summary with goals | `date` (YYYY-MM-DD) |
+| `get_activity_goals` | User's activity goals (daily/weekly) | `period`: `daily`, `weekly` |
+| `get_activity_timeseries` | Activity time series data (max 30 days) | `resourcePath`, `startDate`, `endDate` (YYYY-MM-DD) |
+| `get_azm_timeseries` | Active Zone Minutes time series (max 1095 days) | `startDate`, `endDate` (YYYY-MM-DD) |
+| `get_heart_rate` | Heart rate for time period | `period`: `1d`, `7d`, `30d`, `1w`, `1m`, optional `date` |
+| `get_heart_rate_by_date_range` | Heart rate for date range (max 1 year) | `startDate`, `endDate` (YYYY-MM-DD) |
+| `get_food_log` | Complete nutrition data for a day | `date` (YYYY-MM-DD or "today") |
+| `get_nutrition` | Individual nutrient over time | `resource`, `period`, optional `date` |
+| `get_nutrition_by_date_range` | Individual nutrient for date range | `resource`, `startDate`, `endDate` |
+| `get_profile` | User profile information | None |
+
+**Nutrition resources:** `caloriesIn`, `water`, `protein`, `carbs`, `fat`, `fiber`, `sodium`
+
+**Activity time series resources:** `steps`, `distance`, `calories`, `activityCalories`, `caloriesBMR`, `tracker/activityCalories`, `tracker/calories`, `tracker/distance`
+
+### Claude Desktop
+
+**Using npm package (recommended):**
+
+Add to `claude_desktop_config.json`:
+```json
+{
+  "mcpServers": {
+    "fitbit": {
+      "command": "mcp-fitbit",
+      "args": []
+    }
+  }
+}
+```
+
+**Using local development version:**
+
+Add to `claude_desktop_config.json`:
+```json
+{
+  "mcpServers": {
+    "fitbit": {
+      "command": "node",
+      "args": ["C:\\path\\to\\mcp-fitbit\\build\\index.js"]
+    }
+  }
+}
+```
+
+**Config file locations:**
+- Windows: `%AppData%\Claude\claude_desktop_config.json`
+- macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
+- Linux: `~/.config/Claude/claude_desktop_config.json`
+
+### First Run Authorization
+
+When you first ask your AI assistant to use Fitbit data:
+1. The server opens your browser to `http://localhost:3000/auth`
+2. Log in to Fitbit and grant permissions
+3. You'll be redirected to a success page
+4. Your AI can now access your Fitbit data!
+
+## Development
+
+```bash
+npm run lint          # Check code quality
+npm run format        # Fix formatting
+npm run build         # Compile TypeScript
+npm run dev           # Run with MCP inspector
+```
+
+**Architecture:** See [TASKS.md](TASKS.md) for improvement opportunities and technical details.
+

package/build/activities.js

@@ -0,0 +1,25 @@
+import { registerTool, CommonSchemas, handleFitbitApiCall } from './utils.js';
+// --- Tool Registration ---
+/**
+ * Registers a Fitbit activities/exercises tool with the MCP server.
+ * @param server The McpServer instance.
+ * @param getAccessTokenFn Function to retrieve the current access token.
+ */
+export function registerActivitiesTool(server, getAccessTokenFn) {
+    registerTool(server, {
+        name: 'get_exercises',
+        description: "Get the raw JSON response for exercise and activity logs from Fitbit after a specific date. Requires 'afterDate' parameter in 'YYYY-MM-DD' format. Retrieves a detailed list of logged exercises and activities.",
+        parametersSchema: {
+            afterDate: CommonSchemas.afterDate,
+            limit: CommonSchemas.limit,
+        },
+        handler: async ({ afterDate, limit = 20 }) => {
+            const endpoint = `activities/list.json?afterDate=${afterDate}&sort=asc&offset=0&limit=${limit}`;
+            return handleFitbitApiCall(endpoint, { afterDate, limit }, getAccessTokenFn, {
+                successDataExtractor: (data) => data.activities || [],
+                noDataMessage: `after date '${afterDate}'`,
+                errorContext: `after date '${afterDate}'`
+            });
+        }
+    });
+}

package/build/activity-goals.js

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { registerTool, handleFitbitApiCall } from './utils.js';
+/**
+ * Registers an activity goals tool with the MCP server.
+ * @param server The McpServer instance.
+ * @param getAccessTokenFn Function to retrieve the current access token.
+ */
+export function registerActivityGoalsTool(server, getAccessTokenFn) {
+    registerTool(server, {
+        name: 'get_activity_goals',
+        description: "Get the raw JSON response for user's activity goals from Fitbit. Supports 'daily' and 'weekly' periods. Returns goal values for steps, distance, calories, floors, active minutes, and active zone minutes.",
+        parametersSchema: {
+            period: z
+                .enum(['daily', 'weekly'])
+                .describe("Goal period - either 'daily' or 'weekly'")
+        },
+        handler: async ({ period }) => {
+            const endpoint = `activities/goals/${period}.json`;
+            return handleFitbitApiCall(endpoint, { period }, getAccessTokenFn, {
+                errorContext: `period '${period}'`
+            });
+        }
+    });
+}

package/build/activity-timeseries.js

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import { registerTool, CommonSchemas, handleFitbitApiCall } from './utils.js';
+/**
+ * Registers an activity time series tool with the MCP server.
+ * @param server The McpServer instance.
+ * @param getAccessTokenFn Function to retrieve the current access token.
+ */
+export function registerActivityTimeSeriesTool(server, getAccessTokenFn) {
+    registerTool(server, {
+        name: 'get_activity_timeseries',
+        description: "Get the raw JSON response for activity time series data from Fitbit over a date range (max 30 days). Supports various resource paths like 'steps', 'distance', 'calories', 'activityCalories', 'caloriesBMR'.",
+        parametersSchema: {
+            resourcePath: z
+                .enum([
+                'steps',
+                'distance',
+                'calories',
+                'activityCalories',
+                'caloriesBMR',
+                'tracker/activityCalories',
+                'tracker/calories',
+                'tracker/distance'
+            ])
+                .describe("Activity resource to retrieve (e.g., 'steps', 'distance', 'calories')"),
+            startDate: CommonSchemas.startDate,
+            endDate: CommonSchemas.endDate,
+        },
+        handler: async ({ resourcePath, startDate, endDate }) => {
+            const endpoint = `activities/${resourcePath}/date/${startDate}/${endDate}.json`;
+            return handleFitbitApiCall(endpoint, { resourcePath, startDate, endDate }, getAccessTokenFn, {
+                errorContext: `resource '${resourcePath}' from ${startDate} to ${endDate}`
+            });
+        }
+    });
+}

package/build/auth.js

@@ -0,0 +1,274 @@
+import dotenv from 'dotenv';
+import express from 'express';
+import open from 'open';
+import path from 'path';
+import { AuthorizationCode } from 'simple-oauth2';
+import { fileURLToPath } from 'url';
+import fs from 'fs/promises';
+import { existsSync } from 'fs';
+import { FITBIT_OAUTH_CONFIG } from './config.js';
+// Determine the directory of the current module (build/auth.js)
+const currentFilename = fileURLToPath(import.meta.url);
+const currentDirname = path.dirname(currentFilename);
+// Load environment variables from .env file located in the project root
+const envPath = path.resolve(currentDirname, '..', '.env');
+dotenv.config({ path: envPath });
+// Fitbit OAuth2 Configuration
+const fitbitConfig = {
+    client: {
+        id: process.env.FITBIT_CLIENT_ID || '',
+        secret: process.env.FITBIT_CLIENT_SECRET || '',
+    },
+    auth: {
+        tokenHost: 'https://api.fitbit.com',
+        authorizePath: 'https://www.fitbit.com/oauth2/authorize',
+        tokenPath: 'https://api.fitbit.com/oauth2/token',
+    },
+    options: {
+        authorizationMethod: 'header',
+    },
+};
+// OAuth2 Redirect URI and local server port
+const REDIRECT_URI = 'http://localhost:3000/callback';
+const PORT = 3000;
+// --- State Management ---
+// Storage for the access token and token data
+let accessToken = null;
+let tokenData = null;
+// Holds the temporary HTTP server instance used for the OAuth callback
+let oauthServer = null;
+// --- File paths for token persistence ---
+const TOKEN_FILE_PATH = path.resolve(currentDirname, '..', '.fitbit-token.json');
+// --- OAuth Client Initialization ---
+const oauthClient = new AuthorizationCode(fitbitConfig);
+/**
+ * Saves the token data to a file for persistence
+ * @param tokenData The token data to save
+ */
+async function saveTokenToFile(tokenData) {
+    try {
+        await fs.writeFile(TOKEN_FILE_PATH, JSON.stringify(tokenData, null, 2), 'utf8');
+        console.error(`Token saved to ${TOKEN_FILE_PATH}`);
+    }
+    catch (error) {
+        console.error(`Error saving token to file: ${error}`);
+    }
+}
+/**
+ * Loads the token data from file
+ * @returns The token data or null if not found
+ */
+async function loadTokenFromFile() {
+    try {
+        if (!existsSync(TOKEN_FILE_PATH)) {
+            console.error(`Token file not found at ${TOKEN_FILE_PATH}`);
+            return null;
+        }
+        const data = await fs.readFile(TOKEN_FILE_PATH, 'utf8');
+        const parsedData = JSON.parse(data);
+        console.error('Token loaded from file successfully');
+        return parsedData;
+    }
+    catch (error) {
+        console.error(`Error loading token from file: ${error}`);
+        return null;
+    }
+}
+// --- Fitbit Authorization Flow ---
+/**
+ * Initiates the Fitbit OAuth2 authorization code flow.
+ * Starts a temporary local web server to handle the redirect callback.
+ * Opens the user's browser to the Fitbit authorization page.
+ */
+export function startAuthorizationFlow() {
+    // Prevent multiple authorization flows from running simultaneously
+    if (oauthServer) {
+        console.error('OAuth server is already running.');
+        return;
+    }
+    // Ensure Client ID and Secret are loaded before starting
+    if (!fitbitConfig.client.id || !fitbitConfig.client.secret) {
+        console.error('Error: Fitbit Client ID or Secret not found. Check environment variables.');
+        return;
+    }
+    const app = express();
+    // Generate the Fitbit authorization URL
+    const authorizationUri = oauthClient.authorizeURL({
+        redirect_uri: REDIRECT_URI,
+        // Define necessary scopes required by the application
+        scope: FITBIT_OAUTH_CONFIG.SCOPES,
+    });
+    // Route to initiate the authorization flow by redirecting the user to Fitbit
+    app.get('/auth', (req, res) => {
+        console.error('Redirecting to Fitbit for authorization...');
+        res.redirect(authorizationUri);
+    });
+    // Callback route that Fitbit redirects to after user authorization
+    app.get('/callback', async (req, res) => {
+        const code = req.query.code;
+        // Handle cases where the authorization code is missing
+        if (!code) {
+            console.error('Authorization code missing in callback.');
+            res.status(400).send('Error: Authorization code missing.');
+            // Attempt to close the server if it exists
+            if (oauthServer) {
+                oauthServer.close(() => {
+                    console.error('OAuth server closed due to missing code.');
+                });
+                oauthServer = null;
+            }
+            return;
+        }
+        console.error('Received authorization code. Exchanging for token...');
+        const tokenParams = { code: code, redirect_uri: REDIRECT_URI };
+        try {
+            // Exchange the authorization code for an access token
+            const tokenResult = await oauthClient.getToken(tokenParams);
+            console.error('Access Token received successfully!');
+            accessToken = tokenResult.token.access_token;
+            tokenData = tokenResult.token;
+            // Persist token data to file
+            if (tokenData) {
+                await saveTokenToFile(tokenData);
+                console.error('Token data has been persisted to file');
+            }
+            res.send('Authorization successful! You can close this window. The MCP Server is now authenticated.');
+        }
+        catch (error) {
+            // Handle errors during token exchange
+            const typedError = error;
+            console.error('Error obtaining access token:', typedError.message || typedError);
+            if (typedError.response) {
+                try {
+                    const errorDetails = await typedError.response.text();
+                    console.error('Error details:', errorDetails);
+                    // Optionally parse errorDetails if it's JSON and log typedError.response.body
+                }
+                catch {
+                    console.error('Could not parse error response body.');
+                }
+            }
+            res
+                .status(500)
+                .send('Error obtaining access token. Check MCP server logs.');
+        }
+        finally {
+            // Ensure the temporary server is always shut down after handling the callback
+            if (oauthServer) {
+                console.error('Shutting down temporary OAuth server...');
+                oauthServer.close(() => {
+                    console.error('OAuth server closed.');
+                    oauthServer = null;
+                });
+            }
+        }
+    });
+    // Start the temporary local server
+    oauthServer = app.listen(PORT, async () => {
+        const authUrl = `http://localhost:${PORT}/auth`;
+        console.error(`--------------------------------------------------------------------`);
+        console.error(`ACTION REQUIRED: Fitbit Authorization Needed`);
+        console.error(`Attempting to open authorization page in your browser:`);
+        console.error(authUrl);
+        console.error(`If the browser doesn't open, please navigate there manually.`);
+        console.error(`Waiting for authorization callback...`);
+        console.error(`--------------------------------------------------------------------`);
+        // Attempt to automatically open the authorization URL in the default browser
+        try {
+            await open(authUrl);
+            console.error(`Browser opened (or attempted).`);
+        }
+        catch (err) {
+            console.error(`Failed to open browser automatically:`, err);
+        }
+    });
+    // Handle potential errors during server startup
+    oauthServer.on('error', (err) => {
+        console.error('Error starting temporary OAuth server:', err);
+        oauthServer = null;
+    });
+}
+/**
+ * Retrieves the current Fitbit access token.
+ * Automatically checks for token expiry and refreshes if necessary.
+ * @returns The access token string or null if not available.
+ */
+export async function getAccessToken() {
+    // Return null if no token data exists
+    if (!tokenData || !accessToken) {
+        console.error('No valid access token found.'); // Added missing console.error and fixed surrounding logic
+        return null;
+    }
+    // Check if token is expired
+    if (tokenData.expires_at && new Date(tokenData.expires_at) < new Date()) {
+        console.error('Token is expired. Attempting to refresh...');
+        try {
+            // Create AccessToken instance from the current token data
+            // FitbitTokenData is compatible with the 'Token' type expected by createToken
+            const accessTokenObj = oauthClient.createToken(tokenData);
+            // Refresh the token
+            if (accessTokenObj.expired()) {
+                const refreshedToken = await accessTokenObj.refresh();
+                accessToken = refreshedToken.token.access_token;
+                tokenData = refreshedToken.token;
+                // Save the refreshed token
+                await saveTokenToFile(tokenData);
+                console.error('Token refreshed and saved successfully.');
+                return accessToken;
+            }
+        }
+        catch (refreshError) {
+            console.error('Failed to refresh token:', refreshError);
+            accessToken = null;
+            tokenData = null;
+            return null;
+        }
+    }
+    return accessToken;
+}
+/**
+ * Initializes the authentication module.
+ * Loads persisted token from file storage if available.
+ */
+export async function initializeAuth() {
+    console.error('Auth initialized. Checking for persisted token...');
+    try {
+        // Load token data from file
+        tokenData = await loadTokenFromFile();
+        if (tokenData && tokenData.access_token) {
+            accessToken = tokenData.access_token;
+            console.error('Persisted access token loaded successfully.');
+            // Check if token is expired and needs refresh
+            if (tokenData.expires_at && new Date(tokenData.expires_at) < new Date()) {
+                console.error('Token is expired. Attempting to refresh...');
+                try {
+                    // Create AccessToken instance from the loaded token data
+                    // FitbitTokenData is compatible with the 'Token' type expected by createToken
+                    const accessTokenObj = oauthClient.createToken(tokenData);
+                    // Refresh the token
+                    if (accessTokenObj.expired()) {
+                        const refreshedToken = await accessTokenObj.refresh();
+                        accessToken = refreshedToken.token.access_token;
+                        tokenData = refreshedToken.token;
+                        // Save the refreshed token
+                        if (tokenData) {
+                            await saveTokenToFile(tokenData);
+                            console.error('Refreshed token saved successfully.');
+                        }
+                    }
+                }
+                catch (refreshError) {
+                    console.error('Error refreshing token:', refreshError);
+                    accessToken = null;
+                    tokenData = null;
+                }
+            }
+        }
+        else {
+            console.error('No valid access token found.');
+        }
+    }
+    catch (error) {
+        console.error('Error during token initialization:', error);
+    }
+}

package/build/azm-timeseries.js

@@ -0,0 +1,22 @@
+import { registerTool, CommonSchemas, handleFitbitApiCall } from './utils.js';
+/**
+ * Registers an Active Zone Minutes time series tool with the MCP server.
+ * @param server The McpServer instance.
+ * @param getAccessTokenFn Function to retrieve the current access token.
+ */
+export function registerAzmTimeSeriesTool(server, getAccessTokenFn) {
+    registerTool(server, {
+        name: 'get_azm_timeseries',
+        description: "Get the raw JSON response for Active Zone Minutes (AZM) time series data from Fitbit over a date range (max 1095 days). Returns total AZM plus breakdown by fat burn, cardio, and peak zones.",
+        parametersSchema: {
+            startDate: CommonSchemas.startDate,
+            endDate: CommonSchemas.endDate,
+        },
+        handler: async ({ startDate, endDate }) => {
+            const endpoint = `activities/active-zone-minutes/date/${startDate}/${endDate}.json`;
+            return handleFitbitApiCall(endpoint, { startDate, endDate }, getAccessTokenFn, {
+                errorContext: `AZM data from ${startDate} to ${endDate}`
+            });
+        }
+    });
+}

package/build/config.js

@@ -0,0 +1,56 @@
+/**
+ * Centralized configuration for the MCP Fitbit 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',
+    CALLBACK_URI: 'http://localhost:3000/callback',
+    SCOPES: [
+        'weight',
+        'sleep',
+        'profile',
+        'activity',
+        'heartrate',
+        'nutrition'
+    ].join(' ')
+};
+// === Tool Configuration ===
+// === Common Parameter Types ===
+export const TIME_PERIODS = ['1d', '7d', '30d', '3m', '6m', '1y'];
+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 ===
+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'
+};
+// === HTTP Configuration ===
+export const HTTP_CONFIG = {
+    USER_AGENT: 'mcp-fitbit-server/1.0',
+    TIMEOUT_MS: 30000,
+    MAX_RETRIES: 3
+};
+// === File Paths ===
+export const FILE_PATHS = {
+    TOKEN_STORAGE: '.fitbit-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',
+    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'
+};