shipit-cli 0.18.0__tar.gz → 0.18.2__tar.gz

{shipit_cli-0.18.0 → shipit_cli-0.18.2}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "shipit-cli"
-version = "0.18.0"
+version = "0.18.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.18.0 → shipit_cli-0.18.2}/src/shipit/assets/php/php.ini

@@ -40,7 +40,7 @@ doc_root =
 user_dir =
 enable_dl = Off
 file_uploads = On
-upload_max_filesize = 2G
+upload_max_filesize = 1.5Gb
 max_input_vars = 6144
 max_file_uploads = 20
 allow_url_fopen = On

{shipit_cli-0.18.0 → shipit_cli-0.18.2}/src/shipit/assets/wordpress/install.sh

@@ -11,10 +11,6 @@ WP_LOCALE=${WP_LOCALE:-"en_US"}
 WP_SITEURL=${WP_SITEURL:-"http://localhost"}
 WP_SITE_TITLE=${WP_SITE_TITLE:-"WordPress"}
 
-wp() {
-  php /opt/assets/wp-cli.phar --allow-root --path=/app "$@"
-}
-
 echo "🚀 Starting WordPress setup..."
 
 echo "Creating required directories..."

{shipit_cli-0.18.0 → shipit_cli-0.18.2}/src/shipit/providers/php.py

@@ -1,6 +1,7 @@
 import json
+from enum import Enum
 from pathlib import Path
-from typing import Dict, Optional, Literal
+from typing import Any, Dict, Literal, Optional
 
 from .base import (
     DetectResult,
@@ -12,12 +13,14 @@ from .base import (
     VolumeSpec,
     Config,
 )
-from enum import Enum
 from pydantic_settings import SettingsConfigDict
 
+
 class PhpFramework(Enum):
     Laravel = "laravel"
+    Moodle = "moodle"
     Symfony = "symfony"
+    Drupal = "drupal"
 
 
 class PhpConfig(Config):
@@ -37,8 +40,83 @@ class PhpProvider:
         self.path = path
         self.config = config
 
+    @staticmethod
+    def load_composer_config(path: Path) -> dict[str, Any] | None:
+        composer_path = path / "composer.json"
+        if not composer_path.exists():
+            return None
+        try:
+            composer_config = json.loads(composer_path.read_text())
+        except json.JSONDecodeError:
+            return None
+        if not isinstance(composer_config, dict):
+            return None
+        return composer_config
+
+    @staticmethod
+    def composer_packages(composer_config: dict[str, Any] | None) -> set[str]:
+        if not composer_config:
+            return set()
+
+        packages: set[str] = set()
+        for section in ("require", "require-dev"):
+            deps = composer_config.get(section)
+            if isinstance(deps, dict):
+                packages.update(str(name).lower() for name in deps)
+
+        package_name = composer_config.get("name")
+        if isinstance(package_name, str):
+            packages.add(package_name.lower())
+        return packages
+
+    @classmethod
+    def detect_framework(
+        cls,
+        path: Path,
+        composer_config: dict[str, Any] | None = None,
+    ) -> PhpFramework | None:
+        composer_config = composer_config or cls.load_composer_config(path)
+        composer_packages = cls.composer_packages(composer_config)
+
+        has_moodle_layout = (
+            (path / "version.php").exists()
+            and (path / "lib" / "setup.php").exists()
+            and (
+                (path / "admin" / "cli" / "install.php").exists()
+                or (path / "mod").is_dir()
+                or (path / "theme").is_dir()
+            )
+        )
+        if has_moodle_layout:
+            return PhpFramework.Moodle
+
+        drupal_packages = {
+            "drupal/core",
+            "drupal/core-composer-scaffold",
+            "drupal/core-recommended",
+            "drupal/drupal",
+            "drupal/recommended-project",
+        }
+        has_drupal_layout = (
+            (path / "core" / "lib" / "Drupal.php").exists()
+            or (path / "web" / "core" / "lib" / "Drupal.php").exists()
+        )
+        if has_drupal_layout or composer_packages & drupal_packages:
+            return PhpFramework.Drupal
+
+        if (path / "artisan").exists() and (path / "composer.json").exists():
+            return PhpFramework.Laravel
+
+        if (path / "symfony.lock").exists() or any(
+            package.startswith("symfony/") for package in composer_packages
+        ):
+            return PhpFramework.Symfony
+
+        return None
+
     @classmethod
     def load_config(cls, path: Path, base_config: Config) -> PhpConfig:
+        composer_config = cls.load_composer_config(path)
         use_composer = (
             _exists(path, "composer.json", "composer.lock")
             or (
@@ -48,17 +126,21 @@ class PhpProvider:
             or False
         )
         composer_build_script = None
-        if use_composer:
-            composer_config = json.load(open(path / "composer.json"))
-            if "scripts" in composer_config:
-                assert isinstance(composer_config["scripts"], dict), "Scripts must be a dictionary"
-                composer_build_script = "post-update-cmd" if "post-update-cmd" in composer_config["scripts"] else None
-                if not composer_build_script and "post-install-cmd" in composer_config["scripts"]:
+        if composer_config:
+            scripts = composer_config.get("scripts")
+            if isinstance(scripts, dict):
+                composer_build_script = (
+                    "post-update-cmd" if "post-update-cmd" in scripts else None
+                )
+                if not composer_build_script and "post-install-cmd" in scripts:
                     composer_build_script = "post-install-cmd"
-        config = PhpConfig(use_composer=use_composer, composer_build_script=composer_build_script, **base_config.model_dump())
+        config = PhpConfig(
+            use_composer=use_composer,
+            composer_build_script=composer_build_script,
+            **base_config.model_dump(),
+        )
         if not config.framework:
-            if _exists(path, "symfony.lock"):
-                config.framework = PhpFramework.Symfony
+            config.framework = cls.detect_framework(path, composer_config)
         return config
 
     @classmethod
@@ -69,11 +151,23 @@ class PhpProvider:
     def detect(
         cls, path: Path, config: Config
     ) -> Optional[DetectResult]:
-        if _exists(path, "composer.json") and _exists(path, "public/index.php"):
+        framework = cls.detect_framework(path)
+        if framework == PhpFramework.Drupal and (path / "web" / "index.php").exists():
+            return DetectResult(cls.name(), 70)
+        if framework in {
+            PhpFramework.Drupal,
+            PhpFramework.Moodle,
+            PhpFramework.Symfony,
+        } and _exists(path, "index.php", "public/index.php", "web/index.php"):
+            return DetectResult(cls.name(), 65)
+        if (path / "composer.json").exists() and _exists(
+            path, "public/index.php", "web/index.php"
+        ):
             return DetectResult(cls.name(), 60)
         if (
             _exists(path, "index.php")
             or _exists(path, "public/index.php")
+            or _exists(path, "web/index.php")
             or _exists(path, "app/index.php")
         ):
             return DetectResult(cls.name(), 10)
@@ -160,6 +254,16 @@ class PhpProvider:
     def base_commands(self) -> Dict[str, str]:
         php_script = "phpix" if self.config.phpix else "php"
 
+        if (
+            self.config.framework == PhpFramework.Drupal
+            and _exists(self.path, "web/index.php")
+        ):
+            return {
+                "start": (
+                    f'"{php_script} -S localhost:{{}} -t '
+                    '{}/web".format(PORT, app.serve_path)'
+                )
+            }
         if _exists(self.path, "public/index.php"):
             return {
                 "start": f'"{php_script} -S localhost:{{}} -t {{}}/public".format(PORT, app.serve_path)'

{shipit_cli-0.18.0 → shipit_cli-0.18.2}/src/shipit/providers/wordpress.py

@@ -76,7 +76,11 @@ class WordPressProvider(PhpProvider):
             steps.append(
                 'copy("wordpress/.htaccess", "{}/.htaccess".format(app.path), base="assets")'
             )
-        return steps + super().build_steps()
+        return steps + super().build_steps_with_options(
+            extra_ignore=["wp-content"],
+            after_install=None,
+            after_build=None
+        )
 
     def prepare_steps(self) -> Optional[list[str]]:
         return super().prepare_steps()
@@ -90,7 +94,7 @@ class WordPressProvider(PhpProvider):
                     '-t {}".format(assets.serve_path, PORT, app.serve_path)'
                 )
         return {
-            # "wp": '"php {}/wp-cli.phar --allow-root --path={}".format(assets.serve_path, app.serve_path)',
+            "wp": '"php {}/wp-cli.phar --allow-root --path={}".format(assets.serve_path, app.serve_path)',
             "after_deploy": '"bash {}/setup-wp.sh".format(assets.serve_path)',
             **commands,
         }

{shipit_cli-0.18.0 → shipit_cli-0.18.2}/src/shipit/runners/wasmer.py

@@ -1,6 +1,5 @@
+from enum import Enum
 from functools import reduce
-from shipit.shipit_types import EnvStep
-from shipit.shipit_types import UseStep
 import hashlib
 import json
 import os
@@ -17,7 +16,7 @@ from tomlkit import array, aot, comment, document, nl, string, table
 
 from shipit.builders.base import BuildBackend
 from shipit.runners.base import Runner
-from shipit.shipit_types import Package, PrepareStep, Serve
+from shipit.shipit_types import EnvStep, Package, PrepareStep, Serve, UseStep
 from shipit.ui import console, write_stderr, write_stdout
 from shipit.version import version as shipit_version
 
@@ -25,6 +24,46 @@ if TYPE_CHECKING:
     from shipit.shipit_types import Step
 
 
+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"
+
+
+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_defaults=True)
+    if isinstance(provider_config, dict):
+        return provider_config
+    return {}
+
+
+def resolve_app_kind(provider: str, framework: Any = None) -> Optional[str]:
+    if provider == "wordpress":
+        return "wordpress"
+
+    if isinstance(framework, Enum):
+        framework = framework.value
+    if framework is None:
+        return None
+
+    provider_name = {
+        "node": "javascript",
+        "node-static": "javascript",
+    }.get(provider, provider)
+    framework_name = str(framework).lower()
+    app_kinds = {
+        "python": {"django", "mcp"},
+        "php": {"moodle", "drupal"},
+        "javascript": {"ghost", "strapi"},
+    }
+    if framework_name in app_kinds.get(provider_name, set()):
+        return framework_name
+    return None
+
+
 class MapperItem(TypedDict, total=False):
     dependencies: Dict[str, str]
     scripts: Set[str]
@@ -172,6 +211,7 @@ class WasmerRunner:
         self.wasmer_registry = registry
         self.wasmer_token = token
         self.bin = bin or "wasmer"
+        self.provider_config: Any = None
 
     def get_serve_mount_path(self, name: str) -> Path:
         if name == "app":
@@ -188,6 +228,7 @@ class WasmerRunner:
             )
             provider_config.cross_platform = "wasix_wasm32"
             provider_config.precompile_python = True
+        self.provider_config = provider_config
         return provider_config
 
     def prepare_build_steps(self, build_steps: List["Step"]) -> List["Step"]:
@@ -525,6 +566,21 @@ class WasmerRunner:
             )
             yaml_config["jobs"] = jobs
 
+        annotations = yaml_config.get("annotations", {})
+        assert isinstance(annotations, dict), "annotations must be a dictionary"
+        annotations[SHIPIT_CONFIG_ANNOTATION] = serialize_provider_config(
+            self.provider_config
+        )
+        annotations[SHIPIT_VERSION_ANNOTATION] = shipit_version
+        annotations[SHIPIT_PROVIDER_ANNOTATION] = serve.provider
+        app_kind = resolve_app_kind(
+            serve.provider,
+            getattr(self.provider_config, "framework", None),
+        )
+        if app_kind:
+            annotations[WASMER_APP_KIND_ANNOTATION] = app_kind
+        yaml_config["annotations"] = annotations
+
         app_yaml = yaml.dump(yaml_config)
 
         console.print(f"\n[bold]Created app.yaml manifest ✅[/bold]")

shipit_cli-0.18.2/src/shipit/version.py

@@ -0,0 +1,5 @@
+__all__ = ["version", "version_info"]
+
+
+version = "0.18.2"
+version_info = (0, 18, 2, "final", 0)

shipit_cli-0.18.2/tests/test_wasmer_annotations.py

@@ -0,0 +1,93 @@
+from pathlib import Path
+
+import pytest
+import yaml
+
+from shipit.providers.php import PhpFramework
+from shipit.providers.python import PythonConfig, PythonFramework
+from shipit.runners.wasmer import WasmerRunner, resolve_app_kind
+from shipit.shipit_types import Package, Serve
+from shipit.version import version as shipit_version
+
+
+class DummyBuildBackend:
+    def __init__(self, root: Path) -> None:
+        self.root = root
+
+    def build(self, name, env, mounts, steps) -> None:
+        raise NotImplementedError
+
+    def get_build_mount_path(self, name: str) -> Path:
+        return self.root / "build" / name
+
+    def get_artifact_mount_path(self, name: str) -> Path:
+        path = self.root / "artifacts" / name
+        path.mkdir(parents=True, exist_ok=True)
+        return path
+
+    def get_runtime_path(self) -> str | None:
+        return None
+
+
+@pytest.mark.parametrize(
+    ("provider", "framework", "expected"),
+    [
+        ("wordpress", None, "wordpress"),
+        ("python", PythonFramework.Django, "django"),
+        ("python", PythonFramework.MCP, "mcp"),
+        ("php", PhpFramework.Moodle, "moodle"),
+        ("php", PhpFramework.Drupal, "drupal"),
+        ("javascript", "ghost", "ghost"),
+        ("javascript", "strapi", "strapi"),
+        ("node-static", "ghost", "ghost"),
+        ("python", "fastapi", None),
+    ],
+)
+def test_resolve_app_kind(
+    provider: str,
+    framework: object,
+    expected: str | None,
+) -> None:
+    assert resolve_app_kind(provider, framework) == expected
+
+
+def test_wasmer_app_yaml_adds_python_annotations(tmp_path: Path) -> None:
+    src_dir = tmp_path / "src"
+    src_dir.mkdir()
+    (src_dir / "app.yaml").write_text(
+        yaml.dump({"annotations": {"example.com/existing": "keep"}})
+    )
+
+    runner = WasmerRunner(DummyBuildBackend(tmp_path), src_dir)
+    runner.prepare_config(PythonConfig(framework=PythonFramework.Django))
+
+    serve = Serve(
+        name="django",
+        provider="python",
+        build=[],
+        deps=[Package("python")],
+        commands={
+            "start": (
+                "python -m uvicorn example.asgi --host 0.0.0.0 --port 8080"
+            ),
+        },
+    )
+
+    runner.build_serve(serve)
+
+    app_yaml = yaml.safe_load((runner.wasmer_dir_path / "app.yaml").read_text())
+    annotations = app_yaml["annotations"]
+
+    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["shipitcli.com/config"]["framework"] == "django"
+    assert (
+        annotations["shipitcli.com/config"]["cross_platform"]
+        == "wasix_wasm32"
+    )
+    assert (
+        annotations["shipitcli.com/config"]["python_extra_index_url"]
+        == "https://pythonindex.wasix.org/simple"
+    )

{shipit_cli-0.18.0 → shipit_cli-0.18.2}/tests/test_wordpress_phpix.py

@@ -7,6 +7,7 @@ from shipit.providers.base import Config
 from shipit.providers.wordpress import WordPressProvider
 from shipit.runners.wasmer import WasmerRunner
 from shipit.shipit_types import Mount, Package, Serve, Service
+from shipit.version import version as shipit_version
 
 
 class DummyBuildBackend:
@@ -59,6 +60,13 @@ def test_wasmer_app_yaml_sets_memory_limit_for_wordpress_phpix(
     src_dir.mkdir()
 
     runner = WasmerRunner(DummyBuildBackend(tmp_path), src_dir)
+    provider_config = load_provider_config(
+        WordPressProvider,
+        src_dir,
+        Config(),
+        {"phpix": True},
+    )
+    runner.prepare_config(provider_config)
     serve = Serve(
         name="wordpress",
         provider="wordpress",
@@ -85,3 +93,7 @@ def test_wasmer_app_yaml_sets_memory_limit_for_wordpress_phpix(
     assert app_yaml["capabilities"]["memory"]["limit"] == "2Gb"
     assert app_yaml["enable_email"] is True
     assert app_yaml["env"]["PHPIX_PHP_THREADS"] == "4"
+    assert app_yaml["annotations"]["shipitcli.com/config"]["phpix"] is True
+    assert app_yaml["annotations"]["shipitcli.com/provider"] == "wordpress"
+    assert app_yaml["annotations"]["shipitcli.com/version"] == shipit_version
+    assert app_yaml["annotations"]["wasmer.io/app-kind"] == "wordpress"

shipit_cli-0.18.0/src/shipit/version.py

@@ -1,5 +0,0 @@
-__all__ = ["version", "version_info"]
-
-
-version = "0.18.0"
-version_info = (0, 18, 0, "final", 0)