@andreasnlarsen/whoop-cli 0.1.0

package/dist/commands/auth.js

@@ -0,0 +1,175 @@
+import { ask } from '../util/prompt.js';
+import { tryOpenBrowser } from '../util/open-browser.js';
+import { buildAuthUrl, exchangeAuthCode, generateState, parseAuthInput } from '../auth/oauth.js';
+import { getGlobalOptions, printData, printError } from './context.js';
+import { loadProfile, saveProfile, clearProfileTokens } from '../store/profile-store.js';
+import { tokenFromOAuth, refreshProfileToken } from '../auth/token-service.js';
+import { configError, usageError } from '../http/errors.js';
+const DEFAULT_SCOPES = [
+    'read:recovery',
+    'read:cycles',
+    'read:workout',
+    'read:sleep',
+    'read:profile',
+    'read:body_measurement',
+    'offline',
+];
+const splitScopes = (raw) => raw
+    ? raw
+        .split(/[\s,]+/)
+        .map((s) => s.trim())
+        .filter(Boolean)
+    : DEFAULT_SCOPES;
+const resolveClientConfig = async (profileName, baseUrl, overrides) => {
+    const existing = await loadProfile(profileName);
+    const clientId = overrides.clientId ?? process.env.WHOOP_CLIENT_ID ?? existing?.clientId;
+    const clientSecret = overrides.clientSecret ?? process.env.WHOOP_CLIENT_SECRET ?? existing?.clientSecret;
+    const redirectUri = overrides.redirectUri ?? process.env.WHOOP_REDIRECT_URI ?? existing?.redirectUri;
+    if (!clientId || !clientSecret || !redirectUri) {
+        throw configError('Missing WHOOP OAuth client config. Provide --client-id --client-secret --redirect-uri (or env vars WHOOP_CLIENT_ID/WHOOP_CLIENT_SECRET/WHOOP_REDIRECT_URI).');
+    }
+    return {
+        profileName,
+        clientId,
+        clientSecret,
+        redirectUri,
+        baseUrl,
+        scopes: splitScopes(overrides.scopes ?? existing?.scopes?.join(' ')),
+        createdAt: existing?.createdAt ?? new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        tokens: existing?.tokens,
+    };
+};
+export const registerAuthCommands = (program) => {
+    const auth = program.command('auth').description('Authentication commands');
+    auth
+        .command('login')
+        .description('Run OAuth login flow and store tokens')
+        .option('--client-id <id>')
+        .option('--client-secret <secret>')
+        .option('--redirect-uri <url>')
+        .option('--scopes <scopes>', 'space/comma separated scopes')
+        .option('--code <code>', 'authorization code (skip prompt)')
+        .option('--state <state>', 'state override')
+        .option('--no-open', 'do not attempt to open browser')
+        .action(async function loginAction(opts) {
+        try {
+            const globals = getGlobalOptions(this);
+            const profile = await resolveClientConfig(globals.profile, globals.baseUrl, {
+                clientId: opts.clientId,
+                clientSecret: opts.clientSecret,
+                redirectUri: opts.redirectUri,
+                scopes: opts.scopes,
+            });
+            const state = opts.state ?? generateState();
+            const authUrl = buildAuthUrl({
+                clientId: profile.clientId,
+                clientSecret: profile.clientSecret,
+                redirectUri: profile.redirectUri,
+                baseUrl: profile.baseUrl,
+            }, profile.scopes, state);
+            let openAttempted = false;
+            if (opts.open !== false) {
+                openAttempted = tryOpenBrowser(authUrl);
+            }
+            let code = opts.code;
+            if (!code) {
+                if (!globals.json) {
+                    console.log('Open this URL and authorize access:');
+                    console.log(authUrl);
+                    console.log(openAttempted ? '(attempted browser open)' : '(could not auto-open browser; copy URL manually)');
+                }
+                const input = await ask('Paste redirect URL (or authorization code): ');
+                const parsed = parseAuthInput(input);
+                code = parsed.code;
+                if (parsed.state && parsed.state !== state) {
+                    throw usageError('OAuth state mismatch. Retry login flow for security.', {
+                        expected: state,
+                        received: parsed.state,
+                    });
+                }
+            }
+            const tokenPayload = await exchangeAuthCode({
+                clientId: profile.clientId,
+                clientSecret: profile.clientSecret,
+                redirectUri: profile.redirectUri,
+                baseUrl: profile.baseUrl,
+            }, code);
+            profile.tokens = tokenFromOAuth(tokenPayload, profile.tokens?.refreshToken);
+            await saveProfile(globals.profile, profile);
+            printData(this, {
+                profile: globals.profile,
+                authenticated: true,
+                scopes: profile.scopes,
+                expiresAt: profile.tokens.expiresAt,
+            });
+        }
+        catch (err) {
+            printError(this, err);
+        }
+    });
+    auth
+        .command('status')
+        .description('Show current auth/token status')
+        .action(async function statusAction() {
+        try {
+            const globals = getGlobalOptions(this);
+            const profile = await loadProfile(globals.profile);
+            if (!profile?.tokens) {
+                printData(this, {
+                    profile: globals.profile,
+                    authenticated: false,
+                });
+                return;
+            }
+            const expiresAt = new Date(profile.tokens.expiresAt).getTime();
+            const remainingSeconds = Math.max(0, Math.floor((expiresAt - Date.now()) / 1000));
+            printData(this, {
+                profile: globals.profile,
+                authenticated: true,
+                baseUrl: profile.baseUrl,
+                scopes: profile.scopes,
+                tokenType: profile.tokens.tokenType,
+                expiresAt: profile.tokens.expiresAt,
+                expiresInSeconds: remainingSeconds,
+                hasRefreshToken: Boolean(profile.tokens.refreshToken),
+            });
+        }
+        catch (err) {
+            printError(this, err);
+        }
+    });
+    auth
+        .command('refresh')
+        .description('Refresh access token using stored refresh token')
+        .action(async function refreshAction() {
+        try {
+            const globals = getGlobalOptions(this);
+            const profile = await refreshProfileToken(globals.profile);
+            printData(this, {
+                profile: globals.profile,
+                refreshed: true,
+                expiresAt: profile.tokens?.expiresAt,
+            });
+        }
+        catch (err) {
+            printError(this, err);
+        }
+    });
+    auth
+        .command('logout')
+        .description('Clear stored tokens for profile')
+        .action(async function logoutAction() {
+        try {
+            const globals = getGlobalOptions(this);
+            await clearProfileTokens(globals.profile);
+            printData(this, {
+                profile: globals.profile,
+                loggedOut: true,
+            });
+        }
+        catch (err) {
+            printError(this, err);
+        }
+    });
+};

package/dist/commands/behavior.js

@@ -0,0 +1,87 @@
+import { readFile } from 'node:fs/promises';
+import { WhoopApiClient } from '../http/client.js';
+import { fetchRecoveries } from '../http/whoop-data.js';
+import { getGlobalOptions, printData, printError } from './context.js';
+import { behaviorLogPath } from '../util/config.js';
+import { avg, round } from '../util/metrics.js';
+import { featureUnavailableError, usageError } from '../http/errors.js';
+const readBehaviorLog = async (path) => {
+    const content = await readFile(path, 'utf8');
+    const rows = [];
+    for (const line of content.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        rows.push(JSON.parse(trimmed));
+    }
+    return rows;
+};
+export const registerBehaviorCommands = (program) => {
+    const behavior = program.command('behavior').description('Behavior impact and experiments');
+    behavior
+        .command('impacts')
+        .description('Estimate behavior impacts from local behavior log + WHOOP recoveries')
+        .option('--file <path>', 'behavior log jsonl path', behaviorLogPath())
+        .option('--days <n>', 'lookback days', '30')
+        .action(async function impactsAction(opts) {
+        try {
+            const globals = getGlobalOptions(this);
+            const file = opts.file;
+            const days = Number(opts.days ?? 30);
+            if (Number.isNaN(days) || days <= 0)
+                throw usageError('days must be > 0');
+            const rows = await readBehaviorLog(file).catch(() => {
+                throw featureUnavailableError('Behavior impacts require a local behavior log JSONL file. WHOOP public API does not currently expose Journal behavior impacts directly.', { file });
+            });
+            const client = new WhoopApiClient(globals.profile);
+            const recoveries = await fetchRecoveries(client, {
+                ...{ start: undefined, end: undefined },
+                limit: 25,
+                all: true,
+                timeoutMs: globals.timeoutMs,
+            });
+            const recoveryByDate = new Map();
+            for (const r of recoveries) {
+                const created = r.created_at?.slice(0, 10);
+                const score = r.score?.recovery_score;
+                if (created && typeof score === 'number') {
+                    recoveryByDate.set(created, score);
+                }
+            }
+            const behaviorScores = new Map();
+            for (const row of rows) {
+                const score = recoveryByDate.get(row.date);
+                if (typeof score !== 'number')
+                    continue;
+                for (const [behaviorName, active] of Object.entries(row.behaviors)) {
+                    const bucket = behaviorScores.get(behaviorName) ?? { yes: [], no: [] };
+                    (active ? bucket.yes : bucket.no).push(score);
+                    behaviorScores.set(behaviorName, bucket);
+                }
+            }
+            const impacts = Array.from(behaviorScores.entries())
+                .map(([behaviorName, bucket]) => {
+                const yesAvg = avg(bucket.yes);
+                const noAvg = avg(bucket.no);
+                const delta = yesAvg !== null && noAvg !== null ? yesAvg - noAvg : null;
+                return {
+                    behavior: behaviorName,
+                    yesCount: bucket.yes.length,
+                    noCount: bucket.no.length,
+                    yesRecoveryAvg: round(yesAvg, 1),
+                    noRecoveryAvg: round(noAvg, 1),
+                    deltaRecovery: round(delta, 1),
+                };
+            })
+                .sort((a, b) => (b.deltaRecovery ?? -999) - (a.deltaRecovery ?? -999));
+            printData(this, {
+                source: file,
+                records: rows.length,
+                impacts,
+            });
+        }
+        catch (err) {
+            printError(this, err);
+        }
+    });
+};

package/dist/commands/context.js

@@ -0,0 +1,39 @@
+import { DEFAULT_BASE_URL } from '../util/config.js';
+import { fromError, ok, stringifyEnvelope } from '../output/envelope.js';
+import { normalizeError } from '../http/errors.js';
+export const getGlobalOptions = (command) => {
+    const opts = command.optsWithGlobals();
+    return {
+        json: Boolean(opts.json),
+        pretty: Boolean(opts.pretty),
+        profile: opts.profile ?? 'default',
+        baseUrl: opts.baseUrl ?? DEFAULT_BASE_URL,
+        timeoutMs: Number(opts.timeoutMs ?? '10000'),
+    };
+};
+export const printData = (command, data) => {
+    const globals = getGlobalOptions(command);
+    if (globals.json) {
+        console.log(stringifyEnvelope(ok(data), globals.pretty));
+        return;
+    }
+    if (typeof data === 'string') {
+        console.log(data);
+        return;
+    }
+    console.log(JSON.stringify(data, null, 2));
+};
+export const printError = (command, err) => {
+    const globals = getGlobalOptions(command);
+    const normalized = normalizeError(err);
+    if (globals.json) {
+        console.log(stringifyEnvelope(fromError(normalized), globals.pretty));
+    }
+    else {
+        console.error(`${normalized.code}: ${normalized.message}`);
+        if (normalized.details) {
+            console.error(JSON.stringify(normalized.details, null, 2));
+        }
+    }
+    process.exit(normalized.exitCode);
+};

package/dist/commands/cycle.js

@@ -0,0 +1,58 @@
+import { WhoopApiClient } from '../http/client.js';
+import { fetchCycles } from '../http/whoop-data.js';
+import { getGlobalOptions, printData, printError } from './context.js';
+import { parseDateRange, parseMaybeNumber } from '../util/time.js';
+export const registerCycleCommands = (program) => {
+    const cycle = program.command('cycle').description('Cycle commands');
+    cycle
+        .command('latest')
+        .description('Fetch latest physiological cycle')
+        .action(async function latestAction() {
+        try {
+            const globals = getGlobalOptions(this);
+            const client = new WhoopApiClient(globals.profile);
+            const records = await fetchCycles(client, {
+                limit: 1,
+                timeoutMs: globals.timeoutMs,
+            });
+            printData(this, {
+                latest: records[0] ?? null,
+            });
+        }
+        catch (err) {
+            printError(this, err);
+        }
+    });
+    cycle
+        .command('list')
+        .description('List cycles')
+        .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 fetchCycles(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/experiment.js

@@ -0,0 +1,122 @@
+import { readJsonFile, writeJsonFileSecure } from '../util/fs.js';
+import { experimentsPath } from '../util/config.js';
+import { assertIsoDate, daysAgoIso } from '../util/time.js';
+import { getGlobalOptions, printData, printError } from './context.js';
+import { usageError } from '../http/errors.js';
+import { WhoopApiClient } from '../http/client.js';
+import { fetchRecoveries } from '../http/whoop-data.js';
+import { avg, round } from '../util/metrics.js';
+const loadStore = async () => {
+    const store = await readJsonFile(experimentsPath());
+    return store ?? { experiments: [] };
+};
+const saveStore = async (store) => {
+    await writeJsonFileSecure(experimentsPath(), store);
+};
+const makeId = () => Math.random().toString(36).slice(2, 10);
+export const registerExperimentCommands = (program) => {
+    const experiment = program.command('experiment').description('Behavior experiment tracking');
+    experiment
+        .command('start')
+        .description('Start a behavior experiment')
+        .requiredOption('--name <name>')
+        .requiredOption('--behavior <behavior>')
+        .option('--start-date <YYYY-MM-DD>', 'default: today UTC')
+        .option('--end-date <YYYY-MM-DD>')
+        .action(async function startAction(opts) {
+        try {
+            const startDate = opts.startDate ? assertIsoDate(opts.startDate, 'start-date') : daysAgoIso(0);
+            const endDate = opts.endDate ? assertIsoDate(opts.endDate, 'end-date') : undefined;
+            const store = await loadStore();
+            const item = {
+                id: makeId(),
+                name: String(opts.name),
+                behavior: String(opts.behavior),
+                startDate,
+                endDate,
+                createdAt: new Date().toISOString(),
+            };
+            store.experiments.unshift(item);
+            await saveStore(store);
+            printData(this, item);
+        }
+        catch (err) {
+            printError(this, err);
+        }
+    });
+    experiment
+        .command('list')
+        .description('List saved experiments')
+        .action(async function listAction() {
+        try {
+            const store = await loadStore();
+            printData(this, { count: store.experiments.length, experiments: store.experiments });
+        }
+        catch (err) {
+            printError(this, err);
+        }
+    });
+    experiment
+        .command('report')
+        .description('Generate baseline-vs-experiment recovery report')
+        .requiredOption('--id <experimentId>')
+        .option('--baseline-days <n>', 'default 14', '14')
+        .action(async function reportAction(opts) {
+        try {
+            const globals = getGlobalOptions(this);
+            const baselineDays = Number(opts.baselineDays ?? 14);
+            if (Number.isNaN(baselineDays) || baselineDays <= 0) {
+                throw usageError('baseline-days must be > 0');
+            }
+            const store = await loadStore();
+            const exp = store.experiments.find((x) => x.id === opts.id);
+            if (!exp) {
+                throw usageError('Experiment not found', { id: opts.id });
+            }
+            const client = new WhoopApiClient(globals.profile);
+            const recoveries = await fetchRecoveries(client, {
+                limit: 25,
+                all: true,
+                timeoutMs: globals.timeoutMs,
+            });
+            const byDate = recoveries
+                .map((r) => ({ date: r.created_at?.slice(0, 10), score: r.score?.recovery_score }))
+                .filter((r) => Boolean(r.date) && typeof r.score === 'number');
+            const expStart = new Date(`${exp.startDate}T00:00:00Z`).getTime();
+            const expEnd = exp.endDate ? new Date(`${exp.endDate}T23:59:59Z`).getTime() : Date.now();
+            const baselineStart = expStart - baselineDays * 24 * 60 * 60 * 1000;
+            const baselineEnd = expStart - 1;
+            const baselineScores = byDate
+                .filter((r) => {
+                const t = new Date(`${r.date}T12:00:00Z`).getTime();
+                return t >= baselineStart && t <= baselineEnd;
+            })
+                .map((r) => r.score);
+            const experimentScores = byDate
+                .filter((r) => {
+                const t = new Date(`${r.date}T12:00:00Z`).getTime();
+                return t >= expStart && t <= expEnd;
+            })
+                .map((r) => r.score);
+            const baselineAvg = avg(baselineScores);
+            const experimentAvg = avg(experimentScores);
+            const delta = baselineAvg !== null && experimentAvg !== null ? experimentAvg - baselineAvg : null;
+            printData(this, {
+                experiment: exp,
+                baselineDays,
+                baseline: {
+                    samples: baselineScores.length,
+                    recoveryAvg: round(baselineAvg, 1),
+                },
+                period: {
+                    samples: experimentScores.length,
+                    recoveryAvg: round(experimentAvg, 1),
+                },
+                deltaRecovery: round(delta, 1),
+            });
+        }
+        catch (err) {
+            printError(this, err);
+        }
+    });
+};

package/dist/commands/health.js

@@ -0,0 +1,136 @@
+import { WhoopApiClient } from '../http/client.js';
+import { fetchRecoveries, fetchSleeps } from '../http/whoop-data.js';
+import { avg, round } from '../util/metrics.js';
+import { parseDateRange, parseMaybeNumber } from '../util/time.js';
+import { getGlobalOptions, printData, printError } from './context.js';
+export const registerHealthCommands = (program) => {
+    const health = program.command('health').description('Health flags and trend views');
+    health
+        .command('flags')
+        .description('Detect likely recovery stress flags from recent baseline deltas')
+        .option('--days <n>', 'lookback days', '14')
+        .action(async function flagsAction(opts) {
+        try {
+            const globals = getGlobalOptions(this);
+            const client = new WhoopApiClient(globals.profile);
+            const days = parseMaybeNumber(opts.days) ?? 14;
+            const [recoveries, sleeps] = await Promise.all([
+                fetchRecoveries(client, {
+                    ...parseDateRange({ days }),
+                    limit: 25,
+                    all: true,
+                    timeoutMs: globals.timeoutMs,
+                }),
+                fetchSleeps(client, {
+                    ...parseDateRange({ days }),
+                    limit: 25,
+                    all: true,
+                    timeoutMs: globals.timeoutMs,
+                }),
+            ]);
+            const latestRecovery = recoveries[0];
+            const baseline = recoveries.slice(1);
+            const baselineHrv = avg(baseline.map((r) => r.score?.hrv_rmssd_milli));
+            const baselineRhr = avg(baseline.map((r) => r.score?.resting_heart_rate));
+            const baselineRecovery = avg(baseline.map((r) => r.score?.recovery_score));
+            const flags = [];
+            if (latestRecovery?.score?.recovery_score !== undefined && latestRecovery.score.recovery_score < 34) {
+                flags.push({
+                    code: 'LOW_RECOVERY',
+                    message: 'Recovery score is in red zone (<34).',
+                    severity: 'high',
+                });
+            }
+            if (baselineHrv &&
+                latestRecovery?.score?.hrv_rmssd_milli !== undefined &&
+                latestRecovery.score.hrv_rmssd_milli < baselineHrv * 0.8) {
+                flags.push({
+                    code: 'HRV_DROP',
+                    message: 'HRV is >20% below trailing baseline.',
+                    severity: 'med',
+                });
+            }
+            if (baselineRhr !== null &&
+                baselineRhr !== undefined &&
+                latestRecovery?.score?.resting_heart_rate !== undefined &&
+                latestRecovery.score.resting_heart_rate > baselineRhr + 5) {
+                flags.push({
+                    code: 'RHR_ELEVATION',
+                    message: 'Resting heart rate is elevated >5 bpm over baseline.',
+                    severity: 'med',
+                });
+            }
+            const latestSleep = sleeps[0];
+            if (latestSleep?.score?.sleep_performance_percentage !== undefined &&
+                latestSleep.score.sleep_performance_percentage < 70) {
+                flags.push({
+                    code: 'LOW_SLEEP_PERFORMANCE',
+                    message: 'Sleep performance is below 70%.',
+                    severity: 'med',
+                });
+            }
+            printData(this, {
+                windowDays: days,
+                latest: {
+                    recoveryScore: latestRecovery?.score?.recovery_score ?? null,
+                    hrv: latestRecovery?.score?.hrv_rmssd_milli ?? null,
+                    rhr: latestRecovery?.score?.resting_heart_rate ?? null,
+                    sleepPerformance: latestSleep?.score?.sleep_performance_percentage ?? null,
+                },
+                baseline: {
+                    recoveryScoreAvg: round(baselineRecovery, 1),
+                    hrvAvg: round(baselineHrv, 2),
+                    rhrAvg: round(baselineRhr, 1),
+                },
+                flags,
+            });
+        }
+        catch (err) {
+            printError(this, err);
+        }
+    });
+    health
+        .command('trend')
+        .description('Trend summary for recovery and sleep metrics')
+        .option('--days <n>', 'lookback days', '30')
+        .action(async function trendAction(opts) {
+        try {
+            const globals = getGlobalOptions(this);
+            const client = new WhoopApiClient(globals.profile);
+            const days = parseMaybeNumber(opts.days) ?? 30;
+            const range = parseDateRange({ days });
+            const [recoveries, sleeps] = await Promise.all([
+                fetchRecoveries(client, {
+                    ...range,
+                    limit: 25,
+                    all: true,
+                    timeoutMs: globals.timeoutMs,
+                }),
+                fetchSleeps(client, {
+                    ...range,
+                    limit: 25,
+                    all: true,
+                    timeoutMs: globals.timeoutMs,
+                }),
+            ]);
+            printData(this, {
+                windowDays: days,
+                recovery: {
+                    records: recoveries.length,
+                    recoveryScoreAvg: round(avg(recoveries.map((r) => r.score?.recovery_score)), 1),
+                    hrvAvg: round(avg(recoveries.map((r) => r.score?.hrv_rmssd_milli)), 2),
+                    rhrAvg: round(avg(recoveries.map((r) => r.score?.resting_heart_rate)), 1),
+                },
+                sleep: {
+                    records: sleeps.length,
+                    sleepPerformanceAvg: round(avg(sleeps.map((s) => s.score?.sleep_performance_percentage)), 1),
+                    sleepConsistencyAvg: round(avg(sleeps.map((s) => s.score?.sleep_consistency_percentage)), 1),
+                    sleepEfficiencyAvg: round(avg(sleeps.map((s) => s.score?.sleep_efficiency_percentage)), 1),
+                },
+            });
+        }
+        catch (err) {
+            printError(this, err);
+        }
+    });
+};

package/dist/commands/openclaw.js

@@ -0,0 +1,49 @@
+import { copyFile, mkdir, access } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { getGlobalOptions, printData, printError } from './context.js';
+import { usageError } from '../http/errors.js';
+const defaultOpenclawHome = () => join(homedir(), '.openclaw');
+const canRead = async (path) => {
+    try {
+        await access(path, constants.R_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+export const registerOpenClawCommands = (program) => {
+    const openclaw = program.command('openclaw').description('OpenClaw helper commands');
+    openclaw
+        .command('install-skill')
+        .description('Install bundled whoop-cli OpenClaw skill into ~/.openclaw/workspace/skills/whoop-cli')
+        .option('--openclaw-home <path>', 'override OpenClaw home directory', defaultOpenclawHome())
+        .option('--force', 'overwrite existing SKILL.md if present', false)
+        .action(async function installSkillAction(opts) {
+        try {
+            getGlobalOptions(this);
+            const openclawHome = String(opts.openclawHome ?? defaultOpenclawHome());
+            const targetDir = join(openclawHome, 'workspace', 'skills', 'whoop-cli');
+            const targetFile = join(targetDir, 'SKILL.md');
+            const sourceFile = new URL('../../openclaw-skill/SKILL.md', import.meta.url);
+            const exists = await canRead(targetFile);
+            if (exists && !opts.force) {
+                throw usageError('Target skill file already exists. Re-run with --force to overwrite.', {
+                    targetFile,
+                });
+            }
+            await mkdir(targetDir, { recursive: true });
+            await copyFile(sourceFile, targetFile);
+            printData(this, {
+                installed: true,
+                targetFile,
+                force: Boolean(opts.force),
+            });
+        }
+        catch (err) {
+            printError(this, err);
+        }
+    });
+};