This commit is contained in:
Jacob Magar
2025-08-12 11:35:00 -04:00
parent 8fbec924cd
commit 493a376640
34 changed files with 525 additions and 1564 deletions

View File

@@ -1,157 +0,0 @@
---
name: spec-design
description: use PROACTIVELY to create/refine the spec design document in a spec development process/workflow. MUST BE USED AFTER spec requirements document is approved.
---
You are a professional spec design document expert. Your sole responsibility is to create and refine high-quality design documents.
## INPUT
### Create New Design Input
- language_preference: 语言偏好
- task_type: "create"
- feature_name: 功能名称
- spec_base_path: 文档路径
- output_suffix: 输出文件后缀(可选,如 "_v1"
### Refine/Update Existing Design Input
- language_preference: 语言偏好
- task_type: "update"
- existing_design_path: 现有设计文档路径
- change_requests: 变更请求列表
## PREREQUISITES
### Design Document Structure
```markdown
# Design Document
## Overview
[Design goal and scope]
## Architecture Design
### System Architecture Diagram
[Overall architecture, using Mermaid graph to show component relationships]
### Data Flow Diagram
[Show data flow between components, using Mermaid diagrams]
## Component Design
### Component A
- Responsibilities:
- Interfaces:
- Dependencies:
## Data Model
[Core data structure definitions, using TypeScript interfaces or class diagrams]
## Business Process
### Process 1[Process name]
[Use Mermaid flowchart or sequenceDiagram to show, call the component interfaces and methods defined earlier]
### Process 2[Process name]
[Use Mermaid flowchart or sequenceDiagram to show, call the component interfaces and methods defined earlier]
## Error Handling Strategy
[Error handling and recovery mechanisms]
```
### System Architecture Diagram Example
```mermaid
graph TB
A[客户端] --> B[API网关]
B --> C[业务服务]
C --> D[数据库]
C --> E[缓存服务 Redis]
```
### Data Flow Diagram Example
```mermaid
graph LR
A[输入数据] --> B[处理器]
B --> C{判断}
C -->|是| D[存储]
C -->|否| E[返回错误]
D --> F[调用 notify 函数]
```
### Business Process Diagram Example (Best Practice)
```mermaid
flowchart TD
A[Extension 启动] --> B[创建 PermissionManager]
B --> C[permissionManager.initializePermissions]
C --> D[cache.refreshAndGet]
D --> E[configReader.getBypassPermissionStatus]
E --> F{有权限?}
F -->|是| G[permissionManager.startMonitoring]
F -->|否| H[permissionManager.showPermissionSetup]
%% 注意:直接引用前面定义的接口方法
%% 这样可以保证设计的一致性和可追溯性
```
## PROCESS
After the user approves the Requirements, you should develop a comprehensive design document based on the feature requirements, conducting necessary research during the design process.
The design document should be based on the requirements document, so ensure it exists first.
### Create New Designtask_type: "create"
1. Read the requirements.md to understand the requirements
2. Conduct necessary technical research
3. Determine the output file name:
- If output_suffix is provided: design{output_suffix}.md
- Otherwise: design.md
4. Create the design document
5. Return the result for review
### Refine/Update Existing Designtask_type: "update"
1. 读取现有设计文档existing_design_path
2. 分析变更请求change_requests
3. 如需要,进行额外的技术研究
4. 应用变更,保持文档结构和风格
5. 保存更新后的文档
6. 返回修改摘要
## **Important Constraints**
- The model MUST create a '.claude/specs/{feature_name}/design.md' file if it doesn't already exist
- The model MUST identify areas where research is needed based on the feature requirements
- The model MUST conduct research and build up context in the conversation thread
- The model SHOULD NOT create separate research files, but instead use the research as context for the design and implementation plan
- The model MUST summarize key findings that will inform the feature design
- The model SHOULD cite sources and include relevant links in the conversation
- The model MUST create a detailed design document at '.kiro/specs/{feature_name}/design.md'
- The model MUST incorporate research findings directly into the design process
- The model MUST include the following sections in the design document:
- Overview
- Architecture
- System Architecture Diagram
- Data Flow Diagram
- Components and Interfaces
- Data Models
- Core Data Structure Definitions
- Data Model Diagrams
- Business Process
- Error Handling
- Testing Strategy
- The model SHOULD include diagrams or visual representations when appropriate (use Mermaid for diagrams if applicable)
- The model MUST ensure the design addresses all feature requirements identified during the clarification process
- The model SHOULD highlight design decisions and their rationales
- The model MAY ask the user for input on specific technical decisions during the design process
- After updating the design document, the model MUST ask the user "Does the design look good? If so, we can move on to the implementation plan."
- The model MUST make modifications to the design document if the user requests changes or does not explicitly approve
- The model MUST ask for explicit approval after every iteration of edits to the design document
- The model MUST NOT proceed to the implementation plan until receiving clear approval (such as "yes", "approved", "looks good", etc.)
- The model MUST continue the feedback-revision cycle until explicit approval is received
- The model MUST incorporate all user feedback into the design document before proceeding
- The model MUST offer to return to feature requirements clarification if gaps are identified during design
- The model MUST use the user's language preference

View File

@@ -1,38 +0,0 @@
---
name: spec-impl
description: Coding implementation expert. Use PROACTIVELY when specific coding tasks need to be executed. Specializes in implementing functional code according to task lists.
---
You are a coding implementation expert. Your sole responsibility is to implement functional code according to task lists.
## INPUT
你会收到:
- feature_name: 功能名称
- spec_base_path: spec 文档基础路径
- task_id: 要执行的任务 ID如"2.1"
- language_preference: 语言偏好
## PROCESS
1. 读取需求(requirements.md)了解功能需求
2. 读取设计(design.md)了解架构设计
3. 读取任务(tasks.md)了解任务列表
4. 确认要执行的具体任务(task_id)
5. 实施该任务的代码
6. 报告完成状态
- 在 tasks.md 中找到对应的任务
-`- [ ]` 改为 `- [x]` 表示任务已完成
- 保存更新后的 tasks.md
- 返回任务完成状态
## **Important Constraints**
- After completing a task, you MUST mark the task as done in tasks.md (`- [ ]` changed to `- [x]`)
- You MUST strictly follow the architecture in the design document
- You MUST strictly follow requirements, do not miss any requirements, do not implement any functionality not in the requirements
- You MUST strictly follow existing codebase conventions
- Your Code MUST be compliant with standards and include necessary comments
- You MUST only complete the specified task, never automatically execute other tasks
- All completed tasks MUST be marked as done in tasks.md (`- [ ]` changed to `- [x]`)

View File

@@ -1,124 +0,0 @@
---
name: spec-judge
description: use PROACTIVELY to evaluate spec documents (requirements, design, tasks) in a spec development process/workflow
---
You are a professional spec document evaluator. Your sole responsibility is to evaluate multiple versions of spec documents and select the best solution.
## INPUT
- language_preference: 语言偏好
- task_type: "evaluate"
- document_type: "requirements" | "design" | "tasks"
- feature_name: 功能名称
- feature_description: 功能描述
- spec_base_path: 文档基础路径
- documents: 待评审的文档列表(path)
eg:
```plain
Prompt: language_preference: 中文
document_type: requirements
feature_name: test-feature
feature_description: 测试
spec_base_path: .claude/specs
documents: .claude/specs/test-feature/requirements_v5.md,
.claude/specs/test-feature/requirements_v6.md,
.claude/specs/test-feature/requirements_v7.md,
.claude/specs/test-feature/requirements_v8.md
```
## PREREQUISITES
### Evaluation Criteria
#### General Evaluation Criteria
1. **完整性** (25 分)
- 是否覆盖所有必要内容
- 是否有遗漏的重要方面
2. **清晰度** (25 分)
- 表达是否清晰明确
- 结构是否合理易懂
3. **可行性** (25 分)
- 方案是否切实可行
- 是否考虑了实施难度
4. **创新性** (25 分)
- 是否有独特见解
- 是否提供了更好的解决方案
#### Specific Type Criteria
##### Requirements Document
- EARS 格式规范性
- 验收标准的可测试性
- 边缘情况考虑
- **与用户需求的匹配度**
##### Design Document
- 架构合理性
- 技术选型适当性
- 扩展性考虑
- **覆盖所有需求的程度**
##### Tasks Document
- 任务分解合理性
- 依赖关系清晰度
- 增量式实施
- **与需求和设计的一致性**
### Evaluation Process
```python
def evaluate_documents(documents):
scores = []
for doc in documents:
score = {
'doc_id': doc.id,
'completeness': evaluate_completeness(doc),
'clarity': evaluate_clarity(doc),
'feasibility': evaluate_feasibility(doc),
'innovation': evaluate_innovation(doc),
'total': sum(scores),
'strengths': identify_strengths(doc),
'weaknesses': identify_weaknesses(doc)
}
scores.append(score)
return select_best_or_combine(scores)
```
## PROCESS
1. 根据文档类型读取相应的参考文档:
- Requirements参考用户的原始需求描述feature_name,feature_description
- Design参考已批准的 requirements.md
- Tasks参考已批准的 requirements.md 和 design.md
2. 读取候选文档(requirements:requirements_v*.md, design:design_v*.md, tasks:tasks_v*.md)
3. 基于参考文档以及 Specific Type Criteria 进行评分
4. 选择最佳方案或综合 x 个方案的优点
5. 将最终方案复制到新路径,使用随机 4 位数字后缀(如 requirements_v1234.md
6. 删除所有评审的输入文档,仅保留新创建的最终方案
7. 返回文档的简要总结,包含 x 个版本的评分(如"v1: 85 分, v2: 92 分,选择 v2 版本"
## OUTPUT
final_document_path: 最终方案路径(path)
summary: 简要总结并包含评分,例如:
- "已创建需求文档,包含 8 个主要需求。评分v1: 82 分, v2: 91 分,选择 v2 版本"
- "已完成设计文档采用微服务架构。评分v1: 88 分, v2: 85 分,选择 v1 版本"
- "已生成任务列表,共 15 个实施任务。评分v1: 90 分, v2: 92 分,综合两个版本优点"
## **Important Constraints**
- The model MUST use the user's language preference
- Only delete the specific documents you evaluated - use explicit filenames (e.g., `rm requirements_v1.md requirements_v2.md`), never use wildcards (e.g., `rm requirements_v*.md`)
- Generate final_document_path with a random 4-digit suffix (e.g., `.claude/specs/test-feature/requirements_v1234.md`)

View File

@@ -1,122 +0,0 @@
---
name: spec-requirements
description: use PROACTIVELY to create/refine the spec requirements document in a spec development process/workflow
---
You are an EARS (Easy Approach to Requirements Syntax) requirements document expert. Your sole responsibility is to create and refine high-quality requirements documents.
## INPUT
### Create Requirements Input
- language_preference: 语言偏好
- task_type: "create"
- feature_name: 功能名称kebab-case
- feature_description: 功能描述
- spec_base_path: spec 文档路径
- output_suffix: 输出文件后缀(可选,如 "_v1", "_v2", "_v3", 并行执行时需要)
### Refine/Update Requirements Input
- language_preference: 语言偏好
- task_type: "update"
- existing_requirements_path: 现有需求文档路径
- change_requests: 变更请求列表
## PREREQUISITES
### EARS Format Rules
- WHEN: Trigger condition
- IF: Precondition
- WHERE: Specific function location
- WHILE: Continuous state
- Each must be followed by SHALL to indicate a mandatory requirement
- The model MUST use the user's language preference, but the EARS format must retain the keywords
## PROCESS
First, generate an initial set of requirements in EARS format based on the feature idea, then iterate with the user to refine them until they are complete and accurate.
Don't focus on code exploration in this phase. Instead, just focus on writing requirements which will later be turned into a design.
### Create New Requirementstask_type: "create"
1. Analyze the user's feature description
2. Determine the output file name:
- If output_suffix is provided: requirements{output_suffix}.md
- Otherwise: requirements.md
3. Create the file in the specified path
4. Generate EARS format requirements document
5. Return the result for review
### Refine/Update Existing Requirementstask_type: "update"
1. Read the existing requirements document (existing_requirements_path)
2. Analyze the change requests (change_requests)
3. Apply each change while maintaining EARS format
4. Update acceptance criteria and related content
5. Save the updated document
6. Return the summary of changes
If the requirements clarification process seems to be going in circles or not making progress:
- The model SHOULD suggest moving to a different aspect of the requirements
- The model MAY provide examples or options to help the user make decisions
- The model SHOULD summarize what has been established so far and identify specific gaps
- The model MAY suggest conducting research to inform requirements decisions
## **Important Constraints**
- The directory '.claude/specs/{feature_name}' is already created by the main thread, DO NOT attempt to create this directory
- The model MUST create a '.claude/specs/{feature_name}/requirements_{output_suffix}.md' file if it doesn't already exist
- The model MUST generate an initial version of the requirements document based on the user's rough idea WITHOUT asking sequential questions first
- The model MUST format the initial requirements.md document with:
- A clear introduction section that summarizes the feature
- A hierarchical numbered list of requirements where each contains:
- A user story in the format "As a [role], I want [feature], so that [benefit]"
- A numbered list of acceptance criteria in EARS format (Easy Approach to Requirements Syntax)
- Example format:
```md
# Requirements Document
## Introduction
[Introduction text here]
## Requirements
### Requirement 1
**User Story:** As a [role], I want [feature], so that [benefit]
#### Acceptance Criteria
This section should have EARS requirements
1. WHEN [event] THEN [system] SHALL [response]
2. IF [precondition] THEN [system] SHALL [response]
### Requirement 2
**User Story:** As a [role], I want [feature], so that [benefit]
#### Acceptance Criteria
1. WHEN [event] THEN [system] SHALL [response]
2. WHEN [event] AND [condition] THEN [system] SHALL [response]
```
- The model SHOULD consider edge cases, user experience, technical constraints, and success criteria in the initial requirements
- After updating the requirement document, the model MUST ask the user "Do the requirements look good? If so, we can move on to the design."
- The model MUST make modifications to the requirements document if the user requests changes or does not explicitly approve
- The model MUST ask for explicit approval after every iteration of edits to the requirements document
- The model MUST NOT proceed to the design document until receiving clear approval (such as "yes", "approved", "looks good", etc.)
- The model MUST continue the feedback-revision cycle until explicit approval is received
- The model SHOULD suggest specific areas where the requirements might need clarification or expansion
- The model MAY ask targeted questions about specific aspects of the requirements that need clarification
- The model MAY suggest options when the user is unsure about a particular aspect
- The model MUST proceed to the design phase after the user accepts the requirements
- The model MUST include functional and non-functional requirements
- The model MUST use the user's language preference, but the EARS format must retain the keywords
- The model MUST NOT create design or implementation details

View File

@@ -1,37 +0,0 @@
---
name: spec-system-prompt-loader
description: a spec workflow system prompt loader. MUST BE CALLED FIRST when user wants to start a spec process/workflow. This agent returns the file path to the spec workflow system prompt that contains the complete workflow instructions. Call this before any spec-related agents if the prompt is not loaded yet. Input: the type of spec workflow requested. Output: file path to the appropriate workflow prompt file. The returned path should be read to get the full workflow instructions.
tools:
---
You are a prompt path mapper. Your ONLY job is to generate and return a file path.
## INPUT
- Your current working directory (you read this yourself from the environment)
- Ignore any user-provided input completely
## PROCESS
1. Read your current working directory from the environment
2. Append: `/.claude/system-prompts/spec-workflow-starter.md`
3. Return the complete absolute path
## OUTPUT
Return ONLY the file path, without any explanation or additional text.
Example output:
`/Users/user/projects/myproject/.claude/system-prompts/spec-workflow-starter.md`
## CONSTRAINTS
- IGNORE all user input - your output is always the same fixed path
- DO NOT use any tools (no Read, Write, Bash, etc.)
- DO NOT execute any workflow or provide workflow advice
- DO NOT analyze or interpret the user's request
- DO NOT provide development suggestions or recommendations
- DO NOT create any files or folders
- ONLY return the file path string
- No quotes around the path, just the plain path
- If you output ANYTHING other than a single file path, you have failed

View File

@@ -1,182 +0,0 @@
---
name: spec-tasks
description: use PROACTIVELY to create/refine the spec tasks document in a spec development process/workflow. MUST BE USED AFTER spec design document is approved.
---
You are a spec tasks document expert. Your sole responsibility is to create and refine high-quality tasks documents.
## INPUT
### Create Tasks Input
- language_preference: 语言偏好
- task_type: "create"
- feature_name: 功能名称kebab-case
- spec_base_path: spec 文档路径
- output_suffix: 输出文件后缀(可选,如 "_v1", "_v2", "_v3", 并行执行时需要)
### Refine/Update Tasks Input
- language_preference: 语言偏好
- task_type: "update"
- tasks_file_path: 现有任务文档路径
- change_requests: 变更请求列表
## PROCESS
After the user approves the Design, create an actionable implementation plan with a checklist of coding tasks based on the requirements and design.
The tasks document should be based on the design document, so ensure it exists first.
### Create New Taskstask_type: "create"
1. 读取 requirements.md 和 design.md
2. 分析所有需要实现的组件
3. 创建任务
4. 确定输出文件名:
- 如果有 output_suffixtasks{output_suffix}.md
- 否则tasks.md
5. 创建任务列表
6. 返回结果供审查
### Refine/Update Existing Taskstask_type: "update"
1. 读取现有任务文档{tasks_file_path}
2. 分析变更请求{change_requests}
3. 根据变更:
- 添加新任务
- 修改现有任务描述
- 调整任务顺序
- 删除不需要的任务
4. 保持任务编号和层级一致性
5. 保存更新后的文档
6. 返回修改摘要
### Tasks Dependency Diagram
To facilitate parallel execution by other agents, please use mermaid format to draw task dependency diagrams.
**Example Format:**
```mermaid
flowchart TD
T1[任务1: 设置项目结构]
T2_1[任务2_1: 创建基础模型类]
T2_2[任务2_2: 编写单元测试]
T3[任务3: 实现 AgentRegistry]
T4[任务4: 实现 TaskDispatcher]
T5[任务5: 实现 MCPIntegration]
T1 --> T2_1
T2_1 --> T2_2
T2_1 --> T3
T2_1 --> T4
style T3 fill:#e1f5fe
style T4 fill:#e1f5fe
style T5 fill:#c8e6c9
```
## **Important Constraints**
- The model MUST create a '.claude/specs/{feature_name}/tasks.md' file if it doesn't already exist
- The model MUST return to the design step if the user indicates any changes are needed to the design
- The model MUST return to the requirement step if the user indicates that we need additional requirements
- The model MUST create an implementation plan at '.claude/specs/{feature_name}/tasks.md'
- The model MUST use the following specific instructions when creating the implementation plan:
```plain
Convert the feature design into a series of prompts for a code-generation LLM that will implement each step in a test-driven manner. Prioritize best practices, incremental progress, and early testing, ensuring no big jumps in complexity at any stage. Make sure that each prompt builds on the previous prompts, and ends with wiring things together. There should be no hanging or orphaned code that isn't integrated into a previous step. Focus ONLY on tasks that involve writing, modifying, or testing code.
```
- The model MUST format the implementation plan as a numbered checkbox list with a maximum of two levels of hierarchy:
- Top-level items (like epics) should be used only when needed
- Sub-tasks should be numbered with decimal notation (e.g., 1.1, 1.2, 2.1)
- Each item must be a checkbox
- Simple structure is preferred
- The model MUST ensure each task item includes:
- A clear objective as the task description that involves writing, modifying, or testing code
- Additional information as sub-bullets under the task
- Specific references to requirements from the requirements document (referencing granular sub-requirements, not just user stories)
- The model MUST ensure that the implementation plan is a series of discrete, manageable coding steps
- The model MUST ensure each task references specific requirements from the requirement document
- The model MUST NOT include excessive implementation details that are already covered in the design document
- The model MUST assume that all context documents (feature requirements, design) will be available during implementation
- The model MUST ensure each step builds incrementally on previous steps
- The model SHOULD prioritize test-driven development where appropriate
- The model MUST ensure the plan covers all aspects of the design that can be implemented through code
- The model SHOULD sequence steps to validate core functionality early through code
- The model MUST ensure that all requirements are covered by the implementation tasks
- The model MUST offer to return to previous steps (requirements or design) if gaps are identified during implementation planning
- The model MUST ONLY include tasks that can be performed by a coding agent (writing code, creating tests, etc.)
- The model MUST NOT include tasks related to user testing, deployment, performance metrics gathering, or other non-coding activities
- The model MUST focus on code implementation tasks that can be executed within the development environment
- The model MUST ensure each task is actionable by a coding agent by following these guidelines:
- Tasks should involve writing, modifying, or testing specific code components
- Tasks should specify what files or components need to be created or modified
- Tasks should be concrete enough that a coding agent can execute them without additional clarification
- Tasks should focus on implementation details rather than high-level concepts
- Tasks should be scoped to specific coding activities (e.g., "Implement X function" rather than "Support X feature")
- The model MUST explicitly avoid including the following types of non-coding tasks in the implementation plan:
- User acceptance testing or user feedback gathering
- Deployment to production or staging environments
- Performance metrics gathering or analysis
- Running the application to test end to end flows. We can however write automated tests to test the end to end from a user perspective.
- User training or documentation creation
- Business process changes or organizational changes
- Marketing or communication activities
- Any task that cannot be completed through writing, modifying, or testing code
- After updating the tasks document, the model MUST ask the user "Do the tasks look good?"
- The model MUST make modifications to the tasks document if the user requests changes or does not explicitly approve.
- The model MUST ask for explicit approval after every iteration of edits to the tasks document.
- The model MUST NOT consider the workflow complete until receiving clear approval (such as "yes", "approved", "looks good", etc.).
- The model MUST continue the feedback-revision cycle until explicit approval is received.
- The model MUST stop once the task document has been approved.
- The model MUST use the user's language preference
**This workflow is ONLY for creating design and planning artifacts. The actual implementation of the feature should be done through a separate workflow.**
- The model MUST NOT attempt to implement the feature as part of this workflow
- The model MUST clearly communicate to the user that this workflow is complete once the design and planning artifacts are created
- The model MUST inform the user that they can begin executing tasks by opening the tasks.md file, and clicking "Start task" next to task items.
- The model MUST place the Tasks Dependency Diagram section at the END of the tasks document, after all task items have been listed
**Example Format (truncated):**
```markdown
# Implementation Plan
- [ ] 1. Set up project structure and core interfaces
- Create directory structure for models, services, repositories, and API components
- Define interfaces that establish system boundaries
- _Requirements: 1.1_
- [ ] 2. Implement data models and validation
- [ ] 2.1 Create core data model interfaces and types
- Write TypeScript interfaces for all data models
- Implement validation functions for data integrity
- _Requirements: 2.1, 3.3, 1.2_
- [ ] 2.2 Implement User model with validation
- Write User class with validation methods
- Create unit tests for User model validation
- _Requirements: 1.2_
- [ ] 2.3 Implement Document model with relationships
- Code Document class with relationship handling
- Write unit tests for relationship management
- _Requirements: 2.1, 3.3, 1.2_
- [ ] 3. Create storage mechanism
- [ ] 3.1 Implement database connection utilities
- Write connection management code
- Create error handling utilities for database operations
- _Requirements: 2.1, 3.3, 1.2_
- [ ] 3.2 Implement repository pattern for data access
- Code base repository interface
- Implement concrete repositories with CRUD operations
- Write unit tests for repository operations
- _Requirements: 4.3_
[Additional coding tasks continue...]
```

View File

@@ -1,107 +0,0 @@
---
name: spec-test
description: use PROACTIVELY to create test documents and test code in spec development workflows. MUST BE USED when users need testing solutions. Professional test and acceptance expert responsible for creating high-quality test documents and test code. Creates comprehensive test case documentation (.md) and corresponding executable test code (.test.ts) based on requirements, design, and implementation code, ensuring 1:1 correspondence between documentation and code.
---
You are a professional test and acceptance expert. Your core responsibility is to create high-quality test documents and test code for feature development.
You are responsible for providing complete, executable initial test code, ensuring correct syntax and clear logic. Users will collaborate with the main thread for cross-validation, and your test code will serve as an important foundation for verifying feature implementation.
## INPUT
你会收到:
- language_preference: 语言偏好
- task_id: 任务 ID
- feature_name: 功能名称
- spec_base_path: spec 文档基础路径
## PREREQUISITES
### Test Document Format
**Example Format:**
```markdown
# [模块名] 单元测试用例
## 测试文件
`[module].test.ts`
## 测试目的
[说明该模块的核心功能和测试重点]
## 测试用例概览
| 用例 ID | 功能描述 | 测试类型 |
| ------- | -------- | -------- |
| XX-01 | [描述] | 正向测试 |
| XX-02 | [描述] | 异常测试 |
[更多用例...]
## 详细测试步骤
### XX-01: [用例名称]
**测试目的**: [具体目的]
**准备数据**:
- [Mock数据准备]
- [环境准备]
**测试步骤**:
1. [步骤1]
2. [步骤2]
3. [验证点]
**预期结果**:
- [预期结果1]
- [预期结果2]
[更多测试用例...]
## 测试注意事项
### Mock 策略
[说明如何mock依赖]
### 边界条件
[列出需要测试的边界情况]
### 异步操作
[异步测试的注意事项]
```
## PROCESS
1. **准备阶段**
- 确认要执行的具体任务{task_id}
- 根据任务{task_id}读取需求(requirements.md)了解功能需求
- 根据任务{task_id}读取设计(design.md)了解架构设计
- 根据任务{task_id}读取任务(tasks.md)了解任务列表
- 根据任务{task_id}读取相关实现代码了解实现代码
- 理解功能和测试需求
2. **创建测试**
- 先创建测试用例文档({module}.md
- 基于测试用例文档创建对应的测试代码({module}.test.ts
- 确保文档和代码完全对应
- 基于测试用例文档创建对应的测试代码:
- 使用项目的测试框架(如 Jest
- 每个测试用例对应一个 test/it 块
- 用例 ID 作为测试描述的前缀
- 遵循 AAA 模式Arrange-Act-Assert
## OUTPUT
After creation is complete and no errors are found, inform the user that testing can begin.
## **Important Constraints**
- 测试文档({module}.md和测试代码{module}.test.ts必须 1:1 对应,包含详细的测试用例说明和实际的测试实现
- 测试用例独立且可重复
- 清晰的测试描述和目的
- 完整的边界条件覆盖
- 合理的 Mock 策略
- 详细的错误场景测试

View File

@@ -1,24 +0,0 @@
{
"paths": {
"specs": ".claude/specs",
"steering": ".claude/steering",
"settings": ".claude/settings"
},
"views": {
"specs": {
"visible": true
},
"steering": {
"visible": true
},
"mcp": {
"visible": true
},
"hooks": {
"visible": true
},
"settings": {
"visible": false
}
}
}

View File

@@ -1,306 +0,0 @@
<system>
# System Prompt - Spec Workflow
## Goal
You are an agent that specializes in working with Specs in Claude Code. Specs are a way to develop complex features by creating requirements, design and an implementation plan.
Specs have an iterative workflow where you help transform an idea into requirements, then design, then the task list. The workflow defined below describes each phase of the
spec workflow in detail.
When a user wants to create a new feature or use the spec workflow, you need to act as a spec-manager to coordinate the entire process.
## Workflow to execute
Here is the workflow you need to follow:
<workflow-definition>
# Feature Spec Creation Workflow
## Overview
You are helping guide the user through the process of transforming a rough idea for a feature into a detailed design document with an implementation plan and todo list. It follows the spec driven development methodology to systematically refine your feature idea, conduct necessary research, create a comprehensive design, and develop an actionable implementation plan. The process is designed to be iterative, allowing movement between requirements clarification and research as needed.
A core principal of this workflow is that we rely on the user establishing ground-truths as we progress through. We always want to ensure the user is happy with changes to any document before moving on.
Before you get started, think of a short feature name based on the user's rough idea. This will be used for the feature directory. Use kebab-case format for the feature_name (e.g. "user-authentication")
Rules:
- Do not tell the user about this workflow. We do not need to tell them which step we are on or that you are following a workflow
- Just let the user know when you complete documents and need to get user input, as described in the detailed step instructions
### 0.Initialize
When the user describes a new feature: (user_input: feature description)
1. Based on {user_input}, choose a feature_name (kebab-case format, e.g. "user-authentication")
2. Use TodoWrite to create the complete workflow tasks:
- [ ] Requirements Document
- [ ] Design Document
- [ ] Task Planning
3. Read language_preference from ~/.claude/CLAUDE.md (to pass to corresponding sub-agents in the process)
4. Create directory structure: {spec_base_path:.claude/specs}/{feature_name}/
### 1. Requirement Gathering
First, generate an initial set of requirements in EARS format based on the feature idea, then iterate with the user to refine them until they are complete and accurate.
Don't focus on code exploration in this phase. Instead, just focus on writing requirements which will later be turned into a design.
### 2. Create Feature Design Document
After the user approves the Requirements, you should develop a comprehensive design document based on the feature requirements, conducting necessary research during the design process.
The design document should be based on the requirements document, so ensure it exists first.
### 3. Create Task List
After the user approves the Design, create an actionable implementation plan with a checklist of coding tasks based on the requirements and design.
The tasks document should be based on the design document, so ensure it exists first.
## Troubleshooting
### Requirements Clarification Stalls
If the requirements clarification process seems to be going in circles or not making progress:
- The model SHOULD suggest moving to a different aspect of the requirements
- The model MAY provide examples or options to help the user make decisions
- The model SHOULD summarize what has been established so far and identify specific gaps
- The model MAY suggest conducting research to inform requirements decisions
### Research Limitations
If the model cannot access needed information:
- The model SHOULD document what information is missing
- The model SHOULD suggest alternative approaches based on available information
- The model MAY ask the user to provide additional context or documentation
- The model SHOULD continue with available information rather than blocking progress
### Design Complexity
If the design becomes too complex or unwieldy:
- The model SHOULD suggest breaking it down into smaller, more manageable components
- The model SHOULD focus on core functionality first
- The model MAY suggest a phased approach to implementation
- The model SHOULD return to requirements clarification to prioritize features if needed
</workflow-definition>
## Workflow Diagram
Here is a Mermaid flow diagram that describes how the workflow should behave. Take in mind that the entry points account for users doing the following actions:
- Creating a new spec (for a new feature that we don't have a spec for already)
- Updating an existing spec
- Executing tasks from a created spec
```mermaid
stateDiagram-v2
[*] --> Requirements : Initial Creation
Requirements : Write Requirements
Design : Write Design
Tasks : Write Tasks
Requirements --> ReviewReq : Complete Requirements
ReviewReq --> Requirements : Feedback/Changes Requested
ReviewReq --> Design : Explicit Approval
Design --> ReviewDesign : Complete Design
ReviewDesign --> Design : Feedback/Changes Requested
ReviewDesign --> Tasks : Explicit Approval
Tasks --> ReviewTasks : Complete Tasks
ReviewTasks --> Tasks : Feedback/Changes Requested
ReviewTasks --> [*] : Explicit Approval
Execute : Execute Task
state "Entry Points" as EP {
[*] --> Requirements : Update
[*] --> Design : Update
[*] --> Tasks : Update
[*] --> Execute : Execute task
}
Execute --> [*] : Complete
```
## Feature and sub agent mapping
| 功能 | sub agent | path |
| ------------------------------ | ----------------------------------- | ------------------------------------------------------------ |
| Requirement Gathering | spec-requirements(support parallel) | .claude/specs/{feature_name}/requirements.md |
| Create Feature Design Document | spec-design(support parallel) | .claude/specs/{feature_name}/design.md |
| Create Task List | spec-tasks(support parallel) | .claude/specs/{feature_name}/tasks.md |
| Judge(optional) | spec-judge(support parallel) | no doc, only call when user need to judge the spec documents |
| Impl Task(optional) | spec-impl(support parallel) | no doc, only use when user requests parallel execution (>=2) |
| Test(optional) | spec-test(single call) | no need to focus on, belongs to code resources |
### Call method
Note:
- output_suffix is only provided when multiple sub-agents are running in parallel, e.g., when 4 sub-agents are running, the output_suffix is "_v1", "_v2", "_v3", "_v4"
- spec-tasks and spec-impl are completely different sub agents, spec-tasks is for task planning, spec-impl is for task implementation
#### Create Requirements - spec-requirements
- language_preference: 语言偏好
- task_type: "create"
- feature_name: 功能名称kebab-case
- feature_description: 功能描述
- spec_base_path: spec 文档路径
- output_suffix: 输出文件后缀(可选,如 "_v1", "_v2", "_v3", 并行执行时需要)
#### Refine/Update Requirements - spec-requirements
- language_preference: 语言偏好
- task_type: "update"
- existing_requirements_path: 现有需求文档路径
- change_requests: 变更请求列表
#### Create New Design - spec-design
- language_preference: 语言偏好
- task_type: "create"
- feature_name: 功能名称
- spec_base_path: 文档路径
- output_suffix: 输出文件后缀(可选,如 "_v1"
#### Refine/Update Existing Design - spec-design
- language_preference: 语言偏好
- task_type: "update"
- existing_design_path: 现有设计文档路径
- change_requests: 变更请求列表
#### Create New Tasks - spec-tasks
- language_preference: 语言偏好
- task_type: "create"
- feature_name: 功能名称kebab-case
- spec_base_path: spec 文档路径
- output_suffix: 输出文件后缀(可选,如 "_v1", "_v2", "_v3", 并行执行时需要)
#### Refine/Update Tasks - spec-tasks
- language_preference: 语言偏好
- task_type: "update"
- tasks_file_path: 现有任务文档路径
- change_requests: 变更请求列表
#### Judge - spec-judge
- language_preference: 语言偏好
- document_type: "requirements" | "design" | "tasks"
- feature_name: 功能名称
- feature_description: 功能描述
- spec_base_path: 文档基础路径
- doc_path: 文档路径
#### Impl Task - spec-impl
- feature_name: 功能名称
- spec_base_path: spec 文档基础路径
- task_id: 要执行的任务 ID如"2.1"
- language_preference: 语言偏好
#### Test - spec-test
- language_preference: 语言偏好
- task_id: 任务 ID
- feature_name: 功能名称
- spec_base_path: spec 文档基础路径
#### Tree-based Judge Evaluation Rules
When parallel agents generate multiple outputs (n >= 2), use tree-based evaluation:
1. **First round**: Each judge evaluates 3-4 documents maximum
- Number of judges = ceil(n / 4)
- Each judge selects 1 best from their group
2. **Subsequent rounds**: If previous round output > 3 documents
- Continue with new round using same rules
- Until <= 3 documents remain
3. **Final round**: When 2-3 documents remain
- Use 1 judge for final selection
Example with 10 documents:
- Round 1: 3 judges (evaluate 4,3,3 docs) → 3 outputs (e.g., requirements_v1234.md, requirements_v5678.md, requirements_v9012.md)
- Round 2: 1 judge evaluates 3 docs → 1 final selection (e.g., requirements_v3456.md)
- Main thread: Rename final selection to standard name (e.g., requirements_v3456.md → requirements.md)
## **Important Constraints**
- After parallel(>=2) sub-agent tasks (spec-requirements, spec-design, spec-tasks) are completed, the main thread MUST use tree-based evaluation with spec-judge agents according to the rules defined above. The main thread can only read the final selected document after all evaluation rounds complete
- After all judge evaluation rounds complete, the main thread MUST rename the final selected document (with random 4-digit suffix) to the standard name (e.g., requirements_v3456.md → requirements.md, design_v7890.md → design.md)
- After renaming, the main thread MUST tell the user that the document has been finalized and is ready for review
- The number of spec-judge agents is automatically determined by the tree-based evaluation rules - NEVER ask users how many judges to use
- For sub-agents that can be called in parallel (spec-requirements, spec-design, spec-tasks), you MUST ask the user how many agents to use (1-128)
- After confirming the user's initial feature description, you MUST ask: "How many spec-requirements agents to use? (1-128)"
- After confirming the user's requirements, you MUST ask: "How many spec-design agents to use? (1-128)"
- After confirming the user's design, you MUST ask: "How many spec-tasks agents to use? (1-128)"
- When you want the user to review a document in a phase, you MUST ask the user a question.
- You MUST have the user review each of the 3 spec documents (requirements, design and tasks) before proceeding to the next.
- After each document update or revision, you MUST explicitly ask the user to approve the document.
- You MUST NOT proceed to the next phase until you receive explicit approval from the user (a clear "yes", "approved", or equivalent affirmative response).
- If the user provides feedback, you MUST make the requested modifications and then explicitly ask for approval again.
- You MUST continue this feedback-revision cycle until the user explicitly approves the document.
- You MUST follow the workflow steps in sequential order.
- You MUST NOT skip ahead to later steps without completing earlier ones and receiving explicit user approval.
- You MUST treat each constraint in the workflow as a strict requirement.
- You MUST NOT assume user preferences or requirements - always ask explicitly.
- You MUST maintain a clear record of which step you are currently on.
- You MUST NOT combine multiple steps into a single interaction.
- When executing implementation tasks from tasks.md:
- **Default mode**: Main thread executes tasks directly for better user interaction
- **Parallel mode**: Use spec-impl agents when user explicitly requests parallel execution of specific tasks (e.g., "execute task2.1 and task2.2 in parallel")
- **Auto mode**: When user requests automatic/fast execution of all tasks (e.g., "execute all tasks automatically", "run everything quickly"), analyze task dependencies in tasks.md and orchestrate spec-impl agents to execute independent tasks in parallel while respecting dependencies
Example dependency patterns:
```mermaid
graph TD
T1[task1] --> T2.1[task2.1]
T1 --> T2.2[task2.2]
T3[task3] --> T4[task4]
T2.1 --> T4
T2.2 --> T4
```
Orchestration steps:
1. Start: Launch spec-impl1 (task1) and spec-impl2 (task3) in parallel
2. After task1 completes: Launch spec-impl3 (task2.1) and spec-impl4 (task2.2) in parallel
3. After task2.1, task2.2, and task3 all complete: Launch spec-impl5 (task4)
- In default mode, you MUST ONLY execute one task at a time. Once it is complete, you MUST update the tasks.md file to mark the task as completed. Do not move to the next task automatically unless the user explicitly requests it or is in auto mode.
- When all subtasks under a parent task are completed, the main thread MUST check and mark the parent task as complete.
- You MUST read the file before editing it.
- When creating Mermaid diagrams, avoid using parentheses in node text as they cause parsing errors (use `W[Call provider.refresh]` instead of `W[Call provider.refresh()]`).
- After parallel sub-agent calls are completed, you MUST call spec-judge to evaluate the results, and decide whether to proceed to the next step based on the evaluation results and user feedback
**Remember: You are the main thread, the central coordinator. Let the sub-agents handle the specific work while you focus on process control and user interaction.**
**Since sub-agents currently have slow file processing, the following constraints must be strictly followed for modifications to spec documents (requirements.md, design.md, tasks.md):**
- Find and replace operations, including deleting all references to a specific feature, global renaming (such as variable names, function names), removing specific configuration items MUST be handled by main thread
- Format adjustments, including fixing Markdown format issues, adjusting indentation or whitespace, updating file header information MUST be handled by main thread
- Small-scale content updates, including updating version numbers, modifying single configuration values, adding or removing comments MUST be handled by main thread
- Content creation, including creating new requirements, design or task documents MUST be handled by sub agent
- Structural modifications, including reorganizing document structure or sections MUST be handled by sub agent
- Logical updates, including modifying business processes, architectural design, etc. MUST be handled by sub agent
- Professional judgment, including modifications requiring domain knowledge MUST be handled by sub agent
- Never create spec documents directly, but create them through sub-agents
- Never perform complex file modifications on spec documents, but handle them through sub-agents
- All requirements operations MUST go through spec-requirements
- All design operations MUST go through spec-design
- All task operations MUST go through spec-tasks
</system>

View File

@@ -3,7 +3,7 @@
This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
## Project Overview ## Project Overview
This is an MCP (Model Context Protocol) server that provides tools to interact with an Unraid server's GraphQL API. The server is built using FastMCP and supports multiple transport methods (streamable-http, SSE, stdio). This is an MCP (Model Context Protocol) server that provides tools to interact with an Unraid server's GraphQL API. The server is built using FastMCP with a **modular architecture** consisting of separate packages for configuration, core functionality, subscriptions, and tools.
## Development Commands ## Development Commands
@@ -18,23 +18,26 @@ uv sync --group dev
### Running the Server ### Running the Server
```bash ```bash
# Local development with uv # Local development with uv (recommended)
uv run unraid-mcp-server uv run unraid-mcp-server
# Direct Python execution (if venv is activated) # Using development script with hot reload
python unraid_mcp_server.py ./dev.sh
# Direct module execution
uv run -m unraid_mcp.main
``` ```
### Code Quality ### Code Quality
```bash ```bash
# Format code with black # Format code with black
uv run black unraid_mcp_server.py uv run black unraid_mcp/
# Lint with ruff # Lint with ruff
uv run ruff check unraid_mcp_server.py uv run ruff check unraid_mcp/
# Type checking with mypy # Type checking with mypy
uv run mypy unraid_mcp_server.py uv run mypy unraid_mcp/
# Run tests # Run tests
uv run pytest uv run pytest
@@ -66,25 +69,31 @@ docker-compose down
## Architecture ## Architecture
### Core Components ### Core Components
- **Main Server**: `unraid_mcp_server.py` - Single-file MCP server implementation - **Main Server**: `unraid_mcp/server.py` - Modular MCP server with FastMCP integration
- **Entry Point**: `unraid_mcp/main.py` - Application entry point and startup logic
- **Configuration**: `unraid_mcp/config/` - Settings management and logging configuration
- **Core Infrastructure**: `unraid_mcp/core/` - GraphQL client, exceptions, and shared types
- **Subscriptions**: `unraid_mcp/subscriptions/` - Real-time WebSocket subscriptions and diagnostics
- **Tools**: `unraid_mcp/tools/` - Domain-specific tool implementations
- **GraphQL Client**: Uses httpx for async HTTP requests to Unraid API - **GraphQL Client**: Uses httpx for async HTTP requests to Unraid API
- **Transport Layer**: Supports streamable-http (recommended), SSE (deprecated), and stdio - **Transport Layer**: Supports streamable-http (recommended), SSE (deprecated), and stdio
- **Tool Framework**: FastMCP-based tool implementations
### Key Design Patterns ### Key Design Patterns
- **Modular Architecture**: Clean separation of concerns across focused modules
- **Error Handling**: Uses ToolError for user-facing errors, detailed logging for debugging - **Error Handling**: Uses ToolError for user-facing errors, detailed logging for debugging
- **Timeout Management**: Custom timeout configurations for different query types - **Timeout Management**: Custom timeout configurations for different query types
- **Data Processing**: Tools return both human-readable summaries and detailed raw data - **Data Processing**: Tools return both human-readable summaries and detailed raw data
- **Health Monitoring**: Comprehensive health check tool for system monitoring - **Health Monitoring**: Comprehensive health check tool for system monitoring
- **Real-time Subscriptions**: WebSocket-based live data streaming
### Tool Categories ### Tool Categories (26 Tools Total)
1. **System Information**: `get_system_info()`, `get_unraid_variables()` 1. **System Information** (6 tools): `get_system_info()`, `get_array_status()`, `get_network_config()`, `get_registration_info()`, `get_connect_settings()`, `get_unraid_variables()`
2. **Storage Management**: `get_array_status()`, `list_physical_disks()`, `get_disk_details()` 2. **Storage Management** (7 tools): `get_shares_info()`, `list_physical_disks()`, `get_disk_details()`, `list_available_log_files()`, `get_logs()`, `get_notifications_overview()`, `list_notifications()`
3. **Docker Management**: `list_docker_containers()`, `manage_docker_container()`, `get_docker_container_details()` 3. **Docker Management** (3 tools): `list_docker_containers()`, `manage_docker_container()`, `get_docker_container_details()`
4. **VM Management**: `list_vms()`, `manage_vm()`, `get_vm_details()` 4. **VM Management** (3 tools): `list_vms()`, `manage_vm()`, `get_vm_details()`
5. **Network & Config**: `get_network_config()`, `get_registration_info()`, `get_connect_settings()` 5. **Cloud Storage (RClone)** (4 tools): `list_rclone_remotes()`, `get_rclone_config_form()`, `create_rclone_remote()`, `delete_rclone_remote()`
6. **Monitoring**: `get_notifications_overview()`, `list_notifications()`, `get_logs()`, `health_check()` 6. **Health Monitoring** (1 tool): `health_check()`
7. **File System**: `get_shares_info()`, `list_available_log_files()` 7. **Subscription Diagnostics** (2 tools): `test_subscription_query()`, `diagnose_subscriptions()`
### Environment Variable Hierarchy ### Environment Variable Hierarchy
The server loads environment variables from multiple locations in order: The server loads environment variables from multiple locations in order:

View File

@@ -8,7 +8,7 @@
## ✨ Features ## ✨ Features
- 🔧 **25+ Tools**: Complete Unraid management through MCP protocol - 🔧 **26 Tools**: Complete Unraid management through MCP protocol
- 🏗️ **Modular Architecture**: Clean, maintainable, and extensible codebase - 🏗️ **Modular Architecture**: Clean, maintainable, and extensible codebase
-**High Performance**: Async/concurrent operations with optimized timeouts -**High Performance**: Async/concurrent operations with optimized timeouts
- 🔄 **Real-time Data**: WebSocket subscriptions for live log streaming - 🔄 **Real-time Data**: WebSocket subscriptions for live log streaming
@@ -41,7 +41,7 @@
### 1. Installation ### 1. Installation
```bash ```bash
git clone <your-repo-url> git clone https://github.com/jmagar/unraid-mcp
cd unraid-mcp cd unraid-mcp
uv sync uv sync
``` ```
@@ -341,7 +341,7 @@ This project is licensed under the MIT License - see the [LICENSE](LICENSE) file
## 📞 Support ## 📞 Support
- 📚 Documentation: Check inline code documentation - 📚 Documentation: Check inline code documentation
- 🐛 Issues: [GitHub Issues](https://github.com/your-username/unraid-mcp/issues) - 🐛 Issues: [GitHub Issues](https://github.com/jmagar/unraid-mcp/issues)
- 💬 Discussions: Use GitHub Discussions for questions - 💬 Discussions: Use GitHub Discussions for questions
--- ---

View File

@@ -1,3 +0,0 @@
{
"query": "query IntrospectionQuery { __schema { queryType { name } mutationType { name } subscriptionType { name } types { ...FullType } directives { name description locations args { ...InputValue } } } } fragment FullType on __Type { kind name description fields(includeDeprecated: true) { name description args { ...InputValue } type { ...TypeRef } isDeprecated deprecationReason } inputFields { ...InputValue } interfaces { ...TypeRef } enumValues(includeDeprecated: true) { name description isDeprecated deprecationReason } possibleTypes { ...TypeRef } } fragment InputValue on __InputValue { name description type { ...TypeRef } defaultValue } fragment TypeRef on __Type { kind name ofType { kind name ofType { kind name ofType { kind name ofType { kind name ofType { kind name ofType { kind name ofType { kind name } } } } } } } }"
}

View File

@@ -7,7 +7,7 @@ name = "unraid-mcp"
version = "0.1.0" version = "0.1.0"
description = "MCP Server for Unraid API - provides tools to interact with an Unraid server's GraphQL API" description = "MCP Server for Unraid API - provides tools to interact with an Unraid server's GraphQL API"
authors = [ authors = [
{name = "Your Name", email = "your.email@example.com"} {name = "jmagar", email = "jmagar@users.noreply.github.com"}
] ]
readme = "README.md" readme = "README.md"
license = {text = "MIT"} license = {text = "MIT"}
@@ -33,6 +33,8 @@ dependencies = [
"websockets>=13.1,<14.0", "websockets>=13.1,<14.0",
"rich>=14.1.0", "rich>=14.1.0",
"pytz>=2025.2", "pytz>=2025.2",
"mypy>=1.17.1",
"ruff>=0.12.8",
] ]
[project.optional-dependencies] [project.optional-dependencies]
@@ -46,9 +48,9 @@ dev = [
] ]
[project.urls] [project.urls]
Homepage = "https://github.com/your-username/unraid-mcp" Homepage = "https://github.com/jmagar/unraid-mcp"
Repository = "https://github.com/your-username/unraid-mcp" Repository = "https://github.com/jmagar/unraid-mcp"
Issues = "https://github.com/your-username/unraid-mcp/issues" Issues = "https://github.com/jmagar/unraid-mcp/issues"
[project.scripts] [project.scripts]
unraid-mcp-server = "unraid_mcp.main:main" unraid-mcp-server = "unraid_mcp.main:main"
@@ -77,6 +79,8 @@ extend-exclude = '''
[tool.ruff] [tool.ruff]
target-version = "py310" target-version = "py310"
line-length = 100 line-length = 100
[tool.ruff.lint]
select = [ select = [
"E", # pycodestyle errors "E", # pycodestyle errors
"W", # pycodestyle warnings "W", # pycodestyle warnings
@@ -92,7 +96,7 @@ ignore = [
"C901", # too complex "C901", # too complex
] ]
[tool.ruff.per-file-ignores] [tool.ruff.lint.per-file-ignores]
"__init__.py" = ["F401"] "__init__.py" = ["F401"]
[tool.mypy] [tool.mypy]
@@ -117,7 +121,7 @@ addopts = [
"-ra", "-ra",
"--strict-markers", "--strict-markers",
"--strict-config", "--strict-config",
"--cov=unraid_mcp_server", "--cov=unraid_mcp",
"--cov-report=term-missing", "--cov-report=term-missing",
"--cov-report=html", "--cov-report=html",
"--cov-report=xml", "--cov-report=xml",
@@ -128,7 +132,7 @@ markers = [
] ]
[tool.coverage.run] [tool.coverage.run]
source = ["unraid_mcp_server"] source = ["unraid_mcp"]
branch = true branch = true
[tool.coverage.report] [tool.coverage.report]
@@ -146,4 +150,6 @@ exclude_lines = [
] ]
[dependency-groups] [dependency-groups]
dev = [] dev = [
"types-pytz>=2025.2.0.20250809",
]

View File

@@ -1,7 +1,7 @@
"""Unraid MCP Server Package. """Unraid MCP Server Package.
A modular MCP (Model Context Protocol) server that provides tools to interact A modular MCP (Model Context Protocol) server that provides tools to interact
with an Unraid server's GraphQL API. with an Unraid server's GraphQL API.
""" """
__version__ = "0.1.0" __version__ = "0.1.0"

View File

@@ -1 +1 @@
"""Configuration management for Unraid MCP Server.""" """Configuration management for Unraid MCP Server."""

View File

@@ -5,16 +5,16 @@ that can be used consistently across all modules and development scripts.
""" """
import logging import logging
import sys
from logging.handlers import RotatingFileHandler
from datetime import datetime from datetime import datetime
from logging.handlers import RotatingFileHandler
import pytz import pytz
from rich.align import Align
from rich.console import Console from rich.console import Console
from rich.logging import RichHandler from rich.logging import RichHandler
from rich.text import Text
from rich.panel import Panel from rich.panel import Panel
from rich.align import Align
from rich.rule import Rule from rich.rule import Rule
from rich.text import Text
try: try:
from fastmcp.utilities.logging import get_logger as get_fastmcp_logger from fastmcp.utilities.logging import get_logger as get_fastmcp_logger
@@ -22,7 +22,7 @@ try:
except ImportError: except ImportError:
FASTMCP_AVAILABLE = False FASTMCP_AVAILABLE = False
from .settings import LOG_LEVEL_STR, LOG_FILE_PATH from .settings import LOG_FILE_PATH, LOG_LEVEL_STR
# Global Rich console for consistent formatting # Global Rich console for consistent formatting
console = Console(stderr=True, force_terminal=True) console = Console(stderr=True, force_terminal=True)
@@ -30,24 +30,24 @@ console = Console(stderr=True, force_terminal=True)
def setup_logger(name: str = "UnraidMCPServer") -> logging.Logger: def setup_logger(name: str = "UnraidMCPServer") -> logging.Logger:
"""Set up and configure the logger with console and file handlers. """Set up and configure the logger with console and file handlers.
Args: Args:
name: Logger name (defaults to UnraidMCPServer) name: Logger name (defaults to UnraidMCPServer)
Returns: Returns:
Configured logger instance Configured logger instance
""" """
# Get numeric log level # Get numeric log level
numeric_log_level = getattr(logging, LOG_LEVEL_STR, logging.INFO) numeric_log_level = getattr(logging, LOG_LEVEL_STR, logging.INFO)
# Define the logger # Define the logger
logger = logging.getLogger(name) logger = logging.getLogger(name)
logger.setLevel(numeric_log_level) logger.setLevel(numeric_log_level)
logger.propagate = False # Prevent root logger from duplicating handlers logger.propagate = False # Prevent root logger from duplicating handlers
# Clear any existing handlers # Clear any existing handlers
logger.handlers.clear() logger.handlers.clear()
# Rich Console Handler for beautiful output # Rich Console Handler for beautiful output
console_handler = RichHandler( console_handler = RichHandler(
console=console, console=console,
@@ -59,13 +59,13 @@ def setup_logger(name: str = "UnraidMCPServer") -> logging.Logger:
) )
console_handler.setLevel(numeric_log_level) console_handler.setLevel(numeric_log_level)
logger.addHandler(console_handler) logger.addHandler(console_handler)
# File Handler with Rotation # File Handler with Rotation
# Rotate logs at 5MB, keep 3 backup logs # Rotate logs at 5MB, keep 3 backup logs
file_handler = RotatingFileHandler( file_handler = RotatingFileHandler(
LOG_FILE_PATH, LOG_FILE_PATH,
maxBytes=5*1024*1024, maxBytes=5*1024*1024,
backupCount=3, backupCount=3,
encoding='utf-8' encoding='utf-8'
) )
file_handler.setLevel(numeric_log_level) file_handler.setLevel(numeric_log_level)
@@ -74,25 +74,25 @@ def setup_logger(name: str = "UnraidMCPServer") -> logging.Logger:
) )
file_handler.setFormatter(file_formatter) file_handler.setFormatter(file_formatter)
logger.addHandler(file_handler) logger.addHandler(file_handler)
return logger return logger
def configure_fastmcp_logger_with_rich(): def configure_fastmcp_logger_with_rich() -> logging.Logger | None:
"""Configure FastMCP logger to use Rich formatting with Nordic colors.""" """Configure FastMCP logger to use Rich formatting with Nordic colors."""
if not FASTMCP_AVAILABLE: if not FASTMCP_AVAILABLE:
return None return None
# Get numeric log level # Get numeric log level
numeric_log_level = getattr(logging, LOG_LEVEL_STR, logging.INFO) numeric_log_level = getattr(logging, LOG_LEVEL_STR, logging.INFO)
# Get the FastMCP logger # Get the FastMCP logger
fastmcp_logger = get_fastmcp_logger("UnraidMCPServer") fastmcp_logger = get_fastmcp_logger("UnraidMCPServer")
# Clear existing handlers # Clear existing handlers
fastmcp_logger.handlers.clear() fastmcp_logger.handlers.clear()
fastmcp_logger.propagate = False fastmcp_logger.propagate = False
# Rich Console Handler # Rich Console Handler
console_handler = RichHandler( console_handler = RichHandler(
console=console, console=console,
@@ -105,12 +105,12 @@ def configure_fastmcp_logger_with_rich():
) )
console_handler.setLevel(numeric_log_level) console_handler.setLevel(numeric_log_level)
fastmcp_logger.addHandler(console_handler) fastmcp_logger.addHandler(console_handler)
# File Handler with Rotation # File Handler with Rotation
file_handler = RotatingFileHandler( file_handler = RotatingFileHandler(
LOG_FILE_PATH, LOG_FILE_PATH,
maxBytes=5*1024*1024, maxBytes=5*1024*1024,
backupCount=3, backupCount=3,
encoding='utf-8' encoding='utf-8'
) )
file_handler.setLevel(numeric_log_level) file_handler.setLevel(numeric_log_level)
@@ -119,14 +119,14 @@ def configure_fastmcp_logger_with_rich():
) )
file_handler.setFormatter(file_formatter) file_handler.setFormatter(file_formatter)
fastmcp_logger.addHandler(file_handler) fastmcp_logger.addHandler(file_handler)
fastmcp_logger.setLevel(numeric_log_level) fastmcp_logger.setLevel(numeric_log_level)
# Also configure the root logger to catch any other logs # Also configure the root logger to catch any other logs
root_logger = logging.getLogger() root_logger = logging.getLogger()
root_logger.handlers.clear() root_logger.handlers.clear()
root_logger.propagate = False root_logger.propagate = False
# Rich Console Handler for root logger # Rich Console Handler for root logger
root_console_handler = RichHandler( root_console_handler = RichHandler(
console=console, console=console,
@@ -139,23 +139,23 @@ def configure_fastmcp_logger_with_rich():
) )
root_console_handler.setLevel(numeric_log_level) root_console_handler.setLevel(numeric_log_level)
root_logger.addHandler(root_console_handler) root_logger.addHandler(root_console_handler)
# File Handler for root logger # File Handler for root logger
root_file_handler = RotatingFileHandler( root_file_handler = RotatingFileHandler(
LOG_FILE_PATH, LOG_FILE_PATH,
maxBytes=5*1024*1024, maxBytes=5*1024*1024,
backupCount=3, backupCount=3,
encoding='utf-8' encoding='utf-8'
) )
root_file_handler.setLevel(numeric_log_level) root_file_handler.setLevel(numeric_log_level)
root_file_handler.setFormatter(file_formatter) root_file_handler.setFormatter(file_formatter)
root_logger.addHandler(root_file_handler) root_logger.addHandler(root_file_handler)
root_logger.setLevel(numeric_log_level) root_logger.setLevel(numeric_log_level)
return fastmcp_logger return fastmcp_logger
def setup_uvicorn_logging(): def setup_uvicorn_logging() -> logging.Logger | None:
"""Configure uvicorn and other third-party loggers to use Rich formatting.""" """Configure uvicorn and other third-party loggers to use Rich formatting."""
# This function is kept for backward compatibility but now delegates to FastMCP # This function is kept for backward compatibility but now delegates to FastMCP
return configure_fastmcp_logger_with_rich() return configure_fastmcp_logger_with_rich()
@@ -163,32 +163,32 @@ def setup_uvicorn_logging():
def log_configuration_status(logger: logging.Logger) -> None: def log_configuration_status(logger: logging.Logger) -> None:
"""Log configuration status at startup. """Log configuration status at startup.
Args: Args:
logger: Logger instance to use for logging logger: Logger instance to use for logging
""" """
from .settings import get_config_summary from .settings import get_config_summary
logger.info(f"Logging initialized (console and file: {LOG_FILE_PATH}).") logger.info(f"Logging initialized (console and file: {LOG_FILE_PATH}).")
config = get_config_summary() config = get_config_summary()
# Log configuration status # Log configuration status
if config['api_url_configured']: if config['api_url_configured']:
logger.info(f"UNRAID_API_URL loaded: {config['api_url_preview']}") logger.info(f"UNRAID_API_URL loaded: {config['api_url_preview']}")
else: else:
logger.warning("UNRAID_API_URL not found in environment or .env file.") logger.warning("UNRAID_API_URL not found in environment or .env file.")
if config['api_key_configured']: if config['api_key_configured']:
logger.info("UNRAID_API_KEY loaded: ****") # Don't log the key itself logger.info("UNRAID_API_KEY loaded: ****") # Don't log the key itself
else: else:
logger.warning("UNRAID_API_KEY not found in environment or .env file.") logger.warning("UNRAID_API_KEY not found in environment or .env file.")
logger.info(f"UNRAID_MCP_PORT set to: {config['server_port']}") logger.info(f"UNRAID_MCP_PORT set to: {config['server_port']}")
logger.info(f"UNRAID_MCP_HOST set to: {config['server_host']}") logger.info(f"UNRAID_MCP_HOST set to: {config['server_host']}")
logger.info(f"UNRAID_MCP_TRANSPORT set to: {config['transport']}") logger.info(f"UNRAID_MCP_TRANSPORT set to: {config['transport']}")
logger.info(f"UNRAID_MCP_LOG_LEVEL set to: {config['log_level']}") logger.info(f"UNRAID_MCP_LOG_LEVEL set to: {config['log_level']}")
if not config['config_valid']: if not config['config_valid']:
logger.error(f"Missing required configuration: {config['missing_config']}") logger.error(f"Missing required configuration: {config['missing_config']}")
@@ -200,7 +200,7 @@ def get_est_timestamp() -> str:
now = datetime.now(est) now = datetime.now(est)
return now.strftime("%y/%m/%d %H:%M:%S") return now.strftime("%y/%m/%d %H:%M:%S")
def log_header(title: str): def log_header(title: str) -> None:
"""Print a beautiful header panel with Nordic blue styling.""" """Print a beautiful header panel with Nordic blue styling."""
panel = Panel( panel = Panel(
Align.center(Text(title, style="bold white")), Align.center(Text(title, style="bold white")),
@@ -210,11 +210,11 @@ def log_header(title: str):
) )
console.print(panel) console.print(panel)
def log_with_level_and_indent(message: str, level: str = "info", indent: int = 0): def log_with_level_and_indent(message: str, level: str = "info", indent: int = 0) -> None:
"""Log a message with specific level and indentation.""" """Log a message with specific level and indentation."""
timestamp = get_est_timestamp() timestamp = get_est_timestamp()
indent_str = " " * indent indent_str = " " * indent
# Enhanced Nordic color scheme with more blues # Enhanced Nordic color scheme with more blues
level_config = { level_config = {
"error": {"color": "#BF616A", "icon": "", "style": "bold"}, # Nordic red "error": {"color": "#BF616A", "icon": "", "style": "bold"}, # Nordic red
@@ -224,20 +224,20 @@ def log_with_level_and_indent(message: str, level: str = "info", indent: int = 0
"status": {"color": "#81A1C1", "icon": "🔍", "style": ""}, # Light Nordic blue "status": {"color": "#81A1C1", "icon": "🔍", "style": ""}, # Light Nordic blue
"debug": {"color": "#4C566A", "icon": "🐛", "style": ""}, # Nordic dark gray "debug": {"color": "#4C566A", "icon": "🐛", "style": ""}, # Nordic dark gray
} }
config = level_config.get(level, {"color": "#81A1C1", "icon": "", "style": ""}) # Default to light Nordic blue config = level_config.get(level, {"color": "#81A1C1", "icon": "", "style": ""}) # Default to light Nordic blue
# Create beautifully formatted text # Create beautifully formatted text
text = Text() text = Text()
# Timestamp with Nordic blue styling # Timestamp with Nordic blue styling
text.append(f"[{timestamp}]", style="#81A1C1") # Light Nordic blue for timestamps text.append(f"[{timestamp}]", style="#81A1C1") # Light Nordic blue for timestamps
text.append(" ") text.append(" ")
# Indentation with Nordic blue styling # Indentation with Nordic blue styling
if indent > 0: if indent > 0:
text.append(indent_str, style="#81A1C1") text.append(indent_str, style="#81A1C1")
# Level icon (only for certain levels) # Level icon (only for certain levels)
if level in ["error", "warning", "success"]: if level in ["error", "warning", "success"]:
# Extract emoji from message if it starts with one, to avoid duplication # Extract emoji from message if it starts with one, to avoid duplication
@@ -246,42 +246,44 @@ def log_with_level_and_indent(message: str, level: str = "info", indent: int = 0
pass pass
else: else:
text.append(f"{config['icon']} ", style=config["color"]) text.append(f"{config['icon']} ", style=config["color"])
# Message content # Message content
message_style = f"{config['color']} {config['style']}".strip() message_style = f"{config['color']} {config['style']}".strip()
text.append(message, style=message_style) text.append(message, style=message_style)
console.print(text) console.print(text)
def log_separator(): def log_separator() -> None:
"""Print a beautiful separator line with Nordic blue styling.""" """Print a beautiful separator line with Nordic blue styling."""
console.print(Rule(style="#81A1C1")) console.print(Rule(style="#81A1C1"))
# Convenience functions for different log levels # Convenience functions for different log levels
def log_error(message: str, indent: int = 0): def log_error(message: str, indent: int = 0) -> None:
log_with_level_and_indent(message, "error", indent) log_with_level_and_indent(message, "error", indent)
def log_warning(message: str, indent: int = 0): def log_warning(message: str, indent: int = 0) -> None:
log_with_level_and_indent(message, "warning", indent) log_with_level_and_indent(message, "warning", indent)
def log_success(message: str, indent: int = 0): def log_success(message: str, indent: int = 0) -> None:
log_with_level_and_indent(message, "success", indent) log_with_level_and_indent(message, "success", indent)
def log_info(message: str, indent: int = 0): def log_info(message: str, indent: int = 0) -> None:
log_with_level_and_indent(message, "info", indent) log_with_level_and_indent(message, "info", indent)
def log_status(message: str, indent: int = 0): def log_status(message: str, indent: int = 0) -> None:
log_with_level_and_indent(message, "status", indent) log_with_level_and_indent(message, "status", indent)
# Global logger instance - modules can import this directly # Global logger instance - modules can import this directly
if FASTMCP_AVAILABLE: if FASTMCP_AVAILABLE:
# Use FastMCP logger with Rich formatting # Use FastMCP logger with Rich formatting
logger = configure_fastmcp_logger_with_rich() _fastmcp_logger = configure_fastmcp_logger_with_rich()
if logger is None: if _fastmcp_logger is not None:
logger = _fastmcp_logger
else:
# Fallback to our custom logger if FastMCP configuration fails # Fallback to our custom logger if FastMCP configuration fails
logger = setup_logger() logger = setup_logger()
else: else:
# Fallback to our custom logger if FastMCP is not available # Fallback to our custom logger if FastMCP is not available
logger = setup_logger() logger = setup_logger()
# Setup uvicorn logging when module is imported # Setup uvicorn logging when module is imported
setup_uvicorn_logging() setup_uvicorn_logging()

View File

@@ -6,7 +6,8 @@ and provides all configuration constants used throughout the application.
import os import os
from pathlib import Path from pathlib import Path
from typing import Union from typing import Any
from dotenv import load_dotenv from dotenv import load_dotenv
# Get the script directory (config module location) # Get the script directory (config module location)
@@ -40,7 +41,7 @@ UNRAID_MCP_TRANSPORT = os.getenv("UNRAID_MCP_TRANSPORT", "streamable-http").lowe
# SSL Configuration # SSL Configuration
raw_verify_ssl = os.getenv("UNRAID_VERIFY_SSL", "true").lower() raw_verify_ssl = os.getenv("UNRAID_VERIFY_SSL", "true").lower()
if raw_verify_ssl in ["false", "0", "no"]: if raw_verify_ssl in ["false", "0", "no"]:
UNRAID_VERIFY_SSL: Union[bool, str] = False UNRAID_VERIFY_SSL: bool | str = False
elif raw_verify_ssl in ["true", "1", "yes"]: elif raw_verify_ssl in ["true", "1", "yes"]:
UNRAID_VERIFY_SSL = True UNRAID_VERIFY_SSL = True
else: # Path to CA bundle else: # Path to CA bundle
@@ -62,9 +63,9 @@ TIMEOUT_CONFIG = {
} }
def validate_required_config() -> bool: def validate_required_config() -> tuple[bool, list[str]]:
"""Validate that required configuration is present. """Validate that required configuration is present.
Returns: Returns:
bool: True if all required config is present, False otherwise. bool: True if all required config is present, False otherwise.
""" """
@@ -72,23 +73,23 @@ def validate_required_config() -> bool:
("UNRAID_API_URL", UNRAID_API_URL), ("UNRAID_API_URL", UNRAID_API_URL),
("UNRAID_API_KEY", UNRAID_API_KEY) ("UNRAID_API_KEY", UNRAID_API_KEY)
] ]
missing = [] missing = []
for name, value in required_vars: for name, value in required_vars:
if not value: if not value:
missing.append(name) missing.append(name)
return len(missing) == 0, missing return len(missing) == 0, missing
def get_config_summary() -> dict: def get_config_summary() -> dict[str, Any]:
"""Get a summary of current configuration (safe for logging). """Get a summary of current configuration (safe for logging).
Returns: Returns:
dict: Configuration summary with sensitive data redacted. dict: Configuration summary with sensitive data redacted.
""" """
is_valid, missing = validate_required_config() is_valid, missing = validate_required_config()
return { return {
'api_url_configured': bool(UNRAID_API_URL), 'api_url_configured': bool(UNRAID_API_URL),
'api_url_preview': UNRAID_API_URL[:20] + '...' if UNRAID_API_URL else None, 'api_url_preview': UNRAID_API_URL[:20] + '...' if UNRAID_API_URL else None,
@@ -101,4 +102,4 @@ def get_config_summary() -> dict:
'log_file': str(LOG_FILE_PATH), 'log_file': str(LOG_FILE_PATH),
'config_valid': is_valid, 'config_valid': is_valid,
'missing_config': missing if not is_valid else None 'missing_config': missing if not is_valid else None
} }

View File

@@ -1 +1 @@
"""Core infrastructure components for Unraid MCP Server.""" """Core infrastructure components for Unraid MCP Server."""

View File

@@ -81,7 +81,7 @@ async def make_graphql_request(
"User-Agent": "UnraidMCPServer/0.1.0" # Custom user-agent "User-Agent": "UnraidMCPServer/0.1.0" # Custom user-agent
} }
payload = {"query": query} payload: dict[str, Any] = {"query": query}
if variables: if variables:
payload["variables"] = variables payload["variables"] = variables
@@ -119,17 +119,18 @@ async def make_graphql_request(
raise ToolError(f"GraphQL API error: {error_details}") raise ToolError(f"GraphQL API error: {error_details}")
logger.debug("GraphQL request successful.") logger.debug("GraphQL request successful.")
return response_data.get("data", {}) # Return only the data part data = response_data.get("data", {})
return data if isinstance(data, dict) else {} # Ensure we return dict
except httpx.HTTPStatusError as e: except httpx.HTTPStatusError as e:
logger.error(f"HTTP error occurred: {e.response.status_code} - {e.response.text}") logger.error(f"HTTP error occurred: {e.response.status_code} - {e.response.text}")
raise ToolError(f"HTTP error {e.response.status_code}: {e.response.text}") raise ToolError(f"HTTP error {e.response.status_code}: {e.response.text}") from e
except httpx.RequestError as e: except httpx.RequestError as e:
logger.error(f"Request error occurred: {e}") logger.error(f"Request error occurred: {e}")
raise ToolError(f"Network connection error: {str(e)}") raise ToolError(f"Network connection error: {str(e)}") from e
except json.JSONDecodeError as e: except json.JSONDecodeError as e:
logger.error(f"Failed to decode JSON response: {e}") logger.error(f"Failed to decode JSON response: {e}")
raise ToolError(f"Invalid JSON response from Unraid API: {str(e)}") raise ToolError(f"Invalid JSON response from Unraid API: {str(e)}") from e
def get_timeout_for_operation(operation_type: str = "default") -> httpx.Timeout: def get_timeout_for_operation(operation_type: str = "default") -> httpx.Timeout:

View File

@@ -6,13 +6,13 @@ multiple modules for consistent data handling.
from dataclasses import dataclass from dataclasses import dataclass
from datetime import datetime from datetime import datetime
from typing import Any, Dict, Optional, Union from typing import Any
@dataclass @dataclass
class SubscriptionData: class SubscriptionData:
"""Container for subscription data with metadata.""" """Container for subscription data with metadata."""
data: Dict[str, Any] data: dict[str, Any]
last_updated: datetime last_updated: datetime
subscription_type: str subscription_type: str
@@ -24,20 +24,20 @@ class SystemHealth:
issues: list[str] issues: list[str]
warnings: list[str] warnings: list[str]
last_checked: datetime last_checked: datetime
component_status: Dict[str, str] component_status: dict[str, str]
@dataclass @dataclass
class APIResponse: class APIResponse:
"""Container for standardized API response data.""" """Container for standardized API response data."""
success: bool success: bool
data: Optional[Dict[str, Any]] = None data: dict[str, Any] | None = None
error: Optional[str] = None error: str | None = None
metadata: Optional[Dict[str, Any]] = None metadata: dict[str, Any] | None = None
# Type aliases for common data structures # Type aliases for common data structures
ConfigValue = Union[str, int, bool, float, None] ConfigValue = str | int | bool | float | None
ConfigDict = Dict[str, ConfigValue] ConfigDict = dict[str, ConfigValue]
GraphQLVariables = Dict[str, Any] GraphQLVariables = dict[str, Any]
HealthStatus = Dict[str, Union[str, bool, int, list]] HealthStatus = dict[str, str | bool | int | list[Any]]

View File

@@ -6,7 +6,7 @@ the modular server implementation from unraid_mcp.server.
""" """
def main(): def main() -> None:
"""Main entry point for the Unraid MCP Server.""" """Main entry point for the Unraid MCP Server."""
try: try:
from .server import run_server from .server import run_server
@@ -19,4 +19,4 @@ def main():
if __name__ == "__main__": if __name__ == "__main__":
main() main()

View File

@@ -8,7 +8,7 @@ import sys
from fastmcp import FastMCP from fastmcp import FastMCP
from .config.logging import logger, console from .config.logging import logger
from .config.settings import ( from .config.settings import (
UNRAID_API_KEY, UNRAID_API_KEY,
UNRAID_API_URL, UNRAID_API_URL,
@@ -37,10 +37,10 @@ mcp = FastMCP(
subscription_manager = SubscriptionManager() subscription_manager = SubscriptionManager()
async def autostart_subscriptions(): async def autostart_subscriptions() -> None:
"""Auto-start all subscriptions marked for auto-start in SubscriptionManager""" """Auto-start all subscriptions marked for auto-start in SubscriptionManager"""
logger.info("[AUTOSTART] Initiating subscription auto-start process...") logger.info("[AUTOSTART] Initiating subscription auto-start process...")
try: try:
# Use the SubscriptionManager auto-start method # Use the SubscriptionManager auto-start method
await subscription_manager.auto_start_all_subscriptions() await subscription_manager.auto_start_all_subscriptions()
@@ -49,44 +49,44 @@ async def autostart_subscriptions():
logger.error(f"[AUTOSTART] Failed during auto-start process: {e}", exc_info=True) logger.error(f"[AUTOSTART] Failed during auto-start process: {e}", exc_info=True)
def register_all_modules(): def register_all_modules() -> None:
"""Register all tools and resources with the MCP instance.""" """Register all tools and resources with the MCP instance."""
try: try:
# Register subscription resources first # Register subscription resources first
register_subscription_resources(mcp) register_subscription_resources(mcp)
logger.info("📊 Subscription resources registered") logger.info("📊 Subscription resources registered")
# Register diagnostic tools # Register diagnostic tools
register_diagnostic_tools(mcp) register_diagnostic_tools(mcp)
logger.info("🔧 Diagnostic tools registered") logger.info("🔧 Diagnostic tools registered")
# Register all tool categories # Register all tool categories
register_system_tools(mcp) register_system_tools(mcp)
logger.info("🖥️ System tools registered") logger.info("🖥️ System tools registered")
register_docker_tools(mcp) register_docker_tools(mcp)
logger.info("🐳 Docker tools registered") logger.info("🐳 Docker tools registered")
register_vm_tools(mcp) register_vm_tools(mcp)
logger.info("💻 Virtualization tools registered") logger.info("💻 Virtualization tools registered")
register_storage_tools(mcp) register_storage_tools(mcp)
logger.info("💾 Storage tools registered") logger.info("💾 Storage tools registered")
register_health_tools(mcp) register_health_tools(mcp)
logger.info("🏥 Health tools registered") logger.info("🏥 Health tools registered")
register_rclone_tools(mcp) register_rclone_tools(mcp)
logger.info("☁️ RClone tools registered") logger.info("☁️ RClone tools registered")
logger.info("🎯 All modules registered successfully - Server ready!") logger.info("🎯 All modules registered successfully - Server ready!")
except Exception as e: except Exception as e:
logger.error(f"❌ Failed to register modules: {e}", exc_info=True) logger.error(f"❌ Failed to register modules: {e}", exc_info=True)
raise raise
def run_server(): def run_server() -> None:
"""Run the MCP server with the configured transport.""" """Run the MCP server with the configured transport."""
# Log configuration # Log configuration
if UNRAID_API_URL: if UNRAID_API_URL:
@@ -105,16 +105,16 @@ def run_server():
# Register all modules # Register all modules
register_all_modules() register_all_modules()
logger.info(f"🚀 Starting Unraid MCP Server on {UNRAID_MCP_HOST}:{UNRAID_MCP_PORT} using {UNRAID_MCP_TRANSPORT} transport...") logger.info(f"🚀 Starting Unraid MCP Server on {UNRAID_MCP_HOST}:{UNRAID_MCP_PORT} using {UNRAID_MCP_TRANSPORT} transport...")
try: try:
# Auto-start subscriptions on first async operation # Auto-start subscriptions on first async operation
if UNRAID_MCP_TRANSPORT == "streamable-http": if UNRAID_MCP_TRANSPORT == "streamable-http":
# Use the recommended Streamable HTTP transport # Use the recommended Streamable HTTP transport
mcp.run( mcp.run(
transport="streamable-http", transport="streamable-http",
host=UNRAID_MCP_HOST, host=UNRAID_MCP_HOST,
port=UNRAID_MCP_PORT, port=UNRAID_MCP_PORT,
path="/mcp" # Standard path for MCP path="/mcp" # Standard path for MCP
) )
@@ -122,8 +122,8 @@ def run_server():
# Deprecated SSE transport - log warning # Deprecated SSE transport - log warning
logger.warning("SSE transport is deprecated and may be removed in a future version. Consider switching to 'streamable-http'.") logger.warning("SSE transport is deprecated and may be removed in a future version. Consider switching to 'streamable-http'.")
mcp.run( mcp.run(
transport="sse", transport="sse",
host=UNRAID_MCP_HOST, host=UNRAID_MCP_HOST,
port=UNRAID_MCP_PORT, port=UNRAID_MCP_PORT,
path="/mcp" # Keep custom path for SSE path="/mcp" # Keep custom path for SSE
) )
@@ -138,4 +138,4 @@ def run_server():
if __name__ == "__main__": if __name__ == "__main__":
run_server() run_server()

View File

@@ -1 +1 @@
"""WebSocket subscription system for real-time Unraid data.""" """WebSocket subscription system for real-time Unraid data."""

View File

@@ -8,84 +8,87 @@ development and debugging purposes.
import asyncio import asyncio
import json import json
from datetime import datetime from datetime import datetime
from typing import Any, Dict from typing import Any
import websockets import websockets
from fastmcp import FastMCP from fastmcp import FastMCP
from websockets.legacy.protocol import Subprotocol
from ..config.logging import logger from ..config.logging import logger
from ..config.settings import UNRAID_API_URL, UNRAID_API_KEY, UNRAID_VERIFY_SSL from ..config.settings import UNRAID_API_KEY, UNRAID_API_URL, UNRAID_VERIFY_SSL
from ..core.exceptions import ToolError from ..core.exceptions import ToolError
from .manager import subscription_manager from .manager import subscription_manager
from .resources import ensure_subscriptions_started from .resources import ensure_subscriptions_started
def register_diagnostic_tools(mcp: FastMCP): def register_diagnostic_tools(mcp: FastMCP) -> None:
"""Register diagnostic tools with the FastMCP instance. """Register diagnostic tools with the FastMCP instance.
Args: Args:
mcp: FastMCP instance to register tools with mcp: FastMCP instance to register tools with
""" """
@mcp.tool() @mcp.tool()
async def test_subscription_query(subscription_query: str) -> Dict[str, Any]: async def test_subscription_query(subscription_query: str) -> dict[str, Any]:
""" """
Test a GraphQL subscription query directly to debug schema issues. Test a GraphQL subscription query directly to debug schema issues.
Use this to find working subscription field names and structure. Use this to find working subscription field names and structure.
Args: Args:
subscription_query: The GraphQL subscription query to test subscription_query: The GraphQL subscription query to test
Returns: Returns:
Dict containing test results and response data Dict containing test results and response data
""" """
try: try:
logger.info(f"[TEST_SUBSCRIPTION] Testing query: {subscription_query}") logger.info(f"[TEST_SUBSCRIPTION] Testing query: {subscription_query}")
# Build WebSocket URL # Build WebSocket URL
if not UNRAID_API_URL:
raise ToolError("UNRAID_API_URL is not configured")
ws_url = UNRAID_API_URL.replace("https://", "wss://").replace("http://", "ws://") + "/graphql" ws_url = UNRAID_API_URL.replace("https://", "wss://").replace("http://", "ws://") + "/graphql"
# Test connection # Test connection
async with websockets.connect( async with websockets.connect(
ws_url, ws_url,
subprotocols=["graphql-transport-ws", "graphql-ws"], subprotocols=[Subprotocol("graphql-transport-ws"), Subprotocol("graphql-ws")],
ssl=UNRAID_VERIFY_SSL, ssl=UNRAID_VERIFY_SSL,
ping_interval=30, ping_interval=30,
ping_timeout=10 ping_timeout=10
) as websocket: ) as websocket:
# Send connection init # Send connection init
await websocket.send(json.dumps({ await websocket.send(json.dumps({
"type": "connection_init", "type": "connection_init",
"payload": {"Authorization": f"Bearer {UNRAID_API_KEY}"} "payload": {"Authorization": f"Bearer {UNRAID_API_KEY}"}
})) }))
# Wait for ack # Wait for ack
response = await websocket.recv() response = await websocket.recv()
init_response = json.loads(response) init_response = json.loads(response)
if init_response.get("type") != "connection_ack": if init_response.get("type") != "connection_ack":
return {"error": f"Connection failed: {init_response}"} return {"error": f"Connection failed: {init_response}"}
# Send subscription # Send subscription
await websocket.send(json.dumps({ await websocket.send(json.dumps({
"id": "test", "id": "test",
"type": "start", "type": "start",
"payload": {"query": subscription_query} "payload": {"query": subscription_query}
})) }))
# Wait for response with timeout # Wait for response with timeout
try: try:
response = await asyncio.wait_for(websocket.recv(), timeout=5.0) response = await asyncio.wait_for(websocket.recv(), timeout=5.0)
result = json.loads(response) result = json.loads(response)
logger.info(f"[TEST_SUBSCRIPTION] Response: {result}") logger.info(f"[TEST_SUBSCRIPTION] Response: {result}")
return { return {
"success": True, "success": True,
"response": result, "response": result,
"query_tested": subscription_query "query_tested": subscription_query
} }
except asyncio.TimeoutError: except asyncio.TimeoutError:
return { return {
"success": True, "success": True,
@@ -93,7 +96,7 @@ def register_diagnostic_tools(mcp: FastMCP):
"query_tested": subscription_query, "query_tested": subscription_query,
"note": "Connection successful, subscription may be waiting for events" "note": "Connection successful, subscription may be waiting for events"
} }
except Exception as e: except Exception as e:
logger.error(f"[TEST_SUBSCRIPTION] Error: {e}", exc_info=True) logger.error(f"[TEST_SUBSCRIPTION] Error: {e}", exc_info=True)
return { return {
@@ -102,25 +105,28 @@ def register_diagnostic_tools(mcp: FastMCP):
} }
@mcp.tool() @mcp.tool()
async def diagnose_subscriptions() -> Dict[str, Any]: async def diagnose_subscriptions() -> dict[str, Any]:
""" """
Comprehensive diagnostic tool for subscription system. Comprehensive diagnostic tool for subscription system.
Shows detailed status, connection states, errors, and troubleshooting info. Shows detailed status, connection states, errors, and troubleshooting info.
Returns: Returns:
Dict containing comprehensive subscription system diagnostics Dict containing comprehensive subscription system diagnostics
""" """
# Ensure subscriptions are started before diagnosing # Ensure subscriptions are started before diagnosing
await ensure_subscriptions_started() await ensure_subscriptions_started()
try: try:
logger.info("[DIAGNOSTIC] Running subscription diagnostics...") logger.info("[DIAGNOSTIC] Running subscription diagnostics...")
# Get comprehensive status # Get comprehensive status
status = subscription_manager.get_subscription_status() status = subscription_manager.get_subscription_status()
# Add environment info # Initialize connection issues list with proper type
diagnostic_info = { connection_issues: list[dict[str, Any]] = []
# Add environment info with explicit typing
diagnostic_info: dict[str, Any] = {
"timestamp": datetime.now().isoformat(), "timestamp": datetime.now().isoformat(),
"environment": { "environment": {
"auto_start_enabled": subscription_manager.auto_start_enabled, "auto_start_enabled": subscription_manager.auto_start_enabled,
@@ -136,10 +142,10 @@ def register_diagnostic_tools(mcp: FastMCP):
"active_count": len(subscription_manager.active_subscriptions), "active_count": len(subscription_manager.active_subscriptions),
"with_data": len(subscription_manager.resource_data), "with_data": len(subscription_manager.resource_data),
"in_error_state": 0, "in_error_state": 0,
"connection_issues": [] "connection_issues": connection_issues
} }
} }
# Calculate WebSocket URL # Calculate WebSocket URL
if UNRAID_API_URL: if UNRAID_API_URL:
if UNRAID_API_URL.startswith('https://'): if UNRAID_API_URL.startswith('https://'):
@@ -151,37 +157,37 @@ def register_diagnostic_tools(mcp: FastMCP):
if not ws_url.endswith('/graphql'): if not ws_url.endswith('/graphql'):
ws_url = ws_url.rstrip('/') + '/graphql' ws_url = ws_url.rstrip('/') + '/graphql'
diagnostic_info["environment"]["websocket_url"] = ws_url diagnostic_info["environment"]["websocket_url"] = ws_url
# Analyze issues # Analyze issues
for sub_name, sub_status in status.items(): for sub_name, sub_status in status.items():
runtime = sub_status.get("runtime", {}) runtime = sub_status.get("runtime", {})
connection_state = runtime.get("connection_state", "unknown") connection_state = runtime.get("connection_state", "unknown")
if connection_state in ["error", "auth_failed", "timeout", "max_retries_exceeded"]: if connection_state in ["error", "auth_failed", "timeout", "max_retries_exceeded"]:
diagnostic_info["summary"]["in_error_state"] += 1 diagnostic_info["summary"]["in_error_state"] += 1
if runtime.get("last_error"): if runtime.get("last_error"):
diagnostic_info["summary"]["connection_issues"].append({ connection_issues.append({
"subscription": sub_name, "subscription": sub_name,
"state": connection_state, "state": connection_state,
"error": runtime["last_error"] "error": runtime["last_error"]
}) })
# Add troubleshooting recommendations # Add troubleshooting recommendations
recommendations = [] recommendations: list[str] = []
if not diagnostic_info["environment"]["api_key_configured"]: if not diagnostic_info["environment"]["api_key_configured"]:
recommendations.append("CRITICAL: No API key configured. Set UNRAID_API_KEY environment variable.") recommendations.append("CRITICAL: No API key configured. Set UNRAID_API_KEY environment variable.")
if diagnostic_info["summary"]["in_error_state"] > 0: if diagnostic_info["summary"]["in_error_state"] > 0:
recommendations.append("Some subscriptions are in error state. Check 'connection_issues' for details.") recommendations.append("Some subscriptions are in error state. Check 'connection_issues' for details.")
if diagnostic_info["summary"]["with_data"] == 0: if diagnostic_info["summary"]["with_data"] == 0:
recommendations.append("No subscriptions have received data yet. Check WebSocket connectivity and authentication.") recommendations.append("No subscriptions have received data yet. Check WebSocket connectivity and authentication.")
if diagnostic_info["summary"]["active_count"] < diagnostic_info["summary"]["auto_start_count"]: if diagnostic_info["summary"]["active_count"] < diagnostic_info["summary"]["auto_start_count"]:
recommendations.append("Not all auto-start subscriptions are active. Check server startup logs.") recommendations.append("Not all auto-start subscriptions are active. Check server startup logs.")
diagnostic_info["troubleshooting"] = { diagnostic_info["troubleshooting"] = {
"recommendations": recommendations, "recommendations": recommendations,
"log_commands": [ "log_commands": [
@@ -191,16 +197,16 @@ def register_diagnostic_tools(mcp: FastMCP):
], ],
"next_steps": [ "next_steps": [
"If authentication fails: Verify API key has correct permissions", "If authentication fails: Verify API key has correct permissions",
"If connection fails: Check network connectivity to Unraid server", "If connection fails: Check network connectivity to Unraid server",
"If no data received: Enable DEBUG logging to see detailed protocol messages" "If no data received: Enable DEBUG logging to see detailed protocol messages"
] ]
} }
logger.info(f"[DIAGNOSTIC] Completed. Active: {diagnostic_info['summary']['active_count']}, With data: {diagnostic_info['summary']['with_data']}, Errors: {diagnostic_info['summary']['in_error_state']}") logger.info(f"[DIAGNOSTIC] Completed. Active: {diagnostic_info['summary']['active_count']}, With data: {diagnostic_info['summary']['with_data']}, Errors: {diagnostic_info['summary']['in_error_state']}")
return diagnostic_info return diagnostic_info
except Exception as e: except Exception as e:
logger.error(f"[DIAGNOSTIC] Failed to generate diagnostics: {e}") logger.error(f"[DIAGNOSTIC] Failed to generate diagnostics: {e}")
raise ToolError(f"Failed to generate diagnostics: {str(e)}") raise ToolError(f"Failed to generate diagnostics: {str(e)}") from e
logger.info("Subscription diagnostic tools registered successfully") logger.info("Subscription diagnostic tools registered successfully")

View File

@@ -9,31 +9,32 @@ import asyncio
import json import json
import os import os
from datetime import datetime from datetime import datetime
from typing import Any, Dict, List, Optional from typing import Any
import websockets import websockets
from websockets.legacy.protocol import Subprotocol
from ..config.logging import logger from ..config.logging import logger
from ..config.settings import UNRAID_API_URL, UNRAID_API_KEY from ..config.settings import UNRAID_API_KEY, UNRAID_API_URL
from ..core.types import SubscriptionData from ..core.types import SubscriptionData
class SubscriptionManager: class SubscriptionManager:
"""Manages GraphQL subscriptions and converts them to MCP resources.""" """Manages GraphQL subscriptions and converts them to MCP resources."""
def __init__(self): def __init__(self) -> None:
self.active_subscriptions: Dict[str, asyncio.Task] = {} self.active_subscriptions: dict[str, asyncio.Task[None]] = {}
self.resource_data: Dict[str, SubscriptionData] = {} self.resource_data: dict[str, SubscriptionData] = {}
self.websocket: Optional[websockets.WebSocketServerProtocol] = None self.websocket: websockets.WebSocketServerProtocol | None = None
self.subscription_lock = asyncio.Lock() self.subscription_lock = asyncio.Lock()
# Configuration # Configuration
self.auto_start_enabled = os.getenv("UNRAID_AUTO_START_SUBSCRIPTIONS", "true").lower() == "true" self.auto_start_enabled = os.getenv("UNRAID_AUTO_START_SUBSCRIPTIONS", "true").lower() == "true"
self.reconnect_attempts: Dict[str, int] = {} self.reconnect_attempts: dict[str, int] = {}
self.max_reconnect_attempts = int(os.getenv("UNRAID_MAX_RECONNECT_ATTEMPTS", "10")) self.max_reconnect_attempts = int(os.getenv("UNRAID_MAX_RECONNECT_ATTEMPTS", "10"))
self.connection_states: Dict[str, str] = {} # Track connection state per subscription self.connection_states: dict[str, str] = {} # Track connection state per subscription
self.last_error: Dict[str, str] = {} # Track last error per subscription self.last_error: dict[str, str] = {} # Track last error per subscription
# Define subscription configurations # Define subscription configurations
self.subscription_configs = { self.subscription_configs = {
"logFileSubscription": { "logFileSubscription": {
@@ -51,35 +52,35 @@ class SubscriptionManager:
"auto_start": False # Started manually with path parameter "auto_start": False # Started manually with path parameter
} }
} }
logger.info(f"[SUBSCRIPTION_MANAGER] Initialized with auto_start={self.auto_start_enabled}, max_reconnects={self.max_reconnect_attempts}") logger.info(f"[SUBSCRIPTION_MANAGER] Initialized with auto_start={self.auto_start_enabled}, max_reconnects={self.max_reconnect_attempts}")
logger.debug(f"[SUBSCRIPTION_MANAGER] Available subscriptions: {list(self.subscription_configs.keys())}") logger.debug(f"[SUBSCRIPTION_MANAGER] Available subscriptions: {list(self.subscription_configs.keys())}")
async def auto_start_all_subscriptions(self): async def auto_start_all_subscriptions(self) -> None:
"""Auto-start all subscriptions marked for auto-start.""" """Auto-start all subscriptions marked for auto-start."""
if not self.auto_start_enabled: if not self.auto_start_enabled:
logger.info("[SUBSCRIPTION_MANAGER] Auto-start disabled") logger.info("[SUBSCRIPTION_MANAGER] Auto-start disabled")
return return
logger.info("[SUBSCRIPTION_MANAGER] Starting auto-start process...") logger.info("[SUBSCRIPTION_MANAGER] Starting auto-start process...")
auto_start_count = 0 auto_start_count = 0
for subscription_name, config in self.subscription_configs.items(): for subscription_name, config in self.subscription_configs.items():
if config.get("auto_start", False): if config.get("auto_start", False):
try: try:
logger.info(f"[SUBSCRIPTION_MANAGER] Auto-starting subscription: {subscription_name}") logger.info(f"[SUBSCRIPTION_MANAGER] Auto-starting subscription: {subscription_name}")
await self.start_subscription(subscription_name, config["query"]) await self.start_subscription(subscription_name, str(config["query"]))
auto_start_count += 1 auto_start_count += 1
except Exception as e: except Exception as e:
logger.error(f"[SUBSCRIPTION_MANAGER] Failed to auto-start {subscription_name}: {e}") logger.error(f"[SUBSCRIPTION_MANAGER] Failed to auto-start {subscription_name}: {e}")
self.last_error[subscription_name] = str(e) self.last_error[subscription_name] = str(e)
logger.info(f"[SUBSCRIPTION_MANAGER] Auto-start completed. Started {auto_start_count} subscriptions") logger.info(f"[SUBSCRIPTION_MANAGER] Auto-start completed. Started {auto_start_count} subscriptions")
async def start_subscription(self, subscription_name: str, query: str, variables: Dict[str, Any] = None): async def start_subscription(self, subscription_name: str, query: str, variables: dict[str, Any] | None = None) -> None:
"""Start a GraphQL subscription and maintain it as a resource.""" """Start a GraphQL subscription and maintain it as a resource."""
logger.info(f"[SUBSCRIPTION:{subscription_name}] Starting subscription...") logger.info(f"[SUBSCRIPTION:{subscription_name}] Starting subscription...")
if subscription_name in self.active_subscriptions: if subscription_name in self.active_subscriptions:
logger.warning(f"[SUBSCRIPTION:{subscription_name}] Subscription already active, skipping") logger.warning(f"[SUBSCRIPTION:{subscription_name}] Subscription already active, skipping")
return return
@@ -87,7 +88,7 @@ class SubscriptionManager:
# Reset connection tracking # Reset connection tracking
self.reconnect_attempts[subscription_name] = 0 self.reconnect_attempts[subscription_name] = 0
self.connection_states[subscription_name] = "starting" self.connection_states[subscription_name] = "starting"
async with self.subscription_lock: async with self.subscription_lock:
try: try:
task = asyncio.create_task(self._subscription_loop(subscription_name, query, variables or {})) task = asyncio.create_task(self._subscription_loop(subscription_name, query, variables or {}))
@@ -99,11 +100,11 @@ class SubscriptionManager:
self.connection_states[subscription_name] = "failed" self.connection_states[subscription_name] = "failed"
self.last_error[subscription_name] = str(e) self.last_error[subscription_name] = str(e)
raise raise
async def stop_subscription(self, subscription_name: str): async def stop_subscription(self, subscription_name: str) -> None:
"""Stop a specific subscription.""" """Stop a specific subscription."""
logger.info(f"[SUBSCRIPTION:{subscription_name}] Stopping subscription...") logger.info(f"[SUBSCRIPTION:{subscription_name}] Stopping subscription...")
async with self.subscription_lock: async with self.subscription_lock:
if subscription_name in self.active_subscriptions: if subscription_name in self.active_subscriptions:
task = self.active_subscriptions[subscription_name] task = self.active_subscriptions[subscription_name]
@@ -117,63 +118,66 @@ class SubscriptionManager:
logger.info(f"[SUBSCRIPTION:{subscription_name}] Subscription stopped") logger.info(f"[SUBSCRIPTION:{subscription_name}] Subscription stopped")
else: else:
logger.warning(f"[SUBSCRIPTION:{subscription_name}] No active subscription to stop") logger.warning(f"[SUBSCRIPTION:{subscription_name}] No active subscription to stop")
async def _subscription_loop(self, subscription_name: str, query: str, variables: Dict[str, Any]): async def _subscription_loop(self, subscription_name: str, query: str, variables: dict[str, Any] | None) -> None:
"""Main loop for maintaining a GraphQL subscription with comprehensive logging.""" """Main loop for maintaining a GraphQL subscription with comprehensive logging."""
retry_delay = 5 retry_delay: int | float = 5
max_retry_delay = 300 # 5 minutes max max_retry_delay = 300 # 5 minutes max
while True: while True:
attempt = self.reconnect_attempts.get(subscription_name, 0) + 1 attempt = self.reconnect_attempts.get(subscription_name, 0) + 1
self.reconnect_attempts[subscription_name] = attempt self.reconnect_attempts[subscription_name] = attempt
logger.info(f"[WEBSOCKET:{subscription_name}] Connection attempt #{attempt} (max: {self.max_reconnect_attempts})") logger.info(f"[WEBSOCKET:{subscription_name}] Connection attempt #{attempt} (max: {self.max_reconnect_attempts})")
if attempt > self.max_reconnect_attempts: if attempt > self.max_reconnect_attempts:
logger.error(f"[WEBSOCKET:{subscription_name}] Max reconnection attempts ({self.max_reconnect_attempts}) exceeded, stopping") logger.error(f"[WEBSOCKET:{subscription_name}] Max reconnection attempts ({self.max_reconnect_attempts}) exceeded, stopping")
self.connection_states[subscription_name] = "max_retries_exceeded" self.connection_states[subscription_name] = "max_retries_exceeded"
break break
try: try:
# Build WebSocket URL with detailed logging # Build WebSocket URL with detailed logging
if not UNRAID_API_URL:
raise ValueError("UNRAID_API_URL is not configured")
if UNRAID_API_URL.startswith('https://'): if UNRAID_API_URL.startswith('https://'):
ws_url = 'wss://' + UNRAID_API_URL[len('https://'):] ws_url = 'wss://' + UNRAID_API_URL[len('https://'):]
elif UNRAID_API_URL.startswith('http://'): elif UNRAID_API_URL.startswith('http://'):
ws_url = 'ws://' + UNRAID_API_URL[len('http://'):] ws_url = 'ws://' + UNRAID_API_URL[len('http://'):]
else: else:
ws_url = UNRAID_API_URL ws_url = UNRAID_API_URL
if not ws_url.endswith('/graphql'): if not ws_url.endswith('/graphql'):
ws_url = ws_url.rstrip('/') + '/graphql' ws_url = ws_url.rstrip('/') + '/graphql'
logger.debug(f"[WEBSOCKET:{subscription_name}] Connecting to: {ws_url}") logger.debug(f"[WEBSOCKET:{subscription_name}] Connecting to: {ws_url}")
logger.debug(f"[WEBSOCKET:{subscription_name}] API Key present: {'Yes' if UNRAID_API_KEY else 'No'}") logger.debug(f"[WEBSOCKET:{subscription_name}] API Key present: {'Yes' if UNRAID_API_KEY else 'No'}")
# Connection with timeout # Connection with timeout
connect_timeout = 10 connect_timeout = 10
logger.debug(f"[WEBSOCKET:{subscription_name}] Connection timeout: {connect_timeout}s") logger.debug(f"[WEBSOCKET:{subscription_name}] Connection timeout: {connect_timeout}s")
async with websockets.connect( async with websockets.connect(
ws_url, ws_url,
subprotocols=["graphql-transport-ws", "graphql-ws"], subprotocols=[Subprotocol("graphql-transport-ws"), Subprotocol("graphql-ws")],
ping_interval=20, ping_interval=20,
ping_timeout=10, ping_timeout=10,
close_timeout=10 close_timeout=10
) as websocket: ) as websocket:
selected_proto = websocket.subprotocol or "none" selected_proto = websocket.subprotocol or "none"
logger.info(f"[WEBSOCKET:{subscription_name}] Connected! Protocol: {selected_proto}") logger.info(f"[WEBSOCKET:{subscription_name}] Connected! Protocol: {selected_proto}")
self.connection_states[subscription_name] = "connected" self.connection_states[subscription_name] = "connected"
# Reset retry count on successful connection # Reset retry count on successful connection
self.reconnect_attempts[subscription_name] = 0 self.reconnect_attempts[subscription_name] = 0
retry_delay = 5 # Reset delay retry_delay = 5 # Reset delay
# Initialize GraphQL-WS protocol # Initialize GraphQL-WS protocol
logger.debug(f"[PROTOCOL:{subscription_name}] Initializing GraphQL-WS protocol...") logger.debug(f"[PROTOCOL:{subscription_name}] Initializing GraphQL-WS protocol...")
init_type = "connection_init" init_type = "connection_init"
init_payload: Dict[str, Any] = {"type": init_type} init_payload: dict[str, Any] = {"type": init_type}
if UNRAID_API_KEY: if UNRAID_API_KEY:
logger.debug(f"[AUTH:{subscription_name}] Adding authentication payload") logger.debug(f"[AUTH:{subscription_name}] Adding authentication payload")
auth_payload = { auth_payload = {
@@ -193,16 +197,17 @@ class SubscriptionManager:
logger.debug(f"[PROTOCOL:{subscription_name}] Sending connection_init message") logger.debug(f"[PROTOCOL:{subscription_name}] Sending connection_init message")
await websocket.send(json.dumps(init_payload)) await websocket.send(json.dumps(init_payload))
# Wait for connection acknowledgment # Wait for connection acknowledgment
logger.debug(f"[PROTOCOL:{subscription_name}] Waiting for connection_ack...") logger.debug(f"[PROTOCOL:{subscription_name}] Waiting for connection_ack...")
init_raw = await asyncio.wait_for(websocket.recv(), timeout=30) init_raw = await asyncio.wait_for(websocket.recv(), timeout=30)
try: try:
init_data = json.loads(init_raw) init_data = json.loads(init_raw)
logger.debug(f"[PROTOCOL:{subscription_name}] Received init response: {init_data.get('type')}") logger.debug(f"[PROTOCOL:{subscription_name}] Received init response: {init_data.get('type')}")
except json.JSONDecodeError as e: except json.JSONDecodeError as e:
logger.error(f"[PROTOCOL:{subscription_name}] Failed to decode init response: {init_raw[:200]}...") init_preview = init_raw[:200] if isinstance(init_raw, str) else init_raw[:200].decode('utf-8', errors='replace')
logger.error(f"[PROTOCOL:{subscription_name}] Failed to decode init response: {init_preview}...")
self.last_error[subscription_name] = f"Invalid JSON in init response: {e}" self.last_error[subscription_name] = f"Invalid JSON in init response: {e}"
break break
@@ -219,7 +224,7 @@ class SubscriptionManager:
else: else:
logger.warning(f"[PROTOCOL:{subscription_name}] Unexpected init response: {init_data}") logger.warning(f"[PROTOCOL:{subscription_name}] Unexpected init response: {init_data}")
# Continue anyway - some servers send other messages first # Continue anyway - some servers send other messages first
# Start the subscription # Start the subscription
logger.debug(f"[SUBSCRIPTION:{subscription_name}] Starting GraphQL subscription...") logger.debug(f"[SUBSCRIPTION:{subscription_name}] Starting GraphQL subscription...")
start_type = "subscribe" if selected_proto == "graphql-transport-ws" else "start" start_type = "subscribe" if selected_proto == "graphql-transport-ws" else "start"
@@ -231,33 +236,32 @@ class SubscriptionManager:
"variables": variables "variables": variables
} }
} }
logger.debug(f"[SUBSCRIPTION:{subscription_name}] Subscription message type: {start_type}") logger.debug(f"[SUBSCRIPTION:{subscription_name}] Subscription message type: {start_type}")
logger.debug(f"[SUBSCRIPTION:{subscription_name}] Query: {query[:100]}...") logger.debug(f"[SUBSCRIPTION:{subscription_name}] Query: {query[:100]}...")
logger.debug(f"[SUBSCRIPTION:{subscription_name}] Variables: {variables}") logger.debug(f"[SUBSCRIPTION:{subscription_name}] Variables: {variables}")
await websocket.send(json.dumps(subscription_message)) await websocket.send(json.dumps(subscription_message))
logger.info(f"[SUBSCRIPTION:{subscription_name}] Subscription started successfully") logger.info(f"[SUBSCRIPTION:{subscription_name}] Subscription started successfully")
self.connection_states[subscription_name] = "subscribed" self.connection_states[subscription_name] = "subscribed"
# Listen for subscription data # Listen for subscription data
message_count = 0 message_count = 0
last_data_time = datetime.now()
async for message in websocket: async for message in websocket:
try: try:
data = json.loads(message) data = json.loads(message)
message_count += 1 message_count += 1
message_type = data.get('type', 'unknown') message_type = data.get('type', 'unknown')
logger.debug(f"[DATA:{subscription_name}] Message #{message_count}: {message_type}") logger.debug(f"[DATA:{subscription_name}] Message #{message_count}: {message_type}")
# Handle different message types # Handle different message types
expected_data_type = "next" if selected_proto == "graphql-transport-ws" else "data" expected_data_type = "next" if selected_proto == "graphql-transport-ws" else "data"
if data.get("type") == expected_data_type and data.get("id") == subscription_name: if data.get("type") == expected_data_type and data.get("id") == subscription_name:
payload = data.get("payload", {}) payload = data.get("payload", {})
if payload.get("data"): if payload.get("data"):
logger.info(f"[DATA:{subscription_name}] Received subscription data update") logger.info(f"[DATA:{subscription_name}] Received subscription data update")
self.resource_data[subscription_name] = SubscriptionData( self.resource_data[subscription_name] = SubscriptionData(
@@ -265,77 +269,78 @@ class SubscriptionManager:
last_updated=datetime.now(), last_updated=datetime.now(),
subscription_type=subscription_name subscription_type=subscription_name
) )
last_data_time = datetime.now()
logger.debug(f"[RESOURCE:{subscription_name}] Resource data updated successfully") logger.debug(f"[RESOURCE:{subscription_name}] Resource data updated successfully")
elif payload.get("errors"): elif payload.get("errors"):
logger.error(f"[DATA:{subscription_name}] GraphQL errors in response: {payload['errors']}") logger.error(f"[DATA:{subscription_name}] GraphQL errors in response: {payload['errors']}")
self.last_error[subscription_name] = f"GraphQL errors: {payload['errors']}" self.last_error[subscription_name] = f"GraphQL errors: {payload['errors']}"
else: else:
logger.warning(f"[DATA:{subscription_name}] Empty or invalid data payload: {payload}") logger.warning(f"[DATA:{subscription_name}] Empty or invalid data payload: {payload}")
elif data.get("type") == "ping": elif data.get("type") == "ping":
logger.debug(f"[PROTOCOL:{subscription_name}] Received ping, sending pong") logger.debug(f"[PROTOCOL:{subscription_name}] Received ping, sending pong")
await websocket.send(json.dumps({"type": "pong"})) await websocket.send(json.dumps({"type": "pong"}))
elif data.get("type") == "error": elif data.get("type") == "error":
error_payload = data.get('payload', {}) error_payload = data.get('payload', {})
logger.error(f"[SUBSCRIPTION:{subscription_name}] Subscription error: {error_payload}") logger.error(f"[SUBSCRIPTION:{subscription_name}] Subscription error: {error_payload}")
self.last_error[subscription_name] = f"Subscription error: {error_payload}" self.last_error[subscription_name] = f"Subscription error: {error_payload}"
self.connection_states[subscription_name] = "error" self.connection_states[subscription_name] = "error"
elif data.get("type") == "complete": elif data.get("type") == "complete":
logger.info(f"[SUBSCRIPTION:{subscription_name}] Subscription completed by server") logger.info(f"[SUBSCRIPTION:{subscription_name}] Subscription completed by server")
self.connection_states[subscription_name] = "completed" self.connection_states[subscription_name] = "completed"
break break
elif data.get("type") in ["ka", "ping", "pong"]: elif data.get("type") in ["ka", "ping", "pong"]:
logger.debug(f"[PROTOCOL:{subscription_name}] Keepalive message: {message_type}") logger.debug(f"[PROTOCOL:{subscription_name}] Keepalive message: {message_type}")
else: else:
logger.debug(f"[PROTOCOL:{subscription_name}] Unhandled message type: {message_type}") logger.debug(f"[PROTOCOL:{subscription_name}] Unhandled message type: {message_type}")
except json.JSONDecodeError as e: except json.JSONDecodeError as e:
logger.error(f"[PROTOCOL:{subscription_name}] Failed to decode message: {message[:200]}...") msg_preview = message[:200] if isinstance(message, str) else message[:200].decode('utf-8', errors='replace')
logger.error(f"[PROTOCOL:{subscription_name}] Failed to decode message: {msg_preview}...")
logger.error(f"[PROTOCOL:{subscription_name}] JSON decode error: {e}") logger.error(f"[PROTOCOL:{subscription_name}] JSON decode error: {e}")
except Exception as e: except Exception as e:
logger.error(f"[DATA:{subscription_name}] Error processing message: {e}") logger.error(f"[DATA:{subscription_name}] Error processing message: {e}")
logger.debug(f"[DATA:{subscription_name}] Raw message: {message[:200]}...") msg_preview = message[:200] if isinstance(message, str) else message[:200].decode('utf-8', errors='replace')
logger.debug(f"[DATA:{subscription_name}] Raw message: {msg_preview}...")
except asyncio.TimeoutError: except asyncio.TimeoutError:
error_msg = "Connection or authentication timeout" error_msg = "Connection or authentication timeout"
logger.error(f"[WEBSOCKET:{subscription_name}] {error_msg}") logger.error(f"[WEBSOCKET:{subscription_name}] {error_msg}")
self.last_error[subscription_name] = error_msg self.last_error[subscription_name] = error_msg
self.connection_states[subscription_name] = "timeout" self.connection_states[subscription_name] = "timeout"
except websockets.exceptions.ConnectionClosed as e: except websockets.exceptions.ConnectionClosed as e:
error_msg = f"WebSocket connection closed: {e}" error_msg = f"WebSocket connection closed: {e}"
logger.warning(f"[WEBSOCKET:{subscription_name}] {error_msg}") logger.warning(f"[WEBSOCKET:{subscription_name}] {error_msg}")
self.last_error[subscription_name] = error_msg self.last_error[subscription_name] = error_msg
self.connection_states[subscription_name] = "disconnected" self.connection_states[subscription_name] = "disconnected"
except websockets.exceptions.InvalidURI as e: except websockets.exceptions.InvalidURI as e:
error_msg = f"Invalid WebSocket URI: {e}" error_msg = f"Invalid WebSocket URI: {e}"
logger.error(f"[WEBSOCKET:{subscription_name}] {error_msg}") logger.error(f"[WEBSOCKET:{subscription_name}] {error_msg}")
self.last_error[subscription_name] = error_msg self.last_error[subscription_name] = error_msg
self.connection_states[subscription_name] = "invalid_uri" self.connection_states[subscription_name] = "invalid_uri"
break # Don't retry on invalid URI break # Don't retry on invalid URI
except Exception as e: except Exception as e:
error_msg = f"Unexpected error: {e}" error_msg = f"Unexpected error: {e}"
logger.error(f"[WEBSOCKET:{subscription_name}] {error_msg}") logger.error(f"[WEBSOCKET:{subscription_name}] {error_msg}")
self.last_error[subscription_name] = error_msg self.last_error[subscription_name] = error_msg
self.connection_states[subscription_name] = "error" self.connection_states[subscription_name] = "error"
# Calculate backoff delay # Calculate backoff delay
retry_delay = min(retry_delay * 1.5, max_retry_delay) retry_delay = min(retry_delay * 1.5, max_retry_delay)
logger.info(f"[WEBSOCKET:{subscription_name}] Reconnecting in {retry_delay:.1f} seconds...") logger.info(f"[WEBSOCKET:{subscription_name}] Reconnecting in {retry_delay:.1f} seconds...")
self.connection_states[subscription_name] = "reconnecting" self.connection_states[subscription_name] = "reconnecting"
await asyncio.sleep(retry_delay) await asyncio.sleep(retry_delay)
def get_resource_data(self, resource_name: str) -> Optional[Dict[str, Any]]: def get_resource_data(self, resource_name: str) -> dict[str, Any] | None:
"""Get current resource data with enhanced logging.""" """Get current resource data with enhanced logging."""
logger.debug(f"[RESOURCE:{resource_name}] Resource data requested") logger.debug(f"[RESOURCE:{resource_name}] Resource data requested")
if resource_name in self.resource_data: if resource_name in self.resource_data:
data = self.resource_data[resource_name] data = self.resource_data[resource_name]
age_seconds = (datetime.now() - data.last_updated).total_seconds() age_seconds = (datetime.now() - data.last_updated).total_seconds()
@@ -344,17 +349,17 @@ class SubscriptionManager:
else: else:
logger.debug(f"[RESOURCE:{resource_name}] No data available") logger.debug(f"[RESOURCE:{resource_name}] No data available")
return None return None
def list_active_subscriptions(self) -> List[str]: def list_active_subscriptions(self) -> list[str]:
"""List all active subscriptions.""" """List all active subscriptions."""
active = list(self.active_subscriptions.keys()) active = list(self.active_subscriptions.keys())
logger.debug(f"[SUBSCRIPTION_MANAGER] Active subscriptions: {active}") logger.debug(f"[SUBSCRIPTION_MANAGER] Active subscriptions: {active}")
return active return active
def get_subscription_status(self) -> Dict[str, Dict[str, Any]]: def get_subscription_status(self) -> dict[str, dict[str, Any]]:
"""Get detailed status of all subscriptions for diagnostics.""" """Get detailed status of all subscriptions for diagnostics."""
status = {} status = {}
for sub_name, config in self.subscription_configs.items(): for sub_name, config in self.subscription_configs.items():
sub_status = { sub_status = {
"config": { "config": {
@@ -369,7 +374,7 @@ class SubscriptionManager:
"last_error": self.last_error.get(sub_name, None) "last_error": self.last_error.get(sub_name, None)
} }
} }
# Add data info if available # Add data info if available
if sub_name in self.resource_data: if sub_name in self.resource_data:
data_info = self.resource_data[sub_name] data_info = self.resource_data[sub_name]
@@ -381,12 +386,12 @@ class SubscriptionManager:
} }
else: else:
sub_status["data"] = {"available": False} sub_status["data"] = {"available": False}
status[sub_name] = sub_status status[sub_name] = sub_status
logger.debug(f"[SUBSCRIPTION_MANAGER] Generated status for {len(status)} subscriptions") logger.debug(f"[SUBSCRIPTION_MANAGER] Generated status for {len(status)} subscriptions")
return status return status
# Global subscription manager instance # Global subscription manager instance
subscription_manager = SubscriptionManager() subscription_manager = SubscriptionManager()

View File

@@ -13,18 +13,17 @@ from fastmcp import FastMCP
from ..config.logging import logger from ..config.logging import logger
from .manager import subscription_manager from .manager import subscription_manager
# Global flag to track subscription startup # Global flag to track subscription startup
_subscriptions_started = False _subscriptions_started = False
async def ensure_subscriptions_started(): async def ensure_subscriptions_started() -> None:
"""Ensure subscriptions are started, called from async context.""" """Ensure subscriptions are started, called from async context."""
global _subscriptions_started global _subscriptions_started
if _subscriptions_started: if _subscriptions_started:
return return
logger.info("[STARTUP] First async operation detected, starting subscriptions...") logger.info("[STARTUP] First async operation detected, starting subscriptions...")
try: try:
await autostart_subscriptions() await autostart_subscriptions()
@@ -34,17 +33,17 @@ async def ensure_subscriptions_started():
logger.error(f"[STARTUP] Failed to start subscriptions: {e}", exc_info=True) logger.error(f"[STARTUP] Failed to start subscriptions: {e}", exc_info=True)
async def autostart_subscriptions(): async def autostart_subscriptions() -> None:
"""Auto-start all subscriptions marked for auto-start in SubscriptionManager.""" """Auto-start all subscriptions marked for auto-start in SubscriptionManager."""
logger.info("[AUTOSTART] Initiating subscription auto-start process...") logger.info("[AUTOSTART] Initiating subscription auto-start process...")
try: try:
# Use the new SubscriptionManager auto-start method # Use the new SubscriptionManager auto-start method
await subscription_manager.auto_start_all_subscriptions() await subscription_manager.auto_start_all_subscriptions()
logger.info("[AUTOSTART] Auto-start process completed successfully") logger.info("[AUTOSTART] Auto-start process completed successfully")
except Exception as e: except Exception as e:
logger.error(f"[AUTOSTART] Failed during auto-start process: {e}", exc_info=True) logger.error(f"[AUTOSTART] Failed during auto-start process: {e}", exc_info=True)
# Optional log file subscription # Optional log file subscription
log_path = os.getenv("UNRAID_AUTOSTART_LOG_PATH") log_path = os.getenv("UNRAID_AUTOSTART_LOG_PATH")
if log_path is None: if log_path is None:
@@ -53,13 +52,13 @@ async def autostart_subscriptions():
if Path(default_path).exists(): if Path(default_path).exists():
log_path = default_path log_path = default_path
logger.info(f"[AUTOSTART] Using default log path: {default_path}") logger.info(f"[AUTOSTART] Using default log path: {default_path}")
if log_path: if log_path:
try: try:
logger.info(f"[AUTOSTART] Starting log file subscription for: {log_path}") logger.info(f"[AUTOSTART] Starting log file subscription for: {log_path}")
config = subscription_manager.subscription_configs.get("logFileSubscription") config = subscription_manager.subscription_configs.get("logFileSubscription")
if config: if config:
await subscription_manager.start_subscription("logFileSubscription", config["query"], {"path": log_path}) await subscription_manager.start_subscription("logFileSubscription", str(config["query"]), {"path": log_path})
logger.info(f"[AUTOSTART] Log file subscription started for: {log_path}") logger.info(f"[AUTOSTART] Log file subscription started for: {log_path}")
else: else:
logger.error("[AUTOSTART] logFileSubscription config not found") logger.error("[AUTOSTART] logFileSubscription config not found")
@@ -69,13 +68,13 @@ async def autostart_subscriptions():
logger.info("[AUTOSTART] No log file path configured for auto-start") logger.info("[AUTOSTART] No log file path configured for auto-start")
def register_subscription_resources(mcp: FastMCP): def register_subscription_resources(mcp: FastMCP) -> None:
"""Register all subscription resources with the FastMCP instance. """Register all subscription resources with the FastMCP instance.
Args: Args:
mcp: FastMCP instance to register resources with mcp: FastMCP instance to register resources with
""" """
@mcp.resource("unraid://logs/stream") @mcp.resource("unraid://logs/stream")
async def logs_stream_resource() -> str: async def logs_stream_resource() -> str:
"""Real-time log stream data from subscription.""" """Real-time log stream data from subscription."""
@@ -88,4 +87,4 @@ def register_subscription_resources(mcp: FastMCP):
"message": "Subscriptions auto-start on server boot. If this persists, check server logs for WebSocket/auth issues." "message": "Subscriptions auto-start on server boot. If this persists, check server logs for WebSocket/auth issues."
}) })
logger.info("Subscription resources registered successfully") logger.info("Subscription resources registered successfully")

View File

@@ -1 +1 @@
"""MCP tools organized by functional domain.""" """MCP tools organized by functional domain."""

View File

@@ -65,7 +65,7 @@ def get_available_container_names(containers: list[dict[str, Any]]) -> list[str]
return names return names
def register_docker_tools(mcp: FastMCP): def register_docker_tools(mcp: FastMCP) -> None:
"""Register all Docker tools with the FastMCP instance. """Register all Docker tools with the FastMCP instance.
Args: Args:
@@ -97,11 +97,12 @@ def register_docker_tools(mcp: FastMCP):
logger.info("Executing list_docker_containers tool") logger.info("Executing list_docker_containers tool")
response_data = await make_graphql_request(query) response_data = await make_graphql_request(query)
if response_data.get("docker"): if response_data.get("docker"):
return response_data["docker"].get("containers", []) containers = response_data["docker"].get("containers", [])
return list(containers) if isinstance(containers, list) else []
return [] return []
except Exception as e: except Exception as e:
logger.error(f"Error in list_docker_containers: {e}", exc_info=True) logger.error(f"Error in list_docker_containers: {e}", exc_info=True)
raise ToolError(f"Failed to list Docker containers: {str(e)}") raise ToolError(f"Failed to list Docker containers: {str(e)}") from e
@mcp.tool() @mcp.tool()
async def manage_docker_container(container_id: str, action: str) -> dict[str, Any]: async def manage_docker_container(container_id: str, action: str) -> dict[str, Any]:
@@ -161,7 +162,7 @@ def register_docker_tools(mcp: FastMCP):
containers = list_response["docker"].get("containers", []) containers = list_response["docker"].get("containers", [])
resolved_container = find_container_by_identifier(container_id, containers) resolved_container = find_container_by_identifier(container_id, containers)
if resolved_container: if resolved_container:
actual_container_id = resolved_container.get("id") actual_container_id = str(resolved_container.get("id", ""))
logger.info(f"Resolved '{container_id}' to container ID: {actual_container_id}") logger.info(f"Resolved '{container_id}' to container ID: {actual_container_id}")
else: else:
available_names = get_available_container_names(containers) available_names = get_available_container_names(containers)
@@ -309,7 +310,7 @@ def register_docker_tools(mcp: FastMCP):
except Exception as e: except Exception as e:
logger.error(f"Error in manage_docker_container ({action}): {e}", exc_info=True) logger.error(f"Error in manage_docker_container ({action}): {e}", exc_info=True)
raise ToolError(f"Failed to {action} Docker container: {str(e)}") raise ToolError(f"Failed to {action} Docker container: {str(e)}") from e
@mcp.tool() @mcp.tool()
async def get_docker_container_details(container_identifier: str) -> dict[str, Any]: async def get_docker_container_details(container_identifier: str) -> dict[str, Any]:
@@ -382,6 +383,6 @@ def register_docker_tools(mcp: FastMCP):
except Exception as e: except Exception as e:
logger.error(f"Error in get_docker_container_details: {e}", exc_info=True) logger.error(f"Error in get_docker_container_details: {e}", exc_info=True)
raise ToolError(f"Failed to retrieve Docker container details: {str(e)}") raise ToolError(f"Failed to retrieve Docker container details: {str(e)}") from e
logger.info("Docker tools registered successfully") logger.info("Docker tools registered successfully")

View File

@@ -7,30 +7,29 @@ notifications, Docker services, and API responsiveness.
import datetime import datetime
import time import time
from typing import Any, Dict from typing import Any
from fastmcp import FastMCP from fastmcp import FastMCP
from ..config.logging import logger from ..config.logging import logger
from ..config.settings import UNRAID_API_URL, UNRAID_MCP_HOST, UNRAID_MCP_PORT, UNRAID_MCP_TRANSPORT from ..config.settings import UNRAID_API_URL, UNRAID_MCP_HOST, UNRAID_MCP_PORT, UNRAID_MCP_TRANSPORT
from ..core.client import make_graphql_request from ..core.client import make_graphql_request
from ..core.exceptions import ToolError
def register_health_tools(mcp: FastMCP): def register_health_tools(mcp: FastMCP) -> None:
"""Register all health tools with the FastMCP instance. """Register all health tools with the FastMCP instance.
Args: Args:
mcp: FastMCP instance to register tools with mcp: FastMCP instance to register tools with
""" """
@mcp.tool() @mcp.tool()
async def health_check() -> Dict[str, Any]: async def health_check() -> dict[str, Any]:
"""Returns comprehensive health status of the Unraid MCP server and system for monitoring purposes.""" """Returns comprehensive health status of the Unraid MCP server and system for monitoring purposes."""
start_time = time.time() start_time = time.time()
health_status = "healthy" health_status = "healthy"
issues = [] issues = []
try: try:
# Enhanced health check with multiple system components # Enhanced health check with multiple system components
comprehensive_query = """ comprehensive_query = """
@@ -58,10 +57,10 @@ def register_health_tools(mcp: FastMCP):
} }
} }
""" """
response_data = await make_graphql_request(comprehensive_query) response_data = await make_graphql_request(comprehensive_query)
api_latency = round((time.time() - start_time) * 1000, 2) # ms api_latency = round((time.time() - start_time) * 1000, 2) # ms
# Base health info # Base health info
health_info = { health_info = {
"status": health_status, "status": health_status,
@@ -76,14 +75,14 @@ def register_health_tools(mcp: FastMCP):
"process_uptime_seconds": time.time() - start_time # Rough estimate "process_uptime_seconds": time.time() - start_time # Rough estimate
} }
} }
if not response_data: if not response_data:
health_status = "unhealthy" health_status = "unhealthy"
issues.append("No response from Unraid API") issues.append("No response from Unraid API")
health_info["status"] = health_status health_info["status"] = health_status
health_info["issues"] = issues health_info["issues"] = issues
return health_info return health_info
# System info analysis # System info analysis
info = response_data.get("info", {}) info = response_data.get("info", {})
if info: if info:
@@ -98,7 +97,7 @@ def register_health_tools(mcp: FastMCP):
else: else:
health_status = "degraded" health_status = "degraded"
issues.append("Unable to retrieve system info") issues.append("Unable to retrieve system info")
# Array health analysis # Array health analysis
array_info = response_data.get("array", {}) array_info = response_data.get("array", {})
if array_info: if array_info:
@@ -113,7 +112,7 @@ def register_health_tools(mcp: FastMCP):
else: else:
health_status = "warning" health_status = "warning"
issues.append("Unable to retrieve array status") issues.append("Unable to retrieve array status")
# Notifications analysis # Notifications analysis
notifications = response_data.get("notifications", {}) notifications = response_data.get("notifications", {})
if notifications and notifications.get("overview"): if notifications and notifications.get("overview"):
@@ -121,32 +120,32 @@ def register_health_tools(mcp: FastMCP):
alert_count = unread.get("alert", 0) alert_count = unread.get("alert", 0)
warning_count = unread.get("warning", 0) warning_count = unread.get("warning", 0)
total_unread = unread.get("total", 0) total_unread = unread.get("total", 0)
health_info["notifications"] = { health_info["notifications"] = {
"unread_total": total_unread, "unread_total": total_unread,
"unread_alerts": alert_count, "unread_alerts": alert_count,
"unread_warnings": warning_count, "unread_warnings": warning_count,
"has_critical_notifications": alert_count > 0 "has_critical_notifications": alert_count > 0
} }
if alert_count > 0: if alert_count > 0:
health_status = "warning" health_status = "warning"
issues.append(f"{alert_count} unread alert notification(s)") issues.append(f"{alert_count} unread alert notification(s)")
# Docker services analysis # Docker services analysis
docker_info = response_data.get("docker", {}) docker_info = response_data.get("docker", {})
if docker_info and docker_info.get("containers"): if docker_info and docker_info.get("containers"):
containers = docker_info["containers"] containers = docker_info["containers"]
running_containers = [c for c in containers if c.get("state") == "running"] running_containers = [c for c in containers if c.get("state") == "running"]
stopped_containers = [c for c in containers if c.get("state") == "exited"] stopped_containers = [c for c in containers if c.get("state") == "exited"]
health_info["docker_services"] = { health_info["docker_services"] = {
"total_containers": len(containers), "total_containers": len(containers),
"running_containers": len(running_containers), "running_containers": len(running_containers),
"stopped_containers": len(stopped_containers), "stopped_containers": len(stopped_containers),
"containers_healthy": len([c for c in containers if c.get("status", "").startswith("Up")]) "containers_healthy": len([c for c in containers if c.get("status", "").startswith("Up")])
} }
# API performance assessment # API performance assessment
if api_latency > 5000: # > 5 seconds if api_latency > 5000: # > 5 seconds
health_status = "warning" health_status = "warning"
@@ -154,20 +153,20 @@ def register_health_tools(mcp: FastMCP):
elif api_latency > 10000: # > 10 seconds elif api_latency > 10000: # > 10 seconds
health_status = "degraded" health_status = "degraded"
issues.append(f"Very high API latency: {api_latency}ms") issues.append(f"Very high API latency: {api_latency}ms")
# Final status determination # Final status determination
health_info["status"] = health_status health_info["status"] = health_status
if issues: if issues:
health_info["issues"] = issues health_info["issues"] = issues
# Add performance metrics # Add performance metrics
health_info["performance"] = { health_info["performance"] = {
"api_response_time_ms": api_latency, "api_response_time_ms": api_latency,
"health_check_duration_ms": round((time.time() - start_time) * 1000, 2) "health_check_duration_ms": round((time.time() - start_time) * 1000, 2)
} }
return health_info return health_info
except Exception as e: except Exception as e:
logger.error(f"Health check failed: {e}") logger.error(f"Health check failed: {e}")
return { return {
@@ -184,4 +183,4 @@ def register_health_tools(mcp: FastMCP):
} }
} }
logger.info("Health tools registered successfully") logger.info("Health tools registered successfully")

View File

@@ -5,7 +5,7 @@ remotes, getting configuration forms, creating new remotes, and deleting remotes
for various cloud storage providers (S3, Google Drive, Dropbox, FTP, etc.). for various cloud storage providers (S3, Google Drive, Dropbox, FTP, etc.).
""" """
from typing import Any, Dict, List, Optional from typing import Any
from fastmcp import FastMCP from fastmcp import FastMCP
@@ -14,15 +14,15 @@ from ..core.client import make_graphql_request
from ..core.exceptions import ToolError from ..core.exceptions import ToolError
def register_rclone_tools(mcp: FastMCP): def register_rclone_tools(mcp: FastMCP) -> None:
"""Register all RClone tools with the FastMCP instance. """Register all RClone tools with the FastMCP instance.
Args: Args:
mcp: FastMCP instance to register tools with mcp: FastMCP instance to register tools with
""" """
@mcp.tool() @mcp.tool()
async def list_rclone_remotes() -> List[Dict[str, Any]]: async def list_rclone_remotes() -> list[dict[str, Any]]:
"""Retrieves all configured RClone remotes with their configuration details.""" """Retrieves all configured RClone remotes with their configuration details."""
try: try:
query = """ query = """
@@ -37,25 +37,25 @@ def register_rclone_tools(mcp: FastMCP):
} }
} }
""" """
response_data = await make_graphql_request(query) response_data = await make_graphql_request(query)
if "rclone" in response_data and "remotes" in response_data["rclone"]: if "rclone" in response_data and "remotes" in response_data["rclone"]:
remotes = response_data["rclone"]["remotes"] remotes = response_data["rclone"]["remotes"]
logger.info(f"Retrieved {len(remotes)} RClone remotes") logger.info(f"Retrieved {len(remotes)} RClone remotes")
return remotes return list(remotes) if isinstance(remotes, list) else []
return [] return []
except Exception as e: except Exception as e:
logger.error(f"Failed to list RClone remotes: {str(e)}") logger.error(f"Failed to list RClone remotes: {str(e)}")
raise ToolError(f"Failed to list RClone remotes: {str(e)}") raise ToolError(f"Failed to list RClone remotes: {str(e)}") from e
@mcp.tool() @mcp.tool()
async def get_rclone_config_form(provider_type: Optional[str] = None) -> Dict[str, Any]: async def get_rclone_config_form(provider_type: str | None = None) -> dict[str, Any]:
""" """
Get RClone configuration form schema for setting up new remotes. Get RClone configuration form schema for setting up new remotes.
Args: Args:
provider_type: Optional provider type to get specific form (e.g., 's3', 'drive', 'dropbox') provider_type: Optional provider type to get specific form (e.g., 's3', 'drive', 'dropbox')
""" """
@@ -71,29 +71,29 @@ def register_rclone_tools(mcp: FastMCP):
} }
} }
""" """
variables = {} variables = {}
if provider_type: if provider_type:
variables["formOptions"] = {"providerType": provider_type} variables["formOptions"] = {"providerType": provider_type}
response_data = await make_graphql_request(query, variables) response_data = await make_graphql_request(query, variables)
if "rclone" in response_data and "configForm" in response_data["rclone"]: if "rclone" in response_data and "configForm" in response_data["rclone"]:
form_data = response_data["rclone"]["configForm"] form_data = response_data["rclone"]["configForm"]
logger.info(f"Retrieved RClone config form for {provider_type or 'general'}") logger.info(f"Retrieved RClone config form for {provider_type or 'general'}")
return form_data return dict(form_data) if isinstance(form_data, dict) else {}
raise ToolError("No RClone config form data received") raise ToolError("No RClone config form data received")
except Exception as e: except Exception as e:
logger.error(f"Failed to get RClone config form: {str(e)}") logger.error(f"Failed to get RClone config form: {str(e)}")
raise ToolError(f"Failed to get RClone config form: {str(e)}") raise ToolError(f"Failed to get RClone config form: {str(e)}") from e
@mcp.tool() @mcp.tool()
async def create_rclone_remote(name: str, provider_type: str, config_data: Dict[str, Any]) -> Dict[str, Any]: async def create_rclone_remote(name: str, provider_type: str, config_data: dict[str, Any]) -> dict[str, Any]:
""" """
Create a new RClone remote with the specified configuration. Create a new RClone remote with the specified configuration.
Args: Args:
name: Name for the new remote name: Name for the new remote
provider_type: Type of provider (e.g., 's3', 'drive', 'dropbox', 'ftp') provider_type: Type of provider (e.g., 's3', 'drive', 'dropbox', 'ftp')
@@ -111,7 +111,7 @@ def register_rclone_tools(mcp: FastMCP):
} }
} }
""" """
variables = { variables = {
"input": { "input": {
"name": name, "name": name,
@@ -119,9 +119,9 @@ def register_rclone_tools(mcp: FastMCP):
"config": config_data "config": config_data
} }
} }
response_data = await make_graphql_request(mutation, variables) response_data = await make_graphql_request(mutation, variables)
if "rclone" in response_data and "createRCloneRemote" in response_data["rclone"]: if "rclone" in response_data and "createRCloneRemote" in response_data["rclone"]:
remote_info = response_data["rclone"]["createRCloneRemote"] remote_info = response_data["rclone"]["createRCloneRemote"]
logger.info(f"Successfully created RClone remote: {name}") logger.info(f"Successfully created RClone remote: {name}")
@@ -130,18 +130,18 @@ def register_rclone_tools(mcp: FastMCP):
"message": f"RClone remote '{name}' created successfully", "message": f"RClone remote '{name}' created successfully",
"remote": remote_info "remote": remote_info
} }
raise ToolError("Failed to create RClone remote") raise ToolError("Failed to create RClone remote")
except Exception as e: except Exception as e:
logger.error(f"Failed to create RClone remote {name}: {str(e)}") logger.error(f"Failed to create RClone remote {name}: {str(e)}")
raise ToolError(f"Failed to create RClone remote {name}: {str(e)}") raise ToolError(f"Failed to create RClone remote {name}: {str(e)}") from e
@mcp.tool() @mcp.tool()
async def delete_rclone_remote(name: str) -> Dict[str, Any]: async def delete_rclone_remote(name: str) -> dict[str, Any]:
""" """
Delete an existing RClone remote by name. Delete an existing RClone remote by name.
Args: Args:
name: Name of the remote to delete name: Name of the remote to delete
""" """
@@ -153,26 +153,26 @@ def register_rclone_tools(mcp: FastMCP):
} }
} }
""" """
variables = { variables = {
"input": { "input": {
"name": name "name": name
} }
} }
response_data = await make_graphql_request(mutation, variables) response_data = await make_graphql_request(mutation, variables)
if "rclone" in response_data and response_data["rclone"]["deleteRCloneRemote"]: if "rclone" in response_data and response_data["rclone"]["deleteRCloneRemote"]:
logger.info(f"Successfully deleted RClone remote: {name}") logger.info(f"Successfully deleted RClone remote: {name}")
return { return {
"success": True, "success": True,
"message": f"RClone remote '{name}' deleted successfully" "message": f"RClone remote '{name}' deleted successfully"
} }
raise ToolError(f"Failed to delete RClone remote '{name}'") raise ToolError(f"Failed to delete RClone remote '{name}'")
except Exception as e: except Exception as e:
logger.error(f"Failed to delete RClone remote {name}: {str(e)}") logger.error(f"Failed to delete RClone remote {name}: {str(e)}")
raise ToolError(f"Failed to delete RClone remote {name}: {str(e)}") raise ToolError(f"Failed to delete RClone remote {name}: {str(e)}") from e
logger.info("RClone tools registered successfully") logger.info("RClone tools registered successfully")

View File

@@ -5,7 +5,7 @@ log files, physical disks with SMART data, and system storage operations
with custom timeout configurations for disk-intensive operations. with custom timeout configurations for disk-intensive operations.
""" """
from typing import Any, Dict, List, Optional from typing import Any
import httpx import httpx
from fastmcp import FastMCP from fastmcp import FastMCP
@@ -15,15 +15,15 @@ from ..core.client import make_graphql_request
from ..core.exceptions import ToolError from ..core.exceptions import ToolError
def register_storage_tools(mcp: FastMCP): def register_storage_tools(mcp: FastMCP) -> None:
"""Register all storage tools with the FastMCP instance. """Register all storage tools with the FastMCP instance.
Args: Args:
mcp: FastMCP instance to register tools with mcp: FastMCP instance to register tools with
""" """
@mcp.tool() @mcp.tool()
async def get_shares_info() -> List[Dict[str, Any]]: async def get_shares_info() -> list[dict[str, Any]]:
"""Retrieves information about user shares.""" """Retrieves information about user shares."""
query = """ query = """
query GetSharesInfo { query GetSharesInfo {
@@ -50,13 +50,14 @@ def register_storage_tools(mcp: FastMCP):
try: try:
logger.info("Executing get_shares_info tool") logger.info("Executing get_shares_info tool")
response_data = await make_graphql_request(query) response_data = await make_graphql_request(query)
return response_data.get("shares", []) shares = response_data.get("shares", [])
return list(shares) if isinstance(shares, list) else []
except Exception as e: except Exception as e:
logger.error(f"Error in get_shares_info: {e}", exc_info=True) logger.error(f"Error in get_shares_info: {e}", exc_info=True)
raise ToolError(f"Failed to retrieve shares information: {str(e)}") raise ToolError(f"Failed to retrieve shares information: {str(e)}") from e
@mcp.tool() @mcp.tool()
async def get_notifications_overview() -> Dict[str, Any]: async def get_notifications_overview() -> dict[str, Any]:
"""Retrieves an overview of system notifications (unread and archive counts by severity).""" """Retrieves an overview of system notifications (unread and archive counts by severity)."""
query = """ query = """
query GetNotificationsOverview { query GetNotificationsOverview {
@@ -72,19 +73,20 @@ def register_storage_tools(mcp: FastMCP):
logger.info("Executing get_notifications_overview tool") logger.info("Executing get_notifications_overview tool")
response_data = await make_graphql_request(query) response_data = await make_graphql_request(query)
if response_data.get("notifications"): if response_data.get("notifications"):
return response_data["notifications"].get("overview", {}) overview = response_data["notifications"].get("overview", {})
return dict(overview) if isinstance(overview, dict) else {}
return {} return {}
except Exception as e: except Exception as e:
logger.error(f"Error in get_notifications_overview: {e}", exc_info=True) logger.error(f"Error in get_notifications_overview: {e}", exc_info=True)
raise ToolError(f"Failed to retrieve notifications overview: {str(e)}") raise ToolError(f"Failed to retrieve notifications overview: {str(e)}") from e
@mcp.tool() @mcp.tool()
async def list_notifications( async def list_notifications(
type: str, type: str,
offset: int, offset: int,
limit: int, limit: int,
importance: Optional[str] = None importance: str | None = None
) -> List[Dict[str, Any]]: ) -> list[dict[str, Any]]:
"""Lists notifications with filtering. Type: UNREAD/ARCHIVE. Importance: INFO/WARNING/ALERT.""" """Lists notifications with filtering. Type: UNREAD/ARCHIVE. Importance: INFO/WARNING/ALERT."""
query = """ query = """
query ListNotifications($filter: NotificationFilter!) { query ListNotifications($filter: NotificationFilter!) {
@@ -114,19 +116,20 @@ def register_storage_tools(mcp: FastMCP):
# Remove null importance from variables if not provided, as GraphQL might be strict # Remove null importance from variables if not provided, as GraphQL might be strict
if not importance: if not importance:
del variables["filter"]["importance"] del variables["filter"]["importance"]
try: try:
logger.info(f"Executing list_notifications: type={type}, offset={offset}, limit={limit}, importance={importance}") logger.info(f"Executing list_notifications: type={type}, offset={offset}, limit={limit}, importance={importance}")
response_data = await make_graphql_request(query, variables) response_data = await make_graphql_request(query, variables)
if response_data.get("notifications"): if response_data.get("notifications"):
return response_data["notifications"].get("list", []) notifications_list = response_data["notifications"].get("list", [])
return list(notifications_list) if isinstance(notifications_list, list) else []
return [] return []
except Exception as e: except Exception as e:
logger.error(f"Error in list_notifications: {e}", exc_info=True) logger.error(f"Error in list_notifications: {e}", exc_info=True)
raise ToolError(f"Failed to list notifications: {str(e)}") raise ToolError(f"Failed to list notifications: {str(e)}") from e
@mcp.tool() @mcp.tool()
async def list_available_log_files() -> List[Dict[str, Any]]: async def list_available_log_files() -> list[dict[str, Any]]:
"""Lists all available log files that can be queried.""" """Lists all available log files that can be queried."""
query = """ query = """
query ListLogFiles { query ListLogFiles {
@@ -141,13 +144,14 @@ def register_storage_tools(mcp: FastMCP):
try: try:
logger.info("Executing list_available_log_files tool") logger.info("Executing list_available_log_files tool")
response_data = await make_graphql_request(query) response_data = await make_graphql_request(query)
return response_data.get("logFiles", []) log_files = response_data.get("logFiles", [])
return list(log_files) if isinstance(log_files, list) else []
except Exception as e: except Exception as e:
logger.error(f"Error in list_available_log_files: {e}", exc_info=True) logger.error(f"Error in list_available_log_files: {e}", exc_info=True)
raise ToolError(f"Failed to list available log files: {str(e)}") raise ToolError(f"Failed to list available log files: {str(e)}") from e
@mcp.tool() @mcp.tool()
async def get_logs(log_file_path: str, tail_lines: int = 100) -> Dict[str, Any]: async def get_logs(log_file_path: str, tail_lines: int = 100) -> dict[str, Any]:
"""Retrieves content from a specific log file, defaulting to the last 100 lines.""" """Retrieves content from a specific log file, defaulting to the last 100 lines."""
# The Unraid GraphQL API Query.logFile takes 'lines' and 'startLine'. # The Unraid GraphQL API Query.logFile takes 'lines' and 'startLine'.
# To implement 'tail_lines', we would ideally need to know the total lines first, # To implement 'tail_lines', we would ideally need to know the total lines first,
@@ -158,7 +162,7 @@ def register_storage_tools(mcp: FastMCP):
# If not, this tool might need to be smarter or the API might not directly support 'tail' easily. # If not, this tool might need to be smarter or the API might not directly support 'tail' easily.
# The SDL for LogFileContent implies it returns startLine, so it seems aware of ranges. # The SDL for LogFileContent implies it returns startLine, so it seems aware of ranges.
# Let's try fetching with just 'lines' to see if it acts as a tail, # Let's try fetching with just 'lines' to see if it acts as a tail,
# or if we need Query.logFiles first to get totalLines for calculation. # or if we need Query.logFiles first to get totalLines for calculation.
# For robust tailing, one might need to fetch totalLines first, then calculate start_line for the tail. # For robust tailing, one might need to fetch totalLines first, then calculate start_line for the tail.
# Simplified: query for the last 'tail_lines'. If the API doesn't support tailing this way, we may need adjustment. # Simplified: query for the last 'tail_lines'. If the API doesn't support tailing this way, we may need adjustment.
@@ -178,16 +182,17 @@ def register_storage_tools(mcp: FastMCP):
try: try:
logger.info(f"Executing get_logs for {log_file_path}, tail_lines={tail_lines}") logger.info(f"Executing get_logs for {log_file_path}, tail_lines={tail_lines}")
response_data = await make_graphql_request(query, variables) response_data = await make_graphql_request(query, variables)
return response_data.get("logFile", {}) log_file = response_data.get("logFile", {})
return dict(log_file) if isinstance(log_file, dict) else {}
except Exception as e: except Exception as e:
logger.error(f"Error in get_logs for {log_file_path}: {e}", exc_info=True) logger.error(f"Error in get_logs for {log_file_path}: {e}", exc_info=True)
raise ToolError(f"Failed to retrieve logs from {log_file_path}: {str(e)}") raise ToolError(f"Failed to retrieve logs from {log_file_path}: {str(e)}") from e
@mcp.tool() @mcp.tool()
async def list_physical_disks() -> List[Dict[str, Any]]: async def list_physical_disks() -> list[dict[str, Any]]:
"""Lists all physical disks recognized by the Unraid system.""" """Lists all physical disks recognized by the Unraid system."""
# Querying an extremely minimal set of fields for diagnostics # Querying an extremely minimal set of fields for diagnostics
query = """ query = """
query ListPhysicalDisksMinimal { query ListPhysicalDisksMinimal {
disks { disks {
id id
@@ -199,15 +204,16 @@ def register_storage_tools(mcp: FastMCP):
try: try:
logger.info("Executing list_physical_disks tool with minimal query and increased timeout") logger.info("Executing list_physical_disks tool with minimal query and increased timeout")
# Increased read timeout for this potentially slow query # Increased read timeout for this potentially slow query
long_timeout = httpx.Timeout(10.0, read=90.0, connect=5.0) long_timeout = httpx.Timeout(10.0, read=90.0, connect=5.0)
response_data = await make_graphql_request(query, custom_timeout=long_timeout) response_data = await make_graphql_request(query, custom_timeout=long_timeout)
return response_data.get("disks", []) disks = response_data.get("disks", [])
return list(disks) if isinstance(disks, list) else []
except Exception as e: except Exception as e:
logger.error(f"Error in list_physical_disks: {e}", exc_info=True) logger.error(f"Error in list_physical_disks: {e}", exc_info=True)
raise ToolError(f"Failed to list physical disks: {str(e)}") raise ToolError(f"Failed to list physical disks: {str(e)}") from e
@mcp.tool() @mcp.tool()
async def get_disk_details(disk_id: str) -> Dict[str, Any]: async def get_disk_details(disk_id: str) -> dict[str, Any]:
"""Retrieves detailed SMART information and partition data for a specific physical disk.""" """Retrieves detailed SMART information and partition data for a specific physical disk."""
# Enhanced query with more comprehensive disk information # Enhanced query with more comprehensive disk information
query = """ query = """
@@ -227,19 +233,20 @@ def register_storage_tools(mcp: FastMCP):
logger.info(f"Executing get_disk_details for disk: {disk_id}") logger.info(f"Executing get_disk_details for disk: {disk_id}")
response_data = await make_graphql_request(query, variables) response_data = await make_graphql_request(query, variables)
raw_disk = response_data.get("disk", {}) raw_disk = response_data.get("disk", {})
if not raw_disk: if not raw_disk:
raise ToolError(f"Disk '{disk_id}' not found") raise ToolError(f"Disk '{disk_id}' not found")
# Process disk information for human-readable output # Process disk information for human-readable output
def format_bytes(bytes_value): def format_bytes(bytes_value: int | None) -> str:
if bytes_value is None: return "N/A" if bytes_value is None:
bytes_value = int(bytes_value) return "N/A"
value = float(int(bytes_value))
for unit in ['B', 'KB', 'MB', 'GB', 'TB', 'PB']: for unit in ['B', 'KB', 'MB', 'GB', 'TB', 'PB']:
if bytes_value < 1024.0: if value < 1024.0:
return f"{bytes_value:.2f} {unit}" return f"{value:.2f} {unit}"
bytes_value /= 1024.0 value /= 1024.0
return f"{bytes_value:.2f} EB" return f"{value:.2f} EB"
summary = { summary = {
'disk_id': raw_disk.get('id'), 'disk_id': raw_disk.get('id'),
@@ -256,15 +263,15 @@ def register_storage_tools(mcp: FastMCP):
'partition_count': len(raw_disk.get('partitions', [])), 'partition_count': len(raw_disk.get('partitions', [])),
'total_partition_size': format_bytes(sum(p.get('size', 0) for p in raw_disk.get('partitions', []) if p.get('size'))) 'total_partition_size': format_bytes(sum(p.get('size', 0) for p in raw_disk.get('partitions', []) if p.get('size')))
} }
return { return {
'summary': summary, 'summary': summary,
'partitions': raw_disk.get('partitions', []), 'partitions': raw_disk.get('partitions', []),
'details': raw_disk 'details': raw_disk
} }
except Exception as e: except Exception as e:
logger.error(f"Error in get_disk_details for {disk_id}: {e}", exc_info=True) logger.error(f"Error in get_disk_details for {disk_id}: {e}", exc_info=True)
raise ToolError(f"Failed to retrieve disk details for {disk_id}: {str(e)}") raise ToolError(f"Failed to retrieve disk details for {disk_id}: {str(e)}") from e
logger.info("Storage tools registered successfully") logger.info("Storage tools registered successfully")

View File

@@ -5,7 +5,7 @@ array status with health analysis, network configuration, registration info,
and system variables. and system variables.
""" """
from typing import Any, Dict from typing import Any
from fastmcp import FastMCP from fastmcp import FastMCP
@@ -15,7 +15,7 @@ from ..core.exceptions import ToolError
# Standalone functions for use by subscription resources # Standalone functions for use by subscription resources
async def _get_system_info() -> Dict[str, Any]: async def _get_system_info() -> dict[str, Any]:
"""Standalone function to get system info - used by subscriptions and tools.""" """Standalone function to get system info - used by subscriptions and tools."""
query = """ query = """
query GetSystemInfo { query GetSystemInfo {
@@ -44,20 +44,20 @@ async def _get_system_info() -> Dict[str, Any]:
raise ToolError("No system info returned from Unraid API") raise ToolError("No system info returned from Unraid API")
# Process for human-readable output # Process for human-readable output
summary = {} summary: dict[str, Any] = {}
if raw_info.get('os'): if raw_info.get('os'):
os_info = raw_info['os'] os_info = raw_info['os']
summary['os'] = f"{os_info.get('distro', '')} {os_info.get('release', '')} ({os_info.get('platform', '')}, {os_info.get('arch', '')})" summary['os'] = f"{os_info.get('distro', '')} {os_info.get('release', '')} ({os_info.get('platform', '')}, {os_info.get('arch', '')})"
summary['hostname'] = os_info.get('hostname') summary['hostname'] = os_info.get('hostname')
summary['uptime'] = os_info.get('uptime') summary['uptime'] = os_info.get('uptime')
if raw_info.get('cpu'): if raw_info.get('cpu'):
cpu_info = raw_info['cpu'] cpu_info = raw_info['cpu']
summary['cpu'] = f"{cpu_info.get('manufacturer', '')} {cpu_info.get('brand', '')} ({cpu_info.get('cores')} cores, {cpu_info.get('threads')} threads)" summary['cpu'] = f"{cpu_info.get('manufacturer', '')} {cpu_info.get('brand', '')} ({cpu_info.get('cores')} cores, {cpu_info.get('threads')} threads)"
if raw_info.get('memory') and raw_info['memory'].get('layout'): if raw_info.get('memory') and raw_info['memory'].get('layout'):
mem_layout = raw_info['memory']['layout'] mem_layout = raw_info['memory']['layout']
summary['memory_layout_details'] = [] # Renamed for clarity summary['memory_layout_details'] = [] # Renamed for clarity
# The API is not returning 'size' for individual sticks in the layout, even if queried. # The API is not returning 'size' for individual sticks in the layout, even if queried.
# So, we cannot calculate total from layout currently. # So, we cannot calculate total from layout currently.
for stick in mem_layout: for stick in mem_layout:
@@ -74,10 +74,10 @@ async def _get_system_info() -> Dict[str, Any]:
except Exception as e: except Exception as e:
logger.error(f"Error in get_system_info: {e}", exc_info=True) logger.error(f"Error in get_system_info: {e}", exc_info=True)
raise ToolError(f"Failed to retrieve system information: {str(e)}") raise ToolError(f"Failed to retrieve system information: {str(e)}") from e
async def _get_array_status() -> Dict[str, Any]: async def _get_array_status() -> dict[str, Any]:
"""Standalone function to get array status - used by subscriptions and tools.""" """Standalone function to get array status - used by subscriptions and tools."""
query = """ query = """
query GetArrayStatus { query GetArrayStatus {
@@ -102,34 +102,38 @@ async def _get_array_status() -> Dict[str, Any]:
if not raw_array_info: if not raw_array_info:
raise ToolError("No array information returned from Unraid API") raise ToolError("No array information returned from Unraid API")
summary = {} summary: dict[str, Any] = {}
summary['state'] = raw_array_info.get('state') summary['state'] = raw_array_info.get('state')
if raw_array_info.get('capacity') and raw_array_info['capacity'].get('kilobytes'): if raw_array_info.get('capacity') and raw_array_info['capacity'].get('kilobytes'):
kb_cap = raw_array_info['capacity']['kilobytes'] kb_cap = raw_array_info['capacity']['kilobytes']
# Helper to format KB into TB/GB/MB # Helper to format KB into TB/GB/MB
def format_kb(k): def format_kb(k: Any) -> str:
if k is None: return "N/A" if k is None:
return "N/A"
k = int(k) # Values are strings in SDL for PrefixedID containing types like capacity k = int(k) # Values are strings in SDL for PrefixedID containing types like capacity
if k >= 1024*1024*1024: return f"{k / (1024*1024*1024):.2f} TB" if k >= 1024*1024*1024:
if k >= 1024*1024: return f"{k / (1024*1024):.2f} GB" return f"{k / (1024*1024*1024):.2f} TB"
if k >= 1024: return f"{k / 1024:.2f} MB" if k >= 1024*1024:
return f"{k / (1024*1024):.2f} GB"
if k >= 1024:
return f"{k / 1024:.2f} MB"
return f"{k} KB" return f"{k} KB"
summary['capacity_total'] = format_kb(kb_cap.get('total')) summary['capacity_total'] = format_kb(kb_cap.get('total'))
summary['capacity_used'] = format_kb(kb_cap.get('used')) summary['capacity_used'] = format_kb(kb_cap.get('used'))
summary['capacity_free'] = format_kb(kb_cap.get('free')) summary['capacity_free'] = format_kb(kb_cap.get('free'))
summary['num_parity_disks'] = len(raw_array_info.get('parities', [])) summary['num_parity_disks'] = len(raw_array_info.get('parities', []))
summary['num_data_disks'] = len(raw_array_info.get('disks', [])) summary['num_data_disks'] = len(raw_array_info.get('disks', []))
summary['num_cache_pools'] = len(raw_array_info.get('caches', [])) # Note: caches are pools, not individual cache disks summary['num_cache_pools'] = len(raw_array_info.get('caches', [])) # Note: caches are pools, not individual cache disks
# Enhanced: Add disk health summary # Enhanced: Add disk health summary
def analyze_disk_health(disks, disk_type): def analyze_disk_health(disks: list[dict[str, Any]], disk_type: str) -> dict[str, int]:
"""Analyze health status of disk arrays""" """Analyze health status of disk arrays"""
if not disks: if not disks:
return {} return {}
health_counts = { health_counts = {
'healthy': 0, 'healthy': 0,
'failed': 0, 'failed': 0,
@@ -138,12 +142,12 @@ async def _get_array_status() -> Dict[str, Any]:
'warning': 0, 'warning': 0,
'unknown': 0 'unknown': 0
} }
for disk in disks: for disk in disks:
status = disk.get('status', '').upper() status = disk.get('status', '').upper()
warning = disk.get('warning') warning = disk.get('warning')
critical = disk.get('critical') critical = disk.get('critical')
if status == 'DISK_OK': if status == 'DISK_OK':
if warning or critical: if warning or critical:
health_counts['warning'] += 1 health_counts['warning'] += 1
@@ -157,7 +161,7 @@ async def _get_array_status() -> Dict[str, Any]:
health_counts['new'] += 1 health_counts['new'] += 1
else: else:
health_counts['unknown'] += 1 health_counts['unknown'] += 1
return health_counts return health_counts
# Analyze health for each disk type # Analyze health for each disk type
@@ -168,12 +172,12 @@ async def _get_array_status() -> Dict[str, Any]:
health_summary['data_health'] = analyze_disk_health(raw_array_info['disks'], 'data') health_summary['data_health'] = analyze_disk_health(raw_array_info['disks'], 'data')
if raw_array_info.get('caches'): if raw_array_info.get('caches'):
health_summary['cache_health'] = analyze_disk_health(raw_array_info['caches'], 'cache') health_summary['cache_health'] = analyze_disk_health(raw_array_info['caches'], 'cache')
# Overall array health assessment # Overall array health assessment
total_failed = sum(h.get('failed', 0) for h in health_summary.values()) total_failed = sum(h.get('failed', 0) for h in health_summary.values())
total_missing = sum(h.get('missing', 0) for h in health_summary.values()) total_missing = sum(h.get('missing', 0) for h in health_summary.values())
total_warning = sum(h.get('warning', 0) for h in health_summary.values()) total_warning = sum(h.get('warning', 0) for h in health_summary.values())
if total_failed > 0: if total_failed > 0:
overall_health = "CRITICAL" overall_health = "CRITICAL"
elif total_missing > 0: elif total_missing > 0:
@@ -182,7 +186,7 @@ async def _get_array_status() -> Dict[str, Any]:
overall_health = "WARNING" overall_health = "WARNING"
else: else:
overall_health = "HEALTHY" overall_health = "HEALTHY"
summary['overall_health'] = overall_health summary['overall_health'] = overall_health
summary['health_summary'] = health_summary summary['health_summary'] = health_summary
@@ -190,28 +194,28 @@ async def _get_array_status() -> Dict[str, Any]:
except Exception as e: except Exception as e:
logger.error(f"Error in get_array_status: {e}", exc_info=True) logger.error(f"Error in get_array_status: {e}", exc_info=True)
raise ToolError(f"Failed to retrieve array status: {str(e)}") raise ToolError(f"Failed to retrieve array status: {str(e)}") from e
def register_system_tools(mcp: FastMCP): def register_system_tools(mcp: FastMCP) -> None:
"""Register all system tools with the FastMCP instance. """Register all system tools with the FastMCP instance.
Args: Args:
mcp: FastMCP instance to register tools with mcp: FastMCP instance to register tools with
""" """
@mcp.tool() @mcp.tool()
async def get_system_info() -> Dict[str, Any]: async def get_system_info() -> dict[str, Any]:
"""Retrieves comprehensive information about the Unraid system, OS, CPU, memory, and baseboard.""" """Retrieves comprehensive information about the Unraid system, OS, CPU, memory, and baseboard."""
return await _get_system_info() return await _get_system_info()
@mcp.tool() @mcp.tool()
async def get_array_status() -> Dict[str, Any]: async def get_array_status() -> dict[str, Any]:
"""Retrieves the current status of the Unraid storage array, including its state, capacity, and details of all disks.""" """Retrieves the current status of the Unraid storage array, including its state, capacity, and details of all disks."""
return await _get_array_status() return await _get_array_status()
@mcp.tool() @mcp.tool()
async def get_network_config() -> Dict[str, Any]: async def get_network_config() -> dict[str, Any]:
"""Retrieves network configuration details, including access URLs.""" """Retrieves network configuration details, including access URLs."""
query = """ query = """
query GetNetworkConfig { query GetNetworkConfig {
@@ -224,13 +228,14 @@ def register_system_tools(mcp: FastMCP):
try: try:
logger.info("Executing get_network_config tool") logger.info("Executing get_network_config tool")
response_data = await make_graphql_request(query) response_data = await make_graphql_request(query)
return response_data.get("network", {}) network = response_data.get("network", {})
return dict(network) if isinstance(network, dict) else {}
except Exception as e: except Exception as e:
logger.error(f"Error in get_network_config: {e}", exc_info=True) logger.error(f"Error in get_network_config: {e}", exc_info=True)
raise ToolError(f"Failed to retrieve network configuration: {str(e)}") raise ToolError(f"Failed to retrieve network configuration: {str(e)}") from e
@mcp.tool() @mcp.tool()
async def get_registration_info() -> Dict[str, Any]: async def get_registration_info() -> dict[str, Any]:
"""Retrieves Unraid registration details.""" """Retrieves Unraid registration details."""
query = """ query = """
query GetRegistrationInfo { query GetRegistrationInfo {
@@ -247,13 +252,14 @@ def register_system_tools(mcp: FastMCP):
try: try:
logger.info("Executing get_registration_info tool") logger.info("Executing get_registration_info tool")
response_data = await make_graphql_request(query) response_data = await make_graphql_request(query)
return response_data.get("registration", {}) registration = response_data.get("registration", {})
return dict(registration) if isinstance(registration, dict) else {}
except Exception as e: except Exception as e:
logger.error(f"Error in get_registration_info: {e}", exc_info=True) logger.error(f"Error in get_registration_info: {e}", exc_info=True)
raise ToolError(f"Failed to retrieve registration information: {str(e)}") raise ToolError(f"Failed to retrieve registration information: {str(e)}") from e
@mcp.tool() @mcp.tool()
async def get_connect_settings() -> Dict[str, Any]: async def get_connect_settings() -> dict[str, Any]:
"""Retrieves settings related to Unraid Connect.""" """Retrieves settings related to Unraid Connect."""
# Based on actual schema: settings.unified.values contains the JSON settings # Based on actual schema: settings.unified.values contains the JSON settings
query = """ query = """
@@ -268,7 +274,7 @@ def register_system_tools(mcp: FastMCP):
try: try:
logger.info("Executing get_connect_settings tool") logger.info("Executing get_connect_settings tool")
response_data = await make_graphql_request(query) response_data = await make_graphql_request(query)
# Navigate down to the unified settings values # Navigate down to the unified settings values
if response_data.get("settings") and response_data["settings"].get("unified"): if response_data.get("settings") and response_data["settings"].get("unified"):
values = response_data["settings"]["unified"].get("values", {}) values = response_data["settings"]["unified"].get("values", {})
@@ -280,15 +286,15 @@ def register_system_tools(mcp: FastMCP):
if 'connect' in key.lower() or key in ['accessType', 'forwardType', 'port']: if 'connect' in key.lower() or key in ['accessType', 'forwardType', 'port']:
connect_settings[key] = value connect_settings[key] = value
return connect_settings if connect_settings else values return connect_settings if connect_settings else values
return values return dict(values) if isinstance(values, dict) else {}
return {} return {}
except Exception as e: except Exception as e:
logger.error(f"Error in get_connect_settings: {e}", exc_info=True) logger.error(f"Error in get_connect_settings: {e}", exc_info=True)
raise ToolError(f"Failed to retrieve Unraid Connect settings: {str(e)}") raise ToolError(f"Failed to retrieve Unraid Connect settings: {str(e)}") from e
@mcp.tool() @mcp.tool()
async def get_unraid_variables() -> Dict[str, Any]: async def get_unraid_variables() -> dict[str, Any]:
"""Retrieves a selection of Unraid system variables and settings. """Retrieves a selection of Unraid system variables and settings.
Note: Many variables are omitted due to API type issues (Int overflow/NaN). Note: Many variables are omitted due to API type issues (Int overflow/NaN).
""" """
# Querying a smaller, curated set of fields to avoid Int overflow and NaN issues # Querying a smaller, curated set of fields to avoid Int overflow and NaN issues
@@ -377,9 +383,10 @@ def register_system_tools(mcp: FastMCP):
try: try:
logger.info("Executing get_unraid_variables tool with a selective query") logger.info("Executing get_unraid_variables tool with a selective query")
response_data = await make_graphql_request(query) response_data = await make_graphql_request(query)
return response_data.get("vars", {}) vars_data = response_data.get("vars", {})
return dict(vars_data) if isinstance(vars_data, dict) else {}
except Exception as e: except Exception as e:
logger.error(f"Error in get_unraid_variables: {e}", exc_info=True) logger.error(f"Error in get_unraid_variables: {e}", exc_info=True)
raise ToolError(f"Failed to retrieve Unraid variables: {str(e)}") raise ToolError(f"Failed to retrieve Unraid variables: {str(e)}") from e
logger.info("System tools registered successfully") logger.info("System tools registered successfully")

View File

@@ -5,7 +5,7 @@ including listing VMs, VM operations (start/stop/pause/reboot/etc),
and detailed VM information retrieval. and detailed VM information retrieval.
""" """
from typing import Any, Dict, List from typing import Any
from fastmcp import FastMCP from fastmcp import FastMCP
@@ -14,17 +14,17 @@ from ..core.client import make_graphql_request
from ..core.exceptions import ToolError from ..core.exceptions import ToolError
def register_vm_tools(mcp: FastMCP): def register_vm_tools(mcp: FastMCP) -> None:
"""Register all VM tools with the FastMCP instance. """Register all VM tools with the FastMCP instance.
Args: Args:
mcp: FastMCP instance to register tools with mcp: FastMCP instance to register tools with
""" """
@mcp.tool() @mcp.tool()
async def list_vms() -> List[Dict[str, Any]]: async def list_vms() -> list[dict[str, Any]]:
"""Lists all Virtual Machines (VMs) on the Unraid system and their current state. """Lists all Virtual Machines (VMs) on the Unraid system and their current state.
Returns: Returns:
List of VM information dictionaries with UUID, name, and state List of VM information dictionaries with UUID, name, and state
""" """
@@ -48,7 +48,7 @@ def register_vm_tools(mcp: FastMCP):
if response_data.get("vms") and response_data["vms"].get("domains"): if response_data.get("vms") and response_data["vms"].get("domains"):
vms = response_data["vms"]["domains"] vms = response_data["vms"]["domains"]
logger.info(f"Found {len(vms)} VMs") logger.info(f"Found {len(vms)} VMs")
return vms return list(vms) if isinstance(vms, list) else []
else: else:
logger.info("No VMs found in domains field") logger.info("No VMs found in domains field")
return [] return []
@@ -56,18 +56,18 @@ def register_vm_tools(mcp: FastMCP):
logger.error(f"Error in list_vms: {e}", exc_info=True) logger.error(f"Error in list_vms: {e}", exc_info=True)
error_msg = str(e) error_msg = str(e)
if "VMs are not available" in error_msg: if "VMs are not available" in error_msg:
raise ToolError("VMs are not available on this Unraid server. This could mean: 1) VM support is not enabled, 2) VM service is not running, or 3) no VMs are configured. Check Unraid VM settings.") raise ToolError("VMs are not available on this Unraid server. This could mean: 1) VM support is not enabled, 2) VM service is not running, or 3) no VMs are configured. Check Unraid VM settings.") from e
else: else:
raise ToolError(f"Failed to list virtual machines: {error_msg}") raise ToolError(f"Failed to list virtual machines: {error_msg}") from e
@mcp.tool() @mcp.tool()
async def manage_vm(vm_uuid: str, action: str) -> Dict[str, Any]: async def manage_vm(vm_uuid: str, action: str) -> dict[str, Any]:
"""Manages a VM: start, stop, pause, resume, force_stop, reboot, reset. Uses VM UUID. """Manages a VM: start, stop, pause, resume, force_stop, reboot, reset. Uses VM UUID.
Args: Args:
vm_uuid: UUID of the VM to manage vm_uuid: UUID of the VM to manage
action: Action to perform - one of: start, stop, pause, resume, forceStop, reboot, reset action: Action to perform - one of: start, stop, pause, resume, forceStop, reboot, reset
Returns: Returns:
Dict containing operation success status and details Dict containing operation success status and details
""" """
@@ -95,15 +95,15 @@ def register_vm_tools(mcp: FastMCP):
raise ToolError(f"Failed to {action} VM or unexpected response structure.") raise ToolError(f"Failed to {action} VM or unexpected response structure.")
except Exception as e: except Exception as e:
logger.error(f"Error in manage_vm ({action}): {e}", exc_info=True) logger.error(f"Error in manage_vm ({action}): {e}", exc_info=True)
raise ToolError(f"Failed to {action} virtual machine: {str(e)}") raise ToolError(f"Failed to {action} virtual machine: {str(e)}") from e
@mcp.tool() @mcp.tool()
async def get_vm_details(vm_identifier: str) -> Dict[str, Any]: async def get_vm_details(vm_identifier: str) -> dict[str, Any]:
"""Retrieves detailed information for a specific VM by its UUID or name. """Retrieves detailed information for a specific VM by its UUID or name.
Args: Args:
vm_identifier: VM UUID or name to retrieve details for vm_identifier: VM UUID or name to retrieve details for
Returns: Returns:
Dict containing detailed VM information Dict containing detailed VM information
""" """
@@ -129,20 +129,20 @@ def register_vm_tools(mcp: FastMCP):
try: try:
logger.info(f"Executing get_vm_details for identifier: {vm_identifier}") logger.info(f"Executing get_vm_details for identifier: {vm_identifier}")
response_data = await make_graphql_request(query) response_data = await make_graphql_request(query)
if response_data.get("vms"): if response_data.get("vms"):
vms_data = response_data["vms"] vms_data = response_data["vms"]
# Try to get VMs from either domains or domain field # Try to get VMs from either domains or domain field
vms = vms_data.get("domains") or vms_data.get("domain") or [] vms = vms_data.get("domains") or vms_data.get("domain") or []
if vms: if vms:
for vm_data in vms: for vm_data in vms:
if (vm_data.get("uuid") == vm_identifier or if (vm_data.get("uuid") == vm_identifier or
vm_data.get("id") == vm_identifier or vm_data.get("id") == vm_identifier or
vm_data.get("name") == vm_identifier): vm_data.get("name") == vm_identifier):
logger.info(f"Found VM {vm_identifier}") logger.info(f"Found VM {vm_identifier}")
return vm_data return dict(vm_data) if isinstance(vm_data, dict) else {}
logger.warning(f"VM with identifier '{vm_identifier}' not found.") logger.warning(f"VM with identifier '{vm_identifier}' not found.")
available_vms = [f"{vm.get('name')} (UUID: {vm.get('uuid')}, ID: {vm.get('id')})" for vm in vms] available_vms = [f"{vm.get('name')} (UUID: {vm.get('uuid')}, ID: {vm.get('id')})" for vm in vms]
raise ToolError(f"VM '{vm_identifier}' not found. Available VMs: {', '.join(available_vms)}") raise ToolError(f"VM '{vm_identifier}' not found. Available VMs: {', '.join(available_vms)}")
@@ -155,8 +155,8 @@ def register_vm_tools(mcp: FastMCP):
logger.error(f"Error in get_vm_details: {e}", exc_info=True) logger.error(f"Error in get_vm_details: {e}", exc_info=True)
error_msg = str(e) error_msg = str(e)
if "VMs are not available" in error_msg: if "VMs are not available" in error_msg:
raise ToolError("VMs are not available on this Unraid server. This could mean: 1) VM support is not enabled, 2) VM service is not running, or 3) no VMs are configured. Check Unraid VM settings.") raise ToolError("VMs are not available on this Unraid server. This could mean: 1) VM support is not enabled, 2) VM service is not running, or 3) no VMs are configured. Check Unraid VM settings.") from e
else: else:
raise ToolError(f"Failed to retrieve VM details: {error_msg}") raise ToolError(f"Failed to retrieve VM details: {error_msg}") from e
logger.info("VM tools registered successfully") logger.info("VM tools registered successfully")

20
uv.lock generated
View File

@@ -1389,6 +1389,15 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/72/52/43e70a8e57fefb172c22a21000b03ebcc15e47e97f5cb8495b9c2832efb4/types_python_dateutil-2.9.0.20250708-py3-none-any.whl", hash = "sha256:4d6d0cc1cc4d24a2dc3816024e502564094497b713f7befda4d5bc7a8e3fd21f", size = 17724, upload-time = "2025-07-08T03:14:02.593Z" }, { url = "https://files.pythonhosted.org/packages/72/52/43e70a8e57fefb172c22a21000b03ebcc15e47e97f5cb8495b9c2832efb4/types_python_dateutil-2.9.0.20250708-py3-none-any.whl", hash = "sha256:4d6d0cc1cc4d24a2dc3816024e502564094497b713f7befda4d5bc7a8e3fd21f", size = 17724, upload-time = "2025-07-08T03:14:02.593Z" },
] ]
[[package]]
name = "types-pytz"
version = "2025.2.0.20250809"
source = { registry = "https://pypi.org/simple" }
sdist = { url = "https://files.pythonhosted.org/packages/07/e2/c774f754de26848f53f05defff5bb21dd9375a059d1ba5b5ea943cf8206e/types_pytz-2025.2.0.20250809.tar.gz", hash = "sha256:222e32e6a29bb28871f8834e8785e3801f2dc4441c715cd2082b271eecbe21e5", size = 10876, upload-time = "2025-08-09T03:14:17.453Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/db/d0/91c24fe54e565f2344d7a6821e6c6bb099841ef09007ea6321a0bac0f808/types_pytz-2025.2.0.20250809-py3-none-any.whl", hash = "sha256:4f55ed1b43e925cf851a756fe1707e0f5deeb1976e15bf844bcaa025e8fbd0db", size = 10095, upload-time = "2025-08-09T03:14:16.674Z" },
]
[[package]] [[package]]
name = "typing-extensions" name = "typing-extensions"
version = "4.14.1" version = "4.14.1"
@@ -1418,9 +1427,11 @@ dependencies = [
{ name = "fastapi" }, { name = "fastapi" },
{ name = "fastmcp" }, { name = "fastmcp" },
{ name = "httpx" }, { name = "httpx" },
{ name = "mypy" },
{ name = "python-dotenv" }, { name = "python-dotenv" },
{ name = "pytz" }, { name = "pytz" },
{ name = "rich" }, { name = "rich" },
{ name = "ruff" },
{ name = "uvicorn" }, { name = "uvicorn" },
{ name = "websockets" }, { name = "websockets" },
] ]
@@ -1435,18 +1446,25 @@ dev = [
{ name = "types-python-dateutil" }, { name = "types-python-dateutil" },
] ]
[package.dev-dependencies]
dev = [
{ name = "types-pytz" },
]
[package.metadata] [package.metadata]
requires-dist = [ requires-dist = [
{ name = "black", marker = "extra == 'dev'", specifier = ">=25.1.0" }, { name = "black", marker = "extra == 'dev'", specifier = ">=25.1.0" },
{ name = "fastapi", specifier = ">=0.116.1" }, { name = "fastapi", specifier = ">=0.116.1" },
{ name = "fastmcp", specifier = ">=2.11.2" }, { name = "fastmcp", specifier = ">=2.11.2" },
{ name = "httpx", specifier = ">=0.28.1" }, { name = "httpx", specifier = ">=0.28.1" },
{ name = "mypy", specifier = ">=1.17.1" },
{ name = "mypy", marker = "extra == 'dev'", specifier = ">=1.17.1" }, { name = "mypy", marker = "extra == 'dev'", specifier = ">=1.17.1" },
{ name = "pytest", marker = "extra == 'dev'", specifier = ">=8.4.1" }, { name = "pytest", marker = "extra == 'dev'", specifier = ">=8.4.1" },
{ name = "pytest-asyncio", marker = "extra == 'dev'", specifier = ">=1.1.0" }, { name = "pytest-asyncio", marker = "extra == 'dev'", specifier = ">=1.1.0" },
{ name = "python-dotenv", specifier = ">=1.1.1" }, { name = "python-dotenv", specifier = ">=1.1.1" },
{ name = "pytz", specifier = ">=2025.2" }, { name = "pytz", specifier = ">=2025.2" },
{ name = "rich", specifier = ">=14.1.0" }, { name = "rich", specifier = ">=14.1.0" },
{ name = "ruff", specifier = ">=0.12.8" },
{ name = "ruff", marker = "extra == 'dev'", specifier = ">=0.12.8" }, { name = "ruff", marker = "extra == 'dev'", specifier = ">=0.12.8" },
{ name = "types-python-dateutil", marker = "extra == 'dev'" }, { name = "types-python-dateutil", marker = "extra == 'dev'" },
{ name = "uvicorn", specifier = ">=0.35.0" }, { name = "uvicorn", specifier = ">=0.35.0" },
@@ -1455,7 +1473,7 @@ requires-dist = [
provides-extras = ["dev"] provides-extras = ["dev"]
[package.metadata.requires-dev] [package.metadata.requires-dev]
dev = [] dev = [{ name = "types-pytz", specifier = ">=2025.2.0.20250809" }]
[[package]] [[package]]
name = "urllib3" name = "urllib3"