@andreasnlarsen/whoop-cli 0.1.0

package/dist/commands/profile.js

@@ -0,0 +1,31 @@
+import { WhoopApiClient } from '../http/client.js';
+import { getGlobalOptions, printData, printError } from './context.js';
+export const registerProfileCommands = (program) => {
+    const profile = program.command('profile').description('Profile and body measurements');
+    profile
+        .command('show')
+        .description('Show basic WHOOP profile + body measurements')
+        .action(async function showAction() {
+        try {
+            const globals = getGlobalOptions(this);
+            const client = new WhoopApiClient(globals.profile);
+            const [basic, body] = await Promise.all([
+                client.requestJson({
+                    path: '/developer/v2/user/profile/basic',
+                    timeoutMs: globals.timeoutMs,
+                }),
+                client.requestJson({
+                    path: '/developer/v2/user/measurement/body',
+                    timeoutMs: globals.timeoutMs,
+                }),
+            ]);
+            printData(this, {
+                profile: basic,
+                body,
+            });
+        }
+        catch (err) {
+            printError(this, err);
+        }
+    });
+};

package/dist/commands/recovery.js

@@ -0,0 +1,58 @@
+import { WhoopApiClient } from '../http/client.js';
+import { fetchRecoveries } from '../http/whoop-data.js';
+import { getGlobalOptions, printData, printError } from './context.js';
+import { parseDateRange, parseMaybeNumber } from '../util/time.js';
+export const registerRecoveryCommands = (program) => {
+    const recovery = program.command('recovery').description('Recovery commands');
+    recovery
+        .command('latest')
+        .description('Fetch latest recovery record')
+        .action(async function latestAction() {
+        try {
+            const globals = getGlobalOptions(this);
+            const client = new WhoopApiClient(globals.profile);
+            const records = await fetchRecoveries(client, {
+                limit: 1,
+                timeoutMs: globals.timeoutMs,
+            });
+            printData(this, {
+                latest: records[0] ?? null,
+            });
+        }
+        catch (err) {
+            printError(this, err);
+        }
+    });
+    recovery
+        .command('list')
+        .description('List recovery records')
+        .option('--start <YYYY-MM-DD>')
+        .option('--end <YYYY-MM-DD>')
+        .option('--days <n>', 'lookback days if start/end not provided')
+        .option('--limit <n>', 'page size', '25')
+        .option('--all', 'follow pagination and fetch all pages')
+        .action(async function listAction(opts) {
+        try {
+            const globals = getGlobalOptions(this);
+            const client = new WhoopApiClient(globals.profile);
+            const range = parseDateRange({
+                start: opts.start,
+                end: opts.end,
+                days: parseMaybeNumber(opts.days),
+            });
+            const records = await fetchRecoveries(client, {
+                ...range,
+                limit: parseMaybeNumber(opts.limit),
+                all: Boolean(opts.all),
+                timeoutMs: globals.timeoutMs,
+            });
+            printData(this, {
+                count: records.length,
+                records,
+            });
+        }
+        catch (err) {
+            printError(this, err);
+        }
+    });
+};

package/dist/commands/sleep.js

@@ -0,0 +1,92 @@
+import { WhoopApiClient } from '../http/client.js';
+import { fetchSleeps } from '../http/whoop-data.js';
+import { getGlobalOptions, printData, printError } from './context.js';
+import { avg, round } from '../util/metrics.js';
+import { parseDateRange, parseMaybeNumber } from '../util/time.js';
+export const registerSleepCommands = (program) => {
+    const sleep = program.command('sleep').description('Sleep commands');
+    sleep
+        .command('latest')
+        .description('Fetch latest sleep record')
+        .action(async function latestAction() {
+        try {
+            const globals = getGlobalOptions(this);
+            const client = new WhoopApiClient(globals.profile);
+            const records = await fetchSleeps(client, {
+                limit: 1,
+                timeoutMs: globals.timeoutMs,
+            });
+            printData(this, {
+                latest: records[0] ?? null,
+            });
+        }
+        catch (err) {
+            printError(this, err);
+        }
+    });
+    sleep
+        .command('list')
+        .description('List sleep records')
+        .option('--start <YYYY-MM-DD>')
+        .option('--end <YYYY-MM-DD>')
+        .option('--days <n>', 'lookback days if start/end not provided')
+        .option('--limit <n>', 'page size', '25')
+        .option('--all', 'follow pagination and fetch all pages')
+        .action(async function listAction(opts) {
+        try {
+            const globals = getGlobalOptions(this);
+            const client = new WhoopApiClient(globals.profile);
+            const range = parseDateRange({
+                start: opts.start,
+                end: opts.end,
+                days: parseMaybeNumber(opts.days),
+            });
+            const records = await fetchSleeps(client, {
+                ...range,
+                limit: parseMaybeNumber(opts.limit),
+                all: Boolean(opts.all),
+                timeoutMs: globals.timeoutMs,
+            });
+            printData(this, {
+                count: records.length,
+                records,
+            });
+        }
+        catch (err) {
+            printError(this, err);
+        }
+    });
+    sleep
+        .command('trend')
+        .description('Sleep trend summary over a period')
+        .option('--days <n>', 'lookback days', '30')
+        .option('--limit <n>', 'page size', '25')
+        .action(async function trendAction(opts) {
+        try {
+            const globals = getGlobalOptions(this);
+            const client = new WhoopApiClient(globals.profile);
+            const days = parseMaybeNumber(opts.days) ?? 30;
+            const records = await fetchSleeps(client, {
+                ...parseDateRange({ days }),
+                limit: parseMaybeNumber(opts.limit),
+                all: true,
+                timeoutMs: globals.timeoutMs,
+            });
+            const performance = round(avg(records.map((r) => r.score?.sleep_performance_percentage)), 1);
+            const consistency = round(avg(records.map((r) => r.score?.sleep_consistency_percentage)), 1);
+            const efficiency = round(avg(records.map((r) => r.score?.sleep_efficiency_percentage)), 1);
+            printData(this, {
+                windowDays: days,
+                records: records.length,
+                averages: {
+                    sleepPerformancePct: performance,
+                    sleepConsistencyPct: consistency,
+                    sleepEfficiencyPct: efficiency,
+                },
+            });
+        }
+        catch (err) {
+            printError(this, err);
+        }
+    });
+};

package/dist/commands/summary.js

@@ -0,0 +1,115 @@
+import { WhoopApiClient } from '../http/client.js';
+import { fetchCycles, fetchRecoveries, fetchSleeps, fetchWorkouts } from '../http/whoop-data.js';
+import { classifyRecovery } from '../util/metrics.js';
+import { getGlobalOptions, printData, printError } from './context.js';
+const recommendLoad = (recoveryScore) => {
+    if (typeof recoveryScore !== 'number') {
+        return { target: 'unknown', note: 'No recovery score available yet.' };
+    }
+    if (recoveryScore >= 67) {
+        return { target: 'high', note: 'Push day is appropriate if goals require it.' };
+    }
+    if (recoveryScore >= 34) {
+        return { target: 'moderate', note: 'Maintain and avoid aggressive overload.' };
+    }
+    return { target: 'restorative', note: 'Prioritize recovery, low strain, and sleep quality.' };
+};
+const fetchDailyCore = async (client, timeoutMs) => {
+    const [recovery, sleep, cycle, workouts] = await Promise.all([
+        fetchRecoveries(client, { limit: 1, timeoutMs }),
+        fetchSleeps(client, { limit: 1, timeoutMs }),
+        fetchCycles(client, { limit: 1, timeoutMs }),
+        fetchWorkouts(client, { limit: 5, timeoutMs }),
+    ]);
+    return {
+        recovery: recovery[0] ?? null,
+        sleep: sleep[0] ?? null,
+        cycle: cycle[0] ?? null,
+        workouts,
+    };
+};
+export const registerSummaryCommands = (program) => {
+    program
+        .command('summary')
+        .description('One-line style WHOOP snapshot')
+        .action(async function summaryAction() {
+        try {
+            const globals = getGlobalOptions(this);
+            const client = new WhoopApiClient(globals.profile);
+            const core = await fetchDailyCore(client, globals.timeoutMs);
+            const payload = {
+                recoveryScore: core.recovery?.score?.recovery_score ?? null,
+                hrv: core.recovery?.score?.hrv_rmssd_milli ?? null,
+                restingHr: core.recovery?.score?.resting_heart_rate ?? null,
+                sleepPerformance: core.sleep?.score?.sleep_performance_percentage ?? null,
+                cycleStrain: core.cycle?.score?.strain ?? null,
+                recentWorkouts: core.workouts.length,
+            };
+            printData(this, payload);
+        }
+        catch (err) {
+            printError(this, err);
+        }
+    });
+    program
+        .command('day-brief')
+        .description('Readiness-oriented daily brief for planning your day')
+        .action(async function dayBriefAction() {
+        try {
+            const globals = getGlobalOptions(this);
+            const client = new WhoopApiClient(globals.profile);
+            const core = await fetchDailyCore(client, globals.timeoutMs);
+            const recoveryScore = core.recovery?.score?.recovery_score;
+            const load = recommendLoad(recoveryScore);
+            printData(this, {
+                readiness: {
+                    recoveryScore: recoveryScore ?? null,
+                    zone: classifyRecovery(recoveryScore),
+                    recommendation: load,
+                },
+                sleep: {
+                    performancePct: core.sleep?.score?.sleep_performance_percentage ?? null,
+                    consistencyPct: core.sleep?.score?.sleep_consistency_percentage ?? null,
+                    efficiencyPct: core.sleep?.score?.sleep_efficiency_percentage ?? null,
+                },
+                recentCycle: {
+                    strain: core.cycle?.score?.strain ?? null,
+                    start: core.cycle?.start ?? null,
+                    end: core.cycle?.end ?? null,
+                },
+                guidance: [
+                    recoveryScore !== undefined && recoveryScore < 34
+                        ? 'Prioritize recovery actions: hydration, lower-intensity training, stable bedtime.'
+                        : 'Keep sleep consistency high and align strain to readiness zone.',
+                ],
+            });
+        }
+        catch (err) {
+            printError(this, err);
+        }
+    });
+    program
+        .command('strain-plan')
+        .description('Suggest target training load from current recovery')
+        .action(async function strainPlanAction() {
+        try {
+            const globals = getGlobalOptions(this);
+            const client = new WhoopApiClient(globals.profile);
+            const [recovery] = await fetchRecoveries(client, { limit: 1, timeoutMs: globals.timeoutMs });
+            const [cycle] = await fetchCycles(client, { limit: 1, timeoutMs: globals.timeoutMs });
+            const recoveryScore = recovery?.score?.recovery_score;
+            const load = recommendLoad(recoveryScore);
+            const suggestedStrainRange = load.target === 'high' ? '14-18' : load.target === 'moderate' ? '10-14' : '0-9';
+            printData(this, {
+                recoveryScore: recoveryScore ?? null,
+                yesterdayStrain: cycle?.score?.strain ?? null,
+                recommendedLoad: load.target,
+                suggestedStrainRange,
+                note: load.note,
+            });
+        }
+        catch (err) {
+            printError(this, err);
+        }
+    });
+};

package/dist/commands/sync.js

@@ -0,0 +1,57 @@
+import { writeFile } from 'node:fs/promises';
+import { WhoopApiClient } from '../http/client.js';
+import { fetchCycles, fetchRecoveries, fetchSleeps, fetchWorkouts } from '../http/whoop-data.js';
+import { getGlobalOptions, printData, printError } from './context.js';
+import { parseDateRange } from '../util/time.js';
+import { usageError } from '../http/errors.js';
+const jsonl = (records) => records.map((r) => JSON.stringify(r)).join('\n') + '\n';
+export const registerSyncCommands = (program) => {
+    const sync = program.command('sync').description('Data export helpers');
+    sync
+        .command('pull')
+        .description('Pull WHOOP data and export as JSONL')
+        .requiredOption('--start <YYYY-MM-DD>')
+        .requiredOption('--end <YYYY-MM-DD>')
+        .requiredOption('--out <path>')
+        .option('--limit <n>', 'page size', '25')
+        .action(async function pullAction(opts) {
+        try {
+            const globals = getGlobalOptions(this);
+            const start = opts.start;
+            const end = opts.end;
+            const out = opts.out;
+            const range = parseDateRange({ start, end });
+            if (!range.start || !range.end) {
+                throw usageError('start and end are required for sync pull');
+            }
+            const client = new WhoopApiClient(globals.profile);
+            const limit = Number(opts.limit ?? 25);
+            const [recoveries, sleeps, cycles, workouts] = await Promise.all([
+                fetchRecoveries(client, { ...range, all: true, limit, timeoutMs: globals.timeoutMs }),
+                fetchSleeps(client, { ...range, all: true, limit, timeoutMs: globals.timeoutMs }),
+                fetchCycles(client, { ...range, all: true, limit, timeoutMs: globals.timeoutMs }),
+                fetchWorkouts(client, { ...range, all: true, limit, timeoutMs: globals.timeoutMs }),
+            ]);
+            const rows = [];
+            recoveries.forEach((r) => rows.push({ type: 'recovery', payload: r }));
+            sleeps.forEach((r) => rows.push({ type: 'sleep', payload: r }));
+            cycles.forEach((r) => rows.push({ type: 'cycle', payload: r }));
+            workouts.forEach((r) => rows.push({ type: 'workout', payload: r }));
+            await writeFile(out, jsonl(rows), 'utf8');
+            printData(this, {
+                out,
+                range,
+                counts: {
+                    recoveries: recoveries.length,
+                    sleeps: sleeps.length,
+                    cycles: cycles.length,
+                    workouts: workouts.length,
+                    totalRows: rows.length,
+                },
+            });
+        }
+        catch (err) {
+            printError(this, err);
+        }
+    });
+};

package/dist/commands/webhook.js

@@ -0,0 +1,38 @@
+import { getGlobalOptions, printData, printError } from './context.js';
+import { usageError } from '../http/errors.js';
+import { readRawBodyFromFile, verifyWhoopSignature } from '../util/webhook-signature.js';
+export const registerWebhookCommands = (program) => {
+    const webhook = program.command('webhook').description('Webhook helpers');
+    webhook
+        .command('verify')
+        .description('Verify WHOOP webhook signature')
+        .requiredOption('--secret <secret>', 'WHOOP app client secret')
+        .requiredOption('--timestamp <timestamp>', 'X-WHOOP-Signature-Timestamp header value')
+        .requiredOption('--signature <signature>', 'X-WHOOP-Signature header value')
+        .requiredOption('--body-file <path>', 'raw webhook body file path')
+        .action(async function verifyAction(opts) {
+        try {
+            getGlobalOptions(this);
+            const secret = String(opts.secret ?? '');
+            const timestamp = String(opts.timestamp ?? '');
+            const signature = String(opts.signature ?? '');
+            const bodyFile = String(opts.bodyFile ?? '');
+            if (!secret || !timestamp || !signature || !bodyFile) {
+                throw usageError('secret, timestamp, signature, and body-file are required');
+            }
+            const rawBody = await readRawBodyFromFile(bodyFile);
+            const valid = verifyWhoopSignature({
+                timestamp,
+                rawBody,
+                clientSecret: secret,
+                signature,
+            });
+            printData(this, {
+                valid,
+            });
+        }
+        catch (err) {
+            printError(this, err);
+        }
+    });
+};

package/dist/commands/workout.js

@@ -0,0 +1,77 @@
+import { WhoopApiClient } from '../http/client.js';
+import { fetchWorkouts } from '../http/whoop-data.js';
+import { getGlobalOptions, printData, printError } from './context.js';
+import { avg, round } from '../util/metrics.js';
+import { parseDateRange, parseMaybeNumber } from '../util/time.js';
+export const registerWorkoutCommands = (program) => {
+    const workout = program.command('workout').description('Workout commands');
+    workout
+        .command('list')
+        .description('List workouts')
+        .option('--start <YYYY-MM-DD>')
+        .option('--end <YYYY-MM-DD>')
+        .option('--days <n>', 'lookback days if start/end not provided', '14')
+        .option('--limit <n>', 'page size', '25')
+        .option('--all', 'follow pagination and fetch all pages')
+        .action(async function listAction(opts) {
+        try {
+            const globals = getGlobalOptions(this);
+            const client = new WhoopApiClient(globals.profile);
+            const range = parseDateRange({
+                start: opts.start,
+                end: opts.end,
+                days: parseMaybeNumber(opts.days),
+            });
+            const records = await fetchWorkouts(client, {
+                ...range,
+                limit: parseMaybeNumber(opts.limit),
+                all: Boolean(opts.all),
+                timeoutMs: globals.timeoutMs,
+            });
+            printData(this, {
+                count: records.length,
+                records,
+            });
+        }
+        catch (err) {
+            printError(this, err);
+        }
+    });
+    workout
+        .command('trend')
+        .description('Workout trend summary')
+        .option('--days <n>', 'lookback days', '14')
+        .option('--limit <n>', 'page size', '25')
+        .action(async function trendAction(opts) {
+        try {
+            const globals = getGlobalOptions(this);
+            const client = new WhoopApiClient(globals.profile);
+            const days = parseMaybeNumber(opts.days) ?? 14;
+            const records = await fetchWorkouts(client, {
+                ...parseDateRange({ days }),
+                limit: parseMaybeNumber(opts.limit),
+                all: true,
+                timeoutMs: globals.timeoutMs,
+            });
+            const avgStrain = round(avg(records.map((r) => r.score?.strain)), 2);
+            const avgHr = round(avg(records.map((r) => r.score?.average_heart_rate)), 1);
+            const bySport = records.reduce((acc, r) => {
+                const sport = r.sport_name ?? 'unknown';
+                acc[sport] = (acc[sport] ?? 0) + 1;
+                return acc;
+            }, {});
+            printData(this, {
+                windowDays: days,
+                workouts: records.length,
+                averages: {
+                    strain: avgStrain,
+                    averageHeartRate: avgHr,
+                },
+                bySport,
+            });
+        }
+        catch (err) {
+            printError(this, err);
+        }
+    });
+};

package/dist/http/client.js

@@ -0,0 +1,110 @@
+import { authError, httpError, networkError } from './errors.js';
+import { ensureFreshToken, refreshProfileToken } from '../auth/token-service.js';
+export class WhoopApiClient {
+    profileName;
+    constructor(profileName) {
+        this.profileName = profileName;
+    }
+    buildUrl(profile, path, query) {
+        const url = new URL(path, profile.baseUrl);
+        if (query) {
+            Object.entries(query).forEach(([key, value]) => {
+                if (value === undefined || value === null)
+                    return;
+                url.searchParams.set(key, String(value));
+            });
+        }
+        return url.toString();
+    }
+    async requestJson(opts) {
+        const profile = await ensureFreshToken(this.profileName);
+        return this.runRequest(profile, opts);
+    }
+    async runRequest(profile, opts) {
+        const token = profile.tokens?.accessToken;
+        if (!token) {
+            throw authError('Profile has no access token. Run whoop auth login.');
+        }
+        const url = this.buildUrl(profile, opts.path, opts.query);
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), opts.timeoutMs);
+        try {
+            const res = await fetch(url, {
+                method: opts.method ?? 'GET',
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                    'content-type': opts.body ? 'application/json' : 'application/json',
+                },
+                body: opts.body ? JSON.stringify(opts.body) : undefined,
+                signal: controller.signal,
+            });
+            const text = await res.text();
+            let parsed = text;
+            try {
+                parsed = text ? JSON.parse(text) : null;
+            }
+            catch {
+                // leave as text
+            }
+            if (res.status === 401 && (opts.retryOn401 ?? true)) {
+                const refreshed = await refreshProfileToken(this.profileName);
+                return this.runRequest(refreshed, { ...opts, retryOn401: false });
+            }
+            if (!res.ok) {
+                throw httpError(`WHOOP API request failed (${res.status})`, {
+                    status: res.status,
+                    path: opts.path,
+                    response: parsed,
+                });
+            }
+            return parsed;
+        }
+        catch (err) {
+            if (err.name === 'AbortError') {
+                throw networkError('WHOOP API request timed out', {
+                    timeoutMs: opts.timeoutMs,
+                    path: opts.path,
+                });
+            }
+            if (err.name === 'WhoopCliError')
+                throw err;
+            throw networkError('WHOOP API network request failed', {
+                path: opts.path,
+                cause: err instanceof Error ? err.message : String(err),
+            });
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    async getCollection(path, opts) {
+        const records = [];
+        let nextToken;
+        let pages = 0;
+        const pageLimit = opts.all ? opts.maxPages ?? 200 : 1;
+        const normalizeDateBoundary = (value, kind) => {
+            if (!value)
+                return undefined;
+            if (!/^\d{4}-\d{2}-\d{2}$/.test(value))
+                return value;
+            return kind === 'start' ? `${value}T00:00:00.000Z` : `${value}T23:59:59.999Z`;
+        };
+        do {
+            const response = await this.requestJson({
+                path,
+                timeoutMs: opts.timeoutMs,
+                query: {
+                    limit: opts.limit,
+                    start: normalizeDateBoundary(opts.start, 'start'),
+                    end: normalizeDateBoundary(opts.end, 'end'),
+                    nextToken,
+                },
+            });
+            const current = response.records ?? [];
+            records.push(...current);
+            nextToken = response.next_token;
+            pages += 1;
+        } while (nextToken && pages < pageLimit);
+        return records;
+    }
+}

package/dist/http/errors.js

@@ -0,0 +1,27 @@
+export class WhoopCliError extends Error {
+    code;
+    exitCode;
+    details;
+    constructor(code, message, exitCode, details) {
+        super(message);
+        this.name = 'WhoopCliError';
+        this.code = code;
+        this.exitCode = exitCode;
+        this.details = details;
+    }
+}
+export const usageError = (message, details) => new WhoopCliError('USAGE_ERROR', message, 2, details);
+export const configError = (message, details) => new WhoopCliError('CONFIG_ERROR', message, 2, details);
+export const authError = (message, details) => new WhoopCliError('AUTH_ERROR', message, 3, details);
+export const httpError = (message, details) => new WhoopCliError('HTTP_ERROR', message, 4, details);
+export const networkError = (message, details) => new WhoopCliError('NETWORK_ERROR', message, 4, details);
+export const notFoundError = (message, details) => new WhoopCliError('NOT_FOUND', message, 4, details);
+export const featureUnavailableError = (message, details) => new WhoopCliError('FEATURE_UNAVAILABLE', message, 2, details);
+export const normalizeError = (err) => {
+    if (err instanceof WhoopCliError)
+        return err;
+    if (err instanceof Error) {
+        return new WhoopCliError('INTERNAL_ERROR', err.message, 1);
+    }
+    return new WhoopCliError('INTERNAL_ERROR', String(err), 1);
+};

package/dist/http/whoop-data.js

@@ -0,0 +1,28 @@
+export const fetchRecoveries = async (client, opts) => client.getCollection('/developer/v2/recovery', {
+    start: opts.start,
+    end: opts.end,
+    limit: opts.limit,
+    all: opts.all,
+    timeoutMs: opts.timeoutMs,
+});
+export const fetchSleeps = async (client, opts) => client.getCollection('/developer/v2/activity/sleep', {
+    start: opts.start,
+    end: opts.end,
+    limit: opts.limit,
+    all: opts.all,
+    timeoutMs: opts.timeoutMs,
+});
+export const fetchCycles = async (client, opts) => client.getCollection('/developer/v2/cycle', {
+    start: opts.start,
+    end: opts.end,
+    limit: opts.limit,
+    all: opts.all,
+    timeoutMs: opts.timeoutMs,
+});
+export const fetchWorkouts = async (client, opts) => client.getCollection('/developer/v2/activity/workout', {
+    start: opts.start,
+    end: opts.end,
+    limit: opts.limit,
+    all: opts.all,
+    timeoutMs: opts.timeoutMs,
+});

package/dist/index.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { program } from './cli.js';
+program.parseAsync(process.argv).catch((err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(message);
+    process.exit(1);
+});

package/dist/models/whoop.js

@@ -0,0 +1 @@
+export {};

package/dist/output/envelope.js

@@ -0,0 +1,15 @@
+import { normalizeError } from '../http/errors.js';
+export const ok = (data) => ({ data, error: null });
+export const fail = (code, message, details) => ({
+    data: null,
+    error: {
+        code,
+        message,
+        details,
+    },
+});
+export const fromError = (err) => {
+    const e = normalizeError(err);
+    return fail(e.code, e.message, e.details);
+};
+export const stringifyEnvelope = (envelope, pretty = false) => JSON.stringify(envelope, null, pretty ? 2 : 0);