mcpywrap 0.5.2__tar.gz → 0.5.4__tar.gz

{mcpywrap-0.5.2 → mcpywrap-0.5.4}/CHANGELOG.md

@@ -1,5 +1,15 @@
 # 更新记录
 
+## 0.5.4
+
+- 修复 macOS 网络会话启动时的状态保存路径：在启动游戏前，将 `prepared` 状态写入所属会话目录，避免会话记录未正确更新。
+
+## 0.5.3
+
+- 修复 Windows 双客户端收到 Addon 后入口导入失败：为每个角色使用独立浅层游戏资料目录，兼容网易 3.9 下载包加载器。旧资料复制迁移并保留备份；保留归属、占用锁及缓存版本检查，迁移中断或资料缺失时拒绝静默回退。
+- 新增 `before_archive` 打包阶段及 `MCPY_PACKAGE_ROOT`，允许在依赖组装完成后处理隔离的发布副本；不裁剪开发源码或运行目录。禁止改动包 manifest 和引入文件链接，处理失败时保留原 ZIP。
+- 压缩前链接检查共用跨 Python 版本实现，Python 3.9 同样识别 Windows junction。
+
 ## 0.5.2
 
 - Addon 的本地/Git 依赖可声明 `consumer_prepare`，使用同一依赖版本的工具处理消费项目素材；build、package 和实际本地新启动自动准备，支持传递范围、来源去重及显式停用，无需消费者重复绑定 hooks。

{mcpywrap-0.5.2 → mcpywrap-0.5.4}/PKG-INFO

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

{mcpywrap-0.5.2 → mcpywrap-0.5.4}/docs/game-backends.md

@@ -25,6 +25,15 @@ macOS 支持离线 Addon 世界；无认证服务器连接需 CLI 0.4.3+ 与运
 
 ## AI 与纯命令控制
 
+### Windows 多客户端资料路径
+
+Windows 联调成员的生命周期记录、角色归属及占用锁仍位于项目 `.runtime/groups`；游戏实际使用的独立 profile 位于项目所在磁盘的 `mcpy-profiles/<摘要>`。摘要包含项目角色路径及宿主用户目录，不复用用户真实游戏资料；会话的 `network.windows_profile` 与角色目录中的 `windows-profile.json` 记录实际位置。普通单客户端、macOS 不改变布局。
+
+这是 ModPC 3.9 下载包加载器的路径兼容处理：标准 `.../AppData/Roaming/MinecraftPE_Netease/packcache/<包>/` 有固定层数，较深的项目目录会被拼进 Python 模块名。目录链接会被引擎解析为实际路径，不能修复问题；仅覆盖 APPDATA 也不能替代 Windows 按 USERPROFILE 查询目录。使用真实浅层 profile，不修改引擎、sys.path 或 Addon 入口。
+
+首次迁移在角色占用锁内复制旧 AppData 到临时目录，完成归属标记后原子改名，原副本保留。后续启动复用新位置；目标缺失、归属不符或遗留未完成迁移时停止，不回退到旧身份。旧资料的长路径用宿主扩展路径形式复制，传给游戏的仍是标准短路径。需要项目所在磁盘根目录允许创建 `mcpy-profiles`；不支持 UNC 或被替换为目录链接的位置，不自动提权。用户搬迁项目时需保留组记录及其指向的 profile，不能只把外部目录当缓存删除。
+
+
 Windows/macOS 共同基线是 `--local --project <目录> --non-interactive run --no-gui --detach --json`，后续统一 status/logs/runtime py/runtime reload/stop。控制端不打开 Qt、小窗或 TUI，游戏本身仍需要显示服务及原生窗口。完整操作顺序维护在 [技能的公共流程](../skills/mcpywrap/references/local-development.md)。
 
 `runtime capabilities --session <id> --json` 返回 schema_version=1：control 描述控制端要求，python 提供执行端侧与 worker 队列声明，reload 按同一后端限制返回 available/unsupported/unavailable。查询不执行游戏代码、不返回控制凭据，available 只说明允许调用。旧 worker 缺少队列声明时返回 null，不能推断支持。Windows 已知 Shader 限制也由 WindowsBackend 提供，实际重载与查询没有两份规则。

{mcpywrap-0.5.2 → mcpywrap-0.5.4}/mcpywrap/__init__.py

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

{mcpywrap-0.5.2 → mcpywrap-0.5.4}/mcpywrap/commands/package_cmd.py

@@ -10,6 +10,7 @@ from ..command_context import OperationCommand, project_dir as current_project,
 from ..config import config_exists
 from ..dependencies import DependencyError, read_project
 from ..builders.project_builder import AddonProjectBuilder, MapProjectBuilder
+from ..utils.paths import is_link
 
 
 @click.command(cls=OperationCommand)
@@ -35,7 +36,7 @@ def package_cmd(merge):
         if project_type not in ('addon', 'map'):
             raise ValueError('当前仅支持 Addon 和 Map 项目的打包')
 
-        from ..project_scripts import before, configured, validate_build
+        from ..project_scripts import before, configured, validate_build, operation
         from ..consumer_prepare import PreparationPlan
         plan = PreparationPlan(source)
         if configured(source):
@@ -52,6 +53,15 @@ def package_cmd(merge):
                 success, error = builder.build()
                 if not success:
                     raise click.ClickException(f'构建失败: {error}')
+                # 依赖组装完成后，仅将隔离副本提供给压缩前处理器。
+                identity = _package_manifests(output)
+                with operation(source, 'before_archive', lock_held=True, after_task=plan.check,
+                               package_root=output) as finalizers:
+                    scripts.extend(finalizers)
+                if identity != _package_manifests(output):
+                    raise ValueError('压缩前处理不得修改包 manifest 或包身份')
+                if any(is_link(p) for p in output.rglob('*')):
+                    raise ValueError('压缩前处理不能在产物中引入目录或文件链接')
                 archive = Path(temporary) / 'package.zip'
                 with zipfile.ZipFile(archive, 'w', zipfile.ZIP_DEFLATED) as zipf:
                     if project_type == 'addon':
@@ -77,6 +87,11 @@ def package_cmd(merge):
     return {'artifact': str(destination), **({'scripts': scripts} if scripts else {})}
 
 
+def _package_manifests(root):
+    return {str(p.relative_to(root)): p.read_bytes() for p in root.rglob('*')
+            if p.is_file() and p.name in ('manifest.json', 'pack_manifest.json')}
+
+
 def _zip_dir_keep_empty(zipf, src_dir, dst_root):
     """保留构建产物的空目录，ZIP 路径统一使用相对路径和正斜杠。"""
     source = Path(src_dir)

{mcpywrap-0.5.2 → mcpywrap-0.5.4}/mcpywrap/commands/script_cmd.py

@@ -27,6 +27,8 @@ def list_cmd(effective=False):
     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', [])]
     if json_output():
         return result
     for script in result['scripts']:

{mcpywrap-0.5.2 → mcpywrap-0.5.4}/mcpywrap/engines/macos.py

@@ -380,7 +380,7 @@ else:
                                                  install.home()/'preferences/macos').prepare()
             sessions.require_launch_requested(data['project'], data['session'])
             data['phase'] = 'prepared'
-            sessions.save(directory/'session.json', data)
+            sessions.save(sessions.session_path(data['project'], data['session'])/'session.json', data)
             return LaunchedGame(launch_session(data), capture_output=False, guard=guard)
         except BaseException:
             guard.close()

{mcpywrap-0.5.2 → mcpywrap-0.5.4}/mcpywrap/mcstudio/bridge_payload/manifest.json

@@ -11,9 +11,9 @@
     "Loader.c": "f2f1f781ce82fc30c62a6ce22bb048d3b023f6ff500e6ec8228da28b4dbf1b4a"
   },
   "files": {
-    "Injector.exe": "c3ad30ea3c2822539abe8dee220ef8f94bf6d8a570538bea2809f1c9826ff2a2",
-    "Loader.dll": "087c73b4c1a81c49de0ae9a244d7bd8b6a6bcd66c1c2799ec864f315f747a6f6",
-    "McpyMcsAuth.dll": "8640a44a88c432f33904a530cdaec39dfd00b17a274c5e37e1786fca50a61331",
+    "Injector.exe": "386c7bb1972dcba1e5d4eb86709bc7d0576d789266805057cbc9d498e62dac10",
+    "Loader.dll": "aac19d20010d3ecc2af156688a795be7337a21e5264b4308d66deba2a16b1725",
+    "McpyMcsAuth.dll": "caed744e904c86727de5b2176e9aef0bb28002334188877f6746cc882a83bdbd",
     "publisher.cer": "e5aa2ac39df40804ed8b08fe8e43c4a2b8923f0d02a360708486b2db5b6303d7"
   }
 }

{mcpywrap-0.5.2 → mcpywrap-0.5.4}/mcpywrap/mcstudio/window_capture/manifest.json

@@ -1,5 +1,5 @@
 {
-  "executable_sha256": "183a9412e78838fe70cac66feaabe7fa69ebc4e907f483d1e29b74e98e1df9f1",
+  "executable_sha256": "b9caca51171c908f4dca623ebe498ec06ed345427e80e89cc8917d19f117adc8",
   "source_sha256": "0c0b2a02bfecea68b824a486ac1d88cde6bd9fc8ee8e4c9a6939870bd8e710d1",
   "sources": {
     "video_capture.h": "8daee1b8c1c8273bc8d19d39f0559f82c30d7ff900894bcc2cc197d3881532d7",

{mcpywrap-0.5.2 → mcpywrap-0.5.4}/mcpywrap/project_scripts.py

@@ -17,7 +17,7 @@ from .dependencies import read_project
 from .runtime import storage
 from .utils.locks import directory_lock
 
-EVENTS = ('before_build', 'before_package', 'before_run')
+EVENTS = ('before_build', 'before_package', 'before_run', 'before_archive')
 CHAIN_ENV = '_MCPY_SCRIPT_CHAIN'
 
 
@@ -112,12 +112,14 @@ def _active_process(record):
 
 @contextmanager
 def operation(project, event=None, *, task=None, args=(), cancel=None, progress=None, lock_held=False,
-              after_task=None):
+              after_task=None, package_root=None):
     """Hold the cooperative lock through the caller's consumption of generated files."""
     project = Path(project).resolve()
     reject_recursion()
     scripts, hooks = configuration(project)
     names = [task] if task is not None else hooks.get(event, [])
+    if event == 'before_archive' and names and package_root is None:
+        raise ScriptError('压缩前处理必须由 package 提供临时目录。', 'script_context_missing')
     if any(name not in scripts for name in names):
         raise ScriptError('未定义脚本: ' + str(task), 'script_not_found')
     directory = project/'.mcpy/scripts'
@@ -131,7 +133,7 @@ def operation(project, event=None, *, task=None, args=(), cancel=None, progress=
             if cancel and cancel():
                 raise ScriptError('脚本执行已取消', 'script_cancelled', script=name, event=event)
             results.append(_execute(project, name, scripts[name], event or 'manual', args,
-                                    cancel=cancel, progress=progress))
+                                    cancel=cancel, progress=progress, package_root=package_root))
             if after_task:
                 after_task()
         if cancel and cancel():
@@ -205,13 +207,17 @@ def startup_hooks(data, deployment):
     deployment.preparation_plan = plan
 
 
-def _execute(project, name, spec, event, extra, *, cancel=None, progress=None):
+def _execute(project, name, spec, event, extra, *, cancel=None, progress=None, package_root=None):
     env = dict(os.environ)
+    # 临时打包目录只能由本次 package 注入，不能沿用父进程上下文。
+    env.pop('MCPY_PACKAGE_ROOT', None)
     env.update({key.upper() if os.name == 'nt' else key: value for key, value in spec['env'].items()})
     env.update({CHAIN_ENV: '1', 'MCPY_PROJECT_ROOT': str(project), 'MCPY_EVENT': event,
                 'MCPY_OPERATION': {'before_build': 'build', 'before_package': 'package',
-                                   'before_run': 'run'}.get(event, 'script'),
+                                   'before_run': 'run', 'before_archive': 'package'}.get(event, 'script'),
                 'PYTHONIOENCODING': 'utf-8', 'PYTHONUNBUFFERED': '1'})
+    if package_root is not None:
+        env['MCPY_PACKAGE_ROOT'] = str(Path(package_root).resolve())
     command = list(spec['command']) + list(extra)
     if spec['python'] and not Path(command[2]).is_file():
         raise ScriptError('脚本文件不存在: ' + command[2], 'script_not_found', script=name, event=event)

{mcpywrap-0.5.2 → mcpywrap-0.5.4}/mcpywrap/remote/service.py

@@ -53,7 +53,7 @@ def capabilities():
     from ..engines.host import describe
     backend = get_backend()
     result['host'] = describe()
-    result['local_capabilities'] = ['project-scripts', 'consumer-prepare']
+    result['local_capabilities'] = ['project-scripts', 'consumer-prepare', 'package-finalize']
     result['capabilities'] = list(dict.fromkeys(result['capabilities'] + list(backend.capabilities)))
     if backend.managed_install:
         result['runtime'] = backend.diagnose()

{mcpywrap-0.5.2 → mcpywrap-0.5.4}/mcpywrap/runtime/profiles.py

@@ -2,6 +2,7 @@
 from pathlib import Path
 from ..utils.paths import is_link
 import json
+import hashlib
 import os
 import subprocess
 import sys
@@ -64,12 +65,13 @@ class PlayerProfile:
         self.data['network']['profile'] = str(self.root)
 
     def windows_environment(self):
-        roaming, local = self.root/'AppData/Roaming', self.root/'AppData/Local'
+        profile = self.windows_directory()
+        roaming, local = profile/'AppData/Roaming', profile/'AppData/Local'
         for path in (roaming, local):
-            if not path.resolve().is_relative_to(self.root.resolve()):
+            if not path.resolve().is_relative_to(profile.resolve()):
                 raise EngineError('客户端系统目录指向了外部位置。', 'profile_modified')
             path.mkdir(parents=True, exist_ok=True)
-        environment = dict(os.environ, USERPROFILE=str(self.root), APPDATA=str(roaming), LOCALAPPDATA=str(local))
+        environment = dict(os.environ, USERPROFILE=str(profile), APPDATA=str(roaming), LOCALAPPDATA=str(local))
         from ..mcstudio.processes import background_options
         try:
             probe = subprocess.run([sys.executable, '-c', FOLDER_PROBE], env=environment,
@@ -87,7 +89,7 @@ class PlayerProfile:
         # Seed only presentation/input preferences, never account or device IDs.
         from ..engines.preferences import game_preference, read_properties, write_properties
         target = roaming/'MinecraftPE_Netease/minecraftpe/options.txt'
-        if not target.parent.resolve().is_relative_to(self.root.resolve()):
+        if not target.parent.resolve().is_relative_to(profile.resolve()):
             raise EngineError('客户端游戏目录指向了外部位置。', 'profile_modified')
         if not target.exists() and os.environ.get('APPDATA'):
             source = Path(os.environ['APPDATA'])/'MinecraftPE_Netease/minecraftpe/options.txt'
@@ -102,6 +104,54 @@ class PlayerProfile:
             write_properties(target, values, ':')
         return environment
 
+    def windows_directory(self):
+        """Keep real Windows profiles at the depth expected by ModPC 3.9.
+
+        The received-pack loader strips eight path components. Known folders
+        follow USERPROFILE, and the engine resolves junctions, so the profile
+        itself must be a real drive:/mcpy-profiles/<id> directory. Project-local
+        ownership/leases stay authoritative; previous data is copied once and
+        retained as a backup. No engine or Addon import hooks are changed.
+        """
+        import shutil
+        from ..source_files import long_path
+        parent = Path(self.project.anchor)/'mcpy-profiles'
+        if not self.project.drive or str(parent).startswith('\\\\') or is_link(parent):
+            raise EngineError('客机需要本地磁盘上的独立资料目录。', 'profile_unavailable')
+        key = occupancy.path_key(self.root) + '\n' + os.environ.get('USERPROFILE', '')
+        target = parent/hashlib.sha256(key.encode('utf-8')).hexdigest()[:32]
+        receipt = self.root/'windows-profile.json'
+        expected = {'path': str(target), 'owner': self.owner}
+        previous = storage.read(receipt)
+        if previous is not None and (not isinstance(previous, dict) or
+                any(previous.get(k) != v for k, v in expected.items())):
+            raise EngineError('客机资料路径记录已变化，已保留原内容。', 'profile_modified')
+        marker = target/'.mcpy-owner.json'
+        if os.path.lexists(target):
+            if (previous is None or is_link(target) or not target.is_dir() or
+                    is_link(marker) or storage.read(marker) != self.owner):
+                raise EngineError('客机资料目录归属不明：' + str(target), 'profile_conflict')
+        else:
+            if previous is not None and previous.get('ready'):
+                raise EngineError('已迁移的客机资料目录缺失，未回退到旧副本。', 'recovery_required')
+            staging = target.with_name(target.name + '.preparing')
+            if os.path.lexists(staging):
+                raise EngineError('上次客机资料迁移尚未完成：' + str(staging), 'recovery_required',
+                                  '保留原目录和迁移现场，请核对后恢复；不会覆盖或删除。')
+            legacy = self.root/'AppData'
+            if is_link(legacy) or any(is_link(p) for p in long_path(legacy).rglob('*')):
+                raise EngineError('原客机资料含目录链接，未复制。', 'profile_modified')
+            storage.write(receipt, expected)
+            staging.mkdir(parents=True)
+            if legacy.exists():
+                shutil.copytree(long_path(legacy), long_path(staging/'AppData'))
+            storage.write(staging/'.mcpy-owner.json', self.owner)
+            staging.rename(target)
+        storage.write(receipt, dict(expected, ready=True))
+        self._windows_root = target
+        self.data['network']['windows_profile'] = str(target)
+        return target
+
     def prepare_pack_cache(self, game_root, fingerprint):
         """Invalidate only this role's received packs when its host changes."""
         import re
@@ -111,7 +161,11 @@ class PlayerProfile:
         if not isinstance(fingerprint, str) or not re.fullmatch(r'[0-9a-f]{64}', fingerprint):
             raise EngineError('无法确认主机部署版本，未启动客机。', 'deployment_unavailable')
         cache = Path(game_root)/'packcache'
-        if not cache.resolve().is_relative_to(self.root.resolve()) or is_link(cache):
+        roots = [self.root.resolve()]
+        windows = getattr(self, '_windows_root', None)
+        if windows is not None and storage.read(windows/'.mcpy-owner.json') == self.owner:
+            roots.append(windows.resolve())
+        if not any(cache.resolve().is_relative_to(root) for root in roots) or is_link(cache):
             raise EngineError('客机包缓存指向了外部目录，已保留原内容。', 'profile_modified')
         receipt = self.root/'received-packs.json'
         try:

{mcpywrap-0.5.2 → mcpywrap-0.5.4}/mcpywrap.egg-info/PKG-INFO

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

{mcpywrap-0.5.2 → mcpywrap-0.5.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mcpywrap"
-version = "0.5.2"
+version = "0.5.4"
 description = "A wrapper for Minecraft China Edition Addons management"
 readme = "README.md"
 authors = [{name = "boybook", email = "boybook@easecation.net"}]

{mcpywrap-0.5.2 → mcpywrap-0.5.4}/skills/mcpywrap/references/dual-clients.md

@@ -12,6 +12,8 @@
 
 本次双客户端入口仅用于 `--local`。`--remote` 仍按远端单会话能力使用；不支持时不回退到本机。双客户端暂不提供两个真实账号登录，不反复复用同一 MCS 身份尝试绕过服务器登录限制。
 
+Windows 0.5.3 起，角色的实际游戏资料保存在项目所在磁盘 `mcpy-profiles/<摘要>` 的独立目录，以兼容下载包脚本加载器；组记录与占用锁仍在项目内。旧资料自动复制迁移并保留备份，后续使用新目录。查看会话 `network.windows_profile` 或角色的 `windows-profile.json` 确认位置，不将此目录当作可随意删除的缓存。迁移未完成、归属冲突或已迁移目录缺失时先保留现场；不要删记录、回退旧身份或共享真实用户 AppData 来绕过。磁盘根目录不可写时会启动失败，不自动提权。
+
 ## 启动并确认
 
 以下命令的全局参数都放在子命令之前：

{mcpywrap-0.5.2 → mcpywrap-0.5.4}/skills/mcpywrap/references/project-scripts.md

@@ -83,3 +83,22 @@ Ctrl+C、任务 timeout 或本次 session 的 stop 请求会取消任务并回
 **脚本对源码的写入不会自动回滚。** 脚本失败会阻止本次 builder/启动，但源码中的半成品可能被下一次构建或已开启 watcher 读取。批量生成时暂停 watcher；单文件可使用上述包外临时文件和原子替换。多个文件的替换不构成事务，工具不承诺“生成成功前绝不热更”。
 
 不要让脚本写入 `.mcpy/runtime`、`.runtime`、依赖缓存、全局游戏包或世界数据库。普通 build/package 使用源码生成结果，受管运行产物始终由原部署服务发布。资源文件更新、重载请求投递与游戏中实际生效是不同结果；组资源热更仍遵守现有不支持的限制。
+
+## 组装后、压缩前处理
+
+`local_capabilities` 包含 `package-finalize` 时，根项目可使用 `before_archive`。它在依赖组装完成后、ZIP写入前执行，不会重复运行消费者准备，也不在 build、run 或热更中执行。
+
+```toml
+[tool.mcpywrap.scripts.trim-release]
+python = "tools/prepare_release.py"
+timeout = 180
+
+[tool.mcpywrap.hooks]
+before_archive = ["trim-release"]
+```
+
+处理器从 `MCPY_PACKAGE_ROOT` 读取本次隔离组装目录；`MCPY_PROJECT_ROOT` 仍是源码根，工作目录也不变。只处理临时副本，不改依赖缓存或运行目录。入口应拒绝缺少该上下文的手动执行。
+
+用于裁剪未使用依赖或准备发布文件时，优先使用依赖官方工具并保留许可证；区分静态引用与动态导入。处理后检查实际文件，不能仅凭退出码宣称裁剪成功。不得修改 manifest 或包身份、引入文件／目录链接。任务失败时停止打包，原有 ZIP 保留；成功后仍须用实际生成的包验证游戏加载与受影响功能。
+
+`script list --effective --json` 的 `execution_order.before_archive` 会列出这个阶段。旧 CLI 遇到未知 hook 会拒绝，不能通过删除 hook 生成未经处理的发布包。

{mcpywrap-0.5.2 → mcpywrap-0.5.4}/tests/test_macos_network.py

@@ -40,6 +40,22 @@ class MacOSNetworkTests(unittest.TestCase):
     def call(self, *args):
         return CliRunner().invoke(cli, ['--local', '--project', str(self.root), '--non-interactive', *args, '--json'])
 
+    def test_network_launch_persists_prepared_phase_before_starting_game(self):
+        data = {'session': 'a' * 32, 'project': str(self.root), 'mode': 'network',
+                'launch': {'data': str(self.root/'data')}}
+        path = sessions.session_path(self.root, data['session'])/'session.json'
+
+        def launched(record):
+            self.assertEqual(json.loads(path.read_text())['phase'], 'prepared')
+            self.assertEqual(record['session'], data['session'])
+            return Mock()
+
+        with patch('mcpywrap.engines.preferences.NativePreferences'), \
+                patch.object(sessions, 'require_launch_requested') as requested, \
+                patch('mcpywrap.engines.macos.launch_session', side_effect=launched):
+            self.backend.launch(data, None)
+        requested.assert_called_once_with(data['project'], data['session'])
+
     def test_connect_does_not_read_project_or_create_world(self):
         (self.root/'pyproject.toml').write_text('broken = [')
         result = self.call('connect', 'localhost', '--port', '29132', '--detach')

{mcpywrap-0.5.2 → mcpywrap-0.5.4}/tests/test_project_scripts.py

@@ -77,6 +77,28 @@ class ScriptTests(unittest.TestCase):
             self.assertEqual(z.read('中文 project_bp/generated.json'),b'{"fresh":true}')
             self.assertFalse(any('tools/' in n for n in z.namelist()))
 
+    def test_archive_hook_changes_only_release_copy_and_keeps_previous_zip_on_failure(self):
+        import zipfile
+        unused = self.project/'behavior_pack/unused.py'
+        unused.write_text('unused = True')
+        self.configure("import os\nfrom pathlib import Path\np=Path(os.environ['MCPY_PACKAGE_ROOT'])\nnext(p.rglob('unused.py')).unlink()\n")
+        config = read_project(self.project)
+        config['tool']['mcpywrap']['hooks'] = {'before_archive': ['assets']}
+        write_project(self.project, config)
+        result = self.invoke('package', '--json')
+        self.assertEqual(result.exit_code, 0, result.output)
+        artifact = Path(json.loads(result.stdout)['artifact'])
+        original = artifact.read_bytes()
+        self.assertTrue(unused.exists())
+        with zipfile.ZipFile(artifact) as archive:
+            self.assertFalse(any(n.endswith('/unused.py') for n in archive.namelist()))
+        (self.project/'tools/generate.py').write_text(
+            "import os\nfrom pathlib import Path\np=next(Path(os.environ['MCPY_PACKAGE_ROOT']).rglob('manifest.json'))\np.write_bytes(p.read_bytes()+b' ')\n")
+        result = self.invoke('package', '--json')
+        self.assertNotEqual(result.exit_code, 0, result.output)
+        self.assertEqual(artifact.read_bytes(), original)
+        self.assertTrue(unused.exists())
+
     def test_skill_generator_example_builds_and_preserves_output_on_invalid_input(self):
         import re
         import zipfile

{mcpywrap-0.5.2 → mcpywrap-0.5.4}/tests/test_runtime_profiles.py

@@ -3,6 +3,7 @@ from pathlib import Path
 from tempfile import TemporaryDirectory
 from unittest.mock import Mock, patch
 import os
+import shutil
 import unittest
 
 from mcpywrap.runtime import groups, storage
@@ -13,6 +14,15 @@ from mcpywrap.engines.host import EngineError
 
 
 class ProfileTests(unittest.TestCase):
+    def windows_profile(self, profile):
+        root = profile.windows_directory()
+        def cleanup():
+            if root.exists():
+                self.assertEqual(storage.read(root/'.mcpy-owner.json'), profile.owner)
+                shutil.rmtree(root)
+        self.addCleanup(cleanup)
+        return root
+
     def setUp(self):
         self.temp = TemporaryDirectory()
         self.addCleanup(self.temp.cleanup)
@@ -119,6 +129,7 @@ class ProfileTests(unittest.TestCase):
     def test_child_known_folders_are_private_and_parent_environment_is_unchanged(self):
         profile = PlayerProfile(self.data(0))
         profile.prepare()
+        windows = self.windows_profile(profile)
         source = self.root/'source-appdata'
         options = source/'MinecraftPE_Netease/minecraftpe/options.txt'
         options.parent.mkdir(parents=True)
@@ -127,12 +138,57 @@ class ProfileTests(unittest.TestCase):
             before = dict(os.environ)
             environment = profile.windows_environment()
             self.assertEqual(dict(os.environ), before)
-        self.assertEqual(environment['USERPROFILE'], str(profile.root))
+        self.assertEqual(environment['USERPROFILE'], str(windows))
+        self.assertEqual(len(windows.parts), 3)
         target = Path(environment['APPDATA'])/'MinecraftPE_Netease/minecraftpe/options.txt'
         self.assertEqual(target.read_text(encoding='utf-8'), 'gfx_viewdistance:128\nkeyboard_type_0_key.forward:87\n')
         self.assertIn('private', options.read_text(encoding='utf-8'))
         self.assertFalse((target.parent/'clientId.txt').exists())
 
+    @unittest.skipUnless(os.name == 'nt', 'Windows profile layout')
+    def test_migration_preserves_identity_and_does_not_recopy_stale_data(self):
+        profile = PlayerProfile(self.data(0)); profile.prepare()
+        old = profile.root/'AppData/Roaming/MinecraftPE_Netease/minecraftpe/clientId.txt'
+        old.parent.mkdir(parents=True); old.write_bytes(b'original-player')
+        windows = self.windows_profile(profile)
+        new = windows/old.relative_to(profile.root)
+        self.assertEqual(new.read_bytes(), b'original-player')
+        self.assertEqual(old.read_bytes(), b'original-player')
+        new.write_bytes(b'updated-player')
+        self.assertEqual(profile.windows_directory(), windows)
+        self.assertEqual(new.read_bytes(), b'updated-player')
+        second = PlayerProfile(self.data(1)); second.prepare()
+        self.assertNotEqual(self.windows_profile(second), windows)
+        game = windows/'AppData/Roaming/MinecraftPE_Netease'
+        profile.prepare_pack_cache(game, 'a'*64)
+        cache = game/'packcache/old.py'; cache.parent.mkdir(); cache.write_text('old')
+        profile.prepare_pack_cache(game, 'b'*64)
+        self.assertFalse(cache.exists())
+        self.assertEqual(new.read_bytes(), b'updated-player')
+
+    @unittest.skipUnless(os.name == 'nt', 'Windows profile layout')
+    def test_migrated_profile_missing_or_replaced_never_resets_identity(self):
+        profile = PlayerProfile(self.data(0)); profile.prepare()
+        windows = self.windows_profile(profile)
+        backup = windows.with_name(windows.name+'.test-backup')
+        windows.rename(backup)
+        try:
+            with self.assertRaises(EngineError) as error:
+                profile.windows_directory()
+            self.assertEqual(error.exception.code, 'recovery_required')
+            self.assertFalse(windows.exists())
+        finally:
+            backup.rename(windows)
+        marker = windows/'.mcpy-owner.json'
+        storage.write(marker, {'owner': 'someone-else'})
+        try:
+            with self.assertRaises(EngineError) as error:
+                profile.windows_directory()
+            self.assertEqual(error.exception.code, 'profile_conflict')
+            self.assertEqual(storage.read(marker), {'owner': 'someone-else'})
+        finally:
+            storage.write(marker, profile.owner)
+
 
 if __name__ == '__main__':
     unittest.main()