lightpdf-aipdf-mcp 0.1.42__py3-none-any.whl → 0.1.44__py3-none-any.whl

lightpdf_aipdf_mcp/common.py

@@ -5,7 +5,7 @@ import os
 import time
 from dataclasses import dataclass
 from typing import List, Optional, Dict, Any, Tuple
-
+import urllib.parse
 import httpx
 
 @dataclass
@@ -15,6 +15,7 @@ class BaseResult:
     file_path: str
     error_message: Optional[str] = None
     download_url: Optional[str] = None
+    original_name: Optional[str] = None
 
 class Logger:
     """日志记录器类"""
@@ -57,7 +58,7 @@ class FileHandler:
     @staticmethod
     def is_url(path: str) -> bool:
         """检查路径是否为URL"""
-        return path.startswith(("http://", "https://"))
+        return path.startswith(("http://", "https://", "oss://"))
         
     @staticmethod
     def is_oss_id(path: str) -> bool:

lightpdf_aipdf_mcp/converter.py

@@ -103,9 +103,10 @@ class Converter(BaseApiClient):
     """PDF文档转换器"""
     def __init__(self, logger: Logger, file_handler: FileHandler):
         super().__init__(logger, file_handler)
-        self.api_base_url = "https://techsz.aoscdn.com/api/tasks/document/conversion"
+        api_endpoint = os.environ.get("API_ENDPOINT", "devaw.aoscdn.com/tech")
+        self.api_base_url = f"https://{api_endpoint}/tasks/document/conversion"
 
-    async def add_page_numbers(self, file_path: str, start_num: int = 1, position: str = "5", margin: int = 30, password: str = None) -> ConversionResult:
+    async def add_page_numbers(self, file_path: str, start_num: int = 1, position: str = "5", margin: int = 30, password: str = None, original_name: Optional[str] = None) -> ConversionResult:
         """为PDF文档添加页码
         
         Args:
@@ -114,6 +115,7 @@ class Converter(BaseApiClient):
             position: 页码显示位置，字符串类型，可选值1-6（左上/上中/右上/左下/下中/右下），默认为5（下中）
             margin: 页码显示的边距，整数类型，可选值10/30/60，默认为30
             password: 文档密码，如果文档受密码保护，则需要提供（可选）
+            original_name: 原始文件名（可选）
             
         Returns:
             ConversionResult: 转换结果
@@ -122,6 +124,7 @@ class Converter(BaseApiClient):
         input_format = self.file_handler.get_input_format(file_path)
         if input_format != InputFormat.PDF:
             await self.logger.error(f"添加页码功能仅支持PDF文件，当前文件格式为: {self.file_handler.get_file_extension(file_path)}")
+            return ConversionResult(success=False, file_path=file_path, error_message="添加页码功能仅支持PDF文件", original_name=original_name)
         
         # 验证参数
         valid_positions = {"1", "2", "3", "4", "5", "6"}
@@ -129,15 +132,21 @@ class Converter(BaseApiClient):
         
         # 验证position参数
         if position not in valid_positions:
-            await self.logger.error(f"无效的页码位置值: {position}。有效值为: 1(左上), 2(上中), 3(右上), 4(左下), 5(下中), 6(右下)")
+            error_msg = f"无效的页码位置值: {position}。有效值为: 1(左上), 2(上中), 3(右上), 4(左下), 5(下中), 6(右下)"
+            await self.logger.error(error_msg)
+            return ConversionResult(success=False, file_path=file_path, error_message=error_msg, original_name=original_name)
         
         # 验证margin参数
         if margin not in valid_margins:
-            await self.logger.error(f"无效的页码边距值: {margin}。有效值为: 10, 30, 60")
+            error_msg = f"无效的页码边距值: {margin}。有效值为: 10, 30, 60"
+            await self.logger.error(error_msg)
+            return ConversionResult(success=False, file_path=file_path, error_message=error_msg, original_name=original_name)
         
         # 验证start_num是否为正整数
         if not isinstance(start_num, int) or start_num < 1:
-            await self.logger.error(f"起始页码必须是正整数，当前值为: {start_num}")
+            error_msg = f"起始页码必须是正整数，当前值为: {start_num}"
+            await self.logger.error(error_msg)
+            return ConversionResult(success=False, file_path=file_path, error_message=error_msg, original_name=original_name)
         
         # 构建API参数
         extra_params = {
@@ -150,9 +159,9 @@ class Converter(BaseApiClient):
         await self.logger.log("info", f"正在为PDF添加页码（起始页码: {start_num}, 位置: {position}, 边距: {margin}）...")
         
         # 调用convert_file方法处理API请求
-        return await self.convert_file(file_path, "number-pdf", extra_params, password)
+        return await self.convert_file(file_path, "number-pdf", extra_params, password, original_name)
         
-    async def convert_file(self, file_path: str, format: str, extra_params: dict = None, password: str = None) -> ConversionResult:
+    async def convert_file(self, file_path: str, format: str, extra_params: dict = None, password: str = None, original_name: Optional[str] = None) -> ConversionResult:
         """转换单个文件
         
         Args:
@@ -160,12 +169,14 @@ class Converter(BaseApiClient):
             format: 目标格式
             extra_params: 额外的API参数，例如去除水印
             password: 文档密码，如果文档受密码保护，则需要提供（可选）
+            original_name: 原始文件名（可选）
             
         Returns:
             ConversionResult: 转换结果
         """
         if not self.api_key:
             await self.logger.error("未找到API_KEY。请在客户端配置API_KEY环境变量。")
+            return ConversionResult(success=False, file_path=file_path, error_message="未找到API_KEY", original_name=original_name)
 
         # 特殊格式：doc-repair用于去除水印，number-pdf用于添加页码，输出均为PDF
         is_special_operation = format in ["doc-repair", "number-pdf"]
@@ -180,38 +191,40 @@ class Converter(BaseApiClient):
             # 验证输入文件格式
             input_format = self.file_handler.get_input_format(file_path)
             if not input_format and not is_special_operation:
-                await self.logger.error(f"不支持的输入文件格式: {self.file_handler.get_file_extension(file_path)}")
+                error_msg = f"不支持的输入文件格式: {self.file_handler.get_file_extension(file_path)}"
+                await self.logger.error(error_msg)
+                return ConversionResult(success=False, file_path=file_path, error_message=error_msg, original_name=original_name)
 
             # 如果是去除水印操作，检查是否PDF文件
             if format == "doc-repair" and input_format != InputFormat.PDF:
-                await self.logger.error("去除水印功能仅支持PDF文件")
+                error_msg = "去除水印功能仅支持PDF文件"
+                await self.logger.error(error_msg)
+                return ConversionResult(success=False, file_path=file_path, error_message=error_msg, original_name=original_name)
                 
             # 如果是添加页码操作，检查是否PDF文件
             if format == "number-pdf" and input_format != InputFormat.PDF:
-                await self.logger.error("添加页码功能仅支持PDF文件")
+                error_msg = "添加页码功能仅支持PDF文件"
+                await self.logger.error(error_msg)
+                return ConversionResult(success=False, file_path=file_path, error_message=error_msg, original_name=original_name)
 
             # 验证输出格式（除去特殊操作外）
             if not is_special_operation:
                 try:
                     output_format = OutputFormat(format)
                 except ValueError:
-                    await self.logger.error(f"不支持的输出格式: {format}")
+                    error_msg = f"不支持的输出格式: {format}"
+                    await self.logger.error(error_msg)
+                    return ConversionResult(success=False, file_path=file_path, error_message=error_msg, original_name=original_name)
 
-                # 验证格式转换是否支持
-                if input_format:  # 确保input_format有效
-                    available_formats = self.file_handler.get_available_output_formats(input_format)
-                    if output_format not in available_formats:
-                        await self.logger.error(
-                            f"不支持从 {input_format.value} 格式转换为 {output_format.value} 格式。"
-                            f"支持的输出格式: {', '.join(f.value for f in available_formats)}"
-                        )
         else:
             # 远程路径的情况，设置必要的变量以便后续使用
             if not is_special_operation:
                 try:
                     output_format = OutputFormat(format)
                 except ValueError:
-                    await self.logger.error(f"不支持的输出格式: {format}")
+                    error_msg = f"不支持的输出格式: {format}"
+                    await self.logger.error(error_msg)
+                    return ConversionResult(success=False, file_path=file_path, error_message=error_msg, original_name=original_name)
             else:
                 output_format = OutputFormat.PDF
             
@@ -221,7 +234,7 @@ class Converter(BaseApiClient):
         # 验证文件
         exists = await self.file_handler.validate_file_exists(file_path)
         if not exists:
-            return ConversionResult(success=False, file_path=file_path, error_message="文件不存在")
+            return ConversionResult(success=False, file_path=file_path, error_message="文件不存在", original_name=original_name)
 
         # 操作描述
         if format == "doc-repair":
@@ -239,7 +252,7 @@ class Converter(BaseApiClient):
         await self.logger.log("info", f"正在{operation_desc}...")
 
         import httpx
-        async with httpx.AsyncClient(timeout=120.0) as client:
+        async with httpx.AsyncClient(timeout=600.0) as client:
             try:
                 # 初始化extra_params（如果为None）
                 if extra_params is None:
@@ -262,7 +275,8 @@ class Converter(BaseApiClient):
                     success=True,
                     file_path=file_path,
                     error_message=None,
-                    download_url=download_url
+                    download_url=download_url,
+                    original_name=original_name
                 )
 
             except Exception as e:
@@ -270,7 +284,8 @@ class Converter(BaseApiClient):
                     success=False,
                     file_path=file_path,
                     error_message=str(e),
-                    download_url=None
+                    download_url=None,
+                    original_name=original_name
                 )
 
     async def _create_task(self, client: httpx.AsyncClient, file_path: str, format: str, extra_params: dict = None) -> str:

lightpdf_aipdf_mcp/editor.py

@@ -29,7 +29,8 @@ class Editor(BaseApiClient):
     """PDF文档编辑器"""
     def __init__(self, logger: Logger, file_handler: FileHandler):
         super().__init__(logger, file_handler)
-        self.api_base_url = "https://techsz.aoscdn.com/api/tasks/document/pdfedit"
+        api_endpoint = os.environ.get("API_ENDPOINT", "devaw.aoscdn.com/tech")
+        self.api_base_url = f"https://{api_endpoint}/tasks/document/pdfedit"
 
     async def _validate_pdf_file(self, file_path: str) -> bool:
         """验证文件是否为PDF格式
@@ -63,7 +64,7 @@ class Editor(BaseApiClient):
         log_msg += "..."
         await self.logger.log("info", log_msg)
     
-    async def split_pdf(self, file_path: str, pages: str = "", password: Optional[str] = None, split_type: str = "page", merge_all: int = 1) -> EditResult:
+    async def split_pdf(self, file_path: str, pages: str = "", password: Optional[str] = None, split_type: str = "page", merge_all: int = 1, original_name: Optional[str] = None) -> EditResult:
         """拆分PDF文件
         
         Args:
@@ -72,19 +73,20 @@ class Editor(BaseApiClient):
             password: 文档密码，如果文档受密码保护，则需要提供（可选）
             split_type: 拆分类型，可选值: "every"=每页拆分为一个文件, "page"=指定页面规则拆分，默认为"page"
             merge_all: 是否合并拆分后的文件，仅在split_type="page"时有效，0=不合并，1=合并，默认为1
+            original_name: 原始文件名（可选）
             
         Returns:
             EditResult: 拆分结果
         """
         # 验证输入文件是否为PDF
         if not await self._validate_pdf_file(file_path):
-            return EditResult(success=False, file_path=file_path, error_message="非PDF文件")
+            return EditResult(success=False, file_path=file_path, error_message="非PDF文件", original_name=original_name)
         
         # 验证拆分类型
         valid_split_types = {"every", "page"}
         if split_type not in valid_split_types:
             await self.logger.error(f"无效的拆分类型: {split_type}。有效值为: every, page")
-            return EditResult(success=False, file_path=file_path, error_message=f"无效的拆分类型: {split_type}。有效值为: every, page")
+            return EditResult(success=False, file_path=file_path, error_message=f"无效的拆分类型: {split_type}。有效值为: every, page", original_name=original_name)
         
         # 构建API参数
         extra_params = {
@@ -103,30 +105,31 @@ class Editor(BaseApiClient):
         await self._log_operation("拆分PDF文件", operation_details)
         
         # 调用edit_pdf方法处理API请求
-        return await self.edit_pdf(file_path, EditType.SPLIT, extra_params, password)
+        return await self.edit_pdf(file_path, EditType.SPLIT, extra_params, password, original_name)
 
-    async def merge_pdfs(self, file_paths: List[str], password: Optional[str] = None) -> EditResult:
+    async def merge_pdfs(self, file_paths: List[str], password: Optional[str] = None, original_name: Optional[str] = None) -> EditResult:
         """合并多个PDF文件
         
         Args:
             file_paths: 要合并的PDF文件路径列表
             password: 文档密码，如果文档受密码保护，则需要提供（可选）
+            original_name: 原始文件名（可选）
             
         Returns:
             EditResult: 合并结果
         """
         if len(file_paths) < 2:
             await self.logger.error("合并PDF至少需要两个文件")
-            return EditResult(success=False, file_path=','.join(file_paths), error_message="合并PDF至少需要两个文件")
+            return EditResult(success=False, file_path=','.join(file_paths), error_message="合并PDF至少需要两个文件", original_name=original_name)
         
         # 验证所有文件是否都是PDF并且存在
         for pdf_file in file_paths:
             if not await self._validate_pdf_file(pdf_file):
-                return EditResult(success=False, file_path=pdf_file, error_message="非PDF文件")
+                return EditResult(success=False, file_path=pdf_file, error_message="非PDF文件", original_name=original_name)
             
             exists = await self.file_handler.validate_file_exists(pdf_file)
             if not exists:
-                return EditResult(success=False, file_path=pdf_file, error_message="文件不存在")
+                return EditResult(success=False, file_path=pdf_file, error_message="文件不存在", original_name=original_name)
         
         # 记录操作描述
         await self._log_operation("合并PDF文件", f"{len(file_paths)} 个文件")
@@ -147,7 +150,8 @@ class Editor(BaseApiClient):
                     success=True,
                     file_path=file_paths[0],  # 使用第一个文件路径作为参考
                     error_message=None,
-                    download_url=download_url
+                    download_url=download_url,
+                    original_name=original_name
                 )
 
             except Exception as e:
@@ -155,10 +159,11 @@ class Editor(BaseApiClient):
                     success=False,
                     file_path=file_paths[0],
                     error_message=str(e),
-                    download_url=None
+                    download_url=None,
+                    original_name=original_name
                 )
 
-    async def rotate_pdf(self, file_path: str, angle: int, pages: str = "", password: Optional[str] = None) -> EditResult:
+    async def rotate_pdf(self, file_path: str, angle: int, pages: str = "", password: Optional[str] = None, original_name: Optional[str] = None) -> EditResult:
         """旋转PDF文件的页面
         
         Args:
@@ -166,19 +171,20 @@ class Editor(BaseApiClient):
             angle: 旋转角度，可选值为90、180、270
             pages: 指定要旋转的页面范围，例如 "1,3,5-7" 或 "" 表示所有页面
             password: 文档密码，如果文档受密码保护，则需要提供（可选）
+            original_name: 原始文件名（可选）
             
         Returns:
             EditResult: 旋转结果
         """
         # 验证输入文件是否为PDF
         if not await self._validate_pdf_file(file_path):
-            return EditResult(success=False, file_path=file_path, error_message="非PDF文件")
+            return EditResult(success=False, file_path=file_path, error_message="非PDF文件", original_name=original_name)
         
         # 验证旋转角度
         valid_angles = {90, 180, 270}
         if angle not in valid_angles:
             await self.logger.error("无效的旋转角度。角度必须是: 90, 180, 270")
-            return EditResult(success=False, file_path=file_path, error_message="无效的旋转角度。角度必须是: 90, 180, 270")
+            return EditResult(success=False, file_path=file_path, error_message="无效的旋转角度。角度必须是: 90, 180, 270", original_name=original_name)
         
         # 构建API参数
         extra_params = {
@@ -190,27 +196,28 @@ class Editor(BaseApiClient):
         await self._log_operation("旋转PDF文件", f"参数: {angle_desc}")
         
         # 调用edit_pdf方法处理API请求
-        return await self.edit_pdf(file_path, EditType.ROTATE, extra_params, password)
+        return await self.edit_pdf(file_path, EditType.ROTATE, extra_params, password, original_name)
 
-    async def compress_pdf(self, file_path: str, image_quantity: int = 60, password: Optional[str] = None) -> EditResult:
+    async def compress_pdf(self, file_path: str, image_quantity: int = 60, password: Optional[str] = None, original_name: Optional[str] = None) -> EditResult:
         """压缩PDF文件
         
         Args:
             file_path: 要压缩的PDF文件路径
             image_quantity: 图片质量，范围1-100，默认为60
             password: 文档密码，如果文档受密码保护，则需要提供（可选）
+            original_name: 原始文件名（可选）
             
         Returns:
             EditResult: 压缩结果
         """
         # 验证输入文件是否为PDF
         if not await self._validate_pdf_file(file_path):
-            return EditResult(success=False, file_path=file_path, error_message="非PDF文件")
+            return EditResult(success=False, file_path=file_path, error_message="非PDF文件", original_name=original_name)
         
-        # 验证图片质量
-        if not 1 <= image_quantity <= 100:
-            await self.logger.error(f"无效的图片质量: {image_quantity}。有效值范围为: 1-100")
-            return EditResult(success=False, file_path=file_path, error_message=f"无效的图片质量: {image_quantity}。有效值范围为: 1-100")
+        # 验证图片质量范围
+        if not (1 <= image_quantity <= 100):
+            await self.logger.error("图片质量必须在1到100之间")
+            return EditResult(success=False, file_path=file_path, error_message="图片质量必须在1到100之间", original_name=original_name)
         
         # 构建API参数
         extra_params = {
@@ -221,60 +228,65 @@ class Editor(BaseApiClient):
         await self._log_operation("压缩PDF文件", f"图片质量: {image_quantity}")
         
         # 调用edit_pdf方法处理API请求
-        return await self.edit_pdf(file_path, EditType.COMPRESS, extra_params, password)
+        return await self.edit_pdf(file_path, EditType.COMPRESS, extra_params, password, original_name)
 
-    async def encrypt_pdf(self, file_path: str, password: str, original_password: Optional[str] = None) -> EditResult:
+    async def encrypt_pdf(self, file_path: str, password: str, original_password: Optional[str] = None, original_name: Optional[str] = None) -> EditResult:
         """加密PDF文件
         
         Args:
             file_path: 要加密的PDF文件路径
-            password: 设置的新密码（用于加密PDF）
-            original_password: 文档原密码，如果文档已受密码保护，则需要提供（可选）
-            
-        注意:
-            根据API文档，加密操作需要通过password参数指定要设置的新密码。
-            如果文档已经受密码保护，则使用original_password参数提供原密码进行解锁。
+            password: 要设置的新密码
+            original_password: 原始密码，如果文件已经加密，则需要提供（可选）
+            original_name: 原始文件名（可选）
             
         Returns:
             EditResult: 加密结果
         """
         # 验证输入文件是否为PDF
         if not await self._validate_pdf_file(file_path):
-            return EditResult(success=False, file_path=file_path, error_message="非PDF文件")
+            return EditResult(success=False, file_path=file_path, error_message="非PDF文件", original_name=original_name)
+        
+        # 验证新密码
+        if not password:
+            await self.logger.error("加密PDF文件需要提供新密码")
+            return EditResult(success=False, file_path=file_path, error_message="加密PDF文件需要提供新密码", original_name=original_name)
         
         # 构建API参数
         extra_params = {
-            "password": password  # 设置的新密码
+            "password": password  # 新密码
         }
         
         # 记录操作描述
         await self._log_operation("加密PDF文件")
         
         # 调用edit_pdf方法处理API请求
-        return await self.edit_pdf(file_path, EditType.ENCRYPT, extra_params, original_password)
+        return await self.edit_pdf(file_path, EditType.ENCRYPT, extra_params, original_password, original_name)
 
-    async def decrypt_pdf(self, file_path: str, password: Optional[str] = None) -> EditResult:
+    async def decrypt_pdf(self, file_path: str, password: Optional[str] = None, original_name: Optional[str] = None) -> EditResult:
         """解密PDF文件
         
         Args:
             file_path: 要解密的PDF文件路径
-            password: 文档密码，如果文档受密码保护，则需要提供（必须提供正确的密码才能解密）
-            
-        注意:
-            该方法调用API的unlock功能，需要提供正确的PDF密码才能成功解密。
+            password: 文档密码，用于解锁已加密的文档
+            original_name: 原始文件名（可选）
             
         Returns:
             EditResult: 解密结果
         """
         # 验证输入文件是否为PDF
         if not await self._validate_pdf_file(file_path):
-            return EditResult(success=False, file_path=file_path, error_message="非PDF文件")
+            return EditResult(success=False, file_path=file_path, error_message="非PDF文件", original_name=original_name)
+        
+        # 验证密码
+        if not password:
+            await self.logger.error("解密PDF文件需要提供密码")
+            return EditResult(success=False, file_path=file_path, error_message="解密PDF文件需要提供密码", original_name=original_name)
         
         # 记录操作描述
         await self._log_operation("解密PDF文件")
         
         # 调用edit_pdf方法处理API请求
-        return await self.edit_pdf(file_path, EditType.DECRYPT, {}, password)
+        return await self.edit_pdf(file_path, EditType.DECRYPT, {}, password, original_name)
 
     async def add_watermark(
         self, 
@@ -282,56 +294,47 @@ class Editor(BaseApiClient):
         text: str, 
         position: str,  # 必需参数：位置，如"top", "center", "diagonal"等
         opacity: float = 0.5, 
-        deg: str = "-45",  # 直接使用字符串格式的角度
         range: str = "",  # 与API保持一致，使用range而非pages
         layout: Optional[str] = None,  # 可选参数: "on"/"under"
         font_family: Optional[str] = None,
         font_size: Optional[int] = None,
         font_color: Optional[str] = None,
-        password: Optional[str] = None
+        password: Optional[str] = None,
+        original_name: Optional[str] = None
     ) -> EditResult:
-        """为PDF文件添加水印
+        """为PDF文件添加文本水印
         
         Args:
             file_path: 要添加水印的PDF文件路径
             text: 水印文本内容
-            position: 水印位置，可选值:"topleft","top","topright","left","center",
-                    "right","bottomleft","bottom","bottomright","diagonal","reverse-diagonal"
-            opacity: 透明度，0.0-1.0，默认为0.5
-            deg: 倾斜角度，字符串格式，如"-45"，默认为"-45"
-            range: 指定页面范围，例如 "1,3,5-7" 或 "" 表示所有页面
-            layout: 布局位置，可选值:"on"(在内容上)/"under"(在内容下)
+            position: 水印位置，如"top", "center", "diagonal"等
+            opacity: 透明度，0.0-1.0，默认0.5
+            range: 页面范围，例如 "1,3,5-7" 或空字符串表示所有页面
+            layout: 布局方式："on"=在内容上，"under"=在内容下，默认"on"
             font_family: 字体
             font_size: 字体大小
-            font_color: 字体颜色，如"#ff0000"表示红色
+            font_color: 字体颜色，如 "#ff0000"
             password: 文档密码，如果文档受密码保护，则需要提供（可选）
+            original_name: 原始文件名（可选）
             
         Returns:
             EditResult: 添加水印结果
         """
         # 验证输入文件是否为PDF
         if not await self._validate_pdf_file(file_path):
-            return EditResult(success=False, file_path=file_path, error_message="非PDF文件")
+            return EditResult(success=False, file_path=file_path, error_message="非PDF文件", original_name=original_name)
         
-        # 验证透明度
-        if not 0.0 <= opacity <= 1.0:
-            await self.logger.error(f"无效的透明度: {opacity}。有效值范围为: 0.0-1.0")
-            return EditResult(success=False, file_path=file_path, error_message=f"无效的透明度: {opacity}。有效值范围为: 0.0-1.0")
-        
-        # 验证position参数
-        valid_positions = {"topleft", "top", "topright", "left", "center", "right", 
-                        "bottomleft", "bottom", "bottomright", "diagonal", "reverse-diagonal"}
-        if position not in valid_positions:
-            await self.logger.error(f"无效的位置: {position}")
-            return EditResult(success=False, file_path=file_path, error_message=f"无效的位置: {position}")
+        # 验证必需参数
+        if not text:
+            await self.logger.error("水印文本不能为空")
+            return EditResult(success=False, file_path=file_path, error_message="水印文本不能为空", original_name=original_name)
         
         # 构建API参数
         extra_params = {
-            "edit_type": "text",  # 固定为文本水印
+            "edit_type": "text",
             "text": text,
             "position": position,
             "opacity": opacity,
-            "deg": deg,
             "range": range
         }
         
@@ -349,9 +352,9 @@ class Editor(BaseApiClient):
         await self._log_operation("为PDF添加水印", f"文本: {text}, 位置: {position}, 透明度: {opacity}")
         
         # 调用edit_pdf方法处理API请求
-        return await self.edit_pdf(file_path, EditType.ADD_WATERMARK, extra_params, password)
+        return await self.edit_pdf(file_path, EditType.ADD_WATERMARK, extra_params, password, original_name)
 
-    async def edit_pdf(self, file_path: str, edit_type: EditType, extra_params: Dict[str, Any] = None, password: Optional[str] = None) -> EditResult:
+    async def edit_pdf(self, file_path: str, edit_type: EditType, extra_params: Dict[str, Any] = None, password: Optional[str] = None, original_name: Optional[str] = None) -> EditResult:
         """编辑PDF文件
         
         Args:
@@ -359,6 +362,7 @@ class Editor(BaseApiClient):
             edit_type: 编辑操作类型
             extra_params: 额外的API参数
             password: 文档密码，如果文档受密码保护，则需要提供（可选）
+            original_name: 原始文件名（可选）
             
         注意:
             1. 对于加密操作(protect)，需要在extra_params中提供新密码
@@ -370,14 +374,14 @@ class Editor(BaseApiClient):
         """
         if not self.api_key:
             await self.logger.error("未找到API_KEY。请在客户端配置API_KEY环境变量。")
-            return EditResult(success=False, file_path=file_path, error_message="未找到API_KEY。请在客户端配置API_KEY环境变量。")
+            return EditResult(success=False, file_path=file_path, error_message="未找到API_KEY。请在客户端配置API_KEY环境变量。", original_name=original_name)
 
         # 验证文件
         exists = await self.file_handler.validate_file_exists(file_path)
         if not exists:
-            return EditResult(success=False, file_path=file_path, error_message="文件不存在")
+            return EditResult(success=False, file_path=file_path, error_message="文件不存在", original_name=original_name)
 
-        async with httpx.AsyncClient(timeout=120.0) as client:
+        async with httpx.AsyncClient(timeout=600.0) as client:
             try:
                 # 初始化extra_params（如果为None）
                 if extra_params is None:
@@ -400,7 +404,8 @@ class Editor(BaseApiClient):
                     success=True,
                     file_path=file_path,
                     error_message=None,
-                    download_url=download_url
+                    download_url=download_url,
+                    original_name=original_name
                 )
 
             except Exception as e:
@@ -408,7 +413,8 @@ class Editor(BaseApiClient):
                     success=False,
                     file_path=file_path,
                     error_message=str(e),
-                    download_url=None
+                    download_url=None,
+                    original_name=original_name
                 )
 
     async def _create_task(self, client: httpx.AsyncClient, file_path: str, edit_type: EditType, extra_params: Dict[str, Any] = None) -> str:
@@ -434,10 +440,10 @@ class Editor(BaseApiClient):
         
         # 检查是否为OSS路径
         if self.file_handler.is_oss_id(file_path):
-            # OSS路径处理方式，与URL类似，但提取resource_id
-            data["resource_id"] = file_path.split("oss_id://")[1]
             # 使用JSON方式时添加Content-Type
             headers["Content-Type"] = "application/json"
+            # OSS路径处理方式，与URL类似，但提取resource_id
+            data["resource_id"] = file_path.split("oss_id://")[1]
             response = await client.post(
                 self.api_base_url,
                 json=data,
@@ -445,9 +451,9 @@ class Editor(BaseApiClient):
             )
         # 检查是否为URL路径
         elif self.file_handler.is_url(file_path):
-            data["url"] = file_path
             # 使用JSON方式时添加Content-Type
             headers["Content-Type"] = "application/json"
+            data["url"] = file_path
             response = await client.post(
                 self.api_base_url,
                 json=data,
@@ -492,15 +498,15 @@ class Editor(BaseApiClient):
         
         for i, file_path in enumerate(file_paths):
             # 检查是否为URL或OSS路径
-            if self.file_handler.is_url(file_path):
-                # 对于URL或OSS路径，添加到inputs数组
-                input_item = {"url": file_path}
+            if self.file_handler.is_oss_id(file_path):
+                # 对于OSS路径，添加到inputs数组
+                input_item = {"resource_id": file_path.split("oss_id://")[1]}
                 if password:
                     input_item["password"] = password
                 url_inputs.append(input_item)
-            elif self.file_handler.is_oss_id(file_path):
-                # 对于OSS路径，添加到inputs数组
-                input_item = {"resource_id": file_path.split("oss_id://")[1]}
+            elif self.file_handler.is_url(file_path):
+                # 对于URL或OSS路径，添加到inputs数组
+                input_item = {"url": file_path}
                 if password:
                     input_item["password"] = password
                 url_inputs.append(input_item)

lightpdf_aipdf_mcp/server.py

@@ -3,6 +3,8 @@
 import asyncio
 import os
 import sys
+import argparse
+import json
 from typing import List, Dict, Any, Callable, TypeVar, Optional, Union
 
 # 第三方库导入
@@ -18,80 +20,68 @@ from .common import BaseResult, Logger, FileHandler
 from .converter import Converter, ConversionResult
 from .editor import Editor, EditResult
 
-# 加载环境变量
-load_dotenv()
-
 # 类型定义
 T = TypeVar('T', bound=BaseResult)
 ProcessFunc = Callable[[str], Any]
 
 def generate_result_report(
     results: List[BaseResult], 
-    operation_name: str, 
-    success_action: Optional[str] = None, 
-    failed_action: Optional[str] = None
+    operation_name: str
 ) -> str:
     """生成通用结果报告
     
     Args:
         results: 结果列表
         operation_name: 操作名称
-        success_action: 成功动作描述
-        failed_action: 失败动作描述
         
     Returns:
-        str: 格式化的报告文本
+        str: JSON格式的报告文本
     """
     # 统计结果
     success_count = sum(1 for r in results if r.success)
     failed_count = len(results) - success_count
     
-    # 生成报告头部
-    report_lines = [
-        f"{operation_name}结果：共 {len(results)} 个文件" + (
-            f"，成功 {success_count} 个" if success_count > 0 else ""
-        ) + (
-            f"，失败 {failed_count} 个" if failed_count > 0 else ""
-        ),
-        ""
-    ]
-    
-    # 添加成功的文件信息
-    if success_count > 0 and success_action:
-        report_lines.extend([f"[成功] {success_action}的文件：", ""])
-        for i, result in enumerate(results):
-            if result.success:
-                report_lines.extend([
-                    f"[{i+1}] {result.file_path}",
-                    f"- 在线下载地址: {result.download_url}",
-                    ""
-                ])
+    # 构建结果JSON对象
+    report_obj = {
+        "operation": operation_name,
+        "total": len(results),
+        "success_count": success_count,
+        "failed_count": failed_count,
+        "success_files": [],
+        "failed_files": []
+    }
     
-    # 添加失败的文件信息
-    if failed_count > 0 and failed_action:
-        report_lines.extend([f"[失败] {failed_action}的文件：", ""])
-        for i, result in enumerate(results):
-            if not result.success:
-                report_lines.extend([
-                    f"[{i+1}] {result.file_path}",
-                    f"- 错误: {result.error_message}",
-                    ""
-                ])
+    for result in results:
+        if result.success:
+            # 添加成功的文件信息
+            report_obj["success_files"].append({
+                "file_path": result.file_path,
+                "original_name": result.original_name,
+                "download_url": result.download_url
+            })
+        else:
+            # 添加失败的文件信息
+            report_obj["failed_files"].append({
+                "file_path": result.file_path,
+                "original_name": result.original_name,
+                "error_message": result.error_message
+            })
     
-    return "\n".join(report_lines)
+    # 返回JSON字符串
+    return json.dumps(report_obj, ensure_ascii=False)
 
 async def process_batch_files(
     file_objects: List[Dict[str, str]], 
     logger: Logger, 
-    process_func: Callable[[str, Optional[str]], T],
+    process_func: Callable[[str, Optional[str], Optional[str]], T],
     operation_desc: Optional[str] = None
 ) -> List[T]:
     """通用批处理文件函数
     
     Args:
-        file_objects: 文件对象列表，每个对象包含path和可选的password
+        file_objects: 文件对象列表，每个对象包含path和可选的password及name
         logger: 日志记录器
-        process_func: 处理单个文件的异步函数，接收file_path和password参数
+        process_func: 处理单个文件的异步函数，接收file_path、password和original_name参数
         operation_desc: 操作描述，用于日志记录
     
     Returns:
@@ -107,7 +97,8 @@ async def process_batch_files(
             async with semaphore:
                 file_path = file_obj["path"]
                 password = file_obj.get("password")
-                return await process_func(file_path, password)
+                original_name = file_obj.get("name")
+                return await process_func(file_path, password, original_name)
         
         # 创建任务列表
         tasks = [process_with_semaphore(file_obj) for file_obj in file_objects]
@@ -116,14 +107,16 @@ async def process_batch_files(
         # 单文件处理
         file_path = file_objects[0]["path"]
         password = file_objects[0].get("password")
-        return [await process_func(file_path, password)]
+        original_name = file_objects[0].get("name")
+        return [await process_func(file_path, password, original_name)]
 
 async def process_conversion_file(
     file_path: str, 
     format: str, 
     converter: Converter, 
     extra_params: Optional[Dict[str, Any]] = None, 
-    password: Optional[str] = None
+    password: Optional[str] = None,
+    original_name: Optional[str] = None
 ) -> ConversionResult:
     """处理单个文件转换"""
     is_page_numbering = format == "number-pdf"
@@ -135,47 +128,51 @@ async def process_conversion_file(
             extra_params.get("start_num", 1),
             extra_params.get("position", "5"),
             extra_params.get("margin", 30),
-            password
+            password,
+            original_name
         )
     else:
         # 对于其他操作，使用convert_file方法
-        return await converter.convert_file(file_path, format, extra_params, password)
+        return await converter.convert_file(file_path, format, extra_params, password, original_name)
 
 async def process_edit_file(
     file_path: str, 
     edit_type: str, 
     editor: Editor, 
     extra_params: Dict[str, Any] = None,
-    password: Optional[str] = None
+    password: Optional[str] = None,
+    original_name: Optional[str] = None
 ) -> EditResult:
     """处理单个文件编辑"""
     if edit_type == "decrypt":
-        return await editor.decrypt_pdf(file_path, password)
+        return await editor.decrypt_pdf(file_path, password, original_name)
     elif edit_type == "add_watermark":
         return await editor.add_watermark(
             file_path=file_path,
             text=extra_params.get("text", "水印"),
             position=extra_params.get("position", "center"),
             opacity=extra_params.get("opacity", 0.5),
-            deg=extra_params.get("deg", "0"),
             range=extra_params.get("range", ""),
             layout=extra_params.get("layout", "on"),
             font_family=extra_params.get("font_family"),
             font_size=extra_params.get("font_size"),
             font_color=extra_params.get("font_color"),
-            password=password
+            password=password,
+            original_name=original_name
         )
     elif edit_type == "encrypt":
         return await editor.encrypt_pdf(
             file_path=file_path,
             password=extra_params.get("password", ""),
-            original_password=password
+            original_password=password,
+            original_name=original_name
         )
     elif edit_type == "compress":
         return await editor.compress_pdf(
             file_path=file_path,
             image_quantity=extra_params.get("image_quantity", 60),
-            password=password
+            password=password,
+            original_name=original_name
         )
     elif edit_type == "split":
         return await editor.split_pdf(
@@ -183,27 +180,31 @@ async def process_edit_file(
             pages=extra_params.get("pages", ""),
             password=password,
             split_type=extra_params.get("split_type", "page"),
-            merge_all=extra_params.get("merge_all", 1)
+            merge_all=extra_params.get("merge_all", 1),
+            original_name=original_name
         )
     elif edit_type == "merge":
         # 对于合并操作，我们需要特殊处理，因为它需要处理多个文件
         return EditResult(
             success=False, 
             file_path=file_path, 
-            error_message="合并操作需要使用特殊处理流程"
+            error_message="合并操作需要使用特殊处理流程",
+            original_name=original_name
         )
     elif edit_type == "rotate":
         return await editor.rotate_pdf(
             file_path=file_path, 
             angle=extra_params.get("angle", 90),
             pages=extra_params.get("pages", ""),
-            password=password
+            password=password,
+            original_name=original_name
         )
     else:
         return EditResult(
             success=False, 
             file_path=file_path, 
-            error_message=f"不支持的编辑类型: {edit_type}"
+            error_message=f"不支持的编辑类型: {edit_type}",
+            original_name=original_name
         )
 
 async def process_tool_call(
@@ -246,8 +247,8 @@ async def process_tool_call(
         results = await process_batch_files(
             file_objects, 
             logger,
-            lambda file_path, password: process_edit_file(
-                file_path, edit_type, editor, extra_params, password
+            lambda file_path, password, original_name: process_edit_file(
+                file_path, edit_type, editor, extra_params, password, original_name
             ),
             operation_desc
         )
@@ -255,9 +256,7 @@ async def process_tool_call(
         # 生成报告
         report_msg = generate_result_report(
             results, 
-            operation_desc,
-            f"{edit_map.get(edit_type, edit_type)}成功", 
-            f"{edit_map.get(edit_type, edit_type)}失败"
+            operation_desc
         )
     else:
         # 转换操作
@@ -271,25 +270,19 @@ async def process_tool_call(
         if is_watermark_removal:
             operation_desc = "去除水印"
             task_type = "水印去除"
-            success_action = "去除水印成功"
-            failed_action = "水印去除失败"
         elif is_page_numbering:
             operation_desc = "添加页码"
             task_type = "添加页码"
-            success_action = "添加页码成功"
-            failed_action = "添加页码失败"
         else:
             operation_desc = f"转换为 {format} 格式"
             task_type = "转换"
-            success_action = "转换成功"
-            failed_action = "转换失败"
         
         # 处理文件
         results = await process_batch_files(
             file_objects,
             logger,
-            lambda file_path, password: process_conversion_file(
-                file_path, format, converter, extra_params, password
+            lambda file_path, password, original_name: process_conversion_file(
+                file_path, format, converter, extra_params, password, original_name
             ),
             operation_desc
         )
@@ -297,9 +290,7 @@ async def process_tool_call(
         # 生成报告
         report_msg = generate_result_report(
             results, 
-            task_type,
-            success_action, 
-            failed_action
+            task_type
         )
     
     # 如果全部失败，记录错误
@@ -336,6 +327,10 @@ async def handle_list_tools() -> list[types.Tool]:
                                 "password": {
                                     "type": "string",
                                     "description": "文档密码，如果文档受密码保护，则需要提供此参数"
+                                },
+                                "name": {
+                                    "type": "string",
+                                    "description": "文件的原始文件名"
                                 }
                             },
                             "required": ["path"]
@@ -369,6 +364,10 @@ async def handle_list_tools() -> list[types.Tool]:
                                 "password": {
                                     "type": "string",
                                     "description": "PDF文档密码，如果文档受密码保护，则需要提供此参数"
+                                },
+                                "name": {
+                                    "type": "string",
+                                    "description": "文件的原始文件名"
                                 }
                             },
                             "required": ["path"]
@@ -415,6 +414,10 @@ async def handle_list_tools() -> list[types.Tool]:
                                 "password": {
                                     "type": "string",
                                     "description": "PDF文档密码，如果文档受密码保护，则需要提供此参数"
+                                },
+                                "name": {
+                                    "type": "string",
+                                    "description": "文件的原始文件名"
                                 }
                             },
                             "required": ["path"]
@@ -443,6 +446,10 @@ async def handle_list_tools() -> list[types.Tool]:
                                 "password": {
                                     "type": "string",
                                     "description": "PDF文档密码，如果文档受密码保护，则需要提供此参数"
+                                },
+                                "name": {
+                                    "type": "string",
+                                    "description": "文件的原始文件名"
                                 }
                             },
                             "required": ["path"]
@@ -455,7 +462,7 @@ async def handle_list_tools() -> list[types.Tool]:
                     },
                     "position": {
                         "type": "string",
-                        "description": "水印位置",
+                        "description": "水印位置: 左上(topleft), 上中(top), 右上(topright), 左(left), 中(center), 右(right), 左下(bottomleft), 下(bottom), 右下(bottomright), 对角线(diagonal，-45度), 反对角线(reverse-diagonal，45度)",
                         "enum": ["topleft", "top", "topright", "left", "center", "right", 
                                 "bottomleft", "bottom", "bottomright", "diagonal", "reverse-diagonal"],
                         "default": "center"
@@ -467,11 +474,6 @@ async def handle_list_tools() -> list[types.Tool]:
                         "minimum": 0.0,
                         "maximum": 1.0
                     },
-                    "deg": {
-                        "type": "string",
-                        "description": "倾斜角度，字符串格式",
-                        "default": "0"
-                    },
                     "range": {
                         "type": "string",
                         "description": "页面范围，例如 '1,3,5-7' 或 ''（空字符串或不设置）表示所有页面"
@@ -516,6 +518,10 @@ async def handle_list_tools() -> list[types.Tool]:
                                 "password": {
                                     "type": "string",
                                     "description": "PDF文档的密码，用于解锁文档，如果文档受密码保护，则需要提供此参数"
+                                },
+                                "name": {
+                                    "type": "string",
+                                    "description": "文件的原始文件名"
                                 }
                             },
                             "required": ["path", "password"]
@@ -544,6 +550,10 @@ async def handle_list_tools() -> list[types.Tool]:
                                 "password": {
                                     "type": "string",
                                     "description": "PDF文档密码，如果文档受密码保护，则需要提供此参数"
+                                },
+                                "name": {
+                                    "type": "string",
+                                    "description": "文件的原始文件名"
                                 }
                             },
                             "required": ["path"]
@@ -576,6 +586,10 @@ async def handle_list_tools() -> list[types.Tool]:
                                 "password": {
                                     "type": "string",
                                     "description": "PDF文档密码，如果文档受密码保护，则需要提供此参数"
+                                },
+                                "name": {
+                                    "type": "string",
+                                    "description": "文件的原始文件名"
                                 }
                             },
                             "required": ["path"]
@@ -611,6 +625,10 @@ async def handle_list_tools() -> list[types.Tool]:
                                 "password": {
                                     "type": "string",
                                     "description": "PDF文档密码，如果文档受密码保护，则需要提供此参数"
+                                },
+                                "name": {
+                                    "type": "string",
+                                    "description": "文件的原始文件名"
                                 }
                             },
                             "required": ["path"]
@@ -655,6 +673,10 @@ async def handle_list_tools() -> list[types.Tool]:
                                 "password": {
                                     "type": "string",
                                     "description": "PDF文档密码，如果文档受密码保护，则需要提供此参数"
+                                },
+                                "name": {
+                                    "type": "string",
+                                    "description": "文件的原始文件名"
                                 }
                             },
                             "required": ["path"]
@@ -683,6 +705,10 @@ async def handle_list_tools() -> list[types.Tool]:
                                 "password": {
                                     "type": "string",
                                     "description": "PDF文档密码，如果文档受密码保护，则需要提供此参数"
+                                },
+                                "name": {
+                                    "type": "string",
+                                    "description": "文件的原始文件名"
                                 }
                             },
                             "required": ["path"]
@@ -738,7 +764,7 @@ async def handle_call_tool(name: str, arguments: dict | None) -> list[types.Text
         "add_watermark": {
             "edit_type": "add_watermark",  # 编辑类型
             "is_edit_operation": True,  # 标记为编辑操作
-            "param_keys": ["text", "position", "opacity", "deg", "range", "layout", 
+            "param_keys": ["text", "position", "opacity", "range", "layout", 
                           "font_family", "font_size", "font_color"]  # 需要从arguments获取的参数
         },
         "protect_pdf": {
@@ -773,7 +799,6 @@ async def handle_call_tool(name: str, arguments: dict | None) -> list[types.Text
         "position_watermark": "center",  # 水印的位置默认值
         "margin": 30,
         "opacity": 0.5,
-        "deg": "0",  # 更新为"0"以匹配handle_list_tools中的默认值
         "range": "",
         "layout": "on",  # 添加layout默认值
         "image_quantity": 60,
@@ -832,23 +857,33 @@ async def handle_call_tool(name: str, arguments: dict | None) -> list[types.Text
             file_handler = FileHandler(logger)
             editor = Editor(logger, file_handler)
             
-            # 提取文件路径和密码
+            # 提取文件路径、密码和原始名称
             file_paths = [file_obj["path"] for file_obj in file_objects]
             passwords = [file_obj.get("password") for file_obj in file_objects]
+            original_names = [file_obj.get("name") for file_obj in file_objects]
             
             # 由于merge_pdfs方法只接受一个密码参数，如果文件密码不同，可能需要特殊处理
             # 此处简化处理，使用第一个非空密码
             password = next((p for p in passwords if p), None)
             
+            # 合并文件名用于结果文件
+            merged_name = None
+            if any(original_names):
+                # 如果有原始文件名，则合并它们（最多使用前两个文件名）
+                valid_names = [name for name in original_names if name]
+                if valid_names:
+                    if len(valid_names) == 1:
+                        merged_name = valid_names[0]
+                    else:
+                        merged_name = f"{valid_names[0]}_{valid_names[1]}_等"
+            
             # 直接调用merge_pdfs方法
-            result = await editor.merge_pdfs(file_paths, password)
+            result = await editor.merge_pdfs(file_paths, password, merged_name)
             
             # 构建结果报告
             report_msg = generate_result_report(
                 [result], 
-                "PDF合并",
-                "合并成功",
-                "合并失败"
+                "PDF合并"
             )
             
             # 如果失败，记录错误
@@ -867,6 +902,9 @@ async def handle_call_tool(name: str, arguments: dict | None) -> list[types.Text
 
 async def main():
     """应用主入口"""
+    # 加载环境变量
+    load_dotenv()
+
     # 打印版本号
     try:
         import importlib.metadata
@@ -875,19 +913,71 @@ async def main():
     except Exception as e:
         print("LightPDF AI-PDF MCP Server (版本信息获取失败)", file=sys.stderr)
     
-    import mcp.server.stdio as stdio
+    # 解析命令行参数
+    parser = argparse.ArgumentParser(description="LightPDF AI-PDF MCP Server")
+    parser.add_argument("-p", "--port", type=int, default=0, help="指定SSE服务器的端口号，如果提供则使用SSE模式，否则使用stdio模式")
+    args = parser.parse_args()
+    
+    initialization_options = app.create_initialization_options(
+        notification_options=NotificationOptions()
+    )
     
-    async with stdio.stdio_server() as (read_stream, write_stream):
-        await app.run(
-            read_stream,
-            write_stream,
-            app.create_initialization_options(
-                notification_options=NotificationOptions()
+    if args.port:
+        from mcp.server.sse import SseServerTransport
+        from starlette.applications import Starlette
+        from starlette.routing import Mount, Route
+        import uvicorn
+            
+        # 使用SSE服务器
+        print(f"启动SSE服务器，端口号：{args.port}", file=sys.stderr)
+        
+        # 创建SSE传输
+        transport = SseServerTransport("/messages/")
+        
+        # 定义SSE连接处理函数
+        async def handle_sse(request):
+            async with transport.connect_sse(
+                request.scope, request.receive, request._send
+            ) as streams:
+                await app.run(
+                    streams[0], streams[1], initialization_options
+                )
+        
+        # 创建Starlette应用
+        sse_app = Starlette(routes=[
+            Route("/sse/", endpoint=handle_sse),
+            Mount("/messages/", app=transport.handle_post_message),
+        ])
+        
+        # 使用异步方式启动服务器
+        server = uvicorn.Server(uvicorn.Config(
+            app=sse_app,
+            host="0.0.0.0",
+            port=args.port,
+            log_level="warning"
+        ))
+        await server.serve()
+    else:
+        import mcp.server.stdio as stdio
+
+        # 使用stdio服务器
+        print("启动stdio服务器", file=sys.stderr)
+        async with stdio.stdio_server() as (read_stream, write_stream):
+            await app.run(
+                read_stream,
+                write_stream,
+                initialization_options
             )
-        )
 
 def cli_main():
-    asyncio.run(main())
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        print("服务器被用户中断", file=sys.stderr)
+        sys.exit(0)
+    except Exception as e:
+        print(f"服务器发生错误: {e}", file=sys.stderr)
+        sys.exit(1)
 
 if __name__ == "__main__":
     cli_main()

{lightpdf_aipdf_mcp-0.1.42.dist-info → lightpdf_aipdf_mcp-0.1.44.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lightpdf-aipdf-mcp
-Version: 0.1.42
+Version: 0.1.44
 Summary: MCP Server for LightPDF AI-PDF
 Author: LightPDF Team
 License: Proprietary
@@ -8,9 +8,11 @@ Requires-Python: >=3.8
 Requires-Dist: httpx
 Requires-Dist: httpx-sse
 Requires-Dist: mcp
+Requires-Dist: mcp[cli]
 Requires-Dist: pydantic
 Requires-Dist: pydantic-settings
 Requires-Dist: python-dotenv
+Requires-Dist: starlette
 Requires-Dist: uvicorn
 Description-Content-Type: text/markdown
 
@@ -205,7 +207,6 @@ pip install lightpdf-aipdf-mcp
 - `text`: 水印文本内容
 - `position`: 水印位置，可选值包括"center"、"topleft"等
 - `opacity`: 透明度（0.0-1.0）
-- `deg`: 旋转角度
 - `range`: 页面范围，如 "1,3,5-7"
 - `layout`: 水印显示位置，"on"（在内容上）或"under"（在内容下）
 - 可选的字体设置: `font_family`、`font_size`、`font_color`

lightpdf_aipdf_mcp-0.1.44.dist-info/RECORD

@@ -0,0 +1,9 @@
+lightpdf_aipdf_mcp/__init__.py,sha256=PPnAgpvJLYLVOTxnHDmJAulFnHJD6wuTwS6tRGjqq6s,141
+lightpdf_aipdf_mcp/common.py,sha256=-7LU6gm-As_F8Ly68ssy15Vc9Zt_eNSnvDLEtVZDwlI,6633
+lightpdf_aipdf_mcp/converter.py,sha256=gsYBLqE6EnMCpCYHaYjcdBD5mhXVqiTRvl1yLSqA01w,14773
+lightpdf_aipdf_mcp/editor.py,sha256=KySdMurM8AZHwqSU1PpkSCCesQ4t2h-D8Mm12wf90CA,23539
+lightpdf_aipdf_mcp/server.py,sha256=dd3lAg3DhFYPdgigpcicY_SiMRnwqXkxjbagj5ijSYY,39974
+lightpdf_aipdf_mcp-0.1.44.dist-info/METADATA,sha256=Q8EvtD9EOAMKV1xNC-9hrQ97lSVVsXrHb1i2Ri4Kar0,7906
+lightpdf_aipdf_mcp-0.1.44.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+lightpdf_aipdf_mcp-0.1.44.dist-info/entry_points.txt,sha256=X7TGUe52N4sYH-tYt0YUGApeJgw-efQlZA6uAZmlmr4,63
+lightpdf_aipdf_mcp-0.1.44.dist-info/RECORD,,

lightpdf_aipdf_mcp-0.1.42.dist-info/RECORD

@@ -1,9 +0,0 @@
-lightpdf_aipdf_mcp/__init__.py,sha256=PPnAgpvJLYLVOTxnHDmJAulFnHJD6wuTwS6tRGjqq6s,141
-lightpdf_aipdf_mcp/common.py,sha256=JbKSAknOVvtDIQ7QG4fxj5H1FtCMRMF8PEJw10vyN_k,6564
-lightpdf_aipdf_mcp/converter.py,sha256=MxjO1yqMqfOQ9B696IyjRbtB3oZpemtD7x8arz52zoc,13312
-lightpdf_aipdf_mcp/editor.py,sha256=4hU_GogU1sgZbrrJFhz8106qG18T2OixXNTQHsJTtvE,22802
-lightpdf_aipdf_mcp/server.py,sha256=jXAcfLWhef5E3cle28bytDTTuMiwTMYAglbAFVF6Wlw,35737
-lightpdf_aipdf_mcp-0.1.42.dist-info/METADATA,sha256=WXRb8FSntMMTz-erOUdm3fLFIbOwFIp-1bEURQqJQzI,7879
-lightpdf_aipdf_mcp-0.1.42.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-lightpdf_aipdf_mcp-0.1.42.dist-info/entry_points.txt,sha256=X7TGUe52N4sYH-tYt0YUGApeJgw-efQlZA6uAZmlmr4,63
-lightpdf_aipdf_mcp-0.1.42.dist-info/RECORD,,