@dizzlkheinz/ynab-mcpb 0.12.2 → 0.15.0

package/src/server/YNABMCPServer.ts

@@ -16,12 +16,11 @@ import * as ynab from 'ynab';
 import {
   AuthenticationError,
   ConfigurationError,
-  ServerConfig,
-  ErrorHandler,
-  YNABErrorCode,
-  ValidationError,
-} from '../types/index.js';
-import { createErrorHandler } from './errorHandler.js';
+  ValidationError as ConfigValidationError,
+} from '../utils/errors.js';
+import { YNABErrorCode, ValidationError } from '../types/index.js';
+import { loadConfig, type AppConfig } from './config.js';
+import { createErrorHandler, ErrorHandler } from './errorHandler.js';
 import { BudgetResolver } from './budgetResolver.js';
 import { SecurityMiddleware, withSecurityWrapper } from './securityMiddleware.js';
 import { handleListBudgets, handleGetBudget, GetBudgetSchema } from '../tools/budgetTools.js';
@@ -87,7 +86,6 @@ import {
   type DefaultArgumentResolver,
   type ToolExecutionPayload,
 } from './toolRegistry.js';
-import { validateEnvironment } from './config.js';
 import { ResourceManager } from './resources.js';
 import { PromptManager } from './prompts.js';
 import { DiagnosticManager } from './diagnostics.js';
@@ -107,25 +105,15 @@ import {
   ListBudgetsOutputSchema,
   ListAccountsOutputSchema,
   GetAccountOutputSchema,
-  CreateAccountOutputSchema,
-  ListTransactionsOutputSchema,
   GetTransactionOutputSchema,
   ExportTransactionsOutputSchema,
   CompareTransactionsOutputSchema,
-  CreateTransactionOutputSchema,
-  CreateTransactionsOutputSchema,
-  UpdateTransactionOutputSchema,
-  UpdateTransactionsOutputSchema,
-  DeleteTransactionOutputSchema,
-  CreateReceiptSplitTransactionOutputSchema,
   ListCategoriesOutputSchema,
   GetCategoryOutputSchema,
-  UpdateCategoryOutputSchema,
   ListPayeesOutputSchema,
   GetPayeeOutputSchema,
   GetMonthOutputSchema,
   ListMonthsOutputSchema,
-  ReconcileAccountOutputSchema,
 } from '../tools/schemas/outputs/index.js';
 
 /**
@@ -134,9 +122,9 @@ import {
 export class YNABMCPServer {
   private server: Server;
   private ynabAPI: ynab.API;
-  private config: ServerConfig;
   private exitOnError: boolean;
   private defaultBudgetId: string | undefined;
+  private configInstance: AppConfig;
   private serverVersion: string;
   private toolRegistry: ToolRegistry;
   private resourceManager: ResourceManager;
@@ -149,14 +137,12 @@ export class YNABMCPServer {
 
   constructor(exitOnError: boolean = true) {
     this.exitOnError = exitOnError;
-    // Validate environment variables
-    this.config = validateEnvironment();
-    if (this.config.defaultBudgetId !== undefined) {
-      this.defaultBudgetId = this.config.defaultBudgetId;
-    }
+    this.configInstance = loadConfig();
+    // Config is now imported and validated at startup
+    this.defaultBudgetId = process.env['YNAB_DEFAULT_BUDGET_ID'];
 
     // Initialize YNAB API
-    this.ynabAPI = new ynab.API(this.config.accessToken);
+    this.ynabAPI = new ynab.API(this.configInstance.YNAB_ACCESS_TOKEN);
 
     // Determine server version (prefer package.json)
     this.serverVersion = this.readPackageVersion() ?? '0.0.0';
@@ -169,9 +155,9 @@ export class YNABMCPServer {
       },
       {
         capabilities: {
-          tools: {},
-          resources: {},
-          prompts: {},
+          tools: { listChanged: true },
+          resources: { listChanged: true },
+          prompts: { listChanged: true },
         },
       },
     );
@@ -217,7 +203,7 @@ export class YNABMCPServer {
         },
       },
       validateAccessToken: (token: string) => {
-        const expected = this.config.accessToken.trim();
+        const expected = this.configInstance.YNAB_ACCESS_TOKEN.trim();
         const provided = typeof token === 'string' ? token.trim() : '';
         if (!provided) {
           throw this.errorHandler.createYNABError(
@@ -269,6 +255,10 @@ export class YNABMCPServer {
       await this.ynabAPI.user.getUser();
       return true;
     } catch (error) {
+      if (this.isMalformedTokenResponse(error)) {
+        throw new AuthenticationError('Unexpected response from YNAB during token validation');
+      }
+
       if (error instanceof Error) {
         // Check for authentication-related errors
         if (error.message.includes('401') || error.message.includes('Unauthorized')) {
@@ -277,9 +267,37 @@ export class YNABMCPServer {
         if (error.message.includes('403') || error.message.includes('Forbidden')) {
           throw new AuthenticationError('YNAB access token has insufficient permissions');
         }
+
+        const reason = error.message || String(error);
+        throw new AuthenticationError(`Token validation failed: ${reason}`);
       }
-      throw new AuthenticationError(`Token validation failed: ${error}`);
+
+      throw new AuthenticationError(`Token validation failed: ${String(error)}`);
+    }
+  }
+
+  private isMalformedTokenResponse(error: unknown): boolean {
+    if (error instanceof SyntaxError) {
+      return true;
     }
+
+    const message =
+      typeof error === 'string'
+        ? error
+        : typeof (error as { message?: unknown })?.message === 'string'
+          ? String((error as { message: unknown }).message)
+          : null;
+
+    if (!message) {
+      return false;
+    }
+
+    const normalized = message.toLowerCase();
+    return (
+      normalized.includes('unexpected token') ||
+      normalized.includes('unexpected end of json') ||
+      normalized.includes('<html')
+    );
   }
 
   /**
@@ -345,7 +363,7 @@ export class YNABMCPServer {
         minifyOverride?: boolean;
       } = {
         name: request.params.name,
-        accessToken: this.config.accessToken,
+        accessToken: this.configInstance.YNAB_ACCESS_TOKEN,
         arguments: sanitizedArgs ?? {},
       };
 
@@ -436,6 +454,8 @@ export class YNABMCPServer {
         pretty_spaces: z.number().int().min(0).max(10).optional(),
       })
       .strict();
+    // Permissive object schema used where hosts require a top-level object type
+    const LooseObjectSchema = z.object({}).passthrough();
 
     register({
       name: 'list_budgets',
@@ -576,7 +596,7 @@ export class YNABMCPServer {
       name: 'create_account',
       description: 'Create a new account in the specified budget',
       inputSchema: CreateAccountSchema,
-      outputSchema: CreateAccountOutputSchema,
+      outputSchema: LooseObjectSchema,
       handler: adaptWrite(handleCreateAccount),
       defaultArgumentResolver: resolveBudgetId<z.infer<typeof CreateAccountSchema>>(),
       metadata: {
@@ -591,7 +611,7 @@ export class YNABMCPServer {
       name: 'list_transactions',
       description: 'List transactions for a budget with optional filtering',
       inputSchema: ListTransactionsSchema,
-      outputSchema: ListTransactionsOutputSchema,
+      outputSchema: LooseObjectSchema,
       handler: adaptWithDelta(handleListTransactions),
       defaultArgumentResolver: resolveBudgetId<z.infer<typeof ListTransactionsSchema>>(),
       metadata: {
@@ -638,7 +658,7 @@ export class YNABMCPServer {
       description:
         'Guided reconciliation workflow with human narrative, insight detection, and optional execution (create/update/unclear). Set include_structured_data=true to also get full JSON output (large).',
       inputSchema: ReconcileAccountSchema,
-      outputSchema: ReconcileAccountOutputSchema,
+      outputSchema: LooseObjectSchema,
       handler: adaptWithDelta(handleReconcileAccount),
       defaultArgumentResolver: resolveBudgetId<z.infer<typeof ReconcileAccountSchema>>(),
       metadata: {
@@ -668,7 +688,7 @@ export class YNABMCPServer {
       name: 'create_transaction',
       description: 'Create a new transaction in the specified budget and account',
       inputSchema: CreateTransactionSchema,
-      outputSchema: CreateTransactionOutputSchema,
+      outputSchema: LooseObjectSchema,
       handler: adaptWrite(handleCreateTransaction),
       defaultArgumentResolver: resolveBudgetId<z.infer<typeof CreateTransactionSchema>>(),
       metadata: {
@@ -684,7 +704,7 @@ export class YNABMCPServer {
       description:
         'Create multiple transactions in a single batch (1-100 items) with duplicate detection, dry-run validation, and automatic response size management with correlation metadata.',
       inputSchema: CreateTransactionsSchema,
-      outputSchema: CreateTransactionsOutputSchema,
+      outputSchema: LooseObjectSchema,
       handler: adaptWrite(handleCreateTransactions),
       defaultArgumentResolver: resolveBudgetId<z.infer<typeof CreateTransactionsSchema>>(),
       metadata: {
@@ -700,7 +720,7 @@ export class YNABMCPServer {
       description:
         'Update multiple transactions in a single batch (1-100 items) with dry-run validation, automatic cache invalidation, and response size management. Supports optional original_account_id and original_date metadata for efficient cache invalidation.',
       inputSchema: UpdateTransactionsSchema,
-      outputSchema: UpdateTransactionsOutputSchema,
+      outputSchema: LooseObjectSchema,
       handler: adaptWrite(handleUpdateTransactions),
       defaultArgumentResolver: resolveBudgetId<z.infer<typeof UpdateTransactionsSchema>>(),
       metadata: {
@@ -715,7 +735,7 @@ export class YNABMCPServer {
       name: 'create_receipt_split_transaction',
       description: 'Create a split transaction from receipt items with proportional tax allocation',
       inputSchema: CreateReceiptSplitTransactionSchema,
-      outputSchema: CreateReceiptSplitTransactionOutputSchema,
+      outputSchema: LooseObjectSchema,
       handler: adaptWrite(handleCreateReceiptSplitTransaction),
       defaultArgumentResolver:
         resolveBudgetId<z.infer<typeof CreateReceiptSplitTransactionSchema>>(),
@@ -731,7 +751,7 @@ export class YNABMCPServer {
       name: 'update_transaction',
       description: 'Update an existing transaction',
       inputSchema: UpdateTransactionSchema,
-      outputSchema: UpdateTransactionOutputSchema,
+      outputSchema: LooseObjectSchema,
       handler: adaptWrite(handleUpdateTransaction),
       defaultArgumentResolver: resolveBudgetId<z.infer<typeof UpdateTransactionSchema>>(),
       metadata: {
@@ -746,7 +766,7 @@ export class YNABMCPServer {
       name: 'delete_transaction',
       description: 'Delete a transaction from the specified budget',
       inputSchema: DeleteTransactionSchema,
-      outputSchema: DeleteTransactionOutputSchema,
+      outputSchema: LooseObjectSchema,
       handler: adaptWrite(handleDeleteTransaction),
       defaultArgumentResolver: resolveBudgetId<z.infer<typeof DeleteTransactionSchema>>(),
       metadata: {
@@ -791,7 +811,7 @@ export class YNABMCPServer {
       name: 'update_category',
       description: 'Update the budgeted amount for a category in the current month',
       inputSchema: UpdateCategorySchema,
-      outputSchema: UpdateCategoryOutputSchema,
+      outputSchema: LooseObjectSchema,
       handler: adaptWrite(handleUpdateCategory),
       defaultArgumentResolver: resolveBudgetId<z.infer<typeof UpdateCategorySchema>>(),
       metadata: {
@@ -999,8 +1019,14 @@ export class YNABMCPServer {
 
       console.error('YNAB MCP Server started successfully');
     } catch (error) {
-      if (error instanceof AuthenticationError || error instanceof ConfigurationError) {
-        console.error(`Server startup failed: ${error.message}`);
+      if (
+        error instanceof AuthenticationError ||
+        error instanceof ConfigurationError ||
+        error instanceof ConfigValidationError ||
+        error instanceof ValidationError ||
+        (error as { name?: string })?.name === 'ValidationError'
+      ) {
+        console.error(`Server startup failed: ${error instanceof Error ? error.message : error}`);
         if (this.exitOnError) {
           process.exit(1);
         } else {
@@ -1172,6 +1198,19 @@ export class YNABMCPServer {
     } catch {
       // ignore
     }
+    try {
+      // CJS bundles can rely on __dirname being defined; add nearby package.json fallbacks
+      const dir = typeof __dirname === 'string' ? __dirname : undefined;
+      if (dir) {
+        candidates.push(
+          path.resolve(dir, '../../package.json'),
+          path.resolve(dir, '../package.json'),
+          path.resolve(dir, 'package.json'),
+        );
+      }
+    } catch {
+      // ignore additional fallbacks
+    }
     for (const p of candidates) {
       try {
         if (fs.existsSync(p)) {

package/src/server/__tests__/YNABMCPServer.integration.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import { YNABMCPServer } from '../YNABMCPServer.js';
-import { AuthenticationError, ConfigurationError } from '../../types/index.js';
+import { ValidationError } from '../../types/index.js';
 import { ToolRegistry } from '../toolRegistry.js';
 import { cacheManager } from '../../server/cacheManager.js';
 import { responseFormatter } from '../../server/responseFormatter.js';
@@ -42,16 +42,13 @@ describeIntegration('YNABMCPServer', () => {
     );
 
     it(
-      'should throw ConfigurationError when YNAB_ACCESS_TOKEN is missing',
+      'should throw ValidationError when YNAB_ACCESS_TOKEN is missing',
       { meta: { tier: 'domain', domain: 'server' } },
       () => {
         const originalToken = process.env['YNAB_ACCESS_TOKEN'];
         delete process.env['YNAB_ACCESS_TOKEN'];
 
-        expect(() => new YNABMCPServer()).toThrow(ConfigurationError);
-        expect(() => new YNABMCPServer()).toThrow(
-          'YNAB_ACCESS_TOKEN environment variable is required but not set',
-        );
+        expect(() => new YNABMCPServer()).toThrow(/YNAB_ACCESS_TOKEN/i);
 
         // Restore token
         process.env['YNAB_ACCESS_TOKEN'] = originalToken;
@@ -59,13 +56,12 @@ describeIntegration('YNABMCPServer', () => {
     );
 
     it(
-      'should throw ConfigurationError when YNAB_ACCESS_TOKEN is empty string',
+      'should throw ValidationError when YNAB_ACCESS_TOKEN is empty string',
       { meta: { tier: 'domain', domain: 'server' } },
       () => {
         const originalToken = process.env['YNAB_ACCESS_TOKEN'];
         process.env['YNAB_ACCESS_TOKEN'] = '';
 
-        expect(() => new YNABMCPServer()).toThrow(ConfigurationError);
         expect(() => new YNABMCPServer()).toThrow('YNAB_ACCESS_TOKEN must be a non-empty string');
 
         // Restore token
@@ -74,13 +70,12 @@ describeIntegration('YNABMCPServer', () => {
     );
 
     it(
-      'should throw ConfigurationError when YNAB_ACCESS_TOKEN is only whitespace',
+      'should throw ValidationError when YNAB_ACCESS_TOKEN is only whitespace',
       { meta: { tier: 'domain', domain: 'server' } },
       () => {
         const originalToken = process.env['YNAB_ACCESS_TOKEN'];
         process.env['YNAB_ACCESS_TOKEN'] = '   ';
 
-        expect(() => new YNABMCPServer()).toThrow(ConfigurationError);
         expect(() => new YNABMCPServer()).toThrow('YNAB_ACCESS_TOKEN must be a non-empty string');
 
         // Restore token
@@ -167,7 +162,10 @@ describeIntegration('YNABMCPServer', () => {
 
         try {
           const invalidServer = new YNABMCPServer(false);
-          await expect(invalidServer.validateToken()).rejects.toThrow(AuthenticationError);
+          await expect(invalidServer.validateToken()).rejects.toHaveProperty(
+            'name',
+            'AuthenticationError',
+          );
         } finally {
           // Restore original token
           process.env['YNAB_ACCESS_TOKEN'] = originalToken;
@@ -200,7 +198,7 @@ describeIntegration('YNABMCPServer', () => {
           } catch (error) {
             // Expected to fail on stdio connection in test environment
             // Token was already validated above, so this error should be transport-related
-            expect(error).not.toBeInstanceOf(ConfigurationError);
+            expect(error).not.toBeInstanceOf(ValidationError);
           }
 
           consoleSpy.mockRestore();

package/src/server/__tests__/YNABMCPServer.test.ts

@@ -2,7 +2,7 @@ import { describe, it, expect, vi, beforeEach, afterEach, beforeAll } from 'vite
 import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
 
 import { YNABMCPServer } from '../YNABMCPServer.js';
-import { AuthenticationError, ConfigurationError, ValidationError } from '../../types/index.js';
+import { AuthenticationError, ValidationError } from '../../types/index.js';
 import { ToolRegistry } from '../toolRegistry.js';
 import { cacheManager } from '../../server/cacheManager.js';
 import { responseFormatter } from '../../server/responseFormatter.js';
@@ -80,41 +80,56 @@ describe('YNABMCPServer', () => {
       expect(server.getYNABAPI()).toBeDefined();
     });
 
-    it('should throw ConfigurationError when YNAB_ACCESS_TOKEN is missing', () => {
+    it('should throw ValidationError when YNAB_ACCESS_TOKEN is missing', () => {
       const originalToken = process.env['YNAB_ACCESS_TOKEN'];
       delete process.env['YNAB_ACCESS_TOKEN'];
 
-      expect(() => new YNABMCPServer()).toThrow(ConfigurationError);
-      expect(() => new YNABMCPServer()).toThrow(
-        'YNAB_ACCESS_TOKEN environment variable is required but not set',
-      );
+      expect(() => new YNABMCPServer()).toThrow(/YNAB_ACCESS_TOKEN/i);
 
       // Restore token
       process.env['YNAB_ACCESS_TOKEN'] = originalToken;
     });
 
-    it('should throw ConfigurationError when YNAB_ACCESS_TOKEN is empty string', () => {
+    it('should throw ValidationError when YNAB_ACCESS_TOKEN is empty string', () => {
       const originalToken = process.env['YNAB_ACCESS_TOKEN'];
       process.env['YNAB_ACCESS_TOKEN'] = '';
 
-      expect(() => new YNABMCPServer()).toThrow(ConfigurationError);
       expect(() => new YNABMCPServer()).toThrow('YNAB_ACCESS_TOKEN must be a non-empty string');
 
       // Restore token
       process.env['YNAB_ACCESS_TOKEN'] = originalToken;
     });
 
-    it('should throw ConfigurationError when YNAB_ACCESS_TOKEN is only whitespace', () => {
+    it('should throw ValidationError when YNAB_ACCESS_TOKEN is only whitespace', () => {
       const originalToken = process.env['YNAB_ACCESS_TOKEN'];
       process.env['YNAB_ACCESS_TOKEN'] = '   ';
 
-      expect(() => new YNABMCPServer()).toThrow(ConfigurationError);
       expect(() => new YNABMCPServer()).toThrow('YNAB_ACCESS_TOKEN must be a non-empty string');
 
       // Restore token
       process.env['YNAB_ACCESS_TOKEN'] = originalToken;
     });
 
+    it('should reload configuration for each server instance', () => {
+      const originalToken = process.env['YNAB_ACCESS_TOKEN'];
+
+      process.env['YNAB_ACCESS_TOKEN'] = 'token-one';
+      const firstServer = new YNABMCPServer(false);
+      const firstConfig = (
+        firstServer as unknown as { configInstance: { YNAB_ACCESS_TOKEN: string } }
+      ).configInstance;
+      expect(firstConfig.YNAB_ACCESS_TOKEN).toBe('token-one');
+
+      process.env['YNAB_ACCESS_TOKEN'] = 'token-two';
+      const secondServer = new YNABMCPServer(false);
+      const secondConfig = (
+        secondServer as unknown as { configInstance: { YNAB_ACCESS_TOKEN: string } }
+      ).configInstance;
+      expect(secondConfig.YNAB_ACCESS_TOKEN).toBe('token-two');
+
+      process.env['YNAB_ACCESS_TOKEN'] = originalToken;
+    });
+
     it('should trim whitespace from access token', () => {
       const originalToken = process.env['YNAB_ACCESS_TOKEN'];
       process.env['YNAB_ACCESS_TOKEN'] = `  ${originalToken}  `;
@@ -193,7 +208,7 @@ describe('YNABMCPServer', () => {
         // Expected to fail on stdio connection in test environment
         // But should not fail on token validation
         expect(error).not.toBeInstanceOf(AuthenticationError);
-        expect(error).not.toBeInstanceOf(ConfigurationError);
+        expect(error).not.toBeInstanceOf(ValidationError);
       }
 
       consoleSpy.mockRestore();
@@ -739,10 +754,7 @@ describe('YNABMCPServer', () => {
       delete process.env['YNAB_ACCESS_TOKEN'];
 
       try {
-        expect(() => new YNABMCPServer()).toThrow(ConfigurationError);
-        expect(() => new YNABMCPServer()).toThrow(
-          'YNAB_ACCESS_TOKEN environment variable is required but not set',
-        );
+        expect(() => new YNABMCPServer()).toThrow(/YNAB_ACCESS_TOKEN/i);
       } finally {
         // Restore token
         process.env['YNAB_ACCESS_TOKEN'] = originalToken;