shipit-cli 0.22.0__tar.gz → 0.22.2__tar.gz

{shipit_cli-0.22.0 → shipit_cli-0.22.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shipit-cli
-Version: 0.22.0
+Version: 0.22.2
 Summary: Shipit CLI is the best way to build, serve and deploy your projects anywhere.
 Project-URL: homepage, https://wasmer.io
 Project-URL: repository, https://github.com/wasmerio/shipit

{shipit_cli-0.22.0 → shipit_cli-0.22.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "shipit-cli"
-version = "0.22.0"
+version = "0.22.2"
 description = "Shipit CLI is the best way to build, serve and deploy your projects anywhere."
 readme = "README.md"
 requires-python = ">=3.10"

{shipit_cli-0.22.0 → shipit_cli-0.22.2}/src/shipit/assets/wordpress/install.sh

@@ -54,7 +54,11 @@ else
     --locale="$WP_LOCALE"
 
   echo "🔄 Setting permalinks"
-  wp rewrite structure '/%year%/%monthnum%/%day%/%postname%/'
+  # Avoid `wp rewrite structure`: it relaunches wp-cli in a subprocess to flush
+  # rewrites, which fails under WASIX (PHP_BINARY is empty) and aborts this
+  # script via `set -e`. Setting the option directly is equivalent, since we
+  # flush rewrites with `wp rewrite flush --hard` at the end of this script.
+  wp option update permalink_structure '/%year%/%monthnum%/%day%/%postname%/'
 fi
 
 # Install plugins from WP_PLUGINS environment variable

{shipit_cli-0.22.0 → shipit_cli-0.22.2}/src/shipit/runners/wasmer.py

@@ -29,7 +29,9 @@ SHIPIT_CONFIG_ANNOTATION = "shipitcli.com/config"
 SHIPIT_PROVIDER_ANNOTATION = "shipitcli.com/provider"
 SHIPIT_VERSION_ANNOTATION = "shipitcli.com/version"
 WASMER_APP_KIND_ANNOTATION = "wasmer.io/app-kind"
-EDGEJS_QUICKJS_DEPENDENCY = "wasmer/edgejs-quickjs@=0.0.7"
+WASMER_VERSION_ANNOTATION = "wasmer.io/version"
+BUILD_ANNOTATIONS_FILENAME = "build-annotations.yaml"
+EDGEJS_QUICKJS_DEPENDENCY = "wasmer/edgejs-quickjs@=0.1.0"
 PHPIX_VERSION = "0.3.0-rc.2"
 
 
@@ -41,7 +43,10 @@ def serialize_provider_config(provider_config: Any) -> Dict[str, Any]:
     if provider_config is None:
         return {}
     if hasattr(provider_config, "model_dump"):
-        return provider_config.model_dump(mode="json", exclude_none=True)
+        return provider_config.model_dump(
+            mode="json",
+            exclude_defaults=True,
+        )
     if isinstance(provider_config, dict):
         return provider_config
     return {}
@@ -255,9 +260,9 @@ class WasmerRunner:
             return Path("/opt") / name
 
     def prepare_config(self, provider_config: Any) -> Any:
-        from shipit.providers.python import PythonConfig
-        from shipit.providers.php import PhpConfig
         from shipit.providers.node import NodeConfig
+        from shipit.providers.php import PhpConfig
+        from shipit.providers.python import PythonConfig
 
         # Plan-visible overrides: the Shipit plan intentionally reacts to
         # these at evaluation time (cross-platform wheel builds etc.).
@@ -267,21 +272,15 @@ class WasmerRunner:
             )
             provider_config.cross_platform = "wasix_wasm32"
             provider_config.precompile_python = True
-
-        # Runner-only overrides: these feed app.yaml/wasmer.toml metadata
-        # (app kind, memory caps, runtime selection) but must NOT change the
-        # evaluated plan — with providers evaluated from config, a shared
-        # mutation here would silently flip e.g. php serving to phpix.
-        # phpix stays opt-in via project config/SHIPIT_PHPIX.
-        runner_config = provider_config.model_copy(deep=True)
-        if isinstance(runner_config, PhpConfig):
-            runner_config.phpix = True
-        if isinstance(runner_config, NodeConfig):
-            runner_config.use_edgejs = True
-            if runner_config.precompile_edgejs is None:
-                runner_config.precompile_edgejs = True
-            runner_config.remove_native_binaries = True
-        self.provider_config = runner_config
+        if isinstance(provider_config, PhpConfig):
+            provider_config.phpix = True
+        if isinstance(provider_config, NodeConfig):
+            provider_config.use_edgejs = True
+            if provider_config.precompile_edgejs is None:
+                provider_config.precompile_edgejs = True
+            provider_config.remove_native_binaries = True
+
+        self.provider_config = provider_config.model_copy(deep=True)
         return provider_config
 
     def prepare_build_steps(self, build_steps: List["Step"]) -> List["Step"]:
@@ -313,6 +312,7 @@ class WasmerRunner:
         return new_build_steps
 
     def build(self, serve: Serve) -> None:
+        self._write_build_annotations()
         self.build_prepare(serve)
         self.build_serve(serve)
 
@@ -635,6 +635,7 @@ class WasmerRunner:
 
         annotations = yaml_config.get("annotations", {})
         assert isinstance(annotations, dict), "annotations must be a dictionary"
+        annotations.update(self._load_build_annotations())
         annotations[SHIPIT_CONFIG_ANNOTATION] = serialize_provider_config(
             self.provider_config
         )
@@ -759,6 +760,36 @@ class WasmerRunner:
             env=env or os.environ,
         )
 
+    def _get_wasmer_version(self) -> str:
+        result = subprocess.run(
+            [self.bin, "--version"],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        output = result.stdout.strip()
+        name, separator, version = output.partition(" ")
+        if name.lower() != "wasmer" or not separator or not version:
+            raise ValueError(f"Unexpected Wasmer version output: {output!r}")
+        return version
+
+    def _write_build_annotations(self) -> None:
+        self.wasmer_dir_path.mkdir(parents=True, exist_ok=True)
+        annotations_path = self.wasmer_dir_path / BUILD_ANNOTATIONS_FILENAME
+        annotations_path.write_text(
+            yaml.dump({WASMER_VERSION_ANNOTATION: self._get_wasmer_version()})
+        )
+
+    def _load_build_annotations(self) -> Dict[str, Any]:
+        annotations_path = self.wasmer_dir_path / BUILD_ANNOTATIONS_FILENAME
+        if not annotations_path.exists():
+            return {}
+        annotations = yaml.safe_load(annotations_path.read_text()) or {}
+        assert isinstance(annotations, dict), (
+            f"{BUILD_ANNOTATIONS_FILENAME} must contain a dictionary"
+        )
+        return annotations
+
     def _update_app_yaml(
         self, app_owner: Optional[str] = None, app_name: Optional[str] = None
     ) -> None:

{shipit_cli-0.22.0 → shipit_cli-0.22.2}/src/shipit/version.py

@@ -1,7 +1,7 @@
 __all__ = ["version", "version_info"]
 
 
-version = "0.22.0"  # x-release-please-version
+version = "0.22.2"  # x-release-please-version
 _version_parts = version.split(".")
 version_info = (
     int(_version_parts[0]),

{shipit_cli-0.22.0 → shipit_cli-0.22.2}/tests/test_e2e.py

@@ -201,7 +201,7 @@ def _e2e_case_params(cases: list[E2ECase]) -> list[object]:
         E2ECase(
             path="examples/php-nobuild",
             serve_pattern=(
-                r"PHP 8\.3\.[0-9]+ Development Server \(http://localhost:[\d]+\) started"
+                r"listening addr"
             ),
             http=[HTTPRequest(path="/", body_match=r"PHP Version 8\.3\.[0-9]+")],
         ),
@@ -209,7 +209,7 @@ def _e2e_case_params(cases: list[E2ECase]) -> list[object]:
         E2ECase(
             path="examples/php-nobuild",
             serve_pattern=(
-                r"PHP 8\.3\.[0-9]+ Development Server \(http://localhost:[\d]+\) started"
+                r"listening addr"
             ),
             http=[HTTPRequest(path="/", body_match=r"PHP Version 8\.3\.[0-9]+")],
         ),
@@ -217,7 +217,7 @@ def _e2e_case_params(cases: list[E2ECase]) -> list[object]:
         E2ECase(
             path="examples/php-api",
             serve_pattern=(
-                r"PHP 8\.3\.[0-9]+ Development Server \(http://localhost:[\d]+\) started"
+                r"listening addr"
             ),
             http=[
                 HTTPRequest(
@@ -231,7 +231,7 @@ def _e2e_case_params(cases: list[E2ECase]) -> list[object]:
         E2ECase(
             path="examples/php-wordpress",
             serve_pattern=(
-                r"PHP 8\.3\.[0-9]+ Development Server \(http://localhost:[\d]+\) started"
+                r"listening addr"
             ),
             http=[HTTPRequest(path="/", body_match=r"WordPress")],
         ),
@@ -342,7 +342,7 @@ def _e2e_case_params(cases: list[E2ECase]) -> list[object]:
         E2ECase(
             path="examples/php-wordpress",
             serve_pattern=(
-                r"PHP 8\.3\.[0-9]+ Development Server \(http://localhost:[\d]+\) started"
+                r"listening addr"
             ),
             http=[HTTPRequest(path="/", body_match=r"WordPress")],
             extra_env={"SHIPIT_PHPIX": "true"},
@@ -352,7 +352,7 @@ def _e2e_case_params(cases: list[E2ECase]) -> list[object]:
         E2ECase(
             path="examples/php-nobuild",
             serve_pattern=(
-                r"PHP 8\.3\.[0-9]+ Development Server \(http://localhost:[\d]+\) started"
+                r"listening addr"
             ),
             http=[HTTPRequest(path="/", body_match=r"PHP Version 8\.3\.[0-9]+")],
             extra_env={"SHIPIT_PHPIX": "true"},
@@ -534,7 +534,7 @@ def _e2e_case_params(cases: list[E2ECase]) -> list[object]:
             path="examples/node-astro",
             serve_pattern=r"Node|Astro|Listening|ready",
             http=[HTTPRequest(path="/", body_match=r"Astro Node Example")],
-            build_modes=(BuildMode.Local,),
+            build_modes=(BuildMode.Local, BuildMode.Wasmer),
         ),
         # Hugo static site (built via Hugo, served with static-web-server)
         E2ECase(

{shipit_cli-0.22.0 → shipit_cli-0.22.2}/tests/test_wasmer_annotations.py

@@ -1,3 +1,4 @@
+import subprocess
 import tomllib
 from pathlib import Path
 
@@ -5,9 +6,14 @@ import pytest
 import yaml
 
 from shipit.providers.node import NodeConfig
-from shipit.providers.php import PhpFramework
+from shipit.providers.php import PhpConfig, PhpFramework
 from shipit.providers.python import PythonConfig, PythonFramework
-from shipit.runners.wasmer import WasmerRunner, resolve_app_kind
+from shipit.runners.wasmer import (
+    BUILD_ANNOTATIONS_FILENAME,
+    WasmerRunner,
+    resolve_app_kind,
+    serialize_provider_config,
+)
 from shipit.shipit_types import Package, Serve, Volume
 from shipit.version import version as shipit_version
 
@@ -54,7 +60,32 @@ def test_resolve_app_kind(
     assert resolve_app_kind(provider, framework) == expected
 
 
-def test_wasmer_app_yaml_adds_python_annotations(tmp_path: Path) -> None:
+def test_serialize_provider_config_excludes_defaults() -> None:
+    assert serialize_provider_config(PythonConfig()) == {}
+    assert serialize_provider_config(
+        PythonConfig(framework=PythonFramework.Django)
+    ) == {"framework": "django"}
+
+
+@pytest.mark.parametrize("phpix", [False, True])
+def test_wasmer_prepare_config_enables_phpix(
+    tmp_path: Path,
+    phpix: bool,
+) -> None:
+    src_dir = tmp_path / "src"
+    src_dir.mkdir()
+    runner = WasmerRunner(DummyBuildBackend(tmp_path), src_dir)
+
+    config = runner.prepare_config(PhpConfig(phpix=phpix))
+
+    assert config.phpix is True
+    assert runner.provider_config.phpix is True
+
+
+def test_wasmer_app_yaml_adds_python_annotations(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
     src_dir = tmp_path / "src"
     src_dir.mkdir()
     (src_dir / "app.yaml").write_text(
@@ -63,6 +94,7 @@ def test_wasmer_app_yaml_adds_python_annotations(tmp_path: Path) -> None:
 
     runner = WasmerRunner(DummyBuildBackend(tmp_path), src_dir)
     runner.prepare_config(PythonConfig(framework=PythonFramework.Django))
+    monkeypatch.setattr(runner, "_get_wasmer_version", lambda: "7.2.0")
 
     serve = Serve(
         name="django",
@@ -76,16 +108,23 @@ def test_wasmer_app_yaml_adds_python_annotations(tmp_path: Path) -> None:
         },
     )
 
-    runner.build_serve(serve)
+    runner.build(serve)
 
     app_yaml = yaml.safe_load((runner.wasmer_dir_path / "app.yaml").read_text())
     annotations = app_yaml["annotations"]
+    build_annotations = yaml.safe_load(
+        (runner.wasmer_dir_path / BUILD_ANNOTATIONS_FILENAME).read_text()
+    )
 
+    assert build_annotations == {"wasmer.io/version": "7.2.0"}
     assert annotations["example.com/existing"] == "keep"
     assert annotations["shipitcli.com/provider"] == "python"
     assert annotations["shipitcli.com/version"] == shipit_version
     assert annotations["wasmer.io/app-kind"] == "django"
+    assert annotations["wasmer.io/version"] == "7.2.0"
     assert annotations["shipitcli.com/config"]["framework"] == "django"
+    assert "python_version" not in annotations["shipitcli.com/config"]
+    assert "precompile_python" not in annotations["shipitcli.com/config"]
     assert (
         annotations["shipitcli.com/config"]["cross_platform"]
         == "wasix_wasm32"
@@ -184,6 +223,28 @@ def test_wasmer_run_command_inherits_stdio(
     }
 
 
+def test_get_wasmer_version(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    src_dir = tmp_path / "src"
+    src_dir.mkdir()
+    runner = WasmerRunner(DummyBuildBackend(tmp_path), src_dir, bin="wasmer")
+
+    def fake_run(*args, **kwargs):
+        assert args == (["wasmer", "--version"],)
+        assert kwargs == {
+            "check": True,
+            "capture_output": True,
+            "text": True,
+        }
+        return subprocess.CompletedProcess(args[0], 0, stdout="wasmer 7.2.0\n")
+
+    monkeypatch.setattr("shipit.runners.wasmer.subprocess.run", fake_run)
+
+    assert runner._get_wasmer_version() == "7.2.0"
+
+
 def test_wasmer_node_manifest_maps_to_edgejs(tmp_path: Path) -> None:
     src_dir = tmp_path / "src"
     src_dir.mkdir()
@@ -201,7 +262,7 @@ def test_wasmer_node_manifest_maps_to_edgejs(tmp_path: Path) -> None:
     runner.build_serve(serve)
 
     manifest = tomllib.loads((runner.wasmer_dir_path / "wasmer.toml").read_text())
-    assert manifest["dependencies"]["wasmer/edgejs-quickjs"] == "=0.0.7"
+    assert manifest["dependencies"]["wasmer/edgejs-quickjs"] == "=0.1.0"
     assert manifest["command"][0]["module"] == "wasmer/edgejs-quickjs:edge"
     wasi = manifest["command"][0]["annotations"]["wasi"]
     assert wasi["main-args"] == ["--bytecode-cache", "server.js"]
@@ -277,15 +338,12 @@ def test_wasmer_prepare_config_enables_node_edge_optimizations(
 
     config = runner.prepare_config(NodeConfig())
 
-    # Runner metadata (app.yaml/wasmer.toml) sees the edge optimizations...
     assert runner.provider_config.use_edgejs is True
     assert runner.provider_config.precompile_edgejs is True
     assert runner.provider_config.remove_native_binaries is True
-    # ...but the plan config the Shipit file is evaluated with is untouched,
-    # so per-run runner flags cannot silently change the build plan.
-    assert config.use_edgejs is False
-    assert config.precompile_edgejs is None
-    assert config.remove_native_binaries is False
+    assert config.use_edgejs is True
+    assert config.precompile_edgejs is True
+    assert config.remove_native_binaries is True
 
 
 def test_wasmer_prepare_config_preserves_node_precompile_override(

{shipit_cli-0.22.0 → shipit_cli-0.22.2}/tests/test_wordpress_phpix.py

@@ -190,6 +190,24 @@ def test_generate_shipit_wordpress_phpix_mode(tmp_path: Path) -> None:
     )
 
 
+def test_wasmer_enables_phpix_before_evaluating_plan(tmp_path: Path) -> None:
+    project_dir = tmp_path / "my-plugin"
+    _write_plugin(project_dir)
+
+    _provider_cls, provider_config, generated = _generate_for_path(project_dir)
+    assert provider_config.phpix is False
+
+    runner = WasmerRunner(DummyBuildBackend(tmp_path), project_dir)
+    provider_config = runner.prepare_config(provider_config)
+    _backend, _ctx, serve = _evaluate_generated(
+        project_dir, provider_config, generated, tmp_path
+    )
+
+    assert any(pkg.name == "phpix" for pkg in serve.deps)
+    assert not any(pkg.name == "php" for pkg in serve.deps)
+    assert serve.commands["start"].startswith("phpix ")
+
+
 def test_wasmer_app_yaml_sets_memory_limit_for_wordpress_phpix(
     tmp_path: Path,
 ) -> None: