mcp-grocy 1.10.0 → 1.11.0

package/README.md

@@ -139,7 +139,7 @@ docker compose up -d
 |--------|----------|---------|
 | **`.env` file** | Recommended for most users | `cp .env.example .env` |
 | **Environment variables** | CI/CD, containers | `GROCY_BASE_URL=... GROCY_APIKEY_VALUE=... mcp-grocy` |
-| **Tool toggles** | Customize functionality | Edit `TOOL__*` variables in `.env` |
+| **Tool configuration** | Customize functionality | Edit `tools` section in `mcp-grocy.yaml` |
 
 📖 **For complete configuration reference:** See [Configuration Guide](src/resources/config.md)
 
@@ -172,7 +172,7 @@ npm start
 |----------|---------|-------------|
 | [📖 API Reference](src/resources/api-reference.md) | Complete tool documentation | Tool usage and examples |
 | [⚙️ Configuration Guide](src/resources/config.md) | Advanced configuration reference | Detailed setup, presets, troubleshooting |
-| [📋 .env.example](.env.example) | Configuration template with ALL tools | Copy and customize for your setup |
+| [📋 .env.example](.env.example) | Environment configuration template | Copy and customize for your setup |
 | [🧪 MCP Inspector](https://github.com/modelcontextprotocol/inspector) | Protocol debugging | Debug MCP interactions |
 
 ### 🆘 Troubleshooting
@@ -190,12 +190,12 @@ npm start
 - Ensure the API key has proper permissions
 
 **"Tool not found" errors**
-- Check if the tool is enabled in your `.env` file (tool toggles)
+- Check if the tool is enabled in your `mcp-grocy.yaml` file
 - Verify you're using the correct tool names from the API reference
 
 **Large response errors**
 - Increase `REST_RESPONSE_SIZE_LIMIT` if you have many products/stock entries
-- Consider using tool toggles to disable unused functionality
+- Consider disabling unused tools in `mcp-grocy.yaml`
 
 #### Debug Mode
 

package/build/api/client.js

@@ -1,77 +1,66 @@
+/**
+ * Simplified API client for Grocy
+ */
 import axios from 'axios';
 import https from 'https';
-import config from '../config/environment.js';
-export class ApiError extends Error {
-    status;
-    response;
-    constructor(message, status, response) {
-        super(message);
-        this.name = 'ApiError';
-        this.status = status;
-        this.response = response;
-    }
-}
+import { config } from '../config/index.js';
+import { logger } from '../utils/logger.js';
+import { ApiError, ErrorHandler } from '../utils/errors.js';
 export class GrocyApiClient {
     axiosInstance;
     API_KEY_HEADER = 'GROCY-API-KEY';
     constructor() {
-        const { GROCY_ENABLE_SSL_VERIFY, GROCY_APIKEY_VALUE } = config.get();
-        this.axiosInstance = axios.create({
+        this.axiosInstance = this.createAxiosInstance();
+        this.setupInterceptors();
+    }
+    createAxiosInstance() {
+        const { yaml } = config.getConfig();
+        const apiKey = config.getApiKey();
+        const instance = axios.create({
             baseURL: config.getGrocyBaseUrl(),
-            validateStatus: () => true, // Allow any status code
-            timeout: 30000, // 30 seconds timeout
-            httpsAgent: GROCY_ENABLE_SSL_VERIFY ? undefined : new https.Agent({
+            validateStatus: () => true, // Handle all status codes manually
+            timeout: 30000,
+            httpsAgent: yaml.grocy.enable_ssl_verify ? undefined : new https.Agent({
                 rejectUnauthorized: false
             })
         });
-        // Set default authentication if available
-        if (GROCY_APIKEY_VALUE) {
-            this.axiosInstance.defaults.headers.common[this.API_KEY_HEADER] = GROCY_APIKEY_VALUE;
+        // Set default authentication
+        if (apiKey) {
+            instance.defaults.headers.common[this.API_KEY_HEADER] = apiKey;
         }
-        // Add request interceptor for logging
+        return instance;
+    }
+    setupInterceptors() {
+        // Request logging
         this.axiosInstance.interceptors.request.use((config) => {
-            console.error(`[API] ${config.method?.toUpperCase()} ${config.url}`);
-            if (config.data) {
-                console.error(`[API] Request body: ${JSON.stringify(config.data)}`);
-            }
+            logger.api(`${config.method?.toUpperCase()} ${config.url}`);
             return config;
         }, (error) => {
-            console.error('[API] Request error:', error);
+            logger.error('Request error', 'API', { error: error.message });
             return Promise.reject(error);
         });
-        // Add response interceptor for error handling
+        // Response logging
         this.axiosInstance.interceptors.response.use((response) => {
             if (response.status >= 400) {
-                console.error(`[API] Error response (${response.status}): ${JSON.stringify(response.data)}`);
+                logger.warn(`HTTP ${response.status}`, 'API', {
+                    url: response.config?.url,
+                    status: response.status
+                });
             }
             return response;
         }, (error) => {
-            console.error('[API] Response error:', error);
+            logger.error('Response error', 'API', { error: error.message });
             return Promise.reject(error);
         });
     }
     normalizeEndpoint(endpoint) {
-        // Standardize path handling
-        let normalizedEndpoint = endpoint;
-        // Check if endpoint explicitly starts with /api/ - use it as is
-        if (endpoint.startsWith('/api/')) {
-            normalizedEndpoint = endpoint;
-        }
-        // Handle endpoints that start with api/ without leading slash
-        else if (endpoint.startsWith('api/')) {
-            normalizedEndpoint = `/${endpoint}`;
-        }
-        // All other endpoints - ensure they start with /api/
-        else {
-            if (endpoint.startsWith('/')) {
-                normalizedEndpoint = `/api${endpoint}`;
-            }
-            else {
-                normalizedEndpoint = `/api/${endpoint}`;
-            }
-        }
-        console.error(`[API] Normalized endpoint: ${normalizedEndpoint}`);
-        return normalizedEndpoint;
+        if (endpoint.startsWith('/api/'))
+            return endpoint;
+        if (endpoint.startsWith('api/'))
+            return `/${endpoint}`;
+        if (endpoint.startsWith('/'))
+            return `/api${endpoint}`;
+        return `/api/${endpoint}`;
     }
     buildQueryString(params) {
         return Object.entries(params)
@@ -80,57 +69,35 @@ export class GrocyApiClient {
     }
     async request(endpoint, options = {}) {
         const { method = 'GET', body = null, headers = {}, queryParams = {}, timeout } = options;
-        let url = this.normalizeEndpoint(endpoint);
-        // Add query parameters
-        if (Object.keys(queryParams).length > 0) {
-            const queryString = this.buildQueryString(queryParams);
-            url += `?${queryString}`;
-        }
-        const requestConfig = {
-            method,
-            url,
-            headers: {
-                'Accept': 'application/json',
-                'Content-Type': 'application/json',
-                ...config.getCustomHeaders(),
-                ...headers
-            },
-            timeout
-        };
-        if (['POST', 'PUT', 'PATCH'].includes(method) && body !== null) {
-            requestConfig.data = body;
-        }
-        try {
+        return ErrorHandler.handleAsync(async () => {
+            let url = this.normalizeEndpoint(endpoint);
+            if (Object.keys(queryParams).length > 0) {
+                url += `?${this.buildQueryString(queryParams)}`;
+            }
+            const requestConfig = {
+                method,
+                url,
+                headers: {
+                    'Accept': 'application/json',
+                    'Content-Type': 'application/json',
+                    ...config.getCustomHeaders(),
+                    ...headers
+                },
+                ...(timeout && { timeout })
+            };
+            if (['POST', 'PUT', 'PATCH'].includes(method) && body !== null) {
+                requestConfig.data = body;
+            }
             const response = await this.axiosInstance.request(requestConfig);
             if (response.status >= 400) {
-                throw new ApiError(`API error (${response.status}): ${JSON.stringify(response.data)}`, response.status, response.data);
+                throw new ApiError(response.data?.message || `HTTP ${response.status} error`, response.status, `${method} ${url}`, { responseData: response.data });
             }
             return {
                 data: response.data,
                 status: response.status,
                 headers: response.headers
             };
-        }
-        catch (error) {
-            if (axios.isAxiosError(error)) {
-                const axiosError = error;
-                if (axiosError.code === 'ECONNABORTED') {
-                    throw new ApiError('Connection timeout: The server took too long to respond');
-                }
-                else if (axiosError.code === 'ECONNRESET' || axiosError.message.includes('socket hang up')) {
-                    throw new ApiError('Connection reset: The server unexpectedly closed the connection');
-                }
-                else if (!axiosError.response) {
-                    throw new ApiError('Network error: Unable to reach the Grocy server');
-                }
-            }
-            // Re-throw ApiError instances
-            if (error instanceof ApiError) {
-                throw error;
-            }
-            // Wrap other errors
-            throw new ApiError(`Request failed: ${error.message || error}`);
-        }
+        }, `API ${method} ${endpoint}`);
     }
     // Convenience methods
     async get(endpoint, options = {}) {
@@ -149,6 +116,8 @@ export class GrocyApiClient {
         return this.request(endpoint, { ...options, method: 'PATCH', body });
     }
 }
-// Export a singleton instance
+// Export singleton instance
 export const apiClient = new GrocyApiClient();
 export default apiClient;
+// Re-export ApiError for convenience
+export { ApiError };

package/build/config/environment.js

@@ -1,37 +1,25 @@
 import { z } from 'zod';
+import { yamlConfig } from './yaml-config.js';
+import { logger } from '../utils/logger.js';
 // Environment variable schema with validation and defaults
 const EnvironmentSchema = z.object({
-    // Grocy Configuration
-    GROCY_BASE_URL: z.string().url().default('http://localhost:9283'),
+    // Grocy Configuration - API key must still come from env for security
     GROCY_APIKEY_VALUE: z.string().optional(),
-    GROCY_ENABLE_SSL_VERIFY: z.string().default('true').transform(val => val !== 'false'),
-    // Server Configuration
-    ENABLE_HTTP_SERVER: z.string().default('false').transform(val => ['true', 'yes', '1', 'on', 'enabled'].includes(val.toLowerCase())),
-    HTTP_SERVER_PORT: z.string().default('8080').transform(val => parseInt(val, 10)),
-    // API Configuration
-    REST_RESPONSE_SIZE_LIMIT: z.string().default('10000').transform(val => {
-        const parsed = parseInt(val, 10);
-        if (isNaN(parsed) || parsed <= 0) {
-            throw new Error('REST_RESPONSE_SIZE_LIMIT must be a positive number');
-        }
-        return parsed;
-    }),
     // Build Configuration
     RELEASE_VERSION: z.string().optional(),
 });
 export class ConfigManager {
     static instance;
-    config;
+    envConfig;
     constructor() {
         try {
-            this.config = EnvironmentSchema.parse(process.env);
-            this.validateConfiguration();
+            this.envConfig = EnvironmentSchema.parse(process.env);
         }
         catch (error) {
             if (error instanceof z.ZodError) {
-                console.error('[CONFIG ERROR] Invalid environment variables:');
+                logger.error('Invalid environment variables', 'CONFIG');
                 error.errors.forEach(err => {
-                    console.error(`  - ${err.path.join('.')}: ${err.message}`);
+                    logger.error(`${err.path.join('.')}: ${err.message}`, 'CONFIG');
                 });
                 process.exit(1);
             }
@@ -44,98 +32,30 @@ export class ConfigManager {
         }
         return ConfigManager.instance;
     }
-    validateConfiguration() {
-        // Custom validation logic
-        if (this.config.HTTP_SERVER_PORT < 1 || this.config.HTTP_SERVER_PORT > 65535) {
-            throw new Error('HTTP_SERVER_PORT must be between 1 and 65535');
-        }
-        // Log important configuration
-        console.error(`[CONFIG] Grocy Base URL: ${this.config.GROCY_BASE_URL}`);
-        console.error(`[CONFIG] SSL Verification: ${this.config.GROCY_ENABLE_SSL_VERIFY ? 'enabled' : 'disabled'}`);
-        console.error(`[CONFIG] HTTP Server: ${this.config.ENABLE_HTTP_SERVER ? `enabled on port ${this.config.HTTP_SERVER_PORT}` : 'disabled'}`);
-        console.error(`[CONFIG] Response Size Limit: ${this.config.REST_RESPONSE_SIZE_LIMIT} bytes`);
+    /**
+     * Reset the singleton instance for testing purposes
+     * Note: This should only be used in tests
+     */
+    static resetInstanceForTesting() {
+        ConfigManager.instance = undefined;
     }
     get() {
-        return this.config;
+        return this.envConfig;
     }
     getGrocyBaseUrl() {
-        return this.config.GROCY_BASE_URL.replace(/\/+$/, '');
+        return yamlConfig.getGrocyBaseUrl();
     }
     getApiUrl() {
-        return `${this.getGrocyBaseUrl()}/api`;
+        return yamlConfig.getApiUrl();
     }
     hasApiKeyAuth() {
-        return !!this.config.GROCY_APIKEY_VALUE;
+        return !!this.envConfig.GROCY_APIKEY_VALUE;
     }
     getCustomHeaders() {
-        const headers = {};
-        const headerPrefix = /^header_/i;
-        for (const [key, value] of Object.entries(process.env)) {
-            if (headerPrefix.test(key) && value !== undefined) {
-                const headerName = key.replace(headerPrefix, '');
-                headers[headerName] = value;
-            }
-        }
-        return headers;
+        return yamlConfig.getCustomHeaders();
     }
     parseToolConfiguration() {
-        const enabledTools = new Set();
-        const disabledTools = new Set();
-        const toolSubConfigs = new Map();
-        const errors = [];
-        // Scan all environment variables for TOOL__ patterns
-        for (const [key, value] of Object.entries(process.env)) {
-            if (!key.startsWith('TOOL__'))
-                continue;
-            const parts = key.split('__');
-            if (parts.length === 3) {
-                // TOOL__tool_name__sub_config
-                const toolName = parts[1];
-                const subConfig = parts[2];
-                if (!toolSubConfigs.has(toolName)) {
-                    toolSubConfigs.set(toolName, new Map());
-                }
-                toolSubConfigs.get(toolName).set(subConfig, value === 'true');
-            }
-            else if (parts.length === 2) {
-                // TOOL__tool_name
-                const toolName = parts[1];
-                if (value === 'true') {
-                    enabledTools.add(toolName);
-                }
-                else if (value === 'false') {
-                    disabledTools.add(toolName);
-                }
-                else {
-                    errors.push(`${key}=${value} (must be 'true' or 'false')`);
-                }
-            }
-        }
-        // Error out if invalid values found
-        if (errors.length > 0) {
-            console.error('[CONFIG ERROR] Invalid TOOL_ configuration values:');
-            errors.forEach(error => console.error(`  - ${error}`));
-            console.error('All TOOL_ variables must be set to either "true" or "false"');
-            process.exit(1);
-        }
-        if (enabledTools.size > 0) {
-            console.error(`[CONFIG] Enabled tools (${enabledTools.size}): ${Array.from(enabledTools).sort().join(', ')}`);
-        }
-        else {
-            console.error('[CONFIG] No tools enabled - all tools are disabled by default');
-        }
-        if (disabledTools.size > 0) {
-            console.error(`[CONFIG] Explicitly disabled tools (${disabledTools.size}): ${Array.from(disabledTools).sort().join(', ')}`);
-        }
-        // Log sub-configurations
-        if (toolSubConfigs.size > 0) {
-            console.error('[CONFIG] Tool sub-configurations:');
-            for (const [toolName, subConfigs] of toolSubConfigs) {
-                const subConfigList = Array.from(subConfigs.entries()).map(([key, value]) => `${key}=${value}`);
-                console.error(`  - ${toolName}: ${subConfigList.join(', ')}`);
-            }
-        }
-        return { enabledTools, toolSubConfigs };
+        return yamlConfig.parseToolConfiguration();
     }
 }
 export const config = ConfigManager.getInstance();

package/build/config/index.js

@@ -0,0 +1,158 @@
+/**
+ * Unified configuration system
+ * Combines environment variables and YAML configuration
+ */
+import { z } from 'zod';
+import { readFileSync, existsSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import YAML from 'yaml';
+import { logger } from '../utils/logger.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+// Environment schema
+const EnvironmentSchema = z.object({
+    GROCY_APIKEY_VALUE: z.string().optional(),
+    RELEASE_VERSION: z.string().optional(),
+    NODE_ENV: z.enum(['development', 'production', 'test']).optional(),
+});
+// YAML configuration schema
+const YamlConfigSchema = z.object({
+    server: z.object({
+        enable_http_server: z.boolean().default(false),
+        http_server_port: z.number().min(1).max(65535).default(8080),
+    }).default({}),
+    grocy: z.object({
+        base_url: z.string().url().default('http://localhost:9283'),
+        enable_ssl_verify: z.boolean().default(true),
+        response_size_limit: z.number().positive().default(10000),
+    }).default({}),
+    tools: z.record(z.string(), z.object({
+        enabled: z.boolean().default(false),
+        ack_token: z.string().optional(),
+    }).catchall(z.unknown())).default({}),
+});
+export class ConfigManager {
+    static instance;
+    config;
+    constructor(configPath) {
+        this.config = this.loadConfig(configPath);
+    }
+    static getInstance() {
+        if (!ConfigManager.instance) {
+            ConfigManager.instance = new ConfigManager();
+        }
+        return ConfigManager.instance;
+    }
+    static createForTesting(configPath) {
+        return new ConfigManager(configPath);
+    }
+    loadConfig(configPath) {
+        // Load environment variables
+        const env = this.loadEnvironment();
+        // Load YAML configuration
+        const yaml = this.loadYamlConfig(configPath);
+        return { env, yaml };
+    }
+    loadEnvironment() {
+        try {
+            return EnvironmentSchema.parse(process.env);
+        }
+        catch (error) {
+            if (error instanceof z.ZodError) {
+                logger.error('Invalid environment variables', 'CONFIG');
+                error.errors.forEach(err => {
+                    logger.error(`${err.path.join('.')}: ${err.message}`, 'CONFIG');
+                });
+                process.exit(1);
+            }
+            throw error;
+        }
+    }
+    loadYamlConfig(configPath) {
+        const yamlPath = this.findConfigFile(configPath);
+        try {
+            let configData = {};
+            if (existsSync(yamlPath)) {
+                const yamlContent = readFileSync(yamlPath, 'utf8');
+                configData = YAML.parse(yamlContent) || {};
+                logger.config(`Loaded YAML config from: ${yamlPath}`);
+            }
+            else {
+                logger.config('No YAML config found, using defaults');
+            }
+            return YamlConfigSchema.parse(configData);
+        }
+        catch (error) {
+            if (error instanceof z.ZodError) {
+                logger.error('Invalid YAML configuration', 'CONFIG');
+                error.errors.forEach(err => {
+                    logger.error(`${err.path.join('.')}: ${err.message}`, 'CONFIG');
+                });
+                process.exit(1);
+            }
+            throw error;
+        }
+    }
+    findConfigFile(configPath) {
+        if (configPath)
+            return configPath;
+        // Look for config files in the following order:
+        // 1. Current working directory (for development)
+        // 2. Project root (relative to the compiled main.js)
+        const projectRoot = resolve(__dirname, '../..');
+        const possiblePaths = [
+            resolve(process.cwd(), 'mcp-grocy.yaml'),
+            resolve(process.cwd(), 'mcp-grocy.yml'),
+            resolve(projectRoot, 'mcp-grocy.yaml'),
+            resolve(projectRoot, 'mcp-grocy.yml'),
+        ];
+        return possiblePaths.find(path => existsSync(path)) ?? possiblePaths[0];
+    }
+    // Public getters
+    getConfig() {
+        return this.config;
+    }
+    getGrocyBaseUrl() {
+        return this.config.yaml.grocy.base_url;
+    }
+    getApiUrl() {
+        const baseUrl = this.getGrocyBaseUrl();
+        return baseUrl.endsWith('/') ? `${baseUrl}api` : `${baseUrl}/api`;
+    }
+    hasApiKey() {
+        return !!this.config.env.GROCY_APIKEY_VALUE;
+    }
+    getApiKey() {
+        return this.config.env.GROCY_APIKEY_VALUE;
+    }
+    getCustomHeaders() {
+        const headers = {};
+        if (this.config.env.GROCY_APIKEY_VALUE) {
+            headers['GROCY-API-KEY'] = this.config.env.GROCY_APIKEY_VALUE;
+        }
+        return headers;
+    }
+    parseToolConfiguration() {
+        const enabledTools = new Set();
+        const toolSubConfigs = new Map();
+        for (const [toolName, toolConfig] of Object.entries(this.config.yaml.tools)) {
+            if (toolConfig.enabled) {
+                enabledTools.add(toolName);
+                // Extract sub-configs (everything except standard fields)
+                const subConfigs = new Map();
+                for (const [key, value] of Object.entries(toolConfig)) {
+                    if (!['enabled', 'ack_token'].includes(key)) {
+                        subConfigs.set(key, value);
+                    }
+                }
+                if (subConfigs.size > 0) {
+                    toolSubConfigs.set(toolName, subConfigs);
+                }
+            }
+        }
+        return { enabledTools, toolSubConfigs };
+    }
+}
+// Export singleton instance
+export const config = ConfigManager.getInstance();
+export default config;