@warmio/mcp 4.2.2 → 4.3.2

package/dist/stdio.js

@@ -0,0 +1,200 @@
+import process from 'node:process';
+const CONTENT_LENGTH_HEADER = 'content-length:';
+export class AdaptiveStdioTransport {
+    stdin;
+    stdout;
+    onclose;
+    onerror;
+    onmessage;
+    buffer = Buffer.alloc(0);
+    clientFraming = null;
+    closed = false;
+    started = false;
+    constructor(stdin = process.stdin, stdout = process.stdout) {
+        this.stdin = stdin;
+        this.stdout = stdout;
+    }
+    async start() {
+        if (this.started) {
+            throw new Error('AdaptiveStdioTransport already started');
+        }
+        this.started = true;
+        this.stdin.on('data', this.handleData);
+        this.stdin.on('error', this.handleError);
+        this.stdin.on('end', this.handleEnd);
+        this.stdin.resume();
+    }
+    async close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        this.stdin.off('data', this.handleData);
+        this.stdin.off('error', this.handleError);
+        this.stdin.off('end', this.handleEnd);
+        this.stdin.pause();
+        this.buffer = Buffer.alloc(0);
+        this.onclose?.();
+    }
+    async send(message, _options) {
+        const json = JSON.stringify(message);
+        const framing = this.clientFraming ?? 'content-length';
+        const payload = framing === 'jsonl'
+            ? `${json}\n`
+            : `Content-Length: ${Buffer.byteLength(json, 'utf8')}\r\n\r\n${json}`;
+        await new Promise((resolve) => {
+            if (this.stdout.write(payload)) {
+                resolve();
+                return;
+            }
+            this.stdout.once('drain', resolve);
+        });
+    }
+    handleData = (chunk) => {
+        const incoming = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        this.buffer = this.buffer.length === 0 ? incoming : Buffer.concat([this.buffer, incoming]);
+        this.processBuffer();
+    };
+    handleError = (error) => {
+        this.onerror?.(error);
+    };
+    handleEnd = () => {
+        void this.close();
+    };
+    processBuffer() {
+        while (true) {
+            try {
+                this.trimLeadingNewlines();
+                const parsed = this.readMessage();
+                if (parsed === null) {
+                    return;
+                }
+                this.clientFraming ??= parsed.framing;
+                this.onmessage?.(parsed.message);
+            }
+            catch (error) {
+                this.onerror?.(error instanceof Error ? error : new Error(String(error)));
+                this.buffer = Buffer.alloc(0);
+                return;
+            }
+        }
+    }
+    trimLeadingNewlines() {
+        while (this.buffer.length > 0) {
+            if (this.buffer[0] === 0x0a) {
+                this.buffer = this.buffer.subarray(1);
+                continue;
+            }
+            if (this.buffer.length > 1 && this.buffer[0] === 0x0d && this.buffer[1] === 0x0a) {
+                this.buffer = this.buffer.subarray(2);
+                continue;
+            }
+            return;
+        }
+    }
+    readMessage() {
+        const framing = this.clientFraming ?? this.detectFraming();
+        if (framing === null) {
+            return null;
+        }
+        return framing === 'content-length'
+            ? this.readContentLengthMessage()
+            : this.readJsonLineMessage();
+    }
+    detectFraming() {
+        if (this.buffer.length === 0) {
+            return null;
+        }
+        const preview = this.buffer
+            .subarray(0, Math.min(this.buffer.length, 32))
+            .toString('utf8')
+            .toLowerCase();
+        if (preview.startsWith(CONTENT_LENGTH_HEADER)) {
+            return 'content-length';
+        }
+        if (preview.startsWith('{') || preview.startsWith('[')) {
+            return 'jsonl';
+        }
+        const newlineIndex = this.buffer.indexOf(0x0a);
+        if (newlineIndex === -1) {
+            return null;
+        }
+        const firstLine = this.buffer.toString('utf8', 0, newlineIndex).replace(/\r$/, '').trimStart();
+        if (firstLine.toLowerCase().startsWith(CONTENT_LENGTH_HEADER)) {
+            return 'content-length';
+        }
+        if (firstLine.startsWith('{') || firstLine.startsWith('[')) {
+            return 'jsonl';
+        }
+        throw new Error(`Unsupported MCP stdio framing: ${JSON.stringify(firstLine.slice(0, 80))}`);
+    }
+    readJsonLineMessage() {
+        const newlineIndex = this.buffer.indexOf(0x0a);
+        if (newlineIndex === -1) {
+            return null;
+        }
+        const rawLine = this.buffer.toString('utf8', 0, newlineIndex).replace(/\r$/, '');
+        this.buffer = this.buffer.subarray(newlineIndex + 1);
+        if (rawLine.trim() === '') {
+            return this.readMessage();
+        }
+        return {
+            framing: 'jsonl',
+            message: JSON.parse(rawLine),
+        };
+    }
+    readContentLengthMessage() {
+        const headerBoundary = this.findHeaderBoundary();
+        if (headerBoundary === null) {
+            return null;
+        }
+        const { bodyStart, headerEnd } = headerBoundary;
+        const headerText = this.buffer.toString('utf8', 0, headerEnd);
+        const contentLength = this.parseContentLength(headerText);
+        if (this.buffer.length < bodyStart + contentLength) {
+            return null;
+        }
+        const bodyText = this.buffer.toString('utf8', bodyStart, bodyStart + contentLength);
+        this.buffer = this.buffer.subarray(bodyStart + contentLength);
+        return {
+            framing: 'content-length',
+            message: JSON.parse(bodyText),
+        };
+    }
+    findHeaderBoundary() {
+        const crlfBoundary = this.buffer.indexOf('\r\n\r\n');
+        if (crlfBoundary !== -1) {
+            return {
+                bodyStart: crlfBoundary + 4,
+                headerEnd: crlfBoundary,
+            };
+        }
+        const lfBoundary = this.buffer.indexOf('\n\n');
+        if (lfBoundary !== -1) {
+            return {
+                bodyStart: lfBoundary + 2,
+                headerEnd: lfBoundary,
+            };
+        }
+        return null;
+    }
+    parseContentLength(headerText) {
+        const headers = headerText.split(/\r?\n/);
+        for (const header of headers) {
+            const separatorIndex = header.indexOf(':');
+            if (separatorIndex === -1) {
+                continue;
+            }
+            const name = header.slice(0, separatorIndex).trim().toLowerCase();
+            if (name !== 'content-length') {
+                continue;
+            }
+            const value = Number.parseInt(header.slice(separatorIndex + 1).trim(), 10);
+            if (!Number.isFinite(value) || value < 0) {
+                throw new Error(`Invalid Content-Length header: ${header}`);
+            }
+            return value;
+        }
+        throw new Error('Missing Content-Length header');
+    }
+}

package/dist/types.d.ts

@@ -1,160 +1,4 @@
-import type { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { Implementation } from '@modelcontextprotocol/sdk/types.js';
-import type { GetAccountsOutput, GetFinancialStateOutput, GetTransactionsInput, GetTransactionsOutput, VerifyKeyOutput } from './schemas.js';
 export declare const WARM_TOOL_NAMES: readonly ["get_accounts", "get_transactions", "get_financial_state", "verify_key"];
 export type WarmToolName = (typeof WARM_TOOL_NAMES)[number];
-export interface WarmApiClientOptions {
-    apiUrl?: string;
-    requestTimeoutMs?: number;
-    fetchImplementation?: typeof fetch;
-    apiKeyResolver?: () => string | null;
-}
-export interface WarmServerOptions extends WarmApiClientOptions {
-    serverInfo?: Implementation;
-}
-export type WarmToolRegistrationTarget = McpServer;
-export type RegisteredWarmTools = Record<WarmToolName, RegisteredTool>;
-export interface WarmApiClient {
-    getAccounts(): Promise<GetAccountsOutput>;
-    getFinancialState(): Promise<GetFinancialStateOutput>;
-    getTransactions(input: GetTransactionsInput): Promise<GetTransactionsOutput>;
-    verifyKey(): Promise<VerifyKeyOutput>;
-}
-export interface WarmApiAccount {
-    account_id?: string | null;
-    name?: string | null;
-    type?: string | null;
-    subtype?: string | null;
-    current_balance?: number | null;
-    available_balance?: number | null;
-    institution_name?: string | null;
-    mask?: string | null;
-}
-export interface WarmApiAccountsResponse {
-    accounts?: WarmApiAccount[];
-    generated_at?: string;
-}
-export interface WarmApiTransaction {
-    id?: string | null;
-    account_id?: string | null;
-    date?: string | null;
-    amount?: number | null;
-    merchant_name?: string | null;
-    name?: string | null;
-    primary_category?: string | null;
-    detailed_category?: string | null;
-}
-export interface WarmApiTransactionsResponse {
-    generated_at?: string;
-    next_knowledge?: string;
-    transactions?: WarmApiTransaction[];
-    pagination?: {
-        limit?: number | null;
-        next_cursor?: string | null;
-    };
-}
-export interface WarmApiSnapshot {
-    snapshot_date?: string | null;
-    period_end?: string | null;
-    net_worth?: number | null;
-    total_assets?: number | null;
-    total_liabilities?: number | null;
-    total_cash?: number | null;
-    investment_value?: number | null;
-    asset_value?: number | null;
-    total_debt?: number | null;
-    liability_value?: number | null;
-}
-export interface WarmApiSnapshotsResponse {
-    snapshots?: WarmApiSnapshot[];
-    generated_at?: string;
-}
-export interface WarmApiRecurring {
-    average_amount?: number | null;
-    description?: string | null;
-    frequency?: string | null;
-    is_active?: boolean | null;
-    last_amount?: number | null;
-    merchant_name?: string | null;
-    next_date?: string | null;
-    stream_type?: string | null;
-}
-export interface WarmApiRecurringResponse {
-    recurring_transactions?: WarmApiRecurring[];
-    generated_at?: string;
-}
-export interface WarmApiBudget {
-    amount?: number | null;
-    name?: string | null;
-    period?: string | null;
-    percent_used?: number | null;
-    remaining?: number | null;
-    spent?: number | null;
-    status?: string | null;
-}
-export interface WarmApiBudgetsResponse {
-    budgets?: WarmApiBudget[];
-    generated_at?: string;
-}
-export interface WarmApiGoal {
-    category?: string | null;
-    current?: number | null;
-    monthly_contribution_needed?: number | null;
-    name?: string | null;
-    progress_percent?: number | null;
-    status?: string | null;
-    target?: number | null;
-    target_date?: string | null;
-}
-export interface WarmApiGoalsResponse {
-    goals?: WarmApiGoal[];
-    generated_at?: string;
-}
-export interface WarmApiHealthResponse {
-    score?: number | null;
-    label?: string | null;
-    pillars?: {
-        spend?: number | null;
-        save?: number | null;
-        borrow?: number | null;
-        build?: number | null;
-    } | null;
-    data_completeness?: number | null;
-    message?: string | null;
-    generated_at?: string;
-}
-export interface WarmApiLiability {
-    account_id?: string | null;
-    type?: string | null;
-    balance?: number | null;
-    apr_percentage?: number | null;
-    interest_rate_percentage?: number | null;
-    interest_rate_type?: string | null;
-    minimum_payment?: number | null;
-    next_payment_due_date?: string | null;
-    expected_payoff_date?: string | null;
-    origination_principal_amount?: number | null;
-    is_overdue?: boolean | null;
-}
-export interface WarmApiLiabilitiesResponse {
-    liabilities?: WarmApiLiability[];
-    generated_at?: string;
-}
-export interface WarmApiHolding {
-    account_id?: string | null;
-    security_name?: string | null;
-    symbol?: string | null;
-    type?: string | null;
-    quantity?: number | null;
-    value?: number | null;
-    cost_basis?: number | null;
-}
-export interface WarmApiHoldingsResponse {
-    holdings?: WarmApiHolding[];
-    generated_at?: string;
-}
-export interface WarmApiVerifyResponse {
-    valid?: boolean;
-    status?: string;
-    error?: string;
-}
+export type { GetAccountsOutput, GetTransactionsInput, GetTransactionsOutput, VerifyKeyOutput, WarmApiAccount, WarmApiBudget, WarmApiClient, WarmApiClientOptions, WarmApiGoal, WarmApiHolding, WarmApiLiability, WarmApiTransaction, WarmFinancialState, } from './warm-api-client.js';
+export type { WarmServerOptions } from './server.js';

package/dist/warm-api-client.d.ts

@@ -0,0 +1,184 @@
+type NormalizedAccountType = 'depository' | 'credit' | 'loan' | 'investment' | 'other';
+export interface WarmApiClientOptions {
+    apiKeyResolver?: () => string | null;
+    apiUrl?: string;
+    fetchImplementation?: typeof fetch;
+    requestTimeoutMs?: number;
+}
+export interface WarmApiAccount {
+    account_id?: string | null;
+    available_balance?: number | null;
+    current_balance?: number | null;
+    institution_name?: string | null;
+    mask?: string | null;
+    name?: string | null;
+    subtype?: string | null;
+    type?: string | null;
+}
+export interface WarmApiTransaction {
+    account_id?: string | null;
+    amount?: number | null;
+    date?: string | null;
+    detailed_category?: string | null;
+    id?: string | null;
+    merchant_name?: string | null;
+    name?: string | null;
+    primary_category?: string | null;
+}
+export interface WarmApiBudget {
+    amount?: number | null;
+    name?: string | null;
+    period?: string | null;
+    percent_used?: number | null;
+    remaining?: number | null;
+    spent?: number | null;
+    status?: string | null;
+}
+export interface WarmApiGoal {
+    category?: string | null;
+    current?: number | null;
+    monthly_contribution_needed?: number | null;
+    name?: string | null;
+    progress_percent?: number | null;
+    status?: string | null;
+    target?: number | null;
+    target_date?: string | null;
+}
+export interface WarmFinancialState extends Record<string, unknown> {
+    budgets: Array<{
+        amount: number;
+        name: string;
+        percent_used: number;
+        period: string;
+        remaining: number;
+        spent: number;
+        status: string | null;
+    }>;
+    category_spending: Array<{
+        amount: number;
+        category: string;
+    }>;
+    generated_at: string;
+    goals: Array<{
+        category: string | null;
+        current: number;
+        monthly_contribution_needed: number | null;
+        name: string;
+        progress_percent: number;
+        status: string | null;
+        target: number;
+        target_date: string | null;
+    }>;
+    health: {
+        data_completeness: number | null;
+        label: string | null;
+        message: string | null;
+        pillars: {
+            borrow: number | null;
+            build: number | null;
+            save: number | null;
+            spend: number | null;
+        } | null;
+        score: number | null;
+    };
+    holdings: Array<{
+        account_id: string;
+        cost_basis: number | null;
+        quantity: number;
+        security_name: string | null;
+        symbol: string | null;
+        type: string | null;
+        value: number | null;
+    }>;
+    liabilities: Array<{
+        account_id: string;
+        apr_percentage: number | null;
+        balance: number | null;
+        is_overdue: boolean | null;
+        minimum_payment: number | null;
+        next_payment_due_date: string | null;
+        type: string;
+    }>;
+    recurring: Array<{
+        active: boolean;
+        amount: number;
+        frequency: string;
+        merchant: string;
+        next_date: string | null;
+        type: string | null;
+    }>;
+    snapshots: Array<{
+        date: string;
+        net_worth: number;
+        total_assets: number;
+        total_liabilities: number;
+    }>;
+}
+export interface GetTransactionsInput {
+    cursor?: string;
+    last_knowledge?: string;
+    limit: number;
+    search?: string;
+}
+export interface GetTransactionsOutput extends Record<string, unknown> {
+    generated_at: string | null;
+    next_knowledge: string | null;
+    pagination: {
+        has_more: boolean;
+        limit: number;
+        next_cursor: string | null;
+    };
+    txns: Array<{
+        amount: number;
+        category: string | null;
+        date: string | null;
+        description: string | null;
+        detailed_category: string | null;
+        id: string | null;
+        merchant: string | null;
+    }>;
+}
+export interface GetAccountsOutput extends Record<string, unknown> {
+    accounts: Array<{
+        balance: number;
+        institution: string | null;
+        mask: string | null;
+        name: string;
+        subtype: string | null;
+        type: NormalizedAccountType;
+    }>;
+}
+export interface VerifyKeyOutput extends Record<string, unknown> {
+    status: string;
+    valid: boolean;
+}
+export interface WarmApiClient {
+    getAccounts(): Promise<GetAccountsOutput>;
+    getFinancialState(): Promise<WarmFinancialState>;
+    getTransactions(input: GetTransactionsInput): Promise<GetTransactionsOutput>;
+    verifyKey(): Promise<VerifyKeyOutput>;
+}
+export interface WarmApiLiability {
+    account_id?: string | null;
+    apr_percentage?: number | null;
+    balance?: number | null;
+    is_overdue?: boolean | null;
+    minimum_payment?: number | null;
+    next_payment_due_date?: string | null;
+    type?: string | null;
+}
+export interface WarmApiHolding {
+    account_id?: string | null;
+    cost_basis?: number | null;
+    quantity?: number | null;
+    security_name?: string | null;
+    symbol?: string | null;
+    type?: string | null;
+    value?: number | null;
+}
+export declare function getConfiguredApiKey(): string | null;
+export declare function resetConfiguredApiKeyCache(): void;
+export declare function apiRequest<TResponse>(endpoint: string, params?: Record<string, string | undefined>, options?: WarmApiClientOptions): Promise<TResponse>;
+export declare function createWarmApiClient(options?: WarmApiClientOptions): WarmApiClient;
+export declare function verifyWarmApiKey(apiKey: string): Promise<VerifyKeyOutput>;
+export {};