mcp-grocy 2.7.0 → 2.7.2

package/build/types/index.js

@@ -0,0 +1,64 @@
+/**
+ * Improved type definitions for better type safety
+ */
+import { z } from 'zod';
+// Configuration types
+export const ConfigSchema = z.object({
+    env: z.object({
+        GROCY_API_KEY: z.string().optional(),
+        RELEASE_VERSION: z.string().optional(),
+        NODE_ENV: z.enum(['development', 'production', 'test']).optional(),
+    }),
+    yaml: z.object({
+        server: z.object({
+            enable_http_server: z.boolean().default(false),
+            http_server_port: z.number().min(1).max(65535).default(8080),
+        }),
+        grocy: z.object({
+            base_url: z.string().url(),
+            enable_ssl_verify: z.boolean().default(true),
+            response_size_limit: z.number().positive().default(10000),
+        }),
+        tools: z.record(z.string(), z
+            .object({
+            enabled: z.boolean().default(false),
+            ack_token: z.string().optional(),
+        })
+            .catchall(z.unknown())),
+    }),
+});
+// Validation schemas for runtime type checking
+export const ToolResultSchema = z.object({
+    success: z.boolean(),
+    data: z.any().optional(),
+    error: z.string().optional(),
+    message: z.string().optional(),
+    details: z.any().optional(),
+});
+export const ToolDefinitionSchema = z.object({
+    name: z.string(),
+    description: z.string(),
+    inputSchema: z.object({
+        type: z.literal('object'),
+        properties: z.record(z.string(), z.any()),
+        required: z.array(z.string()).optional(),
+    }),
+});
+export const ToolModuleSchema = z.object({
+    definitions: z.array(ToolDefinitionSchema),
+    handlers: z.record(z.string(), z.custom((v) => typeof v === 'function')),
+});
+// Type guards
+export function isToolResult(obj) {
+    return ToolResultSchema.safeParse(obj).success;
+}
+export function isToolDefinition(obj) {
+    return ToolDefinitionSchema.safeParse(obj).success;
+}
+export function isToolModule(obj) {
+    return (obj &&
+        typeof obj === 'object' &&
+        Array.isArray(obj.definitions) &&
+        typeof obj.handlers === 'object' &&
+        obj.definitions.every((def) => isToolDefinition(def)));
+}

package/build/utils/errors.js

@@ -0,0 +1,143 @@
+/**
+ * Simplified error handling system
+ */
+import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';
+import { logger } from './logger.js';
+/**
+ * Simplified application error
+ */
+export class AppError extends Error {
+    category;
+    statusCode;
+    operation;
+    details;
+    timestamp = new Date();
+    constructor(message, category, statusCode, operation, details) {
+        super(message);
+        this.name = 'AppError';
+        this.category = category;
+        this.statusCode = statusCode;
+        this.operation = operation;
+        this.details = details;
+        Object.setPrototypeOf(this, AppError.prototype);
+    }
+    toMcpError() {
+        const errorCode = this.getErrorCode();
+        return new McpError(errorCode, this.message);
+    }
+    getErrorCode() {
+        switch (this.category) {
+            case 'VALIDATION':
+                return ErrorCode.InvalidParams;
+            case 'AUTH':
+                return ErrorCode.InvalidRequest;
+            case 'API':
+                if (this.statusCode === 404)
+                    return ErrorCode.InvalidRequest;
+                if (this.statusCode === 401 || this.statusCode === 403)
+                    return ErrorCode.InvalidRequest;
+                return ErrorCode.InternalError;
+            default:
+                return ErrorCode.InternalError;
+        }
+    }
+}
+/**
+ * API-specific error
+ */
+export class ApiError extends AppError {
+    constructor(message, statusCode, operation, details) {
+        super(message, 'API', statusCode, operation, details);
+        this.name = 'ApiError';
+    }
+    static fromAxiosError(error, operation) {
+        if (error.response) {
+            return new ApiError(error.response.data?.message || `HTTP ${error.response.status}`, error.response.status, operation, { url: error.config?.url, method: error.config?.method });
+        }
+        if (error.request) {
+            return new ApiError('Network error - unable to reach server', undefined, operation, {
+                url: error.config?.url,
+            });
+        }
+        return new ApiError(error.message || 'Request error', undefined, operation);
+    }
+}
+/**
+ * Validation error
+ */
+export class ValidationError extends AppError {
+    constructor(message, operation, details) {
+        super(message, 'VALIDATION', undefined, operation, details);
+        this.name = 'ValidationError';
+    }
+}
+/**
+ * Configuration error
+ */
+export class ConfigError extends AppError {
+    constructor(message, operation, details) {
+        super(message, 'CONFIG', undefined, operation, details);
+        this.name = 'ConfigError';
+    }
+}
+/**
+ * Centralized error handler
+ */
+export class ErrorHandler {
+    /**
+     * Handle async operations with error wrapping
+     */
+    static async handleAsync(operation, context) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            this.logError(error, context);
+            throw this.wrapError(error, context);
+        }
+    }
+    /**
+     * Log error with context
+     */
+    static logError(error, context) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const fullContext = context ? `${context}: ${errorMessage}` : errorMessage;
+        if (error instanceof AppError) {
+            logger.warn(fullContext, 'ERROR', {
+                category: error.category,
+                statusCode: error.statusCode,
+                operation: error.operation,
+                details: error.details,
+            });
+        }
+        else {
+            logger.error(fullContext, 'ERROR', { error });
+        }
+    }
+    /**
+     * Wrap unknown errors in AppError
+     */
+    static wrapError(error, context) {
+        if (error instanceof AppError) {
+            return error;
+        }
+        if (error instanceof McpError) {
+            return new AppError(error.message, 'INTERNAL', undefined, context);
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        return new AppError(message, 'INTERNAL', undefined, context);
+    }
+    /**
+     * Convert error to MCP error
+     */
+    static toMcpError(error, fallbackMessage = 'Internal error') {
+        if (error instanceof McpError) {
+            return error;
+        }
+        if (error instanceof AppError) {
+            return error.toMcpError();
+        }
+        const message = error instanceof Error ? error.message : fallbackMessage;
+        return new McpError(ErrorCode.InternalError, message);
+    }
+}

package/build/utils/logger.js

@@ -0,0 +1,142 @@
+/**
+ * Centralized logging utility with configurable levels and structured output
+ */
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["ERROR"] = 0] = "ERROR";
+    LogLevel[LogLevel["WARN"] = 1] = "WARN";
+    LogLevel[LogLevel["INFO"] = 2] = "INFO";
+    LogLevel[LogLevel["DEBUG"] = 3] = "DEBUG";
+    LogLevel[LogLevel["TRACE"] = 4] = "TRACE";
+})(LogLevel || (LogLevel = {}));
+export class Logger {
+    static instance;
+    logLevel;
+    enabledCategories = null;
+    constructor() {
+        // Default to INFO level, but allow override via environment
+        this.logLevel = this.parseLogLevel(process.env.LOG_LEVEL || 'INFO');
+        // Allow filtering by categories
+        const categories = process.env.LOG_CATEGORIES;
+        if (categories) {
+            this.enabledCategories = new Set(categories.split(',').map((c) => c.trim().toUpperCase()));
+        }
+    }
+    static getInstance() {
+        if (!Logger.instance) {
+            Logger.instance = new Logger();
+        }
+        return Logger.instance;
+    }
+    parseLogLevel(level) {
+        const upperLevel = level.toUpperCase();
+        switch (upperLevel) {
+            case 'ERROR':
+                return LogLevel.ERROR;
+            case 'WARN':
+                return LogLevel.WARN;
+            case 'INFO':
+                return LogLevel.INFO;
+            case 'DEBUG':
+                return LogLevel.DEBUG;
+            case 'TRACE':
+                return LogLevel.TRACE;
+            default:
+                return LogLevel.INFO;
+        }
+    }
+    shouldLog(level, category) {
+        // Check log level
+        if (level > this.logLevel) {
+            return false;
+        }
+        // Check category filter
+        if (this.enabledCategories && category) {
+            return this.enabledCategories.has(category.toUpperCase());
+        }
+        return true;
+    }
+    formatMessage(entry) {
+        const timestamp = entry.timestamp.toISOString();
+        const level = LogLevel[entry.level].padEnd(5);
+        const category = entry.category ? `[${entry.category}]` : '';
+        const data = entry.data ? ` ${JSON.stringify(entry.data)}` : '';
+        return `${timestamp} ${level} ${category} ${entry.message}${data}`;
+    }
+    log(level, message, category, data) {
+        if (!this.shouldLog(level, category)) {
+            return;
+        }
+        const entry = {
+            level,
+            message,
+            category: category || undefined,
+            data,
+            timestamp: new Date(),
+        };
+        const formattedMessage = this.formatMessage(entry);
+        // Use stderr for all logs to avoid interfering with MCP stdio protocol
+        console.error(formattedMessage);
+    }
+    error(message, category, data) {
+        this.log(LogLevel.ERROR, message, category, data);
+    }
+    warn(message, category, data) {
+        this.log(LogLevel.WARN, message, category, data);
+    }
+    info(message, category, data) {
+        this.log(LogLevel.INFO, message, category, data);
+    }
+    debug(message, category, data) {
+        this.log(LogLevel.DEBUG, message, category, data);
+    }
+    trace(message, category, data) {
+        this.log(LogLevel.TRACE, message, category, data);
+    }
+    // Convenience methods for common categories
+    config(message, data) {
+        this.info(message, 'CONFIG', data);
+    }
+    api(message, data) {
+        this.debug(message, 'API', data);
+    }
+    module(message, data) {
+        this.debug(message, 'MODULE', data);
+    }
+    tools(message, data) {
+        this.info(message, 'TOOLS', data);
+    }
+    server(message, data) {
+        this.info(message, 'SERVER', data);
+    }
+    // Testing utilities
+    setLogLevel(level) {
+        this.logLevel = level;
+    }
+    setEnabledCategories(categories) {
+        this.enabledCategories = categories ? new Set(categories.map((c) => c.toUpperCase())) : null;
+    }
+}
+// Export singleton instance
+export const logger = Logger.getInstance();
+// Convenience function for quick logging
+export function log(level, message, category, data) {
+    // Access the private log method through the public methods
+    switch (level) {
+        case LogLevel.ERROR:
+            logger.error(message, category, data);
+            break;
+        case LogLevel.WARN:
+            logger.warn(message, category, data);
+            break;
+        case LogLevel.INFO:
+            logger.info(message, category, data);
+            break;
+        case LogLevel.DEBUG:
+            logger.debug(message, category, data);
+            break;
+        case LogLevel.TRACE:
+            logger.trace(message, category, data);
+            break;
+    }
+}

package/build/version.js

@@ -1,4 +1,4 @@
 // Auto-generated file - DO NOT MODIFY
-export const VERSION = '2.5.0';
+export const VERSION = '2.7.2';
 export const PACKAGE_NAME = 'mcp-grocy';
 export const SERVER_NAME = 'mcp-grocy';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-grocy",
-  "version": "2.7.0",
+  "version": "2.7.2",
   "description": "Model Context Protocol (MCP) server for Grocy integration",
   "license": "MIT",
   "type": "module",
@@ -20,6 +20,7 @@
   "scripts": {
     "prebuild": "node scripts/build.js",
     "build": "tsc",
+    "prepack": "npm run build",
     "type-check": "tsc --noEmit",
     "prepare": "husky",
     "start": "node build/main.js",
@@ -27,7 +28,7 @@
     "watch": "tsc --watch",
     "inspector": "npx @modelcontextprotocol/inspector build/main.js",
     "test": "vitest run",
-    "test:mcp-validator": "bash scripts/run-mcp-validator.sh",
+    "test:mcp-inspector": "bash scripts/run-mcp-inspector.sh",
     "dev:mcp-tef": "bash scripts/run-mcp-tef.sh",
     "report:mcp-tef": "bash scripts/mcp-tef-report.sh",
     "start:mcp-http-test": "bash scripts/start-mcp-http-for-tests.sh",
@@ -48,38 +49,39 @@
     "prepare-dev-release:dryrun": "node scripts/prepare-dev-release.js --dry-run"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.28.0",
-    "axios": "^1.13.6",
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "axios": "^1.20.0",
     "cors": "^2.8.6",
-    "dotenv": "^17.3.1",
+    "dotenv": "^17.4.2",
     "express": "^5.2.1",
-    "fuse.js": "^7.1.0",
-    "yaml": "^2.8.3",
-    "zod": "^4.3.6"
+    "fuse.js": "^7.5.0",
+    "yaml": "^2.9.0",
+    "zod": "^4.6.1"
   },
   "devDependencies": {
-    "@commitlint/cli": "^20.5.0",
-    "@commitlint/config-conventional": "^20.5.0",
-    "@commitlint/types": "^20.5.0",
-    "@eslint/js": "^9.39.4",
-    "@semantic-release/changelog": "^6.0.3",
+    "@commitlint/cli": "^21.2.2",
+    "@commitlint/config-conventional": "^21.2.2",
+    "@commitlint/types": "^21.2.0",
+    "@eslint/js": "^10.0.1",
+    "@modelcontextprotocol/inspector": "^2.6.0",
+    "@semantic-release/changelog": "^7.0.0",
     "@semantic-release/exec": "^7.1.0",
-    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/git": "^11.0.1",
     "@types/cors": "^2.8.19",
     "@types/express": "^5.0.6",
-    "@types/node": "^22.15.0",
-    "@types/yaml": "^1.9.6",
-    "eslint": "^9.39.4",
+    "@types/node": "^22.20.2",
+    "eslint": "^10.10.0",
     "eslint-config-prettier": "^10.1.8",
-    "fs-extra": "^11.3.4",
+    "fs-extra": "^11.4.0",
     "husky": "^9.1.7",
-    "lint-staged": "^17.0.8",
-    "prettier": "^3.8.1",
-    "semantic-release": "^25.0.3",
-    "ts-node": "^10.9.1",
+    "lint-staged": "^17.5.1",
+    "prettier": "^3.9.6",
+    "semantic-release": "^25.0.9",
+    "ts-node": "^10.9.2",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.57.2",
-    "vitest": "^4.1.2"
+    "typescript-eslint": "^8.70.0",
+    "vite": "^8.3.0",
+    "vitest": "^5.0.0"
   },
   "keywords": [
     "grocy",
@@ -105,7 +107,7 @@
     "node": ">=22.0.0"
   },
   "config": {
-    "supportedGrocyVersion": "4.5.0"
+    "supportedGrocyVersion": "4.7.1"
   },
   "lint-staged": {
     "*.{ts,js,mjs,cjs}": [