Migadu MCP Server

Instructions

Implementation Reference

• migadu_mcp/tools/rewrite_tools.py:234-254 (handler)

  The primary handler function for the 'delete_rewrite' MCP tool. It handles bulk deletion requests by logging the operation, issuing warnings, and delegating to the process_delete_rewrite helper.

  @mcp.tool(
      annotations={
          "readOnlyHint": False,
          "destructiveHint": True,
          "idempotentHint": True,
          "openWorldHint": True,
      },
  )
  async def delete_rewrite(
      targets: List[Dict[str, Any]], ctx: Context
  ) -> Dict[str, Any]:
      """Delete rewrite rules. DESTRUCTIVE: Cannot be undone. List of dicts with: name (required), domain (optional)."""
      count = len(list(ensure_iterable(targets)))
      await log_bulk_operation_start(ctx, "Deleting", count, "rewrite rule")
      await ctx.warning("🗑️ DESTRUCTIVE: This operation cannot be undone!")
  
      result = await process_delete_rewrite(targets, ctx)
      await log_bulk_operation_result(
          ctx, "Rewrite rule deletion", result, "rewrite rule"
      )
      return result

• migadu_mcp/tools/rewrite_tools.py:208-233 (helper)

  Helper function for processing individual delete operations, including validation via RewriteDeleteRequest schema and calling the service layer.

  @bulk_processor_with_schema(RewriteDeleteRequest)
  async def process_delete_rewrite(
      validated_item: RewriteDeleteRequest, ctx: Context
  ) -> Dict[str, Any]:
      """Process a single rewrite rule deletion with Pydantic validation"""
      # Use validated Pydantic model directly - all validation already done
      name = validated_item.name
      domain = validated_item.domain
  
      # Get domain if not provided
      if domain is None:
          from migadu_mcp.config import get_config
  
          config = get_config()
          domain = config.get_default_domain()
          if not domain:
              raise ValueError("No domain provided and MIGADU_DOMAIN not configured")
  
      await ctx.warning(f"🗑️ DESTRUCTIVE: Deleting rewrite rule {name}@{domain}")
  
      service = get_service_factory().rewrite_service()
      await service.delete_rewrite(domain, name)
  
      await log_operation_success(ctx, "Deleted rewrite rule", f"{name}@{domain}")
      return {"deleted": f"{name}@{domain}", "success": True}

• migadu_mcp/utils/schemas.py:276-281 (schema)

  Pydantic model defining the input schema for delete_rewrite requests, with required 'name' and optional 'domain' fields.

  class RewriteDeleteRequest(BaseModel):
      """Request schema for deleting a rewrite rule"""
  
      name: str = Field(..., description="Identifier/slug of the rule to delete")
      domain: Optional[str] = Field(None, description="Domain name")

• migadu_mcp/main.py:24-24 (registration)

  The registration call in the main MCP server initialization that includes the delete_rewrite tool via register_rewrite_tools.

  register_rewrite_tools(mcp)

• migadu_mcp/services/rewrite_service.py:58-61 (helper)

  Service layer implementation that performs the actual HTTP DELETE request to the Migadu API to remove the rewrite rule.

  async def delete_rewrite(self, domain: str, name: str) -> Dict[str, Any]:
      """Delete a rewrite rule"""
      return await self.client.request("DELETE", f"/domains/{domain}/rewrites/{name}")