roblox-studio-physical-operation-mcp 0.1.0__tar.gz → 0.1.1__tar.gz

{roblox_studio_physical_operation_mcp-0.1.0 → roblox_studio_physical_operation_mcp-0.1.1}/.gitignore

@@ -4,12 +4,14 @@ __pycache__/
 *.pyo
 
 *.rbxl.lock
-*.png
 dist/
+
 # Test outputs
 tests/capture_test_output/
 tests/screenshots/
 screenshots/
+*.png
+!roblox_studio_physical_operation_mcp/templates/*.png
 
 # Lock files
 *.lock

{roblox_studio_physical_operation_mcp-0.1.0 → roblox_studio_physical_operation_mcp-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: roblox-studio-physical-operation-mcp
-Version: 0.1.0
+Version: 0.1.1
 Summary: MCP server for controlling Roblox Studio - toolbar detection, game control, log analysis
 Project-URL: Homepage, https://github.com/white-dragon-tools/roblox-studio-physical-operation-mcp
 Project-URL: Repository, https://github.com/white-dragon-tools/roblox-studio-physical-operation-mcp

{roblox_studio_physical_operation_mcp-0.1.0 → roblox_studio_physical_operation_mcp-0.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "roblox-studio-physical-operation-mcp"
-version = "0.1.0"
+version = "0.1.1"
 description = "MCP server for controlling Roblox Studio - toolbar detection, game control, log analysis"
 readme = "README.md"
 license = "MIT"

{roblox_studio_physical_operation_mcp-0.1.0 → roblox_studio_physical_operation_mcp-0.1.1}/roblox_studio_physical_operation_mcp/log_utils.py

@@ -1,467 +1,467 @@
-"""
-日志工具模块: 日志读取、搜索等
-
-优化:
-- 从文件末尾倒序读取，适合大文件
-- 支持过滤特定类别 (如 FLog::Output)
-"""
-
-import os
-import re
-from typing import Optional, Generator
-from dataclasses import dataclass
-
-LOG_DIR = os.path.expandvars(r"%LOCALAPPDATA%\Roblox\logs")
-
-# 默认只读取这些类别的日志
-DEFAULT_CATEGORIES = ["FLog::Output"]
-
-
-@dataclass
-class LogEntry:
-    timestamp: str
-    level: str
-    category: str
-    message: str
-    raw: str
-
-
-def parse_log_line(line: str) -> Optional[LogEntry]:
-    """解析单行日志"""
-    # 格式: 2026-02-03T08:52:02.095Z,128.095795,1996c,12 [DFLog::HttpTraceError] message
-    # 或: 2026-02-03T08:52:04.244Z,130.244095,12f4,6,Info [FLog::...] message
-    match = re.match(
-        r'^(\d{4}-\d{2}-\d{2}T[\d:.]+Z),[\d.]+,[a-f0-9]+,\d+(?:,(\w+))?\s*\[([^\]]+)\]\s*(.*)$',
-        line
-    )
-    if match:
-        return LogEntry(
-            timestamp=match.group(1),
-            level=match.group(2) or "Info",
-            category=match.group(3),
-            message=match.group(4),
-            raw=line
-        )
-    return None
-
-
-def read_file_reverse(file_path: str, chunk_size: int = 8192) -> Generator[str, None, None]:
-    """
-    从文件末尾倒序读取行
-
-    对于大文件，这比读取整个文件再 reverse 更高效
-    """
-    with open(file_path, 'rb') as f:
-        # 移动到文件末尾
-        f.seek(0, 2)
-        file_size = f.tell()
-
-        buffer = b''
-        position = file_size
-
-        while position > 0:
-            # 计算读取位置
-            read_size = min(chunk_size, position)
-            position -= read_size
-            f.seek(position)
-
-            # 读取并拼接
-            chunk = f.read(read_size)
-            buffer = chunk + buffer
-
-            # 按行分割
-            lines = buffer.split(b'\n')
-
-            # 最后一个可能不完整，保留到下次
-            buffer = lines[0]
-
-            # 倒序返回完整的行
-            for line in reversed(lines[1:]):
-                line_str = line.decode('utf-8', errors='ignore').strip()
-                if line_str:
-                    yield line_str
-
-        # 处理剩余的 buffer
-        if buffer:
-            line_str = buffer.decode('utf-8', errors='ignore').strip()
-            if line_str:
-                yield line_str
-
-
-from .log_filter import should_exclude
-
-
-def get_logs_from_line(
-    log_path: str,
-    after_line: int = None,
-    before_line: int = None,
-    timestamps: bool = False,
-    categories: list[str] = None,
-    apply_filter: bool = True
-) -> dict:
-    """
-    从指定行范围读取日志
-    
-    Args:
-        log_path: 日志文件路径
-        after_line: 从哪一行之后开始读取，None 表示从头开始
-        before_line: 到哪一行之前结束，None 表示到末尾
-        timestamps: 是否附加时间戳
-        categories: 只返回这些类别的日志，默认 ["FLog::Output"]
-        apply_filter: 是否应用过滤规则排除 Studio 内部日志
-        
-    Returns:
-        {
-            "logs": "日志文本",
-            "start_line": 起始行号,
-            "last_line": 最后行号,
-            "remaining": 剩余有效日志行数,
-            "has_more": 是否还有更多
-        }
-    """
-    MAX_BYTES = 32000
-    
-    if not os.path.exists(log_path):
-        return {"logs": "", "start_line": 0, "last_line": 0, "remaining": 0, "has_more": False}
-    
-    if categories is None:
-        categories = DEFAULT_CATEGORIES
-    
-    start_line = None
-    last_line = 0
-    current_bytes = 0
-    log_lines = []
-    remaining = 0
-    bytes_exceeded = False
-    
-    try:
-        with open(log_path, 'r', encoding='utf-8', errors='ignore') as f:
-            for line_num, line in enumerate(f, 1):
-                # 跳过 after_line 之前的行
-                if after_line is not None and line_num <= after_line:
-                    continue
-                
-                # 停止在 before_line
-                if before_line is not None and line_num >= before_line:
-                    break
-                
-                line = line.strip()
-                if not line:
-                    continue
-                
-                entry = parse_log_line(line)
-                if not entry:
-                    continue
-                
-                # 类别过滤
-                if categories and entry.category not in categories:
-                    continue
-                
-                # 应用排除规则
-                if apply_filter and should_exclude(entry.message):
-                    continue
-                
-                # 这是一条有效日志
-                remaining += 1
-                
-                # 如果已超过字节限制，只统计不添加
-                if bytes_exceeded:
-                    continue
-                
-                # 格式化输出
-                if timestamps:
-                    time_part = entry.timestamp[11:19]
-                    output_line = f"[{time_part}] {entry.message}"
-                else:
-                    output_line = entry.message
-                
-                line_bytes = len(output_line.encode('utf-8')) + 1
-                
-                # 检查是否超过字节限制
-                if current_bytes + line_bytes > MAX_BYTES and log_lines:
-                    bytes_exceeded = True
-                    continue
-                
-                if start_line is None:
-                    start_line = line_num
-                
-                log_lines.append(output_line)
-                last_line = line_num
-                current_bytes += line_bytes
-                
-    except Exception:
-        pass
-    
-    returned_count = len(log_lines)
-    return {
-        "logs": "\n".join(log_lines),
-        "start_line": start_line or 0,
-        "last_line": last_line,
-        "remaining": remaining - returned_count,
-        "has_more": remaining > returned_count
-    }
-
-
-def get_recent_logs(
-    log_path: str,
-    limit: int = 100,
-    categories: list[str] = None,
-    min_level: Optional[str] = None,
-    apply_filter: bool = True
-) -> list[LogEntry]:
-    """
-    从日志文件末尾读取最近的日志
-
-    Args:
-        log_path: 日志文件路径
-        limit: 返回的最大条数
-        categories: 只返回这些类别的日志，默认 ["FLog::Output"]
-        min_level: 最低日志级别过滤
-        apply_filter: 是否应用过滤规则排除 Studio 内部日志，默认 True
-
-    Returns:
-        日志条目列表 (按时间正序)
-    """
-    if not os.path.exists(log_path):
-        return []
-
-    if categories is None:
-        categories = DEFAULT_CATEGORIES
-
-    entries = []
-    try:
-        for line in read_file_reverse(log_path):
-            entry = parse_log_line(line)
-            if not entry:
-                continue
-
-            # 类别过滤
-            if categories and entry.category not in categories:
-                continue
-
-            # 级别过滤
-            if min_level and entry.level.lower() != min_level.lower():
-                continue
-
-            # 应用排除规则
-            if apply_filter and should_exclude(entry.message):
-                continue
-
-            entries.append(entry)
-            if len(entries) >= limit:
-                break
-    except Exception:
-        pass
-
-    # 返回正序 (最旧的在前)
-    return list(reversed(entries))
-
-
-def get_all_logs(
-    log_path: str,
-    limit: int = 100,
-    min_level: Optional[str] = None
-) -> list[LogEntry]:
-    """
-    获取所有类别的日志 (不过滤类别)
-    """
-    return get_recent_logs(log_path, limit, categories=[], min_level=min_level)
-
-
-def search_logs(
-    log_path: str,
-    pattern: str,
-    limit: int = 50,
-    categories: list[str] = None
-) -> list[LogEntry]:
-    """
-    在日志中搜索匹配的条目
-
-    Args:
-        log_path: 日志文件路径
-        pattern: 正则表达式模式
-        limit: 返回的最大条数
-        categories: 只搜索这些类别，None 表示搜索所有
-    """
-    if not os.path.exists(log_path):
-        return []
-
-    entries = []
-    regex = re.compile(pattern, re.IGNORECASE)
-
-    try:
-        for line in read_file_reverse(log_path):
-            if not regex.search(line):
-                continue
-
-            entry = parse_log_line(line)
-            if not entry:
-                continue
-
-            if categories and entry.category not in categories:
-                continue
-
-            entries.append(entry)
-            if len(entries) >= limit:
-                break
-    except Exception:
-        pass
-
-    return list(reversed(entries))
-
-
-def search_logs_from_line(
-    log_path: str,
-    pattern: str,
-    after_line: int = None,
-    before_line: int = None,
-    timestamps: bool = False,
-    categories: list[str] = None,
-    apply_filter: bool = True
-) -> dict:
-    """
-    在指定行范围内搜索日志
-    
-    Args:
-        log_path: 日志文件路径
-        pattern: 正则表达式模式
-        after_line: 从哪一行之后开始搜索
-        before_line: 到哪一行之前结束
-        timestamps: 是否附加时间戳
-        categories: 只搜索这些类别，默认 ["FLog::Output"]
-        apply_filter: 是否应用过滤规则
-        
-    Returns:
-        {
-            "logs": "匹配的日志文本",
-            "start_line": 起始行号,
-            "last_line": 最后行号,
-            "match_count": 匹配条数,
-            "remaining": 剩余匹配数,
-            "has_more": 是否还有更多
-        }
-    """
-    MAX_BYTES = 32000
-    
-    if not os.path.exists(log_path):
-        return {"logs": "", "start_line": 0, "last_line": 0, "match_count": 0, "remaining": 0, "has_more": False}
-    
-    if categories is None:
-        categories = DEFAULT_CATEGORIES
-    
-    try:
-        regex = re.compile(pattern, re.IGNORECASE)
-    except re.error:
-        return {"error": f"Invalid regex pattern: {pattern}"}
-    
-    start_line = None
-    last_line = 0
-    current_bytes = 0
-    log_lines = []
-    match_count = 0
-    bytes_exceeded = False
-    
-    try:
-        with open(log_path, 'r', encoding='utf-8', errors='ignore') as f:
-            for line_num, line in enumerate(f, 1):
-                if after_line is not None and line_num <= after_line:
-                    continue
-                
-                if before_line is not None and line_num >= before_line:
-                    break
-                
-                line = line.strip()
-                if not line:
-                    continue
-                
-                entry = parse_log_line(line)
-                if not entry:
-                    continue
-                
-                if categories and entry.category not in categories:
-                    continue
-                
-                if apply_filter and should_exclude(entry.message):
-                    continue
-                
-                # 正则匹配
-                if not regex.search(entry.message):
-                    continue
-                
-                match_count += 1
-                
-                if bytes_exceeded:
-                    continue
-                
-                if timestamps:
-                    time_part = entry.timestamp[11:19]
-                    output_line = f"{line_num}|[{time_part}] {entry.message}"
-                else:
-                    output_line = f"{line_num}|{entry.message}"
-                
-                line_bytes = len(output_line.encode('utf-8')) + 1
-                
-                if current_bytes + line_bytes > MAX_BYTES and log_lines:
-                    bytes_exceeded = True
-                    continue
-                
-                if start_line is None:
-                    start_line = line_num
-                
-                log_lines.append(output_line)
-                last_line = line_num
-                current_bytes += line_bytes
-                
-    except Exception:
-        pass
-    
-    returned_count = len(log_lines)
-    return {
-        "logs": "\n".join(log_lines),
-        "start_line": start_line or 0,
-        "last_line": last_line,
-        "match_count": returned_count,
-        "remaining": match_count - returned_count,
-        "has_more": match_count > returned_count
-    }
-
-
-def find_latest_studio_log() -> Optional[str]:
-    """查找最新的 Studio 日志文件"""
-    if not os.path.exists(LOG_DIR):
-        return None
-
-    studio_logs = []
-    for f in os.listdir(LOG_DIR):
-        if "Studio" in f and f.endswith(".log"):
-            path = os.path.join(LOG_DIR, f)
-            studio_logs.append((path, os.path.getmtime(path)))
-
-    if not studio_logs:
-        return None
-
-    studio_logs.sort(key=lambda x: x[1], reverse=True)
-    return studio_logs[0][0]
-
-
-def clean_old_logs(days: int = 7) -> int:
-    """清理超过指定天数的旧日志"""
-    if not os.path.exists(LOG_DIR):
-        return 0
-
-    from datetime import datetime
-    count = 0
-    now = datetime.now().timestamp()
-    threshold = days * 24 * 60 * 60
-
-    for f in os.listdir(LOG_DIR):
-        if f.endswith(".log"):
-            path = os.path.join(LOG_DIR, f)
-            try:
-                if now - os.path.getmtime(path) > threshold:
-                    os.remove(path)
-                    count += 1
-            except Exception:
-                pass
-
-    return count
+"""
+日志工具模块: 日志读取、搜索等
+
+优化:
+- 从文件末尾倒序读取，适合大文件
+- 支持过滤特定类别 (如 FLog::Output)
+"""
+
+import os
+import re
+from typing import Optional, Generator
+from dataclasses import dataclass
+
+LOG_DIR = os.path.expandvars(r"%LOCALAPPDATA%\Roblox\logs")
+
+# 默认读取这些类别的日志（包含用户脚本的 print 和 warn 输出）
+DEFAULT_CATEGORIES = ["FLog::Output", "FLog::Warning"]
+
+
+@dataclass
+class LogEntry:
+    timestamp: str
+    level: str
+    category: str
+    message: str
+    raw: str
+
+
+def parse_log_line(line: str) -> Optional[LogEntry]:
+    """解析单行日志"""
+    # 格式: 2026-02-03T08:52:02.095Z,128.095795,1996c,12 [DFLog::HttpTraceError] message
+    # 或: 2026-02-03T08:52:04.244Z,130.244095,12f4,6,Info [FLog::...] message
+    match = re.match(
+        r'^(\d{4}-\d{2}-\d{2}T[\d:.]+Z),[\d.]+,[a-f0-9]+,\d+(?:,(\w+))?\s*\[([^\]]+)\]\s*(.*)$',
+        line
+    )
+    if match:
+        return LogEntry(
+            timestamp=match.group(1),
+            level=match.group(2) or "Info",
+            category=match.group(3),
+            message=match.group(4),
+            raw=line
+        )
+    return None
+
+
+def read_file_reverse(file_path: str, chunk_size: int = 8192) -> Generator[str, None, None]:
+    """
+    从文件末尾倒序读取行
+
+    对于大文件，这比读取整个文件再 reverse 更高效
+    """
+    with open(file_path, 'rb') as f:
+        # 移动到文件末尾
+        f.seek(0, 2)
+        file_size = f.tell()
+
+        buffer = b''
+        position = file_size
+
+        while position > 0:
+            # 计算读取位置
+            read_size = min(chunk_size, position)
+            position -= read_size
+            f.seek(position)
+
+            # 读取并拼接
+            chunk = f.read(read_size)
+            buffer = chunk + buffer
+
+            # 按行分割
+            lines = buffer.split(b'\n')
+
+            # 最后一个可能不完整，保留到下次
+            buffer = lines[0]
+
+            # 倒序返回完整的行
+            for line in reversed(lines[1:]):
+                line_str = line.decode('utf-8', errors='ignore').strip()
+                if line_str:
+                    yield line_str
+
+        # 处理剩余的 buffer
+        if buffer:
+            line_str = buffer.decode('utf-8', errors='ignore').strip()
+            if line_str:
+                yield line_str
+
+
+from .log_filter import should_exclude
+
+
+def get_logs_from_line(
+    log_path: str,
+    after_line: int = None,
+    before_line: int = None,
+    timestamps: bool = False,
+    categories: list[str] = None,
+    apply_filter: bool = True
+) -> dict:
+    """
+    从指定行范围读取日志
+    
+    Args:
+        log_path: 日志文件路径
+        after_line: 从哪一行之后开始读取，None 表示从头开始
+        before_line: 到哪一行之前结束，None 表示到末尾
+        timestamps: 是否附加时间戳
+        categories: 只返回这些类别的日志，默认 ["FLog::Output"]
+        apply_filter: 是否应用过滤规则排除 Studio 内部日志
+        
+    Returns:
+        {
+            "logs": "日志文本",
+            "start_line": 起始行号,
+            "last_line": 最后行号,
+            "remaining": 剩余有效日志行数,
+            "has_more": 是否还有更多
+        }
+    """
+    MAX_BYTES = 32000
+    
+    if not os.path.exists(log_path):
+        return {"logs": "", "start_line": 0, "last_line": 0, "remaining": 0, "has_more": False}
+    
+    if categories is None:
+        categories = DEFAULT_CATEGORIES
+    
+    start_line = None
+    last_line = 0
+    current_bytes = 0
+    log_lines = []
+    remaining = 0
+    bytes_exceeded = False
+    
+    try:
+        with open(log_path, 'r', encoding='utf-8', errors='ignore') as f:
+            for line_num, line in enumerate(f, 1):
+                # 跳过 after_line 之前的行
+                if after_line is not None and line_num <= after_line:
+                    continue
+                
+                # 停止在 before_line
+                if before_line is not None and line_num >= before_line:
+                    break
+                
+                line = line.strip()
+                if not line:
+                    continue
+                
+                entry = parse_log_line(line)
+                if not entry:
+                    continue
+                
+                # 类别过滤
+                if categories and entry.category not in categories:
+                    continue
+                
+                # 应用排除规则
+                if apply_filter and should_exclude(entry.message):
+                    continue
+                
+                # 这是一条有效日志
+                remaining += 1
+                
+                # 如果已超过字节限制，只统计不添加
+                if bytes_exceeded:
+                    continue
+                
+                # 格式化输出
+                if timestamps:
+                    time_part = entry.timestamp[11:19]
+                    output_line = f"[{time_part}] {entry.message}"
+                else:
+                    output_line = entry.message
+                
+                line_bytes = len(output_line.encode('utf-8')) + 1
+                
+                # 检查是否超过字节限制
+                if current_bytes + line_bytes > MAX_BYTES and log_lines:
+                    bytes_exceeded = True
+                    continue
+                
+                if start_line is None:
+                    start_line = line_num
+                
+                log_lines.append(output_line)
+                last_line = line_num
+                current_bytes += line_bytes
+                
+    except Exception:
+        pass
+    
+    returned_count = len(log_lines)
+    return {
+        "logs": "\n".join(log_lines),
+        "start_line": start_line or 0,
+        "last_line": last_line,
+        "remaining": remaining - returned_count,
+        "has_more": remaining > returned_count
+    }
+
+
+def get_recent_logs(
+    log_path: str,
+    limit: int = 100,
+    categories: list[str] = None,
+    min_level: Optional[str] = None,
+    apply_filter: bool = True
+) -> list[LogEntry]:
+    """
+    从日志文件末尾读取最近的日志
+
+    Args:
+        log_path: 日志文件路径
+        limit: 返回的最大条数
+        categories: 只返回这些类别的日志，默认 ["FLog::Output"]
+        min_level: 最低日志级别过滤
+        apply_filter: 是否应用过滤规则排除 Studio 内部日志，默认 True
+
+    Returns:
+        日志条目列表 (按时间正序)
+    """
+    if not os.path.exists(log_path):
+        return []
+
+    if categories is None:
+        categories = DEFAULT_CATEGORIES
+
+    entries = []
+    try:
+        for line in read_file_reverse(log_path):
+            entry = parse_log_line(line)
+            if not entry:
+                continue
+
+            # 类别过滤
+            if categories and entry.category not in categories:
+                continue
+
+            # 级别过滤
+            if min_level and entry.level.lower() != min_level.lower():
+                continue
+
+            # 应用排除规则
+            if apply_filter and should_exclude(entry.message):
+                continue
+
+            entries.append(entry)
+            if len(entries) >= limit:
+                break
+    except Exception:
+        pass
+
+    # 返回正序 (最旧的在前)
+    return list(reversed(entries))
+
+
+def get_all_logs(
+    log_path: str,
+    limit: int = 100,
+    min_level: Optional[str] = None
+) -> list[LogEntry]:
+    """
+    获取所有类别的日志 (不过滤类别)
+    """
+    return get_recent_logs(log_path, limit, categories=[], min_level=min_level)
+
+
+def search_logs(
+    log_path: str,
+    pattern: str,
+    limit: int = 50,
+    categories: list[str] = None
+) -> list[LogEntry]:
+    """
+    在日志中搜索匹配的条目
+
+    Args:
+        log_path: 日志文件路径
+        pattern: 正则表达式模式
+        limit: 返回的最大条数
+        categories: 只搜索这些类别，None 表示搜索所有
+    """
+    if not os.path.exists(log_path):
+        return []
+
+    entries = []
+    regex = re.compile(pattern, re.IGNORECASE)
+
+    try:
+        for line in read_file_reverse(log_path):
+            if not regex.search(line):
+                continue
+
+            entry = parse_log_line(line)
+            if not entry:
+                continue
+
+            if categories and entry.category not in categories:
+                continue
+
+            entries.append(entry)
+            if len(entries) >= limit:
+                break
+    except Exception:
+        pass
+
+    return list(reversed(entries))
+
+
+def search_logs_from_line(
+    log_path: str,
+    pattern: str,
+    after_line: int = None,
+    before_line: int = None,
+    timestamps: bool = False,
+    categories: list[str] = None,
+    apply_filter: bool = True
+) -> dict:
+    """
+    在指定行范围内搜索日志
+    
+    Args:
+        log_path: 日志文件路径
+        pattern: 正则表达式模式
+        after_line: 从哪一行之后开始搜索
+        before_line: 到哪一行之前结束
+        timestamps: 是否附加时间戳
+        categories: 只搜索这些类别，默认 ["FLog::Output"]
+        apply_filter: 是否应用过滤规则
+        
+    Returns:
+        {
+            "logs": "匹配的日志文本",
+            "start_line": 起始行号,
+            "last_line": 最后行号,
+            "match_count": 匹配条数,
+            "remaining": 剩余匹配数,
+            "has_more": 是否还有更多
+        }
+    """
+    MAX_BYTES = 32000
+    
+    if not os.path.exists(log_path):
+        return {"logs": "", "start_line": 0, "last_line": 0, "match_count": 0, "remaining": 0, "has_more": False}
+    
+    if categories is None:
+        categories = DEFAULT_CATEGORIES
+    
+    try:
+        regex = re.compile(pattern, re.IGNORECASE)
+    except re.error:
+        return {"error": f"Invalid regex pattern: {pattern}"}
+    
+    start_line = None
+    last_line = 0
+    current_bytes = 0
+    log_lines = []
+    match_count = 0
+    bytes_exceeded = False
+    
+    try:
+        with open(log_path, 'r', encoding='utf-8', errors='ignore') as f:
+            for line_num, line in enumerate(f, 1):
+                if after_line is not None and line_num <= after_line:
+                    continue
+                
+                if before_line is not None and line_num >= before_line:
+                    break
+                
+                line = line.strip()
+                if not line:
+                    continue
+                
+                entry = parse_log_line(line)
+                if not entry:
+                    continue
+                
+                if categories and entry.category not in categories:
+                    continue
+                
+                if apply_filter and should_exclude(entry.message):
+                    continue
+                
+                # 正则匹配
+                if not regex.search(entry.message):
+                    continue
+                
+                match_count += 1
+                
+                if bytes_exceeded:
+                    continue
+                
+                if timestamps:
+                    time_part = entry.timestamp[11:19]
+                    output_line = f"{line_num}|[{time_part}] {entry.message}"
+                else:
+                    output_line = f"{line_num}|{entry.message}"
+                
+                line_bytes = len(output_line.encode('utf-8')) + 1
+                
+                if current_bytes + line_bytes > MAX_BYTES and log_lines:
+                    bytes_exceeded = True
+                    continue
+                
+                if start_line is None:
+                    start_line = line_num
+                
+                log_lines.append(output_line)
+                last_line = line_num
+                current_bytes += line_bytes
+                
+    except Exception:
+        pass
+    
+    returned_count = len(log_lines)
+    return {
+        "logs": "\n".join(log_lines),
+        "start_line": start_line or 0,
+        "last_line": last_line,
+        "match_count": returned_count,
+        "remaining": match_count - returned_count,
+        "has_more": match_count > returned_count
+    }
+
+
+def find_latest_studio_log() -> Optional[str]:
+    """查找最新的 Studio 日志文件"""
+    if not os.path.exists(LOG_DIR):
+        return None
+
+    studio_logs = []
+    for f in os.listdir(LOG_DIR):
+        if "Studio" in f and f.endswith(".log"):
+            path = os.path.join(LOG_DIR, f)
+            studio_logs.append((path, os.path.getmtime(path)))
+
+    if not studio_logs:
+        return None
+
+    studio_logs.sort(key=lambda x: x[1], reverse=True)
+    return studio_logs[0][0]
+
+
+def clean_old_logs(days: int = 7) -> int:
+    """清理超过指定天数的旧日志"""
+    if not os.path.exists(LOG_DIR):
+        return 0
+
+    from datetime import datetime
+    count = 0
+    now = datetime.now().timestamp()
+    threshold = days * 24 * 60 * 60
+
+    for f in os.listdir(LOG_DIR):
+        if f.endswith(".log"):
+            path = os.path.join(LOG_DIR, f)
+            try:
+                if now - os.path.getmtime(path) > threshold:
+                    os.remove(path)
+                    count += 1
+            except Exception:
+                pass
+
+    return count

{roblox_studio_physical_operation_mcp-0.1.0 → roblox_studio_physical_operation_mcp-0.1.1}/roblox_studio_physical_operation_mcp/server.py

@@ -18,7 +18,7 @@ from .windows_utils import (
 from .log_utils import get_recent_logs, search_logs, clean_old_logs
 from .toolbar_detector import detect_toolbar_state, detect_toolbar_state_with_debug
 
-mcp = FastMCP("roblox-studio-mcp")
+mcp = FastMCP("roblox-studio-physical-operation-mcp")
 
 # 截图输出目录 (系统临时文件夹)
 import tempfile

roblox_studio_physical_operation_mcp-0.1.1/tests/default.project.json

@@ -0,0 +1,27 @@
+{
+  "name": "LogTest",
+  "tree": {
+    "$className": "DataModel",
+    "ServerScriptService": {
+      "$className": "ServerScriptService",
+      "TestScript": {
+        "$path": "src/TestScript.server.lua"
+      }
+    },
+    "StarterPlayer": {
+      "$className": "StarterPlayer",
+      "StarterPlayerScripts": {
+        "$className": "StarterPlayerScripts"
+      }
+    },
+    "Workspace": {
+      "$className": "Workspace",
+      "$properties": {
+        "FilteringEnabled": true
+      }
+    },
+    "ReplicatedStorage": {
+      "$className": "ReplicatedStorage"
+    }
+  }
+}

roblox_studio_physical_operation_mcp-0.1.1/tests/src/TestScript.server.lua

@@ -0,0 +1,32 @@
+-- 测试脚本：验证 print 和 warn 日志是否都能被 MCP 捕获
+-- Issue #1: 看不到 roblox 运行后的警告日志
+
+print("========== 日志测试开始 ==========")
+
+-- 测试 print (普通输出)
+print("[TEST] 这是一条 print 消息 - 应该能看到")
+
+-- 测试 warn (警告输出)
+warn("[TEST] 这是一条 warn 警告消息 - 需要验证是否能看到")
+
+-- 测试多条消息
+for i = 1, 3 do
+	print("[TEST] print 循环消息 #" .. i)
+	warn("[TEST] warn 循环警告 #" .. i)
+end
+
+-- 测试 error (不会中断脚本的方式)
+print("[TEST] 准备测试 error 输出...")
+
+-- 使用 pcall 包装 error，避免脚本中断
+local success, err = pcall(function()
+	error("[TEST] 这是一条 error 错误消息 - 需要验证是否能看到")
+end)
+
+if not success then
+	print("[TEST] pcall 捕获到错误: " .. tostring(err))
+end
+
+print("========== 日志测试结束 ==========")
+print("[TEST] 如果你只能看到 print 消息，说明 warn 被过滤了")
+print("[TEST] 如果你能看到 warn 消息，说明问题已修复")

roblox_studio_physical_operation_mcp-0.1.1/tests/test_fix_verify.py

@@ -0,0 +1,77 @@
+"""
+测试脚本：验证 warn 日志修复
+Issue #1: 看不到 roblox 运行后的警告日志
+"""
+
+import sys
+import os
+import time
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from roblox_studio_physical_operation_mcp.server import (
+    studio_list, game_start, game_stop, logs_get
+)
+
+PLACE_PATH = os.path.join(os.path.dirname(__file__), "game.rbxl")
+
+
+def main():
+    print("=" * 60)
+    print("Issue #1 Fix Verification")
+    print("=" * 60)
+    
+    # 查找我们的测试实例
+    instances = studio_list()
+    our_instance = None
+    for inst in instances:
+        if inst.get("place_path") and "game.rbxl" in inst.get("place_path", ""):
+            our_instance = inst
+            break
+    
+    if not our_instance:
+        print("Error: Test game.rbxl not running!")
+        print(f"Running instances: {instances}")
+        return
+    
+    print(f"Found test instance: PID={our_instance['pid']}")
+    
+    # 重新开始游戏
+    print("\n[1] Restart game (F5)...")
+    game_stop(place_path=PLACE_PATH)
+    time.sleep(2)
+    game_start(place_path=PLACE_PATH)
+    time.sleep(5)
+    
+    # 获取日志
+    print("\n[2] Get logs (after fix)...")
+    logs = logs_get(place_path=PLACE_PATH)
+    log_text = logs.get("logs", "")
+    
+    print("-" * 40)
+    # 只打印测试相关的行
+    for line in log_text.split("\n"):
+        if "[TEST]" in line or "=====" in line:
+            print(line)
+    print("-" * 40)
+    
+    # 验证
+    print("\n[3] Verification:")
+    has_print = "print" in log_text and "[TEST]" in log_text
+    has_warn = "warn" in log_text and "[TEST]" in log_text
+    
+    print(f"    print messages: {'VISIBLE' if has_print else 'NOT VISIBLE'}")
+    print(f"    warn messages:  {'VISIBLE' if has_warn else 'NOT VISIBLE'}")
+    
+    if has_print and has_warn:
+        print("\n    SUCCESS: Issue #1 is FIXED!")
+    elif has_print and not has_warn:
+        print("\n    FAILED: warn still filtered!")
+    else:
+        print("\n    UNKNOWN: Check output above")
+    
+    print("\n" + "=" * 60)
+
+
+if __name__ == "__main__":
+    main()

roblox_studio_physical_operation_mcp-0.1.1/tests/test_warn_log.py

@@ -0,0 +1,100 @@
+"""
+测试脚本：验证 warn 日志是否能被捕获
+Issue #1: 看不到 roblox 运行后的警告日志
+"""
+
+import sys
+import os
+import time
+
+# 添加项目路径
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from roblox_studio_physical_operation_mcp.server import (
+    studio_list, studio_open, studio_query, 
+    game_start, game_stop, logs_get, modal_close
+)
+
+PLACE_PATH = os.path.join(os.path.dirname(__file__), "game.rbxl")
+
+
+def main():
+    print("=" * 60)
+    print("Issue #1 测试: 验证 warn 日志是否能被捕获")
+    print("=" * 60)
+    
+    # 1. 检查 Studio 是否已运行
+    print("\n[1] 检查 Studio 实例...")
+    instances = studio_list()
+    print(f"    当前实例: {instances}")
+    
+    # 2. 打开 Studio
+    print(f"\n[2] 打开 Studio: {PLACE_PATH}")
+    result = studio_open(PLACE_PATH)
+    print(f"    结果: {result}")
+    
+    # 3. 等待加载
+    print("\n[3] 等待 Studio 加载 (8秒)...")
+    time.sleep(8)
+    
+    # 4. 关闭弹窗
+    print("\n[4] 关闭弹窗...")
+    result = modal_close(place_path=PLACE_PATH)
+    print(f"    结果: {result}")
+    
+    # 5. 查询状态
+    print("\n[5] 查询 Studio 状态...")
+    status = studio_query(place_path=PLACE_PATH)
+    print(f"    状态: {status}")
+    
+    if not status.get("active"):
+        print("    错误: Studio 未运行!")
+        return
+    
+    # 6. 开始游戏
+    print("\n[6] 开始游戏 (F5)...")
+    result = game_start(place_path=PLACE_PATH)
+    print(f"    结果: {result}")
+    
+    # 7. 等待脚本执行
+    print("\n[7] 等待脚本执行 (5秒)...")
+    time.sleep(5)
+    
+    # 8. 获取日志
+    print("\n[8] 获取日志 (默认过滤)...")
+    logs = logs_get(place_path=PLACE_PATH)
+    print(f"    日志结果:")
+    print("-" * 40)
+    print(logs.get("logs", "无日志"))
+    print("-" * 40)
+    print(f"    last_line: {logs.get('last_line')}")
+    print(f"    remaining: {logs.get('remaining')}")
+    
+    # 9. 分析结果
+    print("\n[9] 分析结果...")
+    log_text = logs.get("logs", "")
+    has_print = "[TEST] 这是一条 print 消息" in log_text
+    has_warn = "[TEST] 这是一条 warn 警告消息" in log_text
+    
+    print(f"    print 消息: {'✓ 可见' if has_print else '✗ 不可见'}")
+    print(f"    warn 消息:  {'✓ 可见' if has_warn else '✗ 不可见'}")
+    
+    if has_print and not has_warn:
+        print("\n    ⚠️ 问题确认: warn 日志被过滤了!")
+    elif has_print and has_warn:
+        print("\n    ✓ 正常: print 和 warn 都可见")
+    else:
+        print("\n    ? 异常: 需要检查日志输出")
+    
+    # 10. 停止游戏
+    print("\n[10] 停止游戏 (Shift+F5)...")
+    result = game_stop(place_path=PLACE_PATH)
+    print(f"    结果: {result}")
+    
+    print("\n" + "=" * 60)
+    print("测试完成")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()