sycommon-python-lib 0.2.1a36__tar.gz → 0.2.1a37__tar.gz

{sycommon_python_lib-0.2.1a36 → sycommon_python_lib-0.2.1a37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.1a36
+Version: 0.2.1a37
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{sycommon_python_lib-0.2.1a36 → sycommon_python_lib-0.2.1a37}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.2.1a36"
+version = "0.2.1a37"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.11"

{sycommon_python_lib-0.2.1a36 → sycommon_python_lib-0.2.1a37}/src/sycommon/agent/sandbox/file_ops.py

@@ -33,7 +33,7 @@ class FileOperationsMixin:
     """文件操作 Mixin
 
     适配 deepagents 0.5.0a2 协议
-    同步方法为主实现，异步方法通过 asyncio.to_thread 调用
+    同步方法为主实现，异步方法使用 aiohttp 实现
     """
 
     _timeout: int  # 类型提示，子类需要提供此属性
@@ -46,6 +46,10 @@ class FileOperationsMixin:
         """发送同步 POST 请求"""
         ...
 
+    async def _post_async_with_failover(self: "HTTPSandboxBackend", endpoint: str, data: dict, timeout: int = None) -> dict:
+        """发送异步 POST 请求（带故障转移）"""
+        ...
+
     def _ensure_synced_sync(self: "HTTPSandboxBackend"):
         """确保目录已同步（同步版本）"""
         if not self._auto_sync:
@@ -72,6 +76,32 @@ class FileOperationsMixin:
             self._workspace_verified = True
             SYLogger.info(f"[Sandbox] 同步完成")
 
+    async def _ensure_synced_async(self: "HTTPSandboxBackend"):
+        """确保目录已同步（异步版本）"""
+        if not self._auto_sync:
+            return
+
+        if self._synced and self._workspace_verified:
+            return
+
+        SYLogger.info(f"[Sandbox] 开始检查工作空间同步状态（异步）...")
+
+        try:
+            workspace_exists = await self._check_workspace_exists_async()
+        except Exception as e:
+            SYLogger.warning(f"[Sandbox] 检查工作空间异常: {e}，跳过检查")
+            workspace_exists = True
+
+        if not workspace_exists:
+            SYLogger.info(f"[Sandbox] 工作空间不存在或已被清空，重新同步...")
+            self._synced = False
+
+        if not self._synced:
+            SYLogger.info(f"[Sandbox] 开始同步目录（异步）...")
+            await self._sync_async()
+            self._workspace_verified = True
+            SYLogger.info(f"[Sandbox] 同步完成")
+
     def _check_workspace_exists_sync(self: "HTTPSandboxBackend") -> bool:
         """检查沙箱工作空间是否存在（同步版本）"""
         try:
@@ -84,10 +114,26 @@ class FileOperationsMixin:
             SYLogger.warning(f"[Sandbox] 检查工作空间失败: {e}")
             return False
 
+    async def _check_workspace_exists_async(self: "HTTPSandboxBackend") -> bool:
+        """检查沙箱工作空间是否存在（异步版本）"""
+        try:
+            await self._post_async_with_failover(f"{SANDBOX_API_PREFIX}/ls", {
+                "path": "/",
+                "user_id": self.user_id
+            })
+            return True
+        except Exception as e:
+            SYLogger.warning(f"[Sandbox] 检查工作空间失败: {e}")
+            return False
+
     def _sync_sync(self: "HTTPSandboxBackend"):
         """同步目录（同步版本，由子类实现）"""
         ...
 
+    async def _sync_async(self: "HTTPSandboxBackend") -> dict:
+        """同步目录（异步版本，由子类实现）"""
+        ...
+
     # ============== 目录操作 ==============
 
     def ls(self: "HTTPSandboxBackend", path: str) -> LsResult:
@@ -107,8 +153,20 @@ class FileOperationsMixin:
             return LsResult(error=str(e))
 
     async def als(self: "HTTPSandboxBackend", path: str) -> LsResult:
-        """异步列出目录内容"""
-        return await asyncio.to_thread(self.ls, path)
+        """异步列出目录内容（真正的异步实现）"""
+        try:
+            await self._ensure_synced_async()
+            SYLogger.info(f"[Sandbox] 异步列出目录: {path}")
+            result = await self._post_async_with_failover(f"{SANDBOX_API_PREFIX}/ls", {
+                "path": path,
+                "user_id": self.user_id
+            })
+            entries = [FileInfo(**item) for item in result]
+            SYLogger.info(f"[Sandbox] 目录内容: {len(entries)} 项")
+            return LsResult(entries=entries)
+        except Exception as e:
+            SYLogger.error(f"[Sandbox] 异步列出目录失败: {e}")
+            return LsResult(error=str(e))
 
     # ============== 文件读写 ==============
 
@@ -153,8 +211,33 @@ class FileOperationsMixin:
         offset: int = 0,
         limit: int = 2000,
     ) -> ReadResult:
-        """异步读取文件内容"""
-        return await asyncio.to_thread(self.read, file_path, offset, limit)
+        """异步读取文件内容（真正的异步实现）"""
+        try:
+            await self._ensure_synced_async()
+            SYLogger.info(f"[Sandbox] 异步读取文件: {file_path} (offset={offset}, limit={limit})")
+            result = await self._post_async_with_failover(f"{SANDBOX_API_PREFIX}/read", {
+                "file_path": file_path,
+                "user_id": self.user_id,
+                "offset": offset,
+                "limit": limit
+            })
+            if result.get("error"):
+                SYLogger.error(f"[Sandbox] 异步读取文件失败: {result['error']}")
+                return ReadResult(error=result["error"])
+            content = result.get("content", "")
+            SYLogger.info(f"[Sandbox] 异步读取完成: {len(content)} 字符")
+            from datetime import datetime
+            now = datetime.now().isoformat()
+            file_data = FileData(
+                content=content,
+                encoding="utf-8",
+                created_at=result.get("created_at", now),
+                modified_at=result.get("modified_at", now),
+            )
+            return ReadResult(file_data=file_data)
+        except Exception as e:
+            SYLogger.error(f"[Sandbox] 异步读取文件异常: {e}")
+            return ReadResult(error=str(e))
 
     def write(
         self: "HTTPSandboxBackend",
@@ -188,8 +271,27 @@ class FileOperationsMixin:
         file_path: str,
         content: str,
     ) -> WriteResult:
-        """异步写入文件"""
-        return await asyncio.to_thread(self.write, file_path, content)
+        """异步写入文件（真正的异步实现）"""
+        try:
+            await self._ensure_synced_async()
+            SYLogger.info(f"[Sandbox] 异步写入文件: {file_path} ({len(content)} 字符)")
+            result = await self._post_async_with_failover(f"{SANDBOX_API_PREFIX}/write", {
+                "file_path": file_path,
+                "content": base64.b64encode(content.encode()).decode(),
+                "user_id": self.user_id
+            })
+            write_result = WriteResult(
+                error=result.get("error"),
+                path=result.get("path")
+            )
+            if write_result.error:
+                SYLogger.error(f"[Sandbox] 异步写入失败: {write_result.error}")
+            else:
+                SYLogger.info(f"[Sandbox] 异步写入成功: {write_result.path}")
+            return write_result
+        except Exception as e:
+            SYLogger.error(f"[Sandbox] 异步写入文件异常: {e}")
+            return WriteResult(error=str(e))
 
     def edit(
         self: "HTTPSandboxBackend",
@@ -224,8 +326,24 @@ class FileOperationsMixin:
         new_string: str,
         replace_all: bool = False,
     ) -> EditResult:
-        """异步编辑文件"""
-        return await asyncio.to_thread(self.edit, file_path, old_string, new_string, replace_all)
+        """异步编辑文件（真正的异步实现）"""
+        try:
+            await self._ensure_synced_async()
+            result = await self._post_async_with_failover(f"{SANDBOX_API_PREFIX}/edit", {
+                "file_path": file_path,
+                "old_string": base64.b64encode(old_string.encode()).decode(),
+                "new_string": base64.b64encode(new_string.encode()).decode(),
+                "user_id": self.user_id,
+                "replace_all": replace_all
+            })
+            return EditResult(
+                error=result.get("error"),
+                path=result.get("path"),
+                occurrences=result.get("occurrences")
+            )
+        except Exception as e:
+            SYLogger.error(f"[Sandbox] 异步编辑文件异常: {e}")
+            return EditResult(error=str(e))
 
     # ============== 搜索 ==============
 
@@ -245,8 +363,19 @@ class FileOperationsMixin:
             return GlobResult(error=str(e))
 
     async def aglob(self: "HTTPSandboxBackend", pattern: str, path: str = "/") -> GlobResult:
-        """异步 glob 搜索文件"""
-        return await asyncio.to_thread(self.glob, pattern, path)
+        """异步 glob 搜索文件（真正的异步实现）"""
+        try:
+            await self._ensure_synced_async()
+            result = await self._post_async_with_failover(f"{SANDBOX_API_PREFIX}/glob", {
+                "pattern": pattern,
+                "path": path,
+                "user_id": self.user_id
+            })
+            matches = [FileInfo(**item) for item in result]
+            return GlobResult(matches=matches)
+        except Exception as e:
+            SYLogger.error(f"[Sandbox] 异步 glob 搜索失败: {e}")
+            return GlobResult(error=str(e))
 
     def grep(
         self: "HTTPSandboxBackend",
@@ -277,8 +406,22 @@ class FileOperationsMixin:
         path: str = None,
         glob: str = None,
     ) -> GrepResult:
-        """异步搜索文件内容"""
-        return await asyncio.to_thread(self.grep, pattern, path, glob)
+        """异步搜索文件内容（真正的异步实现）"""
+        try:
+            await self._ensure_synced_async()
+            result = await self._post_async_with_failover(f"{SANDBOX_API_PREFIX}/grep", {
+                "pattern": pattern,
+                "user_id": self.user_id,
+                "path": path,
+                "glob": glob
+            })
+            if isinstance(result, list):
+                matches = [GrepMatch(**item) for item in result]
+                return GrepResult(matches=matches)
+            return GrepResult(error="Unexpected result format")
+        except Exception as e:
+            SYLogger.error(f"[Sandbox] 异步 grep 搜索失败: {e}")
+            return GrepResult(error=str(e))
 
     # ============== 兼容旧版 API（已废弃）==============
 

{sycommon_python_lib-0.2.1a36 → sycommon_python_lib-0.2.1a37}/src/sycommon/agent/sandbox/http_sandbox_backend.py

@@ -9,10 +9,13 @@ HTTP 客户端沙箱后端
 import asyncio
 import base64
 import os
+import ssl
 import requests
 from pathlib import Path
 from typing import Optional, List
 
+import aiohttp
+
 from sycommon.logging.kafka_log import SYLogger
 from sycommon.agent.sandbox.file_ops import FileOperationsMixin, SANDBOX_API_PREFIX
 
@@ -23,6 +26,13 @@ from deepagents.backends.protocol import (
     FileUploadResponse,
 )
 
+# SSL 上下文
+try:
+    import certifi
+    _SSL_CONTEXT = ssl.create_default_context(cafile=certifi.where())
+except ImportError:
+    _SSL_CONTEXT = ssl.create_default_context()
+
 
 class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
     """
@@ -305,6 +315,58 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         """发送同步 POST 请求（带故障转移）"""
         return self._post_sync_with_failover(endpoint, data, timeout)
 
+    # ============== 内部方法 - 异步版本 ==============
+
+    async def _post_async(self, endpoint: str, data: dict, timeout: int = None) -> dict:
+        """真正的异步 POST 请求（使用 aiohttp）"""
+        actual_timeout = timeout or self._timeout
+        if "/execute" in endpoint:
+            http_timeout = actual_timeout + 60
+        else:
+            http_timeout = actual_timeout + 30
+
+        trace_id = SYLogger.get_trace_id()
+        headers = {"Content-Type": "application/json"}
+        if trace_id:
+            headers["x-traceid-header"] = str(trace_id)
+
+        url = f"{self._base_url}{endpoint}"
+        SYLogger.info(f"[Sandbox] Async POST 请求开始: {url}, timeout={http_timeout}s")
+
+        connector = aiohttp.TCPConnector(ssl=_SSL_CONTEXT)
+        timeout_obj = aiohttp.ClientTimeout(total=http_timeout)
+
+        async with aiohttp.ClientSession(connector=connector, timeout=timeout_obj) as session:
+            async with session.post(url, json=data, headers=headers) as resp:
+                SYLogger.info(f"[Sandbox] Async POST 响应状态码: {resp.status}")
+                if resp.status >= 400:
+                    text = await resp.text()
+                    SYLogger.error(f"[Sandbox] HTTP 错误 {resp.status}: {text}")
+                    resp.raise_for_status()
+                result = await resp.json()
+                SYLogger.info(f"[Sandbox] Async POST 成功: {url}")
+                return result
+
+    async def _post_async_with_failover(self, endpoint: str, data: dict, timeout: int = None) -> dict:
+        """带故障转移的异步 POST 请求"""
+        max_retries = 3
+
+        for attempt in range(max_retries):
+            try:
+                return await self._post_async(endpoint, data, timeout)
+            except (aiohttp.ClientError, asyncio.TimeoutError) as e:
+                SYLogger.warning(f"[Sandbox] Async 请求失败 (尝试 {attempt + 1}/{max_retries}): {self._base_url} - {e}")
+
+                if attempt < max_retries - 1:
+                    # 尝试故障转移
+                    switched = await asyncio.to_thread(self._refresh_from_nacos_and_switch_sync)
+                    if not switched:
+                        await asyncio.sleep(1)
+                else:
+                    raise RuntimeError(f"沙箱服务不可用: {e}")
+
+        raise RuntimeError("沙箱服务不可用")
+
     # ============== 属性 ==============
 
     @property
@@ -351,8 +413,172 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
             )
 
     async def aexecute(self, command: str, *, timeout: int = None) -> ExecuteResponse:
-        """异步执行 shell 命令"""
-        return await asyncio.to_thread(self.execute, command, timeout=timeout)
+        """异步执行 shell 命令（真正的异步实现）"""
+        SYLogger.info(f"[Sandbox] aexecute 开始: command={command}")
+        await self._ensure_synced_async()
+        SYLogger.info(f"[Sandbox] _ensure_synced_async 完成，开始执行命令: {command}")
+        try:
+            result = await self._post_async_with_failover(f"{SANDBOX_API_PREFIX}/execute", {
+                "command": command,
+                "user_id": self._user_id,
+                "timeout": timeout or self._timeout
+            })
+            response = ExecuteResponse(
+                output=result["output"],
+                exit_code=result["exit_code"],
+                truncated=result.get("truncated", False)
+            )
+            SYLogger.info(f"[Sandbox] 异步执行完成: exit_code={response.exit_code}")
+            return response
+        except Exception as e:
+            SYLogger.error(f"[Sandbox] 异步执行异常: {e}")
+            return ExecuteResponse(
+                output=f"Error: {type(e).__name__}: {e}",
+                exit_code=1,
+                truncated=False
+            )
+
+    async def _ensure_synced_async(self):
+        """确保目录已同步（异步版本）"""
+        if not self._auto_sync:
+            return
+
+        if self._synced and self._workspace_verified:
+            return
+
+        SYLogger.info(f"[Sandbox] 开始检查工作空间同步状态（异步）...")
+
+        try:
+            workspace_exists = await self._check_workspace_exists_async()
+        except Exception as e:
+            SYLogger.warning(f"[Sandbox] 检查工作空间异常: {e}，跳过检查")
+            workspace_exists = True
+
+        if not workspace_exists:
+            SYLogger.info(f"[Sandbox] 工作空间不存在或已被清空，重新同步...")
+            self._synced = False
+
+        if not self._synced:
+            SYLogger.info(f"[Sandbox] 开始同步目录（异步）...")
+            await self._sync_async()
+            self._workspace_verified = True
+            SYLogger.info(f"[Sandbox] 同步完成")
+
+    async def _check_workspace_exists_async(self) -> bool:
+        """检查沙箱工作空间是否存在（异步版本）"""
+        try:
+            await self._post_async(f"{SANDBOX_API_PREFIX}/ls", {
+                "path": "/",
+                "user_id": self._user_id
+            })
+            return True
+        except Exception as e:
+            SYLogger.warning(f"[Sandbox] 检查工作空间失败: {e}")
+            return False
+
+    async def _sync_async(self) -> dict:
+        """同步目录（异步版本）"""
+        if not self._sync_dirs:
+            SYLogger.info("[Sandbox] 没有配置同步目录")
+            return {}
+
+        SYLogger.info(f"[Sandbox] _sync_async 开始, 共 {len(self._sync_dirs)} 个目录")
+        results = {}
+        for idx, (local_path, remote_path) in enumerate(self._sync_dirs):
+            SYLogger.info(f"[Sandbox] 同步目录 [{idx+1}/{len(self._sync_dirs)}]: {local_path} -> {remote_path}")
+            local_dir = Path(local_path)
+
+            if not local_dir.exists():
+                SYLogger.error(f"[Sandbox] 本地目录不存在: {local_path}")
+                results[local_path] = {"success": 0, "failed": 0, "errors": [{"error": "目录不存在"}]}
+                continue
+
+            if local_dir.is_dir():
+                SYLogger.info(f"[Sandbox] 开始上传目录: {local_path}")
+                result = await self._upload_directory_async(str(local_dir), remote_path)
+                results[local_path] = result
+                SYLogger.info(f"[Sandbox] 目录上传完成: {local_path}, 成功={result['success']}, 失败={result['failed']}")
+            else:
+                # 单文件
+                SYLogger.info(f"[Sandbox] 上传单文件: {local_path}")
+                content = await asyncio.to_thread(lambda: open(local_dir, "rb").read())
+                upload_results = await self.aupload_files([(remote_path, content)])
+                if upload_results[0].error:
+                    results[local_path] = {"success": 0, "failed": 1, "errors": [{"path": remote_path, "error": upload_results[0].error}]}
+                else:
+                    results[local_path] = {"success": 1, "failed": 0, "errors": []}
+
+        self._synced = True
+        SYLogger.info("[Sandbox] _sync_async 完成")
+        return results
+
+    async def _upload_directory_async(self, local_dir: str, remote_path: str = "/") -> dict:
+        """上传整个目录到沙箱（异步版本）"""
+        local_path = Path(local_dir)
+        if not local_path.exists():
+            raise FileNotFoundError(f"本地目录不存在: {local_dir}")
+
+        if not local_path.is_dir():
+            raise NotADirectoryError(f"路径不是目录: {local_dir}")
+
+        SYLogger.info(f"[Sandbox] _upload_directory_async 开始: {local_dir} -> {remote_path}")
+
+        exclude_patterns = [".git", "__pycache__", ".pyc", ".DS_Store", "node_modules"]
+
+        def should_exclude(name: str) -> bool:
+            for pattern in exclude_patterns:
+                if pattern.startswith("*"):
+                    if name.endswith(pattern[1:]):
+                        return True
+                elif name == pattern:
+                    return True
+            return False
+
+        files_to_upload = []
+
+        for root, dirs, files in os.walk(local_path):
+            dirs[:] = [d for d in dirs if not should_exclude(d)]
+
+            for file in files:
+                if should_exclude(file):
+                    continue
+
+                local_file = Path(root) / file
+                relative_path = local_file.relative_to(local_path)
+                sandbox_path = str(Path(remote_path) / relative_path)
+                files_to_upload.append((sandbox_path, local_file))
+
+        SYLogger.info(f"[Sandbox] 准备上传 {len(files_to_upload)} 个文件到沙箱")
+
+        success_count = 0
+        failed_count = 0
+        errors = []
+
+        for idx, (sandbox_path, local_file) in enumerate(files_to_upload):
+            try:
+                if idx % 10 == 0:
+                    SYLogger.info(f"[Sandbox] 上传进度: {idx}/{len(files_to_upload)}")
+
+                content = await asyncio.to_thread(lambda f=local_file: open(f, "rb").read())
+
+                result = await self._post_async(f"{SANDBOX_API_PREFIX}/upload", {
+                    "path": sandbox_path,
+                    "content": base64.b64encode(content).decode(),
+                    "user_id": self._user_id
+                })
+
+                if result.get("error"):
+                    failed_count += 1
+                    errors.append({"path": sandbox_path, "error": result["error"]})
+                else:
+                    success_count += 1
+
+            except Exception as e:
+                failed_count += 1
+                errors.append({"path": sandbox_path, "error": str(e)})
+
+        SYLogger.info(f"[Sandbox] _upload_directory_async 完成: 成功={success_count}, 失败={failed_count}")
+        return {"success": success_count, "failed": failed_count, "errors": errors}
 
     # ============== 后台进程执行 ==============
 
@@ -396,68 +622,46 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
             return {"process_id": None, "status": "error", "error": str(e)}
 
     async def aexecute_background(self, command: str, *, timeout: int = 600) -> dict:
-        """异步后台执行 shell 命令"""
-        return await asyncio.to_thread(self.execute_background, command, timeout=timeout)
-
-    def check_process(self, process_id: str) -> dict:
-        """检查后台进程状态
-
-        Args:
-            process_id: execute_background 返回的进程 ID
+        """异步后台执行 shell 命令（真正的异步实现）"""
+        await self._ensure_synced_async()
+        SYLogger.info(f"[Sandbox] 异步后台执行: {command}")
+        try:
+            result = await self._post_async_with_failover(f"{SANDBOX_API_PREFIX}/execute_background", {
+                "command": command,
+                "user_id": self._user_id,
+                "timeout": timeout
+            })
+            SYLogger.info(f"[Sandbox] 异步后台进程已启动: process_id={result['process_id']}")
+            return result
+        except Exception as e:
+            SYLogger.error(f"[Sandbox] 异步后台执行失败: {e}")
+            return {"process_id": None, "status": "error", "error": str(e)}
 
-        Returns:
-            dict: {
-                "process_id": str,
-                "status": "running" | "completed" | "timeout" | "error" | "not_found",
-                "exit_code": int | None,
-                "output": str | None,  # 仅在进程结束时返回
-                "truncated": bool,
-                "command": str | None,
-                "started_at": str | None
-            }
-        """
+    async def acheck_process(self, process_id: str) -> dict:
+        """异步检查后台进程状态（真正的异步实现）"""
         try:
-            result = self._post_sync(f"{SANDBOX_API_PREFIX}/process_status", {
+            result = await self._post_async_with_failover(f"{SANDBOX_API_PREFIX}/process_status", {
                 "process_id": process_id,
                 "user_id": self._user_id
             })
             return result
         except Exception as e:
-            SYLogger.error(f"[Sandbox] 检查进程失败: {e}")
+            SYLogger.error(f"[Sandbox] 异步检查进程失败: {e}")
             return {"process_id": process_id, "status": "error", "error": str(e)}
 
-    async def acheck_process(self, process_id: str) -> dict:
-        """异步检查后台进程状态"""
-        return await asyncio.to_thread(self.check_process, process_id)
-
-    def kill_process(self, process_id: str) -> dict:
-        """终止后台进程
-
-        Args:
-            process_id: execute_background 返回的进程 ID
-
-        Returns:
-            dict: {
-                "process_id": str,
-                "status": "killed" | "not_found" | "already_completed",
-                "output": str | None  # 进程截止到被杀死时的输出
-            }
-        """
+    async def akill_process(self, process_id: str) -> dict:
+        """异步终止后台进程（真正的异步实现）"""
         try:
-            result = self._post_sync(f"{SANDBOX_API_PREFIX}/kill_process", {
+            result = await self._post_async_with_failover(f"{SANDBOX_API_PREFIX}/kill_process", {
                 "process_id": process_id,
                 "user_id": self._user_id
             })
-            SYLogger.info(f"[Sandbox] 进程终止: {process_id}, status={result['status']}")
+            SYLogger.info(f"[Sandbox] 异步进程终止: {process_id}, status={result['status']}")
             return result
         except Exception as e:
-            SYLogger.error(f"[Sandbox] 终止进程失败: {e}")
+            SYLogger.error(f"[Sandbox] 异步终止进程失败: {e}")
             return {"process_id": process_id, "status": "error", "error": str(e)}
 
-    async def akill_process(self, process_id: str) -> dict:
-        """异步终止后台进程"""
-        return await asyncio.to_thread(self.kill_process, process_id)
-
     # ============== 批量操作 ==============
 
     def upload_files(self, files: List[tuple[str, bytes]]) -> List[FileUploadResponse]:
@@ -479,8 +683,22 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         return results
 
     async def aupload_files(self, files: List[tuple[str, bytes]]) -> List[FileUploadResponse]:
-        """异步上传多个文件"""
-        return await asyncio.to_thread(self.upload_files, files)
+        """异步上传多个文件（真正的异步实现）"""
+        results = []
+        for path, content in files:
+            try:
+                result = await self._post_async_with_failover(f"{SANDBOX_API_PREFIX}/upload", {
+                    "path": path,
+                    "content": base64.b64encode(content).decode(),
+                    "user_id": self._user_id
+                })
+                results.append(FileUploadResponse(
+                    path=result["path"],
+                    error=result.get("error")
+                ))
+            except Exception as e:
+                results.append(FileUploadResponse(path=path, error=str(e)))
+        return results
 
     def download_files(self, paths: List[str]) -> List[FileDownloadResponse]:
         """下载多个文件"""
@@ -504,8 +722,25 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         return results
 
     async def adownload_files(self, paths: List[str]) -> List[FileDownloadResponse]:
-        """异步下载多个文件"""
-        return await asyncio.to_thread(self.download_files, paths)
+        """异步下载多个文件（真正的异步实现）"""
+        results = []
+        for path in paths:
+            try:
+                result = await self._post_async_with_failover(
+                    f"{SANDBOX_API_PREFIX}/download",
+                    {"path": path, "user_id": self._user_id}
+                )
+                if result.get("error"):
+                    results.append(FileDownloadResponse(
+                        path=path,
+                        error=result["error"]
+                    ))
+                else:
+                    content = base64.b64decode(result["content"])
+                    results.append(FileDownloadResponse(path=path, content=content))
+            except Exception as e:
+                results.append(FileDownloadResponse(path=path, error=str(e)))
+        return results
 
     # ============== 目录同步 ==============
 
@@ -555,8 +790,8 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         return self._sync_sync()
 
     async def async_sync(self) -> dict:
-        """异步手动同步所有配置的目录到沙箱"""
-        return await asyncio.to_thread(self.sync)
+        """异步手动同步所有配置的目录到沙箱（真正的异步实现）"""
+        return await self._sync_async()
 
     def sync_dirs(self, dirs: List[tuple[str, str]]) -> dict:
         """同步指定的目录列表到沙箱