huace-aigc-auth-client 1.1.0__py3-none-any.whl → 1.1.2__py3-none-any.whl

huace_aigc_auth_client/__init__.py

@@ -90,4 +90,4 @@ __all__ = [
     "create_sync_config",
     "create_default_field_mappings",
 ]
-__version__ = "1.1.0"
+__version__ = "1.1.2"

huace_aigc_auth_client/legacy_adapter.py

@@ -62,7 +62,8 @@ class SyncConfig:
     # 密码处理
     password_mode: PasswordMode = PasswordMode.UNIFIED
     unified_password: str = "Abc@123456"  # 统一初始密码
-    password_mapper: Optional[Callable[[str], str]] = None  # 自定义密码映射函数
+    password_mapper: Optional[Callable[[Dict], str]] = None  # 自定义密码映射函数（接收用户数据字典）
+    password_is_hashed: bool = False  # password_mapper 返回的是否已经是加密后的密码
     
     # Webhook 配置
     webhook_enabled: bool = False
@@ -104,10 +105,19 @@ class LegacySystemAdapter(ABC):
     - create_user: 创建用户
     - update_user: 更新用户（可选）
     - get_all_users: 获取所有用户（用于初始化同步）
+    - handle_webhook: 处理 webhook 通知（可选，异步方法）
     """
     
-    def __init__(self, sync_config: SyncConfig):
+    def __init__(self, sync_config: SyncConfig, auth_client=None):
+        """
+        初始化适配器
+        
+        Args:
+            sync_config: 同步配置
+            auth_client: AigcAuthClient 实例（可选，用于批量同步）
+        """
         self.config = sync_config
+        self.auth_client = auth_client
     
     @abstractmethod
     def get_user_by_unique_field(self, value: Any) -> Optional[LegacyUserData]:
@@ -127,6 +137,196 @@ class LegacySystemAdapter(ABC):
         """获取所有旧系统用户（用于初始化同步）"""
         return []
     
+    @abstractmethod
+    async def get_user_by_username_async(self, username: str) -> Optional[LegacyUserData]:
+        """异步获取用户（子类必须实现）
+        
+        Args:
+            username: 用户名
+            
+        Returns:
+            Optional[LegacyUserData]: 用户数据，不存在返回 None
+        """
+        raise NotImplementedError("Subclass must implement get_user_by_username_async method")
+    
+    @abstractmethod
+    async def _create_user_async(self, user_data: Dict[str, Any]) -> Optional[Any]:
+        """异步创建用户（子类必须实现）
+        
+        Args:
+            user_data: 用户数据字典
+            
+        Returns:
+            Optional[Any]: 创建的用户 ID 或其他标识
+        """
+        raise NotImplementedError("Subclass must implement _create_user_async method")
+    
+    @abstractmethod
+    async def _update_user_async(self, username: str, user_data: Dict[str, Any]) -> bool:
+        """异步更新用户（子类必须实现）
+        
+        Args:
+            username: 用户名
+            user_data: 要更新的用户数据
+            
+        Returns:
+            bool: 更新成功返回 True
+        """
+        raise NotImplementedError("Subclass must implement _update_user_async method")
+    
+    @abstractmethod
+    async def get_all_users_async(self) -> List[LegacyUserData]:
+        """获取所有用户（子类必须实现，用于批量同步）
+        
+        Returns:
+            List[LegacyUserData]: 所有用户数据列表
+        """
+        raise NotImplementedError("Subclass must implement get_all_users_async method")
+    
+    async def upsert_user_async(self, user_data: Dict[str, Any]) -> Dict[str, Any]:
+        """异步创建或更新用户（存在则更新，不存在则新增）
+        
+        这是一个默认实现，子类可以选择性覆盖以优化性能。
+        
+        Args:
+            user_data: 用户数据字典（必须包含 username）
+            
+        Returns:
+            Dict: 操作结果 {"created": bool, "user_id": Any}
+        """
+        username = user_data.get("username")
+        if not username:
+            raise ValueError("username is required for upsert operation")
+        
+        # 检查用户是否存在
+        existing = await self.get_user_by_username_async(username)
+        
+        if existing:
+            # 用户存在，执行更新
+            await self._update_user_async(username, user_data)
+            return {"created": False, "user_id": existing.get("id")}
+        else:
+            # 用户不存在，执行创建
+            user_id = await self._create_user_async(user_data)
+            return {"created": True, "user_id": user_id}
+    
+    async def batch_sync_to_auth(self) -> Dict[str, Any]:
+        """批量同步旧系统用户到 aigc-auth（默认实现）
+        
+        子类可以选择性覆盖此方法以自定义同步逻辑。
+        
+        Returns:
+            Dict: 同步结果统计
+        """
+        if not self.auth_client:
+            raise ValueError("auth_client is required for batch_sync_to_auth. Please provide it in constructor.")
+        
+        users = await self.get_all_users_async()
+        
+        results = {
+            "total": len(users),
+            "success": 0,
+            "failed": 0,
+            "skipped": 0,
+            "errors": []
+        }
+        
+        for user in users:
+            try:
+                auth_data = self.transform_legacy_to_auth(user)
+                
+                # 获取密码（支持新的元组返回格式）
+                password_result = self.get_password_for_sync(user)
+                if isinstance(password_result, tuple):
+                    password, is_hashed = password_result
+                else:
+                    password, is_hashed = password_result, False
+                
+                # 根据是否已加密选择不同的字段
+                if is_hashed:
+                    auth_data["password_hashed"] = password
+                else:
+                    auth_data["password"] = password
+                
+                result = self.auth_client.sync_user_to_auth(auth_data)
+                
+                if result.get("success"):
+                    if result.get("created"):
+                        results["success"] += 1
+                    else:
+                        results["skipped"] += 1
+                else:
+                    results["failed"] += 1
+                    results["errors"].append({
+                        "user": user.get("username"),
+                        "error": result.get("message")
+                    })
+            except Exception as e:
+                results["failed"] += 1
+                results["errors"].append({
+                    "user": user.get("username"),
+                    "error": str(e)
+                })
+        
+        return results
+    
+    async def handle_webhook(self, event: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        处理来自 aigc-auth 的 webhook 通知（默认实现）
+        
+        子类可以选择性覆盖此方法以自定义 webhook 处理逻辑。
+        
+        Args:
+            event: 事件类型，如 "user.created", "user.updated", "user.deleted"
+            data: 事件数据（用户信息）
+            
+        Returns:
+            Dict: 处理结果
+        """
+        if event == "user.created" or event == "user.updated" or event == "user.login":
+            # 转换数据格式
+            legacy_data = self.transform_auth_to_legacy(data)
+            
+            # 获取密码
+            password_result = self.get_password_for_sync()
+            if isinstance(password_result, tuple):
+                password, is_hashed = password_result
+            else:
+                password, is_hashed = password_result, False
+            legacy_data["password"] = password
+            
+            # 创建或更新用户
+            result = await self.upsert_user_async(legacy_data)
+            
+            return {
+                "success": True,
+                "message": "User created" if result["created"] else "User updated",
+                "created": result["created"],
+                "user_id": result["user_id"]
+            }
+        
+        elif event == "user.deleted":
+            # 禁用用户而不是删除
+            username = data.get("username")
+            await self._update_user_async(username, {"status": "disabled"})
+            
+            return {"success": True, "message": "User disabled"}
+        
+        elif event == "user.init_sync_auth":
+            # 初始化同步：批量同步旧系统用户到 aigc-auth
+            if not self.auth_client:
+                return {"success": False, "message": "auth_client is required for init_sync_auth event. Please provide it in constructor."}
+            
+            results = await self.batch_sync_to_auth()
+            
+            return {
+                "success": True,
+                "message": f"Batch sync completed: {results['success']} created, {results['skipped']} skipped, {results['failed']} failed",
+                "results": results
+            }
+        
+        return {"success": True, "message": "Event ignored"}
+    
     def transform_auth_to_legacy(self, auth_user: Dict[str, Any]) -> Dict[str, Any]:
         """将 aigc-auth 用户数据转换为旧系统格式"""
         result = {}
@@ -167,15 +367,22 @@ class LegacySystemAdapter(ABC):
         
         return result
     
-    def get_password_for_sync(self, legacy_user: Optional[LegacyUserData] = None) -> str:
-        """获取同步时使用的密码"""
+    def get_password_for_sync(self, legacy_user: Optional[LegacyUserData] = None) -> tuple:
+        """获取同步时使用的密码
+        
+        Returns:
+            tuple: (password, is_hashed)
+                - password: 密码字符串
+                - is_hashed: 是否已经是加密后的密码
+        """
         if self.config.password_mode == PasswordMode.UNIFIED:
-            return self.config.unified_password
+            return (self.config.unified_password, False)
         elif self.config.password_mode == PasswordMode.CUSTOM_MAPPING:
             if self.config.password_mapper and legacy_user:
-                return self.config.password_mapper(legacy_user.data)
-            return self.config.unified_password
-        return self.config.unified_password
+                password = self.config.password_mapper(legacy_user.data)
+                return (password, self.config.password_is_hashed)
+            return (self.config.unified_password, False)
+        return (self.config.unified_password, False)
 
 
 class WebhookSender:
@@ -253,78 +460,10 @@ class UserSyncService:
         self.adapter = legacy_adapter
         self.config = legacy_adapter.config
         self.webhook_sender = WebhookSender(self.config)
-    
-    def sync_on_login(self, auth_user_info) -> SyncResult:
-        """
-        登录时同步用户到旧系统
         
-        当用户通过 aigc-auth 登录成功后调用，
-        如果旧系统没有该用户则自动创建。
-        
-        Args:
-            auth_user_info: aigc-auth 返回的 UserInfo 对象
-            
-        Returns:
-            SyncResult: 同步结果
-        """
-        if not self.config.enabled:
-            return SyncResult(success=True, message="Sync disabled")
-        
-        if self.config.direction == SyncDirection.LEGACY_TO_AUTH:
-            return SyncResult(success=True, message="Direction is legacy_to_auth, skip")
-        
-        try:
-            # 获取唯一标识值
-            unique_value = getattr(auth_user_info, self.config.unique_field, None)
-            if not unique_value:
-                return SyncResult(
-                    success=False, 
-                    message=f"Unique field '{self.config.unique_field}' not found in auth user"
-                )
-            
-            # 检查旧系统是否已有该用户
-            legacy_user = self.adapter.get_user_by_unique_field(unique_value)
-            
-            if legacy_user:
-                # 用户已存在，可选更新
-                if self.config.direction == SyncDirection.BIDIRECTIONAL:
-                    auth_data = self._user_info_to_dict(auth_user_info)
-                    legacy_data = self.adapter.transform_auth_to_legacy(auth_data)
-                    self.adapter.update_user(unique_value, legacy_data)
-                
-                return SyncResult(
-                    success=True,
-                    auth_user_id=auth_user_info.id,
-                    legacy_user_id=legacy_user.get("id"),
-                    message="User already exists in legacy system"
-                )
-            
-            # 创建新用户
-            auth_data = self._user_info_to_dict(auth_user_info)
-            legacy_data = self.adapter.transform_auth_to_legacy(auth_data)
-            
-            # 添加密码
-            legacy_data["password"] = self.adapter.get_password_for_sync()
-            
-            legacy_user_id = self.adapter.create_user(legacy_data)
-            
-            if legacy_user_id:
-                return SyncResult(
-                    success=True,
-                    auth_user_id=auth_user_info.id,
-                    legacy_user_id=legacy_user_id,
-                    message="User synced to legacy system"
-                )
-            else:
-                return SyncResult(
-                    success=False,
-                    auth_user_id=auth_user_info.id,
-                    message="Failed to create user in legacy system"
-                )
-                
-        except Exception as e:
-            logger.exception("Error syncing user on login")
-            return SyncResult(success=False, message=str(e), errors=[str(e)])
+        # 确保 adapter 也持有 auth_client 引用
+        if not self.adapter.auth_client:
+            self.adapter.auth_client = auth_client
     
     def _user_info_to_dict(self, user_info) -> Dict[str, Any]:
         """将 UserInfo 对象转换为字典"""
@@ -339,74 +478,59 @@ class UserSyncService:
             "permissions": user_info.permissions,
             "department": user_info.department,
             "company": user_info.company,
-            "is_admin": user_info.is_admin
+            "is_admin": user_info.is_admin,
+            "status": user_info.status,
         }
     
-    def batch_sync_to_auth(
-        self, 
-        users: List[LegacyUserData],
-        on_progress: Optional[Callable[[int, int], None]] = None
-    ) -> Dict[str, Any]:
+    async def sync_on_login_async(self, auth_user_info) -> Dict[str, Any]:
         """
-        批量同步旧系统用户到 aigc-auth
+        登录时异步同步用户到旧系统
+        
+        当用户通过 aigc-auth 登录成功后调用，
+        如果旧系统没有该用户则自动创建。
         
         Args:
-            users: 旧系统用户列表
-            on_progress: 进度回调函数 (current, total)
+            auth_user_info: aigc-auth 返回的 UserInfo 对象
             
         Returns:
-            Dict: 同步结果统计
+            Dict: 同步结果
         """
-        results = {
-            "total": len(users),
-            "success": 0,
-            "failed": 0,
-            "skipped": 0,
-            "errors": []
-        }
+        if not self.config.enabled:
+            return {"success": True, "message": "Sync disabled"}
         
-        for i, user in enumerate(users):
-            try:
-                auth_data = self.adapter.transform_legacy_to_auth(user)
-                
-                # 添加密码
-                auth_data["password"] = self.adapter.get_password_for_sync(user)
-                
-                # 调用 SDK 同步接口
-                result = self.auth_client.sync_user_to_auth(auth_data)
-                
-                if result.get("success"):
-                    if result.get("created"):
-                        results["success"] += 1
-                    else:
-                        results["skipped"] += 1
-                else:
-                    results["failed"] += 1
-                    results["errors"].append({
-                        "user": user.get(self.config.unique_field),
-                        "error": result.get("message")
-                    })
-                    
-            except Exception as e:
-                results["failed"] += 1
-                results["errors"].append({
-                    "user": user.get(self.config.unique_field),
-                    "error": str(e)
-                })
-            
-            if on_progress:
-                on_progress(i + 1, len(users))
+        # 转换用户数据
+        auth_data = self._user_info_to_dict(auth_user_info)
+        legacy_data = self.adapter.transform_auth_to_legacy(auth_data)
         
-        return results
-    
-    def send_user_created_webhook(self, auth_user_data: Dict[str, Any]) -> bool:
-        """发送用户创建 webhook"""
-        return self.webhook_sender.send("user.created", auth_user_data)
+        # 获取密码（支持新的元组返回格式）
+        password_result = self.adapter.get_password_for_sync()
+        if isinstance(password_result, tuple):
+            password, is_hashed = password_result
+        else:
+            password, is_hashed = password_result, False
+        legacy_data["password"] = password
+        
+        # 使用 upsert 方法（存在则更新，不存在则创建）
+        result = await self.adapter.upsert_user_async(legacy_data)
+        
+        return {
+            "success": True,
+            "auth_user_id": auth_user_info.id,
+            "legacy_user_id": result["user_id"],
+            "created": result["created"],
+            "message": "User created" if result["created"] else "User updated"
+        }
     
-    def send_user_updated_webhook(self, auth_user_data: Dict[str, Any]) -> bool:
-        """发送用户更新 webhook"""
-        return self.webhook_sender.send("user.updated", auth_user_data)
-
+    async def batch_sync_to_auth_async(self) -> Dict[str, Any]:
+        """
+        异步批量同步旧系统用户到 aigc-auth
+        
+        直接委托给 adapter 的默认实现
+        
+        Returns:
+            Dict: 同步结果统计
+        """
+        return await self.adapter.batch_sync_to_auth()
 
 # ============ 预设字段映射 ============
 

huace_aigc_auth_client/sdk.py

@@ -42,6 +42,7 @@ class UserInfo:
     department: Optional[str] = None
     company: Optional[str] = None
     is_admin: Optional[bool] = None
+    status: Optional[str] = None
 
     def __post_init__(self):
         if self.roles is None:
@@ -91,7 +92,7 @@ class AigcAuthClient:
         client = AigcAuthClient(
             app_id="your_app_id",
             app_secret="your_app_secret",
-            base_url="https://aigc-auth.huacemedia.com/api/v1"  # 可选
+            base_url="https://aigc-auth.huacemedia.com/aigc-auth/api/v1"  # 可选
         )
 
         # 验证 token
@@ -127,7 +128,7 @@ class AigcAuthClient:
         self.base_url = (
             base_url or
             os.getenv("AIGC_AUTH_BASE_URL") or
-            "https://aigc-auth.huacemedia.com/api/v1"
+            "https://aigc-auth.huacemedia.com/aigc-auth/api/v1"
         )
         self.timeout = timeout
         self.cache_ttl = cache_ttl
@@ -225,7 +226,7 @@ class AigcAuthClient:
         """清空所有缓存"""
         self._cache.clear()
 
-    def _request(self, method: str, endpoint: str, data: Dict = None, token: str = None) -> Dict:
+    def _request(self, method: str, endpoint: str, data: Dict = None, token: str = None, headers: Dict[str, str] = None) -> Dict:
         """
         发送请求
         
@@ -234,6 +235,7 @@ class AigcAuthClient:
             endpoint: 端点路径
             data: 请求数据
             token: 用户 token（用于缓存键）
+            headers: 自定义请求头（会与默认 headers 合并，自定义的优先）
             
         Returns:
             Dict: 响应数据
@@ -253,11 +255,16 @@ class AigcAuthClient:
                 return cached_data
         
         try:
+            # 合并 headers：默认 headers + 自定义 headers（自定义的优先）
+            request_headers = self._get_headers()
+            if headers:
+                request_headers.update(headers)
+            
             response = requests.request(
                 method=method,
                 url=url,
                 json=data,
-                headers=self._get_headers(),
+                headers=request_headers,
                 timeout=self.timeout
             )
             response.raise_for_status()
@@ -323,7 +330,8 @@ class AigcAuthClient:
             permissions=data.get("permissions", []),
             department=data.get("department"),
             company=data.get("company"),
-            is_admin=data.get("is_admin")
+            is_admin=data.get("is_admin"),
+            status=data.get("status")
         )
 
     def check_permissions(
@@ -372,12 +380,15 @@ class AigcAuthClient:
 
     # ============ 用户同步相关方法 ============
 
-    def sync_user_to_auth(self, user_data: Dict[str, Any]) -> Dict[str, Any]:
+    def sync_user_to_auth(self, user_data: Dict[str, Any], headers: Dict[str, str] = None) -> Dict[str, Any]:
         """
         同步用户到 aigc-auth（用于旧系统初始化同步）
 
         Args:
-            user_data: 用户数据，必须包含 username 和 password
+            user_data: 用户数据，必须包含 username，以及 password 或 password_hashed 二选一
+                - password: 明文密码
+                - password_hashed: 已加密的密码哈希（bcrypt 格式）
+            headers: 自定义请求头（可选）
 
         Returns:
             Dict: 同步结果
@@ -386,14 +397,15 @@ class AigcAuthClient:
                 - user_id: int 用户ID
                 - message: str 消息
         """
-        return self._request("POST", "/sync/user", user_data)
+        return self._request("POST", "/sync/user", user_data, headers=headers)
 
-    def batch_sync_users_to_auth(self, users: List[Dict[str, Any]]) -> Dict[str, Any]:
+    def batch_sync_users_to_auth(self, users: List[Dict[str, Any]], headers: Dict[str, str] = None) -> Dict[str, Any]:
         """
         批量同步用户到 aigc-auth
 
         Args:
-            users: 用户数据列表
+            users: 用户数据列表，每个用户必须包含 username，以及 password 或 password_hashed 二选一
+            headers: 自定义请求头（可选）
 
         Returns:
             Dict: 批量同步结果
@@ -403,7 +415,7 @@ class AigcAuthClient:
                 - skipped: int 跳过数（已存在）
                 - errors: List[Dict] 错误详情
         """
-        return self._request("POST", "/sync/batch", {"users": users})
+        return self._request("POST", "/sync/batch", {"users": users}, headers=headers)
 
     def register_webhook(self, webhook_url: str, events: List[str], secret: Optional[str] = None) -> Dict[str, Any]:
         """

{huace_aigc_auth_client-1.1.0.dist-info → huace_aigc_auth_client-1.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: huace-aigc-auth-client
-Version: 1.1.0
+Version: 1.1.2
 Summary: 华策AIGC Auth Client - 提供 Token 验证、用户信息获取、权限检查、旧系统接入等功能
 Author-email: Huace <support@huace.com>
 License: MIT
@@ -46,7 +46,7 @@ AIGC_AUTH_APP_ID=your_app_id
 AIGC_AUTH_APP_SECRET=your_app_secret
 
 # 可选：鉴权服务地址（默认为生产环境）
-AIGC_AUTH_BASE_URL=https://aigc-auth.huacemedia.com/api/v1
+AIGC_AUTH_BASE_URL=https://aigc-auth.huacemedia.com/aigc-auth/api/v1
 ```
 
 如需通过 Nginx 代理：
@@ -75,7 +75,7 @@ client = AigcAuthClient()
 client = AigcAuthClient(
     app_id="your_app_id",
     app_secret="your_app_secret",
-    base_url="https://aigc-auth.huacemedia.com/api/v1"
+    base_url="https://aigc-auth.huacemedia.com/aigc-auth/api/v1"
 )
 ```
 
@@ -108,11 +108,11 @@ try:
     print(f"角色: {user.roles}")
     print(f"权限: {user.permissions}")
     
-    # 检查角色
-    if user.has_role("admin"):
+    # 检查角色(在 Auth 里面配置)
+    if user.has_role("admin") or user.is_admin:
         print("是管理员")
     
-    # 检查权限
+    # 检查权限(在 Auth 里面配置)
     if user.has_permission("user:write"):
         print("有用户写权限")
         
@@ -353,7 +353,7 @@ except AigcAuthError as e:
 # .env 文件
 AIGC_AUTH_APP_ID=your_app_id
 AIGC_AUTH_APP_SECRET=your_app_secret
-AIGC_AUTH_BASE_URL=https://aigc-auth.huacemedia.com/api/v1
+AIGC_AUTH_BASE_URL=https://aigc-auth.huacemedia.com/aigc-auth/api/v1
 
 # 同步配置
 AIGC_AUTH_SYNC_ENABLED=true
@@ -525,7 +525,20 @@ async def init_sync():
     
     for user in users:
         auth_data = adapter.transform_legacy_to_auth(user)
-        auth_data["password"] = sync_config.unified_password
+        
+        # 获取密码（支持元组返回格式）
+        password_result = adapter.get_password_for_sync(user)
+        if isinstance(password_result, tuple):
+            password, is_hashed = password_result
+        else:
+            password, is_hashed = password_result, False
+        
+        # 根据是否已加密选择不同的字段
+        if is_hashed:
+            auth_data["password_hashed"] = password  # 直接传递已加密密码
+        else:
+            auth_data["password"] = password  # 传递明文密码，服务端会加密
+        
         client.sync_user_to_auth(auth_data)
     
     print(f"同步完成：{len(users)} 个用户")
@@ -538,28 +551,42 @@ asyncio.run(init_sync())
 
 | 模式 | 说明 | 适用场景 |
 |------|------|----------|
-| `UNIFIED` | 统一初始密码 | 推荐，安全性高 |
+| `UNIFIED` | 统一初始密码 | 新系统接入，安全性高 |
 | `CUSTOM_MAPPING` | 自定义映射函数 | 需要保留原密码时 |
+| `CUSTOM_MAPPING` + `password_is_hashed=True` | 直接同步已加密密码 | **推荐**，两系统使用相同加密方式 (bcrypt) |
 
 ```python
 from huace_aigc_auth_client import PasswordMode, create_sync_config
 
-# 统一密码模式（推荐）
+# 统一密码模式
 sync_config = create_sync_config(
     password_mode=PasswordMode.UNIFIED,
     unified_password="Abc@123456"
 )
 
-# 自定义映射模式
+# 自定义映射模式（返回明文密码）
 def password_mapper(user_data):
-    return user_data.get("hashed_password", "default")
+    return user_data.get("password", "default")
 
 sync_config = create_sync_config(
     password_mode=PasswordMode.CUSTOM_MAPPING,
     password_mapper=password_mapper
 )
+
+# 直接同步已加密密码（推荐，适用于两系统使用相同的 bcrypt 加密）
+def hashed_password_mapper(user_data):
+    return user_data.get("hashed_password", "")
+
+sync_config = create_sync_config(
+    password_mode=PasswordMode.CUSTOM_MAPPING,
+    password_mapper=hashed_password_mapper,
+    password_is_hashed=True  # 标记返回的是已加密密码
+)
 ```
 
+> **注意**：当 `password_is_hashed=True` 时，SDK 会使用 `password_hashed` 字段传递到服务端，
+> 服务端会直接使用该哈希值而不再重新加密。
+
 ### 同步方向配置
 
 ```python
@@ -611,6 +638,45 @@ from huace_aigc_auth_client import (
 )
 ```
 
+---
+
+## API 变更日志
+
+### v1.1.0 (2026-01-13)
+
+#### 新增功能
+
+1. **支持直接同步已加密密码**
+   - `SyncConfig` 新增 `password_is_hashed` 参数
+   - `SyncUserRequest` 新增 `password_hashed` 字段
+   - 当两个系统使用相同的密码加密方式（bcrypt）时，可直接同步已加密密码
+
+2. **`_request` 方法支持自定义 headers**
+   - `sync_user_to_auth(user_data, headers=None)` 支持传入自定义请求头
+   - `batch_sync_users_to_auth(users, headers=None)` 支持传入自定义请求头
+
+3. **`get_password_for_sync` 返回格式变更**
+   - 旧版：返回 `str`（密码字符串）
+   - 新版：返回 `tuple[str, bool]`（密码字符串, 是否已加密）
+
+#### 使用示例
+
+```python
+# 直接同步已加密密码
+sync_config = create_sync_config(
+    password_mode=PasswordMode.CUSTOM_MAPPING,
+    password_mapper=lambda user: user.get("hashed_password"),
+    password_is_hashed=True,  # 新增参数
+)
+
+# SDK 调用
+client.sync_user_to_auth({
+    "username": "test",
+    "password_hashed": "$2b$12$xxxxx...",  # 直接传递 bcrypt 哈希值
+    "email": "test@example.com"
+})
+```
+
 ## 许可证
 
 MIT License

huace_aigc_auth_client-1.1.2.dist-info/RECORD

@@ -0,0 +1,8 @@
+huace_aigc_auth_client/__init__.py,sha256=XUdOpgiTYKRsmyhCuyH2rY7Ps6Sjsic8xA9nJF71r8U,2163
+huace_aigc_auth_client/legacy_adapter.py,sha256=HRhcoOaTwfHT4F2sfr2JQ3Q5_yd8tngMbycgWjMOGRQ,20966
+huace_aigc_auth_client/sdk.py,sha256=46kkNDmWcce4BkSAT9zn5n8XdURDns3YtXIIfe8TGDU,22453
+huace_aigc_auth_client-1.1.2.dist-info/licenses/LICENSE,sha256=z7dgC7KljhBLNvKjN15391nMj3aLt0gbud8-Yf1F8EQ,1063
+huace_aigc_auth_client-1.1.2.dist-info/METADATA,sha256=gA3CPCKM9-E8bnfeivTTeHasqJd--_JSv3FtjZ0IQ_g,20084
+huace_aigc_auth_client-1.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+huace_aigc_auth_client-1.1.2.dist-info/top_level.txt,sha256=kbv0nQ6PQ0JVneWPH7O2AbtlJnP7AjvFJ6JjM6ZEBxo,23
+huace_aigc_auth_client-1.1.2.dist-info/RECORD,,

huace_aigc_auth_client-1.1.0.dist-info/RECORD

@@ -1,8 +0,0 @@
-huace_aigc_auth_client/__init__.py,sha256=6b5KUzvQaGgjNPeO3AdzJm9kqFAPfLQNNulkYqFadQc,2163
-huace_aigc_auth_client/legacy_adapter.py,sha256=dSEqROe6UK-NEcxC53aG-zEOXQgRRSV-Li128vvRWhw,16149
-huace_aigc_auth_client/sdk.py,sha256=obiLellLFoct79ZTJKWcjE_eAE-d4zzO8ObZE7KLoAE,21573
-huace_aigc_auth_client-1.1.0.dist-info/licenses/LICENSE,sha256=z7dgC7KljhBLNvKjN15391nMj3aLt0gbud8-Yf1F8EQ,1063
-huace_aigc_auth_client-1.1.0.dist-info/METADATA,sha256=E-kmBqpoTUqAW8pvg_1rHFrUn0hvLUn9fi94xwHWP2o,17641
-huace_aigc_auth_client-1.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-huace_aigc_auth_client-1.1.0.dist-info/top_level.txt,sha256=kbv0nQ6PQ0JVneWPH7O2AbtlJnP7AjvFJ6JjM6ZEBxo,23
-huace_aigc_auth_client-1.1.0.dist-info/RECORD,,