mcpywrap 0.4.2__tar.gz → 0.4.4__tar.gz

{mcpywrap-0.4.2 → mcpywrap-0.4.4}/CHANGELOG.md

@@ -1,5 +1,20 @@
 # 更新记录
 
+## 0.4.4
+
+- 修复 Windows 与 macOS 之间同步 Git 依赖时的源码校验失败：获取源码时禁用宿主 Git 的换行、编码与过滤转换，统一保留固定提交中的文件字节。
+- `mcpy sync` 按固定提交直接重新计算 lock 摘要，不改变依赖版本，不再创建锁备份或执行专门迁移；未被修改的旧安装副本自动重建，缓存损坏与手动修改仍会报错。
+- Git 项目依赖和旧代码库使用独立的新源码缓存，首次同步重新获取固定提交，后续可离线复用。补充跨 Git 配置、旧 Windows 缓存、二进制文件与重复同步稳定性的回归测试。
+- Windows 启动时增加原生 HUD 布局日志识别，避免 Python 启动日志异常导致世界就绪状态无法确认。
+- 修复 Mod 模板窗口关闭后未释放对象、在新版 PySide6 下退出进程时可能崩溃的问题。
+
+## 0.4.3
+
+- macOS 新增无认证服务器连接，复用 `mcpy connect` 与项目 `[tool.mcpywrap.server]` 的 `run` 入口、cppconfig、日志、偏好和退出机制，不装配本地 Mod 或创建本地世界实例。
+- 配套 macOS 运行包 0.4.3 使用现有引擎 Python 入口进服，无新增游戏二进制补丁；首次安装自动取得配套运行包，旧包给出明确升级命令，保留已有世界绑定。
+- 网络会话仅开放客户端 Python；在 worker 中拒绝服务端 Python 和本地 Mod 热更。macOS 初次连接超时会提示失败并回收游戏，进入 HUD 后记录连接验证结果。
+- Skill 补充离线服务器条件、旧运行包升级、状态验证及客户端调试边界。已在 macOS 26.6.2 / APK 3.10.100.299889 上通过本机 Nemisys + SynapseAPI + Nukkit 验证 connect、项目 run、Python 与失败清理；不包含 MCS/MPay 登录、外部 HTTP 资源包或新版统一输入的验收。
+
 ## 0.4.2
 
 - 新增统一 `runtime input capabilities/observe/run/status/cancel/stop` 与 `mcpy.input`。键盘组合、独立边沿、玩家与单节点 UI 操作共用 JSON steps、动作注册表、排时和清理；单次 key 快捷命令只生成同一份计划。

{mcpywrap-0.4.2/mcpywrap.egg-info → mcpywrap-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcpywrap
-Version: 0.4.2
+Version: 0.4.4
 Summary: A wrapper for Minecraft China Edition Addons management
 Author-email: boybook <boybook@easecation.net>
 License-Expression: MIT

{mcpywrap-0.4.2 → mcpywrap-0.4.4}/docs/game-backends.md

@@ -19,7 +19,7 @@ WindowsBackend 调用原有 MC Studio 发现、cppconfig 和 Safaia 流程，保
 
 macOS 首次 mcpy run 自动从内置发布源安装原生运行包和官方 APK，进度在 stderr；也可提前执行 mcpy engine install。--catalog / --apk 是高级覆盖选项。交互式 run 显示共用调试小窗，ui 打开完整管理页；--no-gui / --detach / --json / --non-interactive 抑制调试小窗；Windows 保持手动安装 MC Studio。默认资源目录 ~/Library/Application Support/mcpy，可设置 MCPY_ENGINE_HOME、MCPY_RUNTIME_CATALOG。
 
-macOS 当前只支持离线 Addon 世界，不支持 Map、服务器连接、MCS 登录或 Windows 桌面截图/键鼠/录像；需要这些能力时显式使用 Windows 远程端。最低 macOS 13.0，实际游戏只在 26.6.2 验证。运行包尚为 ad-hoc 签名、公证待完成。
+macOS 支持离线 Addon 世界；无认证服务器连接需 CLI 0.4.3+ 与运行包 0.4.3+ 配套，运行包须声明 network_connect_protocol=1（旧 0.4.0 运行包需要显式升级）。connect 与配置了 server 的 run 共用 cppconfig、会话、日志及退出；网络会话仅支持客户端调试，不装配本地 Mod。macOS 不支持 Map、MCS 登录或 Windows 桌面截图/键鼠/录像；需要这些能力时显式使用 Windows 远程端。最低 macOS 13.0，实际游戏只在 26.6.2 验证。运行包尚为 ad-hoc 签名、公证待完成。
 
 图形界面的会话操作集中在 ui/session_controller.py；主界面和小窗仅使用共用 SessionControls/PythonConsole 与 LogView。小窗不再另起 Studio TCP 接收器，详见 [共用日志界面](shared-log-ui.md)。
 

{mcpywrap-0.4.2 → mcpywrap-0.4.4}/docs/git-dependencies.md

@@ -76,11 +76,11 @@ Python的project.dependencies继续表示工具Python依赖，不变成游戏代
 
 两端提交并使用同一份 `mcpy-git.lock.json`，无需维护平台分支。锁定的是 Git 提交、源码和依赖关系；本机安装目录位于 `.mcpy/`，不提交到 Git。当前依赖都是游戏源码，没有需要分别锁定的 Windows/macOS 原生包。
 
-v2 锁使用相同的大小写敏感路径排序；源码由 Git archive 提取，保留仓库内的原始字节，工具生成的文件统一使用 LF。切换操作系统不会改变依赖摘要。新机器或克隆项目后运行一次 `mcpy sync`，随后正常 `mcpy run`。
+v2 锁使用相同的大小写敏感路径排序；源码由 Git archive 提取，禁用宿主 Git 的换行、编码、ident 和 filter 转换及全局 attributes，保留提交中的文件字节（包括二进制和原本的 CRLF）。工具生成的文件统一使用 LF。新机器或克隆项目后运行一次 `mcpy sync`，随后正常 `mcpy run`。
 
-普通 `mcpy sync` 会验证旧 v1 锁的源码，再自动更新跨平台格式，不再需要迁移参数。旧锁备份于 `.mcpy/lock-backups/`；需要重建的旧平台安装副本保留于 `.mcpy/registration-backups/`。提交新锁后，团队两端应使用支持 v2 的新版 mcpy。旧源码校验失败、或已安装文件出现无法解释的修改时仍会报错，不自动丢弃用户修改。
+`mcpy sync` 依据声明中固定的完整 Git 提交重新计算源码和安装内容摘要，直接写回锁文件；不更新依赖版本、不创建备份或执行专门的锁迁移。旧 v1/v2 锁都可通过一次 sync 刷新。新快照使用独立的 `git-archive-v2` 缓存，首次同步会重新获取固定提交，之后可离线复用；旧缓存不参与新摘要计算。已安装副本与旧锁一致时可重建，手动改动或缓存损坏仍会报错。`build/package/run` 继续严格验证锁文件，不隐式重算。
 
-终端只显示同步进度、结果和必要操作；`mcpy sync --json` 保留备份位置、完整摘要等诊断信息，供脚本和 AI 使用。`--migrate-windows-lock` 暂留作旧脚本兼容参数。
+终端只显示同步进度、结果和必要操作；`mcpy sync --json` 返回结构化结果。`--migrate-windows-lock` 和 JSON 中始终为空的 `git_lock_migrations` 仅保留旧脚本兼容。团队各设备应使用包含此修复的版本，并提交 sync 更新后的锁文件。
 
 ## 验证范围
 

{mcpywrap-0.4.2 → mcpywrap-0.4.4}/mcpywrap/__init__.py

@@ -1,4 +1,4 @@
 # -*- coding: utf-8 -*-
 """mcpywrap - 我的世界中国版 Addon 开发依赖、构建与游戏测试工具。"""
 
-__version__ = '0.4.2'
+__version__ = '0.4.4'

{mcpywrap-0.4.2 → mcpywrap-0.4.4}/mcpywrap/code_libraries.py

@@ -64,9 +64,6 @@ def prepare_sync(root, config=None):
     for entry in entries:
         key = identity(entry)
         installed = cache / key
-        if installed.is_dir() and key in expected and expected[key] in (digest(installed), windows_checkout_digest(installed, crlf=False)):
-            lock['libraries'].append({'declaration': entry, 'sha256': digest(installed)})
-            continue
         # 临时仓库不检出文件、不运行依赖代码、hooks 或安装脚本。
         with tempfile.TemporaryDirectory(prefix='fetch-', dir=cache) as temporary:
             temp = Path(temporary)
@@ -83,12 +80,19 @@ def prepare_sync(root, config=None):
                     (content / ('MCPY_UPSTREAM_' + file.name)).write_bytes(file.read_bytes())
             validate_game_files(root, [content])
             value = digest(content)
-            if key in expected and expected[key] not in (value, windows_checkout_digest(content, crlf=False)):
-                raise DependencyError('固定提交的代码库内容与锁文件摘要不符')
             if installed.exists():
-                # 回退到旧提交：用重新获取的内容验证旧缓存，而不是逐文件覆盖。
+                # Rebuild unchanged old installations from canonical source.
                 if digest(installed) != value:
-                    raise DependencyError(f'代码库缓存已损坏，请移走后重新 sync: {installed}')
+                    if key not in expected or expected[key] not in (
+                            digest(installed), windows_checkout_digest(installed, crlf=False)):
+                        raise DependencyError(f'代码库缓存已损坏，请移走后重新 sync: {installed}')
+                    old = temp / 'old'
+                    os.replace(installed, old)
+                    try:
+                        os.replace(content, installed)
+                    except BaseException:
+                        os.replace(old, installed)
+                        raise
             else:
                 os.replace(content, installed)
             lock['libraries'].append({'declaration': entry, 'sha256': value})

{mcpywrap-0.4.2 → mcpywrap-0.4.4}/mcpywrap/commands/connect_cmd.py

@@ -22,5 +22,14 @@ def connect_cmd(host, port, mcs_auth=False, detach=False, request_id=None, **eng
     if request_id:
         raise click.UsageError('--request-id 仅用于远程启动')
     from ..engines.backend import get_backend
-    return get_backend().connect(ServerTarget(host, port, 'mcs' if mcs_auth else 'none'),
-                                 engine_overrides=engine_overrides, detach=detach)
+    from ..engines.host import EngineError
+    backend = get_backend()
+    target = ServerTarget(host, port, 'mcs' if mcs_auth else 'none')
+    try:
+        return backend.connect(target, engine_overrides=engine_overrides, detach=detach)
+    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)

{mcpywrap-0.4.2 → mcpywrap-0.4.4}/mcpywrap/commands/sync_cmd.py

@@ -19,8 +19,6 @@ def sync_cmd(install, migrate_windows_lock=False):
     result = sync_project(project_dir(), install, migrate_windows_lock=migrate_windows_lock)
     if json_output():
         return result
-    if result['git_lock_migrations']:
-        click.echo('已更新跨平台依赖记录，旧文件已备份。')
     count = result['git_projects'] + result['code_libraries']
     click.secho('完成 · %d 个源码依赖已就绪 · %.1fs' % (count, time.monotonic()-started), fg='green')
     if install:
@@ -38,7 +36,6 @@ def sync_project(path, install=False, migrate_windows_lock=False):
         from ..builders.dependency_manager import DependencyManager
         visited, active = set(), set()
         git_count = 0
-        migrations = []
         def sync_sources(directory):
             nonlocal git_count
             key = canonical_path(directory)
@@ -57,8 +54,7 @@ def sync_project(path, install=False, migrate_windows_lock=False):
                     if target and 'mcpywrap' in read_project(target).get('tool', {}):
                         sync_sources(target)
             if git_declarations(directory, source_config) or Path(directory, GIT_LOCK_FILE).exists():
-                git_count += sync_projects(directory, source_config, migrate_windows_lock=migrate_windows_lock,
-                                           migration_report=migrations)
+                git_count += sync_projects(directory, source_config)
             active.remove(key)
             visited.add(key)
         sync_sources(path)
@@ -78,4 +74,4 @@ def sync_project(path, install=False, migrate_windows_lock=False):
             if proc.returncode:
                 raise click.ClickException(proc.stderr or proc.stdout or '项目安装失败')
     return {'project': str(path), 'installed': install, 'code_libraries': library_count,
-            'git_projects': git_count, 'git_lock_migrations': migrations}
+            'git_projects': git_count, 'git_lock_migrations': []}

{mcpywrap-0.4.2 → mcpywrap-0.4.4}/mcpywrap/engines/install.py

@@ -24,7 +24,7 @@ from .host import EngineError, describe, require_macos
 
 CATALOG_ENV = 'MCPY_RUNTIME_CATALOG'
 DEFAULT_CATALOG = ('https://github.com/EaseCation/mcpelauncher-manifest/releases/download/'
-                   'mcpy-runtime-v0.4.0/catalog.json')
+                   'mcpy-runtime-v0.4.3/catalog.json')
 # Public constant from the official ApkDownload component, verified 2026-10-05.
 # https://mcdev.webapp.163.com/static/js/4.05713153ba17aea6db53.js
 CDN_CONSTANT = 'mEE7Cot48r9j2AvEL2N6jpXEc'

{mcpywrap-0.4.2 → mcpywrap-0.4.4}/mcpywrap/engines/macos.py

@@ -65,7 +65,8 @@ def pinned_runtime(item):
     install.verify_game(game, plan['profile'])
     compatibility = install.preflight_runtime(app, game, plan['profile'], meta, plan['runtime_id'])
     return {'runtime': str(app), 'game': str(game), 'profile': plan['profile'], 'runtime_id': plan['runtime_id'],
-            'compat_report': compatibility, 'cppconfig_protocol': meta.get('cppconfig_protocol')}
+            'compat_report': compatibility, 'cppconfig_protocol': meta.get('cppconfig_protocol'),
+            'network_connect_protocol': meta.get('network_connect_protocol')}
 
 
 def run(project, *, new=False, listing=False, delete=None, clean_all=False, force=False,
@@ -85,9 +86,15 @@ def run(project, *, new=False, listing=False, delete=None, clean_all=False, forc
         raise EngineError('MC Studio 身份、EXE 和下载目录参数仅适用于 Windows。', 'unsupported_option',
                           'macOS 当前使用开发者 APK 的离线模式；资源由 mcpy engine 管理。')
     config = read_project(project)
-    if config.get('tool', {}).get('mcpywrap', {}).get('server'):
-        raise EngineError('macOS 本地后端当前只支持离线世界。', 'unsupported_feature',
-                          '连接服务器请配置 --remote <Windows 服务地址>。')
+    if not (listing or delete or clean_all):
+        from ..mcstudio.network import configured_target, prepare_project
+        target = configured_target(config)
+        if target is not None:
+            if new or instance_prefix or world_config is not None:
+                raise click.UsageError('网络模式不支持 --new 或本地世界实例 ID')
+            packs = prepare_project(project, config)
+            from .macos_network import connect
+            return connect(target, project_dir=project, packs=packs, engine_overrides=overrides, detach=detach)
     if config.get('tool', {}).get('mcpywrap', {}).get('project_type', 'addon') != 'addon':
         raise EngineError('macOS 首版支持 Addon 测试，Map 项目尚未接入。', 'unsupported_feature',
                           '地图项目请在 Windows 本机运行。')
@@ -192,6 +199,13 @@ def run(project, *, new=False, listing=False, delete=None, clean_all=False, forc
 
 def launch_session(data):
     plan = data['launch']
+    if data.get('mode') == 'network':
+        from types import SimpleNamespace
+        from ..mcstudio.network import ServerTarget, unauthenticated_config
+        config = unauthenticated_config(
+            SimpleNamespace(version=plan['engine_version'], download_dir=plan['game']),
+            ServerTarget(**data['network']['target']))
+        install.write_json(Path(plan['cppconfig']), config)
     app = Path(plan['runtime'])
     helper = app/'Contents/Resources/launcher/run_netease_dev.py'
     if not helper.is_file():
@@ -228,7 +242,7 @@ class MacOSBackend(GameBackend):
     label = 'macOS · Apple Silicon · Metal'
     capabilities = ('local-worlds', 'macos-local-worlds', 'engine-install', 'macos-engine-install',
                     'status', 'logs', 'stop', 'py', 'runtime', 'runtime-ui', 'runtime-player',
-                    'client-python-requests', 'project-ui', 'reload', 'watch')
+                    'client-python-requests', 'project-ui', 'reload', 'watch', 'network-sessions')
     managed_install = True
     setup_description = ('在 Apple Silicon Mac 上运行本地 Addon 测试。\n'
                          '首次运行会自动下载原生启动器和网易开发者版资源，并在本机完成安装。\n'
@@ -250,6 +264,10 @@ class MacOSBackend(GameBackend):
         options.pop('no_gui', None)
         return run(project, **options)
 
+    def connect(self, target, **options):
+        from .macos_network import connect
+        return connect(target, **options)
+
     def watch_directory(self, project, data):
         return Path(data['config_path']).parent/'assembled'
 
@@ -380,7 +398,9 @@ else:
                 request_id = 'startup-' + str(index)
                 result = channel._rpc('result', {'request_id': request_id})
                 if result.get('request_id') == request_id and result.get('state') in ('failed', 'cancelled'):
-                    raise EngineError('世界启动步骤失败：' + str(result.get('error', result['state'])), 'world_start_failed')
+                    raise EngineError(('服务器连接未完成：' if data.get('mode') == 'network' else '世界启动步骤失败：')
+                                      + str(result.get('error', result['state'])),
+                                      'connection_failed' if data.get('mode') == 'network' else 'world_start_failed')
         except (OSError, ConnectionError):
             pass
         try:
@@ -389,9 +409,13 @@ else:
                 stream.seek(max(0, stream.tell() - 65536))
                 if b'"top_screen":"hud_screen"' in stream.read():
                     data['world_ready'] = True
+                    if data.get('mode') == 'network': data['connection_verified'] = True
                     return True
         except OSError:
             pass
+        if data.get('mode') == 'network' and time.time() - data['created_at'] > 90:
+            raise EngineError('90 秒内未进入服务器；请检查地址、端口、协议版本以及服务器是否允许无认证的中国版客户端。',
+                              'connection_timeout')
         return False
 
     def handoff(self, data):

mcpywrap-0.4.4/mcpywrap/engines/macos_network.py

@@ -0,0 +1,47 @@
+"""Anonymous server launch using the shared cppconfig and session lifecycle."""
+from dataclasses import asdict
+from pathlib import Path
+import uuid
+
+import click
+from . import install
+from .host import EngineError, require_macos
+
+
+def connect(target, *, project_dir=None, packs=(), engine_overrides=None, detach=False):
+    from ..command_context import project_dir as current_project, json_output
+    from ..mcstudio import sessions
+    from ..remote.service import directory_lock
+    from .macos import ensure_runtime, pinned_runtime
+    require_macos()
+    if json_output() and not detach:
+        raise click.UsageError('网络运行 --json 需要 --detach；使用 status/logs/stop 管理返回的会话')
+    overrides = engine_overrides or {}
+    if target.auth != 'none' or overrides.get('game_executable_path') or overrides.get('mcs_download_path'):
+        raise EngineError('macOS 服务器连接仅支持无认证模式；MC Studio 身份和 EXE 参数仅适用于 Windows。',
+                          'unsupported_option')
+    root = Path(project_dir or current_project()).resolve()
+    with directory_lock(install.home()/'install-lock'):
+        state = pinned_runtime({'installation': ensure_runtime()})
+        if state.get('network_connect_protocol') != 1:
+            raise EngineError('此 macOS 运行包尚不支持连接服务器。', 'runtime_incompatible',
+                              '请执行 mcpy engine install --catalog ' + install.DEFAULT_CATALOG + '，再重试；已有世界保留原绑定。')
+        version = state['profile']['apk']['version']
+        requested = overrides.get('engine_version')
+        if requested and requested != version:
+            raise EngineError('当前资源版本为 ' + version, 'engine_version_mismatch',
+                              '请使用匹配的资源，或省略 --engine-version。')
+        session = uuid.uuid4().hex
+        directory = sessions.session_path(root, session)
+        plan = {'runtime': state['runtime'], 'game': state['game'],
+                'data': str(directory/'native/data'), 'cache': str(directory/'native/cache'),
+                'engine_version': version, 'compat_report': state.get('compat_report'),
+                'cppconfig': str(directory/'runtime.cppconfig')}
+        data = sessions.start(root, backend='macos-arm64', session_id=session, launch=plan,
+                              network={'target': asdict(target), 'engine': {'version': version}})
+    result = sessions.handoff(data)
+    if detach:
+        return result
+    click.echo(f'连接 {target.host}:{target.port}（无认证）；不装配本地 Mod。')
+    from .tui import watch_session
+    return watch_session(root, session)

{mcpywrap-0.4.2 → mcpywrap-0.4.4}/mcpywrap/engines/tui.py

@@ -19,10 +19,12 @@ def watch_session(project, session):
                 backend = get_backend(data.get('backend', 'windows'))
                 table = Table.grid(padding=(0, 2))
                 table.add_row('平台', backend.label)
-                table.add_row('状态', '世界已就绪' if data.get('world_ready') else '引擎已启动，正在准备世界…')
+                network = data.get('mode') == 'network'
+                table.add_row('状态', ('已进入服务器' if data.get('connection_verified') else '正在连接服务器…')
+                              if network else ('世界已就绪' if data.get('world_ready') else '引擎已启动，正在准备世界…'))
                 table.add_row('会话', session)
                 table.add_row('操作', 'Ctrl+C 保存退出；其他终端可使用 logs / runtime py')
-                live.update(Panel(table, title='mcpy 本地测试'))
+                live.update(Panel(table, title='mcpy 服务器测试' if network else 'mcpy 本地测试'))
                 time.sleep(.25)
     except KeyboardInterrupt:
         console.print('正在保存世界并关闭窗口…')

{mcpywrap-0.4.2 → mcpywrap-0.4.4}/mcpywrap/engines/windows.py

@@ -13,28 +13,34 @@ class WindowsBackend(GameBackend):
     def debug_channel(self, data, write_log):
         from ..mcstudio.runtime_debug import SafaiaChannel
         self._world_ready = data.get('mode') != 'local'
-        self._log_offset, self._log_pending = 0, b''
+        self._ready_log_cursors = {}
         if data.get('mode') == 'local': data['world_ready'] = False
         return SafaiaChannel(write_log, ready=lambda: self._world_ready)
 
     def refresh(self, data, channel):
         if self._world_ready: return False
         from pathlib import Path
-        path = Path(data['log_path'])
-        try:
-            with path.open('rb') as stream:
-                stream.seek(self._log_offset)
-                chunk = stream.read(65536)
-                self._log_offset = stream.tell()
-        except FileNotFoundError:
-            return False
-        text = self._log_pending + chunk
-        # This engine log is emitted after client/server Python system creation.
-        if b'OnHandlePushScreen hud_screen' in text:
-            self._world_ready = data['world_ready'] = True
-            self._log_pending = b''
-            return True
-        self._log_pending = text[-64:]
+        import re
+        for name in ('log_path', 'engine_log_path'):
+            if not data.get(name): continue
+            path = Path(data[name])
+            offset, pending = self._ready_log_cursors.get(name, (0, b''))
+            try:
+                with path.open('rb') as stream:
+                    stream.seek(offset)
+                    chunk = stream.read(65536)
+                    offset = stream.tell()
+            except FileNotFoundError:
+                continue
+            text = pending + chunk
+            # Both markers require a created gameplay HUD. The native layout
+            # marker also works if the Python launch logging handler raises.
+            hud = (b'OnHandlePushScreen hud_screen' in text if name == 'log_path' else
+                   re.search(rb"\bINFO GUI [^\r\n]*\] Layout main thread: [^\r\n]*controls completed [^\r\n]*for screen 'hud\.hud_screen'\.", text))
+            self._ready_log_cursors[name] = (offset, text[-1024:])
+            if hud:
+                self._world_ready = data['world_ready'] = True
+                return True
         return False
 
     def reload_restriction(self, data, kind):

{mcpywrap-0.4.2 → mcpywrap-0.4.4}/mcpywrap/git_cache.py

@@ -89,7 +89,9 @@ def fetch_snapshot(url, ref):
         raise DependencyError('无效Git引用')
     origin = hashlib.sha256(url.encode('utf-8')).hexdigest()
     base = cache_root()
-    snapshots = base / 'git' / origin
+    # Old archives may contain bytes converted by the host's Git settings.
+    # Keep them separate so even a verified old cache cannot reintroduce CRLF.
+    snapshots = base / 'git-archive-v2' / origin
     snapshots.mkdir(parents=True, exist_ok=True)
     with _source_lock(base / 'locks' / (origin + '.lock')):
         if re.fullmatch('[0-9a-f]{40}', ref) and (snapshots / ref).exists():
@@ -99,6 +101,11 @@ def fetch_snapshot(url, ref):
             repo, package = stage / 'repo', stage / 'snapshot'
             content = package / 'content'
             _git('init', '--bare', repo)
+            # Archive applies checkout conversions too. Preserve blob bytes,
+            # including binary/intentional CRLF files, on every host.
+            (repo / 'info').mkdir(exist_ok=True)
+            (repo / 'info' / 'attributes').write_bytes(
+                b'* -text -eol -filter -ident -working-tree-encoding\n')
             _git('-C', repo, 'fetch', '--depth=1', '--no-tags', url, ref)
             commit = _git('-C', repo, 'rev-parse', 'FETCH_HEAD^{commit}').decode().strip()
             if not re.fullmatch('[0-9a-f]{40}', commit) or (re.fullmatch('[0-9a-f]{40}', ref) and commit != ref):

{mcpywrap-0.4.2 → mcpywrap-0.4.4}/mcpywrap/git_projects.py

@@ -108,11 +108,10 @@ def prepare_graph(root, config=None, migrate_windows_lock=False):
     root = Path(root).resolve()
     config = read_project(root) if config is None else config
     roots = declarations(root, config)
-    expected, legacy = {}, False
+    expected = {}
     if (root / LOCK_FILE).exists():
         try:
             prior = json.loads((root / LOCK_FILE).read_text('utf-8'))
-            legacy = prior['version'] == 1
             expected = {record['id']: record for record in prior['nodes']}
         except (ValueError, KeyError, TypeError) as exc:
             raise DependencyError('无法读取依赖锁文件 mcpy-git.lock.json。\n请从版本控制恢复该文件后运行 mcpy sync。') from exc
@@ -120,7 +119,7 @@ def prepare_graph(root, config=None, migrate_windows_lock=False):
             raise DependencyError('此项目需要较新版本的 mcpy，请先升级 mcpywrap。')
     registered = long_path(root / '.mcpy/git-projects')
     registered.mkdir(parents=True, exist_ok=True)
-    nodes, active, migrations = {}, [], []
+    nodes, active = {}, []
     def visit(entry, supplied_source=None):
         source, commit = supplied_source or fetch_source(root, entry['git'], entry['rev'])
         project, payload, project_config, kind, target = _layout(source, entry)
@@ -138,11 +137,8 @@ def prepare_graph(root, config=None, migrate_windows_lock=False):
         active.append(key)
         source_hash = digest(source)
         previous = expected.get(key)
-        migrating = legacy and previous is not None
-        if previous and previous['source_sha256'] != source_hash:
-            if not migrating or previous['source_sha256'] not in (
-                    windows_checkout_digest(source), windows_checkout_digest(source, crlf=False)):
-                raise DependencyError(f"依赖 {entry['name']} 的源码校验失败。\n请保留 mcpy-git.lock.json，并重新获取该依赖的固定版本。")
+        # sync derives checksums from the pinned commit's verified snapshot.
+        # Old host-dependent checksums are outputs, not version constraints.
         children = []
         for child in declarations(project, project_config):
             children.append(visit(child))
@@ -197,65 +193,39 @@ def prepare_graph(root, config=None, migrate_windows_lock=False):
             from .dependencies import validate_game_files
             validate_game_files(stage, addon_directories(stage).values())
             content_hash = digest(stage)
-            if previous and previous['sha256'] != content_hash and not migrating:
-                raise DependencyError(f"依赖 {entry['name']} 的安装内容与锁文件不一致。\n请确认团队使用相同版本的 mcpywrap；不要删除锁文件。")
             final = registered / key
             if final.exists():
                 if digest(final) != content_hash:
-                    # Old generated files may contain Windows line endings. Only
-                    # replace a verified old registration; preserve it for recovery.
-                    if not migrating or previous['sha256'] not in (
+                    # Only replace an unchanged installation of the old lock.
+                    if not previous or previous['sha256'] not in (
                             digest(final), windows_checkout_digest(final, crlf=False)):
                         raise DependencyError(f"依赖 {entry['name']} 的本地文件已修改。\n请将 {final} 移到项目外备份，再运行 mcpy sync。")
-                    backups = root/'.mcpy/registration-backups'
-                    backups.mkdir(parents=True, exist_ok=True)
-                    backup = Path(tempfile.mkdtemp(prefix=key[:12]+'-', dir=backups))/'project'
-                    os.replace(final, backup)
+                    old = Path(temporary) / 'old'
+                    os.replace(final, old)
                     try:
                         os.replace(stage, final)
                     except BaseException:
-                        os.replace(backup, final)
+                        os.replace(old, final)
                         raise
             else:
                 os.replace(stage, final)
         record = {'id': key, 'source': identity, 'source_sha256': source_hash, 'sha256': content_hash,
                   'kind': kind, 'target': target, 'children': list(dict.fromkeys(children))}
-        if migrating:
-            migrations.append({'node': key, 'name': entry['name'], 'git': entry['git'], 'rev': commit,
-                               'old_source_sha256': previous['source_sha256'], 'source_sha256': source_hash,
-                               'old_registered_sha256': previous['sha256'], 'registered_sha256': content_hash})
         nodes[key] = record
         active.pop()
         return key
     root_ids = [visit(entry) for entry in roots]
-    lock = {'version': 2, 'declarations': roots, 'roots': root_ids, 'nodes': list(nodes.values())}
-    if migrations:
-        lock['_lock_migrations'] = migrations
-    return lock
+    return {'version': 2, 'declarations': roots, 'roots': root_ids, 'nodes': list(nodes.values())}
 
 
 def write_lock(root, lock):
-    data = dict(lock)
-    migrations = data.pop('_lock_migrations', [])
-    report = []
-    if migrations and (Path(root)/LOCK_FILE).exists():
-        old = (Path(root)/LOCK_FILE).read_bytes()
-        backup = Path(root)/'.mcpy/lock-backups'/(hashlib.sha256(old).hexdigest()+'.json')
-        backup.parent.mkdir(parents=True, exist_ok=True)
-        if backup.exists() and backup.read_bytes() != old:
-            raise DependencyError('无法备份旧依赖记录，原锁文件未修改。')
-        backup.write_bytes(old)
-        report.append({'project': str(root), 'backup': str(backup), 'nodes': migrations})
-    _write_json(Path(root) / LOCK_FILE, data)
-    return report
+    _write_json(Path(root) / LOCK_FILE, lock)
 
 
 def sync_projects(root, config=None, migrate_windows_lock=False, migration_report=None):
-    # Kept for older callers; recognized legacy locks now migrate automatically.
-    lock = prepare_graph(root, config, migrate_windows_lock=migrate_windows_lock)
-    report = write_lock(root, lock)
-    if migration_report is not None:
-        migration_report.extend(report)
+    # Legacy arguments are retained for callers; sync simply recalculates the lock.
+    lock = prepare_graph(root, config)
+    write_lock(root, lock)
     return len(lock['nodes'])
 
 

{mcpywrap-0.4.2 → mcpywrap-0.4.4}/mcpywrap/mcstudio/bridge_payload/manifest.json

@@ -11,9 +11,9 @@
     "Loader.c": "f2f1f781ce82fc30c62a6ce22bb048d3b023f6ff500e6ec8228da28b4dbf1b4a"
   },
   "files": {
-    "Injector.exe": "d63c7fcf4061bad6381c14a3f60c7ad78e99e71536dcc82c81fc9e259bea6c53",
-    "Loader.dll": "4e5cdb48778866c66da75b9a560b9513624c1b8cf3b2c6b0e52c5c3145eac91a",
-    "McpyMcsAuth.dll": "30a7a1bf74c7a049e145442baf94870072033d726d83449c7c8a1b9e29438c04",
+    "Injector.exe": "aa185d69f11e138df90f446c239d075ef6ab4e5c5e0457981a6c09f52e04b7b9",
+    "Loader.dll": "03956417da34f569dd6e794076f2252ff05cb286fd1a8dc6ce966dc78911330e",
+    "McpyMcsAuth.dll": "b1270f169319e8acebca7d49be966d54c769590d708157c3984e33f9a943c1d7",
     "publisher.cer": "e5aa2ac39df40804ed8b08fe8e43c4a2b8923f0d02a360708486b2db5b6303d7"
   }
 }

{mcpywrap-0.4.2 → mcpywrap-0.4.4}/mcpywrap/mcstudio/runtime_debug.py

@@ -314,6 +314,8 @@ class _ControlHandler(socketserver.BaseRequestHandler):
             request = json.loads(recv_exact(self.request, size).decode('utf-8'))
             if request.get('token') != self.server.token:
                 raise ValueError('会话控制凭据无效')
+            if self.server.mode == 'network' and (request.get('side', 'client') != 'client' or request.get('action') == 'reload'):
+                raise ValueError('网络会话仅支持客户端调试，不支持服务端 Python 或本地 Mod 热更')
             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'):
@@ -357,8 +359,8 @@ class RuntimeControlServer(socketserver.ThreadingTCPServer):
     daemon_threads = True
     allow_reuse_address = True
 
-    def __init__(self, channel, token, project=None, session=None):
-        self.channel, self.token = channel, token
+    def __init__(self, channel, token, project=None, session=None, mode='local'):
+        self.channel, self.token, self.mode = channel, token, mode
         self.input_manager = None
         if project is not None and session is not None:
             from .host_input import HostInputManager

{mcpywrap-0.4.2 → mcpywrap-0.4.4}/mcpywrap/mcstudio/session_worker.py

@@ -57,12 +57,12 @@ def run(project, session):
         debug_channel = backend.debug_channel(data, receiver._write)
         debug_channel.start(process.pid)
         token = uuid.uuid4().hex
-        control_server = RuntimeControlServer(debug_channel, token, project, session)
+        control_server = RuntimeControlServer(debug_channel, token, project, session, mode=data.get('mode', 'local'))
         control_server.start()
         sessions.save(directory/'control.json', {'port': control_server.server_address[1],
                                                  'token': token,
                                                  'unified_input_worker': True,
-                                                 'python_reload_sides': ['client', 'server'],
+                                                 'python_reload_sides': [] if data.get('mode') == 'network' else ['client', 'server'],
                                                  'client_python_queue': callable(getattr(debug_channel, 'submit', None))})
         data.update(state='running', game=identity(process.pid))
         sessions.save(path, data)

{mcpywrap-0.4.2 → mcpywrap-0.4.4}/mcpywrap/mcstudio/sessions.py

@@ -114,7 +114,7 @@ def handoff(data):
         target = data['network']['target']
         result.update(host=target['host'], port=target['port'], identity_source=target['auth'],
                       identity_provided=data['mcs_auth'], authenticated=False,
-                      connection_verified=False, addons_assembled=False,
+                      connection_verified=data.get('connection_verified', False), addons_assembled=False,
                       engine_version=data['network']['engine']['version'])
     return result
 

{mcpywrap-0.4.2 → mcpywrap-0.4.4}/mcpywrap/mcstudio/window_capture/manifest.json

@@ -1,5 +1,5 @@
 {
-  "executable_sha256": "2a37e9282aac2a242169be0f5ac499aabf443aacff2c7aa92867d9570552089d",
+  "executable_sha256": "4f4f8b0a8eae4b8d409ae90e222886623c4b53ed66525d8267ffaadc1db65442",
   "source_sha256": "0c0b2a02bfecea68b824a486ac1d88cde6bd9fc8ee8e4c9a6939870bd8e710d1",
   "sources": {
     "video_capture.h": "8daee1b8c1c8273bc8d19d39f0559f82c30d7ff900894bcc2cc197d3881532d7",

{mcpywrap-0.4.2 → mcpywrap-0.4.4}/mcpywrap/minecraft/template/mod_template.py

@@ -144,6 +144,8 @@ def open_ui_crate_mod(behavior_pack_path, run_event_loop=True):
     
     # 主窗口
     window = QWidget()
+    # Closed embedded editors must release their signal closures before Qt exits.
+    window.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
     window.setWindowTitle("Minecraft Mod 创建工具")
     window.setMinimumWidth(900)  # 增加窗口宽度以适应目录树
     window.setMinimumHeight(600)  # 设置窗口最小高度

{mcpywrap-0.4.2 → mcpywrap-0.4.4}/mcpywrap/source_files.py

@@ -68,7 +68,10 @@ def _git(*args):
             return value[4:]
         return value
     try:
-        result = subprocess.run(['git', '-c', 'core.hooksPath=', '-c', 'core.longpaths=true', *map(argument, args)],
+        result = subprocess.run(['git', '-c', 'core.hooksPath=', '-c', 'core.longpaths=true',
+                                 '-c', 'core.autocrlf=false', '-c', 'core.eol=lf',
+                                 '-c', 'core.attributesFile=' + os.devnull, *map(argument, args)],
+                                env=dict(os.environ, GIT_ATTR_NOSYSTEM='1'),
                                 capture_output=True, timeout=180)
     except (OSError, subprocess.TimeoutExpired) as exc:
         raise DependencyError(f'无法获取代码库: {exc}') from exc