mcpywrap-core 0.6.2__tar.gz → 0.6.3__tar.gz

{mcpywrap_core-0.6.2 → mcpywrap_core-0.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcpywrap-core
-Version: 0.6.2
+Version: 0.6.3
 Summary: Shared mcpy project dependency, build and runtime logic
 Author-email: boybook <boybook@easecation.net>
 License-Expression: MIT

mcpywrap_core-0.6.3/mcpywrap_core/_version.py

@@ -0,0 +1 @@
+__version__ = '0.6.3'

{mcpywrap_core-0.6.2 → mcpywrap_core-0.6.3}/mcpywrap_core/command_context.py

@@ -88,7 +88,7 @@ def require_project():
 
 def restart_handoff(result, previous):
     if not isinstance(result,dict) or not previous: return result
-    current=result.get('session')
+    current=result.get('replacement_session',result.get('session'))
     if current and current!=previous:
         result=dict(result,previous_session=previous,session_changed=True)
         message='会话已更换；后续日志、截图和调试请使用 --session '+current+'。旧会话记录仍保留。'

{mcpywrap_core-0.6.2 → mcpywrap_core-0.6.3}/mcpywrap_core/commands/run_cmd.py

@@ -69,10 +69,12 @@ def take_world_options(arguments, cppconfig=None):
 @click.option('--force', '-f', is_flag=True, help='强制删除，不提示确认')
 @click.option('--clean-all', is_flag=True, help='清空所有游戏实例')
 @click.option('--clients', type=click.IntRange(1, 2), default=1, show_default=True,
-              help='本机玩家客户端数量；本地双客户端需在客户端 2 手动点击目标局域网卡片加入')
+              help='本机玩家客户端数量；Windows 本地双客户端默认自动加入目标主机')
+@click.option('--join-mode', type=click.Choice(['auto','manual']), default=None,
+              help='Windows 本地双客户端加入方式；auto 自动加入，manual 保留手动选择局域网卡片')
 @click.option('--launch-timeout', cls=HostOption, type=click.IntRange(5,120), default=None, help='App 宿主进程/画中画确认等待秒数；不含世界加载')
 @click.argument('instance_prefix', required=False)
-def run_cmd(new, list, delete, force, clean_all, instance_prefix, no_gui, detach, mcs_auth=False, cppconfig=None, clients=1, background=None, launch_timeout=None, **engine_overrides):
+def run_cmd(new, list, delete, force, clean_all, instance_prefix, no_gui, detach, mcs_auth=False, cppconfig=None, clients=1, background=None, launch_timeout=None, join_mode=None, **engine_overrides):
     """游戏实例运行与管理
     
     可直接运行 'mcpy run' 启动最新实例，或使用选项管理实例。
@@ -89,6 +91,8 @@ def run_cmd(new, list, delete, force, clean_all, instance_prefix, no_gui, detach
         raise click.UsageError('run --json 需要 --detach')
     if clients != 1 and (list or delete or clean_all):
         raise click.UsageError('--clients 仅用于启动游戏')
+    if join_mode is not None and clients != 2:
+        raise click.UsageError('--join-mode 仅用于 --clients 2 的本地联机')
     world_config = take_world_options(engine_overrides, cppconfig)
     if world_config is not None and (not new or instance_prefix or list or delete or clean_all):
         raise click.UsageError('世界创建参数仅用于 --new，不覆盖已有实例')
@@ -121,13 +125,15 @@ def run_cmd(new, list, delete, force, clean_all, instance_prefix, no_gui, detach
         from ..mcstudio.network import configured_target
         target = configured_target(read_project(base_dir))
         if target:
+            if join_mode is not None:
+                raise click.UsageError('--join-mode 不用于外部服务器连接')
             if new or instance_prefix or world_config is not None:
                 raise click.UsageError('网络联调不支持世界创建参数')
             if mcs_auth:
                 raise click.UsageError('双客户端进服暂不支持双账号认证')
             return groups.start_network(base_dir, backend, target, engine_overrides,
                                         background=options['background'])
-        return groups.start_local(base_dir, backend, options)
+        return groups.start_local(base_dir, backend, options, join_mode=join_mode)
     recovered = False
     try:
         try:

{mcpywrap_core-0.6.2 → mcpywrap_core-0.6.3}/mcpywrap_core/engines/windows.py

@@ -8,7 +8,7 @@ class WindowsBackend(GameBackend):
     capabilities = ('local-worlds', 'network-sessions', 'status', 'logs', 'stop', 'py',
                     'runtime', 'runtime-ui', 'runtime-player', 'reload', 'watch',
                     'screenshot', 'key', 'mouse', 'input-sequence', 'mcs-auth', 'serve', 'project-ui', 'editor',
-                    'local-dual-client-manual')
+                    'local-dual-client-manual', 'local-dual-client-auto')
     setup_description = '请在 MC Studio 下载游戏引擎；使用 mcpy doctor 检查资源，可用 --engine-version 选择版本。'
 
     def debug_channel(self, data, write_log):
@@ -16,9 +16,25 @@ class WindowsBackend(GameBackend):
         self._world_ready = False
         self._ready_log_cursors = {}
         data['world_ready'] = False
-        return SafaiaChannel(write_log, ready=lambda: self._world_ready)
+        channel = SafaiaChannel(write_log, ready=lambda: self._world_ready)
+        self._joiner = None
+        if (data.get('network') or {}).get('join') == 'auto':
+            from ..runtime.windows_join import AutoJoin
+            self._joiner = channel.local_join = AutoJoin(data, channel).start()
+        return channel
 
     def refresh(self, data, channel):
+        changed = self._refresh_world(data, channel)
+        joiner = getattr(self, '_joiner', None)
+        if joiner:
+            state = joiner.status()
+            ready = state['state'] == 'joined'
+            if data.get('local_join') != state or data.get('world_ready') != ready:
+                data.update(local_join=state, world_ready=ready)
+                changed = True
+        return changed
+
+    def _refresh_world(self, data, channel):
         if self._world_ready: return False
         from pathlib import Path
         import re
@@ -74,7 +90,7 @@ class WindowsBackend(GameBackend):
     def prepare_guest(self, host):
         return None
 
-    def start_guest(self, host, *, project_dir, session_id, group, role, player, background=False):
+    def start_guest(self, host, *, project_dir, session_id, group, role, player, background=False, join_mode='manual'):
         from ..mcstudio import sessions
         from ..mcstudio.discovery import require_resources, Engine
         from ..runtime.deployment import Deployment
@@ -91,9 +107,15 @@ class WindowsBackend(GameBackend):
             version = record.get('fingerprint') if isinstance(record, dict) else None
             if not version:
                 raise EngineError('无法确认主机加载的版本，请重启联调组。', 'deployment_unavailable')
+        lan_target = None
+        if join_mode == 'auto':
+            from ..mcstudio.lan_window import helper
+            from ..runtime.windows_join import target
+            helper()
+            lan_target = target(host)
         data = sessions.start(project_dir, session_id=session_id, group=group, role=role, background=background,
                               network={'target': None, 'engine': engine, 'player': player,
-                                       'local_host': host['session'], 'join': 'manual',
+                                       'local_host': host['session'], 'join': join_mode, 'lan_target': lan_target,
                                        'deployment_fingerprint': version})
         return sessions.handoff(data)
 
@@ -125,15 +147,36 @@ class WindowsBackend(GameBackend):
             sessions.require_launch_requested(data['project'], data['session'])
             data['phase'] = 'prepared'
             sessions.save(directory/'session.json', data)
-            if data['network'].get('join') == 'manual':
+            if data['network'].get('join') in ('manual','auto'):
                 from ..runtime.groups import is_local_guest
                 from ..mcstudio.game import open_game
                 if not is_local_guest(data['project'], data):
                     raise ValueError('本地主机已退出或联调成员已变更，取消客机启动')
-                process = open_game(None, engine=engine, logging_ip='127.0.0.1',
+                launch_config = None
+                if data['network']['join'] == 'auto':
+                    from ..runtime.windows_join import bootstrap
+                    launch_config = str(bootstrap(data, engine, directory))
+                    sessions.save(directory/'session.json', data)
+                process = open_game(launch_config, engine=engine, logging_ip='127.0.0.1',
                                     logging_port=receiver.port, wait=False, use_system_color=False,
                                     capture_output=True, environment=environment,
                                     background=data.get('background', False))
+                if process and data['network']['join'] == 'auto':
+                    from ..mcstudio.processes import identity
+                    from ..mcstudio.lan_memory import adapt
+                    data['game'] = identity(process.pid)
+                    sessions.save(directory/'session.json', data)
+                    try:
+                        data['network']['lan_adapter'] = adapt(data['game'], data['network']['lan_target']['port'],
+                                                               cancelled=lambda: (directory/'stop').exists())
+                    except BaseException as error:
+                        process.terminate()
+                        process.wait(timeout=10)
+                        if isinstance(error, Exception):
+                            from .host import EngineError
+                            raise EngineError('Windows LAN 自动适配未完成：'+str(error), 'lan_adapter_unavailable',
+                                              '保留会话日志；不会使用其他版本地址重试。可停止客机后选择 --join-mode manual。') from error
+                        raise
             else:
                 from ..mcstudio.network import launch_network, ServerTarget
                 process = launch_network(engine, ServerTarget(**data['network']['target']),

mcpywrap_core-0.6.3/mcpywrap_core/mcstudio/lan_locator.py

@@ -0,0 +1,94 @@
+"""识别 NetherNet TransportConfiguration 的默认 LAN 端口，不保存版本地址表。"""
+from bisect import bisect_right
+from dataclasses import dataclass
+import re
+import struct
+
+
+class LocatorError(ValueError):
+    pass
+
+
+@dataclass(frozen=True)
+class PortSite:
+    instruction_rva: int
+    operand_rva: int
+    function_rva: int
+    expected: bytes
+
+
+def locate_port(image):
+    """image 提供 sections、functions 和 read(rva, size)，可用于静态夹具和活动映像。
+
+    从 Windows x64 展开表确定指令边界，再识别端口、广播周期及协议 magic
+    的同一栈对象初始化。必须恰好找到一处；不把 CALL 位移或数据中的 7551 当指令。
+    """
+    from capstone import Cs, CS_ARCH_X86, CS_MODE_64
+    from capstone.x86_const import X86_OP_IMM, X86_OP_MEM, X86_OP_REG
+    decoder = Cs(CS_ARCH_X86, CS_MODE_64)
+    decoder.detail = True
+    functions = sorted(image.functions)
+    starts = [start for start, end in functions]
+    seen, candidates = set(), []
+    for rva, size, executable in image.sections:
+        if not executable:
+            continue
+        code = image.read(rva, size)
+        for match in re.finditer(re.escape(struct.pack('<I', 7551)), code):
+            position = rva + match.start()
+            index = bisect_right(starts, position) - 1
+            if index < 0:
+                continue
+            start, end = functions[index]
+            if not start <= position < end or end-start > 32768 or start in seen:
+                continue
+            seen.add(start)
+            instructions = list(decoder.disasm(image.read(start, end-start), start))
+            if not instructions or instructions[-1].address + instructions[-1].size != end:
+                continue
+            for i, instruction in enumerate(instructions[:-1]):
+                operands = instruction.operands
+                if (instruction.mnemonic != 'mov' or len(operands) != 2 or
+                        operands[0].type != X86_OP_REG or operands[0].size != 4 or
+                        operands[1].type != X86_OP_IMM or operands[1].imm != 7551 or
+                        instruction.imm_size != 4):
+                    continue
+                store = instructions[i+1]
+                if (store.mnemonic != 'mov' or len(store.operands) != 2 or
+                        store.operands[0].type != X86_OP_MEM or store.operands[0].size != 2 or
+                        store.operands[1].type != X86_OP_REG):
+                    continue
+                # 本组配置的 port 在 magic 后 8 字节，interval 紧接 port 后 4 字节。
+                port = store.operands[0].mem
+                register = instruction.reg_name(operands[0].reg)
+                low_register = store.reg_name(store.operands[1].reg)
+                aliases = {'eax': 'ax', 'ebx': 'bx', 'ecx': 'cx', 'edx': 'dx',
+                           'esi': 'si', 'edi': 'di', **{'r%sd' % n: 'r%sw' % n for n in range(8,16)}}
+                if aliases.get(register) != low_register or store.reg_name(port.base) not in ('rsp','rbp') or port.index:
+                    continue
+                interval, magic, passed = False, False, False
+                magic_register = None
+                for following in instructions[i+2:i+35]:
+                    ops = following.operands
+                    if following.mnemonic == 'mov' and len(ops) == 2:
+                        if (ops[0].type == X86_OP_MEM and ops[0].mem.base == port.base and
+                                ops[0].mem.disp == port.disp+4 and ops[1].type == X86_OP_IMM and ops[1].imm == 2000):
+                            interval = True
+                        if ops[0].type == X86_OP_REG and ops[1].type == X86_OP_IMM and ops[1].imm == 0xdeadbeef:
+                            magic_register = following.reg_name(ops[0].reg)
+                        if (ops[0].type == X86_OP_MEM and ops[0].mem.base == port.base and
+                                ops[0].mem.disp == port.disp-8 and ops[1].type == X86_OP_REG and
+                                magic_register and following.reg_name(ops[1].reg) in
+                                (magic_register, magic_register[:-1] if magic_register.startswith('r') and magic_register.endswith('d') else 'r'+magic_register[1:])):
+                            magic = True
+                    if (following.mnemonic == 'lea' and len(ops) == 2 and
+                            ops[0].type == X86_OP_REG and following.reg_name(ops[0].reg) == 'rcx' and
+                            ops[1].type == X86_OP_MEM and ops[1].mem.base == port.base and
+                            ops[1].mem.disp == port.disp-8):
+                        passed = True
+                if interval and magic and passed:
+                    candidates.append(PortSite(instruction.address, instruction.address+instruction.imm_offset,
+                                               start, bytes(instruction.bytes)))
+    if len(candidates) != 1:
+        raise LocatorError('无法唯一识别 NetherNet LAN 配置初始化（候选数：%s）。' % len(candidates))
+    return candidates[0]

mcpywrap_core-0.6.3/mcpywrap_core/mcstudio/lan_memory.py

@@ -0,0 +1,142 @@
+"""Windows 本地客机的进程内 LAN 默认值适配；不修改磁盘引擎。"""
+from contextlib import contextmanager
+import ctypes as C
+from ctypes import wintypes as W
+import struct
+import time
+
+from .processes import checked_process
+from .lan_locator import LocatorError, locate_port
+
+
+class ProcessImage:
+    def __init__(self, identity):
+        import pefile
+        self.identity = identity
+        if not checked_process(identity):
+            raise LocatorError('游戏进程已退出。')
+        self.kernel = C.WinDLL('kernel32', use_last_error=True)
+        self.psapi = C.WinDLL('psapi', use_last_error=True)
+        k = self.kernel
+        k.OpenProcess.argtypes = [W.DWORD, W.BOOL, W.DWORD]
+        k.OpenProcess.restype = W.HANDLE
+        k.CloseHandle.argtypes = [W.HANDLE]
+        k.ReadProcessMemory.argtypes = [W.HANDLE, C.c_void_p, C.c_void_p, C.c_size_t, C.POINTER(C.c_size_t)]
+        k.WriteProcessMemory.argtypes = k.ReadProcessMemory.argtypes
+        k.VirtualProtectEx.argtypes = [W.HANDLE, C.c_void_p, C.c_size_t, W.DWORD, C.POINTER(W.DWORD)]
+        k.FlushInstructionCache.argtypes = [W.HANDLE, C.c_void_p, C.c_size_t]
+        self.psapi.EnumProcessModulesEx.argtypes = [W.HANDLE, C.POINTER(C.c_void_p), W.DWORD, C.POINTER(W.DWORD), W.DWORD]
+        self.handle = k.OpenProcess(0x438 | 0x800, False, identity['pid'])
+        if not self.handle:
+            raise C.WinError(C.get_last_error())
+        try:
+            modules = (C.c_void_p * 1024)()
+            needed = W.DWORD()
+            if not self.psapi.EnumProcessModulesEx(self.handle, modules, C.sizeof(modules), C.byref(needed), 3):
+                raise C.WinError(C.get_last_error())
+            self.base = modules[0]
+            self.limit = 65536
+            pe = pefile.PE(data=self.read(0, 65536), fast_load=True)
+            if pe.FILE_HEADER.Machine != 0x8664 or not 65536 <= pe.OPTIONAL_HEADER.SizeOfImage <= 1024**3:
+                raise LocatorError('自动联机仅支持可识别的 Windows x64 引擎映像。')
+            self.limit = pe.OPTIONAL_HEADER.SizeOfImage
+            # 加壳入口和可写数据不是引擎代码候选；只取映像主体的可执行节。
+            self.sections = [(s.VirtualAddress, s.Misc_VirtualSize, bool(s.Characteristics & 0x20000000))
+                             for s in pe.sections if s.Name.rstrip(b'\0') not in (b'.boot', b'.winlice', b'.reloc')]
+            directory = pe.OPTIONAL_HEADER.DATA_DIRECTORY[3]
+            if not directory.Size or directory.Size % 12 or directory.Size > 32*1024**2:
+                raise LocatorError('引擎缺少有效的 x64 展开表。')
+            self.functions = [(start, end) for start, end, unwind in struct.iter_unpack(
+                '<III', self.read(directory.VirtualAddress, directory.Size)) if 0 < start < end < self.limit]
+            if not self.functions:
+                raise LocatorError('引擎代码尚未解包或展开表不可识别。')
+        except BaseException:
+            self.close()
+            raise
+
+    def read(self, rva, size):
+        if rva < 0 or size < 0 or rva+size > self.limit:
+            raise LocatorError('引擎映像地址超出边界。')
+        buffer = C.create_string_buffer(size)
+        count = C.c_size_t()
+        if not self.kernel.ReadProcessMemory(self.handle, self.base+rva, buffer, size, C.byref(count)) or count.value != size:
+            raise LocatorError('引擎映像尚不可完整读取。')
+        return buffer.raw
+
+    @contextmanager
+    def suspended(self):
+        ntdll = C.WinDLL('ntdll')
+        ntdll.NtSuspendProcess.argtypes = [W.HANDLE]
+        ntdll.NtResumeProcess.argtypes = [W.HANDLE]
+        if not checked_process(self.identity) or ntdll.NtSuspendProcess(self.handle) < 0:
+            raise LocatorError('无法暂停本次游戏以原子更新 LAN 配置。')
+        try:
+            yield
+        finally:
+            if ntdll.NtResumeProcess(self.handle) < 0:
+                raise LocatorError('游戏恢复执行失败，需要停止本次客机。')
+
+    def patch(self, site, port):
+        if type(port) is not int or not 1 <= port <= 65535:
+            raise ValueError('无效的 LAN 端口')
+        with self.suspended():
+            if self.read(site.instruction_rva, len(site.expected)) != site.expected:
+                raise LocatorError('目标指令已变化，未写入。')
+            address = self.base+site.operand_rva
+            original = self.read(site.operand_rva, 4)
+            previous = W.DWORD()
+            if not self.kernel.VirtualProtectEx(self.handle, address, 4, 0x40, C.byref(previous)):
+                raise C.WinError(C.get_last_error())
+            try:
+                count = C.c_size_t()
+                replacement = struct.pack('<I', port)
+                if not self.kernel.WriteProcessMemory(self.handle, address, replacement, 4, C.byref(count)) or count.value != 4:
+                    raise LocatorError('LAN 端口写入失败。')
+                self.kernel.FlushInstructionCache(self.handle, address, 4)
+                if self.read(site.operand_rva, 4) != replacement:
+                    raise LocatorError('LAN 端口读回校验失败。')
+            except BaseException:
+                self.kernel.WriteProcessMemory(self.handle, address, original, 4, C.byref(count))
+                self.kernel.FlushInstructionCache(self.handle, address, 4)
+                raise
+            finally:
+                ignored = W.DWORD()
+                if not self.kernel.VirtualProtectEx(self.handle, address, 4, previous.value, C.byref(ignored)):
+                    raise LocatorError('无法恢复引擎内存页属性。')
+
+    def close(self):
+        if self.handle:
+            self.kernel.CloseHandle(self.handle)
+            self.handle = None
+
+
+def adapt(identity, port, cancelled=lambda: False, timeout=35):
+    """等待解包后按结构定位；失败由调用者结束自己刚创建的客机。"""
+    if port == 7551:
+        return {'strategy': 'engine-default', 'port': port, 'modified': False}
+    deadline = time.monotonic()+timeout
+    error = None
+    while time.monotonic() < deadline:
+        if cancelled() or not checked_process(identity):
+            raise LocatorError('客机启动已取消或进程退出。')
+        image = None
+        try:
+            image = ProcessImage(identity)
+            site = locate_port(image)
+        except (LocatorError, OSError) as exc:
+            error = exc
+        else:
+            # 一旦找到唯一候选，写入错误不重试，不允许重复变更未知状态。
+            try:
+                if cancelled():
+                    raise LocatorError('客机启动已取消，未写入。')
+                image.patch(site, port)
+                return {'strategy': 'nethernet-configuration-v1', 'port': port, 'modified': True,
+                        'instruction_rva': site.instruction_rva, 'function_rva': site.function_rva}
+            finally:
+                image.close()
+        finally:
+            if image:
+                image.close()
+        time.sleep(.1)
+    raise LocatorError('自动定位 LAN 配置失败：' + str(error))

mcpywrap_core-0.6.3/mcpywrap_core/mcstudio/lan_window.py

@@ -0,0 +1,35 @@
+"""后台采集菜单文字；不移动系统指针、不激活窗口。"""
+import hashlib
+import json
+import subprocess
+
+from .window import GameWindow
+
+
+def helper():
+    from ..host_assets import asset_directory
+    root = asset_directory('window_capture')
+    path = root/'mcpy-window-capture.exe'
+    manifest = json.loads((root/'manifest.json').read_text(encoding='utf-8'))
+    if manifest.get('ocr_protocol') != 1 or hashlib.sha256(path.read_bytes()).hexdigest() != manifest.get('executable_sha256'):
+        raise ValueError('自动加入需要新版 Windows 菜单识别组件；请更新完整 mcpywrap，或使用 --join-mode manual。')
+    return path
+
+
+def observe(game):
+    window = GameWindow(game)
+    try:
+        result = subprocess.run([str(helper()), '--hwnd',str(window.hwnd),'--ocr'],
+                                stdin=subprocess.DEVNULL,stdout=subprocess.PIPE,stderr=subprocess.PIPE,
+                                creationflags=subprocess.CREATE_NO_WINDOW,timeout=12)
+        window.validate_process()
+        if result.returncode:
+            raise ValueError('菜单识别不可用：'+result.stderr.decode('utf-8','replace'))
+        if len(result.stdout)>512*1024:
+            raise ValueError('菜单识别结果过大')
+        data=json.loads(result.stdout)
+        if data.get('protocol') != 1:
+            raise ValueError('菜单识别协议不兼容')
+        return data
+    finally:
+        window.close()

{mcpywrap_core-0.6.2 → mcpywrap_core-0.6.3}/mcpywrap_core/mcstudio/runtime_debug.py

@@ -310,6 +310,9 @@ class SafaiaChannel:
             self.serial.release()
 
     def close(self):
+        joiner = getattr(self, 'local_join', None)
+        if joiner:
+            joiner.stop.set()
         self.stop_event.set()
         with self.changed:
             if self.client:
@@ -321,6 +324,8 @@ class SafaiaChannel:
         for thread in (self.thread, self.discovery):
             if thread.is_alive():
                 thread.join(timeout=1)
+        if joiner:
+            joiner.close()
 
 
 class _ControlHandler(socketserver.BaseRequestHandler):
@@ -345,6 +350,8 @@ class _ControlHandler(socketserver.BaseRequestHandler):
                     group = membership(self.server.project, self.server.session)
                     if not group or not group.get('connection_verified') or request.get('kind') != 'python':
                         raise ValueError('客机尚未确认加入指定主机，或请求了未支持的资源热更')
+            if getattr(self.server.channel, 'joining', False) is True:
+                raise ValueError('客机正在自动加入，请等待连接校验完成后再执行调试操作。')
             if request.get('action') == 'execute':
                 options = {'condition': request['condition']} if request.get('condition') is not None else {}
                 if options and not hasattr(self.server.channel, 'submit'):

{mcpywrap_core-0.6.2 → mcpywrap_core-0.6.3}/mcpywrap_core/mcstudio/sessions.py

@@ -200,8 +200,8 @@ def handoff(data):
                                      '已有世界继续使用存档中的设置。')
     from ..engines.backend import get_backend
     result.update(get_backend(data.get('backend', 'windows')).handoff(data))
-    if data.get('network') and data['network'].get('join') == 'manual':
-        result.update(join='manual', local_host=data['network']['local_host'],
+    if data.get('network') and data['network'].get('join') in ('manual','auto'):
+        result.update(join=data['network']['join'], local_host=data['network']['local_host'],
                       connection_verified=False, addons_assembled=False,
                       engine_version=data['network']['engine']['version'])
     elif data.get('network'):

{mcpywrap_core-0.6.2 → mcpywrap_core-0.6.3}/mcpywrap_core/mobile_host/client.py

@@ -43,7 +43,7 @@ class Client:
         except (URLError, TimeoutError, OSError) as error:
             if isinstance(error, RemoteError): raise
             failure = RemoteError('无法连接 mcpy App；连接失败不足以区分服务关闭、进程退出或端口错误', 'host_unavailable',
-                                  hint='打开 mcpy://service/start 恢复开发连接；主动暂停的服务需在开发工具页重新开启。已提交的操作先查询原任务。')
+                                  hint='请用户手动恢复开发连接（mcpy://service/start）；不要自动调用唤起命令。主动暂停的服务需在“开发”页重新开启，已有操作先查询原任务。')
             failure.details = {'endpoint': self.endpoint, 'recovery_uri': 'mcpy://service/start',
                                'last_known_service': profiles.cached_service(self.profile), 'live_state': 'unavailable'}
             require_user(failure)
@@ -216,7 +216,7 @@ def pair(url, code, workspace, label='mcpy CLI', timeout=900):
         saved['expires'] = time.time()+900
         if resumable: profiles.write_private(receipt, saved)
     import sys
-    print('等待你允许连接：可直接点击 mcpy 弹出的确认卡或通知中的「允许连接」。没有提示时再打开 mcpy 的 开发工具页。', file=sys.stderr)
+    print('等待你允许连接：可直接点击 mcpy 弹出的确认卡或通知中的「允许连接」。没有提示时再打开 mcpy 的“开发”页。', file=sys.stderr)
     end = time.monotonic()+timeout
     while time.monotonic() < end:
         result = request(base+'/result', credentials)

{mcpywrap_core-0.6.2 → mcpywrap_core-0.6.3}/mcpywrap_core/mobile_host/intervention.py

@@ -13,14 +13,14 @@ def require_user(error, operation_id=None):
     if details.get('operation_state')!='waiting_user' and getattr(error,'code',None) not in USER_ACTION_CODES:
         return False
     offline=getattr(error,'code',None)=='host_unavailable'
-    message=('请在手机上手动打开 mcpy，在“开发工具”页确认开发连接已开启，并暂时保持前台；完成后告诉我。若切换应用后又断连，请在该页打开省电设置，小米选择“无限制”。'
+    message=('请在手机上手动打开 mcpy，在“开发”页确认开发连接已开启，连接恢复后可返回当前工具，再告诉我。若切换应用后又断连，请在该页打开省电设置，小米选择“无限制”。'
              if offline else
              '请在手机上手动切回 mcpy，继续这次启动或恢复游戏画面；完成后告诉我。')
     if not offline:
         message+='如果希望以后直接从开发工具启动，请在系统应用权限中允许 mcpy 的“后台弹出界面”，并检查画中画权限；各品牌入口可能不同。'
     if getattr(error,'code',None)=='device_locked': message='请先解锁手机。'+message
     instruction=('立即停止自动尝试，把 user_message 告诉用户并等待用户明确确认。'
-                 '不要自动 run、restart、重新构建、新建世界、循环轮询或尝试其他唤起/权限绕过方式。'
+                 '不要自动 run、restart、重新构建、新建世界、循环轮询或执行 android-open、am start、恢复 URI 或其他唤起/权限绕过方式。'
                  '收到用户确认后，只查询或恢复原任务；不要把用户未回复当作已处理。')
     details.update(needs_user_action=True,next_action='ask_user',retryable=False,
                    retry_policy='after_user_confirmation',user_message=message,agent_instruction=instruction)