mcpywrap 0.3.4__tar.gz → 0.3.5__tar.gz

{mcpywrap-0.3.4 → mcpywrap-0.3.5}/CHANGELOG.md

@@ -1,5 +1,12 @@
 # 更新记录
 
+## 0.3.5
+
+- 网络连接接入统一游戏会话：`connect/run --detach --json` 返回进程身份与日志，可复用 status/logs/stop、Skill 截图与按键脚本；网络 JSON 启动现在要求 `--detach`。
+- 新增 `doctor --mcs-auth` 只读组件检查；Skill 安装脚本分别报告 CLI 能力与组件是否具备，按任务显式要求可选能力。
+- 冒烟脚本支持 `--mcs-auth` 与 `--connect`，共用日志标记验证和本次会话清理；精简 Skill 入口并补充编辑器、地图合并及网络指引。
+- 修复 Windows PowerShell 5.1 中文脚本读取与 GBK 管道兼容；JSON 无损保留 Unicode，会话 SDK／引擎日志统一解码为 UTF-8 后脱敏。
+
 ## 0.3.4
 
 - 新增显式 `--mcs-auth`：网络连接、单人测试和单人项目 GUI 可按次使用已登录的 MC Studio 身份；默认仍不读取身份，配置文件不能自动启用。

{mcpywrap-0.3.4/mcpywrap.egg-info → mcpywrap-0.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcpywrap
-Version: 0.3.4
+Version: 0.3.5
 Summary: A wrapper for Minecraft China Edition Addons management
 Author-email: boybook <boybook@easecation.net>
 License-Expression: MIT
@@ -140,9 +140,18 @@ host = "192.168.31.101"
 port = 19132
 ```
 
-空目录只需上述配置，无需执行 `mcpy init`；已有 Addon 项目也可添加此表。当前使用未认证连接，不读取登录身份或 token，不保证服务器允许进服；项目依赖仍会校验，但暂不装配本地 Mod。
+空目录只需上述配置，无需执行 `mcpy init`；已有 Addon 项目也可添加此表。默认使用未认证连接，不读取登录身份或 token，不保证服务器允许进服；项目依赖仍会校验，但暂不装配本地 Mod。
 
-网络模式前台输出日志并显示日志文件路径，按 Ctrl+C 结束本次游戏。暂不支持 Map 项目、GUI、`--detach`、`--new` 或本地世界实例 ID。
+网络模式默认前台输出日志，Ctrl+C 结束本次游戏。增加 `--detach --json` 可返回会话，与本地游戏共用 `status/logs/stop` 及 Skill 截图、按键脚本：
+
+```powershell
+mcpy --project D:\tests\server --non-interactive connect example.com --detach --json
+mcpy --project D:\tests\server status --session <id> --json
+mcpy --project D:\tests\server stop --session <id> --json
+```
+
+目录须已存在；临时 `connect` 不读取项目配置，只在该目录保存会话。后续操作使用启动返回的 `project` 和 `session`。
+网络模式暂不支持 Map、Qt GUI、`--new` 或本地世界实例 ID；进程启动不等于成功进服。
 
 ### 使用 MC Studio 登录身份（可选）
 
@@ -163,8 +172,8 @@ port = 19132
 
 也可以下载仓库 ZIP，将完整的 `skills/mcpywrap` 文件夹复制到对应 Agent 的技能目录。
 无需从源码安装 Python 项目；CLI 和 Skill 分别安装，`pip/uv install` 不会自动注册 Skill。
-Skill 中的 `scripts/bootstrap.ps1` 可使用已有 uv 安装 CLI，并检查是否具备所需命令能力。
-请使用 mcpywrap 0.3.4 或更高版本；需要固定组合时，可从 `v0.3.4` 标签安装对应 Skill。
+Skill 中的 `scripts/bootstrap.ps1` 使用已有 uv 安装或复用 CLI，报告可选能力；`-RequireCapability network-sessions` 或 `mcs-auth` 仅在任务需要时检查。身份参数与桥接组件就绪分别报告，Git／可编辑安装可能缺少组件。
+推荐使用 mcpywrap 0.3.5 或更高版本，可从 `v0.3.5` 标签安装对应 Skill。网络会话需 `connect --help` 包含 `--detach`，实际能力以脚本检测为准。
 
 安装后可直接描述任务：
 

{mcpywrap-0.3.4 → mcpywrap-0.3.5}/README.md

@@ -113,9 +113,18 @@ host = "192.168.31.101"
 port = 19132
 ```
 
-空目录只需上述配置，无需执行 `mcpy init`；已有 Addon 项目也可添加此表。当前使用未认证连接，不读取登录身份或 token，不保证服务器允许进服；项目依赖仍会校验，但暂不装配本地 Mod。
+空目录只需上述配置，无需执行 `mcpy init`；已有 Addon 项目也可添加此表。默认使用未认证连接，不读取登录身份或 token，不保证服务器允许进服；项目依赖仍会校验，但暂不装配本地 Mod。
 
-网络模式前台输出日志并显示日志文件路径，按 Ctrl+C 结束本次游戏。暂不支持 Map 项目、GUI、`--detach`、`--new` 或本地世界实例 ID。
+网络模式默认前台输出日志，Ctrl+C 结束本次游戏。增加 `--detach --json` 可返回会话，与本地游戏共用 `status/logs/stop` 及 Skill 截图、按键脚本：
+
+```powershell
+mcpy --project D:\tests\server --non-interactive connect example.com --detach --json
+mcpy --project D:\tests\server status --session <id> --json
+mcpy --project D:\tests\server stop --session <id> --json
+```
+
+目录须已存在；临时 `connect` 不读取项目配置，只在该目录保存会话。后续操作使用启动返回的 `project` 和 `session`。
+网络模式暂不支持 Map、Qt GUI、`--new` 或本地世界实例 ID；进程启动不等于成功进服。
 
 ### 使用 MC Studio 登录身份（可选）
 
@@ -136,8 +145,8 @@ port = 19132
 
 也可以下载仓库 ZIP，将完整的 `skills/mcpywrap` 文件夹复制到对应 Agent 的技能目录。
 无需从源码安装 Python 项目；CLI 和 Skill 分别安装，`pip/uv install` 不会自动注册 Skill。
-Skill 中的 `scripts/bootstrap.ps1` 可使用已有 uv 安装 CLI，并检查是否具备所需命令能力。
-请使用 mcpywrap 0.3.4 或更高版本；需要固定组合时，可从 `v0.3.4` 标签安装对应 Skill。
+Skill 中的 `scripts/bootstrap.ps1` 使用已有 uv 安装或复用 CLI，报告可选能力；`-RequireCapability network-sessions` 或 `mcs-auth` 仅在任务需要时检查。身份参数与桥接组件就绪分别报告，Git／可编辑安装可能缺少组件。
+推荐使用 mcpywrap 0.3.5 或更高版本，可从 `v0.3.5` 标签安装对应 Skill。网络会话需 `connect --help` 包含 `--detach`，实际能力以脚本检测为准。
 
 安装后可直接描述任务：
 

{mcpywrap-0.3.4 → mcpywrap-0.3.5}/docs/development.md

@@ -19,6 +19,7 @@ python skills/mcpywrap/scripts/smoke.py --project D:\mods\test --game --expect-l
 
 脚本结束后停止自己创建的会话；日志和产物留在项目中。
 需要手动截图验证时直接运行 `run --no-gui --detach --json`，保存会话 ID，操作完后显式 stop。
+网络验证使用 `smoke.py --project <已有目录> --connect <地址> --expect-log <约定标记>`，不打包项目。单人与网络测试都可显式加 `--mcs-auth`；脚本停止自己创建的会话。
 历史验收记录仅用于追溯，不能代替当前版本测试。
 
 发布见 [发布流程](releasing.md)。

{mcpywrap-0.3.4 → mcpywrap-0.3.5}/docs/engine-discovery.md

@@ -52,4 +52,4 @@ mcpy --project D:\mods\demo stop --session <id> --json
 
 只打开游戏窗口，日志写入返回的文件。`running` 表示进程存活，加载是否成功应查看项目日志或游戏画面。
 Computer Use 只接手游戏画面；Qt 管理、模板及日志页留给人工操作。
-本功能不包含第三方网络服 IP/端口连接。
+以上示例是本地世界会话。网络连接可用 `mcpy connect <地址> --detach --json`，或配置服务器后执行 `run --detach --json`；同样使用返回的项目路径、会话 ID 读取日志、截图、输入和停止。临时 connect 不读取项目引擎配置，使用 CLI 参数或环境变量覆盖。

{mcpywrap-0.3.4 → mcpywrap-0.3.5}/docs/mcs-auth.md

@@ -10,7 +10,9 @@ mcpy ui --mcs-auth
 mcpy --project D:\mods\demo --non-interactive run --mcs-auth --detach --json
 ```
 
-网络模式不支持 `--detach`；GUI 登录支持单人项目，网络目标继续使用 CLI。
+本地与网络均支持 `--detach --json`，共用会话查询、日志和停止。GUI 登录支持单人项目，网络目标使用 CLI。
+
+`mcpy doctor --mcs-auth --json` 可只读检查组件文件，不读取身份、不写缓存、不修改证书。组件具备不表示已登录或系统策略允许启用。
 
 ## 用户会看到什么
 

{mcpywrap-0.3.4 → mcpywrap-0.3.5}/mcpywrap/__init__.py

@@ -1,4 +1,4 @@
 # -*- coding: utf-8 -*-
 """mcpywrap - 将 Python 3 代码转换为 Python 2 代码的工具"""
 
-__version__ = '0.3.4'
+__version__ = '0.3.5'

mcpywrap-0.3.5/mcpywrap/__main__.py

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+"""
+mcpywrap 命令行工具的入口点
+"""
+
+from .cli import cli
+
+def main():
+    """主函数，作为 CLI 入口点"""
+    import sys
+    # Keep the caller's text encoding; unsupported symbols must not abort an operation.
+    for stream in (sys.stdout, sys.stderr):
+        if hasattr(stream, 'reconfigure'):
+            stream.reconfigure(errors='backslashreplace')
+    cli()
+
+if __name__ == "__main__":
+    main()

{mcpywrap-0.3.4 → mcpywrap-0.3.5}/mcpywrap/command_context.py

@@ -111,7 +111,8 @@ class OperationGroup(click.Group):
                 data = {'ok': code == 0, 'error': None, 'hint': None}
                 if isinstance(result, dict):
                     data.update(result)
-                click.echo(json.dumps(data, ensure_ascii=False), file=output)
+                # ASCII JSON survives both GBK consoles and UTF-8 subprocess pipes losslessly.
+                click.echo(json.dumps(data, ensure_ascii=True), file=output)
             elif code:
                 click.echo('错误: ' + str((result or {}).get('error') or '操作失败'), err=True)
                 if (result or {}).get('hint'):

{mcpywrap-0.3.4 → mcpywrap-0.3.5}/mcpywrap/commands/connect_cmd.py

@@ -11,10 +11,12 @@ from ..mcstudio.network import ServerTarget, run_network
 @click.argument('host')
 @click.option('--port', type=click.IntRange(1, 65535), default=19132, show_default=True)
 @click.option('--mcs-auth', is_flag=True, help='本次连接使用已登录的 MC Studio 身份')
-def connect_cmd(host, port, mcs_auth=False, **engine_overrides):
+@click.option('--detach', is_flag=True, help='后台连接并返回游戏会话；JSON 必须指定')
+def connect_cmd(host, port, mcs_auth=False, detach=False, **engine_overrides):
     """尝试连接服务器；前台采集日志，Ctrl+C 结束本次游戏。
 
     默认不读取登录身份；--mcs-auth 要求 MCS 已登录及本机桥接可用。
     不读取项目配置，不装配本地 Mod，不保证服务器接受连接。
     """
-    return run_network(ServerTarget(host, port, 'mcs' if mcs_auth else 'none'), engine_overrides=engine_overrides)
+    return run_network(ServerTarget(host, port, 'mcs' if mcs_auth else 'none'),
+                       engine_overrides=engine_overrides, detach=detach)

{mcpywrap-0.3.4 → mcpywrap-0.3.5}/mcpywrap/commands/doctor_cmd.py

@@ -9,7 +9,8 @@ from ..mcstudio.discovery import (
 
 @click.command(cls=OperationCommand)
 @engine_options
-def doctor_cmd(**overrides):
+@click.option('--mcs-auth', is_flag=True, help='同时只读检查登录组件；不读取身份或安装证书')
+def doctor_cmd(mcs_auth=False, **overrides):
     """诊断游戏发现和运行资源（只读，无需初始化项目）"""
     result = discover_engines(current_project(), overrides=overrides)
     data = result.to_dict()
@@ -21,6 +22,11 @@ def doctor_cmd(**overrides):
         _, issues = studio_installation(purpose)
         data['resources'][purpose].extend(issues)
     data['ok'] = bool(result.selected and not result.error and not data['resources']['run'])
+    if mcs_auth:
+        from ..mcstudio.bridge_assets import inspect_bridge
+        data['mcs_auth'] = inspect_bridge()
+        if not data['mcs_auth']['component_available']:
+            data.update(ok=False, error=data['mcs_auth']['error'], hint=data['mcs_auth']['hint'])
     from ..command_context import json_output
     if not json_output():
         for candidate in result.candidates:
@@ -30,4 +36,7 @@ def doctor_cmd(**overrides):
         for kind, issues in data['resources'].items():
             for issue in issues:
                 click.echo(f'资源 [{kind}]: {issue}')
+        if mcs_auth:
+            click.echo('登录组件: ' + ('文件齐全，尚未验证登录和系统策略' if data['mcs_auth']['component_available']
+                                     else data['mcs_auth']['error']))
     return data

{mcpywrap-0.3.4 → mcpywrap-0.3.5}/mcpywrap/commands/run_cmd.py

@@ -126,7 +126,7 @@ def _build_dependency_tree(node, tree_node):
 
 def _run_game_with_instance(config_path, level_id, all_packs, wait=True, log_callback=None,
                             engine_overrides=None, no_gui=False, logging_port=None, output_path=None,
-                            auth_context=None, auth_config_path=None):
+                            auth_context=None, auth_config_path=None, capture_output=False):
     """使用指定的实例运行游戏
     
     Args:
@@ -274,7 +274,7 @@ def _run_game_with_instance(config_path, level_id, all_packs, wait=True, log_cal
     
     with console.status("启动游戏中...", spinner="dots"):
         game_process = open_game(launch_config_path, logging_port=logging_port, wait=False, engine=engine,
-                                 **({'capture_output': True} if auth_context is not None else
+                                 **({'capture_output': True} if auth_context is not None or capture_output else
                                     {'output_path': output_path} if output_path else {}))
 
     if not game_process:
@@ -356,7 +356,7 @@ def run_cmd(new, list, delete, force, clean_all, instance_prefix, no_gui, detach
     配置 [tool.mcpywrap.server] host/port 时改为网络连接；默认未认证，
     可用 --mcs-auth 显式读取 MCS 身份，单人测试同样支持此选项。
     不装配本地 Mod，不保证服务器接受连接。网络模式前台采集日志，
-    Ctrl+C 结束本次游戏，暂不支持 --detach。
+    Ctrl+C 结束本次网络游戏；--detach 返回可查询、操作和停止的会话。
     """
     base_dir = str(current_project())
     if (delete or clean_all) and non_interactive() and not force:
@@ -379,11 +379,9 @@ def run_cmd(new, list, delete, force, clean_all, instance_prefix, no_gui, detach
                 target = replace(target, auth='mcs')
             if new or instance_prefix:
                 raise click.UsageError('网络模式不支持 --new 或本地世界实例 ID')
-            if detach:
-                raise click.UsageError('网络模式暂不支持 --detach；请在终端会话中前台运行')
             packs = prepare_project(base_dir, config)
             return run_network(target, project_dir=base_dir, packs=packs,
-                               engine_overrides=engine_overrides)
+                               engine_overrides=engine_overrides, detach=detach)
 
     # 确保 map 项目的 setuptools 配置同步
     ensure_map_setuptools_sync(interactive=False)
@@ -470,10 +468,7 @@ def run_cmd(new, list, delete, force, clean_all, instance_prefix, no_gui, detach
         import time
         data = sessions.start(base_dir, config_path, level_id, engine_overrides,
                               **({'auth_context': auth_context} if auth_context is not None else {}))
-        result = {'application': 'game', 'project': base_dir, 'session': data['session'],
-                  'state': data['state'], **data['game'], 'log_path': data['log_path'],
-                  'engine_log_path': data.get('engine_log_path'),
-                  'window_title_hint': 'Minecraft', 'window_verified': False}
+        result = sessions.handoff(data)
         if detach:
             return result
         click.echo('会话: ' + data['session'] + '；日志: ' + data['log_path'])

{mcpywrap-0.3.4 → mcpywrap-0.3.5}/mcpywrap/mcstudio/bridge_assets.py

@@ -9,6 +9,30 @@ BINARIES = ('Injector.exe', 'Loader.dll', 'McpyMcsAuth.dll')
 PAYLOAD = Path(__file__).with_name('bridge_payload')
 
 
+def inspect_bridge():
+    """只检查组件文件；不复制缓存、不读取身份、不改变证书信任。"""
+    override = os.environ.get('MCPY_MCS_BRIDGE_DIR')
+    bundled = not override and (PAYLOAD/'manifest.json').is_file()
+    directory = (Path(override).expanduser().resolve() if override else PAYLOAD if bundled
+                 else Path.home()/'.local/share/mcpywrap/mcs-auth-bridge')
+    result = {'component_available': False, 'directory': str(directory),
+              'source': 'override' if override else 'package' if bundled else 'development',
+              'integrity_verified': False, 'trust_verified': False, 'login_verified': False,
+              'error': None, 'hint': None}
+    try:
+        if bundled:
+            payload_manifest()
+            result['integrity_verified'] = True
+        missing = [name for name in BINARIES if not (directory/name).is_file()]
+        if missing:
+            raise ValueError('缺少登录组件: ' + ', '.join(missing))
+        result['component_available'] = True
+    except (OSError, ValueError, KeyError, TypeError) as exc:
+        result.update(error=str(exc), hint='使用包含桥接组件的正式发布包；Git／可编辑安装需另行构建组件，'
+                      '并通过 MCPY_MCS_BRIDGE_DIR 指定目录。组件存在不表示已登录或系统策略允许启用。')
+    return result
+
+
 def digest(path):
     return hashlib.sha256(path.read_bytes()).hexdigest()
 

{mcpywrap-0.3.4 → mcpywrap-0.3.5}/mcpywrap/mcstudio/bridge_payload/manifest.json

@@ -11,9 +11,9 @@
     "Loader.c": "f2f1f781ce82fc30c62a6ce22bb048d3b023f6ff500e6ec8228da28b4dbf1b4a"
   },
   "files": {
-    "Injector.exe": "02a57987e08ccb672230d25389c5564f47841aee306491ef0b3e50cd8454db4a",
-    "Loader.dll": "df2e3076768bc45487138ff99363738229ee6baf5e078c98b9855f4c11115a4c",
-    "McpyMcsAuth.dll": "f46f1b324ee1959dedb860fa8d45cb9e17610d9b598fe61b7973a8a816b66dce",
+    "Injector.exe": "61355aeeb02b23e2ff790f336c75486697028d98055f95bf5eb0c3a47538e43c",
+    "Loader.dll": "b8eb5e121e005b57e7720e3dfd3aac99f2393678bc4ce7d87194fa270e287db8",
+    "McpyMcsAuth.dll": "fe5c60e7d8266cf8ea843fef6dd517d6324397d3dc477f480830b807945f9abc",
     "publisher.cer": "e5aa2ac39df40804ed8b08fe8e43c4a2b8923f0d02a360708486b2db5b6303d7"
   }
 }

{mcpywrap-0.3.4 → mcpywrap-0.3.5}/mcpywrap/mcstudio/log_protocol.py

@@ -9,6 +9,28 @@ def decode_text(raw):
         return raw.decode('gb18030', errors='replace')
 
 
+class TextLogDecoder:
+    """普通 stdout 按完整行解码，跨块保留字节；UTF-8 优先、GBK/GB18030 回退。"""
+    def __init__(self):
+        self.pending = bytearray()
+
+    def feed(self, data):
+        self.pending.extend(data)
+        output = []
+        while b'\n' in self.pending:
+            line, _, rest = self.pending.partition(b'\n')
+            output.append(decode_text(bytes(line)) + '\n')
+            self.pending = bytearray(rest)
+        if len(self.pending) > 1024 * 1024:
+            output.append(self.finish())
+        return ''.join(output)
+
+    def finish(self):
+        text = decode_text(bytes(self.pending))
+        self.pending.clear()
+        return text
+
+
 class LogDecoder:
     def __init__(self):
         self.pending = bytearray()

{mcpywrap-0.3.4 → mcpywrap-0.3.5}/mcpywrap/mcstudio/network.py

@@ -3,17 +3,15 @@ import codecs
 import ipaddress
 import json
 import re
-import subprocess
-import tempfile
+import time
 import uuid
-from dataclasses import dataclass
+from dataclasses import asdict, dataclass
 from pathlib import Path
 
 import click
 
 from ..dependencies import DependencyService, addon_directories, read_project
 from .discovery import discover_engines, require_resources
-from .file_logs import FileLogServer
 from .game import open_game
 from .mcs import is_windows
 from .runtime_cppconfig import gen_runtime_config
@@ -90,97 +88,82 @@ def unauthenticated_config(engine, target):
     return config
 
 
-def run_network(target, *, project_dir=None, packs=(), engine_overrides=None):
-    """共用调度入口；packs 留待网络装配支持，本版只报告数量，不挂载。"""
+def launch_network(engine, target, config_path, logging_port, auth_context=None):
+    """由会话 worker 调用；监听、日志脱敏和进程回收由 worker 统一负责。"""
+    require_resources(engine)
+    config = unauthenticated_config(engine, target)
+    if target.auth == 'mcs' and auth_context is None:
+        raise ValueError('网络会话缺少本次请求的 MCS 身份，拒绝匿名回退')
+    if auth_context:
+        auth_context.apply(config)
+        game_id = str(uuid.uuid4())
+        config['misc']['game_id'] = game_id
+        config['room_info']['item_ids'] = [game_id]
+        config.update(vip_using_mod=[], isCloud=False, path=str(config_path))
+    config_path.write_text(json.dumps(config, ensure_ascii=False), encoding='utf-8')
+    return open_game(str(config_path), engine=engine, logging_ip='127.0.0.1',
+                     logging_port=logging_port, wait=False, use_system_color=False,
+                     capture_output=True)
+
+
+def run_network(target, *, project_dir=None, packs=(), engine_overrides=None, detach=False):
+    """预检后创建普通游戏会话；临时 connect 只用项目目录存会话，不读取其配置。"""
+    from ..command_context import project_dir as current_project, json_output
+    from . import sessions
+    if json_output() and not detach:
+        raise click.UsageError('网络运行 --json 需要 --detach；使用 status/logs/stop 管理返回的会话')
     if not is_windows():
         raise ValueError('网络游戏启动仅支持 Windows')
     engine = discover_engines(project_dir, engine_overrides,
                               read_project_config=project_dir is not None).require_engine()
     require_resources(engine)
-    config = unauthenticated_config(engine, target)
     identity = None
-    secrets = []
     if target.auth == 'mcs':
         from .mcs_auth import acquire_identity
         identity = acquire_identity()
-        identity.apply(config)
-        # Match MCS's generated ID relationship for third-party servers without a numeric game ID.
-        game_id = str(uuid.uuid4())
-        config['misc']['game_id'] = game_id
-        config['room_info']['item_ids'] = [game_id]
-        config.update(vip_using_mod=[], isCloud=False)
-        secrets = identity.secrets()
         click.echo('已读取 MCS 当前身份；连接结果仍以服务器响应为准。')
     else:
         click.echo('未认证网络连接：不使用账号/token，服务器可能拒绝连接。')
     click.echo(f'本次仅连接服务器，工具未装配本地 Addon（已解析 {len(packs)} 个）。')
-    directory = Path(tempfile.mkdtemp(prefix='mcpy-network-'))
-    config_path, log_path = directory / 'runtime.cppconfig', directory / 'game.log'
-    engine_log = directory / 'engine.log'
-    process, receiver, engine_capture = None, None, None
+    root = Path(project_dir or current_project()).resolve()
+    data = sessions.start(root, auth_context=identity,
+                          network={'target': asdict(target), 'engine': asdict(engine)})
+    result = sessions.handoff(data)
+    if detach:
+        return result
+    click.echo(f"会话: {data['session']}；PID: {data['game']['pid']}（尚未确认连接）")
+    click.echo(f"日志: {data['log_path']}\n引擎输出: {data['engine_log_path']}\nCtrl+C 结束本次游戏。")
     tails = []
-
     def relay(final=False):
-        for tail, decoder in tails:
-            click.echo(decoder.decode(tail.read(), final=final), nl=False)
-
+        for stream, decoder in tails:
+            click.echo(decoder.decode(stream.read(), final=final), nl=False)
     try:
-        if identity:
-            config['path'] = str(config_path)
-        config_path.write_text(json.dumps(config, ensure_ascii=False), encoding='utf-8')
-        if identity:
-            from .private_logs import RedactedDecoder, EngineLogCapture
-            receiver = FileLogServer(log_path, decoder_factory=lambda: RedactedDecoder(secrets))
-        else:
-            receiver = FileLogServer(log_path)
-        receiver.start()
-        engine_log.touch()
-        for path in (log_path, engine_log):
+        for key in ('log_path', 'engine_log_path'):
+            path = Path(data[key])
+            path.touch(exist_ok=True)
             tails.append((path.open('rb'), codecs.getincrementaldecoder('utf-8')(errors='replace')))
-        click.echo(f'目标: {target.host}:{target.port}\n日志: {log_path}\n引擎输出: {engine_log}')
-        process = open_game(str(config_path), engine=engine, logging_ip='127.0.0.1',
-                            logging_port=receiver.port, wait=False, use_system_color=False,
-                            **({'capture_output': True} if identity else {'output_path': str(engine_log)}))
-        if not process:
-            raise click.ClickException(f'游戏启动失败；日志目录: {directory}')
-        if identity:
-            engine_capture = EngineLogCapture(process.stdout, engine_log, secrets)
-        click.echo(f'游戏进程已创建，PID: {process.pid}（尚未确认连接）；Ctrl+C 结束本次游戏。')
         while True:
             relay()
-            try:
-                code = process.wait(timeout=0.2)
+            final = sessions.read(root, data['session'])
+            if final['state'] == 'failed':
+                sessions.stop(root, data['session'])
+            if final['state'] not in ('starting', 'running'):
+                # read() may observe the game exiting just before the worker flushes logs.
+                if final['state'] == 'exited' and 'exit_code' not in final:
+                    time.sleep(0.2)
+                    continue
                 break
-            except subprocess.TimeoutExpired:
-                continue
+            time.sleep(0.2)
+    except BaseException:
+        sessions.stop(root, data['session'])
+        raise
     finally:
         try:
-            if process and process.poll() is None:
-                process.terminate()
-                try:
-                    process.wait(timeout=5)
-                except subprocess.TimeoutExpired:
-                    process.kill()
-                    process.wait(timeout=5)
+            relay(final=True)
         finally:
-            try:
-                try:
-                    if engine_capture:
-                        engine_capture.close()
-                finally:
-                    if receiver:
-                        receiver.close()
-                relay(final=True)
-            finally:
-                for tail, _ in tails:
-                    tail.close()
-                config_path.unlink(missing_ok=True)
-    if code:
-        error = click.ClickException(f'游戏退出码 {code}；日志: {log_path}；引擎输出: {engine_log}')
-        error.exit_code = code if 0 < code < 256 else 1
-        raise error
-    return {'application': 'game', 'pid': process.pid, 'state': 'exited', 'exit_code': code,
-            'authenticated': False, 'connection_verified': False, 'addons_assembled': False,
-            'identity_source': target.auth, 'identity_provided': identity is not None,
-            'host': target.host, 'port': target.port, 'log_path': str(log_path),
-            'engine_log_path': str(engine_log), 'engine_version': engine.version}
+            for stream, _ in tails:
+                stream.close()
+    if final['state'] == 'failed' or final.get('exit_code', 0):
+        raise click.ClickException(final.get('error') or f"游戏退出码 {final['exit_code']}；日志: {data['log_path']}")
+    result.update(state=final['state'], exit_code=final.get('exit_code', 0))
+    return result

{mcpywrap-0.3.4 → mcpywrap-0.3.5}/mcpywrap/mcstudio/private_logs.py

@@ -1,8 +1,7 @@
 """Streaming credential redaction, including secrets split across read boundaries."""
-import codecs
 import threading
 
-from .log_protocol import LogDecoder
+from .log_protocol import LogDecoder, TextLogDecoder
 
 
 class Redactor:
@@ -42,23 +41,23 @@ class RedactedDecoder:
 
 
 class EngineLogCapture:
-    def __init__(self, stream, path, secrets):
+    def __init__(self, stream, path, secrets=()):
         self.stream, self.path, self.secrets = stream, path, secrets
         self.error = None
         self.thread = threading.Thread(target=self._read, daemon=True)
         self.thread.start()
 
     def _read(self):
-        decoder = codecs.getincrementaldecoder('utf-8')(errors='replace')
+        decoder = TextLogDecoder()
         redactor = Redactor(self.secrets)
         try:
             with open(self.path, 'w', encoding='utf-8', newline='') as output:
                 while True:
-                    chunk = self.stream.read(4096)
+                    chunk = getattr(self.stream, 'read1', self.stream.read)(4096)
                     if not chunk:
-                        output.write(redactor.feed(decoder.decode(b'', final=True), final=True))
+                        output.write(redactor.feed(decoder.finish(), final=True))
                         break
-                    output.write(redactor.feed(decoder.decode(chunk)))
+                    output.write(redactor.feed(decoder.feed(chunk)))
                     output.flush()
         except (OSError, ValueError) as exc:
             self.error = type(exc).__name__

{mcpywrap-0.3.4 → mcpywrap-0.3.5}/mcpywrap/mcstudio/session_worker.py

@@ -24,7 +24,7 @@ def run(project, session):
         auth_context = None
         if data.get('mcs_auth'):
             from .mcs_auth import AuthContext
-            from .private_logs import RedactedDecoder, EngineLogCapture
+            from .private_logs import RedactedDecoder
             try:
                 payload = json.loads(sys.stdin.buffer.read(65536).decode('utf-8'))
                 auth_context = AuthContext.parse(payload, data['mcs_pid'])
@@ -37,17 +37,27 @@ def run(project, session):
         receiver.start()
         if (directory / 'stop').exists():
             raise ValueError('启动已取消')
-        from ..commands.run_cmd import _run_game_with_instance
-        with project_scope(project):
-            success, process = _run_game_with_instance(
-                data['config_path'], data['level_id'], [], wait=False,
-                engine_overrides=data['engine_overrides'], no_gui=True, logging_port=receiver.port,
-                output_path=str(directory / 'engine.log'),
-                **({'auth_context': auth_context, 'auth_config_path': str(auth_path)} if auth_context else {}))
+        if data.get('mode') == 'network':
+            from .network import launch_network, ServerTarget
+            from .discovery import Engine
+            process = launch_network(Engine(**data['network']['engine']),
+                                     ServerTarget(**data['network']['target']),
+                                     directory/'runtime.cppconfig', receiver.port, auth_context)
+            success = bool(process)
+        else:
+            from ..commands.run_cmd import _run_game_with_instance
+            with project_scope(project):
+                success, process = _run_game_with_instance(
+                    data['config_path'], data['level_id'], [], wait=False,
+                    engine_overrides=data['engine_overrides'], no_gui=True, logging_port=receiver.port,
+                    output_path=str(directory / 'engine.log'), capture_output=True,
+                    **({'auth_context': auth_context, 'auth_config_path': str(auth_path)} if auth_context else {}))
+        if success and process:
+            from .private_logs import EngineLogCapture
+            engine_capture = EngineLogCapture(process.stdout, directory/'engine.log',
+                                              auth_context.secrets() if auth_context else ())
         if not success or not process or process.poll() is not None:
-            raise ValueError('游戏进程未成功启动，详见 worker.log')
-        if auth_context:
-            engine_capture = EngineLogCapture(process.stdout, directory/'engine.log', secrets)
+            raise ValueError('游戏进程未成功启动，详见 worker.log 和 engine.log')
         data.update(state='running', game=identity(process.pid))
         sessions.save(path, data)
         while process.poll() is None:
@@ -66,10 +76,14 @@ def run(project, session):
         try:
             if engine_capture:
                 engine_capture.close()
+        except OSError as exc:
+            data.update(state='failed', error=str(exc))
         finally:
             if receiver:
                 receiver.close()
             auth_path.unlink(missing_ok=True)
+            if data.get('mode') == 'network':
+                (directory/'runtime.cppconfig').unlink(missing_ok=True)
             sessions.save(path, data)