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

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

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

mcpywrap_core-0.6.2/mcpywrap_core/_process_identity.py

@@ -0,0 +1,55 @@
+"""Process identity without requiring system-wide boot statistics on restricted Linux."""
+import os
+import sys
+from pathlib import Path
+import psutil
+
+
+def proc_stat(pid):
+    # comm may contain spaces and parentheses; numeric fields start after its final ')'.
+    raw = Path('/proc/%d/stat' % pid).read_text().rsplit(')', 1)[1].split()
+    return {'pid': pid, 'state': raw[0], 'parent': int(raw[1]), 'group': int(raw[2]), 'start_ticks': int(raw[19])}
+
+
+def identity(pid):
+    process = psutil.Process(pid)
+    try:
+        created = process.create_time()
+    except psutil.AccessDenied:
+        if not sys.platform.startswith('linux'):
+            raise
+        # Android and other restricted procfs mounts expose our per-process stat,
+        # but not /proc/stat (which psutil needs to convert ticks to wall-clock time).
+        stat = proc_stat(pid)
+        return {'pid': pid, 'start_ticks': stat['start_ticks'], 'executable': process.exe()}
+    return {'pid': pid, 'created_at': created, 'executable': process.exe()}
+
+
+def alive(record):
+    try:
+        if 'start_ticks' in record:
+            stat = proc_stat(record['pid'])
+            return stat['start_ticks'] == record['start_ticks'] and stat['state'] != 'Z'
+        process = psutil.Process(record['pid'])
+        return abs(process.create_time()-record['created_at']) < .01 and process.status() != psutil.STATUS_ZOMBIE
+    except (psutil.NoSuchProcess, FileNotFoundError, ProcessLookupError):
+        return False
+
+
+def proc_members(group, known):
+    """Inspect readable per-process records, never require visibility of other UIDs."""
+    rows = {}
+    for directory in Path('/proc').iterdir():
+        if not directory.name.isdigit(): continue
+        try: rows[int(directory.name)] = proc_stat(int(directory.name))
+        except (OSError, ValueError, IndexError): continue
+    owned = {record['pid'] for record in known.values() if alive(record)}
+    found = {pid for pid, row in rows.items() if row['group'] == group and row['state'] != 'Z'}
+    while True:
+        descendants = {pid for pid, row in rows.items() if row['parent'] in owned | found and row['state'] != 'Z'}
+        if descendants <= found: break
+        found |= descendants
+    for pid in found:
+        try: known[pid] = identity(pid)
+        except (psutil.NoSuchProcess, OSError): pass
+    return [record for record in known.values() if alive(record)]

{mcpywrap_core-0.6.0 → mcpywrap_core-0.6.2}/mcpywrap_core/_script_worker.py

@@ -10,17 +10,11 @@ import time
 import psutil
 
 
-def identity(pid):
-    p = psutil.Process(pid)
-    return {'pid': pid, 'created_at': p.create_time(), 'executable': p.exe()}
-
-
-def alive(record):
-    try:
-        p = psutil.Process(record['pid'])
-        return abs(p.create_time() - record['created_at']) < .01 and p.status() != psutil.STATUS_ZOMBIE
-    except psutil.NoSuchProcess:
-        return False
+# Also works when this supervisor is executed directly by absolute filename.
+try:
+    from ._process_identity import identity, alive, proc_members
+except ImportError:
+    from _process_identity import identity, alive, proc_members
 
 
 def save(path, data):
@@ -149,6 +143,8 @@ class WindowsJob:
 
 
 def members(process, known):
+    if any('start_ticks' in record for record in known.values()):
+        return proc_members(process.pid, known)
     try:
         for p in psutil.Process(process.pid).children(recursive=True):
             known[p.pid] = identity(p.pid)
@@ -229,7 +225,14 @@ def main():
         try:
             child = identity(process.pid)
         except psutil.ZombieProcess:
-            child = {'pid': process.pid, 'created_at': psutil.Process(process.pid).create_time(), 'executable': command[0]}
+            try:
+                child = {'pid': process.pid, 'created_at': psutil.Process(process.pid).create_time(), 'executable': command[0]}
+            except psutil.AccessDenied:
+                try:
+                    from ._process_identity import proc_stat
+                except ImportError:
+                    from _process_identity import proc_stat
+                child = {'pid': process.pid, 'start_ticks': proc_stat(process.pid)['start_ticks'], 'executable': command[0]}
         state.update(child=child, group=process.pid if os.name != 'nt' else None, state='running')
         known[process.pid] = child
         save(path, state)

mcpywrap_core-0.6.2/mcpywrap_core/_version.py

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

{mcpywrap_core-0.6.0 → mcpywrap_core-0.6.2}/mcpywrap_core/api.py

@@ -1,11 +1,13 @@
 """Versioned engineering API. All frontends call the same operation functions."""
 from pathlib import Path
+import click
 
 from . import __version__
 from .host import HOST_API, HostServices, host_scope, current_host
 
 CORE_API = 1
-OPERATIONS = ('resolve', 'build', 'package', 'sync')
+from .operations.project import OPTIONS
+OPERATIONS = ('resolve', 'build', 'package', 'sync', *OPTIONS)
 
 
 class Core:
@@ -20,16 +22,28 @@ class Core:
         """Execute or raise the original structured error; never invoke another core."""
         if operation not in OPERATIONS:
             raise ValueError('未知工程操作：' + str(operation))
-        allowed = {'resolve': set(), 'build': {'merge'}, 'package': {'merge'},
+        allowed = OPTIONS[operation] if operation in OPTIONS else {'resolve': set(), 'build': {'merge'}, 'package': {'merge'},
                    'sync': {'install', 'migrate_windows_lock'}}[operation]
-        if set(options) - allowed or any(type(value) is not bool for value in options.values()):
+        if set(options) - allowed or (operation not in OPTIONS and any(type(value) is not bool for value in options.values())):
             raise ValueError('无效的工程操作参数')
+        if operation in OPTIONS:
+            for name,value in options.items():
+                valid = (type(value) is bool if name=='effective' else
+                         isinstance(value,(list,tuple)) and all(isinstance(item,str) for item in value) if name=='args' else
+                         value is None or isinstance(value,str))
+                if not valid: raise ValueError('无效的工程操作参数：'+name)
+            if operation=='script.run' and not options.get('name'):
+                raise ValueError('运行项目脚本需要 name')
         project = Path(project).expanduser().resolve()
-        if not project.is_dir() or not (project/'pyproject.toml').is_file():
+        if not project.is_dir() or (operation != 'init' and not (project/'pyproject.toml').is_file()):
             raise ValueError('未找到项目 pyproject.toml：' + str(project))
         from .command_context import project_scope
         with host_scope(self.host), project_scope(project) as context:
-            if operation == 'resolve':
+            if operation in OPTIONS:
+                from .operations.project import execute
+                context.non_interactive = True
+                result = execute(operation, project, options)
+            elif operation == 'resolve':
                 from .dependencies import DependencyService
                 manager = DependencyService(project).resolve()
                 result = {'project': str(project), 'dependencies': [
@@ -60,10 +74,10 @@ class Core:
             if request.get('operation') == 'describe':
                 return {'ok': True, 'result': self.describe()}
             options = request.get('options', {})
-            if not isinstance(options, dict) or not isinstance(request.get('project'), str):
+            if not isinstance(options, dict) or not all(isinstance(key,str) for key in options) or not isinstance(request.get('project'), str):
                 raise ValueError('无效的工程请求')
             result = self.execute(request.get('operation'), request['project'], **options)
             return {'ok': True, 'result': result, 'core': self.describe()}
-        except (ValueError, OSError) as error:
-            return {'ok': False, 'error': str(error), 'code': getattr(error, 'code', 'operation_failed'),
+        except (ValueError, OSError, click.ClickException) as error:
+            return {'ok': False, 'error': error.format_message() if isinstance(error,click.ClickException) else str(error), 'code': getattr(error, 'code', 'operation_failed'),
                     'hint': getattr(error, 'hint', None), 'details': getattr(error, 'details', {})}

{mcpywrap_core-0.6.0 → mcpywrap_core-0.6.2}/mcpywrap_core/builders/dependency_manager.py

@@ -3,6 +3,7 @@ import hashlib
 import json
 import re
 from importlib import metadata
+from ..host import distribution, marker_environment
 from functools import cached_property
 from pathlib import Path
 from urllib.parse import urlsplit
@@ -73,7 +74,7 @@ class DependencyManager:
 
     def find_dependency_path(self, package_name):
         try:
-            dist = metadata.distribution(Requirement(package_name).name)
+            dist = distribution(Requirement(package_name).name)
         except (metadata.PackageNotFoundError, InvalidRequirement):
             return None
         direct = dist.read_text('direct_url.json')
@@ -118,11 +119,11 @@ class DependencyManager:
                     requirement = Requirement(entry.value)
                 except InvalidRequirement as exc:
                     raise DependencyError(f'无效的 Python 包声明: {entry.value}') from exc
-                if requirement.marker and not requirement.marker.evaluate():
+                if requirement.marker and not requirement.marker.evaluate(environment=marker_environment()):
                     self._status(source, entry, 'inactive', '当前工具 Python 环境不满足环境标记，未启用；不代表游戏兼容性。')
                     continue
                 try:
-                    dist = metadata.distribution(requirement.name)
+                    dist = distribution(requirement.name)
                 except metadata.PackageNotFoundError:
                     self._missing(source, entry.value, '尚未安装')
                     continue

{mcpywrap_core-0.6.0 → mcpywrap_core-0.6.2}/mcpywrap_core/builders/project_builder.py

@@ -93,7 +93,9 @@ class AddonProjectBuilder:
                 staged_addon = AddonsPack(self.project_name, stage)
                 for kind in ('behavior', 'resource'):
                     setattr(staged_addon, kind + '_pack_dir', str(stage / Path(getattr(self.target_addon, kind + '_pack_dir')).name))
-                assemble_addon(self.packs, staged_addon)
+                from ..operations.input_snapshot import stable_inputs
+                with stable_inputs(self.dependency_manager):
+                    assemble_addon(self.packs, staged_addon)
                 if target.exists():
                     _replace_with_retry(target, backup)
                 try:

{mcpywrap_core-0.6.0 → mcpywrap_core-0.6.2}/mcpywrap_core/cli.py

@@ -7,7 +7,7 @@ from .command_context import OperationGroup, configure_context
 
 COMMANDS = {
     name: (name + '_cmd', name + '_cmd') for name in
-    ('modsdk', 'init', 'add', 'remove', 'build', 'dev', 'package', 'publish',
+    ('host', 'skill', 'modsdk', 'init', 'add', 'remove', 'build', 'dev', 'package', 'publish',
      'mod', 'run', 'connect', 'edit', 'ui', 'doctor', 'engine', 'sync', 'serve', 'record', 'script', 'deployment')
 }
 COMMANDS.update({name: ('session_cmd', name + '_cmd') for name in ('status', 'logs', 'stop', 'restart')})

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

@@ -86,6 +86,16 @@ def require_project():
         raise click.ClickException('未找到 pyproject.toml；请先执行 mcpy init --type addon 或 --type map')
 
 
+def restart_handoff(result, previous):
+    if not isinstance(result,dict) or not previous: return result
+    current=result.get('session')
+    if current and current!=previous:
+        result=dict(result,previous_session=previous,session_changed=True)
+        message='会话已更换；后续日志、截图和调试请使用 --session '+current+'。旧会话记录仍保留。'
+        result['hint']=((result.get('hint') or '')+' '+message).strip()
+    return result
+
+
 class OperationCommand(click.Command):
     def __init__(self, *args, local_only=False, **kwargs):
         self.local_only = local_only
@@ -94,10 +104,25 @@ class OperationCommand(click.Command):
                                         help='输出单个 JSON 结果'))
 
     def invoke(self, ctx):
+        try:
+            result=self._invoke_operation(ctx)
+        except (ValueError,OSError) as error:
+            if ctx.info_name=='restart' and getattr(error,'details',None):
+                error.details=restart_handoff(error.details,ctx.params.get('session'))
+                if error.details.get('session_changed'):
+                    error.hint=((getattr(error,'hint',None) or '')+' '+error.details['hint']).strip()
+            raise
+        return restart_handoff(result,ctx.params.get('session')) if ctx.info_name=='restart' else result
+
+    def _invoke_operation(self, ctx):
         ctx.params.pop('json_output', None)
         if os.environ.get('_MCPY_SCRIPT_CHAIN') and ctx.info_name in ('run', 'build', 'package', 'dev', 'restart', 'edit', 'sync', 'add', 'remove'):
             from .project_scripts import reject_recursion
             reject_recursion()
+        from .mobile_host.routing import route
+        routed, result = route(ctx)
+        if routed:
+            return result
         if self.local_only or (ctx.parent and ctx.parent.info_name == 'engine'):
             return super().invoke(ctx)
         from .remote.client import routed_command

{mcpywrap_core-0.6.0 → mcpywrap_core-0.6.2}/mcpywrap_core/commands/connect_cmd.py

@@ -4,17 +4,19 @@ import click
 from ..command_context import OperationCommand
 from ..mcstudio.discovery import engine_options
 from ..mcstudio.network import ServerTarget
+from ..runtime.window_policy import window_options, resolve_background
 
 
 @click.command(cls=OperationCommand)
 @engine_options
+@window_options
 @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 身份')
 @click.option('--detach', is_flag=True, help='后台连接并返回游戏会话；JSON 必须指定')
 @click.option('--clients', type=click.IntRange(1, 2), default=1, show_default=True)
 @click.option('--request-id', help='远程启动的 32 位十六进制请求 ID，用于找回或重试同一请求')
-def connect_cmd(host, port, mcs_auth=False, detach=False, request_id=None, clients=1, **engine_overrides):
+def connect_cmd(host, port, mcs_auth=False, detach=False, request_id=None, clients=1, background=None, **engine_overrides):
     """尝试连接服务器；前台采集日志，Ctrl+C 结束本次游戏。
 
     默认不读取登录身份；--mcs-auth 要求 MCS 已登录及本机桥接可用。
@@ -26,21 +28,22 @@ def connect_cmd(host, port, mcs_auth=False, detach=False, request_id=None, clien
     from ..engines.host import EngineError
     backend = get_backend()
     target = ServerTarget(host, port, 'mcs' if mcs_auth else 'none')
+    background = resolve_background(background, detach=detach)
     if clients == 2:
         from ..runtime import groups
         from ..command_context import project_dir, json_output
         if json_output() and not detach:
             raise click.UsageError('connect --json 需要 --detach')
-        result = groups.start_network(project_dir(), backend, target, engine_overrides)
+        result = groups.start_network(project_dir(), backend, target, engine_overrides, background=background)
         if detach or result.get('ok') is False:
             return result
         from ..engines.tui import watch_group
         return watch_group(project_dir(), result)
     try:
-        return backend.connect(target, engine_overrides=engine_overrides, detach=detach)
+        return backend.connect(target, engine_overrides=engine_overrides, detach=detach, background=background)
     except EngineError as error:
         if error.code != 'setup_required' or not backend.managed_install: raise
         from .engine_cmd import perform_install
         click.echo('首次运行：自动下载并准备本地游戏环境…', err=True)
         perform_install()
-        return backend.connect(target, engine_overrides=engine_overrides, detach=detach)
+        return backend.connect(target, engine_overrides=engine_overrides, detach=detach, background=background)

{mcpywrap_core-0.6.0 → mcpywrap_core-0.6.2}/mcpywrap_core/commands/desktop_cmd.py

@@ -6,6 +6,10 @@ from ..command_context import OperationCommand, project_dir
 
 
 def output_path(value):
+    if value is None:
+        import datetime
+        import uuid
+        value = project_dir() / 'captures' / ('game-'+datetime.datetime.now().strftime('%Y%m%d-%H%M%S')+'-'+uuid.uuid4().hex[:8]+'.png')
     path = Path(value).expanduser().resolve()
     if path.suffix.lower() != '.png' or path.exists():
         raise ValueError('输出必须是尚不存在的 .png 文件')
@@ -27,7 +31,7 @@ class KeyCommand(OperationCommand):
 
 @click.command(cls=OperationCommand)
 @click.option('--session', required=True)
-@click.option('--output', required=True, help='本机 PNG 路径，不覆盖已有文件')
+@click.option('--output', help='本机 PNG 路径，默认保存到作品 captures/，不覆盖已有文件')
 @click.option('--background-only', is_flag=True, help='仅后台捕获；失败不激活游戏或回退到前台')
 def screenshot_cmd(session, output, background_only=False):
     """保存游戏 PNG；macOS 由 Launcher 按需读帧，远程模式下载 Windows 截图。"""

mcpywrap_core-0.6.2/mcpywrap_core/commands/host_cmd.py

@@ -0,0 +1,68 @@
+"""Pair a standard mcpy installation with a local application host."""
+from pathlib import Path
+import click
+from ..command_context import OperationCommand, project_dir
+from ..mobile_host import profiles
+from ..mobile_host.client import Client, pair
+
+@click.group()
+def host_cmd():
+    """管理本机 App 连接和共享工作区。"""
+
+@host_cmd.command('pair', cls=OperationCommand, local_only=True)
+@click.option('--url', default='http://127.0.0.1:17653', show_default=True)
+@click.option('--code', required=True, help='App 中短时有效的配对码')
+@click.option('--workspace', required=True, type=click.Path(exists=True, file_okay=False))
+@click.option('--label', default='mcpy CLI')
+def pair_cmd(url, code, workspace, label):
+    return pair(url, code, workspace, label)
+
+@host_cmd.command('status', cls=OperationCommand, local_only=True)
+@click.option("--operation",help="查询原任务，避免重复发送修改操作")
+@click.option('--recent', is_flag=True, help='列出本客户端保存的请求 ID（App 离线也可用）')
+@click.option('--binding-only',is_flag=True,help='只读当前工作区的本地绑定，不访问任何宿主')
+def status_cmd(operation, recent, binding_only=False):
+    records=profiles.read()
+    selected=profiles.select(project_dir())
+    if binding_only:
+        if operation or recent: raise click.UsageError('--binding-only 不与 --operation 或 --recent 同用')
+        return dict(paired=selected is not None,bound_for_project=selected is not None,
+                    **({'endpoint':selected['endpoint'],'workspace':selected['workspace']} if selected else {}))
+    record = selected or (records[0] if len(records)==1 else None)
+    if not record: return {'paired': False, 'hint': '在 App 的开发工具页面开始连接'}
+    if recent:
+        from ..mobile_host.receipts import Receipts
+        return {'operations': Receipts(record).recent()}
+    if operation:
+        if len(operation)!=64 or any(c not in '0123456789abcdef' for c in operation): raise ValueError('无效操作 ID')
+        return Client(record).request('GET','/operations/'+operation)
+    from ..remote.protocol import RemoteError
+    binding = dict(paired=True, bound_for_project=profiles.select(project_dir()) is not None,
+                   endpoint=record['endpoint'], workspace=record['workspace'])
+    try:
+        return dict(Client(record).capabilities(), **binding)
+    except RemoteError as error:
+        error.details = dict(getattr(error, 'details', {}) or {}, **binding)
+        raise
+
+@host_cmd.command('disconnect', cls=OperationCommand, local_only=True)
+@click.option('--offline', is_flag=True, help='App 不可达时仅删除本地连接；仍需在 App 撤销授权')
+def disconnect_cmd(offline):
+    records = profiles.read()
+    record = profiles.select(project_dir()) or (records[0] if len(records)==1 else None)
+    if not record:
+        if records: raise ValueError('有多个连接，请用 --project 指定要断开的工作区')
+        return {'paired': False}
+    if not offline: Client(record).request('POST', '/clients/revoke', {})
+    profiles.unbind(record['workspace'])
+    return {'paired': False, 'revoked': not offline}
+
+
+@host_cmd.command('resume', cls=OperationCommand, local_only=True)
+@click.option('--operation', required=True, help='原操作 ID；仅恢复等待和提交已有准备结果')
+def resume_cmd(operation):
+    records = profiles.read()
+    record = profiles.select(project_dir()) or (records[0] if len(records) == 1 else None)
+    if not record:
+        raise ValueError('请先选择已配对的工作区')
+    return Client(record).resume(operation)

{mcpywrap_core-0.6.0 → mcpywrap_core-0.6.2}/mcpywrap_core/commands/modsdk_cmd.py

@@ -6,14 +6,18 @@ from ..minecraft.netease_modsdk import get_available_versions, download_and_inst
 
 @click.command(cls=OperationCommand)
 @click.option('--list', 'list_versions', is_flag=True)
+@click.option('--offline', is_flag=True, help='仅查询缓存的版本目录')
+@click.option('--refresh', is_flag=True, help='联网刷新版本目录，整体最多等待 12 秒')
 @click.option('--version', help='安装指定版本')
 @click.option('--latest', is_flag=True, help='显式选择最新版本')
 @click.option('--inspect', 'inspect_only', is_flag=True, help='只读检查目标 Python 与已安装补全库，无网络')
 @click.option('--python', 'python_path', type=click.Path(dir_okay=False), help='开发环境 Python 可执行文件绝对路径，不解析虚拟环境链接')
 @click.option('--expected-environment', help='安装前后核验 --inspect 返回的环境 identity')
-def modsdk_cmd(list_versions, version, latest, inspect_only, python_path, expected_environment):
+def modsdk_cmd(list_versions, version, latest, inspect_only, python_path, expected_environment, offline=False, refresh=False):
     """管理开发环境 ModSDK 补全库；--python 定向安装，不安装到游戏。"""
     from ..minecraft.modsdk_environment import inspect_environment, install_environment
+    if offline and refresh: raise click.UsageError('--offline 与 --refresh 不能同时使用')
+    if (offline or refresh) and not list_versions: raise click.UsageError('--offline/--refresh 只用于 --list')
     if inspect_only:
         if list_versions or version or latest or expected_environment:
             raise click.UsageError('--inspect 不能与安装/版本列表选项同时使用')
@@ -27,11 +31,15 @@ def modsdk_cmd(list_versions, version, latest, inspect_only, python_path, expect
         raise click.UsageError('--list、--version、--latest 不能同时使用')
     if not any((list_versions, version, latest)) and non_interactive():
         raise click.UsageError('请指定 --list、--version 或 --latest')
+    if list_versions:
+        from ..minecraft.modsdk_versions import catalog
+        result = catalog(offline=offline,refresh=refresh)
+        if not result['versions']:
+            return dict(result, ok=False, code='sdk_catalog_unavailable', error='没有可用的 SDK 版本目录')
+        return result
     versions = get_available_versions()
     if not versions:
         raise click.ClickException('无法获取 ModSDK 版本，请检查网络')
-    if list_versions:
-        return {'versions': versions}
     if not version:
         version = versions[-1] if latest else click.prompt('SDK 版本', type=click.Choice(versions), default=versions[-1])
     if python_path:

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

@@ -2,8 +2,10 @@
 import click
 from ..command_context import OperationCommand, project_dir as current_project, non_interactive, require_project
 from ..config import config_exists
+from ..mobile_host.options import HostOption
 from ..mcstudio.discovery import engine_options
 from ..mcstudio.runtime_cppconfig import creation_settings, RULE_LABELS
+from ..runtime.window_policy import window_options, resolve_background
 
 WORLD_CHOICES = {
     'world_type': {'infinite': 1, 'flat': 2},
@@ -55,6 +57,7 @@ def take_world_options(arguments, cppconfig=None):
 @click.command(cls=OperationCommand)
 @world_options
 @engine_options
+@window_options
 @click.option("--no-gui", is_flag=True, help="不显示调试小窗；适用于 AI、脚本或纯终端操作")
 @click.option("--detach", is_flag=True, help="后台运行并返回游戏会话")
 @click.option('--mcs-auth', is_flag=True, help='本次单人测试或网络连接使用已登录的 MC Studio 身份')
@@ -67,8 +70,9 @@ def take_world_options(arguments, cppconfig=None):
 @click.option('--clean-all', is_flag=True, help='清空所有游戏实例')
 @click.option('--clients', type=click.IntRange(1, 2), default=1, show_default=True,
               help='本机玩家客户端数量；本地双客户端需在客户端 2 手动点击目标局域网卡片加入')
+@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, **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, **engine_overrides):
     """游戏实例运行与管理
     
     可直接运行 'mcpy run' 启动最新实例，或使用选项管理实例。
@@ -78,6 +82,7 @@ def run_cmd(new, list, delete, force, clean_all, instance_prefix, no_gui, detach
     不装配本地 Mod，不保证服务器接受连接。网络模式前台采集日志，
     Ctrl+C 结束本次网络游戏；--detach 返回可查询、操作和停止的会话。
     """
+    if launch_timeout is not None: raise click.UsageError('当前执行目标不支持 --launch-timeout')
     base_dir = str(current_project())
     from ..command_context import json_output
     if clients == 2 and json_output() and not detach:
@@ -107,7 +112,8 @@ def run_cmd(new, list, delete, force, clean_all, instance_prefix, no_gui, detach
         from ..ui.run_session import show_session_window
     options = dict(new=new, listing=list, delete=delete, force=force, clean_all=clean_all,
                    instance_prefix=instance_prefix, no_gui=True, detach=detach or show_debug,
-                   mcs_auth=mcs_auth, overrides=engine_overrides, world_config=world_config)
+                   mcs_auth=mcs_auth, overrides=engine_overrides, world_config=world_config,
+                   background=resolve_background(background, no_gui=no_gui, detach=detach))
     def perform():
         if clients == 1:
             return backend.run(base_dir, **options)
@@ -119,7 +125,8 @@ def run_cmd(new, list, delete, force, clean_all, instance_prefix, no_gui, detach
                 raise click.UsageError('网络联调不支持世界创建参数')
             if mcs_auth:
                 raise click.UsageError('双客户端进服暂不支持双账号认证')
-            return groups.start_network(base_dir, backend, target, engine_overrides)
+            return groups.start_network(base_dir, backend, target, engine_overrides,
+                                        background=options['background'])
         return groups.start_local(base_dir, backend, options)
     recovered = False
     try:

{mcpywrap_core-0.6.0 → mcpywrap_core-0.6.2}/mcpywrap_core/commands/script_cmd.py

@@ -1,7 +1,7 @@
 """Explicit local project scripts, separate from game run and runtime Python."""
 import click
 from ..command_context import OperationCommand, project_dir, require_project
-from ..project_scripts import configuration, operation
+from ..project_scripts import operation
 
 
 @click.group()
@@ -14,21 +14,9 @@ def script_cmd():
 def list_cmd(effective=False):
     """只读列出脚本与生命周期绑定。"""
     require_project()
-    scripts, hooks = configuration(project_dir())
-    result = {'scripts': [{'name': name, 'command': spec['command'], 'timeout': spec['timeout'],
-                         'hooks': [event for event, names in hooks.items() if name in names]}
-                        for name, spec in scripts.items()]}
     from ..command_context import json_output
-    if json_output() and not effective:
-        return result
-    from ..consumer_prepare import PreparationPlan, EVENTS
-    plan = PreparationPlan(project_dir(), inspect_only=True)
-    result.update(plan.inspect())
-    result['execution_order'] = {event: [{'kind': 'root', 'name': name} for name in hooks.get(event, [])] +
-                               [{'kind': 'consumer_prepare', 'provider': p['id'], 'name': p['name']}
-                                for p in plan.enabled] for event in EVENTS}
-    result['execution_order']['before_archive'] = [
-        {'kind': 'root', 'name': name} for name in hooks.get('before_archive', [])]
+    from ..project_scripts import describe_scripts
+    result = describe_scripts(project_dir(), effective=effective or not json_output())
     if json_output():
         return result
     for script in result['scripts']:

{mcpywrap_core-0.6.0 → mcpywrap_core-0.6.2}/mcpywrap_core/commands/session_cmd.py

@@ -2,6 +2,7 @@
 import click
 from ..command_context import OperationCommand, project_dir, json_output
 from ..mcstudio import sessions
+from ..mobile_host.options import HostOption, LogSource
 
 
 @click.command(cls=OperationCommand, name='status')
@@ -26,21 +27,42 @@ def status_cmd(session, list_sessions, group=None):
 @click.option('--session')
 @click.option('--group')
 @click.option('--tail', type=click.IntRange(0, 10000), default=100, show_default=True)
-@click.option('--source', type=click.Choice(['game', 'engine', 'worker', 'all']), default='game', show_default=True)
+@click.option('--source', type=LogSource(), default='game', show_default=True)
 @click.option('--follow', is_flag=True, help='增量跟随日志，结束订阅不停止游戏（仅本机）')
 @click.option('--format', 'output_format', type=click.Choice(['text', 'jsonl']), default='text', show_default=True)
-def logs_cmd(session, tail, source, group=None, follow=False, output_format='text'):
+@click.option('--filter', 'contains', type=click.STRING, help='区分大小写的字面文本匹配，先过滤再取 tail')
+@click.option('--summary', is_flag=True, help='统计扫描范围内完全相同的消息，不推断错误等级')
+@click.option('--since-ms', cls=HostOption, type=click.IntRange(min=0), help='起始 Unix 毫秒时间（需要宿主提供带时间戳日志）')
+@click.option('--until-ms', cls=HostOption, type=click.IntRange(min=0), help='截止 Unix 毫秒时间（需要宿主提供带时间戳日志）')
+def logs_cmd(session, tail, source, group=None, follow=False, output_format='text', contains=None, summary=False, since_ms=None, until_ms=None):
     """读取日志快照，或使用 --follow 持续接收增量日志。"""
     target(session, group)
+    if source in ('client','server') or since_ms is not None or until_ms is not None:
+        raise click.UsageError('本地文本日志未提供可靠端侧/时间戳；这些筛选需支持结构化日志的宿主')
+    if summary and follow:
+        raise click.UsageError('--summary 用于有限日志快照，不与 --follow 同用')
     if follow:
         if json_output():
             raise click.UsageError('--follow 是持续流；使用 --format jsonl，不加 --json')
         from ..mcstudio.log_stream import follow as events
         import json
+        from ..mcstudio.log_query import StreamFilter
+        filters = {}
         from contextlib import closing
         try:
-            with closing(events(project_dir(), session=session, group=group, source=source, tail=tail)) as stream:
+            with closing(events(project_dir(), session=session, group=group, source=source, tail=tail, **({"contains":contains} if contains is not None else {}))) as stream:
                 for item in stream:
+                    if item.get('event') == 'reset': filters.pop((item.get('session'),item.get('source')),None)
+                    if item.get('event') == 'log' and contains is not None:
+                        key=(item.get('session'),item.get('source'))
+                        item=dict(item,text=filters.setdefault(key,StreamFilter(contains)).feed(item['text']))
+                        if not item['text']: continue
+                    if item.get('event') == 'end':
+                        for (sid,name), selection in filters.items():
+                            remaining=selection.feed('',final=True)
+                            if remaining:
+                                if output_format=='jsonl': click.echo(json.dumps({'event':'log','session':sid,'source':name,'text':remaining},ensure_ascii=True))
+                                else: click.echo('['+sid[:8]+' '+name+'] '+remaining,nl=False)
                     if output_format == 'jsonl':
                         click.echo(json.dumps(item, ensure_ascii=True))
                     elif item['event'] == 'log':
@@ -48,6 +70,24 @@ def logs_cmd(session, tail, source, group=None, follow=False, output_format='tex
         except KeyboardInterrupt:
             pass
         return
+    if contains is not None or summary:
+        if output_format != 'text' or tail == 0: raise click.UsageError('日志快照需要 --tail 1..10000 和 --format text')
+        from ..mcstudio.log_query import snapshot
+        if group:
+            from ..runtime.groups import read
+            targets=[member['session'] for member in read(project_dir(),group)['members'] if member.get('session')]
+        else: targets=[session]
+        streams=[]
+        for sid in targets:
+            directory=sessions.session_path(project_dir(),sid)
+            if not (directory/'session.json').is_file(): raise ValueError('会话不存在')
+            for name in (('game','engine','worker') if source=='all' else (source,)):
+                streams.append(dict(snapshot(directory/(name+'.log'),contains=contains,tail=tail,summary=summary),session=sid,source=name))
+        if json_output():
+            return streams[0] if len(streams)==1 else {'streams':streams}
+        from ..mcstudio.log_query import show_snapshot
+        show_snapshot({'streams':streams},summary)
+        return
     if source == 'all' or output_format != 'text' or tail == 0:
         raise click.UsageError('--source all、--format jsonl 和 --tail 0 仅用于 --follow')
     if group:
@@ -85,8 +125,10 @@ def target(session, group):
 @click.command(cls=OperationCommand, name='restart')
 @click.option('--session')
 @click.option('--group')
-def restart_cmd(session, group):
+@click.option('--launch-timeout', cls=HostOption, type=click.IntRange(5,120), default=None, help='App 宿主启动确认等待秒数')
+def restart_cmd(session, group, launch_timeout=None):
     """重试指定成员，或重新运行整个联调组。"""
+    if launch_timeout is not None: raise click.UsageError('当前执行目标不支持 --launch-timeout')
     from ..runtime import groups
     from ..command_context import remote_url
     if remote_url():