@warmio/mcp 5.0.1 → 7.0.0

package/dist/warm-api-client.js

@@ -1,13 +1,10 @@
-import { getWarmApiKeyPath, readConfigFile } from './config-paths.js';
-const DEFAULT_API_URL = process.env.WARM_API_URL || 'https://warm.io';
+import { getWarmApiKeyPath, readConfigFile, } from './config-paths.js';
+const DEFAULT_API_URL = process.env.WARM_API_URL || 'https://app.warm.io';
 const DEFAULT_REQUEST_TIMEOUT_MS = (() => {
     const raw = Number(process.env.WARM_API_TIMEOUT_MS || 10_000);
     return Number.isFinite(raw) && raw > 0 ? raw : 10_000;
 })();
-let cachedApiKey;
-function roundMoney(value) {
-    return Math.round(value * 100) / 100;
-}
+const cachedApiKeys = new Map();
 function getRequestSignal(timeoutMs) {
     if (typeof AbortSignal.timeout === 'function') {
         return AbortSignal.timeout(timeoutMs);
@@ -17,157 +14,61 @@ function getRequestSignal(timeoutMs) {
     timer.unref?.();
     return controller.signal;
 }
-function normalizeAccountType(rawType) {
-    switch (rawType) {
-        case 'depository':
-        case 'credit':
-        case 'loan':
-        case 'investment':
-            return rawType;
-        default:
-            return 'other';
-    }
-}
-function normalizeStateAccount(account) {
-    return {
-        available_balance: account.available_balance == null ? null : roundMoney(account.available_balance),
-        balance: roundMoney(account.current_balance ?? 0),
-        institution: account.institution_name ?? null,
-        mask: account.mask ?? null,
-        name: account.name || 'Unknown Account',
-        subtype: account.subtype ?? null,
-        type: normalizeAccountType(account.type),
-    };
-}
-function normalizeAccounts(accounts) {
-    return {
-        accounts: accounts.map((account) => {
-            const normalized = normalizeStateAccount(account);
-            return {
-                balance: normalized.balance,
-                institution: normalized.institution,
-                mask: normalized.mask,
-                name: normalized.name,
-                subtype: normalized.subtype,
-                type: normalized.type,
-            };
-        }),
-    };
-}
-function normalizeFinancialState(input) {
-    const latestSnapshot = input.snapshots?.[0];
-    const categorySpending = latestSnapshot?.spending_by_category ?? [];
-    return {
-        budgets: (input.budgets || []).map((budget) => ({
-            amount: budget.amount ?? 0,
-            name: budget.name || '',
-            percent_used: budget.percent_used ?? 0,
-            period: budget.period || '',
-            remaining: budget.remaining ?? 0,
-            spent: budget.spent ?? 0,
-            status: budget.status ?? null,
-        })),
-        category_spending: categorySpending.map((item) => ({
-            amount: roundMoney(item?.amount ?? item?.total ?? 0),
-            category: item?.category || 'Uncategorized',
-        })),
-        generated_at: input.generatedAt,
-        goals: (input.goals || []).map((goal) => ({
-            category: goal.category ?? null,
-            current: goal.current ?? 0,
-            monthly_contribution_needed: goal.monthly_contribution_needed ?? null,
-            name: goal.name || '',
-            progress_percent: goal.progress_percent ?? 0,
-            status: goal.status ?? null,
-            target: goal.target ?? 0,
-            target_date: goal.target_date ?? null,
-        })),
-        health: {
-            data_completeness: input.health?.data_completeness ?? null,
-            label: input.health?.label ?? null,
-            message: input.health?.message ?? null,
-            pillars: input.health?.pillars
-                ? {
-                    borrow: input.health.pillars.borrow ?? null,
-                    build: input.health.pillars.build ?? null,
-                    save: input.health.pillars.save ?? null,
-                    spend: input.health.pillars.spend ?? null,
-                }
-                : null,
-            score: input.health?.score ?? null,
-        },
-        holdings: (input.holdings || []).map((holding) => ({
-            account_id: holding.account_id || '',
-            cost_basis: holding.cost_basis ?? null,
-            quantity: roundMoney(holding.quantity ?? 0),
-            security_name: holding.security_name ?? null,
-            symbol: holding.symbol ?? null,
-            type: holding.type ?? null,
-            value: holding.value == null ? null : roundMoney(holding.value),
-        })),
-        liabilities: (input.liabilities || []).map((liability) => ({
-            account_id: liability.account_id || '',
-            apr_percentage: liability.apr_percentage ?? null,
-            balance: liability.balance == null ? null : roundMoney(liability.balance),
-            is_overdue: liability.is_overdue ?? null,
-            minimum_payment: liability.minimum_payment == null ? null : roundMoney(liability.minimum_payment),
-            next_payment_due_date: liability.next_payment_due_date ?? null,
-            type: liability.type || 'unknown',
-        })),
-        recurring: (input.recurring || []).map((stream) => ({
-            active: stream.active === true || stream.is_active === true,
-            amount: roundMoney(stream.amount ?? stream.last_amount ?? stream.average_amount ?? 0),
-            frequency: stream.frequency || '',
-            merchant: stream.merchant || stream.merchant_name || stream.description || '',
-            next_date: stream.next_date ?? null,
-            type: stream.type ?? stream.stream_type ?? null,
-        })),
-        snapshots: (input.snapshots || [])
-            .map((snapshot) => ({
-            date: snapshot.date || snapshot.snapshot_date || snapshot.period_end || null,
-            net_worth: snapshot.net_worth ?? 0,
-            total_assets: snapshot.total_assets ?? 0,
-            total_liabilities: snapshot.total_liabilities ?? 0,
-        }))
-            .filter((snapshot) => typeof snapshot.date === 'string')
-            .map((snapshot) => ({
-            date: snapshot.date,
-            net_worth: roundMoney(snapshot.net_worth),
-            total_assets: roundMoney(snapshot.total_assets),
-            total_liabilities: roundMoney(snapshot.total_liabilities),
-        })),
-    };
-}
 function createWarmApiClientConfig(options) {
     return {
+        audience: options.audience || 'context',
         apiKeyResolver: options.apiKeyResolver,
         apiUrl: options.apiUrl || DEFAULT_API_URL,
         fetchImplementation: options.fetchImplementation || fetch,
         requestTimeoutMs: options.requestTimeoutMs || DEFAULT_REQUEST_TIMEOUT_MS,
     };
 }
-export function getConfiguredApiKey() {
-    if (cachedApiKey !== undefined) {
-        return cachedApiKey;
+export function getConfiguredApiKey(audience = 'context') {
+    if (cachedApiKeys.has(audience)) {
+        return cachedApiKeys.get(audience) ?? null;
     }
-    if (process.env.WARM_API_KEY?.trim()) {
-        cachedApiKey = process.env.WARM_API_KEY.trim();
-        return cachedApiKey;
-    }
-    cachedApiKey = readConfigFile(getWarmApiKeyPath());
-    return cachedApiKey;
+    const environmentKey = audience === 'automation' ? 'WARM_AUTOMATION_API_KEY' : 'WARM_CONTEXT_API_KEY';
+    const apiKey = process.env[environmentKey]?.trim() || readConfigFile(getWarmApiKeyPath(audience));
+    cachedApiKeys.set(audience, apiKey);
+    return apiKey;
 }
 export function resetConfiguredApiKeyCache() {
-    cachedApiKey = undefined;
+    cachedApiKeys.clear();
+}
+export class WarmApiError extends Error {
+    body;
+    headers;
+    status;
+    constructor(message, response) {
+        super(message);
+        this.name = 'WarmApiError';
+        this.body = response.body;
+        this.headers = response.headers;
+        this.status = response.status;
+    }
+}
+function toWarmApiError(response) {
+    const errorMessages = {
+        401: 'Invalid or expired API key. Regenerate at https://warm.io/settings',
+        403: 'API access is available on paid plans only. Upgrade at https://warm.io/settings',
+        429: 'Rate limit exceeded. Try again in a few minutes.',
+    };
+    if (errorMessages[response.status]) {
+        return new WarmApiError(errorMessages[response.status], response);
+    }
+    const detail = typeof response.body === 'object' && response.body !== null && 'error' in response.body
+        ? String(response.body.error)
+        : `HTTP ${response.status}`;
+    return new WarmApiError(detail, response);
 }
-export async function apiRequest(endpoint, params = {}, options = {}) {
+async function requestWarmApi(request, options) {
     const requestOptions = createWarmApiClientConfig(options);
-    const apiKey = requestOptions.apiKeyResolver?.() ?? getConfiguredApiKey();
+    const apiKey = requestOptions.apiKeyResolver?.() ?? getConfiguredApiKey(requestOptions.audience);
     if (!apiKey) {
-        throw new Error('WARM_API_KEY not set. Run "npx @warmio/mcp" to configure or set WARM_API_KEY.');
+        throw new Error(`No ${requestOptions.audience} API key configured. Run "npx @warmio/mcp install --mode ${requestOptions.audience}" or set ${requestOptions.audience === 'automation' ? 'WARM_AUTOMATION_API_KEY' : 'WARM_CONTEXT_API_KEY'}.`);
     }
-    const url = new URL(endpoint, requestOptions.apiUrl);
-    Object.entries(params).forEach(([key, value]) => {
+    const url = new URL(request.endpoint, requestOptions.apiUrl);
+    Object.entries(request.query || {}).forEach(([key, value]) => {
         if (value) {
             url.searchParams.append(key, value);
         }
@@ -175,10 +76,13 @@ export async function apiRequest(endpoint, params = {}, options = {}) {
     let response;
     try {
         response = await requestOptions.fetchImplementation(url.toString(), {
+            ...(request.method && request.method !== 'GET' ? { method: request.method } : {}),
             headers: {
                 Accept: 'application/json',
                 Authorization: `Bearer ${apiKey}`,
+                ...(request.body ? { 'Content-Type': 'application/json' } : {}),
             },
+            ...(request.body ? { body: JSON.stringify(request.body) } : {}),
             signal: getRequestSignal(requestOptions.requestTimeoutMs),
         });
     }
@@ -191,107 +95,91 @@ export async function apiRequest(endpoint, params = {}, options = {}) {
         }
         throw error;
     }
-    if (!response.ok) {
-        const errorMessages = {
-            401: 'Invalid or expired API key. Regenerate at https://warm.io/settings',
-            403: 'API access is available on paid plans only. Upgrade at https://warm.io/settings',
-            429: 'Rate limit exceeded. Try again in a few minutes.',
-        };
-        if (errorMessages[response.status]) {
-            throw new Error(errorMessages[response.status]);
-        }
-        let detail = `HTTP ${response.status}`;
+    const text = await response.text();
+    let body = null;
+    if (text) {
         try {
-            const body = (await response.json());
-            if (body?.error) {
-                detail = body.error;
-            }
+            body = JSON.parse(text);
         }
         catch {
-            // Fall back to the HTTP status when the error body is not JSON.
+            body = text;
         }
-        throw new Error(detail);
     }
-    return (await response.json());
+    return {
+        body: body,
+        headers: Object.fromEntries(response.headers.entries()),
+        status: response.status,
+    };
+}
+async function requestSuccessfulJson(request, options) {
+    const response = await requestWarmApi(request, options);
+    if (response.status >= 400) {
+        throw toWarmApiError(response);
+    }
+    return response.body;
 }
 export function createWarmApiClient(options = {}) {
-    const getAccounts = async () => {
-        const response = await apiRequest('/api/export', { dataset: 'accounts' }, options);
-        return normalizeAccounts(response.accounts || []);
-    };
-    const getFinancialState = async () => {
-        const [snapshotsResponse, recurringResponse, budgetsResponse, goalsResponse, healthResponse, liabilitiesResponse, holdingsResponse,] = await Promise.all([
-            apiRequest('/api/export', { dataset: 'snapshots' }, options),
-            apiRequest('/api/export', { dataset: 'recurring' }, options),
-            apiRequest('/api/export', { dataset: 'budgets' }, options),
-            apiRequest('/api/export', { dataset: 'goals' }, options),
-            apiRequest('/api/export', { dataset: 'health' }, options),
-            apiRequest('/api/export', { dataset: 'liabilities' }, options),
-            apiRequest('/api/export', { dataset: 'holdings' }, options),
-        ]);
-        const generatedAt = holdingsResponse.generated_at ||
-            liabilitiesResponse.generated_at ||
-            healthResponse.generated_at ||
-            goalsResponse.generated_at ||
-            budgetsResponse.generated_at ||
-            recurringResponse.generated_at ||
-            snapshotsResponse.generated_at ||
-            new Date().toISOString();
-        return normalizeFinancialState({
-            budgets: budgetsResponse.budgets,
-            generatedAt,
-            goals: goalsResponse.goals,
-            health: healthResponse,
-            holdings: holdingsResponse.holdings,
-            liabilities: liabilitiesResponse.liabilities,
-            recurring: recurringResponse.recurring || recurringResponse.recurring_transactions,
-            snapshots: snapshotsResponse.snapshots,
-        });
-    };
+    const getFinancialContext = async () => await requestSuccessfulJson({ endpoint: '/api/financial-context' }, options);
+    const getFinancialContextMeta = async () => await requestSuccessfulJson({ endpoint: '/api/financial-context/meta' }, options);
     const getTransactions = async (input) => {
-        const response = await apiRequest('/api/export', {
-            cursor: input.cursor,
-            dataset: 'transactions',
-            last_knowledge: input.last_knowledge,
-            limit: String(input.limit),
-            search: input.search,
-        }, options);
-        const nextCursor = response.pagination?.next_cursor ?? null;
-        return {
-            generated_at: response.generated_at ?? null,
-            next_knowledge: response.next_knowledge ?? null,
-            pagination: {
-                has_more: nextCursor !== null,
-                limit: response.pagination?.limit ?? input.limit,
-                next_cursor: nextCursor,
-            },
-            txns: (response.transactions || []).map((transaction) => ({
-                amount: roundMoney(transaction.amount ?? 0),
-                category: transaction.primary_category ?? null,
-                date: transaction.date ?? null,
-                description: transaction.name ?? null,
-                detailed_category: transaction.detailed_category ?? null,
-                id: transaction.id ?? null,
-                merchant: transaction.merchant_name ?? null,
-            })),
-        };
+        const rawInput = input;
+        if (typeof rawInput.month === 'string' && rawInput.latest !== undefined) {
+            throw new Error('`month` and `latest` are mutually exclusive.');
+        }
+        if (typeof rawInput.month === 'string') {
+            return await requestSuccessfulJson({ endpoint: '/api/financial-context/transactions', query: { month: rawInput.month } }, options);
+        }
+        if (rawInput.latest === true) {
+            return await requestSuccessfulJson({ endpoint: '/api/financial-context/transactions', query: { latest: '1' } }, options);
+        }
+        throw new Error('Call getTransactions with `month` in YYYY-MM format or `latest: true`.');
     };
     const verifyKey = async () => {
-        const response = await apiRequest('/api/verify', {}, options);
+        const response = await requestSuccessfulJson({ endpoint: '/api/verify' }, options);
         return {
+            audience: response.audience,
             status: response.status || (response.valid ? 'ok' : 'invalid'),
             valid: response.valid === true,
         };
     };
+    const validateAudience = async () => {
+        const result = await verifyKey();
+        const expectedAudience = createWarmApiClientConfig(options).audience;
+        if (!result.valid || result.audience !== expectedAudience) {
+            const article = expectedAudience === 'automation' ? 'an' : 'a';
+            throw new Error(`This MCP mode requires ${article} ${expectedAudience} API key. Run "npx @warmio/mcp install --mode ${expectedAudience}" to configure a separate key.`);
+        }
+        return result;
+    };
+    const searchOperations = async (query) => await requestSuccessfulJson({ body: query ? { query } : {}, endpoint: '/api/automation/operations/search', method: 'POST' }, options);
+    const describeOperation = async (operationId, input) => await requestSuccessfulJson({
+        body: { operation_id: operationId, ...(input ? { input } : {}) },
+        endpoint: '/api/automation/operations/describe',
+        method: 'POST',
+    }, options);
+    const invokeOperation = async (operationId, input, approvalId) => await requestSuccessfulJson({
+        body: {
+            operation_id: operationId,
+            input: input ?? {},
+            ...(approvalId ? { approval_id: approvalId } : {}),
+        },
+        endpoint: '/api/automation/operations/invoke',
+        method: 'POST',
+    }, options);
     return {
-        getAccounts,
-        getFinancialState,
+        getFinancialContext,
+        getFinancialContextMeta,
         getTransactions,
+        searchOperations,
+        describeOperation,
+        invokeOperation,
+        validateAudience,
         verifyKey,
     };
 }
-export async function verifyWarmApiKey(apiKey) {
+export async function verifyWarmApiKey(apiKey, audience = 'context') {
     return createWarmApiClient({
+        audience,
         apiKeyResolver: () => apiKey,
     }).verifyKey();
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@warmio/mcp",
-  "version": "5.0.1",
-  "description": "Warm CLI and MCP server for personal financial data",
+  "version": "7.0.0",
+  "description": "Warm CLI and compact context or automation MCP server",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",