@marcelo-ochoa/server-qnap 1.0.1

package/.dockerignore

@@ -0,0 +1,6 @@
+node_modules
+dist
+*.ts
+tsconfig.json
+Dockerfile
+.dockerignore

package/CHANGELOG.md

@@ -0,0 +1,29 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [1.0.1] - 2026-02-09
+
+### Changed
+- **Major refactoring for improved maintainability**: Restructured codebase following MySQL MCP server patterns
+  - Separated tool handlers into individual files in `tools/` directory (`connect.ts`, `report.ts`, `dir.ts`, `file_info.ts`)
+  - Simplified `handlers.ts` to act as a clean dispatcher using a handler registry pattern
+  - Refactored `tools.ts` to use array-based tool definitions for consistency
+  - Updated `server.ts` to use the new handler dispatcher
+  - Improved code organization with better separation of concerns
+  - Enhanced error handling and validation in individual tool handlers
+  - Added connection state management helper functions
+
+### Added
+- **Prompts array support**: Added prompts capability following MikroTik MCP server pattern
+  - Implemented `prompts/list` request handler for better tool discoverability
+  - Added prompts for all available tools: `qnap-connect`, `qnap-report`, `qnap-dir`, `qnap-file-info`
+  - Enhanced server capabilities to include prompts interface
+
+## [1.0.0] - 2026-01-27
+
+### Added
+- Initial implementation of the QNAP MCP server.
+- Tools: `qnap-connect`, `qnap-report`, `qnap-dir`, `qnap-file-info`.
+- Support for QTS Legacy CGI API.
+

package/Demos.md

@@ -0,0 +1,172 @@
+# Demos
+
+Some sample usage scenarios are shown below:
+
+## Usage with Claude Desktop
+
+To use this server with the Claude Desktop app, add the following configuration to the "mcpServers" section of your `claude_desktop_config.json`:
+
+### Docker
+
+* when running docker on macOS, use `host.docker.internal` if the server is running on the host network (eg localhost)
+* Credentials are passed via environment variables `QNAP_USER` and `QNAP_PASSWORD`
+
+```json
+{
+  "mcpServers": {
+    "qnap": {
+      "command": "docker",
+      "args": [
+        "run", 
+        "-i", 
+        "--rm", 
+        "-e",
+        "QNAP_USER=admin",
+        "-e",
+        "QNAP_PASSWORD=password",
+        "mochoa/mcp-qnap", 
+        "http://10.1.1.241:8080"]
+    }
+  }
+}
+```
+
+### NPX
+
+```json
+{
+  "mcpServers": {
+    "qnap": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@marcelo-ochoa/server-qnap",
+        "http://10.1.1.241:8080"
+      ],
+      "env": {
+        "QNAP_USER": "admin",
+        "QNAP_PASSWORD": "password"
+      }
+    }
+  }
+}
+```
+
+### Demo Prompts
+
+Sample prompts using above server.
+
+- qnap-connect http://10.1.1.241:8080 admin password
+- qnap-report
+- qnap-dir /Public
+- qnap-file-info /Public/test.txt
+- analyze backup files in several subdirectories of `/backup/stacks` on the QNAP NAS. For each subdirectory compare the two most recent backups (daily or weekly, identified by filenames like `alldb_backup-2.sql.gz` for weekly and `alldb_backup-09.sql.gz` for daily). The comparison should be based on file size, considering backups with similar sizes as correct. Generate a report indicating the status (OK or Error) for each directory based on this comparison.
+
+### Backup Analysis Report Example
+
+Busing information about files of sub-folders from qnap-dir /backup/stacks
+   - ayudarg
+   - glpi
+   - invop
+   - kanboard
+   - mon
+   - moodle
+   - mygis
+   - ocular-vet
+   - patogis
+   - piexa
+   - web
+   - yact
+   files into above sub-dirs are backups daily or weekly, for example: alldb_backup-2.sql.gz (meaning last backup of week 2 of current month) alldb_backup-09.sql.gz (meaning last daily backup) in some folder there are weekly backups and other are daily backups. please compare last (weekly/daily) with the previous one sorted descending by modification date using the size information of the file. A correct backup will be similar in size, for example 31.41 Mb and 31.33Mb. Make report with directories with status of the backups showing OK or Error based on explained failed.
+
+I have verified the two most recent backup files for each directory, comparing their timestamps and file sizes. "Similar size" is interpreted as a difference of less than 5%, which indicates a successful backup chain.
+
+#### QNAP Backup Status Report
+**Date:** 2026-02-09
+
+| Directory | Frequency | Latest Backup | Previous Backup | Size Comparison | Status |
+| :--- | :--- | :--- | :--- | :--- | :--- |
+| **ayudarg** | Weekly | `alldb_backup-2.sql.gz`<br>(Feb 08, 868.7 KB) | `alldb_backup-1.sql.gz`<br>(Feb 01, 868.7 KB) | Diff: 2 bytes (~0%) | **OK** |
+| **glpi** | Daily | `alldb_backup-09.sql.gz`<br>(Feb 09, 32.9 MB) | `alldb_backup-08.sql.gz`<br>(Feb 08, 32.8 MB) | Diff: ~89 KB (~0.2%) | **OK** |
+| **invop** | Weekly | `alldb_backup-2.sql.gz`<br>(Feb 08, 1.41 MB) | `alldb_backup-1.sql.gz`<br>(Feb 01, 1.41 MB) | Diff: 1 byte (~0%) | **OK** |
+| **kanboard** | Daily | `alldb_backup-09.sql.gz`<br>(Feb 09, 2.97 MB) | `alldb_backup-08.sql.gz`<br>(Feb 08, 2.92 MB) | Diff: ~45 KB (~1.5%) | **OK** |
+| **mon** | Weekly | `alldb_backup-2.sql.gz`<br>(Feb 08, 33.6 MB) | `alldb_backup-1.sql.gz`<br>(Feb 01, 33.7 MB) | Diff: ~117 KB (~0.3%) | **OK** |
+| **moodle** | Daily | `full-backup-09.sql.gz`<br>(Feb 09, 654 MB) | `full-backup-08.sql.gz`<br>(Feb 08, 653 MB) | Diff: ~234 KB (~0.03%) | **OK** |
+| **mygis** | Weekly | `full-backup-2.dump`<br>(Feb 08, 314 KB) | `full-backup-1.dump`<br>(Feb 01, 314 KB) | Diff: 0 bytes (0%) | **OK** |
+| **ocular-vet** | Weekly | `backup-OcularVetDB-2.dump`<br>(Feb 08, 251 KB) | `backup-OcularVetDB-1.dump`<br>(Feb 01, 251 KB) | Diff: ~623 bytes (0.2%) | **OK** |
+| **patogis** | Weekly | `full-backup-2.dump`<br>(Feb 08, 438 KB) | `full-backup-1.dump`<br>(Feb 01, 438 KB) | Diff: 0 bytes (0%) | **OK** |
+| **piexa** | Daily | `full-backup-09.sql.gz`<br>(Feb 09, 162 MB) | `full-backup-08.sql.gz`<br>(Feb 08, 163 MB) | Diff: ~2.2 MB (~0.1%) | **OK** |
+| **web** | Daily | `wordpress_backup-09.sql.gz`<br>(Feb 09, 23.8 MB) | `wordpress_backup-08.sql.gz`<br>(Feb 08, 23.8 MB) | Diff: ~12 KB (~0.05%) | **OK** |
+| **yact** | Weekly | `backup-YactDB-2.gz`<br>(Feb 08, 2.14 MB) | `backup-YactDB-1.gz`<br>(Feb 01, 2.14 MB) | Diff: 0 bytes (0%) | **OK** |
+
+#### Summary
+All analyzed directories show consistent backup sizes and up-to-date timestamps (Feb 08 for weekly, Feb 09 for daily). No errors were detected.
+
+## Using Gemini CLI
+
+[Gemini CLI](https://github.com/google-gemini/gemini-cli/) 
+is an open-source AI agent that brings the power of Gemini directly
+into your terminal. It provides lightweight access to Gemini, giving you the
+most direct path from your prompt to our model.
+
+Using this sample settings.json file at ~/.gemini/ directory:
+
+```json
+{
+  "mcpServers": {
+    "qnap": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@marcelo-ochoa/server-qnap",
+        "http://10.1.1.241:8080"
+      ],
+      "env": {
+        "QNAP_USER": "admin",
+        "QNAP_PASSWORD": "password"
+      }
+    }
+  },
+  "security": {
+    "auth": {
+      "selectedType": "gemini-api-key"
+    }
+  },
+  "ui": {
+    "theme": "ANSI"
+  },
+  "selectedAuthType": "gemini-api-key",
+  "theme": "Dracula"
+}
+```
+
+### Sample prompts with Gemini CLI
+
+- qnap-connect to http://10.1.1.241:8080 using admin as user and password as password using qnap mcp server
+- qnap-report
+- analyze backup files in several subdirectories of `/backup/stacks` on the QNAP NAS. For each subdirectory compare the two most recent backups (daily or weekly, identified by filenames like `alldb_backup-2.sql.gz` for weekly and `alldb_backup-09.sql.gz` for daily). The comparison should be based on file size, considering backups with similar sizes as correct. Generate a report indicating the status (OK or Error) for each directory based on this comparison.
+
+## Using Antigravity Code Editor
+
+Put this in `~/.gemini/antigravity/mcp_config.json`
+
+```json
+{
+    "mcpServers": {
+        "qnap": {
+      "command": "docker",
+      "args": [
+        "run", 
+        "-i", 
+        "--rm", 
+        "-e",
+        "QNAP_USER=admin",
+        "-e",
+        "QNAP_PASSWORD=password",
+        "mochoa/mcp-qnap", 
+        "http://10.1.1.241:8080"
+      ]
+    }
+  }
+}
+```

package/Dockerfile

@@ -0,0 +1,29 @@
+FROM node:slim AS builder
+
+COPY src/qnap /app
+COPY tsconfig.json /tsconfig.json
+
+WORKDIR /app
+
+RUN --mount=type=cache,target=/root/.npm npm install
+
+RUN npm run build
+
+RUN --mount=type=cache,target=/root/.npm-production npm ci --ignore-scripts --omit-dev
+
+FROM node:slim AS release
+
+# Update and upgrade to fix OS-level vulnerabilities
+RUN apt-get update && apt-get upgrade -y && rm -rf /var/lib/apt/lists/*
+
+COPY --from=builder /app/dist /app/dist
+COPY --from=builder /app/package.json /app/package.json
+COPY --from=builder /app/package-lock.json /app/package-lock.json
+
+ENV NODE_ENV=production
+
+WORKDIR /app
+
+RUN npm ci --ignore-scripts --omit-dev
+
+ENTRYPOINT ["node", "dist/index.js"]

package/README.md

@@ -0,0 +1,89 @@
+# QNAP MCP Server
+
+An MCP server implementation for QNAP NAS devices, providing tools to monitor system status, manage files, and generate reports.
+
+## Tools
+
+- `qnap-connect`: Connect to a QNAP NAS and obtain a session ID.
+  - `host`: The QNAP NAS URL (e.g., `http://10.1.1.241:8080`).
+  - `username`: Your admin username.
+  - `password`: Your admin password.
+- `qnap-report`: Generate a system report including CPU, memory, disks, and volume status.
+- `qnap-dir`: List the contents of a directory.
+  - `path`: The path to list (e.g., `/Public`).
+- `qnap-file-info`: Get detailed information about a specific file.
+  - `path`: The directory path.
+  - `filename`: The name of the file.
+
+## Configuration
+
+### Environment Variables
+
+The server can use environment variables and startup arguments for automatic connection:
+
+- **`QNAP_USER`**: QNAP admin username.
+- **`QNAP_PASSWORD`**: QNAP admin password.
+
+### Startup Arguments
+
+1. **`host`**: (Optional) URL of the QNAP NAS (e.g., `http://10.1.1.241:8080`).
+
+If the host and environment variables are provided, the server will attempt to connect automatically at startup.
+
+### Usage with Claude Desktop
+
+Add the following to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "qnap": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@marcelo-ochoa/server-qnap",
+        "http://10.1.1.241:8080"
+      ],
+      "env": {
+        "QNAP_USER": "admin",
+        "QNAP_PASSWORD": "password"
+      }
+    }
+  }
+}
+```
+
+## Development
+
+```bash
+cd src/qnap
+npm install
+npm run build
+```
+
+
+## Demos
+
+See [Demos](https://github.com/marcelo-ochoa/servers/blob/main/src/qnap/Demos.md) for usage examples with Claude Desktop, Gemini CLI, and Antigravity Code Editor.
+
+## Docker
+
+Building the container:
+
+```bash
+docker build -t mochoa/mcp-qnap -f src/qnap/Dockerfile .
+```
+
+Running the container:
+
+```bash
+docker run -i --rm -e QNAP_USER=admin -e QNAP_PASSWORD=password mochoa/mcp-qnap http://10.1.1.241:8080
+```
+
+## Change Log
+
+See [Change Log](CHANGELOG.md) for the history of changes.
+
+## License
+
+MIT

package/REFACTORING.md

@@ -0,0 +1,139 @@
+# QNAP MCP Server Refactoring Summary
+
+## Overview
+The QNAP MCP server has been refactored to follow the same architectural patterns as the MySQL MCP server, improving code organization, maintainability, and readability.
+
+## Changes Made
+
+### 1. Tool Handlers Separation (`tools/` directory)
+Created individual handler files for each tool, following the single responsibility principle:
+
+- **`tools/connect.ts`**: Handles QNAP NAS connection and authentication
+  - Manages connection state (host and session ID)
+  - Provides helper functions: `getNasHost()`, `getNasSid()`, `setNasConnection()`, `clearNasConnection()`
+  - Exports `fetchWithTimeout()` for use by other handlers
+  - Implements `connectHandler()` for the `qnap-connect` tool
+  - Implements `initializeApi()` for programmatic connection
+
+- **`tools/report.ts`**: Generates QNAP system reports
+  - Implements `reportHandler()` for the `qnap-report` tool
+  - Fetches system information and formats connection details
+
+- **`tools/dir.ts`**: Lists directory contents
+  - Implements `dirHandler()` for the `qnap-dir` tool
+  - Handles directory listing via QNAP file manager API
+
+- **`tools/file_info.ts`**: Retrieves file information
+  - Implements `fileInfoHandler()` for the `qnap-file-info` tool
+  - Fetches detailed file metadata
+
+### 2. Handler Dispatcher Pattern (`handlers.ts`)
+Simplified the handlers file to act as a clean dispatcher:
+
+```typescript
+const toolHandlers: Record<string, (request: CallToolRequest) => Promise<any>> = {
+    "qnap-connect": connectHandler,
+    "qnap-report": reportHandler,
+    "qnap-dir": dirHandler,
+    "qnap-file-info": fileInfoHandler,
+};
+
+export const callToolHandler = async (request: CallToolRequest) => {
+    const handler = toolHandlers[request.params.name];
+    if (handler) {
+        return handler(request);
+    }
+    throw new Error(`Unknown tool: ${request.params.name}`);
+};
+```
+
+### 3. Tool Definitions (`tools.ts`)
+Refactored to use a simple array-based structure matching MySQL pattern:
+
+**Before:**
+```typescript
+export const QNAP_CONNECT_TOOL: Tool = { ... };
+export const QNAP_REPORT_TOOL: Tool = { ... };
+export const TOOLS = [QNAP_CONNECT_TOOL, QNAP_REPORT_TOOL, ...];
+```
+
+**After:**
+```typescript
+export const tools = [
+    { name: "qnap-connect", description: "...", inputSchema: {...} },
+    { name: "qnap-report", description: "...", inputSchema: {...} },
+    ...
+];
+```
+
+### 4. Server Updates (`server.ts`)
+Updated to use the new dispatcher pattern:
+
+**Before:**
+```typescript
+switch (request.params.name) {
+    case "qnap-connect":
+        return await handleConnect(request.params.arguments);
+    case "qnap-report":
+        return await handleReport();
+    ...
+}
+```
+
+**After:**
+```typescript
+return await callToolHandler(request);
+```
+
+## Benefits
+
+1. **Better Code Organization**: Each tool has its own file with focused responsibility
+2. **Improved Maintainability**: Changes to one tool don't affect others
+3. **Consistent Patterns**: Follows the same structure as MySQL MCP server
+4. **Enhanced Readability**: Smaller, focused files are easier to understand
+5. **Better Error Handling**: Each handler validates its own inputs
+6. **Easier Testing**: Individual handlers can be tested in isolation
+7. **Scalability**: Adding new tools is straightforward - just create a new handler file and register it
+
+## File Structure Comparison
+
+### Before:
+```
+src/qnap/
+├── handlers.ts (183 lines - all logic inline)
+├── tools.ts (58 lines - individual constants)
+├── server.ts (84 lines - switch statement)
+└── tools/
+    └── qnap_report_collector.py
+```
+
+### After:
+```
+src/qnap/
+├── handlers.ts (24 lines - clean dispatcher)
+├── tools.ts (66 lines - array-based)
+├── server.ts (70 lines - uses dispatcher)
+└── tools/
+    ├── connect.ts (connection logic + state management)
+    ├── report.ts (report generation)
+    ├── dir.ts (directory listing)
+    ├── file_info.ts (file information)
+    └── qnap_report_collector.py
+```
+
+## Migration Notes
+
+- All existing functionality is preserved
+- No breaking changes to the API
+- Connection state is now managed through helper functions
+- Each handler validates its own inputs and returns consistent error structures
+- Build process remains unchanged (`npm run build`)
+
+## Next Steps
+
+Consider these future enhancements:
+1. Add TypeScript interfaces for QNAP API responses
+2. Implement unit tests for individual handlers
+3. Add more comprehensive error messages
+4. Consider adding retry logic for network operations
+5. Add logging/debugging capabilities

package/dist/handlers.js

@@ -0,0 +1,18 @@
+import { connectHandler, initializeApi } from "./tools/connect.js";
+import { reportHandler } from "./tools/report.js";
+import { dirHandler } from "./tools/dir.js";
+import { fileInfoHandler } from "./tools/file_info.js";
+const toolHandlers = {
+    "qnap-connect": connectHandler,
+    "qnap-report": reportHandler,
+    "qnap-dir": dirHandler,
+    "qnap-file-info": fileInfoHandler,
+};
+export const callToolHandler = async (request) => {
+    const handler = toolHandlers[request.params.name];
+    if (handler) {
+        return handler(request);
+    }
+    throw new Error(`Unknown tool: ${request.params.name}`);
+};
+export { initializeApi };

package/dist/index.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { QnapServer } from "./server.js";
+const server = new QnapServer();
+server.run().catch((error) => {
+    console.error("Fatal error running server:", error);
+    process.exit(1);
+});

package/dist/server.js

@@ -0,0 +1,69 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+import { tools } from "./tools.js";
+import { callToolHandler, initializeApi } from "./handlers.js";
+const prompts = [
+    { name: "qnap-connect: Connect to QNAP NAS", description: "connect to QNAP NAS using host, username and password" },
+    { name: "qnap-report: System Report", description: "show a comprehensive system report with CPU, memory, and disk status" },
+    { name: "qnap-dir: List Directory", description: "list contents of a directory on the QNAP NAS" },
+    { name: "qnap-file-info: File Information", description: "get detailed information about a specific file" }
+];
+const PromptsListRequestSchema = z.object({
+    method: z.literal("prompts/list"),
+    params: z.object({}),
+});
+export class QnapServer {
+    server;
+    constructor() {
+        this.server = new Server({
+            name: "qnap-mcp-server",
+            version: "1.0.1",
+        }, {
+            capabilities: {
+                tools: {},
+                prompts: {},
+            },
+        });
+        this.setupHandlers();
+        this.server.onerror = (error) => console.error("[MCP Error]", error);
+    }
+    setupHandlers() {
+        this.server.setRequestHandler(PromptsListRequestSchema, async () => {
+            return {
+                prompts,
+            };
+        });
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+            tools: tools,
+        }));
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            return await callToolHandler(request);
+        });
+    }
+    async run() {
+        const args = process.argv.slice(2);
+        const host = args[0];
+        if (host) {
+            try {
+                await initializeApi(host);
+                console.error(`Automatically connected to QNAP NAS at ${host}`);
+            }
+            catch (error) {
+                console.error(`Failed to automatically connect to QNAP NAS: ${error.message}`);
+            }
+        }
+        else {
+            console.error("Warning: No QNAP host provided as argument. Use qnap-connect tool before using other functionality.");
+        }
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        console.error("QNAP MCP server running on stdio");
+        process.stdin.on("close", () => {
+            console.error("QNAP MCP Server closed");
+            this.server.close();
+            process.exit(0);
+        });
+    }
+}

package/dist/tools/connect.js

@@ -0,0 +1,106 @@
+let nas_host = null;
+let nas_sid = null;
+export function getNasHost() {
+    return nas_host;
+}
+export function getNasSid() {
+    return nas_sid;
+}
+export function setNasConnection(host, sid) {
+    nas_host = host;
+    nas_sid = sid;
+}
+export function clearNasConnection() {
+    nas_host = null;
+    nas_sid = null;
+}
+export async function initializeApi(host, username, password) {
+    const user = username || process.env.QNAP_USER;
+    const pwd = password || process.env.QNAP_PASSWORD;
+    if (!user || !pwd) {
+        throw new Error("Credentials not provided and QNAP_USER/QNAP_PASSWORD env variables not set.");
+    }
+    // Directly perform the connection logic
+    const b64_pwd = Buffer.from(pwd).toString('base64');
+    const url = `${host}/cgi-bin/authLogin.cgi?user=${user}&pwd=${b64_pwd}`;
+    try {
+        const response = await fetchWithTimeout(url);
+        const text = await response.text();
+        // Extract SID using regex
+        const sidMatch = text.match(/<authSid><!\[CDATA\[([^\]]*)\]\]><\/authSid>/);
+        const sid = sidMatch ? sidMatch[1] : null;
+        if (sid) {
+            setNasConnection(host, sid);
+        }
+        else {
+            throw new Error(`Login failed. Response: ${text}`);
+        }
+    }
+    catch (error) {
+        throw new Error(`Error connecting to QNAP: ${error.message}`);
+    }
+}
+async function fetchWithTimeout(url, options = {}, timeout = 60000) {
+    const controller = new AbortController();
+    const id = setTimeout(() => controller.abort(), timeout);
+    const headers = {
+        ...options.headers,
+        'Referer': nas_host ? `${nas_host}/cgi-bin/index.cgi` : '',
+    };
+    if (nas_sid) {
+        headers['Cookie'] = `NAS_SID=${nas_sid}`;
+    }
+    try {
+        const response = await fetch(url, {
+            ...options,
+            headers,
+            signal: controller.signal
+        });
+        clearTimeout(id);
+        return response;
+    }
+    catch (error) {
+        clearTimeout(id);
+        throw error;
+    }
+}
+export async function connectHandler(request) {
+    const { host, username, password } = request.params.arguments || {};
+    if (typeof host !== "string" || !host ||
+        typeof username !== "string" || !username ||
+        typeof password !== "string" || !password) {
+        return {
+            content: [{ type: "text", text: "Missing or invalid host, username, or password argument." }],
+            isError: true,
+        };
+    }
+    const b64_pwd = Buffer.from(password).toString('base64');
+    const url = `${host}/cgi-bin/authLogin.cgi?user=${username}&pwd=${b64_pwd}`;
+    try {
+        const response = await fetchWithTimeout(url);
+        const text = await response.text();
+        // Extract SID using regex
+        const sidMatch = text.match(/<authSid><!\[CDATA\[([^\]]*)\]\]><\/authSid>/);
+        const sid = sidMatch ? sidMatch[1] : null;
+        if (sid) {
+            setNasConnection(host, sid);
+            return {
+                content: [{ type: "text", text: `Connected successfully to ${host}. SID: ${sid}` }],
+                isError: false,
+            };
+        }
+        else {
+            return {
+                content: [{ type: "text", text: `Login failed. Response: ${text}` }],
+                isError: true
+            };
+        }
+    }
+    catch (error) {
+        return {
+            content: [{ type: "text", text: `Error connecting to QNAP: ${error.message}` }],
+            isError: true
+        };
+    }
+}
+export { fetchWithTimeout };