create-maa-project 1.2.2__tar.gz → 1.2.3__tar.gz

{create_maa_project-1.2.2 → create_maa_project-1.2.3}/.release/create-maa-project-manifest.json

@@ -1,68 +1,68 @@
 {
     "schemaVersion": 1,
     "name": "create-maa-project",
-    "version": "1.2.2",
-    "tag": "v1.2.2",
+    "version": "1.2.3",
+    "tag": "v1.2.3",
     "assets": [
         {
             "kind": "sea",
             "os": "linux",
             "arch": "aarch64",
-            "version": "1.2.2",
+            "version": "1.2.3",
             "name": "create-maa-project-linux-aarch64",
-            "url": "https://github.com/Windsland52/create-maa-project/releases/download/v1.2.2/create-maa-project-linux-aarch64",
-            "sha256": "302f1b94b68ead54ccfd7da68c5f0631fe2ea354469cc59da9238325cec6cc8f",
+            "url": "https://github.com/Windsland52/create-maa-project/releases/download/v1.2.3/create-maa-project-linux-aarch64",
+            "sha256": "8a6eda1cabb647e0df9ba8f2e12e273317089a97b43c465a54e3b5dc1ef0bc73",
             "size": 123145344
         },
         {
             "kind": "sea",
             "os": "linux",
             "arch": "x86_64",
-            "version": "1.2.2",
+            "version": "1.2.3",
             "name": "create-maa-project-linux-x86_64",
-            "url": "https://github.com/Windsland52/create-maa-project/releases/download/v1.2.2/create-maa-project-linux-x86_64",
-            "sha256": "8ee14bcb3fafea060891cf98b2a131381065c7053019ac4eb1d6dffc4fa36ff6",
+            "url": "https://github.com/Windsland52/create-maa-project/releases/download/v1.2.3/create-maa-project-linux-x86_64",
+            "sha256": "f4cb775d3d85aba1475ef041d654de13a06cdf17801bc479648bd75e351932b5",
             "size": 125045952
         },
         {
             "kind": "sea",
             "os": "macos",
             "arch": "aarch64",
-            "version": "1.2.2",
+            "version": "1.2.3",
             "name": "create-maa-project-macos-aarch64",
-            "url": "https://github.com/Windsland52/create-maa-project/releases/download/v1.2.2/create-maa-project-macos-aarch64",
-            "sha256": "b5cac2f528e7029224283dd7f623f85b6ab6199476ee6d29742d3323352119e4",
+            "url": "https://github.com/Windsland52/create-maa-project/releases/download/v1.2.3/create-maa-project-macos-aarch64",
+            "sha256": "d0fe39da998fdde748ea5477618a705dad9adfb45ea8d34e17c8aa63430b943b",
             "size": 121408240
         },
         {
             "kind": "sea",
             "os": "macos",
             "arch": "x86_64",
-            "version": "1.2.2",
+            "version": "1.2.3",
             "name": "create-maa-project-macos-x86_64",
-            "url": "https://github.com/Windsland52/create-maa-project/releases/download/v1.2.2/create-maa-project-macos-x86_64",
-            "sha256": "05bb2f42843ce33bcb76e2dd701050ce224905bb08e5c620a4a6c62d7bb5da85",
-            "size": 124472240
+            "url": "https://github.com/Windsland52/create-maa-project/releases/download/v1.2.3/create-maa-project-macos-x86_64",
+            "sha256": "68364953c76c81d8426ebaf2fc571296ecedc81f3f2f3c2e2f75146d98e7e16c",
+            "size": 124476368
         },
         {
             "kind": "sea",
             "os": "win",
             "arch": "aarch64",
-            "version": "1.2.2",
+            "version": "1.2.3",
             "name": "create-maa-project-win-aarch64.exe",
-            "url": "https://github.com/Windsland52/create-maa-project/releases/download/v1.2.2/create-maa-project-win-aarch64.exe",
-            "sha256": "a554bdc37a181d7a407b1027effe5913a33833cea59c7707e1ec1fdd01df6342",
-            "size": 82560000
+            "url": "https://github.com/Windsland52/create-maa-project/releases/download/v1.2.3/create-maa-project-win-aarch64.exe",
+            "sha256": "68c26c233b409357e8873b014918c71bc3012addf9678315e4273180d2760ff3",
+            "size": 82565120
         },
         {
             "kind": "sea",
             "os": "win",
             "arch": "x86_64",
-            "version": "1.2.2",
+            "version": "1.2.3",
             "name": "create-maa-project-win-x86_64.exe",
-            "url": "https://github.com/Windsland52/create-maa-project/releases/download/v1.2.2/create-maa-project-win-x86_64.exe",
-            "sha256": "8a70811812de26fe0b9b51eb7908bd411351bfdbfe20da857bae82fb6d86db5c",
-            "size": 94026240
+            "url": "https://github.com/Windsland52/create-maa-project/releases/download/v1.2.3/create-maa-project-win-x86_64.exe",
+            "sha256": "e730e080a811fc901ea7c1932792452118d6468676bdb6560af491e0b8e796ff",
+            "size": 94031360
         }
     ]
 }

{create_maa_project-1.2.2 → create_maa_project-1.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: create-maa-project
-Version: 1.2.2
+Version: 1.2.3
 Summary: 用于创建和维护 MaaFW 应用项目的脚手架 CLI / Scaffold and maintenance CLI for MaaFW application projects
 Project-URL: Homepage, https://github.com/Windsland52/create-maa-project
 Project-URL: Source, https://github.com/Windsland52/create-maa-project

{create_maa_project-1.2.2 → create_maa_project-1.2.3}/package.json

@@ -1,6 +1,6 @@
 {
     "name": "create-maa-project",
-    "version": "1.2.2",
+    "version": "1.2.3",
     "description": "用于创建和维护 MaaFW 应用项目的脚手架 CLI / Scaffold and maintenance CLI for MaaFW application projects",
     "keywords": [
         "maafw",

create_maa_project-1.2.3/py-wrapper/create_maa_project/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.2.3"

create_maa_project-1.2.3/py-wrapper/create_maa_project/release_manifest.py

@@ -0,0 +1,2 @@
+# Filled by the release workflow when publishing the PyPI wrapper.
+RELEASE_MANIFEST_SHA256 = "63b2a8f2fb60bed85e531ca81d842844cad9c8cfc4c53865c9b7e61dc4cf79a8"

{create_maa_project-1.2.2 → create_maa_project-1.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "create-maa-project"
-version = "1.2.2"
+version = "1.2.3"
 description = "用于创建和维护 MaaFW 应用项目的脚手架 CLI / Scaffold and maintenance CLI for MaaFW application projects"
 keywords = ["maafw", "scaffold", "mcp"]
 readme = "README.md"

{create_maa_project-1.2.2 → create_maa_project-1.2.3}/templates/addons/github/tools/build-release.mjs

@@ -10,11 +10,13 @@ import {
     statSync,
     writeFileSync,
 } from "node:fs";
+import {createHash} from "node:crypto";
 import {basename, dirname, join} from "node:path";
 
 const dryRun = process.argv.includes("--dry-run");
 const projectSlug = {{projectSlug}};
 const releaseArtifactName = {{releaseArtifactName}};
+const requirementsMarker = ".create-maa-project-requirements.sha256";
 mkdirSync("dist", {recursive: true});
 
 const lock = readJson("maa-project.lock.json");
@@ -278,6 +280,7 @@ function prepareReleasePackage(guiKey, gui, packagePaths, interfaceJson, runtime
     }
     if (packageHasAgent(interfaceJson) && hasEmbeddedPythonRuntime(runtimePlatform)) {
         copyPath(pythonRuntimePath(runtimePlatform), join(pkgDir, "python"));
+        writeEmbeddedRequirementsMarker(pkgDir);
     }
     if (!gui.flatLayout) {
         prepareMxuMaafwRuntime(pkgDir, runtimePlatform);
@@ -364,6 +367,17 @@ function smokeReleasePackage(gui, root, packagePaths, runtimePlatform) {
         if (!existsSync(join(root, "agent", "bootstrap.py"))) {
             throw new Error("release package smoke failed: Agent bootstrap is missing");
         }
+        if (hasEmbeddedPythonRuntime(runtimePlatform)) {
+            const markerPath = join(root, "python", requirementsMarker);
+            if (!existsSync(markerPath)) {
+                throw new Error("release package smoke failed: Python requirements marker is missing");
+            }
+            const expectedDigest = requirementsDigest(join(root, "requirements.txt"));
+            const actualDigest = readFileSync(markerPath, "utf8").trim();
+            if (actualDigest !== expectedDigest) {
+                throw new Error("release package smoke failed: Python requirements marker does not match requirements.txt");
+            }
+        }
     }
     assertUnixExecutablePermissions(root, runtimePlatform);
     for (const path of [
@@ -409,6 +423,15 @@ function copyDirectoryContents(source, target) {
     }
 }
 
+function requirementsDigest(requirementsPath) {
+    return createHash("sha256").update(readFileSync(requirementsPath)).digest("hex");
+}
+
+function writeEmbeddedRequirementsMarker(pkgDir) {
+    const digest = requirementsDigest(join(pkgDir, "requirements.txt"));
+    writeFileSync(join(pkgDir, "python", requirementsMarker), digest + "\n", "utf8");
+}
+
 function shouldCopyAgentPath(source) {
     const name = basename(source).toLowerCase();
     return name !== "__pycache__" && !name.endsWith(".pyc") && !name.endsWith(".pyo");

{create_maa_project-1.2.2 → create_maa_project-1.2.3}/templates/agent/agent/bootstrap.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import errno
 import hashlib
 import importlib.metadata
 import json
@@ -8,14 +9,19 @@ import runpy
 import shutil
 import subprocess
 import sys
+import time
+from collections.abc import Generator
+from contextlib import contextmanager
 from datetime import UTC, datetime
 from pathlib import Path
-from typing import Any
+from typing import Any, BinaryIO
 
 PYTHON_MIN = (3, 13)
 PYTHON_MAX = (3, 14)
 VENV_NAME = ".venv"
 REQUIREMENTS_MARKER = ".create-maa-project-requirements.sha256"
+REQUIREMENTS_LOCK = ".create-maa-project-requirements.lock"
+REQUIREMENTS_LOCK_TIMEOUT_SECONDS = 300.0
 DEFAULT_PIP_CONFIG = {
     "enable_pip_install": True,
     "mirror": "https://pypi.tuna.tsinghua.edu.cn/simple",
@@ -172,23 +178,26 @@ def find_requirements_file(project_root: Path) -> Path:
 
 
 def ensure_requirements_installed(project_root: Path, requirements: Path, digest: str) -> None:
-    if not needs_requirement_install(project_root, digest):
-        return
-
-    pip_config = read_pip_config(project_root)
-    if not pip_config.get("enable_pip_install", True):
-        warn(project_root, "pip install is disabled by config/pip_config.json")
-        return
-
-    if install_from_local_wheels(project_root, requirements) or install_from_indexes(
-        project_root,
-        requirements,
-        pip_config,
-    ):
-        write_requirements_marker(project_root, digest)
-        return
+    with requirements_install_lock(project_root):
+        # Another Agent may have completed the installation while this process
+        # waited for the shared environment lock.
+        if not needs_requirement_install(project_root, digest):
+            return
+
+        pip_config = read_pip_config(project_root)
+        if not pip_config.get("enable_pip_install", True):
+            warn(project_root, "pip install is disabled by config/pip_config.json")
+            return
+
+        if install_from_local_wheels(project_root, requirements) or install_from_indexes(
+            project_root,
+            requirements,
+            pip_config,
+        ):
+            write_requirements_marker(project_root, digest)
+            return
 
-    warn(project_root, "Python dependencies were not installed successfully")
+        warn(project_root, "Python dependencies were not installed successfully")
 
 
 def needs_requirement_install(project_root: Path, digest: str) -> bool:
@@ -203,16 +212,121 @@ def needs_requirement_install(project_root: Path, digest: str) -> bool:
 def requirements_marker(project_root: Path) -> Path:
     if is_running_in_project_venv(project_root):
         return venv_dir(project_root) / REQUIREMENTS_MARKER
+    if is_running_in_embedded_python(project_root):
+        return project_root / "python" / REQUIREMENTS_MARKER
     return project_root / "debug" / REQUIREMENTS_MARKER
 
 
+def is_running_in_embedded_python(project_root: Path) -> bool:
+    try:
+        return Path(sys.executable).resolve().is_relative_to((project_root / "python").resolve())
+    except OSError:
+        return False
+
+
+def requirements_lock_path(project_root: Path) -> Path:
+    return requirements_marker(project_root).with_name(REQUIREMENTS_LOCK)
+
+
+@contextmanager
+def requirements_install_lock(
+    project_root: Path,
+    timeout_seconds: float = REQUIREMENTS_LOCK_TIMEOUT_SECONDS,
+) -> Generator[None]:
+    lock_path = requirements_lock_path(project_root)
+    try:
+        lock_path.parent.mkdir(parents=True, exist_ok=True)
+        handle = lock_path.open("a+b")
+    except OSError as error:
+        warn(project_root, "failed to open Python requirements install lock: " + str(error))
+        raise SystemExit(1) from error
+
+    with handle:
+        try:
+            ensure_lock_file_byte(handle)
+        except OSError as error:
+            warn(project_root, "failed to initialize Python requirements install lock: " + str(error))
+            raise SystemExit(1) from error
+
+        deadline = time.monotonic() + timeout_seconds
+        waiting_logged = False
+        while True:
+            try:
+                acquired = try_lock_file(handle)
+            except OSError as error:
+                warn(project_root, "failed to acquire Python requirements install lock: " + str(error))
+                raise SystemExit(1) from error
+            if acquired:
+                break
+            if not waiting_logged:
+                log(project_root, "waiting for Python requirements install lock: " + str(lock_path))
+                waiting_logged = True
+            if time.monotonic() >= deadline:
+                warn(project_root, "timed out waiting for Python requirements install lock: " + str(lock_path))
+                raise SystemExit(1)
+            time.sleep(0.1)
+
+        log(project_root, "acquired Python requirements install lock: " + str(lock_path))
+        try:
+            yield
+        finally:
+            try:
+                unlock_file(handle)
+            except OSError as error:
+                warn(project_root, "failed to release Python requirements install lock: " + str(error))
+
+
+def ensure_lock_file_byte(handle: BinaryIO) -> None:
+    handle.seek(0, 2)
+    if handle.tell() == 0:
+        handle.write(b"\0")
+        handle.flush()
+    handle.seek(0)
+
+
+def try_lock_file(handle: BinaryIO) -> bool:
+    handle.seek(0)
+    try:
+        if sys.platform.startswith("win"):
+            import msvcrt
+
+            msvcrt.locking(handle.fileno(), msvcrt.LK_NBLCK, 1)
+        else:
+            import fcntl
+
+            fcntl.flock(handle.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+    except OSError as error:
+        if error.errno in (errno.EACCES, errno.EAGAIN):
+            return False
+        raise
+    return True
+
+
+def unlock_file(handle: BinaryIO) -> None:
+    handle.seek(0)
+    if sys.platform.startswith("win"):
+        import msvcrt
+
+        msvcrt.locking(handle.fileno(), msvcrt.LK_UNLCK, 1)
+    else:
+        import fcntl
+
+        fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
+
+
 def write_requirements_marker(project_root: Path, digest: str) -> None:
     marker = requirements_marker(project_root)
+    temp_marker = marker.with_name(marker.name + ".tmp")
     try:
         marker.parent.mkdir(parents=True, exist_ok=True)
-        marker.write_text(digest + "\n", encoding="utf8")
+        temp_marker.write_text(digest + "\n", encoding="utf8")
+        temp_marker.replace(marker)
     except OSError as error:
         warn(project_root, "failed to write requirements marker: " + str(error))
+        try:
+            temp_marker.unlink(missing_ok=True)
+        except OSError:
+            pass
 
 
 def install_from_local_wheels(project_root: Path, requirements: Path) -> bool:
@@ -320,15 +434,18 @@ def check_maafw(project_root: Path) -> None:
     except importlib.metadata.PackageNotFoundError:
         warn(project_root, "Python package maafw is not installed")
         return
+    if not version:
+        warn(project_root, "Python package maafw has invalid or incomplete metadata")
+        return
     log(project_root, "maafw " + version)
 
 
 def is_package_installed(name: str) -> bool:
     try:
-        importlib.metadata.version(name)
+        version = importlib.metadata.version(name)
     except importlib.metadata.PackageNotFoundError:
         return False
-    return True
+    return bool(version)
 
 
 def command_output(error: subprocess.CalledProcessError) -> str:

{create_maa_project-1.2.2 → create_maa_project-1.2.3}/tests/scaffold.test.ts

@@ -2465,6 +2465,12 @@ jobs:
         expect(await pathExists(join(projectRoot, 'dist/package-mfaa/deps/maafw-0.0.0-py3-none-any.whl'))).toBe(true)
       } else {
         expect(await pathExists(join(projectRoot, 'dist/package-mfaa', expectedChildExec))).toBe(true)
+        const packagedRequirements = await readFile(join(projectRoot, 'dist/package-mfaa/requirements.txt'))
+        const packagedMarker = await readFile(
+          join(projectRoot, 'dist/package-mfaa/python/.create-maa-project-requirements.sha256'),
+          'utf8',
+        )
+        expect(packagedMarker).toBe(`${sha256(packagedRequirements)}\n`)
       }
       if (!runtimePlatform.startsWith('win-') && process.platform !== 'win32') {
         expect(

create_maa_project-1.2.3/tests/test_agent_bootstrap.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+import importlib.util
+import multiprocessing
+import tempfile
+import time
+import unittest
+from contextlib import nullcontext
+from pathlib import Path
+from unittest.mock import patch
+
+
+BOOTSTRAP_PATH = Path(__file__).resolve().parents[1] / "templates" / "agent" / "agent" / "bootstrap.py"
+SPEC = importlib.util.spec_from_file_location("agent_bootstrap_template", BOOTSTRAP_PATH)
+if SPEC is None or SPEC.loader is None:
+    raise RuntimeError("unable to load Agent bootstrap template")
+agent_bootstrap = importlib.util.module_from_spec(SPEC)
+SPEC.loader.exec_module(agent_bootstrap)
+
+
+def acquire_requirements_lock_and_touch(project_root: str, touched_path: str) -> None:
+    with agent_bootstrap.requirements_install_lock(Path(project_root), timeout_seconds=5.0):
+        Path(touched_path).write_text("acquired\n", encoding="utf8")
+
+
+class AgentBootstrapRequirementsTest(unittest.TestCase):
+    def test_external_maafw_without_marker_does_not_skip_requirements(self) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            project_root = Path(temp_dir)
+            with patch.object(agent_bootstrap, "is_package_installed", return_value=True):
+                with patch.object(agent_bootstrap, "is_running_in_project_venv", return_value=False):
+                    self.assertTrue(agent_bootstrap.needs_requirement_install(project_root, "digest"))
+
+    def test_matching_marker_skips_reinstall_when_maafw_is_available(self) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            project_root = Path(temp_dir)
+            marker = project_root / "debug" / agent_bootstrap.REQUIREMENTS_MARKER
+            marker.parent.mkdir()
+            marker.write_text("digest\n", encoding="utf8")
+
+            with patch.object(agent_bootstrap, "is_package_installed", return_value=True):
+                with patch.object(agent_bootstrap, "is_running_in_project_venv", return_value=False):
+                    self.assertFalse(agent_bootstrap.needs_requirement_install(project_root, "digest"))
+
+    def test_system_python_bin_is_not_treated_as_embedded(self) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            project_root = Path(temp_dir)
+            with patch.object(agent_bootstrap.sys, "executable", "/usr/bin/python3"):
+                self.assertFalse(agent_bootstrap.is_running_in_embedded_python(project_root))
+
+    def test_macos_packaged_python_path_is_treated_as_embedded(self) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            project_root = Path(temp_dir)
+            embedded_python = project_root / "python" / "bin" / "python3"
+            with patch.object(agent_bootstrap.sys, "executable", str(embedded_python)):
+                self.assertTrue(agent_bootstrap.is_running_in_embedded_python(project_root))
+
+    def test_project_venv_marker_takes_priority_over_embedded_runtime(self) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            project_root = Path(temp_dir)
+            with patch.object(agent_bootstrap, "is_running_in_project_venv", return_value=True):
+                with patch.object(agent_bootstrap, "is_running_in_embedded_python", return_value=True):
+                    marker = agent_bootstrap.requirements_marker(project_root)
+
+            self.assertEqual(marker, project_root / ".venv" / agent_bootstrap.REQUIREMENTS_MARKER)
+
+    def test_waiting_installer_rechecks_marker_after_acquiring_lock(self) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            project_root = Path(temp_dir)
+            requirements = project_root / "requirements.txt"
+            requirements.write_text("maafw==1.0.0\n", encoding="utf8")
+
+            with patch.object(agent_bootstrap, "requirements_install_lock", return_value=nullcontext()):
+                with patch.object(agent_bootstrap, "needs_requirement_install", return_value=False):
+                    with patch.object(agent_bootstrap, "install_from_local_wheels") as install_local:
+                        with patch.object(agent_bootstrap, "install_from_indexes") as install_indexes:
+                            agent_bootstrap.ensure_requirements_installed(project_root, requirements, "digest")
+
+            install_local.assert_not_called()
+            install_indexes.assert_not_called()
+
+    def test_requirements_lock_retries_and_releases(self) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            project_root = Path(temp_dir)
+
+            with patch.object(agent_bootstrap, "try_lock_file", side_effect=[False, True]):
+                with patch.object(agent_bootstrap, "unlock_file") as unlock:
+                    with patch.object(agent_bootstrap.time, "monotonic", side_effect=[0.0, 0.0]):
+                        with patch.object(agent_bootstrap.time, "sleep") as sleep:
+                            with agent_bootstrap.requirements_install_lock(project_root, timeout_seconds=1.0):
+                                pass
+
+            sleep.assert_called_once_with(0.1)
+            unlock.assert_called_once()
+
+    def test_requirements_lock_timeout_stops_bootstrap(self) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            project_root = Path(temp_dir)
+
+            with patch.object(agent_bootstrap, "try_lock_file", return_value=False):
+                with patch.object(agent_bootstrap.time, "monotonic", side_effect=[0.0, 2.0]):
+                    with patch.object(agent_bootstrap, "warn") as warn:
+                        with self.assertRaises(SystemExit):
+                            with agent_bootstrap.requirements_install_lock(project_root, timeout_seconds=1.0):
+                                pass
+
+            warn.assert_called_once()
+
+    def test_requirements_lock_serializes_processes(self) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            project_root = Path(temp_dir)
+            touched_path = project_root / "second-process-acquired"
+            process = multiprocessing.get_context("spawn").Process(
+                target=acquire_requirements_lock_and_touch,
+                args=(str(project_root), str(touched_path)),
+            )
+
+            with agent_bootstrap.requirements_install_lock(project_root, timeout_seconds=5.0):
+                process.start()
+                time.sleep(0.3)
+                self.assertFalse(touched_path.exists())
+
+            process.join(timeout=5.0)
+            self.assertEqual(process.exitcode, 0)
+            self.assertTrue(touched_path.exists())
+
+    def test_requirements_marker_is_written_atomically(self) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            project_root = Path(temp_dir)
+            with patch.object(agent_bootstrap, "is_running_in_project_venv", return_value=False):
+                with patch.object(agent_bootstrap, "is_running_in_embedded_python", return_value=False):
+                    agent_bootstrap.write_requirements_marker(project_root, "digest")
+
+            marker = project_root / "debug" / agent_bootstrap.REQUIREMENTS_MARKER
+            self.assertEqual(marker.read_text(encoding="utf8"), "digest\n")
+            self.assertFalse(marker.with_name(marker.name + ".tmp").exists())
+
+    def test_empty_package_version_is_not_installed(self) -> None:
+        with patch.object(agent_bootstrap.importlib.metadata, "version", return_value=None):
+            self.assertFalse(agent_bootstrap.is_package_installed("maafw"))
+
+    def test_empty_maafw_version_reports_invalid_metadata(self) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            project_root = Path(temp_dir)
+            with patch.object(agent_bootstrap.importlib.metadata, "version", return_value=None):
+                with patch.object(agent_bootstrap, "warn") as warn:
+                    agent_bootstrap.check_maafw(project_root)
+
+            warn.assert_called_once_with(project_root, "Python package maafw has invalid or incomplete metadata")
+
+
+if __name__ == "__main__":
+    unittest.main()

create_maa_project-1.2.2/py-wrapper/create_maa_project/__init__.py

@@ -1 +0,0 @@
-__version__ = "1.2.2"

create_maa_project-1.2.2/py-wrapper/create_maa_project/release_manifest.py

@@ -1,2 +0,0 @@
-# Filled by the release workflow when publishing the PyPI wrapper.
-RELEASE_MANIFEST_SHA256 = "5c42a0a01b4e2c34e18d8e8adba50bb541ecff5529a84d298b869e29e4864b41"

create_maa_project-1.2.2/tests/test_agent_bootstrap.py

@@ -1,39 +0,0 @@
-from __future__ import annotations
-
-import importlib.util
-import tempfile
-import unittest
-from pathlib import Path
-from unittest.mock import patch
-
-
-BOOTSTRAP_PATH = Path(__file__).resolve().parents[1] / "templates" / "agent" / "agent" / "bootstrap.py"
-SPEC = importlib.util.spec_from_file_location("agent_bootstrap_template", BOOTSTRAP_PATH)
-if SPEC is None or SPEC.loader is None:
-    raise RuntimeError("unable to load Agent bootstrap template")
-agent_bootstrap = importlib.util.module_from_spec(SPEC)
-SPEC.loader.exec_module(agent_bootstrap)
-
-
-class AgentBootstrapRequirementsTest(unittest.TestCase):
-    def test_external_maafw_without_marker_does_not_skip_requirements(self) -> None:
-        with tempfile.TemporaryDirectory() as temp_dir:
-            project_root = Path(temp_dir)
-            with patch.object(agent_bootstrap, "is_package_installed", return_value=True):
-                with patch.object(agent_bootstrap, "is_running_in_project_venv", return_value=False):
-                    self.assertTrue(agent_bootstrap.needs_requirement_install(project_root, "digest"))
-
-    def test_matching_marker_skips_reinstall_when_maafw_is_available(self) -> None:
-        with tempfile.TemporaryDirectory() as temp_dir:
-            project_root = Path(temp_dir)
-            marker = project_root / "debug" / agent_bootstrap.REQUIREMENTS_MARKER
-            marker.parent.mkdir()
-            marker.write_text("digest\n", encoding="utf8")
-
-            with patch.object(agent_bootstrap, "is_package_installed", return_value=True):
-                with patch.object(agent_bootstrap, "is_running_in_project_venv", return_value=False):
-                    self.assertFalse(agent_bootstrap.needs_requirement_install(project_root, "digest"))
-
-
-if __name__ == "__main__":
-    unittest.main()