sycommon-python-lib 0.2.1a38__tar.gz → 0.2.1a39__tar.gz

{sycommon_python_lib-0.2.1a38 → sycommon_python_lib-0.2.1a39}/PKG-INFO

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

{sycommon_python_lib-0.2.1a38 → sycommon_python_lib-0.2.1a39}/pyproject.toml

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

{sycommon_python_lib-0.2.1a38 → sycommon_python_lib-0.2.1a39}/src/sycommon/middleware/sandbox.py

@@ -21,13 +21,14 @@
 """
 
 import os
-import subprocess
+import asyncio
 import base64
 import shutil
 import tempfile
 import platform
 import uuid
 import threading
+import shlex
 from datetime import datetime
 from fastapi import FastAPI, APIRouter, Request, Header
 from typing import Dict
@@ -55,6 +56,26 @@ from sycommon.models.sandbox import (
 _background_processes: Dict[str, dict] = {}
 _process_lock = threading.Lock()
 
+# 进程清理配置
+PROCESS_CLEANUP_TTL = 300  # 已完成进程保留时间（秒）
+PROCESS_CLEANUP_INTERVAL = 60  # 清理检查间隔（秒）
+_cleanup_task = None
+
+
+async def _cleanup_finished_processes():
+    """异步清理已完成的过期进程"""
+    while True:
+        await asyncio.sleep(PROCESS_CLEANUP_INTERVAL)
+        now = datetime.now().timestamp()
+        with _process_lock:
+            expired = [
+                k for k, v in _background_processes.items()
+                if v.get("completed") and now - v.get("completed_at", 0) > PROCESS_CLEANUP_TTL
+            ]
+            for k in expired:
+                _background_processes.pop(k, None)
+                SYLogger.debug(f"[Sandbox Server] 清理过期进程: {k}")
+
 
 # ============== 常量配置 ==============
 
@@ -70,7 +91,6 @@ if platform.system() == "Linux":
         os.makedirs(_default_workspace, exist_ok=True)
     except PermissionError:
         # 降级到临时目录
-        import tempfile
         _default_workspace = os.path.join(tempfile.gettempdir(), "sycommon_sandbox")
 else:
     # macOS / Windows 使用临时目录
@@ -150,6 +170,13 @@ def setup_sandbox_handler(app: FastAPI, config: dict = None):
 
     initialized = False
 
+    # 启动后台清理任务（在 FastAPI startup event 中启动）
+    @app.on_event("startup")
+    async def start_cleanup_task():
+        global _cleanup_task
+        if _cleanup_task is None:
+            _cleanup_task = asyncio.create_task(_cleanup_finished_processes())
+
     @app.middleware("http")
     async def sandbox_middleware(request: Request, call_next):
         nonlocal initialized
@@ -189,10 +216,12 @@ def setup_sandbox_handler(app: FastAPI, config: dict = None):
         # 创建 shell 初始化脚本，设置路径映射
         # 让绝对路径自动映射到 workspace 下
         # 使用 heredoc 避免命令中的特殊字符（如正则表达式）被 shell 错误解析
+        # 对 workspace 路径进行 shell 转义，防止路径中包含特殊字符（如单引号）导致语法错误
+        safe_workspace = shlex.quote(workspace)
         init_script = f'''
 # 沙箱环境初始化
-export SANDBOX_ROOT="{workspace}"
-export _SANDBOX_WORKSPACE="{workspace}"
+export SANDBOX_ROOT={safe_workspace}
+export _SANDBOX_WORKSPACE={safe_workspace}
 
 # 路径映射函数：将绝对路径映射到沙箱内（如果尚未在沙箱内）
 sandbox_path() {{
@@ -267,23 +296,29 @@ COMMAND_EOF
         env["SANDBOX_ROOT"] = workspace
 
         try:
-            # 使用 Popen 以便超时时能正确终止进程
-            process = subprocess.Popen(
+            # 使用 asyncio.create_subprocess_shell 异步执行命令，避免阻塞事件循环
+            process = await asyncio.create_subprocess_shell(
                 full_command,
-                shell=True,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                text=True,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
                 cwd=workspace,
                 env=env
             )
 
             try:
-                stdout, stderr = process.communicate(timeout=req.timeout)
-            except subprocess.TimeoutExpired:
+                stdout, stderr = await asyncio.wait_for(
+                    process.communicate(),
+                    timeout=req.timeout
+                )
+                # decode bytes to string
+                stdout = stdout.decode('utf-8') if stdout else ''
+                stderr = stderr.decode('utf-8') if stderr else ''
+            except asyncio.TimeoutError:
                 # 超时时终止进程
                 process.kill()
-                stdout, stderr = process.communicate()
+                stdout, stderr = await process.communicate()
+                stdout = stdout.decode('utf-8') if stdout else ''
+                stderr = stderr.decode('utf-8') if stderr else ''
                 SYLogger.error(f"[Sandbox Server] 执行超时: {req.timeout}s")
                 return ExecuteResponse(
                     output=f"Error: Command timed out after {req.timeout} seconds.\nPartial output:\n{stdout}",
@@ -334,7 +369,7 @@ COMMAND_EOF
         if not req.command:
             raise ValueError("Command must be a non-empty string.")
 
-        process_id = str(uuid.uuid4())[:8]
+        process_id = str(uuid.uuid4()).replace('-', '')[:16]
         SYLogger.info(f"[Sandbox Server] 后台执行命令: {req.command} (user={req.user_id}, process_id={process_id})")
 
         # 创建常用目录
@@ -342,10 +377,12 @@ COMMAND_EOF
             os.makedirs(os.path.join(workspace, subdir), exist_ok=True)
 
         # 使用与 execute 相同的 shell 初始化脚本
+        # 对 workspace 路径进行 shell 转义
+        safe_workspace = shlex.quote(workspace)
         init_script = f'''
 # 沙箱环境初始化
-export SANDBOX_ROOT="{workspace}"
-export _SANDBOX_WORKSPACE="{workspace}"
+export SANDBOX_ROOT={safe_workspace}
+export _SANDBOX_WORKSPACE={safe_workspace}
 
 sandbox_path() {{
     local path="$1"
@@ -406,12 +443,11 @@ COMMAND_EOF
         env["SANDBOX_ROOT"] = workspace
 
         try:
-            process = subprocess.Popen(
+            # 使用 asyncio.create_subprocess_shell 异步执行命令
+            process = await asyncio.create_subprocess_shell(
                 full_command,
-                shell=True,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
-                text=True,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
                 cwd=workspace,
                 env=env
             )
@@ -429,17 +465,25 @@ COMMAND_EOF
                     "killed": False
                 }
 
-            # 启动后台线程监控进程
-            def monitor_process():
+            # 启动后台异步任务监控进程
+            async def monitor_process():
                 try:
-                    stdout, stderr = process.communicate(timeout=req.timeout)
-                except subprocess.TimeoutExpired:
+                    stdout, stderr = await asyncio.wait_for(
+                        process.communicate(),
+                        timeout=req.timeout
+                    )
+                    stdout = stdout.decode('utf-8') if stdout else ''
+                    stderr = stderr.decode('utf-8') if stderr else ''
+                except asyncio.TimeoutError:
                     process.kill()
-                    stdout, stderr = process.communicate()
+                    stdout, stderr = await process.communicate()
+                    stdout = stdout.decode('utf-8') if stdout else ''
+                    stderr = stderr.decode('utf-8') if stderr else ''
                     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}"
+                    return
                 except Exception as e:
                     with _process_lock:
                         if process_id in _background_processes:
@@ -467,9 +511,10 @@ COMMAND_EOF
                         _background_processes[process_id]["output_buffer"] = output
                         _background_processes[process_id]["exit_code"] = exit_code
                         _background_processes[process_id]["completed"] = True
+                        _background_processes[process_id]["completed_at"] = datetime.now().timestamp()
 
-            monitor_thread = threading.Thread(target=monitor_process, daemon=True)
-            monitor_thread.start()
+            # 创建后台异步任务
+            asyncio.create_task(monitor_process())
 
             return ExecuteBackgroundResponse(process_id=process_id, status="started")
 
@@ -498,13 +543,13 @@ COMMAND_EOF
 
             process = proc_info["process"]
 
-            # 判断进程状态
+            # 判断进程状态（asyncio subprocess 使用 returncode 而非 poll）
             if proc_info["killed"]:
                 status = "timeout"
             elif proc_info["completed"]:
                 status = "completed"
-            elif process.poll() is not None:
-                # 进程已结束但还没被监控线程处理（极少情况）
+            elif process.returncode is not None:
+                # 进程已结束但还没被监控任务处理（极少情况）
                 status = "completed"
             else:
                 status = "running"
@@ -548,8 +593,7 @@ COMMAND_EOF
             process = proc_info["process"]
             try:
                 process.kill()
-                # 等待进程结束
-                process.wait(timeout=5)
+                # asyncio subprocess 没有 wait(timeout)，直接检查 returncode
             except Exception as e:
                 SYLogger.warning(f"[Sandbox Server] 终止进程时出错: {e}")
 
@@ -633,23 +677,23 @@ COMMAND_EOF
         SYLogger.info(f"[Sandbox Server] 读取文件: {file_path} (offset={req.offset}, limit={req.limit})")
 
         try:
+            output = []
+            lines_read = 0
             with open(file_path, 'r') as f:
-                lines = f.readlines()
-
-            if not lines:
+                for i, line in enumerate(f):
+                    if i < req.offset:
+                        continue
+                    if lines_read >= req.limit:
+                        break
+                    line_num = i + 1
+                    output.append(f"{line_num:6d}\t{line.rstrip()}")
+                    lines_read += 1
+
+            if not output:
                 return ReadResponse(content="System reminder: File exists but has empty contents", error=None)
 
-            start = req.offset
-            end = req.offset + req.limit
-            selected = lines[start:end]
-
-            output = []
-            for i, line in enumerate(selected):
-                line_num = req.offset + i + 1
-                output.append(f"{line_num:6d}\t{line.rstrip()}")
-
             content = "\n".join(output)
-            SYLogger.info(f"[Sandbox Server] 读取完成: {len(selected)} 行")
+            SYLogger.info(f"[Sandbox Server] 读取完成: {lines_read} 行")
             return ReadResponse(content=content, error=None)
 
         except Exception as e:
@@ -819,8 +863,6 @@ COMMAND_EOF
     @sandbox_router.post("/grep", response_model=list[GrepMatch])
     async def grep_search(req: GrepRequest):
         """grep 搜索内容"""
-        import shlex
-
         workspace = get_user_workspace(req.user_id)
         try:
             search_path = resolve_sandbox_path(req.path or "/", workspace)
@@ -831,24 +873,47 @@ COMMAND_EOF
         quoted_path = shlex.quote(search_path)
         grep_opts = "-rHnF"
 
-        glob_pattern = f"--include='{req.glob}'" if req.glob else ""
+        # 安全处理 glob_pattern，使用 shlex.quote 防止命令注入
+        glob_pattern = f"--include={shlex.quote(req.glob)}" if req.glob else ""
         pattern_escaped = shlex.quote(req.pattern)
 
         cmd = f"grep {grep_opts} {glob_pattern} -e {pattern_escaped} {quoted_path} 2>/dev/null || true"
 
-        result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
+        # 使用 asyncio.create_subprocess_shell 异步执行
+        proc = await asyncio.create_subprocess_shell(
+            cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE
+        )
+        stdout, _ = await proc.communicate()
+        result_text = stdout.decode('utf-8') if stdout else ''
 
         matches = []
-        for line in result.stdout.strip().split("\n"):
+        for line in result_text.strip().split("\n"):
             if not line:
                 continue
-            parts = line.split(":", 2)
-            if len(parts) >= 3:
-                matches.append(GrepMatch(
-                    path=parts[0],
-                    line=int(parts[1]),
-                    text=parts[2]
-                ))
+            # 使用更稳健的解析方式：找到第一个冒号（行号前）和第二个冒号（内容前）
+            # 先获取行号和内容部分（路径:path:line:text）
+            # 格式: path:line:text（text 可能包含冒号）
+            first_colon = line.find(":")
+            if first_colon == -1:
+                continue
+            second_colon = line.find(":", first_colon + 1)
+            if second_colon == -1:
+                continue
+
+            path_part = line[:first_colon]
+            try:
+                line_num = int(line[first_colon + 1:second_colon])
+            except ValueError:
+                continue
+            text_part = line[second_colon + 1:]
+
+            matches.append(GrepMatch(
+                path=path_part,
+                line=line_num,
+                text=text_part
+            ))
 
         return matches
 
@@ -867,7 +932,12 @@ COMMAND_EOF
         if not os.path.isdir(target_path):
             return LsResponse(error="not_a_directory")
 
+        # 递归遍历深度和文件数量限制
+        MAX_WALK_DEPTH = 10
+        MAX_FILES = 10000
+
         files = []
+        file_count = 0
         try:
             for item in os.listdir(target_path):
                 item_path = os.path.join(target_path, item)
@@ -882,11 +952,24 @@ COMMAND_EOF
                 except Exception:
                     pass
                 files.append(info)
+                file_count += 1
+
+                if file_count >= MAX_FILES:
+                    return LsResponse(files=files, warning=f"Results truncated at {MAX_FILES} files")
 
                 # 递归获取子目录文件
                 if info.is_dir:
                     for root, dirs, filenames in os.walk(item_path):
+                        # 限制深度
+                        depth = root[len(item_path):].count(os.sep)
+                        if depth >= MAX_WALK_DEPTH:
+                            dirs.clear()  # 不再递归更深层
+                            continue
+
                         for filename in filenames:
+                            if file_count >= MAX_FILES:
+                                return LsResponse(files=files, warning=f"Results truncated at {MAX_FILES} files")
+
                             filepath = os.path.join(root, filename)
                             file_info = FileInfo(path=filepath)
                             try:
@@ -898,6 +981,7 @@ COMMAND_EOF
                             except Exception:
                                 pass
                             files.append(file_info)
+                            file_count += 1
         except Exception as e:
             return LsResponse(error=str(e))
 

{sycommon_python_lib-0.2.1a38 → sycommon_python_lib-0.2.1a39}/src/sycommon/models/sandbox.py

@@ -70,6 +70,7 @@ class LsResponse(BaseModel):
     """列出目录响应"""
     files: list[FileInfo] = []
     error: Optional[str] = None
+    warning: Optional[str] = None  # 用于截断警告
 
 
 class GlobRequest(BaseModel):

{sycommon_python_lib-0.2.1a38 → sycommon_python_lib-0.2.1a39}/src/sycommon_python_lib.egg-info/PKG-INFO

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