sycommon-python-lib 0.2.1a27__tar.gz → 0.2.1a29__tar.gz

{sycommon_python_lib-0.2.1a27 → sycommon_python_lib-0.2.1a29}/PKG-INFO

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

{sycommon_python_lib-0.2.1a27 → sycommon_python_lib-0.2.1a29}/pyproject.toml

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

{sycommon_python_lib-0.2.1a27 → sycommon_python_lib-0.2.1a29}/src/sycommon/agent/sandbox/http_sandbox_backend.py

@@ -342,6 +342,110 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         """异步执行 shell 命令"""
         return await asyncio.to_thread(self.execute, command, timeout=timeout)
 
+    # ============== 后台进程执行 ==============
+
+    def execute_background(self, command: str, *, timeout: int = 600) -> dict:
+        """后台执行 shell 命令（不阻塞，立即返回 process_id）
+
+        适用于长时间运行的服务（如 uvicorn、FastAPI 等）
+
+        Args:
+            command: 要执行的命令
+            timeout: 命令超时时间（秒），默认 600 秒
+
+        Returns:
+            dict: {"process_id": str, "status": "started"}
+
+        Example:
+            # 启动后台服务
+            result = backend.execute_background("uvicorn main:app --host 0.0.0.0 --port 8000")
+            process_id = result["process_id"]
+
+            # 稍后检查状态
+            status = backend.check_process(process_id)
+            if status["status"] == "running":
+                print("服务正在运行...")
+
+            # 需要时终止进程
+            backend.kill_process(process_id)
+        """
+        self._ensure_synced_sync()
+        SYLogger.info(f"[Sandbox] 后台执行: {command}")
+        try:
+            result = self._post_sync(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)}
+
+    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
+
+        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
+            }
+        """
+        try:
+            result = self._post_sync(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}")
+            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  # 进程截止到被杀死时的输出
+            }
+        """
+        try:
+            result = self._post_sync(f"{SANDBOX_API_PREFIX}/kill_process", {
+                "process_id": process_id,
+                "user_id": self._user_id
+            })
+            SYLogger.info(f"[Sandbox] 进程终止: {process_id}, status={result['status']}")
+            return result
+        except Exception as 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]:
@@ -596,21 +700,38 @@ class HTTPSandboxBackend(FileOperationsMixin, SandboxBackendProtocol):
         """异步重置沙箱环境"""
         return await asyncio.to_thread(self.reset)
 
-    def health_check(self) -> dict:
-        """健康检查"""
+    def health_check(self, timeout: int = 10) -> dict:
+        """健康检查（快速检查，默认10秒超时）"""
         trace_id = SYLogger.get_trace_id()
         headers = {}
         if trace_id:
             headers["x-traceid-header"] = str(trace_id)
 
-        resp = requests.get(
-            f"{self._base_url}{SANDBOX_API_PREFIX}/health",
-            headers=headers if headers else None,
-            timeout=30
-        )
-        resp.raise_for_status()
-        return resp.json()
+        url = f"{self._base_url}{SANDBOX_API_PREFIX}/health"
+        SYLogger.info(f"[Sandbox] 健康检查: {url}, timeout={timeout}s")
+        try:
+            resp = requests.get(
+                url,
+                headers=headers if headers else None,
+                timeout=timeout
+            )
+            resp.raise_for_status()
+            result = resp.json()
+            SYLogger.info(f"[Sandbox] 健康检查成功: {result}")
+            return result
+        except Exception as e:
+            SYLogger.error(f"[Sandbox] 健康检查失败: {e}")
+            raise
 
     async def ahealth_check(self) -> dict:
         """异步健康检查"""
         return await asyncio.to_thread(self.health_check)
+
+    def check_available(self, timeout: int = 5) -> bool:
+        """快速检查沙箱是否可用（5秒超时）"""
+        try:
+            self.health_check(timeout=timeout)
+            return True
+        except Exception as e:
+            SYLogger.warning(f"[Sandbox] 沙箱不可用: {e}")
+            return False

{sycommon_python_lib-0.2.1a27 → sycommon_python_lib-0.2.1a29}/src/sycommon/middleware/sandbox.py

@@ -26,12 +26,34 @@ import base64
 import shutil
 import tempfile
 import platform
+import uuid
+import threading
 from datetime import datetime
 from fastapi import FastAPI, APIRouter, Request, Header
-from typing import Optional
+from typing import Dict
 
-from pydantic import BaseModel
 from sycommon.logging.kafka_log import SYLogger
+from sycommon.models.sandbox import (
+    ExecuteRequest, ExecuteResponse,
+    UploadRequest, UploadResponse,
+    DownloadRequest, DownloadResponse,
+    FileInfo, LsRequest, LsResponse,
+    GlobRequest, GrepRequest, GrepMatch,
+    ReadRequest, ReadResponse,
+    WriteRequest, WriteResponse,
+    EditRequest, EditResponse,
+    HealthResponse, ResetRequest, ResetResponse,
+    ExecuteBackgroundRequest, ExecuteBackgroundResponse,
+    ProcessStatusRequest, ProcessStatusResponse,
+    KillProcessRequest, KillProcessResponse,
+)
+
+
+# ============== 后台进程管理 ==============
+
+# 进程存储: process_id -> {process: Popen, command: str, user_id: str, started_at: datetime, workspace: str}
+_background_processes: Dict[str, dict] = {}
+_process_lock = threading.Lock()
 
 
 # ============== 常量配置 ==============
@@ -100,150 +122,6 @@ def resolve_sandbox_path(path: str, workspace: str) -> str:
     return resolved
 
 
-# ============== 请求/响应模型 ==============
-
-class ExecuteRequest(BaseModel):
-    """执行命令请求"""
-    command: str
-    user_id: str  # 用户ID，用于隔离工作目录
-    timeout: Optional[int] = 120  # 默认超时 120 秒
-
-
-class ExecuteResponse(BaseModel):
-    """执行命令响应"""
-    output: str
-    exit_code: int
-    truncated: bool = False
-
-
-class UploadRequest(BaseModel):
-    """上传文件请求"""
-    path: str
-    content: str  # base64 encoded
-    user_id: str
-
-
-class UploadResponse(BaseModel):
-    """上传文件响应"""
-    path: str
-    error: Optional[str] = None
-
-
-class DownloadRequest(BaseModel):
-    """下载文件请求"""
-    path: str
-    user_id: str
-
-
-class DownloadResponse(BaseModel):
-    """下载文件响应"""
-    path: str
-    content: Optional[str] = None  # base64 encoded
-    error: Optional[str] = None
-
-
-class FileInfo(BaseModel):
-    """文件信息"""
-    path: str
-    is_dir: Optional[bool] = None
-    size: Optional[int] = None
-    modified_at: Optional[str] = None
-
-
-class LsRequest(BaseModel):
-    """列出目录请求"""
-    path: str
-    user_id: str
-
-
-class LsResponse(BaseModel):
-    """列出目录响应"""
-    files: list[FileInfo] = []
-    error: Optional[str] = None
-
-
-class GlobRequest(BaseModel):
-    """glob 搜索请求"""
-    pattern: str
-    path: str = "/"
-    user_id: str
-
-
-class GrepRequest(BaseModel):
-    """grep 搜索请求"""
-    pattern: str
-    user_id: str
-    path: Optional[str] = None
-    glob: Optional[str] = None
-
-
-class GrepMatch(BaseModel):
-    """grep 匹配结果"""
-    path: str
-    line: int
-    text: str
-
-
-class ReadRequest(BaseModel):
-    """读取文件请求"""
-    file_path: str
-    user_id: str
-    offset: int = 0
-    limit: int = 2000
-
-
-class ReadResponse(BaseModel):
-    """读取文件响应"""
-    content: Optional[str] = None
-    error: Optional[str] = None
-
-
-class WriteRequest(BaseModel):
-    """写入文件请求"""
-    file_path: str
-    content: str  # base64 encoded
-    user_id: str
-
-
-class WriteResponse(BaseModel):
-    """写入文件响应"""
-    error: Optional[str] = None
-    path: Optional[str] = None
-
-
-class EditRequest(BaseModel):
-    """编辑文件请求"""
-    file_path: str
-    old_string: str  # base64 encoded
-    new_string: str  # base64 encoded
-    user_id: str
-    replace_all: bool = False
-
-
-class EditResponse(BaseModel):
-    """编辑文件响应"""
-    error: Optional[str] = None
-    path: Optional[str] = None
-    occurrences: Optional[int] = None
-
-
-class HealthResponse(BaseModel):
-    """健康检查响应"""
-    status: str
-    workspace: str
-
-
-class ResetRequest(BaseModel):
-    """重置请求"""
-    user_id: str
-
-
-class ResetResponse(BaseModel):
-    """重置响应"""
-    status: str
-    path: str
-
-
 def setup_sandbox_handler(app: FastAPI, config: dict = None):
     """
     沙箱服务初始化
@@ -448,6 +326,251 @@ COMMAND_EOF
                 truncated=False
             )
 
+    @sandbox_router.post("/execute_background", response_model=ExecuteBackgroundResponse)
+    async def execute_background(req: ExecuteBackgroundRequest):
+        """后台执行 shell 命令（不阻塞，立即返回 process_id）"""
+        workspace = get_user_workspace(req.user_id)
+
+        if not req.command:
+            raise ValueError("Command must be a non-empty string.")
+
+        process_id = str(uuid.uuid4())[:8]
+        SYLogger.info(f"[Sandbox Server] 后台执行命令: {req.command} (user={req.user_id}, process_id={process_id})")
+
+        # 创建常用目录
+        for subdir in ["tmp", "output", "skills", "memory", "data"]:
+            os.makedirs(os.path.join(workspace, subdir), exist_ok=True)
+
+        # 使用与 execute 相同的 shell 初始化脚本
+        init_script = f'''
+# 沙箱环境初始化
+export SANDBOX_ROOT="{workspace}"
+export _SANDBOX_WORKSPACE="{workspace}"
+
+sandbox_path() {{
+    local path="$1"
+    if [[ "$path" == "$_SANDBOX_WORKSPACE"* ]]; then
+        echo "$path"
+        return
+    fi
+    if [[ "$path" == /* ]]; then
+        path="${{path#/}}"
+        echo "$_SANDBOX_WORKSPACE/$path"
+    else
+        echo "$path"
+    fi
+}}
+
+cd() {{
+    local target="$1"
+    if [[ -z "$target" ]]; then
+        command cd "$_SANDBOX_WORKSPACE"
+    elif [[ "$target" == "$_SANDBOX_WORKSPACE"* ]]; then
+        command cd "$target"
+    elif [[ "$target" == /* ]]; then
+        local mapped="$_SANDBOX_WORKSPACE/${{target#/}}"
+        command cd "$mapped"
+    else
+        command cd "$target"
+    fi
+}}
+
+mkdir() {{
+    local args=("$@")
+    local new_args=()
+    for arg in "${{args[@]}}"; do
+        if [[ "$arg" == "$_SANDBOX_WORKSPACE"* ]]; then
+            new_args+=("$arg")
+        elif [[ "$arg" == /* ]]; then
+            new_args+=("$_SANDBOX_WORKSPACE/${{arg#/}}")
+        else
+            new_args+=("$arg")
+        fi
+    done
+    command mkdir "${{new_args[@]}}"
+}}
+
+cd "$_SANDBOX_WORKSPACE"
+'''
+
+        full_command = f'''bash <<'COMMAND_EOF'
+{init_script}
+{req.command}
+COMMAND_EOF
+'''
+
+        env = os.environ.copy()
+        env["TMPDIR"] = os.path.join(workspace, "tmp")
+        env["TEMP"] = os.path.join(workspace, "tmp")
+        env["TMP"] = os.path.join(workspace, "tmp")
+        env["SANDBOX_ROOT"] = workspace
+
+        try:
+            process = subprocess.Popen(
+                full_command,
+                shell=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                cwd=workspace,
+                env=env
+            )
+
+            with _process_lock:
+                _background_processes[process_id] = {
+                    "process": process,
+                    "command": req.command,
+                    "user_id": req.user_id,
+                    "started_at": datetime.now(),
+                    "workspace": workspace,
+                    "timeout": req.timeout,
+                    "output_buffer": "",
+                    "completed": False,
+                    "killed": False
+                }
+
+            # 启动后台线程监控进程
+            def monitor_process():
+                try:
+                    stdout, stderr = process.communicate(timeout=req.timeout)
+                except subprocess.TimeoutExpired:
+                    process.kill()
+                    stdout, stderr = process.communicate()
+                    with _process_lock:
+                        if process_id in _background_processes:
+                            _background_processes[process_id]["killed"] = True
+                            _background_processes[process_id]["output_buffer"] = f"Error: Command timed out after {req.timeout} seconds.\nPartial output:\n{stdout}"
+                except Exception as e:
+                    with _process_lock:
+                        if process_id in _background_processes:
+                            _background_processes[process_id]["output_buffer"] = f"Error: {type(e).__name__}: {e}"
+                    return
+
+                output_parts = []
+                if stdout:
+                    output_parts.append(stdout)
+                if stderr:
+                    stderr_lines = stderr.strip().split("\n")
+                    output_parts.extend(f"[stderr] {line}" for line in stderr_lines)
+
+                output = "\n".join(output_parts) if output_parts else "<no output>"
+
+                if len(output) > MAX_OUTPUT_BYTES:
+                    output = output[:MAX_OUTPUT_BYTES] + f"\n\n... Output truncated at {MAX_OUTPUT_BYTES} bytes."
+
+                exit_code = process.returncode
+                if exit_code != 0:
+                    output = f"{output.rstrip()}\n\nExit code: {exit_code}"
+
+                with _process_lock:
+                    if process_id in _background_processes:
+                        _background_processes[process_id]["output_buffer"] = output
+                        _background_processes[process_id]["exit_code"] = exit_code
+                        _background_processes[process_id]["completed"] = True
+
+            monitor_thread = threading.Thread(target=monitor_process, daemon=True)
+            monitor_thread.start()
+
+            return ExecuteBackgroundResponse(process_id=process_id, status="started")
+
+        except Exception as e:
+            SYLogger.error(f"[Sandbox Server] 后台执行异常: {e}")
+            raise RuntimeError(f"Failed to start background process: {e}")
+
+    @sandbox_router.post("/process_status", response_model=ProcessStatusResponse)
+    async def get_process_status(req: ProcessStatusRequest):
+        """查询后台进程状态"""
+        with _process_lock:
+            proc_info = _background_processes.get(req.process_id)
+
+            if not proc_info:
+                return ProcessStatusResponse(
+                    process_id=req.process_id,
+                    status="not_found"
+                )
+
+            # 检查用户权限
+            if proc_info["user_id"] != req.user_id:
+                return ProcessStatusResponse(
+                    process_id=req.process_id,
+                    status="not_found"
+                )
+
+            process = proc_info["process"]
+
+            # 判断进程状态
+            if proc_info["killed"]:
+                status = "timeout"
+            elif proc_info["completed"]:
+                status = "completed"
+            elif process.poll() is not None:
+                # 进程已结束但还没被监控线程处理（极少情况）
+                status = "completed"
+            else:
+                status = "running"
+
+            return ProcessStatusResponse(
+                process_id=req.process_id,
+                status=status,
+                exit_code=proc_info.get("exit_code"),
+                output=proc_info.get("output_buffer") if proc_info["completed"] or proc_info["killed"] else None,
+                truncated=len(proc_info.get("output_buffer", "")) >= MAX_OUTPUT_BYTES if proc_info.get("output_buffer") else False,
+                command=proc_info["command"],
+                started_at=proc_info["started_at"].isoformat()
+            )
+
+    @sandbox_router.post("/kill_process", response_model=KillProcessResponse)
+    async def kill_process(req: KillProcessRequest):
+        """终止后台进程"""
+        with _process_lock:
+            proc_info = _background_processes.get(req.process_id)
+
+            if not proc_info:
+                return KillProcessResponse(
+                    process_id=req.process_id,
+                    status="not_found"
+                )
+
+            # 检查用户权限
+            if proc_info["user_id"] != req.user_id:
+                return KillProcessResponse(
+                    process_id=req.process_id,
+                    status="not_found"
+                )
+
+            if proc_info["completed"] or proc_info["killed"]:
+                return KillProcessResponse(
+                    process_id=req.process_id,
+                    status="already_completed",
+                    output=proc_info.get("output_buffer")
+                )
+
+            process = proc_info["process"]
+            try:
+                process.kill()
+                # 等待进程结束
+                process.wait(timeout=5)
+            except Exception as e:
+                SYLogger.warning(f"[Sandbox Server] 终止进程时出错: {e}")
+
+            # 获取当前输出（如果有）
+            current_output = proc_info.get("output_buffer", "")
+            proc_info["killed"] = True
+            proc_info["completed"] = True
+            proc_info["exit_code"] = process.returncode if process.returncode is not None else -9
+
+            if not current_output:
+                current_output = f"Process killed by user request. Exit code: {proc_info['exit_code']}"
+            proc_info["output_buffer"] = current_output
+
+            SYLogger.info(f"[Sandbox Server] 进程已终止: {req.process_id}")
+
+            return KillProcessResponse(
+                process_id=req.process_id,
+                status="killed",
+                output=current_output
+            )
+
     @sandbox_router.post("/ls", response_model=list[FileInfo])
     async def ls_info(req: LsRequest):
         """列出目录内容"""