@daobrew/wellness-mcp 0.1.0

package/dist/src/health/google-fit.d.ts

@@ -0,0 +1,13 @@
+export interface GoogleFitToken {
+    access_token: string;
+    refresh_token: string;
+    expires_at: number;
+    token_type: string;
+}
+export declare function isConnected(): boolean;
+export declare function loadToken(): GoogleFitToken | null;
+export declare function saveToken(token: GoogleFitToken): void;
+export declare function exchangeCode(code: string, clientId: string, clientSecret: string, redirectUri: string): Promise<GoogleFitToken>;
+export declare function refreshAccessToken(token: GoogleFitToken, clientId: string, clientSecret: string): Promise<GoogleFitToken>;
+export declare function fetchDataSources(token: GoogleFitToken): Promise<any>;
+export declare function fetchHeartRate(token: GoogleFitToken, startTimeMs: number, endTimeMs: number): Promise<any>;

package/dist/src/health/google-fit.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isConnected = isConnected;
+exports.loadToken = loadToken;
+exports.saveToken = saveToken;
+exports.exchangeCode = exchangeCode;
+exports.refreshAccessToken = refreshAccessToken;
+exports.fetchDataSources = fetchDataSources;
+exports.fetchHeartRate = fetchHeartRate;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const PREFS_DIR = (0, path_1.join)((0, os_1.homedir)(), ".daobrew");
+const TOKEN_FILE = (0, path_1.join)(PREFS_DIR, "google-fit-token.json");
+const FITNESS_API_BASE = "https://www.googleapis.com/fitness/v1/users/me";
+function isConnected() {
+    return (0, fs_1.existsSync)(TOKEN_FILE);
+}
+function loadToken() {
+    if (!(0, fs_1.existsSync)(TOKEN_FILE))
+        return null;
+    try {
+        return JSON.parse((0, fs_1.readFileSync)(TOKEN_FILE, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function saveToken(token) {
+    if (!(0, fs_1.existsSync)(PREFS_DIR))
+        (0, fs_1.mkdirSync)(PREFS_DIR, { recursive: true });
+    (0, fs_1.writeFileSync)(TOKEN_FILE, JSON.stringify(token, null, 2));
+}
+async function exchangeCode(code, clientId, clientSecret, redirectUri) {
+    const response = await fetch("https://oauth2.googleapis.com/token", {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({
+            grant_type: "authorization_code",
+            code,
+            client_id: clientId,
+            client_secret: clientSecret,
+            redirect_uri: redirectUri,
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`Google token exchange failed: ${response.status}`);
+    }
+    const data = await response.json();
+    const token = {
+        access_token: data.access_token,
+        refresh_token: data.refresh_token,
+        expires_at: Date.now() + (data.expires_in ?? 3600) * 1000,
+        token_type: data.token_type ?? "Bearer",
+    };
+    saveToken(token);
+    return token;
+}
+async function refreshAccessToken(token, clientId, clientSecret) {
+    const response = await fetch("https://oauth2.googleapis.com/token", {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({
+            grant_type: "refresh_token",
+            refresh_token: token.refresh_token,
+            client_id: clientId,
+            client_secret: clientSecret,
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`Google token refresh failed: ${response.status}`);
+    }
+    const data = await response.json();
+    const newToken = {
+        access_token: data.access_token,
+        refresh_token: token.refresh_token,
+        expires_at: Date.now() + (data.expires_in ?? 3600) * 1000,
+        token_type: data.token_type ?? "Bearer",
+    };
+    saveToken(newToken);
+    return newToken;
+}
+async function fetchDataSources(token) {
+    const response = await fetch(`${FITNESS_API_BASE}/dataSources`, {
+        headers: { Authorization: `Bearer ${token.access_token}` },
+    });
+    if (!response.ok)
+        throw new Error(`Google Fit API error: ${response.status}`);
+    return response.json();
+}
+async function fetchHeartRate(token, startTimeMs, endTimeMs) {
+    const response = await fetch(`${FITNESS_API_BASE}/dataset:aggregate`, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${token.access_token}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            aggregateBy: [{ dataTypeName: "com.google.heart_rate.bpm" }],
+            bucketByTime: { durationMillis: 3600000 },
+            startTimeMillis: startTimeMs,
+            endTimeMillis: endTimeMs,
+        }),
+    });
+    if (!response.ok)
+        throw new Error(`Google Fit API error: ${response.status}`);
+    return response.json();
+}

package/dist/src/health/index.d.ts

@@ -0,0 +1,6 @@
+export * as oura from "./oura.js";
+export * as googleFit from "./google-fit.js";
+export { startOAuthFlow } from "./oauth.js";
+export type { OAuthResult } from "./oauth.js";
+export { syncAllConnectedSources } from "./sync.js";
+export type { SyncResult } from "./sync.js";

package/dist/src/health/index.js

@@ -0,0 +1,42 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncAllConnectedSources = exports.startOAuthFlow = exports.googleFit = exports.oura = void 0;
+exports.oura = __importStar(require("./oura.js"));
+exports.googleFit = __importStar(require("./google-fit.js"));
+var oauth_js_1 = require("./oauth.js");
+Object.defineProperty(exports, "startOAuthFlow", { enumerable: true, get: function () { return oauth_js_1.startOAuthFlow; } });
+var sync_js_1 = require("./sync.js");
+Object.defineProperty(exports, "syncAllConnectedSources", { enumerable: true, get: function () { return sync_js_1.syncAllConnectedSources; } });

package/dist/src/health/oauth.d.ts

@@ -0,0 +1,6 @@
+export interface OAuthResult {
+    status: "connected" | "error" | "cancelled";
+    source: string;
+    error?: string;
+}
+export declare function startOAuthFlow(source: "oura" | "google_fit", clientId: string, authUrl: string, tokenUrl: string, scopes: string[]): Promise<OAuthResult>;

package/dist/src/health/oauth.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startOAuthFlow = startOAuthFlow;
+const http_1 = require("http");
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const PREFS_DIR = (0, path_1.join)((0, os_1.homedir)(), ".daobrew");
+async function exchangeCodeForToken(source, code, clientId, clientSecret, tokenUrl, redirectUri) {
+    if (source === "oura") {
+        const { exchangeCode } = await import("./oura.js");
+        await exchangeCode(code, clientId, clientSecret, redirectUri);
+    }
+    else {
+        const { exchangeCode } = await import("./google-fit.js");
+        await exchangeCode(code, clientId, clientSecret, redirectUri);
+    }
+}
+async function startOAuthFlow(source, clientId, authUrl, tokenUrl, scopes) {
+    const clientSecret = source === "oura"
+        ? process.env.DAOBREW_OURA_CLIENT_SECRET ?? ""
+        : process.env.DAOBREW_GOOGLE_CLIENT_SECRET ?? "";
+    return new Promise((resolve) => {
+        const server = (0, http_1.createServer)(async (req, res) => {
+            const url = new URL(req.url ?? "/", `http://localhost`);
+            if (url.pathname === "/callback") {
+                const code = url.searchParams.get("code");
+                if (!code) {
+                    res.writeHead(400);
+                    res.end("Missing authorization code");
+                    server.close();
+                    resolve({ status: "error", source, error: "No authorization code received" });
+                    return;
+                }
+                try {
+                    if (!(0, fs_1.existsSync)(PREFS_DIR))
+                        (0, fs_1.mkdirSync)(PREFS_DIR, { recursive: true });
+                    const port = server.address().port;
+                    const redirectUri = `http://localhost:${port}/callback`;
+                    await exchangeCodeForToken(source, code, clientId, clientSecret, tokenUrl, redirectUri);
+                    res.writeHead(200, { "Content-Type": "text/html" });
+                    res.end("<html><body><h2>DaoBrew connected! You can close this tab.</h2></body></html>");
+                    server.close();
+                    resolve({ status: "connected", source });
+                }
+                catch (err) {
+                    res.writeHead(500);
+                    res.end("Token exchange failed");
+                    server.close();
+                    resolve({ status: "error", source, error: err.message });
+                }
+            }
+        });
+        server.listen(0, () => {
+            const port = server.address().port;
+            const redirectUri = `http://localhost:${port}/callback`;
+            const fullAuthUrl = `${authUrl}?client_id=${encodeURIComponent(clientId)}&redirect_uri=${encodeURIComponent(redirectUri)}&scope=${encodeURIComponent(scopes.join(" "))}&response_type=code`;
+            // Use execFile (no shell) to avoid command injection
+            const openCmd = process.platform === "darwin" ? "open" : "xdg-open";
+            (0, child_process_1.execFile)(openCmd, [fullAuthUrl], () => { });
+        });
+        // Timeout after 2 minutes
+        setTimeout(() => {
+            server.close();
+            resolve({ status: "cancelled", source, error: "OAuth flow timed out (2 min)" });
+        }, 120000);
+    });
+}

package/dist/src/health/oura.d.ts

@@ -0,0 +1,14 @@
+export interface OuraToken {
+    access_token: string;
+    refresh_token: string;
+    expires_at: number;
+    token_type: string;
+}
+export declare function isConnected(): boolean;
+export declare function loadToken(): OuraToken | null;
+export declare function saveToken(token: OuraToken): void;
+export declare function exchangeCode(code: string, clientId: string, clientSecret: string, redirectUri: string): Promise<OuraToken>;
+export declare function refreshAccessToken(token: OuraToken): Promise<OuraToken>;
+export declare function fetchDailyReadiness(token: OuraToken, startDate?: string, endDate?: string): Promise<any>;
+export declare function fetchHeartRate(token: OuraToken, startDate?: string, endDate?: string): Promise<any>;
+export declare function fetchSleep(token: OuraToken, startDate?: string, endDate?: string): Promise<any>;

package/dist/src/health/oura.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isConnected = isConnected;
+exports.loadToken = loadToken;
+exports.saveToken = saveToken;
+exports.exchangeCode = exchangeCode;
+exports.refreshAccessToken = refreshAccessToken;
+exports.fetchDailyReadiness = fetchDailyReadiness;
+exports.fetchHeartRate = fetchHeartRate;
+exports.fetchSleep = fetchSleep;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const PREFS_DIR = (0, path_1.join)((0, os_1.homedir)(), ".daobrew");
+const TOKEN_FILE = (0, path_1.join)(PREFS_DIR, "oura-token.json");
+const OURA_API_BASE = "https://api.ouraring.com/v2/usercollection";
+function isConnected() {
+    return (0, fs_1.existsSync)(TOKEN_FILE);
+}
+function loadToken() {
+    if (!(0, fs_1.existsSync)(TOKEN_FILE))
+        return null;
+    try {
+        return JSON.parse((0, fs_1.readFileSync)(TOKEN_FILE, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function saveToken(token) {
+    if (!(0, fs_1.existsSync)(PREFS_DIR))
+        (0, fs_1.mkdirSync)(PREFS_DIR, { recursive: true });
+    (0, fs_1.writeFileSync)(TOKEN_FILE, JSON.stringify(token, null, 2));
+}
+async function exchangeCode(code, clientId, clientSecret, redirectUri) {
+    const response = await fetch("https://api.ouraring.com/oauth/token", {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({
+            grant_type: "authorization_code",
+            code,
+            client_id: clientId,
+            client_secret: clientSecret,
+            redirect_uri: redirectUri,
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`Oura token exchange failed: ${response.status}`);
+    }
+    const data = await response.json();
+    const token = {
+        access_token: data.access_token,
+        refresh_token: data.refresh_token,
+        expires_at: Date.now() + (data.expires_in ?? 86400) * 1000,
+        token_type: data.token_type ?? "Bearer",
+    };
+    saveToken(token);
+    return token;
+}
+async function refreshAccessToken(token) {
+    const clientId = process.env.DAOBREW_OURA_CLIENT_ID ?? "";
+    const clientSecret = process.env.DAOBREW_OURA_CLIENT_SECRET ?? "";
+    if (!clientId || !clientSecret) {
+        throw new Error("Cannot refresh Oura token: DAOBREW_OURA_CLIENT_ID/SECRET not set");
+    }
+    const response = await fetch("https://api.ouraring.com/oauth/token", {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({
+            grant_type: "refresh_token",
+            refresh_token: token.refresh_token,
+            client_id: clientId,
+            client_secret: clientSecret,
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`Oura token refresh failed: ${response.status}`);
+    }
+    const data = await response.json();
+    const newToken = {
+        access_token: data.access_token,
+        refresh_token: data.refresh_token ?? token.refresh_token,
+        expires_at: Date.now() + (data.expires_in ?? 86400) * 1000,
+        token_type: data.token_type ?? "Bearer",
+    };
+    saveToken(newToken);
+    return newToken;
+}
+async function fetchDailyReadiness(token, startDate, endDate) {
+    const params = new URLSearchParams();
+    if (startDate)
+        params.set("start_date", startDate);
+    if (endDate)
+        params.set("end_date", endDate);
+    const qs = params.toString() ? `?${params.toString()}` : "";
+    const response = await fetch(`${OURA_API_BASE}/daily_readiness${qs}`, {
+        headers: { Authorization: `Bearer ${token.access_token}` },
+    });
+    if (!response.ok)
+        throw new Error(`Oura API error: ${response.status}`);
+    return response.json();
+}
+async function fetchHeartRate(token, startDate, endDate) {
+    const params = new URLSearchParams();
+    if (startDate)
+        params.set("start_datetime", startDate);
+    if (endDate)
+        params.set("end_datetime", endDate);
+    const qs = params.toString() ? `?${params.toString()}` : "";
+    const response = await fetch(`${OURA_API_BASE}/heartrate${qs}`, {
+        headers: { Authorization: `Bearer ${token.access_token}` },
+    });
+    if (!response.ok)
+        throw new Error(`Oura API error: ${response.status}`);
+    return response.json();
+}
+async function fetchSleep(token, startDate, endDate) {
+    const params = new URLSearchParams();
+    if (startDate)
+        params.set("start_date", startDate);
+    if (endDate)
+        params.set("end_date", endDate);
+    const qs = params.toString() ? `?${params.toString()}` : "";
+    const response = await fetch(`${OURA_API_BASE}/sleep${qs}`, {
+        headers: { Authorization: `Bearer ${token.access_token}` },
+    });
+    if (!response.ok)
+        throw new Error(`Oura API error: ${response.status}`);
+    return response.json();
+}

package/dist/src/health/sync.d.ts

@@ -0,0 +1,7 @@
+import { DaoBrewClient } from "../client.js";
+export interface SyncResult {
+    source: string;
+    samples_pushed: number;
+    error?: string;
+}
+export declare function syncAllConnectedSources(client: DaoBrewClient): Promise<SyncResult[]>;

package/dist/src/health/sync.js

@@ -0,0 +1,194 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncAllConnectedSources = syncAllConnectedSources;
+const oura = __importStar(require("./oura.js"));
+const googleFit = __importStar(require("./google-fit.js"));
+async function syncAllConnectedSources(client) {
+    const results = [];
+    if (oura.isConnected()) {
+        results.push(await syncOura(client));
+    }
+    if (googleFit.isConnected()) {
+        results.push(await syncGoogleFit(client));
+    }
+    return results;
+}
+async function syncOura(client) {
+    let token = oura.loadToken();
+    if (!token)
+        return { source: "oura", samples_pushed: 0, error: "No token found" };
+    try {
+        // Refresh token if expired
+        if (Date.now() >= token.expires_at) {
+            token = await oura.refreshAccessToken(token);
+        }
+        const samples = [];
+        // Use last 4 hours for heart rate, last 2 days for sleep/readiness
+        const now = new Date();
+        const fourHoursAgo = new Date(now.getTime() - 4 * 60 * 60 * 1000);
+        const twoDaysAgo = new Date(now.getTime() - 2 * 24 * 60 * 60 * 1000);
+        const hrStart = fourHoursAgo.toISOString();
+        const hrEnd = now.toISOString();
+        const sleepStart = twoDaysAgo.toISOString().slice(0, 10);
+        const sleepEnd = now.toISOString().slice(0, 10);
+        // Fetch heart rate
+        const hrData = await oura.fetchHeartRate(token, hrStart, hrEnd);
+        if (hrData?.data) {
+            for (const d of hrData.data) {
+                if (d.bpm != null && d.timestamp) {
+                    samples.push({
+                        metric_type: "heart_rate",
+                        value: d.bpm,
+                        unit: "bpm",
+                        start_time: d.timestamp,
+                        end_time: d.timestamp,
+                        source: "oura",
+                    });
+                }
+            }
+        }
+        // Fetch sleep — extract HRV, resting HR, sleep duration
+        const sleepData = await oura.fetchSleep(token, sleepStart, sleepEnd);
+        if (sleepData?.data) {
+            for (const s of sleepData.data) {
+                if (s.average_hrv != null && s.bedtime_start && s.bedtime_end) {
+                    samples.push({
+                        metric_type: "heart_rate_variability",
+                        value: s.average_hrv,
+                        unit: "ms",
+                        start_time: s.bedtime_start,
+                        end_time: s.bedtime_end,
+                        source: "oura",
+                    });
+                }
+                if (s.lowest_heart_rate != null && s.bedtime_start && s.bedtime_end) {
+                    samples.push({
+                        metric_type: "resting_heart_rate",
+                        value: s.lowest_heart_rate,
+                        unit: "bpm",
+                        start_time: s.bedtime_start,
+                        end_time: s.bedtime_end,
+                        source: "oura",
+                    });
+                }
+                if (s.total_sleep_duration != null && s.bedtime_start && s.bedtime_end) {
+                    samples.push({
+                        metric_type: "sleep_analysis",
+                        value: s.total_sleep_duration,
+                        unit: "seconds",
+                        start_time: s.bedtime_start,
+                        end_time: s.bedtime_end,
+                        source: "oura",
+                    });
+                }
+            }
+        }
+        // Fetch readiness — extract body temp deviation
+        const readiness = await oura.fetchDailyReadiness(token, sleepStart, sleepEnd);
+        if (readiness?.data) {
+            for (const r of readiness.data) {
+                if (r.temperature_deviation != null && r.day) {
+                    samples.push({
+                        metric_type: "body_temperature",
+                        value: 36.8 + r.temperature_deviation,
+                        unit: "celsius",
+                        start_time: r.day + "T00:00:00Z",
+                        end_time: r.day + "T23:59:59Z",
+                        source: "oura",
+                    });
+                }
+            }
+        }
+        if (samples.length === 0) {
+            return { source: "oura", samples_pushed: 0 };
+        }
+        const result = await client.pushHealthSamples(samples);
+        return { source: "oura", samples_pushed: result.samples_received };
+    }
+    catch (err) {
+        return { source: "oura", samples_pushed: 0, error: err.message };
+    }
+}
+async function syncGoogleFit(client) {
+    let token = googleFit.loadToken();
+    if (!token)
+        return { source: "google_fit", samples_pushed: 0, error: "No token found" };
+    try {
+        // Refresh token if expired
+        if (Date.now() >= token.expires_at) {
+            const clientId = process.env.DAOBREW_GOOGLE_CLIENT_ID ?? "";
+            const clientSecret = process.env.DAOBREW_GOOGLE_CLIENT_SECRET ?? "";
+            if (clientId && clientSecret) {
+                token = await googleFit.refreshAccessToken(token, clientId, clientSecret);
+            }
+        }
+        const samples = [];
+        const now = Date.now();
+        const fourHoursAgo = now - 4 * 60 * 60 * 1000;
+        // Fetch heart rate via aggregate API
+        const hrData = await googleFit.fetchHeartRate(token, fourHoursAgo, now);
+        if (hrData?.bucket) {
+            for (const bucket of hrData.bucket) {
+                for (const dataset of bucket.dataset ?? []) {
+                    for (const point of dataset.point ?? []) {
+                        for (const val of point.value ?? []) {
+                            if (val.fpVal != null) {
+                                const startMs = parseInt(point.startTimeNanos) / 1_000_000;
+                                const endMs = parseInt(point.endTimeNanos) / 1_000_000;
+                                samples.push({
+                                    metric_type: "heart_rate",
+                                    value: val.fpVal,
+                                    unit: "bpm",
+                                    start_time: new Date(startMs).toISOString(),
+                                    end_time: new Date(endMs).toISOString(),
+                                    source: "google_fit",
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        if (samples.length === 0) {
+            return { source: "google_fit", samples_pushed: 0 };
+        }
+        const result = await client.pushHealthSamples(samples);
+        return { source: "google_fit", samples_pushed: result.samples_received };
+    }
+    catch (err) {
+        return { source: "google_fit", samples_pushed: 0, error: err.message };
+    }
+}

package/dist/src/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};