shipit-cli 0.22.1__tar.gz → 0.23.0__tar.gz

{shipit_cli-0.22.1 → shipit_cli-0.23.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shipit-cli
-Version: 0.22.1
+Version: 0.23.0
 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.1 → shipit_cli-0.23.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "shipit-cli"
-version = "0.22.1"
+version = "0.23.0"
 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.1 → shipit_cli-0.23.0}/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.1 → shipit_cli-0.23.0}/src/shipit/providers/node.py

@@ -9,6 +9,8 @@ from pydantic import Field
 from pydantic_settings import SettingsConfigDict
 from semantic_version import NpmSpec, Version
 
+from shipit.ui import console
+
 from .base import Config, DetectResult
 from .install_context import discover_js_install_context
 
@@ -536,6 +538,12 @@ class NodeProvider:
         if config.commands.start and cls._is_node_command(config.commands.start):
             return DetectResult(cls.name(), 35)
 
+        package_json = cls.parse_package_json(path)
+        package_start = (
+            cls.package_scripts(package_json).get("start", "").strip()
+        )
+        package_score = 30 if package_start else 10
+
         if config.commands.install:
             install_commands = {
                 "npm install",
@@ -552,17 +560,17 @@ class NodeProvider:
                 "bun i",
             }
             if config.commands.install in install_commands:
-                return DetectResult(cls.name(), 30)
+                return DetectResult(cls.name(), package_score)
 
-        package_json = cls.parse_package_json(path)
         found_deps = cls._check_package_json_deps(
             package_json, *cls.FRAMEWORK_DEPENDENCIES
         )
         if cls.detect_framework(package_json, found_deps, path):
-            return DetectResult(cls.name(), 45)
+            framework_score = 45 if package_start else 10
+            return DetectResult(cls.name(), framework_score)
 
         if (path / "package.json").is_file():
-            return DetectResult(cls.name(), 30)
+            return DetectResult(cls.name(), package_score)
 
         if cls._common_entry_file(path, require_node_evidence=True):
             return DetectResult(cls.name(), 30)
@@ -917,28 +925,42 @@ class NodeProvider:
 
     @classmethod
     def infer_start_command(
-        cls, path: Path, package_json: Optional[Dict[str, Any]]
+        cls,
+        path: Path,
+        package_json: Optional[Dict[str, Any]],
+        *,
+        warn: bool = True,
     ) -> Optional[str]:
         scripts = cls.package_scripts(package_json)
         start_script = scripts.get("start")
-        if start_script:
-            return start_script.strip() or None
+        if start_script and start_script.strip():
+            return start_script.strip()
 
         if package_json:
             main = package_json.get("main")
             if isinstance(main, str) and main.strip():
                 return cls._node_entry_command(main.strip())
 
+        if warn and (path / "package.json").is_file():
+            console.print(
+                "[bold yellow]Warning:[/bold yellow] "
+                "no start or main script found in package.json"
+            )
+
         entry_file = cls._common_entry_file(
             path,
             require_node_evidence=not (path / "package.json").is_file(),
         )
         if entry_file:
             return cls._node_entry_command(entry_file)
-
+        if warn:
+            tried = ", ".join(cls.COMMON_ENTRY_FILES)
+            console.print(
+                "[bold yellow]Warning:[/bold yellow] "
+                f"no entry file found for Node project (tried: {tried})"
+            )
         return None
 
     @classmethod
     def _node_entry_command(cls, entry_file: str) -> str:
         return f"node {shlex.quote(entry_file)}"
-

{shipit_cli-0.22.1 → shipit_cli-0.23.0}/src/shipit/providers/python.py

@@ -6,6 +6,8 @@ from typing import List, Optional, Set
 from pydantic import Field
 from pydantic_settings import SettingsConfigDict
 
+from shipit.ui import console
+
 from .install_context import discover_python_dependency_files, discover_python_install_context
 from .base import DetectResult, _exists, Config
 
@@ -156,8 +158,88 @@ class PythonProvider:
             path, config.framework, config.main_file
         )
 
+        if not config.commands.start:
+            config.commands.start = cls.infer_start_command(config)
+
         return config
 
+    @staticmethod
+    def infer_start_command(
+        config: PythonConfig,
+        *,
+        warn: bool = True,
+    ) -> Optional[str]:
+        def cannot_infer(reason: str) -> Optional[str]:
+            if warn:
+                console.print(
+                    f"[bold yellow]Warning:[/bold yellow] {reason}"
+                )
+            return None
+
+        def missing_main_file() -> Optional[str]:
+            if config.framework:
+                return cannot_infer(
+                    "no main file was detected for the "
+                    f"{config.framework.name} framework"
+                )
+            return cannot_infer(
+                "no main file was detected for Python project"
+            )
+
+        main_file = config.main_file
+        asgi = config.asgi_application
+        wsgi = config.wsgi_application
+
+        if config.server == PythonServer.Daphne:
+            if asgi:
+                return f"daphne {asgi} --bind 0.0.0.0 --port $PORT"
+            return cannot_infer(
+                "no ASGI application was detected for the Daphne server"
+            )
+        if config.server == PythonServer.Uvicorn:
+            if asgi:
+                return f"uvicorn {asgi} --host 0.0.0.0 --port $PORT"
+            if wsgi:
+                return (
+                    f"uvicorn {wsgi} --interface=wsgi "
+                    "--host 0.0.0.0 --port $PORT"
+                )
+            if not main_file:
+                if config.framework:
+                    return missing_main_file()
+                return cannot_infer(
+                    "no main file, ASGI application, or WSGI application "
+                    "was detected for the Uvicorn server"
+                )
+        elif config.server == PythonServer.Hypercorn:
+            if asgi:
+                return f"hypercorn {asgi} --bind 0.0.0.0:$PORT"
+            return cannot_infer(
+                "no ASGI application was detected for the Hypercorn server"
+            )
+        elif config.framework == PythonFramework.Streamlit:
+            if main_file:
+                return (
+                    f"streamlit run {main_file} --server.port $PORT "
+                    "--server.address 0.0.0.0 --server.headless true"
+                )
+            return missing_main_file()
+        elif config.framework == PythonFramework.MCP:
+            if not main_file:
+                return missing_main_file()
+            if config.mcp_self_running:
+                return f"python {main_file}"
+            return (
+                f"python $VIRTUAL_ENV/bin/mcp run {main_file} "
+                "--transport=streamable-http"
+            )
+        elif config.framework == PythonFramework.Django:
+            return "python manage.py runserver 0.0.0.0:$PORT"
+
+        if main_file:
+            return f"python {main_file}"
+        return missing_main_file()
+
     @classmethod
     def check_deps(cls, path: Path, *deps: str) -> Set[str]:
         pending_deps = {dep.lower() for dep in deps}

{shipit_cli-0.22.1 → shipit_cli-0.23.0}/src/shipit/providers/staticfile.py

@@ -88,14 +88,65 @@ class StaticFileProvider:
             if _exists(
                 path, "index.html", "index.htm", "public/index.htm", "public/index.html"
             ):
-                return DetectResult(cls.name(), 10)
+                return DetectResult(cls.name(), 15)
             return DetectResult(cls.name(), 10)
         if config.commands.start and config.commands.start.startswith(
             "static-web-server "
         ):
             return DetectResult(cls.name(), 70)
+        if cls._is_unbuilt_node_static_site(path, config):
+            return DetectResult(cls.name(), 15)
         return None
 
+    @classmethod
+    def _is_unbuilt_node_static_site(
+        cls,
+        path: Path,
+        config: Config,
+    ) -> bool:
+        if not _exists(path, "index.html", "index.htm"):
+            return False
+
+        # Local imports avoid a module cycle: node-static composes this
+        # provider for its serving behavior.
+        from .node import NodeProvider
+        from .node_static import NodeStaticProvider
+
+        package_json = NodeProvider.parse_package_json(path)
+        if package_json is None:
+            return False
+
+        scripts = NodeProvider.package_scripts(package_json)
+        if scripts.get("start", "").strip():
+            return False
+        build_scripts = ("build", "generate", "export", "docs:build")
+        if config.commands.build or any(
+            scripts.get(name, "").strip() for name in build_scripts
+        ):
+            return False
+        if NodeStaticProvider.detect(path, config):
+            return False
+
+        found_runtime_deps = NodeProvider._check_package_json_deps(
+            package_json,
+            *NodeProvider.FRAMEWORK_DEPENDENCIES,
+        )
+        if NodeProvider.detect_framework(
+            package_json,
+            found_runtime_deps,
+            path,
+        ):
+            return False
+
+        return (
+            NodeProvider.infer_start_command(
+                path,
+                package_json,
+                warn=False,
+            )
+            is None
+        )
+
     @classmethod
     def _load_redirect_rules(cls, redirects_path: Path) -> list[RedirectRule]:
         rules: list[RedirectRule] = []

{shipit_cli-0.22.1 → shipit_cli-0.23.0}/src/shipit/runners/wasmer.py

@@ -31,8 +31,8 @@ SHIPIT_VERSION_ANNOTATION = "shipitcli.com/version"
 WASMER_APP_KIND_ANNOTATION = "wasmer.io/app-kind"
 WASMER_VERSION_ANNOTATION = "wasmer.io/version"
 BUILD_ANNOTATIONS_FILENAME = "build-annotations.yaml"
-EDGEJS_QUICKJS_DEPENDENCY = "wasmer/edgejs-quickjs@=0.0.7"
-PHPIX_VERSION = "0.3.0-rc.2"
+EDGEJS_QUICKJS_DEPENDENCY = "wasmer/edgejs-quickjs@=0.1.0"
+PHPIX_VERSION = "0.3.0-rc.3"
 
 
 def _phpix_dependency(php_version: str, bits: int) -> str:
@@ -260,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.).
@@ -272,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"]:

{shipit_cli-0.22.1 → shipit_cli-0.23.0}/src/shipit/starlib/tools/python.shipit

@@ -155,55 +155,18 @@ def python_build(config, source = None, app = None, venv = None, serving = True)
         local_venv = local_venv,
     )
 
-def python_commands(config, venv):
-    """start/after_deploy commands for the detected server and framework."""
-    asgi = config.asgi_application
-    wsgi = config.wsgi_application
-    main_file = config.main_file
-
-    start = None
-    if config.server == "daphne":
-        if not asgi:
-            fail("No ASGI application found for Daphne")
-        start = f"daphne {asgi} --bind 0.0.0.0 --port {PORT}"
-    elif config.server == "uvicorn":
-        if not main_file and not asgi and not wsgi:
-            fail("No ASGI or WSGI application found for Uvicorn and no main file found")
-        if asgi:
-            start = f"uvicorn {asgi} --host 0.0.0.0 --port {PORT}"
-        elif wsgi:
-            start = f"uvicorn {wsgi} --interface=wsgi --host 0.0.0.0 --port {PORT}"
-    elif config.server == "hypercorn":
-        if not asgi:
-            fail("No ASGI application found for Hypercorn")
-        start = f"hypercorn {asgi} --bind 0.0.0.0:{PORT}"
-    elif config.framework == "streamlit":
-        if not main_file:
-            fail("No main file found for Streamlit")
-        start = f"streamlit run {main_file} --server.port {PORT} --server.address 0.0.0.0 --server.headless true"
-    elif config.framework == "mcp":
-        if not main_file:
-            fail("No main file found for MCP")
-        if config.mcp_self_running:
-            start = "python " + main_file
-        else:
-            start = "python {}/bin/mcp run {} --transport=streamable-http".format(venv.serve_path, main_file)
-    elif config.framework == "django":
-        start = f"python manage.py runserver 0.0.0.0:{PORT}"
-
-    if not start and main_file:
-        start = "python " + main_file
-
+def python_commands(config):
+    """Commands resolved from the Python provider configuration."""
     commands = {}
-    if start:
-        commands["start"] = start
+    if config.commands.start:
+        commands["start"] = config.commands.start
     if config.migration_strategy == "django":
         commands["after_deploy"] = "python manage.py migrate"
     elif config.migration_strategy == "alembic":
         commands["after_deploy"] = "alembic upgrade head"
     return commands
 
-def python_env(config, app, site_packages):
+def python_env(config, app, venv, site_packages):
     app_path = app.serve_path
     if config.main_file and config.main_file.startswith("src/"):
         pythonpath = "{}:{}/src:{}".format(app_path, app_path, site_packages)
@@ -215,6 +178,8 @@ def python_env(config, app, site_packages):
     elif config.framework == "mcp":
         env_vars["FASTMCP_HOST"] = "0.0.0.0"
         env_vars["FASTMCP_PORT"] = PORT
+        if not config.mcp_self_running:
+            env_vars["VIRTUAL_ENV"] = venv.serve_path
     return env_vars
 
 def python_prepare(config, site_packages, app_serve_path):
@@ -256,8 +221,8 @@ def python_serve(
         name = name,
         cwd = app.serve_path,
         prepare = prepare if prepare != None else python_prepare(config, site_packages, app.serve_path),
-        env = python_env(config, app, site_packages),
-        commands = python_commands(config, venv),
+        env = python_env(config, app, venv, site_packages),
+        commands = python_commands(config),
         services = services if services != None else python_services(config),
         mounts = [app, venv],
         **overrides

{shipit_cli-0.22.1 → shipit_cli-0.23.0}/src/shipit/version.py

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

{shipit_cli-0.22.1 → shipit_cli-0.23.0}/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.1 → shipit_cli-0.23.0}/tests/test_node_provider.py

@@ -341,6 +341,18 @@ def test_node_start_command_uses_package_main(tmp_path: Path) -> None:
     assert provider_config.commands.start == "node src/server.js"
 
 
+def test_node_start_command_ignores_empty_script_and_uses_package_main(
+    tmp_path: Path,
+) -> None:
+    (tmp_path / "package.json").write_text(
+        '{"scripts": {"start": "  "}, "main": "src/server.js"}\n'
+    )
+
+    provider_config = NodeProvider.load_config(tmp_path, Config())
+
+    assert provider_config.commands.start == "node src/server.js"
+
+
 def test_node_start_command_uses_common_entry_file(tmp_path: Path) -> None:
     (tmp_path / "server.js").write_text(
         """const http = require("http");
@@ -356,6 +368,20 @@ http.createServer((_req, res) => {
     assert provider_config.commands.start == "node server.js"
 
 
+def test_node_provider_warns_when_start_command_is_missing(
+    tmp_path: Path,
+    capsys,
+) -> None:
+    (tmp_path / "package.json").write_text('{"name": "missing-start"}\n')
+
+    provider_config = NodeProvider.load_config(tmp_path, Config())
+
+    assert provider_config.commands.start is None
+    warning = capsys.readouterr().err
+    assert "Warning: no start or main script found in package.json" in warning
+    assert "Warning: no entry file found for Node project" in warning
+
+
 def test_node_build_steps_optimize_deps_prunes_then_node_modules(
     tmp_path: Path,
 ) -> None:

{shipit_cli-0.22.1 → shipit_cli-0.23.0}/tests/test_node_static_provider.py

@@ -6,7 +6,7 @@ from pydantic import ValidationError
 
 from shipit.generator import load_provider, load_provider_config
 from shipit.providers.base import Config
-from shipit.providers.node import NodeFramework, PackageManager
+from shipit.providers.node import NodeFramework, NodeProvider, PackageManager
 from shipit.providers.node_static import (
     NodeStaticConfig,
     NodeStaticProvider,
@@ -245,7 +245,9 @@ def test_pure_static_dependency_keeps_priority_with_package_script_command() ->
     assert detect_result.score == 60
 
 
-def test_explicit_next_build_command_uses_node_provider(tmp_path: Path) -> None:
+def test_next_build_without_start_command_uses_node_static(
+    tmp_path: Path,
+) -> None:
     (tmp_path / "package.json").write_text(
         """{
   "scripts": {
@@ -261,10 +263,13 @@ def test_explicit_next_build_command_uses_node_provider(tmp_path: Path) -> None:
     base_config.commands.build = "next build"
 
     detect_result = NodeStaticProvider.detect(tmp_path, base_config)
+    node_result = NodeProvider.detect(tmp_path, base_config)
 
     assert detect_result is not None
     assert detect_result.score == 20
-    assert load_provider(tmp_path, base_config) is not NodeStaticProvider
+    assert node_result is not None
+    assert node_result.score < detect_result.score
+    assert load_provider(tmp_path, base_config) is NodeStaticProvider
 
 
 def test_explicit_next_export_command_stays_node_static(tmp_path: Path) -> None: