@daobrew/wellness-mcp 0.1.0

package/dist/src/index.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const tools_js_1 = require("./tools.js");
+const audio_js_1 = require("./audio.js");
+const client_js_1 = require("./client.js");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+// Load API config from file (env vars are unreliable — Claude Code may not pass them)
+const CONFIG_FILE = (0, path_1.join)((0, os_1.homedir)(), ".daobrew", "config.json");
+let fileConfig = {};
+if ((0, fs_1.existsSync)(CONFIG_FILE)) {
+    try {
+        fileConfig = JSON.parse((0, fs_1.readFileSync)(CONFIG_FILE, "utf-8"));
+    }
+    catch { }
+}
+const apiKey = process.env.DAOBREW_API_KEY || fileConfig.api_key;
+const apiBaseUrl = process.env.DAOBREW_API_URL || fileConfig.api_url;
+// Mock only when explicitly requested via env AND no API key available
+const isMock = process.env.DAOBREW_MOCK === "true" || !apiKey;
+const isDemo = process.argv.includes("--demo");
+if (!isMock && !apiKey) {
+    // This shouldn't happen since isMock=true when !apiKey, but just in case
+    console.error("No API key found. Add api_key to ~/.daobrew/config.json or set DAOBREW_API_KEY.");
+    process.exit(1);
+}
+const client = !isMock && apiKey
+    ? new client_js_1.DaoBrewClient({ apiKey, baseUrl: apiBaseUrl })
+    : undefined;
+const server = new index_js_1.Server({ name: "daobrew-wellness", version: "0.1.0" }, { capabilities: { tools: {}, prompts: {} } });
+server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
+    tools: tools_js_1.toolDefinitions,
+}));
+server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        const result = await (0, tools_js_1.handleToolCall)(name, args ?? {}, isMock, apiKey, isDemo, client);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+    catch (error) {
+        return {
+            content: [{ type: "text", text: JSON.stringify({ error: error.message }) }],
+            isError: true,
+        };
+    }
+});
+const PROMPTS = [
+    { name: "breathe", description: "Start a guided breathing session matched to your current stress pattern", arguments: [] },
+    { name: "stress", description: "Check your current biometric wellness state", arguments: [] },
+    { name: "stop", description: "Stop the currently playing breathing session", arguments: [] },
+];
+server.setRequestHandler(types_js_1.ListPromptsRequestSchema, async () => ({
+    prompts: PROMPTS,
+}));
+server.setRequestHandler(types_js_1.GetPromptRequestSchema, async (request) => {
+    const { name } = request.params;
+    switch (name) {
+        case "breathe":
+            return {
+                description: "Start a guided breathing session",
+                messages: [
+                    {
+                        role: "user",
+                        content: { type: "text", text: "I need a breathing break. Check my wellness state and start a session for my top stress pattern." },
+                    },
+                ],
+            };
+        case "stress":
+            return {
+                description: "Check wellness state",
+                messages: [
+                    {
+                        role: "user",
+                        content: { type: "text", text: "Check my current stress levels and biometric wellness state." },
+                    },
+                ],
+            };
+        case "stop":
+            return {
+                description: "Stop current session",
+                messages: [
+                    {
+                        role: "user",
+                        content: { type: "text", text: "Stop the current breathing session." },
+                    },
+                ],
+            };
+        default:
+            throw new Error(`Unknown prompt: ${name}`);
+    }
+});
+async function main() {
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+}
+function shutdown() {
+    (0, audio_js_1.stopPlayback)();
+    process.exit(0);
+}
+process.on("SIGTERM", shutdown);
+process.on("SIGINT", shutdown);
+main().catch(console.error);

package/dist/src/mock.d.ts

@@ -0,0 +1,8 @@
+import { WellnessState, ElementDetail, SessionStart, SessionResult, SessionHistoryEntry, Element } from "./types.js";
+export declare function mockWellnessState(isDemo?: boolean): WellnessState;
+export declare function mockElementDetail(element: Element): ElementDetail;
+export declare function mockStartSession(element: Element, tier?: string): SessionStart;
+export declare function mockSessionResult(sessionId: string): SessionResult;
+export declare function mockSessionHistory(days?: number): SessionHistoryEntry[];
+/** Reset wellnessCallCount — for tests only. */
+export declare function _resetWellnessCallCount(): void;

package/dist/src/mock.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockWellnessState = mockWellnessState;
+exports.mockElementDetail = mockElementDetail;
+exports.mockStartSession = mockStartSession;
+exports.mockSessionResult = mockSessionResult;
+exports.mockSessionHistory = mockSessionHistory;
+exports._resetWellnessCallCount = _resetWellnessCallCount;
+const types_js_1 = require("./types.js");
+let wellnessCallCount = 0;
+function getQuadrant(yin, yang) {
+    if (yin >= 50 && yang >= 50)
+        return "peak";
+    if (yin < 50 && yang >= 50)
+        return "pushing_it";
+    if (yin >= 50 && yang < 50)
+        return "recharging";
+    return "burnout";
+}
+const QUADRANT_LABELS = {
+    peak: "In Flow",
+    pushing_it: "Pushing It",
+    recharging: "Recharging",
+    burnout: "Running on Empty",
+};
+const QUADRANT_DESCRIPTIONS = {
+    peak: "Your energy is in harmony. Maintain this state.",
+    pushing_it: "Active but under-recovered. Consider rest soon.",
+    recharging: "Well-recovered but low activity. Your body is conserving energy.",
+    burnout: "Under-recovered and inactive. Gentle movement and rest recommended.",
+};
+function yinStateLabel(score) {
+    if (score >= 80)
+        return "Fully Charged";
+    if (score >= 60)
+        return "Steady";
+    if (score >= 40)
+        return "Thinning";
+    if (score >= 20)
+        return "Running Low";
+    return "Empty";
+}
+function yangStateLabel(score) {
+    if (score >= 80)
+        return "Fired Up";
+    if (score >= 60)
+        return "Moving";
+    if (score >= 40)
+        return "Coasting";
+    if (score >= 20)
+        return "Sluggish";
+    return "Stalled";
+}
+function rand(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function timeAwareBias() {
+    const hour = new Date().getHours();
+    if (hour >= 22 || hour < 6)
+        return { yinBias: -15, yangBias: -20, fireBias: 20, earthBias: 0 };
+    if (hour >= 13 && hour < 15)
+        return { yinBias: -10, yangBias: -10, fireBias: 0, earthBias: 15 };
+    if (hour >= 9 && hour < 12)
+        return { yinBias: 10, yangBias: 15, fireBias: 0, earthBias: -10 };
+    return { yinBias: 0, yangBias: 0, fireBias: 0, earthBias: 0 };
+}
+function mockWellnessState(isDemo = false) {
+    wellnessCallCount++;
+    const bias = timeAwareBias();
+    // First call always stressed (good first impression). Demo mode = always stressed.
+    const stressed = isDemo || wellnessCallCount === 1 || wellnessCallCount % 3 === 0;
+    const yin = Math.max(0, Math.min(100, rand(stressed ? 15 : 40, stressed ? 45 : 85) + bias.yinBias));
+    const yang = Math.max(0, Math.min(100, rand(stressed ? 50 : 35, stressed ? 80 : 90) + bias.yangBias));
+    const quadrant = getQuadrant(yin, yang);
+    const scores = {
+        wood: Math.max(0, Math.min(100, rand(stressed ? 40 : 10, stressed ? 80 : 45))),
+        fire: Math.max(0, Math.min(100, rand(stressed ? 30 : 5, stressed ? 70 : 40) + bias.fireBias)),
+        earth: Math.max(0, Math.min(100, rand(stressed ? 25 : 10, stressed ? 60 : 40) + bias.earthBias)),
+        metal: Math.max(0, Math.min(100, rand(5, stressed ? 55 : 35))),
+        water: Math.max(0, Math.min(100, rand(5, stressed ? 45 : 25))),
+    };
+    // On first call or demo, ensure at least one element is active (score >= 50)
+    if (stressed) {
+        const topKey = Object.entries(scores)
+            .sort((a, b) => b[1] - a[1])[0][0];
+        if (scores[topKey] < 50)
+            scores[topKey] = rand(55, 75);
+    }
+    const active = Object.entries(scores)
+        .filter(([, s]) => s >= 50)
+        .map(([e]) => e);
+    const topElement = Object.entries(scores)
+        .sort((a, b) => b[1] - a[1])[0];
+    return {
+        yin, yang, quadrant,
+        quadrant_label: QUADRANT_LABELS[quadrant],
+        quadrant_description: QUADRANT_DESCRIPTIONS[quadrant],
+        yin_label: yinStateLabel(yin),
+        yang_label: yangStateLabel(yang),
+        active_elements: active,
+        element_scores: scores,
+        top_signal: active.length > 0
+            ? `${types_js_1.ELEMENT_LABELS[topElement[0]]} Qi · ${types_js_1.ELEMENT_SHORT_SUMMARIES[topElement[0]]} — ${types_js_1.ELEMENT_ACTIVATION_REASONS[topElement[0]]}`
+            : `All biometrics within normal range`,
+        recommendation: active.length > 0
+            ? `${types_js_1.ELEMENT_LABELS[topElement[0]]} Qi · ${types_js_1.ELEMENT_SHORT_SUMMARIES[topElement[0]]}, try deep breathing.`
+            : `Your energy is in harmony. Maintain this state.`,
+        data_tier: "tier_2",
+        last_updated: new Date().toISOString(),
+    };
+}
+function mockElementDetail(element) {
+    const score = rand(40, 85);
+    const mockHrv = rand(18, 40);
+    const mockBaseline = rand(45, 65);
+    return {
+        element,
+        label: `${types_js_1.ELEMENT_LABELS[element]} · ${types_js_1.ELEMENT_ORGANS[element]}`,
+        score,
+        activated: score >= 50,
+        headline: types_js_1.ELEMENT_ACTIVATION_REASONS[element],
+        evidence: [
+            { signal: "HRV", value: `${mockHrv}ms`, baseline: `${mockBaseline}ms`, direction: "below", weight: 0.35 },
+            { signal: "Heart Rate", value: `${rand(72, 92)}bpm`, baseline: `${rand(62, 72)}bpm`, direction: "above", weight: 0.25 },
+        ],
+        why_this_practice: types_js_1.ELEMENT_TASK_REASONS[element],
+        intervention: {
+            type: "breathing", genre: types_js_1.ELEMENT_GENRES[element],
+            duration_seconds: 300, breathing_rate_bpm: 6.0,
+        },
+    };
+}
+const activeSessions = new Map();
+function mockStartSession(element, tier = "audio") {
+    const sessionId = `sess_${Date.now().toString(36)}`;
+    activeSessions.set(sessionId, { element, tier, startTime: Date.now() });
+    return {
+        session_id: sessionId, status: "started",
+        tier: tier, element,
+        genre: types_js_1.ELEMENT_GENRES[element], duration_seconds: 300, breathing_rate_bpm: 6.0,
+        instruction: `${types_js_1.ELEMENT_LABELS[element]} Qi · ${types_js_1.ELEMENT_SHORT_SUMMARIES[element]}, try deep breathing. Inhale as music rises, exhale as it fades. Session runs 5 minutes.`,
+    };
+}
+function mockSessionResult(sessionId) {
+    const hrvBefore = rand(20, 40);
+    const improvement = rand(20, 60);
+    const hrvAfter = Math.round(hrvBefore * (1 + improvement / 100));
+    const hrBefore = rand(72, 92);
+    const hrAfter = hrBefore - rand(5, 15);
+    return {
+        session_id: sessionId, completed: true, duration_seconds: 300,
+        hrv_before: hrvBefore, hrv_after: hrvAfter, hrv_change_pct: improvement,
+        hr_before: hrBefore, hr_after: hrAfter,
+        summary: `[Mock] Simulated — connect a wearable for real data. HRV improved ${improvement}%, resting HR dropped ${hrBefore - hrAfter}bpm. ${types_js_1.ELEMENT_LABELS[activeSessions.get(sessionId)?.element ?? "wood"]} Qi rebalancing — score ${rand(60, 75)} → ${rand(30, 48)}.`,
+    };
+}
+function mockSessionHistory(days = 7) {
+    const entries = [];
+    const elements = ["wood", "fire", "earth", "metal", "water"];
+    const count = rand(3, Math.min(days * 2, 14));
+    for (let i = 0; i < count; i++) {
+        const daysAgo = rand(0, days - 1);
+        const d = new Date();
+        d.setDate(d.getDate() - daysAgo);
+        entries.push({
+            session_id: `sess_hist_${i}`, timestamp: d.toISOString(),
+            element: elements[rand(0, 4)], tier: "audio",
+            duration_seconds: 300, hrv_change_pct: rand(10, 55),
+        });
+    }
+    return entries.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+}
+/** Reset wellnessCallCount — for tests only. */
+function _resetWellnessCallCount() {
+    wellnessCallCount = 0;
+}

package/dist/src/preferences.d.ts

@@ -0,0 +1,13 @@
+export interface Preferences {
+    ambient_optin: boolean;
+    ambient_optin_date: string | null;
+    preferred_volume: number;
+    cooldown_minutes: number;
+    disabled: boolean;
+    headphones_trusted: boolean;
+    session_count: number;
+    voiceover: boolean;
+}
+export declare function load(): Preferences;
+export declare function save(prefs: Partial<Preferences>): void;
+export declare function incrementSessionCount(): number;

package/dist/src/preferences.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.load = load;
+exports.save = save;
+exports.incrementSessionCount = incrementSessionCount;
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const PREFS_DIR = (0, path_1.join)((0, os_1.homedir)(), ".daobrew");
+const PREFS_FILE = (0, path_1.join)(PREFS_DIR, "prefs.json");
+const DEFAULTS = {
+    ambient_optin: false,
+    ambient_optin_date: null,
+    preferred_volume: 0.3,
+    cooldown_minutes: 30,
+    disabled: false,
+    headphones_trusted: false,
+    session_count: 0,
+    voiceover: true,
+};
+function load() {
+    if (!(0, fs_1.existsSync)(PREFS_FILE))
+        return { ...DEFAULTS };
+    try {
+        return { ...DEFAULTS, ...JSON.parse((0, fs_1.readFileSync)(PREFS_FILE, "utf-8")) };
+    }
+    catch {
+        return { ...DEFAULTS };
+    }
+}
+function save(prefs) {
+    if (!(0, fs_1.existsSync)(PREFS_DIR))
+        (0, fs_1.mkdirSync)(PREFS_DIR, { recursive: true });
+    const current = load();
+    const updated = { ...current, ...prefs };
+    (0, fs_1.writeFileSync)(PREFS_FILE, JSON.stringify(updated, null, 2));
+}
+function incrementSessionCount() {
+    const prefs = load();
+    const count = prefs.session_count + 1;
+    const updates = { session_count: count };
+    if (count >= 3 && prefs.voiceover) {
+        updates.voiceover = false;
+    }
+    save(updates);
+    return count;
+}

package/dist/src/session.d.ts

@@ -0,0 +1,15 @@
+import { Element } from "./types.js";
+export interface ActiveSession {
+    sessionId: string;
+    pid: number;
+    element: Element;
+    genre: string;
+    duration: number;
+    startTime: number;
+    mode: "ambient" | "ondemand";
+}
+export declare function startSession(session: ActiveSession): void;
+export declare function getActiveSession(): ActiveSession | null;
+export declare function clearSession(): ActiveSession | null;
+export declare function isSessionRunning(): boolean;
+export declare function durationPlayed(): number | null;

package/dist/src/session.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startSession = startSession;
+exports.getActiveSession = getActiveSession;
+exports.clearSession = clearSession;
+exports.isSessionRunning = isSessionRunning;
+exports.durationPlayed = durationPlayed;
+let activeSession = null;
+function startSession(session) {
+    activeSession = session;
+}
+function getActiveSession() {
+    return activeSession;
+}
+function clearSession() {
+    const prev = activeSession;
+    activeSession = null;
+    return prev;
+}
+function isSessionRunning() {
+    if (!activeSession)
+        return false;
+    // Verify the audio process is still alive (skip for pid <= 0, e.g. text tier)
+    if (activeSession.pid > 0) {
+        try {
+            process.kill(activeSession.pid, 0);
+        }
+        catch {
+            // Process is dead — clear stale session
+            activeSession = null;
+            return false;
+        }
+    }
+    return true;
+}
+function durationPlayed() {
+    if (!activeSession)
+        return null;
+    return Math.round((Date.now() - activeSession.startTime) / 1000);
+}

package/dist/src/setup-cli.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require("./setup.js").default();

package/dist/src/setup.d.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+/**
+ * DaoBrew Wellness MCP — Interactive Setup
+ *
+ * Usage:
+ *   npx @daobrew/wellness-mcp setup
+ *   daobrew-wellness-mcp setup
+ *
+ * Does:
+ *   1. Creates ~/.daobrew/config.json (API key, backend URL)
+ *   2. Creates ~/.daobrew/prefs.json (ambient opt-in, volume, etc.)
+ *   3. Installs SKILL.md to ~/.claude/skills/daobrew-wellness/
+ *   4. Adds MCP server to .mcp.json in current directory
+ *   5. Registers ambient hook in ~/.claude/settings.json (if ambient enabled)
+ *   6. Copies ambient hook script to ~/.daobrew/ambient-hook.sh
+ */
+export default function run(): void;